=============================================================================== 0010bea8 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10bea8: 55 push %ebp 10bea9: 89 e5 mov %esp,%ebp 10beab: 53 push %ebx 10beac: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10beaf: 8b 1d d8 77 12 00 mov 0x1277d8,%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10beb5: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10bebb: 74 10 je 10becd <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN 10bebd: 8d 76 00 lea 0x0(%esi),%esi * Currently all APIs configure this hook so it is always non-NULL. */ #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); 10bec0: ff 53 08 call *0x8(%ebx) Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10bec3: 8b 1b mov (%ebx),%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10bec5: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10becb: 75 f3 jne 10bec0 <_API_extensions_Run_postdriver+0x18> #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); } } 10becd: 58 pop %eax 10bece: 5b pop %ebx 10becf: c9 leave 10bed0: c3 ret =============================================================================== 0010bed4 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10bed4: 55 push %ebp 10bed5: 89 e5 mov %esp,%ebp 10bed7: 53 push %ebx 10bed8: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10bedb: 8b 1d d8 77 12 00 mov 0x1277d8,%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10bee1: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10bee7: 74 1c je 10bf05 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN 10bee9: 8d 76 00 lea 0x0(%esi),%esi !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); 10beec: 83 ec 0c sub $0xc,%esp 10beef: ff 35 58 7b 12 00 pushl 0x127b58 10bef5: ff 53 0c call *0xc(%ebx) Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10bef8: 8b 1b mov (%ebx),%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10befa: 83 c4 10 add $0x10,%esp 10befd: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx 10bf03: 75 e7 jne 10beec <_API_extensions_Run_postswitch+0x18> the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10bf05: 8b 5d fc mov -0x4(%ebp),%ebx 10bf08: c9 leave 10bf09: c3 ret =============================================================================== 0010e3e4 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10e3e4: 55 push %ebp 10e3e5: 89 e5 mov %esp,%ebp 10e3e7: 57 push %edi 10e3e8: 56 push %esi 10e3e9: 53 push %ebx 10e3ea: 83 ec 1c sub $0x1c,%esp 10e3ed: 8b 5d 08 mov 0x8(%ebp),%ebx 10e3f0: 8b 7d 0c mov 0xc(%ebp),%edi 10e3f3: 8b 4d 14 mov 0x14(%ebp),%ecx 10e3f6: 8a 55 10 mov 0x10(%ebp),%dl ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e3f9: 8b 35 d8 b4 12 00 mov 0x12b4d8,%esi * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10e3ff: 9c pushf 10e400: fa cli 10e401: 8f 45 e4 popl -0x1c(%ebp) switch ( the_rwlock->current_state ) { 10e404: 8b 43 44 mov 0x44(%ebx),%eax 10e407: 85 c0 test %eax,%eax 10e409: 75 1d jne 10e428 <_CORE_RWLock_Obtain_for_reading+0x44> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10e40b: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) the_rwlock->number_of_readers += 1; 10e412: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10e415: ff 75 e4 pushl -0x1c(%ebp) 10e418: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e419: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e420: 8d 65 f4 lea -0xc(%ebp),%esp 10e423: 5b pop %ebx 10e424: 5e pop %esi 10e425: 5f pop %edi 10e426: c9 leave 10e427: c3 ret * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { 10e428: 48 dec %eax 10e429: 74 51 je 10e47c <_CORE_RWLock_Obtain_for_reading+0x98> /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10e42b: 84 d2 test %dl,%dl 10e42d: 75 15 jne 10e444 <_CORE_RWLock_Obtain_for_reading+0x60> _ISR_Enable( level ); 10e42f: ff 75 e4 pushl -0x1c(%ebp) 10e432: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e433: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e43a: 8d 65 f4 lea -0xc(%ebp),%esp 10e43d: 5b pop %ebx 10e43e: 5e pop %esi 10e43f: 5f pop %edi 10e440: c9 leave 10e441: c3 ret 10e442: 66 90 xchg %ax,%ax 10e444: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10e44b: 89 5e 44 mov %ebx,0x44(%esi) executing->Wait.id = id; 10e44e: 89 7e 20 mov %edi,0x20(%esi) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10e451: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e458: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) _ISR_Enable( level ); 10e45f: ff 75 e4 pushl -0x1c(%ebp) 10e462: 9d popf _Thread_queue_Enqueue_with_handler( 10e463: c7 45 10 e8 e5 10 00 movl $0x10e5e8,0x10(%ebp) 10e46a: 89 4d 0c mov %ecx,0xc(%ebp) 10e46d: 89 5d 08 mov %ebx,0x8(%ebp) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e470: 8d 65 f4 lea -0xc(%ebp),%esp 10e473: 5b pop %ebx 10e474: 5e pop %esi 10e475: 5f pop %edi 10e476: c9 leave executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10e477: e9 94 1b 00 00 jmp 110010 <_Thread_queue_Enqueue_with_handler> executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 10e47c: 83 ec 0c sub $0xc,%esp 10e47f: 53 push %ebx 10e480: 88 55 e0 mov %dl,-0x20(%ebp) 10e483: 89 4d dc mov %ecx,-0x24(%ebp) 10e486: e8 ad 1e 00 00 call 110338 <_Thread_queue_First> if ( !waiter ) { 10e48b: 83 c4 10 add $0x10,%esp 10e48e: 85 c0 test %eax,%eax 10e490: 8a 55 e0 mov -0x20(%ebp),%dl 10e493: 8b 4d dc mov -0x24(%ebp),%ecx 10e496: 75 93 jne 10e42b <_CORE_RWLock_Obtain_for_reading+0x47> the_rwlock->number_of_readers += 1; 10e498: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10e49b: ff 75 e4 pushl -0x1c(%ebp) 10e49e: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e49f: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) return; 10e4a6: e9 75 ff ff ff jmp 10e420 <_CORE_RWLock_Obtain_for_reading+0x3c> =============================================================================== 0010e4ac <_CORE_RWLock_Obtain_for_writing>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10e4ac: 55 push %ebp 10e4ad: 89 e5 mov %esp,%ebp 10e4af: 57 push %edi 10e4b0: 56 push %esi 10e4b1: 53 push %ebx 10e4b2: 83 ec 0c sub $0xc,%esp 10e4b5: 8b 45 08 mov 0x8(%ebp),%eax 10e4b8: 8b 7d 0c mov 0xc(%ebp),%edi 10e4bb: 8b 75 14 mov 0x14(%ebp),%esi 10e4be: 8a 5d 10 mov 0x10(%ebp),%bl ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e4c1: 8b 15 d8 b4 12 00 mov 0x12b4d8,%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 ); 10e4c7: 9c pushf 10e4c8: fa cli 10e4c9: 59 pop %ecx switch ( the_rwlock->current_state ) { 10e4ca: 83 78 44 00 cmpl $0x0,0x44(%eax) 10e4ce: 75 18 jne 10e4e8 <_CORE_RWLock_Obtain_for_writing+0x3c> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10e4d0: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax) _ISR_Enable( level ); 10e4d7: 51 push %ecx 10e4d8: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e4d9: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e4e0: 83 c4 0c add $0xc,%esp 10e4e3: 5b pop %ebx 10e4e4: 5e pop %esi 10e4e5: 5f pop %edi 10e4e6: c9 leave 10e4e7: c3 ret /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10e4e8: 84 db test %bl,%bl 10e4ea: 75 14 jne 10e500 <_CORE_RWLock_Obtain_for_writing+0x54> _ISR_Enable( level ); 10e4ec: 51 push %ecx 10e4ed: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e4ee: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e4f5: 83 c4 0c add $0xc,%esp 10e4f8: 5b pop %ebx 10e4f9: 5e pop %esi 10e4fa: 5f pop %edi 10e4fb: c9 leave 10e4fc: c3 ret 10e4fd: 8d 76 00 lea 0x0(%esi),%esi 10e500: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10e507: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 10e50a: 89 7a 20 mov %edi,0x20(%edx) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 10e50d: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e514: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Enable( level ); 10e51b: 51 push %ecx 10e51c: 9d popf _Thread_queue_Enqueue_with_handler( 10e51d: c7 45 10 e8 e5 10 00 movl $0x10e5e8,0x10(%ebp) 10e524: 89 75 0c mov %esi,0xc(%ebp) 10e527: 89 45 08 mov %eax,0x8(%ebp) _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10e52a: 83 c4 0c add $0xc,%esp 10e52d: 5b pop %ebx 10e52e: 5e pop %esi 10e52f: 5f pop %edi 10e530: c9 leave executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10e531: e9 da 1a 00 00 jmp 110010 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010e538 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10e538: 55 push %ebp 10e539: 89 e5 mov %esp,%ebp 10e53b: 53 push %ebx 10e53c: 83 ec 04 sub $0x4,%esp 10e53f: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10e542: 8b 0d d8 b4 12 00 mov 0x12b4d8,%ecx * 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 ); 10e548: 9c pushf 10e549: fa cli 10e54a: 5a pop %edx if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10e54b: 8b 43 44 mov 0x44(%ebx),%eax 10e54e: 85 c0 test %eax,%eax 10e550: 74 7a je 10e5cc <_CORE_RWLock_Release+0x94> _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10e552: 48 dec %eax 10e553: 74 63 je 10e5b8 <_CORE_RWLock_Release+0x80> return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10e555: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10e55c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10e563: 52 push %edx 10e564: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10e565: 83 ec 0c sub $0xc,%esp 10e568: 53 push %ebx 10e569: e8 7a 19 00 00 call 10fee8 <_Thread_queue_Dequeue> if ( next ) { 10e56e: 83 c4 10 add $0x10,%esp 10e571: 85 c0 test %eax,%eax 10e573: 74 39 je 10e5ae <_CORE_RWLock_Release+0x76> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10e575: 83 78 30 01 cmpl $0x1,0x30(%eax) 10e579: 74 61 je 10e5dc <_CORE_RWLock_Release+0xa4> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10e57b: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10e57e: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) 10e585: eb 17 jmp 10e59e <_CORE_RWLock_Release+0x66> 10e587: 90 nop /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 10e588: 83 78 30 01 cmpl $0x1,0x30(%eax) 10e58c: 74 20 je 10e5ae <_CORE_RWLock_Release+0x76><== NEVER TAKEN next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10e58e: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10e591: 83 ec 08 sub $0x8,%esp 10e594: 50 push %eax 10e595: 53 push %ebx 10e596: e8 85 1c 00 00 call 110220 <_Thread_queue_Extract> } 10e59b: 83 c4 10 add $0x10,%esp /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10e59e: 83 ec 0c sub $0xc,%esp 10e5a1: 53 push %ebx 10e5a2: e8 91 1d 00 00 call 110338 <_Thread_queue_First> if ( !next || 10e5a7: 83 c4 10 add $0x10,%esp 10e5aa: 85 c0 test %eax,%eax 10e5ac: 75 da jne 10e588 <_CORE_RWLock_Release+0x50> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5ae: 31 c0 xor %eax,%eax 10e5b0: 8b 5d fc mov -0x4(%ebp),%ebx 10e5b3: c9 leave 10e5b4: c3 ret 10e5b5: 8d 76 00 lea 0x0(%esi),%esi _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { the_rwlock->number_of_readers -= 1; 10e5b8: 8b 43 48 mov 0x48(%ebx),%eax 10e5bb: 48 dec %eax 10e5bc: 89 43 48 mov %eax,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10e5bf: 85 c0 test %eax,%eax 10e5c1: 74 92 je 10e555 <_CORE_RWLock_Release+0x1d> /* must be unlocked again */ _ISR_Enable( level ); 10e5c3: 52 push %edx 10e5c4: 9d popf } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5c5: 31 c0 xor %eax,%eax 10e5c7: 8b 5d fc mov -0x4(%ebp),%ebx 10e5ca: c9 leave 10e5cb: c3 ret * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 10e5cc: 52 push %edx 10e5cd: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10e5ce: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10e5d5: 31 c0 xor %eax,%eax 10e5d7: 8b 5d fc mov -0x4(%ebp),%ebx 10e5da: c9 leave 10e5db: c3 ret next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); if ( next ) { if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10e5dc: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10e5e3: eb c9 jmp 10e5ae <_CORE_RWLock_Release+0x76> =============================================================================== 0010e5e8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10e5e8: 55 push %ebp 10e5e9: 89 e5 mov %esp,%ebp 10e5eb: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e5ee: 8d 45 f4 lea -0xc(%ebp),%eax 10e5f1: 50 push %eax 10e5f2: ff 75 08 pushl 0x8(%ebp) 10e5f5: e8 5e 15 00 00 call 10fb58 <_Thread_Get> switch ( location ) { 10e5fa: 83 c4 10 add $0x10,%esp 10e5fd: 8b 55 f4 mov -0xc(%ebp),%edx 10e600: 85 d2 test %edx,%edx 10e602: 75 17 jne 10e61b <_CORE_RWLock_Timeout+0x33><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10e604: 83 ec 0c sub $0xc,%esp 10e607: 50 push %eax 10e608: e8 0b 1e 00 00 call 110418 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e60d: a1 f0 ae 12 00 mov 0x12aef0,%eax 10e612: 48 dec %eax 10e613: a3 f0 ae 12 00 mov %eax,0x12aef0 10e618: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10e61b: c9 leave 10e61c: c3 ret =============================================================================== 001198e0 <_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 ) { 1198e0: 55 push %ebp 1198e1: 89 e5 mov %esp,%ebp 1198e3: 57 push %edi 1198e4: 56 push %esi 1198e5: 53 push %ebx 1198e6: 83 ec 1c sub $0x1c,%esp 1198e9: 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 ) { 1198ec: 8b 45 10 mov 0x10(%ebp),%eax 1198ef: 39 43 4c cmp %eax,0x4c(%ebx) 1198f2: 72 60 jb 119954 <_CORE_message_queue_Broadcast+0x74><== 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 ) { 1198f4: 8b 43 48 mov 0x48(%ebx),%eax 1198f7: 85 c0 test %eax,%eax 1198f9: 75 45 jne 119940 <_CORE_message_queue_Broadcast+0x60> 1198fb: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 119902: eb 18 jmp 11991c <_CORE_message_queue_Broadcast+0x3c> */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 119904: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 119907: 8b 42 2c mov 0x2c(%edx),%eax 11990a: 89 c7 mov %eax,%edi 11990c: 8b 75 0c mov 0xc(%ebp),%esi 11990f: 8b 4d 10 mov 0x10(%ebp),%ecx 119912: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 119914: 8b 42 28 mov 0x28(%edx),%eax 119917: 8b 55 10 mov 0x10(%ebp),%edx 11991a: 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 = 11991c: 83 ec 0c sub $0xc,%esp 11991f: 53 push %ebx 119920: e8 27 28 00 00 call 11c14c <_Thread_queue_Dequeue> 119925: 89 c2 mov %eax,%edx 119927: 83 c4 10 add $0x10,%esp 11992a: 85 c0 test %eax,%eax 11992c: 75 d6 jne 119904 <_CORE_message_queue_Broadcast+0x24> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 11992e: 8b 55 e4 mov -0x1c(%ebp),%edx 119931: 8b 45 1c mov 0x1c(%ebp),%eax 119934: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 119936: 31 c0 xor %eax,%eax } 119938: 8d 65 f4 lea -0xc(%ebp),%esp 11993b: 5b pop %ebx 11993c: 5e pop %esi 11993d: 5f pop %edi 11993e: c9 leave 11993f: c3 ret * 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 ) { *count = 0; 119940: 8b 55 1c mov 0x1c(%ebp),%edx 119943: c7 02 00 00 00 00 movl $0x0,(%edx) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 119949: 31 c0 xor %eax,%eax #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11994b: 8d 65 f4 lea -0xc(%ebp),%esp 11994e: 5b pop %ebx 11994f: 5e pop %esi 119950: 5f pop %edi 119951: c9 leave 119952: c3 ret 119953: 90 nop 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; 119954: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 119959: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11995c: 5b pop %ebx <== NOT EXECUTED 11995d: 5e pop %esi <== NOT EXECUTED 11995e: 5f pop %edi <== NOT EXECUTED 11995f: c9 leave <== NOT EXECUTED 119960: c3 ret <== NOT EXECUTED =============================================================================== 00114a20 <_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 ) { 114a20: 55 push %ebp 114a21: 89 e5 mov %esp,%ebp 114a23: 57 push %edi 114a24: 56 push %esi 114a25: 53 push %ebx 114a26: 83 ec 0c sub $0xc,%esp 114a29: 8b 5d 08 mov 0x8(%ebp),%ebx 114a2c: 8b 75 10 mov 0x10(%ebp),%esi 114a2f: 8b 45 14 mov 0x14(%ebp),%eax size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 114a32: 89 73 44 mov %esi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 114a35: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 114a3c: 89 43 4c mov %eax,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; 114a3f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 114a46: 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)) { 114a4d: a8 03 test $0x3,%al 114a4f: 74 17 je 114a68 <_CORE_message_queue_Initialize+0x48> allocated_message_size += sizeof(uint32_t); 114a51: 8d 50 04 lea 0x4(%eax),%edx allocated_message_size &= ~(sizeof(uint32_t) - 1); 114a54: 83 e2 fc and $0xfffffffc,%edx } if (allocated_message_size < maximum_message_size) 114a57: 39 d0 cmp %edx,%eax 114a59: 76 0f jbe 114a6a <_CORE_message_queue_Initialize+0x4a><== ALWAYS TAKEN */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) return false; 114a5b: 31 c0 xor %eax,%eax STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 114a5d: 8d 65 f4 lea -0xc(%ebp),%esp 114a60: 5b pop %ebx 114a61: 5e pop %esi 114a62: 5f pop %edi 114a63: c9 leave 114a64: c3 ret 114a65: 8d 76 00 lea 0x0(%esi),%esi /* * 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)) { 114a68: 89 c2 mov %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 * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); 114a6a: 8d 7a 14 lea 0x14(%edx),%edi /* * 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 * 114a6d: 89 f8 mov %edi,%eax 114a6f: 0f af c6 imul %esi,%eax (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 114a72: 39 d0 cmp %edx,%eax 114a74: 72 e5 jb 114a5b <_CORE_message_queue_Initialize+0x3b><== NEVER TAKEN /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 114a76: 83 ec 0c sub $0xc,%esp 114a79: 50 push %eax 114a7a: e8 21 2b 00 00 call 1175a0 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 114a7f: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 114a82: 83 c4 10 add $0x10,%esp 114a85: 85 c0 test %eax,%eax 114a87: 74 d2 je 114a5b <_CORE_message_queue_Initialize+0x3b> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 114a89: 57 push %edi 114a8a: 56 push %esi 114a8b: 50 push %eax 114a8c: 8d 43 68 lea 0x68(%ebx),%eax 114a8f: 50 push %eax 114a90: e8 13 52 00 00 call 119ca8 <_Chain_Initialize> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 114a95: 8d 43 54 lea 0x54(%ebx),%eax 114a98: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 114a9b: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 114aa2: 8d 43 50 lea 0x50(%ebx),%eax 114aa5: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 114aa8: 6a 06 push $0x6 114aaa: 68 80 00 00 00 push $0x80 114aaf: 8b 45 0c mov 0xc(%ebp),%eax 114ab2: 83 38 01 cmpl $0x1,(%eax) 114ab5: 0f 94 c0 sete %al 114ab8: 0f b6 c0 movzbl %al,%eax 114abb: 50 push %eax 114abc: 53 push %ebx 114abd: e8 b6 21 00 00 call 116c78 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 114ac2: 83 c4 20 add $0x20,%esp 114ac5: b0 01 mov $0x1,%al } 114ac7: 8d 65 f4 lea -0xc(%ebp),%esp 114aca: 5b pop %ebx 114acb: 5e pop %esi 114acc: 5f pop %edi 114acd: c9 leave 114ace: c3 ret =============================================================================== 001110b0 <_CORE_message_queue_Insert_message>: void _CORE_message_queue_Insert_message( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message, CORE_message_queue_Submit_types submit_type ) { 1110b0: 55 push %ebp 1110b1: 89 e5 mov %esp,%ebp 1110b3: 56 push %esi 1110b4: 53 push %ebx 1110b5: 83 ec 10 sub $0x10,%esp 1110b8: 8b 45 08 mov 0x8(%ebp),%eax 1110bb: 8b 55 0c mov 0xc(%ebp),%edx 1110be: 8b 4d 10 mov 0x10(%ebp),%ecx 1110c1: 89 4a 08 mov %ecx,0x8(%edx) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); else _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); #else if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) { 1110c4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx 1110ca: 74 70 je 11113c <_CORE_message_queue_Insert_message+0x8c> _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { 1110cc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx 1110d2: 0f 84 88 00 00 00 je 111160 <_CORE_message_queue_Insert_message+0xb0> * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)(the_message_queue->notify_argument); #endif } 1110d8: 8b 58 50 mov 0x50(%eax),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 1110db: 8d 70 54 lea 0x54(%eax),%esi int the_priority; the_priority = _CORE_message_queue_Get_message_priority(the_message); the_header = &the_message_queue->Pending_messages; the_node = _Chain_First( the_header ); while ( !_Chain_Is_tail( the_header, the_node ) ) { 1110de: 39 de cmp %ebx,%esi 1110e0: 74 05 je 1110e7 <_CORE_message_queue_Insert_message+0x37> this_message = (CORE_message_queue_Buffer_control *) the_node; this_priority = _CORE_message_queue_Get_message_priority(this_message); if ( this_priority <= the_priority ) { 1110e2: 3b 4b 08 cmp 0x8(%ebx),%ecx 1110e5: 7d 45 jge 11112c <_CORE_message_queue_Insert_message+0x7c> the_node = the_node->next; continue; } break; } _ISR_Disable( level ); 1110e7: 9c pushf 1110e8: fa cli 1110e9: 5e pop %esi SET_NOTIFY(); 1110ea: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 1110ed: 85 c9 test %ecx,%ecx 1110ef: 0f 94 45 f7 sete -0x9(%ebp) } break; } _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 1110f3: 41 inc %ecx 1110f4: 89 48 48 mov %ecx,0x48(%eax) _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 1110f7: 8b 4b 04 mov 0x4(%ebx),%ecx Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 1110fa: 89 4a 04 mov %ecx,0x4(%edx) before_node = after_node->next; 1110fd: 8b 19 mov (%ecx),%ebx after_node->next = the_node; 1110ff: 89 11 mov %edx,(%ecx) the_node->next = before_node; 111101: 89 1a mov %ebx,(%edx) before_node->previous = the_node; 111103: 89 53 04 mov %edx,0x4(%ebx) _ISR_Enable( level ); 111106: 56 push %esi 111107: 9d popf /* * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 111108: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 11110c: 74 16 je 111124 <_CORE_message_queue_Insert_message+0x74> 11110e: 8b 50 60 mov 0x60(%eax),%edx 111111: 85 d2 test %edx,%edx 111113: 74 0f je 111124 <_CORE_message_queue_Insert_message+0x74> (*the_message_queue->notify_handler)(the_message_queue->notify_argument); 111115: 8b 40 64 mov 0x64(%eax),%eax 111118: 89 45 08 mov %eax,0x8(%ebp) #endif } 11111b: 83 c4 10 add $0x10,%esp 11111e: 5b pop %ebx 11111f: 5e pop %esi 111120: c9 leave * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)(the_message_queue->notify_argument); 111121: ff e2 jmp *%edx 111123: 90 nop #endif } 111124: 83 c4 10 add $0x10,%esp 111127: 5b pop %ebx 111128: 5e pop %esi 111129: c9 leave 11112a: c3 ret 11112b: 90 nop this_message = (CORE_message_queue_Buffer_control *) the_node; this_priority = _CORE_message_queue_Get_message_priority(this_message); if ( this_priority <= the_priority ) { the_node = the_node->next; 11112c: 8b 1b mov (%ebx),%ebx int the_priority; the_priority = _CORE_message_queue_Get_message_priority(the_message); the_header = &the_message_queue->Pending_messages; the_node = _Chain_First( the_header ); while ( !_Chain_Is_tail( the_header, the_node ) ) { 11112e: 39 de cmp %ebx,%esi 111130: 74 b5 je 1110e7 <_CORE_message_queue_Insert_message+0x37> this_message = (CORE_message_queue_Buffer_control *) the_node; this_priority = _CORE_message_queue_Get_message_priority(this_message); if ( this_priority <= the_priority ) { 111132: 3b 4b 08 cmp 0x8(%ebx),%ecx 111135: 7c b0 jl 1110e7 <_CORE_message_queue_Insert_message+0x37> 111137: eb f3 jmp 11112c <_CORE_message_queue_Insert_message+0x7c> 111139: 8d 76 00 lea 0x0(%esi),%esi else _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); #else if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) { _ISR_Disable( level ); 11113c: 9c pushf 11113d: fa cli 11113e: 5b pop %ebx SET_NOTIFY(); 11113f: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 111142: 85 c9 test %ecx,%ecx 111144: 0f 94 45 f7 sete -0x9(%ebp) _ISR_Enable( level ); #else if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) { _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 111148: 41 inc %ecx 111149: 89 48 48 mov %ecx,0x48(%eax) Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 11114c: 8b 48 58 mov 0x58(%eax),%ecx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 11114f: 8d 70 54 lea 0x54(%eax),%esi 111152: 89 32 mov %esi,(%edx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 111154: 89 50 58 mov %edx,0x58(%eax) old_last->next = the_node; 111157: 89 11 mov %edx,(%ecx) the_node->previous = old_last; 111159: 89 4a 04 mov %ecx,0x4(%edx) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 11115c: 53 push %ebx 11115d: 9d popf 11115e: eb a8 jmp 111108 <_CORE_message_queue_Insert_message+0x58> } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { _ISR_Disable( level ); 111160: 9c pushf 111161: fa cli 111162: 5b pop %ebx SET_NOTIFY(); 111163: 8b 48 48 mov 0x48(%eax),%ecx * * INTERRUPT LATENCY: * insert */ void _CORE_message_queue_Insert_message( 111166: 85 c9 test %ecx,%ecx 111168: 0f 94 45 f7 sete -0x9(%ebp) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); } else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) { _ISR_Disable( level ); SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 11116c: 41 inc %ecx 11116d: 89 48 48 mov %ecx,0x48(%eax) RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 111170: 8d 48 50 lea 0x50(%eax),%ecx 111173: 89 4a 04 mov %ecx,0x4(%edx) ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 111176: 8b 48 50 mov 0x50(%eax),%ecx after_node->next = the_node; 111179: 89 50 50 mov %edx,0x50(%eax) the_node->next = before_node; 11117c: 89 0a mov %ecx,(%edx) before_node->previous = the_node; 11117e: 89 51 04 mov %edx,0x4(%ecx) _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 111181: 53 push %ebx 111182: 9d popf 111183: eb 83 jmp 111108 <_CORE_message_queue_Insert_message+0x58> =============================================================================== 00114ad0 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 114ad0: 55 push %ebp 114ad1: 89 e5 mov %esp,%ebp 114ad3: 57 push %edi 114ad4: 56 push %esi 114ad5: 53 push %ebx 114ad6: 83 ec 2c sub $0x2c,%esp 114ad9: 8b 55 08 mov 0x8(%ebp),%edx 114adc: 8b 45 0c mov 0xc(%ebp),%eax 114adf: 89 45 dc mov %eax,-0x24(%ebp) 114ae2: 8b 4d 10 mov 0x10(%ebp),%ecx 114ae5: 89 4d e0 mov %ecx,-0x20(%ebp) 114ae8: 8b 45 14 mov 0x14(%ebp),%eax 114aeb: 8b 5d 1c mov 0x1c(%ebp),%ebx 114aee: 89 5d d8 mov %ebx,-0x28(%ebp) 114af1: 0f b6 7d 18 movzbl 0x18(%ebp),%edi ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 114af5: 8b 0d d8 11 13 00 mov 0x1311d8,%ecx executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 114afb: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) _ISR_Disable( level ); 114b02: 9c pushf 114b03: fa cli 114b04: 8f 45 e4 popl -0x1c(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 114b07: 8b 5a 50 mov 0x50(%edx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 114b0a: 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)) 114b0d: 39 f3 cmp %esi,%ebx 114b0f: 74 7b je 114b8c <_CORE_message_queue_Seize+0xbc> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 114b11: 8b 0b mov (%ebx),%ecx head->next = new_first; 114b13: 89 4a 50 mov %ecx,0x50(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 114b16: 8d 72 50 lea 0x50(%edx),%esi 114b19: 89 71 04 mov %esi,0x4(%ecx) executing = _Thread_Executing; executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 114b1c: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 114b1f: ff 75 e4 pushl -0x1c(%ebp) 114b22: 9d popf *size_p = the_message->Contents.size; 114b23: 8b 4b 0c mov 0xc(%ebx),%ecx 114b26: 89 08 mov %ecx,(%eax) _Thread_Executing->Wait.count = 114b28: 8b 73 08 mov 0x8(%ebx),%esi 114b2b: 8b 0d d8 11 13 00 mov 0x1311d8,%ecx 114b31: 89 71 24 mov %esi,0x24(%ecx) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 114b34: 8d 4b 10 lea 0x10(%ebx),%ecx 114b37: 89 4d e4 mov %ecx,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 114b3a: 8b 08 mov (%eax),%ecx 114b3c: 8b 7d e0 mov -0x20(%ebp),%edi 114b3f: 8b 75 e4 mov -0x1c(%ebp),%esi 114b42: 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 ); 114b44: 83 ec 0c sub $0xc,%esp 114b47: 52 push %edx 114b48: 89 55 d4 mov %edx,-0x2c(%ebp) 114b4b: e8 98 1d 00 00 call 1168e8 <_Thread_queue_Dequeue> if ( !the_thread ) { 114b50: 83 c4 10 add $0x10,%esp 114b53: 85 c0 test %eax,%eax 114b55: 8b 55 d4 mov -0x2c(%ebp),%edx 114b58: 0f 84 86 00 00 00 je 114be4 <_CORE_message_queue_Seize+0x114> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 114b5e: 8b 48 24 mov 0x24(%eax),%ecx 114b61: 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; 114b64: 8b 48 30 mov 0x30(%eax),%ecx 114b67: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 114b6a: 8b 70 2c mov 0x2c(%eax),%esi 114b6d: 8b 7d e4 mov -0x1c(%ebp),%edi 114b70: 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( 114b72: 8b 43 08 mov 0x8(%ebx),%eax 114b75: 89 45 10 mov %eax,0x10(%ebp) 114b78: 89 5d 0c mov %ebx,0xc(%ebp) 114b7b: 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 ); } 114b7e: 8d 65 f4 lea -0xc(%ebp),%esp 114b81: 5b pop %ebx 114b82: 5e pop %esi 114b83: 5f pop %edi 114b84: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 114b85: e9 7a 51 00 00 jmp 119d04 <_CORE_message_queue_Insert_message> 114b8a: 66 90 xchg %ax,%ax return; } #endif } if ( !wait ) { 114b8c: 89 fb mov %edi,%ebx 114b8e: 84 db test %bl,%bl 114b90: 75 16 jne 114ba8 <_CORE_message_queue_Seize+0xd8> _ISR_Enable( level ); 114b92: ff 75 e4 pushl -0x1c(%ebp) 114b95: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 114b96: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx) 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 ); } 114b9d: 8d 65 f4 lea -0xc(%ebp),%esp 114ba0: 5b pop %ebx 114ba1: 5e pop %esi 114ba2: 5f pop %edi 114ba3: c9 leave 114ba4: c3 ret 114ba5: 8d 76 00 lea 0x0(%esi),%esi 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; 114ba8: 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; 114baf: 89 51 44 mov %edx,0x44(%ecx) executing->Wait.id = id; 114bb2: 8b 5d dc mov -0x24(%ebp),%ebx 114bb5: 89 59 20 mov %ebx,0x20(%ecx) executing->Wait.return_argument_second.mutable_object = buffer; 114bb8: 8b 5d e0 mov -0x20(%ebp),%ebx 114bbb: 89 59 2c mov %ebx,0x2c(%ecx) executing->Wait.return_argument = size_p; 114bbe: 89 41 28 mov %eax,0x28(%ecx) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 114bc1: ff 75 e4 pushl -0x1c(%ebp) 114bc4: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 114bc5: c7 45 10 3c 6d 11 00 movl $0x116d3c,0x10(%ebp) 114bcc: 8b 45 d8 mov -0x28(%ebp),%eax 114bcf: 89 45 0c mov %eax,0xc(%ebp) 114bd2: 89 55 08 mov %edx,0x8(%ebp) } 114bd5: 8d 65 f4 lea -0xc(%ebp),%esp 114bd8: 5b pop %ebx 114bd9: 5e pop %esi 114bda: 5f pop %edi 114bdb: 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 ); 114bdc: e9 2f 1e 00 00 jmp 116a10 <_Thread_queue_Enqueue_with_handler> 114be1: 8d 76 00 lea 0x0(%esi),%esi 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 ); 114be4: 89 5d 0c mov %ebx,0xc(%ebp) 114be7: 83 c2 68 add $0x68,%edx 114bea: 89 55 08 mov %edx,0x8(%ebp) } 114bed: 8d 65 f4 lea -0xc(%ebp),%esp 114bf0: 5b pop %ebx 114bf1: 5e pop %esi 114bf2: 5f pop %edi 114bf3: c9 leave 114bf4: e9 a7 fd ff ff jmp 1149a0 <_Chain_Append> =============================================================================== 0010c03c <_CORE_message_queue_Submit>: #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 10c03c: 55 push %ebp 10c03d: 89 e5 mov %esp,%ebp 10c03f: 57 push %edi 10c040: 56 push %esi 10c041: 53 push %ebx 10c042: 83 ec 1c sub $0x1c,%esp 10c045: 8b 5d 08 mov 0x8(%ebp),%ebx 10c048: 8b 75 0c mov 0xc(%ebp),%esi 10c04b: 8a 4d 20 mov 0x20(%ebp),%cl CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 10c04e: 8b 45 10 mov 0x10(%ebp),%eax 10c051: 39 43 4c cmp %eax,0x4c(%ebx) 10c054: 72 32 jb 10c088 <_CORE_message_queue_Submit+0x4c> } /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 10c056: 8b 43 48 mov 0x48(%ebx),%eax 10c059: 85 c0 test %eax,%eax 10c05b: 74 3b je 10c098 <_CORE_message_queue_Submit+0x5c> /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 10c05d: 39 43 44 cmp %eax,0x44(%ebx) 10c060: 0f 87 ba 00 00 00 ja 10c120 <_CORE_message_queue_Submit+0xe4> /* * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 10c066: 84 c9 test %cl,%cl 10c068: 0f 84 ee 00 00 00 je 10c15c <_CORE_message_queue_Submit+0x120> /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 10c06e: 8b 15 54 7b 12 00 mov 0x127b54,%edx 10c074: 85 d2 test %edx,%edx 10c076: 74 60 je 10c0d8 <_CORE_message_queue_Submit+0x9c> return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; 10c078: b8 03 00 00 00 mov $0x3,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c07d: 8d 65 f4 lea -0xc(%ebp),%esp 10c080: 5b pop %ebx 10c081: 5e pop %esi 10c082: 5f pop %edi 10c083: c9 leave 10c084: c3 ret 10c085: 8d 76 00 lea 0x0(%esi),%esi { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 10c088: b8 01 00 00 00 mov $0x1,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c08d: 8d 65 f4 lea -0xc(%ebp),%esp 10c090: 5b pop %ebx 10c091: 5e pop %esi 10c092: 5f pop %edi 10c093: c9 leave 10c094: c3 ret 10c095: 8d 76 00 lea 0x0(%esi),%esi /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 10c098: 83 ec 0c sub $0xc,%esp 10c09b: 53 push %ebx 10c09c: 88 4d e4 mov %cl,-0x1c(%ebp) 10c09f: e8 04 1c 00 00 call 10dca8 <_Thread_queue_Dequeue> 10c0a4: 89 c2 mov %eax,%edx if ( the_thread ) { 10c0a6: 83 c4 10 add $0x10,%esp 10c0a9: 85 c0 test %eax,%eax 10c0ab: 8a 4d e4 mov -0x1c(%ebp),%cl 10c0ae: 0f 84 b8 00 00 00 je 10c16c <_CORE_message_queue_Submit+0x130> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 10c0b4: 8b 40 2c mov 0x2c(%eax),%eax 10c0b7: 89 c7 mov %eax,%edi 10c0b9: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0bc: f3 a4 rep movsb %ds:(%esi),%es:(%edi) _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 10c0be: 8b 42 28 mov 0x28(%edx),%eax 10c0c1: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0c4: 89 08 mov %ecx,(%eax) the_thread->Wait.count = (uint32_t) submit_type; 10c0c6: 8b 45 1c mov 0x1c(%ebp),%eax 10c0c9: 89 42 24 mov %eax,0x24(%edx) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 10c0cc: 31 c0 xor %eax,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10c0d1: 5b pop %ebx 10c0d2: 5e pop %esi 10c0d3: 5f pop %edi 10c0d4: c9 leave 10c0d5: c3 ret 10c0d6: 66 90 xchg %ax,%ax * Thus the unusual choice to open a new scope and declare * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ { Thread_Control *executing = _Thread_Executing; 10c0d8: a1 58 7b 12 00 mov 0x127b58,%eax ISR_Level level; _ISR_Disable( level ); 10c0dd: 9c pushf 10c0de: fa cli 10c0df: 59 pop %ecx 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; 10c0e0: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 10c0e7: 89 58 44 mov %ebx,0x44(%eax) executing->Wait.id = id; 10c0ea: 8b 55 14 mov 0x14(%ebp),%edx 10c0ed: 89 50 20 mov %edx,0x20(%eax) executing->Wait.return_argument_second.immutable_object = buffer; 10c0f0: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.option = (uint32_t) size; 10c0f3: 8b 55 10 mov 0x10(%ebp),%edx 10c0f6: 89 50 30 mov %edx,0x30(%eax) executing->Wait.count = submit_type; 10c0f9: 8b 55 1c mov 0x1c(%ebp),%edx 10c0fc: 89 50 24 mov %edx,0x24(%eax) _ISR_Enable( level ); 10c0ff: 51 push %ecx 10c100: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10c101: 50 push %eax 10c102: 68 fc e0 10 00 push $0x10e0fc 10c107: ff 75 24 pushl 0x24(%ebp) 10c10a: 53 push %ebx 10c10b: e8 c0 1c 00 00 call 10ddd0 <_Thread_queue_Enqueue_with_handler> } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10c110: 83 c4 10 add $0x10,%esp 10c113: b8 07 00 00 00 mov $0x7,%eax #endif } 10c118: 8d 65 f4 lea -0xc(%ebp),%esp 10c11b: 5b pop %ebx 10c11c: 5e pop %esi 10c11d: 5f pop %edi 10c11e: c9 leave 10c11f: c3 ret _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) _Chain_Get( &the_message_queue->Inactive_messages ); 10c120: 83 ec 0c sub $0xc,%esp 10c123: 8d 43 68 lea 0x68(%ebx),%eax 10c126: 50 push %eax 10c127: e8 ec fe ff ff call 10c018 <_Chain_Get> 10c12c: 89 c2 mov %eax,%edx return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; #endif _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, 10c12e: 8d 40 10 lea 0x10(%eax),%eax const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 10c131: 89 c7 mov %eax,%edi 10c133: 8b 4d 10 mov 0x10(%ebp),%ecx 10c136: f3 a4 rep movsb %ds:(%esi),%es:(%edi) size ); the_message->Contents.size = size; 10c138: 8b 4d 10 mov 0x10(%ebp),%ecx 10c13b: 89 4a 0c mov %ecx,0xc(%edx) CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 10c13e: 8b 45 1c mov 0x1c(%ebp),%eax 10c141: 89 42 08 mov %eax,0x8(%edx) _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 10c144: 83 c4 0c add $0xc,%esp 10c147: 50 push %eax 10c148: 52 push %edx 10c149: 53 push %ebx 10c14a: e8 61 4f 00 00 call 1110b0 <_CORE_message_queue_Insert_message> the_message_queue, the_message, submit_type ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 10c14f: 83 c4 10 add $0x10,%esp 10c152: 31 c0 xor %eax,%eax 10c154: e9 34 ff ff ff jmp 10c08d <_CORE_message_queue_Submit+0x51> 10c159: 8d 76 00 lea 0x0(%esi),%esi * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; 10c15c: b8 02 00 00 00 mov $0x2,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 10c161: 8d 65 f4 lea -0xc(%ebp),%esp 10c164: 5b pop %ebx 10c165: 5e pop %esi 10c166: 5f pop %edi 10c167: c9 leave 10c168: c3 ret 10c169: 8d 76 00 lea 0x0(%esi),%esi /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 10c16c: 8b 43 48 mov 0x48(%ebx),%eax 10c16f: e9 e9 fe ff ff jmp 10c05d <_CORE_message_queue_Submit+0x21> =============================================================================== 0010c180 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10c180: 55 push %ebp 10c181: 89 e5 mov %esp,%ebp 10c183: 57 push %edi 10c184: 56 push %esi 10c185: 53 push %ebx 10c186: 83 ec 0c sub $0xc,%esp 10c189: 8b 45 08 mov 0x8(%ebp),%eax 10c18c: 8b 5d 0c mov 0xc(%ebp),%ebx 10c18f: 8b 55 10 mov 0x10(%ebp),%edx /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 10c192: 8d 78 40 lea 0x40(%eax),%edi 10c195: b9 04 00 00 00 mov $0x4,%ecx 10c19a: 89 de mov %ebx,%esi 10c19c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10c19e: 89 50 50 mov %edx,0x50(%eax) the_mutex->blocked_count = 0; 10c1a1: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10c1a8: 85 d2 test %edx,%edx 10c1aa: 75 30 jne 10c1dc <_CORE_mutex_Initialize+0x5c> the_mutex->nest_count = 1; 10c1ac: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) the_mutex->holder = _Thread_Executing; 10c1b3: 8b 15 58 7b 12 00 mov 0x127b58,%edx 10c1b9: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = _Thread_Executing->Object.id; 10c1bc: 8b 4a 08 mov 0x8(%edx),%ecx 10c1bf: 89 48 60 mov %ecx,0x60(%eax) STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c1c2: 8b 48 48 mov 0x48(%eax),%ecx if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10c1c5: 83 f9 02 cmp $0x2,%ecx 10c1c8: 74 05 je 10c1cf <_CORE_mutex_Initialize+0x4f> 10c1ca: 83 f9 03 cmp $0x3,%ecx 10c1cd: 75 22 jne 10c1f1 <_CORE_mutex_Initialize+0x71> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10c1cf: 8b 48 4c mov 0x4c(%eax),%ecx 10c1d2: 39 4a 14 cmp %ecx,0x14(%edx) 10c1d5: 72 41 jb 10c218 <_CORE_mutex_Initialize+0x98> _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 10c1d7: ff 42 1c incl 0x1c(%edx) 10c1da: eb 15 jmp 10c1f1 <_CORE_mutex_Initialize+0x71> } } else { the_mutex->nest_count = 0; 10c1dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) the_mutex->holder = NULL; 10c1e3: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) the_mutex->holder_id = 0; 10c1ea: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) } _Thread_queue_Initialize( 10c1f1: 6a 05 push $0x5 10c1f3: 68 00 04 00 00 push $0x400 10c1f8: 31 d2 xor %edx,%edx 10c1fa: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10c1fe: 0f 95 c2 setne %dl 10c201: 52 push %edx 10c202: 50 push %eax 10c203: e8 30 1e 00 00 call 10e038 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY, STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; 10c208: 83 c4 10 add $0x10,%esp 10c20b: 31 c0 xor %eax,%eax } 10c20d: 8d 65 f4 lea -0xc(%ebp),%esp 10c210: 5b pop %ebx 10c211: 5e pop %esi 10c212: 5f pop %edi 10c213: c9 leave 10c214: c3 ret 10c215: 8d 76 00 lea 0x0(%esi),%esi if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; 10c218: b8 06 00 00 00 mov $0x6,%eax STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c21d: 8d 65 f4 lea -0xc(%ebp),%esp 10c220: 5b pop %ebx 10c221: 5e pop %esi 10c222: 5f pop %edi 10c223: c9 leave 10c224: c3 ret =============================================================================== 0010c278 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10c278: 55 push %ebp 10c279: 89 e5 mov %esp,%ebp 10c27b: 53 push %ebx 10c27c: 83 ec 14 sub $0x14,%esp 10c27f: 8b 5d 08 mov 0x8(%ebp),%ebx 10c282: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c285: a1 70 75 12 00 mov 0x127570,%eax 10c28a: 85 c0 test %eax,%eax 10c28c: 74 04 je 10c292 <_CORE_mutex_Seize+0x1a> 10c28e: 84 d2 test %dl,%dl 10c290: 75 36 jne 10c2c8 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN 10c292: 83 ec 08 sub $0x8,%esp 10c295: 8d 45 18 lea 0x18(%ebp),%eax 10c298: 50 push %eax 10c299: 53 push %ebx 10c29a: 88 55 f4 mov %dl,-0xc(%ebp) 10c29d: e8 e6 4e 00 00 call 111188 <_CORE_mutex_Seize_interrupt_trylock> 10c2a2: 83 c4 10 add $0x10,%esp 10c2a5: 85 c0 test %eax,%eax 10c2a7: 8a 55 f4 mov -0xc(%ebp),%dl 10c2aa: 74 14 je 10c2c0 <_CORE_mutex_Seize+0x48> 10c2ac: 84 d2 test %dl,%dl 10c2ae: 75 30 jne 10c2e0 <_CORE_mutex_Seize+0x68> 10c2b0: ff 75 18 pushl 0x18(%ebp) 10c2b3: 9d popf 10c2b4: a1 58 7b 12 00 mov 0x127b58,%eax 10c2b9: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) } 10c2c0: 8b 5d fc mov -0x4(%ebp),%ebx 10c2c3: c9 leave 10c2c4: c3 ret 10c2c5: 8d 76 00 lea 0x0(%esi),%esi bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c2c8: 83 3d 40 77 12 00 01 cmpl $0x1,0x127740 10c2cf: 76 c1 jbe 10c292 <_CORE_mutex_Seize+0x1a> 10c2d1: 53 push %ebx 10c2d2: 6a 12 push $0x12 10c2d4: 6a 00 push $0x0 10c2d6: 6a 00 push $0x0 10c2d8: e8 1b 06 00 00 call 10c8f8 <_Internal_error_Occurred> 10c2dd: 8d 76 00 lea 0x0(%esi),%esi 10c2e0: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10c2e7: a1 58 7b 12 00 mov 0x127b58,%eax 10c2ec: 89 58 44 mov %ebx,0x44(%eax) 10c2ef: 8b 55 0c mov 0xc(%ebp),%edx 10c2f2: 89 50 20 mov %edx,0x20(%eax) 10c2f5: a1 70 75 12 00 mov 0x127570,%eax 10c2fa: 40 inc %eax 10c2fb: a3 70 75 12 00 mov %eax,0x127570 10c300: ff 75 18 pushl 0x18(%ebp) 10c303: 9d popf 10c304: 83 ec 08 sub $0x8,%esp 10c307: ff 75 14 pushl 0x14(%ebp) 10c30a: 53 push %ebx 10c30b: e8 18 ff ff ff call 10c228 <_CORE_mutex_Seize_interrupt_blocking> 10c310: 83 c4 10 add $0x10,%esp } 10c313: 8b 5d fc mov -0x4(%ebp),%ebx 10c316: c9 leave 10c317: c3 ret =============================================================================== 00111188 <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 111188: 55 push %ebp 111189: 89 e5 mov %esp,%ebp 11118b: 56 push %esi 11118c: 53 push %ebx 11118d: 8b 45 08 mov 0x8(%ebp),%eax 111190: 8b 4d 0c mov 0xc(%ebp),%ecx { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 111193: 8b 15 58 7b 12 00 mov 0x127b58,%edx executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 111199: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 1111a0: 8b 58 50 mov 0x50(%eax),%ebx 1111a3: 85 db test %ebx,%ebx 1111a5: 74 31 je 1111d8 <_CORE_mutex_Seize_interrupt_trylock+0x50> the_mutex->lock = CORE_MUTEX_LOCKED; 1111a7: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) the_mutex->holder = executing; 1111ae: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = executing->Object.id; 1111b1: 8b 5a 08 mov 0x8(%edx),%ebx 1111b4: 89 58 60 mov %ebx,0x60(%eax) the_mutex->nest_count = 1; 1111b7: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 1111be: 8b 58 48 mov 0x48(%eax),%ebx if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 1111c1: 83 fb 02 cmp $0x2,%ebx 1111c4: 74 26 je 1111ec <_CORE_mutex_Seize_interrupt_trylock+0x64> 1111c6: 83 fb 03 cmp $0x3,%ebx 1111c9: 74 3d je 111208 <_CORE_mutex_Seize_interrupt_trylock+0x80> executing->resource_count++; } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( *level_p ); 1111cb: ff 31 pushl (%ecx) 1111cd: 9d popf return 0; 1111ce: 31 c0 xor %eax,%eax 1111d0: 8d 65 f8 lea -0x8(%ebp),%esp 1111d3: 5b pop %ebx 1111d4: 5e pop %esi 1111d5: c9 leave 1111d6: c3 ret 1111d7: 90 nop /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 1111d8: 3b 50 5c cmp 0x5c(%eax),%edx 1111db: 74 17 je 1111f4 <_CORE_mutex_Seize_interrupt_trylock+0x6c> /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 1111dd: b8 01 00 00 00 mov $0x1,%eax 1111e2: 8d 65 f8 lea -0x8(%ebp),%esp 1111e5: 5b pop %ebx 1111e6: 5e pop %esi 1111e7: c9 leave 1111e8: c3 ret 1111e9: 8d 76 00 lea 0x0(%esi),%esi _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 1111ec: ff 42 1c incl 0x1c(%edx) 1111ef: eb da jmp 1111cb <_CORE_mutex_Seize_interrupt_trylock+0x43> 1111f1: 8d 76 00 lea 0x0(%esi),%esi * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 1111f4: 8b 58 40 mov 0x40(%eax),%ebx 1111f7: 85 db test %ebx,%ebx 1111f9: 75 45 jne 111240 <_CORE_mutex_Seize_interrupt_trylock+0xb8> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 1111fb: ff 40 54 incl 0x54(%eax) _ISR_Enable( *level_p ); 1111fe: ff 31 pushl (%ecx) 111200: 9d popf return 0; 111201: 31 c0 xor %eax,%eax 111203: eb dd jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111205: 8d 76 00 lea 0x0(%esi),%esi _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 111208: 8b 5a 1c mov 0x1c(%edx),%ebx 11120b: 8d 73 01 lea 0x1(%ebx),%esi 11120e: 89 72 1c mov %esi,0x1c(%edx) Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { 111211: 8b 72 14 mov 0x14(%edx),%esi 111214: 39 70 4c cmp %esi,0x4c(%eax) 111217: 74 6b je 111284 <_CORE_mutex_Seize_interrupt_trylock+0xfc> _ISR_Enable( *level_p ); return 0; } if ( current > ceiling ) { 111219: 72 39 jb 111254 <_CORE_mutex_Seize_interrupt_trylock+0xcc> ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 11121b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) the_mutex->lock = CORE_MUTEX_UNLOCKED; 111222: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax) the_mutex->nest_count = 0; /* undo locking above */ 111229: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) executing->resource_count--; /* undo locking above */ 111230: 89 5a 1c mov %ebx,0x1c(%edx) _ISR_Enable( *level_p ); 111233: ff 31 pushl (%ecx) 111235: 9d popf return 0; 111236: 31 c0 xor %eax,%eax 111238: 8d 65 f8 lea -0x8(%ebp),%esp 11123b: 5b pop %ebx 11123c: 5e pop %esi 11123d: c9 leave 11123e: c3 ret 11123f: 90 nop * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 111240: 4b dec %ebx 111241: 75 9a jne 1111dd <_CORE_mutex_Seize_interrupt_trylock+0x55> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( *level_p ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 111243: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) _ISR_Enable( *level_p ); 11124a: ff 31 pushl (%ecx) 11124c: 9d popf return 0; 11124d: 31 c0 xor %eax,%eax 11124f: eb 91 jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111251: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 111254: 8b 15 70 75 12 00 mov 0x127570,%edx 11125a: 42 inc %edx 11125b: 89 15 70 75 12 00 mov %edx,0x127570 return 0; } if ( current > ceiling ) { _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); 111261: ff 31 pushl (%ecx) 111263: 9d popf _Thread_Change_priority( 111264: 52 push %edx 111265: 6a 00 push $0x0 111267: ff 70 4c pushl 0x4c(%eax) 11126a: ff 70 5c pushl 0x5c(%eax) 11126d: e8 ce c1 ff ff call 10d440 <_Thread_Change_priority> the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 111272: e8 7d c6 ff ff call 10d8f4 <_Thread_Enable_dispatch> 111277: 83 c4 10 add $0x10,%esp return 0; 11127a: 31 c0 xor %eax,%eax 11127c: e9 61 ff ff ff jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111281: 8d 76 00 lea 0x0(%esi),%esi Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( *level_p ); 111284: ff 31 pushl (%ecx) 111286: 9d popf return 0; 111287: 31 c0 xor %eax,%eax 111289: e9 54 ff ff ff jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> =============================================================================== 0010c318 <_CORE_mutex_Surrender>: #else Objects_Id id __attribute__((unused)), CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused)) #endif ) { 10c318: 55 push %ebp 10c319: 89 e5 mov %esp,%ebp 10c31b: 53 push %ebx 10c31c: 83 ec 04 sub $0x4,%esp 10c31f: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; Thread_Control *holder; holder = the_mutex->holder; 10c322: 8b 43 5c mov 0x5c(%ebx),%eax * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 10c325: 80 7b 44 00 cmpb $0x0,0x44(%ebx) 10c329: 74 15 je 10c340 <_CORE_mutex_Surrender+0x28> if ( !_Thread_Is_executing( holder ) ) 10c32b: 3b 05 58 7b 12 00 cmp 0x127b58,%eax 10c331: 74 0d je 10c340 <_CORE_mutex_Surrender+0x28> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; 10c333: b8 03 00 00 00 mov $0x3,%eax } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c338: 8b 5d fc mov -0x4(%ebp),%ebx 10c33b: c9 leave 10c33c: c3 ret 10c33d: 8d 76 00 lea 0x0(%esi),%esi return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 10c340: 8b 53 54 mov 0x54(%ebx),%edx 10c343: 85 d2 test %edx,%edx 10c345: 74 51 je 10c398 <_CORE_mutex_Surrender+0x80> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10c347: 4a dec %edx 10c348: 89 53 54 mov %edx,0x54(%ebx) if ( the_mutex->nest_count != 0 ) { 10c34b: 85 d2 test %edx,%edx 10c34d: 75 49 jne 10c398 <_CORE_mutex_Surrender+0x80> } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10c34f: 8b 53 48 mov 0x48(%ebx),%edx /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10c352: 83 fa 02 cmp $0x2,%edx 10c355: 74 69 je 10c3c0 <_CORE_mutex_Surrender+0xa8> 10c357: 83 fa 03 cmp $0x3,%edx 10c35a: 74 64 je 10c3c0 <_CORE_mutex_Surrender+0xa8> if ( holder->resource_count == 0 && holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); } } the_mutex->holder = NULL; 10c35c: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 10c363: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 10c36a: 83 ec 0c sub $0xc,%esp 10c36d: 53 push %ebx 10c36e: e8 35 19 00 00 call 10dca8 <_Thread_queue_Dequeue> 10c373: 83 c4 10 add $0x10,%esp 10c376: 85 c0 test %eax,%eax 10c378: 74 7a je 10c3f4 <_CORE_mutex_Surrender+0xdc> } else #endif { the_mutex->holder = the_thread; 10c37a: 89 43 5c mov %eax,0x5c(%ebx) the_mutex->holder_id = the_thread->Object.id; 10c37d: 8b 50 08 mov 0x8(%eax),%edx 10c380: 89 53 60 mov %edx,0x60(%ebx) the_mutex->nest_count = 1; 10c383: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) switch ( the_mutex->Attributes.discipline ) { 10c38a: 8b 53 48 mov 0x48(%ebx),%edx 10c38d: 83 fa 02 cmp $0x2,%edx 10c390: 74 56 je 10c3e8 <_CORE_mutex_Surrender+0xd0> 10c392: 83 fa 03 cmp $0x3,%edx 10c395: 74 09 je 10c3a0 <_CORE_mutex_Surrender+0x88> 10c397: 90 nop } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c398: 31 c0 xor %eax,%eax } 10c39a: 8b 5d fc mov -0x4(%ebp),%ebx 10c39d: c9 leave 10c39e: c3 ret 10c39f: 90 nop _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 10c3a0: ff 40 1c incl 0x1c(%eax) if (the_mutex->Attributes.priority_ceiling < 10c3a3: 8b 53 4c mov 0x4c(%ebx),%edx 10c3a6: 3b 50 14 cmp 0x14(%eax),%edx 10c3a9: 73 ed jae 10c398 <_CORE_mutex_Surrender+0x80> the_thread->current_priority){ _Thread_Change_priority( 10c3ab: 51 push %ecx 10c3ac: 6a 00 push $0x0 10c3ae: 52 push %edx 10c3af: 50 push %eax 10c3b0: e8 8b 10 00 00 call 10d440 <_Thread_Change_priority> 10c3b5: 83 c4 10 add $0x10,%esp } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3b8: 31 c0 xor %eax,%eax 10c3ba: e9 79 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20> 10c3bf: 90 nop _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 10c3c0: 8b 50 1c mov 0x1c(%eax),%edx 10c3c3: 4a dec %edx 10c3c4: 89 50 1c mov %edx,0x1c(%eax) /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( holder->resource_count == 0 && 10c3c7: 85 d2 test %edx,%edx 10c3c9: 75 91 jne 10c35c <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { 10c3cb: 8b 50 18 mov 0x18(%eax),%edx /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( holder->resource_count == 0 && 10c3ce: 3b 50 14 cmp 0x14(%eax),%edx 10c3d1: 74 89 je 10c35c <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); 10c3d3: 51 push %ecx 10c3d4: 6a 01 push $0x1 10c3d6: 52 push %edx 10c3d7: 50 push %eax 10c3d8: e8 63 10 00 00 call 10d440 <_Thread_Change_priority> 10c3dd: 83 c4 10 add $0x10,%esp 10c3e0: e9 77 ff ff ff jmp 10c35c <_CORE_mutex_Surrender+0x44> 10c3e5: 8d 76 00 lea 0x0(%esi),%esi case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 10c3e8: ff 40 1c incl 0x1c(%eax) } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3eb: 31 c0 xor %eax,%eax case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; break; 10c3ed: e9 46 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20> 10c3f2: 66 90 xchg %ax,%ax } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10c3f4: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) return CORE_MUTEX_STATUS_SUCCESSFUL; 10c3fb: 31 c0 xor %eax,%eax 10c3fd: e9 36 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20> =============================================================================== 00115298 <_CORE_semaphore_Seize>: CORE_semaphore_Control *the_semaphore, Objects_Id id, bool wait, Watchdog_Interval timeout ) { 115298: 55 push %ebp 115299: 89 e5 mov %esp,%ebp 11529b: 57 push %edi 11529c: 56 push %esi 11529d: 53 push %ebx 11529e: 83 ec 1c sub $0x1c,%esp 1152a1: 8b 45 08 mov 0x8(%ebp),%eax 1152a4: 8b 7d 0c mov 0xc(%ebp),%edi 1152a7: 8b 75 14 mov 0x14(%ebp),%esi 1152aa: 8a 5d 10 mov 0x10(%ebp),%bl Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 1152ad: 8b 15 d8 d8 12 00 mov 0x12d8d8,%edx executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 1152b3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Disable( level ); 1152ba: 9c pushf 1152bb: fa cli 1152bc: 8f 45 e4 popl -0x1c(%ebp) if ( the_semaphore->count != 0 ) { 1152bf: 8b 48 48 mov 0x48(%eax),%ecx 1152c2: 85 c9 test %ecx,%ecx 1152c4: 75 46 jne 11530c <_CORE_semaphore_Seize+0x74> /* * If the semaphore was not available and the caller was not willing * to block, then return immediately with a status indicating that * the semaphore was not available and the caller never blocked. */ if ( !wait ) { 1152c6: 84 db test %bl,%bl 1152c8: 75 16 jne 1152e0 <_CORE_semaphore_Seize+0x48> _ISR_Enable( level ); 1152ca: ff 75 e4 pushl -0x1c(%ebp) 1152cd: 9d popf executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 1152ce: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 1152d5: 83 c4 1c add $0x1c,%esp 1152d8: 5b pop %ebx 1152d9: 5e pop %esi 1152da: 5f pop %edi 1152db: c9 leave 1152dc: c3 ret 1152dd: 8d 76 00 lea 0x0(%esi),%esi 1152e0: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) /* * If the semaphore is not available and the caller is willing to * block, then we now block the caller with optional timeout. */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 1152e7: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 1152ea: 89 7a 20 mov %edi,0x20(%edx) _ISR_Enable( level ); 1152ed: ff 75 e4 pushl -0x1c(%ebp) 1152f0: 9d popf _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 1152f1: c7 45 10 20 1b 11 00 movl $0x111b20,0x10(%ebp) 1152f8: 89 75 0c mov %esi,0xc(%ebp) 1152fb: 89 45 08 mov %eax,0x8(%ebp) } 1152fe: 83 c4 1c add $0x1c,%esp 115301: 5b pop %ebx 115302: 5e pop %esi 115303: 5f pop %edi 115304: c9 leave */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 115305: e9 ea c4 ff ff jmp 1117f4 <_Thread_queue_Enqueue_with_handler> 11530a: 66 90 xchg %ax,%ax executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; _ISR_Disable( level ); if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 11530c: 49 dec %ecx 11530d: 89 48 48 mov %ecx,0x48(%eax) _ISR_Enable( level ); 115310: ff 75 e4 pushl -0x1c(%ebp) 115313: 9d popf _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 115314: 83 c4 1c add $0x1c,%esp 115317: 5b pop %ebx 115318: 5e pop %esi 115319: 5f pop %edi 11531a: c9 leave 11531b: c3 ret =============================================================================== 0010c450 <_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 ) { 10c450: 55 push %ebp 10c451: 89 e5 mov %esp,%ebp 10c453: 53 push %ebx 10c454: 83 ec 10 sub $0x10,%esp 10c457: 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)) ) { 10c45a: 53 push %ebx 10c45b: e8 48 18 00 00 call 10dca8 <_Thread_queue_Dequeue> 10c460: 83 c4 10 add $0x10,%esp 10c463: 85 c0 test %eax,%eax 10c465: 74 09 je 10c470 <_CORE_semaphore_Surrender+0x20> { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c467: 31 c0 xor %eax,%eax status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10c469: 8b 5d fc mov -0x4(%ebp),%ebx 10c46c: c9 leave 10c46d: c3 ret 10c46e: 66 90 xchg %ax,%ax if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10c470: 9c pushf 10c471: fa cli 10c472: 5a pop %edx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10c473: 8b 43 48 mov 0x48(%ebx),%eax 10c476: 3b 43 40 cmp 0x40(%ebx),%eax 10c479: 72 0d jb 10c488 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10c47b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED _ISR_Enable( level ); 10c480: 52 push %edx 10c481: 9d popf } return status; } 10c482: 8b 5d fc mov -0x4(%ebp),%ebx 10c485: c9 leave 10c486: c3 ret 10c487: 90 nop #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10c488: 40 inc %eax 10c489: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c48c: 31 c0 xor %eax,%eax 10c48e: eb f0 jmp 10c480 <_CORE_semaphore_Surrender+0x30> =============================================================================== 0010c6b0 <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) { 10c6b0: 55 push %ebp 10c6b1: 89 e5 mov %esp,%ebp 10c6b3: 57 push %edi 10c6b4: 56 push %esi 10c6b5: 53 push %ebx 10c6b6: 8b 45 08 mov 0x8(%ebp),%eax 10c6b9: 8b 7d 0c mov 0xc(%ebp),%edi ISR_Level level; bool is_empty_now; _ISR_Disable( level ); 10c6bc: 9c pushf 10c6bd: fa cli 10c6be: 5e pop %esi Chain_Node **the_node ) { bool is_empty_now = true; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c6bf: 8d 58 04 lea 0x4(%eax),%ebx Chain_Node *old_first = head->next; 10c6c2: 8b 10 mov (%eax),%edx if ( old_first != tail ) { 10c6c4: 39 d3 cmp %edx,%ebx 10c6c6: 74 18 je 10c6e0 <_Chain_Get_with_empty_check+0x30> Chain_Node *new_first = old_first->next; 10c6c8: 8b 0a mov (%edx),%ecx head->next = new_first; 10c6ca: 89 08 mov %ecx,(%eax) new_first->previous = head; 10c6cc: 89 41 04 mov %eax,0x4(%ecx) *the_node = old_first; 10c6cf: 89 17 mov %edx,(%edi) is_empty_now = new_first == tail; 10c6d1: 39 cb cmp %ecx,%ebx 10c6d3: 0f 94 c0 sete %al is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); 10c6d6: 56 push %esi 10c6d7: 9d popf return is_empty_now; } 10c6d8: 5b pop %ebx 10c6d9: 5e pop %esi 10c6da: 5f pop %edi 10c6db: c9 leave 10c6dc: c3 ret 10c6dd: 8d 76 00 lea 0x0(%esi),%esi } else *the_node = NULL; 10c6e0: c7 07 00 00 00 00 movl $0x0,(%edi) RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected( Chain_Control *the_chain, Chain_Node **the_node ) { bool is_empty_now = true; 10c6e6: b0 01 mov $0x1,%al 10c6e8: eb ec jmp 10c6d6 <_Chain_Get_with_empty_check+0x26> =============================================================================== 00111054 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 111054: 55 push %ebp 111055: 89 e5 mov %esp,%ebp 111057: 57 push %edi 111058: 56 push %esi 111059: 53 push %ebx 11105a: 83 ec 08 sub $0x8,%esp 11105d: 8b 7d 08 mov 0x8(%ebp),%edi 111060: 8b 4d 10 mov 0x10(%ebp),%ecx 111063: 8b 75 14 mov 0x14(%ebp),%esi size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 111066: 8d 47 04 lea 0x4(%edi),%eax 111069: 89 45 f0 mov %eax,-0x10(%ebp) Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; 11106c: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) while ( count-- ) { 111073: 85 c9 test %ecx,%ecx 111075: 74 35 je 1110ac <_Chain_Initialize+0x58><== NEVER TAKEN 111077: 49 dec %ecx 111078: 89 4d ec mov %ecx,-0x14(%ebp) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; Chain_Node *next = starting_address; 11107b: 8b 45 0c mov 0xc(%ebp),%eax ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; 11107e: 89 fa mov %edi,%edx 111080: eb 07 jmp 111089 <_Chain_Initialize+0x35> 111082: 66 90 xchg %ax,%ax Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 111084: 89 c2 mov %eax,%edx current->next = next; next->previous = current; current = next; next = (Chain_Node *) 111086: 89 d8 mov %ebx,%eax 111088: 49 dec %ecx Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { current->next = next; 111089: 89 02 mov %eax,(%edx) next->previous = current; 11108b: 89 50 04 mov %edx,0x4(%eax) * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 11108e: 8d 1c 30 lea (%eax,%esi,1),%ebx Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 111091: 85 c9 test %ecx,%ecx 111093: 75 ef jne 111084 <_Chain_Initialize+0x30> * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 111095: 0f af 75 ec imul -0x14(%ebp),%esi 111099: 03 75 0c add 0xc(%ebp),%esi current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = tail; 11109c: 8b 45 f0 mov -0x10(%ebp),%eax 11109f: 89 06 mov %eax,(%esi) tail->previous = current; 1110a1: 89 77 08 mov %esi,0x8(%edi) } 1110a4: 83 c4 08 add $0x8,%esp 1110a7: 5b pop %ebx 1110a8: 5e pop %esi 1110a9: 5f pop %edi 1110aa: c9 leave 1110ab: c3 ret ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; 1110ac: 89 fe mov %edi,%esi <== NOT EXECUTED 1110ae: eb ec jmp 11109c <_Chain_Initialize+0x48><== NOT EXECUTED =============================================================================== 0010b070 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 10b070: 55 push %ebp 10b071: 89 e5 mov %esp,%ebp 10b073: 57 push %edi 10b074: 56 push %esi 10b075: 53 push %ebx 10b076: 83 ec 2c sub $0x2c,%esp 10b079: 8b 45 08 mov 0x8(%ebp),%eax 10b07c: 8b 4d 0c mov 0xc(%ebp),%ecx 10b07f: 8b 55 10 mov 0x10(%ebp),%edx 10b082: 89 55 dc mov %edx,-0x24(%ebp) 10b085: 8b 7d 14 mov 0x14(%ebp),%edi rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 10b088: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx executing->Wait.return_code = RTEMS_SUCCESSFUL; 10b08e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10b095: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi _ISR_Disable( level ); 10b09b: 9c pushf 10b09c: fa cli 10b09d: 8f 45 e0 popl -0x20(%ebp) pending_events = api->pending_events; 10b0a0: 8b 16 mov (%esi),%edx 10b0a2: 89 55 d4 mov %edx,-0x2c(%ebp) seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 10b0a5: 21 c2 and %eax,%edx 10b0a7: 89 55 e4 mov %edx,-0x1c(%ebp) 10b0aa: 74 0d je 10b0b9 <_Event_Seize+0x49> 10b0ac: 39 d0 cmp %edx,%eax 10b0ae: 0f 84 84 00 00 00 je 10b138 <_Event_Seize+0xc8> (seized_events == event_in || _Options_Is_any( option_set )) ) { 10b0b4: f6 c1 02 test $0x2,%cl 10b0b7: 75 7f jne 10b138 <_Event_Seize+0xc8> _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 10b0b9: f6 c1 01 test $0x1,%cl 10b0bc: 75 62 jne 10b120 <_Event_Seize+0xb0> * set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; 10b0be: 89 4b 30 mov %ecx,0x30(%ebx) executing->Wait.count = (uint32_t) event_in; 10b0c1: 89 43 24 mov %eax,0x24(%ebx) executing->Wait.return_argument = event_out; 10b0c4: 89 7b 28 mov %edi,0x28(%ebx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10b0c7: c7 05 88 7f 12 00 01 movl $0x1,0x127f88 10b0ce: 00 00 00 _ISR_Enable( level ); 10b0d1: ff 75 e0 pushl -0x20(%ebp) 10b0d4: 9d popf if ( ticks ) { 10b0d5: 8b 45 dc mov -0x24(%ebp),%eax 10b0d8: 85 c0 test %eax,%eax 10b0da: 0f 85 80 00 00 00 jne 10b160 <_Event_Seize+0xf0> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 10b0e0: 83 ec 08 sub $0x8,%esp 10b0e3: 68 00 01 00 00 push $0x100 10b0e8: 53 push %ebx 10b0e9: e8 6a 30 00 00 call 10e158 <_Thread_Set_state> _ISR_Disable( level ); 10b0ee: 9c pushf 10b0ef: fa cli 10b0f0: 5a pop %edx sync_state = _Event_Sync_state; 10b0f1: a1 88 7f 12 00 mov 0x127f88,%eax _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b0f6: c7 05 88 7f 12 00 00 movl $0x0,0x127f88 10b0fd: 00 00 00 if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 10b100: 83 c4 10 add $0x10,%esp 10b103: 83 f8 01 cmp $0x1,%eax 10b106: 74 4c je 10b154 <_Event_Seize+0xe4> * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 10b108: 89 55 10 mov %edx,0x10(%ebp) 10b10b: 89 5d 0c mov %ebx,0xc(%ebp) 10b10e: 89 45 08 mov %eax,0x8(%ebp) } 10b111: 8d 65 f4 lea -0xc(%ebp),%esp 10b114: 5b pop %ebx 10b115: 5e pop %esi 10b116: 5f pop %edi 10b117: c9 leave * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 10b118: e9 d7 22 00 00 jmp 10d3f4 <_Thread_blocking_operation_Cancel> 10b11d: 8d 76 00 lea 0x0(%esi),%esi *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 10b120: ff 75 e0 pushl -0x20(%ebp) 10b123: 9d popf executing->Wait.return_code = RTEMS_UNSATISFIED; 10b124: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) *event_out = seized_events; 10b12b: 8b 55 e4 mov -0x1c(%ebp),%edx 10b12e: 89 17 mov %edx,(%edi) * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 10b130: 8d 65 f4 lea -0xc(%ebp),%esp 10b133: 5b pop %ebx 10b134: 5e pop %esi 10b135: 5f pop %edi 10b136: c9 leave 10b137: c3 ret 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) ); 10b138: 8b 45 e4 mov -0x1c(%ebp),%eax 10b13b: f7 d0 not %eax 10b13d: 23 45 d4 and -0x2c(%ebp),%eax 10b140: 89 06 mov %eax,(%esi) if ( !_Event_sets_Is_empty( seized_events ) && (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 10b142: ff 75 e0 pushl -0x20(%ebp) 10b145: 9d popf *event_out = seized_events; 10b146: 8b 45 e4 mov -0x1c(%ebp),%eax 10b149: 89 07 mov %eax,(%edi) * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 10b14b: 8d 65 f4 lea -0xc(%ebp),%esp 10b14e: 5b pop %ebx 10b14f: 5e pop %esi 10b150: 5f pop %edi 10b151: c9 leave 10b152: c3 ret 10b153: 90 nop _ISR_Disable( level ); sync_state = _Event_Sync_state; _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { _ISR_Enable( level ); 10b154: 52 push %edx 10b155: 9d popf * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 10b156: 8d 65 f4 lea -0xc(%ebp),%esp 10b159: 5b pop %ebx 10b15a: 5e pop %esi 10b15b: 5f pop %edi 10b15c: c9 leave 10b15d: c3 ret 10b15e: 66 90 xchg %ax,%ax _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; _ISR_Enable( level ); if ( ticks ) { _Watchdog_Initialize( 10b160: 8b 43 08 mov 0x8(%ebx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b163: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10b16a: c7 43 64 14 b3 10 00 movl $0x10b314,0x64(%ebx) the_watchdog->id = id; 10b171: 89 43 68 mov %eax,0x68(%ebx) the_watchdog->user_data = user_data; 10b174: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b17b: 8b 45 dc mov -0x24(%ebp),%eax 10b17e: 89 43 54 mov %eax,0x54(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b181: 83 ec 08 sub $0x8,%esp &executing->Timer, _Event_Timeout, executing->Object.id, NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); 10b184: 8d 43 48 lea 0x48(%ebx),%eax 10b187: 50 push %eax 10b188: 68 7c 76 12 00 push $0x12767c 10b18d: e8 66 35 00 00 call 10e6f8 <_Watchdog_Insert> 10b192: 83 c4 10 add $0x10,%esp 10b195: e9 46 ff ff ff jmp 10b0e0 <_Event_Seize+0x70> =============================================================================== 0010b1f0 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 10b1f0: 55 push %ebp 10b1f1: 89 e5 mov %esp,%ebp 10b1f3: 57 push %edi 10b1f4: 56 push %esi 10b1f5: 53 push %ebx 10b1f6: 83 ec 2c sub $0x2c,%esp 10b1f9: 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 ]; 10b1fc: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx option_set = (rtems_option) the_thread->Wait.option; 10b202: 8b 7b 30 mov 0x30(%ebx),%edi _ISR_Disable( level ); 10b205: 9c pushf 10b206: fa cli 10b207: 8f 45 d4 popl -0x2c(%ebp) pending_events = api->pending_events; 10b20a: 8b 11 mov (%ecx),%edx event_condition = (rtems_event_set) the_thread->Wait.count; 10b20c: 8b 43 24 mov 0x24(%ebx),%eax seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 10b20f: 89 c6 mov %eax,%esi 10b211: 21 d6 and %edx,%esi 10b213: 89 75 e4 mov %esi,-0x1c(%ebp) 10b216: 74 74 je 10b28c <_Event_Surrender+0x9c> /* * 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() && 10b218: 8b 35 54 7b 12 00 mov 0x127b54,%esi 10b21e: 85 f6 test %esi,%esi 10b220: 74 0c je 10b22e <_Event_Surrender+0x3e> 10b222: 3b 1d 58 7b 12 00 cmp 0x127b58,%ebx 10b228: 0f 84 96 00 00 00 je 10b2c4 <_Event_Surrender+0xd4> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 10b22e: f6 43 11 01 testb $0x1,0x11(%ebx) 10b232: 74 4c je 10b280 <_Event_Surrender+0x90> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 10b234: 3b 45 e4 cmp -0x1c(%ebp),%eax 10b237: 74 05 je 10b23e <_Event_Surrender+0x4e> 10b239: 83 e7 02 and $0x2,%edi 10b23c: 74 42 je 10b280 <_Event_Surrender+0x90> <== 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) ); 10b23e: 8b 45 e4 mov -0x1c(%ebp),%eax 10b241: f7 d0 not %eax 10b243: 21 d0 and %edx,%eax 10b245: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 10b247: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10b24e: 8b 43 28 mov 0x28(%ebx),%eax 10b251: 8b 75 e4 mov -0x1c(%ebp),%esi 10b254: 89 30 mov %esi,(%eax) _ISR_Flash( level ); 10b256: ff 75 d4 pushl -0x2c(%ebp) 10b259: 9d popf 10b25a: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10b25b: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10b25f: 74 37 je 10b298 <_Event_Surrender+0xa8> _ISR_Enable( level ); 10b261: ff 75 d4 pushl -0x2c(%ebp) 10b264: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b265: 83 ec 08 sub $0x8,%esp 10b268: 68 f8 ff 03 10 push $0x1003fff8 10b26d: 53 push %ebx 10b26e: e8 01 23 00 00 call 10d574 <_Thread_Clear_state> 10b273: 83 c4 10 add $0x10,%esp } return; } } _ISR_Enable( level ); } 10b276: 8d 65 f4 lea -0xc(%ebp),%esp 10b279: 5b pop %ebx 10b27a: 5e pop %esi 10b27b: 5f pop %edi 10b27c: c9 leave 10b27d: c3 ret 10b27e: 66 90 xchg %ax,%ax _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 10b280: ff 75 d4 pushl -0x2c(%ebp) 10b283: 9d popf } 10b284: 8d 65 f4 lea -0xc(%ebp),%esp 10b287: 5b pop %ebx 10b288: 5e pop %esi 10b289: 5f pop %edi 10b28a: c9 leave 10b28b: c3 ret /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 10b28c: ff 75 d4 pushl -0x2c(%ebp) 10b28f: 9d popf } return; } } _ISR_Enable( level ); } 10b290: 8d 65 f4 lea -0xc(%ebp),%esp 10b293: 5b pop %ebx 10b294: 5e pop %esi 10b295: 5f pop %edi 10b296: c9 leave 10b297: c3 ret RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10b298: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10b29f: ff 75 d4 pushl -0x2c(%ebp) 10b2a2: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10b2a3: 83 ec 0c sub $0xc,%esp 10b2a6: 8d 43 48 lea 0x48(%ebx),%eax 10b2a9: 50 push %eax 10b2aa: e8 89 35 00 00 call 10e838 <_Watchdog_Remove> 10b2af: 58 pop %eax 10b2b0: 5a pop %edx 10b2b1: 68 f8 ff 03 10 push $0x1003fff8 10b2b6: 53 push %ebx 10b2b7: e8 b8 22 00 00 call 10d574 <_Thread_Clear_state> 10b2bc: 83 c4 10 add $0x10,%esp 10b2bf: eb c3 jmp 10b284 <_Event_Surrender+0x94> 10b2c1: 8d 76 00 lea 0x0(%esi),%esi * 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) || 10b2c4: 8b 35 88 7f 12 00 mov 0x127f88,%esi /* * 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 ) && 10b2ca: 83 fe 02 cmp $0x2,%esi 10b2cd: 74 0d je 10b2dc <_Event_Surrender+0xec> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 10b2cf: 8b 35 88 7f 12 00 mov 0x127f88,%esi * 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) || 10b2d5: 4e dec %esi 10b2d6: 0f 85 52 ff ff ff jne 10b22e <_Event_Surrender+0x3e> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 10b2dc: 3b 45 e4 cmp -0x1c(%ebp),%eax 10b2df: 74 05 je 10b2e6 <_Event_Surrender+0xf6> 10b2e1: 83 e7 02 and $0x2,%edi 10b2e4: 74 22 je 10b308 <_Event_Surrender+0x118><== NEVER TAKEN 10b2e6: 8b 45 e4 mov -0x1c(%ebp),%eax 10b2e9: f7 d0 not %eax 10b2eb: 21 d0 and %edx,%eax 10b2ed: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 10b2ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10b2f6: 8b 43 28 mov 0x28(%ebx),%eax 10b2f9: 8b 55 e4 mov -0x1c(%ebp),%edx 10b2fc: 89 10 mov %edx,(%eax) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10b2fe: c7 05 88 7f 12 00 03 movl $0x3,0x127f88 10b305: 00 00 00 } _ISR_Enable( level ); 10b308: ff 75 d4 pushl -0x2c(%ebp) 10b30b: 9d popf return; 10b30c: e9 73 ff ff ff jmp 10b284 <_Event_Surrender+0x94> =============================================================================== 0010b314 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 10b314: 55 push %ebp 10b315: 89 e5 mov %esp,%ebp 10b317: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 10b31a: 8d 45 f4 lea -0xc(%ebp),%eax 10b31d: 50 push %eax 10b31e: ff 75 08 pushl 0x8(%ebp) 10b321: e8 f2 25 00 00 call 10d918 <_Thread_Get> switch ( location ) { 10b326: 83 c4 10 add $0x10,%esp 10b329: 8b 55 f4 mov -0xc(%ebp),%edx 10b32c: 85 d2 test %edx,%edx 10b32e: 75 37 jne 10b367 <_Event_Timeout+0x53> <== 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 ); 10b330: 9c pushf 10b331: fa cli 10b332: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 10b333: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 10b33a: 3b 05 58 7b 12 00 cmp 0x127b58,%eax 10b340: 74 2a je 10b36c <_Event_Timeout+0x58> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } the_thread->Wait.return_code = RTEMS_TIMEOUT; 10b342: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 10b349: 52 push %edx 10b34a: 9d popf 10b34b: 83 ec 08 sub $0x8,%esp 10b34e: 68 f8 ff 03 10 push $0x1003fff8 10b353: 50 push %eax 10b354: e8 1b 22 00 00 call 10d574 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10b359: a1 70 75 12 00 mov 0x127570,%eax 10b35e: 48 dec %eax 10b35f: a3 70 75 12 00 mov %eax,0x127570 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 10b364: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b367: c9 leave 10b368: c3 ret 10b369: 8d 76 00 lea 0x0(%esi),%esi } #endif the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10b36c: 8b 0d 88 7f 12 00 mov 0x127f88,%ecx 10b372: 49 dec %ecx 10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10b375: c7 05 88 7f 12 00 02 movl $0x2,0x127f88 10b37c: 00 00 00 10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e> =============================================================================== 001112e4 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 1112e4: 55 push %ebp 1112e5: 89 e5 mov %esp,%ebp 1112e7: 57 push %edi 1112e8: 56 push %esi 1112e9: 53 push %ebx 1112ea: 83 ec 2c sub $0x2c,%esp 1112ed: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE 1112f0: 8d 47 04 lea 0x4(%edi),%eax 1112f3: 89 45 dc mov %eax,-0x24(%ebp) - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 1112f6: 8b 55 08 mov 0x8(%ebp),%edx 1112f9: 8b 52 10 mov 0x10(%edx),%edx 1112fc: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 1112ff: 39 c7 cmp %eax,%edi 111301: 0f 87 69 01 00 00 ja 111470 <_Heap_Allocate_aligned_with_boundary+0x18c> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 111307: 8b 5d 14 mov 0x14(%ebp),%ebx 11130a: 85 db test %ebx,%ebx 11130c: 0f 85 56 01 00 00 jne 111468 <_Heap_Allocate_aligned_with_boundary+0x184> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111312: 8b 45 08 mov 0x8(%ebp),%eax 111315: 8b 48 08 mov 0x8(%eax),%ecx do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 111318: 39 c8 cmp %ecx,%eax 11131a: 0f 84 50 01 00 00 je 111470 <_Heap_Allocate_aligned_with_boundary+0x18c> 111320: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp) uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 111327: 8b 55 cc mov -0x34(%ebp),%edx 11132a: 83 c2 07 add $0x7,%edx 11132d: 89 55 c8 mov %edx,-0x38(%ebp) + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 111330: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 111337: 29 7d d0 sub %edi,-0x30(%ebp) 11133a: eb 1e jmp 11135a <_Heap_Allocate_aligned_with_boundary+0x76> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 11133c: 8d 59 08 lea 0x8(%ecx),%ebx } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 11133f: 85 db test %ebx,%ebx 111341: 0f 85 f1 00 00 00 jne 111438 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN break; } block = block->next; 111347: 8b 49 08 mov 0x8(%ecx),%ecx 11134a: 8b 45 e4 mov -0x1c(%ebp),%eax 11134d: 40 inc %eax do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 11134e: 39 4d 08 cmp %ecx,0x8(%ebp) 111351: 0f 84 25 01 00 00 je 11147c <_Heap_Allocate_aligned_with_boundary+0x198> 111357: 89 45 e4 mov %eax,-0x1c(%ebp) /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 11135a: 8b 59 04 mov 0x4(%ecx),%ebx 11135d: 39 5d dc cmp %ebx,-0x24(%ebp) 111360: 73 e5 jae 111347 <_Heap_Allocate_aligned_with_boundary+0x63> if ( alignment == 0 ) { 111362: 8b 55 10 mov 0x10(%ebp),%edx 111365: 85 d2 test %edx,%edx 111367: 74 d3 je 11133c <_Heap_Allocate_aligned_with_boundary+0x58> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111369: 8b 45 08 mov 0x8(%ebp),%eax 11136c: 8b 40 14 mov 0x14(%eax),%eax 11136f: 89 45 d8 mov %eax,-0x28(%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; 111372: 83 e3 fe and $0xfffffffe,%ebx uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; 111375: 8d 1c 19 lea (%ecx,%ebx,1),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 111378: 8d 51 08 lea 0x8(%ecx),%edx 11137b: 89 55 d4 mov %edx,-0x2c(%ebp) uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; 11137e: 8b 75 c8 mov -0x38(%ebp),%esi 111381: 29 c6 sub %eax,%esi uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 111383: 01 de add %ebx,%esi + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 111385: 03 5d d0 add -0x30(%ebp),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111388: 89 d8 mov %ebx,%eax 11138a: 31 d2 xor %edx,%edx 11138c: f7 75 10 divl 0x10(%ebp) 11138f: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { 111391: 39 de cmp %ebx,%esi 111393: 73 0b jae 1113a0 <_Heap_Allocate_aligned_with_boundary+0xbc> 111395: 89 f0 mov %esi,%eax 111397: 31 d2 xor %edx,%edx 111399: f7 75 10 divl 0x10(%ebp) 11139c: 89 f3 mov %esi,%ebx 11139e: 29 d3 sub %edx,%ebx } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 1113a0: 8b 45 14 mov 0x14(%ebp),%eax 1113a3: 85 c0 test %eax,%eax 1113a5: 74 5b je 111402 <_Heap_Allocate_aligned_with_boundary+0x11e> /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); } alloc_end = alloc_begin + alloc_size; 1113a7: 8d 34 3b lea (%ebx,%edi,1),%esi 1113aa: 89 f0 mov %esi,%eax 1113ac: 31 d2 xor %edx,%edx 1113ae: f7 75 14 divl 0x14(%ebp) 1113b1: 89 f0 mov %esi,%eax 1113b3: 29 d0 sub %edx,%eax /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 1113b5: 39 c3 cmp %eax,%ebx 1113b7: 73 49 jae 111402 <_Heap_Allocate_aligned_with_boundary+0x11e> 1113b9: 39 c6 cmp %eax,%esi 1113bb: 76 45 jbe 111402 <_Heap_Allocate_aligned_with_boundary+0x11e> alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 1113bd: 8b 55 d4 mov -0x2c(%ebp),%edx 1113c0: 01 fa add %edi,%edx 1113c2: 89 55 e0 mov %edx,-0x20(%ebp) uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { if ( boundary_line < boundary_floor ) { 1113c5: 39 c2 cmp %eax,%edx 1113c7: 0f 87 7a ff ff ff ja 111347 <_Heap_Allocate_aligned_with_boundary+0x63> 1113cd: 89 ce mov %ecx,%esi 1113cf: eb 10 jmp 1113e1 <_Heap_Allocate_aligned_with_boundary+0xfd> 1113d1: 8d 76 00 lea 0x0(%esi),%esi /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 1113d4: 39 c1 cmp %eax,%ecx 1113d6: 76 28 jbe 111400 <_Heap_Allocate_aligned_with_boundary+0x11c> if ( boundary_line < boundary_floor ) { 1113d8: 39 45 e0 cmp %eax,-0x20(%ebp) 1113db: 0f 87 9f 00 00 00 ja 111480 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN return 0; } alloc_begin = boundary_line - alloc_size; 1113e1: 89 c3 mov %eax,%ebx 1113e3: 29 fb sub %edi,%ebx 1113e5: 89 d8 mov %ebx,%eax 1113e7: 31 d2 xor %edx,%edx 1113e9: f7 75 10 divl 0x10(%ebp) 1113ec: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 1113ee: 8d 0c 3b lea (%ebx,%edi,1),%ecx 1113f1: 89 c8 mov %ecx,%eax 1113f3: 31 d2 xor %edx,%edx 1113f5: f7 75 14 divl 0x14(%ebp) 1113f8: 89 c8 mov %ecx,%eax 1113fa: 29 d0 sub %edx,%eax /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 1113fc: 39 c3 cmp %eax,%ebx 1113fe: 72 d4 jb 1113d4 <_Heap_Allocate_aligned_with_boundary+0xf0> 111400: 89 f1 mov %esi,%ecx boundary_line = _Heap_Align_down( alloc_end, boundary ); } } /* Ensure that the we have a valid new block at the beginning */ if ( alloc_begin >= alloc_begin_floor ) { 111402: 39 5d d4 cmp %ebx,-0x2c(%ebp) 111405: 0f 87 3c ff ff ff ja 111347 <_Heap_Allocate_aligned_with_boundary+0x63> 11140b: be f8 ff ff ff mov $0xfffffff8,%esi 111410: 29 ce sub %ecx,%esi uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 111412: 01 de add %ebx,%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111414: 89 d8 mov %ebx,%eax 111416: 31 d2 xor %edx,%edx 111418: f7 75 cc divl -0x34(%ebp) uintptr_t const alloc_block_begin = (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size ); uintptr_t const free_size = alloc_block_begin - block_begin; 11141b: 29 d6 sub %edx,%esi if ( free_size >= min_block_size || free_size == 0 ) { 11141d: 39 75 d8 cmp %esi,-0x28(%ebp) 111420: 0f 86 19 ff ff ff jbe 11133f <_Heap_Allocate_aligned_with_boundary+0x5b> 111426: 85 f6 test %esi,%esi 111428: 0f 85 19 ff ff ff jne 111347 <_Heap_Allocate_aligned_with_boundary+0x63> } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 11142e: 85 db test %ebx,%ebx 111430: 0f 84 11 ff ff ff je 111347 <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN 111436: 66 90 xchg %ax,%ax search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 111438: 8b 45 08 mov 0x8(%ebp),%eax 11143b: ff 40 48 incl 0x48(%eax) stats->searches += search_count; 11143e: 8b 55 e4 mov -0x1c(%ebp),%edx 111441: 01 50 4c add %edx,0x4c(%eax) block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 111444: 57 push %edi 111445: 53 push %ebx 111446: 51 push %ecx 111447: 50 push %eax 111448: e8 b7 b3 ff ff call 10c804 <_Heap_Block_allocate> 11144d: 89 d8 mov %ebx,%eax 11144f: 83 c4 10 add $0x10,%esp boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 111452: 8b 55 e4 mov -0x1c(%ebp),%edx 111455: 8b 4d 08 mov 0x8(%ebp),%ecx 111458: 39 51 44 cmp %edx,0x44(%ecx) 11145b: 73 15 jae 111472 <_Heap_Allocate_aligned_with_boundary+0x18e> stats->max_search = search_count; 11145d: 89 51 44 mov %edx,0x44(%ecx) } return (void *) alloc_begin; } 111460: 8d 65 f4 lea -0xc(%ebp),%esp 111463: 5b pop %ebx 111464: 5e pop %esi 111465: 5f pop %edi 111466: c9 leave 111467: c3 ret /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { 111468: 3b 7d 14 cmp 0x14(%ebp),%edi 11146b: 76 1a jbe 111487 <_Heap_Allocate_aligned_with_boundary+0x1a3> 11146d: 8d 76 00 lea 0x0(%esi),%esi do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 111470: 31 c0 xor %eax,%eax if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 111472: 8d 65 f4 lea -0xc(%ebp),%esp 111475: 5b pop %ebx 111476: 5e pop %esi 111477: 5f pop %edi 111478: c9 leave 111479: c3 ret 11147a: 66 90 xchg %ax,%ax do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 11147c: 31 c0 xor %eax,%eax 11147e: eb d2 jmp 111452 <_Heap_Allocate_aligned_with_boundary+0x16e> 111480: 89 f1 mov %esi,%ecx <== NOT EXECUTED 111482: e9 c0 fe ff ff jmp 111347 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED if ( boundary != 0 ) { if ( boundary < alloc_size ) { return NULL; } if ( alignment == 0 ) { 111487: 8b 4d 10 mov 0x10(%ebp),%ecx 11148a: 85 c9 test %ecx,%ecx 11148c: 0f 85 80 fe ff ff jne 111312 <_Heap_Allocate_aligned_with_boundary+0x2e> alignment = page_size; 111492: 89 55 10 mov %edx,0x10(%ebp) 111495: e9 78 fe ff ff jmp 111312 <_Heap_Allocate_aligned_with_boundary+0x2e> =============================================================================== 00111888 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 111888: 55 push %ebp 111889: 89 e5 mov %esp,%ebp 11188b: 57 push %edi 11188c: 56 push %esi 11188d: 53 push %ebx 11188e: 83 ec 4c sub $0x4c,%esp 111891: 8b 5d 08 mov 0x8(%ebp),%ebx 111894: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 111897: 8b 43 20 mov 0x20(%ebx),%eax 11189a: 89 45 d0 mov %eax,-0x30(%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; 11189d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 1118a4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 1118ab: 8b 53 10 mov 0x10(%ebx),%edx 1118ae: 89 55 d4 mov %edx,-0x2c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 1118b1: 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; 1118b4: 8b 73 30 mov 0x30(%ebx),%esi 1118b7: 89 75 c0 mov %esi,-0x40(%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 ) { 1118ba: 8b 55 0c mov 0xc(%ebp),%edx 1118bd: 01 ca add %ecx,%edx 1118bf: 89 55 cc mov %edx,-0x34(%ebp) 1118c2: 73 0c jae 1118d0 <_Heap_Extend+0x48> _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; 1118c4: 31 c0 xor %eax,%eax if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 1118c6: 8d 65 f4 lea -0xc(%ebp),%esp 1118c9: 5b pop %ebx 1118ca: 5e pop %esi 1118cb: 5f pop %edi 1118cc: c9 leave 1118cd: c3 ret 1118ce: 66 90 xchg %ax,%ax if ( extend_area_end < extend_area_begin ) { return false; } extend_area_ok = _Heap_Get_first_and_last_block( 1118d0: 83 ec 08 sub $0x8,%esp 1118d3: 8d 55 e0 lea -0x20(%ebp),%edx 1118d6: 52 push %edx 1118d7: 8d 55 e4 lea -0x1c(%ebp),%edx 1118da: 52 push %edx 1118db: 50 push %eax 1118dc: ff 75 d4 pushl -0x2c(%ebp) 1118df: 51 push %ecx 1118e0: ff 75 0c pushl 0xc(%ebp) 1118e3: e8 38 b1 ff ff call 10ca20 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 1118e8: 83 c4 20 add $0x20,%esp 1118eb: 84 c0 test %al,%al 1118ed: 74 d5 je 1118c4 <_Heap_Extend+0x3c> 1118ef: 8b 7d d0 mov -0x30(%ebp),%edi 1118f2: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 1118f9: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 111900: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 111907: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 11190e: 8b 75 cc mov -0x34(%ebp),%esi 111911: 89 5d b4 mov %ebx,-0x4c(%ebp) 111914: eb 30 jmp 111946 <_Heap_Extend+0xbe> 111916: 66 90 xchg %ax,%ax return false; } if ( extend_area_end == sub_area_begin ) { merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 111918: 39 ce cmp %ecx,%esi 11191a: 73 03 jae 11191f <_Heap_Extend+0x97> 11191c: 89 7d b8 mov %edi,-0x48(%ebp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 11191f: 8d 59 f8 lea -0x8(%ecx),%ebx 111922: 89 c8 mov %ecx,%eax 111924: 31 d2 xor %edx,%edx 111926: f7 75 d4 divl -0x2c(%ebp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 111929: 29 d3 sub %edx,%ebx link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 11192b: 3b 4d 0c cmp 0xc(%ebp),%ecx 11192e: 74 3c je 11196c <_Heap_Extend+0xe4> start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 111930: 39 4d 0c cmp %ecx,0xc(%ebp) 111933: 76 03 jbe 111938 <_Heap_Extend+0xb0> 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 ) 111935: 89 5d bc mov %ebx,-0x44(%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; 111938: 8b 7b 04 mov 0x4(%ebx),%edi 11193b: 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); 11193e: 8d 3c 3b lea (%ebx,%edi,1),%edi link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 111941: 39 7d d0 cmp %edi,-0x30(%ebp) 111944: 74 39 je 11197f <_Heap_Extend+0xf7> return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111946: 3b 7d d0 cmp -0x30(%ebp),%edi 111949: 0f 84 39 01 00 00 je 111a88 <_Heap_Extend+0x200> 11194f: 89 f8 mov %edi,%eax uintptr_t const sub_area_end = start_block->prev_size; 111951: 8b 0f mov (%edi),%ecx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 111953: 39 4d 0c cmp %ecx,0xc(%ebp) 111956: 73 08 jae 111960 <_Heap_Extend+0xd8> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin 111958: 39 f0 cmp %esi,%eax 11195a: 0f 82 64 ff ff ff jb 1118c4 <_Heap_Extend+0x3c> ) { return false; } if ( extend_area_end == sub_area_begin ) { 111960: 39 f0 cmp %esi,%eax 111962: 75 b4 jne 111918 <_Heap_Extend+0x90> 111964: 89 7d c4 mov %edi,-0x3c(%ebp) 111967: eb b6 jmp 11191f <_Heap_Extend+0x97> 111969: 8d 76 00 lea 0x0(%esi),%esi } else if ( extend_area_end < sub_area_end ) { link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { start_block->prev_size = extend_area_end; 11196c: 89 37 mov %esi,(%edi) 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 ) 11196e: 89 5d c8 mov %ebx,-0x38(%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; 111971: 8b 7b 04 mov 0x4(%ebx),%edi 111974: 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); 111977: 8d 3c 3b lea (%ebx,%edi,1),%edi } else if ( sub_area_end < extend_area_begin ) { link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 11197a: 39 7d d0 cmp %edi,-0x30(%ebp) 11197d: 75 c7 jne 111946 <_Heap_Extend+0xbe> <== NEVER TAKEN 11197f: 8b 5d b4 mov -0x4c(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 111982: 8b 75 0c mov 0xc(%ebp),%esi 111985: 3b 73 18 cmp 0x18(%ebx),%esi 111988: 0f 82 06 01 00 00 jb 111a94 <_Heap_Extend+0x20c> heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 11198e: 8b 45 cc mov -0x34(%ebp),%eax 111991: 3b 43 1c cmp 0x1c(%ebx),%eax 111994: 76 03 jbe 111999 <_Heap_Extend+0x111> heap->area_end = extend_area_end; 111996: 89 43 1c mov %eax,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 111999: 8b 55 e0 mov -0x20(%ebp),%edx 11199c: 8b 45 e4 mov -0x1c(%ebp),%eax heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 11199f: 89 d1 mov %edx,%ecx 1119a1: 29 c1 sub %eax,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 1119a3: 8b 75 cc mov -0x34(%ebp),%esi 1119a6: 89 30 mov %esi,(%eax) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 1119a8: 89 ce mov %ecx,%esi 1119aa: 83 ce 01 or $0x1,%esi 1119ad: 89 70 04 mov %esi,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 1119b0: 89 0a mov %ecx,(%edx) extend_last_block->size_and_flag = 0; 1119b2: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 1119b9: 39 43 20 cmp %eax,0x20(%ebx) 1119bc: 0f 86 da 00 00 00 jbe 111a9c <_Heap_Extend+0x214> heap->first_block = extend_first_block; 1119c2: 89 43 20 mov %eax,0x20(%ebx) } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { 1119c5: 8b 75 c4 mov -0x3c(%ebp),%esi 1119c8: 85 f6 test %esi,%esi 1119ca: 0f 84 10 01 00 00 je 111ae0 <_Heap_Extend+0x258> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 1119d0: 8b 73 10 mov 0x10(%ebx),%esi uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 1119d3: 8b 4d 0c mov 0xc(%ebp),%ecx 1119d6: 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; 1119d9: 89 c8 mov %ecx,%eax 1119db: 31 d2 xor %edx,%edx 1119dd: f7 f6 div %esi if ( remainder != 0 ) { 1119df: 85 d2 test %edx,%edx 1119e1: 0f 84 c9 00 00 00 je 111ab0 <_Heap_Extend+0x228> <== ALWAYS TAKEN return value - remainder + alignment; 1119e7: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 1119ea: 29 d0 sub %edx,%eax <== NOT EXECUTED uintptr_t const new_first_block_begin = 1119ec: 8d 50 f8 lea -0x8(%eax),%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; 1119ef: 8b 75 c4 mov -0x3c(%ebp),%esi 1119f2: 8b 0e mov (%esi),%ecx 1119f4: 89 48 f8 mov %ecx,-0x8(%eax) 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 = 1119f7: 89 f0 mov %esi,%eax 1119f9: 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; 1119fb: 83 c8 01 or $0x1,%eax 1119fe: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 111a01: 89 d8 mov %ebx,%eax 111a03: e8 64 fe ff ff call 11186c <_Heap_Free_block> link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 111a08: 8b 45 c8 mov -0x38(%ebp),%eax 111a0b: 85 c0 test %eax,%eax 111a0d: 0f 84 a5 00 00 00 je 111ab8 <_Heap_Extend+0x230> ) { 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, 111a13: 8b 4d cc mov -0x34(%ebp),%ecx 111a16: 83 e9 08 sub $0x8,%ecx 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( 111a19: 2b 4d c8 sub -0x38(%ebp),%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111a1c: 89 c8 mov %ecx,%eax 111a1e: 31 d2 xor %edx,%edx 111a20: f7 73 10 divl 0x10(%ebx) 111a23: 29 d1 sub %edx,%ecx ); 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) 111a25: 8b 55 c8 mov -0x38(%ebp),%edx 111a28: 8b 42 04 mov 0x4(%edx),%eax 111a2b: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 111a2d: 83 c8 01 or $0x1,%eax 111a30: 89 44 11 04 mov %eax,0x4(%ecx,%edx,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; 111a34: 8b 42 04 mov 0x4(%edx),%eax 111a37: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 111a3a: 09 c8 or %ecx,%eax 111a3c: 89 42 04 mov %eax,0x4(%edx) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 111a3f: 89 d8 mov %ebx,%eax 111a41: e8 26 fe ff ff call 11186c <_Heap_Free_block> extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111a46: 8b 75 c4 mov -0x3c(%ebp),%esi 111a49: 85 f6 test %esi,%esi 111a4b: 0f 84 ab 00 00 00 je 111afc <_Heap_Extend+0x274> if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 111a51: 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( 111a54: 8b 43 20 mov 0x20(%ebx),%eax 111a57: 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; 111a59: 8b 4a 04 mov 0x4(%edx),%ecx 111a5c: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 111a5f: 09 c8 or %ecx,%eax 111a61: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, extend_first_block ); } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 111a64: 8b 43 30 mov 0x30(%ebx),%eax 111a67: 2b 45 c0 sub -0x40(%ebp),%eax /* Statistics */ stats->size += extended_size; 111a6a: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) 111a6d: 8b 55 14 mov 0x14(%ebp),%edx 111a70: 85 d2 test %edx,%edx 111a72: 0f 84 a0 00 00 00 je 111b18 <_Heap_Extend+0x290> <== NEVER TAKEN *extended_size_ptr = extended_size; 111a78: 8b 55 14 mov 0x14(%ebp),%edx 111a7b: 89 02 mov %eax,(%edx) return true; 111a7d: b0 01 mov $0x1,%al } 111a7f: 8d 65 f4 lea -0xc(%ebp),%esp 111a82: 5b pop %ebx 111a83: 5e pop %esi 111a84: 5f pop %edi 111a85: c9 leave 111a86: c3 ret 111a87: 90 nop return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111a88: 8b 55 b4 mov -0x4c(%ebp),%edx 111a8b: 8b 42 18 mov 0x18(%edx),%eax 111a8e: e9 be fe ff ff jmp 111951 <_Heap_Extend+0xc9> 111a93: 90 nop start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); if ( extend_area_begin < heap->area_begin ) { heap->area_begin = extend_area_begin; 111a94: 89 73 18 mov %esi,0x18(%ebx) 111a97: e9 fd fe ff ff jmp 111999 <_Heap_Extend+0x111> extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { heap->first_block = extend_first_block; } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 111a9c: 39 53 24 cmp %edx,0x24(%ebx) 111a9f: 0f 83 20 ff ff ff jae 1119c5 <_Heap_Extend+0x13d> heap->last_block = extend_last_block; 111aa5: 89 53 24 mov %edx,0x24(%ebx) 111aa8: e9 18 ff ff ff jmp 1119c5 <_Heap_Extend+0x13d> 111aad: 8d 76 00 lea 0x0(%esi),%esi uintptr_t remainder = value % alignment; if ( remainder != 0 ) { return value - remainder + alignment; } else { return value; 111ab0: 89 c8 mov %ecx,%eax 111ab2: e9 35 ff ff ff jmp 1119ec <_Heap_Extend+0x164> 111ab7: 90 nop ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 111ab8: 8b 7d bc mov -0x44(%ebp),%edi 111abb: 85 ff test %edi,%edi 111abd: 74 87 je 111a46 <_Heap_Extend+0x1be> _Heap_Link_above( 111abf: 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 ); 111ac2: 8b 45 e4 mov -0x1c(%ebp),%eax 111ac5: 2b 45 bc sub -0x44(%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; 111ac8: 8b 75 bc mov -0x44(%ebp),%esi 111acb: 8b 56 04 mov 0x4(%esi),%edx 111ace: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 111ad1: 09 d0 or %edx,%eax 111ad3: 89 46 04 mov %eax,0x4(%esi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 111ad6: 83 49 04 01 orl $0x1,0x4(%ecx) 111ada: e9 67 ff ff ff jmp 111a46 <_Heap_Extend+0x1be> 111adf: 90 nop 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 ) { 111ae0: 8b 4d b8 mov -0x48(%ebp),%ecx 111ae3: 85 c9 test %ecx,%ecx 111ae5: 0f 84 1d ff ff ff je 111a08 <_Heap_Extend+0x180> { 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; 111aeb: 8b 45 b8 mov -0x48(%ebp),%eax 111aee: 29 d0 sub %edx,%eax 111af0: 83 c8 01 or $0x1,%eax 111af3: 89 42 04 mov %eax,0x4(%edx) 111af6: e9 0d ff ff ff jmp 111a08 <_Heap_Extend+0x180> 111afb: 90 nop extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111afc: 8b 4d c8 mov -0x38(%ebp),%ecx 111aff: 85 c9 test %ecx,%ecx 111b01: 0f 85 4a ff ff ff jne 111a51 <_Heap_Extend+0x1c9> _Heap_Free_block( heap, extend_first_block ); 111b07: 8b 55 e4 mov -0x1c(%ebp),%edx 111b0a: 89 d8 mov %ebx,%eax 111b0c: e8 5b fd ff ff call 11186c <_Heap_Free_block> 111b11: e9 3b ff ff ff jmp 111a51 <_Heap_Extend+0x1c9> 111b16: 66 90 xchg %ax,%ax stats->size += extended_size; if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 111b18: b0 01 mov $0x1,%al <== NOT EXECUTED 111b1a: e9 a7 fd ff ff jmp 1118c6 <_Heap_Extend+0x3e> <== NOT EXECUTED =============================================================================== 0011149c <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 11149c: 55 push %ebp 11149d: 89 e5 mov %esp,%ebp 11149f: 57 push %edi 1114a0: 56 push %esi 1114a1: 53 push %ebx 1114a2: 83 ec 10 sub $0x10,%esp 1114a5: 8b 5d 08 mov 0x8(%ebp),%ebx 1114a8: 8b 45 0c mov 0xc(%ebp),%eax 1114ab: 8d 48 f8 lea -0x8(%eax),%ecx 1114ae: 31 d2 xor %edx,%edx 1114b0: 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); 1114b3: 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 1114b5: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 1114b8: 39 c1 cmp %eax,%ecx 1114ba: 72 07 jb 1114c3 <_Heap_Free+0x27> 1114bc: 8b 73 24 mov 0x24(%ebx),%esi 1114bf: 39 f1 cmp %esi,%ecx 1114c1: 76 0d jbe 1114d0 <_Heap_Free+0x34> /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { _HAssert( false ); return( false ); 1114c3: 31 c0 xor %eax,%eax --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1114c5: 83 c4 10 add $0x10,%esp 1114c8: 5b pop %ebx 1114c9: 5e pop %esi 1114ca: 5f pop %edi 1114cb: c9 leave 1114cc: c3 ret 1114cd: 8d 76 00 lea 0x0(%esi),%esi 1114d0: 8b 51 04 mov 0x4(%ecx),%edx 1114d3: 89 55 f0 mov %edx,-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; 1114d6: 83 e2 fe and $0xfffffffe,%edx 1114d9: 89 55 ec mov %edx,-0x14(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 1114dc: 8d 14 11 lea (%ecx,%edx,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; 1114df: 39 d0 cmp %edx,%eax 1114e1: 77 e0 ja 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN 1114e3: 39 d6 cmp %edx,%esi 1114e5: 72 dc jb 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN 1114e7: 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 ) ) { 1114ea: f7 c7 01 00 00 00 test $0x1,%edi 1114f0: 74 d1 je 1114c3 <_Heap_Free+0x27> <== 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; 1114f2: 83 e7 fe and $0xfffffffe,%edi 1114f5: 89 7d e4 mov %edi,-0x1c(%ebp) return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 1114f8: 39 d6 cmp %edx,%esi 1114fa: 0f 84 c8 00 00 00 je 1115c8 <_Heap_Free+0x12c> return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) 111500: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 111505: 0f 94 45 eb sete -0x15(%ebp) next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 111509: f6 45 f0 01 testb $0x1,-0x10(%ebp) 11150d: 75 45 jne 111554 <_Heap_Free+0xb8> uintptr_t const prev_size = block->prev_size; 11150f: 8b 39 mov (%ecx),%edi 111511: 89 7d f0 mov %edi,-0x10(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 111514: 29 f9 sub %edi,%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; 111516: 39 c8 cmp %ecx,%eax 111518: 77 a9 ja 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN 11151a: 39 ce cmp %ecx,%esi 11151c: 72 a5 jb 1114c3 <_Heap_Free+0x27> <== 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) ) { 11151e: f6 41 04 01 testb $0x1,0x4(%ecx) 111522: 74 9f je 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 111524: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 111528: 0f 84 a6 00 00 00 je 1115d4 <_Heap_Free+0x138> uintptr_t const size = block_size + prev_size + next_block_size; 11152e: 8b 7d e4 mov -0x1c(%ebp),%edi 111531: 03 7d ec add -0x14(%ebp),%edi 111534: 03 7d f0 add -0x10(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111537: 8b 42 08 mov 0x8(%edx),%eax 11153a: 8b 52 0c mov 0xc(%edx),%edx RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 11153d: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 111540: 89 50 0c mov %edx,0xc(%eax) } if ( next_is_free ) { /* coalesce both */ uintptr_t const size = block_size + prev_size + next_block_size; _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 111543: ff 4b 38 decl 0x38(%ebx) prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 111546: 89 f8 mov %edi,%eax 111548: 83 c8 01 or $0x1,%eax 11154b: 89 41 04 mov %eax,0x4(%ecx) next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 11154e: 89 3c 39 mov %edi,(%ecx,%edi,1) 111551: eb 2a jmp 11157d <_Heap_Free+0xe1> 111553: 90 nop uintptr_t const size = block_size + prev_size; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ 111554: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 111558: 74 3a je 111594 <_Heap_Free+0xf8> uintptr_t const size = block_size + next_block_size; 11155a: 8b 7d e4 mov -0x1c(%ebp),%edi 11155d: 03 7d ec add -0x14(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111560: 8b 42 08 mov 0x8(%edx),%eax 111563: 8b 52 0c mov 0xc(%edx),%edx ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 111566: 89 41 08 mov %eax,0x8(%ecx) new_block->prev = prev; 111569: 89 51 0c mov %edx,0xc(%ecx) next->prev = new_block; 11156c: 89 48 0c mov %ecx,0xc(%eax) prev->next = new_block; 11156f: 89 4a 08 mov %ecx,0x8(%edx) next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ uintptr_t const size = block_size + next_block_size; _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 111572: 89 f8 mov %edi,%eax 111574: 83 c8 01 or $0x1,%eax 111577: 89 41 04 mov %eax,0x4(%ecx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 11157a: 89 3c 39 mov %edi,(%ecx,%edi,1) stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 11157d: ff 4b 40 decl 0x40(%ebx) ++stats->frees; 111580: ff 43 50 incl 0x50(%ebx) stats->free_size += block_size; 111583: 8b 55 ec mov -0x14(%ebp),%edx 111586: 01 53 30 add %edx,0x30(%ebx) return( true ); 111589: b0 01 mov $0x1,%al } 11158b: 83 c4 10 add $0x10,%esp 11158e: 5b pop %ebx 11158f: 5e pop %esi 111590: 5f pop %edi 111591: c9 leave 111592: c3 ret 111593: 90 nop RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 111594: 8b 43 08 mov 0x8(%ebx),%eax new_block->next = next; 111597: 89 41 08 mov %eax,0x8(%ecx) new_block->prev = block_before; 11159a: 89 59 0c mov %ebx,0xc(%ecx) block_before->next = new_block; 11159d: 89 4b 08 mov %ecx,0x8(%ebx) next->prev = new_block; 1115a0: 89 48 0c mov %ecx,0xc(%eax) next_block->prev_size = size; } 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; 1115a3: 8b 45 ec mov -0x14(%ebp),%eax 1115a6: 83 c8 01 or $0x1,%eax 1115a9: 89 41 04 mov %eax,0x4(%ecx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 1115ac: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 1115b0: 8b 45 ec mov -0x14(%ebp),%eax 1115b3: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->free_blocks; 1115b5: 8b 43 38 mov 0x38(%ebx),%eax 1115b8: 40 inc %eax 1115b9: 89 43 38 mov %eax,0x38(%ebx) if ( stats->max_free_blocks < stats->free_blocks ) { 1115bc: 3b 43 3c cmp 0x3c(%ebx),%eax 1115bf: 76 bc jbe 11157d <_Heap_Free+0xe1> stats->max_free_blocks = stats->free_blocks; 1115c1: 89 43 3c mov %eax,0x3c(%ebx) 1115c4: eb b7 jmp 11157d <_Heap_Free+0xe1> 1115c6: 66 90 xchg %ax,%ax return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 1115c8: c6 45 eb 00 movb $0x0,-0x15(%ebp) 1115cc: e9 38 ff ff ff jmp 111509 <_Heap_Free+0x6d> 1115d1: 8d 76 00 lea 0x0(%esi),%esi 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; 1115d4: 8b 45 ec mov -0x14(%ebp),%eax 1115d7: 03 45 f0 add -0x10(%ebp),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 1115da: 89 c6 mov %eax,%esi 1115dc: 83 ce 01 or $0x1,%esi 1115df: 89 71 04 mov %esi,0x4(%ecx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 1115e2: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 1115e6: 89 02 mov %eax,(%edx) 1115e8: eb 93 jmp 11157d <_Heap_Free+0xe1> =============================================================================== 0010c694 <_Heap_Get_first_and_last_block>: uintptr_t page_size, uintptr_t min_block_size, Heap_Block **first_block_ptr, Heap_Block **last_block_ptr ) { 10c694: 55 push %ebp 10c695: 89 e5 mov %esp,%ebp 10c697: 57 push %edi 10c698: 56 push %esi 10c699: 53 push %ebx 10c69a: 8b 4d 08 mov 0x8(%ebp),%ecx 10c69d: 8b 7d 0c mov 0xc(%ebp),%edi uintptr_t const heap_area_end = heap_area_begin + heap_area_size; 10c6a0: 8d 34 0f lea (%edi,%ecx,1),%esi uintptr_t const alloc_area_begin = _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 10c6a3: 8d 59 08 lea 0x8(%ecx),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 10c6a6: 89 d8 mov %ebx,%eax 10c6a8: 31 d2 xor %edx,%edx 10c6aa: f7 75 10 divl 0x10(%ebp) if ( remainder != 0 ) { 10c6ad: 85 d2 test %edx,%edx 10c6af: 74 05 je 10c6b6 <_Heap_Get_first_and_last_block+0x22> return value - remainder + alignment; 10c6b1: 03 5d 10 add 0x10(%ebp),%ebx 10c6b4: 29 d3 sub %edx,%ebx _Heap_Align_down( heap_area_size - overhead, page_size ); Heap_Block *const first_block = (Heap_Block *) first_block_begin; Heap_Block *const last_block = _Heap_Block_at( first_block, first_block_size ); if ( 10c6b6: 39 f1 cmp %esi,%ecx 10c6b8: 77 2e ja 10c6e8 <_Heap_Get_first_and_last_block+0x54> uintptr_t const alloc_area_begin = _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const first_block_begin = alloc_area_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const overhead = HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin); 10c6ba: 8d 73 f8 lea -0x8(%ebx),%esi uintptr_t const heap_area_end = heap_area_begin + heap_area_size; uintptr_t const alloc_area_begin = _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const first_block_begin = alloc_area_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const overhead = 10c6bd: 29 cb sub %ecx,%ebx Heap_Block *const last_block = _Heap_Block_at( first_block, first_block_size ); if ( heap_area_end < heap_area_begin || heap_area_size <= overhead 10c6bf: 39 df cmp %ebx,%edi 10c6c1: 76 25 jbe 10c6e8 <_Heap_Get_first_and_last_block+0x54> uintptr_t const first_block_begin = alloc_area_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const overhead = HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin); uintptr_t const first_block_size = _Heap_Align_down( heap_area_size - overhead, page_size ); 10c6c3: 29 df sub %ebx,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10c6c5: 89 f8 mov %edi,%eax 10c6c7: 31 d2 xor %edx,%edx 10c6c9: f7 75 10 divl 0x10(%ebp) 10c6cc: 29 d7 sub %edx,%edi _Heap_Block_at( first_block, first_block_size ); if ( heap_area_end < heap_area_begin || heap_area_size <= overhead || first_block_size < min_block_size 10c6ce: 39 7d 14 cmp %edi,0x14(%ebp) 10c6d1: 77 15 ja 10c6e8 <_Heap_Get_first_and_last_block+0x54> ) { /* Invalid area or area too small */ return false; } *first_block_ptr = first_block; 10c6d3: 8b 45 18 mov 0x18(%ebp),%eax 10c6d6: 89 30 mov %esi,(%eax) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10c6d8: 01 f7 add %esi,%edi 10c6da: 8b 45 1c mov 0x1c(%ebp),%eax 10c6dd: 89 38 mov %edi,(%eax) *last_block_ptr = last_block; return true; 10c6df: b0 01 mov $0x1,%al } 10c6e1: 5b pop %ebx 10c6e2: 5e pop %esi 10c6e3: 5f pop %edi 10c6e4: c9 leave 10c6e5: c3 ret 10c6e6: 66 90 xchg %ax,%ax heap_area_end < heap_area_begin || heap_area_size <= overhead || first_block_size < min_block_size ) { /* Invalid area or area too small */ return false; 10c6e8: 31 c0 xor %eax,%eax *first_block_ptr = first_block; *last_block_ptr = last_block; return true; } 10c6ea: 5b pop %ebx 10c6eb: 5e pop %esi 10c6ec: 5f pop %edi 10c6ed: c9 leave 10c6ee: c3 ret =============================================================================== 001151b0 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1151b0: 55 push %ebp 1151b1: 89 e5 mov %esp,%ebp 1151b3: 57 push %edi 1151b4: 56 push %esi 1151b5: 53 push %ebx 1151b6: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 1151b9: c7 07 00 00 00 00 movl $0x0,(%edi) info->largest = 0; 1151bf: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) info->total = 0; 1151c6: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 1151cd: 8b 45 08 mov 0x8(%ebp),%eax 1151d0: 8b 50 08 mov 0x8(%eax),%edx info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); 1151d3: 39 d0 cmp %edx,%eax 1151d5: 74 31 je 115208 <_Heap_Get_free_information+0x58> 1151d7: b9 01 00 00 00 mov $0x1,%ecx 1151dc: 31 f6 xor %esi,%esi 1151de: 31 db xor %ebx,%ebx 1151e0: eb 07 jmp 1151e9 <_Heap_Get_free_information+0x39> 1151e2: 66 90 xchg %ax,%ax 1151e4: 8b 77 04 mov 0x4(%edi),%esi 1151e7: 89 c1 mov %eax,%ecx - 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; 1151e9: 8b 42 04 mov 0x4(%edx),%eax 1151ec: 83 e0 fe and $0xfffffffe,%eax /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; 1151ef: 01 c3 add %eax,%ebx if ( info->largest < the_size ) 1151f1: 39 f0 cmp %esi,%eax 1151f3: 76 03 jbe 1151f8 <_Heap_Get_free_information+0x48> info->largest = the_size; 1151f5: 89 47 04 mov %eax,0x4(%edi) info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); the_block != tail; the_block = the_block->next) 1151f8: 8b 52 08 mov 0x8(%edx),%edx 1151fb: 8d 41 01 lea 0x1(%ecx),%eax info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); 1151fe: 39 55 08 cmp %edx,0x8(%ebp) 115201: 75 e1 jne 1151e4 <_Heap_Get_free_information+0x34> 115203: 89 0f mov %ecx,(%edi) 115205: 89 5f 08 mov %ebx,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 115208: 5b pop %ebx 115209: 5e pop %esi 11520a: 5f pop %edi 11520b: c9 leave 11520c: c3 ret =============================================================================== 00112014 <_Heap_Get_information>: void _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 112014: 55 push %ebp 112015: 89 e5 mov %esp,%ebp 112017: 57 push %edi 112018: 56 push %esi 112019: 53 push %ebx 11201a: 83 ec 04 sub $0x4,%esp 11201d: 8b 45 08 mov 0x8(%ebp),%eax 112020: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Block *the_block = the_heap->first_block; 112023: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *const end = the_heap->last_block; 112026: 8b 40 24 mov 0x24(%eax),%eax 112029: 89 45 f0 mov %eax,-0x10(%ebp) memset(the_info, 0, sizeof(*the_info)); 11202c: b9 18 00 00 00 mov $0x18,%ecx 112031: 31 c0 xor %eax,%eax 112033: 89 df mov %ebx,%edi 112035: f3 aa rep stos %al,%es:(%edi) while ( the_block != end ) { 112037: 3b 55 f0 cmp -0x10(%ebp),%edx 11203a: 74 38 je 112074 <_Heap_Get_information+0x60><== NEVER TAKEN 11203c: 8b 7a 04 mov 0x4(%edx),%edi 11203f: eb 18 jmp 112059 <_Heap_Get_information+0x45> 112041: 8d 76 00 lea 0x0(%esi),%esi uintptr_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); Heap_Information *info; if ( _Heap_Is_prev_used(next_block) ) info = &the_info->Used; 112044: 8d 43 0c lea 0xc(%ebx),%eax else info = &the_info->Free; info->number++; 112047: ff 00 incl (%eax) info->total += the_size; 112049: 01 48 08 add %ecx,0x8(%eax) if ( info->largest < the_size ) 11204c: 39 48 04 cmp %ecx,0x4(%eax) 11204f: 73 03 jae 112054 <_Heap_Get_information+0x40> info->largest = the_size; 112051: 89 48 04 mov %ecx,0x4(%eax) Heap_Block *the_block = the_heap->first_block; Heap_Block *const end = the_heap->last_block; memset(the_info, 0, sizeof(*the_info)); while ( the_block != end ) { 112054: 39 75 f0 cmp %esi,-0x10(%ebp) 112057: 74 1b je 112074 <_Heap_Get_information+0x60> - 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; 112059: 89 f9 mov %edi,%ecx 11205b: 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); 11205e: 8d 34 0a lea (%edx,%ecx,1),%esi 112061: 89 f2 mov %esi,%edx if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 112063: 8b 7e 04 mov 0x4(%esi),%edi while ( the_block != end ) { uintptr_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); Heap_Information *info; if ( _Heap_Is_prev_used(next_block) ) 112066: f7 c7 01 00 00 00 test $0x1,%edi 11206c: 75 d6 jne 112044 <_Heap_Get_information+0x30> info = &the_info->Used; else info = &the_info->Free; 11206e: 89 d8 mov %ebx,%eax 112070: eb d5 jmp 112047 <_Heap_Get_information+0x33> 112072: 66 90 xchg %ax,%ax if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 112074: 58 pop %eax 112075: 5b pop %ebx 112076: 5e pop %esi 112077: 5f pop %edi 112078: c9 leave 112079: c3 ret =============================================================================== 0011ed1c <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 11ed1c: 55 push %ebp 11ed1d: 89 e5 mov %esp,%ebp 11ed1f: 57 push %edi 11ed20: 56 push %esi 11ed21: 53 push %ebx 11ed22: 83 ec 2c sub $0x2c,%esp 11ed25: 8b 5d 08 mov 0x8(%ebp),%ebx 11ed28: 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); 11ed2b: 8d 4e f8 lea -0x8(%esi),%ecx 11ed2e: 89 f0 mov %esi,%eax 11ed30: 31 d2 xor %edx,%edx 11ed32: 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); 11ed35: 29 d1 sub %edx,%ecx uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); *old_size = 0; 11ed37: 8b 45 14 mov 0x14(%ebp),%eax 11ed3a: c7 00 00 00 00 00 movl $0x0,(%eax) *new_size = 0; 11ed40: 8b 55 18 mov 0x18(%ebp),%edx 11ed43: c7 02 00 00 00 00 movl $0x0,(%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; 11ed49: 39 4b 20 cmp %ecx,0x20(%ebx) 11ed4c: 77 05 ja 11ed53 <_Heap_Resize_block+0x37> 11ed4e: 39 4b 24 cmp %ecx,0x24(%ebx) 11ed51: 73 0d jae 11ed60 <_Heap_Resize_block+0x44> new_alloc_size, old_size, new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; 11ed53: b8 02 00 00 00 mov $0x2,%eax } } 11ed58: 8d 65 f4 lea -0xc(%ebp),%esp 11ed5b: 5b pop %ebx 11ed5c: 5e pop %esi 11ed5d: 5f pop %edi 11ed5e: c9 leave 11ed5f: c3 ret - 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; 11ed60: 8b 41 04 mov 0x4(%ecx),%eax 11ed63: 83 e0 fe and $0xfffffffe,%eax { Heap_Statistics *const stats = &heap->stats; uintptr_t const block_begin = (uintptr_t) block; uintptr_t block_size = _Heap_Block_size( block ); uintptr_t block_end = block_begin + block_size; 11ed66: 8d 3c 01 lea (%ecx,%eax,1),%edi 11ed69: 89 7d d4 mov %edi,-0x2c(%ebp) uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 11ed6c: 89 fa mov %edi,%edx 11ed6e: 29 f2 sub %esi,%edx 11ed70: 83 c2 04 add $0x4,%edx 11ed73: 89 55 e0 mov %edx,-0x20(%ebp) 11ed76: 8b 57 04 mov 0x4(%edi),%edx 11ed79: 83 e2 fe and $0xfffffffe,%edx 11ed7c: 89 55 d0 mov %edx,-0x30(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_free( const Heap_Block *block ) { return !_Heap_Is_used( block ); 11ed7f: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11ed84: 0f 94 45 df sete -0x21(%ebp) bool next_block_is_free = _Heap_Is_free( next_block );; _HAssert( _Heap_Is_block_in_heap( heap, next_block ) ); _HAssert( _Heap_Is_prev_used( next_block ) ); *old_size = alloc_size; 11ed88: 8b 55 e0 mov -0x20(%ebp),%edx 11ed8b: 8b 7d 14 mov 0x14(%ebp),%edi 11ed8e: 89 17 mov %edx,(%edi) if ( next_block_is_free ) { 11ed90: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11ed94: 75 6e jne 11ee04 <_Heap_Resize_block+0xe8> block_size += next_block_size; alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 11ed96: 8b 55 e0 mov -0x20(%ebp),%edx 11ed99: 39 55 10 cmp %edx,0x10(%ebp) 11ed9c: 77 79 ja 11ee17 <_Heap_Resize_block+0xfb> return HEAP_RESIZE_UNSATISFIED; } if ( next_block_is_free ) { 11ed9e: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11eda2: 74 31 je 11edd5 <_Heap_Resize_block+0xb9> 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; 11eda4: 8b 79 04 mov 0x4(%ecx),%edi 11eda7: 83 e7 01 and $0x1,%edi block->size_and_flag = size | flag; 11edaa: 09 c7 or %eax,%edi 11edac: 89 79 04 mov %edi,0x4(%ecx) new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11edaf: 8b 7d d4 mov -0x2c(%ebp),%edi 11edb2: 8b 7f 08 mov 0x8(%edi),%edi 11edb5: 89 7d e4 mov %edi,-0x1c(%ebp) 11edb8: 8b 55 d4 mov -0x2c(%ebp),%edx 11edbb: 8b 7a 0c mov 0xc(%edx),%edi RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 11edbe: 8b 55 e4 mov -0x1c(%ebp),%edx 11edc1: 89 57 08 mov %edx,0x8(%edi) next->prev = prev; 11edc4: 89 7a 0c mov %edi,0xc(%edx) _Heap_Block_set_size( block, block_size ); _Heap_Free_list_remove( next_block ); next_block = _Heap_Block_at( block, block_size ); next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 11edc7: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1) /* Statistics */ --stats->free_blocks; 11edcc: ff 4b 38 decl 0x38(%ebx) stats->free_size -= next_block_size; 11edcf: 8b 7d d0 mov -0x30(%ebp),%edi 11edd2: 29 7b 30 sub %edi,0x30(%ebx) } block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 11edd5: ff 75 10 pushl 0x10(%ebp) 11edd8: 56 push %esi 11edd9: 51 push %ecx 11edda: 53 push %ebx 11eddb: e8 24 da fe ff call 10c804 <_Heap_Block_allocate> - 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; 11ede0: 8b 50 04 mov 0x4(%eax),%edx 11ede3: 83 e2 fe and $0xfffffffe,%edx block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS; 11ede6: 29 f0 sub %esi,%eax 11ede8: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11edec: 8b 55 18 mov 0x18(%ebp),%edx 11edef: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->resizes; 11edf1: ff 43 54 incl 0x54(%ebx) 11edf4: 83 c4 10 add $0x10,%esp return HEAP_RESIZE_SUCCESSFUL; 11edf7: 31 c0 xor %eax,%eax new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11edf9: 8d 65 f4 lea -0xc(%ebp),%esp 11edfc: 5b pop %ebx 11edfd: 5e pop %esi 11edfe: 5f pop %edi 11edff: c9 leave 11ee00: c3 ret 11ee01: 8d 76 00 lea 0x0(%esi),%esi _HAssert( _Heap_Is_prev_used( next_block ) ); *old_size = alloc_size; if ( next_block_is_free ) { block_size += next_block_size; 11ee04: 03 45 d0 add -0x30(%ebp),%eax alloc_size += next_block_size; 11ee07: 8b 7d d0 mov -0x30(%ebp),%edi 11ee0a: 01 fa add %edi,%edx 11ee0c: 89 55 e0 mov %edx,-0x20(%ebp) } if ( new_alloc_size > alloc_size ) { 11ee0f: 8b 55 e0 mov -0x20(%ebp),%edx 11ee12: 39 55 10 cmp %edx,0x10(%ebp) 11ee15: 76 87 jbe 11ed9e <_Heap_Resize_block+0x82> return HEAP_RESIZE_UNSATISFIED; 11ee17: b8 01 00 00 00 mov $0x1,%eax new_size ); } else { return HEAP_RESIZE_FATAL_ERROR; } } 11ee1c: 8d 65 f4 lea -0xc(%ebp),%esp 11ee1f: 5b pop %ebx 11ee20: 5e pop %esi 11ee21: 5f pop %edi 11ee22: c9 leave 11ee23: c3 ret =============================================================================== 0011ee24 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11ee24: 55 push %ebp 11ee25: 89 e5 mov %esp,%ebp 11ee27: 56 push %esi 11ee28: 53 push %ebx 11ee29: 8b 5d 08 mov 0x8(%ebp),%ebx 11ee2c: 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); 11ee2f: 8d 4e f8 lea -0x8(%esi),%ecx 11ee32: 89 f0 mov %esi,%eax 11ee34: 31 d2 xor %edx,%edx 11ee36: 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); 11ee39: 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 11ee3b: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 11ee3e: 39 c1 cmp %eax,%ecx 11ee40: 72 07 jb 11ee49 <_Heap_Size_of_alloc_area+0x25> 11ee42: 8b 53 24 mov 0x24(%ebx),%edx 11ee45: 39 d1 cmp %edx,%ecx 11ee47: 76 07 jbe 11ee50 <_Heap_Size_of_alloc_area+0x2c><== ALWAYS TAKEN if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11ee49: 31 c0 xor %eax,%eax } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; return true; } 11ee4b: 5b pop %ebx 11ee4c: 5e pop %esi 11ee4d: c9 leave 11ee4e: c3 ret 11ee4f: 90 nop - 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; 11ee50: 8b 59 04 mov 0x4(%ecx),%ebx 11ee53: 83 e3 fe and $0xfffffffe,%ebx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11ee56: 01 d9 add %ebx,%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; 11ee58: 39 c8 cmp %ecx,%eax 11ee5a: 77 ed ja 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN 11ee5c: 39 ca cmp %ecx,%edx 11ee5e: 72 e9 jb 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11ee60: f6 41 04 01 testb $0x1,0x4(%ecx) 11ee64: 74 e3 je 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11ee66: 29 f1 sub %esi,%ecx 11ee68: 8d 51 04 lea 0x4(%ecx),%edx 11ee6b: 8b 45 10 mov 0x10(%ebp),%eax 11ee6e: 89 10 mov %edx,(%eax) return true; 11ee70: b0 01 mov $0x1,%al } 11ee72: 5b pop %ebx 11ee73: 5e pop %esi 11ee74: c9 leave 11ee75: c3 ret =============================================================================== 0010d338 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10d338: 55 push %ebp 10d339: 89 e5 mov %esp,%ebp 10d33b: 57 push %edi 10d33c: 56 push %esi 10d33d: 53 push %ebx 10d33e: 83 ec 4c sub $0x4c,%esp 10d341: 8b 5d 08 mov 0x8(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10d344: 8b 43 10 mov 0x10(%ebx),%eax 10d347: 89 45 e0 mov %eax,-0x20(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10d34a: 8b 53 14 mov 0x14(%ebx),%edx 10d34d: 89 55 d0 mov %edx,-0x30(%ebp) Heap_Block *const first_block = heap->first_block; 10d350: 8b 43 20 mov 0x20(%ebx),%eax 10d353: 89 45 dc mov %eax,-0x24(%ebp) Heap_Block *const last_block = heap->last_block; 10d356: 8b 53 24 mov 0x24(%ebx),%edx 10d359: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10d35c: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10d360: 74 1a je 10d37c <_Heap_Walk+0x44> 10d362: c7 45 d8 f0 d2 10 00 movl $0x10d2f0,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d369: 83 3d 40 9c 12 00 03 cmpl $0x3,0x129c40 10d370: 74 1a je 10d38c <_Heap_Walk+0x54> <== ALWAYS TAKEN } block = next_block; } while ( block != first_block ); return true; 10d372: b0 01 mov $0x1,%al } 10d374: 8d 65 f4 lea -0xc(%ebp),%esp 10d377: 5b pop %ebx 10d378: 5e pop %esi 10d379: 5f pop %edi 10d37a: c9 leave 10d37b: c3 ret uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; 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; 10d37c: c7 45 d8 e8 d2 10 00 movl $0x10d2e8,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d383: 83 3d 40 9c 12 00 03 cmpl $0x3,0x129c40 10d38a: 75 e6 jne 10d372 <_Heap_Walk+0x3a> 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)( 10d38c: 52 push %edx 10d38d: ff 73 0c pushl 0xc(%ebx) 10d390: ff 73 08 pushl 0x8(%ebx) 10d393: ff 75 cc pushl -0x34(%ebp) 10d396: ff 75 dc pushl -0x24(%ebp) 10d399: ff 73 1c pushl 0x1c(%ebx) 10d39c: ff 73 18 pushl 0x18(%ebx) 10d39f: ff 75 d0 pushl -0x30(%ebp) 10d3a2: ff 75 e0 pushl -0x20(%ebp) 10d3a5: 68 94 1d 12 00 push $0x121d94 10d3aa: 6a 00 push $0x0 10d3ac: ff 75 0c pushl 0xc(%ebp) 10d3af: ff 55 d8 call *-0x28(%ebp) heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10d3b2: 83 c4 30 add $0x30,%esp 10d3b5: 8b 45 e0 mov -0x20(%ebp),%eax 10d3b8: 85 c0 test %eax,%eax 10d3ba: 74 70 je 10d42c <_Heap_Walk+0xf4> (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10d3bc: f6 45 e0 03 testb $0x3,-0x20(%ebp) 10d3c0: 75 72 jne 10d434 <_Heap_Walk+0xfc> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d3c2: 8b 45 d0 mov -0x30(%ebp),%eax 10d3c5: 31 d2 xor %edx,%edx 10d3c7: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10d3ca: 85 d2 test %edx,%edx 10d3cc: 75 72 jne 10d440 <_Heap_Walk+0x108> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d3ce: 8b 45 dc mov -0x24(%ebp),%eax 10d3d1: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d3d4: 31 d2 xor %edx,%edx 10d3d6: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10d3d9: 85 d2 test %edx,%edx 10d3db: 75 6f jne 10d44c <_Heap_Walk+0x114> block = next_block; } while ( block != first_block ); return true; } 10d3dd: 8b 45 dc mov -0x24(%ebp),%eax 10d3e0: 8b 40 04 mov 0x4(%eax),%eax 10d3e3: 89 45 e4 mov %eax,-0x1c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10d3e6: a8 01 test $0x1,%al 10d3e8: 0f 84 ce 02 00 00 je 10d6bc <_Heap_Walk+0x384> - 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; 10d3ee: 8b 55 cc mov -0x34(%ebp),%edx 10d3f1: 8b 42 04 mov 0x4(%edx),%eax 10d3f4: 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); 10d3f7: 01 d0 add %edx,%eax ); return false; } if ( _Heap_Is_free( last_block ) ) { 10d3f9: f6 40 04 01 testb $0x1,0x4(%eax) 10d3fd: 74 25 je 10d424 <_Heap_Walk+0xec> ); return false; } if ( 10d3ff: 39 45 dc cmp %eax,-0x24(%ebp) 10d402: 74 54 je 10d458 <_Heap_Walk+0x120> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10d404: 51 push %ecx <== NOT EXECUTED 10d405: 68 b0 1e 12 00 push $0x121eb0 <== NOT EXECUTED 10d40a: 66 90 xchg %ax,%ax <== NOT EXECUTED return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d40c: 6a 01 push $0x1 10d40e: ff 75 0c pushl 0xc(%ebp) 10d411: ff 55 d8 call *-0x28(%ebp) 10d414: 83 c4 10 add $0x10,%esp return false; } if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; 10d417: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d419: 8d 65 f4 lea -0xc(%ebp),%esp 10d41c: 5b pop %ebx 10d41d: 5e pop %esi 10d41e: 5f pop %edi 10d41f: c9 leave 10d420: c3 ret 10d421: 8d 76 00 lea 0x0(%esi),%esi return false; } if ( _Heap_Is_free( last_block ) ) { (*printer)( 10d424: 53 push %ebx 10d425: 68 4a 1d 12 00 push $0x121d4a 10d42a: eb e0 jmp 10d40c <_Heap_Walk+0xd4> first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { (*printer)( source, true, "page size is zero\n" ); 10d42c: 57 push %edi 10d42d: 68 19 1d 12 00 push $0x121d19 10d432: eb d8 jmp 10d40c <_Heap_Walk+0xd4> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { (*printer)( 10d434: ff 75 e0 pushl -0x20(%ebp) 10d437: 68 2c 1d 12 00 push $0x121d2c 10d43c: eb ce jmp 10d40c <_Heap_Walk+0xd4> 10d43e: 66 90 xchg %ax,%ax return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { (*printer)( 10d440: ff 75 d0 pushl -0x30(%ebp) 10d443: 68 28 1e 12 00 push $0x121e28 10d448: eb c2 jmp 10d40c <_Heap_Walk+0xd4> 10d44a: 66 90 xchg %ax,%ax } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10d44c: ff 75 dc pushl -0x24(%ebp) 10d44f: 68 4c 1e 12 00 push $0x121e4c 10d454: eb b6 jmp 10d40c <_Heap_Walk+0xd4> 10d456: 66 90 xchg %ax,%ax int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10d458: 8b 43 10 mov 0x10(%ebx),%eax 10d45b: 89 45 c8 mov %eax,-0x38(%ebp) block = next_block; } while ( block != first_block ); return true; } 10d45e: 8b 73 08 mov 0x8(%ebx),%esi 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 ) { 10d461: 39 f3 cmp %esi,%ebx 10d463: 74 65 je 10d4ca <_Heap_Walk+0x192> block = next_block; } while ( block != first_block ); return true; } 10d465: 8b 43 20 mov 0x20(%ebx),%eax 10d468: 89 45 d4 mov %eax,-0x2c(%ebp) 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; 10d46b: 39 f0 cmp %esi,%eax 10d46d: 0f 87 55 02 00 00 ja 10d6c8 <_Heap_Walk+0x390> <== NEVER TAKEN 10d473: 8b 7b 24 mov 0x24(%ebx),%edi 10d476: 39 f7 cmp %esi,%edi 10d478: 0f 82 4a 02 00 00 jb 10d6c8 <_Heap_Walk+0x390> <== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d47e: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d481: 31 d2 xor %edx,%edx 10d483: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10d486: 85 d2 test %edx,%edx 10d488: 0f 85 71 02 00 00 jne 10d6ff <_Heap_Walk+0x3c7> <== 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; 10d48e: 8b 46 04 mov 0x4(%esi),%eax 10d491: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d494: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1) 10d499: 0f 85 6d 02 00 00 jne 10d70c <_Heap_Walk+0x3d4> <== NEVER TAKEN 10d49f: 89 da mov %ebx,%edx 10d4a1: 8d 76 00 lea 0x0(%esi),%esi ); return false; } if ( free_block->prev != prev_block ) { 10d4a4: 8b 46 0c mov 0xc(%esi),%eax 10d4a7: 39 d0 cmp %edx,%eax 10d4a9: 0f 85 6a 02 00 00 jne 10d719 <_Heap_Walk+0x3e1> return false; } prev_block = free_block; free_block = free_block->next; 10d4af: 8b 4e 08 mov 0x8(%esi),%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 ) { 10d4b2: 39 cb cmp %ecx,%ebx 10d4b4: 74 1a je 10d4d0 <_Heap_Walk+0x198> 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; 10d4b6: 39 4d d4 cmp %ecx,-0x2c(%ebp) 10d4b9: 0f 86 7d 01 00 00 jbe 10d63c <_Heap_Walk+0x304> if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { (*printer)( 10d4bf: 51 push %ecx 10d4c0: 68 e0 1e 12 00 push $0x121ee0 10d4c5: e9 42 ff ff ff jmp 10d40c <_Heap_Walk+0xd4> 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 ) { 10d4ca: 8b 53 20 mov 0x20(%ebx),%edx 10d4cd: 89 55 d4 mov %edx,-0x2c(%ebp) ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d4d0: 8b 7d dc mov -0x24(%ebp),%edi 10d4d3: 8b 45 d4 mov -0x2c(%ebp),%eax 10d4d6: 66 90 xchg %ax,%ax - 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; 10d4d8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d4db: 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); 10d4de: 8d 34 39 lea (%ecx,%edi,1),%esi 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; 10d4e1: 39 f0 cmp %esi,%eax 10d4e3: 76 23 jbe 10d508 <_Heap_Walk+0x1d0> <== ALWAYS TAKEN 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 ) ) { (*printer)( 10d4e5: 83 ec 0c sub $0xc,%esp 10d4e8: 56 push %esi 10d4e9: 57 push %edi 10d4ea: 68 64 1f 12 00 push $0x121f64 10d4ef: 90 nop 10d4f0: 6a 01 push $0x1 10d4f2: ff 75 0c pushl 0xc(%ebp) 10d4f5: ff 55 d8 call *-0x28(%ebp) "block 0x%08x: next block 0x%08x not in heap\n", block, next_block ); return false; 10d4f8: 83 c4 20 add $0x20,%esp 10d4fb: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d4fd: 8d 65 f4 lea -0xc(%ebp),%esp 10d500: 5b pop %ebx 10d501: 5e pop %esi 10d502: 5f pop %edi 10d503: c9 leave 10d504: c3 ret 10d505: 8d 76 00 lea 0x0(%esi),%esi 10d508: 39 73 24 cmp %esi,0x24(%ebx) 10d50b: 72 d8 jb 10d4e5 <_Heap_Walk+0x1ad> 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; 10d50d: 3b 7d cc cmp -0x34(%ebp),%edi 10d510: 0f 95 45 d4 setne -0x2c(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d514: 89 c8 mov %ecx,%eax 10d516: 31 d2 xor %edx,%edx 10d518: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10d51b: 85 d2 test %edx,%edx 10d51d: 74 0a je 10d529 <_Heap_Walk+0x1f1> 10d51f: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d523: 0f 85 a6 01 00 00 jne 10d6cf <_Heap_Walk+0x397> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10d529: 39 4d d0 cmp %ecx,-0x30(%ebp) 10d52c: 76 0a jbe 10d538 <_Heap_Walk+0x200> 10d52e: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d532: 0f 85 a6 01 00 00 jne 10d6de <_Heap_Walk+0x3a6> <== ALWAYS TAKEN ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10d538: 39 f7 cmp %esi,%edi 10d53a: 72 0a jb 10d546 <_Heap_Walk+0x20e> 10d53c: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10d540: 0f 85 aa 01 00 00 jne 10d6f0 <_Heap_Walk+0x3b8> 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; 10d546: 8b 55 e4 mov -0x1c(%ebp),%edx 10d549: 83 e2 01 and $0x1,%edx ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10d54c: f6 46 04 01 testb $0x1,0x4(%esi) 10d550: 74 4e je 10d5a0 <_Heap_Walk+0x268> if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10d552: 85 d2 test %edx,%edx 10d554: 74 2e je 10d584 <_Heap_Walk+0x24c> (*printer)( 10d556: 83 ec 0c sub $0xc,%esp 10d559: 51 push %ecx 10d55a: 57 push %edi 10d55b: 68 7b 1d 12 00 push $0x121d7b 10d560: 6a 00 push $0x0 10d562: ff 75 0c pushl 0xc(%ebp) 10d565: ff 55 d8 call *-0x28(%ebp) 10d568: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10d56b: 39 75 dc cmp %esi,-0x24(%ebp) 10d56e: 0f 84 fe fd ff ff je 10d372 <_Heap_Walk+0x3a> 10d574: 8b 56 04 mov 0x4(%esi),%edx 10d577: 89 55 e4 mov %edx,-0x1c(%ebp) 10d57a: 8b 43 20 mov 0x20(%ebx),%eax 10d57d: 89 f7 mov %esi,%edi 10d57f: e9 54 ff ff ff jmp 10d4d8 <_Heap_Walk+0x1a0> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10d584: 83 ec 08 sub $0x8,%esp 10d587: ff 37 pushl (%edi) 10d589: 51 push %ecx 10d58a: 57 push %edi 10d58b: 68 c8 20 12 00 push $0x1220c8 10d590: 6a 00 push $0x0 10d592: ff 75 0c pushl 0xc(%ebp) 10d595: ff 55 d8 call *-0x28(%ebp) 10d598: 83 c4 20 add $0x20,%esp 10d59b: eb ce jmp 10d56b <_Heap_Walk+0x233> 10d59d: 8d 76 00 lea 0x0(%esi),%esi block = next_block; } while ( block != first_block ); return true; } 10d5a0: 8b 43 08 mov 0x8(%ebx),%eax 10d5a3: 89 45 b4 mov %eax,-0x4c(%ebp) block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10d5a6: 8b 47 08 mov 0x8(%edi),%eax 10d5a9: 89 45 e4 mov %eax,-0x1c(%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)( 10d5ac: 39 43 0c cmp %eax,0xc(%ebx) 10d5af: 0f 84 cb 00 00 00 je 10d680 <_Heap_Walk+0x348> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10d5b5: 39 c3 cmp %eax,%ebx 10d5b7: 0f 84 db 00 00 00 je 10d698 <_Heap_Walk+0x360> 10d5bd: c7 45 c8 09 1c 12 00 movl $0x121c09,-0x38(%ebp) 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 ? 10d5c4: 8b 47 0c mov 0xc(%edi),%eax 10d5c7: 89 45 d4 mov %eax,-0x2c(%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)( 10d5ca: 39 45 b4 cmp %eax,-0x4c(%ebp) 10d5cd: 0f 84 b9 00 00 00 je 10d68c <_Heap_Walk+0x354> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d5d3: 39 c3 cmp %eax,%ebx 10d5d5: 0f 84 c9 00 00 00 je 10d6a4 <_Heap_Walk+0x36c> 10d5db: b8 09 1c 12 00 mov $0x121c09,%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)( 10d5e0: 83 ec 0c sub $0xc,%esp 10d5e3: ff 75 c8 pushl -0x38(%ebp) 10d5e6: ff 75 e4 pushl -0x1c(%ebp) 10d5e9: 50 push %eax 10d5ea: ff 75 d4 pushl -0x2c(%ebp) 10d5ed: 51 push %ecx 10d5ee: 57 push %edi 10d5ef: 68 24 20 12 00 push $0x122024 10d5f4: 6a 00 push $0x0 10d5f6: ff 75 0c pushl 0xc(%ebp) 10d5f9: 89 55 c4 mov %edx,-0x3c(%ebp) 10d5fc: 89 4d c0 mov %ecx,-0x40(%ebp) 10d5ff: ff 55 d8 call *-0x28(%ebp) block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10d602: 8b 06 mov (%esi),%eax 10d604: 83 c4 30 add $0x30,%esp 10d607: 8b 4d c0 mov -0x40(%ebp),%ecx 10d60a: 39 c1 cmp %eax,%ecx 10d60c: 8b 55 c4 mov -0x3c(%ebp),%edx 10d60f: 75 5f jne 10d670 <_Heap_Walk+0x338> ); return false; } if ( !prev_used ) { 10d611: 85 d2 test %edx,%edx 10d613: 0f 84 97 00 00 00 je 10d6b0 <_Heap_Walk+0x378> block = next_block; } while ( block != first_block ); return true; } 10d619: 8b 43 08 mov 0x8(%ebx),%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 ) { 10d61c: 39 c3 cmp %eax,%ebx 10d61e: 74 0f je 10d62f <_Heap_Walk+0x2f7> <== NEVER TAKEN if ( free_block == block ) { 10d620: 39 c7 cmp %eax,%edi 10d622: 0f 84 43 ff ff ff je 10d56b <_Heap_Walk+0x233> return true; } free_block = free_block->next; 10d628: 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 ) { 10d62b: 39 c3 cmp %eax,%ebx 10d62d: 75 f1 jne 10d620 <_Heap_Walk+0x2e8> return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d62f: 57 push %edi 10d630: 68 f0 20 12 00 push $0x1220f0 10d635: e9 d2 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> 10d63a: 66 90 xchg %ax,%ax 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; 10d63c: 39 f9 cmp %edi,%ecx 10d63e: 0f 87 7b fe ff ff ja 10d4bf <_Heap_Walk+0x187> <== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d644: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d647: 31 d2 xor %edx,%edx 10d649: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10d64c: 85 d2 test %edx,%edx 10d64e: 0f 85 ad 00 00 00 jne 10d701 <_Heap_Walk+0x3c9> - 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; 10d654: 8b 41 04 mov 0x4(%ecx),%eax 10d657: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d65a: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10d65f: 0f 85 a9 00 00 00 jne 10d70e <_Heap_Walk+0x3d6> 10d665: 89 f2 mov %esi,%edx 10d667: 89 ce mov %ecx,%esi 10d669: e9 36 fe ff ff jmp 10d4a4 <_Heap_Walk+0x16c> 10d66e: 66 90 xchg %ax,%ax " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { (*printer)( 10d670: 52 push %edx 10d671: 56 push %esi 10d672: 50 push %eax 10d673: 51 push %ecx 10d674: 57 push %edi 10d675: 68 5c 20 12 00 push $0x12205c 10d67a: e9 71 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> 10d67f: 90 nop 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)( 10d680: c7 45 c8 e6 1c 12 00 movl $0x121ce6,-0x38(%ebp) 10d687: e9 38 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c> 10d68c: b8 ff 1c 12 00 mov $0x121cff,%eax 10d691: e9 4a ff ff ff jmp 10d5e0 <_Heap_Walk+0x2a8> 10d696: 66 90 xchg %ax,%ax " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10d698: c7 45 c8 f5 1c 12 00 movl $0x121cf5,-0x38(%ebp) 10d69f: e9 20 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d6a4: b8 0f 1d 12 00 mov $0x121d0f,%eax 10d6a9: e9 32 ff ff ff jmp 10d5e0 <_Heap_Walk+0x2a8> 10d6ae: 66 90 xchg %ax,%ax return false; } if ( !prev_used ) { (*printer)( 10d6b0: 57 push %edi 10d6b1: 68 98 20 12 00 push $0x122098 10d6b6: e9 51 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> 10d6bb: 90 nop return false; } if ( !_Heap_Is_prev_used( first_block ) ) { (*printer)( 10d6bc: 56 push %esi 10d6bd: 68 80 1e 12 00 push $0x121e80 10d6c2: e9 45 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> 10d6c7: 90 nop 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; 10d6c8: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10d6ca: e9 f0 fd ff ff jmp 10d4bf <_Heap_Walk+0x187> <== NOT EXECUTED return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 10d6cf: 83 ec 0c sub $0xc,%esp 10d6d2: 51 push %ecx 10d6d3: 57 push %edi 10d6d4: 68 94 1f 12 00 push $0x121f94 10d6d9: e9 12 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> return false; } if ( block_size < min_block_size && is_not_last_block ) { (*printer)( 10d6de: 83 ec 08 sub $0x8,%esp 10d6e1: ff 75 d0 pushl -0x30(%ebp) 10d6e4: 51 push %ecx 10d6e5: 57 push %edi 10d6e6: 68 c4 1f 12 00 push $0x121fc4 10d6eb: e9 00 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { (*printer)( 10d6f0: 83 ec 0c sub $0xc,%esp 10d6f3: 56 push %esi 10d6f4: 57 push %edi 10d6f5: 68 f0 1f 12 00 push $0x121ff0 10d6fa: e9 f1 fd ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> ); return false; } if ( 10d6ff: 89 f1 mov %esi,%ecx <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10d701: 51 push %ecx 10d702: 68 00 1f 12 00 push $0x121f00 10d707: e9 00 fd ff ff jmp 10d40c <_Heap_Walk+0xd4> ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d70c: 89 f1 mov %esi,%ecx <== NOT EXECUTED (*printer)( 10d70e: 51 push %ecx 10d70f: 68 5f 1d 12 00 push $0x121d5f 10d714: e9 f3 fc ff ff jmp 10d40c <_Heap_Walk+0xd4> return false; } if ( free_block->prev != prev_block ) { (*printer)( 10d719: 83 ec 0c sub $0xc,%esp 10d71c: 50 push %eax 10d71d: 56 push %esi 10d71e: 68 30 1f 12 00 push $0x121f30 10d723: e9 c8 fd ff ff jmp 10d4f0 <_Heap_Walk+0x1b8> =============================================================================== 0010bdac <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10bdac: 55 push %ebp 10bdad: 89 e5 mov %esp,%ebp 10bdaf: 53 push %ebx 10bdb0: 83 ec 04 sub $0x4,%esp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10bdb3: 8b 0d 20 80 12 00 mov 0x128020,%ecx 10bdb9: 85 c9 test %ecx,%ecx 10bdbb: 74 1a je 10bdd7 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN 10bdbd: 31 db xor %ebx,%ebx 10bdbf: 90 nop (void) rtems_io_initialize( major, 0, NULL ); 10bdc0: 52 push %edx 10bdc1: 6a 00 push $0x0 10bdc3: 6a 00 push $0x0 10bdc5: 53 push %ebx 10bdc6: e8 49 52 00 00 call 111014 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10bdcb: 43 inc %ebx 10bdcc: 83 c4 10 add $0x10,%esp 10bdcf: 39 1d 20 80 12 00 cmp %ebx,0x128020 10bdd5: 77 e9 ja 10bdc0 <_IO_Initialize_all_drivers+0x14> (void) rtems_io_initialize( major, 0, NULL ); } 10bdd7: 8b 5d fc mov -0x4(%ebp),%ebx 10bdda: c9 leave 10bddb: c3 ret =============================================================================== 0010bd14 <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) { 10bd14: 55 push %ebp 10bd15: 89 e5 mov %esp,%ebp 10bd17: 57 push %edi 10bd18: 56 push %esi 10bd19: 53 push %ebx 10bd1a: 83 ec 1c sub $0x1c,%esp uint32_t index; rtems_driver_address_table *driver_table; uint32_t drivers_in_table; uint32_t number_of_drivers; driver_table = Configuration.Device_driver_table; 10bd1d: 8b 1d b8 32 12 00 mov 0x1232b8,%ebx drivers_in_table = Configuration.number_of_device_drivers; 10bd23: a1 b4 32 12 00 mov 0x1232b4,%eax 10bd28: 89 45 e4 mov %eax,-0x1c(%ebp) number_of_drivers = Configuration.maximum_drivers; 10bd2b: 8b 35 b0 32 12 00 mov 0x1232b0,%esi /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 10bd31: 39 f0 cmp %esi,%eax 10bd33: 73 5f jae 10bd94 <_IO_Manager_initialization+0x80> * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) _Workspace_Allocate_or_fatal_error( 10bd35: 8d 0c 76 lea (%esi,%esi,2),%ecx 10bd38: c1 e1 03 shl $0x3,%ecx 10bd3b: 83 ec 0c sub $0xc,%esp 10bd3e: 51 push %ecx 10bd3f: 89 4d dc mov %ecx,-0x24(%ebp) 10bd42: e8 4d 2c 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error> 10bd47: 89 c2 mov %eax,%edx /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 10bd49: a3 24 80 12 00 mov %eax,0x128024 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10bd4e: 89 35 20 80 12 00 mov %esi,0x128020 memset( 10bd54: 31 c0 xor %eax,%eax 10bd56: 8b 4d dc mov -0x24(%ebp),%ecx 10bd59: 89 d7 mov %edx,%edi 10bd5b: f3 aa rep stos %al,%es:(%edi) _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10bd5d: 83 c4 10 add $0x10,%esp 10bd60: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd63: 85 c0 test %eax,%eax 10bd65: 74 25 je 10bd8c <_IO_Manager_initialization+0x78><== NEVER TAKEN 10bd67: a1 24 80 12 00 mov 0x128024,%eax 10bd6c: 89 45 e0 mov %eax,-0x20(%ebp) 10bd6f: 31 c0 xor %eax,%eax 10bd71: 31 d2 xor %edx,%edx 10bd73: 90 nop _IO_Driver_address_table[index] = driver_table[index]; 10bd74: 8b 7d e0 mov -0x20(%ebp),%edi 10bd77: 01 c7 add %eax,%edi 10bd79: 8d 34 03 lea (%ebx,%eax,1),%esi 10bd7c: b9 06 00 00 00 mov $0x6,%ecx 10bd81: f3 a5 rep movsl %ds:(%esi),%es:(%edi) memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10bd83: 42 inc %edx 10bd84: 83 c0 18 add $0x18,%eax 10bd87: 39 55 e4 cmp %edx,-0x1c(%ebp) 10bd8a: 77 e8 ja 10bd74 <_IO_Manager_initialization+0x60> _IO_Driver_address_table[index] = driver_table[index]; } 10bd8c: 8d 65 f4 lea -0xc(%ebp),%esp 10bd8f: 5b pop %ebx 10bd90: 5e pop %esi 10bd91: 5f pop %edi 10bd92: c9 leave 10bd93: c3 ret * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 10bd94: 89 1d 24 80 12 00 mov %ebx,0x128024 _IO_Number_of_drivers = number_of_drivers; 10bd9a: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd9d: a3 20 80 12 00 mov %eax,0x128020 sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; } 10bda2: 8d 65 f4 lea -0xc(%ebp),%esp 10bda5: 5b pop %ebx 10bda6: 5e pop %esi 10bda7: 5f pop %edi 10bda8: c9 leave 10bda9: c3 ret =============================================================================== 0010c8f8 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10c8f8: 55 push %ebp 10c8f9: 89 e5 mov %esp,%ebp 10c8fb: 53 push %ebx 10c8fc: 83 ec 08 sub $0x8,%esp 10c8ff: 8b 45 08 mov 0x8(%ebp),%eax 10c902: 8b 55 0c mov 0xc(%ebp),%edx 10c905: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10c908: a3 50 76 12 00 mov %eax,0x127650 _Internal_errors_What_happened.is_internal = is_internal; 10c90d: 88 15 54 76 12 00 mov %dl,0x127654 _Internal_errors_What_happened.the_error = the_error; 10c913: 89 1d 58 76 12 00 mov %ebx,0x127658 _User_extensions_Fatal( the_source, is_internal, the_error ); 10c919: 53 push %ebx 10c91a: 0f b6 d2 movzbl %dl,%edx 10c91d: 52 push %edx 10c91e: 50 push %eax 10c91f: e8 70 1c 00 00 call 10e594 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10c924: c7 05 40 77 12 00 05 movl $0x5,0x127740 <== NOT EXECUTED 10c92b: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10c92e: fa cli <== NOT EXECUTED 10c92f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c931: f4 hlt <== NOT EXECUTED 10c932: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c935: eb fe jmp 10c935 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 001115ec <_Objects_API_maximum_class>: #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 1115ec: 55 push %ebp 1115ed: 89 e5 mov %esp,%ebp 1115ef: 8b 45 08 mov 0x8(%ebp),%eax 1115f2: 48 dec %eax 1115f3: 83 f8 02 cmp $0x2,%eax 1115f6: 77 0c ja 111604 <_Objects_API_maximum_class+0x18> 1115f8: 8b 04 85 a0 13 12 00 mov 0x1213a0(,%eax,4),%eax case OBJECTS_NO_API: default: break; } return 0; } 1115ff: c9 leave 111600: c3 ret 111601: 8d 76 00 lea 0x0(%esi),%esi #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 111604: 31 c0 xor %eax,%eax case OBJECTS_NO_API: default: break; } return 0; } 111606: c9 leave 111607: c3 ret =============================================================================== 0010c988 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10c988: 55 push %ebp 10c989: 89 e5 mov %esp,%ebp 10c98b: 56 push %esi 10c98c: 53 push %ebx 10c98d: 8b 5d 08 mov 0x8(%ebp),%ebx * 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 ) 10c990: 8b 43 18 mov 0x18(%ebx),%eax 10c993: 85 c0 test %eax,%eax 10c995: 75 0d jne 10c9a4 <_Objects_Allocate+0x1c><== ALWAYS TAKEN return NULL; 10c997: 31 c9 xor %ecx,%ecx ); } #endif return the_object; } 10c999: 89 c8 mov %ecx,%eax 10c99b: 8d 65 f8 lea -0x8(%ebp),%esp 10c99e: 5b pop %ebx 10c99f: 5e pop %esi 10c9a0: c9 leave 10c9a1: c3 ret 10c9a2: 66 90 xchg %ax,%ax /* * 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 ); 10c9a4: 8d 73 20 lea 0x20(%ebx),%esi 10c9a7: 83 ec 0c sub $0xc,%esp 10c9aa: 56 push %esi 10c9ab: e8 68 f6 ff ff call 10c018 <_Chain_Get> 10c9b0: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10c9b2: 83 c4 10 add $0x10,%esp 10c9b5: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10c9b9: 74 de je 10c999 <_Objects_Allocate+0x11> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10c9bb: 85 c0 test %eax,%eax 10c9bd: 74 29 je 10c9e8 <_Objects_Allocate+0x60> } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10c9bf: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10c9c3: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10c9c7: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10c9c9: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10c9cd: 31 d2 xor %edx,%edx 10c9cf: f7 f6 div %esi information->inactive_per_block[ block ]--; 10c9d1: c1 e0 02 shl $0x2,%eax 10c9d4: 03 43 30 add 0x30(%ebx),%eax 10c9d7: ff 08 decl (%eax) information->inactive--; 10c9d9: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10c9dd: 89 c8 mov %ecx,%eax 10c9df: 8d 65 f8 lea -0x8(%ebp),%esp 10c9e2: 5b pop %ebx 10c9e3: 5e pop %esi 10c9e4: c9 leave 10c9e5: c3 ret 10c9e6: 66 90 xchg %ax,%ax * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 10c9e8: 83 ec 0c sub $0xc,%esp 10c9eb: 53 push %ebx 10c9ec: e8 3b 00 00 00 call 10ca2c <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10c9f1: 89 34 24 mov %esi,(%esp) 10c9f4: e8 1f f6 ff ff call 10c018 <_Chain_Get> 10c9f9: 89 c1 mov %eax,%ecx } if ( the_object ) { 10c9fb: 83 c4 10 add $0x10,%esp 10c9fe: 85 c0 test %eax,%eax 10ca00: 74 97 je 10c999 <_Objects_Allocate+0x11> 10ca02: eb bb jmp 10c9bf <_Objects_Allocate+0x37> =============================================================================== 0010ca2c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10ca2c: 55 push %ebp 10ca2d: 89 e5 mov %esp,%ebp 10ca2f: 57 push %edi 10ca30: 56 push %esi 10ca31: 53 push %ebx 10ca32: 83 ec 4c sub $0x4c,%esp 10ca35: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ca38: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10ca3c: 89 45 cc mov %eax,-0x34(%ebp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10ca3f: 8b 4b 34 mov 0x34(%ebx),%ecx 10ca42: 85 c9 test %ecx,%ecx 10ca44: 0f 84 66 02 00 00 je 10ccb0 <_Objects_Extend_information+0x284> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10ca4a: 8b 73 10 mov 0x10(%ebx),%esi 10ca4d: 66 89 75 d0 mov %si,-0x30(%ebp) 10ca51: 8b 7b 14 mov 0x14(%ebx),%edi 10ca54: 89 f0 mov %esi,%eax 10ca56: 31 d2 xor %edx,%edx 10ca58: 66 f7 f7 div %di 10ca5b: 0f b7 f0 movzwl %ax,%esi for ( ; block < block_count; block++ ) { 10ca5e: 85 f6 test %esi,%esi 10ca60: 0f 84 63 02 00 00 je 10ccc9 <_Objects_Extend_information+0x29d><== NEVER TAKEN if ( information->object_blocks[ block ] == NULL ) { 10ca66: 8b 01 mov (%ecx),%eax 10ca68: 85 c0 test %eax,%eax 10ca6a: 0f 84 6b 02 00 00 je 10ccdb <_Objects_Extend_information+0x2af><== NEVER TAKEN 10ca70: 0f b7 ff movzwl %di,%edi /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ca73: 8b 55 cc mov -0x34(%ebp),%edx 10ca76: 89 55 d4 mov %edx,-0x2c(%ebp) index_base = minimum_index; block = 0; 10ca79: 31 d2 xor %edx,%edx 10ca7b: 8b 45 d4 mov -0x2c(%ebp),%eax 10ca7e: eb 0a jmp 10ca8a <_Objects_Extend_information+0x5e> block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { 10ca80: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4) 10ca84: 0f 84 c6 01 00 00 je 10cc50 <_Objects_Extend_information+0x224> do_extend = false; break; } else index_base += information->allocation_size; 10ca8a: 01 f8 add %edi,%eax if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10ca8c: 42 inc %edx 10ca8d: 39 d6 cmp %edx,%esi 10ca8f: 77 ef ja 10ca80 <_Objects_Extend_information+0x54> 10ca91: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10ca94: b1 01 mov $0x1,%cl } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10ca96: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10ca9a: 01 f8 add %edi,%eax 10ca9c: 89 45 d0 mov %eax,-0x30(%ebp) /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 10ca9f: 3d ff ff 00 00 cmp $0xffff,%eax 10caa4: 0f 87 9e 01 00 00 ja 10cc48 <_Objects_Extend_information+0x21c><== NEVER TAKEN /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ block_size = information->allocation_size * information->size; 10caaa: 0f af 7b 18 imul 0x18(%ebx),%edi if ( information->auto_extend ) { 10caae: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10cab2: 0f 84 a4 01 00 00 je 10cc5c <_Objects_Extend_information+0x230> new_object_block = _Workspace_Allocate( block_size ); 10cab8: 83 ec 0c sub $0xc,%esp 10cabb: 57 push %edi 10cabc: 89 55 b8 mov %edx,-0x48(%ebp) 10cabf: 88 4d b4 mov %cl,-0x4c(%ebp) 10cac2: e8 99 1e 00 00 call 10e960 <_Workspace_Allocate> 10cac7: 89 45 c8 mov %eax,-0x38(%ebp) if ( !new_object_block ) 10caca: 83 c4 10 add $0x10,%esp 10cacd: 85 c0 test %eax,%eax 10cacf: 8b 55 b8 mov -0x48(%ebp),%edx 10cad2: 8a 4d b4 mov -0x4c(%ebp),%cl 10cad5: 0f 84 6d 01 00 00 je 10cc48 <_Objects_Extend_information+0x21c> } /* * Do we need to grow the tables? */ if ( do_extend ) { 10cadb: 84 c9 test %cl,%cl 10cadd: 0f 84 ea 00 00 00 je 10cbcd <_Objects_Extend_information+0x1a1> */ /* * Up the block count and maximum */ block_count++; 10cae3: 8d 7e 01 lea 0x1(%esi),%edi * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10cae6: 83 ec 0c sub $0xc,%esp /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10cae9: 8d 04 7f lea (%edi,%edi,2),%eax ((maximum + minimum_index) * sizeof(Objects_Control *)); 10caec: 03 45 d0 add -0x30(%ebp),%eax /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10caef: 03 45 cc add -0x34(%ebp),%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10caf2: c1 e0 02 shl $0x2,%eax (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10caf5: 50 push %eax 10caf6: 89 55 b8 mov %edx,-0x48(%ebp) 10caf9: e8 62 1e 00 00 call 10e960 <_Workspace_Allocate> 10cafe: 89 45 c4 mov %eax,-0x3c(%ebp) if ( !object_blocks ) { 10cb01: 83 c4 10 add $0x10,%esp 10cb04: 85 c0 test %eax,%eax 10cb06: 8b 55 b8 mov -0x48(%ebp),%edx 10cb09: 0f 84 de 01 00 00 je 10cced <_Objects_Extend_information+0x2c1> 10cb0f: 8b 45 c4 mov -0x3c(%ebp),%eax 10cb12: 8d 04 b8 lea (%eax,%edi,4),%eax 10cb15: 89 45 bc mov %eax,-0x44(%ebp) 10cb18: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb1b: 8d 04 f9 lea (%ecx,%edi,8),%eax * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10cb1e: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cb22: 39 4d cc cmp %ecx,-0x34(%ebp) 10cb25: 0f 82 51 01 00 00 jb 10cc7c <_Objects_Extend_information+0x250> } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10cb2b: 8b 4d cc mov -0x34(%ebp),%ecx 10cb2e: 85 c9 test %ecx,%ecx 10cb30: 74 12 je 10cb44 <_Objects_Extend_information+0x118><== NEVER TAKEN 10cb32: 31 c9 xor %ecx,%ecx 10cb34: 8b 7d cc mov -0x34(%ebp),%edi 10cb37: 90 nop local_table[ index ] = NULL; 10cb38: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4) } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10cb3f: 41 inc %ecx 10cb40: 39 cf cmp %ecx,%edi 10cb42: 77 f4 ja 10cb38 <_Objects_Extend_information+0x10c><== NEVER TAKEN 10cb44: c1 e6 02 shl $0x2,%esi 10cb47: 89 75 c0 mov %esi,-0x40(%ebp) } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10cb4a: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb4d: 8b 75 c0 mov -0x40(%ebp),%esi 10cb50: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) inactive_per_block[block_count] = 0; 10cb57: 8b 4d bc mov -0x44(%ebp),%ecx 10cb5a: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10cb61: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10cb65: 03 75 d4 add -0x2c(%ebp),%esi * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10cb68: 39 75 d4 cmp %esi,-0x2c(%ebp) 10cb6b: 73 0f jae 10cb7c <_Objects_Extend_information+0x150><== NEVER TAKEN 10cb6d: 8b 4d d4 mov -0x2c(%ebp),%ecx index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10cb70: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4) object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10cb77: 41 inc %ecx * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10cb78: 39 f1 cmp %esi,%ecx 10cb7a: 72 f4 jb 10cb70 <_Objects_Extend_information+0x144> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10cb7c: 9c pushf 10cb7d: fa cli 10cb7e: 5f pop %edi old_tables = information->object_blocks; 10cb7f: 8b 4b 34 mov 0x34(%ebx),%ecx information->object_blocks = object_blocks; 10cb82: 8b 75 c4 mov -0x3c(%ebp),%esi 10cb85: 89 73 34 mov %esi,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10cb88: 8b 75 bc mov -0x44(%ebp),%esi 10cb8b: 89 73 30 mov %esi,0x30(%ebx) information->local_table = local_table; 10cb8e: 89 43 1c mov %eax,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10cb91: 8b 45 d0 mov -0x30(%ebp),%eax 10cb94: 66 89 43 10 mov %ax,0x10(%ebx) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cb98: 8b 33 mov (%ebx),%esi 10cb9a: c1 e6 18 shl $0x18,%esi 10cb9d: 81 ce 00 00 01 00 or $0x10000,%esi information->maximum_id = _Objects_Build_id( 10cba3: 0f b7 43 04 movzwl 0x4(%ebx),%eax (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cba7: c1 e0 1b shl $0x1b,%eax 10cbaa: 09 c6 or %eax,%esi 10cbac: 0f b7 45 d0 movzwl -0x30(%ebp),%eax uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cbb0: 09 c6 or %eax,%esi 10cbb2: 89 73 0c mov %esi,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10cbb5: 57 push %edi 10cbb6: 9d popf if ( old_tables ) 10cbb7: 85 c9 test %ecx,%ecx 10cbb9: 74 12 je 10cbcd <_Objects_Extend_information+0x1a1> _Workspace_Free( old_tables ); 10cbbb: 83 ec 0c sub $0xc,%esp 10cbbe: 51 push %ecx 10cbbf: 89 55 b8 mov %edx,-0x48(%ebp) 10cbc2: e8 b5 1d 00 00 call 10e97c <_Workspace_Free> 10cbc7: 83 c4 10 add $0x10,%esp 10cbca: 8b 55 b8 mov -0x48(%ebp),%edx } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10cbcd: c1 e2 02 shl $0x2,%edx 10cbd0: 89 55 d0 mov %edx,-0x30(%ebp) 10cbd3: 8b 43 34 mov 0x34(%ebx),%eax 10cbd6: 8b 4d c8 mov -0x38(%ebp),%ecx 10cbd9: 89 0c 10 mov %ecx,(%eax,%edx,1) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10cbdc: ff 73 18 pushl 0x18(%ebx) 10cbdf: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10cbe3: 50 push %eax 10cbe4: 51 push %ecx 10cbe5: 8d 7d dc lea -0x24(%ebp),%edi 10cbe8: 57 push %edi 10cbe9: e8 66 44 00 00 call 111054 <_Chain_Initialize> /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cbee: 83 c4 10 add $0x10,%esp 10cbf1: 8b 75 d4 mov -0x2c(%ebp),%esi information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cbf4: 8d 43 20 lea 0x20(%ebx),%eax 10cbf7: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cbfa: eb 29 jmp 10cc25 <_Objects_Extend_information+0x1f9> 10cbfc: 8b 13 mov (%ebx),%edx 10cbfe: c1 e2 18 shl $0x18,%edx 10cc01: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10cc07: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cc0b: c1 e1 1b shl $0x1b,%ecx 10cc0e: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cc10: 09 f2 or %esi,%edx 10cc12: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cc15: 83 ec 08 sub $0x8,%esp 10cc18: 50 push %eax 10cc19: ff 75 d4 pushl -0x2c(%ebp) 10cc1c: e8 bb f3 ff ff call 10bfdc <_Chain_Append> index++; 10cc21: 46 inc %esi 10cc22: 83 c4 10 add $0x10,%esp /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cc25: 83 ec 0c sub $0xc,%esp 10cc28: 57 push %edi 10cc29: e8 ea f3 ff ff call 10c018 <_Chain_Get> 10cc2e: 83 c4 10 add $0x10,%esp 10cc31: 85 c0 test %eax,%eax 10cc33: 75 c7 jne 10cbfc <_Objects_Extend_information+0x1d0> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10cc35: 8b 43 14 mov 0x14(%ebx),%eax 10cc38: 8b 53 30 mov 0x30(%ebx),%edx 10cc3b: 0f b7 c8 movzwl %ax,%ecx 10cc3e: 8b 75 d0 mov -0x30(%ebp),%esi 10cc41: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10cc44: 66 01 43 2c add %ax,0x2c(%ebx) } 10cc48: 8d 65 f4 lea -0xc(%ebp),%esp 10cc4b: 5b pop %ebx 10cc4c: 5e pop %esi 10cc4d: 5f pop %edi 10cc4e: c9 leave 10cc4f: c3 ret 10cc50: 89 45 d4 mov %eax,-0x2c(%ebp) else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10cc53: 31 c9 xor %ecx,%ecx 10cc55: e9 3c fe ff ff jmp 10ca96 <_Objects_Extend_information+0x6a> 10cc5a: 66 90 xchg %ax,%ax if ( information->auto_extend ) { new_object_block = _Workspace_Allocate( block_size ); if ( !new_object_block ) return; } else { new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 10cc5c: 83 ec 0c sub $0xc,%esp 10cc5f: 57 push %edi 10cc60: 89 55 b8 mov %edx,-0x48(%ebp) 10cc63: 88 4d b4 mov %cl,-0x4c(%ebp) 10cc66: e8 29 1d 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error> 10cc6b: 89 45 c8 mov %eax,-0x38(%ebp) 10cc6e: 83 c4 10 add $0x10,%esp 10cc71: 8a 4d b4 mov -0x4c(%ebp),%cl 10cc74: 8b 55 b8 mov -0x48(%ebp),%edx 10cc77: e9 5f fe ff ff jmp 10cadb <_Objects_Extend_information+0xaf> /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 10cc7c: c1 e6 02 shl $0x2,%esi 10cc7f: 89 75 c0 mov %esi,-0x40(%ebp) 10cc82: 8b 73 34 mov 0x34(%ebx),%esi 10cc85: 8b 7d c4 mov -0x3c(%ebp),%edi 10cc88: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc8b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10cc8d: 8b 73 30 mov 0x30(%ebx),%esi 10cc90: 8b 7d bc mov -0x44(%ebp),%edi 10cc93: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc96: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, information->local_table, (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 10cc98: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cc9c: 03 4d cc add -0x34(%ebp),%ecx information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10cc9f: c1 e1 02 shl $0x2,%ecx 10cca2: 8b 73 1c mov 0x1c(%ebx),%esi 10cca5: 89 c7 mov %eax,%edi 10cca7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10cca9: e9 9c fe ff ff jmp 10cb4a <_Objects_Extend_information+0x11e> 10ccae: 66 90 xchg %ax,%ax minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10ccb0: 8b 53 10 mov 0x10(%ebx),%edx 10ccb3: 66 89 55 d0 mov %dx,-0x30(%ebp) 10ccb7: 0f b7 7b 14 movzwl 0x14(%ebx),%edi /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ccbb: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10ccbe: b1 01 mov $0x1,%cl minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10ccc0: 31 d2 xor %edx,%edx /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10ccc2: 31 f6 xor %esi,%esi 10ccc4: e9 cd fd ff ff jmp 10ca96 <_Objects_Extend_information+0x6a> else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10ccc9: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10cccc: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10cccf: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10ccd2: b1 01 mov $0x1,%cl <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10ccd4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccd6: e9 bb fd ff ff jmp 10ca96 <_Objects_Extend_information+0x6a><== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { 10ccdb: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ccde: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10cce1: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10cce4: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10cce6: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cce8: e9 a9 fd ff ff jmp 10ca96 <_Objects_Extend_information+0x6a><== NOT EXECUTED (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); if ( !object_blocks ) { _Workspace_Free( new_object_block ); 10cced: 83 ec 0c sub $0xc,%esp 10ccf0: ff 75 c8 pushl -0x38(%ebp) 10ccf3: e8 84 1c 00 00 call 10e97c <_Workspace_Free> return; 10ccf8: 83 c4 10 add $0x10,%esp 10ccfb: e9 48 ff ff ff jmp 10cc48 <_Objects_Extend_information+0x21c> =============================================================================== 0010cd90 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10cd90: 55 push %ebp 10cd91: 89 e5 mov %esp,%ebp 10cd93: 56 push %esi 10cd94: 53 push %ebx 10cd95: 8b 75 08 mov 0x8(%ebp),%esi 10cd98: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10cd9b: 66 85 db test %bx,%bx 10cd9e: 75 0c jne 10cdac <_Objects_Get_information+0x1c> the_class_api_maximum = _Objects_API_maximum_class( the_api ); if ( the_class_api_maximum == 0 ) return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; 10cda0: 31 c0 xor %eax,%eax if ( info->maximum == 0 ) return NULL; #endif return info; } 10cda2: 8d 65 f8 lea -0x8(%ebp),%esp 10cda5: 5b pop %ebx 10cda6: 5e pop %esi 10cda7: c9 leave 10cda8: c3 ret 10cda9: 8d 76 00 lea 0x0(%esi),%esi /* * 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 ); 10cdac: 83 ec 0c sub $0xc,%esp 10cdaf: 56 push %esi 10cdb0: e8 37 48 00 00 call 1115ec <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10cdb5: 83 c4 10 add $0x10,%esp 10cdb8: 85 c0 test %eax,%eax 10cdba: 74 e4 je 10cda0 <_Objects_Get_information+0x10> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10cdbc: 0f b7 db movzwl %bx,%ebx 10cdbf: 39 d8 cmp %ebx,%eax 10cdc1: 72 dd jb 10cda0 <_Objects_Get_information+0x10> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10cdc3: 8b 14 b5 48 75 12 00 mov 0x127548(,%esi,4),%edx return NULL; 10cdca: 31 c0 xor %eax,%eax return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10cdcc: 85 d2 test %edx,%edx 10cdce: 74 d2 je 10cda2 <_Objects_Get_information+0x12><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10cdd0: 8b 04 9a mov (%edx,%ebx,4),%eax if ( !info ) 10cdd3: 85 c0 test %eax,%eax 10cdd5: 74 cb je 10cda2 <_Objects_Get_information+0x12><== 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; 10cdd7: 31 d2 xor %edx,%edx 10cdd9: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10cdde: 0f 95 c2 setne %dl 10cde1: f7 da neg %edx 10cde3: 21 d0 and %edx,%eax 10cde5: eb bb jmp 10cda2 <_Objects_Get_information+0x12> =============================================================================== 0010cde8 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10cde8: 55 push %ebp 10cde9: 89 e5 mov %esp,%ebp 10cdeb: 56 push %esi 10cdec: 53 push %ebx 10cded: 8b 55 08 mov 0x8(%ebp),%edx 10cdf0: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 10cdf3: b8 01 00 00 00 mov $0x1,%eax 10cdf8: 2b 42 08 sub 0x8(%edx),%eax 10cdfb: 03 45 0c add 0xc(%ebp),%eax _ISR_Disable( level ); 10cdfe: 9c pushf 10cdff: fa cli 10ce00: 5e pop %esi if ( information->maximum >= index ) { 10ce01: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10ce05: 39 c8 cmp %ecx,%eax 10ce07: 77 1b ja 10ce24 <_Objects_Get_isr_disable+0x3c> if ( (the_object = information->local_table[ index ]) != NULL ) { 10ce09: 8b 52 1c mov 0x1c(%edx),%edx 10ce0c: 8b 04 82 mov (%edx,%eax,4),%eax 10ce0f: 85 c0 test %eax,%eax 10ce11: 74 21 je 10ce34 <_Objects_Get_isr_disable+0x4c> *location = OBJECTS_LOCAL; 10ce13: c7 03 00 00 00 00 movl $0x0,(%ebx) *level_p = level; 10ce19: 8b 55 14 mov 0x14(%ebp),%edx 10ce1c: 89 32 mov %esi,(%edx) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ce1e: 5b pop %ebx 10ce1f: 5e pop %esi 10ce20: c9 leave 10ce21: c3 ret 10ce22: 66 90 xchg %ax,%ax } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10ce24: 56 push %esi 10ce25: 9d popf *location = OBJECTS_ERROR; 10ce26: c7 03 01 00 00 00 movl $0x1,(%ebx) #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; 10ce2c: 31 c0 xor %eax,%eax #endif } 10ce2e: 5b pop %ebx 10ce2f: 5e pop %esi 10ce30: c9 leave 10ce31: c3 ret 10ce32: 66 90 xchg %ax,%ax if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 10ce34: 56 push %esi 10ce35: 9d popf *location = OBJECTS_ERROR; 10ce36: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 10ce3c: eb e0 jmp 10ce1e <_Objects_Get_isr_disable+0x36> =============================================================================== 0010e4d8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 10e4d8: 55 push %ebp 10e4d9: 89 e5 mov %esp,%ebp 10e4db: 57 push %edi 10e4dc: 56 push %esi 10e4dd: 53 push %ebx 10e4de: 83 ec 2c sub $0x2c,%esp 10e4e1: 8b 55 08 mov 0x8(%ebp),%edx 10e4e4: 8b 75 0c mov 0xc(%ebp),%esi 10e4e7: 8b 5d 10 mov 0x10(%ebp),%ebx char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 10e4ea: 85 f6 test %esi,%esi 10e4ec: 75 0e jne 10e4fc <_Objects_Get_name_as_string+0x24> #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 10e4ee: 31 db xor %ebx,%ebx _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 10e4f0: 89 d8 mov %ebx,%eax 10e4f2: 8d 65 f4 lea -0xc(%ebp),%esp 10e4f5: 5b pop %ebx 10e4f6: 5e pop %esi 10e4f7: 5f pop %edi 10e4f8: c9 leave 10e4f9: c3 ret 10e4fa: 66 90 xchg %ax,%ax Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 10e4fc: 85 db test %ebx,%ebx 10e4fe: 74 f0 je 10e4f0 <_Objects_Get_name_as_string+0x18> return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e500: 85 d2 test %edx,%edx 10e502: 75 08 jne 10e50c <_Objects_Get_name_as_string+0x34> 10e504: a1 98 29 13 00 mov 0x132998,%eax 10e509: 8b 50 08 mov 0x8(%eax),%edx information = _Objects_Get_information_id( tmpId ); 10e50c: 83 ec 0c sub $0xc,%esp 10e50f: 52 push %edx 10e510: 89 55 cc mov %edx,-0x34(%ebp) 10e513: e8 f0 fe ff ff call 10e408 <_Objects_Get_information_id> 10e518: 89 c7 mov %eax,%edi if ( !information ) 10e51a: 83 c4 10 add $0x10,%esp 10e51d: 85 c0 test %eax,%eax 10e51f: 8b 55 cc mov -0x34(%ebp),%edx 10e522: 74 ca je 10e4ee <_Objects_Get_name_as_string+0x16> return NULL; the_object = _Objects_Get( information, tmpId, &location ); 10e524: 51 push %ecx 10e525: 8d 45 e4 lea -0x1c(%ebp),%eax 10e528: 50 push %eax 10e529: 52 push %edx 10e52a: 57 push %edi 10e52b: e8 90 00 00 00 call 10e5c0 <_Objects_Get> switch ( location ) { 10e530: 83 c4 10 add $0x10,%esp 10e533: 8b 55 e4 mov -0x1c(%ebp),%edx 10e536: 85 d2 test %edx,%edx 10e538: 75 b4 jne 10e4ee <_Objects_Get_name_as_string+0x16> return NULL; case OBJECTS_LOCAL: #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 10e53a: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10e53e: 74 54 je 10e594 <_Objects_Get_name_as_string+0xbc> s = the_object->name.name_p; 10e540: 8b 78 0c mov 0xc(%eax),%edi lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 10e543: 85 ff test %edi,%edi 10e545: 74 74 je 10e5bb <_Objects_Get_name_as_string+0xe3> for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e547: 4e dec %esi 10e548: 89 75 d4 mov %esi,-0x2c(%ebp) 10e54b: 74 6e je 10e5bb <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN 10e54d: 8a 17 mov (%edi),%dl 10e54f: 84 d2 test %dl,%dl 10e551: 74 68 je 10e5bb <_Objects_Get_name_as_string+0xe3> 10e553: 89 d9 mov %ebx,%ecx 10e555: 31 c0 xor %eax,%eax 10e557: 89 5d d0 mov %ebx,-0x30(%ebp) 10e55a: eb 07 jmp 10e563 <_Objects_Get_name_as_string+0x8b> 10e55c: 8a 14 07 mov (%edi,%eax,1),%dl 10e55f: 84 d2 test %dl,%dl 10e561: 74 21 je 10e584 <_Objects_Get_name_as_string+0xac> *d = (isprint((unsigned char)*s)) ? *s : '*'; 10e563: 0f b6 da movzbl %dl,%ebx 10e566: 8b 35 a8 82 12 00 mov 0x1282a8,%esi 10e56c: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx 10e571: 81 e3 97 00 00 00 and $0x97,%ebx 10e577: 75 02 jne 10e57b <_Objects_Get_name_as_string+0xa3> 10e579: b2 2a mov $0x2a,%dl 10e57b: 88 11 mov %dl,(%ecx) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e57d: 40 inc %eax 10e57e: 41 inc %ecx 10e57f: 3b 45 d4 cmp -0x2c(%ebp),%eax 10e582: 72 d8 jb 10e55c <_Objects_Get_name_as_string+0x84> 10e584: 8b 5d d0 mov -0x30(%ebp),%ebx *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 10e587: c6 01 00 movb $0x0,(%ecx) _Thread_Enable_dispatch(); 10e58a: e8 e5 0a 00 00 call 10f074 <_Thread_Enable_dispatch> return name; 10e58f: e9 5c ff ff ff jmp 10e4f0 <_Objects_Get_name_as_string+0x18> if ( information->is_string ) { s = the_object->name.name_p; } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 10e594: 8b 40 0c mov 0xc(%eax),%eax lname[ 0 ] = (u32_name >> 24) & 0xff; 10e597: 89 c2 mov %eax,%edx 10e599: c1 ea 18 shr $0x18,%edx 10e59c: 88 55 df mov %dl,-0x21(%ebp) lname[ 1 ] = (u32_name >> 16) & 0xff; 10e59f: 89 c2 mov %eax,%edx 10e5a1: c1 ea 10 shr $0x10,%edx 10e5a4: 88 55 e0 mov %dl,-0x20(%ebp) lname[ 2 ] = (u32_name >> 8) & 0xff; 10e5a7: 89 c2 mov %eax,%edx 10e5a9: c1 ea 08 shr $0x8,%edx 10e5ac: 88 55 e1 mov %dl,-0x1f(%ebp) lname[ 3 ] = (u32_name >> 0) & 0xff; 10e5af: 88 45 e2 mov %al,-0x1e(%ebp) lname[ 4 ] = '\0'; 10e5b2: c6 45 e3 00 movb $0x0,-0x1d(%ebp) s = lname; 10e5b6: 8d 7d df lea -0x21(%ebp),%edi 10e5b9: eb 8c jmp 10e547 <_Objects_Get_name_as_string+0x6f> } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10e5bb: 89 d9 mov %ebx,%ecx 10e5bd: eb c8 jmp 10e587 <_Objects_Get_name_as_string+0xaf> =============================================================================== 0010cf98 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 10cf98: 55 push %ebp 10cf99: 89 e5 mov %esp,%ebp 10cf9b: 57 push %edi 10cf9c: 56 push %esi 10cf9d: 53 push %ebx 10cf9e: 83 ec 0c sub $0xc,%esp 10cfa1: 8b 5d 08 mov 0x8(%ebp),%ebx 10cfa4: 8b 75 0c mov 0xc(%ebp),%esi 10cfa7: 8b 7d 10 mov 0x10(%ebp),%edi Objects_Control *object; Objects_Id next_id; if ( !information ) 10cfaa: 85 db test %ebx,%ebx 10cfac: 75 0a jne 10cfb8 <_Objects_Get_next+0x20> if ( !location_p ) return NULL; if ( !next_id_p ) return NULL; 10cfae: 31 c0 xor %eax,%eax return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10cfb0: 8d 65 f4 lea -0xc(%ebp),%esp 10cfb3: 5b pop %ebx 10cfb4: 5e pop %esi 10cfb5: 5f pop %edi 10cfb6: c9 leave 10cfb7: c3 ret Objects_Id next_id; if ( !information ) return NULL; if ( !location_p ) 10cfb8: 85 ff test %edi,%edi 10cfba: 74 f2 je 10cfae <_Objects_Get_next+0x16> return NULL; if ( !next_id_p ) 10cfbc: 8b 45 14 mov 0x14(%ebp),%eax 10cfbf: 85 c0 test %eax,%eax 10cfc1: 74 eb je 10cfae <_Objects_Get_next+0x16> return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 10cfc3: 66 85 f6 test %si,%si 10cfc6: 75 04 jne 10cfcc <_Objects_Get_next+0x34> next_id = information->minimum_id; 10cfc8: 8b 73 08 mov 0x8(%ebx),%esi 10cfcb: 90 nop else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 10cfcc: 66 39 73 10 cmp %si,0x10(%ebx) 10cfd0: 72 22 jb 10cff4 <_Objects_Get_next+0x5c> *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 10cfd2: 51 push %ecx 10cfd3: 57 push %edi 10cfd4: 56 push %esi 10cfd5: 53 push %ebx 10cfd6: e8 2d 00 00 00 call 10d008 <_Objects_Get> next_id++; 10cfdb: 46 inc %esi } while (*location_p != OBJECTS_LOCAL); 10cfdc: 83 c4 10 add $0x10,%esp 10cfdf: 8b 17 mov (%edi),%edx 10cfe1: 85 d2 test %edx,%edx 10cfe3: 75 e7 jne 10cfcc <_Objects_Get_next+0x34> *next_id_p = next_id; 10cfe5: 8b 55 14 mov 0x14(%ebp),%edx 10cfe8: 89 32 mov %esi,(%edx) return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10cfea: 8d 65 f4 lea -0xc(%ebp),%esp 10cfed: 5b pop %ebx 10cfee: 5e pop %esi 10cfef: 5f pop %edi 10cff0: c9 leave 10cff1: c3 ret 10cff2: 66 90 xchg %ax,%ax do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 10cff4: c7 07 01 00 00 00 movl $0x1,(%edi) *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 10cffa: 8b 45 14 mov 0x14(%ebp),%eax 10cffd: c7 00 ff ff ff ff movl $0xffffffff,(%eax) return 0; 10d003: 31 c0 xor %eax,%eax 10d005: eb a9 jmp 10cfb0 <_Objects_Get_next+0x18> =============================================================================== 0011b2a8 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 11b2a8: 55 push %ebp 11b2a9: 89 e5 mov %esp,%ebp 11b2ab: 53 push %ebx 11b2ac: 8b 55 08 mov 0x8(%ebp),%edx 11b2af: 8b 5d 10 mov 0x10(%ebp),%ebx /* * 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; 11b2b2: b8 01 00 00 00 mov $0x1,%eax 11b2b7: 2b 42 08 sub 0x8(%edx),%eax 11b2ba: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 11b2bd: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11b2c1: 39 c8 cmp %ecx,%eax 11b2c3: 77 13 ja 11b2d8 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 11b2c5: 8b 52 1c mov 0x1c(%edx),%edx 11b2c8: 8b 04 82 mov (%edx,%eax,4),%eax 11b2cb: 85 c0 test %eax,%eax 11b2cd: 74 09 je 11b2d8 <_Objects_Get_no_protection+0x30><== NEVER TAKEN *location = OBJECTS_LOCAL; 11b2cf: c7 03 00 00 00 00 movl $0x0,(%ebx) * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; return NULL; } 11b2d5: 5b pop %ebx 11b2d6: c9 leave 11b2d7: c3 ret /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 11b2d8: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 11b2de: 31 c0 xor %eax,%eax } 11b2e0: 5b pop %ebx 11b2e1: c9 leave 11b2e2: c3 ret =============================================================================== 0010e0ec <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10e0ec: 55 push %ebp 10e0ed: 89 e5 mov %esp,%ebp 10e0ef: 83 ec 18 sub $0x18,%esp 10e0f2: 8b 55 08 mov 0x8(%ebp),%edx /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e0f5: 85 d2 test %edx,%edx 10e0f7: 75 08 jne 10e101 <_Objects_Id_to_name+0x15> 10e0f9: a1 78 a7 12 00 mov 0x12a778,%eax 10e0fe: 8b 50 08 mov 0x8(%eax),%edx 10e101: 89 d0 mov %edx,%eax 10e103: c1 e8 18 shr $0x18,%eax 10e106: 83 e0 07 and $0x7,%eax */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 10e109: 8d 48 ff lea -0x1(%eax),%ecx 10e10c: 83 f9 02 cmp $0x2,%ecx 10e10f: 77 1d ja 10e12e <_Objects_Id_to_name+0x42> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10e111: 8b 04 85 68 a1 12 00 mov 0x12a168(,%eax,4),%eax 10e118: 85 c0 test %eax,%eax 10e11a: 74 12 je 10e12e <_Objects_Id_to_name+0x42> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10e11c: 89 d1 mov %edx,%ecx 10e11e: c1 e9 1b shr $0x1b,%ecx return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10e121: 8b 04 88 mov (%eax,%ecx,4),%eax if ( !information ) 10e124: 85 c0 test %eax,%eax 10e126: 74 06 je 10e12e <_Objects_Id_to_name+0x42><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10e128: 80 78 38 00 cmpb $0x0,0x38(%eax) 10e12c: 74 0a je 10e138 <_Objects_Id_to_name+0x4c><== ALWAYS TAKEN the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; 10e12e: b8 03 00 00 00 mov $0x3,%eax return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10e133: c9 leave 10e134: c3 ret 10e135: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10e138: 51 push %ecx 10e139: 8d 4d f4 lea -0xc(%ebp),%ecx 10e13c: 51 push %ecx 10e13d: 52 push %edx 10e13e: 50 push %eax 10e13f: e8 40 ff ff ff call 10e084 <_Objects_Get> if ( !the_object ) 10e144: 83 c4 10 add $0x10,%esp 10e147: 85 c0 test %eax,%eax 10e149: 74 e3 je 10e12e <_Objects_Id_to_name+0x42> return OBJECTS_INVALID_ID; *name = the_object->name; 10e14b: 8b 50 0c mov 0xc(%eax),%edx 10e14e: 8b 45 0c mov 0xc(%ebp),%eax 10e151: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e153: e8 50 0a 00 00 call 10eba8 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10e158: 31 c0 xor %eax,%eax } 10e15a: c9 leave 10e15b: c3 ret =============================================================================== 0010cea8 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10cea8: 55 push %ebp 10cea9: 89 e5 mov %esp,%ebp 10ceab: 57 push %edi 10ceac: 56 push %esi 10cead: 53 push %ebx 10ceae: 83 ec 0c sub $0xc,%esp 10ceb1: 8b 45 08 mov 0x8(%ebp),%eax 10ceb4: 8b 55 0c mov 0xc(%ebp),%edx 10ceb7: 8b 5d 10 mov 0x10(%ebp),%ebx 10ceba: 8b 75 20 mov 0x20(%ebp),%esi 10cebd: 0f b7 7d 18 movzwl 0x18(%ebp),%edi uint32_t maximum_per_allocation; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10cec1: 89 10 mov %edx,(%eax) information->the_class = the_class; 10cec3: 66 89 58 04 mov %bx,0x4(%eax) information->size = size; 10cec7: 89 78 18 mov %edi,0x18(%eax) information->local_table = 0; 10ceca: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) information->inactive_per_block = 0; 10ced1: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) information->object_blocks = 0; 10ced8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) information->inactive = 0; 10cedf: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax) #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) information->is_string = is_string; 10cee5: 8b 7d 1c mov 0x1c(%ebp),%edi 10cee8: 89 f9 mov %edi,%ecx 10ceea: 88 48 38 mov %cl,0x38(%eax) /* * Set the maximum value to 0. It will be updated when objects are * added to the inactive set from _Objects_Extend_information() */ information->maximum = 0; 10ceed: 66 c7 40 10 00 00 movw $0x0,0x10(%eax) /* * Register this Object Class in the Object Information Table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10cef3: 0f b7 db movzwl %bx,%ebx 10cef6: 8b 3c 95 48 75 12 00 mov 0x127548(,%edx,4),%edi 10cefd: 89 04 9f mov %eax,(%edi,%ebx,4) /* * Are we operating in limited or unlimited (e.g. auto-extend) mode. */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; 10cf00: 8b 7d 14 mov 0x14(%ebp),%edi 10cf03: c1 ef 1f shr $0x1f,%edi _Objects_Information_table[ the_api ][ the_class ] = information; /* * Are we operating in limited or unlimited (e.g. auto-extend) mode. */ information->auto_extend = 10cf06: 89 f9 mov %edi,%ecx 10cf08: 88 48 12 mov %cl,0x12(%eax) (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS; 10cf0b: 8b 4d 14 mov 0x14(%ebp),%ecx 10cf0e: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { 10cf14: 85 ff test %edi,%edi 10cf16: 74 04 je 10cf1c <_Objects_Initialize_information+0x74> 10cf18: 85 c9 test %ecx,%ecx 10cf1a: 74 67 je 10cf83 <_Objects_Initialize_information+0xdb><== NEVER TAKEN } /* * The allocation unit is the maximum value */ information->allocation_size = maximum_per_allocation; 10cf1c: 66 89 48 14 mov %cx,0x14(%eax) /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10cf20: c7 40 1c e4 71 12 00 movl $0x1271e4,0x1c(%eax) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cf27: c1 e2 18 shl $0x18,%edx 10cf2a: 81 ca 00 00 01 00 or $0x10000,%edx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10cf30: c1 e3 1b shl $0x1b,%ebx 10cf33: 09 da or %ebx,%edx /* * Calculate minimum and maximum Id's */ minimum_index = (maximum_per_allocation == 0) ? 0 : 1; 10cf35: 31 db xor %ebx,%ebx 10cf37: 85 c9 test %ecx,%ecx 10cf39: 0f 95 c3 setne %bl uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cf3c: 09 da or %ebx,%edx 10cf3e: 89 50 08 mov %edx,0x8(%eax) /* * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10cf41: f7 c6 03 00 00 00 test $0x3,%esi 10cf47: 75 23 jne 10cf6c <_Objects_Initialize_information+0xc4> name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10cf49: 66 89 70 3a mov %si,0x3a(%eax) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10cf4d: 8d 50 24 lea 0x24(%eax),%edx 10cf50: 89 50 20 mov %edx,0x20(%eax) head->next = tail; head->previous = NULL; 10cf53: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10cf5a: 8d 50 20 lea 0x20(%eax),%edx 10cf5d: 89 50 28 mov %edx,0x28(%eax) _Chain_Initialize_empty( &information->Inactive ); /* * Initialize objects .. if there are any */ if ( maximum_per_allocation ) { 10cf60: 85 c9 test %ecx,%ecx 10cf62: 75 10 jne 10cf74 <_Objects_Initialize_information+0xcc> _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10cf64: 8d 65 f4 lea -0xc(%ebp),%esp 10cf67: 5b pop %ebx 10cf68: 5e pop %esi 10cf69: 5f pop %edi 10cf6a: c9 leave 10cf6b: c3 ret * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10cf6c: 83 c6 04 add $0x4,%esi 10cf6f: 83 e6 fc and $0xfffffffc,%esi 10cf72: eb d5 jmp 10cf49 <_Objects_Initialize_information+0xa1> /* * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10cf74: 89 45 08 mov %eax,0x8(%ebp) _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10cf77: 8d 65 f4 lea -0xc(%ebp),%esp 10cf7a: 5b pop %ebx 10cf7b: 5e pop %esi 10cf7c: 5f pop %edi 10cf7d: c9 leave /* * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10cf7e: e9 a9 fa ff ff jmp 10ca2c <_Objects_Extend_information> /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { _Internal_error_Occurred( 10cf83: 50 push %eax 10cf84: 6a 13 push $0x13 10cf86: 6a 01 push $0x1 10cf88: 6a 00 push $0x0 10cf8a: e8 69 f9 ff ff call 10c8f8 <_Internal_error_Occurred> =============================================================================== 00117964 <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 117964: 55 push %ebp 117965: 89 e5 mov %esp,%ebp 117967: 57 push %edi 117968: 56 push %esi 117969: 53 push %ebx 11796a: 83 ec 1c sub $0x1c,%esp 11796d: 8b 7d 08 mov 0x8(%ebp),%edi Objects_Control *the_object; uint32_t index; /* ASSERT: information->is_string == true */ if ( !id ) 117970: 8b 5d 10 mov 0x10(%ebp),%ebx 117973: 85 db test %ebx,%ebx 117975: 74 75 je 1179ec <_Objects_Name_to_id_string+0x88> return OBJECTS_INVALID_ADDRESS; if ( !name ) 117977: 8b 4d 0c mov 0xc(%ebp),%ecx 11797a: 85 c9 test %ecx,%ecx 11797c: 74 4b je 1179c9 <_Objects_Name_to_id_string+0x65> return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 11797e: 8b 47 10 mov 0x10(%edi),%eax 117981: 66 85 c0 test %ax,%ax 117984: 74 43 je 1179c9 <_Objects_Name_to_id_string+0x65> for ( index = 1; index <= information->maximum; index++ ) { 117986: 0f b7 c0 movzwl %ax,%eax 117989: 89 45 e4 mov %eax,-0x1c(%ebp) 11798c: 8b 47 1c mov 0x1c(%edi),%eax 11798f: bb 01 00 00 00 mov $0x1,%ebx 117994: 89 7d e0 mov %edi,-0x20(%ebp) 117997: 89 c7 mov %eax,%edi 117999: 8d 76 00 lea 0x0(%esi),%esi the_object = information->local_table[ index ]; 11799c: 8b 34 9f mov (%edi,%ebx,4),%esi if ( !the_object ) 11799f: 85 f6 test %esi,%esi 1179a1: 74 20 je 1179c3 <_Objects_Name_to_id_string+0x5f> continue; if ( !the_object->name.name_p ) 1179a3: 8b 46 0c mov 0xc(%esi),%eax 1179a6: 85 c0 test %eax,%eax 1179a8: 74 19 je 1179c3 <_Objects_Name_to_id_string+0x5f> continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 1179aa: 52 push %edx 1179ab: 8b 4d e0 mov -0x20(%ebp),%ecx 1179ae: 0f b7 51 3a movzwl 0x3a(%ecx),%edx 1179b2: 52 push %edx 1179b3: 50 push %eax 1179b4: ff 75 0c pushl 0xc(%ebp) 1179b7: e8 70 35 00 00 call 11af2c 1179bc: 83 c4 10 add $0x10,%esp 1179bf: 85 c0 test %eax,%eax 1179c1: 74 15 je 1179d8 <_Objects_Name_to_id_string+0x74> if ( !name ) return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { for ( index = 1; index <= information->maximum; index++ ) { 1179c3: 43 inc %ebx 1179c4: 3b 5d e4 cmp -0x1c(%ebp),%ebx 1179c7: 76 d3 jbe 11799c <_Objects_Name_to_id_string+0x38> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } } } return OBJECTS_INVALID_NAME; 1179c9: b8 01 00 00 00 mov $0x1,%eax } 1179ce: 8d 65 f4 lea -0xc(%ebp),%esp 1179d1: 5b pop %ebx 1179d2: 5e pop %esi 1179d3: 5f pop %edi 1179d4: c9 leave 1179d5: c3 ret 1179d6: 66 90 xchg %ax,%ax if ( !the_object->name.name_p ) continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { *id = the_object->id; 1179d8: 8b 46 08 mov 0x8(%esi),%eax 1179db: 8b 55 10 mov 0x10(%ebp),%edx 1179de: 89 02 mov %eax,(%edx) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 1179e0: 31 c0 xor %eax,%eax } } } return OBJECTS_INVALID_NAME; } 1179e2: 8d 65 f4 lea -0xc(%ebp),%esp 1179e5: 5b pop %ebx 1179e6: 5e pop %esi 1179e7: 5f pop %edi 1179e8: c9 leave 1179e9: c3 ret 1179ea: 66 90 xchg %ax,%ax uint32_t index; /* ASSERT: information->is_string == true */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 1179ec: b8 02 00 00 00 mov $0x2,%eax } } } return OBJECTS_INVALID_NAME; } 1179f1: 8d 65 f4 lea -0xc(%ebp),%esp 1179f4: 5b pop %ebx 1179f5: 5e pop %esi 1179f6: 5f pop %edi 1179f7: c9 leave 1179f8: c3 ret =============================================================================== 0010cfc4 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10cfc4: 55 push %ebp 10cfc5: 89 e5 mov %esp,%ebp 10cfc7: 57 push %edi 10cfc8: 56 push %esi 10cfc9: 53 push %ebx 10cfca: 8b 45 08 mov 0x8(%ebp),%eax 10cfcd: 8b 4d 0c mov 0xc(%ebp),%ecx 10cfd0: 8b 55 10 mov 0x10(%ebp),%edx 10cfd3: 8b 7d 14 mov 0x14(%ebp),%edi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 10cfd6: 85 ff test %edi,%edi 10cfd8: 74 56 je 10d030 <_Objects_Name_to_id_u32+0x6c> return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10cfda: 85 c9 test %ecx,%ecx 10cfdc: 74 08 je 10cfe6 <_Objects_Name_to_id_u32+0x22> return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10cfde: 8b 70 10 mov 0x10(%eax),%esi 10cfe1: 66 85 f6 test %si,%si 10cfe4: 75 0a jne 10cff0 <_Objects_Name_to_id_u32+0x2c> return OBJECTS_INVALID_NAME; name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; 10cfe6: b8 01 00 00 00 mov $0x1,%eax #endif } 10cfeb: 5b pop %ebx 10cfec: 5e pop %esi 10cfed: 5f pop %edi 10cfee: c9 leave 10cfef: c3 ret if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10cff0: 85 d2 test %edx,%edx 10cff2: 75 20 jne 10d014 <_Objects_Name_to_id_u32+0x50> _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 10cff4: 0f b7 f6 movzwl %si,%esi 10cff7: 8b 58 1c mov 0x1c(%eax),%ebx 10cffa: b8 01 00 00 00 mov $0x1,%eax 10cfff: 90 nop the_object = information->local_table[ index ]; 10d000: 8b 14 83 mov (%ebx,%eax,4),%edx if ( !the_object ) 10d003: 85 d2 test %edx,%edx 10d005: 74 05 je 10d00c <_Objects_Name_to_id_u32+0x48> continue; if ( name == the_object->name.name_u32 ) { 10d007: 39 4a 0c cmp %ecx,0xc(%edx) 10d00a: 74 18 je 10d024 <_Objects_Name_to_id_u32+0x60> _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 10d00c: 40 inc %eax 10d00d: 39 c6 cmp %eax,%esi 10d00f: 73 ef jae 10d000 <_Objects_Name_to_id_u32+0x3c> 10d011: eb d3 jmp 10cfe6 <_Objects_Name_to_id_u32+0x22> 10d013: 90 nop return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && (node == OBJECTS_SEARCH_ALL_NODES || 10d014: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10d01a: 74 d8 je 10cff4 <_Objects_Name_to_id_u32+0x30> node == OBJECTS_SEARCH_LOCAL_NODE || 10d01c: 4a dec %edx 10d01d: 75 c7 jne 10cfe6 <_Objects_Name_to_id_u32+0x22> 10d01f: eb d3 jmp 10cff4 <_Objects_Name_to_id_u32+0x30> 10d021: 8d 76 00 lea 0x0(%esi),%esi the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 10d024: 8b 42 08 mov 0x8(%edx),%eax 10d027: 89 07 mov %eax,(%edi) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10d029: 31 c0 xor %eax,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10d02b: 5b pop %ebx 10d02c: 5e pop %esi 10d02d: 5f pop %edi 10d02e: c9 leave 10d02f: c3 ret #endif /* ASSERT: information->is_string == false */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 10d030: b8 02 00 00 00 mov $0x2,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10d035: 5b pop %ebx 10d036: 5e pop %esi 10d037: 5f pop %edi 10d038: c9 leave 10d039: c3 ret =============================================================================== 0010d6ac <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10d6ac: 55 push %ebp 10d6ad: 89 e5 mov %esp,%ebp 10d6af: 57 push %edi 10d6b0: 56 push %esi 10d6b1: 53 push %ebx 10d6b2: 83 ec 14 sub $0x14,%esp 10d6b5: 8b 7d 08 mov 0x8(%ebp),%edi 10d6b8: 8b 5d 10 mov 0x10(%ebp),%ebx size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 10d6bb: 0f b7 47 3a movzwl 0x3a(%edi),%eax 10d6bf: 50 push %eax 10d6c0: 53 push %ebx 10d6c1: e8 22 7a 00 00 call 1150e8 10d6c6: 89 c6 mov %eax,%esi #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 10d6c8: 83 c4 10 add $0x10,%esp 10d6cb: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10d6cf: 75 57 jne 10d728 <_Objects_Set_name+0x7c> d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d6d1: 0f be 13 movsbl (%ebx),%edx 10d6d4: c1 e2 18 shl $0x18,%edx 10d6d7: 83 f8 01 cmp $0x1,%eax 10d6da: 76 38 jbe 10d714 <_Objects_Set_name+0x68> 10d6dc: 0f be 43 01 movsbl 0x1(%ebx),%eax 10d6e0: c1 e0 10 shl $0x10,%eax 10d6e3: 09 d0 or %edx,%eax 10d6e5: 83 fe 02 cmp $0x2,%esi 10d6e8: 74 31 je 10d71b <_Objects_Set_name+0x6f> 10d6ea: 0f be 53 02 movsbl 0x2(%ebx),%edx 10d6ee: c1 e2 08 shl $0x8,%edx 10d6f1: 09 c2 or %eax,%edx 10d6f3: 83 fe 03 cmp $0x3,%esi 10d6f6: 0f 84 88 00 00 00 je 10d784 <_Objects_Set_name+0xd8> 10d6fc: 0f be 43 03 movsbl 0x3(%ebx),%eax 10d700: 09 c2 or %eax,%edx 10d702: 8b 45 0c mov 0xc(%ebp),%eax 10d705: 89 50 0c mov %edx,0xc(%eax) ((3 < length) ? s[ 3 ] : ' ') ); } return true; 10d708: b0 01 mov $0x1,%al } 10d70a: 8d 65 f4 lea -0xc(%ebp),%esp 10d70d: 5b pop %ebx 10d70e: 5e pop %esi 10d70f: 5f pop %edi 10d710: c9 leave 10d711: c3 ret 10d712: 66 90 xchg %ax,%ax d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d714: 89 d0 mov %edx,%eax 10d716: 0d 00 00 20 00 or $0x200000,%eax 10d71b: 89 c2 mov %eax,%edx 10d71d: 80 ce 20 or $0x20,%dh 10d720: b8 20 00 00 00 mov $0x20,%eax 10d725: eb d9 jmp 10d700 <_Objects_Set_name+0x54> 10d727: 90 nop #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { char *d; d = _Workspace_Allocate( length + 1 ); 10d728: 83 ec 0c sub $0xc,%esp 10d72b: 8d 40 01 lea 0x1(%eax),%eax 10d72e: 50 push %eax 10d72f: e8 80 19 00 00 call 10f0b4 <_Workspace_Allocate> 10d734: 89 c7 mov %eax,%edi if ( !d ) 10d736: 83 c4 10 add $0x10,%esp 10d739: 85 c0 test %eax,%eax 10d73b: 74 43 je 10d780 <_Objects_Set_name+0xd4> return false; if ( the_object->name.name_p ) { 10d73d: 8b 55 0c mov 0xc(%ebp),%edx 10d740: 8b 42 0c mov 0xc(%edx),%eax 10d743: 85 c0 test %eax,%eax 10d745: 74 16 je 10d75d <_Objects_Set_name+0xb1> _Workspace_Free( (void *)the_object->name.name_p ); 10d747: 83 ec 0c sub $0xc,%esp 10d74a: 50 push %eax 10d74b: e8 80 19 00 00 call 10f0d0 <_Workspace_Free> the_object->name.name_p = NULL; 10d750: 8b 45 0c mov 0xc(%ebp),%eax 10d753: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 10d75a: 83 c4 10 add $0x10,%esp } strncpy( d, name, length ); 10d75d: 50 push %eax 10d75e: 56 push %esi 10d75f: 53 push %ebx 10d760: 57 push %edi 10d761: e8 06 79 00 00 call 11506c d[length] = '\0'; 10d766: c6 04 37 00 movb $0x0,(%edi,%esi,1) the_object->name.name_p = d; 10d76a: 8b 55 0c mov 0xc(%ebp),%edx 10d76d: 89 7a 0c mov %edi,0xc(%edx) 10d770: 83 c4 10 add $0x10,%esp ((3 < length) ? s[ 3 ] : ' ') ); } return true; 10d773: b0 01 mov $0x1,%al } 10d775: 8d 65 f4 lea -0xc(%ebp),%esp 10d778: 5b pop %ebx 10d779: 5e pop %esi 10d77a: 5f pop %edi 10d77b: c9 leave 10d77c: c3 ret 10d77d: 8d 76 00 lea 0x0(%esi),%esi if ( information->is_string ) { char *d; d = _Workspace_Allocate( length + 1 ); if ( !d ) return false; 10d780: 31 c0 xor %eax,%eax 10d782: eb 86 jmp 10d70a <_Objects_Set_name+0x5e> d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10d784: b8 20 00 00 00 mov $0x20,%eax 10d789: e9 72 ff ff ff jmp 10d700 <_Objects_Set_name+0x54> =============================================================================== 0010d03c <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10d03c: 55 push %ebp 10d03d: 89 e5 mov %esp,%ebp 10d03f: 57 push %edi 10d040: 56 push %esi 10d041: 53 push %ebx 10d042: 83 ec 1c sub $0x1c,%esp /* * Search the list to find block or chunk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); 10d045: 8b 45 08 mov 0x8(%ebp),%eax 10d048: 0f b7 58 08 movzwl 0x8(%eax),%ebx block_count = (information->maximum - index_base) / 10d04c: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10d050: 0f b7 40 10 movzwl 0x10(%eax),%eax 10d054: 29 d8 sub %ebx,%eax 10d056: 31 d2 xor %edx,%edx 10d058: f7 f1 div %ecx information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d05a: 85 c0 test %eax,%eax 10d05c: 74 21 je 10d07f <_Objects_Shrink_information+0x43><== NEVER TAKEN if ( information->inactive_per_block[ block ] == 10d05e: 8b 55 08 mov 0x8(%ebp),%edx 10d061: 8b 7a 30 mov 0x30(%edx),%edi 10d064: 3b 0f cmp (%edi),%ecx 10d066: 74 1f je 10d087 <_Objects_Shrink_information+0x4b><== NEVER TAKEN 10d068: 31 d2 xor %edx,%edx 10d06a: eb 0e jmp 10d07a <_Objects_Shrink_information+0x3e> information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 10d06c: 01 cb add %ecx,%ebx 10d06e: 8d 34 95 00 00 00 00 lea 0x0(,%edx,4),%esi index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10d075: 3b 0c 97 cmp (%edi,%edx,4),%ecx 10d078: 74 12 je 10d08c <_Objects_Shrink_information+0x50> index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d07a: 42 inc %edx 10d07b: 39 d0 cmp %edx,%eax 10d07d: 77 ed ja 10d06c <_Objects_Shrink_information+0x30> return; } index_base += information->allocation_size; } } 10d07f: 8d 65 f4 lea -0xc(%ebp),%esp 10d082: 5b pop %ebx 10d083: 5e pop %esi 10d084: 5f pop %edi 10d085: c9 leave 10d086: c3 ret index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10d087: 31 f6 xor %esi,%esi 10d089: 8d 76 00 lea 0x0(%esi),%esi information->allocation_size ) { /* * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); 10d08c: 8b 55 08 mov 0x8(%ebp),%edx 10d08f: 8b 42 20 mov 0x20(%edx),%eax 10d092: 89 75 e4 mov %esi,-0x1c(%ebp) 10d095: eb 07 jmp 10d09e <_Objects_Shrink_information+0x62> 10d097: 90 nop if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 10d098: 85 ff test %edi,%edi 10d09a: 74 2c je 10d0c8 <_Objects_Shrink_information+0x8c> index = _Objects_Get_index( the_object->id ); /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d09c: 89 f8 mov %edi,%eax * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); do { index = _Objects_Get_index( the_object->id ); 10d09e: 0f b7 50 08 movzwl 0x8(%eax),%edx /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d0a2: 8b 38 mov (%eax),%edi if ((index >= index_base) && 10d0a4: 39 da cmp %ebx,%edx 10d0a6: 72 f0 jb 10d098 <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { 10d0a8: 8b 75 08 mov 0x8(%ebp),%esi 10d0ab: 0f b7 4e 14 movzwl 0x14(%esi),%ecx 10d0af: 8d 0c 0b lea (%ebx,%ecx,1),%ecx /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; if ((index >= index_base) && 10d0b2: 39 ca cmp %ecx,%edx 10d0b4: 73 e2 jae 10d098 <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); 10d0b6: 83 ec 0c sub $0xc,%esp 10d0b9: 50 push %eax 10d0ba: e8 41 ef ff ff call 10c000 <_Chain_Extract> 10d0bf: 83 c4 10 add $0x10,%esp } } while ( the_object ); 10d0c2: 85 ff test %edi,%edi 10d0c4: 75 d6 jne 10d09c <_Objects_Shrink_information+0x60> 10d0c6: 66 90 xchg %ax,%ax 10d0c8: 8b 75 e4 mov -0x1c(%ebp),%esi /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10d0cb: 83 ec 0c sub $0xc,%esp 10d0ce: 8b 55 08 mov 0x8(%ebp),%edx 10d0d1: 8b 42 34 mov 0x34(%edx),%eax 10d0d4: ff 34 30 pushl (%eax,%esi,1) 10d0d7: e8 a0 18 00 00 call 10e97c <_Workspace_Free> information->object_blocks[ block ] = NULL; 10d0dc: 8b 55 08 mov 0x8(%ebp),%edx 10d0df: 8b 42 34 mov 0x34(%edx),%eax 10d0e2: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1) information->inactive_per_block[ block ] = 0; 10d0e9: 8b 42 30 mov 0x30(%edx),%eax 10d0ec: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1) information->inactive -= information->allocation_size; 10d0f3: 8b 42 14 mov 0x14(%edx),%eax 10d0f6: 66 29 42 2c sub %ax,0x2c(%edx) return; 10d0fa: 83 c4 10 add $0x10,%esp } index_base += information->allocation_size; } } 10d0fd: 8d 65 f4 lea -0xc(%ebp),%esp 10d100: 5b pop %ebx 10d101: 5e pop %esi 10d102: 5f pop %edi 10d103: c9 leave 10d104: c3 ret =============================================================================== 0010d524 <_POSIX_Absolute_timeout_to_ticks>: */ POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks( const struct timespec *abstime, Watchdog_Interval *ticks_out ) { 10d524: 55 push %ebp 10d525: 89 e5 mov %esp,%ebp 10d527: 57 push %edi 10d528: 56 push %esi 10d529: 53 push %ebx 10d52a: 83 ec 38 sub $0x38,%esp 10d52d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d530: 8b 75 0c mov 0xc(%ebp),%esi /* * Make sure there is always a value returned. */ *ticks_out = 0; 10d533: c7 06 00 00 00 00 movl $0x0,(%esi) /* * Is the absolute time even valid? */ if ( !_Timespec_Is_valid(abstime) ) 10d539: 53 push %ebx 10d53a: e8 99 3d 00 00 call 1112d8 <_Timespec_Is_valid> 10d53f: 83 c4 10 add $0x10,%esp 10d542: 84 c0 test %al,%al 10d544: 75 0a jne 10d550 <_POSIX_Absolute_timeout_to_ticks+0x2c> return POSIX_ABSOLUTE_TIMEOUT_INVALID; 10d546: 31 c0 xor %eax,%eax /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10d548: 8d 65 f4 lea -0xc(%ebp),%esp 10d54b: 5b pop %ebx 10d54c: 5e pop %esi 10d54d: 5f pop %edi 10d54e: c9 leave 10d54f: c3 ret return POSIX_ABSOLUTE_TIMEOUT_INVALID; /* * Is the absolute time in the past? */ _TOD_Get( ¤t_time ); 10d550: 83 ec 0c sub $0xc,%esp 10d553: 8d 7d e0 lea -0x20(%ebp),%edi 10d556: 57 push %edi 10d557: e8 88 1d 00 00 call 10f2e4 <_TOD_Get> if ( _Timespec_Less_than( abstime, ¤t_time ) ) 10d55c: 5a pop %edx 10d55d: 59 pop %ecx 10d55e: 57 push %edi 10d55f: 53 push %ebx 10d560: e8 9b 3d 00 00 call 111300 <_Timespec_Less_than> 10d565: 83 c4 10 add $0x10,%esp 10d568: 84 c0 test %al,%al 10d56a: 74 10 je 10d57c <_POSIX_Absolute_timeout_to_ticks+0x58> return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; 10d56c: b8 01 00 00 00 mov $0x1,%eax /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10d571: 8d 65 f4 lea -0xc(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: 5f pop %edi 10d577: c9 leave 10d578: c3 ret 10d579: 8d 76 00 lea 0x0(%esi),%esi return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; /* * How long until the requested absolute time? */ _Timespec_Subtract( ¤t_time, abstime, &difference ); 10d57c: 50 push %eax 10d57d: 8d 45 d8 lea -0x28(%ebp),%eax 10d580: 50 push %eax 10d581: 53 push %ebx 10d582: 57 push %edi 10d583: 89 45 d4 mov %eax,-0x2c(%ebp) 10d586: e8 99 3d 00 00 call 111324 <_Timespec_Subtract> /* * Internally the SuperCore uses ticks, so convert to them. */ *ticks_out = _Timespec_To_ticks( &difference ); 10d58b: 8b 45 d4 mov -0x2c(%ebp),%eax 10d58e: 89 04 24 mov %eax,(%esp) 10d591: e8 ce 3d 00 00 call 111364 <_Timespec_To_ticks> 10d596: 89 06 mov %eax,(%esi) /* * If the difference was 0, then the future is now. It is so bright * we better wear shades. */ if ( !*ticks_out ) 10d598: 83 c4 10 add $0x10,%esp return POSIX_ABSOLUTE_TIMEOUT_IS_NOW; 10d59b: 83 f8 01 cmp $0x1,%eax 10d59e: 19 c0 sbb %eax,%eax 10d5a0: 83 c0 03 add $0x3,%eax /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10d5a3: 8d 65 f4 lea -0xc(%ebp),%esp 10d5a6: 5b pop %ebx 10d5a7: 5e pop %esi 10d5a8: 5f pop %edi 10d5a9: c9 leave 10d5aa: c3 ret =============================================================================== 0010c0cc <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 10c0cc: 55 push %ebp 10c0cd: 89 e5 mov %esp,%ebp 10c0cf: 56 push %esi 10c0d0: 53 push %ebx 10c0d1: 8b 5d 08 mov 0x8(%ebp),%ebx 10c0d4: 8b 75 0c mov 0xc(%ebp),%esi int status; if ( !cond ) { 10c0d7: 85 db test %ebx,%ebx 10c0d9: 74 39 je 10c114 <_POSIX_Condition_variables_Get+0x48> *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *cond == PTHREAD_COND_INITIALIZER ) { 10c0db: 8b 03 mov (%ebx),%eax 10c0dd: 83 f8 ff cmp $0xffffffff,%eax 10c0e0: 74 1a je 10c0fc <_POSIX_Condition_variables_Get+0x30> } /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *)_Objects_Get( 10c0e2: 52 push %edx 10c0e3: 56 push %esi 10c0e4: 50 push %eax 10c0e5: 68 c0 a1 12 00 push $0x12a1c0 10c0ea: e8 7d 2b 00 00 call 10ec6c <_Objects_Get> 10c0ef: 83 c4 10 add $0x10,%esp &_POSIX_Condition_variables_Information, (Objects_Id) *cond, location ); } 10c0f2: 8d 65 f8 lea -0x8(%ebp),%esp 10c0f5: 5b pop %ebx 10c0f6: 5e pop %esi 10c0f7: c9 leave 10c0f8: c3 ret 10c0f9: 8d 76 00 lea 0x0(%esi),%esi if ( *cond == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( cond, 0 ); 10c0fc: 83 ec 08 sub $0x8,%esp 10c0ff: 6a 00 push $0x0 10c101: 53 push %ebx 10c102: e8 19 00 00 00 call 10c120 if ( status ) { 10c107: 83 c4 10 add $0x10,%esp 10c10a: 85 c0 test %eax,%eax 10c10c: 75 06 jne 10c114 <_POSIX_Condition_variables_Get+0x48> 10c10e: 8b 03 mov (%ebx),%eax 10c110: eb d0 jmp 10c0e2 <_POSIX_Condition_variables_Get+0x16> 10c112: 66 90 xchg %ax,%ax *location = OBJECTS_ERROR; 10c114: c7 06 01 00 00 00 movl $0x1,(%esi) return (POSIX_Condition_variables_Control *) 0; 10c11a: 31 c0 xor %eax,%eax 10c11c: eb d4 jmp 10c0f2 <_POSIX_Condition_variables_Get+0x26> =============================================================================== 0010c1e8 <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, bool is_broadcast ) { 10c1e8: 55 push %ebp 10c1e9: 89 e5 mov %esp,%ebp 10c1eb: 57 push %edi 10c1ec: 56 push %esi 10c1ed: 53 push %ebx 10c1ee: 83 ec 24 sub $0x24,%esp 10c1f1: 8a 5d 0c mov 0xc(%ebp),%bl register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10c1f4: 8d 45 e4 lea -0x1c(%ebp),%eax 10c1f7: 50 push %eax 10c1f8: ff 75 08 pushl 0x8(%ebp) 10c1fb: e8 cc fe ff ff call 10c0cc <_POSIX_Condition_variables_Get> 10c200: 89 c7 mov %eax,%edi switch ( location ) { 10c202: 83 c4 10 add $0x10,%esp 10c205: 8b 45 e4 mov -0x1c(%ebp),%eax 10c208: 85 c0 test %eax,%eax 10c20a: 74 10 je 10c21c <_POSIX_Condition_variables_Signal_support+0x34> #endif case OBJECTS_ERROR: break; } return EINVAL; 10c20c: b8 16 00 00 00 mov $0x16,%eax } 10c211: 8d 65 f4 lea -0xc(%ebp),%esp 10c214: 5b pop %ebx 10c215: 5e pop %esi 10c216: 5f pop %edi 10c217: c9 leave 10c218: c3 ret 10c219: 8d 76 00 lea 0x0(%esi),%esi 10c21c: 8d 77 18 lea 0x18(%edi),%esi 10c21f: eb 0b jmp 10c22c <_POSIX_Condition_variables_Signal_support+0x44> 10c221: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); if ( !the_thread ) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 10c224: 84 db test %bl,%bl 10c226: 74 20 je 10c248 <_POSIX_Condition_variables_Signal_support+0x60> 10c228: 85 c0 test %eax,%eax 10c22a: 74 1c je 10c248 <_POSIX_Condition_variables_Signal_support+0x60> the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 10c22c: 83 ec 0c sub $0xc,%esp 10c22f: 56 push %esi 10c230: e8 9f 38 00 00 call 10fad4 <_Thread_queue_Dequeue> if ( !the_thread ) 10c235: 83 c4 10 add $0x10,%esp 10c238: 85 c0 test %eax,%eax 10c23a: 75 e8 jne 10c224 <_POSIX_Condition_variables_Signal_support+0x3c> the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10c23c: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi) } while ( is_broadcast && the_thread ); 10c243: 84 db test %bl,%bl 10c245: 75 e1 jne 10c228 <_POSIX_Condition_variables_Signal_support+0x40> 10c247: 90 nop _Thread_Enable_dispatch(); 10c248: e8 d3 34 00 00 call 10f720 <_Thread_Enable_dispatch> return 0; 10c24d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c24f: 8d 65 f4 lea -0xc(%ebp),%esp 10c252: 5b pop %ebx 10c253: 5e pop %esi 10c254: 5f pop %edi 10c255: c9 leave 10c256: c3 ret =============================================================================== 0010c2b0 <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 10c2b0: 55 push %ebp 10c2b1: 89 e5 mov %esp,%ebp 10c2b3: 57 push %edi 10c2b4: 56 push %esi 10c2b5: 53 push %ebx 10c2b6: 83 ec 34 sub $0x34,%esp 10c2b9: 8b 7d 08 mov 0x8(%ebp),%edi 10c2bc: 8b 5d 0c mov 0xc(%ebp),%ebx 10c2bf: 8a 45 14 mov 0x14(%ebp),%al 10c2c2: 88 45 d7 mov %al,-0x29(%ebp) register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 10c2c5: 8d 75 e4 lea -0x1c(%ebp),%esi 10c2c8: 56 push %esi 10c2c9: 53 push %ebx 10c2ca: e8 59 01 00 00 call 10c428 <_POSIX_Mutex_Get> 10c2cf: 83 c4 10 add $0x10,%esp 10c2d2: 85 c0 test %eax,%eax 10c2d4: 74 21 je 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c2d6: a1 d0 9c 12 00 mov 0x129cd0,%eax 10c2db: 48 dec %eax 10c2dc: a3 d0 9c 12 00 mov %eax,0x129cd0 return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10c2e1: 83 ec 08 sub $0x8,%esp 10c2e4: 56 push %esi 10c2e5: 57 push %edi 10c2e6: e8 e1 fd ff ff call 10c0cc <_POSIX_Condition_variables_Get> 10c2eb: 89 c6 mov %eax,%esi switch ( location ) { 10c2ed: 83 c4 10 add $0x10,%esp 10c2f0: 8b 55 e4 mov -0x1c(%ebp),%edx 10c2f3: 85 d2 test %edx,%edx 10c2f5: 74 11 je 10c308 <_POSIX_Condition_variables_Wait_support+0x58> #endif case OBJECTS_ERROR: break; } return EINVAL; 10c2f7: be 16 00 00 00 mov $0x16,%esi } 10c2fc: 89 f0 mov %esi,%eax 10c2fe: 8d 65 f4 lea -0xc(%ebp),%esp 10c301: 5b pop %ebx 10c302: 5e pop %esi 10c303: 5f pop %edi 10c304: c9 leave 10c305: c3 ret 10c306: 66 90 xchg %ax,%ax the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 10c308: 8b 40 14 mov 0x14(%eax),%eax 10c30b: 85 c0 test %eax,%eax 10c30d: 74 19 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78> 10c30f: 3b 03 cmp (%ebx),%eax 10c311: 74 15 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78> _Thread_Enable_dispatch(); 10c313: e8 08 34 00 00 call 10f720 <_Thread_Enable_dispatch> return EINVAL; 10c318: be 16 00 00 00 mov $0x16,%esi case OBJECTS_ERROR: break; } return EINVAL; } 10c31d: 89 f0 mov %esi,%eax 10c31f: 8d 65 f4 lea -0xc(%ebp),%esp 10c322: 5b pop %ebx 10c323: 5e pop %esi 10c324: 5f pop %edi 10c325: c9 leave 10c326: c3 ret 10c327: 90 nop if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { _Thread_Enable_dispatch(); return EINVAL; } (void) pthread_mutex_unlock( mutex ); 10c328: 83 ec 0c sub $0xc,%esp 10c32b: 53 push %ebx 10c32c: e8 73 03 00 00 call 10c6a4 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 10c331: 83 c4 10 add $0x10,%esp 10c334: 80 7d d7 00 cmpb $0x0,-0x29(%ebp) 10c338: 75 4e jne 10c388 <_POSIX_Condition_variables_Wait_support+0xd8> the_cond->Mutex = *mutex; 10c33a: 8b 03 mov (%ebx),%eax 10c33c: 89 46 14 mov %eax,0x14(%esi) 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; 10c33f: c7 46 48 01 00 00 00 movl $0x1,0x48(%esi) _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 10c346: a1 b8 a2 12 00 mov 0x12a2b8,%eax 10c34b: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 10c352: 83 c6 18 add $0x18,%esi 10c355: 89 70 44 mov %esi,0x44(%eax) _Thread_Executing->Wait.id = *cond; 10c358: 8b 17 mov (%edi),%edx 10c35a: 89 50 20 mov %edx,0x20(%eax) _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 10c35d: 50 push %eax 10c35e: 68 78 ff 10 00 push $0x10ff78 10c363: ff 75 10 pushl 0x10(%ebp) 10c366: 56 push %esi 10c367: e8 90 38 00 00 call 10fbfc <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10c36c: e8 af 33 00 00 call 10f720 <_Thread_Enable_dispatch> * a POSIX signal, then pthread_cond_wait returns spuriously, * according to the POSIX standard. It means that pthread_cond_wait * returns a success status, except for the fact that it was not * woken up a pthread_cond_signal or a pthread_cond_broadcast. */ status = _Thread_Executing->Wait.return_code; 10c371: a1 b8 a2 12 00 mov 0x12a2b8,%eax 10c376: 8b 70 34 mov 0x34(%eax),%esi if ( status == EINTR ) 10c379: 83 c4 10 add $0x10,%esp 10c37c: 83 fe 04 cmp $0x4,%esi 10c37f: 75 11 jne 10c392 <_POSIX_Condition_variables_Wait_support+0xe2> status = 0; 10c381: 31 f6 xor %esi,%esi 10c383: eb 0d jmp 10c392 <_POSIX_Condition_variables_Wait_support+0xe2> 10c385: 8d 76 00 lea 0x0(%esi),%esi } else { _Thread_Enable_dispatch(); 10c388: e8 93 33 00 00 call 10f720 <_Thread_Enable_dispatch> status = ETIMEDOUT; 10c38d: be 74 00 00 00 mov $0x74,%esi /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 10c392: 83 ec 0c sub $0xc,%esp 10c395: 53 push %ebx 10c396: e8 81 02 00 00 call 10c61c if ( mutex_status ) 10c39b: 83 c4 10 add $0x10,%esp 10c39e: 85 c0 test %eax,%eax 10c3a0: 0f 85 51 ff ff ff jne 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47> case OBJECTS_ERROR: break; } return EINVAL; } 10c3a6: 89 f0 mov %esi,%eax 10c3a8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3ab: 5b pop %ebx 10c3ac: 5e pop %esi 10c3ad: 5f pop %edi 10c3ae: c9 leave 10c3af: c3 ret =============================================================================== 00116378 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 116378: 55 push %ebp 116379: 89 e5 mov %esp,%ebp 11637b: 57 push %edi 11637c: 56 push %esi 11637d: 53 push %ebx 11637e: 83 ec 24 sub $0x24,%esp 116381: 8b 5d 10 mov 0x10(%ebp),%ebx CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 116384: 68 ff 00 00 00 push $0xff 116389: ff 75 08 pushl 0x8(%ebp) 11638c: e8 a7 4c 00 00 call 11b038 116391: 89 c6 mov %eax,%esi 116393: a1 b0 fa 12 00 mov 0x12fab0,%eax 116398: 40 inc %eax 116399: a3 b0 fa 12 00 mov %eax,0x12fab0 * There is no real basis for the default values. They will work * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 11639e: 83 c4 10 add $0x10,%esp 1163a1: 85 db test %ebx,%ebx 1163a3: 0f 84 b7 00 00 00 je 116460 <_POSIX_Message_queue_Create_support+0xe8> attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 1163a9: 8b 7b 04 mov 0x4(%ebx),%edi 1163ac: 85 ff test %edi,%edi 1163ae: 0f 8e f0 00 00 00 jle 1164a4 <_POSIX_Message_queue_Create_support+0x12c> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 1163b4: 8b 5b 08 mov 0x8(%ebx),%ebx 1163b7: 89 5d e4 mov %ebx,-0x1c(%ebp) 1163ba: 85 db test %ebx,%ebx 1163bc: 0f 8e e2 00 00 00 jle 1164a4 <_POSIX_Message_queue_Create_support+0x12c> RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) _Objects_Allocate( &_POSIX_Message_queue_Information ); 1163c2: 83 ec 0c sub $0xc,%esp 1163c5: 68 80 fe 12 00 push $0x12fe80 1163ca: e8 d9 c3 ff ff call 1127a8 <_Objects_Allocate> 1163cf: 89 c3 mov %eax,%ebx attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 1163d1: 83 c4 10 add $0x10,%esp 1163d4: 85 c0 test %eax,%eax 1163d6: 0f 84 0a 01 00 00 je 1164e6 <_POSIX_Message_queue_Create_support+0x16e> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 1163dc: 8b 45 0c mov 0xc(%ebp),%eax 1163df: 89 43 10 mov %eax,0x10(%ebx) the_mq->named = true; 1163e2: c6 43 14 01 movb $0x1,0x14(%ebx) the_mq->open_count = 1; 1163e6: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx) the_mq->linked = true; 1163ed: c6 43 15 01 movb $0x1,0x15(%ebx) /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n+1); 1163f1: 8d 56 01 lea 0x1(%esi),%edx 1163f4: 83 ec 0c sub $0xc,%esp 1163f7: 52 push %edx 1163f8: 89 55 e0 mov %edx,-0x20(%ebp) 1163fb: e8 dc e4 ff ff call 1148dc <_Workspace_Allocate> 116400: 89 c6 mov %eax,%esi if (!name) { 116402: 83 c4 10 add $0x10,%esp 116405: 85 c0 test %eax,%eax 116407: 8b 55 e0 mov -0x20(%ebp),%edx 11640a: 0f 84 ab 00 00 00 je 1164bb <_POSIX_Message_queue_Create_support+0x143> _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strncpy( name, name_arg, n+1 ); 116410: 50 push %eax 116411: 52 push %edx 116412: ff 75 08 pushl 0x8(%ebp) 116415: 56 push %esi 116416: e8 a1 4b 00 00 call 11afbc * * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 11641b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) if ( !_CORE_message_queue_Initialize( 116422: ff 75 e4 pushl -0x1c(%ebp) 116425: 57 push %edi * current scheduling policy. * * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; 116426: 8d 43 5c lea 0x5c(%ebx),%eax the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( !_CORE_message_queue_Initialize( 116429: 50 push %eax 11642a: 8d 43 1c lea 0x1c(%ebx),%eax 11642d: 50 push %eax 11642e: e8 25 0f 00 00 call 117358 <_CORE_message_queue_Initialize> 116433: 83 c4 20 add $0x20,%esp 116436: 84 c0 test %al,%al 116438: 74 3a je 116474 <_POSIX_Message_queue_Create_support+0xfc> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 11643a: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 11643e: a1 9c fe 12 00 mov 0x12fe9c,%eax 116443: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 116446: 89 73 0c mov %esi,0xc(%ebx) &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 116449: 8b 45 14 mov 0x14(%ebp),%eax 11644c: 89 18 mov %ebx,(%eax) _Thread_Enable_dispatch(); 11644e: e8 41 d3 ff ff call 113794 <_Thread_Enable_dispatch> return 0; 116453: 31 c0 xor %eax,%eax } 116455: 8d 65 f4 lea -0xc(%ebp),%esp 116458: 5b pop %ebx 116459: 5e pop %esi 11645a: 5f pop %edi 11645b: c9 leave 11645c: c3 ret 11645d: 8d 76 00 lea 0x0(%esi),%esi * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { attr.mq_maxmsg = 10; attr.mq_msgsize = 16; 116460: c7 45 e4 10 00 00 00 movl $0x10,-0x1c(%ebp) * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { attr.mq_maxmsg = 10; 116467: bf 0a 00 00 00 mov $0xa,%edi 11646c: e9 51 ff ff ff jmp 1163c2 <_POSIX_Message_queue_Create_support+0x4a> 116471: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 116474: 83 ec 08 sub $0x8,%esp 116477: 53 push %ebx 116478: 68 80 fe 12 00 push $0x12fe80 11647d: e8 9e c6 ff ff call 112b20 <_Objects_Free> attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 116482: 89 34 24 mov %esi,(%esp) 116485: e8 6e e4 ff ff call 1148f8 <_Workspace_Free> _Thread_Enable_dispatch(); 11648a: e8 05 d3 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 11648f: e8 24 34 00 00 call 1198b8 <__errno> 116494: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11649a: 83 c4 10 add $0x10,%esp 11649d: b8 ff ff ff ff mov $0xffffffff,%eax 1164a2: eb b1 jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); 1164a4: e8 eb d2 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 1164a9: e8 0a 34 00 00 call 1198b8 <__errno> 1164ae: c7 00 16 00 00 00 movl $0x16,(%eax) 1164b4: b8 ff ff ff ff mov $0xffffffff,%eax 1164b9: eb 9a jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> 1164bb: 83 ec 08 sub $0x8,%esp 1164be: 53 push %ebx 1164bf: 68 80 fe 12 00 push $0x12fe80 1164c4: e8 57 c6 ff ff call 112b20 <_Objects_Free> * dynamically constructed. */ name = _Workspace_Allocate(n+1); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 1164c9: e8 c6 d2 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOMEM ); 1164ce: e8 e5 33 00 00 call 1198b8 <__errno> 1164d3: c7 00 0c 00 00 00 movl $0xc,(%eax) 1164d9: 83 c4 10 add $0x10,%esp 1164dc: b8 ff ff ff ff mov $0xffffffff,%eax 1164e1: e9 6f ff ff ff jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); 1164e6: e8 a9 d2 ff ff call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENFILE ); 1164eb: e8 c8 33 00 00 call 1198b8 <__errno> 1164f0: c7 00 17 00 00 00 movl $0x17,(%eax) 1164f6: b8 ff ff ff ff mov $0xffffffff,%eax 1164fb: e9 55 ff ff ff jmp 116455 <_POSIX_Message_queue_Create_support+0xdd> =============================================================================== 00116500 <_POSIX_Message_queue_Name_to_id>: */ int _POSIX_Message_queue_Name_to_id( const char *name, Objects_Id *id ) { 116500: 55 push %ebp 116501: 89 e5 mov %esp,%ebp 116503: 53 push %ebx 116504: 83 ec 14 sub $0x14,%esp 116507: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Id the_id; if ( !name ) 11650a: 85 db test %ebx,%ebx 11650c: 74 05 je 116513 <_POSIX_Message_queue_Name_to_id+0x13> return EINVAL; if ( !name[0] ) 11650e: 80 3b 00 cmpb $0x0,(%ebx) 116511: 75 0d jne 116520 <_POSIX_Message_queue_Name_to_id+0x20> return EINVAL; 116513: b8 16 00 00 00 mov $0x16,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 116518: 8b 5d fc mov -0x4(%ebp),%ebx 11651b: c9 leave 11651c: c3 ret 11651d: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; if ( !name[0] ) return EINVAL; if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) 116520: 83 ec 08 sub $0x8,%esp 116523: 68 ff 00 00 00 push $0xff 116528: 53 push %ebx 116529: e8 0a 4b 00 00 call 11b038 11652e: 83 c4 10 add $0x10,%esp 116531: 3d fe 00 00 00 cmp $0xfe,%eax 116536: 76 0c jbe 116544 <_POSIX_Message_queue_Name_to_id+0x44> return ENAMETOOLONG; 116538: b8 5b 00 00 00 mov $0x5b,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 11653d: 8b 5d fc mov -0x4(%ebp),%ebx 116540: c9 leave 116541: c3 ret 116542: 66 90 xchg %ax,%ax return EINVAL; if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) return ENAMETOOLONG; status = _Objects_Name_to_id_string( 116544: 50 push %eax 116545: 8d 45 f4 lea -0xc(%ebp),%eax 116548: 50 push %eax 116549: 53 push %ebx 11654a: 68 80 fe 12 00 push $0x12fe80 11654f: e8 10 14 00 00 call 117964 <_Objects_Name_to_id_string> &_POSIX_Message_queue_Information, name, &the_id ); *id = the_id; 116554: 8b 4d f4 mov -0xc(%ebp),%ecx 116557: 8b 55 0c mov 0xc(%ebp),%edx 11655a: 89 0a mov %ecx,(%edx) if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11655c: 83 c4 10 add $0x10,%esp return 0; 11655f: 83 f8 01 cmp $0x1,%eax 116562: 19 c0 sbb %eax,%eax 116564: f7 d0 not %eax 116566: 83 e0 02 and $0x2,%eax return ENOENT; } 116569: 8b 5d fc mov -0x4(%ebp),%ebx 11656c: c9 leave 11656d: c3 ret =============================================================================== 0010fce8 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10fce8: 55 push %ebp 10fce9: 89 e5 mov %esp,%ebp 10fceb: 53 push %ebx 10fcec: 83 ec 28 sub $0x28,%esp 10fcef: 8b 5d 08 mov 0x8(%ebp),%ebx 10fcf2: 8a 45 18 mov 0x18(%ebp),%al 10fcf5: 88 45 e7 mov %al,-0x19(%ebp) 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 ); 10fcf8: 8d 45 f4 lea -0xc(%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( 10fcfb: 50 push %eax 10fcfc: 53 push %ebx 10fcfd: 68 20 00 13 00 push $0x130020 10fd02: e8 59 2f 00 00 call 112c60 <_Objects_Get> switch ( location ) { 10fd07: 83 c4 10 add $0x10,%esp 10fd0a: 8b 55 f4 mov -0xc(%ebp),%edx 10fd0d: 85 d2 test %edx,%edx 10fd0f: 74 17 je 10fd28 <_POSIX_Message_queue_Receive_support+0x40> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10fd11: e8 a2 9b 00 00 call 1198b8 <__errno> 10fd16: c7 00 09 00 00 00 movl $0x9,(%eax) 10fd1c: b8 ff ff ff ff mov $0xffffffff,%eax } 10fd21: 8b 5d fc mov -0x4(%ebp),%ebx 10fd24: c9 leave 10fd25: c3 ret 10fd26: 66 90 xchg %ax,%ax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10fd28: 8b 50 14 mov 0x14(%eax),%edx 10fd2b: 89 d1 mov %edx,%ecx 10fd2d: 83 e1 03 and $0x3,%ecx 10fd30: 49 dec %ecx 10fd31: 0f 84 af 00 00 00 je 10fde6 <_POSIX_Message_queue_Receive_support+0xfe> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10fd37: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10fd3a: 8b 4d 10 mov 0x10(%ebp),%ecx 10fd3d: 39 48 68 cmp %ecx,0x68(%eax) 10fd40: 77 62 ja 10fda4 <_POSIX_Message_queue_Receive_support+0xbc> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10fd42: c7 45 f0 ff ff ff ff movl $0xffffffff,-0x10(%ebp) /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fd49: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10fd4d: 75 45 jne 10fd94 <_POSIX_Message_queue_Receive_support+0xac><== ALWAYS TAKEN 10fd4f: 31 d2 xor %edx,%edx <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10fd51: 83 ec 08 sub $0x8,%esp 10fd54: ff 75 1c pushl 0x1c(%ebp) 10fd57: 52 push %edx 10fd58: 8d 55 f0 lea -0x10(%ebp),%edx 10fd5b: 52 push %edx 10fd5c: ff 75 0c pushl 0xc(%ebp) 10fd5f: 53 push %ebx 10fd60: 83 c0 1c add $0x1c,%eax 10fd63: 50 push %eax 10fd64: e8 a3 1f 00 00 call 111d0c <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10fd69: 83 c4 20 add $0x20,%esp 10fd6c: e8 23 3a 00 00 call 113794 <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10fd71: 8b 15 98 00 13 00 mov 0x130098,%edx 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); 10fd77: 8b 42 24 mov 0x24(%edx),%eax 10fd7a: 85 c0 test %eax,%eax 10fd7c: 78 22 js 10fda0 <_POSIX_Message_queue_Receive_support+0xb8> do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 10fd7e: 8b 4d 14 mov 0x14(%ebp),%ecx 10fd81: 89 01 mov %eax,(%ecx) _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 10fd83: 8b 42 34 mov 0x34(%edx),%eax 10fd86: 85 c0 test %eax,%eax 10fd88: 75 36 jne 10fdc0 <_POSIX_Message_queue_Receive_support+0xd8> return length_out; 10fd8a: 8b 45 f0 mov -0x10(%ebp),%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10fd8d: 8b 5d fc mov -0x4(%ebp),%ebx 10fd90: c9 leave 10fd91: c3 ret 10fd92: 66 90 xchg %ax,%ax length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fd94: 80 e6 40 and $0x40,%dh 10fd97: 0f 94 c2 sete %dl 10fd9a: 0f b6 d2 movzbl %dl,%edx 10fd9d: eb b2 jmp 10fd51 <_POSIX_Message_queue_Receive_support+0x69> 10fd9f: 90 nop 10fda0: f7 d8 neg %eax 10fda2: eb da jmp 10fd7e <_POSIX_Message_queue_Receive_support+0x96> } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); 10fda4: e8 eb 39 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10fda9: e8 0a 9b 00 00 call 1198b8 <__errno> 10fdae: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10fdb4: b8 ff ff ff ff mov $0xffffffff,%eax 10fdb9: e9 63 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> 10fdbe: 66 90 xchg %ax,%ax _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) return length_out; rtems_set_errno_and_return_minus_one( 10fdc0: e8 f3 9a 00 00 call 1198b8 <__errno> 10fdc5: 89 c3 mov %eax,%ebx 10fdc7: 83 ec 0c sub $0xc,%esp 10fdca: a1 98 00 13 00 mov 0x130098,%eax 10fdcf: ff 70 34 pushl 0x34(%eax) 10fdd2: e8 29 02 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10fdd7: 89 03 mov %eax,(%ebx) 10fdd9: 83 c4 10 add $0x10,%esp 10fddc: b8 ff ff ff ff mov $0xffffffff,%eax 10fde1: e9 3b ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); 10fde6: e8 a9 39 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EBADF ); 10fdeb: e8 c8 9a 00 00 call 1198b8 <__errno> 10fdf0: c7 00 09 00 00 00 movl $0x9,(%eax) 10fdf6: b8 ff ff ff ff mov $0xffffffff,%eax 10fdfb: e9 21 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> =============================================================================== 0010fe20 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 10fe20: 55 push %ebp 10fe21: 89 e5 mov %esp,%ebp 10fe23: 56 push %esi 10fe24: 53 push %ebx 10fe25: 83 ec 20 sub $0x20,%esp 10fe28: 8b 75 08 mov 0x8(%ebp),%esi 10fe2b: 8b 5d 14 mov 0x14(%ebp),%ebx 10fe2e: 8a 55 18 mov 0x18(%ebp),%dl /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 10fe31: 83 fb 20 cmp $0x20,%ebx 10fe34: 0f 87 92 00 00 00 ja 10fecc <_POSIX_Message_queue_Send_support+0xac> 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( 10fe3a: 51 push %ecx rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10fe3b: 8d 45 f4 lea -0xc(%ebp),%eax 10fe3e: 50 push %eax 10fe3f: 56 push %esi 10fe40: 68 20 00 13 00 push $0x130020 10fe45: 88 55 e4 mov %dl,-0x1c(%ebp) 10fe48: e8 13 2e 00 00 call 112c60 <_Objects_Get> switch ( location ) { 10fe4d: 83 c4 10 add $0x10,%esp 10fe50: 8b 55 f4 mov -0xc(%ebp),%edx 10fe53: 85 d2 test %edx,%edx 10fe55: 8a 55 e4 mov -0x1c(%ebp),%dl 10fe58: 75 5e jne 10feb8 <_POSIX_Message_queue_Send_support+0x98> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 10fe5a: 8b 48 14 mov 0x14(%eax),%ecx 10fe5d: f6 c1 03 test $0x3,%cl 10fe60: 74 7e je 10fee0 <_POSIX_Message_queue_Send_support+0xc0> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10fe62: 8b 40 10 mov 0x10(%eax),%eax /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fe65: 84 d2 test %dl,%dl 10fe67: 75 37 jne 10fea0 <_POSIX_Message_queue_Send_support+0x80> 10fe69: 31 d2 xor %edx,%edx do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 10fe6b: ff 75 1c pushl 0x1c(%ebp) 10fe6e: 52 push %edx RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core( unsigned int priority ) { return priority * -1; 10fe6f: f7 db neg %ebx 10fe71: 53 push %ebx 10fe72: 6a 00 push $0x0 10fe74: 56 push %esi 10fe75: ff 75 10 pushl 0x10(%ebp) 10fe78: ff 75 0c pushl 0xc(%ebp) 10fe7b: 83 c0 1c add $0x1c,%eax 10fe7e: 50 push %eax 10fe7f: e8 b4 1f 00 00 call 111e38 <_CORE_message_queue_Submit> 10fe84: 89 c3 mov %eax,%ebx _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 10fe86: 83 c4 20 add $0x20,%esp 10fe89: e8 06 39 00 00 call 113794 <_Thread_Enable_dispatch> * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 10fe8e: 83 fb 07 cmp $0x7,%ebx 10fe91: 74 19 je 10feac <_POSIX_Message_queue_Send_support+0x8c> msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 10fe93: 85 db test %ebx,%ebx 10fe95: 75 61 jne 10fef8 <_POSIX_Message_queue_Send_support+0xd8> return msg_status; 10fe97: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10fe99: 8d 65 f8 lea -0x8(%ebp),%esp 10fe9c: 5b pop %ebx 10fe9d: 5e pop %esi 10fe9e: c9 leave 10fe9f: c3 ret the_mq = the_mq_fd->Queue; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10fea0: 31 d2 xor %edx,%edx 10fea2: f6 c5 40 test $0x40,%ch 10fea5: 0f 94 c2 sete %dl 10fea8: eb c1 jmp 10fe6b <_POSIX_Message_queue_Send_support+0x4b> 10feaa: 66 90 xchg %ax,%ax * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) msg_status = _Thread_Executing->Wait.return_code; 10feac: a1 98 00 13 00 mov 0x130098,%eax 10feb1: 8b 58 34 mov 0x34(%eax),%ebx 10feb4: eb dd jmp 10fe93 <_POSIX_Message_queue_Send_support+0x73> 10feb6: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10feb8: e8 fb 99 00 00 call 1198b8 <__errno> 10febd: c7 00 09 00 00 00 movl $0x9,(%eax) 10fec3: b8 ff ff ff ff mov $0xffffffff,%eax 10fec8: eb cf jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10feca: 66 90 xchg %ax,%ax * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) rtems_set_errno_and_return_minus_one( EINVAL ); 10fecc: e8 e7 99 00 00 call 1198b8 <__errno> 10fed1: c7 00 16 00 00 00 movl $0x16,(%eax) 10fed7: b8 ff ff ff ff mov $0xffffffff,%eax 10fedc: eb bb jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10fede: 66 90 xchg %ax,%ax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); 10fee0: e8 af 38 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EBADF ); 10fee5: e8 ce 99 00 00 call 1198b8 <__errno> 10feea: c7 00 09 00 00 00 movl $0x9,(%eax) 10fef0: b8 ff ff ff ff mov $0xffffffff,%eax 10fef5: eb a2 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10fef7: 90 nop msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) return msg_status; rtems_set_errno_and_return_minus_one( 10fef8: e8 bb 99 00 00 call 1198b8 <__errno> 10fefd: 89 c6 mov %eax,%esi 10feff: 83 ec 0c sub $0xc,%esp 10ff02: 53 push %ebx 10ff03: e8 f8 00 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10ff08: 89 06 mov %eax,(%esi) 10ff0a: 83 c4 10 add $0x10,%esp 10ff0d: b8 ff ff ff ff mov $0xffffffff,%eax 10ff12: eb 85 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> =============================================================================== 0010d0f4 <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 10d0f4: 55 push %ebp 10d0f5: 89 e5 mov %esp,%ebp 10d0f7: 56 push %esi 10d0f8: 53 push %ebx 10d0f9: 8b 5d 08 mov 0x8(%ebp),%ebx 10d0fc: 8b 75 0c mov 0xc(%ebp),%esi ___POSIX_Mutex_Get_support_error_check( mutex, location ); 10d0ff: 85 db test %ebx,%ebx 10d101: 74 39 je 10d13c <_POSIX_Mutex_Get+0x48> ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d103: 8b 03 mov (%ebx),%eax 10d105: 83 f8 ff cmp $0xffffffff,%eax 10d108: 74 1a je 10d124 <_POSIX_Mutex_Get+0x30> return (POSIX_Mutex_Control *) _Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location ); 10d10a: 52 push %edx 10d10b: 56 push %esi 10d10c: 50 push %eax 10d10d: 68 a0 b9 12 00 push $0x12b9a0 10d112: e8 e9 2b 00 00 call 10fd00 <_Objects_Get> { ___POSIX_Mutex_Get_support_error_check( mutex, location ); ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); return (POSIX_Mutex_Control *) 10d117: 83 c4 10 add $0x10,%esp _Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location ); } 10d11a: 8d 65 f8 lea -0x8(%ebp),%esp 10d11d: 5b pop %ebx 10d11e: 5e pop %esi 10d11f: c9 leave 10d120: c3 ret 10d121: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations *location ) { ___POSIX_Mutex_Get_support_error_check( mutex, location ); ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d124: 83 ec 08 sub $0x8,%esp 10d127: 6a 00 push $0x0 10d129: 53 push %ebx 10d12a: e8 b9 00 00 00 call 10d1e8 10d12f: 83 c4 10 add $0x10,%esp 10d132: 85 c0 test %eax,%eax 10d134: 75 06 jne 10d13c <_POSIX_Mutex_Get+0x48> 10d136: 8b 03 mov (%ebx),%eax 10d138: eb d0 jmp 10d10a <_POSIX_Mutex_Get+0x16> 10d13a: 66 90 xchg %ax,%ax 10d13c: c7 06 01 00 00 00 movl $0x1,(%esi) 10d142: 31 c0 xor %eax,%eax 10d144: eb d4 jmp 10d11a <_POSIX_Mutex_Get+0x26> =============================================================================== 0010d148 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10d148: 55 push %ebp 10d149: 89 e5 mov %esp,%ebp 10d14b: 56 push %esi 10d14c: 53 push %ebx 10d14d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d150: 8b 75 0c mov 0xc(%ebp),%esi ___POSIX_Mutex_Get_support_error_check( mutex, location ); 10d153: 85 db test %ebx,%ebx 10d155: 74 39 je 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48> ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d157: 8b 03 mov (%ebx),%eax 10d159: 83 f8 ff cmp $0xffffffff,%eax 10d15c: 74 1a je 10d178 <_POSIX_Mutex_Get_interrupt_disable+0x30> return (POSIX_Mutex_Control *) _Objects_Get_isr_disable( 10d15e: ff 75 10 pushl 0x10(%ebp) 10d161: 56 push %esi 10d162: 50 push %eax 10d163: 68 a0 b9 12 00 push $0x12b9a0 10d168: e8 3b 2b 00 00 call 10fca8 <_Objects_Get_isr_disable> 10d16d: 83 c4 10 add $0x10,%esp &_POSIX_Mutex_Information, (Objects_Id) *mutex, location, level ); } 10d170: 8d 65 f8 lea -0x8(%ebp),%esp 10d173: 5b pop %ebx 10d174: 5e pop %esi 10d175: c9 leave 10d176: c3 ret 10d177: 90 nop ISR_Level *level ) { ___POSIX_Mutex_Get_support_error_check( mutex, location ); ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10d178: 83 ec 08 sub $0x8,%esp 10d17b: 6a 00 push $0x0 10d17d: 53 push %ebx 10d17e: e8 65 00 00 00 call 10d1e8 10d183: 83 c4 10 add $0x10,%esp 10d186: 85 c0 test %eax,%eax 10d188: 75 06 jne 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48> 10d18a: 8b 03 mov (%ebx),%eax 10d18c: eb d0 jmp 10d15e <_POSIX_Mutex_Get_interrupt_disable+0x16> 10d18e: 66 90 xchg %ax,%ax 10d190: c7 06 01 00 00 00 movl $0x1,(%esi) 10d196: 31 c0 xor %eax,%eax 10d198: eb d6 jmp 10d170 <_POSIX_Mutex_Get_interrupt_disable+0x28> =============================================================================== 0010d348 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, bool blocking, Watchdog_Interval timeout ) { 10d348: 55 push %ebp 10d349: 89 e5 mov %esp,%ebp 10d34b: 53 push %ebx 10d34c: 83 ec 18 sub $0x18,%esp 10d34f: 8a 5d 0c mov 0xc(%ebp),%bl register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); 10d352: 8d 45 f0 lea -0x10(%ebp),%eax 10d355: 50 push %eax 10d356: 8d 45 f4 lea -0xc(%ebp),%eax 10d359: 50 push %eax 10d35a: ff 75 08 pushl 0x8(%ebp) 10d35d: e8 e6 fd ff ff call 10d148 <_POSIX_Mutex_Get_interrupt_disable> switch ( location ) { 10d362: 83 c4 10 add $0x10,%esp 10d365: 8b 55 f4 mov -0xc(%ebp),%edx 10d368: 85 d2 test %edx,%edx 10d36a: 75 34 jne 10d3a0 <_POSIX_Mutex_Lock_support+0x58> case OBJECTS_LOCAL: _CORE_mutex_Seize( 10d36c: 83 ec 0c sub $0xc,%esp 10d36f: ff 75 f0 pushl -0x10(%ebp) 10d372: ff 75 10 pushl 0x10(%ebp) 10d375: 0f b6 db movzbl %bl,%ebx 10d378: 53 push %ebx 10d379: ff 70 08 pushl 0x8(%eax) 10d37c: 83 c0 14 add $0x14,%eax 10d37f: 50 push %eax 10d380: e8 47 1d 00 00 call 10f0cc <_CORE_mutex_Seize> the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10d385: 83 c4 14 add $0x14,%esp (CORE_mutex_Status) _Thread_Executing->Wait.return_code 10d388: a1 78 bb 12 00 mov 0x12bb78,%eax the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10d38d: ff 70 34 pushl 0x34(%eax) 10d390: e8 1b 01 00 00 call 10d4b0 <_POSIX_Mutex_Translate_core_mutex_return_code> 10d395: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10d398: 8b 5d fc mov -0x4(%ebp),%ebx 10d39b: c9 leave 10d39c: c3 ret 10d39d: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return EINVAL; 10d3a0: b8 16 00 00 00 mov $0x16,%eax } 10d3a5: 8b 5d fc mov -0x4(%ebp),%ebx 10d3a8: c9 leave 10d3a9: c3 ret =============================================================================== 00114958 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 114958: 55 push %ebp 114959: 89 e5 mov %esp,%ebp 11495b: 56 push %esi 11495c: 53 push %ebx 11495d: 8b 5d 08 mov 0x8(%ebp),%ebx POSIX_Semaphore_Control *the_semaphore; CORE_semaphore_Attributes *the_sem_attr; char *name_p = (char *)name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) 114960: 8b 55 0c mov 0xc(%ebp),%edx 114963: 85 d2 test %edx,%edx 114965: 0f 85 b9 00 00 00 jne 114a24 <_POSIX_Semaphore_Create_support+0xcc> rtems_set_errno_and_return_minus_one( ENOSYS ); if ( name ) { 11496b: 85 db test %ebx,%ebx 11496d: 74 1c je 11498b <_POSIX_Semaphore_Create_support+0x33> if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) 11496f: 83 ec 08 sub $0x8,%esp 114972: 68 ff 00 00 00 push $0xff 114977: 53 push %ebx 114978: e8 0b 3e 00 00 call 118788 11497d: 83 c4 10 add $0x10,%esp 114980: 3d fe 00 00 00 cmp $0xfe,%eax 114985: 0f 87 ad 00 00 00 ja 114a38 <_POSIX_Semaphore_Create_support+0xe0> 11498b: a1 f0 d2 12 00 mov 0x12d2f0,%eax 114990: 40 inc %eax 114991: a3 f0 d2 12 00 mov %eax,0x12d2f0 */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) _Objects_Allocate( &_POSIX_Semaphore_Information ); 114996: 83 ec 0c sub $0xc,%esp 114999: 68 40 d6 12 00 push $0x12d640 11499e: e8 89 b9 ff ff call 11032c <_Objects_Allocate> 1149a3: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 1149a5: 83 c4 10 add $0x10,%esp 1149a8: 85 c0 test %eax,%eax 1149aa: 0f 84 9a 00 00 00 je 114a4a <_POSIX_Semaphore_Create_support+0xf2> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); } the_semaphore->process_shared = pshared; 1149b0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) if ( name ) { 1149b7: 85 db test %ebx,%ebx 1149b9: 74 55 je 114a10 <_POSIX_Semaphore_Create_support+0xb8> the_semaphore->named = true; 1149bb: c6 40 14 01 movb $0x1,0x14(%eax) the_semaphore->open_count = 1; 1149bf: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) the_semaphore->linked = true; 1149c6: c6 40 15 01 movb $0x1,0x15(%eax) * blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 1149ca: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 1149d1: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi) _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1149d8: 50 push %eax 1149d9: ff 75 10 pushl 0x10(%ebp) the_semaphore->named = false; the_semaphore->open_count = 0; the_semaphore->linked = false; } the_sem_attr = &the_semaphore->Semaphore.Attributes; 1149dc: 8d 46 5c lea 0x5c(%esi),%eax /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1149df: 50 push %eax 1149e0: 8d 46 1c lea 0x1c(%esi),%eax 1149e3: 50 push %eax 1149e4: e8 cb b3 ff ff call 10fdb4 <_CORE_semaphore_Initialize> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 1149e9: 0f b7 56 08 movzwl 0x8(%esi),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1149ed: a1 5c d6 12 00 mov 0x12d65c,%eax 1149f2: 89 34 90 mov %esi,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 1149f5: 89 5e 0c mov %ebx,0xc(%esi) &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 1149f8: 8b 45 14 mov 0x14(%ebp),%eax 1149fb: 89 30 mov %esi,(%eax) _Thread_Enable_dispatch(); 1149fd: e8 16 c9 ff ff call 111318 <_Thread_Enable_dispatch> return 0; 114a02: 83 c4 10 add $0x10,%esp 114a05: 31 c0 xor %eax,%eax } 114a07: 8d 65 f8 lea -0x8(%ebp),%esp 114a0a: 5b pop %ebx 114a0b: 5e pop %esi 114a0c: c9 leave 114a0d: c3 ret 114a0e: 66 90 xchg %ax,%ax if ( name ) { the_semaphore->named = true; the_semaphore->open_count = 1; the_semaphore->linked = true; } else { the_semaphore->named = false; 114a10: c6 40 14 00 movb $0x0,0x14(%eax) the_semaphore->open_count = 0; 114a14: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_semaphore->linked = false; 114a1b: c6 40 15 00 movb $0x0,0x15(%eax) 114a1f: eb a9 jmp 1149ca <_POSIX_Semaphore_Create_support+0x72> 114a21: 8d 76 00 lea 0x0(%esi),%esi CORE_semaphore_Attributes *the_sem_attr; char *name_p = (char *)name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) rtems_set_errno_and_return_minus_one( ENOSYS ); 114a24: e8 33 2c 00 00 call 11765c <__errno> 114a29: c7 00 58 00 00 00 movl $0x58,(%eax) 114a2f: b8 ff ff ff ff mov $0xffffffff,%eax 114a34: eb d1 jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf> 114a36: 66 90 xchg %ax,%ax if ( name ) { if ( strnlen( name, NAME_MAX ) >= NAME_MAX ) rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 114a38: e8 1f 2c 00 00 call 11765c <__errno> 114a3d: c7 00 5b 00 00 00 movl $0x5b,(%eax) 114a43: b8 ff ff ff ff mov $0xffffffff,%eax 114a48: eb bd jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf> _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 114a4a: e8 c9 c8 ff ff call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 114a4f: e8 08 2c 00 00 call 11765c <__errno> 114a54: c7 00 1c 00 00 00 movl $0x1c,(%eax) 114a5a: b8 ff ff ff ff mov $0xffffffff,%eax 114a5f: eb a6 jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf> =============================================================================== 00114ab4 <_POSIX_Semaphore_Name_to_id>: int _POSIX_Semaphore_Name_to_id( const char *name, sem_t *id ) { 114ab4: 55 push %ebp 114ab5: 89 e5 mov %esp,%ebp 114ab7: 83 ec 18 sub $0x18,%esp 114aba: 8b 45 08 mov 0x8(%ebp),%eax Objects_Name_or_id_lookup_errors status; Objects_Id the_id; if ( !name ) 114abd: 85 c0 test %eax,%eax 114abf: 74 05 je 114ac6 <_POSIX_Semaphore_Name_to_id+0x12> return EINVAL; if ( !name[0] ) 114ac1: 80 38 00 cmpb $0x0,(%eax) 114ac4: 75 0a jne 114ad0 <_POSIX_Semaphore_Name_to_id+0x1c> return EINVAL; 114ac6: b8 16 00 00 00 mov $0x16,%eax if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 114acb: c9 leave 114acc: c3 ret 114acd: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; if ( !name[0] ) return EINVAL; status = _Objects_Name_to_id_string( 114ad0: 52 push %edx 114ad1: 8d 55 f4 lea -0xc(%ebp),%edx 114ad4: 52 push %edx 114ad5: 50 push %eax 114ad6: 68 40 d6 12 00 push $0x12d640 114adb: e8 7c 0c 00 00 call 11575c <_Objects_Name_to_id_string> &_POSIX_Semaphore_Information, name, &the_id ); *id = the_id; 114ae0: 8b 4d f4 mov -0xc(%ebp),%ecx 114ae3: 8b 55 0c mov 0xc(%ebp),%edx 114ae6: 89 0a mov %ecx,(%edx) if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 114ae8: 83 c4 10 add $0x10,%esp return 0; 114aeb: 83 f8 01 cmp $0x1,%eax 114aee: 19 c0 sbb %eax,%eax 114af0: f7 d0 not %eax 114af2: 83 e0 02 and $0x2,%eax return ENOENT; } 114af5: c9 leave 114af6: c3 ret =============================================================================== 00114b20 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, bool blocking, Watchdog_Interval timeout ) { 114b20: 55 push %ebp 114b21: 89 e5 mov %esp,%ebp 114b23: 53 push %ebx 114b24: 83 ec 18 sub $0x18,%esp 114b27: 8a 5d 0c mov 0xc(%ebp),%bl POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 114b2a: 8d 45 f4 lea -0xc(%ebp),%eax sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) _Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location ); 114b2d: 50 push %eax 114b2e: 8b 45 08 mov 0x8(%ebp),%eax 114b31: ff 30 pushl (%eax) 114b33: 68 40 d6 12 00 push $0x12d640 114b38: e8 a7 bc ff ff call 1107e4 <_Objects_Get> switch ( location ) { 114b3d: 83 c4 10 add $0x10,%esp 114b40: 8b 55 f4 mov -0xc(%ebp),%edx 114b43: 85 d2 test %edx,%edx 114b45: 74 15 je 114b5c <_POSIX_Semaphore_Wait_support+0x3c> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 114b47: e8 10 2b 00 00 call 11765c <__errno> 114b4c: c7 00 16 00 00 00 movl $0x16,(%eax) 114b52: b8 ff ff ff ff mov $0xffffffff,%eax } 114b57: 8b 5d fc mov -0x4(%ebp),%ebx 114b5a: c9 leave 114b5b: c3 ret the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Seize( 114b5c: ff 75 10 pushl 0x10(%ebp) 114b5f: 0f b6 db movzbl %bl,%ebx 114b62: 53 push %ebx 114b63: ff 70 08 pushl 0x8(%eax) 114b66: 83 c0 1c add $0x1c,%eax 114b69: 50 push %eax 114b6a: e8 29 07 00 00 call 115298 <_CORE_semaphore_Seize> &the_semaphore->Semaphore, the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); 114b6f: e8 a4 c7 ff ff call 111318 <_Thread_Enable_dispatch> if ( !_Thread_Executing->Wait.return_code ) 114b74: 83 c4 10 add $0x10,%esp 114b77: a1 d8 d8 12 00 mov 0x12d8d8,%eax 114b7c: 8b 40 34 mov 0x34(%eax),%eax 114b7f: 85 c0 test %eax,%eax 114b81: 75 09 jne 114b8c <_POSIX_Semaphore_Wait_support+0x6c> return 0; 114b83: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 114b85: 8b 5d fc mov -0x4(%ebp),%ebx 114b88: c9 leave 114b89: c3 ret 114b8a: 66 90 xchg %ax,%ax _Thread_Enable_dispatch(); if ( !_Thread_Executing->Wait.return_code ) return 0; rtems_set_errno_and_return_minus_one( 114b8c: e8 cb 2a 00 00 call 11765c <__errno> 114b91: 89 c3 mov %eax,%ebx 114b93: 83 ec 0c sub $0xc,%esp 114b96: a1 d8 d8 12 00 mov 0x12d8d8,%eax 114b9b: ff 70 34 pushl 0x34(%eax) 114b9e: e8 29 26 00 00 call 1171cc <_POSIX_Semaphore_Translate_core_semaphore_return_code> 114ba3: 89 03 mov %eax,(%ebx) 114ba5: 83 c4 10 add $0x10,%esp 114ba8: b8 ff ff ff ff mov $0xffffffff,%eax 114bad: eb a8 jmp 114b57 <_POSIX_Semaphore_Wait_support+0x37> =============================================================================== 001106dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 1106dc: 55 push %ebp 1106dd: 89 e5 mov %esp,%ebp 1106df: 83 ec 08 sub $0x8,%esp 1106e2: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1106e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 1106eb: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx 1106f1: 85 c9 test %ecx,%ecx 1106f3: 75 09 jne 1106fe <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN 1106f5: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 1106fc: 74 06 je 110704 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28> _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); } 1106fe: 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(); 1106ff: e9 38 d6 ff ff jmp 10dd3c <_Thread_Enable_dispatch> POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 110704: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 11070a: 85 c0 test %eax,%eax 11070c: 74 f0 je 1106fe <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 11070e: a1 70 88 12 00 mov 0x128870,%eax 110713: 48 dec %eax 110714: a3 70 88 12 00 mov %eax,0x128870 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 110719: 83 ec 08 sub $0x8,%esp 11071c: 6a ff push $0xffffffff 11071e: 52 push %edx 11071f: e8 c0 08 00 00 call 110fe4 <_POSIX_Thread_Exit> 110724: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 110727: c9 leave 110728: c3 ret =============================================================================== 00111a4c <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 111a4c: 55 push %ebp 111a4d: 89 e5 mov %esp,%ebp 111a4f: 57 push %edi 111a50: 56 push %esi 111a51: 53 push %ebx 111a52: 83 ec 18 sub $0x18,%esp 111a55: 8b 5d 08 mov 0x8(%ebp),%ebx 111a58: 8b 75 0c mov 0xc(%ebp),%esi 111a5b: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 111a5e: ff 36 pushl (%esi) 111a60: e8 cb ff ff ff call 111a30 <_POSIX_Priority_Is_valid> 111a65: 83 c4 10 add $0x10,%esp 111a68: 84 c0 test %al,%al 111a6a: 74 2a je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 111a6c: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 111a72: 8b 45 14 mov 0x14(%ebp),%eax 111a75: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 111a7b: 85 db test %ebx,%ebx 111a7d: 74 25 je 111aa4 <_POSIX_Thread_Translate_sched_param+0x58> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 111a7f: 83 fb 01 cmp $0x1,%ebx 111a82: 0f 84 90 00 00 00 je 111b18 <_POSIX_Thread_Translate_sched_param+0xcc> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 111a88: 83 fb 02 cmp $0x2,%ebx 111a8b: 0f 84 8f 00 00 00 je 111b20 <_POSIX_Thread_Translate_sched_param+0xd4> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { 111a91: 83 fb 04 cmp $0x4,%ebx 111a94: 74 1e je 111ab4 <_POSIX_Thread_Translate_sched_param+0x68> if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) return EINVAL; 111a96: b8 16 00 00 00 mov $0x16,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 111a9b: 8d 65 f4 lea -0xc(%ebp),%esp 111a9e: 5b pop %ebx 111a9f: 5e pop %esi 111aa0: 5f pop %edi 111aa1: c9 leave 111aa2: c3 ret 111aa3: 90 nop *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; *budget_callout = NULL; if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 111aa4: c7 07 01 00 00 00 movl $0x1,(%edi) return 0; 111aaa: 31 c0 xor %eax,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 111aac: 8d 65 f4 lea -0xc(%ebp),%esp 111aaf: 5b pop %ebx 111ab0: 5e pop %esi 111ab1: 5f pop %edi 111ab2: c9 leave 111ab3: c3 ret *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { if ( (param->sched_ss_repl_period.tv_sec == 0) && 111ab4: 8b 5e 08 mov 0x8(%esi),%ebx 111ab7: 85 db test %ebx,%ebx 111ab9: 75 07 jne 111ac2 <_POSIX_Thread_Translate_sched_param+0x76> 111abb: 8b 4e 0c mov 0xc(%esi),%ecx 111abe: 85 c9 test %ecx,%ecx 111ac0: 74 d4 je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a> (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 111ac2: 8b 56 10 mov 0x10(%esi),%edx 111ac5: 85 d2 test %edx,%edx 111ac7: 75 07 jne 111ad0 <_POSIX_Thread_Translate_sched_param+0x84> 111ac9: 8b 46 14 mov 0x14(%esi),%eax 111acc: 85 c0 test %eax,%eax 111ace: 74 c6 je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 111ad0: 83 ec 0c sub $0xc,%esp 111ad3: 8d 46 08 lea 0x8(%esi),%eax 111ad6: 50 push %eax 111ad7: e8 00 da ff ff call 10f4dc <_Timespec_To_ticks> 111adc: 89 c3 mov %eax,%ebx _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 111ade: 8d 46 10 lea 0x10(%esi),%eax 111ae1: 89 04 24 mov %eax,(%esp) 111ae4: e8 f3 d9 ff ff call 10f4dc <_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 ) < 111ae9: 83 c4 10 add $0x10,%esp 111aec: 39 c3 cmp %eax,%ebx 111aee: 72 a6 jb 111a96 <_POSIX_Thread_Translate_sched_param+0x4a> _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 111af0: 83 ec 0c sub $0xc,%esp 111af3: ff 76 04 pushl 0x4(%esi) 111af6: e8 35 ff ff ff call 111a30 <_POSIX_Priority_Is_valid> 111afb: 83 c4 10 add $0x10,%esp 111afe: 84 c0 test %al,%al 111b00: 74 94 je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 111b02: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 111b08: 8b 45 14 mov 0x14(%ebp),%eax 111b0b: c7 00 14 bd 10 00 movl $0x10bd14,(%eax) return 0; 111b11: 31 c0 xor %eax,%eax 111b13: eb 86 jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f> 111b15: 8d 76 00 lea 0x0(%esi),%esi return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 111b18: 31 c0 xor %eax,%eax 111b1a: e9 7c ff ff ff jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f> 111b1f: 90 nop } if ( policy == SCHED_RR ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 111b20: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 111b26: 31 c0 xor %eax,%eax 111b28: e9 6e ff ff ff jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f> =============================================================================== 001108e8 <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *created ) { 1108e8: 55 push %ebp 1108e9: 89 e5 mov %esp,%ebp 1108eb: 57 push %edi 1108ec: 56 push %esi 1108ed: 53 push %ebx 1108ee: 83 ec 28 sub $0x28,%esp 1108f1: 8b 55 0c mov 0xc(%ebp),%edx POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 1108f4: 68 f0 00 00 00 push $0xf0 1108f9: 89 55 e4 mov %edx,-0x1c(%ebp) 1108fc: e8 5f e0 ff ff call 10e960 <_Workspace_Allocate> 110901: 89 c3 mov %eax,%ebx if ( !api ) 110903: 83 c4 10 add $0x10,%esp 110906: 85 c0 test %eax,%eax 110908: 8b 55 e4 mov -0x1c(%ebp),%edx 11090b: 0f 84 2f 01 00 00 je 110a40 <_POSIX_Threads_Create_extension+0x158><== NEVER TAKEN return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 110911: 89 82 ec 00 00 00 mov %eax,0xec(%edx) /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 110917: b9 40 00 00 00 mov $0x40,%ecx 11091c: 31 c0 xor %eax,%eax 11091e: 89 df mov %ebx,%edi 110920: f3 aa rep stos %al,%es:(%edi) 110922: c7 03 01 00 00 00 movl $0x1,(%ebx) 110928: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) 11092f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx) 110936: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx) 11093d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) 110944: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx) api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 11094b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx) api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 110952: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx) 110959: 00 00 00 api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 11095c: be 78 13 12 00 mov $0x121378,%esi 110961: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 110967: b1 07 mov $0x7,%cl 110969: f3 a5 rep movsl %ds:(%esi),%es:(%edi) RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core( Priority_Control priority ) { return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 11096b: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax 110972: 2b 42 14 sub 0x14(%edx),%eax 110975: 89 83 88 00 00 00 mov %eax,0x88(%ebx) _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 11097b: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 110982: 00 00 00 api->cancelability_state = PTHREAD_CANCEL_ENABLE; 110985: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx) 11098c: 00 00 00 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 11098f: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 110996: 00 00 00 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 110999: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax 11099f: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx) head->next = tail; head->previous = NULL; 1109a5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 1109ac: 00 00 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 1109af: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax 1109b5: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) * * The check for class == 1 is debug. Should never really happen. */ /* XXX use signal constants */ api->signals_pending = 0; 1109bb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) 1109c2: 00 00 00 1109c5: 0f b6 42 0b movzbl 0xb(%edx),%eax 1109c9: 83 e0 07 and $0x7,%eax if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API 1109cc: 83 f8 03 cmp $0x3,%eax 1109cf: 74 53 je 110a24 <_POSIX_Threads_Create_extension+0x13c> #endif ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; } else { api->signals_blocked = 0xffffffff; 1109d1: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx) 1109d8: ff ff ff } _Thread_queue_Initialize( 1109db: 6a 00 push $0x0 1109dd: 68 00 10 00 00 push $0x1000 1109e2: 6a 00 push $0x0 1109e4: 8d 43 44 lea 0x44(%ebx),%eax 1109e7: 50 push %eax 1109e8: 89 55 e4 mov %edx,-0x1c(%ebp) 1109eb: e8 48 d6 ff ff call 10e038 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 1109f0: 8b 55 e4 mov -0x1c(%ebp),%edx 1109f3: 8b 42 08 mov 0x8(%edx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1109f6: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx) 1109fd: 00 00 00 the_watchdog->routine = routine; 110a00: c7 83 c4 00 00 00 4c movl $0x110a4c,0xc4(%ebx) 110a07: 0a 11 00 the_watchdog->id = id; 110a0a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx) the_watchdog->user_data = user_data; 110a10: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx) _POSIX_Threads_Sporadic_budget_TSR, created->Object.id, created ); return true; 110a16: 83 c4 10 add $0x10,%esp 110a19: b0 01 mov $0x1,%al } 110a1b: 8d 65 f4 lea -0xc(%ebp),%esp 110a1e: 5b pop %ebx 110a1f: 5e pop %esi 110a20: 5f pop %edi 110a21: c9 leave 110a22: c3 ret 110a23: 90 nop if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API #if defined(RTEMS_DEBUG) && _Objects_Get_class( created->Object.id ) == 1 #endif ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 110a24: a1 58 7b 12 00 mov 0x127b58,%eax api->signals_blocked = executing_api->signals_blocked; 110a29: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 110a2f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 110a35: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx) 110a3b: eb 9e jmp 1109db <_POSIX_Threads_Create_extension+0xf3> 110a3d: 8d 76 00 lea 0x0(%esi),%esi POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) return false; 110a40: 31 c0 xor %eax,%eax created->Object.id, created ); return true; } 110a42: 8d 65 f4 lea -0xc(%ebp),%esp 110a45: 5b pop %ebx 110a46: 5e pop %esi 110a47: 5f pop %edi 110a48: c9 leave 110a49: c3 ret =============================================================================== 00110860 <_POSIX_Threads_Delete_extension>: */ void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) { 110860: 55 push %ebp 110861: 89 e5 mov %esp,%ebp 110863: 57 push %edi 110864: 56 push %esi 110865: 53 push %ebx 110866: 83 ec 28 sub $0x28,%esp 110869: 8b 7d 0c mov 0xc(%ebp),%edi Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 11086c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax 110872: 89 45 e4 mov %eax,-0x1c(%ebp) /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 110875: 57 push %edi 110876: e8 d1 22 00 00 call 112b4c <_POSIX_Threads_cancel_run> /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 11087b: 89 3c 24 mov %edi,(%esp) 11087e: e8 31 23 00 00 call 112bb4 <_POSIX_Keys_Run_destructors> /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 110883: 8b 77 28 mov 0x28(%edi),%esi while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 110886: 83 c4 10 add $0x10,%esp 110889: 8b 45 e4 mov -0x1c(%ebp),%eax 11088c: 8d 58 44 lea 0x44(%eax),%ebx 11088f: eb 08 jmp 110899 <_POSIX_Threads_Delete_extension+0x39> 110891: 8d 76 00 lea 0x0(%esi),%esi *(void **)the_thread->Wait.return_argument = value_ptr; 110894: 8b 40 28 mov 0x28(%eax),%eax 110897: 89 30 mov %esi,(%eax) /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 110899: 83 ec 0c sub $0xc,%esp 11089c: 53 push %ebx 11089d: e8 06 d4 ff ff call 10dca8 <_Thread_queue_Dequeue> 1108a2: 83 c4 10 add $0x10,%esp 1108a5: 85 c0 test %eax,%eax 1108a7: 75 eb jne 110894 <_POSIX_Threads_Delete_extension+0x34> *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 1108a9: 8b 45 e4 mov -0x1c(%ebp),%eax 1108ac: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax) 1108b3: 74 1f je 1108d4 <_POSIX_Threads_Delete_extension+0x74> (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 1108b5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi) 1108bc: 00 00 00 (void) _Workspace_Free( api ); 1108bf: 8b 45 e4 mov -0x1c(%ebp),%eax 1108c2: 89 45 08 mov %eax,0x8(%ebp) } 1108c5: 8d 65 f4 lea -0xc(%ebp),%esp 1108c8: 5b pop %ebx 1108c9: 5e pop %esi 1108ca: 5f pop %edi 1108cb: c9 leave if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; (void) _Workspace_Free( api ); 1108cc: e9 ab e0 ff ff jmp 10e97c <_Workspace_Free> 1108d1: 8d 76 00 lea 0x0(%esi),%esi while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 1108d4: 83 ec 0c sub $0xc,%esp 1108d7: 05 a8 00 00 00 add $0xa8,%eax 1108dc: 50 push %eax 1108dd: e8 56 df ff ff call 10e838 <_Watchdog_Remove> 1108e2: 83 c4 10 add $0x10,%esp 1108e5: eb ce jmp 1108b5 <_POSIX_Threads_Delete_extension+0x55> =============================================================================== 00110824 <_POSIX_Threads_Initialize_user_threads>: * * This routine creates and starts all configured user * initialzation threads. */ void _POSIX_Threads_Initialize_user_threads( void ) { 110824: 55 push %ebp 110825: 89 e5 mov %esp,%ebp 110827: 83 ec 08 sub $0x8,%esp if ( _POSIX_Threads_Initialize_user_threads_p ) 11082a: a1 18 58 12 00 mov 0x125818,%eax 11082f: 85 c0 test %eax,%eax 110831: 74 05 je 110838 <_POSIX_Threads_Initialize_user_threads+0x14> (*_POSIX_Threads_Initialize_user_threads_p)(); } 110833: c9 leave * initialzation threads. */ void _POSIX_Threads_Initialize_user_threads( void ) { if ( _POSIX_Threads_Initialize_user_threads_p ) (*_POSIX_Threads_Initialize_user_threads_p)(); 110834: ff e0 jmp *%eax 110836: 66 90 xchg %ax,%ax } 110838: c9 leave 110839: c3 ret =============================================================================== 0010b9f4 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10b9f4: 55 push %ebp 10b9f5: 89 e5 mov %esp,%ebp 10b9f7: 57 push %edi 10b9f8: 56 push %esi 10b9f9: 53 push %ebx 10b9fa: 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; 10b9fd: 8b 3d 74 45 12 00 mov 0x124574,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10ba03: a1 70 45 12 00 mov 0x124570,%eax 10ba08: 89 45 94 mov %eax,-0x6c(%ebp) if ( !user_threads || maximum == 0 ) 10ba0b: 85 ff test %edi,%edi 10ba0d: 74 44 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN 10ba0f: 85 c0 test %eax,%eax 10ba11: 74 40 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN 10ba13: 31 db xor %ebx,%ebx 10ba15: 8d 75 a4 lea -0x5c(%ebp),%esi for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10ba18: 83 ec 0c sub $0xc,%esp 10ba1b: 56 push %esi 10ba1c: e8 0f 61 00 00 call 111b30 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10ba21: 5a pop %edx 10ba22: 59 pop %ecx 10ba23: 6a 02 push $0x2 10ba25: 56 push %esi 10ba26: e8 31 61 00 00 call 111b5c (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10ba2b: 59 pop %ecx 10ba2c: 58 pop %eax 10ba2d: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10ba31: 56 push %esi 10ba32: e8 59 61 00 00 call 111b90 status = pthread_create( 10ba37: 6a 00 push $0x0 10ba39: ff 34 df pushl (%edi,%ebx,8) 10ba3c: 56 push %esi 10ba3d: 8d 45 e4 lea -0x1c(%ebp),%eax 10ba40: 50 push %eax 10ba41: e8 92 fc ff ff call 10b6d8 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10ba46: 83 c4 20 add $0x20,%esp 10ba49: 85 c0 test %eax,%eax 10ba4b: 75 0e jne 10ba5b <_POSIX_Threads_Initialize_user_threads_body+0x67> * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10ba4d: 43 inc %ebx 10ba4e: 39 5d 94 cmp %ebx,-0x6c(%ebp) 10ba51: 77 c5 ja 10ba18 <_POSIX_Threads_Initialize_user_threads_body+0x24><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10ba53: 8d 65 f4 lea -0xc(%ebp),%esp 10ba56: 5b pop %ebx 10ba57: 5e pop %esi 10ba58: 5f pop %edi 10ba59: c9 leave 10ba5a: c3 ret &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10ba5b: 52 push %edx 10ba5c: 50 push %eax 10ba5d: 6a 01 push $0x1 10ba5f: 6a 02 push $0x2 10ba61: e8 ce 1e 00 00 call 10d934 <_Internal_error_Occurred> =============================================================================== 00110a4c <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 110a4c: 55 push %ebp 110a4d: 89 e5 mov %esp,%ebp 110a4f: 56 push %esi 110a50: 53 push %ebx 110a51: 8b 75 0c mov 0xc(%ebp),%esi Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 110a54: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 110a5a: 83 ec 0c sub $0xc,%esp 110a5d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax 110a63: 50 push %eax 110a64: e8 53 0f 00 00 call 1119bc <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 110a69: 89 46 78 mov %eax,0x78(%esi) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 110a6c: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax 110a73: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); the_thread->real_priority = new_priority; 110a79: 89 46 18 mov %eax,0x18(%esi) */ #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 ) { 110a7c: 83 c4 10 add $0x10,%esp 110a7f: 8b 4e 1c mov 0x1c(%esi),%ecx 110a82: 85 c9 test %ecx,%ecx 110a84: 75 05 jne 110a8b <_POSIX_Threads_Sporadic_budget_TSR+0x3f><== NEVER TAKEN /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 110a86: 39 46 14 cmp %eax,0x14(%esi) 110a89: 77 35 ja 110ac0 <_POSIX_Threads_Sporadic_budget_TSR+0x74> #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 110a8b: 83 ec 0c sub $0xc,%esp 110a8e: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax 110a94: 50 push %eax 110a95: e8 22 0f 00 00 call 1119bc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 110a9a: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 110aa0: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 110aa3: 81 c3 a8 00 00 00 add $0xa8,%ebx 110aa9: 89 5d 0c mov %ebx,0xc(%ebp) 110aac: c7 45 08 7c 76 12 00 movl $0x12767c,0x8(%ebp) } 110ab3: 8d 65 f8 lea -0x8(%ebp),%esp 110ab6: 5b pop %ebx 110ab7: 5e pop %esi 110ab8: c9 leave 110ab9: e9 3a dc ff ff jmp 10e6f8 <_Watchdog_Insert> 110abe: 66 90 xchg %ax,%ax if ( the_thread->resource_count == 0 ) { /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { _Thread_Change_priority( the_thread, new_priority, true ); 110ac0: 52 push %edx 110ac1: 6a 01 push $0x1 110ac3: 50 push %eax 110ac4: 56 push %esi 110ac5: e8 76 c9 ff ff call 10d440 <_Thread_Change_priority> 110aca: 83 c4 10 add $0x10,%esp 110acd: eb bc jmp 110a8b <_POSIX_Threads_Sporadic_budget_TSR+0x3f> =============================================================================== 00110ad0 <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 110ad0: 55 push %ebp 110ad1: 89 e5 mov %esp,%ebp 110ad3: 83 ec 08 sub $0x8,%esp 110ad6: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 110ad9: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 110adf: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 110ae6: 0f b6 15 74 32 12 00 movzbl 0x123274,%edx 110aed: 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; 110af3: 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 ) { 110af6: 8b 48 1c mov 0x1c(%eax),%ecx 110af9: 85 c9 test %ecx,%ecx 110afb: 75 05 jne 110b02 <_POSIX_Threads_Sporadic_budget_callout+0x32><== 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 ) { 110afd: 39 50 14 cmp %edx,0x14(%eax) 110b00: 72 02 jb 110b04 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN #if 0 printk( "lower priority\n" ); #endif } } } 110b02: c9 leave <== NOT EXECUTED 110b03: c3 ret <== NOT EXECUTED * 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 ) { _Thread_Change_priority( the_thread, new_priority, true ); 110b04: 51 push %ecx 110b05: 6a 01 push $0x1 110b07: 52 push %edx 110b08: 50 push %eax 110b09: e8 32 c9 ff ff call 10d440 <_Thread_Change_priority> 110b0e: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 110b11: c9 leave 110b12: c3 ret =============================================================================== 00112b4c <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 112b4c: 55 push %ebp 112b4d: 89 e5 mov %esp,%ebp 112b4f: 57 push %edi 112b50: 56 push %esi 112b51: 53 push %ebx 112b52: 83 ec 0c sub $0xc,%esp POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 112b55: 8b 45 08 mov 0x8(%ebp),%eax 112b58: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 112b5e: c7 83 d8 00 00 00 01 movl $0x1,0xd8(%ebx) 112b65: 00 00 00 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112b68: 8d b3 e8 00 00 00 lea 0xe8(%ebx),%esi while ( !_Chain_Is_empty( handler_stack ) ) { 112b6e: 39 b3 e4 00 00 00 cmp %esi,0xe4(%ebx) 112b74: 74 33 je 112ba9 <_POSIX_Threads_cancel_run+0x5d> 112b76: 66 90 xchg %ax,%ax _ISR_Disable( level ); 112b78: 9c pushf 112b79: fa cli 112b7a: 59 pop %ecx handler = (POSIX_Cancel_Handler_control *) 112b7b: 8b bb ec 00 00 00 mov 0xec(%ebx),%edi ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 112b81: 8b 17 mov (%edi),%edx previous = the_node->previous; 112b83: 8b 47 04 mov 0x4(%edi),%eax next->previous = previous; 112b86: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 112b89: 89 10 mov %edx,(%eax) _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 112b8b: 51 push %ecx 112b8c: 9d popf (*handler->routine)( handler->arg ); 112b8d: 83 ec 0c sub $0xc,%esp 112b90: ff 77 0c pushl 0xc(%edi) 112b93: ff 57 08 call *0x8(%edi) _Workspace_Free( handler ); 112b96: 89 3c 24 mov %edi,(%esp) 112b99: e8 de bd ff ff call 10e97c <_Workspace_Free> handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 112b9e: 83 c4 10 add $0x10,%esp 112ba1: 39 b3 e4 00 00 00 cmp %esi,0xe4(%ebx) 112ba7: 75 cf jne 112b78 <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 112ba9: 8d 65 f4 lea -0xc(%ebp),%esp 112bac: 5b pop %ebx 112bad: 5e pop %esi 112bae: 5f pop %edi 112baf: c9 leave 112bb0: c3 ret =============================================================================== 0011182c <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 11182c: 55 push %ebp 11182d: 89 e5 mov %esp,%ebp 11182f: 56 push %esi 111830: 53 push %ebx 111831: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; (void) _Watchdog_Remove( timer ); 111834: 83 ec 0c sub $0xc,%esp 111837: 53 push %ebx 111838: e8 0b db ff ff call 10f348 <_Watchdog_Remove> _ISR_Disable( level ); 11183d: 9c pushf 11183e: fa cli 11183f: 5e pop %esi /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 111840: 83 c4 10 add $0x10,%esp 111843: 8b 43 08 mov 0x8(%ebx),%eax 111846: 85 c0 test %eax,%eax 111848: 74 0e je 111858 <_POSIX_Timer_Insert_helper+0x2c> _ISR_Enable( level ); 11184a: 56 push %esi 11184b: 9d popf return false; 11184c: 31 c0 xor %eax,%eax */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); return true; } 11184e: 8d 65 f8 lea -0x8(%ebp),%esp 111851: 5b pop %ebx 111852: 5e pop %esi 111853: c9 leave 111854: c3 ret 111855: 8d 76 00 lea 0x0(%esi),%esi Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 111858: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) the_watchdog->routine = routine; 11185f: 8b 45 14 mov 0x14(%ebp),%eax 111862: 89 43 1c mov %eax,0x1c(%ebx) the_watchdog->id = id; 111865: 8b 45 10 mov 0x10(%ebp),%eax 111868: 89 43 20 mov %eax,0x20(%ebx) the_watchdog->user_data = user_data; 11186b: 8b 45 18 mov 0x18(%ebp),%eax 11186e: 89 43 24 mov %eax,0x24(%ebx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 111871: 8b 45 0c mov 0xc(%ebp),%eax 111874: 89 43 0c mov %eax,0xc(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 111877: 83 ec 08 sub $0x8,%esp 11187a: 53 push %ebx 11187b: 68 9c 99 12 00 push $0x12999c 111880: e8 83 d9 ff ff call 10f208 <_Watchdog_Insert> * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 111885: 56 push %esi 111886: 9d popf return true; 111887: 83 c4 10 add $0x10,%esp 11188a: b0 01 mov $0x1,%al } 11188c: 8d 65 f8 lea -0x8(%ebp),%esp 11188f: 5b pop %ebx 111890: 5e pop %esi 111891: c9 leave 111892: c3 ret =============================================================================== 0010b804 <_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) { 10b804: 55 push %ebp 10b805: 89 e5 mov %esp,%ebp 10b807: 53 push %ebx 10b808: 83 ec 04 sub $0x4,%esp 10b80b: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10b80e: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10b811: 8b 53 54 mov 0x54(%ebx),%edx 10b814: 85 d2 test %edx,%edx 10b816: 75 28 jne 10b840 <_POSIX_Timer_TSR+0x3c> 10b818: 8b 43 58 mov 0x58(%ebx),%eax 10b81b: 85 c0 test %eax,%eax 10b81d: 75 21 jne 10b840 <_POSIX_Timer_TSR+0x3c> <== ALWAYS TAKEN /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b81f: 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 ) ) { 10b823: 83 ec 08 sub $0x8,%esp 10b826: ff 73 44 pushl 0x44(%ebx) 10b829: ff 73 38 pushl 0x38(%ebx) 10b82c: e8 8b 5b 00 00 call 1113bc } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10b831: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10b838: 83 c4 10 add $0x10,%esp } 10b83b: 8b 5d fc mov -0x4(%ebp),%ebx 10b83e: c9 leave 10b83f: c3 ret ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10b840: 83 ec 0c sub $0xc,%esp 10b843: 53 push %ebx 10b844: 68 04 b8 10 00 push $0x10b804 10b849: ff 73 08 pushl 0x8(%ebx) 10b84c: ff 73 64 pushl 0x64(%ebx) 10b84f: 8d 43 10 lea 0x10(%ebx),%eax 10b852: 50 push %eax 10b853: e8 d4 5f 00 00 call 11182c <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10b858: 83 c4 20 add $0x20,%esp 10b85b: 84 c0 test %al,%al 10b85d: 74 dc je 10b83b <_POSIX_Timer_TSR+0x37> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10b85f: 83 ec 0c sub $0xc,%esp 10b862: 8d 43 6c lea 0x6c(%ebx),%eax 10b865: 50 push %eax 10b866: e8 95 16 00 00 call 10cf00 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b86b: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10b86f: 83 c4 10 add $0x10,%esp 10b872: eb af jmp 10b823 <_POSIX_Timer_TSR+0x1f> =============================================================================== 00112c38 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 112c38: 55 push %ebp 112c39: 89 e5 mov %esp,%ebp 112c3b: 57 push %edi 112c3c: 56 push %esi 112c3d: 53 push %ebx 112c3e: 83 ec 78 sub $0x78,%esp 112c41: 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, 112c44: 6a 01 push $0x1 112c46: 0f b6 45 10 movzbl 0x10(%ebp),%eax 112c4a: 50 push %eax 112c4b: 8d 55 dc lea -0x24(%ebp),%edx 112c4e: 52 push %edx 112c4f: 53 push %ebx 112c50: ff 75 08 pushl 0x8(%ebp) 112c53: 89 55 9c mov %edx,-0x64(%ebp) 112c56: e8 b5 00 00 00 call 112d10 <_POSIX_signals_Clear_signals> 112c5b: 83 c4 20 add $0x20,%esp 112c5e: 84 c0 test %al,%al 112c60: 8b 55 9c mov -0x64(%ebp),%edx 112c63: 0f 84 9b 00 00 00 je 112d04 <_POSIX_signals_Check_signal+0xcc> #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 112c69: 8d 04 5b lea (%ebx,%ebx,2),%eax 112c6c: c1 e0 02 shl $0x2,%eax 112c6f: 8b 88 c8 7b 12 00 mov 0x127bc8(%eax),%ecx 112c75: 89 4d a4 mov %ecx,-0x5c(%ebp) 112c78: 49 dec %ecx 112c79: 0f 84 85 00 00 00 je 112d04 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 112c7f: 8b 75 08 mov 0x8(%ebp),%esi 112c82: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi 112c88: 89 75 a0 mov %esi,-0x60(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 112c8b: 8b 88 c4 7b 12 00 mov 0x127bc4(%eax),%ecx 112c91: 09 f1 or %esi,%ecx 112c93: 8b 75 08 mov 0x8(%ebp),%esi 112c96: 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, 112c9c: 8d 75 b4 lea -0x4c(%ebp),%esi 112c9f: 89 75 94 mov %esi,-0x6c(%ebp) 112ca2: 8b 35 58 7b 12 00 mov 0x127b58,%esi 112ca8: 83 c6 20 add $0x20,%esi 112cab: b9 0a 00 00 00 mov $0xa,%ecx 112cb0: 8b 7d 94 mov -0x6c(%ebp),%edi 112cb3: 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 ) { 112cb5: 83 b8 c0 7b 12 00 02 cmpl $0x2,0x127bc0(%eax) 112cbc: 74 36 je 112cf4 <_POSIX_signals_Check_signal+0xbc> &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 112cbe: 83 ec 0c sub $0xc,%esp 112cc1: 53 push %ebx 112cc2: ff 55 a4 call *-0x5c(%ebp) break; 112cc5: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 112cc8: 8b 3d 58 7b 12 00 mov 0x127b58,%edi 112cce: 83 c7 20 add $0x20,%edi 112cd1: b9 0a 00 00 00 mov $0xa,%ecx 112cd6: 8b 75 94 mov -0x6c(%ebp),%esi 112cd9: 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; 112cdb: 8b 55 a0 mov -0x60(%ebp),%edx 112cde: 8b 45 08 mov 0x8(%ebp),%eax 112ce1: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) return true; 112ce7: b0 01 mov $0x1,%al } 112ce9: 8d 65 f4 lea -0xc(%ebp),%esp 112cec: 5b pop %ebx 112ced: 5e pop %esi 112cee: 5f pop %edi 112cef: c9 leave 112cf0: c3 ret 112cf1: 8d 76 00 lea 0x0(%esi),%esi /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 112cf4: 50 push %eax 112cf5: 6a 00 push $0x0 112cf7: 52 push %edx 112cf8: 53 push %ebx 112cf9: ff 55 a4 call *-0x5c(%ebp) signo, &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; 112cfc: 83 c4 10 add $0x10,%esp 112cff: eb c7 jmp 112cc8 <_POSIX_signals_Check_signal+0x90> 112d01: 8d 76 00 lea 0x0(%esi),%esi /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) return false; 112d04: 31 c0 xor %eax,%eax * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; return true; } 112d06: 8d 65 f4 lea -0xc(%ebp),%esp 112d09: 5b pop %ebx 112d0a: 5e pop %esi 112d0b: 5f pop %edi 112d0c: c9 leave 112d0d: c3 ret =============================================================================== 001132c0 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1132c0: 55 push %ebp 1132c1: 89 e5 mov %esp,%ebp 1132c3: 53 push %ebx 1132c4: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 1132c7: 9c pushf 1132c8: fa cli 1132c9: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 1132ca: 8d 04 49 lea (%ecx,%ecx,2),%eax 1132cd: c1 e0 02 shl $0x2,%eax 1132d0: 83 b8 c0 7b 12 00 02 cmpl $0x2,0x127bc0(%eax) 1132d7: 74 13 je 1132ec <_POSIX_signals_Clear_process_signals+0x2c> 1132d9: 49 dec %ecx 1132da: b8 fe ff ff ff mov $0xfffffffe,%eax if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 1132df: d3 c0 rol %cl,%eax 1132e1: 21 05 c8 7d 12 00 and %eax,0x127dc8 } _ISR_Enable( level ); 1132e7: 52 push %edx 1132e8: 9d popf } 1132e9: 5b pop %ebx 1132ea: c9 leave 1132eb: c3 ret RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 1132ec: 8d 98 e4 7d 12 00 lea 0x127de4(%eax),%ebx ISR_Level level; _ISR_Disable( level ); if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 1132f2: 39 98 e0 7d 12 00 cmp %ebx,0x127de0(%eax) 1132f8: 75 ed jne 1132e7 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN 1132fa: eb dd jmp 1132d9 <_POSIX_signals_Clear_process_signals+0x19> =============================================================================== 00112d10 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 112d10: 55 push %ebp 112d11: 89 e5 mov %esp,%ebp 112d13: 57 push %edi 112d14: 56 push %esi 112d15: 53 push %ebx 112d16: 83 ec 1c sub $0x1c,%esp 112d19: 8b 5d 0c mov 0xc(%ebp),%ebx 112d1c: 0f b6 7d 14 movzbl 0x14(%ebp),%edi static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 112d20: 8d 4b ff lea -0x1(%ebx),%ecx 112d23: b8 01 00 00 00 mov $0x1,%eax 112d28: d3 e0 shl %cl,%eax /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 112d2a: 80 7d 18 00 cmpb $0x0,0x18(%ebp) 112d2e: 74 40 je 112d70 <_POSIX_signals_Clear_signals+0x60> signals_blocked = ~api->signals_blocked; 112d30: 8b 55 08 mov 0x8(%ebp),%edx 112d33: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx 112d39: f7 d1 not %ecx signals_blocked = SIGNAL_ALL_MASK; /* XXX is this right for siginfo type signals? */ /* XXX are we sure they can be cleared the same way? */ _ISR_Disable( level ); 112d3b: 9c pushf 112d3c: fa cli 112d3d: 8f 45 e4 popl -0x1c(%ebp) if ( is_global ) { 112d40: 89 fa mov %edi,%edx 112d42: 84 d2 test %dl,%dl 112d44: 74 32 je 112d78 <_POSIX_signals_Clear_signals+0x68> if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 112d46: 23 05 c8 7d 12 00 and 0x127dc8,%eax 112d4c: 85 c8 test %ecx,%eax 112d4e: 74 54 je 112da4 <_POSIX_signals_Clear_signals+0x94> if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 112d50: 8d 14 5b lea (%ebx,%ebx,2),%edx 112d53: c1 e2 02 shl $0x2,%edx 112d56: 83 ba c0 7b 12 00 02 cmpl $0x2,0x127bc0(%edx) 112d5d: 74 49 je 112da8 <_POSIX_signals_Clear_signals+0x98> &psiginfo->Node ); } else do_callout = false; } _POSIX_signals_Clear_process_signals( signo ); 112d5f: 83 ec 0c sub $0xc,%esp 112d62: 53 push %ebx 112d63: e8 58 05 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals> 112d68: 83 c4 10 add $0x10,%esp do_callout = true; 112d6b: b0 01 mov $0x1,%al 112d6d: eb 26 jmp 112d95 <_POSIX_signals_Clear_signals+0x85> 112d6f: 90 nop */ if ( check_blocked ) signals_blocked = ~api->signals_blocked; else signals_blocked = SIGNAL_ALL_MASK; 112d70: b9 ff ff ff ff mov $0xffffffff,%ecx 112d75: eb c4 jmp 112d3b <_POSIX_signals_Clear_signals+0x2b> 112d77: 90 nop } _POSIX_signals_Clear_process_signals( signo ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 112d78: 8b 55 08 mov 0x8(%ebp),%edx 112d7b: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx 112d81: 89 c6 mov %eax,%esi 112d83: 21 de and %ebx,%esi 112d85: 85 ce test %ecx,%esi 112d87: 74 1b je 112da4 <_POSIX_signals_Clear_signals+0x94> api->signals_pending &= ~mask; 112d89: f7 d0 not %eax 112d8b: 21 d8 and %ebx,%eax 112d8d: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) do_callout = true; 112d93: b0 01 mov $0x1,%al } } _ISR_Enable( level ); 112d95: ff 75 e4 pushl -0x1c(%ebp) 112d98: 9d popf return do_callout; } 112d99: 8d 65 f4 lea -0xc(%ebp),%esp 112d9c: 5b pop %ebx 112d9d: 5e pop %esi 112d9e: 5f pop %edi 112d9f: c9 leave 112da0: c3 ret 112da1: 8d 76 00 lea 0x0(%esi),%esi bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); do_callout = false; 112da4: 31 c0 xor %eax,%eax 112da6: eb ed jmp 112d95 <_POSIX_signals_Clear_signals+0x85> do_callout = true; } } _ISR_Enable( level ); return do_callout; } 112da8: 8d 8a e0 7d 12 00 lea 0x127de0(%edx),%ecx 112dae: 8b 82 e0 7d 12 00 mov 0x127de0(%edx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112db4: 8d 71 04 lea 0x4(%ecx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 112db7: 39 f0 cmp %esi,%eax 112db9: 74 45 je 112e00 <_POSIX_signals_Clear_signals+0xf0> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 112dbb: 8b 30 mov (%eax),%esi head->next = new_first; 112dbd: 89 b2 e0 7d 12 00 mov %esi,0x127de0(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 112dc3: 89 4e 04 mov %ecx,0x4(%esi) if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); _POSIX_signals_Clear_process_signals( signo ); 112dc6: 83 ec 0c sub $0xc,%esp 112dc9: 53 push %ebx 112dca: 89 45 e0 mov %eax,-0x20(%ebp) 112dcd: e8 ee 04 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals> * It may be impossible to get here with an empty chain * BUT until that is proven we need to be defensive and * protect against it. */ if ( psiginfo ) { *info = psiginfo->Info; 112dd2: 8b 45 e0 mov -0x20(%ebp),%eax 112dd5: 8d 70 08 lea 0x8(%eax),%esi 112dd8: b9 03 00 00 00 mov $0x3,%ecx 112ddd: 8b 7d 10 mov 0x10(%ebp),%edi 112de0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 112de2: 8b 15 48 7d 12 00 mov 0x127d48,%edx the_node->next = tail; 112de8: c7 00 44 7d 12 00 movl $0x127d44,(%eax) tail->previous = the_node; 112dee: a3 48 7d 12 00 mov %eax,0x127d48 old_last->next = the_node; 112df3: 89 02 mov %eax,(%edx) the_node->previous = old_last; 112df5: 89 50 04 mov %edx,0x4(%eax) 112df8: 83 c4 10 add $0x10,%esp 112dfb: e9 5f ff ff ff jmp 112d5f <_POSIX_signals_Clear_signals+0x4f> if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); _POSIX_signals_Clear_process_signals( signo ); 112e00: 83 ec 0c sub $0xc,%esp 112e03: 53 push %ebx 112e04: e8 b7 04 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals> 112e09: 83 c4 10 add $0x10,%esp 112e0c: e9 4e ff ff ff jmp 112d5f <_POSIX_signals_Clear_signals+0x4f> =============================================================================== 0010c0dc <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10c0dc: 55 push %ebp 10c0dd: 89 e5 mov %esp,%ebp 10c0df: 56 push %esi 10c0e0: 53 push %ebx 10c0e1: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10c0e4: b8 1b 00 00 00 mov $0x1b,%eax 10c0e9: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10c0ee: 8d 48 ff lea -0x1(%eax),%ecx 10c0f1: 89 de mov %ebx,%esi 10c0f3: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10c0f5: 85 d6 test %edx,%esi 10c0f7: 75 20 jne 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10c0f9: 40 inc %eax 10c0fa: 83 f8 20 cmp $0x20,%eax 10c0fd: 75 ef jne 10c0ee <_POSIX_signals_Get_lowest+0x12> 10c0ff: b0 01 mov $0x1,%al 10c101: bb 01 00 00 00 mov $0x1,%ebx 10c106: eb 06 jmp 10c10e <_POSIX_signals_Get_lowest+0x32> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10c108: 40 inc %eax 10c109: 83 f8 1b cmp $0x1b,%eax 10c10c: 74 0b je 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN #include #include #include #include int _POSIX_signals_Get_lowest( 10c10e: 8d 48 ff lea -0x1(%eax),%ecx 10c111: 89 de mov %ebx,%esi 10c113: 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 ) ) { 10c115: 85 d6 test %edx,%esi 10c117: 74 ef je 10c108 <_POSIX_signals_Get_lowest+0x2c> * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 10c119: 5b pop %ebx 10c11a: 5e pop %esi 10c11b: c9 leave 10c11c: c3 ret =============================================================================== 00124468 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 124468: 55 push %ebp 124469: 89 e5 mov %esp,%ebp 12446b: 57 push %edi 12446c: 56 push %esi 12446d: 53 push %ebx 12446e: 83 ec 0c sub $0xc,%esp 124471: 8b 5d 08 mov 0x8(%ebp),%ebx 124474: 8b 55 0c mov 0xc(%ebp),%edx POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 124477: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi 12447d: 8d 4a ff lea -0x1(%edx),%ecx 124480: b8 01 00 00 00 mov $0x1,%eax 124485: d3 e0 shl %cl,%eax /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 124487: 8b 4b 10 mov 0x10(%ebx),%ecx 12448a: 89 cf mov %ecx,%edi 12448c: 81 e7 00 80 00 10 and $0x10008000,%edi 124492: 81 ff 00 80 00 10 cmp $0x10008000,%edi 124498: 74 72 je 12450c <_POSIX_signals_Unblock_thread+0xa4> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 12449a: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx 1244a0: f7 d2 not %edx 1244a2: 85 d0 test %edx,%eax 1244a4: 74 5a je 124500 <_POSIX_signals_Unblock_thread+0x98> * 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 ) ) { 1244a6: f7 c1 00 00 00 10 test $0x10000000,%ecx 1244ac: 74 3a je 1244e8 <_POSIX_signals_Unblock_thread+0x80> the_thread->Wait.return_code = EINTR; 1244ae: 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) ) 1244b5: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 1244bb: 0f 85 93 00 00 00 jne 124554 <_POSIX_signals_Unblock_thread+0xec> _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state) ) { 1244c1: 83 e1 08 and $0x8,%ecx 1244c4: 74 3a je 124500 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 1244c6: 83 ec 0c sub $0xc,%esp 1244c9: 8d 43 48 lea 0x48(%ebx),%eax 1244cc: 50 push %eax 1244cd: e8 8e f4 fe ff call 113960 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 1244d2: 5a pop %edx 1244d3: 59 pop %ecx 1244d4: 68 f8 ff 03 10 push $0x1003fff8 1244d9: 53 push %ebx 1244da: e8 bd e1 fe ff call 11269c <_Thread_Clear_state> 1244df: 83 c4 10 add $0x10,%esp } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 1244e2: 31 c0 xor %eax,%eax 1244e4: eb 1c jmp 124502 <_POSIX_signals_Unblock_thread+0x9a> 1244e6: 66 90 xchg %ax,%ax else if ( _States_Is_delaying(the_thread->current_state) ) { (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 1244e8: 85 c9 test %ecx,%ecx 1244ea: 75 14 jne 124500 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1244ec: a1 b4 e8 12 00 mov 0x12e8b4,%eax 1244f1: 85 c0 test %eax,%eax 1244f3: 74 0b je 124500 <_POSIX_signals_Unblock_thread+0x98> 1244f5: 3b 1d b8 e8 12 00 cmp 0x12e8b8,%ebx 1244fb: 74 7b je 124578 <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN 1244fd: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } } return false; 124500: 31 c0 xor %eax,%eax } 124502: 8d 65 f4 lea -0xc(%ebp),%esp 124505: 5b pop %ebx 124506: 5e pop %esi 124507: 5f pop %edi 124508: c9 leave 124509: c3 ret 12450a: 66 90 xchg %ax,%ax * 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) ) { 12450c: 85 43 30 test %eax,0x30(%ebx) 12450f: 74 33 je 124544 <_POSIX_signals_Unblock_thread+0xdc> the_thread->Wait.return_code = EINTR; 124511: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 124518: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 12451b: 8b 75 10 mov 0x10(%ebp),%esi 12451e: 85 f6 test %esi,%esi 124520: 74 42 je 124564 <_POSIX_signals_Unblock_thread+0xfc> the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 124522: b9 03 00 00 00 mov $0x3,%ecx 124527: 89 c7 mov %eax,%edi 124529: 8b 75 10 mov 0x10(%ebp),%esi 12452c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 12452e: 83 ec 0c sub $0xc,%esp 124531: 53 push %ebx 124532: e8 d1 eb fe ff call 113108 <_Thread_queue_Extract_with_proxy> return true; 124537: 83 c4 10 add $0x10,%esp 12453a: b0 01 mov $0x1,%al if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; } 12453c: 8d 65 f4 lea -0xc(%ebp),%esp 12453f: 5b pop %ebx 124540: 5e pop %esi 124541: 5f pop %edi 124542: c9 leave 124543: c3 ret * 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) ) { 124544: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx 12454a: f7 d1 not %ecx 12454c: 85 c8 test %ecx,%eax 12454e: 75 c1 jne 124511 <_POSIX_signals_Unblock_thread+0xa9> 124550: eb ae jmp 124500 <_POSIX_signals_Unblock_thread+0x98> 124552: 66 90 xchg %ax,%ax /* * 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) ) _Thread_queue_Extract_with_proxy( the_thread ); 124554: 83 ec 0c sub $0xc,%esp 124557: 53 push %ebx 124558: e8 ab eb fe ff call 113108 <_Thread_queue_Extract_with_proxy> 12455d: 83 c4 10 add $0x10,%esp } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 124560: 31 c0 xor %eax,%eax 124562: eb 9e jmp 124502 <_POSIX_signals_Unblock_thread+0x9a> the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 124564: 89 10 mov %edx,(%eax) the_info->si_code = SI_USER; 124566: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 12456d: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 124574: eb b8 jmp 12452e <_POSIX_signals_Unblock_thread+0xc6> 124576: 66 90 xchg %ax,%ax _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 124578: c6 05 c4 e8 12 00 01 movb $0x1,0x12e8c4 } } return false; 12457f: 31 c0 xor %eax,%eax 124581: e9 7c ff ff ff jmp 124502 <_POSIX_signals_Unblock_thread+0x9a> =============================================================================== 0010d864 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 10d864: 55 push %ebp 10d865: 89 e5 mov %esp,%ebp 10d867: 56 push %esi 10d868: 53 push %ebx 10d869: 8b 5d 08 mov 0x8(%ebp),%ebx 10d86c: 8b 75 0c mov 0xc(%ebp),%esi if ( !the_heap ) 10d86f: 85 db test %ebx,%ebx 10d871: 74 35 je 10d8a8 <_Protected_heap_Get_information+0x44> return false; if ( !the_info ) 10d873: 85 f6 test %esi,%esi 10d875: 74 31 je 10d8a8 <_Protected_heap_Get_information+0x44> return false; _RTEMS_Lock_allocator(); 10d877: 83 ec 0c sub $0xc,%esp 10d87a: ff 35 3c 80 12 00 pushl 0x12803c 10d880: e8 cf ed ff ff call 10c654 <_API_Mutex_Lock> _Heap_Get_information( the_heap, the_info ); 10d885: 5a pop %edx 10d886: 59 pop %ecx 10d887: 56 push %esi 10d888: 53 push %ebx 10d889: e8 86 47 00 00 call 112014 <_Heap_Get_information> _RTEMS_Unlock_allocator(); 10d88e: 58 pop %eax 10d88f: ff 35 3c 80 12 00 pushl 0x12803c 10d895: e8 02 ee ff ff call 10c69c <_API_Mutex_Unlock> return true; 10d89a: 83 c4 10 add $0x10,%esp 10d89d: b0 01 mov $0x1,%al } 10d89f: 8d 65 f8 lea -0x8(%ebp),%esp 10d8a2: 5b pop %ebx 10d8a3: 5e pop %esi 10d8a4: c9 leave 10d8a5: c3 ret 10d8a6: 66 90 xchg %ax,%ax { if ( !the_heap ) return false; if ( !the_info ) return false; 10d8a8: 31 c0 xor %eax,%eax _RTEMS_Lock_allocator(); _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); return true; } 10d8aa: 8d 65 f8 lea -0x8(%ebp),%esp 10d8ad: 5b pop %ebx 10d8ae: 5e pop %esi 10d8af: c9 leave 10d8b0: c3 ret =============================================================================== 00110c20 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 110c20: 55 push %ebp 110c21: 89 e5 mov %esp,%ebp 110c23: 56 push %esi 110c24: 53 push %ebx 110c25: 83 ec 10 sub $0x10,%esp 110c28: 8b 5d 08 mov 0x8(%ebp),%ebx 110c2b: 8b 75 0c mov 0xc(%ebp),%esi 110c2e: 8a 45 10 mov 0x10(%ebp),%al * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 110c31: 8b 15 50 de 12 00 mov 0x12de50,%edx 110c37: 85 d2 test %edx,%edx 110c39: 74 19 je 110c54 <_Protected_heap_Walk+0x34> _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 110c3b: 0f b6 c0 movzbl %al,%eax 110c3e: 89 45 10 mov %eax,0x10(%ebp) 110c41: 89 75 0c mov %esi,0xc(%ebp) 110c44: 89 5d 08 mov %ebx,0x8(%ebp) } return status; } 110c47: 8d 65 f8 lea -0x8(%ebp),%esp 110c4a: 5b pop %ebx 110c4b: 5e pop %esi 110c4c: c9 leave if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 110c4d: e9 1a f2 ff ff jmp 10fe6c <_Heap_Walk> 110c52: 66 90 xchg %ax,%ax * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); 110c54: 83 ec 0c sub $0xc,%esp 110c57: ff 35 3c df 12 00 pushl 0x12df3c 110c5d: 88 45 f4 mov %al,-0xc(%ebp) 110c60: e8 a7 e3 ff ff call 10f00c <_API_Mutex_Lock> status = _Heap_Walk( the_heap, source, do_dump ); 110c65: 83 c4 0c add $0xc,%esp 110c68: 8a 45 f4 mov -0xc(%ebp),%al 110c6b: 0f b6 c0 movzbl %al,%eax 110c6e: 50 push %eax 110c6f: 56 push %esi 110c70: 53 push %ebx 110c71: e8 f6 f1 ff ff call 10fe6c <_Heap_Walk> _RTEMS_Unlock_allocator(); 110c76: 5a pop %edx 110c77: ff 35 3c df 12 00 pushl 0x12df3c 110c7d: 88 45 f4 mov %al,-0xc(%ebp) 110c80: e8 cf e3 ff ff call 10f054 <_API_Mutex_Unlock> 110c85: 83 c4 10 add $0x10,%esp } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 110c88: 8a 45 f4 mov -0xc(%ebp),%al 110c8b: 8d 65 f8 lea -0x8(%ebp),%esp 110c8e: 5b pop %ebx 110c8f: 5e pop %esi 110c90: c9 leave 110c91: c3 ret =============================================================================== 00110e64 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 110e64: 55 push %ebp 110e65: 89 e5 mov %esp,%ebp 110e67: 53 push %ebx 110e68: 83 ec 10 sub $0x10,%esp 110e6b: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); 110e6e: 80 3d 44 32 12 00 01 cmpb $0x1,0x123244 110e75: 19 c0 sbb %eax,%eax 110e77: 83 e0 c0 and $0xffffffc0,%eax 110e7a: 83 c0 60 add $0x60,%eax if ( !rtems_configuration_get_notepads_enabled() ) to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 110e7d: 50 push %eax 110e7e: e8 dd da ff ff call 10e960 <_Workspace_Allocate> if ( !api ) 110e83: 83 c4 10 add $0x10,%esp 110e86: 85 c0 test %eax,%eax 110e88: 74 6a je 110ef4 <_RTEMS_tasks_Create_extension+0x90> return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 110e8a: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx) api->pending_events = EVENT_SETS_NONE_PENDING; 110e90: c7 00 00 00 00 00 movl $0x0,(%eax) api->event_condition = 0; 110e96: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) */ RTEMS_INLINE_ROUTINE void _ASR_Initialize ( ASR_Information *information ) { information->is_enabled = false; 110e9d: c6 40 08 00 movb $0x0,0x8(%eax) information->handler = NULL; 110ea1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) information->mode_set = RTEMS_DEFAULT_MODES; 110ea8: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) information->signals_posted = 0; 110eaf: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) information->signals_pending = 0; 110eb6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) information->nest_level = 0; 110ebd: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 110ec4: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 110ecb: 00 00 00 if ( rtems_configuration_get_notepads_enabled() ) { 110ece: 80 3d 44 32 12 00 00 cmpb $0x0,0x123244 110ed5: 74 13 je 110eea <_RTEMS_tasks_Create_extension+0x86> 110ed7: 31 d2 xor %edx,%edx 110ed9: 8d 76 00 lea 0x0(%esi),%esi for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 110edc: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4) 110ee3: 00 api->event_condition = 0; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 110ee4: 42 inc %edx 110ee5: 83 fa 10 cmp $0x10,%edx 110ee8: 75 f2 jne 110edc <_RTEMS_tasks_Create_extension+0x78> api->Notepads[i] = 0; } return true; 110eea: b0 01 mov $0x1,%al } 110eec: 8b 5d fc mov -0x4(%ebp),%ebx 110eef: c9 leave 110ef0: c3 ret 110ef1: 8d 76 00 lea 0x0(%esi),%esi to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) return false; 110ef4: 31 c0 xor %eax,%eax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 110ef6: 8b 5d fc mov -0x4(%ebp),%ebx 110ef9: c9 leave 110efa: c3 ret =============================================================================== 00110e0c <_RTEMS_tasks_Delete_extension>: void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 110e0c: 55 push %ebp 110e0d: 89 e5 mov %esp,%ebp 110e0f: 56 push %esi 110e10: 53 push %ebx 110e11: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Free per task variable memory */ tvp = deleted->task_variables; 110e14: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax deleted->task_variables = NULL; 110e1a: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 110e21: 00 00 00 while (tvp) { 110e24: 85 c0 test %eax,%eax 110e26: 75 06 jne 110e2e <_RTEMS_tasks_Delete_extension+0x22> 110e28: eb 17 jmp 110e41 <_RTEMS_tasks_Delete_extension+0x35> 110e2a: 66 90 xchg %ax,%ax next = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); tvp = next; 110e2c: 89 f0 mov %esi,%eax */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; 110e2e: 8b 30 mov (%eax),%esi _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 110e30: 83 ec 08 sub $0x8,%esp 110e33: 50 push %eax 110e34: 53 push %ebx 110e35: e8 56 01 00 00 call 110f90 <_RTEMS_Tasks_Invoke_task_variable_dtor> * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 110e3a: 83 c4 10 add $0x10,%esp 110e3d: 85 f6 test %esi,%esi 110e3f: 75 eb jne 110e2c <_RTEMS_tasks_Delete_extension+0x20> /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 110e41: 83 ec 0c sub $0xc,%esp 110e44: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 110e4a: e8 2d db ff ff call 10e97c <_Workspace_Free> deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 110e4f: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 110e56: 00 00 00 110e59: 83 c4 10 add $0x10,%esp } 110e5c: 8d 65 f8 lea -0x8(%ebp),%esp 110e5f: 5b pop %ebx 110e60: 5e pop %esi 110e61: c9 leave 110e62: c3 ret =============================================================================== 00110d90 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 110d90: 55 push %ebp 110d91: 89 e5 mov %esp,%ebp 110d93: 83 ec 08 sub $0x8,%esp if ( _RTEMS_tasks_Initialize_user_tasks_p ) 110d96: a1 c4 32 12 00 mov 0x1232c4,%eax 110d9b: 85 c0 test %eax,%eax 110d9d: 74 05 je 110da4 <_RTEMS_tasks_Initialize_user_tasks+0x14> (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 110d9f: c9 leave */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 110da0: ff e0 jmp *%eax 110da2: 66 90 xchg %ax,%ax } 110da4: c9 leave 110da5: c3 ret =============================================================================== 0010ba80 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10ba80: 55 push %ebp 10ba81: 89 e5 mov %esp,%ebp 10ba83: 57 push %edi 10ba84: 56 push %esi 10ba85: 53 push %ebx 10ba86: 83 ec 1c sub $0x1c,%esp rtems_initialization_tasks_table *user_tasks; /* * Move information into local variables */ user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table; 10ba89: 8b 1d 6c 32 12 00 mov 0x12326c,%ebx maximum = Configuration_RTEMS_API.number_of_initialization_tasks; 10ba8f: 8b 3d 68 32 12 00 mov 0x123268,%edi /* * Verify that we have a set of user tasks to iterate */ if ( !user_tasks ) 10ba95: 85 db test %ebx,%ebx 10ba97: 74 46 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10ba99: 85 ff test %edi,%edi 10ba9b: 74 42 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN 10ba9d: 31 f6 xor %esi,%esi 10ba9f: 90 nop return_value = rtems_task_create( 10baa0: 83 ec 08 sub $0x8,%esp 10baa3: 8d 45 e4 lea -0x1c(%ebp),%eax 10baa6: 50 push %eax 10baa7: ff 73 0c pushl 0xc(%ebx) 10baaa: ff 73 14 pushl 0x14(%ebx) 10baad: ff 73 04 pushl 0x4(%ebx) 10bab0: ff 73 08 pushl 0x8(%ebx) 10bab3: ff 33 pushl (%ebx) 10bab5: e8 92 fd ff ff call 10b84c user_tasks[ index ].stack_size, user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10baba: 83 c4 20 add $0x20,%esp 10babd: 85 c0 test %eax,%eax 10babf: 75 26 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); return_value = rtems_task_start( 10bac1: 51 push %ecx 10bac2: ff 73 18 pushl 0x18(%ebx) 10bac5: ff 73 10 pushl 0x10(%ebx) 10bac8: ff 75 e4 pushl -0x1c(%ebp) 10bacb: e8 24 00 00 00 call 10baf4 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10bad0: 83 c4 10 add $0x10,%esp 10bad3: 85 c0 test %eax,%eax 10bad5: 75 10 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10bad7: 46 inc %esi 10bad8: 83 c3 1c add $0x1c,%ebx 10badb: 39 f7 cmp %esi,%edi 10badd: 77 c1 ja 10baa0 <_RTEMS_tasks_Initialize_user_tasks_body+0x20><== NEVER TAKEN user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); } } 10badf: 8d 65 f4 lea -0xc(%ebp),%esp 10bae2: 5b pop %ebx 10bae3: 5e pop %esi 10bae4: 5f pop %edi 10bae5: c9 leave 10bae6: c3 ret id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); 10bae7: 52 push %edx 10bae8: 50 push %eax 10bae9: 6a 01 push $0x1 10baeb: 6a 01 push $0x1 10baed: e8 06 0e 00 00 call 10c8f8 <_Internal_error_Occurred> =============================================================================== 00110d48 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 110d48: 55 push %ebp 110d49: 89 e5 mov %esp,%ebp /* * Per Task Variables */ tvp = executing->task_variables; 110d4b: 8b 45 08 mov 0x8(%ebp),%eax 110d4e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 110d54: 85 c0 test %eax,%eax 110d56: 74 13 je 110d6b <_RTEMS_tasks_Switch_extension+0x23> tvp->tval = *tvp->ptr; 110d58: 8b 50 04 mov 0x4(%eax),%edx 110d5b: 8b 0a mov (%edx),%ecx 110d5d: 89 48 0c mov %ecx,0xc(%eax) *tvp->ptr = tvp->gval; 110d60: 8b 48 08 mov 0x8(%eax),%ecx 110d63: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110d65: 8b 00 mov (%eax),%eax /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 110d67: 85 c0 test %eax,%eax 110d69: 75 ed jne 110d58 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 110d6b: 8b 45 0c mov 0xc(%ebp),%eax 110d6e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 110d74: 85 c0 test %eax,%eax 110d76: 74 13 je 110d8b <_RTEMS_tasks_Switch_extension+0x43> tvp->gval = *tvp->ptr; 110d78: 8b 50 04 mov 0x4(%eax),%edx 110d7b: 8b 0a mov (%edx),%ecx 110d7d: 89 48 08 mov %ecx,0x8(%eax) *tvp->ptr = tvp->tval; 110d80: 8b 48 0c mov 0xc(%eax),%ecx 110d83: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110d85: 8b 00 mov (%eax),%eax *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 110d87: 85 c0 test %eax,%eax 110d89: 75 ed jne 110d78 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 110d8b: c9 leave 110d8c: c3 ret =============================================================================== 0010c4f0 <_Rate_monotonic_Initiate_statistics>: } void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 10c4f0: 55 push %ebp 10c4f1: 89 e5 mov %esp,%ebp 10c4f3: 57 push %edi 10c4f4: 56 push %esi 10c4f5: 53 push %ebx 10c4f6: 83 ec 28 sub $0x28,%esp 10c4f9: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *owning_thread = the_period->owner; 10c4fc: 8b 73 40 mov 0x40(%ebx),%esi * If using nanosecond statistics, we need to obtain the uptime. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ Timestamp_Control uptime; _TOD_Get_uptime( &uptime ); 10c4ff: 8d 7d e0 lea -0x20(%ebp),%edi 10c502: 57 push %edi 10c503: e8 9c 18 00 00 call 10dda4 <_TOD_Get_uptime> /* * Set the starting point and the CPU time used for the statistics. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ the_period->time_period_initiated = uptime; 10c508: 8b 45 e0 mov -0x20(%ebp),%eax 10c50b: 8b 55 e4 mov -0x1c(%ebp),%edx 10c50e: 89 43 4c mov %eax,0x4c(%ebx) 10c511: 89 53 50 mov %edx,0x50(%ebx) #else the_period->time_period_initiated = _Watchdog_Ticks_since_boot; #endif the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used; 10c514: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10c51a: 8b 96 88 00 00 00 mov 0x88(%esi),%edx 10c520: 89 43 44 mov %eax,0x44(%ebx) 10c523: 89 53 48 mov %edx,0x48(%ebx) * routine is invoked from rtems_rate_monotonic_period, the owner will * be the executing thread. When this routine is invoked from * _Rate_monotonic_Timeout, it will not. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 10c526: 83 c4 10 add $0x10,%esp 10c529: 39 35 b8 ae 12 00 cmp %esi,0x12aeb8 10c52f: 74 0b je 10c53c <_Rate_monotonic_Initiate_statistics+0x4c> ); _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran ); } #endif } 10c531: 8d 65 f4 lea -0xc(%ebp),%esp 10c534: 5b pop %ebx 10c535: 5e pop %esi 10c536: 5f pop %edi 10c537: c9 leave 10c538: c3 ret 10c539: 8d 76 00 lea 0x0(%esi),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10c53c: 50 push %eax &_Thread_Time_of_last_context_switch, &uptime, &ran 10c53d: 8d 75 d8 lea -0x28(%ebp),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10c540: 56 push %esi 10c541: 57 push %edi 10c542: 68 c8 a9 12 00 push $0x12a9c8 10c547: e8 cc 39 00 00 call 10ff18 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran ); 10c54c: 59 pop %ecx 10c54d: 5f pop %edi 10c54e: 56 push %esi 10c54f: 83 c3 44 add $0x44,%ebx 10c552: 53 push %ebx 10c553: e8 c4 38 00 00 call 10fe1c <_Timespec_Add_to> 10c558: 83 c4 10 add $0x10,%esp } #endif } 10c55b: 8d 65 f4 lea -0xc(%ebp),%esp 10c55e: 5b pop %ebx 10c55f: 5e pop %esi 10c560: 5f pop %edi 10c561: c9 leave 10c562: c3 ret =============================================================================== 0010caac <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10caac: 55 push %ebp 10caad: 89 e5 mov %esp,%ebp 10caaf: 83 ec 2c sub $0x2c,%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 ); 10cab2: 8d 45 f4 lea -0xc(%ebp),%eax 10cab5: 50 push %eax 10cab6: ff 75 08 pushl 0x8(%ebp) 10cab9: 68 e0 a7 12 00 push $0x12a7e0 10cabe: e8 79 1d 00 00 call 10e83c <_Objects_Get> switch ( location ) { 10cac3: 83 c4 10 add $0x10,%esp 10cac6: 8b 55 f4 mov -0xc(%ebp),%edx 10cac9: 85 d2 test %edx,%edx 10cacb: 75 29 jne 10caf6 <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10cacd: 8b 50 40 mov 0x40(%eax),%edx if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10cad0: f6 42 11 40 testb $0x40,0x11(%edx) 10cad4: 74 08 je 10cade <_Rate_monotonic_Timeout+0x32> 10cad6: 8b 48 08 mov 0x8(%eax),%ecx 10cad9: 39 4a 20 cmp %ecx,0x20(%edx) 10cadc: 74 4e je 10cb2c <_Rate_monotonic_Timeout+0x80> _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10cade: 83 78 38 01 cmpl $0x1,0x38(%eax) 10cae2: 74 14 je 10caf8 <_Rate_monotonic_Timeout+0x4c> _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10cae4: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10caeb: a1 d0 a8 12 00 mov 0x12a8d0,%eax 10caf0: 48 dec %eax 10caf1: a3 d0 a8 12 00 mov %eax,0x12a8d0 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10caf6: c9 leave 10caf7: c3 ret _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10caf8: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax) _Rate_monotonic_Initiate_statistics( the_period ); 10caff: 83 ec 0c sub $0xc,%esp 10cb02: 50 push %eax 10cb03: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb06: e8 e5 f9 ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10cb0b: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb0e: 8b 50 3c mov 0x3c(%eax),%edx 10cb11: 89 50 1c mov %edx,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10cb14: 5a pop %edx 10cb15: 59 pop %ecx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10cb16: 83 c0 10 add $0x10,%eax 10cb19: 50 push %eax 10cb1a: 68 dc a9 12 00 push $0x12a9dc 10cb1f: e8 d4 36 00 00 call 1101f8 <_Watchdog_Insert> 10cb24: 83 c4 10 add $0x10,%esp 10cb27: eb c2 jmp 10caeb <_Rate_monotonic_Timeout+0x3f> 10cb29: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10cb2c: 83 ec 08 sub $0x8,%esp 10cb2f: 68 f8 ff 03 10 push $0x1003fff8 10cb34: 52 push %edx 10cb35: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb38: e8 33 24 00 00 call 10ef70 <_Thread_Clear_state> the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10cb3d: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb40: 89 04 24 mov %eax,(%esp) 10cb43: eb c1 jmp 10cb06 <_Rate_monotonic_Timeout+0x5a> =============================================================================== 0010c564 <_Rate_monotonic_Update_statistics>: void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 10c564: 55 push %ebp 10c565: 89 e5 mov %esp,%ebp 10c567: 57 push %edi 10c568: 56 push %esi 10c569: 53 push %ebx 10c56a: 83 ec 1c sub $0x1c,%esp 10c56d: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 10c570: ff 43 54 incl 0x54(%ebx) if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 10c573: 83 7b 38 04 cmpl $0x4,0x38(%ebx) 10c577: 0f 84 bf 00 00 00 je 10c63c <_Rate_monotonic_Update_statistics+0xd8> stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10c57d: 51 push %ecx _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 10c57e: 8d 7d e0 lea -0x20(%ebp),%edi stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10c581: 57 push %edi _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 10c582: 8d 75 d8 lea -0x28(%ebp),%esi stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10c585: 56 push %esi 10c586: 53 push %ebx 10c587: e8 cc fe ff ff call 10c458 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 10c58c: 83 c4 10 add $0x10,%esp 10c58f: 84 c0 test %al,%al 10c591: 75 09 jne 10c59c <_Rate_monotonic_Update_statistics+0x38> stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 10c593: 8d 65 f4 lea -0xc(%ebp),%esp 10c596: 5b pop %ebx 10c597: 5e pop %esi 10c598: 5f pop %edi 10c599: c9 leave 10c59a: c3 ret 10c59b: 90 nop /* * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); 10c59c: 83 ec 08 sub $0x8,%esp 10c59f: 57 push %edi 10c5a0: 8d 43 6c lea 0x6c(%ebx),%eax 10c5a3: 50 push %eax 10c5a4: e8 73 38 00 00 call 10fe1c <_Timespec_Add_to> if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 10c5a9: 58 pop %eax 10c5aa: 5a pop %edx 10c5ab: 8d 43 5c lea 0x5c(%ebx),%eax 10c5ae: 50 push %eax 10c5af: 57 push %edi 10c5b0: e8 3f 39 00 00 call 10fef4 <_Timespec_Less_than> 10c5b5: 83 c4 10 add $0x10,%esp 10c5b8: 84 c0 test %al,%al 10c5ba: 74 0c je 10c5c8 <_Rate_monotonic_Update_statistics+0x64> stats->min_cpu_time = executed; 10c5bc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5bf: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5c2: 89 43 5c mov %eax,0x5c(%ebx) 10c5c5: 89 53 60 mov %edx,0x60(%ebx) if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 10c5c8: 83 ec 08 sub $0x8,%esp 10c5cb: 8d 43 64 lea 0x64(%ebx),%eax 10c5ce: 50 push %eax 10c5cf: 57 push %edi 10c5d0: e8 fb 38 00 00 call 10fed0 <_Timespec_Greater_than> 10c5d5: 83 c4 10 add $0x10,%esp 10c5d8: 84 c0 test %al,%al 10c5da: 74 0c je 10c5e8 <_Rate_monotonic_Update_statistics+0x84> stats->max_cpu_time = executed; 10c5dc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5df: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5e2: 89 43 64 mov %eax,0x64(%ebx) 10c5e5: 89 53 68 mov %edx,0x68(%ebx) /* * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 10c5e8: 83 ec 08 sub $0x8,%esp 10c5eb: 56 push %esi 10c5ec: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c5f2: 50 push %eax 10c5f3: e8 24 38 00 00 call 10fe1c <_Timespec_Add_to> if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 10c5f8: 5a pop %edx 10c5f9: 59 pop %ecx 10c5fa: 8d 43 74 lea 0x74(%ebx),%eax 10c5fd: 50 push %eax 10c5fe: 56 push %esi 10c5ff: e8 f0 38 00 00 call 10fef4 <_Timespec_Less_than> 10c604: 83 c4 10 add $0x10,%esp 10c607: 84 c0 test %al,%al 10c609: 75 39 jne 10c644 <_Rate_monotonic_Update_statistics+0xe0> stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 10c60b: 83 ec 08 sub $0x8,%esp 10c60e: 8d 43 7c lea 0x7c(%ebx),%eax 10c611: 50 push %eax 10c612: 56 push %esi 10c613: e8 b8 38 00 00 call 10fed0 <_Timespec_Greater_than> 10c618: 83 c4 10 add $0x10,%esp 10c61b: 84 c0 test %al,%al 10c61d: 0f 84 70 ff ff ff je 10c593 <_Rate_monotonic_Update_statistics+0x2f> stats->max_wall_time = since_last_period; 10c623: 8b 45 d8 mov -0x28(%ebp),%eax 10c626: 8b 55 dc mov -0x24(%ebp),%edx 10c629: 89 43 7c mov %eax,0x7c(%ebx) 10c62c: 89 93 80 00 00 00 mov %edx,0x80(%ebx) stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 10c632: 8d 65 f4 lea -0xc(%ebp),%esp 10c635: 5b pop %ebx 10c636: 5e pop %esi 10c637: 5f pop %edi 10c638: c9 leave 10c639: c3 ret 10c63a: 66 90 xchg %ax,%ax */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 10c63c: ff 43 58 incl 0x58(%ebx) 10c63f: e9 39 ff ff ff jmp 10c57d <_Rate_monotonic_Update_statistics+0x19> */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) stats->min_wall_time = since_last_period; 10c644: 8b 45 d8 mov -0x28(%ebp),%eax 10c647: 8b 55 dc mov -0x24(%ebp),%edx 10c64a: 89 43 74 mov %eax,0x74(%ebx) 10c64d: 89 53 78 mov %edx,0x78(%ebx) 10c650: eb b9 jmp 10c60b <_Rate_monotonic_Update_statistics+0xa7> =============================================================================== 00111608 <_Scheduler_priority_Block>: void _Scheduler_priority_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 111608: 55 push %ebp 111609: 89 e5 mov %esp,%ebp 11160b: 53 push %ebx 11160c: 8b 45 0c mov 0xc(%ebp),%eax RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract( Thread_Control *the_thread ) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; 11160f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 111615: 8b 12 mov (%edx),%edx if ( _Chain_Has_only_one_node( ready ) ) { 111617: 8b 4a 08 mov 0x8(%edx),%ecx 11161a: 39 0a cmp %ecx,(%edx) 11161c: 74 6e je 11168c <_Scheduler_priority_Block+0x84> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 11161e: 8b 08 mov (%eax),%ecx previous = the_node->previous; 111620: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 111623: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 111626: 89 0a mov %ecx,(%edx) { _Scheduler_priority_Ready_queue_extract(the_thread); /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) 111628: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 11162e: 74 18 je 111648 <_Scheduler_priority_Block+0x40> _Scheduler_priority_Schedule_body(the_scheduler); if ( _Thread_Is_executing( the_thread ) ) 111630: 3b 05 58 7b 12 00 cmp 0x127b58,%eax 111636: 74 04 je 11163c <_Scheduler_priority_Block+0x34> _Scheduler_priority_Block_body(the_scheduler, the_thread); } 111638: 5b pop %ebx 111639: c9 leave 11163a: c3 ret 11163b: 90 nop _Thread_Dispatch_necessary = true; 11163c: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 111643: 5b pop %ebx 111644: c9 leave 111645: c3 ret 111646: 66 90 xchg %ax,%ax 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 ); 111648: 66 8b 1d 80 7b 12 00 mov 0x127b80,%bx 11164f: 31 d2 xor %edx,%edx 111651: 89 d1 mov %edx,%ecx 111653: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 111657: 0f b7 c9 movzwl %cx,%ecx 11165a: 66 8b 9c 09 a0 7b 12 mov 0x127ba0(%ecx,%ecx,1),%bx 111661: 00 111662: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 111666: c1 e1 04 shl $0x4,%ecx 111669: 0f b7 d2 movzwl %dx,%edx 11166c: 8d 14 11 lea (%ecx,%edx,1),%edx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 11166f: 8d 14 52 lea (%edx,%edx,2),%edx 111672: c1 e2 02 shl $0x2,%edx 111675: 8b 4d 08 mov 0x8(%ebp),%ecx 111678: 03 11 add (%ecx),%edx 11167a: 8b 0a mov (%edx),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11167c: 83 c2 04 add $0x4,%edx 11167f: 39 d1 cmp %edx,%ecx 111681: 74 4d je 1116d0 <_Scheduler_priority_Block+0xc8><== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 111683: 89 0d 5c 7b 12 00 mov %ecx,0x127b5c 111689: eb a5 jmp 111630 <_Scheduler_priority_Block+0x28> 11168b: 90 nop RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 11168c: 8d 4a 04 lea 0x4(%edx),%ecx 11168f: 89 0a mov %ecx,(%edx) head->next = tail; head->previous = NULL; 111691: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) tail->previous = head; 111698: 89 52 08 mov %edx,0x8(%edx) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; if ( _Chain_Has_only_one_node( ready ) ) { _Chain_Initialize_empty( ready ); _Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map ); 11169b: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 1116a1: 8b 59 04 mov 0x4(%ecx),%ebx 1116a4: 66 8b 13 mov (%ebx),%dx 1116a7: 66 23 51 0e and 0xe(%ecx),%dx 1116ab: 66 89 13 mov %dx,(%ebx) if ( *the_priority_map->minor == 0 ) 1116ae: 66 85 d2 test %dx,%dx 1116b1: 0f 85 71 ff ff ff jne 111628 <_Scheduler_priority_Block+0x20> _Priority_Major_bit_map &= the_priority_map->block_major; 1116b7: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx 1116be: 23 51 0c and 0xc(%ecx),%edx 1116c1: 66 89 15 80 7b 12 00 mov %dx,0x127b80 1116c8: e9 5b ff ff ff jmp 111628 <_Scheduler_priority_Block+0x20> 1116cd: 8d 76 00 lea 0x0(%esi),%esi Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 1116d0: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 1116d2: eb af jmp 111683 <_Scheduler_priority_Block+0x7b><== NOT EXECUTED =============================================================================== 0010d238 <_Scheduler_priority_Schedule>: */ void _Scheduler_priority_Schedule( Scheduler_Control *the_scheduler ) { 10d238: 55 push %ebp 10d239: 89 e5 mov %esp,%ebp 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 ); 10d23b: 66 8b 0d 80 7b 12 00 mov 0x127b80,%cx 10d242: 31 c0 xor %eax,%eax 10d244: 89 c2 mov %eax,%edx 10d246: 66 0f bc d1 bsf %cx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10d24a: 0f b7 d2 movzwl %dx,%edx 10d24d: 66 8b 8c 12 a0 7b 12 mov 0x127ba0(%edx,%edx,1),%cx 10d254: 00 10d255: 66 0f bc c1 bsf %cx,%ax return (_Priority_Bits_index( major ) << 4) + 10d259: c1 e2 04 shl $0x4,%edx 10d25c: 0f b7 c0 movzwl %ax,%eax 10d25f: 8d 04 02 lea (%edx,%eax,1),%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10d262: 8d 04 40 lea (%eax,%eax,2),%eax 10d265: c1 e0 02 shl $0x2,%eax 10d268: 8b 55 08 mov 0x8(%ebp),%edx 10d26b: 03 02 add (%edx),%eax _Scheduler_priority_Schedule_body( the_scheduler ); } 10d26d: 8b 10 mov (%eax),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10d26f: 83 c0 04 add $0x4,%eax 10d272: 39 c2 cmp %eax,%edx 10d274: 74 0a je 10d280 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d276: 89 15 5c 7b 12 00 mov %edx,0x127b5c 10d27c: c9 leave 10d27d: c3 ret 10d27e: 66 90 xchg %ax,%ax Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10d280: 31 d2 xor %edx,%edx <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d282: 89 15 5c 7b 12 00 mov %edx,0x127b5c <== NOT EXECUTED 10d288: c9 leave <== NOT EXECUTED 10d289: c3 ret <== NOT EXECUTED =============================================================================== 0010d318 <_Scheduler_priority_Unblock>: void _Scheduler_priority_Unblock ( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 10d318: 55 push %ebp 10d319: 89 e5 mov %esp,%ebp 10d31b: 53 push %ebx 10d31c: 8b 45 0c mov 0xc(%ebp),%eax RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue( Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); 10d31f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10d325: 8b 4a 04 mov 0x4(%edx),%ecx 10d328: 66 8b 5a 0a mov 0xa(%edx),%bx 10d32c: 66 09 19 or %bx,(%ecx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10d32f: 66 8b 0d 80 7b 12 00 mov 0x127b80,%cx 10d336: 0b 4a 08 or 0x8(%edx),%ecx 10d339: 66 89 0d 80 7b 12 00 mov %cx,0x127b80 _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10d340: 8b 12 mov (%edx),%edx Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10d342: 8b 4a 08 mov 0x8(%edx),%ecx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10d345: 8d 5a 04 lea 0x4(%edx),%ebx 10d348: 89 18 mov %ebx,(%eax) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d34a: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 10d34d: 89 01 mov %eax,(%ecx) the_node->previous = old_last; 10d34f: 89 48 04 mov %ecx,0x4(%eax) * 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 ) { 10d352: 8b 50 14 mov 0x14(%eax),%edx 10d355: 8b 0d 5c 7b 12 00 mov 0x127b5c,%ecx 10d35b: 3b 51 14 cmp 0x14(%ecx),%edx 10d35e: 73 17 jae 10d377 <_Scheduler_priority_Unblock+0x5f> _Thread_Heir = the_thread; 10d360: a3 5c 7b 12 00 mov %eax,0x127b5c if ( _Thread_Executing->is_preemptible || 10d365: a1 58 7b 12 00 mov 0x127b58,%eax 10d36a: 80 78 74 00 cmpb $0x0,0x74(%eax) 10d36e: 74 0c je 10d37c <_Scheduler_priority_Unblock+0x64> the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10d370: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 _Scheduler_priority_Unblock_body(the_scheduler, the_thread); } 10d377: 5b pop %ebx 10d378: c9 leave 10d379: c3 ret 10d37a: 66 90 xchg %ax,%ax * 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 ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10d37c: 85 d2 test %edx,%edx 10d37e: 75 f7 jne 10d377 <_Scheduler_priority_Unblock+0x5f> the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10d380: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 10d387: eb ee jmp 10d377 <_Scheduler_priority_Unblock+0x5f> =============================================================================== 0010d38c <_Scheduler_priority_Yield>: */ void _Scheduler_priority_Yield( Scheduler_Control *the_scheduler __attribute__((unused)) ) { 10d38c: 55 push %ebp 10d38d: 89 e5 mov %esp,%ebp 10d38f: 56 push %esi 10d390: 53 push %ebx ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10d391: a1 58 7b 12 00 mov 0x127b58,%eax ready = executing->scheduler.priority->ready_chain; 10d396: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10d39c: 8b 12 mov (%edx),%edx _ISR_Disable( level ); 10d39e: 9c pushf 10d39f: fa cli 10d3a0: 59 pop %ecx if ( !_Chain_Has_only_one_node( ready ) ) { 10d3a1: 8b 5a 08 mov 0x8(%edx),%ebx 10d3a4: 39 1a cmp %ebx,(%edx) 10d3a6: 74 40 je 10d3e8 <_Scheduler_priority_Yield+0x5c> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10d3a8: 8b 30 mov (%eax),%esi previous = the_node->previous; 10d3aa: 8b 58 04 mov 0x4(%eax),%ebx next->previous = previous; 10d3ad: 89 5e 04 mov %ebx,0x4(%esi) previous->next = next; 10d3b0: 89 33 mov %esi,(%ebx) Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10d3b2: 8b 5a 08 mov 0x8(%edx),%ebx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10d3b5: 8d 72 04 lea 0x4(%edx),%esi 10d3b8: 89 30 mov %esi,(%eax) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d3ba: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 10d3bd: 89 03 mov %eax,(%ebx) the_node->previous = old_last; 10d3bf: 89 58 04 mov %ebx,0x4(%eax) _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10d3c2: 51 push %ecx 10d3c3: 9d popf 10d3c4: fa cli if ( _Thread_Is_heir( executing ) ) 10d3c5: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 10d3cb: 74 0f je 10d3dc <_Scheduler_priority_Yield+0x50> _Thread_Heir = (Thread_Control *) _Chain_First( ready ); _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) _Thread_Dispatch_necessary = true; 10d3cd: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 _ISR_Enable( level ); 10d3d4: 51 push %ecx 10d3d5: 9d popf } 10d3d6: 5b pop %ebx 10d3d7: 5e pop %esi 10d3d8: c9 leave 10d3d9: c3 ret 10d3da: 66 90 xchg %ax,%ax _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) _Chain_First( ready ); 10d3dc: 8b 02 mov (%edx),%eax 10d3de: a3 5c 7b 12 00 mov %eax,0x127b5c 10d3e3: eb e8 jmp 10d3cd <_Scheduler_priority_Yield+0x41> 10d3e5: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) 10d3e8: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 10d3ee: 75 dd jne 10d3cd <_Scheduler_priority_Yield+0x41> 10d3f0: eb e2 jmp 10d3d4 <_Scheduler_priority_Yield+0x48> =============================================================================== 0010dae0 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10dae0: 55 push %ebp 10dae1: 89 e5 mov %esp,%ebp 10dae3: 53 push %ebx 10dae4: 83 ec 04 sub $0x4,%esp 10dae7: 8b 5d 08 mov 0x8(%ebp),%ebx 10daea: a1 70 23 13 00 mov 0x132370,%eax 10daef: 40 inc %eax 10daf0: a3 70 23 13 00 mov %eax,0x132370 long seconds; _Thread_Disable_dispatch(); _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); 10daf5: a1 44 24 13 00 mov 0x132444,%eax if ( time->tv_sec < seconds ) 10dafa: 8b 13 mov (%ebx),%edx 10dafc: 39 d0 cmp %edx,%eax 10dafe: 7f 34 jg 10db34 <_TOD_Set+0x54> Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 10db00: 51 push %ecx _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds ); 10db01: 29 c2 sub %eax,%edx 10db03: 52 push %edx 10db04: 6a 00 push $0x0 10db06: 68 70 24 13 00 push $0x132470 10db0b: e8 e8 24 00 00 call 10fff8 <_Watchdog_Adjust> 10db10: 83 c4 10 add $0x10,%esp /* POSIX format TOD (timespec) */ _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); 10db13: 8b 03 mov (%ebx),%eax 10db15: a3 44 24 13 00 mov %eax,0x132444 10db1a: 8b 43 04 mov 0x4(%ebx),%eax 10db1d: a3 48 24 13 00 mov %eax,0x132448 _TOD_Is_set = true; 10db22: c6 05 84 23 13 00 01 movb $0x1,0x132384 _TOD_Activate(); _Thread_Enable_dispatch(); } 10db29: 8b 5d fc mov -0x4(%ebp),%ebx 10db2c: c9 leave _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); _TOD_Is_set = true; _TOD_Activate(); _Thread_Enable_dispatch(); 10db2d: e9 42 15 00 00 jmp 10f074 <_Thread_Enable_dispatch> 10db32: 66 90 xchg %ax,%ax 10db34: 51 push %ecx _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); if ( time->tv_sec < seconds ) _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); 10db35: 29 d0 sub %edx,%eax 10db37: 50 push %eax 10db38: 6a 01 push $0x1 10db3a: 68 70 24 13 00 push $0x132470 10db3f: e8 b4 24 00 00 call 10fff8 <_Watchdog_Adjust> 10db44: 83 c4 10 add $0x10,%esp 10db47: eb ca jmp 10db13 <_TOD_Set+0x33> =============================================================================== 0010c1e8 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( const rtems_time_of_day *the_tod ) { 10c1e8: 55 push %ebp 10c1e9: 89 e5 mov %esp,%ebp 10c1eb: 56 push %esi 10c1ec: 53 push %ebx 10c1ed: 8b 55 08 mov 0x8(%ebp),%edx uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 10c1f0: 8b 72 08 mov 0x8(%edx),%esi 10c1f3: 4e dec %esi year_mod_4 = the_tod->year & 3; 10c1f4: 8b 02 mov (%edx),%eax if ( year_mod_4 == 0 ) 10c1f6: 89 c3 mov %eax,%ebx 10c1f8: 83 e3 03 and $0x3,%ebx 10c1fb: 74 67 je 10c264 <_TOD_To_seconds+0x7c> time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 10c1fd: 8b 4a 04 mov 0x4(%edx),%ecx 10c200: 0f b7 8c 09 e0 3a 12 movzwl 0x123ae0(%ecx,%ecx,1),%ecx 10c207: 00 10c208: 8d 34 31 lea (%ecx,%esi,1),%esi time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10c20b: 0f b7 8c 1b 14 3b 12 movzwl 0x123b14(%ebx,%ebx,1),%ecx 10c212: 00 if ( year_mod_4 == 0 ) time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 10c213: 2d c4 07 00 00 sub $0x7c4,%eax 10c218: c1 e8 02 shr $0x2,%eax 10c21b: 8d 1c c0 lea (%eax,%eax,8),%ebx 10c21e: 8d 1c d8 lea (%eax,%ebx,8),%ebx 10c221: 8d 1c 9b lea (%ebx,%ebx,4),%ebx 10c224: 8d 04 98 lea (%eax,%ebx,4),%eax 10c227: 01 c1 add %eax,%ecx ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10c229: 01 f1 add %esi,%ecx time *= TOD_SECONDS_PER_DAY; 10c22b: 8d 04 89 lea (%ecx,%ecx,4),%eax 10c22e: 8d 04 81 lea (%ecx,%eax,4),%eax 10c231: 8d 04 c1 lea (%ecx,%eax,8),%eax 10c234: c1 e0 02 shl $0x2,%eax 10c237: 29 c8 sub %ecx,%eax 10c239: c1 e0 07 shl $0x7,%eax time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 10c23c: 8b 5a 14 mov 0x14(%edx),%ebx 10c23f: 8b 4a 0c mov 0xc(%edx),%ecx 10c242: 8d 0c 49 lea (%ecx,%ecx,2),%ecx 10c245: 8d 0c 89 lea (%ecx,%ecx,4),%ecx 10c248: c1 e1 02 shl $0x2,%ecx 10c24b: 03 4a 10 add 0x10(%edx),%ecx * TOD_SECONDS_PER_MINUTE; 10c24e: 8d 14 49 lea (%ecx,%ecx,2),%edx 10c251: 8d 14 92 lea (%edx,%edx,4),%edx time += the_tod->second; 10c254: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx time += TOD_SECONDS_1970_THROUGH_1988; 10c25b: 8d 04 02 lea (%edx,%eax,1),%eax return( time ); } 10c25e: 5b pop %ebx 10c25f: 5e pop %esi 10c260: c9 leave 10c261: c3 ret 10c262: 66 90 xchg %ax,%ax time = the_tod->day - 1; year_mod_4 = the_tod->year & 3; if ( year_mod_4 == 0 ) time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 10c264: 8b 4a 04 mov 0x4(%edx),%ecx 10c267: 0f b7 8c 09 fa 3a 12 movzwl 0x123afa(%ecx,%ecx,1),%ecx 10c26e: 00 10c26f: 8d 34 31 lea (%ecx,%esi,1),%esi 10c272: eb 97 jmp 10c20b <_TOD_To_seconds+0x23> =============================================================================== 0010c274 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10c274: 55 push %ebp 10c275: 89 e5 mov %esp,%ebp 10c277: 53 push %ebx 10c278: 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(); 10c27b: 8b 1d 2c 62 12 00 mov 0x12622c,%ebx if ((!the_tod) || 10c281: 85 c9 test %ecx,%ecx 10c283: 74 53 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10c285: b8 40 42 0f 00 mov $0xf4240,%eax 10c28a: 31 d2 xor %edx,%edx 10c28c: f7 f3 div %ebx rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10c28e: 3b 41 18 cmp 0x18(%ecx),%eax 10c291: 76 45 jbe 10c2d8 <_TOD_Validate+0x64> (the_tod->ticks >= ticks_per_second) || 10c293: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10c297: 77 3f ja 10c2d8 <_TOD_Validate+0x64> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10c299: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10c29d: 77 39 ja 10c2d8 <_TOD_Validate+0x64> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10c29f: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10c2a3: 77 33 ja 10c2d8 <_TOD_Validate+0x64> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10c2a5: 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) || 10c2a8: 85 c0 test %eax,%eax 10c2aa: 74 2c je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN (the_tod->month == 0) || 10c2ac: 83 f8 0c cmp $0xc,%eax 10c2af: 77 27 ja 10c2d8 <_TOD_Validate+0x64> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10c2b1: 8b 11 mov (%ecx),%edx (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) || 10c2b3: 81 fa c3 07 00 00 cmp $0x7c3,%edx 10c2b9: 76 1d jbe 10c2d8 <_TOD_Validate+0x64> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10c2bb: 8b 49 08 mov 0x8(%ecx),%ecx (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) || 10c2be: 85 c9 test %ecx,%ecx 10c2c0: 74 16 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10c2c2: 83 e2 03 and $0x3,%edx 10c2c5: 75 16 jne 10c2dd <_TOD_Validate+0x69> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10c2c7: 8b 04 85 54 3b 12 00 mov 0x123b54(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10c2ce: 39 c8 cmp %ecx,%eax 10c2d0: 0f 93 c0 setae %al 10c2d3: eb 05 jmp 10c2da <_TOD_Validate+0x66> 10c2d5: 8d 76 00 lea 0x0(%esi),%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; 10c2d8: 31 c0 xor %eax,%eax if ( the_tod->day > days_in_month ) return false; return true; } 10c2da: 5b pop %ebx 10c2db: c9 leave 10c2dc: c3 ret return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10c2dd: 8b 04 85 20 3b 12 00 mov 0x123b20(,%eax,4),%eax 10c2e4: eb e8 jmp 10c2ce <_TOD_Validate+0x5a> =============================================================================== 0010d440 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10d440: 55 push %ebp 10d441: 89 e5 mov %esp,%ebp 10d443: 57 push %edi 10d444: 56 push %esi 10d445: 53 push %ebx 10d446: 83 ec 28 sub $0x28,%esp 10d449: 8b 5d 08 mov 0x8(%ebp),%ebx 10d44c: 8b 75 0c mov 0xc(%ebp),%esi 10d44f: 8a 45 10 mov 0x10(%ebp),%al 10d452: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10d455: 8b 7b 10 mov 0x10(%ebx),%edi /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10d458: 53 push %ebx 10d459: e8 3a 0d 00 00 call 10e198 <_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 ) 10d45e: 83 c4 10 add $0x10,%esp 10d461: 39 73 14 cmp %esi,0x14(%ebx) 10d464: 74 0d je 10d473 <_Thread_Change_priority+0x33> _Thread_Set_priority( the_thread, new_priority ); 10d466: 83 ec 08 sub $0x8,%esp 10d469: 56 push %esi 10d46a: 53 push %ebx 10d46b: e8 c4 0c 00 00 call 10e134 <_Thread_Set_priority> 10d470: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10d473: 9c pushf 10d474: fa cli 10d475: 5e pop %esi /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10d476: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10d479: 83 f8 04 cmp $0x4,%eax 10d47c: 74 26 je 10d4a4 <_Thread_Change_priority+0x64> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10d47e: 83 e7 04 and $0x4,%edi 10d481: 74 15 je 10d498 <_Thread_Change_priority+0x58><== ALWAYS TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10d483: 56 push %esi 10d484: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10d485: a9 e0 be 03 00 test $0x3bee0,%eax 10d48a: 0f 85 94 00 00 00 jne 10d524 <_Thread_Change_priority+0xe4> if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10d490: 8d 65 f4 lea -0xc(%ebp),%esp 10d493: 5b pop %ebx 10d494: 5e pop %esi 10d495: 5f pop %edi 10d496: c9 leave 10d497: c3 ret RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10d498: 89 c2 mov %eax,%edx 10d49a: 83 e2 fb and $0xfffffffb,%edx 10d49d: 89 53 10 mov %edx,0x10(%ebx) 10d4a0: eb e1 jmp 10d483 <_Thread_Change_priority+0x43> 10d4a2: 66 90 xchg %ax,%ax } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10d4a4: 83 e7 04 and $0x4,%edi 10d4a7: 75 40 jne 10d4e9 <_Thread_Change_priority+0xa9><== NEVER TAKEN * Ready Queue with interrupts off. * * FIXME: hard-coded for priority scheduling. Might be ok since this * function is specific to priority scheduling? */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10d4a9: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10d4b0: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10d4b4: 0f 84 82 00 00 00 je 10d53c <_Thread_Change_priority+0xfc> RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue_first( Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); 10d4ba: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10d4c0: 8b 50 04 mov 0x4(%eax),%edx 10d4c3: 66 8b 48 0a mov 0xa(%eax),%cx 10d4c7: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10d4ca: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx 10d4d1: 0b 50 08 or 0x8(%eax),%edx 10d4d4: 66 89 15 80 7b 12 00 mov %dx,0x127b80 _Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain, 10d4db: 8b 00 mov (%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10d4dd: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10d4e0: 8b 10 mov (%eax),%edx after_node->next = the_node; 10d4e2: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10d4e4: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10d4e6: 89 5a 04 mov %ebx,0x4(%edx) _Scheduler_priority_Ready_queue_enqueue_first( the_thread ); else _Scheduler_priority_Ready_queue_enqueue( the_thread ); } _ISR_Flash( level ); 10d4e9: 56 push %esi 10d4ea: 9d popf 10d4eb: fa cli */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( Scheduler_Control *the_scheduler ) { the_scheduler->Operations.schedule( the_scheduler ); 10d4ec: 83 ec 0c sub $0xc,%esp 10d4ef: 68 20 76 12 00 push $0x127620 10d4f4: ff 15 24 76 12 00 call *0x127624 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10d4fa: a1 58 7b 12 00 mov 0x127b58,%eax * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(&_Scheduler); if ( !_Thread_Is_executing_also_the_heir() && 10d4ff: 83 c4 10 add $0x10,%esp 10d502: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax 10d508: 74 0d je 10d517 <_Thread_Change_priority+0xd7> 10d50a: 80 78 74 00 cmpb $0x0,0x74(%eax) 10d50e: 74 07 je 10d517 <_Thread_Change_priority+0xd7> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10d510: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 _ISR_Enable( level ); 10d517: 56 push %esi 10d518: 9d popf } 10d519: 8d 65 f4 lea -0xc(%ebp),%esp 10d51c: 5b pop %ebx 10d51d: 5e pop %esi 10d51e: 5f pop %edi 10d51f: c9 leave 10d520: c3 ret 10d521: 8d 76 00 lea 0x0(%esi),%esi /* 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 ); 10d524: 89 5d 0c mov %ebx,0xc(%ebp) 10d527: 8b 43 44 mov 0x44(%ebx),%eax 10d52a: 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 ); } 10d52d: 8d 65 f4 lea -0xc(%ebp),%esp 10d530: 5b pop %ebx 10d531: 5e pop %esi 10d532: 5f pop %edi 10d533: 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 ); 10d534: e9 63 0b 00 00 jmp 10e09c <_Thread_queue_Requeue> 10d539: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue( Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); 10d53c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10d542: 8b 50 04 mov 0x4(%eax),%edx 10d545: 66 8b 48 0a mov 0xa(%eax),%cx 10d549: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10d54c: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx 10d553: 0b 50 08 or 0x8(%eax),%edx 10d556: 66 89 15 80 7b 12 00 mov %dx,0x127b80 _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10d55d: 8b 00 mov (%eax),%eax Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10d55f: 8b 50 08 mov 0x8(%eax),%edx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10d562: 8d 48 04 lea 0x4(%eax),%ecx 10d565: 89 0b mov %ecx,(%ebx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10d567: 89 58 08 mov %ebx,0x8(%eax) old_last->next = the_node; 10d56a: 89 1a mov %ebx,(%edx) the_node->previous = old_last; 10d56c: 89 53 04 mov %edx,0x4(%ebx) 10d56f: e9 75 ff ff ff jmp 10d4e9 <_Thread_Change_priority+0xa9> =============================================================================== 0010d574 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10d574: 55 push %ebp 10d575: 89 e5 mov %esp,%ebp 10d577: 53 push %ebx 10d578: 83 ec 04 sub $0x4,%esp 10d57b: 8b 55 08 mov 0x8(%ebp),%edx 10d57e: 8b 45 0c mov 0xc(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10d581: 9c pushf 10d582: fa cli 10d583: 5b pop %ebx current_state = the_thread->current_state; 10d584: 8b 4a 10 mov 0x10(%edx),%ecx if ( current_state & state ) { 10d587: 85 c8 test %ecx,%eax 10d589: 74 0b je 10d596 <_Thread_Clear_state+0x22> 10d58b: f7 d0 not %eax 10d58d: 21 c8 and %ecx,%eax current_state = the_thread->current_state = _States_Clear( state, current_state ); 10d58f: 89 42 10 mov %eax,0x10(%edx) if ( _States_Is_ready( current_state ) ) { 10d592: 85 c0 test %eax,%eax 10d594: 74 0a je 10d5a0 <_Thread_Clear_state+0x2c> _Scheduler_Unblock( &_Scheduler, the_thread); } } _ISR_Enable( level ); 10d596: 53 push %ebx 10d597: 9d popf } 10d598: 8b 5d fc mov -0x4(%ebp),%ebx 10d59b: c9 leave 10d59c: c3 ret 10d59d: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 10d5a0: 83 ec 08 sub $0x8,%esp 10d5a3: 52 push %edx 10d5a4: 68 20 76 12 00 push $0x127620 10d5a9: ff 15 30 76 12 00 call *0x127630 10d5af: 83 c4 10 add $0x10,%esp 10d5b2: eb e2 jmp 10d596 <_Thread_Clear_state+0x22> =============================================================================== 0010d740 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10d740: 55 push %ebp 10d741: 89 e5 mov %esp,%ebp 10d743: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10d746: 8d 45 f4 lea -0xc(%ebp),%eax 10d749: 50 push %eax 10d74a: ff 75 08 pushl 0x8(%ebp) 10d74d: e8 c6 01 00 00 call 10d918 <_Thread_Get> switch ( location ) { 10d752: 83 c4 10 add $0x10,%esp 10d755: 8b 55 f4 mov -0xc(%ebp),%edx 10d758: 85 d2 test %edx,%edx 10d75a: 75 1c jne 10d778 <_Thread_Delay_ended+0x38><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10d75c: 83 ec 08 sub $0x8,%esp 10d75f: 68 18 00 00 10 push $0x10000018 10d764: 50 push %eax 10d765: e8 0a fe ff ff call 10d574 <_Thread_Clear_state> 10d76a: a1 70 75 12 00 mov 0x127570,%eax 10d76f: 48 dec %eax 10d770: a3 70 75 12 00 mov %eax,0x127570 10d775: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10d778: c9 leave 10d779: c3 ret =============================================================================== 0010d77c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10d77c: 55 push %ebp 10d77d: 89 e5 mov %esp,%ebp 10d77f: 57 push %edi 10d780: 56 push %esi 10d781: 53 push %ebx 10d782: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10d785: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx _ISR_Disable( level ); 10d78b: 9c pushf 10d78c: fa cli 10d78d: 58 pop %eax while ( _Thread_Dispatch_necessary == true ) { 10d78e: 8a 15 64 7b 12 00 mov 0x127b64,%dl 10d794: 84 d2 test %dl,%dl 10d796: 0f 84 3c 01 00 00 je 10d8d8 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10d79c: 8b 35 5c 7b 12 00 mov 0x127b5c,%esi _Thread_Dispatch_disable_level = 1; 10d7a2: c7 05 70 75 12 00 01 movl $0x1,0x127570 10d7a9: 00 00 00 _Thread_Dispatch_necessary = false; 10d7ac: c6 05 64 7b 12 00 00 movb $0x0,0x127b64 _Thread_Executing = heir; 10d7b3: 89 35 58 7b 12 00 mov %esi,0x127b58 /* * 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 ) 10d7b9: 39 f3 cmp %esi,%ebx 10d7bb: 0f 84 17 01 00 00 je 10d8d8 <_Thread_Dispatch+0x15c> 10d7c1: 8d 7d d8 lea -0x28(%ebp),%edi 10d7c4: e9 f5 00 00 00 jmp 10d8be <_Thread_Dispatch+0x142> 10d7c9: 8d 76 00 lea 0x0(%esi),%esi rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; _ISR_Enable( level ); 10d7cc: 50 push %eax 10d7cd: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10d7ce: 83 ec 0c sub $0xc,%esp 10d7d1: 8d 45 e0 lea -0x20(%ebp),%eax 10d7d4: 50 push %eax 10d7d5: e8 b6 3a 00 00 call 111290 <_TOD_Get_uptime> _Timestamp_Subtract( 10d7da: 83 c4 0c add $0xc,%esp 10d7dd: 57 push %edi 10d7de: 8d 45 e0 lea -0x20(%ebp),%eax 10d7e1: 50 push %eax 10d7e2: 68 68 76 12 00 push $0x127668 10d7e7: e8 2c 0c 00 00 call 10e418 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10d7ec: 58 pop %eax 10d7ed: 5a pop %edx 10d7ee: 57 push %edi 10d7ef: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10d7f5: 50 push %eax 10d7f6: e8 e1 0b 00 00 call 10e3dc <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10d7fb: 8b 45 e0 mov -0x20(%ebp),%eax 10d7fe: 8b 55 e4 mov -0x1c(%ebp),%edx 10d801: a3 68 76 12 00 mov %eax,0x127668 10d806: 89 15 6c 76 12 00 mov %edx,0x12766c #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10d80c: a1 40 76 12 00 mov 0x127640,%eax 10d811: 83 c4 10 add $0x10,%esp 10d814: 85 c0 test %eax,%eax 10d816: 74 10 je 10d828 <_Thread_Dispatch+0xac> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10d818: 8b 10 mov (%eax),%edx 10d81a: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10d820: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10d826: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10d828: 83 ec 08 sub $0x8,%esp 10d82b: 56 push %esi 10d82c: 53 push %ebx 10d82d: e8 86 0e 00 00 call 10e6b8 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10d832: 5a pop %edx 10d833: 59 pop %ecx 10d834: 81 c6 c8 00 00 00 add $0xc8,%esi 10d83a: 56 push %esi 10d83b: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10d841: 50 push %eax 10d842: e8 79 11 00 00 call 10e9c0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10d847: 83 c4 10 add $0x10,%esp 10d84a: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10d850: 85 c0 test %eax,%eax 10d852: 74 36 je 10d88a <_Thread_Dispatch+0x10e> #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 ); 10d854: a1 00 76 12 00 mov 0x127600,%eax 10d859: 39 c3 cmp %eax,%ebx 10d85b: 74 2d je 10d88a <_Thread_Dispatch+0x10e> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10d85d: 85 c0 test %eax,%eax 10d85f: 74 11 je 10d872 <_Thread_Dispatch+0xf6> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10d861: 83 ec 0c sub $0xc,%esp 10d864: 05 e0 00 00 00 add $0xe0,%eax 10d869: 50 push %eax 10d86a: e8 85 11 00 00 call 10e9f4 <_CPU_Context_save_fp> 10d86f: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10d872: 83 ec 0c sub $0xc,%esp 10d875: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10d87b: 50 push %eax 10d87c: e8 7d 11 00 00 call 10e9fe <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10d881: 89 1d 00 76 12 00 mov %ebx,0x127600 10d887: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10d88a: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx _ISR_Disable( level ); 10d890: 9c pushf 10d891: fa cli 10d892: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10d893: 8a 15 64 7b 12 00 mov 0x127b64,%dl 10d899: 84 d2 test %dl,%dl 10d89b: 74 3b je 10d8d8 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10d89d: 8b 35 5c 7b 12 00 mov 0x127b5c,%esi _Thread_Dispatch_disable_level = 1; 10d8a3: c7 05 70 75 12 00 01 movl $0x1,0x127570 10d8aa: 00 00 00 _Thread_Dispatch_necessary = false; 10d8ad: c6 05 64 7b 12 00 00 movb $0x0,0x127b64 _Thread_Executing = heir; 10d8b4: 89 35 58 7b 12 00 mov %esi,0x127b58 /* * 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 ) 10d8ba: 39 de cmp %ebx,%esi 10d8bc: 74 1a je 10d8d8 <_Thread_Dispatch+0x15c><== NEVER TAKEN */ #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 ) 10d8be: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10d8c2: 0f 85 04 ff ff ff jne 10d7cc <_Thread_Dispatch+0x50> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10d8c8: 8b 15 40 75 12 00 mov 0x127540,%edx 10d8ce: 89 56 78 mov %edx,0x78(%esi) 10d8d1: e9 f6 fe ff ff jmp 10d7cc <_Thread_Dispatch+0x50> 10d8d6: 66 90 xchg %ax,%ax _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10d8d8: c7 05 70 75 12 00 00 movl $0x0,0x127570 10d8df: 00 00 00 _ISR_Enable( level ); 10d8e2: 50 push %eax 10d8e3: 9d popf _API_extensions_Run_postswitch(); 10d8e4: e8 eb e5 ff ff call 10bed4 <_API_extensions_Run_postswitch> } 10d8e9: 8d 65 f4 lea -0xc(%ebp),%esp 10d8ec: 5b pop %ebx 10d8ed: 5e pop %esi 10d8ee: 5f pop %edi 10d8ef: c9 leave 10d8f0: c3 ret =============================================================================== 0010d918 <_Thread_Get>: */ Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10d918: 55 push %ebp 10d919: 89 e5 mov %esp,%ebp 10d91b: 53 push %ebx 10d91c: 83 ec 04 sub $0x4,%esp 10d91f: 8b 45 08 mov 0x8(%ebp),%eax 10d922: 8b 4d 0c mov 0xc(%ebp),%ecx uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 10d925: 85 c0 test %eax,%eax 10d927: 74 47 je 10d970 <_Thread_Get+0x58> */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 10d929: 89 c2 mov %eax,%edx 10d92b: c1 ea 18 shr $0x18,%edx 10d92e: 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 ) 10d931: 8d 5a ff lea -0x1(%edx),%ebx 10d934: 83 fb 02 cmp $0x2,%ebx 10d937: 77 27 ja 10d960 <_Thread_Get+0x48> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10d939: 89 c3 mov %eax,%ebx 10d93b: c1 eb 1b shr $0x1b,%ebx *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10d93e: 4b dec %ebx 10d93f: 75 1f jne 10d960 <_Thread_Get+0x48> *location = OBJECTS_ERROR; goto done; } #endif information = api_information[ the_class ]; 10d941: 8b 14 95 48 75 12 00 mov 0x127548(,%edx,4),%edx 10d948: 8b 52 04 mov 0x4(%edx),%edx if ( !information ) { 10d94b: 85 d2 test %edx,%edx 10d94d: 74 11 je 10d960 <_Thread_Get+0x48> *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10d94f: 53 push %ebx 10d950: 51 push %ecx 10d951: 50 push %eax 10d952: 52 push %edx 10d953: e8 e8 f4 ff ff call 10ce40 <_Objects_Get> 10d958: 83 c4 10 add $0x10,%esp done: return tp; } 10d95b: 8b 5d fc mov -0x4(%ebp),%ebx 10d95e: c9 leave 10d95f: c3 ret } #endif information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10d960: c7 01 01 00 00 00 movl $0x1,(%ecx) { uint32_t the_api; uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; 10d966: 31 c0 xor %eax,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10d968: 8b 5d fc mov -0x4(%ebp),%ebx 10d96b: c9 leave 10d96c: c3 ret 10d96d: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d970: a1 70 75 12 00 mov 0x127570,%eax 10d975: 40 inc %eax 10d976: a3 70 75 12 00 mov %eax,0x127570 Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10d97b: c7 01 00 00 00 00 movl $0x0,(%ecx) tp = _Thread_Executing; 10d981: a1 58 7b 12 00 mov 0x127b58,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10d986: 8b 5d fc mov -0x4(%ebp),%ebx 10d989: c9 leave 10d98a: c3 ret =============================================================================== 0011314c <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 11314c: 55 push %ebp 11314d: 89 e5 mov %esp,%ebp 11314f: 53 push %ebx 113150: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 113153: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 113159: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 11315f: 85 c0 test %eax,%eax 113161: 74 79 je 1131dc <_Thread_Handler+0x90> 113163: fa cli #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 113164: a0 ec 71 12 00 mov 0x1271ec,%al 113169: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 11316c: c6 05 ec 71 12 00 01 movb $0x1,0x1271ec #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 113173: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 113179: 85 c0 test %eax,%eax 11317b: 74 24 je 1131a1 <_Thread_Handler+0x55> #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 ); 11317d: a1 00 76 12 00 mov 0x127600,%eax 113182: 39 c3 cmp %eax,%ebx 113184: 74 1b je 1131a1 <_Thread_Handler+0x55> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 113186: 85 c0 test %eax,%eax 113188: 74 11 je 11319b <_Thread_Handler+0x4f> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 11318a: 83 ec 0c sub $0xc,%esp 11318d: 05 e0 00 00 00 add $0xe0,%eax 113192: 50 push %eax 113193: e8 5c b8 ff ff call 10e9f4 <_CPU_Context_save_fp> 113198: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 11319b: 89 1d 00 76 12 00 mov %ebx,0x127600 /* * 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 ); 1131a1: 83 ec 0c sub $0xc,%esp 1131a4: 53 push %ebx 1131a5: e8 72 b3 ff ff call 10e51c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 1131aa: e8 45 a7 ff ff call 10d8f4 <_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) */ { 1131af: 83 c4 10 add $0x10,%esp 1131b2: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 1131b6: 74 28 je 1131e0 <_Thread_Handler+0x94> INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 1131b8: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 1131be: 85 c0 test %eax,%eax 1131c0: 74 2d je 1131ef <_Thread_Handler+0xa3> (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 1131c2: 48 dec %eax 1131c3: 74 43 je 113208 <_Thread_Handler+0xbc> <== ALWAYS TAKEN * 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 ); 1131c5: 83 ec 0c sub $0xc,%esp 1131c8: 53 push %ebx 1131c9: e8 8a b3 ff ff call 10e558 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 1131ce: 83 c4 0c add $0xc,%esp 1131d1: 6a 05 push $0x5 1131d3: 6a 01 push $0x1 1131d5: 6a 00 push $0x0 1131d7: e8 1c 97 ff ff call 10c8f8 <_Internal_error_Occurred> * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; _ISR_Set_level(level); 1131dc: fb sti 1131dd: eb 85 jmp 113164 <_Thread_Handler+0x18> 1131df: 90 nop * _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) */ { INIT_NAME (); 1131e0: e8 8b be 00 00 call 11f070 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 1131e5: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 1131eb: 85 c0 test %eax,%eax 1131ed: 75 d3 jne 1131c2 <_Thread_Handler+0x76> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 1131ef: 83 ec 0c sub $0xc,%esp 1131f2: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 1131f8: ff 93 90 00 00 00 call *0x90(%ebx) INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 1131fe: 89 43 28 mov %eax,0x28(%ebx) 113201: 83 c4 10 add $0x10,%esp 113204: eb bf jmp 1131c5 <_Thread_Handler+0x79> 113206: 66 90 xchg %ax,%ax ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 113208: 83 ec 0c sub $0xc,%esp 11320b: ff b3 98 00 00 00 pushl 0x98(%ebx) 113211: ff 93 90 00 00 00 call *0x90(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 113217: 89 43 28 mov %eax,0x28(%ebx) 11321a: 83 c4 10 add $0x10,%esp 11321d: eb a6 jmp 1131c5 <_Thread_Handler+0x79> =============================================================================== 0010d98c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10d98c: 55 push %ebp 10d98d: 89 e5 mov %esp,%ebp 10d98f: 57 push %edi 10d990: 56 push %esi 10d991: 53 push %ebx 10d992: 83 ec 1c sub $0x1c,%esp 10d995: 8b 5d 0c mov 0xc(%ebp),%ebx 10d998: 8b 4d 10 mov 0x10(%ebp),%ecx 10d99b: 8b 75 14 mov 0x14(%ebp),%esi 10d99e: 8a 55 18 mov 0x18(%ebp),%dl 10d9a1: 0f b6 7d 20 movzbl 0x20(%ebp),%edi /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10d9a5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10d9ac: 00 00 00 10d9af: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10d9b6: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10d9b9: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10d9c0: 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 ) { 10d9c3: 85 c9 test %ecx,%ecx 10d9c5: 0f 84 14 02 00 00 je 10dbdf <_Thread_Initialize+0x253> stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = true; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10d9cb: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10d9d2: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10d9d4: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10d9da: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10d9e0: 84 d2 test %dl,%dl 10d9e2: 0f 85 94 01 00 00 jne 10db7c <_Thread_Initialize+0x1f0> 10d9e8: 31 c0 xor %eax,%eax extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10d9ea: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10d9f1: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10d9f7: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10d9fd: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10da04: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10da0b: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10da12: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10da19: a1 4c 76 12 00 mov 0x12764c,%eax 10da1e: 85 c0 test %eax,%eax 10da20: 0f 85 7a 01 00 00 jne 10dba0 <_Thread_Initialize+0x214> (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10da26: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10da2d: 00 00 00 * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10da30: 31 f6 xor %esi,%esi /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10da32: 89 f8 mov %edi,%eax 10da34: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10da3a: 8b 45 24 mov 0x24(%ebp),%eax 10da3d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10da43: 8b 45 28 mov 0x28(%ebp),%eax 10da46: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10da4c: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10da50: 75 08 jne 10da5a <_Thread_Initialize+0xce> 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; 10da52: a1 40 75 12 00 mov 0x127540,%eax 10da57: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10da5a: 8b 45 2c mov 0x2c(%ebp),%eax 10da5d: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10da63: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10da6a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10da71: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10da78: 8b 45 1c mov 0x1c(%ebp),%eax 10da7b: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10da7e: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { return 10da84: 83 ec 08 sub $0x8,%esp 10da87: 53 push %ebx 10da88: 68 20 76 12 00 push $0x127620 10da8d: ff 15 34 76 12 00 call *0x127634 10da93: 89 c7 mov %eax,%edi sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread ); if ( !sched ) 10da95: 83 c4 10 add $0x10,%esp 10da98: 85 c0 test %eax,%eax 10da9a: 74 46 je 10dae2 <_Thread_Initialize+0x156> goto failed; _Thread_Set_priority( the_thread, priority ); 10da9c: 83 ec 08 sub $0x8,%esp 10da9f: ff 75 1c pushl 0x1c(%ebp) 10daa2: 53 push %ebx 10daa3: e8 8c 06 00 00 call 10e134 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10daa8: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10daaf: 00 00 00 10dab2: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10dab9: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10dabc: 8b 45 08 mov 0x8(%ebp),%eax 10dabf: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10dac2: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10dac6: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10dac9: 8b 45 30 mov 0x30(%ebp),%eax 10dacc: 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 ); 10dacf: 89 1c 24 mov %ebx,(%esp) 10dad2: e8 0d 0b 00 00 call 10e5e4 <_User_extensions_Thread_create> if ( extension_status ) 10dad7: 83 c4 10 add $0x10,%esp 10dada: 84 c0 test %al,%al 10dadc: 0f 85 8e 00 00 00 jne 10db70 <_Thread_Initialize+0x1e4> return true; failed: if ( the_thread->libc_reent ) 10dae2: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10dae8: 85 c0 test %eax,%eax 10daea: 74 0c je 10daf8 <_Thread_Initialize+0x16c> _Workspace_Free( the_thread->libc_reent ); 10daec: 83 ec 0c sub $0xc,%esp 10daef: 50 push %eax 10daf0: e8 87 0e 00 00 call 10e97c <_Workspace_Free> 10daf5: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10daf8: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax 10dafe: 85 c0 test %eax,%eax 10db00: 74 0c je 10db0e <_Thread_Initialize+0x182> _Workspace_Free( the_thread->API_Extensions[i] ); 10db02: 83 ec 0c sub $0xc,%esp 10db05: 50 push %eax 10db06: e8 71 0e 00 00 call 10e97c <_Workspace_Free> 10db0b: 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] ) 10db0e: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 10db14: 85 c0 test %eax,%eax 10db16: 74 0c je 10db24 <_Thread_Initialize+0x198> _Workspace_Free( the_thread->API_Extensions[i] ); 10db18: 83 ec 0c sub $0xc,%esp 10db1b: 50 push %eax 10db1c: e8 5b 0e 00 00 call 10e97c <_Workspace_Free> 10db21: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10db24: 85 f6 test %esi,%esi 10db26: 74 0c je 10db34 <_Thread_Initialize+0x1a8> (void) _Workspace_Free( extensions_area ); 10db28: 83 ec 0c sub $0xc,%esp 10db2b: 56 push %esi 10db2c: e8 4b 0e 00 00 call 10e97c <_Workspace_Free> 10db31: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10db34: 8b 45 e4 mov -0x1c(%ebp),%eax 10db37: 85 c0 test %eax,%eax 10db39: 74 0e je 10db49 <_Thread_Initialize+0x1bd> (void) _Workspace_Free( fp_area ); 10db3b: 83 ec 0c sub $0xc,%esp 10db3e: ff 75 e4 pushl -0x1c(%ebp) 10db41: e8 36 0e 00 00 call 10e97c <_Workspace_Free> 10db46: 83 c4 10 add $0x10,%esp #endif if ( sched ) 10db49: 85 ff test %edi,%edi 10db4b: 74 0c je 10db59 <_Thread_Initialize+0x1cd> (void) _Workspace_Free( sched ); 10db4d: 83 ec 0c sub $0xc,%esp 10db50: 57 push %edi 10db51: e8 26 0e 00 00 call 10e97c <_Workspace_Free> 10db56: 83 c4 10 add $0x10,%esp _Thread_Stack_Free( the_thread ); 10db59: 83 ec 0c sub $0xc,%esp 10db5c: 53 push %ebx 10db5d: e8 0a 07 00 00 call 10e26c <_Thread_Stack_Free> return false; 10db62: 83 c4 10 add $0x10,%esp 10db65: 31 c0 xor %eax,%eax } 10db67: 8d 65 f4 lea -0xc(%ebp),%esp 10db6a: 5b pop %ebx 10db6b: 5e pop %esi 10db6c: 5f pop %edi 10db6d: c9 leave 10db6e: c3 ret 10db6f: 90 nop * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; 10db70: b0 01 mov $0x1,%al _Thread_Stack_Free( the_thread ); return false; } 10db72: 8d 65 f4 lea -0xc(%ebp),%esp 10db75: 5b pop %ebx 10db76: 5e pop %esi 10db77: 5f pop %edi 10db78: c9 leave 10db79: c3 ret 10db7a: 66 90 xchg %ax,%ax /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10db7c: 83 ec 0c sub $0xc,%esp 10db7f: 6a 6c push $0x6c 10db81: e8 da 0d 00 00 call 10e960 <_Workspace_Allocate> 10db86: 89 45 e4 mov %eax,-0x1c(%ebp) if ( !fp_area ) 10db89: 83 c4 10 add $0x10,%esp 10db8c: 85 c0 test %eax,%eax 10db8e: 0f 85 5d fe ff ff jne 10d9f1 <_Thread_Initialize+0x65> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10db94: 31 f6 xor %esi,%esi size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10db96: 31 ff xor %edi,%edi 10db98: e9 45 ff ff ff jmp 10dae2 <_Thread_Initialize+0x156> 10db9d: 8d 76 00 lea 0x0(%esi),%esi /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10dba0: 83 ec 0c sub $0xc,%esp 10dba3: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10dbaa: 50 push %eax 10dbab: e8 b0 0d 00 00 call 10e960 <_Workspace_Allocate> 10dbb0: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10dbb2: 83 c4 10 add $0x10,%esp 10dbb5: 85 c0 test %eax,%eax 10dbb7: 74 5a je 10dc13 <_Thread_Initialize+0x287> goto failed; } the_thread->extensions = (void **) extensions_area; 10dbb9: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) 10dbbf: 8b 0d 4c 76 12 00 mov 0x12764c,%ecx * 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++ ) 10dbc5: 31 d2 xor %edx,%edx (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10dbc7: 31 c0 xor %eax,%eax 10dbc9: 8d 76 00 lea 0x0(%esi),%esi * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) the_thread->extensions[i] = NULL; 10dbcc: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,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++ ) 10dbd3: 40 inc %eax 10dbd4: 89 c2 mov %eax,%edx 10dbd6: 39 c1 cmp %eax,%ecx 10dbd8: 73 f2 jae 10dbcc <_Thread_Initialize+0x240> 10dbda: e9 53 fe ff ff jmp 10da32 <_Thread_Initialize+0xa6> return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10dbdf: 83 ec 08 sub $0x8,%esp 10dbe2: 56 push %esi 10dbe3: 53 push %ebx 10dbe4: 88 55 e0 mov %dl,-0x20(%ebp) 10dbe7: e8 1c 06 00 00 call 10e208 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10dbec: 83 c4 10 add $0x10,%esp 10dbef: 85 c0 test %eax,%eax 10dbf1: 8a 55 e0 mov -0x20(%ebp),%dl 10dbf4: 74 16 je 10dc0c <_Thread_Initialize+0x280> 10dbf6: 39 c6 cmp %eax,%esi 10dbf8: 77 12 ja 10dc0c <_Thread_Initialize+0x280><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10dbfa: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10dc00: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10dc07: e9 c8 fd ff ff jmp 10d9d4 <_Thread_Initialize+0x48> 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 */ 10dc0c: 31 c0 xor %eax,%eax 10dc0e: e9 54 ff ff ff jmp 10db67 <_Thread_Initialize+0x1db> size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10dc13: 31 ff xor %edi,%edi 10dc15: e9 c8 fe ff ff jmp 10dae2 <_Thread_Initialize+0x156> =============================================================================== 00112610 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 112610: 55 push %ebp 112611: 89 e5 mov %esp,%ebp 112613: 53 push %ebx 112614: 83 ec 10 sub $0x10,%esp 112617: 8b 5d 08 mov 0x8(%ebp),%ebx the_thread->resource_count = 0; 11261a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 112621: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 112627: 88 43 74 mov %al,0x74(%ebx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 11262a: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 112630: 89 43 7c mov %eax,0x7c(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 112633: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 112639: 89 83 80 00 00 00 mov %eax,0x80(%ebx) the_thread->Start.pointer_argument = pointer_argument; 11263f: 8b 45 0c mov 0xc(%ebp),%eax 112642: 89 83 98 00 00 00 mov %eax,0x98(%ebx) the_thread->Start.numeric_argument = numeric_argument; 112648: 8b 45 10 mov 0x10(%ebp),%eax 11264b: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 112651: 53 push %ebx 112652: e8 c5 c4 ff ff call 10eb1c <_Thread_queue_Extract_with_proxy> 112657: 83 c4 10 add $0x10,%esp 11265a: 84 c0 test %al,%al 11265c: 75 06 jne 112664 <_Thread_Reset+0x54> if ( _Watchdog_Is_active( &the_thread->Timer ) ) 11265e: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 112662: 74 28 je 11268c <_Thread_Reset+0x7c> (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 112664: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 11266a: 39 43 14 cmp %eax,0x14(%ebx) 11266d: 74 15 je 112684 <_Thread_Reset+0x74> the_thread->real_priority = the_thread->Start.initial_priority; 11266f: 89 43 18 mov %eax,0x18(%ebx) _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 112672: 89 45 0c mov %eax,0xc(%ebp) 112675: 89 5d 08 mov %ebx,0x8(%ebp) } } 112678: 8b 5d fc mov -0x4(%ebp),%ebx 11267b: c9 leave (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { the_thread->real_priority = the_thread->Start.initial_priority; _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 11267c: e9 77 c6 ff ff jmp 10ecf8 <_Thread_Set_priority> 112681: 8d 76 00 lea 0x0(%esi),%esi } } 112684: 8b 5d fc mov -0x4(%ebp),%ebx 112687: c9 leave 112688: c3 ret 112689: 8d 76 00 lea 0x0(%esi),%esi the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 11268c: 83 ec 0c sub $0xc,%esp 11268f: 8d 43 48 lea 0x48(%ebx),%eax 112692: 50 push %eax 112693: e8 a4 cd ff ff call 10f43c <_Watchdog_Remove> 112698: 83 c4 10 add $0x10,%esp 11269b: eb c7 jmp 112664 <_Thread_Reset+0x54> =============================================================================== 0011146c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 11146c: 55 push %ebp 11146d: 89 e5 mov %esp,%ebp 11146f: 53 push %ebx 111470: 83 ec 04 sub $0x4,%esp 111473: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 111476: 9c pushf 111477: fa cli 111478: 5b pop %ebx current_state = the_thread->current_state; 111479: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 11147c: f6 c2 02 test $0x2,%dl 11147f: 74 0a je 11148b <_Thread_Resume+0x1f> <== NEVER TAKEN 111481: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 111484: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 111487: 85 d2 test %edx,%edx 111489: 74 09 je 111494 <_Thread_Resume+0x28> _Scheduler_Unblock( &_Scheduler, the_thread ); } } _ISR_Enable( level ); 11148b: 53 push %ebx 11148c: 9d popf } 11148d: 8b 5d fc mov -0x4(%ebp),%ebx 111490: c9 leave 111491: c3 ret 111492: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 111494: 83 ec 08 sub $0x8,%esp 111497: 50 push %eax 111498: 68 e0 af 12 00 push $0x12afe0 11149d: ff 15 f0 af 12 00 call *0x12aff0 1114a3: 83 c4 10 add $0x10,%esp 1114a6: eb e3 jmp 11148b <_Thread_Resume+0x1f> =============================================================================== 0010e208 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10e208: 55 push %ebp 10e209: 89 e5 mov %esp,%ebp 10e20b: 53 push %ebx 10e20c: 83 ec 04 sub $0x4,%esp the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) the_stack_size = 0; 10e20f: a1 70 32 12 00 mov 0x123270,%eax 10e214: 8b 5d 0c mov 0xc(%ebp),%ebx 10e217: 39 c3 cmp %eax,%ebx 10e219: 73 02 jae 10e21d <_Thread_Stack_Allocate+0x15> 10e21b: 89 c3 mov %eax,%ebx * Call ONLY the CPU table stack allocate hook, _or_ the * the RTEMS workspace allocate. This is so the stack free * routine can call the correct deallocation routine. */ if ( Configuration.stack_allocate_hook ) { 10e21d: a1 a4 32 12 00 mov 0x1232a4,%eax 10e222: 85 c0 test %eax,%eax 10e224: 74 32 je 10e258 <_Thread_Stack_Allocate+0x50> stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size ); 10e226: 83 ec 0c sub $0xc,%esp 10e229: 53 push %ebx 10e22a: ff d0 call *%eax 10e22c: 83 c4 10 add $0x10,%esp the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10e22f: 85 c0 test %eax,%eax 10e231: 74 11 je 10e244 <_Thread_Stack_Allocate+0x3c> the_stack_size = 0; the_thread->Start.stack = stack_addr; 10e233: 8b 55 08 mov 0x8(%ebp),%edx 10e236: 89 82 c4 00 00 00 mov %eax,0xc4(%edx) return the_stack_size; } 10e23c: 89 d8 mov %ebx,%eax 10e23e: 8b 5d fc mov -0x4(%ebp),%ebx 10e241: c9 leave 10e242: c3 ret 10e243: 90 nop the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) the_stack_size = 0; 10e244: 31 db xor %ebx,%ebx the_thread->Start.stack = stack_addr; 10e246: 8b 55 08 mov 0x8(%ebp),%edx 10e249: 89 82 c4 00 00 00 mov %eax,0xc4(%edx) return the_stack_size; } 10e24f: 89 d8 mov %ebx,%eax 10e251: 8b 5d fc mov -0x4(%ebp),%ebx 10e254: c9 leave 10e255: c3 ret 10e256: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size ( size_t size ) { return size + CPU_STACK_ALIGNMENT; 10e258: 83 c3 10 add $0x10,%ebx * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 10e25b: 83 ec 0c sub $0xc,%esp 10e25e: 53 push %ebx 10e25f: e8 fc 06 00 00 call 10e960 <_Workspace_Allocate> 10e264: 83 c4 10 add $0x10,%esp 10e267: eb c6 jmp 10e22f <_Thread_Stack_Allocate+0x27> =============================================================================== 0010e26c <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10e26c: 55 push %ebp 10e26d: 89 e5 mov %esp,%ebp 10e26f: 83 ec 08 sub $0x8,%esp 10e272: 8b 45 08 mov 0x8(%ebp),%eax #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10e275: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax) 10e27c: 74 16 je 10e294 <_Thread_Stack_Free+0x28> * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( Configuration.stack_free_hook ) 10e27e: 8b 15 a8 32 12 00 mov 0x1232a8,%edx 10e284: 85 d2 test %edx,%edx 10e286: 74 10 je 10e298 <_Thread_Stack_Free+0x2c> (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); 10e288: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e28e: 89 45 08 mov %eax,0x8(%ebp) else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10e291: c9 leave * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( Configuration.stack_free_hook ) (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); 10e292: ff e2 jmp *%edx else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10e294: c9 leave 10e295: c3 ret 10e296: 66 90 xchg %ax,%ax */ if ( Configuration.stack_free_hook ) (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10e298: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e29e: 89 45 08 mov %eax,0x8(%ebp) } 10e2a1: c9 leave */ if ( Configuration.stack_free_hook ) (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10e2a2: e9 d5 06 00 00 jmp 10e97c <_Workspace_Free> =============================================================================== 00111978 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 111978: 55 push %ebp 111979: 89 e5 mov %esp,%ebp 11197b: 53 push %ebx 11197c: 83 ec 04 sub $0x4,%esp 11197f: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; _ISR_Disable( level ); 111982: 9c pushf 111983: fa cli 111984: 5b pop %ebx if ( !_States_Is_ready( the_thread->current_state ) ) { 111985: 8b 50 10 mov 0x10(%eax),%edx 111988: 85 d2 test %edx,%edx 11198a: 74 10 je 11199c <_Thread_Suspend+0x24> 11198c: 83 ca 02 or $0x2,%edx 11198f: 89 50 10 mov %edx,0x10(%eax) the_thread->current_state = _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 111992: 53 push %ebx 111993: 9d popf the_thread->current_state = STATES_SUSPENDED; _Scheduler_Block(&_Scheduler, the_thread); _ISR_Enable( level ); } 111994: 8b 5d fc mov -0x4(%ebp),%ebx 111997: c9 leave 111998: c3 ret 111999: 8d 76 00 lea 0x0(%esi),%esi _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 11199c: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax) RTEMS_INLINE_ROUTINE void _Scheduler_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.block( the_scheduler, the_thread ); 1119a3: 83 ec 08 sub $0x8,%esp 1119a6: 50 push %eax 1119a7: 68 20 76 12 00 push $0x127620 1119ac: ff 15 2c 76 12 00 call *0x12762c _Scheduler_Block(&_Scheduler, the_thread); _ISR_Enable( level ); 1119b2: 53 push %ebx 1119b3: 9d popf 1119b4: 83 c4 10 add $0x10,%esp } 1119b7: 8b 5d fc mov -0x4(%ebp),%ebx 1119ba: c9 leave 1119bb: c3 ret =============================================================================== 0010e364 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10e364: 55 push %ebp 10e365: 89 e5 mov %esp,%ebp 10e367: 53 push %ebx 10e368: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10e36b: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10e371: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10e375: 74 19 je 10e390 <_Thread_Tickle_timeslice+0x2c> return; if ( !_States_Is_ready( executing->current_state ) ) 10e377: 8b 43 10 mov 0x10(%ebx),%eax 10e37a: 85 c0 test %eax,%eax 10e37c: 75 12 jne 10e390 <_Thread_Tickle_timeslice+0x2c> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10e37e: 8b 43 7c mov 0x7c(%ebx),%eax 10e381: 83 f8 01 cmp $0x1,%eax 10e384: 72 0a jb 10e390 <_Thread_Tickle_timeslice+0x2c> 10e386: 83 f8 02 cmp $0x2,%eax 10e389: 76 29 jbe 10e3b4 <_Thread_Tickle_timeslice+0x50> 10e38b: 83 f8 03 cmp $0x3,%eax 10e38e: 74 08 je 10e398 <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; #endif } } 10e390: 8b 5d fc mov -0x4(%ebp),%ebx 10e393: c9 leave 10e394: c3 ret 10e395: 8d 76 00 lea 0x0(%esi),%esi } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10e398: 8b 43 78 mov 0x78(%ebx),%eax 10e39b: 48 dec %eax 10e39c: 89 43 78 mov %eax,0x78(%ebx) 10e39f: 85 c0 test %eax,%eax 10e3a1: 75 ed jne 10e390 <_Thread_Tickle_timeslice+0x2c> (*executing->budget_callout)( executing ); 10e3a3: 83 ec 0c sub $0xc,%esp 10e3a6: 53 push %ebx 10e3a7: ff 93 80 00 00 00 call *0x80(%ebx) 10e3ad: 83 c4 10 add $0x10,%esp 10e3b0: eb de jmp 10e390 <_Thread_Tickle_timeslice+0x2c> 10e3b2: 66 90 xchg %ax,%ax 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 ) { 10e3b4: 8b 43 78 mov 0x78(%ebx),%eax 10e3b7: 48 dec %eax 10e3b8: 89 43 78 mov %eax,0x78(%ebx) 10e3bb: 85 c0 test %eax,%eax 10e3bd: 7f d1 jg 10e390 <_Thread_Tickle_timeslice+0x2c> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield( &_Scheduler ); 10e3bf: 83 ec 0c sub $0xc,%esp 10e3c2: 68 20 76 12 00 push $0x127620 10e3c7: ff 15 28 76 12 00 call *0x127628 * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield( ); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10e3cd: a1 40 75 12 00 mov 0x127540,%eax 10e3d2: 89 43 78 mov %eax,0x78(%ebx) 10e3d5: 83 c4 10 add $0x10,%esp 10e3d8: eb b6 jmp 10e390 <_Thread_Tickle_timeslice+0x2c> =============================================================================== 0010dcf4 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10dcf4: 55 push %ebp 10dcf5: 89 e5 mov %esp,%ebp 10dcf7: 57 push %edi 10dcf8: 56 push %esi 10dcf9: 53 push %ebx 10dcfa: 83 ec 2c sub $0x2c,%esp 10dcfd: 8b 7d 08 mov 0x8(%ebp),%edi Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 10dd00: 9c pushf 10dd01: fa cli 10dd02: 58 pop %eax 10dd03: 89 f9 mov %edi,%ecx for( index=0 ; 10dd05: 31 d2 xor %edx,%edx #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10dd07: 8b 19 mov (%ecx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10dd09: 8d 34 52 lea (%edx,%edx,2),%esi 10dd0c: 8d 74 b7 04 lea 0x4(%edi,%esi,4),%esi _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 10dd10: 39 f3 cmp %esi,%ebx 10dd12: 75 18 jne 10dd2c <_Thread_queue_Dequeue_priority+0x38> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10dd14: 42 inc %edx 10dd15: 83 c1 0c add $0xc,%ecx Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 10dd18: 83 fa 04 cmp $0x4,%edx 10dd1b: 75 ea jne 10dd07 <_Thread_queue_Dequeue_priority+0x13> } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10dd1d: 50 push %eax 10dd1e: 9d popf return NULL; 10dd1f: 31 f6 xor %esi,%esi #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10dd21: 89 f0 mov %esi,%eax 10dd23: 8d 65 f4 lea -0xc(%ebp),%esp 10dd26: 5b pop %ebx 10dd27: 5e pop %esi 10dd28: 5f pop %edi 10dd29: c9 leave 10dd2a: c3 ret 10dd2b: 90 nop _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) _Chain_First( 10dd2c: 89 de mov %ebx,%esi */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10dd2e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10dd35: 8b 53 38 mov 0x38(%ebx),%edx dequeue: the_thread->Wait.queue = NULL; new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10dd38: 8b 0b mov (%ebx),%ecx previous_node = the_thread->Object.Node.previous; 10dd3a: 8b 7b 04 mov 0x4(%ebx),%edi 10dd3d: 89 7d d4 mov %edi,-0x2c(%ebp) 10dd40: 8d 7b 3c lea 0x3c(%ebx),%edi if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10dd43: 39 fa cmp %edi,%edx 10dd45: 74 7f je 10ddc6 <_Thread_queue_Dequeue_priority+0xd2> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10dd47: 8b 7b 40 mov 0x40(%ebx),%edi 10dd4a: 89 7d e4 mov %edi,-0x1c(%ebp) next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; 10dd4d: 8b 3a mov (%edx),%edi 10dd4f: 89 7d e0 mov %edi,-0x20(%ebp) previous_node->next = new_first_node; 10dd52: 8b 7d d4 mov -0x2c(%ebp),%edi 10dd55: 89 17 mov %edx,(%edi) next_node->previous = new_first_node; 10dd57: 89 51 04 mov %edx,0x4(%ecx) new_first_node->next = next_node; 10dd5a: 89 0a mov %ecx,(%edx) new_first_node->previous = previous_node; 10dd5c: 89 7a 04 mov %edi,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10dd5f: 8b 4b 40 mov 0x40(%ebx),%ecx 10dd62: 39 4b 38 cmp %ecx,0x38(%ebx) 10dd65: 74 17 je 10dd7e <_Thread_queue_Dequeue_priority+0x8a> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 10dd67: 8d 4a 38 lea 0x38(%edx),%ecx 10dd6a: 8b 7d e0 mov -0x20(%ebp),%edi 10dd6d: 89 4f 04 mov %ecx,0x4(%edi) tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 10dd70: 89 7a 38 mov %edi,0x38(%edx) tail->previous = last_node; 10dd73: 8b 4d e4 mov -0x1c(%ebp),%ecx 10dd76: 89 4a 40 mov %ecx,0x40(%edx) new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10dd79: 83 c2 3c add $0x3c,%edx 10dd7c: 89 11 mov %edx,(%ecx) } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10dd7e: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10dd82: 74 18 je 10dd9c <_Thread_queue_Dequeue_priority+0xa8> _ISR_Enable( level ); 10dd84: 50 push %eax 10dd85: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10dd86: 83 ec 08 sub $0x8,%esp 10dd89: 68 f8 ff 03 10 push $0x1003fff8 10dd8e: 53 push %ebx 10dd8f: e8 e0 f7 ff ff call 10d574 <_Thread_Clear_state> 10dd94: 83 c4 10 add $0x10,%esp 10dd97: eb 88 jmp 10dd21 <_Thread_queue_Dequeue_priority+0x2d> 10dd99: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10dd9c: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10dda3: 50 push %eax 10dda4: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10dda5: 83 ec 0c sub $0xc,%esp 10dda8: 8d 43 48 lea 0x48(%ebx),%eax 10ddab: 50 push %eax 10ddac: e8 87 0a 00 00 call 10e838 <_Watchdog_Remove> 10ddb1: 58 pop %eax 10ddb2: 5a pop %edx 10ddb3: 68 f8 ff 03 10 push $0x1003fff8 10ddb8: 53 push %ebx 10ddb9: e8 b6 f7 ff ff call 10d574 <_Thread_Clear_state> 10ddbe: 83 c4 10 add $0x10,%esp 10ddc1: e9 5b ff ff ff jmp 10dd21 <_Thread_queue_Dequeue_priority+0x2d> head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 10ddc6: 8b 7d d4 mov -0x2c(%ebp),%edi 10ddc9: 89 0f mov %ecx,(%edi) next_node->previous = previous_node; 10ddcb: 89 79 04 mov %edi,0x4(%ecx) 10ddce: eb ae jmp 10dd7e <_Thread_queue_Dequeue_priority+0x8a> =============================================================================== 0010de68 <_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 ) { 10de68: 55 push %ebp 10de69: 89 e5 mov %esp,%ebp 10de6b: 57 push %edi 10de6c: 56 push %esi 10de6d: 53 push %ebx 10de6e: 83 ec 0c sub $0xc,%esp 10de71: 8b 7d 0c mov 0xc(%ebp),%edi RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10de74: 8d 47 3c lea 0x3c(%edi),%eax 10de77: 89 47 38 mov %eax,0x38(%edi) head->next = tail; head->previous = NULL; 10de7a: c7 47 3c 00 00 00 00 movl $0x0,0x3c(%edi) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10de81: 8d 47 38 lea 0x38(%edi),%eax 10de84: 89 47 40 mov %eax,0x40(%edi) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10de87: 8b 57 14 mov 0x14(%edi),%edx RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 10de8a: 89 d0 mov %edx,%eax 10de8c: c1 e8 06 shr $0x6,%eax header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; 10de8f: 8b 4d 08 mov 0x8(%ebp),%ecx 10de92: 8b 59 38 mov 0x38(%ecx),%ebx if ( _Thread_queue_Is_reverse_search( priority ) ) 10de95: f6 c2 20 test $0x20,%dl 10de98: 75 66 jne 10df00 <_Thread_queue_Enqueue_priority+0x98> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10de9a: 8d 04 40 lea (%eax,%eax,2),%eax 10de9d: 8d 04 81 lea (%ecx,%eax,4),%eax 10dea0: 89 45 f0 mov %eax,-0x10(%ebp) RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10dea3: 83 c0 04 add $0x4,%eax 10dea6: 89 7d e8 mov %edi,-0x18(%ebp) 10dea9: 89 c7 mov %eax,%edi if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10deab: 9c pushf 10deac: fa cli 10dead: 5e pop %esi 10deae: 89 75 ec mov %esi,-0x14(%ebp) * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10deb1: 8b 4d f0 mov -0x10(%ebp),%ecx 10deb4: 8b 01 mov (%ecx),%eax restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10deb6: 39 f8 cmp %edi,%eax 10deb8: 75 18 jne 10ded2 <_Thread_queue_Enqueue_priority+0x6a> 10deba: e9 0e 01 00 00 jmp 10dfcd <_Thread_queue_Enqueue_priority+0x165> 10debf: 90 nop break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10dec0: 56 push %esi 10dec1: 9d popf 10dec2: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10dec3: 85 58 10 test %ebx,0x10(%eax) 10dec6: 0f 84 ac 00 00 00 je 10df78 <_Thread_queue_Enqueue_priority+0x110><== NEVER TAKEN _ISR_Enable( level ); goto restart_forward_search; } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10decc: 8b 00 mov (%eax),%eax restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10dece: 39 f8 cmp %edi,%eax 10ded0: 74 07 je 10ded9 <_Thread_queue_Enqueue_priority+0x71> search_priority = search_thread->current_priority; 10ded2: 8b 48 14 mov 0x14(%eax),%ecx if ( priority <= search_priority ) 10ded5: 39 ca cmp %ecx,%edx 10ded7: 77 e7 ja 10dec0 <_Thread_queue_Enqueue_priority+0x58> 10ded9: 8b 7d e8 mov -0x18(%ebp),%edi 10dedc: 89 75 f0 mov %esi,-0x10(%ebp) } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10dedf: 8b 75 08 mov 0x8(%ebp),%esi 10dee2: 8b 5e 30 mov 0x30(%esi),%ebx 10dee5: 83 fb 01 cmp $0x1,%ebx 10dee8: 0f 84 92 00 00 00 je 10df80 <_Thread_queue_Enqueue_priority+0x118> * 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; 10deee: 8b 45 10 mov 0x10(%ebp),%eax 10def1: 8b 55 ec mov -0x14(%ebp),%edx 10def4: 89 10 mov %edx,(%eax) return the_thread_queue->sync_state; } 10def6: 89 d8 mov %ebx,%eax 10def8: 83 c4 0c add $0xc,%esp 10defb: 5b pop %ebx 10defc: 5e pop %esi 10defd: 5f pop %edi 10defe: c9 leave 10deff: c3 ret 10df00: 8d 04 40 lea (%eax,%eax,2),%eax 10df03: 8b 4d 08 mov 0x8(%ebp),%ecx 10df06: 8d 34 81 lea (%ecx,%eax,4),%esi 10df09: 89 7d f0 mov %edi,-0x10(%ebp) the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10df0c: 0f b6 0d 74 32 12 00 movzbl 0x123274,%ecx 10df13: 41 inc %ecx _ISR_Disable( level ); 10df14: 9c pushf 10df15: fa cli 10df16: 5f pop %edi 10df17: 89 7d ec mov %edi,-0x14(%ebp) * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df1a: 8b 46 08 mov 0x8(%esi),%eax restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10df1d: 39 f0 cmp %esi,%eax 10df1f: 75 12 jne 10df33 <_Thread_queue_Enqueue_priority+0xcb> 10df21: eb 17 jmp 10df3a <_Thread_queue_Enqueue_priority+0xd2> 10df23: 90 nop break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10df24: 57 push %edi 10df25: 9d popf 10df26: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10df27: 85 58 10 test %ebx,0x10(%eax) 10df2a: 74 48 je 10df74 <_Thread_queue_Enqueue_priority+0x10c> _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) search_thread->Object.Node.previous; 10df2c: 8b 40 04 mov 0x4(%eax),%eax restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10df2f: 39 f0 cmp %esi,%eax 10df31: 74 07 je 10df3a <_Thread_queue_Enqueue_priority+0xd2> search_priority = search_thread->current_priority; 10df33: 8b 48 14 mov 0x14(%eax),%ecx if ( priority >= search_priority ) 10df36: 39 ca cmp %ecx,%edx 10df38: 72 ea jb 10df24 <_Thread_queue_Enqueue_priority+0xbc> 10df3a: 89 7d e8 mov %edi,-0x18(%ebp) 10df3d: 8b 7d f0 mov -0x10(%ebp),%edi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10df40: 8b 75 08 mov 0x8(%ebp),%esi 10df43: 8b 5e 30 mov 0x30(%esi),%ebx 10df46: 83 fb 01 cmp $0x1,%ebx 10df49: 75 a3 jne 10deee <_Thread_queue_Enqueue_priority+0x86> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10df4b: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) if ( priority == search_priority ) 10df52: 39 ca cmp %ecx,%edx 10df54: 74 53 je 10dfa9 <_Thread_queue_Enqueue_priority+0x141> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10df56: 8b 10 mov (%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10df58: 89 17 mov %edx,(%edi) the_node->previous = search_node; 10df5a: 89 47 04 mov %eax,0x4(%edi) search_node->next = the_node; 10df5d: 89 38 mov %edi,(%eax) next_node->previous = the_node; 10df5f: 89 7a 04 mov %edi,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10df62: 89 77 44 mov %esi,0x44(%edi) _ISR_Enable( level ); 10df65: ff 75 e8 pushl -0x18(%ebp) 10df68: 9d popf * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df69: 89 d8 mov %ebx,%eax 10df6b: 83 c4 0c add $0xc,%esp 10df6e: 5b pop %ebx 10df6f: 5e pop %esi 10df70: 5f pop %edi 10df71: c9 leave 10df72: c3 ret 10df73: 90 nop if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10df74: 57 push %edi 10df75: 9d popf goto restart_reverse_search; 10df76: eb 94 jmp 10df0c <_Thread_queue_Enqueue_priority+0xa4> if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10df78: 56 push %esi <== NOT EXECUTED 10df79: 9d popf <== NOT EXECUTED goto restart_forward_search; 10df7a: e9 2c ff ff ff jmp 10deab <_Thread_queue_Enqueue_priority+0x43><== NOT EXECUTED 10df7f: 90 nop <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10df80: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) if ( priority == search_priority ) 10df87: 39 ca cmp %ecx,%edx 10df89: 74 1e je 10dfa9 <_Thread_queue_Enqueue_priority+0x141> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10df8b: 8b 50 04 mov 0x4(%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10df8e: 89 07 mov %eax,(%edi) the_node->previous = previous_node; 10df90: 89 57 04 mov %edx,0x4(%edi) previous_node->next = the_node; 10df93: 89 3a mov %edi,(%edx) search_node->previous = the_node; 10df95: 89 78 04 mov %edi,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10df98: 89 77 44 mov %esi,0x44(%edi) _ISR_Enable( level ); 10df9b: ff 75 f0 pushl -0x10(%ebp) 10df9e: 9d popf * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10df9f: 89 d8 mov %ebx,%eax 10dfa1: 83 c4 0c add $0xc,%esp 10dfa4: 5b pop %ebx 10dfa5: 5e pop %esi 10dfa6: 5f pop %edi 10dfa7: c9 leave 10dfa8: c3 ret _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10dfa9: 8b 50 40 mov 0x40(%eax),%edx the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); 10dfac: 8d 48 3c lea 0x3c(%eax),%ecx 10dfaf: 89 0f mov %ecx,(%edi) previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; 10dfb1: 89 57 04 mov %edx,0x4(%edi) previous_node->next = the_node; 10dfb4: 89 3a mov %edi,(%edx) search_node->previous = the_node; 10dfb6: 89 78 40 mov %edi,0x40(%eax) the_thread->Wait.queue = the_thread_queue; 10dfb9: 8b 45 08 mov 0x8(%ebp),%eax 10dfbc: 89 47 44 mov %eax,0x44(%edi) _ISR_Enable( level ); 10dfbf: ff 75 ec pushl -0x14(%ebp) 10dfc2: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10dfc3: bb 01 00 00 00 mov $0x1,%ebx 10dfc8: e9 29 ff ff ff jmp 10def6 <_Thread_queue_Enqueue_priority+0x8e> 10dfcd: 8b 7d e8 mov -0x18(%ebp),%edi 10dfd0: 89 75 f0 mov %esi,-0x10(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 10dfd3: b9 ff ff ff ff mov $0xffffffff,%ecx 10dfd8: e9 02 ff ff ff jmp 10dedf <_Thread_queue_Enqueue_priority+0x77> =============================================================================== 0011181c <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 11181c: 55 push %ebp 11181d: 89 e5 mov %esp,%ebp 11181f: 83 ec 08 sub $0x8,%esp 111822: 8b 45 08 mov 0x8(%ebp),%eax 111825: 8b 55 0c mov 0xc(%ebp),%edx /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 111828: 83 78 34 01 cmpl $0x1,0x34(%eax) 11182c: 74 0e je 11183c <_Thread_queue_Extract+0x20> _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 11182e: 89 55 0c mov %edx,0xc(%ebp) 111831: 89 45 08 mov %eax,0x8(%ebp) } 111834: c9 leave * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 111835: e9 e6 19 00 00 jmp 113220 <_Thread_queue_Extract_fifo> 11183a: 66 90 xchg %ax,%ax /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 11183c: 51 push %ecx 11183d: 6a 00 push $0x0 11183f: 52 push %edx 111840: 50 push %eax 111841: e8 06 00 00 00 call 11184c <_Thread_queue_Extract_priority_helper> 111846: 83 c4 10 add $0x10,%esp else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 111849: c9 leave 11184a: c3 ret =============================================================================== 00113220 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) { 113220: 55 push %ebp 113221: 89 e5 mov %esp,%ebp 113223: 53 push %ebx 113224: 83 ec 04 sub $0x4,%esp 113227: 8b 5d 0c mov 0xc(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 11322a: 9c pushf 11322b: fa cli 11322c: 58 pop %eax if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 11322d: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 113234: 74 2e je 113264 <_Thread_queue_Extract_fifo+0x44> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 113236: 8b 0b mov (%ebx),%ecx previous = the_node->previous; 113238: 8b 53 04 mov 0x4(%ebx),%edx next->previous = previous; 11323b: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 11323e: 89 0a mov %ecx,(%edx) return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 113240: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 113247: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 11324b: 74 1f je 11326c <_Thread_queue_Extract_fifo+0x4c> _ISR_Enable( level ); 11324d: 50 push %eax 11324e: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 11324f: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 113256: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 113259: 8b 5d fc mov -0x4(%ebp),%ebx 11325c: c9 leave 11325d: e9 12 a3 ff ff jmp 10d574 <_Thread_Clear_state> 113262: 66 90 xchg %ax,%ax ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 113264: 50 push %eax 113265: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 113266: 8b 5d fc mov -0x4(%ebp),%ebx 113269: c9 leave 11326a: c3 ret 11326b: 90 nop 11326c: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 113273: 50 push %eax 113274: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 113275: 83 ec 0c sub $0xc,%esp 113278: 8d 43 48 lea 0x48(%ebx),%eax 11327b: 50 push %eax 11327c: e8 b7 b5 ff ff call 10e838 <_Watchdog_Remove> 113281: 83 c4 10 add $0x10,%esp 113284: eb c9 jmp 11324f <_Thread_queue_Extract_fifo+0x2f> =============================================================================== 0011184c <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread, bool requeuing ) { 11184c: 55 push %ebp 11184d: 89 e5 mov %esp,%ebp 11184f: 57 push %edi 111850: 56 push %esi 111851: 53 push %ebx 111852: 83 ec 1c sub $0x1c,%esp 111855: 8b 5d 0c mov 0xc(%ebp),%ebx 111858: 8a 45 10 mov 0x10(%ebp),%al 11185b: 88 45 e3 mov %al,-0x1d(%ebp) Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 11185e: 9c pushf 11185f: fa cli 111860: 8f 45 e4 popl -0x1c(%ebp) if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 111863: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 11186a: 74 6c je 1118d8 <_Thread_queue_Extract_priority_helper+0x8c> /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 11186c: 8b 13 mov (%ebx),%edx previous_node = the_node->previous; 11186e: 8b 4b 04 mov 0x4(%ebx),%ecx #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 111871: 8b 43 38 mov 0x38(%ebx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 111874: 8d 73 3c lea 0x3c(%ebx),%esi */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 111877: 39 f0 cmp %esi,%eax 111879: 74 69 je 1118e4 <_Thread_queue_Extract_priority_helper+0x98> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 11187b: 8b 7b 40 mov 0x40(%ebx),%edi if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; 11187e: 8b 30 mov (%eax),%esi previous_node->next = new_first_node; 111880: 89 01 mov %eax,(%ecx) next_node->previous = new_first_node; 111882: 89 42 04 mov %eax,0x4(%edx) new_first_node->next = next_node; 111885: 89 10 mov %edx,(%eax) new_first_node->previous = previous_node; 111887: 89 48 04 mov %ecx,0x4(%eax) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 11188a: 8b 53 40 mov 0x40(%ebx),%edx 11188d: 39 53 38 cmp %edx,0x38(%ebx) 111890: 74 11 je 1118a3 <_Thread_queue_Extract_priority_helper+0x57> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 111892: 8d 50 38 lea 0x38(%eax),%edx 111895: 89 56 04 mov %edx,0x4(%esi) tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 111898: 89 70 38 mov %esi,0x38(%eax) tail->previous = last_node; 11189b: 89 78 40 mov %edi,0x40(%eax) new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); 11189e: 83 c0 3c add $0x3c,%eax 1118a1: 89 07 mov %eax,(%edi) /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 1118a3: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 1118a7: 75 23 jne 1118cc <_Thread_queue_Extract_priority_helper+0x80> _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 1118a9: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 1118ad: 74 3d je 1118ec <_Thread_queue_Extract_priority_helper+0xa0> _ISR_Enable( level ); 1118af: ff 75 e4 pushl -0x1c(%ebp) 1118b2: 9d popf 1118b3: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 1118ba: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1118bd: 8d 65 f4 lea -0xc(%ebp),%esp 1118c0: 5b pop %ebx 1118c1: 5e pop %esi 1118c2: 5f pop %edi 1118c3: c9 leave 1118c4: e9 ab bc ff ff jmp 10d574 <_Thread_Clear_state> 1118c9: 8d 76 00 lea 0x0(%esi),%esi /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 1118cc: ff 75 e4 pushl -0x1c(%ebp) 1118cf: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1118d0: 8d 65 f4 lea -0xc(%ebp),%esp 1118d3: 5b pop %ebx 1118d4: 5e pop %esi 1118d5: 5f pop %edi 1118d6: c9 leave 1118d7: c3 ret Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 1118d8: ff 75 e4 pushl -0x1c(%ebp) 1118db: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1118dc: 8d 65 f4 lea -0xc(%ebp),%esp 1118df: 5b pop %ebx 1118e0: 5e pop %esi 1118e1: 5f pop %edi 1118e2: c9 leave 1118e3: c3 ret head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 1118e4: 89 11 mov %edx,(%ecx) next_node->previous = previous_node; 1118e6: 89 4a 04 mov %ecx,0x4(%edx) 1118e9: eb b8 jmp 1118a3 <_Thread_queue_Extract_priority_helper+0x57> 1118eb: 90 nop 1118ec: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 1118f3: ff 75 e4 pushl -0x1c(%ebp) 1118f6: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 1118f7: 83 ec 0c sub $0xc,%esp 1118fa: 8d 43 48 lea 0x48(%ebx),%eax 1118fd: 50 push %eax 1118fe: e8 35 cf ff ff call 10e838 <_Watchdog_Remove> 111903: 83 c4 10 add $0x10,%esp 111906: eb ab jmp 1118b3 <_Thread_queue_Extract_priority_helper+0x67> =============================================================================== 0010dfe0 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10dfe0: 55 push %ebp 10dfe1: 89 e5 mov %esp,%ebp 10dfe3: 83 ec 08 sub $0x8,%esp 10dfe6: 8b 45 08 mov 0x8(%ebp),%eax States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10dfe9: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10dff0: 75 06 jne 10dff8 <_Thread_queue_Extract_with_proxy+0x18> #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return true; } return false; 10dff2: 31 c0 xor %eax,%eax } 10dff4: c9 leave 10dff5: c3 ret 10dff6: 66 90 xchg %ax,%ax if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10dff8: 83 ec 08 sub $0x8,%esp 10dffb: 50 push %eax 10dffc: ff 70 44 pushl 0x44(%eax) 10dfff: e8 18 38 00 00 call 11181c <_Thread_queue_Extract> return true; 10e004: 83 c4 10 add $0x10,%esp 10e007: b0 01 mov $0x1,%al } return false; } 10e009: c9 leave 10e00a: c3 ret =============================================================================== 0010fe38 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 10fe38: 55 push %ebp 10fe39: 89 e5 mov %esp,%ebp 10fe3b: 83 ec 08 sub $0x8,%esp 10fe3e: 8b 45 08 mov 0x8(%ebp),%eax Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10fe41: 83 78 34 01 cmpl $0x1,0x34(%eax) 10fe45: 74 0d je 10fe54 <_Thread_queue_First+0x1c> first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; 10fe47: ba b0 37 11 00 mov $0x1137b0,%edx return (*first_p)( the_thread_queue ); 10fe4c: 89 45 08 mov %eax,0x8(%ebp) } 10fe4f: c9 leave if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fe50: ff e2 jmp *%edx 10fe52: 66 90 xchg %ax,%ax ) { Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; 10fe54: ba 60 fe 10 00 mov $0x10fe60,%edx else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fe59: 89 45 08 mov %eax,0x8(%ebp) } 10fe5c: c9 leave if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10fe5d: ff e2 jmp *%edx =============================================================================== 001137b0 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 1137b0: 55 push %ebp 1137b1: 89 e5 mov %esp,%ebp 1137b3: 8b 55 08 mov 0x8(%ebp),%edx if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; } 1137b6: 8b 02 mov (%edx),%eax 1137b8: 83 c2 04 add $0x4,%edx Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 1137bb: 39 d0 cmp %edx,%eax 1137bd: 74 05 je 1137c4 <_Thread_queue_First_fifo+0x14> return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; } 1137bf: c9 leave 1137c0: c3 ret 1137c1: 8d 76 00 lea 0x0(%esi),%esi ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; 1137c4: 31 c0 xor %eax,%eax } 1137c6: c9 leave 1137c7: c3 ret =============================================================================== 0010e00c <_Thread_queue_Flush>: #else Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)), #endif uint32_t status ) { 10e00c: 55 push %ebp 10e00d: 89 e5 mov %esp,%ebp 10e00f: 56 push %esi 10e010: 53 push %ebx 10e011: 8b 5d 08 mov 0x8(%ebp),%ebx 10e014: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10e017: eb 06 jmp 10e01f <_Thread_queue_Flush+0x13> 10e019: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; 10e01c: 89 70 34 mov %esi,0x34(%eax) uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10e01f: 83 ec 0c sub $0xc,%esp 10e022: 53 push %ebx 10e023: e8 80 fc ff ff call 10dca8 <_Thread_queue_Dequeue> 10e028: 83 c4 10 add $0x10,%esp 10e02b: 85 c0 test %eax,%eax 10e02d: 75 ed jne 10e01c <_Thread_queue_Flush+0x10> ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10e02f: 8d 65 f8 lea -0x8(%ebp),%esp 10e032: 5b pop %ebx 10e033: 5e pop %esi 10e034: c9 leave 10e035: c3 ret =============================================================================== 0010e038 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10e038: 55 push %ebp 10e039: 89 e5 mov %esp,%ebp 10e03b: 56 push %esi 10e03c: 53 push %ebx 10e03d: 8b 45 08 mov 0x8(%ebp),%eax 10e040: 8b 55 0c mov 0xc(%ebp),%edx the_thread_queue->state = state; 10e043: 8b 4d 10 mov 0x10(%ebp),%ecx 10e046: 89 48 38 mov %ecx,0x38(%eax) the_thread_queue->discipline = the_discipline; 10e049: 89 50 34 mov %edx,0x34(%eax) the_thread_queue->timeout_status = timeout_status; 10e04c: 8b 4d 14 mov 0x14(%ebp),%ecx 10e04f: 89 48 3c mov %ecx,0x3c(%eax) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10e052: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e059: 83 fa 01 cmp $0x1,%edx 10e05c: 74 16 je 10e074 <_Thread_queue_Initialize+0x3c> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10e05e: 8d 50 04 lea 0x4(%eax),%edx 10e061: 89 10 mov %edx,(%eax) head->next = tail; head->previous = NULL; 10e063: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10e06a: 89 40 08 mov %eax,0x8(%eax) _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10e06d: 5b pop %ebx 10e06e: 5e pop %esi 10e06f: c9 leave 10e070: c3 ret 10e071: 8d 76 00 lea 0x0(%esi),%esi the_thread_queue->state = state; the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e074: 89 c1 mov %eax,%ecx 10e076: 30 d2 xor %dl,%dl RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10e078: 8d 1c 52 lea (%edx,%edx,2),%ebx 10e07b: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10e07e: 8d 73 04 lea 0x4(%ebx),%esi 10e081: 89 31 mov %esi,(%ecx) head->next = tail; head->previous = NULL; 10e083: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10e08a: 89 59 08 mov %ebx,0x8(%ecx) uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++) 10e08d: 42 inc %edx 10e08e: 83 c1 0c add $0xc,%ecx the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { uint32_t index; for( index=0 ; 10e091: 83 fa 04 cmp $0x4,%edx 10e094: 75 e2 jne 10e078 <_Thread_queue_Initialize+0x40> _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10e096: 5b pop %ebx 10e097: 5e pop %esi 10e098: c9 leave 10e099: c3 ret =============================================================================== 0010e09c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e09c: 55 push %ebp 10e09d: 89 e5 mov %esp,%ebp 10e09f: 57 push %edi 10e0a0: 56 push %esi 10e0a1: 53 push %ebx 10e0a2: 83 ec 1c sub $0x1c,%esp 10e0a5: 8b 75 08 mov 0x8(%ebp),%esi 10e0a8: 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 ) 10e0ab: 85 f6 test %esi,%esi 10e0ad: 74 06 je 10e0b5 <_Thread_queue_Requeue+0x19><== 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 ) { 10e0af: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10e0b3: 74 0b je 10e0c0 <_Thread_queue_Requeue+0x24><== ALWAYS TAKEN _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); } } 10e0b5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e0b8: 5b pop %ebx <== NOT EXECUTED 10e0b9: 5e pop %esi <== NOT EXECUTED 10e0ba: 5f pop %edi <== NOT EXECUTED 10e0bb: c9 leave <== NOT EXECUTED 10e0bc: c3 ret <== NOT EXECUTED 10e0bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10e0c0: 9c pushf 10e0c1: fa cli 10e0c2: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e0c3: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10e0ca: 75 0c jne 10e0d8 <_Thread_queue_Requeue+0x3c><== ALWAYS TAKEN _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 10e0cc: 53 push %ebx 10e0cd: 9d popf } } 10e0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10e0d1: 5b pop %ebx 10e0d2: 5e pop %esi 10e0d3: 5f pop %edi 10e0d4: c9 leave 10e0d5: c3 ret 10e0d6: 66 90 xchg %ax,%ax 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; 10e0d8: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10e0df: 50 push %eax 10e0e0: 6a 01 push $0x1 10e0e2: 57 push %edi 10e0e3: 56 push %esi 10e0e4: e8 63 37 00 00 call 11184c <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10e0e9: 83 c4 0c add $0xc,%esp 10e0ec: 8d 45 e4 lea -0x1c(%ebp),%eax 10e0ef: 50 push %eax 10e0f0: 57 push %edi 10e0f1: 56 push %esi 10e0f2: e8 71 fd ff ff call 10de68 <_Thread_queue_Enqueue_priority> 10e0f7: 83 c4 10 add $0x10,%esp 10e0fa: eb d0 jmp 10e0cc <_Thread_queue_Requeue+0x30> =============================================================================== 0010e0fc <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10e0fc: 55 push %ebp 10e0fd: 89 e5 mov %esp,%ebp 10e0ff: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e102: 8d 45 f4 lea -0xc(%ebp),%eax 10e105: 50 push %eax 10e106: ff 75 08 pushl 0x8(%ebp) 10e109: e8 0a f8 ff ff call 10d918 <_Thread_Get> switch ( location ) { 10e10e: 83 c4 10 add $0x10,%esp 10e111: 8b 55 f4 mov -0xc(%ebp),%edx 10e114: 85 d2 test %edx,%edx 10e116: 75 17 jne 10e12f <_Thread_queue_Timeout+0x33><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10e118: 83 ec 0c sub $0xc,%esp 10e11b: 50 push %eax 10e11c: e8 e7 37 00 00 call 111908 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e121: a1 70 75 12 00 mov 0x127570,%eax 10e126: 48 dec %eax 10e127: a3 70 75 12 00 mov %eax,0x127570 10e12c: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10e12f: c9 leave 10e130: c3 ret =============================================================================== 00118dc4 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 118dc4: 55 push %ebp 118dc5: 89 e5 mov %esp,%ebp 118dc7: 57 push %edi 118dc8: 56 push %esi 118dc9: 53 push %ebx 118dca: 83 ec 4c sub $0x4c,%esp 118dcd: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118dd0: 8d 45 e0 lea -0x20(%ebp),%eax 118dd3: 89 45 b4 mov %eax,-0x4c(%ebp) 118dd6: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 118dd9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 118de0: 8d 4d dc lea -0x24(%ebp),%ecx 118de3: 89 4d e4 mov %ecx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118de6: 8d 7d d0 lea -0x30(%ebp),%edi 118de9: 8d 45 d4 lea -0x2c(%ebp),%eax 118dec: 89 45 b0 mov %eax,-0x50(%ebp) 118def: 89 45 d0 mov %eax,-0x30(%ebp) head->previous = NULL; 118df2: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 118df9: 89 7d d8 mov %edi,-0x28(%ebp) 118dfc: 8d 73 30 lea 0x30(%ebx),%esi 118dff: 8d 4b 68 lea 0x68(%ebx),%ecx 118e02: 89 4d c4 mov %ecx,-0x3c(%ebp) 118e05: 8d 43 08 lea 0x8(%ebx),%eax 118e08: 89 45 bc mov %eax,-0x44(%ebp) 118e0b: 8d 53 40 lea 0x40(%ebx),%edx 118e0e: 89 55 c0 mov %edx,-0x40(%ebp) 118e11: 8d 76 00 lea 0x0(%esi),%esi 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; 118e14: 8d 4d dc lea -0x24(%ebp),%ecx 118e17: 89 4b 78 mov %ecx,0x78(%ebx) 118e1a: 66 90 xchg %ax,%ax static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 118e1c: a1 84 23 14 00 mov 0x142384,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118e21: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 118e24: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118e27: 51 push %ecx 118e28: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118e29: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118e2b: 50 push %eax 118e2c: 56 push %esi 118e2d: e8 72 3f 00 00 call 11cda4 <_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(); 118e32: a1 e4 22 14 00 mov 0x1422e4,%eax Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 118e37: 8b 53 74 mov 0x74(%ebx),%edx /* * 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 ) { 118e3a: 83 c4 10 add $0x10,%esp 118e3d: 39 d0 cmp %edx,%eax 118e3f: 0f 87 af 00 00 00 ja 118ef4 <_Timer_server_Body+0x130> * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); } else if ( snapshot < last_snapshot ) { 118e45: 0f 82 c9 00 00 00 jb 118f14 <_Timer_server_Body+0x150> */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); } watchdogs->last_snapshot = snapshot; 118e4b: 89 43 74 mov %eax,0x74(%ebx) 118e4e: 66 90 xchg %ax,%ax } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 118e50: 8b 43 78 mov 0x78(%ebx),%eax 118e53: 83 ec 0c sub $0xc,%esp 118e56: 50 push %eax 118e57: e8 04 0a 00 00 call 119860 <_Chain_Get> if ( timer == NULL ) { 118e5c: 83 c4 10 add $0x10,%esp 118e5f: 85 c0 test %eax,%eax 118e61: 74 35 je 118e98 <_Timer_server_Body+0xd4><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118e63: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 118e66: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 118e69: 74 19 je 118e84 <_Timer_server_Body+0xc0><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 118e6b: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118e6e: 75 e0 jne 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 118e70: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e73: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e76: 50 push %eax <== NOT EXECUTED 118e77: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 118e7a: e8 b1 3f 00 00 call 11ce30 <_Watchdog_Insert> <== NOT EXECUTED 118e7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e82: eb cc jmp 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 118e84: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e87: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e8a: 50 push %eax <== NOT EXECUTED 118e8b: 56 push %esi <== NOT EXECUTED 118e8c: e8 9f 3f 00 00 call 11ce30 <_Watchdog_Insert> <== NOT EXECUTED 118e91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e94: eb ba jmp 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED 118e96: 66 90 xchg %ax,%ax <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 118e98: 9c pushf 118e99: fa cli 118e9a: 58 pop %eax tmp = ts->insert_chain; 118e9b: 8b 53 78 mov 0x78(%ebx),%edx if ( _Chain_Is_empty( insert_chain ) ) { 118e9e: 8b 55 b4 mov -0x4c(%ebp),%edx 118ea1: 39 55 dc cmp %edx,-0x24(%ebp) 118ea4: 0f 84 86 00 00 00 je 118f30 <_Timer_server_Body+0x16c><== ALWAYS TAKEN 118eaa: b2 01 mov $0x1,%dl <== NOT EXECUTED ts->insert_chain = NULL; do_loop = false; } _ISR_Enable( level ); 118eac: 50 push %eax 118ead: 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 ) { 118eae: 84 d2 test %dl,%dl 118eb0: 0f 85 66 ff ff ff jne 118e1c <_Timer_server_Body+0x58><== NEVER TAKEN _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 ) ) { 118eb6: 8b 4d b0 mov -0x50(%ebp),%ecx 118eb9: 39 4d d0 cmp %ecx,-0x30(%ebp) 118ebc: 75 22 jne 118ee0 <_Timer_server_Body+0x11c> 118ebe: eb 7e jmp 118f3e <_Timer_server_Body+0x17a> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 118ec0: 8b 10 mov (%eax),%edx head->next = new_first; 118ec2: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 118ec5: 89 7a 04 mov %edi,0x4(%edx) * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 118ec8: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 118ecf: 51 push %ecx 118ed0: 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 ); 118ed1: 83 ec 08 sub $0x8,%esp 118ed4: ff 70 24 pushl 0x24(%eax) 118ed7: ff 70 20 pushl 0x20(%eax) 118eda: ff 50 1c call *0x1c(%eax) } 118edd: 83 c4 10 add $0x10,%esp /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 118ee0: 9c pushf 118ee1: fa cli 118ee2: 59 pop %ecx initialized = false; } #endif return status; } 118ee3: 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)) 118ee6: 3b 45 b0 cmp -0x50(%ebp),%eax 118ee9: 75 d5 jne 118ec0 <_Timer_server_Body+0xfc> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 118eeb: 51 push %ecx 118eec: 9d popf 118eed: e9 22 ff ff ff jmp 118e14 <_Timer_server_Body+0x50> 118ef2: 66 90 xchg %ax,%ax /* * 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 ); 118ef4: 51 push %ecx 118ef5: 57 push %edi if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 118ef6: 89 c1 mov %eax,%ecx 118ef8: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118efa: 51 push %ecx 118efb: ff 75 c4 pushl -0x3c(%ebp) 118efe: 89 45 b8 mov %eax,-0x48(%ebp) 118f01: e8 9e 3e 00 00 call 11cda4 <_Watchdog_Adjust_to_chain> 118f06: 83 c4 10 add $0x10,%esp 118f09: 8b 45 b8 mov -0x48(%ebp),%eax 118f0c: e9 3a ff ff ff jmp 118e4b <_Timer_server_Body+0x87> 118f11: 8d 76 00 lea 0x0(%esi),%esi /* * 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 ); 118f14: 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; 118f15: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 118f17: 52 push %edx 118f18: 6a 01 push $0x1 118f1a: ff 75 c4 pushl -0x3c(%ebp) 118f1d: 89 45 b8 mov %eax,-0x48(%ebp) 118f20: e8 07 3e 00 00 call 11cd2c <_Watchdog_Adjust> 118f25: 83 c4 10 add $0x10,%esp 118f28: 8b 45 b8 mov -0x48(%ebp),%eax 118f2b: e9 1b ff ff ff jmp 118e4b <_Timer_server_Body+0x87> _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); tmp = ts->insert_chain; if ( _Chain_Is_empty( insert_chain ) ) { ts->insert_chain = NULL; 118f30: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 118f37: 31 d2 xor %edx,%edx 118f39: e9 6e ff ff ff jmp 118eac <_Timer_server_Body+0xe8> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 118f3e: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118f42: a1 10 22 14 00 mov 0x142210,%eax 118f47: 40 inc %eax 118f48: a3 10 22 14 00 mov %eax,0x142210 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 118f4d: 83 ec 08 sub $0x8,%esp 118f50: 6a 08 push $0x8 118f52: ff 33 pushl (%ebx) 118f54: e8 67 37 00 00 call 11c6c0 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 118f59: 89 d8 mov %ebx,%eax 118f5b: e8 c4 fd ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 118f60: 89 d8 mov %ebx,%eax 118f62: e8 0d fe ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 118f67: e8 2c 2e 00 00 call 11bd98 <_Thread_Enable_dispatch> ts->active = true; 118f6c: 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 ); 118f70: 5a pop %edx 118f71: ff 75 bc pushl -0x44(%ebp) 118f74: e8 f7 3f 00 00 call 11cf70 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 118f79: 58 pop %eax 118f7a: ff 75 c0 pushl -0x40(%ebp) 118f7d: e8 ee 3f 00 00 call 11cf70 <_Watchdog_Remove> 118f82: 83 c4 10 add $0x10,%esp 118f85: e9 8a fe ff ff jmp 118e14 <_Timer_server_Body+0x50> =============================================================================== 00118f8c <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 118f8c: 55 push %ebp 118f8d: 89 e5 mov %esp,%ebp 118f8f: 57 push %edi 118f90: 56 push %esi 118f91: 53 push %ebx 118f92: 83 ec 2c sub $0x2c,%esp 118f95: 8b 5d 08 mov 0x8(%ebp),%ebx 118f98: 8b 45 0c mov 0xc(%ebp),%eax if ( ts->insert_chain == NULL ) { 118f9b: 8b 53 78 mov 0x78(%ebx),%edx 118f9e: 85 d2 test %edx,%edx 118fa0: 74 16 je 118fb8 <_Timer_server_Schedule_operation_method+0x2c><== ALWAYS TAKEN * 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 ); 118fa2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 118fa5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 118fa8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 118fab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118fae: 5b pop %ebx <== NOT EXECUTED 118faf: 5e pop %esi <== NOT EXECUTED 118fb0: 5f pop %edi <== NOT EXECUTED 118fb1: c9 leave <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 118fb2: e9 6d 08 00 00 jmp 119824 <_Chain_Append> <== NOT EXECUTED 118fb7: 90 nop <== NOT EXECUTED 118fb8: 8b 15 10 22 14 00 mov 0x142210,%edx 118fbe: 42 inc %edx 118fbf: 89 15 10 22 14 00 mov %edx,0x142210 * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118fc5: 8b 50 38 mov 0x38(%eax),%edx 118fc8: 83 fa 01 cmp $0x1,%edx 118fcb: 74 7b je 119048 <_Timer_server_Schedule_operation_method+0xbc> _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); if ( !ts->active ) { _Timer_server_Reset_interval_system_watchdog( ts ); } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 118fcd: 83 fa 03 cmp $0x3,%edx 118fd0: 74 0e je 118fe0 <_Timer_server_Schedule_operation_method+0x54> * 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 ); } } 118fd2: 8d 65 f4 lea -0xc(%ebp),%esp 118fd5: 5b pop %ebx 118fd6: 5e pop %esi 118fd7: 5f pop %edi 118fd8: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 118fd9: e9 ba 2d 00 00 jmp 11bd98 <_Thread_Enable_dispatch> 118fde: 66 90 xchg %ax,%ax } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 118fe0: 9c pushf 118fe1: fa cli 118fe2: 8f 45 e4 popl -0x1c(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 118fe5: 8b 0d e4 22 14 00 mov 0x1422e4,%ecx last_snapshot = ts->TOD_watchdogs.last_snapshot; 118feb: 8b 53 74 mov 0x74(%ebx),%edx 118fee: 89 55 d4 mov %edx,-0x2c(%ebp) initialized = false; } #endif return status; } 118ff1: 8b 53 68 mov 0x68(%ebx),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 118ff4: 8d 7b 6c lea 0x6c(%ebx),%edi * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 118ff7: 39 fa cmp %edi,%edx 118ff9: 74 21 je 11901c <_Timer_server_Schedule_operation_method+0x90> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 118ffb: 8b 7a 10 mov 0x10(%edx),%edi if ( snapshot > last_snapshot ) { 118ffe: 3b 4d d4 cmp -0x2c(%ebp),%ecx 119001: 0f 86 a1 00 00 00 jbe 1190a8 <_Timer_server_Schedule_operation_method+0x11c> /* * We advanced in time. */ delta = snapshot - last_snapshot; 119007: 89 ce mov %ecx,%esi 119009: 2b 75 d4 sub -0x2c(%ebp),%esi 11900c: 89 75 d4 mov %esi,-0x2c(%ebp) if (delta_interval > delta) { 11900f: 39 f7 cmp %esi,%edi 119011: 0f 86 9b 00 00 00 jbe 1190b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN delta_interval -= delta; 119017: 29 f7 sub %esi,%edi * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 119019: 89 7a 10 mov %edi,0x10(%edx) } ts->TOD_watchdogs.last_snapshot = snapshot; 11901c: 89 4b 74 mov %ecx,0x74(%ebx) _ISR_Enable( level ); 11901f: ff 75 e4 pushl -0x1c(%ebp) 119022: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 119023: 83 ec 08 sub $0x8,%esp 119026: 83 c0 10 add $0x10,%eax 119029: 50 push %eax 11902a: 8d 43 68 lea 0x68(%ebx),%eax 11902d: 50 push %eax 11902e: e8 fd 3d 00 00 call 11ce30 <_Watchdog_Insert> if ( !ts->active ) { 119033: 8a 43 7c mov 0x7c(%ebx),%al 119036: 83 c4 10 add $0x10,%esp 119039: 84 c0 test %al,%al 11903b: 75 95 jne 118fd2 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_tod_system_watchdog( ts ); 11903d: 89 d8 mov %ebx,%eax 11903f: e8 30 fd ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog> 119044: eb 8c jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46> 119046: 66 90 xchg %ax,%ax if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 119048: 9c pushf 119049: fa cli 11904a: 8f 45 e4 popl -0x1c(%ebp) snapshot = _Watchdog_Ticks_since_boot; 11904d: 8b 0d 84 23 14 00 mov 0x142384,%ecx last_snapshot = ts->Interval_watchdogs.last_snapshot; 119053: 8b 7b 3c mov 0x3c(%ebx),%edi initialized = false; } #endif return status; } 119056: 8b 53 30 mov 0x30(%ebx),%edx 119059: 8d 73 34 lea 0x34(%ebx),%esi * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = _Watchdog_Ticks_since_boot; last_snapshot = ts->Interval_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 11905c: 39 f2 cmp %esi,%edx 11905e: 74 10 je 119070 <_Timer_server_Schedule_operation_method+0xe4> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 119060: 89 ce mov %ecx,%esi 119062: 29 fe sub %edi,%esi delta_interval = first_watchdog->delta_interval; 119064: 8b 7a 10 mov 0x10(%edx),%edi if (delta_interval > delta) { 119067: 39 fe cmp %edi,%esi 119069: 73 39 jae 1190a4 <_Timer_server_Schedule_operation_method+0x118> delta_interval -= delta; 11906b: 29 f7 sub %esi,%edi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 11906d: 89 7a 10 mov %edi,0x10(%edx) } ts->Interval_watchdogs.last_snapshot = snapshot; 119070: 89 4b 3c mov %ecx,0x3c(%ebx) _ISR_Enable( level ); 119073: ff 75 e4 pushl -0x1c(%ebp) 119076: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 119077: 83 ec 08 sub $0x8,%esp 11907a: 83 c0 10 add $0x10,%eax 11907d: 50 push %eax 11907e: 8d 43 30 lea 0x30(%ebx),%eax 119081: 50 push %eax 119082: e8 a9 3d 00 00 call 11ce30 <_Watchdog_Insert> if ( !ts->active ) { 119087: 8a 43 7c mov 0x7c(%ebx),%al 11908a: 83 c4 10 add $0x10,%esp 11908d: 84 c0 test %al,%al 11908f: 0f 85 3d ff ff ff jne 118fd2 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_interval_system_watchdog( ts ); 119095: 89 d8 mov %ebx,%eax 119097: e8 88 fc ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog> 11909c: e9 31 ff ff ff jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46> 1190a1: 8d 76 00 lea 0x0(%esi),%esi delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1190a4: 31 ff xor %edi,%edi 1190a6: eb c5 jmp 11906d <_Timer_server_Schedule_operation_method+0xe1> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 1190a8: 03 7d d4 add -0x2c(%ebp),%edi delta_interval += delta; 1190ab: 29 cf sub %ecx,%edi 1190ad: e9 67 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d> */ delta = snapshot - last_snapshot; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1190b2: 31 ff xor %edi,%edi <== NOT EXECUTED 1190b4: e9 60 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED =============================================================================== 0010fc18 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10fc18: 55 push %ebp 10fc19: 89 e5 mov %esp,%ebp 10fc1b: 57 push %edi 10fc1c: 56 push %esi 10fc1d: 53 push %ebx 10fc1e: 83 ec 2c sub $0x2c,%esp 10fc21: 8b 45 08 mov 0x8(%ebp),%eax 10fc24: 8b 4d 0c mov 0xc(%ebp),%ecx /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc27: 8b 38 mov (%eax),%edi left += lhs->tv_nsec; 10fc29: 8b 70 04 mov 0x4(%eax),%esi right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc2c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10fc31: 8b 01 mov (%ecx),%eax 10fc33: f7 eb imul %ebx 10fc35: 89 45 e0 mov %eax,-0x20(%ebp) 10fc38: 89 55 e4 mov %edx,-0x1c(%ebp) right += rhs->tv_nsec; 10fc3b: 8b 41 04 mov 0x4(%ecx),%eax 10fc3e: 99 cltd 10fc3f: 01 45 e0 add %eax,-0x20(%ebp) 10fc42: 11 55 e4 adc %edx,-0x1c(%ebp) if ( right == 0 ) { 10fc45: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc48: 0b 55 e0 or -0x20(%ebp),%edx 10fc4b: 74 73 je 10fcc0 <_Timespec_Divide+0xa8> /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10fc4d: 89 f8 mov %edi,%eax 10fc4f: f7 eb imul %ebx 10fc51: 89 45 d0 mov %eax,-0x30(%ebp) 10fc54: 89 55 d4 mov %edx,-0x2c(%ebp) left += lhs->tv_nsec; 10fc57: 89 f7 mov %esi,%edi 10fc59: c1 ff 1f sar $0x1f,%edi 10fc5c: 01 75 d0 add %esi,-0x30(%ebp) 10fc5f: 11 7d d4 adc %edi,-0x2c(%ebp) * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10fc62: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10fc69: bb a0 86 01 00 mov $0x186a0,%ebx 10fc6e: 8b 45 d0 mov -0x30(%ebp),%eax 10fc71: f7 e3 mul %ebx 10fc73: 8d 34 11 lea (%ecx,%edx,1),%esi 10fc76: ff 75 e4 pushl -0x1c(%ebp) 10fc79: ff 75 e0 pushl -0x20(%ebp) 10fc7c: 56 push %esi 10fc7d: 50 push %eax 10fc7e: e8 3d 0a 01 00 call 1206c0 <__udivdi3> 10fc83: 83 c4 10 add $0x10,%esp 10fc86: 89 c3 mov %eax,%ebx 10fc88: 89 d6 mov %edx,%esi *ival_percentage = answer / 1000; 10fc8a: 6a 00 push $0x0 10fc8c: 68 e8 03 00 00 push $0x3e8 10fc91: 52 push %edx 10fc92: 50 push %eax 10fc93: e8 28 0a 01 00 call 1206c0 <__udivdi3> 10fc98: 83 c4 10 add $0x10,%esp 10fc9b: 8b 55 10 mov 0x10(%ebp),%edx 10fc9e: 89 02 mov %eax,(%edx) *fval_percentage = answer % 1000; 10fca0: 6a 00 push $0x0 10fca2: 68 e8 03 00 00 push $0x3e8 10fca7: 56 push %esi 10fca8: 53 push %ebx 10fca9: e8 22 0b 01 00 call 1207d0 <__umoddi3> 10fcae: 83 c4 10 add $0x10,%esp 10fcb1: 8b 55 14 mov 0x14(%ebp),%edx 10fcb4: 89 02 mov %eax,(%edx) } 10fcb6: 8d 65 f4 lea -0xc(%ebp),%esp 10fcb9: 5b pop %ebx 10fcba: 5e pop %esi 10fcbb: 5f pop %edi 10fcbc: c9 leave 10fcbd: c3 ret 10fcbe: 66 90 xchg %ax,%ax left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 10fcc0: 8b 45 10 mov 0x10(%ebp),%eax 10fcc3: c7 00 00 00 00 00 movl $0x0,(%eax) *fval_percentage = 0; 10fcc9: 8b 55 14 mov 0x14(%ebp),%edx 10fccc: c7 02 00 00 00 00 movl $0x0,(%edx) answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10fcd2: 8d 65 f4 lea -0xc(%ebp),%esp 10fcd5: 5b pop %ebx 10fcd6: 5e pop %esi 10fcd7: 5f pop %edi 10fcd8: c9 leave 10fcd9: c3 ret =============================================================================== 0011f794 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 11f794: 55 push %ebp 11f795: 89 e5 mov %esp,%ebp 11f797: 8b 45 08 mov 0x8(%ebp),%eax if ( !time ) 11f79a: 85 c0 test %eax,%eax 11f79c: 74 1a je 11f7b8 <_Timespec_Is_valid+0x24> return false; if ( time->tv_sec < 0 ) 11f79e: 8b 10 mov (%eax),%edx 11f7a0: 85 d2 test %edx,%edx 11f7a2: 78 14 js 11f7b8 <_Timespec_Is_valid+0x24> return false; if ( time->tv_nsec < 0 ) 11f7a4: 8b 40 04 mov 0x4(%eax),%eax 11f7a7: 85 c0 test %eax,%eax 11f7a9: 78 0d js 11f7b8 <_Timespec_Is_valid+0x24> #include #include #include bool _Timespec_Is_valid( 11f7ab: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 11f7b0: 0f 96 c0 setbe %al if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11f7b3: c9 leave 11f7b4: c3 ret 11f7b5: 8d 76 00 lea 0x0(%esi),%esi if ( time->tv_sec < 0 ) return false; if ( time->tv_nsec < 0 ) return false; 11f7b8: 31 c0 xor %eax,%eax if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11f7ba: c9 leave 11f7bb: c3 ret =============================================================================== 001119bc <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 1119bc: 55 push %ebp 1119bd: 89 e5 mov %esp,%ebp 1119bf: 56 push %esi 1119c0: 53 push %ebx 1119c1: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 1119c4: 8b 33 mov (%ebx),%esi 1119c6: 85 f6 test %esi,%esi 1119c8: 75 07 jne 1119d1 <_Timespec_To_ticks+0x15> 1119ca: 8b 43 04 mov 0x4(%ebx),%eax 1119cd: 85 c0 test %eax,%eax 1119cf: 74 37 je 111a08 <_Timespec_To_ticks+0x4c> return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 1119d1: e8 62 17 00 00 call 113138 1119d6: 89 c1 mov %eax,%ecx 1119d8: 0f af ce imul %esi,%ecx ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); 1119db: a1 8c 32 12 00 mov 0x12328c,%eax 1119e0: 8d 04 80 lea (%eax,%eax,4),%eax 1119e3: 8d 04 80 lea (%eax,%eax,4),%eax 1119e6: 8d 34 80 lea (%eax,%eax,4),%esi 1119e9: c1 e6 03 shl $0x3,%esi 1119ec: 8b 43 04 mov 0x4(%ebx),%eax 1119ef: 31 d2 xor %edx,%edx 1119f1: f7 f6 div %esi if (ticks) 1119f3: 01 c8 add %ecx,%eax 1119f5: 74 05 je 1119fc <_Timespec_To_ticks+0x40> return ticks; return 1; } 1119f7: 5b pop %ebx 1119f8: 5e pop %esi 1119f9: c9 leave 1119fa: c3 ret 1119fb: 90 nop ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); if (ticks) return ticks; return 1; 1119fc: b8 01 00 00 00 mov $0x1,%eax } 111a01: 5b pop %ebx 111a02: 5e pop %esi 111a03: c9 leave 111a04: c3 ret 111a05: 8d 76 00 lea 0x0(%esi),%esi ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; 111a08: 31 c0 xor %eax,%eax if (ticks) return ticks; return 1; } 111a0a: 5b pop %ebx 111a0b: 5e pop %esi 111a0c: c9 leave 111a0d: c3 ret =============================================================================== 0010e594 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10e594: 55 push %ebp 10e595: 89 e5 mov %esp,%ebp 10e597: 57 push %edi 10e598: 56 push %esi 10e599: 53 push %ebx 10e59a: 83 ec 1c sub $0x1c,%esp 10e59d: 8b 75 08 mov 0x8(%ebp),%esi 10e5a0: 8b 7d 10 mov 0x10(%ebp),%edi 10e5a3: 8a 45 0c mov 0xc(%ebp),%al the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e5a6: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5ac: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e5b2: 74 25 je 10e5d9 <_User_extensions_Fatal+0x45><== NEVER TAKEN 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 ); 10e5b4: 0f b6 c0 movzbl %al,%eax 10e5b7: 89 45 e4 mov %eax,-0x1c(%ebp) 10e5ba: 66 90 xchg %ax,%ax !_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 ) 10e5bc: 8b 43 30 mov 0x30(%ebx),%eax 10e5bf: 85 c0 test %eax,%eax 10e5c1: 74 0b je 10e5ce <_User_extensions_Fatal+0x3a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10e5c3: 52 push %edx 10e5c4: 57 push %edi 10e5c5: ff 75 e4 pushl -0x1c(%ebp) 10e5c8: 56 push %esi 10e5c9: ff d0 call *%eax 10e5cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e5ce: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e5d1: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e5d7: 75 e3 jne 10e5bc <_User_extensions_Fatal+0x28><== 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 ); } } 10e5d9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e5dc: 5b pop %ebx <== NOT EXECUTED 10e5dd: 5e pop %esi <== NOT EXECUTED 10e5de: 5f pop %edi <== NOT EXECUTED 10e5df: c9 leave <== NOT EXECUTED 10e5e0: c3 ret <== NOT EXECUTED =============================================================================== 0010e458 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10e458: 55 push %ebp 10e459: 89 e5 mov %esp,%ebp 10e45b: 57 push %edi 10e45c: 56 push %esi 10e45d: 53 push %ebx 10e45e: 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; 10e461: a1 bc 32 12 00 mov 0x1232bc,%eax 10e466: 89 45 dc mov %eax,-0x24(%ebp) initial_extensions = Configuration.User_extension_table; 10e469: 8b 35 c0 32 12 00 mov 0x1232c0,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e46f: c7 05 cc 77 12 00 d0 movl $0x1277d0,0x1277cc 10e476: 77 12 00 head->previous = NULL; 10e479: c7 05 d0 77 12 00 00 movl $0x0,0x1277d0 10e480: 00 00 00 tail->previous = head; 10e483: c7 05 d4 77 12 00 cc movl $0x1277cc,0x1277d4 10e48a: 77 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e48d: c7 05 74 75 12 00 78 movl $0x127578,0x127574 10e494: 75 12 00 head->previous = NULL; 10e497: c7 05 78 75 12 00 00 movl $0x0,0x127578 10e49e: 00 00 00 tail->previous = head; 10e4a1: c7 05 7c 75 12 00 74 movl $0x127574,0x12757c 10e4a8: 75 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10e4ab: 85 f6 test %esi,%esi 10e4ad: 74 64 je 10e513 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10e4af: 89 c2 mov %eax,%edx 10e4b1: 8d 04 40 lea (%eax,%eax,2),%eax 10e4b4: 8d 0c 82 lea (%edx,%eax,4),%ecx 10e4b7: c1 e1 02 shl $0x2,%ecx 10e4ba: 83 ec 0c sub $0xc,%esp 10e4bd: 51 push %ecx 10e4be: 89 4d d8 mov %ecx,-0x28(%ebp) 10e4c1: e8 ce 04 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error> 10e4c6: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10e4c8: 31 c0 xor %eax,%eax 10e4ca: 8b 4d d8 mov -0x28(%ebp),%ecx 10e4cd: 89 df mov %ebx,%edi 10e4cf: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e4d1: 83 c4 10 add $0x10,%esp 10e4d4: 8b 45 dc mov -0x24(%ebp),%eax 10e4d7: 85 c0 test %eax,%eax 10e4d9: 74 38 je 10e513 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN 10e4db: 89 75 e4 mov %esi,-0x1c(%ebp) 10e4de: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10e4e5: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10e4e8: 8d 7b 14 lea 0x14(%ebx),%edi 10e4eb: 8b 75 e4 mov -0x1c(%ebp),%esi 10e4ee: b9 08 00 00 00 mov $0x8,%ecx 10e4f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10e4f5: 83 ec 0c sub $0xc,%esp 10e4f8: 53 push %ebx 10e4f9: e8 12 35 00 00 call 111a10 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10e4fe: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e501: ff 45 e0 incl -0x20(%ebp) 10e504: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10e508: 83 c4 10 add $0x10,%esp 10e50b: 8b 45 e0 mov -0x20(%ebp),%eax 10e50e: 39 45 dc cmp %eax,-0x24(%ebp) 10e511: 77 d5 ja 10e4e8 <_User_extensions_Handler_initialization+0x90> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10e513: 8d 65 f4 lea -0xc(%ebp),%esp 10e516: 5b pop %ebx 10e517: 5e pop %esi 10e518: 5f pop %edi 10e519: c9 leave 10e51a: c3 ret =============================================================================== 0010f9e0 <_User_extensions_Remove_set>: #include void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10f9e0: 55 push %ebp 10f9e1: 89 e5 mov %esp,%ebp 10f9e3: 53 push %ebx 10f9e4: 83 ec 10 sub $0x10,%esp 10f9e7: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Extract( &the_extension->Node ); 10f9ea: 53 push %ebx 10f9eb: e8 ac d9 ff ff call 10d39c <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10f9f0: 83 c4 10 add $0x10,%esp 10f9f3: 8b 43 24 mov 0x24(%ebx),%eax 10f9f6: 85 c0 test %eax,%eax 10f9f8: 74 12 je 10fa0c <_User_extensions_Remove_set+0x2c> _Chain_Extract( &the_extension->Switch.Node ); 10f9fa: 83 c3 08 add $0x8,%ebx 10f9fd: 89 5d 08 mov %ebx,0x8(%ebp) } 10fa00: 8b 5d fc mov -0x4(%ebp),%ebx 10fa03: c9 leave /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 10fa04: e9 93 d9 ff ff jmp 10d39c <_Chain_Extract> 10fa09: 8d 76 00 lea 0x0(%esi),%esi } 10fa0c: 8b 5d fc mov -0x4(%ebp),%ebx 10fa0f: c9 leave 10fa10: c3 ret =============================================================================== 0010e51c <_User_extensions_Thread_begin>: #include void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10e51c: 55 push %ebp 10e51d: 89 e5 mov %esp,%ebp 10e51f: 56 push %esi 10e520: 53 push %ebx 10e521: 8b 75 08 mov 0x8(%ebp),%esi the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e524: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e52a: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e530: 74 1c je 10e54e <_User_extensions_Thread_begin+0x32><== NEVER TAKEN 10e532: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10e534: 8b 43 28 mov 0x28(%ebx),%eax 10e537: 85 c0 test %eax,%eax 10e539: 74 09 je 10e544 <_User_extensions_Thread_begin+0x28> (*the_extension->Callouts.thread_begin)( executing ); 10e53b: 83 ec 0c sub $0xc,%esp 10e53e: 56 push %esi 10e53f: ff d0 call *%eax 10e541: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e544: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e546: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e54c: 75 e6 jne 10e534 <_User_extensions_Thread_begin+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10e54e: 8d 65 f8 lea -0x8(%ebp),%esp 10e551: 5b pop %ebx 10e552: 5e pop %esi 10e553: c9 leave 10e554: c3 ret =============================================================================== 0010e5e4 <_User_extensions_Thread_create>: #include bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10e5e4: 55 push %ebp 10e5e5: 89 e5 mov %esp,%ebp 10e5e7: 56 push %esi 10e5e8: 53 push %ebx 10e5e9: 8b 75 08 mov 0x8(%ebp),%esi return false; } } return true; } 10e5ec: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e5f2: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e5f8: 74 26 je 10e620 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN 10e5fa: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10e5fc: 8b 43 14 mov 0x14(%ebx),%eax 10e5ff: 85 c0 test %eax,%eax 10e601: 74 13 je 10e616 <_User_extensions_Thread_create+0x32> status = (*the_extension->Callouts.thread_create)( 10e603: 83 ec 08 sub $0x8,%esp 10e606: 56 push %esi 10e607: ff 35 58 7b 12 00 pushl 0x127b58 10e60d: ff d0 call *%eax _Thread_Executing, the_thread ); if ( !status ) 10e60f: 83 c4 10 add $0x10,%esp 10e612: 84 c0 test %al,%al 10e614: 74 16 je 10e62c <_User_extensions_Thread_create+0x48> User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e616: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e618: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e61e: 75 dc jne 10e5fc <_User_extensions_Thread_create+0x18> if ( !status ) return false; } } return true; 10e620: b0 01 mov $0x1,%al } 10e622: 8d 65 f8 lea -0x8(%ebp),%esp 10e625: 5b pop %ebx 10e626: 5e pop %esi 10e627: c9 leave 10e628: c3 ret 10e629: 8d 76 00 lea 0x0(%esi),%esi status = (*the_extension->Callouts.thread_create)( _Thread_Executing, the_thread ); if ( !status ) return false; 10e62c: 31 c0 xor %eax,%eax } } return true; } 10e62e: 8d 65 f8 lea -0x8(%ebp),%esp 10e631: 5b pop %ebx 10e632: 5e pop %esi 10e633: c9 leave 10e634: c3 ret =============================================================================== 0010e638 <_User_extensions_Thread_delete>: #include void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10e638: 55 push %ebp 10e639: 89 e5 mov %esp,%ebp 10e63b: 56 push %esi 10e63c: 53 push %ebx 10e63d: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e640: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e646: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e64c: 74 23 je 10e671 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN 10e64e: 66 90 xchg %ax,%ax !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10e650: 8b 43 20 mov 0x20(%ebx),%eax 10e653: 85 c0 test %eax,%eax 10e655: 74 0f je 10e666 <_User_extensions_Thread_delete+0x2e> (*the_extension->Callouts.thread_delete)( 10e657: 83 ec 08 sub $0x8,%esp 10e65a: 56 push %esi 10e65b: ff 35 58 7b 12 00 pushl 0x127b58 10e661: ff d0 call *%eax 10e663: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e666: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e669: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e66f: 75 df jne 10e650 <_User_extensions_Thread_delete+0x18> (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e671: 8d 65 f8 lea -0x8(%ebp),%esp 10e674: 5b pop %ebx 10e675: 5e pop %esi 10e676: c9 leave 10e677: c3 ret =============================================================================== 0010e558 <_User_extensions_Thread_exitted>: void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10e558: 55 push %ebp 10e559: 89 e5 mov %esp,%ebp 10e55b: 56 push %esi 10e55c: 53 push %ebx 10e55d: 8b 75 08 mov 0x8(%ebp),%esi the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e560: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e566: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e56c: 74 1d je 10e58b <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN 10e56e: 66 90 xchg %ax,%ax !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10e570: 8b 43 2c mov 0x2c(%ebx),%eax 10e573: 85 c0 test %eax,%eax 10e575: 74 09 je 10e580 <_User_extensions_Thread_exitted+0x28> (*the_extension->Callouts.thread_exitted)( executing ); 10e577: 83 ec 0c sub $0xc,%esp 10e57a: 56 push %esi 10e57b: ff d0 call *%eax 10e57d: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e580: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e583: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx 10e589: 75 e5 jne 10e570 <_User_extensions_Thread_exitted+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10e58b: 8d 65 f8 lea -0x8(%ebp),%esp 10e58e: 5b pop %ebx 10e58f: 5e pop %esi 10e590: c9 leave 10e591: c3 ret =============================================================================== 0010f23c <_User_extensions_Thread_restart>: #include void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10f23c: 55 push %ebp 10f23d: 89 e5 mov %esp,%ebp 10f23f: 56 push %esi 10f240: 53 push %ebx 10f241: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f244: 8b 1d cc 9a 12 00 mov 0x129acc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f24a: 81 fb d0 9a 12 00 cmp $0x129ad0,%ebx 10f250: 74 22 je 10f274 <_User_extensions_Thread_restart+0x38><== NEVER TAKEN 10f252: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10f254: 8b 43 1c mov 0x1c(%ebx),%eax 10f257: 85 c0 test %eax,%eax 10f259: 74 0f je 10f26a <_User_extensions_Thread_restart+0x2e> (*the_extension->Callouts.thread_restart)( 10f25b: 83 ec 08 sub $0x8,%esp 10f25e: 56 push %esi 10f25f: ff 35 58 9e 12 00 pushl 0x129e58 10f265: ff d0 call *%eax 10f267: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10f26a: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f26c: 81 fb d0 9a 12 00 cmp $0x129ad0,%ebx 10f272: 75 e0 jne 10f254 <_User_extensions_Thread_restart+0x18> (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f274: 8d 65 f8 lea -0x8(%ebp),%esp 10f277: 5b pop %ebx 10f278: 5e pop %esi 10f279: c9 leave 10f27a: c3 ret =============================================================================== 0010e678 <_User_extensions_Thread_start>: #include void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10e678: 55 push %ebp 10e679: 89 e5 mov %esp,%ebp 10e67b: 56 push %esi 10e67c: 53 push %ebx 10e67d: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e680: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e686: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e68c: 74 22 je 10e6b0 <_User_extensions_Thread_start+0x38><== NEVER TAKEN 10e68e: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10e690: 8b 43 18 mov 0x18(%ebx),%eax 10e693: 85 c0 test %eax,%eax 10e695: 74 0f je 10e6a6 <_User_extensions_Thread_start+0x2e> (*the_extension->Callouts.thread_start)( 10e697: 83 ec 08 sub $0x8,%esp 10e69a: 56 push %esi 10e69b: ff 35 58 7b 12 00 pushl 0x127b58 10e6a1: ff d0 call *%eax 10e6a3: 83 c4 10 add $0x10,%esp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e6a6: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e6a8: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx 10e6ae: 75 e0 jne 10e690 <_User_extensions_Thread_start+0x18> (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e6b0: 8d 65 f8 lea -0x8(%ebp),%esp 10e6b3: 5b pop %ebx 10e6b4: 5e pop %esi 10e6b5: c9 leave 10e6b6: c3 ret =============================================================================== 0010e6b8 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10e6b8: 55 push %ebp 10e6b9: 89 e5 mov %esp,%ebp 10e6bb: 57 push %edi 10e6bc: 56 push %esi 10e6bd: 53 push %ebx 10e6be: 83 ec 0c sub $0xc,%esp 10e6c1: 8b 7d 08 mov 0x8(%ebp),%edi 10e6c4: 8b 75 0c mov 0xc(%ebp),%esi the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e6c7: 8b 1d 74 75 12 00 mov 0x127574,%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e6cd: 81 fb 78 75 12 00 cmp $0x127578,%ebx 10e6d3: 74 18 je 10e6ed <_User_extensions_Thread_switch+0x35><== NEVER TAKEN 10e6d5: 8d 76 00 lea 0x0(%esi),%esi !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10e6d8: 83 ec 08 sub $0x8,%esp 10e6db: 56 push %esi 10e6dc: 57 push %edi 10e6dd: ff 53 08 call *0x8(%ebx) Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 10e6e0: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e6e2: 83 c4 10 add $0x10,%esp 10e6e5: 81 fb 78 75 12 00 cmp $0x127578,%ebx 10e6eb: 75 eb jne 10e6d8 <_User_extensions_Thread_switch+0x20> the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e6ed: 8d 65 f4 lea -0xc(%ebp),%esp 10e6f0: 5b pop %ebx 10e6f1: 5e pop %esi 10e6f2: 5f pop %edi 10e6f3: c9 leave 10e6f4: c3 ret =============================================================================== 0010fff8 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10fff8: 55 push %ebp 10fff9: 89 e5 mov %esp,%ebp 10fffb: 57 push %edi 10fffc: 56 push %esi 10fffd: 53 push %ebx 10fffe: 83 ec 1c sub $0x1c,%esp 110001: 8b 75 08 mov 0x8(%ebp),%esi 110004: 8b 4d 0c mov 0xc(%ebp),%ecx 110007: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 11000a: 9c pushf 11000b: fa cli 11000c: 58 pop %eax } } _ISR_Enable( level ); } 11000d: 8b 16 mov (%esi),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11000f: 8d 7e 04 lea 0x4(%esi),%edi 110012: 89 7d e4 mov %edi,-0x1c(%ebp) * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 110015: 39 fa cmp %edi,%edx 110017: 74 3d je 110056 <_Watchdog_Adjust+0x5e> switch ( direction ) { 110019: 85 c9 test %ecx,%ecx 11001b: 75 43 jne 110060 <_Watchdog_Adjust+0x68> case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 11001d: 85 db test %ebx,%ebx 11001f: 74 35 je 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 110021: 8b 7a 10 mov 0x10(%edx),%edi 110024: 39 fb cmp %edi,%ebx 110026: 73 0f jae 110037 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN 110028: eb 3e jmp 110068 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 11002a: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 11002c: 29 fb sub %edi,%ebx 11002e: 74 26 je 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 110030: 8b 7a 10 mov 0x10(%edx),%edi 110033: 39 df cmp %ebx,%edi 110035: 77 31 ja 110068 <_Watchdog_Adjust+0x70> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 110037: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 11003e: 50 push %eax 11003f: 9d popf _Watchdog_Tickle( header ); 110040: 83 ec 0c sub $0xc,%esp 110043: 56 push %esi 110044: e8 d3 01 00 00 call 11021c <_Watchdog_Tickle> _ISR_Disable( level ); 110049: 9c pushf 11004a: fa cli 11004b: 58 pop %eax } } _ISR_Enable( level ); } 11004c: 8b 16 mov (%esi),%edx _Watchdog_Tickle( header ); _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 11004e: 83 c4 10 add $0x10,%esp 110051: 39 55 e4 cmp %edx,-0x1c(%ebp) 110054: 75 d6 jne 11002c <_Watchdog_Adjust+0x34> } break; } } _ISR_Enable( level ); 110056: 50 push %eax 110057: 9d popf } 110058: 8d 65 f4 lea -0xc(%ebp),%esp 11005b: 5b pop %ebx 11005c: 5e pop %esi 11005d: 5f pop %edi 11005e: c9 leave 11005f: c3 ret * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 110060: 49 dec %ecx 110061: 75 f3 jne 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 110063: 01 5a 10 add %ebx,0x10(%edx) break; 110066: eb ee jmp 110056 <_Watchdog_Adjust+0x5e> case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 110068: 29 df sub %ebx,%edi 11006a: 89 7a 10 mov %edi,0x10(%edx) break; 11006d: eb e7 jmp 110056 <_Watchdog_Adjust+0x5e> =============================================================================== 0010e6f8 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10e6f8: 55 push %ebp 10e6f9: 89 e5 mov %esp,%ebp 10e6fb: 57 push %edi 10e6fc: 56 push %esi 10e6fd: 53 push %ebx 10e6fe: 83 ec 04 sub $0x4,%esp 10e701: 8b 5d 0c mov 0xc(%ebp),%ebx Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10e704: 8b 3d 54 7b 12 00 mov 0x127b54,%edi _ISR_Disable( level ); 10e70a: 9c pushf 10e70b: fa cli 10e70c: 8f 45 f0 popl -0x10(%ebp) /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { 10e70f: 8b 43 08 mov 0x8(%ebx),%eax 10e712: 85 c0 test %eax,%eax 10e714: 0f 85 9e 00 00 00 jne 10e7b8 <_Watchdog_Insert+0xc0> _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10e71a: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx) _Watchdog_Sync_count++; 10e721: a1 e0 76 12 00 mov 0x1276e0,%eax 10e726: 40 inc %eax 10e727: a3 e0 76 12 00 mov %eax,0x1276e0 restart: delta_interval = the_watchdog->initial; 10e72c: 8b 43 0c mov 0xc(%ebx),%eax RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e72f: 8b 4d 08 mov 0x8(%ebp),%ecx 10e732: 8b 11 mov (%ecx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10e734: 85 c0 test %eax,%eax 10e736: 74 5d je 10e795 <_Watchdog_Insert+0x9d> 10e738: 8b 32 mov (%edx),%esi 10e73a: 85 f6 test %esi,%esi 10e73c: 74 57 je 10e795 <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10e73e: 8b 4a 10 mov 0x10(%edx),%ecx 10e741: 39 c8 cmp %ecx,%eax 10e743: 73 22 jae 10e767 <_Watchdog_Insert+0x6f> 10e745: eb 49 jmp 10e790 <_Watchdog_Insert+0x98> 10e747: 90 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10e748: 8b 35 60 76 12 00 mov 0x127660,%esi 10e74e: 39 f7 cmp %esi,%edi 10e750: 72 72 jb 10e7c4 <_Watchdog_Insert+0xcc> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10e752: 29 c8 sub %ecx,%eax exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10e754: 8b 12 mov (%edx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10e756: 85 c0 test %eax,%eax 10e758: 74 3b je 10e795 <_Watchdog_Insert+0x9d> 10e75a: 8b 0a mov (%edx),%ecx 10e75c: 85 c9 test %ecx,%ecx 10e75e: 74 35 je 10e795 <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10e760: 8b 4a 10 mov 0x10(%edx),%ecx 10e763: 39 c1 cmp %eax,%ecx 10e765: 77 29 ja 10e790 <_Watchdog_Insert+0x98> break; } delta_interval -= after->delta_interval; _ISR_Flash( level ); 10e767: ff 75 f0 pushl -0x10(%ebp) 10e76a: 9d popf 10e76b: fa cli if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10e76c: 83 7b 08 01 cmpl $0x1,0x8(%ebx) 10e770: 74 d6 je 10e748 <_Watchdog_Insert+0x50> _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10e772: 89 3d 60 76 12 00 mov %edi,0x127660 _Watchdog_Sync_count--; 10e778: a1 e0 76 12 00 mov 0x1276e0,%eax 10e77d: 48 dec %eax 10e77e: a3 e0 76 12 00 mov %eax,0x1276e0 _ISR_Enable( level ); 10e783: ff 75 f0 pushl -0x10(%ebp) 10e786: 9d popf } 10e787: 58 pop %eax 10e788: 5b pop %ebx 10e789: 5e pop %esi 10e78a: 5f pop %edi 10e78b: c9 leave 10e78c: c3 ret 10e78d: 8d 76 00 lea 0x0(%esi),%esi if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 10e790: 29 c1 sub %eax,%ecx 10e792: 89 4a 10 mov %ecx,0x10(%edx) RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 10e795: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx) } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10e79c: 89 43 10 mov %eax,0x10(%ebx) _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10e79f: 8b 42 04 mov 0x4(%edx),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10e7a2: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10e7a5: 8b 10 mov (%eax),%edx after_node->next = the_node; 10e7a7: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10e7a9: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10e7ab: 89 5a 04 mov %ebx,0x4(%edx) the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10e7ae: a1 e4 76 12 00 mov 0x1276e4,%eax 10e7b3: 89 43 14 mov %eax,0x14(%ebx) 10e7b6: eb ba jmp 10e772 <_Watchdog_Insert+0x7a> * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 10e7b8: ff 75 f0 pushl -0x10(%ebp) 10e7bb: 9d popf exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10e7bc: 58 pop %eax 10e7bd: 5b pop %ebx 10e7be: 5e pop %esi 10e7bf: 5f pop %edi 10e7c0: c9 leave 10e7c1: c3 ret 10e7c2: 66 90 xchg %ax,%ax if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 10e7c4: 89 3d 60 76 12 00 mov %edi,0x127660 goto restart; 10e7ca: e9 5d ff ff ff jmp 10e72c <_Watchdog_Insert+0x34> =============================================================================== 0010e838 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10e838: 55 push %ebp 10e839: 89 e5 mov %esp,%ebp 10e83b: 56 push %esi 10e83c: 53 push %ebx 10e83d: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10e840: 9c pushf 10e841: fa cli 10e842: 59 pop %ecx previous_state = the_watchdog->state; 10e843: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10e846: 83 f8 01 cmp $0x1,%eax 10e849: 74 4d je 10e898 <_Watchdog_Remove+0x60> 10e84b: 73 0f jae 10e85c <_Watchdog_Remove+0x24> _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10e84d: 8b 1d e4 76 12 00 mov 0x1276e4,%ebx 10e853: 89 5a 18 mov %ebx,0x18(%edx) _ISR_Enable( level ); 10e856: 51 push %ecx 10e857: 9d popf return( previous_state ); } 10e858: 5b pop %ebx 10e859: 5e pop %esi 10e85a: c9 leave 10e85b: c3 ret Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10e85c: 83 f8 03 cmp $0x3,%eax 10e85f: 77 ec ja 10e84d <_Watchdog_Remove+0x15> <== NEVER TAKEN break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10e861: 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 ); } 10e868: 8b 1a mov (%edx),%ebx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10e86a: 8b 33 mov (%ebx),%esi 10e86c: 85 f6 test %esi,%esi 10e86e: 74 06 je 10e876 <_Watchdog_Remove+0x3e> next_watchdog->delta_interval += the_watchdog->delta_interval; 10e870: 8b 72 10 mov 0x10(%edx),%esi 10e873: 01 73 10 add %esi,0x10(%ebx) if ( _Watchdog_Sync_count ) 10e876: 8b 35 e0 76 12 00 mov 0x1276e0,%esi 10e87c: 85 f6 test %esi,%esi 10e87e: 74 0c je 10e88c <_Watchdog_Remove+0x54> _Watchdog_Sync_level = _ISR_Nest_level; 10e880: 8b 35 54 7b 12 00 mov 0x127b54,%esi 10e886: 89 35 60 76 12 00 mov %esi,0x127660 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10e88c: 8b 72 04 mov 0x4(%edx),%esi next->previous = previous; 10e88f: 89 73 04 mov %esi,0x4(%ebx) previous->next = next; 10e892: 89 1e mov %ebx,(%esi) 10e894: eb b7 jmp 10e84d <_Watchdog_Remove+0x15> 10e896: 66 90 xchg %ax,%ax /* * 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; 10e898: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10e89f: eb ac jmp 10e84d <_Watchdog_Remove+0x15> =============================================================================== 0010fbec <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { 10fbec: 55 push %ebp 10fbed: 89 e5 mov %esp,%ebp 10fbef: 57 push %edi 10fbf0: 56 push %esi 10fbf1: 53 push %ebx 10fbf2: 83 ec 2c sub $0x2c,%esp 10fbf5: 8b 55 08 mov 0x8(%ebp),%edx 10fbf8: 8b 45 0c mov 0xc(%ebp),%eax printk( 10fbfb: 8b 78 24 mov 0x24(%eax),%edi 10fbfe: 8b 70 20 mov 0x20(%eax),%esi 10fc01: 8b 58 1c mov 0x1c(%eax),%ebx 10fc04: 8b 48 0c mov 0xc(%eax),%ecx 10fc07: 89 4d d4 mov %ecx,-0x2c(%ebp) 10fc0a: 8b 48 10 mov 0x10(%eax),%ecx 10fc0d: 89 4d e4 mov %ecx,-0x1c(%ebp) 10fc10: 85 d2 test %edx,%edx 10fc12: 74 2c je 10fc40 <_Watchdog_Report+0x54> 10fc14: b9 a3 2c 12 00 mov $0x122ca3,%ecx 10fc19: 83 ec 0c sub $0xc,%esp 10fc1c: 57 push %edi 10fc1d: 56 push %esi 10fc1e: 53 push %ebx 10fc1f: 50 push %eax 10fc20: ff 75 d4 pushl -0x2c(%ebp) 10fc23: ff 75 e4 pushl -0x1c(%ebp) 10fc26: 51 push %ecx 10fc27: 52 push %edx 10fc28: 68 06 37 12 00 push $0x123706 10fc2d: e8 66 9e ff ff call 109a98 10fc32: 83 c4 30 add $0x30,%esp watch, watch->routine, watch->id, watch->user_data ); } 10fc35: 8d 65 f4 lea -0xc(%ebp),%esp 10fc38: 5b pop %ebx 10fc39: 5e pop %esi 10fc3a: 5f pop %edi 10fc3b: c9 leave 10fc3c: c3 ret 10fc3d: 8d 76 00 lea 0x0(%esi),%esi void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { printk( 10fc40: b9 69 35 12 00 mov $0x123569,%ecx 10fc45: 89 ca mov %ecx,%edx 10fc47: eb d0 jmp 10fc19 <_Watchdog_Report+0x2d> =============================================================================== 0010fb7c <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10fb7c: 55 push %ebp 10fb7d: 89 e5 mov %esp,%ebp 10fb7f: 57 push %edi 10fb80: 56 push %esi 10fb81: 53 push %ebx 10fb82: 83 ec 20 sub $0x20,%esp 10fb85: 8b 7d 08 mov 0x8(%ebp),%edi 10fb88: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10fb8b: 9c pushf 10fb8c: fa cli 10fb8d: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10fb90: 56 push %esi 10fb91: 57 push %edi 10fb92: 68 d0 36 12 00 push $0x1236d0 10fb97: e8 fc 9e ff ff call 109a98 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10fb9c: 8b 1e mov (%esi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10fb9e: 83 c6 04 add $0x4,%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { 10fba1: 83 c4 10 add $0x10,%esp 10fba4: 39 f3 cmp %esi,%ebx 10fba6: 74 31 je 10fbd9 <_Watchdog_Report_chain+0x5d> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10fba8: 83 ec 08 sub $0x8,%esp 10fbab: 53 push %ebx 10fbac: 6a 00 push $0x0 10fbae: e8 39 00 00 00 call 10fbec <_Watchdog_Report> _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; node != _Chain_Tail(header) ; node = node->next ) 10fbb3: 8b 1b mov (%ebx),%ebx Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; 10fbb5: 83 c4 10 add $0x10,%esp 10fbb8: 39 f3 cmp %esi,%ebx 10fbba: 75 ec jne 10fba8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10fbbc: 83 ec 08 sub $0x8,%esp 10fbbf: 57 push %edi 10fbc0: 68 e7 36 12 00 push $0x1236e7 10fbc5: e8 ce 9e ff ff call 109a98 10fbca: 83 c4 10 add $0x10,%esp } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); 10fbcd: ff 75 e4 pushl -0x1c(%ebp) 10fbd0: 9d popf } 10fbd1: 8d 65 f4 lea -0xc(%ebp),%esp 10fbd4: 5b pop %ebx 10fbd5: 5e pop %esi 10fbd6: 5f pop %edi 10fbd7: c9 leave 10fbd8: c3 ret _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); 10fbd9: 83 ec 0c sub $0xc,%esp 10fbdc: 68 f6 36 12 00 push $0x1236f6 10fbe1: e8 b2 9e ff ff call 109a98 10fbe6: 83 c4 10 add $0x10,%esp 10fbe9: eb e2 jmp 10fbcd <_Watchdog_Report_chain+0x51> =============================================================================== 0010e8a4 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10e8a4: 55 push %ebp 10e8a5: 89 e5 mov %esp,%ebp 10e8a7: 57 push %edi 10e8a8: 56 push %esi 10e8a9: 53 push %ebx 10e8aa: 83 ec 1c sub $0x1c,%esp 10e8ad: 8b 7d 08 mov 0x8(%ebp),%edi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10e8b0: 9c pushf 10e8b1: fa cli 10e8b2: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10e8b3: 8b 1f mov (%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10e8b5: 8d 47 04 lea 0x4(%edi),%eax 10e8b8: 89 45 e4 mov %eax,-0x1c(%ebp) * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10e8bb: 39 c3 cmp %eax,%ebx 10e8bd: 74 11 je 10e8d0 <_Watchdog_Tickle+0x2c> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10e8bf: 8b 43 10 mov 0x10(%ebx),%eax 10e8c2: 85 c0 test %eax,%eax 10e8c4: 74 34 je 10e8fa <_Watchdog_Tickle+0x56> the_watchdog->delta_interval--; 10e8c6: 48 dec %eax 10e8c7: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10e8ca: 85 c0 test %eax,%eax 10e8cc: 74 2c je 10e8fa <_Watchdog_Tickle+0x56> 10e8ce: 66 90 xchg %ax,%ax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10e8d0: 56 push %esi 10e8d1: 9d popf } 10e8d2: 8d 65 f4 lea -0xc(%ebp),%esp 10e8d5: 5b pop %ebx 10e8d6: 5e pop %esi 10e8d7: 5f pop %edi 10e8d8: c9 leave 10e8d9: c3 ret _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10e8da: 83 ec 08 sub $0x8,%esp 10e8dd: ff 73 24 pushl 0x24(%ebx) 10e8e0: ff 73 20 pushl 0x20(%ebx) 10e8e3: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10e8e6: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10e8e9: 9c pushf 10e8ea: fa cli 10e8eb: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10e8ec: 8b 1f mov (%edi),%ebx _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10e8ee: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10e8f1: 74 dd je 10e8d0 <_Watchdog_Tickle+0x2c> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10e8f3: 8b 43 10 mov 0x10(%ebx),%eax 10e8f6: 85 c0 test %eax,%eax 10e8f8: 75 d6 jne 10e8d0 <_Watchdog_Tickle+0x2c> if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10e8fa: 83 ec 0c sub $0xc,%esp 10e8fd: 53 push %ebx 10e8fe: e8 35 ff ff ff call 10e838 <_Watchdog_Remove> _ISR_Enable( level ); 10e903: 56 push %esi 10e904: 9d popf switch( watchdog_state ) { 10e905: 83 c4 10 add $0x10,%esp 10e908: 83 f8 02 cmp $0x2,%eax 10e90b: 75 dc jne 10e8e9 <_Watchdog_Tickle+0x45> <== NEVER TAKEN 10e90d: eb cb jmp 10e8da <_Watchdog_Tickle+0x36> =============================================================================== 0010e910 <_Workspace_Handler_initialization>: /* * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { 10e910: 55 push %ebp 10e911: 89 e5 mov %esp,%ebp 10e913: 57 push %edi 10e914: 53 push %ebx uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; 10e915: 8b 1d 80 32 12 00 mov 0x123280,%ebx uintptr_t size = Configuration.work_space_size; 10e91b: 8b 15 84 32 12 00 mov 0x123284,%edx if ( Configuration.do_zero_of_workspace ) 10e921: 80 3d ac 32 12 00 00 cmpb $0x0,0x1232ac 10e928: 75 1e jne 10e948 <_Workspace_Handler_initialization+0x38> memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10e92a: 6a 04 push $0x4 10e92c: 52 push %edx 10e92d: 53 push %ebx 10e92e: 68 a0 75 12 00 push $0x1275a0 10e933: e8 b8 dd ff ff call 10c6f0 <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10e938: 83 c4 10 add $0x10,%esp 10e93b: 85 c0 test %eax,%eax 10e93d: 74 13 je 10e952 <_Workspace_Handler_initialization+0x42> _Internal_error_Occurred( INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10e93f: 8d 65 f8 lea -0x8(%ebp),%esp 10e942: 5b pop %ebx 10e943: 5f pop %edi 10e944: c9 leave 10e945: c3 ret 10e946: 66 90 xchg %ax,%ax uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; uintptr_t size = Configuration.work_space_size; if ( Configuration.do_zero_of_workspace ) memset( starting_address, 0, size ); 10e948: 31 c0 xor %eax,%eax 10e94a: 89 df mov %ebx,%edi 10e94c: 89 d1 mov %edx,%ecx 10e94e: f3 aa rep stos %al,%es:(%edi) 10e950: eb d8 jmp 10e92a <_Workspace_Handler_initialization+0x1a> size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10e952: 50 push %eax 10e953: 6a 02 push $0x2 10e955: 6a 01 push $0x1 10e957: 6a 00 push $0x0 10e959: e8 9a df ff ff call 10c8f8 <_Internal_error_Occurred> =============================================================================== 0010b5d4 : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 10b5d4: 55 push %ebp 10b5d5: 89 e5 mov %esp,%ebp 10b5d7: 57 push %edi 10b5d8: 56 push %esi 10b5d9: 53 push %ebx 10b5da: 83 ec 1c sub $0x1c,%esp 10b5dd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b5e0: 8b 75 0c mov 0xc(%ebp),%esi long adjustment; /* * Simple validations */ if ( !delta ) 10b5e3: 85 db test %ebx,%ebx 10b5e5: 0f 84 f1 00 00 00 je 10b6dc rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 10b5eb: 8b 53 04 mov 0x4(%ebx),%edx 10b5ee: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx 10b5f4: 0f 87 e2 00 00 00 ja 10b6dc rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { 10b5fa: 85 f6 test %esi,%esi 10b5fc: 74 10 je 10b60e olddelta->tv_sec = 0; 10b5fe: c7 06 00 00 00 00 movl $0x0,(%esi) olddelta->tv_usec = 0; 10b604: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) 10b60b: 8b 53 04 mov 0x4(%ebx),%edx } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 10b60e: 8b 03 mov (%ebx),%eax 10b610: 8d 04 80 lea (%eax,%eax,4),%eax 10b613: 8d 04 80 lea (%eax,%eax,4),%eax 10b616: 8d 04 80 lea (%eax,%eax,4),%eax 10b619: 8d 04 80 lea (%eax,%eax,4),%eax 10b61c: 8d 04 80 lea (%eax,%eax,4),%eax 10b61f: 8d 04 80 lea (%eax,%eax,4),%eax 10b622: c1 e0 06 shl $0x6,%eax adjustment += delta->tv_usec; 10b625: 8d 04 02 lea (%edx,%eax,1),%eax /* too small to account for */ if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 10b628: 3b 05 8c 47 12 00 cmp 0x12478c,%eax 10b62e: 73 0c jae 10b63c /* set the user's output */ if ( olddelta ) *olddelta = *delta; return 0; 10b630: 31 c0 xor %eax,%eax } 10b632: 8d 65 f4 lea -0xc(%ebp),%esp 10b635: 5b pop %ebx 10b636: 5e pop %esi 10b637: 5f pop %edi 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b63c: a1 b0 8b 12 00 mov 0x128bb0,%eax 10b641: 40 inc %eax 10b642: a3 b0 8b 12 00 mov %eax,0x128bb0 * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 10b647: 83 ec 0c sub $0xc,%esp 10b64a: 8d 7d e0 lea -0x20(%ebp),%edi 10b64d: 57 push %edi 10b64e: e8 89 17 00 00 call 10cddc <_TOD_Get> ts.tv_sec += delta->tv_sec; 10b653: 8b 03 mov (%ebx),%eax 10b655: 01 45 e0 add %eax,-0x20(%ebp) ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 10b658: 8b 43 04 mov 0x4(%ebx),%eax 10b65b: 8d 04 80 lea (%eax,%eax,4),%eax 10b65e: 8d 04 80 lea (%eax,%eax,4),%eax 10b661: 8d 04 80 lea (%eax,%eax,4),%eax 10b664: c1 e0 03 shl $0x3,%eax 10b667: 03 45 e4 add -0x1c(%ebp),%eax 10b66a: 89 45 e4 mov %eax,-0x1c(%ebp) /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10b66d: 83 c4 10 add $0x10,%esp 10b670: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 10b675: 76 18 jbe 10b68f 10b677: 8b 55 e0 mov -0x20(%ebp),%edx 10b67a: 66 90 xchg %ax,%ax ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10b67c: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax * At one point there was a static variable named adjustment * used by this implementation. I don't see any reason for it * to be here based upon the GNU/Linux documentation. */ int adjtime( 10b681: 42 inc %edx ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10b682: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 10b687: 77 f3 ja 10b67c <== NEVER TAKEN 10b689: 89 45 e4 mov %eax,-0x1c(%ebp) 10b68c: 89 55 e0 mov %edx,-0x20(%ebp) ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10b68f: 3d 00 36 65 c4 cmp $0xc4653600,%eax 10b694: 77 19 ja 10b6af <== NEVER TAKEN 10b696: 8b 55 e0 mov -0x20(%ebp),%edx 10b699: 8d 76 00 lea 0x0(%esi),%esi ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 10b69c: 05 00 ca 9a 3b add $0x3b9aca00,%eax * At one point there was a static variable named adjustment * used by this implementation. I don't see any reason for it * to be here based upon the GNU/Linux documentation. */ int adjtime( 10b6a1: 4a dec %edx ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10b6a2: 3d 00 36 65 c4 cmp $0xc4653600,%eax 10b6a7: 76 f3 jbe 10b69c 10b6a9: 89 45 e4 mov %eax,-0x1c(%ebp) 10b6ac: 89 55 e0 mov %edx,-0x20(%ebp) ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 10b6af: 83 ec 0c sub $0xc,%esp 10b6b2: 57 push %edi 10b6b3: e8 ac 17 00 00 call 10ce64 <_TOD_Set> _Thread_Enable_dispatch(); 10b6b8: e8 ef 2b 00 00 call 10e2ac <_Thread_Enable_dispatch> /* set the user's output */ if ( olddelta ) 10b6bd: 83 c4 10 add $0x10,%esp 10b6c0: 85 f6 test %esi,%esi 10b6c2: 0f 84 68 ff ff ff je 10b630 *olddelta = *delta; 10b6c8: 8b 03 mov (%ebx),%eax 10b6ca: 8b 53 04 mov 0x4(%ebx),%edx 10b6cd: 89 06 mov %eax,(%esi) 10b6cf: 89 56 04 mov %edx,0x4(%esi) return 0; 10b6d2: 31 c0 xor %eax,%eax } 10b6d4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6d7: 5b pop %ebx 10b6d8: 5e pop %esi 10b6d9: 5f pop %edi 10b6da: c9 leave 10b6db: c3 ret */ if ( !delta ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); 10b6dc: e8 e7 86 00 00 call 113dc8 <__errno> 10b6e1: c7 00 16 00 00 00 movl $0x16,(%eax) 10b6e7: b8 ff ff ff ff mov $0xffffffff,%eax 10b6ec: e9 41 ff ff ff jmp 10b632 =============================================================================== 0010bd14 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10bd14: 55 push %ebp 10bd15: 89 e5 mov %esp,%ebp 10bd17: 57 push %edi 10bd18: 56 push %esi 10bd19: 53 push %ebx 10bd1a: 83 ec 18 sub $0x18,%esp 10bd1d: 8b 75 08 mov 0x8(%ebp),%esi 10bd20: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10bd23: 68 80 a1 12 00 push $0x12a180 10bd28: e8 73 11 00 00 call 10cea0 if (fcntl (fildes, F_GETFD) < 0) { 10bd2d: 5f pop %edi 10bd2e: 58 pop %eax 10bd2f: 6a 01 push $0x1 10bd31: 56 push %esi 10bd32: e8 91 6a 00 00 call 1127c8 10bd37: 83 c4 10 add $0x10,%esp 10bd3a: 85 c0 test %eax,%eax 10bd3c: 0f 88 73 01 00 00 js 10beb5 pthread_mutex_unlock(&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EBADF); } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 10bd42: 85 db test %ebx,%ebx 10bd44: 0f 84 82 00 00 00 je 10bdcc pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 10bd4a: 8b 3b mov (%ebx),%edi 10bd4c: 39 f7 cmp %esi,%edi 10bd4e: 0f 85 3c 01 00 00 jne 10be90 pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10bd54: 52 push %edx 10bd55: 6a 00 push $0x0 10bd57: 57 push %edi 10bd58: 68 c8 a1 12 00 push $0x12a1c8 10bd5d: e8 76 03 00 00 call 10c0d8 if (r_chain == NULL) { 10bd62: 83 c4 10 add $0x10,%esp 10bd65: 85 c0 test %eax,%eax 10bd67: 74 0f je 10bd78 pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } } return AIO_ALLDONE; 10bd69: bb 02 00 00 00 mov $0x2,%ebx } 10bd6e: 89 d8 mov %ebx,%eax 10bd70: 8d 65 f4 lea -0xc(%ebp),%esp 10bd73: 5b pop %ebx 10bd74: 5e pop %esi 10bd75: 5f pop %edi 10bd76: c9 leave 10bd77: c3 ret rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10bd78: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 10bd7f: a1 12 00 10bd82: 0f 84 98 00 00 00 je 10be20 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10bd88: 50 push %eax 10bd89: 6a 00 push $0x0 10bd8b: 57 push %edi 10bd8c: 68 d4 a1 12 00 push $0x12a1d4 10bd91: e8 42 03 00 00 call 10c0d8 if (r_chain == NULL) { 10bd96: 83 c4 10 add $0x10,%esp 10bd99: 85 c0 test %eax,%eax 10bd9b: 0f 84 ef 00 00 00 je 10be90 rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10bda1: 83 ec 08 sub $0x8,%esp 10bda4: 53 push %ebx 10bda5: 83 c0 08 add $0x8,%eax 10bda8: 50 push %eax 10bda9: e8 ee 06 00 00 call 10c49c 10bdae: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); 10bdb0: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) 10bdb7: e8 6c 11 00 00 call 10cf28 return result; 10bdbc: 83 c4 10 add $0x10,%esp pthread_mutex_unlock (&aio_request_queue.mutex); return result; } } return AIO_ALLDONE; } 10bdbf: 89 d8 mov %ebx,%eax 10bdc1: 8d 65 f4 lea -0xc(%ebp),%esp 10bdc4: 5b pop %ebx 10bdc5: 5e pop %esi 10bdc6: 5f pop %edi 10bdc7: c9 leave 10bdc8: c3 ret 10bdc9: 8d 76 00 lea 0x0(%esi),%esi /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10bdcc: 53 push %ebx 10bdcd: 6a 00 push $0x0 10bdcf: 56 push %esi 10bdd0: 68 c8 a1 12 00 push $0x12a1c8 10bdd5: e8 fe 02 00 00 call 10c0d8 10bdda: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10bddc: 83 c4 10 add $0x10,%esp 10bddf: 85 c0 test %eax,%eax 10bde1: 74 59 je 10be3c return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10bde3: 8d 70 1c lea 0x1c(%eax),%esi 10bde6: 83 ec 0c sub $0xc,%esp 10bde9: 56 push %esi 10bdea: e8 b1 10 00 00 call 10cea0 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10bdef: 89 1c 24 mov %ebx,(%esp) 10bdf2: e8 7d 2a 00 00 call 10e874 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10bdf7: 89 1c 24 mov %ebx,(%esp) 10bdfa: e8 4d 06 00 00 call 10c44c pthread_mutex_unlock (&r_chain->mutex); 10bdff: 89 34 24 mov %esi,(%esp) 10be02: e8 21 11 00 00 call 10cf28 pthread_mutex_unlock (&aio_request_queue.mutex); 10be07: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) 10be0e: e8 15 11 00 00 call 10cf28 return AIO_CANCELED; 10be13: 83 c4 10 add $0x10,%esp 10be16: 31 db xor %ebx,%ebx 10be18: e9 51 ff ff ff jmp 10bd6e 10be1d: 8d 76 00 lea 0x0(%esi),%esi result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } else { pthread_mutex_unlock (&aio_request_queue.mutex); 10be20: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10be23: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10be28: e8 fb 10 00 00 call 10cf28 <== NOT EXECUTED return AIO_ALLDONE; 10be2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be30: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10be35: e9 34 ff ff ff jmp 10bd6e <== NOT EXECUTED 10be3a: 66 90 xchg %ax,%ax <== NOT EXECUTED r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10be3c: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 10be43: a1 12 00 10be46: 74 d8 je 10be20 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10be48: 51 push %ecx 10be49: 6a 00 push $0x0 10be4b: 56 push %esi 10be4c: 68 d4 a1 12 00 push $0x12a1d4 10be51: e8 82 02 00 00 call 10c0d8 10be56: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10be58: 83 c4 10 add $0x10,%esp 10be5b: 85 c0 test %eax,%eax 10be5d: 74 7b je 10beda 10be5f: 83 ec 0c sub $0xc,%esp 10be62: 50 push %eax 10be63: e8 0c 2a 00 00 call 10e874 <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10be68: 89 1c 24 mov %ebx,(%esp) 10be6b: e8 dc 05 00 00 call 10c44c pthread_mutex_destroy (&r_chain->mutex); 10be70: 8d 73 1c lea 0x1c(%ebx),%esi 10be73: 89 34 24 mov %esi,(%esp) 10be76: e8 b9 0d 00 00 call 10cc34 pthread_cond_destroy (&r_chain->mutex); 10be7b: 89 34 24 mov %esi,(%esp) 10be7e: e8 6d 0a 00 00 call 10c8f0 free (r_chain); 10be83: 89 1c 24 mov %ebx,(%esp) 10be86: e8 a9 cc ff ff call 108b34 10be8b: e9 77 ff ff ff jmp 10be07 r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock (&aio_request_queue.mutex); 10be90: 83 ec 0c sub $0xc,%esp 10be93: 68 80 a1 12 00 push $0x12a180 10be98: e8 8b 10 00 00 call 10cf28 rtems_set_errno_and_return_minus_one (EINVAL); 10be9d: e8 5a 9d 00 00 call 115bfc <__errno> 10bea2: c7 00 16 00 00 00 movl $0x16,(%eax) 10bea8: 83 c4 10 add $0x10,%esp 10beab: bb ff ff ff ff mov $0xffffffff,%ebx 10beb0: e9 b9 fe ff ff jmp 10bd6e int result; pthread_mutex_lock (&aio_request_queue.mutex); if (fcntl (fildes, F_GETFD) < 0) { pthread_mutex_unlock(&aio_request_queue.mutex); 10beb5: 83 ec 0c sub $0xc,%esp 10beb8: 68 80 a1 12 00 push $0x12a180 10bebd: e8 66 10 00 00 call 10cf28 rtems_set_errno_and_return_minus_one (EBADF); 10bec2: e8 35 9d 00 00 call 115bfc <__errno> 10bec7: c7 00 09 00 00 00 movl $0x9,(%eax) 10becd: 83 c4 10 add $0x10,%esp 10bed0: bb ff ff ff ff mov $0xffffffff,%ebx 10bed5: e9 94 fe ff ff jmp 10bd6e AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock(&aio_request_queue.mutex); 10beda: 83 ec 0c sub $0xc,%esp 10bedd: 68 80 a1 12 00 push $0x12a180 10bee2: e8 41 10 00 00 call 10cf28 return AIO_ALLDONE; 10bee7: 83 c4 10 add $0x10,%esp 10beea: b3 02 mov $0x2,%bl 10beec: e9 7d fe ff ff jmp 10bd6e =============================================================================== 0010bf00 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10bf00: 55 push %ebp 10bf01: 89 e5 mov %esp,%ebp 10bf03: 53 push %ebx 10bf04: 83 ec 04 sub $0x4,%esp 10bf07: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10bf0a: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10bf11: 75 41 jne 10bf54 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10bf13: 83 ec 08 sub $0x8,%esp 10bf16: 6a 03 push $0x3 10bf18: ff 33 pushl (%ebx) 10bf1a: e8 a9 68 00 00 call 1127c8 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10bf1f: 83 e0 03 and $0x3,%eax 10bf22: 48 dec %eax 10bf23: 83 c4 10 add $0x10,%esp 10bf26: 83 f8 01 cmp $0x1,%eax 10bf29: 77 4d ja 10bf78 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10bf2b: 83 ec 0c sub $0xc,%esp 10bf2e: 6a 18 push $0x18 10bf30: e8 13 d1 ff ff call 109048 if (req == NULL) 10bf35: 83 c4 10 add $0x10,%esp 10bf38: 85 c0 test %eax,%eax 10bf3a: 74 57 je 10bf93 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10bf3c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10bf3f: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10bf46: 89 45 08 mov %eax,0x8(%ebp) } 10bf49: 8b 5d fc mov -0x4(%ebp),%ebx 10bf4c: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10bf4d: e9 ba 05 00 00 jmp 10c50c 10bf52: 66 90 xchg %ax,%ax { rtems_aio_request *req; int mode; if (op != O_SYNC) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10bf54: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10bf5b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf62: e8 95 9c 00 00 call 115bfc <__errno> 10bf67: c7 00 16 00 00 00 movl $0x16,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); } 10bf6d: b8 ff ff ff ff mov $0xffffffff,%eax 10bf72: 8b 5d fc mov -0x4(%ebp),%ebx 10bf75: c9 leave 10bf76: c3 ret 10bf77: 90 nop if (op != O_SYNC) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10bf78: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10bf7f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf86: e8 71 9c 00 00 call 115bfc <__errno> 10bf8b: c7 00 09 00 00 00 movl $0x9,(%eax) 10bf91: eb da jmp 10bf6d req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10bf93: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) 10bf9a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10bfa1: e8 56 9c 00 00 call 115bfc <__errno> <== NOT EXECUTED 10bfa6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10bfac: eb bf jmp 10bf6d <== NOT EXECUTED =============================================================================== 0010c714 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10c714: 55 push %ebp 10c715: 89 e5 mov %esp,%ebp 10c717: 53 push %ebx 10c718: 83 ec 0c sub $0xc,%esp 10c71b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10c71e: 6a 03 push $0x3 10c720: ff 33 pushl (%ebx) 10c722: e8 a1 60 00 00 call 1127c8 if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10c727: 83 c4 10 add $0x10,%esp 10c72a: 83 e0 03 and $0x3,%eax 10c72d: 74 05 je 10c734 <== NEVER TAKEN 10c72f: 83 f8 02 cmp $0x2,%eax 10c732: 75 38 jne 10c76c rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10c734: 8b 53 14 mov 0x14(%ebx),%edx 10c737: 85 d2 test %edx,%edx 10c739: 75 55 jne 10c790 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10c73b: 8b 43 08 mov 0x8(%ebx),%eax 10c73e: 85 c0 test %eax,%eax 10c740: 78 4e js 10c790 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10c742: 83 ec 0c sub $0xc,%esp 10c745: 6a 18 push $0x18 10c747: e8 fc c8 ff ff call 109048 if (req == NULL) 10c74c: 83 c4 10 add $0x10,%esp 10c74f: 85 c0 test %eax,%eax 10c751: 74 58 je 10c7ab <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10c753: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10c756: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10c75d: 89 45 08 mov %eax,0x8(%ebp) } 10c760: 8b 5d fc mov -0x4(%ebp),%ebx 10c763: 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); 10c764: e9 a3 fd ff ff jmp 10c50c 10c769: 8d 76 00 lea 0x0(%esi),%esi rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10c76c: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c773: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c77a: e8 7d 94 00 00 call 115bfc <__errno> 10c77f: c7 00 09 00 00 00 movl $0x9,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); } 10c785: b8 ff ff ff ff mov $0xffffffff,%eax 10c78a: 8b 5d fc mov -0x4(%ebp),%ebx 10c78d: c9 leave 10c78e: c3 ret 10c78f: 90 nop if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10c790: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c797: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c79e: e8 59 94 00 00 call 115bfc <__errno> 10c7a3: c7 00 16 00 00 00 movl $0x16,(%eax) 10c7a9: eb da jmp 10c785 req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10c7ab: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c7b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c7b9: e8 3e 94 00 00 call 115bfc <__errno> <== NOT EXECUTED 10c7be: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c7c4: eb bf jmp 10c785 <== NOT EXECUTED =============================================================================== 0010c7d4 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10c7d4: 55 push %ebp 10c7d5: 89 e5 mov %esp,%ebp 10c7d7: 53 push %ebx 10c7d8: 83 ec 0c sub $0xc,%esp 10c7db: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10c7de: 6a 03 push $0x3 10c7e0: ff 33 pushl (%ebx) 10c7e2: e8 e1 5f 00 00 call 1127c8 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10c7e7: 83 e0 03 and $0x3,%eax 10c7ea: 48 dec %eax 10c7eb: 83 c4 10 add $0x10,%esp 10c7ee: 83 f8 01 cmp $0x1,%eax 10c7f1: 77 35 ja 10c828 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10c7f3: 8b 53 14 mov 0x14(%ebx),%edx 10c7f6: 85 d2 test %edx,%edx 10c7f8: 75 52 jne 10c84c rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10c7fa: 8b 43 08 mov 0x8(%ebx),%eax 10c7fd: 85 c0 test %eax,%eax 10c7ff: 78 4b js 10c84c rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10c801: 83 ec 0c sub $0xc,%esp 10c804: 6a 18 push $0x18 10c806: e8 3d c8 ff ff call 109048 if (req == NULL) 10c80b: 83 c4 10 add $0x10,%esp 10c80e: 85 c0 test %eax,%eax 10c810: 74 55 je 10c867 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10c812: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10c815: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10c81c: 89 45 08 mov %eax,0x8(%ebp) } 10c81f: 8b 5d fc mov -0x4(%ebp),%ebx 10c822: 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); 10c823: e9 e4 fc ff ff jmp 10c50c rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10c828: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c82f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c836: e8 c1 93 00 00 call 115bfc <__errno> 10c83b: c7 00 09 00 00 00 movl $0x9,(%eax) req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); } 10c841: b8 ff ff ff ff mov $0xffffffff,%eax 10c846: 8b 5d fc mov -0x4(%ebp),%ebx 10c849: c9 leave 10c84a: c3 ret 10c84b: 90 nop if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10c84c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c853: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c85a: e8 9d 93 00 00 call 115bfc <__errno> 10c85f: c7 00 16 00 00 00 movl $0x16,(%eax) 10c865: eb da jmp 10c841 req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10c867: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c86e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c875: e8 82 93 00 00 call 115bfc <__errno> <== NOT EXECUTED 10c87a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c880: eb bf jmp 10c841 <== NOT EXECUTED =============================================================================== 0010b454 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 10b454: 55 push %ebp 10b455: 89 e5 mov %esp,%ebp 10b457: 83 ec 08 sub $0x8,%esp 10b45a: 8b 45 08 mov 0x8(%ebp),%eax 10b45d: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10b460: 85 d2 test %edx,%edx 10b462: 74 14 je 10b478 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10b464: 83 f8 01 cmp $0x1,%eax 10b467: 74 47 je 10b4b0 _TOD_Get(tp); return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 10b469: 83 f8 04 cmp $0x4,%eax 10b46c: 74 32 je 10b4a0 <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 10b46e: 83 f8 02 cmp $0x2,%eax 10b471: 74 2d je 10b4a0 return 0; } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 10b473: 83 f8 03 cmp $0x3,%eax 10b476: 74 14 je 10b48c rtems_set_errno_and_return_minus_one( ENOSYS ); #endif rtems_set_errno_and_return_minus_one( EINVAL ); 10b478: e8 a3 8e 00 00 call 114320 <__errno> 10b47d: c7 00 16 00 00 00 movl $0x16,(%eax) 10b483: b8 ff ff ff ff mov $0xffffffff,%eax return 0; } 10b488: c9 leave 10b489: c3 ret 10b48a: 66 90 xchg %ax,%ax } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 10b48c: e8 8f 8e 00 00 call 114320 <__errno> 10b491: c7 00 58 00 00 00 movl $0x58,(%eax) 10b497: b8 ff ff ff ff mov $0xffffffff,%eax #endif rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b49c: c9 leave 10b49d: c3 ret 10b49e: 66 90 xchg %ax,%ax } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { _TOD_Get_uptime_as_timespec( tp ); 10b4a0: 83 ec 0c sub $0xc,%esp 10b4a3: 52 push %edx 10b4a4: e8 a3 1e 00 00 call 10d34c <_TOD_Get_uptime_as_timespec> return 0; 10b4a9: 83 c4 10 add $0x10,%esp 10b4ac: 31 c0 xor %eax,%eax #endif rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b4ae: c9 leave 10b4af: c3 ret { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { _TOD_Get(tp); 10b4b0: 83 ec 0c sub $0xc,%esp 10b4b3: 52 push %edx 10b4b4: e8 3f 1e 00 00 call 10d2f8 <_TOD_Get> return 0; 10b4b9: 83 c4 10 add $0x10,%esp 10b4bc: 31 c0 xor %eax,%eax #endif rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b4be: c9 leave 10b4bf: c3 ret =============================================================================== 0010b4c0 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 10b4c0: 55 push %ebp 10b4c1: 89 e5 mov %esp,%ebp 10b4c3: 83 ec 08 sub $0x8,%esp 10b4c6: 8b 45 08 mov 0x8(%ebp),%eax 10b4c9: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10b4cc: 85 d2 test %edx,%edx 10b4ce: 74 0f je 10b4df <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10b4d0: 83 f8 01 cmp $0x1,%eax 10b4d3: 74 1f je 10b4f4 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10b4d5: 83 f8 02 cmp $0x2,%eax 10b4d8: 74 42 je 10b51c rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10b4da: 83 f8 03 cmp $0x3,%eax 10b4dd: 74 3d je 10b51c rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10b4df: e8 3c 8e 00 00 call 114320 <__errno> 10b4e4: c7 00 16 00 00 00 movl $0x16,(%eax) 10b4ea: b8 ff ff ff ff mov $0xffffffff,%eax return 0; } 10b4ef: c9 leave 10b4f0: c3 ret 10b4f1: 8d 76 00 lea 0x0(%esi),%esi { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10b4f4: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10b4fa: 76 e3 jbe 10b4df rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b4fc: a1 90 85 12 00 mov 0x128590,%eax 10b501: 40 inc %eax 10b502: a3 90 85 12 00 mov %eax,0x128590 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10b507: 83 ec 0c sub $0xc,%esp 10b50a: 52 push %edx 10b50b: e8 94 1e 00 00 call 10d3a4 <_TOD_Set> _Thread_Enable_dispatch(); 10b510: e8 d7 32 00 00 call 10e7ec <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10b515: 83 c4 10 add $0x10,%esp 10b518: 31 c0 xor %eax,%eax } 10b51a: c9 leave 10b51b: c3 ret else if ( clock_id == CLOCK_PROCESS_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 10b51c: e8 ff 8d 00 00 call 114320 <__errno> 10b521: c7 00 58 00 00 00 movl $0x58,(%eax) 10b527: b8 ff ff ff ff mov $0xffffffff,%eax #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10b52c: c9 leave 10b52d: c3 ret =============================================================================== 0010b234 : int getitimer( int which, struct itimerval *value ) { 10b234: 55 push %ebp 10b235: 89 e5 mov %esp,%ebp 10b237: 83 ec 08 sub $0x8,%esp if ( !value ) 10b23a: 8b 45 0c mov 0xc(%ebp),%eax 10b23d: 85 c0 test %eax,%eax 10b23f: 74 2f je 10b270 rtems_set_errno_and_return_minus_one( EFAULT ); switch ( which ) { 10b241: 83 7d 08 02 cmpl $0x2,0x8(%ebp) 10b245: 76 15 jbe 10b25c case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b247: e8 e8 87 00 00 call 113a34 <__errno> 10b24c: c7 00 16 00 00 00 movl $0x16,(%eax) } 10b252: b8 ff ff ff ff mov $0xffffffff,%eax 10b257: c9 leave 10b258: c3 ret 10b259: 8d 76 00 lea 0x0(%esi),%esi switch ( which ) { case ITIMER_REAL: case ITIMER_VIRTUAL: case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); 10b25c: e8 d3 87 00 00 call 113a34 <__errno> 10b261: c7 00 58 00 00 00 movl $0x58,(%eax) default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b267: b8 ff ff ff ff mov $0xffffffff,%eax 10b26c: c9 leave 10b26d: c3 ret 10b26e: 66 90 xchg %ax,%ax int which, struct itimerval *value ) { if ( !value ) rtems_set_errno_and_return_minus_one( EFAULT ); 10b270: e8 bf 87 00 00 call 113a34 <__errno> 10b275: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b27b: eb d5 jmp 10b252 =============================================================================== 001241b4 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 1241b4: 55 push %ebp 1241b5: 89 e5 mov %esp,%ebp 1241b7: 57 push %edi 1241b8: 56 push %esi 1241b9: 53 push %ebx 1241ba: 83 ec 3c sub $0x3c,%esp 1241bd: 8b 75 0c mov 0xc(%ebp),%esi 1241c0: 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() ) 1241c3: e8 00 fd ff ff call 123ec8 1241c8: 3b 45 08 cmp 0x8(%ebp),%eax 1241cb: 0f 85 3f 02 00 00 jne 124410 rtems_set_errno_and_return_minus_one( ESRCH ); /* * Validate the signal passed. */ if ( !sig ) 1241d1: 85 f6 test %esi,%esi 1241d3: 0f 84 4c 02 00 00 je 124425 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 1241d9: 8d 4e ff lea -0x1(%esi),%ecx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 1241dc: 83 f9 1f cmp $0x1f,%ecx 1241df: 0f 87 40 02 00 00 ja 124425 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 ) 1241e5: 8d 04 76 lea (%esi,%esi,2),%eax 1241e8: 83 3c 85 28 e9 12 00 cmpl $0x1,0x12e928(,%eax,4) 1241ef: 01 1241f0: 0f 84 e6 01 00 00 je 1243dc /* * 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 ) ) 1241f6: 83 fe 08 cmp $0x8,%esi 1241f9: 0f 84 c9 00 00 00 je 1242c8 1241ff: 83 fe 04 cmp $0x4,%esi 124202: 0f 84 c0 00 00 00 je 1242c8 124208: 83 fe 0b cmp $0xb,%esi 12420b: 0f 84 b7 00 00 00 je 1242c8 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 124211: bb 01 00 00 00 mov $0x1,%ebx 124216: d3 e3 shl %cl,%ebx /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 124218: 89 75 dc mov %esi,-0x24(%ebp) siginfo->si_code = SI_USER; 12421b: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 124222: 85 ff test %edi,%edi 124224: 0f 84 ba 01 00 00 je 1243e4 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 12422a: 8b 07 mov (%edi),%eax 12422c: 89 45 e4 mov %eax,-0x1c(%ebp) 12422f: a1 d0 e2 12 00 mov 0x12e2d0,%eax 124234: 40 inc %eax 124235: a3 d0 e2 12 00 mov %eax,0x12e2d0 /* * 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; 12423a: 8b 0d b8 e8 12 00 mov 0x12e8b8,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 124240: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax 124246: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 12424c: f7 d0 not %eax 12424e: 85 c3 test %eax,%ebx 124250: 75 34 jne 124286 } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 124252: a1 c0 ea 12 00 mov 0x12eac0,%eax /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 124257: 3d c4 ea 12 00 cmp $0x12eac4,%eax 12425c: 75 1b jne 124279 12425e: e9 81 00 00 00 jmp 1242e4 124263: 90 nop /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 124264: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 12426a: f7 d2 not %edx 12426c: 85 d3 test %edx,%ebx 12426e: 75 16 jne 124286 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 124270: 8b 00 mov (%eax),%eax /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 124272: 3d c4 ea 12 00 cmp $0x12eac4,%eax 124277: 74 6b je 1242e4 <== ALWAYS TAKEN !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 124279: 89 c1 mov %eax,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 12427b: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 124281: 85 58 30 test %ebx,0x30(%eax) 124284: 74 de je 124264 /* * 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 ) ) { 124286: 50 push %eax mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 124287: 8d 45 dc lea -0x24(%ebp),%eax /* * 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 ) ) { 12428a: 50 push %eax 12428b: 56 push %esi 12428c: 51 push %ecx 12428d: e8 d6 01 00 00 call 124468 <_POSIX_signals_Unblock_thread> 124292: 83 c4 10 add $0x10,%esp 124295: 84 c0 test %al,%al 124297: 75 1f jne 1242b8 /* * 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 ); 124299: 83 ec 0c sub $0xc,%esp 12429c: 53 push %ebx 12429d: e8 b2 01 00 00 call 124454 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 1242a2: 8d 1c 76 lea (%esi,%esi,2),%ebx 1242a5: c1 e3 02 shl $0x2,%ebx 1242a8: 83 c4 10 add $0x10,%esp 1242ab: 83 bb 20 e9 12 00 02 cmpl $0x2,0x12e920(%ebx) 1242b2: 0f 84 e4 00 00 00 je 12439c _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 1242b8: e8 5f e7 fe ff call 112a1c <_Thread_Enable_dispatch> return 0; 1242bd: 31 c0 xor %eax,%eax } 1242bf: 8d 65 f4 lea -0xc(%ebp),%esp 1242c2: 5b pop %ebx 1242c3: 5e pop %esi 1242c4: 5f pop %edi 1242c5: c9 leave 1242c6: c3 ret 1242c7: 90 nop * 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 ) ) return pthread_kill( pthread_self(), sig ); 1242c8: e8 7b 03 00 00 call 124648 1242cd: 83 ec 08 sub $0x8,%esp 1242d0: 56 push %esi 1242d1: 50 push %eax 1242d2: e8 b1 02 00 00 call 124588 1242d7: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 1242da: 8d 65 f4 lea -0xc(%ebp),%esp 1242dd: 5b pop %ebx 1242de: 5e pop %esi 1242df: 5f pop %edi 1242e0: c9 leave 1242e1: c3 ret 1242e2: 66 90 xchg %ax,%ax * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 1242e4: 0f b6 05 54 9e 12 00 movzbl 0x129e54,%eax 1242eb: 40 inc %eax 1242ec: 89 45 d4 mov %eax,-0x2c(%ebp) * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 1242ef: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 1242f6: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) 1242fd: 89 5d d0 mov %ebx,-0x30(%ebp) 124300: 89 75 c0 mov %esi,-0x40(%ebp) /* * This can occur when no one is interested and an API is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 124303: 8b 55 cc mov -0x34(%ebp),%edx 124306: 8b 04 95 a8 e2 12 00 mov 0x12e2a8(,%edx,4),%eax 12430d: 85 c0 test %eax,%eax 12430f: 74 68 je 124379 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 124311: 8b 40 04 mov 0x4(%eax),%eax */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 124314: 0f b7 70 10 movzwl 0x10(%eax),%esi object_table = the_info->local_table; 124318: 8b 78 1c mov 0x1c(%eax),%edi for ( index = 1 ; index <= maximum ; index++ ) { 12431b: 85 f6 test %esi,%esi 12431d: 74 5a je 124379 12431f: b8 01 00 00 00 mov $0x1,%eax the_thread = (Thread_Control *) object_table[ index ]; 124324: 8b 14 87 mov (%edi,%eax,4),%edx if ( !the_thread ) 124327: 85 d2 test %edx,%edx 124329: 74 49 je 124374 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 12432b: 8b 4a 14 mov 0x14(%edx),%ecx 12432e: 3b 4d d4 cmp -0x2c(%ebp),%ecx 124331: 77 41 ja 124374 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 124333: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx 124339: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx 12433f: f7 d3 not %ebx 124341: 85 5d d0 test %ebx,-0x30(%ebp) 124344: 74 2e je 124374 * * 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 ) { 124346: 3b 4d d4 cmp -0x2c(%ebp),%ecx 124349: 72 21 jb 12436c * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 12434b: 8b 5d c8 mov -0x38(%ebp),%ebx 12434e: 85 db test %ebx,%ebx 124350: 74 22 je 124374 <== NEVER TAKEN 124352: 8b 5d c8 mov -0x38(%ebp),%ebx 124355: 8b 5b 10 mov 0x10(%ebx),%ebx 124358: 89 5d c4 mov %ebx,-0x3c(%ebp) 12435b: 85 db test %ebx,%ebx 12435d: 74 15 je 124374 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 12435f: 8b 5a 10 mov 0x10(%edx),%ebx 124362: 85 db test %ebx,%ebx 124364: 0f 85 86 00 00 00 jne 1243f0 12436a: 66 90 xchg %ax,%ax 12436c: 89 4d d4 mov %ecx,-0x2c(%ebp) 12436f: 89 55 c8 mov %edx,-0x38(%ebp) 124372: 66 90 xchg %ax,%ax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 124374: 40 inc %eax 124375: 39 c6 cmp %eax,%esi 124377: 73 ab jae 124324 * + 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++) { 124379: ff 45 cc incl -0x34(%ebp) 12437c: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 124380: 75 81 jne 124303 124382: 8b 5d d0 mov -0x30(%ebp),%ebx 124385: 8b 75 c0 mov -0x40(%ebp),%esi } } } } if ( interested ) { 124388: 8b 55 c8 mov -0x38(%ebp),%edx 12438b: 85 d2 test %edx,%edx 12438d: 0f 84 06 ff ff ff je 124299 124393: 8b 4d c8 mov -0x38(%ebp),%ecx 124396: e9 eb fe ff ff jmp 124286 12439b: 90 nop _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 12439c: 83 ec 0c sub $0xc,%esp 12439f: 68 a0 ea 12 00 push $0x12eaa0 1243a4: e8 f7 cc fe ff call 1110a0 <_Chain_Get> if ( !psiginfo ) { 1243a9: 83 c4 10 add $0x10,%esp 1243ac: 85 c0 test %eax,%eax 1243ae: 0f 84 86 00 00 00 je 12443a _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 1243b4: 8d 78 08 lea 0x8(%eax),%edi 1243b7: 8d 75 dc lea -0x24(%ebp),%esi 1243ba: b9 03 00 00 00 mov $0x3,%ecx 1243bf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 1243c1: 83 ec 08 sub $0x8,%esp 1243c4: 50 push %eax 1243c5: 81 c3 40 eb 12 00 add $0x12eb40,%ebx 1243cb: 53 push %ebx 1243cc: e8 93 cc fe ff call 111064 <_Chain_Append> 1243d1: 83 c4 10 add $0x10,%esp 1243d4: e9 df fe ff ff jmp 1242b8 1243d9: 8d 76 00 lea 0x0(%esi),%esi /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) return 0; 1243dc: 31 c0 xor %eax,%eax 1243de: e9 f7 fe ff ff jmp 1242da 1243e3: 90 nop */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 1243e4: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1243eb: e9 3f fe ff ff jmp 12422f continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 1243f0: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp) 1243f7: 0f 85 77 ff ff ff jne 124374 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1243fd: 81 e3 00 00 00 10 and $0x10000000,%ebx 124403: 0f 84 6b ff ff ff je 124374 124409: e9 5e ff ff ff jmp 12436c 12440e: 66 90 xchg %ax,%ax /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 124410: e8 d7 40 ff ff call 1184ec <__errno> 124415: c7 00 03 00 00 00 movl $0x3,(%eax) 12441b: b8 ff ff ff ff mov $0xffffffff,%eax 124420: e9 b5 fe ff ff jmp 1242da */ if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 124425: e8 c2 40 ff ff call 1184ec <__errno> 12442a: c7 00 16 00 00 00 movl $0x16,(%eax) 124430: b8 ff ff ff ff mov $0xffffffff,%eax 124435: e9 a0 fe ff ff jmp 1242da if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { _Thread_Enable_dispatch(); 12443a: e8 dd e5 fe ff call 112a1c <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 12443f: e8 a8 40 ff ff call 1184ec <__errno> 124444: c7 00 0b 00 00 00 movl $0xb,(%eax) 12444a: 83 c8 ff or $0xffffffff,%eax 12444d: e9 88 fe ff ff jmp 1242da =============================================================================== 0010fb14 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 10fb14: 55 push %ebp 10fb15: 89 e5 mov %esp,%ebp 10fb17: 57 push %edi 10fb18: 56 push %esi 10fb19: 53 push %ebx 10fb1a: 83 ec 2c sub $0x2c,%esp 10fb1d: 8b 75 0c mov 0xc(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10fb20: a1 b0 fa 12 00 mov 0x12fab0,%eax 10fb25: 40 inc %eax 10fb26: a3 b0 fa 12 00 mov %eax,0x12fab0 POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10fb2b: 89 f0 mov %esi,%eax 10fb2d: 25 00 02 00 00 and $0x200,%eax 10fb32: 89 45 d4 mov %eax,-0x2c(%ebp) 10fb35: 0f 85 c9 00 00 00 jne 10fc04 /* struct mq_attr attr */ ) { va_list arg; mode_t mode; struct mq_attr *attr = NULL; 10fb3b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) _Objects_Allocate( &_POSIX_Message_queue_Information_fds ); 10fb42: 83 ec 0c sub $0xc,%esp 10fb45: 68 20 00 13 00 push $0x130020 10fb4a: e8 59 2c 00 00 call 1127a8 <_Objects_Allocate> 10fb4f: 89 c3 mov %eax,%ebx attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 10fb51: 83 c4 10 add $0x10,%esp 10fb54: 85 c0 test %eax,%eax 10fb56: 0f 84 b4 00 00 00 je 10fc10 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq_fd->oflag = oflag; 10fb5c: 89 70 14 mov %esi,0x14(%eax) status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10fb5f: 83 ec 08 sub $0x8,%esp 10fb62: 8d 45 e4 lea -0x1c(%ebp),%eax 10fb65: 50 push %eax 10fb66: ff 75 08 pushl 0x8(%ebp) 10fb69: e8 92 69 00 00 call 116500 <_POSIX_Message_queue_Name_to_id> 10fb6e: 89 c7 mov %eax,%edi * If the name to id translation worked, then the message queue exists * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10fb70: 83 c4 10 add $0x10,%esp 10fb73: 85 c0 test %eax,%eax 10fb75: 75 59 jne 10fbd0 } else { /* name -> ID translation succeeded */ /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10fb77: 81 e6 00 0a 00 00 and $0xa00,%esi 10fb7d: 81 fe 00 0a 00 00 cmp $0xa00,%esi 10fb83: 0f 84 a7 00 00 00 je 10fc30 Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) _Objects_Get( &_POSIX_Message_queue_Information, id, location ); 10fb89: 50 push %eax /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 10fb8a: 8d 45 dc lea -0x24(%ebp),%eax 10fb8d: 50 push %eax 10fb8e: ff 75 e4 pushl -0x1c(%ebp) 10fb91: 68 80 fe 12 00 push $0x12fe80 10fb96: e8 c5 30 00 00 call 112c60 <_Objects_Get> 10fb9b: 89 45 e0 mov %eax,-0x20(%ebp) the_mq->open_count += 1; 10fb9e: ff 40 18 incl 0x18(%eax) the_mq_fd->Queue = the_mq; 10fba1: 89 43 10 mov %eax,0x10(%ebx) Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 10fba4: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10fba8: a1 3c 00 13 00 mov 0x13003c,%eax 10fbad: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 10fbb0: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10fbb7: e8 d8 3b 00 00 call 113794 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10fbbc: e8 d3 3b 00 00 call 113794 <_Thread_Enable_dispatch> return (mqd_t)the_mq_fd->Object.id; 10fbc1: 8b 43 08 mov 0x8(%ebx),%eax 10fbc4: 83 c4 10 add $0x10,%esp ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fbc7: 8d 65 f4 lea -0xc(%ebp),%esp 10fbca: 5b pop %ebx 10fbcb: 5e pop %esi 10fbcc: 5f pop %edi 10fbcd: c9 leave 10fbce: c3 ret 10fbcf: 90 nop if ( status ) { /* * 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) ) ) { 10fbd0: 83 f8 02 cmp $0x2,%eax 10fbd3: 0f 84 87 00 00 00 je 10fc60 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 10fbd9: 83 ec 08 sub $0x8,%esp 10fbdc: 53 push %ebx 10fbdd: 68 20 00 13 00 push $0x130020 10fbe2: e8 39 2f 00 00 call 112b20 <_Objects_Free> _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fbe7: e8 a8 3b 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 10fbec: e8 c7 9c 00 00 call 1198b8 <__errno> 10fbf1: 89 38 mov %edi,(%eax) 10fbf3: 83 c4 10 add $0x10,%esp 10fbf6: b8 ff ff ff ff mov $0xffffffff,%eax ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fbfb: 8d 65 f4 lea -0xc(%ebp),%esp 10fbfe: 5b pop %ebx 10fbff: 5e pop %esi 10fc00: 5f pop %edi 10fc01: c9 leave 10fc02: c3 ret 10fc03: 90 nop _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 10fc04: 8b 45 14 mov 0x14(%ebp),%eax 10fc07: 89 45 d0 mov %eax,-0x30(%ebp) 10fc0a: e9 33 ff ff ff jmp 10fb42 10fc0f: 90 nop va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { _Thread_Enable_dispatch(); 10fc10: e8 7f 3b 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENFILE ); 10fc15: e8 9e 9c 00 00 call 1198b8 <__errno> 10fc1a: c7 00 17 00 00 00 movl $0x17,(%eax) 10fc20: b8 ff ff ff ff mov $0xffffffff,%eax ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fc25: 8d 65 f4 lea -0xc(%ebp),%esp 10fc28: 5b pop %ebx 10fc29: 5e pop %esi 10fc2a: 5f pop %edi 10fc2b: c9 leave 10fc2c: c3 ret 10fc2d: 8d 76 00 lea 0x0(%esi),%esi 10fc30: 83 ec 08 sub $0x8,%esp 10fc33: 53 push %ebx 10fc34: 68 20 00 13 00 push $0x130020 10fc39: e8 e2 2e 00 00 call 112b20 <_Objects_Free> /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fc3e: e8 51 3b 00 00 call 113794 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 10fc43: e8 70 9c 00 00 call 1198b8 <__errno> 10fc48: c7 00 11 00 00 00 movl $0x11,(%eax) 10fc4e: 83 c4 10 add $0x10,%esp 10fc51: b8 ff ff ff ff mov $0xffffffff,%eax ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10fc56: 8d 65 f4 lea -0xc(%ebp),%esp 10fc59: 5b pop %ebx 10fc5a: 5e pop %esi 10fc5b: 5f pop %edi 10fc5c: c9 leave 10fc5d: c3 ret 10fc5e: 66 90 xchg %ax,%ax if ( status ) { /* * 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) ) ) { 10fc60: 8b 55 d4 mov -0x2c(%ebp),%edx 10fc63: 85 d2 test %edx,%edx 10fc65: 0f 84 6e ff ff ff je 10fbd9 /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 10fc6b: 8d 45 e0 lea -0x20(%ebp),%eax 10fc6e: 50 push %eax 10fc6f: ff 75 d0 pushl -0x30(%ebp) 10fc72: 6a 01 push $0x1 10fc74: ff 75 08 pushl 0x8(%ebp) 10fc77: e8 fc 66 00 00 call 116378 <_POSIX_Message_queue_Create_support> ); /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 10fc7c: 83 c4 10 add $0x10,%esp 10fc7f: 40 inc %eax 10fc80: 74 26 je 10fca8 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 10fc82: 8b 45 e0 mov -0x20(%ebp),%eax 10fc85: 89 43 10 mov %eax,0x10(%ebx) Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 10fc88: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10fc8c: a1 3c 00 13 00 mov 0x13003c,%eax 10fc91: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 10fc94: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10fc9b: e8 f4 3a 00 00 call 113794 <_Thread_Enable_dispatch> return (mqd_t) the_mq_fd->Object.id; 10fca0: 8b 43 08 mov 0x8(%ebx),%eax 10fca3: e9 1f ff ff ff jmp 10fbc7 10fca8: 83 ec 08 sub $0x8,%esp 10fcab: 53 push %ebx 10fcac: 68 20 00 13 00 push $0x130020 10fcb1: e8 6a 2e 00 00 call 112b20 <_Objects_Free> /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10fcb6: e8 d9 3a 00 00 call 113794 <_Thread_Enable_dispatch> return (mqd_t) -1; 10fcbb: 83 c4 10 add $0x10,%esp 10fcbe: b8 ff ff ff ff mov $0xffffffff,%eax 10fcc3: e9 ff fe ff ff jmp 10fbc7 =============================================================================== 00110950 : #include int pthread_attr_destroy( pthread_attr_t *attr ) { 110950: 55 push %ebp 110951: 89 e5 mov %esp,%ebp 110953: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 110956: 85 c0 test %eax,%eax 110958: 74 12 je 11096c 11095a: 8b 10 mov (%eax),%edx 11095c: 85 d2 test %edx,%edx 11095e: 74 0c je 11096c return EINVAL; attr->is_initialized = false; 110960: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 110966: 31 c0 xor %eax,%eax } 110968: c9 leave 110969: c3 ret 11096a: 66 90 xchg %ax,%ax int pthread_attr_destroy( pthread_attr_t *attr ) { if ( !attr || !attr->is_initialized ) return EINVAL; 11096c: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 110971: c9 leave 110972: c3 ret =============================================================================== 00110ff0 : int pthread_attr_getcputime( pthread_attr_t *attr, int *clock_allowed ) { 110ff0: 55 push %ebp 110ff1: 89 e5 mov %esp,%ebp 110ff3: 8b 45 08 mov 0x8(%ebp),%eax 110ff6: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized || !clock_allowed ) 110ff9: 85 c0 test %eax,%eax 110ffb: 74 13 je 111010 <== NEVER TAKEN 110ffd: 8b 08 mov (%eax),%ecx 110fff: 85 c9 test %ecx,%ecx 111001: 74 0d je 111010 111003: 85 d2 test %edx,%edx 111005: 74 09 je 111010 return EINVAL; *clock_allowed = attr->cputime_clock_allowed; 111007: 8b 40 38 mov 0x38(%eax),%eax 11100a: 89 02 mov %eax,(%edx) return 0; 11100c: 31 c0 xor %eax,%eax } 11100e: c9 leave 11100f: c3 ret pthread_attr_t *attr, int *clock_allowed ) { if ( !attr || !attr->is_initialized || !clock_allowed ) return EINVAL; 111010: b8 16 00 00 00 mov $0x16,%eax *clock_allowed = attr->cputime_clock_allowed; return 0; } 111015: c9 leave 111016: c3 ret =============================================================================== 00110a9c : int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) { 110a9c: 55 push %ebp 110a9d: 89 e5 mov %esp,%ebp 110a9f: 53 push %ebx 110aa0: 8b 45 08 mov 0x8(%ebp),%eax 110aa3: 8b 55 0c mov 0xc(%ebp),%edx 110aa6: 8b 4d 10 mov 0x10(%ebp),%ecx if ( !attr || !attr->is_initialized || !stackaddr || !stacksize ) 110aa9: 85 c0 test %eax,%eax 110aab: 74 1f je 110acc 110aad: 8b 18 mov (%eax),%ebx 110aaf: 85 db test %ebx,%ebx 110ab1: 74 19 je 110acc 110ab3: 85 d2 test %edx,%edx 110ab5: 74 15 je 110acc 110ab7: 85 c9 test %ecx,%ecx 110ab9: 74 11 je 110acc return EINVAL; *stackaddr = attr->stackaddr; 110abb: 8b 58 04 mov 0x4(%eax),%ebx 110abe: 89 1a mov %ebx,(%edx) *stacksize = attr->stacksize; 110ac0: 8b 40 08 mov 0x8(%eax),%eax 110ac3: 89 01 mov %eax,(%ecx) return 0; 110ac5: 31 c0 xor %eax,%eax } 110ac7: 5b pop %ebx 110ac8: c9 leave 110ac9: c3 ret 110aca: 66 90 xchg %ax,%ax void **stackaddr, size_t *stacksize ) { if ( !attr || !attr->is_initialized || !stackaddr || !stacksize ) return EINVAL; 110acc: b8 16 00 00 00 mov $0x16,%eax *stackaddr = attr->stackaddr; *stacksize = attr->stacksize; return 0; } 110ad1: 5b pop %ebx 110ad2: c9 leave 110ad3: c3 ret =============================================================================== 00110b50 : int pthread_attr_setguardsize( pthread_attr_t *attr, size_t guardsize ) { 110b50: 55 push %ebp 110b51: 89 e5 mov %esp,%ebp 110b53: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 110b56: 85 c0 test %eax,%eax 110b58: 74 12 je 110b6c 110b5a: 8b 10 mov (%eax),%edx 110b5c: 85 d2 test %edx,%edx 110b5e: 74 0c je 110b6c return EINVAL; attr->guardsize = guardsize; 110b60: 8b 55 0c mov 0xc(%ebp),%edx 110b63: 89 50 34 mov %edx,0x34(%eax) return 0; 110b66: 31 c0 xor %eax,%eax } 110b68: c9 leave 110b69: c3 ret 110b6a: 66 90 xchg %ax,%ax pthread_attr_t *attr, size_t guardsize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110b6c: b8 16 00 00 00 mov $0x16,%eax attr->guardsize = guardsize; return 0; } 110b71: c9 leave 110b72: c3 ret =============================================================================== 00111b5c : int pthread_attr_setinheritsched( pthread_attr_t *attr, int inheritsched ) { 111b5c: 55 push %ebp 111b5d: 89 e5 mov %esp,%ebp 111b5f: 8b 45 08 mov 0x8(%ebp),%eax 111b62: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 111b65: 85 c0 test %eax,%eax 111b67: 74 1f je 111b88 111b69: 8b 08 mov (%eax),%ecx 111b6b: 85 c9 test %ecx,%ecx 111b6d: 74 19 je 111b88 return EINVAL; switch ( inheritsched ) { 111b6f: 8d 4a ff lea -0x1(%edx),%ecx 111b72: 83 f9 01 cmp $0x1,%ecx 111b75: 76 09 jbe 111b80 case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; return 0; default: return ENOTSUP; 111b77: b8 86 00 00 00 mov $0x86,%eax } } 111b7c: c9 leave 111b7d: c3 ret 111b7e: 66 90 xchg %ax,%ax return EINVAL; switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; 111b80: 89 50 10 mov %edx,0x10(%eax) return 0; 111b83: 31 c0 xor %eax,%eax default: return ENOTSUP; } } 111b85: c9 leave 111b86: c3 ret 111b87: 90 nop pthread_attr_t *attr, int inheritsched ) { if ( !attr || !attr->is_initialized ) return EINVAL; 111b88: b8 16 00 00 00 mov $0x16,%eax return 0; default: return ENOTSUP; } } 111b8d: c9 leave 111b8e: c3 ret =============================================================================== 00110ba8 : int pthread_attr_setschedparam( pthread_attr_t *attr, const struct sched_param *param ) { 110ba8: 55 push %ebp 110ba9: 89 e5 mov %esp,%ebp 110bab: 57 push %edi 110bac: 56 push %esi 110bad: 8b 7d 08 mov 0x8(%ebp),%edi 110bb0: 8b 75 0c mov 0xc(%ebp),%esi if ( !attr || !attr->is_initialized || !param ) 110bb3: 85 ff test %edi,%edi 110bb5: 74 1d je 110bd4 110bb7: 8b 07 mov (%edi),%eax 110bb9: 85 c0 test %eax,%eax 110bbb: 74 17 je 110bd4 110bbd: 85 f6 test %esi,%esi 110bbf: 74 13 je 110bd4 return EINVAL; attr->schedparam = *param; 110bc1: 83 c7 18 add $0x18,%edi 110bc4: b9 07 00 00 00 mov $0x7,%ecx 110bc9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 110bcb: 31 c0 xor %eax,%eax } 110bcd: 5e pop %esi 110bce: 5f pop %edi 110bcf: c9 leave 110bd0: c3 ret 110bd1: 8d 76 00 lea 0x0(%esi),%esi pthread_attr_t *attr, const struct sched_param *param ) { if ( !attr || !attr->is_initialized || !param ) return EINVAL; 110bd4: b8 16 00 00 00 mov $0x16,%eax attr->schedparam = *param; return 0; } 110bd9: 5e pop %esi 110bda: 5f pop %edi 110bdb: c9 leave 110bdc: c3 ret =============================================================================== 00110be0 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 110be0: 55 push %ebp 110be1: 89 e5 mov %esp,%ebp 110be3: 8b 45 08 mov 0x8(%ebp),%eax 110be6: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 110be9: 85 c0 test %eax,%eax 110beb: 74 23 je 110c10 110bed: 8b 08 mov (%eax),%ecx 110bef: 85 c9 test %ecx,%ecx 110bf1: 74 1d je 110c10 return EINVAL; switch ( policy ) { 110bf3: 85 d2 test %edx,%edx 110bf5: 78 0a js 110c01 110bf7: 83 fa 02 cmp $0x2,%edx 110bfa: 7e 0c jle 110c08 110bfc: 83 fa 04 cmp $0x4,%edx 110bff: 74 07 je 110c08 <== ALWAYS TAKEN case SCHED_SPORADIC: attr->schedpolicy = policy; return 0; default: return ENOTSUP; 110c01: b8 86 00 00 00 mov $0x86,%eax } } 110c06: c9 leave 110c07: c3 ret switch ( policy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 110c08: 89 50 14 mov %edx,0x14(%eax) return 0; 110c0b: 31 c0 xor %eax,%eax default: return ENOTSUP; } } 110c0d: c9 leave 110c0e: c3 ret 110c0f: 90 nop pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110c10: b8 16 00 00 00 mov $0x16,%eax return 0; default: return ENOTSUP; } } 110c15: c9 leave 110c16: c3 ret =============================================================================== 00110c18 : int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) { 110c18: 55 push %ebp 110c19: 89 e5 mov %esp,%ebp 110c1b: 8b 45 08 mov 0x8(%ebp),%eax 110c1e: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 110c21: 85 c0 test %eax,%eax 110c23: 74 1a je 110c3f 110c25: 8b 08 mov (%eax),%ecx 110c27: 85 c9 test %ecx,%ecx 110c29: 74 14 je 110c3f return EINVAL; switch ( contentionscope ) { 110c2b: 85 d2 test %edx,%edx 110c2d: 75 0d jne 110c3c case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; 110c2f: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) return 0; 110c36: 31 c0 xor %eax,%eax return ENOTSUP; default: return EINVAL; } } 110c38: c9 leave 110c39: c3 ret 110c3a: 66 90 xchg %ax,%ax ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( contentionscope ) { 110c3c: 4a dec %edx 110c3d: 74 09 je 110c48 case PTHREAD_SCOPE_SYSTEM: return ENOTSUP; default: return EINVAL; 110c3f: b8 16 00 00 00 mov $0x16,%eax } } 110c44: c9 leave 110c45: c3 ret 110c46: 66 90 xchg %ax,%ax case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; return 0; case PTHREAD_SCOPE_SYSTEM: return ENOTSUP; 110c48: b8 86 00 00 00 mov $0x86,%eax default: return EINVAL; } } 110c4d: c9 leave 110c4e: c3 ret =============================================================================== 00110c74 : int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) { 110c74: 55 push %ebp 110c75: 89 e5 mov %esp,%ebp 110c77: 8b 45 08 mov 0x8(%ebp),%eax 110c7a: 8b 55 10 mov 0x10(%ebp),%edx if ( !attr || !attr->is_initialized ) 110c7d: 85 c0 test %eax,%eax 110c7f: 74 27 je 110ca8 110c81: 8b 08 mov (%eax),%ecx 110c83: 85 c9 test %ecx,%ecx 110c85: 74 21 je 110ca8 return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 110c87: 8b 0d f8 db 12 00 mov 0x12dbf8,%ecx 110c8d: d1 e1 shl %ecx 110c8f: 39 d1 cmp %edx,%ecx 110c91: 77 0d ja 110ca0 attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 110c93: 89 50 08 mov %edx,0x8(%eax) attr->stackaddr = stackaddr; 110c96: 8b 55 0c mov 0xc(%ebp),%edx 110c99: 89 50 04 mov %edx,0x4(%eax) return 0; 110c9c: 31 c0 xor %eax,%eax } 110c9e: c9 leave 110c9f: c3 ret { if ( !attr || !attr->is_initialized ) return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; 110ca0: 89 48 08 mov %ecx,0x8(%eax) 110ca3: eb f1 jmp 110c96 110ca5: 8d 76 00 lea 0x0(%esi),%esi void *stackaddr, size_t stacksize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110ca8: b8 16 00 00 00 mov $0x16,%eax else attr->stacksize = stacksize; attr->stackaddr = stackaddr; return 0; } 110cad: c9 leave 110cae: c3 ret =============================================================================== 00110c50 : int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) { 110c50: 55 push %ebp 110c51: 89 e5 mov %esp,%ebp 110c53: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 110c56: 85 c0 test %eax,%eax 110c58: 74 12 je 110c6c 110c5a: 8b 10 mov (%eax),%edx 110c5c: 85 d2 test %edx,%edx 110c5e: 74 0c je 110c6c return EINVAL; attr->stackaddr = stackaddr; 110c60: 8b 55 0c mov 0xc(%ebp),%edx 110c63: 89 50 04 mov %edx,0x4(%eax) return 0; 110c66: 31 c0 xor %eax,%eax } 110c68: c9 leave 110c69: c3 ret 110c6a: 66 90 xchg %ax,%ax pthread_attr_t *attr, void *stackaddr ) { if ( !attr || !attr->is_initialized ) return EINVAL; 110c6c: b8 16 00 00 00 mov $0x16,%eax attr->stackaddr = stackaddr; return 0; } 110c71: c9 leave 110c72: c3 ret =============================================================================== 00111b90 : int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { 111b90: 55 push %ebp 111b91: 89 e5 mov %esp,%ebp 111b93: 8b 45 08 mov 0x8(%ebp),%eax 111b96: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 111b99: 85 c0 test %eax,%eax 111b9b: 74 23 je 111bc0 111b9d: 8b 08 mov (%eax),%ecx 111b9f: 85 c9 test %ecx,%ecx 111ba1: 74 1d je 111bc0 return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 111ba3: 8b 0d 78 45 12 00 mov 0x124578,%ecx 111ba9: d1 e1 shl %ecx 111bab: 39 d1 cmp %edx,%ecx 111bad: 77 09 ja 111bb8 attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 111baf: 89 50 08 mov %edx,0x8(%eax) return 0; 111bb2: 31 c0 xor %eax,%eax } 111bb4: c9 leave 111bb5: c3 ret 111bb6: 66 90 xchg %ax,%ax { if ( !attr || !attr->is_initialized ) return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; 111bb8: 89 48 08 mov %ecx,0x8(%eax) else attr->stacksize = stacksize; return 0; 111bbb: 31 c0 xor %eax,%eax } 111bbd: c9 leave 111bbe: c3 ret 111bbf: 90 nop pthread_attr_t *attr, size_t stacksize ) { if ( !attr || !attr->is_initialized ) return EINVAL; 111bc0: b8 16 00 00 00 mov $0x16,%eax if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; return 0; } 111bc5: c9 leave 111bc6: c3 ret =============================================================================== 0010b99c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10b99c: 55 push %ebp 10b99d: 89 e5 mov %esp,%ebp 10b99f: 57 push %edi 10b9a0: 56 push %esi 10b9a1: 53 push %ebx 10b9a2: 83 ec 2c sub $0x2c,%esp 10b9a5: 8b 5d 08 mov 0x8(%ebp),%ebx 10b9a8: 8b 7d 0c mov 0xc(%ebp),%edi 10b9ab: 8b 75 10 mov 0x10(%ebp),%esi const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10b9ae: 85 db test %ebx,%ebx 10b9b0: 0f 84 82 00 00 00 je 10ba38 return EINVAL; if ( count == 0 ) 10b9b6: 85 f6 test %esi,%esi 10b9b8: 74 7e je 10ba38 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b9ba: 85 ff test %edi,%edi 10b9bc: 0f 84 92 00 00 00 je 10ba54 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10b9c2: 8b 17 mov (%edi),%edx 10b9c4: 85 d2 test %edx,%edx 10b9c6: 74 70 je 10ba38 return EINVAL; switch ( the_attr->process_shared ) { 10b9c8: 8b 47 04 mov 0x4(%edi),%eax 10b9cb: 85 c0 test %eax,%eax 10b9cd: 75 69 jne 10ba38 <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10b9cf: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10b9d6: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b9d9: a1 f0 8c 12 00 mov 0x128cf0,%eax 10b9de: 40 inc %eax 10b9df: a3 f0 8c 12 00 mov %eax,0x128cf0 * 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 ); 10b9e4: 83 ec 0c sub $0xc,%esp 10b9e7: 68 40 91 12 00 push $0x129140 10b9ec: e8 fb 20 00 00 call 10daec <_Objects_Allocate> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10b9f1: 83 c4 10 add $0x10,%esp 10b9f4: 85 c0 test %eax,%eax 10b9f6: 74 50 je 10ba48 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10b9f8: 83 ec 08 sub $0x8,%esp 10b9fb: 8d 55 e0 lea -0x20(%ebp),%edx 10b9fe: 52 push %edx 10b9ff: 8d 50 10 lea 0x10(%eax),%edx 10ba02: 52 push %edx 10ba03: 89 45 d4 mov %eax,-0x2c(%ebp) 10ba06: e8 dd 16 00 00 call 10d0e8 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10ba0b: 8b 45 d4 mov -0x2c(%ebp),%eax 10ba0e: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10ba11: 0f b7 f2 movzwl %dx,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10ba14: 8b 0d 5c 91 12 00 mov 0x12915c,%ecx 10ba1a: 89 04 b1 mov %eax,(%ecx,%esi,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10ba1d: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10ba24: 89 13 mov %edx,(%ebx) _Thread_Enable_dispatch(); 10ba26: e8 2d 30 00 00 call 10ea58 <_Thread_Enable_dispatch> return 0; 10ba2b: 83 c4 10 add $0x10,%esp 10ba2e: 31 c0 xor %eax,%eax } 10ba30: 8d 65 f4 lea -0xc(%ebp),%esp 10ba33: 5b pop %ebx 10ba34: 5e pop %esi 10ba35: 5f pop %edi 10ba36: c9 leave 10ba37: c3 ret switch ( the_attr->process_shared ) { case PTHREAD_PROCESS_PRIVATE: /* only supported values */ break; case PTHREAD_PROCESS_SHARED: default: return EINVAL; 10ba38: b8 16 00 00 00 mov $0x16,%eax * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; } 10ba3d: 8d 65 f4 lea -0xc(%ebp),%esp 10ba40: 5b pop %ebx 10ba41: 5e pop %esi 10ba42: 5f pop %edi 10ba43: c9 leave 10ba44: c3 ret 10ba45: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10ba48: e8 0b 30 00 00 call 10ea58 <_Thread_Enable_dispatch> return EAGAIN; 10ba4d: b8 0b 00 00 00 mov $0xb,%eax 10ba52: eb e9 jmp 10ba3d * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10ba54: 83 ec 0c sub $0xc,%esp 10ba57: 8d 7d d8 lea -0x28(%ebp),%edi 10ba5a: 57 push %edi 10ba5b: e8 7c fe ff ff call 10b8dc 10ba60: 83 c4 10 add $0x10,%esp 10ba63: e9 5a ff ff ff jmp 10b9c2 =============================================================================== 0010ba68 : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 10ba68: 55 push %ebp 10ba69: 89 e5 mov %esp,%ebp 10ba6b: 83 ec 18 sub $0x18,%esp 10ba6e: 8b 45 08 mov 0x8(%ebp),%eax POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10ba71: 85 c0 test %eax,%eax 10ba73: 74 4f je 10bac4 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 10ba75: 51 push %ecx return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); 10ba76: 8d 55 f4 lea -0xc(%ebp),%edx 10ba79: 52 push %edx 10ba7a: ff 30 pushl (%eax) 10ba7c: 68 40 91 12 00 push $0x129140 10ba81: e8 1e 25 00 00 call 10dfa4 <_Objects_Get> switch ( location ) { 10ba86: 83 c4 10 add $0x10,%esp 10ba89: 8b 55 f4 mov -0xc(%ebp),%edx 10ba8c: 85 d2 test %edx,%edx 10ba8e: 75 34 jne 10bac4 case OBJECTS_LOCAL: _CORE_barrier_Wait( 10ba90: 83 ec 0c sub $0xc,%esp 10ba93: 6a 00 push $0x0 10ba95: 6a 00 push $0x0 10ba97: 6a 01 push $0x1 10ba99: ff 70 08 pushl 0x8(%eax) 10ba9c: 83 c0 10 add $0x10,%eax 10ba9f: 50 push %eax 10baa0: e8 77 16 00 00 call 10d11c <_CORE_barrier_Wait> the_barrier->Object.id, true, 0, NULL ); _Thread_Enable_dispatch(); 10baa5: 83 c4 20 add $0x20,%esp 10baa8: e8 ab 2f 00 00 call 10ea58 <_Thread_Enable_dispatch> return _POSIX_Barrier_Translate_core_barrier_return_code( 10baad: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code ); 10bab0: a1 d8 92 12 00 mov 0x1292d8,%eax true, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 10bab5: ff 70 34 pushl 0x34(%eax) 10bab8: e8 e7 5b 00 00 call 1116a4 <_POSIX_Barrier_Translate_core_barrier_return_code> 10babd: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10bac0: c9 leave 10bac1: c3 ret 10bac2: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return EINVAL; 10bac4: b8 16 00 00 00 mov $0x16,%eax } 10bac9: c9 leave 10baca: c3 ret =============================================================================== 0010b894 : */ int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { 10b894: 55 push %ebp 10b895: 89 e5 mov %esp,%ebp 10b897: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == false ) 10b89a: 85 c0 test %eax,%eax 10b89c: 74 12 je 10b8b0 10b89e: 8b 10 mov (%eax),%edx 10b8a0: 85 d2 test %edx,%edx 10b8a2: 74 0c je 10b8b0 return EINVAL; attr->is_initialized = false; 10b8a4: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10b8aa: 31 c0 xor %eax,%eax } 10b8ac: c9 leave 10b8ad: c3 ret 10b8ae: 66 90 xchg %ax,%ax int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { if ( !attr || attr->is_initialized == false ) return EINVAL; 10b8b0: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10b8b5: c9 leave 10b8b6: c3 ret =============================================================================== 0010b134 : */ int pthread_cancel( pthread_t thread ) { 10b134: 55 push %ebp 10b135: 89 e5 mov %esp,%ebp 10b137: 83 ec 18 sub $0x18,%esp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 10b13a: a1 54 8e 12 00 mov 0x128e54,%eax 10b13f: 85 c0 test %eax,%eax 10b141: 74 09 je 10b14c return EPROTO; 10b143: b8 47 00 00 00 mov $0x47,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10b148: c9 leave 10b149: c3 ret 10b14a: 66 90 xchg %ax,%ax pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 10b14c: 51 push %ecx */ if ( _ISR_Is_in_progress() ) return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); 10b14d: 8d 45 f4 lea -0xc(%ebp),%eax 10b150: 50 push %eax 10b151: ff 75 08 pushl 0x8(%ebp) 10b154: 68 40 8b 12 00 push $0x128b40 10b159: e8 2a 21 00 00 call 10d288 <_Objects_Get> switch ( location ) { 10b15e: 83 c4 10 add $0x10,%esp 10b161: 8b 55 f4 mov -0xc(%ebp),%edx 10b164: 85 d2 test %edx,%edx 10b166: 75 20 jne 10b188 case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; thread_support->cancelation_requested = 1; 10b168: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 10b16e: c7 82 e0 00 00 00 01 movl $0x1,0xe0(%edx) 10b175: 00 00 00 /* This enables dispatch implicitly */ _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread ); 10b178: 83 ec 0c sub $0xc,%esp 10b17b: 50 push %eax 10b17c: e8 5b 55 00 00 call 1106dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch> return 0; 10b181: 83 c4 10 add $0x10,%esp 10b184: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10b186: c9 leave 10b187: c3 ret #endif case OBJECTS_ERROR: break; } return EINVAL; 10b188: b8 16 00 00 00 mov $0x16,%eax } 10b18d: c9 leave 10b18e: c3 ret =============================================================================== 0010afb4 : */ void pthread_cleanup_pop( int execute ) { 10afb4: 55 push %ebp 10afb5: 89 e5 mov %esp,%ebp 10afb7: 57 push %edi 10afb8: 56 push %esi 10afb9: 53 push %ebx 10afba: 83 ec 0c sub $0xc,%esp 10afbd: 8b 5d 08 mov 0x8(%ebp),%ebx POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10afc0: a1 58 7f 12 00 mov 0x127f58,%eax 10afc5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10afcb: 8b 15 70 79 12 00 mov 0x127970,%edx 10afd1: 42 inc %edx 10afd2: 89 15 70 79 12 00 mov %edx,0x127970 * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10afd8: 9c pushf 10afd9: fa cli 10afda: 5e pop %esi RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10afdb: 8d 90 e8 00 00 00 lea 0xe8(%eax),%edx if ( _Chain_Is_empty( handler_stack ) ) { 10afe1: 39 90 e4 00 00 00 cmp %edx,0xe4(%eax) 10afe7: 74 47 je 10b030 _Thread_Enable_dispatch(); _ISR_Enable( level ); return; } handler = (POSIX_Cancel_Handler_control *) 10afe9: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10afef: 8b 08 mov (%eax),%ecx previous = the_node->previous; 10aff1: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 10aff4: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 10aff7: 89 0a mov %ecx,(%edx) _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 10aff9: 56 push %esi 10affa: 9d popf 10affb: 8b 70 08 mov 0x8(%eax),%esi 10affe: 8b 78 0c mov 0xc(%eax),%edi tmp_handler = *handler; _Workspace_Free( handler ); 10b001: 83 ec 0c sub $0xc,%esp 10b004: 50 push %eax 10b005: e8 3a 3a 00 00 call 10ea44 <_Workspace_Free> _Thread_Enable_dispatch(); 10b00a: e8 ad 29 00 00 call 10d9bc <_Thread_Enable_dispatch> if ( execute ) 10b00f: 83 c4 10 add $0x10,%esp 10b012: 85 db test %ebx,%ebx 10b014: 75 0a jne 10b020 (*tmp_handler.routine)( tmp_handler.arg ); } 10b016: 8d 65 f4 lea -0xc(%ebp),%esp 10b019: 5b pop %ebx 10b01a: 5e pop %esi 10b01b: 5f pop %edi 10b01c: c9 leave 10b01d: c3 ret 10b01e: 66 90 xchg %ax,%ax _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10b020: 89 7d 08 mov %edi,0x8(%ebp) 10b023: 89 f0 mov %esi,%eax } 10b025: 8d 65 f4 lea -0xc(%ebp),%esp 10b028: 5b pop %ebx 10b029: 5e pop %esi 10b02a: 5f pop %edi 10b02b: c9 leave _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10b02c: ff e0 jmp *%eax 10b02e: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); _ISR_Disable( level ); if ( _Chain_Is_empty( handler_stack ) ) { _Thread_Enable_dispatch(); 10b030: e8 87 29 00 00 call 10d9bc <_Thread_Enable_dispatch> _ISR_Enable( level ); 10b035: 56 push %esi 10b036: 9d popf _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); } 10b037: 8d 65 f4 lea -0xc(%ebp),%esp 10b03a: 5b pop %ebx 10b03b: 5e pop %esi 10b03c: 5f pop %edi 10b03d: c9 leave 10b03e: c3 ret =============================================================================== 0010b360 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 10b360: 55 push %ebp 10b361: 89 e5 mov %esp,%ebp 10b363: 56 push %esi 10b364: 53 push %ebx 10b365: 8b 5d 08 mov 0x8(%ebp),%ebx 10b368: 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 ) 10b36b: 85 db test %ebx,%ebx 10b36d: 74 4d je 10b3bc rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b36f: a1 10 90 12 00 mov 0x129010,%eax 10b374: 40 inc %eax 10b375: a3 10 90 12 00 mov %eax,0x129010 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 10b37a: 83 ec 0c sub $0xc,%esp 10b37d: 6a 10 push $0x10 10b37f: e8 00 42 00 00 call 10f584 <_Workspace_Allocate> if ( handler ) { 10b384: 83 c4 10 add $0x10,%esp 10b387: 85 c0 test %eax,%eax 10b389: 74 25 je 10b3b0 <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b38b: 8b 15 f8 95 12 00 mov 0x1295f8,%edx handler_stack = &thread_support->Cancellation_Handlers; 10b391: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 10b397: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 10b39d: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 10b3a0: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 10b3a3: 83 ec 08 sub $0x8,%esp 10b3a6: 50 push %eax 10b3a7: 52 push %edx 10b3a8: e8 c3 17 00 00 call 10cb70 <_Chain_Append> 10b3ad: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 10b3b0: 8d 65 f8 lea -0x8(%ebp),%esp 10b3b3: 5b pop %ebx 10b3b4: 5e pop %esi 10b3b5: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 10b3b6: e9 cd 30 00 00 jmp 10e488 <_Thread_Enable_dispatch> 10b3bb: 90 nop } 10b3bc: 8d 65 f8 lea -0x8(%ebp),%esp 10b3bf: 5b pop %ebx 10b3c0: 5e pop %esi 10b3c1: c9 leave 10b3c2: c3 ret =============================================================================== 0010c054 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 10c054: 55 push %ebp 10c055: 89 e5 mov %esp,%ebp 10c057: 53 push %ebx 10c058: 83 ec 1c sub $0x1c,%esp POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10c05b: 8d 45 f4 lea -0xc(%ebp),%eax 10c05e: 50 push %eax 10c05f: ff 75 08 pushl 0x8(%ebp) 10c062: e8 65 00 00 00 call 10c0cc <_POSIX_Condition_variables_Get> 10c067: 89 c3 mov %eax,%ebx switch ( location ) { 10c069: 83 c4 10 add $0x10,%esp 10c06c: 8b 4d f4 mov -0xc(%ebp),%ecx 10c06f: 85 c9 test %ecx,%ecx 10c071: 75 25 jne 10c098 case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 10c073: 83 ec 0c sub $0xc,%esp 10c076: 8d 40 18 lea 0x18(%eax),%eax 10c079: 50 push %eax 10c07a: e8 b9 3d 00 00 call 10fe38 <_Thread_queue_First> 10c07f: 83 c4 10 add $0x10,%esp 10c082: 85 c0 test %eax,%eax 10c084: 74 1e je 10c0a4 _Thread_Enable_dispatch(); 10c086: e8 95 36 00 00 call 10f720 <_Thread_Enable_dispatch> return EBUSY; 10c08b: b8 10 00 00 00 mov $0x10,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c090: 8b 5d fc mov -0x4(%ebp),%ebx 10c093: c9 leave 10c094: c3 ret 10c095: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return EINVAL; 10c098: b8 16 00 00 00 mov $0x16,%eax } 10c09d: 8b 5d fc mov -0x4(%ebp),%ebx 10c0a0: c9 leave 10c0a1: c3 ret 10c0a2: 66 90 xchg %ax,%ax if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( 10c0a4: 83 ec 08 sub $0x8,%esp 10c0a7: 53 push %ebx 10c0a8: 68 c0 a1 12 00 push $0x12a1c0 10c0ad: e8 7e 27 00 00 call 10e830 <_Objects_Close> RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 10c0b2: 58 pop %eax 10c0b3: 5a pop %edx 10c0b4: 53 push %ebx 10c0b5: 68 c0 a1 12 00 push $0x12a1c0 10c0ba: e8 6d 2a 00 00 call 10eb2c <_Objects_Free> &_POSIX_Condition_variables_Information, &the_cond->Object ); _POSIX_Condition_variables_Free( the_cond ); _Thread_Enable_dispatch(); 10c0bf: e8 5c 36 00 00 call 10f720 <_Thread_Enable_dispatch> return 0; 10c0c4: 83 c4 10 add $0x10,%esp 10c0c7: 31 c0 xor %eax,%eax 10c0c9: eb d2 jmp 10c09d =============================================================================== 0010c120 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10c120: 55 push %ebp 10c121: 89 e5 mov %esp,%ebp 10c123: 53 push %ebx 10c124: 83 ec 14 sub $0x14,%esp 10c127: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10c12a: 85 db test %ebx,%ebx 10c12c: 0f 84 86 00 00 00 je 10c1b8 else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10c132: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10c136: 74 06 je 10c13e <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10c138: 8b 03 mov (%ebx),%eax 10c13a: 85 c0 test %eax,%eax 10c13c: 75 0a jne 10c148 return EINVAL; 10c13e: b8 16 00 00 00 mov $0x16,%eax *cond = the_cond->Object.id; _Thread_Enable_dispatch(); return 0; } 10c143: 8b 5d fc mov -0x4(%ebp),%ebx 10c146: c9 leave 10c147: c3 ret rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c148: a1 d0 9c 12 00 mov 0x129cd0,%eax 10c14d: 40 inc %eax 10c14e: a3 d0 9c 12 00 mov %eax,0x129cd0 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10c153: 83 ec 0c sub $0xc,%esp 10c156: 68 c0 a1 12 00 push $0x12a1c0 10c15b: e8 54 26 00 00 call 10e7b4 <_Objects_Allocate> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10c160: 83 c4 10 add $0x10,%esp 10c163: 85 c0 test %eax,%eax 10c165: 74 5d je 10c1c4 _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 10c167: 8b 53 04 mov 0x4(%ebx),%edx 10c16a: 89 50 10 mov %edx,0x10(%eax) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10c16d: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) _Thread_queue_Initialize( 10c174: 6a 74 push $0x74 10c176: 68 00 08 00 10 push $0x10000800 10c17b: 6a 00 push $0x0 10c17d: 8d 50 18 lea 0x18(%eax),%edx 10c180: 52 push %edx 10c181: 89 45 f4 mov %eax,-0xc(%ebp) 10c184: e8 2b 3d 00 00 call 10feb4 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c189: 8b 45 f4 mov -0xc(%ebp),%eax 10c18c: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10c18f: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c192: 8b 0d dc a1 12 00 mov 0x12a1dc,%ecx 10c198: 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; 10c19b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10c1a2: 8b 45 08 mov 0x8(%ebp),%eax 10c1a5: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c1a7: e8 74 35 00 00 call 10f720 <_Thread_Enable_dispatch> return 0; 10c1ac: 83 c4 10 add $0x10,%esp 10c1af: 31 c0 xor %eax,%eax } 10c1b1: 8b 5d fc mov -0x4(%ebp),%ebx 10c1b4: c9 leave 10c1b5: c3 ret 10c1b6: 66 90 xchg %ax,%ax { POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; else the_attr = &_POSIX_Condition_variables_Default_attributes; 10c1b8: bb 3c 33 12 00 mov $0x12333c,%ebx 10c1bd: e9 70 ff ff ff jmp 10c132 10c1c2: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { _Thread_Enable_dispatch(); 10c1c4: e8 57 35 00 00 call 10f720 <_Thread_Enable_dispatch> return ENOMEM; 10c1c9: b8 0c 00 00 00 mov $0xc,%eax 10c1ce: e9 70 ff ff ff jmp 10c143 =============================================================================== 0010bfb0 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10bfb0: 55 push %ebp 10bfb1: 89 e5 mov %esp,%ebp 10bfb3: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == false ) 10bfb6: 85 c0 test %eax,%eax 10bfb8: 74 12 je 10bfcc 10bfba: 8b 10 mov (%eax),%edx 10bfbc: 85 d2 test %edx,%edx 10bfbe: 74 0c je 10bfcc <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10bfc0: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10bfc6: 31 c0 xor %eax,%eax } 10bfc8: c9 leave 10bfc9: c3 ret 10bfca: 66 90 xchg %ax,%ax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) return EINVAL; 10bfcc: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10bfd1: c9 leave 10bfd2: c3 ret =============================================================================== 0010bfd4 : int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { 10bfd4: 55 push %ebp 10bfd5: 89 e5 mov %esp,%ebp 10bfd7: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr ) 10bfda: 85 c0 test %eax,%eax 10bfdc: 74 0e je 10bfec return EINVAL; *pshared = attr->process_shared; 10bfde: 8b 50 04 mov 0x4(%eax),%edx 10bfe1: 8b 45 0c mov 0xc(%ebp),%eax 10bfe4: 89 10 mov %edx,(%eax) return 0; 10bfe6: 31 c0 xor %eax,%eax } 10bfe8: c9 leave 10bfe9: c3 ret 10bfea: 66 90 xchg %ax,%ax const pthread_condattr_t *attr, int *pshared ) { if ( !attr ) return EINVAL; 10bfec: b8 16 00 00 00 mov $0x16,%eax *pshared = attr->process_shared; return 0; } 10bff1: c9 leave 10bff2: c3 ret =============================================================================== 0010bff4 : */ int pthread_condattr_init( pthread_condattr_t *attr ) { 10bff4: 55 push %ebp 10bff5: 89 e5 mov %esp,%ebp 10bff7: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr ) 10bffa: 85 c0 test %eax,%eax 10bffc: 74 16 je 10c014 <== NEVER TAKEN return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; 10bffe: 8b 15 3c 33 12 00 mov 0x12333c,%edx 10c004: 8b 0d 40 33 12 00 mov 0x123340,%ecx 10c00a: 89 10 mov %edx,(%eax) 10c00c: 89 48 04 mov %ecx,0x4(%eax) return 0; 10c00f: 31 c0 xor %eax,%eax } 10c011: c9 leave 10c012: c3 ret 10c013: 90 nop int pthread_condattr_init( pthread_condattr_t *attr ) { if ( !attr ) return EINVAL; 10c014: b8 16 00 00 00 mov $0x16,%eax *attr = _POSIX_Condition_variables_Default_attributes; return 0; } 10c019: c9 leave 10c01a: c3 ret =============================================================================== 0010c01c : int pthread_condattr_setpshared( pthread_condattr_t *attr, int pshared ) { 10c01c: 55 push %ebp 10c01d: 89 e5 mov %esp,%ebp 10c01f: 8b 45 08 mov 0x8(%ebp),%eax 10c022: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr ) 10c025: 85 c0 test %eax,%eax 10c027: 74 05 je 10c02e return EINVAL; switch ( pshared ) { 10c029: 83 fa 01 cmp $0x1,%edx 10c02c: 76 0a jbe 10c038 case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; default: return EINVAL; 10c02e: b8 16 00 00 00 mov $0x16,%eax } } 10c033: c9 leave 10c034: c3 ret 10c035: 8d 76 00 lea 0x0(%esi),%esi return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10c038: 89 50 04 mov %edx,0x4(%eax) return 0; 10c03b: 31 c0 xor %eax,%eax default: return EINVAL; } } 10c03d: c9 leave 10c03e: c3 ret =============================================================================== 0010b6d8 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10b6d8: 55 push %ebp 10b6d9: 89 e5 mov %esp,%ebp 10b6db: 57 push %edi 10b6dc: 56 push %esi 10b6dd: 53 push %ebx 10b6de: 83 ec 5c sub $0x5c,%esp 10b6e1: 8b 5d 0c mov 0xc(%ebp),%ebx int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 10b6e4: 8b 75 10 mov 0x10(%ebp),%esi 10b6e7: 85 f6 test %esi,%esi 10b6e9: 0f 84 8d 01 00 00 je 10b87c return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10b6ef: 85 db test %ebx,%ebx 10b6f1: 74 65 je 10b758 if ( !the_attr->is_initialized ) 10b6f3: 8b 0b mov (%ebx),%ecx 10b6f5: 85 c9 test %ecx,%ecx 10b6f7: 74 1e je 10b717 * 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) ) 10b6f9: 8b 53 04 mov 0x4(%ebx),%edx 10b6fc: 85 d2 test %edx,%edx 10b6fe: 74 0a je 10b70a 10b700: a1 78 45 12 00 mov 0x124578,%eax 10b705: 39 43 08 cmp %eax,0x8(%ebx) 10b708: 72 0d jb 10b717 * 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 ) { 10b70a: 8b 43 10 mov 0x10(%ebx),%eax 10b70d: 83 f8 01 cmp $0x1,%eax 10b710: 74 4e je 10b760 10b712: 83 f8 02 cmp $0x2,%eax 10b715: 74 11 je 10b728 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) return EINVAL; 10b717: ba 16 00 00 00 mov $0x16,%edx */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10b71c: 89 d0 mov %edx,%eax 10b71e: 8d 65 f4 lea -0xc(%ebp),%esp 10b721: 5b pop %ebx 10b722: 5e pop %esi 10b723: 5f pop %edi 10b724: c9 leave 10b725: c3 ret 10b726: 66 90 xchg %ax,%ax schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10b728: 8b 4b 14 mov 0x14(%ebx),%ecx 10b72b: 89 4d b0 mov %ecx,-0x50(%ebp) schedparam = the_attr->schedparam; 10b72e: 8d 45 c4 lea -0x3c(%ebp),%eax 10b731: 89 45 b4 mov %eax,-0x4c(%ebp) 10b734: 8d 73 18 lea 0x18(%ebx),%esi 10b737: b9 07 00 00 00 mov $0x7,%ecx 10b73c: 89 c7 mov %eax,%edi 10b73e: 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 ) 10b740: 8b 43 0c mov 0xc(%ebx),%eax 10b743: 85 c0 test %eax,%eax 10b745: 74 49 je 10b790 <== ALWAYS TAKEN return ENOTSUP; 10b747: ba 86 00 00 00 mov $0x86,%edx */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10b74c: 89 d0 mov %edx,%eax 10b74e: 8d 65 f4 lea -0xc(%ebp),%esp 10b751: 5b pop %ebx 10b752: 5e pop %esi 10b753: 5f pop %edi 10b754: c9 leave 10b755: c3 ret 10b756: 66 90 xchg %ax,%ax int rc; if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10b758: bb e0 1e 12 00 mov $0x121ee0,%ebx 10b75d: eb 94 jmp 10b6f3 10b75f: 90 nop * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b760: a1 38 8e 12 00 mov 0x128e38,%eax 10b765: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10b76b: 8b 8e 84 00 00 00 mov 0x84(%esi),%ecx 10b771: 89 4d b0 mov %ecx,-0x50(%ebp) schedparam = api->schedparam; 10b774: 8d 45 c4 lea -0x3c(%ebp),%eax 10b777: 89 45 b4 mov %eax,-0x4c(%ebp) 10b77a: 81 c6 88 00 00 00 add $0x88,%esi 10b780: b9 07 00 00 00 mov $0x7,%ecx 10b785: 89 c7 mov %eax,%edi 10b787: 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 ) 10b789: 8b 43 0c mov 0xc(%ebx),%eax 10b78c: 85 c0 test %eax,%eax 10b78e: 75 b7 jne 10b747 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10b790: 83 ec 0c sub $0xc,%esp 10b793: ff 75 c4 pushl -0x3c(%ebp) 10b796: e8 95 62 00 00 call 111a30 <_POSIX_Priority_Is_valid> 10b79b: 83 c4 10 add $0x10,%esp 10b79e: 84 c0 test %al,%al 10b7a0: 0f 84 71 ff ff ff je 10b717 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10b7a6: 8b 7d c4 mov -0x3c(%ebp),%edi RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10b7a9: 0f b6 35 7c 45 12 00 movzbl 0x12457c,%esi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10b7b0: 8d 45 e0 lea -0x20(%ebp),%eax 10b7b3: 50 push %eax 10b7b4: 8d 45 e4 lea -0x1c(%ebp),%eax 10b7b7: 50 push %eax 10b7b8: ff 75 b4 pushl -0x4c(%ebp) 10b7bb: ff 75 b0 pushl -0x50(%ebp) 10b7be: e8 89 62 00 00 call 111a4c <_POSIX_Thread_Translate_sched_param> 10b7c3: 89 c2 mov %eax,%edx schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 85 c0 test %eax,%eax 10b7ca: 0f 85 4c ff ff ff jne 10b71c #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10b7d0: 83 ec 0c sub $0xc,%esp 10b7d3: ff 35 3c 89 12 00 pushl 0x12893c 10b7d9: 89 45 a0 mov %eax,-0x60(%ebp) 10b7dc: e8 bf 17 00 00 call 10cfa0 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10b7e1: c7 04 24 20 8b 12 00 movl $0x128b20,(%esp) 10b7e8: e8 d7 21 00 00 call 10d9c4 <_Objects_Allocate> 10b7ed: 89 45 ac mov %eax,-0x54(%ebp) * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10b7f0: 83 c4 10 add $0x10,%esp 10b7f3: 85 c0 test %eax,%eax 10b7f5: 8b 55 a0 mov -0x60(%ebp),%edx 10b7f8: 0f 84 0f 01 00 00 je 10b90d /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10b7fe: 8b 4d e0 mov -0x20(%ebp),%ecx 10b801: 8b 45 e4 mov -0x1c(%ebp),%eax 10b804: 89 45 a4 mov %eax,-0x5c(%ebp) 10b807: 8b 43 08 mov 0x8(%ebx),%eax 10b80a: 89 45 a8 mov %eax,-0x58(%ebp) 10b80d: a1 78 45 12 00 mov 0x124578,%eax 10b812: d1 e0 shl %eax 10b814: 3b 45 a8 cmp -0x58(%ebp),%eax 10b817: 73 03 jae 10b81c 10b819: 8b 45 a8 mov -0x58(%ebp),%eax 10b81c: 83 ec 04 sub $0x4,%esp 10b81f: 6a 00 push $0x0 10b821: 6a 00 push $0x0 10b823: 51 push %ecx 10b824: ff 75 a4 pushl -0x5c(%ebp) 10b827: 6a 01 push $0x1 10b829: 81 e6 ff 00 00 00 and $0xff,%esi 10b82f: 29 fe sub %edi,%esi 10b831: 56 push %esi 10b832: 6a 01 push $0x1 10b834: 50 push %eax 10b835: ff 73 04 pushl 0x4(%ebx) 10b838: ff 75 ac pushl -0x54(%ebp) 10b83b: 68 20 8b 12 00 push $0x128b20 10b840: 89 55 a0 mov %edx,-0x60(%ebp) 10b843: e8 80 31 00 00 call 10e9c8 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10b848: 83 c4 30 add $0x30,%esp 10b84b: 84 c0 test %al,%al 10b84d: 8b 55 a0 mov -0x60(%ebp),%edx 10b850: 75 34 jne 10b886 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10b852: 83 ec 08 sub $0x8,%esp 10b855: ff 75 ac pushl -0x54(%ebp) 10b858: 68 20 8b 12 00 push $0x128b20 10b85d: e8 da 24 00 00 call 10dd3c <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b862: 59 pop %ecx 10b863: ff 35 3c 89 12 00 pushl 0x12893c 10b869: e8 7a 17 00 00 call 10cfe8 <_API_Mutex_Unlock> return EAGAIN; 10b86e: 83 c4 10 add $0x10,%esp 10b871: ba 0b 00 00 00 mov $0xb,%edx 10b876: e9 a1 fe ff ff jmp 10b71c 10b87b: 90 nop struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10b87c: ba 0e 00 00 00 mov $0xe,%edx 10b881: e9 96 fe ff ff jmp 10b71c } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10b886: 8b 4d ac mov -0x54(%ebp),%ecx 10b889: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b88f: 89 4d a8 mov %ecx,-0x58(%ebp) api->Attributes = *the_attr; 10b892: b9 10 00 00 00 mov $0x10,%ecx 10b897: 8b 7d a8 mov -0x58(%ebp),%edi 10b89a: 89 de mov %ebx,%esi 10b89c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10b89e: 8b 43 3c mov 0x3c(%ebx),%eax 10b8a1: 8b 4d a8 mov -0x58(%ebp),%ecx 10b8a4: 89 41 40 mov %eax,0x40(%ecx) api->schedpolicy = schedpolicy; 10b8a7: 8b 45 b0 mov -0x50(%ebp),%eax 10b8aa: 89 81 84 00 00 00 mov %eax,0x84(%ecx) api->schedparam = schedparam; 10b8b0: 89 cf mov %ecx,%edi 10b8b2: 81 c7 88 00 00 00 add $0x88,%edi 10b8b8: b9 07 00 00 00 mov $0x7,%ecx 10b8bd: 8b 75 b4 mov -0x4c(%ebp),%esi 10b8c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10b8c2: 83 ec 0c sub $0xc,%esp 10b8c5: 6a 00 push $0x0 10b8c7: ff 75 14 pushl 0x14(%ebp) 10b8ca: ff 75 10 pushl 0x10(%ebp) 10b8cd: 6a 01 push $0x1 10b8cf: ff 75 ac pushl -0x54(%ebp) 10b8d2: 89 55 a0 mov %edx,-0x60(%ebp) 10b8d5: e8 66 3a 00 00 call 10f340 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10b8da: 83 c4 20 add $0x20,%esp 10b8dd: 83 7d b0 04 cmpl $0x4,-0x50(%ebp) 10b8e1: 8b 55 a0 mov -0x60(%ebp),%edx 10b8e4: 74 42 je 10b928 } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10b8e6: 8b 45 ac mov -0x54(%ebp),%eax 10b8e9: 8b 48 08 mov 0x8(%eax),%ecx 10b8ec: 8b 45 08 mov 0x8(%ebp),%eax 10b8ef: 89 08 mov %ecx,(%eax) _RTEMS_Unlock_allocator(); 10b8f1: 83 ec 0c sub $0xc,%esp 10b8f4: ff 35 3c 89 12 00 pushl 0x12893c 10b8fa: 89 55 a0 mov %edx,-0x60(%ebp) 10b8fd: e8 e6 16 00 00 call 10cfe8 <_API_Mutex_Unlock> return 0; 10b902: 83 c4 10 add $0x10,%esp 10b905: 8b 55 a0 mov -0x60(%ebp),%edx 10b908: e9 0f fe ff ff jmp 10b71c * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10b90d: 83 ec 0c sub $0xc,%esp 10b910: ff 35 3c 89 12 00 pushl 0x12893c 10b916: e8 cd 16 00 00 call 10cfe8 <_API_Mutex_Unlock> return EAGAIN; 10b91b: 83 c4 10 add $0x10,%esp 10b91e: ba 0b 00 00 00 mov $0xb,%edx 10b923: e9 f4 fd ff ff jmp 10b71c return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10b928: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10b92b: 8b 45 a8 mov -0x58(%ebp),%eax 10b92e: 05 90 00 00 00 add $0x90,%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10b933: 50 push %eax 10b934: e8 a3 3b 00 00 call 10f4dc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b939: 8b 4d a8 mov -0x58(%ebp),%ecx 10b93c: 89 81 b4 00 00 00 mov %eax,0xb4(%ecx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b942: 58 pop %eax 10b943: 5a pop %edx 10b944: 89 c8 mov %ecx,%eax 10b946: 05 a8 00 00 00 add $0xa8,%eax 10b94b: 50 push %eax 10b94c: 68 5c 89 12 00 push $0x12895c 10b951: e8 b6 3e 00 00 call 10f80c <_Watchdog_Insert> 10b956: 83 c4 10 add $0x10,%esp 10b959: 8b 55 a0 mov -0x60(%ebp),%edx 10b95c: eb 88 jmp 10b8e6 =============================================================================== 00112e78 : } void pthread_exit( void *value_ptr ) { 112e78: 55 push %ebp 112e79: 89 e5 mov %esp,%ebp 112e7b: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 112e7e: ff 75 08 pushl 0x8(%ebp) 112e81: ff 35 58 7b 12 00 pushl 0x127b58 112e87: e8 88 ff ff ff call 112e14 <_POSIX_Thread_Exit> 112e8c: 83 c4 10 add $0x10,%esp } 112e8f: c9 leave <== NOT EXECUTED 112e90: c3 ret <== NOT EXECUTED =============================================================================== 0010d8d0 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 10d8d0: 55 push %ebp 10d8d1: 89 e5 mov %esp,%ebp 10d8d3: 57 push %edi 10d8d4: 56 push %esi 10d8d5: 53 push %ebx 10d8d6: 83 ec 1c sub $0x1c,%esp 10d8d9: 8b 7d 0c mov 0xc(%ebp),%edi 10d8dc: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 10d8df: 85 ff test %edi,%edi 10d8e1: 74 69 je 10d94c 10d8e3: 85 db test %ebx,%ebx 10d8e5: 74 65 je 10d94c pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 10d8e7: 51 push %ecx return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); 10d8e8: 8d 45 e4 lea -0x1c(%ebp),%eax 10d8eb: 50 push %eax 10d8ec: ff 75 08 pushl 0x8(%ebp) 10d8ef: 68 60 b8 12 00 push $0x12b860 10d8f4: e8 07 24 00 00 call 10fd00 <_Objects_Get> switch ( location ) { 10d8f9: 83 c4 10 add $0x10,%esp 10d8fc: 8b 55 e4 mov -0x1c(%ebp),%edx 10d8ff: 85 d2 test %edx,%edx 10d901: 75 39 jne 10d93c case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d903: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi if ( policy ) *policy = api->schedpolicy; 10d909: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 10d90f: 89 17 mov %edx,(%edi) if ( param ) { *param = api->schedparam; 10d911: 81 c6 88 00 00 00 add $0x88,%esi 10d917: b9 07 00 00 00 mov $0x7,%ecx 10d91c: 89 df mov %ebx,%edi 10d91e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core( Priority_Control priority ) { return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10d920: 0f b6 15 5c 72 12 00 movzbl 0x12725c,%edx 10d927: 2b 50 14 sub 0x14(%eax),%edx 10d92a: 89 13 mov %edx,(%ebx) param->sched_priority = _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); 10d92c: e8 83 2e 00 00 call 1107b4 <_Thread_Enable_dispatch> return 0; 10d931: 31 c0 xor %eax,%eax break; } return ESRCH; } 10d933: 8d 65 f4 lea -0xc(%ebp),%esp 10d936: 5b pop %ebx 10d937: 5e pop %esi 10d938: 5f pop %edi 10d939: c9 leave 10d93a: c3 ret 10d93b: 90 nop #endif case OBJECTS_ERROR: break; } return ESRCH; 10d93c: b8 03 00 00 00 mov $0x3,%eax } 10d941: 8d 65 f4 lea -0xc(%ebp),%esp 10d944: 5b pop %ebx 10d945: 5e pop %esi 10d946: 5f pop %edi 10d947: c9 leave 10d948: c3 ret 10d949: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) return EINVAL; 10d94c: b8 16 00 00 00 mov $0x16,%eax break; } return ESRCH; } 10d951: 8d 65 f4 lea -0xc(%ebp),%esp 10d954: 5b pop %ebx 10d955: 5e pop %esi 10d956: 5f pop %edi 10d957: c9 leave 10d958: c3 ret =============================================================================== 0010b6b8 : */ void *pthread_getspecific( pthread_key_t key ) { 10b6b8: 55 push %ebp 10b6b9: 89 e5 mov %esp,%ebp 10b6bb: 83 ec 2c sub $0x2c,%esp uint32_t api; uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); 10b6be: 8d 45 f4 lea -0xc(%ebp),%eax pthread_key_t id, Objects_Locations *location ) { return (POSIX_Keys_Control *) _Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location ); 10b6c1: 50 push %eax 10b6c2: ff 75 08 pushl 0x8(%ebp) 10b6c5: 68 40 8a 12 00 push $0x128a40 10b6ca: e8 a5 25 00 00 call 10dc74 <_Objects_Get> switch ( location ) { 10b6cf: 83 c4 10 add $0x10,%esp 10b6d2: 8b 55 f4 mov -0xc(%ebp),%edx 10b6d5: 85 d2 test %edx,%edx 10b6d7: 75 2b jne 10b704 case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 10b6d9: 8b 15 78 8b 12 00 mov 0x128b78,%edx 10b6df: 8b 4a 08 mov 0x8(%edx),%ecx */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 10b6e2: 89 ca mov %ecx,%edx 10b6e4: c1 ea 18 shr $0x18,%edx 10b6e7: 83 e2 07 and $0x7,%edx index = _Objects_Get_index( _Thread_Executing->Object.id ); 10b6ea: 0f b7 c9 movzwl %cx,%ecx key_data = (void *) the_key->Values[ api ][ index ]; 10b6ed: 8b 44 90 14 mov 0x14(%eax,%edx,4),%eax 10b6f1: 8b 04 88 mov (%eax,%ecx,4),%eax _Thread_Enable_dispatch(); 10b6f4: 89 45 e4 mov %eax,-0x1c(%ebp) 10b6f7: e8 2c 30 00 00 call 10e728 <_Thread_Enable_dispatch> return key_data; 10b6fc: 8b 45 e4 mov -0x1c(%ebp),%eax case OBJECTS_ERROR: break; } return NULL; } 10b6ff: c9 leave 10b700: c3 ret 10b701: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return NULL; 10b704: 31 c0 xor %eax,%eax } 10b706: c9 leave 10b707: c3 ret =============================================================================== 00111118 : int pthread_join( pthread_t thread, void **value_ptr ) { 111118: 55 push %ebp 111119: 89 e5 mov %esp,%ebp 11111b: 53 push %ebx 11111c: 83 ec 18 sub $0x18,%esp 11111f: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); 111122: 8d 45 f4 lea -0xc(%ebp),%eax 111125: 50 push %eax 111126: ff 75 08 pushl 0x8(%ebp) 111129: 68 40 22 13 00 push $0x132240 11112e: e8 11 24 00 00 call 113544 <_Objects_Get> switch ( location ) { 111133: 83 c4 10 add $0x10,%esp 111136: 8b 55 f4 mov -0xc(%ebp),%edx 111139: 85 d2 test %edx,%edx 11113b: 74 0b je 111148 #endif case OBJECTS_ERROR: break; } return ESRCH; 11113d: b8 03 00 00 00 mov $0x3,%eax } 111142: 8b 5d fc mov -0x4(%ebp),%ebx 111145: c9 leave 111146: c3 ret 111147: 90 nop the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 111148: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 11114e: 8b 4a 40 mov 0x40(%edx),%ecx 111151: 85 c9 test %ecx,%ecx 111153: 74 43 je 111198 RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 111155: 8b 0d 58 25 13 00 mov 0x132558,%ecx _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 11115b: 39 c8 cmp %ecx,%eax 11115d: 74 49 je 1111a8 /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 11115f: 8d 45 f0 lea -0x10(%ebp),%eax 111162: 89 41 28 mov %eax,0x28(%ecx) 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; 111165: c7 42 74 01 00 00 00 movl $0x1,0x74(%edx) _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 11116c: 50 push %eax 11116d: 68 00 48 11 00 push $0x114800 111172: 6a 00 push $0x0 111174: 83 c2 44 add $0x44,%edx 111177: 52 push %edx 111178: e8 57 33 00 00 call 1144d4 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 11117d: e8 76 2e 00 00 call 113ff8 <_Thread_Enable_dispatch> if ( value_ptr ) 111182: 83 c4 10 add $0x10,%esp 111185: 85 db test %ebx,%ebx 111187: 74 2b je 1111b4 *value_ptr = return_pointer; 111189: 8b 45 f0 mov -0x10(%ebp),%eax 11118c: 89 03 mov %eax,(%ebx) return 0; 11118e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return ESRCH; } 111190: 8b 5d fc mov -0x4(%ebp),%ebx 111193: c9 leave 111194: c3 ret 111195: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { _Thread_Enable_dispatch(); 111198: e8 5b 2e 00 00 call 113ff8 <_Thread_Enable_dispatch> return EINVAL; 11119d: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return ESRCH; } 1111a2: 8b 5d fc mov -0x4(%ebp),%ebx 1111a5: c9 leave 1111a6: c3 ret 1111a7: 90 nop _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { _Thread_Enable_dispatch(); 1111a8: e8 4b 2e 00 00 call 113ff8 <_Thread_Enable_dispatch> return EDEADLK; 1111ad: b8 2d 00 00 00 mov $0x2d,%eax 1111b2: eb 8e jmp 111142 _Thread_Enable_dispatch(); if ( value_ptr ) *value_ptr = return_pointer; return 0; 1111b4: 31 c0 xor %eax,%eax 1111b6: eb 8a jmp 111142 =============================================================================== 0010b544 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 10b544: 55 push %ebp 10b545: 89 e5 mov %esp,%ebp 10b547: 57 push %edi 10b548: 56 push %esi 10b549: 53 push %ebx 10b54a: 83 ec 28 sub $0x28,%esp 10b54d: a1 90 85 12 00 mov 0x128590,%eax 10b552: 40 inc %eax 10b553: a3 90 85 12 00 mov %eax,0x128590 * the inactive chain of free keys control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 10b558: 68 40 8a 12 00 push $0x128a40 10b55d: e8 5a 22 00 00 call 10d7bc <_Objects_Allocate> 10b562: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 10b564: 83 c4 10 add $0x10,%esp 10b567: 85 c0 test %eax,%eax 10b569: 74 79 je 10b5e4 _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 10b56b: 8b 45 0c mov 0xc(%ebp),%eax 10b56e: 89 46 10 mov %eax,0x10(%esi) * This is a bit more complex than one might initially expect because * APIs are optional. * * NOTE: Currently RTEMS Classic API tasks are always enabled. */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 10b571: bb 01 00 00 00 mov $0x1,%ebx the_key->Values[ the_api ] = NULL; 10b576: c7 44 9e 14 00 00 00 movl $0x0,0x14(%esi,%ebx,4) 10b57d: 00 INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); 10b57e: 8b 04 9d 68 85 12 00 mov 0x128568(,%ebx,4),%eax 10b585: 8b 40 04 mov 0x4(%eax),%eax 10b588: 0f b7 40 10 movzwl 0x10(%eax),%eax true, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 10b58c: 8d 0c 85 04 00 00 00 lea 0x4(,%eax,4),%ecx (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 10b593: 83 ec 0c sub $0xc,%esp 10b596: 51 push %ecx 10b597: 89 4d e4 mov %ecx,-0x1c(%ebp) 10b59a: e8 fd 42 00 00 call 10f89c <_Workspace_Allocate> if ( !table ) { 10b59f: 83 c4 10 add $0x10,%esp 10b5a2: 85 c0 test %eax,%eax 10b5a4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b5a7: 74 4f je 10b5f8 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 10b5a9: 89 44 9e 14 mov %eax,0x14(%esi,%ebx,4) memset( table, '\0', bytes_to_allocate ); 10b5ad: 89 c7 mov %eax,%edi 10b5af: 31 c0 xor %eax,%eax 10b5b1: f3 aa rep stos %al,%es:(%edi) * This is a bit more complex than one might initially expect because * APIs are optional. * * NOTE: Currently RTEMS Classic API tasks are always enabled. */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 10b5b3: 43 inc %ebx 10b5b4: 83 fb 04 cmp $0x4,%ebx 10b5b7: 75 bd jne 10b576 uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b5b9: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b5bc: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b5bf: 8b 15 5c 8a 12 00 mov 0x128a5c,%edx 10b5c5: 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; 10b5c8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 10b5cf: 8b 55 08 mov 0x8(%ebp),%edx 10b5d2: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10b5d4: e8 4f 31 00 00 call 10e728 <_Thread_Enable_dispatch> return 0; 10b5d9: 31 c0 xor %eax,%eax } 10b5db: 8d 65 f4 lea -0xc(%ebp),%esp 10b5de: 5b pop %ebx 10b5df: 5e pop %esi 10b5e0: 5f pop %edi 10b5e1: c9 leave 10b5e2: c3 ret 10b5e3: 90 nop _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { _Thread_Enable_dispatch(); 10b5e4: e8 3f 31 00 00 call 10e728 <_Thread_Enable_dispatch> return EAGAIN; 10b5e9: b8 0b 00 00 00 mov $0xb,%eax _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; _Thread_Enable_dispatch(); return 0; } 10b5ee: 8d 65 f4 lea -0xc(%ebp),%esp 10b5f1: 5b pop %ebx 10b5f2: 5e pop %esi 10b5f3: 5f pop %edi 10b5f4: c9 leave 10b5f5: c3 ret 10b5f6: 66 90 xchg %ax,%ax bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { _POSIX_Keys_Free_memory( the_key ); 10b5f8: 83 ec 0c sub $0xc,%esp 10b5fb: 56 push %esi 10b5fc: e8 87 00 00 00 call 10b688 <_POSIX_Keys_Free_memory> */ RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 10b601: 58 pop %eax 10b602: 5a pop %edx 10b603: 56 push %esi 10b604: 68 40 8a 12 00 push $0x128a40 10b609: e8 26 25 00 00 call 10db34 <_Objects_Free> _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10b60e: e8 15 31 00 00 call 10e728 <_Thread_Enable_dispatch> return ENOMEM; 10b613: 83 c4 10 add $0x10,%esp 10b616: b8 0c 00 00 00 mov $0xc,%eax _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; _Thread_Enable_dispatch(); return 0; } 10b61b: 8d 65 f4 lea -0xc(%ebp),%esp 10b61e: 5b pop %ebx 10b61f: 5e pop %esi 10b620: 5f pop %edi 10b621: c9 leave 10b622: c3 ret =============================================================================== 0010b624 : * 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167 */ int pthread_key_delete( pthread_key_t key ) { 10b624: 55 push %ebp 10b625: 89 e5 mov %esp,%ebp 10b627: 53 push %ebx 10b628: 83 ec 18 sub $0x18,%esp POSIX_Keys_Control *the_key; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); 10b62b: 8d 45 f4 lea -0xc(%ebp),%eax pthread_key_t id, Objects_Locations *location ) { return (POSIX_Keys_Control *) _Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location ); 10b62e: 50 push %eax 10b62f: ff 75 08 pushl 0x8(%ebp) 10b632: 68 40 8a 12 00 push $0x128a40 10b637: e8 38 26 00 00 call 10dc74 <_Objects_Get> 10b63c: 89 c3 mov %eax,%ebx switch ( location ) { 10b63e: 83 c4 10 add $0x10,%esp 10b641: 8b 4d f4 mov -0xc(%ebp),%ecx 10b644: 85 c9 test %ecx,%ecx 10b646: 75 34 jne 10b67c case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 10b648: 83 ec 08 sub $0x8,%esp 10b64b: 50 push %eax 10b64c: 68 40 8a 12 00 push $0x128a40 10b651: e8 e2 21 00 00 call 10d838 <_Objects_Close> _POSIX_Keys_Free_memory( the_key ); 10b656: 89 1c 24 mov %ebx,(%esp) 10b659: e8 2a 00 00 00 call 10b688 <_POSIX_Keys_Free_memory> */ RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 10b65e: 58 pop %eax 10b65f: 5a pop %edx 10b660: 53 push %ebx 10b661: 68 40 8a 12 00 push $0x128a40 10b666: e8 c9 24 00 00 call 10db34 <_Objects_Free> /* * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10b66b: e8 b8 30 00 00 call 10e728 <_Thread_Enable_dispatch> return 0; 10b670: 83 c4 10 add $0x10,%esp 10b673: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10b675: 8b 5d fc mov -0x4(%ebp),%ebx 10b678: c9 leave 10b679: c3 ret 10b67a: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return EINVAL; 10b67c: b8 16 00 00 00 mov $0x16,%eax } 10b681: 8b 5d fc mov -0x4(%ebp),%ebx 10b684: c9 leave 10b685: c3 ret =============================================================================== 00124588 : int pthread_kill( pthread_t thread, int sig ) { 124588: 55 push %ebp 124589: 89 e5 mov %esp,%ebp 12458b: 57 push %edi 12458c: 56 push %esi 12458d: 53 push %ebx 12458e: 83 ec 1c sub $0x1c,%esp 124591: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 124594: 85 db test %ebx,%ebx 124596: 0f 84 84 00 00 00 je 124620 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 12459c: 8d 7b ff lea -0x1(%ebx),%edi rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 12459f: 83 ff 1f cmp $0x1f,%edi 1245a2: 77 7c ja 124620 pthread_t id, Objects_Locations *location ) { return (Thread_Control *) _Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location ); 1245a4: 56 push %esi rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _POSIX_Threads_Get( thread, &location ); 1245a5: 8d 45 e4 lea -0x1c(%ebp),%eax 1245a8: 50 push %eax 1245a9: ff 75 08 pushl 0x8(%ebp) 1245ac: 68 a0 e5 12 00 push $0x12e5a0 1245b1: e8 32 d9 fe ff call 111ee8 <_Objects_Get> 1245b6: 89 c6 mov %eax,%esi switch ( location ) { 1245b8: 83 c4 10 add $0x10,%esp 1245bb: 8b 4d e4 mov -0x1c(%ebp),%ecx 1245be: 85 c9 test %ecx,%ecx 1245c0: 75 72 jne 124634 case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1245c2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 1245c8: 8d 04 5b lea (%ebx,%ebx,2),%eax 1245cb: 83 3c 85 28 e9 12 00 cmpl $0x1,0x12e928(,%eax,4) 1245d2: 01 1245d3: 74 2d je 124602 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 1245d5: b8 01 00 00 00 mov $0x1,%eax 1245da: 89 f9 mov %edi,%ecx 1245dc: d3 e0 shl %cl,%eax return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 1245de: 09 82 d4 00 00 00 or %eax,0xd4(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 1245e4: 52 push %edx 1245e5: 6a 00 push $0x0 1245e7: 53 push %ebx 1245e8: 56 push %esi 1245e9: e8 7a fe ff ff call 124468 <_POSIX_signals_Unblock_thread> if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1245ee: 83 c4 10 add $0x10,%esp 1245f1: a1 b4 e8 12 00 mov 0x12e8b4,%eax 1245f6: 85 c0 test %eax,%eax 1245f8: 74 08 je 124602 1245fa: 3b 35 b8 e8 12 00 cmp 0x12e8b8,%esi 124600: 74 12 je 124614 _Thread_Dispatch_necessary = true; } _Thread_Enable_dispatch(); 124602: e8 15 e4 fe ff call 112a1c <_Thread_Enable_dispatch> return 0; 124607: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); } 124609: 8d 65 f4 lea -0xc(%ebp),%esp 12460c: 5b pop %ebx 12460d: 5e pop %esi 12460e: 5f pop %edi 12460f: c9 leave 124610: c3 ret 124611: 8d 76 00 lea 0x0(%esi),%esi api->signals_pending |= signo_to_mask( sig ); (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 124614: c6 05 c4 e8 12 00 01 movb $0x1,0x12e8c4 12461b: eb e5 jmp 124602 12461d: 8d 76 00 lea 0x0(%esi),%esi if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 124620: e8 c7 3e ff ff call 1184ec <__errno> 124625: c7 00 16 00 00 00 movl $0x16,(%eax) 12462b: b8 ff ff ff ff mov $0xffffffff,%eax 124630: eb d7 jmp 124609 124632: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 124634: e8 b3 3e ff ff call 1184ec <__errno> 124639: c7 00 03 00 00 00 movl $0x3,(%eax) 12463f: b8 ff ff ff ff mov $0xffffffff,%eax 124644: eb c3 jmp 124609 =============================================================================== 0010d19c : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 10d19c: 55 push %ebp 10d19d: 89 e5 mov %esp,%ebp 10d19f: 53 push %ebx 10d1a0: 83 ec 14 sub $0x14,%esp 10d1a3: 8b 5d 0c mov 0xc(%ebp),%ebx register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 10d1a6: 85 db test %ebx,%ebx 10d1a8: 74 19 je 10d1c3 return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10d1aa: 83 ec 08 sub $0x8,%esp 10d1ad: 8d 45 f4 lea -0xc(%ebp),%eax 10d1b0: 50 push %eax 10d1b1: ff 75 08 pushl 0x8(%ebp) 10d1b4: e8 3b ff ff ff call 10d0f4 <_POSIX_Mutex_Get> switch ( location ) { 10d1b9: 83 c4 10 add $0x10,%esp 10d1bc: 8b 55 f4 mov -0xc(%ebp),%edx 10d1bf: 85 d2 test %edx,%edx 10d1c1: 74 0d je 10d1d0 #endif case OBJECTS_ERROR: break; } return EINVAL; 10d1c3: b8 16 00 00 00 mov $0x16,%eax } 10d1c8: 8b 5d fc mov -0x4(%ebp),%ebx 10d1cb: c9 leave 10d1cc: c3 ret 10d1cd: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core( Priority_Control priority ) { return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10d1d0: 0f b6 15 5c 72 12 00 movzbl 0x12725c,%edx 10d1d7: 2b 50 60 sub 0x60(%eax),%edx 10d1da: 89 13 mov %edx,(%ebx) case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); 10d1dc: e8 d3 35 00 00 call 1107b4 <_Thread_Enable_dispatch> return 0; 10d1e1: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10d1e3: 8b 5d fc mov -0x4(%ebp),%ebx 10d1e6: c9 leave 10d1e7: c3 ret =============================================================================== 0010d1e8 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 10d1e8: 55 push %ebp 10d1e9: 89 e5 mov %esp,%ebp 10d1eb: 57 push %edi 10d1ec: 56 push %esi 10d1ed: 53 push %ebx 10d1ee: 83 ec 1c sub $0x1c,%esp 10d1f1: 8b 75 08 mov 0x8(%ebp),%esi 10d1f4: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Mutex_Control *the_mutex; CORE_mutex_Attributes *the_mutex_attr; const pthread_mutexattr_t *the_attr; CORE_mutex_Disciplines the_discipline; if ( attr ) the_attr = attr; 10d1f7: 85 db test %ebx,%ebx 10d1f9: 0f 84 09 01 00 00 je 10d308 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 10d1ff: 85 f6 test %esi,%esi 10d201: 0f 84 e5 00 00 00 je 10d2ec } } } #endif if ( !the_attr->is_initialized ) 10d207: 8b 13 mov (%ebx),%edx 10d209: 85 d2 test %edx,%edx 10d20b: 0f 84 db 00 00 00 je 10d2ec return EINVAL; /* * We only support process private mutexes. */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10d211: 8b 43 04 mov 0x4(%ebx),%eax 10d214: 83 f8 01 cmp $0x1,%eax 10d217: 0f 84 f7 00 00 00 je 10d314 return ENOSYS; if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE ) 10d21d: 85 c0 test %eax,%eax 10d21f: 0f 85 c7 00 00 00 jne 10d2ec return EINVAL; /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10d225: 8b 43 0c mov 0xc(%ebx),%eax 10d228: 83 f8 01 cmp $0x1,%eax 10d22b: 0f 84 eb 00 00 00 je 10d31c 10d231: 83 f8 02 cmp $0x2,%eax 10d234: 0f 84 c2 00 00 00 je 10d2fc 10d23a: 85 c0 test %eax,%eax 10d23c: 0f 85 aa 00 00 00 jne 10d2ec case PTHREAD_PRIO_NONE: the_discipline = CORE_MUTEX_DISCIPLINES_FIFO; 10d242: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) } /* * Validate the priority ceiling field -- should always be valid. */ if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 10d249: 83 ec 0c sub $0xc,%esp 10d24c: ff 73 08 pushl 0x8(%ebx) 10d24f: e8 58 03 00 00 call 10d5ac <_POSIX_Priority_Is_valid> 10d254: 83 c4 10 add $0x10,%esp 10d257: 84 c0 test %al,%al 10d259: 0f 84 8d 00 00 00 je 10d2ec #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) /* * Validate the mutex type and set appropriate SuperCore mutex * attributes. */ switch ( the_attr->type ) { 10d25f: 83 7b 10 03 cmpl $0x3,0x10(%ebx) 10d263: 0f 87 83 00 00 00 ja 10d2ec 10d269: a1 90 b5 12 00 mov 0x12b590,%eax 10d26e: 40 inc %eax 10d26f: a3 90 b5 12 00 mov %eax,0x12b590 * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 10d274: 83 ec 0c sub $0xc,%esp 10d277: 68 a0 b9 12 00 push $0x12b9a0 10d27c: e8 c7 25 00 00 call 10f848 <_Objects_Allocate> 10d281: 89 c7 mov %eax,%edi */ _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 10d283: 83 c4 10 add $0x10,%esp 10d286: 85 c0 test %eax,%eax 10d288: 0f 84 9a 00 00 00 je 10d328 _Thread_Enable_dispatch(); return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 10d28e: 8b 43 04 mov 0x4(%ebx),%eax 10d291: 89 47 10 mov %eax,0x10(%edi) the_mutex_attr = &the_mutex->Mutex.Attributes; 10d294: 8d 57 54 lea 0x54(%edi),%edx if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10d297: 31 c0 xor %eax,%eax 10d299: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10d29d: 0f 94 c0 sete %al 10d2a0: 89 47 54 mov %eax,0x54(%edi) else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = true; 10d2a3: c6 47 58 01 movb $0x1,0x58(%edi) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10d2a7: 0f b6 05 5c 72 12 00 movzbl 0x12725c,%eax 10d2ae: 2b 43 08 sub 0x8(%ebx),%eax 10d2b1: 89 47 60 mov %eax,0x60(%edi) the_mutex_attr->priority_ceiling = _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 10d2b4: 8b 45 e4 mov -0x1c(%ebp),%eax 10d2b7: 89 47 5c mov %eax,0x5c(%edi) /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 10d2ba: 50 push %eax 10d2bb: 6a 01 push $0x1 10d2bd: 52 push %edx 10d2be: 8d 47 14 lea 0x14(%edi),%eax 10d2c1: 50 push %eax 10d2c2: e8 0d 1d 00 00 call 10efd4 <_CORE_mutex_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10d2c7: 8b 47 08 mov 0x8(%edi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10d2ca: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10d2cd: 8b 15 bc b9 12 00 mov 0x12b9bc,%edx 10d2d3: 89 3c 8a mov %edi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10d2d6: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 10d2dd: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10d2df: e8 d0 34 00 00 call 1107b4 <_Thread_Enable_dispatch> return 0; 10d2e4: 83 c4 10 add $0x10,%esp 10d2e7: 31 c0 xor %eax,%eax 10d2e9: eb 06 jmp 10d2f1 10d2eb: 90 nop case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: break; default: return EINVAL; 10d2ec: b8 16 00 00 00 mov $0x16,%eax *mutex = the_mutex->Object.id; _Thread_Enable_dispatch(); return 0; } 10d2f1: 8d 65 f4 lea -0xc(%ebp),%esp 10d2f4: 5b pop %ebx 10d2f5: 5e pop %esi 10d2f6: 5f pop %edi 10d2f7: c9 leave 10d2f8: c3 ret 10d2f9: 8d 76 00 lea 0x0(%esi),%esi break; case PTHREAD_PRIO_INHERIT: the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; break; case PTHREAD_PRIO_PROTECT: the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10d2fc: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) break; 10d303: e9 41 ff ff ff jmp 10d249 CORE_mutex_Attributes *the_mutex_attr; const pthread_mutexattr_t *the_attr; CORE_mutex_Disciplines the_discipline; if ( attr ) the_attr = attr; else the_attr = &_POSIX_Mutex_Default_attributes; 10d308: bb 20 ba 12 00 mov $0x12ba20,%ebx 10d30d: e9 ed fe ff ff jmp 10d1ff 10d312: 66 90 xchg %ax,%ax /* * We only support process private mutexes. */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return ENOSYS; 10d314: b8 58 00 00 00 mov $0x58,%eax 10d319: eb d6 jmp 10d2f1 10d31b: 90 nop switch ( the_attr->protocol ) { case PTHREAD_PRIO_NONE: the_discipline = CORE_MUTEX_DISCIPLINES_FIFO; break; case PTHREAD_PRIO_INHERIT: the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10d31c: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) 10d323: e9 21 ff ff ff jmp 10d249 _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { _Thread_Enable_dispatch(); 10d328: e8 87 34 00 00 call 1107b4 <_Thread_Enable_dispatch> return EAGAIN; 10d32d: b8 0b 00 00 00 mov $0xb,%eax 10d332: eb bd jmp 10d2f1 =============================================================================== 0010d440 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10d440: 55 push %ebp 10d441: 89 e5 mov %esp,%ebp 10d443: 56 push %esi 10d444: 53 push %ebx 10d445: 83 ec 18 sub $0x18,%esp 10d448: 8b 75 08 mov 0x8(%ebp),%esi * * 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 ); 10d44b: 8d 45 f4 lea -0xc(%ebp),%eax 10d44e: 50 push %eax 10d44f: ff 75 0c pushl 0xc(%ebp) 10d452: e8 cd 00 00 00 call 10d524 <_POSIX_Absolute_timeout_to_ticks> 10d457: 89 c3 mov %eax,%ebx if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10d459: 83 c4 10 add $0x10,%esp 10d45c: 83 f8 03 cmp $0x3,%eax 10d45f: 74 2f je 10d490 do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10d461: 50 push %eax 10d462: ff 75 f4 pushl -0xc(%ebp) 10d465: 6a 00 push $0x0 10d467: 56 push %esi 10d468: e8 db fe ff ff call 10d348 <_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) ) { 10d46d: 83 c4 10 add $0x10,%esp 10d470: 83 f8 10 cmp $0x10,%eax 10d473: 74 07 je 10d47c <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return lock_status; } 10d475: 8d 65 f8 lea -0x8(%ebp),%esp 10d478: 5b pop %ebx 10d479: 5e pop %esi 10d47a: c9 leave 10d47b: c3 ret * 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) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10d47c: 85 db test %ebx,%ebx 10d47e: 74 28 je 10d4a8 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10d480: 4b dec %ebx 10d481: 83 fb 01 cmp $0x1,%ebx 10d484: 77 ef ja 10d475 <== NEVER TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10d486: b8 74 00 00 00 mov $0x74,%eax 10d48b: eb e8 jmp 10d475 10d48d: 8d 76 00 lea 0x0(%esi),%esi */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10d490: 52 push %edx 10d491: ff 75 f4 pushl -0xc(%ebp) 10d494: 6a 01 push $0x1 10d496: 56 push %esi 10d497: e8 ac fe ff ff call 10d348 <_POSIX_Mutex_Lock_support> 10d49c: 83 c4 10 add $0x10,%esp status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return lock_status; } 10d49f: 8d 65 f8 lea -0x8(%ebp),%esp 10d4a2: 5b pop %ebx 10d4a3: 5e pop %esi 10d4a4: c9 leave 10d4a5: c3 ret 10d4a6: 66 90 xchg %ax,%ax * 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; 10d4a8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10d4ad: eb c6 jmp 10d475 <== NOT EXECUTED =============================================================================== 0010cf24 : */ int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { 10cf24: 55 push %ebp 10cf25: 89 e5 mov %esp,%ebp 10cf27: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 10cf2a: 85 c0 test %eax,%eax 10cf2c: 74 12 je 10cf40 10cf2e: 8b 10 mov (%eax),%edx 10cf30: 85 d2 test %edx,%edx 10cf32: 74 0c je 10cf40 return EINVAL; attr->is_initialized = false; 10cf34: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10cf3a: 31 c0 xor %eax,%eax } 10cf3c: c9 leave 10cf3d: c3 ret 10cf3e: 66 90 xchg %ax,%ax int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { if ( !attr || !attr->is_initialized ) return EINVAL; 10cf40: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10cf45: c9 leave 10cf46: c3 ret =============================================================================== 0010cfec : int pthread_mutexattr_setprioceiling( pthread_mutexattr_t *attr, int prioceiling ) { 10cfec: 55 push %ebp 10cfed: 89 e5 mov %esp,%ebp 10cfef: 56 push %esi 10cff0: 53 push %ebx 10cff1: 8b 5d 08 mov 0x8(%ebp),%ebx 10cff4: 8b 75 0c mov 0xc(%ebp),%esi if ( !attr || !attr->is_initialized ) 10cff7: 85 db test %ebx,%ebx 10cff9: 74 06 je 10d001 <== NEVER TAKEN 10cffb: 8b 03 mov (%ebx),%eax 10cffd: 85 c0 test %eax,%eax 10cfff: 75 0f jne 10d010 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; 10d001: b8 16 00 00 00 mov $0x16,%eax attr->prio_ceiling = prioceiling; return 0; } 10d006: 8d 65 f8 lea -0x8(%ebp),%esp 10d009: 5b pop %ebx 10d00a: 5e pop %esi 10d00b: c9 leave 10d00c: c3 ret 10d00d: 8d 76 00 lea 0x0(%esi),%esi ) { if ( !attr || !attr->is_initialized ) return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10d010: 83 ec 0c sub $0xc,%esp 10d013: 56 push %esi 10d014: e8 93 05 00 00 call 10d5ac <_POSIX_Priority_Is_valid> 10d019: 83 c4 10 add $0x10,%esp 10d01c: 84 c0 test %al,%al 10d01e: 74 e1 je 10d001 return EINVAL; attr->prio_ceiling = prioceiling; 10d020: 89 73 08 mov %esi,0x8(%ebx) return 0; 10d023: 31 c0 xor %eax,%eax } 10d025: 8d 65 f8 lea -0x8(%ebp),%esp 10d028: 5b pop %ebx 10d029: 5e pop %esi 10d02a: c9 leave 10d02b: c3 ret =============================================================================== 0010d054 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10d054: 55 push %ebp 10d055: 89 e5 mov %esp,%ebp 10d057: 8b 45 08 mov 0x8(%ebp),%eax 10d05a: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 10d05d: 85 c0 test %eax,%eax 10d05f: 74 0b je 10d06c 10d061: 8b 08 mov (%eax),%ecx 10d063: 85 c9 test %ecx,%ecx 10d065: 74 05 je 10d06c return EINVAL; switch ( pshared ) { 10d067: 83 fa 01 cmp $0x1,%edx 10d06a: 76 08 jbe 10d074 <== ALWAYS TAKEN case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; default: return EINVAL; 10d06c: b8 16 00 00 00 mov $0x16,%eax } } 10d071: c9 leave 10d072: c3 ret 10d073: 90 nop return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10d074: 89 50 04 mov %edx,0x4(%eax) return 0; 10d077: 31 c0 xor %eax,%eax default: return EINVAL; } } 10d079: c9 leave 10d07a: c3 ret =============================================================================== 0010b248 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 10b248: 55 push %ebp 10b249: 89 e5 mov %esp,%ebp 10b24b: 8b 45 08 mov 0x8(%ebp),%eax 10b24e: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 10b251: 85 c0 test %eax,%eax 10b253: 74 0b je 10b260 10b255: 8b 08 mov (%eax),%ecx 10b257: 85 c9 test %ecx,%ecx 10b259: 74 05 je 10b260 <== NEVER TAKEN return EINVAL; switch ( type ) { 10b25b: 83 fa 03 cmp $0x3,%edx 10b25e: 76 08 jbe 10b268 case PTHREAD_MUTEX_DEFAULT: attr->type = type; return 0; default: return EINVAL; 10b260: b8 16 00 00 00 mov $0x16,%eax } } 10b265: c9 leave 10b266: c3 ret 10b267: 90 nop switch ( type ) { case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 10b268: 89 50 10 mov %edx,0x10(%eax) return 0; 10b26b: 31 c0 xor %eax,%eax default: return EINVAL; } } 10b26d: c9 leave 10b26e: c3 ret =============================================================================== 0010bd9c : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10bd9c: 55 push %ebp 10bd9d: 89 e5 mov %esp,%ebp 10bd9f: 57 push %edi 10bda0: 56 push %esi 10bda1: 53 push %ebx 10bda2: 83 ec 1c sub $0x1c,%esp 10bda5: 8b 5d 08 mov 0x8(%ebp),%ebx 10bda8: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10bdab: 85 db test %ebx,%ebx 10bdad: 74 51 je 10be00 10bdaf: 85 f6 test %esi,%esi 10bdb1: 74 4d je 10be00 return EINVAL; if ( !once_control->init_executed ) { 10bdb3: 8b 7b 04 mov 0x4(%ebx),%edi 10bdb6: 85 ff test %edi,%edi 10bdb8: 74 0a je 10bdc4 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10bdba: 31 c0 xor %eax,%eax } 10bdbc: 8d 65 f4 lea -0xc(%ebp),%esp 10bdbf: 5b pop %ebx 10bdc0: 5e pop %esi 10bdc1: 5f pop %edi 10bdc2: c9 leave 10bdc3: c3 ret if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10bdc4: 51 push %ecx 10bdc5: 8d 7d e4 lea -0x1c(%ebp),%edi 10bdc8: 57 push %edi 10bdc9: 68 00 01 00 00 push $0x100 10bdce: 68 00 01 00 00 push $0x100 10bdd3: e8 f4 0b 00 00 call 10c9cc if ( !once_control->init_executed ) { 10bdd8: 83 c4 10 add $0x10,%esp 10bddb: 8b 53 04 mov 0x4(%ebx),%edx 10bdde: 85 d2 test %edx,%edx 10bde0: 74 2e je 10be10 <== ALWAYS TAKEN once_control->is_initialized = true; once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10bde2: 50 push %eax 10bde3: 57 push %edi 10bde4: 68 00 01 00 00 push $0x100 10bde9: ff 75 e4 pushl -0x1c(%ebp) 10bdec: e8 db 0b 00 00 call 10c9cc 10bdf1: 83 c4 10 add $0x10,%esp } return 0; 10bdf4: 31 c0 xor %eax,%eax } 10bdf6: 8d 65 f4 lea -0xc(%ebp),%esp 10bdf9: 5b pop %ebx 10bdfa: 5e pop %esi 10bdfb: 5f pop %edi 10bdfc: c9 leave 10bdfd: c3 ret 10bdfe: 66 90 xchg %ax,%ax pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10be00: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10be05: 8d 65 f4 lea -0xc(%ebp),%esp 10be08: 5b pop %ebx 10be09: 5e pop %esi 10be0a: 5f pop %edi 10be0b: c9 leave 10be0c: c3 ret 10be0d: 8d 76 00 lea 0x0(%esi),%esi if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( !once_control->init_executed ) { once_control->is_initialized = true; 10be10: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10be16: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10be1d: ff d6 call *%esi 10be1f: eb c1 jmp 10bde2 =============================================================================== 0010c480 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 10c480: 55 push %ebp 10c481: 89 e5 mov %esp,%ebp 10c483: 53 push %ebx 10c484: 83 ec 14 sub $0x14,%esp 10c487: 8b 45 08 mov 0x8(%ebp),%eax POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 10c48a: 85 c0 test %eax,%eax 10c48c: 74 42 je 10c4d0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 10c48e: 53 push %ebx return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10c48f: 8d 55 f4 lea -0xc(%ebp),%edx 10c492: 52 push %edx 10c493: ff 30 pushl (%eax) 10c495: 68 80 b1 12 00 push $0x12b180 10c49a: e8 e1 2b 00 00 call 10f080 <_Objects_Get> 10c49f: 89 c3 mov %eax,%ebx switch ( location ) { 10c4a1: 83 c4 10 add $0x10,%esp 10c4a4: 8b 4d f4 mov -0xc(%ebp),%ecx 10c4a7: 85 c9 test %ecx,%ecx 10c4a9: 75 25 jne 10c4d0 case OBJECTS_LOCAL: /* * If there is at least one thread waiting, then do not delete it. */ if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) { 10c4ab: 83 ec 0c sub $0xc,%esp 10c4ae: 8d 40 10 lea 0x10(%eax),%eax 10c4b1: 50 push %eax 10c4b2: e8 81 3e 00 00 call 110338 <_Thread_queue_First> 10c4b7: 83 c4 10 add $0x10,%esp 10c4ba: 85 c0 test %eax,%eax 10c4bc: 74 1e je 10c4dc _Thread_Enable_dispatch(); 10c4be: e8 71 36 00 00 call 10fb34 <_Thread_Enable_dispatch> return EBUSY; 10c4c3: b8 10 00 00 00 mov $0x10,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c4c8: 8b 5d fc mov -0x4(%ebp),%ebx 10c4cb: c9 leave 10c4cc: c3 ret 10c4cd: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return EINVAL; 10c4d0: b8 16 00 00 00 mov $0x16,%eax } 10c4d5: 8b 5d fc mov -0x4(%ebp),%ebx 10c4d8: c9 leave 10c4d9: c3 ret 10c4da: 66 90 xchg %ax,%ax /* * POSIX doesn't require behavior when it is locked. */ _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); 10c4dc: 83 ec 08 sub $0x8,%esp 10c4df: 53 push %ebx 10c4e0: 68 80 b1 12 00 push $0x12b180 10c4e5: e8 5a 27 00 00 call 10ec44 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( POSIX_RWLock_Control *the_RWLock ) { _Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object ); 10c4ea: 58 pop %eax 10c4eb: 5a pop %edx 10c4ec: 53 push %ebx 10c4ed: 68 80 b1 12 00 push $0x12b180 10c4f2: e8 49 2a 00 00 call 10ef40 <_Objects_Free> _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 10c4f7: e8 38 36 00 00 call 10fb34 <_Thread_Enable_dispatch> return 0; 10c4fc: 83 c4 10 add $0x10,%esp 10c4ff: 31 c0 xor %eax,%eax 10c501: eb d2 jmp 10c4d5 =============================================================================== 0010c504 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10c504: 55 push %ebp 10c505: 89 e5 mov %esp,%ebp 10c507: 56 push %esi 10c508: 53 push %ebx 10c509: 83 ec 20 sub $0x20,%esp 10c50c: 8b 5d 08 mov 0x8(%ebp),%ebx 10c50f: 8b 75 0c mov 0xc(%ebp),%esi const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10c512: 85 db test %ebx,%ebx 10c514: 74 15 je 10c52b return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10c516: 85 f6 test %esi,%esi 10c518: 0f 84 8e 00 00 00 je 10c5ac } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10c51e: 8b 16 mov (%esi),%edx 10c520: 85 d2 test %edx,%edx 10c522: 74 07 je 10c52b <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10c524: 8b 46 04 mov 0x4(%esi),%eax 10c527: 85 c0 test %eax,%eax 10c529: 74 0d je 10c538 <== ALWAYS TAKEN case PTHREAD_PROCESS_PRIVATE: /* only supported values */ break; case PTHREAD_PROCESS_SHARED: default: return EINVAL; 10c52b: b8 16 00 00 00 mov $0x16,%eax *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; } 10c530: 8d 65 f8 lea -0x8(%ebp),%esp 10c533: 5b pop %ebx 10c534: 5e pop %esi 10c535: c9 leave 10c536: c3 ret 10c537: 90 nop */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10c538: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c53f: a1 f0 ae 12 00 mov 0x12aef0,%eax 10c544: 40 inc %eax 10c545: a3 f0 ae 12 00 mov %eax,0x12aef0 * 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 ); 10c54a: 83 ec 0c sub $0xc,%esp 10c54d: 68 80 b1 12 00 push $0x12b180 10c552: e8 71 26 00 00 call 10ebc8 <_Objects_Allocate> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10c557: 83 c4 10 add $0x10,%esp 10c55a: 85 c0 test %eax,%eax 10c55c: 74 42 je 10c5a0 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10c55e: 83 ec 08 sub $0x8,%esp 10c561: 8d 55 f4 lea -0xc(%ebp),%edx 10c564: 52 push %edx 10c565: 8d 50 10 lea 0x10(%eax),%edx 10c568: 52 push %edx 10c569: 89 45 e4 mov %eax,-0x1c(%ebp) 10c56c: e8 3f 1e 00 00 call 10e3b0 <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c571: 8b 45 e4 mov -0x1c(%ebp),%eax 10c574: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10c577: 0f b7 f2 movzwl %dx,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c57a: 8b 0d 9c b1 12 00 mov 0x12b19c,%ecx 10c580: 89 04 b1 mov %eax,(%ecx,%esi,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10c583: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10c58a: 89 13 mov %edx,(%ebx) _Thread_Enable_dispatch(); 10c58c: e8 a3 35 00 00 call 10fb34 <_Thread_Enable_dispatch> return 0; 10c591: 83 c4 10 add $0x10,%esp 10c594: 31 c0 xor %eax,%eax } 10c596: 8d 65 f8 lea -0x8(%ebp),%esp 10c599: 5b pop %ebx 10c59a: 5e pop %esi 10c59b: c9 leave 10c59c: c3 ret 10c59d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { _Thread_Enable_dispatch(); 10c5a0: e8 8f 35 00 00 call 10fb34 <_Thread_Enable_dispatch> return EAGAIN; 10c5a5: b8 0b 00 00 00 mov $0xb,%eax 10c5aa: eb 84 jmp 10c530 * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10c5ac: 83 ec 0c sub $0xc,%esp 10c5af: 8d 75 ec lea -0x14(%ebp),%esi 10c5b2: 56 push %esi 10c5b3: e8 84 09 00 00 call 10cf3c 10c5b8: 83 c4 10 add $0x10,%esp 10c5bb: e9 5e ff ff ff jmp 10c51e =============================================================================== 0010c628 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10c628: 55 push %ebp 10c629: 89 e5 mov %esp,%ebp 10c62b: 56 push %esi 10c62c: 53 push %ebx 10c62d: 83 ec 20 sub $0x20,%esp 10c630: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10c633: 85 db test %ebx,%ebx 10c635: 74 7d je 10c6b4 * * 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 ); 10c637: 83 ec 08 sub $0x8,%esp 10c63a: 8d 45 f0 lea -0x10(%ebp),%eax 10c63d: 50 push %eax 10c63e: ff 75 0c pushl 0xc(%ebp) 10c641: e8 ae 62 00 00 call 1128f4 <_POSIX_Absolute_timeout_to_ticks> 10c646: 89 c6 mov %eax,%esi 10c648: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10c64b: 8d 45 f4 lea -0xc(%ebp),%eax 10c64e: 50 push %eax 10c64f: ff 33 pushl (%ebx) 10c651: 68 80 b1 12 00 push $0x12b180 10c656: e8 25 2a 00 00 call 10f080 <_Objects_Get> switch ( location ) { 10c65b: 83 c4 10 add $0x10,%esp 10c65e: 8b 55 f4 mov -0xc(%ebp),%edx 10c661: 85 d2 test %edx,%edx 10c663: 75 4f jne 10c6b4 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, 10c665: 83 fe 03 cmp $0x3,%esi 10c668: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10c66b: 83 ec 0c sub $0xc,%esp 10c66e: 6a 00 push $0x0 10c670: ff 75 f0 pushl -0x10(%ebp) 10c673: 0f b6 ca movzbl %dl,%ecx 10c676: 51 push %ecx 10c677: ff 33 pushl (%ebx) 10c679: 83 c0 10 add $0x10,%eax 10c67c: 50 push %eax 10c67d: 88 55 e4 mov %dl,-0x1c(%ebp) 10c680: e8 5f 1d 00 00 call 10e3e4 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10c685: 83 c4 20 add $0x20,%esp 10c688: e8 a7 34 00 00 call 10fb34 <_Thread_Enable_dispatch> if ( !do_wait ) { 10c68d: 8a 55 e4 mov -0x1c(%ebp),%dl 10c690: 84 d2 test %dl,%dl 10c692: 75 40 jne 10c6d4 if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10c694: a1 d8 b4 12 00 mov 0x12b4d8,%eax 10c699: 8b 40 34 mov 0x34(%eax),%eax 10c69c: 83 f8 02 cmp $0x2,%eax 10c69f: 74 1f je 10c6c0 status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10c6a1: 83 ec 0c sub $0xc,%esp 10c6a4: 50 push %eax 10c6a5: e8 ee 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10c6aa: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10c6ad: 8d 65 f8 lea -0x8(%ebp),%esp 10c6b0: 5b pop %ebx 10c6b1: 5e pop %esi 10c6b2: c9 leave 10c6b3: c3 ret _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10c6b4: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10c6bc: 5b pop %ebx 10c6bd: 5e pop %esi 10c6be: c9 leave 10c6bf: c3 ret ); _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10c6c0: 85 f6 test %esi,%esi 10c6c2: 74 f0 je 10c6b4 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10c6c4: 4e dec %esi 10c6c5: 83 fe 01 cmp $0x1,%esi 10c6c8: 77 d7 ja 10c6a1 <== NEVER TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10c6ca: b8 74 00 00 00 mov $0x74,%eax 10c6cf: eb e8 jmp 10c6b9 10c6d1: 8d 76 00 lea 0x0(%esi),%esi ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait ) { 10c6d4: a1 d8 b4 12 00 mov 0x12b4d8,%eax 10c6d9: 8b 40 34 mov 0x34(%eax),%eax 10c6dc: eb c3 jmp 10c6a1 =============================================================================== 0010c6e0 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10c6e0: 55 push %ebp 10c6e1: 89 e5 mov %esp,%ebp 10c6e3: 56 push %esi 10c6e4: 53 push %ebx 10c6e5: 83 ec 20 sub $0x20,%esp 10c6e8: 8b 5d 08 mov 0x8(%ebp),%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10c6eb: 85 db test %ebx,%ebx 10c6ed: 74 7d je 10c76c * * 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 ); 10c6ef: 83 ec 08 sub $0x8,%esp 10c6f2: 8d 45 f0 lea -0x10(%ebp),%eax 10c6f5: 50 push %eax 10c6f6: ff 75 0c pushl 0xc(%ebp) 10c6f9: e8 f6 61 00 00 call 1128f4 <_POSIX_Absolute_timeout_to_ticks> 10c6fe: 89 c6 mov %eax,%esi 10c700: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10c703: 8d 45 f4 lea -0xc(%ebp),%eax 10c706: 50 push %eax 10c707: ff 33 pushl (%ebx) 10c709: 68 80 b1 12 00 push $0x12b180 10c70e: e8 6d 29 00 00 call 10f080 <_Objects_Get> switch ( location ) { 10c713: 83 c4 10 add $0x10,%esp 10c716: 8b 55 f4 mov -0xc(%ebp),%edx 10c719: 85 d2 test %edx,%edx 10c71b: 75 4f jne 10c76c (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, 10c71d: 83 fe 03 cmp $0x3,%esi 10c720: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10c723: 83 ec 0c sub $0xc,%esp 10c726: 6a 00 push $0x0 10c728: ff 75 f0 pushl -0x10(%ebp) 10c72b: 0f b6 ca movzbl %dl,%ecx 10c72e: 51 push %ecx 10c72f: ff 33 pushl (%ebx) 10c731: 83 c0 10 add $0x10,%eax 10c734: 50 push %eax 10c735: 88 55 e4 mov %dl,-0x1c(%ebp) 10c738: e8 6f 1d 00 00 call 10e4ac <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10c73d: 83 c4 20 add $0x20,%esp 10c740: e8 ef 33 00 00 call 10fb34 <_Thread_Enable_dispatch> if ( !do_wait && 10c745: 8a 55 e4 mov -0x1c(%ebp),%dl 10c748: 84 d2 test %dl,%dl 10c74a: 75 40 jne 10c78c (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10c74c: a1 d8 b4 12 00 mov 0x12b4d8,%eax 10c751: 8b 40 34 mov 0x34(%eax),%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10c754: 83 f8 02 cmp $0x2,%eax 10c757: 74 1f je 10c778 if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10c759: 83 ec 0c sub $0xc,%esp 10c75c: 50 push %eax 10c75d: e8 36 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10c762: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10c765: 8d 65 f8 lea -0x8(%ebp),%esp 10c768: 5b pop %ebx 10c769: 5e pop %esi 10c76a: c9 leave 10c76b: c3 ret _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10c76c: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10c771: 8d 65 f8 lea -0x8(%ebp),%esp 10c774: 5b pop %ebx 10c775: 5e pop %esi 10c776: c9 leave 10c777: c3 ret ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10c778: 85 f6 test %esi,%esi 10c77a: 74 f0 je 10c76c <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10c77c: 4e dec %esi 10c77d: 83 fe 01 cmp $0x1,%esi 10c780: 77 d7 ja 10c759 <== NEVER TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10c782: b8 74 00 00 00 mov $0x74,%eax 10c787: eb e8 jmp 10c771 10c789: 8d 76 00 lea 0x0(%esi),%esi ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10c78c: a1 d8 b4 12 00 mov 0x12b4d8,%eax 10c791: 8b 40 34 mov 0x34(%eax),%eax 10c794: eb c3 jmp 10c759 =============================================================================== 0010cef4 : */ int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { 10cef4: 55 push %ebp 10cef5: 89 e5 mov %esp,%ebp 10cef7: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == false ) 10cefa: 85 c0 test %eax,%eax 10cefc: 74 12 je 10cf10 10cefe: 8b 10 mov (%eax),%edx 10cf00: 85 d2 test %edx,%edx 10cf02: 74 0c je 10cf10 return EINVAL; attr->is_initialized = false; 10cf04: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 10cf0a: 31 c0 xor %eax,%eax } 10cf0c: c9 leave 10cf0d: c3 ret 10cf0e: 66 90 xchg %ax,%ax int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { if ( !attr || attr->is_initialized == false ) return EINVAL; 10cf10: b8 16 00 00 00 mov $0x16,%eax attr->is_initialized = false; return 0; } 10cf15: c9 leave 10cf16: c3 ret =============================================================================== 0010cf60 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10cf60: 55 push %ebp 10cf61: 89 e5 mov %esp,%ebp 10cf63: 8b 45 08 mov 0x8(%ebp),%eax 10cf66: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr ) 10cf69: 85 c0 test %eax,%eax 10cf6b: 74 0b je 10cf78 return EINVAL; if ( !attr->is_initialized ) 10cf6d: 8b 08 mov (%eax),%ecx 10cf6f: 85 c9 test %ecx,%ecx 10cf71: 74 05 je 10cf78 return EINVAL; switch ( pshared ) { 10cf73: 83 fa 01 cmp $0x1,%edx 10cf76: 76 08 jbe 10cf80 <== ALWAYS TAKEN case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; default: return EINVAL; 10cf78: b8 16 00 00 00 mov $0x16,%eax } } 10cf7d: c9 leave 10cf7e: c3 ret 10cf7f: 90 nop return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10cf80: 89 50 04 mov %edx,0x4(%eax) return 0; 10cf83: 31 c0 xor %eax,%eax default: return EINVAL; } } 10cf85: c9 leave 10cf86: c3 ret =============================================================================== 0010b214 : int pthread_setcancelstate( int state, int *oldstate ) { 10b214: 55 push %ebp 10b215: 89 e5 mov %esp,%ebp 10b217: 53 push %ebx 10b218: 83 ec 04 sub $0x4,%esp 10b21b: 8b 55 08 mov 0x8(%ebp),%edx 10b21e: 8b 45 0c mov 0xc(%ebp),%eax * 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() ) 10b221: 8b 0d 54 8e 12 00 mov 0x128e54,%ecx 10b227: 85 c9 test %ecx,%ecx 10b229: 75 15 jne 10b240 return EPROTO; if ( !oldstate ) 10b22b: 85 c0 test %eax,%eax 10b22d: 74 05 je 10b234 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 10b22f: 83 fa 01 cmp $0x1,%edx 10b232: 76 18 jbe 10b24c return EINVAL; 10b234: b8 16 00 00 00 mov $0x16,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b239: 8b 5d fc mov -0x4(%ebp),%ebx 10b23c: c9 leave 10b23d: c3 ret 10b23e: 66 90 xchg %ax,%ax * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) return EPROTO; 10b240: b8 47 00 00 00 mov $0x47,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b245: 8b 5d fc mov -0x4(%ebp),%ebx 10b248: c9 leave 10b249: c3 ret 10b24a: 66 90 xchg %ax,%ax return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b24c: 8b 0d 58 8e 12 00 mov 0x128e58,%ecx 10b252: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b258: 8b 1d 70 88 12 00 mov 0x128870,%ebx 10b25e: 43 inc %ebx 10b25f: 89 1d 70 88 12 00 mov %ebx,0x128870 _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 10b265: 8b 99 d8 00 00 00 mov 0xd8(%ecx),%ebx 10b26b: 89 18 mov %ebx,(%eax) thread_support->cancelability_state = state; 10b26d: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx) _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing); 10b273: 83 ec 0c sub $0xc,%esp 10b276: ff 35 58 8e 12 00 pushl 0x128e58 10b27c: e8 5b 54 00 00 call 1106dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch> /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; 10b281: 83 c4 10 add $0x10,%esp 10b284: 31 c0 xor %eax,%eax } 10b286: 8b 5d fc mov -0x4(%ebp),%ebx 10b289: c9 leave 10b28a: c3 ret =============================================================================== 0010b28c : int pthread_setcanceltype( int type, int *oldtype ) { 10b28c: 55 push %ebp 10b28d: 89 e5 mov %esp,%ebp 10b28f: 53 push %ebx 10b290: 83 ec 04 sub $0x4,%esp 10b293: 8b 55 08 mov 0x8(%ebp),%edx 10b296: 8b 45 0c mov 0xc(%ebp),%eax * 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() ) 10b299: 8b 0d 54 8e 12 00 mov 0x128e54,%ecx 10b29f: 85 c9 test %ecx,%ecx 10b2a1: 75 15 jne 10b2b8 return EPROTO; if ( !oldtype ) 10b2a3: 85 c0 test %eax,%eax 10b2a5: 74 05 je 10b2ac return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 10b2a7: 83 fa 01 cmp $0x1,%edx 10b2aa: 76 18 jbe 10b2c4 return EINVAL; 10b2ac: b8 16 00 00 00 mov $0x16,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b2b1: 8b 5d fc mov -0x4(%ebp),%ebx 10b2b4: c9 leave 10b2b5: c3 ret 10b2b6: 66 90 xchg %ax,%ax * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) return EPROTO; 10b2b8: b8 47 00 00 00 mov $0x47,%eax /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; } 10b2bd: 8b 5d fc mov -0x4(%ebp),%ebx 10b2c0: c9 leave 10b2c1: c3 ret 10b2c2: 66 90 xchg %ax,%ax return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10b2c4: 8b 0d 58 8e 12 00 mov 0x128e58,%ecx 10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b2d0: 8b 1d 70 88 12 00 mov 0x128870,%ebx 10b2d6: 43 inc %ebx 10b2d7: 89 1d 70 88 12 00 mov %ebx,0x128870 _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 10b2dd: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx 10b2e3: 89 18 mov %ebx,(%eax) thread_support->cancelability_type = type; 10b2e5: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx) _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing); 10b2eb: 83 ec 0c sub $0xc,%esp 10b2ee: ff 35 58 8e 12 00 pushl 0x128e58 10b2f4: e8 e3 53 00 00 call 1106dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch> /* * _Thread_Enable_dispatch is invoked by above call. */ return 0; 10b2f9: 83 c4 10 add $0x10,%esp 10b2fc: 31 c0 xor %eax,%eax } 10b2fe: 8b 5d fc mov -0x4(%ebp),%ebx 10b301: c9 leave 10b302: c3 ret =============================================================================== 0010dd14 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10dd14: 55 push %ebp 10dd15: 89 e5 mov %esp,%ebp 10dd17: 57 push %edi 10dd18: 56 push %esi 10dd19: 53 push %ebx 10dd1a: 83 ec 2c sub $0x2c,%esp 10dd1d: 8b 75 10 mov 0x10(%ebp),%esi int rc; /* * Check all the parameters */ if ( !param ) 10dd20: 85 f6 test %esi,%esi 10dd22: 0f 84 cc 00 00 00 je 10ddf4 return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10dd28: 8d 45 e0 lea -0x20(%ebp),%eax 10dd2b: 50 push %eax 10dd2c: 8d 45 e4 lea -0x1c(%ebp),%eax 10dd2f: 50 push %eax 10dd30: 56 push %esi 10dd31: ff 75 0c pushl 0xc(%ebp) 10dd34: e8 f7 5b 00 00 call 113930 <_POSIX_Thread_Translate_sched_param> 10dd39: 89 c3 mov %eax,%ebx policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10dd3b: 83 c4 10 add $0x10,%esp 10dd3e: 85 c0 test %eax,%eax 10dd40: 74 0a je 10dd4c case OBJECTS_ERROR: break; } return ESRCH; } 10dd42: 89 d8 mov %ebx,%eax 10dd44: 8d 65 f4 lea -0xc(%ebp),%esp 10dd47: 5b pop %ebx 10dd48: 5e pop %esi 10dd49: 5f pop %edi 10dd4a: c9 leave 10dd4b: c3 ret 10dd4c: 50 push %eax return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10dd4d: 8d 45 dc lea -0x24(%ebp),%eax 10dd50: 50 push %eax 10dd51: ff 75 08 pushl 0x8(%ebp) 10dd54: 68 60 b8 12 00 push $0x12b860 10dd59: e8 a2 1f 00 00 call 10fd00 <_Objects_Get> 10dd5e: 89 c2 mov %eax,%edx switch ( location ) { 10dd60: 83 c4 10 add $0x10,%esp 10dd63: 8b 7d dc mov -0x24(%ebp),%edi 10dd66: 85 ff test %edi,%edi 10dd68: 0f 85 96 00 00 00 jne 10de04 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10dd6e: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10dd74: 89 45 d4 mov %eax,-0x2c(%ebp) if ( api->schedpolicy == SCHED_SPORADIC ) 10dd77: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax) 10dd7e: 0f 84 cc 00 00 00 je 10de50 (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 10dd84: 8b 45 0c mov 0xc(%ebp),%eax 10dd87: 8b 4d d4 mov -0x2c(%ebp),%ecx 10dd8a: 89 81 84 00 00 00 mov %eax,0x84(%ecx) api->schedparam = *param; 10dd90: 89 cf mov %ecx,%edi 10dd92: 81 c7 88 00 00 00 add $0x88,%edi 10dd98: b9 07 00 00 00 mov $0x7,%ecx 10dd9d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10dd9f: 8b 45 e4 mov -0x1c(%ebp),%eax 10dda2: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10dda5: 8b 45 e0 mov -0x20(%ebp),%eax 10dda8: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10ddae: 8b 75 0c mov 0xc(%ebp),%esi 10ddb1: 85 f6 test %esi,%esi 10ddb3: 78 2e js 10dde3 <== NEVER TAKEN 10ddb5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10ddb9: 7f 59 jg 10de14 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ddbb: a1 60 b5 12 00 mov 0x12b560,%eax 10ddc0: 89 42 78 mov %eax,0x78(%edx) 10ddc3: 0f b6 05 5c 72 12 00 movzbl 0x12725c,%eax 10ddca: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ddcd: 2b 81 88 00 00 00 sub 0x88(%ecx),%eax the_thread->real_priority = 10ddd3: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10ddd6: 51 push %ecx 10ddd7: 6a 01 push $0x1 10ddd9: 50 push %eax 10ddda: 52 push %edx 10dddb: e8 20 25 00 00 call 110300 <_Thread_Change_priority> the_thread, the_thread->real_priority, true ); break; 10dde0: 83 c4 10 add $0x10,%esp _Watchdog_Remove( &api->Sporadic_timer ); _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); 10dde3: e8 cc 29 00 00 call 1107b4 <_Thread_Enable_dispatch> case OBJECTS_ERROR: break; } return ESRCH; } 10dde8: 89 d8 mov %ebx,%eax 10ddea: 8d 65 f4 lea -0xc(%ebp),%esp 10dded: 5b pop %ebx 10ddee: 5e pop %esi 10ddef: 5f pop %edi 10ddf0: c9 leave 10ddf1: c3 ret 10ddf2: 66 90 xchg %ax,%ax /* * Check all the parameters */ if ( !param ) return EINVAL; 10ddf4: bb 16 00 00 00 mov $0x16,%ebx case OBJECTS_ERROR: break; } return ESRCH; } 10ddf9: 89 d8 mov %ebx,%eax 10ddfb: 8d 65 f4 lea -0xc(%ebp),%esp 10ddfe: 5b pop %ebx 10ddff: 5e pop %esi 10de00: 5f pop %edi 10de01: c9 leave 10de02: c3 ret 10de03: 90 nop #endif case OBJECTS_ERROR: break; } return ESRCH; 10de04: bb 03 00 00 00 mov $0x3,%ebx } 10de09: 89 d8 mov %ebx,%eax 10de0b: 8d 65 f4 lea -0xc(%ebp),%esp 10de0e: 5b pop %ebx 10de0f: 5e pop %esi 10de10: 5f pop %edi 10de11: c9 leave 10de12: c3 ret 10de13: 90 nop api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 10de14: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10de18: 75 c9 jne 10dde3 <== NEVER TAKEN true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10de1a: 8b 4d d4 mov -0x2c(%ebp),%ecx 10de1d: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax 10de23: 89 81 a4 00 00 00 mov %eax,0xa4(%ecx) _Watchdog_Remove( &api->Sporadic_timer ); 10de29: 83 ec 0c sub $0xc,%esp 10de2c: 89 c8 mov %ecx,%eax 10de2e: 05 a8 00 00 00 add $0xa8,%eax 10de33: 50 push %eax 10de34: 89 55 d0 mov %edx,-0x30(%ebp) 10de37: e8 10 3a 00 00 call 11184c <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10de3c: 58 pop %eax 10de3d: 5a pop %edx 10de3e: 8b 55 d0 mov -0x30(%ebp),%edx 10de41: 52 push %edx 10de42: 6a 00 push $0x0 10de44: e8 af fd ff ff call 10dbf8 <_POSIX_Threads_Sporadic_budget_TSR> break; 10de49: 83 c4 10 add $0x10,%esp 10de4c: eb 95 jmp 10dde3 10de4e: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 10de50: 83 ec 0c sub $0xc,%esp 10de53: 05 a8 00 00 00 add $0xa8,%eax 10de58: 50 push %eax 10de59: 89 55 d0 mov %edx,-0x30(%ebp) 10de5c: e8 eb 39 00 00 call 11184c <_Watchdog_Remove> 10de61: 83 c4 10 add $0x10,%esp 10de64: 8b 55 d0 mov -0x30(%ebp),%edx 10de67: e9 18 ff ff ff jmp 10dd84 =============================================================================== 00111cf4 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 111cf4: 55 push %ebp 111cf5: 89 e5 mov %esp,%ebp 111cf7: 56 push %esi 111cf8: 53 push %ebx 111cf9: 8b 4d 08 mov 0x8(%ebp),%ecx 111cfc: 8b 55 0c mov 0xc(%ebp),%edx 111cff: 8b 5d 10 mov 0x10(%ebp),%ebx POSIX_API_Control *api; if ( !set && !oset ) 111d02: 85 d2 test %edx,%edx 111d04: 0f 84 8a 00 00 00 je 111d94 rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 111d0a: a1 78 8b 12 00 mov 0x128b78,%eax 111d0f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax if ( oset ) 111d15: 85 db test %ebx,%ebx 111d17: 74 0c je 111d25 *oset = api->signals_blocked; 111d19: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi 111d1f: 89 33 mov %esi,(%ebx) if ( !set ) 111d21: 85 d2 test %edx,%edx 111d23: 74 3b je 111d60 return 0; switch ( how ) { 111d25: 83 f9 01 cmp $0x1,%ecx 111d28: 74 5e je 111d88 111d2a: 83 f9 02 cmp $0x2,%ecx 111d2d: 74 39 je 111d68 111d2f: 85 c9 test %ecx,%ecx 111d31: 75 41 jne 111d74 break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; break; case SIG_SETMASK: api->signals_blocked = *set; 111d33: 8b 12 mov (%edx),%edx 111d35: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { 111d3b: 8b 15 e8 8d 12 00 mov 0x128de8,%edx 111d41: 0b 90 d4 00 00 00 or 0xd4(%eax),%edx /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & 111d47: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 111d4d: f7 d0 not %eax 111d4f: 85 c2 test %eax,%edx 111d51: 74 0d je 111d60 (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); 111d53: e8 1c c9 ff ff call 10e674 <_Thread_Dispatch> } return 0; 111d58: 31 c0 xor %eax,%eax } 111d5a: 5b pop %ebx 111d5b: 5e pop %esi 111d5c: c9 leave 111d5d: c3 ret 111d5e: 66 90 xchg %ax,%ax if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); } return 0; 111d60: 31 c0 xor %eax,%eax } 111d62: 5b pop %ebx 111d63: 5e pop %esi 111d64: c9 leave 111d65: c3 ret 111d66: 66 90 xchg %ax,%ax switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 111d68: 8b 12 mov (%edx),%edx 111d6a: f7 d2 not %edx 111d6c: 21 90 d0 00 00 00 and %edx,0xd0(%eax) break; 111d72: eb c7 jmp 111d3b case SIG_SETMASK: api->signals_blocked = *set; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 111d74: e8 a7 25 00 00 call 114320 <__errno> 111d79: c7 00 16 00 00 00 movl $0x16,(%eax) 111d7f: b8 ff ff ff ff mov $0xffffffff,%eax (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Dispatch(); } return 0; } 111d84: 5b pop %ebx 111d85: 5e pop %esi 111d86: c9 leave 111d87: c3 ret if ( !set ) return 0; switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; 111d88: 8b 12 mov (%edx),%edx 111d8a: 09 90 d0 00 00 00 or %edx,0xd0(%eax) break; 111d90: eb a9 jmp 111d3b 111d92: 66 90 xchg %ax,%ax sigset_t *oset ) { POSIX_API_Control *api; if ( !set && !oset ) 111d94: 85 db test %ebx,%ebx 111d96: 74 dc je 111d74 rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 111d98: a1 78 8b 12 00 mov 0x128b78,%eax 111d9d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 111da3: e9 71 ff ff ff jmp 111d19 =============================================================================== 0010bb84 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10bb84: 55 push %ebp 10bb85: 89 e5 mov %esp,%ebp 10bb87: 83 ec 08 sub $0x8,%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() ) 10bb8a: 8b 0d f4 95 12 00 mov 0x1295f4,%ecx 10bb90: 85 c9 test %ecx,%ecx 10bb92: 75 44 jne 10bbd8 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10bb94: a1 f8 95 12 00 mov 0x1295f8,%eax 10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10bb9f: 8b 15 10 90 12 00 mov 0x129010,%edx 10bba5: 42 inc %edx 10bba6: 89 15 10 90 12 00 mov %edx,0x129010 _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10bbac: 8b 90 d8 00 00 00 mov 0xd8(%eax),%edx 10bbb2: 85 d2 test %edx,%edx 10bbb4: 75 26 jne 10bbdc <== NEVER TAKEN 10bbb6: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10bbbc: 85 c0 test %eax,%eax 10bbbe: 74 1c je 10bbdc thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10bbc0: e8 c3 28 00 00 call 10e488 <_Thread_Enable_dispatch> if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10bbc5: 83 ec 08 sub $0x8,%esp 10bbc8: 6a ff push $0xffffffff 10bbca: ff 35 f8 95 12 00 pushl 0x1295f8 10bbd0: e8 53 5b 00 00 call 111728 <_POSIX_Thread_Exit> 10bbd5: 83 c4 10 add $0x10,%esp } 10bbd8: c9 leave 10bbd9: c3 ret 10bbda: 66 90 xchg %ax,%ax 10bbdc: c9 leave _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10bbdd: e9 a6 28 00 00 jmp 10e488 <_Thread_Enable_dispatch> =============================================================================== 0010c50c : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10c50c: 55 push %ebp 10c50d: 89 e5 mov %esp,%ebp 10c50f: 57 push %edi 10c510: 56 push %esi 10c511: 53 push %ebx 10c512: 83 ec 58 sub $0x58,%esp 10c515: 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); 10c518: 68 80 a1 12 00 push $0x12a180 10c51d: e8 7e 09 00 00 call 10cea0 10c522: 89 c6 mov %eax,%esi if (result != 0) { 10c524: 83 c4 10 add $0x10,%esp 10c527: 85 c0 test %eax,%eax 10c529: 0f 85 c1 00 00 00 jne 10c5f0 <== NEVER TAKEN 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); 10c52f: e8 1c 12 00 00 call 10d750 10c534: 51 push %ecx 10c535: 8d 55 c4 lea -0x3c(%ebp),%edx 10c538: 52 push %edx 10c539: 8d 55 e0 lea -0x20(%ebp),%edx 10c53c: 52 push %edx 10c53d: 50 push %eax 10c53e: e8 d9 0d 00 00 call 10d31c req->caller_thread = pthread_self (); 10c543: e8 08 12 00 00 call 10d750 10c548: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10c54b: 8b 43 14 mov 0x14(%ebx),%eax 10c54e: 8b 55 c4 mov -0x3c(%ebp),%edx 10c551: 2b 50 14 sub 0x14(%eax),%edx 10c554: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10c557: 8b 55 e0 mov -0x20(%ebp),%edx 10c55a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10c55d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10c564: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10c56b: 83 c4 10 add $0x10,%esp 10c56e: 8b 15 e8 a1 12 00 mov 0x12a1e8,%edx 10c574: 85 d2 test %edx,%edx 10c576: 75 0d jne 10c585 10c578: 83 3d e4 a1 12 00 04 cmpl $0x4,0x12a1e4 10c57f: 0f 8e 83 00 00 00 jle 10c608 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, 10c585: 51 push %ecx 10c586: 6a 00 push $0x0 10c588: ff 30 pushl (%eax) 10c58a: 68 c8 a1 12 00 push $0x12a1c8 10c58f: e8 44 fb ff ff call 10c0d8 10c594: 89 c7 mov %eax,%edi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10c596: 83 c4 10 add $0x10,%esp 10c599: 85 c0 test %eax,%eax 10c59b: 0f 84 df 00 00 00 je 10c680 { pthread_mutex_lock (&r_chain->mutex); 10c5a1: 8d 57 1c lea 0x1c(%edi),%edx 10c5a4: 83 ec 0c sub $0xc,%esp 10c5a7: 52 push %edx 10c5a8: 89 55 b4 mov %edx,-0x4c(%ebp) 10c5ab: e8 f0 08 00 00 call 10cea0 rtems_aio_insert_prio (&r_chain->perfd, req); 10c5b0: 58 pop %eax 10c5b1: 5a pop %edx 10c5b2: 53 push %ebx 10c5b3: 8d 47 08 lea 0x8(%edi),%eax 10c5b6: 50 push %eax 10c5b7: e8 48 fe ff ff call 10c404 pthread_cond_signal (&r_chain->cond); 10c5bc: 83 c7 20 add $0x20,%edi 10c5bf: 89 3c 24 mov %edi,(%esp) 10c5c2: e8 a9 04 00 00 call 10ca70 pthread_mutex_unlock (&r_chain->mutex); 10c5c7: 8b 55 b4 mov -0x4c(%ebp),%edx 10c5ca: 89 14 24 mov %edx,(%esp) 10c5cd: e8 56 09 00 00 call 10cf28 10c5d2: 83 c4 10 add $0x10,%esp /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); } } pthread_mutex_unlock (&aio_request_queue.mutex); 10c5d5: 83 ec 0c sub $0xc,%esp 10c5d8: 68 80 a1 12 00 push $0x12a180 10c5dd: e8 46 09 00 00 call 10cf28 return 0; 10c5e2: 83 c4 10 add $0x10,%esp } 10c5e5: 89 f0 mov %esi,%eax 10c5e7: 8d 65 f4 lea -0xc(%ebp),%esp 10c5ea: 5b pop %ebx 10c5eb: 5e pop %esi 10c5ec: 5f pop %edi 10c5ed: c9 leave 10c5ee: c3 ret 10c5ef: 90 nop /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); if (result != 0) { free (req); 10c5f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c5f3: 53 push %ebx <== NOT EXECUTED 10c5f4: e8 3b c5 ff ff call 108b34 <== NOT EXECUTED return result; 10c5f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } pthread_mutex_unlock (&aio_request_queue.mutex); return 0; } 10c5fc: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c5fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c601: 5b pop %ebx <== NOT EXECUTED 10c602: 5e pop %esi <== NOT EXECUTED 10c603: 5f pop %edi <== NOT EXECUTED 10c604: c9 leave <== NOT EXECUTED 10c605: c3 ret <== NOT EXECUTED 10c606: 66 90 xchg %ax,%ax <== NOT EXECUTED if ((aio_request_queue.idle_threads == 0) && 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); 10c608: 57 push %edi 10c609: 6a 01 push $0x1 10c60b: ff 30 pushl (%eax) 10c60d: 68 c8 a1 12 00 push $0x12a1c8 10c612: e8 c1 fa ff ff call 10c0d8 10c617: 89 c7 mov %eax,%edi if (r_chain->new_fd == 1) { 10c619: 83 c4 10 add $0x10,%esp 10c61c: 83 78 18 01 cmpl $0x1,0x18(%eax) 10c620: 0f 85 7b ff ff ff jne 10c5a1 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10c626: 83 ec 08 sub $0x8,%esp 10c629: 53 push %ebx 10c62a: 8d 40 08 lea 0x8(%eax),%eax 10c62d: 50 push %eax 10c62e: e8 7d 22 00 00 call 10e8b0 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10c633: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) pthread_mutex_init (&r_chain->mutex, NULL); 10c63a: 5a pop %edx 10c63b: 59 pop %ecx 10c63c: 6a 00 push $0x0 10c63e: 8d 47 1c lea 0x1c(%edi),%eax 10c641: 50 push %eax 10c642: e8 0d 07 00 00 call 10cd54 pthread_cond_init (&r_chain->cond, NULL); 10c647: 5b pop %ebx 10c648: 58 pop %eax 10c649: 6a 00 push $0x0 10c64b: 8d 47 20 lea 0x20(%edi),%eax 10c64e: 50 push %eax 10c64f: e8 68 03 00 00 call 10c9bc AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10c654: 57 push %edi 10c655: 68 98 c1 10 00 push $0x10c198 10c65a: 68 88 a1 12 00 push $0x12a188 10c65f: 8d 45 e4 lea -0x1c(%ebp),%eax 10c662: 50 push %eax 10c663: e8 2c 0a 00 00 call 10d094 10c668: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10c66a: 83 c4 20 add $0x20,%esp 10c66d: 85 c0 test %eax,%eax 10c66f: 0f 85 87 00 00 00 jne 10c6fc <== NEVER TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads; 10c675: ff 05 e4 a1 12 00 incl 0x12a1e4 10c67b: e9 55 ff ff ff jmp 10c5d5 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10c680: 51 push %ecx 10c681: 6a 01 push $0x1 10c683: 8b 43 14 mov 0x14(%ebx),%eax 10c686: ff 30 pushl (%eax) 10c688: 68 d4 a1 12 00 push $0x12a1d4 10c68d: e8 46 fa ff ff call 10c0d8 10c692: 89 c7 mov %eax,%edi if (r_chain->new_fd == 1) { 10c694: 83 c4 10 add $0x10,%esp 10c697: 83 78 18 01 cmpl $0x1,0x18(%eax) 10c69b: 74 17 je 10c6b4 pthread_cond_init (&r_chain->cond, NULL); pthread_cond_signal (&aio_request_queue.new_req); ++aio_request_queue.idle_threads; } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10c69d: 83 ec 08 sub $0x8,%esp 10c6a0: 53 push %ebx 10c6a1: 83 c7 08 add $0x8,%edi 10c6a4: 57 push %edi 10c6a5: e8 5a fd ff ff call 10c404 10c6aa: 83 c4 10 add $0x10,%esp 10c6ad: e9 23 ff ff ff jmp 10c5d5 10c6b2: 66 90 xchg %ax,%ax 10c6b4: 83 ec 08 sub $0x8,%esp 10c6b7: 53 push %ebx 10c6b8: 8d 40 08 lea 0x8(%eax),%eax 10c6bb: 50 push %eax 10c6bc: e8 ef 21 00 00 call 10e8b0 <_Chain_Insert> if (r_chain->new_fd == 1) { /* 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; 10c6c1: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) pthread_mutex_init (&r_chain->mutex, NULL); 10c6c8: 58 pop %eax 10c6c9: 5a pop %edx 10c6ca: 6a 00 push $0x0 10c6cc: 8d 47 1c lea 0x1c(%edi),%eax 10c6cf: 50 push %eax 10c6d0: e8 7f 06 00 00 call 10cd54 pthread_cond_init (&r_chain->cond, NULL); 10c6d5: 59 pop %ecx 10c6d6: 5b pop %ebx 10c6d7: 6a 00 push $0x0 10c6d9: 83 c7 20 add $0x20,%edi 10c6dc: 57 push %edi 10c6dd: e8 da 02 00 00 call 10c9bc pthread_cond_signal (&aio_request_queue.new_req); 10c6e2: c7 04 24 84 a1 12 00 movl $0x12a184,(%esp) 10c6e9: e8 82 03 00 00 call 10ca70 ++aio_request_queue.idle_threads; 10c6ee: ff 05 e8 a1 12 00 incl 0x12a1e8 10c6f4: 83 c4 10 add $0x10,%esp 10c6f7: e9 d9 fe ff ff jmp 10c5d5 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, rtems_aio_handle, (void *) r_chain); if (result != 0) { pthread_mutex_unlock (&aio_request_queue.mutex); 10c6fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c6ff: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c704: e8 1f 08 00 00 call 10cf28 <== NOT EXECUTED return result; 10c709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c70c: 89 de mov %ebx,%esi <== NOT EXECUTED 10c70e: e9 d2 fe ff ff jmp 10c5e5 <== NOT EXECUTED =============================================================================== 0010c198 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10c198: 55 push %ebp <== NOT EXECUTED 10c199: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c19b: 57 push %edi <== NOT EXECUTED 10c19c: 56 push %esi <== NOT EXECUTED 10c19d: 53 push %ebx <== NOT EXECUTED 10c19e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED rtems_aio_request_chain *r_chain = arg; 10c1a1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c1a4: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10c1a7: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED 10c1aa: 66 90 xchg %ax,%ax <== 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); 10c1ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c1af: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c1b2: e8 e9 0c 00 00 call 10cea0 <== NOT EXECUTED if (result != 0) 10c1b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10c1bc: 0f 85 92 01 00 00 jne 10c354 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c1c2: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c1c5: 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)) { 10c1c8: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10c1ca: 0f 84 d0 00 00 00 je 10c2a0 <== 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); 10c1d0: e8 7b 15 00 00 call 10d750 <== NOT EXECUTED 10c1d5: 52 push %edx <== NOT EXECUTED 10c1d6: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10c1d9: 52 push %edx <== NOT EXECUTED 10c1da: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 10c1dd: 52 push %edx <== NOT EXECUTED 10c1de: 50 push %eax <== NOT EXECUTED 10c1df: e8 38 11 00 00 call 10d31c <== NOT EXECUTED param.sched_priority = req->priority; 10c1e4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10c1e7: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED pthread_setschedparam (pthread_self(), req->policy, ¶m); 10c1ea: 8b 7e 08 mov 0x8(%esi),%edi <== NOT EXECUTED 10c1ed: e8 5e 15 00 00 call 10d750 <== NOT EXECUTED 10c1f2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c1f5: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10c1f8: 52 push %edx <== NOT EXECUTED 10c1f9: 57 push %edi <== NOT EXECUTED 10c1fa: 50 push %eax <== NOT EXECUTED 10c1fb: e8 60 15 00 00 call 10d760 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10c200: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c203: e8 6c 26 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10c208: 5f pop %edi <== NOT EXECUTED 10c209: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c20c: e8 17 0d 00 00 call 10cf28 <== NOT EXECUTED switch (req->aiocbp->aio_lio_opcode) { 10c211: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED 10c214: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c217: 8b 47 2c mov 0x2c(%edi),%eax <== NOT EXECUTED 10c21a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c21d: 74 21 je 10c240 <== NOT EXECUTED 10c21f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c222: 74 6c je 10c290 <== NOT EXECUTED 10c224: 48 dec %eax <== NOT EXECUTED 10c225: 74 4d je 10c274 <== NOT EXECUTED default: result = -1; } if (result == -1) { req->aiocbp->return_value = -1; 10c227: c7 47 34 ff ff ff ff movl $0xffffffff,0x34(%edi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10c22e: e8 c9 99 00 00 call 115bfc <__errno> <== NOT EXECUTED 10c233: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10c235: 89 47 30 mov %eax,0x30(%edi) <== NOT EXECUTED 10c238: e9 6f ff ff ff jmp 10c1ac <== NOT EXECUTED 10c23d: 8d 76 00 lea 0x0(%esi),%esi <== 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, 10c240: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c243: ff 77 08 pushl 0x8(%edi) <== NOT EXECUTED 10c246: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 10c249: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10c24c: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED 10c24f: ff 37 pushl (%edi) <== NOT EXECUTED 10c251: e8 3e a4 00 00 call 116694 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10c256: 83 c4 20 add $0x20,%esp <== NOT EXECUTED break; default: result = -1; } if (result == -1) { 10c259: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c25c: 0f 84 9a 01 00 00 je 10c3fc <== NOT EXECUTED req->aiocbp->return_value = -1; req->aiocbp->error_code = errno; } else { req->aiocbp->return_value = result; 10c262: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED 10c265: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED req->aiocbp->error_code = 0; 10c268: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED 10c26f: e9 38 ff ff ff jmp 10c1ac <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); switch (req->aiocbp->aio_lio_opcode) { case LIO_READ: result = pread (req->aiocbp->aio_fildes, 10c274: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c277: ff 77 08 pushl 0x8(%edi) <== NOT EXECUTED 10c27a: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 10c27d: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10c280: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED 10c283: ff 37 pushl (%edi) <== NOT EXECUTED 10c285: e8 56 a3 00 00 call 1165e0 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10c28a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10c28d: eb ca jmp 10c259 <== NOT EXECUTED 10c28f: 90 nop <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_SYNC: result = fsync (req->aiocbp->aio_fildes); 10c290: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c293: ff 37 pushl (%edi) <== NOT EXECUTED 10c295: e8 0a 67 00 00 call 1129a4 <== NOT EXECUTED break; 10c29a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c29d: eb ba jmp 10c259 <== NOT EXECUTED 10c29f: 90 nop <== 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); 10c2a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2a3: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c2a6: e8 7d 0c 00 00 call 10cf28 <== NOT EXECUTED pthread_mutex_lock (&aio_request_queue.mutex); 10c2ab: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) <== NOT EXECUTED 10c2b2: e8 e9 0b 00 00 call 10cea0 <== NOT EXECUTED if (rtems_chain_is_empty (chain)) 10c2b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c2ba: 3b 73 08 cmp 0x8(%ebx),%esi <== NOT EXECUTED 10c2bd: 0f 85 e9 fe ff ff jne 10c1ac <== NOT EXECUTED { clock_gettime (CLOCK_REALTIME, &timeout); 10c2c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c2c6: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10c2c9: 50 push %eax <== NOT EXECUTED 10c2ca: 6a 01 push $0x1 <== NOT EXECUTED 10c2cc: e8 b3 05 00 00 call 10c884 <== NOT EXECUTED timeout.tv_sec += 3; 10c2d1: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10c2d5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&r_chain->cond, 10c2dc: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10c2df: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c2e2: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10c2e5: 52 push %edx <== NOT EXECUTED 10c2e6: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c2eb: 56 push %esi <== NOT EXECUTED 10c2ec: e8 03 08 00 00 call 10caf4 <== 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) { 10c2f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c2f4: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10c2f7: 0f 85 af fe ff ff jne 10c1ac <== NOT EXECUTED 10c2fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c300: 53 push %ebx <== NOT EXECUTED 10c301: e8 6e 25 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10c306: 59 pop %ecx <== NOT EXECUTED 10c307: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 10c30a: e8 25 09 00 00 call 10cc34 <== NOT EXECUTED pthread_cond_destroy (&r_chain->cond); 10c30f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c312: e8 d9 05 00 00 call 10c8f0 <== NOT EXECUTED free (r_chain); 10c317: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c31a: e8 15 c8 ff ff call 108b34 <== 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)) { 10c31f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c322: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 <== NOT EXECUTED 10c329: a1 12 00 10c32c: 74 30 je 10c35e <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; } 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); 10c32e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c331: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c336: e8 ed 0b 00 00 call 10cf28 <== NOT EXECUTED 10c33b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c33e: e9 69 fe ff ff jmp 10c1ac <== NOT EXECUTED &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { pthread_mutex_unlock (&aio_request_queue.mutex); 10c343: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c346: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c34b: e8 d8 0b 00 00 call 10cf28 <== NOT EXECUTED return NULL; 10c350: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c353: 90 nop <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c354: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c356: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c359: 5b pop %ebx <== NOT EXECUTED 10c35a: 5e pop %esi <== NOT EXECUTED 10c35b: 5f pop %edi <== NOT EXECUTED 10c35c: c9 leave <== NOT EXECUTED 10c35d: c3 ret <== NOT EXECUTED free (r_chain); /* 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)) { ++aio_request_queue.idle_threads; 10c35e: ff 05 e8 a1 12 00 incl 0x12a1e8 <== NOT EXECUTED clock_gettime (CLOCK_REALTIME, &timeout); 10c364: 52 push %edx <== NOT EXECUTED 10c365: 52 push %edx <== NOT EXECUTED 10c366: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10c369: 50 push %eax <== NOT EXECUTED 10c36a: 6a 01 push $0x1 <== NOT EXECUTED 10c36c: e8 13 05 00 00 call 10c884 <== NOT EXECUTED timeout.tv_sec += 3; 10c371: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10c375: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&aio_request_queue.new_req, 10c37c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c37f: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10c382: 52 push %edx <== NOT EXECUTED 10c383: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c388: 68 84 a1 12 00 push $0x12a184 <== NOT EXECUTED 10c38d: e8 62 07 00 00 call 10caf4 <== 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) { 10c392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c395: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10c398: 74 a9 je 10c343 <== NOT EXECUTED return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; 10c39a: ff 0d e8 a1 12 00 decl 0x12a1e8 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c3a0: 8b 35 d4 a1 12 00 mov 0x12a1d4,%esi <== NOT EXECUTED 10c3a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c3a9: 56 push %esi <== NOT EXECUTED 10c3aa: e8 c5 24 00 00 call 10e874 <_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, 10c3af: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c3b2: 6a 01 push $0x1 <== NOT EXECUTED 10c3b4: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10c3b7: 68 c8 a1 12 00 push $0x12a1c8 <== NOT EXECUTED 10c3bc: e8 17 fd ff ff call 10c0d8 <== NOT EXECUTED 10c3c1: 89 c3 mov %eax,%ebx <== NOT EXECUTED ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; 10c3c3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED pthread_mutex_init (&r_chain->mutex, NULL); 10c3ca: 5f pop %edi <== NOT EXECUTED 10c3cb: 58 pop %eax <== NOT EXECUTED 10c3cc: 6a 00 push $0x0 <== NOT EXECUTED 10c3ce: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10c3d1: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED 10c3d4: 50 push %eax <== NOT EXECUTED 10c3d5: e8 7a 09 00 00 call 10cd54 <== NOT EXECUTED pthread_cond_init (&r_chain->cond, NULL); 10c3da: 5a pop %edx <== NOT EXECUTED 10c3db: 59 pop %ecx <== NOT EXECUTED 10c3dc: 6a 00 push $0x0 <== NOT EXECUTED 10c3de: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10c3e1: 50 push %eax <== NOT EXECUTED 10c3e2: e8 d5 05 00 00 call 10c9bc <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; 10c3e7: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED 10c3ea: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10c3ed: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10c3f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10c3f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c3f7: e9 b0 fd ff ff jmp 10c1ac <== NOT EXECUTED break; default: result = -1; } if (result == -1) { 10c3fc: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED 10c3ff: e9 23 fe ff ff jmp 10c227 <== NOT EXECUTED =============================================================================== 0010bfb0 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10bfb0: 55 push %ebp 10bfb1: 89 e5 mov %esp,%ebp 10bfb3: 53 push %ebx 10bfb4: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10bfb7: 68 88 a1 12 00 push $0x12a188 10bfbc: e8 7f 10 00 00 call 10d040 10bfc1: 89 c3 mov %eax,%ebx if (result != 0) 10bfc3: 83 c4 10 add $0x10,%esp 10bfc6: 85 c0 test %eax,%eax 10bfc8: 74 0a je 10bfd4 <== ALWAYS TAKEN aio_request_queue.active_threads = 0; aio_request_queue.idle_threads = 0; aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; return result; } 10bfca: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bfcc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bfcf: c9 leave <== NOT EXECUTED 10bfd0: c3 ret <== NOT EXECUTED 10bfd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED result = pthread_attr_init (&aio_request_queue.attr); if (result != 0) return result; result = 10bfd4: 83 ec 08 sub $0x8,%esp 10bfd7: 6a 00 push $0x0 10bfd9: 68 88 a1 12 00 push $0x12a188 10bfde: e8 89 10 00 00 call 10d06c pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10bfe3: 83 c4 10 add $0x10,%esp 10bfe6: 85 c0 test %eax,%eax 10bfe8: 0f 85 96 00 00 00 jne 10c084 <== NEVER TAKEN pthread_attr_destroy (&aio_request_queue.attr); result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10bfee: 83 ec 08 sub $0x8,%esp 10bff1: 6a 00 push $0x0 10bff3: 68 80 a1 12 00 push $0x12a180 10bff8: e8 57 0d 00 00 call 10cd54 if (result != 0) 10bffd: 83 c4 10 add $0x10,%esp 10c000: 85 c0 test %eax,%eax 10c002: 0f 85 b8 00 00 00 jne 10c0c0 <== NEVER TAKEN pthread_attr_destroy (&aio_request_queue.attr); result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10c008: 83 ec 08 sub $0x8,%esp 10c00b: 6a 00 push $0x0 10c00d: 68 84 a1 12 00 push $0x12a184 10c012: e8 a5 09 00 00 call 10c9bc 10c017: 89 c3 mov %eax,%ebx if (result != 0) { 10c019: 83 c4 10 add $0x10,%esp 10c01c: 85 c0 test %eax,%eax 10c01e: 75 7c jne 10c09c <== NEVER TAKEN ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c020: c7 05 c8 a1 12 00 cc movl $0x12a1cc,0x12a1c8 10c027: a1 12 00 head->previous = NULL; 10c02a: c7 05 cc a1 12 00 00 movl $0x0,0x12a1cc 10c031: 00 00 00 tail->previous = head; 10c034: c7 05 d0 a1 12 00 c8 movl $0x12a1c8,0x12a1d0 10c03b: a1 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c03e: c7 05 d4 a1 12 00 d8 movl $0x12a1d8,0x12a1d4 10c045: a1 12 00 head->previous = NULL; 10c048: c7 05 d8 a1 12 00 00 movl $0x0,0x12a1d8 10c04f: 00 00 00 tail->previous = head; 10c052: c7 05 dc a1 12 00 d4 movl $0x12a1d4,0x12a1dc 10c059: a1 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; 10c05c: c7 05 e4 a1 12 00 00 movl $0x0,0x12a1e4 10c063: 00 00 00 aio_request_queue.idle_threads = 0; 10c066: c7 05 e8 a1 12 00 00 movl $0x0,0x12a1e8 10c06d: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10c070: c7 05 e0 a1 12 00 0b movl $0xb00b,0x12a1e0 10c077: b0 00 00 return result; } 10c07a: 89 d8 mov %ebx,%eax 10c07c: 8b 5d fc mov -0x4(%ebp),%ebx 10c07f: c9 leave 10c080: c3 ret 10c081: 8d 76 00 lea 0x0(%esi),%esi result = pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) pthread_attr_destroy (&aio_request_queue.attr); 10c084: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c087: 68 88 a1 12 00 push $0x12a188 <== NOT EXECUTED 10c08c: e8 8b 0f 00 00 call 10d01c <== NOT EXECUTED 10c091: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c094: e9 55 ff ff ff jmp 10bfee <== NOT EXECUTED 10c099: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); result = pthread_cond_init (&aio_request_queue.new_req, NULL); if (result != 0) { pthread_mutex_destroy (&aio_request_queue.mutex); 10c09c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c09f: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED 10c0a4: e8 8b 0b 00 00 call 10cc34 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10c0a9: c7 04 24 88 a1 12 00 movl $0x12a188,(%esp) <== NOT EXECUTED 10c0b0: e8 67 0f 00 00 call 10d01c <== NOT EXECUTED 10c0b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0b8: e9 63 ff ff ff jmp 10c020 <== NOT EXECUTED 10c0bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); result = pthread_mutex_init (&aio_request_queue.mutex, NULL); if (result != 0) pthread_attr_destroy (&aio_request_queue.attr); 10c0c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0c3: 68 88 a1 12 00 push $0x12a188 <== NOT EXECUTED 10c0c8: e8 4f 0f 00 00 call 10d01c <== NOT EXECUTED 10c0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0d0: e9 33 ff ff ff jmp 10c008 <== NOT EXECUTED =============================================================================== 0010c404 : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10c404: 55 push %ebp 10c405: 89 e5 mov %esp,%ebp 10c407: 56 push %esi 10c408: 53 push %ebx 10c409: 8b 55 08 mov 0x8(%ebp),%edx 10c40c: 8b 75 0c mov 0xc(%ebp),%esi } AIO_printf ("Thread finished\n"); return NULL; } 10c40f: 8b 02 mov (%edx),%eax 10c411: 8d 4a 04 lea 0x4(%edx),%ecx rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 10c414: 39 c8 cmp %ecx,%eax 10c416: 74 27 je 10c43f <== NEVER TAKEN 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 && 10c418: 8b 56 14 mov 0x14(%esi),%edx 10c41b: 8b 5a 14 mov 0x14(%edx),%ebx if (rtems_chain_is_empty (chain)) { 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; 10c41e: 8b 50 14 mov 0x14(%eax),%edx while (req->aiocbp->aio_reqprio > prio && 10c421: 39 5a 14 cmp %ebx,0x14(%edx) 10c424: 7c 06 jl 10c42c <== NEVER TAKEN 10c426: eb 0e jmp 10c436 10c428: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c42a: 74 1c je 10c448 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c42c: 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; 10c42e: 8b 50 14 mov 0x14(%eax),%edx <== 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 && 10c431: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED 10c434: 7c f2 jl 10c428 <== 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 ); 10c436: 89 75 0c mov %esi,0xc(%ebp) 10c439: 8b 40 04 mov 0x4(%eax),%eax 10c43c: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10c43f: 5b pop %ebx 10c440: 5e pop %esi 10c441: c9 leave 10c442: e9 69 24 00 00 jmp 10e8b0 <_Chain_Insert> 10c447: 90 nop } AIO_printf ("Thread finished\n"); return NULL; } 10c448: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c44a: eb ea jmp 10c436 <== NOT EXECUTED =============================================================================== 0010c44c : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 10c44c: 55 push %ebp 10c44d: 89 e5 mov %esp,%ebp 10c44f: 57 push %edi 10c450: 56 push %esi 10c451: 53 push %ebx 10c452: 83 ec 0c sub $0xc,%esp 10c455: 8b 7d 08 mov 0x8(%ebp),%edi } AIO_printf ("Thread finished\n"); return NULL; } 10c458: 8b 5f 08 mov 0x8(%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10c45b: 83 c7 0c add $0xc,%edi rtems_chain_control *chain; rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10c45e: 39 fb cmp %edi,%ebx 10c460: 75 04 jne 10c466 <== ALWAYS TAKEN 10c462: eb 2d jmp 10c491 <== NOT EXECUTED { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); 10c464: 89 f3 mov %esi,%ebx */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10c466: 83 ec 0c sub $0xc,%esp 10c469: 53 push %ebx 10c46a: e8 05 24 00 00 call 10e874 <_Chain_Extract> } AIO_printf ("Thread finished\n"); return NULL; } 10c46f: 8b 33 mov (%ebx),%esi while (!rtems_chain_is_tail (chain, node)) { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; 10c471: 8b 43 14 mov 0x14(%ebx),%eax 10c474: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) req->aiocbp->return_value = -1; 10c47b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (req); 10c482: 89 1c 24 mov %ebx,(%esp) 10c485: e8 aa c6 ff ff call 108b34 rtems_chain_control *chain; rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10c48a: 83 c4 10 add $0x10,%esp 10c48d: 39 fe cmp %edi,%esi 10c48f: 75 d3 jne 10c464 node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; req->aiocbp->return_value = -1; free (req); } } 10c491: 8d 65 f4 lea -0xc(%ebp),%esp 10c494: 5b pop %ebx 10c495: 5e pop %esi 10c496: 5f pop %edi 10c497: c9 leave 10c498: c3 ret =============================================================================== 0010c49c : * 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) { 10c49c: 55 push %ebp 10c49d: 89 e5 mov %esp,%ebp 10c49f: 53 push %ebx 10c4a0: 83 ec 04 sub $0x4,%esp 10c4a3: 8b 55 08 mov 0x8(%ebp),%edx 10c4a6: 8b 4d 0c mov 0xc(%ebp),%ecx } AIO_printf ("Thread finished\n"); return NULL; } 10c4a9: 8b 02 mov (%edx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c4ab: 83 c2 04 add $0x4,%edx * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) 10c4ae: 39 d0 cmp %edx,%eax 10c4b0: 74 4e je 10c500 <== NEVER TAKEN return AIO_ALLDONE; rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; 10c4b2: 89 c3 mov %eax,%ebx while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10c4b4: 39 48 14 cmp %ecx,0x14(%eax) 10c4b7: 75 0a jne 10c4c3 <== NEVER TAKEN 10c4b9: eb 19 jmp 10c4d4 10c4bb: 90 nop node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10c4bc: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10c4be: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED 10c4c1: 74 11 je 10c4d4 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10c4c3: 8b 00 mov (%eax),%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) { 10c4c5: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c4c7: 75 f3 jne 10c4bc <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10c4c9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10c4ce: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c4d1: c9 leave <== NOT EXECUTED 10c4d2: c3 ret <== NOT EXECUTED 10c4d3: 90 nop <== NOT EXECUTED 10c4d4: 83 ec 0c sub $0xc,%esp 10c4d7: 50 push %eax 10c4d8: e8 97 23 00 00 call 10e874 <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10c4dd: 8b 43 14 mov 0x14(%ebx),%eax 10c4e0: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10c4e7: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10c4ee: 89 1c 24 mov %ebx,(%esp) 10c4f1: e8 3e c6 ff ff call 108b34 } return AIO_CANCELED; 10c4f6: 83 c4 10 add $0x10,%esp 10c4f9: 31 c0 xor %eax,%eax } 10c4fb: 8b 5d fc mov -0x4(%ebp),%ebx 10c4fe: c9 leave 10c4ff: c3 ret */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) return AIO_ALLDONE; 10c500: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10c505: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c508: c9 leave <== NOT EXECUTED 10c509: c3 ret <== NOT EXECUTED =============================================================================== 0010c0d8 : * */ rtems_aio_request_chain * rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create) { 10c0d8: 55 push %ebp 10c0d9: 89 e5 mov %esp,%ebp 10c0db: 57 push %edi 10c0dc: 56 push %esi 10c0dd: 53 push %ebx 10c0de: 83 ec 1c sub $0x1c,%esp 10c0e1: 8b 75 08 mov 0x8(%ebp),%esi 10c0e4: 8b 5d 0c mov 0xc(%ebp),%ebx } AIO_printf ("Thread finished\n"); return NULL; } 10c0e7: 8b 06 mov (%esi),%eax rtems_chain_node *node; node = rtems_chain_first (chain); r_chain = (rtems_aio_request_chain *) node; while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10c0e9: 8b 50 14 mov 0x14(%eax),%edx 10c0ec: 39 d3 cmp %edx,%ebx 10c0ee: 7e 28 jle 10c118 RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10c0f0: 8d 4e 04 lea 0x4(%esi),%ecx 10c0f3: eb 0c jmp 10c101 10c0f5: 8d 76 00 lea 0x0(%esi),%esi } AIO_printf ("Thread finished\n"); return NULL; } 10c0f8: 8b 00 mov (%eax),%eax rtems_chain_node *node; node = rtems_chain_first (chain); r_chain = (rtems_aio_request_chain *) node; while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10c0fa: 8b 50 14 mov 0x14(%eax),%edx 10c0fd: 39 da cmp %ebx,%edx 10c0ff: 7d 17 jge 10c118 10c101: 39 c8 cmp %ecx,%eax 10c103: 75 f3 jne 10c0f8 10c105: 89 c7 mov %eax,%edi } if (r_chain->fildes == fildes) r_chain->new_fd = 0; else { if (create == 0) 10c107: 8b 45 10 mov 0x10(%ebp),%eax 10c10a: 85 c0 test %eax,%eax 10c10c: 75 1f jne 10c12d r_chain = NULL; 10c10e: 31 c0 xor %eax,%eax r_chain->new_fd = 1; r_chain->fildes = fildes; } } return r_chain; } 10c110: 8d 65 f4 lea -0xc(%ebp),%esp 10c113: 5b pop %ebx 10c114: 5e pop %esi 10c115: 5f pop %edi 10c116: c9 leave 10c117: c3 ret } AIO_printf ("Thread finished\n"); return NULL; } 10c118: 89 c7 mov %eax,%edi while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); r_chain = (rtems_aio_request_chain *) node; } if (r_chain->fildes == fildes) 10c11a: 39 d3 cmp %edx,%ebx 10c11c: 75 e9 jne 10c107 r_chain->new_fd = 0; 10c11e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) r_chain->new_fd = 1; r_chain->fildes = fildes; } } return r_chain; } 10c125: 8d 65 f4 lea -0xc(%ebp),%esp 10c128: 5b pop %ebx 10c129: 5e pop %esi 10c12a: 5f pop %edi 10c12b: c9 leave 10c12c: c3 ret r_chain->new_fd = 0; else { if (create == 0) r_chain = NULL; else { r_chain = malloc (sizeof (rtems_aio_request_chain)); 10c12d: 83 ec 0c sub $0xc,%esp 10c130: 6a 24 push $0x24 10c132: e8 11 cf ff ff call 109048 10c137: 89 c2 mov %eax,%edx RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c139: 8d 4a 0c lea 0xc(%edx),%ecx 10c13c: 89 4a 08 mov %ecx,0x8(%edx) head->next = tail; head->previous = NULL; 10c13f: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10c146: 8d 4a 08 lea 0x8(%edx),%ecx 10c149: 89 4a 10 mov %ecx,0x10(%edx) RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c14c: 8d 4e 04 lea 0x4(%esi),%ecx rtems_chain_initialize_empty (&r_chain->perfd); if (rtems_chain_is_empty (chain)) 10c14f: 83 c4 10 add $0x10,%esp 10c152: 39 0e cmp %ecx,(%esi) 10c154: 74 27 je 10c17d RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10c156: 83 ec 08 sub $0x8,%esp 10c159: 52 push %edx 10c15a: ff 77 04 pushl 0x4(%edi) 10c15d: 89 45 e4 mov %eax,-0x1c(%ebp) 10c160: 89 55 e0 mov %edx,-0x20(%ebp) 10c163: e8 48 27 00 00 call 10e8b0 <_Chain_Insert> 10c168: 83 c4 10 add $0x10,%esp 10c16b: 8b 55 e0 mov -0x20(%ebp),%edx 10c16e: 8b 45 e4 mov -0x1c(%ebp),%eax rtems_chain_prepend (chain, &r_chain->next_fd); else rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd); r_chain->new_fd = 1; 10c171: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx) r_chain->fildes = fildes; 10c178: 89 5a 14 mov %ebx,0x14(%edx) 10c17b: eb a8 jmp 10c125 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10c17d: 83 ec 08 sub $0x8,%esp 10c180: 52 push %edx 10c181: 56 push %esi 10c182: 89 45 e4 mov %eax,-0x1c(%ebp) 10c185: 89 55 e0 mov %edx,-0x20(%ebp) 10c188: e8 23 27 00 00 call 10e8b0 <_Chain_Insert> 10c18d: 83 c4 10 add $0x10,%esp 10c190: 8b 45 e4 mov -0x1c(%ebp),%eax 10c193: 8b 55 e0 mov -0x20(%ebp),%edx 10c196: eb d9 jmp 10c171 =============================================================================== 00113684 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 113684: 55 push %ebp 113685: 89 e5 mov %esp,%ebp 113687: 57 push %edi 113688: 56 push %esi 113689: 53 push %ebx 11368a: 83 ec 2c sub $0x2c,%esp 11368d: 8b 5d 08 mov 0x8(%ebp),%ebx 113690: 8b 7d 0c mov 0xc(%ebp),%edi 113693: 8b 45 10 mov 0x10(%ebp),%eax 113696: 8b 75 14 mov 0x14(%ebp),%esi Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 113699: 85 db test %ebx,%ebx 11369b: 0f 84 87 00 00 00 je 113728 return RTEMS_INVALID_NAME; if ( !id ) 1136a1: 85 f6 test %esi,%esi 1136a3: 0f 84 bf 00 00 00 je 113768 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 1136a9: f7 c7 10 00 00 00 test $0x10,%edi 1136af: 0f 84 83 00 00 00 je 113738 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 1136b5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( maximum_waiters == 0 ) 1136bc: 85 c0 test %eax,%eax 1136be: 0f 84 80 00 00 00 je 113744 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 1136c4: 89 45 e4 mov %eax,-0x1c(%ebp) 1136c7: a1 70 9f 12 00 mov 0x129f70,%eax 1136cc: 40 inc %eax 1136cd: a3 70 9f 12 00 mov %eax,0x129f70 * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void ) { return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information ); 1136d2: 83 ec 0c sub $0xc,%esp 1136d5: 68 a0 a9 12 00 push $0x12a9a0 1136da: e8 85 b0 ff ff call 10e764 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 1136df: 83 c4 10 add $0x10,%esp 1136e2: 85 c0 test %eax,%eax 1136e4: 74 6e je 113754 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 1136e6: 89 78 10 mov %edi,0x10(%eax) _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 1136e9: 83 ec 08 sub $0x8,%esp 1136ec: 8d 55 e0 lea -0x20(%ebp),%edx 1136ef: 52 push %edx 1136f0: 8d 50 14 lea 0x14(%eax),%edx 1136f3: 52 push %edx 1136f4: 89 45 d4 mov %eax,-0x2c(%ebp) 1136f7: e8 c0 07 00 00 call 113ebc <_CORE_barrier_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1136fc: 8b 45 d4 mov -0x2c(%ebp),%eax 1136ff: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 113702: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 113705: 8b 0d bc a9 12 00 mov 0x12a9bc,%ecx 11370b: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 11370e: 89 58 0c mov %ebx,0xc(%eax) &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 113711: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 113713: e8 e8 bf ff ff call 10f700 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 113718: 83 c4 10 add $0x10,%esp 11371b: 31 c0 xor %eax,%eax } 11371d: 8d 65 f4 lea -0xc(%ebp),%esp 113720: 5b pop %ebx 113721: 5e pop %esi 113722: 5f pop %edi 113723: c9 leave 113724: c3 ret 113725: 8d 76 00 lea 0x0(%esi),%esi { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 113728: b8 03 00 00 00 mov $0x3,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11372d: 8d 65 f4 lea -0xc(%ebp),%esp 113730: 5b pop %ebx 113731: 5e pop %esi 113732: 5f pop %edi 113733: c9 leave 113734: c3 ret 113735: 8d 76 00 lea 0x0(%esi),%esi if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 113738: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 11373f: eb 83 jmp 1136c4 113741: 8d 76 00 lea 0x0(%esi),%esi /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; 113744: b8 0a 00 00 00 mov $0xa,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113749: 8d 65 f4 lea -0xc(%ebp),%esp 11374c: 5b pop %ebx 11374d: 5e pop %esi 11374e: 5f pop %edi 11374f: c9 leave 113750: c3 ret 113751: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 113754: e8 a7 bf ff ff call 10f700 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 113759: b8 05 00 00 00 mov $0x5,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11375e: 8d 65 f4 lea -0xc(%ebp),%esp 113761: 5b pop %ebx 113762: 5e pop %esi 113763: 5f pop %edi 113764: c9 leave 113765: c3 ret 113766: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 113768: b8 09 00 00 00 mov $0x9,%eax 11376d: eb ae jmp 11371d =============================================================================== 0010c14c : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10c14c: 55 push %ebp 10c14d: 89 e5 mov %esp,%ebp 10c14f: 56 push %esi 10c150: 53 push %ebx 10c151: 8b 5d 10 mov 0x10(%ebp),%ebx 10c154: 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 ); 10c157: 83 ec 08 sub $0x8,%esp 10c15a: ff 75 0c pushl 0xc(%ebp) 10c15d: ff 75 08 pushl 0x8(%ebp) 10c160: e8 e3 04 00 00 call 10c648 <_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 ) { 10c165: 83 c4 10 add $0x10,%esp 10c168: 84 c0 test %al,%al 10c16a: 75 0c jne 10c178 <== ALWAYS TAKEN sc = rtems_event_send( task, events ); } return sc; } 10c16c: 31 c0 xor %eax,%eax 10c16e: 8d 65 f8 lea -0x8(%ebp),%esp 10c171: 5b pop %ebx 10c172: 5e pop %esi <== NOT EXECUTED 10c173: c9 leave <== NOT EXECUTED 10c174: c3 ret <== NOT EXECUTED 10c175: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { 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 ); 10c178: 89 75 0c mov %esi,0xc(%ebp) 10c17b: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c17e: 8d 65 f8 lea -0x8(%ebp),%esp 10c181: 5b pop %ebx 10c182: 5e pop %esi 10c183: 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 ); 10c184: e9 a3 f5 ff ff jmp 10b72c =============================================================================== 0010c18c : rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) { 10c18c: 55 push %ebp 10c18d: 89 e5 mov %esp,%ebp 10c18f: 56 push %esi 10c190: 53 push %ebx 10c191: 8b 5d 0c mov 0xc(%ebp),%ebx 10c194: 8b 75 10 mov 0x10(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check( rtems_chain_control *chain, rtems_chain_node **node ) { return _Chain_Get_with_empty_check( chain, node ); 10c197: 83 ec 08 sub $0x8,%esp 10c19a: ff 75 14 pushl 0x14(%ebp) 10c19d: ff 75 08 pushl 0x8(%ebp) 10c1a0: e8 0b 05 00 00 call 10c6b0 <_Chain_Get_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { 10c1a5: 83 c4 10 add $0x10,%esp 10c1a8: 84 c0 test %al,%al 10c1aa: 75 0c jne 10c1b8 sc = rtems_event_send( task, events ); } return sc; } 10c1ac: 31 c0 xor %eax,%eax 10c1ae: 8d 65 f8 lea -0x8(%ebp),%esp 10c1b1: 5b pop %ebx 10c1b2: 5e pop %esi 10c1b3: c9 leave 10c1b4: c3 ret 10c1b5: 8d 76 00 lea 0x0(%esi),%esi { rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { sc = rtems_event_send( task, events ); 10c1b8: 89 75 0c mov %esi,0xc(%ebp) 10c1bb: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c1be: 8d 65 f8 lea -0x8(%ebp),%esp 10c1c1: 5b pop %ebx 10c1c2: 5e pop %esi 10c1c3: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { sc = rtems_event_send( task, events ); 10c1c4: e9 63 f5 ff ff jmp 10b72c =============================================================================== 0010c1cc : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10c1cc: 55 push %ebp 10c1cd: 89 e5 mov %esp,%ebp 10c1cf: 57 push %edi 10c1d0: 56 push %esi 10c1d1: 53 push %ebx 10c1d2: 83 ec 1c sub $0x1c,%esp 10c1d5: 8b 75 08 mov 0x8(%ebp),%esi while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10c1d8: 8d 7d e4 lea -0x1c(%ebp),%edi 10c1db: 90 nop */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10c1dc: 83 ec 0c sub $0xc,%esp 10c1df: 56 push %esi 10c1e0: e8 07 05 00 00 call 10c6ec <_Chain_Get> 10c1e5: 89 c3 mov %eax,%ebx rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c1e7: 83 c4 10 add $0x10,%esp 10c1ea: 85 c0 test %eax,%eax 10c1ec: 75 22 jne 10c210 ) { rtems_event_set out; sc = rtems_event_receive( 10c1ee: 57 push %edi 10c1ef: ff 75 10 pushl 0x10(%ebp) 10c1f2: 6a 00 push $0x0 10c1f4: ff 75 0c pushl 0xc(%ebp) 10c1f7: e8 a8 f3 ff ff call 10b5a4 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10c1fc: 83 c4 10 add $0x10,%esp 10c1ff: 85 c0 test %eax,%eax 10c201: 74 d9 je 10c1dc <== NEVER TAKEN timeout, &out ); } *node_ptr = node; 10c203: 8b 55 14 mov 0x14(%ebp),%edx 10c206: 89 1a mov %ebx,(%edx) return sc; } 10c208: 8d 65 f4 lea -0xc(%ebp),%esp 10c20b: 5b pop %ebx 10c20c: 5e pop %esi 10c20d: 5f pop %edi 10c20e: c9 leave 10c20f: c3 ret rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c210: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10c212: 8b 55 14 mov 0x14(%ebp),%edx 10c215: 89 1a mov %ebx,(%edx) return sc; } 10c217: 8d 65 f4 lea -0xc(%ebp),%esp 10c21a: 5b pop %ebx 10c21b: 5e pop %esi 10c21c: 5f pop %edi 10c21d: c9 leave 10c21e: c3 ret =============================================================================== 0010c220 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10c220: 55 push %ebp 10c221: 89 e5 mov %esp,%ebp 10c223: 56 push %esi 10c224: 53 push %ebx 10c225: 8b 5d 10 mov 0x10(%ebp),%ebx 10c228: 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 ); 10c22b: 83 ec 08 sub $0x8,%esp 10c22e: ff 75 0c pushl 0xc(%ebp) 10c231: ff 75 08 pushl 0x8(%ebp) 10c234: e8 f7 04 00 00 call 10c730 <_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) { 10c239: 83 c4 10 add $0x10,%esp 10c23c: 84 c0 test %al,%al 10c23e: 75 0c jne 10c24c <== ALWAYS TAKEN sc = rtems_event_send( task, events ); } return sc; } 10c240: 31 c0 xor %eax,%eax 10c242: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c245: 5b pop %ebx <== NOT EXECUTED 10c246: 5e pop %esi <== NOT EXECUTED 10c247: c9 leave <== NOT EXECUTED 10c248: c3 ret <== NOT EXECUTED 10c249: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { 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 ); 10c24c: 89 75 0c mov %esi,0xc(%ebp) 10c24f: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10c252: 8d 65 f8 lea -0x8(%ebp),%esp 10c255: 5b pop %ebx 10c256: 5e pop %esi 10c257: 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 ); 10c258: e9 cf f4 ff ff jmp 10b72c =============================================================================== 00115a60 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 115a60: 55 push %ebp 115a61: 89 e5 mov %esp,%ebp 115a63: 53 push %ebx 115a64: 83 ec 04 sub $0x4,%esp 115a67: 8b 45 08 mov 0x8(%ebp),%eax 115a6a: 8b 5d 0c mov 0xc(%ebp),%ebx if ( !time_buffer ) 115a6d: 85 db test %ebx,%ebx 115a6f: 74 3b je 115aac return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) 115a71: 85 c0 test %eax,%eax 115a73: 74 2b je 115aa0 return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) 115a75: 83 f8 01 cmp $0x1,%eax 115a78: 74 3e je 115ab8 return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { 115a7a: 83 f8 02 cmp $0x2,%eax 115a7d: 74 45 je 115ac4 *interval = rtems_clock_get_ticks_since_boot(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { 115a7f: 83 f8 03 cmp $0x3,%eax 115a82: 74 4c je 115ad0 *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) 115a84: 83 f8 04 cmp $0x4,%eax 115a87: 74 0b je 115a94 return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; 115a89: b8 0a 00 00 00 mov $0xa,%eax } 115a8e: 5a pop %edx 115a8f: 5b pop %ebx 115a90: c9 leave 115a91: c3 ret 115a92: 66 90 xchg %ax,%ax *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 115a94: 89 5d 08 mov %ebx,0x8(%ebp) return RTEMS_INVALID_NUMBER; } 115a97: 59 pop %ecx 115a98: 5b pop %ebx 115a99: c9 leave *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 115a9a: e9 41 01 00 00 jmp 115be0 115a9f: 90 nop { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 115aa0: 89 5d 08 mov %ebx,0x8(%ebp) if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 115aa3: 58 pop %eax 115aa4: 5b pop %ebx 115aa5: c9 leave { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 115aa6: e9 81 00 00 00 jmp 115b2c 115aab: 90 nop rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 115aac: b8 09 00 00 00 mov $0x9,%eax if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 115ab1: 5a pop %edx 115ab2: 5b pop %ebx 115ab3: c9 leave 115ab4: c3 ret 115ab5: 8d 76 00 lea 0x0(%esi),%esi if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 115ab8: 89 5d 08 mov %ebx,0x8(%ebp) if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 115abb: 5b pop %ebx 115abc: 5b pop %ebx 115abd: c9 leave if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 115abe: e9 19 00 00 00 jmp 115adc 115ac3: 90 nop if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 115ac4: e8 57 00 00 00 call 115b20 115ac9: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 115acb: 31 c0 xor %eax,%eax 115acd: eb bf jmp 115a8e 115acf: 90 nop } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 115ad0: e8 37 00 00 00 call 115b0c 115ad5: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 115ad7: 31 c0 xor %eax,%eax 115ad9: eb b3 jmp 115a8e =============================================================================== 00115be0 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 115be0: 55 push %ebp 115be1: 89 e5 mov %esp,%ebp 115be3: 56 push %esi 115be4: 53 push %ebx 115be5: 83 ec 10 sub $0x10,%esp 115be8: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !time ) 115beb: 85 db test %ebx,%ebx 115bed: 74 51 je 115c40 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 115bef: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224 115bf6: 75 0c jne 115c04 return RTEMS_NOT_DEFINED; 115bf8: b8 0b 00 00 00 mov $0xb,%eax _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 115bfd: 8d 65 f8 lea -0x8(%ebp),%esp 115c00: 5b pop %ebx 115c01: 5e pop %esi 115c02: c9 leave 115c03: c3 ret { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 115c04: 9c pushf 115c05: fa cli 115c06: 5e pop %esi _TOD_Get( &now ); 115c07: 83 ec 0c sub $0xc,%esp 115c0a: 8d 45 f0 lea -0x10(%ebp),%eax 115c0d: 50 push %eax 115c0e: e8 21 44 00 00 call 11a034 <_TOD_Get> _ISR_Enable(level); 115c13: 56 push %esi 115c14: 9d popf useconds = (suseconds_t)now.tv_nsec; 115c15: 8b 4d f4 mov -0xc(%ebp),%ecx useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 115c18: 8b 45 f0 mov -0x10(%ebp),%eax 115c1b: 89 03 mov %eax,(%ebx) _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); useconds = (suseconds_t)now.tv_nsec; useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; 115c1d: b8 d3 4d 62 10 mov $0x10624dd3,%eax 115c22: f7 e9 imul %ecx 115c24: 89 d0 mov %edx,%eax 115c26: c1 f8 06 sar $0x6,%eax 115c29: c1 f9 1f sar $0x1f,%ecx 115c2c: 29 c8 sub %ecx,%eax 115c2e: 89 43 04 mov %eax,0x4(%ebx) if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; 115c31: 83 c4 10 add $0x10,%esp 115c34: 31 c0 xor %eax,%eax } 115c36: 8d 65 f8 lea -0x8(%ebp),%esp 115c39: 5b pop %ebx 115c3a: 5e pop %esi 115c3b: c9 leave 115c3c: c3 ret 115c3d: 8d 76 00 lea 0x0(%esi),%esi rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) return RTEMS_INVALID_ADDRESS; 115c40: b8 09 00 00 00 mov $0x9,%eax 115c45: eb b6 jmp 115bfd =============================================================================== 0010b1d4 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 10b1d4: 55 push %ebp 10b1d5: 89 e5 mov %esp,%ebp 10b1d7: 83 ec 08 sub $0x8,%esp 10b1da: 8b 45 08 mov 0x8(%ebp),%eax if ( !uptime ) 10b1dd: 85 c0 test %eax,%eax 10b1df: 74 13 je 10b1f4 return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime_as_timespec( uptime ); 10b1e1: 83 ec 0c sub $0xc,%esp 10b1e4: 50 push %eax 10b1e5: e8 7a 16 00 00 call 10c864 <_TOD_Get_uptime_as_timespec> return RTEMS_SUCCESSFUL; 10b1ea: 83 c4 10 add $0x10,%esp 10b1ed: 31 c0 xor %eax,%eax } 10b1ef: c9 leave 10b1f0: c3 ret 10b1f1: 8d 76 00 lea 0x0(%esi),%esi rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) return RTEMS_INVALID_ADDRESS; 10b1f4: b8 09 00 00 00 mov $0x9,%eax _TOD_Get_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; } 10b1f9: c9 leave 10b1fa: c3 ret =============================================================================== 0010c124 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 10c124: 55 push %ebp 10c125: 89 e5 mov %esp,%ebp 10c127: 53 push %ebx 10c128: 83 ec 14 sub $0x14,%esp 10c12b: 8b 5d 08 mov 0x8(%ebp),%ebx struct timespec newtime; if ( !time_buffer ) 10c12e: 85 db test %ebx,%ebx 10c130: 74 66 je 10c198 return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 10c132: 83 ec 0c sub $0xc,%esp 10c135: 53 push %ebx 10c136: e8 39 01 00 00 call 10c274 <_TOD_Validate> 10c13b: 83 c4 10 add $0x10,%esp 10c13e: 84 c0 test %al,%al 10c140: 75 0a jne 10c14c _Thread_Disable_dispatch(); _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; 10c142: b8 14 00 00 00 mov $0x14,%eax } 10c147: 8b 5d fc mov -0x4(%ebp),%ebx 10c14a: c9 leave 10c14b: c3 ret if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10c14c: 83 ec 0c sub $0xc,%esp 10c14f: 53 push %ebx 10c150: e8 93 00 00 00 call 10c1e8 <_TOD_To_seconds> 10c155: 89 45 f0 mov %eax,-0x10(%ebp) newtime.tv_nsec = time_buffer->ticks * 10c158: 8b 43 18 mov 0x18(%ebx),%eax 10c15b: 0f af 05 2c 62 12 00 imul 0x12622c,%eax 10c162: 8d 04 80 lea (%eax,%eax,4),%eax 10c165: 8d 04 80 lea (%eax,%eax,4),%eax 10c168: 8d 04 80 lea (%eax,%eax,4),%eax 10c16b: c1 e0 03 shl $0x3,%eax 10c16e: 89 45 f4 mov %eax,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c171: a1 70 23 13 00 mov 0x132370,%eax 10c176: 40 inc %eax 10c177: a3 70 23 13 00 mov %eax,0x132370 rtems_configuration_get_nanoseconds_per_tick(); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 10c17c: 8d 45 f0 lea -0x10(%ebp),%eax 10c17f: 89 04 24 mov %eax,(%esp) 10c182: e8 59 19 00 00 call 10dae0 <_TOD_Set> _Thread_Enable_dispatch(); 10c187: e8 e8 2e 00 00 call 10f074 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c18c: 83 c4 10 add $0x10,%esp 10c18f: 31 c0 xor %eax,%eax } return RTEMS_INVALID_CLOCK; } 10c191: 8b 5d fc mov -0x4(%ebp),%ebx 10c194: c9 leave 10c195: c3 ret 10c196: 66 90 xchg %ax,%ax ) { struct timespec newtime; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10c198: b8 09 00 00 00 mov $0x9,%eax _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10c19d: 8b 5d fc mov -0x4(%ebp),%ebx 10c1a0: c9 leave 10c1a1: c3 ret =============================================================================== 0010afd0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 10afd0: 55 push %ebp 10afd1: 89 e5 mov %esp,%ebp 10afd3: 83 ec 08 sub $0x8,%esp _TOD_Tickle_ticks(); 10afd6: e8 3d 15 00 00 call 10c518 <_TOD_Tickle_ticks> */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 10afdb: 83 ec 0c sub $0xc,%esp 10afde: 68 7c 76 12 00 push $0x12767c 10afe3: e8 bc 38 00 00 call 10e8a4 <_Watchdog_Tickle> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 10afe8: e8 77 33 00 00 call 10e364 <_Thread_Tickle_timeslice> * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) { return ( _Thread_Dispatch_necessary ); 10afed: a0 64 7b 12 00 mov 0x127b64,%al if ( _Thread_Is_context_switch_necessary() && 10aff2: 83 c4 10 add $0x10,%esp 10aff5: 84 c0 test %al,%al 10aff7: 74 09 je 10b002 * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 10aff9: a1 70 75 12 00 mov 0x127570,%eax 10affe: 85 c0 test %eax,%eax 10b000: 74 06 je 10b008 _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 10b002: 31 c0 xor %eax,%eax 10b004: c9 leave 10b005: c3 ret 10b006: 66 90 xchg %ax,%ax _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 10b008: e8 6f 27 00 00 call 10d77c <_Thread_Dispatch> return RTEMS_SUCCESSFUL; } 10b00d: 31 c0 xor %eax,%eax 10b00f: c9 leave 10b010: c3 ret =============================================================================== 0010b19c : rtems_status_code rtems_event_send( rtems_id id, rtems_event_set event_in ) { 10b19c: 55 push %ebp 10b19d: 89 e5 mov %esp,%ebp 10b19f: 53 push %ebx 10b1a0: 83 ec 1c sub $0x1c,%esp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); 10b1a3: 8d 45 f4 lea -0xc(%ebp),%eax 10b1a6: 50 push %eax 10b1a7: ff 75 08 pushl 0x8(%ebp) 10b1aa: e8 69 27 00 00 call 10d918 <_Thread_Get> switch ( location ) { 10b1af: 83 c4 10 add $0x10,%esp 10b1b2: 8b 55 f4 mov -0xc(%ebp),%edx 10b1b5: 85 d2 test %edx,%edx 10b1b7: 75 2b jne 10b1e4 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 10b1b9: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 10b1bf: 9c pushf 10b1c0: fa cli 10b1c1: 59 pop %ecx *the_event_set |= the_new_events; 10b1c2: 8b 5d 0c mov 0xc(%ebp),%ebx 10b1c5: 09 1a or %ebx,(%edx) _ISR_Enable( level ); 10b1c7: 51 push %ecx 10b1c8: 9d popf _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 10b1c9: 83 ec 0c sub $0xc,%esp 10b1cc: 50 push %eax 10b1cd: e8 1e 00 00 00 call 10b1f0 <_Event_Surrender> _Thread_Enable_dispatch(); 10b1d2: e8 1d 27 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b1d7: 83 c4 10 add $0x10,%esp 10b1da: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b1dc: 8b 5d fc mov -0x4(%ebp),%ebx 10b1df: c9 leave 10b1e0: c3 ret 10b1e1: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1e4: b8 04 00 00 00 mov $0x4,%eax } 10b1e9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ec: c9 leave 10b1ed: c3 ret =============================================================================== 0010d00c : #include rtems_status_code rtems_extension_delete( rtems_id id ) { 10d00c: 55 push %ebp 10d00d: 89 e5 mov %esp,%ebp 10d00f: 53 push %ebx 10d010: 83 ec 18 sub $0x18,%esp Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); 10d013: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Extension_Control *) _Objects_Get( &_Extension_Information, id, location ); 10d016: 50 push %eax 10d017: ff 75 08 pushl 0x8(%ebp) 10d01a: 68 00 26 13 00 push $0x132600 10d01f: e8 24 12 00 00 call 10e248 <_Objects_Get> 10d024: 89 c3 mov %eax,%ebx switch ( location ) { 10d026: 83 c4 10 add $0x10,%esp 10d029: 8b 55 f4 mov -0xc(%ebp),%edx 10d02c: 85 d2 test %edx,%edx 10d02e: 75 38 jne 10d068 case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10d030: 83 ec 0c sub $0xc,%esp 10d033: 8d 40 10 lea 0x10(%eax),%eax 10d036: 50 push %eax 10d037: e8 a4 29 00 00 call 10f9e0 <_User_extensions_Remove_set> _Objects_Close( &_Extension_Information, &the_extension->Object ); 10d03c: 59 pop %ecx 10d03d: 58 pop %eax 10d03e: 53 push %ebx 10d03f: 68 00 26 13 00 push $0x132600 10d044: e8 c3 0d 00 00 call 10de0c <_Objects_Close> RTEMS_INLINE_ROUTINE void _Extension_Free ( Extension_Control *the_extension ) { _Objects_Free( &_Extension_Information, &the_extension->Object ); 10d049: 58 pop %eax 10d04a: 5a pop %edx 10d04b: 53 push %ebx 10d04c: 68 00 26 13 00 push $0x132600 10d051: e8 b2 10 00 00 call 10e108 <_Objects_Free> _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10d056: e8 a1 1c 00 00 call 10ecfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d05b: 83 c4 10 add $0x10,%esp 10d05e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d060: 8b 5d fc mov -0x4(%ebp),%ebx 10d063: c9 leave 10d064: c3 ret 10d065: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d068: b8 04 00 00 00 mov $0x4,%eax } 10d06d: 8b 5d fc mov -0x4(%ebp),%ebx 10d070: c9 leave 10d071: c3 ret =============================================================================== 00112ff8 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 112ff8: 55 push %ebp 112ff9: 89 e5 mov %esp,%ebp 112ffb: 53 push %ebx 112ffc: 83 ec 04 sub $0x4,%esp 112fff: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113002: 39 05 20 80 12 00 cmp %eax,0x128020 113008: 76 1a jbe 113024 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 11300a: 8d 14 40 lea (%eax,%eax,2),%edx 11300d: c1 e2 03 shl $0x3,%edx 113010: 03 15 24 80 12 00 add 0x128024,%edx 113016: 8b 52 08 mov 0x8(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113019: 85 d2 test %edx,%edx 11301b: 74 13 je 113030 } 11301d: 59 pop %ecx 11301e: 5b pop %ebx 11301f: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113020: ff e2 jmp *%edx 113022: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113024: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113029: 5a pop %edx 11302a: 5b pop %ebx 11302b: c9 leave 11302c: c3 ret 11302d: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113030: 31 c0 xor %eax,%eax } 113032: 5a pop %edx 113033: 5b pop %ebx 113034: c9 leave 113035: c3 ret =============================================================================== 00113038 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 113038: 55 push %ebp 113039: 89 e5 mov %esp,%ebp 11303b: 53 push %ebx 11303c: 83 ec 04 sub $0x4,%esp 11303f: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113042: 39 05 20 80 12 00 cmp %eax,0x128020 113048: 76 1a jbe 113064 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 11304a: 8d 14 40 lea (%eax,%eax,2),%edx 11304d: c1 e2 03 shl $0x3,%edx 113050: 03 15 24 80 12 00 add 0x128024,%edx 113056: 8b 52 14 mov 0x14(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113059: 85 d2 test %edx,%edx 11305b: 74 13 je 113070 } 11305d: 59 pop %ecx 11305e: 5b pop %ebx 11305f: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113060: ff e2 jmp *%edx 113062: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113064: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113069: 5a pop %edx 11306a: 5b pop %ebx 11306b: c9 leave 11306c: c3 ret 11306d: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113070: 31 c0 xor %eax,%eax } 113072: 5a pop %edx 113073: 5b pop %ebx 113074: c9 leave 113075: c3 ret =============================================================================== 00111014 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111014: 55 push %ebp 111015: 89 e5 mov %esp,%ebp 111017: 53 push %ebx 111018: 83 ec 04 sub $0x4,%esp 11101b: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 11101e: 39 05 20 80 12 00 cmp %eax,0x128020 111024: 76 1a jbe 111040 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 111026: 8d 14 40 lea (%eax,%eax,2),%edx 111029: c1 e2 03 shl $0x3,%edx 11102c: 03 15 24 80 12 00 add 0x128024,%edx 111032: 8b 12 mov (%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111034: 85 d2 test %edx,%edx 111036: 74 14 je 11104c } 111038: 59 pop %ecx 111039: 5b pop %ebx 11103a: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11103b: ff e2 jmp *%edx 11103d: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111040: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111045: 5a pop %edx 111046: 5b pop %ebx 111047: c9 leave 111048: c3 ret 111049: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 11104c: 31 c0 xor %eax,%eax } 11104e: 5a pop %edx 11104f: 5b pop %ebx 111050: c9 leave 111051: c3 ret =============================================================================== 00113078 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 113078: 55 push %ebp 113079: 89 e5 mov %esp,%ebp 11307b: 53 push %ebx 11307c: 83 ec 04 sub $0x4,%esp 11307f: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113082: 39 05 20 80 12 00 cmp %eax,0x128020 113088: 76 1a jbe 1130a4 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 11308a: 8d 14 40 lea (%eax,%eax,2),%edx 11308d: c1 e2 03 shl $0x3,%edx 113090: 03 15 24 80 12 00 add 0x128024,%edx 113096: 8b 52 04 mov 0x4(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113099: 85 d2 test %edx,%edx 11309b: 74 13 je 1130b0 } 11309d: 59 pop %ecx 11309e: 5b pop %ebx 11309f: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1130a0: ff e2 jmp *%edx 1130a2: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 1130a4: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 1130a9: 5a pop %edx 1130aa: 5b pop %ebx 1130ab: c9 leave 1130ac: c3 ret 1130ad: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1130b0: 31 c0 xor %eax,%eax } 1130b2: 5a pop %edx 1130b3: 5b pop %ebx 1130b4: c9 leave 1130b5: c3 ret =============================================================================== 001130b8 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1130b8: 55 push %ebp 1130b9: 89 e5 mov %esp,%ebp 1130bb: 53 push %ebx 1130bc: 83 ec 04 sub $0x4,%esp 1130bf: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1130c2: 39 05 20 80 12 00 cmp %eax,0x128020 1130c8: 76 1a jbe 1130e4 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 1130ca: 8d 14 40 lea (%eax,%eax,2),%edx 1130cd: c1 e2 03 shl $0x3,%edx 1130d0: 03 15 24 80 12 00 add 0x128024,%edx 1130d6: 8b 52 0c mov 0xc(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1130d9: 85 d2 test %edx,%edx 1130db: 74 13 je 1130f0 } 1130dd: 59 pop %ecx 1130de: 5b pop %ebx 1130df: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1130e0: ff e2 jmp *%edx 1130e2: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 1130e4: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 1130e9: 5a pop %edx 1130ea: 5b pop %ebx 1130eb: c9 leave 1130ec: c3 ret 1130ed: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1130f0: 31 c0 xor %eax,%eax } 1130f2: 5a pop %edx 1130f3: 5b pop %ebx 1130f4: c9 leave 1130f5: c3 ret =============================================================================== 0010cecc : 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 ) { 10cecc: 55 push %ebp 10cecd: 89 e5 mov %esp,%ebp 10cecf: 57 push %edi 10ced0: 56 push %esi 10ced1: 53 push %ebx 10ced2: 83 ec 0c sub $0xc,%esp 10ced5: 8b 5d 08 mov 0x8(%ebp),%ebx 10ced8: 8b 75 0c mov 0xc(%ebp),%esi 10cedb: 8b 55 10 mov 0x10(%ebp),%edx rtems_device_major_number major_limit = _IO_Number_of_drivers; 10cede: a1 00 bd 12 00 mov 0x12bd00,%eax if ( rtems_interrupt_is_in_progress() ) 10cee3: 8b 0d 34 b8 12 00 mov 0x12b834,%ecx 10cee9: 85 c9 test %ecx,%ecx 10ceeb: 0f 85 ab 00 00 00 jne 10cf9c return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10cef1: 85 d2 test %edx,%edx 10cef3: 0f 84 e7 00 00 00 je 10cfe0 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10cef9: 89 02 mov %eax,(%edx) if ( driver_table == NULL ) 10cefb: 85 f6 test %esi,%esi 10cefd: 0f 84 dd 00 00 00 je 10cfe0 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cf03: 8b 3e mov (%esi),%edi 10cf05: 85 ff test %edi,%edi 10cf07: 0f 84 c7 00 00 00 je 10cfd4 return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10cf0d: 39 d8 cmp %ebx,%eax 10cf0f: 76 7b jbe 10cf8c rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10cf11: a1 50 b2 12 00 mov 0x12b250,%eax 10cf16: 40 inc %eax 10cf17: a3 50 b2 12 00 mov %eax,0x12b250 return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10cf1c: 85 db test %ebx,%ebx 10cf1e: 0f 85 88 00 00 00 jne 10cfac static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10cf24: 8b 0d 00 bd 12 00 mov 0x12bd00,%ecx rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10cf2a: 85 c9 test %ecx,%ecx 10cf2c: 0f 84 bb 00 00 00 je 10cfed <== NEVER TAKEN 10cf32: 8b 3d 04 bd 12 00 mov 0x12bd04,%edi 10cf38: 89 f8 mov %edi,%eax 10cf3a: eb 08 jmp 10cf44 10cf3c: 43 inc %ebx 10cf3d: 83 c0 18 add $0x18,%eax 10cf40: 39 d9 cmp %ebx,%ecx 10cf42: 76 0b jbe 10cf4f static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cf44: 83 38 00 cmpl $0x0,(%eax) 10cf47: 75 f3 jne 10cf3c 10cf49: 83 78 04 00 cmpl $0x0,0x4(%eax) 10cf4d: 75 ed jne 10cf3c if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10cf4f: 89 1a mov %ebx,(%edx) if ( m != n ) 10cf51: 39 d9 cmp %ebx,%ecx 10cf53: 0f 84 9b 00 00 00 je 10cff4 10cf59: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cf5c: c1 e0 03 shl $0x3,%eax } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 10cf5f: 01 c7 add %eax,%edi 10cf61: b9 06 00 00 00 mov $0x6,%ecx 10cf66: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10cf68: e8 a3 1c 00 00 call 10ec10 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10cf6d: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10cf74: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10cf7b: 89 5d 08 mov %ebx,0x8(%ebp) } 10cf7e: 83 c4 0c add $0xc,%esp 10cf81: 5b pop %ebx 10cf82: 5e pop %esi 10cf83: 5f pop %edi 10cf84: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10cf85: e9 36 7e 00 00 jmp 114dc0 10cf8a: 66 90 xchg %ax,%ax if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10cf8c: 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 ); } 10cf91: 83 c4 0c add $0xc,%esp 10cf94: 5b pop %ebx 10cf95: 5e pop %esi 10cf96: 5f pop %edi 10cf97: c9 leave 10cf98: c3 ret 10cf99: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10cf9c: b8 12 00 00 00 mov $0x12,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cfa1: 83 c4 0c add $0xc,%esp 10cfa4: 5b pop %ebx 10cfa5: 5e pop %esi 10cfa6: 5f pop %edi 10cfa7: c9 leave 10cfa8: c3 ret 10cfa9: 8d 76 00 lea 0x0(%esi),%esi _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10cfac: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cfaf: c1 e0 03 shl $0x3,%eax 10cfb2: 8b 0d 04 bd 12 00 mov 0x12bd04,%ecx 10cfb8: 01 c1 add %eax,%ecx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cfba: 8b 39 mov (%ecx),%edi 10cfbc: 85 ff test %edi,%edi 10cfbe: 74 40 je 10d000 major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); 10cfc0: e8 4b 1c 00 00 call 10ec10 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10cfc5: b8 0c 00 00 00 mov $0xc,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cfca: 83 c4 0c add $0xc,%esp 10cfcd: 5b pop %ebx 10cfce: 5e pop %esi 10cfcf: 5f pop %edi 10cfd0: c9 leave 10cfd1: c3 ret 10cfd2: 66 90 xchg %ax,%ax static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10cfd4: 8b 4e 04 mov 0x4(%esi),%ecx 10cfd7: 85 c9 test %ecx,%ecx 10cfd9: 0f 85 2e ff ff ff jne 10cf0d 10cfdf: 90 nop if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10cfe0: b8 09 00 00 00 mov $0x9,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10cfe5: 83 c4 0c add $0xc,%esp 10cfe8: 5b pop %ebx 10cfe9: 5e pop %esi 10cfea: 5f pop %edi 10cfeb: c9 leave 10cfec: c3 ret if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10cfed: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 10cff3: 90 nop <== NOT EXECUTED if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10cff4: e8 17 1c 00 00 call 10ec10 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10cff9: 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; 10cffe: eb 91 jmp 10cf91 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d000: 8b 49 04 mov 0x4(%ecx),%ecx 10d003: 85 c9 test %ecx,%ecx 10d005: 75 b9 jne 10cfc0 if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 10d007: 89 1a mov %ebx,(%edx) 10d009: 8b 3d 04 bd 12 00 mov 0x12bd04,%edi 10d00f: e9 4b ff ff ff jmp 10cf5f =============================================================================== 0010d014 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10d014: 55 push %ebp 10d015: 89 e5 mov %esp,%ebp 10d017: 57 push %edi 10d018: 83 ec 04 sub $0x4,%esp 10d01b: 8b 45 08 mov 0x8(%ebp),%eax if ( rtems_interrupt_is_in_progress() ) 10d01e: 8b 0d 34 b8 12 00 mov 0x12b834,%ecx 10d024: 85 c9 test %ecx,%ecx 10d026: 75 44 jne 10d06c return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { 10d028: 39 05 00 bd 12 00 cmp %eax,0x12bd00 10d02e: 77 0c ja 10d03c _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; 10d030: b8 0d 00 00 00 mov $0xd,%eax } 10d035: 5a pop %edx 10d036: 5f pop %edi 10d037: c9 leave 10d038: c3 ret 10d039: 8d 76 00 lea 0x0(%esi),%esi 10d03c: 8b 15 50 b2 12 00 mov 0x12b250,%edx 10d042: 42 inc %edx 10d043: 89 15 50 b2 12 00 mov %edx,0x12b250 return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( &_IO_Driver_address_table[major], 10d049: 8d 14 40 lea (%eax,%eax,2),%edx 10d04c: c1 e2 03 shl $0x3,%edx if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( 10d04f: 03 15 04 bd 12 00 add 0x12bd04,%edx 10d055: b9 18 00 00 00 mov $0x18,%ecx 10d05a: 31 c0 xor %eax,%eax 10d05c: 89 d7 mov %edx,%edi 10d05e: f3 aa rep stos %al,%es:(%edi) &_IO_Driver_address_table[major], 0, sizeof( rtems_driver_address_table ) ); _Thread_Enable_dispatch(); 10d060: e8 ab 1b 00 00 call 10ec10 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d065: 31 c0 xor %eax,%eax } return RTEMS_UNSATISFIED; } 10d067: 5a pop %edx 10d068: 5f pop %edi 10d069: c9 leave 10d06a: c3 ret 10d06b: 90 nop rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10d06c: b8 12 00 00 00 mov $0x12,%eax return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10d071: 5a pop %edx 10d072: 5f pop %edi 10d073: c9 leave 10d074: c3 ret =============================================================================== 001130f8 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1130f8: 55 push %ebp 1130f9: 89 e5 mov %esp,%ebp 1130fb: 53 push %ebx 1130fc: 83 ec 04 sub $0x4,%esp 1130ff: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 113102: 39 05 20 80 12 00 cmp %eax,0x128020 113108: 76 1a jbe 113124 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 11310a: 8d 14 40 lea (%eax,%eax,2),%edx 11310d: c1 e2 03 shl $0x3,%edx 113110: 03 15 24 80 12 00 add 0x128024,%edx 113116: 8b 52 10 mov 0x10(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113119: 85 d2 test %edx,%edx 11311b: 74 13 je 113130 } 11311d: 59 pop %ecx 11311e: 5b pop %ebx 11311f: c9 leave if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113120: ff e2 jmp *%edx 113122: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 113124: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 113129: 5a pop %edx 11312a: 5b pop %ebx 11312b: c9 leave 11312c: c3 ret 11312d: 8d 76 00 lea 0x0(%esi),%esi if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 113130: 31 c0 xor %eax,%eax } 113132: 5a pop %edx 113133: 5b pop %ebx 113134: c9 leave 113135: c3 ret =============================================================================== 0010dfbc : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10dfbc: 55 push %ebp 10dfbd: 89 e5 mov %esp,%ebp 10dfbf: 57 push %edi 10dfc0: 56 push %esi 10dfc1: 53 push %ebx 10dfc2: 83 ec 1c sub $0x1c,%esp 10dfc5: 8b 7d 08 mov 0x8(%ebp),%edi uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10dfc8: 85 ff test %edi,%edi 10dfca: 74 49 je 10e015 <== NEVER TAKEN 10dfcc: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp) #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10dfd3: 8b 55 e4 mov -0x1c(%ebp),%edx 10dfd6: 8b 04 95 48 23 13 00 mov 0x132348(,%edx,4),%eax 10dfdd: 8b 70 04 mov 0x4(%eax),%esi if ( !information ) 10dfe0: 85 f6 test %esi,%esi 10dfe2: 74 28 je 10e00c continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10dfe4: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 10dfe9: 74 21 je 10e00c 10dfeb: bb 01 00 00 00 mov $0x1,%ebx the_thread = (Thread_Control *)information->local_table[ i ]; 10dff0: 8b 46 1c mov 0x1c(%esi),%eax 10dff3: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10dff6: 85 c0 test %eax,%eax 10dff8: 74 09 je 10e003 <== NEVER TAKEN continue; (*routine)(the_thread); 10dffa: 83 ec 0c sub $0xc,%esp 10dffd: 50 push %eax 10dffe: ff d7 call *%edi 10e000: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10e003: 43 inc %ebx 10e004: 0f b7 46 10 movzwl 0x10(%esi),%eax 10e008: 39 d8 cmp %ebx,%eax 10e00a: 73 e4 jae 10dff0 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10e00c: ff 45 e4 incl -0x1c(%ebp) 10e00f: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp) 10e013: 75 be jne 10dfd3 (*routine)(the_thread); } } } 10e015: 8d 65 f4 lea -0xc(%ebp),%esp 10e018: 5b pop %ebx 10e019: 5e pop %esi 10e01a: 5f pop %edi 10e01b: c9 leave 10e01c: c3 ret =============================================================================== 001163bc : rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 1163bc: 55 push %ebp 1163bd: 89 e5 mov %esp,%ebp 1163bf: 57 push %edi 1163c0: 56 push %esi 1163c1: 53 push %ebx 1163c2: 83 ec 1c sub $0x1c,%esp 1163c5: 8b 7d 08 mov 0x8(%ebp),%edi 1163c8: 8b 5d 0c mov 0xc(%ebp),%ebx 1163cb: 8b 75 14 mov 0x14(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 1163ce: 85 db test %ebx,%ebx 1163d0: 74 62 je 116434 return RTEMS_INVALID_ADDRESS; if ( !count ) 1163d2: 85 f6 test %esi,%esi 1163d4: 74 5e je 116434 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 1163d6: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1163d7: 8d 45 e4 lea -0x1c(%ebp),%eax 1163da: 50 push %eax 1163db: 57 push %edi 1163dc: 68 40 2c 14 00 push $0x142c40 1163e1: e8 fe 4e 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 1163e6: 83 c4 10 add $0x10,%esp 1163e9: 8b 55 e4 mov -0x1c(%ebp),%edx 1163ec: 85 d2 test %edx,%edx 1163ee: 74 10 je 116400 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163f0: b8 04 00 00 00 mov $0x4,%eax } 1163f5: 8d 65 f4 lea -0xc(%ebp),%esp 1163f8: 5b pop %ebx 1163f9: 5e pop %esi 1163fa: 5f pop %edi 1163fb: c9 leave 1163fc: c3 ret 1163fd: 8d 76 00 lea 0x0(%esi),%esi the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 116400: 83 ec 08 sub $0x8,%esp 116403: 56 push %esi 116404: 6a 00 push $0x0 116406: 57 push %edi 116407: ff 75 10 pushl 0x10(%ebp) 11640a: 53 push %ebx 11640b: 83 c0 14 add $0x14,%eax 11640e: 50 push %eax 11640f: e8 cc 34 00 00 call 1198e0 <_CORE_message_queue_Broadcast> 116414: 89 c3 mov %eax,%ebx NULL, #endif count ); _Thread_Enable_dispatch(); 116416: 83 c4 20 add $0x20,%esp 116419: e8 7a 59 00 00 call 11bd98 <_Thread_Enable_dispatch> return 11641e: 83 ec 0c sub $0xc,%esp 116421: 53 push %ebx 116422: e8 69 03 00 00 call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116427: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11642a: 8d 65 f4 lea -0xc(%ebp),%esp 11642d: 5b pop %ebx 11642e: 5e pop %esi 11642f: 5f pop %edi 116430: c9 leave 116431: c3 ret 116432: 66 90 xchg %ax,%ax if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !count ) return RTEMS_INVALID_ADDRESS; 116434: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116439: 8d 65 f4 lea -0xc(%ebp),%esp 11643c: 5b pop %ebx 11643d: 5e pop %esi 11643e: 5f pop %edi 11643f: c9 leave 116440: c3 ret =============================================================================== 00113858 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 113858: 55 push %ebp 113859: 89 e5 mov %esp,%ebp 11385b: 57 push %edi 11385c: 56 push %esi 11385d: 53 push %ebx 11385e: 83 ec 2c sub $0x2c,%esp 113861: 8b 5d 08 mov 0x8(%ebp),%ebx 113864: 8b 75 0c mov 0xc(%ebp),%esi 113867: 8b 4d 10 mov 0x10(%ebp),%ecx 11386a: 8b 7d 18 mov 0x18(%ebp),%edi CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 11386d: 85 db test %ebx,%ebx 11386f: 74 2f je 1138a0 return RTEMS_INVALID_NAME; if ( !id ) 113871: 85 ff test %edi,%edi 113873: 0f 84 a3 00 00 00 je 11391c if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 113879: 85 f6 test %esi,%esi 11387b: 74 13 je 113890 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 11387d: 85 c9 test %ecx,%ecx 11387f: 75 2f jne 1138b0 return RTEMS_INVALID_SIZE; 113881: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113886: 8d 65 f4 lea -0xc(%ebp),%esp 113889: 5b pop %ebx 11388a: 5e pop %esi 11388b: 5f pop %edi 11388c: c9 leave 11388d: c3 ret 11388e: 66 90 xchg %ax,%ax !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) return RTEMS_INVALID_NUMBER; 113890: b8 0a 00 00 00 mov $0xa,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 113895: 8d 65 f4 lea -0xc(%ebp),%esp 113898: 5b pop %ebx 113899: 5e pop %esi 11389a: 5f pop %edi 11389b: c9 leave 11389c: c3 ret 11389d: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1138a0: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1138a5: 8d 65 f4 lea -0xc(%ebp),%esp 1138a8: 5b pop %ebx 1138a9: 5e pop %esi 1138aa: 5f pop %edi 1138ab: c9 leave 1138ac: c3 ret 1138ad: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 1138b0: a1 f0 0b 13 00 mov 0x130bf0,%eax 1138b5: 40 inc %eax 1138b6: a3 f0 0b 13 00 mov %eax,0x130bf0 #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp) 1138be: e8 d9 5f 00 00 call 11989c <_Message_queue_Allocate> 1138c3: 89 c2 mov %eax,%edx if ( !the_message_queue ) { 1138c5: 85 c0 test %eax,%eax 1138c7: 8b 4d d4 mov -0x2c(%ebp),%ecx 1138ca: 74 7c je 113948 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 1138cc: 8b 45 14 mov 0x14(%ebp),%eax 1138cf: 89 42 10 mov %eax,0x10(%edx) if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 1138d2: a8 04 test $0x4,%al 1138d4: 0f 95 c0 setne %al 1138d7: 0f b6 c0 movzbl %al,%eax 1138da: 89 45 e4 mov %eax,-0x1c(%ebp) else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 1138dd: 51 push %ecx 1138de: 56 push %esi 1138df: 8d 45 e4 lea -0x1c(%ebp),%eax 1138e2: 50 push %eax 1138e3: 8d 42 14 lea 0x14(%edx),%eax 1138e6: 50 push %eax 1138e7: 89 55 d4 mov %edx,-0x2c(%ebp) 1138ea: e8 31 11 00 00 call 114a20 <_CORE_message_queue_Initialize> 1138ef: 83 c4 10 add $0x10,%esp 1138f2: 84 c0 test %al,%al 1138f4: 8b 55 d4 mov -0x2c(%ebp),%edx 1138f7: 75 2f jne 113928 */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 1138f9: 83 ec 08 sub $0x8,%esp 1138fc: 52 push %edx 1138fd: 68 20 16 13 00 push $0x131620 113902: e8 b9 1f 00 00 call 1158c0 <_Objects_Free> _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 113907: e8 28 2c 00 00 call 116534 <_Thread_Enable_dispatch> return RTEMS_UNSATISFIED; 11390c: 83 c4 10 add $0x10,%esp 11390f: b8 0d 00 00 00 mov $0xd,%eax 113914: e9 6d ff ff ff jmp 113886 113919: 8d 76 00 lea 0x0(%esi),%esi if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 11391c: b8 09 00 00 00 mov $0x9,%eax 113921: e9 60 ff ff ff jmp 113886 113926: 66 90 xchg %ax,%ax Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 113928: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 11392b: 0f b7 f0 movzwl %ax,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 11392e: 8b 0d 3c 16 13 00 mov 0x13163c,%ecx 113934: 89 14 b1 mov %edx,(%ecx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 113937: 89 5a 0c mov %ebx,0xc(%edx) &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 11393a: 89 07 mov %eax,(%edi) name, 0 ); #endif _Thread_Enable_dispatch(); 11393c: e8 f3 2b 00 00 call 116534 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 113941: 31 c0 xor %eax,%eax 113943: e9 3e ff ff ff jmp 113886 _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 113948: e8 e7 2b 00 00 call 116534 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 11394d: b8 05 00 00 00 mov $0x5,%eax 113952: e9 2f ff ff ff jmp 113886 =============================================================================== 00116544 : */ rtems_status_code rtems_message_queue_delete( rtems_id id ) { 116544: 55 push %ebp 116545: 89 e5 mov %esp,%ebp 116547: 53 push %ebx 116548: 83 ec 18 sub $0x18,%esp register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); 11654b: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 11654e: 50 push %eax 11654f: ff 75 08 pushl 0x8(%ebp) 116552: 68 40 2c 14 00 push $0x142c40 116557: e8 88 4d 00 00 call 11b2e4 <_Objects_Get> 11655c: 89 c3 mov %eax,%ebx switch ( location ) { 11655e: 83 c4 10 add $0x10,%esp 116561: 8b 4d f4 mov -0xc(%ebp),%ecx 116564: 85 c9 test %ecx,%ecx 116566: 75 3c jne 1165a4 case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 116568: 83 ec 08 sub $0x8,%esp 11656b: 50 push %eax 11656c: 68 40 2c 14 00 push $0x142c40 116571: e8 f6 48 00 00 call 11ae6c <_Objects_Close> &the_message_queue->Object ); _CORE_message_queue_Close( 116576: 83 c4 0c add $0xc,%esp 116579: 6a 05 push $0x5 11657b: 6a 00 push $0x0 11657d: 8d 43 14 lea 0x14(%ebx),%eax 116580: 50 push %eax 116581: e8 de 33 00 00 call 119964 <_CORE_message_queue_Close> */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 116586: 58 pop %eax 116587: 5a pop %edx 116588: 53 push %ebx 116589: 68 40 2c 14 00 push $0x142c40 11658e: e8 d5 4b 00 00 call 11b168 <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 116593: e8 00 58 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116598: 83 c4 10 add $0x10,%esp 11659b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11659d: 8b 5d fc mov -0x4(%ebp),%ebx 1165a0: c9 leave 1165a1: c3 ret 1165a2: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1165a4: b8 04 00 00 00 mov $0x4,%eax } 1165a9: 8b 5d fc mov -0x4(%ebp),%ebx 1165ac: c9 leave 1165ad: c3 ret =============================================================================== 001165b0 : rtems_status_code rtems_message_queue_flush( rtems_id id, uint32_t *count ) { 1165b0: 55 push %ebp 1165b1: 89 e5 mov %esp,%ebp 1165b3: 53 push %ebx 1165b4: 83 ec 14 sub $0x14,%esp 1165b7: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1165ba: 85 db test %ebx,%ebx 1165bc: 74 46 je 116604 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 1165be: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1165bf: 8d 45 f4 lea -0xc(%ebp),%eax 1165c2: 50 push %eax 1165c3: ff 75 08 pushl 0x8(%ebp) 1165c6: 68 40 2c 14 00 push $0x142c40 1165cb: e8 14 4d 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 1165d0: 83 c4 10 add $0x10,%esp 1165d3: 8b 55 f4 mov -0xc(%ebp),%edx 1165d6: 85 d2 test %edx,%edx 1165d8: 74 0a je 1165e4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1165da: b8 04 00 00 00 mov $0x4,%eax } 1165df: 8b 5d fc mov -0x4(%ebp),%ebx 1165e2: c9 leave 1165e3: c3 ret the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 1165e4: 83 ec 0c sub $0xc,%esp 1165e7: 83 c0 14 add $0x14,%eax 1165ea: 50 push %eax 1165eb: e8 b0 33 00 00 call 1199a0 <_CORE_message_queue_Flush> 1165f0: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 1165f2: e8 a1 57 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1165f7: 83 c4 10 add $0x10,%esp 1165fa: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1165fc: 8b 5d fc mov -0x4(%ebp),%ebx 1165ff: c9 leave 116600: c3 ret 116601: 8d 76 00 lea 0x0(%esi),%esi { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 116604: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116609: 8b 5d fc mov -0x4(%ebp),%ebx 11660c: c9 leave 11660d: c3 ret =============================================================================== 00116610 : rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 116610: 55 push %ebp 116611: 89 e5 mov %esp,%ebp 116613: 53 push %ebx 116614: 83 ec 14 sub $0x14,%esp 116617: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 11661a: 85 db test %ebx,%ebx 11661c: 74 3a je 116658 11661e: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 11661f: 8d 45 f4 lea -0xc(%ebp),%eax 116622: 50 push %eax 116623: ff 75 08 pushl 0x8(%ebp) 116626: 68 40 2c 14 00 push $0x142c40 11662b: e8 b4 4c 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 116630: 83 c4 10 add $0x10,%esp 116633: 8b 55 f4 mov -0xc(%ebp),%edx 116636: 85 d2 test %edx,%edx 116638: 74 0a je 116644 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11663a: b8 04 00 00 00 mov $0x4,%eax } 11663f: 8b 5d fc mov -0x4(%ebp),%ebx 116642: c9 leave 116643: c3 ret the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 116644: 8b 40 5c mov 0x5c(%eax),%eax 116647: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 116649: e8 4a 57 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11664e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116650: 8b 5d fc mov -0x4(%ebp),%ebx 116653: c9 leave 116654: c3 ret 116655: 8d 76 00 lea 0x0(%esi),%esi { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 116658: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11665d: 8b 5d fc mov -0x4(%ebp),%ebx 116660: c9 leave 116661: c3 ret =============================================================================== 0011397c : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 11397c: 55 push %ebp 11397d: 89 e5 mov %esp,%ebp 11397f: 56 push %esi 113980: 53 push %ebx 113981: 83 ec 10 sub $0x10,%esp 113984: 8b 5d 0c mov 0xc(%ebp),%ebx 113987: 8b 75 10 mov 0x10(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 11398a: 85 db test %ebx,%ebx 11398c: 74 6e je 1139fc return RTEMS_INVALID_ADDRESS; if ( !size ) 11398e: 85 f6 test %esi,%esi 113990: 74 6a je 1139fc Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 113992: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 113993: 8d 45 f4 lea -0xc(%ebp),%eax 113996: 50 push %eax 113997: ff 75 08 pushl 0x8(%ebp) 11399a: 68 20 16 13 00 push $0x131620 11399f: e8 5c 20 00 00 call 115a00 <_Objects_Get> switch ( location ) { 1139a4: 83 c4 10 add $0x10,%esp 1139a7: 8b 55 f4 mov -0xc(%ebp),%edx 1139aa: 85 d2 test %edx,%edx 1139ac: 75 42 jne 1139f0 if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 1139ae: 83 ec 08 sub $0x8,%esp 1139b1: ff 75 18 pushl 0x18(%ebp) */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 1139b4: 8b 55 14 mov 0x14(%ebp),%edx 1139b7: 83 e2 01 and $0x1,%edx 1139ba: 83 f2 01 xor $0x1,%edx 1139bd: 52 push %edx 1139be: 56 push %esi 1139bf: 53 push %ebx 1139c0: ff 70 08 pushl 0x8(%eax) 1139c3: 83 c0 14 add $0x14,%eax 1139c6: 50 push %eax 1139c7: e8 04 11 00 00 call 114ad0 <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 1139cc: 83 c4 20 add $0x20,%esp 1139cf: e8 60 2b 00 00 call 116534 <_Thread_Enable_dispatch> return _Message_queue_Translate_core_message_queue_return_code( 1139d4: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code 1139d7: a1 d8 11 13 00 mov 0x1311d8,%eax size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1139dc: ff 70 34 pushl 0x34(%eax) 1139df: e8 a0 00 00 00 call 113a84 <_Message_queue_Translate_core_message_queue_return_code> 1139e4: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1139e7: 8d 65 f8 lea -0x8(%ebp),%esp 1139ea: 5b pop %ebx 1139eb: 5e pop %esi 1139ec: c9 leave 1139ed: c3 ret 1139ee: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1139f0: b8 04 00 00 00 mov $0x4,%eax } 1139f5: 8d 65 f8 lea -0x8(%ebp),%esp 1139f8: 5b pop %ebx 1139f9: 5e pop %esi 1139fa: c9 leave 1139fb: c3 ret if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 1139fc: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113a01: 8d 65 f8 lea -0x8(%ebp),%esp 113a04: 5b pop %ebx 113a05: 5e pop %esi 113a06: c9 leave 113a07: c3 ret =============================================================================== 0010b3a8 : rtems_status_code rtems_message_queue_send( rtems_id id, const void *buffer, size_t size ) { 10b3a8: 55 push %ebp 10b3a9: 89 e5 mov %esp,%ebp 10b3ab: 56 push %esi 10b3ac: 53 push %ebx 10b3ad: 83 ec 10 sub $0x10,%esp 10b3b0: 8b 75 08 mov 0x8(%ebp),%esi 10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10b3b6: 85 db test %ebx,%ebx 10b3b8: 74 5e je 10b418 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 10b3ba: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: 56 push %esi 10b3c0: 68 a0 7f 12 00 push $0x127fa0 10b3c5: e8 76 1a 00 00 call 10ce40 <_Objects_Get> switch ( location ) { 10b3ca: 83 c4 10 add $0x10,%esp 10b3cd: 8b 55 f4 mov -0xc(%ebp),%edx 10b3d0: 85 d2 test %edx,%edx 10b3d2: 74 0c je 10b3e0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b3d4: b8 04 00 00 00 mov $0x4,%eax } 10b3d9: 8d 65 f8 lea -0x8(%ebp),%esp 10b3dc: 5b pop %ebx 10b3dd: 5e pop %esi 10b3de: c9 leave 10b3df: c3 ret CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 10b3e0: 6a 00 push $0x0 10b3e2: 6a 00 push $0x0 10b3e4: 68 ff ff ff 7f push $0x7fffffff 10b3e9: 6a 00 push $0x0 10b3eb: 56 push %esi 10b3ec: ff 75 10 pushl 0x10(%ebp) 10b3ef: 53 push %ebx the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_message_queue_Send( 10b3f0: 83 c0 14 add $0x14,%eax 10b3f3: 50 push %eax 10b3f4: e8 43 0c 00 00 call 10c03c <_CORE_message_queue_Submit> 10b3f9: 89 c3 mov %eax,%ebx MESSAGE_QUEUE_MP_HANDLER, false, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 10b3fb: 83 c4 20 add $0x20,%esp 10b3fe: e8 f1 24 00 00 call 10d8f4 <_Thread_Enable_dispatch> /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 10b403: 83 ec 0c sub $0xc,%esp 10b406: 53 push %ebx 10b407: e8 18 00 00 00 call 10b424 <_Message_queue_Translate_core_message_queue_return_code> 10b40c: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b40f: 8d 65 f8 lea -0x8(%ebp),%esp 10b412: 5b pop %ebx 10b413: 5e pop %esi 10b414: c9 leave 10b415: c3 ret 10b416: 66 90 xchg %ax,%ax register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 10b418: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b41d: 8d 65 f8 lea -0x8(%ebp),%esp 10b420: 5b pop %ebx 10b421: 5e pop %esi 10b422: c9 leave 10b423: c3 ret =============================================================================== 001167a0 : rtems_status_code rtems_message_queue_urgent( rtems_id id, const void *buffer, size_t size ) { 1167a0: 55 push %ebp 1167a1: 89 e5 mov %esp,%ebp 1167a3: 56 push %esi 1167a4: 53 push %ebx 1167a5: 83 ec 10 sub $0x10,%esp 1167a8: 8b 75 08 mov 0x8(%ebp),%esi 1167ab: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 1167ae: 85 db test %ebx,%ebx 1167b0: 74 5e je 116810 1167b2: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1167b3: 8d 45 f4 lea -0xc(%ebp),%eax 1167b6: 50 push %eax 1167b7: 56 push %esi 1167b8: 68 40 2c 14 00 push $0x142c40 1167bd: e8 22 4b 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 1167c2: 83 c4 10 add $0x10,%esp 1167c5: 8b 55 f4 mov -0xc(%ebp),%edx 1167c8: 85 d2 test %edx,%edx 1167ca: 74 0c je 1167d8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1167cc: b8 04 00 00 00 mov $0x4,%eax } 1167d1: 8d 65 f8 lea -0x8(%ebp),%esp 1167d4: 5b pop %ebx 1167d5: 5e pop %esi 1167d6: c9 leave 1167d7: c3 ret CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 1167d8: 6a 00 push $0x0 1167da: 6a 00 push $0x0 1167dc: 68 00 00 00 80 push $0x80000000 1167e1: 6a 00 push $0x0 1167e3: 56 push %esi 1167e4: ff 75 10 pushl 0x10(%ebp) 1167e7: 53 push %ebx the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_message_queue_Urgent( 1167e8: 83 c0 14 add $0x14,%eax 1167eb: 50 push %eax 1167ec: e8 ef 33 00 00 call 119be0 <_CORE_message_queue_Submit> 1167f1: 89 c3 mov %eax,%ebx id, MESSAGE_QUEUE_MP_HANDLER, false, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 1167f3: 83 c4 20 add $0x20,%esp 1167f6: e8 9d 55 00 00 call 11bd98 <_Thread_Enable_dispatch> /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 1167fb: 83 ec 0c sub $0xc,%esp 1167fe: 53 push %ebx 1167ff: e8 8c ff ff ff call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116804: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116807: 8d 65 f8 lea -0x8(%ebp),%esp 11680a: 5b pop %ebx 11680b: 5e pop %esi 11680c: c9 leave 11680d: c3 ret 11680e: 66 90 xchg %ax,%ax register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 116810: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116815: 8d 65 f8 lea -0x8(%ebp),%esp 116818: 5b pop %ebx 116819: 5e pop %esi 11681a: c9 leave 11681b: c3 ret =============================================================================== 0010b978 : }; const char *rtems_object_get_api_name( int api ) { 10b978: 55 push %ebp 10b979: 89 e5 mov %esp,%ebp 10b97b: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10b97e: ff 75 08 pushl 0x8(%ebp) 10b981: 68 60 74 12 00 push $0x127460 10b986: e8 b9 49 00 00 call 110344 if ( api_assoc ) 10b98b: 83 c4 10 add $0x10,%esp 10b98e: 85 c0 test %eax,%eax 10b990: 74 06 je 10b998 return api_assoc->name; 10b992: 8b 00 mov (%eax),%eax return "BAD CLASS"; } 10b994: c9 leave 10b995: c3 ret 10b996: 66 90 xchg %ax,%ax const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); if ( api_assoc ) return api_assoc->name; return "BAD CLASS"; 10b998: b8 43 24 12 00 mov $0x122443,%eax } 10b99d: c9 leave 10b99e: c3 ret =============================================================================== 0010cf60 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 10cf60: 55 push %ebp 10cf61: 89 e5 mov %esp,%ebp 10cf63: 57 push %edi 10cf64: 56 push %esi 10cf65: 53 push %ebx 10cf66: 83 ec 0c sub $0xc,%esp 10cf69: 8b 5d 10 mov 0x10(%ebp),%ebx int i; /* * Validate parameters and look up information structure. */ if ( !info ) 10cf6c: 85 db test %ebx,%ebx 10cf6e: 74 60 je 10cfd0 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10cf70: 83 ec 08 sub $0x8,%esp 10cf73: 0f b7 45 0c movzwl 0xc(%ebp),%eax 10cf77: 50 push %eax 10cf78: ff 75 08 pushl 0x8(%ebp) 10cf7b: e8 54 1b 00 00 call 10ead4 <_Objects_Get_information> if ( !obj_info ) 10cf80: 83 c4 10 add $0x10,%esp 10cf83: 85 c0 test %eax,%eax 10cf85: 74 59 je 10cfe0 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10cf87: 8b 50 08 mov 0x8(%eax),%edx 10cf8a: 89 13 mov %edx,(%ebx) info->maximum_id = obj_info->maximum_id; 10cf8c: 8b 50 0c mov 0xc(%eax),%edx 10cf8f: 89 53 04 mov %edx,0x4(%ebx) info->auto_extend = obj_info->auto_extend; 10cf92: 8a 50 12 mov 0x12(%eax),%dl 10cf95: 88 53 0c mov %dl,0xc(%ebx) info->maximum = obj_info->maximum; 10cf98: 0f b7 70 10 movzwl 0x10(%eax),%esi 10cf9c: 89 73 08 mov %esi,0x8(%ebx) for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10cf9f: 85 f6 test %esi,%esi 10cfa1: 74 44 je 10cfe7 <== NEVER TAKEN 10cfa3: 8b 78 1c mov 0x1c(%eax),%edi 10cfa6: b9 01 00 00 00 mov $0x1,%ecx 10cfab: b8 01 00 00 00 mov $0x1,%eax 10cfb0: 31 d2 xor %edx,%edx 10cfb2: 66 90 xchg %ax,%ax if ( !obj_info->local_table[i] ) unallocated++; 10cfb4: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4) 10cfb8: 83 d2 00 adc $0x0,%edx info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10cfbb: 40 inc %eax 10cfbc: 89 c1 mov %eax,%ecx 10cfbe: 39 c6 cmp %eax,%esi 10cfc0: 73 f2 jae 10cfb4 if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10cfc2: 89 53 10 mov %edx,0x10(%ebx) return RTEMS_SUCCESSFUL; 10cfc5: 31 c0 xor %eax,%eax } 10cfc7: 8d 65 f4 lea -0xc(%ebp),%esp 10cfca: 5b pop %ebx 10cfcb: 5e pop %esi 10cfcc: 5f pop %edi 10cfcd: c9 leave 10cfce: c3 ret 10cfcf: 90 nop /* * Validate parameters and look up information structure. */ if ( !info ) return RTEMS_INVALID_ADDRESS; 10cfd0: b8 09 00 00 00 mov $0x9,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10cfd5: 8d 65 f4 lea -0xc(%ebp),%esp 10cfd8: 5b pop %ebx 10cfd9: 5e pop %esi 10cfda: 5f pop %edi 10cfdb: c9 leave 10cfdc: c3 ret 10cfdd: 8d 76 00 lea 0x0(%esi),%esi if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) return RTEMS_INVALID_NUMBER; 10cfe0: b8 0a 00 00 00 mov $0xa,%eax 10cfe5: eb e0 jmp 10cfc7 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10cfe7: 31 d2 xor %edx,%edx 10cfe9: eb d7 jmp 10cfc2 =============================================================================== 0010c520 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 10c520: 55 push %ebp 10c521: 89 e5 mov %esp,%ebp 10c523: 53 push %ebx 10c524: 83 ec 14 sub $0x14,%esp 10c527: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10c52a: 85 db test %ebx,%ebx 10c52c: 74 26 je 10c554 return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 10c52e: 83 ec 08 sub $0x8,%esp 10c531: 8d 45 f4 lea -0xc(%ebp),%eax 10c534: 50 push %eax 10c535: ff 75 08 pushl 0x8(%ebp) 10c538: e8 af 1b 00 00 call 10e0ec <_Objects_Id_to_name> *name = name_u.name_u32; 10c53d: 8b 55 f4 mov -0xc(%ebp),%edx 10c540: 89 13 mov %edx,(%ebx) return _Status_Object_name_errors_to_status[ status ]; 10c542: 8b 04 85 2c 30 12 00 mov 0x12302c(,%eax,4),%eax 10c549: 83 c4 10 add $0x10,%esp } 10c54c: 8b 5d fc mov -0x4(%ebp),%ebx 10c54f: c9 leave 10c550: c3 ret 10c551: 8d 76 00 lea 0x0(%esi),%esi { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) return RTEMS_INVALID_ADDRESS; 10c554: b8 09 00 00 00 mov $0x9,%eax status = _Objects_Id_to_name( id, &name_u ); *name = name_u.name_u32; return _Status_Object_name_errors_to_status[ status ]; } 10c559: 8b 5d fc mov -0x4(%ebp),%ebx 10c55c: c9 leave 10c55d: c3 ret =============================================================================== 0010b9ac : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 57 push %edi 10b9b0: 56 push %esi 10b9b1: 53 push %ebx 10b9b2: 83 ec 1c sub $0x1c,%esp 10b9b5: 8b 75 08 mov 0x8(%ebp),%esi 10b9b8: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b9bb: 85 ff test %edi,%edi 10b9bd: 74 61 je 10ba20 return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b9bf: 85 f6 test %esi,%esi 10b9c1: 74 35 je 10b9f8 information = _Objects_Get_information_id( tmpId ); 10b9c3: 83 ec 0c sub $0xc,%esp 10b9c6: 56 push %esi 10b9c7: e8 2c 19 00 00 call 10d2f8 <_Objects_Get_information_id> 10b9cc: 89 c3 mov %eax,%ebx if ( !information ) 10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 85 c0 test %eax,%eax 10b9d3: 74 16 je 10b9eb return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10b9d5: 50 push %eax 10b9d6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b9d9: 50 push %eax 10b9da: 56 push %esi 10b9db: 53 push %ebx 10b9dc: e8 cf 1a 00 00 call 10d4b0 <_Objects_Get> switch ( location ) { 10b9e1: 83 c4 10 add $0x10,%esp 10b9e4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b9e7: 85 c9 test %ecx,%ecx 10b9e9: 74 19 je 10ba04 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b9eb: b8 04 00 00 00 mov $0x4,%eax } 10b9f0: 8d 65 f4 lea -0xc(%ebp),%esp 10b9f3: 5b pop %ebx 10b9f4: 5e pop %esi 10b9f5: 5f pop %edi 10b9f6: c9 leave 10b9f7: c3 ret Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b9f8: a1 18 9e 12 00 mov 0x129e18,%eax 10b9fd: 8b 70 08 mov 0x8(%eax),%esi 10ba00: eb c1 jmp 10b9c3 10ba02: 66 90 xchg %ax,%ax the_object = _Objects_Get( information, tmpId, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10ba04: 52 push %edx 10ba05: 57 push %edi 10ba06: 50 push %eax 10ba07: 53 push %ebx 10ba08: e8 9f 1c 00 00 call 10d6ac <_Objects_Set_name> _Thread_Enable_dispatch(); 10ba0d: e8 36 26 00 00 call 10e048 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ba12: 83 c4 10 add $0x10,%esp 10ba15: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba17: 8d 65 f4 lea -0xc(%ebp),%esp 10ba1a: 5b pop %ebx 10ba1b: 5e pop %esi 10ba1c: 5f pop %edi 10ba1d: c9 leave 10ba1e: c3 ret 10ba1f: 90 nop Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; 10ba20: b8 09 00 00 00 mov $0x9,%eax 10ba25: eb c9 jmp 10b9f0 =============================================================================== 0011681c : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 11681c: 55 push %ebp 11681d: 89 e5 mov %esp,%ebp 11681f: 57 push %edi 116820: 56 push %esi 116821: 53 push %ebx 116822: 83 ec 1c sub $0x1c,%esp 116825: 8b 5d 08 mov 0x8(%ebp),%ebx 116828: 8b 75 0c mov 0xc(%ebp),%esi 11682b: 8b 55 10 mov 0x10(%ebp),%edx 11682e: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 116831: 85 db test %ebx,%ebx 116833: 74 47 je 11687c return RTEMS_INVALID_NAME; if ( !starting_address ) 116835: 85 f6 test %esi,%esi 116837: 74 23 je 11685c return RTEMS_INVALID_ADDRESS; if ( !id ) 116839: 8b 45 1c mov 0x1c(%ebp),%eax 11683c: 85 c0 test %eax,%eax 11683e: 74 1c je 11685c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 116840: 85 d2 test %edx,%edx 116842: 74 28 je 11686c 116844: 85 ff test %edi,%edi 116846: 74 24 je 11686c 116848: 39 fa cmp %edi,%edx 11684a: 72 20 jb 11686c 11684c: f7 c7 03 00 00 00 test $0x3,%edi 116852: 75 18 jne 11686c !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 116854: f7 c6 03 00 00 00 test $0x3,%esi 11685a: 74 30 je 11688c return RTEMS_INVALID_ADDRESS; 11685c: b8 09 00 00 00 mov $0x9,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 116861: 8d 65 f4 lea -0xc(%ebp),%esp 116864: 5b pop %ebx 116865: 5e pop %esi 116866: 5f pop %edi 116867: c9 leave 116868: c3 ret 116869: 8d 76 00 lea 0x0(%esi),%esi 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; 11686c: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 116871: 8d 65 f4 lea -0xc(%ebp),%esp 116874: 5b pop %ebx 116875: 5e pop %esi 116876: 5f pop %edi 116877: c9 leave 116878: c3 ret 116879: 8d 76 00 lea 0x0(%esi),%esi ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 11687c: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 116881: 8d 65 f4 lea -0xc(%ebp),%esp 116884: 5b pop %ebx 116885: 5e pop %esi 116886: 5f pop %edi 116887: c9 leave 116888: c3 ret 116889: 8d 76 00 lea 0x0(%esi),%esi 11688c: a1 10 22 14 00 mov 0x142210,%eax 116891: 40 inc %eax 116892: a3 10 22 14 00 mov %eax,0x142210 * 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 ); 116897: 83 ec 0c sub $0xc,%esp 11689a: 68 a0 20 14 00 push $0x1420a0 11689f: 89 55 e0 mov %edx,-0x20(%ebp) 1168a2: e8 49 45 00 00 call 11adf0 <_Objects_Allocate> 1168a7: 89 45 e4 mov %eax,-0x1c(%ebp) _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1168aa: 83 c4 10 add $0x10,%esp 1168ad: 85 c0 test %eax,%eax 1168af: 8b 55 e0 mov -0x20(%ebp),%edx 1168b2: 74 58 je 11690c _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 1168b4: 8b 45 e4 mov -0x1c(%ebp),%eax 1168b7: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 1168ba: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 1168bd: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 1168c0: 8b 4d 18 mov 0x18(%ebp),%ecx 1168c3: 89 48 1c mov %ecx,0x1c(%eax) the_partition->number_of_used_blocks = 0; 1168c6: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) _Chain_Initialize( &the_partition->Memory, starting_address, 1168cd: 57 push %edi 1168ce: 89 d0 mov %edx,%eax 1168d0: 31 d2 xor %edx,%edx 1168d2: f7 f7 div %edi 1168d4: 50 push %eax 1168d5: 56 push %esi 1168d6: 8b 45 e4 mov -0x1c(%ebp),%eax 1168d9: 83 c0 24 add $0x24,%eax 1168dc: 50 push %eax 1168dd: e8 a2 2f 00 00 call 119884 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1168e2: 8b 7d e4 mov -0x1c(%ebp),%edi 1168e5: 8b 47 08 mov 0x8(%edi),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1168e8: 0f b7 f0 movzwl %ax,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1168eb: 8b 15 bc 20 14 00 mov 0x1420bc,%edx 1168f1: 89 3c b2 mov %edi,(%edx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1168f4: 89 5f 0c mov %ebx,0xc(%edi) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1168f7: 8b 55 1c mov 0x1c(%ebp),%edx 1168fa: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1168fc: e8 97 54 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116901: 83 c4 10 add $0x10,%esp 116904: 31 c0 xor %eax,%eax 116906: e9 66 ff ff ff jmp 116871 11690b: 90 nop _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 11690c: e8 87 54 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 116911: b8 05 00 00 00 mov $0x5,%eax 116916: e9 56 ff ff ff jmp 116871 =============================================================================== 00116988 : rtems_status_code rtems_partition_get_buffer( rtems_id id, void **buffer ) { 116988: 55 push %ebp 116989: 89 e5 mov %esp,%ebp 11698b: 56 push %esi 11698c: 53 push %ebx 11698d: 83 ec 20 sub $0x20,%esp 116990: 8b 5d 0c mov 0xc(%ebp),%ebx register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 116993: 85 db test %ebx,%ebx 116995: 74 59 je 1169f0 Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 116997: 52 push %edx return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); 116998: 8d 45 f4 lea -0xc(%ebp),%eax 11699b: 50 push %eax 11699c: ff 75 08 pushl 0x8(%ebp) 11699f: 68 a0 20 14 00 push $0x1420a0 1169a4: e8 3b 49 00 00 call 11b2e4 <_Objects_Get> 1169a9: 89 c6 mov %eax,%esi switch ( location ) { 1169ab: 83 c4 10 add $0x10,%esp 1169ae: 8b 45 f4 mov -0xc(%ebp),%eax 1169b1: 85 c0 test %eax,%eax 1169b3: 75 2f jne 1169e4 */ RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 1169b5: 83 ec 0c sub $0xc,%esp 1169b8: 8d 46 24 lea 0x24(%esi),%eax 1169bb: 50 push %eax 1169bc: e8 9f 2e 00 00 call 119860 <_Chain_Get> case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 1169c1: 83 c4 10 add $0x10,%esp 1169c4: 85 c0 test %eax,%eax 1169c6: 74 34 je 1169fc the_partition->number_of_used_blocks += 1; 1169c8: ff 46 20 incl 0x20(%esi) _Thread_Enable_dispatch(); 1169cb: 89 45 e4 mov %eax,-0x1c(%ebp) 1169ce: e8 c5 53 00 00 call 11bd98 <_Thread_Enable_dispatch> *buffer = the_buffer; 1169d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1169d6: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 1169d8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1169da: 8d 65 f8 lea -0x8(%ebp),%esp 1169dd: 5b pop %ebx 1169de: 5e pop %esi 1169df: c9 leave 1169e0: c3 ret 1169e1: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1169e4: b8 04 00 00 00 mov $0x4,%eax } 1169e9: 8d 65 f8 lea -0x8(%ebp),%esp 1169ec: 5b pop %ebx 1169ed: 5e pop %esi 1169ee: c9 leave 1169ef: c3 ret register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 1169f0: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1169f5: 8d 65 f8 lea -0x8(%ebp),%esp 1169f8: 5b pop %ebx 1169f9: 5e pop %esi 1169fa: c9 leave 1169fb: c3 ret the_partition->number_of_used_blocks += 1; _Thread_Enable_dispatch(); *buffer = the_buffer; return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1169fc: e8 97 53 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_UNSATISFIED; 116a01: b8 0d 00 00 00 mov $0xd,%eax 116a06: eb e1 jmp 1169e9 =============================================================================== 00116a2c : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 116a2c: 55 push %ebp 116a2d: 89 e5 mov %esp,%ebp 116a2f: 56 push %esi 116a30: 53 push %ebx 116a31: 83 ec 14 sub $0x14,%esp 116a34: 8b 75 0c mov 0xc(%ebp),%esi register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); 116a37: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 116a3a: 50 push %eax 116a3b: ff 75 08 pushl 0x8(%ebp) 116a3e: 68 a0 20 14 00 push $0x1420a0 116a43: e8 9c 48 00 00 call 11b2e4 <_Objects_Get> 116a48: 89 c3 mov %eax,%ebx switch ( location ) { 116a4a: 83 c4 10 add $0x10,%esp 116a4d: 8b 45 f4 mov -0xc(%ebp),%eax 116a50: 85 c0 test %eax,%eax 116a52: 74 0c je 116a60 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 116a54: b8 04 00 00 00 mov $0x4,%eax } 116a59: 8d 65 f8 lea -0x8(%ebp),%esp 116a5c: 5b pop %ebx 116a5d: 5e pop %esi 116a5e: c9 leave 116a5f: c3 ret ) { void *starting; void *ending; starting = the_partition->starting_address; 116a60: 8b 43 10 mov 0x10(%ebx),%eax ending = _Addresses_Add_offset( starting, the_partition->length ); 116a63: 8b 53 14 mov 0x14(%ebx),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 116a66: 39 c6 cmp %eax,%esi 116a68: 72 3a jb 116aa4 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 116a6a: 8d 14 10 lea (%eax,%edx,1),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 116a6d: 39 d6 cmp %edx,%esi 116a6f: 77 33 ja 116aa4 <== NEVER TAKEN RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 116a71: 89 f2 mov %esi,%edx 116a73: 29 c2 sub %eax,%edx 116a75: 89 d0 mov %edx,%eax offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 116a77: 31 d2 xor %edx,%edx 116a79: f7 73 18 divl 0x18(%ebx) starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 116a7c: 85 d2 test %edx,%edx 116a7e: 75 24 jne 116aa4 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 116a80: 83 ec 08 sub $0x8,%esp 116a83: 56 push %esi 116a84: 8d 43 24 lea 0x24(%ebx),%eax 116a87: 50 push %eax 116a88: e8 97 2d 00 00 call 119824 <_Chain_Append> switch ( location ) { case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 116a8d: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 116a90: e8 03 53 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116a95: 83 c4 10 add $0x10,%esp 116a98: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116a9a: 8d 65 f8 lea -0x8(%ebp),%esp 116a9d: 5b pop %ebx 116a9e: 5e pop %esi 116a9f: c9 leave 116aa0: c3 ret 116aa1: 8d 76 00 lea 0x0(%esi),%esi _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 116aa4: e8 ef 52 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 116aa9: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116aae: 8d 65 f8 lea -0x8(%ebp),%esp 116ab1: 5b pop %ebx 116ab2: 5e pop %esi 116ab3: c9 leave 116ab4: c3 ret =============================================================================== 00115e50 : void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 115e50: 55 push %ebp 115e51: 89 e5 mov %esp,%ebp 115e53: 57 push %edi 115e54: 56 push %esi 115e55: 53 push %ebx 115e56: 83 ec 1c sub $0x1c,%esp 115e59: 8b 5d 08 mov 0x8(%ebp),%ebx 115e5c: 8b 55 0c mov 0xc(%ebp),%edx 115e5f: 8b 7d 10 mov 0x10(%ebp),%edi 115e62: 8b 75 18 mov 0x18(%ebp),%esi register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 115e65: 85 db test %ebx,%ebx 115e67: 74 1b je 115e84 return RTEMS_INVALID_NAME; if ( !id ) 115e69: 85 f6 test %esi,%esi 115e6b: 74 08 je 115e75 * id - port id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_port_create( 115e6d: 89 f8 mov %edi,%eax 115e6f: 09 d0 or %edx,%eax return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 115e71: a8 03 test $0x3,%al 115e73: 74 1f je 115e94 !_Addresses_Is_aligned( external_start ) ) return RTEMS_INVALID_ADDRESS; 115e75: b8 09 00 00 00 mov $0x9,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 115e7a: 8d 65 f4 lea -0xc(%ebp),%esp 115e7d: 5b pop %ebx 115e7e: 5e pop %esi 115e7f: 5f pop %edi 115e80: c9 leave 115e81: c3 ret 115e82: 66 90 xchg %ax,%ax ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 115e84: b8 03 00 00 00 mov $0x3,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 115e89: 8d 65 f4 lea -0xc(%ebp),%esp 115e8c: 5b pop %ebx 115e8d: 5e pop %esi 115e8e: 5f pop %edi 115e8f: c9 leave 115e90: c3 ret 115e91: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 115e94: a1 10 22 14 00 mov 0x142210,%eax 115e99: 40 inc %eax 115e9a: a3 10 22 14 00 mov %eax,0x142210 */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) _Objects_Allocate( &_Dual_ported_memory_Information ); 115e9f: 83 ec 0c sub $0xc,%esp 115ea2: 68 60 20 14 00 push $0x142060 115ea7: 89 55 e4 mov %edx,-0x1c(%ebp) 115eaa: e8 41 4f 00 00 call 11adf0 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 115eaf: 83 c4 10 add $0x10,%esp 115eb2: 85 c0 test %eax,%eax 115eb4: 8b 55 e4 mov -0x1c(%ebp),%edx 115eb7: 74 33 je 115eec _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 115eb9: 89 50 10 mov %edx,0x10(%eax) the_port->external_base = external_start; 115ebc: 89 78 14 mov %edi,0x14(%eax) the_port->length = length - 1; 115ebf: 8b 55 14 mov 0x14(%ebp),%edx 115ec2: 4a dec %edx 115ec3: 89 50 18 mov %edx,0x18(%eax) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 115ec6: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 115ec9: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 115ecc: 8b 0d 7c 20 14 00 mov 0x14207c,%ecx 115ed2: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 115ed5: 89 58 0c mov %ebx,0xc(%eax) &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 115ed8: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 115eda: e8 b9 5e 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115edf: 31 c0 xor %eax,%eax } 115ee1: 8d 65 f4 lea -0xc(%ebp),%esp 115ee4: 5b pop %ebx 115ee5: 5e pop %esi 115ee6: 5f pop %edi 115ee7: c9 leave 115ee8: c3 ret 115ee9: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { _Thread_Enable_dispatch(); 115eec: e8 a7 5e 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 115ef1: b8 05 00 00 00 mov $0x5,%eax 115ef6: eb 82 jmp 115e7a =============================================================================== 00115ef8 : */ rtems_status_code rtems_port_delete( rtems_id id ) { 115ef8: 55 push %ebp 115ef9: 89 e5 mov %esp,%ebp 115efb: 83 ec 2c sub $0x2c,%esp register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); 115efe: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) _Objects_Get( &_Dual_ported_memory_Information, id, location ); 115f01: 50 push %eax 115f02: ff 75 08 pushl 0x8(%ebp) 115f05: 68 60 20 14 00 push $0x142060 115f0a: e8 d5 53 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 115f0f: 83 c4 10 add $0x10,%esp 115f12: 8b 4d f4 mov -0xc(%ebp),%ecx 115f15: 85 c9 test %ecx,%ecx 115f17: 75 2f jne 115f48 case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 115f19: 83 ec 08 sub $0x8,%esp 115f1c: 50 push %eax 115f1d: 68 60 20 14 00 push $0x142060 115f22: 89 45 e4 mov %eax,-0x1c(%ebp) 115f25: e8 42 4f 00 00 call 11ae6c <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free ( Dual_ported_memory_Control *the_port ) { _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object ); 115f2a: 58 pop %eax 115f2b: 5a pop %edx 115f2c: 8b 45 e4 mov -0x1c(%ebp),%eax 115f2f: 50 push %eax 115f30: 68 60 20 14 00 push $0x142060 115f35: e8 2e 52 00 00 call 11b168 <_Objects_Free> _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 115f3a: e8 59 5e 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115f3f: 83 c4 10 add $0x10,%esp 115f42: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115f44: c9 leave 115f45: c3 ret 115f46: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115f48: b8 04 00 00 00 mov $0x4,%eax } 115f4d: c9 leave 115f4e: c3 ret =============================================================================== 00115f50 : rtems_status_code rtems_port_external_to_internal( rtems_id id, void *external, void **internal ) { 115f50: 55 push %ebp 115f51: 89 e5 mov %esp,%ebp 115f53: 56 push %esi 115f54: 53 push %ebx 115f55: 83 ec 10 sub $0x10,%esp 115f58: 8b 75 0c mov 0xc(%ebp),%esi 115f5b: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 115f5e: 85 db test %ebx,%ebx 115f60: 74 4e je 115fb0 Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) _Objects_Get( &_Dual_ported_memory_Information, id, location ); 115f62: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); 115f63: 8d 45 f4 lea -0xc(%ebp),%eax 115f66: 50 push %eax 115f67: ff 75 08 pushl 0x8(%ebp) 115f6a: 68 60 20 14 00 push $0x142060 115f6f: e8 70 53 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 115f74: 83 c4 10 add $0x10,%esp 115f77: 8b 55 f4 mov -0xc(%ebp),%edx 115f7a: 85 d2 test %edx,%edx 115f7c: 74 0e je 115f8c #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115f7e: b8 04 00 00 00 mov $0x4,%eax } 115f83: 8d 65 f8 lea -0x8(%ebp),%esp 115f86: 5b pop %ebx 115f87: 5e pop %esi 115f88: c9 leave 115f89: c3 ret 115f8a: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 115f8c: 89 f2 mov %esi,%edx 115f8e: 2b 50 14 sub 0x14(%eax),%edx the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 115f91: 3b 50 18 cmp 0x18(%eax),%edx 115f94: 77 16 ja 115fac RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 115f96: 03 50 10 add 0x10(%eax),%edx 115f99: 89 13 mov %edx,(%ebx) *internal = external; else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 115f9b: e8 f8 5d 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115fa0: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115fa2: 8d 65 f8 lea -0x8(%ebp),%esp 115fa5: 5b pop %ebx 115fa6: 5e pop %esi 115fa7: c9 leave 115fa8: c3 ret 115fa9: 8d 76 00 lea 0x0(%esi),%esi the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) *internal = external; 115fac: 89 33 mov %esi,(%ebx) 115fae: eb eb jmp 115f9b register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) return RTEMS_INVALID_ADDRESS; 115fb0: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115fb5: 8d 65 f8 lea -0x8(%ebp),%esp 115fb8: 5b pop %ebx 115fb9: 5e pop %esi 115fba: c9 leave 115fbb: c3 ret =============================================================================== 00115fe0 : rtems_status_code rtems_port_internal_to_external( rtems_id id, void *internal, void **external ) { 115fe0: 55 push %ebp 115fe1: 89 e5 mov %esp,%ebp 115fe3: 56 push %esi 115fe4: 53 push %ebx 115fe5: 83 ec 10 sub $0x10,%esp 115fe8: 8b 75 0c mov 0xc(%ebp),%esi 115feb: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 115fee: 85 db test %ebx,%ebx 115ff0: 74 4e je 116040 <== NEVER TAKEN 115ff2: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); 115ff3: 8d 45 f4 lea -0xc(%ebp),%eax 115ff6: 50 push %eax 115ff7: ff 75 08 pushl 0x8(%ebp) 115ffa: 68 60 20 14 00 push $0x142060 115fff: e8 e0 52 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 116004: 83 c4 10 add $0x10,%esp 116007: 8b 55 f4 mov -0xc(%ebp),%edx 11600a: 85 d2 test %edx,%edx 11600c: 74 0e je 11601c #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11600e: b8 04 00 00 00 mov $0x4,%eax } 116013: 8d 65 f8 lea -0x8(%ebp),%esp 116016: 5b pop %ebx 116017: 5e pop %esi 116018: c9 leave 116019: c3 ret 11601a: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 11601c: 89 f2 mov %esi,%edx 11601e: 2b 50 10 sub 0x10(%eax),%edx the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 116021: 3b 50 18 cmp 0x18(%eax),%edx 116024: 77 16 ja 11603c RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 116026: 03 50 14 add 0x14(%eax),%edx 116029: 89 13 mov %edx,(%ebx) *external = internal; else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 11602b: e8 68 5d 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116030: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116032: 8d 65 f8 lea -0x8(%ebp),%esp 116035: 5b pop %ebx 116036: 5e pop %esi 116037: c9 leave 116038: c3 ret 116039: 8d 76 00 lea 0x0(%esi),%esi switch ( location ) { case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) *external = internal; 11603c: 89 33 mov %esi,(%ebx) 11603e: eb eb jmp 11602b register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) return RTEMS_INVALID_ADDRESS; 116040: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116045: 8d 65 f8 lea -0x8(%ebp),%esp 116048: 5b pop %ebx 116049: 5e pop %esi 11604a: c9 leave 11604b: c3 ret =============================================================================== 00116ab8 : */ rtems_status_code rtems_rate_monotonic_cancel( rtems_id id ) { 116ab8: 55 push %ebp 116ab9: 89 e5 mov %esp,%ebp 116abb: 53 push %ebx 116abc: 83 ec 18 sub $0x18,%esp Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); 116abf: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 116ac2: 50 push %eax 116ac3: ff 75 08 pushl 0x8(%ebp) 116ac6: 68 e0 20 14 00 push $0x1420e0 116acb: e8 14 48 00 00 call 11b2e4 <_Objects_Get> 116ad0: 89 c3 mov %eax,%ebx switch ( location ) { 116ad2: 83 c4 10 add $0x10,%esp 116ad5: 8b 45 f4 mov -0xc(%ebp),%eax 116ad8: 85 c0 test %eax,%eax 116ada: 74 0c je 116ae8 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 116adc: b8 04 00 00 00 mov $0x4,%eax } 116ae1: 8b 5d fc mov -0x4(%ebp),%ebx 116ae4: c9 leave 116ae5: c3 ret 116ae6: 66 90 xchg %ax,%ax the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 116ae8: a1 f8 27 14 00 mov 0x1427f8,%eax 116aed: 39 43 40 cmp %eax,0x40(%ebx) 116af0: 74 12 je 116b04 _Thread_Enable_dispatch(); 116af2: e8 a1 52 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 116af7: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116afc: 8b 5d fc mov -0x4(%ebp),%ebx 116aff: c9 leave 116b00: c3 ret 116b01: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } (void) _Watchdog_Remove( &the_period->Timer ); 116b04: 83 ec 0c sub $0xc,%esp 116b07: 8d 43 10 lea 0x10(%ebx),%eax 116b0a: 50 push %eax 116b0b: e8 60 64 00 00 call 11cf70 <_Watchdog_Remove> the_period->state = RATE_MONOTONIC_INACTIVE; 116b10: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) _Thread_Enable_dispatch(); 116b17: e8 7c 52 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116b1c: 83 c4 10 add $0x10,%esp 116b1f: 31 c0 xor %eax,%eax 116b21: eb be jmp 116ae1 =============================================================================== 0010c340 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 10c340: 55 push %ebp 10c341: 89 e5 mov %esp,%ebp 10c343: 57 push %edi 10c344: 56 push %esi 10c345: 53 push %ebx 10c346: 83 ec 1c sub $0x1c,%esp 10c349: 8b 5d 08 mov 0x8(%ebp),%ebx 10c34c: 8b 75 0c mov 0xc(%ebp),%esi Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10c34f: 85 db test %ebx,%ebx 10c351: 0f 84 a9 00 00 00 je 10c400 return RTEMS_INVALID_NAME; if ( !id ) 10c357: 85 f6 test %esi,%esi 10c359: 0f 84 c5 00 00 00 je 10c424 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c35f: a1 d0 a8 12 00 mov 0x12a8d0,%eax 10c364: 40 inc %eax 10c365: a3 d0 a8 12 00 mov %eax,0x12a8d0 * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) _Objects_Allocate( &_Rate_monotonic_Information ); 10c36a: 83 ec 0c sub $0xc,%esp 10c36d: 68 e0 a7 12 00 push $0x12a7e0 10c372: e8 25 1f 00 00 call 10e29c <_Objects_Allocate> 10c377: 89 c2 mov %eax,%edx _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 10c379: 83 c4 10 add $0x10,%esp 10c37c: 85 c0 test %eax,%eax 10c37e: 0f 84 8c 00 00 00 je 10c410 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 10c384: a1 b8 ae 12 00 mov 0x12aeb8,%eax 10c389: 89 42 40 mov %eax,0x40(%edx) the_period->state = RATE_MONOTONIC_INACTIVE; 10c38c: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c393: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 10c39a: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx) the_watchdog->id = id; 10c3a1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) the_watchdog->user_data = user_data; 10c3a8: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 10c3af: 8d 42 54 lea 0x54(%edx),%eax 10c3b2: 89 45 e4 mov %eax,-0x1c(%ebp) 10c3b5: b9 38 00 00 00 mov $0x38,%ecx 10c3ba: 31 c0 xor %eax,%eax 10c3bc: 8b 7d e4 mov -0x1c(%ebp),%edi 10c3bf: f3 aa rep stos %al,%es:(%edi) 10c3c1: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10c3c8: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10c3cf: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10c3d6: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c3dd: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c3e0: 0f b7 f8 movzwl %ax,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c3e3: 8b 0d fc a7 12 00 mov 0x12a7fc,%ecx 10c3e9: 89 14 b9 mov %edx,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c3ec: 89 5a 0c mov %ebx,0xc(%edx) &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 10c3ef: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10c3f1: e8 fa 2e 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c3f6: 31 c0 xor %eax,%eax } 10c3f8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3fb: 5b pop %ebx 10c3fc: 5e pop %esi 10c3fd: 5f pop %edi 10c3fe: c9 leave 10c3ff: c3 ret ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10c400: b8 03 00 00 00 mov $0x3,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c405: 8d 65 f4 lea -0xc(%ebp),%esp 10c408: 5b pop %ebx 10c409: 5e pop %esi 10c40a: 5f pop %edi 10c40b: c9 leave 10c40c: c3 ret 10c40d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 10c410: e8 db 2e 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10c415: b8 05 00 00 00 mov $0x5,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c41a: 8d 65 f4 lea -0xc(%ebp),%esp 10c41d: 5b pop %ebx 10c41e: 5e pop %esi 10c41f: 5f pop %edi 10c420: c9 leave 10c421: c3 ret 10c422: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10c424: b8 09 00 00 00 mov $0x9,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c429: 8d 65 f4 lea -0xc(%ebp),%esp 10c42c: 5b pop %ebx 10c42d: 5e pop %esi 10c42e: 5f pop %edi 10c42f: c9 leave 10c430: c3 ret =============================================================================== 001128d0 : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 1128d0: 55 push %ebp 1128d1: 89 e5 mov %esp,%ebp 1128d3: 53 push %ebx 1128d4: 83 ec 24 sub $0x24,%esp 1128d7: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) 1128da: 85 db test %ebx,%ebx 1128dc: 0f 84 92 00 00 00 je 112974 1128e2: 50 push %eax return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); 1128e3: 8d 45 f4 lea -0xc(%ebp),%eax 1128e6: 50 push %eax 1128e7: ff 75 08 pushl 0x8(%ebp) 1128ea: 68 e0 a7 12 00 push $0x12a7e0 1128ef: e8 48 bf ff ff call 10e83c <_Objects_Get> switch ( location ) { 1128f4: 83 c4 10 add $0x10,%esp 1128f7: 8b 4d f4 mov -0xc(%ebp),%ecx 1128fa: 85 c9 test %ecx,%ecx 1128fc: 74 0a je 112908 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1128fe: b8 04 00 00 00 mov $0x4,%eax } 112903: 8b 5d fc mov -0x4(%ebp),%ebx 112906: c9 leave 112907: c3 ret the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 112908: 8b 50 40 mov 0x40(%eax),%edx 11290b: 8b 52 08 mov 0x8(%edx),%edx 11290e: 89 13 mov %edx,(%ebx) status->state = the_period->state; 112910: 8b 50 38 mov 0x38(%eax),%edx 112913: 89 53 04 mov %edx,0x4(%ebx) /* * If the period is inactive, there is no information. */ if ( status->state == RATE_MONOTONIC_INACTIVE ) { 112916: 85 d2 test %edx,%edx 112918: 75 2a jne 112944 #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timespec_Set_to_zero( &status->since_last_period ); 11291a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 112921: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Timespec_Set_to_zero( &status->executed_since_last_period ); 112928: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 11292f: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) status->since_last_period = since_last_period; status->executed_since_last_period = executed; #endif } _Thread_Enable_dispatch(); 112936: e8 b5 c9 ff ff call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11293b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11293d: 8b 5d fc mov -0x4(%ebp),%ebx 112940: c9 leave 112941: c3 ret 112942: 66 90 xchg %ax,%ax } else { /* * Grab the current status. */ valid_status = 112944: 52 push %edx _Rate_monotonic_Get_status( 112945: 8d 55 ec lea -0x14(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 112948: 52 push %edx _Rate_monotonic_Get_status( 112949: 8d 55 e4 lea -0x1c(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 11294c: 52 push %edx 11294d: 50 push %eax 11294e: e8 05 9b ff ff call 10c458 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { 112953: 83 c4 10 add $0x10,%esp 112956: 84 c0 test %al,%al 112958: 74 26 je 112980 _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( 11295a: 8b 45 e4 mov -0x1c(%ebp),%eax 11295d: 8b 55 e8 mov -0x18(%ebp),%edx 112960: 89 43 08 mov %eax,0x8(%ebx) 112963: 89 53 0c mov %edx,0xc(%ebx) &since_last_period, &status->since_last_period ); _Timestamp_To_timespec( 112966: 8b 45 ec mov -0x14(%ebp),%eax 112969: 8b 55 f0 mov -0x10(%ebp),%edx 11296c: 89 43 10 mov %eax,0x10(%ebx) 11296f: 89 53 14 mov %edx,0x14(%ebx) 112972: eb c2 jmp 112936 Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) return RTEMS_INVALID_ADDRESS; 112974: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112979: 8b 5d fc mov -0x4(%ebp),%ebx 11297c: c9 leave 11297d: c3 ret 11297e: 66 90 xchg %ax,%ax valid_status = _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { _Thread_Enable_dispatch(); 112980: e8 6b c9 ff ff call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 112985: b8 0b 00 00 00 mov $0xb,%eax 11298a: e9 74 ff ff ff jmp 112903 =============================================================================== 0010c654 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10c654: 55 push %ebp 10c655: 89 e5 mov %esp,%ebp 10c657: 57 push %edi 10c658: 56 push %esi 10c659: 53 push %ebx 10c65a: 83 ec 30 sub $0x30,%esp 10c65d: 8b 5d 08 mov 0x8(%ebp),%ebx 10c660: 8b 75 0c mov 0xc(%ebp),%esi 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 ); 10c663: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10c666: 50 push %eax 10c667: 53 push %ebx 10c668: 68 e0 a7 12 00 push $0x12a7e0 10c66d: e8 ca 21 00 00 call 10e83c <_Objects_Get> switch ( location ) { 10c672: 83 c4 10 add $0x10,%esp 10c675: 8b 55 e4 mov -0x1c(%ebp),%edx 10c678: 85 d2 test %edx,%edx 10c67a: 74 10 je 10c68c #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c67c: b8 04 00 00 00 mov $0x4,%eax } 10c681: 8d 65 f4 lea -0xc(%ebp),%esp 10c684: 5b pop %ebx 10c685: 5e pop %esi 10c686: 5f pop %edi 10c687: c9 leave 10c688: c3 ret 10c689: 8d 76 00 lea 0x0(%esi),%esi the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10c68c: 8b 15 b8 ae 12 00 mov 0x12aeb8,%edx 10c692: 39 50 40 cmp %edx,0x40(%eax) 10c695: 74 15 je 10c6ac _Thread_Enable_dispatch(); 10c697: e8 54 2c 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10c69c: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6a1: 8d 65 f4 lea -0xc(%ebp),%esp 10c6a4: 5b pop %ebx 10c6a5: 5e pop %esi 10c6a6: 5f pop %edi 10c6a7: c9 leave 10c6a8: c3 ret 10c6a9: 8d 76 00 lea 0x0(%esi),%esi if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 10c6ac: 85 f6 test %esi,%esi 10c6ae: 75 1c jne 10c6cc switch ( the_period->state ) { 10c6b0: 8b 40 38 mov 0x38(%eax),%eax 10c6b3: 83 f8 04 cmp $0x4,%eax 10c6b6: 77 6c ja 10c724 <== NEVER TAKEN 10c6b8: 8b 04 85 dc 34 12 00 mov 0x1234dc(,%eax,4),%eax case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10c6bf: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6c2: e8 29 2c 00 00 call 10f2f0 <_Thread_Enable_dispatch> return( return_value ); 10c6c7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6ca: eb b5 jmp 10c681 } _ISR_Disable( level ); 10c6cc: 9c pushf 10c6cd: fa cli 10c6ce: 5f pop %edi if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10c6cf: 8b 50 38 mov 0x38(%eax),%edx 10c6d2: 85 d2 test %edx,%edx 10c6d4: 74 52 je 10c728 _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10c6d6: 83 fa 02 cmp $0x2,%edx 10c6d9: 0f 84 9e 00 00 00 je 10c77d _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10c6df: 83 fa 04 cmp $0x4,%edx 10c6e2: 75 98 jne 10c67c <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10c6e4: 83 ec 0c sub $0xc,%esp 10c6e7: 50 push %eax 10c6e8: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6eb: e8 74 fe ff ff call 10c564 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10c6f0: 57 push %edi 10c6f1: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10c6f2: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6f5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) the_period->next_length = length; 10c6fc: 89 70 3c mov %esi,0x3c(%eax) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c6ff: 89 70 1c mov %esi,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c702: 5b pop %ebx 10c703: 5e pop %esi _Watchdog_Insert_ticks( &the_period->Timer, length ); 10c704: 83 c0 10 add $0x10,%eax 10c707: 50 push %eax 10c708: 68 dc a9 12 00 push $0x12a9dc 10c70d: e8 e6 3a 00 00 call 1101f8 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10c712: e8 d9 2b 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10c717: 83 c4 10 add $0x10,%esp 10c71a: b8 06 00 00 00 mov $0x6,%eax 10c71f: e9 5d ff ff ff jmp 10c681 _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10c724: 31 c0 xor %eax,%eax 10c726: eb 97 jmp 10c6bf <== NOT EXECUTED return( return_value ); } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { _ISR_Enable( level ); 10c728: 57 push %edi 10c729: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10c72a: 83 ec 0c sub $0xc,%esp 10c72d: 50 push %eax 10c72e: 89 45 d4 mov %eax,-0x2c(%ebp) 10c731: e8 ba fd ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10c736: 8b 45 d4 mov -0x2c(%ebp),%eax 10c739: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c740: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10c747: c7 40 2c ac ca 10 00 movl $0x10caac,0x2c(%eax) the_watchdog->id = id; 10c74e: 89 58 30 mov %ebx,0x30(%eax) the_watchdog->user_data = user_data; 10c751: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10c758: 89 70 3c mov %esi,0x3c(%eax) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c75b: 89 70 1c mov %esi,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c75e: 5e pop %esi 10c75f: 5f pop %edi _Watchdog_Insert_ticks( &the_period->Timer, length ); 10c760: 83 c0 10 add $0x10,%eax 10c763: 50 push %eax 10c764: 68 dc a9 12 00 push $0x12a9dc 10c769: e8 8a 3a 00 00 call 1101f8 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10c76e: e8 7d 2b 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c773: 83 c4 10 add $0x10,%esp 10c776: 31 c0 xor %eax,%eax 10c778: e9 04 ff ff ff jmp 10c681 if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10c77d: 83 ec 0c sub $0xc,%esp 10c780: 50 push %eax 10c781: 89 45 d4 mov %eax,-0x2c(%ebp) 10c784: e8 db fd ff ff call 10c564 <_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; 10c789: 8b 45 d4 mov -0x2c(%ebp),%eax 10c78c: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) the_period->next_length = length; 10c793: 89 70 3c mov %esi,0x3c(%eax) _ISR_Enable( level ); 10c796: 57 push %edi 10c797: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10c798: 8b 15 b8 ae 12 00 mov 0x12aeb8,%edx 10c79e: 8b 48 08 mov 0x8(%eax),%ecx 10c7a1: 89 4a 20 mov %ecx,0x20(%edx) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10c7a4: 59 pop %ecx 10c7a5: 5b pop %ebx 10c7a6: 68 00 40 00 00 push $0x4000 10c7ab: 52 push %edx 10c7ac: 89 45 d4 mov %eax,-0x2c(%ebp) 10c7af: e8 a0 33 00 00 call 10fb54 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10c7b4: 9c pushf 10c7b5: fa cli 10c7b6: 59 pop %ecx local_state = the_period->state; 10c7b7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c7ba: 8b 50 38 mov 0x38(%eax),%edx the_period->state = RATE_MONOTONIC_ACTIVE; 10c7bd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) _ISR_Enable( level ); 10c7c4: 51 push %ecx 10c7c5: 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 ) 10c7c6: 83 c4 10 add $0x10,%esp 10c7c9: 83 fa 03 cmp $0x3,%edx 10c7cc: 74 0c je 10c7da _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 10c7ce: e8 1d 2b 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c7d3: 31 c0 xor %eax,%eax 10c7d5: e9 a7 fe ff ff jmp 10c681 /* * 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 ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10c7da: 57 push %edi 10c7db: 57 push %edi 10c7dc: 68 00 40 00 00 push $0x4000 10c7e1: ff 35 b8 ae 12 00 pushl 0x12aeb8 10c7e7: e8 84 27 00 00 call 10ef70 <_Thread_Clear_state> 10c7ec: 83 c4 10 add $0x10,%esp 10c7ef: eb dd jmp 10c7ce =============================================================================== 0010c7f4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10c7f4: 55 push %ebp 10c7f5: 89 e5 mov %esp,%ebp 10c7f7: 57 push %edi 10c7f8: 56 push %esi 10c7f9: 53 push %ebx 10c7fa: 81 ec 8c 00 00 00 sub $0x8c,%esp 10c800: 8b 75 08 mov 0x8(%ebp),%esi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10c803: 8b 7d 0c mov 0xc(%ebp),%edi 10c806: 85 ff test %edi,%edi 10c808: 0f 84 be 00 00 00 je 10c8cc <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10c80e: 83 ec 08 sub $0x8,%esp 10c811: 68 f0 34 12 00 push $0x1234f0 10c816: 56 push %esi 10c817: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10c81a: 59 pop %ecx 10c81b: 5b pop %ebx 10c81c: 68 28 35 12 00 push $0x123528 10c821: 56 push %esi 10c822: ff 55 0c call *0xc(%ebp) (*print)( context, "--- Wall times are in seconds ---\n" ); 10c825: 58 pop %eax 10c826: 5a pop %edx 10c827: 68 4c 35 12 00 push $0x12354c 10c82c: 56 push %esi 10c82d: ff 55 0c call *0xc(%ebp) Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10c830: 5b pop %ebx 10c831: 5f pop %edi 10c832: 68 70 35 12 00 push $0x123570 10c837: 56 push %esi 10c838: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10c83b: 5a pop %edx 10c83c: 59 pop %ecx 10c83d: 68 bc 35 12 00 push $0x1235bc 10c842: 56 push %esi 10c843: ff 55 0c call *0xc(%ebp) /* * 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 ; 10c846: 8b 1d e8 a7 12 00 mov 0x12a7e8,%ebx 10c84c: 83 c4 10 add $0x10,%esp 10c84f: 3b 1d ec a7 12 00 cmp 0x12a7ec,%ebx 10c855: 77 75 ja 10c8cc <== NEVER TAKEN 10c857: 8d 7d 88 lea -0x78(%ebp),%edi 10c85a: eb 09 jmp 10c865 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10c85c: 43 inc %ebx /* * 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 ; 10c85d: 39 1d ec a7 12 00 cmp %ebx,0x12a7ec 10c863: 72 67 jb 10c8cc id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10c865: 83 ec 08 sub $0x8,%esp 10c868: 57 push %edi 10c869: 53 push %ebx 10c86a: e8 b5 5f 00 00 call 112824 if ( status != RTEMS_SUCCESSFUL ) 10c86f: 83 c4 10 add $0x10,%esp 10c872: 85 c0 test %eax,%eax 10c874: 75 e6 jne 10c85c #if defined(RTEMS_DEBUG) status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); 10c876: 83 ec 08 sub $0x8,%esp 10c879: 8d 45 c0 lea -0x40(%ebp),%eax 10c87c: 50 push %eax 10c87d: 53 push %ebx 10c87e: e8 4d 60 00 00 call 1128d0 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10c883: 83 c4 0c add $0xc,%esp 10c886: 8d 55 e3 lea -0x1d(%ebp),%edx 10c889: 52 push %edx 10c88a: 6a 05 push $0x5 10c88c: ff 75 c0 pushl -0x40(%ebp) 10c88f: e8 b4 02 00 00 call 10cb48 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10c894: 59 pop %ecx 10c895: 58 pop %eax 10c896: ff 75 8c pushl -0x74(%ebp) 10c899: ff 75 88 pushl -0x78(%ebp) 10c89c: 8d 45 e3 lea -0x1d(%ebp),%eax 10c89f: 50 push %eax 10c8a0: 53 push %ebx 10c8a1: 68 0e 35 12 00 push $0x12350e 10c8a6: 56 push %esi 10c8a7: ff 55 0c call *0xc(%ebp) ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10c8aa: 8b 45 88 mov -0x78(%ebp),%eax 10c8ad: 83 c4 20 add $0x20,%esp 10c8b0: 85 c0 test %eax,%eax 10c8b2: 75 20 jne 10c8d4 (*print)( context, "\n" ); 10c8b4: 83 ec 08 sub $0x8,%esp 10c8b7: 68 f9 15 12 00 push $0x1215f9 10c8bc: 56 push %esi 10c8bd: ff 55 0c call *0xc(%ebp) continue; 10c8c0: 83 c4 10 add $0x10,%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++ ) { 10c8c3: 43 inc %ebx /* * 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 ; 10c8c4: 39 1d ec a7 12 00 cmp %ebx,0x12a7ec 10c8ca: 73 99 jae 10c865 <== ALWAYS TAKEN the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10c8cc: 8d 65 f4 lea -0xc(%ebp),%esp 10c8cf: 5b pop %ebx 10c8d0: 5e pop %esi 10c8d1: 5f pop %edi 10c8d2: c9 leave 10c8d3: c3 ret 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 ); 10c8d4: 52 push %edx 10c8d5: 8d 55 d8 lea -0x28(%ebp),%edx 10c8d8: 52 push %edx 10c8d9: 50 push %eax 10c8da: 8d 45 a0 lea -0x60(%ebp),%eax 10c8dd: 50 push %eax 10c8de: e8 75 35 00 00 call 10fe58 <_Timespec_Divide_by_integer> (*print)( context, 10c8e3: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 10c8e8: 8b 45 dc mov -0x24(%ebp),%eax 10c8eb: f7 e9 imul %ecx 10c8ed: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c8f3: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c8f9: c1 f8 06 sar $0x6,%eax 10c8fc: 8b 55 dc mov -0x24(%ebp),%edx 10c8ff: c1 fa 1f sar $0x1f,%edx 10c902: 29 d0 sub %edx,%eax 10c904: 50 push %eax 10c905: ff 75 d8 pushl -0x28(%ebp) 10c908: 8b 45 9c mov -0x64(%ebp),%eax 10c90b: f7 e9 imul %ecx 10c90d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c913: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c919: c1 f8 06 sar $0x6,%eax 10c91c: 8b 55 9c mov -0x64(%ebp),%edx 10c91f: c1 fa 1f sar $0x1f,%edx 10c922: 29 d0 sub %edx,%eax 10c924: 50 push %eax 10c925: ff 75 98 pushl -0x68(%ebp) 10c928: 8b 45 94 mov -0x6c(%ebp),%eax 10c92b: f7 e9 imul %ecx 10c92d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c933: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c939: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c93f: c1 f8 06 sar $0x6,%eax 10c942: 8b 55 94 mov -0x6c(%ebp),%edx 10c945: c1 fa 1f sar $0x1f,%edx 10c948: 29 d0 sub %edx,%eax 10c94a: 50 push %eax 10c94b: ff 75 90 pushl -0x70(%ebp) 10c94e: 68 08 36 12 00 push $0x123608 10c953: 56 push %esi 10c954: 89 4d 84 mov %ecx,-0x7c(%ebp) 10c957: ff 55 0c call *0xc(%ebp) 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); 10c95a: 83 c4 2c add $0x2c,%esp 10c95d: 8d 55 d8 lea -0x28(%ebp),%edx 10c960: 52 push %edx 10c961: ff 75 88 pushl -0x78(%ebp) 10c964: 8d 45 b8 lea -0x48(%ebp),%eax 10c967: 50 push %eax 10c968: e8 eb 34 00 00 call 10fe58 <_Timespec_Divide_by_integer> (*print)( context, 10c96d: 8b 4d 84 mov -0x7c(%ebp),%ecx 10c970: 8b 45 dc mov -0x24(%ebp),%eax 10c973: f7 e9 imul %ecx 10c975: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c97b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c981: c1 f8 06 sar $0x6,%eax 10c984: 8b 55 dc mov -0x24(%ebp),%edx 10c987: c1 fa 1f sar $0x1f,%edx 10c98a: 29 d0 sub %edx,%eax 10c98c: 50 push %eax 10c98d: ff 75 d8 pushl -0x28(%ebp) 10c990: 8b 45 b4 mov -0x4c(%ebp),%eax 10c993: f7 e9 imul %ecx 10c995: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c99b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9a1: c1 f8 06 sar $0x6,%eax 10c9a4: 8b 55 b4 mov -0x4c(%ebp),%edx 10c9a7: c1 fa 1f sar $0x1f,%edx 10c9aa: 29 d0 sub %edx,%eax 10c9ac: 50 push %eax 10c9ad: ff 75 b0 pushl -0x50(%ebp) 10c9b0: 8b 45 ac mov -0x54(%ebp),%eax 10c9b3: f7 e9 imul %ecx 10c9b5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c9bb: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c9c1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9c7: c1 f8 06 sar $0x6,%eax 10c9ca: 8b 55 ac mov -0x54(%ebp),%edx 10c9cd: c1 fa 1f sar $0x1f,%edx 10c9d0: 29 d0 sub %edx,%eax 10c9d2: 50 push %eax 10c9d3: ff 75 a8 pushl -0x58(%ebp) 10c9d6: 68 28 36 12 00 push $0x123628 10c9db: 56 push %esi 10c9dc: ff 55 0c call *0xc(%ebp) 10c9df: 83 c4 30 add $0x30,%esp 10c9e2: e9 75 fe ff ff jmp 10c85c =============================================================================== 0010ca00 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 10ca00: 55 push %ebp 10ca01: 89 e5 mov %esp,%ebp 10ca03: 53 push %ebx 10ca04: 83 ec 04 sub $0x4,%esp 10ca07: a1 d0 a8 12 00 mov 0x12a8d0,%eax 10ca0c: 40 inc %eax 10ca0d: a3 d0 a8 12 00 mov %eax,0x12a8d0 /* * Cycle through all possible ids and try to reset 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 ; 10ca12: 8b 1d e8 a7 12 00 mov 0x12a7e8,%ebx 10ca18: 3b 1d ec a7 12 00 cmp 0x12a7ec,%ebx 10ca1e: 77 15 ja 10ca35 <== NEVER TAKEN id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 10ca20: 83 ec 0c sub $0xc,%esp 10ca23: 53 push %ebx 10ca24: e8 17 00 00 00 call 10ca40 * Cycle through all possible ids and try to reset 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++ ) { 10ca29: 43 inc %ebx /* * Cycle through all possible ids and try to reset 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 ; 10ca2a: 83 c4 10 add $0x10,%esp 10ca2d: 39 1d ec a7 12 00 cmp %ebx,0x12a7ec 10ca33: 73 eb jae 10ca20 /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 10ca35: 8b 5d fc mov -0x4(%ebp),%ebx 10ca38: c9 leave } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 10ca39: e9 b2 28 00 00 jmp 10f2f0 <_Thread_Enable_dispatch> =============================================================================== 0010ca40 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 10ca40: 55 push %ebp 10ca41: 89 e5 mov %esp,%ebp 10ca43: 57 push %edi 10ca44: 53 push %ebx 10ca45: 83 ec 14 sub $0x14,%esp Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); 10ca48: 8d 45 f4 lea -0xc(%ebp),%eax 10ca4b: 50 push %eax 10ca4c: ff 75 08 pushl 0x8(%ebp) 10ca4f: 68 e0 a7 12 00 push $0x12a7e0 10ca54: e8 e3 1d 00 00 call 10e83c <_Objects_Get> 10ca59: 89 c2 mov %eax,%edx switch ( location ) { 10ca5b: 83 c4 10 add $0x10,%esp 10ca5e: 8b 45 f4 mov -0xc(%ebp),%eax 10ca61: 85 c0 test %eax,%eax 10ca63: 75 3b jne 10caa0 case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 10ca65: 8d 5a 54 lea 0x54(%edx),%ebx 10ca68: b9 38 00 00 00 mov $0x38,%ecx 10ca6d: 31 c0 xor %eax,%eax 10ca6f: 89 df mov %ebx,%edi 10ca71: f3 aa rep stos %al,%es:(%edi) 10ca73: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10ca7a: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10ca81: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10ca88: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) _Thread_Enable_dispatch(); 10ca8f: e8 5c 28 00 00 call 10f2f0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ca94: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ca96: 8d 65 f8 lea -0x8(%ebp),%esp 10ca99: 5b pop %ebx 10ca9a: 5f pop %edi 10ca9b: c9 leave 10ca9c: c3 ret 10ca9d: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10caa0: b8 04 00 00 00 mov $0x4,%eax } 10caa5: 8d 65 f8 lea -0x8(%ebp),%esp 10caa8: 5b pop %ebx 10caa9: 5f pop %edi 10caaa: c9 leave 10caab: c3 ret =============================================================================== 0011724c : uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 11724c: 55 push %ebp 11724d: 89 e5 mov %esp,%ebp 11724f: 57 push %edi 117250: 56 push %esi 117251: 53 push %ebx 117252: 83 ec 1c sub $0x1c,%esp 117255: 8b 7d 08 mov 0x8(%ebp),%edi 117258: 8b 75 0c mov 0xc(%ebp),%esi rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 11725b: 85 ff test %edi,%edi 11725d: 0f 84 c1 00 00 00 je 117324 return RTEMS_INVALID_NAME; if ( !starting_address ) 117263: 85 f6 test %esi,%esi 117265: 0f 84 e1 00 00 00 je 11734c return RTEMS_INVALID_ADDRESS; if ( !id ) 11726b: 8b 45 1c mov 0x1c(%ebp),%eax 11726e: 85 c0 test %eax,%eax 117270: 0f 84 d6 00 00 00 je 11734c return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 117276: 83 ec 0c sub $0xc,%esp 117279: ff 35 fc 22 14 00 pushl 0x1422fc 11727f: e8 28 25 00 00 call 1197ac <_API_Mutex_Lock> * This function allocates a region control block from * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 117284: c7 04 24 20 21 14 00 movl $0x142120,(%esp) 11728b: e8 60 3b 00 00 call 11adf0 <_Objects_Allocate> 117290: 89 c3 mov %eax,%ebx the_region = _Region_Allocate(); if ( !the_region ) 117292: 83 c4 10 add $0x10,%esp 117295: 85 c0 test %eax,%eax 117297: 0f 84 bf 00 00 00 je 11735c return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 11729d: ff 75 14 pushl 0x14(%ebp) 1172a0: ff 75 10 pushl 0x10(%ebp) 1172a3: 56 push %esi 1172a4: 8d 40 68 lea 0x68(%eax),%eax 1172a7: 50 push %eax 1172a8: e8 4f 37 00 00 call 11a9fc <_Heap_Initialize> 1172ad: 89 43 5c mov %eax,0x5c(%ebx) &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 1172b0: 83 c4 10 add $0x10,%esp 1172b3: 85 c0 test %eax,%eax 1172b5: 74 7d je 117334 return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 1172b7: 89 73 50 mov %esi,0x50(%ebx) the_region->length = length; 1172ba: 8b 45 10 mov 0x10(%ebp),%eax 1172bd: 89 43 54 mov %eax,0x54(%ebx) the_region->page_size = page_size; 1172c0: 8b 55 14 mov 0x14(%ebp),%edx 1172c3: 89 53 58 mov %edx,0x58(%ebx) the_region->attribute_set = attribute_set; 1172c6: 8b 45 18 mov 0x18(%ebp),%eax 1172c9: 89 43 60 mov %eax,0x60(%ebx) the_region->number_of_used_blocks = 0; 1172cc: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) _Thread_queue_Initialize( 1172d3: 6a 06 push $0x6 1172d5: 6a 40 push $0x40 1172d7: a8 04 test $0x4,%al 1172d9: 0f 95 c0 setne %al 1172dc: 0f b6 c0 movzbl %al,%eax 1172df: 50 push %eax 1172e0: 8d 43 10 lea 0x10(%ebx),%eax 1172e3: 50 push %eax 1172e4: e8 f3 51 00 00 call 11c4dc <_Thread_queue_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1172e9: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1172ec: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1172ef: 8b 15 3c 21 14 00 mov 0x14213c,%edx 1172f5: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1172f8: 89 7b 0c mov %edi,0xc(%ebx) &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1172fb: 8b 55 1c mov 0x1c(%ebp),%edx 1172fe: 89 02 mov %eax,(%edx) 117300: 83 c4 10 add $0x10,%esp return_status = RTEMS_SUCCESSFUL; 117303: 31 c0 xor %eax,%eax } } _RTEMS_Unlock_allocator(); 117305: 83 ec 0c sub $0xc,%esp 117308: ff 35 fc 22 14 00 pushl 0x1422fc 11730e: 89 45 e4 mov %eax,-0x1c(%ebp) 117311: e8 de 24 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; 117316: 83 c4 10 add $0x10,%esp 117319: 8b 45 e4 mov -0x1c(%ebp),%eax } 11731c: 8d 65 f4 lea -0xc(%ebp),%esp 11731f: 5b pop %ebx 117320: 5e pop %esi 117321: 5f pop %edi 117322: c9 leave 117323: c3 ret { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 117324: b8 03 00 00 00 mov $0x3,%eax } } _RTEMS_Unlock_allocator(); return return_status; } 117329: 8d 65 f4 lea -0xc(%ebp),%esp 11732c: 5b pop %ebx 11732d: 5e pop %esi 11732e: 5f pop %edi 11732f: c9 leave 117330: c3 ret 117331: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 117334: 83 ec 08 sub $0x8,%esp 117337: 53 push %ebx 117338: 68 20 21 14 00 push $0x142120 11733d: e8 26 3e 00 00 call 11b168 <_Objects_Free> 117342: 83 c4 10 add $0x10,%esp &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { _Region_Free( the_region ); return_status = RTEMS_INVALID_SIZE; 117345: b8 08 00 00 00 mov $0x8,%eax 11734a: eb b9 jmp 117305 if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 11734c: b8 09 00 00 00 mov $0x9,%eax } } _RTEMS_Unlock_allocator(); return return_status; } 117351: 8d 65 f4 lea -0xc(%ebp),%esp 117354: 5b pop %ebx 117355: 5e pop %esi 117356: 5f pop %edi 117357: c9 leave 117358: c3 ret 117359: 8d 76 00 lea 0x0(%esi),%esi _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) return_status = RTEMS_TOO_MANY; 11735c: b8 05 00 00 00 mov $0x5,%eax 117361: eb a2 jmp 117305 =============================================================================== 00117364 : */ rtems_status_code rtems_region_delete( rtems_id id ) { 117364: 55 push %ebp 117365: 89 e5 mov %esp,%ebp 117367: 53 push %ebx 117368: 83 ec 30 sub $0x30,%esp Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; _RTEMS_Lock_allocator(); 11736b: ff 35 fc 22 14 00 pushl 0x1422fc 117371: e8 36 24 00 00 call 1197ac <_API_Mutex_Lock> Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 117376: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117379: 8d 45 f4 lea -0xc(%ebp),%eax 11737c: 50 push %eax 11737d: ff 75 08 pushl 0x8(%ebp) 117380: 68 20 21 14 00 push $0x142120 117385: e8 1e 3f 00 00 call 11b2a8 <_Objects_Get_no_protection> switch ( location ) { 11738a: 83 c4 10 add $0x10,%esp 11738d: 8b 5d f4 mov -0xc(%ebp),%ebx 117390: 85 db test %ebx,%ebx 117392: 74 1c je 1173b0 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 117394: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 117399: 83 ec 0c sub $0xc,%esp 11739c: ff 35 fc 22 14 00 pushl 0x1422fc 1173a2: e8 4d 24 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; } 1173a7: 89 d8 mov %ebx,%eax 1173a9: 8b 5d fc mov -0x4(%ebp),%ebx 1173ac: c9 leave 1173ad: c3 ret 1173ae: 66 90 xchg %ax,%ax the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 1173b0: 8b 48 64 mov 0x64(%eax),%ecx 1173b3: 85 c9 test %ecx,%ecx 1173b5: 74 09 je 1173c0 return_status = RTEMS_RESOURCE_IN_USE; 1173b7: bb 0c 00 00 00 mov $0xc,%ebx 1173bc: eb db jmp 117399 1173be: 66 90 xchg %ax,%ax else { _Objects_Close( &_Region_Information, &the_region->Object ); 1173c0: 83 ec 08 sub $0x8,%esp 1173c3: 50 push %eax 1173c4: 68 20 21 14 00 push $0x142120 1173c9: 89 45 e4 mov %eax,-0x1c(%ebp) 1173cc: e8 9b 3a 00 00 call 11ae6c <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 1173d1: 58 pop %eax 1173d2: 5a pop %edx 1173d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1173d6: 50 push %eax 1173d7: 68 20 21 14 00 push $0x142120 1173dc: e8 87 3d 00 00 call 11b168 <_Objects_Free> 1173e1: 83 c4 10 add $0x10,%esp _Region_Free( the_region ); return_status = RTEMS_SUCCESSFUL; 1173e4: 31 db xor %ebx,%ebx 1173e6: eb b1 jmp 117399 =============================================================================== 001173e8 : rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 1173e8: 55 push %ebp 1173e9: 89 e5 mov %esp,%ebp 1173eb: 56 push %esi 1173ec: 53 push %ebx 1173ed: 83 ec 10 sub $0x10,%esp 1173f0: 8b 5d 0c mov 0xc(%ebp),%ebx bool extend_ok; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 1173f3: 85 db test %ebx,%ebx 1173f5: 74 75 je 11746c return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 1173f7: 83 ec 0c sub $0xc,%esp 1173fa: ff 35 fc 22 14 00 pushl 0x1422fc 117400: e8 a7 23 00 00 call 1197ac <_API_Mutex_Lock> Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 117405: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117408: 8d 45 f0 lea -0x10(%ebp),%eax 11740b: 50 push %eax 11740c: ff 75 08 pushl 0x8(%ebp) 11740f: 68 20 21 14 00 push $0x142120 117414: e8 8f 3e 00 00 call 11b2a8 <_Objects_Get_no_protection> 117419: 89 c6 mov %eax,%esi switch ( location ) { 11741b: 83 c4 10 add $0x10,%esp 11741e: 8b 45 f0 mov -0x10(%ebp),%eax 117421: 85 c0 test %eax,%eax 117423: 74 1f je 117444 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 117425: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 11742a: 83 ec 0c sub $0xc,%esp 11742d: ff 35 fc 22 14 00 pushl 0x1422fc 117433: e8 bc 23 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; 117438: 83 c4 10 add $0x10,%esp } 11743b: 89 d8 mov %ebx,%eax 11743d: 8d 65 f8 lea -0x8(%ebp),%esp 117440: 5b pop %ebx 117441: 5e pop %esi 117442: c9 leave 117443: c3 ret the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: extend_ok = _Heap_Extend( 117444: 8d 45 f4 lea -0xc(%ebp),%eax 117447: 50 push %eax 117448: ff 75 10 pushl 0x10(%ebp) 11744b: 53 push %ebx 11744c: 8d 46 68 lea 0x68(%esi),%eax 11744f: 50 push %eax 117450: e8 9b 2f 00 00 call 11a3f0 <_Heap_Extend> starting_address, length, &amount_extended ); if ( extend_ok ) { 117455: 83 c4 10 add $0x10,%esp 117458: 84 c0 test %al,%al 11745a: 74 20 je 11747c the_region->length += amount_extended; 11745c: 8b 45 f4 mov -0xc(%ebp),%eax 11745f: 01 46 54 add %eax,0x54(%esi) the_region->maximum_segment_size += amount_extended; 117462: 01 46 5c add %eax,0x5c(%esi) return_status = RTEMS_SUCCESSFUL; 117465: 31 db xor %ebx,%ebx 117467: eb c1 jmp 11742a 117469: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 11746c: bb 09 00 00 00 mov $0x9,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 117471: 89 d8 mov %ebx,%eax 117473: 8d 65 f8 lea -0x8(%ebp),%esp 117476: 5b pop %ebx 117477: 5e pop %esi 117478: c9 leave 117479: c3 ret 11747a: 66 90 xchg %ax,%ax if ( extend_ok ) { the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; } else { return_status = RTEMS_INVALID_ADDRESS; 11747c: bb 09 00 00 00 mov $0x9,%ebx 117481: eb a7 jmp 11742a =============================================================================== 00117484 : rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 117484: 55 push %ebp 117485: 89 e5 mov %esp,%ebp 117487: 53 push %ebx 117488: 83 ec 14 sub $0x14,%esp 11748b: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 11748e: 85 db test %ebx,%ebx 117490: 74 76 je 117508 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 117492: 83 ec 0c sub $0xc,%esp 117495: ff 35 fc 22 14 00 pushl 0x1422fc 11749b: e8 0c 23 00 00 call 1197ac <_API_Mutex_Lock> 1174a0: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 1174a3: 8d 45 f4 lea -0xc(%ebp),%eax 1174a6: 50 push %eax 1174a7: ff 75 08 pushl 0x8(%ebp) 1174aa: 68 20 21 14 00 push $0x142120 1174af: e8 f4 3d 00 00 call 11b2a8 <_Objects_Get_no_protection> switch ( location ) { 1174b4: 83 c4 10 add $0x10,%esp 1174b7: 8b 55 f4 mov -0xc(%ebp),%edx 1174ba: 85 d2 test %edx,%edx 1174bc: 74 1e je 1174dc break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 1174be: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 1174c3: 83 ec 0c sub $0xc,%esp 1174c6: ff 35 fc 22 14 00 pushl 0x1422fc 1174cc: e8 23 23 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; 1174d1: 83 c4 10 add $0x10,%esp } 1174d4: 89 d8 mov %ebx,%eax 1174d6: 8b 5d fc mov -0x4(%ebp),%ebx 1174d9: c9 leave 1174da: c3 ret 1174db: 90 nop the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->Used.number = 0; 1174dc: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_info->Used.total = 0; 1174e3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) the_info->Used.largest = 0; 1174ea: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 1174f1: 83 ec 08 sub $0x8,%esp 1174f4: 53 push %ebx 1174f5: 83 c0 68 add $0x68,%eax 1174f8: 50 push %eax 1174f9: e8 da 32 00 00 call 11a7d8 <_Heap_Get_free_information> return_status = RTEMS_SUCCESSFUL; break; 1174fe: 83 c4 10 add $0x10,%esp the_info->Used.total = 0; the_info->Used.largest = 0; _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); return_status = RTEMS_SUCCESSFUL; 117501: 31 db xor %ebx,%ebx break; 117503: eb be jmp 1174c3 117505: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) return RTEMS_INVALID_ADDRESS; 117508: bb 09 00 00 00 mov $0x9,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 11750d: 89 d8 mov %ebx,%eax 11750f: 8b 5d fc mov -0x4(%ebp),%ebx 117512: c9 leave 117513: c3 ret =============================================================================== 0011758c : uintptr_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 11758c: 55 push %ebp 11758d: 89 e5 mov %esp,%ebp 11758f: 57 push %edi 117590: 56 push %esi 117591: 53 push %ebx 117592: 83 ec 2c sub $0x2c,%esp 117595: 8b 75 0c mov 0xc(%ebp),%esi 117598: 8b 5d 18 mov 0x18(%ebp),%ebx Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; void *the_segment; if ( !segment ) 11759b: 85 db test %ebx,%ebx 11759d: 0f 84 a1 00 00 00 je 117644 return RTEMS_INVALID_ADDRESS; *segment = NULL; 1175a3: c7 03 00 00 00 00 movl $0x0,(%ebx) if ( size == 0 ) 1175a9: 85 f6 test %esi,%esi 1175ab: 75 0f jne 1175bc return RTEMS_INVALID_SIZE; 1175ad: b8 08 00 00 00 mov $0x8,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 1175b2: 8d 65 f4 lea -0xc(%ebp),%esp 1175b5: 5b pop %ebx 1175b6: 5e pop %esi 1175b7: 5f pop %edi 1175b8: c9 leave 1175b9: c3 ret 1175ba: 66 90 xchg %ax,%ax *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 1175bc: 83 ec 0c sub $0xc,%esp 1175bf: ff 35 fc 22 14 00 pushl 0x1422fc 1175c5: e8 e2 21 00 00 call 1197ac <_API_Mutex_Lock> executing = _Thread_Executing; 1175ca: a1 f8 27 14 00 mov 0x1427f8,%eax 1175cf: 89 45 d4 mov %eax,-0x2c(%ebp) 1175d2: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 1175d5: 8d 45 e4 lea -0x1c(%ebp),%eax 1175d8: 50 push %eax 1175d9: ff 75 08 pushl 0x8(%ebp) 1175dc: 68 20 21 14 00 push $0x142120 1175e1: e8 c2 3c 00 00 call 11b2a8 <_Objects_Get_no_protection> 1175e6: 89 c7 mov %eax,%edi switch ( location ) { 1175e8: 83 c4 10 add $0x10,%esp 1175eb: 8b 45 e4 mov -0x1c(%ebp),%eax 1175ee: 85 c0 test %eax,%eax 1175f0: 75 2a jne 11761c case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 1175f2: 3b 77 5c cmp 0x5c(%edi),%esi 1175f5: 76 2d jbe 117624 return_status = RTEMS_INVALID_SIZE; 1175f7: b8 08 00 00 00 mov $0x8,%eax default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1175fc: 83 ec 0c sub $0xc,%esp 1175ff: ff 35 fc 22 14 00 pushl 0x1422fc 117605: 89 45 d0 mov %eax,-0x30(%ebp) 117608: e8 e7 21 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; 11760d: 83 c4 10 add $0x10,%esp 117610: 8b 45 d0 mov -0x30(%ebp),%eax } 117613: 8d 65 f4 lea -0xc(%ebp),%esp 117616: 5b pop %ebx 117617: 5e pop %esi 117618: 5f pop %edi 117619: c9 leave 11761a: c3 ret 11761b: 90 nop break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 11761c: b8 04 00 00 00 mov $0x4,%eax 117621: eb d9 jmp 1175fc 117623: 90 nop * @brief See _Heap_Allocate_aligned_with_boundary() with alignment and * boundary equals zero. */ RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 117624: 6a 00 push $0x0 117626: 6a 00 push $0x0 117628: 56 push %esi RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uintptr_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 117629: 8d 47 68 lea 0x68(%edi),%eax 11762c: 50 push %eax 11762d: e8 ea 2b 00 00 call 11a21c <_Heap_Allocate_aligned_with_boundary> the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 117632: 83 c4 10 add $0x10,%esp 117635: 85 c0 test %eax,%eax 117637: 74 17 je 117650 the_region->number_of_used_blocks += 1; 117639: ff 47 64 incl 0x64(%edi) *segment = the_segment; 11763c: 89 03 mov %eax,(%ebx) return_status = RTEMS_SUCCESSFUL; 11763e: 31 c0 xor %eax,%eax 117640: eb ba jmp 1175fc 117642: 66 90 xchg %ax,%ax rtems_status_code return_status; Region_Control *the_region; void *the_segment; if ( !segment ) return RTEMS_INVALID_ADDRESS; 117644: b8 09 00 00 00 mov $0x9,%eax 117649: e9 64 ff ff ff jmp 1175b2 11764e: 66 90 xchg %ax,%ax if ( the_segment ) { the_region->number_of_used_blocks += 1; *segment = the_segment; return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 117650: f6 45 10 01 testb $0x1,0x10(%ebp) 117654: 74 07 je 11765d return_status = RTEMS_UNSATISFIED; 117656: b8 0d 00 00 00 mov $0xd,%eax 11765b: eb 9f jmp 1175fc rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 11765d: a1 10 22 14 00 mov 0x142210,%eax 117662: 40 inc %eax 117663: a3 10 22 14 00 mov %eax,0x142210 * Switch from using the memory allocation mutex to using a * dispatching disabled critical section. We have to do this * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 117668: 83 ec 0c sub $0xc,%esp 11766b: ff 35 fc 22 14 00 pushl 0x1422fc 117671: e8 7e 21 00 00 call 1197f4 <_API_Mutex_Unlock> executing->Wait.queue = &the_region->Wait_queue; 117676: 8d 47 10 lea 0x10(%edi),%eax 117679: 8b 55 d4 mov -0x2c(%ebp),%edx 11767c: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 11767f: 8b 4d 08 mov 0x8(%ebp),%ecx 117682: 89 4a 20 mov %ecx,0x20(%edx) executing->Wait.count = size; 117685: 89 72 24 mov %esi,0x24(%edx) executing->Wait.return_argument = segment; 117688: 89 5a 28 mov %ebx,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; 11768b: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi) _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 117692: 83 c4 0c add $0xc,%esp 117695: 68 a0 c5 11 00 push $0x11c5a0 11769a: ff 75 14 pushl 0x14(%ebp) 11769d: 50 push %eax 11769e: e8 d1 4b 00 00 call 11c274 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 1176a3: e8 f0 46 00 00 call 11bd98 <_Thread_Enable_dispatch> return (rtems_status_code) executing->Wait.return_code; 1176a8: 8b 55 d4 mov -0x2c(%ebp),%edx 1176ab: 8b 42 34 mov 0x34(%edx),%eax 1176ae: 83 c4 10 add $0x10,%esp 1176b1: e9 fc fe ff ff jmp 1175b2 =============================================================================== 0011776c : rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 11776c: 55 push %ebp 11776d: 89 e5 mov %esp,%ebp 11776f: 56 push %esi 117770: 53 push %ebx 117771: 83 ec 20 sub $0x20,%esp 117774: 8b 5d 14 mov 0x14(%ebp),%ebx uintptr_t osize; rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 117777: 85 db test %ebx,%ebx 117779: 0f 84 89 00 00 00 je 117808 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 11777f: 83 ec 0c sub $0xc,%esp 117782: ff 35 fc 22 14 00 pushl 0x1422fc 117788: e8 1f 20 00 00 call 1197ac <_API_Mutex_Lock> 11778d: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117790: 8d 45 f0 lea -0x10(%ebp),%eax 117793: 50 push %eax 117794: ff 75 08 pushl 0x8(%ebp) 117797: 68 20 21 14 00 push $0x142120 11779c: e8 07 3b 00 00 call 11b2a8 <_Objects_Get_no_protection> 1177a1: 89 c6 mov %eax,%esi switch ( location ) { 1177a3: 83 c4 10 add $0x10,%esp 1177a6: 8b 45 f0 mov -0x10(%ebp),%eax 1177a9: 85 c0 test %eax,%eax 1177ab: 74 1f je 1177cc default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1177ad: 83 ec 0c sub $0xc,%esp 1177b0: ff 35 fc 22 14 00 pushl 0x1422fc 1177b6: e8 39 20 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; 1177bb: 83 c4 10 add $0x10,%esp 1177be: b8 04 00 00 00 mov $0x4,%eax } 1177c3: 8d 65 f8 lea -0x8(%ebp),%esp 1177c6: 5b pop %ebx 1177c7: 5e pop %esi 1177c8: c9 leave 1177c9: c3 ret 1177ca: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 1177cc: 83 ec 0c sub $0xc,%esp 1177cf: 8d 45 f4 lea -0xc(%ebp),%eax 1177d2: 50 push %eax 1177d3: 8d 45 ec lea -0x14(%ebp),%eax 1177d6: 50 push %eax 1177d7: ff 75 10 pushl 0x10(%ebp) 1177da: ff 75 0c pushl 0xc(%ebp) 1177dd: 8d 46 68 lea 0x68(%esi),%eax 1177e0: 50 push %eax 1177e1: e8 1e 34 00 00 call 11ac04 <_Heap_Resize_block> segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 1177e6: 8b 55 ec mov -0x14(%ebp),%edx 1177e9: 89 13 mov %edx,(%ebx) _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 1177eb: 83 c4 20 add $0x20,%esp 1177ee: 85 c0 test %eax,%eax 1177f0: 75 22 jne 117814 _Region_Process_queue( the_region ); /* unlocks allocator */ 1177f2: 83 ec 0c sub $0xc,%esp 1177f5: 56 push %esi 1177f6: e8 b5 7c 00 00 call 11f4b0 <_Region_Process_queue> 1177fb: 83 c4 10 add $0x10,%esp else _RTEMS_Unlock_allocator(); if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; 1177fe: 31 c0 xor %eax,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 117800: 8d 65 f8 lea -0x8(%ebp),%esp 117803: 5b pop %ebx 117804: 5e pop %esi 117805: c9 leave 117806: c3 ret 117807: 90 nop rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) return RTEMS_INVALID_ADDRESS; 117808: b8 09 00 00 00 mov $0x9,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 11780d: 8d 65 f8 lea -0x8(%ebp),%esp 117810: 5b pop %ebx 117811: 5e pop %esi 117812: c9 leave 117813: c3 ret _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 117814: 83 ec 0c sub $0xc,%esp 117817: ff 35 fc 22 14 00 pushl 0x1422fc 11781d: 89 45 e4 mov %eax,-0x1c(%ebp) 117820: e8 cf 1f 00 00 call 1197f4 <_API_Mutex_Unlock> if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; if (status == HEAP_RESIZE_UNSATISFIED) 117825: 83 c4 10 add $0x10,%esp return RTEMS_UNSATISFIED; 117828: 8b 45 e4 mov -0x1c(%ebp),%eax 11782b: 48 dec %eax 11782c: 0f 94 c0 sete %al 11782f: 0f b6 c0 movzbl %al,%eax 117832: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 117839: 8d 65 f8 lea -0x8(%ebp),%esp 11783c: 5b pop %ebx 11783d: 5e pop %esi 11783e: c9 leave 11783f: c3 ret =============================================================================== 00117840 : rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 117840: 55 push %ebp 117841: 89 e5 mov %esp,%ebp 117843: 53 push %ebx 117844: 83 ec 20 sub $0x20,%esp uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 117847: ff 35 fc 22 14 00 pushl 0x1422fc 11784d: e8 5a 1f 00 00 call 1197ac <_API_Mutex_Lock> 117852: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 117855: 8d 45 f4 lea -0xc(%ebp),%eax 117858: 50 push %eax 117859: ff 75 08 pushl 0x8(%ebp) 11785c: 68 20 21 14 00 push $0x142120 117861: e8 42 3a 00 00 call 11b2a8 <_Objects_Get_no_protection> 117866: 89 c3 mov %eax,%ebx switch ( location ) { 117868: 83 c4 10 add $0x10,%esp 11786b: 8b 45 f4 mov -0xc(%ebp),%eax 11786e: 85 c0 test %eax,%eax 117870: 75 1e jne 117890 RTEMS_INLINE_ROUTINE bool _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 117872: 83 ec 08 sub $0x8,%esp 117875: ff 75 0c pushl 0xc(%ebp) 117878: 8d 43 68 lea 0x68(%ebx),%eax 11787b: 50 push %eax 11787c: e8 07 2e 00 00 call 11a688 <_Heap_Free> #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 117881: 83 c4 10 add $0x10,%esp 117884: 84 c0 test %al,%al 117886: 75 28 jne 1178b0 return_status = RTEMS_INVALID_ADDRESS; 117888: bb 09 00 00 00 mov $0x9,%ebx 11788d: eb 06 jmp 117895 11788f: 90 nop break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 117890: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 117895: 83 ec 0c sub $0xc,%esp 117898: ff 35 fc 22 14 00 pushl 0x1422fc 11789e: e8 51 1f 00 00 call 1197f4 <_API_Mutex_Unlock> return return_status; 1178a3: 83 c4 10 add $0x10,%esp } 1178a6: 89 d8 mov %ebx,%eax 1178a8: 8b 5d fc mov -0x4(%ebp),%ebx 1178ab: c9 leave 1178ac: c3 ret 1178ad: 8d 76 00 lea 0x0(%esi),%esi _Region_Debug_Walk( the_region, 4 ); if ( !status ) return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 1178b0: ff 4b 64 decl 0x64(%ebx) _Region_Process_queue(the_region); /* unlocks allocator */ 1178b3: 83 ec 0c sub $0xc,%esp 1178b6: 53 push %ebx 1178b7: e8 f4 7b 00 00 call 11f4b0 <_Region_Process_queue> return RTEMS_SUCCESSFUL; 1178bc: 83 c4 10 add $0x10,%esp 1178bf: 31 db xor %ebx,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 1178c1: 89 d8 mov %ebx,%eax 1178c3: 8b 5d fc mov -0x4(%ebp),%ebx 1178c6: c9 leave 1178c7: c3 ret =============================================================================== 0010b434 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 10b434: 55 push %ebp 10b435: 89 e5 mov %esp,%ebp 10b437: 57 push %edi 10b438: 56 push %esi 10b439: 53 push %ebx 10b43a: 83 ec 3c sub $0x3c,%esp 10b43d: 8b 75 08 mov 0x8(%ebp),%esi 10b440: 8b 5d 10 mov 0x10(%ebp),%ebx 10b443: 8b 7d 18 mov 0x18(%ebp),%edi register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) 10b446: 85 f6 test %esi,%esi 10b448: 74 4a je 10b494 return RTEMS_INVALID_NAME; if ( !id ) 10b44a: 85 ff test %edi,%edi 10b44c: 0f 84 f6 00 00 00 je 10b548 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10b452: 89 da mov %ebx,%edx 10b454: 81 e2 c0 00 00 00 and $0xc0,%edx 10b45a: 74 48 je 10b4a4 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 10b45c: 89 d8 mov %ebx,%eax 10b45e: 83 e0 30 and $0x30,%eax _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 10b461: 83 f8 10 cmp $0x10,%eax 10b464: 74 0e je 10b474 } if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; 10b466: b8 0b 00 00 00 mov $0xb,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b46b: 8d 65 f4 lea -0xc(%ebp),%esp 10b46e: 5b pop %ebx 10b46f: 5e pop %esi 10b470: 5f pop %edi 10b471: c9 leave 10b472: c3 ret 10b473: 90 nop #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 10b474: f6 c3 04 test $0x4,%bl 10b477: 74 ed je 10b466 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 10b479: 81 fa c0 00 00 00 cmp $0xc0,%edx 10b47f: 74 e5 je 10b466 10b481: b9 10 00 00 00 mov $0x10,%ecx _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 10b486: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b48a: 76 1f jbe 10b4ab return RTEMS_INVALID_NUMBER; 10b48c: b8 0a 00 00 00 mov $0xa,%eax 10b491: eb d8 jmp 10b46b 10b493: 90 nop CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10b494: b8 03 00 00 00 mov $0x3,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b499: 8d 65 f4 lea -0xc(%ebp),%esp 10b49c: 5b pop %ebx 10b49d: 5e pop %esi 10b49e: 5f pop %edi 10b49f: c9 leave 10b4a0: c3 ret 10b4a1: 8d 76 00 lea 0x0(%esi),%esi if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 10b4a4: 89 d9 mov %ebx,%ecx 10b4a6: 83 e1 30 and $0x30,%ecx 10b4a9: 75 db jne 10b486 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b4ab: a1 70 75 12 00 mov 0x127570,%eax 10b4b0: 40 inc %eax 10b4b1: a3 70 75 12 00 mov %eax,0x127570 * This function allocates a semaphore control block from * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 10b4b6: 83 ec 0c sub $0xc,%esp 10b4b9: 68 c0 74 12 00 push $0x1274c0 10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp) 10b4c1: e8 c2 14 00 00 call 10c988 <_Objects_Allocate> 10b4c6: 89 c2 mov %eax,%edx _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 10b4c8: 83 c4 10 add $0x10,%esp 10b4cb: 85 c0 test %eax,%eax 10b4cd: 8b 4d c4 mov -0x3c(%ebp),%ecx 10b4d0: 0f 84 ba 00 00 00 je 10b590 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 10b4d6: 89 58 10 mov %ebx,0x10(%eax) /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 10b4d9: 85 c9 test %ecx,%ecx 10b4db: 74 77 je 10b554 /* * It is either simple binary semaphore or a more powerful mutex * style binary semaphore. This is the mutex style. */ if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 10b4dd: 31 c0 xor %eax,%eax 10b4df: f6 c3 04 test $0x4,%bl 10b4e2: 0f 95 c0 setne %al 10b4e5: 89 45 d8 mov %eax,-0x28(%ebp) else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 10b4e8: 83 f9 10 cmp $0x10,%ecx 10b4eb: 0f 84 ae 00 00 00 je 10b59f the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; the_mutex_attr.only_owner_release = true; } } } else /* must be simple binary semaphore */ { the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 10b4f1: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp) the_mutex_attr.only_owner_release = false; 10b4f8: c6 45 d4 00 movb $0x0,-0x2c(%ebp) } mutex_status = _CORE_mutex_Initialize( 10b4fc: 50 push %eax 10b4fd: 31 c0 xor %eax,%eax 10b4ff: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b503: 0f 94 c0 sete %al 10b506: 50 push %eax 10b507: 8d 45 d0 lea -0x30(%ebp),%eax 10b50a: 50 push %eax 10b50b: 8d 42 14 lea 0x14(%edx),%eax 10b50e: 50 push %eax 10b50f: 89 55 c4 mov %edx,-0x3c(%ebp) 10b512: e8 69 0c 00 00 call 10c180 <_CORE_mutex_Initialize> &the_semaphore->Core_control.mutex, &the_mutex_attr, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10b517: 83 c4 10 add $0x10,%esp 10b51a: 83 f8 06 cmp $0x6,%eax 10b51d: 8b 55 c4 mov -0x3c(%ebp),%edx 10b520: 0f 84 a9 00 00 00 je 10b5cf Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b526: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10b529: 0f b7 d8 movzwl %ax,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b52c: 8b 0d dc 74 12 00 mov 0x1274dc,%ecx 10b532: 89 14 99 mov %edx,(%ecx,%ebx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10b535: 89 72 0c mov %esi,0xc(%edx) &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10b538: 89 07 mov %eax,(%edi) the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10b53a: e8 b5 23 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b53f: 31 c0 xor %eax,%eax 10b541: e9 25 ff ff ff jmp 10b46b 10b546: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10b548: b8 09 00 00 00 mov $0x9,%eax 10b54d: e9 19 ff ff ff jmp 10b46b 10b552: 66 90 xchg %ax,%ax */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; 10b554: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 10b55b: 31 c0 xor %eax,%eax 10b55d: f6 c3 04 test $0x4,%bl 10b560: 0f 95 c0 setne %al 10b563: 89 45 e4 mov %eax,-0x1c(%ebp) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; /* * The following are just to make Purify happy. */ the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10b566: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; 10b56d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) _CORE_semaphore_Initialize( 10b574: 51 push %ecx 10b575: ff 75 0c pushl 0xc(%ebp) 10b578: 8d 45 e0 lea -0x20(%ebp),%eax 10b57b: 50 push %eax 10b57c: 8d 42 14 lea 0x14(%edx),%eax 10b57f: 50 push %eax 10b580: 89 55 c4 mov %edx,-0x3c(%ebp) 10b583: e8 88 0e 00 00 call 10c410 <_CORE_semaphore_Initialize> 10b588: 83 c4 10 add $0x10,%esp 10b58b: 8b 55 c4 mov -0x3c(%ebp),%edx 10b58e: eb 96 jmp 10b526 _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 10b590: e8 5f 23 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10b595: b8 05 00 00 00 mov $0x5,%eax 10b59a: e9 cc fe ff ff jmp 10b46b the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attr.priority_ceiling = priority_ceiling; 10b59f: 8b 45 14 mov 0x14(%ebp),%eax 10b5a2: 89 45 dc mov %eax,-0x24(%ebp) the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10b5a5: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) the_mutex_attr.only_owner_release = false; 10b5ac: c6 45 d4 00 movb $0x0,-0x2c(%ebp) if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { 10b5b0: 83 7d d8 01 cmpl $0x1,-0x28(%ebp) 10b5b4: 0f 85 42 ff ff ff jne 10b4fc if ( _Attributes_Is_inherit_priority( attribute_set ) ) { 10b5ba: f6 c3 40 test $0x40,%bl 10b5bd: 74 30 je 10b5ef the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10b5bf: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp) the_mutex_attr.only_owner_release = true; 10b5c6: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b5ca: e9 2d ff ff ff jmp 10b4fc */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 10b5cf: 83 ec 08 sub $0x8,%esp 10b5d2: 52 push %edx 10b5d3: 68 c0 74 12 00 push $0x1274c0 10b5d8: e8 23 17 00 00 call 10cd00 <_Objects_Free> (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10b5dd: e8 12 23 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_INVALID_PRIORITY; 10b5e2: 83 c4 10 add $0x10,%esp 10b5e5: b8 13 00 00 00 mov $0x13,%eax 10b5ea: e9 7c fe ff ff jmp 10b46b if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { if ( _Attributes_Is_inherit_priority( attribute_set ) ) { the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; the_mutex_attr.only_owner_release = true; } else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) { 10b5ef: 81 e3 80 00 00 00 and $0x80,%ebx 10b5f5: 0f 84 01 ff ff ff je 10b4fc the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10b5fb: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp) the_mutex_attr.only_owner_release = true; 10b602: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b606: e9 f1 fe ff ff jmp 10b4fc =============================================================================== 0010b60c : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 10b60c: 55 push %ebp 10b60d: 89 e5 mov %esp,%ebp 10b60f: 53 push %ebx 10b610: 83 ec 18 sub $0x18,%esp register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); 10b613: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 10b616: 50 push %eax 10b617: ff 75 08 pushl 0x8(%ebp) 10b61a: 68 c0 74 12 00 push $0x1274c0 10b61f: e8 1c 18 00 00 call 10ce40 <_Objects_Get> 10b624: 89 c3 mov %eax,%ebx switch ( location ) { 10b626: 83 c4 10 add $0x10,%esp 10b629: 8b 4d f4 mov -0xc(%ebp),%ecx 10b62c: 85 c9 test %ecx,%ecx 10b62e: 74 0c je 10b63c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b630: b8 04 00 00 00 mov $0x4,%eax } 10b635: 8b 5d fc mov -0x4(%ebp),%ebx 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 10b63c: 8b 40 10 mov 0x10(%eax),%eax the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10b63f: 83 e0 30 and $0x30,%eax 10b642: 74 58 je 10b69c if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 10b644: 8b 53 64 mov 0x64(%ebx),%edx 10b647: 85 d2 test %edx,%edx 10b649: 75 15 jne 10b660 10b64b: 83 f8 20 cmp $0x20,%eax 10b64e: 74 10 je 10b660 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 10b650: e8 9f 22 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b655: b8 0c 00 00 00 mov $0xc,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b65a: 8b 5d fc mov -0x4(%ebp),%ebx 10b65d: c9 leave 10b65e: c3 ret 10b65f: 90 nop !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 10b660: 50 push %eax 10b661: 6a 04 push $0x4 10b663: 6a 00 push $0x0 10b665: 8d 43 14 lea 0x14(%ebx),%eax 10b668: 50 push %eax 10b669: e8 06 0b 00 00 call 10c174 <_CORE_mutex_Flush> 10b66e: 83 c4 10 add $0x10,%esp SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10b671: 83 ec 08 sub $0x8,%esp 10b674: 53 push %ebx 10b675: 68 c0 74 12 00 push $0x1274c0 10b67a: e8 85 13 00 00 call 10ca04 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 10b67f: 58 pop %eax 10b680: 5a pop %edx 10b681: 53 push %ebx 10b682: 68 c0 74 12 00 push $0x1274c0 10b687: e8 74 16 00 00 call 10cd00 <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10b68c: e8 63 22 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b691: 83 c4 10 add $0x10,%esp 10b694: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b696: 8b 5d fc mov -0x4(%ebp),%ebx 10b699: c9 leave 10b69a: c3 ret 10b69b: 90 nop &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10b69c: 51 push %ecx 10b69d: 6a 02 push $0x2 10b69f: 6a 00 push $0x0 10b6a1: 8d 43 14 lea 0x14(%ebx),%eax 10b6a4: 50 push %eax 10b6a5: e8 5a 0d 00 00 call 10c404 <_CORE_semaphore_Flush> 10b6aa: 83 c4 10 add $0x10,%esp 10b6ad: eb c2 jmp 10b671 =============================================================================== 0010b6b0 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10b6b0: 55 push %ebp 10b6b1: 89 e5 mov %esp,%ebp 10b6b3: 57 push %edi 10b6b4: 56 push %esi 10b6b5: 53 push %ebx 10b6b6: 83 ec 1c sub $0x1c,%esp 10b6b9: 8b 5d 08 mov 0x8(%ebp),%ebx 10b6bc: 8b 75 0c mov 0xc(%ebp),%esi 10b6bf: 8b 7d 10 mov 0x10(%ebp),%edi register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); 10b6c2: 8d 45 e0 lea -0x20(%ebp),%eax Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) _Objects_Get_isr_disable( &_Semaphore_Information, id, location, level ); 10b6c5: 50 push %eax 10b6c6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b6c9: 50 push %eax 10b6ca: 53 push %ebx 10b6cb: 68 c0 74 12 00 push $0x1274c0 10b6d0: e8 13 17 00 00 call 10cde8 <_Objects_Get_isr_disable> switch ( location ) { 10b6d5: 83 c4 10 add $0x10,%esp 10b6d8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b6db: 85 c9 test %ecx,%ecx 10b6dd: 74 0d je 10b6ec case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b6df: b8 04 00 00 00 mov $0x4,%eax } 10b6e4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6e7: 5b pop %ebx 10b6e8: 5e pop %esi 10b6e9: 5f pop %edi 10b6ea: c9 leave 10b6eb: c3 ret the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10b6ec: f6 40 10 30 testb $0x30,0x10(%eax) 10b6f0: 74 36 je 10b728 _CORE_mutex_Seize( 10b6f2: 83 ec 0c sub $0xc,%esp 10b6f5: ff 75 e0 pushl -0x20(%ebp) 10b6f8: 57 push %edi */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 10b6f9: 83 e6 01 and $0x1,%esi 10b6fc: 83 f6 01 xor $0x1,%esi 10b6ff: 56 push %esi 10b700: 53 push %ebx 10b701: 83 c0 14 add $0x14,%eax 10b704: 50 push %eax 10b705: e8 6e 0b 00 00 call 10c278 <_CORE_mutex_Seize> id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10b70a: 83 c4 14 add $0x14,%esp _Thread_Executing->Wait.return_code ); 10b70d: a1 58 7b 12 00 mov 0x127b58,%eax id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10b712: ff 70 34 pushl 0x34(%eax) 10b715: e8 12 01 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b71a: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10b71d: 8d 65 f4 lea -0xc(%ebp),%esp 10b720: 5b pop %ebx 10b721: 5e pop %esi 10b722: 5f pop %edi 10b723: c9 leave 10b724: c3 ret 10b725: 8d 76 00 lea 0x0(%esi),%esi { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 10b728: 8b 15 58 7b 12 00 mov 0x127b58,%edx executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10b72e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( the_semaphore->count != 0 ) { 10b735: 8b 48 5c mov 0x5c(%eax),%ecx 10b738: 85 c9 test %ecx,%ecx 10b73a: 75 2c jne 10b768 the_semaphore->count -= 1; _ISR_Enable( *level_p ); return; } if ( !wait ) { 10b73c: 83 e6 01 and $0x1,%esi 10b73f: 74 33 je 10b774 _ISR_Enable( *level_p ); 10b741: ff 75 e0 pushl -0x20(%ebp) 10b744: 9d popf executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 10b745: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10b74c: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code ); 10b74f: a1 58 7b 12 00 mov 0x127b58,%eax id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10b754: ff 70 34 pushl 0x34(%eax) 10b757: e8 e0 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b75c: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10b75f: 8d 65 f4 lea -0xc(%ebp),%esp 10b762: 5b pop %ebx 10b763: 5e pop %esi 10b764: 5f pop %edi 10b765: c9 leave 10b766: c3 ret 10b767: 90 nop /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 10b768: 49 dec %ecx 10b769: 89 48 5c mov %ecx,0x5c(%eax) _ISR_Enable( *level_p ); 10b76c: ff 75 e0 pushl -0x20(%ebp) 10b76f: 9d popf 10b770: eb da jmp 10b74c 10b772: 66 90 xchg %ax,%ax 10b774: 8b 0d 70 75 12 00 mov 0x127570,%ecx 10b77a: 41 inc %ecx 10b77b: 89 0d 70 75 12 00 mov %ecx,0x127570 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; 10b781: c7 40 44 01 00 00 00 movl $0x1,0x44(%eax) return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 10b788: 83 c0 14 add $0x14,%eax 10b78b: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 10b78e: 89 5a 20 mov %ebx,0x20(%edx) _ISR_Enable( *level_p ); 10b791: ff 75 e0 pushl -0x20(%ebp) 10b794: 9d popf _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 10b795: 52 push %edx 10b796: 68 fc e0 10 00 push $0x10e0fc 10b79b: 57 push %edi 10b79c: 50 push %eax 10b79d: e8 2e 26 00 00 call 10ddd0 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10b7a2: e8 4d 21 00 00 call 10d8f4 <_Thread_Enable_dispatch> 10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: eb a0 jmp 10b74c =============================================================================== 0010b7ac : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 10b7ac: 55 push %ebp 10b7ad: 89 e5 mov %esp,%ebp 10b7af: 53 push %ebx 10b7b0: 83 ec 18 sub $0x18,%esp 10b7b3: 8b 5d 08 mov 0x8(%ebp),%ebx register Semaphore_Control *the_semaphore; Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); 10b7b6: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 10b7b9: 50 push %eax 10b7ba: 53 push %ebx 10b7bb: 68 c0 74 12 00 push $0x1274c0 10b7c0: e8 7b 16 00 00 call 10ce40 <_Objects_Get> switch ( location ) { 10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 8b 55 f4 mov -0xc(%ebp),%edx 10b7cb: 85 d2 test %edx,%edx 10b7cd: 74 0d je 10b7dc case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b7cf: b8 04 00 00 00 mov $0x4,%eax } 10b7d4: 8b 5d fc mov -0x4(%ebp),%ebx 10b7d7: c9 leave 10b7d8: c3 ret 10b7d9: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10b7dc: f6 40 10 30 testb $0x30,0x10(%eax) 10b7e0: 75 26 jne 10b808 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 10b7e2: 52 push %edx 10b7e3: 6a 00 push $0x0 10b7e5: 53 push %ebx 10b7e6: 83 c0 14 add $0x14,%eax 10b7e9: 50 push %eax 10b7ea: e8 61 0c 00 00 call 10c450 <_CORE_semaphore_Surrender> 10b7ef: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10b7f1: e8 fe 20 00 00 call 10d8f4 <_Thread_Enable_dispatch> return 10b7f6: 89 1c 24 mov %ebx,(%esp) 10b7f9: e8 3e 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b7fe: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b801: 8b 5d fc mov -0x4(%ebp),%ebx 10b804: c9 leave 10b805: c3 ret 10b806: 66 90 xchg %ax,%ax the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { mutex_status = _CORE_mutex_Surrender( 10b808: 51 push %ecx 10b809: 6a 00 push $0x0 10b80b: 53 push %ebx 10b80c: 83 c0 14 add $0x14,%eax 10b80f: 50 push %eax 10b810: e8 03 0b 00 00 call 10c318 <_CORE_mutex_Surrender> 10b815: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10b817: e8 d8 20 00 00 call 10d8f4 <_Thread_Enable_dispatch> return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 10b81c: 89 1c 24 mov %ebx,(%esp) 10b81f: e8 08 00 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b824: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b827: 8b 5d fc mov -0x4(%ebp),%ebx 10b82a: c9 leave 10b82b: c3 ret =============================================================================== 00117d60 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 117d60: 55 push %ebp 117d61: 89 e5 mov %esp,%ebp 117d63: 53 push %ebx 117d64: 83 ec 14 sub $0x14,%esp 117d67: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 117d6a: 85 db test %ebx,%ebx 117d6c: 75 0a jne 117d78 return RTEMS_INVALID_NUMBER; 117d6e: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117d73: 8b 5d fc mov -0x4(%ebp),%ebx 117d76: c9 leave 117d77: c3 ret ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 117d78: 83 ec 08 sub $0x8,%esp 117d7b: 8d 45 f4 lea -0xc(%ebp),%eax 117d7e: 50 push %eax 117d7f: ff 75 08 pushl 0x8(%ebp) 117d82: e8 35 40 00 00 call 11bdbc <_Thread_Get> switch ( location ) { 117d87: 83 c4 10 add $0x10,%esp 117d8a: 8b 55 f4 mov -0xc(%ebp),%edx 117d8d: 85 d2 test %edx,%edx 117d8f: 74 0b je 117d9c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 117d91: b8 04 00 00 00 mov $0x4,%eax } 117d96: 8b 5d fc mov -0x4(%ebp),%ebx 117d99: c9 leave 117d9a: c3 ret 117d9b: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 117d9c: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 117da2: 8b 4a 0c mov 0xc(%edx),%ecx 117da5: 85 c9 test %ecx,%ecx 117da7: 74 3f je 117de8 if ( asr->is_enabled ) { 117da9: 80 7a 08 00 cmpb $0x0,0x8(%edx) 117dad: 74 25 je 117dd4 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 117daf: 9c pushf 117db0: fa cli 117db1: 59 pop %ecx *signal_set |= signals; 117db2: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 117db5: 51 push %ecx 117db6: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 117db7: 8b 15 f4 27 14 00 mov 0x1427f4,%edx 117dbd: 85 d2 test %edx,%edx 117dbf: 74 1b je 117ddc 117dc1: 3b 05 f8 27 14 00 cmp 0x1427f8,%eax 117dc7: 75 13 jne 117ddc <== NEVER TAKEN _Thread_Dispatch_necessary = true; 117dc9: c6 05 04 28 14 00 01 movb $0x1,0x142804 117dd0: eb 0a jmp 117ddc 117dd2: 66 90 xchg %ax,%ax rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 117dd4: 9c pushf 117dd5: fa cli 117dd6: 58 pop %eax *signal_set |= signals; 117dd7: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 117dda: 50 push %eax 117ddb: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 117ddc: e8 b7 3f 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 117de1: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117de3: 8b 5d fc mov -0x4(%ebp),%ebx 117de6: c9 leave 117de7: c3 ret _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 117de8: e8 ab 3f 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 117ded: b8 0b 00 00 00 mov $0xb,%eax 117df2: e9 7c ff ff ff jmp 117d73 =============================================================================== 0010b84c : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, rtems_id *id ) { 10b84c: 55 push %ebp 10b84d: 89 e5 mov %esp,%ebp 10b84f: 57 push %edi 10b850: 56 push %esi 10b851: 53 push %ebx 10b852: 83 ec 1c sub $0x1c,%esp 10b855: 8b 5d 08 mov 0x8(%ebp),%ebx 10b858: 8b 7d 0c mov 0xc(%ebp),%edi 10b85b: 8b 75 1c mov 0x1c(%ebp),%esi Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10b85e: 85 f6 test %esi,%esi 10b860: 0f 84 3e 01 00 00 je 10b9a4 return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10b866: 85 db test %ebx,%ebx 10b868: 0f 84 d2 00 00 00 je 10b940 /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 10b86e: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp) 10b875: 75 17 jne 10b88e */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10b877: 85 ff test %edi,%edi 10b879: 0f 84 b1 00 00 00 je 10b930 ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 10b87f: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10b886: 39 c7 cmp %eax,%edi 10b888: 0f 87 a2 00 00 00 ja 10b930 */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10b88e: 83 ec 0c sub $0xc,%esp 10b891: ff 35 5c 76 12 00 pushl 0x12765c 10b897: e8 c8 06 00 00 call 10bf64 <_API_Mutex_Lock> * This function allocates a task control block from * the inactive chain of free task control blocks. */ RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information ); 10b89c: c7 04 24 00 75 12 00 movl $0x127500,(%esp) 10b8a3: e8 e0 10 00 00 call 10c988 <_Objects_Allocate> 10b8a8: 89 c2 mov %eax,%edx * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10b8aa: 83 c4 10 add $0x10,%esp 10b8ad: 85 c0 test %eax,%eax 10b8af: 0f 84 cf 00 00 00 je 10b984 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10b8b5: 50 push %eax 10b8b6: 53 push %ebx */ RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level ( Modes_Control mode_set ) { return ( mode_set & RTEMS_INTERRUPT_MASK ); 10b8b7: 8b 45 14 mov 0x14(%ebp),%eax 10b8ba: 83 e0 01 and $0x1,%eax 10b8bd: 50 push %eax 10b8be: 6a 00 push $0x0 10b8c0: 31 c0 xor %eax,%eax 10b8c2: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp) 10b8c9: 0f 95 c0 setne %al 10b8cc: 50 push %eax 10b8cd: 31 c0 xor %eax,%eax 10b8cf: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp) 10b8d6: 0f 94 c0 sete %al 10b8d9: 50 push %eax 10b8da: 57 push %edi */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point( rtems_attribute attribute_set ) { return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false; 10b8db: 8b 45 18 mov 0x18(%ebp),%eax 10b8de: 83 e0 01 and $0x1,%eax 10b8e1: 50 push %eax 10b8e2: ff 75 10 pushl 0x10(%ebp) 10b8e5: 6a 00 push $0x0 10b8e7: 52 push %edx 10b8e8: 68 00 75 12 00 push $0x127500 10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp) 10b8f0: e8 97 20 00 00 call 10d98c <_Thread_Initialize> NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 10b8f5: 83 c4 30 add $0x30,%esp 10b8f8: 84 c0 test %al,%al 10b8fa: 8b 55 e4 mov -0x1c(%ebp),%edx 10b8fd: 74 51 je 10b950 _RTEMS_Unlock_allocator(); return RTEMS_UNSATISFIED; } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; 10b8ff: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax * id - thread id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_task_create( 10b905: f7 45 14 00 04 00 00 testl $0x400,0x14(%ebp) } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 10b90c: 0f 94 40 08 sete 0x8(%eax) *id = the_thread->Object.id; 10b910: 8b 42 08 mov 0x8(%edx),%eax 10b913: 89 06 mov %eax,(%esi) ); } #endif _RTEMS_Unlock_allocator(); 10b915: 83 ec 0c sub $0xc,%esp 10b918: ff 35 5c 76 12 00 pushl 0x12765c 10b91e: e8 89 06 00 00 call 10bfac <_API_Mutex_Unlock> return RTEMS_SUCCESSFUL; 10b923: 83 c4 10 add $0x10,%esp 10b926: 31 c0 xor %eax,%eax } 10b928: 8d 65 f4 lea -0xc(%ebp),%esp 10b92b: 5b pop %ebx 10b92c: 5e pop %esi 10b92d: 5f pop %edi 10b92e: c9 leave 10b92f: c3 ret * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) ) return RTEMS_INVALID_PRIORITY; 10b930: b8 13 00 00 00 mov $0x13,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b935: 8d 65 f4 lea -0xc(%ebp),%esp 10b938: 5b pop %ebx 10b939: 5e pop %esi 10b93a: 5f pop %edi 10b93b: c9 leave 10b93c: c3 ret 10b93d: 8d 76 00 lea 0x0(%esi),%esi if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10b940: b8 03 00 00 00 mov $0x3,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b945: 8d 65 f4 lea -0xc(%ebp),%esp 10b948: 5b pop %ebx 10b949: 5e pop %esi 10b94a: 5f pop %edi 10b94b: c9 leave 10b94c: c3 ret 10b94d: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free ( Thread_Control *the_task ) { _Objects_Free( 10b950: 83 ec 0c sub $0xc,%esp 10b953: ff 72 08 pushl 0x8(%edx) 10b956: e8 15 14 00 00 call 10cd70 <_Objects_Get_information_id> 10b95b: 5a pop %edx 10b95c: 59 pop %ecx 10b95d: 8b 55 e4 mov -0x1c(%ebp),%edx 10b960: 52 push %edx 10b961: 50 push %eax 10b962: e8 99 13 00 00 call 10cd00 <_Objects_Free> #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b967: 58 pop %eax 10b968: ff 35 5c 76 12 00 pushl 0x12765c 10b96e: e8 39 06 00 00 call 10bfac <_API_Mutex_Unlock> return RTEMS_UNSATISFIED; 10b973: 83 c4 10 add $0x10,%esp 10b976: b8 0d 00 00 00 mov $0xd,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b97b: 8d 65 f4 lea -0xc(%ebp),%esp 10b97e: 5b pop %ebx 10b97f: 5e pop %esi 10b980: 5f pop %edi 10b981: c9 leave 10b982: c3 ret 10b983: 90 nop */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10b984: 83 ec 0c sub $0xc,%esp 10b987: ff 35 5c 76 12 00 pushl 0x12765c 10b98d: e8 1a 06 00 00 call 10bfac <_API_Mutex_Unlock> return RTEMS_TOO_MANY; 10b992: 83 c4 10 add $0x10,%esp 10b995: b8 05 00 00 00 mov $0x5,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10b99a: 8d 65 f4 lea -0xc(%ebp),%esp 10b99d: 5b pop %ebx 10b99e: 5e pop %esi 10b99f: 5f pop %edi 10b9a0: c9 leave 10b9a1: c3 ret 10b9a2: 66 90 xchg %ax,%ax RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) return RTEMS_INVALID_ADDRESS; 10b9a4: b8 09 00 00 00 mov $0x9,%eax 10b9a9: eb 8a jmp 10b935 =============================================================================== 0010b9ac : */ rtems_status_code rtems_task_delete( rtems_id id ) { 10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 53 push %ebx 10b9b0: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 10b9b3: ff 35 5c 76 12 00 pushl 0x12765c 10b9b9: e8 a6 05 00 00 call 10bf64 <_API_Mutex_Lock> the_thread = _Thread_Get( id, &location ); 10b9be: 5a pop %edx 10b9bf: 59 pop %ecx 10b9c0: 8d 45 f4 lea -0xc(%ebp),%eax 10b9c3: 50 push %eax 10b9c4: ff 75 08 pushl 0x8(%ebp) 10b9c7: e8 4c 1f 00 00 call 10d918 <_Thread_Get> 10b9cc: 89 c3 mov %eax,%ebx switch ( location ) { 10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 8b 45 f4 mov -0xc(%ebp),%eax 10b9d4: 85 c0 test %eax,%eax 10b9d6: 75 44 jne 10ba1c case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10b9d8: 83 ec 0c sub $0xc,%esp 10b9db: ff 73 08 pushl 0x8(%ebx) 10b9de: e8 8d 13 00 00 call 10cd70 <_Objects_Get_information_id> 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 10b9e3: 5a pop %edx 10b9e4: 59 pop %ecx 10b9e5: 53 push %ebx 10b9e6: 50 push %eax 10b9e7: e8 c8 1b 00 00 call 10d5b4 <_Thread_Close> 10b9ec: 58 pop %eax 10b9ed: ff 73 08 pushl 0x8(%ebx) 10b9f0: e8 7b 13 00 00 call 10cd70 <_Objects_Get_information_id> 10b9f5: 5a pop %edx 10b9f6: 59 pop %ecx 10b9f7: 53 push %ebx 10b9f8: 50 push %eax 10b9f9: e8 02 13 00 00 call 10cd00 <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10b9fe: 58 pop %eax 10b9ff: ff 35 5c 76 12 00 pushl 0x12765c 10ba05: e8 a2 05 00 00 call 10bfac <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 10ba0a: e8 e5 1e 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ba0f: 83 c4 10 add $0x10,%esp 10ba12: 31 c0 xor %eax,%eax break; } _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; } 10ba14: 8b 5d fc mov -0x4(%ebp),%ebx 10ba17: c9 leave 10ba18: c3 ret 10ba19: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 10ba1c: 83 ec 0c sub $0xc,%esp 10ba1f: ff 35 5c 76 12 00 pushl 0x12765c 10ba25: e8 82 05 00 00 call 10bfac <_API_Mutex_Unlock> return RTEMS_INVALID_ID; 10ba2a: 83 c4 10 add $0x10,%esp 10ba2d: b8 04 00 00 00 mov $0x4,%eax } 10ba32: 8b 5d fc mov -0x4(%ebp),%ebx 10ba35: c9 leave 10ba36: c3 ret =============================================================================== 0010d4e4 : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10d4e4: 55 push %ebp 10d4e5: 89 e5 mov %esp,%ebp 10d4e7: 56 push %esi 10d4e8: 53 push %ebx 10d4e9: 83 ec 10 sub $0x10,%esp 10d4ec: 8b 45 08 mov 0x8(%ebp),%eax 10d4ef: 8b 75 0c mov 0xc(%ebp),%esi 10d4f2: 8b 5d 10 mov 0x10(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10d4f5: 80 3d e4 61 12 00 00 cmpb $0x0,0x1261e4 10d4fc: 74 6e je 10d56c return RTEMS_NOT_CONFIGURED; if ( !note ) 10d4fe: 85 db test %ebx,%ebx 10d500: 74 7e je 10d580 /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10d502: 83 fe 0f cmp $0xf,%esi 10d505: 77 3d ja 10d544 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d507: 85 c0 test %eax,%eax 10d509: 74 45 je 10d550 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10d50b: 8b 15 18 ae 12 00 mov 0x12ae18,%edx /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d511: 3b 42 08 cmp 0x8(%edx),%eax 10d514: 74 40 je 10d556 api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10d516: 83 ec 08 sub $0x8,%esp 10d519: 8d 55 f4 lea -0xc(%ebp),%edx 10d51c: 52 push %edx 10d51d: 50 push %eax 10d51e: e8 3d 22 00 00 call 10f760 <_Thread_Get> switch ( location ) { 10d523: 83 c4 10 add $0x10,%esp 10d526: 8b 55 f4 mov -0xc(%ebp),%edx 10d529: 85 d2 test %edx,%edx 10d52b: 75 4b jne 10d578 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10d52d: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10d533: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d537: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10d539: e8 fe 21 00 00 call 10f73c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d53e: 31 c0 xor %eax,%eax 10d540: eb 07 jmp 10d549 10d542: 66 90 xchg %ax,%ax * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) return RTEMS_INVALID_NUMBER; 10d544: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d549: 8d 65 f8 lea -0x8(%ebp),%esp 10d54c: 5b pop %ebx 10d54d: 5e pop %esi 10d54e: c9 leave 10d54f: c3 ret /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d550: 8b 15 18 ae 12 00 mov 0x12ae18,%edx _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10d556: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10d55c: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d560: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 10d562: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d564: 8d 65 f8 lea -0x8(%ebp),%esp 10d567: 5b pop %ebx 10d568: 5e pop %esi 10d569: c9 leave 10d56a: c3 ret 10d56b: 90 nop register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10d56c: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d571: 8d 65 f8 lea -0x8(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: c9 leave 10d577: c3 ret case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d578: b8 04 00 00 00 mov $0x4,%eax 10d57d: eb ca jmp 10d549 10d57f: 90 nop if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) return RTEMS_INVALID_ADDRESS; 10d580: b8 09 00 00 00 mov $0x9,%eax 10d585: eb c2 jmp 10d549 =============================================================================== 00118144 : */ rtems_status_code rtems_task_is_suspended( rtems_id id ) { 118144: 55 push %ebp 118145: 89 e5 mov %esp,%ebp 118147: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 11814a: 8d 45 f4 lea -0xc(%ebp),%eax 11814d: 50 push %eax 11814e: ff 75 08 pushl 0x8(%ebp) 118151: e8 66 3c 00 00 call 11bdbc <_Thread_Get> switch ( location ) { 118156: 83 c4 10 add $0x10,%esp 118159: 8b 55 f4 mov -0xc(%ebp),%edx 11815c: 85 d2 test %edx,%edx 11815e: 74 08 je 118168 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118160: b8 04 00 00 00 mov $0x4,%eax } 118165: c9 leave 118166: c3 ret 118167: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 118168: f6 40 10 02 testb $0x2,0x10(%eax) 11816c: 74 0e je 11817c _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11816e: e8 25 3c 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 118173: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118178: c9 leave 118179: c3 ret 11817a: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Enable_dispatch(); 11817c: e8 17 3c 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118181: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118183: c9 leave 118184: c3 ret =============================================================================== 00112e94 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 112e94: 55 push %ebp 112e95: 89 e5 mov %esp,%ebp 112e97: 57 push %edi 112e98: 56 push %esi 112e99: 53 push %ebx 112e9a: 83 ec 1c sub $0x1c,%esp 112e9d: 8b 4d 10 mov 0x10(%ebp),%ecx ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 112ea0: 85 c9 test %ecx,%ecx 112ea2: 0f 84 40 01 00 00 je 112fe8 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 112ea8: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx api = executing->API_Extensions[ THREAD_API_RTEMS ]; 112eae: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 112eb4: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 112eb8: 19 f6 sbb %esi,%esi 112eba: 81 e6 00 01 00 00 and $0x100,%esi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 112ec0: 8b 53 7c mov 0x7c(%ebx),%edx 112ec3: 85 d2 test %edx,%edx 112ec5: 0f 85 f1 00 00 00 jne 112fbc old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 112ecb: 80 7f 08 01 cmpb $0x1,0x8(%edi) 112ecf: 19 d2 sbb %edx,%edx 112ed1: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 112ed7: 89 55 e4 mov %edx,-0x1c(%ebp) 112eda: 89 4d e0 mov %ecx,-0x20(%ebp) 112edd: e8 7a be ff ff call 10ed5c <_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; 112ee2: 8b 55 e4 mov -0x1c(%ebp),%edx 112ee5: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 112ee7: 09 f0 or %esi,%eax 112ee9: 8b 4d e0 mov -0x20(%ebp),%ecx 112eec: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 112eee: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 112ef5: 74 0b je 112f02 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 112ef7: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 112efe: 0f 94 43 74 sete 0x74(%ebx) if ( mask & RTEMS_TIMESLICE_MASK ) { 112f02: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 112f09: 74 1c je 112f27 if ( _Modes_Is_timeslice(mode_set) ) { 112f0b: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 112f12: 0f 84 b8 00 00 00 je 112fd0 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 112f18: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 112f1f: a1 40 75 12 00 mov 0x127540,%eax 112f24: 89 43 78 mov %eax,0x78(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112f27: f6 45 0c 01 testb $0x1,0xc(%ebp) 112f2b: 74 0b je 112f38 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 112f2d: f6 45 08 01 testb $0x1,0x8(%ebp) 112f31: 0f 84 91 00 00 00 je 112fc8 112f37: fa cli * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 112f38: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 112f3f: 74 3f je 112f80 * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 112f41: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 112f48: 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 ) { 112f4b: 38 47 08 cmp %al,0x8(%edi) 112f4e: 74 30 je 112f80 asr->is_enabled = is_asr_enabled; 112f50: 88 47 08 mov %al,0x8(%edi) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 112f53: 9c pushf 112f54: fa cli 112f55: 58 pop %eax _signals = information->signals_pending; 112f56: 8b 57 18 mov 0x18(%edi),%edx information->signals_pending = information->signals_posted; 112f59: 8b 4f 14 mov 0x14(%edi),%ecx 112f5c: 89 4f 18 mov %ecx,0x18(%edi) information->signals_posted = _signals; 112f5f: 89 57 14 mov %edx,0x14(%edi) _ISR_Enable( _level ); 112f62: 50 push %eax 112f63: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 112f64: 8b 47 14 mov 0x14(%edi),%eax 112f67: 85 c0 test %eax,%eax 112f69: 0f 95 c0 setne %al needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 112f6c: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740 112f73: 74 16 je 112f8b <== ALWAYS TAKEN if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 112f75: 31 c0 xor %eax,%eax } 112f77: 83 c4 1c add $0x1c,%esp 112f7a: 5b pop %ebx 112f7b: 5e pop %esi 112f7c: 5f pop %edi 112f7d: c9 leave 112f7e: c3 ret 112f7f: 90 nop /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 112f80: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 112f82: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740 112f89: 75 ea jne 112f75 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 112f8b: 8b 15 58 7b 12 00 mov 0x127b58,%edx if ( are_signals_pending || 112f91: 84 c0 test %al,%al 112f93: 75 0e jne 112fa3 112f95: 3b 15 5c 7b 12 00 cmp 0x127b5c,%edx 112f9b: 74 d8 je 112f75 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 112f9d: 80 7a 74 00 cmpb $0x0,0x74(%edx) 112fa1: 74 d2 je 112f75 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 112fa3: c6 05 64 7b 12 00 01 movb $0x1,0x127b64 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 112faa: e8 cd a7 ff ff call 10d77c <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 112faf: 31 c0 xor %eax,%eax } 112fb1: 83 c4 1c add $0x1c,%esp 112fb4: 5b pop %ebx 112fb5: 5e pop %esi 112fb6: 5f pop %edi 112fb7: c9 leave 112fb8: c3 ret 112fb9: 8d 76 00 lea 0x0(%esi),%esi old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 112fbc: 81 ce 00 02 00 00 or $0x200,%esi 112fc2: e9 04 ff ff ff jmp 112ecb 112fc7: 90 nop 112fc8: fb sti 112fc9: e9 6a ff ff ff jmp 112f38 112fce: 66 90 xchg %ax,%ax if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 112fd0: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112fd7: f6 45 0c 01 testb $0x1,0xc(%ebp) 112fdb: 0f 84 57 ff ff ff je 112f38 112fe1: e9 47 ff ff ff jmp 112f2d 112fe6: 66 90 xchg %ax,%ax bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 112fe8: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 112fed: 83 c4 1c add $0x1c,%esp 112ff0: 5b pop %ebx 112ff1: 5e pop %esi 112ff2: 5f pop %edi 112ff3: c9 leave 112ff4: c3 ret =============================================================================== 0010ecdc : */ rtems_status_code rtems_task_resume( rtems_id id ) { 10ecdc: 55 push %ebp 10ecdd: 89 e5 mov %esp,%ebp 10ecdf: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ece2: 8d 45 f4 lea -0xc(%ebp),%eax 10ece5: 50 push %eax 10ece6: ff 75 08 pushl 0x8(%ebp) 10ece9: e8 62 1f 00 00 call 110c50 <_Thread_Get> switch ( location ) { 10ecee: 83 c4 10 add $0x10,%esp 10ecf1: 8b 55 f4 mov -0xc(%ebp),%edx 10ecf4: 85 d2 test %edx,%edx 10ecf6: 74 08 je 10ed00 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10ecf8: b8 04 00 00 00 mov $0x4,%eax } 10ecfd: c9 leave 10ecfe: c3 ret 10ecff: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10ed00: f6 40 10 02 testb $0x2,0x10(%eax) 10ed04: 75 0e jne 10ed14 _Thread_Resume( the_thread, true ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ed06: e8 21 1f 00 00 call 110c2c <_Thread_Enable_dispatch> return RTEMS_INCORRECT_STATE; 10ed0b: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ed10: c9 leave 10ed11: c3 ret 10ed12: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, true ); 10ed14: 83 ec 08 sub $0x8,%esp 10ed17: 6a 01 push $0x1 10ed19: 50 push %eax 10ed1a: e8 4d 27 00 00 call 11146c <_Thread_Resume> _Thread_Enable_dispatch(); 10ed1f: e8 08 1f 00 00 call 110c2c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ed24: 83 c4 10 add $0x10,%esp 10ed27: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ed29: c9 leave 10ed2a: c3 ret =============================================================================== 0010d65c : rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 10d65c: 55 push %ebp 10d65d: 89 e5 mov %esp,%ebp 10d65f: 56 push %esi 10d660: 53 push %ebx 10d661: 83 ec 10 sub $0x10,%esp 10d664: 8b 45 08 mov 0x8(%ebp),%eax 10d667: 8b 5d 0c mov 0xc(%ebp),%ebx 10d66a: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10d66d: 80 3d e4 61 12 00 00 cmpb $0x0,0x1261e4 10d674: 74 66 je 10d6dc /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10d676: 83 fb 0f cmp $0xf,%ebx 10d679: 77 39 ja 10d6b4 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d67b: 85 c0 test %eax,%eax 10d67d: 74 41 je 10d6c0 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10d67f: 8b 15 18 ae 12 00 mov 0x12ae18,%edx /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d685: 3b 42 08 cmp 0x8(%edx),%eax 10d688: 74 3c je 10d6c6 api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10d68a: 83 ec 08 sub $0x8,%esp 10d68d: 8d 55 f4 lea -0xc(%ebp),%edx 10d690: 52 push %edx 10d691: 50 push %eax 10d692: e8 c9 20 00 00 call 10f760 <_Thread_Get> switch ( location ) { 10d697: 83 c4 10 add $0x10,%esp 10d69a: 8b 55 f4 mov -0xc(%ebp),%edx 10d69d: 85 d2 test %edx,%edx 10d69f: 75 47 jne 10d6e8 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10d6a1: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10d6a7: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) _Thread_Enable_dispatch(); 10d6ab: e8 8c 20 00 00 call 10f73c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d6b0: 31 c0 xor %eax,%eax 10d6b2: eb 05 jmp 10d6b9 * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) return RTEMS_INVALID_NUMBER; 10d6b4: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10d6bc: 5b pop %ebx 10d6bd: 5e pop %esi 10d6be: c9 leave 10d6bf: c3 ret /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10d6c0: 8b 15 18 ae 12 00 mov 0x12ae18,%edx _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10d6c6: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10d6cc: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) return RTEMS_SUCCESSFUL; 10d6d0: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d6d2: 8d 65 f8 lea -0x8(%ebp),%esp 10d6d5: 5b pop %ebx 10d6d6: 5e pop %esi 10d6d7: c9 leave 10d6d8: c3 ret 10d6d9: 8d 76 00 lea 0x0(%esi),%esi register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10d6dc: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10d6e1: 8d 65 f8 lea -0x8(%ebp),%esp 10d6e4: 5b pop %ebx 10d6e5: 5e pop %esi 10d6e6: c9 leave 10d6e7: c3 ret case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d6e8: b8 04 00 00 00 mov $0x4,%eax } 10d6ed: 8d 65 f8 lea -0x8(%ebp),%esp 10d6f0: 5b pop %ebx 10d6f1: 5e pop %esi 10d6f2: c9 leave 10d6f3: c3 ret =============================================================================== 0010f9a0 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10f9a0: 55 push %ebp 10f9a1: 89 e5 mov %esp,%ebp 10f9a3: 56 push %esi 10f9a4: 53 push %ebx 10f9a5: 83 ec 10 sub $0x10,%esp 10f9a8: 8b 5d 0c mov 0xc(%ebp),%ebx 10f9ab: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10f9ae: 85 db test %ebx,%ebx 10f9b0: 74 0b je 10f9bd 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 ) ); 10f9b2: 0f b6 05 34 72 12 00 movzbl 0x127234,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10f9b9: 39 c3 cmp %eax,%ebx 10f9bb: 77 5f ja 10fa1c !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f9bd: 85 f6 test %esi,%esi 10f9bf: 74 67 je 10fa28 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10f9c1: 83 ec 08 sub $0x8,%esp 10f9c4: 8d 45 f4 lea -0xc(%ebp),%eax 10f9c7: 50 push %eax 10f9c8: ff 75 08 pushl 0x8(%ebp) 10f9cb: e8 c0 20 00 00 call 111a90 <_Thread_Get> switch ( location ) { 10f9d0: 83 c4 10 add $0x10,%esp 10f9d3: 8b 55 f4 mov -0xc(%ebp),%edx 10f9d6: 85 d2 test %edx,%edx 10f9d8: 75 36 jne 10fa10 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10f9da: 8b 50 14 mov 0x14(%eax),%edx 10f9dd: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10f9df: 85 db test %ebx,%ebx 10f9e1: 74 1c je 10f9ff the_thread->real_priority = new_priority; 10f9e3: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10f9e6: 8b 48 1c mov 0x1c(%eax),%ecx 10f9e9: 85 c9 test %ecx,%ecx 10f9eb: 74 05 je 10f9f2 10f9ed: 3b 58 14 cmp 0x14(%eax),%ebx 10f9f0: 73 0d jae 10f9ff <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10f9f2: 52 push %edx 10f9f3: 6a 00 push $0x0 10f9f5: 53 push %ebx 10f9f6: 50 push %eax 10f9f7: e8 bc 1b 00 00 call 1115b8 <_Thread_Change_priority> 10f9fc: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10f9ff: e8 68 20 00 00 call 111a6c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10fa04: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa06: 8d 65 f8 lea -0x8(%ebp),%esp 10fa09: 5b pop %ebx 10fa0a: 5e pop %esi 10fa0b: c9 leave 10fa0c: c3 ret 10fa0d: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10fa10: b8 04 00 00 00 mov $0x4,%eax } 10fa15: 8d 65 f8 lea -0x8(%ebp),%esp 10fa18: 5b pop %ebx 10fa19: 5e pop %esi 10fa1a: c9 leave 10fa1b: c3 ret register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10fa1c: b8 13 00 00 00 mov $0x13,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa21: 8d 65 f8 lea -0x8(%ebp),%esp 10fa24: 5b pop %ebx 10fa25: 5e pop %esi 10fa26: c9 leave 10fa27: c3 ret if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10fa28: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa2d: 8d 65 f8 lea -0x8(%ebp),%esp 10fa30: 5b pop %ebx 10fa31: 5e pop %esi 10fa32: c9 leave 10fa33: c3 ret =============================================================================== 0010baf4 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 10baf4: 55 push %ebp 10baf5: 89 e5 mov %esp,%ebp 10baf7: 53 push %ebx 10baf8: 83 ec 14 sub $0x14,%esp 10bafb: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10bafe: 85 db test %ebx,%ebx 10bb00: 74 4e je 10bb50 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10bb02: 83 ec 08 sub $0x8,%esp 10bb05: 8d 45 f4 lea -0xc(%ebp),%eax 10bb08: 50 push %eax 10bb09: ff 75 08 pushl 0x8(%ebp) 10bb0c: e8 07 1e 00 00 call 10d918 <_Thread_Get> switch ( location ) { 10bb11: 83 c4 10 add $0x10,%esp 10bb14: 8b 55 f4 mov -0xc(%ebp),%edx 10bb17: 85 d2 test %edx,%edx 10bb19: 75 29 jne 10bb44 case OBJECTS_LOCAL: if ( _Thread_Start( 10bb1b: 83 ec 0c sub $0xc,%esp 10bb1e: ff 75 10 pushl 0x10(%ebp) 10bb21: 6a 00 push $0x0 10bb23: 53 push %ebx 10bb24: 6a 00 push $0x0 10bb26: 50 push %eax 10bb27: e8 d8 27 00 00 call 10e304 <_Thread_Start> 10bb2c: 83 c4 20 add $0x20,%esp 10bb2f: 84 c0 test %al,%al 10bb31: 75 29 jne 10bb5c the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10bb33: e8 bc 1d 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_INCORRECT_STATE; 10bb38: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb3d: 8b 5d fc mov -0x4(%ebp),%ebx 10bb40: c9 leave 10bb41: c3 ret 10bb42: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bb44: b8 04 00 00 00 mov $0x4,%eax } 10bb49: 8b 5d fc mov -0x4(%ebp),%ebx 10bb4c: c9 leave 10bb4d: c3 ret 10bb4e: 66 90 xchg %ax,%ax { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; 10bb50: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb55: 8b 5d fc mov -0x4(%ebp),%ebx 10bb58: c9 leave 10bb59: c3 ret 10bb5a: 66 90 xchg %ax,%ax switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 10bb5c: e8 93 1d 00 00 call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bb61: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb63: 8b 5d fc mov -0x4(%ebp),%ebx 10bb66: c9 leave 10bb67: c3 ret =============================================================================== 00110f40 : */ rtems_status_code rtems_task_suspend( rtems_id id ) { 110f40: 55 push %ebp 110f41: 89 e5 mov %esp,%ebp 110f43: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 110f46: 8d 45 f4 lea -0xc(%ebp),%eax 110f49: 50 push %eax 110f4a: ff 75 08 pushl 0x8(%ebp) 110f4d: e8 c6 c9 ff ff call 10d918 <_Thread_Get> switch ( location ) { 110f52: 83 c4 10 add $0x10,%esp 110f55: 8b 55 f4 mov -0xc(%ebp),%edx 110f58: 85 d2 test %edx,%edx 110f5a: 74 08 je 110f64 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 110f5c: b8 04 00 00 00 mov $0x4,%eax } 110f61: c9 leave 110f62: c3 ret 110f63: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 110f64: f6 40 10 02 testb $0x2,0x10(%eax) 110f68: 74 0e je 110f78 _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 110f6a: e8 85 c9 ff ff call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 110f6f: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110f74: c9 leave 110f75: c3 ret 110f76: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 110f78: 83 ec 0c sub $0xc,%esp 110f7b: 50 push %eax 110f7c: e8 f7 09 00 00 call 111978 <_Thread_Suspend> _Thread_Enable_dispatch(); 110f81: e8 6e c9 ff ff call 10d8f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 110f86: 83 c4 10 add $0x10,%esp 110f89: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110f8b: c9 leave 110f8c: c3 ret =============================================================================== 0010c650 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 10c650: 55 push %ebp 10c651: 89 e5 mov %esp,%ebp 10c653: 57 push %edi 10c654: 56 push %esi 10c655: 53 push %ebx 10c656: 83 ec 1c sub $0x1c,%esp 10c659: 8b 5d 0c mov 0xc(%ebp),%ebx 10c65c: 8b 7d 10 mov 0x10(%ebp),%edi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 10c65f: 85 db test %ebx,%ebx 10c661: 0f 84 9d 00 00 00 je 10c704 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10c667: 83 ec 08 sub $0x8,%esp 10c66a: 8d 45 e4 lea -0x1c(%ebp),%eax 10c66d: 50 push %eax 10c66e: ff 75 08 pushl 0x8(%ebp) 10c671: e8 b2 1f 00 00 call 10e628 <_Thread_Get> 10c676: 89 c6 mov %eax,%esi switch (location) { 10c678: 83 c4 10 add $0x10,%esp 10c67b: 8b 45 e4 mov -0x1c(%ebp),%eax 10c67e: 85 c0 test %eax,%eax 10c680: 74 0e je 10c690 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c682: b8 04 00 00 00 mov $0x4,%eax } 10c687: 8d 65 f4 lea -0xc(%ebp),%esp 10c68a: 5b pop %ebx 10c68b: 5e pop %esi 10c68c: 5f pop %edi 10c68d: c9 leave 10c68e: c3 ret 10c68f: 90 nop case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 10c690: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax while (tvp) { 10c696: 85 c0 test %eax,%eax 10c698: 75 44 jne 10c6de 10c69a: 66 90 xchg %ax,%ax /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); 10c69c: 83 ec 0c sub $0xc,%esp 10c69f: 6a 14 push $0x14 10c6a1: e8 ca 2f 00 00 call 10f670 <_Workspace_Allocate> if (new == NULL) { 10c6a6: 83 c4 10 add $0x10,%esp 10c6a9: 85 c0 test %eax,%eax 10c6ab: 74 4b je 10c6f8 _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 10c6ad: 8b 13 mov (%ebx),%edx 10c6af: 89 50 08 mov %edx,0x8(%eax) new->ptr = ptr; 10c6b2: 89 58 04 mov %ebx,0x4(%eax) new->dtor = dtor; 10c6b5: 89 78 10 mov %edi,0x10(%eax) new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 10c6b8: 8b 96 f4 00 00 00 mov 0xf4(%esi),%edx 10c6be: 89 10 mov %edx,(%eax) the_thread->task_variables = new; 10c6c0: 89 86 f4 00 00 00 mov %eax,0xf4(%esi) _Thread_Enable_dispatch(); 10c6c6: e8 39 1f 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c6cb: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6cd: 8d 65 f4 lea -0xc(%ebp),%esp 10c6d0: 5b pop %ebx 10c6d1: 5e pop %esi 10c6d2: 5f pop %edi 10c6d3: c9 leave 10c6d4: c3 ret 10c6d5: 8d 76 00 lea 0x0(%esi),%esi if (tvp->ptr == ptr) { tvp->dtor = dtor; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10c6d8: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10c6da: 85 c0 test %eax,%eax 10c6dc: 74 be je 10c69c if (tvp->ptr == ptr) { 10c6de: 39 58 04 cmp %ebx,0x4(%eax) 10c6e1: 75 f5 jne 10c6d8 tvp->dtor = dtor; 10c6e3: 89 78 10 mov %edi,0x10(%eax) _Thread_Enable_dispatch(); 10c6e6: e8 19 1f 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c6eb: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6ed: 8d 65 f4 lea -0xc(%ebp),%esp 10c6f0: 5b pop %ebx 10c6f1: 5e pop %esi 10c6f2: 5f pop %edi 10c6f3: c9 leave 10c6f4: c3 ret 10c6f5: 8d 76 00 lea 0x0(%esi),%esi * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); 10c6f8: e8 07 1f 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_NO_MEMORY; 10c6fd: b8 1a 00 00 00 mov $0x1a,%eax 10c702: eb 83 jmp 10c687 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 10c704: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c709: 8d 65 f4 lea -0xc(%ebp),%esp 10c70c: 5b pop %ebx 10c70d: 5e pop %esi 10c70e: 5f pop %edi 10c70f: c9 leave 10c710: c3 ret =============================================================================== 0010c714 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 10c714: 55 push %ebp 10c715: 89 e5 mov %esp,%ebp 10c717: 53 push %ebx 10c718: 83 ec 14 sub $0x14,%esp 10c71b: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 10c71e: 85 db test %ebx,%ebx 10c720: 74 76 je 10c798 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 10c722: 83 ec 08 sub $0x8,%esp 10c725: 8d 45 f4 lea -0xc(%ebp),%eax 10c728: 50 push %eax 10c729: ff 75 08 pushl 0x8(%ebp) 10c72c: e8 f7 1e 00 00 call 10e628 <_Thread_Get> switch (location) { 10c731: 83 c4 10 add $0x10,%esp 10c734: 8b 55 f4 mov -0xc(%ebp),%edx 10c737: 85 d2 test %edx,%edx 10c739: 74 0d je 10c748 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c73b: b8 04 00 00 00 mov $0x4,%eax } 10c740: 8b 5d fc mov -0x4(%ebp),%ebx 10c743: c9 leave 10c744: c3 ret 10c745: 8d 76 00 lea 0x0(%esi),%esi the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; 10c748: 8b 88 f4 00 00 00 mov 0xf4(%eax),%ecx while (tvp) { 10c74e: 85 c9 test %ecx,%ecx 10c750: 74 17 je 10c769 if (tvp->ptr == ptr) { 10c752: 39 59 04 cmp %ebx,0x4(%ecx) 10c755: 75 0c jne 10c763 10c757: eb 49 jmp 10c7a2 10c759: 8d 76 00 lea 0x0(%esi),%esi 10c75c: 39 5a 04 cmp %ebx,0x4(%edx) 10c75f: 74 17 je 10c778 10c761: 89 d1 mov %edx,%ecx _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 10c763: 8b 11 mov (%ecx),%edx the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 10c765: 85 d2 test %edx,%edx 10c767: 75 f3 jne 10c75c <== ALWAYS TAKEN return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10c769: e8 96 1e 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10c76e: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c773: 8b 5d fc mov -0x4(%ebp),%ebx 10c776: c9 leave 10c777: c3 ret case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 10c778: 8b 1a mov (%edx),%ebx 10c77a: 89 19 mov %ebx,(%ecx) else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 10c77c: 83 ec 08 sub $0x8,%esp 10c77f: 52 push %edx 10c780: 50 push %eax 10c781: e8 b2 00 00 00 call 10c838 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 10c786: e8 79 1e 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c78b: 83 c4 10 add $0x10,%esp 10c78e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c790: 8b 5d fc mov -0x4(%ebp),%ebx 10c793: c9 leave 10c794: c3 ret 10c795: 8d 76 00 lea 0x0(%esi),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 10c798: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c79d: 8b 5d fc mov -0x4(%ebp),%ebx 10c7a0: c9 leave 10c7a1: c3 ret while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 10c7a2: 8b 11 mov (%ecx),%edx 10c7a4: 89 90 f4 00 00 00 mov %edx,0xf4(%eax) 10c7aa: 89 ca mov %ecx,%edx 10c7ac: eb ce jmp 10c77c =============================================================================== 0010c7b0 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 10c7b0: 55 push %ebp 10c7b1: 89 e5 mov %esp,%ebp 10c7b3: 56 push %esi 10c7b4: 53 push %ebx 10c7b5: 83 ec 10 sub $0x10,%esp 10c7b8: 8b 5d 0c mov 0xc(%ebp),%ebx 10c7bb: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 10c7be: 85 db test %ebx,%ebx 10c7c0: 74 56 je 10c818 return RTEMS_INVALID_ADDRESS; if ( !result ) 10c7c2: 85 f6 test %esi,%esi 10c7c4: 74 52 je 10c818 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10c7c6: 83 ec 08 sub $0x8,%esp 10c7c9: 8d 45 f4 lea -0xc(%ebp),%eax 10c7cc: 50 push %eax 10c7cd: ff 75 08 pushl 0x8(%ebp) 10c7d0: e8 53 1e 00 00 call 10e628 <_Thread_Get> switch (location) { 10c7d5: 83 c4 10 add $0x10,%esp 10c7d8: 8b 55 f4 mov -0xc(%ebp),%edx 10c7db: 85 d2 test %edx,%edx 10c7dd: 75 2d jne 10c80c case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 10c7df: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax while (tvp) { 10c7e5: 85 c0 test %eax,%eax 10c7e7: 75 09 jne 10c7f2 10c7e9: eb 39 jmp 10c824 10c7eb: 90 nop */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10c7ec: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10c7ee: 85 c0 test %eax,%eax 10c7f0: 74 32 je 10c824 <== NEVER TAKEN if (tvp->ptr == ptr) { 10c7f2: 39 58 04 cmp %ebx,0x4(%eax) 10c7f5: 75 f5 jne 10c7ec /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 10c7f7: 8b 40 0c mov 0xc(%eax),%eax 10c7fa: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10c7fc: e8 03 1e 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c801: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c803: 8d 65 f8 lea -0x8(%ebp),%esp 10c806: 5b pop %ebx 10c807: 5e pop %esi 10c808: c9 leave 10c809: c3 ret 10c80a: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c80c: b8 04 00 00 00 mov $0x4,%eax } 10c811: 8d 65 f8 lea -0x8(%ebp),%esp 10c814: 5b pop %ebx 10c815: 5e pop %esi 10c816: c9 leave 10c817: c3 ret if ( !ptr ) return RTEMS_INVALID_ADDRESS; if ( !result ) return RTEMS_INVALID_ADDRESS; 10c818: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c81d: 8d 65 f8 lea -0x8(%ebp),%esp 10c820: 5b pop %ebx 10c821: 5e pop %esi 10c822: c9 leave 10c823: c3 ret _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10c824: e8 db 1d 00 00 call 10e604 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10c829: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c82e: 8d 65 f8 lea -0x8(%ebp),%esp 10c831: 5b pop %ebx 10c832: 5e pop %esi 10c833: c9 leave 10c834: c3 ret =============================================================================== 0010c9cc : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10c9cc: 55 push %ebp 10c9cd: 89 e5 mov %esp,%ebp 10c9cf: 53 push %ebx 10c9d0: 83 ec 14 sub $0x14,%esp 10c9d3: 8b 5d 08 mov 0x8(%ebp),%ebx Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10c9d6: 80 3d 84 a2 12 00 00 cmpb $0x0,0x12a284 10c9dd: 0f 84 a9 00 00 00 je 10ca8c return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10c9e3: 85 db test %ebx,%ebx 10c9e5: 0f 84 ad 00 00 00 je 10ca98 return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10c9eb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) if ( !_TOD_Validate( time_buffer ) ) 10c9f2: 83 ec 0c sub $0xc,%esp 10c9f5: 53 push %ebx 10c9f6: e8 c5 f3 ff ff call 10bdc0 <_TOD_Validate> 10c9fb: 83 c4 10 add $0x10,%esp 10c9fe: 84 c0 test %al,%al 10ca00: 75 0a jne 10ca0c return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 10ca02: b8 14 00 00 00 mov $0x14,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca07: 8b 5d fc mov -0x4(%ebp),%ebx 10ca0a: c9 leave 10ca0b: c3 ret time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10ca0c: 83 ec 0c sub $0xc,%esp 10ca0f: 53 push %ebx 10ca10: e8 1f f3 ff ff call 10bd34 <_TOD_To_seconds> if ( seconds <= _TOD_Seconds_since_epoch() ) 10ca15: 83 c4 10 add $0x10,%esp 10ca18: 3b 05 44 a3 12 00 cmp 0x12a344,%eax 10ca1e: 76 e2 jbe 10ca02 10ca20: 8b 15 70 a2 12 00 mov 0x12a270,%edx 10ca26: 42 inc %edx 10ca27: 89 15 70 a2 12 00 mov %edx,0x12a270 return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10ca2d: 83 ec 08 sub $0x8,%esp 10ca30: 6a 10 push $0x10 10ca32: ff 35 58 a8 12 00 pushl 0x12a858 10ca38: 89 45 f4 mov %eax,-0xc(%ebp) 10ca3b: e8 68 26 00 00 call 10f0a8 <_Thread_Set_state> _Watchdog_Initialize( &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, 10ca40: 8b 15 58 a8 12 00 mov 0x12a858,%edx if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); _Watchdog_Initialize( 10ca46: 8b 4a 08 mov 0x8(%edx),%ecx Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10ca49: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) the_watchdog->routine = routine; 10ca50: c7 42 64 90 e6 10 00 movl $0x10e690,0x64(%edx) the_watchdog->id = id; 10ca57: 89 4a 68 mov %ecx,0x68(%edx) the_watchdog->user_data = user_data; 10ca5a: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_seconds( 10ca61: 8b 45 f4 mov -0xc(%ebp),%eax 10ca64: 2b 05 44 a3 12 00 sub 0x12a344,%eax 10ca6a: 89 42 54 mov %eax,0x54(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 10ca6d: 58 pop %eax 10ca6e: 59 pop %ecx 10ca6f: 83 c2 48 add $0x48,%edx 10ca72: 52 push %edx 10ca73: 68 70 a3 12 00 push $0x12a370 10ca78: e8 43 2c 00 00 call 10f6c0 <_Watchdog_Insert> &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 10ca7d: e8 c2 1d 00 00 call 10e844 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ca82: 83 c4 10 add $0x10,%esp 10ca85: 31 c0 xor %eax,%eax 10ca87: e9 7b ff ff ff jmp 10ca07 ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 10ca8c: b8 0b 00 00 00 mov $0xb,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca91: 8b 5d fc mov -0x4(%ebp),%ebx 10ca94: c9 leave 10ca95: c3 ret 10ca96: 66 90 xchg %ax,%ax if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10ca98: b8 09 00 00 00 mov $0x9,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ca9d: 8b 5d fc mov -0x4(%ebp),%ebx 10caa0: c9 leave 10caa1: c3 ret =============================================================================== 001186e0 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 1186e0: 55 push %ebp 1186e1: 89 e5 mov %esp,%ebp 1186e3: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1186e6: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1186e9: 50 push %eax 1186ea: ff 75 08 pushl 0x8(%ebp) 1186ed: 68 80 2c 14 00 push $0x142c80 1186f2: e8 ed 2b 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 1186f7: 83 c4 10 add $0x10,%esp 1186fa: 8b 55 f4 mov -0xc(%ebp),%edx 1186fd: 85 d2 test %edx,%edx 1186ff: 74 07 je 118708 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118701: b8 04 00 00 00 mov $0x4,%eax } 118706: c9 leave 118707: c3 ret the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 118708: 83 78 38 04 cmpl $0x4,0x38(%eax) 11870c: 74 0f je 11871d <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 11870e: 83 ec 0c sub $0xc,%esp 118711: 83 c0 10 add $0x10,%eax 118714: 50 push %eax 118715: e8 56 48 00 00 call 11cf70 <_Watchdog_Remove> 11871a: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 11871d: e8 76 36 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118722: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118724: c9 leave 118725: c3 ret =============================================================================== 0010bffc : rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 10bffc: 55 push %ebp 10bffd: 89 e5 mov %esp,%ebp 10bfff: 57 push %edi 10c000: 56 push %esi 10c001: 53 push %ebx 10c002: 83 ec 0c sub $0xc,%esp 10c005: 8b 5d 08 mov 0x8(%ebp),%ebx 10c008: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10c00b: 85 db test %ebx,%ebx 10c00d: 74 6d je 10c07c return RTEMS_INVALID_NAME; if ( !id ) 10c00f: 85 f6 test %esi,%esi 10c011: 0f 84 89 00 00 00 je 10c0a0 10c017: a1 d0 8f 12 00 mov 0x128fd0,%eax 10c01c: 40 inc %eax 10c01d: a3 d0 8f 12 00 mov %eax,0x128fd0 * This function allocates a timer control block from * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void ) { return (Timer_Control *) _Objects_Allocate( &_Timer_Information ); 10c022: 83 ec 0c sub $0xc,%esp 10c025: 68 40 9a 12 00 push $0x129a40 10c02a: e8 29 0f 00 00 call 10cf58 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10c02f: 83 c4 10 add $0x10,%esp 10c032: 85 c0 test %eax,%eax 10c034: 74 56 je 10c08c _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10c036: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c03d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10c044: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10c04b: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10c052: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c059: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c05c: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c05f: 8b 0d 5c 9a 12 00 mov 0x129a5c,%ecx 10c065: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c068: 89 58 0c mov %ebx,0xc(%eax) &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10c06b: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10c06d: e8 52 1e 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c072: 31 c0 xor %eax,%eax } 10c074: 8d 65 f4 lea -0xc(%ebp),%esp 10c077: 5b pop %ebx 10c078: 5e pop %esi 10c079: 5f pop %edi 10c07a: c9 leave 10c07b: c3 ret ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10c07c: b8 03 00 00 00 mov $0x3,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c081: 8d 65 f4 lea -0xc(%ebp),%esp 10c084: 5b pop %ebx 10c085: 5e pop %esi 10c086: 5f pop %edi 10c087: c9 leave 10c088: c3 ret 10c089: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 10c08c: e8 33 1e 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10c091: b8 05 00 00 00 mov $0x5,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c096: 8d 65 f4 lea -0xc(%ebp),%esp 10c099: 5b pop %ebx 10c09a: 5e pop %esi 10c09b: 5f pop %edi 10c09c: c9 leave 10c09d: c3 ret 10c09e: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10c0a0: b8 09 00 00 00 mov $0x9,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c0a5: 8d 65 f4 lea -0xc(%ebp),%esp 10c0a8: 5b pop %ebx 10c0a9: 5e pop %esi 10c0aa: 5f pop %edi 10c0ab: c9 leave 10c0ac: c3 ret =============================================================================== 001187dc : */ rtems_status_code rtems_timer_delete( rtems_id id ) { 1187dc: 55 push %ebp 1187dd: 89 e5 mov %esp,%ebp 1187df: 53 push %ebx 1187e0: 83 ec 18 sub $0x18,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1187e3: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1187e6: 50 push %eax 1187e7: ff 75 08 pushl 0x8(%ebp) 1187ea: 68 80 2c 14 00 push $0x142c80 1187ef: e8 f0 2a 00 00 call 11b2e4 <_Objects_Get> 1187f4: 89 c3 mov %eax,%ebx switch ( location ) { 1187f6: 83 c4 10 add $0x10,%esp 1187f9: 8b 4d f4 mov -0xc(%ebp),%ecx 1187fc: 85 c9 test %ecx,%ecx 1187fe: 75 38 jne 118838 case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 118800: 83 ec 08 sub $0x8,%esp 118803: 50 push %eax 118804: 68 80 2c 14 00 push $0x142c80 118809: e8 5e 26 00 00 call 11ae6c <_Objects_Close> (void) _Watchdog_Remove( &the_timer->Ticker ); 11880e: 8d 43 10 lea 0x10(%ebx),%eax 118811: 89 04 24 mov %eax,(%esp) 118814: e8 57 47 00 00 call 11cf70 <_Watchdog_Remove> */ RTEMS_INLINE_ROUTINE void _Timer_Free ( Timer_Control *the_timer ) { _Objects_Free( &_Timer_Information, &the_timer->Object ); 118819: 58 pop %eax 11881a: 5a pop %edx 11881b: 53 push %ebx 11881c: 68 80 2c 14 00 push $0x142c80 118821: e8 42 29 00 00 call 11b168 <_Objects_Free> _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 118826: e8 6d 35 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11882b: 83 c4 10 add $0x10,%esp 11882e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118830: 8b 5d fc mov -0x4(%ebp),%ebx 118833: c9 leave 118834: c3 ret 118835: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118838: b8 04 00 00 00 mov $0x4,%eax } 11883d: 8b 5d fc mov -0x4(%ebp),%ebx 118840: c9 leave 118841: c3 ret =============================================================================== 0010c0b0 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10c0b0: 55 push %ebp 10c0b1: 89 e5 mov %esp,%ebp 10c0b3: 57 push %edi 10c0b4: 56 push %esi 10c0b5: 53 push %ebx 10c0b6: 83 ec 2c sub $0x2c,%esp 10c0b9: 8b 5d 0c mov 0xc(%ebp),%ebx 10c0bc: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10c0bf: 85 db test %ebx,%ebx 10c0c1: 0f 84 99 00 00 00 je 10c160 return RTEMS_INVALID_NUMBER; if ( !routine ) 10c0c7: 85 f6 test %esi,%esi 10c0c9: 0f 84 b1 00 00 00 je 10c180 Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 10c0cf: 57 push %edi return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); 10c0d0: 8d 45 e4 lea -0x1c(%ebp),%eax 10c0d3: 50 push %eax 10c0d4: ff 75 08 pushl 0x8(%ebp) 10c0d7: 68 40 9a 12 00 push $0x129a40 10c0dc: e8 2f 13 00 00 call 10d410 <_Objects_Get> 10c0e1: 89 c7 mov %eax,%edi switch ( location ) { 10c0e3: 83 c4 10 add $0x10,%esp 10c0e6: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c0e9: 85 c9 test %ecx,%ecx 10c0eb: 74 0f je 10c0fc #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c0ed: b8 04 00 00 00 mov $0x4,%eax } 10c0f2: 8d 65 f4 lea -0xc(%ebp),%esp 10c0f5: 5b pop %ebx 10c0f6: 5e pop %esi 10c0f7: 5f pop %edi 10c0f8: c9 leave 10c0f9: c3 ret 10c0fa: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10c0fc: 8d 50 10 lea 0x10(%eax),%edx 10c0ff: 83 ec 0c sub $0xc,%esp 10c102: 52 push %edx 10c103: 89 55 d4 mov %edx,-0x2c(%ebp) 10c106: e8 fd 2c 00 00 call 10ee08 <_Watchdog_Remove> _ISR_Disable( level ); 10c10b: 9c pushf 10c10c: fa cli 10c10d: 58 pop %eax /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 10c10e: 83 c4 10 add $0x10,%esp 10c111: 8b 57 18 mov 0x18(%edi),%edx 10c114: 85 d2 test %edx,%edx 10c116: 8b 55 d4 mov -0x2c(%ebp),%edx 10c119: 75 55 jne 10c170 /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 10c11b: c7 47 38 00 00 00 00 movl $0x0,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c122: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10c129: 89 77 2c mov %esi,0x2c(%edi) the_watchdog->id = id; 10c12c: 8b 4d 08 mov 0x8(%ebp),%ecx 10c12f: 89 4f 30 mov %ecx,0x30(%edi) the_watchdog->user_data = user_data; 10c132: 8b 4d 14 mov 0x14(%ebp),%ecx 10c135: 89 4f 34 mov %ecx,0x34(%edi) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10c138: 50 push %eax 10c139: 9d popf Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10c13a: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10c13d: 83 ec 08 sub $0x8,%esp 10c140: 52 push %edx 10c141: 68 dc 90 12 00 push $0x1290dc 10c146: e8 7d 2b 00 00 call 10ecc8 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10c14b: e8 74 1d 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c150: 83 c4 10 add $0x10,%esp 10c153: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c155: 8d 65 f4 lea -0xc(%ebp),%esp 10c158: 5b pop %ebx 10c159: 5e pop %esi 10c15a: 5f pop %edi 10c15b: c9 leave 10c15c: c3 ret 10c15d: 8d 76 00 lea 0x0(%esi),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; 10c160: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c165: 8d 65 f4 lea -0xc(%ebp),%esp 10c168: 5b pop %ebx 10c169: 5e pop %esi 10c16a: 5f pop %edi 10c16b: c9 leave 10c16c: c3 ret 10c16d: 8d 76 00 lea 0x0(%esi),%esi * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 10c170: 50 push %eax 10c171: 9d popf _Thread_Enable_dispatch(); 10c172: e8 4d 1d 00 00 call 10dec4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c177: 31 c0 xor %eax,%eax 10c179: e9 74 ff ff ff jmp 10c0f2 10c17e: 66 90 xchg %ax,%ax if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) return RTEMS_INVALID_ADDRESS; 10c180: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c185: 8d 65 f4 lea -0xc(%ebp),%esp 10c188: 5b pop %ebx 10c189: 5e pop %esi 10c18a: 5f pop %edi 10c18b: c9 leave 10c18c: c3 ret =============================================================================== 00118924 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118924: 55 push %ebp 118925: 89 e5 mov %esp,%ebp 118927: 57 push %edi 118928: 56 push %esi 118929: 53 push %ebx 11892a: 83 ec 2c sub $0x2c,%esp 11892d: 8b 75 08 mov 0x8(%ebp),%esi 118930: 8b 7d 0c mov 0xc(%ebp),%edi 118933: 8b 5d 10 mov 0x10(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 118936: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224 11893d: 75 0d jne 11894c return RTEMS_NOT_DEFINED; 11893f: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118944: 8d 65 f4 lea -0xc(%ebp),%esp 118947: 5b pop %ebx 118948: 5e pop %esi 118949: 5f pop %edi 11894a: c9 leave 11894b: c3 ret rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 11894c: 83 ec 0c sub $0xc,%esp 11894f: 57 push %edi 118950: e8 87 d4 ff ff call 115ddc <_TOD_Validate> 118955: 83 c4 10 add $0x10,%esp 118958: 84 c0 test %al,%al 11895a: 74 1e je 11897a return RTEMS_INVALID_CLOCK; if ( !routine ) 11895c: 85 db test %ebx,%ebx 11895e: 0f 84 a4 00 00 00 je 118a08 return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 118964: 83 ec 0c sub $0xc,%esp 118967: 57 push %edi 118968: e8 e3 d3 ff ff call 115d50 <_TOD_To_seconds> 11896d: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11896f: 83 c4 10 add $0x10,%esp 118972: 3b 05 e4 22 14 00 cmp 0x1422e4,%eax 118978: 77 0e ja 118988 return RTEMS_INVALID_CLOCK; 11897a: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11897f: 8d 65 f4 lea -0xc(%ebp),%esp 118982: 5b pop %ebx 118983: 5e pop %esi 118984: 5f pop %edi 118985: c9 leave 118986: c3 ret 118987: 90 nop 118988: 50 push %eax seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 118989: 8d 45 e4 lea -0x1c(%ebp),%eax 11898c: 50 push %eax 11898d: 56 push %esi 11898e: 68 80 2c 14 00 push $0x142c80 118993: e8 4c 29 00 00 call 11b2e4 <_Objects_Get> switch ( location ) { 118998: 83 c4 10 add $0x10,%esp 11899b: 8b 4d e4 mov -0x1c(%ebp),%ecx 11899e: 85 c9 test %ecx,%ecx 1189a0: 75 5a jne 1189fc case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1189a2: 8d 48 10 lea 0x10(%eax),%ecx 1189a5: 83 ec 0c sub $0xc,%esp 1189a8: 51 push %ecx 1189a9: 89 45 d0 mov %eax,-0x30(%ebp) 1189ac: 89 4d d4 mov %ecx,-0x2c(%ebp) 1189af: e8 bc 45 00 00 call 11cf70 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 1189b4: 8b 55 d0 mov -0x30(%ebp),%edx 1189b7: c7 42 38 02 00 00 00 movl $0x2,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1189be: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 1189c5: 89 5a 2c mov %ebx,0x2c(%edx) the_watchdog->id = id; 1189c8: 89 72 30 mov %esi,0x30(%edx) the_watchdog->user_data = user_data; 1189cb: 8b 45 14 mov 0x14(%ebp),%eax 1189ce: 89 42 34 mov %eax,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( 1189d1: 2b 3d e4 22 14 00 sub 0x1422e4,%edi 1189d7: 89 7a 1c mov %edi,0x1c(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 1189da: 58 pop %eax 1189db: 5a pop %edx 1189dc: 8b 4d d4 mov -0x2c(%ebp),%ecx 1189df: 51 push %ecx 1189e0: 68 10 23 14 00 push $0x142310 1189e5: e8 46 44 00 00 call 11ce30 <_Watchdog_Insert> &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 1189ea: e8 a9 33 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1189ef: 83 c4 10 add $0x10,%esp 1189f2: 31 c0 xor %eax,%eax 1189f4: e9 4b ff ff ff jmp 118944 1189f9: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1189fc: b8 04 00 00 00 mov $0x4,%eax 118a01: e9 3e ff ff ff jmp 118944 118a06: 66 90 xchg %ax,%ax if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118a08: b8 09 00 00 00 mov $0x9,%eax 118a0d: e9 32 ff ff ff jmp 118944 =============================================================================== 001190bc : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 1190bc: 55 push %ebp 1190bd: 89 e5 mov %esp,%ebp 1190bf: 56 push %esi 1190c0: 53 push %ebx 1190c1: 83 ec 10 sub $0x10,%esp 1190c4: 8b 45 08 mov 0x8(%ebp),%eax 1190c7: 85 c0 test %eax,%eax 1190c9: 74 41 je 11910c ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 1190cb: 0f b6 15 d4 9a 13 00 movzbl 0x139ad4,%edx */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1190d2: 39 d0 cmp %edx,%eax 1190d4: 76 42 jbe 119118 * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 1190d6: 40 inc %eax 1190d7: 75 33 jne 11910c return RTEMS_INVALID_PRIORITY; _priority = 0; 1190d9: 31 f6 xor %esi,%esi 1190db: 8b 15 10 22 14 00 mov 0x142210,%edx 1190e1: 42 inc %edx 1190e2: 89 15 10 22 14 00 mov %edx,0x142210 /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 1190e8: 8a 1d 40 db 13 00 mov 0x13db40,%bl initialized = true; 1190ee: c6 05 40 db 13 00 01 movb $0x1,0x13db40 _Thread_Enable_dispatch(); 1190f5: e8 9e 2c 00 00 call 11bd98 <_Thread_Enable_dispatch> if ( tmpInitialized ) 1190fa: 84 db test %bl,%bl 1190fc: 74 1e je 11911c return RTEMS_INCORRECT_STATE; 1190fe: b8 0e 00 00 00 mov $0xe,%eax initialized = false; } #endif return status; } 119103: 8d 65 f8 lea -0x8(%ebp),%esp 119106: 5b pop %ebx 119107: 5e pop %esi 119108: c9 leave 119109: c3 ret 11910a: 66 90 xchg %ax,%ax * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) return RTEMS_INVALID_PRIORITY; 11910c: b8 13 00 00 00 mov $0x13,%eax initialized = false; } #endif return status; } 119111: 8d 65 f8 lea -0x8(%ebp),%esp 119114: 5b pop %ebx 119115: 5e pop %esi 119116: c9 leave 119117: c3 ret 119118: 89 c6 mov %eax,%esi 11911a: eb bf jmp 1190db * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 11911c: 83 ec 08 sub $0x8,%esp 11911f: 8d 45 f4 lea -0xc(%ebp),%eax 119122: 50 push %eax 119123: 8b 45 10 mov 0x10(%ebp),%eax 119126: 80 cc 80 or $0x80,%ah 119129: 50 push %eax 11912a: 68 00 01 00 00 push $0x100 11912f: ff 75 0c pushl 0xc(%ebp) 119132: 56 push %esi 119133: 68 45 4d 49 54 push $0x54494d45 119138: e8 bb ec ff ff call 117df8 /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 11913d: 83 c4 20 add $0x20,%esp 119140: 85 c0 test %eax,%eax 119142: 74 10 je 119154 initialized = false; 119144: c6 05 40 db 13 00 00 movb $0x0,0x13db40 initialized = false; } #endif return status; } 11914b: 8d 65 f8 lea -0x8(%ebp),%esp 11914e: 5b pop %ebx 11914f: 5e pop %esi 119150: c9 leave 119151: c3 ret 119152: 66 90 xchg %ax,%ax * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( &_RTEMS_tasks_Information, _Objects_Get_index(id) 119154: 8b 45 f4 mov -0xc(%ebp),%eax */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 119157: 0f b7 c8 movzwl %ax,%ecx 11915a: 8b 15 bc 21 14 00 mov 0x1421bc,%edx /* * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( 119160: 8b 14 8a mov (%edx,%ecx,4),%edx 119163: 89 15 c0 da 13 00 mov %edx,0x13dac0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 119169: c7 05 f0 da 13 00 f4 movl $0x13daf4,0x13daf0 119170: da 13 00 head->previous = NULL; 119173: c7 05 f4 da 13 00 00 movl $0x0,0x13daf4 11917a: 00 00 00 tail->previous = head; 11917d: c7 05 f8 da 13 00 f0 movl $0x13daf0,0x13daf8 119184: da 13 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 119187: c7 05 28 db 13 00 2c movl $0x13db2c,0x13db28 11918e: db 13 00 head->previous = NULL; 119191: c7 05 2c db 13 00 00 movl $0x0,0x13db2c 119198: 00 00 00 tail->previous = head; 11919b: c7 05 30 db 13 00 28 movl $0x13db28,0x13db30 1191a2: db 13 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1191a5: c7 05 d0 da 13 00 00 movl $0x0,0x13dad0 1191ac: 00 00 00 the_watchdog->routine = routine; 1191af: c7 05 e4 da 13 00 e4 movl $0x11bbe4,0x13dae4 1191b6: bb 11 00 the_watchdog->id = id; 1191b9: a3 e8 da 13 00 mov %eax,0x13dae8 the_watchdog->user_data = user_data; 1191be: c7 05 ec da 13 00 00 movl $0x0,0x13daec 1191c5: 00 00 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1191c8: c7 05 08 db 13 00 00 movl $0x0,0x13db08 1191cf: 00 00 00 the_watchdog->routine = routine; 1191d2: c7 05 1c db 13 00 e4 movl $0x11bbe4,0x13db1c 1191d9: bb 11 00 the_watchdog->id = id; 1191dc: a3 20 db 13 00 mov %eax,0x13db20 the_watchdog->user_data = user_data; 1191e1: c7 05 24 db 13 00 00 movl $0x0,0x13db24 1191e8: 00 00 00 /* * Initialize the pointer to the timer schedule method so applications that * do not use the Timer Server do not have to pull it in. */ ts->schedule_operation = _Timer_server_Schedule_operation_method; 1191eb: c7 05 c4 da 13 00 8c movl $0x118f8c,0x13dac4 1191f2: 8f 11 00 ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 1191f5: 8b 15 84 23 14 00 mov 0x142384,%edx 1191fb: 89 15 fc da 13 00 mov %edx,0x13dafc ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 119201: 8b 15 e4 22 14 00 mov 0x1422e4,%edx 119207: 89 15 34 db 13 00 mov %edx,0x13db34 ts->insert_chain = NULL; 11920d: c7 05 38 db 13 00 00 movl $0x0,0x13db38 119214: 00 00 00 ts->active = false; 119217: c6 05 3c db 13 00 00 movb $0x0,0x13db3c /* * The default timer server is now available. */ _Timer_server = ts; 11921e: c7 05 c0 2c 14 00 c0 movl $0x13dac0,0x142cc0 119225: da 13 00 /* * Start the timer server */ status = rtems_task_start( 119228: 53 push %ebx 119229: 68 c0 da 13 00 push $0x13dac0 11922e: 68 c4 8d 11 00 push $0x118dc4 119233: 50 push %eax 119234: e8 7f f2 ff ff call 1184b8 if (status) { initialized = false; } #endif return status; 119239: 83 c4 10 add $0x10,%esp 11923c: e9 d0 fe ff ff jmp 119111 =============================================================================== 00118a9c : */ rtems_status_code rtems_timer_reset( rtems_id id ) { 118a9c: 55 push %ebp 118a9d: 89 e5 mov %esp,%ebp 118a9f: 56 push %esi 118aa0: 53 push %ebx 118aa1: 83 ec 24 sub $0x24,%esp Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; the_timer = _Timer_Get( id, &location ); 118aa4: 8d 45 f4 lea -0xc(%ebp),%eax 118aa7: 50 push %eax 118aa8: ff 75 08 pushl 0x8(%ebp) 118aab: 68 80 2c 14 00 push $0x142c80 118ab0: e8 2f 28 00 00 call 11b2e4 <_Objects_Get> 118ab5: 89 c3 mov %eax,%ebx switch ( location ) { 118ab7: 83 c4 10 add $0x10,%esp 118aba: 8b 45 f4 mov -0xc(%ebp),%eax 118abd: 85 c0 test %eax,%eax 118abf: 74 0f je 118ad0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118ac1: b8 04 00 00 00 mov $0x4,%eax } 118ac6: 8d 65 f8 lea -0x8(%ebp),%esp 118ac9: 5b pop %ebx 118aca: 5e pop %esi 118acb: c9 leave 118acc: c3 ret 118acd: 8d 76 00 lea 0x0(%esi),%esi the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { 118ad0: 8b 43 38 mov 0x38(%ebx),%eax 118ad3: 85 c0 test %eax,%eax 118ad5: 74 1d je 118af4 _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118ad7: 48 dec %eax 118ad8: 74 3a je 118b14 /* * Must be dormant or time of day timer (e.g. TIMER_DORMANT, * TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We * can only reset active interval timers. */ status = RTEMS_NOT_DEFINED; 118ada: b8 0b 00 00 00 mov $0xb,%eax } _Thread_Enable_dispatch(); 118adf: 89 45 e4 mov %eax,-0x1c(%ebp) 118ae2: e8 b1 32 00 00 call 11bd98 <_Thread_Enable_dispatch> return status; 118ae7: 8b 45 e4 mov -0x1c(%ebp),%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118aea: 8d 65 f8 lea -0x8(%ebp),%esp 118aed: 5b pop %ebx 118aee: 5e pop %esi 118aef: c9 leave 118af0: c3 ret 118af1: 8d 76 00 lea 0x0(%esi),%esi the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { _Watchdog_Remove( &the_timer->Ticker ); 118af4: 83 c3 10 add $0x10,%ebx 118af7: 83 ec 0c sub $0xc,%esp 118afa: 53 push %ebx 118afb: e8 70 44 00 00 call 11cf70 <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 118b00: 59 pop %ecx 118b01: 5e pop %esi 118b02: 53 push %ebx 118b03: 68 1c 23 14 00 push $0x14231c 118b08: e8 23 43 00 00 call 11ce30 <_Watchdog_Insert> 118b0d: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 118b10: 31 c0 xor %eax,%eax 118b12: eb cb jmp 118adf case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { Timer_server_Control *timer_server = _Timer_server; 118b14: 8b 35 c0 2c 14 00 mov 0x142cc0,%esi if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 118b1a: 83 ec 0c sub $0xc,%esp 118b1d: 8d 43 10 lea 0x10(%ebx),%eax 118b20: 50 push %eax 118b21: e8 4a 44 00 00 call 11cf70 <_Watchdog_Remove> (*timer_server->schedule_operation)( timer_server, the_timer ); 118b26: 58 pop %eax 118b27: 5a pop %edx 118b28: 53 push %ebx 118b29: 56 push %esi 118b2a: ff 56 04 call *0x4(%esi) 118b2d: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 118b30: 31 c0 xor %eax,%eax 118b32: eb ab jmp 118adf =============================================================================== 00118b34 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 118b34: 55 push %ebp 118b35: 89 e5 mov %esp,%ebp 118b37: 57 push %edi 118b38: 56 push %esi 118b39: 53 push %ebx 118b3a: 83 ec 2c sub $0x2c,%esp 118b3d: 8b 7d 0c mov 0xc(%ebp),%edi 118b40: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 118b43: 8b 1d c0 2c 14 00 mov 0x142cc0,%ebx if ( !timer_server ) 118b49: 85 db test %ebx,%ebx 118b4b: 0f 84 9f 00 00 00 je 118bf0 return RTEMS_INCORRECT_STATE; if ( !routine ) 118b51: 85 f6 test %esi,%esi 118b53: 0f 84 a3 00 00 00 je 118bfc return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 118b59: 85 ff test %edi,%edi 118b5b: 75 0f jne 118b6c return RTEMS_INVALID_NUMBER; 118b5d: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118b62: 8d 65 f4 lea -0xc(%ebp),%esp 118b65: 5b pop %ebx 118b66: 5e pop %esi 118b67: 5f pop %edi 118b68: c9 leave 118b69: c3 ret 118b6a: 66 90 xchg %ax,%ax 118b6c: 52 push %edx return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); 118b6d: 8d 45 e4 lea -0x1c(%ebp),%eax 118b70: 50 push %eax 118b71: ff 75 08 pushl 0x8(%ebp) 118b74: 68 80 2c 14 00 push $0x142c80 118b79: e8 66 27 00 00 call 11b2e4 <_Objects_Get> 118b7e: 89 c2 mov %eax,%edx switch ( location ) { 118b80: 83 c4 10 add $0x10,%esp 118b83: 8b 45 e4 mov -0x1c(%ebp),%eax 118b86: 85 c0 test %eax,%eax 118b88: 75 56 jne 118be0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118b8a: 83 ec 0c sub $0xc,%esp 118b8d: 8d 42 10 lea 0x10(%edx),%eax 118b90: 50 push %eax 118b91: 89 55 d4 mov %edx,-0x2c(%ebp) 118b94: e8 d7 43 00 00 call 11cf70 <_Watchdog_Remove> _ISR_Disable( level ); 118b99: 9c pushf 118b9a: fa cli 118b9b: 58 pop %eax /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 118b9c: 83 c4 10 add $0x10,%esp 118b9f: 8b 55 d4 mov -0x2c(%ebp),%edx 118ba2: 8b 4a 18 mov 0x18(%edx),%ecx 118ba5: 85 c9 test %ecx,%ecx 118ba7: 75 5f jne 118c08 /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 118ba9: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 118bb0: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 118bb7: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 118bba: 8b 4d 08 mov 0x8(%ebp),%ecx 118bbd: 89 4a 30 mov %ecx,0x30(%edx) the_watchdog->user_data = user_data; 118bc0: 8b 4d 14 mov 0x14(%ebp),%ecx 118bc3: 89 4a 34 mov %ecx,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 118bc6: 89 7a 1c mov %edi,0x1c(%edx) _ISR_Enable( level ); 118bc9: 50 push %eax 118bca: 9d popf (*timer_server->schedule_operation)( timer_server, the_timer ); 118bcb: 83 ec 08 sub $0x8,%esp 118bce: 52 push %edx 118bcf: 53 push %ebx 118bd0: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 118bd3: e8 c0 31 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118bd8: 83 c4 10 add $0x10,%esp 118bdb: 31 c0 xor %eax,%eax 118bdd: eb 83 jmp 118b62 118bdf: 90 nop #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118be0: b8 04 00 00 00 mov $0x4,%eax } 118be5: 8d 65 f4 lea -0xc(%ebp),%esp 118be8: 5b pop %ebx 118be9: 5e pop %esi 118bea: 5f pop %edi 118beb: c9 leave 118bec: c3 ret 118bed: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 118bf0: b8 0e 00 00 00 mov $0xe,%eax 118bf5: e9 68 ff ff ff jmp 118b62 118bfa: 66 90 xchg %ax,%ax if ( !routine ) return RTEMS_INVALID_ADDRESS; 118bfc: b8 09 00 00 00 mov $0x9,%eax 118c01: e9 5c ff ff ff jmp 118b62 118c06: 66 90 xchg %ax,%ax * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 118c08: 50 push %eax 118c09: 9d popf _Thread_Enable_dispatch(); 118c0a: e8 89 31 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118c0f: 31 c0 xor %eax,%eax 118c11: e9 4c ff ff ff jmp 118b62 =============================================================================== 00118c18 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118c18: 55 push %ebp 118c19: 89 e5 mov %esp,%ebp 118c1b: 57 push %edi 118c1c: 56 push %esi 118c1d: 53 push %ebx 118c1e: 83 ec 2c sub $0x2c,%esp 118c21: 8b 7d 0c mov 0xc(%ebp),%edi 118c24: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 118c27: 8b 1d c0 2c 14 00 mov 0x142cc0,%ebx if ( !timer_server ) 118c2d: 85 db test %ebx,%ebx 118c2f: 0f 84 d7 00 00 00 je 118d0c return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 118c35: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224 118c3c: 0f 84 aa 00 00 00 je 118cec <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) 118c42: 85 f6 test %esi,%esi 118c44: 0f 84 b2 00 00 00 je 118cfc return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 118c4a: 83 ec 0c sub $0xc,%esp 118c4d: 57 push %edi 118c4e: e8 89 d1 ff ff call 115ddc <_TOD_Validate> 118c53: 83 c4 10 add $0x10,%esp 118c56: 84 c0 test %al,%al 118c58: 75 0e jne 118c68 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 118c5a: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118c5f: 8d 65 f4 lea -0xc(%ebp),%esp 118c62: 5b pop %ebx 118c63: 5e pop %esi 118c64: 5f pop %edi 118c65: c9 leave 118c66: c3 ret 118c67: 90 nop return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 118c68: 83 ec 0c sub $0xc,%esp 118c6b: 57 push %edi 118c6c: e8 df d0 ff ff call 115d50 <_TOD_To_seconds> 118c71: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 118c73: 83 c4 10 add $0x10,%esp 118c76: 3b 05 e4 22 14 00 cmp 0x1422e4,%eax 118c7c: 76 dc jbe 118c5a 118c7e: 52 push %edx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 118c7f: 8d 45 e4 lea -0x1c(%ebp),%eax 118c82: 50 push %eax 118c83: ff 75 08 pushl 0x8(%ebp) 118c86: 68 80 2c 14 00 push $0x142c80 118c8b: e8 54 26 00 00 call 11b2e4 <_Objects_Get> 118c90: 89 c2 mov %eax,%edx switch ( location ) { 118c92: 83 c4 10 add $0x10,%esp 118c95: 8b 45 e4 mov -0x1c(%ebp),%eax 118c98: 85 c0 test %eax,%eax 118c9a: 75 7c jne 118d18 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 118c9c: 83 ec 0c sub $0xc,%esp 118c9f: 8d 42 10 lea 0x10(%edx),%eax 118ca2: 50 push %eax 118ca3: 89 55 d4 mov %edx,-0x2c(%ebp) 118ca6: e8 c5 42 00 00 call 11cf70 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 118cab: 8b 55 d4 mov -0x2c(%ebp),%edx 118cae: c7 42 38 03 00 00 00 movl $0x3,0x38(%edx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 118cb5: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 118cbc: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 118cbf: 8b 45 08 mov 0x8(%ebp),%eax 118cc2: 89 42 30 mov %eax,0x30(%edx) the_watchdog->user_data = user_data; 118cc5: 8b 45 14 mov 0x14(%ebp),%eax 118cc8: 89 42 34 mov %eax,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 118ccb: 2b 3d e4 22 14 00 sub 0x1422e4,%edi 118cd1: 89 7a 1c mov %edi,0x1c(%edx) (*timer_server->schedule_operation)( timer_server, the_timer ); 118cd4: 58 pop %eax 118cd5: 59 pop %ecx 118cd6: 52 push %edx 118cd7: 53 push %ebx 118cd8: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 118cdb: e8 b8 30 00 00 call 11bd98 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 118ce0: 83 c4 10 add $0x10,%esp 118ce3: 31 c0 xor %eax,%eax 118ce5: e9 75 ff ff ff jmp 118c5f 118cea: 66 90 xchg %ax,%ax if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 118cec: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118cf1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118cf4: 5b pop %ebx <== NOT EXECUTED 118cf5: 5e pop %esi <== NOT EXECUTED 118cf6: 5f pop %edi <== NOT EXECUTED 118cf7: c9 leave <== NOT EXECUTED 118cf8: c3 ret <== NOT EXECUTED 118cf9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118cfc: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118d01: 8d 65 f4 lea -0xc(%ebp),%esp 118d04: 5b pop %ebx 118d05: 5e pop %esi 118d06: 5f pop %edi 118d07: c9 leave 118d08: c3 ret 118d09: 8d 76 00 lea 0x0(%esi),%esi Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 118d0c: b8 0e 00 00 00 mov $0xe,%eax 118d11: e9 49 ff ff ff jmp 118c5f 118d16: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118d18: b8 04 00 00 00 mov $0x4,%eax 118d1d: e9 3d ff ff ff jmp 118c5f =============================================================================== 0010be34 : #include int sched_get_priority_max( int policy ) { 10be34: 55 push %ebp 10be35: 89 e5 mov %esp,%ebp 10be37: 83 ec 08 sub $0x8,%esp 10be3a: 8b 45 08 mov 0x8(%ebp),%eax switch ( policy ) { 10be3d: 85 c0 test %eax,%eax 10be3f: 78 0a js 10be4b 10be41: 83 f8 02 cmp $0x2,%eax 10be44: 7e 1a jle 10be60 10be46: 83 f8 04 cmp $0x4,%eax 10be49: 74 15 je 10be60 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10be4b: e8 d4 81 00 00 call 114024 <__errno> 10be50: c7 00 16 00 00 00 movl $0x16,(%eax) 10be56: b8 ff ff ff ff mov $0xffffffff,%eax } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10be5b: c9 leave 10be5c: c3 ret 10be5d: 8d 76 00 lea 0x0(%esi),%esi default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10be60: 0f b6 05 7c 45 12 00 movzbl 0x12457c,%eax 10be67: 48 dec %eax } 10be68: c9 leave 10be69: c3 ret =============================================================================== 0010be6c : #include int sched_get_priority_min( int policy ) { 10be6c: 55 push %ebp 10be6d: 89 e5 mov %esp,%ebp 10be6f: 83 ec 08 sub $0x8,%esp 10be72: 8b 45 08 mov 0x8(%ebp),%eax switch ( policy ) { 10be75: 85 c0 test %eax,%eax 10be77: 78 0a js 10be83 10be79: 83 f8 02 cmp $0x2,%eax 10be7c: 7e 1a jle 10be98 <== ALWAYS TAKEN 10be7e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10be81: 74 15 je 10be98 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10be83: e8 9c 81 00 00 call 114024 <__errno> 10be88: c7 00 16 00 00 00 movl $0x16,(%eax) 10be8e: b8 ff ff ff ff mov $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10be93: c9 leave 10be94: c3 ret 10be95: 8d 76 00 lea 0x0(%esi),%esi default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10be98: b8 01 00 00 00 mov $0x1,%eax } 10be9d: c9 leave 10be9e: c3 ret =============================================================================== 0010bea0 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10bea0: 55 push %ebp 10bea1: 89 e5 mov %esp,%ebp 10bea3: 56 push %esi 10bea4: 53 push %ebx 10bea5: 8b 75 08 mov 0x8(%ebp),%esi 10bea8: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10beab: 85 f6 test %esi,%esi 10bead: 75 21 jne 10bed0 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 10beaf: 85 db test %ebx,%ebx 10beb1: 74 38 je 10beeb rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10beb3: 83 ec 08 sub $0x8,%esp 10beb6: 53 push %ebx 10beb7: ff 35 20 88 12 00 pushl 0x128820 10bebd: e8 92 35 00 00 call 10f454 <_Timespec_From_ticks> return 0; 10bec2: 83 c4 10 add $0x10,%esp 10bec5: 31 c0 xor %eax,%eax } 10bec7: 8d 65 f8 lea -0x8(%ebp),%esp 10beca: 5b pop %ebx 10becb: 5e pop %esi 10becc: c9 leave 10becd: c3 ret 10bece: 66 90 xchg %ax,%ax { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10bed0: e8 fb c8 ff ff call 1087d0 10bed5: 39 f0 cmp %esi,%eax 10bed7: 74 d6 je 10beaf rtems_set_errno_and_return_minus_one( ESRCH ); 10bed9: e8 46 81 00 00 call 114024 <__errno> 10bede: c7 00 03 00 00 00 movl $0x3,(%eax) 10bee4: b8 ff ff ff ff mov $0xffffffff,%eax 10bee9: eb dc jmp 10bec7 if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10beeb: e8 34 81 00 00 call 114024 <__errno> 10bef0: c7 00 16 00 00 00 movl $0x16,(%eax) 10bef6: b8 ff ff ff ff mov $0xffffffff,%eax 10befb: eb ca jmp 10bec7 =============================================================================== 0010e604 : */ int sem_close( sem_t *sem ) { 10e604: 55 push %ebp 10e605: 89 e5 mov %esp,%ebp 10e607: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e60a: 8d 45 f4 lea -0xc(%ebp),%eax sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) _Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location ); 10e60d: 50 push %eax 10e60e: 8b 45 08 mov 0x8(%ebp),%eax 10e611: ff 30 pushl (%eax) 10e613: 68 40 d6 12 00 push $0x12d640 10e618: e8 c7 21 00 00 call 1107e4 <_Objects_Get> switch ( location ) { 10e61d: 83 c4 10 add $0x10,%esp 10e620: 8b 55 f4 mov -0xc(%ebp),%edx 10e623: 85 d2 test %edx,%edx 10e625: 74 15 je 10e63c #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e627: e8 30 90 00 00 call 11765c <__errno> 10e62c: c7 00 16 00 00 00 movl $0x16,(%eax) 10e632: b8 ff ff ff ff mov $0xffffffff,%eax } 10e637: c9 leave 10e638: c3 ret 10e639: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 10e63c: ff 48 18 decl 0x18(%eax) _POSIX_Semaphore_Delete( the_semaphore ); 10e63f: 83 ec 0c sub $0xc,%esp 10e642: 50 push %eax 10e643: e8 1c 64 00 00 call 114a64 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10e648: e8 cb 2c 00 00 call 111318 <_Thread_Enable_dispatch> return 0; 10e64d: 83 c4 10 add $0x10,%esp 10e650: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e652: c9 leave 10e653: c3 ret =============================================================================== 0010e654 : */ int sem_destroy( sem_t *sem ) { 10e654: 55 push %ebp 10e655: 89 e5 mov %esp,%ebp 10e657: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e65a: 8d 45 f4 lea -0xc(%ebp),%eax 10e65d: 50 push %eax 10e65e: 8b 45 08 mov 0x8(%ebp),%eax 10e661: ff 30 pushl (%eax) 10e663: 68 40 d6 12 00 push $0x12d640 10e668: e8 77 21 00 00 call 1107e4 <_Objects_Get> switch ( location ) { 10e66d: 83 c4 10 add $0x10,%esp 10e670: 8b 55 f4 mov -0xc(%ebp),%edx 10e673: 85 d2 test %edx,%edx 10e675: 74 15 je 10e68c #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e677: e8 e0 8f 00 00 call 11765c <__errno> 10e67c: c7 00 16 00 00 00 movl $0x16,(%eax) 10e682: b8 ff ff ff ff mov $0xffffffff,%eax } 10e687: c9 leave 10e688: c3 ret 10e689: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == true ) { 10e68c: 80 78 14 00 cmpb $0x0,0x14(%eax) 10e690: 75 16 jne 10e6a8 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 10e692: 83 ec 0c sub $0xc,%esp 10e695: 50 push %eax 10e696: e8 c9 63 00 00 call 114a64 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10e69b: e8 78 2c 00 00 call 111318 <_Thread_Enable_dispatch> return 0; 10e6a0: 83 c4 10 add $0x10,%esp 10e6a3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e6a5: c9 leave 10e6a6: c3 ret 10e6a7: 90 nop /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == true ) { _Thread_Enable_dispatch(); 10e6a8: e8 6b 2c 00 00 call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 10e6ad: e8 aa 8f 00 00 call 11765c <__errno> 10e6b2: c7 00 16 00 00 00 movl $0x16,(%eax) 10e6b8: b8 ff ff ff ff mov $0xffffffff,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e6bd: c9 leave 10e6be: c3 ret =============================================================================== 0010e6c0 : int sem_getvalue( sem_t *sem, int *sval ) { 10e6c0: 55 push %ebp 10e6c1: 89 e5 mov %esp,%ebp 10e6c3: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e6c6: 8d 45 f4 lea -0xc(%ebp),%eax 10e6c9: 50 push %eax 10e6ca: 8b 45 08 mov 0x8(%ebp),%eax 10e6cd: ff 30 pushl (%eax) 10e6cf: 68 40 d6 12 00 push $0x12d640 10e6d4: e8 0b 21 00 00 call 1107e4 <_Objects_Get> switch ( location ) { 10e6d9: 83 c4 10 add $0x10,%esp 10e6dc: 8b 55 f4 mov -0xc(%ebp),%edx 10e6df: 85 d2 test %edx,%edx 10e6e1: 74 15 je 10e6f8 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e6e3: e8 74 8f 00 00 call 11765c <__errno> 10e6e8: c7 00 16 00 00 00 movl $0x16,(%eax) 10e6ee: b8 ff ff ff ff mov $0xffffffff,%eax } 10e6f3: c9 leave 10e6f4: c3 ret 10e6f5: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 10e6f8: 8b 50 64 mov 0x64(%eax),%edx 10e6fb: 8b 45 0c mov 0xc(%ebp),%eax 10e6fe: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e700: e8 13 2c 00 00 call 111318 <_Thread_Enable_dispatch> return 0; 10e705: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e707: c9 leave 10e708: c3 ret =============================================================================== 0010e754 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10e754: 55 push %ebp 10e755: 89 e5 mov %esp,%ebp 10e757: 57 push %edi 10e758: 56 push %esi 10e759: 53 push %ebx 10e75a: 83 ec 2c sub $0x2c,%esp 10e75d: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10e760: a1 f0 d2 12 00 mov 0x12d2f0,%eax 10e765: 40 inc %eax 10e766: a3 f0 d2 12 00 mov %eax,0x12d2f0 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10e76b: 8b 7d 0c mov 0xc(%ebp),%edi 10e76e: 81 e7 00 02 00 00 and $0x200,%edi 10e774: 0f 85 86 00 00 00 jne 10e800 /* unsigned int value */ ) { va_list arg; mode_t mode; unsigned int value = 0; 10e77a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10e781: 83 ec 08 sub $0x8,%esp 10e784: 8d 45 e4 lea -0x1c(%ebp),%eax 10e787: 50 push %eax 10e788: 56 push %esi 10e789: e8 26 63 00 00 call 114ab4 <_POSIX_Semaphore_Name_to_id> 10e78e: 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 ) { 10e790: 83 c4 10 add $0x10,%esp 10e793: 85 c0 test %eax,%eax 10e795: 74 25 je 10e7bc /* * 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) ) ) { 10e797: 83 f8 02 cmp $0x2,%eax 10e79a: 75 04 jne 10e7a0 <== NEVER TAKEN 10e79c: 85 ff test %edi,%edi 10e79e: 75 6c jne 10e80c _Thread_Enable_dispatch(); 10e7a0: e8 73 2b 00 00 call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10e7a5: e8 b2 8e 00 00 call 11765c <__errno> 10e7aa: 89 18 mov %ebx,(%eax) 10e7ac: b8 ff ff ff ff mov $0xffffffff,%eax id = &the_semaphore->Semaphore_id; #else id = (sem_t *)&the_semaphore->Object.id; #endif return id; } 10e7b1: 8d 65 f4 lea -0xc(%ebp),%esp 10e7b4: 5b pop %ebx 10e7b5: 5e pop %esi 10e7b6: 5f pop %edi 10e7b7: c9 leave 10e7b8: c3 ret 10e7b9: 8d 76 00 lea 0x0(%esi),%esi /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10e7bc: 8b 45 0c mov 0xc(%ebp),%eax 10e7bf: 25 00 0a 00 00 and $0xa00,%eax 10e7c4: 3d 00 0a 00 00 cmp $0xa00,%eax 10e7c9: 74 65 je 10e830 10e7cb: 50 push %eax _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10e7cc: 8d 45 dc lea -0x24(%ebp),%eax 10e7cf: 50 push %eax 10e7d0: ff 75 e4 pushl -0x1c(%ebp) 10e7d3: 68 40 d6 12 00 push $0x12d640 10e7d8: e8 07 20 00 00 call 1107e4 <_Objects_Get> 10e7dd: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10e7e0: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10e7e3: e8 30 2b 00 00 call 111318 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10e7e8: e8 2b 2b 00 00 call 111318 <_Thread_Enable_dispatch> goto return_id; 10e7ed: 83 c4 10 add $0x10,%esp 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; 10e7f0: 8b 45 e0 mov -0x20(%ebp),%eax 10e7f3: 83 c0 08 add $0x8,%eax #endif return id; } 10e7f6: 8d 65 f4 lea -0xc(%ebp),%esp 10e7f9: 5b pop %ebx 10e7fa: 5e pop %esi 10e7fb: 5f pop %edi 10e7fc: c9 leave 10e7fd: c3 ret 10e7fe: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10e800: 8b 45 14 mov 0x14(%ebp),%eax 10e803: 89 45 d4 mov %eax,-0x2c(%ebp) 10e806: e9 76 ff ff ff jmp 10e781 10e80b: 90 nop /* * 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( 10e80c: 8d 45 e0 lea -0x20(%ebp),%eax 10e80f: 50 push %eax 10e810: ff 75 d4 pushl -0x2c(%ebp) 10e813: 6a 00 push $0x0 10e815: 56 push %esi 10e816: e8 3d 61 00 00 call 114958 <_POSIX_Semaphore_Create_support> 10e81b: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10e81d: e8 f6 2a 00 00 call 111318 <_Thread_Enable_dispatch> if ( status == -1 ) 10e822: 83 c4 10 add $0x10,%esp 10e825: 43 inc %ebx 10e826: 75 c8 jne 10e7f0 return SEM_FAILED; 10e828: b8 ff ff ff ff mov $0xffffffff,%eax 10e82d: eb c7 jmp 10e7f6 10e82f: 90 nop /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); 10e830: e8 e3 2a 00 00 call 111318 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10e835: e8 22 8e 00 00 call 11765c <__errno> 10e83a: c7 00 11 00 00 00 movl $0x11,(%eax) 10e840: b8 ff ff ff ff mov $0xffffffff,%eax 10e845: eb af jmp 10e7f6 =============================================================================== 0010e848 : */ int sem_post( sem_t *sem ) { 10e848: 55 push %ebp 10e849: 89 e5 mov %esp,%ebp 10e84b: 83 ec 1c sub $0x1c,%esp register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); 10e84e: 8d 45 f4 lea -0xc(%ebp),%eax 10e851: 50 push %eax 10e852: 8b 45 08 mov 0x8(%ebp),%eax 10e855: ff 30 pushl (%eax) 10e857: 68 40 d6 12 00 push $0x12d640 10e85c: e8 83 1f 00 00 call 1107e4 <_Objects_Get> switch ( location ) { 10e861: 83 c4 10 add $0x10,%esp 10e864: 8b 4d f4 mov -0xc(%ebp),%ecx 10e867: 85 c9 test %ecx,%ecx 10e869: 74 15 je 10e880 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10e86b: e8 ec 8d 00 00 call 11765c <__errno> 10e870: c7 00 16 00 00 00 movl $0x16,(%eax) 10e876: b8 ff ff ff ff mov $0xffffffff,%eax } 10e87b: c9 leave 10e87c: c3 ret 10e87d: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 10e880: 52 push %edx 10e881: 6a 00 push $0x0 10e883: ff 70 08 pushl 0x8(%eax) 10e886: 83 c0 1c add $0x1c,%eax 10e889: 50 push %eax 10e88a: e8 65 15 00 00 call 10fdf4 <_CORE_semaphore_Surrender> NULL /* XXX need to define a routine to handle this case */ #else NULL #endif ); _Thread_Enable_dispatch(); 10e88f: e8 84 2a 00 00 call 111318 <_Thread_Enable_dispatch> return 0; 10e894: 83 c4 10 add $0x10,%esp 10e897: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10e899: c9 leave 10e89a: c3 ret =============================================================================== 0010e89c : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 10e89c: 55 push %ebp 10e89d: 89 e5 mov %esp,%ebp 10e89f: 53 push %ebx 10e8a0: 83 ec 1c sub $0x1c,%esp 10e8a3: 8b 5d 08 mov 0x8(%ebp),%ebx * * 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 ); 10e8a6: 8d 45 f4 lea -0xc(%ebp),%eax 10e8a9: 50 push %eax 10e8aa: ff 75 0c pushl 0xc(%ebp) 10e8ad: e8 36 55 00 00 call 113de8 <_POSIX_Absolute_timeout_to_ticks> if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10e8b2: 83 c4 10 add $0x10,%esp 10e8b5: 83 f8 03 cmp $0x3,%eax 10e8b8: 74 16 je 10e8d0 <== ALWAYS TAKEN do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10e8ba: 50 push %eax <== NOT EXECUTED 10e8bb: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10e8be: 6a 00 push $0x0 <== NOT EXECUTED 10e8c0: 53 push %ebx <== NOT EXECUTED 10e8c1: e8 5a 62 00 00 call 114b20 <_POSIX_Semaphore_Wait_support><== NOT EXECUTED 10e8c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) rtems_set_errno_and_return_minus_one( ETIMEDOUT ); } return lock_status; } 10e8c9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e8cc: c9 leave <== NOT EXECUTED 10e8cd: c3 ret <== NOT EXECUTED 10e8ce: 66 90 xchg %ax,%ax <== NOT EXECUTED */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10e8d0: 52 push %edx 10e8d1: ff 75 f4 pushl -0xc(%ebp) 10e8d4: 6a 01 push $0x1 10e8d6: 53 push %ebx 10e8d7: e8 44 62 00 00 call 114b20 <_POSIX_Semaphore_Wait_support> 10e8dc: 83 c4 10 add $0x10,%esp lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) rtems_set_errno_and_return_minus_one( ETIMEDOUT ); } return lock_status; } 10e8df: 8b 5d fc mov -0x4(%ebp),%ebx 10e8e2: c9 leave 10e8e3: c3 ret =============================================================================== 0010b2f4 : int setitimer( int which, const struct itimerval *value, struct itimerval *ovalue ) { 10b2f4: 55 push %ebp 10b2f5: 89 e5 mov %esp,%ebp 10b2f7: 83 ec 08 sub $0x8,%esp if ( !value ) 10b2fa: 8b 55 0c mov 0xc(%ebp),%edx 10b2fd: 85 d2 test %edx,%edx 10b2ff: 74 33 je 10b334 rtems_set_errno_and_return_minus_one( EFAULT ); if ( !ovalue ) 10b301: 8b 45 10 mov 0x10(%ebp),%eax 10b304: 85 c0 test %eax,%eax 10b306: 74 2c je 10b334 rtems_set_errno_and_return_minus_one( EFAULT ); switch ( which ) { 10b308: 83 7d 08 02 cmpl $0x2,0x8(%ebp) 10b30c: 76 12 jbe 10b320 case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b30e: e8 21 87 00 00 call 113a34 <__errno> 10b313: c7 00 16 00 00 00 movl $0x16,(%eax) } 10b319: b8 ff ff ff ff mov $0xffffffff,%eax 10b31e: c9 leave 10b31f: c3 ret switch ( which ) { case ITIMER_REAL: case ITIMER_VIRTUAL: case ITIMER_PROF: rtems_set_errno_and_return_minus_one( ENOSYS ); 10b320: e8 0f 87 00 00 call 113a34 <__errno> 10b325: c7 00 58 00 00 00 movl $0x58,(%eax) default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b32b: b8 ff ff ff ff mov $0xffffffff,%eax 10b330: c9 leave 10b331: c3 ret 10b332: 66 90 xchg %ax,%ax { if ( !value ) rtems_set_errno_and_return_minus_one( EFAULT ); if ( !ovalue ) rtems_set_errno_and_return_minus_one( EFAULT ); 10b334: e8 fb 86 00 00 call 113a34 <__errno> 10b339: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b33f: eb d8 jmp 10b319 =============================================================================== 0010bd50 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10bd50: 55 push %ebp 10bd51: 89 e5 mov %esp,%ebp 10bd53: 57 push %edi 10bd54: 56 push %esi 10bd55: 53 push %ebx 10bd56: 83 ec 1c sub $0x1c,%esp 10bd59: 8b 5d 08 mov 0x8(%ebp),%ebx 10bd5c: 8b 45 0c mov 0xc(%ebp),%eax 10bd5f: 8b 55 10 mov 0x10(%ebp),%edx ISR_Level level; if ( oact ) 10bd62: 85 d2 test %edx,%edx 10bd64: 74 13 je 10bd79 *oact = _POSIX_signals_Vectors[ sig ]; 10bd66: 8d 0c 5b lea (%ebx,%ebx,2),%ecx 10bd69: 8d 34 8d e0 8b 12 00 lea 0x128be0(,%ecx,4),%esi 10bd70: b9 03 00 00 00 mov $0x3,%ecx 10bd75: 89 d7 mov %edx,%edi 10bd77: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10bd79: 85 db test %ebx,%ebx 10bd7b: 74 77 je 10bdf4 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10bd7d: 8d 53 ff lea -0x1(%ebx),%edx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10bd80: 83 fa 1f cmp $0x1f,%edx 10bd83: 77 6f ja 10bdf4 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10bd85: 83 fb 09 cmp $0x9,%ebx 10bd88: 74 6a je 10bdf4 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10bd8a: 85 c0 test %eax,%eax 10bd8c: 74 62 je 10bdf0 <== 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 ); 10bd8e: 9c pushf 10bd8f: fa cli 10bd90: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10bd93: 8b 50 08 mov 0x8(%eax),%edx 10bd96: 85 d2 test %edx,%edx 10bd98: 74 36 je 10bdd0 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( sig ); 10bd9a: 83 ec 0c sub $0xc,%esp 10bd9d: 53 push %ebx 10bd9e: 89 45 e0 mov %eax,-0x20(%ebp) 10bda1: e8 96 57 00 00 call 11153c <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10bda6: 8d 14 5b lea (%ebx,%ebx,2),%edx 10bda9: 8d 14 95 e0 8b 12 00 lea 0x128be0(,%edx,4),%edx 10bdb0: b9 03 00 00 00 mov $0x3,%ecx 10bdb5: 8b 45 e0 mov -0x20(%ebp),%eax 10bdb8: 89 d7 mov %edx,%edi 10bdba: 89 c6 mov %eax,%esi 10bdbc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bdbe: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10bdc1: ff 75 e4 pushl -0x1c(%ebp) 10bdc4: 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; 10bdc5: 31 c0 xor %eax,%eax } 10bdc7: 8d 65 f4 lea -0xc(%ebp),%esp 10bdca: 5b pop %ebx 10bdcb: 5e pop %esi 10bdcc: 5f pop %edi 10bdcd: c9 leave 10bdce: c3 ret 10bdcf: 90 nop * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); if ( act->sa_handler == SIG_DFL ) { _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10bdd0: 8d 34 5b lea (%ebx,%ebx,2),%esi 10bdd3: c1 e6 02 shl $0x2,%esi 10bdd6: 8d 86 e0 8b 12 00 lea 0x128be0(%esi),%eax 10bddc: 81 c6 20 30 12 00 add $0x123020,%esi 10bde2: b9 03 00 00 00 mov $0x3,%ecx 10bde7: 89 c7 mov %eax,%edi 10bde9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bdeb: eb d4 jmp 10bdc1 10bded: 8d 76 00 lea 0x0(%esi),%esi * 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; 10bdf0: 31 c0 xor %eax,%eax 10bdf2: eb d3 jmp 10bdc7 * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 10bdf4: e8 27 85 00 00 call 114320 <__errno> 10bdf9: c7 00 16 00 00 00 movl $0x16,(%eax) 10bdff: b8 ff ff ff ff mov $0xffffffff,%eax 10be04: eb c1 jmp 10bdc7 =============================================================================== 0010c120 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10c120: 55 push %ebp 10c121: 89 e5 mov %esp,%ebp 10c123: 57 push %edi 10c124: 56 push %esi 10c125: 53 push %ebx 10c126: 83 ec 2c sub $0x2c,%esp 10c129: 8b 5d 08 mov 0x8(%ebp),%ebx 10c12c: 8b 7d 0c mov 0xc(%ebp),%edi 10c12f: 8b 75 10 mov 0x10(%ebp),%esi ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10c132: 85 db test %ebx,%ebx 10c134: 0f 84 9e 01 00 00 je 10c2d8 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10c13a: 85 f6 test %esi,%esi 10c13c: 0f 84 3e 01 00 00 je 10c280 if ( !_Timespec_Is_valid( timeout ) ) 10c142: 83 ec 0c sub $0xc,%esp 10c145: 56 push %esi 10c146: e8 19 36 00 00 call 10f764 <_Timespec_Is_valid> 10c14b: 83 c4 10 add $0x10,%esp 10c14e: 84 c0 test %al,%al 10c150: 0f 84 82 01 00 00 je 10c2d8 rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10c156: 83 ec 0c sub $0xc,%esp 10c159: 56 push %esi 10c15a: e8 6d 36 00 00 call 10f7cc <_Timespec_To_ticks> if ( !interval ) 10c15f: 83 c4 10 add $0x10,%esp 10c162: 85 c0 test %eax,%eax 10c164: 0f 84 6e 01 00 00 je 10c2d8 <== NEVER TAKEN /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10c16a: 85 ff test %edi,%edi 10c16c: 0f 84 18 01 00 00 je 10c28a <== NEVER TAKEN the_thread = _Thread_Executing; 10c172: 8b 0d 38 a2 12 00 mov 0x12a238,%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c178: 8b 91 ec 00 00 00 mov 0xec(%ecx),%edx * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10c17e: 9c pushf 10c17f: fa cli 10c180: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10c183: 8b 33 mov (%ebx),%esi 10c185: 89 75 d4 mov %esi,-0x2c(%ebp) 10c188: 8b b2 d4 00 00 00 mov 0xd4(%edx),%esi 10c18e: 85 75 d4 test %esi,-0x2c(%ebp) 10c191: 0f 85 fd 00 00 00 jne 10c294 return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10c197: 8b 35 a8 a4 12 00 mov 0x12a4a8,%esi 10c19d: 85 75 d4 test %esi,-0x2c(%ebp) 10c1a0: 0f 85 96 00 00 00 jne 10c23c the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 10c1a6: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10c1ac: 8b 35 50 9c 12 00 mov 0x129c50,%esi 10c1b2: 46 inc %esi 10c1b3: 89 35 50 9c 12 00 mov %esi,0x129c50 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10c1b9: c7 41 44 40 a4 12 00 movl $0x12a440,0x44(%ecx) the_thread->Wait.return_code = EINTR; 10c1c0: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx) the_thread->Wait.option = *set; 10c1c7: 8b 33 mov (%ebx),%esi 10c1c9: 89 71 30 mov %esi,0x30(%ecx) the_thread->Wait.return_argument = the_info; 10c1cc: 89 79 28 mov %edi,0x28(%ecx) 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; 10c1cf: c7 05 70 a4 12 00 01 movl $0x1,0x12a470 10c1d6: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10c1d9: ff 75 d0 pushl -0x30(%ebp) 10c1dc: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10c1dd: 51 push %ecx 10c1de: 68 48 f4 10 00 push $0x10f448 10c1e3: 50 push %eax 10c1e4: 68 40 a4 12 00 push $0x12a440 10c1e9: 89 55 cc mov %edx,-0x34(%ebp) 10c1ec: e8 2b 2f 00 00 call 10f11c <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10c1f1: e8 4a 2a 00 00 call 10ec40 <_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 ); 10c1f6: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c1fd: 6a 00 push $0x0 10c1ff: 57 push %edi 10c200: ff 37 pushl (%edi) 10c202: 8b 55 cc mov -0x34(%ebp),%edx 10c205: 52 push %edx 10c206: e8 1d 5a 00 00 call 111c28 <_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) 10c20b: 83 c4 20 add $0x20,%esp 10c20e: a1 38 a2 12 00 mov 0x12a238,%eax 10c213: 83 78 34 04 cmpl $0x4,0x34(%eax) 10c217: 0f 85 d3 00 00 00 jne 10c2f0 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10c21d: 8b 37 mov (%edi),%esi 10c21f: 8d 4e ff lea -0x1(%esi),%ecx 10c222: b8 01 00 00 00 mov $0x1,%eax 10c227: d3 e0 shl %cl,%eax 10c229: 85 03 test %eax,(%ebx) 10c22b: 0f 84 bf 00 00 00 je 10c2f0 <== NEVER TAKEN errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 10c231: 89 f0 mov %esi,%eax 10c233: 8d 65 f4 lea -0xc(%ebp),%esp 10c236: 5b pop %ebx 10c237: 5e pop %esi 10c238: 5f pop %edi 10c239: c9 leave 10c23a: c3 ret 10c23b: 90 nop } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10c23c: 83 ec 0c sub $0xc,%esp 10c23f: 56 push %esi 10c240: 89 55 cc mov %edx,-0x34(%ebp) 10c243: e8 94 fe ff ff call 10c0dc <_POSIX_signals_Get_lowest> 10c248: 89 c6 mov %eax,%esi _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10c24a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c251: 6a 01 push $0x1 10c253: 57 push %edi 10c254: 50 push %eax 10c255: 8b 55 cc mov -0x34(%ebp),%edx 10c258: 52 push %edx 10c259: e8 ca 59 00 00 call 111c28 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10c25e: ff 75 d0 pushl -0x30(%ebp) 10c261: 9d popf the_info->si_signo = signo; 10c262: 89 37 mov %esi,(%edi) the_info->si_code = SI_USER; 10c264: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10c26b: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10c272: 83 c4 20 add $0x20,%esp errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 10c275: 89 f0 mov %esi,%eax 10c277: 8d 65 f4 lea -0xc(%ebp),%esp 10c27a: 5b pop %ebx 10c27b: 5e pop %esi 10c27c: 5f pop %edi 10c27d: c9 leave 10c27e: c3 ret 10c27f: 90 nop /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10c280: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10c282: 85 ff test %edi,%edi 10c284: 0f 85 e8 fe ff ff jne 10c172 10c28a: 8d 7d dc lea -0x24(%ebp),%edi 10c28d: e9 e0 fe ff ff jmp 10c172 10c292: 66 90 xchg %ax,%ax /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10c294: 83 ec 0c sub $0xc,%esp 10c297: 56 push %esi 10c298: 89 55 cc mov %edx,-0x34(%ebp) 10c29b: e8 3c fe ff ff call 10c0dc <_POSIX_signals_Get_lowest> 10c2a0: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10c2a2: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c2a9: 6a 00 push $0x0 10c2ab: 57 push %edi 10c2ac: 50 push %eax 10c2ad: 8b 55 cc mov -0x34(%ebp),%edx 10c2b0: 52 push %edx 10c2b1: e8 72 59 00 00 call 111c28 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10c2b6: ff 75 d0 pushl -0x30(%ebp) 10c2b9: 9d popf the_info->si_code = SI_USER; 10c2ba: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10c2c1: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10c2c8: 8b 37 mov (%edi),%esi 10c2ca: 83 c4 20 add $0x20,%esp errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 10c2cd: 89 f0 mov %esi,%eax 10c2cf: 8d 65 f4 lea -0xc(%ebp),%esp 10c2d2: 5b pop %ebx 10c2d3: 5e pop %esi 10c2d4: 5f pop %edi 10c2d5: c9 leave 10c2d6: c3 ret 10c2d7: 90 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c2d8: e8 87 86 00 00 call 114964 <__errno> 10c2dd: c7 00 16 00 00 00 movl $0x16,(%eax) 10c2e3: be ff ff ff ff mov $0xffffffff,%esi 10c2e8: e9 44 ff ff ff jmp 10c231 10c2ed: 8d 76 00 lea 0x0(%esi),%esi * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) || !(*set & signo_to_mask( the_info->si_signo )) ) { errno = _Thread_Executing->Wait.return_code; 10c2f0: e8 6f 86 00 00 call 114964 <__errno> 10c2f5: 8b 15 38 a2 12 00 mov 0x12a238,%edx 10c2fb: 8b 52 34 mov 0x34(%edx),%edx 10c2fe: 89 10 mov %edx,(%eax) return -1; 10c300: be ff ff ff ff mov $0xffffffff,%esi 10c305: e9 27 ff ff ff jmp 10c231 =============================================================================== 0010df98 : int sigwait( const sigset_t *set, int *sig ) { 10df98: 55 push %ebp 10df99: 89 e5 mov %esp,%ebp 10df9b: 53 push %ebx 10df9c: 83 ec 08 sub $0x8,%esp 10df9f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10dfa2: 6a 00 push $0x0 10dfa4: 6a 00 push $0x0 10dfa6: ff 75 08 pushl 0x8(%ebp) 10dfa9: e8 e6 fd ff ff call 10dd94 if ( status != -1 ) { 10dfae: 83 c4 10 add $0x10,%esp 10dfb1: 83 f8 ff cmp $0xffffffff,%eax 10dfb4: 74 0e je 10dfc4 if ( sig ) 10dfb6: 85 db test %ebx,%ebx 10dfb8: 74 16 je 10dfd0 <== NEVER TAKEN *sig = status; 10dfba: 89 03 mov %eax,(%ebx) return 0; 10dfbc: 31 c0 xor %eax,%eax } return errno; } 10dfbe: 8b 5d fc mov -0x4(%ebp),%ebx 10dfc1: c9 leave 10dfc2: c3 ret 10dfc3: 90 nop if ( sig ) *sig = status; return 0; } return errno; 10dfc4: e8 5b 81 00 00 call 116124 <__errno> 10dfc9: 8b 00 mov (%eax),%eax } 10dfcb: 8b 5d fc mov -0x4(%ebp),%ebx 10dfce: c9 leave 10dfcf: c3 ret status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) *sig = status; return 0; 10dfd0: 31 c0 xor %eax,%eax } return errno; } 10dfd2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dfd5: c9 leave <== NOT EXECUTED 10dfd6: c3 ret <== NOT EXECUTED =============================================================================== 0010b500 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10b500: 55 push %ebp 10b501: 89 e5 mov %esp,%ebp 10b503: 56 push %esi 10b504: 53 push %ebx 10b505: 8b 5d 0c mov 0xc(%ebp),%ebx 10b508: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10b50b: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10b50f: 0f 85 db 00 00 00 jne 10b5f0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10b515: 85 f6 test %esi,%esi 10b517: 0f 84 d3 00 00 00 je 10b5f0 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10b51d: 85 db test %ebx,%ebx 10b51f: 74 21 je 10b542 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10b521: 8b 03 mov (%ebx),%eax 10b523: 48 dec %eax 10b524: 83 f8 01 cmp $0x1,%eax 10b527: 0f 87 c3 00 00 00 ja 10b5f0 <== 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 ) 10b52d: 8b 43 04 mov 0x4(%ebx),%eax 10b530: 85 c0 test %eax,%eax 10b532: 0f 84 b8 00 00 00 je 10b5f0 <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10b538: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10b539: 83 f8 1f cmp $0x1f,%eax 10b53c: 0f 87 ae 00 00 00 ja 10b5f0 <== NEVER TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b542: a1 90 98 12 00 mov 0x129890,%eax 10b547: 40 inc %eax 10b548: a3 90 98 12 00 mov %eax,0x129890 * 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 ); 10b54d: 83 ec 0c sub $0xc,%esp 10b550: 68 20 9c 12 00 push $0x129c20 10b555: e8 9e 1e 00 00 call 10d3f8 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10b55a: 83 c4 10 add $0x10,%esp 10b55d: 85 c0 test %eax,%eax 10b55f: 0f 84 a2 00 00 00 je 10b607 rtems_set_errno_and_return_minus_one( EAGAIN ); } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10b565: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10b569: 8b 15 78 9e 12 00 mov 0x129e78,%edx 10b56f: 8b 52 08 mov 0x8(%edx),%edx 10b572: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10b575: 85 db test %ebx,%ebx 10b577: 74 11 je 10b58a ptimer->inf.sigev_notify = evp->sigev_notify; 10b579: 8b 13 mov (%ebx),%edx 10b57b: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10b57e: 8b 53 04 mov 0x4(%ebx),%edx 10b581: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10b584: 8b 53 08 mov 0x8(%ebx),%edx 10b587: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10b58a: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10b591: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10b598: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10b59f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10b5a6: 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; 10b5ad: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10b5b4: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10b5bb: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10b5c2: 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 ), 10b5c9: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b5cc: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b5cf: 8b 0d 3c 9c 12 00 mov 0x129c3c,%ecx 10b5d5: 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; 10b5d8: 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; 10b5df: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10b5e1: e8 7e 2d 00 00 call 10e364 <_Thread_Enable_dispatch> return 0; 10b5e6: 31 c0 xor %eax,%eax } 10b5e8: 8d 65 f8 lea -0x8(%ebp),%esp 10b5eb: 5b pop %ebx 10b5ec: 5e pop %esi 10b5ed: c9 leave 10b5ee: c3 ret 10b5ef: 90 nop if ( !evp->sigev_signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10b5f0: e8 d3 8a 00 00 call 1140c8 <__errno> 10b5f5: c7 00 16 00 00 00 movl $0x16,(%eax) 10b5fb: b8 ff ff ff ff mov $0xffffffff,%eax _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; _Thread_Enable_dispatch(); return 0; } 10b600: 8d 65 f8 lea -0x8(%ebp),%esp 10b603: 5b pop %ebx 10b604: 5e pop %esi 10b605: c9 leave 10b606: c3 ret /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); 10b607: e8 58 2d 00 00 call 10e364 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10b60c: e8 b7 8a 00 00 call 1140c8 <__errno> 10b611: c7 00 0b 00 00 00 movl $0xb,(%eax) 10b617: b8 ff ff ff ff mov $0xffffffff,%eax 10b61c: eb ca jmp 10b5e8 =============================================================================== 0010ba44 : int timer_delete( timer_t timerid ) { 10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 53 push %ebx 10ba48: 83 ec 18 sub $0x18,%esp * because rtems_timer_delete stops the timer before deleting it. */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 10ba4b: 8d 45 f4 lea -0xc(%ebp),%eax timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10ba4e: 50 push %eax 10ba4f: ff 75 08 pushl 0x8(%ebp) 10ba52: 68 00 9b 12 00 push $0x129b00 10ba57: e8 a4 21 00 00 call 10dc00 <_Objects_Get> 10ba5c: 89 c3 mov %eax,%ebx switch ( location ) { 10ba5e: 83 c4 10 add $0x10,%esp 10ba61: 8b 4d f4 mov -0xc(%ebp),%ecx 10ba64: 85 c9 test %ecx,%ecx 10ba66: 74 18 je 10ba80 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10ba68: e8 6b 8d 00 00 call 1147d8 <__errno> 10ba6d: c7 00 16 00 00 00 movl $0x16,(%eax) 10ba73: b8 ff ff ff ff mov $0xffffffff,%eax } 10ba78: 8b 5d fc mov -0x4(%ebp),%ebx 10ba7b: c9 leave 10ba7c: c3 ret 10ba7d: 8d 76 00 lea 0x0(%esi),%esi ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); 10ba80: 83 ec 08 sub $0x8,%esp 10ba83: 50 push %eax 10ba84: 68 00 9b 12 00 push $0x129b00 10ba89: e8 36 1d 00 00 call 10d7c4 <_Objects_Close> ptimer->state = POSIX_TIMER_STATE_FREE; 10ba8e: c6 43 3c 01 movb $0x1,0x3c(%ebx) (void) _Watchdog_Remove( &ptimer->Timer ); 10ba92: 8d 43 10 lea 0x10(%ebx),%eax 10ba95: 89 04 24 mov %eax,(%esp) 10ba98: e8 43 3c 00 00 call 10f6e0 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free ( POSIX_Timer_Control *the_timer ) { _Objects_Free( &_POSIX_Timer_Information, &the_timer->Object ); 10ba9d: 58 pop %eax 10ba9e: 5a pop %edx 10ba9f: 53 push %ebx 10baa0: 68 00 9b 12 00 push $0x129b00 10baa5: e8 16 20 00 00 call 10dac0 <_Objects_Free> _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 10baaa: e8 05 2c 00 00 call 10e6b4 <_Thread_Enable_dispatch> return 0; 10baaf: 83 c4 10 add $0x10,%esp 10bab2: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10bab4: 8b 5d fc mov -0x4(%ebp),%ebx 10bab7: c9 leave 10bab8: c3 ret =============================================================================== 0010c900 : * its execution, _POSIX_Timer_TSR will have to set this counter to 0. */ int timer_getoverrun( timer_t timerid ) { 10c900: 55 push %ebp 10c901: 89 e5 mov %esp,%ebp 10c903: 53 push %ebx 10c904: 83 ec 18 sub $0x18,%esp int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 10c907: 8d 45 f4 lea -0xc(%ebp),%eax timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10c90a: 50 push %eax 10c90b: ff 75 08 pushl 0x8(%ebp) 10c90e: 68 c0 b1 12 00 push $0x12b1c0 10c913: e8 2c 21 00 00 call 10ea44 <_Objects_Get> switch ( location ) { 10c918: 83 c4 10 add $0x10,%esp 10c91b: 8b 55 f4 mov -0xc(%ebp),%edx 10c91e: 85 d2 test %edx,%edx 10c920: 74 1a je 10c93c #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c922: e8 31 89 00 00 call 115258 <__errno> 10c927: c7 00 16 00 00 00 movl $0x16,(%eax) 10c92d: bb ff ff ff ff mov $0xffffffff,%ebx } 10c932: 89 d8 mov %ebx,%eax 10c934: 8b 5d fc mov -0x4(%ebp),%ebx 10c937: c9 leave 10c938: c3 ret 10c939: 8d 76 00 lea 0x0(%esi),%esi ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: overrun = ptimer->overrun; 10c93c: 8b 58 68 mov 0x68(%eax),%ebx ptimer->overrun = 0; 10c93f: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) _Thread_Enable_dispatch(); 10c946: e8 ad 2b 00 00 call 10f4f8 <_Thread_Enable_dispatch> case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c94b: 89 d8 mov %ebx,%eax 10c94d: 8b 5d fc mov -0x4(%ebp),%ebx 10c950: c9 leave 10c951: c3 ret =============================================================================== 0010c954 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 10c954: 55 push %ebp 10c955: 89 e5 mov %esp,%ebp 10c957: 56 push %esi 10c958: 53 push %ebx 10c959: 83 ec 10 sub $0x10,%esp 10c95c: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; Watchdog_Interval left; if ( !value ) 10c95f: 85 db test %ebx,%ebx 10c961: 74 65 je 10c9c8 rtems_set_errno_and_return_minus_one( EINVAL ); /* Reads the current time */ _TOD_Get( ¤t_time ); 10c963: 83 ec 0c sub $0xc,%esp 10c966: 8d 45 ec lea -0x14(%ebp),%eax 10c969: 50 push %eax 10c96a: e8 01 17 00 00 call 10e070 <_TOD_Get> 10c96f: 83 c4 0c add $0xc,%esp ptimer = _POSIX_Timer_Get( timerid, &location ); 10c972: 8d 45 f4 lea -0xc(%ebp),%eax 10c975: 50 push %eax 10c976: ff 75 08 pushl 0x8(%ebp) 10c979: 68 c0 b1 12 00 push $0x12b1c0 10c97e: e8 c1 20 00 00 call 10ea44 <_Objects_Get> 10c983: 89 c6 mov %eax,%esi switch ( location ) { 10c985: 83 c4 10 add $0x10,%esp 10c988: 8b 45 f4 mov -0xc(%ebp),%eax 10c98b: 85 c0 test %eax,%eax 10c98d: 75 39 jne 10c9c8 case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ 10c98f: a1 a4 af 12 00 mov 0x12afa4,%eax _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10c994: 83 ec 08 sub $0x8,%esp 10c997: 8d 53 08 lea 0x8(%ebx),%edx 10c99a: 52 push %edx case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ 10c99b: 8b 56 1c mov 0x1c(%esi),%edx 10c99e: 03 56 24 add 0x24(%esi),%edx case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = 10c9a1: 29 c2 sub %eax,%edx (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10c9a3: 52 push %edx 10c9a4: e8 73 36 00 00 call 11001c <_Timespec_From_ticks> value->it_interval = ptimer->timer_data.it_interval; 10c9a9: 8b 46 54 mov 0x54(%esi),%eax 10c9ac: 8b 56 58 mov 0x58(%esi),%edx 10c9af: 89 03 mov %eax,(%ebx) 10c9b1: 89 53 04 mov %edx,0x4(%ebx) _Thread_Enable_dispatch(); 10c9b4: e8 3f 2b 00 00 call 10f4f8 <_Thread_Enable_dispatch> return 0; 10c9b9: 83 c4 10 add $0x10,%esp 10c9bc: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c9be: 8d 65 f8 lea -0x8(%ebp),%esp 10c9c1: 5b pop %ebx 10c9c2: 5e pop %esi 10c9c3: c9 leave 10c9c4: c3 ret 10c9c5: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c9c8: e8 8b 88 00 00 call 115258 <__errno> 10c9cd: c7 00 16 00 00 00 movl $0x16,(%eax) 10c9d3: b8 ff ff ff ff mov $0xffffffff,%eax 10c9d8: eb e4 jmp 10c9be =============================================================================== 0010b620 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10b620: 55 push %ebp 10b621: 89 e5 mov %esp,%ebp 10b623: 57 push %edi 10b624: 56 push %esi 10b625: 53 push %ebx 10b626: 83 ec 3c sub $0x3c,%esp 10b629: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10b62c: 85 db test %ebx,%ebx 10b62e: 0f 84 50 01 00 00 je 10b784 <== 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) ) ) { 10b634: 83 ec 0c sub $0xc,%esp 10b637: 8d 43 08 lea 0x8(%ebx),%eax 10b63a: 50 push %eax 10b63b: e8 6c 38 00 00 call 10eeac <_Timespec_Is_valid> 10b640: 83 c4 10 add $0x10,%esp 10b643: 84 c0 test %al,%al 10b645: 0f 84 39 01 00 00 je 10b784 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10b64b: 83 ec 0c sub $0xc,%esp 10b64e: 53 push %ebx 10b64f: e8 58 38 00 00 call 10eeac <_Timespec_Is_valid> 10b654: 83 c4 10 add $0x10,%esp 10b657: 84 c0 test %al,%al 10b659: 0f 84 25 01 00 00 je 10b784 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10b65f: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10b663: 0f 84 db 00 00 00 je 10b744 10b669: 8b 45 0c mov 0xc(%ebp),%eax 10b66c: 85 c0 test %eax,%eax 10b66e: 0f 85 10 01 00 00 jne 10b784 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b674: 8d 45 cc lea -0x34(%ebp),%eax 10b677: 89 45 c4 mov %eax,-0x3c(%ebp) 10b67a: b9 04 00 00 00 mov $0x4,%ecx 10b67f: 89 c7 mov %eax,%edi 10b681: 89 de mov %ebx,%esi 10b683: f3 a5 rep movsl %ds:(%esi),%es:(%edi) timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10b685: 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 ); 10b686: 8d 45 e4 lea -0x1c(%ebp),%eax 10b689: 50 push %eax 10b68a: ff 75 08 pushl 0x8(%ebp) 10b68d: 68 20 9c 12 00 push $0x129c20 10b692: e8 19 22 00 00 call 10d8b0 <_Objects_Get> 10b697: 89 c2 mov %eax,%edx switch ( location ) { 10b699: 83 c4 10 add $0x10,%esp 10b69c: 8b 7d e4 mov -0x1c(%ebp),%edi 10b69f: 85 ff test %edi,%edi 10b6a1: 0f 85 dd 00 00 00 jne 10b784 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 ) { 10b6a7: 8b 75 d4 mov -0x2c(%ebp),%esi 10b6aa: 85 f6 test %esi,%esi 10b6ac: 75 0b jne 10b6b9 10b6ae: 8b 4d d8 mov -0x28(%ebp),%ecx 10b6b1: 85 c9 test %ecx,%ecx 10b6b3: 0f 84 df 00 00 00 je 10b798 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10b6b9: 83 ec 0c sub $0xc,%esp 10b6bc: 53 push %ebx 10b6bd: 89 55 c0 mov %edx,-0x40(%ebp) 10b6c0: e8 4f 38 00 00 call 10ef14 <_Timespec_To_ticks> 10b6c5: 8b 55 c0 mov -0x40(%ebp),%edx 10b6c8: 89 42 64 mov %eax,0x64(%edx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10b6cb: 8d 45 d4 lea -0x2c(%ebp),%eax 10b6ce: 89 04 24 mov %eax,(%esp) 10b6d1: e8 3e 38 00 00 call 10ef14 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10b6d6: 8b 55 c0 mov -0x40(%ebp),%edx 10b6d9: 89 14 24 mov %edx,(%esp) 10b6dc: 68 04 b8 10 00 push $0x10b804 10b6e1: ff 72 08 pushl 0x8(%edx) 10b6e4: 50 push %eax 10b6e5: 8d 42 10 lea 0x10(%edx),%eax 10b6e8: 50 push %eax 10b6e9: e8 3e 61 00 00 call 11182c <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10b6ee: 83 c4 20 add $0x20,%esp 10b6f1: 84 c0 test %al,%al 10b6f3: 8b 55 c0 mov -0x40(%ebp),%edx 10b6f6: 0f 84 e8 00 00 00 je 10b7e4 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10b6fc: 8b 45 14 mov 0x14(%ebp),%eax 10b6ff: 85 c0 test %eax,%eax 10b701: 0f 84 ed 00 00 00 je 10b7f4 *ovalue = ptimer->timer_data; 10b707: 8d 42 54 lea 0x54(%edx),%eax 10b70a: b9 04 00 00 00 mov $0x4,%ecx 10b70f: 8b 7d 14 mov 0x14(%ebp),%edi 10b712: 89 c6 mov %eax,%esi 10b714: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10b716: b9 04 00 00 00 mov $0x4,%ecx 10b71b: 89 c7 mov %eax,%edi 10b71d: 8b 75 c4 mov -0x3c(%ebp),%esi 10b720: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b722: c6 42 3c 03 movb $0x3,0x3c(%edx) _TOD_Get( &ptimer->time ); 10b726: 83 ec 0c sub $0xc,%esp 10b729: 83 c2 6c add $0x6c,%edx 10b72c: 52 push %edx 10b72d: e8 ce 17 00 00 call 10cf00 <_TOD_Get> _Thread_Enable_dispatch(); 10b732: e8 2d 2c 00 00 call 10e364 <_Thread_Enable_dispatch> return 0; 10b737: 83 c4 10 add $0x10,%esp 10b73a: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b73c: 8d 65 f4 lea -0xc(%ebp),%esp 10b73f: 5b pop %ebx 10b740: 5e pop %esi 10b741: 5f pop %edi 10b742: c9 leave 10b743: c3 ret if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b744: 8d 45 cc lea -0x34(%ebp),%eax 10b747: 89 45 c4 mov %eax,-0x3c(%ebp) 10b74a: 89 c7 mov %eax,%edi 10b74c: 89 de mov %ebx,%esi 10b74e: 8b 4d 0c mov 0xc(%ebp),%ecx 10b751: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { struct timespec now; _TOD_Get( &now ); 10b753: 83 ec 0c sub $0xc,%esp 10b756: 8d 75 dc lea -0x24(%ebp),%esi 10b759: 56 push %esi 10b75a: e8 a1 17 00 00 call 10cf00 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10b75f: 59 pop %ecx 10b760: 5f pop %edi 10b761: 8d 7d d4 lea -0x2c(%ebp),%edi 10b764: 57 push %edi 10b765: 56 push %esi 10b766: e8 1d 37 00 00 call 10ee88 <_Timespec_Greater_than> 10b76b: 83 c4 10 add $0x10,%esp 10b76e: 84 c0 test %al,%al 10b770: 75 12 jne 10b784 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10b772: 52 push %edx 10b773: 57 push %edi 10b774: 57 push %edi 10b775: 56 push %esi 10b776: e8 59 37 00 00 call 10eed4 <_Timespec_Subtract> 10b77b: 83 c4 10 add $0x10,%esp 10b77e: e9 02 ff ff ff jmp 10b685 10b783: 90 nop #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b784: e8 3f 89 00 00 call 1140c8 <__errno> 10b789: c7 00 16 00 00 00 movl $0x16,(%eax) 10b78f: b8 ff ff ff ff mov $0xffffffff,%eax 10b794: eb a6 jmp 10b73c 10b796: 66 90 xchg %ax,%ax 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 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10b798: 83 ec 0c sub $0xc,%esp 10b79b: 8d 40 10 lea 0x10(%eax),%eax 10b79e: 50 push %eax 10b79f: 89 55 c0 mov %edx,-0x40(%ebp) 10b7a2: e8 a1 3b 00 00 call 10f348 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: 8b 55 14 mov 0x14(%ebp),%edx 10b7ad: 85 d2 test %edx,%edx 10b7af: 8b 55 c0 mov -0x40(%ebp),%edx 10b7b2: 74 48 je 10b7fc *ovalue = ptimer->timer_data; 10b7b4: 8d 42 54 lea 0x54(%edx),%eax 10b7b7: b9 04 00 00 00 mov $0x4,%ecx 10b7bc: 8b 7d 14 mov 0x14(%ebp),%edi 10b7bf: 89 c6 mov %eax,%esi 10b7c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10b7c3: b9 04 00 00 00 mov $0x4,%ecx 10b7c8: 89 c7 mov %eax,%edi 10b7ca: 8b 75 c4 mov -0x3c(%ebp),%esi 10b7cd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b7cf: c6 42 3c 04 movb $0x4,0x3c(%edx) /* Returns with success */ _Thread_Enable_dispatch(); 10b7d3: e8 8c 2b 00 00 call 10e364 <_Thread_Enable_dispatch> return 0; 10b7d8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b7da: 8d 65 f4 lea -0xc(%ebp),%esp 10b7dd: 5b pop %ebx 10b7de: 5e pop %esi 10b7df: 5f pop %edi 10b7e0: c9 leave 10b7e1: c3 ret 10b7e2: 66 90 xchg %ax,%ax ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { _Thread_Enable_dispatch(); 10b7e4: e8 7b 2b 00 00 call 10e364 <_Thread_Enable_dispatch> return 0; 10b7e9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b7eb: 8d 65 f4 lea -0xc(%ebp),%esp 10b7ee: 5b pop %ebx 10b7ef: 5e pop %esi 10b7f0: 5f pop %edi 10b7f1: c9 leave 10b7f2: c3 ret 10b7f3: 90 nop 10b7f4: 8d 42 54 lea 0x54(%edx),%eax 10b7f7: e9 1a ff ff ff jmp 10b716 10b7fc: 8d 42 54 lea 0x54(%edx),%eax 10b7ff: eb c2 jmp 10b7c3 =============================================================================== 0010b410 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 10b410: 55 push %ebp 10b411: 89 e5 mov %esp,%ebp 10b413: 56 push %esi 10b414: 53 push %ebx 10b415: 83 ec 10 sub $0x10,%esp 10b418: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 10b41b: 8b 0d 9c 8f 12 00 mov 0x128f9c,%ecx 10b421: 85 c9 test %ecx,%ecx 10b423: 0f 84 8f 00 00 00 je 10b4b8 _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 10b429: 83 ec 0c sub $0xc,%esp 10b42c: 68 80 8f 12 00 push $0x128f80 10b431: e8 72 3a 00 00 call 10eea8 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 10b436: 83 e8 02 sub $0x2,%eax 10b439: 83 c4 10 add $0x10,%esp 10b43c: 83 f8 01 cmp $0x1,%eax 10b43f: 0f 86 a3 00 00 00 jbe 10b4e8 <== ALWAYS TAKEN useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 10b445: 31 f6 xor %esi,%esi /* * 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 ) { 10b447: 85 db test %ebx,%ebx 10b449: 74 62 je 10b4ad Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10b44b: ba 83 de 1b 43 mov $0x431bde83,%edx 10b450: 89 d8 mov %ebx,%eax 10b452: f7 e2 mul %edx 10b454: c1 ea 12 shr $0x12,%edx 10b457: 89 55 f0 mov %edx,-0x10(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10b45a: 8d 04 92 lea (%edx,%edx,4),%eax 10b45d: 8d 04 80 lea (%eax,%eax,4),%eax 10b460: 8d 04 80 lea (%eax,%eax,4),%eax 10b463: 8d 04 80 lea (%eax,%eax,4),%eax 10b466: 8d 04 80 lea (%eax,%eax,4),%eax 10b469: 8d 04 80 lea (%eax,%eax,4),%eax 10b46c: c1 e0 06 shl $0x6,%eax 10b46f: 29 c3 sub %eax,%ebx 10b471: 8d 04 9b lea (%ebx,%ebx,4),%eax 10b474: 8d 04 80 lea (%eax,%eax,4),%eax 10b477: 8d 04 80 lea (%eax,%eax,4),%eax 10b47a: c1 e0 03 shl $0x3,%eax 10b47d: 89 45 f4 mov %eax,-0xc(%ebp) ticks = _Timespec_To_ticks( &tp ); 10b480: 83 ec 0c sub $0xc,%esp 10b483: 8d 5d f0 lea -0x10(%ebp),%ebx 10b486: 53 push %ebx 10b487: e8 70 35 00 00 call 10e9fc <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10b48c: 89 1c 24 mov %ebx,(%esp) 10b48f: e8 68 35 00 00 call 10e9fc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b494: a3 8c 8f 12 00 mov %eax,0x128f8c _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b499: 58 pop %eax 10b49a: 5a pop %edx 10b49b: 68 80 8f 12 00 push $0x128f80 10b4a0: 68 9c 86 12 00 push $0x12869c 10b4a5: e8 be 38 00 00 call 10ed68 <_Watchdog_Insert> 10b4aa: 83 c4 10 add $0x10,%esp } return remaining; } 10b4ad: 89 f0 mov %esi,%eax 10b4af: 8d 65 f8 lea -0x8(%ebp),%esp 10b4b2: 5b pop %ebx 10b4b3: 5e pop %esi 10b4b4: c9 leave 10b4b5: c3 ret 10b4b6: 66 90 xchg %ax,%ax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b4b8: c7 05 88 8f 12 00 00 movl $0x0,0x128f88 10b4bf: 00 00 00 the_watchdog->routine = routine; 10b4c2: c7 05 9c 8f 12 00 d4 movl $0x10b3d4,0x128f9c 10b4c9: b3 10 00 the_watchdog->id = id; 10b4cc: c7 05 a0 8f 12 00 00 movl $0x0,0x128fa0 10b4d3: 00 00 00 the_watchdog->user_data = user_data; 10b4d6: c7 05 a4 8f 12 00 00 movl $0x0,0x128fa4 10b4dd: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 10b4e0: 31 f6 xor %esi,%esi 10b4e2: e9 60 ff ff ff jmp 10b447 10b4e7: 90 nop * 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); 10b4e8: a1 94 8f 12 00 mov 0x128f94,%eax 10b4ed: 03 05 8c 8f 12 00 add 0x128f8c,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10b4f3: 83 ec 08 sub $0x8,%esp 10b4f6: 8d 55 f0 lea -0x10(%ebp),%edx 10b4f9: 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); 10b4fa: 2b 05 98 8f 12 00 sub 0x128f98,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10b500: 50 push %eax 10b501: e8 6e 34 00 00 call 10e974 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10b506: 8b 45 f0 mov -0x10(%ebp),%eax 10b509: 8d 04 80 lea (%eax,%eax,4),%eax 10b50c: 8d 04 80 lea (%eax,%eax,4),%eax 10b50f: 8d 04 80 lea (%eax,%eax,4),%eax 10b512: 8d 04 80 lea (%eax,%eax,4),%eax 10b515: 8d 04 80 lea (%eax,%eax,4),%eax 10b518: 8d 0c 80 lea (%eax,%eax,4),%ecx 10b51b: c1 e1 06 shl $0x6,%ecx remaining += tp.tv_nsec / 1000; 10b51e: 8b 75 f4 mov -0xc(%ebp),%esi 10b521: b8 d3 4d 62 10 mov $0x10624dd3,%eax 10b526: f7 ee imul %esi 10b528: 89 d0 mov %edx,%eax 10b52a: c1 f8 06 sar $0x6,%eax 10b52d: c1 fe 1f sar $0x1f,%esi 10b530: 29 f0 sub %esi,%eax 10b532: 8d 34 08 lea (%eax,%ecx,1),%esi 10b535: 83 c4 10 add $0x10,%esp 10b538: e9 0a ff ff ff jmp 10b447