=============================================================================== 0010cdfc <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10cdfc: 55 push %ebp 10cdfd: 89 e5 mov %esp,%ebp 10cdff: 53 push %ebx 10ce00: 83 ec 04 sub $0x4,%esp 10ce03: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce06: 8b 15 44 88 12 00 mov 0x128844,%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 ); 10ce0c: 9c pushf 10ce0d: fa cli 10ce0e: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce0f: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce12: 85 c9 test %ecx,%ecx 10ce14: 75 0b jne 10ce21 <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce16: 50 push %eax 10ce17: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce18: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce1f: eb 72 jmp 10ce93 <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce21: 49 dec %ecx 10ce22: 75 0f jne 10ce33 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce24: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce27: 49 dec %ecx 10ce28: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce2b: 85 c9 test %ecx,%ecx 10ce2d: 74 04 je 10ce33 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce2f: 50 push %eax 10ce30: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce31: eb 60 jmp 10ce93 <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce33: 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; 10ce3a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10ce41: 50 push %eax 10ce42: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10ce43: 83 ec 0c sub $0xc,%esp 10ce46: 53 push %ebx 10ce47: e8 68 15 00 00 call 10e3b4 <_Thread_queue_Dequeue> if ( next ) { 10ce4c: 83 c4 10 add $0x10,%esp 10ce4f: 85 c0 test %eax,%eax 10ce51: 74 40 je 10ce93 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ce53: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce57: 75 09 jne 10ce62 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ce59: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10ce60: eb 31 jmp 10ce93 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10ce62: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10ce65: 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 ); 10ce6c: 83 ec 0c sub $0xc,%esp 10ce6f: 53 push %ebx 10ce70: e8 2b 19 00 00 call 10e7a0 <_Thread_queue_First> if ( !next || 10ce75: 83 c4 10 add $0x10,%esp 10ce78: 85 c0 test %eax,%eax 10ce7a: 74 17 je 10ce93 <_CORE_RWLock_Release+0x97> 10ce7c: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce80: 74 11 je 10ce93 <_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; 10ce82: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10ce85: 52 push %edx 10ce86: 52 push %edx 10ce87: 50 push %eax 10ce88: 53 push %ebx 10ce89: e8 06 18 00 00 call 10e694 <_Thread_queue_Extract> } 10ce8e: 83 c4 10 add $0x10,%esp 10ce91: eb d9 jmp 10ce6c <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10ce93: 31 c0 xor %eax,%eax 10ce95: 8b 5d fc mov -0x4(%ebp),%ebx 10ce98: c9 leave 10ce99: c3 ret =============================================================================== 0010ce9c <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10ce9c: 55 push %ebp 10ce9d: 89 e5 mov %esp,%ebp 10ce9f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cea2: 8d 45 f4 lea -0xc(%ebp),%eax 10cea5: 50 push %eax 10cea6: ff 75 08 pushl 0x8(%ebp) 10cea9: e8 aa 11 00 00 call 10e058 <_Thread_Get> switch ( location ) { 10ceae: 83 c4 10 add $0x10,%esp 10ceb1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10ceb5: 75 17 jne 10cece <_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 ); 10ceb7: 83 ec 0c sub $0xc,%esp 10ceba: 50 push %eax 10cebb: e8 ac 19 00 00 call 10e86c <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10cec0: a1 f4 82 12 00 mov 0x1282f4,%eax 10cec5: 48 dec %eax 10cec6: a3 f4 82 12 00 mov %eax,0x1282f4 10cecb: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cece: c9 leave 10cecf: c3 ret =============================================================================== 00117364 <_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 ) { 117364: 55 push %ebp 117365: 89 e5 mov %esp,%ebp 117367: 57 push %edi 117368: 56 push %esi 117369: 53 push %ebx 11736a: 83 ec 1c sub $0x1c,%esp 11736d: 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; 117370: 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 ) { 117375: 8b 55 10 mov 0x10(%ebp),%edx 117378: 3b 53 4c cmp 0x4c(%ebx),%edx 11737b: 77 4e ja 1173cb <_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 ) { 11737d: 83 7b 48 00 cmpl $0x0,0x48(%ebx) 117381: 75 09 jne 11738c <_CORE_message_queue_Broadcast+0x28> 117383: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 11738a: eb 23 jmp 1173af <_CORE_message_queue_Broadcast+0x4b> *count = 0; 11738c: 8b 45 1c mov 0x1c(%ebp),%eax 11738f: c7 00 00 00 00 00 movl $0x0,(%eax) 117395: eb 32 jmp 1173c9 <_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; 117397: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11739a: 8b 42 2c mov 0x2c(%edx),%eax 11739d: 89 c7 mov %eax,%edi 11739f: 8b 75 0c mov 0xc(%ebp),%esi 1173a2: 8b 4d 10 mov 0x10(%ebp),%ecx 1173a5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 1173a7: 8b 42 28 mov 0x28(%edx),%eax 1173aa: 8b 55 10 mov 0x10(%ebp),%edx 1173ad: 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 = 1173af: 83 ec 0c sub $0xc,%esp 1173b2: 53 push %ebx 1173b3: e8 9c 22 00 00 call 119654 <_Thread_queue_Dequeue> 1173b8: 89 c2 mov %eax,%edx 1173ba: 83 c4 10 add $0x10,%esp 1173bd: 85 c0 test %eax,%eax 1173bf: 75 d6 jne 117397 <_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; 1173c1: 8b 55 e4 mov -0x1c(%ebp),%edx 1173c4: 8b 45 1c mov 0x1c(%ebp),%eax 1173c7: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1173c9: 31 c0 xor %eax,%eax } 1173cb: 8d 65 f4 lea -0xc(%ebp),%esp 1173ce: 5b pop %ebx 1173cf: 5e pop %esi 1173d0: 5f pop %edi 1173d1: c9 leave 1173d2: c3 ret =============================================================================== 00112218 <_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 ) { 112218: 55 push %ebp 112219: 89 e5 mov %esp,%ebp 11221b: 57 push %edi 11221c: 56 push %esi 11221d: 53 push %ebx 11221e: 83 ec 1c sub $0x1c,%esp 112221: 8b 5d 08 mov 0x8(%ebp),%ebx 112224: 8b 7d 10 mov 0x10(%ebp),%edi 112227: 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; 11222a: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 11222d: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 112234: 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; 112237: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 11223e: 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)) { 112245: 89 d0 mov %edx,%eax 112247: f6 c2 03 test $0x3,%dl 11224a: 74 0c je 112258 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 11224c: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 11224f: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 112252: 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) 112254: 39 d0 cmp %edx,%eax 112256: 72 68 jb 1122c0 <_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)); 112258: 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 * 11225b: 89 d1 mov %edx,%ecx 11225d: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 112260: 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) 112262: 39 c1 cmp %eax,%ecx 112264: 72 5a jb 1122c0 <_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 ); 112266: 83 ec 0c sub $0xc,%esp 112269: 51 push %ecx 11226a: 89 55 e4 mov %edx,-0x1c(%ebp) 11226d: e8 a0 26 00 00 call 114912 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 112272: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 112275: 83 c4 10 add $0x10,%esp 112278: 85 c0 test %eax,%eax 11227a: 8b 55 e4 mov -0x1c(%ebp),%edx 11227d: 74 41 je 1122c0 <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 11227f: 52 push %edx 112280: 57 push %edi 112281: 50 push %eax 112282: 8d 43 68 lea 0x68(%ebx),%eax 112285: 50 push %eax 112286: e8 e1 49 00 00 call 116c6c <_Chain_Initialize> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 11228b: 8d 43 54 lea 0x54(%ebx),%eax 11228e: 89 43 50 mov %eax,0x50(%ebx) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 112291: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) the_message_queue->message_buffers, (size_t) maximum_pending_messages, allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); 112298: 8d 43 50 lea 0x50(%ebx),%eax 11229b: 89 43 58 mov %eax,0x58(%ebx) _Thread_queue_Initialize( 11229e: 6a 06 push $0x6 1122a0: 68 80 00 00 00 push $0x80 1122a5: 8b 45 0c mov 0xc(%ebp),%eax 1122a8: 83 38 01 cmpl $0x1,(%eax) 1122ab: 0f 94 c0 sete %al 1122ae: 0f b6 c0 movzbl %al,%eax 1122b1: 50 push %eax 1122b2: 53 push %ebx 1122b3: e8 04 1d 00 00 call 113fbc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 1122b8: 83 c4 20 add $0x20,%esp 1122bb: be 01 00 00 00 mov $0x1,%esi } 1122c0: 89 f0 mov %esi,%eax 1122c2: 8d 65 f4 lea -0xc(%ebp),%esp 1122c5: 5b pop %ebx 1122c6: 5e pop %esi 1122c7: 5f pop %edi 1122c8: c9 leave 1122c9: c3 ret =============================================================================== 001122cc <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 1122cc: 55 push %ebp 1122cd: 89 e5 mov %esp,%ebp 1122cf: 57 push %edi 1122d0: 56 push %esi 1122d1: 53 push %ebx 1122d2: 83 ec 2c sub $0x2c,%esp 1122d5: 8b 55 08 mov 0x8(%ebp),%edx 1122d8: 8b 45 0c mov 0xc(%ebp),%eax 1122db: 89 45 dc mov %eax,-0x24(%ebp) 1122de: 8b 5d 10 mov 0x10(%ebp),%ebx 1122e1: 89 5d e0 mov %ebx,-0x20(%ebp) 1122e4: 8b 4d 14 mov 0x14(%ebp),%ecx 1122e7: 8b 75 1c mov 0x1c(%ebp),%esi 1122ea: 89 75 d4 mov %esi,-0x2c(%ebp) 1122ed: 8a 45 18 mov 0x18(%ebp),%al 1122f0: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 1122f3: a1 9c c9 12 00 mov 0x12c99c,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1122f8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 1122ff: 9c pushf 112300: fa cli 112301: 8f 45 e4 popl -0x1c(%ebp) */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 112304: 8b 5a 50 mov 0x50(%edx),%ebx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 112307: 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)) 11230a: 39 f3 cmp %esi,%ebx 11230c: 0f 84 8a 00 00 00 je 11239c <_CORE_message_queue_Seize+0xd0> { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 112312: 8b 33 mov (%ebx),%esi the_chain->first = new_first; 112314: 89 72 50 mov %esi,0x50(%edx) CORE_message_queue_Buffer_control *_CORE_message_queue_Get_pending_message ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) _Chain_Get_unprotected( &the_message_queue->Pending_messages ); 112317: 8d 7a 50 lea 0x50(%edx),%edi 11231a: 89 7e 04 mov %edi,0x4(%esi) the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 11231d: 85 db test %ebx,%ebx 11231f: 74 7b je 11239c <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 112321: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 112324: ff 75 e4 pushl -0x1c(%ebp) 112327: 9d popf *size_p = the_message->Contents.size; 112328: 8b 43 0c mov 0xc(%ebx),%eax 11232b: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 11232d: 8b 73 08 mov 0x8(%ebx),%esi 112330: a1 9c c9 12 00 mov 0x12c99c,%eax 112335: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112338: 8d 73 10 lea 0x10(%ebx),%esi 11233b: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11233e: 8b 09 mov (%ecx),%ecx 112340: 8b 7d e0 mov -0x20(%ebp),%edi 112343: 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 ); 112345: 83 ec 0c sub $0xc,%esp 112348: 52 push %edx 112349: 89 55 d0 mov %edx,-0x30(%ebp) 11234c: e8 3b 19 00 00 call 113c8c <_Thread_queue_Dequeue> if ( !the_thread ) { 112351: 83 c4 10 add $0x10,%esp 112354: 85 c0 test %eax,%eax 112356: 8b 55 d0 mov -0x30(%ebp),%edx 112359: 75 15 jne 112370 <_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 ); 11235b: 89 5d 0c mov %ebx,0xc(%ebp) 11235e: 83 c2 68 add $0x68,%edx 112361: 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 ); } 112364: 8d 65 f4 lea -0xc(%ebp),%esp 112367: 5b pop %ebx 112368: 5e pop %esi 112369: 5f pop %edi 11236a: c9 leave 11236b: e9 28 fe ff ff jmp 112198 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 112370: 8b 48 24 mov 0x24(%eax),%ecx 112373: 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; 112376: 8b 48 30 mov 0x30(%eax),%ecx 112379: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11237c: 8b 70 2c mov 0x2c(%eax),%esi 11237f: 8b 7d e4 mov -0x1c(%ebp),%edi 112382: 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( 112384: 8b 43 08 mov 0x8(%ebx),%eax 112387: 89 45 10 mov %eax,0x10(%ebp) 11238a: 89 5d 0c mov %ebx,0xc(%ebp) 11238d: 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 ); } 112390: 8d 65 f4 lea -0xc(%ebp),%esp 112393: 5b pop %ebx 112394: 5e pop %esi 112395: 5f pop %edi 112396: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 112397: e9 08 49 00 00 jmp 116ca4 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 11239c: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 1123a0: 75 13 jne 1123b5 <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 1123a2: ff 75 e4 pushl -0x1c(%ebp) 1123a5: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1123a6: 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 ); } 1123ad: 8d 65 f4 lea -0xc(%ebp),%esp 1123b0: 5b pop %ebx 1123b1: 5e pop %esi 1123b2: 5f pop %edi 1123b3: c9 leave 1123b4: 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; 1123b5: 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; 1123bc: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 1123bf: 8b 5d dc mov -0x24(%ebp),%ebx 1123c2: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 1123c5: 8b 75 e0 mov -0x20(%ebp),%esi 1123c8: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 1123cb: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 1123ce: ff 75 e4 pushl -0x1c(%ebp) 1123d1: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 1123d2: c7 45 10 6c 40 11 00 movl $0x11406c,0x10(%ebp) 1123d9: 8b 45 d4 mov -0x2c(%ebp),%eax 1123dc: 89 45 0c mov %eax,0xc(%ebp) 1123df: 89 55 08 mov %edx,0x8(%ebp) } 1123e2: 8d 65 f4 lea -0xc(%ebp),%esp 1123e5: 5b pop %ebx 1123e6: 5e pop %esi 1123e7: 5f pop %edi 1123e8: 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 ); 1123e9: e9 a6 19 00 00 jmp 113d94 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ac1d <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac1d: 55 push %ebp 10ac1e: 89 e5 mov %esp,%ebp 10ac20: 53 push %ebx 10ac21: 83 ec 14 sub $0x14,%esp 10ac24: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac27: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac2a: a1 e4 42 12 00 mov 0x1242e4,%eax 10ac2f: 85 c0 test %eax,%eax 10ac31: 74 19 je 10ac4c <_CORE_mutex_Seize+0x2f> 10ac33: 84 d2 test %dl,%dl 10ac35: 74 15 je 10ac4c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac37: 83 3d 64 44 12 00 01 cmpl $0x1,0x124464 10ac3e: 76 0c jbe 10ac4c <_CORE_mutex_Seize+0x2f> 10ac40: 53 push %ebx 10ac41: 6a 12 push $0x12 10ac43: 6a 00 push $0x0 10ac45: 6a 00 push $0x0 10ac47: e8 e4 05 00 00 call 10b230 <_Internal_error_Occurred> 10ac4c: 51 push %ecx 10ac4d: 51 push %ecx 10ac4e: 8d 45 18 lea 0x18(%ebp),%eax 10ac51: 50 push %eax 10ac52: 53 push %ebx 10ac53: 88 55 f4 mov %dl,-0xc(%ebp) 10ac56: e8 b9 46 00 00 call 10f314 <_CORE_mutex_Seize_interrupt_trylock> 10ac5b: 83 c4 10 add $0x10,%esp 10ac5e: 85 c0 test %eax,%eax 10ac60: 8a 55 f4 mov -0xc(%ebp),%dl 10ac63: 74 48 je 10acad <_CORE_mutex_Seize+0x90> 10ac65: 84 d2 test %dl,%dl 10ac67: 75 12 jne 10ac7b <_CORE_mutex_Seize+0x5e> 10ac69: ff 75 18 pushl 0x18(%ebp) 10ac6c: 9d popf 10ac6d: a1 34 48 12 00 mov 0x124834,%eax 10ac72: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10ac79: eb 32 jmp 10acad <_CORE_mutex_Seize+0x90> 10ac7b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ac82: a1 34 48 12 00 mov 0x124834,%eax 10ac87: 89 58 44 mov %ebx,0x44(%eax) 10ac8a: 8b 55 0c mov 0xc(%ebp),%edx 10ac8d: 89 50 20 mov %edx,0x20(%eax) 10ac90: a1 e4 42 12 00 mov 0x1242e4,%eax 10ac95: 40 inc %eax 10ac96: a3 e4 42 12 00 mov %eax,0x1242e4 10ac9b: ff 75 18 pushl 0x18(%ebp) 10ac9e: 9d popf 10ac9f: 50 push %eax 10aca0: 50 push %eax 10aca1: ff 75 14 pushl 0x14(%ebp) 10aca4: 53 push %ebx 10aca5: e8 26 ff ff ff call 10abd0 <_CORE_mutex_Seize_interrupt_blocking> 10acaa: 83 c4 10 add $0x10,%esp } 10acad: 8b 5d fc mov -0x4(%ebp),%ebx 10acb0: c9 leave 10acb1: c3 ret =============================================================================== 0010add8 <_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 ) { 10add8: 55 push %ebp 10add9: 89 e5 mov %esp,%ebp 10addb: 53 push %ebx 10addc: 83 ec 10 sub $0x10,%esp 10addf: 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)) ) { 10ade2: 53 push %ebx 10ade3: e8 64 14 00 00 call 10c24c <_Thread_queue_Dequeue> 10ade8: 89 c2 mov %eax,%edx 10adea: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10aded: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10adef: 85 d2 test %edx,%edx 10adf1: 75 15 jne 10ae08 <_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 ); 10adf3: 9c pushf 10adf4: fa cli 10adf5: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10adf6: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10adf9: 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 ) 10adfb: 3b 53 40 cmp 0x40(%ebx),%edx 10adfe: 73 06 jae 10ae06 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae00: 42 inc %edx 10ae01: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae04: 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 ); 10ae06: 51 push %ecx 10ae07: 9d popf } return status; } 10ae08: 8b 5d fc mov -0x4(%ebp),%ebx 10ae0b: c9 leave 10ae0c: c3 ret =============================================================================== 00109d48 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109d48: 55 push %ebp 109d49: 89 e5 mov %esp,%ebp 109d4b: 57 push %edi 109d4c: 56 push %esi 109d4d: 53 push %ebx 109d4e: 83 ec 2c sub $0x2c,%esp 109d51: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 109d54: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109d5a: 8b 43 30 mov 0x30(%ebx),%eax 109d5d: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109d60: 9c pushf 109d61: fa cli 109d62: 58 pop %eax pending_events = api->pending_events; 109d63: 8b 17 mov (%edi),%edx 109d65: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109d68: 8b 73 24 mov 0x24(%ebx),%esi seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109d6b: 21 f2 and %esi,%edx 109d6d: 75 07 jne 109d76 <_Event_Surrender+0x2e> _ISR_Enable( level ); 109d6f: 50 push %eax 109d70: 9d popf return; 109d71: e9 af 00 00 00 jmp 109e25 <_Event_Surrender+0xdd> /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109d76: 83 3d 30 48 12 00 00 cmpl $0x0,0x124830 109d7d: 74 49 je 109dc8 <_Event_Surrender+0x80> 109d7f: 3b 1d 34 48 12 00 cmp 0x124834,%ebx 109d85: 75 41 jne 109dc8 <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d87: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && 109d8d: 83 f9 02 cmp $0x2,%ecx 109d90: 74 09 je 109d9b <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109d92: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d98: 49 dec %ecx 109d99: 75 2d jne 109dc8 <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109d9b: 39 f2 cmp %esi,%edx 109d9d: 74 06 je 109da5 <_Event_Surrender+0x5d> 109d9f: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109da3: 74 1f je 109dc4 <_Event_Surrender+0x7c> <== NEVER TAKEN RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 109da5: 89 d6 mov %edx,%esi 109da7: f7 d6 not %esi 109da9: 23 75 d4 and -0x2c(%ebp),%esi 109dac: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109dae: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109db5: 8b 4b 28 mov 0x28(%ebx),%ecx 109db8: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109dba: c7 05 e4 4b 12 00 03 movl $0x3,0x124be4 109dc1: 00 00 00 } _ISR_Enable( level ); 109dc4: 50 push %eax 109dc5: 9d popf return; 109dc6: eb 5d jmp 109e25 <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109dc8: f6 43 11 01 testb $0x1,0x11(%ebx) 109dcc: 74 55 je 109e23 <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109dce: 39 f2 cmp %esi,%edx 109dd0: 74 06 je 109dd8 <_Event_Surrender+0x90> 109dd2: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dd6: 74 4b je 109e23 <_Event_Surrender+0xdb> <== NEVER TAKEN 109dd8: 89 d6 mov %edx,%esi 109dda: f7 d6 not %esi 109ddc: 23 75 d4 and -0x2c(%ebp),%esi 109ddf: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109de1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109de8: 8b 4b 28 mov 0x28(%ebx),%ecx 109deb: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109ded: 50 push %eax 109dee: 9d popf 109def: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109df0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109df4: 74 06 je 109dfc <_Event_Surrender+0xb4> _ISR_Enable( level ); 109df6: 50 push %eax 109df7: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109df8: 51 push %ecx 109df9: 51 push %ecx 109dfa: eb 17 jmp 109e13 <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109dfc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e03: 50 push %eax 109e04: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e05: 83 ec 0c sub $0xc,%esp 109e08: 8d 43 48 lea 0x48(%ebx),%eax 109e0b: 50 push %eax 109e0c: e8 a7 2f 00 00 call 10cdb8 <_Watchdog_Remove> 109e11: 58 pop %eax 109e12: 5a pop %edx 109e13: 68 f8 ff 03 10 push $0x1003fff8 109e18: 53 push %ebx 109e19: e8 3e 1d 00 00 call 10bb5c <_Thread_Clear_state> 109e1e: 83 c4 10 add $0x10,%esp 109e21: eb 02 jmp 109e25 <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e23: 50 push %eax 109e24: 9d popf } 109e25: 8d 65 f4 lea -0xc(%ebp),%esp 109e28: 5b pop %ebx 109e29: 5e pop %esi 109e2a: 5f pop %edi 109e2b: c9 leave 109e2c: c3 ret =============================================================================== 00109e30 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e30: 55 push %ebp 109e31: 89 e5 mov %esp,%ebp 109e33: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e36: 8d 45 f4 lea -0xc(%ebp),%eax 109e39: 50 push %eax 109e3a: ff 75 08 pushl 0x8(%ebp) 109e3d: e8 ae 20 00 00 call 10bef0 <_Thread_Get> switch ( location ) { 109e42: 83 c4 10 add $0x10,%esp 109e45: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109e49: 75 49 jne 109e94 <_Event_Timeout+0x64> <== NEVER TAKEN * * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 109e4b: 9c pushf 109e4c: fa cli 109e4d: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109e4e: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109e55: 3b 05 34 48 12 00 cmp 0x124834,%eax 109e5b: 75 13 jne 109e70 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109e5d: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx 109e63: 49 dec %ecx 109e64: 75 0a jne 109e70 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109e66: c7 05 e4 4b 12 00 02 movl $0x2,0x124be4 109e6d: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109e70: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109e77: 52 push %edx 109e78: 9d popf 109e79: 52 push %edx 109e7a: 52 push %edx 109e7b: 68 f8 ff 03 10 push $0x1003fff8 109e80: 50 push %eax 109e81: e8 d6 1c 00 00 call 10bb5c <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109e86: a1 e4 42 12 00 mov 0x1242e4,%eax 109e8b: 48 dec %eax 109e8c: a3 e4 42 12 00 mov %eax,0x1242e4 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109e91: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109e94: c9 leave 109e95: c3 ret =============================================================================== 0010f973 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10f973: 55 push %ebp 10f974: 89 e5 mov %esp,%ebp 10f976: 57 push %edi 10f977: 56 push %esi 10f978: 53 push %ebx 10f979: 83 ec 4c sub $0x4c,%esp 10f97c: 8b 5d 08 mov 0x8(%ebp),%ebx 10f97f: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10f982: 8b 43 20 mov 0x20(%ebx),%eax 10f985: 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; 10f988: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10f98f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10f996: 8b 53 10 mov 0x10(%ebx),%edx 10f999: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10f99c: 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; 10f99f: 8b 7b 30 mov 0x30(%ebx),%edi 10f9a2: 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; 10f9a5: 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 ) { 10f9a7: 8b 7d 0c mov 0xc(%ebp),%edi 10f9aa: 01 cf add %ecx,%edi 10f9ac: 0f 82 d4 01 00 00 jb 10fb86 <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10f9b2: 52 push %edx 10f9b3: 52 push %edx 10f9b4: 8d 55 e0 lea -0x20(%ebp),%edx 10f9b7: 52 push %edx 10f9b8: 8d 55 e4 lea -0x1c(%ebp),%edx 10f9bb: 52 push %edx 10f9bc: 50 push %eax 10f9bd: ff 75 c4 pushl -0x3c(%ebp) 10f9c0: 51 push %ecx 10f9c1: ff 75 0c pushl 0xc(%ebp) 10f9c4: e8 8a b9 ff ff call 10b353 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10f9c9: 83 c4 20 add $0x20,%esp 10f9cc: 84 c0 test %al,%al 10f9ce: 0f 84 b2 01 00 00 je 10fb86 <_Heap_Extend+0x213> 10f9d4: 8b 4d c0 mov -0x40(%ebp),%ecx 10f9d7: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10f9de: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10f9e5: 31 f6 xor %esi,%esi 10f9e7: 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; 10f9ee: 8b 43 18 mov 0x18(%ebx),%eax 10f9f1: 89 5d b8 mov %ebx,-0x48(%ebp) 10f9f4: eb 02 jmp 10f9f8 <_Heap_Extend+0x85> 10f9f6: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10f9f8: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10f9fa: 39 c7 cmp %eax,%edi 10f9fc: 76 09 jbe 10fa07 <_Heap_Extend+0x94> 10f9fe: 39 5d 0c cmp %ebx,0xc(%ebp) 10fa01: 0f 82 7d 01 00 00 jb 10fb84 <_Heap_Extend+0x211> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fa07: 39 c7 cmp %eax,%edi 10fa09: 74 06 je 10fa11 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fa0b: 39 df cmp %ebx,%edi 10fa0d: 72 07 jb 10fa16 <_Heap_Extend+0xa3> 10fa0f: eb 08 jmp 10fa19 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fa11: 89 4d d0 mov %ecx,-0x30(%ebp) 10fa14: eb 03 jmp 10fa19 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fa16: 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); 10fa19: 8d 43 f8 lea -0x8(%ebx),%eax 10fa1c: 89 45 d4 mov %eax,-0x2c(%ebp) 10fa1f: 89 d8 mov %ebx,%eax 10fa21: 31 d2 xor %edx,%edx 10fa23: 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); 10fa26: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fa29: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fa2c: 75 07 jne 10fa35 <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fa2e: 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 ) 10fa30: 8b 75 d4 mov -0x2c(%ebp),%esi 10fa33: eb 08 jmp 10fa3d <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fa35: 73 06 jae 10fa3d <_Heap_Extend+0xca> 10fa37: 8b 55 d4 mov -0x2c(%ebp),%edx 10fa3a: 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; 10fa3d: 8b 45 d4 mov -0x2c(%ebp),%eax 10fa40: 8b 48 04 mov 0x4(%eax),%ecx 10fa43: 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); 10fa46: 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 ); 10fa48: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fa4b: 75 a9 jne 10f9f6 <_Heap_Extend+0x83> 10fa4d: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fa50: 8b 55 0c mov 0xc(%ebp),%edx 10fa53: 3b 53 18 cmp 0x18(%ebx),%edx 10fa56: 73 05 jae 10fa5d <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fa58: 89 53 18 mov %edx,0x18(%ebx) 10fa5b: eb 08 jmp 10fa65 <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fa5d: 39 7b 1c cmp %edi,0x1c(%ebx) 10fa60: 73 03 jae 10fa65 <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fa62: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fa65: 8b 45 e0 mov -0x20(%ebp),%eax 10fa68: 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 = 10fa6b: 89 c1 mov %eax,%ecx 10fa6d: 29 d1 sub %edx,%ecx 10fa6f: 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; 10fa72: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fa74: 83 c9 01 or $0x1,%ecx 10fa77: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fa7a: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fa7d: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fa7f: 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 ) { 10fa86: 39 53 20 cmp %edx,0x20(%ebx) 10fa89: 76 05 jbe 10fa90 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fa8b: 89 53 20 mov %edx,0x20(%ebx) 10fa8e: eb 08 jmp 10fa98 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fa90: 39 43 24 cmp %eax,0x24(%ebx) 10fa93: 73 03 jae 10fa98 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fa95: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fa98: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fa9c: 74 3b je 10fad9 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fa9e: 8b 43 10 mov 0x10(%ebx),%eax 10faa1: 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 ); 10faa4: 8b 4d 0c mov 0xc(%ebp),%ecx 10faa7: 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; 10faaa: 89 c8 mov %ecx,%eax 10faac: 31 d2 xor %edx,%edx 10faae: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fab1: 85 d2 test %edx,%edx 10fab3: 74 05 je 10faba <_Heap_Extend+0x147> <== ALWAYS TAKEN return value - remainder + alignment; 10fab5: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED 10fab8: 29 d1 sub %edx,%ecx <== NOT EXECUTED uintptr_t const new_first_block_begin = 10faba: 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; 10fabd: 8b 45 d0 mov -0x30(%ebp),%eax 10fac0: 8b 00 mov (%eax),%eax 10fac2: 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 = 10fac5: 8b 45 d0 mov -0x30(%ebp),%eax 10fac8: 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; 10faca: 83 c8 01 or $0x1,%eax 10facd: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fad0: 89 d8 mov %ebx,%eax 10fad2: e8 81 fe ff ff call 10f958 <_Heap_Free_block> 10fad7: eb 14 jmp 10faed <_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 ) { 10fad9: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fadd: 74 0e je 10faed <_Heap_Extend+0x17a> _Heap_Link_below( 10fadf: 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; 10fae2: 8b 45 c8 mov -0x38(%ebp),%eax 10fae5: 29 d0 sub %edx,%eax 10fae7: 83 c8 01 or $0x1,%eax 10faea: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10faed: 85 f6 test %esi,%esi 10faef: 74 30 je 10fb21 <_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, 10faf1: 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( 10faf4: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10faf6: 89 f8 mov %edi,%eax 10faf8: 31 d2 xor %edx,%edx 10fafa: f7 73 10 divl 0x10(%ebx) 10fafd: 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) 10faff: 8b 46 04 mov 0x4(%esi),%eax 10fb02: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fb04: 83 c8 01 or $0x1,%eax 10fb07: 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; 10fb0b: 8b 46 04 mov 0x4(%esi),%eax 10fb0e: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fb11: 09 f8 or %edi,%eax 10fb13: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fb16: 89 f2 mov %esi,%edx 10fb18: 89 d8 mov %ebx,%eax 10fb1a: e8 39 fe ff ff call 10f958 <_Heap_Free_block> 10fb1f: eb 21 jmp 10fb42 <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fb21: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fb25: 74 1b je 10fb42 <_Heap_Extend+0x1cf> _Heap_Link_above( 10fb27: 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 ); 10fb2a: 8b 45 e4 mov -0x1c(%ebp),%eax 10fb2d: 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; 10fb30: 8b 7d cc mov -0x34(%ebp),%edi 10fb33: 8b 57 04 mov 0x4(%edi),%edx 10fb36: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fb39: 09 d0 or %edx,%eax 10fb3b: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fb3e: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fb42: 85 f6 test %esi,%esi 10fb44: 75 10 jne 10fb56 <_Heap_Extend+0x1e3> 10fb46: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fb4a: 75 0a jne 10fb56 <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fb4c: 8b 55 e4 mov -0x1c(%ebp),%edx 10fb4f: 89 d8 mov %ebx,%eax 10fb51: e8 02 fe ff ff call 10f958 <_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 10fb56: 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( 10fb59: 8b 43 20 mov 0x20(%ebx),%eax 10fb5c: 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; 10fb5e: 8b 4a 04 mov 0x4(%edx),%ecx 10fb61: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fb64: 09 c8 or %ecx,%eax 10fb66: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fb69: 8b 43 30 mov 0x30(%ebx),%eax 10fb6c: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fb6f: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fb72: 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 ) 10fb77: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fb7b: 74 09 je 10fb86 <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fb7d: 8b 55 14 mov 0x14(%ebp),%edx 10fb80: 89 02 mov %eax,(%edx) 10fb82: eb 02 jmp 10fb86 <_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; 10fb84: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fb86: 89 f0 mov %esi,%eax 10fb88: 8d 65 f4 lea -0xc(%ebp),%esp 10fb8b: 5b pop %ebx 10fb8c: 5e pop %esi 10fb8d: 5f pop %edi 10fb8e: c9 leave 10fb8f: c3 ret =============================================================================== 0010f5b8 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f5b8: 55 push %ebp 10f5b9: 89 e5 mov %esp,%ebp 10f5bb: 57 push %edi 10f5bc: 56 push %esi 10f5bd: 53 push %ebx 10f5be: 83 ec 14 sub $0x14,%esp 10f5c1: 8b 4d 08 mov 0x8(%ebp),%ecx 10f5c4: 8b 45 0c mov 0xc(%ebp),%eax 10f5c7: 8d 58 f8 lea -0x8(%eax),%ebx 10f5ca: 31 d2 xor %edx,%edx 10f5cc: 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); 10f5cf: 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 10f5d1: 8b 41 20 mov 0x20(%ecx),%eax 10f5d4: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f5d7: 31 d2 xor %edx,%edx 10f5d9: 39 c3 cmp %eax,%ebx 10f5db: 72 08 jb 10f5e5 <_Heap_Free+0x2d> 10f5dd: 31 d2 xor %edx,%edx 10f5df: 39 59 24 cmp %ebx,0x24(%ecx) 10f5e2: 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; 10f5e5: 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 ) ) { 10f5e7: 85 d2 test %edx,%edx 10f5e9: 0f 84 21 01 00 00 je 10f710 <_Heap_Free+0x158> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f5ef: 8b 43 04 mov 0x4(%ebx),%eax 10f5f2: 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; 10f5f5: 89 c6 mov %eax,%esi 10f5f7: 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); 10f5fa: 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; 10f5fd: 31 ff xor %edi,%edi 10f5ff: 3b 55 ec cmp -0x14(%ebp),%edx 10f602: 72 0a jb 10f60e <_Heap_Free+0x56> <== NEVER TAKEN 10f604: 31 c0 xor %eax,%eax 10f606: 39 51 24 cmp %edx,0x24(%ecx) 10f609: 0f 93 c0 setae %al 10f60c: 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; 10f60e: 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 ) ) { 10f610: 85 ff test %edi,%edi 10f612: 0f 84 f8 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f618: 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 ) ) { 10f61b: f7 c7 01 00 00 00 test $0x1,%edi 10f621: 0f 84 e9 00 00 00 je 10f710 <_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; 10f627: 83 e7 fe and $0xfffffffe,%edi 10f62a: 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 10f62d: 8b 41 24 mov 0x24(%ecx),%eax 10f630: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f633: 31 c0 xor %eax,%eax 10f635: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f638: 74 0a je 10f644 <_Heap_Free+0x8c> 10f63a: 31 c0 xor %eax,%eax 10f63c: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f641: 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 10f644: 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 ) ) { 10f647: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f64b: 75 62 jne 10f6af <_Heap_Free+0xf7> uintptr_t const prev_size = block->prev_size; 10f64d: 8b 03 mov (%ebx),%eax 10f64f: 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); 10f652: 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; 10f654: 31 ff xor %edi,%edi 10f656: 3b 5d ec cmp -0x14(%ebp),%ebx 10f659: 72 0a jb 10f665 <_Heap_Free+0xad> <== NEVER TAKEN 10f65b: 31 c0 xor %eax,%eax 10f65d: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f660: 0f 93 c0 setae %al 10f663: 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 ); 10f665: 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 ) ) { 10f667: 85 ff test %edi,%edi 10f669: 0f 84 a1 00 00 00 je 10f710 <_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) ) { 10f66f: f6 43 04 01 testb $0x1,0x4(%ebx) 10f673: 0f 84 97 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f679: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f67d: 74 1a je 10f699 <_Heap_Free+0xe1> uintptr_t const size = block_size + prev_size + next_block_size; 10f67f: 8b 45 e8 mov -0x18(%ebp),%eax 10f682: 8d 04 06 lea (%esi,%eax,1),%eax 10f685: 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; 10f688: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f68b: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f68e: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f691: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f694: ff 49 38 decl 0x38(%ecx) 10f697: eb 33 jmp 10f6cc <_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; 10f699: 8b 45 f0 mov -0x10(%ebp),%eax 10f69c: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f69f: 89 c7 mov %eax,%edi 10f6a1: 83 cf 01 or $0x1,%edi 10f6a4: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f6a7: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f6ab: 89 02 mov %eax,(%edx) 10f6ad: eb 56 jmp 10f705 <_Heap_Free+0x14d> } } else if ( next_is_free ) { /* coalesce next */ 10f6af: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f6b3: 74 24 je 10f6d9 <_Heap_Free+0x121> uintptr_t const size = block_size + next_block_size; 10f6b5: 8b 45 e8 mov -0x18(%ebp),%eax 10f6b8: 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; 10f6ba: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f6bd: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f6c0: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f6c3: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f6c6: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f6c9: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f6cc: 89 c2 mov %eax,%edx 10f6ce: 83 ca 01 or $0x1,%edx 10f6d1: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f6d4: 89 04 03 mov %eax,(%ebx,%eax,1) 10f6d7: eb 2c jmp 10f705 <_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; 10f6d9: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f6dc: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f6df: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f6e2: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f6e5: 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; 10f6e8: 89 f0 mov %esi,%eax 10f6ea: 83 c8 01 or $0x1,%eax 10f6ed: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f6f0: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f6f4: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f6f6: 8b 41 38 mov 0x38(%ecx),%eax 10f6f9: 40 inc %eax 10f6fa: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f6fd: 39 41 3c cmp %eax,0x3c(%ecx) 10f700: 73 03 jae 10f705 <_Heap_Free+0x14d> stats->max_free_blocks = stats->free_blocks; 10f702: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f705: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f708: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f70b: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f70e: b0 01 mov $0x1,%al } 10f710: 83 c4 14 add $0x14,%esp 10f713: 5b pop %ebx 10f714: 5e pop %esi 10f715: 5f pop %edi 10f716: c9 leave 10f717: c3 ret =============================================================================== 0011cb80 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11cb80: 55 push %ebp 11cb81: 89 e5 mov %esp,%ebp 11cb83: 57 push %edi 11cb84: 56 push %esi 11cb85: 53 push %ebx 11cb86: 8b 5d 08 mov 0x8(%ebp),%ebx 11cb89: 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); 11cb8c: 8d 4e f8 lea -0x8(%esi),%ecx 11cb8f: 89 f0 mov %esi,%eax 11cb91: 31 d2 xor %edx,%edx 11cb93: 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); 11cb96: 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 11cb98: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11cb9b: 31 ff xor %edi,%edi 11cb9d: 39 d1 cmp %edx,%ecx 11cb9f: 72 0a jb 11cbab <_Heap_Size_of_alloc_area+0x2b> 11cba1: 31 c0 xor %eax,%eax 11cba3: 39 4b 24 cmp %ecx,0x24(%ebx) 11cba6: 0f 93 c0 setae %al 11cba9: 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; 11cbab: 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 ) ) { 11cbad: 85 ff test %edi,%edi 11cbaf: 74 30 je 11cbe1 <_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; 11cbb1: 8b 41 04 mov 0x4(%ecx),%eax 11cbb4: 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); 11cbb7: 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; 11cbb9: 31 ff xor %edi,%edi 11cbbb: 39 d1 cmp %edx,%ecx 11cbbd: 72 0a jb 11cbc9 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11cbbf: 31 c0 xor %eax,%eax 11cbc1: 39 4b 24 cmp %ecx,0x24(%ebx) 11cbc4: 0f 93 c0 setae %al 11cbc7: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11cbc9: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11cbcb: 85 ff test %edi,%edi 11cbcd: 74 12 je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11cbcf: f6 41 04 01 testb $0x1,0x4(%ecx) 11cbd3: 74 0c je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11cbd5: 29 f1 sub %esi,%ecx 11cbd7: 8d 51 04 lea 0x4(%ecx),%edx 11cbda: 8b 45 10 mov 0x10(%ebp),%eax 11cbdd: 89 10 mov %edx,(%eax) return true; 11cbdf: b0 01 mov $0x1,%al } 11cbe1: 5b pop %ebx 11cbe2: 5e pop %esi 11cbe3: 5f pop %edi 11cbe4: c9 leave 11cbe5: c3 ret =============================================================================== 0010bc0e <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bc0e: 55 push %ebp 10bc0f: 89 e5 mov %esp,%ebp 10bc11: 57 push %edi 10bc12: 56 push %esi 10bc13: 53 push %ebx 10bc14: 83 ec 4c sub $0x4c,%esp 10bc17: 8b 75 08 mov 0x8(%ebp),%esi 10bc1a: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bc1d: 8b 46 10 mov 0x10(%esi),%eax 10bc20: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bc23: 8b 4e 14 mov 0x14(%esi),%ecx 10bc26: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bc29: 8b 46 20 mov 0x20(%esi),%eax 10bc2c: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bc2f: 8b 4e 24 mov 0x24(%esi),%ecx 10bc32: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bc35: c7 45 e4 d0 bb 10 00 movl $0x10bbd0,-0x1c(%ebp) 10bc3c: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bc40: 74 07 je 10bc49 <_Heap_Walk+0x3b> 10bc42: c7 45 e4 d5 bb 10 00 movl $0x10bbd5,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bc49: 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() ) ) { 10bc4b: 83 3d ec 64 12 00 03 cmpl $0x3,0x1264ec 10bc52: 0f 85 e8 02 00 00 jne 10bf40 <_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)( 10bc58: 52 push %edx 10bc59: ff 76 0c pushl 0xc(%esi) 10bc5c: ff 76 08 pushl 0x8(%esi) 10bc5f: ff 75 c8 pushl -0x38(%ebp) 10bc62: ff 75 d0 pushl -0x30(%ebp) 10bc65: ff 76 1c pushl 0x1c(%esi) 10bc68: ff 76 18 pushl 0x18(%esi) 10bc6b: ff 75 d4 pushl -0x2c(%ebp) 10bc6e: ff 75 d8 pushl -0x28(%ebp) 10bc71: 68 09 f7 11 00 push $0x11f709 10bc76: 6a 00 push $0x0 10bc78: 53 push %ebx 10bc79: 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 ) { 10bc7c: 83 c4 30 add $0x30,%esp 10bc7f: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bc83: 75 0b jne 10bc90 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bc85: 50 push %eax 10bc86: 68 9a f7 11 00 push $0x11f79a 10bc8b: e9 6b 02 00 00 jmp 10befb <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bc90: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bc94: 74 0d je 10bca3 <_Heap_Walk+0x95> (*printer)( 10bc96: ff 75 d8 pushl -0x28(%ebp) 10bc99: 68 ad f7 11 00 push $0x11f7ad 10bc9e: e9 58 02 00 00 jmp 10befb <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bca3: 8b 45 d4 mov -0x2c(%ebp),%eax 10bca6: 31 d2 xor %edx,%edx 10bca8: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bcab: 85 d2 test %edx,%edx 10bcad: 74 0d je 10bcbc <_Heap_Walk+0xae> (*printer)( 10bcaf: ff 75 d4 pushl -0x2c(%ebp) 10bcb2: 68 cb f7 11 00 push $0x11f7cb 10bcb7: e9 3f 02 00 00 jmp 10befb <_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; 10bcbc: 8b 45 d0 mov -0x30(%ebp),%eax 10bcbf: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcc2: 31 d2 xor %edx,%edx 10bcc4: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bcc7: 85 d2 test %edx,%edx 10bcc9: 74 0d je 10bcd8 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bccb: ff 75 d0 pushl -0x30(%ebp) 10bcce: 68 ef f7 11 00 push $0x11f7ef 10bcd3: e9 23 02 00 00 jmp 10befb <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bcd8: 8b 45 d0 mov -0x30(%ebp),%eax 10bcdb: f6 40 04 01 testb $0x1,0x4(%eax) 10bcdf: 75 0b jne 10bcec <_Heap_Walk+0xde> (*printer)( 10bce1: 57 push %edi 10bce2: 68 20 f8 11 00 push $0x11f820 10bce7: e9 0f 02 00 00 jmp 10befb <_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; 10bcec: 8b 4d c8 mov -0x38(%ebp),%ecx 10bcef: 8b 79 04 mov 0x4(%ecx),%edi 10bcf2: 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); 10bcf5: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bcf7: f6 47 04 01 testb $0x1,0x4(%edi) 10bcfb: 75 0b jne 10bd08 <_Heap_Walk+0xfa> (*printer)( 10bcfd: 56 push %esi 10bcfe: 68 4e f8 11 00 push $0x11f84e 10bd03: e9 f3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> ); return false; } if ( 10bd08: 3b 7d d0 cmp -0x30(%ebp),%edi 10bd0b: 74 0b je 10bd18 <_Heap_Walk+0x10a> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bd0d: 51 push %ecx <== NOT EXECUTED 10bd0e: 68 63 f8 11 00 push $0x11f863 <== NOT EXECUTED 10bd13: e9 e3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bd18: 8b 46 10 mov 0x10(%esi),%eax 10bd1b: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bd1e: 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 ); 10bd21: 89 75 dc mov %esi,-0x24(%ebp) 10bd24: eb 75 jmp 10bd9b <_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; 10bd26: 31 c0 xor %eax,%eax 10bd28: 39 4e 20 cmp %ecx,0x20(%esi) 10bd2b: 77 08 ja 10bd35 <_Heap_Walk+0x127> 10bd2d: 31 c0 xor %eax,%eax 10bd2f: 39 4e 24 cmp %ecx,0x24(%esi) 10bd32: 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 ) ) { 10bd35: 85 c0 test %eax,%eax 10bd37: 75 0b jne 10bd44 <_Heap_Walk+0x136> (*printer)( 10bd39: 51 push %ecx 10bd3a: 68 92 f8 11 00 push $0x11f892 10bd3f: e9 b7 01 00 00 jmp 10befb <_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; 10bd44: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd47: 31 d2 xor %edx,%edx 10bd49: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bd4c: 85 d2 test %edx,%edx 10bd4e: 74 0b je 10bd5b <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bd50: 51 push %ecx 10bd51: 68 b2 f8 11 00 push $0x11f8b2 10bd56: e9 a0 01 00 00 jmp 10befb <_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; 10bd5b: 8b 41 04 mov 0x4(%ecx),%eax 10bd5e: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bd61: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bd66: 74 0b je 10bd73 <_Heap_Walk+0x165> (*printer)( 10bd68: 51 push %ecx 10bd69: 68 e2 f8 11 00 push $0x11f8e2 10bd6e: e9 88 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10bd73: 8b 41 0c mov 0xc(%ecx),%eax 10bd76: 3b 45 dc cmp -0x24(%ebp),%eax 10bd79: 74 1a je 10bd95 <_Heap_Walk+0x187> (*printer)( 10bd7b: 83 ec 0c sub $0xc,%esp 10bd7e: 50 push %eax 10bd7f: 51 push %ecx 10bd80: 68 fe f8 11 00 push $0x11f8fe 10bd85: 6a 01 push $0x1 10bd87: 53 push %ebx 10bd88: ff 55 e4 call *-0x1c(%ebp) 10bd8b: 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; 10bd8e: 31 c0 xor %eax,%eax 10bd90: e9 ab 01 00 00 jmp 10bf40 <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10bd95: 89 4d dc mov %ecx,-0x24(%ebp) 10bd98: 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 ) { 10bd9b: 39 f1 cmp %esi,%ecx 10bd9d: 75 87 jne 10bd26 <_Heap_Walk+0x118> 10bd9f: 89 5d dc mov %ebx,-0x24(%ebp) 10bda2: eb 02 jmp 10bda6 <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10bda4: 89 df mov %ebx,%edi return true; } 10bda6: 8b 4f 04 mov 0x4(%edi),%ecx 10bda9: 89 4d cc mov %ecx,-0x34(%ebp) 10bdac: 83 e1 fe and $0xfffffffe,%ecx 10bdaf: 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); 10bdb2: 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; 10bdb5: 31 c0 xor %eax,%eax 10bdb7: 39 5e 20 cmp %ebx,0x20(%esi) 10bdba: 77 08 ja 10bdc4 <_Heap_Walk+0x1b6> <== NEVER TAKEN 10bdbc: 31 c0 xor %eax,%eax 10bdbe: 39 5e 24 cmp %ebx,0x24(%esi) 10bdc1: 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 ) ) { 10bdc4: 85 c0 test %eax,%eax 10bdc6: 75 11 jne 10bdd9 <_Heap_Walk+0x1cb> 10bdc8: 89 d9 mov %ebx,%ecx 10bdca: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdcd: 83 ec 0c sub $0xc,%esp 10bdd0: 51 push %ecx 10bdd1: 57 push %edi 10bdd2: 68 30 f9 11 00 push $0x11f930 10bdd7: eb ac jmp 10bd85 <_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; 10bdd9: 3b 7d c8 cmp -0x38(%ebp),%edi 10bddc: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bddf: 8b 45 e0 mov -0x20(%ebp),%eax 10bde2: 31 d2 xor %edx,%edx 10bde4: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10bde7: 85 d2 test %edx,%edx 10bde9: 74 15 je 10be00 <_Heap_Walk+0x1f2> 10bdeb: 84 c9 test %cl,%cl 10bded: 74 11 je 10be00 <_Heap_Walk+0x1f2> 10bdef: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdf2: 83 ec 0c sub $0xc,%esp 10bdf5: ff 75 e0 pushl -0x20(%ebp) 10bdf8: 57 push %edi 10bdf9: 68 5d f9 11 00 push $0x11f95d 10bdfe: eb 85 jmp 10bd85 <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be00: 8b 45 d4 mov -0x2c(%ebp),%eax 10be03: 39 45 e0 cmp %eax,-0x20(%ebp) 10be06: 73 18 jae 10be20 <_Heap_Walk+0x212> 10be08: 84 c9 test %cl,%cl 10be0a: 74 14 je 10be20 <_Heap_Walk+0x212> <== NEVER TAKEN 10be0c: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be0f: 52 push %edx 10be10: 52 push %edx 10be11: 50 push %eax 10be12: ff 75 e0 pushl -0x20(%ebp) 10be15: 57 push %edi 10be16: 68 8b f9 11 00 push $0x11f98b 10be1b: e9 65 ff ff ff jmp 10bd85 <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10be20: 39 fb cmp %edi,%ebx 10be22: 77 18 ja 10be3c <_Heap_Walk+0x22e> 10be24: 84 c9 test %cl,%cl 10be26: 74 14 je 10be3c <_Heap_Walk+0x22e> 10be28: 89 d9 mov %ebx,%ecx 10be2a: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be2d: 83 ec 0c sub $0xc,%esp 10be30: 51 push %ecx 10be31: 57 push %edi 10be32: 68 b6 f9 11 00 push $0x11f9b6 10be37: e9 49 ff ff ff jmp 10bd85 <_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; 10be3c: 8b 4d cc mov -0x34(%ebp),%ecx 10be3f: 83 e1 01 and $0x1,%ecx 10be42: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10be45: f6 43 04 01 testb $0x1,0x4(%ebx) 10be49: 0f 85 ba 00 00 00 jne 10bf09 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10be4f: 8b 46 08 mov 0x8(%esi),%eax 10be52: 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 ? 10be55: 8b 4f 08 mov 0x8(%edi),%ecx 10be58: 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)( 10be5b: ba d6 f6 11 00 mov $0x11f6d6,%edx 10be60: 3b 4e 0c cmp 0xc(%esi),%ecx 10be63: 74 0e je 10be73 <_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)" : "") 10be65: ba 0d f6 11 00 mov $0x11f60d,%edx 10be6a: 39 f1 cmp %esi,%ecx 10be6c: 75 05 jne 10be73 <_Heap_Walk+0x265> 10be6e: ba e5 f6 11 00 mov $0x11f6e5,%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 ? 10be73: 8b 47 0c mov 0xc(%edi),%eax 10be76: 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)( 10be79: b8 ef f6 11 00 mov $0x11f6ef,%eax 10be7e: 8b 4d c0 mov -0x40(%ebp),%ecx 10be81: 39 4d cc cmp %ecx,-0x34(%ebp) 10be84: 74 0f je 10be95 <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10be86: b8 0d f6 11 00 mov $0x11f60d,%eax 10be8b: 39 75 cc cmp %esi,-0x34(%ebp) 10be8e: 75 05 jne 10be95 <_Heap_Walk+0x287> 10be90: b8 ff f6 11 00 mov $0x11f6ff,%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)( 10be95: 83 ec 0c sub $0xc,%esp 10be98: 52 push %edx 10be99: ff 75 b4 pushl -0x4c(%ebp) 10be9c: 50 push %eax 10be9d: ff 75 cc pushl -0x34(%ebp) 10bea0: ff 75 e0 pushl -0x20(%ebp) 10bea3: 57 push %edi 10bea4: 68 ea f9 11 00 push $0x11f9ea 10bea9: 6a 00 push $0x0 10beab: ff 75 dc pushl -0x24(%ebp) 10beae: 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 ) { 10beb1: 8b 03 mov (%ebx),%eax 10beb3: 83 c4 30 add $0x30,%esp 10beb6: 39 45 e0 cmp %eax,-0x20(%ebp) 10beb9: 74 16 je 10bed1 <_Heap_Walk+0x2c3> 10bebb: 89 d9 mov %ebx,%ecx 10bebd: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bec0: 56 push %esi 10bec1: 51 push %ecx 10bec2: 50 push %eax 10bec3: ff 75 e0 pushl -0x20(%ebp) 10bec6: 57 push %edi 10bec7: 68 1f fa 11 00 push $0x11fa1f 10becc: e9 b4 fe ff ff jmp 10bd85 <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bed1: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bed5: 75 0b jne 10bee2 <_Heap_Walk+0x2d4> 10bed7: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10beda: 57 push %edi 10bedb: 68 58 fa 11 00 push $0x11fa58 10bee0: eb 19 jmp 10befb <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10bee2: 8b 46 08 mov 0x8(%esi),%eax 10bee5: eb 07 jmp 10beee <_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 ) { 10bee7: 39 f8 cmp %edi,%eax 10bee9: 74 4a je 10bf35 <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10beeb: 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 ) { 10beee: 39 f0 cmp %esi,%eax 10bef0: 75 f5 jne 10bee7 <_Heap_Walk+0x2d9> 10bef2: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10bef5: 57 push %edi 10bef6: 68 c3 fa 11 00 push $0x11fac3 10befb: 6a 01 push $0x1 10befd: 53 push %ebx 10befe: ff 55 e4 call *-0x1c(%ebp) 10bf01: 83 c4 10 add $0x10,%esp 10bf04: e9 85 fe ff ff jmp 10bd8e <_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) { 10bf09: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf0d: 74 0e je 10bf1d <_Heap_Walk+0x30f> (*printer)( 10bf0f: 83 ec 0c sub $0xc,%esp 10bf12: ff 75 e0 pushl -0x20(%ebp) 10bf15: 57 push %edi 10bf16: 68 87 fa 11 00 push $0x11fa87 10bf1b: eb 0d jmp 10bf2a <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bf1d: 51 push %ecx 10bf1e: 51 push %ecx 10bf1f: ff 37 pushl (%edi) 10bf21: ff 75 e0 pushl -0x20(%ebp) 10bf24: 57 push %edi 10bf25: 68 9e fa 11 00 push $0x11fa9e 10bf2a: 6a 00 push $0x0 10bf2c: ff 75 dc pushl -0x24(%ebp) 10bf2f: ff 55 e4 call *-0x1c(%ebp) 10bf32: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bf35: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bf38: 0f 85 66 fe ff ff jne 10bda4 <_Heap_Walk+0x196> return true; 10bf3e: b0 01 mov $0x1,%al } 10bf40: 8d 65 f4 lea -0xc(%ebp),%esp 10bf43: 5b pop %ebx 10bf44: 5e pop %esi 10bf45: 5f pop %edi 10bf46: c9 leave 10bf47: c3 ret =============================================================================== 0010b230 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b230: 55 push %ebp 10b231: 89 e5 mov %esp,%ebp 10b233: 53 push %ebx 10b234: 83 ec 08 sub $0x8,%esp 10b237: 8b 45 08 mov 0x8(%ebp),%eax 10b23a: 8b 55 0c mov 0xc(%ebp),%edx 10b23d: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b240: a3 7c 43 12 00 mov %eax,0x12437c _Internal_errors_What_happened.is_internal = is_internal; 10b245: 88 15 80 43 12 00 mov %dl,0x124380 _Internal_errors_What_happened.the_error = the_error; 10b24b: 89 1d 84 43 12 00 mov %ebx,0x124384 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b251: 53 push %ebx 10b252: 0f b6 d2 movzbl %dl,%edx 10b255: 52 push %edx 10b256: 50 push %eax 10b257: e8 23 19 00 00 call 10cb7f <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b25c: c7 05 64 44 12 00 05 movl $0x5,0x124464 <== NOT EXECUTED 10b263: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b266: fa cli <== NOT EXECUTED 10b267: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b269: f4 hlt <== NOT EXECUTED 10b26a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b26d: eb fe jmp 10b26d <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b2c0 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b2c0: 55 push %ebp 10b2c1: 89 e5 mov %esp,%ebp 10b2c3: 56 push %esi 10b2c4: 53 push %ebx 10b2c5: 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; 10b2c8: 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 ) 10b2ca: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b2ce: 74 53 je 10b323 <_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 ); 10b2d0: 8d 73 20 lea 0x20(%ebx),%esi 10b2d3: 83 ec 0c sub $0xc,%esp 10b2d6: 56 push %esi 10b2d7: e8 30 f7 ff ff call 10aa0c <_Chain_Get> 10b2dc: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b2de: 83 c4 10 add $0x10,%esp 10b2e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b2e5: 74 3c je 10b323 <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b2e7: 85 c0 test %eax,%eax 10b2e9: 75 1a jne 10b305 <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b2eb: 83 ec 0c sub $0xc,%esp 10b2ee: 53 push %ebx 10b2ef: e8 60 00 00 00 call 10b354 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b2f4: 89 34 24 mov %esi,(%esp) 10b2f7: e8 10 f7 ff ff call 10aa0c <_Chain_Get> 10b2fc: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b2fe: 83 c4 10 add $0x10,%esp 10b301: 85 c0 test %eax,%eax 10b303: 74 1e je 10b323 <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b305: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b309: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b30d: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b30f: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b313: 31 d2 xor %edx,%edx 10b315: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b317: c1 e0 02 shl $0x2,%eax 10b31a: 03 43 30 add 0x30(%ebx),%eax 10b31d: ff 08 decl (%eax) information->inactive--; 10b31f: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b323: 89 c8 mov %ecx,%eax 10b325: 8d 65 f8 lea -0x8(%ebp),%esp 10b328: 5b pop %ebx 10b329: 5e pop %esi 10b32a: c9 leave 10b32b: c3 ret =============================================================================== 0010b648 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b648: 55 push %ebp 10b649: 89 e5 mov %esp,%ebp 10b64b: 57 push %edi 10b64c: 56 push %esi 10b64d: 53 push %ebx 10b64e: 83 ec 0c sub $0xc,%esp 10b651: 8b 75 08 mov 0x8(%ebp),%esi 10b654: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b657: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b659: 66 85 ff test %di,%di 10b65c: 74 37 je 10b695 <_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 ); 10b65e: 83 ec 0c sub $0xc,%esp 10b661: 56 push %esi 10b662: e8 b1 40 00 00 call 10f718 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b667: 83 c4 10 add $0x10,%esp 10b66a: 85 c0 test %eax,%eax 10b66c: 74 27 je 10b695 <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b66e: 0f b7 ff movzwl %di,%edi 10b671: 39 c7 cmp %eax,%edi 10b673: 77 20 ja 10b695 <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b675: 8b 04 b5 bc 42 12 00 mov 0x1242bc(,%esi,4),%eax 10b67c: 85 c0 test %eax,%eax 10b67e: 74 15 je 10b695 <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b680: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b683: 85 db test %ebx,%ebx 10b685: 74 0e je 10b695 <_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; 10b687: 31 c0 xor %eax,%eax 10b689: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b68e: 0f 95 c0 setne %al 10b691: f7 d8 neg %eax 10b693: 21 c3 and %eax,%ebx #endif return info; } 10b695: 89 d8 mov %ebx,%eax 10b697: 8d 65 f4 lea -0xc(%ebp),%esp 10b69a: 5b pop %ebx 10b69b: 5e pop %esi 10b69c: 5f pop %edi 10b69d: c9 leave 10b69e: c3 ret =============================================================================== 00118abc <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118abc: 55 push %ebp 118abd: 89 e5 mov %esp,%ebp 118abf: 53 push %ebx 118ac0: 8b 55 08 mov 0x8(%ebp),%edx 118ac3: 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; 118ac6: b8 01 00 00 00 mov $0x1,%eax 118acb: 2b 42 08 sub 0x8(%edx),%eax 118ace: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118ad1: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118ad5: 39 c3 cmp %eax,%ebx 118ad7: 72 12 jb 118aeb <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118ad9: 8b 52 1c mov 0x1c(%edx),%edx 118adc: 8b 04 82 mov (%edx,%eax,4),%eax 118adf: 85 c0 test %eax,%eax 118ae1: 74 08 je 118aeb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118ae3: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118ae9: eb 08 jmp 118af3 <_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; 118aeb: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118af1: 31 c0 xor %eax,%eax } 118af3: 5b pop %ebx 118af4: c9 leave 118af5: c3 ret =============================================================================== 0010c874 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c874: 55 push %ebp 10c875: 89 e5 mov %esp,%ebp 10c877: 53 push %ebx 10c878: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c87b: 8b 45 08 mov 0x8(%ebp),%eax 10c87e: 85 c0 test %eax,%eax 10c880: 75 08 jne 10c88a <_Objects_Id_to_name+0x16> 10c882: a1 80 78 12 00 mov 0x127880,%eax 10c887: 8b 40 08 mov 0x8(%eax),%eax 10c88a: 89 c2 mov %eax,%edx 10c88c: c1 ea 18 shr $0x18,%edx 10c88f: 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 ) 10c892: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c895: bb 03 00 00 00 mov $0x3,%ebx 10c89a: 83 f9 02 cmp $0x2,%ecx 10c89d: 77 36 ja 10c8d5 <_Objects_Id_to_name+0x61> 10c89f: eb 3b jmp 10c8dc <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c8a1: 89 c1 mov %eax,%ecx 10c8a3: 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 ]; 10c8a6: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8a9: 85 d2 test %edx,%edx 10c8ab: 74 28 je 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8ad: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8b1: 75 22 jne 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8b3: 51 push %ecx 10c8b4: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8b7: 51 push %ecx 10c8b8: 50 push %eax 10c8b9: 52 push %edx 10c8ba: e8 5d ff ff ff call 10c81c <_Objects_Get> if ( !the_object ) 10c8bf: 83 c4 10 add $0x10,%esp 10c8c2: 85 c0 test %eax,%eax 10c8c4: 74 0f je 10c8d5 <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c8c6: 8b 50 0c mov 0xc(%eax),%edx 10c8c9: 8b 45 0c mov 0xc(%ebp),%eax 10c8cc: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c8ce: e8 9f 07 00 00 call 10d072 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c8d3: 31 db xor %ebx,%ebx } 10c8d5: 89 d8 mov %ebx,%eax 10c8d7: 8b 5d fc mov -0x4(%ebp),%ebx 10c8da: c9 leave 10c8db: 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 ] ) 10c8dc: 8b 14 95 08 73 12 00 mov 0x127308(,%edx,4),%edx 10c8e3: 85 d2 test %edx,%edx 10c8e5: 75 ba jne 10c8a1 <_Objects_Id_to_name+0x2d> 10c8e7: eb ec jmp 10c8d5 <_Objects_Id_to_name+0x61> =============================================================================== 0010e2b8 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e2b8: 55 push %ebp 10e2b9: 89 e5 mov %esp,%ebp 10e2bb: 57 push %edi 10e2bc: 56 push %esi 10e2bd: 53 push %ebx 10e2be: 83 ec 30 sub $0x30,%esp 10e2c1: 8b 75 08 mov 0x8(%ebp),%esi 10e2c4: 8b 5d 14 mov 0x14(%ebp),%ebx 10e2c7: 8a 55 18 mov 0x18(%ebp),%dl POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10e2ca: 8d 45 e4 lea -0x1c(%ebp),%eax RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10e2cd: 50 push %eax 10e2ce: 56 push %esi 10e2cf: 68 7c d9 12 00 push $0x12d97c 10e2d4: 88 55 d4 mov %dl,-0x2c(%ebp) 10e2d7: e8 f0 2a 00 00 call 110dcc <_Objects_Get> switch ( location ) { 10e2dc: 83 c4 10 add $0x10,%esp 10e2df: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e2e3: 8a 55 d4 mov -0x2c(%ebp),%dl 10e2e6: 0f 85 aa 00 00 00 jne 10e396 <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e2ec: 8b 78 14 mov 0x14(%eax),%edi 10e2ef: 89 f9 mov %edi,%ecx 10e2f1: 83 e1 03 and $0x3,%ecx 10e2f4: 49 dec %ecx 10e2f5: 75 0a jne 10e301 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e2f7: e8 22 33 00 00 call 11161e <_Thread_Enable_dispatch> 10e2fc: e9 95 00 00 00 jmp 10e396 <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e301: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e304: 8b 48 68 mov 0x68(%eax),%ecx 10e307: 39 4d 10 cmp %ecx,0x10(%ebp) 10e30a: 73 15 jae 10e321 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e30c: e8 0d 33 00 00 call 11161e <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e311: e8 be 8a 00 00 call 116dd4 <__errno> 10e316: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e31c: e9 80 00 00 00 jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e321: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10e328: 31 c9 xor %ecx,%ecx 10e32a: 84 d2 test %dl,%dl 10e32c: 74 09 je 10e337 <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e32e: 81 e7 00 40 00 00 and $0x4000,%edi 10e334: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e337: 52 push %edx 10e338: 52 push %edx 10e339: ff 75 1c pushl 0x1c(%ebp) 10e33c: 0f b6 c9 movzbl %cl,%ecx 10e33f: 51 push %ecx 10e340: 8d 55 e0 lea -0x20(%ebp),%edx 10e343: 52 push %edx 10e344: ff 75 0c pushl 0xc(%ebp) 10e347: 56 push %esi 10e348: 83 c0 1c add $0x1c,%eax 10e34b: 50 push %eax 10e34c: e8 73 1c 00 00 call 10ffc4 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e351: 83 c4 20 add $0x20,%esp 10e354: e8 c5 32 00 00 call 11161e <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e359: a1 f4 d9 12 00 mov 0x12d9f4,%eax RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core( CORE_message_queue_Submit_types priority ) { /* absolute value without a library dependency */ return ((priority >= 0) ? priority : -priority); 10e35e: 8b 50 24 mov 0x24(%eax),%edx 10e361: c1 fa 1f sar $0x1f,%edx 10e364: 8b 48 24 mov 0x24(%eax),%ecx 10e367: 31 d1 xor %edx,%ecx 10e369: 89 0b mov %ecx,(%ebx) 10e36b: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e36d: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e371: 75 05 jne 10e378 <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e373: 8b 45 e0 mov -0x20(%ebp),%eax 10e376: eb 2c jmp 10e3a4 <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e378: e8 57 8a 00 00 call 116dd4 <__errno> 10e37d: 89 c3 mov %eax,%ebx 10e37f: 83 ec 0c sub $0xc,%esp 10e382: a1 f4 d9 12 00 mov 0x12d9f4,%eax 10e387: ff 70 34 pushl 0x34(%eax) 10e38a: e8 ed 01 00 00 call 10e57c <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e38f: 89 03 mov %eax,(%ebx) 10e391: 83 c4 10 add $0x10,%esp 10e394: eb 0b jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e396: e8 39 8a 00 00 call 116dd4 <__errno> 10e39b: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3a1: 83 c8 ff or $0xffffffff,%eax } 10e3a4: 8d 65 f4 lea -0xc(%ebp),%esp 10e3a7: 5b pop %ebx 10e3a8: 5e pop %esi 10e3a9: 5f pop %edi 10e3aa: c9 leave 10e3ab: c3 ret =============================================================================== 0010e86c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e86c: 55 push %ebp 10e86d: 89 e5 mov %esp,%ebp 10e86f: 83 ec 08 sub $0x8,%esp 10e872: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e875: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e87b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e882: 75 2c jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e884: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e88b: 75 23 jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e88d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e894: 74 1a je 10e8b0 <_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; 10e896: a1 d4 52 12 00 mov 0x1252d4,%eax 10e89b: 48 dec %eax 10e89c: a3 d4 52 12 00 mov %eax,0x1252d4 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e8a1: 50 push %eax 10e8a2: 50 push %eax 10e8a3: 6a ff push $0xffffffff 10e8a5: 52 push %edx 10e8a6: e8 51 08 00 00 call 10f0fc <_POSIX_Thread_Exit> 10e8ab: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10e8ae: c9 leave 10e8af: c3 ret 10e8b0: 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(); 10e8b1: e9 c0 d9 ff ff jmp 10c276 <_Thread_Enable_dispatch> =============================================================================== 0010faf0 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10faf0: 55 push %ebp 10faf1: 89 e5 mov %esp,%ebp 10faf3: 57 push %edi 10faf4: 56 push %esi 10faf5: 53 push %ebx 10faf6: 83 ec 28 sub $0x28,%esp 10faf9: 8b 55 08 mov 0x8(%ebp),%edx 10fafc: 8b 5d 0c mov 0xc(%ebp),%ebx 10faff: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fb02: ff 33 pushl (%ebx) 10fb04: 89 55 e0 mov %edx,-0x20(%ebp) 10fb07: e8 c4 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid> 10fb0c: 83 c4 10 add $0x10,%esp return EINVAL; 10fb0f: 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 ) ) 10fb14: 84 c0 test %al,%al 10fb16: 8b 55 e0 mov -0x20(%ebp),%edx 10fb19: 0f 84 a4 00 00 00 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fb1f: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fb25: 8b 45 14 mov 0x14(%ebp),%eax 10fb28: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fb2e: 85 d2 test %edx,%edx 10fb30: 75 0b jne 10fb3d <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fb32: c7 07 01 00 00 00 movl $0x1,(%edi) 10fb38: e9 83 00 00 00 jmp 10fbc0 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fb3d: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fb3f: 83 fa 01 cmp $0x1,%edx 10fb42: 74 7f je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fb44: 83 fa 02 cmp $0x2,%edx 10fb47: 75 08 jne 10fb51 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fb49: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fb4f: eb 72 jmp 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fb51: 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 ) { 10fb56: 83 fa 04 cmp $0x4,%edx 10fb59: 75 68 jne 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fb5b: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fb5f: 75 06 jne 10fb67 <_POSIX_Thread_Translate_sched_param+0x77> 10fb61: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fb65: 74 5c je 10fbc3 <_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) && 10fb67: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fb6b: 75 0b jne 10fb78 <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fb6d: 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) && 10fb72: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fb76: 74 4b je 10fbc3 <_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 ) < 10fb78: 83 ec 0c sub $0xc,%esp 10fb7b: 8d 43 08 lea 0x8(%ebx),%eax 10fb7e: 50 push %eax 10fb7f: e8 14 de ff ff call 10d998 <_Timespec_To_ticks> 10fb84: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fb87: 8d 43 10 lea 0x10(%ebx),%eax 10fb8a: 89 04 24 mov %eax,(%esp) 10fb8d: e8 06 de ff ff call 10d998 <_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 ) < 10fb92: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fb95: 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 ) < 10fb9a: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fb9d: 72 24 jb 10fbc3 <_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 ) ) 10fb9f: 83 ec 0c sub $0xc,%esp 10fba2: ff 73 04 pushl 0x4(%ebx) 10fba5: e8 26 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid> 10fbaa: 83 c4 10 add $0x10,%esp 10fbad: 84 c0 test %al,%al 10fbaf: 74 12 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fbb1: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fbb7: 8b 45 14 mov 0x14(%ebp),%eax 10fbba: c7 00 e9 a7 10 00 movl $0x10a7e9,(%eax) return 0; 10fbc0: 66 31 f6 xor %si,%si } return EINVAL; } 10fbc3: 89 f0 mov %esi,%eax 10fbc5: 8d 65 f4 lea -0xc(%ebp),%esp 10fbc8: 5b pop %ebx 10fbc9: 5e pop %esi 10fbca: 5f pop %edi 10fbcb: c9 leave 10fbcc: c3 ret =============================================================================== 0010a4ec <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a4ec: 55 push %ebp 10a4ed: 89 e5 mov %esp,%ebp 10a4ef: 57 push %edi 10a4f0: 56 push %esi 10a4f1: 53 push %ebx 10a4f2: 83 ec 6c sub $0x6c,%esp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = Configuration_POSIX_API.User_initialization_threads_table; 10a4f5: 8b 3d 10 12 12 00 mov 0x121210,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a4fb: 8b 15 0c 12 12 00 mov 0x12120c,%edx if ( !user_threads || maximum == 0 ) 10a501: 85 d2 test %edx,%edx 10a503: 74 54 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a505: 85 ff test %edi,%edi 10a507: 74 50 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a509: 31 db xor %ebx,%ebx for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10a50b: 8d 75 a4 lea -0x5c(%ebp),%esi 10a50e: 83 ec 0c sub $0xc,%esp 10a511: 56 push %esi 10a512: 89 55 94 mov %edx,-0x6c(%ebp) 10a515: e8 b6 56 00 00 call 10fbd0 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a51a: 5a pop %edx 10a51b: 59 pop %ecx 10a51c: 6a 02 push $0x2 10a51e: 56 push %esi 10a51f: e8 d4 56 00 00 call 10fbf8 (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a524: 59 pop %ecx 10a525: 58 pop %eax 10a526: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a52a: 56 push %esi 10a52b: e8 f4 56 00 00 call 10fc24 status = pthread_create( 10a530: 6a 00 push $0x0 10a532: ff 34 df pushl (%edi,%ebx,8) 10a535: 56 push %esi 10a536: 8d 45 e4 lea -0x1c(%ebp),%eax 10a539: 50 push %eax 10a53a: e8 e5 fc ff ff call 10a224 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a53f: 83 c4 20 add $0x20,%esp 10a542: 85 c0 test %eax,%eax 10a544: 8b 55 94 mov -0x6c(%ebp),%edx 10a547: 74 0b je 10a554 <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a549: 52 push %edx 10a54a: 50 push %eax 10a54b: 6a 01 push $0x1 10a54d: 6a 02 push $0x2 10a54f: e8 e4 1b 00 00 call 10c138 <_Internal_error_Occurred> * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10a554: 43 inc %ebx 10a555: 39 d3 cmp %edx,%ebx 10a557: 72 b5 jb 10a50e <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a559: 8d 65 f4 lea -0xc(%ebp),%esp 10a55c: 5b pop %ebx 10a55d: 5e pop %esi 10a55e: 5f pop %edi 10a55f: c9 leave 10a560: c3 ret =============================================================================== 0010ec4f <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10ec4f: 55 push %ebp 10ec50: 89 e5 mov %esp,%ebp 10ec52: 56 push %esi 10ec53: 53 push %ebx 10ec54: 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 ]; 10ec57: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 10ec5d: 83 ec 0c sub $0xc,%esp 10ec60: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ec66: 50 push %eax 10ec67: e8 94 0e 00 00 call 10fb00 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10ec6c: 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); 10ec6f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax 10ec76: 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; 10ec7c: 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 ) { 10ec7f: 83 c4 10 add $0x10,%esp 10ec82: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ec86: 75 12 jne 10ec9a <_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 ) { 10ec88: 39 43 14 cmp %eax,0x14(%ebx) 10ec8b: 76 0d jbe 10ec9a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ec8d: 52 push %edx 10ec8e: 6a 01 push $0x1 10ec90: 50 push %eax 10ec91: 53 push %ebx 10ec92: e8 a5 cd ff ff call 10ba3c <_Thread_Change_priority> 10ec97: 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 ); 10ec9a: 83 ec 0c sub $0xc,%esp 10ec9d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10eca3: 50 push %eax 10eca4: e8 57 0e 00 00 call 10fb00 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10eca9: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ecaf: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ecb2: 81 c6 a8 00 00 00 add $0xa8,%esi 10ecb8: 89 75 0c mov %esi,0xc(%ebp) 10ecbb: c7 45 08 ac 43 12 00 movl $0x1243ac,0x8(%ebp) } 10ecc2: 8d 65 f8 lea -0x8(%ebp),%esp 10ecc5: 5b pop %ebx 10ecc6: 5e pop %esi 10ecc7: c9 leave 10ecc8: e9 d3 df ff ff jmp 10cca0 <_Watchdog_Insert> =============================================================================== 0010eccd <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10eccd: 55 push %ebp 10ecce: 89 e5 mov %esp,%ebp 10ecd0: 83 ec 08 sub $0x8,%esp 10ecd3: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ecd6: 8b 88 f8 00 00 00 mov 0xf8(%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 */ 10ecdc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10ece3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx 10ecea: 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; 10ecf0: 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 ) { 10ecf3: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10ecf7: 75 12 jne 10ed0b <_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 ) { 10ecf9: 39 50 14 cmp %edx,0x14(%eax) 10ecfc: 73 0d jae 10ed0b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10ecfe: 51 push %ecx 10ecff: 6a 01 push $0x1 10ed01: 52 push %edx 10ed02: 50 push %eax 10ed03: e8 34 cd ff ff call 10ba3c <_Thread_Change_priority> 10ed08: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10ed0b: c9 leave 10ed0c: c3 ret =============================================================================== 0010a2ac <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 10a2ac: 55 push %ebp 10a2ad: 89 e5 mov %esp,%ebp 10a2af: 53 push %ebx 10a2b0: 83 ec 04 sub $0x4,%esp 10a2b3: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a2b6: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a2b9: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a2bd: 75 06 jne 10a2c5 <_POSIX_Timer_TSR+0x19> 10a2bf: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a2c3: 74 34 je 10a2f9 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a2c5: 83 ec 0c sub $0xc,%esp 10a2c8: 53 push %ebx 10a2c9: 68 ac a2 10 00 push $0x10a2ac 10a2ce: ff 73 08 pushl 0x8(%ebx) 10a2d1: ff 73 64 pushl 0x64(%ebx) 10a2d4: 8d 43 10 lea 0x10(%ebx),%eax 10a2d7: 50 push %eax 10a2d8: e8 d3 55 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a2dd: 83 c4 20 add $0x20,%esp 10a2e0: 84 c0 test %al,%al 10a2e2: 74 30 je 10a314 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a2e4: 83 ec 0c sub $0xc,%esp 10a2e7: 8d 43 6c lea 0x6c(%ebx),%eax 10a2ea: 50 push %eax 10a2eb: e8 50 14 00 00 call 10b740 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2f0: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a2f4: 83 c4 10 add $0x10,%esp 10a2f7: eb 04 jmp 10a2fd <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a2f9: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10a2fd: 50 push %eax 10a2fe: 50 push %eax 10a2ff: ff 73 44 pushl 0x44(%ebx) 10a302: ff 73 38 pushl 0x38(%ebx) 10a305: e8 7a 51 00 00 call 10f484 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a30a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a311: 83 c4 10 add $0x10,%esp } 10a314: 8b 5d fc mov -0x4(%ebp),%ebx 10a317: c9 leave 10a318: c3 ret =============================================================================== 00110ac8 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110ac8: 55 push %ebp 110ac9: 89 e5 mov %esp,%ebp 110acb: 57 push %edi 110acc: 56 push %esi 110acd: 53 push %ebx 110ace: 83 ec 68 sub $0x68,%esp 110ad1: 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, 110ad4: 6a 01 push $0x1 110ad6: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110ada: 50 push %eax 110adb: 8d 45 dc lea -0x24(%ebp),%eax 110ade: 50 push %eax 110adf: 53 push %ebx 110ae0: ff 75 08 pushl 0x8(%ebp) 110ae3: e8 8c 00 00 00 call 110b74 <_POSIX_signals_Clear_signals> 110ae8: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110aeb: 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, 110aed: 84 c0 test %al,%al 110aef: 74 78 je 110b69 <_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 ) 110af1: 6b d3 0c imul $0xc,%ebx,%edx 110af4: 8b 82 4c 48 12 00 mov 0x12484c(%edx),%eax 110afa: 83 f8 01 cmp $0x1,%eax 110afd: 74 6a je 110b69 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110aff: 8b 4d 08 mov 0x8(%ebp),%ecx 110b02: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110b08: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110b0b: 0b 8a 48 48 12 00 or 0x124848(%edx),%ecx 110b11: 8b 75 08 mov 0x8(%ebp),%esi 110b14: 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, 110b1a: 8d 7d b4 lea -0x4c(%ebp),%edi 110b1d: 8b 35 34 48 12 00 mov 0x124834,%esi 110b23: 83 c6 20 add $0x20,%esi 110b26: b9 0a 00 00 00 mov $0xa,%ecx 110b2b: 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 ) { 110b2d: 83 ba 44 48 12 00 02 cmpl $0x2,0x124844(%edx) 110b34: 75 09 jne 110b3f <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110b36: 52 push %edx 110b37: 6a 00 push $0x0 110b39: 8d 55 dc lea -0x24(%ebp),%edx 110b3c: 52 push %edx 110b3d: eb 03 jmp 110b42 <_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 ); 110b3f: 83 ec 0c sub $0xc,%esp 110b42: 53 push %ebx 110b43: ff d0 call *%eax break; 110b45: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110b48: 8b 3d 34 48 12 00 mov 0x124834,%edi 110b4e: 83 c7 20 add $0x20,%edi 110b51: 8d 75 b4 lea -0x4c(%ebp),%esi 110b54: b9 0a 00 00 00 mov $0xa,%ecx 110b59: 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; 110b5b: 8b 75 a4 mov -0x5c(%ebp),%esi 110b5e: 8b 4d 08 mov 0x8(%ebp),%ecx 110b61: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110b67: b1 01 mov $0x1,%cl } 110b69: 88 c8 mov %cl,%al 110b6b: 8d 65 f4 lea -0xc(%ebp),%esp 110b6e: 5b pop %ebx 110b6f: 5e pop %esi 110b70: 5f pop %edi 110b71: c9 leave 110b72: c3 ret =============================================================================== 0011105c <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 11105c: 55 push %ebp 11105d: 89 e5 mov %esp,%ebp 11105f: 53 push %ebx 111060: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 111063: 9c pushf 111064: fa cli 111065: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 111066: 6b c1 0c imul $0xc,%ecx,%eax 111069: 83 b8 44 48 12 00 02 cmpl $0x2,0x124844(%eax) 111070: 75 0e jne 111080 <_POSIX_signals_Clear_process_signals+0x24> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 111072: 8d 98 40 4a 12 00 lea 0x124a40(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 111078: 39 98 3c 4a 12 00 cmp %ebx,0x124a3c(%eax) 11107e: 75 0e jne 11108e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 111080: 49 dec %ecx 111081: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 111086: d3 c0 rol %cl,%eax 111088: 21 05 38 4a 12 00 and %eax,0x124a38 } _ISR_Enable( level ); 11108e: 52 push %edx 11108f: 9d popf } 111090: 5b pop %ebx 111091: c9 leave 111092: c3 ret =============================================================================== 0010ab64 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10ab64: 55 push %ebp 10ab65: 89 e5 mov %esp,%ebp 10ab67: 56 push %esi 10ab68: 53 push %ebx 10ab69: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab6c: b8 1b 00 00 00 mov $0x1b,%eax 10ab71: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab76: 8d 48 ff lea -0x1(%eax),%ecx 10ab79: 89 de mov %ebx,%esi 10ab7b: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab7d: 85 d6 test %edx,%esi 10ab7f: 75 1e jne 10ab9f <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab81: 40 inc %eax 10ab82: 83 f8 20 cmp $0x20,%eax 10ab85: 75 ef jne 10ab76 <_POSIX_signals_Get_lowest+0x12> 10ab87: b0 01 mov $0x1,%al 10ab89: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab8e: 8d 48 ff lea -0x1(%eax),%ecx 10ab91: 89 de mov %ebx,%esi 10ab93: d3 e6 shl %cl,%esi #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab95: 85 d6 test %edx,%esi 10ab97: 75 06 jne 10ab9f <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ab99: 40 inc %eax 10ab9a: 83 f8 1b cmp $0x1b,%eax 10ab9d: 75 ef jne 10ab8e <_POSIX_signals_Get_lowest+0x2a><== ALWAYS TAKEN * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 10ab9f: 5b pop %ebx 10aba0: 5e pop %esi 10aba1: c9 leave 10aba2: c3 ret =============================================================================== 00121868 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 121868: 55 push %ebp 121869: 89 e5 mov %esp,%ebp 12186b: 57 push %edi 12186c: 56 push %esi 12186d: 53 push %ebx 12186e: 83 ec 0c sub $0xc,%esp 121871: 8b 5d 08 mov 0x8(%ebp),%ebx 121874: 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 ]; 121877: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax 12187d: 8d 4e ff lea -0x1(%esi),%ecx 121880: ba 01 00 00 00 mov $0x1,%edx 121885: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 121887: 8b 4b 10 mov 0x10(%ebx),%ecx 12188a: 89 cf mov %ecx,%edi 12188c: 81 e7 00 80 00 10 and $0x10008000,%edi 121892: 81 ff 00 80 00 10 cmp $0x10008000,%edi 121898: 75 58 jne 1218f2 <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 12189a: 85 53 30 test %edx,0x30(%ebx) 12189d: 75 12 jne 1218b1 <_POSIX_signals_Unblock_thread+0x49> 12189f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1218a5: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 1218a7: 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) ) { 1218a9: 85 c2 test %eax,%edx 1218ab: 0f 84 b0 00 00 00 je 121961 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 1218b1: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 1218b8: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 1218bb: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1218bf: 75 12 jne 1218d3 <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 1218c1: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 1218c3: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 1218ca: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 1218d1: eb 0c jmp 1218df <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 1218d3: b9 03 00 00 00 mov $0x3,%ecx 1218d8: 89 c7 mov %eax,%edi 1218da: 8b 75 10 mov 0x10(%ebp),%esi 1218dd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 1218df: 83 ec 0c sub $0xc,%esp 1218e2: 53 push %ebx 1218e3: e8 0c f4 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy> return true; 1218e8: 83 c4 10 add $0x10,%esp 1218eb: bf 01 00 00 00 mov $0x1,%edi 1218f0: eb 6f jmp 121961 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 1218f2: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1218f8: 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; 1218fa: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 1218fc: 85 c2 test %eax,%edx 1218fe: 74 61 je 121961 <_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 ) ) { 121900: f7 c1 00 00 00 10 test $0x10000000,%ecx 121906: 74 3d je 121945 <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 121908: 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) ) 12190f: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 121915: 74 0b je 121922 <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 121917: 83 ec 0c sub $0xc,%esp 12191a: 53 push %ebx 12191b: e8 d4 f3 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy> 121920: eb 1e jmp 121940 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 121922: 80 e1 08 and $0x8,%cl 121925: 74 3a je 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 121927: 83 ec 0c sub $0xc,%esp 12192a: 8d 43 48 lea 0x48(%ebx),%eax 12192d: 50 push %eax 12192e: e8 4d fc fe ff call 111580 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 121933: 58 pop %eax 121934: 5a pop %edx 121935: 68 f8 ff 03 10 push $0x1003fff8 12193a: 53 push %ebx 12193b: e8 e4 e9 fe ff call 110324 <_Thread_Clear_state> 121940: 83 c4 10 add $0x10,%esp 121943: eb 1c jmp 121961 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 121945: 85 c9 test %ecx,%ecx 121947: 75 18 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 121949: 83 3d a4 a9 12 00 00 cmpl $0x0,0x12a9a4 121950: 74 0f je 121961 <_POSIX_signals_Unblock_thread+0xf9> 121952: 3b 1d a8 a9 12 00 cmp 0x12a9a8,%ebx 121958: 75 07 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 12195a: c6 05 b4 a9 12 00 01 movb $0x1,0x12a9b4 } } return false; } 121961: 89 f8 mov %edi,%eax 121963: 8d 65 f4 lea -0xc(%ebp),%esp 121966: 5b pop %ebx 121967: 5e pop %esi 121968: 5f pop %edi 121969: c9 leave 12196a: c3 ret =============================================================================== 0010b3b4 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3b4: 55 push %ebp 10b3b5: 89 e5 mov %esp,%ebp 10b3b7: 53 push %ebx 10b3b8: 83 ec 18 sub $0x18,%esp /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); 10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: ff 75 08 pushl 0x8(%ebp) 10b3c2: 68 14 73 12 00 push $0x127314 10b3c7: e8 cc 1a 00 00 call 10ce98 <_Objects_Get> 10b3cc: 89 c3 mov %eax,%ebx switch ( location ) { 10b3ce: 83 c4 10 add $0x10,%esp 10b3d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b3d5: 75 64 jne 10b43b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b3d7: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b3da: f6 40 11 40 testb $0x40,0x11(%eax) 10b3de: 74 18 je 10b3f8 <_Rate_monotonic_Timeout+0x44> 10b3e0: 8b 53 08 mov 0x8(%ebx),%edx 10b3e3: 39 50 20 cmp %edx,0x20(%eax) 10b3e6: 75 10 jne 10b3f8 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b3e8: 52 push %edx 10b3e9: 52 push %edx 10b3ea: 68 f8 ff 03 10 push $0x1003fff8 10b3ef: 50 push %eax 10b3f0: e8 0f 1f 00 00 call 10d304 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b3f5: 59 pop %ecx 10b3f6: eb 10 jmp 10b408 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b3f8: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b3fc: 75 2b jne 10b429 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b3fe: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b405: 83 ec 0c sub $0xc,%esp 10b408: 53 push %ebx 10b409: e8 ec fa ff ff call 10aefa <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b40e: 8b 43 3c mov 0x3c(%ebx),%eax 10b411: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b414: 58 pop %eax 10b415: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b416: 83 c3 10 add $0x10,%ebx 10b419: 53 push %ebx 10b41a: 68 d0 74 12 00 push $0x1274d0 10b41f: e8 b8 31 00 00 call 10e5dc <_Watchdog_Insert> 10b424: 83 c4 10 add $0x10,%esp 10b427: eb 07 jmp 10b430 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b429: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10b430: a1 08 74 12 00 mov 0x127408,%eax 10b435: 48 dec %eax 10b436: a3 08 74 12 00 mov %eax,0x127408 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b43b: 8b 5d fc mov -0x4(%ebp),%ebx 10b43e: c9 leave 10b43f: c3 ret =============================================================================== 0010acb4 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10acb4: 55 push %ebp 10acb5: 89 e5 mov %esp,%ebp 10acb7: 56 push %esi 10acb8: 53 push %ebx 10acb9: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); 10acbc: 8b 35 44 42 12 00 mov 0x124244,%esi (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 10acc2: 31 db xor %ebx,%ebx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acc4: 85 c9 test %ecx,%ecx 10acc6: 74 57 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10acc8: b8 40 42 0f 00 mov $0xf4240,%eax 10accd: 31 d2 xor %edx,%edx 10accf: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acd1: 39 41 18 cmp %eax,0x18(%ecx) 10acd4: 73 49 jae 10ad1f <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10acd6: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10acda: 77 43 ja 10ad1f <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10acdc: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ace0: 77 3d ja 10ad1f <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ace2: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10ace6: 77 37 ja 10ad1f <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10ace8: 8b 41 04 mov 0x4(%ecx),%eax rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 10aceb: 85 c0 test %eax,%eax 10aced: 74 30 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10acef: 83 f8 0c cmp $0xc,%eax 10acf2: 77 2b ja 10ad1f <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10acf4: 8b 31 mov (%ecx),%esi (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || 10acf6: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10acfc: 76 21 jbe 10ad1f <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10acfe: 8b 51 08 mov 0x8(%ecx),%edx (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10ad01: 85 d2 test %edx,%edx 10ad03: 74 1a je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad05: 83 e6 03 and $0x3,%esi 10ad08: 75 09 jne 10ad13 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad0a: 8b 04 85 24 14 12 00 mov 0x121424(,%eax,4),%eax 10ad11: eb 07 jmp 10ad1a <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad13: 8b 04 85 f0 13 12 00 mov 0x1213f0(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad1a: 39 c2 cmp %eax,%edx 10ad1c: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad1f: 88 d8 mov %bl,%al 10ad21: 5b pop %ebx 10ad22: 5e pop %esi 10ad23: c9 leave 10ad24: c3 ret =============================================================================== 0010ba3c <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10ba3c: 55 push %ebp 10ba3d: 89 e5 mov %esp,%ebp 10ba3f: 57 push %edi 10ba40: 56 push %esi 10ba41: 53 push %ebx 10ba42: 83 ec 28 sub $0x28,%esp 10ba45: 8b 5d 08 mov 0x8(%ebp),%ebx 10ba48: 8b 7d 0c mov 0xc(%ebp),%edi 10ba4b: 8a 45 10 mov 0x10(%ebp),%al 10ba4e: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10ba51: 8b 73 10 mov 0x10(%ebx),%esi /* * 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 ); 10ba54: 53 push %ebx 10ba55: e8 3e 0d 00 00 call 10c798 <_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 ) 10ba5a: 83 c4 10 add $0x10,%esp 10ba5d: 39 7b 14 cmp %edi,0x14(%ebx) 10ba60: 74 0c je 10ba6e <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10ba62: 50 push %eax 10ba63: 50 push %eax 10ba64: 57 push %edi 10ba65: 53 push %ebx 10ba66: e8 f5 0b 00 00 call 10c660 <_Thread_Set_priority> 10ba6b: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10ba6e: 9c pushf 10ba6f: fa cli 10ba70: 59 pop %ecx /* * 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; 10ba71: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10ba74: 83 f8 04 cmp $0x4,%eax 10ba77: 74 2f je 10baa8 <_Thread_Change_priority+0x6c> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10ba79: 83 e6 04 and $0x4,%esi 10ba7c: 75 08 jne 10ba86 <_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); 10ba7e: 89 c2 mov %eax,%edx 10ba80: 83 e2 fb and $0xfffffffb,%edx 10ba83: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10ba86: 51 push %ecx 10ba87: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10ba88: a9 e0 be 03 00 test $0x3bee0,%eax 10ba8d: 0f 84 c0 00 00 00 je 10bb53 <_Thread_Change_priority+0x117> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10ba93: 89 5d 0c mov %ebx,0xc(%ebp) 10ba96: 8b 43 44 mov 0x44(%ebx),%eax 10ba99: 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 ); } 10ba9c: 8d 65 f4 lea -0xc(%ebp),%esp 10ba9f: 5b pop %ebx 10baa0: 5e pop %esi 10baa1: 5f pop %edi 10baa2: 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 ); 10baa3: e9 30 0b 00 00 jmp 10c5d8 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10baa8: 83 e6 04 and $0x4,%esi 10baab: 75 53 jne 10bb00 <_Thread_Change_priority+0xc4><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10baad: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bab4: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax 10baba: 66 8b 93 96 00 00 00 mov 0x96(%ebx),%dx 10bac1: 66 09 10 or %dx,(%eax) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bac4: 66 a1 88 43 12 00 mov 0x124388,%ax 10baca: 0b 83 94 00 00 00 or 0x94(%ebx),%eax 10bad0: 66 a3 88 43 12 00 mov %ax,0x124388 _Priority_bit_map_Add( &the_thread->Priority_map ); if ( prepend_it ) 10bad6: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10bada: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bae0: 74 0e je 10baf0 <_Thread_Change_priority+0xb4> Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10bae2: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10bae5: 8b 10 mov (%eax),%edx after_node->next = the_node; 10bae7: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10bae9: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10baeb: 89 5a 04 mov %ebx,0x4(%edx) 10baee: eb 10 jmp 10bb00 <_Thread_Change_priority+0xc4> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10baf0: 8d 50 04 lea 0x4(%eax),%edx 10baf3: 89 13 mov %edx,(%ebx) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10baf5: 8b 50 08 mov 0x8(%eax),%edx the_chain->last = the_node; 10baf8: 89 58 08 mov %ebx,0x8(%eax) old_last_node->next = the_node; 10bafb: 89 1a mov %ebx,(%edx) the_node->previous = old_last_node; 10bafd: 89 53 04 mov %edx,0x4(%ebx) _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 10bb00: 51 push %ecx 10bb01: 9d popf 10bb02: fa cli 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 ); 10bb03: 66 8b 1d 88 43 12 00 mov 0x124388,%bx 10bb0a: 31 c0 xor %eax,%eax 10bb0c: 89 c2 mov %eax,%edx 10bb0e: 66 0f bc d3 bsf %bx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bb12: 0f b7 d2 movzwl %dx,%edx 10bb15: 66 8b 9c 12 f8 43 12 mov 0x1243f8(%edx,%edx,1),%bx 10bb1c: 00 10bb1d: 66 0f bc c3 bsf %bx,%ax return (_Priority_Bits_index( major ) << 4) + 10bb21: c1 e2 04 shl $0x4,%edx 10bb24: 0f b7 c0 movzwl %ax,%eax */ RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void ) { _Thread_Heir = (Thread_Control *) _Thread_Ready_chain[ _Priority_bit_map_Get_highest() ].first; 10bb27: 8d 04 02 lea (%edx,%eax,1),%eax 10bb2a: 6b c0 0c imul $0xc,%eax,%eax 10bb2d: 03 05 b0 42 12 00 add 0x1242b0,%eax * ready thread. */ RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void ) { _Thread_Heir = (Thread_Control *) 10bb33: 8b 10 mov (%eax),%edx 10bb35: 89 15 38 48 12 00 mov %edx,0x124838 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bb3b: a1 34 48 12 00 mov 0x124834,%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. */ _Thread_Calculate_heir(); if ( !_Thread_Is_executing_also_the_heir() && 10bb40: 39 d0 cmp %edx,%eax 10bb42: 74 0d je 10bb51 <_Thread_Change_priority+0x115> 10bb44: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bb48: 74 07 je 10bb51 <_Thread_Change_priority+0x115> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bb4a: c6 05 40 48 12 00 01 movb $0x1,0x124840 _ISR_Enable( level ); 10bb51: 51 push %ecx 10bb52: 9d popf } 10bb53: 8d 65 f4 lea -0xc(%ebp),%esp 10bb56: 5b pop %ebx 10bb57: 5e pop %esi 10bb58: 5f pop %edi 10bb59: c9 leave 10bb5a: c3 ret =============================================================================== 0010bb5c <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bb5c: 55 push %ebp 10bb5d: 89 e5 mov %esp,%ebp 10bb5f: 53 push %ebx 10bb60: 8b 45 08 mov 0x8(%ebp),%eax 10bb63: 8b 55 0c mov 0xc(%ebp),%edx ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bb66: 9c pushf 10bb67: fa cli 10bb68: 59 pop %ecx current_state = the_thread->current_state; 10bb69: 8b 58 10 mov 0x10(%eax),%ebx if ( current_state & state ) { 10bb6c: 85 da test %ebx,%edx 10bb6e: 74 71 je 10bbe1 <_Thread_Clear_state+0x85> 10bb70: f7 d2 not %edx 10bb72: 21 da and %ebx,%edx current_state = the_thread->current_state = _States_Clear( state, current_state ); 10bb74: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10bb77: 85 d2 test %edx,%edx 10bb79: 75 66 jne 10bbe1 <_Thread_Clear_state+0x85> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bb7b: 8b 90 90 00 00 00 mov 0x90(%eax),%edx 10bb81: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx 10bb88: 66 09 1a or %bx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bb8b: 66 8b 15 88 43 12 00 mov 0x124388,%dx 10bb92: 0b 90 94 00 00 00 or 0x94(%eax),%edx 10bb98: 66 89 15 88 43 12 00 mov %dx,0x124388 _Priority_bit_map_Add( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bb9f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10bba5: 8d 5a 04 lea 0x4(%edx),%ebx 10bba8: 89 18 mov %ebx,(%eax) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10bbaa: 8b 5a 08 mov 0x8(%edx),%ebx the_chain->last = the_node; 10bbad: 89 42 08 mov %eax,0x8(%edx) old_last_node->next = the_node; 10bbb0: 89 03 mov %eax,(%ebx) the_node->previous = old_last_node; 10bbb2: 89 58 04 mov %ebx,0x4(%eax) _ISR_Flash( level ); 10bbb5: 51 push %ecx 10bbb6: 9d popf 10bbb7: fa cli * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10bbb8: 8b 50 14 mov 0x14(%eax),%edx 10bbbb: 8b 1d 38 48 12 00 mov 0x124838,%ebx 10bbc1: 3b 53 14 cmp 0x14(%ebx),%edx 10bbc4: 73 1b jae 10bbe1 <_Thread_Clear_state+0x85> _Thread_Heir = the_thread; 10bbc6: a3 38 48 12 00 mov %eax,0x124838 if ( _Thread_Executing->is_preemptible || 10bbcb: a1 34 48 12 00 mov 0x124834,%eax 10bbd0: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bbd4: 75 04 jne 10bbda <_Thread_Clear_state+0x7e> 10bbd6: 85 d2 test %edx,%edx 10bbd8: 75 07 jne 10bbe1 <_Thread_Clear_state+0x85><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10bbda: c6 05 40 48 12 00 01 movb $0x1,0x124840 } } } _ISR_Enable( level ); 10bbe1: 51 push %ecx 10bbe2: 9d popf } 10bbe3: 5b pop %ebx 10bbe4: c9 leave 10bbe5: c3 ret =============================================================================== 0010bd5c <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bd5c: 55 push %ebp 10bd5d: 89 e5 mov %esp,%ebp 10bd5f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bd62: 8d 45 f4 lea -0xc(%ebp),%eax 10bd65: 50 push %eax 10bd66: ff 75 08 pushl 0x8(%ebp) 10bd69: e8 82 01 00 00 call 10bef0 <_Thread_Get> switch ( location ) { 10bd6e: 83 c4 10 add $0x10,%esp 10bd71: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bd75: 75 1b jne 10bd92 <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bd77: 52 push %edx 10bd78: 52 push %edx 10bd79: 68 18 00 00 10 push $0x10000018 10bd7e: 50 push %eax 10bd7f: e8 d8 fd ff ff call 10bb5c <_Thread_Clear_state> 10bd84: a1 e4 42 12 00 mov 0x1242e4,%eax 10bd89: 48 dec %eax 10bd8a: a3 e4 42 12 00 mov %eax,0x1242e4 10bd8f: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bd92: c9 leave 10bd93: c3 ret =============================================================================== 0010bd94 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bd94: 55 push %ebp 10bd95: 89 e5 mov %esp,%ebp 10bd97: 57 push %edi 10bd98: 56 push %esi 10bd99: 53 push %ebx 10bd9a: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10bd9d: 8b 1d 34 48 12 00 mov 0x124834,%ebx _ISR_Disable( level ); 10bda3: 9c pushf 10bda4: fa cli 10bda5: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10bda6: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bda9: e9 f9 00 00 00 jmp 10bea7 <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10bdae: 8b 35 38 48 12 00 mov 0x124838,%esi _Thread_Dispatch_disable_level = 1; 10bdb4: c7 05 e4 42 12 00 01 movl $0x1,0x1242e4 10bdbb: 00 00 00 _Thread_Dispatch_necessary = false; 10bdbe: c6 05 40 48 12 00 00 movb $0x0,0x124840 _Thread_Executing = heir; 10bdc5: 89 35 34 48 12 00 mov %esi,0x124834 /* * 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 ) 10bdcb: 39 de cmp %ebx,%esi 10bdcd: 0f 84 e2 00 00 00 je 10beb5 <_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 ) 10bdd3: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10bdd7: 75 09 jne 10bde2 <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bdd9: 8b 15 b4 42 12 00 mov 0x1242b4,%edx 10bddf: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10bde2: 50 push %eax 10bde3: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bde4: 83 ec 0c sub $0xc,%esp 10bde7: 8d 45 e0 lea -0x20(%ebp),%eax 10bdea: 50 push %eax 10bdeb: e8 08 36 00 00 call 10f3f8 <_TOD_Get_uptime> _Timestamp_Subtract( 10bdf0: 83 c4 0c add $0xc,%esp 10bdf3: 57 push %edi 10bdf4: 8d 45 e0 lea -0x20(%ebp),%eax 10bdf7: 50 push %eax 10bdf8: 68 98 43 12 00 push $0x124398 10bdfd: e8 32 0c 00 00 call 10ca34 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10be02: 58 pop %eax 10be03: 5a pop %edx 10be04: 57 push %edi 10be05: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10be0b: 50 push %eax 10be0c: e8 f3 0b 00 00 call 10ca04 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10be11: 8b 45 e0 mov -0x20(%ebp),%eax 10be14: 8b 55 e4 mov -0x1c(%ebp),%edx 10be17: a3 98 43 12 00 mov %eax,0x124398 10be1c: 89 15 9c 43 12 00 mov %edx,0x12439c #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10be22: a1 6c 43 12 00 mov 0x12436c,%eax 10be27: 83 c4 10 add $0x10,%esp 10be2a: 85 c0 test %eax,%eax 10be2c: 74 10 je 10be3e <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10be2e: 8b 10 mov (%eax),%edx 10be30: 89 93 f0 00 00 00 mov %edx,0xf0(%ebx) *_Thread_libc_reent = heir->libc_reent; 10be36: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx 10be3c: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10be3e: 51 push %ecx 10be3f: 51 push %ecx 10be40: 56 push %esi 10be41: 53 push %ebx 10be42: e8 25 0e 00 00 call 10cc6c <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10be47: 58 pop %eax 10be48: 5a pop %edx 10be49: 81 c6 d4 00 00 00 add $0xd4,%esi 10be4f: 56 push %esi 10be50: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax 10be56: 50 push %eax 10be57: e8 d4 10 00 00 call 10cf30 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10be5c: 83 c4 10 add $0x10,%esp 10be5f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 10be66: 74 36 je 10be9e <_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 ); 10be68: a1 68 43 12 00 mov 0x124368,%eax 10be6d: 39 c3 cmp %eax,%ebx 10be6f: 74 2d je 10be9e <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10be71: 85 c0 test %eax,%eax 10be73: 74 11 je 10be86 <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10be75: 83 ec 0c sub $0xc,%esp 10be78: 05 ec 00 00 00 add $0xec,%eax 10be7d: 50 push %eax 10be7e: e8 e1 10 00 00 call 10cf64 <_CPU_Context_save_fp> 10be83: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10be86: 83 ec 0c sub $0xc,%esp 10be89: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax 10be8f: 50 push %eax 10be90: e8 d9 10 00 00 call 10cf6e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10be95: 89 1d 68 43 12 00 mov %ebx,0x124368 10be9b: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10be9e: 8b 1d 34 48 12 00 mov 0x124834,%ebx _ISR_Disable( level ); 10bea4: 9c pushf 10bea5: fa cli 10bea6: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bea7: 8a 15 40 48 12 00 mov 0x124840,%dl 10bead: 84 d2 test %dl,%dl 10beaf: 0f 85 f9 fe ff ff jne 10bdae <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10beb5: c7 05 e4 42 12 00 00 movl $0x0,0x1242e4 10bebc: 00 00 00 _ISR_Enable( level ); 10bebf: 50 push %eax 10bec0: 9d popf _API_extensions_Run_postswitch(); 10bec1: e8 0d ea ff ff call 10a8d3 <_API_extensions_Run_postswitch> } 10bec6: 8d 65 f4 lea -0xc(%ebp),%esp 10bec9: 5b pop %ebx 10beca: 5e pop %esi 10becb: 5f pop %edi 10becc: c9 leave 10becd: c3 ret =============================================================================== 00110f10 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110f10: 55 push %ebp 110f11: 89 e5 mov %esp,%ebp 110f13: 53 push %ebx 110f14: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110f17: 8b 1d 34 48 12 00 mov 0x124834,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110f1d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax _ISR_Set_level(level); 110f23: 85 c0 test %eax,%eax 110f25: 74 03 je 110f2a <_Thread_Handler+0x1a> 110f27: fa cli 110f28: eb 01 jmp 110f2b <_Thread_Handler+0x1b> 110f2a: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110f2b: a0 a0 3f 12 00 mov 0x123fa0,%al 110f30: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110f33: 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) && 110f3a: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 110f41: 74 24 je 110f67 <_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 ); 110f43: a1 68 43 12 00 mov 0x124368,%eax 110f48: 39 c3 cmp %eax,%ebx 110f4a: 74 1b je 110f67 <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110f4c: 85 c0 test %eax,%eax 110f4e: 74 11 je 110f61 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110f50: 83 ec 0c sub $0xc,%esp 110f53: 05 ec 00 00 00 add $0xec,%eax 110f58: 50 push %eax 110f59: e8 06 c0 ff ff call 10cf64 <_CPU_Context_save_fp> 110f5e: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110f61: 89 1d 68 43 12 00 mov %ebx,0x124368 /* * 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 ); 110f67: 83 ec 0c sub $0xc,%esp 110f6a: 53 push %ebx 110f6b: e8 ac bb ff ff call 10cb1c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110f70: e8 59 af ff ff call 10bece <_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) */ { 110f75: 83 c4 10 add $0x10,%esp 110f78: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 110f7c: 75 05 jne 110f83 <_Thread_Handler+0x73> INIT_NAME (); 110f7e: e8 5d be 00 00 call 11cde0 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 110f83: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 110f89: 85 c0 test %eax,%eax 110f8b: 75 0b jne 110f98 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 110f8d: 83 ec 0c sub $0xc,%esp 110f90: ff b3 a8 00 00 00 pushl 0xa8(%ebx) 110f96: eb 0c jmp 110fa4 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 110f98: 48 dec %eax 110f99: 75 15 jne 110fb0 <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 110f9b: 83 ec 0c sub $0xc,%esp 110f9e: ff b3 a4 00 00 00 pushl 0xa4(%ebx) 110fa4: ff 93 9c 00 00 00 call *0x9c(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 110faa: 89 43 28 mov %eax,0x28(%ebx) 110fad: 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 ); 110fb0: 83 ec 0c sub $0xc,%esp 110fb3: 53 push %ebx 110fb4: e8 94 bb ff ff call 10cb4d <_User_extensions_Thread_exitted> _Internal_error_Occurred( 110fb9: 83 c4 0c add $0xc,%esp 110fbc: 6a 05 push $0x5 110fbe: 6a 01 push $0x1 110fc0: 6a 00 push $0x0 110fc2: e8 69 a2 ff ff call 10b230 <_Internal_error_Occurred> =============================================================================== 0010bf60 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10bf60: 55 push %ebp 10bf61: 89 e5 mov %esp,%ebp 10bf63: 57 push %edi 10bf64: 56 push %esi 10bf65: 53 push %ebx 10bf66: 83 ec 1c sub $0x1c,%esp 10bf69: 8b 5d 0c mov 0xc(%ebp),%ebx 10bf6c: 8b 4d 10 mov 0x10(%ebp),%ecx 10bf6f: 8b 75 14 mov 0x14(%ebp),%esi 10bf72: 8a 55 18 mov 0x18(%ebp),%dl 10bf75: 8a 45 20 mov 0x20(%ebp),%al 10bf78: 88 45 e7 mov %al,-0x19(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10bf7b: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 10bf82: 00 00 00 10bf85: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx) 10bf8c: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10bf8f: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10bf96: 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 ) { 10bf99: 85 c9 test %ecx,%ecx 10bf9b: 75 31 jne 10bfce <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10bf9d: 51 push %ecx 10bf9e: 51 push %ecx 10bf9f: 56 push %esi 10bfa0: 53 push %ebx 10bfa1: 88 55 e0 mov %dl,-0x20(%ebp) 10bfa4: e8 63 08 00 00 call 10c80c <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10bfa9: 83 c4 10 add $0x10,%esp 10bfac: 39 f0 cmp %esi,%eax 10bfae: 8a 55 e0 mov -0x20(%ebp),%dl 10bfb1: 0f 82 c1 01 00 00 jb 10c178 <_Thread_Initialize+0x218> 10bfb7: 85 c0 test %eax,%eax 10bfb9: 0f 84 b9 01 00 00 je 10c178 <_Thread_Initialize+0x218><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10bfbf: 8b 8b d0 00 00 00 mov 0xd0(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10bfc5: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) 10bfcc: eb 09 jmp 10bfd7 <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10bfce: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) 10bfd5: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10bfd7: 89 8b c8 00 00 00 mov %ecx,0xc8(%ebx) the_stack->size = size; 10bfdd: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10bfe3: 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 ) { 10bfe5: 84 d2 test %dl,%dl 10bfe7: 74 17 je 10c000 <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10bfe9: 83 ec 0c sub $0xc,%esp 10bfec: 6a 6c push $0x6c 10bfee: e8 df 0e 00 00 call 10ced2 <_Workspace_Allocate> 10bff3: 89 c7 mov %eax,%edi if ( !fp_area ) 10bff5: 83 c4 10 add $0x10,%esp 10bff8: 85 c0 test %eax,%eax 10bffa: 0f 84 08 01 00 00 je 10c108 <_Thread_Initialize+0x1a8> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c000: 89 bb ec 00 00 00 mov %edi,0xec(%ebx) the_thread->Start.fp_context = fp_area; 10c006: 89 bb cc 00 00 00 mov %edi,0xcc(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c00c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c013: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c01a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c021: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c028: a1 78 43 12 00 mov 0x124378,%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; 10c02d: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c02f: 85 c0 test %eax,%eax 10c031: 74 1d je 10c050 <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c033: 83 ec 0c sub $0xc,%esp 10c036: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c03d: 50 push %eax 10c03e: e8 8f 0e 00 00 call 10ced2 <_Workspace_Allocate> 10c043: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c045: 83 c4 10 add $0x10,%esp 10c048: 85 c0 test %eax,%eax 10c04a: 0f 84 ba 00 00 00 je 10c10a <_Thread_Initialize+0x1aa> goto failed; } the_thread->extensions = (void **) extensions_area; 10c050: 89 b3 fc 00 00 00 mov %esi,0xfc(%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 ) { 10c056: 85 f6 test %esi,%esi 10c058: 74 16 je 10c070 <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c05a: 8b 15 78 43 12 00 mov 0x124378,%edx 10c060: 31 c0 xor %eax,%eax 10c062: eb 08 jmp 10c06c <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c064: 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++ ) 10c06b: 40 inc %eax 10c06c: 39 d0 cmp %edx,%eax 10c06e: 76 f4 jbe 10c064 <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c070: 8a 45 e7 mov -0x19(%ebp),%al 10c073: 88 83 ac 00 00 00 mov %al,0xac(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c079: 8b 45 24 mov 0x24(%ebp),%eax 10c07c: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) the_thread->Start.budget_callout = budget_callout; 10c082: 8b 45 28 mov 0x28(%ebp),%eax 10c085: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) switch ( budget_algorithm ) { 10c08b: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c08f: 75 08 jne 10c099 <_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; 10c091: a1 b4 42 12 00 mov 0x1242b4,%eax 10c096: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c099: 8b 45 2c mov 0x2c(%ebp),%eax 10c09c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) the_thread->current_state = STATES_DORMANT; 10c0a2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c0a9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c0b0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c0b7: 8b 45 1c mov 0x1c(%ebp),%eax 10c0ba: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c0bd: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) _Thread_Set_priority( the_thread, priority ); 10c0c3: 52 push %edx 10c0c4: 52 push %edx 10c0c5: 50 push %eax 10c0c6: 53 push %ebx 10c0c7: e8 94 05 00 00 call 10c660 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c0cc: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c0d3: 00 00 00 10c0d6: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c0dd: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10c0e0: 8b 45 08 mov 0x8(%ebp),%eax 10c0e3: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c0e6: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c0ea: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c0ed: 8b 45 30 mov 0x30(%ebp),%eax 10c0f0: 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 ); 10c0f3: 89 1c 24 mov %ebx,(%esp) 10c0f6: e8 c1 0a 00 00 call 10cbbc <_User_extensions_Thread_create> 10c0fb: 88 c2 mov %al,%dl if ( extension_status ) 10c0fd: 83 c4 10 add $0x10,%esp return true; 10c100: 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 ) 10c102: 84 d2 test %dl,%dl 10c104: 74 04 je 10c10a <_Thread_Initialize+0x1aa> 10c106: eb 72 jmp 10c17a <_Thread_Initialize+0x21a> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c108: 31 f6 xor %esi,%esi extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: if ( the_thread->libc_reent ) 10c10a: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax 10c110: 85 c0 test %eax,%eax 10c112: 74 0c je 10c120 <_Thread_Initialize+0x1c0> _Workspace_Free( the_thread->libc_reent ); 10c114: 83 ec 0c sub $0xc,%esp 10c117: 50 push %eax 10c118: e8 ce 0d 00 00 call 10ceeb <_Workspace_Free> 10c11d: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c120: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax 10c126: 85 c0 test %eax,%eax 10c128: 74 0c je 10c136 <_Thread_Initialize+0x1d6> _Workspace_Free( the_thread->API_Extensions[i] ); 10c12a: 83 ec 0c sub $0xc,%esp 10c12d: 50 push %eax 10c12e: e8 b8 0d 00 00 call 10ceeb <_Workspace_Free> 10c133: 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] ) 10c136: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax 10c13c: 85 c0 test %eax,%eax 10c13e: 74 0c je 10c14c <_Thread_Initialize+0x1ec> _Workspace_Free( the_thread->API_Extensions[i] ); 10c140: 83 ec 0c sub $0xc,%esp 10c143: 50 push %eax 10c144: e8 a2 0d 00 00 call 10ceeb <_Workspace_Free> 10c149: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10c14c: 85 f6 test %esi,%esi 10c14e: 74 0c je 10c15c <_Thread_Initialize+0x1fc> (void) _Workspace_Free( extensions_area ); 10c150: 83 ec 0c sub $0xc,%esp 10c153: 56 push %esi 10c154: e8 92 0d 00 00 call 10ceeb <_Workspace_Free> 10c159: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c15c: 85 ff test %edi,%edi 10c15e: 74 0c je 10c16c <_Thread_Initialize+0x20c> (void) _Workspace_Free( fp_area ); 10c160: 83 ec 0c sub $0xc,%esp 10c163: 57 push %edi 10c164: e8 82 0d 00 00 call 10ceeb <_Workspace_Free> 10c169: 83 c4 10 add $0x10,%esp #endif _Thread_Stack_Free( the_thread ); 10c16c: 83 ec 0c sub $0xc,%esp 10c16f: 53 push %ebx 10c170: e8 e7 06 00 00 call 10c85c <_Thread_Stack_Free> return false; 10c175: 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 */ 10c178: 31 c0 xor %eax,%eax _Thread_Stack_Free( the_thread ); return false; } 10c17a: 8d 65 f4 lea -0xc(%ebp),%esp 10c17d: 5b pop %ebx 10c17e: 5e pop %esi 10c17f: 5f pop %edi 10c180: c9 leave 10c181: c3 ret =============================================================================== 0010f400 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f400: 55 push %ebp 10f401: 89 e5 mov %esp,%ebp 10f403: 53 push %ebx 10f404: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f407: 9c pushf 10f408: fa cli 10f409: 59 pop %ecx current_state = the_thread->current_state; 10f40a: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f40d: f6 c2 02 test $0x2,%dl 10f410: 74 70 je 10f482 <_Thread_Resume+0x82> <== NEVER TAKEN 10f412: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f415: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f418: 85 d2 test %edx,%edx 10f41a: 75 66 jne 10f482 <_Thread_Resume+0x82> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10f41c: 8b 90 90 00 00 00 mov 0x90(%eax),%edx 10f422: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx 10f429: 66 09 1a or %bx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10f42c: 66 8b 15 50 74 12 00 mov 0x127450,%dx 10f433: 0b 90 94 00 00 00 or 0x94(%eax),%edx 10f439: 66 89 15 50 74 12 00 mov %dx,0x127450 _Priority_bit_map_Add( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10f440: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10f446: 8d 5a 04 lea 0x4(%edx),%ebx 10f449: 89 18 mov %ebx,(%eax) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10f44b: 8b 5a 08 mov 0x8(%edx),%ebx the_chain->last = the_node; 10f44e: 89 42 08 mov %eax,0x8(%edx) old_last_node->next = the_node; 10f451: 89 03 mov %eax,(%ebx) the_node->previous = old_last_node; 10f453: 89 58 04 mov %ebx,0x4(%eax) _ISR_Flash( level ); 10f456: 51 push %ecx 10f457: 9d popf 10f458: fa cli if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10f459: 8b 50 14 mov 0x14(%eax),%edx 10f45c: 8b 1d 00 79 12 00 mov 0x127900,%ebx 10f462: 3b 53 14 cmp 0x14(%ebx),%edx 10f465: 73 1b jae 10f482 <_Thread_Resume+0x82> _Thread_Heir = the_thread; 10f467: a3 00 79 12 00 mov %eax,0x127900 if ( _Thread_Executing->is_preemptible || 10f46c: a1 fc 78 12 00 mov 0x1278fc,%eax 10f471: 80 78 74 00 cmpb $0x0,0x74(%eax) 10f475: 75 04 jne 10f47b <_Thread_Resume+0x7b> 10f477: 85 d2 test %edx,%edx 10f479: 75 07 jne 10f482 <_Thread_Resume+0x82> <== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10f47b: c6 05 08 79 12 00 01 movb $0x1,0x127908 } } } _ISR_Enable( level ); 10f482: 51 push %ecx 10f483: 9d popf } 10f484: 5b pop %ebx 10f485: c9 leave 10f486: c3 ret =============================================================================== 0010c944 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10c944: 55 push %ebp 10c945: 89 e5 mov %esp,%ebp 10c947: 53 push %ebx 10c948: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10c94b: 8b 1d 34 48 12 00 mov 0x124834,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10c951: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10c955: 74 4c je 10c9a3 <_Thread_Tickle_timeslice+0x5f> return; if ( !_States_Is_ready( executing->current_state ) ) 10c957: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10c95b: 75 46 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10c95d: 8b 43 7c mov 0x7c(%ebx),%eax 10c960: 83 f8 01 cmp $0x1,%eax 10c963: 72 3e jb 10c9a3 <_Thread_Tickle_timeslice+0x5f> 10c965: 83 f8 02 cmp $0x2,%eax 10c968: 76 07 jbe 10c971 <_Thread_Tickle_timeslice+0x2d> 10c96a: 83 f8 03 cmp $0x3,%eax 10c96d: 75 34 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN 10c96f: eb 1a jmp 10c98b <_Thread_Tickle_timeslice+0x47> 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 ) { 10c971: 8b 43 78 mov 0x78(%ebx),%eax 10c974: 48 dec %eax 10c975: 89 43 78 mov %eax,0x78(%ebx) 10c978: 85 c0 test %eax,%eax 10c97a: 7f 27 jg 10c9a3 <_Thread_Tickle_timeslice+0x5f> * at the priority of the currently executing thread, then the * 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. */ _Thread_Yield_processor(); 10c97c: e8 27 00 00 00 call 10c9a8 <_Thread_Yield_processor> executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c981: a1 b4 42 12 00 mov 0x1242b4,%eax 10c986: 89 43 78 mov %eax,0x78(%ebx) 10c989: eb 18 jmp 10c9a3 <_Thread_Tickle_timeslice+0x5f> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10c98b: 8b 43 78 mov 0x78(%ebx),%eax 10c98e: 48 dec %eax 10c98f: 89 43 78 mov %eax,0x78(%ebx) 10c992: 85 c0 test %eax,%eax 10c994: 75 0d jne 10c9a3 <_Thread_Tickle_timeslice+0x5f> (*executing->budget_callout)( executing ); 10c996: 83 ec 0c sub $0xc,%esp 10c999: 53 push %ebx 10c99a: ff 93 80 00 00 00 call *0x80(%ebx) 10c9a0: 83 c4 10 add $0x10,%esp break; #endif } } 10c9a3: 8b 5d fc mov -0x4(%ebp),%ebx 10c9a6: c9 leave 10c9a7: c3 ret =============================================================================== 0010c3e0 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10c3e0: 55 push %ebp 10c3e1: 89 e5 mov %esp,%ebp 10c3e3: 57 push %edi 10c3e4: 56 push %esi 10c3e5: 53 push %ebx 10c3e6: 83 ec 14 sub $0x14,%esp 10c3e9: 8b 4d 08 mov 0x8(%ebp),%ecx 10c3ec: 8b 45 0c mov 0xc(%ebp),%eax 10c3ef: 8d 50 3c lea 0x3c(%eax),%edx 10c3f2: 89 50 38 mov %edx,0x38(%eax) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 10c3f5: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) Chain_Node *previous_node; Chain_Node *search_node; Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); 10c3fc: 8d 50 38 lea 0x38(%eax),%edx 10c3ff: 89 50 40 mov %edx,0x40(%eax) priority = the_thread->current_priority; 10c402: 8b 58 14 mov 0x14(%eax),%ebx RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 10c405: 89 df mov %ebx,%edi 10c407: c1 ef 06 shr $0x6,%edi header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c40a: 6b ff 0c imul $0xc,%edi,%edi 10c40d: 8d 3c 39 lea (%ecx,%edi,1),%edi 10c410: 89 7d ec mov %edi,-0x14(%ebp) block_state = the_thread_queue->state; 10c413: 8b 51 38 mov 0x38(%ecx),%edx 10c416: 89 55 e4 mov %edx,-0x1c(%ebp) restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10c419: 89 7d e8 mov %edi,-0x18(%ebp) priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 10c41c: f6 c3 20 test $0x20,%bl 10c41f: 75 73 jne 10c494 <_Thread_queue_Enqueue_priority+0xb4> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10c421: 8d 77 04 lea 0x4(%edi),%esi 10c424: 89 75 e8 mov %esi,-0x18(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c427: 9c pushf 10c428: fa cli 10c429: 8f 45 f0 popl -0x10(%ebp) 10c42c: 8b 75 f0 mov -0x10(%ebp),%esi search_thread = (Thread_Control *) header->first; 10c42f: 8b 17 mov (%edi),%edx if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 10c431: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) 10c438: 89 75 e0 mov %esi,-0x20(%ebp) _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c43b: eb 1f jmp 10c45c <_Thread_queue_Enqueue_priority+0x7c> search_priority = search_thread->current_priority; 10c43d: 8b 72 14 mov 0x14(%edx),%esi 10c440: 89 75 ec mov %esi,-0x14(%ebp) if ( priority <= search_priority ) 10c443: 39 f3 cmp %esi,%ebx 10c445: 76 1a jbe 10c461 <_Thread_queue_Enqueue_priority+0x81> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c447: ff 75 f0 pushl -0x10(%ebp) 10c44a: 9d popf 10c44b: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c44c: 8b 75 e4 mov -0x1c(%ebp),%esi 10c44f: 85 72 10 test %esi,0x10(%edx) 10c452: 75 06 jne 10c45a <_Thread_queue_Enqueue_priority+0x7a><== ALWAYS TAKEN _ISR_Enable( level ); 10c454: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c457: 9d popf <== NOT EXECUTED goto restart_forward_search; 10c458: eb cd jmp 10c427 <_Thread_queue_Enqueue_priority+0x47><== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10c45a: 8b 12 mov (%edx),%edx restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c45c: 3b 55 e8 cmp -0x18(%ebp),%edx 10c45f: 75 dc jne 10c43d <_Thread_queue_Enqueue_priority+0x5d> 10c461: 8b 75 e0 mov -0x20(%ebp),%esi } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c464: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c468: 0f 85 ae 00 00 00 jne 10c51c <_Thread_queue_Enqueue_priority+0x13c> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c46e: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c475: 3b 5d ec cmp -0x14(%ebp),%ebx 10c478: 0f 84 87 00 00 00 je 10c505 <_Thread_queue_Enqueue_priority+0x125> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c47e: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c481: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c483: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c486: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c488: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c48b: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c48e: ff 75 f0 pushl -0x10(%ebp) 10c491: 9d popf 10c492: eb 6a jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c494: 0f b6 3d f4 01 12 00 movzbl 0x1201f4,%edi 10c49b: 47 inc %edi 10c49c: 89 7d e0 mov %edi,-0x20(%ebp) _ISR_Disable( level ); 10c49f: 9c pushf 10c4a0: fa cli 10c4a1: 8f 45 f0 popl -0x10(%ebp) 10c4a4: 8b 75 f0 mov -0x10(%ebp),%esi search_thread = (Thread_Control *) header->last; 10c4a7: 8b 7d e8 mov -0x18(%ebp),%edi 10c4aa: 8b 57 08 mov 0x8(%edi),%edx 10c4ad: 8b 7d e0 mov -0x20(%ebp),%edi 10c4b0: 89 75 e0 mov %esi,-0x20(%ebp) while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c4b3: eb 1d jmp 10c4d2 <_Thread_queue_Enqueue_priority+0xf2> search_priority = search_thread->current_priority; 10c4b5: 8b 7a 14 mov 0x14(%edx),%edi if ( priority >= search_priority ) 10c4b8: 39 fb cmp %edi,%ebx 10c4ba: 73 1b jae 10c4d7 <_Thread_queue_Enqueue_priority+0xf7> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c4bc: ff 75 f0 pushl -0x10(%ebp) 10c4bf: 9d popf 10c4c0: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c4c1: 8b 75 e4 mov -0x1c(%ebp),%esi 10c4c4: 85 72 10 test %esi,0x10(%edx) 10c4c7: 75 06 jne 10c4cf <_Thread_queue_Enqueue_priority+0xef> _ISR_Enable( level ); 10c4c9: ff 75 f0 pushl -0x10(%ebp) 10c4cc: 9d popf goto restart_reverse_search; 10c4cd: eb c5 jmp 10c494 <_Thread_queue_Enqueue_priority+0xb4> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; 10c4cf: 8b 52 04 mov 0x4(%edx),%edx restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c4d2: 3b 55 ec cmp -0x14(%ebp),%edx 10c4d5: 75 de jne 10c4b5 <_Thread_queue_Enqueue_priority+0xd5> 10c4d7: 8b 75 e0 mov -0x20(%ebp),%esi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c4da: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c4de: 75 3c jne 10c51c <_Thread_queue_Enqueue_priority+0x13c> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c4e0: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c4e7: 39 fb cmp %edi,%ebx 10c4e9: 74 1a je 10c505 <_Thread_queue_Enqueue_priority+0x125> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c4eb: 8b 1a mov (%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c4ed: 89 18 mov %ebx,(%eax) the_node->previous = search_node; 10c4ef: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c4f2: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c4f4: 89 43 04 mov %eax,0x4(%ebx) the_thread->Wait.queue = the_thread_queue; 10c4f7: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c4fa: ff 75 f0 pushl -0x10(%ebp) 10c4fd: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c4fe: b8 01 00 00 00 mov $0x1,%eax 10c503: eb 1f jmp 10c524 <_Thread_queue_Enqueue_priority+0x144> 10c505: 83 c2 3c add $0x3c,%edx equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c508: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c50b: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c50d: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c510: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c512: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c515: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c518: 56 push %esi 10c519: 9d popf 10c51a: eb e2 jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10c51c: 8b 45 10 mov 0x10(%ebp),%eax 10c51f: 89 30 mov %esi,(%eax) return the_thread_queue->sync_state; 10c521: 8b 41 30 mov 0x30(%ecx),%eax } 10c524: 83 c4 14 add $0x14,%esp 10c527: 5b pop %ebx 10c528: 5e pop %esi 10c529: 5f pop %edi 10c52a: c9 leave 10c52b: c3 ret =============================================================================== 0010c5d8 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c5d8: 55 push %ebp 10c5d9: 89 e5 mov %esp,%ebp 10c5db: 57 push %edi 10c5dc: 56 push %esi 10c5dd: 53 push %ebx 10c5de: 83 ec 1c sub $0x1c,%esp 10c5e1: 8b 75 08 mov 0x8(%ebp),%esi 10c5e4: 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 ) 10c5e7: 85 f6 test %esi,%esi 10c5e9: 74 36 je 10c621 <_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 ) { 10c5eb: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c5ef: 75 30 jne 10c621 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c5f1: 9c pushf 10c5f2: fa cli 10c5f3: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c5f4: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c5fb: 74 22 je 10c61f <_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; 10c5fd: 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 ); 10c604: 50 push %eax 10c605: 6a 01 push $0x1 10c607: 57 push %edi 10c608: 56 push %esi 10c609: e8 82 32 00 00 call 10f890 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c60e: 83 c4 0c add $0xc,%esp 10c611: 8d 45 e4 lea -0x1c(%ebp),%eax 10c614: 50 push %eax 10c615: 57 push %edi 10c616: 56 push %esi 10c617: e8 c4 fd ff ff call 10c3e0 <_Thread_queue_Enqueue_priority> 10c61c: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c61f: 53 push %ebx 10c620: 9d popf } } 10c621: 8d 65 f4 lea -0xc(%ebp),%esp 10c624: 5b pop %ebx 10c625: 5e pop %esi 10c626: 5f pop %edi 10c627: c9 leave 10c628: c3 ret =============================================================================== 0010c62c <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c62c: 55 push %ebp 10c62d: 89 e5 mov %esp,%ebp 10c62f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c632: 8d 45 f4 lea -0xc(%ebp),%eax 10c635: 50 push %eax 10c636: ff 75 08 pushl 0x8(%ebp) 10c639: e8 b2 f8 ff ff call 10bef0 <_Thread_Get> switch ( location ) { 10c63e: 83 c4 10 add $0x10,%esp 10c641: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c645: 75 17 jne 10c65e <_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 ); 10c647: 83 ec 0c sub $0xc,%esp 10c64a: 50 push %eax 10c64b: e8 f4 32 00 00 call 10f944 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c650: a1 e4 42 12 00 mov 0x1242e4,%eax 10c655: 48 dec %eax 10c656: a3 e4 42 12 00 mov %eax,0x1242e4 10c65b: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c65e: c9 leave 10c65f: c3 ret =============================================================================== 0011696c <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 11696c: 55 push %ebp 11696d: 89 e5 mov %esp,%ebp 11696f: 57 push %edi 116970: 56 push %esi 116971: 53 push %ebx 116972: 83 ec 4c sub $0x4c,%esp 116975: 8b 5d 08 mov 0x8(%ebp),%ebx 116978: 8d 45 dc lea -0x24(%ebp),%eax 11697b: 8d 55 e0 lea -0x20(%ebp),%edx 11697e: 89 55 b4 mov %edx,-0x4c(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 116981: 89 55 dc mov %edx,-0x24(%ebp) the_chain->permanent_null = NULL; 116984: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) Timer_server_Control *ts = (Timer_server_Control *) arg; Chain_Control insert_chain; Chain_Control fire_chain; _Chain_Initialize_empty( &insert_chain ); 11698b: 89 45 e4 mov %eax,-0x1c(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 11698e: 8d 7d d0 lea -0x30(%ebp),%edi 116991: 8d 55 d4 lea -0x2c(%ebp),%edx 116994: 89 55 b0 mov %edx,-0x50(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 116997: 89 55 d0 mov %edx,-0x30(%ebp) the_chain->permanent_null = NULL; 11699a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) the_chain->last = _Chain_Head(the_chain); 1169a1: 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 ); 1169a4: 8d 43 30 lea 0x30(%ebx),%eax 1169a7: 89 45 c0 mov %eax,-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 ); 1169aa: 8d 73 68 lea 0x68(%ebx),%esi static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 1169ad: 8d 53 08 lea 0x8(%ebx),%edx 1169b0: 89 55 bc mov %edx,-0x44(%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; 1169b3: 8d 4d dc lea -0x24(%ebp),%ecx 1169b6: 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; 1169b9: a1 f0 d7 13 00 mov 0x13d7f0,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169be: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 1169c1: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169c4: 51 push %ecx 1169c5: 8d 4d d0 lea -0x30(%ebp),%ecx 1169c8: 51 push %ecx 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 a0 39 00 00 call 11a374 <_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 44 d7 13 00 mov 0x13d744,%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 13 jbe 1169fa <_Timer_server_Body+0x8e> /* * 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: 8d 55 d0 lea -0x30(%ebp),%edx 1169eb: 52 push %edx if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 1169ec: 8b 4d c4 mov -0x3c(%ebp),%ecx 1169ef: 29 c1 sub %eax,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169f1: 51 push %ecx 1169f2: 56 push %esi 1169f3: e8 7c 39 00 00 call 11a374 <_Watchdog_Adjust_to_chain> 1169f8: eb 0f jmp 116a09 <_Timer_server_Body+0x9d> } else if ( snapshot < last_snapshot ) { 1169fa: 73 10 jae 116a0c <_Timer_server_Body+0xa0> /* * 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 ); 1169fc: 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; 1169fd: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 116a00: 50 push %eax 116a01: 6a 01 push $0x1 116a03: 56 push %esi 116a04: e8 ff 38 00 00 call 11a308 <_Watchdog_Adjust> 116a09: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116a0c: 8b 45 c4 mov -0x3c(%ebp),%eax 116a0f: 89 43 74 mov %eax,0x74(%ebx) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 116a12: 8b 43 78 mov 0x78(%ebx),%eax 116a15: 83 ec 0c sub $0xc,%esp 116a18: 50 push %eax 116a19: e8 ea 08 00 00 call 117308 <_Chain_Get> if ( timer == NULL ) { 116a1e: 83 c4 10 add $0x10,%esp 116a21: 85 c0 test %eax,%eax 116a23: 74 29 je 116a4e <_Timer_server_Body+0xe2> static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116a25: 8b 50 38 mov 0x38(%eax),%edx 116a28: 83 fa 01 cmp $0x1,%edx 116a2b: 75 0b jne 116a38 <_Timer_server_Body+0xcc> _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116a2d: 52 push %edx 116a2e: 52 push %edx 116a2f: 83 c0 10 add $0x10,%eax 116a32: 50 push %eax 116a33: ff 75 c0 pushl -0x40(%ebp) 116a36: eb 0c jmp 116a44 <_Timer_server_Body+0xd8> } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116a38: 83 fa 03 cmp $0x3,%edx 116a3b: 75 d5 jne 116a12 <_Timer_server_Body+0xa6><== NEVER TAKEN _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116a3d: 51 push %ecx 116a3e: 51 push %ecx 116a3f: 83 c0 10 add $0x10,%eax 116a42: 50 push %eax 116a43: 56 push %esi 116a44: e8 b3 39 00 00 call 11a3fc <_Watchdog_Insert> 116a49: 83 c4 10 add $0x10,%esp 116a4c: eb c4 jmp 116a12 <_Timer_server_Body+0xa6> * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 116a4e: 9c pushf 116a4f: fa cli 116a50: 5a pop %edx tmp = ts->insert_chain; 116a51: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116a54: b0 01 mov $0x1,%al 116a56: 8b 4d b4 mov -0x4c(%ebp),%ecx 116a59: 39 4d dc cmp %ecx,-0x24(%ebp) 116a5c: 75 09 jne 116a67 <_Timer_server_Body+0xfb> ts->insert_chain = NULL; 116a5e: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116a65: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116a67: 52 push %edx 116a68: 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 ) { 116a69: 84 c0 test %al,%al 116a6b: 0f 85 48 ff ff ff jne 1169b9 <_Timer_server_Body+0x4d> _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: 8b 45 b0 mov -0x50(%ebp),%eax 116a74: 39 45 d0 cmp %eax,-0x30(%ebp) 116a77: 74 37 je 116ab0 <_Timer_server_Body+0x144> /* * 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: 5a pop %edx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 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+0x13d> { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 116a84: 8b 08 mov (%eax),%ecx the_chain->first = new_first; 116a86: 89 4d d0 mov %ecx,-0x30(%ebp) new_first->previous = _Chain_Head(the_chain); 116a89: 89 79 04 mov %edi,0x4(%ecx) 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+0x13d><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116a97: 52 push %edx 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+0x10d> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 116aa9: 52 push %edx 116aaa: 9d popf 116aab: e9 03 ff ff ff jmp 1169b3 <_Timer_server_Body+0x47> * 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 17 fe ff ff call 1168d0 <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ab9: 50 push %eax 116aba: 50 push %eax 116abb: 6a 08 push $0x8 116abd: ff 33 pushl (%ebx) 116abf: e8 18 31 00 00 call 119bdc <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116ac4: 89 d8 mov %ebx,%eax 116ac6: e8 15 fe ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116acb: 89 d8 mov %ebx,%eax 116acd: e8 54 fe ff ff call 116926 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116ad2: e8 ff 27 00 00 call 1192d6 <_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: 59 pop %ecx 116adc: ff 75 bc pushl -0x44(%ebp) 116adf: e8 30 3a 00 00 call 11a514 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116ae4: 8d 43 40 lea 0x40(%ebx),%eax 116ae7: 89 04 24 mov %eax,(%esp) 116aea: e8 25 3a 00 00 call 11a514 <_Watchdog_Remove> 116aef: 83 c4 10 add $0x10,%esp 116af2: e9 bc fe ff ff jmp 1169b3 <_Timer_server_Body+0x47> =============================================================================== 00116af7 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116af7: 55 push %ebp 116af8: 89 e5 mov %esp,%ebp 116afa: 57 push %edi 116afb: 56 push %esi 116afc: 53 push %ebx 116afd: 83 ec 2c sub $0x2c,%esp 116b00: 8b 5d 08 mov 0x8(%ebp),%ebx 116b03: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116b06: 8b 43 78 mov 0x78(%ebx),%eax 116b09: 85 c0 test %eax,%eax 116b0b: 0f 85 de 00 00 00 jne 116bef <_Timer_server_Schedule_operation_method+0xf8> * 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(); 116b11: e8 ba fd ff ff call 1168d0 <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116b16: 8b 46 38 mov 0x38(%esi),%eax 116b19: 83 f8 01 cmp $0x1,%eax 116b1c: 75 5a jne 116b78 <_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 ); 116b1e: 9c pushf 116b1f: fa cli 116b20: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116b23: 8b 15 f0 d7 13 00 mov 0x13d7f0,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116b29: 8b 4b 3c mov 0x3c(%ebx),%ecx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 116b2c: 8b 43 30 mov 0x30(%ebx),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 116b2f: 8d 7b 34 lea 0x34(%ebx),%edi if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 116b32: 39 f8 cmp %edi,%eax 116b34: 74 19 je 116b4f <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116b36: 89 d7 mov %edx,%edi 116b38: 29 cf sub %ecx,%edi 116b3a: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116b3d: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116b40: 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) { 116b42: 3b 7d e4 cmp -0x1c(%ebp),%edi 116b45: 76 05 jbe 116b4c <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116b47: 89 f9 mov %edi,%ecx 116b49: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116b4c: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116b4f: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116b52: ff 75 e0 pushl -0x20(%ebp) 116b55: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b56: 50 push %eax 116b57: 50 push %eax 116b58: 83 c6 10 add $0x10,%esi 116b5b: 56 push %esi 116b5c: 8d 43 30 lea 0x30(%ebx),%eax 116b5f: 50 push %eax 116b60: e8 97 38 00 00 call 11a3fc <_Watchdog_Insert> if ( !ts->active ) { 116b65: 8a 43 7c mov 0x7c(%ebx),%al 116b68: 83 c4 10 add $0x10,%esp 116b6b: 84 c0 test %al,%al 116b6d: 75 74 jne 116be3 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116b6f: 89 d8 mov %ebx,%eax 116b71: e8 6a fd ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog> 116b76: eb 6b jmp 116be3 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b78: 83 f8 03 cmp $0x3,%eax 116b7b: 75 66 jne 116be3 <_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 ); 116b7d: 9c pushf 116b7e: fa cli 116b7f: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116b82: 8b 15 44 d7 13 00 mov 0x13d744,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116b88: 8b 43 74 mov 0x74(%ebx),%eax */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 116b8b: 8b 4b 68 mov 0x68(%ebx),%ecx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 116b8e: 8d 7b 6c lea 0x6c(%ebx),%edi if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 116b91: 39 f9 cmp %edi,%ecx 116b93: 74 27 je 116bbc <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116b95: 8b 79 10 mov 0x10(%ecx),%edi 116b98: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116b9b: 39 c2 cmp %eax,%edx 116b9d: 76 15 jbe 116bb4 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116b9f: 89 d7 mov %edx,%edi 116ba1: 29 c7 sub %eax,%edi 116ba3: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116ba6: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116ba8: 39 7d d4 cmp %edi,-0x2c(%ebp) 116bab: 76 0c jbe 116bb9 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116bad: 8b 45 d4 mov -0x2c(%ebp),%eax 116bb0: 29 f8 sub %edi,%eax 116bb2: eb 05 jmp 116bb9 <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116bb4: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116bb7: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116bb9: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116bbc: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116bbf: ff 75 e0 pushl -0x20(%ebp) 116bc2: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116bc3: 57 push %edi 116bc4: 57 push %edi 116bc5: 83 c6 10 add $0x10,%esi 116bc8: 56 push %esi 116bc9: 8d 43 68 lea 0x68(%ebx),%eax 116bcc: 50 push %eax 116bcd: e8 2a 38 00 00 call 11a3fc <_Watchdog_Insert> if ( !ts->active ) { 116bd2: 8a 43 7c mov 0x7c(%ebx),%al 116bd5: 83 c4 10 add $0x10,%esp 116bd8: 84 c0 test %al,%al 116bda: 75 07 jne 116be3 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116bdc: 89 d8 mov %ebx,%eax 116bde: e8 43 fd ff ff call 116926 <_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 ); } } 116be3: 8d 65 f4 lea -0xc(%ebp),%esp 116be6: 5b pop %ebx 116be7: 5e pop %esi 116be8: 5f pop %edi 116be9: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116bea: e9 e7 26 00 00 jmp 1192d6 <_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 ); 116bef: 8b 43 78 mov 0x78(%ebx),%eax 116bf2: 89 75 0c mov %esi,0xc(%ebp) 116bf5: 89 45 08 mov %eax,0x8(%ebp) } } 116bf8: 8d 65 f4 lea -0xc(%ebp),%esp 116bfb: 5b pop %ebx 116bfc: 5e pop %esi 116bfd: 5f pop %edi 116bfe: c9 leave * 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 ); 116bff: e9 c8 06 00 00 jmp 1172cc <_Chain_Append> =============================================================================== 0010cb7f <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10cb7f: 55 push %ebp 10cb80: 89 e5 mov %esp,%ebp 10cb82: 57 push %edi 10cb83: 56 push %esi 10cb84: 53 push %ebx 10cb85: 83 ec 0c sub $0xc,%esp 10cb88: 8b 7d 10 mov 0x10(%ebp),%edi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10cb8b: 8b 1d e0 44 12 00 mov 0x1244e0,%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 ); 10cb91: 0f b6 75 0c movzbl 0xc(%ebp),%esi ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10cb95: eb 15 jmp 10cbac <_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 ) 10cb97: 8b 43 30 mov 0x30(%ebx),%eax 10cb9a: 85 c0 test %eax,%eax 10cb9c: 74 0b je 10cba9 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cb9e: 52 push %edx 10cb9f: 57 push %edi 10cba0: 56 push %esi 10cba1: ff 75 08 pushl 0x8(%ebp) 10cba4: ff d0 call *%eax 10cba6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10cba9: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10cbac: 81 fb d8 44 12 00 cmp $0x1244d8,%ebx 10cbb2: 75 e3 jne 10cb97 <_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 ); } } 10cbb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cbb7: 5b pop %ebx <== NOT EXECUTED 10cbb8: 5e pop %esi <== NOT EXECUTED 10cbb9: 5f pop %edi <== NOT EXECUTED 10cbba: c9 leave <== NOT EXECUTED 10cbbb: c3 ret <== NOT EXECUTED =============================================================================== 0010ca68 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10ca68: 55 push %ebp 10ca69: 89 e5 mov %esp,%ebp 10ca6b: 57 push %edi 10ca6c: 56 push %esi 10ca6d: 53 push %ebx 10ca6e: 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; 10ca71: a1 30 02 12 00 mov 0x120230,%eax 10ca76: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10ca79: 8b 35 34 02 12 00 mov 0x120234,%esi */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10ca7f: c7 05 d8 44 12 00 dc movl $0x1244dc,0x1244d8 10ca86: 44 12 00 the_chain->permanent_null = NULL; 10ca89: c7 05 dc 44 12 00 00 movl $0x0,0x1244dc 10ca90: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10ca93: c7 05 e0 44 12 00 d8 movl $0x1244d8,0x1244e0 10ca9a: 44 12 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10ca9d: c7 05 e8 42 12 00 ec movl $0x1242ec,0x1242e8 10caa4: 42 12 00 the_chain->permanent_null = NULL; 10caa7: c7 05 ec 42 12 00 00 movl $0x0,0x1242ec 10caae: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10cab1: c7 05 f0 42 12 00 e8 movl $0x1242e8,0x1242f0 10cab8: 42 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cabb: 85 f6 test %esi,%esi 10cabd: 74 53 je 10cb12 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cabf: 6b c8 34 imul $0x34,%eax,%ecx 10cac2: 83 ec 0c sub $0xc,%esp 10cac5: 51 push %ecx 10cac6: 89 4d e0 mov %ecx,-0x20(%ebp) 10cac9: e8 32 04 00 00 call 10cf00 <_Workspace_Allocate_or_fatal_error> 10cace: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cad0: 31 c0 xor %eax,%eax 10cad2: 8b 4d e0 mov -0x20(%ebp),%ecx 10cad5: 89 df mov %ebx,%edi 10cad7: f3 aa rep stos %al,%es:(%edi) 10cad9: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cadb: 83 c4 10 add $0x10,%esp 10cade: 31 d2 xor %edx,%edx 10cae0: eb 2b jmp 10cb0d <_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; 10cae2: 8d 7b 14 lea 0x14(%ebx),%edi 10cae5: 89 c6 mov %eax,%esi 10cae7: b9 08 00 00 00 mov $0x8,%ecx 10caec: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10caee: 83 ec 0c sub $0xc,%esp 10caf1: 53 push %ebx 10caf2: 89 45 dc mov %eax,-0x24(%ebp) 10caf5: 89 55 e0 mov %edx,-0x20(%ebp) 10caf8: e8 43 30 00 00 call 10fb40 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cafd: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cb00: 8b 55 e0 mov -0x20(%ebp),%edx 10cb03: 42 inc %edx 10cb04: 8b 45 dc mov -0x24(%ebp),%eax 10cb07: 83 c0 20 add $0x20,%eax 10cb0a: 83 c4 10 add $0x10,%esp 10cb0d: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cb10: 72 d0 jb 10cae2 <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cb12: 8d 65 f4 lea -0xc(%ebp),%esp 10cb15: 5b pop %ebx 10cb16: 5e pop %esi 10cb17: 5f pop %edi 10cb18: c9 leave 10cb19: c3 ret =============================================================================== 0010e4b0 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e4b0: 55 push %ebp 10e4b1: 89 e5 mov %esp,%ebp 10e4b3: 57 push %edi 10e4b4: 56 push %esi 10e4b5: 53 push %ebx 10e4b6: 83 ec 1c sub $0x1c,%esp 10e4b9: 8b 75 08 mov 0x8(%ebp),%esi 10e4bc: 8b 7d 0c mov 0xc(%ebp),%edi 10e4bf: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e4c2: 9c pushf 10e4c3: fa cli 10e4c4: 58 pop %eax */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 10e4c5: 8b 16 mov (%esi),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10e4c7: 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 ) ) { 10e4ca: 39 ca cmp %ecx,%edx 10e4cc: 74 44 je 10e512 <_Watchdog_Adjust+0x62> switch ( direction ) { 10e4ce: 85 ff test %edi,%edi 10e4d0: 74 3c je 10e50e <_Watchdog_Adjust+0x5e> 10e4d2: 4f dec %edi 10e4d3: 75 3d jne 10e512 <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e4d5: 01 5a 10 add %ebx,0x10(%edx) break; 10e4d8: eb 38 jmp 10e512 <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) header->first ); 10e4da: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e4dc: 8b 7a 10 mov 0x10(%edx),%edi 10e4df: 39 fb cmp %edi,%ebx 10e4e1: 73 07 jae 10e4ea <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e4e3: 29 df sub %ebx,%edi 10e4e5: 89 7a 10 mov %edi,0x10(%edx) break; 10e4e8: eb 28 jmp 10e512 <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e4ea: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e4f1: 50 push %eax 10e4f2: 9d popf _Watchdog_Tickle( header ); 10e4f3: 83 ec 0c sub $0xc,%esp 10e4f6: 56 push %esi 10e4f7: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e4fa: e8 9d 01 00 00 call 10e69c <_Watchdog_Tickle> _ISR_Disable( level ); 10e4ff: 9c pushf 10e500: fa cli 10e501: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e502: 83 c4 10 add $0x10,%esp 10e505: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e508: 39 0e cmp %ecx,(%esi) 10e50a: 74 06 je 10e512 <_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; 10e50c: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e50e: 85 db test %ebx,%ebx 10e510: 75 c8 jne 10e4da <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e512: 50 push %eax 10e513: 9d popf } 10e514: 8d 65 f4 lea -0xc(%ebp),%esp 10e517: 5b pop %ebx 10e518: 5e pop %esi 10e519: 5f pop %edi 10e51a: c9 leave 10e51b: c3 ret =============================================================================== 0010cdb8 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10cdb8: 55 push %ebp 10cdb9: 89 e5 mov %esp,%ebp 10cdbb: 56 push %esi 10cdbc: 53 push %ebx 10cdbd: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cdc0: 9c pushf 10cdc1: fa cli 10cdc2: 5e pop %esi previous_state = the_watchdog->state; 10cdc3: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10cdc6: 83 f8 01 cmp $0x1,%eax 10cdc9: 74 09 je 10cdd4 <_Watchdog_Remove+0x1c> 10cdcb: 72 42 jb 10ce0f <_Watchdog_Remove+0x57> 10cdcd: 83 f8 03 cmp $0x3,%eax 10cdd0: 77 3d ja 10ce0f <_Watchdog_Remove+0x57> <== NEVER TAKEN 10cdd2: eb 09 jmp 10cddd <_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; 10cdd4: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cddb: eb 32 jmp 10ce0f <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cddd: 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 ); } 10cde4: 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) ) 10cde6: 83 39 00 cmpl $0x0,(%ecx) 10cde9: 74 06 je 10cdf1 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cdeb: 8b 5a 10 mov 0x10(%edx),%ebx 10cdee: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10cdf1: 8b 1d 18 44 12 00 mov 0x124418,%ebx 10cdf7: 85 db test %ebx,%ebx 10cdf9: 74 0c je 10ce07 <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cdfb: 8b 1d 30 48 12 00 mov 0x124830,%ebx 10ce01: 89 1d 90 43 12 00 mov %ebx,0x124390 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10ce07: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10ce0a: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10ce0d: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10ce0f: 8b 0d 1c 44 12 00 mov 0x12441c,%ecx 10ce15: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10ce18: 56 push %esi 10ce19: 9d popf return( previous_state ); } 10ce1a: 5b pop %ebx 10ce1b: 5e pop %esi 10ce1c: c9 leave 10ce1d: c3 ret =============================================================================== 0010e040 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e040: 55 push %ebp 10e041: 89 e5 mov %esp,%ebp 10e043: 57 push %edi 10e044: 56 push %esi 10e045: 53 push %ebx 10e046: 83 ec 20 sub $0x20,%esp 10e049: 8b 7d 08 mov 0x8(%ebp),%edi 10e04c: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e04f: 9c pushf 10e050: fa cli 10e051: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e054: 56 push %esi 10e055: 57 push %edi 10e056: 68 80 0f 12 00 push $0x120f80 10e05b: e8 88 aa ff ff call 108ae8 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 10e060: 8b 1e mov (%esi),%ebx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10e062: 83 c6 04 add $0x4,%esi if ( !_Chain_Is_empty( header ) ) { 10e065: 83 c4 10 add $0x10,%esp 10e068: 39 f3 cmp %esi,%ebx 10e06a: 74 1d je 10e089 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e06c: 52 push %edx 10e06d: 52 push %edx 10e06e: 53 push %ebx 10e06f: 6a 00 push $0x0 10e071: e8 32 00 00 00 call 10e0a8 <_Watchdog_Report> _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = header->first ; node != _Chain_Tail(header) ; node = node->next ) 10e076: 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 = header->first ; 10e078: 83 c4 10 add $0x10,%esp 10e07b: 39 f3 cmp %esi,%ebx 10e07d: 75 ed jne 10e06c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e07f: 50 push %eax 10e080: 50 push %eax 10e081: 57 push %edi 10e082: 68 97 0f 12 00 push $0x120f97 10e087: eb 08 jmp 10e091 <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e089: 83 ec 0c sub $0xc,%esp 10e08c: 68 a6 0f 12 00 push $0x120fa6 10e091: e8 52 aa ff ff call 108ae8 10e096: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e099: ff 75 e4 pushl -0x1c(%ebp) 10e09c: 9d popf } 10e09d: 8d 65 f4 lea -0xc(%ebp),%esp 10e0a0: 5b pop %ebx 10e0a1: 5e pop %esi 10e0a2: 5f pop %edi 10e0a3: c9 leave 10e0a4: c3 ret =============================================================================== 0010a7c0 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a7c0: 55 push %ebp 10a7c1: 89 e5 mov %esp,%ebp 10a7c3: 57 push %edi 10a7c4: 56 push %esi 10a7c5: 53 push %ebx 10a7c6: 83 ec 18 sub $0x18,%esp 10a7c9: 8b 75 08 mov 0x8(%ebp),%esi 10a7cc: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a7cf: 68 78 72 12 00 push $0x127278 10a7d4: e8 0b 10 00 00 call 10b7e4 if (aiocbp == NULL) 10a7d9: 83 c4 10 add $0x10,%esp 10a7dc: 85 db test %ebx,%ebx 10a7de: 0f 85 05 01 00 00 jne 10a8e9 { if (fcntl (fildes, F_GETFL) < 0) { 10a7e4: 53 push %ebx 10a7e5: 53 push %ebx 10a7e6: 6a 03 push $0x3 10a7e8: 56 push %esi 10a7e9: e8 9e 5f 00 00 call 11078c 10a7ee: 83 c4 10 add $0x10,%esp 10a7f1: 85 c0 test %eax,%eax 10a7f3: 79 1d jns 10a812 <== NEVER TAKEN pthread_mutex_unlock(&aio_request_queue.mutex); 10a7f5: 83 ec 0c sub $0xc,%esp 10a7f8: 68 78 72 12 00 push $0x127278 10a7fd: e8 62 10 00 00 call 10b864 rtems_set_errno_and_return_minus_one (EBADF); 10a802: e8 35 8e 00 00 call 11363c <__errno> 10a807: c7 00 09 00 00 00 movl $0x9,(%eax) 10a80d: e9 f5 00 00 00 jmp 10a907 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a812: 51 push %ecx <== NOT EXECUTED 10a813: 6a 00 push $0x0 <== NOT EXECUTED 10a815: 56 push %esi <== NOT EXECUTED 10a816: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10a81b: e8 20 03 00 00 call 10ab40 <== NOT EXECUTED 10a820: 89 c3 mov %eax,%ebx <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a825: 85 c0 test %eax,%eax <== NOT EXECUTED 10a827: 0f 85 82 00 00 00 jne 10a8af <== NOT EXECUTED { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) 10a82d: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10a834: 72 12 00 10a837: 74 5c je 10a895 <== NOT EXECUTED { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, 10a839: 52 push %edx <== NOT EXECUTED 10a83a: 6a 00 push $0x0 <== NOT EXECUTED 10a83c: 56 push %esi <== NOT EXECUTED 10a83d: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED 10a842: e8 f9 02 00 00 call 10ab40 <== NOT EXECUTED 10a847: 89 c3 mov %eax,%ebx <== NOT EXECUTED fildes, 0); if (r_chain == NULL) { 10a849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a84c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a84e: 75 17 jne 10a867 <== NOT EXECUTED pthread_mutex_unlock(&aio_request_queue.mutex); 10a850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a853: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a858: e8 07 10 00 00 call 10b864 <== NOT EXECUTED return AIO_ALLDONE; 10a85d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a860: b3 02 mov $0x2,%bl <== NOT EXECUTED 10a862: e9 1b 01 00 00 jmp 10a982 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a867: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a86a: 50 push %eax <== NOT EXECUTED 10a86b: e8 d0 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED } rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a870: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a873: e8 07 06 00 00 call 10ae7f <== NOT EXECUTED pthread_mutex_destroy (&r_chain->mutex); 10a878: 8d 73 1c lea 0x1c(%ebx),%esi <== NOT EXECUTED 10a87b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a87e: e8 41 0d 00 00 call 10b5c4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->mutex); 10a883: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a886: e8 45 0a 00 00 call 10b2d0 <== NOT EXECUTED free (r_chain); 10a88b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a88e: e8 ad d4 ff ff call 107d40 <== NOT EXECUTED 10a893: eb 3e jmp 10a8d3 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } pthread_mutex_unlock (&aio_request_queue.mutex); 10a895: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a898: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a89d: e8 c2 0f 00 00 call 10b864 <== NOT EXECUTED return AIO_ALLDONE; 10a8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a8aa: e9 d3 00 00 00 jmp 10a982 <== NOT EXECUTED } pthread_mutex_lock (&r_chain->mutex); 10a8af: 8d 70 1c lea 0x1c(%eax),%esi <== NOT EXECUTED 10a8b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8b5: 56 push %esi <== NOT EXECUTED 10a8b6: e8 29 0f 00 00 call 10b7e4 <== NOT EXECUTED 10a8bb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a8be: e8 7d 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a8c6: e8 b4 05 00 00 call 10ae7f <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); 10a8cb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a8ce: e8 91 0f 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a8d3: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10a8da: e8 85 0f 00 00 call 10b864 <== NOT EXECUTED return AIO_CANCELED; 10a8df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8e2: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a8e4: e9 99 00 00 00 jmp 10a982 <== NOT EXECUTED } else { if (aiocbp->aio_fildes != fildes) { 10a8e9: 8b 3b mov (%ebx),%edi 10a8eb: 39 f7 cmp %esi,%edi 10a8ed: 74 20 je 10a90f <== NEVER TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10a8ef: 83 ec 0c sub $0xc,%esp 10a8f2: 68 78 72 12 00 push $0x127278 10a8f7: e8 68 0f 00 00 call 10b864 rtems_set_errno_and_return_minus_one (EINVAL); 10a8fc: e8 3b 8d 00 00 call 11363c <__errno> 10a901: c7 00 16 00 00 00 movl $0x16,(%eax) 10a907: 83 c4 10 add $0x10,%esp 10a90a: 83 cb ff or $0xffffffff,%ebx 10a90d: eb 73 jmp 10a982 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a90f: 50 push %eax <== NOT EXECUTED 10a910: 6a 00 push $0x0 <== NOT EXECUTED 10a912: 57 push %edi <== NOT EXECUTED 10a913: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10a918: e8 23 02 00 00 call 10ab40 <== NOT EXECUTED 10a91d: 89 c6 mov %eax,%esi <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a91f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a922: 85 c0 test %eax,%eax <== NOT EXECUTED 10a924: 75 2e jne 10a954 <== NOT EXECUTED if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) 10a926: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10a92d: 72 12 00 10a930: 74 22 je 10a954 <== NOT EXECUTED { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, 10a932: 56 push %esi <== NOT EXECUTED 10a933: 6a 00 push $0x0 <== NOT EXECUTED 10a935: 57 push %edi <== NOT EXECUTED 10a936: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED 10a93b: e8 00 02 00 00 call 10ab40 <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a943: 85 c0 test %eax,%eax <== NOT EXECUTED 10a945: 74 a8 je 10a8ef <== NOT EXECUTED { pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp); 10a947: 51 push %ecx <== NOT EXECUTED 10a948: 51 push %ecx <== NOT EXECUTED 10a949: 53 push %ebx <== NOT EXECUTED 10a94a: 50 push %eax <== NOT EXECUTED 10a94b: e8 6f 05 00 00 call 10aebf <== NOT EXECUTED 10a950: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a952: eb 1f jmp 10a973 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); return result; } pthread_mutex_lock (&r_chain->mutex); 10a954: 8d 7e 1c lea 0x1c(%esi),%edi <== NOT EXECUTED 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: 57 push %edi <== NOT EXECUTED 10a95b: e8 84 0e 00 00 call 10b7e4 <== NOT EXECUTED result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp); 10a960: 58 pop %eax <== NOT EXECUTED 10a961: 5a pop %edx <== NOT EXECUTED 10a962: 53 push %ebx <== NOT EXECUTED 10a963: 56 push %esi <== NOT EXECUTED 10a964: e8 56 05 00 00 call 10aebf <== NOT EXECUTED 10a969: 89 c3 mov %eax,%ebx <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); 10a96b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a96e: e8 f1 0e 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a973: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10a97a: e8 e5 0e 00 00 call 10b864 <== NOT EXECUTED return result; 10a97f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return AIO_ALLDONE; } 10a982: 89 d8 mov %ebx,%eax 10a984: 8d 65 f4 lea -0xc(%ebp),%esp 10a987: 5b pop %ebx 10a988: 5e pop %esi 10a989: 5f pop %edi 10a98a: c9 leave 10a98b: c3 ret =============================================================================== 0010a998 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a998: 55 push %ebp 10a999: 89 e5 mov %esp,%ebp 10a99b: 53 push %ebx 10a99c: 83 ec 04 sub $0x4,%esp 10a99f: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a9a2: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10a9a9: 74 1b je 10a9c6 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a9ab: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a9b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9b9: e8 7e 8c 00 00 call 11363c <__errno> 10a9be: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9c4: eb 74 jmp 10aa3a mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a9c6: 50 push %eax 10a9c7: 50 push %eax 10a9c8: 6a 03 push $0x3 10a9ca: ff 33 pushl (%ebx) 10a9cc: e8 bb 5d 00 00 call 11078c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a9d1: 83 e0 03 and $0x3,%eax 10a9d4: 48 dec %eax 10a9d5: 83 c4 10 add $0x10,%esp 10a9d8: 83 f8 01 cmp $0x1,%eax 10a9db: 76 1b jbe 10a9f8 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a9dd: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a9e4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9eb: e8 4c 8c 00 00 call 11363c <__errno> 10a9f0: c7 00 09 00 00 00 movl $0x9,(%eax) 10a9f6: eb 42 jmp 10aa3a req = malloc (sizeof (rtems_aio_request)); 10a9f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9fb: 6a 18 push $0x18 <== NOT EXECUTED 10a9fd: e8 c2 d7 ff ff call 1081c4 <== NOT EXECUTED if (req == NULL) 10aa02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa05: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa07: 75 1b jne 10aa24 <== NOT EXECUTED rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10aa09: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10aa10: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10aa17: e8 20 8c 00 00 call 11363c <__errno> <== NOT EXECUTED 10aa1c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10aa22: eb 16 jmp 10aa3a <== NOT EXECUTED req->aiocbp = aiocbp; 10aa24: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa27: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) <== NOT EXECUTED return rtems_aio_enqueue (req); 10aa2e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10aa31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa34: c9 leave <== NOT EXECUTED rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10aa35: e9 d7 04 00 00 jmp 10af11 <== NOT EXECUTED } 10aa3a: 83 c8 ff or $0xffffffff,%eax 10aa3d: 8b 5d fc mov -0x4(%ebp),%ebx 10aa40: c9 leave 10aa41: c3 ret =============================================================================== 0010b10c : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b10c: 55 push %ebp 10b10d: 89 e5 mov %esp,%ebp 10b10f: 53 push %ebx 10b110: 83 ec 0c sub $0xc,%esp 10b113: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b116: 6a 03 push $0x3 10b118: ff 33 pushl (%ebx) 10b11a: e8 6d 56 00 00 call 11078c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b11f: 83 e0 03 and $0x3,%eax 10b122: 83 c4 10 add $0x10,%esp 10b125: 83 f8 02 cmp $0x2,%eax 10b128: 74 1f je 10b149 10b12a: 85 c0 test %eax,%eax 10b12c: 74 1b je 10b149 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b12e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b135: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b13c: e8 fb 84 00 00 call 11363c <__errno> 10b141: c7 00 09 00 00 00 movl $0x9,(%eax) 10b147: eb 69 jmp 10b1b2 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b149: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b14d: 75 06 jne 10b155 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b14f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b153: 79 1b jns 10b170 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b155: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b15c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b163: e8 d4 84 00 00 call 11363c <__errno> 10b168: c7 00 16 00 00 00 movl $0x16,(%eax) 10b16e: eb 42 jmp 10b1b2 req = malloc (sizeof (rtems_aio_request)); 10b170: 83 ec 0c sub $0xc,%esp 10b173: 6a 18 push $0x18 10b175: e8 4a d0 ff ff call 1081c4 if (req == NULL) 10b17a: 83 c4 10 add $0x10,%esp 10b17d: 85 c0 test %eax,%eax 10b17f: 75 1b jne 10b19c <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b181: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b188: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b18f: e8 a8 84 00 00 call 11363c <__errno> <== NOT EXECUTED 10b194: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b19a: eb 16 jmp 10b1b2 <== NOT EXECUTED req->aiocbp = aiocbp; 10b19c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b19f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b1a6: 89 45 08 mov %eax,0x8(%ebp) } 10b1a9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ac: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); 10b1ad: e9 5f fd ff ff jmp 10af11 } 10b1b2: 83 c8 ff or $0xffffffff,%eax 10b1b5: 8b 5d fc mov -0x4(%ebp),%ebx 10b1b8: c9 leave 10b1b9: c3 ret =============================================================================== 0010b1c8 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b1c8: 55 push %ebp 10b1c9: 89 e5 mov %esp,%ebp 10b1cb: 53 push %ebx 10b1cc: 83 ec 0c sub $0xc,%esp 10b1cf: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b1d2: 6a 03 push $0x3 10b1d4: ff 33 pushl (%ebx) 10b1d6: e8 b1 55 00 00 call 11078c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b1db: 83 e0 03 and $0x3,%eax 10b1de: 48 dec %eax 10b1df: 83 c4 10 add $0x10,%esp 10b1e2: 83 f8 01 cmp $0x1,%eax 10b1e5: 76 1b jbe 10b202 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1e7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b1ee: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1f5: e8 42 84 00 00 call 11363c <__errno> 10b1fa: c7 00 09 00 00 00 movl $0x9,(%eax) 10b200: eb 69 jmp 10b26b if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b202: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b206: 75 06 jne 10b20e rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b208: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b20c: 79 1b jns 10b229 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b20e: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b215: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b21c: e8 1b 84 00 00 call 11363c <__errno> 10b221: c7 00 16 00 00 00 movl $0x16,(%eax) 10b227: eb 42 jmp 10b26b req = malloc (sizeof (rtems_aio_request)); 10b229: 83 ec 0c sub $0xc,%esp 10b22c: 6a 18 push $0x18 10b22e: e8 91 cf ff ff call 1081c4 if (req == NULL) 10b233: 83 c4 10 add $0x10,%esp 10b236: 85 c0 test %eax,%eax 10b238: 75 1b jne 10b255 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b23a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b241: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b248: e8 ef 83 00 00 call 11363c <__errno> <== NOT EXECUTED 10b24d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b253: eb 16 jmp 10b26b <== NOT EXECUTED req->aiocbp = aiocbp; 10b255: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b258: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b25f: 89 45 08 mov %eax,0x8(%ebp) } 10b262: 8b 5d fc mov -0x4(%ebp),%ebx 10b265: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); 10b266: e9 a6 fc ff ff jmp 10af11 } 10b26b: 83 c8 ff or $0xffffffff,%eax 10b26e: 8b 5d fc mov -0x4(%ebp),%ebx 10b271: c9 leave 10b272: c3 ret =============================================================================== 00109f94 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109f94: 55 push %ebp 109f95: 89 e5 mov %esp,%ebp 109f97: 83 ec 08 sub $0x8,%esp 109f9a: 8b 45 08 mov 0x8(%ebp),%eax 109f9d: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109fa0: 85 d2 test %edx,%edx 109fa2: 74 3c je 109fe0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109fa4: 83 f8 01 cmp $0x1,%eax 109fa7: 75 0b jne 109fb4 _TOD_Get(tp); 109fa9: 83 ec 0c sub $0xc,%esp 109fac: 52 push %edx 109fad: e8 9e 1b 00 00 call 10bb50 <_TOD_Get> 109fb2: eb 13 jmp 109fc7 return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 109fb4: 83 f8 04 cmp $0x4,%eax 109fb7: 74 05 je 109fbe <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 109fb9: 83 f8 02 cmp $0x2,%eax 109fbc: 75 10 jne 109fce _TOD_Get_uptime_as_timespec( tp ); 109fbe: 83 ec 0c sub $0xc,%esp 109fc1: 52 push %edx 109fc2: e8 e5 1b 00 00 call 10bbac <_TOD_Get_uptime_as_timespec> return 0; 109fc7: 83 c4 10 add $0x10,%esp 109fca: 31 c0 xor %eax,%eax 109fcc: eb 20 jmp 109fee } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 109fce: 83 f8 03 cmp $0x3,%eax 109fd1: 75 0d jne 109fe0 rtems_set_errno_and_return_minus_one( ENOSYS ); 109fd3: e8 68 7f 00 00 call 111f40 <__errno> 109fd8: c7 00 58 00 00 00 movl $0x58,(%eax) 109fde: eb 0b jmp 109feb #endif rtems_set_errno_and_return_minus_one( EINVAL ); 109fe0: e8 5b 7f 00 00 call 111f40 <__errno> 109fe5: c7 00 16 00 00 00 movl $0x16,(%eax) 109feb: 83 c8 ff or $0xffffffff,%eax return 0; } 109fee: c9 leave 109fef: c3 ret =============================================================================== 00109ff0 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 109ff0: 55 push %ebp 109ff1: 89 e5 mov %esp,%ebp 109ff3: 83 ec 08 sub $0x8,%esp 109ff6: 8b 45 08 mov 0x8(%ebp),%eax 109ff9: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109ffc: 85 d2 test %edx,%edx 109ffe: 74 44 je 10a044 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a000: 83 f8 01 cmp $0x1,%eax 10a003: 75 28 jne 10a02d if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a005: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a00b: 76 37 jbe 10a044 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a00d: a1 24 63 12 00 mov 0x126324,%eax 10a012: 40 inc %eax 10a013: a3 24 63 12 00 mov %eax,0x126324 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a018: 83 ec 0c sub $0xc,%esp 10a01b: 52 push %edx 10a01c: e8 e3 1b 00 00 call 10bc04 <_TOD_Set> _Thread_Enable_dispatch(); 10a021: e8 68 2c 00 00 call 10cc8e <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a026: 83 c4 10 add $0x10,%esp 10a029: 31 c0 xor %eax,%eax 10a02b: eb 25 jmp 10a052 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a02d: 83 f8 02 cmp $0x2,%eax 10a030: 74 05 je 10a037 rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a032: 83 f8 03 cmp $0x3,%eax 10a035: 75 0d jne 10a044 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a037: e8 04 7f 00 00 call 111f40 <__errno> 10a03c: c7 00 58 00 00 00 movl $0x58,(%eax) 10a042: eb 0b jmp 10a04f #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a044: e8 f7 7e 00 00 call 111f40 <__errno> 10a049: c7 00 16 00 00 00 movl $0x16,(%eax) 10a04f: 83 c8 ff or $0xffffffff,%eax return 0; } 10a052: c9 leave 10a053: c3 ret =============================================================================== 00121620 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121620: 55 push %ebp 121621: 89 e5 mov %esp,%ebp 121623: 57 push %edi 121624: 56 push %esi 121625: 53 push %ebx 121626: 83 ec 4c sub $0x4c,%esp 121629: 8b 5d 0c mov 0xc(%ebp),%ebx 12162c: 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() ) 12162f: e8 64 fd ff ff call 121398 121634: 39 45 08 cmp %eax,0x8(%ebp) 121637: 74 0d je 121646 rtems_set_errno_and_return_minus_one( ESRCH ); 121639: e8 16 43 ff ff call 115954 <__errno> 12163e: c7 00 03 00 00 00 movl $0x3,(%eax) 121644: eb 0f jmp 121655 /* * Validate the signal passed. */ if ( !sig ) 121646: 85 db test %ebx,%ebx 121648: 75 13 jne 12165d rtems_set_errno_and_return_minus_one( EINVAL ); 12164a: e8 05 43 ff ff call 115954 <__errno> 12164f: c7 00 16 00 00 00 movl $0x16,(%eax) 121655: 83 c8 ff or $0xffffffff,%eax 121658: e9 ef 01 00 00 jmp 12184c static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 12165d: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 121660: 83 f9 1f cmp $0x1f,%ecx 121663: 77 e5 ja 12164a 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 ) 121665: 6b d3 0c imul $0xc,%ebx,%edx return 0; 121668: 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 ) 12166a: 83 ba c0 a9 12 00 01 cmpl $0x1,0x12a9c0(%edx) 121671: 0f 84 d5 01 00 00 je 12184c /* * 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 ) ) 121677: 83 fb 04 cmp $0x4,%ebx 12167a: 74 0a je 121686 12167c: 83 fb 08 cmp $0x8,%ebx 12167f: 74 05 je 121686 121681: 83 fb 0b cmp $0xb,%ebx 121684: 75 16 jne 12169c return pthread_kill( pthread_self(), sig ); 121686: e8 89 03 00 00 call 121a14 12168b: 56 push %esi 12168c: 56 push %esi 12168d: 53 push %ebx 12168e: 50 push %eax 12168f: e8 d8 02 00 00 call 12196c 121694: 83 c4 10 add $0x10,%esp 121697: e9 b0 01 00 00 jmp 12184c static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 12169c: be 01 00 00 00 mov $0x1,%esi 1216a1: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 1216a3: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 1216a6: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 1216ad: 85 ff test %edi,%edi 1216af: 75 09 jne 1216ba siginfo->si_value.sival_int = 0; 1216b1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1216b8: eb 05 jmp 1216bf } else { siginfo->si_value = *value; 1216ba: 8b 07 mov (%edi),%eax 1216bc: 89 45 e4 mov %eax,-0x1c(%ebp) 1216bf: a1 58 a4 12 00 mov 0x12a458,%eax 1216c4: 40 inc %eax 1216c5: a3 58 a4 12 00 mov %eax,0x12a458 /* * 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; 1216ca: a1 a8 a9 12 00 mov 0x12a9a8,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 1216cf: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx 1216d5: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 1216db: f7 d2 not %edx 1216dd: 85 d6 test %edx,%esi 1216df: 0f 85 ed 00 00 00 jne 1217d2 /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; 1216e5: 8b 15 44 ab 12 00 mov 0x12ab44,%edx 1216eb: eb 23 jmp 121710 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 1216ed: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1216ef: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 1216f5: 85 72 30 test %esi,0x30(%edx) 1216f8: 0f 85 d4 00 00 00 jne 1217d2 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 1216fe: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 121704: f7 d1 not %ecx 121706: 85 ce test %ecx,%esi 121708: 0f 85 c4 00 00 00 jne 1217d2 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 12170e: 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 = the_chain->first ; 121710: 81 fa 48 ab 12 00 cmp $0x12ab48,%edx 121716: 75 d5 jne 1216ed * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 121718: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx 12171f: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 121720: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 121722: 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 ] ) 121729: 8b 7d cc mov -0x34(%ebp),%edi 12172c: 8b 14 bd 30 a4 12 00 mov 0x12a430(,%edi,4),%edx 121733: 85 d2 test %edx,%edx 121735: 0f 84 86 00 00 00 je 1217c1 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 12173b: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 12173e: 0f b7 7a 10 movzwl 0x10(%edx),%edi 121742: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 121745: 8b 52 1c mov 0x1c(%edx),%edx 121748: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 12174b: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 121752: 89 5d b4 mov %ebx,-0x4c(%ebp) 121755: eb 5f jmp 1217b6 the_thread = (Thread_Control *) object_table[ index ]; 121757: 8b 5d d0 mov -0x30(%ebp),%ebx 12175a: 8b 7d c0 mov -0x40(%ebp),%edi 12175d: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 121760: 85 d2 test %edx,%edx 121762: 74 4f je 1217b3 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 121764: 8b 5a 14 mov 0x14(%edx),%ebx 121767: 89 5d d4 mov %ebx,-0x2c(%ebp) 12176a: 39 cb cmp %ecx,%ebx 12176c: 77 45 ja 1217b3 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 12176e: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi 121774: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 12177a: f7 d7 not %edi 12177c: 85 fe test %edi,%esi 12177e: 74 33 je 1217b3 * * 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 ) { 121780: 39 cb cmp %ecx,%ebx 121782: 72 2a jb 1217ae * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 121784: 85 c0 test %eax,%eax 121786: 74 2b je 1217b3 <== NEVER TAKEN 121788: 8b 78 10 mov 0x10(%eax),%edi 12178b: 89 7d c8 mov %edi,-0x38(%ebp) 12178e: 85 ff test %edi,%edi 121790: 74 21 je 1217b3 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 121792: 8b 7a 10 mov 0x10(%edx),%edi 121795: 85 ff test %edi,%edi 121797: 74 15 je 1217ae continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 121799: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 1217a0: 75 11 jne 1217b3 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1217a2: 81 e7 00 00 00 10 and $0x10000000,%edi 1217a8: 74 09 je 1217b3 1217aa: 89 d9 mov %ebx,%ecx 1217ac: eb 03 jmp 1217b1 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1217ae: 8b 4d d4 mov -0x2c(%ebp),%ecx 1217b1: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 1217b3: ff 45 d0 incl -0x30(%ebp) 1217b6: 8b 55 c4 mov -0x3c(%ebp),%edx 1217b9: 39 55 d0 cmp %edx,-0x30(%ebp) 1217bc: 76 99 jbe 121757 1217be: 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++) { 1217c1: ff 45 cc incl -0x34(%ebp) 1217c4: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 1217c8: 0f 85 5b ff ff ff jne 121729 } } } } if ( interested ) { 1217ce: 85 c0 test %eax,%eax 1217d0: 74 13 je 1217e5 /* * 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 ) ) { 1217d2: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 1217d3: 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 ) ) { 1217d6: 52 push %edx 1217d7: 53 push %ebx 1217d8: 50 push %eax 1217d9: e8 8a 00 00 00 call 121868 <_POSIX_signals_Unblock_thread> 1217de: 83 c4 10 add $0x10,%esp 1217e1: 84 c0 test %al,%al 1217e3: 75 60 jne 121845 /* * 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 ); 1217e5: 83 ec 0c sub $0xc,%esp 1217e8: 56 push %esi 1217e9: e8 66 00 00 00 call 121854 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 1217ee: 6b db 0c imul $0xc,%ebx,%ebx 1217f1: 83 c4 10 add $0x10,%esp 1217f4: 83 bb b8 a9 12 00 02 cmpl $0x2,0x12a9b8(%ebx) 1217fb: 75 48 jne 121845 psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 1217fd: 83 ec 0c sub $0xc,%esp 121800: 68 38 ab 12 00 push $0x12ab38 121805: e8 2a d9 fe ff call 10f134 <_Chain_Get> if ( !psiginfo ) { 12180a: 83 c4 10 add $0x10,%esp 12180d: 85 c0 test %eax,%eax 12180f: 75 15 jne 121826 _Thread_Enable_dispatch(); 121811: e8 80 ee fe ff call 110696 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 121816: e8 39 41 ff ff call 115954 <__errno> 12181b: c7 00 0b 00 00 00 movl $0xb,(%eax) 121821: e9 2f fe ff ff jmp 121655 } psiginfo->Info = *siginfo; 121826: 8d 78 08 lea 0x8(%eax),%edi 121829: 8d 75 dc lea -0x24(%ebp),%esi 12182c: b9 03 00 00 00 mov $0x3,%ecx 121831: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 121833: 52 push %edx 121834: 52 push %edx 121835: 50 push %eax 121836: 81 c3 b0 ab 12 00 add $0x12abb0,%ebx 12183c: 53 push %ebx 12183d: e8 b6 d8 fe ff call 10f0f8 <_Chain_Append> 121842: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 121845: e8 4c ee fe ff call 110696 <_Thread_Enable_dispatch> return 0; 12184a: 31 c0 xor %eax,%eax } 12184c: 8d 65 f4 lea -0xc(%ebp),%esp 12184f: 5b pop %ebx 121850: 5e pop %esi 121851: 5f pop %edi 121852: c9 leave 121853: c3 ret =============================================================================== 0010dff0 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 10dff0: 55 push %ebp 10dff1: 89 e5 mov %esp,%ebp 10dff3: 53 push %ebx 10dff4: 83 ec 14 sub $0x14,%esp 10dff7: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 10dffa: 85 db test %ebx,%ebx 10dffc: 75 0d jne 10e00b <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10dffe: e8 d1 8d 00 00 call 116dd4 <__errno> 10e003: c7 00 16 00 00 00 movl $0x16,(%eax) 10e009: eb 49 jmp 10e054 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10e00b: 50 push %eax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10e00c: 8d 45 f4 lea -0xc(%ebp),%eax 10e00f: 50 push %eax 10e010: ff 75 08 pushl 0x8(%ebp) 10e013: 68 7c d9 12 00 push $0x12d97c 10e018: e8 af 2d 00 00 call 110dcc <_Objects_Get> switch ( location ) { 10e01d: 83 c4 10 add $0x10,%esp 10e020: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10e024: 75 23 jne 10e049 case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10e026: 8b 50 10 mov 0x10(%eax),%edx * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 10e029: 8b 40 14 mov 0x14(%eax),%eax 10e02c: 89 03 mov %eax,(%ebx) mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10e02e: 8b 42 68 mov 0x68(%edx),%eax 10e031: 89 43 08 mov %eax,0x8(%ebx) mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 10e034: 8b 42 60 mov 0x60(%edx),%eax 10e037: 89 43 04 mov %eax,0x4(%ebx) mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 10e03a: 8b 42 64 mov 0x64(%edx),%eax 10e03d: 89 43 0c mov %eax,0xc(%ebx) _Thread_Enable_dispatch(); 10e040: e8 d9 35 00 00 call 11161e <_Thread_Enable_dispatch> return 0; 10e045: 31 c0 xor %eax,%eax 10e047: eb 0e jmp 10e057 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e049: e8 86 8d 00 00 call 116dd4 <__errno> 10e04e: c7 00 09 00 00 00 movl $0x9,(%eax) 10e054: 83 c8 ff or $0xffffffff,%eax } 10e057: 8b 5d fc mov -0x4(%ebp),%ebx 10e05a: c9 leave 10e05b: c3 ret =============================================================================== 0010efd8 : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10efd8: 55 push %ebp 10efd9: 89 e5 mov %esp,%ebp 10efdb: 8b 55 08 mov 0x8(%ebp),%edx 10efde: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10efe1: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) 10efe6: 85 d2 test %edx,%edx 10efe8: 74 17 je 10f001 <== NEVER TAKEN 10efea: 85 c9 test %ecx,%ecx 10efec: 74 0e je 10effc 10efee: 83 3a 00 cmpl $0x0,(%edx) 10eff1: 74 09 je 10effc return EINVAL; *inheritsched = attr->inheritsched; 10eff3: 8b 42 10 mov 0x10(%edx),%eax 10eff6: 89 01 mov %eax,(%ecx) return 0; 10eff8: 31 c0 xor %eax,%eax 10effa: eb 05 jmp 10f001 const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10effc: b8 16 00 00 00 mov $0x16,%eax *inheritsched = attr->inheritsched; return 0; } 10f001: c9 leave 10f002: c3 ret =============================================================================== 0010f1f4 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f1f4: 55 push %ebp 10f1f5: 89 e5 mov %esp,%ebp 10f1f7: 8b 55 08 mov 0x8(%ebp),%edx 10f1fa: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f1fd: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f202: 85 d2 test %edx,%edx 10f204: 74 1e je 10f224 10f206: 83 3a 00 cmpl $0x0,(%edx) 10f209: 74 19 je 10f224 return EINVAL; switch ( policy ) { 10f20b: 83 f9 04 cmp $0x4,%ecx 10f20e: 77 0f ja 10f21f 10f210: b0 01 mov $0x1,%al 10f212: d3 e0 shl %cl,%eax 10f214: a8 17 test $0x17,%al 10f216: 74 07 je 10f21f <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f218: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f21b: 31 c0 xor %eax,%eax 10f21d: eb 05 jmp 10f224 default: return ENOTSUP; 10f21f: b8 86 00 00 00 mov $0x86,%eax } } 10f224: c9 leave 10f225: c3 ret =============================================================================== 0010a514 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a514: 55 push %ebp 10a515: 89 e5 mov %esp,%ebp 10a517: 57 push %edi 10a518: 56 push %esi 10a519: 53 push %ebx 10a51a: 83 ec 1c sub $0x1c,%esp 10a51d: 8b 5d 08 mov 0x8(%ebp),%ebx 10a520: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a523: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a528: 85 db test %ebx,%ebx 10a52a: 0f 84 96 00 00 00 je 10a5c6 return EINVAL; if ( count == 0 ) 10a530: 85 f6 test %esi,%esi 10a532: 0f 84 8e 00 00 00 je 10a5c6 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a538: 8b 7d 0c mov 0xc(%ebp),%edi 10a53b: 85 ff test %edi,%edi 10a53d: 75 0f jne 10a54e the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a53f: 83 ec 0c sub $0xc,%esp 10a542: 8d 7d d8 lea -0x28(%ebp),%edi 10a545: 57 push %edi 10a546: e8 19 ff ff ff call 10a464 10a54b: 83 c4 10 add $0x10,%esp /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; 10a54e: b8 16 00 00 00 mov $0x16,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a553: 83 3f 00 cmpl $0x0,(%edi) 10a556: 74 6e je 10a5c6 return EINVAL; switch ( the_attr->process_shared ) { 10a558: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a55c: 75 68 jne 10a5c6 <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a55e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a565: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a568: a1 f4 63 12 00 mov 0x1263f4,%eax 10a56d: 40 inc %eax 10a56e: a3 f4 63 12 00 mov %eax,0x1263f4 * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) _Objects_Allocate( &_POSIX_Barrier_Information ); 10a573: 83 ec 0c sub $0xc,%esp 10a576: 68 c0 67 12 00 push $0x1267c0 10a57b: e8 08 1e 00 00 call 10c388 <_Objects_Allocate> 10a580: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a582: 83 c4 10 add $0x10,%esp 10a585: 85 c0 test %eax,%eax 10a587: 75 0c jne 10a595 _Thread_Enable_dispatch(); 10a589: e8 08 2a 00 00 call 10cf96 <_Thread_Enable_dispatch> return EAGAIN; 10a58e: b8 0b 00 00 00 mov $0xb,%eax 10a593: eb 31 jmp 10a5c6 } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a595: 50 push %eax 10a596: 50 push %eax 10a597: 8d 45 e0 lea -0x20(%ebp),%eax 10a59a: 50 push %eax 10a59b: 8d 46 10 lea 0x10(%esi),%eax 10a59e: 50 push %eax 10a59f: e8 9c 14 00 00 call 10ba40 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5a4: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5a7: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a5aa: 8b 15 dc 67 12 00 mov 0x1267dc,%edx 10a5b0: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a5b3: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10a5ba: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a5bc: e8 d5 29 00 00 call 10cf96 <_Thread_Enable_dispatch> return 0; 10a5c1: 83 c4 10 add $0x10,%esp 10a5c4: 31 c0 xor %eax,%eax } 10a5c6: 8d 65 f4 lea -0xc(%ebp),%esp 10a5c9: 5b pop %ebx 10a5ca: 5e pop %esi 10a5cb: 5f pop %edi 10a5cc: c9 leave 10a5cd: c3 ret =============================================================================== 00109ecc : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109ecc: 55 push %ebp 109ecd: 89 e5 mov %esp,%ebp 109ecf: 56 push %esi 109ed0: 53 push %ebx 109ed1: 8b 5d 08 mov 0x8(%ebp),%ebx 109ed4: 8b 75 0c mov 0xc(%ebp),%esi /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 109ed7: 85 db test %ebx,%ebx 109ed9: 74 4b je 109f26 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109edb: a1 cc 62 12 00 mov 0x1262cc,%eax 109ee0: 40 inc %eax 109ee1: a3 cc 62 12 00 mov %eax,0x1262cc return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109ee6: 83 ec 0c sub $0xc,%esp 109ee9: 6a 10 push $0x10 109eeb: e8 22 3b 00 00 call 10da12 <_Workspace_Allocate> if ( handler ) { 109ef0: 83 c4 10 add $0x10,%esp 109ef3: 85 c0 test %eax,%eax 109ef5: 74 24 je 109f1b <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109ef7: 8b 15 1c 68 12 00 mov 0x12681c,%edx handler_stack = &thread_support->Cancellation_Handlers; 109efd: 8b 92 f8 00 00 00 mov 0xf8(%edx),%edx 109f03: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f09: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f0c: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f0f: 51 push %ecx 109f10: 51 push %ecx 109f11: 50 push %eax 109f12: 52 push %edx 109f13: e8 7c 15 00 00 call 10b494 <_Chain_Append> 109f18: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f1b: 8d 65 f8 lea -0x8(%ebp),%esp 109f1e: 5b pop %ebx 109f1f: 5e pop %esi 109f20: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f21: e9 6c 2a 00 00 jmp 10c992 <_Thread_Enable_dispatch> } 109f26: 8d 65 f8 lea -0x8(%ebp),%esp 109f29: 5b pop %ebx 109f2a: 5e pop %esi 109f2b: c9 leave 109f2c: c3 ret =============================================================================== 0010ac3c : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac3c: 55 push %ebp 10ac3d: 89 e5 mov %esp,%ebp 10ac3f: 56 push %esi 10ac40: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac41: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac44: 85 db test %ebx,%ebx 10ac46: 75 05 jne 10ac4d else the_attr = &_POSIX_Condition_variables_Default_attributes; 10ac48: bb 28 0c 12 00 mov $0x120c28,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10ac4d: b8 16 00 00 00 mov $0x16,%eax else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10ac52: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10ac56: 74 76 je 10acce <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10ac58: 83 3b 00 cmpl $0x0,(%ebx) 10ac5b: 74 71 je 10acce rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10ac5d: a1 e4 62 12 00 mov 0x1262e4,%eax 10ac62: 40 inc %eax 10ac63: a3 e4 62 12 00 mov %eax,0x1262e4 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10ac68: 83 ec 0c sub $0xc,%esp 10ac6b: 68 48 67 12 00 push $0x126748 10ac70: e8 f3 22 00 00 call 10cf68 <_Objects_Allocate> 10ac75: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ac77: 83 c4 10 add $0x10,%esp 10ac7a: 85 c0 test %eax,%eax 10ac7c: 75 0c jne 10ac8a _Thread_Enable_dispatch(); 10ac7e: e8 f3 2e 00 00 call 10db76 <_Thread_Enable_dispatch> return ENOMEM; 10ac83: b8 0c 00 00 00 mov $0xc,%eax 10ac88: eb 44 jmp 10acce } the_cond->process_shared = the_attr->process_shared; 10ac8a: 8b 43 04 mov 0x4(%ebx),%eax 10ac8d: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ac90: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10ac97: 6a 74 push $0x74 10ac99: 68 00 08 00 10 push $0x10000800 10ac9e: 6a 00 push $0x0 10aca0: 8d 46 18 lea 0x18(%esi),%eax 10aca3: 50 push %eax 10aca4: e8 c3 35 00 00 call 10e26c <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10aca9: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10acac: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10acaf: 8b 15 64 67 12 00 mov 0x126764,%edx 10acb5: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10acb8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10acbf: 8b 55 08 mov 0x8(%ebp),%edx 10acc2: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10acc4: e8 ad 2e 00 00 call 10db76 <_Thread_Enable_dispatch> return 0; 10acc9: 83 c4 10 add $0x10,%esp 10accc: 31 c0 xor %eax,%eax } 10acce: 8d 65 f8 lea -0x8(%ebp),%esp 10acd1: 5b pop %ebx 10acd2: 5e pop %esi 10acd3: c9 leave 10acd4: c3 ret =============================================================================== 0010aaf0 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10aaf0: 55 push %ebp 10aaf1: 89 e5 mov %esp,%ebp 10aaf3: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10aaf6: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10aafb: 85 d2 test %edx,%edx 10aafd: 74 0d je 10ab0c 10aaff: 83 3a 00 cmpl $0x0,(%edx) 10ab02: 74 08 je 10ab0c <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab04: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab0a: 30 c0 xor %al,%al } 10ab0c: c9 leave 10ab0d: c3 ret =============================================================================== 0010a224 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a224: 55 push %ebp 10a225: 89 e5 mov %esp,%ebp 10a227: 57 push %edi 10a228: 56 push %esi 10a229: 53 push %ebx 10a22a: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a22d: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp) int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 10a234: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a238: 0f 84 0f 02 00 00 je 10a44d return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a23e: 8b 5d 0c mov 0xc(%ebp),%ebx 10a241: 85 db test %ebx,%ebx 10a243: 75 05 jne 10a24a 10a245: bb 94 f8 11 00 mov $0x11f894,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a24a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; if ( !the_attr->is_initialized ) 10a251: 83 3b 00 cmpl $0x0,(%ebx) 10a254: 0f 84 f3 01 00 00 je 10a44d * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 10a25a: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a25e: 74 0e je 10a26e 10a260: a1 14 12 12 00 mov 0x121214,%eax 10a265: 39 43 08 cmp %eax,0x8(%ebx) 10a268: 0f 82 df 01 00 00 jb 10a44d * If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 10a26e: 8b 43 10 mov 0x10(%ebx),%eax 10a271: 83 f8 01 cmp $0x1,%eax 10a274: 74 0b je 10a281 10a276: 83 f8 02 cmp $0x2,%eax 10a279: 0f 85 c7 01 00 00 jne 10a446 10a27f: eb 1f jmp 10a2a0 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a281: a1 24 58 12 00 mov 0x125824,%eax 10a286: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi schedpolicy = api->schedpolicy; 10a28c: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a292: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a295: 8d 7d c4 lea -0x3c(%ebp),%edi 10a298: 81 c6 88 00 00 00 add $0x88,%esi 10a29e: eb 0c jmp 10a2ac break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2a0: 8b 43 14 mov 0x14(%ebx),%eax 10a2a3: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2a6: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2a9: 8d 73 18 lea 0x18(%ebx),%esi 10a2ac: b9 07 00 00 00 mov $0x7,%ecx 10a2b1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) return ENOTSUP; 10a2b3: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10a2ba: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a2be: 0f 85 89 01 00 00 jne 10a44d return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2c4: 83 ec 0c sub $0xc,%esp 10a2c7: ff 75 c4 pushl -0x3c(%ebp) 10a2ca: e8 01 58 00 00 call 10fad0 <_POSIX_Priority_Is_valid> 10a2cf: 83 c4 10 add $0x10,%esp return EINVAL; 10a2d2: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2d9: 84 c0 test %al,%al 10a2db: 0f 84 6c 01 00 00 je 10a44d <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a2e1: 8b 45 c4 mov -0x3c(%ebp),%eax 10a2e4: 89 45 a8 mov %eax,-0x58(%ebp) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10a2e7: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a2ee: 8d 45 e0 lea -0x20(%ebp),%eax 10a2f1: 50 push %eax 10a2f2: 8d 45 e4 lea -0x1c(%ebp),%eax 10a2f5: 50 push %eax 10a2f6: 8d 45 c4 lea -0x3c(%ebp),%eax 10a2f9: 50 push %eax 10a2fa: ff 75 ac pushl -0x54(%ebp) 10a2fd: e8 ee 57 00 00 call 10faf0 <_POSIX_Thread_Translate_sched_param> 10a302: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a305: 83 c4 10 add $0x10,%esp 10a308: 85 c0 test %eax,%eax 10a30a: 0f 85 3d 01 00 00 jne 10a44d #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a310: 83 ec 0c sub $0xc,%esp 10a313: ff 35 7c 53 12 00 pushl 0x12537c 10a319: e8 42 15 00 00 call 10b860 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a31e: c7 04 24 20 55 12 00 movl $0x125520,(%esp) 10a325: e8 9e 1e 00 00 call 10c1c8 <_Objects_Allocate> 10a32a: 89 45 b0 mov %eax,-0x50(%ebp) * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10a32d: 83 c4 10 add $0x10,%esp 10a330: 85 c0 test %eax,%eax 10a332: 75 05 jne 10a339 _RTEMS_Unlock_allocator(); 10a334: 83 ec 0c sub $0xc,%esp 10a337: eb 53 jmp 10a38c /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a339: 8b 4d e0 mov -0x20(%ebp),%ecx 10a33c: 8b 75 e4 mov -0x1c(%ebp),%esi 10a33f: 8b 53 08 mov 0x8(%ebx),%edx 10a342: a1 14 12 12 00 mov 0x121214,%eax 10a347: d1 e0 shl %eax 10a349: 39 d0 cmp %edx,%eax 10a34b: 73 02 jae 10a34f 10a34d: 89 d0 mov %edx,%eax 10a34f: 52 push %edx 10a350: 6a 00 push $0x0 10a352: 6a 00 push $0x0 10a354: 51 push %ecx 10a355: 56 push %esi 10a356: 6a 01 push $0x1 10a358: 81 e7 ff 00 00 00 and $0xff,%edi 10a35e: 2b 7d a8 sub -0x58(%ebp),%edi 10a361: 57 push %edi 10a362: 6a 01 push $0x1 10a364: 50 push %eax 10a365: ff 73 04 pushl 0x4(%ebx) 10a368: ff 75 b0 pushl -0x50(%ebp) 10a36b: 68 20 55 12 00 push $0x125520 10a370: e8 f3 2a 00 00 call 10ce68 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a375: 83 c4 30 add $0x30,%esp 10a378: 84 c0 test %al,%al 10a37a: 75 2a jne 10a3a6 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a37c: 56 push %esi 10a37d: 56 push %esi 10a37e: ff 75 b0 pushl -0x50(%ebp) 10a381: 68 20 55 12 00 push $0x125520 10a386: e8 35 21 00 00 call 10c4c0 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a38b: 5b pop %ebx 10a38c: ff 35 7c 53 12 00 pushl 0x12537c 10a392: e8 11 15 00 00 call 10b8a8 <_API_Mutex_Unlock> return EAGAIN; 10a397: 83 c4 10 add $0x10,%esp 10a39a: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3a1: e9 a7 00 00 00 jmp 10a44d } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3a6: 8b 45 b0 mov -0x50(%ebp),%eax 10a3a9: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx api->Attributes = *the_attr; 10a3af: b9 10 00 00 00 mov $0x10,%ecx 10a3b4: 89 d7 mov %edx,%edi 10a3b6: 89 de mov %ebx,%esi 10a3b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a3ba: 8b 43 3c mov 0x3c(%ebx),%eax 10a3bd: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a3c0: 8b 45 ac mov -0x54(%ebp),%eax 10a3c3: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a3c9: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a3cf: 8d 75 c4 lea -0x3c(%ebp),%esi 10a3d2: b1 07 mov $0x7,%cl 10a3d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a3d6: 83 ec 0c sub $0xc,%esp 10a3d9: 6a 00 push $0x0 10a3db: ff 75 14 pushl 0x14(%ebp) 10a3de: ff 75 10 pushl 0x10(%ebp) 10a3e1: 6a 01 push $0x1 10a3e3: ff 75 b0 pushl -0x50(%ebp) 10a3e6: 89 55 a4 mov %edx,-0x5c(%ebp) 10a3e9: e8 02 34 00 00 call 10d7f0 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a3ee: 83 c4 20 add $0x20,%esp 10a3f1: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a3f5: 8b 55 a4 mov -0x5c(%ebp),%edx 10a3f8: 75 2e jne 10a428 _Watchdog_Insert_ticks( 10a3fa: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a3fd: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a403: 50 push %eax 10a404: e8 8f 35 00 00 call 10d998 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a409: 8b 55 a4 mov -0x5c(%ebp),%edx 10a40c: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a412: 58 pop %eax 10a413: 59 pop %ecx 10a414: 81 c2 a8 00 00 00 add $0xa8,%edx 10a41a: 52 push %edx 10a41b: 68 9c 53 12 00 push $0x12539c 10a420: e8 27 38 00 00 call 10dc4c <_Watchdog_Insert> 10a425: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a428: 8b 45 b0 mov -0x50(%ebp),%eax 10a42b: 8b 50 08 mov 0x8(%eax),%edx 10a42e: 8b 45 08 mov 0x8(%ebp),%eax 10a431: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a433: 83 ec 0c sub $0xc,%esp 10a436: ff 35 7c 53 12 00 pushl 0x12537c 10a43c: e8 67 14 00 00 call 10b8a8 <_API_Mutex_Unlock> return 0; 10a441: 83 c4 10 add $0x10,%esp 10a444: eb 07 jmp 10a44d schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a446: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a44d: 8b 45 b4 mov -0x4c(%ebp),%eax 10a450: 8d 65 f4 lea -0xc(%ebp),%esp 10a453: 5b pop %ebx 10a454: 5e pop %esi 10a455: 5f pop %edi 10a456: c9 leave 10a457: c3 ret =============================================================================== 00110cc0 : } void pthread_exit( void *value_ptr ) { 110cc0: 55 push %ebp 110cc1: 89 e5 mov %esp,%ebp 110cc3: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110cc6: ff 75 08 pushl 0x8(%ebp) 110cc9: ff 35 34 48 12 00 pushl 0x124834 110ccf: e8 88 ff ff ff call 110c5c <_POSIX_Thread_Exit> 110cd4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110cd7: c9 leave <== NOT EXECUTED 110cd8: c3 ret <== NOT EXECUTED =============================================================================== 0010bf30 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf30: 55 push %ebp 10bf31: 89 e5 mov %esp,%ebp 10bf33: 53 push %ebx 10bf34: 83 ec 2c sub $0x2c,%esp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10bf37: 8d 45 f4 lea -0xc(%ebp),%eax 10bf3a: 50 push %eax 10bf3b: ff 75 0c pushl 0xc(%ebp) 10bf3e: e8 b9 00 00 00 call 10bffc <_POSIX_Absolute_timeout_to_ticks> 10bf43: 89 c3 mov %eax,%ebx int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex)); int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex)); #if defined(_POSIX_TIMEOUTS) int _EXFUN(pthread_mutex_timedlock, 10bf45: 83 c4 0c add $0xc,%esp 10bf48: 83 f8 03 cmp $0x3,%eax 10bf4b: 0f 94 c2 sete %dl if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10bf4e: ff 75 f4 pushl -0xc(%ebp) 10bf51: 0f b6 c2 movzbl %dl,%eax 10bf54: 50 push %eax 10bf55: ff 75 08 pushl 0x8(%ebp) 10bf58: 88 55 e4 mov %dl,-0x1c(%ebp) 10bf5b: e8 e8 fe ff ff call 10be48 <_POSIX_Mutex_Lock_support> * This service only gives us the option to block. We used a polling * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 10bf60: 83 c4 10 add $0x10,%esp 10bf63: 8a 55 e4 mov -0x1c(%ebp),%dl 10bf66: 84 d2 test %dl,%dl 10bf68: 75 1d jne 10bf87 10bf6a: 83 f8 10 cmp $0x10,%eax 10bf6d: 75 18 jne 10bf87 <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bf6f: 85 db test %ebx,%ebx 10bf71: 74 08 je 10bf7b <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bf73: 4b dec %ebx 10bf74: 83 fb 01 cmp $0x1,%ebx 10bf77: 77 0e ja 10bf87 <== NEVER TAKEN 10bf79: eb 07 jmp 10bf82 * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10bf7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bf80: eb 05 jmp 10bf87 <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bf82: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bf87: 8b 5d fc mov -0x4(%ebp),%ebx 10bf8a: c9 leave 10bf8b: c3 ret =============================================================================== 0010bba8 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bba8: 55 push %ebp 10bba9: 89 e5 mov %esp,%ebp 10bbab: 8b 55 08 mov 0x8(%ebp),%edx 10bbae: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bbb1: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbb6: 85 d2 test %edx,%edx 10bbb8: 74 0f je 10bbc9 10bbba: 83 3a 00 cmpl $0x0,(%edx) 10bbbd: 74 0a je 10bbc9 return EINVAL; switch ( pshared ) { 10bbbf: 83 f9 01 cmp $0x1,%ecx 10bbc2: 77 05 ja 10bbc9 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bbc4: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bbc7: 30 c0 xor %al,%al default: return EINVAL; } } 10bbc9: c9 leave 10bbca: c3 ret =============================================================================== 00109dc0 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109dc0: 55 push %ebp 109dc1: 89 e5 mov %esp,%ebp 109dc3: 8b 55 08 mov 0x8(%ebp),%edx 109dc6: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109dc9: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109dce: 85 d2 test %edx,%edx 109dd0: 74 0f je 109de1 109dd2: 83 3a 00 cmpl $0x0,(%edx) 109dd5: 74 0a je 109de1 <== NEVER TAKEN return EINVAL; switch ( type ) { 109dd7: 83 f9 03 cmp $0x3,%ecx 109dda: 77 05 ja 109de1 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109ddc: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109ddf: 30 c0 xor %al,%al default: return EINVAL; } } 109de1: c9 leave 109de2: c3 ret =============================================================================== 0010a870 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a870: 55 push %ebp 10a871: 89 e5 mov %esp,%ebp 10a873: 56 push %esi 10a874: 53 push %ebx 10a875: 83 ec 10 sub $0x10,%esp 10a878: 8b 5d 08 mov 0x8(%ebp),%ebx 10a87b: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a87e: 85 f6 test %esi,%esi 10a880: 74 51 je 10a8d3 10a882: 85 db test %ebx,%ebx 10a884: 74 4d je 10a8d3 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a886: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a888: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a88c: 75 4a jne 10a8d8 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a88e: 52 push %edx 10a88f: 8d 45 f4 lea -0xc(%ebp),%eax 10a892: 50 push %eax 10a893: 68 00 01 00 00 push $0x100 10a898: 68 00 01 00 00 push $0x100 10a89d: e8 9e 0a 00 00 call 10b340 if ( !once_control->init_executed ) { 10a8a2: 83 c4 10 add $0x10,%esp 10a8a5: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8a9: 75 0f jne 10a8ba <== NEVER TAKEN once_control->is_initialized = true; 10a8ab: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a8b1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a8b8: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a8ba: 50 push %eax 10a8bb: 8d 45 f4 lea -0xc(%ebp),%eax 10a8be: 50 push %eax 10a8bf: 68 00 01 00 00 push $0x100 10a8c4: ff 75 f4 pushl -0xc(%ebp) 10a8c7: e8 74 0a 00 00 call 10b340 10a8cc: 83 c4 10 add $0x10,%esp } return 0; 10a8cf: 31 c0 xor %eax,%eax 10a8d1: eb 05 jmp 10a8d8 pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a8d3: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a8d8: 8d 65 f8 lea -0x8(%ebp),%esp 10a8db: 5b pop %ebx 10a8dc: 5e pop %esi 10a8dd: c9 leave 10a8de: c3 ret =============================================================================== 0010b09c : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b09c: 55 push %ebp 10b09d: 89 e5 mov %esp,%ebp 10b09f: 56 push %esi 10b0a0: 53 push %ebx 10b0a1: 83 ec 10 sub $0x10,%esp 10b0a4: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0a7: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b0ac: 85 db test %ebx,%ebx 10b0ae: 0f 84 8b 00 00 00 je 10b13f return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b0b4: 8b 75 0c mov 0xc(%ebp),%esi 10b0b7: 85 f6 test %esi,%esi 10b0b9: 75 0f jne 10b0ca the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b0bb: 83 ec 0c sub $0xc,%esp 10b0be: 8d 75 ec lea -0x14(%ebp),%esi 10b0c1: 56 push %esi 10b0c2: e8 5d 09 00 00 call 10ba24 10b0c7: 83 c4 10 add $0x10,%esp /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; 10b0ca: b8 16 00 00 00 mov $0x16,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10b0cf: 83 3e 00 cmpl $0x0,(%esi) 10b0d2: 74 6b je 10b13f <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b0d4: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b0d8: 75 65 jne 10b13f <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b0da: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b0e1: a1 f4 82 12 00 mov 0x1282f4,%eax 10b0e6: 40 inc %eax 10b0e7: a3 f4 82 12 00 mov %eax,0x1282f4 * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) _Objects_Allocate( &_POSIX_RWLock_Information ); 10b0ec: 83 ec 0c sub $0xc,%esp 10b0ef: 68 00 85 12 00 push $0x128500 10b0f4: e8 2f 23 00 00 call 10d428 <_Objects_Allocate> 10b0f9: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b0fb: 83 c4 10 add $0x10,%esp 10b0fe: 85 c0 test %eax,%eax 10b100: 75 0c jne 10b10e _Thread_Enable_dispatch(); 10b102: e8 2f 2f 00 00 call 10e036 <_Thread_Enable_dispatch> return EAGAIN; 10b107: b8 0b 00 00 00 mov $0xb,%eax 10b10c: eb 31 jmp 10b13f } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b10e: 50 push %eax 10b10f: 50 push %eax 10b110: 8d 45 f4 lea -0xc(%ebp),%eax 10b113: 50 push %eax 10b114: 8d 46 10 lea 0x10(%esi),%eax 10b117: 50 push %eax 10b118: e8 6f 1b 00 00 call 10cc8c <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b11d: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b120: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b123: 8b 15 1c 85 12 00 mov 0x12851c,%edx 10b129: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10b12c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b133: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b135: e8 fc 2e 00 00 call 10e036 <_Thread_Enable_dispatch> return 0; 10b13a: 83 c4 10 add $0x10,%esp 10b13d: 31 c0 xor %eax,%eax } 10b13f: 8d 65 f8 lea -0x8(%ebp),%esp 10b142: 5b pop %ebx 10b143: 5e pop %esi 10b144: c9 leave 10b145: c3 ret =============================================================================== 0010b1b0 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b1b0: 55 push %ebp 10b1b1: 89 e5 mov %esp,%ebp 10b1b3: 57 push %edi 10b1b4: 56 push %esi 10b1b5: 53 push %ebx 10b1b6: 83 ec 2c sub $0x2c,%esp 10b1b9: 8b 7d 08 mov 0x8(%ebp),%edi Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) return EINVAL; 10b1bc: bb 16 00 00 00 mov $0x16,%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10b1c1: 85 ff test %edi,%edi 10b1c3: 0f 84 87 00 00 00 je 10b250 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b1c9: 50 push %eax 10b1ca: 50 push %eax 10b1cb: 8d 45 e0 lea -0x20(%ebp),%eax 10b1ce: 50 push %eax 10b1cf: ff 75 0c pushl 0xc(%ebp) 10b1d2: e8 39 58 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks> 10b1d7: 89 c6 mov %eax,%esi 10b1d9: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b1dc: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1df: 50 push %eax 10b1e0: ff 37 pushl (%edi) 10b1e2: 68 00 85 12 00 push $0x128500 10b1e7: e8 6c 26 00 00 call 10d858 <_Objects_Get> switch ( location ) { 10b1ec: 83 c4 10 add $0x10,%esp 10b1ef: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b1f3: 75 5b jne 10b250 int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock, 10b1f5: 83 fe 03 cmp $0x3,%esi 10b1f8: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b1fb: 83 ec 0c sub $0xc,%esp 10b1fe: 6a 00 push $0x0 10b200: ff 75 e0 pushl -0x20(%ebp) 10b203: 0f b6 ca movzbl %dl,%ecx 10b206: 51 push %ecx 10b207: ff 37 pushl (%edi) 10b209: 83 c0 10 add $0x10,%eax 10b20c: 50 push %eax 10b20d: 88 55 d4 mov %dl,-0x2c(%ebp) 10b210: e8 ab 1a 00 00 call 10ccc0 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b215: 83 c4 20 add $0x20,%esp 10b218: e8 19 2e 00 00 call 10e036 <_Thread_Enable_dispatch> if ( !do_wait ) { 10b21d: 8a 55 d4 mov -0x2c(%ebp),%dl 10b220: 84 d2 test %dl,%dl 10b222: 75 17 jne 10b23b if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b224: a1 44 88 12 00 mov 0x128844,%eax 10b229: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b22d: 75 0c jne 10b23b if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b22f: 85 f6 test %esi,%esi 10b231: 74 1d je 10b250 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b233: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b234: b3 74 mov $0x74,%bl _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b236: 83 fe 01 cmp $0x1,%esi 10b239: 76 15 jbe 10b250 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b23b: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b23e: a1 44 88 12 00 mov 0x128844,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b243: ff 70 34 pushl 0x34(%eax) 10b246: e8 bd 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b24b: 89 c3 mov %eax,%ebx 10b24d: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b250: 89 d8 mov %ebx,%eax 10b252: 8d 65 f4 lea -0xc(%ebp),%esp 10b255: 5b pop %ebx 10b256: 5e pop %esi 10b257: 5f pop %edi 10b258: c9 leave 10b259: c3 ret =============================================================================== 0010b25c : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b25c: 55 push %ebp 10b25d: 89 e5 mov %esp,%ebp 10b25f: 57 push %edi 10b260: 56 push %esi 10b261: 53 push %ebx 10b262: 83 ec 2c sub $0x2c,%esp 10b265: 8b 7d 08 mov 0x8(%ebp),%edi Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) return EINVAL; 10b268: bb 16 00 00 00 mov $0x16,%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10b26d: 85 ff test %edi,%edi 10b26f: 0f 84 87 00 00 00 je 10b2fc * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b275: 50 push %eax 10b276: 50 push %eax 10b277: 8d 45 e0 lea -0x20(%ebp),%eax 10b27a: 50 push %eax 10b27b: ff 75 0c pushl 0xc(%ebp) 10b27e: e8 8d 57 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks> 10b283: 89 c6 mov %eax,%esi 10b285: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b288: 8d 45 e4 lea -0x1c(%ebp),%eax 10b28b: 50 push %eax 10b28c: ff 37 pushl (%edi) 10b28e: 68 00 85 12 00 push $0x128500 10b293: e8 c0 25 00 00 call 10d858 <_Objects_Get> switch ( location ) { 10b298: 83 c4 10 add $0x10,%esp 10b29b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b29f: 75 5b jne 10b2fc (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime)); int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedwrlock, 10b2a1: 83 fe 03 cmp $0x3,%esi 10b2a4: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2a7: 83 ec 0c sub $0xc,%esp 10b2aa: 6a 00 push $0x0 10b2ac: ff 75 e0 pushl -0x20(%ebp) 10b2af: 0f b6 ca movzbl %dl,%ecx 10b2b2: 51 push %ecx 10b2b3: ff 37 pushl (%edi) 10b2b5: 83 c0 10 add $0x10,%eax 10b2b8: 50 push %eax 10b2b9: 88 55 d4 mov %dl,-0x2c(%ebp) 10b2bc: e8 b7 1a 00 00 call 10cd78 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b2c1: 83 c4 20 add $0x20,%esp 10b2c4: e8 6d 2d 00 00 call 10e036 <_Thread_Enable_dispatch> if ( !do_wait && 10b2c9: 8a 55 d4 mov -0x2c(%ebp),%dl 10b2cc: 84 d2 test %dl,%dl 10b2ce: 75 17 jne 10b2e7 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b2d0: a1 44 88 12 00 mov 0x128844,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b2d5: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b2d9: 75 0c jne 10b2e7 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b2db: 85 f6 test %esi,%esi 10b2dd: 74 1d je 10b2fc <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2df: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b2e0: b3 74 mov $0x74,%bl _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2e2: 83 fe 01 cmp $0x1,%esi 10b2e5: 76 15 jbe 10b2fc <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2e7: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b2ea: a1 44 88 12 00 mov 0x128844,%eax if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2ef: ff 70 34 pushl 0x34(%eax) 10b2f2: e8 11 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2f7: 89 c3 mov %eax,%ebx 10b2f9: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b2fc: 89 d8 mov %ebx,%eax 10b2fe: 8d 65 f4 lea -0xc(%ebp),%esp 10b301: 5b pop %ebx 10b302: 5e pop %esi 10b303: 5f pop %edi 10b304: c9 leave 10b305: c3 ret =============================================================================== 0010ba44 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 8b 55 08 mov 0x8(%ebp),%edx 10ba4a: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10ba4d: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10ba52: 85 d2 test %edx,%edx 10ba54: 74 0f je 10ba65 return EINVAL; if ( !attr->is_initialized ) 10ba56: 83 3a 00 cmpl $0x0,(%edx) 10ba59: 74 0a je 10ba65 return EINVAL; switch ( pshared ) { 10ba5b: 83 f9 01 cmp $0x1,%ecx 10ba5e: 77 05 ja 10ba65 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ba60: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10ba63: 30 c0 xor %al,%al default: return EINVAL; } } 10ba65: c9 leave 10ba66: c3 ret =============================================================================== 0010c754 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c754: 55 push %ebp 10c755: 89 e5 mov %esp,%ebp 10c757: 57 push %edi 10c758: 56 push %esi 10c759: 53 push %ebx 10c75a: 83 ec 2c sub $0x2c,%esp 10c75d: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c760: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c767: 85 f6 test %esi,%esi 10c769: 0f 84 00 01 00 00 je 10c86f return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c76f: 8d 45 e0 lea -0x20(%ebp),%eax 10c772: 50 push %eax 10c773: 8d 45 e4 lea -0x1c(%ebp),%eax 10c776: 50 push %eax 10c777: 56 push %esi 10c778: ff 75 0c pushl 0xc(%ebp) 10c77b: e8 00 52 00 00 call 111980 <_POSIX_Thread_Translate_sched_param> 10c780: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c783: 83 c4 10 add $0x10,%esp 10c786: 85 c0 test %eax,%eax 10c788: 0f 85 e1 00 00 00 jne 10c86f 10c78e: 53 push %ebx return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10c78f: 8d 45 dc lea -0x24(%ebp),%eax 10c792: 50 push %eax 10c793: ff 75 08 pushl 0x8(%ebp) 10c796: 68 80 95 12 00 push $0x129580 10c79b: e8 80 1c 00 00 call 10e420 <_Objects_Get> 10c7a0: 89 c2 mov %eax,%edx switch ( location ) { 10c7a2: 83 c4 10 add $0x10,%esp 10c7a5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c7a9: 0f 85 b9 00 00 00 jne 10c868 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7af: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7b5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7bc: 75 18 jne 10c7d6 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7be: 83 ec 0c sub $0xc,%esp 10c7c1: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c7c7: 50 push %eax 10c7c8: 89 55 d0 mov %edx,-0x30(%ebp) 10c7cb: e8 48 34 00 00 call 10fc18 <_Watchdog_Remove> 10c7d0: 83 c4 10 add $0x10,%esp 10c7d3: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c7d6: 8b 45 0c mov 0xc(%ebp),%eax 10c7d9: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c7df: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c7e5: b9 07 00 00 00 mov $0x7,%ecx 10c7ea: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c7ec: 8b 45 e4 mov -0x1c(%ebp),%eax 10c7ef: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c7f2: 8b 45 e0 mov -0x20(%ebp),%eax 10c7f5: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c7fb: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c7ff: 78 60 js 10c861 <== NEVER TAKEN 10c801: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c805: 7e 08 jle 10c80f 10c807: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c80b: 75 54 jne 10c861 <== NEVER TAKEN 10c80d: eb 24 jmp 10c833 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c80f: a1 04 93 12 00 mov 0x129304,%eax 10c814: 89 42 78 mov %eax,0x78(%edx) 10c817: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax 10c81e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c824: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c827: 51 push %ecx 10c828: 6a 01 push $0x1 10c82a: 50 push %eax 10c82b: 52 push %edx 10c82c: e8 3b 1f 00 00 call 10e76c <_Thread_Change_priority> 10c831: eb 2b jmp 10c85e true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c833: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c839: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c83f: 83 ec 0c sub $0xc,%esp 10c842: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c848: 53 push %ebx 10c849: 89 55 d0 mov %edx,-0x30(%ebp) 10c84c: e8 c7 33 00 00 call 10fc18 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c851: 58 pop %eax 10c852: 5a pop %edx 10c853: 8b 55 d0 mov -0x30(%ebp),%edx 10c856: 52 push %edx 10c857: 6a 00 push $0x0 10c859: e8 e1 fd ff ff call 10c63f <_POSIX_Threads_Sporadic_budget_TSR> break; 10c85e: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c861: e8 98 23 00 00 call 10ebfe <_Thread_Enable_dispatch> return 0; 10c866: eb 07 jmp 10c86f #endif case OBJECTS_ERROR: break; } return ESRCH; 10c868: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c86f: 8b 45 d4 mov -0x2c(%ebp),%eax 10c872: 8d 65 f4 lea -0xc(%ebp),%esp 10c875: 5b pop %ebx 10c876: 5e pop %esi 10c877: 5f pop %edi 10c878: c9 leave 10c879: c3 ret =============================================================================== 0010a640 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a640: 55 push %ebp 10a641: 89 e5 mov %esp,%ebp 10a643: 53 push %ebx 10a644: 83 ec 04 sub $0x4,%esp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a647: 83 3d 18 68 12 00 00 cmpl $0x0,0x126818 10a64e: 75 48 jne 10a698 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a650: a1 1c 68 12 00 mov 0x12681c,%eax 10a655: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax 10a65b: 8b 15 cc 62 12 00 mov 0x1262cc,%edx 10a661: 42 inc %edx 10a662: 89 15 cc 62 12 00 mov %edx,0x1262cc */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a668: 31 db xor %ebx,%ebx return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a66a: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a671: 75 0a jne 10a67d <== NEVER TAKEN /* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate)); int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype)); void _EXFUN(pthread_testcancel, (void)); 10a673: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a67a: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a67d: e8 10 23 00 00 call 10c992 <_Thread_Enable_dispatch> if ( cancel ) 10a682: 84 db test %bl,%bl 10a684: 74 12 je 10a698 _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a686: 50 push %eax 10a687: 50 push %eax 10a688: 6a ff push $0xffffffff 10a68a: ff 35 1c 68 12 00 pushl 0x12681c 10a690: e8 9b 51 00 00 call 10f830 <_POSIX_Thread_Exit> 10a695: 83 c4 10 add $0x10,%esp } 10a698: 8b 5d fc mov -0x4(%ebp),%ebx 10a69b: c9 leave 10a69c: c3 ret =============================================================================== 0010af11 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af11: 55 push %ebp 10af12: 89 e5 mov %esp,%ebp 10af14: 57 push %edi 10af15: 56 push %esi 10af16: 53 push %ebx 10af17: 83 ec 58 sub $0x58,%esp 10af1a: 8b 5d 08 mov 0x8(%ebp),%ebx struct sched_param param; /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); 10af1d: 68 78 72 12 00 push $0x127278 10af22: e8 bd 08 00 00 call 10b7e4 10af27: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af2a: 83 c4 10 add $0x10,%esp 10af2d: 85 c0 test %eax,%eax 10af2f: 74 0e je 10af3f <== ALWAYS TAKEN free (req); 10af31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af34: 53 push %ebx <== NOT EXECUTED 10af35: e8 06 ce ff ff call 107d40 <== NOT EXECUTED 10af3a: e9 bf 01 00 00 jmp 10b0fe <== NOT EXECUTED return result; } /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10af3f: e8 a0 10 00 00 call 10bfe4 10af44: 57 push %edi 10af45: 8d 55 c4 lea -0x3c(%ebp),%edx 10af48: 52 push %edx 10af49: 8d 55 e0 lea -0x20(%ebp),%edx 10af4c: 52 push %edx 10af4d: 50 push %eax 10af4e: e8 95 0c 00 00 call 10bbe8 req->caller_thread = pthread_self (); 10af53: e8 8c 10 00 00 call 10bfe4 10af58: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10af5b: 8b 43 14 mov 0x14(%ebx),%eax 10af5e: 8b 55 c4 mov -0x3c(%ebp),%edx 10af61: 2b 50 14 sub 0x14(%eax),%edx 10af64: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10af67: 8b 55 e0 mov -0x20(%ebp),%edx 10af6a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10af6d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10af74: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10af7b: 83 c4 10 add $0x10,%esp 10af7e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0 10af85: 0f 85 b7 00 00 00 jne 10b042 10af8b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc 10af92: 0f 8f aa 00 00 00 jg 10b042 aio_request_queue.active_threads < AIO_MAX_THREADS) /* we still have empty places on the active_threads chain */ { chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10af98: 56 push %esi 10af99: 6a 01 push $0x1 10af9b: ff 30 pushl (%eax) 10af9d: 68 c0 72 12 00 push $0x1272c0 10afa2: e8 99 fb ff ff call 10ab40 10afa7: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10afa9: 83 c4 10 add $0x10,%esp 10afac: 83 78 18 01 cmpl $0x1,0x18(%eax) 10afb0: 8d 50 08 lea 0x8(%eax),%edx 10afb3: 8d 78 1c lea 0x1c(%eax),%edi 10afb6: 8d 40 20 lea 0x20(%eax),%eax 10afb9: 89 45 b0 mov %eax,-0x50(%ebp) 10afbc: 75 66 jne 10b024 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10afbe: 51 push %ecx 10afbf: 51 push %ecx 10afc0: 53 push %ebx 10afc1: 52 push %edx 10afc2: e8 b5 1f 00 00 call 10cf7c <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10afc7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10afce: 5b pop %ebx 10afcf: 58 pop %eax 10afd0: 6a 00 push $0x0 10afd2: 57 push %edi 10afd3: e8 ec 06 00 00 call 10b6c4 pthread_cond_init (&r_chain->cond, NULL); 10afd8: 5a pop %edx 10afd9: 59 pop %ecx 10afda: 6a 00 push $0x0 10afdc: ff 75 b0 pushl -0x50(%ebp) 10afdf: e8 a0 03 00 00 call 10b384 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10afe4: 56 push %esi 10afe5: 68 eb ab 10 00 push $0x10abeb 10afea: 68 80 72 12 00 push $0x127280 10afef: 8d 45 e4 lea -0x1c(%ebp),%eax 10aff2: 50 push %eax 10aff3: e8 bc 09 00 00 call 10b9b4 10aff8: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10affa: 83 c4 20 add $0x20,%esp 10affd: 85 c0 test %eax,%eax 10afff: 74 18 je 10b019 <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10b001: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b004: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10b009: e8 56 08 00 00 call 10b864 <== NOT EXECUTED return result; 10b00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b011: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b014: e9 e8 00 00 00 jmp 10b101 <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b019: ff 05 dc 72 12 00 incl 0x1272dc 10b01f: e9 cd 00 00 00 jmp 10b0f1 } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b024: 83 ec 0c sub $0xc,%esp 10b027: 57 push %edi 10b028: 89 55 ac mov %edx,-0x54(%ebp) 10b02b: e8 b4 07 00 00 call 10b7e4 rtems_aio_insert_prio (&r_chain->perfd, req); 10b030: 5e pop %esi 10b031: 58 pop %eax 10b032: 53 push %ebx 10b033: 8b 55 ac mov -0x54(%ebp),%edx 10b036: 52 push %edx 10b037: e8 00 fe ff ff call 10ae3c pthread_cond_signal (&r_chain->cond); 10b03c: 5b pop %ebx 10b03d: ff 75 b0 pushl -0x50(%ebp) 10b040: eb 36 jmp 10b078 else { /* the maximum number of threads has been already created even though some of them might be idle. The request belongs to one of the active fd chain */ r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10b042: 51 push %ecx 10b043: 6a 00 push $0x0 10b045: ff 30 pushl (%eax) 10b047: 68 c0 72 12 00 push $0x1272c0 10b04c: e8 ef fa ff ff call 10ab40 10b051: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b053: 83 c4 10 add $0x10,%esp 10b056: 85 c0 test %eax,%eax 10b058: 74 2d je 10b087 <== ALWAYS TAKEN { pthread_mutex_lock (&r_chain->mutex); 10b05a: 8d 78 1c lea 0x1c(%eax),%edi <== NOT EXECUTED 10b05d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b060: 57 push %edi <== NOT EXECUTED 10b061: e8 7e 07 00 00 call 10b7e4 <== NOT EXECUTED rtems_aio_insert_prio (&r_chain->perfd, req); 10b066: 58 pop %eax <== NOT EXECUTED 10b067: 5a pop %edx <== NOT EXECUTED 10b068: 53 push %ebx <== NOT EXECUTED 10b069: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 10b06c: 50 push %eax <== NOT EXECUTED 10b06d: e8 ca fd ff ff call 10ae3c <== NOT EXECUTED pthread_cond_signal (&r_chain->cond); 10b072: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b075: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b078: e8 a3 03 00 00 call 10b420 pthread_mutex_unlock (&r_chain->mutex); 10b07d: 89 3c 24 mov %edi,(%esp) 10b080: e8 df 07 00 00 call 10b864 10b085: eb 67 jmp 10b0ee } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b087: 56 push %esi 10b088: 6a 01 push $0x1 10b08a: 8b 43 14 mov 0x14(%ebx),%eax 10b08d: ff 30 pushl (%eax) 10b08f: 68 cc 72 12 00 push $0x1272cc 10b094: e8 a7 fa ff ff call 10ab40 10b099: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b09b: 83 c4 10 add $0x10,%esp 10b09e: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b0a2: 8d 40 08 lea 0x8(%eax),%eax 10b0a5: 75 3e jne 10b0e5 10b0a7: 51 push %ecx 10b0a8: 51 push %ecx 10b0a9: 53 push %ebx 10b0aa: 50 push %eax 10b0ab: e8 cc 1e 00 00 call 10cf7c <_Chain_Insert> /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10b0b0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b0b7: 58 pop %eax 10b0b8: 5a pop %edx 10b0b9: 6a 00 push $0x0 10b0bb: 8d 46 1c lea 0x1c(%esi),%eax 10b0be: 50 push %eax 10b0bf: e8 00 06 00 00 call 10b6c4 pthread_cond_init (&r_chain->cond, NULL); 10b0c4: 5b pop %ebx 10b0c5: 5f pop %edi 10b0c6: 6a 00 push $0x0 10b0c8: 83 c6 20 add $0x20,%esi 10b0cb: 56 push %esi 10b0cc: e8 b3 02 00 00 call 10b384 pthread_cond_signal (&aio_request_queue.new_req); 10b0d1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp) 10b0d8: e8 43 03 00 00 call 10b420 ++aio_request_queue.idle_threads; 10b0dd: ff 05 e0 72 12 00 incl 0x1272e0 10b0e3: eb 09 jmp 10b0ee } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b0e5: 51 push %ecx 10b0e6: 51 push %ecx 10b0e7: 53 push %ebx 10b0e8: 50 push %eax 10b0e9: e8 4e fd ff ff call 10ae3c 10b0ee: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b0f1: 83 ec 0c sub $0xc,%esp 10b0f4: 68 78 72 12 00 push $0x127278 10b0f9: e8 66 07 00 00 call 10b864 return 0; 10b0fe: 83 c4 10 add $0x10,%esp } 10b101: 8b 45 b4 mov -0x4c(%ebp),%eax 10b104: 8d 65 f4 lea -0xc(%ebp),%esp 10b107: 5b pop %ebx 10b108: 5e pop %esi 10b109: 5f pop %edi 10b10a: c9 leave 10b10b: c3 ret =============================================================================== 0010abeb : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10abeb: 55 push %ebp <== NOT EXECUTED 10abec: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abee: 57 push %edi <== NOT EXECUTED 10abef: 56 push %esi <== NOT EXECUTED 10abf0: 53 push %ebx <== NOT EXECUTED 10abf1: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED rtems_aio_request_chain *r_chain = arg; 10abf4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10abf7: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED 10abfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abfd: 57 push %edi <== NOT EXECUTED 10abfe: e8 e1 0b 00 00 call 10b7e4 <== NOT EXECUTED if (result != 0) 10ac03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac06: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac08: 0f 85 24 02 00 00 jne 10ae32 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 10ac0e: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10ac11: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10ac14: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ac16: 0f 84 cc 00 00 00 je 10ace8 <== NOT EXECUTED node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10ac1c: e8 c3 13 00 00 call 10bfe4 <== NOT EXECUTED 10ac21: 52 push %edx <== NOT EXECUTED 10ac22: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10ac25: 52 push %edx <== NOT EXECUTED 10ac26: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10ac29: 51 push %ecx <== NOT EXECUTED 10ac2a: 50 push %eax <== NOT EXECUTED 10ac2b: e8 b8 0f 00 00 call 10bbe8 <== NOT EXECUTED param.sched_priority = req->priority; 10ac30: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10ac33: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED pthread_setschedparam (pthread_self(), req->policy, ¶m); 10ac36: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10ac39: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED 10ac3c: e8 a3 13 00 00 call 10bfe4 <== NOT EXECUTED 10ac41: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac44: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED 10ac47: 51 push %ecx <== NOT EXECUTED 10ac48: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED 10ac4b: 52 push %edx <== NOT EXECUTED 10ac4c: 50 push %eax <== NOT EXECUTED 10ac4d: e8 a2 13 00 00 call 10bff4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ac52: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ac55: e8 e6 22 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10ac5a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ac5d: e8 02 0c 00 00 call 10b864 <== NOT EXECUTED switch (req->aiocbp->aio_lio_opcode) { 10ac62: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10ac65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac68: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED 10ac6b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10ac6e: 74 20 je 10ac90 <== NOT EXECUTED 10ac70: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10ac73: 74 36 je 10acab <== NOT EXECUTED 10ac75: 4a dec %edx <== NOT EXECUTED 10ac76: 75 45 jne 10acbd <== NOT EXECUTED case LIO_READ: result = pread (req->aiocbp->aio_fildes, 10ac78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac7b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac7e: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac81: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac84: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac87: ff 30 pushl (%eax) <== NOT EXECUTED 10ac89: e8 ea 93 00 00 call 114078 <== NOT EXECUTED 10ac8e: eb 16 jmp 10aca6 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: result = pwrite (req->aiocbp->aio_fildes, 10ac90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac93: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac96: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac99: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac9c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac9f: ff 30 pushl (%eax) <== NOT EXECUTED 10aca1: e8 8a 94 00 00 call 114130 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10aca6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aca9: eb 0d jmp 10acb8 <== NOT EXECUTED case LIO_SYNC: result = fsync (req->aiocbp->aio_fildes); 10acab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acae: ff 30 pushl (%eax) <== NOT EXECUTED 10acb0: e8 27 5c 00 00 call 1108dc <== NOT EXECUTED break; 10acb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10acb8: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10acbb: 75 19 jne 10acd6 <== NOT EXECUTED req->aiocbp->return_value = -1; 10acbd: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10acc0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10acc7: e8 70 89 00 00 call 11363c <__errno> <== NOT EXECUTED 10accc: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10acce: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10acd1: e9 21 ff ff ff jmp 10abf7 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10acd6: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED 10acd9: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED req->aiocbp->error_code = 0; 10acdc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED 10ace3: e9 0f ff ff ff jmp 10abf7 <== NOT EXECUTED wait for a signal on chain, this will unlock the queue. The fd chain is already unlocked */ struct timespec timeout; pthread_mutex_unlock (&r_chain->mutex); 10ace8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aceb: 57 push %edi <== NOT EXECUTED 10acec: e8 73 0b 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_lock (&aio_request_queue.mutex); 10acf1: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10acf8: e8 e7 0a 00 00 call 10b7e4 <== NOT EXECUTED if (rtems_chain_is_empty (chain)) 10acfd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad00: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED 10ad03: 0f 85 ee fe ff ff jne 10abf7 <== NOT EXECUTED { clock_gettime (CLOCK_REALTIME, &timeout); 10ad09: 56 push %esi <== NOT EXECUTED 10ad0a: 56 push %esi <== NOT EXECUTED 10ad0b: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad0e: 50 push %eax <== NOT EXECUTED 10ad0f: 6a 01 push $0x1 <== NOT EXECUTED 10ad11: e8 5e 05 00 00 call 10b274 <== NOT EXECUTED timeout.tv_sec += 3; 10ad16: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad1a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&r_chain->cond, 10ad21: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10ad24: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad27: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10ad2a: 52 push %edx <== NOT EXECUTED 10ad2b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ad30: 56 push %esi <== NOT EXECUTED 10ad31: e8 5a 07 00 00 call 10b490 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad39: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10ad3c: 0f 85 b5 fe ff ff jne 10abf7 <== NOT EXECUTED 10ad42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad45: 53 push %ebx <== NOT EXECUTED 10ad46: e8 f5 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10ad4b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ad4e: e8 71 08 00 00 call 10b5c4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->cond); 10ad53: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ad56: e8 75 05 00 00 call 10b2d0 <== NOT EXECUTED free (r_chain); 10ad5b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ad5e: e8 dd cf ff ff call 107d40 <== NOT EXECUTED /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad66: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10ad6d: 72 12 00 10ad70: 0f 85 a7 00 00 00 jne 10ae1d <== NOT EXECUTED ++aio_request_queue.idle_threads; 10ad76: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED clock_gettime (CLOCK_REALTIME, &timeout); 10ad7c: 53 push %ebx <== NOT EXECUTED 10ad7d: 53 push %ebx <== NOT EXECUTED 10ad7e: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED 10ad81: 51 push %ecx <== NOT EXECUTED 10ad82: 6a 01 push $0x1 <== NOT EXECUTED 10ad84: e8 eb 04 00 00 call 10b274 <== NOT EXECUTED timeout.tv_sec += 3; 10ad89: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad8d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&aio_request_queue.new_req, 10ad94: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad97: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad9a: 50 push %eax <== NOT EXECUTED 10ad9b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ada0: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED 10ada5: e8 e6 06 00 00 call 10b490 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10adaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adad: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10adb0: 75 12 jne 10adc4 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10adb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adb5: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10adba: e8 a5 0a 00 00 call 10b864 <== NOT EXECUTED return NULL; 10adbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adc2: eb 6e jmp 10ae32 <== NOT EXECUTED } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; 10adc4: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10adca: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED 10add0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10add3: 56 push %esi <== NOT EXECUTED 10add4: e8 67 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10add9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10addc: 6a 01 push $0x1 <== NOT EXECUTED 10adde: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10ade1: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10ade6: e8 55 fd ff ff call 10ab40 <== NOT EXECUTED 10adeb: 89 c3 mov %eax,%ebx <== NOT EXECUTED ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; 10aded: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED pthread_mutex_init (&r_chain->mutex, NULL); 10adf4: 5a pop %edx <== NOT EXECUTED 10adf5: 59 pop %ecx <== NOT EXECUTED 10adf6: 6a 00 push $0x0 <== NOT EXECUTED 10adf8: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED 10adfb: 50 push %eax <== NOT EXECUTED 10adfc: e8 c3 08 00 00 call 10b6c4 <== NOT EXECUTED pthread_cond_init (&r_chain->cond, NULL); 10ae01: 5f pop %edi <== NOT EXECUTED 10ae02: 58 pop %eax <== NOT EXECUTED 10ae03: 6a 00 push $0x0 <== NOT EXECUTED 10ae05: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10ae08: 50 push %eax <== NOT EXECUTED 10ae09: e8 76 05 00 00 call 10b384 <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; 10ae0e: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED 10ae11: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10ae14: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10ae19: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10ae1b: eb 0d jmp 10ae2a <== NOT EXECUTED } else /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10ae1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae20: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ae25: e8 3a 0a 00 00 call 10b864 <== NOT EXECUTED 10ae2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae2d: e9 c5 fd ff ff jmp 10abf7 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae32: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae34: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae37: 5b pop %ebx <== NOT EXECUTED 10ae38: 5e pop %esi <== NOT EXECUTED 10ae39: 5f pop %edi <== NOT EXECUTED 10ae3a: c9 leave <== NOT EXECUTED 10ae3b: c3 ret <== NOT EXECUTED =============================================================================== 0010aa44 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aa44: 55 push %ebp 10aa45: 89 e5 mov %esp,%ebp 10aa47: 53 push %ebx 10aa48: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aa4b: 68 80 72 12 00 push $0x127280 10aa50: e8 13 0f 00 00 call 10b968 10aa55: 89 c3 mov %eax,%ebx if (result != 0) 10aa57: 83 c4 10 add $0x10,%esp 10aa5a: 85 c0 test %eax,%eax 10aa5c: 0f 85 d7 00 00 00 jne 10ab39 <== NEVER TAKEN return result; result = 10aa62: 51 push %ecx 10aa63: 51 push %ecx 10aa64: 6a 00 push $0x0 10aa66: 68 80 72 12 00 push $0x127280 10aa6b: e8 20 0f 00 00 call 10b990 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aa70: 83 c4 10 add $0x10,%esp 10aa73: 85 c0 test %eax,%eax 10aa75: 74 10 je 10aa87 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa7a: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aa7f: e8 c4 0e 00 00 call 10b948 <== NOT EXECUTED 10aa84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aa87: 52 push %edx 10aa88: 52 push %edx 10aa89: 6a 00 push $0x0 10aa8b: 68 78 72 12 00 push $0x127278 10aa90: e8 2f 0c 00 00 call 10b6c4 if (result != 0) 10aa95: 83 c4 10 add $0x10,%esp 10aa98: 85 c0 test %eax,%eax 10aa9a: 74 10 je 10aaac <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa9f: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aaa4: e8 9f 0e 00 00 call 10b948 <== NOT EXECUTED 10aaa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10aaac: 50 push %eax 10aaad: 50 push %eax 10aaae: 6a 00 push $0x0 10aab0: 68 7c 72 12 00 push $0x12727c 10aab5: e8 ca 08 00 00 call 10b384 10aaba: 89 c3 mov %eax,%ebx if (result != 0) { 10aabc: 83 c4 10 add $0x10,%esp 10aabf: 85 c0 test %eax,%eax 10aac1: 74 1c je 10aadf <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10aac3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aac6: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10aacb: e8 f4 0a 00 00 call 10b5c4 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10aad0: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED 10aad7: e8 6c 0e 00 00 call 10b948 <== NOT EXECUTED 10aadc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10aadf: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0 10aae6: 72 12 00 the_chain->permanent_null = NULL; 10aae9: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4 10aaf0: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10aaf3: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8 10aafa: 72 12 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10aafd: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc 10ab04: 72 12 00 the_chain->permanent_null = NULL; 10ab07: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0 10ab0e: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10ab11: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4 10ab18: 72 12 00 } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 10ab1b: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc 10ab22: 00 00 00 aio_request_queue.idle_threads = 0; 10ab25: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0 10ab2c: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab2f: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8 10ab36: b0 00 00 return result; } 10ab39: 89 d8 mov %ebx,%eax 10ab3b: 8b 5d fc mov -0x4(%ebp),%ebx 10ab3e: c9 leave 10ab3f: c3 ret =============================================================================== 0010ae3c : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae3c: 55 push %ebp 10ae3d: 89 e5 mov %esp,%ebp 10ae3f: 56 push %esi 10ae40: 53 push %ebx 10ae41: 8b 4d 08 mov 0x8(%ebp),%ecx 10ae44: 8b 55 0c mov 0xc(%ebp),%edx } AIO_printf ("Thread finished\n"); return NULL; } 10ae47: 8b 01 mov (%ecx),%eax 10ae49: 8d 59 04 lea 0x4(%ecx),%ebx rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 10ae4c: 39 d8 cmp %ebx,%eax 10ae4e: 74 27 je 10ae77 <== NEVER TAKEN AIO_printf ("First in chain \n"); rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10ae50: 8b 48 14 mov 0x14(%eax),%ecx 10ae53: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10ae56: 8b 72 14 mov 0x14(%edx),%esi 10ae59: 8b 76 14 mov 0x14(%esi),%esi 10ae5c: eb 08 jmp 10ae66 } AIO_printf ("Thread finished\n"); return NULL; } 10ae5e: 8b 00 mov (%eax),%eax <== NOT EXECUTED int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10ae60: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10ae63: 8b 49 14 mov 0x14(%ecx),%ecx <== NOT EXECUTED rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 10ae66: 39 ce cmp %ecx,%esi 10ae68: 7e 04 jle 10ae6e <== ALWAYS TAKEN 10ae6a: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ae6c: 75 f0 jne 10ae5e <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10ae6e: 89 55 0c mov %edx,0xc(%ebp) 10ae71: 8b 40 04 mov 0x4(%eax),%eax 10ae74: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10ae77: 5b pop %ebx 10ae78: 5e pop %esi 10ae79: c9 leave 10ae7a: e9 fd 20 00 00 jmp 10cf7c <_Chain_Insert> =============================================================================== 0010ae7f : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 10ae7f: 55 push %ebp <== NOT EXECUTED 10ae80: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae82: 56 push %esi <== NOT EXECUTED 10ae83: 53 push %ebx <== NOT EXECUTED 10ae84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae87: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 10ae8a: 8d 70 0c lea 0xc(%eax),%esi <== NOT EXECUTED rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10ae8d: eb 25 jmp 10aeb4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ae8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae92: 53 push %ebx <== NOT EXECUTED 10ae93: e8 a8 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; req->aiocbp->error_code = ECANCELED; 10ae98: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10ae9b: c7 42 30 8c 00 00 00 movl $0x8c,0x30(%edx) <== NOT EXECUTED req->aiocbp->return_value = -1; 10aea2: c7 42 34 ff ff ff ff movl $0xffffffff,0x34(%edx) <== NOT EXECUTED free (req); 10aea9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aeac: e8 8f ce ff ff call 107d40 <== NOT EXECUTED 10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10aeb4: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10aeb6: 75 d7 jne 10ae8f <== NOT EXECUTED rtems_aio_request *req = (rtems_aio_request *) node; req->aiocbp->error_code = ECANCELED; req->aiocbp->return_value = -1; free (req); } } 10aeb8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aebb: 5b pop %ebx <== NOT EXECUTED 10aebc: 5e pop %esi <== NOT EXECUTED 10aebd: c9 leave <== NOT EXECUTED 10aebe: c3 ret <== NOT EXECUTED =============================================================================== 0010aebf : * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { 10aebf: 55 push %ebp <== NOT EXECUTED 10aec0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aec2: 53 push %ebx <== NOT EXECUTED 10aec3: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10aec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aec9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10aecc: 8b 18 mov (%eax),%ebx <== NOT EXECUTED 10aece: 83 c0 04 add $0x4,%eax <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10aed1: eb 02 jmp 10aed5 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10aed3: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10aed5: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10aed7: 74 2e je 10af07 <== NOT EXECUTED 10aed9: 39 53 14 cmp %edx,0x14(%ebx) <== NOT EXECUTED 10aedc: 75 f5 jne 10aed3 <== NOT EXECUTED 10aede: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aee1: 53 push %ebx <== NOT EXECUTED 10aee2: e8 59 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10aee7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10aeea: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) <== NOT EXECUTED current->aiocbp->return_value = -1; 10aef1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) <== NOT EXECUTED free (current); 10aef8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aefb: e8 40 ce ff ff call 107d40 <== NOT EXECUTED } return AIO_CANCELED; 10af00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af03: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af05: eb 05 jmp 10af0c <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10af07: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10af0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af0f: c9 leave <== NOT EXECUTED 10af10: c3 ret <== NOT EXECUTED =============================================================================== 0010aaa8 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10aaa8: 55 push %ebp 10aaa9: 89 e5 mov %esp,%ebp 10aaab: 56 push %esi 10aaac: 53 push %ebx 10aaad: 8b 5d 10 mov 0x10(%ebp),%ebx 10aab0: 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 ); 10aab3: 50 push %eax 10aab4: 50 push %eax 10aab5: ff 75 0c pushl 0xc(%ebp) 10aab8: ff 75 08 pushl 0x8(%ebp) 10aabb: e8 88 04 00 00 call 10af48 <_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 ) { 10aac0: 83 c4 10 add $0x10,%esp 10aac3: 84 c0 test %al,%al 10aac5: 74 11 je 10aad8 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10aac7: 89 75 0c mov %esi,0xc(%ebp) 10aaca: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10aacd: 8d 65 f8 lea -0x8(%ebp),%esp 10aad0: 5b pop %ebx 10aad1: 5e pop %esi 10aad2: 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 ); 10aad3: e9 d4 f6 ff ff jmp 10a1ac } return sc; } 10aad8: 31 c0 xor %eax,%eax 10aada: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aadd: 5b pop %ebx <== NOT EXECUTED 10aade: 5e pop %esi <== NOT EXECUTED 10aadf: c9 leave <== NOT EXECUTED 10aae0: c3 ret <== NOT EXECUTED =============================================================================== 0010ab20 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10ab20: 55 push %ebp 10ab21: 89 e5 mov %esp,%ebp 10ab23: 57 push %edi 10ab24: 56 push %esi 10ab25: 53 push %ebx 10ab26: 83 ec 1c sub $0x1c,%esp 10ab29: 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( 10ab2c: 8d 75 e4 lea -0x1c(%ebp),%esi 10ab2f: eb 13 jmp 10ab44 10ab31: 56 push %esi 10ab32: ff 75 10 pushl 0x10(%ebp) 10ab35: 6a 00 push $0x0 10ab37: 57 push %edi 10ab38: e8 0f f5 ff ff call 10a04c ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10ab3d: 83 c4 10 add $0x10,%esp 10ab40: 85 c0 test %eax,%eax 10ab42: 75 16 jne 10ab5a <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10ab44: 83 ec 0c sub $0xc,%esp 10ab47: ff 75 08 pushl 0x8(%ebp) 10ab4a: e8 99 04 00 00 call 10afe8 <_Chain_Get> 10ab4f: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10ab51: 83 c4 10 add $0x10,%esp 10ab54: 85 c0 test %eax,%eax 10ab56: 74 d9 je 10ab31 10ab58: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10ab5a: 8b 55 14 mov 0x14(%ebp),%edx 10ab5d: 89 1a mov %ebx,(%edx) return sc; } 10ab5f: 8d 65 f4 lea -0xc(%ebp),%esp 10ab62: 5b pop %ebx 10ab63: 5e pop %esi 10ab64: 5f pop %edi 10ab65: c9 leave 10ab66: c3 ret =============================================================================== 0010ab68 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10ab68: 55 push %ebp 10ab69: 89 e5 mov %esp,%ebp 10ab6b: 56 push %esi 10ab6c: 53 push %ebx 10ab6d: 8b 5d 10 mov 0x10(%ebp),%ebx 10ab70: 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 ); 10ab73: 50 push %eax 10ab74: 50 push %eax 10ab75: ff 75 0c pushl 0xc(%ebp) 10ab78: ff 75 08 pushl 0x8(%ebp) 10ab7b: e8 ac 04 00 00 call 10b02c <_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) { 10ab80: 83 c4 10 add $0x10,%esp 10ab83: 84 c0 test %al,%al 10ab85: 74 11 je 10ab98 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ab87: 89 75 0c mov %esi,0xc(%ebp) 10ab8a: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ab8d: 8d 65 f8 lea -0x8(%ebp),%esp 10ab90: 5b pop %ebx 10ab91: 5e pop %esi 10ab92: 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 ); 10ab93: e9 14 f6 ff ff jmp 10a1ac } return sc; } 10ab98: 31 c0 xor %eax,%eax 10ab9a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ab9d: 5b pop %ebx <== NOT EXECUTED 10ab9e: 5e pop %esi <== NOT EXECUTED 10ab9f: c9 leave <== NOT EXECUTED 10aba0: c3 ret <== NOT EXECUTED =============================================================================== 0010b718 : 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 ) { 10b718: 55 push %ebp 10b719: 89 e5 mov %esp,%ebp 10b71b: 57 push %edi 10b71c: 56 push %esi 10b71d: 53 push %ebx 10b71e: 83 ec 0c sub $0xc,%esp 10b721: 8b 5d 08 mov 0x8(%ebp),%ebx 10b724: 8b 75 0c mov 0xc(%ebp),%esi 10b727: 8b 45 10 mov 0x10(%ebp),%eax rtems_device_major_number major_limit = _IO_Number_of_drivers; 10b72a: 8b 15 20 7d 12 00 mov 0x127d20,%edx if ( rtems_interrupt_is_in_progress() ) 10b730: 83 3d e8 78 12 00 00 cmpl $0x0,0x1278e8 10b737: 0f 85 cc 00 00 00 jne 10b809 <== NEVER TAKEN return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10b73d: 85 c0 test %eax,%eax 10b73f: 0f 84 cb 00 00 00 je 10b810 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10b745: 89 10 mov %edx,(%eax) if ( driver_table == NULL ) 10b747: 85 f6 test %esi,%esi 10b749: 0f 84 c1 00 00 00 je 10b810 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b74f: 83 3e 00 cmpl $0x0,(%esi) 10b752: 0f 85 cc 00 00 00 jne 10b824 10b758: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b75c: 0f 85 c2 00 00 00 jne 10b824 10b762: e9 a9 00 00 00 jmp 10b810 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b767: 8b 15 9c 73 12 00 mov 0x12739c,%edx 10b76d: 42 inc %edx 10b76e: 89 15 9c 73 12 00 mov %edx,0x12739c if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10b774: 85 db test %ebx,%ebx 10b776: 75 32 jne 10b7aa static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10b778: 8b 0d 20 7d 12 00 mov 0x127d20,%ecx 10b77e: 8b 15 24 7d 12 00 mov 0x127d24,%edx 10b784: eb 15 jmp 10b79b static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b786: 83 3a 00 cmpl $0x0,(%edx) 10b789: 0f 85 9f 00 00 00 jne 10b82e 10b78f: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b793: 0f 85 95 00 00 00 jne 10b82e 10b799: eb 04 jmp 10b79f 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 ) { 10b79b: 39 cb cmp %ecx,%ebx 10b79d: 72 e7 jb 10b786 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10b79f: 89 18 mov %ebx,(%eax) if ( m != n ) 10b7a1: 39 cb cmp %ecx,%ebx 10b7a3: 75 30 jne 10b7d5 10b7a5: e9 8d 00 00 00 jmp 10b837 _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10b7aa: 6b d3 18 imul $0x18,%ebx,%edx 10b7ad: 03 15 24 7d 12 00 add 0x127d24,%edx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b7b3: 31 c9 xor %ecx,%ecx 10b7b5: 83 3a 00 cmpl $0x0,(%edx) 10b7b8: 75 09 jne 10b7c3 10b7ba: 31 c9 xor %ecx,%ecx 10b7bc: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b7c0: 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 ) ) { 10b7c3: 85 c9 test %ecx,%ecx 10b7c5: 75 0c jne 10b7d3 _Thread_Enable_dispatch(); 10b7c7: e8 2a 18 00 00 call 10cff6 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b7cc: b8 0c 00 00 00 mov $0xc,%eax 10b7d1: eb 49 jmp 10b81c } *registered_major = major; 10b7d3: 89 18 mov %ebx,(%eax) } _IO_Driver_address_table [major] = *driver_table; 10b7d5: 6b c3 18 imul $0x18,%ebx,%eax 10b7d8: 03 05 24 7d 12 00 add 0x127d24,%eax 10b7de: b9 06 00 00 00 mov $0x6,%ecx 10b7e3: 89 c7 mov %eax,%edi 10b7e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10b7e7: e8 0a 18 00 00 call 10cff6 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10b7ec: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10b7f3: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10b7fa: 89 5d 08 mov %ebx,0x8(%ebp) } 10b7fd: 83 c4 0c add $0xc,%esp 10b800: 5b pop %ebx 10b801: 5e pop %esi 10b802: 5f pop %edi 10b803: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10b804: e9 a3 70 00 00 jmp 1128ac ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10b809: b8 12 00 00 00 mov $0x12,%eax 10b80e: eb 0c jmp 10b81c if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10b810: b8 09 00 00 00 mov $0x9,%eax 10b815: eb 05 jmp 10b81c if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10b817: 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 ); } 10b81c: 83 c4 0c add $0xc,%esp 10b81f: 5b pop %ebx 10b820: 5e pop %esi 10b821: 5f pop %edi 10b822: c9 leave 10b823: c3 ret return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10b824: 39 d3 cmp %edx,%ebx 10b826: 0f 82 3b ff ff ff jb 10b767 10b82c: eb e9 jmp 10b817 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 ) { 10b82e: 43 inc %ebx 10b82f: 83 c2 18 add $0x18,%edx 10b832: e9 64 ff ff ff jmp 10b79b if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10b837: e8 ba 17 00 00 call 10cff6 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10b83c: 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; 10b841: eb d9 jmp 10b81c =============================================================================== 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_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10c758: 8b 04 9d e0 00 13 00 mov 0x1300e0(,%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 =============================================================================== 001147e8 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1147e8: 55 push %ebp 1147e9: 89 e5 mov %esp,%ebp 1147eb: 57 push %edi 1147ec: 56 push %esi 1147ed: 53 push %ebx 1147ee: 83 ec 1c sub $0x1c,%esp 1147f1: 8b 75 0c mov 0xc(%ebp),%esi 1147f4: 8b 55 10 mov 0x10(%ebp),%edx 1147f7: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1147fa: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1147ff: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114803: 0f 84 ce 00 00 00 je 1148d7 return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 114809: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 11480b: 85 f6 test %esi,%esi 11480d: 0f 84 c4 00 00 00 je 1148d7 return RTEMS_INVALID_ADDRESS; if ( !id ) 114813: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 114817: 0f 84 ba 00 00 00 je 1148d7 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11481d: 85 ff test %edi,%edi 11481f: 0f 84 ad 00 00 00 je 1148d2 114825: 85 d2 test %edx,%edx 114827: 0f 84 a5 00 00 00 je 1148d2 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 11482d: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11482f: 39 fa cmp %edi,%edx 114831: 0f 82 a0 00 00 00 jb 1148d7 114837: f7 c7 03 00 00 00 test $0x3,%edi 11483d: 0f 85 94 00 00 00 jne 1148d7 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 114843: b0 09 mov $0x9,%al if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 114845: f7 c6 03 00 00 00 test $0x3,%esi 11484b: 0f 85 86 00 00 00 jne 1148d7 114851: a1 b8 d6 13 00 mov 0x13d6b8,%eax 114856: 40 inc %eax 114857: a3 b8 d6 13 00 mov %eax,0x13d6b8 * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 11485c: 83 ec 0c sub $0xc,%esp 11485f: 68 44 d5 13 00 push $0x13d544 114864: 89 55 e4 mov %edx,-0x1c(%ebp) 114867: e8 20 3e 00 00 call 11868c <_Objects_Allocate> 11486c: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 11486e: 83 c4 10 add $0x10,%esp 114871: 85 c0 test %eax,%eax 114873: 8b 55 e4 mov -0x1c(%ebp),%edx 114876: 75 0c jne 114884 _Thread_Enable_dispatch(); 114878: e8 59 4a 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 11487d: b8 05 00 00 00 mov $0x5,%eax 114882: eb 53 jmp 1148d7 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 114884: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 114887: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 11488a: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 11488d: 8b 45 18 mov 0x18(%ebp),%eax 114890: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 114893: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 11489a: 57 push %edi 11489b: 89 d0 mov %edx,%eax 11489d: 31 d2 xor %edx,%edx 11489f: f7 f7 div %edi 1148a1: 50 push %eax 1148a2: 56 push %esi 1148a3: 8d 43 24 lea 0x24(%ebx),%eax 1148a6: 50 push %eax 1148a7: e8 80 2a 00 00 call 11732c <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1148ac: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1148af: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1148b2: 8b 15 60 d5 13 00 mov 0x13d560,%edx 1148b8: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1148bb: 8b 55 08 mov 0x8(%ebp),%edx 1148be: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1148c1: 8b 55 1c mov 0x1c(%ebp),%edx 1148c4: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1148c6: e8 0b 4a 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1148cb: 83 c4 10 add $0x10,%esp 1148ce: 31 c0 xor %eax,%eax 1148d0: eb 05 jmp 1148d7 if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 1148d2: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1148d7: 8d 65 f4 lea -0xc(%ebp),%esp 1148da: 5b pop %ebx 1148db: 5e pop %esi 1148dc: 5f pop %edi 1148dd: c9 leave 1148de: c3 ret =============================================================================== 0010b03d : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b03d: 55 push %ebp 10b03e: 89 e5 mov %esp,%ebp 10b040: 57 push %edi 10b041: 56 push %esi 10b042: 53 push %ebx 10b043: 83 ec 30 sub $0x30,%esp 10b046: 8b 75 08 mov 0x8(%ebp),%esi 10b049: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); 10b04c: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b04f: 50 push %eax 10b050: 56 push %esi 10b051: 68 14 73 12 00 push $0x127314 10b056: e8 3d 1e 00 00 call 10ce98 <_Objects_Get> 10b05b: 89 c7 mov %eax,%edi switch ( location ) { 10b05d: 83 c4 10 add $0x10,%esp 10b060: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b064: 0f 85 3b 01 00 00 jne 10b1a5 <== NEVER TAKEN case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b06a: a1 58 79 12 00 mov 0x127958,%eax 10b06f: 39 47 40 cmp %eax,0x40(%edi) 10b072: 74 0f je 10b083 _Thread_Enable_dispatch(); 10b074: e8 fd 25 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b079: be 17 00 00 00 mov $0x17,%esi 10b07e: e9 27 01 00 00 jmp 10b1aa } if ( length == RTEMS_PERIOD_STATUS ) { 10b083: 85 db test %ebx,%ebx 10b085: 75 1b jne 10b0a2 switch ( the_period->state ) { 10b087: 8b 47 38 mov 0x38(%edi),%eax 10b08a: 31 f6 xor %esi,%esi 10b08c: 83 f8 04 cmp $0x4,%eax 10b08f: 77 07 ja 10b098 <== NEVER TAKEN 10b091: 8b 34 85 00 0d 12 00 mov 0x120d00(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b098: e8 d9 25 00 00 call 10d676 <_Thread_Enable_dispatch> return( return_value ); 10b09d: e9 08 01 00 00 jmp 10b1aa } _ISR_Disable( level ); 10b0a2: 9c pushf 10b0a3: fa cli 10b0a4: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b0a7: 8b 47 38 mov 0x38(%edi),%eax 10b0aa: 85 c0 test %eax,%eax 10b0ac: 75 4c jne 10b0fa _ISR_Enable( level ); 10b0ae: ff 75 d4 pushl -0x2c(%ebp) 10b0b1: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0b2: 83 ec 0c sub $0xc,%esp 10b0b5: 57 push %edi 10b0b6: e8 3f fe ff ff call 10aefa <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b0bb: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b0c2: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b0c9: c7 47 2c b4 b3 10 00 movl $0x10b3b4,0x2c(%edi) the_watchdog->id = id; 10b0d0: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b0d3: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b0da: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b0dd: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b0e0: 58 pop %eax 10b0e1: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b0e2: 83 c7 10 add $0x10,%edi 10b0e5: 57 push %edi 10b0e6: 68 d0 74 12 00 push $0x1274d0 10b0eb: e8 ec 34 00 00 call 10e5dc <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b0f0: e8 81 25 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b0f5: 83 c4 10 add $0x10,%esp 10b0f8: eb 65 jmp 10b15f } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b0fa: 83 f8 02 cmp $0x2,%eax 10b0fd: 75 64 jne 10b163 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b0ff: 83 ec 0c sub $0xc,%esp 10b102: 57 push %edi 10b103: e8 5a fe ff ff call 10af62 <_Rate_monotonic_Update_statistics> /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 10b108: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b10f: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b112: ff 75 d4 pushl -0x2c(%ebp) 10b115: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b116: a1 58 79 12 00 mov 0x127958,%eax 10b11b: 8b 57 08 mov 0x8(%edi),%edx 10b11e: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b121: 5b pop %ebx 10b122: 5e pop %esi 10b123: 68 00 40 00 00 push $0x4000 10b128: 50 push %eax 10b129: e8 42 2d 00 00 call 10de70 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b12e: 9c pushf 10b12f: fa cli 10b130: 5a pop %edx local_state = the_period->state; 10b131: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b134: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b13b: 52 push %edx 10b13c: 9d popf /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 10b13d: 83 c4 10 add $0x10,%esp 10b140: 83 f8 03 cmp $0x3,%eax 10b143: 75 15 jne 10b15a _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b145: 51 push %ecx 10b146: 51 push %ecx 10b147: 68 00 40 00 00 push $0x4000 10b14c: ff 35 58 79 12 00 pushl 0x127958 10b152: e8 ad 21 00 00 call 10d304 <_Thread_Clear_state> 10b157: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b15a: e8 17 25 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b15f: 31 f6 xor %esi,%esi 10b161: eb 47 jmp 10b1aa #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b163: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b168: 83 f8 04 cmp $0x4,%eax 10b16b: 75 3d jne 10b1aa <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b16d: 83 ec 0c sub $0xc,%esp 10b170: 57 push %edi 10b171: e8 ec fd ff ff call 10af62 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b176: ff 75 d4 pushl -0x2c(%ebp) 10b179: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b17a: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b181: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b184: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b187: 58 pop %eax 10b188: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b189: 83 c7 10 add $0x10,%edi 10b18c: 57 push %edi 10b18d: 68 d0 74 12 00 push $0x1274d0 10b192: e8 45 34 00 00 call 10e5dc <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b197: e8 da 24 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b19c: 83 c4 10 add $0x10,%esp 10b19f: 66 be 06 00 mov $0x6,%si 10b1a3: eb 05 jmp 10b1aa #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1a5: be 04 00 00 00 mov $0x4,%esi } 10b1aa: 89 f0 mov %esi,%eax 10b1ac: 8d 65 f4 lea -0xc(%ebp),%esp 10b1af: 5b pop %ebx 10b1b0: 5e pop %esi 10b1b1: 5f pop %edi 10b1b2: c9 leave 10b1b3: c3 ret =============================================================================== 0010b1b4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10b1b4: 55 push %ebp 10b1b5: 89 e5 mov %esp,%ebp 10b1b7: 57 push %edi 10b1b8: 56 push %esi 10b1b9: 53 push %ebx 10b1ba: 83 ec 7c sub $0x7c,%esp 10b1bd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b1c0: 8b 7d 0c mov 0xc(%ebp),%edi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10b1c3: 85 ff test %edi,%edi 10b1c5: 0f 84 2b 01 00 00 je 10b2f6 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b1cb: 52 push %edx 10b1cc: 52 push %edx 10b1cd: 68 14 0d 12 00 push $0x120d14 10b1d2: 53 push %ebx 10b1d3: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b1d5: 5e pop %esi 10b1d6: 58 pop %eax 10b1d7: 68 32 0d 12 00 push $0x120d32 10b1dc: 53 push %ebx 10b1dd: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b1df: 5a pop %edx 10b1e0: 59 pop %ecx 10b1e1: 68 54 0d 12 00 push $0x120d54 10b1e6: 53 push %ebx 10b1e7: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b1e9: 5e pop %esi 10b1ea: 58 pop %eax 10b1eb: 68 77 0d 12 00 push $0x120d77 10b1f0: 53 push %ebx 10b1f1: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b1f3: 5a pop %edx 10b1f4: 59 pop %ecx 10b1f5: 68 c2 0d 12 00 push $0x120dc2 10b1fa: 53 push %ebx 10b1fb: ff d7 call *%edi /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10b1fd: 8b 35 1c 73 12 00 mov 0x12731c,%esi 10b203: 83 c4 10 add $0x10,%esp 10b206: e9 df 00 00 00 jmp 10b2ea id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b20b: 50 push %eax 10b20c: 50 push %eax 10b20d: 8d 45 88 lea -0x78(%ebp),%eax 10b210: 50 push %eax 10b211: 56 push %esi 10b212: e8 39 56 00 00 call 110850 if ( status != RTEMS_SUCCESSFUL ) 10b217: 83 c4 10 add $0x10,%esp 10b21a: 85 c0 test %eax,%eax 10b21c: 0f 85 c7 00 00 00 jne 10b2e9 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 10b222: 51 push %ecx 10b223: 51 push %ecx 10b224: 8d 55 c0 lea -0x40(%ebp),%edx 10b227: 52 push %edx 10b228: 56 push %esi 10b229: e8 c6 56 00 00 call 1108f4 #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b22e: 83 c4 0c add $0xc,%esp 10b231: 8d 45 e3 lea -0x1d(%ebp),%eax 10b234: 50 push %eax 10b235: 6a 05 push $0x5 10b237: ff 75 c0 pushl -0x40(%ebp) 10b23a: e8 01 02 00 00 call 10b440 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b23f: 58 pop %eax 10b240: 5a pop %edx 10b241: ff 75 8c pushl -0x74(%ebp) 10b244: ff 75 88 pushl -0x78(%ebp) 10b247: 8d 55 e3 lea -0x1d(%ebp),%edx 10b24a: 52 push %edx 10b24b: 56 push %esi 10b24c: 68 0e 0e 12 00 push $0x120e0e 10b251: 53 push %ebx 10b252: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b254: 8b 45 88 mov -0x78(%ebp),%eax 10b257: 83 c4 20 add $0x20,%esp 10b25a: 85 c0 test %eax,%eax 10b25c: 75 0f jne 10b26d (*print)( context, "\n" ); 10b25e: 51 push %ecx 10b25f: 51 push %ecx 10b260: 68 88 10 12 00 push $0x121088 10b265: 53 push %ebx 10b266: ff d7 call *%edi continue; 10b268: 83 c4 10 add $0x10,%esp 10b26b: eb 7c jmp 10b2e9 struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 10b26d: 52 push %edx 10b26e: 8d 55 d8 lea -0x28(%ebp),%edx 10b271: 52 push %edx 10b272: 50 push %eax 10b273: 8d 45 a0 lea -0x60(%ebp),%eax 10b276: 50 push %eax 10b277: e8 34 30 00 00 call 10e2b0 <_Timespec_Divide_by_integer> (*print)( context, 10b27c: 8b 45 dc mov -0x24(%ebp),%eax 10b27f: b9 e8 03 00 00 mov $0x3e8,%ecx 10b284: 99 cltd 10b285: f7 f9 idiv %ecx 10b287: 50 push %eax 10b288: ff 75 d8 pushl -0x28(%ebp) 10b28b: 8b 45 9c mov -0x64(%ebp),%eax 10b28e: 99 cltd 10b28f: f7 f9 idiv %ecx 10b291: 50 push %eax 10b292: ff 75 98 pushl -0x68(%ebp) 10b295: 8b 45 94 mov -0x6c(%ebp),%eax 10b298: 99 cltd 10b299: f7 f9 idiv %ecx 10b29b: 50 push %eax 10b29c: ff 75 90 pushl -0x70(%ebp) 10b29f: 68 25 0e 12 00 push $0x120e25 10b2a4: 53 push %ebx 10b2a5: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b2a8: ff d7 call *%edi struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2aa: 83 c4 2c add $0x2c,%esp 10b2ad: 8d 55 d8 lea -0x28(%ebp),%edx 10b2b0: 52 push %edx 10b2b1: ff 75 88 pushl -0x78(%ebp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; 10b2b4: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2b7: 50 push %eax 10b2b8: e8 f3 2f 00 00 call 10e2b0 <_Timespec_Divide_by_integer> (*print)( context, 10b2bd: 8b 45 dc mov -0x24(%ebp),%eax 10b2c0: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b2c3: 99 cltd 10b2c4: f7 f9 idiv %ecx 10b2c6: 50 push %eax 10b2c7: ff 75 d8 pushl -0x28(%ebp) 10b2ca: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2cd: 99 cltd 10b2ce: f7 f9 idiv %ecx 10b2d0: 50 push %eax 10b2d1: ff 75 b0 pushl -0x50(%ebp) 10b2d4: 8b 45 ac mov -0x54(%ebp),%eax 10b2d7: 99 cltd 10b2d8: f7 f9 idiv %ecx 10b2da: 50 push %eax 10b2db: ff 75 a8 pushl -0x58(%ebp) 10b2de: 68 44 0e 12 00 push $0x120e44 10b2e3: 53 push %ebx 10b2e4: ff d7 call *%edi 10b2e6: 83 c4 30 add $0x30,%esp * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10b2e9: 46 inc %esi /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10b2ea: 3b 35 20 73 12 00 cmp 0x127320,%esi 10b2f0: 0f 86 15 ff ff ff jbe 10b20b the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b2f6: 8d 65 f4 lea -0xc(%ebp),%esp 10b2f9: 5b pop %ebx 10b2fa: 5e pop %esi 10b2fb: 5f pop %edi 10b2fc: c9 leave 10b2fd: c3 ret =============================================================================== 00115b48 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115b48: 55 push %ebp 115b49: 89 e5 mov %esp,%ebp 115b4b: 53 push %ebx 115b4c: 83 ec 14 sub $0x14,%esp 115b4f: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115b52: b8 0a 00 00 00 mov $0xa,%eax register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 115b57: 85 db test %ebx,%ebx 115b59: 74 6d je 115bc8 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115b5b: 50 push %eax 115b5c: 50 push %eax 115b5d: 8d 45 f4 lea -0xc(%ebp),%eax 115b60: 50 push %eax 115b61: ff 75 08 pushl 0x8(%ebp) 115b64: e8 8f 37 00 00 call 1192f8 <_Thread_Get> switch ( location ) { 115b69: 83 c4 10 add $0x10,%esp 115b6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115b70: 75 51 jne 115bc3 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115b72: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115b78: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115b7c: 74 39 je 115bb7 if ( asr->is_enabled ) { 115b7e: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115b82: 74 22 je 115ba6 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115b84: 9c pushf 115b85: fa cli 115b86: 59 pop %ecx *signal_set |= signals; 115b87: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115b8a: 51 push %ecx 115b8b: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115b8c: 83 3d 0c dc 13 00 00 cmpl $0x0,0x13dc0c 115b93: 74 19 je 115bae 115b95: 3b 05 10 dc 13 00 cmp 0x13dc10,%eax 115b9b: 75 11 jne 115bae <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115b9d: c6 05 1c dc 13 00 01 movb $0x1,0x13dc1c 115ba4: eb 08 jmp 115bae rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115ba6: 9c pushf 115ba7: fa cli 115ba8: 58 pop %eax *signal_set |= signals; 115ba9: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115bac: 50 push %eax 115bad: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115bae: e8 23 37 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115bb3: 31 c0 xor %eax,%eax 115bb5: eb 11 jmp 115bc8 } _Thread_Enable_dispatch(); 115bb7: e8 1a 37 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115bbc: b8 0b 00 00 00 mov $0xb,%eax 115bc1: eb 05 jmp 115bc8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115bc3: b8 04 00 00 00 mov $0x4,%eax } 115bc8: 8b 5d fc mov -0x4(%ebp),%ebx 115bcb: c9 leave 115bcc: c3 ret =============================================================================== 00110cdc : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110cdc: 55 push %ebp 110cdd: 89 e5 mov %esp,%ebp 110cdf: 57 push %edi 110ce0: 56 push %esi 110ce1: 53 push %ebx 110ce2: 83 ec 1c sub $0x1c,%esp 110ce5: 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; 110ce8: 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 ) 110ced: 85 c9 test %ecx,%ecx 110cef: 0f 84 fb 00 00 00 je 110df0 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110cf5: 8b 35 34 48 12 00 mov 0x124834,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110cfb: 8b 9e f4 00 00 00 mov 0xf4(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110d01: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110d05: 19 ff sbb %edi,%edi 110d07: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110d0d: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110d11: 74 06 je 110d19 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110d13: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110d19: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110d1d: 19 d2 sbb %edx,%edx 110d1f: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110d25: 89 55 e4 mov %edx,-0x1c(%ebp) 110d28: 89 4d e0 mov %ecx,-0x20(%ebp) 110d2b: e8 65 c5 ff ff call 10d295 <_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; 110d30: 8b 55 e4 mov -0x1c(%ebp),%edx 110d33: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110d35: 09 f8 or %edi,%eax 110d37: 8b 4d e0 mov -0x20(%ebp),%ecx 110d3a: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110d3c: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110d43: 74 0b je 110d50 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110d45: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110d4c: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110d50: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110d57: 74 21 je 110d7a if ( _Modes_Is_timeslice(mode_set) ) { 110d59: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110d60: 74 11 je 110d73 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110d62: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110d69: a1 b4 42 12 00 mov 0x1242b4,%eax 110d6e: 89 46 78 mov %eax,0x78(%esi) 110d71: eb 07 jmp 110d7a } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110d73: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110d7a: f6 45 0c 01 testb $0x1,0xc(%ebp) 110d7e: 74 0a je 110d8a */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110d80: f6 45 08 01 testb $0x1,0x8(%ebp) 110d84: 74 03 je 110d89 110d86: fa cli 110d87: eb 01 jmp 110d8a 110d89: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110d8a: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110d8c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110d93: 74 2a je 110dbf * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110d95: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110d9c: 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 ) { 110d9f: 3a 43 08 cmp 0x8(%ebx),%al 110da2: 74 1b je 110dbf asr->is_enabled = is_asr_enabled; 110da4: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110da7: 9c pushf 110da8: fa cli 110da9: 58 pop %eax _signals = information->signals_pending; 110daa: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110dad: 8b 4b 14 mov 0x14(%ebx),%ecx 110db0: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110db3: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110db6: 50 push %eax 110db7: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110db8: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110dbc: 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; 110dbf: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110dc1: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464 110dc8: 75 26 jne 110df0 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110dca: 8b 15 34 48 12 00 mov 0x124834,%edx if ( are_signals_pending || 110dd0: 84 c9 test %cl,%cl 110dd2: 75 0e jne 110de2 110dd4: 3b 15 38 48 12 00 cmp 0x124838,%edx 110dda: 74 14 je 110df0 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110ddc: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110de0: 74 0e je 110df0 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110de2: c6 05 40 48 12 00 01 movb $0x1,0x124840 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110de9: e8 a6 af ff ff call 10bd94 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110dee: 31 c0 xor %eax,%eax } 110df0: 83 c4 1c add $0x1c,%esp 110df3: 5b pop %ebx 110df4: 5e pop %esi 110df5: 5f pop %edi 110df6: c9 leave 110df7: c3 ret =============================================================================== 0010dd34 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd34: 55 push %ebp 10dd35: 89 e5 mov %esp,%ebp 10dd37: 56 push %esi 10dd38: 53 push %ebx 10dd39: 83 ec 10 sub $0x10,%esp 10dd3c: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd3f: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd42: 85 db test %ebx,%ebx 10dd44: 74 10 je 10dd56 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 ) ); 10dd46: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd4d: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd52: 39 d3 cmp %edx,%ebx 10dd54: 77 52 ja 10dda8 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dd56: 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 ) 10dd5b: 85 f6 test %esi,%esi 10dd5d: 74 49 je 10dda8 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10dd5f: 51 push %ecx 10dd60: 51 push %ecx 10dd61: 8d 45 f4 lea -0xc(%ebp),%eax 10dd64: 50 push %eax 10dd65: ff 75 08 pushl 0x8(%ebp) 10dd68: e8 f7 1b 00 00 call 10f964 <_Thread_Get> switch ( location ) { 10dd6d: 83 c4 10 add $0x10,%esp 10dd70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10dd74: 75 2d jne 10dda3 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10dd76: 8b 50 14 mov 0x14(%eax),%edx 10dd79: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10dd7b: 85 db test %ebx,%ebx 10dd7d: 74 1b je 10dd9a the_thread->real_priority = new_priority; 10dd7f: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10dd82: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10dd86: 74 05 je 10dd8d 10dd88: 39 58 14 cmp %ebx,0x14(%eax) 10dd8b: 76 0d jbe 10dd9a <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dd8d: 52 push %edx 10dd8e: 6a 00 push $0x0 10dd90: 53 push %ebx 10dd91: 50 push %eax 10dd92: e8 19 17 00 00 call 10f4b0 <_Thread_Change_priority> 10dd97: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10dd9a: e8 a3 1b 00 00 call 10f942 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10dd9f: 31 c0 xor %eax,%eax 10dda1: eb 05 jmp 10dda8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10dda3: b8 04 00 00 00 mov $0x4,%eax } 10dda8: 8d 65 f8 lea -0x8(%ebp),%esp 10ddab: 5b pop %ebx 10ddac: 5e pop %esi 10ddad: c9 leave 10ddae: c3 ret =============================================================================== 00116394 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 116394: 55 push %ebp 116395: 89 e5 mov %esp,%ebp 116397: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 11639a: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 11639d: 50 push %eax 11639e: ff 75 08 pushl 0x8(%ebp) 1163a1: 68 04 e0 13 00 push $0x13e004 1163a6: e8 4d 27 00 00 call 118af8 <_Objects_Get> switch ( location ) { 1163ab: 83 c4 10 add $0x10,%esp 1163ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1163b2: 75 1e jne 1163d2 case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1163b4: 83 78 38 04 cmpl $0x4,0x38(%eax) 1163b8: 74 0f je 1163c9 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1163ba: 83 ec 0c sub $0xc,%esp 1163bd: 83 c0 10 add $0x10,%eax 1163c0: 50 push %eax 1163c1: e8 4e 41 00 00 call 11a514 <_Watchdog_Remove> 1163c6: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1163c9: e8 08 2f 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1163ce: 31 c0 xor %eax,%eax 1163d0: eb 05 jmp 1163d7 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163d2: b8 04 00 00 00 mov $0x4,%eax } 1163d7: c9 leave 1163d8: c3 ret =============================================================================== 001167f4 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 1167f4: 55 push %ebp 1167f5: 89 e5 mov %esp,%ebp 1167f7: 57 push %edi 1167f8: 56 push %esi 1167f9: 53 push %ebx 1167fa: 83 ec 1c sub $0x1c,%esp 1167fd: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 116800: 8b 35 44 e0 13 00 mov 0x13e044,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 116806: 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 ) 11680b: 85 f6 test %esi,%esi 11680d: 0f 84 b1 00 00 00 je 1168c4 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 116813: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 116815: 80 3d cc d6 13 00 00 cmpb $0x0,0x13d6cc 11681c: 0f 84 a2 00 00 00 je 1168c4 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 116822: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 116824: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116828: 0f 84 96 00 00 00 je 1168c4 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11682e: 83 ec 0c sub $0xc,%esp 116831: 57 push %edi 116832: e8 b5 d6 ff ff call 113eec <_TOD_Validate> 116837: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 11683a: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11683c: 84 c0 test %al,%al 11683e: 0f 84 80 00 00 00 je 1168c4 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 116844: 83 ec 0c sub $0xc,%esp 116847: 57 push %edi 116848: e8 37 d6 ff ff call 113e84 <_TOD_To_seconds> 11684d: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11684f: 83 c4 10 add $0x10,%esp 116852: 3b 05 44 d7 13 00 cmp 0x13d744,%eax 116858: 76 6a jbe 1168c4 11685a: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 11685b: 8d 45 e4 lea -0x1c(%ebp),%eax 11685e: 50 push %eax 11685f: ff 75 08 pushl 0x8(%ebp) 116862: 68 04 e0 13 00 push $0x13e004 116867: e8 8c 22 00 00 call 118af8 <_Objects_Get> 11686c: 89 c3 mov %eax,%ebx switch ( location ) { 11686e: 83 c4 10 add $0x10,%esp 116871: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 116875: 75 48 jne 1168bf case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 116877: 83 ec 0c sub $0xc,%esp 11687a: 8d 40 10 lea 0x10(%eax),%eax 11687d: 50 push %eax 11687e: e8 91 3c 00 00 call 11a514 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 116883: 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; 11688a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 116891: 8b 45 10 mov 0x10(%ebp),%eax 116894: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 116897: 8b 45 08 mov 0x8(%ebp),%eax 11689a: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 11689d: 8b 45 14 mov 0x14(%ebp),%eax 1168a0: 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(); 1168a3: 2b 3d 44 d7 13 00 sub 0x13d744,%edi 1168a9: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1168ac: 58 pop %eax 1168ad: 5a pop %edx 1168ae: 53 push %ebx 1168af: 56 push %esi 1168b0: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1168b3: e8 1e 2a 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1168b8: 83 c4 10 add $0x10,%esp 1168bb: 31 db xor %ebx,%ebx 1168bd: eb 05 jmp 1168c4 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1168bf: bb 04 00 00 00 mov $0x4,%ebx } 1168c4: 89 d8 mov %ebx,%eax 1168c6: 8d 65 f4 lea -0xc(%ebp),%esp 1168c9: 5b pop %ebx 1168ca: 5e pop %esi 1168cb: 5f pop %edi 1168cc: c9 leave 1168cd: c3 ret =============================================================================== 0010a8f0 : #include int sched_get_priority_max( int policy ) { 10a8f0: 55 push %ebp 10a8f1: 89 e5 mov %esp,%ebp 10a8f3: 83 ec 08 sub $0x8,%esp 10a8f6: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a8f9: 83 f9 04 cmp $0x4,%ecx 10a8fc: 77 0b ja 10a909 10a8fe: b8 01 00 00 00 mov $0x1,%eax 10a903: d3 e0 shl %cl,%eax 10a905: a8 17 test $0x17,%al 10a907: 75 10 jne 10a919 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a909: e8 ae 73 00 00 call 111cbc <__errno> 10a90e: c7 00 16 00 00 00 movl $0x16,(%eax) 10a914: 83 c8 ff or $0xffffffff,%eax 10a917: eb 08 jmp 10a921 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a919: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax 10a920: 48 dec %eax } 10a921: c9 leave 10a922: c3 ret =============================================================================== 0010a924 : #include int sched_get_priority_min( int policy ) { 10a924: 55 push %ebp 10a925: 89 e5 mov %esp,%ebp 10a927: 83 ec 08 sub $0x8,%esp 10a92a: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a92d: 83 f9 04 cmp $0x4,%ecx 10a930: 77 11 ja 10a943 10a932: ba 01 00 00 00 mov $0x1,%edx 10a937: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a939: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a93e: 80 e2 17 and $0x17,%dl 10a941: 75 0e jne 10a951 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a943: e8 74 73 00 00 call 111cbc <__errno> 10a948: c7 00 16 00 00 00 movl $0x16,(%eax) 10a94e: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a951: c9 leave 10a952: c3 ret =============================================================================== 0010a954 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a954: 55 push %ebp 10a955: 89 e5 mov %esp,%ebp 10a957: 56 push %esi 10a958: 53 push %ebx 10a959: 8b 75 08 mov 0x8(%ebp),%esi 10a95c: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a95f: 85 f6 test %esi,%esi 10a961: 74 16 je 10a979 <== NEVER TAKEN 10a963: e8 b8 d0 ff ff call 107a20 10a968: 39 c6 cmp %eax,%esi 10a96a: 74 0d je 10a979 rtems_set_errno_and_return_minus_one( ESRCH ); 10a96c: e8 4b 73 00 00 call 111cbc <__errno> 10a971: c7 00 03 00 00 00 movl $0x3,(%eax) 10a977: eb 0f jmp 10a988 if ( !interval ) 10a979: 85 db test %ebx,%ebx 10a97b: 75 10 jne 10a98d rtems_set_errno_and_return_minus_one( EINVAL ); 10a97d: e8 3a 73 00 00 call 111cbc <__errno> 10a982: c7 00 16 00 00 00 movl $0x16,(%eax) 10a988: 83 c8 ff or $0xffffffff,%eax 10a98b: eb 13 jmp 10a9a0 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a98d: 50 push %eax 10a98e: 50 push %eax 10a98f: 53 push %ebx 10a990: ff 35 a4 52 12 00 pushl 0x1252a4 10a996: e8 a1 2f 00 00 call 10d93c <_Timespec_From_ticks> return 0; 10a99b: 83 c4 10 add $0x10,%esp 10a99e: 31 c0 xor %eax,%eax } 10a9a0: 8d 65 f8 lea -0x8(%ebp),%esp 10a9a3: 5b pop %ebx 10a9a4: 5e pop %esi 10a9a5: c9 leave 10a9a6: c3 ret =============================================================================== 0010d040 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d040: 55 push %ebp 10d041: 89 e5 mov %esp,%ebp 10d043: 57 push %edi 10d044: 56 push %esi 10d045: 53 push %ebx 10d046: 83 ec 2c sub $0x2c,%esp 10d049: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d04c: a1 cc a4 12 00 mov 0x12a4cc,%eax 10d051: 40 inc %eax 10d052: a3 cc a4 12 00 mov %eax,0x12a4cc va_list arg; mode_t mode; unsigned int value = 0; 10d057: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d059: 8b 45 0c mov 0xc(%ebp),%eax 10d05c: 25 00 02 00 00 and $0x200,%eax 10d061: 89 45 d4 mov %eax,-0x2c(%ebp) 10d064: 74 03 je 10d069 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d066: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d069: 52 push %edx 10d06a: 52 push %edx 10d06b: 8d 45 e4 lea -0x1c(%ebp),%eax 10d06e: 50 push %eax 10d06f: 56 push %esi 10d070: e8 9b 58 00 00 call 112910 <_POSIX_Semaphore_Name_to_id> 10d075: 89 c3 mov %eax,%ebx * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10d077: 83 c4 10 add $0x10,%esp 10d07a: 85 c0 test %eax,%eax 10d07c: 74 19 je 10d097 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10d07e: 83 f8 02 cmp $0x2,%eax 10d081: 75 06 jne 10d089 <== NEVER TAKEN 10d083: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d087: 75 59 jne 10d0e2 _Thread_Enable_dispatch(); 10d089: e8 68 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d08e: e8 45 7f 00 00 call 114fd8 <__errno> 10d093: 89 18 mov %ebx,(%eax) 10d095: eb 1f jmp 10d0b6 /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d097: 8b 45 0c mov 0xc(%ebp),%eax 10d09a: 25 00 0a 00 00 and $0xa00,%eax 10d09f: 3d 00 0a 00 00 cmp $0xa00,%eax 10d0a4: 75 15 jne 10d0bb _Thread_Enable_dispatch(); 10d0a6: e8 4b 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d0ab: e8 28 7f 00 00 call 114fd8 <__errno> 10d0b0: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0b6: 83 c8 ff or $0xffffffff,%eax 10d0b9: eb 4a jmp 10d105 10d0bb: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d0bc: 8d 45 dc lea -0x24(%ebp),%eax 10d0bf: 50 push %eax 10d0c0: ff 75 e4 pushl -0x1c(%ebp) 10d0c3: 68 98 a7 12 00 push $0x12a798 10d0c8: e8 d7 1c 00 00 call 10eda4 <_Objects_Get> 10d0cd: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d0d0: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d0d3: e8 1e 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d0d8: e8 19 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> goto return_id; 10d0dd: 83 c4 10 add $0x10,%esp 10d0e0: eb 1d jmp 10d0ff /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10d0e2: 8d 45 e0 lea -0x20(%ebp),%eax 10d0e5: 50 push %eax 10d0e6: 57 push %edi 10d0e7: 6a 00 push $0x0 10d0e9: 56 push %esi 10d0ea: e8 ed 56 00 00 call 1127dc <_POSIX_Semaphore_Create_support> 10d0ef: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d0f1: e8 00 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> if ( status == -1 ) 10d0f6: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d0f9: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d0fc: 43 inc %ebx 10d0fd: 74 06 je 10d105 return_id: #if defined(RTEMS_USE_16_BIT_OBJECT) the_semaphore->Semaphore_id = the_semaphore->Object.id; id = &the_semaphore->Semaphore_id; #else id = (sem_t *)&the_semaphore->Object.id; 10d0ff: 8b 45 e0 mov -0x20(%ebp),%eax 10d102: 83 c0 08 add $0x8,%eax #endif return id; } 10d105: 8d 65 f4 lea -0xc(%ebp),%esp 10d108: 5b pop %ebx 10d109: 5e pop %esi 10d10a: 5f pop %edi 10d10b: c9 leave 10d10c: c3 ret =============================================================================== 0010a7cc : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a7cc: 55 push %ebp 10a7cd: 89 e5 mov %esp,%ebp 10a7cf: 57 push %edi 10a7d0: 56 push %esi 10a7d1: 53 push %ebx 10a7d2: 83 ec 1c sub $0x1c,%esp 10a7d5: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7d8: 8b 55 0c mov 0xc(%ebp),%edx 10a7db: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a7de: 85 c0 test %eax,%eax 10a7e0: 74 12 je 10a7f4 *oact = _POSIX_signals_Vectors[ sig ]; 10a7e2: 6b f3 0c imul $0xc,%ebx,%esi 10a7e5: 81 c6 84 68 12 00 add $0x126884,%esi 10a7eb: b9 03 00 00 00 mov $0x3,%ecx 10a7f0: 89 c7 mov %eax,%edi 10a7f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a7f4: 85 db test %ebx,%ebx 10a7f6: 74 0d je 10a805 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a7f8: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a7fb: 83 f8 1f cmp $0x1f,%eax 10a7fe: 77 05 ja 10a805 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a800: 83 fb 09 cmp $0x9,%ebx 10a803: 75 10 jne 10a815 rtems_set_errno_and_return_minus_one( EINVAL ); 10a805: e8 36 77 00 00 call 111f40 <__errno> 10a80a: c7 00 16 00 00 00 movl $0x16,(%eax) 10a810: 83 c8 ff or $0xffffffff,%eax 10a813: eb 57 jmp 10a86c * 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; 10a815: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a817: 85 d2 test %edx,%edx 10a819: 74 51 je 10a86c <== 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 ); 10a81b: 9c pushf 10a81c: fa cli 10a81d: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a820: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a824: 75 1a jne 10a840 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a826: 6b f3 0c imul $0xc,%ebx,%esi 10a829: 8d 86 84 68 12 00 lea 0x126884(%esi),%eax 10a82f: 81 c6 f4 08 12 00 add $0x1208f4,%esi 10a835: b9 03 00 00 00 mov $0x3,%ecx 10a83a: 89 c7 mov %eax,%edi 10a83c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a83e: eb 26 jmp 10a866 } else { _POSIX_signals_Clear_process_signals( sig ); 10a840: 83 ec 0c sub $0xc,%esp 10a843: 53 push %ebx 10a844: 89 55 e0 mov %edx,-0x20(%ebp) 10a847: e8 8c 4d 00 00 call 10f5d8 <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a84c: 6b db 0c imul $0xc,%ebx,%ebx 10a84f: 81 c3 84 68 12 00 add $0x126884,%ebx 10a855: b9 03 00 00 00 mov $0x3,%ecx 10a85a: 8b 55 e0 mov -0x20(%ebp),%edx 10a85d: 89 df mov %ebx,%edi 10a85f: 89 d6 mov %edx,%esi 10a861: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a863: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a866: ff 75 e4 pushl -0x1c(%ebp) 10a869: 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; 10a86a: 31 c0 xor %eax,%eax } 10a86c: 8d 65 f4 lea -0xc(%ebp),%esp 10a86f: 5b pop %ebx 10a870: 5e pop %esi 10a871: 5f pop %edi 10a872: c9 leave 10a873: c3 ret =============================================================================== 0010aba3 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10aba3: 55 push %ebp 10aba4: 89 e5 mov %esp,%ebp 10aba6: 57 push %edi 10aba7: 56 push %esi 10aba8: 53 push %ebx 10aba9: 83 ec 3c sub $0x3c,%esp 10abac: 8b 75 08 mov 0x8(%ebp),%esi 10abaf: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10abb2: 85 f6 test %esi,%esi 10abb4: 74 24 je 10abda /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abb6: 85 db test %ebx,%ebx 10abb8: 74 30 je 10abea if ( !_Timespec_Is_valid( timeout ) ) 10abba: 83 ec 0c sub $0xc,%esp 10abbd: 53 push %ebx 10abbe: e8 45 30 00 00 call 10dc08 <_Timespec_Is_valid> 10abc3: 83 c4 10 add $0x10,%esp 10abc6: 84 c0 test %al,%al 10abc8: 74 10 je 10abda rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10abca: 83 ec 0c sub $0xc,%esp 10abcd: 53 push %ebx 10abce: e8 8d 30 00 00 call 10dc60 <_Timespec_To_ticks> if ( !interval ) 10abd3: 83 c4 10 add $0x10,%esp 10abd6: 85 c0 test %eax,%eax 10abd8: 75 12 jne 10abec <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10abda: e8 19 79 00 00 call 1124f8 <__errno> 10abdf: c7 00 16 00 00 00 movl $0x16,(%eax) 10abe5: e9 39 01 00 00 jmp 10ad23 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10abea: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10abec: 8b 7d 0c mov 0xc(%ebp),%edi 10abef: 85 ff test %edi,%edi 10abf1: 75 03 jne 10abf6 10abf3: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10abf6: 8b 15 74 68 12 00 mov 0x126874,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10abfc: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx 10ac02: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ac05: 9c pushf 10ac06: fa cli 10ac07: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10ac0a: 8b 1e mov (%esi),%ebx 10ac0c: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac0f: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac12: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac18: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac1b: 74 32 je 10ac4f /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac1d: 83 ec 0c sub $0xc,%esp 10ac20: 51 push %ecx 10ac21: e8 3e ff ff ff call 10ab64 <_POSIX_signals_Get_lowest> 10ac26: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac28: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac2f: 6a 00 push $0x0 10ac31: 57 push %edi 10ac32: 50 push %eax 10ac33: 53 push %ebx 10ac34: e8 fb 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac39: ff 75 d0 pushl -0x30(%ebp) 10ac3c: 9d popf the_info->si_code = SI_USER; 10ac3d: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac44: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac4b: 8b 1f mov (%edi),%ebx 10ac4d: eb 3d jmp 10ac8c } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac4f: 8b 0d 78 6a 12 00 mov 0x126a78,%ecx 10ac55: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac58: 74 3a je 10ac94 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac5a: 83 ec 0c sub $0xc,%esp 10ac5d: 51 push %ecx 10ac5e: e8 01 ff ff ff call 10ab64 <_POSIX_signals_Get_lowest> 10ac63: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10ac65: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac6c: 6a 01 push $0x1 10ac6e: 57 push %edi 10ac6f: 50 push %eax 10ac70: ff 75 d4 pushl -0x2c(%ebp) 10ac73: e8 bc 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10ac78: ff 75 d0 pushl -0x30(%ebp) 10ac7b: 9d popf the_info->si_signo = signo; 10ac7c: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10ac7e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac85: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10ac8c: 83 c4 20 add $0x20,%esp 10ac8f: e9 92 00 00 00 jmp 10ad26 } the_info->si_signo = -1; 10ac94: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10ac9a: 8b 0d 24 63 12 00 mov 0x126324,%ecx 10aca0: 41 inc %ecx 10aca1: 89 0d 24 63 12 00 mov %ecx,0x126324 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10aca7: c7 42 44 10 6a 12 00 movl $0x126a10,0x44(%edx) the_thread->Wait.return_code = EINTR; 10acae: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10acb5: 8b 0e mov (%esi),%ecx 10acb7: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acba: 89 7a 28 mov %edi,0x28(%edx) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10acbd: c7 05 40 6a 12 00 01 movl $0x1,0x126a40 10acc4: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10acc7: ff 75 d0 pushl -0x30(%ebp) 10acca: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10accb: 52 push %edx 10accc: 68 00 d8 10 00 push $0x10d800 10acd1: 50 push %eax 10acd2: 68 10 6a 12 00 push $0x126a10 10acd7: e8 4c 28 00 00 call 10d528 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10acdc: e8 c1 23 00 00 call 10d0a2 <_Thread_Enable_dispatch> /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 10ace1: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ace8: 6a 00 push $0x0 10acea: 57 push %edi 10aceb: ff 37 pushl (%edi) 10aced: ff 75 d4 pushl -0x2c(%ebp) 10acf0: e8 3f 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals> /* Set errno only if return code is not EINTR or * if EINTR was caused by a signal being caught, which * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) 10acf5: 83 c4 20 add $0x20,%esp 10acf8: a1 74 68 12 00 mov 0x126874,%eax 10acfd: 83 78 34 04 cmpl $0x4,0x34(%eax) 10ad01: 75 10 jne 10ad13 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10ad03: 8b 1f mov (%edi),%ebx 10ad05: 8d 4b ff lea -0x1(%ebx),%ecx 10ad08: b8 01 00 00 00 mov $0x1,%eax 10ad0d: d3 e0 shl %cl,%eax 10ad0f: 85 06 test %eax,(%esi) 10ad11: 75 13 jne 10ad26 errno = _Thread_Executing->Wait.return_code; 10ad13: e8 e0 77 00 00 call 1124f8 <__errno> 10ad18: 8b 15 74 68 12 00 mov 0x126874,%edx 10ad1e: 8b 52 34 mov 0x34(%edx),%edx 10ad21: 89 10 mov %edx,(%eax) return -1; 10ad23: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad26: 89 d8 mov %ebx,%eax 10ad28: 8d 65 f4 lea -0xc(%ebp),%esp 10ad2b: 5b pop %ebx 10ad2c: 5e pop %esi 10ad2d: 5f pop %edi 10ad2e: c9 leave 10ad2f: c3 ret =============================================================================== 0010ca14 : int sigwait( const sigset_t *set, int *sig ) { 10ca14: 55 push %ebp 10ca15: 89 e5 mov %esp,%ebp 10ca17: 53 push %ebx 10ca18: 83 ec 08 sub $0x8,%esp 10ca1b: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca1e: 6a 00 push $0x0 10ca20: 6a 00 push $0x0 10ca22: ff 75 08 pushl 0x8(%ebp) 10ca25: e8 45 fe ff ff call 10c86f 10ca2a: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca2c: 83 c4 10 add $0x10,%esp 10ca2f: 83 f8 ff cmp $0xffffffff,%eax 10ca32: 74 0a je 10ca3e if ( sig ) *sig = status; return 0; 10ca34: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca36: 85 db test %ebx,%ebx 10ca38: 74 0b je 10ca45 <== NEVER TAKEN *sig = status; 10ca3a: 89 13 mov %edx,(%ebx) 10ca3c: eb 07 jmp 10ca45 return 0; } return errno; 10ca3e: e8 cd 72 00 00 call 113d10 <__errno> 10ca43: 8b 00 mov (%eax),%eax } 10ca45: 8b 5d fc mov -0x4(%ebp),%ebx 10ca48: c9 leave 10ca49: c3 ret =============================================================================== 0010a02c : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a02c: 55 push %ebp 10a02d: 89 e5 mov %esp,%ebp 10a02f: 56 push %esi 10a030: 53 push %ebx 10a031: 8b 5d 0c mov 0xc(%ebp),%ebx 10a034: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a037: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a03b: 75 1d jne 10a05a rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a03d: 85 f6 test %esi,%esi 10a03f: 74 19 je 10a05a /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a041: 85 db test %ebx,%ebx 10a043: 74 22 je 10a067 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a045: 8b 03 mov (%ebx),%eax 10a047: 48 dec %eax 10a048: 83 f8 01 cmp $0x1,%eax 10a04b: 77 0d ja 10a05a <== NEVER TAKEN ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10a04d: 8b 43 04 mov 0x4(%ebx),%eax 10a050: 85 c0 test %eax,%eax 10a052: 74 06 je 10a05a <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a054: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a055: 83 f8 1f cmp $0x1f,%eax 10a058: 76 0d jbe 10a067 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a05a: e8 7d 7c 00 00 call 111cdc <__errno> 10a05f: c7 00 16 00 00 00 movl $0x16,(%eax) 10a065: eb 2f jmp 10a096 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a067: a1 38 63 12 00 mov 0x126338,%eax 10a06c: 40 inc %eax 10a06d: a3 38 63 12 00 mov %eax,0x126338 * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 10a072: 83 ec 0c sub $0xc,%esp 10a075: 68 44 66 12 00 push $0x126644 10a07a: e8 71 1b 00 00 call 10bbf0 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a07f: 83 c4 10 add $0x10,%esp 10a082: 85 c0 test %eax,%eax 10a084: 75 18 jne 10a09e _Thread_Enable_dispatch(); 10a086: e8 73 27 00 00 call 10c7fe <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a08b: e8 4c 7c 00 00 call 111cdc <__errno> 10a090: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a096: 83 c8 ff or $0xffffffff,%eax 10a099: e9 83 00 00 00 jmp 10a121 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a09e: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0a2: 8b 15 88 68 12 00 mov 0x126888,%edx 10a0a8: 8b 52 08 mov 0x8(%edx),%edx 10a0ab: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a0ae: 85 db test %ebx,%ebx 10a0b0: 74 11 je 10a0c3 ptimer->inf.sigev_notify = evp->sigev_notify; 10a0b2: 8b 13 mov (%ebx),%edx 10a0b4: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a0b7: 8b 53 04 mov 0x4(%ebx),%edx 10a0ba: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a0bd: 8b 53 08 mov 0x8(%ebx),%edx 10a0c0: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a0c3: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a0ca: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a0d1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a0d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a0df: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10a0e6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a0ed: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a0f4: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a0fb: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a102: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a105: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a108: 8b 0d 60 66 12 00 mov 0x126660,%ecx 10a10e: 89 04 99 mov %eax,(%ecx,%ebx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a111: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10a118: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a11a: e8 df 26 00 00 call 10c7fe <_Thread_Enable_dispatch> return 0; 10a11f: 31 c0 xor %eax,%eax } 10a121: 8d 65 f8 lea -0x8(%ebp),%esp 10a124: 5b pop %ebx 10a125: 5e pop %esi 10a126: c9 leave 10a127: c3 ret =============================================================================== 0010a128 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a128: 55 push %ebp 10a129: 89 e5 mov %esp,%ebp 10a12b: 57 push %edi 10a12c: 56 push %esi 10a12d: 53 push %ebx 10a12e: 83 ec 2c sub $0x2c,%esp 10a131: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a134: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a138: 0f 84 58 01 00 00 je 10a296 <== NEVER TAKEN /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 10a13e: 83 ec 0c sub $0xc,%esp 10a141: 8b 45 10 mov 0x10(%ebp),%eax 10a144: 83 c0 08 add $0x8,%eax 10a147: 50 push %eax 10a148: e8 3b 32 00 00 call 10d388 <_Timespec_Is_valid> 10a14d: 83 c4 10 add $0x10,%esp 10a150: 84 c0 test %al,%al 10a152: 0f 84 3e 01 00 00 je 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a158: 83 ec 0c sub $0xc,%esp 10a15b: ff 75 10 pushl 0x10(%ebp) 10a15e: e8 25 32 00 00 call 10d388 <_Timespec_Is_valid> 10a163: 83 c4 10 add $0x10,%esp 10a166: 84 c0 test %al,%al 10a168: 0f 84 28 01 00 00 je 10a296 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a16e: 85 db test %ebx,%ebx 10a170: 74 09 je 10a17b 10a172: 83 fb 04 cmp $0x4,%ebx 10a175: 0f 85 1b 01 00 00 jne 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a17b: 8d 7d cc lea -0x34(%ebp),%edi 10a17e: b9 04 00 00 00 mov $0x4,%ecx 10a183: 8b 75 10 mov 0x10(%ebp),%esi 10a186: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a188: 83 fb 04 cmp $0x4,%ebx 10a18b: 75 2f jne 10a1bc struct timespec now; _TOD_Get( &now ); 10a18d: 83 ec 0c sub $0xc,%esp 10a190: 8d 5d dc lea -0x24(%ebp),%ebx 10a193: 53 push %ebx 10a194: e8 a7 15 00 00 call 10b740 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a199: 59 pop %ecx 10a19a: 5e pop %esi 10a19b: 8d 75 d4 lea -0x2c(%ebp),%esi 10a19e: 56 push %esi 10a19f: 53 push %ebx 10a1a0: e8 bf 31 00 00 call 10d364 <_Timespec_Greater_than> 10a1a5: 83 c4 10 add $0x10,%esp 10a1a8: 84 c0 test %al,%al 10a1aa: 0f 85 e6 00 00 00 jne 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a1b0: 52 push %edx 10a1b1: 56 push %esi 10a1b2: 56 push %esi 10a1b3: 53 push %ebx 10a1b4: e8 f3 31 00 00 call 10d3ac <_Timespec_Subtract> 10a1b9: 83 c4 10 add $0x10,%esp timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10a1bc: 50 push %eax /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 10a1bd: 8d 45 e4 lea -0x1c(%ebp),%eax 10a1c0: 50 push %eax 10a1c1: ff 75 08 pushl 0x8(%ebp) 10a1c4: 68 44 66 12 00 push $0x126644 10a1c9: e8 52 1e 00 00 call 10c020 <_Objects_Get> 10a1ce: 89 c3 mov %eax,%ebx switch ( location ) { 10a1d0: 83 c4 10 add $0x10,%esp 10a1d3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a1d7: 0f 85 b9 00 00 00 jne 10a296 case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10a1dd: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a1e1: 75 3b jne 10a21e 10a1e3: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a1e7: 75 35 jne 10a21e /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a1e9: 83 ec 0c sub $0xc,%esp 10a1ec: 8d 40 10 lea 0x10(%eax),%eax 10a1ef: 50 push %eax 10a1f0: e8 7b 35 00 00 call 10d770 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a1f5: 83 c4 10 add $0x10,%esp 10a1f8: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a1fc: 74 0d je 10a20b *ovalue = ptimer->timer_data; 10a1fe: 8d 73 54 lea 0x54(%ebx),%esi 10a201: b9 04 00 00 00 mov $0x4,%ecx 10a206: 8b 7d 14 mov 0x14(%ebp),%edi 10a209: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a20b: 8d 7b 54 lea 0x54(%ebx),%edi 10a20e: 8d 75 cc lea -0x34(%ebp),%esi 10a211: b9 04 00 00 00 mov $0x4,%ecx 10a216: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a218: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a21c: eb 35 jmp 10a253 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a21e: 83 ec 0c sub $0xc,%esp 10a221: ff 75 10 pushl 0x10(%ebp) 10a224: e8 b7 31 00 00 call 10d3e0 <_Timespec_To_ticks> 10a229: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a22c: 8d 45 d4 lea -0x2c(%ebp),%eax 10a22f: 89 04 24 mov %eax,(%esp) 10a232: e8 a9 31 00 00 call 10d3e0 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a237: 89 1c 24 mov %ebx,(%esp) 10a23a: 68 ac a2 10 00 push $0x10a2ac 10a23f: ff 73 08 pushl 0x8(%ebx) 10a242: 50 push %eax 10a243: 8d 43 10 lea 0x10(%ebx),%eax 10a246: 50 push %eax 10a247: e8 64 56 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a24c: 83 c4 20 add $0x20,%esp 10a24f: 84 c0 test %al,%al 10a251: 75 07 jne 10a25a _Thread_Enable_dispatch(); 10a253: e8 a6 25 00 00 call 10c7fe <_Thread_Enable_dispatch> 10a258: eb 38 jmp 10a292 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a25e: 74 0d je 10a26d *ovalue = ptimer->timer_data; 10a260: 8d 73 54 lea 0x54(%ebx),%esi 10a263: b9 04 00 00 00 mov $0x4,%ecx 10a268: 8b 7d 14 mov 0x14(%ebp),%edi 10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a26d: 8d 7b 54 lea 0x54(%ebx),%edi 10a270: 8d 75 cc lea -0x34(%ebp),%esi 10a273: b9 04 00 00 00 mov $0x4,%ecx 10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a27a: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a27e: 83 ec 0c sub $0xc,%esp 10a281: 83 c3 6c add $0x6c,%ebx 10a284: 53 push %ebx 10a285: e8 b6 14 00 00 call 10b740 <_TOD_Get> _Thread_Enable_dispatch(); 10a28a: e8 6f 25 00 00 call 10c7fe <_Thread_Enable_dispatch> return 0; 10a28f: 83 c4 10 add $0x10,%esp 10a292: 31 c0 xor %eax,%eax 10a294: eb 0e jmp 10a2a4 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a296: e8 41 7a 00 00 call 111cdc <__errno> 10a29b: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2a1: 83 c8 ff or $0xffffffff,%eax } 10a2a4: 8d 65 f4 lea -0xc(%ebp),%esp 10a2a7: 5b pop %ebx 10a2a8: 5e pop %esi 10a2a9: 5f pop %edi 10a2aa: c9 leave 10a2ab: c3 ret =============================================================================== 00109f68 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f68: 55 push %ebp 109f69: 89 e5 mov %esp,%ebp 109f6b: 57 push %edi 109f6c: 56 push %esi 109f6d: 53 push %ebx 109f6e: 83 ec 1c sub $0x1c,%esp 109f71: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f74: 83 3d 28 6c 12 00 00 cmpl $0x0,0x126c28 109f7b: 75 2c jne 109fa9 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109f7d: c7 05 14 6c 12 00 00 movl $0x0,0x126c14 109f84: 00 00 00 the_watchdog->routine = routine; 109f87: c7 05 28 6c 12 00 30 movl $0x109f30,0x126c28 109f8e: 9f 10 00 the_watchdog->id = id; 109f91: c7 05 2c 6c 12 00 00 movl $0x0,0x126c2c 109f98: 00 00 00 the_watchdog->user_data = user_data; 109f9b: c7 05 30 6c 12 00 00 movl $0x0,0x126c30 109fa2: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fa5: 31 db xor %ebx,%ebx 109fa7: eb 4f jmp 109ff8 if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 109fa9: 83 ec 0c sub $0xc,%esp 109fac: 68 0c 6c 12 00 push $0x126c0c 109fb1: e8 a2 33 00 00 call 10d358 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fb6: 83 e8 02 sub $0x2,%eax 109fb9: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fbc: 31 db xor %ebx,%ebx _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fbe: 83 f8 01 cmp $0x1,%eax 109fc1: 77 35 ja 109ff8 <== NEVER TAKEN * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109fc3: a1 20 6c 12 00 mov 0x126c20,%eax 109fc8: 03 05 18 6c 12 00 add 0x126c18,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fce: 57 push %edi 109fcf: 57 push %edi 109fd0: 8d 55 e0 lea -0x20(%ebp),%edx 109fd3: 52 push %edx * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109fd4: 2b 05 24 6c 12 00 sub 0x126c24,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fda: 50 push %eax 109fdb: e8 20 2f 00 00 call 10cf00 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 109fe0: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 109fe7: 8b 45 e4 mov -0x1c(%ebp),%eax 109fea: bf e8 03 00 00 mov $0x3e8,%edi 109fef: 99 cltd 109ff0: f7 ff idiv %edi 109ff2: 8d 1c 08 lea (%eax,%ecx,1),%ebx 109ff5: 83 c4 10 add $0x10,%esp /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 109ff8: 85 f6 test %esi,%esi 109ffa: 74 44 je 10a040 <== NEVER TAKEN Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 109ffc: b9 40 42 0f 00 mov $0xf4240,%ecx 10a001: 89 f0 mov %esi,%eax 10a003: 31 d2 xor %edx,%edx 10a005: f7 f1 div %ecx 10a007: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a00a: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a010: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a013: 83 ec 0c sub $0xc,%esp 10a016: 8d 75 e0 lea -0x20(%ebp),%esi 10a019: 56 push %esi 10a01a: e8 3d 2f 00 00 call 10cf5c <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a01f: 89 34 24 mov %esi,(%esp) 10a022: e8 35 2f 00 00 call 10cf5c <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a027: a3 18 6c 12 00 mov %eax,0x126c18 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a02c: 59 pop %ecx 10a02d: 5e pop %esi 10a02e: 68 0c 6c 12 00 push $0x126c0c 10a033: 68 fc 63 12 00 push $0x1263fc 10a038: e8 03 32 00 00 call 10d240 <_Watchdog_Insert> 10a03d: 83 c4 10 add $0x10,%esp } return remaining; } 10a040: 89 d8 mov %ebx,%eax 10a042: 8d 65 f4 lea -0xc(%ebp),%esp 10a045: 5b pop %ebx 10a046: 5e pop %esi 10a047: 5f pop %edi 10a048: c9 leave 10a049: c3 ret