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 98 80 12 00 mov 0x128098,%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 9c 80 12 00 cmp $0x12809c,%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 9c 80 12 00 cmp $0x12809c,%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 98 80 12 00 mov 0x128098,%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 9c 80 12 00 cmp $0x12809c,%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 18 84 12 00 pushl 0x128418 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 9c 80 12 00 cmp $0x12809c,%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 98 bd 12 00 mov 0x12bd98,%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 98 bd 12 00 mov 0x12bd98,%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 98 bd 12 00 mov 0x12bd98,%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 b0 b7 12 00 mov 0x12b7b0,%eax 10e612: 48 dec %eax 10e613: a3 b0 b7 12 00 mov %eax,0x12b7b0 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 0c 13 00 mov 0x130cd8,%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 0c 13 00 mov 0x130cd8,%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 14 84 12 00 mov 0x128414,%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 18 84 12 00 mov 0x128418,%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 18 84 12 00 mov 0x128418,%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 30 7e 12 00 mov 0x127e30,%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 18 84 12 00 mov 0x128418,%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 00 80 12 00 01 cmpl $0x1,0x128000
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 18 84 12 00 mov 0x128418,%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 30 7e 12 00 mov 0x127e30,%eax 10c2fa: 40 inc %eax 10c2fb: a3 30 7e 12 00 mov %eax,0x127e30 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 18 84 12 00 mov 0x128418,%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 30 7e 12 00 mov 0x127e30,%edx 11125a: 42 inc %edx 11125b: 89 15 30 7e 12 00 mov %edx,0x127e30
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 18 84 12 00 cmp 0x128418,%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 98 e1 12 00 mov 0x12e198,%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 18 84 12 00 mov 0x128418,%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 48 88 12 00 01 movl $0x1,0x128848
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 48 88 12 00 mov 0x128848,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b0f6: c7 05 48 88 12 00 00 movl $0x0,0x128848
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 3c 7f 12 00 push $0x127f3c 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 14 84 12 00 mov 0x128414,%esi 10b21e: 85 f6 test %esi,%esi
10b220: 74 0c je 10b22e <_Event_Surrender+0x3e>
10b222: 3b 1d 18 84 12 00 cmp 0x128418,%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 48 88 12 00 mov 0x128848,%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 48 88 12 00 mov 0x128848,%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 48 88 12 00 03 movl $0x3,0x128848
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 18 84 12 00 cmp 0x128418,%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 30 7e 12 00 mov 0x127e30,%eax 10b35e: 48 dec %eax 10b35f: a3 30 7e 12 00 mov %eax,0x127e30
_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 48 88 12 00 mov 0x128848,%ecx 10b372: 49 dec %ecx
10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10b375: c7 05 48 88 12 00 02 movl $0x2,0x128848
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
0011f5d8 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11f5d8: 55 push %ebp 11f5d9: 89 e5 mov %esp,%ebp 11f5db: 57 push %edi 11f5dc: 56 push %esi 11f5dd: 53 push %ebx 11f5de: 83 ec 2c sub $0x2c,%esp 11f5e1: 8b 5d 08 mov 0x8(%ebp),%ebx 11f5e4: 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);
11f5e7: 8d 4e f8 lea -0x8(%esi),%ecx 11f5ea: 89 f0 mov %esi,%eax 11f5ec: 31 d2 xor %edx,%edx 11f5ee: 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);
11f5f1: 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;
11f5f3: 8b 45 14 mov 0x14(%ebp),%eax 11f5f6: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11f5fc: 8b 55 18 mov 0x18(%ebp),%edx 11f5ff: 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;
11f605: 39 4b 20 cmp %ecx,0x20(%ebx)
11f608: 77 05 ja 11f60f <_Heap_Resize_block+0x37>
11f60a: 39 4b 24 cmp %ecx,0x24(%ebx)
11f60d: 73 0d jae 11f61c <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
11f60f: b8 02 00 00 00 mov $0x2,%eax
} }
11f614: 8d 65 f4 lea -0xc(%ebp),%esp 11f617: 5b pop %ebx 11f618: 5e pop %esi 11f619: 5f pop %edi 11f61a: c9 leave 11f61b: 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;
11f61c: 8b 41 04 mov 0x4(%ecx),%eax 11f61f: 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;
11f622: 8d 3c 01 lea (%ecx,%eax,1),%edi 11f625: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11f628: 89 fa mov %edi,%edx 11f62a: 29 f2 sub %esi,%edx 11f62c: 83 c2 04 add $0x4,%edx 11f62f: 89 55 e0 mov %edx,-0x20(%ebp) 11f632: 8b 57 04 mov 0x4(%edi),%edx 11f635: 83 e2 fe and $0xfffffffe,%edx 11f638: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11f63b: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11f640: 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;
11f644: 8b 55 e0 mov -0x20(%ebp),%edx 11f647: 8b 7d 14 mov 0x14(%ebp),%edi 11f64a: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11f64c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f650: 75 6e jne 11f6c0 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11f652: 8b 55 e0 mov -0x20(%ebp),%edx 11f655: 39 55 10 cmp %edx,0x10(%ebp)
11f658: 77 79 ja 11f6d3 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11f65a: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f65e: 74 31 je 11f691 <_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;
11f660: 8b 79 04 mov 0x4(%ecx),%edi 11f663: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11f666: 09 c7 or %eax,%edi 11f668: 89 79 04 mov %edi,0x4(%ecx)
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f66b: 8b 7d d4 mov -0x2c(%ebp),%edi 11f66e: 8b 7f 08 mov 0x8(%edi),%edi 11f671: 89 7d e4 mov %edi,-0x1c(%ebp) 11f674: 8b 55 d4 mov -0x2c(%ebp),%edx 11f677: 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;
11f67a: 8b 55 e4 mov -0x1c(%ebp),%edx 11f67d: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11f680: 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;
11f683: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11f688: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11f68b: 8b 7d d0 mov -0x30(%ebp),%edi 11f68e: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11f691: ff 75 10 pushl 0x10(%ebp) 11f694: 56 push %esi 11f695: 51 push %ecx 11f696: 53 push %ebx 11f697: e8 68 d1 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;
11f69c: 8b 50 04 mov 0x4(%eax),%edx 11f69f: 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;
11f6a2: 29 f0 sub %esi,%eax 11f6a4: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11f6a8: 8b 55 18 mov 0x18(%ebp),%edx 11f6ab: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11f6ad: ff 43 54 incl 0x54(%ebx) 11f6b0: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11f6b3: 31 c0 xor %eax,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f6b5: 8d 65 f4 lea -0xc(%ebp),%esp 11f6b8: 5b pop %ebx 11f6b9: 5e pop %esi 11f6ba: 5f pop %edi 11f6bb: c9 leave 11f6bc: c3 ret 11f6bd: 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;
11f6c0: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11f6c3: 8b 7d d0 mov -0x30(%ebp),%edi 11f6c6: 01 fa add %edi,%edx 11f6c8: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11f6cb: 8b 55 e0 mov -0x20(%ebp),%edx 11f6ce: 39 55 10 cmp %edx,0x10(%ebp)
11f6d1: 76 87 jbe 11f65a <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11f6d3: b8 01 00 00 00 mov $0x1,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f6d8: 8d 65 f4 lea -0xc(%ebp),%esp 11f6db: 5b pop %ebx 11f6dc: 5e pop %esi 11f6dd: 5f pop %edi 11f6de: c9 leave 11f6df: c3 ret
0011f6e0 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11f6e0: 55 push %ebp 11f6e1: 89 e5 mov %esp,%ebp 11f6e3: 56 push %esi 11f6e4: 53 push %ebx 11f6e5: 8b 5d 08 mov 0x8(%ebp),%ebx 11f6e8: 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);
11f6eb: 8d 4e f8 lea -0x8(%esi),%ecx 11f6ee: 89 f0 mov %esi,%eax 11f6f0: 31 d2 xor %edx,%edx 11f6f2: 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);
11f6f5: 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
11f6f7: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11f6fa: 39 c1 cmp %eax,%ecx
11f6fc: 72 07 jb 11f705 <_Heap_Size_of_alloc_area+0x25>
11f6fe: 8b 53 24 mov 0x24(%ebx),%edx 11f701: 39 d1 cmp %edx,%ecx
11f703: 76 07 jbe 11f70c <_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;
11f705: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11f707: 5b pop %ebx 11f708: 5e pop %esi 11f709: c9 leave 11f70a: c3 ret 11f70b: 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;
11f70c: 8b 59 04 mov 0x4(%ecx),%ebx 11f70f: 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);
11f712: 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;
11f714: 39 c8 cmp %ecx,%eax
11f716: 77 ed ja 11f705 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11f718: 39 ca cmp %ecx,%edx
11f71a: 72 e9 jb 11f705 <_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 )
11f71c: f6 41 04 01 testb $0x1,0x4(%ecx)
11f720: 74 e3 je 11f705 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11f722: 29 f1 sub %esi,%ecx 11f724: 8d 51 04 lea 0x4(%ecx),%edx 11f727: 8b 45 10 mov 0x10(%ebp),%eax 11f72a: 89 10 mov %edx,(%eax)
return true;
11f72c: b0 01 mov $0x1,%al
}
11f72e: 5b pop %ebx 11f72f: 5e pop %esi 11f730: c9 leave 11f731: 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 00 a5 12 00 03 cmpl $0x3,0x12a500
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 00 a5 12 00 03 cmpl $0x3,0x12a500
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 54 26 12 00 push $0x122654 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 70 27 12 00 push $0x122770 <== 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 0a 26 12 00 push $0x12260a 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 d9 25 12 00 push $0x1225d9 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 ec 25 12 00 push $0x1225ec 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 e8 26 12 00 push $0x1226e8 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 0c 27 12 00 push $0x12270c 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 a0 27 12 00 push $0x1227a0 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 24 28 12 00 push $0x122824 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 3b 26 12 00 push $0x12263b 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 88 29 12 00 push $0x122988 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 c9 24 12 00 movl $0x1224c9,-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 c9 24 12 00 mov $0x1224c9,%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 e4 28 12 00 push $0x1228e4 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 b0 29 12 00 push $0x1229b0 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 1c 29 12 00 push $0x12291c 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 a6 25 12 00 movl $0x1225a6,-0x38(%ebp) 10d687: e9 38 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c> 10d68c: b8 bf 25 12 00 mov $0x1225bf,%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 b5 25 12 00 movl $0x1225b5,-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 cf 25 12 00 mov $0x1225cf,%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 58 29 12 00 push $0x122958 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 40 27 12 00 push $0x122740 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 54 28 12 00 push $0x122854 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 84 28 12 00 push $0x122884 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 b0 28 12 00 push $0x1228b0 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 c0 27 12 00 push $0x1227c0 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 1f 26 12 00 push $0x12261f 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 f0 27 12 00 push $0x1227f0 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 e0 88 12 00 mov 0x1288e0,%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 <rtems_io_initialize>
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 e0 88 12 00 cmp %ebx,0x1288e0
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 38 3b 12 00 mov 0x123b38,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10bd23: a1 34 3b 12 00 mov 0x123b34,%eax 10bd28: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10bd2b: 8b 35 30 3b 12 00 mov 0x123b30,%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 e4 88 12 00 mov %eax,0x1288e4
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10bd4e: 89 35 e0 88 12 00 mov %esi,0x1288e0
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 e4 88 12 00 mov 0x1288e4,%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 e4 88 12 00 mov %ebx,0x1288e4
_IO_Number_of_drivers = number_of_drivers;
10bd9a: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd9d: a3 e0 88 12 00 mov %eax,0x1288e0
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 10 7f 12 00 mov %eax,0x127f10
_Internal_errors_What_happened.is_internal = is_internal;
10c90d: 88 15 14 7f 12 00 mov %dl,0x127f14
_Internal_errors_What_happened.the_error = the_error;
10c913: 89 1d 18 7f 12 00 mov %ebx,0x127f18
_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 00 80 12 00 05 movl $0x5,0x128000 <== 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 <rtems/score/object.h>
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 60 1c 12 00 mov 0x121c60(,%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 <rtems/score/object.h>
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 <== NOT EXECUTED
);
}
#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 08 7e 12 00 mov 0x127e08(,%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 78 3a 13 00 mov 0x133a78,%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 48 93 12 00 mov 0x129348,%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 38 b0 12 00 mov 0x12b038,%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 28 aa 12 00 mov 0x12aa28(,%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 08 7e 12 00 mov 0x127e08(,%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 a4 7a 12 00 movl $0x127aa4,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 <strncmp> 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 <strnlen> 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 <strncpy>
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 80 aa 12 00 push $0x12aa80 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 <pthread_cond_init>
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 90 a5 12 00 mov 0x12a590,%eax 10c2db: 48 dec %eax 10c2dc: a3 90 a5 12 00 mov %eax,0x12a590
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 <pthread_mutex_unlock>
_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 78 ab 12 00 mov 0x12ab78,%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 78 ab 12 00 mov 0x12ab78,%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 <pthread_mutex_lock>
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 <strnlen> 116391: 89 c6 mov %eax,%esi 116393: a1 50 0f 13 00 mov 0x130f50,%eax 116398: 40 inc %eax 116399: a3 50 0f 13 00 mov %eax,0x130f50
* 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 20 13 13 00 push $0x131320 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 <strncpy>
* * 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 3c 13 13 00 mov 0x13133c,%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 20 13 13 00 push $0x131320 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 20 13 13 00 push $0x131320 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 <strnlen> 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 20 13 13 00 push $0x131320 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 c0 14 13 00 push $0x1314c0 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 38 15 13 00 mov 0x131538,%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 38 15 13 00 mov 0x131538,%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 c0 14 13 00 push $0x1314c0 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 38 15 13 00 mov 0x131538,%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 d1 12 00 push $0x12d1a0 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 <pthread_mutex_init> 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 d1 12 00 push $0x12d1a0 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 <pthread_mutex_init> 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 d3 12 00 mov 0x12d378,%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 <strnlen> 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 b0 db 12 00 mov 0x12dbb0,%eax 114990: 40 inc %eax 114991: a3 b0 db 12 00 mov %eax,0x12dbb0
*/
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 00 df 12 00 push $0x12df00 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 1c df 12 00 mov 0x12df1c,%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 00 df 12 00 push $0x12df00 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 00 df 12 00 push $0x12df00 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 98 e1 12 00 mov 0x12e198,%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 98 e1 12 00 mov 0x12e198,%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 <rtems/posix/pthread.h>
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 30 91 12 00 mov 0x129130,%eax 110713: 48 dec %eax 110714: a3 30 91 12 00 mov %eax,0x129130
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 38 1c 12 00 mov $0x121c38,%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 f4 3a 12 00 movzbl 0x123af4,%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 18 84 12 00 mov 0x128418,%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 d8 60 12 00 mov 0x1260d8,%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 f4 4d 12 00 mov 0x124df4,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10ba03: a1 f0 4d 12 00 mov 0x124df0,%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 <pthread_attr_init>
(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 <pthread_attr_setinheritsched>
(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 <pthread_attr_setstacksize>
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 <pthread_create>
&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 f4 3a 12 00 movzbl 0x123af4,%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 3c 7f 12 00 movl $0x127f3c,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 f4 3a 12 00 movzbl 0x123af4,%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 <rtems/posix/threadsup.h>
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 5c a2 12 00 push $0x12a25c 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 <pthread_kill>
}
/* 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 88 84 12 00 mov 0x128488(%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 84 84 12 00 mov 0x128484(%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 18 84 12 00 mov 0x128418,%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 80 84 12 00 02 cmpl $0x2,0x128480(%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 18 84 12 00 mov 0x128418,%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 80 84 12 00 02 cmpl $0x2,0x128480(%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 88 86 12 00 and %eax,0x128688
}
_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 a4 86 12 00 lea 0x1286a4(%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 a0 86 12 00 cmp %ebx,0x1286a0(%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 88 86 12 00 and 0x128688,%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 80 84 12 00 02 cmpl $0x2,0x128480(%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 a0 86 12 00 lea 0x1286a0(%edx),%ecx 112dae: 8b 82 a0 86 12 00 mov 0x1286a0(%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 a0 86 12 00 mov %esi,0x1286a0(%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 08 86 12 00 mov 0x128608,%edx
the_node->next = tail;
112de8: c7 00 04 86 12 00 movl $0x128604,(%eax)
tail->previous = the_node;
112dee: a3 08 86 12 00 mov %eax,0x128608
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 <rtems/score/isr.h>
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 <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
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 <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
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
00124d1c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
124d1c: 55 push %ebp 124d1d: 89 e5 mov %esp,%ebp 124d1f: 57 push %edi 124d20: 56 push %esi 124d21: 53 push %ebx 124d22: 83 ec 0c sub $0xc,%esp 124d25: 8b 5d 08 mov 0x8(%ebp),%ebx 124d28: 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 ];
124d2b: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi 124d31: 8d 4a ff lea -0x1(%edx),%ecx 124d34: b8 01 00 00 00 mov $0x1,%eax 124d39: d3 e0 shl %cl,%eax
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
124d3b: 8b 4b 10 mov 0x10(%ebx),%ecx 124d3e: 89 cf mov %ecx,%edi 124d40: 81 e7 00 80 00 10 and $0x10008000,%edi 124d46: 81 ff 00 80 00 10 cmp $0x10008000,%edi
124d4c: 74 72 je 124dc0 <_POSIX_signals_Unblock_thread+0xa4>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
124d4e: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx 124d54: f7 d2 not %edx 124d56: 85 d0 test %edx,%eax
124d58: 74 5a je 124db4 <_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 ) ) {
124d5a: f7 c1 00 00 00 10 test $0x10000000,%ecx
124d60: 74 3a je 124d9c <_POSIX_signals_Unblock_thread+0x80>
the_thread->Wait.return_code = EINTR;
124d62: 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) )
124d69: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
124d6f: 0f 85 93 00 00 00 jne 124e08 <_POSIX_signals_Unblock_thread+0xec>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
124d75: 83 e1 08 and $0x8,%ecx
124d78: 74 3a je 124db4 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
124d7a: 83 ec 0c sub $0xc,%esp 124d7d: 8d 43 48 lea 0x48(%ebx),%eax 124d80: 50 push %eax 124d81: e8 da eb fe ff call 113960 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
124d86: 5a pop %edx 124d87: 59 pop %ecx 124d88: 68 f8 ff 03 10 push $0x1003fff8 124d8d: 53 push %ebx 124d8e: e8 09 d9 fe ff call 11269c <_Thread_Clear_state> 124d93: 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;
124d96: 31 c0 xor %eax,%eax 124d98: eb 1c jmp 124db6 <_POSIX_signals_Unblock_thread+0x9a> 124d9a: 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 ) {
124d9c: 85 c9 test %ecx,%ecx
124d9e: 75 14 jne 124db4 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124da0: a1 74 f1 12 00 mov 0x12f174,%eax 124da5: 85 c0 test %eax,%eax
124da7: 74 0b je 124db4 <_POSIX_signals_Unblock_thread+0x98>
124da9: 3b 1d 78 f1 12 00 cmp 0x12f178,%ebx
124daf: 74 7b je 124e2c <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN
124db1: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
}
return false;
124db4: 31 c0 xor %eax,%eax
}
124db6: 8d 65 f4 lea -0xc(%ebp),%esp 124db9: 5b pop %ebx 124dba: 5e pop %esi 124dbb: 5f pop %edi 124dbc: c9 leave 124dbd: c3 ret 124dbe: 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) ) {
124dc0: 85 43 30 test %eax,0x30(%ebx)
124dc3: 74 33 je 124df8 <_POSIX_signals_Unblock_thread+0xdc>
the_thread->Wait.return_code = EINTR;
124dc5: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
124dcc: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
124dcf: 8b 75 10 mov 0x10(%ebp),%esi 124dd2: 85 f6 test %esi,%esi
124dd4: 74 42 je 124e18 <_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;
124dd6: b9 03 00 00 00 mov $0x3,%ecx 124ddb: 89 c7 mov %eax,%edi 124ddd: 8b 75 10 mov 0x10(%ebp),%esi 124de0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
124de2: 83 ec 0c sub $0xc,%esp 124de5: 53 push %ebx 124de6: e8 1d e3 fe ff call 113108 <_Thread_queue_Extract_with_proxy>
return true;
124deb: 83 c4 10 add $0x10,%esp 124dee: b0 01 mov $0x1,%al
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
124df0: 8d 65 f4 lea -0xc(%ebp),%esp 124df3: 5b pop %ebx 124df4: 5e pop %esi 124df5: 5f pop %edi 124df6: c9 leave 124df7: 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) ) {
124df8: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx 124dfe: f7 d1 not %ecx 124e00: 85 c8 test %ecx,%eax
124e02: 75 c1 jne 124dc5 <_POSIX_signals_Unblock_thread+0xa9>
124e04: eb ae jmp 124db4 <_POSIX_signals_Unblock_thread+0x98> 124e06: 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 );
124e08: 83 ec 0c sub $0xc,%esp 124e0b: 53 push %ebx 124e0c: e8 f7 e2 fe ff call 113108 <_Thread_queue_Extract_with_proxy> 124e11: 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;
124e14: 31 c0 xor %eax,%eax 124e16: eb 9e jmp 124db6 <_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;
124e18: 89 10 mov %edx,(%eax)
the_info->si_code = SI_USER;
124e1a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
124e21: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 124e28: eb b8 jmp 124de2 <_POSIX_signals_Unblock_thread+0xc6> 124e2a: 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;
124e2c: c6 05 84 f1 12 00 01 movb $0x1,0x12f184
}
}
return false;
124e33: 31 c0 xor %eax,%eax 124e35: e9 7c ff ff ff jmp 124db6 <_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 fc 88 12 00 pushl 0x1288fc 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 fc 88 12 00 pushl 0x1288fc 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 70 f3 12 00 mov 0x12f370,%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 5c f4 12 00 pushl 0x12f45c 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 5c f4 12 00 pushl 0x12f45c 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 c4 3a 12 00 01 cmpb $0x1,0x123ac4 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 c4 3a 12 00 00 cmpb $0x0,0x123ac4
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 44 3b 12 00 mov 0x123b44,%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 ec 3a 12 00 mov 0x123aec,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10ba8f: 8b 3d e8 3a 12 00 mov 0x123ae8,%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 <rtems_task_create>
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 <rtems_task_start>
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 98 b7 12 00 cmp %esi,0x12b798
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 a8 b2 12 00 push $0x12b2a8 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 c0 b0 12 00 push $0x12b0c0 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 b0 b1 12 00 mov 0x12b1b0,%eax 10caf0: 48 dec %eax 10caf1: a3 b0 b1 12 00 mov %eax,0x12b1b0
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 bc b2 12 00 push $0x12b2bc 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 1c 84 12 00 cmp 0x12841c,%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 18 84 12 00 cmp 0x128418,%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 24 84 12 00 01 movb $0x1,0x128424 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 40 84 12 00 mov 0x128440,%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 60 84 12 mov 0x128460(%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 1c 84 12 00 mov %ecx,0x12841c 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 40 84 12 00 mov 0x128440,%dx 1116be: 23 51 0c and 0xc(%ecx),%edx 1116c1: 66 89 15 40 84 12 00 mov %dx,0x128440 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 40 84 12 00 mov 0x128440,%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 60 84 12 mov 0x128460(%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 1c 84 12 00 mov %edx,0x12841c 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 1c 84 12 00 mov %edx,0x12841c <== 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 40 84 12 00 mov 0x128440,%cx 10d336: 0b 4a 08 or 0x8(%edx),%ecx 10d339: 66 89 0d 40 84 12 00 mov %cx,0x128440
_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 1c 84 12 00 mov 0x12841c,%ecx 10d35b: 3b 51 14 cmp 0x14(%ecx),%edx
10d35e: 73 17 jae 10d377 <_Scheduler_priority_Unblock+0x5f>
_Thread_Heir = the_thread;
10d360: a3 1c 84 12 00 mov %eax,0x12841c
if ( _Thread_Executing->is_preemptible ||
10d365: a1 18 84 12 00 mov 0x128418,%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 24 84 12 00 01 movb $0x1,0x128424
_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 24 84 12 00 01 movb $0x1,0x128424 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 18 84 12 00 mov 0x128418,%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 1c 84 12 00 cmp 0x12841c,%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 24 84 12 00 01 movb $0x1,0x128424
_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 1c 84 12 00 mov %eax,0x12841c 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 1c 84 12 00 cmp 0x12841c,%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 50 34 13 00 mov 0x133450,%eax 10daef: 40 inc %eax 10daf0: a3 50 34 13 00 mov %eax,0x133450
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10daf5: a1 24 35 13 00 mov 0x133524,%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 50 35 13 00 push $0x133550 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 24 35 13 00 mov %eax,0x133524 10db1a: 8b 43 04 mov 0x4(%ebx),%eax 10db1d: a3 28 35 13 00 mov %eax,0x133528
_TOD_Is_set = true;
10db22: c6 05 64 34 13 00 01 movb $0x1,0x133464
_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 50 35 13 00 push $0x133550 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 a0 43 12 movzwl 0x1243a0(%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 d4 43 12 movzwl 0x1243d4(%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 ba 43 12 movzwl 0x1243ba(%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 cc 72 12 00 mov 0x1272cc,%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 14 44 12 00 mov 0x124414(,%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 e0 43 12 00 mov 0x1243e0(,%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 40 84 12 00 mov 0x128440,%dx 10d4d1: 0b 50 08 or 0x8(%eax),%edx 10d4d4: 66 89 15 40 84 12 00 mov %dx,0x128440
_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 e0 7e 12 00 push $0x127ee0 10d4f4: ff 15 e4 7e 12 00 call *0x127ee4
* 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 18 84 12 00 mov 0x128418,%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 1c 84 12 00 cmp 0x12841c,%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 24 84 12 00 01 movb $0x1,0x128424
_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 40 84 12 00 mov 0x128440,%dx 10d553: 0b 50 08 or 0x8(%eax),%edx 10d556: 66 89 15 40 84 12 00 mov %dx,0x128440
_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 e0 7e 12 00 push $0x127ee0 10d5a9: ff 15 f0 7e 12 00 call *0x127ef0 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 30 7e 12 00 mov 0x127e30,%eax 10d76f: 48 dec %eax 10d770: a3 30 7e 12 00 mov %eax,0x127e30 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 18 84 12 00 mov 0x128418,%ebx
_ISR_Disable( level );
10d78b: 9c pushf 10d78c: fa cli 10d78d: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10d78e: 8a 15 24 84 12 00 mov 0x128424,%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 1c 84 12 00 mov 0x12841c,%esi
_Thread_Dispatch_disable_level = 1;
10d7a2: c7 05 30 7e 12 00 01 movl $0x1,0x127e30
10d7a9: 00 00 00
_Thread_Dispatch_necessary = false;
10d7ac: c6 05 24 84 12 00 00 movb $0x0,0x128424
_Thread_Executing = heir;
10d7b3: 89 35 18 84 12 00 mov %esi,0x128418
/*
* 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 28 7f 12 00 push $0x127f28 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 28 7f 12 00 mov %eax,0x127f28 10d806: 89 15 2c 7f 12 00 mov %edx,0x127f2c
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10d80c: a1 00 7f 12 00 mov 0x127f00,%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 c0 7e 12 00 mov 0x127ec0,%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 c0 7e 12 00 mov %ebx,0x127ec0 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 18 84 12 00 mov 0x128418,%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 24 84 12 00 mov 0x128424,%dl 10d899: 84 d2 test %dl,%dl
10d89b: 74 3b je 10d8d8 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d89d: 8b 35 1c 84 12 00 mov 0x12841c,%esi
_Thread_Dispatch_disable_level = 1;
10d8a3: c7 05 30 7e 12 00 01 movl $0x1,0x127e30
10d8aa: 00 00 00
_Thread_Dispatch_necessary = false;
10d8ad: c6 05 24 84 12 00 00 movb $0x0,0x128424
_Thread_Executing = heir;
10d8b4: 89 35 18 84 12 00 mov %esi,0x128418
/*
* 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 00 7e 12 00 mov 0x127e00,%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 30 7e 12 00 00 movl $0x0,0x127e30
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 08 7e 12 00 mov 0x127e08(,%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 30 7e 12 00 mov 0x127e30,%eax 10d975: 40 inc %eax 10d976: a3 30 7e 12 00 mov %eax,0x127e30
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 18 84 12 00 mov 0x128418,%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 18 84 12 00 mov 0x128418,%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 ac 7a 12 00 mov 0x127aac,%al 113169: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
11316c: c6 05 ac 7a 12 00 01 movb $0x1,0x127aac
#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 c0 7e 12 00 mov 0x127ec0,%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 c0 7e 12 00 mov %ebx,0x127ec0
/* * 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 4b c7 00 00 call 11f930 <__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 0c 7f 12 00 mov 0x127f0c,%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 00 7e 12 00 mov 0x127e00,%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 e0 7e 12 00 push $0x127ee0 10da8d: ff 15 f4 7e 12 00 call *0x127ef4 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 0c 7f 12 00 mov 0x127f0c,%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 a0 b8 12 00 push $0x12b8a0 11149d: ff 15 b0 b8 12 00 call *0x12b8b0 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 f0 3a 12 00 mov 0x123af0,%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 24 3b 12 00 mov 0x123b24,%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 28 3b 12 00 mov 0x123b28,%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 e0 7e 12 00 push $0x127ee0 1119ac: ff 15 ec 7e 12 00 call *0x127eec
_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 18 84 12 00 mov 0x128418,%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 e0 7e 12 00 push $0x127ee0 10e3c7: ff 15 e8 7e 12 00 call *0x127ee8
* 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 00 7e 12 00 mov 0x127e00,%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>
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 30 7e 12 00 mov 0x127e30,%eax 10e126: 48 dec %eax 10e127: a3 30 7e 12 00 mov %eax,0x127e30 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 44 2c 14 00 mov 0x142c44,%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 a4 2b 14 00 mov 0x142ba4,%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 d0 2a 14 00 mov 0x142ad0,%eax 118f47: 40 inc %eax 118f48: a3 d0 2a 14 00 mov %eax,0x142ad0
/*
* 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 d0 2a 14 00 mov 0x142ad0,%edx 118fbe: 42 inc %edx 118fbf: 89 15 d0 2a 14 00 mov %edx,0x142ad0
* 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 a4 2b 14 00 mov 0x142ba4,%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 44 2c 14 00 mov 0x142c44,%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 f9 12 01 00 call 120f7c <__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 e4 12 01 00 call 120f7c <__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 de 13 01 00 call 12108c <__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
00120060 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
120060: 55 push %ebp 120061: 89 e5 mov %esp,%ebp 120063: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
120066: 85 c0 test %eax,%eax
120068: 74 1a je 120084 <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
12006a: 8b 10 mov (%eax),%edx 12006c: 85 d2 test %edx,%edx
12006e: 78 14 js 120084 <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
120070: 8b 40 04 mov 0x4(%eax),%eax 120073: 85 c0 test %eax,%eax
120075: 78 0d js 120084 <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
120077: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 12007c: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
12007f: c9 leave 120080: c3 ret 120081: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
120084: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
120086: c9 leave 120087: 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 <TOD_TICKS_PER_SECOND_method> 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 0c 3b 12 00 mov 0x123b0c,%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 94 80 12 00 mov 0x128094,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5ac: 81 fb 8c 80 12 00 cmp $0x12808c,%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 8c 80 12 00 cmp $0x12808c,%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 <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
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 3c 3b 12 00 mov 0x123b3c,%eax 10e466: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10e469: 8b 35 40 3b 12 00 mov 0x123b40,%esi
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e46f: c7 05 8c 80 12 00 90 movl $0x128090,0x12808c
10e476: 80 12 00 head->previous = NULL;
10e479: c7 05 90 80 12 00 00 movl $0x0,0x128090
10e480: 00 00 00 tail->previous = head;
10e483: c7 05 94 80 12 00 8c movl $0x12808c,0x128094
10e48a: 80 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e48d: c7 05 34 7e 12 00 38 movl $0x127e38,0x127e34
10e494: 7e 12 00 head->previous = NULL;
10e497: c7 05 38 7e 12 00 00 movl $0x0,0x127e38
10e49e: 00 00 00 tail->previous = head;
10e4a1: c7 05 3c 7e 12 00 34 movl $0x127e34,0x127e3c
10e4a8: 7e 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 <rtems/score/userext.h>
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 <rtems/score/userext.h>
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 8c 80 12 00 mov 0x12808c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e52a: 81 fb 90 80 12 00 cmp $0x128090,%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 90 80 12 00 cmp $0x128090,%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 <rtems/score/userext.h>
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 8c 80 12 00 mov 0x12808c,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e5f2: 81 fb 90 80 12 00 cmp $0x128090,%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 18 84 12 00 pushl 0x128418 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 90 80 12 00 cmp $0x128090,%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 <rtems/score/userext.h>
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 94 80 12 00 mov 0x128094,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e646: 81 fb 8c 80 12 00 cmp $0x12808c,%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 18 84 12 00 pushl 0x128418 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 8c 80 12 00 cmp $0x12808c,%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 94 80 12 00 mov 0x128094,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e566: 81 fb 8c 80 12 00 cmp $0x12808c,%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 8c 80 12 00 cmp $0x12808c,%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 <rtems/score/userext.h>
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 ac a3 12 00 mov 0x12a3ac,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f24a: 81 fb b0 a3 12 00 cmp $0x12a3b0,%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 38 a7 12 00 pushl 0x12a738 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 b0 a3 12 00 cmp $0x12a3b0,%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 <rtems/score/userext.h>
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 8c 80 12 00 mov 0x12808c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e686: 81 fb 90 80 12 00 cmp $0x128090,%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 18 84 12 00 pushl 0x128418 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 90 80 12 00 cmp $0x128090,%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 34 7e 12 00 mov 0x127e34,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e6cd: 81 fb 38 7e 12 00 cmp $0x127e38,%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 38 7e 12 00 cmp $0x127e38,%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 14 84 12 00 mov 0x128414,%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 a0 7f 12 00 mov 0x127fa0,%eax 10e726: 40 inc %eax 10e727: a3 a0 7f 12 00 mov %eax,0x127fa0
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 20 7f 12 00 mov 0x127f20,%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 20 7f 12 00 mov %edi,0x127f20
_Watchdog_Sync_count--;
10e778: a1 a0 7f 12 00 mov 0x127fa0,%eax 10e77d: 48 dec %eax 10e77e: a3 a0 7f 12 00 mov %eax,0x127fa0
_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 a4 7f 12 00 mov 0x127fa4,%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 20 7f 12 00 mov %edi,0x127f20
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 a4 7f 12 00 mov 0x127fa4,%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 a0 7f 12 00 mov 0x127fa0,%esi 10e87c: 85 f6 test %esi,%esi
10e87e: 74 0c je 10e88c <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10e880: 8b 35 14 84 12 00 mov 0x128414,%esi 10e886: 89 35 20 7f 12 00 mov %esi,0x127f20
{
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 63 35 12 00 mov $0x123563,%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 c6 3f 12 00 push $0x123fc6 10fc2d: e8 66 9e ff ff call 109a98 <printk> 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 29 3e 12 00 mov $0x123e29,%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 90 3f 12 00 push $0x123f90 10fb97: e8 fc 9e ff ff call 109a98 <printk>
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 a7 3f 12 00 push $0x123fa7 10fbc5: e8 ce 9e ff ff call 109a98 <printk> 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 b6 3f 12 00 push $0x123fb6 10fbe1: e8 b2 9e ff ff call 109a98 <printk> 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 00 3b 12 00 mov 0x123b00,%ebx
uintptr_t size = Configuration.work_space_size;
10e91b: 8b 15 04 3b 12 00 mov 0x123b04,%edx
if ( Configuration.do_zero_of_workspace )
10e921: 80 3d 2c 3b 12 00 00 cmpb $0x0,0x123b2c
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 60 7e 12 00 push $0x127e60 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 <adjtime>:
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 <adjtime+0x108>
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 <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
10b5fa: 85 f6 test %esi,%esi
10b5fc: 74 10 je 10b60e <adjtime+0x3a>
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 2c 42 12 00 cmp 0x12422c,%eax
10b62e: 73 0c jae 10b63c <adjtime+0x68>
/* 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 90 86 12 00 mov 0x128690,%eax 10b641: 40 inc %eax 10b642: a3 90 86 12 00 mov %eax,0x128690
* 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 <adjtime+0xbb>
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 <adjtime+0xa8> <== 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 <adjtime+0xdb> <== 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 <adjtime+0xc8>
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 <adjtime+0x5c>
*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 <adjtime+0x5e>
0010bd14 <aio_cancel>:
* 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 aa 12 00 push $0x12aa80 10bd28: e8 bf 11 00 00 call 10ceec <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10bd2d: 5a pop %edx 10bd2e: 59 pop %ecx 10bd2f: 6a 01 push $0x1 10bd31: 56 push %esi 10bd32: e8 e1 6a 00 00 call 112818 <fcntl> 10bd37: 83 c4 10 add $0x10,%esp 10bd3a: 85 c0 test %eax,%eax
10bd3c: 0f 88 9b 01 00 00 js 10bedd <aio_cancel+0x1c9>
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 ea 00 00 00 je 10be34 <aio_cancel+0x120>
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 b8 00 00 00 jne 10be0c <aio_cancel+0xf8>
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: 56 push %esi 10bd55: 6a 00 push $0x0 10bd57: 57 push %edi 10bd58: 68 c8 aa 12 00 push $0x12aac8 10bd5d: e8 9e 03 00 00 call 10c100 <rtems_aio_search_fd> 10bd62: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10bd64: 83 c4 10 add $0x10,%esp 10bd67: 85 c0 test %eax,%eax
10bd69: 74 3d je 10bda8 <aio_cancel+0x94>
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10bd6b: 8d 78 1c lea 0x1c(%eax),%edi 10bd6e: 83 ec 0c sub $0xc,%esp 10bd71: 57 push %edi 10bd72: e8 75 11 00 00 call 10ceec <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bd77: 58 pop %eax 10bd78: 5a pop %edx 10bd79: 53 push %ebx 10bd7a: 83 c6 08 add $0x8,%esi 10bd7d: 56 push %esi 10bd7e: e8 5d 07 00 00 call 10c4e0 <rtems_aio_remove_req> 10bd83: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10bd85: 89 3c 24 mov %edi,(%esp) 10bd88: e8 e7 11 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10bd8d: c7 04 24 80 aa 12 00 movl $0x12aa80,(%esp) 10bd94: e8 db 11 00 00 call 10cf74 <pthread_mutex_unlock>
return result;
10bd99: 83 c4 10 add $0x10,%esp
} return AIO_ALLDONE; }
10bd9c: 89 d8 mov %ebx,%eax 10bd9e: 8d 65 f4 lea -0xc(%ebp),%esp 10bda1: 5b pop %ebx 10bda2: 5e pop %esi 10bda3: 5f pop %edi 10bda4: c9 leave 10bda5: c3 ret 10bda6: 66 90 xchg %ax,%ax
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)) {
10bda8: 81 3d d4 aa 12 00 d8 cmpl $0x12aad8,0x12aad4
10bdaf: aa 12 00
10bdb2: 74 40 je 10bdf4 <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10bdb4: 51 push %ecx 10bdb5: 6a 00 push $0x0 10bdb7: 57 push %edi 10bdb8: 68 d4 aa 12 00 push $0x12aad4 10bdbd: e8 3e 03 00 00 call 10c100 <rtems_aio_search_fd>
if (r_chain == NULL) {
10bdc2: 83 c4 10 add $0x10,%esp 10bdc5: 85 c0 test %eax,%eax
10bdc7: 74 43 je 10be0c <aio_cancel+0xf8>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bdc9: 83 ec 08 sub $0x8,%esp 10bdcc: 53 push %ebx 10bdcd: 83 c0 08 add $0x8,%eax 10bdd0: 50 push %eax 10bdd1: e8 0a 07 00 00 call 10c4e0 <rtems_aio_remove_req> 10bdd6: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
10bdd8: c7 04 24 80 aa 12 00 movl $0x12aa80,(%esp) 10bddf: e8 90 11 00 00 call 10cf74 <pthread_mutex_unlock>
return result;
10bde4: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
10bde7: 89 d8 mov %ebx,%eax 10bde9: 8d 65 f4 lea -0xc(%ebp),%esp 10bdec: 5b pop %ebx 10bded: 5e pop %esi 10bdee: 5f pop %edi 10bdef: c9 leave 10bdf0: c3 ret 10bdf1: 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);
10bdf4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdf7: 68 80 aa 12 00 push $0x12aa80 <== NOT EXECUTED 10bdfc: e8 73 11 00 00 call 10cf74 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10be01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be04: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10be09: eb 91 jmp 10bd9c <aio_cancel+0x88> <== NOT EXECUTED 10be0b: 90 nop <== NOT EXECUTED
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);
10be0c: 83 ec 0c sub $0xc,%esp 10be0f: 68 80 aa 12 00 push $0x12aa80 10be14: e8 5b 11 00 00 call 10cf74 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10be19: e8 2e 9e 00 00 call 115c4c <__errno> 10be1e: c7 00 16 00 00 00 movl $0x16,(%eax) 10be24: 83 c4 10 add $0x10,%esp 10be27: bb ff ff ff ff mov $0xffffffff,%ebx 10be2c: e9 6b ff ff ff jmp 10bd9c <aio_cancel+0x88> 10be31: 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);
10be34: 50 push %eax 10be35: 6a 00 push $0x0 10be37: 56 push %esi 10be38: 68 c8 aa 12 00 push $0x12aac8 10be3d: e8 be 02 00 00 call 10c100 <rtems_aio_search_fd> 10be42: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10be44: 83 c4 10 add $0x10,%esp 10be47: 85 c0 test %eax,%eax
10be49: 74 3d je 10be88 <aio_cancel+0x174>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10be4b: 8d 70 1c lea 0x1c(%eax),%esi 10be4e: 83 ec 0c sub $0xc,%esp 10be51: 56 push %esi 10be52: e8 95 10 00 00 call 10ceec <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10be57: 89 1c 24 mov %ebx,(%esp) 10be5a: e8 61 2a 00 00 call 10e8c0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10be5f: 89 1c 24 mov %ebx,(%esp) 10be62: e8 29 06 00 00 call 10c490 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10be67: 89 34 24 mov %esi,(%esp) 10be6a: e8 05 11 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10be6f: c7 04 24 80 aa 12 00 movl $0x12aa80,(%esp) 10be76: e8 f9 10 00 00 call 10cf74 <pthread_mutex_unlock>
return AIO_CANCELED;
10be7b: 83 c4 10 add $0x10,%esp 10be7e: 31 db xor %ebx,%ebx 10be80: e9 17 ff ff ff jmp 10bd9c <aio_cancel+0x88> 10be85: 8d 76 00 lea 0x0(%esi),%esi
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)) {
10be88: 81 3d d4 aa 12 00 d8 cmpl $0x12aad8,0x12aad4
10be8f: aa 12 00
10be92: 0f 84 5c ff ff ff je 10bdf4 <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10be98: 57 push %edi 10be99: 6a 00 push $0x0 10be9b: 56 push %esi 10be9c: 68 d4 aa 12 00 push $0x12aad4 10bea1: e8 5a 02 00 00 call 10c100 <rtems_aio_search_fd> 10bea6: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10bea8: 83 c4 10 add $0x10,%esp 10beab: 85 c0 test %eax,%eax
10bead: 74 53 je 10bf02 <aio_cancel+0x1ee>
10beaf: 83 ec 0c sub $0xc,%esp 10beb2: 50 push %eax 10beb3: e8 08 2a 00 00 call 10e8c0 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10beb8: 89 1c 24 mov %ebx,(%esp) 10bebb: e8 d0 05 00 00 call 10c490 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10bec0: 8d 73 1c lea 0x1c(%ebx),%esi 10bec3: 89 34 24 mov %esi,(%esp) 10bec6: e8 b5 0d 00 00 call 10cc80 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10becb: 89 34 24 mov %esi,(%esp) 10bece: e8 69 0a 00 00 call 10c93c <pthread_cond_destroy>
free (r_chain);
10bed3: 89 1c 24 mov %ebx,(%esp) 10bed6: e8 59 cc ff ff call 108b34 <free> 10bedb: eb 92 jmp 10be6f <aio_cancel+0x15b>
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
10bedd: 83 ec 0c sub $0xc,%esp 10bee0: 68 80 aa 12 00 push $0x12aa80 10bee5: e8 8a 10 00 00 call 10cf74 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10beea: e8 5d 9d 00 00 call 115c4c <__errno> 10beef: c7 00 09 00 00 00 movl $0x9,(%eax) 10bef5: 83 c4 10 add $0x10,%esp 10bef8: bb ff ff ff ff mov $0xffffffff,%ebx 10befd: e9 9a fe ff ff jmp 10bd9c <aio_cancel+0x88>
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);
10bf02: 83 ec 0c sub $0xc,%esp 10bf05: 68 80 aa 12 00 push $0x12aa80 10bf0a: e8 65 10 00 00 call 10cf74 <pthread_mutex_unlock>
return AIO_ALLDONE;
10bf0f: 83 c4 10 add $0x10,%esp 10bf12: b3 02 mov $0x2,%bl 10bf14: e9 83 fe ff ff jmp 10bd9c <aio_cancel+0x88>
0010bf28 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10bf28: 55 push %ebp 10bf29: 89 e5 mov %esp,%ebp 10bf2b: 53 push %ebx 10bf2c: 83 ec 04 sub $0x4,%esp 10bf2f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10bf32: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10bf39: 75 41 jne 10bf7c <aio_fsync+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10bf3b: 83 ec 08 sub $0x8,%esp 10bf3e: 6a 03 push $0x3 10bf40: ff 33 pushl (%ebx) 10bf42: e8 d1 68 00 00 call 112818 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10bf47: 83 e0 03 and $0x3,%eax 10bf4a: 48 dec %eax 10bf4b: 83 c4 10 add $0x10,%esp 10bf4e: 83 f8 01 cmp $0x1,%eax
10bf51: 77 4d ja 10bfa0 <aio_fsync+0x78>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10bf53: 83 ec 0c sub $0xc,%esp 10bf56: 6a 18 push $0x18 10bf58: e8 eb d0 ff ff call 109048 <malloc>
if (req == NULL)
10bf5d: 83 c4 10 add $0x10,%esp 10bf60: 85 c0 test %eax,%eax
10bf62: 74 57 je 10bfbb <aio_fsync+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10bf64: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10bf67: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10bf6e: 89 45 08 mov %eax,0x8(%ebp)
}
10bf71: 8b 5d fc mov -0x4(%ebp),%ebx 10bf74: 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);
10bf75: e9 d6 05 00 00 jmp 10c550 <rtems_aio_enqueue> 10bf7a: 66 90 xchg %ax,%ax
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10bf7c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10bf83: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf8a: e8 bd 9c 00 00 call 115c4c <__errno> 10bf8f: c7 00 16 00 00 00 movl $0x16,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
10bf95: b8 ff ff ff ff mov $0xffffffff,%eax 10bf9a: 8b 5d fc mov -0x4(%ebp),%ebx 10bf9d: c9 leave 10bf9e: c3 ret 10bf9f: 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);
10bfa0: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10bfa7: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bfae: e8 99 9c 00 00 call 115c4c <__errno> 10bfb3: c7 00 09 00 00 00 movl $0x9,(%eax) 10bfb9: eb da jmp 10bf95 <aio_fsync+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10bfbb: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10bfc2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10bfc9: e8 7e 9c 00 00 call 115c4c <__errno> <== NOT EXECUTED 10bfce: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10bfd4: eb bf jmp 10bf95 <aio_fsync+0x6d> <== NOT EXECUTED
0010c760 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10c760: 55 push %ebp 10c761: 89 e5 mov %esp,%ebp 10c763: 53 push %ebx 10c764: 83 ec 0c sub $0xc,%esp 10c767: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c76a: 6a 03 push $0x3 10c76c: ff 33 pushl (%ebx) 10c76e: e8 a5 60 00 00 call 112818 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c773: 83 c4 10 add $0x10,%esp 10c776: 83 e0 03 and $0x3,%eax
10c779: 74 05 je 10c780 <aio_read+0x20> <== NEVER TAKEN
10c77b: 83 f8 02 cmp $0x2,%eax
10c77e: 75 38 jne 10c7b8 <aio_read+0x58>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c780: 8b 53 14 mov 0x14(%ebx),%edx 10c783: 85 d2 test %edx,%edx
10c785: 75 55 jne 10c7dc <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c787: 8b 43 08 mov 0x8(%ebx),%eax 10c78a: 85 c0 test %eax,%eax
10c78c: 78 4e js 10c7dc <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c78e: 83 ec 0c sub $0xc,%esp 10c791: 6a 18 push $0x18 10c793: e8 b0 c8 ff ff call 109048 <malloc>
if (req == NULL)
10c798: 83 c4 10 add $0x10,%esp 10c79b: 85 c0 test %eax,%eax
10c79d: 74 58 je 10c7f7 <aio_read+0x97> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c79f: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10c7a2: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c7a9: 89 45 08 mov %eax,0x8(%ebp)
}
10c7ac: 8b 5d fc mov -0x4(%ebp),%ebx 10c7af: 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);
10c7b0: e9 9b fd ff ff jmp 10c550 <rtems_aio_enqueue> 10c7b5: 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);
10c7b8: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c7bf: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c7c6: e8 81 94 00 00 call 115c4c <__errno> 10c7cb: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
10c7d1: b8 ff ff ff ff mov $0xffffffff,%eax 10c7d6: 8b 5d fc mov -0x4(%ebp),%ebx 10c7d9: c9 leave 10c7da: c3 ret 10c7db: 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);
10c7dc: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c7e3: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c7ea: e8 5d 94 00 00 call 115c4c <__errno> 10c7ef: c7 00 16 00 00 00 movl $0x16,(%eax) 10c7f5: eb da jmp 10c7d1 <aio_read+0x71>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c7f7: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c7fe: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c805: e8 42 94 00 00 call 115c4c <__errno> <== NOT EXECUTED 10c80a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c810: eb bf jmp 10c7d1 <aio_read+0x71> <== NOT EXECUTED
0010c820 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10c820: 55 push %ebp 10c821: 89 e5 mov %esp,%ebp 10c823: 53 push %ebx 10c824: 83 ec 0c sub $0xc,%esp 10c827: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c82a: 6a 03 push $0x3 10c82c: ff 33 pushl (%ebx) 10c82e: e8 e5 5f 00 00 call 112818 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c833: 83 e0 03 and $0x3,%eax 10c836: 48 dec %eax 10c837: 83 c4 10 add $0x10,%esp 10c83a: 83 f8 01 cmp $0x1,%eax
10c83d: 77 35 ja 10c874 <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c83f: 8b 53 14 mov 0x14(%ebx),%edx 10c842: 85 d2 test %edx,%edx
10c844: 75 52 jne 10c898 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c846: 8b 43 08 mov 0x8(%ebx),%eax 10c849: 85 c0 test %eax,%eax
10c84b: 78 4b js 10c898 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c84d: 83 ec 0c sub $0xc,%esp 10c850: 6a 18 push $0x18 10c852: e8 f1 c7 ff ff call 109048 <malloc>
if (req == NULL)
10c857: 83 c4 10 add $0x10,%esp 10c85a: 85 c0 test %eax,%eax
10c85c: 74 55 je 10c8b3 <aio_write+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c85e: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10c861: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c868: 89 45 08 mov %eax,0x8(%ebp)
}
10c86b: 8b 5d fc mov -0x4(%ebp),%ebx 10c86e: 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);
10c86f: e9 dc fc ff ff jmp 10c550 <rtems_aio_enqueue>
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);
10c874: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c87b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c882: e8 c5 93 00 00 call 115c4c <__errno> 10c887: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
10c88d: b8 ff ff ff ff mov $0xffffffff,%eax 10c892: 8b 5d fc mov -0x4(%ebp),%ebx 10c895: c9 leave 10c896: c3 ret 10c897: 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);
10c898: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c89f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c8a6: e8 a1 93 00 00 call 115c4c <__errno> 10c8ab: c7 00 16 00 00 00 movl $0x16,(%eax) 10c8b1: eb da jmp 10c88d <aio_write+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c8b3: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c8ba: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c8c1: e8 86 93 00 00 call 115c4c <__errno> <== NOT EXECUTED 10c8c6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c8cc: eb bf jmp 10c88d <aio_write+0x6d> <== NOT EXECUTED
0010b454 <clock_gettime>:
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 <clock_gettime+0x24>
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 <clock_gettime+0x5c>
_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 <clock_gettime+0x4c> <== 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 <clock_gettime+0x4c>
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 <clock_gettime+0x38>
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 <clock_settime>:
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 <clock_settime+0x1f> <== 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 <clock_settime+0x34>
_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 <clock_settime+0x5c>
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 <clock_settime+0x5c>
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 <clock_settime+0x1f>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4fc: a1 30 9e 12 00 mov 0x129e30,%eax 10b501: 40 inc %eax 10b502: a3 30 9e 12 00 mov %eax,0x129e30
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 <getitimer>:
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 <getitimer+0x3c>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10b241: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b245: 76 15 jbe 10b25c <getitimer+0x28>
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 <getitimer+0x1e>
00124a68 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
124a68: 55 push %ebp 124a69: 89 e5 mov %esp,%ebp 124a6b: 57 push %edi 124a6c: 56 push %esi 124a6d: 53 push %ebx 124a6e: 83 ec 3c sub $0x3c,%esp 124a71: 8b 75 0c mov 0xc(%ebp),%esi 124a74: 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() )
124a77: e8 00 fd ff ff call 12477c <getpid> 124a7c: 3b 45 08 cmp 0x8(%ebp),%eax
124a7f: 0f 85 3f 02 00 00 jne 124cc4 <killinfo+0x25c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
124a85: 85 f6 test %esi,%esi
124a87: 0f 84 4c 02 00 00 je 124cd9 <killinfo+0x271>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
124a8d: 8d 4e ff lea -0x1(%esi),%ecx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
124a90: 83 f9 1f cmp $0x1f,%ecx
124a93: 0f 87 40 02 00 00 ja 124cd9 <killinfo+0x271>
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 )
124a99: 8d 04 76 lea (%esi,%esi,2),%eax 124a9c: 83 3c 85 e8 f1 12 00 cmpl $0x1,0x12f1e8(,%eax,4)
124aa3: 01 124aa4: 0f 84 e6 01 00 00 je 124c90 <killinfo+0x228> /* * 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 ) )
124aaa: 83 fe 08 cmp $0x8,%esi
124aad: 0f 84 c9 00 00 00 je 124b7c <killinfo+0x114>
124ab3: 83 fe 04 cmp $0x4,%esi
124ab6: 0f 84 c0 00 00 00 je 124b7c <killinfo+0x114>
124abc: 83 fe 0b cmp $0xb,%esi
124abf: 0f 84 b7 00 00 00 je 124b7c <killinfo+0x114>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124ac5: bb 01 00 00 00 mov $0x1,%ebx 124aca: d3 e3 shl %cl,%ebx
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
124acc: 89 75 dc mov %esi,-0x24(%ebp)
siginfo->si_code = SI_USER;
124acf: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
124ad6: 85 ff test %edi,%edi
124ad8: 0f 84 ba 01 00 00 je 124c98 <killinfo+0x230>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
124ade: 8b 07 mov (%edi),%eax 124ae0: 89 45 e4 mov %eax,-0x1c(%ebp) 124ae3: a1 90 eb 12 00 mov 0x12eb90,%eax 124ae8: 40 inc %eax 124ae9: a3 90 eb 12 00 mov %eax,0x12eb90
/*
* 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;
124aee: 8b 0d 78 f1 12 00 mov 0x12f178,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
124af4: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax 124afa: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 124b00: f7 d0 not %eax 124b02: 85 c3 test %eax,%ebx
124b04: 75 34 jne 124b3a <killinfo+0xd2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124b06: a1 80 f3 12 00 mov 0x12f380,%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 );
124b0b: 3d 84 f3 12 00 cmp $0x12f384,%eax
124b10: 75 1b jne 124b2d <killinfo+0xc5>
124b12: e9 81 00 00 00 jmp 124b98 <killinfo+0x130> 124b17: 90 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
124b18: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 124b1e: f7 d2 not %edx 124b20: 85 d3 test %edx,%ebx
124b22: 75 16 jne 124b3a <killinfo+0xd2>
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 ) {
124b24: 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 );
124b26: 3d 84 f3 12 00 cmp $0x12f384,%eax
124b2b: 74 6b je 124b98 <killinfo+0x130> <== ALWAYS TAKEN
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
124b2d: 89 c1 mov %eax,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124b2f: 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)
124b35: 85 58 30 test %ebx,0x30(%eax)
124b38: 74 de je 124b18 <killinfo+0xb0>
/*
* 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 ) ) {
124b3a: 50 push %eax
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
124b3b: 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 ) ) {
124b3e: 50 push %eax 124b3f: 56 push %esi 124b40: 51 push %ecx 124b41: e8 d6 01 00 00 call 124d1c <_POSIX_signals_Unblock_thread> 124b46: 83 c4 10 add $0x10,%esp 124b49: 84 c0 test %al,%al
124b4b: 75 1f jne 124b6c <killinfo+0x104>
/*
* 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 );
124b4d: 83 ec 0c sub $0xc,%esp 124b50: 53 push %ebx 124b51: e8 b2 01 00 00 call 124d08 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
124b56: 8d 1c 76 lea (%esi,%esi,2),%ebx 124b59: c1 e3 02 shl $0x2,%ebx 124b5c: 83 c4 10 add $0x10,%esp 124b5f: 83 bb e0 f1 12 00 02 cmpl $0x2,0x12f1e0(%ebx)
124b66: 0f 84 e4 00 00 00 je 124c50 <killinfo+0x1e8>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
124b6c: e8 ab de fe ff call 112a1c <_Thread_Enable_dispatch>
return 0;
124b71: 31 c0 xor %eax,%eax
}
124b73: 8d 65 f4 lea -0xc(%ebp),%esp 124b76: 5b pop %ebx 124b77: 5e pop %esi 124b78: 5f pop %edi 124b79: c9 leave 124b7a: c3 ret 124b7b: 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 );
124b7c: e8 7b 03 00 00 call 124efc <pthread_self> 124b81: 83 ec 08 sub $0x8,%esp 124b84: 56 push %esi 124b85: 50 push %eax 124b86: e8 b1 02 00 00 call 124e3c <pthread_kill> 124b8b: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124b8e: 8d 65 f4 lea -0xc(%ebp),%esp 124b91: 5b pop %ebx 124b92: 5e pop %esi 124b93: 5f pop %edi 124b94: c9 leave 124b95: c3 ret 124b96: 66 90 xchg %ax,%ax
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
124b98: 0f b6 05 d4 a6 12 00 movzbl 0x12a6d4,%eax 124b9f: 40 inc %eax 124ba0: 89 45 d4 mov %eax,-0x2c(%ebp)
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
124ba3: 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++) {
124baa: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) 124bb1: 89 5d d0 mov %ebx,-0x30(%ebp) 124bb4: 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 ] )
124bb7: 8b 55 cc mov -0x34(%ebp),%edx 124bba: 8b 04 95 68 eb 12 00 mov 0x12eb68(,%edx,4),%eax 124bc1: 85 c0 test %eax,%eax
124bc3: 74 68 je 124c2d <killinfo+0x1c5> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
124bc5: 8b 40 04 mov 0x4(%eax),%eax
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
124bc8: 0f b7 70 10 movzwl 0x10(%eax),%esi
object_table = the_info->local_table;
124bcc: 8b 78 1c mov 0x1c(%eax),%edi
for ( index = 1 ; index <= maximum ; index++ ) {
124bcf: 85 f6 test %esi,%esi
124bd1: 74 5a je 124c2d <killinfo+0x1c5>
124bd3: b8 01 00 00 00 mov $0x1,%eax
the_thread = (Thread_Control *) object_table[ index ];
124bd8: 8b 14 87 mov (%edi,%eax,4),%edx
if ( !the_thread )
124bdb: 85 d2 test %edx,%edx
124bdd: 74 49 je 124c28 <killinfo+0x1c0>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
124bdf: 8b 4a 14 mov 0x14(%edx),%ecx 124be2: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124be5: 77 41 ja 124c28 <killinfo+0x1c0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
124be7: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx 124bed: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx 124bf3: f7 d3 not %ebx 124bf5: 85 5d d0 test %ebx,-0x30(%ebp)
124bf8: 74 2e je 124c28 <killinfo+0x1c0>
*
* 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 ) {
124bfa: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124bfd: 72 21 jb 124c20 <killinfo+0x1b8>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
124bff: 8b 5d c8 mov -0x38(%ebp),%ebx 124c02: 85 db test %ebx,%ebx
124c04: 74 22 je 124c28 <killinfo+0x1c0> <== NEVER TAKEN
124c06: 8b 5d c8 mov -0x38(%ebp),%ebx 124c09: 8b 5b 10 mov 0x10(%ebx),%ebx 124c0c: 89 5d c4 mov %ebx,-0x3c(%ebp) 124c0f: 85 db test %ebx,%ebx
124c11: 74 15 je 124c28 <killinfo+0x1c0> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
124c13: 8b 5a 10 mov 0x10(%edx),%ebx 124c16: 85 db test %ebx,%ebx
124c18: 0f 85 86 00 00 00 jne 124ca4 <killinfo+0x23c>
124c1e: 66 90 xchg %ax,%ax 124c20: 89 4d d4 mov %ecx,-0x2c(%ebp) 124c23: 89 55 c8 mov %edx,-0x38(%ebp) 124c26: 66 90 xchg %ax,%ax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
124c28: 40 inc %eax 124c29: 39 c6 cmp %eax,%esi
124c2b: 73 ab jae 124bd8 <killinfo+0x170>
* + 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++) {
124c2d: ff 45 cc incl -0x34(%ebp) 124c30: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
124c34: 75 81 jne 124bb7 <killinfo+0x14f>
124c36: 8b 5d d0 mov -0x30(%ebp),%ebx 124c39: 8b 75 c0 mov -0x40(%ebp),%esi
}
}
}
}
if ( interested ) {
124c3c: 8b 55 c8 mov -0x38(%ebp),%edx 124c3f: 85 d2 test %edx,%edx
124c41: 0f 84 06 ff ff ff je 124b4d <killinfo+0xe5>
124c47: 8b 4d c8 mov -0x38(%ebp),%ecx 124c4a: e9 eb fe ff ff jmp 124b3a <killinfo+0xd2> 124c4f: 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 );
124c50: 83 ec 0c sub $0xc,%esp 124c53: 68 60 f3 12 00 push $0x12f360 124c58: e8 43 c4 fe ff call 1110a0 <_Chain_Get>
if ( !psiginfo ) {
124c5d: 83 c4 10 add $0x10,%esp 124c60: 85 c0 test %eax,%eax
124c62: 0f 84 86 00 00 00 je 124cee <killinfo+0x286>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
124c68: 8d 78 08 lea 0x8(%eax),%edi 124c6b: 8d 75 dc lea -0x24(%ebp),%esi 124c6e: b9 03 00 00 00 mov $0x3,%ecx 124c73: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
124c75: 83 ec 08 sub $0x8,%esp 124c78: 50 push %eax 124c79: 81 c3 00 f4 12 00 add $0x12f400,%ebx 124c7f: 53 push %ebx 124c80: e8 df c3 fe ff call 111064 <_Chain_Append> 124c85: 83 c4 10 add $0x10,%esp 124c88: e9 df fe ff ff jmp 124b6c <killinfo+0x104> 124c8d: 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;
124c90: 31 c0 xor %eax,%eax 124c92: e9 f7 fe ff ff jmp 124b8e <killinfo+0x126> 124c97: 90 nop
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
124c98: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 124c9f: e9 3f fe ff ff jmp 124ae3 <killinfo+0x7b>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
124ca4: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp)
124cab: 0f 85 77 ff ff ff jne 124c28 <killinfo+0x1c0>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
124cb1: 81 e3 00 00 00 10 and $0x10000000,%ebx
124cb7: 0f 84 6b ff ff ff je 124c28 <killinfo+0x1c0>
124cbd: e9 5e ff ff ff jmp 124c20 <killinfo+0x1b8> 124cc2: 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 );
124cc4: e8 23 38 ff ff call 1184ec <__errno> 124cc9: c7 00 03 00 00 00 movl $0x3,(%eax) 124ccf: b8 ff ff ff ff mov $0xffffffff,%eax 124cd4: e9 b5 fe ff ff jmp 124b8e <killinfo+0x126>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
124cd9: e8 0e 38 ff ff call 1184ec <__errno> 124cde: c7 00 16 00 00 00 movl $0x16,(%eax) 124ce4: b8 ff ff ff ff mov $0xffffffff,%eax 124ce9: e9 a0 fe ff ff jmp 124b8e <killinfo+0x126>
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();
124cee: e8 29 dd fe ff call 112a1c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
124cf3: e8 f4 37 ff ff call 1184ec <__errno> 124cf8: c7 00 0b 00 00 00 movl $0xb,(%eax) 124cfe: 83 c8 ff or $0xffffffff,%eax 124d01: e9 88 fe ff ff jmp 124b8e <killinfo+0x126>
0010fb14 <mq_open>:
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 50 0f 13 00 mov 0x130f50,%eax 10fb25: 40 inc %eax 10fb26: a3 50 0f 13 00 mov %eax,0x130f50
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 <mq_open+0xf0>
/* 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 c0 14 13 00 push $0x1314c0 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 <mq_open+0xfc>
_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 <mq_open+0xbc>
} 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 <mq_open+0x11c>
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 20 13 13 00 push $0x131320 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 dc 14 13 00 mov 0x1314dc,%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 <mq_open+0x14c>
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 c0 14 13 00 push $0x1314c0 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 <mq_open+0x2e> 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 c0 14 13 00 push $0x1314c0 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 <mq_open+0xc5>
/*
* 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 <mq_open+0x194>
_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 dc 14 13 00 mov 0x1314dc,%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 <mq_open+0xb3> 10fca8: 83 ec 08 sub $0x8,%esp 10fcab: 53 push %ebx 10fcac: 68 c0 14 13 00 push $0x1314c0 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 <mq_open+0xb3>
00110950 <pthread_attr_destroy>:
#include <rtems/system.h>
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 <pthread_attr_destroy+0x1c>
11095a: 8b 10 mov (%eax),%edx 11095c: 85 d2 test %edx,%edx
11095e: 74 0c je 11096c <pthread_attr_destroy+0x1c>
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 <pthread_attr_getcputime>:
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 <pthread_attr_getcputime+0x20><== NEVER TAKEN
110ffd: 8b 08 mov (%eax),%ecx 110fff: 85 c9 test %ecx,%ecx
111001: 74 0d je 111010 <pthread_attr_getcputime+0x20>
111003: 85 d2 test %edx,%edx
111005: 74 09 je 111010 <pthread_attr_getcputime+0x20>
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 <pthread_attr_getstack>:
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 <pthread_attr_getstack+0x30>
110aad: 8b 18 mov (%eax),%ebx 110aaf: 85 db test %ebx,%ebx
110ab1: 74 19 je 110acc <pthread_attr_getstack+0x30>
110ab3: 85 d2 test %edx,%edx
110ab5: 74 15 je 110acc <pthread_attr_getstack+0x30>
110ab7: 85 c9 test %ecx,%ecx
110ab9: 74 11 je 110acc <pthread_attr_getstack+0x30>
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 <pthread_attr_setguardsize>:
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 <pthread_attr_setguardsize+0x1c>
110b5a: 8b 10 mov (%eax),%edx 110b5c: 85 d2 test %edx,%edx
110b5e: 74 0c je 110b6c <pthread_attr_setguardsize+0x1c>
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 <pthread_attr_setinheritsched>:
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 <pthread_attr_setinheritsched+0x2c>
111b69: 8b 08 mov (%eax),%ecx 111b6b: 85 c9 test %ecx,%ecx
111b6d: 74 19 je 111b88 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
111b6f: 8d 4a ff lea -0x1(%edx),%ecx 111b72: 83 f9 01 cmp $0x1,%ecx
111b75: 76 09 jbe 111b80 <pthread_attr_setinheritsched+0x24>
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 <pthread_attr_setschedparam>:
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 <pthread_attr_setschedparam+0x2c>
110bb7: 8b 07 mov (%edi),%eax 110bb9: 85 c0 test %eax,%eax
110bbb: 74 17 je 110bd4 <pthread_attr_setschedparam+0x2c>
110bbd: 85 f6 test %esi,%esi
110bbf: 74 13 je 110bd4 <pthread_attr_setschedparam+0x2c>
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 <pthread_attr_setschedpolicy>:
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 <pthread_attr_setschedpolicy+0x30>
110bed: 8b 08 mov (%eax),%ecx 110bef: 85 c9 test %ecx,%ecx
110bf1: 74 1d je 110c10 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
110bf3: 85 d2 test %edx,%edx
110bf5: 78 0a js 110c01 <pthread_attr_setschedpolicy+0x21>
110bf7: 83 fa 02 cmp $0x2,%edx
110bfa: 7e 0c jle 110c08 <pthread_attr_setschedpolicy+0x28>
110bfc: 83 fa 04 cmp $0x4,%edx
110bff: 74 07 je 110c08 <pthread_attr_setschedpolicy+0x28><== 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 <pthread_attr_setscope>:
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 <pthread_attr_setscope+0x27>
110c25: 8b 08 mov (%eax),%ecx 110c27: 85 c9 test %ecx,%ecx
110c29: 74 14 je 110c3f <pthread_attr_setscope+0x27>
return EINVAL;
switch ( contentionscope ) {
110c2b: 85 d2 test %edx,%edx
110c2d: 75 0d jne 110c3c <pthread_attr_setscope+0x24>
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 <pthread_attr_setscope+0x30>
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 <pthread_attr_setstack>:
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 <pthread_attr_setstack+0x34>
110c81: 8b 08 mov (%eax),%ecx 110c83: 85 c9 test %ecx,%ecx
110c85: 74 21 je 110ca8 <pthread_attr_setstack+0x34>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
110c87: 8b 0d 78 e4 12 00 mov 0x12e478,%ecx 110c8d: d1 e1 shl %ecx 110c8f: 39 d1 cmp %edx,%ecx
110c91: 77 0d ja 110ca0 <pthread_attr_setstack+0x2c>
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 <pthread_attr_setstack+0x22> 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 <pthread_attr_setstackaddr>:
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 <pthread_attr_setstackaddr+0x1c>
110c5a: 8b 10 mov (%eax),%edx 110c5c: 85 d2 test %edx,%edx
110c5e: 74 0c je 110c6c <pthread_attr_setstackaddr+0x1c>
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 <pthread_attr_setstacksize>:
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 <pthread_attr_setstacksize+0x30>
111b9d: 8b 08 mov (%eax),%ecx 111b9f: 85 c9 test %ecx,%ecx
111ba1: 74 1d je 111bc0 <pthread_attr_setstacksize+0x30>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
111ba3: 8b 0d f8 4d 12 00 mov 0x124df8,%ecx 111ba9: d1 e1 shl %ecx 111bab: 39 d1 cmp %edx,%ecx
111bad: 77 09 ja 111bb8 <pthread_attr_setstacksize+0x28>
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 <pthread_barrier_init>:
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 <pthread_barrier_init+0x9c>
return EINVAL;
if ( count == 0 )
10b9b6: 85 f6 test %esi,%esi
10b9b8: 74 7e je 10ba38 <pthread_barrier_init+0x9c>
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 <pthread_barrier_init+0xb8>
}
/*
* 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 <pthread_barrier_init+0x9c>
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 <pthread_barrier_init+0x9c><== 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 b0 95 12 00 mov 0x1295b0,%eax 10b9de: 40 inc %eax 10b9df: a3 b0 95 12 00 mov %eax,0x1295b0
* 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 00 9a 12 00 push $0x129a00 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 <pthread_barrier_init+0xac>
_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 1c 9a 12 00 mov 0x129a1c,%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 <pthread_barrier_init+0xa1>
* 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 <pthread_barrierattr_init> 10ba60: 83 c4 10 add $0x10,%esp 10ba63: e9 5a ff ff ff jmp 10b9c2 <pthread_barrier_init+0x26>
0010ba68 <pthread_barrier_wait>:
*/
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 <pthread_barrier_wait+0x5c>
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 00 9a 12 00 push $0x129a00 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 <pthread_barrier_wait+0x5c>
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 98 9b 12 00 mov 0x129b98,%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 <pthread_barrierattr_destroy>:
*/
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 <pthread_barrierattr_destroy+0x1c>
10b89e: 8b 10 mov (%eax),%edx 10b8a0: 85 d2 test %edx,%edx
10b8a2: 74 0c je 10b8b0 <pthread_barrierattr_destroy+0x1c>
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 <pthread_cancel>:
*/
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 14 97 12 00 mov 0x129714,%eax 10b13f: 85 c0 test %eax,%eax
10b141: 74 09 je 10b14c <pthread_cancel+0x18>
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 00 94 12 00 push $0x129400 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 <pthread_cancel+0x54>
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 <pthread_cleanup_pop>:
*/
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 18 88 12 00 mov 0x128818,%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 30 82 12 00 mov 0x128230,%edx 10afd1: 42 inc %edx 10afd2: 89 15 30 82 12 00 mov %edx,0x128230
* 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 <pthread_cleanup_pop+0x7c>
_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 <pthread_cleanup_pop+0x6c>
(*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 <pthread_cleanup_push>:
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 <pthread_cleanup_push+0x5c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b36f: a1 d0 98 12 00 mov 0x1298d0,%eax 10b374: 40 inc %eax 10b375: a3 d0 98 12 00 mov %eax,0x1298d0
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 <pthread_cleanup_push+0x50><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b38b: 8b 15 b8 9e 12 00 mov 0x129eb8,%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 <pthread_cond_destroy>:
*/
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 <pthread_cond_destroy+0x44>
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 <pthread_cond_destroy+0x50>
_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 80 aa 12 00 push $0x12aa80 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 80 aa 12 00 push $0x12aa80 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 <pthread_cond_destroy+0x49>
0010c120 <pthread_cond_init>:
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 <pthread_cond_init+0x98>
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 <pthread_cond_init+0x1e><== 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 <pthread_cond_init+0x28>
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 90 a5 12 00 mov 0x12a590,%eax 10c14d: 40 inc %eax 10c14e: a3 90 a5 12 00 mov %eax,0x12a590
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 80 aa 12 00 push $0x12aa80 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 <pthread_cond_init+0xa4>
_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 9c aa 12 00 mov 0x12aa9c,%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 fc 3b 12 00 mov $0x123bfc,%ebx 10c1bd: e9 70 ff ff ff jmp 10c132 <pthread_cond_init+0x12> 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 <pthread_cond_init+0x23>
0010bfb0 <pthread_condattr_destroy>:
*/
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 <pthread_condattr_destroy+0x1c>
10bfba: 8b 10 mov (%eax),%edx 10bfbc: 85 d2 test %edx,%edx
10bfbe: 74 0c je 10bfcc <pthread_condattr_destroy+0x1c><== 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 <pthread_condattr_getpshared>:
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 <pthread_condattr_getpshared+0x18>
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 <pthread_condattr_init>:
*/
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 <pthread_condattr_init+0x20><== NEVER TAKEN
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
10bffe: 8b 15 fc 3b 12 00 mov 0x123bfc,%edx 10c004: 8b 0d 00 3c 12 00 mov 0x123c00,%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 <pthread_condattr_setpshared>:
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 <pthread_condattr_setpshared+0x12>
return EINVAL;
switch ( pshared ) {
10c029: 83 fa 01 cmp $0x1,%edx
10c02c: 76 0a jbe 10c038 <pthread_condattr_setpshared+0x1c>
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_create>:
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 <pthread_create+0x1a4>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10b6ef: 85 db test %ebx,%ebx
10b6f1: 74 65 je 10b758 <pthread_create+0x80>
if ( !the_attr->is_initialized )
10b6f3: 8b 0b mov (%ebx),%ecx 10b6f5: 85 c9 test %ecx,%ecx
10b6f7: 74 1e je 10b717 <pthread_create+0x3f> * 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 <pthread_create+0x32>
10b700: a1 f8 4d 12 00 mov 0x124df8,%eax 10b705: 39 43 08 cmp %eax,0x8(%ebx)
10b708: 72 0d jb 10b717 <pthread_create+0x3f>
* 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 <pthread_create+0x88>
10b712: 83 f8 02 cmp $0x2,%eax
10b715: 74 11 je 10b728 <pthread_create+0x50>
/*
* 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 <pthread_create+0xb8> <== 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 a0 27 12 00 mov $0x1227a0,%ebx 10b75d: eb 94 jmp 10b6f3 <pthread_create+0x1b> 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 f8 96 12 00 mov 0x1296f8,%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 <pthread_create+0x6f>
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 <pthread_create+0x3f> <== 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 fc 4d 12 00 movzbl 0x124dfc,%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 <pthread_create+0x44>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b7d0: 83 ec 0c sub $0xc,%esp 10b7d3: ff 35 fc 91 12 00 pushl 0x1291fc 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 e0 93 12 00 movl $0x1293e0,(%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 <pthread_create+0x235>
/*
* 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 f8 4d 12 00 mov 0x124df8,%eax 10b812: d1 e0 shl %eax 10b814: 3b 45 a8 cmp -0x58(%ebp),%eax
10b817: 73 03 jae 10b81c <pthread_create+0x144>
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 e0 93 12 00 push $0x1293e0 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 <pthread_create+0x1ae>
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 e0 93 12 00 push $0x1293e0 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 fc 91 12 00 pushl 0x1291fc 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 <pthread_create+0x44> 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 <pthread_create+0x44>
}
/*
* 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 <pthread_create+0x250>
}
/*
* 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 fc 91 12 00 pushl 0x1291fc 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 <pthread_create+0x44>
*
* 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 fc 91 12 00 pushl 0x1291fc 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 <pthread_create+0x44>
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 1c 92 12 00 push $0x12921c 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 <pthread_create+0x20e>
00112e78 <pthread_exit>:
}
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 18 84 12 00 pushl 0x128418 112e87: e8 88 ff ff ff call 112e14 <_POSIX_Thread_Exit>
112e8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
112e8f: c9 leave <== NOT EXECUTED 112e90: c3 ret <== NOT EXECUTED
0010d8d0 <pthread_getschedparam>:
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 <pthread_getschedparam+0x7c>
10d8e3: 85 db test %ebx,%ebx
10d8e5: 74 65 je 10d94c <pthread_getschedparam+0x7c>
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 d0 12 00 push $0x12d060 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 <pthread_getschedparam+0x6c>
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 1c 8a 12 00 movzbl 0x128a1c,%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 <pthread_getspecific>:
*/
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 e0 a1 12 00 push $0x12a1e0 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 <pthread_getspecific+0x4c>
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
10b6d9: 8b 15 18 a3 12 00 mov 0x12a318,%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 <pthread_join>:
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 00 2b 13 00 push $0x132b00 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 <pthread_join+0x30>
#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 <pthread_join+0x80>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
111155: 8b 0d 18 2e 13 00 mov 0x132e18,%ecx
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
11115b: 39 c8 cmp %ecx,%eax
11115d: 74 49 je 1111a8 <pthread_join+0x90>
/*
* 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 <pthread_join+0x9c>
*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 <pthread_join+0x2a>
_Thread_Enable_dispatch();
if ( value_ptr )
*value_ptr = return_pointer;
return 0;
1111b4: 31 c0 xor %eax,%eax 1111b6: eb 8a jmp 111142 <pthread_join+0x2a>
0010b544 <pthread_key_create>:
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 30 9d 12 00 mov 0x129d30,%eax 10b552: 40 inc %eax 10b553: a3 30 9d 12 00 mov %eax,0x129d30
* 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 e0 a1 12 00 push $0x12a1e0 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 <pthread_key_create+0xa0>
_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 08 9d 12 00 mov 0x129d08(,%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 <pthread_key_create+0xb4>
_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 <pthread_key_create+0x32>
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 fc a1 12 00 mov 0x12a1fc,%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 e0 a1 12 00 push $0x12a1e0 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 <pthread_key_delete>:
* 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 e0 a1 12 00 push $0x12a1e0 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 <pthread_key_delete+0x58>
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
10b648: 83 ec 08 sub $0x8,%esp 10b64b: 50 push %eax 10b64c: 68 e0 a1 12 00 push $0x12a1e0 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 e0 a1 12 00 push $0x12a1e0 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
00124e3c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
124e3c: 55 push %ebp 124e3d: 89 e5 mov %esp,%ebp 124e3f: 57 push %edi 124e40: 56 push %esi 124e41: 53 push %ebx 124e42: 83 ec 1c sub $0x1c,%esp 124e45: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
124e48: 85 db test %ebx,%ebx
124e4a: 0f 84 84 00 00 00 je 124ed4 <pthread_kill+0x98>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
124e50: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
124e53: 83 ff 1f cmp $0x1f,%edi
124e56: 77 7c ja 124ed4 <pthread_kill+0x98>
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
124e58: 56 push %esi
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _POSIX_Threads_Get( thread, &location );
124e59: 8d 45 e4 lea -0x1c(%ebp),%eax 124e5c: 50 push %eax 124e5d: ff 75 08 pushl 0x8(%ebp) 124e60: 68 60 ee 12 00 push $0x12ee60 124e65: e8 7e d0 fe ff call 111ee8 <_Objects_Get> 124e6a: 89 c6 mov %eax,%esi
switch ( location ) {
124e6c: 83 c4 10 add $0x10,%esp 124e6f: 8b 4d e4 mov -0x1c(%ebp),%ecx 124e72: 85 c9 test %ecx,%ecx
124e74: 75 72 jne 124ee8 <pthread_kill+0xac>
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124e76: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
124e7c: 8d 04 5b lea (%ebx,%ebx,2),%eax 124e7f: 83 3c 85 e8 f1 12 00 cmpl $0x1,0x12f1e8(,%eax,4)
124e86: 01
124e87: 74 2d je 124eb6 <pthread_kill+0x7a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124e89: b8 01 00 00 00 mov $0x1,%eax 124e8e: 89 f9 mov %edi,%ecx 124e90: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
124e92: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
124e98: 52 push %edx 124e99: 6a 00 push $0x0 124e9b: 53 push %ebx 124e9c: 56 push %esi 124e9d: e8 7a fe ff ff call 124d1c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124ea2: 83 c4 10 add $0x10,%esp 124ea5: a1 74 f1 12 00 mov 0x12f174,%eax 124eaa: 85 c0 test %eax,%eax
124eac: 74 08 je 124eb6 <pthread_kill+0x7a>
124eae: 3b 35 78 f1 12 00 cmp 0x12f178,%esi
124eb4: 74 12 je 124ec8 <pthread_kill+0x8c>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
124eb6: e8 61 db fe ff call 112a1c <_Thread_Enable_dispatch>
return 0;
124ebb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
124ebd: 8d 65 f4 lea -0xc(%ebp),%esp 124ec0: 5b pop %ebx 124ec1: 5e pop %esi 124ec2: 5f pop %edi 124ec3: c9 leave 124ec4: c3 ret 124ec5: 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;
124ec8: c6 05 84 f1 12 00 01 movb $0x1,0x12f184 124ecf: eb e5 jmp 124eb6 <pthread_kill+0x7a> 124ed1: 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 );
124ed4: e8 13 36 ff ff call 1184ec <__errno> 124ed9: c7 00 16 00 00 00 movl $0x16,(%eax) 124edf: b8 ff ff ff ff mov $0xffffffff,%eax 124ee4: eb d7 jmp 124ebd <pthread_kill+0x81> 124ee6: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
124ee8: e8 ff 35 ff ff call 1184ec <__errno> 124eed: c7 00 03 00 00 00 movl $0x3,(%eax) 124ef3: b8 ff ff ff ff mov $0xffffffff,%eax 124ef8: eb c3 jmp 124ebd <pthread_kill+0x81>
0010d19c <pthread_mutex_getprioceiling>:
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 <pthread_mutex_getprioceiling+0x27>
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 <pthread_mutex_getprioceiling+0x34>
#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 1c 8a 12 00 movzbl 0x128a1c,%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 <pthread_mutex_init>:
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 <pthread_mutex_init+0x120>
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 <pthread_mutex_init+0x104>
}
}
}
#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 <pthread_mutex_init+0x104>
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 <pthread_mutex_init+0x12c>
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 <pthread_mutex_init+0x104>
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 <pthread_mutex_init+0x134>
10d231: 83 f8 02 cmp $0x2,%eax
10d234: 0f 84 c2 00 00 00 je 10d2fc <pthread_mutex_init+0x114>
10d23a: 85 c0 test %eax,%eax
10d23c: 0f 85 aa 00 00 00 jne 10d2ec <pthread_mutex_init+0x104>
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 <pthread_mutex_init+0x104>
#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 <pthread_mutex_init+0x104>
10d269: a1 90 cd 12 00 mov 0x12cd90,%eax 10d26e: 40 inc %eax 10d26f: a3 90 cd 12 00 mov %eax,0x12cd90
* _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 d1 12 00 push $0x12d1a0 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 <pthread_mutex_init+0x140>
_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 1c 8a 12 00 movzbl 0x128a1c,%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 d1 12 00 mov 0x12d1bc,%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 <pthread_mutex_init+0x109> 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 <pthread_mutex_init+0x61>
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 d2 12 00 mov $0x12d220,%ebx 10d30d: e9 ed fe ff ff jmp 10d1ff <pthread_mutex_init+0x17> 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 <pthread_mutex_init+0x109> 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 <pthread_mutex_init+0x61>
_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 <pthread_mutex_init+0x109>
0010d440 <pthread_mutex_timedlock>:
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 <pthread_mutex_timedlock+0x50>
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 <pthread_mutex_timedlock+0x3c><== 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 <pthread_mutex_timedlock+0x68><== 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 <pthread_mutex_timedlock+0x35><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10d486: b8 74 00 00 00 mov $0x74,%eax 10d48b: eb e8 jmp 10d475 <pthread_mutex_timedlock+0x35> 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 <pthread_mutex_timedlock+0x35><== NOT EXECUTED
0010cf24 <pthread_mutexattr_destroy>:
*/
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 <pthread_mutexattr_destroy+0x1c>
10cf2e: 8b 10 mov (%eax),%edx 10cf30: 85 d2 test %edx,%edx
10cf32: 74 0c je 10cf40 <pthread_mutexattr_destroy+0x1c>
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 <pthread_mutexattr_setprioceiling>:
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 <pthread_mutexattr_setprioceiling+0x15><== NEVER TAKEN
10cffb: 8b 03 mov (%ebx),%eax 10cffd: 85 c0 test %eax,%eax
10cfff: 75 0f jne 10d010 <pthread_mutexattr_setprioceiling+0x24>
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 <pthread_mutexattr_setprioceiling+0x15>
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 <pthread_mutexattr_setpshared>:
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 <pthread_mutexattr_setpshared+0x18>
10d061: 8b 08 mov (%eax),%ecx 10d063: 85 c9 test %ecx,%ecx
10d065: 74 05 je 10d06c <pthread_mutexattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10d067: 83 fa 01 cmp $0x1,%edx
10d06a: 76 08 jbe 10d074 <pthread_mutexattr_setpshared+0x20><== 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 <pthread_mutexattr_settype>:
#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 <pthread_mutexattr_settype+0x18>
10b255: 8b 08 mov (%eax),%ecx 10b257: 85 c9 test %ecx,%ecx
10b259: 74 05 je 10b260 <pthread_mutexattr_settype+0x18><== NEVER TAKEN
return EINVAL;
switch ( type ) {
10b25b: 83 fa 03 cmp $0x3,%edx
10b25e: 76 08 jbe 10b268 <pthread_mutexattr_settype+0x20>
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 <pthread_once>:
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 <pthread_once+0x64>
10bdaf: 85 f6 test %esi,%esi
10bdb1: 74 4d je 10be00 <pthread_once+0x64>
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 <pthread_once+0x28>
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 <rtems_task_mode>
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 <pthread_once+0x74> <== 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 <rtems_task_mode> 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 <pthread_once+0x46>
0010c480 <pthread_rwlock_destroy>:
*/
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 <pthread_rwlock_destroy+0x50>
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 40 ba 12 00 push $0x12ba40 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 <pthread_rwlock_destroy+0x50>
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 <pthread_rwlock_destroy+0x5c>
_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 40 ba 12 00 push $0x12ba40 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 40 ba 12 00 push $0x12ba40 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 <pthread_rwlock_destroy+0x55>
0010c504 <pthread_rwlock_init>:
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 <pthread_rwlock_init+0x27>
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 <pthread_rwlock_init+0xa8>
}
/*
* 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 <pthread_rwlock_init+0x27><== 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 <pthread_rwlock_init+0x34><== 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 b0 b7 12 00 mov 0x12b7b0,%eax 10c544: 40 inc %eax 10c545: a3 b0 b7 12 00 mov %eax,0x12b7b0
* 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 40 ba 12 00 push $0x12ba40 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 <pthread_rwlock_init+0x9c>
_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 5c ba 12 00 mov 0x12ba5c,%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 <pthread_rwlock_init+0x2c>
* 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 <pthread_rwlockattr_init> 10c5b8: 83 c4 10 add $0x10,%esp 10c5bb: e9 5e ff ff ff jmp 10c51e <pthread_rwlock_init+0x1a>
0010c628 <pthread_rwlock_timedrdlock>:
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 <pthread_rwlock_timedrdlock+0x8c> * * 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 40 ba 12 00 push $0x12ba40 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 <pthread_rwlock_timedrdlock+0x8c> 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 <pthread_rwlock_timedrdlock+0xac>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10c694: a1 98 bd 12 00 mov 0x12bd98,%eax 10c699: 8b 40 34 mov 0x34(%eax),%eax 10c69c: 83 f8 02 cmp $0x2,%eax
10c69f: 74 1f je 10c6c0 <pthread_rwlock_timedrdlock+0x98>
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 <pthread_rwlock_timedrdlock+0x8c><== 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 <pthread_rwlock_timedrdlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
10c6ca: b8 74 00 00 00 mov $0x74,%eax 10c6cf: eb e8 jmp 10c6b9 <pthread_rwlock_timedrdlock+0x91> 10c6d1: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
10c6d4: a1 98 bd 12 00 mov 0x12bd98,%eax 10c6d9: 8b 40 34 mov 0x34(%eax),%eax 10c6dc: eb c3 jmp 10c6a1 <pthread_rwlock_timedrdlock+0x79>
0010c6e0 <pthread_rwlock_timedwrlock>:
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 <pthread_rwlock_timedwrlock+0x8c> * * 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 40 ba 12 00 push $0x12ba40 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_timedwrlock+0x8c>
(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 <pthread_rwlock_timedwrlock+0xac>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10c74c: a1 98 bd 12 00 mov 0x12bd98,%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 <pthread_rwlock_timedwrlock+0x98>
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 <pthread_rwlock_timedwrlock+0x8c><== 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 <pthread_rwlock_timedwrlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
10c782: b8 74 00 00 00 mov $0x74,%eax 10c787: eb e8 jmp 10c771 <pthread_rwlock_timedwrlock+0x91> 10c789: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10c78c: a1 98 bd 12 00 mov 0x12bd98,%eax 10c791: 8b 40 34 mov 0x34(%eax),%eax 10c794: eb c3 jmp 10c759 <pthread_rwlock_timedwrlock+0x79>
0010cef4 <pthread_rwlockattr_destroy>:
*/
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 <pthread_rwlockattr_destroy+0x1c>
10cefe: 8b 10 mov (%eax),%edx 10cf00: 85 d2 test %edx,%edx
10cf02: 74 0c je 10cf10 <pthread_rwlockattr_destroy+0x1c>
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 <pthread_rwlockattr_setpshared>:
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 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
if ( !attr->is_initialized )
10cf6d: 8b 08 mov (%eax),%ecx 10cf6f: 85 c9 test %ecx,%ecx
10cf71: 74 05 je 10cf78 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10cf73: 83 fa 01 cmp $0x1,%edx
10cf76: 76 08 jbe 10cf80 <pthread_rwlockattr_setpshared+0x20><== 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 <pthread_setcancelstate>:
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 14 97 12 00 mov 0x129714,%ecx 10b227: 85 c9 test %ecx,%ecx
10b229: 75 15 jne 10b240 <pthread_setcancelstate+0x2c>
return EPROTO;
if ( !oldstate )
10b22b: 85 c0 test %eax,%eax
10b22d: 74 05 je 10b234 <pthread_setcancelstate+0x20>
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
10b22f: 83 fa 01 cmp $0x1,%edx
10b232: 76 18 jbe 10b24c <pthread_setcancelstate+0x38>
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 18 97 12 00 mov 0x129718,%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 30 91 12 00 mov 0x129130,%ebx 10b25e: 43 inc %ebx 10b25f: 89 1d 30 91 12 00 mov %ebx,0x129130
_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 18 97 12 00 pushl 0x129718 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 <pthread_setcanceltype>:
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 14 97 12 00 mov 0x129714,%ecx 10b29f: 85 c9 test %ecx,%ecx
10b2a1: 75 15 jne 10b2b8 <pthread_setcanceltype+0x2c>
return EPROTO;
if ( !oldtype )
10b2a3: 85 c0 test %eax,%eax
10b2a5: 74 05 je 10b2ac <pthread_setcanceltype+0x20>
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
10b2a7: 83 fa 01 cmp $0x1,%edx
10b2aa: 76 18 jbe 10b2c4 <pthread_setcanceltype+0x38>
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 18 97 12 00 mov 0x129718,%ecx 10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b2d0: 8b 1d 30 91 12 00 mov 0x129130,%ebx 10b2d6: 43 inc %ebx 10b2d7: 89 1d 30 91 12 00 mov %ebx,0x129130
_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 18 97 12 00 pushl 0x129718 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 <pthread_setschedparam>:
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 <pthread_setschedparam+0xe0>
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 <pthread_setschedparam+0x38>
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 d0 12 00 push $0x12d060 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 <pthread_setschedparam+0xf0>
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 <pthread_setschedparam+0x13c>
(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 <pthread_setschedparam+0xcf><== NEVER TAKEN
10ddb5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10ddb9: 7f 59 jg 10de14 <pthread_setschedparam+0x100>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ddbb: a1 60 cd 12 00 mov 0x12cd60,%eax 10ddc0: 89 42 78 mov %eax,0x78(%edx) 10ddc3: 0f b6 05 1c 8a 12 00 movzbl 0x128a1c,%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 <pthread_setschedparam+0xcf><== 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 <pthread_setschedparam+0xcf> 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 <pthread_setschedparam+0x70>
00111cf4 <pthread_sigmask>:
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 <pthread_sigmask+0xa0>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111d0a: a1 18 a4 12 00 mov 0x12a418,%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 <pthread_sigmask+0x31>
*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 <pthread_sigmask+0x6c>
return 0;
switch ( how ) {
111d25: 83 f9 01 cmp $0x1,%ecx
111d28: 74 5e je 111d88 <pthread_sigmask+0x94>
111d2a: 83 f9 02 cmp $0x2,%ecx
111d2d: 74 39 je 111d68 <pthread_sigmask+0x74>
111d2f: 85 c9 test %ecx,%ecx
111d31: 75 41 jne 111d74 <pthread_sigmask+0x80>
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 88 a6 12 00 mov 0x12a688,%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 <pthread_sigmask+0x6c>
(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 <pthread_sigmask+0x47>
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 <pthread_sigmask+0x47> 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 <pthread_sigmask+0x80>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111d98: a1 18 a4 12 00 mov 0x12a418,%eax 111d9d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 111da3: e9 71 ff ff ff jmp 111d19 <pthread_sigmask+0x25>
0010bb84 <pthread_testcancel>:
*
* 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 b4 9e 12 00 mov 0x129eb4,%ecx 10bb90: 85 c9 test %ecx,%ecx
10bb92: 75 44 jne 10bbd8 <pthread_testcancel+0x54><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10bb94: a1 b8 9e 12 00 mov 0x129eb8,%eax 10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10bb9f: 8b 15 d0 98 12 00 mov 0x1298d0,%edx 10bba5: 42 inc %edx 10bba6: 89 15 d0 98 12 00 mov %edx,0x1298d0
_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 <pthread_testcancel+0x58><== NEVER TAKEN
10bbb6: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10bbbc: 85 c0 test %eax,%eax
10bbbe: 74 1c je 10bbdc <pthread_testcancel+0x58>
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 b8 9e 12 00 pushl 0x129eb8 10bbd0: e8 53 5b 00 00 call 111728 <_POSIX_Thread_Exit>
10bbd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10bbd8: c9 leave <== NOT EXECUTED 10bbd9: c3 ret <== NOT EXECUTED 10bbda: 66 90 xchg %ax,%ax <== NOT EXECUTED
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>
0010c550 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10c550: 55 push %ebp 10c551: 89 e5 mov %esp,%ebp 10c553: 57 push %edi 10c554: 56 push %esi 10c555: 53 push %ebx 10c556: 83 ec 58 sub $0x58,%esp 10c559: 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);
10c55c: 68 80 aa 12 00 push $0x12aa80 10c561: e8 86 09 00 00 call 10ceec <pthread_mutex_lock> 10c566: 89 c6 mov %eax,%esi
if (result != 0) {
10c568: 83 c4 10 add $0x10,%esp 10c56b: 85 c0 test %eax,%eax
10c56d: 0f 85 c1 00 00 00 jne 10c634 <rtems_aio_enqueue+0xe4><== 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);
10c573: e8 24 12 00 00 call 10d79c <pthread_self> 10c578: 51 push %ecx 10c579: 8d 55 c4 lea -0x3c(%ebp),%edx 10c57c: 52 push %edx 10c57d: 8d 55 e0 lea -0x20(%ebp),%edx 10c580: 52 push %edx 10c581: 50 push %eax 10c582: e8 e1 0d 00 00 call 10d368 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10c587: e8 10 12 00 00 call 10d79c <pthread_self> 10c58c: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10c58f: 8b 43 14 mov 0x14(%ebx),%eax 10c592: 8b 55 c4 mov -0x3c(%ebp),%edx 10c595: 2b 50 14 sub 0x14(%eax),%edx 10c598: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10c59b: 8b 55 e0 mov -0x20(%ebp),%edx 10c59e: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10c5a1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10c5a8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10c5af: 83 c4 10 add $0x10,%esp 10c5b2: 8b 15 e8 aa 12 00 mov 0x12aae8,%edx 10c5b8: 85 d2 test %edx,%edx
10c5ba: 75 0d jne 10c5c9 <rtems_aio_enqueue+0x79><== NEVER TAKEN
10c5bc: 83 3d e4 aa 12 00 04 cmpl $0x4,0x12aae4
10c5c3: 0f 8e 83 00 00 00 jle 10c64c <rtems_aio_enqueue+0xfc>
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,
10c5c9: 51 push %ecx 10c5ca: 6a 00 push $0x0 10c5cc: ff 30 pushl (%eax) 10c5ce: 68 c8 aa 12 00 push $0x12aac8 10c5d3: e8 28 fb ff ff call 10c100 <rtems_aio_search_fd> 10c5d8: 89 c7 mov %eax,%edi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10c5da: 83 c4 10 add $0x10,%esp 10c5dd: 85 c0 test %eax,%eax
10c5df: 0f 84 df 00 00 00 je 10c6c4 <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
10c5e5: 8d 57 1c lea 0x1c(%edi),%edx 10c5e8: 83 ec 0c sub $0xc,%esp 10c5eb: 52 push %edx 10c5ec: 89 55 b4 mov %edx,-0x4c(%ebp) 10c5ef: e8 f8 08 00 00 call 10ceec <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10c5f4: 58 pop %eax 10c5f5: 5a pop %edx 10c5f6: 53 push %ebx 10c5f7: 8d 47 08 lea 0x8(%edi),%eax 10c5fa: 50 push %eax 10c5fb: e8 48 fe ff ff call 10c448 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10c600: 83 c7 20 add $0x20,%edi 10c603: 89 3c 24 mov %edi,(%esp) 10c606: e8 b1 04 00 00 call 10cabc <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10c60b: 8b 55 b4 mov -0x4c(%ebp),%edx 10c60e: 89 14 24 mov %edx,(%esp) 10c611: e8 5e 09 00 00 call 10cf74 <pthread_mutex_unlock> 10c616: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10c619: 83 ec 0c sub $0xc,%esp 10c61c: 68 80 aa 12 00 push $0x12aa80 10c621: e8 4e 09 00 00 call 10cf74 <pthread_mutex_unlock>
return 0;
10c626: 83 c4 10 add $0x10,%esp
}
10c629: 89 f0 mov %esi,%eax 10c62b: 8d 65 f4 lea -0xc(%ebp),%esp 10c62e: 5b pop %ebx 10c62f: 5e pop %esi 10c630: 5f pop %edi 10c631: c9 leave 10c632: c3 ret 10c633: 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);
10c634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c637: 53 push %ebx <== NOT EXECUTED 10c638: e8 f7 c4 ff ff call 108b34 <free> <== NOT EXECUTED
return result;
10c63d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
10c640: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c642: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c645: 5b pop %ebx <== NOT EXECUTED 10c646: 5e pop %esi <== NOT EXECUTED 10c647: 5f pop %edi <== NOT EXECUTED 10c648: c9 leave <== NOT EXECUTED 10c649: c3 ret <== NOT EXECUTED 10c64a: 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);
10c64c: 57 push %edi 10c64d: 6a 01 push $0x1 10c64f: ff 30 pushl (%eax) 10c651: 68 c8 aa 12 00 push $0x12aac8 10c656: e8 a5 fa ff ff call 10c100 <rtems_aio_search_fd> 10c65b: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c65d: 83 c4 10 add $0x10,%esp 10c660: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c664: 0f 85 7b ff ff ff jne 10c5e5 <rtems_aio_enqueue+0x95>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10c66a: 83 ec 08 sub $0x8,%esp 10c66d: 53 push %ebx 10c66e: 8d 40 08 lea 0x8(%eax),%eax 10c671: 50 push %eax 10c672: e8 85 22 00 00 call 10e8fc <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0;
10c677: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c67e: 5a pop %edx 10c67f: 59 pop %ecx 10c680: 6a 00 push $0x0 10c682: 8d 47 1c lea 0x1c(%edi),%eax 10c685: 50 push %eax 10c686: e8 15 07 00 00 call 10cda0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c68b: 5b pop %ebx 10c68c: 58 pop %eax 10c68d: 6a 00 push $0x0 10c68f: 8d 47 20 lea 0x20(%edi),%eax 10c692: 50 push %eax 10c693: e8 70 03 00 00 call 10ca08 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10c698: 57 push %edi 10c699: 68 fc c1 10 00 push $0x10c1fc 10c69e: 68 88 aa 12 00 push $0x12aa88 10c6a3: 8d 45 e4 lea -0x1c(%ebp),%eax 10c6a6: 50 push %eax 10c6a7: e8 34 0a 00 00 call 10d0e0 <pthread_create> 10c6ac: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10c6ae: 83 c4 20 add $0x20,%esp 10c6b1: 85 c0 test %eax,%eax
10c6b3: 0f 85 8e 00 00 00 jne 10c747 <rtems_aio_enqueue+0x1f7><== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
10c6b9: ff 05 e4 aa 12 00 incl 0x12aae4 10c6bf: e9 55 ff ff ff jmp 10c619 <rtems_aio_enqueue+0xc9>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10c6c4: 57 push %edi 10c6c5: 6a 01 push $0x1 10c6c7: 8b 43 14 mov 0x14(%ebx),%eax 10c6ca: ff 30 pushl (%eax) 10c6cc: 68 d4 aa 12 00 push $0x12aad4 10c6d1: e8 2a fa ff ff call 10c100 <rtems_aio_search_fd> 10c6d6: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c6d8: 83 c4 10 add $0x10,%esp 10c6db: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c6df: 74 33 je 10c714 <rtems_aio_enqueue+0x1c4> r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
10c6e1: 83 ec 08 sub $0x8,%esp 10c6e4: 53 push %ebx 10c6e5: 83 c7 08 add $0x8,%edi 10c6e8: 57 push %edi 10c6e9: e8 5a fd ff ff call 10c448 <rtems_aio_insert_prio> 10c6ee: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10c6f1: 8b 0d e8 aa 12 00 mov 0x12aae8,%ecx 10c6f7: 85 c9 test %ecx,%ecx
10c6f9: 0f 8e 1a ff ff ff jle 10c619 <rtems_aio_enqueue+0xc9><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10c6ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c702: 68 84 aa 12 00 push $0x12aa84 <== NOT EXECUTED 10c707: e8 b0 03 00 00 call 10cabc <pthread_cond_signal> <== NOT EXECUTED 10c70c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c70f: e9 05 ff ff ff jmp 10c619 <rtems_aio_enqueue+0xc9><== NOT EXECUTED
10c714: 83 ec 08 sub $0x8,%esp 10c717: 53 push %ebx 10c718: 8d 40 08 lea 0x8(%eax),%eax 10c71b: 50 push %eax 10c71c: e8 db 21 00 00 call 10e8fc <_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;
10c721: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c728: 5a pop %edx 10c729: 59 pop %ecx 10c72a: 6a 00 push $0x0 10c72c: 8d 47 1c lea 0x1c(%edi),%eax 10c72f: 50 push %eax 10c730: e8 6b 06 00 00 call 10cda0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c735: 5b pop %ebx 10c736: 58 pop %eax 10c737: 6a 00 push $0x0 10c739: 83 c7 20 add $0x20,%edi 10c73c: 57 push %edi 10c73d: e8 c6 02 00 00 call 10ca08 <pthread_cond_init> 10c742: 83 c4 10 add $0x10,%esp 10c745: eb aa jmp 10c6f1 <rtems_aio_enqueue+0x1a1>
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);
10c747: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c74a: 68 80 aa 12 00 push $0x12aa80 <== NOT EXECUTED 10c74f: e8 20 08 00 00 call 10cf74 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10c754: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c757: 89 de mov %ebx,%esi <== NOT EXECUTED 10c759: e9 cb fe ff ff jmp 10c629 <rtems_aio_enqueue+0xd9><== NOT EXECUTED
0010c1fc <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10c1fc: 55 push %ebp 10c1fd: 89 e5 mov %esp,%ebp 10c1ff: 57 push %edi 10c200: 56 push %esi 10c201: 53 push %ebx 10c202: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10c205: 8b 7d 08 mov 0x8(%ebp),%edi 10c208: 8d 47 1c lea 0x1c(%edi),%eax 10c20b: 89 45 b4 mov %eax,-0x4c(%ebp) 10c20e: 66 90 xchg %ax,%ax
/* 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);
10c210: 83 ec 0c sub $0xc,%esp 10c213: ff 75 b4 pushl -0x4c(%ebp) 10c216: e8 d1 0c 00 00 call 10ceec <pthread_mutex_lock>
if (result != 0)
10c21b: 83 c4 10 add $0x10,%esp 10c21e: 85 c0 test %eax,%eax
10c220: 0f 85 2a 01 00 00 jne 10c350 <rtems_aio_handle+0x154><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c226: 8b 5f 08 mov 0x8(%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 );
10c229: 8d 47 0c lea 0xc(%edi),%eax
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
10c22c: 39 c3 cmp %eax,%ebx
10c22e: 0f 84 d0 00 00 00 je 10c304 <rtems_aio_handle+0x108>
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);
10c234: e8 63 15 00 00 call 10d79c <pthread_self> 10c239: 52 push %edx 10c23a: 8d 55 c0 lea -0x40(%ebp),%edx 10c23d: 52 push %edx 10c23e: 8d 55 e4 lea -0x1c(%ebp),%edx 10c241: 52 push %edx 10c242: 50 push %eax 10c243: e8 20 11 00 00 call 10d368 <pthread_getschedparam>
param.sched_priority = req->priority;
10c248: 8b 43 0c mov 0xc(%ebx),%eax 10c24b: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10c24e: 8b 73 08 mov 0x8(%ebx),%esi 10c251: e8 46 15 00 00 call 10d79c <pthread_self> 10c256: 83 c4 0c add $0xc,%esp 10c259: 8d 55 c0 lea -0x40(%ebp),%edx 10c25c: 52 push %edx 10c25d: 56 push %esi 10c25e: 50 push %eax 10c25f: e8 48 15 00 00 call 10d7ac <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c264: 89 1c 24 mov %ebx,(%esp) 10c267: e8 54 26 00 00 call 10e8c0 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10c26c: 5e pop %esi 10c26d: ff 75 b4 pushl -0x4c(%ebp) 10c270: e8 ff 0c 00 00 call 10cf74 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10c275: 8b 73 14 mov 0x14(%ebx),%esi 10c278: 83 c4 10 add $0x10,%esp 10c27b: 8b 46 2c mov 0x2c(%esi),%eax 10c27e: 83 f8 02 cmp $0x2,%eax
10c281: 74 21 je 10c2a4 <rtems_aio_handle+0xa8>
10c283: 83 f8 03 cmp $0x3,%eax
10c286: 74 6c je 10c2f4 <rtems_aio_handle+0xf8> <== NEVER TAKEN
10c288: 48 dec %eax
10c289: 74 4d je 10c2d8 <rtems_aio_handle+0xdc> <== ALWAYS TAKEN
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
10c28b: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10c292: e8 b5 99 00 00 call 115c4c <__errno> <== NOT EXECUTED 10c297: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10c299: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10c29c: e9 6f ff ff ff jmp 10c210 <rtems_aio_handle+0x14> <== NOT EXECUTED 10c2a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
10c2a4: 83 ec 0c sub $0xc,%esp 10c2a7: ff 76 08 pushl 0x8(%esi) 10c2aa: ff 76 04 pushl 0x4(%esi) 10c2ad: ff 76 10 pushl 0x10(%esi) 10c2b0: ff 76 0c pushl 0xc(%esi) 10c2b3: ff 36 pushl (%esi) 10c2b5: e8 2a a4 00 00 call 1166e4 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c2ba: 83 c4 20 add $0x20,%esp
break;
default:
result = -1;
}
if (result == -1) {
10c2bd: 83 f8 ff cmp $0xffffffff,%eax
10c2c0: 0f 84 78 01 00 00 je 10c43e <rtems_aio_handle+0x242><== NEVER TAKEN
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
10c2c6: 8b 53 14 mov 0x14(%ebx),%edx 10c2c9: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10c2cc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10c2d3: e9 38 ff ff ff jmp 10c210 <rtems_aio_handle+0x14>
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
10c2d8: 83 ec 0c sub $0xc,%esp 10c2db: ff 76 08 pushl 0x8(%esi) 10c2de: ff 76 04 pushl 0x4(%esi) 10c2e1: ff 76 10 pushl 0x10(%esi) 10c2e4: ff 76 0c pushl 0xc(%esi) 10c2e7: ff 36 pushl (%esi) 10c2e9: e8 42 a3 00 00 call 116630 <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c2ee: 83 c4 20 add $0x20,%esp 10c2f1: eb ca jmp 10c2bd <rtems_aio_handle+0xc1> 10c2f3: 90 nop
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10c2f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2f7: ff 36 pushl (%esi) <== NOT EXECUTED 10c2f9: e8 f6 66 00 00 call 1129f4 <fsync> <== NOT EXECUTED
break;
10c2fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c301: eb ba jmp 10c2bd <rtems_aio_handle+0xc1> <== NOT EXECUTED 10c303: 90 nop <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10c304: 83 ec 0c sub $0xc,%esp 10c307: ff 75 b4 pushl -0x4c(%ebp) 10c30a: e8 65 0c 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10c30f: c7 04 24 80 aa 12 00 movl $0x12aa80,(%esp) 10c316: e8 d1 0b 00 00 call 10ceec <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10c31b: 83 c4 10 add $0x10,%esp 10c31e: 3b 5f 08 cmp 0x8(%edi),%ebx
10c321: 74 39 je 10c35c <rtems_aio_handle+0x160><== ALWAYS TAKEN
}
}
/* 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);
10c323: 83 ec 0c sub $0xc,%esp 10c326: 68 80 aa 12 00 push $0x12aa80 10c32b: e8 44 0c 00 00 call 10cf74 <pthread_mutex_unlock> 10c330: 83 c4 10 add $0x10,%esp 10c333: e9 d8 fe ff ff jmp 10c210 <rtems_aio_handle+0x14>
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
10c338: ff 0d e8 aa 12 00 decl 0x12aae8
pthread_mutex_unlock (&aio_request_queue.mutex);
10c33e: 83 ec 0c sub $0xc,%esp 10c341: 68 80 aa 12 00 push $0x12aa80 10c346: e8 29 0c 00 00 call 10cf74 <pthread_mutex_unlock>
return NULL;
10c34b: 83 c4 10 add $0x10,%esp 10c34e: 66 90 xchg %ax,%ax
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c350: 31 c0 xor %eax,%eax 10c352: 8d 65 f4 lea -0xc(%ebp),%esp 10c355: 5b pop %ebx 10c356: 5e pop %esi 10c357: 5f pop %edi 10c358: c9 leave 10c359: c3 ret 10c35a: 66 90 xchg %ax,%ax
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
10c35c: 83 ec 08 sub $0x8,%esp 10c35f: 8d 45 dc lea -0x24(%ebp),%eax 10c362: 50 push %eax 10c363: 6a 01 push $0x1 10c365: e8 66 05 00 00 call 10c8d0 <clock_gettime>
timeout.tv_sec += 3;
10c36a: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10c36e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10c375: 8d 5f 20 lea 0x20(%edi),%ebx 10c378: 83 c4 0c add $0xc,%esp 10c37b: 8d 55 dc lea -0x24(%ebp),%edx 10c37e: 52 push %edx 10c37f: 68 80 aa 12 00 push $0x12aa80 10c384: 53 push %ebx 10c385: e8 b6 07 00 00 call 10cb40 <pthread_cond_timedwait>
&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) {
10c38a: 83 c4 10 add $0x10,%esp 10c38d: 83 f8 74 cmp $0x74,%eax
10c390: 75 91 jne 10c323 <rtems_aio_handle+0x127><== NEVER TAKEN
10c392: 83 ec 0c sub $0xc,%esp 10c395: 57 push %edi 10c396: e8 25 25 00 00 call 10e8c0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
10c39b: 59 pop %ecx 10c39c: ff 75 b4 pushl -0x4c(%ebp) 10c39f: e8 dc 08 00 00 call 10cc80 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10c3a4: 89 1c 24 mov %ebx,(%esp) 10c3a7: e8 90 05 00 00 call 10c93c <pthread_cond_destroy>
free (r_chain);
10c3ac: 89 3c 24 mov %edi,(%esp) 10c3af: e8 80 c7 ff ff call 108b34 <free>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c3b4: 8b 3d d4 aa 12 00 mov 0x12aad4,%edi
pthread_cond_destroy (&r_chain->cond);
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)) {
10c3ba: 83 c4 10 add $0x10,%esp 10c3bd: 81 ff d8 aa 12 00 cmp $0x12aad8,%edi
10c3c3: 74 2b je 10c3f0 <rtems_aio_handle+0x1f4>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
10c3c5: ff 0d e8 aa 12 00 decl 0x12aae8
++aio_request_queue.active_threads;
10c3cb: ff 05 e4 aa 12 00 incl 0x12aae4 10c3d1: 83 ec 0c sub $0xc,%esp 10c3d4: 57 push %edi 10c3d5: e8 e6 24 00 00 call 10e8c0 <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
10c3da: 89 3c 24 mov %edi,(%esp) 10c3dd: e8 de fd ff ff call 10c1c0 <rtems_aio_move_to_work> 10c3e2: 83 c4 10 add $0x10,%esp 10c3e5: 8d 47 1c lea 0x1c(%edi),%eax 10c3e8: 89 45 b4 mov %eax,-0x4c(%ebp) 10c3eb: e9 33 ff ff ff jmp 10c323 <rtems_aio_handle+0x127>
/* 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_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
10c3f0: ff 05 e8 aa 12 00 incl 0x12aae8
--aio_request_queue.active_threads;
10c3f6: ff 0d e4 aa 12 00 decl 0x12aae4
clock_gettime (CLOCK_REALTIME, &timeout);
10c3fc: 52 push %edx 10c3fd: 52 push %edx 10c3fe: 8d 45 dc lea -0x24(%ebp),%eax 10c401: 50 push %eax 10c402: 6a 01 push $0x1 10c404: e8 c7 04 00 00 call 10c8d0 <clock_gettime>
timeout.tv_sec += 3;
10c409: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10c40d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10c414: 83 c4 0c add $0xc,%esp 10c417: 8d 55 dc lea -0x24(%ebp),%edx 10c41a: 52 push %edx 10c41b: 68 80 aa 12 00 push $0x12aa80 10c420: 68 84 aa 12 00 push $0x12aa84 10c425: e8 16 07 00 00 call 10cb40 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10c42a: 83 c4 10 add $0x10,%esp 10c42d: 83 f8 74 cmp $0x74,%eax
10c430: 0f 84 02 ff ff ff je 10c338 <rtems_aio_handle+0x13c><== ALWAYS TAKEN
10c436: 8b 3d d4 aa 12 00 mov 0x12aad4,%edi <== NOT EXECUTED 10c43c: eb 87 jmp 10c3c5 <rtems_aio_handle+0x1c9><== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
10c43e: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED 10c441: e9 45 fe ff ff jmp 10c28b <rtems_aio_handle+0x8f> <== NOT EXECUTED
0010bfd8 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10bfd8: 55 push %ebp 10bfd9: 89 e5 mov %esp,%ebp 10bfdb: 53 push %ebx 10bfdc: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10bfdf: 68 88 aa 12 00 push $0x12aa88 10bfe4: e8 a3 10 00 00 call 10d08c <pthread_attr_init> 10bfe9: 89 c3 mov %eax,%ebx
if (result != 0)
10bfeb: 83 c4 10 add $0x10,%esp 10bfee: 85 c0 test %eax,%eax
10bff0: 74 0a je 10bffc <rtems_aio_init+0x24> <== ALWAYS TAKEN
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
10bff2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bff4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bff7: c9 leave <== NOT EXECUTED 10bff8: c3 ret <== NOT EXECUTED 10bff9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
10bffc: 83 ec 08 sub $0x8,%esp 10bfff: 6a 00 push $0x0 10c001: 68 88 aa 12 00 push $0x12aa88 10c006: e8 ad 10 00 00 call 10d0b8 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10c00b: 83 c4 10 add $0x10,%esp 10c00e: 85 c0 test %eax,%eax
10c010: 0f 85 96 00 00 00 jne 10c0ac <rtems_aio_init+0xd4> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10c016: 83 ec 08 sub $0x8,%esp 10c019: 6a 00 push $0x0 10c01b: 68 80 aa 12 00 push $0x12aa80 10c020: e8 7b 0d 00 00 call 10cda0 <pthread_mutex_init>
if (result != 0)
10c025: 83 c4 10 add $0x10,%esp 10c028: 85 c0 test %eax,%eax
10c02a: 0f 85 b8 00 00 00 jne 10c0e8 <rtems_aio_init+0x110> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10c030: 83 ec 08 sub $0x8,%esp 10c033: 6a 00 push $0x0 10c035: 68 84 aa 12 00 push $0x12aa84 10c03a: e8 c9 09 00 00 call 10ca08 <pthread_cond_init> 10c03f: 89 c3 mov %eax,%ebx
if (result != 0) {
10c041: 83 c4 10 add $0x10,%esp 10c044: 85 c0 test %eax,%eax
10c046: 75 7c jne 10c0c4 <rtems_aio_init+0xec> <== NEVER TAKEN
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c048: c7 05 c8 aa 12 00 cc movl $0x12aacc,0x12aac8
10c04f: aa 12 00 head->previous = NULL;
10c052: c7 05 cc aa 12 00 00 movl $0x0,0x12aacc
10c059: 00 00 00 tail->previous = head;
10c05c: c7 05 d0 aa 12 00 c8 movl $0x12aac8,0x12aad0
10c063: aa 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c066: c7 05 d4 aa 12 00 d8 movl $0x12aad8,0x12aad4
10c06d: aa 12 00 head->previous = NULL;
10c070: c7 05 d8 aa 12 00 00 movl $0x0,0x12aad8
10c077: 00 00 00 tail->previous = head;
10c07a: c7 05 dc aa 12 00 d4 movl $0x12aad4,0x12aadc
10c081: aa 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;
10c084: c7 05 e4 aa 12 00 00 movl $0x0,0x12aae4
10c08b: 00 00 00 aio_request_queue.idle_threads = 0;
10c08e: c7 05 e8 aa 12 00 00 movl $0x0,0x12aae8
10c095: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10c098: c7 05 e0 aa 12 00 0b movl $0xb00b,0x12aae0
10c09f: b0 00 00
return result;
}
10c0a2: 89 d8 mov %ebx,%eax 10c0a4: 8b 5d fc mov -0x4(%ebp),%ebx 10c0a7: c9 leave 10c0a8: c3 ret 10c0a9: 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);
10c0ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0af: 68 88 aa 12 00 push $0x12aa88 <== NOT EXECUTED 10c0b4: e8 af 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED 10c0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0bc: e9 55 ff ff ff jmp 10c016 <rtems_aio_init+0x3e> <== NOT EXECUTED 10c0c1: 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);
10c0c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0c7: 68 80 aa 12 00 push $0x12aa80 <== NOT EXECUTED 10c0cc: e8 af 0b 00 00 call 10cc80 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10c0d1: c7 04 24 88 aa 12 00 movl $0x12aa88,(%esp) <== NOT EXECUTED 10c0d8: e8 8b 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED 10c0dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0e0: e9 63 ff ff ff jmp 10c048 <rtems_aio_init+0x70> <== NOT EXECUTED 10c0e5: 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);
10c0e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0eb: 68 88 aa 12 00 push $0x12aa88 <== NOT EXECUTED 10c0f0: e8 73 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED 10c0f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0f8: e9 33 ff ff ff jmp 10c030 <rtems_aio_init+0x58> <== NOT EXECUTED
0010c448 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10c448: 55 push %ebp 10c449: 89 e5 mov %esp,%ebp 10c44b: 56 push %esi 10c44c: 53 push %ebx 10c44d: 8b 55 08 mov 0x8(%ebp),%edx 10c450: 8b 75 0c mov 0xc(%ebp),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c453: 8b 02 mov (%edx),%eax 10c455: 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)) {
10c458: 39 c8 cmp %ecx,%eax
10c45a: 74 27 je 10c483 <rtems_aio_insert_prio+0x3b><== 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 &&
10c45c: 8b 56 14 mov 0x14(%esi),%edx 10c45f: 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;
10c462: 8b 50 14 mov 0x14(%eax),%edx
while (req->aiocbp->aio_reqprio > prio &&
10c465: 39 5a 14 cmp %ebx,0x14(%edx)
10c468: 7c 06 jl 10c470 <rtems_aio_insert_prio+0x28><== NEVER TAKEN
10c46a: eb 0e jmp 10c47a <rtems_aio_insert_prio+0x32>
10c46c: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c46e: 74 1c je 10c48c <rtems_aio_insert_prio+0x44><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c470: 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;
10c472: 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 &&
10c475: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED 10c478: 7c f2 jl 10c46c <rtems_aio_insert_prio+0x24><== 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 );
10c47a: 89 75 0c mov %esi,0xc(%ebp) 10c47d: 8b 40 04 mov 0x4(%eax),%eax 10c480: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10c483: 5b pop %ebx 10c484: 5e pop %esi 10c485: c9 leave 10c486: e9 71 24 00 00 jmp 10e8fc <_Chain_Insert> 10c48b: 90 nop
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c48c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c48e: eb ea jmp 10c47a <rtems_aio_insert_prio+0x32><== NOT EXECUTED
0010c1c0 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10c1c0: 55 push %ebp 10c1c1: 89 e5 mov %esp,%ebp 10c1c3: 83 ec 08 sub $0x8,%esp 10c1c6: 8b 4d 08 mov 0x8(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1c9: a1 c8 aa 12 00 mov 0x12aac8,%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10c1ce: 8b 51 14 mov 0x14(%ecx),%edx 10c1d1: 39 50 14 cmp %edx,0x14(%eax)
10c1d4: 7c 09 jl 10c1df <rtems_aio_move_to_work+0x1f><== ALWAYS TAKEN
10c1d6: eb 13 jmp 10c1eb <rtems_aio_move_to_work+0x2b><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1d8: 8b 00 mov (%eax),%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10c1da: 39 50 14 cmp %edx,0x14(%eax)
10c1dd: 7d 0c jge 10c1eb <rtems_aio_move_to_work+0x2b>
10c1df: 3d cc aa 12 00 cmp $0x12aacc,%eax
10c1e4: 75 f2 jne 10c1d8 <rtems_aio_move_to_work+0x18><== ALWAYS TAKEN
10c1e6: b8 cc aa 12 00 mov $0x12aacc,%eax <== NOT EXECUTED
10c1eb: 83 ec 08 sub $0x8,%esp 10c1ee: 51 push %ecx 10c1ef: ff 70 04 pushl 0x4(%eax) 10c1f2: e8 05 27 00 00 call 10e8fc <_Chain_Insert> 10c1f7: 83 c4 10 add $0x10,%esp
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
10c1fa: c9 leave 10c1fb: c3 ret
0010c490 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10c490: 55 push %ebp 10c491: 89 e5 mov %esp,%ebp 10c493: 57 push %edi 10c494: 56 push %esi 10c495: 53 push %ebx 10c496: 83 ec 0c sub $0xc,%esp 10c499: 8b 7d 08 mov 0x8(%ebp),%edi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c49c: 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));
10c49f: 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))
10c4a2: 39 fb cmp %edi,%ebx
10c4a4: 75 04 jne 10c4aa <rtems_aio_remove_fd+0x1a><== ALWAYS TAKEN
10c4a6: eb 2d jmp 10c4d5 <rtems_aio_remove_fd+0x45><== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
10c4a8: 89 f3 mov %esi,%ebx
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c4aa: 83 ec 0c sub $0xc,%esp 10c4ad: 53 push %ebx 10c4ae: e8 0d 24 00 00 call 10e8c0 <_Chain_Extract>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4b3: 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;
10c4b5: 8b 43 14 mov 0x14(%ebx),%eax 10c4b8: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
req->aiocbp->return_value = -1;
10c4bf: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (req);
10c4c6: 89 1c 24 mov %ebx,(%esp) 10c4c9: e8 66 c6 ff ff call 108b34 <free>
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10c4ce: 83 c4 10 add $0x10,%esp 10c4d1: 39 fe cmp %edi,%esi
10c4d3: 75 d3 jne 10c4a8 <rtems_aio_remove_fd+0x18>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10c4d5: 8d 65 f4 lea -0xc(%ebp),%esp 10c4d8: 5b pop %ebx 10c4d9: 5e pop %esi 10c4da: 5f pop %edi 10c4db: c9 leave 10c4dc: c3 ret
0010c4e0 <rtems_aio_remove_req>:
* 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)
{
10c4e0: 55 push %ebp 10c4e1: 89 e5 mov %esp,%ebp 10c4e3: 53 push %ebx 10c4e4: 83 ec 04 sub $0x4,%esp 10c4e7: 8b 55 08 mov 0x8(%ebp),%edx 10c4ea: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4ed: 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 );
10c4ef: 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))
10c4f2: 39 d0 cmp %edx,%eax
10c4f4: 74 4e je 10c544 <rtems_aio_remove_req+0x64>
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
10c4f6: 89 c3 mov %eax,%ebx
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c4f8: 39 48 14 cmp %ecx,0x14(%eax)
10c4fb: 75 0a jne 10c507 <rtems_aio_remove_req+0x27><== NEVER TAKEN
10c4fd: eb 19 jmp 10c518 <rtems_aio_remove_req+0x38> 10c4ff: 90 nop
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10c500: 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) {
10c502: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED 10c505: 74 11 je 10c518 <rtems_aio_remove_req+0x38><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c507: 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) {
10c509: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c50b: 75 f3 jne 10c500 <rtems_aio_remove_req+0x20><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10c50d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c512: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c515: c9 leave <== NOT EXECUTED 10c516: c3 ret <== NOT EXECUTED 10c517: 90 nop <== NOT EXECUTED
10c518: 83 ec 0c sub $0xc,%esp 10c51b: 50 push %eax 10c51c: e8 9f 23 00 00 call 10e8c0 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10c521: 8b 43 14 mov 0x14(%ebx),%eax 10c524: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10c52b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10c532: 89 1c 24 mov %ebx,(%esp) 10c535: e8 fa c5 ff ff call 108b34 <free>
}
return AIO_CANCELED;
10c53a: 83 c4 10 add $0x10,%esp 10c53d: 31 c0 xor %eax,%eax
}
10c53f: 8b 5d fc mov -0x4(%ebp),%ebx 10c542: c9 leave 10c543: c3 ret
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10c544: b8 02 00 00 00 mov $0x2,%eax
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c549: 8b 5d fc mov -0x4(%ebp),%ebx 10c54c: c9 leave 10c54d: c3 ret
0010c100 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
10c100: 55 push %ebp 10c101: 89 e5 mov %esp,%ebp 10c103: 57 push %edi 10c104: 56 push %esi 10c105: 53 push %ebx 10c106: 83 ec 1c sub $0x1c,%esp 10c109: 8b 75 08 mov 0x8(%ebp),%esi 10c10c: 8b 5d 0c mov 0xc(%ebp),%ebx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c10f: 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)) {
10c111: 8b 50 14 mov 0x14(%eax),%edx 10c114: 39 d3 cmp %edx,%ebx
10c116: 7e 28 jle 10c140 <rtems_aio_search_fd+0x40>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c118: 8d 4e 04 lea 0x4(%esi),%ecx 10c11b: eb 0c jmp 10c129 <rtems_aio_search_fd+0x29> 10c11d: 8d 76 00 lea 0x0(%esi),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c120: 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)) {
10c122: 8b 50 14 mov 0x14(%eax),%edx 10c125: 39 da cmp %ebx,%edx
10c127: 7d 17 jge 10c140 <rtems_aio_search_fd+0x40>
10c129: 39 c8 cmp %ecx,%eax
10c12b: 75 f3 jne 10c120 <rtems_aio_search_fd+0x20>
10c12d: 89 c7 mov %eax,%edi
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
10c12f: 8b 45 10 mov 0x10(%ebp),%eax 10c132: 85 c0 test %eax,%eax
10c134: 75 1f jne 10c155 <rtems_aio_search_fd+0x55>
r_chain = NULL;
10c136: 31 c0 xor %eax,%eax
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c138: 8d 65 f4 lea -0xc(%ebp),%esp 10c13b: 5b pop %ebx 10c13c: 5e pop %esi 10c13d: 5f pop %edi 10c13e: c9 leave 10c13f: c3 ret
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c140: 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)
10c142: 39 d3 cmp %edx,%ebx
10c144: 75 e9 jne 10c12f <rtems_aio_search_fd+0x2f>
r_chain->new_fd = 0;
10c146: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c14d: 8d 65 f4 lea -0xc(%ebp),%esp 10c150: 5b pop %ebx 10c151: 5e pop %esi 10c152: 5f pop %edi 10c153: c9 leave 10c154: c3 ret
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
10c155: 83 ec 0c sub $0xc,%esp 10c158: 6a 24 push $0x24 10c15a: e8 e9 ce ff ff call 109048 <malloc> 10c15f: 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 );
10c161: 8d 4a 0c lea 0xc(%edx),%ecx 10c164: 89 4a 08 mov %ecx,0x8(%edx)
head->next = tail;
head->previous = NULL;
10c167: 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 );
10c16e: 8d 4a 08 lea 0x8(%edx),%ecx 10c171: 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 );
10c174: 8d 4e 04 lea 0x4(%esi),%ecx
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
10c177: 83 c4 10 add $0x10,%esp 10c17a: 39 0e cmp %ecx,(%esi)
10c17c: 74 27 je 10c1a5 <rtems_aio_search_fd+0xa5>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10c17e: 83 ec 08 sub $0x8,%esp 10c181: 52 push %edx 10c182: ff 77 04 pushl 0x4(%edi) 10c185: 89 45 e4 mov %eax,-0x1c(%ebp) 10c188: 89 55 e0 mov %edx,-0x20(%ebp) 10c18b: e8 6c 27 00 00 call 10e8fc <_Chain_Insert> 10c190: 83 c4 10 add $0x10,%esp 10c193: 8b 55 e0 mov -0x20(%ebp),%edx 10c196: 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;
10c199: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx)
r_chain->fildes = fildes;
10c1a0: 89 5a 14 mov %ebx,0x14(%edx) 10c1a3: eb a8 jmp 10c14d <rtems_aio_search_fd+0x4d>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10c1a5: 83 ec 08 sub $0x8,%esp 10c1a8: 52 push %edx 10c1a9: 56 push %esi 10c1aa: 89 45 e4 mov %eax,-0x1c(%ebp) 10c1ad: 89 55 e0 mov %edx,-0x20(%ebp) 10c1b0: e8 47 27 00 00 call 10e8fc <_Chain_Insert> 10c1b5: 83 c4 10 add $0x10,%esp 10c1b8: 8b 45 e4 mov -0x1c(%ebp),%eax 10c1bb: 8b 55 e0 mov -0x20(%ebp),%edx 10c1be: eb d9 jmp 10c199 <rtems_aio_search_fd+0x99>
00113684 <rtems_barrier_create>:
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 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
1136a1: 85 f6 test %esi,%esi
1136a3: 0f 84 bf 00 00 00 je 113768 <rtems_barrier_create+0xe4><== 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 <rtems_barrier_create+0xb4>
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 <rtems_barrier_create+0xc0><== 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 30 a8 12 00 mov 0x12a830,%eax 1136cc: 40 inc %eax 1136cd: a3 30 a8 12 00 mov %eax,0x12a830
* 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 60 b2 12 00 push $0x12b260 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 <rtems_barrier_create+0xd0>
_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 7c b2 12 00 mov 0x12b27c,%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 <rtems_barrier_create+0x40> 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 <rtems_barrier_create+0x99>
0010c14c <rtems_chain_append_with_notification>:
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 <rtems_chain_append_with_notification+0x2c><== 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 10c173: c9 leave 10c174: c3 ret 10c175: 8d 76 00 lea 0x0(%esi),%esi
{
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 <rtems_event_send>
0010c18c <rtems_chain_get_with_notification>:
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 <rtems_chain_get_with_notification+0x2c>
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 <rtems_event_send>
0010c1cc <rtems_chain_get_with_wait>:
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_chain_get_with_wait+0x44>
) {
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_event_receive>
)
{
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 <rtems_chain_get_with_wait+0x10><== 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_prepend_with_notification>:
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 <rtems_chain_prepend_with_notification+0x2c><== 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 <rtems_event_send>
00115a60 <rtems_clock_get>:
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 <rtems_clock_get+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
115a71: 85 c0 test %eax,%eax
115a73: 74 2b je 115aa0 <rtems_clock_get+0x40>
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 <rtems_clock_get+0x58>
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 <rtems_clock_get+0x64>
*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 <rtems_clock_get+0x70>
*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 <rtems_clock_get+0x34>
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 <rtems_clock_get_tod_timeval> 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 <rtems_clock_get_tod> 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 <rtems_clock_get_seconds_since_epoch> 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 <rtems_clock_get_ticks_since_boot> 115ac9: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115acb: 31 c0 xor %eax,%eax 115acd: eb bf jmp 115a8e <rtems_clock_get+0x2e> 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 <rtems_clock_get_ticks_per_second> 115ad5: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115ad7: 31 c0 xor %eax,%eax 115ad9: eb b3 jmp 115a8e <rtems_clock_get+0x2e>
00115be0 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
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 <rtems_clock_get_tod_timeval+0x60>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
115bef: 80 3d e4 2a 14 00 00 cmpb $0x0,0x142ae4
115bf6: 75 0c jne 115c04 <rtems_clock_get_tod_timeval+0x24>
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 <rtems_clock_get_tod_timeval+0x1d>
0010b1d4 <rtems_clock_get_uptime>:
* 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 <rtems_clock_get_uptime+0x20>
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_clock_set>:
*/
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 <rtems_clock_set+0x74>
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 <rtems_clock_set+0x28>
_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 cc 72 12 00 imul 0x1272cc,%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 50 34 13 00 mov 0x133450,%eax 10c176: 40 inc %eax 10c177: a3 50 34 13 00 mov %eax,0x133450
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 <rtems_clock_tick>:
*
* 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 3c 7f 12 00 push $0x127f3c 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 24 84 12 00 mov 0x128424,%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 <rtems_clock_tick+0x32>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
10aff9: a1 30 7e 12 00 mov 0x127e30,%eax 10affe: 85 c0 test %eax,%eax
10b000: 74 06 je 10b008 <rtems_clock_tick+0x38>
_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_event_send>:
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 <rtems_event_send+0x48>
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 <rtems_extension_delete>:
#include <rtems/extension.h>
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 c0 30 13 00 push $0x1330c0 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 <rtems_extension_delete+0x5c>
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 c0 30 13 00 push $0x1330c0 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 c0 30 13 00 push $0x1330c0 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_io_close>:
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 e0 88 12 00 cmp %eax,0x1288e0
113008: 76 1a jbe 113024 <rtems_io_close+0x2c>
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 e4 88 12 00 add 0x1288e4,%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 <rtems_io_close+0x38> }
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_io_control>:
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 e0 88 12 00 cmp %eax,0x1288e0
113048: 76 1a jbe 113064 <rtems_io_control+0x2c>
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 e4 88 12 00 add 0x1288e4,%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 <rtems_io_control+0x38> }
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_io_initialize>:
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 e0 88 12 00 cmp %eax,0x1288e0
111024: 76 1a jbe 111040 <rtems_io_initialize+0x2c>
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 e4 88 12 00 add 0x1288e4,%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 <rtems_io_initialize+0x38> }
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_io_open>:
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 e0 88 12 00 cmp %eax,0x1288e0
113088: 76 1a jbe 1130a4 <rtems_io_open+0x2c>
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 e4 88 12 00 add 0x1288e4,%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 <rtems_io_open+0x38> }
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_io_read>:
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 e0 88 12 00 cmp %eax,0x1288e0
1130c8: 76 1a jbe 1130e4 <rtems_io_read+0x2c>
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 e4 88 12 00 add 0x1288e4,%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 <rtems_io_read+0x38> }
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_io_register_driver>:
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 c0 c5 12 00 mov 0x12c5c0,%eax
if ( rtems_interrupt_is_in_progress() )
10cee3: 8b 0d f4 c0 12 00 mov 0x12c0f4,%ecx 10cee9: 85 c9 test %ecx,%ecx
10ceeb: 0f 85 ab 00 00 00 jne 10cf9c <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10cef1: 85 d2 test %edx,%edx
10cef3: 0f 84 e7 00 00 00 je 10cfe0 <rtems_io_register_driver+0x114>
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 <rtems_io_register_driver+0x114>
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 <rtems_io_register_driver+0x108>
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_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10cf11: a1 10 bb 12 00 mov 0x12bb10,%eax 10cf16: 40 inc %eax 10cf17: a3 10 bb 12 00 mov %eax,0x12bb10
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 <rtems_io_register_driver+0xe0>
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 c0 c5 12 00 mov 0x12c5c0,%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 <rtems_io_register_driver+0x121><== NEVER TAKEN
10cf32: 8b 3d c4 c5 12 00 mov 0x12c5c4,%edi 10cf38: 89 f8 mov %edi,%eax 10cf3a: eb 08 jmp 10cf44 <rtems_io_register_driver+0x78> 10cf3c: 43 inc %ebx 10cf3d: 83 c0 18 add $0x18,%eax 10cf40: 39 d9 cmp %ebx,%ecx
10cf42: 76 0b jbe 10cf4f <rtems_io_register_driver+0x83>
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 <rtems_io_register_driver+0x70>
10cf49: 83 78 04 00 cmpl $0x0,0x4(%eax)
10cf4d: 75 ed jne 10cf3c <rtems_io_register_driver+0x70>
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 <rtems_io_register_driver+0x128>
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 <rtems_io_initialize> 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 c4 c5 12 00 mov 0x12c5c4,%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 <rtems_io_register_driver+0x134>
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 <rtems_io_register_driver+0x41>
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 <rtems_io_register_driver+0xc5>
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 <rtems_io_register_driver+0xf4>
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 c4 c5 12 00 mov 0x12c5c4,%edi 10d00f: e9 4b ff ff ff jmp 10cf5f <rtems_io_register_driver+0x93>
0010d014 <rtems_io_unregister_driver>:
*/
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 f4 c0 12 00 mov 0x12c0f4,%ecx 10d024: 85 c9 test %ecx,%ecx
10d026: 75 44 jne 10d06c <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10d028: 39 05 c0 c5 12 00 cmp %eax,0x12c5c0
10d02e: 77 0c ja 10d03c <rtems_io_unregister_driver+0x28>
_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 10 bb 12 00 mov 0x12bb10,%edx 10d042: 42 inc %edx 10d043: 89 15 10 bb 12 00 mov %edx,0x12bb10
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 c4 c5 12 00 add 0x12c5c4,%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_io_write>:
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 e0 88 12 00 cmp %eax,0x1288e0
113108: 76 1a jbe 113124 <rtems_io_write+0x2c>
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 e4 88 12 00 add 0x1288e4,%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 <rtems_io_write+0x38> }
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 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
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 <rtems_iterate_over_all_threads+0x59><== 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 28 34 13 00 mov 0x133428(,%edx,4),%eax 10dfdd: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10dfe0: 85 f6 test %esi,%esi
10dfe2: 74 28 je 10e00c <rtems_iterate_over_all_threads+0x50>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10dfe4: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10dfe9: 74 21 je 10e00c <rtems_iterate_over_all_threads+0x50>
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 <rtems_iterate_over_all_threads+0x47><== 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 <rtems_iterate_over_all_threads+0x34>
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 <rtems_iterate_over_all_threads+0x17>
(*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_message_queue_broadcast>:
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 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
1163d2: 85 f6 test %esi,%esi
1163d4: 74 5e je 116434 <rtems_message_queue_broadcast+0x78>
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 00 35 14 00 push $0x143500 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 <rtems_message_queue_broadcast+0x44>
#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 <rtems_message_queue_create>:
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 <rtems_message_queue_create+0x48>
return RTEMS_INVALID_NAME;
if ( !id )
113871: 85 ff test %edi,%edi
113873: 0f 84 a3 00 00 00 je 11391c <rtems_message_queue_create+0xc4>
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 <rtems_message_queue_create+0x38>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
11387d: 85 c9 test %ecx,%ecx
11387f: 75 2f jne 1138b0 <rtems_message_queue_create+0x58>
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 06 13 00 mov 0x1306f0,%eax 1138b5: 40 inc %eax 1138b6: a3 f0 06 13 00 mov %eax,0x1306f0
#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 <rtems_message_queue_create+0xf0>
_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_message_queue_create+0xd0>
*/
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 11 13 00 push $0x131120 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 <rtems_message_queue_create+0x2e> 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 <rtems_message_queue_create+0x2e> 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 11 13 00 mov 0x13113c,%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 <rtems_message_queue_create+0x2e>
_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 <rtems_message_queue_create+0x2e>
00116544 <rtems_message_queue_delete>:
*/
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 00 35 14 00 push $0x143500 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 <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
116568: 83 ec 08 sub $0x8,%esp 11656b: 50 push %eax 11656c: 68 00 35 14 00 push $0x143500 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 00 35 14 00 push $0x143500 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_message_queue_flush>:
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 <rtems_message_queue_flush+0x54>
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 00 35 14 00 push $0x143500 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 <rtems_message_queue_flush+0x34>
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_message_queue_get_number_pending>:
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 <rtems_message_queue_get_number_pending+0x48>
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 00 35 14 00 push $0x143500 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 <rtems_message_queue_get_number_pending+0x34>
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 <rtems_message_queue_receive>:
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 <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
11398e: 85 f6 test %esi,%esi
113990: 74 6a je 1139fc <rtems_message_queue_receive+0x80>
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 11 13 00 push $0x131120 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 <rtems_message_queue_receive+0x74>
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 0c 13 00 mov 0x130cd8,%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_message_queue_send>:
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 <rtems_message_queue_send+0x70>
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 60 88 12 00 push $0x128860 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 <rtems_message_queue_send+0x38>
#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_message_queue_urgent>:
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 <rtems_message_queue_urgent+0x70>
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 00 35 14 00 push $0x143500 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 <rtems_message_queue_urgent+0x38>
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 <rtems_object_get_api_name>:
};
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 e0 7c 12 00 push $0x127ce0 10b986: e8 b9 49 00 00 call 110344 <rtems_assoc_ptr_by_local>
if ( api_assoc )
10b98b: 83 c4 10 add $0x10,%esp 10b98e: 85 c0 test %eax,%eax
10b990: 74 06 je 10b998 <rtems_object_get_api_name+0x20>
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 03 2d 12 00 mov $0x122d03,%eax
}
10b99d: c9 leave 10b99e: c3 ret
0010cf60 <rtems_object_get_class_information>:
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 <rtems_object_get_class_information+0x70>
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 <rtems_object_get_class_information+0x80>
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 <rtems_object_get_class_information+0x87><== 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 <rtems_object_get_class_information+0x54>
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 <rtems_object_get_class_information+0x67>
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 <rtems_object_get_class_information+0x62>
0010c520 <rtems_object_get_classic_name>:
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 <rtems_object_get_classic_name+0x34>
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 ec 38 12 00 mov 0x1238ec(,%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_object_set_name>:
*/
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 <rtems_object_set_name+0x74>
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 <rtems_object_set_name+0x4c>
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 <rtems_object_set_name+0x3f>
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 <rtems_object_set_name+0x58>
#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 d8 a6 12 00 mov 0x12a6d8,%eax 10b9fd: 8b 70 08 mov 0x8(%eax),%esi 10ba00: eb c1 jmp 10b9c3 <rtems_object_set_name+0x17> 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 <rtems_object_set_name+0x44>
0011681c <rtems_partition_create>:
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 <rtems_partition_create+0x60>
return RTEMS_INVALID_NAME;
if ( !starting_address )
116835: 85 f6 test %esi,%esi
116837: 74 23 je 11685c <rtems_partition_create+0x40>
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 <rtems_partition_create+0x40><== 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 <rtems_partition_create+0x50>
116844: 85 ff test %edi,%edi
116846: 74 24 je 11686c <rtems_partition_create+0x50>
116848: 39 fa cmp %edi,%edx
11684a: 72 20 jb 11686c <rtems_partition_create+0x50>
11684c: f7 c7 03 00 00 00 test $0x3,%edi
116852: 75 18 jne 11686c <rtems_partition_create+0x50>
!_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 <rtems_partition_create+0x70>
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 d0 2a 14 00 mov 0x142ad0,%eax 116891: 40 inc %eax 116892: a3 d0 2a 14 00 mov %eax,0x142ad0
* 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 60 29 14 00 push $0x142960 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 <rtems_partition_create+0xf0>
_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 7c 29 14 00 mov 0x14297c,%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 <rtems_partition_create+0x55> 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 <rtems_partition_create+0x55>
00116988 <rtems_partition_get_buffer>:
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 <rtems_partition_get_buffer+0x68>
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 60 29 14 00 push $0x142960 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_partition_get_buffer+0x5c>
*/
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 <rtems_partition_get_buffer+0x74>
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 <rtems_partition_get_buffer+0x61>
00116a2c <rtems_partition_return_buffer>:
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 60 29 14 00 push $0x142960 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 <rtems_partition_return_buffer+0x34>
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_partition_return_buffer+0x78>
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 <rtems_partition_return_buffer+0x78><== 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_partition_return_buffer+0x78>
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 <rtems_port_create>:
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 <rtems_port_create+0x34>
return RTEMS_INVALID_NAME;
if ( !id )
115e69: 85 f6 test %esi,%esi
115e6b: 74 08 je 115e75 <rtems_port_create+0x25>
* 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 <rtems_port_create+0x44>
!_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 d0 2a 14 00 mov 0x142ad0,%eax 115e99: 40 inc %eax 115e9a: a3 d0 2a 14 00 mov %eax,0x142ad0
*/
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 20 29 14 00 push $0x142920 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 <rtems_port_create+0x9c>
_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 3c 29 14 00 mov 0x14293c,%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 <rtems_port_create+0x2a>
00115ef8 <rtems_port_delete>:
*/
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 20 29 14 00 push $0x142920 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 <rtems_port_delete+0x50>
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 20 29 14 00 push $0x142920 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 20 29 14 00 push $0x142920 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_port_external_to_internal>:
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 <rtems_port_external_to_internal+0x60>
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 20 29 14 00 push $0x142920 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 <rtems_port_external_to_internal+0x3c>
#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_port_external_to_internal+0x5c>
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 <rtems_port_external_to_internal+0x4b>
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_port_internal_to_external>:
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 <rtems_port_internal_to_external+0x60><== 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 20 29 14 00 push $0x142920 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 <rtems_port_internal_to_external+0x3c>
#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_port_internal_to_external+0x5c>
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 <rtems_port_internal_to_external+0x4b>
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_rate_monotonic_cancel>:
*/
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 a0 29 14 00 push $0x1429a0 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 <rtems_rate_monotonic_cancel+0x30>
#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 b8 30 14 00 mov 0x1430b8,%eax 116aed: 39 43 40 cmp %eax,0x40(%ebx)
116af0: 74 12 je 116b04 <rtems_rate_monotonic_cancel+0x4c>
_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 <rtems_rate_monotonic_cancel+0x29>
0010c340 <rtems_rate_monotonic_create>:
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 <rtems_rate_monotonic_create+0xc0>
return RTEMS_INVALID_NAME;
if ( !id )
10c357: 85 f6 test %esi,%esi
10c359: 0f 84 c5 00 00 00 je 10c424 <rtems_rate_monotonic_create+0xe4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c35f: a1 b0 b1 12 00 mov 0x12b1b0,%eax 10c364: 40 inc %eax 10c365: a3 b0 b1 12 00 mov %eax,0x12b1b0
* 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 c0 b0 12 00 push $0x12b0c0 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 <rtems_rate_monotonic_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10c384: a1 98 b7 12 00 mov 0x12b798,%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 dc b0 12 00 mov 0x12b0dc,%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_rate_monotonic_get_status>:
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 <rtems_rate_monotonic_get_status+0xa4>
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 c0 b0 12 00 push $0x12b0c0 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 <rtems_rate_monotonic_get_status+0x38>
#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 <rtems_rate_monotonic_get_status+0x74>
#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 <rtems_rate_monotonic_get_status+0xb0>
_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 <rtems_rate_monotonic_get_status+0x66>
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 <rtems_rate_monotonic_get_status+0x33>
0010c654 <rtems_rate_monotonic_period>:
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 c0 b0 12 00 push $0x12b0c0 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 <rtems_rate_monotonic_period+0x38>
#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 98 b7 12 00 mov 0x12b798,%edx 10c692: 39 50 40 cmp %edx,0x40(%eax)
10c695: 74 15 je 10c6ac <rtems_rate_monotonic_period+0x58>
_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 <rtems_rate_monotonic_period+0x78>
switch ( the_period->state ) {
10c6b0: 8b 40 38 mov 0x38(%eax),%eax 10c6b3: 83 f8 04 cmp $0x4,%eax
10c6b6: 77 6c ja 10c724 <rtems_rate_monotonic_period+0xd0><== NEVER TAKEN
10c6b8: 8b 04 85 bc 3d 12 00 mov 0x123dbc(,%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 <rtems_rate_monotonic_period+0x2d>
}
_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 <rtems_rate_monotonic_period+0xd4>
_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 <rtems_rate_monotonic_period+0x129>
_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 <rtems_rate_monotonic_period+0x28><== 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 bc b2 12 00 push $0x12b2bc 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 <rtems_rate_monotonic_period+0x2d>
_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 <rtems_rate_monotonic_period+0x6b><== 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 bc b2 12 00 push $0x12b2bc 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 <rtems_rate_monotonic_period+0x2d>
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 98 b7 12 00 mov 0x12b798,%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 <rtems_rate_monotonic_period+0x186>
_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 <rtems_rate_monotonic_period+0x2d>
/*
* 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 98 b7 12 00 pushl 0x12b798 10c7e7: e8 84 27 00 00 call 10ef70 <_Thread_Clear_state> 10c7ec: 83 c4 10 add $0x10,%esp 10c7ef: eb dd jmp 10c7ce <rtems_rate_monotonic_period+0x17a>
0010c7f4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
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 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10c80e: 83 ec 08 sub $0x8,%esp 10c811: 68 d0 3d 12 00 push $0x123dd0 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 08 3e 12 00 push $0x123e08 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 2c 3e 12 00 push $0x123e2c 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 50 3e 12 00 push $0x123e50 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 9c 3e 12 00 push $0x123e9c 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 c8 b0 12 00 mov 0x12b0c8,%ebx 10c84c: 83 c4 10 add $0x10,%esp 10c84f: 3b 1d cc b0 12 00 cmp 0x12b0cc,%ebx
10c855: 77 75 ja 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
10c857: 8d 7d 88 lea -0x78(%ebp),%edi 10c85a: eb 09 jmp 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71>
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 cc b0 12 00 cmp %ebx,0x12b0cc
10c863: 72 67 jb 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8>
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 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10c86f: 83 c4 10 add $0x10,%esp 10c872: 85 c0 test %eax,%eax
10c874: 75 e6 jne 10c85c <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
#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 <rtems_rate_monotonic_get_status>
#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 <rtems_object_get_name>
/*
* 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 ee 3d 12 00 push $0x123dee 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 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
(*print)( context, "\n" );
10c8b4: 83 ec 08 sub $0x8,%esp 10c8b7: 68 d9 1e 12 00 push $0x121ed9 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 cc b0 12 00 cmp %ebx,0x12b0cc
10c8ca: 73 99 jae 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71><== 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 e8 3e 12 00 push $0x123ee8 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 08 3f 12 00 push $0x123f08 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
0010ca00 <rtems_rate_monotonic_reset_all_statistics>:
/*
* 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 b0 b1 12 00 mov 0x12b1b0,%eax 10ca0c: 40 inc %eax 10ca0d: a3 b0 b1 12 00 mov %eax,0x12b1b0
/*
* 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 c8 b0 12 00 mov 0x12b0c8,%ebx 10ca18: 3b 1d cc b0 12 00 cmp 0x12b0cc,%ebx
10ca1e: 77 15 ja 10ca35 <rtems_rate_monotonic_reset_all_statistics+0x35><== 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 <rtems_rate_monotonic_reset_statistics>
* 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 cc b0 12 00 cmp %ebx,0x12b0cc
10ca33: 73 eb jae 10ca20 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* 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_rate_monotonic_reset_statistics>:
*/
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 c0 b0 12 00 push $0x12b0c0 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 <rtems_rate_monotonic_reset_statistics+0x60>
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 <rtems_region_create>:
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 <rtems_region_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !starting_address )
117263: 85 f6 test %esi,%esi
117265: 0f 84 e1 00 00 00 je 11734c <rtems_region_create+0x100>
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 <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
117276: 83 ec 0c sub $0xc,%esp 117279: ff 35 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 movl $0x1429e0,(%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 <rtems_region_create+0x110>
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 <rtems_region_create+0xe8>
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 fc 29 14 00 mov 0x1429fc,%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 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 push $0x1429e0 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 <rtems_region_create+0xb9>
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 <rtems_region_create+0xb9>
00117364 <rtems_region_delete>:
*/
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 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 push $0x1429e0 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 <rtems_region_delete+0x4c>
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 bc 2b 14 00 pushl 0x142bbc 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 <rtems_region_delete+0x5c>
return_status = RTEMS_RESOURCE_IN_USE;
1173b7: bb 0c 00 00 00 mov $0xc,%ebx 1173bc: eb db jmp 117399 <rtems_region_delete+0x35> 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 e0 29 14 00 push $0x1429e0 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 e0 29 14 00 push $0x1429e0 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 <rtems_region_delete+0x35>
001173e8 <rtems_region_extend>:
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 <rtems_region_extend+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
1173f7: 83 ec 0c sub $0xc,%esp 1173fa: ff 35 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 push $0x1429e0 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 <rtems_region_extend+0x5c>
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 bc 2b 14 00 pushl 0x142bbc 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 <rtems_region_extend+0x94>
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 <rtems_region_extend+0x42> 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 <rtems_region_extend+0x42>
00117484 <rtems_region_get_free_information>:
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 <rtems_region_get_free_information+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
117492: 83 ec 0c sub $0xc,%esp 117495: ff 35 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 push $0x1429e0 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 <rtems_region_get_free_information+0x58>
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 bc 2b 14 00 pushl 0x142bbc 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 <rtems_region_get_free_information+0x3f> 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 <rtems_region_get_segment>:
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 <rtems_region_get_segment+0xb8>
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 <rtems_region_get_segment+0x30>
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 bc 2b 14 00 pushl 0x142bbc 1175c5: e8 e2 21 00 00 call 1197ac <_API_Mutex_Lock>
executing = _Thread_Executing;
1175ca: a1 b8 30 14 00 mov 0x1430b8,%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 e0 29 14 00 push $0x1429e0 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 <rtems_region_get_segment+0x90>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
1175f2: 3b 77 5c cmp 0x5c(%edi),%esi
1175f5: 76 2d jbe 117624 <rtems_region_get_segment+0x98>
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 bc 2b 14 00 pushl 0x142bbc 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 <rtems_region_get_segment+0x70> 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 <rtems_region_get_segment+0xc4>
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 <rtems_region_get_segment+0x70> 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 <rtems_region_get_segment+0x26> 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 <rtems_region_get_segment+0xd1>
return_status = RTEMS_UNSATISFIED;
117656: b8 0d 00 00 00 mov $0xd,%eax 11765b: eb 9f jmp 1175fc <rtems_region_get_segment+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
11765d: a1 d0 2a 14 00 mov 0x142ad0,%eax 117662: 40 inc %eax 117663: a3 d0 2a 14 00 mov %eax,0x142ad0
* 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 bc 2b 14 00 pushl 0x142bbc 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 <rtems_region_get_segment+0x26>
0011776c <rtems_region_resize_segment>:
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 <rtems_region_resize_segment+0x9c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
11777f: 83 ec 0c sub $0xc,%esp 117782: ff 35 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 push $0x1429e0 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 <rtems_region_resize_segment+0x60>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1177ad: 83 ec 0c sub $0xc,%esp 1177b0: ff 35 bc 2b 14 00 pushl 0x142bbc 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 <rtems_region_resize_segment+0xa8>
_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 bc 2b 14 00 pushl 0x142bbc 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_region_return_segment>:
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 bc 2b 14 00 pushl 0x142bbc 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 e0 29 14 00 push $0x1429e0 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_region_return_segment+0x50>
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 <rtems_region_return_segment+0x70>
return_status = RTEMS_INVALID_ADDRESS;
117888: bb 09 00 00 00 mov $0x9,%ebx 11788d: eb 06 jmp 117895 <rtems_region_return_segment+0x55> 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 bc 2b 14 00 pushl 0x142bbc 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 <rtems_semaphore_create>:
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 <rtems_semaphore_create+0x60>
return RTEMS_INVALID_NAME;
if ( !id )
10b44a: 85 ff test %edi,%edi
10b44c: 0f 84 f6 00 00 00 je 10b548 <rtems_semaphore_create+0x114>
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_semaphore_create+0x70>
*/
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 <rtems_semaphore_create+0x40>
}
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 <rtems_semaphore_create+0x32>
_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 <rtems_semaphore_create+0x32>
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 <rtems_semaphore_create+0x77>
return RTEMS_INVALID_NUMBER;
10b48c: b8 0a 00 00 00 mov $0xa,%eax 10b491: eb d8 jmp 10b46b <rtems_semaphore_create+0x37> 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_semaphore_create+0x52>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4ab: a1 30 7e 12 00 mov 0x127e30,%eax 10b4b0: 40 inc %eax 10b4b1: a3 30 7e 12 00 mov %eax,0x127e30
* 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 80 7d 12 00 push $0x127d80 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 <rtems_semaphore_create+0x15c>
_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 <rtems_semaphore_create+0x120>
/*
* 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 <rtems_semaphore_create+0x16b>
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 <rtems_semaphore_create+0x19b>
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 9c 7d 12 00 mov 0x127d9c,%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 <rtems_semaphore_create+0x37> 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 <rtems_semaphore_create+0x37> 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 <rtems_semaphore_create+0xf2>
_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 <rtems_semaphore_create+0x37>
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 <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
10b5ba: f6 c3 40 test $0x40,%bl
10b5bd: 74 30 je 10b5ef <rtems_semaphore_create+0x1bb>
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_semaphore_create+0xc8>
*/
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 80 7d 12 00 push $0x127d80 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 <rtems_semaphore_create+0x37>
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 <rtems_semaphore_create+0xc8>
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 <rtems_semaphore_create+0xc8>
0010b60c <rtems_semaphore_delete>:
#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 80 7d 12 00 push $0x127d80 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 <rtems_semaphore_delete+0x30>
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 <rtems_semaphore_delete+0x90>
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 <rtems_semaphore_delete+0x54>
10b64b: 83 f8 20 cmp $0x20,%eax
10b64e: 74 10 je 10b660 <rtems_semaphore_delete+0x54>
!_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 80 7d 12 00 push $0x127d80 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 80 7d 12 00 push $0x127d80 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 <rtems_semaphore_delete+0x65>
0010b6b0 <rtems_semaphore_obtain>:
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 80 7d 12 00 push $0x127d80 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 <rtems_semaphore_obtain+0x3c>
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 <rtems_semaphore_obtain+0x78>
_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 18 84 12 00 mov 0x128418,%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 18 84 12 00 mov 0x128418,%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 <rtems_semaphore_obtain+0xb8>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
10b73c: 83 e6 01 and $0x1,%esi
10b73f: 74 33 je 10b774 <rtems_semaphore_obtain+0xc4>
_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 18 84 12 00 mov 0x128418,%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 <rtems_semaphore_obtain+0x9c> 10b772: 66 90 xchg %ax,%ax 10b774: 8b 0d 30 7e 12 00 mov 0x127e30,%ecx 10b77a: 41 inc %ecx 10b77b: 89 0d 30 7e 12 00 mov %ecx,0x127e30
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 <rtems_semaphore_obtain+0x9c>
0010b7ac <rtems_semaphore_release>:
#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 80 7d 12 00 push $0x127d80 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 <rtems_semaphore_release+0x30>
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 <rtems_semaphore_release+0x5c>
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_signal_send>:
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 <rtems_signal_send+0x18>
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 <rtems_signal_send+0x3c>
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 <rtems_signal_send+0x88>
if ( asr->is_enabled ) {
117da9: 80 7a 08 00 cmpb $0x0,0x8(%edx)
117dad: 74 25 je 117dd4 <rtems_signal_send+0x74>
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 b4 30 14 00 mov 0x1430b4,%edx 117dbd: 85 d2 test %edx,%edx
117dbf: 74 1b je 117ddc <rtems_signal_send+0x7c>
117dc1: 3b 05 b8 30 14 00 cmp 0x1430b8,%eax
117dc7: 75 13 jne 117ddc <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
117dc9: c6 05 c4 30 14 00 01 movb $0x1,0x1430c4 117dd0: eb 0a jmp 117ddc <rtems_signal_send+0x7c> 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 <rtems_signal_send+0x13>
0010b84c <rtems_task_create>:
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 <rtems_task_create+0x158>
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 <rtems_task_create+0xf4>
/*
* 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_task_create+0x42>
*/
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 <rtems_task_create+0xe4>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10b87f: 0f b6 05 f4 3a 12 00 movzbl 0x123af4,%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 <rtems_task_create+0xe4>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b88e: 83 ec 0c sub $0xc,%esp 10b891: ff 35 1c 7f 12 00 pushl 0x127f1c 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 c0 7d 12 00 movl $0x127dc0,(%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 <rtems_task_create+0x138>
/*
* 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 c0 7d 12 00 push $0x127dc0 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_task_create+0x104>
_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 1c 7f 12 00 pushl 0x127f1c 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 1c 7f 12 00 pushl 0x127f1c 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 1c 7f 12 00 pushl 0x127f1c 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 <rtems_task_create+0xe9>
0010b9ac <rtems_task_delete>:
*/
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 1c 7f 12 00 pushl 0x127f1c 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 <rtems_task_delete+0x70>
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 1c 7f 12 00 pushl 0x127f1c 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 1c 7f 12 00 pushl 0x127f1c 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_task_get_note>:
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 64 79 12 00 00 cmpb $0x0,0x127964
10d4fc: 74 6e je 10d56c <rtems_task_get_note+0x88>
return RTEMS_NOT_CONFIGURED;
if ( !note )
10d4fe: 85 db test %ebx,%ebx
10d500: 74 7e je 10d580 <rtems_task_get_note+0x9c>
/*
* 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 <rtems_task_get_note+0x60>
/*
* 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 <rtems_task_get_note+0x6c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d50b: 8b 15 d8 c5 12 00 mov 0x12c5d8,%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 <rtems_task_get_note+0x72>
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 <rtems_task_get_note+0x94>
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 <rtems_task_get_note+0x65> 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 d8 c5 12 00 mov 0x12c5d8,%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 <rtems_task_get_note+0x65> 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 <rtems_task_get_note+0x65>
00118144 <rtems_task_is_suspended>:
*/
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 <rtems_task_is_suspended+0x24>
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 <rtems_task_is_suspended+0x38>
_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_task_mode>:
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 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
112ea8: 8b 1d 18 84 12 00 mov 0x128418,%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 <rtems_task_mode+0x128>
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 <rtems_task_mode+0x6e>
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 <rtems_task_mode+0x93>
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 <rtems_task_mode+0x13c>
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 00 7e 12 00 mov 0x127e00,%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_task_mode+0xa4>
*/
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 <rtems_task_mode+0x134>
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 <rtems_task_mode+0xec>
* 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 <rtems_task_mode+0xec>
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 00 80 12 00 03 cmpl $0x3,0x128000
112f73: 74 16 je 112f8b <rtems_task_mode+0xf7> <== 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 00 80 12 00 03 cmpl $0x3,0x128000
112f89: 75 ea jne 112f75 <rtems_task_mode+0xe1> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
112f8b: 8b 15 18 84 12 00 mov 0x128418,%edx
if ( are_signals_pending ||
112f91: 84 c0 test %al,%al
112f93: 75 0e jne 112fa3 <rtems_task_mode+0x10f>
112f95: 3b 15 1c 84 12 00 cmp 0x12841c,%edx
112f9b: 74 d8 je 112f75 <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
112f9d: 80 7a 74 00 cmpb $0x0,0x74(%edx)
112fa1: 74 d2 je 112f75 <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
112fa3: c6 05 24 84 12 00 01 movb $0x1,0x128424
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 <rtems_task_mode+0x37> 112fc7: 90 nop 112fc8: fb sti 112fc9: e9 6a ff ff ff jmp 112f38 <rtems_task_mode+0xa4> 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 <rtems_task_mode+0xa4>
112fe1: e9 47 ff ff ff jmp 112f2d <rtems_task_mode+0x99> 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_task_resume>:
*/
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 <rtems_task_resume+0x24>
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 <rtems_task_resume+0x38>
_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_task_set_note>:
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 64 79 12 00 00 cmpb $0x0,0x127964
10d674: 74 66 je 10d6dc <rtems_task_set_note+0x80>
/*
* 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 <rtems_task_set_note+0x58>
/*
* 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 <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d67f: 8b 15 d8 c5 12 00 mov 0x12c5d8,%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 <rtems_task_set_note+0x6a>
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 <rtems_task_set_note+0x8c>
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 <rtems_task_set_note+0x5d>
* 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 d8 c5 12 00 mov 0x12c5d8,%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_task_set_priority>:
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_task_set_priority+0x1d>
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 b4 7a 12 00 movzbl 0x127ab4,%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_task_set_priority+0x7c>
!_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 <rtems_task_set_priority+0x88>
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 <rtems_task_set_priority+0x70>
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 <rtems_task_set_priority+0x5f>
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 <rtems_task_set_priority+0x52>
10f9ed: 3b 58 14 cmp 0x14(%eax),%ebx
10f9f0: 73 0d jae 10f9ff <rtems_task_set_priority+0x5f><== 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_task_start>:
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 <rtems_task_start+0x5c>
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 <rtems_task_start+0x50>
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 <rtems_task_start+0x68>
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_task_suspend>:
*/
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 <rtems_task_suspend+0x24>
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 <rtems_task_suspend+0x38>
_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_task_variable_add>:
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 <rtems_task_variable_add+0xb4>
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 <rtems_task_variable_add+0x40>
#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 <rtems_task_variable_add+0x8e>
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 <rtems_task_variable_add+0xa8>
_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 <rtems_task_variable_add+0x4c>
if (tvp->ptr == ptr) {
10c6de: 39 58 04 cmp %ebx,0x4(%eax)
10c6e1: 75 f5 jne 10c6d8 <rtems_task_variable_add+0x88>
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 <rtems_task_variable_add+0x37>
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_task_variable_delete>:
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 <rtems_task_variable_delete+0x84>
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 <rtems_task_variable_delete+0x34>
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 <rtems_task_variable_delete+0x55>
if (tvp->ptr == ptr) {
10c752: 39 59 04 cmp %ebx,0x4(%ecx)
10c755: 75 0c jne 10c763 <rtems_task_variable_delete+0x4f>
10c757: eb 49 jmp 10c7a2 <rtems_task_variable_delete+0x8e> 10c759: 8d 76 00 lea 0x0(%esi),%esi 10c75c: 39 5a 04 cmp %ebx,0x4(%edx)
10c75f: 74 17 je 10c778 <rtems_task_variable_delete+0x64>
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 <rtems_task_variable_delete+0x48><== 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 <rtems_task_variable_delete+0x68>
0010c7b0 <rtems_task_variable_get>:
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 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10c7c2: 85 f6 test %esi,%esi
10c7c4: 74 52 je 10c818 <rtems_task_variable_get+0x68>
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 <rtems_task_variable_get+0x5c>
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 <rtems_task_variable_get+0x42>
10c7e9: eb 39 jmp 10c824 <rtems_task_variable_get+0x74> 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 <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10c7f2: 39 58 04 cmp %ebx,0x4(%eax)
10c7f5: 75 f5 jne 10c7ec <rtems_task_variable_get+0x3c>
/*
* 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_task_wake_when>:
*/
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 44 ab 12 00 00 cmpb $0x0,0x12ab44
10c9dd: 0f 84 a9 00 00 00 je 10ca8c <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10c9e3: 85 db test %ebx,%ebx
10c9e5: 0f 84 ad 00 00 00 je 10ca98 <rtems_task_wake_when+0xcc>
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 <rtems_task_wake_when+0x40>
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 04 ac 12 00 cmp 0x12ac04,%eax
10ca1e: 76 e2 jbe 10ca02 <rtems_task_wake_when+0x36>
10ca20: 8b 15 30 ab 12 00 mov 0x12ab30,%edx 10ca26: 42 inc %edx 10ca27: 89 15 30 ab 12 00 mov %edx,0x12ab30
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 18 b1 12 00 pushl 0x12b118 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 18 b1 12 00 mov 0x12b118,%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 04 ac 12 00 sub 0x12ac04,%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 30 ac 12 00 push $0x12ac30 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 <rtems_task_wake_when+0x3b>
)
{
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_timer_cancel>:
*/
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 40 35 14 00 push $0x143540 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 <rtems_timer_cancel+0x28>
#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 <rtems_timer_cancel+0x3d><== 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_timer_create>:
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 <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10c00f: 85 f6 test %esi,%esi
10c011: 0f 84 89 00 00 00 je 10c0a0 <rtems_timer_create+0xa4>
10c017: a1 90 98 12 00 mov 0x129890,%eax 10c01c: 40 inc %eax 10c01d: a3 90 98 12 00 mov %eax,0x129890
* 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 00 a3 12 00 push $0x12a300 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 <rtems_timer_create+0x90>
_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 1c a3 12 00 mov 0x12a31c,%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_timer_delete>:
*/
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 40 35 14 00 push $0x143540 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 <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
118800: 83 ec 08 sub $0x8,%esp 118803: 50 push %eax 118804: 68 40 35 14 00 push $0x143540 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 40 35 14 00 push $0x143540 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_timer_fire_after>:
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 <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10c0c7: 85 f6 test %esi,%esi
10c0c9: 0f 84 b1 00 00 00 je 10c180 <rtems_timer_fire_after+0xd0>
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 00 a3 12 00 push $0x12a300 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 <rtems_timer_fire_after+0x4c>
#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 <rtems_timer_fire_after+0xc0>
/*
* 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 9c 99 12 00 push $0x12999c 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 <rtems_timer_fire_after+0x42> 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_timer_fire_when>:
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 e4 2a 14 00 00 cmpb $0x0,0x142ae4
11893d: 75 0d jne 11894c <rtems_timer_fire_when+0x28>
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 <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
11895c: 85 db test %ebx,%ebx
11895e: 0f 84 a4 00 00 00 je 118a08 <rtems_timer_fire_when+0xe4>
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 a4 2b 14 00 cmp 0x142ba4,%eax
118978: 77 0e ja 118988 <rtems_timer_fire_when+0x64>
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 40 35 14 00 push $0x143540 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 <rtems_timer_fire_when+0xd8>
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 a4 2b 14 00 sub 0x142ba4,%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 d0 2b 14 00 push $0x142bd0 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 <rtems_timer_fire_when+0x20> 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 <rtems_timer_fire_when+0x20> 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 <rtems_timer_fire_when+0x20>
001190bc <rtems_timer_initiate_server>:
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 <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1190cb: 0f b6 15 54 a3 13 00 movzbl 0x13a354,%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 <rtems_timer_initiate_server+0x5c>
* 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 <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1190d9: 31 f6 xor %esi,%esi 1190db: 8b 15 d0 2a 14 00 mov 0x142ad0,%edx 1190e1: 42 inc %edx 1190e2: 89 15 d0 2a 14 00 mov %edx,0x142ad0
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1190e8: 8a 1d 00 e4 13 00 mov 0x13e400,%bl
initialized = true;
1190ee: c6 05 00 e4 13 00 01 movb $0x1,0x13e400
_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 <rtems_timer_initiate_server+0x60>
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 <rtems_timer_initiate_server+0x1f>
* 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 <rtems_task_create>
/* 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 <rtems_timer_initiate_server+0x98>
initialized = false;
119144: c6 05 00 e4 13 00 00 movb $0x0,0x13e400
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 7c 2a 14 00 mov 0x142a7c,%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 80 e3 13 00 mov %edx,0x13e380
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
119169: c7 05 b0 e3 13 00 b4 movl $0x13e3b4,0x13e3b0
119170: e3 13 00 head->previous = NULL;
119173: c7 05 b4 e3 13 00 00 movl $0x0,0x13e3b4
11917a: 00 00 00 tail->previous = head;
11917d: c7 05 b8 e3 13 00 b0 movl $0x13e3b0,0x13e3b8
119184: e3 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
119187: c7 05 e8 e3 13 00 ec movl $0x13e3ec,0x13e3e8
11918e: e3 13 00 head->previous = NULL;
119191: c7 05 ec e3 13 00 00 movl $0x0,0x13e3ec
119198: 00 00 00 tail->previous = head;
11919b: c7 05 f0 e3 13 00 e8 movl $0x13e3e8,0x13e3f0
1191a2: e3 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191a5: c7 05 90 e3 13 00 00 movl $0x0,0x13e390
1191ac: 00 00 00 the_watchdog->routine = routine;
1191af: c7 05 a4 e3 13 00 e4 movl $0x11bbe4,0x13e3a4
1191b6: bb 11 00 the_watchdog->id = id;
1191b9: a3 a8 e3 13 00 mov %eax,0x13e3a8
the_watchdog->user_data = user_data;
1191be: c7 05 ac e3 13 00 00 movl $0x0,0x13e3ac
1191c5: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191c8: c7 05 c8 e3 13 00 00 movl $0x0,0x13e3c8
1191cf: 00 00 00 the_watchdog->routine = routine;
1191d2: c7 05 dc e3 13 00 e4 movl $0x11bbe4,0x13e3dc
1191d9: bb 11 00 the_watchdog->id = id;
1191dc: a3 e0 e3 13 00 mov %eax,0x13e3e0
the_watchdog->user_data = user_data;
1191e1: c7 05 e4 e3 13 00 00 movl $0x0,0x13e3e4
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 84 e3 13 00 8c movl $0x118f8c,0x13e384
1191f2: 8f 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1191f5: 8b 15 44 2c 14 00 mov 0x142c44,%edx 1191fb: 89 15 bc e3 13 00 mov %edx,0x13e3bc
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
119201: 8b 15 a4 2b 14 00 mov 0x142ba4,%edx 119207: 89 15 f4 e3 13 00 mov %edx,0x13e3f4
ts->insert_chain = NULL;
11920d: c7 05 f8 e3 13 00 00 movl $0x0,0x13e3f8
119214: 00 00 00 ts->active = false;
119217: c6 05 fc e3 13 00 00 movb $0x0,0x13e3fc
/*
* The default timer server is now available.
*/
_Timer_server = ts;
11921e: c7 05 80 35 14 00 80 movl $0x13e380,0x143580
119225: e3 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
119228: 53 push %ebx 119229: 68 80 e3 13 00 push $0x13e380 11922e: 68 c4 8d 11 00 push $0x118dc4 119233: 50 push %eax 119234: e8 7f f2 ff ff call 1184b8 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
119239: 83 c4 10 add $0x10,%esp 11923c: e9 d0 fe ff ff jmp 119111 <rtems_timer_initiate_server+0x55>
00118a9c <rtems_timer_reset>:
*/
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 40 35 14 00 push $0x143540 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 <rtems_timer_reset+0x34>
#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 <rtems_timer_reset+0x58>
_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 <rtems_timer_reset+0x78>
/*
* 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 dc 2b 14 00 push $0x142bdc 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 <rtems_timer_reset+0x43>
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 80 35 14 00 mov 0x143580,%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 <rtems_timer_reset+0x43>
00118b34 <rtems_timer_server_fire_after>:
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 80 35 14 00 mov 0x143580,%ebx
if ( !timer_server )
118b49: 85 db test %ebx,%ebx
118b4b: 0f 84 9f 00 00 00 je 118bf0 <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
118b51: 85 f6 test %esi,%esi
118b53: 0f 84 a3 00 00 00 je 118bfc <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118b59: 85 ff test %edi,%edi
118b5b: 75 0f jne 118b6c <rtems_timer_server_fire_after+0x38>
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 40 35 14 00 push $0x143540 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 <rtems_timer_server_fire_after+0xac>
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 <rtems_timer_server_fire_after+0xd4>
/*
* 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 <rtems_timer_server_fire_after+0x2e> 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 <rtems_timer_server_fire_after+0x2e> 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 <rtems_timer_server_fire_after+0x2e> 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 <rtems_timer_server_fire_after+0x2e>
00118c18 <rtems_timer_server_fire_when>:
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 80 35 14 00 mov 0x143580,%ebx
if ( !timer_server )
118c2d: 85 db test %ebx,%ebx
118c2f: 0f 84 d7 00 00 00 je 118d0c <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118c35: 80 3d e4 2a 14 00 00 cmpb $0x0,0x142ae4
118c3c: 0f 84 aa 00 00 00 je 118cec <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
118c42: 85 f6 test %esi,%esi
118c44: 0f 84 b2 00 00 00 je 118cfc <rtems_timer_server_fire_when+0xe4>
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 <rtems_timer_server_fire_when+0x50>
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 a4 2b 14 00 cmp 0x142ba4,%eax
118c7c: 76 dc jbe 118c5a <rtems_timer_server_fire_when+0x42>
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 40 35 14 00 push $0x143540 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 <rtems_timer_server_fire_when+0x100>
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 a4 2b 14 00 sub 0x142ba4,%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 <rtems_timer_server_fire_when+0x47> 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 <rtems_timer_server_fire_when+0x47> 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 <rtems_timer_server_fire_when+0x47>
0010be34 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
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 <sched_get_priority_max+0x17>
10be41: 83 f8 02 cmp $0x2,%eax
10be44: 7e 1a jle 10be60 <sched_get_priority_max+0x2c>
10be46: 83 f8 04 cmp $0x4,%eax
10be49: 74 15 je 10be60 <sched_get_priority_max+0x2c><== 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 fc 4d 12 00 movzbl 0x124dfc,%eax 10be67: 48 dec %eax
}
10be68: c9 leave 10be69: c3 ret
0010be6c <sched_get_priority_min>:
#include <rtems/posix/priority.h>
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 <sched_get_priority_min+0x17>
10be79: 83 f8 02 cmp $0x2,%eax
10be7c: 7e 1a jle 10be98 <sched_get_priority_min+0x2c><== ALWAYS TAKEN
10be7e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10be81: 74 15 je 10be98 <sched_get_priority_min+0x2c><== 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 <sched_rr_get_interval>:
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 <sched_rr_get_interval+0x30><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
10beaf: 85 db test %ebx,%ebx
10beb1: 74 38 je 10beeb <sched_rr_get_interval+0x4b>
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 e0 90 12 00 pushl 0x1290e0 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 <getpid> 10bed5: 39 f0 cmp %esi,%eax
10bed7: 74 d6 je 10beaf <sched_rr_get_interval+0xf>
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 <sched_rr_get_interval+0x27>
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 <sched_rr_get_interval+0x27>
0010e604 <sem_close>:
*/
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 00 df 12 00 push $0x12df00 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 <sem_close+0x38>
#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 <sem_destroy>:
*/
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 00 df 12 00 push $0x12df00 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 <sem_destroy+0x38>
#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 <sem_destroy+0x54>
_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 <sem_getvalue>:
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 00 df 12 00 push $0x12df00 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 <sem_getvalue+0x38>
#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 <sem_open>:
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 b0 db 12 00 mov 0x12dbb0,%eax 10e765: 40 inc %eax 10e766: a3 b0 db 12 00 mov %eax,0x12dbb0
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 <sem_open+0xac>
/* 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 <sem_open+0x68>
/*
* 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 <sem_open+0x4c> <== NEVER TAKEN
10e79c: 85 ff test %edi,%edi
10e79e: 75 6c jne 10e80c <sem_open+0xb8>
_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 <sem_open+0xdc>
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 00 df 12 00 push $0x12df00 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 <sem_open+0x2d> 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 <sem_open+0x9c>
return SEM_FAILED;
10e828: b8 ff ff ff ff mov $0xffffffff,%eax 10e82d: eb c7 jmp 10e7f6 <sem_open+0xa2> 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 <sem_open+0xa2>
0010e848 <sem_post>:
*/
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 00 df 12 00 push $0x12df00 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 <sem_post+0x38>
#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 <sem_timedwait>:
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 <sem_timedwait+0x34> <== 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 <setitimer>:
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 <setitimer+0x40>
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 <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10b308: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b30c: 76 12 jbe 10b320 <setitimer+0x2c>
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 <setitimer+0x25>
0010bd50 <sigaction>:
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 <sigaction+0x29>
*oact = _POSIX_signals_Vectors[ sig ];
10bd66: 8d 0c 5b lea (%ebx,%ebx,2),%ecx 10bd69: 8d 34 8d 80 a4 12 00 lea 0x12a480(,%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 <sigaction+0xa4>
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 <sigaction+0xa4>
*
* 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 <sigaction+0xa4>
/*
* 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 <sigaction+0xa0> <== 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 <sigaction+0x80>
_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 80 a4 12 00 lea 0x12a480(,%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 80 a4 12 00 lea 0x12a480(%esi),%eax 10bddc: 81 c6 e0 38 12 00 add $0x1238e0,%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 <sigaction+0x71> 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 <sigaction+0x77> <== NOT EXECUTED
* 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 <sigaction+0x77>
0010c120 <sigtimedwait>:
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 <sigtimedwait+0x1b8>
/* 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 <sigtimedwait+0x160>
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 <sigtimedwait+0x1b8>
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 <sigtimedwait+0x1b8> <== 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 <sigtimedwait+0x16a> <== NEVER TAKEN
the_thread = _Thread_Executing;
10c172: 8b 0d b8 9b 12 00 mov 0x129bb8,%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 <sigtimedwait+0x174>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10c197: 8b 35 28 9e 12 00 mov 0x129e28,%esi 10c19d: 85 75 d4 test %esi,-0x2c(%ebp)
10c1a0: 0f 85 96 00 00 00 jne 10c23c <sigtimedwait+0x11c>
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 d0 95 12 00 mov 0x1295d0,%esi 10c1b2: 46 inc %esi 10c1b3: 89 35 d0 95 12 00 mov %esi,0x1295d0
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10c1b9: c7 41 44 c0 9d 12 00 movl $0x129dc0,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 f0 9d 12 00 01 movl $0x1,0x129df0
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 c0 9d 12 00 push $0x129dc0 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 b8 9b 12 00 mov 0x129bb8,%eax 10c213: 83 78 34 04 cmpl $0x4,0x34(%eax)
10c217: 0f 85 d3 00 00 00 jne 10c2f0 <sigtimedwait+0x1d0>
|| !(*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 <sigtimedwait+0x1d0> <== 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 <sigtimedwait+0x52>
10c28a: 8d 7d dc lea -0x24(%ebp),%edi 10c28d: e9 e0 fe ff ff jmp 10c172 <sigtimedwait+0x52> 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 <sigtimedwait+0x111> 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 b8 9b 12 00 mov 0x129bb8,%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 <sigtimedwait+0x111>
0010df98 <sigwait>:
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 <sigtimedwait>
if ( status != -1 ) {
10dfae: 83 c4 10 add $0x10,%esp 10dfb1: 83 f8 ff cmp $0xffffffff,%eax
10dfb4: 74 0e je 10dfc4 <sigwait+0x2c>
if ( sig )
10dfb6: 85 db test %ebx,%ebx
10dfb8: 74 16 je 10dfd0 <sigwait+0x38> <== 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 <timer_create>:
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 <timer_create+0xf0>
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 <timer_create+0xf0>
/*
* 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 <timer_create+0x42>
/* 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 <timer_create+0xf0> <== 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 <timer_create+0xf0> <== 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 <timer_create+0xf0> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b542: a1 50 a1 12 00 mov 0x12a150,%eax 10b547: 40 inc %eax 10b548: a3 50 a1 12 00 mov %eax,0x12a150
* 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 e0 a4 12 00 push $0x12a4e0 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 <timer_create+0x107>
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 38 a7 12 00 mov 0x12a738,%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 <timer_create+0x8a>
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 fc a4 12 00 mov 0x12a4fc,%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 <timer_create+0xe8>
0010ba44 <timer_delete>:
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 e0 a3 12 00 push $0x12a3e0 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 <timer_delete+0x3c>
#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 e0 a3 12 00 push $0x12a3e0 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 e0 a3 12 00 push $0x12a3e0 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 <timer_getoverrun>:
* 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 80 ba 12 00 push $0x12ba80 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 <timer_getoverrun+0x3c>
#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 <timer_gettime>:
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 <timer_gettime+0x74>
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 80 ba 12 00 push $0x12ba80 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 <timer_gettime+0x74>
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10c98f: a1 64 b8 12 00 mov 0x12b864,%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 <timer_gettime+0x6a>
0010b620 <timer_settime>:
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 <timer_settime+0x164> <== 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 <timer_settime+0x164>
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 <timer_settime+0x164> <== 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 <timer_settime+0x124>
10b669: 8b 45 0c mov 0xc(%ebp),%eax 10b66c: 85 c0 test %eax,%eax
10b66e: 0f 85 10 01 00 00 jne 10b784 <timer_settime+0x164>
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 e0 a4 12 00 push $0x12a4e0 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 <timer_settime+0x164>
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 <timer_settime+0x99>
10b6ae: 8b 4d d8 mov -0x28(%ebp),%ecx 10b6b1: 85 c9 test %ecx,%ecx
10b6b3: 0f 84 df 00 00 00 je 10b798 <timer_settime+0x178>
_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 <timer_settime+0x1c4>
/*
* 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 <timer_settime+0x1d4>
*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 <timer_settime+0x164>
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 <timer_settime+0x65> 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 <timer_settime+0x11c> 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 <timer_settime+0x1dc>
*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 <timer_settime+0xf6> 10b7fc: 8d 42 54 lea 0x54(%edx),%eax 10b7ff: eb c2 jmp 10b7c3 <timer_settime+0x1a3>
0010b410 <ualarm>:
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 3c a7 12 00 mov 0x12a73c,%ecx 10b421: 85 c9 test %ecx,%ecx
10b423: 0f 84 8f 00 00 00 je 10b4b8 <ualarm+0xa8>
_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 20 a7 12 00 push $0x12a720 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 <ualarm+0xd8> <== 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 <ualarm+0x9d>
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 2c a7 12 00 mov %eax,0x12a72c
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b499: 58 pop %eax 10b49a: 5a pop %edx 10b49b: 68 20 a7 12 00 push $0x12a720 10b4a0: 68 3c 9e 12 00 push $0x129e3c 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 28 a7 12 00 00 movl $0x0,0x12a728
10b4bf: 00 00 00 the_watchdog->routine = routine;
10b4c2: c7 05 3c a7 12 00 d4 movl $0x10b3d4,0x12a73c
10b4c9: b3 10 00 the_watchdog->id = id;
10b4cc: c7 05 40 a7 12 00 00 movl $0x0,0x12a740
10b4d3: 00 00 00 the_watchdog->user_data = user_data;
10b4d6: c7 05 44 a7 12 00 00 movl $0x0,0x12a744
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 <ualarm+0x37> 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 34 a7 12 00 mov 0x12a734,%eax 10b4ed: 03 05 2c a7 12 00 add 0x12a72c,%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 38 a7 12 00 sub 0x12a738,%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 <ualarm+0x37>