0010b394 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10b394: 55 push %ebp 10b395: 89 e5 mov %esp,%ebp 10b397: 53 push %ebx 10b398: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10b39b: 8b 1d 18 7a 12 00 mov 0x127a18,%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10b3a1: 81 fb 1c 7a 12 00 cmp $0x127a1c,%ebx
10b3a7: 74 10 je 10b3b9 <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN
10b3a9: 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)();
10b3ac: 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 ) {
10b3af: 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 );
10b3b1: 81 fb 1c 7a 12 00 cmp $0x127a1c,%ebx
10b3b7: 75 f3 jne 10b3ac <_API_extensions_Run_postdriver+0x18>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10b3b9: 58 pop %eax 10b3ba: 5b pop %ebx 10b3bb: c9 leave 10b3bc: c3 ret
0010b3c0 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10b3c0: 55 push %ebp 10b3c1: 89 e5 mov %esp,%ebp 10b3c3: 53 push %ebx 10b3c4: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10b3c7: 8b 1d 18 7a 12 00 mov 0x127a18,%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10b3cd: 81 fb 1c 7a 12 00 cmp $0x127a1c,%ebx
10b3d3: 74 1c je 10b3f1 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN
10b3d5: 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 );
10b3d8: 83 ec 0c sub $0xc,%esp 10b3db: ff 35 98 7d 12 00 pushl 0x127d98 10b3e1: 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 ) {
10b3e4: 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 );
10b3e6: 83 c4 10 add $0x10,%esp 10b3e9: 81 fb 1c 7a 12 00 cmp $0x127a1c,%ebx
10b3ef: 75 e7 jne 10b3d8 <_API_extensions_Run_postswitch+0x18>
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10b3f1: 8b 5d fc mov -0x4(%ebp),%ebx 10b3f4: c9 leave 10b3f5: c3 ret
0010d7a0 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10d7a0: 55 push %ebp 10d7a1: 89 e5 mov %esp,%ebp 10d7a3: 57 push %edi 10d7a4: 56 push %esi 10d7a5: 53 push %ebx 10d7a6: 83 ec 1c sub $0x1c,%esp 10d7a9: 8b 5d 08 mov 0x8(%ebp),%ebx 10d7ac: 8b 7d 0c mov 0xc(%ebp),%edi 10d7af: 8b 4d 14 mov 0x14(%ebp),%ecx 10d7b2: 8a 55 10 mov 0x10(%ebp),%dl
ISR_Level level; Thread_Control *executing = _Thread_Executing;
10d7b5: 8b 35 98 b6 12 00 mov 0x12b698,%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 );
10d7bb: 9c pushf 10d7bc: fa cli 10d7bd: 8f 45 e4 popl -0x1c(%ebp)
switch ( the_rwlock->current_state ) {
10d7c0: 8b 43 44 mov 0x44(%ebx),%eax 10d7c3: 85 c0 test %eax,%eax
10d7c5: 75 1d jne 10d7e4 <_CORE_RWLock_Obtain_for_reading+0x44>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10d7c7: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
the_rwlock->number_of_readers += 1;
10d7ce: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10d7d1: ff 75 e4 pushl -0x1c(%ebp) 10d7d4: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10d7d5: 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 */
}
10d7dc: 8d 65 f4 lea -0xc(%ebp),%esp 10d7df: 5b pop %ebx 10d7e0: 5e pop %esi 10d7e1: 5f pop %edi 10d7e2: c9 leave 10d7e3: 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 ) {
10d7e4: 48 dec %eax
10d7e5: 74 51 je 10d838 <_CORE_RWLock_Obtain_for_reading+0x98>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10d7e7: 84 d2 test %dl,%dl
10d7e9: 75 15 jne 10d800 <_CORE_RWLock_Obtain_for_reading+0x60>
_ISR_Enable( level );
10d7eb: ff 75 e4 pushl -0x1c(%ebp) 10d7ee: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10d7ef: 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 */
}
10d7f6: 8d 65 f4 lea -0xc(%ebp),%esp 10d7f9: 5b pop %ebx 10d7fa: 5e pop %esi 10d7fb: 5f pop %edi 10d7fc: c9 leave 10d7fd: c3 ret 10d7fe: 66 90 xchg %ax,%ax 10d800: 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;
10d807: 89 5e 44 mov %ebx,0x44(%esi)
executing->Wait.id = id;
10d80a: 89 7e 20 mov %edi,0x20(%esi)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
10d80d: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10d814: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Enable( level );
10d81b: ff 75 e4 pushl -0x1c(%ebp) 10d81e: 9d popf
_Thread_queue_Enqueue_with_handler(
10d81f: c7 45 10 a4 d9 10 00 movl $0x10d9a4,0x10(%ebp) 10d826: 89 4d 0c mov %ecx,0xc(%ebp) 10d829: 89 5d 08 mov %ebx,0x8(%ebp)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10d82c: 8d 65 f4 lea -0xc(%ebp),%esp 10d82f: 5b pop %ebx 10d830: 5e pop %esi 10d831: 5f pop %edi 10d832: 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(
10d833: e9 b8 1b 00 00 jmp 10f3f0 <_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 );
10d838: 83 ec 0c sub $0xc,%esp 10d83b: 53 push %ebx 10d83c: 88 55 e0 mov %dl,-0x20(%ebp) 10d83f: 89 4d dc mov %ecx,-0x24(%ebp) 10d842: e8 d1 1e 00 00 call 10f718 <_Thread_queue_First>
if ( !waiter ) {
10d847: 83 c4 10 add $0x10,%esp 10d84a: 85 c0 test %eax,%eax 10d84c: 8a 55 e0 mov -0x20(%ebp),%dl 10d84f: 8b 4d dc mov -0x24(%ebp),%ecx
10d852: 75 93 jne 10d7e7 <_CORE_RWLock_Obtain_for_reading+0x47> the_rwlock->number_of_readers += 1;
10d854: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10d857: ff 75 e4 pushl -0x1c(%ebp) 10d85a: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10d85b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
return;
10d862: e9 75 ff ff ff jmp 10d7dc <_CORE_RWLock_Obtain_for_reading+0x3c>
0010d868 <_CORE_RWLock_Obtain_for_writing>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10d868: 55 push %ebp 10d869: 89 e5 mov %esp,%ebp 10d86b: 57 push %edi 10d86c: 56 push %esi 10d86d: 53 push %ebx 10d86e: 83 ec 0c sub $0xc,%esp 10d871: 8b 45 08 mov 0x8(%ebp),%eax 10d874: 8b 7d 0c mov 0xc(%ebp),%edi 10d877: 8b 75 14 mov 0x14(%ebp),%esi 10d87a: 8a 5d 10 mov 0x10(%ebp),%bl
ISR_Level level; Thread_Control *executing = _Thread_Executing;
10d87d: 8b 15 98 b6 12 00 mov 0x12b698,%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 );
10d883: 9c pushf 10d884: fa cli 10d885: 59 pop %ecx
switch ( the_rwlock->current_state ) {
10d886: 83 78 44 00 cmpl $0x0,0x44(%eax)
10d88a: 75 18 jne 10d8a4 <_CORE_RWLock_Obtain_for_writing+0x3c>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10d88c: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax)
_ISR_Enable( level );
10d893: 51 push %ecx 10d894: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10d895: 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 */
}
10d89c: 83 c4 0c add $0xc,%esp 10d89f: 5b pop %ebx 10d8a0: 5e pop %esi 10d8a1: 5f pop %edi 10d8a2: c9 leave 10d8a3: c3 ret
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10d8a4: 84 db test %bl,%bl
10d8a6: 75 14 jne 10d8bc <_CORE_RWLock_Obtain_for_writing+0x54>
_ISR_Enable( level );
10d8a8: 51 push %ecx 10d8a9: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10d8aa: 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 */
}
10d8b1: 83 c4 0c add $0xc,%esp 10d8b4: 5b pop %ebx 10d8b5: 5e pop %esi 10d8b6: 5f pop %edi 10d8b7: c9 leave 10d8b8: c3 ret 10d8b9: 8d 76 00 lea 0x0(%esi),%esi 10d8bc: 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;
10d8c3: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10d8c6: 89 7a 20 mov %edi,0x20(%edx)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
10d8c9: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10d8d0: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Enable( level );
10d8d7: 51 push %ecx 10d8d8: 9d popf
_Thread_queue_Enqueue_with_handler(
10d8d9: c7 45 10 a4 d9 10 00 movl $0x10d9a4,0x10(%ebp) 10d8e0: 89 75 0c mov %esi,0xc(%ebp) 10d8e3: 89 45 08 mov %eax,0x8(%ebp)
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10d8e6: 83 c4 0c add $0xc,%esp 10d8e9: 5b pop %ebx 10d8ea: 5e pop %esi 10d8eb: 5f pop %edi 10d8ec: 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(
10d8ed: e9 fe 1a 00 00 jmp 10f3f0 <_Thread_queue_Enqueue_with_handler>
0010d8f4 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10d8f4: 55 push %ebp 10d8f5: 89 e5 mov %esp,%ebp 10d8f7: 53 push %ebx 10d8f8: 83 ec 04 sub $0x4,%esp 10d8fb: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level; Thread_Control *executing = _Thread_Executing;
10d8fe: 8b 0d 98 b6 12 00 mov 0x12b698,%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 );
10d904: 9c pushf 10d905: fa cli 10d906: 5a pop %edx
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10d907: 8b 43 44 mov 0x44(%ebx),%eax 10d90a: 85 c0 test %eax,%eax
10d90c: 74 7a je 10d988 <_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 ) {
10d90e: 48 dec %eax
10d90f: 74 63 je 10d974 <_CORE_RWLock_Release+0x80>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10d911: 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;
10d918: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10d91f: 52 push %edx 10d920: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10d921: 83 ec 0c sub $0xc,%esp 10d924: 53 push %ebx 10d925: e8 9e 19 00 00 call 10f2c8 <_Thread_queue_Dequeue>
if ( next ) {
10d92a: 83 c4 10 add $0x10,%esp 10d92d: 85 c0 test %eax,%eax
10d92f: 74 39 je 10d96a <_CORE_RWLock_Release+0x76>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10d931: 83 78 30 01 cmpl $0x1,0x30(%eax)
10d935: 74 61 je 10d998 <_CORE_RWLock_Release+0xa4>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10d937: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10d93a: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) 10d941: eb 17 jmp 10d95a <_CORE_RWLock_Release+0x66> 10d943: 90 nop
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
10d944: 83 78 30 01 cmpl $0x1,0x30(%eax)
10d948: 74 20 je 10d96a <_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;
10d94a: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10d94d: 83 ec 08 sub $0x8,%esp 10d950: 50 push %eax 10d951: 53 push %ebx 10d952: e8 a9 1c 00 00 call 10f600 <_Thread_queue_Extract>
}
10d957: 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 );
10d95a: 83 ec 0c sub $0xc,%esp 10d95d: 53 push %ebx 10d95e: e8 b5 1d 00 00 call 10f718 <_Thread_queue_First>
if ( !next ||
10d963: 83 c4 10 add $0x10,%esp 10d966: 85 c0 test %eax,%eax
10d968: 75 da jne 10d944 <_CORE_RWLock_Release+0x50>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10d96a: 31 c0 xor %eax,%eax 10d96c: 8b 5d fc mov -0x4(%ebp),%ebx 10d96f: c9 leave 10d970: c3 ret 10d971: 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;
10d974: 8b 43 48 mov 0x48(%ebx),%eax 10d977: 48 dec %eax 10d978: 89 43 48 mov %eax,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10d97b: 85 c0 test %eax,%eax
10d97d: 74 92 je 10d911 <_CORE_RWLock_Release+0x1d>
/* must be unlocked again */
_ISR_Enable( level );
10d97f: 52 push %edx 10d980: 9d popf
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10d981: 31 c0 xor %eax,%eax 10d983: 8b 5d fc mov -0x4(%ebp),%ebx 10d986: c9 leave 10d987: c3 ret
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
10d988: 52 push %edx 10d989: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10d98a: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx)
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10d991: 31 c0 xor %eax,%eax 10d993: 8b 5d fc mov -0x4(%ebp),%ebx 10d996: c9 leave 10d997: 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;
10d998: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10d99f: eb c9 jmp 10d96a <_CORE_RWLock_Release+0x76>
0010d9a4 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10d9a4: 55 push %ebp 10d9a5: 89 e5 mov %esp,%ebp 10d9a7: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d9aa: 8d 45 f4 lea -0xc(%ebp),%eax 10d9ad: 50 push %eax 10d9ae: ff 75 08 pushl 0x8(%ebp) 10d9b1: e8 b6 15 00 00 call 10ef6c <_Thread_Get>
switch ( location ) {
10d9b6: 83 c4 10 add $0x10,%esp 10d9b9: 8b 55 f4 mov -0xc(%ebp),%edx 10d9bc: 85 d2 test %edx,%edx
10d9be: 75 17 jne 10d9d7 <_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 );
10d9c0: 83 ec 0c sub $0xc,%esp 10d9c3: 50 push %eax 10d9c4: e8 2f 1e 00 00 call 10f7f8 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10d9c9: a1 ec b0 12 00 mov 0x12b0ec,%eax 10d9ce: 48 dec %eax 10d9cf: a3 ec b0 12 00 mov %eax,0x12b0ec 10d9d4: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10d9d7: c9 leave 10d9d8: c3 ret
001109c8 <_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
)
{
1109c8: 55 push %ebp 1109c9: 89 e5 mov %esp,%ebp 1109cb: 57 push %edi 1109cc: 56 push %esi 1109cd: 53 push %ebx 1109ce: 83 ec 0c sub $0xc,%esp 1109d1: 8b 5d 08 mov 0x8(%ebp),%ebx 1109d4: 8b 75 10 mov 0x10(%ebp),%esi 1109d7: 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;
1109da: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
1109dd: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
1109e4: 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;
1109e7: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
1109ee: 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)) {
1109f5: a8 03 test $0x3,%al
1109f7: 74 17 je 110a10 <_CORE_message_queue_Initialize+0x48>
allocated_message_size += sizeof(uint32_t);
1109f9: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uint32_t) - 1);
1109fc: 83 e2 fc and $0xfffffffc,%edx
}
if (allocated_message_size < maximum_message_size)
1109ff: 39 d0 cmp %edx,%eax
110a01: 76 0f jbe 110a12 <_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;
110a03: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
110a05: 8d 65 f4 lea -0xc(%ebp),%esp 110a08: 5b pop %ebx 110a09: 5e pop %esi 110a0a: 5f pop %edi 110a0b: c9 leave 110a0c: c3 ret 110a0d: 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)) {
110a10: 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));
110a12: 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 *
110a15: 89 f8 mov %edi,%eax 110a17: 0f af c6 imul %esi,%eax
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
110a1a: 39 d0 cmp %edx,%eax
110a1c: 72 e5 jb 110a03 <_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 );
110a1e: 83 ec 0c sub $0xc,%esp 110a21: 50 push %eax 110a22: e8 35 d3 ff ff call 10dd5c <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
110a27: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
110a2a: 83 c4 10 add $0x10,%esp 110a2d: 85 c0 test %eax,%eax
110a2f: 74 d2 je 110a03 <_CORE_message_queue_Initialize+0x3b>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
110a31: 57 push %edi 110a32: 56 push %esi 110a33: 50 push %eax 110a34: 8d 43 68 lea 0x68(%ebx),%eax 110a37: 50 push %eax 110a38: e8 ab fe ff ff call 1108e8 <_Chain_Initialize>
Chain_Node *tail = _Chain_Tail( the_chain );
110a3d: 8d 43 54 lea 0x54(%ebx),%eax 110a40: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
110a43: 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 );
110a4a: 8d 43 50 lea 0x50(%ebx),%eax 110a4d: 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(
110a50: 6a 06 push $0x6 110a52: 68 80 00 00 00 push $0x80 110a57: 8b 45 0c mov 0xc(%ebp),%eax 110a5a: 83 38 01 cmpl $0x1,(%eax) 110a5d: 0f 94 c0 sete %al 110a60: 0f b6 c0 movzbl %al,%eax 110a63: 50 push %eax 110a64: 53 push %ebx 110a65: e8 26 ca ff ff call 10d490 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
110a6a: 83 c4 20 add $0x20,%esp 110a6d: b0 01 mov $0x1,%al
}
110a6f: 8d 65 f4 lea -0xc(%ebp),%esp 110a72: 5b pop %ebx 110a73: 5e pop %esi 110a74: 5f pop %edi 110a75: c9 leave 110a76: c3 ret
00112ba0 <_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
)
{
112ba0: 55 push %ebp 112ba1: 89 e5 mov %esp,%ebp 112ba3: 56 push %esi 112ba4: 53 push %ebx 112ba5: 83 ec 10 sub $0x10,%esp 112ba8: 8b 45 08 mov 0x8(%ebp),%eax 112bab: 8b 55 0c mov 0xc(%ebp),%edx 112bae: 8b 4d 10 mov 0x10(%ebp),%ecx 112bb1: 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 ) {
112bb4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx
112bba: 74 70 je 112c2c <_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 ) {
112bbc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx
112bc2: 0f 84 88 00 00 00 je 112c50 <_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
}
112bc8: 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));
112bcb: 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 ) ) {
112bce: 39 de cmp %ebx,%esi
112bd0: 74 05 je 112bd7 <_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 ) {
112bd2: 3b 4b 08 cmp 0x8(%ebx),%ecx
112bd5: 7d 45 jge 112c1c <_CORE_message_queue_Insert_message+0x7c>
the_node = the_node->next;
continue;
}
break;
}
_ISR_Disable( level );
112bd7: 9c pushf 112bd8: fa cli 112bd9: 5e pop %esi
SET_NOTIFY();
112bda: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
112bdd: 85 c9 test %ecx,%ecx 112bdf: 0f 94 45 f7 sete -0x9(%ebp)
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
112be3: 41 inc %ecx 112be4: 89 48 48 mov %ecx,0x48(%eax)
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
112be7: 8b 4b 04 mov 0x4(%ebx),%ecx
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
112bea: 89 4a 04 mov %ecx,0x4(%edx)
before_node = after_node->next;
112bed: 8b 19 mov (%ecx),%ebx
after_node->next = the_node;
112bef: 89 11 mov %edx,(%ecx)
the_node->next = before_node;
112bf1: 89 1a mov %ebx,(%edx)
before_node->previous = the_node;
112bf3: 89 53 04 mov %edx,0x4(%ebx)
_ISR_Enable( level );
112bf6: 56 push %esi 112bf7: 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 )
112bf8: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
112bfc: 74 16 je 112c14 <_CORE_message_queue_Insert_message+0x74>
112bfe: 8b 50 60 mov 0x60(%eax),%edx 112c01: 85 d2 test %edx,%edx
112c03: 74 0f je 112c14 <_CORE_message_queue_Insert_message+0x74>
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
112c05: 8b 40 64 mov 0x64(%eax),%eax 112c08: 89 45 08 mov %eax,0x8(%ebp)
#endif }
112c0b: 83 c4 10 add $0x10,%esp 112c0e: 5b pop %ebx 112c0f: 5e pop %esi 112c10: 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);
112c11: ff e2 jmp *%edx 112c13: 90 nop
#endif }
112c14: 83 c4 10 add $0x10,%esp 112c17: 5b pop %ebx 112c18: 5e pop %esi 112c19: c9 leave 112c1a: c3 ret 112c1b: 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;
112c1c: 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 ) ) {
112c1e: 39 de cmp %ebx,%esi
112c20: 74 b5 je 112bd7 <_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 ) {
112c22: 3b 4b 08 cmp 0x8(%ebx),%ecx
112c25: 7c b0 jl 112bd7 <_CORE_message_queue_Insert_message+0x37>
112c27: eb f3 jmp 112c1c <_CORE_message_queue_Insert_message+0x7c> 112c29: 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 );
112c2c: 9c pushf 112c2d: fa cli 112c2e: 5b pop %ebx
SET_NOTIFY();
112c2f: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
112c32: 85 c9 test %ecx,%ecx 112c34: 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++;
112c38: 41 inc %ecx 112c39: 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;
112c3c: 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 );
112c3f: 8d 70 54 lea 0x54(%eax),%esi 112c42: 89 32 mov %esi,(%edx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
112c44: 89 50 58 mov %edx,0x58(%eax)
old_last->next = the_node;
112c47: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
112c49: 89 4a 04 mov %ecx,0x4(%edx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
112c4c: 53 push %ebx 112c4d: 9d popf 112c4e: eb a8 jmp 112bf8 <_CORE_message_queue_Insert_message+0x58>
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
112c50: 9c pushf 112c51: fa cli 112c52: 5b pop %ebx
SET_NOTIFY();
112c53: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
112c56: 85 c9 test %ecx,%ecx 112c58: 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++;
112c5c: 41 inc %ecx 112c5d: 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);
112c60: 8d 48 50 lea 0x50(%eax),%ecx 112c63: 89 4a 04 mov %ecx,0x4(%edx)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
112c66: 8b 48 50 mov 0x50(%eax),%ecx
after_node->next = the_node;
112c69: 89 50 50 mov %edx,0x50(%eax)
the_node->next = before_node;
112c6c: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
112c6e: 89 51 04 mov %edx,0x4(%ecx)
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
112c71: 53 push %ebx 112c72: 9d popf 112c73: eb 83 jmp 112bf8 <_CORE_message_queue_Insert_message+0x58>
00110a78 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
110a78: 55 push %ebp 110a79: 89 e5 mov %esp,%ebp 110a7b: 57 push %edi 110a7c: 56 push %esi 110a7d: 53 push %ebx 110a7e: 83 ec 2c sub $0x2c,%esp 110a81: 8b 55 08 mov 0x8(%ebp),%edx 110a84: 8b 45 0c mov 0xc(%ebp),%eax 110a87: 89 45 dc mov %eax,-0x24(%ebp) 110a8a: 8b 4d 10 mov 0x10(%ebp),%ecx 110a8d: 89 4d e0 mov %ecx,-0x20(%ebp) 110a90: 8b 45 14 mov 0x14(%ebp),%eax 110a93: 8b 5d 1c mov 0x1c(%ebp),%ebx 110a96: 89 5d d8 mov %ebx,-0x28(%ebp) 110a99: 0f b6 7d 18 movzbl 0x18(%ebp),%edi
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
110a9d: 8b 0d 98 7d 12 00 mov 0x127d98,%ecx
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
110aa3: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
110aaa: 9c pushf 110aab: fa cli 110aac: 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 );
}
110aaf: 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 );
110ab2: 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))
110ab5: 39 f3 cmp %esi,%ebx
110ab7: 74 7b je 110b34 <_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;
110ab9: 8b 0b mov (%ebx),%ecx
head->next = new_first;
110abb: 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 );
110abe: 8d 72 50 lea 0x50(%edx),%esi 110ac1: 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;
110ac4: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
110ac7: ff 75 e4 pushl -0x1c(%ebp) 110aca: 9d popf
*size_p = the_message->Contents.size;
110acb: 8b 4b 0c mov 0xc(%ebx),%ecx 110ace: 89 08 mov %ecx,(%eax)
_Thread_Executing->Wait.count =
110ad0: 8b 73 08 mov 0x8(%ebx),%esi 110ad3: 8b 0d 98 7d 12 00 mov 0x127d98,%ecx 110ad9: 89 71 24 mov %esi,0x24(%ecx)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
110adc: 8d 4b 10 lea 0x10(%ebx),%ecx 110adf: 89 4d e4 mov %ecx,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
110ae2: 8b 08 mov (%eax),%ecx 110ae4: 8b 7d e0 mov -0x20(%ebp),%edi 110ae7: 8b 75 e4 mov -0x1c(%ebp),%esi 110aea: 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 );
110aec: 83 ec 0c sub $0xc,%esp 110aef: 52 push %edx 110af0: 89 55 d4 mov %edx,-0x2c(%ebp) 110af3: e8 08 c6 ff ff call 10d100 <_Thread_queue_Dequeue>
if ( !the_thread ) {
110af8: 83 c4 10 add $0x10,%esp 110afb: 85 c0 test %eax,%eax 110afd: 8b 55 d4 mov -0x2c(%ebp),%edx
110b00: 0f 84 86 00 00 00 je 110b8c <_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;
110b06: 8b 48 24 mov 0x24(%eax),%ecx 110b09: 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;
110b0c: 8b 48 30 mov 0x30(%eax),%ecx 110b0f: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
110b12: 8b 70 2c mov 0x2c(%eax),%esi 110b15: 8b 7d e4 mov -0x1c(%ebp),%edi 110b18: 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(
110b1a: 8b 43 08 mov 0x8(%ebx),%eax 110b1d: 89 45 10 mov %eax,0x10(%ebp) 110b20: 89 5d 0c mov %ebx,0xc(%ebp) 110b23: 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 );
}
110b26: 8d 65 f4 lea -0xc(%ebp),%esp 110b29: 5b pop %ebx 110b2a: 5e pop %esi 110b2b: 5f pop %edi 110b2c: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
110b2d: e9 6e 20 00 00 jmp 112ba0 <_CORE_message_queue_Insert_message> 110b32: 66 90 xchg %ax,%ax
return;
}
#endif
}
if ( !wait ) {
110b34: 89 fb mov %edi,%ebx 110b36: 84 db test %bl,%bl
110b38: 75 16 jne 110b50 <_CORE_message_queue_Seize+0xd8>
_ISR_Enable( level );
110b3a: ff 75 e4 pushl -0x1c(%ebp) 110b3d: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
110b3e: 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 );
}
110b45: 8d 65 f4 lea -0xc(%ebp),%esp 110b48: 5b pop %ebx 110b49: 5e pop %esi 110b4a: 5f pop %edi 110b4b: c9 leave 110b4c: c3 ret 110b4d: 8d 76 00 lea 0x0(%esi),%esi 110b50: 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;
110b57: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
110b5a: 8b 5d dc mov -0x24(%ebp),%ebx 110b5d: 89 59 20 mov %ebx,0x20(%ecx)
executing->Wait.return_argument_second.mutable_object = buffer;
110b60: 8b 5d e0 mov -0x20(%ebp),%ebx 110b63: 89 59 2c mov %ebx,0x2c(%ecx)
executing->Wait.return_argument = size_p;
110b66: 89 41 28 mov %eax,0x28(%ecx)
/* Wait.count will be filled in with the message priority */ _ISR_Enable( level );
110b69: ff 75 e4 pushl -0x1c(%ebp) 110b6c: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
110b6d: c7 45 10 54 d5 10 00 movl $0x10d554,0x10(%ebp) 110b74: 8b 45 d8 mov -0x28(%ebp),%eax 110b77: 89 45 0c mov %eax,0xc(%ebp) 110b7a: 89 55 08 mov %edx,0x8(%ebp)
}
110b7d: 8d 65 f4 lea -0xc(%ebp),%esp 110b80: 5b pop %ebx 110b81: 5e pop %esi 110b82: 5f pop %edi 110b83: 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 );
110b84: e9 9f c6 ff ff jmp 10d228 <_Thread_queue_Enqueue_with_handler> 110b89: 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 );
110b8c: 89 5d 0c mov %ebx,0xc(%ebp) 110b8f: 83 c2 68 add $0x68,%edx 110b92: 89 55 08 mov %edx,0x8(%ebp)
}
110b95: 8d 65 f4 lea -0xc(%ebp),%esp 110b98: 5b pop %ebx 110b99: 5e pop %esi 110b9a: 5f pop %edi 110b9b: c9 leave 110b9c: e9 2f a9 ff ff jmp 10b4d0 <_Chain_Append>
00110ba4 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
110ba4: 55 push %ebp 110ba5: 89 e5 mov %esp,%ebp 110ba7: 57 push %edi 110ba8: 56 push %esi 110ba9: 53 push %ebx 110baa: 83 ec 1c sub $0x1c,%esp 110bad: 8b 5d 08 mov 0x8(%ebp),%ebx 110bb0: 8b 75 0c mov 0xc(%ebp),%esi 110bb3: 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 ) {
110bb6: 8b 45 10 mov 0x10(%ebp),%eax 110bb9: 39 43 4c cmp %eax,0x4c(%ebx)
110bbc: 72 32 jb 110bf0 <_CORE_message_queue_Submit+0x4c>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
110bbe: 8b 43 48 mov 0x48(%ebx),%eax 110bc1: 85 c0 test %eax,%eax
110bc3: 74 3b je 110c00 <_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 <
110bc5: 39 43 44 cmp %eax,0x44(%ebx)
110bc8: 0f 87 ba 00 00 00 ja 110c88 <_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 ) {
110bce: 84 c9 test %cl,%cl
110bd0: 0f 84 ee 00 00 00 je 110cc4 <_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() ) {
110bd6: 8b 15 94 7d 12 00 mov 0x127d94,%edx 110bdc: 85 d2 test %edx,%edx
110bde: 74 60 je 110c40 <_CORE_message_queue_Submit+0x9c>
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
110be0: 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
}
110be5: 8d 65 f4 lea -0xc(%ebp),%esp 110be8: 5b pop %ebx 110be9: 5e pop %esi 110bea: 5f pop %edi 110beb: c9 leave 110bec: c3 ret 110bed: 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;
110bf0: 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
}
110bf5: 8d 65 f4 lea -0xc(%ebp),%esp 110bf8: 5b pop %ebx 110bf9: 5e pop %esi 110bfa: 5f pop %edi 110bfb: c9 leave 110bfc: c3 ret 110bfd: 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 );
110c00: 83 ec 0c sub $0xc,%esp 110c03: 53 push %ebx 110c04: 88 4d e4 mov %cl,-0x1c(%ebp) 110c07: e8 f4 c4 ff ff call 10d100 <_Thread_queue_Dequeue> 110c0c: 89 c2 mov %eax,%edx
if ( the_thread ) {
110c0e: 83 c4 10 add $0x10,%esp 110c11: 85 c0 test %eax,%eax 110c13: 8a 4d e4 mov -0x1c(%ebp),%cl
110c16: 0f 84 b8 00 00 00 je 110cd4 <_CORE_message_queue_Submit+0x130>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
110c1c: 8b 40 2c mov 0x2c(%eax),%eax 110c1f: 89 c7 mov %eax,%edi 110c21: 8b 4d 10 mov 0x10(%ebp),%ecx 110c24: 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;
110c26: 8b 42 28 mov 0x28(%edx),%eax 110c29: 8b 4d 10 mov 0x10(%ebp),%ecx 110c2c: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = (uint32_t) submit_type;
110c2e: 8b 45 1c mov 0x1c(%ebp),%eax 110c31: 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;
110c34: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
110c36: 8d 65 f4 lea -0xc(%ebp),%esp 110c39: 5b pop %ebx 110c3a: 5e pop %esi 110c3b: 5f pop %edi 110c3c: c9 leave 110c3d: c3 ret 110c3e: 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;
110c40: a1 98 7d 12 00 mov 0x127d98,%eax
ISR_Level level;
_ISR_Disable( level );
110c45: 9c pushf 110c46: fa cli 110c47: 59 pop %ecx 110c48: 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;
110c4f: 89 58 44 mov %ebx,0x44(%eax)
executing->Wait.id = id;
110c52: 8b 55 14 mov 0x14(%ebp),%edx 110c55: 89 50 20 mov %edx,0x20(%eax)
executing->Wait.return_argument_second.immutable_object = buffer;
110c58: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.option = (uint32_t) size;
110c5b: 8b 55 10 mov 0x10(%ebp),%edx 110c5e: 89 50 30 mov %edx,0x30(%eax)
executing->Wait.count = submit_type;
110c61: 8b 55 1c mov 0x1c(%ebp),%edx 110c64: 89 50 24 mov %edx,0x24(%eax)
_ISR_Enable( level );
110c67: 51 push %ecx 110c68: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
110c69: 50 push %eax 110c6a: 68 54 d5 10 00 push $0x10d554 110c6f: ff 75 24 pushl 0x24(%ebp) 110c72: 53 push %ebx 110c73: e8 b0 c5 ff ff call 10d228 <_Thread_queue_Enqueue_with_handler>
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
110c78: 83 c4 10 add $0x10,%esp 110c7b: b8 07 00 00 00 mov $0x7,%eax
#endif }
110c80: 8d 65 f4 lea -0xc(%ebp),%esp 110c83: 5b pop %ebx 110c84: 5e pop %esi 110c85: 5f pop %edi 110c86: c9 leave 110c87: 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 );
110c88: 83 ec 0c sub $0xc,%esp 110c8b: 8d 43 68 lea 0x68(%ebx),%eax 110c8e: 50 push %eax 110c8f: e8 78 a8 ff ff call 10b50c <_Chain_Get> 110c94: 89 c2 mov %eax,%edx
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
#endif
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
110c96: 8d 40 10 lea 0x10(%eax),%eax
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
110c99: 89 c7 mov %eax,%edi 110c9b: 8b 4d 10 mov 0x10(%ebp),%ecx 110c9e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
size
);
the_message->Contents.size = size;
110ca0: 8b 4d 10 mov 0x10(%ebp),%ecx 110ca3: 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;
110ca6: 8b 45 1c mov 0x1c(%ebp),%eax 110ca9: 89 42 08 mov %eax,0x8(%edx)
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
110cac: 83 c4 0c add $0xc,%esp 110caf: 50 push %eax 110cb0: 52 push %edx 110cb1: 53 push %ebx 110cb2: e8 e9 1e 00 00 call 112ba0 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
110cb7: 83 c4 10 add $0x10,%esp 110cba: 31 c0 xor %eax,%eax 110cbc: e9 34 ff ff ff jmp 110bf5 <_CORE_message_queue_Submit+0x51> 110cc1: 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;
110cc4: 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
}
110cc9: 8d 65 f4 lea -0xc(%ebp),%esp 110ccc: 5b pop %ebx 110ccd: 5e pop %esi 110cce: 5f pop %edi 110ccf: c9 leave 110cd0: c3 ret 110cd1: 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 ) {
110cd4: 8b 43 48 mov 0x48(%ebx),%eax 110cd7: e9 e9 fe ff ff jmp 110bc5 <_CORE_message_queue_Submit+0x21>
0010b53c <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10b53c: 55 push %ebp 10b53d: 89 e5 mov %esp,%ebp 10b53f: 57 push %edi 10b540: 56 push %esi 10b541: 53 push %ebx 10b542: 83 ec 0c sub $0xc,%esp 10b545: 8b 45 08 mov 0x8(%ebp),%eax 10b548: 8b 5d 0c mov 0xc(%ebp),%ebx 10b54b: 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;
10b54e: 8d 78 40 lea 0x40(%eax),%edi 10b551: b9 04 00 00 00 mov $0x4,%ecx 10b556: 89 de mov %ebx,%esi 10b558: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10b55a: 89 50 50 mov %edx,0x50(%eax)
the_mutex->blocked_count = 0;
10b55d: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10b564: 85 d2 test %edx,%edx
10b566: 75 30 jne 10b598 <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10b568: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
the_mutex->holder = _Thread_Executing;
10b56f: 8b 15 98 7d 12 00 mov 0x127d98,%edx 10b575: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = _Thread_Executing->Object.id;
10b578: 8b 4a 08 mov 0x8(%edx),%ecx 10b57b: 89 48 60 mov %ecx,0x60(%eax)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b57e: 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 ) ||
10b581: 83 f9 02 cmp $0x2,%ecx
10b584: 74 05 je 10b58b <_CORE_mutex_Initialize+0x4f>
10b586: 83 f9 03 cmp $0x3,%ecx
10b589: 75 22 jne 10b5ad <_CORE_mutex_Initialize+0x71>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10b58b: 8b 48 4c mov 0x4c(%eax),%ecx 10b58e: 39 4a 14 cmp %ecx,0x14(%edx)
10b591: 72 41 jb 10b5d4 <_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++;
10b593: ff 42 1c incl 0x1c(%edx) 10b596: eb 15 jmp 10b5ad <_CORE_mutex_Initialize+0x71>
}
} else {
the_mutex->nest_count = 0;
10b598: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_mutex->holder = NULL;
10b59f: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
the_mutex->holder_id = 0;
10b5a6: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
}
_Thread_queue_Initialize(
10b5ad: 6a 05 push $0x5 10b5af: 68 00 04 00 00 push $0x400 10b5b4: 31 d2 xor %edx,%edx 10b5b6: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b5ba: 0f 95 c2 setne %dl 10b5bd: 52 push %edx 10b5be: 50 push %eax 10b5bf: e8 cc 1e 00 00 call 10d490 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b5c4: 83 c4 10 add $0x10,%esp 10b5c7: 31 c0 xor %eax,%eax
}
10b5c9: 8d 65 f4 lea -0xc(%ebp),%esp 10b5cc: 5b pop %ebx 10b5cd: 5e pop %esi 10b5ce: 5f pop %edi 10b5cf: c9 leave 10b5d0: c3 ret 10b5d1: 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;
10b5d4: b8 06 00 00 00 mov $0x6,%eax
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b5d9: 8d 65 f4 lea -0xc(%ebp),%esp 10b5dc: 5b pop %ebx 10b5dd: 5e pop %esi 10b5de: 5f pop %edi 10b5df: c9 leave 10b5e0: c3 ret
0010b634 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10b634: 55 push %ebp 10b635: 89 e5 mov %esp,%ebp 10b637: 53 push %ebx 10b638: 83 ec 14 sub $0x14,%esp 10b63b: 8b 5d 08 mov 0x8(%ebp),%ebx 10b63e: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10b641: a1 ec 77 12 00 mov 0x1277ec,%eax 10b646: 85 c0 test %eax,%eax
10b648: 74 04 je 10b64e <_CORE_mutex_Seize+0x1a>
10b64a: 84 d2 test %dl,%dl
10b64c: 75 36 jne 10b684 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN
10b64e: 83 ec 08 sub $0x8,%esp 10b651: 8d 45 18 lea 0x18(%ebp),%eax 10b654: 50 push %eax 10b655: 53 push %ebx 10b656: 88 55 f4 mov %dl,-0xc(%ebp) 10b659: e8 7e 56 00 00 call 110cdc <_CORE_mutex_Seize_interrupt_trylock> 10b65e: 83 c4 10 add $0x10,%esp 10b661: 85 c0 test %eax,%eax 10b663: 8a 55 f4 mov -0xc(%ebp),%dl
10b666: 74 14 je 10b67c <_CORE_mutex_Seize+0x48>
10b668: 84 d2 test %dl,%dl
10b66a: 75 30 jne 10b69c <_CORE_mutex_Seize+0x68>
10b66c: ff 75 18 pushl 0x18(%ebp) 10b66f: 9d popf 10b670: a1 98 7d 12 00 mov 0x127d98,%eax 10b675: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10b67c: 8b 5d fc mov -0x4(%ebp),%ebx 10b67f: c9 leave 10b680: c3 ret 10b681: 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 );
10b684: 83 3d 80 79 12 00 01 cmpl $0x1,0x127980
10b68b: 76 c1 jbe 10b64e <_CORE_mutex_Seize+0x1a>
10b68d: 53 push %ebx 10b68e: 6a 12 push $0x12 10b690: 6a 00 push $0x0 10b692: 6a 00 push $0x0 10b694: e8 1b 06 00 00 call 10bcb4 <_Internal_error_Occurred> 10b699: 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;
10b69c: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10b6a3: a1 98 7d 12 00 mov 0x127d98,%eax 10b6a8: 89 58 44 mov %ebx,0x44(%eax) 10b6ab: 8b 55 0c mov 0xc(%ebp),%edx 10b6ae: 89 50 20 mov %edx,0x20(%eax) 10b6b1: a1 ec 77 12 00 mov 0x1277ec,%eax 10b6b6: 40 inc %eax 10b6b7: a3 ec 77 12 00 mov %eax,0x1277ec 10b6bc: ff 75 18 pushl 0x18(%ebp) 10b6bf: 9d popf 10b6c0: 83 ec 08 sub $0x8,%esp 10b6c3: ff 75 14 pushl 0x14(%ebp) 10b6c6: 53 push %ebx 10b6c7: e8 18 ff ff ff call 10b5e4 <_CORE_mutex_Seize_interrupt_blocking> 10b6cc: 83 c4 10 add $0x10,%esp
}
10b6cf: 8b 5d fc mov -0x4(%ebp),%ebx 10b6d2: c9 leave 10b6d3: c3 ret
00110cdc <_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
)
{
110cdc: 55 push %ebp 110cdd: 89 e5 mov %esp,%ebp 110cdf: 56 push %esi 110ce0: 53 push %ebx 110ce1: 8b 45 08 mov 0x8(%ebp),%eax 110ce4: 8b 4d 0c mov 0xc(%ebp),%ecx
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
110ce7: 8b 15 98 7d 12 00 mov 0x127d98,%edx
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
110ced: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
110cf4: 8b 58 50 mov 0x50(%eax),%ebx 110cf7: 85 db test %ebx,%ebx
110cf9: 74 31 je 110d2c <_CORE_mutex_Seize_interrupt_trylock+0x50>
the_mutex->lock = CORE_MUTEX_LOCKED;
110cfb: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
the_mutex->holder = executing;
110d02: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = executing->Object.id;
110d05: 8b 5a 08 mov 0x8(%edx),%ebx 110d08: 89 58 60 mov %ebx,0x60(%eax)
the_mutex->nest_count = 1;
110d0b: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
110d12: 8b 58 48 mov 0x48(%eax),%ebx
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
110d15: 83 fb 02 cmp $0x2,%ebx
110d18: 74 26 je 110d40 <_CORE_mutex_Seize_interrupt_trylock+0x64>
110d1a: 83 fb 03 cmp $0x3,%ebx
110d1d: 74 3d je 110d5c <_CORE_mutex_Seize_interrupt_trylock+0x80>
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
110d1f: ff 31 pushl (%ecx) 110d21: 9d popf
return 0;
110d22: 31 c0 xor %eax,%eax 110d24: 8d 65 f8 lea -0x8(%ebp),%esp 110d27: 5b pop %ebx 110d28: 5e pop %esi 110d29: c9 leave 110d2a: c3 ret 110d2b: 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 ) ) {
110d2c: 3b 50 5c cmp 0x5c(%eax),%edx
110d2f: 74 17 je 110d48 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
110d31: b8 01 00 00 00 mov $0x1,%eax 110d36: 8d 65 f8 lea -0x8(%ebp),%esp 110d39: 5b pop %ebx 110d3a: 5e pop %esi 110d3b: c9 leave 110d3c: c3 ret 110d3d: 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++;
110d40: ff 42 1c incl 0x1c(%edx) 110d43: eb da jmp 110d1f <_CORE_mutex_Seize_interrupt_trylock+0x43> 110d45: 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 ) {
110d48: 8b 58 40 mov 0x40(%eax),%ebx 110d4b: 85 db test %ebx,%ebx
110d4d: 75 45 jne 110d94 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
110d4f: ff 40 54 incl 0x54(%eax)
_ISR_Enable( *level_p );
110d52: ff 31 pushl (%ecx) 110d54: 9d popf
return 0;
110d55: 31 c0 xor %eax,%eax 110d57: eb dd jmp 110d36 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 110d59: 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++;
110d5c: 8b 5a 1c mov 0x1c(%edx),%ebx 110d5f: 8d 73 01 lea 0x1(%ebx),%esi 110d62: 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 ) {
110d65: 8b 72 14 mov 0x14(%edx),%esi 110d68: 39 70 4c cmp %esi,0x4c(%eax)
110d6b: 74 6b je 110dd8 <_CORE_mutex_Seize_interrupt_trylock+0xfc>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
110d6d: 72 39 jb 110da8 <_CORE_mutex_Seize_interrupt_trylock+0xcc>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
110d6f: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
110d76: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax)
the_mutex->nest_count = 0; /* undo locking above */
110d7d: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
executing->resource_count--; /* undo locking above */
110d84: 89 5a 1c mov %ebx,0x1c(%edx)
_ISR_Enable( *level_p );
110d87: ff 31 pushl (%ecx) 110d89: 9d popf
return 0;
110d8a: 31 c0 xor %eax,%eax 110d8c: 8d 65 f8 lea -0x8(%ebp),%esp 110d8f: 5b pop %ebx 110d90: 5e pop %esi 110d91: c9 leave 110d92: c3 ret 110d93: 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 ) {
110d94: 4b dec %ebx
110d95: 75 9a jne 110d31 <_CORE_mutex_Seize_interrupt_trylock+0x55>
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
110d97: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
_ISR_Enable( *level_p );
110d9e: ff 31 pushl (%ecx) 110da0: 9d popf
return 0;
110da1: 31 c0 xor %eax,%eax 110da3: eb 91 jmp 110d36 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 110da5: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
110da8: 8b 15 ec 77 12 00 mov 0x1277ec,%edx 110dae: 42 inc %edx 110daf: 89 15 ec 77 12 00 mov %edx,0x1277ec
return 0;
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
110db5: ff 31 pushl (%ecx) 110db7: 9d popf
_Thread_Change_priority(
110db8: 52 push %edx 110db9: 6a 00 push $0x0 110dbb: ff 70 4c pushl 0x4c(%eax) 110dbe: ff 70 5c pushl 0x5c(%eax) 110dc1: e8 82 bb ff ff call 10c948 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
110dc6: e8 b5 bf ff ff call 10cd80 <_Thread_Enable_dispatch> 110dcb: 83 c4 10 add $0x10,%esp
return 0;
110dce: 31 c0 xor %eax,%eax 110dd0: e9 61 ff ff ff jmp 110d36 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 110dd5: 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 );
110dd8: ff 31 pushl (%ecx) 110dda: 9d popf
return 0;
110ddb: 31 c0 xor %eax,%eax 110ddd: e9 54 ff ff ff jmp 110d36 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
0010b6d4 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
10b6d4: 55 push %ebp 10b6d5: 89 e5 mov %esp,%ebp 10b6d7: 53 push %ebx 10b6d8: 83 ec 04 sub $0x4,%esp 10b6db: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
10b6de: 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 ) {
10b6e1: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10b6e5: 74 15 je 10b6fc <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10b6e7: 3b 05 98 7d 12 00 cmp 0x127d98,%eax
10b6ed: 74 0d je 10b6fc <_CORE_mutex_Surrender+0x28>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
10b6ef: b8 03 00 00 00 mov $0x3,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b6f4: 8b 5d fc mov -0x4(%ebp),%ebx 10b6f7: c9 leave 10b6f8: c3 ret 10b6f9: 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 )
10b6fc: 8b 53 54 mov 0x54(%ebx),%edx 10b6ff: 85 d2 test %edx,%edx
10b701: 74 51 je 10b754 <_CORE_mutex_Surrender+0x80>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10b703: 4a dec %edx 10b704: 89 53 54 mov %edx,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10b707: 85 d2 test %edx,%edx
10b709: 75 49 jne 10b754 <_CORE_mutex_Surrender+0x80>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b70b: 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 ) ||
10b70e: 83 fa 02 cmp $0x2,%edx
10b711: 74 69 je 10b77c <_CORE_mutex_Surrender+0xa8>
10b713: 83 fa 03 cmp $0x3,%edx
10b716: 74 64 je 10b77c <_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;
10b718: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10b71f: 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 ) ) ) {
10b726: 83 ec 0c sub $0xc,%esp 10b729: 53 push %ebx 10b72a: e8 d1 19 00 00 call 10d100 <_Thread_queue_Dequeue> 10b72f: 83 c4 10 add $0x10,%esp 10b732: 85 c0 test %eax,%eax
10b734: 74 7a je 10b7b0 <_CORE_mutex_Surrender+0xdc>
} else
#endif
{
the_mutex->holder = the_thread;
10b736: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10b739: 8b 50 08 mov 0x8(%eax),%edx 10b73c: 89 53 60 mov %edx,0x60(%ebx)
the_mutex->nest_count = 1;
10b73f: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10b746: 8b 53 48 mov 0x48(%ebx),%edx 10b749: 83 fa 02 cmp $0x2,%edx
10b74c: 74 56 je 10b7a4 <_CORE_mutex_Surrender+0xd0>
10b74e: 83 fa 03 cmp $0x3,%edx
10b751: 74 09 je 10b75c <_CORE_mutex_Surrender+0x88>
10b753: 90 nop
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b754: 31 c0 xor %eax,%eax
}
10b756: 8b 5d fc mov -0x4(%ebp),%ebx 10b759: c9 leave 10b75a: c3 ret 10b75b: 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++;
10b75c: ff 40 1c incl 0x1c(%eax)
if (the_mutex->Attributes.priority_ceiling <
10b75f: 8b 53 4c mov 0x4c(%ebx),%edx 10b762: 3b 50 14 cmp 0x14(%eax),%edx
10b765: 73 ed jae 10b754 <_CORE_mutex_Surrender+0x80>
the_thread->current_priority){
_Thread_Change_priority(
10b767: 51 push %ecx 10b768: 6a 00 push $0x0 10b76a: 52 push %edx 10b76b: 50 push %eax 10b76c: e8 d7 11 00 00 call 10c948 <_Thread_Change_priority> 10b771: 83 c4 10 add $0x10,%esp
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b774: 31 c0 xor %eax,%eax 10b776: e9 79 ff ff ff jmp 10b6f4 <_CORE_mutex_Surrender+0x20> 10b77b: 90 nop
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
10b77c: 8b 50 1c mov 0x1c(%eax),%edx 10b77f: 4a dec %edx 10b780: 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 &&
10b783: 85 d2 test %edx,%edx
10b785: 75 91 jne 10b718 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
10b787: 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 &&
10b78a: 3b 50 14 cmp 0x14(%eax),%edx
10b78d: 74 89 je 10b718 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
10b78f: 51 push %ecx 10b790: 6a 01 push $0x1 10b792: 52 push %edx 10b793: 50 push %eax 10b794: e8 af 11 00 00 call 10c948 <_Thread_Change_priority> 10b799: 83 c4 10 add $0x10,%esp 10b79c: e9 77 ff ff ff jmp 10b718 <_CORE_mutex_Surrender+0x44> 10b7a1: 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++;
10b7a4: ff 40 1c incl 0x1c(%eax)
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b7a7: 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;
10b7a9: e9 46 ff ff ff jmp 10b6f4 <_CORE_mutex_Surrender+0x20> 10b7ae: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10b7b0: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b7b7: 31 c0 xor %eax,%eax 10b7b9: e9 36 ff ff ff jmp 10b6f4 <_CORE_mutex_Surrender+0x20>
00114d5c <_CORE_semaphore_Seize>:
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
114d5c: 55 push %ebp 114d5d: 89 e5 mov %esp,%ebp 114d5f: 57 push %edi 114d60: 56 push %esi 114d61: 53 push %ebx 114d62: 83 ec 1c sub $0x1c,%esp 114d65: 8b 45 08 mov 0x8(%ebp),%eax 114d68: 8b 7d 0c mov 0xc(%ebp),%edi 114d6b: 8b 75 14 mov 0x14(%ebp),%esi 114d6e: 8a 5d 10 mov 0x10(%ebp),%bl
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
114d71: 8b 15 98 cc 12 00 mov 0x12cc98,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
114d77: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Disable( level );
114d7e: 9c pushf 114d7f: fa cli 114d80: 8f 45 e4 popl -0x1c(%ebp)
if ( the_semaphore->count != 0 ) {
114d83: 8b 48 48 mov 0x48(%eax),%ecx 114d86: 85 c9 test %ecx,%ecx
114d88: 75 46 jne 114dd0 <_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 ) {
114d8a: 84 db test %bl,%bl
114d8c: 75 16 jne 114da4 <_CORE_semaphore_Seize+0x48>
_ISR_Enable( level );
114d8e: ff 75 e4 pushl -0x1c(%ebp) 114d91: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
114d92: 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 ); }
114d99: 83 c4 1c add $0x1c,%esp 114d9c: 5b pop %ebx 114d9d: 5e pop %esi 114d9e: 5f pop %edi 114d9f: c9 leave 114da0: c3 ret 114da1: 8d 76 00 lea 0x0(%esi),%esi 114da4: 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;
114dab: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
114dae: 89 7a 20 mov %edi,0x20(%edx)
_ISR_Enable( level );
114db1: ff 75 e4 pushl -0x1c(%ebp) 114db4: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
114db5: c7 45 10 f0 0e 11 00 movl $0x110ef0,0x10(%ebp) 114dbc: 89 75 0c mov %esi,0xc(%ebp) 114dbf: 89 45 08 mov %eax,0x8(%ebp)
}
114dc2: 83 c4 1c add $0x1c,%esp 114dc5: 5b pop %ebx 114dc6: 5e pop %esi 114dc7: 5f pop %edi 114dc8: 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 );
114dc9: e9 f6 bd ff ff jmp 110bc4 <_Thread_queue_Enqueue_with_handler> 114dce: 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;
114dd0: 49 dec %ecx 114dd1: 89 48 48 mov %ecx,0x48(%eax)
_ISR_Enable( level );
114dd4: ff 75 e4 pushl -0x1c(%ebp) 114dd7: 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 ); }
114dd8: 83 c4 1c add $0x1c,%esp 114ddb: 5b pop %ebx 114ddc: 5e pop %esi 114ddd: 5f pop %edi 114dde: c9 leave 114ddf: c3 ret
0010b80c <_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
)
{
10b80c: 55 push %ebp 10b80d: 89 e5 mov %esp,%ebp 10b80f: 53 push %ebx 10b810: 83 ec 10 sub $0x10,%esp 10b813: 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)) ) {
10b816: 53 push %ebx 10b817: e8 e4 18 00 00 call 10d100 <_Thread_queue_Dequeue> 10b81c: 83 c4 10 add $0x10,%esp 10b81f: 85 c0 test %eax,%eax
10b821: 74 09 je 10b82c <_CORE_semaphore_Surrender+0x20>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b823: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10b825: 8b 5d fc mov -0x4(%ebp),%ebx 10b828: c9 leave 10b829: c3 ret 10b82a: 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 );
10b82c: 9c pushf 10b82d: fa cli 10b82e: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10b82f: 8b 43 48 mov 0x48(%ebx),%eax 10b832: 3b 43 40 cmp 0x40(%ebx),%eax
10b835: 72 0d jb 10b844 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10b837: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10b83c: 52 push %edx 10b83d: 9d popf
}
return status;
}
10b83e: 8b 5d fc mov -0x4(%ebp),%ebx 10b841: c9 leave 10b842: c3 ret 10b843: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10b844: 40 inc %eax 10b845: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b848: 31 c0 xor %eax,%eax 10b84a: eb f0 jmp 10b83c <_CORE_semaphore_Surrender+0x30>
0010bc74 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
10bc74: 55 push %ebp 10bc75: 89 e5 mov %esp,%ebp 10bc77: 57 push %edi 10bc78: 56 push %esi 10bc79: 53 push %ebx 10bc7a: 8b 45 08 mov 0x8(%ebp),%eax 10bc7d: 8b 7d 0c mov 0xc(%ebp),%edi
ISR_Level level;
bool is_empty_now;
_ISR_Disable( level );
10bc80: 9c pushf 10bc81: fa cli 10bc82: 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 );
10bc83: 8d 58 04 lea 0x4(%eax),%ebx
Chain_Node *old_first = head->next;
10bc86: 8b 10 mov (%eax),%edx
if ( old_first != tail ) {
10bc88: 39 d3 cmp %edx,%ebx
10bc8a: 74 18 je 10bca4 <_Chain_Get_with_empty_check+0x30>
Chain_Node *new_first = old_first->next;
10bc8c: 8b 0a mov (%edx),%ecx
head->next = new_first;
10bc8e: 89 08 mov %ecx,(%eax)
new_first->previous = head;
10bc90: 89 41 04 mov %eax,0x4(%ecx)
*the_node = old_first;
10bc93: 89 17 mov %edx,(%edi)
is_empty_now = new_first == tail;
10bc95: 39 cb cmp %ecx,%ebx 10bc97: 0f 94 c0 sete %al
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level );
10bc9a: 56 push %esi 10bc9b: 9d popf
return is_empty_now;
}
10bc9c: 5b pop %ebx 10bc9d: 5e pop %esi 10bc9e: 5f pop %edi 10bc9f: c9 leave 10bca0: c3 ret 10bca1: 8d 76 00 lea 0x0(%esi),%esi
} else
*the_node = NULL;
10bca4: 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;
10bcaa: b0 01 mov $0x1,%al 10bcac: eb ec jmp 10bc9a <_Chain_Get_with_empty_check+0x26>
001108e8 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
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 08 sub $0x8,%esp 1108f1: 8b 7d 08 mov 0x8(%ebp),%edi 1108f4: 8b 4d 10 mov 0x10(%ebp),%ecx 1108f7: 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 );
1108fa: 8d 47 04 lea 0x4(%edi),%eax 1108fd: 89 45 f0 mov %eax,-0x10(%ebp)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
110900: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
while ( count-- ) {
110907: 85 c9 test %ecx,%ecx
110909: 74 35 je 110940 <_Chain_Initialize+0x58><== NEVER TAKEN
11090b: 49 dec %ecx 11090c: 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;
11090f: 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;
110912: 89 fa mov %edi,%edx 110914: eb 07 jmp 11091d <_Chain_Initialize+0x35> 110916: 66 90 xchg %ax,%ax
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
110918: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
11091a: 89 d8 mov %ebx,%eax 11091c: 49 dec %ecx
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
11091d: 89 02 mov %eax,(%edx)
next->previous = current;
11091f: 89 50 04 mov %edx,0x4(%eax)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
110922: 8d 1c 30 lea (%eax,%esi,1),%ebx
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
110925: 85 c9 test %ecx,%ecx
110927: 75 ef jne 110918 <_Chain_Initialize+0x30>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
110929: 0f af 75 ec imul -0x14(%ebp),%esi 11092d: 03 75 0c add 0xc(%ebp),%esi
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
110930: 8b 45 f0 mov -0x10(%ebp),%eax 110933: 89 06 mov %eax,(%esi)
tail->previous = current;
110935: 89 77 08 mov %esi,0x8(%edi)
}
110938: 83 c4 08 add $0x8,%esp 11093b: 5b pop %ebx 11093c: 5e pop %esi 11093d: 5f pop %edi 11093e: c9 leave 11093f: 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;
110940: 89 fe mov %edi,%esi <== NOT EXECUTED 110942: eb ec jmp 110930 <_Chain_Initialize+0x48><== NOT EXECUTED
0010a618 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
10a618: 55 push %ebp 10a619: 89 e5 mov %esp,%ebp 10a61b: 57 push %edi 10a61c: 56 push %esi 10a61d: 53 push %ebx 10a61e: 83 ec 2c sub $0x2c,%esp 10a621: 8b 45 08 mov 0x8(%ebp),%eax 10a624: 8b 4d 0c mov 0xc(%ebp),%ecx 10a627: 8b 55 10 mov 0x10(%ebp),%edx 10a62a: 89 55 dc mov %edx,-0x24(%ebp) 10a62d: 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;
10a630: 8b 1d 98 7d 12 00 mov 0x127d98,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
10a636: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10a63d: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi
_ISR_Disable( level );
10a643: 9c pushf 10a644: fa cli 10a645: 8f 45 e0 popl -0x20(%ebp)
pending_events = api->pending_events;
10a648: 8b 16 mov (%esi),%edx 10a64a: 89 55 d4 mov %edx,-0x2c(%ebp)
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
10a64d: 21 c2 and %eax,%edx 10a64f: 89 55 e4 mov %edx,-0x1c(%ebp)
10a652: 74 0d je 10a661 <_Event_Seize+0x49>
10a654: 39 d0 cmp %edx,%eax
10a656: 0f 84 84 00 00 00 je 10a6e0 <_Event_Seize+0xc8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
10a65c: f6 c1 02 test $0x2,%cl
10a65f: 75 7f jne 10a6e0 <_Event_Seize+0xc8>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
10a661: f6 c1 01 test $0x1,%cl
10a664: 75 62 jne 10a6c8 <_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;
10a666: 89 4b 30 mov %ecx,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
10a669: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
10a66c: 89 7b 28 mov %edi,0x28(%ebx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10a66f: c7 05 c8 81 12 00 01 movl $0x1,0x1281c8
10a676: 00 00 00
_ISR_Enable( level );
10a679: ff 75 e0 pushl -0x20(%ebp) 10a67c: 9d popf
if ( ticks ) {
10a67d: 8b 45 dc mov -0x24(%ebp),%eax 10a680: 85 c0 test %eax,%eax
10a682: 0f 85 80 00 00 00 jne 10a708 <_Event_Seize+0xf0>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
10a688: 83 ec 08 sub $0x8,%esp 10a68b: 68 00 01 00 00 push $0x100 10a690: 53 push %ebx 10a691: e8 0e 2f 00 00 call 10d5a4 <_Thread_Set_state>
_ISR_Disable( level );
10a696: 9c pushf 10a697: fa cli 10a698: 5a pop %edx
sync_state = _Event_Sync_state;
10a699: a1 c8 81 12 00 mov 0x1281c8,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10a69e: c7 05 c8 81 12 00 00 movl $0x0,0x1281c8
10a6a5: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
10a6a8: 83 c4 10 add $0x10,%esp 10a6ab: 83 f8 01 cmp $0x1,%eax
10a6ae: 74 4c je 10a6fc <_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 );
10a6b0: 89 55 10 mov %edx,0x10(%ebp) 10a6b3: 89 5d 0c mov %ebx,0xc(%ebp) 10a6b6: 89 45 08 mov %eax,0x8(%ebp)
}
10a6b9: 8d 65 f4 lea -0xc(%ebp),%esp 10a6bc: 5b pop %ebx 10a6bd: 5e pop %esi 10a6be: 5f pop %edi 10a6bf: 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 );
10a6c0: e9 37 22 00 00 jmp 10c8fc <_Thread_blocking_operation_Cancel> 10a6c5: 8d 76 00 lea 0x0(%esi),%esi
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
10a6c8: ff 75 e0 pushl -0x20(%ebp) 10a6cb: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
10a6cc: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
10a6d3: 8b 55 e4 mov -0x1c(%ebp),%edx 10a6d6: 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 ); }
10a6d8: 8d 65 f4 lea -0xc(%ebp),%esp 10a6db: 5b pop %ebx 10a6dc: 5e pop %esi 10a6dd: 5f pop %edi 10a6de: c9 leave 10a6df: 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) );
10a6e0: 8b 45 e4 mov -0x1c(%ebp),%eax 10a6e3: f7 d0 not %eax 10a6e5: 23 45 d4 and -0x2c(%ebp),%eax 10a6e8: 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 );
10a6ea: ff 75 e0 pushl -0x20(%ebp) 10a6ed: 9d popf
*event_out = seized_events;
10a6ee: 8b 45 e4 mov -0x1c(%ebp),%eax 10a6f1: 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 ); }
10a6f3: 8d 65 f4 lea -0xc(%ebp),%esp 10a6f6: 5b pop %ebx 10a6f7: 5e pop %esi 10a6f8: 5f pop %edi 10a6f9: c9 leave 10a6fa: c3 ret 10a6fb: 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 );
10a6fc: 52 push %edx 10a6fd: 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 ); }
10a6fe: 8d 65 f4 lea -0xc(%ebp),%esp 10a701: 5b pop %ebx 10a702: 5e pop %esi 10a703: 5f pop %edi 10a704: c9 leave 10a705: c3 ret 10a706: 66 90 xchg %ax,%ax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
10a708: 8b 43 08 mov 0x8(%ebx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10a70b: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10a712: c7 43 64 bc a8 10 00 movl $0x10a8bc,0x64(%ebx)
the_watchdog->id = id;
10a719: 89 43 68 mov %eax,0x68(%ebx)
the_watchdog->user_data = user_data;
10a71c: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a723: 8b 45 dc mov -0x24(%ebp),%eax 10a726: 89 43 54 mov %eax,0x54(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a729: 83 ec 08 sub $0x8,%esp
&executing->Timer,
_Event_Timeout,
executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
10a72c: 8d 43 48 lea 0x48(%ebx),%eax 10a72f: 50 push %eax 10a730: 68 c0 78 12 00 push $0x1278c0 10a735: e8 ba 33 00 00 call 10daf4 <_Watchdog_Insert> 10a73a: 83 c4 10 add $0x10,%esp 10a73d: e9 46 ff ff ff jmp 10a688 <_Event_Seize+0x70>
0010a798 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
10a798: 55 push %ebp 10a799: 89 e5 mov %esp,%ebp 10a79b: 57 push %edi 10a79c: 56 push %esi 10a79d: 53 push %ebx 10a79e: 83 ec 2c sub $0x2c,%esp 10a7a1: 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 ];
10a7a4: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx
option_set = (rtems_option) the_thread->Wait.option;
10a7aa: 8b 7b 30 mov 0x30(%ebx),%edi
_ISR_Disable( level );
10a7ad: 9c pushf 10a7ae: fa cli 10a7af: 8f 45 d4 popl -0x2c(%ebp)
pending_events = api->pending_events;
10a7b2: 8b 11 mov (%ecx),%edx
event_condition = (rtems_event_set) the_thread->Wait.count;
10a7b4: 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 ) ) {
10a7b7: 89 c6 mov %eax,%esi 10a7b9: 21 d6 and %edx,%esi 10a7bb: 89 75 e4 mov %esi,-0x1c(%ebp)
10a7be: 74 74 je 10a834 <_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() &&
10a7c0: 8b 35 94 7d 12 00 mov 0x127d94,%esi 10a7c6: 85 f6 test %esi,%esi
10a7c8: 74 0c je 10a7d6 <_Event_Surrender+0x3e>
10a7ca: 3b 1d 98 7d 12 00 cmp 0x127d98,%ebx
10a7d0: 0f 84 96 00 00 00 je 10a86c <_Event_Surrender+0xd4>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
10a7d6: f6 43 11 01 testb $0x1,0x11(%ebx)
10a7da: 74 4c je 10a828 <_Event_Surrender+0x90>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
10a7dc: 3b 45 e4 cmp -0x1c(%ebp),%eax
10a7df: 74 05 je 10a7e6 <_Event_Surrender+0x4e>
10a7e1: 83 e7 02 and $0x2,%edi
10a7e4: 74 42 je 10a828 <_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) );
10a7e6: 8b 45 e4 mov -0x1c(%ebp),%eax 10a7e9: f7 d0 not %eax 10a7eb: 21 d0 and %edx,%eax 10a7ed: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
10a7ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10a7f6: 8b 43 28 mov 0x28(%ebx),%eax 10a7f9: 8b 75 e4 mov -0x1c(%ebp),%esi 10a7fc: 89 30 mov %esi,(%eax)
_ISR_Flash( level );
10a7fe: ff 75 d4 pushl -0x2c(%ebp) 10a801: 9d popf 10a802: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10a803: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10a807: 74 37 je 10a840 <_Event_Surrender+0xa8>
_ISR_Enable( level );
10a809: ff 75 d4 pushl -0x2c(%ebp) 10a80c: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10a80d: 83 ec 08 sub $0x8,%esp 10a810: 68 f8 ff 03 10 push $0x1003fff8 10a815: 53 push %ebx 10a816: e8 01 22 00 00 call 10ca1c <_Thread_Clear_state> 10a81b: 83 c4 10 add $0x10,%esp
}
return;
}
}
_ISR_Enable( level );
}
10a81e: 8d 65 f4 lea -0xc(%ebp),%esp 10a821: 5b pop %ebx 10a822: 5e pop %esi 10a823: 5f pop %edi 10a824: c9 leave 10a825: c3 ret 10a826: 66 90 xchg %ax,%ax
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
10a828: ff 75 d4 pushl -0x2c(%ebp) 10a82b: 9d popf
}
10a82c: 8d 65 f4 lea -0xc(%ebp),%esp 10a82f: 5b pop %ebx 10a830: 5e pop %esi 10a831: 5f pop %edi 10a832: c9 leave 10a833: c3 ret
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
10a834: ff 75 d4 pushl -0x2c(%ebp) 10a837: 9d popf
}
return;
}
}
_ISR_Enable( level );
}
10a838: 8d 65 f4 lea -0xc(%ebp),%esp 10a83b: 5b pop %ebx 10a83c: 5e pop %esi 10a83d: 5f pop %edi 10a83e: c9 leave 10a83f: c3 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10a840: 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 );
10a847: ff 75 d4 pushl -0x2c(%ebp) 10a84a: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10a84b: 83 ec 0c sub $0xc,%esp 10a84e: 8d 43 48 lea 0x48(%ebx),%eax 10a851: 50 push %eax 10a852: e8 dd 33 00 00 call 10dc34 <_Watchdog_Remove> 10a857: 58 pop %eax 10a858: 5a pop %edx 10a859: 68 f8 ff 03 10 push $0x1003fff8 10a85e: 53 push %ebx 10a85f: e8 b8 21 00 00 call 10ca1c <_Thread_Clear_state> 10a864: 83 c4 10 add $0x10,%esp 10a867: eb c3 jmp 10a82c <_Event_Surrender+0x94> 10a869: 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) ||
10a86c: 8b 35 c8 81 12 00 mov 0x1281c8,%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 ) &&
10a872: 83 fe 02 cmp $0x2,%esi
10a875: 74 0d je 10a884 <_Event_Surrender+0xec> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
10a877: 8b 35 c8 81 12 00 mov 0x1281c8,%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) ||
10a87d: 4e dec %esi
10a87e: 0f 85 52 ff ff ff jne 10a7d6 <_Event_Surrender+0x3e>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
10a884: 3b 45 e4 cmp -0x1c(%ebp),%eax
10a887: 74 05 je 10a88e <_Event_Surrender+0xf6>
10a889: 83 e7 02 and $0x2,%edi
10a88c: 74 22 je 10a8b0 <_Event_Surrender+0x118><== NEVER TAKEN
10a88e: 8b 45 e4 mov -0x1c(%ebp),%eax 10a891: f7 d0 not %eax 10a893: 21 d0 and %edx,%eax 10a895: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
10a897: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10a89e: 8b 43 28 mov 0x28(%ebx),%eax 10a8a1: 8b 55 e4 mov -0x1c(%ebp),%edx 10a8a4: 89 10 mov %edx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10a8a6: c7 05 c8 81 12 00 03 movl $0x3,0x1281c8
10a8ad: 00 00 00
}
_ISR_Enable( level );
10a8b0: ff 75 d4 pushl -0x2c(%ebp) 10a8b3: 9d popf
return;
10a8b4: e9 73 ff ff ff jmp 10a82c <_Event_Surrender+0x94>
0010a8bc <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10a8bc: 55 push %ebp 10a8bd: 89 e5 mov %esp,%ebp 10a8bf: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10a8c2: 8d 45 f4 lea -0xc(%ebp),%eax 10a8c5: 50 push %eax 10a8c6: ff 75 08 pushl 0x8(%ebp) 10a8c9: e8 d6 24 00 00 call 10cda4 <_Thread_Get>
switch ( location ) {
10a8ce: 83 c4 10 add $0x10,%esp 10a8d1: 8b 55 f4 mov -0xc(%ebp),%edx 10a8d4: 85 d2 test %edx,%edx
10a8d6: 75 37 jne 10a90f <_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 );
10a8d8: 9c pushf 10a8d9: fa cli 10a8da: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
10a8db: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
10a8e2: 3b 05 98 7d 12 00 cmp 0x127d98,%eax
10a8e8: 74 2a je 10a914 <_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;
10a8ea: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
10a8f1: 52 push %edx 10a8f2: 9d popf 10a8f3: 83 ec 08 sub $0x8,%esp 10a8f6: 68 f8 ff 03 10 push $0x1003fff8 10a8fb: 50 push %eax 10a8fc: e8 1b 21 00 00 call 10ca1c <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10a901: a1 ec 77 12 00 mov 0x1277ec,%eax 10a906: 48 dec %eax 10a907: a3 ec 77 12 00 mov %eax,0x1277ec
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
10a90c: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10a90f: c9 leave 10a910: c3 ret 10a911: 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 )
10a914: 8b 0d c8 81 12 00 mov 0x1281c8,%ecx 10a91a: 49 dec %ecx
10a91b: 75 cd jne 10a8ea <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10a91d: c7 05 c8 81 12 00 02 movl $0x2,0x1281c8
10a924: 00 00 00
10a927: eb c1 jmp 10a8ea <_Event_Timeout+0x2e>
00110e38 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
110e38: 55 push %ebp 110e39: 89 e5 mov %esp,%ebp 110e3b: 57 push %edi 110e3c: 56 push %esi 110e3d: 53 push %ebx 110e3e: 83 ec 2c sub $0x2c,%esp 110e41: 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
110e44: 8d 47 04 lea 0x4(%edi),%eax 110e47: 89 45 dc mov %eax,-0x24(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
110e4a: 8b 55 08 mov 0x8(%ebp),%edx 110e4d: 8b 52 10 mov 0x10(%edx),%edx 110e50: 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 ) {
110e53: 39 c7 cmp %eax,%edi
110e55: 0f 87 69 01 00 00 ja 110fc4 <_Heap_Allocate_aligned_with_boundary+0x18c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
110e5b: 8b 5d 14 mov 0x14(%ebp),%ebx 110e5e: 85 db test %ebx,%ebx
110e60: 0f 85 56 01 00 00 jne 110fbc <_Heap_Allocate_aligned_with_boundary+0x184>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
110e66: 8b 45 08 mov 0x8(%ebp),%eax 110e69: 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 ) {
110e6c: 39 c8 cmp %ecx,%eax
110e6e: 0f 84 50 01 00 00 je 110fc4 <_Heap_Allocate_aligned_with_boundary+0x18c>
110e74: 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
110e7b: 8b 55 cc mov -0x34(%ebp),%edx 110e7e: 83 c2 07 add $0x7,%edx 110e81: 89 55 c8 mov %edx,-0x38(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
110e84: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 110e8b: 29 7d d0 sub %edi,-0x30(%ebp) 110e8e: eb 1e jmp 110eae <_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;
110e90: 8d 59 08 lea 0x8(%ecx),%ebx
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
110e93: 85 db test %ebx,%ebx
110e95: 0f 85 f1 00 00 00 jne 110f8c <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN
break;
}
block = block->next;
110e9b: 8b 49 08 mov 0x8(%ecx),%ecx 110e9e: 8b 45 e4 mov -0x1c(%ebp),%eax 110ea1: 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 ) {
110ea2: 39 4d 08 cmp %ecx,0x8(%ebp)
110ea5: 0f 84 25 01 00 00 je 110fd0 <_Heap_Allocate_aligned_with_boundary+0x198>
110eab: 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 ) {
110eae: 8b 59 04 mov 0x4(%ecx),%ebx 110eb1: 39 5d dc cmp %ebx,-0x24(%ebp)
110eb4: 73 e5 jae 110e9b <_Heap_Allocate_aligned_with_boundary+0x63>
if ( alignment == 0 ) {
110eb6: 8b 55 10 mov 0x10(%ebp),%edx 110eb9: 85 d2 test %edx,%edx
110ebb: 74 d3 je 110e90 <_Heap_Allocate_aligned_with_boundary+0x58>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
110ebd: 8b 45 08 mov 0x8(%ebp),%eax 110ec0: 8b 40 14 mov 0x14(%eax),%eax 110ec3: 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;
110ec6: 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;
110ec9: 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;
110ecc: 8d 51 08 lea 0x8(%ecx),%edx 110ecf: 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;
110ed2: 8b 75 c8 mov -0x38(%ebp),%esi 110ed5: 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
110ed7: 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;
110ed9: 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);
110edc: 89 d8 mov %ebx,%eax 110ede: 31 d2 xor %edx,%edx 110ee0: f7 75 10 divl 0x10(%ebp) 110ee3: 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 ) {
110ee5: 39 de cmp %ebx,%esi
110ee7: 73 0b jae 110ef4 <_Heap_Allocate_aligned_with_boundary+0xbc>
110ee9: 89 f0 mov %esi,%eax 110eeb: 31 d2 xor %edx,%edx 110eed: f7 75 10 divl 0x10(%ebp) 110ef0: 89 f3 mov %esi,%ebx 110ef2: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
110ef4: 8b 45 14 mov 0x14(%ebp),%eax 110ef7: 85 c0 test %eax,%eax
110ef9: 74 5b je 110f56 <_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;
110efb: 8d 34 3b lea (%ebx,%edi,1),%esi 110efe: 89 f0 mov %esi,%eax 110f00: 31 d2 xor %edx,%edx 110f02: f7 75 14 divl 0x14(%ebp) 110f05: 89 f0 mov %esi,%eax 110f07: 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 ) {
110f09: 39 c3 cmp %eax,%ebx
110f0b: 73 49 jae 110f56 <_Heap_Allocate_aligned_with_boundary+0x11e>
110f0d: 39 c6 cmp %eax,%esi
110f0f: 76 45 jbe 110f56 <_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;
110f11: 8b 55 d4 mov -0x2c(%ebp),%edx 110f14: 01 fa add %edi,%edx 110f16: 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 ) {
110f19: 39 c2 cmp %eax,%edx
110f1b: 0f 87 7a ff ff ff ja 110e9b <_Heap_Allocate_aligned_with_boundary+0x63>
110f21: 89 ce mov %ecx,%esi 110f23: eb 10 jmp 110f35 <_Heap_Allocate_aligned_with_boundary+0xfd> 110f25: 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 ) {
110f28: 39 c1 cmp %eax,%ecx
110f2a: 76 28 jbe 110f54 <_Heap_Allocate_aligned_with_boundary+0x11c>
if ( boundary_line < boundary_floor ) {
110f2c: 39 45 e0 cmp %eax,-0x20(%ebp)
110f2f: 0f 87 9f 00 00 00 ja 110fd4 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
110f35: 89 c3 mov %eax,%ebx 110f37: 29 fb sub %edi,%ebx 110f39: 89 d8 mov %ebx,%eax 110f3b: 31 d2 xor %edx,%edx 110f3d: f7 75 10 divl 0x10(%ebp) 110f40: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
110f42: 8d 0c 3b lea (%ebx,%edi,1),%ecx 110f45: 89 c8 mov %ecx,%eax 110f47: 31 d2 xor %edx,%edx 110f49: f7 75 14 divl 0x14(%ebp) 110f4c: 89 c8 mov %ecx,%eax 110f4e: 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 ) {
110f50: 39 c3 cmp %eax,%ebx
110f52: 72 d4 jb 110f28 <_Heap_Allocate_aligned_with_boundary+0xf0>
110f54: 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 ) {
110f56: 39 5d d4 cmp %ebx,-0x2c(%ebp)
110f59: 0f 87 3c ff ff ff ja 110e9b <_Heap_Allocate_aligned_with_boundary+0x63>
110f5f: be f8 ff ff ff mov $0xfffffff8,%esi 110f64: 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);
110f66: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110f68: 89 d8 mov %ebx,%eax 110f6a: 31 d2 xor %edx,%edx 110f6c: 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;
110f6f: 29 d6 sub %edx,%esi
if ( free_size >= min_block_size || free_size == 0 ) {
110f71: 39 75 d8 cmp %esi,-0x28(%ebp)
110f74: 0f 86 19 ff ff ff jbe 110e93 <_Heap_Allocate_aligned_with_boundary+0x5b>
110f7a: 85 f6 test %esi,%esi
110f7c: 0f 85 19 ff ff ff jne 110e9b <_Heap_Allocate_aligned_with_boundary+0x63>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
110f82: 85 db test %ebx,%ebx
110f84: 0f 84 11 ff ff ff je 110e9b <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN
110f8a: 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;
110f8c: 8b 45 08 mov 0x8(%ebp),%eax 110f8f: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
110f92: 8b 55 e4 mov -0x1c(%ebp),%edx 110f95: 01 50 4c add %edx,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
110f98: 57 push %edi 110f99: 53 push %ebx 110f9a: 51 push %ecx 110f9b: 50 push %eax 110f9c: e8 1f ac ff ff call 10bbc0 <_Heap_Block_allocate> 110fa1: 89 d8 mov %ebx,%eax 110fa3: 83 c4 10 add $0x10,%esp
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
110fa6: 8b 55 e4 mov -0x1c(%ebp),%edx 110fa9: 8b 4d 08 mov 0x8(%ebp),%ecx 110fac: 39 51 44 cmp %edx,0x44(%ecx)
110faf: 73 15 jae 110fc6 <_Heap_Allocate_aligned_with_boundary+0x18e>
stats->max_search = search_count;
110fb1: 89 51 44 mov %edx,0x44(%ecx)
}
return (void *) alloc_begin;
}
110fb4: 8d 65 f4 lea -0xc(%ebp),%esp 110fb7: 5b pop %ebx 110fb8: 5e pop %esi 110fb9: 5f pop %edi 110fba: c9 leave 110fbb: c3 ret
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
110fbc: 3b 7d 14 cmp 0x14(%ebp),%edi
110fbf: 76 1a jbe 110fdb <_Heap_Allocate_aligned_with_boundary+0x1a3>
110fc1: 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 ) {
110fc4: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
110fc6: 8d 65 f4 lea -0xc(%ebp),%esp 110fc9: 5b pop %ebx 110fca: 5e pop %esi 110fcb: 5f pop %edi 110fcc: c9 leave 110fcd: c3 ret 110fce: 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 ) {
110fd0: 31 c0 xor %eax,%eax 110fd2: eb d2 jmp 110fa6 <_Heap_Allocate_aligned_with_boundary+0x16e>
110fd4: 89 f1 mov %esi,%ecx <== NOT EXECUTED 110fd6: e9 c0 fe ff ff jmp 110e9b <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
110fdb: 8b 4d 10 mov 0x10(%ebp),%ecx 110fde: 85 c9 test %ecx,%ecx
110fe0: 0f 85 80 fe ff ff jne 110e66 <_Heap_Allocate_aligned_with_boundary+0x2e>
alignment = page_size;
110fe6: 89 55 10 mov %edx,0x10(%ebp) 110fe9: e9 78 fe ff ff jmp 110e66 <_Heap_Allocate_aligned_with_boundary+0x2e>
0011134c <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
11134c: 55 push %ebp 11134d: 89 e5 mov %esp,%ebp 11134f: 57 push %edi 111350: 56 push %esi 111351: 53 push %ebx 111352: 83 ec 4c sub $0x4c,%esp 111355: 8b 5d 08 mov 0x8(%ebp),%ebx 111358: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
11135b: 8b 43 20 mov 0x20(%ebx),%eax 11135e: 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;
111361: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
111368: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
11136f: 8b 53 10 mov 0x10(%ebx),%edx 111372: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
111375: 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;
111378: 8b 73 30 mov 0x30(%ebx),%esi 11137b: 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 ) {
11137e: 8b 55 0c mov 0xc(%ebp),%edx 111381: 01 ca add %ecx,%edx 111383: 89 55 cc mov %edx,-0x34(%ebp)
111386: 73 0c jae 111394 <_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;
111388: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
11138a: 8d 65 f4 lea -0xc(%ebp),%esp 11138d: 5b pop %ebx 11138e: 5e pop %esi 11138f: 5f pop %edi 111390: c9 leave 111391: c3 ret 111392: 66 90 xchg %ax,%ax
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
111394: 83 ec 08 sub $0x8,%esp 111397: 8d 55 e0 lea -0x20(%ebp),%edx 11139a: 52 push %edx 11139b: 8d 55 e4 lea -0x1c(%ebp),%edx 11139e: 52 push %edx 11139f: 50 push %eax 1113a0: ff 75 d4 pushl -0x2c(%ebp) 1113a3: 51 push %ecx 1113a4: ff 75 0c pushl 0xc(%ebp) 1113a7: e8 20 aa ff ff call 10bdcc <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
1113ac: 83 c4 20 add $0x20,%esp 1113af: 84 c0 test %al,%al
1113b1: 74 d5 je 111388 <_Heap_Extend+0x3c>
1113b3: 8b 7d d0 mov -0x30(%ebp),%edi 1113b6: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 1113bd: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 1113c4: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 1113cb: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 1113d2: 8b 75 cc mov -0x34(%ebp),%esi 1113d5: 89 5d b4 mov %ebx,-0x4c(%ebp) 1113d8: eb 30 jmp 11140a <_Heap_Extend+0xbe> 1113da: 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 ) {
1113dc: 39 ce cmp %ecx,%esi
1113de: 73 03 jae 1113e3 <_Heap_Extend+0x97>
1113e0: 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);
1113e3: 8d 59 f8 lea -0x8(%ecx),%ebx 1113e6: 89 c8 mov %ecx,%eax 1113e8: 31 d2 xor %edx,%edx 1113ea: 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);
1113ed: 29 d3 sub %edx,%ebx
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
1113ef: 3b 4d 0c cmp 0xc(%ebp),%ecx
1113f2: 74 3c je 111430 <_Heap_Extend+0xe4>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
1113f4: 39 4d 0c cmp %ecx,0xc(%ebp)
1113f7: 76 03 jbe 1113fc <_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 )
1113f9: 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;
1113fc: 8b 7b 04 mov 0x4(%ebx),%edi 1113ff: 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);
111402: 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 );
111405: 39 7d d0 cmp %edi,-0x30(%ebp)
111408: 74 39 je 111443 <_Heap_Extend+0xf7>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
11140a: 3b 7d d0 cmp -0x30(%ebp),%edi
11140d: 0f 84 39 01 00 00 je 11154c <_Heap_Extend+0x200>
111413: 89 f8 mov %edi,%eax
uintptr_t const sub_area_end = start_block->prev_size;
111415: 8b 0f mov (%edi),%ecx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
111417: 39 4d 0c cmp %ecx,0xc(%ebp)
11141a: 73 08 jae 111424 <_Heap_Extend+0xd8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
11141c: 39 f0 cmp %esi,%eax
11141e: 0f 82 64 ff ff ff jb 111388 <_Heap_Extend+0x3c>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
111424: 39 f0 cmp %esi,%eax
111426: 75 b4 jne 1113dc <_Heap_Extend+0x90>
111428: 89 7d c4 mov %edi,-0x3c(%ebp) 11142b: eb b6 jmp 1113e3 <_Heap_Extend+0x97> 11142d: 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;
111430: 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 )
111432: 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;
111435: 8b 7b 04 mov 0x4(%ebx),%edi 111438: 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);
11143b: 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 );
11143e: 39 7d d0 cmp %edi,-0x30(%ebp)
111441: 75 c7 jne 11140a <_Heap_Extend+0xbe> <== NEVER TAKEN
111443: 8b 5d b4 mov -0x4c(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
111446: 8b 75 0c mov 0xc(%ebp),%esi 111449: 3b 73 18 cmp 0x18(%ebx),%esi
11144c: 0f 82 06 01 00 00 jb 111558 <_Heap_Extend+0x20c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
111452: 8b 45 cc mov -0x34(%ebp),%eax 111455: 3b 43 1c cmp 0x1c(%ebx),%eax
111458: 76 03 jbe 11145d <_Heap_Extend+0x111>
heap->area_end = extend_area_end;
11145a: 89 43 1c mov %eax,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
11145d: 8b 55 e0 mov -0x20(%ebp),%edx 111460: 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 =
111463: 89 d1 mov %edx,%ecx 111465: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
111467: 8b 75 cc mov -0x34(%ebp),%esi 11146a: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
11146c: 89 ce mov %ecx,%esi 11146e: 83 ce 01 or $0x1,%esi 111471: 89 70 04 mov %esi,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
111474: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
111476: 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 ) {
11147d: 39 43 20 cmp %eax,0x20(%ebx)
111480: 0f 86 da 00 00 00 jbe 111560 <_Heap_Extend+0x214>
heap->first_block = extend_first_block;
111486: 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 ) {
111489: 8b 75 c4 mov -0x3c(%ebp),%esi 11148c: 85 f6 test %esi,%esi
11148e: 0f 84 10 01 00 00 je 1115a4 <_Heap_Extend+0x258>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
111494: 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 );
111497: 8b 4d 0c mov 0xc(%ebp),%ecx 11149a: 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;
11149d: 89 c8 mov %ecx,%eax 11149f: 31 d2 xor %edx,%edx 1114a1: f7 f6 div %esi
if ( remainder != 0 ) {
1114a3: 85 d2 test %edx,%edx
1114a5: 0f 84 c9 00 00 00 je 111574 <_Heap_Extend+0x228>
return value - remainder + alignment;
1114ab: 8d 04 31 lea (%ecx,%esi,1),%eax 1114ae: 29 d0 sub %edx,%eax
uintptr_t const new_first_block_begin =
1114b0: 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;
1114b3: 8b 75 c4 mov -0x3c(%ebp),%esi 1114b6: 8b 0e mov (%esi),%ecx 1114b8: 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 =
1114bb: 89 f0 mov %esi,%eax 1114bd: 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;
1114bf: 83 c8 01 or $0x1,%eax 1114c2: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
1114c5: 89 d8 mov %ebx,%eax 1114c7: e8 64 fe ff ff call 111330 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
1114cc: 8b 45 c8 mov -0x38(%ebp),%eax 1114cf: 85 c0 test %eax,%eax
1114d1: 0f 84 a5 00 00 00 je 11157c <_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,
1114d7: 8b 4d cc mov -0x34(%ebp),%ecx 1114da: 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(
1114dd: 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);
1114e0: 89 c8 mov %ecx,%eax 1114e2: 31 d2 xor %edx,%edx 1114e4: f7 73 10 divl 0x10(%ebx) 1114e7: 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)
1114e9: 8b 55 c8 mov -0x38(%ebp),%edx 1114ec: 8b 42 04 mov 0x4(%edx),%eax 1114ef: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
1114f1: 83 c8 01 or $0x1,%eax 1114f4: 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;
1114f8: 8b 42 04 mov 0x4(%edx),%eax 1114fb: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
1114fe: 09 c8 or %ecx,%eax 111500: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
111503: 89 d8 mov %ebx,%eax 111505: e8 26 fe ff ff call 111330 <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
11150a: 8b 75 c4 mov -0x3c(%ebp),%esi 11150d: 85 f6 test %esi,%esi
11150f: 0f 84 ab 00 00 00 je 1115c0 <_Heap_Extend+0x274>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
111515: 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(
111518: 8b 43 20 mov 0x20(%ebx),%eax 11151b: 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;
11151d: 8b 4a 04 mov 0x4(%edx),%ecx 111520: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
111523: 09 c8 or %ecx,%eax 111525: 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;
111528: 8b 43 30 mov 0x30(%ebx),%eax 11152b: 2b 45 c0 sub -0x40(%ebp),%eax
/* Statistics */
stats->size += extended_size;
11152e: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
111531: 8b 55 14 mov 0x14(%ebp),%edx 111534: 85 d2 test %edx,%edx
111536: 0f 84 a0 00 00 00 je 1115dc <_Heap_Extend+0x290> <== NEVER TAKEN
*extended_size_ptr = extended_size;
11153c: 8b 55 14 mov 0x14(%ebp),%edx 11153f: 89 02 mov %eax,(%edx)
return true;
111541: b0 01 mov $0x1,%al
}
111543: 8d 65 f4 lea -0xc(%ebp),%esp 111546: 5b pop %ebx 111547: 5e pop %esi 111548: 5f pop %edi 111549: c9 leave 11154a: c3 ret 11154b: 90 nop
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
11154c: 8b 55 b4 mov -0x4c(%ebp),%edx 11154f: 8b 42 18 mov 0x18(%edx),%eax 111552: e9 be fe ff ff jmp 111415 <_Heap_Extend+0xc9> 111557: 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;
111558: 89 73 18 mov %esi,0x18(%ebx) 11155b: e9 fd fe ff ff jmp 11145d <_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 ) {
111560: 39 53 24 cmp %edx,0x24(%ebx)
111563: 0f 83 20 ff ff ff jae 111489 <_Heap_Extend+0x13d>
heap->last_block = extend_last_block;
111569: 89 53 24 mov %edx,0x24(%ebx) 11156c: e9 18 ff ff ff jmp 111489 <_Heap_Extend+0x13d> 111571: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
} else {
return value;
111574: 89 c8 mov %ecx,%eax 111576: e9 35 ff ff ff jmp 1114b0 <_Heap_Extend+0x164> 11157b: 90 nop
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
11157c: 8b 7d bc mov -0x44(%ebp),%edi 11157f: 85 ff test %edi,%edi
111581: 74 87 je 11150a <_Heap_Extend+0x1be>
_Heap_Link_above(
111583: 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 );
111586: 8b 45 e4 mov -0x1c(%ebp),%eax 111589: 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;
11158c: 8b 75 bc mov -0x44(%ebp),%esi 11158f: 8b 56 04 mov 0x4(%esi),%edx 111592: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
111595: 09 d0 or %edx,%eax 111597: 89 46 04 mov %eax,0x4(%esi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
11159a: 83 49 04 01 orl $0x1,0x4(%ecx) 11159e: e9 67 ff ff ff jmp 11150a <_Heap_Extend+0x1be> 1115a3: 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 ) {
1115a4: 8b 4d b8 mov -0x48(%ebp),%ecx 1115a7: 85 c9 test %ecx,%ecx
1115a9: 0f 84 1d ff ff ff je 1114cc <_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;
1115af: 8b 45 b8 mov -0x48(%ebp),%eax 1115b2: 29 d0 sub %edx,%eax 1115b4: 83 c8 01 or $0x1,%eax 1115b7: 89 42 04 mov %eax,0x4(%edx) 1115ba: e9 0d ff ff ff jmp 1114cc <_Heap_Extend+0x180> 1115bf: 90 nop
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
1115c0: 8b 4d c8 mov -0x38(%ebp),%ecx 1115c3: 85 c9 test %ecx,%ecx
1115c5: 0f 85 4a ff ff ff jne 111515 <_Heap_Extend+0x1c9>
_Heap_Free_block( heap, extend_first_block );
1115cb: 8b 55 e4 mov -0x1c(%ebp),%edx 1115ce: 89 d8 mov %ebx,%eax 1115d0: e8 5b fd ff ff call 111330 <_Heap_Free_block> 1115d5: e9 3b ff ff ff jmp 111515 <_Heap_Extend+0x1c9> 1115da: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
1115dc: b0 01 mov $0x1,%al <== NOT EXECUTED 1115de: e9 a7 fd ff ff jmp 11138a <_Heap_Extend+0x3e> <== NOT EXECUTED
00110ff0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
110ff0: 55 push %ebp 110ff1: 89 e5 mov %esp,%ebp 110ff3: 57 push %edi 110ff4: 56 push %esi 110ff5: 53 push %ebx 110ff6: 83 ec 10 sub $0x10,%esp 110ff9: 8b 4d 08 mov 0x8(%ebp),%ecx 110ffc: 8b 45 0c mov 0xc(%ebp),%eax
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
110fff: 85 c0 test %eax,%eax
111001: 0f 84 e9 00 00 00 je 1110f0 <_Heap_Free+0x100>
111007: 8d 58 f8 lea -0x8(%eax),%ebx 11100a: 31 d2 xor %edx,%edx 11100c: f7 71 10 divl 0x10(%ecx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
11100f: 29 d3 sub %edx,%ebx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
111011: 8b 41 20 mov 0x20(%ecx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
111014: 39 c3 cmp %eax,%ebx
111016: 72 1c jb 111034 <_Heap_Free+0x44>
111018: 8b 71 24 mov 0x24(%ecx),%esi 11101b: 39 f3 cmp %esi,%ebx
11101d: 77 15 ja 111034 <_Heap_Free+0x44>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
11101f: 8b 53 04 mov 0x4(%ebx),%edx 111022: 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;
111025: 83 e2 fe and $0xfffffffe,%edx 111028: 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);
11102b: 8d 14 13 lea (%ebx,%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;
11102e: 39 d0 cmp %edx,%eax
111030: 76 0e jbe 111040 <_Heap_Free+0x50> <== ALWAYS TAKEN
111032: 66 90 xchg %ax,%ax
/* 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 );
111034: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111036: 83 c4 10 add $0x10,%esp 111039: 5b pop %ebx 11103a: 5e pop %esi 11103b: 5f pop %edi 11103c: c9 leave 11103d: c3 ret 11103e: 66 90 xchg %ax,%ax 111040: 39 d6 cmp %edx,%esi
111042: 72 f0 jb 111034 <_Heap_Free+0x44> <== NEVER TAKEN
111044: 8b 7a 04 mov 0x4(%edx),%edi
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
111047: f7 c7 01 00 00 00 test $0x1,%edi
11104d: 74 e5 je 111034 <_Heap_Free+0x44> <== 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;
11104f: 83 e7 fe and $0xfffffffe,%edi 111052: 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 ));
111055: 39 d6 cmp %edx,%esi
111057: 0f 84 d3 00 00 00 je 111130 <_Heap_Free+0x140>
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
11105d: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 111062: 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 ) ) {
111066: f6 45 f0 01 testb $0x1,-0x10(%ebp)
11106a: 75 44 jne 1110b0 <_Heap_Free+0xc0>
uintptr_t const prev_size = block->prev_size;
11106c: 8b 3b mov (%ebx),%edi 11106e: 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);
111071: 29 fb sub %edi,%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
111073: 39 d8 cmp %ebx,%eax
111075: 77 bd ja 111034 <_Heap_Free+0x44> <== NEVER TAKEN
111077: 39 de cmp %ebx,%esi
111079: 72 b9 jb 111034 <_Heap_Free+0x44> <== 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) ) {
11107b: f6 43 04 01 testb $0x1,0x4(%ebx)
11107f: 74 b3 je 111034 <_Heap_Free+0x44> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
111081: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111085: 0f 84 b1 00 00 00 je 11113c <_Heap_Free+0x14c>
uintptr_t const size = block_size + prev_size + next_block_size;
11108b: 8b 7d e4 mov -0x1c(%ebp),%edi 11108e: 03 7d ec add -0x14(%ebp),%edi 111091: 03 7d f0 add -0x10(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111094: 8b 42 08 mov 0x8(%edx),%eax 111097: 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;
11109a: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
11109d: 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;
1110a0: ff 49 38 decl 0x38(%ecx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1110a3: 89 f8 mov %edi,%eax 1110a5: 83 c8 01 or $0x1,%eax 1110a8: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
1110ab: 89 3c 3b mov %edi,(%ebx,%edi,1) 1110ae: eb 29 jmp 1110d9 <_Heap_Free+0xe9>
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 */
1110b0: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
1110b4: 74 46 je 1110fc <_Heap_Free+0x10c>
uintptr_t const size = block_size + next_block_size;
1110b6: 8b 7d e4 mov -0x1c(%ebp),%edi 1110b9: 03 7d ec add -0x14(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1110bc: 8b 42 08 mov 0x8(%edx),%eax 1110bf: 8b 52 0c mov 0xc(%edx),%edx
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
1110c2: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = prev;
1110c5: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
1110c8: 89 58 0c mov %ebx,0xc(%eax)
prev->next = new_block;
1110cb: 89 5a 08 mov %ebx,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;
1110ce: 89 f8 mov %edi,%eax 1110d0: 83 c8 01 or $0x1,%eax 1110d3: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
1110d6: 89 3c 3b mov %edi,(%ebx,%edi,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
1110d9: ff 49 40 decl 0x40(%ecx)
++stats->frees;
1110dc: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
1110df: 8b 55 ec mov -0x14(%ebp),%edx 1110e2: 01 51 30 add %edx,0x30(%ecx)
return( true );
1110e5: b0 01 mov $0x1,%al
}
1110e7: 83 c4 10 add $0x10,%esp 1110ea: 5b pop %ebx 1110eb: 5e pop %esi 1110ec: 5f pop %edi 1110ed: c9 leave 1110ee: c3 ret 1110ef: 90 nop
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
1110f0: b0 01 mov $0x1,%al
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1110f2: 83 c4 10 add $0x10,%esp 1110f5: 5b pop %ebx 1110f6: 5e pop %esi 1110f7: 5f pop %edi 1110f8: c9 leave 1110f9: c3 ret 1110fa: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
1110fc: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
1110ff: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
111102: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
111105: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
111108: 89 58 0c mov %ebx,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;
11110b: 8b 45 ec mov -0x14(%ebp),%eax 11110e: 83 c8 01 or $0x1,%eax 111111: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
111114: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
111118: 8b 45 ec mov -0x14(%ebp),%eax 11111b: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->free_blocks;
11111d: 8b 41 38 mov 0x38(%ecx),%eax 111120: 40 inc %eax 111121: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
111124: 3b 41 3c cmp 0x3c(%ecx),%eax
111127: 76 b0 jbe 1110d9 <_Heap_Free+0xe9>
stats->max_free_blocks = stats->free_blocks;
111129: 89 41 3c mov %eax,0x3c(%ecx) 11112c: eb ab jmp 1110d9 <_Heap_Free+0xe9> 11112e: 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 ));
111130: c6 45 eb 00 movb $0x0,-0x15(%ebp) 111134: e9 2d ff ff ff jmp 111066 <_Heap_Free+0x76> 111139: 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;
11113c: 8b 45 ec mov -0x14(%ebp),%eax 11113f: 03 45 f0 add -0x10(%ebp),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
111142: 89 c6 mov %eax,%esi 111144: 83 ce 01 or $0x1,%esi 111147: 89 73 04 mov %esi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
11114a: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
11114e: 89 02 mov %eax,(%edx) 111150: eb 87 jmp 1110d9 <_Heap_Free+0xe9>
0010ba50 <_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
)
{
10ba50: 55 push %ebp 10ba51: 89 e5 mov %esp,%ebp 10ba53: 57 push %edi 10ba54: 56 push %esi 10ba55: 53 push %ebx 10ba56: 8b 4d 08 mov 0x8(%ebp),%ecx 10ba59: 8b 7d 0c mov 0xc(%ebp),%edi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
10ba5c: 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 );
10ba5f: 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;
10ba62: 89 d8 mov %ebx,%eax 10ba64: 31 d2 xor %edx,%edx 10ba66: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
10ba69: 85 d2 test %edx,%edx
10ba6b: 74 05 je 10ba72 <_Heap_Get_first_and_last_block+0x22>
return value - remainder + alignment;
10ba6d: 03 5d 10 add 0x10(%ebp),%ebx 10ba70: 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 (
10ba72: 39 f1 cmp %esi,%ecx
10ba74: 77 2e ja 10baa4 <_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);
10ba76: 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 =
10ba79: 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
10ba7b: 39 df cmp %ebx,%edi
10ba7d: 76 25 jbe 10baa4 <_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 );
10ba7f: 29 df sub %ebx,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10ba81: 89 f8 mov %edi,%eax 10ba83: 31 d2 xor %edx,%edx 10ba85: f7 75 10 divl 0x10(%ebp) 10ba88: 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
10ba8a: 39 7d 14 cmp %edi,0x14(%ebp)
10ba8d: 77 15 ja 10baa4 <_Heap_Get_first_and_last_block+0x54>
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
10ba8f: 8b 45 18 mov 0x18(%ebp),%eax 10ba92: 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);
10ba94: 01 f7 add %esi,%edi 10ba96: 8b 45 1c mov 0x1c(%ebp),%eax 10ba99: 89 38 mov %edi,(%eax)
*last_block_ptr = last_block;
return true;
10ba9b: b0 01 mov $0x1,%al
}
10ba9d: 5b pop %ebx 10ba9e: 5e pop %esi 10ba9f: 5f pop %edi 10baa0: c9 leave 10baa1: c3 ret 10baa2: 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;
10baa4: 31 c0 xor %eax,%eax
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
10baa6: 5b pop %ebx 10baa7: 5e pop %esi 10baa8: 5f pop %edi 10baa9: c9 leave 10baaa: c3 ret
00114d74 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
114d74: 55 push %ebp 114d75: 89 e5 mov %esp,%ebp 114d77: 57 push %edi 114d78: 56 push %esi 114d79: 53 push %ebx 114d7a: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
114d7d: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
114d83: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
114d8a: 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;
}
}
114d91: 8b 45 08 mov 0x8(%ebp),%eax 114d94: 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);
114d97: 39 d0 cmp %edx,%eax
114d99: 74 31 je 114dcc <_Heap_Get_free_information+0x58>
114d9b: b9 01 00 00 00 mov $0x1,%ecx 114da0: 31 f6 xor %esi,%esi 114da2: 31 db xor %ebx,%ebx 114da4: eb 07 jmp 114dad <_Heap_Get_free_information+0x39> 114da6: 66 90 xchg %ax,%ax 114da8: 8b 77 04 mov 0x4(%edi),%esi 114dab: 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;
114dad: 8b 42 04 mov 0x4(%edx),%eax 114db0: 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;
114db3: 01 c3 add %eax,%ebx
if ( info->largest < the_size )
114db5: 39 f0 cmp %esi,%eax
114db7: 76 03 jbe 114dbc <_Heap_Get_free_information+0x48>
info->largest = the_size;
114db9: 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)
114dbc: 8b 52 08 mov 0x8(%edx),%edx 114dbf: 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);
114dc2: 39 55 08 cmp %edx,0x8(%ebp)
114dc5: 75 e1 jne 114da8 <_Heap_Get_free_information+0x34>
114dc7: 89 0f mov %ecx,(%edi) 114dc9: 89 5f 08 mov %ebx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
114dcc: 5b pop %ebx 114dcd: 5e pop %esi 114dce: 5f pop %edi 114dcf: c9 leave 114dd0: c3 ret
00111b0c <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
111b0c: 55 push %ebp 111b0d: 89 e5 mov %esp,%ebp 111b0f: 57 push %edi 111b10: 56 push %esi 111b11: 53 push %ebx 111b12: 83 ec 04 sub $0x4,%esp 111b15: 8b 45 08 mov 0x8(%ebp),%eax 111b18: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->first_block;
111b1b: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->last_block;
111b1e: 8b 40 24 mov 0x24(%eax),%eax 111b21: 89 45 f0 mov %eax,-0x10(%ebp)
memset(the_info, 0, sizeof(*the_info));
111b24: b9 18 00 00 00 mov $0x18,%ecx 111b29: 31 c0 xor %eax,%eax 111b2b: 89 df mov %ebx,%edi 111b2d: f3 aa rep stos %al,%es:(%edi)
while ( the_block != end ) {
111b2f: 3b 55 f0 cmp -0x10(%ebp),%edx
111b32: 74 38 je 111b6c <_Heap_Get_information+0x60><== NEVER TAKEN
111b34: 8b 7a 04 mov 0x4(%edx),%edi 111b37: eb 18 jmp 111b51 <_Heap_Get_information+0x45> 111b39: 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;
111b3c: 8d 43 0c lea 0xc(%ebx),%eax
else
info = &the_info->Free;
info->number++;
111b3f: ff 00 incl (%eax)
info->total += the_size;
111b41: 01 48 08 add %ecx,0x8(%eax)
if ( info->largest < the_size )
111b44: 39 48 04 cmp %ecx,0x4(%eax)
111b47: 73 03 jae 111b4c <_Heap_Get_information+0x40>
info->largest = the_size;
111b49: 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 ) {
111b4c: 39 75 f0 cmp %esi,-0x10(%ebp)
111b4f: 74 1b je 111b6c <_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;
111b51: 89 f9 mov %edi,%ecx 111b53: 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);
111b56: 8d 34 0a lea (%edx,%ecx,1),%esi 111b59: 89 f2 mov %esi,%edx
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
111b5b: 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) )
111b5e: f7 c7 01 00 00 00 test $0x1,%edi
111b64: 75 d6 jne 111b3c <_Heap_Get_information+0x30>
info = &the_info->Used;
else
info = &the_info->Free;
111b66: 89 d8 mov %ebx,%eax 111b68: eb d5 jmp 111b3f <_Heap_Get_information+0x33> 111b6a: 66 90 xchg %ax,%ax
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
111b6c: 58 pop %eax 111b6d: 5b pop %ebx 111b6e: 5e pop %esi 111b6f: 5f pop %edi 111b70: c9 leave 111b71: c3 ret
0011f118 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11f118: 55 push %ebp 11f119: 89 e5 mov %esp,%ebp 11f11b: 57 push %edi 11f11c: 56 push %esi 11f11d: 53 push %ebx 11f11e: 83 ec 2c sub $0x2c,%esp 11f121: 8b 5d 08 mov 0x8(%ebp),%ebx 11f124: 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);
11f127: 8d 4e f8 lea -0x8(%esi),%ecx 11f12a: 89 f0 mov %esi,%eax 11f12c: 31 d2 xor %edx,%edx 11f12e: 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);
11f131: 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;
11f133: 8b 45 14 mov 0x14(%ebp),%eax 11f136: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11f13c: 8b 55 18 mov 0x18(%ebp),%edx 11f13f: 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;
11f145: 39 4b 20 cmp %ecx,0x20(%ebx)
11f148: 77 05 ja 11f14f <_Heap_Resize_block+0x37>
11f14a: 39 4b 24 cmp %ecx,0x24(%ebx)
11f14d: 73 0d jae 11f15c <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
11f14f: b8 02 00 00 00 mov $0x2,%eax
}
11f154: 8d 65 f4 lea -0xc(%ebp),%esp 11f157: 5b pop %ebx 11f158: 5e pop %esi 11f159: 5f pop %edi 11f15a: c9 leave 11f15b: 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;
11f15c: 8b 41 04 mov 0x4(%ecx),%eax 11f15f: 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;
11f162: 8d 3c 01 lea (%ecx,%eax,1),%edi 11f165: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11f168: 89 fa mov %edi,%edx 11f16a: 29 f2 sub %esi,%edx 11f16c: 83 c2 04 add $0x4,%edx 11f16f: 89 55 e0 mov %edx,-0x20(%ebp) 11f172: 8b 57 04 mov 0x4(%edi),%edx 11f175: 83 e2 fe and $0xfffffffe,%edx 11f178: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11f17b: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11f180: 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;
11f184: 8b 55 e0 mov -0x20(%ebp),%edx 11f187: 8b 7d 14 mov 0x14(%ebp),%edi 11f18a: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11f18c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f190: 75 6e jne 11f200 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11f192: 8b 55 e0 mov -0x20(%ebp),%edx 11f195: 39 55 10 cmp %edx,0x10(%ebp)
11f198: 77 79 ja 11f213 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11f19a: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f19e: 74 31 je 11f1d1 <_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;
11f1a0: 8b 79 04 mov 0x4(%ecx),%edi 11f1a3: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11f1a6: 09 c7 or %eax,%edi 11f1a8: 89 79 04 mov %edi,0x4(%ecx)
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
11f1ab: 8b 7d d4 mov -0x2c(%ebp),%edi 11f1ae: 8b 7f 08 mov 0x8(%edi),%edi 11f1b1: 89 7d e4 mov %edi,-0x1c(%ebp) 11f1b4: 8b 55 d4 mov -0x2c(%ebp),%edx 11f1b7: 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;
11f1ba: 8b 55 e4 mov -0x1c(%ebp),%edx 11f1bd: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11f1c0: 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;
11f1c3: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11f1c8: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11f1cb: 8b 7d d0 mov -0x30(%ebp),%edi 11f1ce: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11f1d1: ff 75 10 pushl 0x10(%ebp) 11f1d4: 56 push %esi 11f1d5: 51 push %ecx 11f1d6: 53 push %ebx 11f1d7: e8 e4 c9 fe ff call 10bbc0 <_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;
11f1dc: 8b 50 04 mov 0x4(%eax),%edx 11f1df: 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;
11f1e2: 29 f0 sub %esi,%eax 11f1e4: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11f1e8: 8b 55 18 mov 0x18(%ebp),%edx 11f1eb: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11f1ed: ff 43 54 incl 0x54(%ebx) 11f1f0: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11f1f3: 31 c0 xor %eax,%eax
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
11f1f5: 8d 65 f4 lea -0xc(%ebp),%esp 11f1f8: 5b pop %ebx 11f1f9: 5e pop %esi 11f1fa: 5f pop %edi 11f1fb: c9 leave 11f1fc: c3 ret 11f1fd: 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;
11f200: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11f203: 8b 7d d0 mov -0x30(%ebp),%edi 11f206: 01 fa add %edi,%edx 11f208: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11f20b: 8b 55 e0 mov -0x20(%ebp),%edx 11f20e: 39 55 10 cmp %edx,0x10(%ebp)
11f211: 76 87 jbe 11f19a <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11f213: b8 01 00 00 00 mov $0x1,%eax
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
11f218: 8d 65 f4 lea -0xc(%ebp),%esp 11f21b: 5b pop %ebx 11f21c: 5e pop %esi 11f21d: 5f pop %edi 11f21e: c9 leave 11f21f: c3 ret
0011f220 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11f220: 55 push %ebp 11f221: 89 e5 mov %esp,%ebp 11f223: 56 push %esi 11f224: 53 push %ebx 11f225: 8b 5d 08 mov 0x8(%ebp),%ebx 11f228: 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);
11f22b: 8d 4e f8 lea -0x8(%esi),%ecx 11f22e: 89 f0 mov %esi,%eax 11f230: 31 d2 xor %edx,%edx 11f232: 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);
11f235: 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
11f237: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11f23a: 39 c1 cmp %eax,%ecx
11f23c: 72 07 jb 11f245 <_Heap_Size_of_alloc_area+0x25>
11f23e: 8b 53 24 mov 0x24(%ebx),%edx 11f241: 39 d1 cmp %edx,%ecx
11f243: 76 07 jbe 11f24c <_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;
11f245: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11f247: 5b pop %ebx 11f248: 5e pop %esi 11f249: c9 leave 11f24a: c3 ret 11f24b: 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;
11f24c: 8b 59 04 mov 0x4(%ecx),%ebx 11f24f: 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);
11f252: 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;
11f254: 39 c8 cmp %ecx,%eax
11f256: 77 ed ja 11f245 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11f258: 39 ca cmp %ecx,%edx
11f25a: 72 e9 jb 11f245 <_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 )
11f25c: f6 41 04 01 testb $0x1,0x4(%ecx)
11f260: 74 e3 je 11f245 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11f262: 29 f1 sub %esi,%ecx 11f264: 8d 51 04 lea 0x4(%ecx),%edx 11f267: 8b 45 10 mov 0x10(%ebp),%eax 11f26a: 89 10 mov %edx,(%eax)
return true;
11f26c: b0 01 mov $0x1,%al
}
11f26e: 5b pop %ebx 11f26f: 5e pop %esi 11f270: c9 leave 11f271: c3 ret
0010c728 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10c728: 55 push %ebp 10c729: 89 e5 mov %esp,%ebp 10c72b: 57 push %edi 10c72c: 56 push %esi 10c72d: 53 push %ebx 10c72e: 83 ec 4c sub $0x4c,%esp 10c731: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10c734: 8b 43 10 mov 0x10(%ebx),%eax 10c737: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10c73a: 8b 53 14 mov 0x14(%ebx),%edx 10c73d: 89 55 d0 mov %edx,-0x30(%ebp)
Heap_Block *const first_block = heap->first_block;
10c740: 8b 43 20 mov 0x20(%ebx),%eax 10c743: 89 45 dc mov %eax,-0x24(%ebp)
Heap_Block *const last_block = heap->last_block;
10c746: 8b 53 24 mov 0x24(%ebx),%edx 10c749: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10c74c: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10c750: 74 1a je 10c76c <_Heap_Walk+0x44>
10c752: c7 45 d8 e0 c6 10 00 movl $0x10c6e0,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10c759: 83 3d 40 9e 12 00 03 cmpl $0x3,0x129e40
10c760: 74 1a je 10c77c <_Heap_Walk+0x54> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10c762: b0 01 mov $0x1,%al
}
10c764: 8d 65 f4 lea -0xc(%ebp),%esp 10c767: 5b pop %ebx 10c768: 5e pop %esi 10c769: 5f pop %edi 10c76a: c9 leave 10c76b: 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;
10c76c: c7 45 d8 d8 c6 10 00 movl $0x10c6d8,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10c773: 83 3d 40 9e 12 00 03 cmpl $0x3,0x129e40
10c77a: 75 e6 jne 10c762 <_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)(
10c77c: 52 push %edx 10c77d: ff 73 0c pushl 0xc(%ebx) 10c780: ff 73 08 pushl 0x8(%ebx) 10c783: ff 75 cc pushl -0x34(%ebp) 10c786: ff 75 dc pushl -0x24(%ebp) 10c789: ff 73 1c pushl 0x1c(%ebx) 10c78c: ff 73 18 pushl 0x18(%ebx) 10c78f: ff 75 d0 pushl -0x30(%ebp) 10c792: ff 75 e0 pushl -0x20(%ebp) 10c795: 68 44 20 12 00 push $0x122044 10c79a: 6a 00 push $0x0 10c79c: ff 75 0c pushl 0xc(%ebp) 10c79f: 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 ) {
10c7a2: 83 c4 30 add $0x30,%esp 10c7a5: 8b 45 e0 mov -0x20(%ebp),%eax 10c7a8: 85 c0 test %eax,%eax
10c7aa: 74 70 je 10c81c <_Heap_Walk+0xf4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10c7ac: f6 45 e0 03 testb $0x3,-0x20(%ebp)
10c7b0: 75 72 jne 10c824 <_Heap_Walk+0xfc>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c7b2: 8b 45 d0 mov -0x30(%ebp),%eax 10c7b5: 31 d2 xor %edx,%edx 10c7b7: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10c7ba: 85 d2 test %edx,%edx
10c7bc: 75 72 jne 10c830 <_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;
10c7be: 8b 45 dc mov -0x24(%ebp),%eax 10c7c1: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c7c4: 31 d2 xor %edx,%edx 10c7c6: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10c7c9: 85 d2 test %edx,%edx
10c7cb: 75 6f jne 10c83c <_Heap_Walk+0x114>
block = next_block;
} while ( block != first_block );
return true;
}
10c7cd: 8b 45 dc mov -0x24(%ebp),%eax 10c7d0: 8b 40 04 mov 0x4(%eax),%eax 10c7d3: 89 45 e4 mov %eax,-0x1c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10c7d6: a8 01 test $0x1,%al
10c7d8: 0f 84 ce 02 00 00 je 10caac <_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;
10c7de: 8b 55 cc mov -0x34(%ebp),%edx 10c7e1: 8b 42 04 mov 0x4(%edx),%eax 10c7e4: 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);
10c7e7: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10c7e9: f6 40 04 01 testb $0x1,0x4(%eax)
10c7ed: 74 25 je 10c814 <_Heap_Walk+0xec>
);
return false;
}
if (
10c7ef: 39 45 dc cmp %eax,-0x24(%ebp)
10c7f2: 74 54 je 10c848 <_Heap_Walk+0x120>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10c7f4: 51 push %ecx 10c7f5: 68 60 21 12 00 push $0x122160 10c7fa: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10c7fc: 6a 01 push $0x1 10c7fe: ff 75 0c pushl 0xc(%ebp) 10c801: ff 55 d8 call *-0x28(%ebp) 10c804: 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;
10c807: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10c809: 8d 65 f4 lea -0xc(%ebp),%esp 10c80c: 5b pop %ebx 10c80d: 5e pop %esi 10c80e: 5f pop %edi 10c80f: c9 leave 10c810: c3 ret 10c811: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10c814: 53 push %ebx 10c815: 68 fa 1f 12 00 push $0x121ffa 10c81a: eb e0 jmp 10c7fc <_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" );
10c81c: 57 push %edi 10c81d: 68 c9 1f 12 00 push $0x121fc9 10c822: eb d8 jmp 10c7fc <_Heap_Walk+0xd4>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10c824: ff 75 e0 pushl -0x20(%ebp) 10c827: 68 dc 1f 12 00 push $0x121fdc 10c82c: eb ce jmp 10c7fc <_Heap_Walk+0xd4> 10c82e: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10c830: ff 75 d0 pushl -0x30(%ebp) 10c833: 68 d8 20 12 00 push $0x1220d8 10c838: eb c2 jmp 10c7fc <_Heap_Walk+0xd4> 10c83a: 66 90 xchg %ax,%ax
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10c83c: ff 75 dc pushl -0x24(%ebp) 10c83f: 68 fc 20 12 00 push $0x1220fc 10c844: eb b6 jmp 10c7fc <_Heap_Walk+0xd4> 10c846: 66 90 xchg %ax,%ax
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10c848: 8b 43 10 mov 0x10(%ebx),%eax 10c84b: 89 45 c8 mov %eax,-0x38(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10c84e: 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 ) {
10c851: 39 f3 cmp %esi,%ebx
10c853: 74 65 je 10c8ba <_Heap_Walk+0x192>
block = next_block;
} while ( block != first_block );
return true;
}
10c855: 8b 43 20 mov 0x20(%ebx),%eax 10c858: 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;
10c85b: 39 f0 cmp %esi,%eax
10c85d: 0f 87 55 02 00 00 ja 10cab8 <_Heap_Walk+0x390> <== NEVER TAKEN
10c863: 8b 7b 24 mov 0x24(%ebx),%edi 10c866: 39 f7 cmp %esi,%edi
10c868: 0f 82 4a 02 00 00 jb 10cab8 <_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;
10c86e: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c871: 31 d2 xor %edx,%edx 10c873: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10c876: 85 d2 test %edx,%edx
10c878: 0f 85 71 02 00 00 jne 10caef <_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;
10c87e: 8b 46 04 mov 0x4(%esi),%eax 10c881: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10c884: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10c889: 0f 85 6d 02 00 00 jne 10cafc <_Heap_Walk+0x3d4> <== NEVER TAKEN
10c88f: 89 da mov %ebx,%edx 10c891: 8d 76 00 lea 0x0(%esi),%esi
);
return false;
}
if ( free_block->prev != prev_block ) {
10c894: 8b 46 0c mov 0xc(%esi),%eax 10c897: 39 d0 cmp %edx,%eax
10c899: 0f 85 6a 02 00 00 jne 10cb09 <_Heap_Walk+0x3e1>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10c89f: 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 ) {
10c8a2: 39 cb cmp %ecx,%ebx
10c8a4: 74 1a je 10c8c0 <_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;
10c8a6: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10c8a9: 0f 86 7d 01 00 00 jbe 10ca2c <_Heap_Walk+0x304>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10c8af: 51 push %ecx 10c8b0: 68 90 21 12 00 push $0x122190 10c8b5: e9 42 ff ff ff jmp 10c7fc <_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 ) {
10c8ba: 8b 53 20 mov 0x20(%ebx),%edx 10c8bd: 89 55 d4 mov %edx,-0x2c(%ebp)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10c8c0: 8b 7d dc mov -0x24(%ebp),%edi 10c8c3: 8b 45 d4 mov -0x2c(%ebp),%eax 10c8c6: 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;
10c8c8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c8cb: 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);
10c8ce: 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;
10c8d1: 39 f0 cmp %esi,%eax
10c8d3: 76 23 jbe 10c8f8 <_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)(
10c8d5: 83 ec 0c sub $0xc,%esp 10c8d8: 56 push %esi 10c8d9: 57 push %edi 10c8da: 68 14 22 12 00 push $0x122214 10c8df: 90 nop 10c8e0: 6a 01 push $0x1 10c8e2: ff 75 0c pushl 0xc(%ebp) 10c8e5: ff 55 d8 call *-0x28(%ebp)
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
10c8e8: 83 c4 20 add $0x20,%esp 10c8eb: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10c8ed: 8d 65 f4 lea -0xc(%ebp),%esp 10c8f0: 5b pop %ebx 10c8f1: 5e pop %esi 10c8f2: 5f pop %edi 10c8f3: c9 leave 10c8f4: c3 ret 10c8f5: 8d 76 00 lea 0x0(%esi),%esi 10c8f8: 39 73 24 cmp %esi,0x24(%ebx)
10c8fb: 72 d8 jb 10c8d5 <_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;
10c8fd: 3b 7d cc cmp -0x34(%ebp),%edi 10c900: 0f 95 45 d4 setne -0x2c(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c904: 89 c8 mov %ecx,%eax 10c906: 31 d2 xor %edx,%edx 10c908: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10c90b: 85 d2 test %edx,%edx
10c90d: 74 0a je 10c919 <_Heap_Walk+0x1f1>
10c90f: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10c913: 0f 85 a6 01 00 00 jne 10cabf <_Heap_Walk+0x397>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10c919: 39 4d d0 cmp %ecx,-0x30(%ebp)
10c91c: 76 0a jbe 10c928 <_Heap_Walk+0x200>
10c91e: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10c922: 0f 85 a6 01 00 00 jne 10cace <_Heap_Walk+0x3a6> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10c928: 39 f7 cmp %esi,%edi
10c92a: 72 0a jb 10c936 <_Heap_Walk+0x20e>
10c92c: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10c930: 0f 85 aa 01 00 00 jne 10cae0 <_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;
10c936: 8b 55 e4 mov -0x1c(%ebp),%edx 10c939: 83 e2 01 and $0x1,%edx
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10c93c: f6 46 04 01 testb $0x1,0x4(%esi)
10c940: 74 4e je 10c990 <_Heap_Walk+0x268>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10c942: 85 d2 test %edx,%edx
10c944: 74 2e je 10c974 <_Heap_Walk+0x24c>
(*printer)(
10c946: 83 ec 0c sub $0xc,%esp 10c949: 51 push %ecx 10c94a: 57 push %edi 10c94b: 68 2b 20 12 00 push $0x12202b 10c950: 6a 00 push $0x0 10c952: ff 75 0c pushl 0xc(%ebp) 10c955: ff 55 d8 call *-0x28(%ebp) 10c958: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10c95b: 39 75 dc cmp %esi,-0x24(%ebp)
10c95e: 0f 84 fe fd ff ff je 10c762 <_Heap_Walk+0x3a>
10c964: 8b 56 04 mov 0x4(%esi),%edx 10c967: 89 55 e4 mov %edx,-0x1c(%ebp) 10c96a: 8b 43 20 mov 0x20(%ebx),%eax 10c96d: 89 f7 mov %esi,%edi 10c96f: e9 54 ff ff ff jmp 10c8c8 <_Heap_Walk+0x1a0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10c974: 83 ec 08 sub $0x8,%esp 10c977: ff 37 pushl (%edi) 10c979: 51 push %ecx 10c97a: 57 push %edi 10c97b: 68 78 23 12 00 push $0x122378 10c980: 6a 00 push $0x0 10c982: ff 75 0c pushl 0xc(%ebp) 10c985: ff 55 d8 call *-0x28(%ebp) 10c988: 83 c4 20 add $0x20,%esp 10c98b: eb ce jmp 10c95b <_Heap_Walk+0x233> 10c98d: 8d 76 00 lea 0x0(%esi),%esi
block = next_block;
} while ( block != first_block );
return true;
}
10c990: 8b 43 08 mov 0x8(%ebx),%eax 10c993: 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 ?
10c996: 8b 47 08 mov 0x8(%edi),%eax 10c999: 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)(
10c99c: 39 43 0c cmp %eax,0xc(%ebx)
10c99f: 0f 84 cb 00 00 00 je 10ca70 <_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)" : "")
10c9a5: 39 c3 cmp %eax,%ebx
10c9a7: 0f 84 db 00 00 00 je 10ca88 <_Heap_Walk+0x360>
10c9ad: c7 45 c8 c9 1e 12 00 movl $0x121ec9,-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 ?
10c9b4: 8b 47 0c mov 0xc(%edi),%eax 10c9b7: 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)(
10c9ba: 39 45 b4 cmp %eax,-0x4c(%ebp)
10c9bd: 0f 84 b9 00 00 00 je 10ca7c <_Heap_Walk+0x354>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10c9c3: 39 c3 cmp %eax,%ebx
10c9c5: 0f 84 c9 00 00 00 je 10ca94 <_Heap_Walk+0x36c>
10c9cb: b8 c9 1e 12 00 mov $0x121ec9,%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)(
10c9d0: 83 ec 0c sub $0xc,%esp 10c9d3: ff 75 c8 pushl -0x38(%ebp) 10c9d6: ff 75 e4 pushl -0x1c(%ebp) 10c9d9: 50 push %eax 10c9da: ff 75 d4 pushl -0x2c(%ebp) 10c9dd: 51 push %ecx 10c9de: 57 push %edi 10c9df: 68 d4 22 12 00 push $0x1222d4 10c9e4: 6a 00 push $0x0 10c9e6: ff 75 0c pushl 0xc(%ebp) 10c9e9: 89 55 c4 mov %edx,-0x3c(%ebp) 10c9ec: 89 4d c0 mov %ecx,-0x40(%ebp) 10c9ef: 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 ) {
10c9f2: 8b 06 mov (%esi),%eax 10c9f4: 83 c4 30 add $0x30,%esp 10c9f7: 8b 4d c0 mov -0x40(%ebp),%ecx 10c9fa: 39 c1 cmp %eax,%ecx 10c9fc: 8b 55 c4 mov -0x3c(%ebp),%edx
10c9ff: 75 5f jne 10ca60 <_Heap_Walk+0x338>
);
return false;
}
if ( !prev_used ) {
10ca01: 85 d2 test %edx,%edx
10ca03: 0f 84 97 00 00 00 je 10caa0 <_Heap_Walk+0x378>
block = next_block;
} while ( block != first_block );
return true;
}
10ca09: 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 ) {
10ca0c: 39 c3 cmp %eax,%ebx
10ca0e: 74 0f je 10ca1f <_Heap_Walk+0x2f7> <== NEVER TAKEN
if ( free_block == block ) {
10ca10: 39 c7 cmp %eax,%edi
10ca12: 0f 84 43 ff ff ff je 10c95b <_Heap_Walk+0x233>
return true;
}
free_block = free_block->next;
10ca18: 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 ) {
10ca1b: 39 c3 cmp %eax,%ebx
10ca1d: 75 f1 jne 10ca10 <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10ca1f: 57 push %edi 10ca20: 68 a0 23 12 00 push $0x1223a0 10ca25: e9 d2 fd ff ff jmp 10c7fc <_Heap_Walk+0xd4> 10ca2a: 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;
10ca2c: 39 f9 cmp %edi,%ecx
10ca2e: 0f 87 7b fe ff ff ja 10c8af <_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;
10ca34: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10ca37: 31 d2 xor %edx,%edx 10ca39: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10ca3c: 85 d2 test %edx,%edx
10ca3e: 0f 85 ad 00 00 00 jne 10caf1 <_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;
10ca44: 8b 41 04 mov 0x4(%ecx),%eax 10ca47: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10ca4a: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10ca4f: 0f 85 a9 00 00 00 jne 10cafe <_Heap_Walk+0x3d6>
10ca55: 89 f2 mov %esi,%edx 10ca57: 89 ce mov %ecx,%esi 10ca59: e9 36 fe ff ff jmp 10c894 <_Heap_Walk+0x16c> 10ca5e: 66 90 xchg %ax,%ax
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10ca60: 52 push %edx 10ca61: 56 push %esi 10ca62: 50 push %eax 10ca63: 51 push %ecx 10ca64: 57 push %edi 10ca65: 68 0c 23 12 00 push $0x12230c 10ca6a: e9 71 fe ff ff jmp 10c8e0 <_Heap_Walk+0x1b8> 10ca6f: 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)(
10ca70: c7 45 c8 96 1f 12 00 movl $0x121f96,-0x38(%ebp) 10ca77: e9 38 ff ff ff jmp 10c9b4 <_Heap_Walk+0x28c> 10ca7c: b8 af 1f 12 00 mov $0x121faf,%eax 10ca81: e9 4a ff ff ff jmp 10c9d0 <_Heap_Walk+0x2a8> 10ca86: 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)" : "")
10ca88: c7 45 c8 a5 1f 12 00 movl $0x121fa5,-0x38(%ebp) 10ca8f: e9 20 ff ff ff jmp 10c9b4 <_Heap_Walk+0x28c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10ca94: b8 bf 1f 12 00 mov $0x121fbf,%eax 10ca99: e9 32 ff ff ff jmp 10c9d0 <_Heap_Walk+0x2a8> 10ca9e: 66 90 xchg %ax,%ax
return false;
}
if ( !prev_used ) {
(*printer)(
10caa0: 57 push %edi 10caa1: 68 48 23 12 00 push $0x122348 10caa6: e9 51 fd ff ff jmp 10c7fc <_Heap_Walk+0xd4> 10caab: 90 nop
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10caac: 56 push %esi 10caad: 68 30 21 12 00 push $0x122130 10cab2: e9 45 fd ff ff jmp 10c7fc <_Heap_Walk+0xd4> 10cab7: 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;
10cab8: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10caba: e9 f0 fd ff ff jmp 10c8af <_Heap_Walk+0x187> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10cabf: 83 ec 0c sub $0xc,%esp 10cac2: 51 push %ecx 10cac3: 57 push %edi 10cac4: 68 44 22 12 00 push $0x122244 10cac9: e9 12 fe ff ff jmp 10c8e0 <_Heap_Walk+0x1b8>
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
10cace: 83 ec 08 sub $0x8,%esp 10cad1: ff 75 d0 pushl -0x30(%ebp) 10cad4: 51 push %ecx 10cad5: 57 push %edi 10cad6: 68 74 22 12 00 push $0x122274 10cadb: e9 00 fe ff ff jmp 10c8e0 <_Heap_Walk+0x1b8>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
10cae0: 83 ec 0c sub $0xc,%esp 10cae3: 56 push %esi 10cae4: 57 push %edi 10cae5: 68 a0 22 12 00 push $0x1222a0 10caea: e9 f1 fd ff ff jmp 10c8e0 <_Heap_Walk+0x1b8>
);
return false;
}
if (
10caef: 89 f1 mov %esi,%ecx <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10caf1: 51 push %ecx 10caf2: 68 b0 21 12 00 push $0x1221b0 10caf7: e9 00 fd ff ff jmp 10c7fc <_Heap_Walk+0xd4>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10cafc: 89 f1 mov %esi,%ecx <== NOT EXECUTED
(*printer)(
10cafe: 51 push %ecx 10caff: 68 0f 20 12 00 push $0x12200f 10cb04: e9 f3 fc ff ff jmp 10c7fc <_Heap_Walk+0xd4>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
10cb09: 83 ec 0c sub $0xc,%esp 10cb0c: 50 push %eax 10cb0d: 56 push %esi 10cb0e: 68 e0 21 12 00 push $0x1221e0 10cb13: e9 c8 fd ff ff jmp 10c8e0 <_Heap_Walk+0x1b8>
0010b298 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10b298: 55 push %ebp 10b299: 89 e5 mov %esp,%ebp 10b29b: 53 push %ebx 10b29c: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10b29f: 8b 0d 20 82 12 00 mov 0x128220,%ecx 10b2a5: 85 c9 test %ecx,%ecx
10b2a7: 74 1a je 10b2c3 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10b2a9: 31 db xor %ebx,%ebx 10b2ab: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10b2ac: 52 push %edx 10b2ad: 6a 00 push $0x0 10b2af: 6a 00 push $0x0 10b2b1: 53 push %ebx 10b2b2: e8 f1 55 00 00 call 1108a8 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10b2b7: 43 inc %ebx 10b2b8: 83 c4 10 add $0x10,%esp 10b2bb: 39 1d 20 82 12 00 cmp %ebx,0x128220
10b2c1: 77 e9 ja 10b2ac <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10b2c3: 8b 5d fc mov -0x4(%ebp),%ebx 10b2c6: c9 leave 10b2c7: c3 ret
0010b200 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
10b200: 55 push %ebp 10b201: 89 e5 mov %esp,%ebp 10b203: 57 push %edi 10b204: 56 push %esi 10b205: 53 push %ebx 10b206: 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;
10b209: 8b 1d 94 35 12 00 mov 0x123594,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10b20f: a1 90 35 12 00 mov 0x123590,%eax 10b214: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10b217: 8b 35 8c 35 12 00 mov 0x12358c,%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 )
10b21d: 39 f0 cmp %esi,%eax
10b21f: 73 5f jae 10b280 <_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(
10b221: 8d 0c 76 lea (%esi,%esi,2),%ecx 10b224: c1 e1 03 shl $0x3,%ecx 10b227: 83 ec 0c sub $0xc,%esp 10b22a: 51 push %ecx 10b22b: 89 4d dc mov %ecx,-0x24(%ebp) 10b22e: e8 5d 2b 00 00 call 10dd90 <_Workspace_Allocate_or_fatal_error> 10b233: 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 *)
10b235: a3 24 82 12 00 mov %eax,0x128224
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10b23a: 89 35 20 82 12 00 mov %esi,0x128220
memset(
10b240: 31 c0 xor %eax,%eax 10b242: 8b 4d dc mov -0x24(%ebp),%ecx 10b245: 89 d7 mov %edx,%edi 10b247: 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++ )
10b249: 83 c4 10 add $0x10,%esp 10b24c: 8b 45 e4 mov -0x1c(%ebp),%eax 10b24f: 85 c0 test %eax,%eax
10b251: 74 25 je 10b278 <_IO_Manager_initialization+0x78><== NEVER TAKEN
10b253: a1 24 82 12 00 mov 0x128224,%eax 10b258: 89 45 e0 mov %eax,-0x20(%ebp) 10b25b: 31 c0 xor %eax,%eax 10b25d: 31 d2 xor %edx,%edx 10b25f: 90 nop
_IO_Driver_address_table[index] = driver_table[index];
10b260: 8b 7d e0 mov -0x20(%ebp),%edi 10b263: 01 c7 add %eax,%edi 10b265: 8d 34 03 lea (%ebx,%eax,1),%esi 10b268: b9 06 00 00 00 mov $0x6,%ecx 10b26d: 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++ )
10b26f: 42 inc %edx 10b270: 83 c0 18 add $0x18,%eax 10b273: 39 55 e4 cmp %edx,-0x1c(%ebp)
10b276: 77 e8 ja 10b260 <_IO_Manager_initialization+0x60>
_IO_Driver_address_table[index] = driver_table[index];
}
10b278: 8d 65 f4 lea -0xc(%ebp),%esp 10b27b: 5b pop %ebx 10b27c: 5e pop %esi 10b27d: 5f pop %edi 10b27e: c9 leave 10b27f: 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;
10b280: 89 1d 24 82 12 00 mov %ebx,0x128224
_IO_Number_of_drivers = number_of_drivers;
10b286: 8b 45 e4 mov -0x1c(%ebp),%eax 10b289: a3 20 82 12 00 mov %eax,0x128220
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10b28e: 8d 65 f4 lea -0xc(%ebp),%esp 10b291: 5b pop %ebx 10b292: 5e pop %esi 10b293: 5f pop %edi 10b294: c9 leave 10b295: c3 ret
0010bcb4 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10bcb4: 55 push %ebp 10bcb5: 89 e5 mov %esp,%ebp 10bcb7: 53 push %ebx 10bcb8: 83 ec 08 sub $0x8,%esp 10bcbb: 8b 45 08 mov 0x8(%ebp),%eax 10bcbe: 8b 55 0c mov 0xc(%ebp),%edx 10bcc1: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10bcc4: a3 94 78 12 00 mov %eax,0x127894
_Internal_errors_What_happened.is_internal = is_internal;
10bcc9: 88 15 98 78 12 00 mov %dl,0x127898
_Internal_errors_What_happened.the_error = the_error;
10bccf: 89 1d 9c 78 12 00 mov %ebx,0x12789c
_User_extensions_Fatal( the_source, is_internal, the_error );
10bcd5: 53 push %ebx 10bcd6: 0f b6 d2 movzbl %dl,%edx 10bcd9: 52 push %edx 10bcda: 50 push %eax 10bcdb: e8 b0 1c 00 00 call 10d990 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10bce0: c7 05 80 79 12 00 05 movl $0x5,0x127980 <== NOT EXECUTED
10bce7: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10bcea: fa cli <== NOT EXECUTED 10bceb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bced: f4 hlt <== NOT EXECUTED 10bcee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bcf1: eb fe jmp 10bcf1 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
00111154 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
111154: 55 push %ebp 111155: 89 e5 mov %esp,%ebp 111157: 8b 45 08 mov 0x8(%ebp),%eax 11115a: 48 dec %eax 11115b: 83 f8 02 cmp $0x2,%eax
11115e: 77 0c ja 11116c <_Objects_API_maximum_class+0x18>
111160: 8b 04 85 80 16 12 00 mov 0x121680(,%eax,4),%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
111167: c9 leave 111168: c3 ret 111169: 8d 76 00 lea 0x0(%esi),%esi
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
11116c: 31 c0 xor %eax,%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
11116e: c9 leave 11116f: c3 ret
0010bd44 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10bd44: 55 push %ebp 10bd45: 89 e5 mov %esp,%ebp 10bd47: 56 push %esi 10bd48: 53 push %ebx 10bd49: 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 )
10bd4c: 8b 43 18 mov 0x18(%ebx),%eax 10bd4f: 85 c0 test %eax,%eax
10bd51: 75 0d jne 10bd60 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
return NULL;
10bd53: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
);
}
#endif
return the_object;
}
10bd55: 89 c8 mov %ecx,%eax 10bd57: 8d 65 f8 lea -0x8(%ebp),%esp 10bd5a: 5b pop %ebx 10bd5b: 5e pop %esi 10bd5c: c9 leave 10bd5d: c3 ret 10bd5e: 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 );
10bd60: 8d 73 20 lea 0x20(%ebx),%esi 10bd63: 83 ec 0c sub $0xc,%esp 10bd66: 56 push %esi 10bd67: e8 a0 f7 ff ff call 10b50c <_Chain_Get> 10bd6c: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10bd6e: 83 c4 10 add $0x10,%esp 10bd71: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10bd75: 74 de je 10bd55 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10bd77: 85 c0 test %eax,%eax
10bd79: 74 29 je 10bda4 <_Objects_Allocate+0x60>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10bd7b: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10bd7f: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10bd83: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10bd85: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10bd89: 31 d2 xor %edx,%edx 10bd8b: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10bd8d: c1 e0 02 shl $0x2,%eax 10bd90: 03 43 30 add 0x30(%ebx),%eax 10bd93: ff 08 decl (%eax)
information->inactive--;
10bd95: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10bd99: 89 c8 mov %ecx,%eax 10bd9b: 8d 65 f8 lea -0x8(%ebp),%esp 10bd9e: 5b pop %ebx 10bd9f: 5e pop %esi 10bda0: c9 leave 10bda1: c3 ret 10bda2: 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 );
10bda4: 83 ec 0c sub $0xc,%esp 10bda7: 53 push %ebx 10bda8: e8 3b 00 00 00 call 10bde8 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10bdad: 89 34 24 mov %esi,(%esp) 10bdb0: e8 57 f7 ff ff call 10b50c <_Chain_Get> 10bdb5: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10bdb7: 83 c4 10 add $0x10,%esp 10bdba: 85 c0 test %eax,%eax
10bdbc: 74 97 je 10bd55 <_Objects_Allocate+0x11>
10bdbe: eb bb jmp 10bd7b <_Objects_Allocate+0x37>
0010bde8 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10bde8: 55 push %ebp 10bde9: 89 e5 mov %esp,%ebp 10bdeb: 57 push %edi 10bdec: 56 push %esi 10bded: 53 push %ebx 10bdee: 83 ec 4c sub $0x4c,%esp 10bdf1: 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 );
10bdf4: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10bdf8: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10bdfb: 8b 4b 34 mov 0x34(%ebx),%ecx 10bdfe: 85 c9 test %ecx,%ecx
10be00: 0f 84 62 02 00 00 je 10c068 <_Objects_Extend_information+0x280>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10be06: 8b 73 10 mov 0x10(%ebx),%esi 10be09: 66 89 75 d0 mov %si,-0x30(%ebp) 10be0d: 8b 7b 14 mov 0x14(%ebx),%edi 10be10: 89 f0 mov %esi,%eax 10be12: 31 d2 xor %edx,%edx 10be14: 66 f7 f7 div %di 10be17: 0f b7 f0 movzwl %ax,%esi
for ( ; block < block_count; block++ ) {
10be1a: 85 f6 test %esi,%esi
10be1c: 0f 84 5f 02 00 00 je 10c081 <_Objects_Extend_information+0x299><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10be22: 8b 01 mov (%ecx),%eax 10be24: 85 c0 test %eax,%eax
10be26: 0f 84 67 02 00 00 je 10c093 <_Objects_Extend_information+0x2ab><== NEVER TAKEN
10be2c: 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 );
10be2f: 8b 55 cc mov -0x34(%ebp),%edx 10be32: 89 55 d4 mov %edx,-0x2c(%ebp)
index_base = minimum_index; block = 0;
10be35: 31 d2 xor %edx,%edx 10be37: 8b 45 d4 mov -0x2c(%ebp),%eax 10be3a: eb 0a jmp 10be46 <_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 ) {
10be3c: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4)
10be40: 0f 84 c2 01 00 00 je 10c008 <_Objects_Extend_information+0x220>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10be46: 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++ ) {
10be48: 42 inc %edx 10be49: 39 d6 cmp %edx,%esi
10be4b: 77 ef ja 10be3c <_Objects_Extend_information+0x54>
10be4d: 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;
10be50: b1 01 mov $0x1,%cl
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10be52: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10be56: 01 f8 add %edi,%eax 10be58: 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 ) {
10be5b: 3d ff ff 00 00 cmp $0xffff,%eax
10be60: 0f 87 9a 01 00 00 ja 10c000 <_Objects_Extend_information+0x218>
/*
* 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;
10be66: 0f af 7b 18 imul 0x18(%ebx),%edi
if ( information->auto_extend ) {
10be6a: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10be6e: 0f 84 a0 01 00 00 je 10c014 <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
10be74: 83 ec 0c sub $0xc,%esp 10be77: 57 push %edi 10be78: 89 55 b8 mov %edx,-0x48(%ebp) 10be7b: 88 4d b4 mov %cl,-0x4c(%ebp) 10be7e: e8 d9 1e 00 00 call 10dd5c <_Workspace_Allocate> 10be83: 89 45 c8 mov %eax,-0x38(%ebp)
if ( !new_object_block )
10be86: 83 c4 10 add $0x10,%esp 10be89: 85 c0 test %eax,%eax 10be8b: 8b 55 b8 mov -0x48(%ebp),%edx 10be8e: 8a 4d b4 mov -0x4c(%ebp),%cl
10be91: 0f 84 69 01 00 00 je 10c000 <_Objects_Extend_information+0x218>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10be97: 84 c9 test %cl,%cl
10be99: 0f 84 e6 00 00 00 je 10bf85 <_Objects_Extend_information+0x19d>
*/
/*
* Up the block count and maximum
*/
block_count++;
10be9f: 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 );
10bea2: 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 *)) +
10bea5: 8d 04 7f lea (%edi,%edi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10bea8: 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 *)) +
10beab: 03 45 cc add -0x34(%ebp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10beae: 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 );
10beb1: 50 push %eax 10beb2: 89 55 b8 mov %edx,-0x48(%ebp) 10beb5: e8 a2 1e 00 00 call 10dd5c <_Workspace_Allocate> 10beba: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !object_blocks ) {
10bebd: 83 c4 10 add $0x10,%esp 10bec0: 85 c0 test %eax,%eax 10bec2: 8b 55 b8 mov -0x48(%ebp),%edx
10bec5: 0f 84 da 01 00 00 je 10c0a5 <_Objects_Extend_information+0x2bd>
10becb: 8b 45 c4 mov -0x3c(%ebp),%eax 10bece: 8d 04 b8 lea (%eax,%edi,4),%eax 10bed1: 89 45 bc mov %eax,-0x44(%ebp) 10bed4: 8b 4d c4 mov -0x3c(%ebp),%ecx 10bed7: 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 ) {
10beda: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10bede: 39 4d cc cmp %ecx,-0x34(%ebp)
10bee1: 0f 82 4d 01 00 00 jb 10c034 <_Objects_Extend_information+0x24c>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10bee7: 8b 4d cc mov -0x34(%ebp),%ecx 10beea: 85 c9 test %ecx,%ecx
10beec: 74 12 je 10bf00 <_Objects_Extend_information+0x118><== NEVER TAKEN
10beee: 31 c9 xor %ecx,%ecx 10bef0: 8b 7d cc mov -0x34(%ebp),%edi 10bef3: 90 nop
local_table[ index ] = NULL;
10bef4: 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++ ) {
10befb: 41 inc %ecx 10befc: 39 cf cmp %ecx,%edi
10befe: 77 f4 ja 10bef4 <_Objects_Extend_information+0x10c><== NEVER TAKEN
10bf00: c1 e6 02 shl $0x2,%esi 10bf03: 89 75 c0 mov %esi,-0x40(%ebp)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10bf06: 8b 4d c4 mov -0x3c(%ebp),%ecx 10bf09: 8b 75 c0 mov -0x40(%ebp),%esi 10bf0c: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
inactive_per_block[block_count] = 0;
10bf13: 8b 4d bc mov -0x44(%ebp),%ecx 10bf16: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10bf1d: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10bf21: 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 ;
10bf24: 39 75 d4 cmp %esi,-0x2c(%ebp)
10bf27: 73 0f jae 10bf38 <_Objects_Extend_information+0x150><== NEVER TAKEN
10bf29: 8b 4d d4 mov -0x2c(%ebp),%ecx
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10bf2c: 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++ ) {
10bf33: 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 ;
10bf34: 39 f1 cmp %esi,%ecx
10bf36: 72 f4 jb 10bf2c <_Objects_Extend_information+0x144>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10bf38: 9c pushf 10bf39: fa cli 10bf3a: 5f pop %edi
old_tables = information->object_blocks;
10bf3b: 8b 73 34 mov 0x34(%ebx),%esi
information->object_blocks = object_blocks;
10bf3e: 8b 4d c4 mov -0x3c(%ebp),%ecx 10bf41: 89 4b 34 mov %ecx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10bf44: 8b 4d bc mov -0x44(%ebp),%ecx 10bf47: 89 4b 30 mov %ecx,0x30(%ebx)
information->local_table = local_table;
10bf4a: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10bf4d: 8b 45 d0 mov -0x30(%ebp),%eax 10bf50: 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) |
10bf54: 8b 0b mov (%ebx),%ecx 10bf56: c1 e1 18 shl $0x18,%ecx 10bf59: 81 c9 00 00 01 00 or $0x10000,%ecx
information->maximum_id = _Objects_Build_id(
10bf5f: 0f b7 43 04 movzwl 0x4(%ebx),%eax
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10bf63: c1 e0 1b shl $0x1b,%eax 10bf66: 09 c1 or %eax,%ecx 10bf68: 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) |
10bf6c: 09 c1 or %eax,%ecx 10bf6e: 89 4b 0c mov %ecx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10bf71: 57 push %edi 10bf72: 9d popf
_Workspace_Free( old_tables );
10bf73: 83 ec 0c sub $0xc,%esp 10bf76: 56 push %esi 10bf77: 89 55 b8 mov %edx,-0x48(%ebp) 10bf7a: e8 f9 1d 00 00 call 10dd78 <_Workspace_Free> 10bf7f: 83 c4 10 add $0x10,%esp 10bf82: 8b 55 b8 mov -0x48(%ebp),%edx
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10bf85: c1 e2 02 shl $0x2,%edx 10bf88: 89 55 d0 mov %edx,-0x30(%ebp) 10bf8b: 8b 43 34 mov 0x34(%ebx),%eax 10bf8e: 8b 4d c8 mov -0x38(%ebp),%ecx 10bf91: 89 0c 10 mov %ecx,(%eax,%edx,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10bf94: ff 73 18 pushl 0x18(%ebx) 10bf97: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10bf9b: 50 push %eax 10bf9c: 51 push %ecx 10bf9d: 8d 7d dc lea -0x24(%ebp),%edi 10bfa0: 57 push %edi 10bfa1: e8 42 49 00 00 call 1108e8 <_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 ) {
10bfa6: 83 c4 10 add $0x10,%esp 10bfa9: 8b 75 d4 mov -0x2c(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10bfac: 8d 43 20 lea 0x20(%ebx),%eax 10bfaf: 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 ) {
10bfb2: eb 29 jmp 10bfdd <_Objects_Extend_information+0x1f5> 10bfb4: 8b 13 mov (%ebx),%edx 10bfb6: c1 e2 18 shl $0x18,%edx 10bfb9: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10bfbf: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10bfc3: c1 e1 1b shl $0x1b,%ecx 10bfc6: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10bfc8: 09 f2 or %esi,%edx 10bfca: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10bfcd: 83 ec 08 sub $0x8,%esp 10bfd0: 50 push %eax 10bfd1: ff 75 d4 pushl -0x2c(%ebp) 10bfd4: e8 f7 f4 ff ff call 10b4d0 <_Chain_Append>
index++;
10bfd9: 46 inc %esi 10bfda: 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 ) {
10bfdd: 83 ec 0c sub $0xc,%esp 10bfe0: 57 push %edi 10bfe1: e8 26 f5 ff ff call 10b50c <_Chain_Get> 10bfe6: 83 c4 10 add $0x10,%esp 10bfe9: 85 c0 test %eax,%eax
10bfeb: 75 c7 jne 10bfb4 <_Objects_Extend_information+0x1cc>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10bfed: 8b 43 14 mov 0x14(%ebx),%eax 10bff0: 8b 53 30 mov 0x30(%ebx),%edx 10bff3: 0f b7 c8 movzwl %ax,%ecx 10bff6: 8b 75 d0 mov -0x30(%ebp),%esi 10bff9: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10bffc: 66 01 43 2c add %ax,0x2c(%ebx)
}
10c000: 8d 65 f4 lea -0xc(%ebp),%esp 10c003: 5b pop %ebx 10c004: 5e pop %esi 10c005: 5f pop %edi 10c006: c9 leave 10c007: c3 ret 10c008: 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;
10c00b: 31 c9 xor %ecx,%ecx 10c00d: e9 40 fe ff ff jmp 10be52 <_Objects_Extend_information+0x6a> 10c012: 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 );
10c014: 83 ec 0c sub $0xc,%esp 10c017: 57 push %edi 10c018: 89 55 b8 mov %edx,-0x48(%ebp) 10c01b: 88 4d b4 mov %cl,-0x4c(%ebp) 10c01e: e8 6d 1d 00 00 call 10dd90 <_Workspace_Allocate_or_fatal_error> 10c023: 89 45 c8 mov %eax,-0x38(%ebp) 10c026: 83 c4 10 add $0x10,%esp 10c029: 8a 4d b4 mov -0x4c(%ebp),%cl 10c02c: 8b 55 b8 mov -0x48(%ebp),%edx 10c02f: e9 63 fe ff ff jmp 10be97 <_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,
10c034: c1 e6 02 shl $0x2,%esi 10c037: 89 75 c0 mov %esi,-0x40(%ebp) 10c03a: 8b 73 34 mov 0x34(%ebx),%esi 10c03d: 8b 7d c4 mov -0x3c(%ebp),%edi 10c040: 8b 4d c0 mov -0x40(%ebp),%ecx 10c043: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10c045: 8b 73 30 mov 0x30(%ebx),%esi 10c048: 8b 7d bc mov -0x44(%ebp),%edi 10c04b: 8b 4d c0 mov -0x40(%ebp),%ecx 10c04e: 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 *) );
10c050: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10c054: 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,
10c057: c1 e1 02 shl $0x2,%ecx 10c05a: 8b 73 1c mov 0x1c(%ebx),%esi 10c05d: 89 c7 mov %eax,%edi 10c05f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10c061: e9 a0 fe ff ff jmp 10bf06 <_Objects_Extend_information+0x11e> 10c066: 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 )
10c068: 8b 53 10 mov 0x10(%ebx),%edx 10c06b: 66 89 55 d0 mov %dx,-0x30(%ebp) 10c06f: 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 );
10c073: 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;
10c076: b1 01 mov $0x1,%cl
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10c078: 31 d2 xor %edx,%edx
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10c07a: 31 f6 xor %esi,%esi 10c07c: e9 d1 fd ff ff jmp 10be52 <_Objects_Extend_information+0x6a>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10c081: 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 );
10c084: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10c087: 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;
10c08a: b1 01 mov $0x1,%cl <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10c08c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c08e: e9 bf fd ff ff jmp 10be52 <_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 ) {
10c093: 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 );
10c096: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10c099: 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;
10c09c: 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;
10c09e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c0a0: e9 ad fd ff ff jmp 10be52 <_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 );
10c0a5: 83 ec 0c sub $0xc,%esp 10c0a8: ff 75 c8 pushl -0x38(%ebp) 10c0ab: e8 c8 1c 00 00 call 10dd78 <_Workspace_Free>
return;
10c0b0: 83 c4 10 add $0x10,%esp 10c0b3: e9 48 ff ff ff jmp 10c000 <_Objects_Extend_information+0x218>
0010c148 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10c148: 55 push %ebp 10c149: 89 e5 mov %esp,%ebp 10c14b: 56 push %esi 10c14c: 53 push %ebx 10c14d: 8b 75 08 mov 0x8(%ebp),%esi 10c150: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10c153: 66 85 db test %bx,%bx
10c156: 75 0c jne 10c164 <_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;
10c158: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10c15a: 8d 65 f8 lea -0x8(%ebp),%esp 10c15d: 5b pop %ebx 10c15e: 5e pop %esi 10c15f: c9 leave 10c160: c3 ret 10c161: 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 );
10c164: 83 ec 0c sub $0xc,%esp 10c167: 56 push %esi 10c168: e8 e7 4f 00 00 call 111154 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10c16d: 83 c4 10 add $0x10,%esp 10c170: 85 c0 test %eax,%eax
10c172: 74 e4 je 10c158 <_Objects_Get_information+0x10>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10c174: 0f b7 db movzwl %bx,%ebx 10c177: 39 d8 cmp %ebx,%eax
10c179: 72 dd jb 10c158 <_Objects_Get_information+0x10>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10c17b: 8b 14 b5 c4 77 12 00 mov 0x1277c4(,%esi,4),%edx
return NULL;
10c182: 31 c0 xor %eax,%eax
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10c184: 85 d2 test %edx,%edx
10c186: 74 d2 je 10c15a <_Objects_Get_information+0x12><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10c188: 8b 04 9a mov (%edx,%ebx,4),%eax
if ( !info )
10c18b: 85 c0 test %eax,%eax
10c18d: 74 cb je 10c15a <_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;
10c18f: 31 d2 xor %edx,%edx 10c191: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10c196: 0f 95 c2 setne %dl 10c199: f7 da neg %edx 10c19b: 21 d0 and %edx,%eax 10c19d: eb bb jmp 10c15a <_Objects_Get_information+0x12>
0010c1a0 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10c1a0: 55 push %ebp 10c1a1: 89 e5 mov %esp,%ebp 10c1a3: 56 push %esi 10c1a4: 53 push %ebx 10c1a5: 8b 55 08 mov 0x8(%ebp),%edx 10c1a8: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
10c1ab: b8 01 00 00 00 mov $0x1,%eax 10c1b0: 2b 42 08 sub 0x8(%edx),%eax 10c1b3: 03 45 0c add 0xc(%ebp),%eax
_ISR_Disable( level );
10c1b6: 9c pushf 10c1b7: fa cli 10c1b8: 5e pop %esi
if ( information->maximum >= index ) {
10c1b9: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10c1bd: 39 c8 cmp %ecx,%eax
10c1bf: 77 1b ja 10c1dc <_Objects_Get_isr_disable+0x3c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10c1c1: 8b 52 1c mov 0x1c(%edx),%edx 10c1c4: 8b 04 82 mov (%edx,%eax,4),%eax 10c1c7: 85 c0 test %eax,%eax
10c1c9: 74 21 je 10c1ec <_Objects_Get_isr_disable+0x4c>
*location = OBJECTS_LOCAL;
10c1cb: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10c1d1: 8b 55 14 mov 0x14(%ebp),%edx 10c1d4: 89 32 mov %esi,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
10c1d6: 5b pop %ebx 10c1d7: 5e pop %esi 10c1d8: c9 leave 10c1d9: c3 ret 10c1da: 66 90 xchg %ax,%ax
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10c1dc: 56 push %esi 10c1dd: 9d popf
*location = OBJECTS_ERROR;
10c1de: 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;
10c1e4: 31 c0 xor %eax,%eax
#endif }
10c1e6: 5b pop %ebx 10c1e7: 5e pop %esi 10c1e8: c9 leave 10c1e9: c3 ret 10c1ea: 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 );
10c1ec: 56 push %esi 10c1ed: 9d popf
*location = OBJECTS_ERROR;
10c1ee: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
10c1f4: eb e0 jmp 10c1d6 <_Objects_Get_isr_disable+0x36>
0010d8b4 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10d8b4: 55 push %ebp 10d8b5: 89 e5 mov %esp,%ebp 10d8b7: 57 push %edi 10d8b8: 56 push %esi 10d8b9: 53 push %ebx 10d8ba: 83 ec 2c sub $0x2c,%esp 10d8bd: 8b 55 08 mov 0x8(%ebp),%edx 10d8c0: 8b 75 0c mov 0xc(%ebp),%esi 10d8c3: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10d8c6: 85 f6 test %esi,%esi
10d8c8: 75 0e jne 10d8d8 <_Objects_Get_name_as_string+0x24>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
10d8ca: 31 db xor %ebx,%ebx
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
10d8cc: 89 d8 mov %ebx,%eax 10d8ce: 8d 65 f4 lea -0xc(%ebp),%esp 10d8d1: 5b pop %ebx 10d8d2: 5e pop %esi 10d8d3: 5f pop %edi 10d8d4: c9 leave 10d8d5: c3 ret 10d8d6: 66 90 xchg %ax,%ax
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10d8d8: 85 db test %ebx,%ebx
10d8da: 74 f0 je 10d8cc <_Objects_Get_name_as_string+0x18>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10d8dc: 85 d2 test %edx,%edx
10d8de: 75 08 jne 10d8e8 <_Objects_Get_name_as_string+0x34>
10d8e0: a1 58 b9 12 00 mov 0x12b958,%eax 10d8e5: 8b 50 08 mov 0x8(%eax),%edx
information = _Objects_Get_information_id( tmpId );
10d8e8: 83 ec 0c sub $0xc,%esp 10d8eb: 52 push %edx 10d8ec: 89 55 cc mov %edx,-0x34(%ebp) 10d8ef: e8 f0 fe ff ff call 10d7e4 <_Objects_Get_information_id> 10d8f4: 89 c7 mov %eax,%edi
if ( !information )
10d8f6: 83 c4 10 add $0x10,%esp 10d8f9: 85 c0 test %eax,%eax 10d8fb: 8b 55 cc mov -0x34(%ebp),%edx
10d8fe: 74 ca je 10d8ca <_Objects_Get_name_as_string+0x16>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10d900: 51 push %ecx 10d901: 8d 45 e4 lea -0x1c(%ebp),%eax 10d904: 50 push %eax 10d905: 52 push %edx 10d906: 57 push %edi 10d907: e8 90 00 00 00 call 10d99c <_Objects_Get>
switch ( location ) {
10d90c: 83 c4 10 add $0x10,%esp 10d90f: 8b 55 e4 mov -0x1c(%ebp),%edx 10d912: 85 d2 test %edx,%edx
10d914: 75 b4 jne 10d8ca <_Objects_Get_name_as_string+0x16>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10d916: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10d91a: 74 54 je 10d970 <_Objects_Get_name_as_string+0xbc>
s = the_object->name.name_p;
10d91c: 8b 78 0c mov 0xc(%eax),%edi
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
10d91f: 85 ff test %edi,%edi
10d921: 74 74 je 10d997 <_Objects_Get_name_as_string+0xe3>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10d923: 4e dec %esi 10d924: 89 75 d4 mov %esi,-0x2c(%ebp)
10d927: 74 6e je 10d997 <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN
10d929: 8a 17 mov (%edi),%dl 10d92b: 84 d2 test %dl,%dl
10d92d: 74 68 je 10d997 <_Objects_Get_name_as_string+0xe3>
10d92f: 89 d9 mov %ebx,%ecx 10d931: 31 c0 xor %eax,%eax 10d933: 89 5d d0 mov %ebx,-0x30(%ebp) 10d936: eb 07 jmp 10d93f <_Objects_Get_name_as_string+0x8b> 10d938: 8a 14 07 mov (%edi,%eax,1),%dl 10d93b: 84 d2 test %dl,%dl
10d93d: 74 21 je 10d960 <_Objects_Get_name_as_string+0xac>
*d = (isprint((unsigned char)*s)) ? *s : '*';
10d93f: 0f b6 da movzbl %dl,%ebx 10d942: 8b 35 88 8c 12 00 mov 0x128c88,%esi 10d948: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx 10d94d: 81 e3 97 00 00 00 and $0x97,%ebx
10d953: 75 02 jne 10d957 <_Objects_Get_name_as_string+0xa3>
10d955: b2 2a mov $0x2a,%dl 10d957: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10d959: 40 inc %eax 10d95a: 41 inc %ecx 10d95b: 3b 45 d4 cmp -0x2c(%ebp),%eax
10d95e: 72 d8 jb 10d938 <_Objects_Get_name_as_string+0x84>
10d960: 8b 5d d0 mov -0x30(%ebp),%ebx
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
10d963: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
10d966: e8 41 0b 00 00 call 10e4ac <_Thread_Enable_dispatch>
return name;
10d96b: e9 5c ff ff ff jmp 10d8cc <_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;
10d970: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
10d973: 89 c2 mov %eax,%edx 10d975: c1 ea 18 shr $0x18,%edx 10d978: 88 55 df mov %dl,-0x21(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10d97b: 89 c2 mov %eax,%edx 10d97d: c1 ea 10 shr $0x10,%edx 10d980: 88 55 e0 mov %dl,-0x20(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10d983: 89 c2 mov %eax,%edx 10d985: c1 ea 08 shr $0x8,%edx 10d988: 88 55 e1 mov %dl,-0x1f(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10d98b: 88 45 e2 mov %al,-0x1e(%ebp)
lname[ 4 ] = '\0';
10d98e: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
s = lname;
10d992: 8d 7d df lea -0x21(%ebp),%edi 10d995: eb 8c jmp 10d923 <_Objects_Get_name_as_string+0x6f>
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10d997: 89 d9 mov %ebx,%ecx 10d999: eb c8 jmp 10d963 <_Objects_Get_name_as_string+0xaf>
0010c340 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
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 0c sub $0xc,%esp 10c349: 8b 5d 08 mov 0x8(%ebp),%ebx 10c34c: 8b 75 0c mov 0xc(%ebp),%esi 10c34f: 8b 7d 10 mov 0x10(%ebp),%edi
Objects_Control *object;
Objects_Id next_id;
if ( !information )
10c352: 85 db test %ebx,%ebx
10c354: 75 0a jne 10c360 <_Objects_Get_next+0x20>
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
10c356: 31 c0 xor %eax,%eax
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10c358: 8d 65 f4 lea -0xc(%ebp),%esp 10c35b: 5b pop %ebx 10c35c: 5e pop %esi 10c35d: 5f pop %edi 10c35e: c9 leave 10c35f: c3 ret
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
10c360: 85 ff test %edi,%edi
10c362: 74 f2 je 10c356 <_Objects_Get_next+0x16>
return NULL;
if ( !next_id_p )
10c364: 8b 45 14 mov 0x14(%ebp),%eax 10c367: 85 c0 test %eax,%eax
10c369: 74 eb je 10c356 <_Objects_Get_next+0x16>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
10c36b: 66 85 f6 test %si,%si
10c36e: 75 04 jne 10c374 <_Objects_Get_next+0x34>
next_id = information->minimum_id;
10c370: 8b 73 08 mov 0x8(%ebx),%esi 10c373: 90 nop
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
10c374: 66 39 73 10 cmp %si,0x10(%ebx)
10c378: 72 22 jb 10c39c <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
10c37a: 51 push %ecx 10c37b: 57 push %edi 10c37c: 56 push %esi 10c37d: 53 push %ebx 10c37e: e8 2d 00 00 00 call 10c3b0 <_Objects_Get>
next_id++;
10c383: 46 inc %esi
} while (*location_p != OBJECTS_LOCAL);
10c384: 83 c4 10 add $0x10,%esp 10c387: 8b 17 mov (%edi),%edx 10c389: 85 d2 test %edx,%edx
10c38b: 75 e7 jne 10c374 <_Objects_Get_next+0x34>
*next_id_p = next_id;
10c38d: 8b 55 14 mov 0x14(%ebp),%edx 10c390: 89 32 mov %esi,(%edx)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10c392: 8d 65 f4 lea -0xc(%ebp),%esp 10c395: 5b pop %ebx 10c396: 5e pop %esi 10c397: 5f pop %edi 10c398: c9 leave 10c399: c3 ret 10c39a: 66 90 xchg %ax,%ax
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
10c39c: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
10c3a2: 8b 45 14 mov 0x14(%ebp),%eax 10c3a5: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
return 0;
10c3ab: 31 c0 xor %eax,%eax 10c3ad: eb a9 jmp 10c358 <_Objects_Get_next+0x18>
0011a8c0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11a8c0: 55 push %ebp 11a8c1: 89 e5 mov %esp,%ebp 11a8c3: 53 push %ebx 11a8c4: 8b 55 08 mov 0x8(%ebp),%edx 11a8c7: 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;
11a8ca: b8 01 00 00 00 mov $0x1,%eax 11a8cf: 2b 42 08 sub 0x8(%edx),%eax 11a8d2: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
11a8d5: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11a8d9: 39 c8 cmp %ecx,%eax
11a8db: 77 13 ja 11a8f0 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11a8dd: 8b 52 1c mov 0x1c(%edx),%edx 11a8e0: 8b 04 82 mov (%edx,%eax,4),%eax 11a8e3: 85 c0 test %eax,%eax
11a8e5: 74 09 je 11a8f0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11a8e7: 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; }
11a8ed: 5b pop %ebx 11a8ee: c9 leave 11a8ef: 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;
11a8f0: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
11a8f6: 31 c0 xor %eax,%eax
}
11a8f8: 5b pop %ebx 11a8f9: c9 leave 11a8fa: c3 ret
0010d4a4 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10d4a4: 55 push %ebp 10d4a5: 89 e5 mov %esp,%ebp 10d4a7: 83 ec 18 sub $0x18,%esp 10d4aa: 8b 55 08 mov 0x8(%ebp),%edx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10d4ad: 85 d2 test %edx,%edx
10d4af: 75 08 jne 10d4b9 <_Objects_Id_to_name+0x15>
10d4b1: a1 18 9b 12 00 mov 0x129b18,%eax 10d4b6: 8b 50 08 mov 0x8(%eax),%edx 10d4b9: 89 d0 mov %edx,%eax 10d4bb: c1 e8 18 shr $0x18,%eax 10d4be: 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 )
10d4c1: 8d 48 ff lea -0x1(%eax),%ecx 10d4c4: 83 f9 02 cmp $0x2,%ecx
10d4c7: 77 1d ja 10d4e6 <_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 ] )
10d4c9: 8b 04 85 44 95 12 00 mov 0x129544(,%eax,4),%eax 10d4d0: 85 c0 test %eax,%eax
10d4d2: 74 12 je 10d4e6 <_Objects_Id_to_name+0x42>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10d4d4: 89 d1 mov %edx,%ecx 10d4d6: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10d4d9: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
10d4dc: 85 c0 test %eax,%eax
10d4de: 74 06 je 10d4e6 <_Objects_Id_to_name+0x42><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10d4e0: 80 78 38 00 cmpb $0x0,0x38(%eax)
10d4e4: 74 0a je 10d4f0 <_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;
10d4e6: 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;
}
10d4eb: c9 leave 10d4ec: c3 ret 10d4ed: 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 );
10d4f0: 51 push %ecx 10d4f1: 8d 4d f4 lea -0xc(%ebp),%ecx 10d4f4: 51 push %ecx 10d4f5: 52 push %edx 10d4f6: 50 push %eax 10d4f7: e8 40 ff ff ff call 10d43c <_Objects_Get>
if ( !the_object )
10d4fc: 83 c4 10 add $0x10,%esp 10d4ff: 85 c0 test %eax,%eax
10d501: 74 e3 je 10d4e6 <_Objects_Id_to_name+0x42>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10d503: 8b 50 0c mov 0xc(%eax),%edx 10d506: 8b 45 0c mov 0xc(%ebp),%eax 10d509: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10d50b: e8 24 0b 00 00 call 10e034 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10d510: 31 c0 xor %eax,%eax
}
10d512: c9 leave 10d513: c3 ret
001172cc <_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
)
{
1172cc: 55 push %ebp 1172cd: 89 e5 mov %esp,%ebp 1172cf: 57 push %edi 1172d0: 56 push %esi 1172d1: 53 push %ebx 1172d2: 83 ec 1c sub $0x1c,%esp 1172d5: 8b 7d 08 mov 0x8(%ebp),%edi
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
1172d8: 8b 5d 10 mov 0x10(%ebp),%ebx 1172db: 85 db test %ebx,%ebx
1172dd: 74 75 je 117354 <_Objects_Name_to_id_string+0x88>
return OBJECTS_INVALID_ADDRESS;
if ( !name )
1172df: 8b 4d 0c mov 0xc(%ebp),%ecx 1172e2: 85 c9 test %ecx,%ecx
1172e4: 74 4b je 117331 <_Objects_Name_to_id_string+0x65>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
1172e6: 8b 47 10 mov 0x10(%edi),%eax 1172e9: 66 85 c0 test %ax,%ax
1172ec: 74 43 je 117331 <_Objects_Name_to_id_string+0x65>
for ( index = 1; index <= information->maximum; index++ ) {
1172ee: 0f b7 c0 movzwl %ax,%eax 1172f1: 89 45 e4 mov %eax,-0x1c(%ebp) 1172f4: 8b 47 1c mov 0x1c(%edi),%eax 1172f7: bb 01 00 00 00 mov $0x1,%ebx 1172fc: 89 7d e0 mov %edi,-0x20(%ebp) 1172ff: 89 c7 mov %eax,%edi 117301: 8d 76 00 lea 0x0(%esi),%esi
the_object = information->local_table[ index ];
117304: 8b 34 9f mov (%edi,%ebx,4),%esi
if ( !the_object )
117307: 85 f6 test %esi,%esi
117309: 74 20 je 11732b <_Objects_Name_to_id_string+0x5f>
continue;
if ( !the_object->name.name_p )
11730b: 8b 46 0c mov 0xc(%esi),%eax 11730e: 85 c0 test %eax,%eax
117310: 74 19 je 11732b <_Objects_Name_to_id_string+0x5f>
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
117312: 52 push %edx 117313: 8b 4d e0 mov -0x20(%ebp),%ecx 117316: 0f b7 51 3a movzwl 0x3a(%ecx),%edx 11731a: 52 push %edx 11731b: 50 push %eax 11731c: ff 75 0c pushl 0xc(%ebp) 11731f: e8 68 34 00 00 call 11a78c <strncmp> 117324: 83 c4 10 add $0x10,%esp 117327: 85 c0 test %eax,%eax
117329: 74 15 je 117340 <_Objects_Name_to_id_string+0x74>
if ( !name )
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
11732b: 43 inc %ebx 11732c: 3b 5d e4 cmp -0x1c(%ebp),%ebx
11732f: 76 d3 jbe 117304 <_Objects_Name_to_id_string+0x38>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
}
}
return OBJECTS_INVALID_NAME;
117331: b8 01 00 00 00 mov $0x1,%eax
}
117336: 8d 65 f4 lea -0xc(%ebp),%esp 117339: 5b pop %ebx 11733a: 5e pop %esi 11733b: 5f pop %edi 11733c: c9 leave 11733d: c3 ret 11733e: 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;
117340: 8b 46 08 mov 0x8(%esi),%eax 117343: 8b 55 10 mov 0x10(%ebp),%edx 117346: 89 02 mov %eax,(%edx)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
117348: 31 c0 xor %eax,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
11734a: 8d 65 f4 lea -0xc(%ebp),%esp 11734d: 5b pop %ebx 11734e: 5e pop %esi 11734f: 5f pop %edi 117350: c9 leave 117351: c3 ret 117352: 66 90 xchg %ax,%ax
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
117354: b8 02 00 00 00 mov $0x2,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
117359: 8d 65 f4 lea -0xc(%ebp),%esp 11735c: 5b pop %ebx 11735d: 5e pop %esi 11735e: 5f pop %edi 11735f: c9 leave 117360: c3 ret
0010c378 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10c378: 55 push %ebp 10c379: 89 e5 mov %esp,%ebp 10c37b: 57 push %edi 10c37c: 56 push %esi 10c37d: 53 push %ebx 10c37e: 8b 45 08 mov 0x8(%ebp),%eax 10c381: 8b 4d 0c mov 0xc(%ebp),%ecx 10c384: 8b 55 10 mov 0x10(%ebp),%edx 10c387: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
10c38a: 85 ff test %edi,%edi
10c38c: 74 56 je 10c3e4 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10c38e: 85 c9 test %ecx,%ecx
10c390: 74 08 je 10c39a <_Objects_Name_to_id_u32+0x22>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10c392: 8b 70 10 mov 0x10(%eax),%esi 10c395: 66 85 f6 test %si,%si
10c398: 75 0a jne 10c3a4 <_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;
10c39a: b8 01 00 00 00 mov $0x1,%eax
#endif }
10c39f: 5b pop %ebx 10c3a0: 5e pop %esi 10c3a1: 5f pop %edi 10c3a2: c9 leave 10c3a3: c3 ret
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10c3a4: 85 d2 test %edx,%edx
10c3a6: 75 20 jne 10c3c8 <_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++ ) {
10c3a8: 0f b7 f6 movzwl %si,%esi 10c3ab: 8b 58 1c mov 0x1c(%eax),%ebx 10c3ae: b8 01 00 00 00 mov $0x1,%eax 10c3b3: 90 nop
the_object = information->local_table[ index ];
10c3b4: 8b 14 83 mov (%ebx,%eax,4),%edx
if ( !the_object )
10c3b7: 85 d2 test %edx,%edx
10c3b9: 74 05 je 10c3c0 <_Objects_Name_to_id_u32+0x48>
continue;
if ( name == the_object->name.name_u32 ) {
10c3bb: 39 4a 0c cmp %ecx,0xc(%edx)
10c3be: 74 18 je 10c3d8 <_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++ ) {
10c3c0: 40 inc %eax 10c3c1: 39 c6 cmp %eax,%esi
10c3c3: 73 ef jae 10c3b4 <_Objects_Name_to_id_u32+0x3c>
10c3c5: eb d3 jmp 10c39a <_Objects_Name_to_id_u32+0x22> 10c3c7: 90 nop
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
10c3c8: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10c3ce: 74 d8 je 10c3a8 <_Objects_Name_to_id_u32+0x30>
node == OBJECTS_SEARCH_LOCAL_NODE ||
10c3d0: 4a dec %edx
10c3d1: 75 c7 jne 10c39a <_Objects_Name_to_id_u32+0x22>
10c3d3: eb d3 jmp 10c3a8 <_Objects_Name_to_id_u32+0x30> 10c3d5: 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;
10c3d8: 8b 42 08 mov 0x8(%edx),%eax 10c3db: 89 07 mov %eax,(%edi)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c3dd: 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 }
10c3df: 5b pop %ebx 10c3e0: 5e pop %esi 10c3e1: 5f pop %edi 10c3e2: c9 leave 10c3e3: c3 ret
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
10c3e4: 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 }
10c3e9: 5b pop %ebx 10c3ea: 5e pop %esi 10c3eb: 5f pop %edi 10c3ec: c9 leave 10c3ed: c3 ret
0010c9e8 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10c9e8: 55 push %ebp 10c9e9: 89 e5 mov %esp,%ebp 10c9eb: 57 push %edi 10c9ec: 56 push %esi 10c9ed: 53 push %ebx 10c9ee: 83 ec 14 sub $0x14,%esp 10c9f1: 8b 7d 08 mov 0x8(%ebp),%edi 10c9f4: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10c9f7: 0f b7 47 3a movzwl 0x3a(%edi),%eax 10c9fb: 50 push %eax 10c9fc: 53 push %ebx 10c9fd: e8 96 81 00 00 call 114b98 <strnlen> 10ca02: 89 c6 mov %eax,%esi
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10ca04: 83 c4 10 add $0x10,%esp 10ca07: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10ca0b: 75 57 jne 10ca64 <_Objects_Set_name+0x7c>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10ca0d: 0f be 13 movsbl (%ebx),%edx 10ca10: c1 e2 18 shl $0x18,%edx 10ca13: 83 f8 01 cmp $0x1,%eax
10ca16: 76 38 jbe 10ca50 <_Objects_Set_name+0x68>
10ca18: 0f be 43 01 movsbl 0x1(%ebx),%eax 10ca1c: c1 e0 10 shl $0x10,%eax 10ca1f: 09 d0 or %edx,%eax 10ca21: 83 fe 02 cmp $0x2,%esi
10ca24: 74 31 je 10ca57 <_Objects_Set_name+0x6f>
10ca26: 0f be 53 02 movsbl 0x2(%ebx),%edx 10ca2a: c1 e2 08 shl $0x8,%edx 10ca2d: 09 c2 or %eax,%edx 10ca2f: 83 fe 03 cmp $0x3,%esi
10ca32: 0f 84 80 00 00 00 je 10cab8 <_Objects_Set_name+0xd0>
10ca38: 0f be 43 03 movsbl 0x3(%ebx),%eax 10ca3c: 09 c2 or %eax,%edx 10ca3e: 8b 45 0c mov 0xc(%ebp),%eax 10ca41: 89 50 0c mov %edx,0xc(%eax)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10ca44: b0 01 mov $0x1,%al
}
10ca46: 8d 65 f4 lea -0xc(%ebp),%esp 10ca49: 5b pop %ebx 10ca4a: 5e pop %esi 10ca4b: 5f pop %edi 10ca4c: c9 leave 10ca4d: c3 ret 10ca4e: 66 90 xchg %ax,%ax
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10ca50: 89 d0 mov %edx,%eax 10ca52: 0d 00 00 20 00 or $0x200000,%eax 10ca57: 89 c2 mov %eax,%edx 10ca59: 80 ce 20 or $0x20,%dh 10ca5c: b8 20 00 00 00 mov $0x20,%eax 10ca61: eb d9 jmp 10ca3c <_Objects_Set_name+0x54> 10ca63: 90 nop
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
10ca64: 83 ec 0c sub $0xc,%esp 10ca67: 8d 40 01 lea 0x1(%eax),%eax 10ca6a: 50 push %eax 10ca6b: e8 c0 19 00 00 call 10e430 <_Workspace_Allocate> 10ca70: 89 c7 mov %eax,%edi
if ( !d )
10ca72: 83 c4 10 add $0x10,%esp 10ca75: 85 c0 test %eax,%eax
10ca77: 74 3b je 10cab4 <_Objects_Set_name+0xcc>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
10ca79: 83 ec 0c sub $0xc,%esp 10ca7c: 8b 45 0c mov 0xc(%ebp),%eax 10ca7f: ff 70 0c pushl 0xc(%eax) 10ca82: e8 c5 19 00 00 call 10e44c <_Workspace_Free>
the_object->name.name_p = NULL;
10ca87: 8b 45 0c mov 0xc(%ebp),%eax 10ca8a: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
strncpy( d, name, length );
10ca91: 83 c4 0c add $0xc,%esp 10ca94: 56 push %esi 10ca95: 53 push %ebx 10ca96: 57 push %edi 10ca97: e8 80 80 00 00 call 114b1c <strncpy>
d[length] = '\0';
10ca9c: c6 04 37 00 movb $0x0,(%edi,%esi,1)
the_object->name.name_p = d;
10caa0: 8b 45 0c mov 0xc(%ebp),%eax 10caa3: 89 78 0c mov %edi,0xc(%eax) 10caa6: 83 c4 10 add $0x10,%esp
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10caa9: b0 01 mov $0x1,%al
}
10caab: 8d 65 f4 lea -0xc(%ebp),%esp 10caae: 5b pop %ebx 10caaf: 5e pop %esi 10cab0: 5f pop %edi 10cab1: c9 leave 10cab2: c3 ret 10cab3: 90 nop
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
10cab4: 31 c0 xor %eax,%eax 10cab6: eb 8e jmp 10ca46 <_Objects_Set_name+0x5e>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10cab8: b8 20 00 00 00 mov $0x20,%eax 10cabd: e9 7a ff ff ff jmp 10ca3c <_Objects_Set_name+0x54>
0010c3f0 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10c3f0: 55 push %ebp 10c3f1: 89 e5 mov %esp,%ebp 10c3f3: 57 push %edi 10c3f4: 56 push %esi 10c3f5: 53 push %ebx 10c3f6: 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 );
10c3f9: 8b 45 08 mov 0x8(%ebp),%eax 10c3fc: 0f b7 58 08 movzwl 0x8(%eax),%ebx
block_count = (information->maximum - index_base) /
10c400: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10c404: 0f b7 40 10 movzwl 0x10(%eax),%eax 10c408: 29 d8 sub %ebx,%eax 10c40a: 31 d2 xor %edx,%edx 10c40c: f7 f1 div %ecx
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10c40e: 85 c0 test %eax,%eax
10c410: 74 21 je 10c433 <_Objects_Shrink_information+0x43><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10c412: 8b 55 08 mov 0x8(%ebp),%edx 10c415: 8b 72 30 mov 0x30(%edx),%esi 10c418: 3b 0e cmp (%esi),%ecx
10c41a: 74 1f je 10c43b <_Objects_Shrink_information+0x4b><== NEVER TAKEN
10c41c: 31 d2 xor %edx,%edx 10c41e: eb 0e jmp 10c42e <_Objects_Shrink_information+0x3e>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10c420: 01 cb add %ecx,%ebx 10c422: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi
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 ] ==
10c429: 3b 0c 96 cmp (%esi,%edx,4),%ecx
10c42c: 74 12 je 10c440 <_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++ ) {
10c42e: 42 inc %edx 10c42f: 39 d0 cmp %edx,%eax
10c431: 77 ed ja 10c420 <_Objects_Shrink_information+0x30>
return;
}
index_base += information->allocation_size;
}
}
10c433: 8d 65 f4 lea -0xc(%ebp),%esp 10c436: 5b pop %ebx 10c437: 5e pop %esi 10c438: 5f pop %edi 10c439: c9 leave 10c43a: 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 ] ==
10c43b: 31 ff xor %edi,%edi <== NOT EXECUTED 10c43d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
10c440: 8b 55 08 mov 0x8(%ebp),%edx 10c443: 8b 42 20 mov 0x20(%edx),%eax 10c446: 89 7d e4 mov %edi,-0x1c(%ebp) 10c449: eb 07 jmp 10c452 <_Objects_Shrink_information+0x62> 10c44b: 90 nop
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10c44c: 85 f6 test %esi,%esi
10c44e: 74 2c je 10c47c <_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;
10c450: 89 f0 mov %esi,%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 );
10c452: 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;
10c456: 8b 30 mov (%eax),%esi
if ((index >= index_base) &&
10c458: 39 da cmp %ebx,%edx
10c45a: 72 f0 jb 10c44c <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
10c45c: 8b 7d 08 mov 0x8(%ebp),%edi 10c45f: 0f b7 4f 14 movzwl 0x14(%edi),%ecx 10c463: 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) &&
10c466: 39 ca cmp %ecx,%edx
10c468: 73 e2 jae 10c44c <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10c46a: 83 ec 0c sub $0xc,%esp 10c46d: 50 push %eax 10c46e: e8 81 f0 ff ff call 10b4f4 <_Chain_Extract> 10c473: 83 c4 10 add $0x10,%esp
}
}
while ( the_object );
10c476: 85 f6 test %esi,%esi
10c478: 75 d6 jne 10c450 <_Objects_Shrink_information+0x60>
10c47a: 66 90 xchg %ax,%ax 10c47c: 8b 7d e4 mov -0x1c(%ebp),%edi
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10c47f: 83 ec 0c sub $0xc,%esp 10c482: 8b 55 08 mov 0x8(%ebp),%edx 10c485: 8b 42 34 mov 0x34(%edx),%eax 10c488: ff 34 38 pushl (%eax,%edi,1) 10c48b: e8 e8 18 00 00 call 10dd78 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10c490: 8b 55 08 mov 0x8(%ebp),%edx 10c493: 8b 42 34 mov 0x34(%edx),%eax 10c496: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive_per_block[ block ] = 0;
10c49d: 8b 42 30 mov 0x30(%edx),%eax 10c4a0: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive -= information->allocation_size;
10c4a7: 8b 42 14 mov 0x14(%edx),%eax 10c4aa: 66 29 42 2c sub %ax,0x2c(%edx)
return;
10c4ae: 83 c4 10 add $0x10,%esp
}
index_base += information->allocation_size;
}
}
10c4b1: 8d 65 f4 lea -0xc(%ebp),%esp 10c4b4: 5b pop %ebx 10c4b5: 5e pop %esi 10c4b6: 5f pop %edi 10c4b7: c9 leave 10c4b8: c3 ret
0010cabc <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
10cabc: 55 push %ebp 10cabd: 89 e5 mov %esp,%ebp 10cabf: 57 push %edi 10cac0: 56 push %esi 10cac1: 53 push %ebx 10cac2: 83 ec 38 sub $0x38,%esp 10cac5: 8b 5d 08 mov 0x8(%ebp),%ebx 10cac8: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
10cacb: c7 06 00 00 00 00 movl $0x0,(%esi)
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
10cad1: 53 push %ebx 10cad2: e8 6d 3b 00 00 call 110644 <_Timespec_Is_valid> 10cad7: 83 c4 10 add $0x10,%esp 10cada: 84 c0 test %al,%al
10cadc: 75 0a jne 10cae8 <_POSIX_Absolute_timeout_to_ticks+0x2c>
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
10cade: 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; }
10cae0: 8d 65 f4 lea -0xc(%ebp),%esp 10cae3: 5b pop %ebx 10cae4: 5e pop %esi 10cae5: 5f pop %edi 10cae6: c9 leave 10cae7: c3 ret
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
10cae8: 83 ec 0c sub $0xc,%esp 10caeb: 8d 7d e0 lea -0x20(%ebp),%edi 10caee: 57 push %edi 10caef: e8 94 1b 00 00 call 10e688 <_TOD_Get>
if ( _Timespec_Less_than( abstime, ¤t_time ) )
10caf4: 5a pop %edx 10caf5: 59 pop %ecx 10caf6: 57 push %edi 10caf7: 53 push %ebx 10caf8: e8 6f 3b 00 00 call 11066c <_Timespec_Less_than> 10cafd: 83 c4 10 add $0x10,%esp 10cb00: 84 c0 test %al,%al
10cb02: 74 10 je 10cb14 <_POSIX_Absolute_timeout_to_ticks+0x58>
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
10cb04: 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; }
10cb09: 8d 65 f4 lea -0xc(%ebp),%esp 10cb0c: 5b pop %ebx 10cb0d: 5e pop %esi 10cb0e: 5f pop %edi 10cb0f: c9 leave 10cb10: c3 ret 10cb11: 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 );
10cb14: 50 push %eax 10cb15: 8d 45 d8 lea -0x28(%ebp),%eax 10cb18: 50 push %eax 10cb19: 53 push %ebx 10cb1a: 57 push %edi 10cb1b: 89 45 d4 mov %eax,-0x2c(%ebp) 10cb1e: e8 6d 3b 00 00 call 110690 <_Timespec_Subtract>
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
10cb23: 8b 45 d4 mov -0x2c(%ebp),%eax 10cb26: 89 04 24 mov %eax,(%esp) 10cb29: e8 a2 3b 00 00 call 1106d0 <_Timespec_To_ticks> 10cb2e: 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 )
10cb30: 83 c4 10 add $0x10,%esp
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
10cb33: 83 f8 01 cmp $0x1,%eax 10cb36: 19 c0 sbb %eax,%eax 10cb38: 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; }
10cb3b: 8d 65 f4 lea -0xc(%ebp),%esp 10cb3e: 5b pop %ebx 10cb3f: 5e pop %esi 10cb40: 5f pop %edi 10cb41: c9 leave 10cb42: c3 ret
0010b674 <_POSIX_Condition_variables_Get>:
POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get (
pthread_cond_t *cond,
Objects_Locations *location
)
{
10b674: 55 push %ebp 10b675: 89 e5 mov %esp,%ebp 10b677: 56 push %esi 10b678: 53 push %ebx 10b679: 8b 5d 08 mov 0x8(%ebp),%ebx 10b67c: 8b 75 0c mov 0xc(%ebp),%esi
int status;
if ( !cond ) {
10b67f: 85 db test %ebx,%ebx
10b681: 74 39 je 10b6bc <_POSIX_Condition_variables_Get+0x48>
*location = OBJECTS_ERROR;
return (POSIX_Condition_variables_Control *) 0;
}
if ( *cond == PTHREAD_COND_INITIALIZER ) {
10b683: 8b 03 mov (%ebx),%eax 10b685: 83 f8 ff cmp $0xffffffff,%eax
10b688: 74 1a je 10b6a4 <_POSIX_Condition_variables_Get+0x30>
}
/*
* Now call Objects_Get()
*/
return (POSIX_Condition_variables_Control *)_Objects_Get(
10b68a: 52 push %edx 10b68b: 56 push %esi 10b68c: 50 push %eax 10b68d: 68 80 a3 12 00 push $0x12a380 10b692: e8 8d 29 00 00 call 10e024 <_Objects_Get> 10b697: 83 c4 10 add $0x10,%esp
&_POSIX_Condition_variables_Information,
(Objects_Id) *cond,
location
);
}
10b69a: 8d 65 f8 lea -0x8(%ebp),%esp 10b69d: 5b pop %ebx 10b69e: 5e pop %esi 10b69f: c9 leave 10b6a0: c3 ret 10b6a1: 8d 76 00 lea 0x0(%esi),%esi
if ( *cond == PTHREAD_COND_INITIALIZER ) {
/*
* Do an "auto-create" here.
*/
status = pthread_cond_init( cond, 0 );
10b6a4: 83 ec 08 sub $0x8,%esp 10b6a7: 6a 00 push $0x0 10b6a9: 53 push %ebx 10b6aa: e8 19 00 00 00 call 10b6c8 <pthread_cond_init>
if ( status ) {
10b6af: 83 c4 10 add $0x10,%esp 10b6b2: 85 c0 test %eax,%eax
10b6b4: 75 06 jne 10b6bc <_POSIX_Condition_variables_Get+0x48>
10b6b6: 8b 03 mov (%ebx),%eax 10b6b8: eb d0 jmp 10b68a <_POSIX_Condition_variables_Get+0x16> 10b6ba: 66 90 xchg %ax,%ax
*location = OBJECTS_ERROR;
10b6bc: c7 06 01 00 00 00 movl $0x1,(%esi)
return (POSIX_Condition_variables_Control *) 0;
10b6c2: 31 c0 xor %eax,%eax 10b6c4: eb d4 jmp 10b69a <_POSIX_Condition_variables_Get+0x26>
0010b790 <_POSIX_Condition_variables_Signal_support>:
int _POSIX_Condition_variables_Signal_support(
pthread_cond_t *cond,
bool is_broadcast
)
{
10b790: 55 push %ebp 10b791: 89 e5 mov %esp,%ebp 10b793: 57 push %edi 10b794: 56 push %esi 10b795: 53 push %ebx 10b796: 83 ec 24 sub $0x24,%esp 10b799: 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 );
10b79c: 8d 45 e4 lea -0x1c(%ebp),%eax 10b79f: 50 push %eax 10b7a0: ff 75 08 pushl 0x8(%ebp) 10b7a3: e8 cc fe ff ff call 10b674 <_POSIX_Condition_variables_Get> 10b7a8: 89 c7 mov %eax,%edi
switch ( location ) {
10b7aa: 83 c4 10 add $0x10,%esp 10b7ad: 8b 45 e4 mov -0x1c(%ebp),%eax 10b7b0: 85 c0 test %eax,%eax
10b7b2: 74 10 je 10b7c4 <_POSIX_Condition_variables_Signal_support+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b7b4: b8 16 00 00 00 mov $0x16,%eax
}
10b7b9: 8d 65 f4 lea -0xc(%ebp),%esp 10b7bc: 5b pop %ebx 10b7bd: 5e pop %esi 10b7be: 5f pop %edi 10b7bf: c9 leave 10b7c0: c3 ret 10b7c1: 8d 76 00 lea 0x0(%esi),%esi 10b7c4: 8d 77 18 lea 0x18(%edi),%esi 10b7c7: eb 0b jmp 10b7d4 <_POSIX_Condition_variables_Signal_support+0x44> 10b7c9: 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 );
10b7cc: 84 db test %bl,%bl
10b7ce: 74 20 je 10b7f0 <_POSIX_Condition_variables_Signal_support+0x60>
10b7d0: 85 c0 test %eax,%eax
10b7d2: 74 1c je 10b7f0 <_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 );
10b7d4: 83 ec 0c sub $0xc,%esp 10b7d7: 56 push %esi 10b7d8: e8 d7 36 00 00 call 10eeb4 <_Thread_queue_Dequeue>
if ( !the_thread )
10b7dd: 83 c4 10 add $0x10,%esp 10b7e0: 85 c0 test %eax,%eax
10b7e2: 75 e8 jne 10b7cc <_POSIX_Condition_variables_Signal_support+0x3c>
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10b7e4: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi)
} while ( is_broadcast && the_thread );
10b7eb: 84 db test %bl,%bl
10b7ed: 75 e1 jne 10b7d0 <_POSIX_Condition_variables_Signal_support+0x40>
10b7ef: 90 nop
_Thread_Enable_dispatch();
10b7f0: e8 3f 33 00 00 call 10eb34 <_Thread_Enable_dispatch>
return 0;
10b7f5: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b7f7: 8d 65 f4 lea -0xc(%ebp),%esp 10b7fa: 5b pop %ebx 10b7fb: 5e pop %esi 10b7fc: 5f pop %edi 10b7fd: c9 leave 10b7fe: c3 ret
0010b858 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
10b858: 55 push %ebp 10b859: 89 e5 mov %esp,%ebp 10b85b: 57 push %edi 10b85c: 56 push %esi 10b85d: 53 push %ebx 10b85e: 83 ec 34 sub $0x34,%esp 10b861: 8b 7d 08 mov 0x8(%ebp),%edi 10b864: 8b 5d 0c mov 0xc(%ebp),%ebx 10b867: 8a 45 14 mov 0x14(%ebp),%al 10b86a: 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 ) ) {
10b86d: 8d 75 e4 lea -0x1c(%ebp),%esi 10b870: 56 push %esi 10b871: 53 push %ebx 10b872: e8 59 01 00 00 call 10b9d0 <_POSIX_Mutex_Get> 10b877: 83 c4 10 add $0x10,%esp 10b87a: 85 c0 test %eax,%eax
10b87c: 74 21 je 10b89f <_POSIX_Condition_variables_Wait_support+0x47>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b87e: a1 cc 9e 12 00 mov 0x129ecc,%eax 10b883: 48 dec %eax 10b884: a3 cc 9e 12 00 mov %eax,0x129ecc
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10b889: 83 ec 08 sub $0x8,%esp 10b88c: 56 push %esi 10b88d: 57 push %edi 10b88e: e8 e1 fd ff ff call 10b674 <_POSIX_Condition_variables_Get> 10b893: 89 c6 mov %eax,%esi
switch ( location ) {
10b895: 83 c4 10 add $0x10,%esp 10b898: 8b 55 e4 mov -0x1c(%ebp),%edx 10b89b: 85 d2 test %edx,%edx
10b89d: 74 11 je 10b8b0 <_POSIX_Condition_variables_Wait_support+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b89f: be 16 00 00 00 mov $0x16,%esi
}
10b8a4: 89 f0 mov %esi,%eax 10b8a6: 8d 65 f4 lea -0xc(%ebp),%esp 10b8a9: 5b pop %ebx 10b8aa: 5e pop %esi 10b8ab: 5f pop %edi 10b8ac: c9 leave 10b8ad: c3 ret 10b8ae: 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 ) ) {
10b8b0: 8b 40 14 mov 0x14(%eax),%eax 10b8b3: 85 c0 test %eax,%eax
10b8b5: 74 19 je 10b8d0 <_POSIX_Condition_variables_Wait_support+0x78>
10b8b7: 3b 03 cmp (%ebx),%eax
10b8b9: 74 15 je 10b8d0 <_POSIX_Condition_variables_Wait_support+0x78>
_Thread_Enable_dispatch();
10b8bb: e8 74 32 00 00 call 10eb34 <_Thread_Enable_dispatch>
return EINVAL;
10b8c0: be 16 00 00 00 mov $0x16,%esi
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b8c5: 89 f0 mov %esi,%eax 10b8c7: 8d 65 f4 lea -0xc(%ebp),%esp 10b8ca: 5b pop %ebx 10b8cb: 5e pop %esi 10b8cc: 5f pop %edi 10b8cd: c9 leave 10b8ce: c3 ret 10b8cf: 90 nop
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
_Thread_Enable_dispatch();
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
10b8d0: 83 ec 0c sub $0xc,%esp 10b8d3: 53 push %ebx 10b8d4: e8 73 03 00 00 call 10bc4c <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
10b8d9: 83 c4 10 add $0x10,%esp 10b8dc: 80 7d d7 00 cmpb $0x0,-0x29(%ebp)
10b8e0: 75 4e jne 10b930 <_POSIX_Condition_variables_Wait_support+0xd8>
the_cond->Mutex = *mutex;
10b8e2: 8b 03 mov (%ebx),%eax 10b8e4: 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;
10b8e7: 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;
10b8ee: a1 78 a4 12 00 mov 0x12a478,%eax 10b8f3: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
10b8fa: 83 c6 18 add $0x18,%esi 10b8fd: 89 70 44 mov %esi,0x44(%eax)
_Thread_Executing->Wait.id = *cond;
10b900: 8b 17 mov (%edi),%edx 10b902: 89 50 20 mov %edx,0x20(%eax)
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
10b905: 50 push %eax 10b906: 68 58 f3 10 00 push $0x10f358 10b90b: ff 75 10 pushl 0x10(%ebp) 10b90e: 56 push %esi 10b90f: e8 c8 36 00 00 call 10efdc <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10b914: e8 1b 32 00 00 call 10eb34 <_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;
10b919: a1 78 a4 12 00 mov 0x12a478,%eax 10b91e: 8b 70 34 mov 0x34(%eax),%esi
if ( status == EINTR )
10b921: 83 c4 10 add $0x10,%esp 10b924: 83 fe 04 cmp $0x4,%esi
10b927: 75 11 jne 10b93a <_POSIX_Condition_variables_Wait_support+0xe2>
status = 0;
10b929: 31 f6 xor %esi,%esi 10b92b: eb 0d jmp 10b93a <_POSIX_Condition_variables_Wait_support+0xe2> 10b92d: 8d 76 00 lea 0x0(%esi),%esi
} else {
_Thread_Enable_dispatch();
10b930: e8 ff 31 00 00 call 10eb34 <_Thread_Enable_dispatch>
status = ETIMEDOUT;
10b935: be 74 00 00 00 mov $0x74,%esi
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
10b93a: 83 ec 0c sub $0xc,%esp 10b93d: 53 push %ebx 10b93e: e8 81 02 00 00 call 10bbc4 <pthread_mutex_lock>
if ( mutex_status )
10b943: 83 c4 10 add $0x10,%esp 10b946: 85 c0 test %eax,%eax
10b948: 0f 85 51 ff ff ff jne 10b89f <_POSIX_Condition_variables_Wait_support+0x47>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b94e: 89 f0 mov %esi,%eax 10b950: 8d 65 f4 lea -0xc(%ebp),%esp 10b953: 5b pop %ebx 10b954: 5e pop %esi 10b955: 5f pop %edi 10b956: c9 leave 10b957: c3 ret
00115a48 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
115a48: 55 push %ebp 115a49: 89 e5 mov %esp,%ebp 115a4b: 57 push %edi 115a4c: 56 push %esi 115a4d: 53 push %ebx 115a4e: 83 ec 24 sub $0x24,%esp 115a51: 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 );
115a54: 68 ff 00 00 00 push $0xff 115a59: ff 75 08 pushl 0x8(%ebp) 115a5c: e8 37 4e 00 00 call 11a898 <strnlen> 115a61: 89 c6 mov %eax,%esi 115a63: a1 8c fa 12 00 mov 0x12fa8c,%eax 115a68: 40 inc %eax 115a69: a3 8c fa 12 00 mov %eax,0x12fa8c
* 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 ) {
115a6e: 83 c4 10 add $0x10,%esp 115a71: 85 db test %ebx,%ebx
115a73: 0f 84 b7 00 00 00 je 115b30 <_POSIX_Message_queue_Create_support+0xe8>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
115a79: 8b 7b 04 mov 0x4(%ebx),%edi 115a7c: 85 ff test %edi,%edi
115a7e: 0f 8e f0 00 00 00 jle 115b74 <_POSIX_Message_queue_Create_support+0x12c>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
115a84: 8b 5b 08 mov 0x8(%ebx),%ebx 115a87: 89 5d e4 mov %ebx,-0x1c(%ebp) 115a8a: 85 db test %ebx,%ebx
115a8c: 0f 8e e2 00 00 00 jle 115b74 <_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 );
115a92: 83 ec 0c sub $0xc,%esp 115a95: 68 20 fe 12 00 push $0x12fe20 115a9a: e8 fd c1 ff ff call 111c9c <_Objects_Allocate> 115a9f: 89 c3 mov %eax,%ebx
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
115aa1: 83 c4 10 add $0x10,%esp 115aa4: 85 c0 test %eax,%eax
115aa6: 0f 84 0a 01 00 00 je 115bb6 <_POSIX_Message_queue_Create_support+0x16e>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
115aac: 8b 45 0c mov 0xc(%ebp),%eax 115aaf: 89 43 10 mov %eax,0x10(%ebx)
the_mq->named = true;
115ab2: c6 43 14 01 movb $0x1,0x14(%ebx)
the_mq->open_count = 1;
115ab6: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx)
the_mq->linked = true;
115abd: 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);
115ac1: 8d 56 01 lea 0x1(%esi),%edx 115ac4: 83 ec 0c sub $0xc,%esp 115ac7: 52 push %edx 115ac8: 89 55 e0 mov %edx,-0x20(%ebp) 115acb: e8 c8 e2 ff ff call 113d98 <_Workspace_Allocate> 115ad0: 89 c6 mov %eax,%esi
if (!name) {
115ad2: 83 c4 10 add $0x10,%esp 115ad5: 85 c0 test %eax,%eax 115ad7: 8b 55 e0 mov -0x20(%ebp),%edx
115ada: 0f 84 ab 00 00 00 je 115b8b <_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 );
115ae0: 50 push %eax 115ae1: 52 push %edx 115ae2: ff 75 08 pushl 0x8(%ebp) 115ae5: 56 push %esi 115ae6: e8 31 4d 00 00 call 11a81c <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;
115aeb: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
if ( !_CORE_message_queue_Initialize(
115af2: ff 75 e4 pushl -0x1c(%ebp) 115af5: 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;
115af6: 8d 43 5c lea 0x5c(%ebx),%eax
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( !_CORE_message_queue_Initialize(
115af9: 50 push %eax 115afa: 8d 43 1c lea 0x1c(%ebx),%eax 115afd: 50 push %eax 115afe: e8 a9 11 00 00 call 116cac <_CORE_message_queue_Initialize> 115b03: 83 c4 20 add $0x20,%esp 115b06: 84 c0 test %al,%al
115b08: 74 3a je 115b44 <_POSIX_Message_queue_Create_support+0xfc>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
115b0a: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
115b0e: a1 3c fe 12 00 mov 0x12fe3c,%eax 115b13: 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;
115b16: 89 73 0c mov %esi,0xc(%ebx)
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
115b19: 8b 45 14 mov 0x14(%ebp),%eax 115b1c: 89 18 mov %ebx,(%eax)
_Thread_Enable_dispatch();
115b1e: e8 bd d1 ff ff call 112ce0 <_Thread_Enable_dispatch>
return 0;
115b23: 31 c0 xor %eax,%eax
}
115b25: 8d 65 f4 lea -0xc(%ebp),%esp 115b28: 5b pop %ebx 115b29: 5e pop %esi 115b2a: 5f pop %edi 115b2b: c9 leave 115b2c: c3 ret 115b2d: 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;
115b30: 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;
115b37: bf 0a 00 00 00 mov $0xa,%edi 115b3c: e9 51 ff ff ff jmp 115a92 <_POSIX_Message_queue_Create_support+0x4a> 115b41: 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 );
115b44: 83 ec 08 sub $0x8,%esp 115b47: 53 push %ebx 115b48: 68 20 fe 12 00 push $0x12fe20 115b4d: e8 be c4 ff ff call 112010 <_Objects_Free>
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
115b52: 89 34 24 mov %esi,(%esp) 115b55: e8 5a e2 ff ff call 113db4 <_Workspace_Free>
_Thread_Enable_dispatch();
115b5a: e8 81 d1 ff ff call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
115b5f: e8 b8 35 00 00 call 11911c <__errno> 115b64: c7 00 1c 00 00 00 movl $0x1c,(%eax) 115b6a: 83 c4 10 add $0x10,%esp 115b6d: b8 ff ff ff ff mov $0xffffffff,%eax 115b72: eb b1 jmp 115b25 <_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();
115b74: e8 67 d1 ff ff call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
115b79: e8 9e 35 00 00 call 11911c <__errno> 115b7e: c7 00 16 00 00 00 movl $0x16,(%eax) 115b84: b8 ff ff ff ff mov $0xffffffff,%eax 115b89: eb 9a jmp 115b25 <_POSIX_Message_queue_Create_support+0xdd> 115b8b: 83 ec 08 sub $0x8,%esp 115b8e: 53 push %ebx 115b8f: 68 20 fe 12 00 push $0x12fe20 115b94: e8 77 c4 ff ff call 112010 <_Objects_Free>
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
if (!name) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
115b99: e8 42 d1 ff ff call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOMEM );
115b9e: e8 79 35 00 00 call 11911c <__errno> 115ba3: c7 00 0c 00 00 00 movl $0xc,(%eax) 115ba9: 83 c4 10 add $0x10,%esp 115bac: b8 ff ff ff ff mov $0xffffffff,%eax 115bb1: e9 6f ff ff ff jmp 115b25 <_POSIX_Message_queue_Create_support+0xdd>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
115bb6: e8 25 d1 ff ff call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
115bbb: e8 5c 35 00 00 call 11911c <__errno> 115bc0: c7 00 17 00 00 00 movl $0x17,(%eax) 115bc6: b8 ff ff ff ff mov $0xffffffff,%eax 115bcb: e9 55 ff ff ff jmp 115b25 <_POSIX_Message_queue_Create_support+0xdd>
00115bd0 <_POSIX_Message_queue_Name_to_id>:
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
115bd0: 55 push %ebp 115bd1: 89 e5 mov %esp,%ebp 115bd3: 53 push %ebx 115bd4: 83 ec 14 sub $0x14,%esp 115bd7: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
115bda: 85 db test %ebx,%ebx
115bdc: 74 05 je 115be3 <_POSIX_Message_queue_Name_to_id+0x13>
return EINVAL;
if ( !name[0] )
115bde: 80 3b 00 cmpb $0x0,(%ebx)
115be1: 75 0d jne 115bf0 <_POSIX_Message_queue_Name_to_id+0x20>
return EINVAL;
115be3: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
115be8: 8b 5d fc mov -0x4(%ebp),%ebx 115beb: c9 leave 115bec: c3 ret 115bed: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
115bf0: 83 ec 08 sub $0x8,%esp 115bf3: 68 ff 00 00 00 push $0xff 115bf8: 53 push %ebx 115bf9: e8 9a 4c 00 00 call 11a898 <strnlen> 115bfe: 83 c4 10 add $0x10,%esp 115c01: 3d fe 00 00 00 cmp $0xfe,%eax
115c06: 76 0c jbe 115c14 <_POSIX_Message_queue_Name_to_id+0x44>
return ENAMETOOLONG;
115c08: b8 5b 00 00 00 mov $0x5b,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
115c0d: 8b 5d fc mov -0x4(%ebp),%ebx 115c10: c9 leave 115c11: c3 ret 115c12: 66 90 xchg %ax,%ax
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
return ENAMETOOLONG;
status = _Objects_Name_to_id_string(
115c14: 50 push %eax 115c15: 8d 45 f4 lea -0xc(%ebp),%eax 115c18: 50 push %eax 115c19: 53 push %ebx 115c1a: 68 20 fe 12 00 push $0x12fe20 115c1f: e8 a8 16 00 00 call 1172cc <_Objects_Name_to_id_string>
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
115c24: 8b 4d f4 mov -0xc(%ebp),%ecx 115c27: 8b 55 0c mov 0xc(%ebp),%edx 115c2a: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
115c2c: 83 c4 10 add $0x10,%esp
return 0;
115c2f: 83 f8 01 cmp $0x1,%eax 115c32: 19 c0 sbb %eax,%eax 115c34: f7 d0 not %eax 115c36: 83 e0 02 and $0x2,%eax
return ENOENT;
}
115c39: 8b 5d fc mov -0x4(%ebp),%ebx 115c3c: c9 leave 115c3d: c3 ret
0010f290 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10f290: 55 push %ebp 10f291: 89 e5 mov %esp,%ebp 10f293: 53 push %ebx 10f294: 83 ec 28 sub $0x28,%esp 10f297: 8b 5d 08 mov 0x8(%ebp),%ebx 10f29a: 8a 45 18 mov 0x18(%ebp),%al 10f29d: 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 );
10f2a0: 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(
10f2a3: 50 push %eax 10f2a4: 53 push %ebx 10f2a5: 68 c0 ff 12 00 push $0x12ffc0 10f2aa: e8 a1 2e 00 00 call 112150 <_Objects_Get>
switch ( location ) {
10f2af: 83 c4 10 add $0x10,%esp 10f2b2: 8b 55 f4 mov -0xc(%ebp),%edx 10f2b5: 85 d2 test %edx,%edx
10f2b7: 74 17 je 10f2d0 <_POSIX_Message_queue_Receive_support+0x40>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10f2b9: e8 5e 9e 00 00 call 11911c <__errno> 10f2be: c7 00 09 00 00 00 movl $0x9,(%eax) 10f2c4: b8 ff ff ff ff mov $0xffffffff,%eax
}
10f2c9: 8b 5d fc mov -0x4(%ebp),%ebx 10f2cc: c9 leave 10f2cd: c3 ret 10f2ce: 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 ) {
10f2d0: 8b 50 14 mov 0x14(%eax),%edx 10f2d3: 89 d1 mov %edx,%ecx 10f2d5: 83 e1 03 and $0x3,%ecx 10f2d8: 49 dec %ecx
10f2d9: 0f 84 af 00 00 00 je 10f38e <_POSIX_Message_queue_Receive_support+0xfe>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10f2df: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10f2e2: 8b 4d 10 mov 0x10(%ebp),%ecx 10f2e5: 39 48 68 cmp %ecx,0x68(%eax)
10f2e8: 77 62 ja 10f34c <_POSIX_Message_queue_Receive_support+0xbc>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10f2ea: 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 )
10f2f1: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10f2f5: 75 45 jne 10f33c <_POSIX_Message_queue_Receive_support+0xac><== ALWAYS TAKEN
10f2f7: 31 d2 xor %edx,%edx <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10f2f9: 83 ec 08 sub $0x8,%esp 10f2fc: ff 75 1c pushl 0x1c(%ebp) 10f2ff: 52 push %edx 10f300: 8d 55 f0 lea -0x10(%ebp),%edx 10f303: 52 push %edx 10f304: ff 75 0c pushl 0xc(%ebp) 10f307: 53 push %ebx 10f308: 83 c0 1c add $0x1c,%eax 10f30b: 50 push %eax 10f30c: e8 ef 1e 00 00 call 111200 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10f311: 83 c4 20 add $0x20,%esp 10f314: e8 c7 39 00 00 call 112ce0 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10f319: 8b 15 38 00 13 00 mov 0x130038,%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);
10f31f: 8b 42 24 mov 0x24(%edx),%eax 10f322: 85 c0 test %eax,%eax
10f324: 78 22 js 10f348 <_POSIX_Message_queue_Receive_support+0xb8>
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
10f326: 8b 4d 14 mov 0x14(%ebp),%ecx 10f329: 89 01 mov %eax,(%ecx)
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
10f32b: 8b 42 34 mov 0x34(%edx),%eax 10f32e: 85 c0 test %eax,%eax
10f330: 75 36 jne 10f368 <_POSIX_Message_queue_Receive_support+0xd8>
return length_out;
10f332: 8b 45 f0 mov -0x10(%ebp),%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
10f335: 8b 5d fc mov -0x4(%ebp),%ebx 10f338: c9 leave 10f339: c3 ret 10f33a: 66 90 xchg %ax,%ax
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10f33c: 80 e6 40 and $0x40,%dh 10f33f: 0f 94 c2 sete %dl 10f342: 0f b6 d2 movzbl %dl,%edx 10f345: eb b2 jmp 10f2f9 <_POSIX_Message_queue_Receive_support+0x69> 10f347: 90 nop 10f348: f7 d8 neg %eax 10f34a: eb da jmp 10f326 <_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();
10f34c: e8 8f 39 00 00 call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10f351: e8 c6 9d 00 00 call 11911c <__errno> 10f356: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10f35c: b8 ff ff ff ff mov $0xffffffff,%eax 10f361: e9 63 ff ff ff jmp 10f2c9 <_POSIX_Message_queue_Receive_support+0x39> 10f366: 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(
10f368: e8 af 9d 00 00 call 11911c <__errno> 10f36d: 89 c3 mov %eax,%ebx 10f36f: 83 ec 0c sub $0xc,%esp 10f372: a1 38 00 13 00 mov 0x130038,%eax 10f377: ff 70 34 pushl 0x34(%eax) 10f37a: e8 29 02 00 00 call 10f5a8 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10f37f: 89 03 mov %eax,(%ebx) 10f381: 83 c4 10 add $0x10,%esp 10f384: b8 ff ff ff ff mov $0xffffffff,%eax 10f389: e9 3b ff ff ff jmp 10f2c9 <_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();
10f38e: e8 4d 39 00 00 call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10f393: e8 84 9d 00 00 call 11911c <__errno> 10f398: c7 00 09 00 00 00 movl $0x9,(%eax) 10f39e: b8 ff ff ff ff mov $0xffffffff,%eax 10f3a3: e9 21 ff ff ff jmp 10f2c9 <_POSIX_Message_queue_Receive_support+0x39>
0010f3c8 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10f3c8: 55 push %ebp 10f3c9: 89 e5 mov %esp,%ebp 10f3cb: 56 push %esi 10f3cc: 53 push %ebx 10f3cd: 83 ec 20 sub $0x20,%esp 10f3d0: 8b 75 08 mov 0x8(%ebp),%esi 10f3d3: 8b 5d 14 mov 0x14(%ebp),%ebx 10f3d6: 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 )
10f3d9: 83 fb 20 cmp $0x20,%ebx
10f3dc: 0f 87 92 00 00 00 ja 10f474 <_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(
10f3e2: 51 push %ecx
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10f3e3: 8d 45 f4 lea -0xc(%ebp),%eax 10f3e6: 50 push %eax 10f3e7: 56 push %esi 10f3e8: 68 c0 ff 12 00 push $0x12ffc0 10f3ed: 88 55 e4 mov %dl,-0x1c(%ebp) 10f3f0: e8 5b 2d 00 00 call 112150 <_Objects_Get>
switch ( location ) {
10f3f5: 83 c4 10 add $0x10,%esp 10f3f8: 8b 55 f4 mov -0xc(%ebp),%edx 10f3fb: 85 d2 test %edx,%edx 10f3fd: 8a 55 e4 mov -0x1c(%ebp),%dl
10f400: 75 5e jne 10f460 <_POSIX_Message_queue_Send_support+0x98>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
10f402: 8b 48 14 mov 0x14(%eax),%ecx 10f405: f6 c1 03 test $0x3,%cl
10f408: 74 7e je 10f488 <_POSIX_Message_queue_Send_support+0xc0>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10f40a: 8b 40 10 mov 0x10(%eax),%eax
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10f40d: 84 d2 test %dl,%dl
10f40f: 75 37 jne 10f448 <_POSIX_Message_queue_Send_support+0x80>
10f411: 31 d2 xor %edx,%edx
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
10f413: ff 75 1c pushl 0x1c(%ebp) 10f416: 52 push %edx
RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core(
unsigned int priority
)
{
return priority * -1;
10f417: f7 db neg %ebx 10f419: 53 push %ebx 10f41a: 6a 00 push $0x0 10f41c: 56 push %esi 10f41d: ff 75 10 pushl 0x10(%ebp) 10f420: ff 75 0c pushl 0xc(%ebp) 10f423: 83 c0 1c add $0x1c,%eax 10f426: 50 push %eax 10f427: e8 00 1f 00 00 call 11132c <_CORE_message_queue_Submit> 10f42c: 89 c3 mov %eax,%ebx
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
10f42e: 83 c4 20 add $0x20,%esp 10f431: e8 aa 38 00 00 call 112ce0 <_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 )
10f436: 83 fb 07 cmp $0x7,%ebx
10f439: 74 19 je 10f454 <_POSIX_Message_queue_Send_support+0x8c>
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
10f43b: 85 db test %ebx,%ebx
10f43d: 75 61 jne 10f4a0 <_POSIX_Message_queue_Send_support+0xd8>
return msg_status;
10f43f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
10f441: 8d 65 f8 lea -0x8(%ebp),%esp 10f444: 5b pop %ebx 10f445: 5e pop %esi 10f446: c9 leave 10f447: c3 ret
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10f448: 31 d2 xor %edx,%edx 10f44a: f6 c5 40 test $0x40,%ch 10f44d: 0f 94 c2 sete %dl 10f450: eb c1 jmp 10f413 <_POSIX_Message_queue_Send_support+0x4b> 10f452: 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;
10f454: a1 38 00 13 00 mov 0x130038,%eax 10f459: 8b 58 34 mov 0x34(%eax),%ebx 10f45c: eb dd jmp 10f43b <_POSIX_Message_queue_Send_support+0x73> 10f45e: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10f460: e8 b7 9c 00 00 call 11911c <__errno> 10f465: c7 00 09 00 00 00 movl $0x9,(%eax) 10f46b: b8 ff ff ff ff mov $0xffffffff,%eax 10f470: eb cf jmp 10f441 <_POSIX_Message_queue_Send_support+0x79> 10f472: 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 );
10f474: e8 a3 9c 00 00 call 11911c <__errno> 10f479: c7 00 16 00 00 00 movl $0x16,(%eax) 10f47f: b8 ff ff ff ff mov $0xffffffff,%eax 10f484: eb bb jmp 10f441 <_POSIX_Message_queue_Send_support+0x79> 10f486: 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();
10f488: e8 53 38 00 00 call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10f48d: e8 8a 9c 00 00 call 11911c <__errno> 10f492: c7 00 09 00 00 00 movl $0x9,(%eax) 10f498: b8 ff ff ff ff mov $0xffffffff,%eax 10f49d: eb a2 jmp 10f441 <_POSIX_Message_queue_Send_support+0x79> 10f49f: 90 nop
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
return msg_status;
rtems_set_errno_and_return_minus_one(
10f4a0: e8 77 9c 00 00 call 11911c <__errno> 10f4a5: 89 c6 mov %eax,%esi 10f4a7: 83 ec 0c sub $0xc,%esp 10f4aa: 53 push %ebx 10f4ab: e8 f8 00 00 00 call 10f5a8 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10f4b0: 89 06 mov %eax,(%esi) 10f4b2: 83 c4 10 add $0x10,%esp 10f4b5: b8 ff ff ff ff mov $0xffffffff,%eax 10f4ba: eb 85 jmp 10f441 <_POSIX_Message_queue_Send_support+0x79>
0010c68c <_POSIX_Mutex_Get>:
POSIX_Mutex_Control *_POSIX_Mutex_Get (
pthread_mutex_t *mutex,
Objects_Locations *location
)
{
10c68c: 55 push %ebp 10c68d: 89 e5 mov %esp,%ebp 10c68f: 56 push %esi 10c690: 53 push %ebx 10c691: 8b 5d 08 mov 0x8(%ebp),%ebx 10c694: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10c697: 85 db test %ebx,%ebx
10c699: 74 39 je 10c6d4 <_POSIX_Mutex_Get+0x48>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10c69b: 8b 03 mov (%ebx),%eax 10c69d: 83 f8 ff cmp $0xffffffff,%eax
10c6a0: 74 1a je 10c6bc <_POSIX_Mutex_Get+0x30>
return (POSIX_Mutex_Control *)
_Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location );
10c6a2: 52 push %edx 10c6a3: 56 push %esi 10c6a4: 50 push %eax 10c6a5: 68 60 ca 12 00 push $0x12ca60 10c6aa: e8 f1 29 00 00 call 10f0a0 <_Objects_Get>
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
return (POSIX_Mutex_Control *)
10c6af: 83 c4 10 add $0x10,%esp
_Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location );
}
10c6b2: 8d 65 f8 lea -0x8(%ebp),%esp 10c6b5: 5b pop %ebx 10c6b6: 5e pop %esi 10c6b7: c9 leave 10c6b8: c3 ret 10c6b9: 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 );
10c6bc: 83 ec 08 sub $0x8,%esp 10c6bf: 6a 00 push $0x0 10c6c1: 53 push %ebx 10c6c2: e8 b9 00 00 00 call 10c780 <pthread_mutex_init> 10c6c7: 83 c4 10 add $0x10,%esp 10c6ca: 85 c0 test %eax,%eax
10c6cc: 75 06 jne 10c6d4 <_POSIX_Mutex_Get+0x48>
10c6ce: 8b 03 mov (%ebx),%eax 10c6d0: eb d0 jmp 10c6a2 <_POSIX_Mutex_Get+0x16> 10c6d2: 66 90 xchg %ax,%ax 10c6d4: c7 06 01 00 00 00 movl $0x1,(%esi) 10c6da: 31 c0 xor %eax,%eax 10c6dc: eb d4 jmp 10c6b2 <_POSIX_Mutex_Get+0x26>
0010c6e0 <_POSIX_Mutex_Get_interrupt_disable>:
POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable (
pthread_mutex_t *mutex,
Objects_Locations *location,
ISR_Level *level
)
{
10c6e0: 55 push %ebp 10c6e1: 89 e5 mov %esp,%ebp 10c6e3: 56 push %esi 10c6e4: 53 push %ebx 10c6e5: 8b 5d 08 mov 0x8(%ebp),%ebx 10c6e8: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10c6eb: 85 db test %ebx,%ebx
10c6ed: 74 39 je 10c728 <_POSIX_Mutex_Get_interrupt_disable+0x48>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10c6ef: 8b 03 mov (%ebx),%eax 10c6f1: 83 f8 ff cmp $0xffffffff,%eax
10c6f4: 74 1a je 10c710 <_POSIX_Mutex_Get_interrupt_disable+0x30>
return (POSIX_Mutex_Control *) _Objects_Get_isr_disable(
10c6f6: ff 75 10 pushl 0x10(%ebp) 10c6f9: 56 push %esi 10c6fa: 50 push %eax 10c6fb: 68 60 ca 12 00 push $0x12ca60 10c700: e8 43 29 00 00 call 10f048 <_Objects_Get_isr_disable> 10c705: 83 c4 10 add $0x10,%esp
&_POSIX_Mutex_Information,
(Objects_Id) *mutex,
location,
level
);
}
10c708: 8d 65 f8 lea -0x8(%ebp),%esp 10c70b: 5b pop %ebx 10c70c: 5e pop %esi 10c70d: c9 leave 10c70e: c3 ret 10c70f: 90 nop
ISR_Level *level
)
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10c710: 83 ec 08 sub $0x8,%esp 10c713: 6a 00 push $0x0 10c715: 53 push %ebx 10c716: e8 65 00 00 00 call 10c780 <pthread_mutex_init> 10c71b: 83 c4 10 add $0x10,%esp 10c71e: 85 c0 test %eax,%eax
10c720: 75 06 jne 10c728 <_POSIX_Mutex_Get_interrupt_disable+0x48>
10c722: 8b 03 mov (%ebx),%eax 10c724: eb d0 jmp 10c6f6 <_POSIX_Mutex_Get_interrupt_disable+0x16> 10c726: 66 90 xchg %ax,%ax 10c728: c7 06 01 00 00 00 movl $0x1,(%esi) 10c72e: 31 c0 xor %eax,%eax 10c730: eb d6 jmp 10c708 <_POSIX_Mutex_Get_interrupt_disable+0x28>
0010c8e0 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
bool blocking,
Watchdog_Interval timeout
)
{
10c8e0: 55 push %ebp 10c8e1: 89 e5 mov %esp,%ebp 10c8e3: 53 push %ebx 10c8e4: 83 ec 18 sub $0x18,%esp 10c8e7: 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 );
10c8ea: 8d 45 f0 lea -0x10(%ebp),%eax 10c8ed: 50 push %eax 10c8ee: 8d 45 f4 lea -0xc(%ebp),%eax 10c8f1: 50 push %eax 10c8f2: ff 75 08 pushl 0x8(%ebp) 10c8f5: e8 e6 fd ff ff call 10c6e0 <_POSIX_Mutex_Get_interrupt_disable>
switch ( location ) {
10c8fa: 83 c4 10 add $0x10,%esp 10c8fd: 8b 55 f4 mov -0xc(%ebp),%edx 10c900: 85 d2 test %edx,%edx
10c902: 75 34 jne 10c938 <_POSIX_Mutex_Lock_support+0x58>
case OBJECTS_LOCAL:
_CORE_mutex_Seize(
10c904: 83 ec 0c sub $0xc,%esp 10c907: ff 75 f0 pushl -0x10(%ebp) 10c90a: ff 75 10 pushl 0x10(%ebp) 10c90d: 0f b6 db movzbl %bl,%ebx 10c910: 53 push %ebx 10c911: ff 70 08 pushl 0x8(%eax) 10c914: 83 c0 14 add $0x14,%eax 10c917: 50 push %eax 10c918: e8 53 1b 00 00 call 10e470 <_CORE_mutex_Seize>
the_mutex->Object.id,
blocking,
timeout,
level
);
return _POSIX_Mutex_Translate_core_mutex_return_code(
10c91d: 83 c4 14 add $0x14,%esp
(CORE_mutex_Status) _Thread_Executing->Wait.return_code
10c920: a1 38 cc 12 00 mov 0x12cc38,%eax
the_mutex->Object.id,
blocking,
timeout,
level
);
return _POSIX_Mutex_Translate_core_mutex_return_code(
10c925: ff 70 34 pushl 0x34(%eax) 10c928: e8 1b 01 00 00 call 10ca48 <_POSIX_Mutex_Translate_core_mutex_return_code> 10c92d: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c930: 8b 5d fc mov -0x4(%ebp),%ebx 10c933: c9 leave 10c934: c3 ret 10c935: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c938: b8 16 00 00 00 mov $0x16,%eax
}
10c93d: 8b 5d fc mov -0x4(%ebp),%ebx 10c940: c9 leave 10c941: c3 ret
00113ed8 <_POSIX_Semaphore_Create_support>:
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
113ed8: 55 push %ebp 113ed9: 89 e5 mov %esp,%ebp 113edb: 56 push %esi 113edc: 53 push %ebx 113edd: 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)
113ee0: 8b 55 0c mov 0xc(%ebp),%edx 113ee3: 85 d2 test %edx,%edx
113ee5: 0f 85 b9 00 00 00 jne 113fa4 <_POSIX_Semaphore_Create_support+0xcc>
rtems_set_errno_and_return_minus_one( ENOSYS );
if ( name ) {
113eeb: 85 db test %ebx,%ebx
113eed: 74 1c je 113f0b <_POSIX_Semaphore_Create_support+0x33>
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
113eef: 83 ec 08 sub $0x8,%esp 113ef2: 68 ff 00 00 00 push $0xff 113ef7: 53 push %ebx 113ef8: e8 3b 43 00 00 call 118238 <strnlen> 113efd: 83 c4 10 add $0x10,%esp 113f00: 3d fe 00 00 00 cmp $0xfe,%eax
113f05: 0f 87 ad 00 00 00 ja 113fb8 <_POSIX_Semaphore_Create_support+0xe0>
113f0b: a1 ec c6 12 00 mov 0x12c6ec,%eax 113f10: 40 inc %eax 113f11: a3 ec c6 12 00 mov %eax,0x12c6ec
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
_Objects_Allocate( &_POSIX_Semaphore_Information );
113f16: 83 ec 0c sub $0xc,%esp 113f19: 68 00 ca 12 00 push $0x12ca00 113f1e: e8 b5 b7 ff ff call 10f6d8 <_Objects_Allocate> 113f23: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
113f25: 83 c4 10 add $0x10,%esp 113f28: 85 c0 test %eax,%eax
113f2a: 0f 84 9a 00 00 00 je 113fca <_POSIX_Semaphore_Create_support+0xf2>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
113f30: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
if ( name ) {
113f37: 85 db test %ebx,%ebx
113f39: 74 55 je 113f90 <_POSIX_Semaphore_Create_support+0xb8>
the_semaphore->named = true;
113f3b: c6 40 14 01 movb $0x1,0x14(%eax)
the_semaphore->open_count = 1;
113f3f: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
the_semaphore->linked = true;
113f46: 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;
113f4a: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi)
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
113f51: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi)
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
113f58: 50 push %eax 113f59: 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;
113f5c: 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 );
113f5f: 50 push %eax 113f60: 8d 46 1c lea 0x1c(%esi),%eax 113f63: 50 push %eax 113f64: e8 f7 b1 ff ff call 10f160 <_CORE_semaphore_Initialize>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
113f69: 0f b7 56 08 movzwl 0x8(%esi),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
113f6d: a1 1c ca 12 00 mov 0x12ca1c,%eax 113f72: 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;
113f75: 89 5e 0c mov %ebx,0xc(%esi)
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
113f78: 8b 45 14 mov 0x14(%ebp),%eax 113f7b: 89 30 mov %esi,(%eax)
_Thread_Enable_dispatch();
113f7d: e8 9a c7 ff ff call 11071c <_Thread_Enable_dispatch>
return 0;
113f82: 83 c4 10 add $0x10,%esp 113f85: 31 c0 xor %eax,%eax
}
113f87: 8d 65 f8 lea -0x8(%ebp),%esp 113f8a: 5b pop %ebx 113f8b: 5e pop %esi 113f8c: c9 leave 113f8d: c3 ret 113f8e: 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;
113f90: c6 40 14 00 movb $0x0,0x14(%eax)
the_semaphore->open_count = 0;
113f94: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_semaphore->linked = false;
113f9b: c6 40 15 00 movb $0x0,0x15(%eax) 113f9f: eb a9 jmp 113f4a <_POSIX_Semaphore_Create_support+0x72> 113fa1: 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 );
113fa4: e8 63 31 00 00 call 11710c <__errno> 113fa9: c7 00 58 00 00 00 movl $0x58,(%eax) 113faf: b8 ff ff ff ff mov $0xffffffff,%eax 113fb4: eb d1 jmp 113f87 <_POSIX_Semaphore_Create_support+0xaf> 113fb6: 66 90 xchg %ax,%ax
if ( name ) {
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
113fb8: e8 4f 31 00 00 call 11710c <__errno> 113fbd: c7 00 5b 00 00 00 movl $0x5b,(%eax) 113fc3: b8 ff ff ff ff mov $0xffffffff,%eax 113fc8: eb bd jmp 113f87 <_POSIX_Semaphore_Create_support+0xaf>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
113fca: e8 4d c7 ff ff call 11071c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
113fcf: e8 38 31 00 00 call 11710c <__errno> 113fd4: c7 00 1c 00 00 00 movl $0x1c,(%eax) 113fda: b8 ff ff ff ff mov $0xffffffff,%eax 113fdf: eb a6 jmp 113f87 <_POSIX_Semaphore_Create_support+0xaf>
00113fe4 <_POSIX_Semaphore_Delete>:
*/
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
113fe4: 55 push %ebp 113fe5: 89 e5 mov %esp,%ebp 113fe7: 53 push %ebx 113fe8: 83 ec 04 sub $0x4,%esp 113feb: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
113fee: 80 7b 15 00 cmpb $0x0,0x15(%ebx)
113ff2: 75 07 jne 113ffb <_POSIX_Semaphore_Delete+0x17>
113ff4: 8b 4b 18 mov 0x18(%ebx),%ecx 113ff7: 85 c9 test %ecx,%ecx
113ff9: 74 05 je 114000 <_POSIX_Semaphore_Delete+0x1c><== NEVER TAKEN
-1
);
_POSIX_Semaphore_Free( the_semaphore );
}
}
113ffb: 8b 5d fc mov -0x4(%ebp),%ebx 113ffe: c9 leave 113fff: c3 ret
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
_Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object );
114000: 83 ec 08 sub $0x8,%esp 114003: 53 push %ebx 114004: 68 00 ca 12 00 push $0x12ca00 114009: e8 46 b7 ff ff call 10f754 <_Objects_Close>
_CORE_semaphore_Flush(
11400e: 83 c4 0c add $0xc,%esp 114011: 6a ff push $0xffffffff 114013: 6a 00 push $0x0 114015: 8d 43 1c lea 0x1c(%ebx),%eax 114018: 50 push %eax 114019: e8 36 b1 ff ff call 10f154 <_CORE_semaphore_Flush>
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
11401e: 58 pop %eax 11401f: 5a pop %edx 114020: 53 push %ebx 114021: 68 00 ca 12 00 push $0x12ca00 114026: e8 21 ba ff ff call 10fa4c <_Objects_Free> 11402b: 83 c4 10 add $0x10,%esp
-1
);
_POSIX_Semaphore_Free( the_semaphore );
}
}
11402e: 8b 5d fc mov -0x4(%ebp),%ebx 114031: c9 leave 114032: c3 ret
00114034 <_POSIX_Semaphore_Name_to_id>:
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
114034: 55 push %ebp 114035: 89 e5 mov %esp,%ebp 114037: 83 ec 18 sub $0x18,%esp 11403a: 8b 45 08 mov 0x8(%ebp),%eax
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
11403d: 85 c0 test %eax,%eax
11403f: 74 05 je 114046 <_POSIX_Semaphore_Name_to_id+0x12>
return EINVAL;
if ( !name[0] )
114041: 80 38 00 cmpb $0x0,(%eax)
114044: 75 0a jne 114050 <_POSIX_Semaphore_Name_to_id+0x1c>
return EINVAL;
114046: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
11404b: c9 leave 11404c: c3 ret 11404d: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
status = _Objects_Name_to_id_string(
114050: 52 push %edx 114051: 8d 55 f4 lea -0xc(%ebp),%edx 114054: 52 push %edx 114055: 50 push %eax 114056: 68 00 ca 12 00 push $0x12ca00 11405b: e8 d4 11 00 00 call 115234 <_Objects_Name_to_id_string>
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
114060: 8b 4d f4 mov -0xc(%ebp),%ecx 114063: 8b 55 0c mov 0xc(%ebp),%edx 114066: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
114068: 83 c4 10 add $0x10,%esp
return 0;
11406b: 83 f8 01 cmp $0x1,%eax 11406e: 19 c0 sbb %eax,%eax 114070: f7 d0 not %eax 114072: 83 e0 02 and $0x2,%eax
return ENOENT;
}
114075: c9 leave 114076: c3 ret
001140a0 <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
1140a0: 55 push %ebp 1140a1: 89 e5 mov %esp,%ebp 1140a3: 53 push %ebx 1140a4: 83 ec 18 sub $0x18,%esp 1140a7: 8a 5d 0c mov 0xc(%ebp),%bl
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
1140aa: 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 );
1140ad: 50 push %eax 1140ae: 8b 45 08 mov 0x8(%ebp),%eax 1140b1: ff 30 pushl (%eax) 1140b3: 68 00 ca 12 00 push $0x12ca00 1140b8: e8 cf ba ff ff call 10fb8c <_Objects_Get>
switch ( location ) {
1140bd: 83 c4 10 add $0x10,%esp 1140c0: 8b 55 f4 mov -0xc(%ebp),%edx 1140c3: 85 d2 test %edx,%edx
1140c5: 74 15 je 1140dc <_POSIX_Semaphore_Wait_support+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
1140c7: e8 40 30 00 00 call 11710c <__errno> 1140cc: c7 00 16 00 00 00 movl $0x16,(%eax) 1140d2: b8 ff ff ff ff mov $0xffffffff,%eax
}
1140d7: 8b 5d fc mov -0x4(%ebp),%ebx 1140da: c9 leave 1140db: c3 ret
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
1140dc: ff 75 10 pushl 0x10(%ebp) 1140df: 0f b6 db movzbl %bl,%ebx 1140e2: 53 push %ebx 1140e3: ff 70 08 pushl 0x8(%eax) 1140e6: 83 c0 1c add $0x1c,%eax 1140e9: 50 push %eax 1140ea: e8 6d 0c 00 00 call 114d5c <_CORE_semaphore_Seize>
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
1140ef: e8 28 c6 ff ff call 11071c <_Thread_Enable_dispatch>
if ( !_Thread_Executing->Wait.return_code )
1140f4: 83 c4 10 add $0x10,%esp 1140f7: a1 98 cc 12 00 mov 0x12cc98,%eax 1140fc: 8b 40 34 mov 0x34(%eax),%eax 1140ff: 85 c0 test %eax,%eax
114101: 75 09 jne 11410c <_POSIX_Semaphore_Wait_support+0x6c>
return 0;
114103: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
114105: 8b 5d fc mov -0x4(%ebp),%ebx 114108: c9 leave 114109: c3 ret 11410a: 66 90 xchg %ax,%ax
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
return 0;
rtems_set_errno_and_return_minus_one(
11410c: e8 fb 2f 00 00 call 11710c <__errno> 114111: 89 c3 mov %eax,%ebx 114113: 83 ec 0c sub $0xc,%esp 114116: a1 98 cc 12 00 mov 0x12cc98,%eax 11411b: ff 70 34 pushl 0x34(%eax) 11411e: e8 6d 2a 00 00 call 116b90 <_POSIX_Semaphore_Translate_core_semaphore_return_code> 114123: 89 03 mov %eax,(%ebx) 114125: 83 c4 10 add $0x10,%esp 114128: b8 ff ff ff ff mov $0xffffffff,%eax 11412d: eb a8 jmp 1140d7 <_POSIX_Semaphore_Wait_support+0x37>
0010fc6c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10fc6c: 55 push %ebp 10fc6d: 89 e5 mov %esp,%ebp 10fc6f: 83 ec 08 sub $0x8,%esp 10fc72: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10fc75: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10fc7b: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx 10fc81: 85 c9 test %ecx,%ecx
10fc83: 75 09 jne 10fc8e <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN
10fc85: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10fc8c: 74 06 je 10fc94 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28>
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
}
10fc8e: 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();
10fc8f: e9 bc d4 ff ff jmp 10d150 <_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 &&
10fc94: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10fc9a: 85 c0 test %eax,%eax
10fc9c: 74 f0 je 10fc8e <_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;
10fc9e: a1 6c 8a 12 00 mov 0x128a6c,%eax 10fca3: 48 dec %eax 10fca4: a3 6c 8a 12 00 mov %eax,0x128a6c
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10fca9: 83 ec 08 sub $0x8,%esp 10fcac: 6a ff push $0xffffffff 10fcae: 52 push %edx 10fcaf: e8 c0 08 00 00 call 110574 <_POSIX_Thread_Exit> 10fcb4: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10fcb7: c9 leave 10fcb8: c3 ret
00110fcc <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
110fcc: 55 push %ebp 110fcd: 89 e5 mov %esp,%ebp 110fcf: 57 push %edi 110fd0: 56 push %esi 110fd1: 53 push %ebx 110fd2: 83 ec 18 sub $0x18,%esp 110fd5: 8b 5d 08 mov 0x8(%ebp),%ebx 110fd8: 8b 75 0c mov 0xc(%ebp),%esi 110fdb: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
110fde: ff 36 pushl (%esi) 110fe0: e8 cb ff ff ff call 110fb0 <_POSIX_Priority_Is_valid> 110fe5: 83 c4 10 add $0x10,%esp 110fe8: 84 c0 test %al,%al
110fea: 74 2a je 111016 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110fec: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
110ff2: 8b 45 14 mov 0x14(%ebp),%eax 110ff5: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
110ffb: 85 db test %ebx,%ebx
110ffd: 74 25 je 111024 <_POSIX_Thread_Translate_sched_param+0x58>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
110fff: 83 fb 01 cmp $0x1,%ebx
111002: 0f 84 90 00 00 00 je 111098 <_POSIX_Thread_Translate_sched_param+0xcc>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
111008: 83 fb 02 cmp $0x2,%ebx
11100b: 0f 84 8f 00 00 00 je 1110a0 <_POSIX_Thread_Translate_sched_param+0xd4>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
111011: 83 fb 04 cmp $0x4,%ebx
111014: 74 1e je 111034 <_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;
111016: b8 16 00 00 00 mov $0x16,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
11101b: 8d 65 f4 lea -0xc(%ebp),%esp 11101e: 5b pop %ebx 11101f: 5e pop %esi 111020: 5f pop %edi 111021: c9 leave 111022: c3 ret 111023: 90 nop
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
111024: c7 07 01 00 00 00 movl $0x1,(%edi)
return 0;
11102a: 31 c0 xor %eax,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
11102c: 8d 65 f4 lea -0xc(%ebp),%esp 11102f: 5b pop %ebx 111030: 5e pop %esi 111031: 5f pop %edi 111032: c9 leave 111033: 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) &&
111034: 8b 5e 08 mov 0x8(%esi),%ebx 111037: 85 db test %ebx,%ebx
111039: 75 07 jne 111042 <_POSIX_Thread_Translate_sched_param+0x76>
11103b: 8b 4e 0c mov 0xc(%esi),%ecx 11103e: 85 c9 test %ecx,%ecx
111040: 74 d4 je 111016 <_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) &&
111042: 8b 56 10 mov 0x10(%esi),%edx 111045: 85 d2 test %edx,%edx
111047: 75 07 jne 111050 <_POSIX_Thread_Translate_sched_param+0x84>
111049: 8b 46 14 mov 0x14(%esi),%eax 11104c: 85 c0 test %eax,%eax
11104e: 74 c6 je 111016 <_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 ) <
111050: 83 ec 0c sub $0xc,%esp 111053: 8d 46 08 lea 0x8(%esi),%eax 111056: 50 push %eax 111057: e8 fc d7 ff ff call 10e858 <_Timespec_To_ticks> 11105c: 89 c3 mov %eax,%ebx
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
11105e: 8d 46 10 lea 0x10(%esi),%eax 111061: 89 04 24 mov %eax,(%esp) 111064: e8 ef d7 ff ff call 10e858 <_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 ) <
111069: 83 c4 10 add $0x10,%esp 11106c: 39 c3 cmp %eax,%ebx
11106e: 72 a6 jb 111016 <_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 ) )
111070: 83 ec 0c sub $0xc,%esp 111073: ff 76 04 pushl 0x4(%esi) 111076: e8 35 ff ff ff call 110fb0 <_POSIX_Priority_Is_valid> 11107b: 83 c4 10 add $0x10,%esp 11107e: 84 c0 test %al,%al
111080: 74 94 je 111016 <_POSIX_Thread_Translate_sched_param+0x4a>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
111082: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
111088: 8b 45 14 mov 0x14(%ebp),%eax 11108b: c7 00 bc b2 10 00 movl $0x10b2bc,(%eax)
return 0;
111091: 31 c0 xor %eax,%eax 111093: eb 86 jmp 11101b <_POSIX_Thread_Translate_sched_param+0x4f> 111095: 8d 76 00 lea 0x0(%esi),%esi
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
111098: 31 c0 xor %eax,%eax 11109a: e9 7c ff ff ff jmp 11101b <_POSIX_Thread_Translate_sched_param+0x4f> 11109f: 90 nop
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
1110a0: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
1110a6: 31 c0 xor %eax,%eax 1110a8: e9 6e ff ff ff jmp 11101b <_POSIX_Thread_Translate_sched_param+0x4f>
0010fef8 <_POSIX_Threads_Create_extension>:
bool _POSIX_Threads_Create_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *created
)
{
10fef8: 55 push %ebp 10fef9: 89 e5 mov %esp,%ebp 10fefb: 57 push %edi 10fefc: 56 push %esi 10fefd: 53 push %ebx 10fefe: 83 ec 28 sub $0x28,%esp 10ff01: 8b 55 0c mov 0xc(%ebp),%edx
POSIX_API_Control *api;
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
10ff04: 68 f0 00 00 00 push $0xf0 10ff09: 89 55 e4 mov %edx,-0x1c(%ebp) 10ff0c: e8 4b de ff ff call 10dd5c <_Workspace_Allocate> 10ff11: 89 c3 mov %eax,%ebx
if ( !api )
10ff13: 83 c4 10 add $0x10,%esp 10ff16: 85 c0 test %eax,%eax 10ff18: 8b 55 e4 mov -0x1c(%ebp),%edx
10ff1b: 0f 84 2f 01 00 00 je 110050 <_POSIX_Threads_Create_extension+0x158>
return false;
created->API_Extensions[ THREAD_API_POSIX ] = api;
10ff21: 89 82 ec 00 00 00 mov %eax,0xec(%edx)
/* XXX check all fields are touched */
api->Attributes = _POSIX_Threads_Default_attributes;
10ff27: b9 40 00 00 00 mov $0x40,%ecx 10ff2c: 31 c0 xor %eax,%eax 10ff2e: 89 df mov %ebx,%edi 10ff30: f3 aa rep stos %al,%es:(%edi) 10ff32: c7 03 01 00 00 00 movl $0x1,(%ebx) 10ff38: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) 10ff3f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx) 10ff46: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx) 10ff4d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) 10ff54: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx)
api->detachstate = _POSIX_Threads_Default_attributes.detachstate;
10ff5b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx)
api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;
10ff62: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx)
10ff69: 00 00 00 api->schedparam = _POSIX_Threads_Default_attributes.schedparam;
10ff6c: be 58 16 12 00 mov $0x121658,%esi 10ff71: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10ff77: b1 07 mov $0x7,%cl 10ff79: 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);
10ff7b: 0f b6 05 54 35 12 00 movzbl 0x123554,%eax 10ff82: 2b 42 14 sub 0x14(%edx),%eax 10ff85: 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;
10ff8b: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
10ff92: 00 00 00 api->cancelability_state = PTHREAD_CANCEL_ENABLE;
10ff95: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx)
10ff9c: 00 00 00 api->cancelability_type = PTHREAD_CANCEL_DEFERRED;
10ff9f: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
10ffa6: 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 );
10ffa9: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax 10ffaf: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
head->next = tail;
head->previous = NULL;
10ffb5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10ffbc: 00 00 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10ffbf: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax 10ffc5: 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;
10ffcb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx)
10ffd2: 00 00 00
10ffd5: 0f b6 42 0b movzbl 0xb(%edx),%eax 10ffd9: 83 e0 07 and $0x7,%eax
if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API
10ffdc: 83 f8 03 cmp $0x3,%eax
10ffdf: 74 53 je 110034 <_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;
10ffe1: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx)
10ffe8: ff ff ff
}
_Thread_queue_Initialize(
10ffeb: 6a 00 push $0x0 10ffed: 68 00 10 00 00 push $0x1000 10fff2: 6a 00 push $0x0 10fff4: 8d 43 44 lea 0x44(%ebx),%eax 10fff7: 50 push %eax 10fff8: 89 55 e4 mov %edx,-0x1c(%ebp) 10fffb: e8 90 d4 ff ff call 10d490 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_JOIN_AT_EXIT,
0
);
_Watchdog_Initialize(
110000: 8b 55 e4 mov -0x1c(%ebp),%edx 110003: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
110006: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx)
11000d: 00 00 00 the_watchdog->routine = routine;
110010: c7 83 c4 00 00 00 5c movl $0x11005c,0xc4(%ebx)
110017: 00 11 00 the_watchdog->id = id;
11001a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx)
the_watchdog->user_data = user_data;
110020: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx)
_POSIX_Threads_Sporadic_budget_TSR,
created->Object.id,
created
);
return true;
110026: 83 c4 10 add $0x10,%esp 110029: b0 01 mov $0x1,%al
}
11002b: 8d 65 f4 lea -0xc(%ebp),%esp 11002e: 5b pop %ebx 11002f: 5e pop %esi 110030: 5f pop %edi 110031: c9 leave 110032: c3 ret 110033: 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 ];
110034: a1 98 7d 12 00 mov 0x127d98,%eax
api->signals_blocked = executing_api->signals_blocked;
110039: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 11003f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 110045: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx) 11004b: eb 9e jmp 10ffeb <_POSIX_Threads_Create_extension+0xf3> 11004d: 8d 76 00 lea 0x0(%esi),%esi
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
if ( !api )
return false;
110050: 31 c0 xor %eax,%eax
created->Object.id,
created
);
return true;
}
110052: 8d 65 f4 lea -0xc(%ebp),%esp 110055: 5b pop %ebx 110056: 5e pop %esi 110057: 5f pop %edi 110058: c9 leave 110059: c3 ret
0010fe70 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
10fe70: 55 push %ebp 10fe71: 89 e5 mov %esp,%ebp 10fe73: 57 push %edi 10fe74: 56 push %esi 10fe75: 53 push %ebx 10fe76: 83 ec 28 sub $0x28,%esp 10fe79: 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 ];
10fe7c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax 10fe82: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
10fe85: 57 push %edi 10fe86: e8 15 27 00 00 call 1125a0 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
10fe8b: 89 3c 24 mov %edi,(%esp) 10fe8e: e8 75 27 00 00 call 112608 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
10fe93: 8b 77 28 mov 0x28(%edi),%esi
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
10fe96: 83 c4 10 add $0x10,%esp 10fe99: 8b 45 e4 mov -0x1c(%ebp),%eax 10fe9c: 8d 58 44 lea 0x44(%eax),%ebx 10fe9f: eb 08 jmp 10fea9 <_POSIX_Threads_Delete_extension+0x39> 10fea1: 8d 76 00 lea 0x0(%esi),%esi
*(void **)the_thread->Wait.return_argument = value_ptr;
10fea4: 8b 40 28 mov 0x28(%eax),%eax 10fea7: 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 )) )
10fea9: 83 ec 0c sub $0xc,%esp 10feac: 53 push %ebx 10fead: e8 4e d2 ff ff call 10d100 <_Thread_queue_Dequeue> 10feb2: 83 c4 10 add $0x10,%esp 10feb5: 85 c0 test %eax,%eax
10feb7: 75 eb jne 10fea4 <_POSIX_Threads_Delete_extension+0x34>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
10feb9: 8b 45 e4 mov -0x1c(%ebp),%eax 10febc: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
10fec3: 74 1f je 10fee4 <_POSIX_Threads_Delete_extension+0x74>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
10fec5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi)
10fecc: 00 00 00
_Workspace_Free( api );
10fecf: 8b 45 e4 mov -0x1c(%ebp),%eax 10fed2: 89 45 08 mov %eax,0x8(%ebp)
}
10fed5: 8d 65 f4 lea -0xc(%ebp),%esp 10fed8: 5b pop %ebx 10fed9: 5e pop %esi 10feda: 5f pop %edi 10fedb: c9 leave
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
10fedc: e9 97 de ff ff jmp 10dd78 <_Workspace_Free> 10fee1: 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 );
10fee4: 83 ec 0c sub $0xc,%esp 10fee7: 05 a8 00 00 00 add $0xa8,%eax 10feec: 50 push %eax 10feed: e8 42 dd ff ff call 10dc34 <_Watchdog_Remove> 10fef2: 83 c4 10 add $0x10,%esp 10fef5: eb ce jmp 10fec5 <_POSIX_Threads_Delete_extension+0x55>
0010fe34 <_POSIX_Threads_Initialize_user_threads>:
*
* This routine creates and starts all configured user
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
10fe34: 55 push %ebp 10fe35: 89 e5 mov %esp,%ebp 10fe37: 83 ec 08 sub $0x8,%esp
if ( _POSIX_Threads_Initialize_user_threads_p )
10fe3a: a1 b8 5a 12 00 mov 0x125ab8,%eax 10fe3f: 85 c0 test %eax,%eax
10fe41: 74 05 je 10fe48 <_POSIX_Threads_Initialize_user_threads+0x14>
(*_POSIX_Threads_Initialize_user_threads_p)();
}
10fe43: c9 leave
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
if ( _POSIX_Threads_Initialize_user_threads_p )
(*_POSIX_Threads_Initialize_user_threads_p)();
10fe44: ff e0 jmp *%eax 10fe46: 66 90 xchg %ax,%ax
}
10fe48: c9 leave 10fe49: c3 ret
0010af9c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10af9c: 55 push %ebp 10af9d: 89 e5 mov %esp,%ebp 10af9f: 57 push %edi 10afa0: 56 push %esi 10afa1: 53 push %ebx 10afa2: 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;
10afa5: 8b 3d d4 47 12 00 mov 0x1247d4,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10afab: a1 d0 47 12 00 mov 0x1247d0,%eax 10afb0: 89 45 94 mov %eax,-0x6c(%ebp)
if ( !user_threads || maximum == 0 )
10afb3: 85 ff test %edi,%edi
10afb5: 74 44 je 10affb <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN
10afb7: 85 c0 test %eax,%eax
10afb9: 74 40 je 10affb <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN
10afbb: 31 db xor %ebx,%ebx 10afbd: 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 );
10afc0: 83 ec 0c sub $0xc,%esp 10afc3: 56 push %esi 10afc4: e8 e7 60 00 00 call 1110b0 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10afc9: 5a pop %edx 10afca: 59 pop %ecx 10afcb: 6a 02 push $0x2 10afcd: 56 push %esi 10afce: e8 09 61 00 00 call 1110dc <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10afd3: 59 pop %ecx 10afd4: 58 pop %eax 10afd5: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10afd9: 56 push %esi 10afda: e8 31 61 00 00 call 111110 <pthread_attr_setstacksize>
status = pthread_create(
10afdf: 6a 00 push $0x0 10afe1: ff 34 df pushl (%edi,%ebx,8) 10afe4: 56 push %esi 10afe5: 8d 45 e4 lea -0x1c(%ebp),%eax 10afe8: 50 push %eax 10afe9: e8 92 fc ff ff call 10ac80 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10afee: 83 c4 20 add $0x20,%esp 10aff1: 85 c0 test %eax,%eax
10aff3: 75 0e jne 10b003 <_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++ ) {
10aff5: 43 inc %ebx 10aff6: 39 5d 94 cmp %ebx,-0x6c(%ebp)
10aff9: 77 c5 ja 10afc0 <_POSIX_Threads_Initialize_user_threads_body+0x24><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10affb: 8d 65 f4 lea -0xc(%ebp),%esp 10affe: 5b pop %ebx 10afff: 5e pop %esi 10b000: 5f pop %edi 10b001: c9 leave 10b002: c3 ret
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10b003: 52 push %edx 10b004: 50 push %eax 10b005: 6a 01 push $0x1 10b007: 6a 02 push $0x2 10b009: e8 da 1c 00 00 call 10cce8 <_Internal_error_Occurred>
0011005c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
11005c: 55 push %ebp 11005d: 89 e5 mov %esp,%ebp 11005f: 56 push %esi 110060: 53 push %ebx 110061: 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 ];
110064: 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 );
11006a: 83 ec 0c sub $0xc,%esp 11006d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax 110073: 50 push %eax 110074: e8 97 13 00 00 call 111410 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
110079: 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);
11007c: 0f b6 05 54 35 12 00 movzbl 0x123554,%eax 110083: 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;
110089: 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 ) {
11008c: 83 c4 10 add $0x10,%esp 11008f: 8b 4e 1c mov 0x1c(%esi),%ecx 110092: 85 c9 test %ecx,%ecx
110094: 75 05 jne 11009b <_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 ) {
110096: 39 46 14 cmp %eax,0x14(%esi)
110099: 77 35 ja 1100d0 <_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 );
11009b: 83 ec 0c sub $0xc,%esp 11009e: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax 1100a4: 50 push %eax 1100a5: e8 66 13 00 00 call 111410 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
1100aa: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
1100b0: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
1100b3: 81 c3 a8 00 00 00 add $0xa8,%ebx 1100b9: 89 5d 0c mov %ebx,0xc(%ebp) 1100bc: c7 45 08 c0 78 12 00 movl $0x1278c0,0x8(%ebp)
}
1100c3: 8d 65 f8 lea -0x8(%ebp),%esp 1100c6: 5b pop %ebx 1100c7: 5e pop %esi 1100c8: c9 leave 1100c9: e9 26 da ff ff jmp 10daf4 <_Watchdog_Insert> 1100ce: 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 );
1100d0: 52 push %edx 1100d1: 6a 01 push $0x1 1100d3: 50 push %eax 1100d4: 56 push %esi 1100d5: e8 6e c8 ff ff call 10c948 <_Thread_Change_priority> 1100da: 83 c4 10 add $0x10,%esp 1100dd: eb bc jmp 11009b <_POSIX_Threads_Sporadic_budget_TSR+0x3f>
001100e0 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
1100e0: 55 push %ebp 1100e1: 89 e5 mov %esp,%ebp 1100e3: 83 ec 08 sub $0x8,%esp 1100e6: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1100e9: 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 */
1100ef: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 1100f6: 0f b6 15 54 35 12 00 movzbl 0x123554,%edx 1100fd: 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;
110103: 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 ) {
110106: 8b 48 1c mov 0x1c(%eax),%ecx 110109: 85 c9 test %ecx,%ecx
11010b: 75 05 jne 110112 <_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 ) {
11010d: 39 50 14 cmp %edx,0x14(%eax)
110110: 72 02 jb 110114 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110112: c9 leave <== NOT EXECUTED 110113: 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 );
110114: 51 push %ecx 110115: 6a 01 push $0x1 110117: 52 push %edx 110118: 50 push %eax 110119: e8 2a c8 ff ff call 10c948 <_Thread_Change_priority> 11011e: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110121: c9 leave 110122: c3 ret
001125a0 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
1125a0: 55 push %ebp 1125a1: 89 e5 mov %esp,%ebp 1125a3: 57 push %edi 1125a4: 56 push %esi 1125a5: 53 push %ebx 1125a6: 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 ];
1125a9: 8b 45 08 mov 0x8(%ebp),%eax 1125ac: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
1125b2: c7 86 d8 00 00 00 01 movl $0x1,0xd8(%esi)
1125b9: 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 );
1125bc: 8d be e8 00 00 00 lea 0xe8(%esi),%edi
while ( !_Chain_Is_empty( handler_stack ) ) {
1125c2: 39 be e4 00 00 00 cmp %edi,0xe4(%esi)
1125c8: 74 33 je 1125fd <_POSIX_Threads_cancel_run+0x5d>
1125ca: 66 90 xchg %ax,%ax
_ISR_Disable( level );
1125cc: 9c pushf 1125cd: fa cli 1125ce: 59 pop %ecx
handler = (POSIX_Cancel_Handler_control *)
1125cf: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
1125d5: 8b 13 mov (%ebx),%edx
previous = the_node->previous;
1125d7: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
1125da: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
1125dd: 89 10 mov %edx,(%eax)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
1125df: 51 push %ecx 1125e0: 9d popf
(*handler->routine)( handler->arg );
1125e1: 83 ec 0c sub $0xc,%esp 1125e4: ff 73 0c pushl 0xc(%ebx) 1125e7: ff 53 08 call *0x8(%ebx)
_Workspace_Free( handler );
1125ea: 89 1c 24 mov %ebx,(%esp) 1125ed: e8 86 b7 ff ff call 10dd78 <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
1125f2: 83 c4 10 add $0x10,%esp 1125f5: 39 be e4 00 00 00 cmp %edi,0xe4(%esi)
1125fb: 75 cf jne 1125cc <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
1125fd: 8d 65 f4 lea -0xc(%ebp),%esp 112600: 5b pop %ebx 112601: 5e pop %esi 112602: 5f pop %edi 112603: c9 leave 112604: c3 ret
00110db8 <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
110db8: 55 push %ebp 110db9: 89 e5 mov %esp,%ebp 110dbb: 56 push %esi 110dbc: 53 push %ebx 110dbd: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
(void) _Watchdog_Remove( timer );
110dc0: 83 ec 0c sub $0xc,%esp 110dc3: 53 push %ebx 110dc4: e8 f3 d8 ff ff call 10e6bc <_Watchdog_Remove>
_ISR_Disable( level );
110dc9: 9c pushf 110dca: fa cli 110dcb: 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 ) {
110dcc: 83 c4 10 add $0x10,%esp 110dcf: 8b 43 08 mov 0x8(%ebx),%eax 110dd2: 85 c0 test %eax,%eax
110dd4: 74 0e je 110de4 <_POSIX_Timer_Insert_helper+0x2c>
_ISR_Enable( level );
110dd6: 56 push %esi 110dd7: 9d popf
return false;
110dd8: 31 c0 xor %eax,%eax
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
return true;
}
110dda: 8d 65 f8 lea -0x8(%ebp),%esp 110ddd: 5b pop %ebx 110dde: 5e pop %esi 110ddf: c9 leave 110de0: c3 ret 110de1: 8d 76 00 lea 0x0(%esi),%esi
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
110de4: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
the_watchdog->routine = routine;
110deb: 8b 45 14 mov 0x14(%ebp),%eax 110dee: 89 43 1c mov %eax,0x1c(%ebx)
the_watchdog->id = id;
110df1: 8b 45 10 mov 0x10(%ebp),%eax 110df4: 89 43 20 mov %eax,0x20(%ebx)
the_watchdog->user_data = user_data;
110df7: 8b 45 18 mov 0x18(%ebp),%eax 110dfa: 89 43 24 mov %eax,0x24(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
110dfd: 8b 45 0c mov 0xc(%ebp),%eax 110e00: 89 43 0c mov %eax,0xc(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
110e03: 83 ec 08 sub $0x8,%esp 110e06: 53 push %ebx 110e07: 68 60 9b 12 00 push $0x129b60 110e0c: e8 6b d7 ff ff call 10e57c <_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 );
110e11: 56 push %esi 110e12: 9d popf
return true;
110e13: 83 c4 10 add $0x10,%esp 110e16: b0 01 mov $0x1,%al
}
110e18: 8d 65 f8 lea -0x8(%ebp),%esp 110e1b: 5b pop %ebx 110e1c: 5e pop %esi 110e1d: c9 leave 110e1e: c3 ret
0010ad9c <_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)
{
10ad9c: 55 push %ebp 10ad9d: 89 e5 mov %esp,%ebp 10ad9f: 53 push %ebx 10ada0: 83 ec 04 sub $0x4,%esp 10ada3: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10ada6: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10ada9: 8b 53 54 mov 0x54(%ebx),%edx 10adac: 85 d2 test %edx,%edx
10adae: 75 28 jne 10add8 <_POSIX_Timer_TSR+0x3c>
10adb0: 8b 43 58 mov 0x58(%ebx),%eax 10adb3: 85 c0 test %eax,%eax
10adb5: 75 21 jne 10add8 <_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;
10adb7: 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 ) ) {
10adbb: 83 ec 08 sub $0x8,%esp 10adbe: ff 73 44 pushl 0x44(%ebx) 10adc1: ff 73 38 pushl 0x38(%ebx) 10adc4: e8 83 5b 00 00 call 11094c <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10adc9: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10add0: 83 c4 10 add $0x10,%esp
}
10add3: 8b 5d fc mov -0x4(%ebp),%ebx 10add6: c9 leave 10add7: 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(
10add8: 83 ec 0c sub $0xc,%esp 10addb: 53 push %ebx 10addc: 68 9c ad 10 00 push $0x10ad9c 10ade1: ff 73 08 pushl 0x8(%ebx) 10ade4: ff 73 64 pushl 0x64(%ebx) 10ade7: 8d 43 10 lea 0x10(%ebx),%eax 10adea: 50 push %eax 10adeb: e8 c8 5f 00 00 call 110db8 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10adf0: 83 c4 20 add $0x20,%esp 10adf3: 84 c0 test %al,%al
10adf5: 74 dc je 10add3 <_POSIX_Timer_TSR+0x37> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10adf7: 83 ec 0c sub $0xc,%esp 10adfa: 8d 43 6c lea 0x6c(%ebx),%eax 10adfd: 50 push %eax 10adfe: e8 a9 14 00 00 call 10c2ac <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10ae03: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10ae07: 83 c4 10 add $0x10,%esp 10ae0a: eb af jmp 10adbb <_POSIX_Timer_TSR+0x1f>
0011268c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
11268c: 55 push %ebp 11268d: 89 e5 mov %esp,%ebp 11268f: 57 push %edi 112690: 56 push %esi 112691: 53 push %ebx 112692: 83 ec 78 sub $0x78,%esp 112695: 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,
112698: 6a 01 push $0x1 11269a: 0f b6 45 10 movzbl 0x10(%ebp),%eax 11269e: 50 push %eax 11269f: 8d 55 dc lea -0x24(%ebp),%edx 1126a2: 52 push %edx 1126a3: 53 push %ebx 1126a4: ff 75 08 pushl 0x8(%ebp) 1126a7: 89 55 9c mov %edx,-0x64(%ebp) 1126aa: e8 b5 00 00 00 call 112764 <_POSIX_signals_Clear_signals> 1126af: 83 c4 20 add $0x20,%esp 1126b2: 84 c0 test %al,%al 1126b4: 8b 55 9c mov -0x64(%ebp),%edx
1126b7: 0f 84 9b 00 00 00 je 112758 <_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 )
1126bd: 8d 04 5b lea (%ebx,%ebx,2),%eax 1126c0: c1 e0 02 shl $0x2,%eax 1126c3: 8b 88 08 7e 12 00 mov 0x127e08(%eax),%ecx 1126c9: 89 4d a4 mov %ecx,-0x5c(%ebp) 1126cc: 49 dec %ecx
1126cd: 0f 84 85 00 00 00 je 112758 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
1126d3: 8b 75 08 mov 0x8(%ebp),%esi 1126d6: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi 1126dc: 89 75 a0 mov %esi,-0x60(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
1126df: 8b 88 04 7e 12 00 mov 0x127e04(%eax),%ecx 1126e5: 09 f1 or %esi,%ecx 1126e7: 8b 75 08 mov 0x8(%ebp),%esi 1126ea: 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,
1126f0: 8d 75 b4 lea -0x4c(%ebp),%esi 1126f3: 89 75 94 mov %esi,-0x6c(%ebp) 1126f6: 8b 35 98 7d 12 00 mov 0x127d98,%esi 1126fc: 83 c6 20 add $0x20,%esi 1126ff: b9 0a 00 00 00 mov $0xa,%ecx 112704: 8b 7d 94 mov -0x6c(%ebp),%edi 112707: 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 ) {
112709: 83 b8 00 7e 12 00 02 cmpl $0x2,0x127e00(%eax)
112710: 74 36 je 112748 <_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 );
112712: 83 ec 0c sub $0xc,%esp 112715: 53 push %ebx 112716: ff 55 a4 call *-0x5c(%ebp)
break;
112719: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
11271c: 8b 3d 98 7d 12 00 mov 0x127d98,%edi 112722: 83 c7 20 add $0x20,%edi 112725: b9 0a 00 00 00 mov $0xa,%ecx 11272a: 8b 75 94 mov -0x6c(%ebp),%esi 11272d: 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;
11272f: 8b 55 a0 mov -0x60(%ebp),%edx 112732: 8b 45 08 mov 0x8(%ebp),%eax 112735: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
return true;
11273b: b0 01 mov $0x1,%al
}
11273d: 8d 65 f4 lea -0xc(%ebp),%esp 112740: 5b pop %ebx 112741: 5e pop %esi 112742: 5f pop %edi 112743: c9 leave 112744: c3 ret 112745: 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)(
112748: 50 push %eax 112749: 6a 00 push $0x0 11274b: 52 push %edx 11274c: 53 push %ebx 11274d: ff 55 a4 call *-0x5c(%ebp)
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
112750: 83 c4 10 add $0x10,%esp 112753: eb c7 jmp 11271c <_POSIX_signals_Check_signal+0x90> 112755: 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;
112758: 31 c0 xor %eax,%eax
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
11275a: 8d 65 f4 lea -0xc(%ebp),%esp 11275d: 5b pop %ebx 11275e: 5e pop %esi 11275f: 5f pop %edi 112760: c9 leave 112761: c3 ret
00112e00 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
112e00: 55 push %ebp 112e01: 89 e5 mov %esp,%ebp 112e03: 53 push %ebx 112e04: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
112e07: 9c pushf 112e08: fa cli 112e09: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
112e0a: 8d 04 49 lea (%ecx,%ecx,2),%eax 112e0d: c1 e0 02 shl $0x2,%eax 112e10: 83 b8 00 7e 12 00 02 cmpl $0x2,0x127e00(%eax)
112e17: 74 13 je 112e2c <_POSIX_signals_Clear_process_signals+0x2c>
112e19: 49 dec %ecx 112e1a: 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;
112e1f: d3 c0 rol %cl,%eax 112e21: 21 05 08 80 12 00 and %eax,0x128008
}
_ISR_Enable( level );
112e27: 52 push %edx 112e28: 9d popf
}
112e29: 5b pop %ebx 112e2a: c9 leave 112e2b: 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 );
112e2c: 8d 98 24 80 12 00 lea 0x128024(%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 ] ) )
112e32: 39 98 20 80 12 00 cmp %ebx,0x128020(%eax)
112e38: 75 ed jne 112e27 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN
112e3a: eb dd jmp 112e19 <_POSIX_signals_Clear_process_signals+0x19>
00112764 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
112764: 55 push %ebp 112765: 89 e5 mov %esp,%ebp 112767: 57 push %edi 112768: 56 push %esi 112769: 53 push %ebx 11276a: 83 ec 1c sub $0x1c,%esp 11276d: 8b 5d 0c mov 0xc(%ebp),%ebx 112770: 0f b6 7d 14 movzbl 0x14(%ebp),%edi
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
112774: 8d 4b ff lea -0x1(%ebx),%ecx 112777: b8 01 00 00 00 mov $0x1,%eax 11277c: 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 )
11277e: 80 7d 18 00 cmpb $0x0,0x18(%ebp)
112782: 74 40 je 1127c4 <_POSIX_signals_Clear_signals+0x60>
signals_blocked = ~api->signals_blocked;
112784: 8b 55 08 mov 0x8(%ebp),%edx 112787: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx 11278d: 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 );
11278f: 9c pushf 112790: fa cli 112791: 8f 45 e4 popl -0x1c(%ebp)
if ( is_global ) {
112794: 89 fa mov %edi,%edx 112796: 84 d2 test %dl,%dl
112798: 74 32 je 1127cc <_POSIX_signals_Clear_signals+0x68>
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
11279a: 23 05 08 80 12 00 and 0x128008,%eax 1127a0: 85 c8 test %ecx,%eax
1127a2: 74 54 je 1127f8 <_POSIX_signals_Clear_signals+0x94>
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
1127a4: 8d 14 5b lea (%ebx,%ebx,2),%edx 1127a7: c1 e2 02 shl $0x2,%edx 1127aa: 83 ba 00 7e 12 00 02 cmpl $0x2,0x127e00(%edx)
1127b1: 74 49 je 1127fc <_POSIX_signals_Clear_signals+0x98>
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
1127b3: 83 ec 0c sub $0xc,%esp 1127b6: 53 push %ebx 1127b7: e8 44 06 00 00 call 112e00 <_POSIX_signals_Clear_process_signals> 1127bc: 83 c4 10 add $0x10,%esp
do_callout = true;
1127bf: b0 01 mov $0x1,%al 1127c1: eb 26 jmp 1127e9 <_POSIX_signals_Clear_signals+0x85> 1127c3: 90 nop
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
else
signals_blocked = SIGNAL_ALL_MASK;
1127c4: b9 ff ff ff ff mov $0xffffffff,%ecx 1127c9: eb c4 jmp 11278f <_POSIX_signals_Clear_signals+0x2b> 1127cb: 90 nop
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
1127cc: 8b 55 08 mov 0x8(%ebp),%edx 1127cf: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx 1127d5: 89 c6 mov %eax,%esi 1127d7: 21 de and %ebx,%esi 1127d9: 85 ce test %ecx,%esi
1127db: 74 1b je 1127f8 <_POSIX_signals_Clear_signals+0x94>
api->signals_pending &= ~mask;
1127dd: f7 d0 not %eax 1127df: 21 d8 and %ebx,%eax 1127e1: 89 82 d4 00 00 00 mov %eax,0xd4(%edx)
do_callout = true;
1127e7: b0 01 mov $0x1,%al
}
}
_ISR_Enable( level );
1127e9: ff 75 e4 pushl -0x1c(%ebp) 1127ec: 9d popf
return do_callout; }
1127ed: 8d 65 f4 lea -0xc(%ebp),%esp 1127f0: 5b pop %ebx 1127f1: 5e pop %esi 1127f2: 5f pop %edi 1127f3: c9 leave 1127f4: c3 ret 1127f5: 8d 76 00 lea 0x0(%esi),%esi
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
1127f8: 31 c0 xor %eax,%eax 1127fa: eb ed jmp 1127e9 <_POSIX_signals_Clear_signals+0x85>
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
1127fc: 8d 8a 20 80 12 00 lea 0x128020(%edx),%ecx 112802: 8b 82 20 80 12 00 mov 0x128020(%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 );
112808: 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))
11280b: 39 f0 cmp %esi,%eax
11280d: 74 45 je 112854 <_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;
11280f: 8b 30 mov (%eax),%esi
head->next = new_first;
112811: 89 b2 20 80 12 00 mov %esi,0x128020(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
112817: 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 );
11281a: 83 ec 0c sub $0xc,%esp 11281d: 53 push %ebx 11281e: 89 45 e0 mov %eax,-0x20(%ebp) 112821: e8 da 05 00 00 call 112e00 <_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;
112826: 8b 45 e0 mov -0x20(%ebp),%eax 112829: 8d 70 08 lea 0x8(%eax),%esi 11282c: b9 03 00 00 00 mov $0x3,%ecx 112831: 8b 7d 10 mov 0x10(%ebp),%edi 112834: 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;
112836: 8b 15 88 7f 12 00 mov 0x127f88,%edx
the_node->next = tail;
11283c: c7 00 84 7f 12 00 movl $0x127f84,(%eax)
tail->previous = the_node;
112842: a3 88 7f 12 00 mov %eax,0x127f88
old_last->next = the_node;
112847: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
112849: 89 50 04 mov %edx,0x4(%eax) 11284c: 83 c4 10 add $0x10,%esp 11284f: e9 5f ff ff ff jmp 1127b3 <_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 );
112854: 83 ec 0c sub $0xc,%esp 112857: 53 push %ebx 112858: e8 a3 05 00 00 call 112e00 <_POSIX_signals_Clear_process_signals> 11285d: 83 c4 10 add $0x10,%esp 112860: e9 4e ff ff ff jmp 1127b3 <_POSIX_signals_Clear_signals+0x4f>
0010b670 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10b670: 55 push %ebp 10b671: 89 e5 mov %esp,%ebp 10b673: 56 push %esi 10b674: 53 push %ebx 10b675: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10b678: b8 1b 00 00 00 mov $0x1b,%eax 10b67d: 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(
10b682: 8d 48 ff lea -0x1(%eax),%ecx 10b685: 89 de mov %ebx,%esi 10b687: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10b689: 85 d6 test %edx,%esi
10b68b: 75 20 jne 10b6ad <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10b68d: 40 inc %eax 10b68e: 83 f8 20 cmp $0x20,%eax
10b691: 75 ef jne 10b682 <_POSIX_signals_Get_lowest+0x12>
10b693: b0 01 mov $0x1,%al 10b695: bb 01 00 00 00 mov $0x1,%ebx 10b69a: eb 06 jmp 10b6a2 <_POSIX_signals_Get_lowest+0x32>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10b69c: 40 inc %eax 10b69d: 83 f8 1b cmp $0x1b,%eax
10b6a0: 74 0b je 10b6ad <_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(
10b6a2: 8d 48 ff lea -0x1(%eax),%ecx 10b6a5: 89 de mov %ebx,%esi 10b6a7: 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 ) ) {
10b6a9: 85 d6 test %edx,%esi
10b6ab: 74 ef je 10b69c <_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; }
10b6ad: 5b pop %ebx 10b6ae: 5e pop %esi 10b6af: c9 leave 10b6b0: c3 ret
001247cc <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
1247cc: 55 push %ebp 1247cd: 89 e5 mov %esp,%ebp 1247cf: 57 push %edi 1247d0: 56 push %esi 1247d1: 53 push %ebx 1247d2: 83 ec 0c sub $0xc,%esp 1247d5: 8b 5d 08 mov 0x8(%ebp),%ebx 1247d8: 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 ];
1247db: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi 1247e1: 8d 4a ff lea -0x1(%edx),%ecx 1247e4: b8 01 00 00 00 mov $0x1,%eax 1247e9: d3 e0 shl %cl,%eax
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
1247eb: 8b 4b 10 mov 0x10(%ebx),%ecx 1247ee: 89 cf mov %ecx,%edi 1247f0: 81 e7 00 80 00 10 and $0x10008000,%edi 1247f6: 81 ff 00 80 00 10 cmp $0x10008000,%edi
1247fc: 74 72 je 124870 <_POSIX_signals_Unblock_thread+0xa4>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1247fe: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx 124804: f7 d2 not %edx 124806: 85 d0 test %edx,%eax
124808: 74 5a je 124864 <_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 ) ) {
12480a: f7 c1 00 00 00 10 test $0x10000000,%ecx
124810: 74 3a je 12484c <_POSIX_signals_Unblock_thread+0x80>
the_thread->Wait.return_code = EINTR;
124812: 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) )
124819: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
12481f: 0f 85 93 00 00 00 jne 1248b8 <_POSIX_signals_Unblock_thread+0xec>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
124825: 83 e1 08 and $0x8,%ecx
124828: 74 3a je 124864 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
12482a: 83 ec 0c sub $0xc,%esp 12482d: 8d 43 48 lea 0x48(%ebx),%eax 124830: 50 push %eax 124831: e8 9e e4 fe ff call 112cd4 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
124836: 5a pop %edx 124837: 59 pop %ecx 124838: 68 f8 ff 03 10 push $0x1003fff8 12483d: 53 push %ebx 12483e: e8 79 d2 fe ff call 111abc <_Thread_Clear_state> 124843: 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;
124846: 31 c0 xor %eax,%eax 124848: eb 1c jmp 124866 <_POSIX_signals_Unblock_thread+0x9a> 12484a: 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 ) {
12484c: 85 c9 test %ecx,%ecx
12484e: 75 14 jne 124864 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124850: a1 34 dc 12 00 mov 0x12dc34,%eax 124855: 85 c0 test %eax,%eax
124857: 74 0b je 124864 <_POSIX_signals_Unblock_thread+0x98>
124859: 3b 1d 38 dc 12 00 cmp 0x12dc38,%ebx
12485f: 74 7b je 1248dc <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN
124861: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
}
return false;
124864: 31 c0 xor %eax,%eax
}
124866: 8d 65 f4 lea -0xc(%ebp),%esp 124869: 5b pop %ebx 12486a: 5e pop %esi 12486b: 5f pop %edi 12486c: c9 leave 12486d: c3 ret 12486e: 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) ) {
124870: 85 43 30 test %eax,0x30(%ebx)
124873: 74 33 je 1248a8 <_POSIX_signals_Unblock_thread+0xdc>
the_thread->Wait.return_code = EINTR;
124875: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
12487c: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
12487f: 8b 75 10 mov 0x10(%ebp),%esi 124882: 85 f6 test %esi,%esi
124884: 74 42 je 1248c8 <_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;
124886: b9 03 00 00 00 mov $0x3,%ecx 12488b: 89 c7 mov %eax,%edi 12488d: 8b 75 10 mov 0x10(%ebp),%esi 124890: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
124892: 83 ec 0c sub $0xc,%esp 124895: 53 push %ebx 124896: e8 3d dc fe ff call 1124d8 <_Thread_queue_Extract_with_proxy>
return true;
12489b: 83 c4 10 add $0x10,%esp 12489e: b0 01 mov $0x1,%al
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
1248a0: 8d 65 f4 lea -0xc(%ebp),%esp 1248a3: 5b pop %ebx 1248a4: 5e pop %esi 1248a5: 5f pop %edi 1248a6: c9 leave 1248a7: 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) ) {
1248a8: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx 1248ae: f7 d1 not %ecx 1248b0: 85 c8 test %ecx,%eax
1248b2: 75 c1 jne 124875 <_POSIX_signals_Unblock_thread+0xa9>
1248b4: eb ae jmp 124864 <_POSIX_signals_Unblock_thread+0x98> 1248b6: 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 );
1248b8: 83 ec 0c sub $0xc,%esp 1248bb: 53 push %ebx 1248bc: e8 17 dc fe ff call 1124d8 <_Thread_queue_Extract_with_proxy> 1248c1: 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;
1248c4: 31 c0 xor %eax,%eax 1248c6: eb 9e jmp 124866 <_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;
1248c8: 89 10 mov %edx,(%eax)
the_info->si_code = SI_USER;
1248ca: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
1248d1: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 1248d8: eb b8 jmp 124892 <_POSIX_signals_Unblock_thread+0xc6> 1248da: 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;
1248dc: c6 05 44 dc 12 00 01 movb $0x1,0x12dc44
}
}
return false;
1248e3: 31 c0 xor %eax,%eax 1248e5: e9 7c ff ff ff jmp 124866 <_POSIX_signals_Unblock_thread+0x9a>
0010cba0 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10cba0: 55 push %ebp 10cba1: 89 e5 mov %esp,%ebp 10cba3: 56 push %esi 10cba4: 53 push %ebx 10cba5: 8b 5d 08 mov 0x8(%ebp),%ebx 10cba8: 8b 75 0c mov 0xc(%ebp),%esi
if ( !the_heap )
10cbab: 85 db test %ebx,%ebx
10cbad: 74 35 je 10cbe4 <_Protected_heap_Get_information+0x44>
return false;
if ( !the_info )
10cbaf: 85 f6 test %esi,%esi
10cbb1: 74 31 je 10cbe4 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
10cbb3: 83 ec 0c sub $0xc,%esp 10cbb6: ff 35 20 82 12 00 pushl 0x128220 10cbbc: e8 87 ef ff ff call 10bb48 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
10cbc1: 5a pop %edx 10cbc2: 59 pop %ecx 10cbc3: 56 push %esi 10cbc4: 53 push %ebx 10cbc5: e8 42 4f 00 00 call 111b0c <_Heap_Get_information>
_RTEMS_Unlock_allocator();
10cbca: 58 pop %eax 10cbcb: ff 35 20 82 12 00 pushl 0x128220 10cbd1: e8 ba ef ff ff call 10bb90 <_API_Mutex_Unlock>
return true;
10cbd6: 83 c4 10 add $0x10,%esp 10cbd9: b0 01 mov $0x1,%al
}
10cbdb: 8d 65 f8 lea -0x8(%ebp),%esp 10cbde: 5b pop %ebx 10cbdf: 5e pop %esi 10cbe0: c9 leave 10cbe1: c3 ret 10cbe2: 66 90 xchg %ax,%ax
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
10cbe4: 31 c0 xor %eax,%eax
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
10cbe6: 8d 65 f8 lea -0x8(%ebp),%esp 10cbe9: 5b pop %ebx 10cbea: 5e pop %esi 10cbeb: c9 leave 10cbec: c3 ret
00110048 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
110048: 55 push %ebp 110049: 89 e5 mov %esp,%ebp 11004b: 56 push %esi 11004c: 53 push %ebx 11004d: 83 ec 10 sub $0x10,%esp 110050: 8b 5d 08 mov 0x8(%ebp),%ebx 110053: 8b 75 0c mov 0xc(%ebp),%esi 110056: 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 ) {
110059: 8b 15 0c de 12 00 mov 0x12de0c,%edx 11005f: 85 d2 test %edx,%edx
110061: 74 19 je 11007c <_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 );
110063: 0f b6 c0 movzbl %al,%eax 110066: 89 45 10 mov %eax,0x10(%ebp) 110069: 89 75 0c mov %esi,0xc(%ebp) 11006c: 89 5d 08 mov %ebx,0x8(%ebp)
} return status; }
11006f: 8d 65 f8 lea -0x8(%ebp),%esp 110072: 5b pop %ebx 110073: 5e pop %esi 110074: 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 );
110075: e9 22 f2 ff ff jmp 10f29c <_Heap_Walk> 11007a: 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();
11007c: 83 ec 0c sub $0xc,%esp 11007f: ff 35 c0 de 12 00 pushl 0x12dec0 110085: 88 45 f4 mov %al,-0xc(%ebp) 110088: e8 d3 e4 ff ff call 10e560 <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
11008d: 83 c4 0c add $0xc,%esp 110090: 8a 45 f4 mov -0xc(%ebp),%al 110093: 0f b6 c0 movzbl %al,%eax 110096: 50 push %eax 110097: 56 push %esi 110098: 53 push %ebx 110099: e8 fe f1 ff ff call 10f29c <_Heap_Walk>
_RTEMS_Unlock_allocator();
11009e: 5a pop %edx 11009f: ff 35 c0 de 12 00 pushl 0x12dec0 1100a5: 88 45 f4 mov %al,-0xc(%ebp) 1100a8: e8 fb e4 ff ff call 10e5a8 <_API_Mutex_Unlock> 1100ad: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
1100b0: 8a 45 f4 mov -0xc(%ebp),%al 1100b3: 8d 65 f8 lea -0x8(%ebp),%esp 1100b6: 5b pop %ebx 1100b7: 5e pop %esi 1100b8: c9 leave 1100b9: c3 ret
001106f8 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
1106f8: 55 push %ebp 1106f9: 89 e5 mov %esp,%ebp 1106fb: 53 push %ebx 1106fc: 83 ec 10 sub $0x10,%esp 1106ff: 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 );
110702: 80 3d 24 35 12 00 01 cmpb $0x1,0x123524 110709: 19 c0 sbb %eax,%eax 11070b: 83 e0 c0 and $0xffffffc0,%eax 11070e: 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 );
110711: 50 push %eax 110712: e8 45 d6 ff ff call 10dd5c <_Workspace_Allocate>
if ( !api )
110717: 83 c4 10 add $0x10,%esp 11071a: 85 c0 test %eax,%eax
11071c: 74 6a je 110788 <_RTEMS_tasks_Create_extension+0x90>
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
11071e: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
110724: c7 00 00 00 00 00 movl $0x0,(%eax)
api->event_condition = 0;
11072a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = false;
110731: c6 40 08 00 movb $0x0,0x8(%eax)
information->handler = NULL;
110735: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
information->mode_set = RTEMS_DEFAULT_MODES;
11073c: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
information->signals_posted = 0;
110743: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
information->signals_pending = 0;
11074a: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
information->nest_level = 0;
110751: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal ); created->task_variables = NULL;
110758: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
11075f: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
110762: 80 3d 24 35 12 00 00 cmpb $0x0,0x123524
110769: 74 13 je 11077e <_RTEMS_tasks_Create_extension+0x86>
11076b: 31 d2 xor %edx,%edx 11076d: 8d 76 00 lea 0x0(%esi),%esi
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
110770: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4)
110777: 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++)
110778: 42 inc %edx 110779: 83 fa 10 cmp $0x10,%edx
11077c: 75 f2 jne 110770 <_RTEMS_tasks_Create_extension+0x78>
api->Notepads[i] = 0;
}
return true;
11077e: b0 01 mov $0x1,%al
}
110780: 8b 5d fc mov -0x4(%ebp),%ebx 110783: c9 leave 110784: c3 ret 110785: 8d 76 00 lea 0x0(%esi),%esi
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
110788: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
11078a: 8b 5d fc mov -0x4(%ebp),%ebx 11078d: c9 leave 11078e: c3 ret
001106a0 <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
1106a0: 55 push %ebp 1106a1: 89 e5 mov %esp,%ebp 1106a3: 56 push %esi 1106a4: 53 push %ebx 1106a5: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
1106a8: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
deleted->task_variables = NULL;
1106ae: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi)
1106b5: 00 00 00
while (tvp) {
1106b8: 85 c0 test %eax,%eax
1106ba: 75 06 jne 1106c2 <_RTEMS_tasks_Delete_extension+0x22>
1106bc: eb 17 jmp 1106d5 <_RTEMS_tasks_Delete_extension+0x35> 1106be: 66 90 xchg %ax,%ax
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
1106c0: 89 d8 mov %ebx,%eax
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
1106c2: 8b 18 mov (%eax),%ebx
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
1106c4: 83 ec 08 sub $0x8,%esp 1106c7: 50 push %eax 1106c8: 56 push %esi 1106c9: e8 56 01 00 00 call 110824 <_RTEMS_Tasks_Invoke_task_variable_dtor>
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
1106ce: 83 c4 10 add $0x10,%esp 1106d1: 85 db test %ebx,%ebx
1106d3: 75 eb jne 1106c0 <_RTEMS_tasks_Delete_extension+0x20>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
1106d5: 83 ec 0c sub $0xc,%esp 1106d8: ff b6 e8 00 00 00 pushl 0xe8(%esi) 1106de: e8 95 d6 ff ff call 10dd78 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
1106e3: c7 86 e8 00 00 00 00 movl $0x0,0xe8(%esi)
1106ea: 00 00 00
1106ed: 83 c4 10 add $0x10,%esp
}
1106f0: 8d 65 f8 lea -0x8(%ebp),%esp 1106f3: 5b pop %ebx 1106f4: 5e pop %esi 1106f5: c9 leave 1106f6: c3 ret
00110624 <_RTEMS_tasks_Initialize_user_tasks>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
110624: 55 push %ebp 110625: 89 e5 mov %esp,%ebp 110627: 83 ec 08 sub $0x8,%esp
if ( _RTEMS_tasks_Initialize_user_tasks_p )
11062a: a1 a0 35 12 00 mov 0x1235a0,%eax 11062f: 85 c0 test %eax,%eax
110631: 74 05 je 110638 <_RTEMS_tasks_Initialize_user_tasks+0x14>
(*_RTEMS_tasks_Initialize_user_tasks_p)();
}
110633: c9 leave
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
if ( _RTEMS_tasks_Initialize_user_tasks_p )
(*_RTEMS_tasks_Initialize_user_tasks_p)();
110634: ff e0 jmp *%eax 110636: 66 90 xchg %ax,%ax
}
110638: c9 leave 110639: c3 ret
0010af78 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10af78: 55 push %ebp 10af79: 89 e5 mov %esp,%ebp 10af7b: 57 push %edi 10af7c: 56 push %esi 10af7d: 53 push %ebx 10af7e: 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;
10af81: 8b 1d 4c 35 12 00 mov 0x12354c,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10af87: 8b 3d 48 35 12 00 mov 0x123548,%edi
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
10af8d: 85 db test %ebx,%ebx
10af8f: 74 46 je 10afd7 <_RTEMS_tasks_Initialize_user_tasks_body+0x5f>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10af91: 85 ff test %edi,%edi
10af93: 74 42 je 10afd7 <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN
10af95: 31 f6 xor %esi,%esi 10af97: 90 nop
return_value = rtems_task_create(
10af98: 83 ec 08 sub $0x8,%esp 10af9b: 8d 45 e4 lea -0x1c(%ebp),%eax 10af9e: 50 push %eax 10af9f: ff 73 0c pushl 0xc(%ebx) 10afa2: ff 73 14 pushl 0x14(%ebx) 10afa5: ff 73 04 pushl 0x4(%ebx) 10afa8: ff 73 08 pushl 0x8(%ebx) 10afab: ff 33 pushl (%ebx) 10afad: e8 92 fd ff ff call 10ad44 <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 ) )
10afb2: 83 c4 20 add $0x20,%esp 10afb5: 85 c0 test %eax,%eax
10afb7: 75 26 jne 10afdf <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
10afb9: 51 push %ecx 10afba: ff 73 18 pushl 0x18(%ebx) 10afbd: ff 73 10 pushl 0x10(%ebx) 10afc0: ff 75 e4 pushl -0x1c(%ebp) 10afc3: e8 24 00 00 00 call 10afec <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10afc8: 83 c4 10 add $0x10,%esp 10afcb: 85 c0 test %eax,%eax
10afcd: 75 10 jne 10afdf <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10afcf: 46 inc %esi 10afd0: 83 c3 1c add $0x1c,%ebx 10afd3: 39 f7 cmp %esi,%edi
10afd5: 77 c1 ja 10af98 <_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 );
}
}
10afd7: 8d 65 f4 lea -0xc(%ebp),%esp 10afda: 5b pop %ebx 10afdb: 5e pop %esi 10afdc: 5f pop %edi 10afdd: c9 leave 10afde: 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 );
10afdf: 52 push %edx 10afe0: 50 push %eax 10afe1: 6a 01 push $0x1 10afe3: 6a 01 push $0x1 10afe5: e8 ca 0c 00 00 call 10bcb4 <_Internal_error_Occurred>
001105dc <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
1105dc: 55 push %ebp 1105dd: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
1105df: 8b 45 08 mov 0x8(%ebp),%eax 1105e2: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
1105e8: 85 c0 test %eax,%eax
1105ea: 74 13 je 1105ff <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
1105ec: 8b 50 04 mov 0x4(%eax),%edx 1105ef: 8b 0a mov (%edx),%ecx 1105f1: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
1105f4: 8b 48 08 mov 0x8(%eax),%ecx 1105f7: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
1105f9: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
1105fb: 85 c0 test %eax,%eax
1105fd: 75 ed jne 1105ec <_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;
1105ff: 8b 45 0c mov 0xc(%ebp),%eax 110602: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110608: 85 c0 test %eax,%eax
11060a: 74 13 je 11061f <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
11060c: 8b 50 04 mov 0x4(%eax),%edx 11060f: 8b 0a mov (%edx),%ecx 110611: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
110614: 8b 48 0c mov 0xc(%eax),%ecx 110617: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110619: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
11061b: 85 c0 test %eax,%eax
11061d: 75 ed jne 11060c <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
11061f: c9 leave 110620: c3 ret
0010b9d8 <_Rate_monotonic_Initiate_statistics>:
}
void _Rate_monotonic_Initiate_statistics(
Rate_monotonic_Control *the_period
)
{
10b9d8: 55 push %ebp 10b9d9: 89 e5 mov %esp,%ebp 10b9db: 57 push %edi 10b9dc: 56 push %esi 10b9dd: 53 push %ebx 10b9de: 83 ec 28 sub $0x28,%esp 10b9e1: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *owning_thread = the_period->owner;
10b9e4: 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 );
10b9e7: 8d 7d e0 lea -0x20(%ebp),%edi 10b9ea: 57 push %edi 10b9eb: e8 60 17 00 00 call 10d150 <_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;
10b9f0: 8b 45 e0 mov -0x20(%ebp),%eax 10b9f3: 8b 55 e4 mov -0x1c(%ebp),%edx 10b9f6: 89 43 4c mov %eax,0x4c(%ebx) 10b9f9: 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;
10b9fc: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10ba02: 8b 96 88 00 00 00 mov 0x88(%esi),%edx 10ba08: 89 43 44 mov %eax,0x44(%ebx) 10ba0b: 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) {
10ba0e: 83 c4 10 add $0x10,%esp 10ba11: 39 35 18 b1 12 00 cmp %esi,0x12b118
10ba17: 74 0b je 10ba24 <_Rate_monotonic_Initiate_statistics+0x4c>
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
}
#endif
}
10ba19: 8d 65 f4 lea -0xc(%ebp),%esp 10ba1c: 5b pop %ebx 10ba1d: 5e pop %esi 10ba1e: 5f pop %edi 10ba1f: c9 leave 10ba20: c3 ret 10ba21: 8d 76 00 lea 0x0(%esi),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10ba24: 50 push %eax
&_Thread_Time_of_last_context_switch, &uptime, &ran
10ba25: 8d 75 d8 lea -0x28(%ebp),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10ba28: 56 push %esi 10ba29: 57 push %edi 10ba2a: 68 2c ac 12 00 push $0x12ac2c 10ba2f: e8 8c 38 00 00 call 10f2c0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
10ba34: 59 pop %ecx 10ba35: 5f pop %edi 10ba36: 56 push %esi 10ba37: 83 c3 44 add $0x44,%ebx 10ba3a: 53 push %ebx 10ba3b: e8 84 37 00 00 call 10f1c4 <_Timespec_Add_to> 10ba40: 83 c4 10 add $0x10,%esp
}
#endif
}
10ba43: 8d 65 f4 lea -0xc(%ebp),%esp 10ba46: 5b pop %ebx 10ba47: 5e pop %esi 10ba48: 5f pop %edi 10ba49: c9 leave 10ba4a: c3 ret
0010bf94 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10bf94: 55 push %ebp 10bf95: 89 e5 mov %esp,%ebp 10bf97: 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 );
10bf9a: 8d 45 f4 lea -0xc(%ebp),%eax 10bf9d: 50 push %eax 10bf9e: ff 75 08 pushl 0x8(%ebp) 10bfa1: 68 80 aa 12 00 push $0x12aa80 10bfa6: e8 39 1c 00 00 call 10dbe4 <_Objects_Get>
switch ( location ) {
10bfab: 83 c4 10 add $0x10,%esp 10bfae: 8b 55 f4 mov -0xc(%ebp),%edx 10bfb1: 85 d2 test %edx,%edx
10bfb3: 75 29 jne 10bfde <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10bfb5: 8b 50 40 mov 0x40(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10bfb8: f6 42 11 40 testb $0x40,0x11(%edx)
10bfbc: 74 08 je 10bfc6 <_Rate_monotonic_Timeout+0x32>
10bfbe: 8b 48 08 mov 0x8(%eax),%ecx 10bfc1: 39 4a 20 cmp %ecx,0x20(%edx)
10bfc4: 74 4e je 10c014 <_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 ) {
10bfc6: 83 78 38 01 cmpl $0x1,0x38(%eax)
10bfca: 74 14 je 10bfe0 <_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;
10bfcc: 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;
10bfd3: a1 6c ab 12 00 mov 0x12ab6c,%eax 10bfd8: 48 dec %eax 10bfd9: a3 6c ab 12 00 mov %eax,0x12ab6c
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10bfde: c9 leave 10bfdf: 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;
10bfe0: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax)
_Rate_monotonic_Initiate_statistics( the_period );
10bfe7: 83 ec 0c sub $0xc,%esp 10bfea: 50 push %eax 10bfeb: 89 45 e4 mov %eax,-0x1c(%ebp) 10bfee: e8 e5 f9 ff ff call 10b9d8 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10bff3: 8b 45 e4 mov -0x1c(%ebp),%eax 10bff6: 8b 50 3c mov 0x3c(%eax),%edx 10bff9: 89 50 1c mov %edx,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10bffc: 5a pop %edx 10bffd: 59 pop %ecx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10bffe: 83 c0 10 add $0x10,%eax 10c001: 50 push %eax 10c002: 68 40 ac 12 00 push $0x12ac40 10c007: e8 94 35 00 00 call 10f5a0 <_Watchdog_Insert> 10c00c: 83 c4 10 add $0x10,%esp 10c00f: eb c2 jmp 10bfd3 <_Rate_monotonic_Timeout+0x3f> 10c011: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10c014: 83 ec 08 sub $0x8,%esp 10c017: 68 f8 ff 03 10 push $0x1003fff8 10c01c: 52 push %edx 10c01d: 89 45 e4 mov %eax,-0x1c(%ebp) 10c020: e8 e3 23 00 00 call 10e408 <_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 );
10c025: 8b 45 e4 mov -0x1c(%ebp),%eax 10c028: 89 04 24 mov %eax,(%esp) 10c02b: eb c1 jmp 10bfee <_Rate_monotonic_Timeout+0x5a>
0010ba4c <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
10ba4c: 55 push %ebp 10ba4d: 89 e5 mov %esp,%ebp 10ba4f: 57 push %edi 10ba50: 56 push %esi 10ba51: 53 push %ebx 10ba52: 83 ec 1c sub $0x1c,%esp 10ba55: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
10ba58: ff 43 54 incl 0x54(%ebx)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
10ba5b: 83 7b 38 04 cmpl $0x4,0x38(%ebx)
10ba5f: 0f 84 bf 00 00 00 je 10bb24 <_Rate_monotonic_Update_statistics+0xd8>
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10ba65: 51 push %ecx
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10ba66: 8d 7d e0 lea -0x20(%ebp),%edi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10ba69: 57 push %edi
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10ba6a: 8d 75 d8 lea -0x28(%ebp),%esi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10ba6d: 56 push %esi 10ba6e: 53 push %ebx 10ba6f: e8 cc fe ff ff call 10b940 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
10ba74: 83 c4 10 add $0x10,%esp 10ba77: 84 c0 test %al,%al
10ba79: 75 09 jne 10ba84 <_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
}
10ba7b: 8d 65 f4 lea -0xc(%ebp),%esp 10ba7e: 5b pop %ebx 10ba7f: 5e pop %esi 10ba80: 5f pop %edi 10ba81: c9 leave 10ba82: c3 ret 10ba83: 90 nop
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
10ba84: 83 ec 08 sub $0x8,%esp 10ba87: 57 push %edi 10ba88: 8d 43 6c lea 0x6c(%ebx),%eax 10ba8b: 50 push %eax 10ba8c: e8 33 37 00 00 call 10f1c4 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
10ba91: 58 pop %eax 10ba92: 5a pop %edx 10ba93: 8d 43 5c lea 0x5c(%ebx),%eax 10ba96: 50 push %eax 10ba97: 57 push %edi 10ba98: e8 ff 37 00 00 call 10f29c <_Timespec_Less_than> 10ba9d: 83 c4 10 add $0x10,%esp 10baa0: 84 c0 test %al,%al
10baa2: 74 0c je 10bab0 <_Rate_monotonic_Update_statistics+0x64>
stats->min_cpu_time = executed;
10baa4: 8b 45 e0 mov -0x20(%ebp),%eax 10baa7: 8b 55 e4 mov -0x1c(%ebp),%edx 10baaa: 89 43 5c mov %eax,0x5c(%ebx) 10baad: 89 53 60 mov %edx,0x60(%ebx)
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
10bab0: 83 ec 08 sub $0x8,%esp 10bab3: 8d 43 64 lea 0x64(%ebx),%eax 10bab6: 50 push %eax 10bab7: 57 push %edi 10bab8: e8 bb 37 00 00 call 10f278 <_Timespec_Greater_than> 10babd: 83 c4 10 add $0x10,%esp 10bac0: 84 c0 test %al,%al
10bac2: 74 0c je 10bad0 <_Rate_monotonic_Update_statistics+0x84>
stats->max_cpu_time = executed;
10bac4: 8b 45 e0 mov -0x20(%ebp),%eax 10bac7: 8b 55 e4 mov -0x1c(%ebp),%edx 10baca: 89 43 64 mov %eax,0x64(%ebx) 10bacd: 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 );
10bad0: 83 ec 08 sub $0x8,%esp 10bad3: 56 push %esi 10bad4: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10bada: 50 push %eax 10badb: e8 e4 36 00 00 call 10f1c4 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
10bae0: 5a pop %edx 10bae1: 59 pop %ecx 10bae2: 8d 43 74 lea 0x74(%ebx),%eax 10bae5: 50 push %eax 10bae6: 56 push %esi 10bae7: e8 b0 37 00 00 call 10f29c <_Timespec_Less_than> 10baec: 83 c4 10 add $0x10,%esp 10baef: 84 c0 test %al,%al
10baf1: 75 39 jne 10bb2c <_Rate_monotonic_Update_statistics+0xe0>
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
10baf3: 83 ec 08 sub $0x8,%esp 10baf6: 8d 43 7c lea 0x7c(%ebx),%eax 10baf9: 50 push %eax 10bafa: 56 push %esi 10bafb: e8 78 37 00 00 call 10f278 <_Timespec_Greater_than> 10bb00: 83 c4 10 add $0x10,%esp 10bb03: 84 c0 test %al,%al
10bb05: 0f 84 70 ff ff ff je 10ba7b <_Rate_monotonic_Update_statistics+0x2f>
stats->max_wall_time = since_last_period;
10bb0b: 8b 45 d8 mov -0x28(%ebp),%eax 10bb0e: 8b 55 dc mov -0x24(%ebp),%edx 10bb11: 89 43 7c mov %eax,0x7c(%ebx) 10bb14: 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
}
10bb1a: 8d 65 f4 lea -0xc(%ebp),%esp 10bb1d: 5b pop %ebx 10bb1e: 5e pop %esi 10bb1f: 5f pop %edi 10bb20: c9 leave 10bb21: c3 ret 10bb22: 66 90 xchg %ax,%ax
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
10bb24: ff 43 58 incl 0x58(%ebx) 10bb27: e9 39 ff ff ff jmp 10ba65 <_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;
10bb2c: 8b 45 d8 mov -0x28(%ebp),%eax 10bb2f: 8b 55 dc mov -0x24(%ebp),%edx 10bb32: 89 43 74 mov %eax,0x74(%ebx) 10bb35: 89 53 78 mov %edx,0x78(%ebx) 10bb38: eb b9 jmp 10baf3 <_Rate_monotonic_Update_statistics+0xa7>
0010c55c <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10c55c: 55 push %ebp 10c55d: 89 e5 mov %esp,%ebp 10c55f: 53 push %ebx 10c560: 8b 45 08 mov 0x8(%ebp),%eax
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
10c563: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
ready = sched_info->ready_chain;
10c569: 8b 11 mov (%ecx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
10c56b: 8b 5a 08 mov 0x8(%edx),%ebx 10c56e: 39 1a cmp %ebx,(%edx)
10c570: 74 6e je 10c5e0 <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10c572: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10c574: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10c577: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10c57a: 89 0a mov %ecx,(%edx)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10c57c: 3b 05 9c 7d 12 00 cmp 0x127d9c,%eax
10c582: 74 18 je 10c59c <_Scheduler_priority_Block+0x40>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10c584: 3b 05 98 7d 12 00 cmp 0x127d98,%eax
10c58a: 74 04 je 10c590 <_Scheduler_priority_Block+0x34>
_Thread_Dispatch_necessary = true;
}
10c58c: 5b pop %ebx 10c58d: c9 leave 10c58e: c3 ret 10c58f: 90 nop
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
10c590: c6 05 a4 7d 12 00 01 movb $0x1,0x127da4
}
10c597: 5b pop %ebx 10c598: c9 leave 10c599: c3 ret 10c59a: 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 );
10c59c: 66 8b 1d c0 7d 12 00 mov 0x127dc0,%bx 10c5a3: 31 d2 xor %edx,%edx 10c5a5: 89 d1 mov %edx,%ecx 10c5a7: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10c5ab: 0f b7 c9 movzwl %cx,%ecx 10c5ae: 66 8b 9c 09 e0 7d 12 mov 0x127de0(%ecx,%ecx,1),%bx
10c5b5: 00
10c5b6: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10c5ba: c1 e1 04 shl $0x4,%ecx 10c5bd: 0f b7 d2 movzwl %dx,%edx 10c5c0: 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 ] ) )
10c5c3: 8d 14 52 lea (%edx,%edx,2),%edx 10c5c6: c1 e2 02 shl $0x2,%edx 10c5c9: 03 15 60 34 12 00 add 0x123460,%edx 10c5cf: 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 );
10c5d1: 83 c2 04 add $0x4,%edx 10c5d4: 39 d1 cmp %edx,%ecx
10c5d6: 74 44 je 10c61c <_Scheduler_priority_Block+0xc0><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10c5d8: 89 0d 9c 7d 12 00 mov %ecx,0x127d9c 10c5de: eb a4 jmp 10c584 <_Scheduler_priority_Block+0x28>
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 );
10c5e0: 8d 5a 04 lea 0x4(%edx),%ebx 10c5e3: 89 1a mov %ebx,(%edx)
head->next = tail;
head->previous = NULL;
10c5e5: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
10c5ec: 89 52 08 mov %edx,0x8(%edx)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
10c5ef: 8b 59 04 mov 0x4(%ecx),%ebx 10c5f2: 66 8b 13 mov (%ebx),%dx 10c5f5: 66 23 51 0e and 0xe(%ecx),%dx 10c5f9: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
10c5fc: 66 85 d2 test %dx,%dx
10c5ff: 0f 85 77 ff ff ff jne 10c57c <_Scheduler_priority_Block+0x20>
_Priority_Major_bit_map &= the_priority_map->block_major;
10c605: 66 8b 15 c0 7d 12 00 mov 0x127dc0,%dx 10c60c: 23 51 0c and 0xc(%ecx),%edx 10c60f: 66 89 15 c0 7d 12 00 mov %dx,0x127dc0 10c616: e9 61 ff ff ff jmp 10c57c <_Scheduler_priority_Block+0x20> 10c61b: 90 nop
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;
10c61c: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c61e: eb b8 jmp 10c5d8 <_Scheduler_priority_Block+0x7c><== NOT EXECUTED
0010c770 <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10c770: 55 push %ebp 10c771: 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 );
10c773: 66 8b 0d c0 7d 12 00 mov 0x127dc0,%cx 10c77a: 31 c0 xor %eax,%eax 10c77c: 89 c2 mov %eax,%edx 10c77e: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10c782: 0f b7 d2 movzwl %dx,%edx 10c785: 66 8b 8c 12 e0 7d 12 mov 0x127de0(%edx,%edx,1),%cx
10c78c: 00
10c78d: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10c791: c1 e2 04 shl $0x4,%edx 10c794: 0f b7 c0 movzwl %ax,%eax 10c797: 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 ] ) )
10c79a: 8d 04 40 lea (%eax,%eax,2),%eax 10c79d: c1 e0 02 shl $0x2,%eax 10c7a0: 03 05 60 34 12 00 add 0x123460,%eax
_Scheduler_priority_Schedule_body(); }
10c7a6: 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 );
10c7a8: 83 c0 04 add $0x4,%eax 10c7ab: 39 c2 cmp %eax,%edx
10c7ad: 74 09 je 10c7b8 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10c7af: 89 15 9c 7d 12 00 mov %edx,0x127d9c 10c7b5: c9 leave 10c7b6: c3 ret 10c7b7: 90 nop
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;
10c7b8: 31 d2 xor %edx,%edx <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10c7ba: 89 15 9c 7d 12 00 mov %edx,0x127d9c <== NOT EXECUTED 10c7c0: c9 leave <== NOT EXECUTED 10c7c1: c3 ret <== NOT EXECUTED
0010c894 <_Scheduler_priority_Yield>:
* ready chain
* select heir
*/
void _Scheduler_priority_Yield(void)
{
10c894: 55 push %ebp 10c895: 89 e5 mov %esp,%ebp 10c897: 56 push %esi 10c898: 53 push %ebx
Scheduler_priority_Per_thread *sched_info;
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10c899: a1 98 7d 12 00 mov 0x127d98,%eax
sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info; ready = sched_info->ready_chain;
10c89e: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10c8a4: 8b 12 mov (%edx),%edx
_ISR_Disable( level );
10c8a6: 9c pushf 10c8a7: fa cli 10c8a8: 59 pop %ecx
if ( !_Chain_Has_only_one_node( ready ) ) {
10c8a9: 8b 5a 08 mov 0x8(%edx),%ebx 10c8ac: 39 1a cmp %ebx,(%edx)
10c8ae: 74 40 je 10c8f0 <_Scheduler_priority_Yield+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10c8b0: 8b 30 mov (%eax),%esi
previous = the_node->previous;
10c8b2: 8b 58 04 mov 0x4(%eax),%ebx
next->previous = previous;
10c8b5: 89 5e 04 mov %ebx,0x4(%esi)
previous->next = next;
10c8b8: 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;
10c8ba: 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 );
10c8bd: 8d 72 04 lea 0x4(%edx),%esi 10c8c0: 89 30 mov %esi,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10c8c2: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10c8c5: 89 03 mov %eax,(%ebx)
the_node->previous = old_last;
10c8c7: 89 58 04 mov %ebx,0x4(%eax)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10c8ca: 51 push %ecx 10c8cb: 9d popf 10c8cc: fa cli
if ( _Thread_Is_heir( executing ) )
10c8cd: 3b 05 9c 7d 12 00 cmp 0x127d9c,%eax
10c8d3: 74 0f je 10c8e4 <_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;
10c8d5: c6 05 a4 7d 12 00 01 movb $0x1,0x127da4
_ISR_Enable( level );
10c8dc: 51 push %ecx 10c8dd: 9d popf
}
10c8de: 5b pop %ebx 10c8df: 5e pop %esi 10c8e0: c9 leave 10c8e1: c3 ret 10c8e2: 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 );
10c8e4: 8b 02 mov (%edx),%eax 10c8e6: a3 9c 7d 12 00 mov %eax,0x127d9c 10c8eb: eb e8 jmp 10c8d5 <_Scheduler_priority_Yield+0x41> 10c8ed: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
10c8f0: 3b 05 9c 7d 12 00 cmp 0x127d9c,%eax
10c8f6: 75 dd jne 10c8d5 <_Scheduler_priority_Yield+0x41>
10c8f8: eb e2 jmp 10c8dc <_Scheduler_priority_Yield+0x48>
0010cb28 <_Scheduler_simple_Ready_queue_Enqueue>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_Enqueue(
Thread_Control *the_thread
)
{
10cb28: 55 push %ebp 10cb29: 89 e5 mov %esp,%ebp 10cb2b: 56 push %esi 10cb2c: 53 push %ebx 10cb2d: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
10cb30: 8b 15 a0 3e 12 00 mov 0x123ea0,%edx
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cb36: 8b 02 mov (%edx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10cb38: 8d 4a 04 lea 0x4(%edx),%ecx
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
10cb3b: 39 c8 cmp %ecx,%eax
10cb3d: 74 1a je 10cb59 <_Scheduler_simple_Ready_queue_Enqueue+0x31>
current = (Thread_Control *) the_node;
10cb3f: 89 c2 mov %eax,%edx
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
10cb41: 8b 5e 14 mov 0x14(%esi),%ebx 10cb44: 3b 58 14 cmp 0x14(%eax),%ebx
10cb47: 73 0a jae 10cb53 <_Scheduler_simple_Ready_queue_Enqueue+0x2b>
10cb49: eb 21 jmp 10cb6c <_Scheduler_simple_Ready_queue_Enqueue+0x44> 10cb4b: 90 nop
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
10cb4c: 89 c2 mov %eax,%edx
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
10cb4e: 39 58 14 cmp %ebx,0x14(%eax)
10cb51: 77 19 ja 10cb6c <_Scheduler_simple_Ready_queue_Enqueue+0x44>
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
10cb53: 8b 00 mov (%eax),%eax 10cb55: 39 c8 cmp %ecx,%eax
10cb57: 75 f3 jne 10cb4c <_Scheduler_simple_Ready_queue_Enqueue+0x24>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10cb59: 89 56 04 mov %edx,0x4(%esi)
before_node = after_node->next;
10cb5c: 8b 02 mov (%edx),%eax
after_node->next = the_node;
10cb5e: 89 32 mov %esi,(%edx)
the_node->next = before_node;
10cb60: 89 06 mov %eax,(%esi)
before_node->previous = the_node;
10cb62: 89 70 04 mov %esi,0x4(%eax)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cb65: 5b pop %ebx 10cb66: 5e pop %esi 10cb67: c9 leave 10cb68: c3 ret 10cb69: 8d 76 00 lea 0x0(%esi),%esi
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
current = (Thread_Control *)current->Object.Node.previous;
10cb6c: 8b 50 04 mov 0x4(%eax),%edx
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10cb6f: 89 56 04 mov %edx,0x4(%esi)
before_node = after_node->next;
10cb72: 8b 02 mov (%edx),%eax
after_node->next = the_node;
10cb74: 89 32 mov %esi,(%edx)
the_node->next = before_node;
10cb76: 89 06 mov %eax,(%esi)
before_node->previous = the_node;
10cb78: 89 70 04 mov %esi,0x4(%eax)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cb7b: 5b pop %ebx 10cb7c: 5e pop %esi 10cb7d: c9 leave 10cb7e: c3 ret
0010caf8 <_Scheduler_simple_Ready_queue_Enqueue_first>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_Enqueue_first(
Thread_Control *the_thread
)
{
10caf8: 55 push %ebp 10caf9: 89 e5 mov %esp,%ebp 10cafb: 8b 4d 08 mov 0x8(%ebp),%ecx
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cafe: a1 a0 3e 12 00 mov 0x123ea0,%eax 10cb03: 8b 00 mov (%eax),%eax
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
10cb05: 8b 51 14 mov 0x14(%ecx),%edx 10cb08: 3b 50 14 cmp 0x14(%eax),%edx
10cb0b: 76 0a jbe 10cb17 <_Scheduler_simple_Ready_queue_Enqueue_first+0x1f>
10cb0d: 8d 76 00 lea 0x0(%esi),%esi
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
10cb10: 8b 00 mov (%eax),%eax
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
10cb12: 39 50 14 cmp %edx,0x14(%eax)
10cb15: 72 f9 jb 10cb10 <_Scheduler_simple_Ready_queue_Enqueue_first+0x18><== NEVER TAKEN
current = (Thread_Control *)current->Object.Node.previous;
10cb17: 8b 40 04 mov 0x4(%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10cb1a: 89 41 04 mov %eax,0x4(%ecx)
before_node = after_node->next;
10cb1d: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10cb1f: 89 08 mov %ecx,(%eax)
the_node->next = before_node;
10cb21: 89 11 mov %edx,(%ecx)
before_node->previous = the_node;
10cb23: 89 4a 04 mov %ecx,0x4(%edx)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cb26: c9 leave 10cb27: c3 ret
0010cec0 <_TOD_Set>:
*/
void _TOD_Set(
const struct timespec *time
)
{
10cec0: 55 push %ebp 10cec1: 89 e5 mov %esp,%ebp 10cec3: 53 push %ebx 10cec4: 83 ec 04 sub $0x4,%esp 10cec7: 8b 5d 08 mov 0x8(%ebp),%ebx 10ceca: a1 6c b3 12 00 mov 0x12b36c,%eax 10cecf: 40 inc %eax 10ced0: a3 6c b3 12 00 mov %eax,0x12b36c
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10ced5: a1 08 b4 12 00 mov 0x12b408,%eax
if ( time->tv_sec < seconds )
10ceda: 8b 13 mov (%ebx),%edx 10cedc: 39 d0 cmp %edx,%eax
10cede: 7f 34 jg 10cf14 <_TOD_Set+0x54>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
10cee0: 51 push %ecx
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
10cee1: 29 c2 sub %eax,%edx 10cee3: 52 push %edx 10cee4: 6a 00 push $0x0 10cee6: 68 34 b4 12 00 push $0x12b434 10ceeb: e8 30 24 00 00 call 10f320 <_Watchdog_Adjust> 10cef0: 83 c4 10 add $0x10,%esp
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
10cef3: 8b 03 mov (%ebx),%eax 10cef5: a3 08 b4 12 00 mov %eax,0x12b408 10cefa: 8b 43 04 mov 0x4(%ebx),%eax 10cefd: a3 0c b4 12 00 mov %eax,0x12b40c
_TOD_Is_set = true;
10cf02: c6 05 7c b3 12 00 01 movb $0x1,0x12b37c
_TOD_Activate();
_Thread_Enable_dispatch();
}
10cf09: 8b 5d fc mov -0x4(%ebp),%ebx 10cf0c: c9 leave
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
10cf0d: e9 9a 15 00 00 jmp 10e4ac <_Thread_Enable_dispatch> 10cf12: 66 90 xchg %ax,%ax 10cf14: 51 push %ecx
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
if ( time->tv_sec < seconds )
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
10cf15: 29 d0 sub %edx,%eax 10cf17: 50 push %eax 10cf18: 6a 01 push $0x1 10cf1a: 68 34 b4 12 00 push $0x12b434 10cf1f: e8 fc 23 00 00 call 10f320 <_Watchdog_Adjust> 10cf24: 83 c4 10 add $0x10,%esp 10cf27: eb ca jmp 10cef3 <_TOD_Set+0x33>
0010b7b4 <_TOD_To_seconds>:
*/
uint32_t _TOD_To_seconds(
const rtems_time_of_day *the_tod
)
{
10b7b4: 55 push %ebp 10b7b5: 89 e5 mov %esp,%ebp 10b7b7: 56 push %esi 10b7b8: 53 push %ebx 10b7b9: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
10b7bc: 8b 72 08 mov 0x8(%edx),%esi 10b7bf: 4e dec %esi
year_mod_4 = the_tod->year & 3;
10b7c0: 8b 02 mov (%edx),%eax
if ( year_mod_4 == 0 )
10b7c2: 89 c3 mov %eax,%ebx 10b7c4: 83 e3 03 and $0x3,%ebx
10b7c7: 74 67 je 10b830 <_TOD_To_seconds+0x7c>
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
10b7c9: 8b 4a 04 mov 0x4(%edx),%ecx 10b7cc: 0f b7 8c 09 00 3d 12 movzwl 0x123d00(%ecx,%ecx,1),%ecx
10b7d3: 00
10b7d4: 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 ];
10b7d7: 0f b7 8c 1b 34 3d 12 movzwl 0x123d34(%ebx,%ebx,1),%ecx
10b7de: 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 ) *
10b7df: 2d c4 07 00 00 sub $0x7c4,%eax 10b7e4: c1 e8 02 shr $0x2,%eax 10b7e7: 8d 1c c0 lea (%eax,%eax,8),%ebx 10b7ea: 8d 1c d8 lea (%eax,%ebx,8),%ebx 10b7ed: 8d 1c 9b lea (%ebx,%ebx,4),%ebx 10b7f0: 8d 04 98 lea (%eax,%ebx,4),%eax 10b7f3: 01 c1 add %eax,%ecx
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10b7f5: 01 f1 add %esi,%ecx
time *= TOD_SECONDS_PER_DAY;
10b7f7: 8d 04 89 lea (%ecx,%ecx,4),%eax 10b7fa: 8d 04 81 lea (%ecx,%eax,4),%eax 10b7fd: 8d 04 c1 lea (%ecx,%eax,8),%eax 10b800: c1 e0 02 shl $0x2,%eax 10b803: 29 c8 sub %ecx,%eax 10b805: c1 e0 07 shl $0x7,%eax
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
10b808: 8b 5a 14 mov 0x14(%edx),%ebx 10b80b: 8b 4a 0c mov 0xc(%edx),%ecx 10b80e: 8d 0c 49 lea (%ecx,%ecx,2),%ecx 10b811: 8d 0c 89 lea (%ecx,%ecx,4),%ecx 10b814: c1 e1 02 shl $0x2,%ecx 10b817: 03 4a 10 add 0x10(%edx),%ecx
* TOD_SECONDS_PER_MINUTE;
10b81a: 8d 14 49 lea (%ecx,%ecx,2),%edx 10b81d: 8d 14 92 lea (%edx,%edx,4),%edx
time += the_tod->second;
10b820: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx
time += TOD_SECONDS_1970_THROUGH_1988;
10b827: 8d 04 02 lea (%edx,%eax,1),%eax
return( time );
}
10b82a: 5b pop %ebx 10b82b: 5e pop %esi 10b82c: c9 leave 10b82d: c3 ret 10b82e: 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 ];
10b830: 8b 4a 04 mov 0x4(%edx),%ecx 10b833: 0f b7 8c 09 1a 3d 12 movzwl 0x123d1a(%ecx,%ecx,1),%ecx
10b83a: 00
10b83b: 8d 34 31 lea (%ecx,%esi,1),%esi 10b83e: eb 97 jmp 10b7d7 <_TOD_To_seconds+0x23>
0010b840 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10b840: 55 push %ebp 10b841: 89 e5 mov %esp,%ebp 10b843: 53 push %ebx 10b844: 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();
10b847: 8b 1d 6c 6c 12 00 mov 0x126c6c,%ebx
if ((!the_tod) ||
10b84d: 85 c9 test %ecx,%ecx
10b84f: 74 53 je 10b8a4 <_TOD_Validate+0x64> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10b851: b8 40 42 0f 00 mov $0xf4240,%eax 10b856: 31 d2 xor %edx,%edx 10b858: f7 f3 div %ebx
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
10b85a: 3b 41 18 cmp 0x18(%ecx),%eax
10b85d: 76 45 jbe 10b8a4 <_TOD_Validate+0x64>
(the_tod->ticks >= ticks_per_second) ||
10b85f: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10b863: 77 3f ja 10b8a4 <_TOD_Validate+0x64>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10b865: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10b869: 77 39 ja 10b8a4 <_TOD_Validate+0x64>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10b86b: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10b86f: 77 33 ja 10b8a4 <_TOD_Validate+0x64>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10b871: 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) ||
10b874: 85 c0 test %eax,%eax
10b876: 74 2c je 10b8a4 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->month == 0) ||
10b878: 83 f8 0c cmp $0xc,%eax
10b87b: 77 27 ja 10b8a4 <_TOD_Validate+0x64>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10b87d: 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) ||
10b87f: 81 fa c3 07 00 00 cmp $0x7c3,%edx
10b885: 76 1d jbe 10b8a4 <_TOD_Validate+0x64>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10b887: 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) ||
10b88a: 85 c9 test %ecx,%ecx
10b88c: 74 16 je 10b8a4 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10b88e: 83 e2 03 and $0x3,%edx
10b891: 75 16 jne 10b8a9 <_TOD_Validate+0x69>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10b893: 8b 04 85 74 3d 12 00 mov 0x123d74(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10b89a: 39 c8 cmp %ecx,%eax 10b89c: 0f 93 c0 setae %al 10b89f: eb 05 jmp 10b8a6 <_TOD_Validate+0x66> 10b8a1: 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;
10b8a4: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10b8a6: 5b pop %ebx 10b8a7: c9 leave 10b8a8: 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 ];
10b8a9: 8b 04 85 40 3d 12 00 mov 0x123d40(,%eax,4),%eax 10b8b0: eb e8 jmp 10b89a <_TOD_Validate+0x5a>
0010c948 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10c948: 55 push %ebp 10c949: 89 e5 mov %esp,%ebp 10c94b: 57 push %edi 10c94c: 56 push %esi 10c94d: 53 push %ebx 10c94e: 83 ec 28 sub $0x28,%esp 10c951: 8b 5d 08 mov 0x8(%ebp),%ebx 10c954: 8b 75 0c mov 0xc(%ebp),%esi 10c957: 8a 45 10 mov 0x10(%ebp),%al 10c95a: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10c95d: 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 );
10c960: 53 push %ebx 10c961: e8 7a 0c 00 00 call 10d5e0 <_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 )
10c966: 83 c4 10 add $0x10,%esp 10c969: 39 73 14 cmp %esi,0x14(%ebx)
10c96c: 74 0d je 10c97b <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10c96e: 83 ec 08 sub $0x8,%esp 10c971: 56 push %esi 10c972: 53 push %ebx 10c973: e8 14 0c 00 00 call 10d58c <_Thread_Set_priority> 10c978: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10c97b: 9c pushf 10c97c: fa cli 10c97d: 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;
10c97e: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10c981: 83 f8 04 cmp $0x4,%eax
10c984: 74 22 je 10c9a8 <_Thread_Change_priority+0x60>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10c986: 83 e7 04 and $0x4,%edi
10c989: 74 11 je 10c99c <_Thread_Change_priority+0x54><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10c98b: 56 push %esi 10c98c: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10c98d: a9 e0 be 03 00 test $0x3bee0,%eax
10c992: 75 60 jne 10c9f4 <_Thread_Change_priority+0xac>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10c994: 8d 65 f4 lea -0xc(%ebp),%esp 10c997: 5b pop %ebx 10c998: 5e pop %esi 10c999: 5f pop %edi 10c99a: c9 leave 10c99b: c3 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10c99c: 89 c2 mov %eax,%edx 10c99e: 83 e2 fb and $0xfffffffb,%edx 10c9a1: 89 53 10 mov %edx,0x10(%ebx) 10c9a4: eb e5 jmp 10c98b <_Thread_Change_priority+0x43> 10c9a6: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10c9a8: 83 e7 04 and $0x4,%edi
10c9ab: 75 1a jne 10c9c7 <_Thread_Change_priority+0x7f><== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10c9ad: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10c9b4: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10c9b8: 74 52 je 10ca0c <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10c9ba: 83 ec 0c sub $0xc,%esp 10c9bd: 53 push %ebx 10c9be: ff 15 88 34 12 00 call *0x123488 10c9c4: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10c9c7: 56 push %esi 10c9c8: 9d popf 10c9c9: fa cli
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
10c9ca: ff 15 68 34 12 00 call *0x123468
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10c9d0: a1 98 7d 12 00 mov 0x127d98,%eax
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
10c9d5: 3b 05 9c 7d 12 00 cmp 0x127d9c,%eax
10c9db: 74 0d je 10c9ea <_Thread_Change_priority+0xa2>
10c9dd: 80 78 74 00 cmpb $0x0,0x74(%eax)
10c9e1: 74 07 je 10c9ea <_Thread_Change_priority+0xa2>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10c9e3: c6 05 a4 7d 12 00 01 movb $0x1,0x127da4
_ISR_Enable( level );
10c9ea: 56 push %esi 10c9eb: 9d popf
}
10c9ec: 8d 65 f4 lea -0xc(%ebp),%esp 10c9ef: 5b pop %ebx 10c9f0: 5e pop %esi 10c9f1: 5f pop %edi 10c9f2: c9 leave 10c9f3: c3 ret
/* 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 );
10c9f4: 89 5d 0c mov %ebx,0xc(%ebp) 10c9f7: 8b 43 44 mov 0x44(%ebx),%eax 10c9fa: 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 );
}
10c9fd: 8d 65 f4 lea -0xc(%ebp),%esp 10ca00: 5b pop %ebx 10ca01: 5e pop %esi 10ca02: 5f pop %edi 10ca03: 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 );
10ca04: e9 eb 0a 00 00 jmp 10d4f4 <_Thread_queue_Requeue> 10ca09: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10ca0c: 83 ec 0c sub $0xc,%esp 10ca0f: 53 push %ebx 10ca10: ff 15 84 34 12 00 call *0x123484 10ca16: 83 c4 10 add $0x10,%esp 10ca19: eb ac jmp 10c9c7 <_Thread_Change_priority+0x7f>
0010ca1c <_Thread_Clear_state>:
*/
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10ca1c: 55 push %ebp 10ca1d: 89 e5 mov %esp,%ebp 10ca1f: 53 push %ebx 10ca20: 83 ec 04 sub $0x4,%esp 10ca23: 8b 55 08 mov 0x8(%ebp),%edx 10ca26: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10ca29: 9c pushf 10ca2a: fa cli 10ca2b: 5b pop %ebx
current_state = the_thread->current_state;
10ca2c: 8b 4a 10 mov 0x10(%edx),%ecx
if ( current_state & state ) {
10ca2f: 85 c8 test %ecx,%eax
10ca31: 74 0b je 10ca3e <_Thread_Clear_state+0x22>
10ca33: f7 d0 not %eax 10ca35: 21 c8 and %ecx,%eax
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10ca37: 89 42 10 mov %eax,0x10(%edx)
if ( _States_Is_ready( current_state ) ) {
10ca3a: 85 c0 test %eax,%eax
10ca3c: 74 0a je 10ca48 <_Thread_Clear_state+0x2c>
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10ca3e: 53 push %ebx 10ca3f: 9d popf
}
10ca40: 8b 5d fc mov -0x4(%ebp),%ebx 10ca43: c9 leave 10ca44: c3 ret 10ca45: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10ca48: 83 ec 0c sub $0xc,%esp 10ca4b: 52 push %edx 10ca4c: ff 15 74 34 12 00 call *0x123474 10ca52: 83 c4 10 add $0x10,%esp 10ca55: eb e7 jmp 10ca3e <_Thread_Clear_state+0x22>
0010cbcc <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10cbcc: 55 push %ebp 10cbcd: 89 e5 mov %esp,%ebp 10cbcf: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cbd2: 8d 45 f4 lea -0xc(%ebp),%eax 10cbd5: 50 push %eax 10cbd6: ff 75 08 pushl 0x8(%ebp) 10cbd9: e8 c6 01 00 00 call 10cda4 <_Thread_Get>
switch ( location ) {
10cbde: 83 c4 10 add $0x10,%esp 10cbe1: 8b 55 f4 mov -0xc(%ebp),%edx 10cbe4: 85 d2 test %edx,%edx
10cbe6: 75 1c jne 10cc04 <_Thread_Delay_ended+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10cbe8: 83 ec 08 sub $0x8,%esp 10cbeb: 68 18 00 00 10 push $0x10000018 10cbf0: 50 push %eax 10cbf1: e8 26 fe ff ff call 10ca1c <_Thread_Clear_state> 10cbf6: a1 ec 77 12 00 mov 0x1277ec,%eax 10cbfb: 48 dec %eax 10cbfc: a3 ec 77 12 00 mov %eax,0x1277ec 10cc01: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10cc04: c9 leave 10cc05: c3 ret
0010cc08 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10cc08: 55 push %ebp 10cc09: 89 e5 mov %esp,%ebp 10cc0b: 57 push %edi 10cc0c: 56 push %esi 10cc0d: 53 push %ebx 10cc0e: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10cc11: 8b 1d 98 7d 12 00 mov 0x127d98,%ebx
_ISR_Disable( level );
10cc17: 9c pushf 10cc18: fa cli 10cc19: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10cc1a: 8a 15 a4 7d 12 00 mov 0x127da4,%dl 10cc20: 84 d2 test %dl,%dl
10cc22: 0f 84 3c 01 00 00 je 10cd64 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10cc28: 8b 35 9c 7d 12 00 mov 0x127d9c,%esi
_Thread_Dispatch_disable_level = 1;
10cc2e: c7 05 ec 77 12 00 01 movl $0x1,0x1277ec
10cc35: 00 00 00
_Thread_Dispatch_necessary = false;
10cc38: c6 05 a4 7d 12 00 00 movb $0x0,0x127da4
_Thread_Executing = heir;
10cc3f: 89 35 98 7d 12 00 mov %esi,0x127d98
/*
* 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 )
10cc45: 39 f3 cmp %esi,%ebx
10cc47: 0f 84 17 01 00 00 je 10cd64 <_Thread_Dispatch+0x15c>
10cc4d: 8d 7d d8 lea -0x28(%ebp),%edi 10cc50: e9 f5 00 00 00 jmp 10cd4a <_Thread_Dispatch+0x142> 10cc55: 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 );
10cc58: 50 push %eax 10cc59: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10cc5a: 83 ec 0c sub $0xc,%esp 10cc5d: 8d 45 e0 lea -0x20(%ebp),%eax 10cc60: 50 push %eax 10cc61: e8 7e 41 00 00 call 110de4 <_TOD_Get_uptime>
_Timestamp_Subtract(
10cc66: 83 c4 0c add $0xc,%esp 10cc69: 57 push %edi 10cc6a: 8d 45 e0 lea -0x20(%ebp),%eax 10cc6d: 50 push %eax 10cc6e: 68 ac 78 12 00 push $0x1278ac 10cc73: e8 9c 0b 00 00 call 10d814 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10cc78: 58 pop %eax 10cc79: 5a pop %edx 10cc7a: 57 push %edi 10cc7b: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10cc81: 50 push %eax 10cc82: e8 51 0b 00 00 call 10d7d8 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10cc87: 8b 45 e0 mov -0x20(%ebp),%eax 10cc8a: 8b 55 e4 mov -0x1c(%ebp),%edx 10cc8d: a3 ac 78 12 00 mov %eax,0x1278ac 10cc92: 89 15 b0 78 12 00 mov %edx,0x1278b0
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10cc98: a1 84 78 12 00 mov 0x127884,%eax 10cc9d: 83 c4 10 add $0x10,%esp 10cca0: 85 c0 test %eax,%eax
10cca2: 74 10 je 10ccb4 <_Thread_Dispatch+0xac> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10cca4: 8b 10 mov (%eax),%edx 10cca6: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10ccac: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10ccb2: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10ccb4: 83 ec 08 sub $0x8,%esp 10ccb7: 56 push %esi 10ccb8: 53 push %ebx 10ccb9: e8 f6 0d 00 00 call 10dab4 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10ccbe: 5a pop %edx 10ccbf: 59 pop %ecx 10ccc0: 81 c6 c8 00 00 00 add $0xc8,%esi 10ccc6: 56 push %esi 10ccc7: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10cccd: 50 push %eax 10ccce: e8 ed 10 00 00 call 10ddc0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10ccd3: 83 c4 10 add $0x10,%esp 10ccd6: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10ccdc: 85 c0 test %eax,%eax
10ccde: 74 36 je 10cd16 <_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 );
10cce0: a1 80 78 12 00 mov 0x127880,%eax 10cce5: 39 c3 cmp %eax,%ebx
10cce7: 74 2d je 10cd16 <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10cce9: 85 c0 test %eax,%eax
10cceb: 74 11 je 10ccfe <_Thread_Dispatch+0xf6>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10cced: 83 ec 0c sub $0xc,%esp 10ccf0: 05 e0 00 00 00 add $0xe0,%eax 10ccf5: 50 push %eax 10ccf6: e8 f9 10 00 00 call 10ddf4 <_CPU_Context_save_fp> 10ccfb: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10ccfe: 83 ec 0c sub $0xc,%esp 10cd01: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10cd07: 50 push %eax 10cd08: e8 f1 10 00 00 call 10ddfe <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10cd0d: 89 1d 80 78 12 00 mov %ebx,0x127880 10cd13: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10cd16: 8b 1d 98 7d 12 00 mov 0x127d98,%ebx
_ISR_Disable( level );
10cd1c: 9c pushf 10cd1d: fa cli 10cd1e: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10cd1f: 8a 15 a4 7d 12 00 mov 0x127da4,%dl 10cd25: 84 d2 test %dl,%dl
10cd27: 74 3b je 10cd64 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10cd29: 8b 35 9c 7d 12 00 mov 0x127d9c,%esi
_Thread_Dispatch_disable_level = 1;
10cd2f: c7 05 ec 77 12 00 01 movl $0x1,0x1277ec
10cd36: 00 00 00
_Thread_Dispatch_necessary = false;
10cd39: c6 05 a4 7d 12 00 00 movb $0x0,0x127da4
_Thread_Executing = heir;
10cd40: 89 35 98 7d 12 00 mov %esi,0x127d98
/*
* 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 )
10cd46: 39 de cmp %ebx,%esi
10cd48: 74 1a je 10cd64 <_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 )
10cd4a: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10cd4e: 0f 85 04 ff ff ff jne 10cc58 <_Thread_Dispatch+0x50>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10cd54: 8b 15 c0 77 12 00 mov 0x1277c0,%edx 10cd5a: 89 56 78 mov %edx,0x78(%esi) 10cd5d: e9 f6 fe ff ff jmp 10cc58 <_Thread_Dispatch+0x50> 10cd62: 66 90 xchg %ax,%ax
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10cd64: c7 05 ec 77 12 00 00 movl $0x0,0x1277ec
10cd6b: 00 00 00
_ISR_Enable( level );
10cd6e: 50 push %eax 10cd6f: 9d popf
_API_extensions_Run_postswitch();
10cd70: e8 4b e6 ff ff call 10b3c0 <_API_extensions_Run_postswitch>
}
10cd75: 8d 65 f4 lea -0xc(%ebp),%esp 10cd78: 5b pop %ebx 10cd79: 5e pop %esi 10cd7a: 5f pop %edi 10cd7b: c9 leave 10cd7c: c3 ret
0010cda4 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10cda4: 55 push %ebp 10cda5: 89 e5 mov %esp,%ebp 10cda7: 53 push %ebx 10cda8: 83 ec 04 sub $0x4,%esp 10cdab: 8b 45 08 mov 0x8(%ebp),%eax 10cdae: 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 ) ) {
10cdb1: 85 c0 test %eax,%eax
10cdb3: 74 4b je 10ce00 <_Thread_Get+0x5c>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10cdb5: 89 c2 mov %eax,%edx 10cdb7: c1 ea 18 shr $0x18,%edx 10cdba: 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 )
10cdbd: 8d 5a ff lea -0x1(%edx),%ebx 10cdc0: 83 fb 02 cmp $0x2,%ebx
10cdc3: 77 2b ja 10cdf0 <_Thread_Get+0x4c>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10cdc5: 89 c3 mov %eax,%ebx 10cdc7: 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 :) */
10cdca: 4b dec %ebx
10cdcb: 75 23 jne 10cdf0 <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10cdcd: 8b 14 95 c4 77 12 00 mov 0x1277c4(,%edx,4),%edx
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
10cdd4: 85 d2 test %edx,%edx
10cdd6: 74 18 je 10cdf0 <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
10cdd8: 8b 52 04 mov 0x4(%edx),%edx
if ( !information ) {
10cddb: 85 d2 test %edx,%edx
10cddd: 74 11 je 10cdf0 <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10cddf: 53 push %ebx 10cde0: 51 push %ecx 10cde1: 50 push %eax 10cde2: 52 push %edx 10cde3: e8 10 f4 ff ff call 10c1f8 <_Objects_Get> 10cde8: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10cdeb: 8b 5d fc mov -0x4(%ebp),%ebx 10cdee: c9 leave 10cdef: c3 ret
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10cdf0: 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;
10cdf6: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10cdf8: 8b 5d fc mov -0x4(%ebp),%ebx 10cdfb: c9 leave 10cdfc: c3 ret 10cdfd: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10ce00: a1 ec 77 12 00 mov 0x1277ec,%eax 10ce05: 40 inc %eax 10ce06: a3 ec 77 12 00 mov %eax,0x1277ec
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;
10ce0b: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10ce11: a1 98 7d 12 00 mov 0x127d98,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10ce16: 8b 5d fc mov -0x4(%ebp),%ebx 10ce19: c9 leave 10ce1a: c3 ret
00112c8c <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
112c8c: 55 push %ebp 112c8d: 89 e5 mov %esp,%ebp 112c8f: 53 push %ebx 112c90: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
112c93: 8b 1d 98 7d 12 00 mov 0x127d98,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
112c99: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
112c9f: 85 c0 test %eax,%eax
112ca1: 74 79 je 112d1c <_Thread_Handler+0x90>
112ca3: fa cli
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
112ca4: a0 54 74 12 00 mov 0x127454,%al 112ca9: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
112cac: c6 05 54 74 12 00 01 movb $0x1,0x127454
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
112cb3: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 112cb9: 85 c0 test %eax,%eax
112cbb: 74 24 je 112ce1 <_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 );
112cbd: a1 80 78 12 00 mov 0x127880,%eax 112cc2: 39 c3 cmp %eax,%ebx
112cc4: 74 1b je 112ce1 <_Thread_Handler+0x55>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
112cc6: 85 c0 test %eax,%eax
112cc8: 74 11 je 112cdb <_Thread_Handler+0x4f>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
112cca: 83 ec 0c sub $0xc,%esp 112ccd: 05 e0 00 00 00 add $0xe0,%eax 112cd2: 50 push %eax 112cd3: e8 1c b1 ff ff call 10ddf4 <_CPU_Context_save_fp> 112cd8: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
112cdb: 89 1d 80 78 12 00 mov %ebx,0x127880
/* * 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 );
112ce1: 83 ec 0c sub $0xc,%esp 112ce4: 53 push %ebx 112ce5: e8 2e ac ff ff call 10d918 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
112cea: e8 91 a0 ff ff call 10cd80 <_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) */ {
112cef: 83 c4 10 add $0x10,%esp 112cf2: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
112cf6: 74 28 je 112d20 <_Thread_Handler+0x94>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
112cf8: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 112cfe: 85 c0 test %eax,%eax
112d00: 74 2d je 112d2f <_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 ) {
112d02: 48 dec %eax
112d03: 74 43 je 112d48 <_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 );
112d05: 83 ec 0c sub $0xc,%esp 112d08: 53 push %ebx 112d09: e8 46 ac ff ff call 10d954 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
112d0e: 83 c4 0c add $0xc,%esp 112d11: 6a 05 push $0x5 112d13: 6a 01 push $0x1 112d15: 6a 00 push $0x0 112d17: e8 98 8f ff ff call 10bcb4 <_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);
112d1c: fb sti 112d1d: eb 85 jmp 112ca4 <_Thread_Handler+0x18> 112d1f: 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 ();
112d20: e8 4b c7 00 00 call 11f470 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
112d25: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 112d2b: 85 c0 test %eax,%eax
112d2d: 75 d3 jne 112d02 <_Thread_Handler+0x76>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
112d2f: 83 ec 0c sub $0xc,%esp 112d32: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 112d38: ff 93 90 00 00 00 call *0x90(%ebx)
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
112d3e: 89 43 28 mov %eax,0x28(%ebx) 112d41: 83 c4 10 add $0x10,%esp 112d44: eb bf jmp 112d05 <_Thread_Handler+0x79> 112d46: 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)(
112d48: 83 ec 0c sub $0xc,%esp 112d4b: ff b3 98 00 00 00 pushl 0x98(%ebx) 112d51: 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 =
112d57: 89 43 28 mov %eax,0x28(%ebx) 112d5a: 83 c4 10 add $0x10,%esp 112d5d: eb a6 jmp 112d05 <_Thread_Handler+0x79>
0010ce1c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10ce1c: 55 push %ebp 10ce1d: 89 e5 mov %esp,%ebp 10ce1f: 57 push %edi 10ce20: 56 push %esi 10ce21: 53 push %ebx 10ce22: 83 ec 1c sub $0x1c,%esp 10ce25: 8b 5d 0c mov 0xc(%ebp),%ebx 10ce28: 8b 4d 10 mov 0x10(%ebp),%ecx 10ce2b: 8b 75 14 mov 0x14(%ebp),%esi 10ce2e: 8b 7d 1c mov 0x1c(%ebp),%edi 10ce31: 8a 55 18 mov 0x18(%ebp),%dl 10ce34: 8a 45 20 mov 0x20(%ebp),%al 10ce37: 88 45 df mov %al,-0x21(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10ce3a: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10ce41: 00 00 00
10ce44: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10ce4b: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10ce4e: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10ce55: 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 ) {
10ce58: 85 c9 test %ecx,%ecx
10ce5a: 0f 84 d3 01 00 00 je 10d033 <_Thread_Initialize+0x217>
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;
10ce60: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10ce67: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10ce69: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10ce6f: 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 ) {
10ce75: 84 d2 test %dl,%dl
10ce77: 0f 85 4f 01 00 00 jne 10cfcc <_Thread_Initialize+0x1b0>
10ce7d: 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;
10ce7f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%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;
10ce86: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10ce8c: 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;
10ce92: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10ce99: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10cea0: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10cea7: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10ceae: a1 90 78 12 00 mov 0x127890,%eax 10ceb3: 85 c0 test %eax,%eax
10ceb5: 0f 85 39 01 00 00 jne 10cff4 <_Thread_Initialize+0x1d8>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10cebb: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10cec2: 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;
10cec5: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10cec7: 8a 45 df mov -0x21(%ebp),%al 10ceca: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10ced0: 8b 45 24 mov 0x24(%ebp),%eax 10ced3: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10ced9: 8b 45 28 mov 0x28(%ebp),%eax 10cedc: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10cee2: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10cee6: 75 08 jne 10cef0 <_Thread_Initialize+0xd4>
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;
10cee8: a1 c0 77 12 00 mov 0x1277c0,%eax 10ceed: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10cef0: 8b 45 2c mov 0x2c(%ebp),%eax 10cef3: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10cef9: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10cf00: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10cf07: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10cf0e: 89 7b 18 mov %edi,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10cf11: 89 bb b0 00 00 00 mov %edi,0xb0(%ebx)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
10cf17: 83 ec 0c sub $0xc,%esp 10cf1a: 53 push %ebx 10cf1b: ff 15 78 34 12 00 call *0x123478 10cf21: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Allocate( the_thread ); if ( !sched )
10cf24: 83 c4 10 add $0x10,%esp 10cf27: 85 c0 test %eax,%eax
10cf29: 74 40 je 10cf6b <_Thread_Initialize+0x14f>
goto failed;
_Thread_Set_priority( the_thread, priority );
10cf2b: 83 ec 08 sub $0x8,%esp 10cf2e: 57 push %edi 10cf2f: 53 push %ebx 10cf30: e8 57 06 00 00 call 10d58c <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10cf35: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10cf3c: 00 00 00
10cf3f: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10cf46: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10cf49: 8b 45 08 mov 0x8(%ebp),%eax 10cf4c: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10cf4f: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10cf53: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10cf56: 8b 45 30 mov 0x30(%ebp),%eax 10cf59: 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 );
10cf5c: 89 1c 24 mov %ebx,(%esp) 10cf5f: e8 7c 0a 00 00 call 10d9e0 <_User_extensions_Thread_create>
if ( extension_status )
10cf64: 83 c4 10 add $0x10,%esp 10cf67: 84 c0 test %al,%al
10cf69: 75 55 jne 10cfc0 <_Thread_Initialize+0x1a4>
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10cf6b: 83 ec 0c sub $0xc,%esp 10cf6e: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10cf74: e8 ff 0d 00 00 call 10dd78 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10cf79: 5f pop %edi 10cf7a: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10cf80: e8 f3 0d 00 00 call 10dd78 <_Workspace_Free> 10cf85: 59 pop %ecx 10cf86: ff b3 ec 00 00 00 pushl 0xec(%ebx) 10cf8c: e8 e7 0d 00 00 call 10dd78 <_Workspace_Free>
_Workspace_Free( extensions_area );
10cf91: 89 34 24 mov %esi,(%esp) 10cf94: e8 df 0d 00 00 call 10dd78 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10cf99: 5a pop %edx 10cf9a: ff 75 e0 pushl -0x20(%ebp) 10cf9d: e8 d6 0d 00 00 call 10dd78 <_Workspace_Free>
#endif
_Workspace_Free( sched );
10cfa2: 58 pop %eax 10cfa3: ff 75 e4 pushl -0x1c(%ebp) 10cfa6: e8 cd 0d 00 00 call 10dd78 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10cfab: 89 1c 24 mov %ebx,(%esp) 10cfae: e8 c1 06 00 00 call 10d674 <_Thread_Stack_Free>
return false;
10cfb3: 83 c4 10 add $0x10,%esp 10cfb6: 31 c0 xor %eax,%eax
}
10cfb8: 8d 65 f4 lea -0xc(%ebp),%esp 10cfbb: 5b pop %ebx 10cfbc: 5e pop %esi 10cfbd: 5f pop %edi 10cfbe: c9 leave 10cfbf: c3 ret
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
10cfc0: b0 01 mov $0x1,%al
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10cfc2: 8d 65 f4 lea -0xc(%ebp),%esp 10cfc5: 5b pop %ebx 10cfc6: 5e pop %esi 10cfc7: 5f pop %edi 10cfc8: c9 leave 10cfc9: c3 ret 10cfca: 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 );
10cfcc: 83 ec 0c sub $0xc,%esp 10cfcf: 6a 6c push $0x6c 10cfd1: e8 86 0d 00 00 call 10dd5c <_Workspace_Allocate> 10cfd6: 89 45 e0 mov %eax,-0x20(%ebp)
if ( !fp_area )
10cfd9: 83 c4 10 add $0x10,%esp 10cfdc: 85 c0 test %eax,%eax
10cfde: 0f 85 a2 fe ff ff jne 10ce86 <_Thread_Initialize+0x6a>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10cfe4: 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;
10cfe6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10cfed: e9 79 ff ff ff jmp 10cf6b <_Thread_Initialize+0x14f> 10cff2: 66 90 xchg %ax,%ax
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10cff4: 83 ec 0c sub $0xc,%esp 10cff7: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10cffe: 50 push %eax 10cfff: e8 58 0d 00 00 call 10dd5c <_Workspace_Allocate> 10d004: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10d006: 83 c4 10 add $0x10,%esp 10d009: 85 c0 test %eax,%eax
10d00b: 74 5a je 10d067 <_Thread_Initialize+0x24b>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10d00d: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) 10d013: 8b 0d 90 78 12 00 mov 0x127890,%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++ )
10d019: 31 d2 xor %edx,%edx
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10d01b: 31 c0 xor %eax,%eax 10d01d: 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;
10d020: 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++ )
10d027: 40 inc %eax 10d028: 89 c2 mov %eax,%edx 10d02a: 39 c1 cmp %eax,%ecx
10d02c: 73 f2 jae 10d020 <_Thread_Initialize+0x204>
10d02e: e9 94 fe ff ff jmp 10cec7 <_Thread_Initialize+0xab>
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10d033: 83 ec 08 sub $0x8,%esp 10d036: 56 push %esi 10d037: 53 push %ebx 10d038: 88 55 d8 mov %dl,-0x28(%ebp) 10d03b: e8 d0 05 00 00 call 10d610 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10d040: 83 c4 10 add $0x10,%esp 10d043: 85 c0 test %eax,%eax 10d045: 8a 55 d8 mov -0x28(%ebp),%dl
10d048: 74 16 je 10d060 <_Thread_Initialize+0x244>
10d04a: 39 c6 cmp %eax,%esi
10d04c: 77 12 ja 10d060 <_Thread_Initialize+0x244><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10d04e: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10d054: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10d05b: e9 09 fe ff ff jmp 10ce69 <_Thread_Initialize+0x4d>
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 */
10d060: 31 c0 xor %eax,%eax 10d062: e9 51 ff ff ff jmp 10cfb8 <_Thread_Initialize+0x19c>
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;
10d067: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10d06e: e9 f8 fe ff ff jmp 10cf6b <_Thread_Initialize+0x14f>
00112028 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
112028: 55 push %ebp 112029: 89 e5 mov %esp,%ebp 11202b: 53 push %ebx 11202c: 83 ec 10 sub $0x10,%esp 11202f: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
112032: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
112039: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 11203f: 88 43 74 mov %al,0x74(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
112042: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 112048: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
11204b: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 112051: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
112057: 8b 45 0c mov 0xc(%ebp),%eax 11205a: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
112060: 8b 45 10 mov 0x10(%ebp),%eax 112063: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
112069: 53 push %ebx 11206a: e8 8d be ff ff call 10defc <_Thread_queue_Extract_with_proxy> 11206f: 83 c4 10 add $0x10,%esp 112072: 84 c0 test %al,%al
112074: 75 06 jne 11207c <_Thread_Reset+0x54>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
112076: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
11207a: 74 28 je 1120a4 <_Thread_Reset+0x7c>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
11207c: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 112082: 39 43 14 cmp %eax,0x14(%ebx)
112085: 74 15 je 11209c <_Thread_Reset+0x74>
the_thread->real_priority = the_thread->Start.initial_priority;
112087: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
11208a: 89 45 0c mov %eax,0xc(%ebp) 11208d: 89 5d 08 mov %ebx,0x8(%ebp)
} }
112090: 8b 5d fc mov -0x4(%ebp),%ebx 112093: 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 );
112094: e9 3f c0 ff ff jmp 10e0d8 <_Thread_Set_priority> 112099: 8d 76 00 lea 0x0(%esi),%esi
} }
11209c: 8b 5d fc mov -0x4(%ebp),%ebx 11209f: c9 leave 1120a0: c3 ret 1120a1: 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 );
1120a4: 83 ec 0c sub $0xc,%esp 1120a7: 8d 43 48 lea 0x48(%ebx),%eax 1120aa: 50 push %eax 1120ab: e8 10 c7 ff ff call 10e7c0 <_Watchdog_Remove> 1120b0: 83 c4 10 add $0x10,%esp 1120b3: eb c7 jmp 11207c <_Thread_Reset+0x54>
0010d610 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10d610: 55 push %ebp 10d611: 89 e5 mov %esp,%ebp 10d613: 53 push %ebx 10d614: 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;
10d617: a1 50 35 12 00 mov 0x123550,%eax 10d61c: 8b 5d 0c mov 0xc(%ebp),%ebx 10d61f: 39 c3 cmp %eax,%ebx
10d621: 73 02 jae 10d625 <_Thread_Stack_Allocate+0x15>
10d623: 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 ) {
10d625: a1 80 35 12 00 mov 0x123580,%eax 10d62a: 85 c0 test %eax,%eax
10d62c: 74 32 je 10d660 <_Thread_Stack_Allocate+0x50>
stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size );
10d62e: 83 ec 0c sub $0xc,%esp 10d631: 53 push %ebx 10d632: ff d0 call *%eax 10d634: 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 )
10d637: 85 c0 test %eax,%eax
10d639: 74 11 je 10d64c <_Thread_Stack_Allocate+0x3c>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10d63b: 8b 55 08 mov 0x8(%ebp),%edx 10d63e: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10d644: 89 d8 mov %ebx,%eax 10d646: 8b 5d fc mov -0x4(%ebp),%ebx 10d649: c9 leave 10d64a: c3 ret 10d64b: 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;
10d64c: 31 db xor %ebx,%ebx
the_thread->Start.stack = stack_addr;
10d64e: 8b 55 08 mov 0x8(%ebp),%edx 10d651: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10d657: 89 d8 mov %ebx,%eax 10d659: 8b 5d fc mov -0x4(%ebp),%ebx 10d65c: c9 leave 10d65d: c3 ret 10d65e: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size (
size_t size
)
{
return size + CPU_STACK_ALIGNMENT;
10d660: 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 );
10d663: 83 ec 0c sub $0xc,%esp 10d666: 53 push %ebx 10d667: e8 f0 06 00 00 call 10dd5c <_Workspace_Allocate> 10d66c: 83 c4 10 add $0x10,%esp 10d66f: eb c6 jmp 10d637 <_Thread_Stack_Allocate+0x27>
0010d674 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10d674: 55 push %ebp 10d675: 89 e5 mov %esp,%ebp 10d677: 83 ec 08 sub $0x8,%esp 10d67a: 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 )
10d67d: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax)
10d684: 74 16 je 10d69c <_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 )
10d686: 8b 15 84 35 12 00 mov 0x123584,%edx 10d68c: 85 d2 test %edx,%edx
10d68e: 74 10 je 10d6a0 <_Thread_Stack_Free+0x2c>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10d690: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10d696: 89 45 08 mov %eax,0x8(%ebp)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10d699: 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 );
10d69a: ff e2 jmp *%edx
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10d69c: c9 leave 10d69d: c3 ret 10d69e: 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 );
10d6a0: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10d6a6: 89 45 08 mov %eax,0x8(%ebp)
}
10d6a9: 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 );
10d6aa: e9 c9 06 00 00 jmp 10dd78 <_Workspace_Free>
0010d76c <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10d76c: 55 push %ebp 10d76d: 89 e5 mov %esp,%ebp 10d76f: 53 push %ebx 10d770: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10d773: 8b 1d 98 7d 12 00 mov 0x127d98,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10d779: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10d77d: 74 19 je 10d798 <_Thread_Tickle_timeslice+0x2c>
return;
if ( !_States_Is_ready( executing->current_state ) )
10d77f: 8b 43 10 mov 0x10(%ebx),%eax 10d782: 85 c0 test %eax,%eax
10d784: 75 12 jne 10d798 <_Thread_Tickle_timeslice+0x2c>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10d786: 8b 43 7c mov 0x7c(%ebx),%eax 10d789: 83 f8 01 cmp $0x1,%eax
10d78c: 72 0a jb 10d798 <_Thread_Tickle_timeslice+0x2c>
10d78e: 83 f8 02 cmp $0x2,%eax
10d791: 76 29 jbe 10d7bc <_Thread_Tickle_timeslice+0x50>
10d793: 83 f8 03 cmp $0x3,%eax
10d796: 74 08 je 10d7a0 <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
10d798: 8b 5d fc mov -0x4(%ebp),%ebx 10d79b: c9 leave 10d79c: c3 ret 10d79d: 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 )
10d7a0: 8b 43 78 mov 0x78(%ebx),%eax 10d7a3: 48 dec %eax 10d7a4: 89 43 78 mov %eax,0x78(%ebx) 10d7a7: 85 c0 test %eax,%eax
10d7a9: 75 ed jne 10d798 <_Thread_Tickle_timeslice+0x2c> (*executing->budget_callout)( executing );
10d7ab: 83 ec 0c sub $0xc,%esp 10d7ae: 53 push %ebx 10d7af: ff 93 80 00 00 00 call *0x80(%ebx) 10d7b5: 83 c4 10 add $0x10,%esp 10d7b8: eb de jmp 10d798 <_Thread_Tickle_timeslice+0x2c> 10d7ba: 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 ) {
10d7bc: 8b 43 78 mov 0x78(%ebx),%eax 10d7bf: 48 dec %eax 10d7c0: 89 43 78 mov %eax,0x78(%ebx) 10d7c3: 85 c0 test %eax,%eax
10d7c5: 7f d1 jg 10d798 <_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();
10d7c7: ff 15 6c 34 12 00 call *0x12346c
* 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;
10d7cd: a1 c0 77 12 00 mov 0x1277c0,%eax 10d7d2: 89 43 78 mov %eax,0x78(%ebx) 10d7d5: eb c1 jmp 10d798 <_Thread_Tickle_timeslice+0x2c>
0010d14c <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10d14c: 55 push %ebp 10d14d: 89 e5 mov %esp,%ebp 10d14f: 57 push %edi 10d150: 56 push %esi 10d151: 53 push %ebx 10d152: 83 ec 2c sub $0x2c,%esp 10d155: 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 );
10d158: 9c pushf 10d159: fa cli 10d15a: 58 pop %eax 10d15b: 89 f9 mov %edi,%ecx
for( index=0 ;
10d15d: 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 );
}
10d15f: 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 );
10d161: 8d 34 52 lea (%edx,%edx,2),%esi 10d164: 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 ] ) ) {
10d168: 39 f3 cmp %esi,%ebx
10d16a: 75 18 jne 10d184 <_Thread_queue_Dequeue_priority+0x38>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10d16c: 42 inc %edx 10d16d: 83 c1 0c add $0xc,%ecx
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
10d170: 83 fa 04 cmp $0x4,%edx
10d173: 75 ea jne 10d15f <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10d175: 50 push %eax 10d176: 9d popf
return NULL;
10d177: 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 );
}
10d179: 89 f0 mov %esi,%eax 10d17b: 8d 65 f4 lea -0xc(%ebp),%esp 10d17e: 5b pop %ebx 10d17f: 5e pop %esi 10d180: 5f pop %edi 10d181: c9 leave 10d182: c3 ret 10d183: 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(
10d184: 89 de mov %ebx,%esi
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10d186: 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 );
}
10d18d: 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;
10d190: 8b 0b mov (%ebx),%ecx
previous_node = the_thread->Object.Node.previous;
10d192: 8b 7b 04 mov 0x4(%ebx),%edi 10d195: 89 7d d4 mov %edi,-0x2c(%ebp) 10d198: 8d 7b 3c lea 0x3c(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10d19b: 39 fa cmp %edi,%edx
10d19d: 74 7f je 10d21e <_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 );
}
10d19f: 8b 7b 40 mov 0x40(%ebx),%edi 10d1a2: 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;
10d1a5: 8b 3a mov (%edx),%edi 10d1a7: 89 7d e0 mov %edi,-0x20(%ebp)
previous_node->next = new_first_node;
10d1aa: 8b 7d d4 mov -0x2c(%ebp),%edi 10d1ad: 89 17 mov %edx,(%edi)
next_node->previous = new_first_node;
10d1af: 89 51 04 mov %edx,0x4(%ecx)
new_first_node->next = next_node;
10d1b2: 89 0a mov %ecx,(%edx)
new_first_node->previous = previous_node;
10d1b4: 89 7a 04 mov %edi,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10d1b7: 8b 4b 40 mov 0x40(%ebx),%ecx 10d1ba: 39 4b 38 cmp %ecx,0x38(%ebx)
10d1bd: 74 17 je 10d1d6 <_Thread_queue_Dequeue_priority+0x8a>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
10d1bf: 8d 4a 38 lea 0x38(%edx),%ecx 10d1c2: 8b 7d e0 mov -0x20(%ebp),%edi 10d1c5: 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;
10d1c8: 89 7a 38 mov %edi,0x38(%edx)
tail->previous = last_node;
10d1cb: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d1ce: 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 );
10d1d1: 83 c2 3c add $0x3c,%edx 10d1d4: 89 11 mov %edx,(%ecx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10d1d6: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10d1da: 74 18 je 10d1f4 <_Thread_queue_Dequeue_priority+0xa8>
_ISR_Enable( level );
10d1dc: 50 push %eax 10d1dd: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10d1de: 83 ec 08 sub $0x8,%esp 10d1e1: 68 f8 ff 03 10 push $0x1003fff8 10d1e6: 53 push %ebx 10d1e7: e8 30 f8 ff ff call 10ca1c <_Thread_Clear_state> 10d1ec: 83 c4 10 add $0x10,%esp 10d1ef: eb 88 jmp 10d179 <_Thread_queue_Dequeue_priority+0x2d> 10d1f1: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10d1f4: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10d1fb: 50 push %eax 10d1fc: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10d1fd: 83 ec 0c sub $0xc,%esp 10d200: 8d 43 48 lea 0x48(%ebx),%eax 10d203: 50 push %eax 10d204: e8 2b 0a 00 00 call 10dc34 <_Watchdog_Remove> 10d209: 58 pop %eax 10d20a: 5a pop %edx 10d20b: 68 f8 ff 03 10 push $0x1003fff8 10d210: 53 push %ebx 10d211: e8 06 f8 ff ff call 10ca1c <_Thread_Clear_state> 10d216: 83 c4 10 add $0x10,%esp 10d219: e9 5b ff ff ff jmp 10d179 <_Thread_queue_Dequeue_priority+0x2d>
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
10d21e: 8b 7d d4 mov -0x2c(%ebp),%edi 10d221: 89 0f mov %ecx,(%edi)
next_node->previous = previous_node;
10d223: 89 79 04 mov %edi,0x4(%ecx) 10d226: eb ae jmp 10d1d6 <_Thread_queue_Dequeue_priority+0x8a>
001112b8 <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
1112b8: 55 push %ebp 1112b9: 89 e5 mov %esp,%ebp 1112bb: 83 ec 08 sub $0x8,%esp 1112be: 8b 45 08 mov 0x8(%ebp),%eax 1112c1: 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 )
1112c4: 83 78 34 01 cmpl $0x1,0x34(%eax)
1112c8: 74 0e je 1112d8 <_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 );
1112ca: 89 55 0c mov %edx,0xc(%ebp) 1112cd: 89 45 08 mov %eax,0x8(%ebp)
}
1112d0: 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 );
1112d1: e9 8a 1a 00 00 jmp 112d60 <_Thread_queue_Extract_fifo> 1112d6: 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 );
1112d8: 51 push %ecx 1112d9: 6a 00 push $0x0 1112db: 52 push %edx 1112dc: 50 push %eax 1112dd: e8 06 00 00 00 call 1112e8 <_Thread_queue_Extract_priority_helper> 1112e2: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
1112e5: c9 leave 1112e6: c3 ret
00112d60 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
112d60: 55 push %ebp 112d61: 89 e5 mov %esp,%ebp 112d63: 53 push %ebx 112d64: 83 ec 04 sub $0x4,%esp 112d67: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
112d6a: 9c pushf 112d6b: fa cli 112d6c: 58 pop %eax
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
112d6d: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
112d74: 74 2e je 112da4 <_Thread_queue_Extract_fifo+0x44>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
112d76: 8b 0b mov (%ebx),%ecx
previous = the_node->previous;
112d78: 8b 53 04 mov 0x4(%ebx),%edx
next->previous = previous;
112d7b: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
112d7e: 89 0a mov %ecx,(%edx)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
112d80: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
112d87: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
112d8b: 74 1f je 112dac <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
112d8d: 50 push %eax 112d8e: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
112d8f: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 112d96: 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
}
112d99: 8b 5d fc mov -0x4(%ebp),%ebx 112d9c: c9 leave 112d9d: e9 7a 9c ff ff jmp 10ca1c <_Thread_Clear_state> 112da2: 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 );
112da4: 50 push %eax 112da5: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
112da6: 8b 5d fc mov -0x4(%ebp),%ebx 112da9: c9 leave 112daa: c3 ret 112dab: 90 nop 112dac: 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 );
112db3: 50 push %eax 112db4: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
112db5: 83 ec 0c sub $0xc,%esp 112db8: 8d 43 48 lea 0x48(%ebx),%eax 112dbb: 50 push %eax 112dbc: e8 73 ae ff ff call 10dc34 <_Watchdog_Remove> 112dc1: 83 c4 10 add $0x10,%esp 112dc4: eb c9 jmp 112d8f <_Thread_queue_Extract_fifo+0x2f>
001112e8 <_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
)
{
1112e8: 55 push %ebp 1112e9: 89 e5 mov %esp,%ebp 1112eb: 57 push %edi 1112ec: 56 push %esi 1112ed: 53 push %ebx 1112ee: 83 ec 1c sub $0x1c,%esp 1112f1: 8b 5d 0c mov 0xc(%ebp),%ebx 1112f4: 8a 45 10 mov 0x10(%ebp),%al 1112f7: 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 );
1112fa: 9c pushf 1112fb: fa cli 1112fc: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
1112ff: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
111306: 74 6c je 111374 <_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;
111308: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
11130a: 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
}
11130d: 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 );
111310: 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 ) ) {
111313: 39 f0 cmp %esi,%eax
111315: 74 69 je 111380 <_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
}
111317: 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;
11131a: 8b 30 mov (%eax),%esi
previous_node->next = new_first_node;
11131c: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
11131e: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
111321: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
111323: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
111326: 8b 53 40 mov 0x40(%ebx),%edx 111329: 39 53 38 cmp %edx,0x38(%ebx)
11132c: 74 11 je 11133f <_Thread_queue_Extract_priority_helper+0x57>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
11132e: 8d 50 38 lea 0x38(%eax),%edx 111331: 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;
111334: 89 70 38 mov %esi,0x38(%eax)
tail->previous = last_node;
111337: 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 );
11133a: 83 c0 3c add $0x3c,%eax 11133d: 89 07 mov %eax,(%edi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
11133f: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
111343: 75 23 jne 111368 <_Thread_queue_Extract_priority_helper+0x80>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
111345: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
111349: 74 3d je 111388 <_Thread_queue_Extract_priority_helper+0xa0>
_ISR_Enable( level );
11134b: ff 75 e4 pushl -0x1c(%ebp) 11134e: 9d popf 11134f: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 111356: 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
}
111359: 8d 65 f4 lea -0xc(%ebp),%esp 11135c: 5b pop %ebx 11135d: 5e pop %esi 11135e: 5f pop %edi 11135f: c9 leave 111360: e9 b7 b6 ff ff jmp 10ca1c <_Thread_Clear_state> 111365: 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 );
111368: ff 75 e4 pushl -0x1c(%ebp) 11136b: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
11136c: 8d 65 f4 lea -0xc(%ebp),%esp 11136f: 5b pop %ebx 111370: 5e pop %esi 111371: 5f pop %edi 111372: c9 leave 111373: 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 );
111374: ff 75 e4 pushl -0x1c(%ebp) 111377: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111378: 8d 65 f4 lea -0xc(%ebp),%esp 11137b: 5b pop %ebx 11137c: 5e pop %esi 11137d: 5f pop %edi 11137e: c9 leave 11137f: c3 ret
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
111380: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
111382: 89 4a 04 mov %ecx,0x4(%edx) 111385: eb b8 jmp 11133f <_Thread_queue_Extract_priority_helper+0x57> 111387: 90 nop 111388: 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 );
11138f: ff 75 e4 pushl -0x1c(%ebp) 111392: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
111393: 83 ec 0c sub $0xc,%esp 111396: 8d 43 48 lea 0x48(%ebx),%eax 111399: 50 push %eax 11139a: e8 95 c8 ff ff call 10dc34 <_Watchdog_Remove> 11139f: 83 c4 10 add $0x10,%esp 1113a2: eb ab jmp 11134f <_Thread_queue_Extract_priority_helper+0x67>
0010d438 <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10d438: 55 push %ebp 10d439: 89 e5 mov %esp,%ebp 10d43b: 83 ec 08 sub $0x8,%esp 10d43e: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d441: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10d448: 75 06 jne 10d450 <_Thread_queue_Extract_with_proxy+0x18>
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return true;
}
return false;
10d44a: 31 c0 xor %eax,%eax
}
10d44c: c9 leave 10d44d: c3 ret 10d44e: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10d450: 83 ec 08 sub $0x8,%esp 10d453: 50 push %eax 10d454: ff 70 44 pushl 0x44(%eax) 10d457: e8 5c 3e 00 00 call 1112b8 <_Thread_queue_Extract>
return true;
10d45c: 83 c4 10 add $0x10,%esp 10d45f: b0 01 mov $0x1,%al
} return false; }
10d461: c9 leave 10d462: c3 ret
0010f218 <_Thread_queue_First>:
*/
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue
)
{
10f218: 55 push %ebp 10f219: 89 e5 mov %esp,%ebp 10f21b: 83 ec 08 sub $0x8,%esp 10f21e: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
10f221: 83 78 34 01 cmpl $0x1,0x34(%eax)
10f225: 74 0d je 10f234 <_Thread_queue_First+0x1c>
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
10f227: ba cc 31 11 00 mov $0x1131cc,%edx
return (*first_p)( the_thread_queue );
10f22c: 89 45 08 mov %eax,0x8(%ebp)
}
10f22f: 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 );
10f230: ff e2 jmp *%edx 10f232: 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;
10f234: ba 40 f2 10 00 mov $0x10f240,%edx
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
10f239: 89 45 08 mov %eax,0x8(%ebp)
}
10f23c: 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 );
10f23d: ff e2 jmp *%edx
001131cc <_Thread_queue_First_fifo>:
*/
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
1131cc: 55 push %ebp 1131cd: 89 e5 mov %esp,%ebp 1131cf: 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;
}
1131d2: 8b 02 mov (%edx),%eax 1131d4: 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 ) )
1131d7: 39 d0 cmp %edx,%eax
1131d9: 74 05 je 1131e0 <_Thread_queue_First_fifo+0x14>
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
1131db: c9 leave 1131dc: c3 ret 1131dd: 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;
1131e0: 31 c0 xor %eax,%eax
}
1131e2: c9 leave 1131e3: c3 ret
0010d464 <_Thread_queue_Flush>:
#else
Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)),
#endif
uint32_t status
)
{
10d464: 55 push %ebp 10d465: 89 e5 mov %esp,%ebp 10d467: 56 push %esi 10d468: 53 push %ebx 10d469: 8b 5d 08 mov 0x8(%ebp),%ebx 10d46c: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10d46f: eb 06 jmp 10d477 <_Thread_queue_Flush+0x13> 10d471: 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;
10d474: 89 70 34 mov %esi,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10d477: 83 ec 0c sub $0xc,%esp 10d47a: 53 push %ebx 10d47b: e8 80 fc ff ff call 10d100 <_Thread_queue_Dequeue> 10d480: 83 c4 10 add $0x10,%esp 10d483: 85 c0 test %eax,%eax
10d485: 75 ed jne 10d474 <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10d487: 8d 65 f8 lea -0x8(%ebp),%esp 10d48a: 5b pop %ebx 10d48b: 5e pop %esi 10d48c: c9 leave 10d48d: c3 ret
0010d490 <_Thread_queue_Initialize>:
Thread_queue_Control *the_thread_queue,
Thread_queue_Disciplines the_discipline,
States_Control state,
uint32_t timeout_status
)
{
10d490: 55 push %ebp 10d491: 89 e5 mov %esp,%ebp 10d493: 56 push %esi 10d494: 53 push %ebx 10d495: 8b 45 08 mov 0x8(%ebp),%eax 10d498: 8b 55 0c mov 0xc(%ebp),%edx
the_thread_queue->state = state;
10d49b: 8b 4d 10 mov 0x10(%ebp),%ecx 10d49e: 89 48 38 mov %ecx,0x38(%eax)
the_thread_queue->discipline = the_discipline;
10d4a1: 89 50 34 mov %edx,0x34(%eax)
the_thread_queue->timeout_status = timeout_status;
10d4a4: 8b 4d 14 mov 0x14(%ebp),%ecx 10d4a7: 89 48 3c mov %ecx,0x3c(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10d4aa: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10d4b1: 83 fa 01 cmp $0x1,%edx
10d4b4: 74 16 je 10d4cc <_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 );
10d4b6: 8d 50 04 lea 0x4(%eax),%edx 10d4b9: 89 10 mov %edx,(%eax)
head->next = tail;
head->previous = NULL;
10d4bb: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10d4c2: 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 );
}
}
10d4c5: 5b pop %ebx 10d4c6: 5e pop %esi 10d4c7: c9 leave 10d4c8: c3 ret 10d4c9: 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 ) {
10d4cc: 89 c1 mov %eax,%ecx 10d4ce: 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 );
10d4d0: 8d 1c 52 lea (%edx,%edx,2),%ebx 10d4d3: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10d4d6: 8d 73 04 lea 0x4(%ebx),%esi 10d4d9: 89 31 mov %esi,(%ecx)
head->next = tail;
head->previous = NULL;
10d4db: 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 );
10d4e2: 89 59 08 mov %ebx,0x8(%ecx)
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++)
10d4e5: 42 inc %edx 10d4e6: 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 ;
10d4e9: 83 fa 04 cmp $0x4,%edx
10d4ec: 75 e2 jne 10d4d0 <_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 );
}
}
10d4ee: 5b pop %ebx 10d4ef: 5e pop %esi 10d4f0: c9 leave 10d4f1: c3 ret
0010d4f4 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10d4f4: 55 push %ebp 10d4f5: 89 e5 mov %esp,%ebp 10d4f7: 57 push %edi 10d4f8: 56 push %esi 10d4f9: 53 push %ebx 10d4fa: 83 ec 1c sub $0x1c,%esp 10d4fd: 8b 75 08 mov 0x8(%ebp),%esi 10d500: 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 )
10d503: 85 f6 test %esi,%esi
10d505: 74 06 je 10d50d <_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 ) {
10d507: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10d50b: 74 0b je 10d518 <_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 );
}
}
10d50d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d510: 5b pop %ebx <== NOT EXECUTED 10d511: 5e pop %esi <== NOT EXECUTED 10d512: 5f pop %edi <== NOT EXECUTED 10d513: c9 leave <== NOT EXECUTED 10d514: c3 ret <== NOT EXECUTED 10d515: 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 );
10d518: 9c pushf 10d519: fa cli 10d51a: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10d51b: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10d522: 75 0c jne 10d530 <_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 );
10d524: 53 push %ebx 10d525: 9d popf
} }
10d526: 8d 65 f4 lea -0xc(%ebp),%esp 10d529: 5b pop %ebx 10d52a: 5e pop %esi 10d52b: 5f pop %edi 10d52c: c9 leave 10d52d: c3 ret 10d52e: 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;
10d530: 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 );
10d537: 50 push %eax 10d538: 6a 01 push $0x1 10d53a: 57 push %edi 10d53b: 56 push %esi 10d53c: e8 a7 3d 00 00 call 1112e8 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10d541: 83 c4 0c add $0xc,%esp 10d544: 8d 45 e4 lea -0x1c(%ebp),%eax 10d547: 50 push %eax 10d548: 57 push %edi 10d549: 56 push %esi 10d54a: e8 71 fd ff ff call 10d2c0 <_Thread_queue_Enqueue_priority> 10d54f: 83 c4 10 add $0x10,%esp 10d552: eb d0 jmp 10d524 <_Thread_queue_Requeue+0x30>
0010d554 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10d554: 55 push %ebp 10d555: 89 e5 mov %esp,%ebp 10d557: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d55a: 8d 45 f4 lea -0xc(%ebp),%eax 10d55d: 50 push %eax 10d55e: ff 75 08 pushl 0x8(%ebp) 10d561: e8 3e f8 ff ff call 10cda4 <_Thread_Get>
switch ( location ) {
10d566: 83 c4 10 add $0x10,%esp 10d569: 8b 55 f4 mov -0xc(%ebp),%edx 10d56c: 85 d2 test %edx,%edx
10d56e: 75 17 jne 10d587 <_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 );
10d570: 83 ec 0c sub $0xc,%esp 10d573: 50 push %eax 10d574: e8 2b 3e 00 00 call 1113a4 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10d579: a1 ec 77 12 00 mov 0x1277ec,%eax 10d57e: 48 dec %eax 10d57f: a3 ec 77 12 00 mov %eax,0x1277ec 10d584: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10d587: c9 leave 10d588: c3 ret
001183e0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
1183e0: 55 push %ebp 1183e1: 89 e5 mov %esp,%ebp 1183e3: 57 push %edi 1183e4: 56 push %esi 1183e5: 53 push %ebx 1183e6: 83 ec 4c sub $0x4c,%esp 1183e9: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1183ec: 8d 45 e0 lea -0x20(%ebp),%eax 1183ef: 89 45 b4 mov %eax,-0x4c(%ebp) 1183f2: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
1183f5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
1183fc: 8d 4d dc lea -0x24(%ebp),%ecx 1183ff: 89 4d e4 mov %ecx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118402: 8d 7d d0 lea -0x30(%ebp),%edi 118405: 8d 45 d4 lea -0x2c(%ebp),%eax 118408: 89 45 b0 mov %eax,-0x50(%ebp) 11840b: 89 45 d0 mov %eax,-0x30(%ebp)
head->previous = NULL;
11840e: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
118415: 89 7d d8 mov %edi,-0x28(%ebp) 118418: 8d 73 30 lea 0x30(%ebx),%esi 11841b: 8d 4b 68 lea 0x68(%ebx),%ecx 11841e: 89 4d c4 mov %ecx,-0x3c(%ebp) 118421: 8d 43 08 lea 0x8(%ebx),%eax 118424: 89 45 c0 mov %eax,-0x40(%ebp) 118427: 8d 53 40 lea 0x40(%ebx),%edx 11842a: 89 55 bc mov %edx,-0x44(%ebp) 11842d: 8d 76 00 lea 0x0(%esi),%esi
{
/*
* 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;
118430: 8d 4d dc lea -0x24(%ebp),%ecx 118433: 89 4b 78 mov %ecx,0x78(%ebx) 118436: 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;
118438: a1 e4 21 14 00 mov 0x1421e4,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
11843d: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
118440: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118443: 51 push %ecx 118444: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118445: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118447: 50 push %eax 118448: 56 push %esi 118449: e8 32 3f 00 00 call 11c380 <_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();
11844e: a1 48 21 14 00 mov 0x142148,%eax
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
118453: 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 ) {
118456: 83 c4 10 add $0x10,%esp 118459: 39 d0 cmp %edx,%eax
11845b: 77 63 ja 1184c0 <_Timer_server_Body+0xe0>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
11845d: 72 7d jb 1184dc <_Timer_server_Body+0xfc>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
11845f: 89 43 74 mov %eax,0x74(%ebx) 118462: 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 );
118464: 8b 43 78 mov 0x78(%ebx),%eax 118467: 83 ec 0c sub $0xc,%esp 11846a: 50 push %eax 11846b: e8 f8 09 00 00 call 118e68 <_Chain_Get>
if ( timer == NULL ) {
118470: 83 c4 10 add $0x10,%esp 118473: 85 c0 test %eax,%eax
118475: 74 35 je 1184ac <_Timer_server_Body+0xcc><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118477: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 11847a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 11847d: 74 19 je 118498 <_Timer_server_Body+0xb8><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
11847f: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118482: 75 e0 jne 118464 <_Timer_server_Body+0x84><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118484: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118487: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11848a: 50 push %eax <== NOT EXECUTED 11848b: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 11848e: e8 79 3f 00 00 call 11c40c <_Watchdog_Insert> <== NOT EXECUTED 118493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118496: eb cc jmp 118464 <_Timer_server_Body+0x84><== 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 );
118498: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11849b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11849e: 50 push %eax <== NOT EXECUTED 11849f: 56 push %esi <== NOT EXECUTED 1184a0: e8 67 3f 00 00 call 11c40c <_Watchdog_Insert> <== NOT EXECUTED 1184a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1184a8: eb ba jmp 118464 <_Timer_server_Body+0x84><== NOT EXECUTED 1184aa: 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 );
1184ac: 9c pushf 1184ad: fa cli 1184ae: 58 pop %eax
if ( _Chain_Is_empty( insert_chain ) ) {
1184af: 8b 55 b4 mov -0x4c(%ebp),%edx 1184b2: 39 55 dc cmp %edx,-0x24(%ebp)
1184b5: 74 41 je 1184f8 <_Timer_server_Body+0x118><== ALWAYS TAKEN
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
1184b7: 50 push %eax <== NOT EXECUTED 1184b8: 9d popf <== NOT EXECUTED 1184b9: e9 7a ff ff ff jmp 118438 <_Timer_server_Body+0x58><== NOT EXECUTED 1184be: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* 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 );
1184c0: 51 push %ecx 1184c1: 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;
1184c2: 89 c1 mov %eax,%ecx 1184c4: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1184c6: 51 push %ecx 1184c7: ff 75 c4 pushl -0x3c(%ebp) 1184ca: 89 45 b8 mov %eax,-0x48(%ebp) 1184cd: e8 ae 3e 00 00 call 11c380 <_Watchdog_Adjust_to_chain> 1184d2: 83 c4 10 add $0x10,%esp 1184d5: 8b 45 b8 mov -0x48(%ebp),%eax 1184d8: eb 85 jmp 11845f <_Timer_server_Body+0x7f> 1184da: 66 90 xchg %ax,%ax
/*
* 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 );
1184dc: 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;
1184dd: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1184df: 52 push %edx 1184e0: 6a 01 push $0x1 1184e2: ff 75 c4 pushl -0x3c(%ebp) 1184e5: 89 45 b8 mov %eax,-0x48(%ebp) 1184e8: e8 1b 3e 00 00 call 11c308 <_Watchdog_Adjust> 1184ed: 83 c4 10 add $0x10,%esp 1184f0: 8b 45 b8 mov -0x48(%ebp),%eax 1184f3: e9 67 ff ff ff jmp 11845f <_Timer_server_Body+0x7f>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
1184f8: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
_ISR_Enable( level );
1184ff: 50 push %eax 118500: 9d popf
_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 ) ) {
118501: 8b 4d b0 mov -0x50(%ebp),%ecx 118504: 39 4d d0 cmp %ecx,-0x30(%ebp)
118507: 75 23 jne 11852c <_Timer_server_Body+0x14c>
118509: eb 33 jmp 11853e <_Timer_server_Body+0x15e> 11850b: 90 nop
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
11850c: 8b 10 mov (%eax),%edx
head->next = new_first;
11850e: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
118511: 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;
118514: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
11851b: 51 push %ecx 11851c: 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 );
11851d: 83 ec 08 sub $0x8,%esp 118520: ff 70 24 pushl 0x24(%eax) 118523: ff 70 20 pushl 0x20(%eax) 118526: ff 50 1c call *0x1c(%eax)
}
118529: 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 );
11852c: 9c pushf 11852d: fa cli 11852e: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
11852f: 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))
118532: 3b 45 b0 cmp -0x50(%ebp),%eax
118535: 75 d5 jne 11850c <_Timer_server_Body+0x12c>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
118537: 51 push %ecx 118538: 9d popf 118539: e9 f2 fe ff ff jmp 118430 <_Timer_server_Body+0x50>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
11853e: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118542: a1 ac 20 14 00 mov 0x1420ac,%eax 118547: 40 inc %eax 118548: a3 ac 20 14 00 mov %eax,0x1420ac
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
11854d: 83 ec 08 sub $0x8,%esp 118550: 6a 08 push $0x8 118552: ff 33 pushl (%ebx) 118554: e8 d7 37 00 00 call 11bd30 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
118559: 89 d8 mov %ebx,%eax 11855b: e8 e0 fd ff ff call 118340 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
118560: 89 d8 mov %ebx,%eax 118562: e8 29 fe ff ff call 118390 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
118567: e8 18 2f 00 00 call 11b484 <_Thread_Enable_dispatch>
ts->active = true;
11856c: 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 );
118570: 5a pop %edx 118571: ff 75 c0 pushl -0x40(%ebp) 118574: e8 d3 3f 00 00 call 11c54c <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
118579: 58 pop %eax 11857a: ff 75 bc pushl -0x44(%ebp) 11857d: e8 ca 3f 00 00 call 11c54c <_Watchdog_Remove> 118582: 83 c4 10 add $0x10,%esp 118585: e9 a6 fe ff ff jmp 118430 <_Timer_server_Body+0x50>
0011858c <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
11858c: 55 push %ebp 11858d: 89 e5 mov %esp,%ebp 11858f: 57 push %edi 118590: 56 push %esi 118591: 53 push %ebx 118592: 83 ec 2c sub $0x2c,%esp 118595: 8b 5d 08 mov 0x8(%ebp),%ebx 118598: 8b 45 0c mov 0xc(%ebp),%eax
if ( ts->insert_chain == NULL ) {
11859b: 8b 53 78 mov 0x78(%ebx),%edx 11859e: 85 d2 test %edx,%edx
1185a0: 74 16 je 1185b8 <_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 );
1185a2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 1185a5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1185a8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
} }
1185ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1185ae: 5b pop %ebx <== NOT EXECUTED 1185af: 5e pop %esi <== NOT EXECUTED 1185b0: 5f pop %edi <== NOT EXECUTED 1185b1: 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 );
1185b2: e9 75 08 00 00 jmp 118e2c <_Chain_Append> <== NOT EXECUTED 1185b7: 90 nop <== NOT EXECUTED
1185b8: 8b 15 ac 20 14 00 mov 0x1420ac,%edx 1185be: 42 inc %edx 1185bf: 89 15 ac 20 14 00 mov %edx,0x1420ac
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
1185c5: 8b 50 38 mov 0x38(%eax),%edx 1185c8: 83 fa 01 cmp $0x1,%edx
1185cb: 74 7b je 118648 <_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 ) {
1185cd: 83 fa 03 cmp $0x3,%edx
1185d0: 74 0e je 1185e0 <_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 );
}
}
1185d2: 8d 65 f4 lea -0xc(%ebp),%esp 1185d5: 5b pop %ebx 1185d6: 5e pop %esi 1185d7: 5f pop %edi 1185d8: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
1185d9: e9 a6 2e 00 00 jmp 11b484 <_Thread_Enable_dispatch> 1185de: 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 );
1185e0: 9c pushf 1185e1: fa cli 1185e2: 8f 45 e4 popl -0x1c(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
1185e5: 8b 0d 48 21 14 00 mov 0x142148,%ecx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
1185eb: 8b 53 74 mov 0x74(%ebx),%edx 1185ee: 89 55 d4 mov %edx,-0x2c(%ebp)
initialized = false;
}
#endif
return status;
}
1185f1: 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 );
1185f4: 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 ) ) {
1185f7: 39 fa cmp %edi,%edx
1185f9: 74 21 je 11861c <_Timer_server_Schedule_operation_method+0x90>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
1185fb: 8b 7a 10 mov 0x10(%edx),%edi
if ( snapshot > last_snapshot ) {
1185fe: 3b 4d d4 cmp -0x2c(%ebp),%ecx
118601: 0f 86 a1 00 00 00 jbe 1186a8 <_Timer_server_Schedule_operation_method+0x11c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
118607: 89 ce mov %ecx,%esi 118609: 2b 75 d4 sub -0x2c(%ebp),%esi 11860c: 89 75 d4 mov %esi,-0x2c(%ebp)
if (delta_interval > delta) {
11860f: 39 f7 cmp %esi,%edi
118611: 0f 86 9b 00 00 00 jbe 1186b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN
delta_interval -= delta;
118617: 29 f7 sub %esi,%edi
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
118619: 89 7a 10 mov %edi,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
11861c: 89 4b 74 mov %ecx,0x74(%ebx)
_ISR_Enable( level );
11861f: ff 75 e4 pushl -0x1c(%ebp) 118622: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118623: 83 ec 08 sub $0x8,%esp 118626: 83 c0 10 add $0x10,%eax 118629: 50 push %eax 11862a: 8d 43 68 lea 0x68(%ebx),%eax 11862d: 50 push %eax 11862e: e8 d9 3d 00 00 call 11c40c <_Watchdog_Insert>
if ( !ts->active ) {
118633: 8a 43 7c mov 0x7c(%ebx),%al 118636: 83 c4 10 add $0x10,%esp 118639: 84 c0 test %al,%al
11863b: 75 95 jne 1185d2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_tod_system_watchdog( ts );
11863d: 89 d8 mov %ebx,%eax 11863f: e8 4c fd ff ff call 118390 <_Timer_server_Reset_tod_system_watchdog> 118644: eb 8c jmp 1185d2 <_Timer_server_Schedule_operation_method+0x46> 118646: 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 );
118648: 9c pushf 118649: fa cli 11864a: 8f 45 e4 popl -0x1c(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
11864d: 8b 0d e4 21 14 00 mov 0x1421e4,%ecx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
118653: 8b 7b 3c mov 0x3c(%ebx),%edi
initialized = false;
}
#endif
return status;
}
118656: 8b 53 30 mov 0x30(%ebx),%edx 118659: 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 ) ) {
11865c: 39 f2 cmp %esi,%edx
11865e: 74 10 je 118670 <_Timer_server_Schedule_operation_method+0xe4>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
118660: 89 ce mov %ecx,%esi 118662: 29 fe sub %edi,%esi
delta_interval = first_watchdog->delta_interval;
118664: 8b 7a 10 mov 0x10(%edx),%edi
if (delta_interval > delta) {
118667: 39 fe cmp %edi,%esi
118669: 73 39 jae 1186a4 <_Timer_server_Schedule_operation_method+0x118>
delta_interval -= delta;
11866b: 29 f7 sub %esi,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
11866d: 89 7a 10 mov %edi,0x10(%edx)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
118670: 89 4b 3c mov %ecx,0x3c(%ebx)
_ISR_Enable( level );
118673: ff 75 e4 pushl -0x1c(%ebp) 118676: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
118677: 83 ec 08 sub $0x8,%esp 11867a: 83 c0 10 add $0x10,%eax 11867d: 50 push %eax 11867e: 8d 43 30 lea 0x30(%ebx),%eax 118681: 50 push %eax 118682: e8 85 3d 00 00 call 11c40c <_Watchdog_Insert>
if ( !ts->active ) {
118687: 8a 43 7c mov 0x7c(%ebx),%al 11868a: 83 c4 10 add $0x10,%esp 11868d: 84 c0 test %al,%al
11868f: 0f 85 3d ff ff ff jne 1185d2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_interval_system_watchdog( ts );
118695: 89 d8 mov %ebx,%eax 118697: e8 a4 fc ff ff call 118340 <_Timer_server_Reset_interval_system_watchdog> 11869c: e9 31 ff ff ff jmp 1185d2 <_Timer_server_Schedule_operation_method+0x46> 1186a1: 8d 76 00 lea 0x0(%esi),%esi
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1186a4: 31 ff xor %edi,%edi 1186a6: eb c5 jmp 11866d <_Timer_server_Schedule_operation_method+0xe1>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
1186a8: 03 7d d4 add -0x2c(%ebp),%edi
delta_interval += delta;
1186ab: 29 cf sub %ecx,%edi 1186ad: e9 67 ff ff ff jmp 118619 <_Timer_server_Schedule_operation_method+0x8d>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1186b2: 31 ff xor %edi,%edi <== NOT EXECUTED 1186b4: e9 60 ff ff ff jmp 118619 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED
0010ef40 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10ef40: 55 push %ebp 10ef41: 89 e5 mov %esp,%ebp 10ef43: 57 push %edi 10ef44: 56 push %esi 10ef45: 53 push %ebx 10ef46: 83 ec 2c sub $0x2c,%esp 10ef49: 8b 45 08 mov 0x8(%ebp),%eax 10ef4c: 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;
10ef4f: 8b 38 mov (%eax),%edi
left += lhs->tv_nsec;
10ef51: 8b 70 04 mov 0x4(%eax),%esi
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10ef54: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10ef59: 8b 01 mov (%ecx),%eax 10ef5b: f7 eb imul %ebx 10ef5d: 89 45 e0 mov %eax,-0x20(%ebp) 10ef60: 89 55 e4 mov %edx,-0x1c(%ebp)
right += rhs->tv_nsec;
10ef63: 8b 41 04 mov 0x4(%ecx),%eax 10ef66: 99 cltd 10ef67: 01 45 e0 add %eax,-0x20(%ebp) 10ef6a: 11 55 e4 adc %edx,-0x1c(%ebp)
if ( right == 0 ) {
10ef6d: 8b 55 e4 mov -0x1c(%ebp),%edx 10ef70: 0b 55 e0 or -0x20(%ebp),%edx
10ef73: 74 73 je 10efe8 <_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;
10ef75: 89 f8 mov %edi,%eax 10ef77: f7 eb imul %ebx 10ef79: 89 45 d0 mov %eax,-0x30(%ebp) 10ef7c: 89 55 d4 mov %edx,-0x2c(%ebp)
left += lhs->tv_nsec;
10ef7f: 89 f7 mov %esi,%edi 10ef81: c1 ff 1f sar $0x1f,%edi 10ef84: 01 75 d0 add %esi,-0x30(%ebp) 10ef87: 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;
10ef8a: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10ef91: bb a0 86 01 00 mov $0x186a0,%ebx 10ef96: 8b 45 d0 mov -0x30(%ebp),%eax 10ef99: f7 e3 mul %ebx 10ef9b: 8d 34 11 lea (%ecx,%edx,1),%esi 10ef9e: ff 75 e4 pushl -0x1c(%ebp) 10efa1: ff 75 e0 pushl -0x20(%ebp) 10efa4: 56 push %esi 10efa5: 50 push %eax 10efa6: e8 71 1a 01 00 call 120a1c <__udivdi3> 10efab: 83 c4 10 add $0x10,%esp 10efae: 89 c3 mov %eax,%ebx 10efb0: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10efb2: 6a 00 push $0x0 10efb4: 68 e8 03 00 00 push $0x3e8 10efb9: 52 push %edx 10efba: 50 push %eax 10efbb: e8 5c 1a 01 00 call 120a1c <__udivdi3> 10efc0: 83 c4 10 add $0x10,%esp 10efc3: 8b 55 10 mov 0x10(%ebp),%edx 10efc6: 89 02 mov %eax,(%edx)
*fval_percentage = answer % 1000;
10efc8: 6a 00 push $0x0 10efca: 68 e8 03 00 00 push $0x3e8 10efcf: 56 push %esi 10efd0: 53 push %ebx 10efd1: e8 56 1b 01 00 call 120b2c <__umoddi3> 10efd6: 83 c4 10 add $0x10,%esp 10efd9: 8b 55 14 mov 0x14(%ebp),%edx 10efdc: 89 02 mov %eax,(%edx)
}
10efde: 8d 65 f4 lea -0xc(%ebp),%esp 10efe1: 5b pop %ebx 10efe2: 5e pop %esi 10efe3: 5f pop %edi 10efe4: c9 leave 10efe5: c3 ret 10efe6: 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;
10efe8: 8b 45 10 mov 0x10(%ebp),%eax 10efeb: c7 00 00 00 00 00 movl $0x0,(%eax)
*fval_percentage = 0;
10eff1: 8b 55 14 mov 0x14(%ebp),%edx 10eff4: c7 02 00 00 00 00 movl $0x0,(%edx)
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10effa: 8d 65 f4 lea -0xc(%ebp),%esp 10effd: 5b pop %ebx 10effe: 5e pop %esi 10efff: 5f pop %edi 10f000: c9 leave 10f001: c3 ret
00120258 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
120258: 55 push %ebp 120259: 89 e5 mov %esp,%ebp 12025b: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
12025e: 85 c0 test %eax,%eax
120260: 74 1a je 12027c <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
120262: 8b 10 mov (%eax),%edx 120264: 85 d2 test %edx,%edx
120266: 78 14 js 12027c <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
120268: 8b 40 04 mov 0x4(%eax),%eax 12026b: 85 c0 test %eax,%eax
12026d: 78 0d js 12027c <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
12026f: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 120274: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
120277: c9 leave 120278: c3 ret 120279: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
12027c: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
12027e: c9 leave 12027f: c3 ret
00111410 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
111410: 55 push %ebp 111411: 89 e5 mov %esp,%ebp 111413: 56 push %esi 111414: 53 push %ebx 111415: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
111418: 8b 33 mov (%ebx),%esi 11141a: 85 f6 test %esi,%esi
11141c: 75 07 jne 111425 <_Timespec_To_ticks+0x15>
11141e: 8b 43 04 mov 0x4(%ebx),%eax 111421: 85 c0 test %eax,%eax
111423: 74 37 je 11145c <_Timespec_To_ticks+0x4c>
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
111425: e8 4e 18 00 00 call 112c78 <TOD_TICKS_PER_SECOND_method> 11142a: 89 c1 mov %eax,%ecx 11142c: 0f af ce imul %esi,%ecx
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
11142f: a1 6c 35 12 00 mov 0x12356c,%eax 111434: 8d 04 80 lea (%eax,%eax,4),%eax 111437: 8d 04 80 lea (%eax,%eax,4),%eax 11143a: 8d 34 80 lea (%eax,%eax,4),%esi 11143d: c1 e6 03 shl $0x3,%esi 111440: 8b 43 04 mov 0x4(%ebx),%eax 111443: 31 d2 xor %edx,%edx 111445: f7 f6 div %esi
if (ticks)
111447: 01 c8 add %ecx,%eax
111449: 74 05 je 111450 <_Timespec_To_ticks+0x40>
return ticks;
return 1;
}
11144b: 5b pop %ebx 11144c: 5e pop %esi 11144d: c9 leave 11144e: c3 ret 11144f: 90 nop
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
if (ticks)
return ticks;
return 1;
111450: b8 01 00 00 00 mov $0x1,%eax
}
111455: 5b pop %ebx 111456: 5e pop %esi 111457: c9 leave 111458: c3 ret 111459: 8d 76 00 lea 0x0(%esi),%esi
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
11145c: 31 c0 xor %eax,%eax
if (ticks)
return ticks;
return 1;
}
11145e: 5b pop %ebx 11145f: 5e pop %esi 111460: c9 leave 111461: c3 ret
0010d990 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10d990: 55 push %ebp 10d991: 89 e5 mov %esp,%ebp 10d993: 57 push %edi 10d994: 56 push %esi 10d995: 53 push %ebx 10d996: 83 ec 1c sub $0x1c,%esp 10d999: 8b 75 08 mov 0x8(%ebp),%esi 10d99c: 8b 7d 10 mov 0x10(%ebp),%edi 10d99f: 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 );
}
}
10d9a2: 8b 1d 14 7a 12 00 mov 0x127a14,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d9a8: 81 fb 0c 7a 12 00 cmp $0x127a0c,%ebx
10d9ae: 74 25 je 10d9d5 <_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 );
10d9b0: 0f b6 c0 movzbl %al,%eax 10d9b3: 89 45 e4 mov %eax,-0x1c(%ebp) 10d9b6: 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 )
10d9b8: 8b 43 30 mov 0x30(%ebx),%eax 10d9bb: 85 c0 test %eax,%eax
10d9bd: 74 0b je 10d9ca <_User_extensions_Fatal+0x3a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10d9bf: 52 push %edx 10d9c0: 57 push %edi 10d9c1: ff 75 e4 pushl -0x1c(%ebp) 10d9c4: 56 push %esi 10d9c5: ff d0 call *%eax
10d9c7: 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 ) {
10d9ca: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d9cd: 81 fb 0c 7a 12 00 cmp $0x127a0c,%ebx
10d9d3: 75 e3 jne 10d9b8 <_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 );
}
}
10d9d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d9d8: 5b pop %ebx <== NOT EXECUTED 10d9d9: 5e pop %esi <== NOT EXECUTED 10d9da: 5f pop %edi <== NOT EXECUTED 10d9db: c9 leave <== NOT EXECUTED 10d9dc: c3 ret <== NOT EXECUTED
0010d854 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10d854: 55 push %ebp 10d855: 89 e5 mov %esp,%ebp 10d857: 57 push %edi 10d858: 56 push %esi 10d859: 53 push %ebx 10d85a: 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;
10d85d: a1 98 35 12 00 mov 0x123598,%eax 10d862: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10d865: 8b 35 9c 35 12 00 mov 0x12359c,%esi
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10d86b: c7 05 0c 7a 12 00 10 movl $0x127a10,0x127a0c
10d872: 7a 12 00 head->previous = NULL;
10d875: c7 05 10 7a 12 00 00 movl $0x0,0x127a10
10d87c: 00 00 00 tail->previous = head;
10d87f: c7 05 14 7a 12 00 0c movl $0x127a0c,0x127a14
10d886: 7a 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10d889: c7 05 f0 77 12 00 f4 movl $0x1277f4,0x1277f0
10d890: 77 12 00 head->previous = NULL;
10d893: c7 05 f4 77 12 00 00 movl $0x0,0x1277f4
10d89a: 00 00 00 tail->previous = head;
10d89d: c7 05 f8 77 12 00 f0 movl $0x1277f0,0x1277f8
10d8a4: 77 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10d8a7: 85 f6 test %esi,%esi
10d8a9: 74 64 je 10d90f <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10d8ab: 89 c2 mov %eax,%edx 10d8ad: 8d 04 40 lea (%eax,%eax,2),%eax 10d8b0: 8d 0c 82 lea (%edx,%eax,4),%ecx 10d8b3: c1 e1 02 shl $0x2,%ecx 10d8b6: 83 ec 0c sub $0xc,%esp 10d8b9: 51 push %ecx 10d8ba: 89 4d d8 mov %ecx,-0x28(%ebp) 10d8bd: e8 ce 04 00 00 call 10dd90 <_Workspace_Allocate_or_fatal_error> 10d8c2: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10d8c4: 31 c0 xor %eax,%eax 10d8c6: 8b 4d d8 mov -0x28(%ebp),%ecx 10d8c9: 89 df mov %ebx,%edi 10d8cb: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10d8cd: 83 c4 10 add $0x10,%esp 10d8d0: 8b 45 dc mov -0x24(%ebp),%eax 10d8d3: 85 c0 test %eax,%eax
10d8d5: 74 38 je 10d90f <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
10d8d7: 89 75 e4 mov %esi,-0x1c(%ebp) 10d8da: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10d8e1: 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;
10d8e4: 8d 7b 14 lea 0x14(%ebx),%edi 10d8e7: 8b 75 e4 mov -0x1c(%ebp),%esi 10d8ea: b9 08 00 00 00 mov $0x8,%ecx 10d8ef: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10d8f1: 83 ec 0c sub $0xc,%esp 10d8f4: 53 push %ebx 10d8f5: e8 6a 3b 00 00 call 111464 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10d8fa: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10d8fd: ff 45 e0 incl -0x20(%ebp) 10d900: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10d904: 83 c4 10 add $0x10,%esp 10d907: 8b 45 e0 mov -0x20(%ebp),%eax 10d90a: 39 45 dc cmp %eax,-0x24(%ebp)
10d90d: 77 d5 ja 10d8e4 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10d90f: 8d 65 f4 lea -0xc(%ebp),%esp 10d912: 5b pop %ebx 10d913: 5e pop %esi 10d914: 5f pop %edi 10d915: c9 leave 10d916: c3 ret
0010ece4 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10ece4: 55 push %ebp 10ece5: 89 e5 mov %esp,%ebp 10ece7: 53 push %ebx 10ece8: 83 ec 10 sub $0x10,%esp 10eceb: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10ecee: 53 push %ebx 10ecef: e8 9c db ff ff call 10c890 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10ecf4: 83 c4 10 add $0x10,%esp 10ecf7: 8b 43 24 mov 0x24(%ebx),%eax 10ecfa: 85 c0 test %eax,%eax
10ecfc: 74 12 je 10ed10 <_User_extensions_Remove_set+0x2c>
_Chain_Extract( &the_extension->Switch.Node );
10ecfe: 83 c3 08 add $0x8,%ebx 10ed01: 89 5d 08 mov %ebx,0x8(%ebp)
}
10ed04: 8b 5d fc mov -0x4(%ebp),%ebx 10ed07: c9 leave
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10ed08: e9 83 db ff ff jmp 10c890 <_Chain_Extract> 10ed0d: 8d 76 00 lea 0x0(%esi),%esi
}
10ed10: 8b 5d fc mov -0x4(%ebp),%ebx 10ed13: c9 leave 10ed14: c3 ret
0010d918 <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10d918: 55 push %ebp 10d919: 89 e5 mov %esp,%ebp 10d91b: 56 push %esi 10d91c: 53 push %ebx 10d91d: 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 );
}
}
10d920: 8b 1d 0c 7a 12 00 mov 0x127a0c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10d926: 81 fb 10 7a 12 00 cmp $0x127a10,%ebx
10d92c: 74 1c je 10d94a <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10d92e: 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 )
10d930: 8b 43 28 mov 0x28(%ebx),%eax 10d933: 85 c0 test %eax,%eax
10d935: 74 09 je 10d940 <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10d937: 83 ec 0c sub $0xc,%esp 10d93a: 56 push %esi 10d93b: ff d0 call *%eax 10d93d: 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 ) {
10d940: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10d942: 81 fb 10 7a 12 00 cmp $0x127a10,%ebx
10d948: 75 e6 jne 10d930 <_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 );
}
}
10d94a: 8d 65 f8 lea -0x8(%ebp),%esp 10d94d: 5b pop %ebx 10d94e: 5e pop %esi 10d94f: c9 leave 10d950: c3 ret
0010d9e0 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10d9e0: 55 push %ebp 10d9e1: 89 e5 mov %esp,%ebp 10d9e3: 56 push %esi 10d9e4: 53 push %ebx 10d9e5: 8b 75 08 mov 0x8(%ebp),%esi
return false;
}
}
return true;
}
10d9e8: 8b 1d 0c 7a 12 00 mov 0x127a0c,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10d9ee: 81 fb 10 7a 12 00 cmp $0x127a10,%ebx
10d9f4: 74 26 je 10da1c <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10d9f6: 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 ) {
10d9f8: 8b 43 14 mov 0x14(%ebx),%eax 10d9fb: 85 c0 test %eax,%eax
10d9fd: 74 13 je 10da12 <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10d9ff: 83 ec 08 sub $0x8,%esp 10da02: 56 push %esi 10da03: ff 35 98 7d 12 00 pushl 0x127d98 10da09: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10da0b: 83 c4 10 add $0x10,%esp 10da0e: 84 c0 test %al,%al
10da10: 74 16 je 10da28 <_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 ) {
10da12: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10da14: 81 fb 10 7a 12 00 cmp $0x127a10,%ebx
10da1a: 75 dc jne 10d9f8 <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10da1c: b0 01 mov $0x1,%al
}
10da1e: 8d 65 f8 lea -0x8(%ebp),%esp 10da21: 5b pop %ebx 10da22: 5e pop %esi 10da23: c9 leave 10da24: c3 ret 10da25: 8d 76 00 lea 0x0(%esi),%esi
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
10da28: 31 c0 xor %eax,%eax
}
}
return true;
}
10da2a: 8d 65 f8 lea -0x8(%ebp),%esp 10da2d: 5b pop %ebx 10da2e: 5e pop %esi 10da2f: c9 leave 10da30: c3 ret
0010da34 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10da34: 55 push %ebp 10da35: 89 e5 mov %esp,%ebp 10da37: 56 push %esi 10da38: 53 push %ebx 10da39: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10da3c: 8b 1d 14 7a 12 00 mov 0x127a14,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10da42: 81 fb 0c 7a 12 00 cmp $0x127a0c,%ebx
10da48: 74 23 je 10da6d <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10da4a: 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 )
10da4c: 8b 43 20 mov 0x20(%ebx),%eax 10da4f: 85 c0 test %eax,%eax
10da51: 74 0f je 10da62 <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10da53: 83 ec 08 sub $0x8,%esp 10da56: 56 push %esi 10da57: ff 35 98 7d 12 00 pushl 0x127d98 10da5d: ff d0 call *%eax 10da5f: 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 ) {
10da62: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10da65: 81 fb 0c 7a 12 00 cmp $0x127a0c,%ebx
10da6b: 75 df jne 10da4c <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10da6d: 8d 65 f8 lea -0x8(%ebp),%esp 10da70: 5b pop %ebx 10da71: 5e pop %esi 10da72: c9 leave 10da73: c3 ret
0010d954 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10d954: 55 push %ebp 10d955: 89 e5 mov %esp,%ebp 10d957: 56 push %esi 10d958: 53 push %ebx 10d959: 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 );
}
}
10d95c: 8b 1d 14 7a 12 00 mov 0x127a14,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d962: 81 fb 0c 7a 12 00 cmp $0x127a0c,%ebx
10d968: 74 1d je 10d987 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10d96a: 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 )
10d96c: 8b 43 2c mov 0x2c(%ebx),%eax 10d96f: 85 c0 test %eax,%eax
10d971: 74 09 je 10d97c <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10d973: 83 ec 0c sub $0xc,%esp 10d976: 56 push %esi 10d977: ff d0 call *%eax 10d979: 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 ) {
10d97c: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d97f: 81 fb 0c 7a 12 00 cmp $0x127a0c,%ebx
10d985: 75 e5 jne 10d96c <_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 );
}
}
10d987: 8d 65 f8 lea -0x8(%ebp),%esp 10d98a: 5b pop %ebx 10d98b: 5e pop %esi 10d98c: c9 leave 10d98d: c3 ret
0010e5c0 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10e5c0: 55 push %ebp 10e5c1: 89 e5 mov %esp,%ebp 10e5c3: 56 push %esi 10e5c4: 53 push %ebx 10e5c5: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10e5c8: 8b 1d ac 9c 12 00 mov 0x129cac,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e5ce: 81 fb b0 9c 12 00 cmp $0x129cb0,%ebx
10e5d4: 74 22 je 10e5f8 <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10e5d6: 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 )
10e5d8: 8b 43 1c mov 0x1c(%ebx),%eax 10e5db: 85 c0 test %eax,%eax
10e5dd: 74 0f je 10e5ee <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10e5df: 83 ec 08 sub $0x8,%esp 10e5e2: 56 push %esi 10e5e3: ff 35 38 a0 12 00 pushl 0x12a038 10e5e9: ff d0 call *%eax 10e5eb: 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 ) {
10e5ee: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e5f0: 81 fb b0 9c 12 00 cmp $0x129cb0,%ebx
10e5f6: 75 e0 jne 10e5d8 <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10e5f8: 8d 65 f8 lea -0x8(%ebp),%esp 10e5fb: 5b pop %ebx 10e5fc: 5e pop %esi 10e5fd: c9 leave 10e5fe: c3 ret
0010da74 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10da74: 55 push %ebp 10da75: 89 e5 mov %esp,%ebp 10da77: 56 push %esi 10da78: 53 push %ebx 10da79: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10da7c: 8b 1d 0c 7a 12 00 mov 0x127a0c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10da82: 81 fb 10 7a 12 00 cmp $0x127a10,%ebx
10da88: 74 22 je 10daac <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10da8a: 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 )
10da8c: 8b 43 18 mov 0x18(%ebx),%eax 10da8f: 85 c0 test %eax,%eax
10da91: 74 0f je 10daa2 <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10da93: 83 ec 08 sub $0x8,%esp 10da96: 56 push %esi 10da97: ff 35 98 7d 12 00 pushl 0x127d98 10da9d: ff d0 call *%eax 10da9f: 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 ) {
10daa2: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10daa4: 81 fb 10 7a 12 00 cmp $0x127a10,%ebx
10daaa: 75 e0 jne 10da8c <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10daac: 8d 65 f8 lea -0x8(%ebp),%esp 10daaf: 5b pop %ebx 10dab0: 5e pop %esi 10dab1: c9 leave 10dab2: c3 ret
0010dab4 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10dab4: 55 push %ebp 10dab5: 89 e5 mov %esp,%ebp 10dab7: 57 push %edi 10dab8: 56 push %esi 10dab9: 53 push %ebx 10daba: 83 ec 0c sub $0xc,%esp 10dabd: 8b 7d 08 mov 0x8(%ebp),%edi 10dac0: 8b 75 0c mov 0xc(%ebp),%esi
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10dac3: 8b 1d f0 77 12 00 mov 0x1277f0,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10dac9: 81 fb f4 77 12 00 cmp $0x1277f4,%ebx
10dacf: 74 18 je 10dae9 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10dad1: 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 );
10dad4: 83 ec 08 sub $0x8,%esp 10dad7: 56 push %esi 10dad8: 57 push %edi 10dad9: 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 ) {
10dadc: 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 );
10dade: 83 c4 10 add $0x10,%esp 10dae1: 81 fb f4 77 12 00 cmp $0x1277f4,%ebx
10dae7: 75 eb jne 10dad4 <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10dae9: 8d 65 f4 lea -0xc(%ebp),%esp 10daec: 5b pop %ebx 10daed: 5e pop %esi 10daee: 5f pop %edi 10daef: c9 leave 10daf0: c3 ret
0010f320 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10f320: 55 push %ebp 10f321: 89 e5 mov %esp,%ebp 10f323: 57 push %edi 10f324: 56 push %esi 10f325: 53 push %ebx 10f326: 83 ec 1c sub $0x1c,%esp 10f329: 8b 75 08 mov 0x8(%ebp),%esi 10f32c: 8b 4d 0c mov 0xc(%ebp),%ecx 10f32f: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10f332: 9c pushf 10f333: fa cli 10f334: 58 pop %eax
}
}
_ISR_Enable( level );
}
10f335: 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 );
10f337: 8d 7e 04 lea 0x4(%esi),%edi 10f33a: 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 ) ) {
10f33d: 39 fa cmp %edi,%edx
10f33f: 74 3d je 10f37e <_Watchdog_Adjust+0x5e>
switch ( direction ) {
10f341: 85 c9 test %ecx,%ecx
10f343: 75 43 jne 10f388 <_Watchdog_Adjust+0x68>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10f345: 85 db test %ebx,%ebx
10f347: 74 35 je 10f37e <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10f349: 8b 7a 10 mov 0x10(%edx),%edi 10f34c: 39 fb cmp %edi,%ebx
10f34e: 73 0f jae 10f35f <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
10f350: eb 3e jmp 10f390 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 10f352: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10f354: 29 fb sub %edi,%ebx
10f356: 74 26 je 10f37e <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10f358: 8b 7a 10 mov 0x10(%edx),%edi 10f35b: 39 df cmp %ebx,%edi
10f35d: 77 31 ja 10f390 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10f35f: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10f366: 50 push %eax 10f367: 9d popf
_Watchdog_Tickle( header );
10f368: 83 ec 0c sub $0xc,%esp 10f36b: 56 push %esi 10f36c: e8 d3 01 00 00 call 10f544 <_Watchdog_Tickle>
_ISR_Disable( level );
10f371: 9c pushf 10f372: fa cli 10f373: 58 pop %eax
}
}
_ISR_Enable( level );
}
10f374: 8b 16 mov (%esi),%edx
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10f376: 83 c4 10 add $0x10,%esp 10f379: 39 55 e4 cmp %edx,-0x1c(%ebp)
10f37c: 75 d6 jne 10f354 <_Watchdog_Adjust+0x34>
}
break;
}
}
_ISR_Enable( level );
10f37e: 50 push %eax 10f37f: 9d popf
}
10f380: 8d 65 f4 lea -0xc(%ebp),%esp 10f383: 5b pop %ebx 10f384: 5e pop %esi 10f385: 5f pop %edi 10f386: c9 leave 10f387: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
10f388: 49 dec %ecx
10f389: 75 f3 jne 10f37e <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10f38b: 01 5a 10 add %ebx,0x10(%edx)
break;
10f38e: eb ee jmp 10f37e <_Watchdog_Adjust+0x5e>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
10f390: 29 df sub %ebx,%edi 10f392: 89 7a 10 mov %edi,0x10(%edx)
break;
10f395: eb e7 jmp 10f37e <_Watchdog_Adjust+0x5e>
0010daf4 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10daf4: 55 push %ebp 10daf5: 89 e5 mov %esp,%ebp 10daf7: 57 push %edi 10daf8: 56 push %esi 10daf9: 53 push %ebx 10dafa: 83 ec 04 sub $0x4,%esp 10dafd: 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;
10db00: 8b 3d 94 7d 12 00 mov 0x127d94,%edi
_ISR_Disable( level );
10db06: 9c pushf 10db07: fa cli 10db08: 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 ) {
10db0b: 8b 43 08 mov 0x8(%ebx),%eax 10db0e: 85 c0 test %eax,%eax
10db10: 0f 85 9e 00 00 00 jne 10dbb4 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10db16: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
_Watchdog_Sync_count++;
10db1d: a1 20 79 12 00 mov 0x127920,%eax 10db22: 40 inc %eax 10db23: a3 20 79 12 00 mov %eax,0x127920
restart:
delta_interval = the_watchdog->initial;
10db28: 8b 43 0c mov 0xc(%ebx),%eax
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10db2b: 8b 4d 08 mov 0x8(%ebp),%ecx 10db2e: 8b 11 mov (%ecx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10db30: 85 c0 test %eax,%eax
10db32: 74 5d je 10db91 <_Watchdog_Insert+0x9d>
10db34: 8b 32 mov (%edx),%esi 10db36: 85 f6 test %esi,%esi
10db38: 74 57 je 10db91 <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10db3a: 8b 4a 10 mov 0x10(%edx),%ecx 10db3d: 39 c8 cmp %ecx,%eax
10db3f: 73 22 jae 10db63 <_Watchdog_Insert+0x6f>
10db41: eb 49 jmp 10db8c <_Watchdog_Insert+0x98> 10db43: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10db44: 8b 35 a4 78 12 00 mov 0x1278a4,%esi 10db4a: 39 f7 cmp %esi,%edi
10db4c: 72 72 jb 10dbc0 <_Watchdog_Insert+0xcc>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10db4e: 29 c8 sub %ecx,%eax
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10db50: 8b 12 mov (%edx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10db52: 85 c0 test %eax,%eax
10db54: 74 3b je 10db91 <_Watchdog_Insert+0x9d>
10db56: 8b 0a mov (%edx),%ecx 10db58: 85 c9 test %ecx,%ecx
10db5a: 74 35 je 10db91 <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10db5c: 8b 4a 10 mov 0x10(%edx),%ecx 10db5f: 39 c1 cmp %eax,%ecx
10db61: 77 29 ja 10db8c <_Watchdog_Insert+0x98>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
10db63: ff 75 f0 pushl -0x10(%ebp) 10db66: 9d popf 10db67: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10db68: 83 7b 08 01 cmpl $0x1,0x8(%ebx)
10db6c: 74 d6 je 10db44 <_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;
10db6e: 89 3d a4 78 12 00 mov %edi,0x1278a4
_Watchdog_Sync_count--;
10db74: a1 20 79 12 00 mov 0x127920,%eax 10db79: 48 dec %eax 10db7a: a3 20 79 12 00 mov %eax,0x127920
_ISR_Enable( level );
10db7f: ff 75 f0 pushl -0x10(%ebp) 10db82: 9d popf
}
10db83: 58 pop %eax 10db84: 5b pop %ebx 10db85: 5e pop %esi 10db86: 5f pop %edi 10db87: c9 leave 10db88: c3 ret 10db89: 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;
10db8c: 29 c1 sub %eax,%ecx 10db8e: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
10db91: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10db98: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10db9b: 8b 42 04 mov 0x4(%edx),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10db9e: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10dba1: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10dba3: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10dba5: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10dba7: 89 5a 04 mov %ebx,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10dbaa: a1 24 79 12 00 mov 0x127924,%eax 10dbaf: 89 43 14 mov %eax,0x14(%ebx) 10dbb2: eb ba jmp 10db6e <_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 );
10dbb4: ff 75 f0 pushl -0x10(%ebp) 10dbb7: 9d popf
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10dbb8: 58 pop %eax 10dbb9: 5b pop %ebx 10dbba: 5e pop %esi 10dbbb: 5f pop %edi 10dbbc: c9 leave 10dbbd: c3 ret 10dbbe: 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;
10dbc0: 89 3d a4 78 12 00 mov %edi,0x1278a4
goto restart;
10dbc6: e9 5d ff ff ff jmp 10db28 <_Watchdog_Insert+0x34>
0010dc34 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10dc34: 55 push %ebp 10dc35: 89 e5 mov %esp,%ebp 10dc37: 56 push %esi 10dc38: 53 push %ebx 10dc39: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10dc3c: 9c pushf 10dc3d: fa cli 10dc3e: 59 pop %ecx
previous_state = the_watchdog->state;
10dc3f: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10dc42: 83 f8 01 cmp $0x1,%eax
10dc45: 74 4d je 10dc94 <_Watchdog_Remove+0x60>
10dc47: 73 0f jae 10dc58 <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10dc49: 8b 1d 24 79 12 00 mov 0x127924,%ebx 10dc4f: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10dc52: 51 push %ecx 10dc53: 9d popf
return( previous_state ); }
10dc54: 5b pop %ebx 10dc55: 5e pop %esi 10dc56: c9 leave 10dc57: c3 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10dc58: 83 f8 03 cmp $0x3,%eax
10dc5b: 77 ec ja 10dc49 <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10dc5d: 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 );
}
10dc64: 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) )
10dc66: 8b 33 mov (%ebx),%esi 10dc68: 85 f6 test %esi,%esi
10dc6a: 74 06 je 10dc72 <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10dc6c: 8b 72 10 mov 0x10(%edx),%esi 10dc6f: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10dc72: 8b 35 20 79 12 00 mov 0x127920,%esi 10dc78: 85 f6 test %esi,%esi
10dc7a: 74 0c je 10dc88 <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10dc7c: 8b 35 94 7d 12 00 mov 0x127d94,%esi 10dc82: 89 35 a4 78 12 00 mov %esi,0x1278a4
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10dc88: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10dc8b: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10dc8e: 89 1e mov %ebx,(%esi) 10dc90: eb b7 jmp 10dc49 <_Watchdog_Remove+0x15> 10dc92: 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;
10dc94: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10dc9b: eb ac jmp 10dc49 <_Watchdog_Remove+0x15>
0010ef58 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
10ef58: 55 push %ebp 10ef59: 89 e5 mov %esp,%ebp 10ef5b: 57 push %edi 10ef5c: 56 push %esi 10ef5d: 53 push %ebx 10ef5e: 83 ec 2c sub $0x2c,%esp 10ef61: 8b 55 08 mov 0x8(%ebp),%edx 10ef64: 8b 45 0c mov 0xc(%ebp),%eax
printk(
10ef67: 8b 78 24 mov 0x24(%eax),%edi 10ef6a: 8b 70 20 mov 0x20(%eax),%esi 10ef6d: 8b 58 1c mov 0x1c(%eax),%ebx 10ef70: 8b 48 0c mov 0xc(%eax),%ecx 10ef73: 89 4d d4 mov %ecx,-0x2c(%ebp) 10ef76: 8b 48 10 mov 0x10(%eax),%ecx 10ef79: 89 4d e4 mov %ecx,-0x1c(%ebp) 10ef7c: 85 d2 test %edx,%edx
10ef7e: 74 2c je 10efac <_Watchdog_Report+0x54>
10ef80: b9 03 2f 12 00 mov $0x122f03,%ecx 10ef85: 83 ec 0c sub $0xc,%esp 10ef88: 57 push %edi 10ef89: 56 push %esi 10ef8a: 53 push %ebx 10ef8b: 50 push %eax 10ef8c: ff 75 d4 pushl -0x2c(%ebp) 10ef8f: ff 75 e4 pushl -0x1c(%ebp) 10ef92: 51 push %ecx 10ef93: 52 push %edx 10ef94: 68 56 39 12 00 push $0x123956 10ef99: e8 92 a0 ff ff call 109030 <printk> 10ef9e: 83 c4 30 add $0x30,%esp
watch,
watch->routine,
watch->id,
watch->user_data
);
}
10efa1: 8d 65 f4 lea -0xc(%ebp),%esp 10efa4: 5b pop %ebx 10efa5: 5e pop %esi 10efa6: 5f pop %edi 10efa7: c9 leave 10efa8: c3 ret 10efa9: 8d 76 00 lea 0x0(%esi),%esi
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
printk(
10efac: b9 c9 37 12 00 mov $0x1237c9,%ecx 10efb1: 89 ca mov %ecx,%edx 10efb3: eb d0 jmp 10ef85 <_Watchdog_Report+0x2d>
0010eee8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10eee8: 55 push %ebp 10eee9: 89 e5 mov %esp,%ebp 10eeeb: 57 push %edi 10eeec: 56 push %esi 10eeed: 53 push %ebx 10eeee: 83 ec 20 sub $0x20,%esp 10eef1: 8b 7d 08 mov 0x8(%ebp),%edi 10eef4: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10eef7: 9c pushf 10eef8: fa cli 10eef9: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10eefc: 56 push %esi 10eefd: 57 push %edi 10eefe: 68 20 39 12 00 push $0x123920 10ef03: e8 28 a1 ff ff call 109030 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10ef08: 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 );
10ef0a: 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 ) ) {
10ef0d: 83 c4 10 add $0x10,%esp 10ef10: 39 f3 cmp %esi,%ebx
10ef12: 74 31 je 10ef45 <_Watchdog_Report_chain+0x5d>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10ef14: 83 ec 08 sub $0x8,%esp 10ef17: 53 push %ebx 10ef18: 6a 00 push $0x0 10ef1a: e8 39 00 00 00 call 10ef58 <_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 )
10ef1f: 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 ) ;
10ef21: 83 c4 10 add $0x10,%esp 10ef24: 39 f3 cmp %esi,%ebx
10ef26: 75 ec jne 10ef14 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10ef28: 83 ec 08 sub $0x8,%esp 10ef2b: 57 push %edi 10ef2c: 68 37 39 12 00 push $0x123937 10ef31: e8 fa a0 ff ff call 109030 <printk> 10ef36: 83 c4 10 add $0x10,%esp
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10ef39: ff 75 e4 pushl -0x1c(%ebp) 10ef3c: 9d popf
}
10ef3d: 8d 65 f4 lea -0xc(%ebp),%esp 10ef40: 5b pop %ebx 10ef41: 5e pop %esi 10ef42: 5f pop %edi 10ef43: c9 leave 10ef44: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10ef45: 83 ec 0c sub $0xc,%esp 10ef48: 68 46 39 12 00 push $0x123946 10ef4d: e8 de a0 ff ff call 109030 <printk> 10ef52: 83 c4 10 add $0x10,%esp 10ef55: eb e2 jmp 10ef39 <_Watchdog_Report_chain+0x51>
0010dd0c <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10dd0c: 55 push %ebp 10dd0d: 89 e5 mov %esp,%ebp 10dd0f: 57 push %edi 10dd10: 53 push %ebx
uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start;
10dd11: 8b 1d 60 35 12 00 mov 0x123560,%ebx
uintptr_t size = Configuration.work_space_size;
10dd17: 8b 15 64 35 12 00 mov 0x123564,%edx
if ( Configuration.do_zero_of_workspace )
10dd1d: 80 3d 88 35 12 00 00 cmpb $0x0,0x123588
10dd24: 75 1e jne 10dd44 <_Workspace_Handler_initialization+0x38>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10dd26: 6a 04 push $0x4 10dd28: 52 push %edx 10dd29: 53 push %ebx 10dd2a: 68 20 78 12 00 push $0x127820 10dd2f: e8 78 dd ff ff call 10baac <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10dd34: 83 c4 10 add $0x10,%esp 10dd37: 85 c0 test %eax,%eax
10dd39: 74 13 je 10dd4e <_Workspace_Handler_initialization+0x42>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10dd3b: 8d 65 f8 lea -0x8(%ebp),%esp 10dd3e: 5b pop %ebx 10dd3f: 5f pop %edi 10dd40: c9 leave 10dd41: c3 ret 10dd42: 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 );
10dd44: 31 c0 xor %eax,%eax 10dd46: 89 df mov %ebx,%edi 10dd48: 89 d1 mov %edx,%ecx 10dd4a: f3 aa rep stos %al,%es:(%edi) 10dd4c: eb d8 jmp 10dd26 <_Workspace_Handler_initialization+0x1a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10dd4e: 50 push %eax 10dd4f: 6a 02 push $0x2 10dd51: 6a 01 push $0x1 10dd53: 6a 00 push $0x0 10dd55: e8 5a df ff ff call 10bcb4 <_Internal_error_Occurred>
0010ab7c <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
10ab7c: 55 push %ebp 10ab7d: 89 e5 mov %esp,%ebp 10ab7f: 57 push %edi 10ab80: 56 push %esi 10ab81: 53 push %ebx 10ab82: 83 ec 1c sub $0x1c,%esp 10ab85: 8b 5d 08 mov 0x8(%ebp),%ebx 10ab88: 8b 75 0c mov 0xc(%ebp),%esi
long adjustment;
/*
* Simple validations
*/
if ( !delta )
10ab8b: 85 db test %ebx,%ebx
10ab8d: 0f 84 f1 00 00 00 je 10ac84 <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
10ab93: 8b 53 04 mov 0x4(%ebx),%edx 10ab96: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx
10ab9c: 0f 87 e2 00 00 00 ja 10ac84 <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
10aba2: 85 f6 test %esi,%esi
10aba4: 74 10 je 10abb6 <adjtime+0x3a>
olddelta->tv_sec = 0;
10aba6: c7 06 00 00 00 00 movl $0x0,(%esi)
olddelta->tv_usec = 0;
10abac: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) 10abb3: 8b 53 04 mov 0x4(%ebx),%edx
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
10abb6: 8b 03 mov (%ebx),%eax 10abb8: 8d 04 80 lea (%eax,%eax,4),%eax 10abbb: 8d 04 80 lea (%eax,%eax,4),%eax 10abbe: 8d 04 80 lea (%eax,%eax,4),%eax 10abc1: 8d 04 80 lea (%eax,%eax,4),%eax 10abc4: 8d 04 80 lea (%eax,%eax,4),%eax 10abc7: 8d 04 80 lea (%eax,%eax,4),%eax 10abca: c1 e0 06 shl $0x6,%eax
adjustment += delta->tv_usec;
10abcd: 8d 04 02 lea (%edx,%eax,1),%eax
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
10abd0: 3b 05 ec 49 12 00 cmp 0x1249ec,%eax
10abd6: 73 0c jae 10abe4 <adjtime+0x68>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
10abd8: 31 c0 xor %eax,%eax
}
10abda: 8d 65 f4 lea -0xc(%ebp),%esp 10abdd: 5b pop %ebx 10abde: 5e pop %esi 10abdf: 5f pop %edi 10abe0: c9 leave 10abe1: c3 ret 10abe2: 66 90 xchg %ax,%ax
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10abe4: a1 ac 8d 12 00 mov 0x128dac,%eax 10abe9: 40 inc %eax 10abea: a3 ac 8d 12 00 mov %eax,0x128dac
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
10abef: 83 ec 0c sub $0xc,%esp 10abf2: 8d 7d e0 lea -0x20(%ebp),%edi 10abf5: 57 push %edi 10abf6: e8 9d 15 00 00 call 10c198 <_TOD_Get>
ts.tv_sec += delta->tv_sec;
10abfb: 8b 03 mov (%ebx),%eax 10abfd: 01 45 e0 add %eax,-0x20(%ebp)
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
10ac00: 8b 43 04 mov 0x4(%ebx),%eax 10ac03: 8d 04 80 lea (%eax,%eax,4),%eax 10ac06: 8d 04 80 lea (%eax,%eax,4),%eax 10ac09: 8d 04 80 lea (%eax,%eax,4),%eax 10ac0c: c1 e0 03 shl $0x3,%eax 10ac0f: 03 45 e4 add -0x1c(%ebp),%eax 10ac12: 89 45 e4 mov %eax,-0x1c(%ebp)
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10ac15: 83 c4 10 add $0x10,%esp 10ac18: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10ac1d: 76 18 jbe 10ac37 <adjtime+0xbb>
10ac1f: 8b 55 e0 mov -0x20(%ebp),%edx 10ac22: 66 90 xchg %ax,%ax
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
10ac24: 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(
10ac29: 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 ) {
10ac2a: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10ac2f: 77 f3 ja 10ac24 <adjtime+0xa8> <== NEVER TAKEN
10ac31: 89 45 e4 mov %eax,-0x1c(%ebp) 10ac34: 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) ) {
10ac37: 3d 00 36 65 c4 cmp $0xc4653600,%eax
10ac3c: 77 19 ja 10ac57 <adjtime+0xdb> <== NEVER TAKEN
10ac3e: 8b 55 e0 mov -0x20(%ebp),%edx 10ac41: 8d 76 00 lea 0x0(%esi),%esi
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
10ac44: 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(
10ac49: 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) ) {
10ac4a: 3d 00 36 65 c4 cmp $0xc4653600,%eax
10ac4f: 76 f3 jbe 10ac44 <adjtime+0xc8>
10ac51: 89 45 e4 mov %eax,-0x1c(%ebp) 10ac54: 89 55 e0 mov %edx,-0x20(%ebp)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
10ac57: 83 ec 0c sub $0xc,%esp 10ac5a: 57 push %edi 10ac5b: e8 c0 15 00 00 call 10c220 <_TOD_Set>
_Thread_Enable_dispatch();
10ac60: e8 5b 2a 00 00 call 10d6c0 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
10ac65: 83 c4 10 add $0x10,%esp 10ac68: 85 f6 test %esi,%esi
10ac6a: 0f 84 68 ff ff ff je 10abd8 <adjtime+0x5c>
*olddelta = *delta;
10ac70: 8b 03 mov (%ebx),%eax 10ac72: 8b 53 04 mov 0x4(%ebx),%edx 10ac75: 89 06 mov %eax,(%esi) 10ac77: 89 56 04 mov %edx,0x4(%esi)
return 0;
10ac7a: 31 c0 xor %eax,%eax
}
10ac7c: 8d 65 f4 lea -0xc(%ebp),%esp 10ac7f: 5b pop %ebx 10ac80: 5e pop %esi 10ac81: 5f pop %edi 10ac82: c9 leave 10ac83: 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 );
10ac84: e8 0f 8c 00 00 call 113898 <__errno> 10ac89: c7 00 16 00 00 00 movl $0x16,(%eax) 10ac8f: b8 ff ff ff ff mov $0xffffffff,%eax 10ac94: e9 41 ff ff ff jmp 10abda <adjtime+0x5e>
0010b2bc <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10b2bc: 55 push %ebp 10b2bd: 89 e5 mov %esp,%ebp 10b2bf: 57 push %edi 10b2c0: 56 push %esi 10b2c1: 53 push %ebx 10b2c2: 83 ec 18 sub $0x18,%esp 10b2c5: 8b 75 08 mov 0x8(%ebp),%esi 10b2c8: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10b2cb: 68 a0 94 12 00 push $0x1294a0 10b2d0: e8 bf 11 00 00 call 10c494 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10b2d5: 5a pop %edx 10b2d6: 59 pop %ecx 10b2d7: 6a 01 push $0x1 10b2d9: 56 push %esi 10b2da: e8 65 6a 00 00 call 111d44 <fcntl> 10b2df: 83 c4 10 add $0x10,%esp 10b2e2: 85 c0 test %eax,%eax
10b2e4: 0f 88 9b 01 00 00 js 10b485 <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) {
10b2ea: 85 db test %ebx,%ebx
10b2ec: 0f 84 ea 00 00 00 je 10b3dc <aio_cancel+0x120>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10b2f2: 8b 3b mov (%ebx),%edi 10b2f4: 39 f7 cmp %esi,%edi
10b2f6: 0f 85 b8 00 00 00 jne 10b3b4 <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);
10b2fc: 56 push %esi 10b2fd: 6a 00 push $0x0 10b2ff: 57 push %edi 10b300: 68 e8 94 12 00 push $0x1294e8 10b305: e8 9e 03 00 00 call 10b6a8 <rtems_aio_search_fd> 10b30a: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10b30c: 83 c4 10 add $0x10,%esp 10b30f: 85 c0 test %eax,%eax
10b311: 74 3d je 10b350 <aio_cancel+0x94>
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10b313: 8d 78 1c lea 0x1c(%eax),%edi 10b316: 83 ec 0c sub $0xc,%esp 10b319: 57 push %edi 10b31a: e8 75 11 00 00 call 10c494 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10b31f: 58 pop %eax 10b320: 5a pop %edx 10b321: 53 push %ebx 10b322: 83 c6 08 add $0x8,%esi 10b325: 56 push %esi 10b326: e8 5d 07 00 00 call 10ba88 <rtems_aio_remove_req> 10b32b: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10b32d: 89 3c 24 mov %edi,(%esp) 10b330: e8 e7 11 00 00 call 10c51c <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10b335: c7 04 24 a0 94 12 00 movl $0x1294a0,(%esp) 10b33c: e8 db 11 00 00 call 10c51c <pthread_mutex_unlock>
return result;
10b341: 83 c4 10 add $0x10,%esp
} return AIO_ALLDONE; }
10b344: 89 d8 mov %ebx,%eax 10b346: 8d 65 f4 lea -0xc(%ebp),%esp 10b349: 5b pop %ebx 10b34a: 5e pop %esi 10b34b: 5f pop %edi 10b34c: c9 leave 10b34d: c3 ret 10b34e: 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)) {
10b350: 81 3d f4 94 12 00 f8 cmpl $0x1294f8,0x1294f4
10b357: 94 12 00
10b35a: 74 40 je 10b39c <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10b35c: 51 push %ecx 10b35d: 6a 00 push $0x0 10b35f: 57 push %edi 10b360: 68 f4 94 12 00 push $0x1294f4 10b365: e8 3e 03 00 00 call 10b6a8 <rtems_aio_search_fd>
if (r_chain == NULL) {
10b36a: 83 c4 10 add $0x10,%esp 10b36d: 85 c0 test %eax,%eax
10b36f: 74 43 je 10b3b4 <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);
10b371: 83 ec 08 sub $0x8,%esp 10b374: 53 push %ebx 10b375: 83 c0 08 add $0x8,%eax 10b378: 50 push %eax 10b379: e8 0a 07 00 00 call 10ba88 <rtems_aio_remove_req> 10b37e: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
10b380: c7 04 24 a0 94 12 00 movl $0x1294a0,(%esp) 10b387: e8 90 11 00 00 call 10c51c <pthread_mutex_unlock>
return result;
10b38c: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
10b38f: 89 d8 mov %ebx,%eax 10b391: 8d 65 f4 lea -0xc(%ebp),%esp 10b394: 5b pop %ebx 10b395: 5e pop %esi 10b396: 5f pop %edi 10b397: c9 leave 10b398: c3 ret 10b399: 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);
10b39c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b39f: 68 a0 94 12 00 push $0x1294a0 <== NOT EXECUTED 10b3a4: e8 73 11 00 00 call 10c51c <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10b3a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3ac: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10b3b1: eb 91 jmp 10b344 <aio_cancel+0x88> <== NOT EXECUTED 10b3b3: 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);
10b3b4: 83 ec 0c sub $0xc,%esp 10b3b7: 68 a0 94 12 00 push $0x1294a0 10b3bc: e8 5b 11 00 00 call 10c51c <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10b3c1: e8 36 a3 00 00 call 1156fc <__errno> 10b3c6: c7 00 16 00 00 00 movl $0x16,(%eax) 10b3cc: 83 c4 10 add $0x10,%esp 10b3cf: bb ff ff ff ff mov $0xffffffff,%ebx 10b3d4: e9 6b ff ff ff jmp 10b344 <aio_cancel+0x88> 10b3d9: 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);
10b3dc: 50 push %eax 10b3dd: 6a 00 push $0x0 10b3df: 56 push %esi 10b3e0: 68 e8 94 12 00 push $0x1294e8 10b3e5: e8 be 02 00 00 call 10b6a8 <rtems_aio_search_fd> 10b3ea: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10b3ec: 83 c4 10 add $0x10,%esp 10b3ef: 85 c0 test %eax,%eax
10b3f1: 74 3d je 10b430 <aio_cancel+0x174>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10b3f3: 8d 70 1c lea 0x1c(%eax),%esi 10b3f6: 83 ec 0c sub $0xc,%esp 10b3f9: 56 push %esi 10b3fa: e8 95 10 00 00 call 10c494 <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10b3ff: 89 1c 24 mov %ebx,(%esp) 10b402: e8 a5 29 00 00 call 10ddac <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10b407: 89 1c 24 mov %ebx,(%esp) 10b40a: e8 29 06 00 00 call 10ba38 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10b40f: 89 34 24 mov %esi,(%esp) 10b412: e8 05 11 00 00 call 10c51c <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10b417: c7 04 24 a0 94 12 00 movl $0x1294a0,(%esp) 10b41e: e8 f9 10 00 00 call 10c51c <pthread_mutex_unlock>
return AIO_CANCELED;
10b423: 83 c4 10 add $0x10,%esp 10b426: 31 db xor %ebx,%ebx 10b428: e9 17 ff ff ff jmp 10b344 <aio_cancel+0x88> 10b42d: 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)) {
10b430: 81 3d f4 94 12 00 f8 cmpl $0x1294f8,0x1294f4
10b437: 94 12 00
10b43a: 0f 84 5c ff ff ff je 10b39c <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10b440: 57 push %edi 10b441: 6a 00 push $0x0 10b443: 56 push %esi 10b444: 68 f4 94 12 00 push $0x1294f4 10b449: e8 5a 02 00 00 call 10b6a8 <rtems_aio_search_fd> 10b44e: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10b450: 83 c4 10 add $0x10,%esp 10b453: 85 c0 test %eax,%eax
10b455: 74 53 je 10b4aa <aio_cancel+0x1ee>
10b457: 83 ec 0c sub $0xc,%esp 10b45a: 50 push %eax 10b45b: e8 4c 29 00 00 call 10ddac <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10b460: 89 1c 24 mov %ebx,(%esp) 10b463: e8 d0 05 00 00 call 10ba38 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10b468: 8d 73 1c lea 0x1c(%ebx),%esi 10b46b: 89 34 24 mov %esi,(%esp) 10b46e: e8 b5 0d 00 00 call 10c228 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10b473: 89 34 24 mov %esi,(%esp) 10b476: e8 69 0a 00 00 call 10bee4 <pthread_cond_destroy>
free (r_chain);
10b47b: 89 1c 24 mov %ebx,(%esp) 10b47e: e8 31 cc ff ff call 1080b4 <free> 10b483: eb 92 jmp 10b417 <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);
10b485: 83 ec 0c sub $0xc,%esp 10b488: 68 a0 94 12 00 push $0x1294a0 10b48d: e8 8a 10 00 00 call 10c51c <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10b492: e8 65 a2 00 00 call 1156fc <__errno> 10b497: c7 00 09 00 00 00 movl $0x9,(%eax) 10b49d: 83 c4 10 add $0x10,%esp 10b4a0: bb ff ff ff ff mov $0xffffffff,%ebx 10b4a5: e9 9a fe ff ff jmp 10b344 <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);
10b4aa: 83 ec 0c sub $0xc,%esp 10b4ad: 68 a0 94 12 00 push $0x1294a0 10b4b2: e8 65 10 00 00 call 10c51c <pthread_mutex_unlock>
return AIO_ALLDONE;
10b4b7: 83 c4 10 add $0x10,%esp 10b4ba: b3 02 mov $0x2,%bl 10b4bc: e9 83 fe ff ff jmp 10b344 <aio_cancel+0x88>
0010b4d0 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10b4d0: 55 push %ebp 10b4d1: 89 e5 mov %esp,%ebp 10b4d3: 53 push %ebx 10b4d4: 83 ec 04 sub $0x4,%esp 10b4d7: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10b4da: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10b4e1: 75 41 jne 10b524 <aio_fsync+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b4e3: 83 ec 08 sub $0x8,%esp 10b4e6: 6a 03 push $0x3 10b4e8: ff 33 pushl (%ebx) 10b4ea: e8 55 68 00 00 call 111d44 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b4ef: 83 e0 03 and $0x3,%eax 10b4f2: 48 dec %eax 10b4f3: 83 c4 10 add $0x10,%esp 10b4f6: 83 f8 01 cmp $0x1,%eax
10b4f9: 77 4d ja 10b548 <aio_fsync+0x78>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10b4fb: 83 ec 0c sub $0xc,%esp 10b4fe: 6a 18 push $0x18 10b500: e8 c3 d0 ff ff call 1085c8 <malloc>
if (req == NULL)
10b505: 83 c4 10 add $0x10,%esp 10b508: 85 c0 test %eax,%eax
10b50a: 74 57 je 10b563 <aio_fsync+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10b50c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10b50f: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b516: 89 45 08 mov %eax,0x8(%ebp)
}
10b519: 8b 5d fc mov -0x4(%ebp),%ebx 10b51c: 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);
10b51d: e9 d6 05 00 00 jmp 10baf8 <rtems_aio_enqueue> 10b522: 66 90 xchg %ax,%ax
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b524: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b52b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b532: e8 c5 a1 00 00 call 1156fc <__errno> 10b537: c7 00 16 00 00 00 movl $0x16,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
10b53d: b8 ff ff ff ff mov $0xffffffff,%eax 10b542: 8b 5d fc mov -0x4(%ebp),%ebx 10b545: c9 leave 10b546: c3 ret 10b547: 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);
10b548: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b54f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b556: e8 a1 a1 00 00 call 1156fc <__errno> 10b55b: c7 00 09 00 00 00 movl $0x9,(%eax) 10b561: eb da jmp 10b53d <aio_fsync+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b563: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b56a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b571: e8 86 a1 00 00 call 1156fc <__errno> <== NOT EXECUTED 10b576: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b57c: eb bf jmp 10b53d <aio_fsync+0x6d> <== NOT EXECUTED
0010bd08 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10bd08: 55 push %ebp 10bd09: 89 e5 mov %esp,%ebp 10bd0b: 53 push %ebx 10bd0c: 83 ec 0c sub $0xc,%esp 10bd0f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10bd12: 6a 03 push $0x3 10bd14: ff 33 pushl (%ebx) 10bd16: e8 29 60 00 00 call 111d44 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10bd1b: 83 c4 10 add $0x10,%esp 10bd1e: 83 e0 03 and $0x3,%eax
10bd21: 74 05 je 10bd28 <aio_read+0x20> <== NEVER TAKEN
10bd23: 83 f8 02 cmp $0x2,%eax
10bd26: 75 38 jne 10bd60 <aio_read+0x58>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10bd28: 8b 53 14 mov 0x14(%ebx),%edx 10bd2b: 85 d2 test %edx,%edx
10bd2d: 75 55 jne 10bd84 <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10bd2f: 8b 43 08 mov 0x8(%ebx),%eax 10bd32: 85 c0 test %eax,%eax
10bd34: 78 4e js 10bd84 <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10bd36: 83 ec 0c sub $0xc,%esp 10bd39: 6a 18 push $0x18 10bd3b: e8 88 c8 ff ff call 1085c8 <malloc>
if (req == NULL)
10bd40: 83 c4 10 add $0x10,%esp 10bd43: 85 c0 test %eax,%eax
10bd45: 74 58 je 10bd9f <aio_read+0x97> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10bd47: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10bd4a: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10bd51: 89 45 08 mov %eax,0x8(%ebp)
}
10bd54: 8b 5d fc mov -0x4(%ebp),%ebx 10bd57: 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);
10bd58: e9 9b fd ff ff jmp 10baf8 <rtems_aio_enqueue> 10bd5d: 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);
10bd60: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10bd67: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bd6e: e8 89 99 00 00 call 1156fc <__errno> 10bd73: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
10bd79: b8 ff ff ff ff mov $0xffffffff,%eax 10bd7e: 8b 5d fc mov -0x4(%ebp),%ebx 10bd81: c9 leave 10bd82: c3 ret 10bd83: 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);
10bd84: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10bd8b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bd92: e8 65 99 00 00 call 1156fc <__errno> 10bd97: c7 00 16 00 00 00 movl $0x16,(%eax) 10bd9d: eb da jmp 10bd79 <aio_read+0x71>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10bd9f: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10bda6: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10bdad: e8 4a 99 00 00 call 1156fc <__errno> <== NOT EXECUTED 10bdb2: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10bdb8: eb bf jmp 10bd79 <aio_read+0x71> <== NOT EXECUTED
0010bdc8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10bdc8: 55 push %ebp 10bdc9: 89 e5 mov %esp,%ebp 10bdcb: 53 push %ebx 10bdcc: 83 ec 0c sub $0xc,%esp 10bdcf: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10bdd2: 6a 03 push $0x3 10bdd4: ff 33 pushl (%ebx) 10bdd6: e8 69 5f 00 00 call 111d44 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10bddb: 83 e0 03 and $0x3,%eax 10bdde: 48 dec %eax 10bddf: 83 c4 10 add $0x10,%esp 10bde2: 83 f8 01 cmp $0x1,%eax
10bde5: 77 35 ja 10be1c <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10bde7: 8b 53 14 mov 0x14(%ebx),%edx 10bdea: 85 d2 test %edx,%edx
10bdec: 75 52 jne 10be40 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10bdee: 8b 43 08 mov 0x8(%ebx),%eax 10bdf1: 85 c0 test %eax,%eax
10bdf3: 78 4b js 10be40 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10bdf5: 83 ec 0c sub $0xc,%esp 10bdf8: 6a 18 push $0x18 10bdfa: e8 c9 c7 ff ff call 1085c8 <malloc>
if (req == NULL)
10bdff: 83 c4 10 add $0x10,%esp 10be02: 85 c0 test %eax,%eax
10be04: 74 55 je 10be5b <aio_write+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10be06: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10be09: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10be10: 89 45 08 mov %eax,0x8(%ebp)
}
10be13: 8b 5d fc mov -0x4(%ebp),%ebx 10be16: 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);
10be17: e9 dc fc ff ff jmp 10baf8 <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);
10be1c: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10be23: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10be2a: e8 cd 98 00 00 call 1156fc <__errno> 10be2f: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
10be35: b8 ff ff ff ff mov $0xffffffff,%eax 10be3a: 8b 5d fc mov -0x4(%ebp),%ebx 10be3d: c9 leave 10be3e: c3 ret 10be3f: 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);
10be40: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10be47: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10be4e: e8 a9 98 00 00 call 1156fc <__errno> 10be53: c7 00 16 00 00 00 movl $0x16,(%eax) 10be59: eb da jmp 10be35 <aio_write+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10be5b: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10be62: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10be69: e8 8e 98 00 00 call 1156fc <__errno> <== NOT EXECUTED 10be6e: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10be74: eb bf jmp 10be35 <aio_write+0x6d> <== NOT EXECUTED
0010a9fc <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
10a9fc: 55 push %ebp 10a9fd: 89 e5 mov %esp,%ebp 10a9ff: 83 ec 08 sub $0x8,%esp 10aa02: 8b 45 08 mov 0x8(%ebp),%eax 10aa05: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10aa08: 85 d2 test %edx,%edx
10aa0a: 74 14 je 10aa20 <clock_gettime+0x24>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10aa0c: 83 f8 01 cmp $0x1,%eax
10aa0f: 74 47 je 10aa58 <clock_gettime+0x5c>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
10aa11: 83 f8 04 cmp $0x4,%eax
10aa14: 74 32 je 10aa48 <clock_gettime+0x4c> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
10aa16: 83 f8 02 cmp $0x2,%eax
10aa19: 74 2d je 10aa48 <clock_gettime+0x4c>
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
10aa1b: 83 f8 03 cmp $0x3,%eax
10aa1e: 74 14 je 10aa34 <clock_gettime+0x38>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
10aa20: e8 bb 93 00 00 call 113de0 <__errno> 10aa25: c7 00 16 00 00 00 movl $0x16,(%eax) 10aa2b: b8 ff ff ff ff mov $0xffffffff,%eax
return 0;
}
10aa30: c9 leave 10aa31: c3 ret 10aa32: 66 90 xchg %ax,%ax
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
10aa34: e8 a7 93 00 00 call 113de0 <__errno> 10aa39: c7 00 58 00 00 00 movl $0x58,(%eax) 10aa3f: b8 ff ff ff ff mov $0xffffffff,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10aa44: c9 leave 10aa45: c3 ret 10aa46: 66 90 xchg %ax,%ax
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
_TOD_Get_uptime_as_timespec( tp );
10aa48: 83 ec 0c sub $0xc,%esp 10aa4b: 52 push %edx 10aa4c: e8 ab 1c 00 00 call 10c6fc <_TOD_Get_uptime_as_timespec>
return 0;
10aa51: 83 c4 10 add $0x10,%esp 10aa54: 31 c0 xor %eax,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10aa56: c9 leave 10aa57: c3 ret
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
10aa58: 83 ec 0c sub $0xc,%esp 10aa5b: 52 push %edx 10aa5c: e8 47 1c 00 00 call 10c6a8 <_TOD_Get>
return 0;
10aa61: 83 c4 10 add $0x10,%esp 10aa64: 31 c0 xor %eax,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10aa66: c9 leave 10aa67: c3 ret
0010aa68 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10aa68: 55 push %ebp 10aa69: 89 e5 mov %esp,%ebp 10aa6b: 83 ec 08 sub $0x8,%esp 10aa6e: 8b 45 08 mov 0x8(%ebp),%eax 10aa71: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10aa74: 85 d2 test %edx,%edx
10aa76: 74 0f je 10aa87 <clock_settime+0x1f> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10aa78: 83 f8 01 cmp $0x1,%eax
10aa7b: 74 1f je 10aa9c <clock_settime+0x34>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10aa7d: 83 f8 02 cmp $0x2,%eax
10aa80: 74 42 je 10aac4 <clock_settime+0x5c>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10aa82: 83 f8 03 cmp $0x3,%eax
10aa85: 74 3d je 10aac4 <clock_settime+0x5c>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10aa87: e8 54 93 00 00 call 113de0 <__errno> 10aa8c: c7 00 16 00 00 00 movl $0x16,(%eax) 10aa92: b8 ff ff ff ff mov $0xffffffff,%eax
return 0;
}
10aa97: c9 leave 10aa98: c3 ret 10aa99: 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 )
10aa9c: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10aaa2: 76 e3 jbe 10aa87 <clock_settime+0x1f>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10aaa4: a1 4c 97 12 00 mov 0x12974c,%eax 10aaa9: 40 inc %eax 10aaaa: a3 4c 97 12 00 mov %eax,0x12974c
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10aaaf: 83 ec 0c sub $0xc,%esp 10aab2: 52 push %edx 10aab3: e8 9c 1c 00 00 call 10c754 <_TOD_Set>
_Thread_Enable_dispatch();
10aab8: e8 37 31 00 00 call 10dbf4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10aabd: 83 c4 10 add $0x10,%esp 10aac0: 31 c0 xor %eax,%eax
}
10aac2: c9 leave 10aac3: 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 );
10aac4: e8 17 93 00 00 call 113de0 <__errno> 10aac9: c7 00 58 00 00 00 movl $0x58,(%eax) 10aacf: b8 ff ff ff ff mov $0xffffffff,%eax
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10aad4: c9 leave 10aad5: c3 ret
0010a7dc <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
10a7dc: 55 push %ebp 10a7dd: 89 e5 mov %esp,%ebp 10a7df: 83 ec 08 sub $0x8,%esp
if ( !value )
10a7e2: 8b 45 0c mov 0xc(%ebp),%eax 10a7e5: 85 c0 test %eax,%eax
10a7e7: 74 2f je 10a818 <getitimer+0x3c>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10a7e9: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10a7ed: 76 15 jbe 10a804 <getitimer+0x28>
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a7ef: e8 00 8d 00 00 call 1134f4 <__errno> 10a7f4: c7 00 16 00 00 00 movl $0x16,(%eax)
}
10a7fa: b8 ff ff ff ff mov $0xffffffff,%eax 10a7ff: c9 leave 10a800: c3 ret 10a801: 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 );
10a804: e8 eb 8c 00 00 call 1134f4 <__errno> 10a809: c7 00 58 00 00 00 movl $0x58,(%eax)
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10a80f: b8 ff ff ff ff mov $0xffffffff,%eax 10a814: c9 leave 10a815: c3 ret 10a816: 66 90 xchg %ax,%ax
int which,
struct itimerval *value
)
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
10a818: e8 d7 8c 00 00 call 1134f4 <__errno> 10a81d: c7 00 0e 00 00 00 movl $0xe,(%eax) 10a823: eb d5 jmp 10a7fa <getitimer+0x1e>
00124518 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
124518: 55 push %ebp 124519: 89 e5 mov %esp,%ebp 12451b: 57 push %edi 12451c: 56 push %esi 12451d: 53 push %ebx 12451e: 83 ec 3c sub $0x3c,%esp 124521: 8b 75 0c mov 0xc(%ebp),%esi 124524: 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() )
124527: e8 00 fd ff ff call 12422c <getpid> 12452c: 3b 45 08 cmp 0x8(%ebp),%eax
12452f: 0f 85 3f 02 00 00 jne 124774 <killinfo+0x25c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
124535: 85 f6 test %esi,%esi
124537: 0f 84 4c 02 00 00 je 124789 <killinfo+0x271>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
12453d: 8d 4e ff lea -0x1(%esi),%ecx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
124540: 83 f9 1f cmp $0x1f,%ecx
124543: 0f 87 40 02 00 00 ja 124789 <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 )
124549: 8d 04 76 lea (%esi,%esi,2),%eax 12454c: 83 3c 85 a8 dc 12 00 cmpl $0x1,0x12dca8(,%eax,4)
124553: 01 124554: 0f 84 e6 01 00 00 je 124740 <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 ) )
12455a: 83 fe 08 cmp $0x8,%esi
12455d: 0f 84 c9 00 00 00 je 12462c <killinfo+0x114>
124563: 83 fe 04 cmp $0x4,%esi
124566: 0f 84 c0 00 00 00 je 12462c <killinfo+0x114>
12456c: 83 fe 0b cmp $0xb,%esi
12456f: 0f 84 b7 00 00 00 je 12462c <killinfo+0x114>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124575: bb 01 00 00 00 mov $0x1,%ebx 12457a: d3 e3 shl %cl,%ebx
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
12457c: 89 75 dc mov %esi,-0x24(%ebp)
siginfo->si_code = SI_USER;
12457f: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
124586: 85 ff test %edi,%edi
124588: 0f 84 ba 01 00 00 je 124748 <killinfo+0x230>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
12458e: 8b 07 mov (%edi),%eax 124590: 89 45 e4 mov %eax,-0x1c(%ebp) 124593: a1 8c d6 12 00 mov 0x12d68c,%eax 124598: 40 inc %eax 124599: a3 8c d6 12 00 mov %eax,0x12d68c
/*
* 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;
12459e: 8b 0d 38 dc 12 00 mov 0x12dc38,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
1245a4: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax 1245aa: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1245b0: f7 d0 not %eax 1245b2: 85 c3 test %eax,%ebx
1245b4: 75 34 jne 1245ea <killinfo+0xd2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
1245b6: a1 40 de 12 00 mov 0x12de40,%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 );
1245bb: 3d 44 de 12 00 cmp $0x12de44,%eax
1245c0: 75 1b jne 1245dd <killinfo+0xc5>
1245c2: e9 81 00 00 00 jmp 124648 <killinfo+0x130> 1245c7: 90 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
1245c8: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 1245ce: f7 d2 not %edx 1245d0: 85 d3 test %edx,%ebx
1245d2: 75 16 jne 1245ea <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 ) {
1245d4: 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 );
1245d6: 3d 44 de 12 00 cmp $0x12de44,%eax
1245db: 74 6b je 124648 <killinfo+0x130> <== ALWAYS TAKEN
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
1245dd: 89 c1 mov %eax,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1245df: 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)
1245e5: 85 58 30 test %ebx,0x30(%eax)
1245e8: 74 de je 1245c8 <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 ) ) {
1245ea: 50 push %eax
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
1245eb: 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 ) ) {
1245ee: 50 push %eax 1245ef: 56 push %esi 1245f0: 51 push %ecx 1245f1: e8 d6 01 00 00 call 1247cc <_POSIX_signals_Unblock_thread> 1245f6: 83 c4 10 add $0x10,%esp 1245f9: 84 c0 test %al,%al
1245fb: 75 1f jne 12461c <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 );
1245fd: 83 ec 0c sub $0xc,%esp 124600: 53 push %ebx 124601: e8 b2 01 00 00 call 1247b8 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
124606: 8d 1c 76 lea (%esi,%esi,2),%ebx 124609: c1 e3 02 shl $0x2,%ebx 12460c: 83 c4 10 add $0x10,%esp 12460f: 83 bb a0 dc 12 00 02 cmpl $0x2,0x12dca0(%ebx)
124616: 0f 84 e4 00 00 00 je 124700 <killinfo+0x1e8>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
12461c: e8 ff d7 fe ff call 111e20 <_Thread_Enable_dispatch>
return 0;
124621: 31 c0 xor %eax,%eax
}
124623: 8d 65 f4 lea -0xc(%ebp),%esp 124626: 5b pop %ebx 124627: 5e pop %esi 124628: 5f pop %edi 124629: c9 leave 12462a: c3 ret 12462b: 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 );
12462c: e8 77 03 00 00 call 1249a8 <pthread_self> 124631: 83 ec 08 sub $0x8,%esp 124634: 56 push %esi 124635: 50 push %eax 124636: e8 b1 02 00 00 call 1248ec <pthread_kill> 12463b: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
12463e: 8d 65 f4 lea -0xc(%ebp),%esp 124641: 5b pop %ebx 124642: 5e pop %esi 124643: 5f pop %edi 124644: c9 leave 124645: c3 ret 124646: 66 90 xchg %ax,%ax
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
124648: 0f b6 05 54 92 12 00 movzbl 0x129254,%eax 12464f: 40 inc %eax 124650: 89 45 d4 mov %eax,-0x2c(%ebp)
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
124653: 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++) {
12465a: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) 124661: 89 5d d0 mov %ebx,-0x30(%ebp) 124664: 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 ] )
124667: 8b 55 cc mov -0x34(%ebp),%edx 12466a: 8b 04 95 64 d6 12 00 mov 0x12d664(,%edx,4),%eax 124671: 85 c0 test %eax,%eax
124673: 74 68 je 1246dd <killinfo+0x1c5> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
124675: 8b 40 04 mov 0x4(%eax),%eax
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
124678: 0f b7 70 10 movzwl 0x10(%eax),%esi
object_table = the_info->local_table;
12467c: 8b 78 1c mov 0x1c(%eax),%edi
for ( index = 1 ; index <= maximum ; index++ ) {
12467f: 85 f6 test %esi,%esi
124681: 74 5a je 1246dd <killinfo+0x1c5>
124683: b8 01 00 00 00 mov $0x1,%eax
the_thread = (Thread_Control *) object_table[ index ];
124688: 8b 14 87 mov (%edi,%eax,4),%edx
if ( !the_thread )
12468b: 85 d2 test %edx,%edx
12468d: 74 49 je 1246d8 <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 )
12468f: 8b 4a 14 mov 0x14(%edx),%ecx 124692: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124695: 77 41 ja 1246d8 <killinfo+0x1c0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
124697: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx 12469d: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx 1246a3: f7 d3 not %ebx 1246a5: 85 5d d0 test %ebx,-0x30(%ebp)
1246a8: 74 2e je 1246d8 <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 ) {
1246aa: 3b 4d d4 cmp -0x2c(%ebp),%ecx
1246ad: 72 21 jb 1246d0 <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 ) ) {
1246af: 8b 5d c8 mov -0x38(%ebp),%ebx 1246b2: 85 db test %ebx,%ebx
1246b4: 74 22 je 1246d8 <killinfo+0x1c0> <== NEVER TAKEN
1246b6: 8b 5d c8 mov -0x38(%ebp),%ebx 1246b9: 8b 5b 10 mov 0x10(%ebx),%ebx 1246bc: 89 5d c4 mov %ebx,-0x3c(%ebp) 1246bf: 85 db test %ebx,%ebx
1246c1: 74 15 je 1246d8 <killinfo+0x1c0> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
1246c3: 8b 5a 10 mov 0x10(%edx),%ebx 1246c6: 85 db test %ebx,%ebx
1246c8: 0f 85 86 00 00 00 jne 124754 <killinfo+0x23c>
1246ce: 66 90 xchg %ax,%ax 1246d0: 89 4d d4 mov %ecx,-0x2c(%ebp) 1246d3: 89 55 c8 mov %edx,-0x38(%ebp) 1246d6: 66 90 xchg %ax,%ax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
1246d8: 40 inc %eax 1246d9: 39 c6 cmp %eax,%esi
1246db: 73 ab jae 124688 <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++) {
1246dd: ff 45 cc incl -0x34(%ebp) 1246e0: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
1246e4: 75 81 jne 124667 <killinfo+0x14f>
1246e6: 8b 5d d0 mov -0x30(%ebp),%ebx 1246e9: 8b 75 c0 mov -0x40(%ebp),%esi
}
}
}
}
if ( interested ) {
1246ec: 8b 55 c8 mov -0x38(%ebp),%edx 1246ef: 85 d2 test %edx,%edx
1246f1: 0f 84 06 ff ff ff je 1245fd <killinfo+0xe5>
1246f7: 8b 4d c8 mov -0x38(%ebp),%ecx 1246fa: e9 eb fe ff ff jmp 1245ea <killinfo+0xd2> 1246ff: 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 );
124700: 83 ec 0c sub $0xc,%esp 124703: 68 20 de 12 00 push $0x12de20 124708: e8 77 be fe ff call 110584 <_Chain_Get>
if ( !psiginfo ) {
12470d: 83 c4 10 add $0x10,%esp 124710: 85 c0 test %eax,%eax
124712: 0f 84 86 00 00 00 je 12479e <killinfo+0x286>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
124718: 8d 78 08 lea 0x8(%eax),%edi 12471b: 8d 75 dc lea -0x24(%ebp),%esi 12471e: b9 03 00 00 00 mov $0x3,%ecx 124723: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
124725: 83 ec 08 sub $0x8,%esp 124728: 50 push %eax 124729: 81 c3 c0 de 12 00 add $0x12dec0,%ebx 12472f: 53 push %ebx 124730: e8 13 be fe ff call 110548 <_Chain_Append> 124735: 83 c4 10 add $0x10,%esp 124738: e9 df fe ff ff jmp 12461c <killinfo+0x104> 12473d: 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;
124740: 31 c0 xor %eax,%eax 124742: e9 f7 fe ff ff jmp 12463e <killinfo+0x126> 124747: 90 nop
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
124748: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 12474f: e9 3f fe ff ff jmp 124593 <killinfo+0x7b>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
124754: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp)
12475b: 0f 85 77 ff ff ff jne 1246d8 <killinfo+0x1c0>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
124761: 81 e3 00 00 00 10 and $0x10000000,%ebx
124767: 0f 84 6b ff ff ff je 1246d8 <killinfo+0x1c0>
12476d: e9 5e ff ff ff jmp 1246d0 <killinfo+0x1b8> 124772: 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 );
124774: e8 23 38 ff ff call 117f9c <__errno> 124779: c7 00 03 00 00 00 movl $0x3,(%eax) 12477f: b8 ff ff ff ff mov $0xffffffff,%eax 124784: e9 b5 fe ff ff jmp 12463e <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 );
124789: e8 0e 38 ff ff call 117f9c <__errno> 12478e: c7 00 16 00 00 00 movl $0x16,(%eax) 124794: b8 ff ff ff ff mov $0xffffffff,%eax 124799: e9 a0 fe ff ff jmp 12463e <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();
12479e: e8 7d d6 fe ff call 111e20 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
1247a3: e8 f4 37 ff ff call 117f9c <__errno> 1247a8: c7 00 0b 00 00 00 movl $0xb,(%eax) 1247ae: 83 c8 ff or $0xffffffff,%eax 1247b1: e9 88 fe ff ff jmp 12463e <killinfo+0x126>
0010f0bc <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
10f0bc: 55 push %ebp 10f0bd: 89 e5 mov %esp,%ebp 10f0bf: 57 push %edi 10f0c0: 56 push %esi 10f0c1: 53 push %ebx 10f0c2: 83 ec 2c sub $0x2c,%esp 10f0c5: 8b 75 0c mov 0xc(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10f0c8: a1 8c fa 12 00 mov 0x12fa8c,%eax 10f0cd: 40 inc %eax 10f0ce: a3 8c fa 12 00 mov %eax,0x12fa8c
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10f0d3: 89 f0 mov %esi,%eax 10f0d5: 25 00 02 00 00 and $0x200,%eax 10f0da: 89 45 d4 mov %eax,-0x2c(%ebp)
10f0dd: 0f 85 c9 00 00 00 jne 10f1ac <mq_open+0xf0>
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
10f0e3: 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 );
10f0ea: 83 ec 0c sub $0xc,%esp 10f0ed: 68 c0 ff 12 00 push $0x12ffc0 10f0f2: e8 a5 2b 00 00 call 111c9c <_Objects_Allocate> 10f0f7: 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 ) {
10f0f9: 83 c4 10 add $0x10,%esp 10f0fc: 85 c0 test %eax,%eax
10f0fe: 0f 84 b4 00 00 00 je 10f1b8 <mq_open+0xfc>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
10f104: 89 70 14 mov %esi,0x14(%eax)
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
10f107: 83 ec 08 sub $0x8,%esp 10f10a: 8d 45 e4 lea -0x1c(%ebp),%eax 10f10d: 50 push %eax 10f10e: ff 75 08 pushl 0x8(%ebp) 10f111: e8 ba 6a 00 00 call 115bd0 <_POSIX_Message_queue_Name_to_id> 10f116: 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 ) {
10f118: 83 c4 10 add $0x10,%esp 10f11b: 85 c0 test %eax,%eax
10f11d: 75 59 jne 10f178 <mq_open+0xbc>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10f11f: 81 e6 00 0a 00 00 and $0xa00,%esi 10f125: 81 fe 00 0a 00 00 cmp $0xa00,%esi
10f12b: 0f 84 a7 00 00 00 je 10f1d8 <mq_open+0x11c>
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
10f131: 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 );
10f132: 8d 45 dc lea -0x24(%ebp),%eax 10f135: 50 push %eax 10f136: ff 75 e4 pushl -0x1c(%ebp) 10f139: 68 20 fe 12 00 push $0x12fe20 10f13e: e8 0d 30 00 00 call 112150 <_Objects_Get> 10f143: 89 45 e0 mov %eax,-0x20(%ebp)
the_mq->open_count += 1;
10f146: ff 40 18 incl 0x18(%eax)
the_mq_fd->Queue = the_mq;
10f149: 89 43 10 mov %eax,0x10(%ebx)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
10f14c: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10f150: a1 dc ff 12 00 mov 0x12ffdc,%eax 10f155: 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;
10f158: 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();
10f15f: e8 7c 3b 00 00 call 112ce0 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10f164: e8 77 3b 00 00 call 112ce0 <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
10f169: 8b 43 08 mov 0x8(%ebx),%eax 10f16c: 83 c4 10 add $0x10,%esp
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10f16f: 8d 65 f4 lea -0xc(%ebp),%esp 10f172: 5b pop %ebx 10f173: 5e pop %esi 10f174: 5f pop %edi 10f175: c9 leave 10f176: c3 ret 10f177: 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) ) ) {
10f178: 83 f8 02 cmp $0x2,%eax
10f17b: 0f 84 87 00 00 00 je 10f208 <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 );
10f181: 83 ec 08 sub $0x8,%esp 10f184: 53 push %ebx 10f185: 68 c0 ff 12 00 push $0x12ffc0 10f18a: e8 81 2e 00 00 call 112010 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10f18f: e8 4c 3b 00 00 call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
10f194: e8 83 9f 00 00 call 11911c <__errno> 10f199: 89 38 mov %edi,(%eax) 10f19b: 83 c4 10 add $0x10,%esp 10f19e: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10f1a3: 8d 65 f4 lea -0xc(%ebp),%esp 10f1a6: 5b pop %ebx 10f1a7: 5e pop %esi 10f1a8: 5f pop %edi 10f1a9: c9 leave 10f1aa: c3 ret 10f1ab: 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 * );
10f1ac: 8b 45 14 mov 0x14(%ebp),%eax 10f1af: 89 45 d0 mov %eax,-0x30(%ebp) 10f1b2: e9 33 ff ff ff jmp 10f0ea <mq_open+0x2e> 10f1b7: 90 nop
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
_Thread_Enable_dispatch();
10f1b8: e8 23 3b 00 00 call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
10f1bd: e8 5a 9f 00 00 call 11911c <__errno> 10f1c2: c7 00 17 00 00 00 movl $0x17,(%eax) 10f1c8: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10f1cd: 8d 65 f4 lea -0xc(%ebp),%esp 10f1d0: 5b pop %ebx 10f1d1: 5e pop %esi 10f1d2: 5f pop %edi 10f1d3: c9 leave 10f1d4: c3 ret 10f1d5: 8d 76 00 lea 0x0(%esi),%esi 10f1d8: 83 ec 08 sub $0x8,%esp 10f1db: 53 push %ebx 10f1dc: 68 c0 ff 12 00 push $0x12ffc0 10f1e1: e8 2a 2e 00 00 call 112010 <_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();
10f1e6: e8 f5 3a 00 00 call 112ce0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
10f1eb: e8 2c 9f 00 00 call 11911c <__errno> 10f1f0: c7 00 11 00 00 00 movl $0x11,(%eax) 10f1f6: 83 c4 10 add $0x10,%esp 10f1f9: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10f1fe: 8d 65 f4 lea -0xc(%ebp),%esp 10f201: 5b pop %ebx 10f202: 5e pop %esi 10f203: 5f pop %edi 10f204: c9 leave 10f205: c3 ret 10f206: 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) ) ) {
10f208: 8b 55 d4 mov -0x2c(%ebp),%edx 10f20b: 85 d2 test %edx,%edx
10f20d: 0f 84 6e ff ff ff je 10f181 <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(
10f213: 8d 45 e0 lea -0x20(%ebp),%eax 10f216: 50 push %eax 10f217: ff 75 d0 pushl -0x30(%ebp) 10f21a: 6a 01 push $0x1 10f21c: ff 75 08 pushl 0x8(%ebp) 10f21f: e8 24 68 00 00 call 115a48 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
10f224: 83 c4 10 add $0x10,%esp 10f227: 40 inc %eax
10f228: 74 26 je 10f250 <mq_open+0x194>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
10f22a: 8b 45 e0 mov -0x20(%ebp),%eax 10f22d: 89 43 10 mov %eax,0x10(%ebx)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
10f230: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10f234: a1 dc ff 12 00 mov 0x12ffdc,%eax 10f239: 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;
10f23c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
10f243: e8 98 3a 00 00 call 112ce0 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
10f248: 8b 43 08 mov 0x8(%ebx),%eax 10f24b: e9 1f ff ff ff jmp 10f16f <mq_open+0xb3> 10f250: 83 ec 08 sub $0x8,%esp 10f253: 53 push %ebx 10f254: 68 c0 ff 12 00 push $0x12ffc0 10f259: e8 b2 2d 00 00 call 112010 <_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();
10f25e: e8 7d 3a 00 00 call 112ce0 <_Thread_Enable_dispatch>
return (mqd_t) -1;
10f263: 83 c4 10 add $0x10,%esp 10f266: b8 ff ff ff ff mov $0xffffffff,%eax 10f26b: e9 ff fe ff ff jmp 10f16f <mq_open+0xb3>
001200c4 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
1200c4: 55 push %ebp 1200c5: 89 e5 mov %esp,%ebp 1200c7: 56 push %esi 1200c8: 53 push %ebx 1200c9: 8b 75 08 mov 0x8(%ebp),%esi 1200cc: 8b 5d 0c mov 0xc(%ebp),%ebx
* Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( !_Timespec_Is_valid( rqtp ) )
1200cf: 83 ec 0c sub $0xc,%esp 1200d2: 56 push %esi 1200d3: e8 80 01 00 00 call 120258 <_Timespec_Is_valid> 1200d8: 83 c4 10 add $0x10,%esp 1200db: 84 c0 test %al,%al
1200dd: 0f 84 e1 00 00 00 je 1201c4 <nanosleep+0x100> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
ticks = _Timespec_To_ticks( rqtp );
1200e3: 83 ec 0c sub $0xc,%esp 1200e6: 56 push %esi 1200e7: e8 e8 1f ff ff call 1120d4 <_Timespec_To_ticks> 1200ec: 89 c6 mov %eax,%esi
* A nanosleep for zero time is implemented as a yield.
* This behavior is also beyond the POSIX specification but is
* consistent with the RTEMS API and yields desirable behavior.
*/
if ( !ticks ) {
1200ee: 83 c4 10 add $0x10,%esp 1200f1: 85 c0 test %eax,%eax
1200f3: 75 37 jne 12012c <nanosleep+0x68>
1200f5: a1 2c 93 12 00 mov 0x12932c,%eax 1200fa: 40 inc %eax 1200fb: a3 2c 93 12 00 mov %eax,0x12932c
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
120100: ff 15 cc 4a 12 00 call *0x124acc
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
120106: e8 a5 d7 fe ff call 10d8b0 <_Thread_Enable_dispatch>
if ( rmtp ) {
12010b: 85 db test %ebx,%ebx
12010d: 0f 84 93 00 00 00 je 1201a6 <nanosleep+0xe2> <== NEVER TAKEN
rmtp->tv_sec = 0;
120113: c7 03 00 00 00 00 movl $0x0,(%ebx)
rmtp->tv_nsec = 0;
120119: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
}
return 0;
120120: 31 c0 xor %eax,%eax
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
}
120122: 8d 65 f8 lea -0x8(%ebp),%esp 120125: 5b pop %ebx 120126: 5e pop %esi 120127: c9 leave 120128: c3 ret 120129: 8d 76 00 lea 0x0(%esi),%esi 12012c: a1 2c 93 12 00 mov 0x12932c,%eax 120131: 40 inc %eax 120132: a3 2c 93 12 00 mov %eax,0x12932c
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
120137: 83 ec 08 sub $0x8,%esp 12013a: 68 08 00 00 10 push $0x10000008 12013f: ff 35 d8 98 12 00 pushl 0x1298d8 120145: e8 8a df fe ff call 10e0d4 <_Thread_Set_state>
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
12014a: 8b 15 d8 98 12 00 mov 0x1298d8,%edx
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
120150: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
120153: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
12015a: c7 42 64 fc d6 10 00 movl $0x10d6fc,0x64(%edx)
the_watchdog->id = id;
120161: 89 42 68 mov %eax,0x68(%edx)
the_watchdog->user_data = user_data;
120164: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
12016b: 89 72 54 mov %esi,0x54(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
12016e: 58 pop %eax 12016f: 59 pop %ecx
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
120170: 83 c2 48 add $0x48,%edx 120173: 52 push %edx 120174: 68 00 94 12 00 push $0x129400 120179: e8 a6 e4 fe ff call 10e624 <_Watchdog_Insert>
_Thread_Enable_dispatch();
12017e: e8 2d d7 fe ff call 10d8b0 <_Thread_Enable_dispatch>
/* calculate time remaining */
if ( rmtp ) {
120183: 83 c4 10 add $0x10,%esp 120186: 85 db test %ebx,%ebx
120188: 74 1c je 1201a6 <nanosleep+0xe2>
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
12018a: a1 d8 98 12 00 mov 0x1298d8,%eax 12018f: 03 70 5c add 0x5c(%eax),%esi
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
120192: 2b 70 60 sub 0x60(%eax),%esi
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
120195: 83 ec 08 sub $0x8,%esp 120198: 53 push %ebx 120199: 56 push %esi 12019a: e8 71 00 00 00 call 120210 <_Timespec_From_ticks>
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
12019f: 83 c4 10 add $0x10,%esp 1201a2: 85 f6 test %esi,%esi
1201a4: 75 09 jne 1201af <nanosleep+0xeb>
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
1201a6: 31 c0 xor %eax,%eax
}
1201a8: 8d 65 f8 lea -0x8(%ebp),%esp 1201ab: 5b pop %ebx 1201ac: 5e pop %esi 1201ad: c9 leave 1201ae: c3 ret
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
rtems_set_errno_and_return_minus_one( EINTR );
1201af: e8 dc 3d ff ff call 113f90 <__errno> 1201b4: c7 00 04 00 00 00 movl $0x4,(%eax) 1201ba: b8 ff ff ff ff mov $0xffffffff,%eax 1201bf: e9 5e ff ff ff jmp 120122 <nanosleep+0x5e>
*
* NOTE: This behavior is beyond the POSIX specification.
* FSU and GNU/Linux pthreads shares this behavior.
*/
if ( !_Timespec_Is_valid( rqtp ) )
rtems_set_errno_and_return_minus_one( EINVAL );
1201c4: e8 c7 3d ff ff call 113f90 <__errno> 1201c9: c7 00 16 00 00 00 movl $0x16,(%eax) 1201cf: b8 ff ff ff ff mov $0xffffffff,%eax 1201d4: e9 49 ff ff ff jmp 120122 <nanosleep+0x5e>
0010fee8 <pthread_attr_destroy>:
#include <rtems/system.h>
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
10fee8: 55 push %ebp 10fee9: 89 e5 mov %esp,%ebp 10feeb: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
10feee: 85 c0 test %eax,%eax
10fef0: 74 12 je 10ff04 <pthread_attr_destroy+0x1c>
10fef2: 8b 10 mov (%eax),%edx 10fef4: 85 d2 test %edx,%edx
10fef6: 74 0c je 10ff04 <pthread_attr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10fef8: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10fefe: 31 c0 xor %eax,%eax
}
10ff00: c9 leave 10ff01: c3 ret 10ff02: 66 90 xchg %ax,%ax
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
10ff04: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10ff09: c9 leave 10ff0a: c3 ret
0010ffe4 <pthread_attr_getscope>:
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
10ffe4: 55 push %ebp 10ffe5: 89 e5 mov %esp,%ebp 10ffe7: 8b 45 08 mov 0x8(%ebp),%eax 10ffea: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized || !contentionscope )
10ffed: 85 c0 test %eax,%eax
10ffef: 74 13 je 110004 <pthread_attr_getscope+0x20><== NEVER TAKEN
10fff1: 8b 08 mov (%eax),%ecx 10fff3: 85 c9 test %ecx,%ecx
10fff5: 74 0d je 110004 <pthread_attr_getscope+0x20><== NEVER TAKEN
10fff7: 85 d2 test %edx,%edx
10fff9: 74 09 je 110004 <pthread_attr_getscope+0x20><== NEVER TAKEN
return EINVAL;
*contentionscope = attr->contentionscope;
10fffb: 8b 40 0c mov 0xc(%eax),%eax 10fffe: 89 02 mov %eax,(%edx)
return 0;
110000: 31 c0 xor %eax,%eax
}
110002: c9 leave 110003: c3 ret
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
return EINVAL;
110004: b8 16 00 00 00 mov $0x16,%eax
*contentionscope = attr->contentionscope;
return 0;
}
110009: c9 leave 11000a: c3 ret
00110034 <pthread_attr_getstack>:
int pthread_attr_getstack(
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
110034: 55 push %ebp 110035: 89 e5 mov %esp,%ebp 110037: 53 push %ebx 110038: 8b 45 08 mov 0x8(%ebp),%eax 11003b: 8b 55 0c mov 0xc(%ebp),%edx 11003e: 8b 4d 10 mov 0x10(%ebp),%ecx
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
110041: 85 c0 test %eax,%eax
110043: 74 1f je 110064 <pthread_attr_getstack+0x30>
110045: 8b 18 mov (%eax),%ebx 110047: 85 db test %ebx,%ebx
110049: 74 19 je 110064 <pthread_attr_getstack+0x30>
11004b: 85 d2 test %edx,%edx
11004d: 74 15 je 110064 <pthread_attr_getstack+0x30>
11004f: 85 c9 test %ecx,%ecx
110051: 74 11 je 110064 <pthread_attr_getstack+0x30>
return EINVAL;
*stackaddr = attr->stackaddr;
110053: 8b 58 04 mov 0x4(%eax),%ebx 110056: 89 1a mov %ebx,(%edx)
*stacksize = attr->stacksize;
110058: 8b 40 08 mov 0x8(%eax),%eax 11005b: 89 01 mov %eax,(%ecx)
return 0;
11005d: 31 c0 xor %eax,%eax
}
11005f: 5b pop %ebx 110060: c9 leave 110061: c3 ret 110062: 66 90 xchg %ax,%ax
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
110064: b8 16 00 00 00 mov $0x16,%eax
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
110069: 5b pop %ebx 11006a: c9 leave 11006b: c3 ret
001100e8 <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
1100e8: 55 push %ebp 1100e9: 89 e5 mov %esp,%ebp 1100eb: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
1100ee: 85 c0 test %eax,%eax
1100f0: 74 12 je 110104 <pthread_attr_setguardsize+0x1c>
1100f2: 8b 10 mov (%eax),%edx 1100f4: 85 d2 test %edx,%edx
1100f6: 74 0c je 110104 <pthread_attr_setguardsize+0x1c>
return EINVAL;
attr->guardsize = guardsize;
1100f8: 8b 55 0c mov 0xc(%ebp),%edx 1100fb: 89 50 34 mov %edx,0x34(%eax)
return 0;
1100fe: 31 c0 xor %eax,%eax
}
110100: c9 leave 110101: c3 ret 110102: 66 90 xchg %ax,%ax
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110104: b8 16 00 00 00 mov $0x16,%eax
attr->guardsize = guardsize;
return 0;
}
110109: c9 leave 11010a: c3 ret
001110dc <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
1110dc: 55 push %ebp 1110dd: 89 e5 mov %esp,%ebp 1110df: 8b 45 08 mov 0x8(%ebp),%eax 1110e2: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
1110e5: 85 c0 test %eax,%eax
1110e7: 74 1f je 111108 <pthread_attr_setinheritsched+0x2c>
1110e9: 8b 08 mov (%eax),%ecx 1110eb: 85 c9 test %ecx,%ecx
1110ed: 74 19 je 111108 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
1110ef: 8d 4a ff lea -0x1(%edx),%ecx 1110f2: 83 f9 01 cmp $0x1,%ecx
1110f5: 76 09 jbe 111100 <pthread_attr_setinheritsched+0x24>
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
1110f7: b8 86 00 00 00 mov $0x86,%eax
} }
1110fc: c9 leave 1110fd: c3 ret 1110fe: 66 90 xchg %ax,%ax
return EINVAL;
switch ( inheritsched ) {
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
111100: 89 50 10 mov %edx,0x10(%eax)
return 0;
111103: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
111105: c9 leave 111106: c3 ret 111107: 90 nop
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111108: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
11110d: c9 leave 11110e: c3 ret
00110140 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
110140: 55 push %ebp 110141: 89 e5 mov %esp,%ebp 110143: 57 push %edi 110144: 56 push %esi 110145: 8b 7d 08 mov 0x8(%ebp),%edi 110148: 8b 75 0c mov 0xc(%ebp),%esi
if ( !attr || !attr->is_initialized || !param )
11014b: 85 ff test %edi,%edi
11014d: 74 1d je 11016c <pthread_attr_setschedparam+0x2c>
11014f: 8b 07 mov (%edi),%eax 110151: 85 c0 test %eax,%eax
110153: 74 17 je 11016c <pthread_attr_setschedparam+0x2c>
110155: 85 f6 test %esi,%esi
110157: 74 13 je 11016c <pthread_attr_setschedparam+0x2c>
return EINVAL;
attr->schedparam = *param;
110159: 83 c7 18 add $0x18,%edi 11015c: b9 07 00 00 00 mov $0x7,%ecx 110161: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
110163: 31 c0 xor %eax,%eax
}
110165: 5e pop %esi 110166: 5f pop %edi 110167: c9 leave 110168: c3 ret 110169: 8d 76 00 lea 0x0(%esi),%esi
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
11016c: b8 16 00 00 00 mov $0x16,%eax
attr->schedparam = *param;
return 0;
}
110171: 5e pop %esi 110172: 5f pop %edi 110173: c9 leave 110174: c3 ret
00110178 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
110178: 55 push %ebp 110179: 89 e5 mov %esp,%ebp 11017b: 8b 45 08 mov 0x8(%ebp),%eax 11017e: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
110181: 85 c0 test %eax,%eax
110183: 74 23 je 1101a8 <pthread_attr_setschedpolicy+0x30>
110185: 8b 08 mov (%eax),%ecx 110187: 85 c9 test %ecx,%ecx
110189: 74 1d je 1101a8 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
11018b: 85 d2 test %edx,%edx
11018d: 78 0a js 110199 <pthread_attr_setschedpolicy+0x21>
11018f: 83 fa 02 cmp $0x2,%edx
110192: 7e 0c jle 1101a0 <pthread_attr_setschedpolicy+0x28>
110194: 83 fa 04 cmp $0x4,%edx
110197: 74 07 je 1101a0 <pthread_attr_setschedpolicy+0x28><== ALWAYS TAKEN
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
110199: b8 86 00 00 00 mov $0x86,%eax
} }
11019e: c9 leave 11019f: c3 ret
switch ( policy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
1101a0: 89 50 14 mov %edx,0x14(%eax)
return 0;
1101a3: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
1101a5: c9 leave 1101a6: c3 ret 1101a7: 90 nop
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
1101a8: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
1101ad: c9 leave 1101ae: c3 ret
001101b0 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
1101b0: 55 push %ebp 1101b1: 89 e5 mov %esp,%ebp 1101b3: 8b 45 08 mov 0x8(%ebp),%eax 1101b6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
1101b9: 85 c0 test %eax,%eax
1101bb: 74 1a je 1101d7 <pthread_attr_setscope+0x27>
1101bd: 8b 08 mov (%eax),%ecx 1101bf: 85 c9 test %ecx,%ecx
1101c1: 74 14 je 1101d7 <pthread_attr_setscope+0x27>
return EINVAL;
switch ( contentionscope ) {
1101c3: 85 d2 test %edx,%edx
1101c5: 75 0d jne 1101d4 <pthread_attr_setscope+0x24>
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
1101c7: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
return 0;
1101ce: 31 c0 xor %eax,%eax
return ENOTSUP;
default:
return EINVAL;
}
}
1101d0: c9 leave 1101d1: c3 ret 1101d2: 66 90 xchg %ax,%ax
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
1101d4: 4a dec %edx
1101d5: 74 09 je 1101e0 <pthread_attr_setscope+0x30>
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
1101d7: b8 16 00 00 00 mov $0x16,%eax
} }
1101dc: c9 leave 1101dd: c3 ret 1101de: 66 90 xchg %ax,%ax
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
return 0;
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
1101e0: b8 86 00 00 00 mov $0x86,%eax
default:
return EINVAL;
}
}
1101e5: c9 leave 1101e6: c3 ret
0011020c <pthread_attr_setstack>:
int pthread_attr_setstack(
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
11020c: 55 push %ebp 11020d: 89 e5 mov %esp,%ebp 11020f: 8b 45 08 mov 0x8(%ebp),%eax 110212: 8b 55 10 mov 0x10(%ebp),%edx
if ( !attr || !attr->is_initialized )
110215: 85 c0 test %eax,%eax
110217: 74 27 je 110240 <pthread_attr_setstack+0x34>
110219: 8b 08 mov (%eax),%ecx 11021b: 85 c9 test %ecx,%ecx
11021d: 74 21 je 110240 <pthread_attr_setstack+0x34>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
11021f: 8b 0d 38 de 12 00 mov 0x12de38,%ecx 110225: d1 e1 shl %ecx 110227: 39 d1 cmp %edx,%ecx
110229: 77 0d ja 110238 <pthread_attr_setstack+0x2c>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
11022b: 89 50 08 mov %edx,0x8(%eax)
attr->stackaddr = stackaddr;
11022e: 8b 55 0c mov 0xc(%ebp),%edx 110231: 89 50 04 mov %edx,0x4(%eax)
return 0;
110234: 31 c0 xor %eax,%eax
}
110236: c9 leave 110237: c3 ret
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
110238: 89 48 08 mov %ecx,0x8(%eax) 11023b: eb f1 jmp 11022e <pthread_attr_setstack+0x22> 11023d: 8d 76 00 lea 0x0(%esi),%esi
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110240: b8 16 00 00 00 mov $0x16,%eax
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
110245: c9 leave 110246: c3 ret
001101e8 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
1101e8: 55 push %ebp 1101e9: 89 e5 mov %esp,%ebp 1101eb: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
1101ee: 85 c0 test %eax,%eax
1101f0: 74 12 je 110204 <pthread_attr_setstackaddr+0x1c>
1101f2: 8b 10 mov (%eax),%edx 1101f4: 85 d2 test %edx,%edx
1101f6: 74 0c je 110204 <pthread_attr_setstackaddr+0x1c>
return EINVAL;
attr->stackaddr = stackaddr;
1101f8: 8b 55 0c mov 0xc(%ebp),%edx 1101fb: 89 50 04 mov %edx,0x4(%eax)
return 0;
1101fe: 31 c0 xor %eax,%eax
}
110200: c9 leave 110201: c3 ret 110202: 66 90 xchg %ax,%ax
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110204: b8 16 00 00 00 mov $0x16,%eax
attr->stackaddr = stackaddr;
return 0;
}
110209: c9 leave 11020a: c3 ret
00111110 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
111110: 55 push %ebp 111111: 89 e5 mov %esp,%ebp 111113: 8b 45 08 mov 0x8(%ebp),%eax 111116: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111119: 85 c0 test %eax,%eax
11111b: 74 23 je 111140 <pthread_attr_setstacksize+0x30>
11111d: 8b 08 mov (%eax),%ecx 11111f: 85 c9 test %ecx,%ecx
111121: 74 1d je 111140 <pthread_attr_setstacksize+0x30>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
111123: 8b 0d d8 47 12 00 mov 0x1247d8,%ecx 111129: d1 e1 shl %ecx 11112b: 39 d1 cmp %edx,%ecx
11112d: 77 09 ja 111138 <pthread_attr_setstacksize+0x28>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
11112f: 89 50 08 mov %edx,0x8(%eax)
return 0;
111132: 31 c0 xor %eax,%eax
}
111134: c9 leave 111135: c3 ret 111136: 66 90 xchg %ax,%ax
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
111138: 89 48 08 mov %ecx,0x8(%eax)
else
attr->stacksize = stacksize;
return 0;
11113b: 31 c0 xor %eax,%eax
}
11113d: c9 leave 11113e: c3 ret 11113f: 90 nop
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111140: 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;
}
111145: c9 leave 111146: c3 ret
0010af34 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10af34: 55 push %ebp 10af35: 89 e5 mov %esp,%ebp 10af37: 57 push %edi 10af38: 56 push %esi 10af39: 53 push %ebx 10af3a: 83 ec 2c sub $0x2c,%esp 10af3d: 8b 5d 08 mov 0x8(%ebp),%ebx 10af40: 8b 7d 0c mov 0xc(%ebp),%edi 10af43: 8b 75 10 mov 0x10(%ebp),%esi
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10af46: 85 db test %ebx,%ebx
10af48: 0f 84 82 00 00 00 je 10afd0 <pthread_barrier_init+0x9c>
return EINVAL;
if ( count == 0 )
10af4e: 85 f6 test %esi,%esi
10af50: 74 7e je 10afd0 <pthread_barrier_init+0x9c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10af52: 85 ff test %edi,%edi
10af54: 0f 84 92 00 00 00 je 10afec <pthread_barrier_init+0xb8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10af5a: 8b 17 mov (%edi),%edx 10af5c: 85 d2 test %edx,%edx
10af5e: 74 70 je 10afd0 <pthread_barrier_init+0x9c>
return EINVAL;
switch ( the_attr->process_shared ) {
10af60: 8b 47 04 mov 0x4(%edi),%eax 10af63: 85 c0 test %eax,%eax
10af65: 75 69 jne 10afd0 <pthread_barrier_init+0x9c><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10af67: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10af6e: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10af71: a1 cc 8e 12 00 mov 0x128ecc,%eax 10af76: 40 inc %eax 10af77: a3 cc 8e 12 00 mov %eax,0x128ecc
* 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 );
10af7c: 83 ec 0c sub $0xc,%esp 10af7f: 68 e0 92 12 00 push $0x1292e0 10af84: e8 0f 1f 00 00 call 10ce98 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10af89: 83 c4 10 add $0x10,%esp 10af8c: 85 c0 test %eax,%eax
10af8e: 74 50 je 10afe0 <pthread_barrier_init+0xac>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10af90: 83 ec 08 sub $0x8,%esp 10af93: 8d 55 e0 lea -0x20(%ebp),%edx 10af96: 52 push %edx 10af97: 8d 50 10 lea 0x10(%eax),%edx 10af9a: 52 push %edx 10af9b: 89 45 d4 mov %eax,-0x2c(%ebp) 10af9e: e8 29 16 00 00 call 10c5cc <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10afa3: 8b 45 d4 mov -0x2c(%ebp),%eax 10afa6: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10afa9: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10afac: 8b 0d fc 92 12 00 mov 0x1292fc,%ecx 10afb2: 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;
10afb5: 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;
10afbc: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10afbe: e8 99 2e 00 00 call 10de5c <_Thread_Enable_dispatch>
return 0;
10afc3: 83 c4 10 add $0x10,%esp 10afc6: 31 c0 xor %eax,%eax
}
10afc8: 8d 65 f4 lea -0xc(%ebp),%esp 10afcb: 5b pop %ebx 10afcc: 5e pop %esi 10afcd: 5f pop %edi 10afce: c9 leave 10afcf: c3 ret
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
10afd0: 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; }
10afd5: 8d 65 f4 lea -0xc(%ebp),%esp 10afd8: 5b pop %ebx 10afd9: 5e pop %esi 10afda: 5f pop %edi 10afdb: c9 leave 10afdc: c3 ret 10afdd: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
10afe0: e8 77 2e 00 00 call 10de5c <_Thread_Enable_dispatch>
return EAGAIN;
10afe5: b8 0b 00 00 00 mov $0xb,%eax 10afea: eb e9 jmp 10afd5 <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 );
10afec: 83 ec 0c sub $0xc,%esp 10afef: 8d 7d d8 lea -0x28(%ebp),%edi 10aff2: 57 push %edi 10aff3: e8 7c fe ff ff call 10ae74 <pthread_barrierattr_init> 10aff8: 83 c4 10 add $0x10,%esp 10affb: e9 5a ff ff ff jmp 10af5a <pthread_barrier_init+0x26>
0010b000 <pthread_barrier_wait>:
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
10b000: 55 push %ebp 10b001: 89 e5 mov %esp,%ebp 10b003: 83 ec 18 sub $0x18,%esp 10b006: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
10b009: 85 c0 test %eax,%eax
10b00b: 74 4f je 10b05c <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(
10b00d: 51 push %ecx
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
10b00e: 8d 55 f4 lea -0xc(%ebp),%edx 10b011: 52 push %edx 10b012: ff 30 pushl (%eax) 10b014: 68 e0 92 12 00 push $0x1292e0 10b019: e8 2e 23 00 00 call 10d34c <_Objects_Get>
switch ( location ) {
10b01e: 83 c4 10 add $0x10,%esp 10b021: 8b 55 f4 mov -0xc(%ebp),%edx 10b024: 85 d2 test %edx,%edx
10b026: 75 34 jne 10b05c <pthread_barrier_wait+0x5c>
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
10b028: 83 ec 0c sub $0xc,%esp 10b02b: 6a 00 push $0x0 10b02d: 6a 00 push $0x0 10b02f: 6a 01 push $0x1 10b031: ff 70 08 pushl 0x8(%eax) 10b034: 83 c0 10 add $0x10,%eax 10b037: 50 push %eax 10b038: e8 c3 15 00 00 call 10c600 <_CORE_barrier_Wait>
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
10b03d: 83 c4 20 add $0x20,%esp 10b040: e8 17 2e 00 00 call 10de5c <_Thread_Enable_dispatch>
return _POSIX_Barrier_Translate_core_barrier_return_code(
10b045: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10b048: a1 78 94 12 00 mov 0x129478,%eax
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
10b04d: ff 70 34 pushl 0x34(%eax) 10b050: e8 cf 5b 00 00 call 110c24 <_POSIX_Barrier_Translate_core_barrier_return_code> 10b055: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b058: c9 leave 10b059: c3 ret 10b05a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b05c: b8 16 00 00 00 mov $0x16,%eax
}
10b061: c9 leave 10b062: c3 ret
0010ae2c <pthread_barrierattr_destroy>:
*/
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
10ae2c: 55 push %ebp 10ae2d: 89 e5 mov %esp,%ebp 10ae2f: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10ae32: 85 c0 test %eax,%eax
10ae34: 74 12 je 10ae48 <pthread_barrierattr_destroy+0x1c>
10ae36: 8b 10 mov (%eax),%edx 10ae38: 85 d2 test %edx,%edx
10ae3a: 74 0c je 10ae48 <pthread_barrierattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10ae3c: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10ae42: 31 c0 xor %eax,%eax
}
10ae44: c9 leave 10ae45: c3 ret 10ae46: 66 90 xchg %ax,%ax
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10ae48: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10ae4d: c9 leave 10ae4e: c3 ret
0010a6dc <pthread_cancel>:
*/
int pthread_cancel(
pthread_t thread
)
{
10a6dc: 55 push %ebp 10a6dd: 89 e5 mov %esp,%ebp 10a6df: 83 ec 18 sub $0x18,%esp
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
10a6e2: 8b 0d 14 90 12 00 mov 0x129014,%ecx 10a6e8: 85 c9 test %ecx,%ecx
10a6ea: 74 08 je 10a6f4 <pthread_cancel+0x18>
return EPROTO;
10a6ec: b8 47 00 00 00 mov $0x47,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10a6f1: c9 leave 10a6f2: c3 ret 10a6f3: 90 nop
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
10a6f4: 83 ec 08 sub $0x8,%esp 10a6f7: 8d 45 f4 lea -0xc(%ebp),%eax 10a6fa: 50 push %eax 10a6fb: ff 75 08 pushl 0x8(%ebp) 10a6fe: e8 71 2a 00 00 call 10d174 <_Thread_Get>
switch ( location ) {
10a703: 83 c4 10 add $0x10,%esp 10a706: 8b 55 f4 mov -0xc(%ebp),%edx 10a709: 85 d2 test %edx,%edx
10a70b: 75 23 jne 10a730 <pthread_cancel+0x54>
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
10a70d: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 10a713: c7 82 e0 00 00 00 01 movl $0x1,0xe0(%edx)
10a71a: 00 00 00
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
10a71d: 83 ec 0c sub $0xc,%esp 10a720: 50 push %eax 10a721: e8 46 55 00 00 call 10fc6c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
return 0;
10a726: 83 c4 10 add $0x10,%esp 10a729: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10a72b: c9 leave 10a72c: c3 ret 10a72d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10a730: b8 16 00 00 00 mov $0x16,%eax
}
10a735: c9 leave 10a736: c3 ret
0010a54c <pthread_cleanup_pop>:
*/
void pthread_cleanup_pop(
int execute
)
{
10a54c: 55 push %ebp 10a54d: 89 e5 mov %esp,%ebp 10a54f: 57 push %edi 10a550: 56 push %esi 10a551: 53 push %ebx 10a552: 83 ec 0c sub $0xc,%esp 10a555: 8b 75 08 mov 0x8(%ebp),%esi
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 ];
10a558: a1 38 81 12 00 mov 0x128138,%eax 10a55d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a563: 8b 15 8c 7b 12 00 mov 0x127b8c,%edx 10a569: 42 inc %edx 10a56a: 89 15 8c 7b 12 00 mov %edx,0x127b8c
* 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 );
10a570: 9c pushf 10a571: fa cli 10a572: 5b pop %ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10a573: 8d 90 e8 00 00 00 lea 0xe8(%eax),%edx
if ( _Chain_Is_empty( handler_stack ) ) {
10a579: 39 90 e4 00 00 00 cmp %edx,0xe4(%eax)
10a57f: 74 47 je 10a5c8 <pthread_cleanup_pop+0x7c>
_Thread_Enable_dispatch();
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
10a581: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10a587: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10a589: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10a58c: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10a58f: 89 0a mov %ecx,(%edx)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
10a591: 53 push %ebx 10a592: 9d popf 10a593: 8b 58 08 mov 0x8(%eax),%ebx 10a596: 8b 78 0c mov 0xc(%eax),%edi
tmp_handler = *handler;
_Workspace_Free( handler );
10a599: 83 ec 0c sub $0xc,%esp 10a59c: 50 push %eax 10a59d: e8 16 38 00 00 call 10ddb8 <_Workspace_Free>
_Thread_Enable_dispatch();
10a5a2: e8 19 28 00 00 call 10cdc0 <_Thread_Enable_dispatch>
if ( execute )
10a5a7: 83 c4 10 add $0x10,%esp 10a5aa: 85 f6 test %esi,%esi
10a5ac: 75 0a jne 10a5b8 <pthread_cleanup_pop+0x6c>
(*tmp_handler.routine)( tmp_handler.arg );
}
10a5ae: 8d 65 f4 lea -0xc(%ebp),%esp 10a5b1: 5b pop %ebx 10a5b2: 5e pop %esi 10a5b3: 5f pop %edi 10a5b4: c9 leave 10a5b5: c3 ret 10a5b6: 66 90 xchg %ax,%ax
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
10a5b8: 89 7d 08 mov %edi,0x8(%ebp) 10a5bb: 89 d8 mov %ebx,%eax
}
10a5bd: 8d 65 f4 lea -0xc(%ebp),%esp 10a5c0: 5b pop %ebx 10a5c1: 5e pop %esi 10a5c2: 5f pop %edi 10a5c3: c9 leave
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
10a5c4: ff e0 jmp *%eax 10a5c6: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
_Thread_Enable_dispatch();
10a5c8: e8 f3 27 00 00 call 10cdc0 <_Thread_Enable_dispatch>
_ISR_Enable( level );
10a5cd: 53 push %ebx 10a5ce: 9d popf
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
}
10a5cf: 8d 65 f4 lea -0xc(%ebp),%esp 10a5d2: 5b pop %ebx 10a5d3: 5e pop %esi 10a5d4: 5f pop %edi 10a5d5: c9 leave 10a5d6: c3 ret
0010a908 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
10a908: 55 push %ebp 10a909: 89 e5 mov %esp,%ebp 10a90b: 56 push %esi 10a90c: 53 push %ebx 10a90d: 8b 5d 08 mov 0x8(%ebp),%ebx 10a910: 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 )
10a913: 85 db test %ebx,%ebx
10a915: 74 4d je 10a964 <pthread_cleanup_push+0x5c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a917: a1 0c 92 12 00 mov 0x12920c,%eax 10a91c: 40 inc %eax 10a91d: a3 0c 92 12 00 mov %eax,0x12920c
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
10a922: 83 ec 0c sub $0xc,%esp 10a925: 6a 10 push $0x10 10a927: e8 d8 3f 00 00 call 10e904 <_Workspace_Allocate>
if ( handler ) {
10a92c: 83 c4 10 add $0x10,%esp 10a92f: 85 c0 test %eax,%eax
10a931: 74 25 je 10a958 <pthread_cleanup_push+0x50><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a933: 8b 15 b8 97 12 00 mov 0x1297b8,%edx
handler_stack = &thread_support->Cancellation_Handlers;
10a939: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 10a93f: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
10a945: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
10a948: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
10a94b: 83 ec 08 sub $0x8,%esp 10a94e: 50 push %eax 10a94f: 52 push %edx 10a950: e8 0b 17 00 00 call 10c060 <_Chain_Append> 10a955: 83 c4 10 add $0x10,%esp
} _Thread_Enable_dispatch(); }
10a958: 8d 65 f8 lea -0x8(%ebp),%esp 10a95b: 5b pop %ebx 10a95c: 5e pop %esi 10a95d: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
10a95e: e9 35 2f 00 00 jmp 10d898 <_Thread_Enable_dispatch> 10a963: 90 nop
}
10a964: 8d 65 f8 lea -0x8(%ebp),%esp 10a967: 5b pop %ebx 10a968: 5e pop %esi 10a969: c9 leave 10a96a: c3 ret
0010b5fc <pthread_cond_destroy>:
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
10b5fc: 55 push %ebp 10b5fd: 89 e5 mov %esp,%ebp 10b5ff: 53 push %ebx 10b600: 83 ec 1c sub $0x1c,%esp
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10b603: 8d 45 f4 lea -0xc(%ebp),%eax 10b606: 50 push %eax 10b607: ff 75 08 pushl 0x8(%ebp) 10b60a: e8 65 00 00 00 call 10b674 <_POSIX_Condition_variables_Get> 10b60f: 89 c3 mov %eax,%ebx
switch ( location ) {
10b611: 83 c4 10 add $0x10,%esp 10b614: 8b 4d f4 mov -0xc(%ebp),%ecx 10b617: 85 c9 test %ecx,%ecx
10b619: 75 25 jne 10b640 <pthread_cond_destroy+0x44>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
10b61b: 83 ec 0c sub $0xc,%esp 10b61e: 8d 40 18 lea 0x18(%eax),%eax 10b621: 50 push %eax 10b622: e8 f1 3b 00 00 call 10f218 <_Thread_queue_First> 10b627: 83 c4 10 add $0x10,%esp 10b62a: 85 c0 test %eax,%eax
10b62c: 74 1e je 10b64c <pthread_cond_destroy+0x50>
_Thread_Enable_dispatch();
10b62e: e8 01 35 00 00 call 10eb34 <_Thread_Enable_dispatch>
return EBUSY;
10b633: b8 10 00 00 00 mov $0x10,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b638: 8b 5d fc mov -0x4(%ebp),%ebx 10b63b: c9 leave 10b63c: c3 ret 10b63d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b640: b8 16 00 00 00 mov $0x16,%eax
}
10b645: 8b 5d fc mov -0x4(%ebp),%ebx 10b648: c9 leave 10b649: c3 ret 10b64a: 66 90 xchg %ax,%ax
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close(
10b64c: 83 ec 08 sub $0x8,%esp 10b64f: 53 push %ebx 10b650: 68 80 a3 12 00 push $0x12a380 10b655: e8 92 25 00 00 call 10dbec <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
10b65a: 58 pop %eax 10b65b: 5a pop %edx 10b65c: 53 push %ebx 10b65d: 68 80 a3 12 00 push $0x12a380 10b662: e8 7d 28 00 00 call 10dee4 <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
10b667: e8 c8 34 00 00 call 10eb34 <_Thread_Enable_dispatch>
return 0;
10b66c: 83 c4 10 add $0x10,%esp 10b66f: 31 c0 xor %eax,%eax 10b671: eb d2 jmp 10b645 <pthread_cond_destroy+0x49>
0010b6c8 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10b6c8: 55 push %ebp 10b6c9: 89 e5 mov %esp,%ebp 10b6cb: 53 push %ebx 10b6cc: 83 ec 14 sub $0x14,%esp 10b6cf: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10b6d2: 85 db test %ebx,%ebx
10b6d4: 0f 84 86 00 00 00 je 10b760 <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 )
10b6da: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10b6de: 74 06 je 10b6e6 <pthread_cond_init+0x1e><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10b6e0: 8b 03 mov (%ebx),%eax 10b6e2: 85 c0 test %eax,%eax
10b6e4: 75 0a jne 10b6f0 <pthread_cond_init+0x28>
return EINVAL;
10b6e6: b8 16 00 00 00 mov $0x16,%eax
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b6eb: 8b 5d fc mov -0x4(%ebp),%ebx 10b6ee: c9 leave 10b6ef: c3 ret
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b6f0: a1 cc 9e 12 00 mov 0x129ecc,%eax 10b6f5: 40 inc %eax 10b6f6: a3 cc 9e 12 00 mov %eax,0x129ecc
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10b6fb: 83 ec 0c sub $0xc,%esp 10b6fe: 68 80 a3 12 00 push $0x12a380 10b703: e8 68 24 00 00 call 10db70 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10b708: 83 c4 10 add $0x10,%esp 10b70b: 85 c0 test %eax,%eax
10b70d: 74 5d je 10b76c <pthread_cond_init+0xa4>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
10b70f: 8b 53 04 mov 0x4(%ebx),%edx 10b712: 89 50 10 mov %edx,0x10(%eax)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10b715: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
_Thread_queue_Initialize(
10b71c: 6a 74 push $0x74 10b71e: 68 00 08 00 10 push $0x10000800 10b723: 6a 00 push $0x0 10b725: 8d 50 18 lea 0x18(%eax),%edx 10b728: 52 push %edx 10b729: 89 45 f4 mov %eax,-0xc(%ebp) 10b72c: e8 63 3b 00 00 call 10f294 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b731: 8b 45 f4 mov -0xc(%ebp),%eax 10b734: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b737: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b73a: 8b 0d 9c a3 12 00 mov 0x12a39c,%ecx 10b740: 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;
10b743: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10b74a: 8b 45 08 mov 0x8(%ebp),%eax 10b74d: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10b74f: e8 e0 33 00 00 call 10eb34 <_Thread_Enable_dispatch>
return 0;
10b754: 83 c4 10 add $0x10,%esp 10b757: 31 c0 xor %eax,%eax
}
10b759: 8b 5d fc mov -0x4(%ebp),%ebx 10b75c: c9 leave 10b75d: c3 ret 10b75e: 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;
10b760: bb 9c 35 12 00 mov $0x12359c,%ebx 10b765: e9 70 ff ff ff jmp 10b6da <pthread_cond_init+0x12> 10b76a: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
10b76c: e8 c3 33 00 00 call 10eb34 <_Thread_Enable_dispatch>
return ENOMEM;
10b771: b8 0c 00 00 00 mov $0xc,%eax 10b776: e9 70 ff ff ff jmp 10b6eb <pthread_cond_init+0x23>
0010b558 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10b558: 55 push %ebp 10b559: 89 e5 mov %esp,%ebp 10b55b: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10b55e: 85 c0 test %eax,%eax
10b560: 74 12 je 10b574 <pthread_condattr_destroy+0x1c>
10b562: 8b 10 mov (%eax),%edx 10b564: 85 d2 test %edx,%edx
10b566: 74 0c je 10b574 <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10b568: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10b56e: 31 c0 xor %eax,%eax
}
10b570: c9 leave 10b571: c3 ret 10b572: 66 90 xchg %ax,%ax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10b574: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10b579: c9 leave 10b57a: c3 ret
0010b57c <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
10b57c: 55 push %ebp 10b57d: 89 e5 mov %esp,%ebp 10b57f: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr )
10b582: 85 c0 test %eax,%eax
10b584: 74 0e je 10b594 <pthread_condattr_getpshared+0x18>
return EINVAL;
*pshared = attr->process_shared;
10b586: 8b 50 04 mov 0x4(%eax),%edx 10b589: 8b 45 0c mov 0xc(%ebp),%eax 10b58c: 89 10 mov %edx,(%eax)
return 0;
10b58e: 31 c0 xor %eax,%eax
}
10b590: c9 leave 10b591: c3 ret 10b592: 66 90 xchg %ax,%ax
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
10b594: b8 16 00 00 00 mov $0x16,%eax
*pshared = attr->process_shared;
return 0;
}
10b599: c9 leave 10b59a: c3 ret
0010b5c4 <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
10b5c4: 55 push %ebp 10b5c5: 89 e5 mov %esp,%ebp 10b5c7: 8b 45 08 mov 0x8(%ebp),%eax 10b5ca: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10b5cd: 85 c0 test %eax,%eax
10b5cf: 74 05 je 10b5d6 <pthread_condattr_setpshared+0x12>
return EINVAL;
switch ( pshared ) {
10b5d1: 83 fa 01 cmp $0x1,%edx
10b5d4: 76 0a jbe 10b5e0 <pthread_condattr_setpshared+0x1c>
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10b5d6: b8 16 00 00 00 mov $0x16,%eax
} }
10b5db: c9 leave 10b5dc: c3 ret 10b5dd: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10b5e0: 89 50 04 mov %edx,0x4(%eax)
return 0;
10b5e3: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10b5e5: c9 leave 10b5e6: c3 ret
0010ac80 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10ac80: 55 push %ebp 10ac81: 89 e5 mov %esp,%ebp 10ac83: 57 push %edi 10ac84: 56 push %esi 10ac85: 53 push %ebx 10ac86: 83 ec 5c sub $0x5c,%esp 10ac89: 8b 5d 0c mov 0xc(%ebp),%ebx
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10ac8c: 8b 75 10 mov 0x10(%ebp),%esi 10ac8f: 85 f6 test %esi,%esi
10ac91: 0f 84 8d 01 00 00 je 10ae24 <pthread_create+0x1a4> <== NEVER TAKEN
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10ac97: 85 db test %ebx,%ebx
10ac99: 74 65 je 10ad00 <pthread_create+0x80>
if ( !the_attr->is_initialized )
10ac9b: 8b 0b mov (%ebx),%ecx 10ac9d: 85 c9 test %ecx,%ecx
10ac9f: 74 1e je 10acbf <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) )
10aca1: 8b 53 04 mov 0x4(%ebx),%edx 10aca4: 85 d2 test %edx,%edx
10aca6: 74 0a je 10acb2 <pthread_create+0x32>
10aca8: a1 d8 47 12 00 mov 0x1247d8,%eax 10acad: 39 43 08 cmp %eax,0x8(%ebx)
10acb0: 72 0d jb 10acbf <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 ) {
10acb2: 8b 43 10 mov 0x10(%ebx),%eax 10acb5: 83 f8 01 cmp $0x1,%eax
10acb8: 74 4e je 10ad08 <pthread_create+0x88>
10acba: 83 f8 02 cmp $0x2,%eax
10acbd: 74 11 je 10acd0 <pthread_create+0x50>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
10acbf: ba 16 00 00 00 mov $0x16,%edx
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10acc4: 89 d0 mov %edx,%eax 10acc6: 8d 65 f4 lea -0xc(%ebp),%esp 10acc9: 5b pop %ebx 10acca: 5e pop %esi 10accb: 5f pop %edi 10accc: c9 leave 10accd: c3 ret 10acce: 66 90 xchg %ax,%ax
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10acd0: 8b 4b 14 mov 0x14(%ebx),%ecx 10acd3: 89 4d b0 mov %ecx,-0x50(%ebp)
schedparam = the_attr->schedparam;
10acd6: 8d 45 c4 lea -0x3c(%ebp),%eax 10acd9: 89 45 b4 mov %eax,-0x4c(%ebp) 10acdc: 8d 73 18 lea 0x18(%ebx),%esi 10acdf: b9 07 00 00 00 mov $0x7,%ecx 10ace4: 89 c7 mov %eax,%edi 10ace6: 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 )
10ace8: 8b 43 0c mov 0xc(%ebx),%eax 10aceb: 85 c0 test %eax,%eax
10aced: 74 49 je 10ad38 <pthread_create+0xb8> <== ALWAYS TAKEN
return ENOTSUP;
10acef: ba 86 00 00 00 mov $0x86,%edx
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10acf4: 89 d0 mov %edx,%eax 10acf6: 8d 65 f4 lea -0xc(%ebp),%esp 10acf9: 5b pop %ebx 10acfa: 5e pop %esi 10acfb: 5f pop %edi 10acfc: c9 leave 10acfd: c3 ret 10acfe: 66 90 xchg %ax,%ax
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10ad00: bb 40 21 12 00 mov $0x122140,%ebx 10ad05: eb 94 jmp 10ac9b <pthread_create+0x1b> 10ad07: 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 ];
10ad08: a1 f8 8f 12 00 mov 0x128ff8,%eax 10ad0d: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10ad13: 8b 8e 84 00 00 00 mov 0x84(%esi),%ecx 10ad19: 89 4d b0 mov %ecx,-0x50(%ebp)
schedparam = api->schedparam;
10ad1c: 8d 45 c4 lea -0x3c(%ebp),%eax 10ad1f: 89 45 b4 mov %eax,-0x4c(%ebp) 10ad22: 81 c6 88 00 00 00 add $0x88,%esi 10ad28: b9 07 00 00 00 mov $0x7,%ecx 10ad2d: 89 c7 mov %eax,%edi 10ad2f: 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 )
10ad31: 8b 43 0c mov 0xc(%ebx),%eax 10ad34: 85 c0 test %eax,%eax
10ad36: 75 b7 jne 10acef <pthread_create+0x6f>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10ad38: 83 ec 0c sub $0xc,%esp 10ad3b: ff 75 c4 pushl -0x3c(%ebp) 10ad3e: e8 6d 62 00 00 call 110fb0 <_POSIX_Priority_Is_valid> 10ad43: 83 c4 10 add $0x10,%esp 10ad46: 84 c0 test %al,%al
10ad48: 0f 84 71 ff ff ff je 10acbf <pthread_create+0x3f> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10ad4e: 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);
10ad51: 0f b6 35 dc 47 12 00 movzbl 0x1247dc,%esi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10ad58: 8d 45 e0 lea -0x20(%ebp),%eax 10ad5b: 50 push %eax 10ad5c: 8d 45 e4 lea -0x1c(%ebp),%eax 10ad5f: 50 push %eax 10ad60: ff 75 b4 pushl -0x4c(%ebp) 10ad63: ff 75 b0 pushl -0x50(%ebp) 10ad66: e8 61 62 00 00 call 110fcc <_POSIX_Thread_Translate_sched_param> 10ad6b: 89 c2 mov %eax,%edx
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10ad6d: 83 c4 10 add $0x10,%esp 10ad70: 85 c0 test %eax,%eax
10ad72: 0f 85 4c ff ff ff jne 10acc4 <pthread_create+0x44>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10ad78: 83 ec 0c sub $0xc,%esp 10ad7b: ff 35 00 8b 12 00 pushl 0x128b00 10ad81: 89 45 a0 mov %eax,-0x60(%ebp) 10ad84: e8 03 17 00 00 call 10c48c <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10ad89: c7 04 24 e0 8c 12 00 movl $0x128ce0,(%esp) 10ad90: e8 e3 1f 00 00 call 10cd78 <_Objects_Allocate> 10ad95: 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 ) {
10ad98: 83 c4 10 add $0x10,%esp 10ad9b: 85 c0 test %eax,%eax 10ad9d: 8b 55 a0 mov -0x60(%ebp),%edx
10ada0: 0f 84 0f 01 00 00 je 10aeb5 <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(
10ada6: 8b 4d e0 mov -0x20(%ebp),%ecx 10ada9: 8b 45 e4 mov -0x1c(%ebp),%eax 10adac: 89 45 a4 mov %eax,-0x5c(%ebp) 10adaf: 8b 43 08 mov 0x8(%ebx),%eax 10adb2: 89 45 a8 mov %eax,-0x58(%ebp) 10adb5: a1 d8 47 12 00 mov 0x1247d8,%eax 10adba: d1 e0 shl %eax 10adbc: 3b 45 a8 cmp -0x58(%ebp),%eax
10adbf: 73 03 jae 10adc4 <pthread_create+0x144>
10adc1: 8b 45 a8 mov -0x58(%ebp),%eax 10adc4: 83 ec 04 sub $0x4,%esp 10adc7: 6a 00 push $0x0 10adc9: 6a 00 push $0x0 10adcb: 51 push %ecx 10adcc: ff 75 a4 pushl -0x5c(%ebp) 10adcf: 6a 01 push $0x1 10add1: 81 e6 ff 00 00 00 and $0xff,%esi 10add7: 29 fe sub %edi,%esi 10add9: 56 push %esi 10adda: 6a 01 push $0x1 10addc: 50 push %eax 10addd: ff 73 04 pushl 0x4(%ebx) 10ade0: ff 75 ac pushl -0x54(%ebp) 10ade3: 68 e0 8c 12 00 push $0x128ce0 10ade8: 89 55 a0 mov %edx,-0x60(%ebp) 10adeb: e8 e8 2f 00 00 call 10ddd8 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10adf0: 83 c4 30 add $0x30,%esp 10adf3: 84 c0 test %al,%al 10adf5: 8b 55 a0 mov -0x60(%ebp),%edx
10adf8: 75 34 jne 10ae2e <pthread_create+0x1ae>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10adfa: 83 ec 08 sub $0x8,%esp 10adfd: ff 75 ac pushl -0x54(%ebp) 10ae00: 68 e0 8c 12 00 push $0x128ce0 10ae05: e8 e2 22 00 00 call 10d0ec <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10ae0a: 59 pop %ecx 10ae0b: ff 35 00 8b 12 00 pushl 0x128b00 10ae11: e8 be 16 00 00 call 10c4d4 <_API_Mutex_Unlock>
return EAGAIN;
10ae16: 83 c4 10 add $0x10,%esp 10ae19: ba 0b 00 00 00 mov $0xb,%edx 10ae1e: e9 a1 fe ff ff jmp 10acc4 <pthread_create+0x44> 10ae23: 90 nop
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10ae24: ba 0e 00 00 00 mov $0xe,%edx 10ae29: e9 96 fe ff ff jmp 10acc4 <pthread_create+0x44>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ae2e: 8b 4d ac mov -0x54(%ebp),%ecx 10ae31: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10ae37: 89 4d a8 mov %ecx,-0x58(%ebp)
api->Attributes = *the_attr;
10ae3a: b9 10 00 00 00 mov $0x10,%ecx 10ae3f: 8b 7d a8 mov -0x58(%ebp),%edi 10ae42: 89 de mov %ebx,%esi 10ae44: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10ae46: 8b 43 3c mov 0x3c(%ebx),%eax 10ae49: 8b 4d a8 mov -0x58(%ebp),%ecx 10ae4c: 89 41 40 mov %eax,0x40(%ecx)
api->schedpolicy = schedpolicy;
10ae4f: 8b 45 b0 mov -0x50(%ebp),%eax 10ae52: 89 81 84 00 00 00 mov %eax,0x84(%ecx)
api->schedparam = schedparam;
10ae58: 89 cf mov %ecx,%edi 10ae5a: 81 c7 88 00 00 00 add $0x88,%edi 10ae60: b9 07 00 00 00 mov $0x7,%ecx 10ae65: 8b 75 b4 mov -0x4c(%ebp),%esi 10ae68: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10ae6a: 83 ec 0c sub $0xc,%esp 10ae6d: 6a 00 push $0x0 10ae6f: ff 75 14 pushl 0x14(%ebp) 10ae72: ff 75 10 pushl 0x10(%ebp) 10ae75: 6a 01 push $0x1 10ae77: ff 75 ac pushl -0x54(%ebp) 10ae7a: 89 55 a0 mov %edx,-0x60(%ebp) 10ae7d: e8 46 38 00 00 call 10e6c8 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10ae82: 83 c4 20 add $0x20,%esp 10ae85: 83 7d b0 04 cmpl $0x4,-0x50(%ebp) 10ae89: 8b 55 a0 mov -0x60(%ebp),%edx
10ae8c: 74 42 je 10aed0 <pthread_create+0x250>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10ae8e: 8b 45 ac mov -0x54(%ebp),%eax 10ae91: 8b 48 08 mov 0x8(%eax),%ecx 10ae94: 8b 45 08 mov 0x8(%ebp),%eax 10ae97: 89 08 mov %ecx,(%eax)
_RTEMS_Unlock_allocator();
10ae99: 83 ec 0c sub $0xc,%esp 10ae9c: ff 35 00 8b 12 00 pushl 0x128b00 10aea2: 89 55 a0 mov %edx,-0x60(%ebp) 10aea5: e8 2a 16 00 00 call 10c4d4 <_API_Mutex_Unlock>
return 0;
10aeaa: 83 c4 10 add $0x10,%esp 10aead: 8b 55 a0 mov -0x60(%ebp),%edx 10aeb0: e9 0f fe ff ff jmp 10acc4 <pthread_create+0x44>
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10aeb5: 83 ec 0c sub $0xc,%esp 10aeb8: ff 35 00 8b 12 00 pushl 0x128b00 10aebe: e8 11 16 00 00 call 10c4d4 <_API_Mutex_Unlock>
return EAGAIN;
10aec3: 83 c4 10 add $0x10,%esp 10aec6: ba 0b 00 00 00 mov $0xb,%edx 10aecb: e9 f4 fd ff ff jmp 10acc4 <pthread_create+0x44>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10aed0: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10aed3: 8b 45 a8 mov -0x58(%ebp),%eax 10aed6: 05 90 00 00 00 add $0x90,%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10aedb: 50 push %eax 10aedc: e8 77 39 00 00 call 10e858 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10aee1: 8b 4d a8 mov -0x58(%ebp),%ecx 10aee4: 89 81 b4 00 00 00 mov %eax,0xb4(%ecx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10aeea: 58 pop %eax 10aeeb: 5a pop %edx 10aeec: 89 c8 mov %ecx,%eax 10aeee: 05 a8 00 00 00 add $0xa8,%eax 10aef3: 50 push %eax 10aef4: 68 20 8b 12 00 push $0x128b20 10aef9: e8 8a 3c 00 00 call 10eb88 <_Watchdog_Insert> 10aefe: 83 c4 10 add $0x10,%esp 10af01: 8b 55 a0 mov -0x60(%ebp),%edx 10af04: eb 88 jmp 10ae8e <pthread_create+0x20e>
0010ad94 <pthread_detach>:
#include <rtems/posix/pthread.h>
int pthread_detach(
pthread_t thread
)
{
10ad94: 55 push %ebp 10ad95: 89 e5 mov %esp,%ebp 10ad97: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
10ad9a: 8d 45 f4 lea -0xc(%ebp),%eax 10ad9d: 50 push %eax 10ad9e: ff 75 08 pushl 0x8(%ebp) 10ada1: e8 9e 2c 00 00 call 10da44 <_Thread_Get>
switch ( location ) {
10ada6: 83 c4 10 add $0x10,%esp 10ada9: 8b 55 f4 mov -0xc(%ebp),%edx 10adac: 85 d2 test %edx,%edx
10adae: 75 18 jne 10adc8 <pthread_detach+0x34>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->detachstate = PTHREAD_CREATE_DETACHED;
10adb0: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10adb6: c7 40 40 00 00 00 00 movl $0x0,0x40(%eax)
_Thread_Enable_dispatch();
10adbd: e8 5e 2c 00 00 call 10da20 <_Thread_Enable_dispatch>
return 0;
10adc2: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10adc4: c9 leave 10adc5: c3 ret 10adc6: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10adc8: b8 03 00 00 00 mov $0x3,%eax
}
10adcd: c9 leave 10adce: c3 ret
001128cc <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
1128cc: 55 push %ebp 1128cd: 89 e5 mov %esp,%ebp 1128cf: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
1128d2: ff 75 08 pushl 0x8(%ebp) 1128d5: ff 35 98 7d 12 00 pushl 0x127d98 1128db: e8 88 ff ff ff call 112868 <_POSIX_Thread_Exit>
1128e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1128e3: c9 leave <== NOT EXECUTED 1128e4: c3 ret <== NOT EXECUTED
0010ce68 <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
10ce68: 55 push %ebp 10ce69: 89 e5 mov %esp,%ebp 10ce6b: 57 push %edi 10ce6c: 56 push %esi 10ce6d: 53 push %ebx 10ce6e: 83 ec 1c sub $0x1c,%esp 10ce71: 8b 7d 0c mov 0xc(%ebp),%edi 10ce74: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
10ce77: 85 ff test %edi,%edi
10ce79: 74 65 je 10cee0 <pthread_getschedparam+0x78>
10ce7b: 85 db test %ebx,%ebx
10ce7d: 74 61 je 10cee0 <pthread_getschedparam+0x78>
return EINVAL;
the_thread = _Thread_Get( thread, &location );
10ce7f: 83 ec 08 sub $0x8,%esp 10ce82: 8d 45 e4 lea -0x1c(%ebp),%eax 10ce85: 50 push %eax 10ce86: ff 75 08 pushl 0x8(%ebp) 10ce89: e8 46 2d 00 00 call 10fbd4 <_Thread_Get>
switch ( location ) {
10ce8e: 83 c4 10 add $0x10,%esp 10ce91: 8b 55 e4 mov -0x1c(%ebp),%edx 10ce94: 85 d2 test %edx,%edx
10ce96: 75 38 jne 10ced0 <pthread_getschedparam+0x68>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ce98: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
if ( policy )
*policy = api->schedpolicy;
10ce9e: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 10cea4: 89 17 mov %edx,(%edi)
if ( param ) {
*param = api->schedparam;
10cea6: 81 c6 88 00 00 00 add $0x88,%esi 10ceac: b9 07 00 00 00 mov $0x7,%ecx 10ceb1: 89 df mov %ebx,%edi 10ceb3: 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);
10ceb5: 0f b6 15 dc 83 12 00 movzbl 0x1283dc,%edx 10cebc: 2b 50 14 sub 0x14(%eax),%edx 10cebf: 89 13 mov %edx,(%ebx)
param->sched_priority =
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
10cec1: e8 ea 2c 00 00 call 10fbb0 <_Thread_Enable_dispatch>
return 0;
10cec6: 31 c0 xor %eax,%eax
break;
}
return ESRCH;
}
10cec8: 8d 65 f4 lea -0xc(%ebp),%esp 10cecb: 5b pop %ebx 10cecc: 5e pop %esi 10cecd: 5f pop %edi 10cece: c9 leave 10cecf: c3 ret
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10ced0: b8 03 00 00 00 mov $0x3,%eax
}
10ced5: 8d 65 f4 lea -0xc(%ebp),%esp 10ced8: 5b pop %ebx 10ced9: 5e pop %esi 10ceda: 5f pop %edi 10cedb: c9 leave 10cedc: c3 ret 10cedd: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
10cee0: b8 16 00 00 00 mov $0x16,%eax
break;
}
return ESRCH;
}
10cee5: 8d 65 f4 lea -0xc(%ebp),%esp 10cee8: 5b pop %ebx 10cee9: 5e pop %esi 10ceea: 5f pop %edi 10ceeb: c9 leave 10ceec: c3 ret
0010ac60 <pthread_getspecific>:
*/
void *pthread_getspecific(
pthread_key_t key
)
{
10ac60: 55 push %ebp 10ac61: 89 e5 mov %esp,%ebp 10ac63: 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 );
10ac66: 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 );
10ac69: 50 push %eax 10ac6a: ff 75 08 pushl 0x8(%ebp) 10ac6d: 68 c0 9a 12 00 push $0x129ac0 10ac72: e8 b5 23 00 00 call 10d02c <_Objects_Get>
switch ( location ) {
10ac77: 83 c4 10 add $0x10,%esp 10ac7a: 8b 55 f4 mov -0xc(%ebp),%edx 10ac7d: 85 d2 test %edx,%edx
10ac7f: 75 2b jne 10acac <pthread_getspecific+0x4c>
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
10ac81: 8b 15 f8 9b 12 00 mov 0x129bf8,%edx 10ac87: 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);
10ac8a: 89 ca mov %ecx,%edx 10ac8c: c1 ea 18 shr $0x18,%edx 10ac8f: 83 e2 07 and $0x7,%edx
index = _Objects_Get_index( _Thread_Executing->Object.id );
10ac92: 0f b7 c9 movzwl %cx,%ecx
key_data = (void *) the_key->Values[ api ][ index ];
10ac95: 8b 44 90 14 mov 0x14(%eax,%edx,4),%eax 10ac99: 8b 04 88 mov (%eax,%ecx,4),%eax
_Thread_Enable_dispatch();
10ac9c: 89 45 e4 mov %eax,-0x1c(%ebp) 10ac9f: e8 98 2e 00 00 call 10db3c <_Thread_Enable_dispatch>
return key_data;
10aca4: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return NULL;
}
10aca7: c9 leave 10aca8: c3 ret 10aca9: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return NULL;
10acac: 31 c0 xor %eax,%eax
}
10acae: c9 leave 10acaf: c3 ret
001106ac <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
1106ac: 55 push %ebp 1106ad: 89 e5 mov %esp,%ebp 1106af: 53 push %ebx 1106b0: 83 ec 1c sub $0x1c,%esp 1106b3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _Thread_Get( thread, &location );
1106b6: 8d 45 f4 lea -0xc(%ebp),%eax 1106b9: 50 push %eax 1106ba: ff 75 08 pushl 0x8(%ebp) 1106bd: e8 52 2d 00 00 call 113414 <_Thread_Get>
switch ( location ) {
1106c2: 83 c4 10 add $0x10,%esp 1106c5: 8b 55 f4 mov -0xc(%ebp),%edx 1106c8: 85 d2 test %edx,%edx
1106ca: 74 0c je 1106d8 <pthread_join+0x2c>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
1106cc: b8 03 00 00 00 mov $0x3,%eax
}
1106d1: 8b 5d fc mov -0x4(%ebp),%ebx 1106d4: c9 leave 1106d5: c3 ret 1106d6: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1106d8: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
1106de: 8b 4a 40 mov 0x40(%edx),%ecx 1106e1: 85 c9 test %ecx,%ecx
1106e3: 74 43 je 110728 <pthread_join+0x7c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
1106e5: 8b 0d d8 26 13 00 mov 0x1326d8,%ecx
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
1106eb: 39 c8 cmp %ecx,%eax
1106ed: 74 49 je 110738 <pthread_join+0x8c>
/*
* Put ourself on the threads join list
*/
_Thread_Executing->Wait.return_argument = &return_pointer;
1106ef: 8d 45 f0 lea -0x10(%ebp),%eax 1106f2: 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;
1106f5: 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 );
1106fc: 50 push %eax 1106fd: 68 c4 3b 11 00 push $0x113bc4 110702: 6a 00 push $0x0 110704: 83 c2 44 add $0x44,%edx 110707: 52 push %edx 110708: e8 8b 31 00 00 call 113898 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
11070d: e8 de 2c 00 00 call 1133f0 <_Thread_Enable_dispatch>
if ( value_ptr )
110712: 83 c4 10 add $0x10,%esp 110715: 85 db test %ebx,%ebx
110717: 74 2b je 110744 <pthread_join+0x98>
*value_ptr = return_pointer;
110719: 8b 45 f0 mov -0x10(%ebp),%eax 11071c: 89 03 mov %eax,(%ebx)
return 0;
11071e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
110720: 8b 5d fc mov -0x4(%ebp),%ebx 110723: c9 leave 110724: c3 ret 110725: 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();
110728: e8 c3 2c 00 00 call 1133f0 <_Thread_Enable_dispatch>
return EINVAL;
11072d: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
110732: 8b 5d fc mov -0x4(%ebp),%ebx 110735: c9 leave 110736: c3 ret 110737: 90 nop
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
_Thread_Enable_dispatch();
110738: e8 b3 2c 00 00 call 1133f0 <_Thread_Enable_dispatch>
return EDEADLK;
11073d: b8 2d 00 00 00 mov $0x2d,%eax 110742: eb 8d jmp 1106d1 <pthread_join+0x25>
_Thread_Enable_dispatch();
if ( value_ptr )
*value_ptr = return_pointer;
return 0;
110744: 31 c0 xor %eax,%eax 110746: eb 89 jmp 1106d1 <pthread_join+0x25>
0010aaec <pthread_key_create>:
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
10aaec: 55 push %ebp 10aaed: 89 e5 mov %esp,%ebp 10aaef: 57 push %edi 10aaf0: 56 push %esi 10aaf1: 53 push %ebx 10aaf2: 83 ec 28 sub $0x28,%esp 10aaf5: a1 4c 96 12 00 mov 0x12964c,%eax 10aafa: 40 inc %eax 10aafb: a3 4c 96 12 00 mov %eax,0x12964c
* 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 );
10ab00: 68 c0 9a 12 00 push $0x129ac0 10ab05: e8 6e 20 00 00 call 10cb78 <_Objects_Allocate> 10ab0a: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
10ab0c: 83 c4 10 add $0x10,%esp 10ab0f: 85 c0 test %eax,%eax
10ab11: 74 79 je 10ab8c <pthread_key_create+0xa0>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
10ab13: 8b 45 0c mov 0xc(%ebp),%eax 10ab16: 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++ ) {
10ab19: bb 01 00 00 00 mov $0x1,%ebx
the_key->Values[ the_api ] = NULL;
10ab1e: c7 44 9e 14 00 00 00 movl $0x0,0x14(%esi,%ebx,4)
10ab25: 00
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
10ab26: 8b 04 9d 24 96 12 00 mov 0x129624(,%ebx,4),%eax 10ab2d: 8b 40 04 mov 0x4(%eax),%eax 10ab30: 0f b7 40 10 movzwl 0x10(%eax),%eax
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
10ab34: 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 );
10ab3b: 83 ec 0c sub $0xc,%esp 10ab3e: 51 push %ecx 10ab3f: 89 4d e4 mov %ecx,-0x1c(%ebp) 10ab42: e8 d9 40 00 00 call 10ec20 <_Workspace_Allocate>
if ( !table ) {
10ab47: 83 c4 10 add $0x10,%esp 10ab4a: 85 c0 test %eax,%eax 10ab4c: 8b 4d e4 mov -0x1c(%ebp),%ecx
10ab4f: 74 4f je 10aba0 <pthread_key_create+0xb4>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
10ab51: 89 44 9e 14 mov %eax,0x14(%esi,%ebx,4)
memset( table, '\0', bytes_to_allocate );
10ab55: 89 c7 mov %eax,%edi 10ab57: 31 c0 xor %eax,%eax 10ab59: 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++ ) {
10ab5b: 43 inc %ebx 10ab5c: 83 fb 04 cmp $0x4,%ebx
10ab5f: 75 bd jne 10ab1e <pthread_key_create+0x32>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10ab61: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ab64: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ab67: 8b 15 dc 9a 12 00 mov 0x129adc,%edx 10ab6d: 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;
10ab70: 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;
10ab77: 8b 55 08 mov 0x8(%ebp),%edx 10ab7a: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10ab7c: e8 bb 2f 00 00 call 10db3c <_Thread_Enable_dispatch>
return 0;
10ab81: 31 c0 xor %eax,%eax
}
10ab83: 8d 65 f4 lea -0xc(%ebp),%esp 10ab86: 5b pop %ebx 10ab87: 5e pop %esi 10ab88: 5f pop %edi 10ab89: c9 leave 10ab8a: c3 ret 10ab8b: 90 nop
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
_Thread_Enable_dispatch();
10ab8c: e8 ab 2f 00 00 call 10db3c <_Thread_Enable_dispatch>
return EAGAIN;
10ab91: 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;
}
10ab96: 8d 65 f4 lea -0xc(%ebp),%esp 10ab99: 5b pop %ebx 10ab9a: 5e pop %esi 10ab9b: 5f pop %edi 10ab9c: c9 leave 10ab9d: c3 ret 10ab9e: 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 );
10aba0: 83 ec 0c sub $0xc,%esp 10aba3: 56 push %esi 10aba4: e8 87 00 00 00 call 10ac30 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10aba9: 58 pop %eax 10abaa: 5a pop %edx 10abab: 56 push %esi 10abac: 68 c0 9a 12 00 push $0x129ac0 10abb1: e8 36 23 00 00 call 10ceec <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10abb6: e8 81 2f 00 00 call 10db3c <_Thread_Enable_dispatch>
return ENOMEM;
10abbb: 83 c4 10 add $0x10,%esp 10abbe: 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;
}
10abc3: 8d 65 f4 lea -0xc(%ebp),%esp 10abc6: 5b pop %ebx 10abc7: 5e pop %esi 10abc8: 5f pop %edi 10abc9: c9 leave 10abca: c3 ret
0010abcc <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
)
{
10abcc: 55 push %ebp 10abcd: 89 e5 mov %esp,%ebp 10abcf: 53 push %ebx 10abd0: 83 ec 18 sub $0x18,%esp
POSIX_Keys_Control *the_key;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
10abd3: 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 );
10abd6: 50 push %eax 10abd7: ff 75 08 pushl 0x8(%ebp) 10abda: 68 c0 9a 12 00 push $0x129ac0 10abdf: e8 48 24 00 00 call 10d02c <_Objects_Get> 10abe4: 89 c3 mov %eax,%ebx
switch ( location ) {
10abe6: 83 c4 10 add $0x10,%esp 10abe9: 8b 4d f4 mov -0xc(%ebp),%ecx 10abec: 85 c9 test %ecx,%ecx
10abee: 75 34 jne 10ac24 <pthread_key_delete+0x58>
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
10abf0: 83 ec 08 sub $0x8,%esp 10abf3: 50 push %eax 10abf4: 68 c0 9a 12 00 push $0x129ac0 10abf9: e8 f6 1f 00 00 call 10cbf4 <_Objects_Close>
_POSIX_Keys_Free_memory( the_key );
10abfe: 89 1c 24 mov %ebx,(%esp) 10ac01: e8 2a 00 00 00 call 10ac30 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10ac06: 58 pop %eax 10ac07: 5a pop %edx 10ac08: 53 push %ebx 10ac09: 68 c0 9a 12 00 push $0x129ac0 10ac0e: e8 d9 22 00 00 call 10ceec <_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();
10ac13: e8 24 2f 00 00 call 10db3c <_Thread_Enable_dispatch>
return 0;
10ac18: 83 c4 10 add $0x10,%esp 10ac1b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10ac1d: 8b 5d fc mov -0x4(%ebp),%ebx 10ac20: c9 leave 10ac21: c3 ret 10ac22: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10ac24: b8 16 00 00 00 mov $0x16,%eax
}
10ac29: 8b 5d fc mov -0x4(%ebp),%ebx 10ac2c: c9 leave 10ac2d: c3 ret
001248ec <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
1248ec: 55 push %ebp 1248ed: 89 e5 mov %esp,%ebp 1248ef: 57 push %edi 1248f0: 56 push %esi 1248f1: 53 push %ebx 1248f2: 83 ec 1c sub $0x1c,%esp 1248f5: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
1248f8: 85 db test %ebx,%ebx
1248fa: 0f 84 80 00 00 00 je 124980 <pthread_kill+0x94>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
124900: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
124903: 83 ff 1f cmp $0x1f,%edi
124906: 77 78 ja 124980 <pthread_kill+0x94>
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
124908: 83 ec 08 sub $0x8,%esp 12490b: 8d 45 e4 lea -0x1c(%ebp),%eax 12490e: 50 push %eax 12490f: ff 75 08 pushl 0x8(%ebp) 124912: e8 2d d5 fe ff call 111e44 <_Thread_Get> 124917: 89 c6 mov %eax,%esi
switch ( location ) {
124919: 83 c4 10 add $0x10,%esp 12491c: 8b 4d e4 mov -0x1c(%ebp),%ecx 12491f: 85 c9 test %ecx,%ecx
124921: 75 71 jne 124994 <pthread_kill+0xa8> <== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124923: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
124929: 8d 04 5b lea (%ebx,%ebx,2),%eax 12492c: 83 3c 85 a8 dc 12 00 cmpl $0x1,0x12dca8(,%eax,4)
124933: 01
124934: 74 2d je 124963 <pthread_kill+0x77>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124936: b8 01 00 00 00 mov $0x1,%eax 12493b: 89 f9 mov %edi,%ecx 12493d: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
12493f: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
124945: 52 push %edx 124946: 6a 00 push $0x0 124948: 53 push %ebx 124949: 56 push %esi 12494a: e8 7d fe ff ff call 1247cc <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
12494f: 83 c4 10 add $0x10,%esp 124952: a1 34 dc 12 00 mov 0x12dc34,%eax 124957: 85 c0 test %eax,%eax
124959: 74 08 je 124963 <pthread_kill+0x77>
12495b: 3b 35 38 dc 12 00 cmp 0x12dc38,%esi
124961: 74 11 je 124974 <pthread_kill+0x88>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
124963: e8 b8 d4 fe ff call 111e20 <_Thread_Enable_dispatch>
return 0;
124968: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
12496a: 8d 65 f4 lea -0xc(%ebp),%esp 12496d: 5b pop %ebx 12496e: 5e pop %esi 12496f: 5f pop %edi 124970: c9 leave 124971: c3 ret 124972: 66 90 xchg %ax,%ax
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;
124974: c6 05 44 dc 12 00 01 movb $0x1,0x12dc44 12497b: eb e6 jmp 124963 <pthread_kill+0x77> 12497d: 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 );
124980: e8 17 36 ff ff call 117f9c <__errno> 124985: c7 00 16 00 00 00 movl $0x16,(%eax) 12498b: b8 ff ff ff ff mov $0xffffffff,%eax 124990: eb d8 jmp 12496a <pthread_kill+0x7e> 124992: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
124994: e8 03 36 ff ff call 117f9c <__errno> <== NOT EXECUTED 124999: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 12499f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1249a4: eb c4 jmp 12496a <pthread_kill+0x7e> <== NOT EXECUTED
0010c734 <pthread_mutex_getprioceiling>:
int pthread_mutex_getprioceiling(
pthread_mutex_t *mutex,
int *prioceiling
)
{
10c734: 55 push %ebp 10c735: 89 e5 mov %esp,%ebp 10c737: 53 push %ebx 10c738: 83 ec 14 sub $0x14,%esp 10c73b: 8b 5d 0c mov 0xc(%ebp),%ebx
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
if ( !prioceiling )
10c73e: 85 db test %ebx,%ebx
10c740: 74 19 je 10c75b <pthread_mutex_getprioceiling+0x27>
return EINVAL;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
10c742: 83 ec 08 sub $0x8,%esp 10c745: 8d 45 f4 lea -0xc(%ebp),%eax 10c748: 50 push %eax 10c749: ff 75 08 pushl 0x8(%ebp) 10c74c: e8 3b ff ff ff call 10c68c <_POSIX_Mutex_Get>
switch ( location ) {
10c751: 83 c4 10 add $0x10,%esp 10c754: 8b 55 f4 mov -0xc(%ebp),%edx 10c757: 85 d2 test %edx,%edx
10c759: 74 0d je 10c768 <pthread_mutex_getprioceiling+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c75b: b8 16 00 00 00 mov $0x16,%eax
}
10c760: 8b 5d fc mov -0x4(%ebp),%ebx 10c763: c9 leave 10c764: c3 ret 10c765: 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);
10c768: 0f b6 15 dc 83 12 00 movzbl 0x1283dc,%edx 10c76f: 2b 50 60 sub 0x60(%eax),%edx 10c772: 89 13 mov %edx,(%ebx)
case OBJECTS_LOCAL:
*prioceiling = _POSIX_Priority_From_core(
the_mutex->Mutex.Attributes.priority_ceiling
);
_Thread_Enable_dispatch();
10c774: e8 37 34 00 00 call 10fbb0 <_Thread_Enable_dispatch>
return 0;
10c779: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c77b: 8b 5d fc mov -0x4(%ebp),%ebx 10c77e: c9 leave 10c77f: c3 ret
0010c780 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
10c780: 55 push %ebp 10c781: 89 e5 mov %esp,%ebp 10c783: 57 push %edi 10c784: 56 push %esi 10c785: 53 push %ebx 10c786: 83 ec 1c sub $0x1c,%esp 10c789: 8b 75 08 mov 0x8(%ebp),%esi 10c78c: 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;
10c78f: 85 db test %ebx,%ebx
10c791: 0f 84 09 01 00 00 je 10c8a0 <pthread_mutex_init+0x120>
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
10c797: 85 f6 test %esi,%esi
10c799: 0f 84 e5 00 00 00 je 10c884 <pthread_mutex_init+0x104>
}
}
}
#endif
if ( !the_attr->is_initialized )
10c79f: 8b 13 mov (%ebx),%edx 10c7a1: 85 d2 test %edx,%edx
10c7a3: 0f 84 db 00 00 00 je 10c884 <pthread_mutex_init+0x104>
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10c7a9: 8b 43 04 mov 0x4(%ebx),%eax 10c7ac: 83 f8 01 cmp $0x1,%eax
10c7af: 0f 84 f7 00 00 00 je 10c8ac <pthread_mutex_init+0x12c>
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
10c7b5: 85 c0 test %eax,%eax
10c7b7: 0f 85 c7 00 00 00 jne 10c884 <pthread_mutex_init+0x104>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
10c7bd: 8b 43 0c mov 0xc(%ebx),%eax 10c7c0: 83 f8 01 cmp $0x1,%eax
10c7c3: 0f 84 eb 00 00 00 je 10c8b4 <pthread_mutex_init+0x134>
10c7c9: 83 f8 02 cmp $0x2,%eax
10c7cc: 0f 84 c2 00 00 00 je 10c894 <pthread_mutex_init+0x114>
10c7d2: 85 c0 test %eax,%eax
10c7d4: 0f 85 aa 00 00 00 jne 10c884 <pthread_mutex_init+0x104>
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
10c7da: 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 ) )
10c7e1: 83 ec 0c sub $0xc,%esp 10c7e4: ff 73 08 pushl 0x8(%ebx) 10c7e7: e8 58 03 00 00 call 10cb44 <_POSIX_Priority_Is_valid> 10c7ec: 83 c4 10 add $0x10,%esp 10c7ef: 84 c0 test %al,%al
10c7f1: 0f 84 8d 00 00 00 je 10c884 <pthread_mutex_init+0x104>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
10c7f7: 83 7b 10 03 cmpl $0x3,0x10(%ebx)
10c7fb: 0f 87 83 00 00 00 ja 10c884 <pthread_mutex_init+0x104>
10c801: a1 8c c6 12 00 mov 0x12c68c,%eax 10c806: 40 inc %eax 10c807: a3 8c c6 12 00 mov %eax,0x12c68c
* _POSIX_Mutex_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void )
{
return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information );
10c80c: 83 ec 0c sub $0xc,%esp 10c80f: 68 60 ca 12 00 push $0x12ca60 10c814: e8 d3 23 00 00 call 10ebec <_Objects_Allocate> 10c819: 89 c7 mov %eax,%edi
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
10c81b: 83 c4 10 add $0x10,%esp 10c81e: 85 c0 test %eax,%eax
10c820: 0f 84 9a 00 00 00 je 10c8c0 <pthread_mutex_init+0x140>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
10c826: 8b 43 04 mov 0x4(%ebx),%eax 10c829: 89 47 10 mov %eax,0x10(%edi)
the_mutex_attr = &the_mutex->Mutex.Attributes;
10c82c: 8d 57 54 lea 0x54(%edi),%edx
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10c82f: 31 c0 xor %eax,%eax 10c831: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10c835: 0f 94 c0 sete %al 10c838: 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;
10c83b: 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);
10c83f: 0f b6 05 dc 83 12 00 movzbl 0x1283dc,%eax 10c846: 2b 43 08 sub 0x8(%ebx),%eax 10c849: 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;
10c84c: 8b 45 e4 mov -0x1c(%ebp),%eax 10c84f: 89 47 5c mov %eax,0x5c(%edi)
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
10c852: 50 push %eax 10c853: 6a 01 push $0x1 10c855: 52 push %edx 10c856: 8d 47 14 lea 0x14(%edi),%eax 10c859: 50 push %eax 10c85a: e8 19 1b 00 00 call 10e378 <_CORE_mutex_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c85f: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10c862: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c865: 8b 15 7c ca 12 00 mov 0x12ca7c,%edx 10c86b: 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;
10c86e: 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;
10c875: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c877: e8 34 33 00 00 call 10fbb0 <_Thread_Enable_dispatch>
return 0;
10c87c: 83 c4 10 add $0x10,%esp 10c87f: 31 c0 xor %eax,%eax 10c881: eb 06 jmp 10c889 <pthread_mutex_init+0x109> 10c883: 90 nop
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
10c884: b8 16 00 00 00 mov $0x16,%eax
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10c889: 8d 65 f4 lea -0xc(%ebp),%esp 10c88c: 5b pop %ebx 10c88d: 5e pop %esi 10c88e: 5f pop %edi 10c88f: c9 leave 10c890: c3 ret 10c891: 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;
10c894: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp)
break;
10c89b: e9 41 ff ff ff jmp 10c7e1 <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;
10c8a0: bb e0 ca 12 00 mov $0x12cae0,%ebx 10c8a5: e9 ed fe ff ff jmp 10c797 <pthread_mutex_init+0x17> 10c8aa: 66 90 xchg %ax,%ax
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return ENOSYS;
10c8ac: b8 58 00 00 00 mov $0x58,%eax 10c8b1: eb d6 jmp 10c889 <pthread_mutex_init+0x109> 10c8b3: 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;
10c8b4: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) 10c8bb: e9 21 ff ff ff jmp 10c7e1 <pthread_mutex_init+0x61>
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
_Thread_Enable_dispatch();
10c8c0: e8 eb 32 00 00 call 10fbb0 <_Thread_Enable_dispatch>
return EAGAIN;
10c8c5: b8 0b 00 00 00 mov $0xb,%eax 10c8ca: eb bd jmp 10c889 <pthread_mutex_init+0x109>
0010c9d8 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10c9d8: 55 push %ebp 10c9d9: 89 e5 mov %esp,%ebp 10c9db: 56 push %esi 10c9dc: 53 push %ebx 10c9dd: 83 ec 18 sub $0x18,%esp 10c9e0: 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 );
10c9e3: 8d 45 f4 lea -0xc(%ebp),%eax 10c9e6: 50 push %eax 10c9e7: ff 75 0c pushl 0xc(%ebp) 10c9ea: e8 cd 00 00 00 call 10cabc <_POSIX_Absolute_timeout_to_ticks> 10c9ef: 89 c3 mov %eax,%ebx
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
10c9f1: 83 c4 10 add $0x10,%esp 10c9f4: 83 f8 03 cmp $0x3,%eax
10c9f7: 74 2f je 10ca28 <pthread_mutex_timedlock+0x50>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10c9f9: 50 push %eax 10c9fa: ff 75 f4 pushl -0xc(%ebp) 10c9fd: 6a 00 push $0x0 10c9ff: 56 push %esi 10ca00: e8 db fe ff ff call 10c8e0 <_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) ) {
10ca05: 83 c4 10 add $0x10,%esp 10ca08: 83 f8 10 cmp $0x10,%eax
10ca0b: 74 07 je 10ca14 <pthread_mutex_timedlock+0x3c><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
10ca0d: 8d 65 f8 lea -0x8(%ebp),%esp 10ca10: 5b pop %ebx 10ca11: 5e pop %esi 10ca12: c9 leave 10ca13: 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 )
10ca14: 85 db test %ebx,%ebx
10ca16: 74 28 je 10ca40 <pthread_mutex_timedlock+0x68><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10ca18: 4b dec %ebx 10ca19: 83 fb 01 cmp $0x1,%ebx
10ca1c: 77 ef ja 10ca0d <pthread_mutex_timedlock+0x35><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10ca1e: b8 74 00 00 00 mov $0x74,%eax 10ca23: eb e8 jmp 10ca0d <pthread_mutex_timedlock+0x35> 10ca25: 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 );
10ca28: 52 push %edx 10ca29: ff 75 f4 pushl -0xc(%ebp) 10ca2c: 6a 01 push $0x1 10ca2e: 56 push %esi 10ca2f: e8 ac fe ff ff call 10c8e0 <_POSIX_Mutex_Lock_support> 10ca34: 83 c4 10 add $0x10,%esp
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
10ca37: 8d 65 f8 lea -0x8(%ebp),%esp 10ca3a: 5b pop %ebx 10ca3b: 5e pop %esi 10ca3c: c9 leave 10ca3d: c3 ret 10ca3e: 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;
10ca40: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10ca45: eb c6 jmp 10ca0d <pthread_mutex_timedlock+0x35><== NOT EXECUTED
0010c4bc <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
10c4bc: 55 push %ebp 10c4bd: 89 e5 mov %esp,%ebp 10c4bf: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
10c4c2: 85 c0 test %eax,%eax
10c4c4: 74 12 je 10c4d8 <pthread_mutexattr_destroy+0x1c>
10c4c6: 8b 10 mov (%eax),%edx 10c4c8: 85 d2 test %edx,%edx
10c4ca: 74 0c je 10c4d8 <pthread_mutexattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10c4cc: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10c4d2: 31 c0 xor %eax,%eax
}
10c4d4: c9 leave 10c4d5: c3 ret 10c4d6: 66 90 xchg %ax,%ax
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
10c4d8: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10c4dd: c9 leave 10c4de: c3 ret
0010c584 <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
10c584: 55 push %ebp 10c585: 89 e5 mov %esp,%ebp 10c587: 56 push %esi 10c588: 53 push %ebx 10c589: 8b 5d 08 mov 0x8(%ebp),%ebx 10c58c: 8b 75 0c mov 0xc(%ebp),%esi
if ( !attr || !attr->is_initialized )
10c58f: 85 db test %ebx,%ebx
10c591: 74 06 je 10c599 <pthread_mutexattr_setprioceiling+0x15>
10c593: 8b 03 mov (%ebx),%eax 10c595: 85 c0 test %eax,%eax
10c597: 75 0f jne 10c5a8 <pthread_mutexattr_setprioceiling+0x24>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
return EINVAL;
10c599: b8 16 00 00 00 mov $0x16,%eax
attr->prio_ceiling = prioceiling;
return 0;
}
10c59e: 8d 65 f8 lea -0x8(%ebp),%esp 10c5a1: 5b pop %ebx 10c5a2: 5e pop %esi 10c5a3: c9 leave 10c5a4: c3 ret 10c5a5: 8d 76 00 lea 0x0(%esi),%esi
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
10c5a8: 83 ec 0c sub $0xc,%esp 10c5ab: 56 push %esi 10c5ac: e8 93 05 00 00 call 10cb44 <_POSIX_Priority_Is_valid> 10c5b1: 83 c4 10 add $0x10,%esp 10c5b4: 84 c0 test %al,%al
10c5b6: 74 e1 je 10c599 <pthread_mutexattr_setprioceiling+0x15>
return EINVAL;
attr->prio_ceiling = prioceiling;
10c5b8: 89 73 08 mov %esi,0x8(%ebx)
return 0;
10c5bb: 31 c0 xor %eax,%eax
}
10c5bd: 8d 65 f8 lea -0x8(%ebp),%esp 10c5c0: 5b pop %ebx 10c5c1: 5e pop %esi 10c5c2: c9 leave 10c5c3: c3 ret
0010c5ec <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10c5ec: 55 push %ebp 10c5ed: 89 e5 mov %esp,%ebp 10c5ef: 8b 45 08 mov 0x8(%ebp),%eax 10c5f2: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10c5f5: 85 c0 test %eax,%eax
10c5f7: 74 0b je 10c604 <pthread_mutexattr_setpshared+0x18>
10c5f9: 8b 08 mov (%eax),%ecx 10c5fb: 85 c9 test %ecx,%ecx
10c5fd: 74 05 je 10c604 <pthread_mutexattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10c5ff: 83 fa 01 cmp $0x1,%edx
10c602: 76 08 jbe 10c60c <pthread_mutexattr_setpshared+0x20><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10c604: b8 16 00 00 00 mov $0x16,%eax
} }
10c609: c9 leave 10c60a: c3 ret 10c60b: 90 nop
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10c60c: 89 50 04 mov %edx,0x4(%eax)
return 0;
10c60f: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10c611: c9 leave 10c612: c3 ret
0010a7e0 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
10a7e0: 55 push %ebp 10a7e1: 89 e5 mov %esp,%ebp 10a7e3: 8b 45 08 mov 0x8(%ebp),%eax 10a7e6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10a7e9: 85 c0 test %eax,%eax
10a7eb: 74 0b je 10a7f8 <pthread_mutexattr_settype+0x18>
10a7ed: 8b 08 mov (%eax),%ecx 10a7ef: 85 c9 test %ecx,%ecx
10a7f1: 74 05 je 10a7f8 <pthread_mutexattr_settype+0x18><== NEVER TAKEN
return EINVAL;
switch ( type ) {
10a7f3: 83 fa 03 cmp $0x3,%edx
10a7f6: 76 08 jbe 10a800 <pthread_mutexattr_settype+0x20>
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
return 0;
default:
return EINVAL;
10a7f8: b8 16 00 00 00 mov $0x16,%eax
} }
10a7fd: c9 leave 10a7fe: c3 ret 10a7ff: 90 nop
switch ( type ) {
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
10a800: 89 50 10 mov %edx,0x10(%eax)
return 0;
10a803: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10a805: c9 leave 10a806: c3 ret
0010b344 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10b344: 55 push %ebp 10b345: 89 e5 mov %esp,%ebp 10b347: 57 push %edi 10b348: 56 push %esi 10b349: 53 push %ebx 10b34a: 83 ec 1c sub $0x1c,%esp 10b34d: 8b 5d 08 mov 0x8(%ebp),%ebx 10b350: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10b353: 85 db test %ebx,%ebx
10b355: 74 51 je 10b3a8 <pthread_once+0x64>
10b357: 85 f6 test %esi,%esi
10b359: 74 4d je 10b3a8 <pthread_once+0x64>
return EINVAL;
if ( !once_control->init_executed ) {
10b35b: 8b 7b 04 mov 0x4(%ebx),%edi 10b35e: 85 ff test %edi,%edi
10b360: 74 0a je 10b36c <pthread_once+0x28>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10b362: 31 c0 xor %eax,%eax
}
10b364: 8d 65 f4 lea -0xc(%ebp),%esp 10b367: 5b pop %ebx 10b368: 5e pop %esi 10b369: 5f pop %edi 10b36a: c9 leave 10b36b: 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);
10b36c: 51 push %ecx 10b36d: 8d 7d e4 lea -0x1c(%ebp),%edi 10b370: 57 push %edi 10b371: 68 00 01 00 00 push $0x100 10b376: 68 00 01 00 00 push $0x100 10b37b: e8 3c 0b 00 00 call 10bebc <rtems_task_mode>
if ( !once_control->init_executed ) {
10b380: 83 c4 10 add $0x10,%esp 10b383: 8b 53 04 mov 0x4(%ebx),%edx 10b386: 85 d2 test %edx,%edx
10b388: 74 2e je 10b3b8 <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);
10b38a: 50 push %eax 10b38b: 57 push %edi 10b38c: 68 00 01 00 00 push $0x100 10b391: ff 75 e4 pushl -0x1c(%ebp) 10b394: e8 23 0b 00 00 call 10bebc <rtems_task_mode> 10b399: 83 c4 10 add $0x10,%esp
} return 0;
10b39c: 31 c0 xor %eax,%eax
}
10b39e: 8d 65 f4 lea -0xc(%ebp),%esp 10b3a1: 5b pop %ebx 10b3a2: 5e pop %esi 10b3a3: 5f pop %edi 10b3a4: c9 leave 10b3a5: c3 ret 10b3a6: 66 90 xchg %ax,%ax
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10b3a8: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10b3ad: 8d 65 f4 lea -0xc(%ebp),%esp 10b3b0: 5b pop %ebx 10b3b1: 5e pop %esi 10b3b2: 5f pop %edi 10b3b3: c9 leave 10b3b4: c3 ret 10b3b5: 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;
10b3b8: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10b3be: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10b3c5: ff d6 call *%esi 10b3c7: eb c1 jmp 10b38a <pthread_once+0x46>
0010ba28 <pthread_rwlock_destroy>:
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
10ba28: 55 push %ebp 10ba29: 89 e5 mov %esp,%ebp 10ba2b: 53 push %ebx 10ba2c: 83 ec 14 sub $0x14,%esp 10ba2f: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
10ba32: 85 c0 test %eax,%eax
10ba34: 74 42 je 10ba78 <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(
10ba36: 53 push %ebx
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10ba37: 8d 55 f4 lea -0xc(%ebp),%edx 10ba3a: 52 push %edx 10ba3b: ff 30 pushl (%eax) 10ba3d: 68 40 b3 12 00 push $0x12b340 10ba42: e8 f1 29 00 00 call 10e438 <_Objects_Get> 10ba47: 89 c3 mov %eax,%ebx
switch ( location ) {
10ba49: 83 c4 10 add $0x10,%esp 10ba4c: 8b 4d f4 mov -0xc(%ebp),%ecx 10ba4f: 85 c9 test %ecx,%ecx
10ba51: 75 25 jne 10ba78 <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 ) {
10ba53: 83 ec 0c sub $0xc,%esp 10ba56: 8d 40 10 lea 0x10(%eax),%eax 10ba59: 50 push %eax 10ba5a: e8 b9 3c 00 00 call 10f718 <_Thread_queue_First> 10ba5f: 83 c4 10 add $0x10,%esp 10ba62: 85 c0 test %eax,%eax
10ba64: 74 1e je 10ba84 <pthread_rwlock_destroy+0x5c>
_Thread_Enable_dispatch();
10ba66: e8 dd 34 00 00 call 10ef48 <_Thread_Enable_dispatch>
return EBUSY;
10ba6b: b8 10 00 00 00 mov $0x10,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10ba70: 8b 5d fc mov -0x4(%ebp),%ebx 10ba73: c9 leave 10ba74: c3 ret 10ba75: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10ba78: b8 16 00 00 00 mov $0x16,%eax
}
10ba7d: 8b 5d fc mov -0x4(%ebp),%ebx 10ba80: c9 leave 10ba81: c3 ret 10ba82: 66 90 xchg %ax,%ax
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
10ba84: 83 ec 08 sub $0x8,%esp 10ba87: 53 push %ebx 10ba88: 68 40 b3 12 00 push $0x12b340 10ba8d: e8 6e 25 00 00 call 10e000 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
10ba92: 58 pop %eax 10ba93: 5a pop %edx 10ba94: 53 push %ebx 10ba95: 68 40 b3 12 00 push $0x12b340 10ba9a: e8 59 28 00 00 call 10e2f8 <_Objects_Free>
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
10ba9f: e8 a4 34 00 00 call 10ef48 <_Thread_Enable_dispatch>
return 0;
10baa4: 83 c4 10 add $0x10,%esp 10baa7: 31 c0 xor %eax,%eax 10baa9: eb d2 jmp 10ba7d <pthread_rwlock_destroy+0x55>
0010baac <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10baac: 55 push %ebp 10baad: 89 e5 mov %esp,%ebp 10baaf: 56 push %esi 10bab0: 53 push %ebx 10bab1: 83 ec 20 sub $0x20,%esp 10bab4: 8b 5d 08 mov 0x8(%ebp),%ebx 10bab7: 8b 75 0c mov 0xc(%ebp),%esi
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10baba: 85 db test %ebx,%ebx
10babc: 74 15 je 10bad3 <pthread_rwlock_init+0x27>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10babe: 85 f6 test %esi,%esi
10bac0: 0f 84 8e 00 00 00 je 10bb54 <pthread_rwlock_init+0xa8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10bac6: 8b 16 mov (%esi),%edx 10bac8: 85 d2 test %edx,%edx
10baca: 74 07 je 10bad3 <pthread_rwlock_init+0x27><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10bacc: 8b 46 04 mov 0x4(%esi),%eax 10bacf: 85 c0 test %eax,%eax
10bad1: 74 0d je 10bae0 <pthread_rwlock_init+0x34><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
10bad3: b8 16 00 00 00 mov $0x16,%eax
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10bad8: 8d 65 f8 lea -0x8(%ebp),%esp 10badb: 5b pop %ebx 10badc: 5e pop %esi 10badd: c9 leave 10bade: c3 ret 10badf: 90 nop
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10bae0: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10bae7: a1 ec b0 12 00 mov 0x12b0ec,%eax 10baec: 40 inc %eax 10baed: a3 ec b0 12 00 mov %eax,0x12b0ec
* 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 );
10baf2: 83 ec 0c sub $0xc,%esp 10baf5: 68 40 b3 12 00 push $0x12b340 10bafa: e8 85 24 00 00 call 10df84 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10baff: 83 c4 10 add $0x10,%esp 10bb02: 85 c0 test %eax,%eax
10bb04: 74 42 je 10bb48 <pthread_rwlock_init+0x9c>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10bb06: 83 ec 08 sub $0x8,%esp 10bb09: 8d 55 f4 lea -0xc(%ebp),%edx 10bb0c: 52 push %edx 10bb0d: 8d 50 10 lea 0x10(%eax),%edx 10bb10: 52 push %edx 10bb11: 89 45 e4 mov %eax,-0x1c(%ebp) 10bb14: e8 53 1c 00 00 call 10d76c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10bb19: 8b 45 e4 mov -0x1c(%ebp),%eax 10bb1c: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10bb1f: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10bb22: 8b 0d 5c b3 12 00 mov 0x12b35c,%ecx 10bb28: 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;
10bb2b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10bb32: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10bb34: e8 0f 34 00 00 call 10ef48 <_Thread_Enable_dispatch>
return 0;
10bb39: 83 c4 10 add $0x10,%esp 10bb3c: 31 c0 xor %eax,%eax
}
10bb3e: 8d 65 f8 lea -0x8(%ebp),%esp 10bb41: 5b pop %ebx 10bb42: 5e pop %esi 10bb43: c9 leave 10bb44: c3 ret 10bb45: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
10bb48: e8 fb 33 00 00 call 10ef48 <_Thread_Enable_dispatch>
return EAGAIN;
10bb4d: b8 0b 00 00 00 mov $0xb,%eax 10bb52: eb 84 jmp 10bad8 <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 );
10bb54: 83 ec 0c sub $0xc,%esp 10bb57: 8d 75 ec lea -0x14(%ebp),%esi 10bb5a: 56 push %esi 10bb5b: e8 84 09 00 00 call 10c4e4 <pthread_rwlockattr_init> 10bb60: 83 c4 10 add $0x10,%esp 10bb63: e9 5e ff ff ff jmp 10bac6 <pthread_rwlock_init+0x1a>
0010bbd0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10bbd0: 55 push %ebp 10bbd1: 89 e5 mov %esp,%ebp 10bbd3: 56 push %esi 10bbd4: 53 push %ebx 10bbd5: 83 ec 20 sub $0x20,%esp 10bbd8: 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 )
10bbdb: 85 db test %ebx,%ebx
10bbdd: 74 7d je 10bc5c <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 );
10bbdf: 83 ec 08 sub $0x8,%esp 10bbe2: 8d 45 f0 lea -0x10(%ebp),%eax 10bbe5: 50 push %eax 10bbe6: ff 75 0c pushl 0xc(%ebp) 10bbe9: e8 a6 62 00 00 call 111e94 <_POSIX_Absolute_timeout_to_ticks> 10bbee: 89 c6 mov %eax,%esi 10bbf0: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10bbf3: 8d 45 f4 lea -0xc(%ebp),%eax 10bbf6: 50 push %eax 10bbf7: ff 33 pushl (%ebx) 10bbf9: 68 40 b3 12 00 push $0x12b340 10bbfe: e8 35 28 00 00 call 10e438 <_Objects_Get>
switch ( location ) {
10bc03: 83 c4 10 add $0x10,%esp 10bc06: 8b 55 f4 mov -0xc(%ebp),%edx 10bc09: 85 d2 test %edx,%edx
10bc0b: 75 4f jne 10bc5c <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,
10bc0d: 83 fe 03 cmp $0x3,%esi 10bc10: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10bc13: 83 ec 0c sub $0xc,%esp 10bc16: 6a 00 push $0x0 10bc18: ff 75 f0 pushl -0x10(%ebp) 10bc1b: 0f b6 ca movzbl %dl,%ecx 10bc1e: 51 push %ecx 10bc1f: ff 33 pushl (%ebx) 10bc21: 83 c0 10 add $0x10,%eax 10bc24: 50 push %eax 10bc25: 88 55 e4 mov %dl,-0x1c(%ebp) 10bc28: e8 73 1b 00 00 call 10d7a0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10bc2d: 83 c4 20 add $0x20,%esp 10bc30: e8 13 33 00 00 call 10ef48 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10bc35: 8a 55 e4 mov -0x1c(%ebp),%dl 10bc38: 84 d2 test %dl,%dl
10bc3a: 75 40 jne 10bc7c <pthread_rwlock_timedrdlock+0xac>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10bc3c: a1 98 b6 12 00 mov 0x12b698,%eax 10bc41: 8b 40 34 mov 0x34(%eax),%eax 10bc44: 83 f8 02 cmp $0x2,%eax
10bc47: 74 1f je 10bc68 <pthread_rwlock_timedrdlock+0x98>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10bc49: 83 ec 0c sub $0xc,%esp 10bc4c: 50 push %eax 10bc4d: e8 ee 00 00 00 call 10bd40 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10bc52: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10bc55: 8d 65 f8 lea -0x8(%ebp),%esp 10bc58: 5b pop %ebx 10bc59: 5e pop %esi 10bc5a: c9 leave 10bc5b: 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;
10bc5c: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10bc61: 8d 65 f8 lea -0x8(%ebp),%esp 10bc64: 5b pop %ebx 10bc65: 5e pop %esi 10bc66: c9 leave 10bc67: c3 ret
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bc68: 85 f6 test %esi,%esi
10bc6a: 74 f0 je 10bc5c <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bc6c: 4e dec %esi 10bc6d: 83 fe 01 cmp $0x1,%esi
10bc70: 77 d7 ja 10bc49 <pthread_rwlock_timedrdlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
10bc72: b8 74 00 00 00 mov $0x74,%eax 10bc77: eb e8 jmp 10bc61 <pthread_rwlock_timedrdlock+0x91> 10bc79: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
10bc7c: a1 98 b6 12 00 mov 0x12b698,%eax 10bc81: 8b 40 34 mov 0x34(%eax),%eax 10bc84: eb c3 jmp 10bc49 <pthread_rwlock_timedrdlock+0x79>
0010bc88 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10bc88: 55 push %ebp 10bc89: 89 e5 mov %esp,%ebp 10bc8b: 56 push %esi 10bc8c: 53 push %ebx 10bc8d: 83 ec 20 sub $0x20,%esp 10bc90: 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 )
10bc93: 85 db test %ebx,%ebx
10bc95: 74 7d je 10bd14 <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 );
10bc97: 83 ec 08 sub $0x8,%esp 10bc9a: 8d 45 f0 lea -0x10(%ebp),%eax 10bc9d: 50 push %eax 10bc9e: ff 75 0c pushl 0xc(%ebp) 10bca1: e8 ee 61 00 00 call 111e94 <_POSIX_Absolute_timeout_to_ticks> 10bca6: 89 c6 mov %eax,%esi 10bca8: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10bcab: 8d 45 f4 lea -0xc(%ebp),%eax 10bcae: 50 push %eax 10bcaf: ff 33 pushl (%ebx) 10bcb1: 68 40 b3 12 00 push $0x12b340 10bcb6: e8 7d 27 00 00 call 10e438 <_Objects_Get>
switch ( location ) {
10bcbb: 83 c4 10 add $0x10,%esp 10bcbe: 8b 55 f4 mov -0xc(%ebp),%edx 10bcc1: 85 d2 test %edx,%edx
10bcc3: 75 4f jne 10bd14 <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,
10bcc5: 83 fe 03 cmp $0x3,%esi 10bcc8: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10bccb: 83 ec 0c sub $0xc,%esp 10bcce: 6a 00 push $0x0 10bcd0: ff 75 f0 pushl -0x10(%ebp) 10bcd3: 0f b6 ca movzbl %dl,%ecx 10bcd6: 51 push %ecx 10bcd7: ff 33 pushl (%ebx) 10bcd9: 83 c0 10 add $0x10,%eax 10bcdc: 50 push %eax 10bcdd: 88 55 e4 mov %dl,-0x1c(%ebp) 10bce0: e8 83 1b 00 00 call 10d868 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10bce5: 83 c4 20 add $0x20,%esp 10bce8: e8 5b 32 00 00 call 10ef48 <_Thread_Enable_dispatch>
if ( !do_wait &&
10bced: 8a 55 e4 mov -0x1c(%ebp),%dl 10bcf0: 84 d2 test %dl,%dl
10bcf2: 75 40 jne 10bd34 <pthread_rwlock_timedwrlock+0xac>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10bcf4: a1 98 b6 12 00 mov 0x12b698,%eax 10bcf9: 8b 40 34 mov 0x34(%eax),%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10bcfc: 83 f8 02 cmp $0x2,%eax
10bcff: 74 1f je 10bd20 <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(
10bd01: 83 ec 0c sub $0xc,%esp 10bd04: 50 push %eax 10bd05: e8 36 00 00 00 call 10bd40 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10bd0a: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10bd0d: 8d 65 f8 lea -0x8(%ebp),%esp 10bd10: 5b pop %ebx 10bd11: 5e pop %esi 10bd12: c9 leave 10bd13: c3 ret
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10bd14: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10bd19: 8d 65 f8 lea -0x8(%ebp),%esp 10bd1c: 5b pop %ebx 10bd1d: 5e pop %esi 10bd1e: c9 leave 10bd1f: c3 ret
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bd20: 85 f6 test %esi,%esi
10bd22: 74 f0 je 10bd14 <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bd24: 4e dec %esi 10bd25: 83 fe 01 cmp $0x1,%esi
10bd28: 77 d7 ja 10bd01 <pthread_rwlock_timedwrlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
10bd2a: b8 74 00 00 00 mov $0x74,%eax 10bd2f: eb e8 jmp 10bd19 <pthread_rwlock_timedwrlock+0x91> 10bd31: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10bd34: a1 98 b6 12 00 mov 0x12b698,%eax 10bd39: 8b 40 34 mov 0x34(%eax),%eax 10bd3c: eb c3 jmp 10bd01 <pthread_rwlock_timedwrlock+0x79>
0010c49c <pthread_rwlockattr_destroy>:
*/
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
10c49c: 55 push %ebp 10c49d: 89 e5 mov %esp,%ebp 10c49f: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10c4a2: 85 c0 test %eax,%eax
10c4a4: 74 12 je 10c4b8 <pthread_rwlockattr_destroy+0x1c>
10c4a6: 8b 10 mov (%eax),%edx 10c4a8: 85 d2 test %edx,%edx
10c4aa: 74 0c je 10c4b8 <pthread_rwlockattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10c4ac: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10c4b2: 31 c0 xor %eax,%eax
}
10c4b4: c9 leave 10c4b5: c3 ret 10c4b6: 66 90 xchg %ax,%ax
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10c4b8: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10c4bd: c9 leave 10c4be: c3 ret
0010c508 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10c508: 55 push %ebp 10c509: 89 e5 mov %esp,%ebp 10c50b: 8b 45 08 mov 0x8(%ebp),%eax 10c50e: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10c511: 85 c0 test %eax,%eax
10c513: 74 0b je 10c520 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
if ( !attr->is_initialized )
10c515: 8b 08 mov (%eax),%ecx 10c517: 85 c9 test %ecx,%ecx
10c519: 74 05 je 10c520 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10c51b: 83 fa 01 cmp $0x1,%edx
10c51e: 76 08 jbe 10c528 <pthread_rwlockattr_setpshared+0x20><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10c520: b8 16 00 00 00 mov $0x16,%eax
} }
10c525: c9 leave 10c526: c3 ret 10c527: 90 nop
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10c528: 89 50 04 mov %edx,0x4(%eax)
return 0;
10c52b: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10c52d: c9 leave 10c52e: c3 ret
0010a7bc <pthread_setcancelstate>:
int pthread_setcancelstate(
int state,
int *oldstate
)
{
10a7bc: 55 push %ebp 10a7bd: 89 e5 mov %esp,%ebp 10a7bf: 53 push %ebx 10a7c0: 83 ec 04 sub $0x4,%esp 10a7c3: 8b 55 08 mov 0x8(%ebp),%edx 10a7c6: 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() )
10a7c9: 8b 0d 14 90 12 00 mov 0x129014,%ecx 10a7cf: 85 c9 test %ecx,%ecx
10a7d1: 75 15 jne 10a7e8 <pthread_setcancelstate+0x2c>
return EPROTO;
if ( !oldstate )
10a7d3: 85 c0 test %eax,%eax
10a7d5: 74 05 je 10a7dc <pthread_setcancelstate+0x20>
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
10a7d7: 83 fa 01 cmp $0x1,%edx
10a7da: 76 18 jbe 10a7f4 <pthread_setcancelstate+0x38>
return EINVAL;
10a7dc: b8 16 00 00 00 mov $0x16,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10a7e1: 8b 5d fc mov -0x4(%ebp),%ebx 10a7e4: c9 leave 10a7e5: c3 ret 10a7e6: 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;
10a7e8: b8 47 00 00 00 mov $0x47,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10a7ed: 8b 5d fc mov -0x4(%ebp),%ebx 10a7f0: c9 leave 10a7f1: c3 ret 10a7f2: 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 ];
10a7f4: 8b 0d 18 90 12 00 mov 0x129018,%ecx 10a7fa: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a800: 8b 1d 6c 8a 12 00 mov 0x128a6c,%ebx 10a806: 43 inc %ebx 10a807: 89 1d 6c 8a 12 00 mov %ebx,0x128a6c
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
10a80d: 8b 99 d8 00 00 00 mov 0xd8(%ecx),%ebx 10a813: 89 18 mov %ebx,(%eax)
thread_support->cancelability_state = state;
10a815: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx)
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
10a81b: 83 ec 0c sub $0xc,%esp 10a81e: ff 35 18 90 12 00 pushl 0x129018 10a824: e8 43 54 00 00 call 10fc6c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
10a829: 83 c4 10 add $0x10,%esp 10a82c: 31 c0 xor %eax,%eax
}
10a82e: 8b 5d fc mov -0x4(%ebp),%ebx 10a831: c9 leave 10a832: c3 ret
0010a834 <pthread_setcanceltype>:
int pthread_setcanceltype(
int type,
int *oldtype
)
{
10a834: 55 push %ebp 10a835: 89 e5 mov %esp,%ebp 10a837: 53 push %ebx 10a838: 83 ec 04 sub $0x4,%esp 10a83b: 8b 55 08 mov 0x8(%ebp),%edx 10a83e: 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() )
10a841: 8b 0d 14 90 12 00 mov 0x129014,%ecx 10a847: 85 c9 test %ecx,%ecx
10a849: 75 15 jne 10a860 <pthread_setcanceltype+0x2c>
return EPROTO;
if ( !oldtype )
10a84b: 85 c0 test %eax,%eax
10a84d: 74 05 je 10a854 <pthread_setcanceltype+0x20>
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
10a84f: 83 fa 01 cmp $0x1,%edx
10a852: 76 18 jbe 10a86c <pthread_setcanceltype+0x38>
return EINVAL;
10a854: b8 16 00 00 00 mov $0x16,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10a859: 8b 5d fc mov -0x4(%ebp),%ebx 10a85c: c9 leave 10a85d: c3 ret 10a85e: 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;
10a860: b8 47 00 00 00 mov $0x47,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10a865: 8b 5d fc mov -0x4(%ebp),%ebx 10a868: c9 leave 10a869: c3 ret 10a86a: 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 ];
10a86c: 8b 0d 18 90 12 00 mov 0x129018,%ecx 10a872: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10a878: 8b 1d 6c 8a 12 00 mov 0x128a6c,%ebx 10a87e: 43 inc %ebx 10a87f: 89 1d 6c 8a 12 00 mov %ebx,0x128a6c
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
10a885: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx 10a88b: 89 18 mov %ebx,(%eax)
thread_support->cancelability_type = type;
10a88d: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx)
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
10a893: 83 ec 0c sub $0xc,%esp 10a896: ff 35 18 90 12 00 pushl 0x129018 10a89c: e8 cb 53 00 00 call 10fc6c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
10a8a1: 83 c4 10 add $0x10,%esp 10a8a4: 31 c0 xor %eax,%eax
}
10a8a6: 8b 5d fc mov -0x4(%ebp),%ebx 10a8a9: c9 leave 10a8aa: c3 ret
0010d2a8 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10d2a8: 55 push %ebp 10d2a9: 89 e5 mov %esp,%ebp 10d2ab: 57 push %edi 10d2ac: 56 push %esi 10d2ad: 53 push %ebx 10d2ae: 83 ec 2c sub $0x2c,%esp 10d2b1: 8b 75 10 mov 0x10(%ebp),%esi
int rc;
/*
* Check all the parameters
*/
if ( !param )
10d2b4: 85 f6 test %esi,%esi
10d2b6: 0f 84 c8 00 00 00 je 10d384 <pthread_setschedparam+0xdc>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10d2bc: 8d 45 e0 lea -0x20(%ebp),%eax 10d2bf: 50 push %eax 10d2c0: 8d 45 e4 lea -0x1c(%ebp),%eax 10d2c3: 50 push %eax 10d2c4: 56 push %esi 10d2c5: ff 75 0c pushl 0xc(%ebp) 10d2c8: e8 d3 5b 00 00 call 112ea0 <_POSIX_Thread_Translate_sched_param> 10d2cd: 89 c3 mov %eax,%ebx
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10d2cf: 83 c4 10 add $0x10,%esp 10d2d2: 85 c0 test %eax,%eax
10d2d4: 74 0a je 10d2e0 <pthread_setschedparam+0x38>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10d2d6: 89 d8 mov %ebx,%eax 10d2d8: 8d 65 f4 lea -0xc(%ebp),%esp 10d2db: 5b pop %ebx 10d2dc: 5e pop %esi 10d2dd: 5f pop %edi 10d2de: c9 leave 10d2df: c3 ret
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
10d2e0: 83 ec 08 sub $0x8,%esp 10d2e3: 8d 45 dc lea -0x24(%ebp),%eax 10d2e6: 50 push %eax 10d2e7: ff 75 08 pushl 0x8(%ebp) 10d2ea: e8 e5 28 00 00 call 10fbd4 <_Thread_Get> 10d2ef: 89 c2 mov %eax,%edx
switch ( location ) {
10d2f1: 83 c4 10 add $0x10,%esp 10d2f4: 8b 7d dc mov -0x24(%ebp),%edi 10d2f7: 85 ff test %edi,%edi
10d2f9: 0f 85 95 00 00 00 jne 10d394 <pthread_setschedparam+0xec>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10d2ff: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10d305: 89 45 d4 mov %eax,-0x2c(%ebp)
if ( api->schedpolicy == SCHED_SPORADIC )
10d308: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
10d30f: 0f 84 cb 00 00 00 je 10d3e0 <pthread_setschedparam+0x138>
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
10d315: 8b 45 0c mov 0xc(%ebp),%eax 10d318: 8b 4d d4 mov -0x2c(%ebp),%ecx 10d31b: 89 81 84 00 00 00 mov %eax,0x84(%ecx)
api->schedparam = *param;
10d321: 89 cf mov %ecx,%edi 10d323: 81 c7 88 00 00 00 add $0x88,%edi 10d329: b9 07 00 00 00 mov $0x7,%ecx 10d32e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10d330: 8b 45 e4 mov -0x1c(%ebp),%eax 10d333: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10d336: 8b 45 e0 mov -0x20(%ebp),%eax 10d339: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10d33f: 8b 75 0c mov 0xc(%ebp),%esi 10d342: 85 f6 test %esi,%esi
10d344: 78 2e js 10d374 <pthread_setschedparam+0xcc><== NEVER TAKEN
10d346: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10d34a: 7f 58 jg 10d3a4 <pthread_setschedparam+0xfc>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10d34c: a1 60 c6 12 00 mov 0x12c660,%eax 10d351: 89 42 78 mov %eax,0x78(%edx) 10d354: 0f b6 05 dc 83 12 00 movzbl 0x1283dc,%eax 10d35b: 8b 4d d4 mov -0x2c(%ebp),%ecx 10d35e: 2b 81 88 00 00 00 sub 0x88(%ecx),%eax
the_thread->real_priority =
10d364: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10d367: 51 push %ecx 10d368: 6a 01 push $0x1 10d36a: 50 push %eax 10d36b: 52 push %edx 10d36c: e8 07 24 00 00 call 10f778 <_Thread_Change_priority>
the_thread,
the_thread->real_priority,
true
);
break;
10d371: 83 c4 10 add $0x10,%esp
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
10d374: e8 37 28 00 00 call 10fbb0 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10d379: 89 d8 mov %ebx,%eax 10d37b: 8d 65 f4 lea -0xc(%ebp),%esp 10d37e: 5b pop %ebx 10d37f: 5e pop %esi 10d380: 5f pop %edi 10d381: c9 leave 10d382: c3 ret 10d383: 90 nop
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10d384: bb 16 00 00 00 mov $0x16,%ebx
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10d389: 89 d8 mov %ebx,%eax 10d38b: 8d 65 f4 lea -0xc(%ebp),%esp 10d38e: 5b pop %ebx 10d38f: 5e pop %esi 10d390: 5f pop %edi 10d391: c9 leave 10d392: c3 ret 10d393: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10d394: bb 03 00 00 00 mov $0x3,%ebx
}
10d399: 89 d8 mov %ebx,%eax 10d39b: 8d 65 f4 lea -0xc(%ebp),%esp 10d39e: 5b pop %ebx 10d39f: 5e pop %esi 10d3a0: 5f pop %edi 10d3a1: c9 leave 10d3a2: c3 ret 10d3a3: 90 nop
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
10d3a4: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10d3a8: 75 ca jne 10d374 <pthread_setschedparam+0xcc><== NEVER TAKEN
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10d3aa: 8b 4d d4 mov -0x2c(%ebp),%ecx 10d3ad: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax 10d3b3: 89 81 a4 00 00 00 mov %eax,0xa4(%ecx)
_Watchdog_Remove( &api->Sporadic_timer );
10d3b9: 83 ec 0c sub $0xc,%esp 10d3bc: 89 c8 mov %ecx,%eax 10d3be: 05 a8 00 00 00 add $0xa8,%eax 10d3c3: 50 push %eax 10d3c4: 89 55 d0 mov %edx,-0x30(%ebp) 10d3c7: e8 ec 37 00 00 call 110bb8 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10d3cc: 58 pop %eax 10d3cd: 5a pop %edx 10d3ce: 8b 55 d0 mov -0x30(%ebp),%edx 10d3d1: 52 push %edx 10d3d2: 6a 00 push $0x0 10d3d4: e8 b3 fd ff ff call 10d18c <_POSIX_Threads_Sporadic_budget_TSR>
break;
10d3d9: 83 c4 10 add $0x10,%esp 10d3dc: eb 96 jmp 10d374 <pthread_setschedparam+0xcc> 10d3de: 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 );
10d3e0: 83 ec 0c sub $0xc,%esp 10d3e3: 05 a8 00 00 00 add $0xa8,%eax 10d3e8: 50 push %eax 10d3e9: 89 55 d0 mov %edx,-0x30(%ebp) 10d3ec: e8 c7 37 00 00 call 110bb8 <_Watchdog_Remove> 10d3f1: 83 c4 10 add $0x10,%esp 10d3f4: 8b 55 d0 mov -0x30(%ebp),%edx 10d3f7: e9 19 ff ff ff jmp 10d315 <pthread_setschedparam+0x6d>
00111284 <pthread_sigmask>:
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
111284: 55 push %ebp 111285: 89 e5 mov %esp,%ebp 111287: 56 push %esi 111288: 53 push %ebx 111289: 8b 4d 08 mov 0x8(%ebp),%ecx 11128c: 8b 55 0c mov 0xc(%ebp),%edx 11128f: 8b 5d 10 mov 0x10(%ebp),%ebx
POSIX_API_Control *api;
if ( !set && !oset )
111292: 85 d2 test %edx,%edx
111294: 0f 84 8a 00 00 00 je 111324 <pthread_sigmask+0xa0>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
11129a: a1 f8 9c 12 00 mov 0x129cf8,%eax 11129f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
if ( oset )
1112a5: 85 db test %ebx,%ebx
1112a7: 74 0c je 1112b5 <pthread_sigmask+0x31>
*oset = api->signals_blocked;
1112a9: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi 1112af: 89 33 mov %esi,(%ebx)
if ( !set )
1112b1: 85 d2 test %edx,%edx
1112b3: 74 3b je 1112f0 <pthread_sigmask+0x6c>
return 0;
switch ( how ) {
1112b5: 83 f9 01 cmp $0x1,%ecx
1112b8: 74 5e je 111318 <pthread_sigmask+0x94>
1112ba: 83 f9 02 cmp $0x2,%ecx
1112bd: 74 39 je 1112f8 <pthread_sigmask+0x74>
1112bf: 85 c9 test %ecx,%ecx
1112c1: 75 41 jne 111304 <pthread_sigmask+0x80>
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
1112c3: 8b 12 mov (%edx),%edx 1112c5: 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) ) {
1112cb: 8b 15 68 9f 12 00 mov 0x129f68,%edx 1112d1: 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 &
1112d7: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1112dd: f7 d0 not %eax 1112df: 85 c2 test %eax,%edx
1112e1: 74 0d je 1112f0 <pthread_sigmask+0x6c>
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
1112e3: e8 94 c7 ff ff call 10da7c <_Thread_Dispatch>
}
return 0;
1112e8: 31 c0 xor %eax,%eax
}
1112ea: 5b pop %ebx 1112eb: 5e pop %esi 1112ec: c9 leave 1112ed: c3 ret 1112ee: 66 90 xchg %ax,%ax
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
1112f0: 31 c0 xor %eax,%eax
}
1112f2: 5b pop %ebx 1112f3: 5e pop %esi 1112f4: c9 leave 1112f5: c3 ret 1112f6: 66 90 xchg %ax,%ax
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
1112f8: 8b 12 mov (%edx),%edx 1112fa: f7 d2 not %edx 1112fc: 21 90 d0 00 00 00 and %edx,0xd0(%eax)
break;
111302: eb c7 jmp 1112cb <pthread_sigmask+0x47>
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
111304: e8 d7 2a 00 00 call 113de0 <__errno> 111309: c7 00 16 00 00 00 movl $0x16,(%eax) 11130f: b8 ff ff ff ff mov $0xffffffff,%eax
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
111314: 5b pop %ebx 111315: 5e pop %esi 111316: c9 leave 111317: c3 ret
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
111318: 8b 12 mov (%edx),%edx 11131a: 09 90 d0 00 00 00 or %edx,0xd0(%eax)
break;
111320: eb a9 jmp 1112cb <pthread_sigmask+0x47> 111322: 66 90 xchg %ax,%ax
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
111324: 85 db test %ebx,%ebx
111326: 74 dc je 111304 <pthread_sigmask+0x80> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111328: a1 f8 9c 12 00 mov 0x129cf8,%eax 11132d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 111333: e9 71 ff ff ff jmp 1112a9 <pthread_sigmask+0x25>
0010b128 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10b128: 55 push %ebp 10b129: 89 e5 mov %esp,%ebp 10b12b: 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() )
10b12e: 8b 0d b4 97 12 00 mov 0x1297b4,%ecx 10b134: 85 c9 test %ecx,%ecx
10b136: 75 44 jne 10b17c <pthread_testcancel+0x54><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b138: a1 b8 97 12 00 mov 0x1297b8,%eax 10b13d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10b143: 8b 15 0c 92 12 00 mov 0x12920c,%edx 10b149: 42 inc %edx 10b14a: 89 15 0c 92 12 00 mov %edx,0x12920c
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10b150: 8b 90 d8 00 00 00 mov 0xd8(%eax),%edx 10b156: 85 d2 test %edx,%edx
10b158: 75 26 jne 10b180 <pthread_testcancel+0x58><== NEVER TAKEN
10b15a: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10b160: 85 c0 test %eax,%eax
10b162: 74 1c je 10b180 <pthread_testcancel+0x58>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10b164: e8 2f 27 00 00 call 10d898 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10b169: 83 ec 08 sub $0x8,%esp 10b16c: 6a ff push $0xffffffff 10b16e: ff 35 b8 97 12 00 pushl 0x1297b8 10b174: e8 3f 5b 00 00 call 110cb8 <_POSIX_Thread_Exit>
10b179: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10b17c: c9 leave <== NOT EXECUTED 10b17d: c3 ret <== NOT EXECUTED 10b17e: 66 90 xchg %ax,%ax <== NOT EXECUTED
10b180: c9 leave
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10b181: e9 12 27 00 00 jmp 10d898 <_Thread_Enable_dispatch>
0010baf8 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10baf8: 55 push %ebp 10baf9: 89 e5 mov %esp,%ebp 10bafb: 57 push %edi 10bafc: 56 push %esi 10bafd: 53 push %ebx 10bafe: 83 ec 58 sub $0x58,%esp 10bb01: 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);
10bb04: 68 a0 94 12 00 push $0x1294a0 10bb09: e8 86 09 00 00 call 10c494 <pthread_mutex_lock> 10bb0e: 89 c6 mov %eax,%esi
if (result != 0) {
10bb10: 83 c4 10 add $0x10,%esp 10bb13: 85 c0 test %eax,%eax
10bb15: 0f 85 c1 00 00 00 jne 10bbdc <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);
10bb1b: e8 20 12 00 00 call 10cd40 <pthread_self> 10bb20: 51 push %ecx 10bb21: 8d 55 c4 lea -0x3c(%ebp),%edx 10bb24: 52 push %edx 10bb25: 8d 55 e0 lea -0x20(%ebp),%edx 10bb28: 52 push %edx 10bb29: 50 push %eax 10bb2a: e8 e1 0d 00 00 call 10c910 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10bb2f: e8 0c 12 00 00 call 10cd40 <pthread_self> 10bb34: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10bb37: 8b 43 14 mov 0x14(%ebx),%eax 10bb3a: 8b 55 c4 mov -0x3c(%ebp),%edx 10bb3d: 2b 50 14 sub 0x14(%eax),%edx 10bb40: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10bb43: 8b 55 e0 mov -0x20(%ebp),%edx 10bb46: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10bb49: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10bb50: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10bb57: 83 c4 10 add $0x10,%esp 10bb5a: 8b 15 08 95 12 00 mov 0x129508,%edx 10bb60: 85 d2 test %edx,%edx
10bb62: 75 0d jne 10bb71 <rtems_aio_enqueue+0x79><== NEVER TAKEN
10bb64: 83 3d 04 95 12 00 04 cmpl $0x4,0x129504
10bb6b: 0f 8e 83 00 00 00 jle 10bbf4 <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,
10bb71: 51 push %ecx 10bb72: 6a 00 push $0x0 10bb74: ff 30 pushl (%eax) 10bb76: 68 e8 94 12 00 push $0x1294e8 10bb7b: e8 28 fb ff ff call 10b6a8 <rtems_aio_search_fd> 10bb80: 89 c7 mov %eax,%edi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10bb82: 83 c4 10 add $0x10,%esp 10bb85: 85 c0 test %eax,%eax
10bb87: 0f 84 df 00 00 00 je 10bc6c <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
10bb8d: 8d 57 1c lea 0x1c(%edi),%edx 10bb90: 83 ec 0c sub $0xc,%esp 10bb93: 52 push %edx 10bb94: 89 55 b4 mov %edx,-0x4c(%ebp) 10bb97: e8 f8 08 00 00 call 10c494 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10bb9c: 58 pop %eax 10bb9d: 5a pop %edx 10bb9e: 53 push %ebx 10bb9f: 8d 47 08 lea 0x8(%edi),%eax 10bba2: 50 push %eax 10bba3: e8 48 fe ff ff call 10b9f0 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10bba8: 83 c7 20 add $0x20,%edi 10bbab: 89 3c 24 mov %edi,(%esp) 10bbae: e8 b1 04 00 00 call 10c064 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10bbb3: 8b 55 b4 mov -0x4c(%ebp),%edx 10bbb6: 89 14 24 mov %edx,(%esp) 10bbb9: e8 5e 09 00 00 call 10c51c <pthread_mutex_unlock> 10bbbe: 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);
10bbc1: 83 ec 0c sub $0xc,%esp 10bbc4: 68 a0 94 12 00 push $0x1294a0 10bbc9: e8 4e 09 00 00 call 10c51c <pthread_mutex_unlock>
return 0;
10bbce: 83 c4 10 add $0x10,%esp
}
10bbd1: 89 f0 mov %esi,%eax 10bbd3: 8d 65 f4 lea -0xc(%ebp),%esp 10bbd6: 5b pop %ebx 10bbd7: 5e pop %esi 10bbd8: 5f pop %edi 10bbd9: c9 leave 10bbda: c3 ret 10bbdb: 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);
10bbdc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bbdf: 53 push %ebx <== NOT EXECUTED 10bbe0: e8 cf c4 ff ff call 1080b4 <free> <== NOT EXECUTED
return result;
10bbe5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
10bbe8: 89 f0 mov %esi,%eax <== NOT EXECUTED 10bbea: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bbed: 5b pop %ebx <== NOT EXECUTED 10bbee: 5e pop %esi <== NOT EXECUTED 10bbef: 5f pop %edi <== NOT EXECUTED 10bbf0: c9 leave <== NOT EXECUTED 10bbf1: c3 ret <== NOT EXECUTED 10bbf2: 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);
10bbf4: 57 push %edi 10bbf5: 6a 01 push $0x1 10bbf7: ff 30 pushl (%eax) 10bbf9: 68 e8 94 12 00 push $0x1294e8 10bbfe: e8 a5 fa ff ff call 10b6a8 <rtems_aio_search_fd> 10bc03: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10bc05: 83 c4 10 add $0x10,%esp 10bc08: 83 78 18 01 cmpl $0x1,0x18(%eax)
10bc0c: 0f 85 7b ff ff ff jne 10bb8d <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);
10bc12: 83 ec 08 sub $0x8,%esp 10bc15: 53 push %ebx 10bc16: 8d 40 08 lea 0x8(%eax),%eax 10bc19: 50 push %eax 10bc1a: e8 c9 21 00 00 call 10dde8 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0;
10bc1f: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10bc26: 5a pop %edx 10bc27: 59 pop %ecx 10bc28: 6a 00 push $0x0 10bc2a: 8d 47 1c lea 0x1c(%edi),%eax 10bc2d: 50 push %eax 10bc2e: e8 15 07 00 00 call 10c348 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10bc33: 5b pop %ebx 10bc34: 58 pop %eax 10bc35: 6a 00 push $0x0 10bc37: 8d 47 20 lea 0x20(%edi),%eax 10bc3a: 50 push %eax 10bc3b: e8 70 03 00 00 call 10bfb0 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10bc40: 57 push %edi 10bc41: 68 a4 b7 10 00 push $0x10b7a4 10bc46: 68 a8 94 12 00 push $0x1294a8 10bc4b: 8d 45 e4 lea -0x1c(%ebp),%eax 10bc4e: 50 push %eax 10bc4f: e8 34 0a 00 00 call 10c688 <pthread_create> 10bc54: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10bc56: 83 c4 20 add $0x20,%esp 10bc59: 85 c0 test %eax,%eax
10bc5b: 0f 85 8e 00 00 00 jne 10bcef <rtems_aio_enqueue+0x1f7><== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
10bc61: ff 05 04 95 12 00 incl 0x129504 10bc67: e9 55 ff ff ff jmp 10bbc1 <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);
10bc6c: 57 push %edi 10bc6d: 6a 01 push $0x1 10bc6f: 8b 43 14 mov 0x14(%ebx),%eax 10bc72: ff 30 pushl (%eax) 10bc74: 68 f4 94 12 00 push $0x1294f4 10bc79: e8 2a fa ff ff call 10b6a8 <rtems_aio_search_fd> 10bc7e: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10bc80: 83 c4 10 add $0x10,%esp 10bc83: 83 78 18 01 cmpl $0x1,0x18(%eax)
10bc87: 74 33 je 10bcbc <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);
10bc89: 83 ec 08 sub $0x8,%esp 10bc8c: 53 push %ebx 10bc8d: 83 c7 08 add $0x8,%edi 10bc90: 57 push %edi 10bc91: e8 5a fd ff ff call 10b9f0 <rtems_aio_insert_prio> 10bc96: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10bc99: 8b 0d 08 95 12 00 mov 0x129508,%ecx 10bc9f: 85 c9 test %ecx,%ecx
10bca1: 0f 8e 1a ff ff ff jle 10bbc1 <rtems_aio_enqueue+0xc9><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10bca7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bcaa: 68 a4 94 12 00 push $0x1294a4 <== NOT EXECUTED 10bcaf: e8 b0 03 00 00 call 10c064 <pthread_cond_signal> <== NOT EXECUTED 10bcb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bcb7: e9 05 ff ff ff jmp 10bbc1 <rtems_aio_enqueue+0xc9><== NOT EXECUTED
10bcbc: 83 ec 08 sub $0x8,%esp 10bcbf: 53 push %ebx 10bcc0: 8d 40 08 lea 0x8(%eax),%eax 10bcc3: 50 push %eax 10bcc4: e8 1f 21 00 00 call 10dde8 <_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;
10bcc9: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10bcd0: 5a pop %edx 10bcd1: 59 pop %ecx 10bcd2: 6a 00 push $0x0 10bcd4: 8d 47 1c lea 0x1c(%edi),%eax 10bcd7: 50 push %eax 10bcd8: e8 6b 06 00 00 call 10c348 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10bcdd: 5b pop %ebx 10bcde: 58 pop %eax 10bcdf: 6a 00 push $0x0 10bce1: 83 c7 20 add $0x20,%edi 10bce4: 57 push %edi 10bce5: e8 c6 02 00 00 call 10bfb0 <pthread_cond_init> 10bcea: 83 c4 10 add $0x10,%esp 10bced: eb aa jmp 10bc99 <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);
10bcef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bcf2: 68 a0 94 12 00 push $0x1294a0 <== NOT EXECUTED 10bcf7: e8 20 08 00 00 call 10c51c <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10bcfc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bcff: 89 de mov %ebx,%esi <== NOT EXECUTED 10bd01: e9 cb fe ff ff jmp 10bbd1 <rtems_aio_enqueue+0xd9><== NOT EXECUTED
0010b7a4 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10b7a4: 55 push %ebp 10b7a5: 89 e5 mov %esp,%ebp 10b7a7: 57 push %edi 10b7a8: 56 push %esi 10b7a9: 53 push %ebx 10b7aa: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10b7ad: 8b 7d 08 mov 0x8(%ebp),%edi 10b7b0: 8d 47 1c lea 0x1c(%edi),%eax 10b7b3: 89 45 b4 mov %eax,-0x4c(%ebp) 10b7b6: 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);
10b7b8: 83 ec 0c sub $0xc,%esp 10b7bb: ff 75 b4 pushl -0x4c(%ebp) 10b7be: e8 d1 0c 00 00 call 10c494 <pthread_mutex_lock>
if (result != 0)
10b7c3: 83 c4 10 add $0x10,%esp 10b7c6: 85 c0 test %eax,%eax
10b7c8: 0f 85 2a 01 00 00 jne 10b8f8 <rtems_aio_handle+0x154><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b7ce: 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 );
10b7d1: 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)) {
10b7d4: 39 c3 cmp %eax,%ebx
10b7d6: 0f 84 d0 00 00 00 je 10b8ac <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);
10b7dc: e8 5f 15 00 00 call 10cd40 <pthread_self> 10b7e1: 52 push %edx 10b7e2: 8d 55 c0 lea -0x40(%ebp),%edx 10b7e5: 52 push %edx 10b7e6: 8d 55 e4 lea -0x1c(%ebp),%edx 10b7e9: 52 push %edx 10b7ea: 50 push %eax 10b7eb: e8 20 11 00 00 call 10c910 <pthread_getschedparam>
param.sched_priority = req->priority;
10b7f0: 8b 43 0c mov 0xc(%ebx),%eax 10b7f3: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10b7f6: 8b 73 08 mov 0x8(%ebx),%esi 10b7f9: e8 42 15 00 00 call 10cd40 <pthread_self> 10b7fe: 83 c4 0c add $0xc,%esp 10b801: 8d 55 c0 lea -0x40(%ebp),%edx 10b804: 52 push %edx 10b805: 56 push %esi 10b806: 50 push %eax 10b807: e8 44 15 00 00 call 10cd50 <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10b80c: 89 1c 24 mov %ebx,(%esp) 10b80f: e8 98 25 00 00 call 10ddac <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10b814: 5e pop %esi 10b815: ff 75 b4 pushl -0x4c(%ebp) 10b818: e8 ff 0c 00 00 call 10c51c <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10b81d: 8b 73 14 mov 0x14(%ebx),%esi 10b820: 83 c4 10 add $0x10,%esp 10b823: 8b 46 2c mov 0x2c(%esi),%eax 10b826: 83 f8 02 cmp $0x2,%eax
10b829: 74 21 je 10b84c <rtems_aio_handle+0xa8>
10b82b: 83 f8 03 cmp $0x3,%eax
10b82e: 74 6c je 10b89c <rtems_aio_handle+0xf8> <== NEVER TAKEN
10b830: 48 dec %eax
10b831: 74 4d je 10b880 <rtems_aio_handle+0xdc> <== ALWAYS TAKEN
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
10b833: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10b83a: e8 bd 9e 00 00 call 1156fc <__errno> <== NOT EXECUTED 10b83f: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10b841: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10b844: e9 6f ff ff ff jmp 10b7b8 <rtems_aio_handle+0x14> <== NOT EXECUTED 10b849: 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,
10b84c: 83 ec 0c sub $0xc,%esp 10b84f: ff 76 08 pushl 0x8(%esi) 10b852: ff 76 04 pushl 0x4(%esi) 10b855: ff 76 10 pushl 0x10(%esi) 10b858: ff 76 0c pushl 0xc(%esi) 10b85b: ff 36 pushl (%esi) 10b85d: e8 32 a9 00 00 call 116194 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10b862: 83 c4 20 add $0x20,%esp
break;
default:
result = -1;
}
if (result == -1) {
10b865: 83 f8 ff cmp $0xffffffff,%eax
10b868: 0f 84 78 01 00 00 je 10b9e6 <rtems_aio_handle+0x242><== NEVER TAKEN
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
10b86e: 8b 53 14 mov 0x14(%ebx),%edx 10b871: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10b874: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10b87b: e9 38 ff ff ff jmp 10b7b8 <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,
10b880: 83 ec 0c sub $0xc,%esp 10b883: ff 76 08 pushl 0x8(%esi) 10b886: ff 76 04 pushl 0x4(%esi) 10b889: ff 76 10 pushl 0x10(%esi) 10b88c: ff 76 0c pushl 0xc(%esi) 10b88f: ff 36 pushl (%esi) 10b891: e8 4a a8 00 00 call 1160e0 <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10b896: 83 c4 20 add $0x20,%esp 10b899: eb ca jmp 10b865 <rtems_aio_handle+0xc1> 10b89b: 90 nop
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10b89c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b89f: ff 36 pushl (%esi) <== NOT EXECUTED 10b8a1: e8 7a 66 00 00 call 111f20 <fsync> <== NOT EXECUTED
break;
10b8a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b8a9: eb ba jmp 10b865 <rtems_aio_handle+0xc1> <== NOT EXECUTED 10b8ab: 90 nop <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10b8ac: 83 ec 0c sub $0xc,%esp 10b8af: ff 75 b4 pushl -0x4c(%ebp) 10b8b2: e8 65 0c 00 00 call 10c51c <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10b8b7: c7 04 24 a0 94 12 00 movl $0x1294a0,(%esp) 10b8be: e8 d1 0b 00 00 call 10c494 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10b8c3: 83 c4 10 add $0x10,%esp 10b8c6: 3b 5f 08 cmp 0x8(%edi),%ebx
10b8c9: 74 39 je 10b904 <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);
10b8cb: 83 ec 0c sub $0xc,%esp 10b8ce: 68 a0 94 12 00 push $0x1294a0 10b8d3: e8 44 0c 00 00 call 10c51c <pthread_mutex_unlock> 10b8d8: 83 c4 10 add $0x10,%esp 10b8db: e9 d8 fe ff ff jmp 10b7b8 <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;
10b8e0: ff 0d 08 95 12 00 decl 0x129508
pthread_mutex_unlock (&aio_request_queue.mutex);
10b8e6: 83 ec 0c sub $0xc,%esp 10b8e9: 68 a0 94 12 00 push $0x1294a0 10b8ee: e8 29 0c 00 00 call 10c51c <pthread_mutex_unlock>
return NULL;
10b8f3: 83 c4 10 add $0x10,%esp 10b8f6: 66 90 xchg %ax,%ax
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b8f8: 31 c0 xor %eax,%eax 10b8fa: 8d 65 f4 lea -0xc(%ebp),%esp 10b8fd: 5b pop %ebx 10b8fe: 5e pop %esi 10b8ff: 5f pop %edi 10b900: c9 leave 10b901: c3 ret 10b902: 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);
10b904: 83 ec 08 sub $0x8,%esp 10b907: 8d 45 dc lea -0x24(%ebp),%eax 10b90a: 50 push %eax 10b90b: 6a 01 push $0x1 10b90d: e8 66 05 00 00 call 10be78 <clock_gettime>
timeout.tv_sec += 3;
10b912: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10b916: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10b91d: 8d 5f 20 lea 0x20(%edi),%ebx 10b920: 83 c4 0c add $0xc,%esp 10b923: 8d 55 dc lea -0x24(%ebp),%edx 10b926: 52 push %edx 10b927: 68 a0 94 12 00 push $0x1294a0 10b92c: 53 push %ebx 10b92d: e8 b6 07 00 00 call 10c0e8 <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) {
10b932: 83 c4 10 add $0x10,%esp 10b935: 83 f8 74 cmp $0x74,%eax
10b938: 75 91 jne 10b8cb <rtems_aio_handle+0x127><== NEVER TAKEN
10b93a: 83 ec 0c sub $0xc,%esp 10b93d: 57 push %edi 10b93e: e8 69 24 00 00 call 10ddac <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
10b943: 59 pop %ecx 10b944: ff 75 b4 pushl -0x4c(%ebp) 10b947: e8 dc 08 00 00 call 10c228 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10b94c: 89 1c 24 mov %ebx,(%esp) 10b94f: e8 90 05 00 00 call 10bee4 <pthread_cond_destroy>
free (r_chain);
10b954: 89 3c 24 mov %edi,(%esp) 10b957: e8 58 c7 ff ff call 1080b4 <free>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b95c: 8b 3d f4 94 12 00 mov 0x1294f4,%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)) {
10b962: 83 c4 10 add $0x10,%esp 10b965: 81 ff f8 94 12 00 cmp $0x1294f8,%edi
10b96b: 74 2b je 10b998 <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;
10b96d: ff 0d 08 95 12 00 decl 0x129508
++aio_request_queue.active_threads;
10b973: ff 05 04 95 12 00 incl 0x129504 10b979: 83 ec 0c sub $0xc,%esp 10b97c: 57 push %edi 10b97d: e8 2a 24 00 00 call 10ddac <_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);
10b982: 89 3c 24 mov %edi,(%esp) 10b985: e8 de fd ff ff call 10b768 <rtems_aio_move_to_work> 10b98a: 83 c4 10 add $0x10,%esp 10b98d: 8d 47 1c lea 0x1c(%edi),%eax 10b990: 89 45 b4 mov %eax,-0x4c(%ebp) 10b993: e9 33 ff ff ff jmp 10b8cb <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;
10b998: ff 05 08 95 12 00 incl 0x129508
--aio_request_queue.active_threads;
10b99e: ff 0d 04 95 12 00 decl 0x129504
clock_gettime (CLOCK_REALTIME, &timeout);
10b9a4: 52 push %edx 10b9a5: 52 push %edx 10b9a6: 8d 45 dc lea -0x24(%ebp),%eax 10b9a9: 50 push %eax 10b9aa: 6a 01 push $0x1 10b9ac: e8 c7 04 00 00 call 10be78 <clock_gettime>
timeout.tv_sec += 3;
10b9b1: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10b9b5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10b9bc: 83 c4 0c add $0xc,%esp 10b9bf: 8d 55 dc lea -0x24(%ebp),%edx 10b9c2: 52 push %edx 10b9c3: 68 a0 94 12 00 push $0x1294a0 10b9c8: 68 a4 94 12 00 push $0x1294a4 10b9cd: e8 16 07 00 00 call 10c0e8 <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) {
10b9d2: 83 c4 10 add $0x10,%esp 10b9d5: 83 f8 74 cmp $0x74,%eax
10b9d8: 0f 84 02 ff ff ff je 10b8e0 <rtems_aio_handle+0x13c><== ALWAYS TAKEN
10b9de: 8b 3d f4 94 12 00 mov 0x1294f4,%edi <== NOT EXECUTED 10b9e4: eb 87 jmp 10b96d <rtems_aio_handle+0x1c9><== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
10b9e6: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED 10b9e9: e9 45 fe ff ff jmp 10b833 <rtems_aio_handle+0x8f> <== NOT EXECUTED
0010b580 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10b580: 55 push %ebp 10b581: 89 e5 mov %esp,%ebp 10b583: 53 push %ebx 10b584: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10b587: 68 a8 94 12 00 push $0x1294a8 10b58c: e8 a3 10 00 00 call 10c634 <pthread_attr_init> 10b591: 89 c3 mov %eax,%ebx
if (result != 0)
10b593: 83 c4 10 add $0x10,%esp 10b596: 85 c0 test %eax,%eax
10b598: 74 0a je 10b5a4 <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;
}
10b59a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b59c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b59f: c9 leave <== NOT EXECUTED 10b5a0: c3 ret <== NOT EXECUTED 10b5a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
10b5a4: 83 ec 08 sub $0x8,%esp 10b5a7: 6a 00 push $0x0 10b5a9: 68 a8 94 12 00 push $0x1294a8 10b5ae: e8 ad 10 00 00 call 10c660 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10b5b3: 83 c4 10 add $0x10,%esp 10b5b6: 85 c0 test %eax,%eax
10b5b8: 0f 85 96 00 00 00 jne 10b654 <rtems_aio_init+0xd4> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10b5be: 83 ec 08 sub $0x8,%esp 10b5c1: 6a 00 push $0x0 10b5c3: 68 a0 94 12 00 push $0x1294a0 10b5c8: e8 7b 0d 00 00 call 10c348 <pthread_mutex_init>
if (result != 0)
10b5cd: 83 c4 10 add $0x10,%esp 10b5d0: 85 c0 test %eax,%eax
10b5d2: 0f 85 b8 00 00 00 jne 10b690 <rtems_aio_init+0x110> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10b5d8: 83 ec 08 sub $0x8,%esp 10b5db: 6a 00 push $0x0 10b5dd: 68 a4 94 12 00 push $0x1294a4 10b5e2: e8 c9 09 00 00 call 10bfb0 <pthread_cond_init> 10b5e7: 89 c3 mov %eax,%ebx
if (result != 0) {
10b5e9: 83 c4 10 add $0x10,%esp 10b5ec: 85 c0 test %eax,%eax
10b5ee: 75 7c jne 10b66c <rtems_aio_init+0xec> <== NEVER TAKEN
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10b5f0: c7 05 e8 94 12 00 ec movl $0x1294ec,0x1294e8
10b5f7: 94 12 00 head->previous = NULL;
10b5fa: c7 05 ec 94 12 00 00 movl $0x0,0x1294ec
10b601: 00 00 00 tail->previous = head;
10b604: c7 05 f0 94 12 00 e8 movl $0x1294e8,0x1294f0
10b60b: 94 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10b60e: c7 05 f4 94 12 00 f8 movl $0x1294f8,0x1294f4
10b615: 94 12 00 head->previous = NULL;
10b618: c7 05 f8 94 12 00 00 movl $0x0,0x1294f8
10b61f: 00 00 00 tail->previous = head;
10b622: c7 05 fc 94 12 00 f4 movl $0x1294f4,0x1294fc
10b629: 94 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;
10b62c: c7 05 04 95 12 00 00 movl $0x0,0x129504
10b633: 00 00 00 aio_request_queue.idle_threads = 0;
10b636: c7 05 08 95 12 00 00 movl $0x0,0x129508
10b63d: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10b640: c7 05 00 95 12 00 0b movl $0xb00b,0x129500
10b647: b0 00 00
return result;
}
10b64a: 89 d8 mov %ebx,%eax 10b64c: 8b 5d fc mov -0x4(%ebp),%ebx 10b64f: c9 leave 10b650: c3 ret 10b651: 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);
10b654: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b657: 68 a8 94 12 00 push $0x1294a8 <== NOT EXECUTED 10b65c: e8 af 0f 00 00 call 10c610 <pthread_attr_destroy> <== NOT EXECUTED 10b661: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b664: e9 55 ff ff ff jmp 10b5be <rtems_aio_init+0x3e> <== NOT EXECUTED 10b669: 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);
10b66c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b66f: 68 a0 94 12 00 push $0x1294a0 <== NOT EXECUTED 10b674: e8 af 0b 00 00 call 10c228 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10b679: c7 04 24 a8 94 12 00 movl $0x1294a8,(%esp) <== NOT EXECUTED 10b680: e8 8b 0f 00 00 call 10c610 <pthread_attr_destroy> <== NOT EXECUTED 10b685: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b688: e9 63 ff ff ff jmp 10b5f0 <rtems_aio_init+0x70> <== NOT EXECUTED 10b68d: 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);
10b690: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b693: 68 a8 94 12 00 push $0x1294a8 <== NOT EXECUTED 10b698: e8 73 0f 00 00 call 10c610 <pthread_attr_destroy> <== NOT EXECUTED 10b69d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b6a0: e9 33 ff ff ff jmp 10b5d8 <rtems_aio_init+0x58> <== NOT EXECUTED
0010b9f0 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10b9f0: 55 push %ebp 10b9f1: 89 e5 mov %esp,%ebp 10b9f3: 56 push %esi 10b9f4: 53 push %ebx 10b9f5: 8b 55 08 mov 0x8(%ebp),%edx 10b9f8: 8b 75 0c mov 0xc(%ebp),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b9fb: 8b 02 mov (%edx),%eax 10b9fd: 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)) {
10ba00: 39 c8 cmp %ecx,%eax
10ba02: 74 27 je 10ba2b <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 &&
10ba04: 8b 56 14 mov 0x14(%esi),%edx 10ba07: 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;
10ba0a: 8b 50 14 mov 0x14(%eax),%edx
while (req->aiocbp->aio_reqprio > prio &&
10ba0d: 39 5a 14 cmp %ebx,0x14(%edx)
10ba10: 7c 06 jl 10ba18 <rtems_aio_insert_prio+0x28><== NEVER TAKEN
10ba12: eb 0e jmp 10ba22 <rtems_aio_insert_prio+0x32>
10ba14: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10ba16: 74 1c je 10ba34 <rtems_aio_insert_prio+0x44><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ba18: 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;
10ba1a: 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 &&
10ba1d: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED 10ba20: 7c f2 jl 10ba14 <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 );
10ba22: 89 75 0c mov %esi,0xc(%ebp) 10ba25: 8b 40 04 mov 0x4(%eax),%eax 10ba28: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10ba2b: 5b pop %ebx 10ba2c: 5e pop %esi 10ba2d: c9 leave 10ba2e: e9 b5 23 00 00 jmp 10dde8 <_Chain_Insert> 10ba33: 90 nop
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ba34: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10ba36: eb ea jmp 10ba22 <rtems_aio_insert_prio+0x32><== NOT EXECUTED
0010b768 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10b768: 55 push %ebp 10b769: 89 e5 mov %esp,%ebp 10b76b: 83 ec 08 sub $0x8,%esp 10b76e: 8b 4d 08 mov 0x8(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b771: a1 e8 94 12 00 mov 0x1294e8,%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 &&
10b776: 8b 51 14 mov 0x14(%ecx),%edx 10b779: 39 50 14 cmp %edx,0x14(%eax)
10b77c: 7c 09 jl 10b787 <rtems_aio_move_to_work+0x1f><== ALWAYS TAKEN
10b77e: eb 13 jmp 10b793 <rtems_aio_move_to_work+0x2b><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b780: 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 &&
10b782: 39 50 14 cmp %edx,0x14(%eax)
10b785: 7d 0c jge 10b793 <rtems_aio_move_to_work+0x2b>
10b787: 3d ec 94 12 00 cmp $0x1294ec,%eax
10b78c: 75 f2 jne 10b780 <rtems_aio_move_to_work+0x18><== ALWAYS TAKEN
10b78e: b8 ec 94 12 00 mov $0x1294ec,%eax <== NOT EXECUTED
10b793: 83 ec 08 sub $0x8,%esp 10b796: 51 push %ecx 10b797: ff 70 04 pushl 0x4(%eax) 10b79a: e8 49 26 00 00 call 10dde8 <_Chain_Insert> 10b79f: 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);
}
10b7a2: c9 leave 10b7a3: c3 ret
0010ba38 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10ba38: 55 push %ebp 10ba39: 89 e5 mov %esp,%ebp 10ba3b: 57 push %edi 10ba3c: 56 push %esi 10ba3d: 53 push %ebx 10ba3e: 83 ec 0c sub $0xc,%esp 10ba41: 8b 7d 08 mov 0x8(%ebp),%edi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ba44: 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));
10ba47: 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))
10ba4a: 39 fb cmp %edi,%ebx
10ba4c: 75 04 jne 10ba52 <rtems_aio_remove_fd+0x1a><== ALWAYS TAKEN
10ba4e: eb 2d jmp 10ba7d <rtems_aio_remove_fd+0x45><== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
10ba50: 89 f3 mov %esi,%ebx
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ba52: 83 ec 0c sub $0xc,%esp 10ba55: 53 push %ebx 10ba56: e8 51 23 00 00 call 10ddac <_Chain_Extract>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ba5b: 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;
10ba5d: 8b 43 14 mov 0x14(%ebx),%eax 10ba60: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
req->aiocbp->return_value = -1;
10ba67: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (req);
10ba6e: 89 1c 24 mov %ebx,(%esp) 10ba71: e8 3e c6 ff ff call 1080b4 <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))
10ba76: 83 c4 10 add $0x10,%esp 10ba79: 39 fe cmp %edi,%esi
10ba7b: 75 d3 jne 10ba50 <rtems_aio_remove_fd+0x18>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10ba7d: 8d 65 f4 lea -0xc(%ebp),%esp 10ba80: 5b pop %ebx 10ba81: 5e pop %esi 10ba82: 5f pop %edi 10ba83: c9 leave 10ba84: c3 ret
0010ba88 <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)
{
10ba88: 55 push %ebp 10ba89: 89 e5 mov %esp,%ebp 10ba8b: 53 push %ebx 10ba8c: 83 ec 04 sub $0x4,%esp 10ba8f: 8b 55 08 mov 0x8(%ebp),%edx 10ba92: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ba95: 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 );
10ba97: 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))
10ba9a: 39 d0 cmp %edx,%eax
10ba9c: 74 4e je 10baec <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;
10ba9e: 89 c3 mov %eax,%ebx
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10baa0: 39 48 14 cmp %ecx,0x14(%eax)
10baa3: 75 0a jne 10baaf <rtems_aio_remove_req+0x27><== NEVER TAKEN
10baa5: eb 19 jmp 10bac0 <rtems_aio_remove_req+0x38> 10baa7: 90 nop
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10baa8: 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) {
10baaa: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED 10baad: 74 11 je 10bac0 <rtems_aio_remove_req+0x38><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10baaf: 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) {
10bab1: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bab3: 75 f3 jne 10baa8 <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;
10bab5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10baba: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10babd: c9 leave <== NOT EXECUTED 10babe: c3 ret <== NOT EXECUTED 10babf: 90 nop <== NOT EXECUTED
10bac0: 83 ec 0c sub $0xc,%esp 10bac3: 50 push %eax 10bac4: e8 e3 22 00 00 call 10ddac <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10bac9: 8b 43 14 mov 0x14(%ebx),%eax 10bacc: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10bad3: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10bada: 89 1c 24 mov %ebx,(%esp) 10badd: e8 d2 c5 ff ff call 1080b4 <free>
}
return AIO_CANCELED;
10bae2: 83 c4 10 add $0x10,%esp 10bae5: 31 c0 xor %eax,%eax
}
10bae7: 8b 5d fc mov -0x4(%ebp),%ebx 10baea: c9 leave 10baeb: c3 ret
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10baec: b8 02 00 00 00 mov $0x2,%eax
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10baf1: 8b 5d fc mov -0x4(%ebp),%ebx 10baf4: c9 leave 10baf5: c3 ret
0010b6a8 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
10b6a8: 55 push %ebp 10b6a9: 89 e5 mov %esp,%ebp 10b6ab: 57 push %edi 10b6ac: 56 push %esi 10b6ad: 53 push %ebx 10b6ae: 83 ec 1c sub $0x1c,%esp 10b6b1: 8b 75 08 mov 0x8(%ebp),%esi 10b6b4: 8b 5d 0c mov 0xc(%ebp),%ebx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b6b7: 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)) {
10b6b9: 8b 50 14 mov 0x14(%eax),%edx 10b6bc: 39 d3 cmp %edx,%ebx
10b6be: 7e 28 jle 10b6e8 <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));
10b6c0: 8d 4e 04 lea 0x4(%esi),%ecx 10b6c3: eb 0c jmp 10b6d1 <rtems_aio_search_fd+0x29> 10b6c5: 8d 76 00 lea 0x0(%esi),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b6c8: 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)) {
10b6ca: 8b 50 14 mov 0x14(%eax),%edx 10b6cd: 39 da cmp %ebx,%edx
10b6cf: 7d 17 jge 10b6e8 <rtems_aio_search_fd+0x40>
10b6d1: 39 c8 cmp %ecx,%eax
10b6d3: 75 f3 jne 10b6c8 <rtems_aio_search_fd+0x20>
10b6d5: 89 c7 mov %eax,%edi
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
10b6d7: 8b 45 10 mov 0x10(%ebp),%eax 10b6da: 85 c0 test %eax,%eax
10b6dc: 75 1f jne 10b6fd <rtems_aio_search_fd+0x55>
r_chain = NULL;
10b6de: 31 c0 xor %eax,%eax
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10b6e0: 8d 65 f4 lea -0xc(%ebp),%esp 10b6e3: 5b pop %ebx 10b6e4: 5e pop %esi 10b6e5: 5f pop %edi 10b6e6: c9 leave 10b6e7: c3 ret
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10b6e8: 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)
10b6ea: 39 d3 cmp %edx,%ebx
10b6ec: 75 e9 jne 10b6d7 <rtems_aio_search_fd+0x2f>
r_chain->new_fd = 0;
10b6ee: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10b6f5: 8d 65 f4 lea -0xc(%ebp),%esp 10b6f8: 5b pop %ebx 10b6f9: 5e pop %esi 10b6fa: 5f pop %edi 10b6fb: c9 leave 10b6fc: c3 ret
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
10b6fd: 83 ec 0c sub $0xc,%esp 10b700: 6a 24 push $0x24 10b702: e8 c1 ce ff ff call 1085c8 <malloc> 10b707: 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 );
10b709: 8d 4a 0c lea 0xc(%edx),%ecx 10b70c: 89 4a 08 mov %ecx,0x8(%edx)
head->next = tail;
head->previous = NULL;
10b70f: 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 );
10b716: 8d 4a 08 lea 0x8(%edx),%ecx 10b719: 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 );
10b71c: 8d 4e 04 lea 0x4(%esi),%ecx
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
10b71f: 83 c4 10 add $0x10,%esp 10b722: 39 0e cmp %ecx,(%esi)
10b724: 74 27 je 10b74d <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 );
10b726: 83 ec 08 sub $0x8,%esp 10b729: 52 push %edx 10b72a: ff 77 04 pushl 0x4(%edi) 10b72d: 89 45 e4 mov %eax,-0x1c(%ebp) 10b730: 89 55 e0 mov %edx,-0x20(%ebp) 10b733: e8 b0 26 00 00 call 10dde8 <_Chain_Insert> 10b738: 83 c4 10 add $0x10,%esp 10b73b: 8b 55 e0 mov -0x20(%ebp),%edx 10b73e: 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;
10b741: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx)
r_chain->fildes = fildes;
10b748: 89 5a 14 mov %ebx,0x14(%edx) 10b74b: eb a8 jmp 10b6f5 <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);
10b74d: 83 ec 08 sub $0x8,%esp 10b750: 52 push %edx 10b751: 56 push %esi 10b752: 89 45 e4 mov %eax,-0x1c(%ebp) 10b755: 89 55 e0 mov %edx,-0x20(%ebp) 10b758: e8 8b 26 00 00 call 10dde8 <_Chain_Insert> 10b75d: 83 c4 10 add $0x10,%esp 10b760: 8b 45 e4 mov -0x1c(%ebp),%eax 10b763: 8b 55 e0 mov -0x20(%ebp),%edx 10b766: eb d9 jmp 10b741 <rtems_aio_search_fd+0x99>
00112c04 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
112c04: 55 push %ebp 112c05: 89 e5 mov %esp,%ebp 112c07: 57 push %edi 112c08: 56 push %esi 112c09: 53 push %ebx 112c0a: 83 ec 2c sub $0x2c,%esp 112c0d: 8b 5d 08 mov 0x8(%ebp),%ebx 112c10: 8b 7d 0c mov 0xc(%ebp),%edi 112c13: 8b 45 10 mov 0x10(%ebp),%eax 112c16: 8b 75 14 mov 0x14(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
112c19: 85 db test %ebx,%ebx
112c1b: 0f 84 87 00 00 00 je 112ca8 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
112c21: 85 f6 test %esi,%esi
112c23: 0f 84 bf 00 00 00 je 112ce8 <rtems_barrier_create+0xe4>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
112c29: f7 c7 10 00 00 00 test $0x10,%edi
112c2f: 0f 84 83 00 00 00 je 112cb8 <rtems_barrier_create+0xb4>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
112c35: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( maximum_waiters == 0 )
112c3c: 85 c0 test %eax,%eax
112c3e: 0f 84 80 00 00 00 je 112cc4 <rtems_barrier_create+0xc0>
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
112c44: 89 45 e4 mov %eax,-0x1c(%ebp) 112c47: a1 4c a1 12 00 mov 0x12a14c,%eax 112c4c: 40 inc %eax 112c4d: a3 4c a1 12 00 mov %eax,0x12a14c
* 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 );
112c52: 83 ec 0c sub $0xc,%esp 112c55: 68 40 ab 12 00 push $0x12ab40 112c5a: e8 b1 ae ff ff call 10db10 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
112c5f: 83 c4 10 add $0x10,%esp 112c62: 85 c0 test %eax,%eax
112c64: 74 6e je 112cd4 <rtems_barrier_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
112c66: 89 78 10 mov %edi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
112c69: 83 ec 08 sub $0x8,%esp 112c6c: 8d 55 e0 lea -0x20(%ebp),%edx 112c6f: 52 push %edx 112c70: 8d 50 14 lea 0x14(%eax),%edx 112c73: 52 push %edx 112c74: 89 45 d4 mov %eax,-0x2c(%ebp) 112c77: e8 44 0a 00 00 call 1136c0 <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
112c7c: 8b 45 d4 mov -0x2c(%ebp),%eax 112c7f: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
112c82: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
112c85: 8b 0d 5c ab 12 00 mov 0x12ab5c,%ecx 112c8b: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
112c8e: 89 58 0c mov %ebx,0xc(%eax)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
112c91: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
112c93: e8 6c be ff ff call 10eb04 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
112c98: 83 c4 10 add $0x10,%esp 112c9b: 31 c0 xor %eax,%eax
}
112c9d: 8d 65 f4 lea -0xc(%ebp),%esp 112ca0: 5b pop %ebx 112ca1: 5e pop %esi 112ca2: 5f pop %edi 112ca3: c9 leave 112ca4: c3 ret 112ca5: 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;
112ca8: b8 03 00 00 00 mov $0x3,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112cad: 8d 65 f4 lea -0xc(%ebp),%esp 112cb0: 5b pop %ebx 112cb1: 5e pop %esi 112cb2: 5f pop %edi 112cb3: c9 leave 112cb4: c3 ret 112cb5: 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;
112cb8: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 112cbf: eb 83 jmp 112c44 <rtems_barrier_create+0x40> 112cc1: 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;
112cc4: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112cc9: 8d 65 f4 lea -0xc(%ebp),%esp 112ccc: 5b pop %ebx 112ccd: 5e pop %esi 112cce: 5f pop %edi 112ccf: c9 leave 112cd0: c3 ret 112cd1: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
112cd4: e8 2b be ff ff call 10eb04 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
112cd9: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112cde: 8d 65 f4 lea -0xc(%ebp),%esp 112ce1: 5b pop %ebx 112ce2: 5e pop %esi 112ce3: 5f pop %edi 112ce4: c9 leave 112ce5: c3 ret 112ce6: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
112ce8: b8 09 00 00 00 mov $0x9,%eax 112ced: eb ae jmp 112c9d <rtems_barrier_create+0x99>
0010b708 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10b708: 55 push %ebp 10b709: 89 e5 mov %esp,%ebp 10b70b: 56 push %esi 10b70c: 53 push %ebx 10b70d: 8b 5d 10 mov 0x10(%ebp),%ebx 10b710: 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 );
10b713: 83 ec 08 sub $0x8,%esp 10b716: ff 75 0c pushl 0xc(%ebp) 10b719: ff 75 08 pushl 0x8(%ebp) 10b71c: e8 eb 04 00 00 call 10bc0c <_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 ) {
10b721: 83 c4 10 add $0x10,%esp 10b724: 84 c0 test %al,%al
10b726: 75 0c jne 10b734 <rtems_chain_append_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10b728: 31 c0 xor %eax,%eax 10b72a: 8d 65 f8 lea -0x8(%ebp),%esp 10b72d: 5b pop %ebx 10b72e: 5e pop %esi 10b72f: c9 leave 10b730: c3 ret 10b731: 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 );
10b734: 89 75 0c mov %esi,0xc(%ebp) 10b737: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10b73a: 8d 65 f8 lea -0x8(%ebp),%esp 10b73d: 5b pop %ebx 10b73e: 5e pop %esi 10b73f: 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 );
10b740: e9 5f f6 ff ff jmp 10ada4 <rtems_event_send>
0010b748 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
10b748: 55 push %ebp 10b749: 89 e5 mov %esp,%ebp 10b74b: 56 push %esi 10b74c: 53 push %ebx 10b74d: 8b 5d 0c mov 0xc(%ebp),%ebx 10b750: 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 );
10b753: 83 ec 08 sub $0x8,%esp 10b756: ff 75 14 pushl 0x14(%ebp) 10b759: ff 75 08 pushl 0x8(%ebp) 10b75c: e8 13 05 00 00 call 10bc74 <_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 ) {
10b761: 83 c4 10 add $0x10,%esp 10b764: 84 c0 test %al,%al
10b766: 75 0c jne 10b774 <rtems_chain_get_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10b768: 31 c0 xor %eax,%eax 10b76a: 8d 65 f8 lea -0x8(%ebp),%esp 10b76d: 5b pop %ebx 10b76e: 5e pop %esi 10b76f: c9 leave 10b770: c3 ret 10b771: 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 );
10b774: 89 75 0c mov %esi,0xc(%ebp) 10b777: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10b77a: 8d 65 f8 lea -0x8(%ebp),%esp 10b77d: 5b pop %ebx 10b77e: 5e pop %esi 10b77f: 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 );
10b780: e9 1f f6 ff ff jmp 10ada4 <rtems_event_send>
0010b788 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10b788: 55 push %ebp 10b789: 89 e5 mov %esp,%ebp 10b78b: 57 push %edi 10b78c: 56 push %esi 10b78d: 53 push %ebx 10b78e: 83 ec 1c sub $0x1c,%esp 10b791: 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(
10b794: 8d 7d e4 lea -0x1c(%ebp),%edi 10b797: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10b798: 83 ec 0c sub $0xc,%esp 10b79b: 56 push %esi 10b79c: e8 0f 05 00 00 call 10bcb0 <_Chain_Get> 10b7a1: 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
10b7a3: 83 c4 10 add $0x10,%esp 10b7a6: 85 c0 test %eax,%eax
10b7a8: 75 22 jne 10b7cc <rtems_chain_get_with_wait+0x44>
) {
rtems_event_set out;
sc = rtems_event_receive(
10b7aa: 57 push %edi 10b7ab: ff 75 10 pushl 0x10(%ebp) 10b7ae: 6a 00 push $0x0 10b7b0: ff 75 0c pushl 0xc(%ebp) 10b7b3: e8 64 f4 ff ff call 10ac1c <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10b7b8: 83 c4 10 add $0x10,%esp 10b7bb: 85 c0 test %eax,%eax
10b7bd: 74 d9 je 10b798 <rtems_chain_get_with_wait+0x10><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10b7bf: 8b 55 14 mov 0x14(%ebp),%edx 10b7c2: 89 1a mov %ebx,(%edx)
return sc;
}
10b7c4: 8d 65 f4 lea -0xc(%ebp),%esp 10b7c7: 5b pop %ebx 10b7c8: 5e pop %esi 10b7c9: 5f pop %edi 10b7ca: c9 leave 10b7cb: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10b7cc: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10b7ce: 8b 55 14 mov 0x14(%ebp),%edx 10b7d1: 89 1a mov %ebx,(%edx)
return sc;
}
10b7d3: 8d 65 f4 lea -0xc(%ebp),%esp 10b7d6: 5b pop %ebx 10b7d7: 5e pop %esi 10b7d8: 5f pop %edi 10b7d9: c9 leave 10b7da: c3 ret
0010b7dc <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10b7dc: 55 push %ebp 10b7dd: 89 e5 mov %esp,%ebp 10b7df: 56 push %esi 10b7e0: 53 push %ebx 10b7e1: 8b 5d 10 mov 0x10(%ebp),%ebx 10b7e4: 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 );
10b7e7: 83 ec 08 sub $0x8,%esp 10b7ea: ff 75 0c pushl 0xc(%ebp) 10b7ed: ff 75 08 pushl 0x8(%ebp) 10b7f0: e8 ff 04 00 00 call 10bcf4 <_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) {
10b7f5: 83 c4 10 add $0x10,%esp 10b7f8: 84 c0 test %al,%al
10b7fa: 75 0c jne 10b808 <rtems_chain_prepend_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10b7fc: 31 c0 xor %eax,%eax 10b7fe: 8d 65 f8 lea -0x8(%ebp),%esp 10b801: 5b pop %ebx 10b802: 5e pop %esi 10b803: c9 leave 10b804: c3 ret 10b805: 8d 76 00 lea 0x0(%esi),%esi
{
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 );
10b808: 89 75 0c mov %esi,0xc(%ebp) 10b80b: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10b80e: 8d 65 f8 lea -0x8(%ebp),%esp 10b811: 5b pop %ebx 10b812: 5e pop %esi 10b813: 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 );
10b814: e9 8b f5 ff ff jmp 10ada4 <rtems_event_send>
00115088 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
115088: 55 push %ebp 115089: 89 e5 mov %esp,%ebp 11508b: 53 push %ebx 11508c: 83 ec 04 sub $0x4,%esp 11508f: 8b 45 08 mov 0x8(%ebp),%eax 115092: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
115095: 85 db test %ebx,%ebx
115097: 74 3b je 1150d4 <rtems_clock_get+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
115099: 85 c0 test %eax,%eax
11509b: 74 2b je 1150c8 <rtems_clock_get+0x40>
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
11509d: 83 f8 01 cmp $0x1,%eax
1150a0: 74 3e je 1150e0 <rtems_clock_get+0x58>
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
1150a2: 83 f8 02 cmp $0x2,%eax
1150a5: 74 45 je 1150ec <rtems_clock_get+0x64>
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
1150a7: 83 f8 03 cmp $0x3,%eax
1150aa: 74 4c je 1150f8 <rtems_clock_get+0x70>
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
1150ac: 83 f8 04 cmp $0x4,%eax
1150af: 74 0b je 1150bc <rtems_clock_get+0x34>
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
1150b1: b8 0a 00 00 00 mov $0xa,%eax
}
1150b6: 5a pop %edx 1150b7: 5b pop %ebx 1150b8: c9 leave 1150b9: c3 ret 1150ba: 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 );
1150bc: 89 5d 08 mov %ebx,0x8(%ebp)
return RTEMS_INVALID_NUMBER;
}
1150bf: 59 pop %ecx 1150c0: 5b pop %ebx 1150c1: 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 );
1150c2: e9 41 01 00 00 jmp 115208 <rtems_clock_get_tod_timeval> 1150c7: 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 );
1150c8: 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;
}
1150cb: 58 pop %eax 1150cc: 5b pop %ebx 1150cd: 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 );
1150ce: e9 81 00 00 00 jmp 115154 <rtems_clock_get_tod> 1150d3: 90 nop
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
1150d4: 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;
}
1150d9: 5a pop %edx 1150da: 5b pop %ebx 1150db: c9 leave 1150dc: c3 ret 1150dd: 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);
1150e0: 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;
}
1150e3: 5b pop %ebx 1150e4: 5b pop %ebx 1150e5: 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);
1150e6: e9 19 00 00 00 jmp 115104 <rtems_clock_get_seconds_since_epoch> 1150eb: 90 nop
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
1150ec: e8 57 00 00 00 call 115148 <rtems_clock_get_ticks_since_boot> 1150f1: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1150f3: 31 c0 xor %eax,%eax 1150f5: eb bf jmp 1150b6 <rtems_clock_get+0x2e> 1150f7: 90 nop
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
1150f8: e8 37 00 00 00 call 115134 <rtems_clock_get_ticks_per_second> 1150fd: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1150ff: 31 c0 xor %eax,%eax 115101: eb b3 jmp 1150b6 <rtems_clock_get+0x2e>
00115208 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
115208: 55 push %ebp 115209: 89 e5 mov %esp,%ebp 11520b: 56 push %esi 11520c: 53 push %ebx 11520d: 83 ec 10 sub $0x10,%esp 115210: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !time )
115213: 85 db test %ebx,%ebx
115215: 74 51 je 115268 <rtems_clock_get_tod_timeval+0x60>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
115217: 80 3d bc 20 14 00 00 cmpb $0x0,0x1420bc
11521e: 75 0c jne 11522c <rtems_clock_get_tod_timeval+0x24>
return RTEMS_NOT_DEFINED;
115220: b8 0b 00 00 00 mov $0xb,%eax
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
115225: 8d 65 f8 lea -0x8(%ebp),%esp 115228: 5b pop %ebx 115229: 5e pop %esi 11522a: c9 leave 11522b: c3 ret
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
11522c: 9c pushf 11522d: fa cli 11522e: 5e pop %esi
_TOD_Get( &now );
11522f: 83 ec 0c sub $0xc,%esp 115232: 8d 45 f0 lea -0x10(%ebp),%eax 115235: 50 push %eax 115236: e8 01 44 00 00 call 11963c <_TOD_Get>
_ISR_Enable(level);
11523b: 56 push %esi 11523c: 9d popf
useconds = (suseconds_t)now.tv_nsec;
11523d: 8b 4d f4 mov -0xc(%ebp),%ecx
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
115240: 8b 45 f0 mov -0x10(%ebp),%eax 115243: 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;
115245: b8 d3 4d 62 10 mov $0x10624dd3,%eax 11524a: f7 e9 imul %ecx 11524c: 89 d0 mov %edx,%eax 11524e: c1 f8 06 sar $0x6,%eax 115251: c1 f9 1f sar $0x1f,%ecx 115254: 29 c8 sub %ecx,%eax 115256: 89 43 04 mov %eax,0x4(%ebx)
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
115259: 83 c4 10 add $0x10,%esp 11525c: 31 c0 xor %eax,%eax
}
11525e: 8d 65 f8 lea -0x8(%ebp),%esp 115261: 5b pop %ebx 115262: 5e pop %esi 115263: c9 leave 115264: c3 ret 115265: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
115268: b8 09 00 00 00 mov $0x9,%eax 11526d: eb b6 jmp 115225 <rtems_clock_get_tod_timeval+0x1d>
0010a77c <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
10a77c: 55 push %ebp 10a77d: 89 e5 mov %esp,%ebp 10a77f: 83 ec 08 sub $0x8,%esp 10a782: 8b 45 08 mov 0x8(%ebp),%eax
if ( !uptime )
10a785: 85 c0 test %eax,%eax
10a787: 74 13 je 10a79c <rtems_clock_get_uptime+0x20>
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
10a789: 83 ec 0c sub $0xc,%esp 10a78c: 50 push %eax 10a78d: e8 8e 14 00 00 call 10bc20 <_TOD_Get_uptime_as_timespec>
return RTEMS_SUCCESSFUL;
10a792: 83 c4 10 add $0x10,%esp 10a795: 31 c0 xor %eax,%eax
}
10a797: c9 leave 10a798: c3 ret 10a799: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
10a79c: b8 09 00 00 00 mov $0x9,%eax
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
10a7a1: c9 leave 10a7a2: c3 ret
0010b6f0 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
10b6f0: 55 push %ebp 10b6f1: 89 e5 mov %esp,%ebp 10b6f3: 53 push %ebx 10b6f4: 83 ec 14 sub $0x14,%esp 10b6f7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10b6fa: 85 db test %ebx,%ebx
10b6fc: 74 66 je 10b764 <rtems_clock_set+0x74>
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
10b6fe: 83 ec 0c sub $0xc,%esp 10b701: 53 push %ebx 10b702: e8 39 01 00 00 call 10b840 <_TOD_Validate> 10b707: 83 c4 10 add $0x10,%esp 10b70a: 84 c0 test %al,%al
10b70c: 75 0a jne 10b718 <rtems_clock_set+0x28>
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
10b70e: b8 14 00 00 00 mov $0x14,%eax
}
10b713: 8b 5d fc mov -0x4(%ebp),%ebx 10b716: c9 leave 10b717: c3 ret
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
10b718: 83 ec 0c sub $0xc,%esp 10b71b: 53 push %ebx 10b71c: e8 93 00 00 00 call 10b7b4 <_TOD_To_seconds> 10b721: 89 45 f0 mov %eax,-0x10(%ebp)
newtime.tv_nsec = time_buffer->ticks *
10b724: 8b 43 18 mov 0x18(%ebx),%eax 10b727: 0f af 05 6c 6c 12 00 imul 0x126c6c,%eax 10b72e: 8d 04 80 lea (%eax,%eax,4),%eax 10b731: 8d 04 80 lea (%eax,%eax,4),%eax 10b734: 8d 04 80 lea (%eax,%eax,4),%eax 10b737: c1 e0 03 shl $0x3,%eax 10b73a: 89 45 f4 mov %eax,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b73d: a1 6c b3 12 00 mov 0x12b36c,%eax 10b742: 40 inc %eax 10b743: a3 6c b3 12 00 mov %eax,0x12b36c
rtems_configuration_get_nanoseconds_per_tick();
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
10b748: 8d 45 f0 lea -0x10(%ebp),%eax 10b74b: 89 04 24 mov %eax,(%esp) 10b74e: e8 6d 17 00 00 call 10cec0 <_TOD_Set>
_Thread_Enable_dispatch();
10b753: e8 54 2d 00 00 call 10e4ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b758: 83 c4 10 add $0x10,%esp 10b75b: 31 c0 xor %eax,%eax
} return RTEMS_INVALID_CLOCK; }
10b75d: 8b 5d fc mov -0x4(%ebp),%ebx 10b760: c9 leave 10b761: c3 ret 10b762: 66 90 xchg %ax,%ax
)
{
struct timespec newtime;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10b764: b8 09 00 00 00 mov $0x9,%eax
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10b769: 8b 5d fc mov -0x4(%ebp),%ebx 10b76c: c9 leave 10b76d: c3 ret
0010a578 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
10a578: 55 push %ebp 10a579: 89 e5 mov %esp,%ebp 10a57b: 83 ec 08 sub $0x8,%esp
_TOD_Tickle_ticks();
10a57e: e8 51 13 00 00 call 10b8d4 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
10a583: 83 ec 0c sub $0xc,%esp 10a586: 68 c0 78 12 00 push $0x1278c0 10a58b: e8 10 37 00 00 call 10dca0 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
10a590: e8 d7 31 00 00 call 10d76c <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
10a595: a0 a4 7d 12 00 mov 0x127da4,%al
if ( _Thread_Is_context_switch_necessary() &&
10a59a: 83 c4 10 add $0x10,%esp 10a59d: 84 c0 test %al,%al
10a59f: 74 09 je 10a5aa <rtems_clock_tick+0x32>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
10a5a1: a1 ec 77 12 00 mov 0x1277ec,%eax 10a5a6: 85 c0 test %eax,%eax
10a5a8: 74 06 je 10a5b0 <rtems_clock_tick+0x38>
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
10a5aa: 31 c0 xor %eax,%eax 10a5ac: c9 leave 10a5ad: c3 ret 10a5ae: 66 90 xchg %ax,%ax
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
10a5b0: e8 53 26 00 00 call 10cc08 <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
}
10a5b5: 31 c0 xor %eax,%eax 10a5b7: c9 leave 10a5b8: c3 ret
0010a744 <rtems_event_send>:
rtems_status_code rtems_event_send(
rtems_id id,
rtems_event_set event_in
)
{
10a744: 55 push %ebp 10a745: 89 e5 mov %esp,%ebp 10a747: 53 push %ebx 10a748: 83 ec 1c sub $0x1c,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
the_thread = _Thread_Get( id, &location );
10a74b: 8d 45 f4 lea -0xc(%ebp),%eax 10a74e: 50 push %eax 10a74f: ff 75 08 pushl 0x8(%ebp) 10a752: e8 4d 26 00 00 call 10cda4 <_Thread_Get>
switch ( location ) {
10a757: 83 c4 10 add $0x10,%esp 10a75a: 8b 55 f4 mov -0xc(%ebp),%edx 10a75d: 85 d2 test %edx,%edx
10a75f: 75 2b jne 10a78c <rtems_event_send+0x48>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10a761: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
rtems_event_set *the_event_set
)
{
ISR_Level level;
_ISR_Disable( level );
10a767: 9c pushf 10a768: fa cli 10a769: 59 pop %ecx
*the_event_set |= the_new_events;
10a76a: 8b 5d 0c mov 0xc(%ebp),%ebx 10a76d: 09 1a or %ebx,(%edx)
_ISR_Enable( level );
10a76f: 51 push %ecx 10a770: 9d popf
_Event_sets_Post( event_in, &api->pending_events );
_Event_Surrender( the_thread );
10a771: 83 ec 0c sub $0xc,%esp 10a774: 50 push %eax 10a775: e8 1e 00 00 00 call 10a798 <_Event_Surrender>
_Thread_Enable_dispatch();
10a77a: e8 01 26 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10a77f: 83 c4 10 add $0x10,%esp 10a782: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a784: 8b 5d fc mov -0x4(%ebp),%ebx 10a787: c9 leave 10a788: c3 ret 10a789: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10a78c: b8 04 00 00 00 mov $0x4,%eax
}
10a791: 8b 5d fc mov -0x4(%ebp),%ebx 10a794: c9 leave 10a795: c3 ret
0010c6b8 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
10c6b8: 55 push %ebp 10c6b9: 89 e5 mov %esp,%ebp 10c6bb: 57 push %edi 10c6bc: 56 push %esi 10c6bd: 53 push %ebx 10c6be: 83 ec 1c sub $0x1c,%esp 10c6c1: 8b 75 0c mov 0xc(%ebp),%esi 10c6c4: 8b 5d 10 mov 0x10(%ebp),%ebx
Extension_Control *the_extension;
if ( !id )
10c6c7: 85 db test %ebx,%ebx
10c6c9: 0f 84 85 00 00 00 je 10c754 <rtems_extension_create+0x9c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10c6cf: 8b 45 08 mov 0x8(%ebp),%eax 10c6d2: 85 c0 test %eax,%eax
10c6d4: 75 0e jne 10c6e4 <rtems_extension_create+0x2c>
return RTEMS_INVALID_NAME;
10c6d6: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c6db: 8d 65 f4 lea -0xc(%ebp),%esp 10c6de: 5b pop %ebx 10c6df: 5e pop %esi 10c6e0: 5f pop %edi 10c6e1: c9 leave 10c6e2: c3 ret 10c6e3: 90 nop
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c6e4: a1 6c b3 12 00 mov 0x12b36c,%eax 10c6e9: 40 inc %eax 10c6ea: a3 6c b3 12 00 mov %eax,0x12b36c
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
10c6ef: 83 ec 0c sub $0xc,%esp 10c6f2: 68 c0 b5 12 00 push $0x12b5c0 10c6f7: e8 04 0d 00 00 call 10d400 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
10c6fc: 83 c4 10 add $0x10,%esp 10c6ff: 85 c0 test %eax,%eax
10c701: 74 45 je 10c748 <rtems_extension_create+0x90>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10c703: 8d 78 24 lea 0x24(%eax),%edi 10c706: b9 08 00 00 00 mov $0x8,%ecx 10c70b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10c70d: 83 ec 0c sub $0xc,%esp
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
_User_extensions_Add_set_with_table( &the_extension->Extension, extension_table );
10c710: 8d 50 10 lea 0x10(%eax),%edx 10c713: 52 push %edx 10c714: 89 45 e4 mov %eax,-0x1c(%ebp) 10c717: e8 28 29 00 00 call 10f044 <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c71c: 8b 45 e4 mov -0x1c(%ebp),%eax 10c71f: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c722: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c725: 8b 0d dc b5 12 00 mov 0x12b5dc,%ecx 10c72b: 89 04 b1 mov %eax,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c72e: 8b 4d 08 mov 0x8(%ebp),%ecx 10c731: 89 48 0c mov %ecx,0xc(%eax)
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
10c734: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10c736: e8 71 1d 00 00 call 10e4ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c73b: 83 c4 10 add $0x10,%esp 10c73e: 31 c0 xor %eax,%eax
}
10c740: 8d 65 f4 lea -0xc(%ebp),%esp 10c743: 5b pop %ebx 10c744: 5e pop %esi 10c745: 5f pop %edi 10c746: c9 leave 10c747: c3 ret
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
_Thread_Enable_dispatch();
10c748: e8 5f 1d 00 00 call 10e4ac <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c74d: b8 05 00 00 00 mov $0x5,%eax 10c752: eb 87 jmp 10c6db <rtems_extension_create+0x23>
)
{
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c754: b8 09 00 00 00 mov $0x9,%eax 10c759: eb 80 jmp 10c6db <rtems_extension_create+0x23>
0010c4f8 <rtems_extension_delete>:
#include <rtems/extension.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
10c4f8: 55 push %ebp 10c4f9: 89 e5 mov %esp,%ebp 10c4fb: 53 push %ebx 10c4fc: 83 ec 18 sub $0x18,%esp
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
10c4ff: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Extension_Control *)
_Objects_Get( &_Extension_Information, id, location );
10c502: 50 push %eax 10c503: ff 75 08 pushl 0x8(%ebp) 10c506: 68 a0 af 12 00 push $0x12afa0 10c50b: e8 f0 10 00 00 call 10d600 <_Objects_Get> 10c510: 89 c3 mov %eax,%ebx
switch ( location ) {
10c512: 83 c4 10 add $0x10,%esp 10c515: 8b 55 f4 mov -0xc(%ebp),%edx 10c518: 85 d2 test %edx,%edx
10c51a: 75 38 jne 10c554 <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10c51c: 83 ec 0c sub $0xc,%esp 10c51f: 8d 40 10 lea 0x10(%eax),%eax 10c522: 50 push %eax 10c523: e8 bc 27 00 00 call 10ece4 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10c528: 59 pop %ecx 10c529: 58 pop %eax 10c52a: 53 push %ebx 10c52b: 68 a0 af 12 00 push $0x12afa0 10c530: e8 93 0c 00 00 call 10d1c8 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _Extension_Free (
Extension_Control *the_extension
)
{
_Objects_Free( &_Extension_Information, &the_extension->Object );
10c535: 58 pop %eax 10c536: 5a pop %edx 10c537: 53 push %ebx 10c538: 68 a0 af 12 00 push $0x12afa0 10c53d: e8 7e 0f 00 00 call 10d4c0 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10c542: e8 c9 1b 00 00 call 10e110 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c547: 83 c4 10 add $0x10,%esp 10c54a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c54c: 8b 5d fc mov -0x4(%ebp),%ebx 10c54f: c9 leave 10c550: c3 ret 10c551: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c554: b8 04 00 00 00 mov $0x4,%eax
}
10c559: 8b 5d fc mov -0x4(%ebp),%ebx 10c55c: c9 leave 10c55d: c3 ret
00112a60 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112a60: 55 push %ebp 112a61: 89 e5 mov %esp,%ebp 112a63: 53 push %ebx 112a64: 83 ec 04 sub $0x4,%esp 112a67: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112a6a: 39 05 20 82 12 00 cmp %eax,0x128220
112a70: 76 1a jbe 112a8c <rtems_io_close+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
112a72: 8d 14 40 lea (%eax,%eax,2),%edx 112a75: c1 e2 03 shl $0x3,%edx 112a78: 03 15 24 82 12 00 add 0x128224,%edx 112a7e: 8b 52 08 mov 0x8(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112a81: 85 d2 test %edx,%edx
112a83: 74 13 je 112a98 <rtems_io_close+0x38> }
112a85: 59 pop %ecx 112a86: 5b pop %ebx 112a87: 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;
112a88: ff e2 jmp *%edx 112a8a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112a8c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112a91: 5a pop %edx 112a92: 5b pop %ebx 112a93: c9 leave 112a94: c3 ret 112a95: 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;
112a98: 31 c0 xor %eax,%eax
}
112a9a: 5a pop %edx 112a9b: 5b pop %ebx 112a9c: c9 leave 112a9d: c3 ret
00112aa0 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112aa0: 55 push %ebp 112aa1: 89 e5 mov %esp,%ebp 112aa3: 53 push %ebx 112aa4: 83 ec 04 sub $0x4,%esp 112aa7: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112aaa: 39 05 20 82 12 00 cmp %eax,0x128220
112ab0: 76 1a jbe 112acc <rtems_io_control+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
112ab2: 8d 14 40 lea (%eax,%eax,2),%edx 112ab5: c1 e2 03 shl $0x3,%edx 112ab8: 03 15 24 82 12 00 add 0x128224,%edx 112abe: 8b 52 14 mov 0x14(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112ac1: 85 d2 test %edx,%edx
112ac3: 74 13 je 112ad8 <rtems_io_control+0x38> }
112ac5: 59 pop %ecx 112ac6: 5b pop %ebx 112ac7: 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;
112ac8: ff e2 jmp *%edx 112aca: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112acc: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112ad1: 5a pop %edx 112ad2: 5b pop %ebx 112ad3: c9 leave 112ad4: c3 ret 112ad5: 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;
112ad8: 31 c0 xor %eax,%eax
}
112ada: 5a pop %edx 112adb: 5b pop %ebx 112adc: c9 leave 112add: c3 ret
001108a8 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
1108a8: 55 push %ebp 1108a9: 89 e5 mov %esp,%ebp 1108ab: 53 push %ebx 1108ac: 83 ec 04 sub $0x4,%esp 1108af: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
1108b2: 39 05 20 82 12 00 cmp %eax,0x128220
1108b8: 76 1a jbe 1108d4 <rtems_io_initialize+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
1108ba: 8d 14 40 lea (%eax,%eax,2),%edx 1108bd: c1 e2 03 shl $0x3,%edx 1108c0: 03 15 24 82 12 00 add 0x128224,%edx 1108c6: 8b 12 mov (%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1108c8: 85 d2 test %edx,%edx
1108ca: 74 14 je 1108e0 <rtems_io_initialize+0x38> }
1108cc: 59 pop %ecx 1108cd: 5b pop %ebx 1108ce: 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;
1108cf: ff e2 jmp *%edx 1108d1: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
1108d4: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
1108d9: 5a pop %edx 1108da: 5b pop %ebx 1108db: c9 leave 1108dc: c3 ret 1108dd: 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;
1108e0: 31 c0 xor %eax,%eax
}
1108e2: 5a pop %edx 1108e3: 5b pop %ebx 1108e4: c9 leave 1108e5: c3 ret
00112ae0 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112ae0: 55 push %ebp 112ae1: 89 e5 mov %esp,%ebp 112ae3: 53 push %ebx 112ae4: 83 ec 04 sub $0x4,%esp 112ae7: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112aea: 39 05 20 82 12 00 cmp %eax,0x128220
112af0: 76 1a jbe 112b0c <rtems_io_open+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
112af2: 8d 14 40 lea (%eax,%eax,2),%edx 112af5: c1 e2 03 shl $0x3,%edx 112af8: 03 15 24 82 12 00 add 0x128224,%edx 112afe: 8b 52 04 mov 0x4(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112b01: 85 d2 test %edx,%edx
112b03: 74 13 je 112b18 <rtems_io_open+0x38> }
112b05: 59 pop %ecx 112b06: 5b pop %ebx 112b07: 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;
112b08: ff e2 jmp *%edx 112b0a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112b0c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112b11: 5a pop %edx 112b12: 5b pop %ebx 112b13: c9 leave 112b14: c3 ret 112b15: 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;
112b18: 31 c0 xor %eax,%eax
}
112b1a: 5a pop %edx 112b1b: 5b pop %ebx 112b1c: c9 leave 112b1d: c3 ret
00112b20 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112b20: 55 push %ebp 112b21: 89 e5 mov %esp,%ebp 112b23: 53 push %ebx 112b24: 83 ec 04 sub $0x4,%esp 112b27: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112b2a: 39 05 20 82 12 00 cmp %eax,0x128220
112b30: 76 1a jbe 112b4c <rtems_io_read+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
112b32: 8d 14 40 lea (%eax,%eax,2),%edx 112b35: c1 e2 03 shl $0x3,%edx 112b38: 03 15 24 82 12 00 add 0x128224,%edx 112b3e: 8b 52 0c mov 0xc(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112b41: 85 d2 test %edx,%edx
112b43: 74 13 je 112b58 <rtems_io_read+0x38> }
112b45: 59 pop %ecx 112b46: 5b pop %ebx 112b47: 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;
112b48: ff e2 jmp *%edx 112b4a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112b4c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112b51: 5a pop %edx 112b52: 5b pop %ebx 112b53: c9 leave 112b54: c3 ret 112b55: 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;
112b58: 31 c0 xor %eax,%eax
}
112b5a: 5a pop %edx 112b5b: 5b pop %ebx 112b5c: c9 leave 112b5d: c3 ret
0010c3b8 <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
)
{
10c3b8: 55 push %ebp 10c3b9: 89 e5 mov %esp,%ebp 10c3bb: 57 push %edi 10c3bc: 56 push %esi 10c3bd: 53 push %ebx 10c3be: 83 ec 0c sub $0xc,%esp 10c3c1: 8b 5d 08 mov 0x8(%ebp),%ebx 10c3c4: 8b 75 0c mov 0xc(%ebp),%esi 10c3c7: 8b 55 10 mov 0x10(%ebp),%edx
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10c3ca: a1 c0 af 12 00 mov 0x12afc0,%eax
if ( rtems_interrupt_is_in_progress() )
10c3cf: 8b 0d 34 ab 12 00 mov 0x12ab34,%ecx 10c3d5: 85 c9 test %ecx,%ecx
10c3d7: 0f 85 ab 00 00 00 jne 10c488 <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10c3dd: 85 d2 test %edx,%edx
10c3df: 0f 84 e7 00 00 00 je 10c4cc <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10c3e5: 89 02 mov %eax,(%edx)
if ( driver_table == NULL )
10c3e7: 85 f6 test %esi,%esi
10c3e9: 0f 84 dd 00 00 00 je 10c4cc <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;
10c3ef: 8b 3e mov (%esi),%edi 10c3f1: 85 ff test %edi,%edi
10c3f3: 0f 84 c7 00 00 00 je 10c4c0 <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 )
10c3f9: 39 d8 cmp %ebx,%eax
10c3fb: 76 7b jbe 10c478 <rtems_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c3fd: a1 8c a5 12 00 mov 0x12a58c,%eax 10c402: 40 inc %eax 10c403: a3 8c a5 12 00 mov %eax,0x12a58c
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10c408: 85 db test %ebx,%ebx
10c40a: 0f 85 88 00 00 00 jne 10c498 <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;
10c410: 8b 0d c0 af 12 00 mov 0x12afc0,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10c416: 85 c9 test %ecx,%ecx
10c418: 0f 84 bb 00 00 00 je 10c4d9 <rtems_io_register_driver+0x121><== NEVER TAKEN
10c41e: 8b 3d c4 af 12 00 mov 0x12afc4,%edi 10c424: 89 f8 mov %edi,%eax 10c426: eb 08 jmp 10c430 <rtems_io_register_driver+0x78> 10c428: 43 inc %ebx 10c429: 83 c0 18 add $0x18,%eax 10c42c: 39 d9 cmp %ebx,%ecx
10c42e: 76 0b jbe 10c43b <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;
10c430: 83 38 00 cmpl $0x0,(%eax)
10c433: 75 f3 jne 10c428 <rtems_io_register_driver+0x70>
10c435: 83 78 04 00 cmpl $0x0,0x4(%eax)
10c439: 75 ed jne 10c428 <rtems_io_register_driver+0x70>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10c43b: 89 1a mov %ebx,(%edx)
if ( m != n )
10c43d: 39 d9 cmp %ebx,%ecx
10c43f: 0f 84 9b 00 00 00 je 10c4e0 <rtems_io_register_driver+0x128>
10c445: 8d 04 5b lea (%ebx,%ebx,2),%eax 10c448: c1 e0 03 shl $0x3,%eax
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10c44b: 01 c7 add %eax,%edi 10c44d: b9 06 00 00 00 mov $0x6,%ecx 10c452: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10c454: e8 cb 1b 00 00 call 10e024 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10c459: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10c460: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10c467: 89 5d 08 mov %ebx,0x8(%ebp)
}
10c46a: 83 c4 0c add $0xc,%esp 10c46d: 5b pop %ebx 10c46e: 5e pop %esi 10c46f: 5f pop %edi 10c470: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10c471: e9 5e 81 00 00 jmp 1145d4 <rtems_io_initialize> 10c476: 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;
10c478: 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 );
}
10c47d: 83 c4 0c add $0xc,%esp 10c480: 5b pop %ebx 10c481: 5e pop %esi 10c482: 5f pop %edi 10c483: c9 leave 10c484: c3 ret 10c485: 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;
10c488: 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 );
}
10c48d: 83 c4 0c add $0xc,%esp 10c490: 5b pop %ebx 10c491: 5e pop %esi 10c492: 5f pop %edi 10c493: c9 leave 10c494: c3 ret 10c495: 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;
10c498: 8d 04 5b lea (%ebx,%ebx,2),%eax 10c49b: c1 e0 03 shl $0x3,%eax 10c49e: 8b 0d c4 af 12 00 mov 0x12afc4,%ecx 10c4a4: 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;
10c4a6: 8b 39 mov (%ecx),%edi 10c4a8: 85 ff test %edi,%edi
10c4aa: 74 40 je 10c4ec <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();
10c4ac: e8 73 1b 00 00 call 10e024 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10c4b1: 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 );
}
10c4b6: 83 c4 0c add $0xc,%esp 10c4b9: 5b pop %ebx 10c4ba: 5e pop %esi 10c4bb: 5f pop %edi 10c4bc: c9 leave 10c4bd: c3 ret 10c4be: 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;
10c4c0: 8b 4e 04 mov 0x4(%esi),%ecx 10c4c3: 85 c9 test %ecx,%ecx
10c4c5: 0f 85 2e ff ff ff jne 10c3f9 <rtems_io_register_driver+0x41>
10c4cb: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10c4cc: 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 );
}
10c4d1: 83 c4 0c add $0xc,%esp 10c4d4: 5b pop %ebx 10c4d5: 5e pop %esi 10c4d6: 5f pop %edi 10c4d7: c9 leave 10c4d8: c3 ret
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10c4d9: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 10c4df: 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();
10c4e0: e8 3f 1b 00 00 call 10e024 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10c4e5: 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;
10c4ea: eb 91 jmp 10c47d <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;
10c4ec: 8b 49 04 mov 0x4(%ecx),%ecx 10c4ef: 85 c9 test %ecx,%ecx
10c4f1: 75 b9 jne 10c4ac <rtems_io_register_driver+0xf4>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10c4f3: 89 1a mov %ebx,(%edx) 10c4f5: 8b 3d c4 af 12 00 mov 0x12afc4,%edi 10c4fb: e9 4b ff ff ff jmp 10c44b <rtems_io_register_driver+0x93>
0010c500 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10c500: 55 push %ebp 10c501: 89 e5 mov %esp,%ebp 10c503: 57 push %edi 10c504: 83 ec 04 sub $0x4,%esp 10c507: 8b 45 08 mov 0x8(%ebp),%eax
if ( rtems_interrupt_is_in_progress() )
10c50a: 8b 0d 34 ab 12 00 mov 0x12ab34,%ecx 10c510: 85 c9 test %ecx,%ecx
10c512: 75 44 jne 10c558 <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10c514: 39 05 c0 af 12 00 cmp %eax,0x12afc0
10c51a: 77 0c ja 10c528 <rtems_io_unregister_driver+0x28>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
10c51c: b8 0d 00 00 00 mov $0xd,%eax
}
10c521: 5a pop %edx 10c522: 5f pop %edi 10c523: c9 leave 10c524: c3 ret 10c525: 8d 76 00 lea 0x0(%esi),%esi 10c528: 8b 15 8c a5 12 00 mov 0x12a58c,%edx 10c52e: 42 inc %edx 10c52f: 89 15 8c a5 12 00 mov %edx,0x12a58c
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
&_IO_Driver_address_table[major],
10c535: 8d 14 40 lea (%eax,%eax,2),%edx 10c538: 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(
10c53b: 03 15 c4 af 12 00 add 0x12afc4,%edx 10c541: b9 18 00 00 00 mov $0x18,%ecx 10c546: 31 c0 xor %eax,%eax 10c548: 89 d7 mov %edx,%edi 10c54a: f3 aa rep stos %al,%es:(%edi)
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
10c54c: e8 d3 1a 00 00 call 10e024 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c551: 31 c0 xor %eax,%eax
}
return RTEMS_UNSATISFIED;
}
10c553: 5a pop %edx 10c554: 5f pop %edi 10c555: c9 leave 10c556: c3 ret 10c557: 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;
10c558: b8 12 00 00 00 mov $0x12,%eax
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10c55d: 5a pop %edx 10c55e: 5f pop %edi 10c55f: c9 leave 10c560: c3 ret
00112b60 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112b60: 55 push %ebp 112b61: 89 e5 mov %esp,%ebp 112b63: 53 push %ebx 112b64: 83 ec 04 sub $0x4,%esp 112b67: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112b6a: 39 05 20 82 12 00 cmp %eax,0x128220
112b70: 76 1a jbe 112b8c <rtems_io_write+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
112b72: 8d 14 40 lea (%eax,%eax,2),%edx 112b75: c1 e2 03 shl $0x3,%edx 112b78: 03 15 24 82 12 00 add 0x128224,%edx 112b7e: 8b 52 10 mov 0x10(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112b81: 85 d2 test %edx,%edx
112b83: 74 13 je 112b98 <rtems_io_write+0x38> }
112b85: 59 pop %ecx 112b86: 5b pop %ebx 112b87: 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;
112b88: ff e2 jmp *%edx 112b8a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112b8c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112b91: 5a pop %edx 112b92: 5b pop %ebx 112b93: c9 leave 112b94: c3 ret 112b95: 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;
112b98: 31 c0 xor %eax,%eax
}
112b9a: 5a pop %edx 112b9b: 5b pop %ebx 112b9c: c9 leave 112b9d: c3 ret
0010d39c <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)
{
10d39c: 55 push %ebp 10d39d: 89 e5 mov %esp,%ebp 10d39f: 57 push %edi 10d3a0: 56 push %esi 10d3a1: 53 push %ebx 10d3a2: 83 ec 1c sub $0x1c,%esp 10d3a5: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10d3a8: 85 ff test %edi,%edi
10d3aa: 74 49 je 10d3f5 <rtems_iterate_over_all_threads+0x59><== NEVER TAKEN
10d3ac: 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 ];
10d3b3: 8b 55 e4 mov -0x1c(%ebp),%edx 10d3b6: 8b 04 95 44 b3 12 00 mov 0x12b344(,%edx,4),%eax 10d3bd: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10d3c0: 85 f6 test %esi,%esi
10d3c2: 74 28 je 10d3ec <rtems_iterate_over_all_threads+0x50>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10d3c4: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10d3c9: 74 21 je 10d3ec <rtems_iterate_over_all_threads+0x50>
10d3cb: bb 01 00 00 00 mov $0x1,%ebx
the_thread = (Thread_Control *)information->local_table[ i ];
10d3d0: 8b 46 1c mov 0x1c(%esi),%eax 10d3d3: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10d3d6: 85 c0 test %eax,%eax
10d3d8: 74 09 je 10d3e3 <rtems_iterate_over_all_threads+0x47><== NEVER TAKEN
continue;
(*routine)(the_thread);
10d3da: 83 ec 0c sub $0xc,%esp 10d3dd: 50 push %eax 10d3de: ff d7 call *%edi 10d3e0: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10d3e3: 43 inc %ebx 10d3e4: 0f b7 46 10 movzwl 0x10(%esi),%eax 10d3e8: 39 d8 cmp %ebx,%eax
10d3ea: 73 e4 jae 10d3d0 <rtems_iterate_over_all_threads+0x34>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10d3ec: ff 45 e4 incl -0x1c(%ebp) 10d3ef: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp)
10d3f3: 75 be jne 10d3b3 <rtems_iterate_over_all_threads+0x17>
(*routine)(the_thread);
}
}
}
10d3f5: 8d 65 f4 lea -0xc(%ebp),%esp 10d3f8: 5b pop %ebx 10d3f9: 5e pop %esi 10d3fa: 5f pop %edi 10d3fb: c9 leave 10d3fc: c3 ret
001159e4 <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
1159e4: 55 push %ebp 1159e5: 89 e5 mov %esp,%ebp 1159e7: 57 push %edi 1159e8: 56 push %esi 1159e9: 53 push %ebx 1159ea: 83 ec 1c sub $0x1c,%esp 1159ed: 8b 7d 08 mov 0x8(%ebp),%edi 1159f0: 8b 5d 0c mov 0xc(%ebp),%ebx 1159f3: 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 )
1159f6: 85 db test %ebx,%ebx
1159f8: 74 62 je 115a5c <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
1159fa: 85 f6 test %esi,%esi
1159fc: 74 5e je 115a5c <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1159fe: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1159ff: 8d 45 e4 lea -0x1c(%ebp),%eax 115a02: 50 push %eax 115a03: 57 push %edi 115a04: 68 a0 2a 14 00 push $0x142aa0 115a09: e8 ee 4e 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
115a0e: 83 c4 10 add $0x10,%esp 115a11: 8b 55 e4 mov -0x1c(%ebp),%edx 115a14: 85 d2 test %edx,%edx
115a16: 74 10 je 115a28 <rtems_message_queue_broadcast+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115a18: b8 04 00 00 00 mov $0x4,%eax
}
115a1d: 8d 65 f4 lea -0xc(%ebp),%esp 115a20: 5b pop %ebx 115a21: 5e pop %esi 115a22: 5f pop %edi 115a23: c9 leave 115a24: c3 ret 115a25: 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(
115a28: 83 ec 08 sub $0x8,%esp 115a2b: 56 push %esi 115a2c: 6a 00 push $0x0 115a2e: 57 push %edi 115a2f: ff 75 10 pushl 0x10(%ebp) 115a32: 53 push %ebx 115a33: 83 c0 14 add $0x14,%eax 115a36: 50 push %eax 115a37: e8 ac 34 00 00 call 118ee8 <_CORE_message_queue_Broadcast> 115a3c: 89 c3 mov %eax,%ebx
NULL,
#endif
count
);
_Thread_Enable_dispatch();
115a3e: 83 c4 20 add $0x20,%esp 115a41: e8 3e 5a 00 00 call 11b484 <_Thread_Enable_dispatch>
return
115a46: 83 ec 0c sub $0xc,%esp 115a49: 53 push %ebx 115a4a: e8 69 03 00 00 call 115db8 <_Message_queue_Translate_core_message_queue_return_code> 115a4f: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115a52: 8d 65 f4 lea -0xc(%ebp),%esp 115a55: 5b pop %ebx 115a56: 5e pop %esi 115a57: 5f pop %edi 115a58: c9 leave 115a59: c3 ret 115a5a: 66 90 xchg %ax,%ax
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
115a5c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115a61: 8d 65 f4 lea -0xc(%ebp),%esp 115a64: 5b pop %ebx 115a65: 5e pop %esi 115a66: 5f pop %edi 115a67: c9 leave 115a68: c3 ret
0011026c <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11026c: 55 push %ebp 11026d: 89 e5 mov %esp,%ebp 11026f: 57 push %edi 110270: 56 push %esi 110271: 53 push %ebx 110272: 83 ec 2c sub $0x2c,%esp 110275: 8b 5d 08 mov 0x8(%ebp),%ebx 110278: 8b 75 0c mov 0xc(%ebp),%esi 11027b: 8b 4d 10 mov 0x10(%ebp),%ecx 11027e: 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 ) )
110281: 85 db test %ebx,%ebx
110283: 74 2f je 1102b4 <rtems_message_queue_create+0x48>
return RTEMS_INVALID_NAME;
if ( !id )
110285: 85 ff test %edi,%edi
110287: 0f 84 a3 00 00 00 je 110330 <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 )
11028d: 85 f6 test %esi,%esi
11028f: 74 13 je 1102a4 <rtems_message_queue_create+0x38>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
110291: 85 c9 test %ecx,%ecx
110293: 75 2f jne 1102c4 <rtems_message_queue_create+0x58>
return RTEMS_INVALID_SIZE;
110295: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11029a: 8d 65 f4 lea -0xc(%ebp),%esp 11029d: 5b pop %ebx 11029e: 5e pop %esi 11029f: 5f pop %edi 1102a0: c9 leave 1102a1: c3 ret 1102a2: 66 90 xchg %ax,%ax
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
1102a4: b8 0a 00 00 00 mov $0xa,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1102a9: 8d 65 f4 lea -0xc(%ebp),%esp 1102ac: 5b pop %ebx 1102ad: 5e pop %esi 1102ae: 5f pop %edi 1102af: c9 leave 1102b0: c3 ret 1102b1: 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;
1102b4: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1102b9: 8d 65 f4 lea -0xc(%ebp),%esp 1102bc: 5b pop %ebx 1102bd: 5e pop %esi 1102be: 5f pop %edi 1102bf: c9 leave 1102c0: c3 ret 1102c1: 8d 76 00 lea 0x0(%esi),%esi 1102c4: a1 ec 77 12 00 mov 0x1277ec,%eax 1102c9: 40 inc %eax 1102ca: a3 ec 77 12 00 mov %eax,0x1277ec
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
1102cf: 89 4d d4 mov %ecx,-0x2c(%ebp) 1102d2: e8 11 26 00 00 call 1128e8 <_Message_queue_Allocate> 1102d7: 89 c2 mov %eax,%edx
if ( !the_message_queue ) {
1102d9: 85 c0 test %eax,%eax 1102db: 8b 4d d4 mov -0x2c(%ebp),%ecx
1102de: 74 7c je 11035c <rtems_message_queue_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
1102e0: 8b 45 14 mov 0x14(%ebp),%eax 1102e3: 89 42 10 mov %eax,0x10(%edx)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
1102e6: a8 04 test $0x4,%al 1102e8: 0f 95 c0 setne %al 1102eb: 0f b6 c0 movzbl %al,%eax 1102ee: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
1102f1: 51 push %ecx 1102f2: 56 push %esi 1102f3: 8d 45 e4 lea -0x1c(%ebp),%eax 1102f6: 50 push %eax 1102f7: 8d 42 14 lea 0x14(%edx),%eax 1102fa: 50 push %eax 1102fb: 89 55 d4 mov %edx,-0x2c(%ebp) 1102fe: e8 c5 06 00 00 call 1109c8 <_CORE_message_queue_Initialize> 110303: 83 c4 10 add $0x10,%esp 110306: 84 c0 test %al,%al 110308: 8b 55 d4 mov -0x2c(%ebp),%edx
11030b: 75 2f jne 11033c <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 );
11030d: 83 ec 08 sub $0x8,%esp 110310: 52 push %edx 110311: 68 c0 82 12 00 push $0x1282c0 110316: e8 9d bd ff ff call 10c0b8 <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
11031b: e8 60 ca ff ff call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
110320: 83 c4 10 add $0x10,%esp 110323: b8 0d 00 00 00 mov $0xd,%eax 110328: e9 6d ff ff ff jmp 11029a <rtems_message_queue_create+0x2e> 11032d: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
110330: b8 09 00 00 00 mov $0x9,%eax 110335: e9 60 ff ff ff jmp 11029a <rtems_message_queue_create+0x2e> 11033a: 66 90 xchg %ax,%ax
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
11033c: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
11033f: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
110342: 8b 0d dc 82 12 00 mov 0x1282dc,%ecx 110348: 89 14 b1 mov %edx,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
11034b: 89 5a 0c mov %ebx,0xc(%edx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
11034e: 89 07 mov %eax,(%edi)
name,
0
);
#endif
_Thread_Enable_dispatch();
110350: e8 2b ca ff ff call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
110355: 31 c0 xor %eax,%eax 110357: e9 3e ff ff ff jmp 11029a <rtems_message_queue_create+0x2e>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
11035c: e8 1f ca ff ff call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
110361: b8 05 00 00 00 mov $0x5,%eax 110366: e9 2f ff ff ff jmp 11029a <rtems_message_queue_create+0x2e>
0011036c <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
11036c: 55 push %ebp 11036d: 89 e5 mov %esp,%ebp 11036f: 53 push %ebx 110370: 83 ec 18 sub $0x18,%esp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
110373: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
110376: 50 push %eax 110377: ff 75 08 pushl 0x8(%ebp) 11037a: 68 c0 82 12 00 push $0x1282c0 11037f: e8 74 be ff ff call 10c1f8 <_Objects_Get> 110384: 89 c3 mov %eax,%ebx
switch ( location ) {
110386: 83 c4 10 add $0x10,%esp 110389: 8b 4d f4 mov -0xc(%ebp),%ecx 11038c: 85 c9 test %ecx,%ecx
11038e: 75 3c jne 1103cc <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
110390: 83 ec 08 sub $0x8,%esp 110393: 50 push %eax 110394: 68 c0 82 12 00 push $0x1282c0 110399: e8 22 ba ff ff call 10bdc0 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
11039e: 83 c4 0c add $0xc,%esp 1103a1: 6a 05 push $0x5 1103a3: 6a 00 push $0x0 1103a5: 8d 43 14 lea 0x14(%ebx),%eax 1103a8: 50 push %eax 1103a9: e8 96 05 00 00 call 110944 <_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 );
1103ae: 58 pop %eax 1103af: 5a pop %edx 1103b0: 53 push %ebx 1103b1: 68 c0 82 12 00 push $0x1282c0 1103b6: e8 fd bc ff ff call 10c0b8 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
1103bb: e8 c0 c9 ff ff call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1103c0: 83 c4 10 add $0x10,%esp 1103c3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1103c5: 8b 5d fc mov -0x4(%ebp),%ebx 1103c8: c9 leave 1103c9: c3 ret 1103ca: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1103cc: b8 04 00 00 00 mov $0x4,%eax
}
1103d1: 8b 5d fc mov -0x4(%ebp),%ebx 1103d4: c9 leave 1103d5: c3 ret
00115bd8 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
rtems_id id,
uint32_t *count
)
{
115bd8: 55 push %ebp 115bd9: 89 e5 mov %esp,%ebp 115bdb: 53 push %ebx 115bdc: 83 ec 14 sub $0x14,%esp 115bdf: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
115be2: 85 db test %ebx,%ebx
115be4: 74 46 je 115c2c <rtems_message_queue_flush+0x54>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
115be6: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
115be7: 8d 45 f4 lea -0xc(%ebp),%eax 115bea: 50 push %eax 115beb: ff 75 08 pushl 0x8(%ebp) 115bee: 68 a0 2a 14 00 push $0x142aa0 115bf3: e8 04 4d 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
115bf8: 83 c4 10 add $0x10,%esp 115bfb: 8b 55 f4 mov -0xc(%ebp),%edx 115bfe: 85 d2 test %edx,%edx
115c00: 74 0a je 115c0c <rtems_message_queue_flush+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115c02: b8 04 00 00 00 mov $0x4,%eax
}
115c07: 8b 5d fc mov -0x4(%ebp),%ebx 115c0a: c9 leave 115c0b: 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 );
115c0c: 83 ec 0c sub $0xc,%esp 115c0f: 83 c0 14 add $0x14,%eax 115c12: 50 push %eax 115c13: e8 90 33 00 00 call 118fa8 <_CORE_message_queue_Flush> 115c18: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
115c1a: e8 65 58 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115c1f: 83 c4 10 add $0x10,%esp 115c22: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c24: 8b 5d fc mov -0x4(%ebp),%ebx 115c27: c9 leave 115c28: c3 ret 115c29: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
115c2c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c31: 8b 5d fc mov -0x4(%ebp),%ebx 115c34: c9 leave 115c35: c3 ret
00115c38 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
115c38: 55 push %ebp 115c39: 89 e5 mov %esp,%ebp 115c3b: 53 push %ebx 115c3c: 83 ec 14 sub $0x14,%esp 115c3f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
115c42: 85 db test %ebx,%ebx
115c44: 74 3a je 115c80 <rtems_message_queue_get_number_pending+0x48>
115c46: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
115c47: 8d 45 f4 lea -0xc(%ebp),%eax 115c4a: 50 push %eax 115c4b: ff 75 08 pushl 0x8(%ebp) 115c4e: 68 a0 2a 14 00 push $0x142aa0 115c53: e8 a4 4c 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
115c58: 83 c4 10 add $0x10,%esp 115c5b: 8b 55 f4 mov -0xc(%ebp),%edx 115c5e: 85 d2 test %edx,%edx
115c60: 74 0a je 115c6c <rtems_message_queue_get_number_pending+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115c62: b8 04 00 00 00 mov $0x4,%eax
}
115c67: 8b 5d fc mov -0x4(%ebp),%ebx 115c6a: c9 leave 115c6b: 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;
115c6c: 8b 40 5c mov 0x5c(%eax),%eax 115c6f: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
115c71: e8 0e 58 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115c76: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c78: 8b 5d fc mov -0x4(%ebp),%ebx 115c7b: c9 leave 115c7c: c3 ret 115c7d: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
115c80: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c85: 8b 5d fc mov -0x4(%ebp),%ebx 115c88: c9 leave 115c89: c3 ret
001103d8 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
1103d8: 55 push %ebp 1103d9: 89 e5 mov %esp,%ebp 1103db: 56 push %esi 1103dc: 53 push %ebx 1103dd: 83 ec 10 sub $0x10,%esp 1103e0: 8b 5d 0c mov 0xc(%ebp),%ebx 1103e3: 8b 75 10 mov 0x10(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
1103e6: 85 db test %ebx,%ebx
1103e8: 74 6e je 110458 <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
1103ea: 85 f6 test %esi,%esi
1103ec: 74 6a je 110458 <rtems_message_queue_receive+0x80>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1103ee: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1103ef: 8d 45 f4 lea -0xc(%ebp),%eax 1103f2: 50 push %eax 1103f3: ff 75 08 pushl 0x8(%ebp) 1103f6: 68 c0 82 12 00 push $0x1282c0 1103fb: e8 f8 bd ff ff call 10c1f8 <_Objects_Get>
switch ( location ) {
110400: 83 c4 10 add $0x10,%esp 110403: 8b 55 f4 mov -0xc(%ebp),%edx 110406: 85 d2 test %edx,%edx
110408: 75 42 jne 11044c <rtems_message_queue_receive+0x74>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
11040a: 83 ec 08 sub $0x8,%esp 11040d: ff 75 18 pushl 0x18(%ebp) 110410: 8b 55 14 mov 0x14(%ebp),%edx 110413: 83 e2 01 and $0x1,%edx 110416: 83 f2 01 xor $0x1,%edx 110419: 52 push %edx 11041a: 56 push %esi 11041b: 53 push %ebx 11041c: ff 70 08 pushl 0x8(%eax) 11041f: 83 c0 14 add $0x14,%eax 110422: 50 push %eax 110423: e8 50 06 00 00 call 110a78 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
110428: 83 c4 20 add $0x20,%esp 11042b: e8 50 c9 ff ff call 10cd80 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
110430: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code
110433: a1 98 7d 12 00 mov 0x127d98,%eax
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
110438: ff 70 34 pushl 0x34(%eax) 11043b: e8 a0 00 00 00 call 1104e0 <_Message_queue_Translate_core_message_queue_return_code> 110440: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110443: 8d 65 f8 lea -0x8(%ebp),%esp 110446: 5b pop %ebx 110447: 5e pop %esi 110448: c9 leave 110449: c3 ret 11044a: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11044c: b8 04 00 00 00 mov $0x4,%eax
}
110451: 8d 65 f8 lea -0x8(%ebp),%esp 110454: 5b pop %ebx 110455: 5e pop %esi 110456: c9 leave 110457: c3 ret
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
110458: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11045d: 8d 65 f8 lea -0x8(%ebp),%esp 110460: 5b pop %ebx 110461: 5e pop %esi 110462: c9 leave 110463: c3 ret
00110464 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
rtems_id id,
const void *buffer,
size_t size
)
{
110464: 55 push %ebp 110465: 89 e5 mov %esp,%ebp 110467: 56 push %esi 110468: 53 push %ebx 110469: 83 ec 10 sub $0x10,%esp 11046c: 8b 75 08 mov 0x8(%ebp),%esi 11046f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
110472: 85 db test %ebx,%ebx
110474: 74 5e je 1104d4 <rtems_message_queue_send+0x70>
110476: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
110477: 8d 45 f4 lea -0xc(%ebp),%eax 11047a: 50 push %eax 11047b: 56 push %esi 11047c: 68 c0 82 12 00 push $0x1282c0 110481: e8 72 bd ff ff call 10c1f8 <_Objects_Get>
switch ( location ) {
110486: 83 c4 10 add $0x10,%esp 110489: 8b 55 f4 mov -0xc(%ebp),%edx 11048c: 85 d2 test %edx,%edx
11048e: 74 0c je 11049c <rtems_message_queue_send+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
110490: b8 04 00 00 00 mov $0x4,%eax
}
110495: 8d 65 f8 lea -0x8(%ebp),%esp 110498: 5b pop %ebx 110499: 5e pop %esi 11049a: c9 leave 11049b: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
11049c: 6a 00 push $0x0 11049e: 6a 00 push $0x0 1104a0: 68 ff ff ff 7f push $0x7fffffff 1104a5: 6a 00 push $0x0 1104a7: 56 push %esi 1104a8: ff 75 10 pushl 0x10(%ebp) 1104ab: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Send(
1104ac: 83 c0 14 add $0x14,%eax 1104af: 50 push %eax 1104b0: e8 ef 06 00 00 call 110ba4 <_CORE_message_queue_Submit> 1104b5: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
1104b7: 83 c4 20 add $0x20,%esp 1104ba: e8 c1 c8 ff ff call 10cd80 <_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);
1104bf: 83 ec 0c sub $0xc,%esp 1104c2: 53 push %ebx 1104c3: e8 18 00 00 00 call 1104e0 <_Message_queue_Translate_core_message_queue_return_code> 1104c8: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1104cb: 8d 65 f8 lea -0x8(%ebp),%esp 1104ce: 5b pop %ebx 1104cf: 5e pop %esi 1104d0: c9 leave 1104d1: c3 ret 1104d2: 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;
1104d4: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1104d9: 8d 65 f8 lea -0x8(%ebp),%esp 1104dc: 5b pop %ebx 1104dd: 5e pop %esi 1104de: c9 leave 1104df: c3 ret
00115dc8 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
rtems_id id,
const void *buffer,
size_t size
)
{
115dc8: 55 push %ebp 115dc9: 89 e5 mov %esp,%ebp 115dcb: 56 push %esi 115dcc: 53 push %ebx 115dcd: 83 ec 10 sub $0x10,%esp 115dd0: 8b 75 08 mov 0x8(%ebp),%esi 115dd3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
115dd6: 85 db test %ebx,%ebx
115dd8: 74 5e je 115e38 <rtems_message_queue_urgent+0x70>
115dda: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
115ddb: 8d 45 f4 lea -0xc(%ebp),%eax 115dde: 50 push %eax 115ddf: 56 push %esi 115de0: 68 a0 2a 14 00 push $0x142aa0 115de5: e8 12 4b 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
115dea: 83 c4 10 add $0x10,%esp 115ded: 8b 55 f4 mov -0xc(%ebp),%edx 115df0: 85 d2 test %edx,%edx
115df2: 74 0c je 115e00 <rtems_message_queue_urgent+0x38>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115df4: b8 04 00 00 00 mov $0x4,%eax
}
115df9: 8d 65 f8 lea -0x8(%ebp),%esp 115dfc: 5b pop %ebx 115dfd: 5e pop %esi 115dfe: c9 leave 115dff: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
115e00: 6a 00 push $0x0 115e02: 6a 00 push $0x0 115e04: 68 00 00 00 80 push $0x80000000 115e09: 6a 00 push $0x0 115e0b: 56 push %esi 115e0c: ff 75 10 pushl 0x10(%ebp) 115e0f: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Urgent(
115e10: 83 c0 14 add $0x14,%eax 115e13: 50 push %eax 115e14: e8 cf 33 00 00 call 1191e8 <_CORE_message_queue_Submit> 115e19: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
115e1b: 83 c4 20 add $0x20,%esp 115e1e: e8 61 56 00 00 call 11b484 <_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);
115e23: 83 ec 0c sub $0xc,%esp 115e26: 53 push %ebx 115e27: e8 8c ff ff ff call 115db8 <_Message_queue_Translate_core_message_queue_return_code> 115e2c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115e2f: 8d 65 f8 lea -0x8(%ebp),%esp 115e32: 5b pop %ebx 115e33: 5e pop %esi 115e34: c9 leave 115e35: c3 ret 115e36: 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;
115e38: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115e3d: 8d 65 f8 lea -0x8(%ebp),%esp 115e40: 5b pop %ebx 115e41: 5e pop %esi 115e42: c9 leave 115e43: c3 ret
0010ae70 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
10ae70: 55 push %ebp 10ae71: 89 e5 mov %esp,%ebp 10ae73: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
10ae76: ff 75 08 pushl 0x8(%ebp) 10ae79: 68 00 76 12 00 push $0x127600 10ae7e: e8 ed 49 00 00 call 10f870 <rtems_assoc_ptr_by_local>
if ( api_assoc )
10ae83: 83 c4 10 add $0x10,%esp 10ae86: 85 c0 test %eax,%eax
10ae88: 74 06 je 10ae90 <rtems_object_get_api_name+0x20>
return api_assoc->name;
10ae8a: 8b 00 mov (%eax),%eax
return "BAD CLASS"; }
10ae8c: c9 leave 10ae8d: c3 ret 10ae8e: 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";
10ae90: b8 a3 26 12 00 mov $0x1226a3,%eax
}
10ae95: c9 leave 10ae96: c3 ret
0010c588 <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
)
{
10c588: 55 push %ebp 10c589: 89 e5 mov %esp,%ebp 10c58b: 57 push %edi 10c58c: 56 push %esi 10c58d: 53 push %ebx 10c58e: 83 ec 0c sub $0xc,%esp 10c591: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10c594: 85 db test %ebx,%ebx
10c596: 74 60 je 10c5f8 <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10c598: 83 ec 08 sub $0x8,%esp 10c59b: 0f b7 45 0c movzwl 0xc(%ebp),%eax 10c59f: 50 push %eax 10c5a0: ff 75 08 pushl 0x8(%ebp) 10c5a3: e8 14 1a 00 00 call 10dfbc <_Objects_Get_information>
if ( !obj_info )
10c5a8: 83 c4 10 add $0x10,%esp 10c5ab: 85 c0 test %eax,%eax
10c5ad: 74 59 je 10c608 <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;
10c5af: 8b 50 08 mov 0x8(%eax),%edx 10c5b2: 89 13 mov %edx,(%ebx)
info->maximum_id = obj_info->maximum_id;
10c5b4: 8b 50 0c mov 0xc(%eax),%edx 10c5b7: 89 53 04 mov %edx,0x4(%ebx)
info->auto_extend = obj_info->auto_extend;
10c5ba: 8a 50 12 mov 0x12(%eax),%dl 10c5bd: 88 53 0c mov %dl,0xc(%ebx)
info->maximum = obj_info->maximum;
10c5c0: 0f b7 70 10 movzwl 0x10(%eax),%esi 10c5c4: 89 73 08 mov %esi,0x8(%ebx)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10c5c7: 85 f6 test %esi,%esi
10c5c9: 74 44 je 10c60f <rtems_object_get_class_information+0x87><== NEVER TAKEN
10c5cb: 8b 78 1c mov 0x1c(%eax),%edi 10c5ce: b9 01 00 00 00 mov $0x1,%ecx 10c5d3: b8 01 00 00 00 mov $0x1,%eax 10c5d8: 31 d2 xor %edx,%edx 10c5da: 66 90 xchg %ax,%ax
if ( !obj_info->local_table[i] )
unallocated++;
10c5dc: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4) 10c5e0: 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++ )
10c5e3: 40 inc %eax 10c5e4: 89 c1 mov %eax,%ecx 10c5e6: 39 c6 cmp %eax,%esi
10c5e8: 73 f2 jae 10c5dc <rtems_object_get_class_information+0x54>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10c5ea: 89 53 10 mov %edx,0x10(%ebx)
return RTEMS_SUCCESSFUL;
10c5ed: 31 c0 xor %eax,%eax
}
10c5ef: 8d 65 f4 lea -0xc(%ebp),%esp 10c5f2: 5b pop %ebx 10c5f3: 5e pop %esi 10c5f4: 5f pop %edi 10c5f5: c9 leave 10c5f6: c3 ret 10c5f7: 90 nop
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
10c5f8: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10c5fd: 8d 65 f4 lea -0xc(%ebp),%esp 10c600: 5b pop %ebx 10c601: 5e pop %esi 10c602: 5f pop %edi 10c603: c9 leave 10c604: c3 ret 10c605: 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;
10c608: b8 0a 00 00 00 mov $0xa,%eax 10c60d: eb e0 jmp 10c5ef <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++ )
10c60f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c611: eb d7 jmp 10c5ea <rtems_object_get_class_information+0x62><== NOT EXECUTED
0010ba18 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
10ba18: 55 push %ebp 10ba19: 89 e5 mov %esp,%ebp 10ba1b: 53 push %ebx 10ba1c: 83 ec 14 sub $0x14,%esp 10ba1f: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10ba22: 85 db test %ebx,%ebx
10ba24: 74 26 je 10ba4c <rtems_object_get_classic_name+0x34>
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
10ba26: 83 ec 08 sub $0x8,%esp 10ba29: 8d 45 f4 lea -0xc(%ebp),%eax 10ba2c: 50 push %eax 10ba2d: ff 75 08 pushl 0x8(%ebp) 10ba30: e8 6f 1a 00 00 call 10d4a4 <_Objects_Id_to_name>
*name = name_u.name_u32;
10ba35: 8b 55 f4 mov -0xc(%ebp),%edx 10ba38: 89 13 mov %edx,(%ebx)
return _Status_Object_name_errors_to_status[ status ];
10ba3a: 8b 04 85 0c 33 12 00 mov 0x12330c(,%eax,4),%eax 10ba41: 83 c4 10 add $0x10,%esp
}
10ba44: 8b 5d fc mov -0x4(%ebp),%ebx 10ba47: c9 leave 10ba48: c3 ret 10ba49: 8d 76 00 lea 0x0(%esi),%esi
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10ba4c: 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 ];
}
10ba51: 8b 5d fc mov -0x4(%ebp),%ebx 10ba54: c9 leave 10ba55: c3 ret
0010aea4 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10aea4: 55 push %ebp 10aea5: 89 e5 mov %esp,%ebp 10aea7: 57 push %edi 10aea8: 56 push %esi 10aea9: 53 push %ebx 10aeaa: 83 ec 1c sub $0x1c,%esp 10aead: 8b 75 08 mov 0x8(%ebp),%esi 10aeb0: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10aeb3: 85 ff test %edi,%edi
10aeb5: 74 61 je 10af18 <rtems_object_set_name+0x74>
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10aeb7: 85 f6 test %esi,%esi
10aeb9: 74 35 je 10aef0 <rtems_object_set_name+0x4c>
information = _Objects_Get_information_id( tmpId );
10aebb: 83 ec 0c sub $0xc,%esp 10aebe: 56 push %esi 10aebf: e8 ec 17 00 00 call 10c6b0 <_Objects_Get_information_id> 10aec4: 89 c3 mov %eax,%ebx
if ( !information )
10aec6: 83 c4 10 add $0x10,%esp 10aec9: 85 c0 test %eax,%eax
10aecb: 74 16 je 10aee3 <rtems_object_set_name+0x3f>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10aecd: 50 push %eax 10aece: 8d 45 e4 lea -0x1c(%ebp),%eax 10aed1: 50 push %eax 10aed2: 56 push %esi 10aed3: 53 push %ebx 10aed4: e8 8f 19 00 00 call 10c868 <_Objects_Get>
switch ( location ) {
10aed9: 83 c4 10 add $0x10,%esp 10aedc: 8b 4d e4 mov -0x1c(%ebp),%ecx 10aedf: 85 c9 test %ecx,%ecx
10aee1: 74 19 je 10aefc <rtems_object_set_name+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10aee3: b8 04 00 00 00 mov $0x4,%eax
}
10aee8: 8d 65 f4 lea -0xc(%ebp),%esp 10aeeb: 5b pop %ebx 10aeec: 5e pop %esi 10aeed: 5f pop %edi 10aeee: c9 leave 10aeef: c3 ret
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10aef0: a1 b8 9f 12 00 mov 0x129fb8,%eax 10aef5: 8b 70 08 mov 0x8(%eax),%esi 10aef8: eb c1 jmp 10aebb <rtems_object_set_name+0x17> 10aefa: 66 90 xchg %ax,%ax
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10aefc: 52 push %edx 10aefd: 57 push %edi 10aefe: 50 push %eax 10aeff: 53 push %ebx 10af00: e8 e3 1a 00 00 call 10c9e8 <_Objects_Set_name>
_Thread_Enable_dispatch();
10af05: e8 4a 25 00 00 call 10d454 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10af0a: 83 c4 10 add $0x10,%esp 10af0d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10af0f: 8d 65 f4 lea -0xc(%ebp),%esp 10af12: 5b pop %ebx 10af13: 5e pop %esi 10af14: 5f pop %edi 10af15: c9 leave 10af16: c3 ret 10af17: 90 nop
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10af18: b8 09 00 00 00 mov $0x9,%eax 10af1d: eb c9 jmp 10aee8 <rtems_object_set_name+0x44>
00115e44 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
115e44: 55 push %ebp 115e45: 89 e5 mov %esp,%ebp 115e47: 57 push %edi 115e48: 56 push %esi 115e49: 53 push %ebx 115e4a: 83 ec 1c sub $0x1c,%esp 115e4d: 8b 5d 08 mov 0x8(%ebp),%ebx 115e50: 8b 75 0c mov 0xc(%ebp),%esi 115e53: 8b 55 10 mov 0x10(%ebp),%edx 115e56: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
115e59: 85 db test %ebx,%ebx
115e5b: 74 47 je 115ea4 <rtems_partition_create+0x60>
return RTEMS_INVALID_NAME;
if ( !starting_address )
115e5d: 85 f6 test %esi,%esi
115e5f: 74 23 je 115e84 <rtems_partition_create+0x40>
return RTEMS_INVALID_ADDRESS;
if ( !id )
115e61: 8b 45 1c mov 0x1c(%ebp),%eax 115e64: 85 c0 test %eax,%eax
115e66: 74 1c je 115e84 <rtems_partition_create+0x40><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
115e68: 85 d2 test %edx,%edx
115e6a: 74 28 je 115e94 <rtems_partition_create+0x50>
115e6c: 85 ff test %edi,%edi
115e6e: 74 24 je 115e94 <rtems_partition_create+0x50>
115e70: 39 fa cmp %edi,%edx
115e72: 72 20 jb 115e94 <rtems_partition_create+0x50>
115e74: f7 c7 03 00 00 00 test $0x3,%edi
115e7a: 75 18 jne 115e94 <rtems_partition_create+0x50>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
115e7c: f7 c6 03 00 00 00 test $0x3,%esi
115e82: 74 30 je 115eb4 <rtems_partition_create+0x70>
return RTEMS_INVALID_ADDRESS;
115e84: b8 09 00 00 00 mov $0x9,%eax
);
#endif
_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
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;
115e94: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e99: 8d 65 f4 lea -0xc(%ebp),%esp 115e9c: 5b pop %ebx 115e9d: 5e pop %esi 115e9e: 5f pop %edi 115e9f: c9 leave 115ea0: c3 ret 115ea1: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
115ea4: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115ea9: 8d 65 f4 lea -0xc(%ebp),%esp 115eac: 5b pop %ebx 115ead: 5e pop %esi 115eae: 5f pop %edi 115eaf: c9 leave 115eb0: c3 ret 115eb1: 8d 76 00 lea 0x0(%esi),%esi 115eb4: a1 ac 20 14 00 mov 0x1420ac,%eax 115eb9: 40 inc %eax 115eba: a3 ac 20 14 00 mov %eax,0x1420ac
* 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 );
115ebf: 83 ec 0c sub $0xc,%esp 115ec2: 68 40 1f 14 00 push $0x141f40 115ec7: 89 55 e0 mov %edx,-0x20(%ebp) 115eca: e8 3d 45 00 00 call 11a40c <_Objects_Allocate> 115ecf: 89 45 e4 mov %eax,-0x1c(%ebp)
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
115ed2: 83 c4 10 add $0x10,%esp 115ed5: 85 c0 test %eax,%eax 115ed7: 8b 55 e0 mov -0x20(%ebp),%edx
115eda: 74 58 je 115f34 <rtems_partition_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
115edc: 8b 45 e4 mov -0x1c(%ebp),%eax 115edf: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
115ee2: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
115ee5: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
115ee8: 8b 4d 18 mov 0x18(%ebp),%ecx 115eeb: 89 48 1c mov %ecx,0x1c(%eax)
the_partition->number_of_used_blocks = 0;
115eee: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
_Chain_Initialize( &the_partition->Memory, starting_address,
115ef5: 57 push %edi 115ef6: 89 d0 mov %edx,%eax 115ef8: 31 d2 xor %edx,%edx 115efa: f7 f7 div %edi 115efc: 50 push %eax 115efd: 56 push %esi 115efe: 8b 45 e4 mov -0x1c(%ebp),%eax 115f01: 83 c0 24 add $0x24,%eax 115f04: 50 push %eax 115f05: e8 82 2f 00 00 call 118e8c <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
115f0a: 8b 7d e4 mov -0x1c(%ebp),%edi 115f0d: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
115f10: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
115f13: 8b 15 5c 1f 14 00 mov 0x141f5c,%edx 115f19: 89 3c b2 mov %edi,(%edx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
115f1c: 89 5f 0c mov %ebx,0xc(%edi)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
115f1f: 8b 55 1c mov 0x1c(%ebp),%edx 115f22: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
115f24: e8 5b 55 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115f29: 83 c4 10 add $0x10,%esp 115f2c: 31 c0 xor %eax,%eax 115f2e: e9 66 ff ff ff jmp 115e99 <rtems_partition_create+0x55> 115f33: 90 nop
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
115f34: e8 4b 55 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115f39: b8 05 00 00 00 mov $0x5,%eax 115f3e: e9 56 ff ff ff jmp 115e99 <rtems_partition_create+0x55>
00115fb0 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
115fb0: 55 push %ebp 115fb1: 89 e5 mov %esp,%ebp 115fb3: 56 push %esi 115fb4: 53 push %ebx 115fb5: 83 ec 20 sub $0x20,%esp 115fb8: 8b 5d 0c mov 0xc(%ebp),%ebx
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
115fbb: 85 db test %ebx,%ebx
115fbd: 74 59 je 116018 <rtems_partition_get_buffer+0x68><== NEVER TAKEN
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
115fbf: 52 push %edx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
115fc0: 8d 45 f4 lea -0xc(%ebp),%eax 115fc3: 50 push %eax 115fc4: ff 75 08 pushl 0x8(%ebp) 115fc7: 68 40 1f 14 00 push $0x141f40 115fcc: e8 2b 49 00 00 call 11a8fc <_Objects_Get> 115fd1: 89 c6 mov %eax,%esi
switch ( location ) {
115fd3: 83 c4 10 add $0x10,%esp 115fd6: 8b 45 f4 mov -0xc(%ebp),%eax 115fd9: 85 c0 test %eax,%eax
115fdb: 75 2f jne 11600c <rtems_partition_get_buffer+0x5c><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
115fdd: 83 ec 0c sub $0xc,%esp 115fe0: 8d 46 24 lea 0x24(%esi),%eax 115fe3: 50 push %eax 115fe4: e8 7f 2e 00 00 call 118e68 <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
115fe9: 83 c4 10 add $0x10,%esp 115fec: 85 c0 test %eax,%eax
115fee: 74 34 je 116024 <rtems_partition_get_buffer+0x74>
the_partition->number_of_used_blocks += 1;
115ff0: ff 46 20 incl 0x20(%esi)
_Thread_Enable_dispatch();
115ff3: 89 45 e4 mov %eax,-0x1c(%ebp) 115ff6: e8 89 54 00 00 call 11b484 <_Thread_Enable_dispatch>
*buffer = the_buffer;
115ffb: 8b 45 e4 mov -0x1c(%ebp),%eax 115ffe: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
116000: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116002: 8d 65 f8 lea -0x8(%ebp),%esp 116005: 5b pop %ebx 116006: 5e pop %esi 116007: c9 leave 116008: c3 ret 116009: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11600c: b8 04 00 00 00 mov $0x4,%eax
}
116011: 8d 65 f8 lea -0x8(%ebp),%esp 116014: 5b pop %ebx 116015: 5e pop %esi 116016: c9 leave 116017: c3 ret
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
116018: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11601d: 8d 65 f8 lea -0x8(%ebp),%esp 116020: 5b pop %ebx 116021: 5e pop %esi 116022: c9 leave 116023: c3 ret
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
116024: e8 5b 54 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
116029: b8 0d 00 00 00 mov $0xd,%eax 11602e: eb e1 jmp 116011 <rtems_partition_get_buffer+0x61>
00116054 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
116054: 55 push %ebp 116055: 89 e5 mov %esp,%ebp 116057: 56 push %esi 116058: 53 push %ebx 116059: 83 ec 14 sub $0x14,%esp 11605c: 8b 75 0c mov 0xc(%ebp),%esi
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
11605f: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116062: 50 push %eax 116063: ff 75 08 pushl 0x8(%ebp) 116066: 68 40 1f 14 00 push $0x141f40 11606b: e8 8c 48 00 00 call 11a8fc <_Objects_Get> 116070: 89 c3 mov %eax,%ebx
switch ( location ) {
116072: 83 c4 10 add $0x10,%esp 116075: 8b 45 f4 mov -0xc(%ebp),%eax 116078: 85 c0 test %eax,%eax
11607a: 74 0c je 116088 <rtems_partition_return_buffer+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11607c: b8 04 00 00 00 mov $0x4,%eax
}
116081: 8d 65 f8 lea -0x8(%ebp),%esp 116084: 5b pop %ebx 116085: 5e pop %esi 116086: c9 leave 116087: c3 ret
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
116088: 8b 43 10 mov 0x10(%ebx),%eax
ending = _Addresses_Add_offset( starting, the_partition->length );
11608b: 8b 53 14 mov 0x14(%ebx),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
11608e: 39 c6 cmp %eax,%esi
116090: 72 3a jb 1160cc <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116092: 8d 14 10 lea (%eax,%edx,1),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116095: 39 d6 cmp %edx,%esi
116097: 77 33 ja 1160cc <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);
116099: 89 f2 mov %esi,%edx 11609b: 29 c2 sub %eax,%edx 11609d: 89 d0 mov %edx,%eax
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
11609f: 31 d2 xor %edx,%edx 1160a1: 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 ) &&
1160a4: 85 d2 test %edx,%edx
1160a6: 75 24 jne 1160cc <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 );
1160a8: 83 ec 08 sub $0x8,%esp 1160ab: 56 push %esi 1160ac: 8d 43 24 lea 0x24(%ebx),%eax 1160af: 50 push %eax 1160b0: e8 77 2d 00 00 call 118e2c <_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;
1160b5: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
1160b8: e8 c7 53 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1160bd: 83 c4 10 add $0x10,%esp 1160c0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1160c2: 8d 65 f8 lea -0x8(%ebp),%esp 1160c5: 5b pop %ebx 1160c6: 5e pop %esi 1160c7: c9 leave 1160c8: c3 ret 1160c9: 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();
1160cc: e8 b3 53 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
1160d1: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1160d6: 8d 65 f8 lea -0x8(%ebp),%esp 1160d9: 5b pop %ebx 1160da: 5e pop %esi 1160db: c9 leave 1160dc: c3 ret
00115478 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
115478: 55 push %ebp 115479: 89 e5 mov %esp,%ebp 11547b: 57 push %edi 11547c: 56 push %esi 11547d: 53 push %ebx 11547e: 83 ec 1c sub $0x1c,%esp 115481: 8b 5d 08 mov 0x8(%ebp),%ebx 115484: 8b 55 0c mov 0xc(%ebp),%edx 115487: 8b 7d 10 mov 0x10(%ebp),%edi 11548a: 8b 75 18 mov 0x18(%ebp),%esi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
11548d: 85 db test %ebx,%ebx
11548f: 74 1b je 1154ac <rtems_port_create+0x34>
return RTEMS_INVALID_NAME;
if ( !id )
115491: 85 f6 test %esi,%esi
115493: 74 08 je 11549d <rtems_port_create+0x25>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
115495: 89 f8 mov %edi,%eax 115497: 09 d0 or %edx,%eax
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
115499: a8 03 test $0x3,%al
11549b: 74 1f je 1154bc <rtems_port_create+0x44>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
11549d: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1154a2: 8d 65 f4 lea -0xc(%ebp),%esp 1154a5: 5b pop %ebx 1154a6: 5e pop %esi 1154a7: 5f pop %edi 1154a8: c9 leave 1154a9: c3 ret 1154aa: 66 90 xchg %ax,%ax
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1154ac: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1154b1: 8d 65 f4 lea -0xc(%ebp),%esp 1154b4: 5b pop %ebx 1154b5: 5e pop %esi 1154b6: 5f pop %edi 1154b7: c9 leave 1154b8: c3 ret 1154b9: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1154bc: a1 ac 20 14 00 mov 0x1420ac,%eax 1154c1: 40 inc %eax 1154c2: a3 ac 20 14 00 mov %eax,0x1420ac
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
1154c7: 83 ec 0c sub $0xc,%esp 1154ca: 68 00 1f 14 00 push $0x141f00 1154cf: 89 55 e4 mov %edx,-0x1c(%ebp) 1154d2: e8 35 4f 00 00 call 11a40c <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
1154d7: 83 c4 10 add $0x10,%esp 1154da: 85 c0 test %eax,%eax 1154dc: 8b 55 e4 mov -0x1c(%ebp),%edx
1154df: 74 33 je 115514 <rtems_port_create+0x9c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
1154e1: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
1154e4: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
1154e7: 8b 55 14 mov 0x14(%ebp),%edx 1154ea: 4a dec %edx 1154eb: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1154ee: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1154f1: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1154f4: 8b 0d 1c 1f 14 00 mov 0x141f1c,%ecx 1154fa: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1154fd: 89 58 0c mov %ebx,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
115500: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
115502: e8 7d 5f 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115507: 31 c0 xor %eax,%eax
}
115509: 8d 65 f4 lea -0xc(%ebp),%esp 11550c: 5b pop %ebx 11550d: 5e pop %esi 11550e: 5f pop %edi 11550f: c9 leave 115510: c3 ret 115511: 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();
115514: e8 6b 5f 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115519: b8 05 00 00 00 mov $0x5,%eax 11551e: eb 82 jmp 1154a2 <rtems_port_create+0x2a>
00115520 <rtems_port_delete>:
*/
rtems_status_code rtems_port_delete(
rtems_id id
)
{
115520: 55 push %ebp 115521: 89 e5 mov %esp,%ebp 115523: 83 ec 2c sub $0x2c,%esp
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
115526: 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 );
115529: 50 push %eax 11552a: ff 75 08 pushl 0x8(%ebp) 11552d: 68 00 1f 14 00 push $0x141f00 115532: e8 c5 53 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
115537: 83 c4 10 add $0x10,%esp 11553a: 8b 4d f4 mov -0xc(%ebp),%ecx 11553d: 85 c9 test %ecx,%ecx
11553f: 75 2f jne 115570 <rtems_port_delete+0x50>
case OBJECTS_LOCAL:
_Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
115541: 83 ec 08 sub $0x8,%esp 115544: 50 push %eax 115545: 68 00 1f 14 00 push $0x141f00 11554a: 89 45 e4 mov %eax,-0x1c(%ebp) 11554d: e8 36 4f 00 00 call 11a488 <_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 );
115552: 58 pop %eax 115553: 5a pop %edx 115554: 8b 45 e4 mov -0x1c(%ebp),%eax 115557: 50 push %eax 115558: 68 00 1f 14 00 push $0x141f00 11555d: e8 1e 52 00 00 call 11a780 <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
115562: e8 1d 5f 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115567: 83 c4 10 add $0x10,%esp 11556a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11556c: c9 leave 11556d: c3 ret 11556e: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115570: b8 04 00 00 00 mov $0x4,%eax
}
115575: c9 leave 115576: c3 ret
00115578 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
rtems_id id,
void *external,
void **internal
)
{
115578: 55 push %ebp 115579: 89 e5 mov %esp,%ebp 11557b: 56 push %esi 11557c: 53 push %ebx 11557d: 83 ec 10 sub $0x10,%esp 115580: 8b 75 0c mov 0xc(%ebp),%esi 115583: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
115586: 85 db test %ebx,%ebx
115588: 74 4e je 1155d8 <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 );
11558a: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
11558b: 8d 45 f4 lea -0xc(%ebp),%eax 11558e: 50 push %eax 11558f: ff 75 08 pushl 0x8(%ebp) 115592: 68 00 1f 14 00 push $0x141f00 115597: e8 60 53 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
11559c: 83 c4 10 add $0x10,%esp 11559f: 8b 55 f4 mov -0xc(%ebp),%edx 1155a2: 85 d2 test %edx,%edx
1155a4: 74 0e je 1155b4 <rtems_port_external_to_internal+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1155a6: b8 04 00 00 00 mov $0x4,%eax
}
1155ab: 8d 65 f8 lea -0x8(%ebp),%esp 1155ae: 5b pop %ebx 1155af: 5e pop %esi 1155b0: c9 leave 1155b1: c3 ret 1155b2: 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);
1155b4: 89 f2 mov %esi,%edx 1155b6: 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 )
1155b9: 3b 50 18 cmp 0x18(%eax),%edx
1155bc: 77 16 ja 1155d4 <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);
1155be: 03 50 10 add 0x10(%eax),%edx 1155c1: 89 13 mov %edx,(%ebx)
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
1155c3: e8 bc 5e 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1155c8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1155ca: 8d 65 f8 lea -0x8(%ebp),%esp 1155cd: 5b pop %ebx 1155ce: 5e pop %esi 1155cf: c9 leave 1155d0: c3 ret 1155d1: 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;
1155d4: 89 33 mov %esi,(%ebx) 1155d6: eb eb jmp 1155c3 <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;
1155d8: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1155dd: 8d 65 f8 lea -0x8(%ebp),%esp 1155e0: 5b pop %ebx 1155e1: 5e pop %esi 1155e2: c9 leave 1155e3: c3 ret
00115608 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
115608: 55 push %ebp 115609: 89 e5 mov %esp,%ebp 11560b: 56 push %esi 11560c: 53 push %ebx 11560d: 83 ec 10 sub $0x10,%esp 115610: 8b 75 0c mov 0xc(%ebp),%esi 115613: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
115616: 85 db test %ebx,%ebx
115618: 74 4e je 115668 <rtems_port_internal_to_external+0x60>
11561a: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
11561b: 8d 45 f4 lea -0xc(%ebp),%eax 11561e: 50 push %eax 11561f: ff 75 08 pushl 0x8(%ebp) 115622: 68 00 1f 14 00 push $0x141f00 115627: e8 d0 52 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
11562c: 83 c4 10 add $0x10,%esp 11562f: 8b 55 f4 mov -0xc(%ebp),%edx 115632: 85 d2 test %edx,%edx
115634: 74 0e je 115644 <rtems_port_internal_to_external+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115636: b8 04 00 00 00 mov $0x4,%eax
}
11563b: 8d 65 f8 lea -0x8(%ebp),%esp 11563e: 5b pop %ebx 11563f: 5e pop %esi 115640: c9 leave 115641: c3 ret 115642: 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);
115644: 89 f2 mov %esi,%edx 115646: 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 )
115649: 3b 50 18 cmp 0x18(%eax),%edx
11564c: 77 16 ja 115664 <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);
11564e: 03 50 14 add 0x14(%eax),%edx 115651: 89 13 mov %edx,(%ebx)
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
115653: e8 2c 5e 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115658: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11565a: 8d 65 f8 lea -0x8(%ebp),%esp 11565d: 5b pop %ebx 11565e: 5e pop %esi 11565f: c9 leave 115660: c3 ret 115661: 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;
115664: 89 33 mov %esi,(%ebx) 115666: eb eb jmp 115653 <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;
115668: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11566d: 8d 65 f8 lea -0x8(%ebp),%esp 115670: 5b pop %ebx 115671: 5e pop %esi 115672: c9 leave 115673: c3 ret
001160e0 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
1160e0: 55 push %ebp 1160e1: 89 e5 mov %esp,%ebp 1160e3: 53 push %ebx 1160e4: 83 ec 18 sub $0x18,%esp
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
1160e7: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
1160ea: 50 push %eax 1160eb: ff 75 08 pushl 0x8(%ebp) 1160ee: 68 80 1f 14 00 push $0x141f80 1160f3: e8 04 48 00 00 call 11a8fc <_Objects_Get> 1160f8: 89 c3 mov %eax,%ebx
switch ( location ) {
1160fa: 83 c4 10 add $0x10,%esp 1160fd: 8b 45 f4 mov -0xc(%ebp),%eax 116100: 85 c0 test %eax,%eax
116102: 74 0c je 116110 <rtems_rate_monotonic_cancel+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116104: b8 04 00 00 00 mov $0x4,%eax
}
116109: 8b 5d fc mov -0x4(%ebp),%ebx 11610c: c9 leave 11610d: c3 ret 11610e: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
116110: a1 58 26 14 00 mov 0x142658,%eax 116115: 39 43 40 cmp %eax,0x40(%ebx)
116118: 74 12 je 11612c <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
11611a: e8 65 53 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
11611f: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116124: 8b 5d fc mov -0x4(%ebp),%ebx 116127: c9 leave 116128: c3 ret 116129: 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 );
11612c: 83 ec 0c sub $0xc,%esp 11612f: 8d 43 10 lea 0x10(%ebx),%eax 116132: 50 push %eax 116133: e8 14 64 00 00 call 11c54c <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
116138: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
_Thread_Enable_dispatch();
11613f: e8 40 53 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116144: 83 c4 10 add $0x10,%esp 116147: 31 c0 xor %eax,%eax 116149: eb be jmp 116109 <rtems_rate_monotonic_cancel+0x29>
0010b828 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
10b828: 55 push %ebp 10b829: 89 e5 mov %esp,%ebp 10b82b: 57 push %edi 10b82c: 56 push %esi 10b82d: 53 push %ebx 10b82e: 83 ec 1c sub $0x1c,%esp 10b831: 8b 5d 08 mov 0x8(%ebp),%ebx 10b834: 8b 75 0c mov 0xc(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10b837: 85 db test %ebx,%ebx
10b839: 0f 84 a9 00 00 00 je 10b8e8 <rtems_rate_monotonic_create+0xc0>
return RTEMS_INVALID_NAME;
if ( !id )
10b83f: 85 f6 test %esi,%esi
10b841: 0f 84 c5 00 00 00 je 10b90c <rtems_rate_monotonic_create+0xe4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b847: a1 6c ab 12 00 mov 0x12ab6c,%eax 10b84c: 40 inc %eax 10b84d: a3 6c ab 12 00 mov %eax,0x12ab6c
* 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 );
10b852: 83 ec 0c sub $0xc,%esp 10b855: 68 80 aa 12 00 push $0x12aa80 10b85a: e8 e9 1d 00 00 call 10d648 <_Objects_Allocate> 10b85f: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
10b861: 83 c4 10 add $0x10,%esp 10b864: 85 c0 test %eax,%eax
10b866: 0f 84 8c 00 00 00 je 10b8f8 <rtems_rate_monotonic_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10b86c: a1 18 b1 12 00 mov 0x12b118,%eax 10b871: 89 42 40 mov %eax,0x40(%edx)
the_period->state = RATE_MONOTONIC_INACTIVE;
10b874: 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;
10b87b: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
10b882: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx)
the_watchdog->id = id;
10b889: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
the_watchdog->user_data = user_data;
10b890: 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 );
10b897: 8d 42 54 lea 0x54(%edx),%eax 10b89a: 89 45 e4 mov %eax,-0x1c(%ebp) 10b89d: b9 38 00 00 00 mov $0x38,%ecx 10b8a2: 31 c0 xor %eax,%eax 10b8a4: 8b 7d e4 mov -0x1c(%ebp),%edi 10b8a7: f3 aa rep stos %al,%es:(%edi) 10b8a9: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10b8b0: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10b8b7: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10b8be: 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 ),
10b8c5: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b8c8: 0f b7 f8 movzwl %ax,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b8cb: 8b 0d 9c aa 12 00 mov 0x12aa9c,%ecx 10b8d1: 89 14 b9 mov %edx,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b8d4: 89 5a 0c mov %ebx,0xc(%edx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
10b8d7: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10b8d9: e8 8e 2e 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b8de: 31 c0 xor %eax,%eax
}
10b8e0: 8d 65 f4 lea -0xc(%ebp),%esp 10b8e3: 5b pop %ebx 10b8e4: 5e pop %esi 10b8e5: 5f pop %edi 10b8e6: c9 leave 10b8e7: c3 ret
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b8e8: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b8ed: 8d 65 f4 lea -0xc(%ebp),%esp 10b8f0: 5b pop %ebx 10b8f1: 5e pop %esi 10b8f2: 5f pop %edi 10b8f3: c9 leave 10b8f4: c3 ret 10b8f5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
10b8f8: e8 6f 2e 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b8fd: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b902: 8d 65 f4 lea -0xc(%ebp),%esp 10b905: 5b pop %ebx 10b906: 5e pop %esi 10b907: 5f pop %edi 10b908: c9 leave 10b909: c3 ret 10b90a: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b90c: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b911: 8d 65 f4 lea -0xc(%ebp),%esp 10b914: 5b pop %ebx 10b915: 5e pop %esi 10b916: 5f pop %edi 10b917: c9 leave 10b918: c3 ret
00112114 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
112114: 55 push %ebp 112115: 89 e5 mov %esp,%ebp 112117: 53 push %ebx 112118: 83 ec 24 sub $0x24,%esp 11211b: 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 )
11211e: 85 db test %ebx,%ebx
112120: 0f 84 92 00 00 00 je 1121b8 <rtems_rate_monotonic_get_status+0xa4>
112126: 50 push %eax
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
112127: 8d 45 f4 lea -0xc(%ebp),%eax 11212a: 50 push %eax 11212b: ff 75 08 pushl 0x8(%ebp) 11212e: 68 80 aa 12 00 push $0x12aa80 112133: e8 ac ba ff ff call 10dbe4 <_Objects_Get>
switch ( location ) {
112138: 83 c4 10 add $0x10,%esp 11213b: 8b 4d f4 mov -0xc(%ebp),%ecx 11213e: 85 c9 test %ecx,%ecx
112140: 74 0a je 11214c <rtems_rate_monotonic_get_status+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
112142: b8 04 00 00 00 mov $0x4,%eax
}
112147: 8b 5d fc mov -0x4(%ebp),%ebx 11214a: c9 leave 11214b: c3 ret
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
11214c: 8b 50 40 mov 0x40(%eax),%edx 11214f: 8b 52 08 mov 0x8(%edx),%edx 112152: 89 13 mov %edx,(%ebx)
status->state = the_period->state;
112154: 8b 50 38 mov 0x38(%eax),%edx 112157: 89 53 04 mov %edx,0x4(%ebx)
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
11215a: 85 d2 test %edx,%edx
11215c: 75 2a jne 112188 <rtems_rate_monotonic_get_status+0x74>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
11215e: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 112165: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Timespec_Set_to_zero( &status->executed_since_last_period );
11216c: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 112173: 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();
11217a: e8 ed c5 ff ff call 10e76c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11217f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112181: 8b 5d fc mov -0x4(%ebp),%ebx 112184: c9 leave 112185: c3 ret 112186: 66 90 xchg %ax,%ax
} else {
/*
* Grab the current status.
*/
valid_status =
112188: 52 push %edx
_Rate_monotonic_Get_status(
112189: 8d 55 ec lea -0x14(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
11218c: 52 push %edx
_Rate_monotonic_Get_status(
11218d: 8d 55 e4 lea -0x1c(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
112190: 52 push %edx 112191: 50 push %eax 112192: e8 a9 97 ff ff call 10b940 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
112197: 83 c4 10 add $0x10,%esp 11219a: 84 c0 test %al,%al
11219c: 74 26 je 1121c4 <rtems_rate_monotonic_get_status+0xb0>
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
11219e: 8b 45 e4 mov -0x1c(%ebp),%eax 1121a1: 8b 55 e8 mov -0x18(%ebp),%edx 1121a4: 89 43 08 mov %eax,0x8(%ebx) 1121a7: 89 53 0c mov %edx,0xc(%ebx)
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
1121aa: 8b 45 ec mov -0x14(%ebp),%eax 1121ad: 8b 55 f0 mov -0x10(%ebp),%edx 1121b0: 89 43 10 mov %eax,0x10(%ebx) 1121b3: 89 53 14 mov %edx,0x14(%ebx) 1121b6: eb c2 jmp 11217a <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;
1121b8: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1121bd: 8b 5d fc mov -0x4(%ebp),%ebx 1121c0: c9 leave 1121c1: c3 ret 1121c2: 66 90 xchg %ax,%ax
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
1121c4: e8 a3 c5 ff ff call 10e76c <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
1121c9: b8 0b 00 00 00 mov $0xb,%eax 1121ce: e9 74 ff ff ff jmp 112147 <rtems_rate_monotonic_get_status+0x33>
0010bb3c <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10bb3c: 55 push %ebp 10bb3d: 89 e5 mov %esp,%ebp 10bb3f: 57 push %edi 10bb40: 56 push %esi 10bb41: 53 push %ebx 10bb42: 83 ec 30 sub $0x30,%esp 10bb45: 8b 5d 08 mov 0x8(%ebp),%ebx 10bb48: 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 );
10bb4b: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10bb4e: 50 push %eax 10bb4f: 53 push %ebx 10bb50: 68 80 aa 12 00 push $0x12aa80 10bb55: e8 8a 20 00 00 call 10dbe4 <_Objects_Get>
switch ( location ) {
10bb5a: 83 c4 10 add $0x10,%esp 10bb5d: 8b 55 e4 mov -0x1c(%ebp),%edx 10bb60: 85 d2 test %edx,%edx
10bb62: 74 10 je 10bb74 <rtems_rate_monotonic_period+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb64: b8 04 00 00 00 mov $0x4,%eax
}
10bb69: 8d 65 f4 lea -0xc(%ebp),%esp 10bb6c: 5b pop %ebx 10bb6d: 5e pop %esi 10bb6e: 5f pop %edi 10bb6f: c9 leave 10bb70: c3 ret 10bb71: 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 ) ) {
10bb74: 8b 15 18 b1 12 00 mov 0x12b118,%edx 10bb7a: 39 50 40 cmp %edx,0x40(%eax)
10bb7d: 74 15 je 10bb94 <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10bb7f: e8 e8 2b 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10bb84: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb89: 8d 65 f4 lea -0xc(%ebp),%esp 10bb8c: 5b pop %ebx 10bb8d: 5e pop %esi 10bb8e: 5f pop %edi 10bb8f: c9 leave 10bb90: c3 ret 10bb91: 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 ) {
10bb94: 85 f6 test %esi,%esi
10bb96: 75 1c jne 10bbb4 <rtems_rate_monotonic_period+0x78>
switch ( the_period->state ) {
10bb98: 8b 40 38 mov 0x38(%eax),%eax 10bb9b: 83 f8 04 cmp $0x4,%eax
10bb9e: 77 6c ja 10bc0c <rtems_rate_monotonic_period+0xd0><== NEVER TAKEN
10bba0: 8b 04 85 bc 37 12 00 mov 0x1237bc(,%eax,4),%eax
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10bba7: 89 45 d4 mov %eax,-0x2c(%ebp) 10bbaa: e8 bd 2b 00 00 call 10e76c <_Thread_Enable_dispatch>
return( return_value );
10bbaf: 8b 45 d4 mov -0x2c(%ebp),%eax 10bbb2: eb b5 jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
}
_ISR_Disable( level );
10bbb4: 9c pushf 10bbb5: fa cli 10bbb6: 5f pop %edi
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10bbb7: 8b 50 38 mov 0x38(%eax),%edx 10bbba: 85 d2 test %edx,%edx
10bbbc: 74 52 je 10bc10 <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 ) {
10bbbe: 83 fa 02 cmp $0x2,%edx
10bbc1: 0f 84 9e 00 00 00 je 10bc65 <rtems_rate_monotonic_period+0x129>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10bbc7: 83 fa 04 cmp $0x4,%edx
10bbca: 75 98 jne 10bb64 <rtems_rate_monotonic_period+0x28><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10bbcc: 83 ec 0c sub $0xc,%esp 10bbcf: 50 push %eax 10bbd0: 89 45 d4 mov %eax,-0x2c(%ebp) 10bbd3: e8 74 fe ff ff call 10ba4c <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10bbd8: 57 push %edi 10bbd9: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10bbda: 8b 45 d4 mov -0x2c(%ebp),%eax 10bbdd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
the_period->next_length = length;
10bbe4: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10bbe7: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10bbea: 5b pop %ebx 10bbeb: 5e pop %esi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10bbec: 83 c0 10 add $0x10,%eax 10bbef: 50 push %eax 10bbf0: 68 40 ac 12 00 push $0x12ac40 10bbf5: e8 a6 39 00 00 call 10f5a0 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10bbfa: e8 6d 2b 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10bbff: 83 c4 10 add $0x10,%esp 10bc02: b8 06 00 00 00 mov $0x6,%eax 10bc07: e9 5d ff ff ff jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10bc0c: 31 c0 xor %eax,%eax
10bc0e: eb 97 jmp 10bba7 <rtems_rate_monotonic_period+0x6b><== NOT EXECUTED
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
10bc10: 57 push %edi 10bc11: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10bc12: 83 ec 0c sub $0xc,%esp 10bc15: 50 push %eax 10bc16: 89 45 d4 mov %eax,-0x2c(%ebp) 10bc19: e8 ba fd ff ff call 10b9d8 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10bc1e: 8b 45 d4 mov -0x2c(%ebp),%eax 10bc21: 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;
10bc28: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10bc2f: c7 40 2c 94 bf 10 00 movl $0x10bf94,0x2c(%eax)
the_watchdog->id = id;
10bc36: 89 58 30 mov %ebx,0x30(%eax)
the_watchdog->user_data = user_data;
10bc39: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10bc40: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10bc43: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10bc46: 5e pop %esi 10bc47: 5f pop %edi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10bc48: 83 c0 10 add $0x10,%eax 10bc4b: 50 push %eax 10bc4c: 68 40 ac 12 00 push $0x12ac40 10bc51: e8 4a 39 00 00 call 10f5a0 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10bc56: e8 11 2b 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bc5b: 83 c4 10 add $0x10,%esp 10bc5e: 31 c0 xor %eax,%eax 10bc60: e9 04 ff ff ff jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10bc65: 83 ec 0c sub $0xc,%esp 10bc68: 50 push %eax 10bc69: 89 45 d4 mov %eax,-0x2c(%ebp) 10bc6c: e8 db fd ff ff call 10ba4c <_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;
10bc71: 8b 45 d4 mov -0x2c(%ebp),%eax 10bc74: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
the_period->next_length = length;
10bc7b: 89 70 3c mov %esi,0x3c(%eax)
_ISR_Enable( level );
10bc7e: 57 push %edi 10bc7f: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10bc80: 8b 15 18 b1 12 00 mov 0x12b118,%edx 10bc86: 8b 48 08 mov 0x8(%eax),%ecx 10bc89: 89 4a 20 mov %ecx,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10bc8c: 59 pop %ecx 10bc8d: 5b pop %ebx 10bc8e: 68 00 40 00 00 push $0x4000 10bc93: 52 push %edx 10bc94: 89 45 d4 mov %eax,-0x2c(%ebp) 10bc97: e8 f4 32 00 00 call 10ef90 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10bc9c: 9c pushf 10bc9d: fa cli 10bc9e: 59 pop %ecx
local_state = the_period->state;
10bc9f: 8b 45 d4 mov -0x2c(%ebp),%eax 10bca2: 8b 50 38 mov 0x38(%eax),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10bca5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
_ISR_Enable( level );
10bcac: 51 push %ecx 10bcad: 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 )
10bcae: 83 c4 10 add $0x10,%esp 10bcb1: 83 fa 03 cmp $0x3,%edx
10bcb4: 74 0c je 10bcc2 <rtems_rate_monotonic_period+0x186>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
10bcb6: e8 b1 2a 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bcbb: 31 c0 xor %eax,%eax 10bcbd: e9 a7 fe ff ff jmp 10bb69 <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 );
10bcc2: 57 push %edi 10bcc3: 57 push %edi 10bcc4: 68 00 40 00 00 push $0x4000 10bcc9: ff 35 18 b1 12 00 pushl 0x12b118 10bccf: e8 34 27 00 00 call 10e408 <_Thread_Clear_state> 10bcd4: 83 c4 10 add $0x10,%esp 10bcd7: eb dd jmp 10bcb6 <rtems_rate_monotonic_period+0x17a>
0010bcdc <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10bcdc: 55 push %ebp 10bcdd: 89 e5 mov %esp,%ebp 10bcdf: 57 push %edi 10bce0: 56 push %esi 10bce1: 53 push %ebx 10bce2: 81 ec 8c 00 00 00 sub $0x8c,%esp 10bce8: 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 )
10bceb: 8b 7d 0c mov 0xc(%ebp),%edi 10bcee: 85 ff test %edi,%edi
10bcf0: 0f 84 be 00 00 00 je 10bdb4 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10bcf6: 83 ec 08 sub $0x8,%esp 10bcf9: 68 d0 37 12 00 push $0x1237d0 10bcfe: 56 push %esi 10bcff: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10bd02: 59 pop %ecx 10bd03: 5b pop %ebx 10bd04: 68 08 38 12 00 push $0x123808 10bd09: 56 push %esi 10bd0a: ff 55 0c call *0xc(%ebp)
(*print)( context, "--- Wall times are in seconds ---\n" );
10bd0d: 58 pop %eax 10bd0e: 5a pop %edx 10bd0f: 68 2c 38 12 00 push $0x12382c 10bd14: 56 push %esi 10bd15: ff 55 0c call *0xc(%ebp)
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
10bd18: 5b pop %ebx 10bd19: 5f pop %edi 10bd1a: 68 50 38 12 00 push $0x123850 10bd1f: 56 push %esi 10bd20: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10bd23: 5a pop %edx 10bd24: 59 pop %ecx 10bd25: 68 9c 38 12 00 push $0x12389c 10bd2a: 56 push %esi 10bd2b: 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 ;
10bd2e: 8b 1d 88 aa 12 00 mov 0x12aa88,%ebx 10bd34: 83 c4 10 add $0x10,%esp 10bd37: 3b 1d 8c aa 12 00 cmp 0x12aa8c,%ebx
10bd3d: 77 75 ja 10bdb4 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
10bd3f: 8d 7d 88 lea -0x78(%ebp),%edi 10bd42: eb 09 jmp 10bd4d <rtems_rate_monotonic_report_statistics_with_plugin+0x71>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10bd44: 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 ;
10bd45: 39 1d 8c aa 12 00 cmp %ebx,0x12aa8c
10bd4b: 72 67 jb 10bdb4 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10bd4d: 83 ec 08 sub $0x8,%esp 10bd50: 57 push %edi 10bd51: 53 push %ebx 10bd52: e8 11 63 00 00 call 112068 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10bd57: 83 c4 10 add $0x10,%esp 10bd5a: 85 c0 test %eax,%eax
10bd5c: 75 e6 jne 10bd44 <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 );
10bd5e: 83 ec 08 sub $0x8,%esp 10bd61: 8d 45 c0 lea -0x40(%ebp),%eax 10bd64: 50 push %eax 10bd65: 53 push %ebx 10bd66: e8 a9 63 00 00 call 112114 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10bd6b: 83 c4 0c add $0xc,%esp 10bd6e: 8d 55 e3 lea -0x1d(%ebp),%edx 10bd71: 52 push %edx 10bd72: 6a 05 push $0x5 10bd74: ff 75 c0 pushl -0x40(%ebp) 10bd77: e8 b4 02 00 00 call 10c030 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10bd7c: 59 pop %ecx 10bd7d: 58 pop %eax 10bd7e: ff 75 8c pushl -0x74(%ebp) 10bd81: ff 75 88 pushl -0x78(%ebp) 10bd84: 8d 45 e3 lea -0x1d(%ebp),%eax 10bd87: 50 push %eax 10bd88: 53 push %ebx 10bd89: 68 ee 37 12 00 push $0x1237ee 10bd8e: 56 push %esi 10bd8f: ff 55 0c call *0xc(%ebp)
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10bd92: 8b 45 88 mov -0x78(%ebp),%eax 10bd95: 83 c4 20 add $0x20,%esp 10bd98: 85 c0 test %eax,%eax
10bd9a: 75 20 jne 10bdbc <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
(*print)( context, "\n" );
10bd9c: 83 ec 08 sub $0x8,%esp 10bd9f: 68 f1 19 12 00 push $0x1219f1 10bda4: 56 push %esi 10bda5: ff 55 0c call *0xc(%ebp)
continue;
10bda8: 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++ ) {
10bdab: 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 ;
10bdac: 39 1d 8c aa 12 00 cmp %ebx,0x12aa8c
10bdb2: 73 99 jae 10bd4d <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
}
}
}
10bdb4: 8d 65 f4 lea -0xc(%ebp),%esp 10bdb7: 5b pop %ebx 10bdb8: 5e pop %esi 10bdb9: 5f pop %edi 10bdba: c9 leave 10bdbb: 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 );
10bdbc: 52 push %edx 10bdbd: 8d 55 d8 lea -0x28(%ebp),%edx 10bdc0: 52 push %edx 10bdc1: 50 push %eax 10bdc2: 8d 45 a0 lea -0x60(%ebp),%eax 10bdc5: 50 push %eax 10bdc6: e8 35 34 00 00 call 10f200 <_Timespec_Divide_by_integer>
(*print)( context,
10bdcb: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 10bdd0: 8b 45 dc mov -0x24(%ebp),%eax 10bdd3: f7 e9 imul %ecx 10bdd5: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10bddb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10bde1: c1 f8 06 sar $0x6,%eax 10bde4: 8b 55 dc mov -0x24(%ebp),%edx 10bde7: c1 fa 1f sar $0x1f,%edx 10bdea: 29 d0 sub %edx,%eax 10bdec: 50 push %eax 10bded: ff 75 d8 pushl -0x28(%ebp) 10bdf0: 8b 45 9c mov -0x64(%ebp),%eax 10bdf3: f7 e9 imul %ecx 10bdf5: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10bdfb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be01: c1 f8 06 sar $0x6,%eax 10be04: 8b 55 9c mov -0x64(%ebp),%edx 10be07: c1 fa 1f sar $0x1f,%edx 10be0a: 29 d0 sub %edx,%eax 10be0c: 50 push %eax 10be0d: ff 75 98 pushl -0x68(%ebp) 10be10: 8b 45 94 mov -0x6c(%ebp),%eax 10be13: f7 e9 imul %ecx 10be15: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10be1b: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10be21: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be27: c1 f8 06 sar $0x6,%eax 10be2a: 8b 55 94 mov -0x6c(%ebp),%edx 10be2d: c1 fa 1f sar $0x1f,%edx 10be30: 29 d0 sub %edx,%eax 10be32: 50 push %eax 10be33: ff 75 90 pushl -0x70(%ebp) 10be36: 68 e8 38 12 00 push $0x1238e8 10be3b: 56 push %esi 10be3c: 89 4d 84 mov %ecx,-0x7c(%ebp) 10be3f: 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);
10be42: 83 c4 2c add $0x2c,%esp 10be45: 8d 55 d8 lea -0x28(%ebp),%edx 10be48: 52 push %edx 10be49: ff 75 88 pushl -0x78(%ebp) 10be4c: 8d 45 b8 lea -0x48(%ebp),%eax 10be4f: 50 push %eax 10be50: e8 ab 33 00 00 call 10f200 <_Timespec_Divide_by_integer>
(*print)( context,
10be55: 8b 4d 84 mov -0x7c(%ebp),%ecx 10be58: 8b 45 dc mov -0x24(%ebp),%eax 10be5b: f7 e9 imul %ecx 10be5d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10be63: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be69: c1 f8 06 sar $0x6,%eax 10be6c: 8b 55 dc mov -0x24(%ebp),%edx 10be6f: c1 fa 1f sar $0x1f,%edx 10be72: 29 d0 sub %edx,%eax 10be74: 50 push %eax 10be75: ff 75 d8 pushl -0x28(%ebp) 10be78: 8b 45 b4 mov -0x4c(%ebp),%eax 10be7b: f7 e9 imul %ecx 10be7d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10be83: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be89: c1 f8 06 sar $0x6,%eax 10be8c: 8b 55 b4 mov -0x4c(%ebp),%edx 10be8f: c1 fa 1f sar $0x1f,%edx 10be92: 29 d0 sub %edx,%eax 10be94: 50 push %eax 10be95: ff 75 b0 pushl -0x50(%ebp) 10be98: 8b 45 ac mov -0x54(%ebp),%eax 10be9b: f7 e9 imul %ecx 10be9d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10bea3: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10bea9: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10beaf: c1 f8 06 sar $0x6,%eax 10beb2: 8b 55 ac mov -0x54(%ebp),%edx 10beb5: c1 fa 1f sar $0x1f,%edx 10beb8: 29 d0 sub %edx,%eax 10beba: 50 push %eax 10bebb: ff 75 a8 pushl -0x58(%ebp) 10bebe: 68 08 39 12 00 push $0x123908 10bec3: 56 push %esi 10bec4: ff 55 0c call *0xc(%ebp) 10bec7: 83 c4 30 add $0x30,%esp 10beca: e9 75 fe ff ff jmp 10bd44 <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
0010bee8 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
10bee8: 55 push %ebp 10bee9: 89 e5 mov %esp,%ebp 10beeb: 53 push %ebx 10beec: 83 ec 04 sub $0x4,%esp 10beef: a1 6c ab 12 00 mov 0x12ab6c,%eax 10bef4: 40 inc %eax 10bef5: a3 6c ab 12 00 mov %eax,0x12ab6c
/*
* 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 ;
10befa: 8b 1d 88 aa 12 00 mov 0x12aa88,%ebx 10bf00: 3b 1d 8c aa 12 00 cmp 0x12aa8c,%ebx
10bf06: 77 15 ja 10bf1d <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
10bf08: 83 ec 0c sub $0xc,%esp 10bf0b: 53 push %ebx 10bf0c: e8 17 00 00 00 call 10bf28 <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++ ) {
10bf11: 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 ;
10bf12: 83 c4 10 add $0x10,%esp 10bf15: 39 1d 8c aa 12 00 cmp %ebx,0x12aa8c
10bf1b: 73 eb jae 10bf08 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
10bf1d: 8b 5d fc mov -0x4(%ebp),%ebx 10bf20: c9 leave
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
10bf21: e9 46 28 00 00 jmp 10e76c <_Thread_Enable_dispatch>
0010bf28 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
10bf28: 55 push %ebp 10bf29: 89 e5 mov %esp,%ebp 10bf2b: 57 push %edi 10bf2c: 53 push %ebx 10bf2d: 83 ec 14 sub $0x14,%esp
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
10bf30: 8d 45 f4 lea -0xc(%ebp),%eax 10bf33: 50 push %eax 10bf34: ff 75 08 pushl 0x8(%ebp) 10bf37: 68 80 aa 12 00 push $0x12aa80 10bf3c: e8 a3 1c 00 00 call 10dbe4 <_Objects_Get> 10bf41: 89 c2 mov %eax,%edx
switch ( location ) {
10bf43: 83 c4 10 add $0x10,%esp 10bf46: 8b 45 f4 mov -0xc(%ebp),%eax 10bf49: 85 c0 test %eax,%eax
10bf4b: 75 3b jne 10bf88 <rtems_rate_monotonic_reset_statistics+0x60>
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
10bf4d: 8d 5a 54 lea 0x54(%edx),%ebx 10bf50: b9 38 00 00 00 mov $0x38,%ecx 10bf55: 31 c0 xor %eax,%eax 10bf57: 89 df mov %ebx,%edi 10bf59: f3 aa rep stos %al,%es:(%edi) 10bf5b: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10bf62: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10bf69: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10bf70: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
_Thread_Enable_dispatch();
10bf77: e8 f0 27 00 00 call 10e76c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bf7c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bf7e: 8d 65 f8 lea -0x8(%ebp),%esp 10bf81: 5b pop %ebx 10bf82: 5f pop %edi 10bf83: c9 leave 10bf84: c3 ret 10bf85: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bf88: b8 04 00 00 00 mov $0x4,%eax
}
10bf8d: 8d 65 f8 lea -0x8(%ebp),%esp 10bf90: 5b pop %ebx 10bf91: 5f pop %edi 10bf92: c9 leave 10bf93: c3 ret
00116874 <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
116874: 55 push %ebp 116875: 89 e5 mov %esp,%ebp 116877: 57 push %edi 116878: 56 push %esi 116879: 53 push %ebx 11687a: 83 ec 1c sub $0x1c,%esp 11687d: 8b 7d 08 mov 0x8(%ebp),%edi 116880: 8b 75 0c mov 0xc(%ebp),%esi
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
116883: 85 ff test %edi,%edi
116885: 0f 84 c1 00 00 00 je 11694c <rtems_region_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !starting_address )
11688b: 85 f6 test %esi,%esi
11688d: 0f 84 e1 00 00 00 je 116974 <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
if ( !id )
116893: 8b 45 1c mov 0x1c(%ebp),%eax 116896: 85 c0 test %eax,%eax
116898: 0f 84 d6 00 00 00 je 116974 <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
11689e: 83 ec 0c sub $0xc,%esp 1168a1: ff 35 60 21 14 00 pushl 0x142160 1168a7: e8 08 25 00 00 call 118db4 <_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 );
1168ac: c7 04 24 c0 1f 14 00 movl $0x141fc0,(%esp) 1168b3: e8 54 3b 00 00 call 11a40c <_Objects_Allocate> 1168b8: 89 c3 mov %eax,%ebx
the_region = _Region_Allocate();
if ( !the_region )
1168ba: 83 c4 10 add $0x10,%esp 1168bd: 85 c0 test %eax,%eax
1168bf: 0f 84 bf 00 00 00 je 116984 <rtems_region_create+0x110>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
1168c5: ff 75 14 pushl 0x14(%ebp) 1168c8: ff 75 10 pushl 0x10(%ebp) 1168cb: 56 push %esi 1168cc: 8d 40 68 lea 0x68(%eax),%eax 1168cf: 50 push %eax 1168d0: e8 43 37 00 00 call 11a018 <_Heap_Initialize> 1168d5: 89 43 5c mov %eax,0x5c(%ebx)
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
1168d8: 83 c4 10 add $0x10,%esp 1168db: 85 c0 test %eax,%eax
1168dd: 74 7d je 11695c <rtems_region_create+0xe8>
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
1168df: 89 73 50 mov %esi,0x50(%ebx)
the_region->length = length;
1168e2: 8b 45 10 mov 0x10(%ebp),%eax 1168e5: 89 43 54 mov %eax,0x54(%ebx)
the_region->page_size = page_size;
1168e8: 8b 55 14 mov 0x14(%ebp),%edx 1168eb: 89 53 58 mov %edx,0x58(%ebx)
the_region->attribute_set = attribute_set;
1168ee: 8b 45 18 mov 0x18(%ebp),%eax 1168f1: 89 43 60 mov %eax,0x60(%ebx)
the_region->number_of_used_blocks = 0;
1168f4: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
_Thread_queue_Initialize(
1168fb: 6a 06 push $0x6 1168fd: 6a 40 push $0x40 1168ff: a8 04 test $0x4,%al 116901: 0f 95 c0 setne %al 116904: 0f b6 c0 movzbl %al,%eax 116907: 50 push %eax 116908: 8d 43 10 lea 0x10(%ebx),%eax 11690b: 50 push %eax 11690c: e8 83 52 00 00 call 11bb94 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
116911: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
116914: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
116917: 8b 15 dc 1f 14 00 mov 0x141fdc,%edx 11691d: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
116920: 89 7b 0c mov %edi,0xc(%ebx)
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
116923: 8b 55 1c mov 0x1c(%ebp),%edx 116926: 89 02 mov %eax,(%edx) 116928: 83 c4 10 add $0x10,%esp
return_status = RTEMS_SUCCESSFUL;
11692b: 31 c0 xor %eax,%eax
}
}
_RTEMS_Unlock_allocator();
11692d: 83 ec 0c sub $0xc,%esp 116930: ff 35 60 21 14 00 pushl 0x142160 116936: 89 45 e4 mov %eax,-0x1c(%ebp) 116939: e8 be 24 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status;
11693e: 83 c4 10 add $0x10,%esp 116941: 8b 45 e4 mov -0x1c(%ebp),%eax
}
116944: 8d 65 f4 lea -0xc(%ebp),%esp 116947: 5b pop %ebx 116948: 5e pop %esi 116949: 5f pop %edi 11694a: c9 leave 11694b: c3 ret
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
11694c: b8 03 00 00 00 mov $0x3,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
116951: 8d 65 f4 lea -0xc(%ebp),%esp 116954: 5b pop %ebx 116955: 5e pop %esi 116956: 5f pop %edi 116957: c9 leave 116958: c3 ret 116959: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
11695c: 83 ec 08 sub $0x8,%esp 11695f: 53 push %ebx 116960: 68 c0 1f 14 00 push $0x141fc0 116965: e8 16 3e 00 00 call 11a780 <_Objects_Free> 11696a: 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;
11696d: b8 08 00 00 00 mov $0x8,%eax 116972: eb b9 jmp 11692d <rtems_region_create+0xb9>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
116974: b8 09 00 00 00 mov $0x9,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
116979: 8d 65 f4 lea -0xc(%ebp),%esp 11697c: 5b pop %ebx 11697d: 5e pop %esi 11697e: 5f pop %edi 11697f: c9 leave 116980: c3 ret 116981: 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;
116984: b8 05 00 00 00 mov $0x5,%eax 116989: eb a2 jmp 11692d <rtems_region_create+0xb9>
0011698c <rtems_region_delete>:
*/
rtems_status_code rtems_region_delete(
rtems_id id
)
{
11698c: 55 push %ebp 11698d: 89 e5 mov %esp,%ebp 11698f: 53 push %ebx 116990: 83 ec 30 sub $0x30,%esp
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
_RTEMS_Lock_allocator();
116993: ff 35 60 21 14 00 pushl 0x142160 116999: e8 16 24 00 00 call 118db4 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
11699e: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1169a1: 8d 45 f4 lea -0xc(%ebp),%eax 1169a4: 50 push %eax 1169a5: ff 75 08 pushl 0x8(%ebp) 1169a8: 68 c0 1f 14 00 push $0x141fc0 1169ad: e8 0e 3f 00 00 call 11a8c0 <_Objects_Get_no_protection>
switch ( location ) {
1169b2: 83 c4 10 add $0x10,%esp 1169b5: 8b 5d f4 mov -0xc(%ebp),%ebx 1169b8: 85 db test %ebx,%ebx
1169ba: 74 1c je 1169d8 <rtems_region_delete+0x4c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
1169bc: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
1169c1: 83 ec 0c sub $0xc,%esp 1169c4: ff 35 60 21 14 00 pushl 0x142160 1169ca: e8 2d 24 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status; }
1169cf: 89 d8 mov %ebx,%eax 1169d1: 8b 5d fc mov -0x4(%ebp),%ebx 1169d4: c9 leave 1169d5: c3 ret 1169d6: 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 )
1169d8: 8b 48 64 mov 0x64(%eax),%ecx 1169db: 85 c9 test %ecx,%ecx
1169dd: 74 09 je 1169e8 <rtems_region_delete+0x5c>
return_status = RTEMS_RESOURCE_IN_USE;
1169df: bb 0c 00 00 00 mov $0xc,%ebx 1169e4: eb db jmp 1169c1 <rtems_region_delete+0x35> 1169e6: 66 90 xchg %ax,%ax
else {
_Objects_Close( &_Region_Information, &the_region->Object );
1169e8: 83 ec 08 sub $0x8,%esp 1169eb: 50 push %eax 1169ec: 68 c0 1f 14 00 push $0x141fc0 1169f1: 89 45 e4 mov %eax,-0x1c(%ebp) 1169f4: e8 8f 3a 00 00 call 11a488 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
1169f9: 58 pop %eax 1169fa: 5a pop %edx 1169fb: 8b 45 e4 mov -0x1c(%ebp),%eax 1169fe: 50 push %eax 1169ff: 68 c0 1f 14 00 push $0x141fc0 116a04: e8 77 3d 00 00 call 11a780 <_Objects_Free> 116a09: 83 c4 10 add $0x10,%esp
_Region_Free( the_region );
return_status = RTEMS_SUCCESSFUL;
116a0c: 31 db xor %ebx,%ebx 116a0e: eb b1 jmp 1169c1 <rtems_region_delete+0x35>
00116a10 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
116a10: 55 push %ebp 116a11: 89 e5 mov %esp,%ebp 116a13: 56 push %esi 116a14: 53 push %ebx 116a15: 83 ec 10 sub $0x10,%esp 116a18: 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 )
116a1b: 85 db test %ebx,%ebx
116a1d: 74 75 je 116a94 <rtems_region_extend+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
116a1f: 83 ec 0c sub $0xc,%esp 116a22: ff 35 60 21 14 00 pushl 0x142160 116a28: e8 87 23 00 00 call 118db4 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
116a2d: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116a30: 8d 45 f0 lea -0x10(%ebp),%eax 116a33: 50 push %eax 116a34: ff 75 08 pushl 0x8(%ebp) 116a37: 68 c0 1f 14 00 push $0x141fc0 116a3c: e8 7f 3e 00 00 call 11a8c0 <_Objects_Get_no_protection> 116a41: 89 c6 mov %eax,%esi
switch ( location ) {
116a43: 83 c4 10 add $0x10,%esp 116a46: 8b 45 f0 mov -0x10(%ebp),%eax 116a49: 85 c0 test %eax,%eax
116a4b: 74 1f je 116a6c <rtems_region_extend+0x5c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116a4d: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
116a52: 83 ec 0c sub $0xc,%esp 116a55: ff 35 60 21 14 00 pushl 0x142160 116a5b: e8 9c 23 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status;
116a60: 83 c4 10 add $0x10,%esp
}
116a63: 89 d8 mov %ebx,%eax 116a65: 8d 65 f8 lea -0x8(%ebp),%esp 116a68: 5b pop %ebx 116a69: 5e pop %esi 116a6a: c9 leave 116a6b: c3 ret
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
116a6c: 8d 45 f4 lea -0xc(%ebp),%eax 116a6f: 50 push %eax 116a70: ff 75 10 pushl 0x10(%ebp) 116a73: 53 push %ebx 116a74: 8d 46 68 lea 0x68(%esi),%eax 116a77: 50 push %eax 116a78: e8 7b 2f 00 00 call 1199f8 <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
116a7d: 83 c4 10 add $0x10,%esp 116a80: 84 c0 test %al,%al
116a82: 74 20 je 116aa4 <rtems_region_extend+0x94>
the_region->length += amount_extended;
116a84: 8b 45 f4 mov -0xc(%ebp),%eax 116a87: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
116a8a: 01 46 5c add %eax,0x5c(%esi)
return_status = RTEMS_SUCCESSFUL;
116a8d: 31 db xor %ebx,%ebx 116a8f: eb c1 jmp 116a52 <rtems_region_extend+0x42> 116a91: 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;
116a94: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116a99: 89 d8 mov %ebx,%eax 116a9b: 8d 65 f8 lea -0x8(%ebp),%esp 116a9e: 5b pop %ebx 116a9f: 5e pop %esi 116aa0: c9 leave 116aa1: c3 ret 116aa2: 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;
116aa4: bb 09 00 00 00 mov $0x9,%ebx 116aa9: eb a7 jmp 116a52 <rtems_region_extend+0x42>
00116aac <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
116aac: 55 push %ebp 116aad: 89 e5 mov %esp,%ebp 116aaf: 53 push %ebx 116ab0: 83 ec 14 sub $0x14,%esp 116ab3: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
116ab6: 85 db test %ebx,%ebx
116ab8: 74 76 je 116b30 <rtems_region_get_free_information+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
116aba: 83 ec 0c sub $0xc,%esp 116abd: ff 35 60 21 14 00 pushl 0x142160 116ac3: e8 ec 22 00 00 call 118db4 <_API_Mutex_Lock> 116ac8: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116acb: 8d 45 f4 lea -0xc(%ebp),%eax 116ace: 50 push %eax 116acf: ff 75 08 pushl 0x8(%ebp) 116ad2: 68 c0 1f 14 00 push $0x141fc0 116ad7: e8 e4 3d 00 00 call 11a8c0 <_Objects_Get_no_protection>
switch ( location ) {
116adc: 83 c4 10 add $0x10,%esp 116adf: 8b 55 f4 mov -0xc(%ebp),%edx 116ae2: 85 d2 test %edx,%edx
116ae4: 74 1e je 116b04 <rtems_region_get_free_information+0x58>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116ae6: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
116aeb: 83 ec 0c sub $0xc,%esp 116aee: ff 35 60 21 14 00 pushl 0x142160 116af4: e8 03 23 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status;
116af9: 83 c4 10 add $0x10,%esp
}
116afc: 89 d8 mov %ebx,%eax 116afe: 8b 5d fc mov -0x4(%ebp),%ebx 116b01: c9 leave 116b02: c3 ret 116b03: 90 nop
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
116b04: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_info->Used.total = 0;
116b0b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
the_info->Used.largest = 0;
116b12: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
116b19: 83 ec 08 sub $0x8,%esp 116b1c: 53 push %ebx 116b1d: 83 c0 68 add $0x68,%eax 116b20: 50 push %eax 116b21: e8 ce 32 00 00 call 119df4 <_Heap_Get_free_information>
return_status = RTEMS_SUCCESSFUL;
break;
116b26: 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;
116b29: 31 db xor %ebx,%ebx
break;
116b2b: eb be jmp 116aeb <rtems_region_get_free_information+0x3f> 116b2d: 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;
116b30: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116b35: 89 d8 mov %ebx,%eax 116b37: 8b 5d fc mov -0x4(%ebp),%ebx 116b3a: c9 leave 116b3b: c3 ret
00116bb4 <rtems_region_get_segment>:
uintptr_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
116bb4: 55 push %ebp 116bb5: 89 e5 mov %esp,%ebp 116bb7: 57 push %edi 116bb8: 56 push %esi 116bb9: 53 push %ebx 116bba: 83 ec 2c sub $0x2c,%esp 116bbd: 8b 75 0c mov 0xc(%ebp),%esi 116bc0: 8b 5d 18 mov 0x18(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
116bc3: 85 db test %ebx,%ebx
116bc5: 0f 84 a1 00 00 00 je 116c6c <rtems_region_get_segment+0xb8>
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
116bcb: c7 03 00 00 00 00 movl $0x0,(%ebx)
if ( size == 0 )
116bd1: 85 f6 test %esi,%esi
116bd3: 75 0f jne 116be4 <rtems_region_get_segment+0x30>
return RTEMS_INVALID_SIZE;
116bd5: b8 08 00 00 00 mov $0x8,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116bda: 8d 65 f4 lea -0xc(%ebp),%esp 116bdd: 5b pop %ebx 116bde: 5e pop %esi 116bdf: 5f pop %edi 116be0: c9 leave 116be1: c3 ret 116be2: 66 90 xchg %ax,%ax
*segment = NULL;
if ( size == 0 )
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
116be4: 83 ec 0c sub $0xc,%esp 116be7: ff 35 60 21 14 00 pushl 0x142160 116bed: e8 c2 21 00 00 call 118db4 <_API_Mutex_Lock>
executing = _Thread_Executing;
116bf2: a1 58 26 14 00 mov 0x142658,%eax 116bf7: 89 45 d4 mov %eax,-0x2c(%ebp) 116bfa: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116bfd: 8d 45 e4 lea -0x1c(%ebp),%eax 116c00: 50 push %eax 116c01: ff 75 08 pushl 0x8(%ebp) 116c04: 68 c0 1f 14 00 push $0x141fc0 116c09: e8 b2 3c 00 00 call 11a8c0 <_Objects_Get_no_protection> 116c0e: 89 c7 mov %eax,%edi
switch ( location ) {
116c10: 83 c4 10 add $0x10,%esp 116c13: 8b 45 e4 mov -0x1c(%ebp),%eax 116c16: 85 c0 test %eax,%eax
116c18: 75 2a jne 116c44 <rtems_region_get_segment+0x90>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
116c1a: 3b 77 5c cmp 0x5c(%edi),%esi
116c1d: 76 2d jbe 116c4c <rtems_region_get_segment+0x98>
return_status = RTEMS_INVALID_SIZE;
116c1f: b8 08 00 00 00 mov $0x8,%eax
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
116c24: 83 ec 0c sub $0xc,%esp 116c27: ff 35 60 21 14 00 pushl 0x142160 116c2d: 89 45 d0 mov %eax,-0x30(%ebp) 116c30: e8 c7 21 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status;
116c35: 83 c4 10 add $0x10,%esp 116c38: 8b 45 d0 mov -0x30(%ebp),%eax
}
116c3b: 8d 65 f4 lea -0xc(%ebp),%esp 116c3e: 5b pop %ebx 116c3f: 5e pop %esi 116c40: 5f pop %edi 116c41: c9 leave 116c42: c3 ret 116c43: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116c44: b8 04 00 00 00 mov $0x4,%eax 116c49: eb d9 jmp 116c24 <rtems_region_get_segment+0x70> 116c4b: 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 );
116c4c: 6a 00 push $0x0 116c4e: 6a 00 push $0x0 116c50: 56 push %esi
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
116c51: 8d 47 68 lea 0x68(%edi),%eax 116c54: 50 push %eax 116c55: e8 ca 2b 00 00 call 119824 <_Heap_Allocate_aligned_with_boundary>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
116c5a: 83 c4 10 add $0x10,%esp 116c5d: 85 c0 test %eax,%eax
116c5f: 74 17 je 116c78 <rtems_region_get_segment+0xc4>
the_region->number_of_used_blocks += 1;
116c61: ff 47 64 incl 0x64(%edi)
*segment = the_segment;
116c64: 89 03 mov %eax,(%ebx)
return_status = RTEMS_SUCCESSFUL;
116c66: 31 c0 xor %eax,%eax 116c68: eb ba jmp 116c24 <rtems_region_get_segment+0x70> 116c6a: 66 90 xchg %ax,%ax
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
return RTEMS_INVALID_ADDRESS;
116c6c: b8 09 00 00 00 mov $0x9,%eax 116c71: e9 64 ff ff ff jmp 116bda <rtems_region_get_segment+0x26> 116c76: 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 ) ) {
116c78: f6 45 10 01 testb $0x1,0x10(%ebp)
116c7c: 74 07 je 116c85 <rtems_region_get_segment+0xd1>
return_status = RTEMS_UNSATISFIED;
116c7e: b8 0d 00 00 00 mov $0xd,%eax 116c83: eb 9f jmp 116c24 <rtems_region_get_segment+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
116c85: a1 ac 20 14 00 mov 0x1420ac,%eax 116c8a: 40 inc %eax 116c8b: a3 ac 20 14 00 mov %eax,0x1420ac
* 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();
116c90: 83 ec 0c sub $0xc,%esp 116c93: ff 35 60 21 14 00 pushl 0x142160 116c99: e8 5e 21 00 00 call 118dfc <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
116c9e: 8d 47 10 lea 0x10(%edi),%eax 116ca1: 8b 55 d4 mov -0x2c(%ebp),%edx 116ca4: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
116ca7: 8b 4d 08 mov 0x8(%ebp),%ecx 116caa: 89 4a 20 mov %ecx,0x20(%edx)
executing->Wait.count = size;
116cad: 89 72 24 mov %esi,0x24(%edx)
executing->Wait.return_argument = segment;
116cb0: 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;
116cb3: 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 );
116cba: 83 c4 0c add $0xc,%esp 116cbd: 68 58 bc 11 00 push $0x11bc58 116cc2: ff 75 14 pushl 0x14(%ebp) 116cc5: 50 push %eax 116cc6: e8 61 4c 00 00 call 11b92c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
116ccb: e8 b4 47 00 00 call 11b484 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
116cd0: 8b 55 d4 mov -0x2c(%ebp),%edx 116cd3: 8b 42 34 mov 0x34(%edx),%eax 116cd6: 83 c4 10 add $0x10,%esp 116cd9: e9 fc fe ff ff jmp 116bda <rtems_region_get_segment+0x26>
00116d94 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
116d94: 55 push %ebp 116d95: 89 e5 mov %esp,%ebp 116d97: 56 push %esi 116d98: 53 push %ebx 116d99: 83 ec 20 sub $0x20,%esp 116d9c: 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 )
116d9f: 85 db test %ebx,%ebx
116da1: 0f 84 89 00 00 00 je 116e30 <rtems_region_resize_segment+0x9c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
116da7: 83 ec 0c sub $0xc,%esp 116daa: ff 35 60 21 14 00 pushl 0x142160 116db0: e8 ff 1f 00 00 call 118db4 <_API_Mutex_Lock> 116db5: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116db8: 8d 45 f0 lea -0x10(%ebp),%eax 116dbb: 50 push %eax 116dbc: ff 75 08 pushl 0x8(%ebp) 116dbf: 68 c0 1f 14 00 push $0x141fc0 116dc4: e8 f7 3a 00 00 call 11a8c0 <_Objects_Get_no_protection> 116dc9: 89 c6 mov %eax,%esi
switch ( location ) {
116dcb: 83 c4 10 add $0x10,%esp 116dce: 8b 45 f0 mov -0x10(%ebp),%eax 116dd1: 85 c0 test %eax,%eax
116dd3: 74 1f je 116df4 <rtems_region_resize_segment+0x60>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
116dd5: 83 ec 0c sub $0xc,%esp 116dd8: ff 35 60 21 14 00 pushl 0x142160 116dde: e8 19 20 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status;
116de3: 83 c4 10 add $0x10,%esp 116de6: b8 04 00 00 00 mov $0x4,%eax
}
116deb: 8d 65 f8 lea -0x8(%ebp),%esp 116dee: 5b pop %ebx 116def: 5e pop %esi 116df0: c9 leave 116df1: c3 ret 116df2: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
116df4: 83 ec 0c sub $0xc,%esp 116df7: 8d 45 f4 lea -0xc(%ebp),%eax 116dfa: 50 push %eax 116dfb: 8d 45 ec lea -0x14(%ebp),%eax 116dfe: 50 push %eax 116dff: ff 75 10 pushl 0x10(%ebp) 116e02: ff 75 0c pushl 0xc(%ebp) 116e05: 8d 46 68 lea 0x68(%esi),%eax 116e08: 50 push %eax 116e09: e8 12 34 00 00 call 11a220 <_Heap_Resize_block>
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
116e0e: 8b 55 ec mov -0x14(%ebp),%edx 116e11: 89 13 mov %edx,(%ebx)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
116e13: 83 c4 20 add $0x20,%esp 116e16: 85 c0 test %eax,%eax
116e18: 75 22 jne 116e3c <rtems_region_resize_segment+0xa8>
_Region_Process_queue( the_region ); /* unlocks allocator */
116e1a: 83 ec 0c sub $0xc,%esp 116e1d: 56 push %esi 116e1e: e8 7d 7e 00 00 call 11eca0 <_Region_Process_queue> 116e23: 83 c4 10 add $0x10,%esp
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
116e26: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116e28: 8d 65 f8 lea -0x8(%ebp),%esp 116e2b: 5b pop %ebx 116e2c: 5e pop %esi 116e2d: c9 leave 116e2e: c3 ret 116e2f: 90 nop
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
116e30: b8 09 00 00 00 mov $0x9,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116e35: 8d 65 f8 lea -0x8(%ebp),%esp 116e38: 5b pop %ebx 116e39: 5e pop %esi 116e3a: c9 leave 116e3b: c3 ret
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
116e3c: 83 ec 0c sub $0xc,%esp 116e3f: ff 35 60 21 14 00 pushl 0x142160 116e45: 89 45 e4 mov %eax,-0x1c(%ebp) 116e48: e8 af 1f 00 00 call 118dfc <_API_Mutex_Unlock>
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
116e4d: 83 c4 10 add $0x10,%esp
return RTEMS_UNSATISFIED;
116e50: 8b 45 e4 mov -0x1c(%ebp),%eax 116e53: 48 dec %eax 116e54: 0f 94 c0 sete %al 116e57: 0f b6 c0 movzbl %al,%eax 116e5a: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116e61: 8d 65 f8 lea -0x8(%ebp),%esp 116e64: 5b pop %ebx 116e65: 5e pop %esi 116e66: c9 leave 116e67: c3 ret
00116e68 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
116e68: 55 push %ebp 116e69: 89 e5 mov %esp,%ebp 116e6b: 53 push %ebx 116e6c: 83 ec 20 sub $0x20,%esp
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
116e6f: ff 35 60 21 14 00 pushl 0x142160 116e75: e8 3a 1f 00 00 call 118db4 <_API_Mutex_Lock> 116e7a: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116e7d: 8d 45 f4 lea -0xc(%ebp),%eax 116e80: 50 push %eax 116e81: ff 75 08 pushl 0x8(%ebp) 116e84: 68 c0 1f 14 00 push $0x141fc0 116e89: e8 32 3a 00 00 call 11a8c0 <_Objects_Get_no_protection> 116e8e: 89 c3 mov %eax,%ebx
switch ( location ) {
116e90: 83 c4 10 add $0x10,%esp 116e93: 8b 45 f4 mov -0xc(%ebp),%eax 116e96: 85 c0 test %eax,%eax
116e98: 75 1e jne 116eb8 <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 );
116e9a: 83 ec 08 sub $0x8,%esp 116e9d: ff 75 0c pushl 0xc(%ebp) 116ea0: 8d 43 68 lea 0x68(%ebx),%eax 116ea3: 50 push %eax 116ea4: e8 e7 2d 00 00 call 119c90 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
116ea9: 83 c4 10 add $0x10,%esp 116eac: 84 c0 test %al,%al
116eae: 75 28 jne 116ed8 <rtems_region_return_segment+0x70>
return_status = RTEMS_INVALID_ADDRESS;
116eb0: bb 09 00 00 00 mov $0x9,%ebx 116eb5: eb 06 jmp 116ebd <rtems_region_return_segment+0x55> 116eb7: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116eb8: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
116ebd: 83 ec 0c sub $0xc,%esp 116ec0: ff 35 60 21 14 00 pushl 0x142160 116ec6: e8 31 1f 00 00 call 118dfc <_API_Mutex_Unlock>
return return_status;
116ecb: 83 c4 10 add $0x10,%esp
}
116ece: 89 d8 mov %ebx,%eax 116ed0: 8b 5d fc mov -0x4(%ebp),%ebx 116ed3: c9 leave 116ed4: c3 ret 116ed5: 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;
116ed8: ff 4b 64 decl 0x64(%ebx)
_Region_Process_queue(the_region); /* unlocks allocator */
116edb: 83 ec 0c sub $0xc,%esp 116ede: 53 push %ebx 116edf: e8 bc 7d 00 00 call 11eca0 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
116ee4: 83 c4 10 add $0x10,%esp 116ee7: 31 db xor %ebx,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116ee9: 89 d8 mov %ebx,%eax 116eeb: 8b 5d fc mov -0x4(%ebp),%ebx 116eee: c9 leave 116eef: c3 ret
0010a92c <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
10a92c: 55 push %ebp 10a92d: 89 e5 mov %esp,%ebp 10a92f: 57 push %edi 10a930: 56 push %esi 10a931: 53 push %ebx 10a932: 83 ec 3c sub $0x3c,%esp 10a935: 8b 75 08 mov 0x8(%ebp),%esi 10a938: 8b 5d 10 mov 0x10(%ebp),%ebx 10a93b: 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 ) )
10a93e: 85 f6 test %esi,%esi
10a940: 74 4a je 10a98c <rtems_semaphore_create+0x60>
return RTEMS_INVALID_NAME;
if ( !id )
10a942: 85 ff test %edi,%edi
10a944: 0f 84 f6 00 00 00 je 10aa40 <rtems_semaphore_create+0x114><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10a94a: 89 da mov %ebx,%edx 10a94c: 81 e2 c0 00 00 00 and $0xc0,%edx
10a952: 74 48 je 10a99c <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);
10a954: 89 d8 mov %ebx,%eax 10a956: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10a959: 83 f8 10 cmp $0x10,%eax
10a95c: 74 0e je 10a96c <rtems_semaphore_create+0x40>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
10a95e: b8 0b 00 00 00 mov $0xb,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a963: 8d 65 f4 lea -0xc(%ebp),%esp 10a966: 5b pop %ebx 10a967: 5e pop %esi 10a968: 5f pop %edi 10a969: c9 leave 10a96a: c3 ret 10a96b: 90 nop
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10a96c: f6 c3 04 test $0x4,%bl
10a96f: 74 ed je 10a95e <rtems_semaphore_create+0x32>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
10a971: 81 fa c0 00 00 00 cmp $0xc0,%edx
10a977: 74 e5 je 10a95e <rtems_semaphore_create+0x32>
10a979: 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 ) )
10a97e: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10a982: 76 1f jbe 10a9a3 <rtems_semaphore_create+0x77>
return RTEMS_INVALID_NUMBER;
10a984: b8 0a 00 00 00 mov $0xa,%eax 10a989: eb d8 jmp 10a963 <rtems_semaphore_create+0x37> 10a98b: 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;
10a98c: b8 03 00 00 00 mov $0x3,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a991: 8d 65 f4 lea -0xc(%ebp),%esp 10a994: 5b pop %ebx 10a995: 5e pop %esi 10a996: 5f pop %edi 10a997: c9 leave 10a998: c3 ret 10a999: 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 ) )
10a99c: 89 d9 mov %ebx,%ecx 10a99e: 83 e1 30 and $0x30,%ecx
10a9a1: 75 db jne 10a97e <rtems_semaphore_create+0x52>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a9a3: a1 ec 77 12 00 mov 0x1277ec,%eax 10a9a8: 40 inc %eax 10a9a9: a3 ec 77 12 00 mov %eax,0x1277ec
* 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 );
10a9ae: 83 ec 0c sub $0xc,%esp 10a9b1: 68 40 77 12 00 push $0x127740 10a9b6: 89 4d c4 mov %ecx,-0x3c(%ebp) 10a9b9: e8 86 13 00 00 call 10bd44 <_Objects_Allocate> 10a9be: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
10a9c0: 83 c4 10 add $0x10,%esp 10a9c3: 85 c0 test %eax,%eax 10a9c5: 8b 4d c4 mov -0x3c(%ebp),%ecx
10a9c8: 0f 84 ba 00 00 00 je 10aa88 <rtems_semaphore_create+0x15c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
10a9ce: 89 58 10 mov %ebx,0x10(%eax)
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
10a9d1: 85 c9 test %ecx,%ecx
10a9d3: 74 77 je 10aa4c <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;
10a9d5: 31 c0 xor %eax,%eax 10a9d7: f6 c3 04 test $0x4,%bl 10a9da: 0f 95 c0 setne %al 10a9dd: 89 45 d8 mov %eax,-0x28(%ebp)
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
10a9e0: 83 f9 10 cmp $0x10,%ecx
10a9e3: 0f 84 ae 00 00 00 je 10aa97 <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;
10a9e9: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10a9f0: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
}
mutex_status = _CORE_mutex_Initialize(
10a9f4: 50 push %eax 10a9f5: 31 c0 xor %eax,%eax 10a9f7: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10a9fb: 0f 94 c0 sete %al 10a9fe: 50 push %eax 10a9ff: 8d 45 d0 lea -0x30(%ebp),%eax 10aa02: 50 push %eax 10aa03: 8d 42 14 lea 0x14(%edx),%eax 10aa06: 50 push %eax 10aa07: 89 55 c4 mov %edx,-0x3c(%ebp) 10aa0a: e8 2d 0b 00 00 call 10b53c <_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 ) {
10aa0f: 83 c4 10 add $0x10,%esp 10aa12: 83 f8 06 cmp $0x6,%eax 10aa15: 8b 55 c4 mov -0x3c(%ebp),%edx
10aa18: 0f 84 a9 00 00 00 je 10aac7 <rtems_semaphore_create+0x19b>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10aa1e: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10aa21: 0f b7 d8 movzwl %ax,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10aa24: 8b 0d 5c 77 12 00 mov 0x12775c,%ecx 10aa2a: 89 14 99 mov %edx,(%ecx,%ebx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10aa2d: 89 72 0c mov %esi,0xc(%edx)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
10aa30: 89 07 mov %eax,(%edi)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
10aa32: e8 49 23 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10aa37: 31 c0 xor %eax,%eax 10aa39: e9 25 ff ff ff jmp 10a963 <rtems_semaphore_create+0x37> 10aa3e: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10aa40: b8 09 00 00 00 mov $0x9,%eax 10aa45: e9 19 ff ff ff jmp 10a963 <rtems_semaphore_create+0x37> 10aa4a: 66 90 xchg %ax,%ax
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
10aa4c: 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;
10aa53: 31 c0 xor %eax,%eax 10aa55: f6 c3 04 test $0x4,%bl 10aa58: 0f 95 c0 setne %al 10aa5b: 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;
10aa5e: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
10aa65: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
_CORE_semaphore_Initialize(
10aa6c: 51 push %ecx 10aa6d: ff 75 0c pushl 0xc(%ebp) 10aa70: 8d 45 e0 lea -0x20(%ebp),%eax 10aa73: 50 push %eax 10aa74: 8d 42 14 lea 0x14(%edx),%eax 10aa77: 50 push %eax 10aa78: 89 55 c4 mov %edx,-0x3c(%ebp) 10aa7b: e8 4c 0d 00 00 call 10b7cc <_CORE_semaphore_Initialize> 10aa80: 83 c4 10 add $0x10,%esp 10aa83: 8b 55 c4 mov -0x3c(%ebp),%edx 10aa86: eb 96 jmp 10aa1e <rtems_semaphore_create+0xf2>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
10aa88: e8 f3 22 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10aa8d: b8 05 00 00 00 mov $0x5,%eax 10aa92: e9 cc fe ff ff jmp 10a963 <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;
10aa97: 8b 45 14 mov 0x14(%ebp),%eax 10aa9a: 89 45 dc mov %eax,-0x24(%ebp)
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10aa9d: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10aaa4: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
10aaa8: 83 7d d8 01 cmpl $0x1,-0x28(%ebp)
10aaac: 0f 85 42 ff ff ff jne 10a9f4 <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
10aab2: f6 c3 40 test $0x40,%bl
10aab5: 74 30 je 10aae7 <rtems_semaphore_create+0x1bb>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10aab7: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10aabe: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10aac2: e9 2d ff ff ff jmp 10a9f4 <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10aac7: 83 ec 08 sub $0x8,%esp 10aaca: 52 push %edx 10aacb: 68 40 77 12 00 push $0x127740 10aad0: e8 e3 15 00 00 call 10c0b8 <_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();
10aad5: e8 a6 22 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
10aada: 83 c4 10 add $0x10,%esp 10aadd: b8 13 00 00 00 mov $0x13,%eax 10aae2: e9 7c fe ff ff jmp 10a963 <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 ) ) {
10aae7: 81 e3 80 00 00 00 and $0x80,%ebx
10aaed: 0f 84 01 ff ff ff je 10a9f4 <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10aaf3: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10aafa: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10aafe: e9 f1 fe ff ff jmp 10a9f4 <rtems_semaphore_create+0xc8>
0010ab04 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
10ab04: 55 push %ebp 10ab05: 89 e5 mov %esp,%ebp 10ab07: 53 push %ebx 10ab08: 83 ec 18 sub $0x18,%esp
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
10ab0b: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10ab0e: 50 push %eax 10ab0f: ff 75 08 pushl 0x8(%ebp) 10ab12: 68 40 77 12 00 push $0x127740 10ab17: e8 dc 16 00 00 call 10c1f8 <_Objects_Get> 10ab1c: 89 c3 mov %eax,%ebx
switch ( location ) {
10ab1e: 83 c4 10 add $0x10,%esp 10ab21: 8b 4d f4 mov -0xc(%ebp),%ecx 10ab24: 85 c9 test %ecx,%ecx
10ab26: 74 0c je 10ab34 <rtems_semaphore_delete+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ab28: b8 04 00 00 00 mov $0x4,%eax
}
10ab2d: 8b 5d fc mov -0x4(%ebp),%ebx 10ab30: c9 leave 10ab31: c3 ret 10ab32: 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);
10ab34: 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) ) {
10ab37: 83 e0 30 and $0x30,%eax
10ab3a: 74 58 je 10ab94 <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
10ab3c: 8b 53 64 mov 0x64(%ebx),%edx 10ab3f: 85 d2 test %edx,%edx
10ab41: 75 15 jne 10ab58 <rtems_semaphore_delete+0x54>
10ab43: 83 f8 20 cmp $0x20,%eax
10ab46: 74 10 je 10ab58 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
10ab48: e8 33 22 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10ab4d: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ab52: 8b 5d fc mov -0x4(%ebp),%ebx 10ab55: c9 leave 10ab56: c3 ret 10ab57: 90 nop
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
10ab58: 50 push %eax 10ab59: 6a 04 push $0x4 10ab5b: 6a 00 push $0x0 10ab5d: 8d 43 14 lea 0x14(%ebx),%eax 10ab60: 50 push %eax 10ab61: e8 ca 09 00 00 call 10b530 <_CORE_mutex_Flush> 10ab66: 83 c4 10 add $0x10,%esp
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
10ab69: 83 ec 08 sub $0x8,%esp 10ab6c: 53 push %ebx 10ab6d: 68 40 77 12 00 push $0x127740 10ab72: e8 49 12 00 00 call 10bdc0 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10ab77: 58 pop %eax 10ab78: 5a pop %edx 10ab79: 53 push %ebx 10ab7a: 68 40 77 12 00 push $0x127740 10ab7f: e8 34 15 00 00 call 10c0b8 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10ab84: e8 f7 21 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ab89: 83 c4 10 add $0x10,%esp 10ab8c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ab8e: 8b 5d fc mov -0x4(%ebp),%ebx 10ab91: c9 leave 10ab92: c3 ret 10ab93: 90 nop
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
10ab94: 51 push %ecx 10ab95: 6a 02 push $0x2 10ab97: 6a 00 push $0x0 10ab99: 8d 43 14 lea 0x14(%ebx),%eax 10ab9c: 50 push %eax 10ab9d: e8 1e 0c 00 00 call 10b7c0 <_CORE_semaphore_Flush> 10aba2: 83 c4 10 add $0x10,%esp 10aba5: eb c2 jmp 10ab69 <rtems_semaphore_delete+0x65>
0010aba8 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10aba8: 55 push %ebp 10aba9: 89 e5 mov %esp,%ebp 10abab: 57 push %edi 10abac: 56 push %esi 10abad: 53 push %ebx 10abae: 83 ec 1c sub $0x1c,%esp 10abb1: 8b 5d 08 mov 0x8(%ebp),%ebx 10abb4: 8b 75 0c mov 0xc(%ebp),%esi 10abb7: 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 );
10abba: 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 );
10abbd: 50 push %eax 10abbe: 8d 45 e4 lea -0x1c(%ebp),%eax 10abc1: 50 push %eax 10abc2: 53 push %ebx 10abc3: 68 40 77 12 00 push $0x127740 10abc8: e8 d3 15 00 00 call 10c1a0 <_Objects_Get_isr_disable>
switch ( location ) {
10abcd: 83 c4 10 add $0x10,%esp 10abd0: 8b 4d e4 mov -0x1c(%ebp),%ecx 10abd3: 85 c9 test %ecx,%ecx
10abd5: 74 0d je 10abe4 <rtems_semaphore_obtain+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10abd7: b8 04 00 00 00 mov $0x4,%eax
}
10abdc: 8d 65 f4 lea -0xc(%ebp),%esp 10abdf: 5b pop %ebx 10abe0: 5e pop %esi 10abe1: 5f pop %edi 10abe2: c9 leave 10abe3: 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) ) {
10abe4: f6 40 10 30 testb $0x30,0x10(%eax)
10abe8: 74 36 je 10ac20 <rtems_semaphore_obtain+0x78>
_CORE_mutex_Seize(
10abea: 83 ec 0c sub $0xc,%esp 10abed: ff 75 e0 pushl -0x20(%ebp) 10abf0: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
10abf1: 83 e6 01 and $0x1,%esi 10abf4: 83 f6 01 xor $0x1,%esi 10abf7: 56 push %esi 10abf8: 53 push %ebx 10abf9: 83 c0 14 add $0x14,%eax 10abfc: 50 push %eax 10abfd: e8 32 0a 00 00 call 10b634 <_CORE_mutex_Seize>
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10ac02: 83 c4 14 add $0x14,%esp
_Thread_Executing->Wait.return_code );
10ac05: a1 98 7d 12 00 mov 0x127d98,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10ac0a: ff 70 34 pushl 0x34(%eax) 10ac0d: e8 12 01 00 00 call 10ad24 <_Semaphore_Translate_core_mutex_return_code> 10ac12: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10ac15: 8d 65 f4 lea -0xc(%ebp),%esp 10ac18: 5b pop %ebx 10ac19: 5e pop %esi 10ac1a: 5f pop %edi 10ac1b: c9 leave 10ac1c: c3 ret 10ac1d: 8d 76 00 lea 0x0(%esi),%esi
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
10ac20: 8b 15 98 7d 12 00 mov 0x127d98,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ac26: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( the_semaphore->count != 0 ) {
10ac2d: 8b 48 5c mov 0x5c(%eax),%ecx 10ac30: 85 c9 test %ecx,%ecx
10ac32: 75 2c jne 10ac60 <rtems_semaphore_obtain+0xb8>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
10ac34: 83 e6 01 and $0x1,%esi
10ac37: 74 33 je 10ac6c <rtems_semaphore_obtain+0xc4>
_ISR_Enable( *level_p );
10ac39: ff 75 e0 pushl -0x20(%ebp) 10ac3c: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
10ac3d: 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(
10ac44: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10ac47: a1 98 7d 12 00 mov 0x127d98,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10ac4c: ff 70 34 pushl 0x34(%eax) 10ac4f: e8 e0 00 00 00 call 10ad34 <_Semaphore_Translate_core_semaphore_return_code> 10ac54: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10ac57: 8d 65 f4 lea -0xc(%ebp),%esp 10ac5a: 5b pop %ebx 10ac5b: 5e pop %esi 10ac5c: 5f pop %edi 10ac5d: c9 leave 10ac5e: c3 ret 10ac5f: 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;
10ac60: 49 dec %ecx 10ac61: 89 48 5c mov %ecx,0x5c(%eax)
_ISR_Enable( *level_p );
10ac64: ff 75 e0 pushl -0x20(%ebp) 10ac67: 9d popf 10ac68: eb da jmp 10ac44 <rtems_semaphore_obtain+0x9c> 10ac6a: 66 90 xchg %ax,%ax 10ac6c: 8b 0d ec 77 12 00 mov 0x1277ec,%ecx 10ac72: 41 inc %ecx 10ac73: 89 0d ec 77 12 00 mov %ecx,0x1277ec
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;
10ac79: 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;
10ac80: 83 c0 14 add $0x14,%eax 10ac83: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10ac86: 89 5a 20 mov %ebx,0x20(%edx)
_ISR_Enable( *level_p );
10ac89: ff 75 e0 pushl -0x20(%ebp) 10ac8c: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
10ac8d: 52 push %edx 10ac8e: 68 54 d5 10 00 push $0x10d554 10ac93: 57 push %edi 10ac94: 50 push %eax 10ac95: e8 8e 25 00 00 call 10d228 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10ac9a: e8 e1 20 00 00 call 10cd80 <_Thread_Enable_dispatch> 10ac9f: 83 c4 10 add $0x10,%esp 10aca2: eb a0 jmp 10ac44 <rtems_semaphore_obtain+0x9c>
0010aca4 <rtems_semaphore_release>:
#endif
rtems_status_code rtems_semaphore_release(
rtems_id id
)
{
10aca4: 55 push %ebp 10aca5: 89 e5 mov %esp,%ebp 10aca7: 53 push %ebx 10aca8: 83 ec 18 sub $0x18,%esp 10acab: 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 );
10acae: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10acb1: 50 push %eax 10acb2: 53 push %ebx 10acb3: 68 40 77 12 00 push $0x127740 10acb8: e8 3b 15 00 00 call 10c1f8 <_Objects_Get>
switch ( location ) {
10acbd: 83 c4 10 add $0x10,%esp 10acc0: 8b 55 f4 mov -0xc(%ebp),%edx 10acc3: 85 d2 test %edx,%edx
10acc5: 74 0d je 10acd4 <rtems_semaphore_release+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10acc7: b8 04 00 00 00 mov $0x4,%eax
}
10accc: 8b 5d fc mov -0x4(%ebp),%ebx 10accf: c9 leave 10acd0: c3 ret 10acd1: 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) ) {
10acd4: f6 40 10 30 testb $0x30,0x10(%eax)
10acd8: 75 26 jne 10ad00 <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(
10acda: 52 push %edx 10acdb: 6a 00 push $0x0 10acdd: 53 push %ebx 10acde: 83 c0 14 add $0x14,%eax 10ace1: 50 push %eax 10ace2: e8 25 0b 00 00 call 10b80c <_CORE_semaphore_Surrender> 10ace7: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10ace9: e8 92 20 00 00 call 10cd80 <_Thread_Enable_dispatch>
return
10acee: 89 1c 24 mov %ebx,(%esp) 10acf1: e8 3e 00 00 00 call 10ad34 <_Semaphore_Translate_core_semaphore_return_code> 10acf6: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10acf9: 8b 5d fc mov -0x4(%ebp),%ebx 10acfc: c9 leave 10acfd: c3 ret 10acfe: 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(
10ad00: 51 push %ecx 10ad01: 6a 00 push $0x0 10ad03: 53 push %ebx 10ad04: 83 c0 14 add $0x14,%eax 10ad07: 50 push %eax 10ad08: e8 c7 09 00 00 call 10b6d4 <_CORE_mutex_Surrender> 10ad0d: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10ad0f: e8 6c 20 00 00 call 10cd80 <_Thread_Enable_dispatch>
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
10ad14: 89 1c 24 mov %ebx,(%esp) 10ad17: e8 08 00 00 00 call 10ad24 <_Semaphore_Translate_core_mutex_return_code> 10ad1c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ad1f: 8b 5d fc mov -0x4(%ebp),%ebx 10ad22: c9 leave 10ad23: c3 ret
00117388 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
117388: 55 push %ebp 117389: 89 e5 mov %esp,%ebp 11738b: 53 push %ebx 11738c: 83 ec 14 sub $0x14,%esp 11738f: 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 )
117392: 85 db test %ebx,%ebx
117394: 75 0a jne 1173a0 <rtems_signal_send+0x18>
return RTEMS_INVALID_NUMBER;
117396: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11739b: 8b 5d fc mov -0x4(%ebp),%ebx 11739e: c9 leave 11739f: c3 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
1173a0: 83 ec 08 sub $0x8,%esp 1173a3: 8d 45 f4 lea -0xc(%ebp),%eax 1173a6: 50 push %eax 1173a7: ff 75 08 pushl 0x8(%ebp) 1173aa: e8 f9 40 00 00 call 11b4a8 <_Thread_Get>
switch ( location ) {
1173af: 83 c4 10 add $0x10,%esp 1173b2: 8b 55 f4 mov -0xc(%ebp),%edx 1173b5: 85 d2 test %edx,%edx
1173b7: 74 0b je 1173c4 <rtems_signal_send+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1173b9: b8 04 00 00 00 mov $0x4,%eax
}
1173be: 8b 5d fc mov -0x4(%ebp),%ebx 1173c1: c9 leave 1173c2: c3 ret 1173c3: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
1173c4: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
1173ca: 8b 4a 0c mov 0xc(%edx),%ecx 1173cd: 85 c9 test %ecx,%ecx
1173cf: 74 3f je 117410 <rtems_signal_send+0x88>
if ( asr->is_enabled ) {
1173d1: 80 7a 08 00 cmpb $0x0,0x8(%edx)
1173d5: 74 25 je 1173fc <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
1173d7: 9c pushf 1173d8: fa cli 1173d9: 59 pop %ecx
*signal_set |= signals;
1173da: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
1173dd: 51 push %ecx 1173de: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1173df: 8b 15 54 26 14 00 mov 0x142654,%edx 1173e5: 85 d2 test %edx,%edx
1173e7: 74 1b je 117404 <rtems_signal_send+0x7c>
1173e9: 3b 05 58 26 14 00 cmp 0x142658,%eax
1173ef: 75 13 jne 117404 <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
1173f1: c6 05 64 26 14 00 01 movb $0x1,0x142664 1173f8: eb 0a jmp 117404 <rtems_signal_send+0x7c> 1173fa: 66 90 xchg %ax,%ax
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
1173fc: 9c pushf 1173fd: fa cli 1173fe: 58 pop %eax
*signal_set |= signals;
1173ff: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
117402: 50 push %eax 117403: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
117404: e8 7b 40 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117409: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11740b: 8b 5d fc mov -0x4(%ebp),%ebx 11740e: c9 leave 11740f: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117410: e8 6f 40 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
117415: b8 0b 00 00 00 mov $0xb,%eax 11741a: e9 7c ff ff ff jmp 11739b <rtems_signal_send+0x13>
0010ad44 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
10ad44: 55 push %ebp 10ad45: 89 e5 mov %esp,%ebp 10ad47: 57 push %edi 10ad48: 56 push %esi 10ad49: 53 push %ebx 10ad4a: 83 ec 1c sub $0x1c,%esp 10ad4d: 8b 5d 08 mov 0x8(%ebp),%ebx 10ad50: 8b 7d 0c mov 0xc(%ebp),%edi 10ad53: 8b 75 1c mov 0x1c(%ebp),%esi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10ad56: 85 f6 test %esi,%esi
10ad58: 0f 84 3e 01 00 00 je 10ae9c <rtems_task_create+0x158>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10ad5e: 85 db test %ebx,%ebx
10ad60: 0f 84 d2 00 00 00 je 10ae38 <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 ) ) {
10ad66: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp)
10ad6d: 75 17 jne 10ad86 <rtems_task_create+0x42>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10ad6f: 85 ff test %edi,%edi
10ad71: 0f 84 b1 00 00 00 je 10ae28 <rtems_task_create+0xe4>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10ad77: 0f b6 05 54 35 12 00 movzbl 0x123554,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10ad7e: 39 c7 cmp %eax,%edi
10ad80: 0f 87 a2 00 00 00 ja 10ae28 <rtems_task_create+0xe4>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10ad86: 83 ec 0c sub $0xc,%esp 10ad89: ff 35 a0 78 12 00 pushl 0x1278a0 10ad8f: e8 c4 06 00 00 call 10b458 <_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 );
10ad94: c7 04 24 80 77 12 00 movl $0x127780,(%esp) 10ad9b: e8 a4 0f 00 00 call 10bd44 <_Objects_Allocate> 10ada0: 89 c2 mov %eax,%edx
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10ada2: 83 c4 10 add $0x10,%esp 10ada5: 85 c0 test %eax,%eax
10ada7: 0f 84 cf 00 00 00 je 10ae7c <rtems_task_create+0x138>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10adad: 50 push %eax 10adae: 53 push %ebx
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
10adaf: 8b 45 14 mov 0x14(%ebp),%eax 10adb2: 83 e0 01 and $0x1,%eax 10adb5: 50 push %eax 10adb6: 6a 00 push $0x0 10adb8: 31 c0 xor %eax,%eax 10adba: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp) 10adc1: 0f 95 c0 setne %al 10adc4: 50 push %eax 10adc5: 31 c0 xor %eax,%eax 10adc7: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp) 10adce: 0f 94 c0 sete %al 10add1: 50 push %eax 10add2: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
10add3: 8b 45 18 mov 0x18(%ebp),%eax 10add6: 83 e0 01 and $0x1,%eax 10add9: 50 push %eax 10adda: ff 75 10 pushl 0x10(%ebp) 10addd: 6a 00 push $0x0 10addf: 52 push %edx 10ade0: 68 80 77 12 00 push $0x127780 10ade5: 89 55 e4 mov %edx,-0x1c(%ebp) 10ade8: e8 2f 20 00 00 call 10ce1c <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
10aded: 83 c4 30 add $0x30,%esp 10adf0: 84 c0 test %al,%al 10adf2: 8b 55 e4 mov -0x1c(%ebp),%edx
10adf5: 74 51 je 10ae48 <rtems_task_create+0x104>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
10adf7: 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(
10adfd: 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;
10ae04: 0f 94 40 08 sete 0x8(%eax)
*id = the_thread->Object.id;
10ae08: 8b 42 08 mov 0x8(%edx),%eax 10ae0b: 89 06 mov %eax,(%esi)
);
}
#endif
_RTEMS_Unlock_allocator();
10ae0d: 83 ec 0c sub $0xc,%esp 10ae10: ff 35 a0 78 12 00 pushl 0x1278a0 10ae16: e8 85 06 00 00 call 10b4a0 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
10ae1b: 83 c4 10 add $0x10,%esp 10ae1e: 31 c0 xor %eax,%eax
}
10ae20: 8d 65 f4 lea -0xc(%ebp),%esp 10ae23: 5b pop %ebx 10ae24: 5e pop %esi 10ae25: 5f pop %edi 10ae26: c9 leave 10ae27: 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;
10ae28: b8 13 00 00 00 mov $0x13,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae2d: 8d 65 f4 lea -0xc(%ebp),%esp 10ae30: 5b pop %ebx 10ae31: 5e pop %esi 10ae32: 5f pop %edi 10ae33: c9 leave 10ae34: c3 ret 10ae35: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10ae38: b8 03 00 00 00 mov $0x3,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae3d: 8d 65 f4 lea -0xc(%ebp),%esp 10ae40: 5b pop %ebx 10ae41: 5e pop %esi 10ae42: 5f pop %edi 10ae43: c9 leave 10ae44: c3 ret 10ae45: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
10ae48: 83 ec 0c sub $0xc,%esp 10ae4b: ff 72 08 pushl 0x8(%edx) 10ae4e: e8 d5 12 00 00 call 10c128 <_Objects_Get_information_id> 10ae53: 5a pop %edx 10ae54: 59 pop %ecx 10ae55: 8b 55 e4 mov -0x1c(%ebp),%edx 10ae58: 52 push %edx 10ae59: 50 push %eax 10ae5a: e8 59 12 00 00 call 10c0b8 <_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();
10ae5f: 58 pop %eax 10ae60: ff 35 a0 78 12 00 pushl 0x1278a0 10ae66: e8 35 06 00 00 call 10b4a0 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
10ae6b: 83 c4 10 add $0x10,%esp 10ae6e: b8 0d 00 00 00 mov $0xd,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae73: 8d 65 f4 lea -0xc(%ebp),%esp 10ae76: 5b pop %ebx 10ae77: 5e pop %esi 10ae78: 5f pop %edi 10ae79: c9 leave 10ae7a: c3 ret 10ae7b: 90 nop
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10ae7c: 83 ec 0c sub $0xc,%esp 10ae7f: ff 35 a0 78 12 00 pushl 0x1278a0 10ae85: e8 16 06 00 00 call 10b4a0 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
10ae8a: 83 c4 10 add $0x10,%esp 10ae8d: b8 05 00 00 00 mov $0x5,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae92: 8d 65 f4 lea -0xc(%ebp),%esp 10ae95: 5b pop %ebx 10ae96: 5e pop %esi 10ae97: 5f pop %edi 10ae98: c9 leave 10ae99: c3 ret 10ae9a: 66 90 xchg %ax,%ax
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10ae9c: b8 09 00 00 00 mov $0x9,%eax 10aea1: eb 8a jmp 10ae2d <rtems_task_create+0xe9>
0010aea4 <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
10aea4: 55 push %ebp 10aea5: 89 e5 mov %esp,%ebp 10aea7: 53 push %ebx 10aea8: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
10aeab: ff 35 a0 78 12 00 pushl 0x1278a0 10aeb1: e8 a2 05 00 00 call 10b458 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
10aeb6: 5a pop %edx 10aeb7: 59 pop %ecx 10aeb8: 8d 45 f4 lea -0xc(%ebp),%eax 10aebb: 50 push %eax 10aebc: ff 75 08 pushl 0x8(%ebp) 10aebf: e8 e0 1e 00 00 call 10cda4 <_Thread_Get> 10aec4: 89 c3 mov %eax,%ebx
switch ( location ) {
10aec6: 83 c4 10 add $0x10,%esp 10aec9: 8b 45 f4 mov -0xc(%ebp),%eax 10aecc: 85 c0 test %eax,%eax
10aece: 75 44 jne 10af14 <rtems_task_delete+0x70>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
10aed0: 83 ec 0c sub $0xc,%esp 10aed3: ff 73 08 pushl 0x8(%ebx) 10aed6: e8 4d 12 00 00 call 10c128 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
10aedb: 5a pop %edx 10aedc: 59 pop %ecx 10aedd: 53 push %ebx 10aede: 50 push %eax 10aedf: e8 74 1b 00 00 call 10ca58 <_Thread_Close> 10aee4: 58 pop %eax 10aee5: ff 73 08 pushl 0x8(%ebx) 10aee8: e8 3b 12 00 00 call 10c128 <_Objects_Get_information_id> 10aeed: 5a pop %edx 10aeee: 59 pop %ecx 10aeef: 53 push %ebx 10aef0: 50 push %eax 10aef1: e8 c2 11 00 00 call 10c0b8 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10aef6: 58 pop %eax 10aef7: ff 35 a0 78 12 00 pushl 0x1278a0 10aefd: e8 9e 05 00 00 call 10b4a0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10af02: e8 79 1e 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10af07: 83 c4 10 add $0x10,%esp 10af0a: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
10af0c: 8b 5d fc mov -0x4(%ebp),%ebx 10af0f: c9 leave 10af10: c3 ret 10af11: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
10af14: 83 ec 0c sub $0xc,%esp 10af17: ff 35 a0 78 12 00 pushl 0x1278a0 10af1d: e8 7e 05 00 00 call 10b4a0 <_API_Mutex_Unlock>
return RTEMS_INVALID_ID;
10af22: 83 c4 10 add $0x10,%esp 10af25: b8 04 00 00 00 mov $0x4,%eax
}
10af2a: 8b 5d fc mov -0x4(%ebp),%ebx 10af2d: c9 leave 10af2e: c3 ret
0010ca6c <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
10ca6c: 55 push %ebp 10ca6d: 89 e5 mov %esp,%ebp 10ca6f: 56 push %esi 10ca70: 53 push %ebx 10ca71: 83 ec 10 sub $0x10,%esp 10ca74: 8b 45 08 mov 0x8(%ebp),%eax 10ca77: 8b 75 0c mov 0xc(%ebp),%esi 10ca7a: 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() )
10ca7d: 80 3d e4 74 12 00 00 cmpb $0x0,0x1274e4
10ca84: 74 6e je 10caf4 <rtems_task_get_note+0x88>
return RTEMS_NOT_CONFIGURED;
if ( !note )
10ca86: 85 db test %ebx,%ebx
10ca88: 74 7e je 10cb08 <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 )
10ca8a: 83 fe 0f cmp $0xf,%esi
10ca8d: 77 3d ja 10cacc <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 ) ||
10ca8f: 85 c0 test %eax,%eax
10ca91: 74 45 je 10cad8 <rtems_task_get_note+0x6c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10ca93: 8b 15 98 c0 12 00 mov 0x12c098,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10ca99: 3b 42 08 cmp 0x8(%edx),%eax
10ca9c: 74 40 je 10cade <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 );
10ca9e: 83 ec 08 sub $0x8,%esp 10caa1: 8d 55 f4 lea -0xc(%ebp),%edx 10caa4: 52 push %edx 10caa5: 50 push %eax 10caa6: e8 d1 21 00 00 call 10ec7c <_Thread_Get>
switch ( location ) {
10caab: 83 c4 10 add $0x10,%esp 10caae: 8b 55 f4 mov -0xc(%ebp),%edx 10cab1: 85 d2 test %edx,%edx
10cab3: 75 4b jne 10cb00 <rtems_task_get_note+0x94>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10cab5: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10cabb: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10cabf: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10cac1: e8 92 21 00 00 call 10ec58 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10cac6: 31 c0 xor %eax,%eax 10cac8: eb 07 jmp 10cad1 <rtems_task_get_note+0x65> 10caca: 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;
10cacc: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cad1: 8d 65 f8 lea -0x8(%ebp),%esp 10cad4: 5b pop %ebx 10cad5: 5e pop %esi 10cad6: c9 leave 10cad7: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cad8: 8b 15 98 c0 12 00 mov 0x12c098,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10cade: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10cae4: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10cae8: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
10caea: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10caec: 8d 65 f8 lea -0x8(%ebp),%esp 10caef: 5b pop %ebx 10caf0: 5e pop %esi 10caf1: c9 leave 10caf2: c3 ret 10caf3: 90 nop
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10caf4: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10caf9: 8d 65 f8 lea -0x8(%ebp),%esp 10cafc: 5b pop %ebx 10cafd: 5e pop %esi 10cafe: c9 leave 10caff: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10cb00: b8 04 00 00 00 mov $0x4,%eax 10cb05: eb ca jmp 10cad1 <rtems_task_get_note+0x65> 10cb07: 90 nop
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
return RTEMS_INVALID_ADDRESS;
10cb08: b8 09 00 00 00 mov $0x9,%eax 10cb0d: eb c2 jmp 10cad1 <rtems_task_get_note+0x65>
0011776c <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
11776c: 55 push %ebp 11776d: 89 e5 mov %esp,%ebp 11776f: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
117772: 8d 45 f4 lea -0xc(%ebp),%eax 117775: 50 push %eax 117776: ff 75 08 pushl 0x8(%ebp) 117779: e8 2a 3d 00 00 call 11b4a8 <_Thread_Get>
switch ( location ) {
11777e: 83 c4 10 add $0x10,%esp 117781: 8b 55 f4 mov -0xc(%ebp),%edx 117784: 85 d2 test %edx,%edx
117786: 74 08 je 117790 <rtems_task_is_suspended+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117788: b8 04 00 00 00 mov $0x4,%eax
}
11778d: c9 leave 11778e: c3 ret 11778f: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
117790: f6 40 10 02 testb $0x2,0x10(%eax)
117794: 74 0e je 1177a4 <rtems_task_is_suspended+0x38>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117796: e8 e9 3c 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
11779b: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1177a0: c9 leave 1177a1: c3 ret 1177a2: 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();
1177a4: e8 db 3c 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1177a9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1177ab: c9 leave 1177ac: c3 ret
001128fc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
1128fc: 55 push %ebp 1128fd: 89 e5 mov %esp,%ebp 1128ff: 57 push %edi 112900: 56 push %esi 112901: 53 push %ebx 112902: 83 ec 1c sub $0x1c,%esp 112905: 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 )
112908: 85 c9 test %ecx,%ecx
11290a: 0f 84 40 01 00 00 je 112a50 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
112910: 8b 1d 98 7d 12 00 mov 0x127d98,%ebx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
112916: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
11291c: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 112920: 19 f6 sbb %esi,%esi 112922: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
112928: 8b 53 7c mov 0x7c(%ebx),%edx 11292b: 85 d2 test %edx,%edx
11292d: 0f 85 f1 00 00 00 jne 112a24 <rtems_task_mode+0x128>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
112933: 80 7f 08 01 cmpb $0x1,0x8(%edi) 112937: 19 d2 sbb %edx,%edx 112939: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
11293f: 89 55 e4 mov %edx,-0x1c(%ebp) 112942: 89 4d e0 mov %ecx,-0x20(%ebp) 112945: e8 12 b8 ff ff call 10e15c <_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;
11294a: 8b 55 e4 mov -0x1c(%ebp),%edx 11294d: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
11294f: 09 f0 or %esi,%eax 112951: 8b 4d e0 mov -0x20(%ebp),%ecx 112954: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
112956: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
11295d: 74 0b je 11296a <rtems_task_mode+0x6e>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
11295f: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 112966: 0f 94 43 74 sete 0x74(%ebx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
11296a: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
112971: 74 1c je 11298f <rtems_task_mode+0x93>
if ( _Modes_Is_timeslice(mode_set) ) {
112973: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
11297a: 0f 84 b8 00 00 00 je 112a38 <rtems_task_mode+0x13c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
112980: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
112987: a1 c0 77 12 00 mov 0x1277c0,%eax 11298c: 89 43 78 mov %eax,0x78(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
11298f: f6 45 0c 01 testb $0x1,0xc(%ebp)
112993: 74 0b je 1129a0 <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 ) );
112995: f6 45 08 01 testb $0x1,0x8(%ebp)
112999: 0f 84 91 00 00 00 je 112a30 <rtems_task_mode+0x134>
11299f: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
1129a0: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
1129a7: 74 3f je 1129e8 <rtems_task_mode+0xec>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
1129a9: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 1129b0: 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 ) {
1129b3: 38 47 08 cmp %al,0x8(%edi)
1129b6: 74 30 je 1129e8 <rtems_task_mode+0xec>
asr->is_enabled = is_asr_enabled;
1129b8: 88 47 08 mov %al,0x8(%edi)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
1129bb: 9c pushf 1129bc: fa cli 1129bd: 58 pop %eax
_signals = information->signals_pending;
1129be: 8b 57 18 mov 0x18(%edi),%edx
information->signals_pending = information->signals_posted;
1129c1: 8b 4f 14 mov 0x14(%edi),%ecx 1129c4: 89 4f 18 mov %ecx,0x18(%edi)
information->signals_posted = _signals;
1129c7: 89 57 14 mov %edx,0x14(%edi)
_ISR_Enable( _level );
1129ca: 50 push %eax 1129cb: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
1129cc: 8b 47 14 mov 0x14(%edi),%eax 1129cf: 85 c0 test %eax,%eax 1129d1: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
1129d4: 83 3d 80 79 12 00 03 cmpl $0x3,0x127980
1129db: 74 16 je 1129f3 <rtems_task_mode+0xf7> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
1129dd: 31 c0 xor %eax,%eax
}
1129df: 83 c4 1c add $0x1c,%esp 1129e2: 5b pop %ebx 1129e3: 5e pop %esi 1129e4: 5f pop %edi 1129e5: c9 leave 1129e6: c3 ret 1129e7: 90 nop
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
1129e8: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
1129ea: 83 3d 80 79 12 00 03 cmpl $0x3,0x127980
1129f1: 75 ea jne 1129dd <rtems_task_mode+0xe1>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
1129f3: 8b 15 98 7d 12 00 mov 0x127d98,%edx
if ( are_signals_pending ||
1129f9: 84 c0 test %al,%al
1129fb: 75 0e jne 112a0b <rtems_task_mode+0x10f>
1129fd: 3b 15 9c 7d 12 00 cmp 0x127d9c,%edx
112a03: 74 d8 je 1129dd <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
112a05: 80 7a 74 00 cmpb $0x0,0x74(%edx)
112a09: 74 d2 je 1129dd <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
112a0b: c6 05 a4 7d 12 00 01 movb $0x1,0x127da4
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
112a12: e8 f1 a1 ff ff call 10cc08 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
112a17: 31 c0 xor %eax,%eax
}
112a19: 83 c4 1c add $0x1c,%esp 112a1c: 5b pop %ebx 112a1d: 5e pop %esi 112a1e: 5f pop %edi 112a1f: c9 leave 112a20: c3 ret 112a21: 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;
112a24: 81 ce 00 02 00 00 or $0x200,%esi 112a2a: e9 04 ff ff ff jmp 112933 <rtems_task_mode+0x37> 112a2f: 90 nop 112a30: fb sti 112a31: e9 6a ff ff ff jmp 1129a0 <rtems_task_mode+0xa4> 112a36: 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;
112a38: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112a3f: f6 45 0c 01 testb $0x1,0xc(%ebp)
112a43: 0f 84 57 ff ff ff je 1129a0 <rtems_task_mode+0xa4>
112a49: e9 47 ff ff ff jmp 112995 <rtems_task_mode+0x99> 112a4e: 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;
112a50: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
112a55: 83 c4 1c add $0x1c,%esp 112a58: 5b pop %ebx 112a59: 5e pop %esi 112a5a: 5f pop %edi 112a5b: c9 leave 112a5c: c3 ret
0010e1c4 <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
10e1c4: 55 push %ebp 10e1c5: 89 e5 mov %esp,%ebp 10e1c7: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e1ca: 8d 45 f4 lea -0xc(%ebp),%eax 10e1cd: 50 push %eax 10e1ce: ff 75 08 pushl 0x8(%ebp) 10e1d1: e8 7e 1e 00 00 call 110054 <_Thread_Get>
switch ( location ) {
10e1d6: 83 c4 10 add $0x10,%esp 10e1d9: 8b 55 f4 mov -0xc(%ebp),%edx 10e1dc: 85 d2 test %edx,%edx
10e1de: 74 08 je 10e1e8 <rtems_task_resume+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10e1e0: b8 04 00 00 00 mov $0x4,%eax
}
10e1e5: c9 leave 10e1e6: c3 ret 10e1e7: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
10e1e8: f6 40 10 02 testb $0x2,0x10(%eax)
10e1ec: 75 0e jne 10e1fc <rtems_task_resume+0x38>
_Thread_Resume( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10e1ee: e8 3d 1e 00 00 call 110030 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10e1f3: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10e1f8: c9 leave 10e1f9: c3 ret 10e1fa: 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 );
10e1fc: 83 ec 08 sub $0x8,%esp 10e1ff: 6a 02 push $0x2 10e201: 50 push %eax 10e202: e8 c5 1a 00 00 call 10fccc <_Thread_Clear_state>
_Thread_Enable_dispatch();
10e207: e8 24 1e 00 00 call 110030 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10e20c: 83 c4 10 add $0x10,%esp 10e20f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10e211: c9 leave 10e212: c3 ret
0010cbe4 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
10cbe4: 55 push %ebp 10cbe5: 89 e5 mov %esp,%ebp 10cbe7: 56 push %esi 10cbe8: 53 push %ebx 10cbe9: 83 ec 10 sub $0x10,%esp 10cbec: 8b 45 08 mov 0x8(%ebp),%eax 10cbef: 8b 5d 0c mov 0xc(%ebp),%ebx 10cbf2: 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() )
10cbf5: 80 3d e4 74 12 00 00 cmpb $0x0,0x1274e4
10cbfc: 74 66 je 10cc64 <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 )
10cbfe: 83 fb 0f cmp $0xf,%ebx
10cc01: 77 39 ja 10cc3c <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 ) ||
10cc03: 85 c0 test %eax,%eax
10cc05: 74 41 je 10cc48 <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10cc07: 8b 15 98 c0 12 00 mov 0x12c098,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cc0d: 3b 42 08 cmp 0x8(%edx),%eax
10cc10: 74 3c je 10cc4e <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 );
10cc12: 83 ec 08 sub $0x8,%esp 10cc15: 8d 55 f4 lea -0xc(%ebp),%edx 10cc18: 52 push %edx 10cc19: 50 push %eax 10cc1a: e8 5d 20 00 00 call 10ec7c <_Thread_Get>
switch ( location ) {
10cc1f: 83 c4 10 add $0x10,%esp 10cc22: 8b 55 f4 mov -0xc(%ebp),%edx 10cc25: 85 d2 test %edx,%edx
10cc27: 75 47 jne 10cc70 <rtems_task_set_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10cc29: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10cc2f: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10cc33: e8 20 20 00 00 call 10ec58 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10cc38: 31 c0 xor %eax,%eax 10cc3a: eb 05 jmp 10cc41 <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;
10cc3c: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cc41: 8d 65 f8 lea -0x8(%ebp),%esp 10cc44: 5b pop %ebx 10cc45: 5e pop %esi 10cc46: c9 leave 10cc47: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cc48: 8b 15 98 c0 12 00 mov 0x12c098,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10cc4e: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10cc54: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
return RTEMS_SUCCESSFUL;
10cc58: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cc5a: 8d 65 f8 lea -0x8(%ebp),%esp 10cc5d: 5b pop %ebx 10cc5e: 5e pop %esi 10cc5f: c9 leave 10cc60: c3 ret 10cc61: 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;
10cc64: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cc69: 8d 65 f8 lea -0x8(%ebp),%esp 10cc6c: 5b pop %ebx 10cc6d: 5e pop %esi 10cc6e: c9 leave 10cc6f: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10cc70: b8 04 00 00 00 mov $0x4,%eax
}
10cc75: 8d 65 f8 lea -0x8(%ebp),%esp 10cc78: 5b pop %ebx 10cc79: 5e pop %esi 10cc7a: c9 leave 10cc7b: c3 ret
0010ee88 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10ee88: 55 push %ebp 10ee89: 89 e5 mov %esp,%ebp 10ee8b: 56 push %esi 10ee8c: 53 push %ebx 10ee8d: 83 ec 10 sub $0x10,%esp 10ee90: 8b 5d 0c mov 0xc(%ebp),%ebx 10ee93: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10ee96: 85 db test %ebx,%ebx
10ee98: 74 0b je 10eea5 <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 ) );
10ee9a: 0f b6 05 34 74 12 00 movzbl 0x127434,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10eea1: 39 c3 cmp %eax,%ebx
10eea3: 77 5f ja 10ef04 <rtems_task_set_priority+0x7c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10eea5: 85 f6 test %esi,%esi
10eea7: 74 67 je 10ef10 <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10eea9: 83 ec 08 sub $0x8,%esp 10eeac: 8d 45 f4 lea -0xc(%ebp),%eax 10eeaf: 50 push %eax 10eeb0: ff 75 08 pushl 0x8(%ebp) 10eeb3: e8 dc 1f 00 00 call 110e94 <_Thread_Get>
switch ( location ) {
10eeb8: 83 c4 10 add $0x10,%esp 10eebb: 8b 55 f4 mov -0xc(%ebp),%edx 10eebe: 85 d2 test %edx,%edx
10eec0: 75 36 jne 10eef8 <rtems_task_set_priority+0x70>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10eec2: 8b 50 14 mov 0x14(%eax),%edx 10eec5: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10eec7: 85 db test %ebx,%ebx
10eec9: 74 1c je 10eee7 <rtems_task_set_priority+0x5f>
the_thread->real_priority = new_priority;
10eecb: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10eece: 8b 48 1c mov 0x1c(%eax),%ecx 10eed1: 85 c9 test %ecx,%ecx
10eed3: 74 05 je 10eeda <rtems_task_set_priority+0x52>
10eed5: 3b 58 14 cmp 0x14(%eax),%ebx
10eed8: 73 0d jae 10eee7 <rtems_task_set_priority+0x5f><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10eeda: 52 push %edx 10eedb: 6a 00 push $0x0 10eedd: 53 push %ebx 10eede: 50 push %eax 10eedf: e8 54 1b 00 00 call 110a38 <_Thread_Change_priority> 10eee4: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10eee7: e8 84 1f 00 00 call 110e70 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10eeec: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10eeee: 8d 65 f8 lea -0x8(%ebp),%esp 10eef1: 5b pop %ebx 10eef2: 5e pop %esi 10eef3: c9 leave 10eef4: c3 ret 10eef5: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10eef8: b8 04 00 00 00 mov $0x4,%eax
}
10eefd: 8d 65 f8 lea -0x8(%ebp),%esp 10ef00: 5b pop %ebx 10ef01: 5e pop %esi 10ef02: c9 leave 10ef03: 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;
10ef04: b8 13 00 00 00 mov $0x13,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ef09: 8d 65 f8 lea -0x8(%ebp),%esp 10ef0c: 5b pop %ebx 10ef0d: 5e pop %esi 10ef0e: c9 leave 10ef0f: 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;
10ef10: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ef15: 8d 65 f8 lea -0x8(%ebp),%esp 10ef18: 5b pop %ebx 10ef19: 5e pop %esi 10ef1a: c9 leave 10ef1b: c3 ret
0010afec <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
10afec: 55 push %ebp 10afed: 89 e5 mov %esp,%ebp 10afef: 53 push %ebx 10aff0: 83 ec 14 sub $0x14,%esp 10aff3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10aff6: 85 db test %ebx,%ebx
10aff8: 74 4e je 10b048 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10affa: 83 ec 08 sub $0x8,%esp 10affd: 8d 45 f4 lea -0xc(%ebp),%eax 10b000: 50 push %eax 10b001: ff 75 08 pushl 0x8(%ebp) 10b004: e8 9b 1d 00 00 call 10cda4 <_Thread_Get>
switch ( location ) {
10b009: 83 c4 10 add $0x10,%esp 10b00c: 8b 55 f4 mov -0xc(%ebp),%edx 10b00f: 85 d2 test %edx,%edx
10b011: 75 29 jne 10b03c <rtems_task_start+0x50>
case OBJECTS_LOCAL:
if ( _Thread_Start(
10b013: 83 ec 0c sub $0xc,%esp 10b016: ff 75 10 pushl 0x10(%ebp) 10b019: 6a 00 push $0x0 10b01b: 53 push %ebx 10b01c: 6a 00 push $0x0 10b01e: 50 push %eax 10b01f: e8 e8 26 00 00 call 10d70c <_Thread_Start> 10b024: 83 c4 20 add $0x20,%esp 10b027: 84 c0 test %al,%al
10b029: 75 29 jne 10b054 <rtems_task_start+0x68>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10b02b: e8 50 1d 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10b030: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b035: 8b 5d fc mov -0x4(%ebp),%ebx 10b038: c9 leave 10b039: c3 ret 10b03a: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b03c: b8 04 00 00 00 mov $0x4,%eax
}
10b041: 8b 5d fc mov -0x4(%ebp),%ebx 10b044: c9 leave 10b045: c3 ret 10b046: 66 90 xchg %ax,%ax
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
10b048: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b04d: 8b 5d fc mov -0x4(%ebp),%ebx 10b050: c9 leave 10b051: c3 ret 10b052: 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();
10b054: e8 27 1d 00 00 call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b059: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b05b: 8b 5d fc mov -0x4(%ebp),%ebx 10b05e: c9 leave 10b05f: c3 ret
001107d4 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
1107d4: 55 push %ebp 1107d5: 89 e5 mov %esp,%ebp 1107d7: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
1107da: 8d 45 f4 lea -0xc(%ebp),%eax 1107dd: 50 push %eax 1107de: ff 75 08 pushl 0x8(%ebp) 1107e1: e8 be c5 ff ff call 10cda4 <_Thread_Get>
switch ( location ) {
1107e6: 83 c4 10 add $0x10,%esp 1107e9: 8b 55 f4 mov -0xc(%ebp),%edx 1107ec: 85 d2 test %edx,%edx
1107ee: 74 08 je 1107f8 <rtems_task_suspend+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1107f0: b8 04 00 00 00 mov $0x4,%eax
}
1107f5: c9 leave 1107f6: c3 ret 1107f7: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
1107f8: f6 40 10 02 testb $0x2,0x10(%eax)
1107fc: 74 0e je 11080c <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1107fe: e8 7d c5 ff ff call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
110803: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110808: c9 leave 110809: c3 ret 11080a: 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 );
11080c: 83 ec 08 sub $0x8,%esp 11080f: 6a 02 push $0x2 110811: 50 push %eax 110812: e8 8d cd ff ff call 10d5a4 <_Thread_Set_state>
_Thread_Enable_dispatch();
110817: e8 64 c5 ff ff call 10cd80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11081c: 83 c4 10 add $0x10,%esp 11081f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110821: c9 leave 110822: c3 ret
0010bb48 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10bb48: 55 push %ebp 10bb49: 89 e5 mov %esp,%ebp 10bb4b: 57 push %edi 10bb4c: 56 push %esi 10bb4d: 53 push %ebx 10bb4e: 83 ec 1c sub $0x1c,%esp 10bb51: 8b 5d 0c mov 0xc(%ebp),%ebx 10bb54: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10bb57: 85 db test %ebx,%ebx
10bb59: 0f 84 9d 00 00 00 je 10bbfc <rtems_task_variable_add+0xb4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10bb5f: 83 ec 08 sub $0x8,%esp 10bb62: 8d 45 e4 lea -0x1c(%ebp),%eax 10bb65: 50 push %eax 10bb66: ff 75 08 pushl 0x8(%ebp) 10bb69: e8 ce 1e 00 00 call 10da3c <_Thread_Get> 10bb6e: 89 c6 mov %eax,%esi
switch (location) {
10bb70: 83 c4 10 add $0x10,%esp 10bb73: 8b 45 e4 mov -0x1c(%ebp),%eax 10bb76: 85 c0 test %eax,%eax
10bb78: 74 0e je 10bb88 <rtems_task_variable_add+0x40>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb7a: b8 04 00 00 00 mov $0x4,%eax
}
10bb7f: 8d 65 f4 lea -0xc(%ebp),%esp 10bb82: 5b pop %ebx 10bb83: 5e pop %esi 10bb84: 5f pop %edi 10bb85: c9 leave 10bb86: c3 ret 10bb87: 90 nop
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10bb88: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
while (tvp) {
10bb8e: 85 c0 test %eax,%eax
10bb90: 75 44 jne 10bbd6 <rtems_task_variable_add+0x8e>
10bb92: 66 90 xchg %ax,%ax
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
10bb94: 83 ec 0c sub $0xc,%esp 10bb97: 6a 14 push $0x14 10bb99: e8 56 2e 00 00 call 10e9f4 <_Workspace_Allocate>
if (new == NULL) {
10bb9e: 83 c4 10 add $0x10,%esp 10bba1: 85 c0 test %eax,%eax
10bba3: 74 4b je 10bbf0 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10bba5: 8b 13 mov (%ebx),%edx 10bba7: 89 50 08 mov %edx,0x8(%eax)
new->ptr = ptr;
10bbaa: 89 58 04 mov %ebx,0x4(%eax)
new->dtor = dtor;
10bbad: 89 78 10 mov %edi,0x10(%eax)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10bbb0: 8b 96 f4 00 00 00 mov 0xf4(%esi),%edx 10bbb6: 89 10 mov %edx,(%eax)
the_thread->task_variables = new;
10bbb8: 89 86 f4 00 00 00 mov %eax,0xf4(%esi)
_Thread_Enable_dispatch();
10bbbe: e8 55 1e 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bbc3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bbc5: 8d 65 f4 lea -0xc(%ebp),%esp 10bbc8: 5b pop %ebx 10bbc9: 5e pop %esi 10bbca: 5f pop %edi 10bbcb: c9 leave 10bbcc: c3 ret 10bbcd: 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;
10bbd0: 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) {
10bbd2: 85 c0 test %eax,%eax
10bbd4: 74 be je 10bb94 <rtems_task_variable_add+0x4c>
if (tvp->ptr == ptr) {
10bbd6: 39 58 04 cmp %ebx,0x4(%eax)
10bbd9: 75 f5 jne 10bbd0 <rtems_task_variable_add+0x88>
tvp->dtor = dtor;
10bbdb: 89 78 10 mov %edi,0x10(%eax)
_Thread_Enable_dispatch();
10bbde: e8 35 1e 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bbe3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bbe5: 8d 65 f4 lea -0xc(%ebp),%esp 10bbe8: 5b pop %ebx 10bbe9: 5e pop %esi 10bbea: 5f pop %edi 10bbeb: c9 leave 10bbec: c3 ret 10bbed: 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();
10bbf0: e8 23 1e 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
10bbf5: b8 1a 00 00 00 mov $0x1a,%eax 10bbfa: eb 83 jmp 10bb7f <rtems_task_variable_add+0x37>
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10bbfc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc01: 8d 65 f4 lea -0xc(%ebp),%esp 10bc04: 5b pop %ebx 10bc05: 5e pop %esi 10bc06: 5f pop %edi 10bc07: c9 leave 10bc08: c3 ret
0010bc0c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10bc0c: 55 push %ebp 10bc0d: 89 e5 mov %esp,%ebp 10bc0f: 53 push %ebx 10bc10: 83 ec 14 sub $0x14,%esp 10bc13: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10bc16: 85 db test %ebx,%ebx
10bc18: 74 76 je 10bc90 <rtems_task_variable_delete+0x84>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10bc1a: 83 ec 08 sub $0x8,%esp 10bc1d: 8d 45 f4 lea -0xc(%ebp),%eax 10bc20: 50 push %eax 10bc21: ff 75 08 pushl 0x8(%ebp) 10bc24: e8 13 1e 00 00 call 10da3c <_Thread_Get>
switch (location) {
10bc29: 83 c4 10 add $0x10,%esp 10bc2c: 8b 55 f4 mov -0xc(%ebp),%edx 10bc2f: 85 d2 test %edx,%edx
10bc31: 74 0d je 10bc40 <rtems_task_variable_delete+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bc33: b8 04 00 00 00 mov $0x4,%eax
}
10bc38: 8b 5d fc mov -0x4(%ebp),%ebx 10bc3b: c9 leave 10bc3c: c3 ret 10bc3d: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10bc40: 8b 88 f4 00 00 00 mov 0xf4(%eax),%ecx
while (tvp) {
10bc46: 85 c9 test %ecx,%ecx
10bc48: 74 17 je 10bc61 <rtems_task_variable_delete+0x55>
if (tvp->ptr == ptr) {
10bc4a: 39 59 04 cmp %ebx,0x4(%ecx)
10bc4d: 75 0c jne 10bc5b <rtems_task_variable_delete+0x4f>
10bc4f: eb 49 jmp 10bc9a <rtems_task_variable_delete+0x8e> 10bc51: 8d 76 00 lea 0x0(%esi),%esi 10bc54: 39 5a 04 cmp %ebx,0x4(%edx)
10bc57: 74 17 je 10bc70 <rtems_task_variable_delete+0x64>
10bc59: 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;
10bc5b: 8b 11 mov (%ecx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10bc5d: 85 d2 test %edx,%edx
10bc5f: 75 f3 jne 10bc54 <rtems_task_variable_delete+0x48><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10bc61: e8 b2 1d 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10bc66: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc6b: 8b 5d fc mov -0x4(%ebp),%ebx 10bc6e: c9 leave 10bc6f: c3 ret
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
10bc70: 8b 1a mov (%edx),%ebx 10bc72: 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 );
10bc74: 83 ec 08 sub $0x8,%esp 10bc77: 52 push %edx 10bc78: 50 push %eax 10bc79: e8 b2 00 00 00 call 10bd30 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10bc7e: e8 95 1d 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bc83: 83 c4 10 add $0x10,%esp 10bc86: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc88: 8b 5d fc mov -0x4(%ebp),%ebx 10bc8b: c9 leave 10bc8c: c3 ret 10bc8d: 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;
10bc90: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc95: 8b 5d fc mov -0x4(%ebp),%ebx 10bc98: c9 leave 10bc99: 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;
10bc9a: 8b 11 mov (%ecx),%edx 10bc9c: 89 90 f4 00 00 00 mov %edx,0xf4(%eax) 10bca2: 89 ca mov %ecx,%edx 10bca4: eb ce jmp 10bc74 <rtems_task_variable_delete+0x68>
0010bca8 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10bca8: 55 push %ebp 10bca9: 89 e5 mov %esp,%ebp 10bcab: 56 push %esi 10bcac: 53 push %ebx 10bcad: 83 ec 10 sub $0x10,%esp 10bcb0: 8b 5d 0c mov 0xc(%ebp),%ebx 10bcb3: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10bcb6: 85 db test %ebx,%ebx
10bcb8: 74 56 je 10bd10 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10bcba: 85 f6 test %esi,%esi
10bcbc: 74 52 je 10bd10 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10bcbe: 83 ec 08 sub $0x8,%esp 10bcc1: 8d 45 f4 lea -0xc(%ebp),%eax 10bcc4: 50 push %eax 10bcc5: ff 75 08 pushl 0x8(%ebp) 10bcc8: e8 6f 1d 00 00 call 10da3c <_Thread_Get>
switch (location) {
10bccd: 83 c4 10 add $0x10,%esp 10bcd0: 8b 55 f4 mov -0xc(%ebp),%edx 10bcd3: 85 d2 test %edx,%edx
10bcd5: 75 2d jne 10bd04 <rtems_task_variable_get+0x5c>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10bcd7: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
10bcdd: 85 c0 test %eax,%eax
10bcdf: 75 09 jne 10bcea <rtems_task_variable_get+0x42>
10bce1: eb 39 jmp 10bd1c <rtems_task_variable_get+0x74> 10bce3: 90 nop
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10bce4: 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) {
10bce6: 85 c0 test %eax,%eax
10bce8: 74 32 je 10bd1c <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10bcea: 39 58 04 cmp %ebx,0x4(%eax)
10bced: 75 f5 jne 10bce4 <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;
10bcef: 8b 40 0c mov 0xc(%eax),%eax 10bcf2: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10bcf4: e8 1f 1d 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bcf9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bcfb: 8d 65 f8 lea -0x8(%ebp),%esp 10bcfe: 5b pop %ebx 10bcff: 5e pop %esi 10bd00: c9 leave 10bd01: c3 ret 10bd02: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bd04: b8 04 00 00 00 mov $0x4,%eax
}
10bd09: 8d 65 f8 lea -0x8(%ebp),%esp 10bd0c: 5b pop %ebx 10bd0d: 5e pop %esi 10bd0e: c9 leave 10bd0f: c3 ret
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
10bd10: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd15: 8d 65 f8 lea -0x8(%ebp),%esp 10bd18: 5b pop %ebx 10bd19: 5e pop %esi 10bd1a: c9 leave 10bd1b: c3 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10bd1c: e8 f7 1c 00 00 call 10da18 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10bd21: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd26: 8d 65 f8 lea -0x8(%ebp),%esp 10bd29: 5b pop %ebx 10bd2a: 5e pop %esi 10bd2b: c9 leave 10bd2c: c3 ret
0010bea8 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10bea8: 55 push %ebp 10bea9: 89 e5 mov %esp,%ebp 10beab: 53 push %ebx 10beac: 83 ec 14 sub $0x14,%esp 10beaf: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10beb2: 80 3d 9c 95 12 00 00 cmpb $0x0,0x12959c
10beb9: 0f 84 a9 00 00 00 je 10bf68 <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10bebf: 85 db test %ebx,%ebx
10bec1: 0f 84 ad 00 00 00 je 10bf74 <rtems_task_wake_when+0xcc>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10bec7: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10bece: 83 ec 0c sub $0xc,%esp 10bed1: 53 push %ebx 10bed2: e8 81 f4 ff ff call 10b358 <_TOD_Validate> 10bed7: 83 c4 10 add $0x10,%esp 10beda: 84 c0 test %al,%al
10bedc: 75 0a jne 10bee8 <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;
10bede: b8 14 00 00 00 mov $0x14,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bee3: 8b 5d fc mov -0x4(%ebp),%ebx 10bee6: c9 leave 10bee7: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10bee8: 83 ec 0c sub $0xc,%esp 10beeb: 53 push %ebx 10beec: e8 db f3 ff ff call 10b2cc <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
10bef1: 83 c4 10 add $0x10,%esp 10bef4: 3b 05 28 96 12 00 cmp 0x129628,%eax
10befa: 76 e2 jbe 10bede <rtems_task_wake_when+0x36>
10befc: 8b 15 8c 95 12 00 mov 0x12958c,%edx 10bf02: 42 inc %edx 10bf03: 89 15 8c 95 12 00 mov %edx,0x12958c
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10bf09: 83 ec 08 sub $0x8,%esp 10bf0c: 6a 10 push $0x10 10bf0e: ff 35 38 9b 12 00 pushl 0x129b38 10bf14: 89 45 f4 mov %eax,-0xc(%ebp) 10bf17: e8 50 25 00 00 call 10e46c <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
10bf1c: 8b 15 38 9b 12 00 mov 0x129b38,%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(
10bf22: 8b 4a 08 mov 0x8(%edx),%ecx
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10bf25: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
10bf2c: c7 42 64 94 da 10 00 movl $0x10da94,0x64(%edx)
the_watchdog->id = id;
10bf33: 89 4a 68 mov %ecx,0x68(%edx)
the_watchdog->user_data = user_data;
10bf36: 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(
10bf3d: 8b 45 f4 mov -0xc(%ebp),%eax 10bf40: 2b 05 28 96 12 00 sub 0x129628,%eax 10bf46: 89 42 54 mov %eax,0x54(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
10bf49: 58 pop %eax 10bf4a: 59 pop %ecx 10bf4b: 83 c2 48 add $0x48,%edx 10bf4e: 52 push %edx 10bf4f: 68 54 96 12 00 push $0x129654 10bf54: e8 db 2a 00 00 call 10ea34 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
10bf59: e8 ea 1c 00 00 call 10dc48 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bf5e: 83 c4 10 add $0x10,%esp 10bf61: 31 c0 xor %eax,%eax 10bf63: e9 7b ff ff ff jmp 10bee3 <rtems_task_wake_when+0x3b>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
10bf68: b8 0b 00 00 00 mov $0xb,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bf6d: 8b 5d fc mov -0x4(%ebp),%ebx 10bf70: c9 leave 10bf71: c3 ret 10bf72: 66 90 xchg %ax,%ax
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10bf74: b8 09 00 00 00 mov $0x9,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bf79: 8b 5d fc mov -0x4(%ebp),%ebx 10bf7c: c9 leave 10bf7d: c3 ret
00117cfc <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
117cfc: 55 push %ebp 117cfd: 89 e5 mov %esp,%ebp 117cff: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
117d02: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
117d05: 50 push %eax 117d06: ff 75 08 pushl 0x8(%ebp) 117d09: 68 e0 2a 14 00 push $0x142ae0 117d0e: e8 e9 2b 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
117d13: 83 c4 10 add $0x10,%esp 117d16: 8b 55 f4 mov -0xc(%ebp),%edx 117d19: 85 d2 test %edx,%edx
117d1b: 74 07 je 117d24 <rtems_timer_cancel+0x28>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117d1d: b8 04 00 00 00 mov $0x4,%eax
}
117d22: c9 leave 117d23: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
117d24: 83 78 38 04 cmpl $0x4,0x38(%eax)
117d28: 74 0f je 117d39 <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
117d2a: 83 ec 0c sub $0xc,%esp 117d2d: 83 c0 10 add $0x10,%eax 117d30: 50 push %eax 117d31: e8 16 48 00 00 call 11c54c <_Watchdog_Remove> 117d36: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
117d39: e8 46 37 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117d3e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117d40: c9 leave 117d41: c3 ret
0010b4d8 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
10b4d8: 55 push %ebp 10b4d9: 89 e5 mov %esp,%ebp 10b4db: 57 push %edi 10b4dc: 56 push %esi 10b4dd: 53 push %ebx 10b4de: 83 ec 0c sub $0xc,%esp 10b4e1: 8b 5d 08 mov 0x8(%ebp),%ebx 10b4e4: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10b4e7: 85 db test %ebx,%ebx
10b4e9: 74 6d je 10b558 <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10b4eb: 85 f6 test %esi,%esi
10b4ed: 0f 84 89 00 00 00 je 10b57c <rtems_timer_create+0xa4>
10b4f3: a1 cc 91 12 00 mov 0x1291cc,%eax 10b4f8: 40 inc %eax 10b4f9: a3 cc 91 12 00 mov %eax,0x1291cc
* 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 );
10b4fe: 83 ec 0c sub $0xc,%esp 10b501: 68 c0 9b 12 00 push $0x129bc0 10b506: e8 f9 0d 00 00 call 10c304 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10b50b: 83 c4 10 add $0x10,%esp 10b50e: 85 c0 test %eax,%eax
10b510: 74 56 je 10b568 <rtems_timer_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10b512: 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;
10b519: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10b520: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10b527: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10b52e: 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 ),
10b535: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b538: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b53b: 8b 0d dc 9b 12 00 mov 0x129bdc,%ecx 10b541: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b544: 89 58 0c mov %ebx,0xc(%eax)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10b547: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10b549: e8 7a 1d 00 00 call 10d2c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b54e: 31 c0 xor %eax,%eax
}
10b550: 8d 65 f4 lea -0xc(%ebp),%esp 10b553: 5b pop %ebx 10b554: 5e pop %esi 10b555: 5f pop %edi 10b556: c9 leave 10b557: c3 ret
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b558: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b55d: 8d 65 f4 lea -0xc(%ebp),%esp 10b560: 5b pop %ebx 10b561: 5e pop %esi 10b562: 5f pop %edi 10b563: c9 leave 10b564: c3 ret 10b565: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
10b568: e8 5b 1d 00 00 call 10d2c8 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b56d: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b572: 8d 65 f4 lea -0xc(%ebp),%esp 10b575: 5b pop %ebx 10b576: 5e pop %esi 10b577: 5f pop %edi 10b578: c9 leave 10b579: c3 ret 10b57a: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b57c: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b581: 8d 65 f4 lea -0xc(%ebp),%esp 10b584: 5b pop %ebx 10b585: 5e pop %esi 10b586: 5f pop %edi 10b587: c9 leave 10b588: c3 ret
00117df8 <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
rtems_id id
)
{
117df8: 55 push %ebp 117df9: 89 e5 mov %esp,%ebp 117dfb: 53 push %ebx 117dfc: 83 ec 18 sub $0x18,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
117dff: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
117e02: 50 push %eax 117e03: ff 75 08 pushl 0x8(%ebp) 117e06: 68 e0 2a 14 00 push $0x142ae0 117e0b: e8 ec 2a 00 00 call 11a8fc <_Objects_Get> 117e10: 89 c3 mov %eax,%ebx
switch ( location ) {
117e12: 83 c4 10 add $0x10,%esp 117e15: 8b 4d f4 mov -0xc(%ebp),%ecx 117e18: 85 c9 test %ecx,%ecx
117e1a: 75 38 jne 117e54 <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
117e1c: 83 ec 08 sub $0x8,%esp 117e1f: 50 push %eax 117e20: 68 e0 2a 14 00 push $0x142ae0 117e25: e8 5e 26 00 00 call 11a488 <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
117e2a: 8d 43 10 lea 0x10(%ebx),%eax 117e2d: 89 04 24 mov %eax,(%esp) 117e30: e8 17 47 00 00 call 11c54c <_Watchdog_Remove>
*/
RTEMS_INLINE_ROUTINE void _Timer_Free (
Timer_Control *the_timer
)
{
_Objects_Free( &_Timer_Information, &the_timer->Object );
117e35: 58 pop %eax 117e36: 5a pop %edx 117e37: 53 push %ebx 117e38: 68 e0 2a 14 00 push $0x142ae0 117e3d: e8 3e 29 00 00 call 11a780 <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
117e42: e8 3d 36 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117e47: 83 c4 10 add $0x10,%esp 117e4a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117e4c: 8b 5d fc mov -0x4(%ebp),%ebx 117e4f: c9 leave 117e50: c3 ret 117e51: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117e54: b8 04 00 00 00 mov $0x4,%eax
}
117e59: 8b 5d fc mov -0x4(%ebp),%ebx 117e5c: c9 leave 117e5d: c3 ret
0010b58c <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10b58c: 55 push %ebp 10b58d: 89 e5 mov %esp,%ebp 10b58f: 57 push %edi 10b590: 56 push %esi 10b591: 53 push %ebx 10b592: 83 ec 2c sub $0x2c,%esp 10b595: 8b 5d 0c mov 0xc(%ebp),%ebx 10b598: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10b59b: 85 db test %ebx,%ebx
10b59d: 0f 84 99 00 00 00 je 10b63c <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10b5a3: 85 f6 test %esi,%esi
10b5a5: 0f 84 b1 00 00 00 je 10b65c <rtems_timer_fire_after+0xd0>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
10b5ab: 57 push %edi
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
10b5ac: 8d 45 e4 lea -0x1c(%ebp),%eax 10b5af: 50 push %eax 10b5b0: ff 75 08 pushl 0x8(%ebp) 10b5b3: 68 c0 9b 12 00 push $0x129bc0 10b5b8: e8 fb 11 00 00 call 10c7b8 <_Objects_Get> 10b5bd: 89 c7 mov %eax,%edi
switch ( location ) {
10b5bf: 83 c4 10 add $0x10,%esp 10b5c2: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b5c5: 85 c9 test %ecx,%ecx
10b5c7: 74 0f je 10b5d8 <rtems_timer_fire_after+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b5c9: b8 04 00 00 00 mov $0x4,%eax
}
10b5ce: 8d 65 f4 lea -0xc(%ebp),%esp 10b5d1: 5b pop %ebx 10b5d2: 5e pop %esi 10b5d3: 5f pop %edi 10b5d4: c9 leave 10b5d5: c3 ret 10b5d6: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10b5d8: 8d 50 10 lea 0x10(%eax),%edx 10b5db: 83 ec 0c sub $0xc,%esp 10b5de: 52 push %edx 10b5df: 89 55 d4 mov %edx,-0x2c(%ebp) 10b5e2: e8 95 2b 00 00 call 10e17c <_Watchdog_Remove>
_ISR_Disable( level );
10b5e7: 9c pushf 10b5e8: fa cli 10b5e9: 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 ) {
10b5ea: 83 c4 10 add $0x10,%esp 10b5ed: 8b 57 18 mov 0x18(%edi),%edx 10b5f0: 85 d2 test %edx,%edx 10b5f2: 8b 55 d4 mov -0x2c(%ebp),%edx
10b5f5: 75 55 jne 10b64c <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;
10b5f7: 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;
10b5fe: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b605: 89 77 2c mov %esi,0x2c(%edi)
the_watchdog->id = id;
10b608: 8b 4d 08 mov 0x8(%ebp),%ecx 10b60b: 89 4f 30 mov %ecx,0x30(%edi)
the_watchdog->user_data = user_data;
10b60e: 8b 4d 14 mov 0x14(%ebp),%ecx 10b611: 89 4f 34 mov %ecx,0x34(%edi)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10b614: 50 push %eax 10b615: 9d popf
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b616: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b619: 83 ec 08 sub $0x8,%esp 10b61c: 52 push %edx 10b61d: 68 a0 92 12 00 push $0x1292a0 10b622: e8 15 2a 00 00 call 10e03c <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10b627: e8 9c 1c 00 00 call 10d2c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b62c: 83 c4 10 add $0x10,%esp 10b62f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b631: 8d 65 f4 lea -0xc(%ebp),%esp 10b634: 5b pop %ebx 10b635: 5e pop %esi 10b636: 5f pop %edi 10b637: c9 leave 10b638: c3 ret 10b639: 8d 76 00 lea 0x0(%esi),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
10b63c: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b641: 8d 65 f4 lea -0xc(%ebp),%esp 10b644: 5b pop %ebx 10b645: 5e pop %esi 10b646: 5f pop %edi 10b647: c9 leave 10b648: c3 ret 10b649: 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 );
10b64c: 50 push %eax 10b64d: 9d popf
_Thread_Enable_dispatch();
10b64e: e8 75 1c 00 00 call 10d2c8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b653: 31 c0 xor %eax,%eax 10b655: e9 74 ff ff ff jmp 10b5ce <rtems_timer_fire_after+0x42> 10b65a: 66 90 xchg %ax,%ax
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
10b65c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b661: 8d 65 f4 lea -0xc(%ebp),%esp 10b664: 5b pop %ebx 10b665: 5e pop %esi 10b666: 5f pop %edi 10b667: c9 leave 10b668: c3 ret
00117f40 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
117f40: 55 push %ebp 117f41: 89 e5 mov %esp,%ebp 117f43: 57 push %edi 117f44: 56 push %esi 117f45: 53 push %ebx 117f46: 83 ec 2c sub $0x2c,%esp 117f49: 8b 75 08 mov 0x8(%ebp),%esi 117f4c: 8b 7d 0c mov 0xc(%ebp),%edi 117f4f: 8b 5d 10 mov 0x10(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
117f52: 80 3d bc 20 14 00 00 cmpb $0x0,0x1420bc
117f59: 75 0d jne 117f68 <rtems_timer_fire_when+0x28>
return RTEMS_NOT_DEFINED;
117f5b: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117f60: 8d 65 f4 lea -0xc(%ebp),%esp 117f63: 5b pop %ebx 117f64: 5e pop %esi 117f65: 5f pop %edi 117f66: c9 leave 117f67: c3 ret
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
117f68: 83 ec 0c sub $0xc,%esp 117f6b: 57 push %edi 117f6c: e8 93 d4 ff ff call 115404 <_TOD_Validate> 117f71: 83 c4 10 add $0x10,%esp 117f74: 84 c0 test %al,%al
117f76: 74 1e je 117f96 <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
117f78: 85 db test %ebx,%ebx
117f7a: 0f 84 a4 00 00 00 je 118024 <rtems_timer_fire_when+0xe4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
117f80: 83 ec 0c sub $0xc,%esp 117f83: 57 push %edi 117f84: e8 ef d3 ff ff call 115378 <_TOD_To_seconds> 117f89: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
117f8b: 83 c4 10 add $0x10,%esp 117f8e: 3b 05 48 21 14 00 cmp 0x142148,%eax
117f94: 77 0e ja 117fa4 <rtems_timer_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
117f96: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117f9b: 8d 65 f4 lea -0xc(%ebp),%esp 117f9e: 5b pop %ebx 117f9f: 5e pop %esi 117fa0: 5f pop %edi 117fa1: c9 leave 117fa2: c3 ret 117fa3: 90 nop 117fa4: 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 );
117fa5: 8d 45 e4 lea -0x1c(%ebp),%eax 117fa8: 50 push %eax 117fa9: 56 push %esi 117faa: 68 e0 2a 14 00 push $0x142ae0 117faf: e8 48 29 00 00 call 11a8fc <_Objects_Get>
switch ( location ) {
117fb4: 83 c4 10 add $0x10,%esp 117fb7: 8b 4d e4 mov -0x1c(%ebp),%ecx 117fba: 85 c9 test %ecx,%ecx
117fbc: 75 5a jne 118018 <rtems_timer_fire_when+0xd8><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
117fbe: 8d 48 10 lea 0x10(%eax),%ecx 117fc1: 83 ec 0c sub $0xc,%esp 117fc4: 51 push %ecx 117fc5: 89 45 d0 mov %eax,-0x30(%ebp) 117fc8: 89 4d d4 mov %ecx,-0x2c(%ebp) 117fcb: e8 7c 45 00 00 call 11c54c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
117fd0: 8b 55 d0 mov -0x30(%ebp),%edx 117fd3: 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;
117fda: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
117fe1: 89 5a 2c mov %ebx,0x2c(%edx)
the_watchdog->id = id;
117fe4: 89 72 30 mov %esi,0x30(%edx)
the_watchdog->user_data = user_data;
117fe7: 8b 45 14 mov 0x14(%ebp),%eax 117fea: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
117fed: 2b 3d 48 21 14 00 sub 0x142148,%edi 117ff3: 89 7a 1c mov %edi,0x1c(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
117ff6: 58 pop %eax 117ff7: 5a pop %edx 117ff8: 8b 4d d4 mov -0x2c(%ebp),%ecx 117ffb: 51 push %ecx 117ffc: 68 74 21 14 00 push $0x142174 118001: e8 06 44 00 00 call 11c40c <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
118006: e8 79 34 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11800b: 83 c4 10 add $0x10,%esp 11800e: 31 c0 xor %eax,%eax 118010: e9 4b ff ff ff jmp 117f60 <rtems_timer_fire_when+0x20> 118015: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118018: b8 04 00 00 00 mov $0x4,%eax 11801d: e9 3e ff ff ff jmp 117f60 <rtems_timer_fire_when+0x20> 118022: 66 90 xchg %ax,%ax
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118024: b8 09 00 00 00 mov $0x9,%eax 118029: e9 32 ff ff ff jmp 117f60 <rtems_timer_fire_when+0x20>
001186bc <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
1186bc: 55 push %ebp 1186bd: 89 e5 mov %esp,%ebp 1186bf: 56 push %esi 1186c0: 53 push %ebx 1186c1: 83 ec 10 sub $0x10,%esp 1186c4: 8b 45 08 mov 0x8(%ebp),%eax 1186c7: 85 c0 test %eax,%eax
1186c9: 74 41 je 11870c <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1186cb: 0f b6 15 f4 99 13 00 movzbl 0x1399f4,%edx
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
1186d2: 39 d0 cmp %edx,%eax
1186d4: 76 42 jbe 118718 <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 )
1186d6: 40 inc %eax
1186d7: 75 33 jne 11870c <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1186d9: 31 f6 xor %esi,%esi 1186db: 8b 15 ac 20 14 00 mov 0x1420ac,%edx 1186e1: 42 inc %edx 1186e2: 89 15 ac 20 14 00 mov %edx,0x1420ac
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1186e8: 8a 1d e0 d9 13 00 mov 0x13d9e0,%bl
initialized = true;
1186ee: c6 05 e0 d9 13 00 01 movb $0x1,0x13d9e0
_Thread_Enable_dispatch();
1186f5: e8 8a 2d 00 00 call 11b484 <_Thread_Enable_dispatch>
if ( tmpInitialized )
1186fa: 84 db test %bl,%bl
1186fc: 74 1e je 11871c <rtems_timer_initiate_server+0x60>
return RTEMS_INCORRECT_STATE;
1186fe: b8 0e 00 00 00 mov $0xe,%eax
initialized = false;
}
#endif
return status;
}
118703: 8d 65 f8 lea -0x8(%ebp),%esp 118706: 5b pop %ebx 118707: 5e pop %esi 118708: c9 leave 118709: c3 ret 11870a: 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;
11870c: b8 13 00 00 00 mov $0x13,%eax
initialized = false;
}
#endif
return status;
}
118711: 8d 65 f8 lea -0x8(%ebp),%esp 118714: 5b pop %ebx 118715: 5e pop %esi 118716: c9 leave 118717: c3 ret 118718: 89 c6 mov %eax,%esi 11871a: eb bf jmp 1186db <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(
11871c: 83 ec 08 sub $0x8,%esp 11871f: 8d 45 f4 lea -0xc(%ebp),%eax 118722: 50 push %eax 118723: 8b 45 10 mov 0x10(%ebp),%eax 118726: 80 cc 80 or $0x80,%ah 118729: 50 push %eax 11872a: 68 00 01 00 00 push $0x100 11872f: ff 75 0c pushl 0xc(%ebp) 118732: 56 push %esi 118733: 68 45 4d 49 54 push $0x54494d45 118738: e8 e3 ec ff ff call 117420 <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) {
11873d: 83 c4 20 add $0x20,%esp 118740: 85 c0 test %eax,%eax
118742: 74 10 je 118754 <rtems_timer_initiate_server+0x98>
initialized = false;
118744: c6 05 e0 d9 13 00 00 movb $0x0,0x13d9e0
initialized = false;
}
#endif
return status;
}
11874b: 8d 65 f8 lea -0x8(%ebp),%esp 11874e: 5b pop %ebx 11874f: 5e pop %esi 118750: c9 leave 118751: c3 ret 118752: 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)
118754: 8b 45 f4 mov -0xc(%ebp),%eax
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
118757: 0f b7 c8 movzwl %ax,%ecx 11875a: 8b 15 5c 20 14 00 mov 0x14205c,%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(
118760: 8b 14 8a mov (%edx,%ecx,4),%edx 118763: 89 15 60 d9 13 00 mov %edx,0x13d960
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118769: c7 05 90 d9 13 00 94 movl $0x13d994,0x13d990
118770: d9 13 00 head->previous = NULL;
118773: c7 05 94 d9 13 00 00 movl $0x0,0x13d994
11877a: 00 00 00 tail->previous = head;
11877d: c7 05 98 d9 13 00 90 movl $0x13d990,0x13d998
118784: d9 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118787: c7 05 c8 d9 13 00 cc movl $0x13d9cc,0x13d9c8
11878e: d9 13 00 head->previous = NULL;
118791: c7 05 cc d9 13 00 00 movl $0x0,0x13d9cc
118798: 00 00 00 tail->previous = head;
11879b: c7 05 d0 d9 13 00 c8 movl $0x13d9c8,0x13d9d0
1187a2: d9 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1187a5: c7 05 70 d9 13 00 00 movl $0x0,0x13d970
1187ac: 00 00 00 the_watchdog->routine = routine;
1187af: c7 05 84 d9 13 00 d0 movl $0x11b2d0,0x13d984
1187b6: b2 11 00 the_watchdog->id = id;
1187b9: a3 88 d9 13 00 mov %eax,0x13d988
the_watchdog->user_data = user_data;
1187be: c7 05 8c d9 13 00 00 movl $0x0,0x13d98c
1187c5: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1187c8: c7 05 a8 d9 13 00 00 movl $0x0,0x13d9a8
1187cf: 00 00 00 the_watchdog->routine = routine;
1187d2: c7 05 bc d9 13 00 d0 movl $0x11b2d0,0x13d9bc
1187d9: b2 11 00 the_watchdog->id = id;
1187dc: a3 c0 d9 13 00 mov %eax,0x13d9c0
the_watchdog->user_data = user_data;
1187e1: c7 05 c4 d9 13 00 00 movl $0x0,0x13d9c4
1187e8: 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;
1187eb: c7 05 64 d9 13 00 8c movl $0x11858c,0x13d964
1187f2: 85 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1187f5: 8b 15 e4 21 14 00 mov 0x1421e4,%edx 1187fb: 89 15 9c d9 13 00 mov %edx,0x13d99c
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
118801: 8b 15 48 21 14 00 mov 0x142148,%edx 118807: 89 15 d4 d9 13 00 mov %edx,0x13d9d4
ts->insert_chain = NULL;
11880d: c7 05 d8 d9 13 00 00 movl $0x0,0x13d9d8
118814: 00 00 00 ts->active = false;
118817: c6 05 dc d9 13 00 00 movb $0x0,0x13d9dc
/*
* The default timer server is now available.
*/
_Timer_server = ts;
11881e: c7 05 20 2b 14 00 60 movl $0x13d960,0x142b20
118825: d9 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
118828: 53 push %ebx 118829: 68 60 d9 13 00 push $0x13d960 11882e: 68 e0 83 11 00 push $0x1183e0 118833: 50 push %eax 118834: e8 a7 f2 ff ff call 117ae0 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
118839: 83 c4 10 add $0x10,%esp 11883c: e9 d0 fe ff ff jmp 118711 <rtems_timer_initiate_server+0x55>
001180b8 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
1180b8: 55 push %ebp 1180b9: 89 e5 mov %esp,%ebp 1180bb: 56 push %esi 1180bc: 53 push %ebx 1180bd: 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 );
1180c0: 8d 45 f4 lea -0xc(%ebp),%eax 1180c3: 50 push %eax 1180c4: ff 75 08 pushl 0x8(%ebp) 1180c7: 68 e0 2a 14 00 push $0x142ae0 1180cc: e8 2b 28 00 00 call 11a8fc <_Objects_Get> 1180d1: 89 c3 mov %eax,%ebx
switch ( location ) {
1180d3: 83 c4 10 add $0x10,%esp 1180d6: 8b 45 f4 mov -0xc(%ebp),%eax 1180d9: 85 c0 test %eax,%eax
1180db: 74 0f je 1180ec <rtems_timer_reset+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1180dd: b8 04 00 00 00 mov $0x4,%eax
}
1180e2: 8d 65 f8 lea -0x8(%ebp),%esp 1180e5: 5b pop %ebx 1180e6: 5e pop %esi 1180e7: c9 leave 1180e8: c3 ret 1180e9: 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 ) {
1180ec: 8b 43 38 mov 0x38(%ebx),%eax 1180ef: 85 c0 test %eax,%eax
1180f1: 74 1d je 118110 <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 ) {
1180f3: 48 dec %eax
1180f4: 74 3a je 118130 <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;
1180f6: b8 0b 00 00 00 mov $0xb,%eax
}
_Thread_Enable_dispatch();
1180fb: 89 45 e4 mov %eax,-0x1c(%ebp) 1180fe: e8 81 33 00 00 call 11b484 <_Thread_Enable_dispatch>
return status;
118103: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118106: 8d 65 f8 lea -0x8(%ebp),%esp 118109: 5b pop %ebx 11810a: 5e pop %esi 11810b: c9 leave 11810c: c3 ret 11810d: 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 );
118110: 83 c3 10 add $0x10,%ebx 118113: 83 ec 0c sub $0xc,%esp 118116: 53 push %ebx 118117: e8 30 44 00 00 call 11c54c <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
11811c: 59 pop %ecx 11811d: 5e pop %esi 11811e: 53 push %ebx 11811f: 68 80 21 14 00 push $0x142180 118124: e8 e3 42 00 00 call 11c40c <_Watchdog_Insert> 118129: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
11812c: 31 c0 xor %eax,%eax 11812e: eb cb jmp 1180fb <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;
118130: 8b 35 20 2b 14 00 mov 0x142b20,%esi
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
118136: 83 ec 0c sub $0xc,%esp 118139: 8d 43 10 lea 0x10(%ebx),%eax 11813c: 50 push %eax 11813d: e8 0a 44 00 00 call 11c54c <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
118142: 58 pop %eax 118143: 5a pop %edx 118144: 53 push %ebx 118145: 56 push %esi 118146: ff 56 04 call *0x4(%esi) 118149: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
11814c: 31 c0 xor %eax,%eax 11814e: eb ab jmp 1180fb <rtems_timer_reset+0x43>
00118150 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118150: 55 push %ebp 118151: 89 e5 mov %esp,%ebp 118153: 57 push %edi 118154: 56 push %esi 118155: 53 push %ebx 118156: 83 ec 2c sub $0x2c,%esp 118159: 8b 7d 0c mov 0xc(%ebp),%edi 11815c: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
11815f: 8b 1d 20 2b 14 00 mov 0x142b20,%ebx
if ( !timer_server )
118165: 85 db test %ebx,%ebx
118167: 0f 84 9f 00 00 00 je 11820c <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
11816d: 85 f6 test %esi,%esi
11816f: 0f 84 a3 00 00 00 je 118218 <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118175: 85 ff test %edi,%edi
118177: 75 0f jne 118188 <rtems_timer_server_fire_after+0x38>
return RTEMS_INVALID_NUMBER;
118179: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11817e: 8d 65 f4 lea -0xc(%ebp),%esp 118181: 5b pop %ebx 118182: 5e pop %esi 118183: 5f pop %edi 118184: c9 leave 118185: c3 ret 118186: 66 90 xchg %ax,%ax 118188: 52 push %edx
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
118189: 8d 45 e4 lea -0x1c(%ebp),%eax 11818c: 50 push %eax 11818d: ff 75 08 pushl 0x8(%ebp) 118190: 68 e0 2a 14 00 push $0x142ae0 118195: e8 62 27 00 00 call 11a8fc <_Objects_Get> 11819a: 89 c2 mov %eax,%edx
switch ( location ) {
11819c: 83 c4 10 add $0x10,%esp 11819f: 8b 45 e4 mov -0x1c(%ebp),%eax 1181a2: 85 c0 test %eax,%eax
1181a4: 75 56 jne 1181fc <rtems_timer_server_fire_after+0xac>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1181a6: 83 ec 0c sub $0xc,%esp 1181a9: 8d 42 10 lea 0x10(%edx),%eax 1181ac: 50 push %eax 1181ad: 89 55 d4 mov %edx,-0x2c(%ebp) 1181b0: e8 97 43 00 00 call 11c54c <_Watchdog_Remove>
_ISR_Disable( level );
1181b5: 9c pushf 1181b6: fa cli 1181b7: 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 ) {
1181b8: 83 c4 10 add $0x10,%esp 1181bb: 8b 55 d4 mov -0x2c(%ebp),%edx 1181be: 8b 4a 18 mov 0x18(%edx),%ecx 1181c1: 85 c9 test %ecx,%ecx
1181c3: 75 5f jne 118224 <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;
1181c5: 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;
1181cc: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1181d3: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
1181d6: 8b 4d 08 mov 0x8(%ebp),%ecx 1181d9: 89 4a 30 mov %ecx,0x30(%edx)
the_watchdog->user_data = user_data;
1181dc: 8b 4d 14 mov 0x14(%ebp),%ecx 1181df: 89 4a 34 mov %ecx,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
1181e2: 89 7a 1c mov %edi,0x1c(%edx)
_ISR_Enable( level );
1181e5: 50 push %eax 1181e6: 9d popf
(*timer_server->schedule_operation)( timer_server, the_timer );
1181e7: 83 ec 08 sub $0x8,%esp 1181ea: 52 push %edx 1181eb: 53 push %ebx 1181ec: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
1181ef: e8 90 32 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1181f4: 83 c4 10 add $0x10,%esp 1181f7: 31 c0 xor %eax,%eax 1181f9: eb 83 jmp 11817e <rtems_timer_server_fire_after+0x2e> 1181fb: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1181fc: b8 04 00 00 00 mov $0x4,%eax
}
118201: 8d 65 f4 lea -0xc(%ebp),%esp 118204: 5b pop %ebx 118205: 5e pop %esi 118206: 5f pop %edi 118207: c9 leave 118208: c3 ret 118209: 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;
11820c: b8 0e 00 00 00 mov $0xe,%eax 118211: e9 68 ff ff ff jmp 11817e <rtems_timer_server_fire_after+0x2e> 118216: 66 90 xchg %ax,%ax
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118218: b8 09 00 00 00 mov $0x9,%eax 11821d: e9 5c ff ff ff jmp 11817e <rtems_timer_server_fire_after+0x2e> 118222: 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 );
118224: 50 push %eax 118225: 9d popf
_Thread_Enable_dispatch();
118226: e8 59 32 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11822b: 31 c0 xor %eax,%eax 11822d: e9 4c ff ff ff jmp 11817e <rtems_timer_server_fire_after+0x2e>
00118234 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118234: 55 push %ebp 118235: 89 e5 mov %esp,%ebp 118237: 57 push %edi 118238: 56 push %esi 118239: 53 push %ebx 11823a: 83 ec 2c sub $0x2c,%esp 11823d: 8b 7d 0c mov 0xc(%ebp),%edi 118240: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
118243: 8b 1d 20 2b 14 00 mov 0x142b20,%ebx
if ( !timer_server )
118249: 85 db test %ebx,%ebx
11824b: 0f 84 d7 00 00 00 je 118328 <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118251: 80 3d bc 20 14 00 00 cmpb $0x0,0x1420bc
118258: 0f 84 aa 00 00 00 je 118308 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
11825e: 85 f6 test %esi,%esi
118260: 0f 84 b2 00 00 00 je 118318 <rtems_timer_server_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
118266: 83 ec 0c sub $0xc,%esp 118269: 57 push %edi 11826a: e8 95 d1 ff ff call 115404 <_TOD_Validate> 11826f: 83 c4 10 add $0x10,%esp 118272: 84 c0 test %al,%al
118274: 75 0e jne 118284 <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;
118276: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11827b: 8d 65 f4 lea -0xc(%ebp),%esp 11827e: 5b pop %ebx 11827f: 5e pop %esi 118280: 5f pop %edi 118281: c9 leave 118282: c3 ret 118283: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
118284: 83 ec 0c sub $0xc,%esp 118287: 57 push %edi 118288: e8 eb d0 ff ff call 115378 <_TOD_To_seconds> 11828d: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11828f: 83 c4 10 add $0x10,%esp 118292: 3b 05 48 21 14 00 cmp 0x142148,%eax
118298: 76 dc jbe 118276 <rtems_timer_server_fire_when+0x42>
11829a: 52 push %edx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11829b: 8d 45 e4 lea -0x1c(%ebp),%eax 11829e: 50 push %eax 11829f: ff 75 08 pushl 0x8(%ebp) 1182a2: 68 e0 2a 14 00 push $0x142ae0 1182a7: e8 50 26 00 00 call 11a8fc <_Objects_Get> 1182ac: 89 c2 mov %eax,%edx
switch ( location ) {
1182ae: 83 c4 10 add $0x10,%esp 1182b1: 8b 45 e4 mov -0x1c(%ebp),%eax 1182b4: 85 c0 test %eax,%eax
1182b6: 75 7c jne 118334 <rtems_timer_server_fire_when+0x100>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1182b8: 83 ec 0c sub $0xc,%esp 1182bb: 8d 42 10 lea 0x10(%edx),%eax 1182be: 50 push %eax 1182bf: 89 55 d4 mov %edx,-0x2c(%ebp) 1182c2: e8 85 42 00 00 call 11c54c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
1182c7: 8b 55 d4 mov -0x2c(%ebp),%edx 1182ca: 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;
1182d1: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1182d8: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
1182db: 8b 45 08 mov 0x8(%ebp),%eax 1182de: 89 42 30 mov %eax,0x30(%edx)
the_watchdog->user_data = user_data;
1182e1: 8b 45 14 mov 0x14(%ebp),%eax 1182e4: 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();
1182e7: 2b 3d 48 21 14 00 sub 0x142148,%edi 1182ed: 89 7a 1c mov %edi,0x1c(%edx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1182f0: 58 pop %eax 1182f1: 59 pop %ecx 1182f2: 52 push %edx 1182f3: 53 push %ebx 1182f4: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
1182f7: e8 88 31 00 00 call 11b484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1182fc: 83 c4 10 add $0x10,%esp 1182ff: 31 c0 xor %eax,%eax 118301: e9 75 ff ff ff jmp 11827b <rtems_timer_server_fire_when+0x47> 118306: 66 90 xchg %ax,%ax
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
118308: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11830d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118310: 5b pop %ebx <== NOT EXECUTED 118311: 5e pop %esi <== NOT EXECUTED 118312: 5f pop %edi <== NOT EXECUTED 118313: c9 leave <== NOT EXECUTED 118314: c3 ret <== NOT EXECUTED 118315: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118318: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11831d: 8d 65 f4 lea -0xc(%ebp),%esp 118320: 5b pop %ebx 118321: 5e pop %esi 118322: 5f pop %edi 118323: c9 leave 118324: c3 ret 118325: 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;
118328: b8 0e 00 00 00 mov $0xe,%eax 11832d: e9 49 ff ff ff jmp 11827b <rtems_timer_server_fire_when+0x47> 118332: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118334: b8 04 00 00 00 mov $0x4,%eax 118339: e9 3d ff ff ff jmp 11827b <rtems_timer_server_fire_when+0x47>
0010b3dc <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10b3dc: 55 push %ebp 10b3dd: 89 e5 mov %esp,%ebp 10b3df: 83 ec 08 sub $0x8,%esp 10b3e2: 8b 45 08 mov 0x8(%ebp),%eax
switch ( policy ) {
10b3e5: 85 c0 test %eax,%eax
10b3e7: 78 0a js 10b3f3 <sched_get_priority_max+0x17>
10b3e9: 83 f8 02 cmp $0x2,%eax
10b3ec: 7e 1a jle 10b408 <sched_get_priority_max+0x2c>
10b3ee: 83 f8 04 cmp $0x4,%eax
10b3f1: 74 15 je 10b408 <sched_get_priority_max+0x2c><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10b3f3: e8 dc 86 00 00 call 113ad4 <__errno> 10b3f8: c7 00 16 00 00 00 movl $0x16,(%eax) 10b3fe: b8 ff ff ff ff mov $0xffffffff,%eax
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
}
10b403: c9 leave 10b404: c3 ret 10b405: 8d 76 00 lea 0x0(%esi),%esi
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10b408: 0f b6 05 dc 47 12 00 movzbl 0x1247dc,%eax 10b40f: 48 dec %eax
}
10b410: c9 leave 10b411: c3 ret
0010b414 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10b414: 55 push %ebp 10b415: 89 e5 mov %esp,%ebp 10b417: 83 ec 08 sub $0x8,%esp 10b41a: 8b 45 08 mov 0x8(%ebp),%eax
switch ( policy ) {
10b41d: 85 c0 test %eax,%eax
10b41f: 78 0a js 10b42b <sched_get_priority_min+0x17>
10b421: 83 f8 02 cmp $0x2,%eax
10b424: 7e 1a jle 10b440 <sched_get_priority_min+0x2c><== ALWAYS TAKEN
10b426: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10b429: 74 15 je 10b440 <sched_get_priority_min+0x2c><== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10b42b: e8 a4 86 00 00 call 113ad4 <__errno> 10b430: c7 00 16 00 00 00 movl $0x16,(%eax) 10b436: b8 ff ff ff ff mov $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10b43b: c9 leave 10b43c: c3 ret 10b43d: 8d 76 00 lea 0x0(%esi),%esi
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10b440: b8 01 00 00 00 mov $0x1,%eax
}
10b445: c9 leave 10b446: c3 ret
0010b448 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10b448: 55 push %ebp 10b449: 89 e5 mov %esp,%ebp 10b44b: 56 push %esi 10b44c: 53 push %ebx 10b44d: 8b 75 08 mov 0x8(%ebp),%esi 10b450: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10b453: 85 f6 test %esi,%esi
10b455: 75 21 jne 10b478 <sched_rr_get_interval+0x30><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
10b457: 85 db test %ebx,%ebx
10b459: 74 38 je 10b493 <sched_rr_get_interval+0x4b>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10b45b: 83 ec 08 sub $0x8,%esp 10b45e: 53 push %ebx 10b45f: ff 35 20 8a 12 00 pushl 0x128a20 10b465: e8 66 33 00 00 call 10e7d0 <_Timespec_From_ticks>
return 0;
10b46a: 83 c4 10 add $0x10,%esp 10b46d: 31 c0 xor %eax,%eax
}
10b46f: 8d 65 f8 lea -0x8(%ebp),%esp 10b472: 5b pop %ebx 10b473: 5e pop %esi 10b474: c9 leave 10b475: c3 ret 10b476: 66 90 xchg %ax,%ax
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10b478: e8 d3 c8 ff ff call 107d50 <getpid> 10b47d: 39 f0 cmp %esi,%eax
10b47f: 74 d6 je 10b457 <sched_rr_get_interval+0xf>
rtems_set_errno_and_return_minus_one( ESRCH );
10b481: e8 4e 86 00 00 call 113ad4 <__errno> 10b486: c7 00 03 00 00 00 movl $0x3,(%eax) 10b48c: b8 ff ff ff ff mov $0xffffffff,%eax 10b491: eb dc jmp 10b46f <sched_rr_get_interval+0x27>
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
10b493: e8 3c 86 00 00 call 113ad4 <__errno> 10b498: c7 00 16 00 00 00 movl $0x16,(%eax) 10b49e: b8 ff ff ff ff mov $0xffffffff,%eax 10b4a3: eb ca jmp 10b46f <sched_rr_get_interval+0x27>
0010db9c <sem_close>:
*/
int sem_close(
sem_t *sem
)
{
10db9c: 55 push %ebp 10db9d: 89 e5 mov %esp,%ebp 10db9f: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10dba2: 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 );
10dba5: 50 push %eax 10dba6: 8b 45 08 mov 0x8(%ebp),%eax 10dba9: ff 30 pushl (%eax) 10dbab: 68 00 ca 12 00 push $0x12ca00 10dbb0: e8 d7 1f 00 00 call 10fb8c <_Objects_Get>
switch ( location ) {
10dbb5: 83 c4 10 add $0x10,%esp 10dbb8: 8b 55 f4 mov -0xc(%ebp),%edx 10dbbb: 85 d2 test %edx,%edx
10dbbd: 74 15 je 10dbd4 <sem_close+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10dbbf: e8 48 95 00 00 call 11710c <__errno> 10dbc4: c7 00 16 00 00 00 movl $0x16,(%eax) 10dbca: b8 ff ff ff ff mov $0xffffffff,%eax
}
10dbcf: c9 leave 10dbd0: c3 ret 10dbd1: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
10dbd4: ff 48 18 decl 0x18(%eax)
_POSIX_Semaphore_Delete( the_semaphore );
10dbd7: 83 ec 0c sub $0xc,%esp 10dbda: 50 push %eax 10dbdb: e8 04 64 00 00 call 113fe4 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10dbe0: e8 37 2b 00 00 call 11071c <_Thread_Enable_dispatch>
return 0;
10dbe5: 83 c4 10 add $0x10,%esp 10dbe8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10dbea: c9 leave 10dbeb: c3 ret
0010dbec <sem_destroy>:
*/
int sem_destroy(
sem_t *sem
)
{
10dbec: 55 push %ebp 10dbed: 89 e5 mov %esp,%ebp 10dbef: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10dbf2: 8d 45 f4 lea -0xc(%ebp),%eax 10dbf5: 50 push %eax 10dbf6: 8b 45 08 mov 0x8(%ebp),%eax 10dbf9: ff 30 pushl (%eax) 10dbfb: 68 00 ca 12 00 push $0x12ca00 10dc00: e8 87 1f 00 00 call 10fb8c <_Objects_Get>
switch ( location ) {
10dc05: 83 c4 10 add $0x10,%esp 10dc08: 8b 55 f4 mov -0xc(%ebp),%edx 10dc0b: 85 d2 test %edx,%edx
10dc0d: 74 15 je 10dc24 <sem_destroy+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10dc0f: e8 f8 94 00 00 call 11710c <__errno> 10dc14: c7 00 16 00 00 00 movl $0x16,(%eax) 10dc1a: b8 ff ff ff ff mov $0xffffffff,%eax
}
10dc1f: c9 leave 10dc20: c3 ret 10dc21: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
10dc24: 80 78 14 00 cmpb $0x0,0x14(%eax)
10dc28: 75 16 jne 10dc40 <sem_destroy+0x54>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
10dc2a: 83 ec 0c sub $0xc,%esp 10dc2d: 50 push %eax 10dc2e: e8 b1 63 00 00 call 113fe4 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10dc33: e8 e4 2a 00 00 call 11071c <_Thread_Enable_dispatch>
return 0;
10dc38: 83 c4 10 add $0x10,%esp 10dc3b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10dc3d: c9 leave 10dc3e: c3 ret 10dc3f: 90 nop
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
_Thread_Enable_dispatch();
10dc40: e8 d7 2a 00 00 call 11071c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
10dc45: e8 c2 94 00 00 call 11710c <__errno> 10dc4a: c7 00 16 00 00 00 movl $0x16,(%eax) 10dc50: b8 ff ff ff ff mov $0xffffffff,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10dc55: c9 leave 10dc56: c3 ret
0010dc58 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
10dc58: 55 push %ebp 10dc59: 89 e5 mov %esp,%ebp 10dc5b: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10dc5e: 8d 45 f4 lea -0xc(%ebp),%eax 10dc61: 50 push %eax 10dc62: 8b 45 08 mov 0x8(%ebp),%eax 10dc65: ff 30 pushl (%eax) 10dc67: 68 00 ca 12 00 push $0x12ca00 10dc6c: e8 1b 1f 00 00 call 10fb8c <_Objects_Get>
switch ( location ) {
10dc71: 83 c4 10 add $0x10,%esp 10dc74: 8b 55 f4 mov -0xc(%ebp),%edx 10dc77: 85 d2 test %edx,%edx
10dc79: 74 15 je 10dc90 <sem_getvalue+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10dc7b: e8 8c 94 00 00 call 11710c <__errno> 10dc80: c7 00 16 00 00 00 movl $0x16,(%eax) 10dc86: b8 ff ff ff ff mov $0xffffffff,%eax
}
10dc8b: c9 leave 10dc8c: c3 ret 10dc8d: 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 );
10dc90: 8b 50 64 mov 0x64(%eax),%edx 10dc93: 8b 45 0c mov 0xc(%ebp),%eax 10dc96: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10dc98: e8 7f 2a 00 00 call 11071c <_Thread_Enable_dispatch>
return 0;
10dc9d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10dc9f: c9 leave 10dca0: c3 ret
0010dcec <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10dcec: 55 push %ebp 10dced: 89 e5 mov %esp,%ebp 10dcef: 57 push %edi 10dcf0: 56 push %esi 10dcf1: 53 push %ebx 10dcf2: 83 ec 2c sub $0x2c,%esp 10dcf5: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10dcf8: a1 ec c6 12 00 mov 0x12c6ec,%eax 10dcfd: 40 inc %eax 10dcfe: a3 ec c6 12 00 mov %eax,0x12c6ec
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10dd03: 8b 7d 0c mov 0xc(%ebp),%edi 10dd06: 81 e7 00 02 00 00 and $0x200,%edi
10dd0c: 0f 85 86 00 00 00 jne 10dd98 <sem_open+0xac>
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
10dd12: 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 );
10dd19: 83 ec 08 sub $0x8,%esp 10dd1c: 8d 45 e4 lea -0x1c(%ebp),%eax 10dd1f: 50 push %eax 10dd20: 56 push %esi 10dd21: e8 0e 63 00 00 call 114034 <_POSIX_Semaphore_Name_to_id> 10dd26: 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 ) {
10dd28: 83 c4 10 add $0x10,%esp 10dd2b: 85 c0 test %eax,%eax
10dd2d: 74 25 je 10dd54 <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) ) ) {
10dd2f: 83 f8 02 cmp $0x2,%eax
10dd32: 75 04 jne 10dd38 <sem_open+0x4c> <== NEVER TAKEN
10dd34: 85 ff test %edi,%edi
10dd36: 75 6c jne 10dda4 <sem_open+0xb8>
_Thread_Enable_dispatch();
10dd38: e8 df 29 00 00 call 11071c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10dd3d: e8 ca 93 00 00 call 11710c <__errno> 10dd42: 89 18 mov %ebx,(%eax) 10dd44: b8 ff ff ff ff mov $0xffffffff,%eax
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
10dd49: 8d 65 f4 lea -0xc(%ebp),%esp 10dd4c: 5b pop %ebx 10dd4d: 5e pop %esi 10dd4e: 5f pop %edi 10dd4f: c9 leave 10dd50: c3 ret 10dd51: 8d 76 00 lea 0x0(%esi),%esi
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10dd54: 8b 45 0c mov 0xc(%ebp),%eax 10dd57: 25 00 0a 00 00 and $0xa00,%eax 10dd5c: 3d 00 0a 00 00 cmp $0xa00,%eax
10dd61: 74 65 je 10ddc8 <sem_open+0xdc>
10dd63: 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 );
10dd64: 8d 45 dc lea -0x24(%ebp),%eax 10dd67: 50 push %eax 10dd68: ff 75 e4 pushl -0x1c(%ebp) 10dd6b: 68 00 ca 12 00 push $0x12ca00 10dd70: e8 17 1e 00 00 call 10fb8c <_Objects_Get> 10dd75: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10dd78: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10dd7b: e8 9c 29 00 00 call 11071c <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10dd80: e8 97 29 00 00 call 11071c <_Thread_Enable_dispatch>
goto return_id;
10dd85: 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;
10dd88: 8b 45 e0 mov -0x20(%ebp),%eax 10dd8b: 83 c0 08 add $0x8,%eax
#endif return id; }
10dd8e: 8d 65 f4 lea -0xc(%ebp),%esp 10dd91: 5b pop %ebx 10dd92: 5e pop %esi 10dd93: 5f pop %edi 10dd94: c9 leave 10dd95: c3 ret 10dd96: 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 );
10dd98: 8b 45 14 mov 0x14(%ebp),%eax 10dd9b: 89 45 d4 mov %eax,-0x2c(%ebp) 10dd9e: e9 76 ff ff ff jmp 10dd19 <sem_open+0x2d> 10dda3: 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(
10dda4: 8d 45 e0 lea -0x20(%ebp),%eax 10dda7: 50 push %eax 10dda8: ff 75 d4 pushl -0x2c(%ebp) 10ddab: 6a 00 push $0x0 10ddad: 56 push %esi 10ddae: e8 25 61 00 00 call 113ed8 <_POSIX_Semaphore_Create_support> 10ddb3: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10ddb5: e8 62 29 00 00 call 11071c <_Thread_Enable_dispatch>
if ( status == -1 )
10ddba: 83 c4 10 add $0x10,%esp 10ddbd: 43 inc %ebx
10ddbe: 75 c8 jne 10dd88 <sem_open+0x9c>
return SEM_FAILED;
10ddc0: b8 ff ff ff ff mov $0xffffffff,%eax 10ddc5: eb c7 jmp 10dd8e <sem_open+0xa2> 10ddc7: 90 nop
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
10ddc8: e8 4f 29 00 00 call 11071c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10ddcd: e8 3a 93 00 00 call 11710c <__errno> 10ddd2: c7 00 11 00 00 00 movl $0x11,(%eax) 10ddd8: b8 ff ff ff ff mov $0xffffffff,%eax 10dddd: eb af jmp 10dd8e <sem_open+0xa2>
0010dde0 <sem_post>:
*/
int sem_post(
sem_t *sem
)
{
10dde0: 55 push %ebp 10dde1: 89 e5 mov %esp,%ebp 10dde3: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10dde6: 8d 45 f4 lea -0xc(%ebp),%eax 10dde9: 50 push %eax 10ddea: 8b 45 08 mov 0x8(%ebp),%eax 10dded: ff 30 pushl (%eax) 10ddef: 68 00 ca 12 00 push $0x12ca00 10ddf4: e8 93 1d 00 00 call 10fb8c <_Objects_Get>
switch ( location ) {
10ddf9: 83 c4 10 add $0x10,%esp 10ddfc: 8b 4d f4 mov -0xc(%ebp),%ecx 10ddff: 85 c9 test %ecx,%ecx
10de01: 74 15 je 10de18 <sem_post+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10de03: e8 04 93 00 00 call 11710c <__errno> 10de08: c7 00 16 00 00 00 movl $0x16,(%eax) 10de0e: b8 ff ff ff ff mov $0xffffffff,%eax
}
10de13: c9 leave 10de14: c3 ret 10de15: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
10de18: 52 push %edx 10de19: 6a 00 push $0x0 10de1b: ff 70 08 pushl 0x8(%eax) 10de1e: 83 c0 1c add $0x1c,%eax 10de21: 50 push %eax 10de22: e8 79 13 00 00 call 10f1a0 <_CORE_semaphore_Surrender>
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
10de27: e8 f0 28 00 00 call 11071c <_Thread_Enable_dispatch>
return 0;
10de2c: 83 c4 10 add $0x10,%esp 10de2f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10de31: c9 leave 10de32: c3 ret
0010de34 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
10de34: 55 push %ebp 10de35: 89 e5 mov %esp,%ebp 10de37: 53 push %ebx 10de38: 83 ec 1c sub $0x1c,%esp 10de3b: 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 );
10de3e: 8d 45 f4 lea -0xc(%ebp),%eax 10de41: 50 push %eax 10de42: ff 75 0c pushl 0xc(%ebp) 10de45: e8 1e 55 00 00 call 113368 <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
10de4a: 83 c4 10 add $0x10,%esp 10de4d: 83 f8 03 cmp $0x3,%eax
10de50: 74 16 je 10de68 <sem_timedwait+0x34> <== ALWAYS TAKEN
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
10de52: 50 push %eax <== NOT EXECUTED 10de53: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10de56: 6a 00 push $0x0 <== NOT EXECUTED 10de58: 53 push %ebx <== NOT EXECUTED 10de59: e8 42 62 00 00 call 1140a0 <_POSIX_Semaphore_Wait_support><== NOT EXECUTED 10de5e: 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;
}
10de61: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10de64: c9 leave <== NOT EXECUTED 10de65: c3 ret <== NOT EXECUTED 10de66: 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 );
10de68: 52 push %edx 10de69: ff 75 f4 pushl -0xc(%ebp) 10de6c: 6a 01 push $0x1 10de6e: 53 push %ebx 10de6f: e8 2c 62 00 00 call 1140a0 <_POSIX_Semaphore_Wait_support> 10de74: 83 c4 10 add $0x10,%esp
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
10de77: 8b 5d fc mov -0x4(%ebp),%ebx 10de7a: c9 leave 10de7b: c3 ret
0010a89c <setitimer>:
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
10a89c: 55 push %ebp 10a89d: 89 e5 mov %esp,%ebp 10a89f: 83 ec 08 sub $0x8,%esp
if ( !value )
10a8a2: 8b 55 0c mov 0xc(%ebp),%edx 10a8a5: 85 d2 test %edx,%edx
10a8a7: 74 33 je 10a8dc <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
10a8a9: 8b 45 10 mov 0x10(%ebp),%eax 10a8ac: 85 c0 test %eax,%eax
10a8ae: 74 2c je 10a8dc <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10a8b0: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10a8b4: 76 12 jbe 10a8c8 <setitimer+0x2c>
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a8b6: e8 39 8c 00 00 call 1134f4 <__errno> 10a8bb: c7 00 16 00 00 00 movl $0x16,(%eax)
}
10a8c1: b8 ff ff ff ff mov $0xffffffff,%eax 10a8c6: c9 leave 10a8c7: c3 ret
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
10a8c8: e8 27 8c 00 00 call 1134f4 <__errno> 10a8cd: c7 00 58 00 00 00 movl $0x58,(%eax)
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10a8d3: b8 ff ff ff ff mov $0xffffffff,%eax 10a8d8: c9 leave 10a8d9: c3 ret 10a8da: 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 );
10a8dc: e8 13 8c 00 00 call 1134f4 <__errno> 10a8e1: c7 00 0e 00 00 00 movl $0xe,(%eax) 10a8e7: eb d8 jmp 10a8c1 <setitimer+0x25>
0010b2ec <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10b2ec: 55 push %ebp 10b2ed: 89 e5 mov %esp,%ebp 10b2ef: 57 push %edi 10b2f0: 56 push %esi 10b2f1: 53 push %ebx 10b2f2: 83 ec 1c sub $0x1c,%esp 10b2f5: 8b 5d 08 mov 0x8(%ebp),%ebx 10b2f8: 8b 45 0c mov 0xc(%ebp),%eax 10b2fb: 8b 55 10 mov 0x10(%ebp),%edx
ISR_Level level;
if ( oact )
10b2fe: 85 d2 test %edx,%edx
10b300: 74 13 je 10b315 <sigaction+0x29>
*oact = _POSIX_signals_Vectors[ sig ];
10b302: 8d 0c 5b lea (%ebx,%ebx,2),%ecx 10b305: 8d 34 8d 60 9d 12 00 lea 0x129d60(,%ecx,4),%esi 10b30c: b9 03 00 00 00 mov $0x3,%ecx 10b311: 89 d7 mov %edx,%edi 10b313: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10b315: 85 db test %ebx,%ebx
10b317: 74 77 je 10b390 <sigaction+0xa4>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10b319: 8d 53 ff lea -0x1(%ebx),%edx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10b31c: 83 fa 1f cmp $0x1f,%edx
10b31f: 77 6f ja 10b390 <sigaction+0xa4>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10b321: 83 fb 09 cmp $0x9,%ebx
10b324: 74 6a je 10b390 <sigaction+0xa4>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10b326: 85 c0 test %eax,%eax
10b328: 74 62 je 10b38c <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 );
10b32a: 9c pushf 10b32b: fa cli 10b32c: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10b32f: 8b 50 08 mov 0x8(%eax),%edx 10b332: 85 d2 test %edx,%edx
10b334: 74 36 je 10b36c <sigaction+0x80>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
10b336: 83 ec 0c sub $0xc,%esp 10b339: 53 push %ebx 10b33a: 89 45 e0 mov %eax,-0x20(%ebp) 10b33d: e8 8a 57 00 00 call 110acc <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10b342: 8d 14 5b lea (%ebx,%ebx,2),%edx 10b345: 8d 14 95 60 9d 12 00 lea 0x129d60(,%edx,4),%edx 10b34c: b9 03 00 00 00 mov $0x3,%ecx 10b351: 8b 45 e0 mov -0x20(%ebp),%eax 10b354: 89 d7 mov %edx,%edi 10b356: 89 c6 mov %eax,%esi 10b358: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10b35a: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10b35d: ff 75 e4 pushl -0x1c(%ebp) 10b360: 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;
10b361: 31 c0 xor %eax,%eax
}
10b363: 8d 65 f4 lea -0xc(%ebp),%esp 10b366: 5b pop %ebx 10b367: 5e pop %esi 10b368: 5f pop %edi 10b369: c9 leave 10b36a: c3 ret 10b36b: 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 ];
10b36c: 8d 34 5b lea (%ebx,%ebx,2),%esi 10b36f: c1 e6 02 shl $0x2,%esi 10b372: 8d 86 60 9d 12 00 lea 0x129d60(%esi),%eax 10b378: 81 c6 80 32 12 00 add $0x123280,%esi 10b37e: b9 03 00 00 00 mov $0x3,%ecx 10b383: 89 c7 mov %eax,%edi 10b385: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10b387: eb d4 jmp 10b35d <sigaction+0x71> 10b389: 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;
10b38c: 31 c0 xor %eax,%eax
10b38e: eb d3 jmp 10b363 <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 );
10b390: e8 4b 8a 00 00 call 113de0 <__errno> 10b395: c7 00 16 00 00 00 movl $0x16,(%eax) 10b39b: b8 ff ff ff ff mov $0xffffffff,%eax 10b3a0: eb c1 jmp 10b363 <sigaction+0x77>
0010b6b4 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10b6b4: 55 push %ebp 10b6b5: 89 e5 mov %esp,%ebp 10b6b7: 57 push %edi 10b6b8: 56 push %esi 10b6b9: 53 push %ebx 10b6ba: 83 ec 2c sub $0x2c,%esp 10b6bd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b6c0: 8b 7d 0c mov 0xc(%ebp),%edi 10b6c3: 8b 75 10 mov 0x10(%ebp),%esi
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10b6c6: 85 db test %ebx,%ebx
10b6c8: 0f 84 9e 01 00 00 je 10b86c <sigtimedwait+0x1b8>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10b6ce: 85 f6 test %esi,%esi
10b6d0: 0f 84 3e 01 00 00 je 10b814 <sigtimedwait+0x160>
if ( !_Timespec_Is_valid( timeout ) )
10b6d6: 83 ec 0c sub $0xc,%esp 10b6d9: 56 push %esi 10b6da: e8 f5 33 00 00 call 10ead4 <_Timespec_Is_valid> 10b6df: 83 c4 10 add $0x10,%esp 10b6e2: 84 c0 test %al,%al
10b6e4: 0f 84 82 01 00 00 je 10b86c <sigtimedwait+0x1b8>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10b6ea: 83 ec 0c sub $0xc,%esp 10b6ed: 56 push %esi 10b6ee: e8 49 34 00 00 call 10eb3c <_Timespec_To_ticks>
if ( !interval )
10b6f3: 83 c4 10 add $0x10,%esp 10b6f6: 85 c0 test %eax,%eax
10b6f8: 0f 84 6e 01 00 00 je 10b86c <sigtimedwait+0x1b8> <== NEVER TAKEN
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10b6fe: 85 ff test %edi,%edi
10b700: 0f 84 18 01 00 00 je 10b81e <sigtimedwait+0x16a> <== NEVER TAKEN
the_thread = _Thread_Executing;
10b706: 8b 0d d8 a3 12 00 mov 0x12a3d8,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10b70c: 8b 91 ec 00 00 00 mov 0xec(%ecx),%edx
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10b712: 9c pushf 10b713: fa cli 10b714: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10b717: 8b 33 mov (%ebx),%esi 10b719: 89 75 d4 mov %esi,-0x2c(%ebp) 10b71c: 8b b2 d4 00 00 00 mov 0xd4(%edx),%esi 10b722: 85 75 d4 test %esi,-0x2c(%ebp)
10b725: 0f 85 fd 00 00 00 jne 10b828 <sigtimedwait+0x174>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10b72b: 8b 35 48 a6 12 00 mov 0x12a648,%esi 10b731: 85 75 d4 test %esi,-0x2c(%ebp)
10b734: 0f 85 96 00 00 00 jne 10b7d0 <sigtimedwait+0x11c>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
10b73a: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10b740: 8b 35 2c 9e 12 00 mov 0x129e2c,%esi 10b746: 46 inc %esi 10b747: 89 35 2c 9e 12 00 mov %esi,0x129e2c
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10b74d: c7 41 44 e0 a5 12 00 movl $0x12a5e0,0x44(%ecx)
the_thread->Wait.return_code = EINTR;
10b754: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx)
the_thread->Wait.option = *set;
10b75b: 8b 33 mov (%ebx),%esi 10b75d: 89 71 30 mov %esi,0x30(%ecx)
the_thread->Wait.return_argument = the_info;
10b760: 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;
10b763: c7 05 10 a6 12 00 01 movl $0x1,0x12a610
10b76a: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10b76d: ff 75 d0 pushl -0x30(%ebp) 10b770: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10b771: 51 push %ecx 10b772: 68 14 e8 10 00 push $0x10e814 10b777: 50 push %eax 10b778: 68 e0 a5 12 00 push $0x12a5e0 10b77d: 89 55 cc mov %edx,-0x34(%ebp) 10b780: e8 63 2d 00 00 call 10e4e8 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10b785: e8 b6 28 00 00 call 10e040 <_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 );
10b78a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b791: 6a 00 push $0x0 10b793: 57 push %edi 10b794: ff 37 pushl (%edi) 10b796: 8b 55 cc mov -0x34(%ebp),%edx 10b799: 52 push %edx 10b79a: e8 09 5a 00 00 call 1111a8 <_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)
10b79f: 83 c4 20 add $0x20,%esp 10b7a2: a1 d8 a3 12 00 mov 0x12a3d8,%eax 10b7a7: 83 78 34 04 cmpl $0x4,0x34(%eax)
10b7ab: 0f 85 d3 00 00 00 jne 10b884 <sigtimedwait+0x1d0>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10b7b1: 8b 37 mov (%edi),%esi 10b7b3: 8d 4e ff lea -0x1(%esi),%ecx 10b7b6: b8 01 00 00 00 mov $0x1,%eax 10b7bb: d3 e0 shl %cl,%eax 10b7bd: 85 03 test %eax,(%ebx)
10b7bf: 0f 84 bf 00 00 00 je 10b884 <sigtimedwait+0x1d0>
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10b7c5: 89 f0 mov %esi,%eax 10b7c7: 8d 65 f4 lea -0xc(%ebp),%esp 10b7ca: 5b pop %ebx 10b7cb: 5e pop %esi 10b7cc: 5f pop %edi 10b7cd: c9 leave 10b7ce: c3 ret 10b7cf: 90 nop
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10b7d0: 83 ec 0c sub $0xc,%esp 10b7d3: 56 push %esi 10b7d4: 89 55 cc mov %edx,-0x34(%ebp) 10b7d7: e8 94 fe ff ff call 10b670 <_POSIX_signals_Get_lowest> 10b7dc: 89 c6 mov %eax,%esi
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10b7de: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b7e5: 6a 01 push $0x1 10b7e7: 57 push %edi 10b7e8: 50 push %eax 10b7e9: 8b 55 cc mov -0x34(%ebp),%edx 10b7ec: 52 push %edx 10b7ed: e8 b6 59 00 00 call 1111a8 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10b7f2: ff 75 d0 pushl -0x30(%ebp) 10b7f5: 9d popf
the_info->si_signo = signo;
10b7f6: 89 37 mov %esi,(%edi)
the_info->si_code = SI_USER;
10b7f8: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10b7ff: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10b806: 83 c4 20 add $0x20,%esp
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10b809: 89 f0 mov %esi,%eax 10b80b: 8d 65 f4 lea -0xc(%ebp),%esp 10b80e: 5b pop %ebx 10b80f: 5e pop %esi 10b810: 5f pop %edi 10b811: c9 leave 10b812: c3 ret 10b813: 90 nop
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10b814: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10b816: 85 ff test %edi,%edi
10b818: 0f 85 e8 fe ff ff jne 10b706 <sigtimedwait+0x52>
10b81e: 8d 7d dc lea -0x24(%ebp),%edi 10b821: e9 e0 fe ff ff jmp 10b706 <sigtimedwait+0x52> 10b826: 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 );
10b828: 83 ec 0c sub $0xc,%esp 10b82b: 56 push %esi 10b82c: 89 55 cc mov %edx,-0x34(%ebp) 10b82f: e8 3c fe ff ff call 10b670 <_POSIX_signals_Get_lowest> 10b834: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10b836: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b83d: 6a 00 push $0x0 10b83f: 57 push %edi 10b840: 50 push %eax 10b841: 8b 55 cc mov -0x34(%ebp),%edx 10b844: 52 push %edx 10b845: e8 5e 59 00 00 call 1111a8 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10b84a: ff 75 d0 pushl -0x30(%ebp) 10b84d: 9d popf
the_info->si_code = SI_USER;
10b84e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10b855: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10b85c: 8b 37 mov (%edi),%esi 10b85e: 83 c4 20 add $0x20,%esp
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10b861: 89 f0 mov %esi,%eax 10b863: 8d 65 f4 lea -0xc(%ebp),%esp 10b866: 5b pop %ebx 10b867: 5e pop %esi 10b868: 5f pop %edi 10b869: c9 leave 10b86a: c3 ret 10b86b: 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 );
10b86c: e8 a3 8b 00 00 call 114414 <__errno> 10b871: c7 00 16 00 00 00 movl $0x16,(%eax) 10b877: be ff ff ff ff mov $0xffffffff,%esi 10b87c: e9 44 ff ff ff jmp 10b7c5 <sigtimedwait+0x111> 10b881: 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;
10b884: e8 8b 8b 00 00 call 114414 <__errno> 10b889: 8b 15 d8 a3 12 00 mov 0x12a3d8,%edx 10b88f: 8b 52 34 mov 0x34(%edx),%edx 10b892: 89 10 mov %edx,(%eax)
return -1;
10b894: be ff ff ff ff mov $0xffffffff,%esi 10b899: e9 27 ff ff ff jmp 10b7c5 <sigtimedwait+0x111>
0010d4dc <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10d4dc: 55 push %ebp 10d4dd: 89 e5 mov %esp,%ebp 10d4df: 53 push %ebx 10d4e0: 83 ec 08 sub $0x8,%esp 10d4e3: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10d4e6: 6a 00 push $0x0 10d4e8: 6a 00 push $0x0 10d4ea: ff 75 08 pushl 0x8(%ebp) 10d4ed: e8 e6 fd ff ff call 10d2d8 <sigtimedwait>
if ( status != -1 ) {
10d4f2: 83 c4 10 add $0x10,%esp 10d4f5: 83 f8 ff cmp $0xffffffff,%eax
10d4f8: 74 0e je 10d508 <sigwait+0x2c>
if ( sig )
10d4fa: 85 db test %ebx,%ebx
10d4fc: 74 16 je 10d514 <sigwait+0x38> <== NEVER TAKEN
*sig = status;
10d4fe: 89 03 mov %eax,(%ebx)
return 0;
10d500: 31 c0 xor %eax,%eax
}
return errno;
}
10d502: 8b 5d fc mov -0x4(%ebp),%ebx 10d505: c9 leave 10d506: c3 ret 10d507: 90 nop
if ( sig )
*sig = status;
return 0;
}
return errno;
10d508: e8 77 86 00 00 call 115b84 <__errno> 10d50d: 8b 00 mov (%eax),%eax
}
10d50f: 8b 5d fc mov -0x4(%ebp),%ebx 10d512: c9 leave 10d513: c3 ret
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
10d514: 31 c0 xor %eax,%eax
}
return errno;
}
10d516: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d519: c9 leave <== NOT EXECUTED 10d51a: c3 ret <== NOT EXECUTED
0010aa98 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10aa98: 55 push %ebp 10aa99: 89 e5 mov %esp,%ebp 10aa9b: 56 push %esi 10aa9c: 53 push %ebx 10aa9d: 8b 5d 0c mov 0xc(%ebp),%ebx 10aaa0: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10aaa3: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10aaa7: 0f 85 db 00 00 00 jne 10ab88 <timer_create+0xf0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10aaad: 85 f6 test %esi,%esi
10aaaf: 0f 84 d3 00 00 00 je 10ab88 <timer_create+0xf0>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10aab5: 85 db test %ebx,%ebx
10aab7: 74 21 je 10aada <timer_create+0x42>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10aab9: 8b 03 mov (%ebx),%eax 10aabb: 48 dec %eax 10aabc: 83 f8 01 cmp $0x1,%eax
10aabf: 0f 87 c3 00 00 00 ja 10ab88 <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 )
10aac5: 8b 43 04 mov 0x4(%ebx),%eax 10aac8: 85 c0 test %eax,%eax
10aaca: 0f 84 b8 00 00 00 je 10ab88 <timer_create+0xf0> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10aad0: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10aad1: 83 f8 1f cmp $0x1f,%eax
10aad4: 0f 87 ae 00 00 00 ja 10ab88 <timer_create+0xf0> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10aada: a1 8c 9a 12 00 mov 0x129a8c,%eax 10aadf: 40 inc %eax 10aae0: a3 8c 9a 12 00 mov %eax,0x129a8c
* 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 );
10aae5: 83 ec 0c sub $0xc,%esp 10aae8: 68 e0 9d 12 00 push $0x129de0 10aaed: e8 b2 1c 00 00 call 10c7a4 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10aaf2: 83 c4 10 add $0x10,%esp 10aaf5: 85 c0 test %eax,%eax
10aaf7: 0f 84 a2 00 00 00 je 10ab9f <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;
10aafd: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10ab01: 8b 15 38 a0 12 00 mov 0x12a038,%edx 10ab07: 8b 52 08 mov 0x8(%edx),%edx 10ab0a: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10ab0d: 85 db test %ebx,%ebx
10ab0f: 74 11 je 10ab22 <timer_create+0x8a>
ptimer->inf.sigev_notify = evp->sigev_notify;
10ab11: 8b 13 mov (%ebx),%edx 10ab13: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10ab16: 8b 53 04 mov 0x4(%ebx),%edx 10ab19: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10ab1c: 8b 53 08 mov 0x8(%ebx),%edx 10ab1f: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10ab22: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10ab29: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10ab30: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10ab37: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10ab3e: 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;
10ab45: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10ab4c: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10ab53: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10ab5a: 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 ),
10ab61: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ab64: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ab67: 8b 0d fc 9d 12 00 mov 0x129dfc,%ecx 10ab6d: 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;
10ab70: 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;
10ab77: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10ab79: e8 ea 2b 00 00 call 10d768 <_Thread_Enable_dispatch>
return 0;
10ab7e: 31 c0 xor %eax,%eax
}
10ab80: 8d 65 f8 lea -0x8(%ebp),%esp 10ab83: 5b pop %ebx 10ab84: 5e pop %esi 10ab85: c9 leave 10ab86: c3 ret 10ab87: 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 );
10ab88: e8 f7 8f 00 00 call 113b84 <__errno> 10ab8d: c7 00 16 00 00 00 movl $0x16,(%eax) 10ab93: 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;
}
10ab98: 8d 65 f8 lea -0x8(%ebp),%esp 10ab9b: 5b pop %ebx 10ab9c: 5e pop %esi 10ab9d: c9 leave 10ab9e: c3 ret
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
10ab9f: e8 c4 2b 00 00 call 10d768 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10aba4: e8 db 8f 00 00 call 113b84 <__errno> 10aba9: c7 00 0b 00 00 00 movl $0xb,(%eax) 10abaf: b8 ff ff ff ff mov $0xffffffff,%eax 10abb4: eb ca jmp 10ab80 <timer_create+0xe8>
0010afdc <timer_delete>:
int timer_delete(
timer_t timerid
)
{
10afdc: 55 push %ebp 10afdd: 89 e5 mov %esp,%ebp 10afdf: 53 push %ebx 10afe0: 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 );
10afe3: 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 );
10afe6: 50 push %eax 10afe7: ff 75 08 pushl 0x8(%ebp) 10afea: 68 c0 9c 12 00 push $0x129cc0 10afef: e8 b4 1f 00 00 call 10cfa8 <_Objects_Get> 10aff4: 89 c3 mov %eax,%ebx
switch ( location ) {
10aff6: 83 c4 10 add $0x10,%esp 10aff9: 8b 4d f4 mov -0xc(%ebp),%ecx 10affc: 85 c9 test %ecx,%ecx
10affe: 74 18 je 10b018 <timer_delete+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b000: e8 7f 92 00 00 call 114284 <__errno> 10b005: c7 00 16 00 00 00 movl $0x16,(%eax) 10b00b: b8 ff ff ff ff mov $0xffffffff,%eax
}
10b010: 8b 5d fc mov -0x4(%ebp),%ebx 10b013: c9 leave 10b014: c3 ret 10b015: 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 );
10b018: 83 ec 08 sub $0x8,%esp 10b01b: 50 push %eax 10b01c: 68 c0 9c 12 00 push $0x129cc0 10b021: e8 4a 1b 00 00 call 10cb70 <_Objects_Close>
ptimer->state = POSIX_TIMER_STATE_FREE;
10b026: c6 43 3c 01 movb $0x1,0x3c(%ebx)
(void) _Watchdog_Remove( &ptimer->Timer );
10b02a: 8d 43 10 lea 0x10(%ebx),%eax 10b02d: 89 04 24 mov %eax,(%esp) 10b030: e8 1f 3a 00 00 call 10ea54 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
10b035: 58 pop %eax 10b036: 5a pop %edx 10b037: 53 push %ebx 10b038: 68 c0 9c 12 00 push $0x129cc0 10b03d: e8 26 1e 00 00 call 10ce68 <_Objects_Free>
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
10b042: e8 71 2a 00 00 call 10dab8 <_Thread_Enable_dispatch>
return 0;
10b047: 83 c4 10 add $0x10,%esp 10b04a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b04c: 8b 5d fc mov -0x4(%ebp),%ebx 10b04f: c9 leave 10b050: c3 ret
0010be98 <timer_getoverrun>:
* its execution, _POSIX_Timer_TSR will have to set this counter to 0.
*/
int timer_getoverrun(
timer_t timerid
)
{
10be98: 55 push %ebp 10be99: 89 e5 mov %esp,%ebp 10be9b: 53 push %ebx 10be9c: 83 ec 18 sub $0x18,%esp
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
10be9f: 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 );
10bea2: 50 push %eax 10bea3: ff 75 08 pushl 0x8(%ebp) 10bea6: 68 80 b3 12 00 push $0x12b380 10beab: e8 3c 1f 00 00 call 10ddec <_Objects_Get>
switch ( location ) {
10beb0: 83 c4 10 add $0x10,%esp 10beb3: 8b 55 f4 mov -0xc(%ebp),%edx 10beb6: 85 d2 test %edx,%edx
10beb8: 74 1a je 10bed4 <timer_getoverrun+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10beba: e8 45 8e 00 00 call 114d04 <__errno> 10bebf: c7 00 16 00 00 00 movl $0x16,(%eax) 10bec5: bb ff ff ff ff mov $0xffffffff,%ebx
}
10beca: 89 d8 mov %ebx,%eax 10becc: 8b 5d fc mov -0x4(%ebp),%ebx 10becf: c9 leave 10bed0: c3 ret 10bed1: 8d 76 00 lea 0x0(%esi),%esi
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
10bed4: 8b 58 68 mov 0x68(%eax),%ebx
ptimer->overrun = 0;
10bed7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
_Thread_Enable_dispatch();
10bede: e8 19 2a 00 00 call 10e8fc <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10bee3: 89 d8 mov %ebx,%eax 10bee5: 8b 5d fc mov -0x4(%ebp),%ebx 10bee8: c9 leave 10bee9: c3 ret
0010beec <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
10beec: 55 push %ebp 10beed: 89 e5 mov %esp,%ebp 10beef: 56 push %esi 10bef0: 53 push %ebx 10bef1: 83 ec 10 sub $0x10,%esp 10bef4: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
10bef7: 85 db test %ebx,%ebx
10bef9: 74 65 je 10bf60 <timer_gettime+0x74>
rtems_set_errno_and_return_minus_one( EINVAL );
/* Reads the current time */
_TOD_Get( ¤t_time );
10befb: 83 ec 0c sub $0xc,%esp 10befe: 8d 45 ec lea -0x14(%ebp),%eax 10bf01: 50 push %eax 10bf02: e8 15 15 00 00 call 10d41c <_TOD_Get> 10bf07: 83 c4 0c add $0xc,%esp
ptimer = _POSIX_Timer_Get( timerid, &location );
10bf0a: 8d 45 f4 lea -0xc(%ebp),%eax 10bf0d: 50 push %eax 10bf0e: ff 75 08 pushl 0x8(%ebp) 10bf11: 68 80 b3 12 00 push $0x12b380 10bf16: e8 d1 1e 00 00 call 10ddec <_Objects_Get> 10bf1b: 89 c6 mov %eax,%esi
switch ( location ) {
10bf1d: 83 c4 10 add $0x10,%esp 10bf20: 8b 45 f4 mov -0xc(%ebp),%eax 10bf23: 85 c0 test %eax,%eax
10bf25: 75 39 jne 10bf60 <timer_gettime+0x74>
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10bf27: a1 64 b1 12 00 mov 0x12b164,%eax
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
10bf2c: 83 ec 08 sub $0x8,%esp 10bf2f: 8d 53 08 lea 0x8(%ebx),%edx 10bf32: 52 push %edx
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10bf33: 8b 56 1c mov 0x1c(%esi),%edx 10bf36: 03 56 24 add 0x24(%esi),%edx
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
10bf39: 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 );
10bf3b: 52 push %edx 10bf3c: e8 4f 34 00 00 call 10f390 <_Timespec_From_ticks>
value->it_interval = ptimer->timer_data.it_interval;
10bf41: 8b 46 54 mov 0x54(%esi),%eax 10bf44: 8b 56 58 mov 0x58(%esi),%edx 10bf47: 89 03 mov %eax,(%ebx) 10bf49: 89 53 04 mov %edx,0x4(%ebx)
_Thread_Enable_dispatch();
10bf4c: e8 ab 29 00 00 call 10e8fc <_Thread_Enable_dispatch>
return 0;
10bf51: 83 c4 10 add $0x10,%esp 10bf54: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10bf56: 8d 65 f8 lea -0x8(%ebp),%esp 10bf59: 5b pop %ebx 10bf5a: 5e pop %esi 10bf5b: c9 leave 10bf5c: c3 ret 10bf5d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10bf60: e8 9f 8d 00 00 call 114d04 <__errno> 10bf65: c7 00 16 00 00 00 movl $0x16,(%eax) 10bf6b: b8 ff ff ff ff mov $0xffffffff,%eax 10bf70: eb e4 jmp 10bf56 <timer_gettime+0x6a>
0010abb8 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10abb8: 55 push %ebp 10abb9: 89 e5 mov %esp,%ebp 10abbb: 57 push %edi 10abbc: 56 push %esi 10abbd: 53 push %ebx 10abbe: 83 ec 3c sub $0x3c,%esp 10abc1: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10abc4: 85 db test %ebx,%ebx
10abc6: 0f 84 50 01 00 00 je 10ad1c <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) ) ) {
10abcc: 83 ec 0c sub $0xc,%esp 10abcf: 8d 43 08 lea 0x8(%ebx),%eax 10abd2: 50 push %eax 10abd3: e8 48 36 00 00 call 10e220 <_Timespec_Is_valid> 10abd8: 83 c4 10 add $0x10,%esp 10abdb: 84 c0 test %al,%al
10abdd: 0f 84 39 01 00 00 je 10ad1c <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10abe3: 83 ec 0c sub $0xc,%esp 10abe6: 53 push %ebx 10abe7: e8 34 36 00 00 call 10e220 <_Timespec_Is_valid> 10abec: 83 c4 10 add $0x10,%esp 10abef: 84 c0 test %al,%al
10abf1: 0f 84 25 01 00 00 je 10ad1c <timer_settime+0x164> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10abf7: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10abfb: 0f 84 db 00 00 00 je 10acdc <timer_settime+0x124>
10ac01: 8b 45 0c mov 0xc(%ebp),%eax 10ac04: 85 c0 test %eax,%eax
10ac06: 0f 85 10 01 00 00 jne 10ad1c <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10ac0c: 8d 45 cc lea -0x34(%ebp),%eax 10ac0f: 89 45 c4 mov %eax,-0x3c(%ebp) 10ac12: b9 04 00 00 00 mov $0x4,%ecx 10ac17: 89 c7 mov %eax,%edi 10ac19: 89 de mov %ebx,%esi 10ac1b: 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 );
10ac1d: 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 );
10ac1e: 8d 45 e4 lea -0x1c(%ebp),%eax 10ac21: 50 push %eax 10ac22: ff 75 08 pushl 0x8(%ebp) 10ac25: 68 e0 9d 12 00 push $0x129de0 10ac2a: e8 29 20 00 00 call 10cc58 <_Objects_Get> 10ac2f: 89 c2 mov %eax,%edx
switch ( location ) {
10ac31: 83 c4 10 add $0x10,%esp 10ac34: 8b 7d e4 mov -0x1c(%ebp),%edi 10ac37: 85 ff test %edi,%edi
10ac39: 0f 85 dd 00 00 00 jne 10ad1c <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 ) {
10ac3f: 8b 75 d4 mov -0x2c(%ebp),%esi 10ac42: 85 f6 test %esi,%esi
10ac44: 75 0b jne 10ac51 <timer_settime+0x99>
10ac46: 8b 4d d8 mov -0x28(%ebp),%ecx 10ac49: 85 c9 test %ecx,%ecx
10ac4b: 0f 84 df 00 00 00 je 10ad30 <timer_settime+0x178>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10ac51: 83 ec 0c sub $0xc,%esp 10ac54: 53 push %ebx 10ac55: 89 55 c0 mov %edx,-0x40(%ebp) 10ac58: e8 2b 36 00 00 call 10e288 <_Timespec_To_ticks> 10ac5d: 8b 55 c0 mov -0x40(%ebp),%edx 10ac60: 89 42 64 mov %eax,0x64(%edx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10ac63: 8d 45 d4 lea -0x2c(%ebp),%eax 10ac66: 89 04 24 mov %eax,(%esp) 10ac69: e8 1a 36 00 00 call 10e288 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10ac6e: 8b 55 c0 mov -0x40(%ebp),%edx 10ac71: 89 14 24 mov %edx,(%esp) 10ac74: 68 9c ad 10 00 push $0x10ad9c 10ac79: ff 72 08 pushl 0x8(%edx) 10ac7c: 50 push %eax 10ac7d: 8d 42 10 lea 0x10(%edx),%eax 10ac80: 50 push %eax 10ac81: e8 32 61 00 00 call 110db8 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10ac86: 83 c4 20 add $0x20,%esp 10ac89: 84 c0 test %al,%al 10ac8b: 8b 55 c0 mov -0x40(%ebp),%edx
10ac8e: 0f 84 e8 00 00 00 je 10ad7c <timer_settime+0x1c4>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10ac94: 8b 45 14 mov 0x14(%ebp),%eax 10ac97: 85 c0 test %eax,%eax
10ac99: 0f 84 ed 00 00 00 je 10ad8c <timer_settime+0x1d4>
*ovalue = ptimer->timer_data;
10ac9f: 8d 42 54 lea 0x54(%edx),%eax 10aca2: b9 04 00 00 00 mov $0x4,%ecx 10aca7: 8b 7d 14 mov 0x14(%ebp),%edi 10acaa: 89 c6 mov %eax,%esi 10acac: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10acae: b9 04 00 00 00 mov $0x4,%ecx 10acb3: 89 c7 mov %eax,%edi 10acb5: 8b 75 c4 mov -0x3c(%ebp),%esi 10acb8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10acba: c6 42 3c 03 movb $0x3,0x3c(%edx)
_TOD_Get( &ptimer->time );
10acbe: 83 ec 0c sub $0xc,%esp 10acc1: 83 c2 6c add $0x6c,%edx 10acc4: 52 push %edx 10acc5: e8 e2 15 00 00 call 10c2ac <_TOD_Get>
_Thread_Enable_dispatch();
10acca: e8 99 2a 00 00 call 10d768 <_Thread_Enable_dispatch>
return 0;
10accf: 83 c4 10 add $0x10,%esp 10acd2: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10acd4: 8d 65 f4 lea -0xc(%ebp),%esp 10acd7: 5b pop %ebx 10acd8: 5e pop %esi 10acd9: 5f pop %edi 10acda: c9 leave 10acdb: c3 ret
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10acdc: 8d 45 cc lea -0x34(%ebp),%eax 10acdf: 89 45 c4 mov %eax,-0x3c(%ebp) 10ace2: 89 c7 mov %eax,%edi 10ace4: 89 de mov %ebx,%esi 10ace6: 8b 4d 0c mov 0xc(%ebp),%ecx 10ace9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
10aceb: 83 ec 0c sub $0xc,%esp 10acee: 8d 75 dc lea -0x24(%ebp),%esi 10acf1: 56 push %esi 10acf2: e8 b5 15 00 00 call 10c2ac <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10acf7: 59 pop %ecx 10acf8: 5f pop %edi 10acf9: 8d 7d d4 lea -0x2c(%ebp),%edi 10acfc: 57 push %edi 10acfd: 56 push %esi 10acfe: e8 f9 34 00 00 call 10e1fc <_Timespec_Greater_than> 10ad03: 83 c4 10 add $0x10,%esp 10ad06: 84 c0 test %al,%al
10ad08: 75 12 jne 10ad1c <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10ad0a: 52 push %edx 10ad0b: 57 push %edi 10ad0c: 57 push %edi 10ad0d: 56 push %esi 10ad0e: e8 35 35 00 00 call 10e248 <_Timespec_Subtract> 10ad13: 83 c4 10 add $0x10,%esp 10ad16: e9 02 ff ff ff jmp 10ac1d <timer_settime+0x65> 10ad1b: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10ad1c: e8 63 8e 00 00 call 113b84 <__errno> 10ad21: c7 00 16 00 00 00 movl $0x16,(%eax) 10ad27: b8 ff ff ff ff mov $0xffffffff,%eax 10ad2c: eb a6 jmp 10acd4 <timer_settime+0x11c> 10ad2e: 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 );
10ad30: 83 ec 0c sub $0xc,%esp 10ad33: 8d 40 10 lea 0x10(%eax),%eax 10ad36: 50 push %eax 10ad37: 89 55 c0 mov %edx,-0x40(%ebp) 10ad3a: e8 7d 39 00 00 call 10e6bc <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10ad3f: 83 c4 10 add $0x10,%esp 10ad42: 8b 55 14 mov 0x14(%ebp),%edx 10ad45: 85 d2 test %edx,%edx 10ad47: 8b 55 c0 mov -0x40(%ebp),%edx
10ad4a: 74 48 je 10ad94 <timer_settime+0x1dc>
*ovalue = ptimer->timer_data;
10ad4c: 8d 42 54 lea 0x54(%edx),%eax 10ad4f: b9 04 00 00 00 mov $0x4,%ecx 10ad54: 8b 7d 14 mov 0x14(%ebp),%edi 10ad57: 89 c6 mov %eax,%esi 10ad59: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10ad5b: b9 04 00 00 00 mov $0x4,%ecx 10ad60: 89 c7 mov %eax,%edi 10ad62: 8b 75 c4 mov -0x3c(%ebp),%esi 10ad65: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10ad67: c6 42 3c 04 movb $0x4,0x3c(%edx)
/* Returns with success */
_Thread_Enable_dispatch();
10ad6b: e8 f8 29 00 00 call 10d768 <_Thread_Enable_dispatch>
return 0;
10ad70: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10ad72: 8d 65 f4 lea -0xc(%ebp),%esp 10ad75: 5b pop %ebx 10ad76: 5e pop %esi 10ad77: 5f pop %edi 10ad78: c9 leave 10ad79: c3 ret 10ad7a: 66 90 xchg %ax,%ax
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
_Thread_Enable_dispatch();
10ad7c: e8 e7 29 00 00 call 10d768 <_Thread_Enable_dispatch>
return 0;
10ad81: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10ad83: 8d 65 f4 lea -0xc(%ebp),%esp 10ad86: 5b pop %ebx 10ad87: 5e pop %esi 10ad88: 5f pop %edi 10ad89: c9 leave 10ad8a: c3 ret 10ad8b: 90 nop 10ad8c: 8d 42 54 lea 0x54(%edx),%eax 10ad8f: e9 1a ff ff ff jmp 10acae <timer_settime+0xf6> 10ad94: 8d 42 54 lea 0x54(%edx),%eax 10ad97: eb c2 jmp 10ad5b <timer_settime+0x1a3>
0010a9b8 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
10a9b8: 55 push %ebp 10a9b9: 89 e5 mov %esp,%ebp 10a9bb: 56 push %esi 10a9bc: 53 push %ebx 10a9bd: 83 ec 10 sub $0x10,%esp 10a9c0: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
10a9c3: 8b 0d fc 9f 12 00 mov 0x129ffc,%ecx 10a9c9: 85 c9 test %ecx,%ecx
10a9cb: 0f 84 8f 00 00 00 je 10aa60 <ualarm+0xa8>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
10a9d1: 83 ec 0c sub $0xc,%esp 10a9d4: 68 e0 9f 12 00 push $0x129fe0 10a9d9: e8 4e 38 00 00 call 10e22c <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10a9de: 83 e8 02 sub $0x2,%eax 10a9e1: 83 c4 10 add $0x10,%esp 10a9e4: 83 f8 01 cmp $0x1,%eax
10a9e7: 0f 86 a3 00 00 00 jbe 10aa90 <ualarm+0xd8> <== ALWAYS TAKEN
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10a9ed: 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 ) {
10a9ef: 85 db test %ebx,%ebx
10a9f1: 74 62 je 10aa55 <ualarm+0x9d>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10a9f3: ba 83 de 1b 43 mov $0x431bde83,%edx 10a9f8: 89 d8 mov %ebx,%eax 10a9fa: f7 e2 mul %edx 10a9fc: c1 ea 12 shr $0x12,%edx 10a9ff: 89 55 f0 mov %edx,-0x10(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10aa02: 8d 04 92 lea (%edx,%edx,4),%eax 10aa05: 8d 04 80 lea (%eax,%eax,4),%eax 10aa08: 8d 04 80 lea (%eax,%eax,4),%eax 10aa0b: 8d 04 80 lea (%eax,%eax,4),%eax 10aa0e: 8d 04 80 lea (%eax,%eax,4),%eax 10aa11: 8d 04 80 lea (%eax,%eax,4),%eax 10aa14: c1 e0 06 shl $0x6,%eax 10aa17: 29 c3 sub %eax,%ebx 10aa19: 8d 04 9b lea (%ebx,%ebx,4),%eax 10aa1c: 8d 04 80 lea (%eax,%eax,4),%eax 10aa1f: 8d 04 80 lea (%eax,%eax,4),%eax 10aa22: c1 e0 03 shl $0x3,%eax 10aa25: 89 45 f4 mov %eax,-0xc(%ebp)
ticks = _Timespec_To_ticks( &tp );
10aa28: 83 ec 0c sub $0xc,%esp 10aa2b: 8d 5d f0 lea -0x10(%ebp),%ebx 10aa2e: 53 push %ebx 10aa2f: e8 4c 33 00 00 call 10dd80 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10aa34: 89 1c 24 mov %ebx,(%esp) 10aa37: e8 44 33 00 00 call 10dd80 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10aa3c: a3 ec 9f 12 00 mov %eax,0x129fec
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10aa41: 58 pop %eax 10aa42: 5a pop %edx 10aa43: 68 e0 9f 12 00 push $0x129fe0 10aa48: 68 00 97 12 00 push $0x129700 10aa4d: e8 9a 36 00 00 call 10e0ec <_Watchdog_Insert> 10aa52: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10aa55: 89 f0 mov %esi,%eax 10aa57: 8d 65 f8 lea -0x8(%ebp),%esp 10aa5a: 5b pop %ebx 10aa5b: 5e pop %esi 10aa5c: c9 leave 10aa5d: c3 ret 10aa5e: 66 90 xchg %ax,%ax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10aa60: c7 05 e8 9f 12 00 00 movl $0x0,0x129fe8
10aa67: 00 00 00 the_watchdog->routine = routine;
10aa6a: c7 05 fc 9f 12 00 7c movl $0x10a97c,0x129ffc
10aa71: a9 10 00 the_watchdog->id = id;
10aa74: c7 05 00 a0 12 00 00 movl $0x0,0x12a000
10aa7b: 00 00 00 the_watchdog->user_data = user_data;
10aa7e: c7 05 04 a0 12 00 00 movl $0x0,0x12a004
10aa85: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10aa88: 31 f6 xor %esi,%esi 10aa8a: e9 60 ff ff ff jmp 10a9ef <ualarm+0x37> 10aa8f: 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);
10aa90: a1 f4 9f 12 00 mov 0x129ff4,%eax 10aa95: 03 05 ec 9f 12 00 add 0x129fec,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10aa9b: 83 ec 08 sub $0x8,%esp 10aa9e: 8d 55 f0 lea -0x10(%ebp),%edx 10aaa1: 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);
10aaa2: 2b 05 f8 9f 12 00 sub 0x129ff8,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10aaa8: 50 push %eax 10aaa9: e8 4a 32 00 00 call 10dcf8 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
10aaae: 8b 45 f0 mov -0x10(%ebp),%eax 10aab1: 8d 04 80 lea (%eax,%eax,4),%eax 10aab4: 8d 04 80 lea (%eax,%eax,4),%eax 10aab7: 8d 04 80 lea (%eax,%eax,4),%eax 10aaba: 8d 04 80 lea (%eax,%eax,4),%eax 10aabd: 8d 04 80 lea (%eax,%eax,4),%eax 10aac0: 8d 0c 80 lea (%eax,%eax,4),%ecx 10aac3: c1 e1 06 shl $0x6,%ecx
remaining += tp.tv_nsec / 1000;
10aac6: 8b 75 f4 mov -0xc(%ebp),%esi 10aac9: b8 d3 4d 62 10 mov $0x10624dd3,%eax 10aace: f7 ee imul %esi 10aad0: 89 d0 mov %edx,%eax 10aad2: c1 f8 06 sar $0x6,%eax 10aad5: c1 fe 1f sar $0x1f,%esi 10aad8: 29 f0 sub %esi,%eax 10aada: 8d 34 08 lea (%eax,%ecx,1),%esi 10aadd: 83 c4 10 add $0x10,%esp 10aae0: e9 0a ff ff ff jmp 10a9ef <ualarm+0x37>