0010be9c <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) {
10be9c: 55 push %ebp 10be9d: 89 e5 mov %esp,%ebp 10be9f: 53 push %ebx 10bea0: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10bea3: 8b 1d b8 7f 12 00 mov 0x127fb8,%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10bea9: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10beaf: 74 10 je 10bec1 <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN
10beb1: 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)();
10beb4: 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 ) {
10beb7: 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 );
10beb9: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10bebf: 75 f3 jne 10beb4 <_API_extensions_Run_postdriver+0x18>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10bec1: 58 pop %eax 10bec2: 5b pop %ebx 10bec3: c9 leave 10bec4: c3 ret
0010bec8 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10bec8: 55 push %ebp 10bec9: 89 e5 mov %esp,%ebp 10becb: 53 push %ebx 10becc: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10becf: 8b 1d b8 7f 12 00 mov 0x127fb8,%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10bed5: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10bedb: 74 1c je 10bef9 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN
10bedd: 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 );
10bee0: 83 ec 0c sub $0xc,%esp 10bee3: ff 35 38 83 12 00 pushl 0x128338 10bee9: 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 ) {
10beec: 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 );
10beee: 83 c4 10 add $0x10,%esp 10bef1: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10bef7: 75 e7 jne 10bee0 <_API_extensions_Run_postswitch+0x18>
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10bef9: 8b 5d fc mov -0x4(%ebp),%ebx 10befc: c9 leave 10befd: c3 ret
0010e3e0 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10e3e0: 55 push %ebp 10e3e1: 89 e5 mov %esp,%ebp 10e3e3: 57 push %edi 10e3e4: 56 push %esi 10e3e5: 53 push %ebx 10e3e6: 83 ec 1c sub $0x1c,%esp 10e3e9: 8b 5d 08 mov 0x8(%ebp),%ebx 10e3ec: 8b 7d 0c mov 0xc(%ebp),%edi 10e3ef: 8b 4d 14 mov 0x14(%ebp),%ecx 10e3f2: 8a 55 10 mov 0x10(%ebp),%dl
ISR_Level level; Thread_Control *executing = _Thread_Executing;
10e3f5: 8b 35 d8 bc 12 00 mov 0x12bcd8,%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 );
10e3fb: 9c pushf 10e3fc: fa cli 10e3fd: 8f 45 e4 popl -0x1c(%ebp)
switch ( the_rwlock->current_state ) {
10e400: 8b 43 44 mov 0x44(%ebx),%eax 10e403: 85 c0 test %eax,%eax
10e405: 75 1d jne 10e424 <_CORE_RWLock_Obtain_for_reading+0x44>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10e407: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
the_rwlock->number_of_readers += 1;
10e40e: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10e411: ff 75 e4 pushl -0x1c(%ebp) 10e414: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e415: 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 */
}
10e41c: 8d 65 f4 lea -0xc(%ebp),%esp 10e41f: 5b pop %ebx 10e420: 5e pop %esi 10e421: 5f pop %edi 10e422: c9 leave 10e423: 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 ) {
10e424: 48 dec %eax
10e425: 74 51 je 10e478 <_CORE_RWLock_Obtain_for_reading+0x98>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10e427: 84 d2 test %dl,%dl
10e429: 75 15 jne 10e440 <_CORE_RWLock_Obtain_for_reading+0x60>
_ISR_Enable( level );
10e42b: ff 75 e4 pushl -0x1c(%ebp) 10e42e: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e42f: 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 */
}
10e436: 8d 65 f4 lea -0xc(%ebp),%esp 10e439: 5b pop %ebx 10e43a: 5e pop %esi 10e43b: 5f pop %edi 10e43c: c9 leave 10e43d: c3 ret 10e43e: 66 90 xchg %ax,%ax 10e440: 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;
10e447: 89 5e 44 mov %ebx,0x44(%esi)
executing->Wait.id = id;
10e44a: 89 7e 20 mov %edi,0x20(%esi)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
10e44d: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e454: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Enable( level );
10e45b: ff 75 e4 pushl -0x1c(%ebp) 10e45e: 9d popf
_Thread_queue_Enqueue_with_handler(
10e45f: c7 45 10 e4 e5 10 00 movl $0x10e5e4,0x10(%ebp) 10e466: 89 4d 0c mov %ecx,0xc(%ebp) 10e469: 89 5d 08 mov %ebx,0x8(%ebp)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e46c: 8d 65 f4 lea -0xc(%ebp),%esp 10e46f: 5b pop %ebx 10e470: 5e pop %esi 10e471: 5f pop %edi 10e472: 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(
10e473: e9 1c 1c 00 00 jmp 110094 <_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 );
10e478: 83 ec 0c sub $0xc,%esp 10e47b: 53 push %ebx 10e47c: 88 55 e0 mov %dl,-0x20(%ebp) 10e47f: 89 4d dc mov %ecx,-0x24(%ebp) 10e482: e8 35 1f 00 00 call 1103bc <_Thread_queue_First>
if ( !waiter ) {
10e487: 83 c4 10 add $0x10,%esp 10e48a: 85 c0 test %eax,%eax 10e48c: 8a 55 e0 mov -0x20(%ebp),%dl 10e48f: 8b 4d dc mov -0x24(%ebp),%ecx
10e492: 75 93 jne 10e427 <_CORE_RWLock_Obtain_for_reading+0x47> the_rwlock->number_of_readers += 1;
10e494: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10e497: ff 75 e4 pushl -0x1c(%ebp) 10e49a: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e49b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
return;
10e4a2: e9 75 ff ff ff jmp 10e41c <_CORE_RWLock_Obtain_for_reading+0x3c>
0010e4a8 <_CORE_RWLock_Obtain_for_writing>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10e4a8: 55 push %ebp 10e4a9: 89 e5 mov %esp,%ebp 10e4ab: 57 push %edi 10e4ac: 56 push %esi 10e4ad: 53 push %ebx 10e4ae: 83 ec 0c sub $0xc,%esp 10e4b1: 8b 45 08 mov 0x8(%ebp),%eax 10e4b4: 8b 7d 0c mov 0xc(%ebp),%edi 10e4b7: 8b 75 14 mov 0x14(%ebp),%esi 10e4ba: 8a 5d 10 mov 0x10(%ebp),%bl
ISR_Level level; Thread_Control *executing = _Thread_Executing;
10e4bd: 8b 15 d8 bc 12 00 mov 0x12bcd8,%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 );
10e4c3: 9c pushf 10e4c4: fa cli 10e4c5: 59 pop %ecx
switch ( the_rwlock->current_state ) {
10e4c6: 83 78 44 00 cmpl $0x0,0x44(%eax)
10e4ca: 75 18 jne 10e4e4 <_CORE_RWLock_Obtain_for_writing+0x3c>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10e4cc: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax)
_ISR_Enable( level );
10e4d3: 51 push %ecx 10e4d4: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e4d5: 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 */
}
10e4dc: 83 c4 0c add $0xc,%esp 10e4df: 5b pop %ebx 10e4e0: 5e pop %esi 10e4e1: 5f pop %edi 10e4e2: c9 leave 10e4e3: c3 ret
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10e4e4: 84 db test %bl,%bl
10e4e6: 75 14 jne 10e4fc <_CORE_RWLock_Obtain_for_writing+0x54>
_ISR_Enable( level );
10e4e8: 51 push %ecx 10e4e9: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e4ea: 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 */
}
10e4f1: 83 c4 0c add $0xc,%esp 10e4f4: 5b pop %ebx 10e4f5: 5e pop %esi 10e4f6: 5f pop %edi 10e4f7: c9 leave 10e4f8: c3 ret 10e4f9: 8d 76 00 lea 0x0(%esi),%esi 10e4fc: 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;
10e503: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10e506: 89 7a 20 mov %edi,0x20(%edx)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
10e509: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e510: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Enable( level );
10e517: 51 push %ecx 10e518: 9d popf
_Thread_queue_Enqueue_with_handler(
10e519: c7 45 10 e4 e5 10 00 movl $0x10e5e4,0x10(%ebp) 10e520: 89 75 0c mov %esi,0xc(%ebp) 10e523: 89 45 08 mov %eax,0x8(%ebp)
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e526: 83 c4 0c add $0xc,%esp 10e529: 5b pop %ebx 10e52a: 5e pop %esi 10e52b: 5f pop %edi 10e52c: 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(
10e52d: e9 62 1b 00 00 jmp 110094 <_Thread_queue_Enqueue_with_handler>
0010e534 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10e534: 55 push %ebp 10e535: 89 e5 mov %esp,%ebp 10e537: 53 push %ebx 10e538: 83 ec 04 sub $0x4,%esp 10e53b: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level; Thread_Control *executing = _Thread_Executing;
10e53e: 8b 0d d8 bc 12 00 mov 0x12bcd8,%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 );
10e544: 9c pushf 10e545: fa cli 10e546: 5a pop %edx
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10e547: 8b 43 44 mov 0x44(%ebx),%eax 10e54a: 85 c0 test %eax,%eax
10e54c: 74 7a je 10e5c8 <_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 ) {
10e54e: 48 dec %eax
10e54f: 74 63 je 10e5b4 <_CORE_RWLock_Release+0x80>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e551: 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;
10e558: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10e55f: 52 push %edx 10e560: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10e561: 83 ec 0c sub $0xc,%esp 10e564: 53 push %ebx 10e565: e8 02 1a 00 00 call 10ff6c <_Thread_queue_Dequeue>
if ( next ) {
10e56a: 83 c4 10 add $0x10,%esp 10e56d: 85 c0 test %eax,%eax
10e56f: 74 39 je 10e5aa <_CORE_RWLock_Release+0x76>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10e571: 83 78 30 01 cmpl $0x1,0x30(%eax)
10e575: 74 61 je 10e5d8 <_CORE_RWLock_Release+0xa4>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10e577: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10e57a: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) 10e581: eb 17 jmp 10e59a <_CORE_RWLock_Release+0x66> 10e583: 90 nop
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
10e584: 83 78 30 01 cmpl $0x1,0x30(%eax)
10e588: 74 20 je 10e5aa <_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;
10e58a: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10e58d: 83 ec 08 sub $0x8,%esp 10e590: 50 push %eax 10e591: 53 push %ebx 10e592: e8 0d 1d 00 00 call 1102a4 <_Thread_queue_Extract>
}
10e597: 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 );
10e59a: 83 ec 0c sub $0xc,%esp 10e59d: 53 push %ebx 10e59e: e8 19 1e 00 00 call 1103bc <_Thread_queue_First>
if ( !next ||
10e5a3: 83 c4 10 add $0x10,%esp 10e5a6: 85 c0 test %eax,%eax
10e5a8: 75 da jne 10e584 <_CORE_RWLock_Release+0x50>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5aa: 31 c0 xor %eax,%eax 10e5ac: 8b 5d fc mov -0x4(%ebp),%ebx 10e5af: c9 leave 10e5b0: c3 ret 10e5b1: 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;
10e5b4: 8b 43 48 mov 0x48(%ebx),%eax 10e5b7: 48 dec %eax 10e5b8: 89 43 48 mov %eax,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10e5bb: 85 c0 test %eax,%eax
10e5bd: 74 92 je 10e551 <_CORE_RWLock_Release+0x1d>
/* must be unlocked again */
_ISR_Enable( level );
10e5bf: 52 push %edx 10e5c0: 9d popf
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5c1: 31 c0 xor %eax,%eax 10e5c3: 8b 5d fc mov -0x4(%ebp),%ebx 10e5c6: c9 leave 10e5c7: c3 ret
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
10e5c8: 52 push %edx 10e5c9: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e5ca: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx)
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5d1: 31 c0 xor %eax,%eax 10e5d3: 8b 5d fc mov -0x4(%ebp),%ebx 10e5d6: c9 leave 10e5d7: 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;
10e5d8: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10e5df: eb c9 jmp 10e5aa <_CORE_RWLock_Release+0x76>
0010e5e4 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10e5e4: 55 push %ebp 10e5e5: 89 e5 mov %esp,%ebp 10e5e7: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e5ea: 8d 45 f4 lea -0xc(%ebp),%eax 10e5ed: 50 push %eax 10e5ee: ff 75 08 pushl 0x8(%ebp) 10e5f1: e8 1e 16 00 00 call 10fc14 <_Thread_Get>
switch ( location ) {
10e5f6: 83 c4 10 add $0x10,%esp 10e5f9: 8b 55 f4 mov -0xc(%ebp),%edx 10e5fc: 85 d2 test %edx,%edx
10e5fe: 75 17 jne 10e617 <_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 );
10e600: 83 ec 0c sub $0xc,%esp 10e603: 50 push %eax 10e604: e8 93 1e 00 00 call 11049c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e609: a1 30 b7 12 00 mov 0x12b730,%eax 10e60e: 48 dec %eax 10e60f: a3 30 b7 12 00 mov %eax,0x12b730 10e614: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e617: c9 leave 10e618: c3 ret
001198dc <_CORE_message_queue_Broadcast>:
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
1198dc: 55 push %ebp 1198dd: 89 e5 mov %esp,%ebp 1198df: 57 push %edi 1198e0: 56 push %esi 1198e1: 53 push %ebx 1198e2: 83 ec 1c sub $0x1c,%esp 1198e5: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
1198e8: 8b 45 10 mov 0x10(%ebp),%eax 1198eb: 39 43 4c cmp %eax,0x4c(%ebx)
1198ee: 72 60 jb 119950 <_CORE_message_queue_Broadcast+0x74><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
1198f0: 8b 43 48 mov 0x48(%ebx),%eax 1198f3: 85 c0 test %eax,%eax
1198f5: 75 45 jne 11993c <_CORE_message_queue_Broadcast+0x60>
1198f7: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1198fe: eb 18 jmp 119918 <_CORE_message_queue_Broadcast+0x3c>
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
119900: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
119903: 8b 42 2c mov 0x2c(%edx),%eax 119906: 89 c7 mov %eax,%edi 119908: 8b 75 0c mov 0xc(%ebp),%esi 11990b: 8b 4d 10 mov 0x10(%ebp),%ecx 11990e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
119910: 8b 42 28 mov 0x28(%edx),%eax 119913: 8b 55 10 mov 0x10(%ebp),%edx 119916: 89 10 mov %edx,(%eax)
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
119918: 83 ec 0c sub $0xc,%esp 11991b: 53 push %ebx 11991c: e8 af 28 00 00 call 11c1d0 <_Thread_queue_Dequeue> 119921: 89 c2 mov %eax,%edx 119923: 83 c4 10 add $0x10,%esp 119926: 85 c0 test %eax,%eax
119928: 75 d6 jne 119900 <_CORE_message_queue_Broadcast+0x24>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
11992a: 8b 55 e4 mov -0x1c(%ebp),%edx 11992d: 8b 45 1c mov 0x1c(%ebp),%eax 119930: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
119932: 31 c0 xor %eax,%eax
}
119934: 8d 65 f4 lea -0xc(%ebp),%esp 119937: 5b pop %ebx 119938: 5e pop %esi 119939: 5f pop %edi 11993a: c9 leave 11993b: c3 ret
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
*count = 0;
11993c: 8b 55 1c mov 0x1c(%ebp),%edx 11993f: c7 02 00 00 00 00 movl $0x0,(%edx)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
119945: 31 c0 xor %eax,%eax
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
119947: 8d 65 f4 lea -0xc(%ebp),%esp 11994a: 5b pop %ebx 11994b: 5e pop %esi 11994c: 5f pop %edi 11994d: c9 leave 11994e: c3 ret 11994f: 90 nop
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
119950: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
119955: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119958: 5b pop %ebx <== NOT EXECUTED 119959: 5e pop %esi <== NOT EXECUTED 11995a: 5f pop %edi <== NOT EXECUTED 11995b: c9 leave <== NOT EXECUTED 11995c: c3 ret <== NOT EXECUTED
00114a1c <_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
)
{
114a1c: 55 push %ebp 114a1d: 89 e5 mov %esp,%ebp 114a1f: 57 push %edi 114a20: 56 push %esi 114a21: 53 push %ebx 114a22: 83 ec 0c sub $0xc,%esp 114a25: 8b 5d 08 mov 0x8(%ebp),%ebx 114a28: 8b 75 10 mov 0x10(%ebp),%esi 114a2b: 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;
114a2e: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
114a31: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
114a38: 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;
114a3b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
114a42: 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)) {
114a49: a8 03 test $0x3,%al
114a4b: 74 17 je 114a64 <_CORE_message_queue_Initialize+0x48>
allocated_message_size += sizeof(uint32_t);
114a4d: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uint32_t) - 1);
114a50: 83 e2 fc and $0xfffffffc,%edx
}
if (allocated_message_size < maximum_message_size)
114a53: 39 d0 cmp %edx,%eax
114a55: 76 0f jbe 114a66 <_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;
114a57: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
114a59: 8d 65 f4 lea -0xc(%ebp),%esp 114a5c: 5b pop %ebx 114a5d: 5e pop %esi 114a5e: 5f pop %edi 114a5f: c9 leave 114a60: c3 ret 114a61: 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)) {
114a64: 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));
114a66: 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 *
114a69: 89 f8 mov %edi,%eax 114a6b: 0f af c6 imul %esi,%eax
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
114a6e: 39 d0 cmp %edx,%eax
114a70: 72 e5 jb 114a57 <_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 );
114a72: 83 ec 0c sub $0xc,%esp 114a75: 50 push %eax 114a76: e8 4d 2b 00 00 call 1175c8 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
114a7b: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
114a7e: 83 c4 10 add $0x10,%esp 114a81: 85 c0 test %eax,%eax
114a83: 74 d2 je 114a57 <_CORE_message_queue_Initialize+0x3b>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
114a85: 57 push %edi 114a86: 56 push %esi 114a87: 50 push %eax 114a88: 8d 43 68 lea 0x68(%ebx),%eax 114a8b: 50 push %eax 114a8c: e8 47 52 00 00 call 119cd8 <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
114a91: 8d 43 54 lea 0x54(%ebx),%eax 114a94: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
114a97: 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 );
114a9e: 8d 43 50 lea 0x50(%ebx),%eax 114aa1: 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(
114aa4: 6a 06 push $0x6 114aa6: 68 80 00 00 00 push $0x80 114aab: 8b 45 0c mov 0xc(%ebp),%eax 114aae: 83 38 01 cmpl $0x1,(%eax) 114ab1: 0f 94 c0 sete %al 114ab4: 0f b6 c0 movzbl %al,%eax 114ab7: 50 push %eax 114ab8: 53 push %ebx 114ab9: e8 3e 22 00 00 call 116cfc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
114abe: 83 c4 20 add $0x20,%esp 114ac1: b0 01 mov $0x1,%al
}
114ac3: 8d 65 f4 lea -0xc(%ebp),%esp 114ac6: 5b pop %ebx 114ac7: 5e pop %esi 114ac8: 5f pop %edi 114ac9: c9 leave 114aca: c3 ret
001110e0 <_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
)
{
1110e0: 55 push %ebp 1110e1: 89 e5 mov %esp,%ebp 1110e3: 56 push %esi 1110e4: 53 push %ebx 1110e5: 83 ec 10 sub $0x10,%esp 1110e8: 8b 45 08 mov 0x8(%ebp),%eax 1110eb: 8b 55 0c mov 0xc(%ebp),%edx 1110ee: 8b 4d 10 mov 0x10(%ebp),%ecx 1110f1: 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 ) {
1110f4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx
1110fa: 74 70 je 11116c <_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 ) {
1110fc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx
111102: 0f 84 88 00 00 00 je 111190 <_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
}
111108: 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));
11110b: 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 ) ) {
11110e: 39 de cmp %ebx,%esi
111110: 74 05 je 111117 <_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 ) {
111112: 3b 4b 08 cmp 0x8(%ebx),%ecx
111115: 7d 45 jge 11115c <_CORE_message_queue_Insert_message+0x7c>
the_node = the_node->next;
continue;
}
break;
}
_ISR_Disable( level );
111117: 9c pushf 111118: fa cli 111119: 5e pop %esi
SET_NOTIFY();
11111a: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
11111d: 85 c9 test %ecx,%ecx 11111f: 0f 94 45 f7 sete -0x9(%ebp)
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
111123: 41 inc %ecx 111124: 89 48 48 mov %ecx,0x48(%eax)
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
111127: 8b 4b 04 mov 0x4(%ebx),%ecx
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
11112a: 89 4a 04 mov %ecx,0x4(%edx)
before_node = after_node->next;
11112d: 8b 19 mov (%ecx),%ebx
after_node->next = the_node;
11112f: 89 11 mov %edx,(%ecx)
the_node->next = before_node;
111131: 89 1a mov %ebx,(%edx)
before_node->previous = the_node;
111133: 89 53 04 mov %edx,0x4(%ebx)
_ISR_Enable( level );
111136: 56 push %esi 111137: 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 )
111138: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
11113c: 74 16 je 111154 <_CORE_message_queue_Insert_message+0x74>
11113e: 8b 50 60 mov 0x60(%eax),%edx 111141: 85 d2 test %edx,%edx
111143: 74 0f je 111154 <_CORE_message_queue_Insert_message+0x74>
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
111145: 8b 40 64 mov 0x64(%eax),%eax 111148: 89 45 08 mov %eax,0x8(%ebp)
#endif }
11114b: 83 c4 10 add $0x10,%esp 11114e: 5b pop %ebx 11114f: 5e pop %esi 111150: 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);
111151: ff e2 jmp *%edx 111153: 90 nop
#endif }
111154: 83 c4 10 add $0x10,%esp 111157: 5b pop %ebx 111158: 5e pop %esi 111159: c9 leave 11115a: c3 ret 11115b: 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;
11115c: 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 ) ) {
11115e: 39 de cmp %ebx,%esi
111160: 74 b5 je 111117 <_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 ) {
111162: 3b 4b 08 cmp 0x8(%ebx),%ecx
111165: 7c b0 jl 111117 <_CORE_message_queue_Insert_message+0x37>
111167: eb f3 jmp 11115c <_CORE_message_queue_Insert_message+0x7c> 111169: 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 );
11116c: 9c pushf 11116d: fa cli 11116e: 5b pop %ebx
SET_NOTIFY();
11116f: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
111172: 85 c9 test %ecx,%ecx 111174: 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++;
111178: 41 inc %ecx 111179: 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;
11117c: 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 );
11117f: 8d 70 54 lea 0x54(%eax),%esi 111182: 89 32 mov %esi,(%edx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
111184: 89 50 58 mov %edx,0x58(%eax)
old_last->next = the_node;
111187: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
111189: 89 4a 04 mov %ecx,0x4(%edx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
11118c: 53 push %ebx 11118d: 9d popf 11118e: eb a8 jmp 111138 <_CORE_message_queue_Insert_message+0x58>
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
111190: 9c pushf 111191: fa cli 111192: 5b pop %ebx
SET_NOTIFY();
111193: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
111196: 85 c9 test %ecx,%ecx 111198: 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++;
11119c: 41 inc %ecx 11119d: 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);
1111a0: 8d 48 50 lea 0x50(%eax),%ecx 1111a3: 89 4a 04 mov %ecx,0x4(%edx)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
1111a6: 8b 48 50 mov 0x50(%eax),%ecx
after_node->next = the_node;
1111a9: 89 50 50 mov %edx,0x50(%eax)
the_node->next = before_node;
1111ac: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
1111ae: 89 51 04 mov %edx,0x4(%ecx)
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
1111b1: 53 push %ebx 1111b2: 9d popf 1111b3: eb 83 jmp 111138 <_CORE_message_queue_Insert_message+0x58>
00114acc <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
114acc: 55 push %ebp 114acd: 89 e5 mov %esp,%ebp 114acf: 57 push %edi 114ad0: 56 push %esi 114ad1: 53 push %ebx 114ad2: 83 ec 2c sub $0x2c,%esp 114ad5: 8b 55 08 mov 0x8(%ebp),%edx 114ad8: 8b 45 0c mov 0xc(%ebp),%eax 114adb: 89 45 dc mov %eax,-0x24(%ebp) 114ade: 8b 4d 10 mov 0x10(%ebp),%ecx 114ae1: 89 4d e0 mov %ecx,-0x20(%ebp) 114ae4: 8b 45 14 mov 0x14(%ebp),%eax 114ae7: 8b 5d 1c mov 0x1c(%ebp),%ebx 114aea: 89 5d d8 mov %ebx,-0x28(%ebp) 114aed: 0f b6 7d 18 movzbl 0x18(%ebp),%edi
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
114af1: 8b 0d d8 0c 13 00 mov 0x130cd8,%ecx
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
114af7: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
114afe: 9c pushf 114aff: fa cli 114b00: 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 );
}
114b03: 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 );
114b06: 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))
114b09: 39 f3 cmp %esi,%ebx
114b0b: 74 7b je 114b88 <_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;
114b0d: 8b 0b mov (%ebx),%ecx
head->next = new_first;
114b0f: 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 );
114b12: 8d 72 50 lea 0x50(%edx),%esi 114b15: 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;
114b18: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
114b1b: ff 75 e4 pushl -0x1c(%ebp) 114b1e: 9d popf
*size_p = the_message->Contents.size;
114b1f: 8b 4b 0c mov 0xc(%ebx),%ecx 114b22: 89 08 mov %ecx,(%eax)
_Thread_Executing->Wait.count =
114b24: 8b 73 08 mov 0x8(%ebx),%esi 114b27: 8b 0d d8 0c 13 00 mov 0x130cd8,%ecx 114b2d: 89 71 24 mov %esi,0x24(%ecx)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
114b30: 8d 4b 10 lea 0x10(%ebx),%ecx 114b33: 89 4d e4 mov %ecx,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
114b36: 8b 08 mov (%eax),%ecx 114b38: 8b 7d e0 mov -0x20(%ebp),%edi 114b3b: 8b 75 e4 mov -0x1c(%ebp),%esi 114b3e: 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 );
114b40: 83 ec 0c sub $0xc,%esp 114b43: 52 push %edx 114b44: 89 55 d4 mov %edx,-0x2c(%ebp) 114b47: e8 20 1e 00 00 call 11696c <_Thread_queue_Dequeue>
if ( !the_thread ) {
114b4c: 83 c4 10 add $0x10,%esp 114b4f: 85 c0 test %eax,%eax 114b51: 8b 55 d4 mov -0x2c(%ebp),%edx
114b54: 0f 84 86 00 00 00 je 114be0 <_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;
114b5a: 8b 48 24 mov 0x24(%eax),%ecx 114b5d: 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;
114b60: 8b 48 30 mov 0x30(%eax),%ecx 114b63: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
114b66: 8b 70 2c mov 0x2c(%eax),%esi 114b69: 8b 7d e4 mov -0x1c(%ebp),%edi 114b6c: 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(
114b6e: 8b 43 08 mov 0x8(%ebx),%eax 114b71: 89 45 10 mov %eax,0x10(%ebp) 114b74: 89 5d 0c mov %ebx,0xc(%ebp) 114b77: 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 );
}
114b7a: 8d 65 f4 lea -0xc(%ebp),%esp 114b7d: 5b pop %ebx 114b7e: 5e pop %esi 114b7f: 5f pop %edi 114b80: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
114b81: e9 ae 51 00 00 jmp 119d34 <_CORE_message_queue_Insert_message> 114b86: 66 90 xchg %ax,%ax
return;
}
#endif
}
if ( !wait ) {
114b88: 89 fb mov %edi,%ebx 114b8a: 84 db test %bl,%bl
114b8c: 75 16 jne 114ba4 <_CORE_message_queue_Seize+0xd8>
_ISR_Enable( level );
114b8e: ff 75 e4 pushl -0x1c(%ebp) 114b91: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
114b92: 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 );
}
114b99: 8d 65 f4 lea -0xc(%ebp),%esp 114b9c: 5b pop %ebx 114b9d: 5e pop %esi 114b9e: 5f pop %edi 114b9f: c9 leave 114ba0: c3 ret 114ba1: 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;
114ba4: 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;
114bab: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
114bae: 8b 5d dc mov -0x24(%ebp),%ebx 114bb1: 89 59 20 mov %ebx,0x20(%ecx)
executing->Wait.return_argument_second.mutable_object = buffer;
114bb4: 8b 5d e0 mov -0x20(%ebp),%ebx 114bb7: 89 59 2c mov %ebx,0x2c(%ecx)
executing->Wait.return_argument = size_p;
114bba: 89 41 28 mov %eax,0x28(%ecx)
/* Wait.count will be filled in with the message priority */ _ISR_Enable( level );
114bbd: ff 75 e4 pushl -0x1c(%ebp) 114bc0: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
114bc1: c7 45 10 c0 6d 11 00 movl $0x116dc0,0x10(%ebp) 114bc8: 8b 45 d8 mov -0x28(%ebp),%eax 114bcb: 89 45 0c mov %eax,0xc(%ebp) 114bce: 89 55 08 mov %edx,0x8(%ebp)
}
114bd1: 8d 65 f4 lea -0xc(%ebp),%esp 114bd4: 5b pop %ebx 114bd5: 5e pop %esi 114bd6: 5f pop %edi 114bd7: 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 );
114bd8: e9 b7 1e 00 00 jmp 116a94 <_Thread_queue_Enqueue_with_handler> 114bdd: 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 );
114be0: 89 5d 0c mov %ebx,0xc(%ebp) 114be3: 83 c2 68 add $0x68,%edx 114be6: 89 55 08 mov %edx,0x8(%ebp)
}
114be9: 8d 65 f4 lea -0xc(%ebp),%esp 114bec: 5b pop %ebx 114bed: 5e pop %esi 114bee: 5f pop %edi 114bef: c9 leave 114bf0: e9 a7 fd ff ff jmp 11499c <_Chain_Append>
0010c038 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
10c038: 55 push %ebp 10c039: 89 e5 mov %esp,%ebp 10c03b: 57 push %edi 10c03c: 56 push %esi 10c03d: 53 push %ebx 10c03e: 83 ec 1c sub $0x1c,%esp 10c041: 8b 5d 08 mov 0x8(%ebp),%ebx 10c044: 8b 75 0c mov 0xc(%ebp),%esi 10c047: 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 ) {
10c04a: 8b 45 10 mov 0x10(%ebp),%eax 10c04d: 39 43 4c cmp %eax,0x4c(%ebx)
10c050: 72 32 jb 10c084 <_CORE_message_queue_Submit+0x4c>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
10c052: 8b 43 48 mov 0x48(%ebx),%eax 10c055: 85 c0 test %eax,%eax
10c057: 74 3b je 10c094 <_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 <
10c059: 39 43 44 cmp %eax,0x44(%ebx)
10c05c: 0f 87 ba 00 00 00 ja 10c11c <_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 ) {
10c062: 84 c9 test %cl,%cl
10c064: 0f 84 ee 00 00 00 je 10c158 <_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() ) {
10c06a: 8b 15 34 83 12 00 mov 0x128334,%edx 10c070: 85 d2 test %edx,%edx
10c072: 74 60 je 10c0d4 <_CORE_message_queue_Submit+0x9c>
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
10c074: 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
}
10c079: 8d 65 f4 lea -0xc(%ebp),%esp 10c07c: 5b pop %ebx 10c07d: 5e pop %esi 10c07e: 5f pop %edi 10c07f: c9 leave 10c080: c3 ret 10c081: 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;
10c084: 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
}
10c089: 8d 65 f4 lea -0xc(%ebp),%esp 10c08c: 5b pop %ebx 10c08d: 5e pop %esi 10c08e: 5f pop %edi 10c08f: c9 leave 10c090: c3 ret 10c091: 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 );
10c094: 83 ec 0c sub $0xc,%esp 10c097: 53 push %ebx 10c098: 88 4d e4 mov %cl,-0x1c(%ebp) 10c09b: e8 8c 1c 00 00 call 10dd2c <_Thread_queue_Dequeue> 10c0a0: 89 c2 mov %eax,%edx
if ( the_thread ) {
10c0a2: 83 c4 10 add $0x10,%esp 10c0a5: 85 c0 test %eax,%eax 10c0a7: 8a 4d e4 mov -0x1c(%ebp),%cl
10c0aa: 0f 84 b8 00 00 00 je 10c168 <_CORE_message_queue_Submit+0x130>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c0b0: 8b 40 2c mov 0x2c(%eax),%eax 10c0b3: 89 c7 mov %eax,%edi 10c0b5: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0b8: 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;
10c0ba: 8b 42 28 mov 0x28(%edx),%eax 10c0bd: 8b 4d 10 mov 0x10(%ebp),%ecx 10c0c0: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = (uint32_t) submit_type;
10c0c2: 8b 45 1c mov 0x1c(%ebp),%eax 10c0c5: 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;
10c0c8: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c0ca: 8d 65 f4 lea -0xc(%ebp),%esp 10c0cd: 5b pop %ebx 10c0ce: 5e pop %esi 10c0cf: 5f pop %edi 10c0d0: c9 leave 10c0d1: c3 ret 10c0d2: 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;
10c0d4: a1 38 83 12 00 mov 0x128338,%eax
ISR_Level level;
_ISR_Disable( level );
10c0d9: 9c pushf 10c0da: fa cli 10c0db: 59 pop %ecx
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c0dc: 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;
10c0e3: 89 58 44 mov %ebx,0x44(%eax)
executing->Wait.id = id;
10c0e6: 8b 55 14 mov 0x14(%ebp),%edx 10c0e9: 89 50 20 mov %edx,0x20(%eax)
executing->Wait.return_argument_second.immutable_object = buffer;
10c0ec: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.option = (uint32_t) size;
10c0ef: 8b 55 10 mov 0x10(%ebp),%edx 10c0f2: 89 50 30 mov %edx,0x30(%eax)
executing->Wait.count = submit_type;
10c0f5: 8b 55 1c mov 0x1c(%ebp),%edx 10c0f8: 89 50 24 mov %edx,0x24(%eax)
_ISR_Enable( level );
10c0fb: 51 push %ecx 10c0fc: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
10c0fd: 50 push %eax 10c0fe: 68 80 e1 10 00 push $0x10e180 10c103: ff 75 24 pushl 0x24(%ebp) 10c106: 53 push %ebx 10c107: e8 48 1d 00 00 call 10de54 <_Thread_queue_Enqueue_with_handler>
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
10c10c: 83 c4 10 add $0x10,%esp 10c10f: b8 07 00 00 00 mov $0x7,%eax
#endif }
10c114: 8d 65 f4 lea -0xc(%ebp),%esp 10c117: 5b pop %ebx 10c118: 5e pop %esi 10c119: 5f pop %edi 10c11a: c9 leave 10c11b: 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 );
10c11c: 83 ec 0c sub $0xc,%esp 10c11f: 8d 43 68 lea 0x68(%ebx),%eax 10c122: 50 push %eax 10c123: e8 ec fe ff ff call 10c014 <_Chain_Get> 10c128: 89 c2 mov %eax,%edx
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
#endif
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
10c12a: 8d 40 10 lea 0x10(%eax),%eax
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c12d: 89 c7 mov %eax,%edi 10c12f: 8b 4d 10 mov 0x10(%ebp),%ecx 10c132: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
size
);
the_message->Contents.size = size;
10c134: 8b 4d 10 mov 0x10(%ebp),%ecx 10c137: 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;
10c13a: 8b 45 1c mov 0x1c(%ebp),%eax 10c13d: 89 42 08 mov %eax,0x8(%edx)
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
10c140: 83 c4 0c add $0xc,%esp 10c143: 50 push %eax 10c144: 52 push %edx 10c145: 53 push %ebx 10c146: e8 95 4f 00 00 call 1110e0 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
10c14b: 83 c4 10 add $0x10,%esp 10c14e: 31 c0 xor %eax,%eax 10c150: e9 34 ff ff ff jmp 10c089 <_CORE_message_queue_Submit+0x51> 10c155: 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;
10c158: 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
}
10c15d: 8d 65 f4 lea -0xc(%ebp),%esp 10c160: 5b pop %ebx 10c161: 5e pop %esi 10c162: 5f pop %edi 10c163: c9 leave 10c164: c3 ret 10c165: 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 ) {
10c168: 8b 43 48 mov 0x48(%ebx),%eax 10c16b: e9 e9 fe ff ff jmp 10c059 <_CORE_message_queue_Submit+0x21>
0010c17c <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10c17c: 55 push %ebp 10c17d: 89 e5 mov %esp,%ebp 10c17f: 57 push %edi 10c180: 56 push %esi 10c181: 53 push %ebx 10c182: 83 ec 0c sub $0xc,%esp 10c185: 8b 45 08 mov 0x8(%ebp),%eax 10c188: 8b 5d 0c mov 0xc(%ebp),%ebx 10c18b: 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;
10c18e: 8d 78 40 lea 0x40(%eax),%edi 10c191: b9 04 00 00 00 mov $0x4,%ecx 10c196: 89 de mov %ebx,%esi 10c198: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10c19a: 89 50 50 mov %edx,0x50(%eax)
the_mutex->blocked_count = 0;
10c19d: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10c1a4: 85 d2 test %edx,%edx
10c1a6: 75 30 jne 10c1d8 <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10c1a8: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
the_mutex->holder = _Thread_Executing;
10c1af: 8b 15 38 83 12 00 mov 0x128338,%edx 10c1b5: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = _Thread_Executing->Object.id;
10c1b8: 8b 4a 08 mov 0x8(%edx),%ecx 10c1bb: 89 48 60 mov %ecx,0x60(%eax)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c1be: 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 ) ||
10c1c1: 83 f9 02 cmp $0x2,%ecx
10c1c4: 74 05 je 10c1cb <_CORE_mutex_Initialize+0x4f>
10c1c6: 83 f9 03 cmp $0x3,%ecx
10c1c9: 75 22 jne 10c1ed <_CORE_mutex_Initialize+0x71>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10c1cb: 8b 48 4c mov 0x4c(%eax),%ecx 10c1ce: 39 4a 14 cmp %ecx,0x14(%edx)
10c1d1: 72 41 jb 10c214 <_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++;
10c1d3: ff 42 1c incl 0x1c(%edx) 10c1d6: eb 15 jmp 10c1ed <_CORE_mutex_Initialize+0x71>
}
} else {
the_mutex->nest_count = 0;
10c1d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_mutex->holder = NULL;
10c1df: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
the_mutex->holder_id = 0;
10c1e6: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
}
_Thread_queue_Initialize(
10c1ed: 6a 05 push $0x5 10c1ef: 68 00 04 00 00 push $0x400 10c1f4: 31 d2 xor %edx,%edx 10c1f6: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10c1fa: 0f 95 c2 setne %dl 10c1fd: 52 push %edx 10c1fe: 50 push %eax 10c1ff: e8 b8 1e 00 00 call 10e0bc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c204: 83 c4 10 add $0x10,%esp 10c207: 31 c0 xor %eax,%eax
}
10c209: 8d 65 f4 lea -0xc(%ebp),%esp 10c20c: 5b pop %ebx 10c20d: 5e pop %esi 10c20e: 5f pop %edi 10c20f: c9 leave 10c210: c3 ret 10c211: 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;
10c214: b8 06 00 00 00 mov $0x6,%eax
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c219: 8d 65 f4 lea -0xc(%ebp),%esp 10c21c: 5b pop %ebx 10c21d: 5e pop %esi 10c21e: 5f pop %edi 10c21f: c9 leave 10c220: c3 ret
0010c274 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10c274: 55 push %ebp 10c275: 89 e5 mov %esp,%ebp 10c277: 53 push %ebx 10c278: 83 ec 14 sub $0x14,%esp 10c27b: 8b 5d 08 mov 0x8(%ebp),%ebx 10c27e: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c281: a1 90 7d 12 00 mov 0x127d90,%eax 10c286: 85 c0 test %eax,%eax
10c288: 74 04 je 10c28e <_CORE_mutex_Seize+0x1a>
10c28a: 84 d2 test %dl,%dl
10c28c: 75 36 jne 10c2c4 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN
10c28e: 83 ec 08 sub $0x8,%esp 10c291: 8d 45 18 lea 0x18(%ebp),%eax 10c294: 50 push %eax 10c295: 53 push %ebx 10c296: 88 55 f4 mov %dl,-0xc(%ebp) 10c299: e8 1a 4f 00 00 call 1111b8 <_CORE_mutex_Seize_interrupt_trylock> 10c29e: 83 c4 10 add $0x10,%esp 10c2a1: 85 c0 test %eax,%eax 10c2a3: 8a 55 f4 mov -0xc(%ebp),%dl
10c2a6: 74 14 je 10c2bc <_CORE_mutex_Seize+0x48>
10c2a8: 84 d2 test %dl,%dl
10c2aa: 75 30 jne 10c2dc <_CORE_mutex_Seize+0x68>
10c2ac: ff 75 18 pushl 0x18(%ebp) 10c2af: 9d popf 10c2b0: a1 38 83 12 00 mov 0x128338,%eax 10c2b5: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10c2bc: 8b 5d fc mov -0x4(%ebp),%ebx 10c2bf: c9 leave 10c2c0: c3 ret 10c2c1: 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 );
10c2c4: 83 3d 20 7f 12 00 01 cmpl $0x1,0x127f20
10c2cb: 76 c1 jbe 10c28e <_CORE_mutex_Seize+0x1a>
10c2cd: 53 push %ebx 10c2ce: 6a 12 push $0x12 10c2d0: 6a 00 push $0x0 10c2d2: 6a 00 push $0x0 10c2d4: e8 1b 06 00 00 call 10c8f4 <_Internal_error_Occurred> 10c2d9: 8d 76 00 lea 0x0(%esi),%esi 10c2dc: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10c2e3: a1 38 83 12 00 mov 0x128338,%eax 10c2e8: 89 58 44 mov %ebx,0x44(%eax) 10c2eb: 8b 55 0c mov 0xc(%ebp),%edx 10c2ee: 89 50 20 mov %edx,0x20(%eax) 10c2f1: a1 90 7d 12 00 mov 0x127d90,%eax 10c2f6: 40 inc %eax 10c2f7: a3 90 7d 12 00 mov %eax,0x127d90 10c2fc: ff 75 18 pushl 0x18(%ebp) 10c2ff: 9d popf 10c300: 83 ec 08 sub $0x8,%esp 10c303: ff 75 14 pushl 0x14(%ebp) 10c306: 53 push %ebx 10c307: e8 18 ff ff ff call 10c224 <_CORE_mutex_Seize_interrupt_blocking> 10c30c: 83 c4 10 add $0x10,%esp
}
10c30f: 8b 5d fc mov -0x4(%ebp),%ebx 10c312: c9 leave 10c313: c3 ret
001111b8 <_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
)
{
1111b8: 55 push %ebp 1111b9: 89 e5 mov %esp,%ebp 1111bb: 56 push %esi 1111bc: 53 push %ebx 1111bd: 8b 45 08 mov 0x8(%ebp),%eax 1111c0: 8b 4d 0c mov 0xc(%ebp),%ecx
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
1111c3: 8b 15 38 83 12 00 mov 0x128338,%edx
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
1111c9: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
1111d0: 8b 58 50 mov 0x50(%eax),%ebx 1111d3: 85 db test %ebx,%ebx
1111d5: 74 31 je 111208 <_CORE_mutex_Seize_interrupt_trylock+0x50>
the_mutex->lock = CORE_MUTEX_LOCKED;
1111d7: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
the_mutex->holder = executing;
1111de: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = executing->Object.id;
1111e1: 8b 5a 08 mov 0x8(%edx),%ebx 1111e4: 89 58 60 mov %ebx,0x60(%eax)
the_mutex->nest_count = 1;
1111e7: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
1111ee: 8b 58 48 mov 0x48(%eax),%ebx
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
1111f1: 83 fb 02 cmp $0x2,%ebx
1111f4: 74 26 je 11121c <_CORE_mutex_Seize_interrupt_trylock+0x64>
1111f6: 83 fb 03 cmp $0x3,%ebx
1111f9: 74 3d je 111238 <_CORE_mutex_Seize_interrupt_trylock+0x80>
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
1111fb: ff 31 pushl (%ecx) 1111fd: 9d popf
return 0;
1111fe: 31 c0 xor %eax,%eax 111200: 8d 65 f8 lea -0x8(%ebp),%esp 111203: 5b pop %ebx 111204: 5e pop %esi 111205: c9 leave 111206: c3 ret 111207: 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 ) ) {
111208: 3b 50 5c cmp 0x5c(%eax),%edx
11120b: 74 17 je 111224 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
11120d: b8 01 00 00 00 mov $0x1,%eax 111212: 8d 65 f8 lea -0x8(%ebp),%esp 111215: 5b pop %ebx 111216: 5e pop %esi 111217: c9 leave 111218: c3 ret 111219: 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++;
11121c: ff 42 1c incl 0x1c(%edx) 11121f: eb da jmp 1111fb <_CORE_mutex_Seize_interrupt_trylock+0x43> 111221: 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 ) {
111224: 8b 58 40 mov 0x40(%eax),%ebx 111227: 85 db test %ebx,%ebx
111229: 75 45 jne 111270 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
11122b: ff 40 54 incl 0x54(%eax)
_ISR_Enable( *level_p );
11122e: ff 31 pushl (%ecx) 111230: 9d popf
return 0;
111231: 31 c0 xor %eax,%eax 111233: eb dd jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111235: 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++;
111238: 8b 5a 1c mov 0x1c(%edx),%ebx 11123b: 8d 73 01 lea 0x1(%ebx),%esi 11123e: 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 ) {
111241: 8b 72 14 mov 0x14(%edx),%esi 111244: 39 70 4c cmp %esi,0x4c(%eax)
111247: 74 6b je 1112b4 <_CORE_mutex_Seize_interrupt_trylock+0xfc>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
111249: 72 39 jb 111284 <_CORE_mutex_Seize_interrupt_trylock+0xcc>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
11124b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
111252: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax)
the_mutex->nest_count = 0; /* undo locking above */
111259: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
executing->resource_count--; /* undo locking above */
111260: 89 5a 1c mov %ebx,0x1c(%edx)
_ISR_Enable( *level_p );
111263: ff 31 pushl (%ecx) 111265: 9d popf
return 0;
111266: 31 c0 xor %eax,%eax 111268: 8d 65 f8 lea -0x8(%ebp),%esp 11126b: 5b pop %ebx 11126c: 5e pop %esi 11126d: c9 leave 11126e: c3 ret 11126f: 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 ) {
111270: 4b dec %ebx
111271: 75 9a jne 11120d <_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;
111273: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
_ISR_Enable( *level_p );
11127a: ff 31 pushl (%ecx) 11127c: 9d popf
return 0;
11127d: 31 c0 xor %eax,%eax 11127f: eb 91 jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 111281: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
111284: 8b 15 90 7d 12 00 mov 0x127d90,%edx 11128a: 42 inc %edx 11128b: 89 15 90 7d 12 00 mov %edx,0x127d90
return 0;
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
111291: ff 31 pushl (%ecx) 111293: 9d popf
_Thread_Change_priority(
111294: 52 push %edx 111295: 6a 00 push $0x0 111297: ff 70 4c pushl 0x4c(%eax) 11129a: ff 70 5c pushl 0x5c(%eax) 11129d: e8 d6 c2 ff ff call 10d578 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
1112a2: e8 09 c7 ff ff call 10d9b0 <_Thread_Enable_dispatch> 1112a7: 83 c4 10 add $0x10,%esp
return 0;
1112aa: 31 c0 xor %eax,%eax 1112ac: e9 61 ff ff ff jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 1112b1: 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 );
1112b4: ff 31 pushl (%ecx) 1112b6: 9d popf
return 0;
1112b7: 31 c0 xor %eax,%eax 1112b9: e9 54 ff ff ff jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
0010c314 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
10c314: 55 push %ebp 10c315: 89 e5 mov %esp,%ebp 10c317: 53 push %ebx 10c318: 83 ec 04 sub $0x4,%esp 10c31b: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
10c31e: 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 ) {
10c321: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10c325: 74 15 je 10c33c <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10c327: 3b 05 38 83 12 00 cmp 0x128338,%eax
10c32d: 74 0d je 10c33c <_CORE_mutex_Surrender+0x28>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
10c32f: b8 03 00 00 00 mov $0x3,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c334: 8b 5d fc mov -0x4(%ebp),%ebx 10c337: c9 leave 10c338: c3 ret 10c339: 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 )
10c33c: 8b 53 54 mov 0x54(%ebx),%edx 10c33f: 85 d2 test %edx,%edx
10c341: 74 51 je 10c394 <_CORE_mutex_Surrender+0x80>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10c343: 4a dec %edx 10c344: 89 53 54 mov %edx,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10c347: 85 d2 test %edx,%edx
10c349: 75 49 jne 10c394 <_CORE_mutex_Surrender+0x80>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c34b: 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 ) ||
10c34e: 83 fa 02 cmp $0x2,%edx
10c351: 74 69 je 10c3bc <_CORE_mutex_Surrender+0xa8>
10c353: 83 fa 03 cmp $0x3,%edx
10c356: 74 64 je 10c3bc <_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;
10c358: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10c35f: 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 ) ) ) {
10c366: 83 ec 0c sub $0xc,%esp 10c369: 53 push %ebx 10c36a: e8 bd 19 00 00 call 10dd2c <_Thread_queue_Dequeue> 10c36f: 83 c4 10 add $0x10,%esp 10c372: 85 c0 test %eax,%eax
10c374: 74 7a je 10c3f0 <_CORE_mutex_Surrender+0xdc>
} else
#endif
{
the_mutex->holder = the_thread;
10c376: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10c379: 8b 50 08 mov 0x8(%eax),%edx 10c37c: 89 53 60 mov %edx,0x60(%ebx)
the_mutex->nest_count = 1;
10c37f: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10c386: 8b 53 48 mov 0x48(%ebx),%edx 10c389: 83 fa 02 cmp $0x2,%edx
10c38c: 74 56 je 10c3e4 <_CORE_mutex_Surrender+0xd0>
10c38e: 83 fa 03 cmp $0x3,%edx
10c391: 74 09 je 10c39c <_CORE_mutex_Surrender+0x88>
10c393: 90 nop
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c394: 31 c0 xor %eax,%eax
}
10c396: 8b 5d fc mov -0x4(%ebp),%ebx 10c399: c9 leave 10c39a: c3 ret 10c39b: 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++;
10c39c: ff 40 1c incl 0x1c(%eax)
if (the_mutex->Attributes.priority_ceiling <
10c39f: 8b 53 4c mov 0x4c(%ebx),%edx 10c3a2: 3b 50 14 cmp 0x14(%eax),%edx
10c3a5: 73 ed jae 10c394 <_CORE_mutex_Surrender+0x80>
the_thread->current_priority){
_Thread_Change_priority(
10c3a7: 51 push %ecx 10c3a8: 6a 00 push $0x0 10c3aa: 52 push %edx 10c3ab: 50 push %eax 10c3ac: e8 c7 11 00 00 call 10d578 <_Thread_Change_priority> 10c3b1: 83 c4 10 add $0x10,%esp
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3b4: 31 c0 xor %eax,%eax 10c3b6: e9 79 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20> 10c3bb: 90 nop
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
10c3bc: 8b 50 1c mov 0x1c(%eax),%edx 10c3bf: 4a dec %edx 10c3c0: 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 &&
10c3c3: 85 d2 test %edx,%edx
10c3c5: 75 91 jne 10c358 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
10c3c7: 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 &&
10c3ca: 3b 50 14 cmp 0x14(%eax),%edx
10c3cd: 74 89 je 10c358 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
10c3cf: 51 push %ecx 10c3d0: 6a 01 push $0x1 10c3d2: 52 push %edx 10c3d3: 50 push %eax 10c3d4: e8 9f 11 00 00 call 10d578 <_Thread_Change_priority> 10c3d9: 83 c4 10 add $0x10,%esp 10c3dc: e9 77 ff ff ff jmp 10c358 <_CORE_mutex_Surrender+0x44> 10c3e1: 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++;
10c3e4: ff 40 1c incl 0x1c(%eax)
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3e7: 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;
10c3e9: e9 46 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20> 10c3ee: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10c3f0: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3f7: 31 c0 xor %eax,%eax 10c3f9: e9 36 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20>
001152b8 <_CORE_semaphore_Seize>:
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
1152b8: 55 push %ebp 1152b9: 89 e5 mov %esp,%ebp 1152bb: 57 push %edi 1152bc: 56 push %esi 1152bd: 53 push %ebx 1152be: 83 ec 1c sub $0x1c,%esp 1152c1: 8b 45 08 mov 0x8(%ebp),%eax 1152c4: 8b 7d 0c mov 0xc(%ebp),%edi 1152c7: 8b 75 14 mov 0x14(%ebp),%esi 1152ca: 8a 5d 10 mov 0x10(%ebp),%bl
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
1152cd: 8b 15 b8 e0 12 00 mov 0x12e0b8,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
1152d3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Disable( level );
1152da: 9c pushf 1152db: fa cli 1152dc: 8f 45 e4 popl -0x1c(%ebp)
if ( the_semaphore->count != 0 ) {
1152df: 8b 48 48 mov 0x48(%eax),%ecx 1152e2: 85 c9 test %ecx,%ecx
1152e4: 75 46 jne 11532c <_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 ) {
1152e6: 84 db test %bl,%bl
1152e8: 75 16 jne 115300 <_CORE_semaphore_Seize+0x48>
_ISR_Enable( level );
1152ea: ff 75 e4 pushl -0x1c(%ebp) 1152ed: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
1152ee: 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 ); }
1152f5: 83 c4 1c add $0x1c,%esp 1152f8: 5b pop %ebx 1152f9: 5e pop %esi 1152fa: 5f pop %edi 1152fb: c9 leave 1152fc: c3 ret 1152fd: 8d 76 00 lea 0x0(%esi),%esi 115300: 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;
115307: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
11530a: 89 7a 20 mov %edi,0x20(%edx)
_ISR_Enable( level );
11530d: ff 75 e4 pushl -0x1c(%ebp) 115310: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
115311: c7 45 10 a4 1b 11 00 movl $0x111ba4,0x10(%ebp) 115318: 89 75 0c mov %esi,0xc(%ebp) 11531b: 89 45 08 mov %eax,0x8(%ebp)
}
11531e: 83 c4 1c add $0x1c,%esp 115321: 5b pop %ebx 115322: 5e pop %esi 115323: 5f pop %edi 115324: 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 );
115325: e9 4e c5 ff ff jmp 111878 <_Thread_queue_Enqueue_with_handler> 11532a: 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;
11532c: 49 dec %ecx 11532d: 89 48 48 mov %ecx,0x48(%eax)
_ISR_Enable( level );
115330: ff 75 e4 pushl -0x1c(%ebp) 115333: 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 ); }
115334: 83 c4 1c add $0x1c,%esp 115337: 5b pop %ebx 115338: 5e pop %esi 115339: 5f pop %edi 11533a: c9 leave 11533b: c3 ret
0010c44c <_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
)
{
10c44c: 55 push %ebp 10c44d: 89 e5 mov %esp,%ebp 10c44f: 53 push %ebx 10c450: 83 ec 10 sub $0x10,%esp 10c453: 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)) ) {
10c456: 53 push %ebx 10c457: e8 d0 18 00 00 call 10dd2c <_Thread_queue_Dequeue> 10c45c: 83 c4 10 add $0x10,%esp 10c45f: 85 c0 test %eax,%eax
10c461: 74 09 je 10c46c <_CORE_semaphore_Surrender+0x20>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c463: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10c465: 8b 5d fc mov -0x4(%ebp),%ebx 10c468: c9 leave 10c469: c3 ret 10c46a: 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 );
10c46c: 9c pushf 10c46d: fa cli 10c46e: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10c46f: 8b 43 48 mov 0x48(%ebx),%eax 10c472: 3b 43 40 cmp 0x40(%ebx),%eax
10c475: 72 0d jb 10c484 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10c477: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10c47c: 52 push %edx 10c47d: 9d popf
}
return status;
}
10c47e: 8b 5d fc mov -0x4(%ebp),%ebx 10c481: c9 leave 10c482: c3 ret 10c483: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10c484: 40 inc %eax 10c485: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c488: 31 c0 xor %eax,%eax 10c48a: eb f0 jmp 10c47c <_CORE_semaphore_Surrender+0x30>
0010c6ac <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
10c6ac: 55 push %ebp 10c6ad: 89 e5 mov %esp,%ebp 10c6af: 57 push %edi 10c6b0: 56 push %esi 10c6b1: 53 push %ebx 10c6b2: 8b 45 08 mov 0x8(%ebp),%eax 10c6b5: 8b 7d 0c mov 0xc(%ebp),%edi
ISR_Level level;
bool is_empty_now;
_ISR_Disable( level );
10c6b8: 9c pushf 10c6b9: fa cli 10c6ba: 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 );
10c6bb: 8d 58 04 lea 0x4(%eax),%ebx
Chain_Node *old_first = head->next;
10c6be: 8b 10 mov (%eax),%edx
if ( old_first != tail ) {
10c6c0: 39 d3 cmp %edx,%ebx
10c6c2: 74 18 je 10c6dc <_Chain_Get_with_empty_check+0x30>
Chain_Node *new_first = old_first->next;
10c6c4: 8b 0a mov (%edx),%ecx
head->next = new_first;
10c6c6: 89 08 mov %ecx,(%eax)
new_first->previous = head;
10c6c8: 89 41 04 mov %eax,0x4(%ecx)
*the_node = old_first;
10c6cb: 89 17 mov %edx,(%edi)
is_empty_now = new_first == tail;
10c6cd: 39 cb cmp %ecx,%ebx 10c6cf: 0f 94 c0 sete %al
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level );
10c6d2: 56 push %esi 10c6d3: 9d popf
return is_empty_now;
}
10c6d4: 5b pop %ebx 10c6d5: 5e pop %esi 10c6d6: 5f pop %edi 10c6d7: c9 leave 10c6d8: c3 ret 10c6d9: 8d 76 00 lea 0x0(%esi),%esi
} else
*the_node = NULL;
10c6dc: 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;
10c6e2: b0 01 mov $0x1,%al 10c6e4: eb ec jmp 10c6d2 <_Chain_Get_with_empty_check+0x26>
00111084 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
111084: 55 push %ebp 111085: 89 e5 mov %esp,%ebp 111087: 57 push %edi 111088: 56 push %esi 111089: 53 push %ebx 11108a: 83 ec 08 sub $0x8,%esp 11108d: 8b 7d 08 mov 0x8(%ebp),%edi 111090: 8b 4d 10 mov 0x10(%ebp),%ecx 111093: 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 );
111096: 8d 47 04 lea 0x4(%edi),%eax 111099: 89 45 f0 mov %eax,-0x10(%ebp)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
11109c: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
while ( count-- ) {
1110a3: 85 c9 test %ecx,%ecx
1110a5: 74 35 je 1110dc <_Chain_Initialize+0x58><== NEVER TAKEN
1110a7: 49 dec %ecx 1110a8: 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;
1110ab: 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;
1110ae: 89 fa mov %edi,%edx 1110b0: eb 07 jmp 1110b9 <_Chain_Initialize+0x35> 1110b2: 66 90 xchg %ax,%ax
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
1110b4: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
1110b6: 89 d8 mov %ebx,%eax 1110b8: 49 dec %ecx
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
1110b9: 89 02 mov %eax,(%edx)
next->previous = current;
1110bb: 89 50 04 mov %edx,0x4(%eax)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
1110be: 8d 1c 30 lea (%eax,%esi,1),%ebx
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
1110c1: 85 c9 test %ecx,%ecx
1110c3: 75 ef jne 1110b4 <_Chain_Initialize+0x30>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
1110c5: 0f af 75 ec imul -0x14(%ebp),%esi 1110c9: 03 75 0c add 0xc(%ebp),%esi
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
1110cc: 8b 45 f0 mov -0x10(%ebp),%eax 1110cf: 89 06 mov %eax,(%esi)
tail->previous = current;
1110d1: 89 77 08 mov %esi,0x8(%edi)
}
1110d4: 83 c4 08 add $0x8,%esp 1110d7: 5b pop %ebx 1110d8: 5e pop %esi 1110d9: 5f pop %edi 1110da: c9 leave 1110db: 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;
1110dc: 89 fe mov %edi,%esi <== NOT EXECUTED 1110de: eb ec jmp 1110cc <_Chain_Initialize+0x48><== NOT EXECUTED
0010b070 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
10b070: 55 push %ebp 10b071: 89 e5 mov %esp,%ebp 10b073: 57 push %edi 10b074: 56 push %esi 10b075: 53 push %ebx 10b076: 83 ec 2c sub $0x2c,%esp 10b079: 8b 45 08 mov 0x8(%ebp),%eax 10b07c: 8b 4d 0c mov 0xc(%ebp),%ecx 10b07f: 8b 55 10 mov 0x10(%ebp),%edx 10b082: 89 55 dc mov %edx,-0x24(%ebp) 10b085: 8b 7d 14 mov 0x14(%ebp),%edi
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
10b088: 8b 1d 38 83 12 00 mov 0x128338,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
10b08e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10b095: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi
_ISR_Disable( level );
10b09b: 9c pushf 10b09c: fa cli 10b09d: 8f 45 e0 popl -0x20(%ebp)
pending_events = api->pending_events;
10b0a0: 8b 16 mov (%esi),%edx 10b0a2: 89 55 d4 mov %edx,-0x2c(%ebp)
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
10b0a5: 21 c2 and %eax,%edx 10b0a7: 89 55 e4 mov %edx,-0x1c(%ebp)
10b0aa: 74 0d je 10b0b9 <_Event_Seize+0x49>
10b0ac: 39 d0 cmp %edx,%eax
10b0ae: 0f 84 84 00 00 00 je 10b138 <_Event_Seize+0xc8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
10b0b4: f6 c1 02 test $0x2,%cl
10b0b7: 75 7f jne 10b138 <_Event_Seize+0xc8>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
10b0b9: f6 c1 01 test $0x1,%cl
10b0bc: 75 62 jne 10b120 <_Event_Seize+0xb0> * set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set;
10b0be: 89 4b 30 mov %ecx,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
10b0c1: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
10b0c4: 89 7b 28 mov %edi,0x28(%ebx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10b0c7: c7 05 68 87 12 00 01 movl $0x1,0x128768
10b0ce: 00 00 00
_ISR_Enable( level );
10b0d1: ff 75 e0 pushl -0x20(%ebp) 10b0d4: 9d popf
if ( ticks ) {
10b0d5: 8b 45 dc mov -0x24(%ebp),%eax 10b0d8: 85 c0 test %eax,%eax
10b0da: 0f 85 80 00 00 00 jne 10b160 <_Event_Seize+0xf0>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
10b0e0: 83 ec 08 sub $0x8,%esp 10b0e3: 68 00 01 00 00 push $0x100 10b0e8: 53 push %ebx 10b0e9: e8 e2 30 00 00 call 10e1d0 <_Thread_Set_state>
_ISR_Disable( level );
10b0ee: 9c pushf 10b0ef: fa cli 10b0f0: 5a pop %edx
sync_state = _Event_Sync_state;
10b0f1: a1 68 87 12 00 mov 0x128768,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b0f6: c7 05 68 87 12 00 00 movl $0x0,0x128768
10b0fd: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
10b100: 83 c4 10 add $0x10,%esp 10b103: 83 f8 01 cmp $0x1,%eax
10b106: 74 4c je 10b154 <_Event_Seize+0xe4> * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
10b108: 89 55 10 mov %edx,0x10(%ebp) 10b10b: 89 5d 0c mov %ebx,0xc(%ebp) 10b10e: 89 45 08 mov %eax,0x8(%ebp)
}
10b111: 8d 65 f4 lea -0xc(%ebp),%esp 10b114: 5b pop %ebx 10b115: 5e pop %esi 10b116: 5f pop %edi 10b117: c9 leave
* An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
10b118: e9 0f 24 00 00 jmp 10d52c <_Thread_blocking_operation_Cancel> 10b11d: 8d 76 00 lea 0x0(%esi),%esi
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
10b120: ff 75 e0 pushl -0x20(%ebp) 10b123: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
10b124: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
10b12b: 8b 55 e4 mov -0x1c(%ebp),%edx 10b12e: 89 17 mov %edx,(%edi)
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); }
10b130: 8d 65 f4 lea -0xc(%ebp),%esp 10b133: 5b pop %ebx 10b134: 5e pop %esi 10b135: 5f pop %edi 10b136: c9 leave 10b137: c3 ret
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
10b138: 8b 45 e4 mov -0x1c(%ebp),%eax 10b13b: f7 d0 not %eax 10b13d: 23 45 d4 and -0x2c(%ebp),%eax 10b140: 89 06 mov %eax,(%esi)
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
10b142: ff 75 e0 pushl -0x20(%ebp) 10b145: 9d popf
*event_out = seized_events;
10b146: 8b 45 e4 mov -0x1c(%ebp),%eax 10b149: 89 07 mov %eax,(%edi)
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); }
10b14b: 8d 65 f4 lea -0xc(%ebp),%esp 10b14e: 5b pop %ebx 10b14f: 5e pop %esi 10b150: 5f pop %edi 10b151: c9 leave 10b152: c3 ret 10b153: 90 nop
_ISR_Disable( level );
sync_state = _Event_Sync_state;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
_ISR_Enable( level );
10b154: 52 push %edx 10b155: 9d popf
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); }
10b156: 8d 65 f4 lea -0xc(%ebp),%esp 10b159: 5b pop %ebx 10b15a: 5e pop %esi 10b15b: 5f pop %edi 10b15c: c9 leave 10b15d: c3 ret 10b15e: 66 90 xchg %ax,%ax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
10b160: 8b 43 08 mov 0x8(%ebx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b163: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10b16a: c7 43 64 14 b3 10 00 movl $0x10b314,0x64(%ebx)
the_watchdog->id = id;
10b171: 89 43 68 mov %eax,0x68(%ebx)
the_watchdog->user_data = user_data;
10b174: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b17b: 8b 45 dc mov -0x24(%ebp),%eax 10b17e: 89 43 54 mov %eax,0x54(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b181: 83 ec 08 sub $0x8,%esp
&executing->Timer,
_Event_Timeout,
executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
10b184: 8d 43 48 lea 0x48(%ebx),%eax 10b187: 50 push %eax 10b188: 68 60 7e 12 00 push $0x127e60 10b18d: e8 8e 35 00 00 call 10e720 <_Watchdog_Insert> 10b192: 83 c4 10 add $0x10,%esp 10b195: e9 46 ff ff ff jmp 10b0e0 <_Event_Seize+0x70>
0010b1f0 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
10b1f0: 55 push %ebp 10b1f1: 89 e5 mov %esp,%ebp 10b1f3: 57 push %edi 10b1f4: 56 push %esi 10b1f5: 53 push %ebx 10b1f6: 83 ec 2c sub $0x2c,%esp 10b1f9: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10b1fc: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx
option_set = (rtems_option) the_thread->Wait.option;
10b202: 8b 7b 30 mov 0x30(%ebx),%edi
_ISR_Disable( level );
10b205: 9c pushf 10b206: fa cli 10b207: 8f 45 d4 popl -0x2c(%ebp)
pending_events = api->pending_events;
10b20a: 8b 11 mov (%ecx),%edx
event_condition = (rtems_event_set) the_thread->Wait.count;
10b20c: 8b 43 24 mov 0x24(%ebx),%eax
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
10b20f: 89 c6 mov %eax,%esi 10b211: 21 d6 and %edx,%esi 10b213: 89 75 e4 mov %esi,-0x1c(%ebp)
10b216: 74 74 je 10b28c <_Event_Surrender+0x9c>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
10b218: 8b 35 34 83 12 00 mov 0x128334,%esi 10b21e: 85 f6 test %esi,%esi
10b220: 74 0c je 10b22e <_Event_Surrender+0x3e>
10b222: 3b 1d 38 83 12 00 cmp 0x128338,%ebx
10b228: 0f 84 96 00 00 00 je 10b2c4 <_Event_Surrender+0xd4>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
10b22e: f6 43 11 01 testb $0x1,0x11(%ebx)
10b232: 74 4c je 10b280 <_Event_Surrender+0x90>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
10b234: 3b 45 e4 cmp -0x1c(%ebp),%eax
10b237: 74 05 je 10b23e <_Event_Surrender+0x4e>
10b239: 83 e7 02 and $0x2,%edi
10b23c: 74 42 je 10b280 <_Event_Surrender+0x90> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
10b23e: 8b 45 e4 mov -0x1c(%ebp),%eax 10b241: f7 d0 not %eax 10b243: 21 d0 and %edx,%eax 10b245: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
10b247: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b24e: 8b 43 28 mov 0x28(%ebx),%eax 10b251: 8b 75 e4 mov -0x1c(%ebp),%esi 10b254: 89 30 mov %esi,(%eax)
_ISR_Flash( level );
10b256: ff 75 d4 pushl -0x2c(%ebp) 10b259: 9d popf 10b25a: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10b25b: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10b25f: 74 37 je 10b298 <_Event_Surrender+0xa8>
_ISR_Enable( level );
10b261: ff 75 d4 pushl -0x2c(%ebp) 10b264: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b265: 83 ec 08 sub $0x8,%esp 10b268: 68 f8 ff 03 10 push $0x1003fff8 10b26d: 53 push %ebx 10b26e: e8 d9 23 00 00 call 10d64c <_Thread_Clear_state> 10b273: 83 c4 10 add $0x10,%esp
}
return;
}
}
_ISR_Enable( level );
}
10b276: 8d 65 f4 lea -0xc(%ebp),%esp 10b279: 5b pop %ebx 10b27a: 5e pop %esi 10b27b: 5f pop %edi 10b27c: c9 leave 10b27d: c3 ret 10b27e: 66 90 xchg %ax,%ax
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
10b280: ff 75 d4 pushl -0x2c(%ebp) 10b283: 9d popf
}
10b284: 8d 65 f4 lea -0xc(%ebp),%esp 10b287: 5b pop %ebx 10b288: 5e pop %esi 10b289: 5f pop %edi 10b28a: c9 leave 10b28b: c3 ret
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
10b28c: ff 75 d4 pushl -0x2c(%ebp) 10b28f: 9d popf
}
return;
}
}
_ISR_Enable( level );
}
10b290: 8d 65 f4 lea -0xc(%ebp),%esp 10b293: 5b pop %ebx 10b294: 5e pop %esi 10b295: 5f pop %edi 10b296: c9 leave 10b297: c3 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10b298: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10b29f: ff 75 d4 pushl -0x2c(%ebp) 10b2a2: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10b2a3: 83 ec 0c sub $0xc,%esp 10b2a6: 8d 43 48 lea 0x48(%ebx),%eax 10b2a9: 50 push %eax 10b2aa: e8 b1 35 00 00 call 10e860 <_Watchdog_Remove> 10b2af: 58 pop %eax 10b2b0: 5a pop %edx 10b2b1: 68 f8 ff 03 10 push $0x1003fff8 10b2b6: 53 push %ebx 10b2b7: e8 90 23 00 00 call 10d64c <_Thread_Clear_state> 10b2bc: 83 c4 10 add $0x10,%esp 10b2bf: eb c3 jmp 10b284 <_Event_Surrender+0x94> 10b2c1: 8d 76 00 lea 0x0(%esi),%esi
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
10b2c4: 8b 35 68 87 12 00 mov 0x128768,%esi
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
10b2ca: 83 fe 02 cmp $0x2,%esi
10b2cd: 74 0d je 10b2dc <_Event_Surrender+0xec> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
10b2cf: 8b 35 68 87 12 00 mov 0x128768,%esi
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
10b2d5: 4e dec %esi
10b2d6: 0f 85 52 ff ff ff jne 10b22e <_Event_Surrender+0x3e>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
10b2dc: 3b 45 e4 cmp -0x1c(%ebp),%eax
10b2df: 74 05 je 10b2e6 <_Event_Surrender+0xf6>
10b2e1: 83 e7 02 and $0x2,%edi
10b2e4: 74 22 je 10b308 <_Event_Surrender+0x118><== NEVER TAKEN
10b2e6: 8b 45 e4 mov -0x1c(%ebp),%eax 10b2e9: f7 d0 not %eax 10b2eb: 21 d0 and %edx,%eax 10b2ed: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
10b2ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b2f6: 8b 43 28 mov 0x28(%ebx),%eax 10b2f9: 8b 55 e4 mov -0x1c(%ebp),%edx 10b2fc: 89 10 mov %edx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10b2fe: c7 05 68 87 12 00 03 movl $0x3,0x128768
10b305: 00 00 00
}
_ISR_Enable( level );
10b308: ff 75 d4 pushl -0x2c(%ebp) 10b30b: 9d popf
return;
10b30c: e9 73 ff ff ff jmp 10b284 <_Event_Surrender+0x94>
0010b314 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10b314: 55 push %ebp 10b315: 89 e5 mov %esp,%ebp 10b317: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10b31a: 8d 45 f4 lea -0xc(%ebp),%eax 10b31d: 50 push %eax 10b31e: ff 75 08 pushl 0x8(%ebp) 10b321: e8 ae 26 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10b326: 83 c4 10 add $0x10,%esp 10b329: 8b 55 f4 mov -0xc(%ebp),%edx 10b32c: 85 d2 test %edx,%edx
10b32e: 75 37 jne 10b367 <_Event_Timeout+0x53> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
10b330: 9c pushf 10b331: fa cli 10b332: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
10b333: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
10b33a: 3b 05 38 83 12 00 cmp 0x128338,%eax
10b340: 74 2a je 10b36c <_Event_Timeout+0x58>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
10b342: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
10b349: 52 push %edx 10b34a: 9d popf 10b34b: 83 ec 08 sub $0x8,%esp 10b34e: 68 f8 ff 03 10 push $0x1003fff8 10b353: 50 push %eax 10b354: e8 f3 22 00 00 call 10d64c <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b359: a1 90 7d 12 00 mov 0x127d90,%eax 10b35e: 48 dec %eax 10b35f: a3 90 7d 12 00 mov %eax,0x127d90
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
10b364: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b367: c9 leave 10b368: c3 ret 10b369: 8d 76 00 lea 0x0(%esi),%esi
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
10b36c: 8b 0d 68 87 12 00 mov 0x128768,%ecx 10b372: 49 dec %ecx
10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10b375: c7 05 68 87 12 00 02 movl $0x2,0x128768
10b37c: 00 00 00
10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e>
00111314 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
111314: 55 push %ebp 111315: 89 e5 mov %esp,%ebp 111317: 57 push %edi 111318: 56 push %esi 111319: 53 push %ebx 11131a: 83 ec 2c sub $0x2c,%esp 11131d: 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
111320: 8d 47 04 lea 0x4(%edi),%eax 111323: 89 45 dc mov %eax,-0x24(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
111326: 8b 55 08 mov 0x8(%ebp),%edx 111329: 8b 52 10 mov 0x10(%edx),%edx 11132c: 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 ) {
11132f: 39 c7 cmp %eax,%edi
111331: 0f 87 69 01 00 00 ja 1114a0 <_Heap_Allocate_aligned_with_boundary+0x18c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
111337: 8b 5d 14 mov 0x14(%ebp),%ebx 11133a: 85 db test %ebx,%ebx
11133c: 0f 85 56 01 00 00 jne 111498 <_Heap_Allocate_aligned_with_boundary+0x184>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111342: 8b 45 08 mov 0x8(%ebp),%eax 111345: 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 ) {
111348: 39 c8 cmp %ecx,%eax
11134a: 0f 84 50 01 00 00 je 1114a0 <_Heap_Allocate_aligned_with_boundary+0x18c>
111350: 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
111357: 8b 55 cc mov -0x34(%ebp),%edx 11135a: 83 c2 07 add $0x7,%edx 11135d: 89 55 c8 mov %edx,-0x38(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
111360: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 111367: 29 7d d0 sub %edi,-0x30(%ebp) 11136a: eb 1e jmp 11138a <_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;
11136c: 8d 59 08 lea 0x8(%ecx),%ebx
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
11136f: 85 db test %ebx,%ebx
111371: 0f 85 f1 00 00 00 jne 111468 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN
break;
}
block = block->next;
111377: 8b 49 08 mov 0x8(%ecx),%ecx 11137a: 8b 45 e4 mov -0x1c(%ebp),%eax 11137d: 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 ) {
11137e: 39 4d 08 cmp %ecx,0x8(%ebp)
111381: 0f 84 25 01 00 00 je 1114ac <_Heap_Allocate_aligned_with_boundary+0x198>
111387: 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 ) {
11138a: 8b 59 04 mov 0x4(%ecx),%ebx 11138d: 39 5d dc cmp %ebx,-0x24(%ebp)
111390: 73 e5 jae 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
if ( alignment == 0 ) {
111392: 8b 55 10 mov 0x10(%ebp),%edx 111395: 85 d2 test %edx,%edx
111397: 74 d3 je 11136c <_Heap_Allocate_aligned_with_boundary+0x58>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111399: 8b 45 08 mov 0x8(%ebp),%eax 11139c: 8b 40 14 mov 0x14(%eax),%eax 11139f: 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;
1113a2: 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;
1113a5: 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;
1113a8: 8d 51 08 lea 0x8(%ecx),%edx 1113ab: 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;
1113ae: 8b 75 c8 mov -0x38(%ebp),%esi 1113b1: 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
1113b3: 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;
1113b5: 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);
1113b8: 89 d8 mov %ebx,%eax 1113ba: 31 d2 xor %edx,%edx 1113bc: f7 75 10 divl 0x10(%ebp) 1113bf: 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 ) {
1113c1: 39 de cmp %ebx,%esi
1113c3: 73 0b jae 1113d0 <_Heap_Allocate_aligned_with_boundary+0xbc>
1113c5: 89 f0 mov %esi,%eax 1113c7: 31 d2 xor %edx,%edx 1113c9: f7 75 10 divl 0x10(%ebp) 1113cc: 89 f3 mov %esi,%ebx 1113ce: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
1113d0: 8b 45 14 mov 0x14(%ebp),%eax 1113d3: 85 c0 test %eax,%eax
1113d5: 74 5b je 111432 <_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;
1113d7: 8d 34 3b lea (%ebx,%edi,1),%esi 1113da: 89 f0 mov %esi,%eax 1113dc: 31 d2 xor %edx,%edx 1113de: f7 75 14 divl 0x14(%ebp) 1113e1: 89 f0 mov %esi,%eax 1113e3: 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 ) {
1113e5: 39 c3 cmp %eax,%ebx
1113e7: 73 49 jae 111432 <_Heap_Allocate_aligned_with_boundary+0x11e>
1113e9: 39 c6 cmp %eax,%esi
1113eb: 76 45 jbe 111432 <_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;
1113ed: 8b 55 d4 mov -0x2c(%ebp),%edx 1113f0: 01 fa add %edi,%edx 1113f2: 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 ) {
1113f5: 39 c2 cmp %eax,%edx
1113f7: 0f 87 7a ff ff ff ja 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
1113fd: 89 ce mov %ecx,%esi 1113ff: eb 10 jmp 111411 <_Heap_Allocate_aligned_with_boundary+0xfd> 111401: 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 ) {
111404: 39 c1 cmp %eax,%ecx
111406: 76 28 jbe 111430 <_Heap_Allocate_aligned_with_boundary+0x11c>
if ( boundary_line < boundary_floor ) {
111408: 39 45 e0 cmp %eax,-0x20(%ebp)
11140b: 0f 87 9f 00 00 00 ja 1114b0 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
111411: 89 c3 mov %eax,%ebx 111413: 29 fb sub %edi,%ebx 111415: 89 d8 mov %ebx,%eax 111417: 31 d2 xor %edx,%edx 111419: f7 75 10 divl 0x10(%ebp) 11141c: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
11141e: 8d 0c 3b lea (%ebx,%edi,1),%ecx 111421: 89 c8 mov %ecx,%eax 111423: 31 d2 xor %edx,%edx 111425: f7 75 14 divl 0x14(%ebp) 111428: 89 c8 mov %ecx,%eax 11142a: 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 ) {
11142c: 39 c3 cmp %eax,%ebx
11142e: 72 d4 jb 111404 <_Heap_Allocate_aligned_with_boundary+0xf0>
111430: 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 ) {
111432: 39 5d d4 cmp %ebx,-0x2c(%ebp)
111435: 0f 87 3c ff ff ff ja 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
11143b: be f8 ff ff ff mov $0xfffffff8,%esi 111440: 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);
111442: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
111444: 89 d8 mov %ebx,%eax 111446: 31 d2 xor %edx,%edx 111448: 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;
11144b: 29 d6 sub %edx,%esi
if ( free_size >= min_block_size || free_size == 0 ) {
11144d: 39 75 d8 cmp %esi,-0x28(%ebp)
111450: 0f 86 19 ff ff ff jbe 11136f <_Heap_Allocate_aligned_with_boundary+0x5b>
111456: 85 f6 test %esi,%esi
111458: 0f 85 19 ff ff ff jne 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
11145e: 85 db test %ebx,%ebx
111460: 0f 84 11 ff ff ff je 111377 <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN
111466: 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;
111468: 8b 45 08 mov 0x8(%ebp),%eax 11146b: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
11146e: 8b 55 e4 mov -0x1c(%ebp),%edx 111471: 01 50 4c add %edx,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
111474: 57 push %edi 111475: 53 push %ebx 111476: 51 push %ecx 111477: 50 push %eax 111478: e8 83 b3 ff ff call 10c800 <_Heap_Block_allocate> 11147d: 89 d8 mov %ebx,%eax 11147f: 83 c4 10 add $0x10,%esp
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
111482: 8b 55 e4 mov -0x1c(%ebp),%edx 111485: 8b 4d 08 mov 0x8(%ebp),%ecx 111488: 39 51 44 cmp %edx,0x44(%ecx)
11148b: 73 15 jae 1114a2 <_Heap_Allocate_aligned_with_boundary+0x18e>
stats->max_search = search_count;
11148d: 89 51 44 mov %edx,0x44(%ecx)
}
return (void *) alloc_begin;
}
111490: 8d 65 f4 lea -0xc(%ebp),%esp 111493: 5b pop %ebx 111494: 5e pop %esi 111495: 5f pop %edi 111496: c9 leave 111497: c3 ret
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
111498: 3b 7d 14 cmp 0x14(%ebp),%edi
11149b: 76 1a jbe 1114b7 <_Heap_Allocate_aligned_with_boundary+0x1a3>
11149d: 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 ) {
1114a0: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
1114a2: 8d 65 f4 lea -0xc(%ebp),%esp 1114a5: 5b pop %ebx 1114a6: 5e pop %esi 1114a7: 5f pop %edi 1114a8: c9 leave 1114a9: c3 ret 1114aa: 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 ) {
1114ac: 31 c0 xor %eax,%eax 1114ae: eb d2 jmp 111482 <_Heap_Allocate_aligned_with_boundary+0x16e>
1114b0: 89 f1 mov %esi,%ecx <== NOT EXECUTED 1114b2: e9 c0 fe ff ff jmp 111377 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
1114b7: 8b 4d 10 mov 0x10(%ebp),%ecx 1114ba: 85 c9 test %ecx,%ecx
1114bc: 0f 85 80 fe ff ff jne 111342 <_Heap_Allocate_aligned_with_boundary+0x2e>
alignment = page_size;
1114c2: 89 55 10 mov %edx,0x10(%ebp) 1114c5: e9 78 fe ff ff jmp 111342 <_Heap_Allocate_aligned_with_boundary+0x2e>
001118a8 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
1118a8: 55 push %ebp 1118a9: 89 e5 mov %esp,%ebp 1118ab: 57 push %edi 1118ac: 56 push %esi 1118ad: 53 push %ebx 1118ae: 83 ec 4c sub $0x4c,%esp 1118b1: 8b 5d 08 mov 0x8(%ebp),%ebx 1118b4: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
1118b7: 8b 43 20 mov 0x20(%ebx),%eax 1118ba: 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;
1118bd: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
1118c4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
1118cb: 8b 53 10 mov 0x10(%ebx),%edx 1118ce: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
1118d1: 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;
1118d4: 8b 73 30 mov 0x30(%ebx),%esi 1118d7: 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 ) {
1118da: 8b 55 0c mov 0xc(%ebp),%edx 1118dd: 01 ca add %ecx,%edx 1118df: 89 55 cc mov %edx,-0x34(%ebp)
1118e2: 73 0c jae 1118f0 <_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;
1118e4: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
1118e6: 8d 65 f4 lea -0xc(%ebp),%esp 1118e9: 5b pop %ebx 1118ea: 5e pop %esi 1118eb: 5f pop %edi 1118ec: c9 leave 1118ed: c3 ret 1118ee: 66 90 xchg %ax,%ax
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
1118f0: 83 ec 08 sub $0x8,%esp 1118f3: 8d 55 e0 lea -0x20(%ebp),%edx 1118f6: 52 push %edx 1118f7: 8d 55 e4 lea -0x1c(%ebp),%edx 1118fa: 52 push %edx 1118fb: 50 push %eax 1118fc: ff 75 d4 pushl -0x2c(%ebp) 1118ff: 51 push %ecx 111900: ff 75 0c pushl 0xc(%ebp) 111903: e8 14 b1 ff ff call 10ca1c <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
111908: 83 c4 20 add $0x20,%esp 11190b: 84 c0 test %al,%al
11190d: 74 d5 je 1118e4 <_Heap_Extend+0x3c>
11190f: 8b 7d d0 mov -0x30(%ebp),%edi 111912: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 111919: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 111920: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 111927: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 11192e: 8b 75 cc mov -0x34(%ebp),%esi 111931: 89 5d b4 mov %ebx,-0x4c(%ebp) 111934: eb 30 jmp 111966 <_Heap_Extend+0xbe> 111936: 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 ) {
111938: 39 ce cmp %ecx,%esi
11193a: 73 03 jae 11193f <_Heap_Extend+0x97>
11193c: 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);
11193f: 8d 59 f8 lea -0x8(%ecx),%ebx 111942: 89 c8 mov %ecx,%eax 111944: 31 d2 xor %edx,%edx 111946: 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);
111949: 29 d3 sub %edx,%ebx
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
11194b: 3b 4d 0c cmp 0xc(%ebp),%ecx
11194e: 74 3c je 11198c <_Heap_Extend+0xe4> <== NEVER TAKEN
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
111950: 39 4d 0c cmp %ecx,0xc(%ebp)
111953: 76 03 jbe 111958 <_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 )
111955: 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;
111958: 8b 7b 04 mov 0x4(%ebx),%edi 11195b: 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);
11195e: 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 );
111961: 39 7d d0 cmp %edi,-0x30(%ebp)
111964: 74 39 je 11199f <_Heap_Extend+0xf7>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111966: 3b 7d d0 cmp -0x30(%ebp),%edi
111969: 0f 84 39 01 00 00 je 111aa8 <_Heap_Extend+0x200>
11196f: 89 f8 mov %edi,%eax
uintptr_t const sub_area_end = start_block->prev_size;
111971: 8b 0f mov (%edi),%ecx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
111973: 39 4d 0c cmp %ecx,0xc(%ebp)
111976: 73 08 jae 111980 <_Heap_Extend+0xd8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
111978: 39 f0 cmp %esi,%eax
11197a: 0f 82 64 ff ff ff jb 1118e4 <_Heap_Extend+0x3c>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
111980: 39 f0 cmp %esi,%eax
111982: 75 b4 jne 111938 <_Heap_Extend+0x90>
111984: 89 7d c4 mov %edi,-0x3c(%ebp) 111987: eb b6 jmp 11193f <_Heap_Extend+0x97> 111989: 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;
11198c: 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 )
11198e: 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;
111991: 8b 7b 04 mov 0x4(%ebx),%edi 111994: 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);
111997: 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 );
11199a: 39 7d d0 cmp %edi,-0x30(%ebp)
11199d: 75 c7 jne 111966 <_Heap_Extend+0xbe> <== NEVER TAKEN
11199f: 8b 5d b4 mov -0x4c(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
1119a2: 8b 75 0c mov 0xc(%ebp),%esi 1119a5: 3b 73 18 cmp 0x18(%ebx),%esi
1119a8: 0f 82 06 01 00 00 jb 111ab4 <_Heap_Extend+0x20c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
1119ae: 8b 45 cc mov -0x34(%ebp),%eax 1119b1: 3b 43 1c cmp 0x1c(%ebx),%eax
1119b4: 76 03 jbe 1119b9 <_Heap_Extend+0x111>
heap->area_end = extend_area_end;
1119b6: 89 43 1c mov %eax,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
1119b9: 8b 55 e0 mov -0x20(%ebp),%edx 1119bc: 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 =
1119bf: 89 d1 mov %edx,%ecx 1119c1: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
1119c3: 8b 75 cc mov -0x34(%ebp),%esi 1119c6: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
1119c8: 89 ce mov %ecx,%esi 1119ca: 83 ce 01 or $0x1,%esi 1119cd: 89 70 04 mov %esi,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
1119d0: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
1119d2: 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 ) {
1119d9: 39 43 20 cmp %eax,0x20(%ebx)
1119dc: 0f 86 da 00 00 00 jbe 111abc <_Heap_Extend+0x214>
heap->first_block = extend_first_block;
1119e2: 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 ) {
1119e5: 8b 75 c4 mov -0x3c(%ebp),%esi 1119e8: 85 f6 test %esi,%esi
1119ea: 0f 84 10 01 00 00 je 111b00 <_Heap_Extend+0x258>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
1119f0: 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 );
1119f3: 8b 4d 0c mov 0xc(%ebp),%ecx 1119f6: 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;
1119f9: 89 c8 mov %ecx,%eax 1119fb: 31 d2 xor %edx,%edx 1119fd: f7 f6 div %esi
if ( remainder != 0 ) {
1119ff: 85 d2 test %edx,%edx
111a01: 0f 84 c9 00 00 00 je 111ad0 <_Heap_Extend+0x228> <== ALWAYS TAKEN
return value - remainder + alignment;
111a07: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 111a0a: 29 d0 sub %edx,%eax <== NOT EXECUTED
uintptr_t const new_first_block_begin =
111a0c: 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;
111a0f: 8b 75 c4 mov -0x3c(%ebp),%esi 111a12: 8b 0e mov (%esi),%ecx 111a14: 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 =
111a17: 89 f0 mov %esi,%eax 111a19: 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;
111a1b: 83 c8 01 or $0x1,%eax 111a1e: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
111a21: 89 d8 mov %ebx,%eax 111a23: e8 64 fe ff ff call 11188c <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
111a28: 8b 45 c8 mov -0x38(%ebp),%eax 111a2b: 85 c0 test %eax,%eax
111a2d: 0f 84 a5 00 00 00 je 111ad8 <_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,
111a33: 8b 4d cc mov -0x34(%ebp),%ecx 111a36: 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(
111a39: 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);
111a3c: 89 c8 mov %ecx,%eax 111a3e: 31 d2 xor %edx,%edx 111a40: f7 73 10 divl 0x10(%ebx) 111a43: 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)
111a45: 8b 55 c8 mov -0x38(%ebp),%edx 111a48: 8b 42 04 mov 0x4(%edx),%eax 111a4b: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
111a4d: 83 c8 01 or $0x1,%eax 111a50: 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;
111a54: 8b 42 04 mov 0x4(%edx),%eax 111a57: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
111a5a: 09 c8 or %ecx,%eax 111a5c: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
111a5f: 89 d8 mov %ebx,%eax 111a61: e8 26 fe ff ff call 11188c <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111a66: 8b 75 c4 mov -0x3c(%ebp),%esi 111a69: 85 f6 test %esi,%esi
111a6b: 0f 84 ab 00 00 00 je 111b1c <_Heap_Extend+0x274>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
111a71: 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(
111a74: 8b 43 20 mov 0x20(%ebx),%eax 111a77: 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;
111a79: 8b 4a 04 mov 0x4(%edx),%ecx 111a7c: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
111a7f: 09 c8 or %ecx,%eax 111a81: 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;
111a84: 8b 43 30 mov 0x30(%ebx),%eax 111a87: 2b 45 c0 sub -0x40(%ebp),%eax
/* Statistics */
stats->size += extended_size;
111a8a: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
111a8d: 8b 55 14 mov 0x14(%ebp),%edx 111a90: 85 d2 test %edx,%edx
111a92: 0f 84 a0 00 00 00 je 111b38 <_Heap_Extend+0x290> <== NEVER TAKEN
*extended_size_ptr = extended_size;
111a98: 8b 55 14 mov 0x14(%ebp),%edx 111a9b: 89 02 mov %eax,(%edx)
return true;
111a9d: b0 01 mov $0x1,%al
}
111a9f: 8d 65 f4 lea -0xc(%ebp),%esp 111aa2: 5b pop %ebx 111aa3: 5e pop %esi 111aa4: 5f pop %edi 111aa5: c9 leave 111aa6: c3 ret 111aa7: 90 nop
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111aa8: 8b 55 b4 mov -0x4c(%ebp),%edx 111aab: 8b 42 18 mov 0x18(%edx),%eax 111aae: e9 be fe ff ff jmp 111971 <_Heap_Extend+0xc9> 111ab3: 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;
111ab4: 89 73 18 mov %esi,0x18(%ebx) 111ab7: e9 fd fe ff ff jmp 1119b9 <_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 ) {
111abc: 39 53 24 cmp %edx,0x24(%ebx)
111abf: 0f 83 20 ff ff ff jae 1119e5 <_Heap_Extend+0x13d>
heap->last_block = extend_last_block;
111ac5: 89 53 24 mov %edx,0x24(%ebx) 111ac8: e9 18 ff ff ff jmp 1119e5 <_Heap_Extend+0x13d> 111acd: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
} else {
return value;
111ad0: 89 c8 mov %ecx,%eax 111ad2: e9 35 ff ff ff jmp 111a0c <_Heap_Extend+0x164> 111ad7: 90 nop
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
111ad8: 8b 7d bc mov -0x44(%ebp),%edi 111adb: 85 ff test %edi,%edi
111add: 74 87 je 111a66 <_Heap_Extend+0x1be>
_Heap_Link_above(
111adf: 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 );
111ae2: 8b 45 e4 mov -0x1c(%ebp),%eax 111ae5: 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;
111ae8: 8b 75 bc mov -0x44(%ebp),%esi 111aeb: 8b 56 04 mov 0x4(%esi),%edx 111aee: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
111af1: 09 d0 or %edx,%eax 111af3: 89 46 04 mov %eax,0x4(%esi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
111af6: 83 49 04 01 orl $0x1,0x4(%ecx) 111afa: e9 67 ff ff ff jmp 111a66 <_Heap_Extend+0x1be> 111aff: 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 ) {
111b00: 8b 4d b8 mov -0x48(%ebp),%ecx 111b03: 85 c9 test %ecx,%ecx
111b05: 0f 84 1d ff ff ff je 111a28 <_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;
111b0b: 8b 45 b8 mov -0x48(%ebp),%eax 111b0e: 29 d0 sub %edx,%eax 111b10: 83 c8 01 or $0x1,%eax 111b13: 89 42 04 mov %eax,0x4(%edx) 111b16: e9 0d ff ff ff jmp 111a28 <_Heap_Extend+0x180> 111b1b: 90 nop
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111b1c: 8b 4d c8 mov -0x38(%ebp),%ecx 111b1f: 85 c9 test %ecx,%ecx
111b21: 0f 85 4a ff ff ff jne 111a71 <_Heap_Extend+0x1c9>
_Heap_Free_block( heap, extend_first_block );
111b27: 8b 55 e4 mov -0x1c(%ebp),%edx 111b2a: 89 d8 mov %ebx,%eax 111b2c: e8 5b fd ff ff call 11188c <_Heap_Free_block> 111b31: e9 3b ff ff ff jmp 111a71 <_Heap_Extend+0x1c9> 111b36: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
111b38: b0 01 mov $0x1,%al <== NOT EXECUTED 111b3a: e9 a7 fd ff ff jmp 1118e6 <_Heap_Extend+0x3e> <== NOT EXECUTED
001114cc <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
1114cc: 55 push %ebp 1114cd: 89 e5 mov %esp,%ebp 1114cf: 57 push %edi 1114d0: 56 push %esi 1114d1: 53 push %ebx 1114d2: 83 ec 10 sub $0x10,%esp 1114d5: 8b 5d 08 mov 0x8(%ebp),%ebx 1114d8: 8b 45 0c mov 0xc(%ebp),%eax 1114db: 8d 48 f8 lea -0x8(%eax),%ecx 1114de: 31 d2 xor %edx,%edx 1114e0: 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);
1114e3: 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
1114e5: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1114e8: 39 c1 cmp %eax,%ecx
1114ea: 72 07 jb 1114f3 <_Heap_Free+0x27>
1114ec: 8b 73 24 mov 0x24(%ebx),%esi 1114ef: 39 f1 cmp %esi,%ecx
1114f1: 76 0d jbe 111500 <_Heap_Free+0x34>
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
1114f3: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1114f5: 83 c4 10 add $0x10,%esp 1114f8: 5b pop %ebx 1114f9: 5e pop %esi 1114fa: 5f pop %edi 1114fb: c9 leave 1114fc: c3 ret 1114fd: 8d 76 00 lea 0x0(%esi),%esi 111500: 8b 51 04 mov 0x4(%ecx),%edx 111503: 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;
111506: 83 e2 fe and $0xfffffffe,%edx 111509: 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);
11150c: 8d 14 11 lea (%ecx,%edx,1),%edx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11150f: 39 d0 cmp %edx,%eax
111511: 77 e0 ja 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
111513: 39 d6 cmp %edx,%esi
111515: 72 dc jb 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
111517: 8b 7a 04 mov 0x4(%edx),%edi
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
11151a: f7 c7 01 00 00 00 test $0x1,%edi
111520: 74 d1 je 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
111522: 83 e7 fe and $0xfffffffe,%edi 111525: 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 ));
111528: 39 d6 cmp %edx,%esi
11152a: 0f 84 c8 00 00 00 je 1115f8 <_Heap_Free+0x12c>
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
111530: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 111535: 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 ) ) {
111539: f6 45 f0 01 testb $0x1,-0x10(%ebp)
11153d: 75 45 jne 111584 <_Heap_Free+0xb8>
uintptr_t const prev_size = block->prev_size;
11153f: 8b 39 mov (%ecx),%edi 111541: 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);
111544: 29 f9 sub %edi,%ecx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
111546: 39 c8 cmp %ecx,%eax
111548: 77 a9 ja 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
11154a: 39 ce cmp %ecx,%esi
11154c: 72 a5 jb 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
11154e: f6 41 04 01 testb $0x1,0x4(%ecx)
111552: 74 9f je 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
111554: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111558: 0f 84 a6 00 00 00 je 111604 <_Heap_Free+0x138>
uintptr_t const size = block_size + prev_size + next_block_size;
11155e: 8b 7d e4 mov -0x1c(%ebp),%edi 111561: 03 7d ec add -0x14(%ebp),%edi 111564: 03 7d f0 add -0x10(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111567: 8b 42 08 mov 0x8(%edx),%eax 11156a: 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;
11156d: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
111570: 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;
111573: ff 4b 38 decl 0x38(%ebx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
111576: 89 f8 mov %edi,%eax 111578: 83 c8 01 or $0x1,%eax 11157b: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
11157e: 89 3c 39 mov %edi,(%ecx,%edi,1) 111581: eb 2a jmp 1115ad <_Heap_Free+0xe1> 111583: 90 nop
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
111584: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111588: 74 3a je 1115c4 <_Heap_Free+0xf8>
uintptr_t const size = block_size + next_block_size;
11158a: 8b 7d e4 mov -0x1c(%ebp),%edi 11158d: 03 7d ec add -0x14(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111590: 8b 42 08 mov 0x8(%edx),%eax 111593: 8b 52 0c mov 0xc(%edx),%edx
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
111596: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = prev;
111599: 89 51 0c mov %edx,0xc(%ecx)
next->prev = new_block;
11159c: 89 48 0c mov %ecx,0xc(%eax)
prev->next = new_block;
11159f: 89 4a 08 mov %ecx,0x8(%edx)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1115a2: 89 f8 mov %edi,%eax 1115a4: 83 c8 01 or $0x1,%eax 1115a7: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
1115aa: 89 3c 39 mov %edi,(%ecx,%edi,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
1115ad: ff 4b 40 decl 0x40(%ebx)
++stats->frees;
1115b0: ff 43 50 incl 0x50(%ebx)
stats->free_size += block_size;
1115b3: 8b 55 ec mov -0x14(%ebp),%edx 1115b6: 01 53 30 add %edx,0x30(%ebx)
return( true );
1115b9: b0 01 mov $0x1,%al
}
1115bb: 83 c4 10 add $0x10,%esp 1115be: 5b pop %ebx 1115bf: 5e pop %esi 1115c0: 5f pop %edi 1115c1: c9 leave 1115c2: c3 ret 1115c3: 90 nop
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
1115c4: 8b 43 08 mov 0x8(%ebx),%eax
new_block->next = next;
1115c7: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = block_before;
1115ca: 89 59 0c mov %ebx,0xc(%ecx)
block_before->next = new_block;
1115cd: 89 4b 08 mov %ecx,0x8(%ebx)
next->prev = new_block;
1115d0: 89 48 0c mov %ecx,0xc(%eax)
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
1115d3: 8b 45 ec mov -0x14(%ebp),%eax 1115d6: 83 c8 01 or $0x1,%eax 1115d9: 89 41 04 mov %eax,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
1115dc: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
1115e0: 8b 45 ec mov -0x14(%ebp),%eax 1115e3: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->free_blocks;
1115e5: 8b 43 38 mov 0x38(%ebx),%eax 1115e8: 40 inc %eax 1115e9: 89 43 38 mov %eax,0x38(%ebx)
if ( stats->max_free_blocks < stats->free_blocks ) {
1115ec: 3b 43 3c cmp 0x3c(%ebx),%eax
1115ef: 76 bc jbe 1115ad <_Heap_Free+0xe1>
stats->max_free_blocks = stats->free_blocks;
1115f1: 89 43 3c mov %eax,0x3c(%ebx) 1115f4: eb b7 jmp 1115ad <_Heap_Free+0xe1> 1115f6: 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 ));
1115f8: c6 45 eb 00 movb $0x0,-0x15(%ebp) 1115fc: e9 38 ff ff ff jmp 111539 <_Heap_Free+0x6d> 111601: 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;
111604: 8b 45 ec mov -0x14(%ebp),%eax 111607: 03 45 f0 add -0x10(%ebp),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
11160a: 89 c6 mov %eax,%esi 11160c: 83 ce 01 or $0x1,%esi 11160f: 89 71 04 mov %esi,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
111612: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
111616: 89 02 mov %eax,(%edx) 111618: eb 93 jmp 1115ad <_Heap_Free+0xe1>
0010c690 <_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
)
{
10c690: 55 push %ebp 10c691: 89 e5 mov %esp,%ebp 10c693: 57 push %edi 10c694: 56 push %esi 10c695: 53 push %ebx 10c696: 8b 4d 08 mov 0x8(%ebp),%ecx 10c699: 8b 7d 0c mov 0xc(%ebp),%edi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
10c69c: 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 );
10c69f: 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;
10c6a2: 89 d8 mov %ebx,%eax 10c6a4: 31 d2 xor %edx,%edx 10c6a6: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
10c6a9: 85 d2 test %edx,%edx
10c6ab: 74 05 je 10c6b2 <_Heap_Get_first_and_last_block+0x22>
return value - remainder + alignment;
10c6ad: 03 5d 10 add 0x10(%ebp),%ebx 10c6b0: 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 (
10c6b2: 39 f1 cmp %esi,%ecx
10c6b4: 77 2e ja 10c6e4 <_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);
10c6b6: 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 =
10c6b9: 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
10c6bb: 39 df cmp %ebx,%edi
10c6bd: 76 25 jbe 10c6e4 <_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 );
10c6bf: 29 df sub %ebx,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10c6c1: 89 f8 mov %edi,%eax 10c6c3: 31 d2 xor %edx,%edx 10c6c5: f7 75 10 divl 0x10(%ebp) 10c6c8: 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
10c6ca: 39 7d 14 cmp %edi,0x14(%ebp)
10c6cd: 77 15 ja 10c6e4 <_Heap_Get_first_and_last_block+0x54>
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
10c6cf: 8b 45 18 mov 0x18(%ebp),%eax 10c6d2: 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);
10c6d4: 01 f7 add %esi,%edi 10c6d6: 8b 45 1c mov 0x1c(%ebp),%eax 10c6d9: 89 38 mov %edi,(%eax)
*last_block_ptr = last_block;
return true;
10c6db: b0 01 mov $0x1,%al
}
10c6dd: 5b pop %ebx 10c6de: 5e pop %esi 10c6df: 5f pop %edi 10c6e0: c9 leave 10c6e1: c3 ret 10c6e2: 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;
10c6e4: 31 c0 xor %eax,%eax
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
10c6e6: 5b pop %ebx 10c6e7: 5e pop %esi 10c6e8: 5f pop %edi 10c6e9: c9 leave 10c6ea: c3 ret
001151e0 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
1151e0: 55 push %ebp 1151e1: 89 e5 mov %esp,%ebp 1151e3: 57 push %edi 1151e4: 56 push %esi 1151e5: 53 push %ebx 1151e6: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
1151e9: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
1151ef: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
1151f6: 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;
}
}
1151fd: 8b 45 08 mov 0x8(%ebp),%eax 115200: 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);
115203: 39 d0 cmp %edx,%eax
115205: 74 31 je 115238 <_Heap_Get_free_information+0x58>
115207: b9 01 00 00 00 mov $0x1,%ecx 11520c: 31 f6 xor %esi,%esi 11520e: 31 db xor %ebx,%ebx 115210: eb 07 jmp 115219 <_Heap_Get_free_information+0x39> 115212: 66 90 xchg %ax,%ax 115214: 8b 77 04 mov 0x4(%edi),%esi 115217: 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;
115219: 8b 42 04 mov 0x4(%edx),%eax 11521c: 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;
11521f: 01 c3 add %eax,%ebx
if ( info->largest < the_size )
115221: 39 f0 cmp %esi,%eax
115223: 76 03 jbe 115228 <_Heap_Get_free_information+0x48>
info->largest = the_size;
115225: 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)
115228: 8b 52 08 mov 0x8(%edx),%edx 11522b: 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);
11522e: 39 55 08 cmp %edx,0x8(%ebp)
115231: 75 e1 jne 115214 <_Heap_Get_free_information+0x34>
115233: 89 0f mov %ecx,(%edi) 115235: 89 5f 08 mov %ebx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
115238: 5b pop %ebx 115239: 5e pop %esi 11523a: 5f pop %edi 11523b: c9 leave 11523c: c3 ret
00112044 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
112044: 55 push %ebp 112045: 89 e5 mov %esp,%ebp 112047: 57 push %edi 112048: 56 push %esi 112049: 53 push %ebx 11204a: 83 ec 04 sub $0x4,%esp 11204d: 8b 45 08 mov 0x8(%ebp),%eax 112050: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->first_block;
112053: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->last_block;
112056: 8b 40 24 mov 0x24(%eax),%eax 112059: 89 45 f0 mov %eax,-0x10(%ebp)
memset(the_info, 0, sizeof(*the_info));
11205c: b9 18 00 00 00 mov $0x18,%ecx 112061: 31 c0 xor %eax,%eax 112063: 89 df mov %ebx,%edi 112065: f3 aa rep stos %al,%es:(%edi)
while ( the_block != end ) {
112067: 3b 55 f0 cmp -0x10(%ebp),%edx
11206a: 74 38 je 1120a4 <_Heap_Get_information+0x60><== NEVER TAKEN
11206c: 8b 7a 04 mov 0x4(%edx),%edi 11206f: eb 18 jmp 112089 <_Heap_Get_information+0x45> 112071: 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;
112074: 8d 43 0c lea 0xc(%ebx),%eax
else
info = &the_info->Free;
info->number++;
112077: ff 00 incl (%eax)
info->total += the_size;
112079: 01 48 08 add %ecx,0x8(%eax)
if ( info->largest < the_size )
11207c: 39 48 04 cmp %ecx,0x4(%eax)
11207f: 73 03 jae 112084 <_Heap_Get_information+0x40>
info->largest = the_size;
112081: 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 ) {
112084: 39 75 f0 cmp %esi,-0x10(%ebp)
112087: 74 1b je 1120a4 <_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;
112089: 89 f9 mov %edi,%ecx 11208b: 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);
11208e: 8d 34 0a lea (%edx,%ecx,1),%esi 112091: 89 f2 mov %esi,%edx
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
112093: 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) )
112096: f7 c7 01 00 00 00 test $0x1,%edi
11209c: 75 d6 jne 112074 <_Heap_Get_information+0x30>
info = &the_info->Used;
else
info = &the_info->Free;
11209e: 89 d8 mov %ebx,%eax 1120a0: eb d5 jmp 112077 <_Heap_Get_information+0x33> 1120a2: 66 90 xchg %ax,%ax
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
1120a4: 58 pop %eax 1120a5: 5b pop %ebx 1120a6: 5e pop %esi 1120a7: 5f pop %edi 1120a8: c9 leave 1120a9: c3 ret
0011f528 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11f528: 55 push %ebp 11f529: 89 e5 mov %esp,%ebp 11f52b: 57 push %edi 11f52c: 56 push %esi 11f52d: 53 push %ebx 11f52e: 83 ec 2c sub $0x2c,%esp 11f531: 8b 5d 08 mov 0x8(%ebp),%ebx 11f534: 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);
11f537: 8d 4e f8 lea -0x8(%esi),%ecx 11f53a: 89 f0 mov %esi,%eax 11f53c: 31 d2 xor %edx,%edx 11f53e: 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);
11f541: 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;
11f543: 8b 45 14 mov 0x14(%ebp),%eax 11f546: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11f54c: 8b 55 18 mov 0x18(%ebp),%edx 11f54f: 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;
11f555: 39 4b 20 cmp %ecx,0x20(%ebx)
11f558: 77 05 ja 11f55f <_Heap_Resize_block+0x37>
11f55a: 39 4b 24 cmp %ecx,0x24(%ebx)
11f55d: 73 0d jae 11f56c <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
11f55f: b8 02 00 00 00 mov $0x2,%eax
} }
11f564: 8d 65 f4 lea -0xc(%ebp),%esp 11f567: 5b pop %ebx 11f568: 5e pop %esi 11f569: 5f pop %edi 11f56a: c9 leave 11f56b: 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;
11f56c: 8b 41 04 mov 0x4(%ecx),%eax 11f56f: 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;
11f572: 8d 3c 01 lea (%ecx,%eax,1),%edi 11f575: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11f578: 89 fa mov %edi,%edx 11f57a: 29 f2 sub %esi,%edx 11f57c: 83 c2 04 add $0x4,%edx 11f57f: 89 55 e0 mov %edx,-0x20(%ebp) 11f582: 8b 57 04 mov 0x4(%edi),%edx 11f585: 83 e2 fe and $0xfffffffe,%edx 11f588: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11f58b: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11f590: 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;
11f594: 8b 55 e0 mov -0x20(%ebp),%edx 11f597: 8b 7d 14 mov 0x14(%ebp),%edi 11f59a: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11f59c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f5a0: 75 6e jne 11f610 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11f5a2: 8b 55 e0 mov -0x20(%ebp),%edx 11f5a5: 39 55 10 cmp %edx,0x10(%ebp)
11f5a8: 77 79 ja 11f623 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11f5aa: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f5ae: 74 31 je 11f5e1 <_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;
11f5b0: 8b 79 04 mov 0x4(%ecx),%edi 11f5b3: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11f5b6: 09 c7 or %eax,%edi 11f5b8: 89 79 04 mov %edi,0x4(%ecx)
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f5bb: 8b 7d d4 mov -0x2c(%ebp),%edi 11f5be: 8b 7f 08 mov 0x8(%edi),%edi 11f5c1: 89 7d e4 mov %edi,-0x1c(%ebp) 11f5c4: 8b 55 d4 mov -0x2c(%ebp),%edx 11f5c7: 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;
11f5ca: 8b 55 e4 mov -0x1c(%ebp),%edx 11f5cd: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11f5d0: 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;
11f5d3: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11f5d8: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11f5db: 8b 7d d0 mov -0x30(%ebp),%edi 11f5de: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11f5e1: ff 75 10 pushl 0x10(%ebp) 11f5e4: 56 push %esi 11f5e5: 51 push %ecx 11f5e6: 53 push %ebx 11f5e7: e8 14 d2 fe ff call 10c800 <_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;
11f5ec: 8b 50 04 mov 0x4(%eax),%edx 11f5ef: 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;
11f5f2: 29 f0 sub %esi,%eax 11f5f4: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11f5f8: 8b 55 18 mov 0x18(%ebp),%edx 11f5fb: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11f5fd: ff 43 54 incl 0x54(%ebx) 11f600: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11f603: 31 c0 xor %eax,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f605: 8d 65 f4 lea -0xc(%ebp),%esp 11f608: 5b pop %ebx 11f609: 5e pop %esi 11f60a: 5f pop %edi 11f60b: c9 leave 11f60c: c3 ret 11f60d: 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;
11f610: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11f613: 8b 7d d0 mov -0x30(%ebp),%edi 11f616: 01 fa add %edi,%edx 11f618: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11f61b: 8b 55 e0 mov -0x20(%ebp),%edx 11f61e: 39 55 10 cmp %edx,0x10(%ebp)
11f621: 76 87 jbe 11f5aa <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11f623: b8 01 00 00 00 mov $0x1,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f628: 8d 65 f4 lea -0xc(%ebp),%esp 11f62b: 5b pop %ebx 11f62c: 5e pop %esi 11f62d: 5f pop %edi 11f62e: c9 leave 11f62f: c3 ret
0011f630 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11f630: 55 push %ebp 11f631: 89 e5 mov %esp,%ebp 11f633: 56 push %esi 11f634: 53 push %ebx 11f635: 8b 5d 08 mov 0x8(%ebp),%ebx 11f638: 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);
11f63b: 8d 4e f8 lea -0x8(%esi),%ecx 11f63e: 89 f0 mov %esi,%eax 11f640: 31 d2 xor %edx,%edx 11f642: 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);
11f645: 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
11f647: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11f64a: 39 c1 cmp %eax,%ecx
11f64c: 72 07 jb 11f655 <_Heap_Size_of_alloc_area+0x25>
11f64e: 8b 53 24 mov 0x24(%ebx),%edx 11f651: 39 d1 cmp %edx,%ecx
11f653: 76 07 jbe 11f65c <_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;
11f655: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11f657: 5b pop %ebx 11f658: 5e pop %esi 11f659: c9 leave 11f65a: c3 ret 11f65b: 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;
11f65c: 8b 59 04 mov 0x4(%ecx),%ebx 11f65f: 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);
11f662: 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;
11f664: 39 c8 cmp %ecx,%eax
11f666: 77 ed ja 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11f668: 39 ca cmp %ecx,%edx
11f66a: 72 e9 jb 11f655 <_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 )
11f66c: f6 41 04 01 testb $0x1,0x4(%ecx)
11f670: 74 e3 je 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11f672: 29 f1 sub %esi,%ecx 11f674: 8d 51 04 lea 0x4(%ecx),%edx 11f677: 8b 45 10 mov 0x10(%ebp),%eax 11f67a: 89 10 mov %edx,(%eax)
return true;
11f67c: b0 01 mov $0x1,%al
}
11f67e: 5b pop %ebx 11f67f: 5e pop %esi 11f680: c9 leave 11f681: c3 ret
0010d334 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10d334: 55 push %ebp 10d335: 89 e5 mov %esp,%ebp 10d337: 57 push %edi 10d338: 56 push %esi 10d339: 53 push %ebx 10d33a: 83 ec 4c sub $0x4c,%esp 10d33d: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10d340: 8b 43 10 mov 0x10(%ebx),%eax 10d343: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10d346: 8b 53 14 mov 0x14(%ebx),%edx 10d349: 89 55 d0 mov %edx,-0x30(%ebp)
Heap_Block *const first_block = heap->first_block;
10d34c: 8b 43 20 mov 0x20(%ebx),%eax 10d34f: 89 45 dc mov %eax,-0x24(%ebp)
Heap_Block *const last_block = heap->last_block;
10d352: 8b 53 24 mov 0x24(%ebx),%edx 10d355: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10d358: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10d35c: 74 1a je 10d378 <_Heap_Walk+0x44>
10d35e: c7 45 d8 ec d2 10 00 movl $0x10d2ec,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d365: 83 3d 20 a4 12 00 03 cmpl $0x3,0x12a420
10d36c: 74 1a je 10d388 <_Heap_Walk+0x54> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10d36e: b0 01 mov $0x1,%al
}
10d370: 8d 65 f4 lea -0xc(%ebp),%esp 10d373: 5b pop %ebx 10d374: 5e pop %esi 10d375: 5f pop %edi 10d376: c9 leave 10d377: 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;
10d378: c7 45 d8 e4 d2 10 00 movl $0x10d2e4,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d37f: 83 3d 20 a4 12 00 03 cmpl $0x3,0x12a420
10d386: 75 e6 jne 10d36e <_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)(
10d388: 52 push %edx 10d389: ff 73 0c pushl 0xc(%ebx) 10d38c: ff 73 08 pushl 0x8(%ebx) 10d38f: ff 75 cc pushl -0x34(%ebp) 10d392: ff 75 dc pushl -0x24(%ebp) 10d395: ff 73 1c pushl 0x1c(%ebx) 10d398: ff 73 18 pushl 0x18(%ebx) 10d39b: ff 75 d0 pushl -0x30(%ebp) 10d39e: ff 75 e0 pushl -0x20(%ebp) 10d3a1: 68 a4 25 12 00 push $0x1225a4 10d3a6: 6a 00 push $0x0 10d3a8: ff 75 0c pushl 0xc(%ebp) 10d3ab: 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 ) {
10d3ae: 83 c4 30 add $0x30,%esp 10d3b1: 8b 45 e0 mov -0x20(%ebp),%eax 10d3b4: 85 c0 test %eax,%eax
10d3b6: 74 70 je 10d428 <_Heap_Walk+0xf4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10d3b8: f6 45 e0 03 testb $0x3,-0x20(%ebp)
10d3bc: 75 72 jne 10d430 <_Heap_Walk+0xfc>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3be: 8b 45 d0 mov -0x30(%ebp),%eax 10d3c1: 31 d2 xor %edx,%edx 10d3c3: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10d3c6: 85 d2 test %edx,%edx
10d3c8: 75 72 jne 10d43c <_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;
10d3ca: 8b 45 dc mov -0x24(%ebp),%eax 10d3cd: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3d0: 31 d2 xor %edx,%edx 10d3d2: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10d3d5: 85 d2 test %edx,%edx
10d3d7: 75 6f jne 10d448 <_Heap_Walk+0x114>
block = next_block;
} while ( block != first_block );
return true;
}
10d3d9: 8b 45 dc mov -0x24(%ebp),%eax 10d3dc: 8b 40 04 mov 0x4(%eax),%eax 10d3df: 89 45 e4 mov %eax,-0x1c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10d3e2: a8 01 test $0x1,%al
10d3e4: 0f 84 ce 02 00 00 je 10d6b8 <_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;
10d3ea: 8b 55 cc mov -0x34(%ebp),%edx 10d3ed: 8b 42 04 mov 0x4(%edx),%eax 10d3f0: 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);
10d3f3: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10d3f5: f6 40 04 01 testb $0x1,0x4(%eax)
10d3f9: 74 25 je 10d420 <_Heap_Walk+0xec>
);
return false;
}
if (
10d3fb: 39 45 dc cmp %eax,-0x24(%ebp)
10d3fe: 74 54 je 10d454 <_Heap_Walk+0x120> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10d400: 51 push %ecx <== NOT EXECUTED 10d401: 68 c0 26 12 00 push $0x1226c0 <== NOT EXECUTED 10d406: 66 90 xchg %ax,%ax <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d408: 6a 01 push $0x1 10d40a: ff 75 0c pushl 0xc(%ebp) 10d40d: ff 55 d8 call *-0x28(%ebp) 10d410: 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;
10d413: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d415: 8d 65 f4 lea -0xc(%ebp),%esp 10d418: 5b pop %ebx 10d419: 5e pop %esi 10d41a: 5f pop %edi 10d41b: c9 leave 10d41c: c3 ret 10d41d: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10d420: 53 push %ebx 10d421: 68 5a 25 12 00 push $0x12255a 10d426: eb e0 jmp 10d408 <_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" );
10d428: 57 push %edi 10d429: 68 29 25 12 00 push $0x122529 10d42e: eb d8 jmp 10d408 <_Heap_Walk+0xd4>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10d430: ff 75 e0 pushl -0x20(%ebp) 10d433: 68 3c 25 12 00 push $0x12253c 10d438: eb ce jmp 10d408 <_Heap_Walk+0xd4> 10d43a: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10d43c: ff 75 d0 pushl -0x30(%ebp) 10d43f: 68 38 26 12 00 push $0x122638 10d444: eb c2 jmp 10d408 <_Heap_Walk+0xd4> 10d446: 66 90 xchg %ax,%ax
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10d448: ff 75 dc pushl -0x24(%ebp) 10d44b: 68 5c 26 12 00 push $0x12265c 10d450: eb b6 jmp 10d408 <_Heap_Walk+0xd4> 10d452: 66 90 xchg %ax,%ax
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10d454: 8b 43 10 mov 0x10(%ebx),%eax 10d457: 89 45 c8 mov %eax,-0x38(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10d45a: 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 ) {
10d45d: 39 f3 cmp %esi,%ebx
10d45f: 74 65 je 10d4c6 <_Heap_Walk+0x192>
block = next_block;
} while ( block != first_block );
return true;
}
10d461: 8b 43 20 mov 0x20(%ebx),%eax 10d464: 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;
10d467: 39 f0 cmp %esi,%eax
10d469: 0f 87 55 02 00 00 ja 10d6c4 <_Heap_Walk+0x390> <== NEVER TAKEN
10d46f: 8b 7b 24 mov 0x24(%ebx),%edi 10d472: 39 f7 cmp %esi,%edi
10d474: 0f 82 4a 02 00 00 jb 10d6c4 <_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;
10d47a: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d47d: 31 d2 xor %edx,%edx 10d47f: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d482: 85 d2 test %edx,%edx
10d484: 0f 85 71 02 00 00 jne 10d6fb <_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;
10d48a: 8b 46 04 mov 0x4(%esi),%eax 10d48d: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d490: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10d495: 0f 85 6d 02 00 00 jne 10d708 <_Heap_Walk+0x3d4> <== NEVER TAKEN
10d49b: 89 da mov %ebx,%edx 10d49d: 8d 76 00 lea 0x0(%esi),%esi
);
return false;
}
if ( free_block->prev != prev_block ) {
10d4a0: 8b 46 0c mov 0xc(%esi),%eax 10d4a3: 39 d0 cmp %edx,%eax
10d4a5: 0f 85 6a 02 00 00 jne 10d715 <_Heap_Walk+0x3e1>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10d4ab: 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 ) {
10d4ae: 39 cb cmp %ecx,%ebx
10d4b0: 74 1a je 10d4cc <_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;
10d4b2: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10d4b5: 0f 86 7d 01 00 00 jbe 10d638 <_Heap_Walk+0x304>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10d4bb: 51 push %ecx 10d4bc: 68 f0 26 12 00 push $0x1226f0 10d4c1: e9 42 ff ff ff jmp 10d408 <_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 ) {
10d4c6: 8b 53 20 mov 0x20(%ebx),%edx 10d4c9: 89 55 d4 mov %edx,-0x2c(%ebp)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d4cc: 8b 7d dc mov -0x24(%ebp),%edi 10d4cf: 8b 45 d4 mov -0x2c(%ebp),%eax 10d4d2: 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;
10d4d4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d4d7: 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);
10d4da: 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;
10d4dd: 39 f0 cmp %esi,%eax
10d4df: 76 23 jbe 10d504 <_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)(
10d4e1: 83 ec 0c sub $0xc,%esp 10d4e4: 56 push %esi 10d4e5: 57 push %edi 10d4e6: 68 74 27 12 00 push $0x122774 10d4eb: 90 nop 10d4ec: 6a 01 push $0x1 10d4ee: ff 75 0c pushl 0xc(%ebp) 10d4f1: ff 55 d8 call *-0x28(%ebp)
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
10d4f4: 83 c4 20 add $0x20,%esp 10d4f7: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d4f9: 8d 65 f4 lea -0xc(%ebp),%esp 10d4fc: 5b pop %ebx 10d4fd: 5e pop %esi 10d4fe: 5f pop %edi 10d4ff: c9 leave 10d500: c3 ret 10d501: 8d 76 00 lea 0x0(%esi),%esi 10d504: 39 73 24 cmp %esi,0x24(%ebx)
10d507: 72 d8 jb 10d4e1 <_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;
10d509: 3b 7d cc cmp -0x34(%ebp),%edi 10d50c: 0f 95 45 d4 setne -0x2c(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d510: 89 c8 mov %ecx,%eax 10d512: 31 d2 xor %edx,%edx 10d514: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10d517: 85 d2 test %edx,%edx
10d519: 74 0a je 10d525 <_Heap_Walk+0x1f1>
10d51b: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d51f: 0f 85 a6 01 00 00 jne 10d6cb <_Heap_Walk+0x397>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10d525: 39 4d d0 cmp %ecx,-0x30(%ebp)
10d528: 76 0a jbe 10d534 <_Heap_Walk+0x200>
10d52a: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d52e: 0f 85 a6 01 00 00 jne 10d6da <_Heap_Walk+0x3a6> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10d534: 39 f7 cmp %esi,%edi
10d536: 72 0a jb 10d542 <_Heap_Walk+0x20e>
10d538: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d53c: 0f 85 aa 01 00 00 jne 10d6ec <_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;
10d542: 8b 55 e4 mov -0x1c(%ebp),%edx 10d545: 83 e2 01 and $0x1,%edx
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10d548: f6 46 04 01 testb $0x1,0x4(%esi)
10d54c: 74 4e je 10d59c <_Heap_Walk+0x268>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10d54e: 85 d2 test %edx,%edx
10d550: 74 2e je 10d580 <_Heap_Walk+0x24c>
(*printer)(
10d552: 83 ec 0c sub $0xc,%esp 10d555: 51 push %ecx 10d556: 57 push %edi 10d557: 68 8b 25 12 00 push $0x12258b 10d55c: 6a 00 push $0x0 10d55e: ff 75 0c pushl 0xc(%ebp) 10d561: ff 55 d8 call *-0x28(%ebp) 10d564: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10d567: 39 75 dc cmp %esi,-0x24(%ebp)
10d56a: 0f 84 fe fd ff ff je 10d36e <_Heap_Walk+0x3a>
10d570: 8b 56 04 mov 0x4(%esi),%edx 10d573: 89 55 e4 mov %edx,-0x1c(%ebp) 10d576: 8b 43 20 mov 0x20(%ebx),%eax 10d579: 89 f7 mov %esi,%edi 10d57b: e9 54 ff ff ff jmp 10d4d4 <_Heap_Walk+0x1a0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10d580: 83 ec 08 sub $0x8,%esp 10d583: ff 37 pushl (%edi) 10d585: 51 push %ecx 10d586: 57 push %edi 10d587: 68 d8 28 12 00 push $0x1228d8 10d58c: 6a 00 push $0x0 10d58e: ff 75 0c pushl 0xc(%ebp) 10d591: ff 55 d8 call *-0x28(%ebp) 10d594: 83 c4 20 add $0x20,%esp 10d597: eb ce jmp 10d567 <_Heap_Walk+0x233> 10d599: 8d 76 00 lea 0x0(%esi),%esi
block = next_block;
} while ( block != first_block );
return true;
}
10d59c: 8b 43 08 mov 0x8(%ebx),%eax 10d59f: 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 ?
10d5a2: 8b 47 08 mov 0x8(%edi),%eax 10d5a5: 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)(
10d5a8: 39 43 0c cmp %eax,0xc(%ebx)
10d5ab: 0f 84 cb 00 00 00 je 10d67c <_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)" : "")
10d5b1: 39 c3 cmp %eax,%ebx
10d5b3: 0f 84 db 00 00 00 je 10d694 <_Heap_Walk+0x360>
10d5b9: c7 45 c8 29 24 12 00 movl $0x122429,-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 ?
10d5c0: 8b 47 0c mov 0xc(%edi),%eax 10d5c3: 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)(
10d5c6: 39 45 b4 cmp %eax,-0x4c(%ebp)
10d5c9: 0f 84 b9 00 00 00 je 10d688 <_Heap_Walk+0x354>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d5cf: 39 c3 cmp %eax,%ebx
10d5d1: 0f 84 c9 00 00 00 je 10d6a0 <_Heap_Walk+0x36c>
10d5d7: b8 29 24 12 00 mov $0x122429,%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)(
10d5dc: 83 ec 0c sub $0xc,%esp 10d5df: ff 75 c8 pushl -0x38(%ebp) 10d5e2: ff 75 e4 pushl -0x1c(%ebp) 10d5e5: 50 push %eax 10d5e6: ff 75 d4 pushl -0x2c(%ebp) 10d5e9: 51 push %ecx 10d5ea: 57 push %edi 10d5eb: 68 34 28 12 00 push $0x122834 10d5f0: 6a 00 push $0x0 10d5f2: ff 75 0c pushl 0xc(%ebp) 10d5f5: 89 55 c4 mov %edx,-0x3c(%ebp) 10d5f8: 89 4d c0 mov %ecx,-0x40(%ebp) 10d5fb: 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 ) {
10d5fe: 8b 06 mov (%esi),%eax 10d600: 83 c4 30 add $0x30,%esp 10d603: 8b 4d c0 mov -0x40(%ebp),%ecx 10d606: 39 c1 cmp %eax,%ecx 10d608: 8b 55 c4 mov -0x3c(%ebp),%edx
10d60b: 75 5f jne 10d66c <_Heap_Walk+0x338>
);
return false;
}
if ( !prev_used ) {
10d60d: 85 d2 test %edx,%edx
10d60f: 0f 84 97 00 00 00 je 10d6ac <_Heap_Walk+0x378>
block = next_block;
} while ( block != first_block );
return true;
}
10d615: 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 ) {
10d618: 39 c3 cmp %eax,%ebx
10d61a: 74 0f je 10d62b <_Heap_Walk+0x2f7> <== NEVER TAKEN
if ( free_block == block ) {
10d61c: 39 c7 cmp %eax,%edi
10d61e: 0f 84 43 ff ff ff je 10d567 <_Heap_Walk+0x233>
return true;
}
free_block = free_block->next;
10d624: 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 ) {
10d627: 39 c3 cmp %eax,%ebx
10d629: 75 f1 jne 10d61c <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d62b: 57 push %edi 10d62c: 68 00 29 12 00 push $0x122900 10d631: e9 d2 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> 10d636: 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;
10d638: 39 f9 cmp %edi,%ecx
10d63a: 0f 87 7b fe ff ff ja 10d4bb <_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;
10d640: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d643: 31 d2 xor %edx,%edx 10d645: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d648: 85 d2 test %edx,%edx
10d64a: 0f 85 ad 00 00 00 jne 10d6fd <_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;
10d650: 8b 41 04 mov 0x4(%ecx),%eax 10d653: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d656: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10d65b: 0f 85 a9 00 00 00 jne 10d70a <_Heap_Walk+0x3d6>
10d661: 89 f2 mov %esi,%edx 10d663: 89 ce mov %ecx,%esi 10d665: e9 36 fe ff ff jmp 10d4a0 <_Heap_Walk+0x16c> 10d66a: 66 90 xchg %ax,%ax
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10d66c: 52 push %edx 10d66d: 56 push %esi 10d66e: 50 push %eax 10d66f: 51 push %ecx 10d670: 57 push %edi 10d671: 68 6c 28 12 00 push $0x12286c 10d676: e9 71 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8> 10d67b: 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)(
10d67c: c7 45 c8 f6 24 12 00 movl $0x1224f6,-0x38(%ebp) 10d683: e9 38 ff ff ff jmp 10d5c0 <_Heap_Walk+0x28c> 10d688: b8 0f 25 12 00 mov $0x12250f,%eax 10d68d: e9 4a ff ff ff jmp 10d5dc <_Heap_Walk+0x2a8> 10d692: 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)" : "")
10d694: c7 45 c8 05 25 12 00 movl $0x122505,-0x38(%ebp) 10d69b: e9 20 ff ff ff jmp 10d5c0 <_Heap_Walk+0x28c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d6a0: b8 1f 25 12 00 mov $0x12251f,%eax 10d6a5: e9 32 ff ff ff jmp 10d5dc <_Heap_Walk+0x2a8> 10d6aa: 66 90 xchg %ax,%ax
return false;
}
if ( !prev_used ) {
(*printer)(
10d6ac: 57 push %edi 10d6ad: 68 a8 28 12 00 push $0x1228a8 10d6b2: e9 51 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> 10d6b7: 90 nop
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10d6b8: 56 push %esi 10d6b9: 68 90 26 12 00 push $0x122690 10d6be: e9 45 fd ff ff jmp 10d408 <_Heap_Walk+0xd4> 10d6c3: 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;
10d6c4: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10d6c6: e9 f0 fd ff ff jmp 10d4bb <_Heap_Walk+0x187> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10d6cb: 83 ec 0c sub $0xc,%esp 10d6ce: 51 push %ecx 10d6cf: 57 push %edi 10d6d0: 68 a4 27 12 00 push $0x1227a4 10d6d5: e9 12 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
10d6da: 83 ec 08 sub $0x8,%esp 10d6dd: ff 75 d0 pushl -0x30(%ebp) 10d6e0: 51 push %ecx 10d6e1: 57 push %edi 10d6e2: 68 d4 27 12 00 push $0x1227d4 10d6e7: e9 00 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
10d6ec: 83 ec 0c sub $0xc,%esp 10d6ef: 56 push %esi 10d6f0: 57 push %edi 10d6f1: 68 00 28 12 00 push $0x122800 10d6f6: e9 f1 fd ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
);
return false;
}
if (
10d6fb: 89 f1 mov %esi,%ecx <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10d6fd: 51 push %ecx 10d6fe: 68 10 27 12 00 push $0x122710 10d703: e9 00 fd ff ff jmp 10d408 <_Heap_Walk+0xd4>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d708: 89 f1 mov %esi,%ecx <== NOT EXECUTED
(*printer)(
10d70a: 51 push %ecx 10d70b: 68 6f 25 12 00 push $0x12256f 10d710: e9 f3 fc ff ff jmp 10d408 <_Heap_Walk+0xd4>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
10d715: 83 ec 0c sub $0xc,%esp 10d718: 50 push %eax 10d719: 56 push %esi 10d71a: 68 40 27 12 00 push $0x122740 10d71f: e9 c8 fd ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
0010bda0 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10bda0: 55 push %ebp 10bda1: 89 e5 mov %esp,%ebp 10bda3: 53 push %ebx 10bda4: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bda7: 8b 0d 00 88 12 00 mov 0x128800,%ecx 10bdad: 85 c9 test %ecx,%ecx
10bdaf: 74 1a je 10bdcb <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10bdb1: 31 db xor %ebx,%ebx 10bdb3: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10bdb4: 52 push %edx 10bdb5: 6a 00 push $0x0 10bdb7: 6a 00 push $0x0 10bdb9: 53 push %ebx 10bdba: e8 85 52 00 00 call 111044 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bdbf: 43 inc %ebx 10bdc0: 83 c4 10 add $0x10,%esp 10bdc3: 39 1d 00 88 12 00 cmp %ebx,0x128800
10bdc9: 77 e9 ja 10bdb4 <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10bdcb: 8b 5d fc mov -0x4(%ebp),%ebx 10bdce: c9 leave 10bdcf: c3 ret
0010bd08 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
10bd08: 55 push %ebp 10bd09: 89 e5 mov %esp,%ebp 10bd0b: 57 push %edi 10bd0c: 56 push %esi 10bd0d: 53 push %ebx 10bd0e: 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;
10bd11: 8b 1d b4 3a 12 00 mov 0x123ab4,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10bd17: a1 b0 3a 12 00 mov 0x123ab0,%eax 10bd1c: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10bd1f: 8b 35 ac 3a 12 00 mov 0x123aac,%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 )
10bd25: 39 f0 cmp %esi,%eax
10bd27: 73 5f jae 10bd88 <_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(
10bd29: 8d 0c 76 lea (%esi,%esi,2),%ecx 10bd2c: c1 e1 03 shl $0x3,%ecx 10bd2f: 83 ec 0c sub $0xc,%esp 10bd32: 51 push %ecx 10bd33: 89 4d dc mov %ecx,-0x24(%ebp) 10bd36: e8 81 2c 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error> 10bd3b: 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 *)
10bd3d: a3 04 88 12 00 mov %eax,0x128804
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10bd42: 89 35 00 88 12 00 mov %esi,0x128800
memset(
10bd48: 31 c0 xor %eax,%eax 10bd4a: 8b 4d dc mov -0x24(%ebp),%ecx 10bd4d: 89 d7 mov %edx,%edi 10bd4f: 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++ )
10bd51: 83 c4 10 add $0x10,%esp 10bd54: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd57: 85 c0 test %eax,%eax
10bd59: 74 25 je 10bd80 <_IO_Manager_initialization+0x78><== NEVER TAKEN
10bd5b: a1 04 88 12 00 mov 0x128804,%eax 10bd60: 89 45 e0 mov %eax,-0x20(%ebp) 10bd63: 31 c0 xor %eax,%eax 10bd65: 31 d2 xor %edx,%edx 10bd67: 90 nop
_IO_Driver_address_table[index] = driver_table[index];
10bd68: 8b 7d e0 mov -0x20(%ebp),%edi 10bd6b: 01 c7 add %eax,%edi 10bd6d: 8d 34 03 lea (%ebx,%eax,1),%esi 10bd70: b9 06 00 00 00 mov $0x6,%ecx 10bd75: 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++ )
10bd77: 42 inc %edx 10bd78: 83 c0 18 add $0x18,%eax 10bd7b: 39 55 e4 cmp %edx,-0x1c(%ebp)
10bd7e: 77 e8 ja 10bd68 <_IO_Manager_initialization+0x60>
_IO_Driver_address_table[index] = driver_table[index];
}
10bd80: 8d 65 f4 lea -0xc(%ebp),%esp 10bd83: 5b pop %ebx 10bd84: 5e pop %esi 10bd85: 5f pop %edi 10bd86: c9 leave 10bd87: 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;
10bd88: 89 1d 04 88 12 00 mov %ebx,0x128804
_IO_Number_of_drivers = number_of_drivers;
10bd8e: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd91: a3 00 88 12 00 mov %eax,0x128800
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10bd96: 8d 65 f4 lea -0xc(%ebp),%esp 10bd99: 5b pop %ebx 10bd9a: 5e pop %esi 10bd9b: 5f pop %edi 10bd9c: c9 leave 10bd9d: c3 ret
0010c8f4 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10c8f4: 55 push %ebp 10c8f5: 89 e5 mov %esp,%ebp 10c8f7: 53 push %ebx 10c8f8: 83 ec 08 sub $0x8,%esp 10c8fb: 8b 45 08 mov 0x8(%ebp),%eax 10c8fe: 8b 55 0c mov 0xc(%ebp),%edx 10c901: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10c904: a3 34 7e 12 00 mov %eax,0x127e34
_Internal_errors_What_happened.is_internal = is_internal;
10c909: 88 15 38 7e 12 00 mov %dl,0x127e38
_Internal_errors_What_happened.the_error = the_error;
10c90f: 89 1d 3c 7e 12 00 mov %ebx,0x127e3c
_User_extensions_Fatal( the_source, is_internal, the_error );
10c915: 53 push %ebx 10c916: 0f b6 d2 movzbl %dl,%edx 10c919: 52 push %edx 10c91a: 50 push %eax 10c91b: e8 9c 1c 00 00 call 10e5bc <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10c920: c7 05 20 7f 12 00 05 movl $0x5,0x127f20 <== NOT EXECUTED
10c927: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10c92a: fa cli <== NOT EXECUTED 10c92b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c92d: f4 hlt <== NOT EXECUTED 10c92e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c931: eb fe jmp 10c931 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0011161c <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
11161c: 55 push %ebp 11161d: 89 e5 mov %esp,%ebp 11161f: 8b 45 08 mov 0x8(%ebp),%eax 111622: 48 dec %eax 111623: 83 f8 02 cmp $0x2,%eax
111626: 77 0c ja 111634 <_Objects_API_maximum_class+0x18>
111628: 8b 04 85 a0 1b 12 00 mov 0x121ba0(,%eax,4),%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
11162f: c9 leave 111630: c3 ret 111631: 8d 76 00 lea 0x0(%esi),%esi
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
111634: 31 c0 xor %eax,%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
111636: c9 leave 111637: c3 ret
0010c984 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10c984: 55 push %ebp 10c985: 89 e5 mov %esp,%ebp 10c987: 56 push %esi 10c988: 53 push %ebx 10c989: 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 )
10c98c: 8b 43 18 mov 0x18(%ebx),%eax 10c98f: 85 c0 test %eax,%eax
10c991: 75 0d jne 10c9a0 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
return NULL;
10c993: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
);
}
#endif
return the_object;
}
10c995: 89 c8 mov %ecx,%eax 10c997: 8d 65 f8 lea -0x8(%ebp),%esp 10c99a: 5b pop %ebx 10c99b: 5e pop %esi 10c99c: c9 leave 10c99d: c3 ret 10c99e: 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 );
10c9a0: 8d 73 20 lea 0x20(%ebx),%esi 10c9a3: 83 ec 0c sub $0xc,%esp 10c9a6: 56 push %esi 10c9a7: e8 68 f6 ff ff call 10c014 <_Chain_Get> 10c9ac: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10c9ae: 83 c4 10 add $0x10,%esp 10c9b1: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10c9b5: 74 de je 10c995 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10c9b7: 85 c0 test %eax,%eax
10c9b9: 74 29 je 10c9e4 <_Objects_Allocate+0x60>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10c9bb: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10c9bf: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10c9c3: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10c9c5: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10c9c9: 31 d2 xor %edx,%edx 10c9cb: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10c9cd: c1 e0 02 shl $0x2,%eax 10c9d0: 03 43 30 add 0x30(%ebx),%eax 10c9d3: ff 08 decl (%eax)
information->inactive--;
10c9d5: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10c9d9: 89 c8 mov %ecx,%eax 10c9db: 8d 65 f8 lea -0x8(%ebp),%esp 10c9de: 5b pop %ebx 10c9df: 5e pop %esi 10c9e0: c9 leave 10c9e1: c3 ret 10c9e2: 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 );
10c9e4: 83 ec 0c sub $0xc,%esp 10c9e7: 53 push %ebx 10c9e8: e8 3b 00 00 00 call 10ca28 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10c9ed: 89 34 24 mov %esi,(%esp) 10c9f0: e8 1f f6 ff ff call 10c014 <_Chain_Get> 10c9f5: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10c9f7: 83 c4 10 add $0x10,%esp 10c9fa: 85 c0 test %eax,%eax
10c9fc: 74 97 je 10c995 <_Objects_Allocate+0x11>
10c9fe: eb bb jmp 10c9bb <_Objects_Allocate+0x37>
0010ca28 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10ca28: 55 push %ebp 10ca29: 89 e5 mov %esp,%ebp 10ca2b: 57 push %edi 10ca2c: 56 push %esi 10ca2d: 53 push %ebx 10ca2e: 83 ec 4c sub $0x4c,%esp 10ca31: 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 );
10ca34: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10ca38: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10ca3b: 8b 4b 34 mov 0x34(%ebx),%ecx 10ca3e: 85 c9 test %ecx,%ecx
10ca40: 0f 84 62 02 00 00 je 10cca8 <_Objects_Extend_information+0x280>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10ca46: 8b 73 10 mov 0x10(%ebx),%esi 10ca49: 66 89 75 d0 mov %si,-0x30(%ebp) 10ca4d: 8b 7b 14 mov 0x14(%ebx),%edi 10ca50: 89 f0 mov %esi,%eax 10ca52: 31 d2 xor %edx,%edx 10ca54: 66 f7 f7 div %di 10ca57: 0f b7 f0 movzwl %ax,%esi
for ( ; block < block_count; block++ ) {
10ca5a: 85 f6 test %esi,%esi
10ca5c: 0f 84 5f 02 00 00 je 10ccc1 <_Objects_Extend_information+0x299><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10ca62: 8b 01 mov (%ecx),%eax 10ca64: 85 c0 test %eax,%eax
10ca66: 0f 84 67 02 00 00 je 10ccd3 <_Objects_Extend_information+0x2ab><== NEVER TAKEN
10ca6c: 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 );
10ca6f: 8b 55 cc mov -0x34(%ebp),%edx 10ca72: 89 55 d4 mov %edx,-0x2c(%ebp)
index_base = minimum_index; block = 0;
10ca75: 31 d2 xor %edx,%edx 10ca77: 8b 45 d4 mov -0x2c(%ebp),%eax 10ca7a: eb 0a jmp 10ca86 <_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 ) {
10ca7c: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4)
10ca80: 0f 84 c2 01 00 00 je 10cc48 <_Objects_Extend_information+0x220>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10ca86: 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++ ) {
10ca88: 42 inc %edx 10ca89: 39 d6 cmp %edx,%esi
10ca8b: 77 ef ja 10ca7c <_Objects_Extend_information+0x54>
10ca8d: 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;
10ca90: b1 01 mov $0x1,%cl
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10ca92: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10ca96: 01 f8 add %edi,%eax 10ca98: 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 ) {
10ca9b: 3d ff ff 00 00 cmp $0xffff,%eax
10caa0: 0f 87 9a 01 00 00 ja 10cc40 <_Objects_Extend_information+0x218><== NEVER TAKEN
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
10caa6: 0f af 7b 18 imul 0x18(%ebx),%edi
if ( information->auto_extend ) {
10caaa: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10caae: 0f 84 a0 01 00 00 je 10cc54 <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
10cab4: 83 ec 0c sub $0xc,%esp 10cab7: 57 push %edi 10cab8: 89 55 b8 mov %edx,-0x48(%ebp) 10cabb: 88 4d b4 mov %cl,-0x4c(%ebp) 10cabe: e8 c5 1e 00 00 call 10e988 <_Workspace_Allocate> 10cac3: 89 45 c8 mov %eax,-0x38(%ebp)
if ( !new_object_block )
10cac6: 83 c4 10 add $0x10,%esp 10cac9: 85 c0 test %eax,%eax 10cacb: 8b 55 b8 mov -0x48(%ebp),%edx 10cace: 8a 4d b4 mov -0x4c(%ebp),%cl
10cad1: 0f 84 69 01 00 00 je 10cc40 <_Objects_Extend_information+0x218>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10cad7: 84 c9 test %cl,%cl
10cad9: 0f 84 e6 00 00 00 je 10cbc5 <_Objects_Extend_information+0x19d>
*/
/*
* Up the block count and maximum
*/
block_count++;
10cadf: 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 );
10cae2: 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 *)) +
10cae5: 8d 04 7f lea (%edi,%edi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10cae8: 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 *)) +
10caeb: 03 45 cc add -0x34(%ebp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10caee: 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 );
10caf1: 50 push %eax 10caf2: 89 55 b8 mov %edx,-0x48(%ebp) 10caf5: e8 8e 1e 00 00 call 10e988 <_Workspace_Allocate> 10cafa: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !object_blocks ) {
10cafd: 83 c4 10 add $0x10,%esp 10cb00: 85 c0 test %eax,%eax 10cb02: 8b 55 b8 mov -0x48(%ebp),%edx
10cb05: 0f 84 da 01 00 00 je 10cce5 <_Objects_Extend_information+0x2bd>
10cb0b: 8b 45 c4 mov -0x3c(%ebp),%eax 10cb0e: 8d 04 b8 lea (%eax,%edi,4),%eax 10cb11: 89 45 bc mov %eax,-0x44(%ebp) 10cb14: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb17: 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 ) {
10cb1a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cb1e: 39 4d cc cmp %ecx,-0x34(%ebp)
10cb21: 0f 82 4d 01 00 00 jb 10cc74 <_Objects_Extend_information+0x24c>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10cb27: 8b 4d cc mov -0x34(%ebp),%ecx 10cb2a: 85 c9 test %ecx,%ecx
10cb2c: 74 12 je 10cb40 <_Objects_Extend_information+0x118><== NEVER TAKEN
10cb2e: 31 c9 xor %ecx,%ecx 10cb30: 8b 7d cc mov -0x34(%ebp),%edi 10cb33: 90 nop
local_table[ index ] = NULL;
10cb34: 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++ ) {
10cb3b: 41 inc %ecx 10cb3c: 39 cf cmp %ecx,%edi
10cb3e: 77 f4 ja 10cb34 <_Objects_Extend_information+0x10c><== NEVER TAKEN
10cb40: c1 e6 02 shl $0x2,%esi 10cb43: 89 75 c0 mov %esi,-0x40(%ebp)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10cb46: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb49: 8b 75 c0 mov -0x40(%ebp),%esi 10cb4c: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
inactive_per_block[block_count] = 0;
10cb53: 8b 4d bc mov -0x44(%ebp),%ecx 10cb56: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10cb5d: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10cb61: 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 ;
10cb64: 39 75 d4 cmp %esi,-0x2c(%ebp)
10cb67: 73 0f jae 10cb78 <_Objects_Extend_information+0x150><== NEVER TAKEN
10cb69: 8b 4d d4 mov -0x2c(%ebp),%ecx
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10cb6c: 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++ ) {
10cb73: 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 ;
10cb74: 39 f1 cmp %esi,%ecx
10cb76: 72 f4 jb 10cb6c <_Objects_Extend_information+0x144>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10cb78: 9c pushf 10cb79: fa cli 10cb7a: 5f pop %edi
old_tables = information->object_blocks;
10cb7b: 8b 73 34 mov 0x34(%ebx),%esi
information->object_blocks = object_blocks;
10cb7e: 8b 4d c4 mov -0x3c(%ebp),%ecx 10cb81: 89 4b 34 mov %ecx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10cb84: 8b 4d bc mov -0x44(%ebp),%ecx 10cb87: 89 4b 30 mov %ecx,0x30(%ebx)
information->local_table = local_table;
10cb8a: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10cb8d: 8b 45 d0 mov -0x30(%ebp),%eax 10cb90: 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) |
10cb94: 8b 0b mov (%ebx),%ecx 10cb96: c1 e1 18 shl $0x18,%ecx 10cb99: 81 c9 00 00 01 00 or $0x10000,%ecx
information->maximum_id = _Objects_Build_id(
10cb9f: 0f b7 43 04 movzwl 0x4(%ebx),%eax
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cba3: c1 e0 1b shl $0x1b,%eax 10cba6: 09 c1 or %eax,%ecx 10cba8: 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) |
10cbac: 09 c1 or %eax,%ecx 10cbae: 89 4b 0c mov %ecx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10cbb1: 57 push %edi 10cbb2: 9d popf
_Workspace_Free( old_tables );
10cbb3: 83 ec 0c sub $0xc,%esp 10cbb6: 56 push %esi 10cbb7: 89 55 b8 mov %edx,-0x48(%ebp) 10cbba: e8 e5 1d 00 00 call 10e9a4 <_Workspace_Free> 10cbbf: 83 c4 10 add $0x10,%esp 10cbc2: 8b 55 b8 mov -0x48(%ebp),%edx
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10cbc5: c1 e2 02 shl $0x2,%edx 10cbc8: 89 55 d0 mov %edx,-0x30(%ebp) 10cbcb: 8b 43 34 mov 0x34(%ebx),%eax 10cbce: 8b 4d c8 mov -0x38(%ebp),%ecx 10cbd1: 89 0c 10 mov %ecx,(%eax,%edx,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10cbd4: ff 73 18 pushl 0x18(%ebx) 10cbd7: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10cbdb: 50 push %eax 10cbdc: 51 push %ecx 10cbdd: 8d 7d dc lea -0x24(%ebp),%edi 10cbe0: 57 push %edi 10cbe1: e8 9e 44 00 00 call 111084 <_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 ) {
10cbe6: 83 c4 10 add $0x10,%esp 10cbe9: 8b 75 d4 mov -0x2c(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cbec: 8d 43 20 lea 0x20(%ebx),%eax 10cbef: 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 ) {
10cbf2: eb 29 jmp 10cc1d <_Objects_Extend_information+0x1f5> 10cbf4: 8b 13 mov (%ebx),%edx 10cbf6: c1 e2 18 shl $0x18,%edx 10cbf9: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10cbff: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cc03: c1 e1 1b shl $0x1b,%ecx 10cc06: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cc08: 09 f2 or %esi,%edx 10cc0a: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cc0d: 83 ec 08 sub $0x8,%esp 10cc10: 50 push %eax 10cc11: ff 75 d4 pushl -0x2c(%ebp) 10cc14: e8 bf f3 ff ff call 10bfd8 <_Chain_Append>
index++;
10cc19: 46 inc %esi 10cc1a: 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 ) {
10cc1d: 83 ec 0c sub $0xc,%esp 10cc20: 57 push %edi 10cc21: e8 ee f3 ff ff call 10c014 <_Chain_Get> 10cc26: 83 c4 10 add $0x10,%esp 10cc29: 85 c0 test %eax,%eax
10cc2b: 75 c7 jne 10cbf4 <_Objects_Extend_information+0x1cc>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10cc2d: 8b 43 14 mov 0x14(%ebx),%eax 10cc30: 8b 53 30 mov 0x30(%ebx),%edx 10cc33: 0f b7 c8 movzwl %ax,%ecx 10cc36: 8b 75 d0 mov -0x30(%ebp),%esi 10cc39: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10cc3c: 66 01 43 2c add %ax,0x2c(%ebx)
}
10cc40: 8d 65 f4 lea -0xc(%ebp),%esp 10cc43: 5b pop %ebx 10cc44: 5e pop %esi 10cc45: 5f pop %edi 10cc46: c9 leave 10cc47: c3 ret 10cc48: 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;
10cc4b: 31 c9 xor %ecx,%ecx 10cc4d: e9 40 fe ff ff jmp 10ca92 <_Objects_Extend_information+0x6a> 10cc52: 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 );
10cc54: 83 ec 0c sub $0xc,%esp 10cc57: 57 push %edi 10cc58: 89 55 b8 mov %edx,-0x48(%ebp) 10cc5b: 88 4d b4 mov %cl,-0x4c(%ebp) 10cc5e: e8 59 1d 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error> 10cc63: 89 45 c8 mov %eax,-0x38(%ebp) 10cc66: 83 c4 10 add $0x10,%esp 10cc69: 8a 4d b4 mov -0x4c(%ebp),%cl 10cc6c: 8b 55 b8 mov -0x48(%ebp),%edx 10cc6f: e9 63 fe ff ff jmp 10cad7 <_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,
10cc74: c1 e6 02 shl $0x2,%esi 10cc77: 89 75 c0 mov %esi,-0x40(%ebp) 10cc7a: 8b 73 34 mov 0x34(%ebx),%esi 10cc7d: 8b 7d c4 mov -0x3c(%ebp),%edi 10cc80: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc83: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10cc85: 8b 73 30 mov 0x30(%ebx),%esi 10cc88: 8b 7d bc mov -0x44(%ebp),%edi 10cc8b: 8b 4d c0 mov -0x40(%ebp),%ecx 10cc8e: 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 *) );
10cc90: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cc94: 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,
10cc97: c1 e1 02 shl $0x2,%ecx 10cc9a: 8b 73 1c mov 0x1c(%ebx),%esi 10cc9d: 89 c7 mov %eax,%edi 10cc9f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10cca1: e9 a0 fe ff ff jmp 10cb46 <_Objects_Extend_information+0x11e> 10cca6: 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 )
10cca8: 8b 53 10 mov 0x10(%ebx),%edx 10ccab: 66 89 55 d0 mov %dx,-0x30(%ebp) 10ccaf: 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 );
10ccb3: 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;
10ccb6: b1 01 mov $0x1,%cl
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10ccb8: 31 d2 xor %edx,%edx
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10ccba: 31 f6 xor %esi,%esi 10ccbc: e9 d1 fd ff ff jmp 10ca92 <_Objects_Extend_information+0x6a>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10ccc1: 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 );
10ccc4: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10ccc7: 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;
10ccca: b1 01 mov $0x1,%cl <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10cccc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccce: e9 bf fd ff ff jmp 10ca92 <_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 ) {
10ccd3: 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 );
10ccd6: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10ccd9: 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;
10ccdc: 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;
10ccde: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cce0: e9 ad fd ff ff jmp 10ca92 <_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 );
10cce5: 83 ec 0c sub $0xc,%esp 10cce8: ff 75 c8 pushl -0x38(%ebp) 10cceb: e8 b4 1c 00 00 call 10e9a4 <_Workspace_Free>
return;
10ccf0: 83 c4 10 add $0x10,%esp 10ccf3: e9 48 ff ff ff jmp 10cc40 <_Objects_Extend_information+0x218>
0010cd88 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10cd88: 55 push %ebp 10cd89: 89 e5 mov %esp,%ebp 10cd8b: 56 push %esi 10cd8c: 53 push %ebx 10cd8d: 8b 75 08 mov 0x8(%ebp),%esi 10cd90: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10cd93: 66 85 db test %bx,%bx
10cd96: 75 0c jne 10cda4 <_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;
10cd98: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10cd9a: 8d 65 f8 lea -0x8(%ebp),%esp 10cd9d: 5b pop %ebx 10cd9e: 5e pop %esi 10cd9f: c9 leave 10cda0: c3 ret 10cda1: 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 );
10cda4: 83 ec 0c sub $0xc,%esp 10cda7: 56 push %esi 10cda8: e8 6f 48 00 00 call 11161c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10cdad: 83 c4 10 add $0x10,%esp 10cdb0: 85 c0 test %eax,%eax
10cdb2: 74 e4 je 10cd98 <_Objects_Get_information+0x10>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10cdb4: 0f b7 db movzwl %bx,%ebx 10cdb7: 39 d8 cmp %ebx,%eax
10cdb9: 72 dd jb 10cd98 <_Objects_Get_information+0x10>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10cdbb: 8b 14 b5 68 7d 12 00 mov 0x127d68(,%esi,4),%edx
return NULL;
10cdc2: 31 c0 xor %eax,%eax
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10cdc4: 85 d2 test %edx,%edx
10cdc6: 74 d2 je 10cd9a <_Objects_Get_information+0x12><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10cdc8: 8b 04 9a mov (%edx,%ebx,4),%eax
if ( !info )
10cdcb: 85 c0 test %eax,%eax
10cdcd: 74 cb je 10cd9a <_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;
10cdcf: 31 d2 xor %edx,%edx 10cdd1: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10cdd6: 0f 95 c2 setne %dl 10cdd9: f7 da neg %edx 10cddb: 21 d0 and %edx,%eax 10cddd: eb bb jmp 10cd9a <_Objects_Get_information+0x12>
0010cde0 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10cde0: 55 push %ebp 10cde1: 89 e5 mov %esp,%ebp 10cde3: 56 push %esi 10cde4: 53 push %ebx 10cde5: 8b 55 08 mov 0x8(%ebp),%edx 10cde8: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
10cdeb: b8 01 00 00 00 mov $0x1,%eax 10cdf0: 2b 42 08 sub 0x8(%edx),%eax 10cdf3: 03 45 0c add 0xc(%ebp),%eax
_ISR_Disable( level );
10cdf6: 9c pushf 10cdf7: fa cli 10cdf8: 5e pop %esi
if ( information->maximum >= index ) {
10cdf9: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10cdfd: 39 c8 cmp %ecx,%eax
10cdff: 77 1b ja 10ce1c <_Objects_Get_isr_disable+0x3c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10ce01: 8b 52 1c mov 0x1c(%edx),%edx 10ce04: 8b 04 82 mov (%edx,%eax,4),%eax 10ce07: 85 c0 test %eax,%eax
10ce09: 74 21 je 10ce2c <_Objects_Get_isr_disable+0x4c>
*location = OBJECTS_LOCAL;
10ce0b: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10ce11: 8b 55 14 mov 0x14(%ebp),%edx 10ce14: 89 32 mov %esi,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
10ce16: 5b pop %ebx 10ce17: 5e pop %esi 10ce18: c9 leave 10ce19: c3 ret 10ce1a: 66 90 xchg %ax,%ax
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10ce1c: 56 push %esi 10ce1d: 9d popf
*location = OBJECTS_ERROR;
10ce1e: 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;
10ce24: 31 c0 xor %eax,%eax
#endif }
10ce26: 5b pop %ebx 10ce27: 5e pop %esi 10ce28: c9 leave 10ce29: c3 ret 10ce2a: 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 );
10ce2c: 56 push %esi 10ce2d: 9d popf
*location = OBJECTS_ERROR;
10ce2e: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
10ce34: eb e0 jmp 10ce16 <_Objects_Get_isr_disable+0x36>
0010e4d0 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10e4d0: 55 push %ebp 10e4d1: 89 e5 mov %esp,%ebp 10e4d3: 57 push %edi 10e4d4: 56 push %esi 10e4d5: 53 push %ebx 10e4d6: 83 ec 2c sub $0x2c,%esp 10e4d9: 8b 55 08 mov 0x8(%ebp),%edx 10e4dc: 8b 75 0c mov 0xc(%ebp),%esi 10e4df: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10e4e2: 85 f6 test %esi,%esi
10e4e4: 75 0e jne 10e4f4 <_Objects_Get_name_as_string+0x24>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
10e4e6: 31 db xor %ebx,%ebx
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
10e4e8: 89 d8 mov %ebx,%eax 10e4ea: 8d 65 f4 lea -0xc(%ebp),%esp 10e4ed: 5b pop %ebx 10e4ee: 5e pop %esi 10e4ef: 5f pop %edi 10e4f0: c9 leave 10e4f1: c3 ret 10e4f2: 66 90 xchg %ax,%ax
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10e4f4: 85 db test %ebx,%ebx
10e4f6: 74 f0 je 10e4e8 <_Objects_Get_name_as_string+0x18>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e4f8: 85 d2 test %edx,%edx
10e4fa: 75 08 jne 10e504 <_Objects_Get_name_as_string+0x34>
10e4fc: a1 f8 af 12 00 mov 0x12aff8,%eax 10e501: 8b 50 08 mov 0x8(%eax),%edx
information = _Objects_Get_information_id( tmpId );
10e504: 83 ec 0c sub $0xc,%esp 10e507: 52 push %edx 10e508: 89 55 cc mov %edx,-0x34(%ebp) 10e50b: e8 f0 fe ff ff call 10e400 <_Objects_Get_information_id> 10e510: 89 c7 mov %eax,%edi
if ( !information )
10e512: 83 c4 10 add $0x10,%esp 10e515: 85 c0 test %eax,%eax 10e517: 8b 55 cc mov -0x34(%ebp),%edx
10e51a: 74 ca je 10e4e6 <_Objects_Get_name_as_string+0x16>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10e51c: 51 push %ecx 10e51d: 8d 45 e4 lea -0x1c(%ebp),%eax 10e520: 50 push %eax 10e521: 52 push %edx 10e522: 57 push %edi 10e523: e8 90 00 00 00 call 10e5b8 <_Objects_Get>
switch ( location ) {
10e528: 83 c4 10 add $0x10,%esp 10e52b: 8b 55 e4 mov -0x1c(%ebp),%edx 10e52e: 85 d2 test %edx,%edx
10e530: 75 b4 jne 10e4e6 <_Objects_Get_name_as_string+0x16>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10e532: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10e536: 74 54 je 10e58c <_Objects_Get_name_as_string+0xbc>
s = the_object->name.name_p;
10e538: 8b 78 0c mov 0xc(%eax),%edi
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
10e53b: 85 ff test %edi,%edi
10e53d: 74 74 je 10e5b3 <_Objects_Get_name_as_string+0xe3>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e53f: 4e dec %esi 10e540: 89 75 d4 mov %esi,-0x2c(%ebp)
10e543: 74 6e je 10e5b3 <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN
10e545: 8a 17 mov (%edi),%dl 10e547: 84 d2 test %dl,%dl
10e549: 74 68 je 10e5b3 <_Objects_Get_name_as_string+0xe3>
10e54b: 89 d9 mov %ebx,%ecx 10e54d: 31 c0 xor %eax,%eax 10e54f: 89 5d d0 mov %ebx,-0x30(%ebp) 10e552: eb 07 jmp 10e55b <_Objects_Get_name_as_string+0x8b> 10e554: 8a 14 07 mov (%edi,%eax,1),%dl 10e557: 84 d2 test %dl,%dl
10e559: 74 21 je 10e57c <_Objects_Get_name_as_string+0xac>
*d = (isprint((unsigned char)*s)) ? *s : '*';
10e55b: 0f b6 da movzbl %dl,%ebx 10e55e: 8b 35 e8 82 12 00 mov 0x1282e8,%esi 10e564: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx 10e569: 81 e3 97 00 00 00 and $0x97,%ebx
10e56f: 75 02 jne 10e573 <_Objects_Get_name_as_string+0xa3>
10e571: b2 2a mov $0x2a,%dl 10e573: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e575: 40 inc %eax 10e576: 41 inc %ecx 10e577: 3b 45 d4 cmp -0x2c(%ebp),%eax
10e57a: 72 d8 jb 10e554 <_Objects_Get_name_as_string+0x84>
10e57c: 8b 5d d0 mov -0x30(%ebp),%ebx
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
10e57f: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
10e582: e8 a9 0b 00 00 call 10f130 <_Thread_Enable_dispatch>
return name;
10e587: e9 5c ff ff ff jmp 10e4e8 <_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;
10e58c: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
10e58f: 89 c2 mov %eax,%edx 10e591: c1 ea 18 shr $0x18,%edx 10e594: 88 55 df mov %dl,-0x21(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10e597: 89 c2 mov %eax,%edx 10e599: c1 ea 10 shr $0x10,%edx 10e59c: 88 55 e0 mov %dl,-0x20(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10e59f: 89 c2 mov %eax,%edx 10e5a1: c1 ea 08 shr $0x8,%edx 10e5a4: 88 55 e1 mov %dl,-0x1f(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10e5a7: 88 45 e2 mov %al,-0x1e(%ebp)
lname[ 4 ] = '\0';
10e5aa: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
s = lname;
10e5ae: 8d 7d df lea -0x21(%ebp),%edi 10e5b1: eb 8c jmp 10e53f <_Objects_Get_name_as_string+0x6f>
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e5b3: 89 d9 mov %ebx,%ecx 10e5b5: eb c8 jmp 10e57f <_Objects_Get_name_as_string+0xaf>
0010cf90 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
10cf90: 55 push %ebp 10cf91: 89 e5 mov %esp,%ebp 10cf93: 57 push %edi 10cf94: 56 push %esi 10cf95: 53 push %ebx 10cf96: 83 ec 0c sub $0xc,%esp 10cf99: 8b 5d 08 mov 0x8(%ebp),%ebx 10cf9c: 8b 75 0c mov 0xc(%ebp),%esi 10cf9f: 8b 7d 10 mov 0x10(%ebp),%edi
Objects_Control *object;
Objects_Id next_id;
if ( !information )
10cfa2: 85 db test %ebx,%ebx
10cfa4: 75 0a jne 10cfb0 <_Objects_Get_next+0x20>
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
10cfa6: 31 c0 xor %eax,%eax
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cfa8: 8d 65 f4 lea -0xc(%ebp),%esp 10cfab: 5b pop %ebx 10cfac: 5e pop %esi 10cfad: 5f pop %edi 10cfae: c9 leave 10cfaf: c3 ret
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
10cfb0: 85 ff test %edi,%edi
10cfb2: 74 f2 je 10cfa6 <_Objects_Get_next+0x16>
return NULL;
if ( !next_id_p )
10cfb4: 8b 45 14 mov 0x14(%ebp),%eax 10cfb7: 85 c0 test %eax,%eax
10cfb9: 74 eb je 10cfa6 <_Objects_Get_next+0x16>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
10cfbb: 66 85 f6 test %si,%si
10cfbe: 75 04 jne 10cfc4 <_Objects_Get_next+0x34>
next_id = information->minimum_id;
10cfc0: 8b 73 08 mov 0x8(%ebx),%esi 10cfc3: 90 nop
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
10cfc4: 66 39 73 10 cmp %si,0x10(%ebx)
10cfc8: 72 22 jb 10cfec <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
10cfca: 51 push %ecx 10cfcb: 57 push %edi 10cfcc: 56 push %esi 10cfcd: 53 push %ebx 10cfce: e8 2d 00 00 00 call 10d000 <_Objects_Get>
next_id++;
10cfd3: 46 inc %esi
} while (*location_p != OBJECTS_LOCAL);
10cfd4: 83 c4 10 add $0x10,%esp 10cfd7: 8b 17 mov (%edi),%edx 10cfd9: 85 d2 test %edx,%edx
10cfdb: 75 e7 jne 10cfc4 <_Objects_Get_next+0x34>
*next_id_p = next_id;
10cfdd: 8b 55 14 mov 0x14(%ebp),%edx 10cfe0: 89 32 mov %esi,(%edx)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cfe2: 8d 65 f4 lea -0xc(%ebp),%esp 10cfe5: 5b pop %ebx 10cfe6: 5e pop %esi 10cfe7: 5f pop %edi 10cfe8: c9 leave 10cfe9: c3 ret 10cfea: 66 90 xchg %ax,%ax
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
10cfec: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
10cff2: 8b 45 14 mov 0x14(%ebp),%eax 10cff5: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
return 0;
10cffb: 31 c0 xor %eax,%eax 10cffd: eb a9 jmp 10cfa8 <_Objects_Get_next+0x18>
0011b2a0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11b2a0: 55 push %ebp 11b2a1: 89 e5 mov %esp,%ebp 11b2a3: 53 push %ebx 11b2a4: 8b 55 08 mov 0x8(%ebp),%edx 11b2a7: 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;
11b2aa: b8 01 00 00 00 mov $0x1,%eax 11b2af: 2b 42 08 sub 0x8(%edx),%eax 11b2b2: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
11b2b5: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11b2b9: 39 c8 cmp %ecx,%eax
11b2bb: 77 13 ja 11b2d0 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11b2bd: 8b 52 1c mov 0x1c(%edx),%edx 11b2c0: 8b 04 82 mov (%edx,%eax,4),%eax 11b2c3: 85 c0 test %eax,%eax
11b2c5: 74 09 je 11b2d0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11b2c7: 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; }
11b2cd: 5b pop %ebx 11b2ce: c9 leave 11b2cf: 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;
11b2d0: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
11b2d6: 31 c0 xor %eax,%eax
}
11b2d8: 5b pop %ebx 11b2d9: c9 leave 11b2da: c3 ret
0010e0e4 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10e0e4: 55 push %ebp 10e0e5: 89 e5 mov %esp,%ebp 10e0e7: 83 ec 18 sub $0x18,%esp 10e0ea: 8b 55 08 mov 0x8(%ebp),%edx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e0ed: 85 d2 test %edx,%edx
10e0ef: 75 08 jne 10e0f9 <_Objects_Id_to_name+0x15>
10e0f1: a1 78 af 12 00 mov 0x12af78,%eax 10e0f6: 8b 50 08 mov 0x8(%eax),%edx 10e0f9: 89 d0 mov %edx,%eax 10e0fb: c1 e8 18 shr $0x18,%eax 10e0fe: 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 )
10e101: 8d 48 ff lea -0x1(%eax),%ecx 10e104: 83 f9 02 cmp $0x2,%ecx
10e107: 77 1d ja 10e126 <_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 ] )
10e109: 8b 04 85 a8 a9 12 00 mov 0x12a9a8(,%eax,4),%eax 10e110: 85 c0 test %eax,%eax
10e112: 74 12 je 10e126 <_Objects_Id_to_name+0x42>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10e114: 89 d1 mov %edx,%ecx 10e116: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10e119: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
10e11c: 85 c0 test %eax,%eax
10e11e: 74 06 je 10e126 <_Objects_Id_to_name+0x42><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10e120: 80 78 38 00 cmpb $0x0,0x38(%eax)
10e124: 74 0a je 10e130 <_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;
10e126: 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;
}
10e12b: c9 leave 10e12c: c3 ret 10e12d: 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 );
10e130: 51 push %ecx 10e131: 8d 4d f4 lea -0xc(%ebp),%ecx 10e134: 51 push %ecx 10e135: 52 push %edx 10e136: 50 push %eax 10e137: e8 40 ff ff ff call 10e07c <_Objects_Get>
if ( !the_object )
10e13c: 83 c4 10 add $0x10,%esp 10e13f: 85 c0 test %eax,%eax
10e141: 74 e3 je 10e126 <_Objects_Id_to_name+0x42>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10e143: 8b 50 0c mov 0xc(%eax),%edx 10e146: 8b 45 0c mov 0xc(%ebp),%eax 10e149: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10e14b: e8 14 0b 00 00 call 10ec64 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10e150: 31 c0 xor %eax,%eax
}
10e152: c9 leave 10e153: c3 ret
0010cea0 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
10cea0: 55 push %ebp 10cea1: 89 e5 mov %esp,%ebp 10cea3: 57 push %edi 10cea4: 56 push %esi 10cea5: 53 push %ebx 10cea6: 83 ec 0c sub $0xc,%esp 10cea9: 8b 45 08 mov 0x8(%ebp),%eax 10ceac: 8b 55 0c mov 0xc(%ebp),%edx 10ceaf: 8b 5d 10 mov 0x10(%ebp),%ebx 10ceb2: 8b 75 20 mov 0x20(%ebp),%esi 10ceb5: 0f b7 7d 18 movzwl 0x18(%ebp),%edi
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
10ceb9: 89 10 mov %edx,(%eax)
information->the_class = the_class;
10cebb: 66 89 58 04 mov %bx,0x4(%eax)
information->size = size;
10cebf: 89 78 18 mov %edi,0x18(%eax)
information->local_table = 0;
10cec2: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
information->inactive_per_block = 0;
10cec9: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
information->object_blocks = 0;
10ced0: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
information->inactive = 0;
10ced7: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax)
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
information->is_string = is_string;
10cedd: 8b 7d 1c mov 0x1c(%ebp),%edi 10cee0: 89 f9 mov %edi,%ecx 10cee2: 88 48 38 mov %cl,0x38(%eax)
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
10cee5: 66 c7 40 10 00 00 movw $0x0,0x10(%eax)
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
10ceeb: 0f b7 db movzwl %bx,%ebx 10ceee: 8b 3c 95 68 7d 12 00 mov 0x127d68(,%edx,4),%edi 10cef5: 89 04 9f mov %eax,(%edi,%ebx,4)
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
10cef8: 8b 7d 14 mov 0x14(%ebp),%edi 10cefb: c1 ef 1f shr $0x1f,%edi
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
10cefe: 89 f9 mov %edi,%ecx 10cf00: 88 48 12 mov %cl,0x12(%eax)
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
10cf03: 8b 4d 14 mov 0x14(%ebp),%ecx 10cf06: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
10cf0c: 85 ff test %edi,%edi
10cf0e: 74 04 je 10cf14 <_Objects_Initialize_information+0x74>
10cf10: 85 c9 test %ecx,%ecx
10cf12: 74 57 je 10cf6b <_Objects_Initialize_information+0xcb><== NEVER TAKEN
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
10cf14: 66 89 48 14 mov %cx,0x14(%eax)
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
10cf18: c7 40 1c 04 7a 12 00 movl $0x127a04,0x1c(%eax)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cf1f: c1 e2 18 shl $0x18,%edx 10cf22: 81 ca 00 00 01 00 or $0x10000,%edx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cf28: c1 e3 1b shl $0x1b,%ebx 10cf2b: 09 da or %ebx,%edx
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
10cf2d: 31 db xor %ebx,%ebx 10cf2f: 85 c9 test %ecx,%ecx 10cf31: 0f 95 c3 setne %bl
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cf34: 09 da or %ebx,%edx 10cf36: 89 50 08 mov %edx,0x8(%eax)
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
#endif
information->name_length = name_length;
10cf39: 66 89 70 3a mov %si,0x3a(%eax)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10cf3d: 8d 50 24 lea 0x24(%eax),%edx 10cf40: 89 50 20 mov %edx,0x20(%eax)
head->next = tail;
head->previous = NULL;
10cf43: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10cf4a: 8d 50 20 lea 0x20(%eax),%edx 10cf4d: 89 50 28 mov %edx,0x28(%eax)
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
10cf50: 85 c9 test %ecx,%ecx
10cf52: 75 08 jne 10cf5c <_Objects_Initialize_information+0xbc>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10cf54: 8d 65 f4 lea -0xc(%ebp),%esp 10cf57: 5b pop %ebx 10cf58: 5e pop %esi 10cf59: 5f pop %edi 10cf5a: c9 leave 10cf5b: c3 ret
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10cf5c: 89 45 08 mov %eax,0x8(%ebp)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10cf5f: 8d 65 f4 lea -0xc(%ebp),%esp 10cf62: 5b pop %ebx 10cf63: 5e pop %esi 10cf64: 5f pop %edi 10cf65: c9 leave
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10cf66: e9 bd fa ff ff jmp 10ca28 <_Objects_Extend_information>
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
_Internal_error_Occurred(
10cf6b: 50 push %eax 10cf6c: 6a 13 push $0x13 10cf6e: 6a 01 push $0x1 10cf70: 6a 00 push $0x0 10cf72: e8 7d f9 ff ff call 10c8f4 <_Internal_error_Occurred>
00117994 <_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
)
{
117994: 55 push %ebp 117995: 89 e5 mov %esp,%ebp 117997: 57 push %edi 117998: 56 push %esi 117999: 53 push %ebx 11799a: 83 ec 1c sub $0x1c,%esp 11799d: 8b 7d 08 mov 0x8(%ebp),%edi
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
1179a0: 8b 5d 10 mov 0x10(%ebp),%ebx 1179a3: 85 db test %ebx,%ebx
1179a5: 74 75 je 117a1c <_Objects_Name_to_id_string+0x88>
return OBJECTS_INVALID_ADDRESS;
if ( !name )
1179a7: 8b 4d 0c mov 0xc(%ebp),%ecx 1179aa: 85 c9 test %ecx,%ecx
1179ac: 74 4b je 1179f9 <_Objects_Name_to_id_string+0x65>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
1179ae: 8b 47 10 mov 0x10(%edi),%eax 1179b1: 66 85 c0 test %ax,%ax
1179b4: 74 43 je 1179f9 <_Objects_Name_to_id_string+0x65>
for ( index = 1; index <= information->maximum; index++ ) {
1179b6: 0f b7 c0 movzwl %ax,%eax 1179b9: 89 45 e4 mov %eax,-0x1c(%ebp) 1179bc: 8b 47 1c mov 0x1c(%edi),%eax 1179bf: bb 01 00 00 00 mov $0x1,%ebx 1179c4: 89 7d e0 mov %edi,-0x20(%ebp) 1179c7: 89 c7 mov %eax,%edi 1179c9: 8d 76 00 lea 0x0(%esi),%esi
the_object = information->local_table[ index ];
1179cc: 8b 34 9f mov (%edi,%ebx,4),%esi
if ( !the_object )
1179cf: 85 f6 test %esi,%esi
1179d1: 74 20 je 1179f3 <_Objects_Name_to_id_string+0x5f>
continue;
if ( !the_object->name.name_p )
1179d3: 8b 46 0c mov 0xc(%esi),%eax 1179d6: 85 c0 test %eax,%eax
1179d8: 74 19 je 1179f3 <_Objects_Name_to_id_string+0x5f>
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
1179da: 52 push %edx 1179db: 8b 4d e0 mov -0x20(%ebp),%ecx 1179de: 0f b7 51 3a movzwl 0x3a(%ecx),%edx 1179e2: 52 push %edx 1179e3: 50 push %eax 1179e4: ff 75 0c pushl 0xc(%ebp) 1179e7: e8 a0 34 00 00 call 11ae8c <strncmp> 1179ec: 83 c4 10 add $0x10,%esp 1179ef: 85 c0 test %eax,%eax
1179f1: 74 15 je 117a08 <_Objects_Name_to_id_string+0x74>
if ( !name )
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
1179f3: 43 inc %ebx 1179f4: 3b 5d e4 cmp -0x1c(%ebp),%ebx
1179f7: 76 d3 jbe 1179cc <_Objects_Name_to_id_string+0x38>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
}
}
return OBJECTS_INVALID_NAME;
1179f9: b8 01 00 00 00 mov $0x1,%eax
}
1179fe: 8d 65 f4 lea -0xc(%ebp),%esp 117a01: 5b pop %ebx 117a02: 5e pop %esi 117a03: 5f pop %edi 117a04: c9 leave 117a05: c3 ret 117a06: 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;
117a08: 8b 46 08 mov 0x8(%esi),%eax 117a0b: 8b 55 10 mov 0x10(%ebp),%edx 117a0e: 89 02 mov %eax,(%edx)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
117a10: 31 c0 xor %eax,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
117a12: 8d 65 f4 lea -0xc(%ebp),%esp 117a15: 5b pop %ebx 117a16: 5e pop %esi 117a17: 5f pop %edi 117a18: c9 leave 117a19: c3 ret 117a1a: 66 90 xchg %ax,%ax
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
117a1c: b8 02 00 00 00 mov $0x2,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
117a21: 8d 65 f4 lea -0xc(%ebp),%esp 117a24: 5b pop %ebx 117a25: 5e pop %esi 117a26: 5f pop %edi 117a27: c9 leave 117a28: c3 ret
0010cfa8 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10cfa8: 55 push %ebp 10cfa9: 89 e5 mov %esp,%ebp 10cfab: 57 push %edi 10cfac: 56 push %esi 10cfad: 53 push %ebx 10cfae: 8b 45 08 mov 0x8(%ebp),%eax 10cfb1: 8b 4d 0c mov 0xc(%ebp),%ecx 10cfb4: 8b 55 10 mov 0x10(%ebp),%edx 10cfb7: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
10cfba: 85 ff test %edi,%edi
10cfbc: 74 56 je 10d014 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10cfbe: 85 c9 test %ecx,%ecx
10cfc0: 74 08 je 10cfca <_Objects_Name_to_id_u32+0x22>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cfc2: 8b 70 10 mov 0x10(%eax),%esi 10cfc5: 66 85 f6 test %si,%si
10cfc8: 75 0a jne 10cfd4 <_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;
10cfca: b8 01 00 00 00 mov $0x1,%eax
#endif }
10cfcf: 5b pop %ebx 10cfd0: 5e pop %esi 10cfd1: 5f pop %edi 10cfd2: c9 leave 10cfd3: c3 ret
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cfd4: 85 d2 test %edx,%edx
10cfd6: 75 20 jne 10cff8 <_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++ ) {
10cfd8: 0f b7 f6 movzwl %si,%esi 10cfdb: 8b 58 1c mov 0x1c(%eax),%ebx 10cfde: b8 01 00 00 00 mov $0x1,%eax 10cfe3: 90 nop
the_object = information->local_table[ index ];
10cfe4: 8b 14 83 mov (%ebx,%eax,4),%edx
if ( !the_object )
10cfe7: 85 d2 test %edx,%edx
10cfe9: 74 05 je 10cff0 <_Objects_Name_to_id_u32+0x48>
continue;
if ( name == the_object->name.name_u32 ) {
10cfeb: 39 4a 0c cmp %ecx,0xc(%edx)
10cfee: 74 18 je 10d008 <_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++ ) {
10cff0: 40 inc %eax 10cff1: 39 c6 cmp %eax,%esi
10cff3: 73 ef jae 10cfe4 <_Objects_Name_to_id_u32+0x3c>
10cff5: eb d3 jmp 10cfca <_Objects_Name_to_id_u32+0x22> 10cff7: 90 nop
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
10cff8: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10cffe: 74 d8 je 10cfd8 <_Objects_Name_to_id_u32+0x30>
node == OBJECTS_SEARCH_LOCAL_NODE ||
10d000: 4a dec %edx
10d001: 75 c7 jne 10cfca <_Objects_Name_to_id_u32+0x22>
10d003: eb d3 jmp 10cfd8 <_Objects_Name_to_id_u32+0x30> 10d005: 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;
10d008: 8b 42 08 mov 0x8(%edx),%eax 10d00b: 89 07 mov %eax,(%edi)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10d00d: 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 }
10d00f: 5b pop %ebx 10d010: 5e pop %esi 10d011: 5f pop %edi 10d012: c9 leave 10d013: c3 ret
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
10d014: 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 }
10d019: 5b pop %ebx 10d01a: 5e pop %esi 10d01b: 5f pop %edi 10d01c: c9 leave 10d01d: c3 ret
0010d690 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10d690: 55 push %ebp 10d691: 89 e5 mov %esp,%ebp 10d693: 57 push %edi 10d694: 56 push %esi 10d695: 53 push %ebx 10d696: 83 ec 14 sub $0x14,%esp 10d699: 8b 7d 08 mov 0x8(%ebp),%edi 10d69c: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10d69f: 0f b7 47 3a movzwl 0x3a(%edi),%eax 10d6a3: 50 push %eax 10d6a4: 53 push %ebx 10d6a5: e8 8e 79 00 00 call 115038 <strnlen> 10d6aa: 89 c6 mov %eax,%esi
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10d6ac: 83 c4 10 add $0x10,%esp 10d6af: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10d6b3: 75 57 jne 10d70c <_Objects_Set_name+0x7c>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d6b5: 0f be 13 movsbl (%ebx),%edx 10d6b8: c1 e2 18 shl $0x18,%edx 10d6bb: 83 f8 01 cmp $0x1,%eax
10d6be: 76 38 jbe 10d6f8 <_Objects_Set_name+0x68>
10d6c0: 0f be 43 01 movsbl 0x1(%ebx),%eax 10d6c4: c1 e0 10 shl $0x10,%eax 10d6c7: 09 d0 or %edx,%eax 10d6c9: 83 fe 02 cmp $0x2,%esi
10d6cc: 74 31 je 10d6ff <_Objects_Set_name+0x6f>
10d6ce: 0f be 53 02 movsbl 0x2(%ebx),%edx 10d6d2: c1 e2 08 shl $0x8,%edx 10d6d5: 09 c2 or %eax,%edx 10d6d7: 83 fe 03 cmp $0x3,%esi
10d6da: 0f 84 80 00 00 00 je 10d760 <_Objects_Set_name+0xd0>
10d6e0: 0f be 43 03 movsbl 0x3(%ebx),%eax 10d6e4: 09 c2 or %eax,%edx 10d6e6: 8b 45 0c mov 0xc(%ebp),%eax 10d6e9: 89 50 0c mov %edx,0xc(%eax)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10d6ec: b0 01 mov $0x1,%al
}
10d6ee: 8d 65 f4 lea -0xc(%ebp),%esp 10d6f1: 5b pop %ebx 10d6f2: 5e pop %esi 10d6f3: 5f pop %edi 10d6f4: c9 leave 10d6f5: c3 ret 10d6f6: 66 90 xchg %ax,%ax
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d6f8: 89 d0 mov %edx,%eax 10d6fa: 0d 00 00 20 00 or $0x200000,%eax 10d6ff: 89 c2 mov %eax,%edx 10d701: 80 ce 20 or $0x20,%dh 10d704: b8 20 00 00 00 mov $0x20,%eax 10d709: eb d9 jmp 10d6e4 <_Objects_Set_name+0x54> 10d70b: 90 nop
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
10d70c: 83 ec 0c sub $0xc,%esp 10d70f: 8d 40 01 lea 0x1(%eax),%eax 10d712: 50 push %eax 10d713: e8 bc 19 00 00 call 10f0d4 <_Workspace_Allocate> 10d718: 89 c7 mov %eax,%edi
if ( !d )
10d71a: 83 c4 10 add $0x10,%esp 10d71d: 85 c0 test %eax,%eax
10d71f: 74 3b je 10d75c <_Objects_Set_name+0xcc>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
10d721: 83 ec 0c sub $0xc,%esp 10d724: 8b 45 0c mov 0xc(%ebp),%eax 10d727: ff 70 0c pushl 0xc(%eax) 10d72a: e8 c1 19 00 00 call 10f0f0 <_Workspace_Free>
the_object->name.name_p = NULL;
10d72f: 8b 45 0c mov 0xc(%ebp),%eax 10d732: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
strncpy( d, name, length );
10d739: 83 c4 0c add $0xc,%esp 10d73c: 56 push %esi 10d73d: 53 push %ebx 10d73e: 57 push %edi 10d73f: e8 78 78 00 00 call 114fbc <strncpy>
d[length] = '\0';
10d744: c6 04 37 00 movb $0x0,(%edi,%esi,1)
the_object->name.name_p = d;
10d748: 8b 45 0c mov 0xc(%ebp),%eax 10d74b: 89 78 0c mov %edi,0xc(%eax) 10d74e: 83 c4 10 add $0x10,%esp
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10d751: b0 01 mov $0x1,%al
}
10d753: 8d 65 f4 lea -0xc(%ebp),%esp 10d756: 5b pop %ebx 10d757: 5e pop %esi 10d758: 5f pop %edi 10d759: c9 leave 10d75a: c3 ret 10d75b: 90 nop
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
10d75c: 31 c0 xor %eax,%eax 10d75e: eb 8e jmp 10d6ee <_Objects_Set_name+0x5e>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d760: b8 20 00 00 00 mov $0x20,%eax 10d765: e9 7a ff ff ff jmp 10d6e4 <_Objects_Set_name+0x54>
0010d020 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10d020: 55 push %ebp 10d021: 89 e5 mov %esp,%ebp 10d023: 57 push %edi 10d024: 56 push %esi 10d025: 53 push %ebx 10d026: 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 );
10d029: 8b 45 08 mov 0x8(%ebp),%eax 10d02c: 0f b7 58 08 movzwl 0x8(%eax),%ebx
block_count = (information->maximum - index_base) /
10d030: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10d034: 0f b7 40 10 movzwl 0x10(%eax),%eax 10d038: 29 d8 sub %ebx,%eax 10d03a: 31 d2 xor %edx,%edx 10d03c: f7 f1 div %ecx
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10d03e: 85 c0 test %eax,%eax
10d040: 74 21 je 10d063 <_Objects_Shrink_information+0x43><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10d042: 8b 55 08 mov 0x8(%ebp),%edx 10d045: 8b 72 30 mov 0x30(%edx),%esi 10d048: 3b 0e cmp (%esi),%ecx
10d04a: 74 1f je 10d06b <_Objects_Shrink_information+0x4b><== NEVER TAKEN
10d04c: 31 d2 xor %edx,%edx 10d04e: eb 0e jmp 10d05e <_Objects_Shrink_information+0x3e>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10d050: 01 cb add %ecx,%ebx 10d052: 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 ] ==
10d059: 3b 0c 96 cmp (%esi,%edx,4),%ecx
10d05c: 74 12 je 10d070 <_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++ ) {
10d05e: 42 inc %edx 10d05f: 39 d0 cmp %edx,%eax
10d061: 77 ed ja 10d050 <_Objects_Shrink_information+0x30>
return;
}
index_base += information->allocation_size;
}
}
10d063: 8d 65 f4 lea -0xc(%ebp),%esp 10d066: 5b pop %ebx 10d067: 5e pop %esi 10d068: 5f pop %edi 10d069: c9 leave 10d06a: 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 ] ==
10d06b: 31 ff xor %edi,%edi <== NOT EXECUTED 10d06d: 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 );
10d070: 8b 55 08 mov 0x8(%ebp),%edx 10d073: 8b 42 20 mov 0x20(%edx),%eax 10d076: 89 7d e4 mov %edi,-0x1c(%ebp) 10d079: eb 07 jmp 10d082 <_Objects_Shrink_information+0x62> 10d07b: 90 nop
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10d07c: 85 f6 test %esi,%esi
10d07e: 74 2c je 10d0ac <_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;
10d080: 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 );
10d082: 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;
10d086: 8b 30 mov (%eax),%esi
if ((index >= index_base) &&
10d088: 39 da cmp %ebx,%edx
10d08a: 72 f0 jb 10d07c <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
10d08c: 8b 7d 08 mov 0x8(%ebp),%edi 10d08f: 0f b7 4f 14 movzwl 0x14(%edi),%ecx 10d093: 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) &&
10d096: 39 ca cmp %ecx,%edx
10d098: 73 e2 jae 10d07c <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10d09a: 83 ec 0c sub $0xc,%esp 10d09d: 50 push %eax 10d09e: e8 59 ef ff ff call 10bffc <_Chain_Extract> 10d0a3: 83 c4 10 add $0x10,%esp
}
}
while ( the_object );
10d0a6: 85 f6 test %esi,%esi
10d0a8: 75 d6 jne 10d080 <_Objects_Shrink_information+0x60>
10d0aa: 66 90 xchg %ax,%ax 10d0ac: 8b 7d e4 mov -0x1c(%ebp),%edi
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10d0af: 83 ec 0c sub $0xc,%esp 10d0b2: 8b 55 08 mov 0x8(%ebp),%edx 10d0b5: 8b 42 34 mov 0x34(%edx),%eax 10d0b8: ff 34 38 pushl (%eax,%edi,1) 10d0bb: e8 e4 18 00 00 call 10e9a4 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10d0c0: 8b 55 08 mov 0x8(%ebp),%edx 10d0c3: 8b 42 34 mov 0x34(%edx),%eax 10d0c6: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive_per_block[ block ] = 0;
10d0cd: 8b 42 30 mov 0x30(%edx),%eax 10d0d0: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive -= information->allocation_size;
10d0d7: 8b 42 14 mov 0x14(%edx),%eax 10d0da: 66 29 42 2c sub %ax,0x2c(%edx)
return;
10d0de: 83 c4 10 add $0x10,%esp
}
index_base += information->allocation_size;
}
}
10d0e1: 8d 65 f4 lea -0xc(%ebp),%esp 10d0e4: 5b pop %ebx 10d0e5: 5e pop %esi 10d0e6: 5f pop %edi 10d0e7: c9 leave 10d0e8: c3 ret
0010d524 <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
10d524: 55 push %ebp 10d525: 89 e5 mov %esp,%ebp 10d527: 57 push %edi 10d528: 56 push %esi 10d529: 53 push %ebx 10d52a: 83 ec 38 sub $0x38,%esp 10d52d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d530: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
10d533: c7 06 00 00 00 00 movl $0x0,(%esi)
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
10d539: 53 push %ebx 10d53a: e8 c1 3d 00 00 call 111300 <_Timespec_Is_valid> 10d53f: 83 c4 10 add $0x10,%esp 10d542: 84 c0 test %al,%al
10d544: 75 0a jne 10d550 <_POSIX_Absolute_timeout_to_ticks+0x2c>
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
10d546: 31 c0 xor %eax,%eax
/* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; }
10d548: 8d 65 f4 lea -0xc(%ebp),%esp 10d54b: 5b pop %ebx 10d54c: 5e pop %esi 10d54d: 5f pop %edi 10d54e: c9 leave 10d54f: c3 ret
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
10d550: 83 ec 0c sub $0xc,%esp 10d553: 8d 7d e0 lea -0x20(%ebp),%edi 10d556: 57 push %edi 10d557: e8 84 1d 00 00 call 10f2e0 <_TOD_Get>
if ( _Timespec_Less_than( abstime, ¤t_time ) )
10d55c: 5a pop %edx 10d55d: 59 pop %ecx 10d55e: 57 push %edi 10d55f: 53 push %ebx 10d560: e8 c3 3d 00 00 call 111328 <_Timespec_Less_than> 10d565: 83 c4 10 add $0x10,%esp 10d568: 84 c0 test %al,%al
10d56a: 74 10 je 10d57c <_POSIX_Absolute_timeout_to_ticks+0x58>
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
10d56c: b8 01 00 00 00 mov $0x1,%eax
/* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; }
10d571: 8d 65 f4 lea -0xc(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: 5f pop %edi 10d577: c9 leave 10d578: c3 ret 10d579: 8d 76 00 lea 0x0(%esi),%esi
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
10d57c: 50 push %eax 10d57d: 8d 45 d8 lea -0x28(%ebp),%eax 10d580: 50 push %eax 10d581: 53 push %ebx 10d582: 57 push %edi 10d583: 89 45 d4 mov %eax,-0x2c(%ebp) 10d586: e8 c1 3d 00 00 call 11134c <_Timespec_Subtract>
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
10d58b: 8b 45 d4 mov -0x2c(%ebp),%eax 10d58e: 89 04 24 mov %eax,(%esp) 10d591: e8 f6 3d 00 00 call 11138c <_Timespec_To_ticks> 10d596: 89 06 mov %eax,(%esi)
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
10d598: 83 c4 10 add $0x10,%esp
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
10d59b: 83 f8 01 cmp $0x1,%eax 10d59e: 19 c0 sbb %eax,%eax 10d5a0: 83 c0 03 add $0x3,%eax
/* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; }
10d5a3: 8d 65 f4 lea -0xc(%ebp),%esp 10d5a6: 5b pop %ebx 10d5a7: 5e pop %esi 10d5a8: 5f pop %edi 10d5a9: c9 leave 10d5aa: c3 ret
0010c0cc <_POSIX_Condition_variables_Get>:
POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get (
pthread_cond_t *cond,
Objects_Locations *location
)
{
10c0cc: 55 push %ebp 10c0cd: 89 e5 mov %esp,%ebp 10c0cf: 56 push %esi 10c0d0: 53 push %ebx 10c0d1: 8b 5d 08 mov 0x8(%ebp),%ebx 10c0d4: 8b 75 0c mov 0xc(%ebp),%esi
int status;
if ( !cond ) {
10c0d7: 85 db test %ebx,%ebx
10c0d9: 74 39 je 10c114 <_POSIX_Condition_variables_Get+0x48>
*location = OBJECTS_ERROR;
return (POSIX_Condition_variables_Control *) 0;
}
if ( *cond == PTHREAD_COND_INITIALIZER ) {
10c0db: 8b 03 mov (%ebx),%eax 10c0dd: 83 f8 ff cmp $0xffffffff,%eax
10c0e0: 74 1a je 10c0fc <_POSIX_Condition_variables_Get+0x30>
}
/*
* Now call Objects_Get()
*/
return (POSIX_Condition_variables_Control *)_Objects_Get(
10c0e2: 52 push %edx 10c0e3: 56 push %esi 10c0e4: 50 push %eax 10c0e5: 68 40 9a 12 00 push $0x129a40 10c0ea: e8 75 2b 00 00 call 10ec64 <_Objects_Get> 10c0ef: 83 c4 10 add $0x10,%esp
&_POSIX_Condition_variables_Information,
(Objects_Id) *cond,
location
);
}
10c0f2: 8d 65 f8 lea -0x8(%ebp),%esp 10c0f5: 5b pop %ebx 10c0f6: 5e pop %esi 10c0f7: c9 leave 10c0f8: c3 ret 10c0f9: 8d 76 00 lea 0x0(%esi),%esi
if ( *cond == PTHREAD_COND_INITIALIZER ) {
/*
* Do an "auto-create" here.
*/
status = pthread_cond_init( cond, 0 );
10c0fc: 83 ec 08 sub $0x8,%esp 10c0ff: 6a 00 push $0x0 10c101: 53 push %ebx 10c102: e8 19 00 00 00 call 10c120 <pthread_cond_init>
if ( status ) {
10c107: 83 c4 10 add $0x10,%esp 10c10a: 85 c0 test %eax,%eax
10c10c: 75 06 jne 10c114 <_POSIX_Condition_variables_Get+0x48>
10c10e: 8b 03 mov (%ebx),%eax 10c110: eb d0 jmp 10c0e2 <_POSIX_Condition_variables_Get+0x16> 10c112: 66 90 xchg %ax,%ax
*location = OBJECTS_ERROR;
10c114: c7 06 01 00 00 00 movl $0x1,(%esi)
return (POSIX_Condition_variables_Control *) 0;
10c11a: 31 c0 xor %eax,%eax 10c11c: eb d4 jmp 10c0f2 <_POSIX_Condition_variables_Get+0x26>
0010c1e8 <_POSIX_Condition_variables_Signal_support>:
int _POSIX_Condition_variables_Signal_support(
pthread_cond_t *cond,
bool is_broadcast
)
{
10c1e8: 55 push %ebp 10c1e9: 89 e5 mov %esp,%ebp 10c1eb: 57 push %edi 10c1ec: 56 push %esi 10c1ed: 53 push %ebx 10c1ee: 83 ec 24 sub $0x24,%esp 10c1f1: 8a 5d 0c mov 0xc(%ebp),%bl
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
Thread_Control *the_thread;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10c1f4: 8d 45 e4 lea -0x1c(%ebp),%eax 10c1f7: 50 push %eax 10c1f8: ff 75 08 pushl 0x8(%ebp) 10c1fb: e8 cc fe ff ff call 10c0cc <_POSIX_Condition_variables_Get> 10c200: 89 c7 mov %eax,%edi
switch ( location ) {
10c202: 83 c4 10 add $0x10,%esp 10c205: 8b 45 e4 mov -0x1c(%ebp),%eax 10c208: 85 c0 test %eax,%eax
10c20a: 74 10 je 10c21c <_POSIX_Condition_variables_Signal_support+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c20c: b8 16 00 00 00 mov $0x16,%eax
}
10c211: 8d 65 f4 lea -0xc(%ebp),%esp 10c214: 5b pop %ebx 10c215: 5e pop %esi 10c216: 5f pop %edi 10c217: c9 leave 10c218: c3 ret 10c219: 8d 76 00 lea 0x0(%esi),%esi 10c21c: 8d 77 18 lea 0x18(%edi),%esi 10c21f: eb 0b jmp 10c22c <_POSIX_Condition_variables_Signal_support+0x44> 10c221: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
do {
the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue );
if ( !the_thread )
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
} while ( is_broadcast && the_thread );
10c224: 84 db test %bl,%bl
10c226: 74 20 je 10c248 <_POSIX_Condition_variables_Signal_support+0x60>
10c228: 85 c0 test %eax,%eax
10c22a: 74 1c je 10c248 <_POSIX_Condition_variables_Signal_support+0x60>
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
case OBJECTS_LOCAL:
do {
the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue );
10c22c: 83 ec 0c sub $0xc,%esp 10c22f: 56 push %esi 10c230: e8 23 39 00 00 call 10fb58 <_Thread_queue_Dequeue>
if ( !the_thread )
10c235: 83 c4 10 add $0x10,%esp 10c238: 85 c0 test %eax,%eax
10c23a: 75 e8 jne 10c224 <_POSIX_Condition_variables_Signal_support+0x3c>
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10c23c: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi)
} while ( is_broadcast && the_thread );
10c243: 84 db test %bl,%bl
10c245: 75 e1 jne 10c228 <_POSIX_Condition_variables_Signal_support+0x40>
10c247: 90 nop
_Thread_Enable_dispatch();
10c248: e8 8f 35 00 00 call 10f7dc <_Thread_Enable_dispatch>
return 0;
10c24d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c24f: 8d 65 f4 lea -0xc(%ebp),%esp 10c252: 5b pop %ebx 10c253: 5e pop %esi 10c254: 5f pop %edi 10c255: c9 leave 10c256: c3 ret
0010c2b0 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
10c2b0: 55 push %ebp 10c2b1: 89 e5 mov %esp,%ebp 10c2b3: 57 push %edi 10c2b4: 56 push %esi 10c2b5: 53 push %ebx 10c2b6: 83 ec 34 sub $0x34,%esp 10c2b9: 8b 7d 08 mov 0x8(%ebp),%edi 10c2bc: 8b 5d 0c mov 0xc(%ebp),%ebx 10c2bf: 8a 45 14 mov 0x14(%ebp),%al 10c2c2: 88 45 d7 mov %al,-0x29(%ebp)
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
10c2c5: 8d 75 e4 lea -0x1c(%ebp),%esi 10c2c8: 56 push %esi 10c2c9: 53 push %ebx 10c2ca: e8 59 01 00 00 call 10c428 <_POSIX_Mutex_Get> 10c2cf: 83 c4 10 add $0x10,%esp 10c2d2: 85 c0 test %eax,%eax
10c2d4: 74 21 je 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c2d6: a1 90 95 12 00 mov 0x129590,%eax 10c2db: 48 dec %eax 10c2dc: a3 90 95 12 00 mov %eax,0x129590
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10c2e1: 83 ec 08 sub $0x8,%esp 10c2e4: 56 push %esi 10c2e5: 57 push %edi 10c2e6: e8 e1 fd ff ff call 10c0cc <_POSIX_Condition_variables_Get> 10c2eb: 89 c6 mov %eax,%esi
switch ( location ) {
10c2ed: 83 c4 10 add $0x10,%esp 10c2f0: 8b 55 e4 mov -0x1c(%ebp),%edx 10c2f3: 85 d2 test %edx,%edx
10c2f5: 74 11 je 10c308 <_POSIX_Condition_variables_Wait_support+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c2f7: be 16 00 00 00 mov $0x16,%esi
}
10c2fc: 89 f0 mov %esi,%eax 10c2fe: 8d 65 f4 lea -0xc(%ebp),%esp 10c301: 5b pop %ebx 10c302: 5e pop %esi 10c303: 5f pop %edi 10c304: c9 leave 10c305: c3 ret 10c306: 66 90 xchg %ax,%ax
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
10c308: 8b 40 14 mov 0x14(%eax),%eax 10c30b: 85 c0 test %eax,%eax
10c30d: 74 19 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78>
10c30f: 3b 03 cmp (%ebx),%eax
10c311: 74 15 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78>
_Thread_Enable_dispatch();
10c313: e8 c4 34 00 00 call 10f7dc <_Thread_Enable_dispatch>
return EINVAL;
10c318: be 16 00 00 00 mov $0x16,%esi
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c31d: 89 f0 mov %esi,%eax 10c31f: 8d 65 f4 lea -0xc(%ebp),%esp 10c322: 5b pop %ebx 10c323: 5e pop %esi 10c324: 5f pop %edi 10c325: c9 leave 10c326: c3 ret 10c327: 90 nop
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
_Thread_Enable_dispatch();
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
10c328: 83 ec 0c sub $0xc,%esp 10c32b: 53 push %ebx 10c32c: e8 73 03 00 00 call 10c6a4 <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
10c331: 83 c4 10 add $0x10,%esp 10c334: 80 7d d7 00 cmpb $0x0,-0x29(%ebp)
10c338: 75 4e jne 10c388 <_POSIX_Condition_variables_Wait_support+0xd8>
the_cond->Mutex = *mutex;
10c33a: 8b 03 mov (%ebx),%eax 10c33c: 89 46 14 mov %eax,0x14(%esi)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c33f: c7 46 48 01 00 00 00 movl $0x1,0x48(%esi)
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
10c346: a1 38 9b 12 00 mov 0x129b38,%eax 10c34b: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
10c352: 83 c6 18 add $0x18,%esi 10c355: 89 70 44 mov %esi,0x44(%eax)
_Thread_Executing->Wait.id = *cond;
10c358: 8b 17 mov (%edi),%edx 10c35a: 89 50 20 mov %edx,0x20(%eax)
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
10c35d: 50 push %eax 10c35e: 68 fc ff 10 00 push $0x10fffc 10c363: ff 75 10 pushl 0x10(%ebp) 10c366: 56 push %esi 10c367: e8 14 39 00 00 call 10fc80 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10c36c: e8 6b 34 00 00 call 10f7dc <_Thread_Enable_dispatch>
* a POSIX signal, then pthread_cond_wait returns spuriously,
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal or a pthread_cond_broadcast.
*/
status = _Thread_Executing->Wait.return_code;
10c371: a1 38 9b 12 00 mov 0x129b38,%eax 10c376: 8b 70 34 mov 0x34(%eax),%esi
if ( status == EINTR )
10c379: 83 c4 10 add $0x10,%esp 10c37c: 83 fe 04 cmp $0x4,%esi
10c37f: 75 11 jne 10c392 <_POSIX_Condition_variables_Wait_support+0xe2>
status = 0;
10c381: 31 f6 xor %esi,%esi 10c383: eb 0d jmp 10c392 <_POSIX_Condition_variables_Wait_support+0xe2> 10c385: 8d 76 00 lea 0x0(%esi),%esi
} else {
_Thread_Enable_dispatch();
10c388: e8 4f 34 00 00 call 10f7dc <_Thread_Enable_dispatch>
status = ETIMEDOUT;
10c38d: be 74 00 00 00 mov $0x74,%esi
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
10c392: 83 ec 0c sub $0xc,%esp 10c395: 53 push %ebx 10c396: e8 81 02 00 00 call 10c61c <pthread_mutex_lock>
if ( mutex_status )
10c39b: 83 c4 10 add $0x10,%esp 10c39e: 85 c0 test %eax,%eax
10c3a0: 0f 85 51 ff ff ff jne 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c3a6: 89 f0 mov %esi,%eax 10c3a8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3ab: 5b pop %ebx 10c3ac: 5e pop %esi 10c3ad: 5f pop %edi 10c3ae: c9 leave 10c3af: c3 ret
001163a8 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
1163a8: 55 push %ebp 1163a9: 89 e5 mov %esp,%ebp 1163ab: 57 push %edi 1163ac: 56 push %esi 1163ad: 53 push %ebx 1163ae: 83 ec 24 sub $0x24,%esp 1163b1: 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 );
1163b4: 68 ff 00 00 00 push $0xff 1163b9: ff 75 08 pushl 0x8(%ebp) 1163bc: e8 d7 4b 00 00 call 11af98 <strnlen> 1163c1: 89 c6 mov %eax,%esi 1163c3: a1 f0 0e 13 00 mov 0x130ef0,%eax 1163c8: 40 inc %eax 1163c9: a3 f0 0e 13 00 mov %eax,0x130ef0
* 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 ) {
1163ce: 83 c4 10 add $0x10,%esp 1163d1: 85 db test %ebx,%ebx
1163d3: 0f 84 b7 00 00 00 je 116490 <_POSIX_Message_queue_Create_support+0xe8>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
1163d9: 8b 7b 04 mov 0x4(%ebx),%edi 1163dc: 85 ff test %edi,%edi
1163de: 0f 8e f0 00 00 00 jle 1164d4 <_POSIX_Message_queue_Create_support+0x12c>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
1163e4: 8b 5b 08 mov 0x8(%ebx),%ebx 1163e7: 89 5d e4 mov %ebx,-0x1c(%ebp) 1163ea: 85 db test %ebx,%ebx
1163ec: 0f 8e e2 00 00 00 jle 1164d4 <_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 );
1163f2: 83 ec 0c sub $0xc,%esp 1163f5: 68 80 12 13 00 push $0x131280 1163fa: e8 a5 c3 ff ff call 1127a4 <_Objects_Allocate> 1163ff: 89 c3 mov %eax,%ebx
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
116401: 83 c4 10 add $0x10,%esp 116404: 85 c0 test %eax,%eax
116406: 0f 84 0a 01 00 00 je 116516 <_POSIX_Message_queue_Create_support+0x16e>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
11640c: 8b 45 0c mov 0xc(%ebp),%eax 11640f: 89 43 10 mov %eax,0x10(%ebx)
the_mq->named = true;
116412: c6 43 14 01 movb $0x1,0x14(%ebx)
the_mq->open_count = 1;
116416: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx)
the_mq->linked = true;
11641d: 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);
116421: 8d 56 01 lea 0x1(%esi),%edx 116424: 83 ec 0c sub $0xc,%esp 116427: 52 push %edx 116428: 89 55 e0 mov %edx,-0x20(%ebp) 11642b: e8 d4 e4 ff ff call 114904 <_Workspace_Allocate> 116430: 89 c6 mov %eax,%esi
if (!name) {
116432: 83 c4 10 add $0x10,%esp 116435: 85 c0 test %eax,%eax 116437: 8b 55 e0 mov -0x20(%ebp),%edx
11643a: 0f 84 ab 00 00 00 je 1164eb <_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 );
116440: 50 push %eax 116441: 52 push %edx 116442: ff 75 08 pushl 0x8(%ebp) 116445: 56 push %esi 116446: e8 d1 4a 00 00 call 11af1c <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;
11644b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
if ( !_CORE_message_queue_Initialize(
116452: ff 75 e4 pushl -0x1c(%ebp) 116455: 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;
116456: 8d 43 5c lea 0x5c(%ebx),%eax
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( !_CORE_message_queue_Initialize(
116459: 50 push %eax 11645a: 8d 43 1c lea 0x1c(%ebx),%eax 11645d: 50 push %eax 11645e: e8 25 0f 00 00 call 117388 <_CORE_message_queue_Initialize> 116463: 83 c4 20 add $0x20,%esp 116466: 84 c0 test %al,%al
116468: 74 3a je 1164a4 <_POSIX_Message_queue_Create_support+0xfc>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
11646a: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11646e: a1 9c 12 13 00 mov 0x13129c,%eax 116473: 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;
116476: 89 73 0c mov %esi,0xc(%ebx)
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
116479: 8b 45 14 mov 0x14(%ebp),%eax 11647c: 89 18 mov %ebx,(%eax)
_Thread_Enable_dispatch();
11647e: e8 cd d3 ff ff call 113850 <_Thread_Enable_dispatch>
return 0;
116483: 31 c0 xor %eax,%eax
}
116485: 8d 65 f4 lea -0xc(%ebp),%esp 116488: 5b pop %ebx 116489: 5e pop %esi 11648a: 5f pop %edi 11648b: c9 leave 11648c: c3 ret 11648d: 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;
116490: 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;
116497: bf 0a 00 00 00 mov $0xa,%edi 11649c: e9 51 ff ff ff jmp 1163f2 <_POSIX_Message_queue_Create_support+0x4a> 1164a1: 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 );
1164a4: 83 ec 08 sub $0x8,%esp 1164a7: 53 push %ebx 1164a8: 68 80 12 13 00 push $0x131280 1164ad: e8 66 c6 ff ff call 112b18 <_Objects_Free>
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
1164b2: 89 34 24 mov %esi,(%esp) 1164b5: e8 66 e4 ff ff call 114920 <_Workspace_Free>
_Thread_Enable_dispatch();
1164ba: e8 91 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
1164bf: e8 50 33 00 00 call 119814 <__errno> 1164c4: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1164ca: 83 c4 10 add $0x10,%esp 1164cd: b8 ff ff ff ff mov $0xffffffff,%eax 1164d2: eb b1 jmp 116485 <_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();
1164d4: e8 77 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
1164d9: e8 36 33 00 00 call 119814 <__errno> 1164de: c7 00 16 00 00 00 movl $0x16,(%eax) 1164e4: b8 ff ff ff ff mov $0xffffffff,%eax 1164e9: eb 9a jmp 116485 <_POSIX_Message_queue_Create_support+0xdd> 1164eb: 83 ec 08 sub $0x8,%esp 1164ee: 53 push %ebx 1164ef: 68 80 12 13 00 push $0x131280 1164f4: e8 1f c6 ff ff call 112b18 <_Objects_Free>
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
if (!name) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
1164f9: e8 52 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOMEM );
1164fe: e8 11 33 00 00 call 119814 <__errno> 116503: c7 00 0c 00 00 00 movl $0xc,(%eax) 116509: 83 c4 10 add $0x10,%esp 11650c: b8 ff ff ff ff mov $0xffffffff,%eax 116511: e9 6f ff ff ff jmp 116485 <_POSIX_Message_queue_Create_support+0xdd>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
116516: e8 35 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
11651b: e8 f4 32 00 00 call 119814 <__errno> 116520: c7 00 17 00 00 00 movl $0x17,(%eax) 116526: b8 ff ff ff ff mov $0xffffffff,%eax 11652b: e9 55 ff ff ff jmp 116485 <_POSIX_Message_queue_Create_support+0xdd>
00116530 <_POSIX_Message_queue_Name_to_id>:
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
116530: 55 push %ebp 116531: 89 e5 mov %esp,%ebp 116533: 53 push %ebx 116534: 83 ec 14 sub $0x14,%esp 116537: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
11653a: 85 db test %ebx,%ebx
11653c: 74 05 je 116543 <_POSIX_Message_queue_Name_to_id+0x13>
return EINVAL;
if ( !name[0] )
11653e: 80 3b 00 cmpb $0x0,(%ebx)
116541: 75 0d jne 116550 <_POSIX_Message_queue_Name_to_id+0x20>
return EINVAL;
116543: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
116548: 8b 5d fc mov -0x4(%ebp),%ebx 11654b: c9 leave 11654c: c3 ret 11654d: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
116550: 83 ec 08 sub $0x8,%esp 116553: 68 ff 00 00 00 push $0xff 116558: 53 push %ebx 116559: e8 3a 4a 00 00 call 11af98 <strnlen> 11655e: 83 c4 10 add $0x10,%esp 116561: 3d fe 00 00 00 cmp $0xfe,%eax
116566: 76 0c jbe 116574 <_POSIX_Message_queue_Name_to_id+0x44>
return ENAMETOOLONG;
116568: b8 5b 00 00 00 mov $0x5b,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
11656d: 8b 5d fc mov -0x4(%ebp),%ebx 116570: c9 leave 116571: c3 ret 116572: 66 90 xchg %ax,%ax
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
return ENAMETOOLONG;
status = _Objects_Name_to_id_string(
116574: 50 push %eax 116575: 8d 45 f4 lea -0xc(%ebp),%eax 116578: 50 push %eax 116579: 53 push %ebx 11657a: 68 80 12 13 00 push $0x131280 11657f: e8 10 14 00 00 call 117994 <_Objects_Name_to_id_string>
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
116584: 8b 4d f4 mov -0xc(%ebp),%ecx 116587: 8b 55 0c mov 0xc(%ebp),%edx 11658a: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
11658c: 83 c4 10 add $0x10,%esp
return 0;
11658f: 83 f8 01 cmp $0x1,%eax 116592: 19 c0 sbb %eax,%eax 116594: f7 d0 not %eax 116596: 83 e0 02 and $0x2,%eax
return ENOENT;
}
116599: 8b 5d fc mov -0x4(%ebp),%ebx 11659c: c9 leave 11659d: c3 ret
0010fce8 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10fce8: 55 push %ebp 10fce9: 89 e5 mov %esp,%ebp 10fceb: 53 push %ebx 10fcec: 83 ec 28 sub $0x28,%esp 10fcef: 8b 5d 08 mov 0x8(%ebp),%ebx 10fcf2: 8a 45 18 mov 0x18(%ebp),%al 10fcf5: 88 45 e7 mov %al,-0x19(%ebp)
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10fcf8: 8d 45 f4 lea -0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10fcfb: 50 push %eax 10fcfc: 53 push %ebx 10fcfd: 68 20 14 13 00 push $0x131420 10fd02: e8 51 2f 00 00 call 112c58 <_Objects_Get>
switch ( location ) {
10fd07: 83 c4 10 add $0x10,%esp 10fd0a: 8b 55 f4 mov -0xc(%ebp),%edx 10fd0d: 85 d2 test %edx,%edx
10fd0f: 74 17 je 10fd28 <_POSIX_Message_queue_Receive_support+0x40>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10fd11: e8 fe 9a 00 00 call 119814 <__errno> 10fd16: c7 00 09 00 00 00 movl $0x9,(%eax) 10fd1c: b8 ff ff ff ff mov $0xffffffff,%eax
}
10fd21: 8b 5d fc mov -0x4(%ebp),%ebx 10fd24: c9 leave 10fd25: c3 ret 10fd26: 66 90 xchg %ax,%ax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10fd28: 8b 50 14 mov 0x14(%eax),%edx 10fd2b: 89 d1 mov %edx,%ecx 10fd2d: 83 e1 03 and $0x3,%ecx 10fd30: 49 dec %ecx
10fd31: 0f 84 af 00 00 00 je 10fde6 <_POSIX_Message_queue_Receive_support+0xfe>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10fd37: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10fd3a: 8b 4d 10 mov 0x10(%ebp),%ecx 10fd3d: 39 48 68 cmp %ecx,0x68(%eax)
10fd40: 77 62 ja 10fda4 <_POSIX_Message_queue_Receive_support+0xbc>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10fd42: c7 45 f0 ff ff ff ff movl $0xffffffff,-0x10(%ebp)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fd49: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10fd4d: 75 45 jne 10fd94 <_POSIX_Message_queue_Receive_support+0xac><== ALWAYS TAKEN
10fd4f: 31 d2 xor %edx,%edx <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10fd51: 83 ec 08 sub $0x8,%esp 10fd54: ff 75 1c pushl 0x1c(%ebp) 10fd57: 52 push %edx 10fd58: 8d 55 f0 lea -0x10(%ebp),%edx 10fd5b: 52 push %edx 10fd5c: ff 75 0c pushl 0xc(%ebp) 10fd5f: 53 push %ebx 10fd60: 83 c0 1c add $0x1c,%eax 10fd63: 50 push %eax 10fd64: e8 9f 1f 00 00 call 111d08 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10fd69: 83 c4 20 add $0x20,%esp 10fd6c: e8 df 3a 00 00 call 113850 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10fd71: 8b 15 98 14 13 00 mov 0x131498,%edx
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
10fd77: 8b 42 24 mov 0x24(%edx),%eax 10fd7a: 85 c0 test %eax,%eax
10fd7c: 78 22 js 10fda0 <_POSIX_Message_queue_Receive_support+0xb8>
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
10fd7e: 8b 4d 14 mov 0x14(%ebp),%ecx 10fd81: 89 01 mov %eax,(%ecx)
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
10fd83: 8b 42 34 mov 0x34(%edx),%eax 10fd86: 85 c0 test %eax,%eax
10fd88: 75 36 jne 10fdc0 <_POSIX_Message_queue_Receive_support+0xd8>
return length_out;
10fd8a: 8b 45 f0 mov -0x10(%ebp),%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
10fd8d: 8b 5d fc mov -0x4(%ebp),%ebx 10fd90: c9 leave 10fd91: c3 ret 10fd92: 66 90 xchg %ax,%ax
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fd94: 80 e6 40 and $0x40,%dh 10fd97: 0f 94 c2 sete %dl 10fd9a: 0f b6 d2 movzbl %dl,%edx 10fd9d: eb b2 jmp 10fd51 <_POSIX_Message_queue_Receive_support+0x69> 10fd9f: 90 nop 10fda0: f7 d8 neg %eax 10fda2: eb da jmp 10fd7e <_POSIX_Message_queue_Receive_support+0x96>
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
10fda4: e8 a7 3a 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10fda9: e8 66 9a 00 00 call 119814 <__errno> 10fdae: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10fdb4: b8 ff ff ff ff mov $0xffffffff,%eax 10fdb9: e9 63 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39> 10fdbe: 66 90 xchg %ax,%ax
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
10fdc0: e8 4f 9a 00 00 call 119814 <__errno> 10fdc5: 89 c3 mov %eax,%ebx 10fdc7: 83 ec 0c sub $0xc,%esp 10fdca: a1 98 14 13 00 mov 0x131498,%eax 10fdcf: ff 70 34 pushl 0x34(%eax) 10fdd2: e8 29 02 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10fdd7: 89 03 mov %eax,(%ebx) 10fdd9: 83 c4 10 add $0x10,%esp 10fddc: b8 ff ff ff ff mov $0xffffffff,%eax 10fde1: e9 3b ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
10fde6: e8 65 3a 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10fdeb: e8 24 9a 00 00 call 119814 <__errno> 10fdf0: c7 00 09 00 00 00 movl $0x9,(%eax) 10fdf6: b8 ff ff ff ff mov $0xffffffff,%eax 10fdfb: e9 21 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39>
0010fe20 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10fe20: 55 push %ebp 10fe21: 89 e5 mov %esp,%ebp 10fe23: 56 push %esi 10fe24: 53 push %ebx 10fe25: 83 ec 20 sub $0x20,%esp 10fe28: 8b 75 08 mov 0x8(%ebp),%esi 10fe2b: 8b 5d 14 mov 0x14(%ebp),%ebx 10fe2e: 8a 55 18 mov 0x18(%ebp),%dl
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
10fe31: 83 fb 20 cmp $0x20,%ebx
10fe34: 0f 87 92 00 00 00 ja 10fecc <_POSIX_Message_queue_Send_support+0xac>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10fe3a: 51 push %ecx
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10fe3b: 8d 45 f4 lea -0xc(%ebp),%eax 10fe3e: 50 push %eax 10fe3f: 56 push %esi 10fe40: 68 20 14 13 00 push $0x131420 10fe45: 88 55 e4 mov %dl,-0x1c(%ebp) 10fe48: e8 0b 2e 00 00 call 112c58 <_Objects_Get>
switch ( location ) {
10fe4d: 83 c4 10 add $0x10,%esp 10fe50: 8b 55 f4 mov -0xc(%ebp),%edx 10fe53: 85 d2 test %edx,%edx 10fe55: 8a 55 e4 mov -0x1c(%ebp),%dl
10fe58: 75 5e jne 10feb8 <_POSIX_Message_queue_Send_support+0x98>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
10fe5a: 8b 48 14 mov 0x14(%eax),%ecx 10fe5d: f6 c1 03 test $0x3,%cl
10fe60: 74 7e je 10fee0 <_POSIX_Message_queue_Send_support+0xc0>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10fe62: 8b 40 10 mov 0x10(%eax),%eax
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fe65: 84 d2 test %dl,%dl
10fe67: 75 37 jne 10fea0 <_POSIX_Message_queue_Send_support+0x80>
10fe69: 31 d2 xor %edx,%edx
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
10fe6b: ff 75 1c pushl 0x1c(%ebp) 10fe6e: 52 push %edx
RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core(
unsigned int priority
)
{
return priority * -1;
10fe6f: f7 db neg %ebx 10fe71: 53 push %ebx 10fe72: 6a 00 push $0x0 10fe74: 56 push %esi 10fe75: ff 75 10 pushl 0x10(%ebp) 10fe78: ff 75 0c pushl 0xc(%ebp) 10fe7b: 83 c0 1c add $0x1c,%eax 10fe7e: 50 push %eax 10fe7f: e8 b0 1f 00 00 call 111e34 <_CORE_message_queue_Submit> 10fe84: 89 c3 mov %eax,%ebx
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
10fe86: 83 c4 20 add $0x20,%esp 10fe89: e8 c2 39 00 00 call 113850 <_Thread_Enable_dispatch>
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
10fe8e: 83 fb 07 cmp $0x7,%ebx
10fe91: 74 19 je 10feac <_POSIX_Message_queue_Send_support+0x8c>
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
10fe93: 85 db test %ebx,%ebx
10fe95: 75 61 jne 10fef8 <_POSIX_Message_queue_Send_support+0xd8>
return msg_status;
10fe97: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
10fe99: 8d 65 f8 lea -0x8(%ebp),%esp 10fe9c: 5b pop %ebx 10fe9d: 5e pop %esi 10fe9e: c9 leave 10fe9f: c3 ret
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fea0: 31 d2 xor %edx,%edx 10fea2: f6 c5 40 test $0x40,%ch 10fea5: 0f 94 c2 sete %dl 10fea8: eb c1 jmp 10fe6b <_POSIX_Message_queue_Send_support+0x4b> 10feaa: 66 90 xchg %ax,%ax
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
msg_status = _Thread_Executing->Wait.return_code;
10feac: a1 98 14 13 00 mov 0x131498,%eax 10feb1: 8b 58 34 mov 0x34(%eax),%ebx 10feb4: eb dd jmp 10fe93 <_POSIX_Message_queue_Send_support+0x73> 10feb6: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10feb8: e8 57 99 00 00 call 119814 <__errno> 10febd: c7 00 09 00 00 00 movl $0x9,(%eax) 10fec3: b8 ff ff ff ff mov $0xffffffff,%eax 10fec8: eb cf jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10feca: 66 90 xchg %ax,%ax
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
10fecc: e8 43 99 00 00 call 119814 <__errno> 10fed1: c7 00 16 00 00 00 movl $0x16,(%eax) 10fed7: b8 ff ff ff ff mov $0xffffffff,%eax 10fedc: eb bb jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10fede: 66 90 xchg %ax,%ax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
10fee0: e8 6b 39 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10fee5: e8 2a 99 00 00 call 119814 <__errno> 10feea: c7 00 09 00 00 00 movl $0x9,(%eax) 10fef0: b8 ff ff ff ff mov $0xffffffff,%eax 10fef5: eb a2 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79> 10fef7: 90 nop
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
return msg_status;
rtems_set_errno_and_return_minus_one(
10fef8: e8 17 99 00 00 call 119814 <__errno> 10fefd: 89 c6 mov %eax,%esi 10feff: 83 ec 0c sub $0xc,%esp 10ff02: 53 push %ebx 10ff03: e8 f8 00 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10ff08: 89 06 mov %eax,(%esi) 10ff0a: 83 c4 10 add $0x10,%esp 10ff0d: b8 ff ff ff ff mov $0xffffffff,%eax 10ff12: eb 85 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79>
0010d0f4 <_POSIX_Mutex_Get>:
POSIX_Mutex_Control *_POSIX_Mutex_Get (
pthread_mutex_t *mutex,
Objects_Locations *location
)
{
10d0f4: 55 push %ebp 10d0f5: 89 e5 mov %esp,%ebp 10d0f7: 56 push %esi 10d0f8: 53 push %ebx 10d0f9: 8b 5d 08 mov 0x8(%ebp),%ebx 10d0fc: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10d0ff: 85 db test %ebx,%ebx
10d101: 74 39 je 10d13c <_POSIX_Mutex_Get+0x48>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d103: 8b 03 mov (%ebx),%eax 10d105: 83 f8 ff cmp $0xffffffff,%eax
10d108: 74 1a je 10d124 <_POSIX_Mutex_Get+0x30>
return (POSIX_Mutex_Control *)
_Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location );
10d10a: 52 push %edx 10d10b: 56 push %esi 10d10c: 50 push %eax 10d10d: 68 c0 d0 12 00 push $0x12d0c0 10d112: e8 e1 2b 00 00 call 10fcf8 <_Objects_Get>
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
return (POSIX_Mutex_Control *)
10d117: 83 c4 10 add $0x10,%esp
_Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location );
}
10d11a: 8d 65 f8 lea -0x8(%ebp),%esp 10d11d: 5b pop %ebx 10d11e: 5e pop %esi 10d11f: c9 leave 10d120: c3 ret 10d121: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations *location
)
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d124: 83 ec 08 sub $0x8,%esp 10d127: 6a 00 push $0x0 10d129: 53 push %ebx 10d12a: e8 b9 00 00 00 call 10d1e8 <pthread_mutex_init> 10d12f: 83 c4 10 add $0x10,%esp 10d132: 85 c0 test %eax,%eax
10d134: 75 06 jne 10d13c <_POSIX_Mutex_Get+0x48>
10d136: 8b 03 mov (%ebx),%eax 10d138: eb d0 jmp 10d10a <_POSIX_Mutex_Get+0x16> 10d13a: 66 90 xchg %ax,%ax 10d13c: c7 06 01 00 00 00 movl $0x1,(%esi) 10d142: 31 c0 xor %eax,%eax 10d144: eb d4 jmp 10d11a <_POSIX_Mutex_Get+0x26>
0010d148 <_POSIX_Mutex_Get_interrupt_disable>:
POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable (
pthread_mutex_t *mutex,
Objects_Locations *location,
ISR_Level *level
)
{
10d148: 55 push %ebp 10d149: 89 e5 mov %esp,%ebp 10d14b: 56 push %esi 10d14c: 53 push %ebx 10d14d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d150: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10d153: 85 db test %ebx,%ebx
10d155: 74 39 je 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d157: 8b 03 mov (%ebx),%eax 10d159: 83 f8 ff cmp $0xffffffff,%eax
10d15c: 74 1a je 10d178 <_POSIX_Mutex_Get_interrupt_disable+0x30>
return (POSIX_Mutex_Control *) _Objects_Get_isr_disable(
10d15e: ff 75 10 pushl 0x10(%ebp) 10d161: 56 push %esi 10d162: 50 push %eax 10d163: 68 c0 d0 12 00 push $0x12d0c0 10d168: e8 33 2b 00 00 call 10fca0 <_Objects_Get_isr_disable> 10d16d: 83 c4 10 add $0x10,%esp
&_POSIX_Mutex_Information,
(Objects_Id) *mutex,
location,
level
);
}
10d170: 8d 65 f8 lea -0x8(%ebp),%esp 10d173: 5b pop %ebx 10d174: 5e pop %esi 10d175: c9 leave 10d176: c3 ret 10d177: 90 nop
ISR_Level *level
)
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d178: 83 ec 08 sub $0x8,%esp 10d17b: 6a 00 push $0x0 10d17d: 53 push %ebx 10d17e: e8 65 00 00 00 call 10d1e8 <pthread_mutex_init> 10d183: 83 c4 10 add $0x10,%esp 10d186: 85 c0 test %eax,%eax
10d188: 75 06 jne 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48>
10d18a: 8b 03 mov (%ebx),%eax 10d18c: eb d0 jmp 10d15e <_POSIX_Mutex_Get_interrupt_disable+0x16> 10d18e: 66 90 xchg %ax,%ax 10d190: c7 06 01 00 00 00 movl $0x1,(%esi) 10d196: 31 c0 xor %eax,%eax 10d198: eb d6 jmp 10d170 <_POSIX_Mutex_Get_interrupt_disable+0x28>
0010d348 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
bool blocking,
Watchdog_Interval timeout
)
{
10d348: 55 push %ebp 10d349: 89 e5 mov %esp,%ebp 10d34b: 53 push %ebx 10d34c: 83 ec 18 sub $0x18,%esp 10d34f: 8a 5d 0c mov 0xc(%ebp),%bl
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
ISR_Level level;
the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level );
10d352: 8d 45 f0 lea -0x10(%ebp),%eax 10d355: 50 push %eax 10d356: 8d 45 f4 lea -0xc(%ebp),%eax 10d359: 50 push %eax 10d35a: ff 75 08 pushl 0x8(%ebp) 10d35d: e8 e6 fd ff ff call 10d148 <_POSIX_Mutex_Get_interrupt_disable>
switch ( location ) {
10d362: 83 c4 10 add $0x10,%esp 10d365: 8b 55 f4 mov -0xc(%ebp),%edx 10d368: 85 d2 test %edx,%edx
10d36a: 75 34 jne 10d3a0 <_POSIX_Mutex_Lock_support+0x58>
case OBJECTS_LOCAL:
_CORE_mutex_Seize(
10d36c: 83 ec 0c sub $0xc,%esp 10d36f: ff 75 f0 pushl -0x10(%ebp) 10d372: ff 75 10 pushl 0x10(%ebp) 10d375: 0f b6 db movzbl %bl,%ebx 10d378: 53 push %ebx 10d379: ff 70 08 pushl 0x8(%eax) 10d37c: 83 c0 14 add $0x14,%eax 10d37f: 50 push %eax 10d380: e8 43 1d 00 00 call 10f0c8 <_CORE_mutex_Seize>
the_mutex->Object.id,
blocking,
timeout,
level
);
return _POSIX_Mutex_Translate_core_mutex_return_code(
10d385: 83 c4 14 add $0x14,%esp
(CORE_mutex_Status) _Thread_Executing->Wait.return_code
10d388: a1 98 d2 12 00 mov 0x12d298,%eax
the_mutex->Object.id,
blocking,
timeout,
level
);
return _POSIX_Mutex_Translate_core_mutex_return_code(
10d38d: ff 70 34 pushl 0x34(%eax) 10d390: e8 1b 01 00 00 call 10d4b0 <_POSIX_Mutex_Translate_core_mutex_return_code> 10d395: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10d398: 8b 5d fc mov -0x4(%ebp),%ebx 10d39b: c9 leave 10d39c: c3 ret 10d39d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10d3a0: b8 16 00 00 00 mov $0x16,%eax
}
10d3a5: 8b 5d fc mov -0x4(%ebp),%ebx 10d3a8: c9 leave 10d3a9: c3 ret
00114978 <_POSIX_Semaphore_Create_support>:
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
114978: 55 push %ebp 114979: 89 e5 mov %esp,%ebp 11497b: 56 push %esi 11497c: 53 push %ebx 11497d: 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)
114980: 8b 55 0c mov 0xc(%ebp),%edx 114983: 85 d2 test %edx,%edx
114985: 0f 85 b9 00 00 00 jne 114a44 <_POSIX_Semaphore_Create_support+0xcc>
rtems_set_errno_and_return_minus_one( ENOSYS );
if ( name ) {
11498b: 85 db test %ebx,%ebx
11498d: 74 1c je 1149ab <_POSIX_Semaphore_Create_support+0x33>
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
11498f: 83 ec 08 sub $0x8,%esp 114992: 68 ff 00 00 00 push $0xff 114997: 53 push %ebx 114998: e8 3b 3d 00 00 call 1186d8 <strnlen> 11499d: 83 c4 10 add $0x10,%esp 1149a0: 3d fe 00 00 00 cmp $0xfe,%eax
1149a5: 0f 87 ad 00 00 00 ja 114a58 <_POSIX_Semaphore_Create_support+0xe0>
1149ab: a1 10 db 12 00 mov 0x12db10,%eax 1149b0: 40 inc %eax 1149b1: a3 10 db 12 00 mov %eax,0x12db10
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
_Objects_Allocate( &_POSIX_Semaphore_Information );
1149b6: 83 ec 0c sub $0xc,%esp 1149b9: 68 20 de 12 00 push $0x12de20 1149be: e8 65 b9 ff ff call 110328 <_Objects_Allocate> 1149c3: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
1149c5: 83 c4 10 add $0x10,%esp 1149c8: 85 c0 test %eax,%eax
1149ca: 0f 84 9a 00 00 00 je 114a6a <_POSIX_Semaphore_Create_support+0xf2>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
1149d0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
if ( name ) {
1149d7: 85 db test %ebx,%ebx
1149d9: 74 55 je 114a30 <_POSIX_Semaphore_Create_support+0xb8>
the_semaphore->named = true;
1149db: c6 40 14 01 movb $0x1,0x14(%eax)
the_semaphore->open_count = 1;
1149df: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
the_semaphore->linked = true;
1149e6: 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;
1149ea: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi)
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
1149f1: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi)
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
1149f8: 50 push %eax 1149f9: 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;
1149fc: 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 );
1149ff: 50 push %eax 114a00: 8d 46 1c lea 0x1c(%esi),%eax 114a03: 50 push %eax 114a04: e8 a7 b3 ff ff call 10fdb0 <_CORE_semaphore_Initialize>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
114a09: 0f b7 56 08 movzwl 0x8(%esi),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
114a0d: a1 3c de 12 00 mov 0x12de3c,%eax 114a12: 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;
114a15: 89 5e 0c mov %ebx,0xc(%esi)
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
114a18: 8b 45 14 mov 0x14(%ebp),%eax 114a1b: 89 30 mov %esi,(%eax)
_Thread_Enable_dispatch();
114a1d: e8 b2 c9 ff ff call 1113d4 <_Thread_Enable_dispatch>
return 0;
114a22: 83 c4 10 add $0x10,%esp 114a25: 31 c0 xor %eax,%eax
}
114a27: 8d 65 f8 lea -0x8(%ebp),%esp 114a2a: 5b pop %ebx 114a2b: 5e pop %esi 114a2c: c9 leave 114a2d: c3 ret 114a2e: 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;
114a30: c6 40 14 00 movb $0x0,0x14(%eax)
the_semaphore->open_count = 0;
114a34: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_semaphore->linked = false;
114a3b: c6 40 15 00 movb $0x0,0x15(%eax) 114a3f: eb a9 jmp 1149ea <_POSIX_Semaphore_Create_support+0x72> 114a41: 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 );
114a44: e8 5f 2b 00 00 call 1175a8 <__errno> 114a49: c7 00 58 00 00 00 movl $0x58,(%eax) 114a4f: b8 ff ff ff ff mov $0xffffffff,%eax 114a54: eb d1 jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf> 114a56: 66 90 xchg %ax,%ax
if ( name ) {
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
114a58: e8 4b 2b 00 00 call 1175a8 <__errno> 114a5d: c7 00 5b 00 00 00 movl $0x5b,(%eax) 114a63: b8 ff ff ff ff mov $0xffffffff,%eax 114a68: eb bd jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
114a6a: e8 65 c9 ff ff call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
114a6f: e8 34 2b 00 00 call 1175a8 <__errno> 114a74: c7 00 1c 00 00 00 movl $0x1c,(%eax) 114a7a: b8 ff ff ff ff mov $0xffffffff,%eax 114a7f: eb a6 jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf>
00114ad4 <_POSIX_Semaphore_Name_to_id>:
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
114ad4: 55 push %ebp 114ad5: 89 e5 mov %esp,%ebp 114ad7: 83 ec 18 sub $0x18,%esp 114ada: 8b 45 08 mov 0x8(%ebp),%eax
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
114add: 85 c0 test %eax,%eax
114adf: 74 05 je 114ae6 <_POSIX_Semaphore_Name_to_id+0x12>
return EINVAL;
if ( !name[0] )
114ae1: 80 38 00 cmpb $0x0,(%eax)
114ae4: 75 0a jne 114af0 <_POSIX_Semaphore_Name_to_id+0x1c>
return EINVAL;
114ae6: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
114aeb: c9 leave 114aec: c3 ret 114aed: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
status = _Objects_Name_to_id_string(
114af0: 52 push %edx 114af1: 8d 55 f4 lea -0xc(%ebp),%edx 114af4: 52 push %edx 114af5: 50 push %eax 114af6: 68 20 de 12 00 push $0x12de20 114afb: e8 7c 0c 00 00 call 11577c <_Objects_Name_to_id_string>
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
114b00: 8b 4d f4 mov -0xc(%ebp),%ecx 114b03: 8b 55 0c mov 0xc(%ebp),%edx 114b06: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
114b08: 83 c4 10 add $0x10,%esp
return 0;
114b0b: 83 f8 01 cmp $0x1,%eax 114b0e: 19 c0 sbb %eax,%eax 114b10: f7 d0 not %eax 114b12: 83 e0 02 and $0x2,%eax
return ENOENT;
}
114b15: c9 leave 114b16: c3 ret
00114b40 <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
114b40: 55 push %ebp 114b41: 89 e5 mov %esp,%ebp 114b43: 53 push %ebx 114b44: 83 ec 18 sub $0x18,%esp 114b47: 8a 5d 0c mov 0xc(%ebp),%bl
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
114b4a: 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 );
114b4d: 50 push %eax 114b4e: 8b 45 08 mov 0x8(%ebp),%eax 114b51: ff 30 pushl (%eax) 114b53: 68 20 de 12 00 push $0x12de20 114b58: e8 7f bc ff ff call 1107dc <_Objects_Get>
switch ( location ) {
114b5d: 83 c4 10 add $0x10,%esp 114b60: 8b 55 f4 mov -0xc(%ebp),%edx 114b63: 85 d2 test %edx,%edx
114b65: 74 15 je 114b7c <_POSIX_Semaphore_Wait_support+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
114b67: e8 3c 2a 00 00 call 1175a8 <__errno> 114b6c: c7 00 16 00 00 00 movl $0x16,(%eax) 114b72: b8 ff ff ff ff mov $0xffffffff,%eax
}
114b77: 8b 5d fc mov -0x4(%ebp),%ebx 114b7a: c9 leave 114b7b: c3 ret
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
114b7c: ff 75 10 pushl 0x10(%ebp) 114b7f: 0f b6 db movzbl %bl,%ebx 114b82: 53 push %ebx 114b83: ff 70 08 pushl 0x8(%eax) 114b86: 83 c0 1c add $0x1c,%eax 114b89: 50 push %eax 114b8a: e8 29 07 00 00 call 1152b8 <_CORE_semaphore_Seize>
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
114b8f: e8 40 c8 ff ff call 1113d4 <_Thread_Enable_dispatch>
if ( !_Thread_Executing->Wait.return_code )
114b94: 83 c4 10 add $0x10,%esp 114b97: a1 b8 e0 12 00 mov 0x12e0b8,%eax 114b9c: 8b 40 34 mov 0x34(%eax),%eax 114b9f: 85 c0 test %eax,%eax
114ba1: 75 09 jne 114bac <_POSIX_Semaphore_Wait_support+0x6c>
return 0;
114ba3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
114ba5: 8b 5d fc mov -0x4(%ebp),%ebx 114ba8: c9 leave 114ba9: c3 ret 114baa: 66 90 xchg %ax,%ax
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
return 0;
rtems_set_errno_and_return_minus_one(
114bac: e8 f7 29 00 00 call 1175a8 <__errno> 114bb1: 89 c3 mov %eax,%ebx 114bb3: 83 ec 0c sub $0xc,%esp 114bb6: a1 b8 e0 12 00 mov 0x12e0b8,%eax 114bbb: ff 70 34 pushl 0x34(%eax) 114bbe: e8 55 25 00 00 call 117118 <_POSIX_Semaphore_Translate_core_semaphore_return_code> 114bc3: 89 03 mov %eax,(%ebx) 114bc5: 83 c4 10 add $0x10,%esp 114bc8: b8 ff ff ff ff mov $0xffffffff,%eax 114bcd: eb a8 jmp 114b77 <_POSIX_Semaphore_Wait_support+0x37>
001106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
1106fc: 55 push %ebp 1106fd: 89 e5 mov %esp,%ebp 1106ff: 83 ec 08 sub $0x8,%esp 110702: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
110705: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
11070b: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx 110711: 85 c9 test %ecx,%ecx
110713: 75 09 jne 11071e <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN
110715: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
11071c: 74 06 je 110724 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28>
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
}
11071e: 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();
11071f: e9 d4 d6 ff ff jmp 10ddf8 <_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 &&
110724: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 11072a: 85 c0 test %eax,%eax
11072c: 74 f0 je 11071e <_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;
11072e: a1 b0 90 12 00 mov 0x1290b0,%eax 110733: 48 dec %eax 110734: a3 b0 90 12 00 mov %eax,0x1290b0
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
110739: 83 ec 08 sub $0x8,%esp 11073c: 6a ff push $0xffffffff 11073e: 52 push %edx 11073f: e8 c0 08 00 00 call 111004 <_POSIX_Thread_Exit> 110744: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
110747: c9 leave 110748: c3 ret
00111a6c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
111a6c: 55 push %ebp 111a6d: 89 e5 mov %esp,%ebp 111a6f: 57 push %edi 111a70: 56 push %esi 111a71: 53 push %ebx 111a72: 83 ec 18 sub $0x18,%esp 111a75: 8b 5d 08 mov 0x8(%ebp),%ebx 111a78: 8b 75 0c mov 0xc(%ebp),%esi 111a7b: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
111a7e: ff 36 pushl (%esi) 111a80: e8 cb ff ff ff call 111a50 <_POSIX_Priority_Is_valid> 111a85: 83 c4 10 add $0x10,%esp 111a88: 84 c0 test %al,%al
111a8a: 74 2a je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
111a8c: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
111a92: 8b 45 14 mov 0x14(%ebp),%eax 111a95: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
111a9b: 85 db test %ebx,%ebx
111a9d: 74 25 je 111ac4 <_POSIX_Thread_Translate_sched_param+0x58>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
111a9f: 83 fb 01 cmp $0x1,%ebx
111aa2: 0f 84 90 00 00 00 je 111b38 <_POSIX_Thread_Translate_sched_param+0xcc>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
111aa8: 83 fb 02 cmp $0x2,%ebx
111aab: 0f 84 8f 00 00 00 je 111b40 <_POSIX_Thread_Translate_sched_param+0xd4>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
111ab1: 83 fb 04 cmp $0x4,%ebx
111ab4: 74 1e je 111ad4 <_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;
111ab6: b8 16 00 00 00 mov $0x16,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
111abb: 8d 65 f4 lea -0xc(%ebp),%esp 111abe: 5b pop %ebx 111abf: 5e pop %esi 111ac0: 5f pop %edi 111ac1: c9 leave 111ac2: c3 ret 111ac3: 90 nop
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
111ac4: c7 07 01 00 00 00 movl $0x1,(%edi)
return 0;
111aca: 31 c0 xor %eax,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
111acc: 8d 65 f4 lea -0xc(%ebp),%esp 111acf: 5b pop %ebx 111ad0: 5e pop %esi 111ad1: 5f pop %edi 111ad2: c9 leave 111ad3: 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) &&
111ad4: 8b 5e 08 mov 0x8(%esi),%ebx 111ad7: 85 db test %ebx,%ebx
111ad9: 75 07 jne 111ae2 <_POSIX_Thread_Translate_sched_param+0x76>
111adb: 8b 4e 0c mov 0xc(%esi),%ecx 111ade: 85 c9 test %ecx,%ecx
111ae0: 74 d4 je 111ab6 <_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) &&
111ae2: 8b 56 10 mov 0x10(%esi),%edx 111ae5: 85 d2 test %edx,%edx
111ae7: 75 07 jne 111af0 <_POSIX_Thread_Translate_sched_param+0x84>
111ae9: 8b 46 14 mov 0x14(%esi),%eax 111aec: 85 c0 test %eax,%eax
111aee: 74 c6 je 111ab6 <_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 ) <
111af0: 83 ec 0c sub $0xc,%esp 111af3: 8d 46 08 lea 0x8(%esi),%eax 111af6: 50 push %eax 111af7: e8 00 da ff ff call 10f4fc <_Timespec_To_ticks> 111afc: 89 c3 mov %eax,%ebx
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
111afe: 8d 46 10 lea 0x10(%esi),%eax 111b01: 89 04 24 mov %eax,(%esp) 111b04: e8 f3 d9 ff ff call 10f4fc <_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 ) <
111b09: 83 c4 10 add $0x10,%esp 111b0c: 39 c3 cmp %eax,%ebx
111b0e: 72 a6 jb 111ab6 <_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 ) )
111b10: 83 ec 0c sub $0xc,%esp 111b13: ff 76 04 pushl 0x4(%esi) 111b16: e8 35 ff ff ff call 111a50 <_POSIX_Priority_Is_valid> 111b1b: 83 c4 10 add $0x10,%esp 111b1e: 84 c0 test %al,%al
111b20: 74 94 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
111b22: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
111b28: 8b 45 14 mov 0x14(%ebp),%eax 111b2b: c7 00 14 bd 10 00 movl $0x10bd14,(%eax)
return 0;
111b31: 31 c0 xor %eax,%eax 111b33: eb 86 jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f> 111b35: 8d 76 00 lea 0x0(%esi),%esi
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
111b38: 31 c0 xor %eax,%eax 111b3a: e9 7c ff ff ff jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f> 111b3f: 90 nop
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
111b40: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
111b46: 31 c0 xor %eax,%eax 111b48: e9 6e ff ff ff jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f>
00110918 <_POSIX_Threads_Create_extension>:
bool _POSIX_Threads_Create_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *created
)
{
110918: 55 push %ebp 110919: 89 e5 mov %esp,%ebp 11091b: 57 push %edi 11091c: 56 push %esi 11091d: 53 push %ebx 11091e: 83 ec 28 sub $0x28,%esp 110921: 8b 55 0c mov 0xc(%ebp),%edx
POSIX_API_Control *api;
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
110924: 68 f0 00 00 00 push $0xf0 110929: 89 55 e4 mov %edx,-0x1c(%ebp) 11092c: e8 57 e0 ff ff call 10e988 <_Workspace_Allocate> 110931: 89 c3 mov %eax,%ebx
if ( !api )
110933: 83 c4 10 add $0x10,%esp 110936: 85 c0 test %eax,%eax 110938: 8b 55 e4 mov -0x1c(%ebp),%edx
11093b: 0f 84 2f 01 00 00 je 110a70 <_POSIX_Threads_Create_extension+0x158><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_POSIX ] = api;
110941: 89 82 ec 00 00 00 mov %eax,0xec(%edx)
/* XXX check all fields are touched */
api->Attributes = _POSIX_Threads_Default_attributes;
110947: b9 40 00 00 00 mov $0x40,%ecx 11094c: 31 c0 xor %eax,%eax 11094e: 89 df mov %ebx,%edi 110950: f3 aa rep stos %al,%es:(%edi) 110952: c7 03 01 00 00 00 movl $0x1,(%ebx) 110958: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) 11095f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx) 110966: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx) 11096d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) 110974: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx)
api->detachstate = _POSIX_Threads_Default_attributes.detachstate;
11097b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx)
api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;
110982: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx)
110989: 00 00 00 api->schedparam = _POSIX_Threads_Default_attributes.schedparam;
11098c: be 78 1b 12 00 mov $0x121b78,%esi 110991: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 110997: b1 07 mov $0x7,%cl 110999: 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);
11099b: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax 1109a2: 2b 42 14 sub 0x14(%edx),%eax 1109a5: 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;
1109ab: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
1109b2: 00 00 00 api->cancelability_state = PTHREAD_CANCEL_ENABLE;
1109b5: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx)
1109bc: 00 00 00 api->cancelability_type = PTHREAD_CANCEL_DEFERRED;
1109bf: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
1109c6: 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 );
1109c9: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax 1109cf: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
head->next = tail;
head->previous = NULL;
1109d5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
1109dc: 00 00 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
1109df: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax 1109e5: 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;
1109eb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx)
1109f2: 00 00 00
1109f5: 0f b6 42 0b movzbl 0xb(%edx),%eax 1109f9: 83 e0 07 and $0x7,%eax
if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API
1109fc: 83 f8 03 cmp $0x3,%eax
1109ff: 74 53 je 110a54 <_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;
110a01: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx)
110a08: ff ff ff
}
_Thread_queue_Initialize(
110a0b: 6a 00 push $0x0 110a0d: 68 00 10 00 00 push $0x1000 110a12: 6a 00 push $0x0 110a14: 8d 43 44 lea 0x44(%ebx),%eax 110a17: 50 push %eax 110a18: 89 55 e4 mov %edx,-0x1c(%ebp) 110a1b: e8 9c d6 ff ff call 10e0bc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_JOIN_AT_EXIT,
0
);
_Watchdog_Initialize(
110a20: 8b 55 e4 mov -0x1c(%ebp),%edx 110a23: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
110a26: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx)
110a2d: 00 00 00 the_watchdog->routine = routine;
110a30: c7 83 c4 00 00 00 7c movl $0x110a7c,0xc4(%ebx)
110a37: 0a 11 00 the_watchdog->id = id;
110a3a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx)
the_watchdog->user_data = user_data;
110a40: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx)
_POSIX_Threads_Sporadic_budget_TSR,
created->Object.id,
created
);
return true;
110a46: 83 c4 10 add $0x10,%esp 110a49: b0 01 mov $0x1,%al
}
110a4b: 8d 65 f4 lea -0xc(%ebp),%esp 110a4e: 5b pop %ebx 110a4f: 5e pop %esi 110a50: 5f pop %edi 110a51: c9 leave 110a52: c3 ret 110a53: 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 ];
110a54: a1 38 83 12 00 mov 0x128338,%eax
api->signals_blocked = executing_api->signals_blocked;
110a59: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 110a5f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 110a65: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx) 110a6b: eb 9e jmp 110a0b <_POSIX_Threads_Create_extension+0xf3> 110a6d: 8d 76 00 lea 0x0(%esi),%esi
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
if ( !api )
return false;
110a70: 31 c0 xor %eax,%eax
created->Object.id,
created
);
return true;
}
110a72: 8d 65 f4 lea -0xc(%ebp),%esp 110a75: 5b pop %ebx 110a76: 5e pop %esi 110a77: 5f pop %edi 110a78: c9 leave 110a79: c3 ret
00110890 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
110890: 55 push %ebp 110891: 89 e5 mov %esp,%ebp 110893: 57 push %edi 110894: 56 push %esi 110895: 53 push %ebx 110896: 83 ec 28 sub $0x28,%esp 110899: 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 ];
11089c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax 1108a2: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
1108a5: 57 push %edi 1108a6: e8 fd 21 00 00 call 112aa8 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
1108ab: 89 3c 24 mov %edi,(%esp) 1108ae: e8 5d 22 00 00 call 112b10 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
1108b3: 8b 77 28 mov 0x28(%edi),%esi
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
1108b6: 83 c4 10 add $0x10,%esp 1108b9: 8b 45 e4 mov -0x1c(%ebp),%eax 1108bc: 8d 58 44 lea 0x44(%eax),%ebx 1108bf: eb 08 jmp 1108c9 <_POSIX_Threads_Delete_extension+0x39> 1108c1: 8d 76 00 lea 0x0(%esi),%esi
*(void **)the_thread->Wait.return_argument = value_ptr;
1108c4: 8b 40 28 mov 0x28(%eax),%eax 1108c7: 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 )) )
1108c9: 83 ec 0c sub $0xc,%esp 1108cc: 53 push %ebx 1108cd: e8 5a d4 ff ff call 10dd2c <_Thread_queue_Dequeue> 1108d2: 83 c4 10 add $0x10,%esp 1108d5: 85 c0 test %eax,%eax
1108d7: 75 eb jne 1108c4 <_POSIX_Threads_Delete_extension+0x34>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
1108d9: 8b 45 e4 mov -0x1c(%ebp),%eax 1108dc: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
1108e3: 74 1f je 110904 <_POSIX_Threads_Delete_extension+0x74>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
1108e5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi)
1108ec: 00 00 00
_Workspace_Free( api );
1108ef: 8b 45 e4 mov -0x1c(%ebp),%eax 1108f2: 89 45 08 mov %eax,0x8(%ebp)
}
1108f5: 8d 65 f4 lea -0xc(%ebp),%esp 1108f8: 5b pop %ebx 1108f9: 5e pop %esi 1108fa: 5f pop %edi 1108fb: c9 leave
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
1108fc: e9 a3 e0 ff ff jmp 10e9a4 <_Workspace_Free> 110901: 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 );
110904: 83 ec 0c sub $0xc,%esp 110907: 05 a8 00 00 00 add $0xa8,%eax 11090c: 50 push %eax 11090d: e8 4e df ff ff call 10e860 <_Watchdog_Remove> 110912: 83 c4 10 add $0x10,%esp 110915: eb ce jmp 1108e5 <_POSIX_Threads_Delete_extension+0x55>
00110854 <_POSIX_Threads_Initialize_user_threads>:
*
* This routine creates and starts all configured user
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
110854: 55 push %ebp 110855: 89 e5 mov %esp,%ebp 110857: 83 ec 08 sub $0x8,%esp
if ( _POSIX_Threads_Initialize_user_threads_p )
11085a: a1 38 60 12 00 mov 0x126038,%eax 11085f: 85 c0 test %eax,%eax
110861: 74 05 je 110868 <_POSIX_Threads_Initialize_user_threads+0x14>
(*_POSIX_Threads_Initialize_user_threads_p)();
}
110863: c9 leave
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
if ( _POSIX_Threads_Initialize_user_threads_p )
(*_POSIX_Threads_Initialize_user_threads_p)();
110864: ff e0 jmp *%eax 110866: 66 90 xchg %ax,%ax
}
110868: c9 leave 110869: c3 ret
0010b9f4 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10b9f4: 55 push %ebp 10b9f5: 89 e5 mov %esp,%ebp 10b9f7: 57 push %edi 10b9f8: 56 push %esi 10b9f9: 53 push %ebx 10b9fa: 83 ec 6c sub $0x6c,%esp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
10b9fd: 8b 3d 94 4d 12 00 mov 0x124d94,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10ba03: a1 90 4d 12 00 mov 0x124d90,%eax 10ba08: 89 45 94 mov %eax,-0x6c(%ebp)
if ( !user_threads || maximum == 0 )
10ba0b: 85 ff test %edi,%edi
10ba0d: 74 44 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN
10ba0f: 85 c0 test %eax,%eax
10ba11: 74 40 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN
10ba13: 31 db xor %ebx,%ebx 10ba15: 8d 75 a4 lea -0x5c(%ebp),%esi
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
10ba18: 83 ec 0c sub $0xc,%esp 10ba1b: 56 push %esi 10ba1c: e8 2f 61 00 00 call 111b50 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10ba21: 5a pop %edx 10ba22: 59 pop %ecx 10ba23: 6a 02 push $0x2 10ba25: 56 push %esi 10ba26: e8 51 61 00 00 call 111b7c <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10ba2b: 59 pop %ecx 10ba2c: 58 pop %eax 10ba2d: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10ba31: 56 push %esi 10ba32: e8 79 61 00 00 call 111bb0 <pthread_attr_setstacksize>
status = pthread_create(
10ba37: 6a 00 push $0x0 10ba39: ff 34 df pushl (%edi,%ebx,8) 10ba3c: 56 push %esi 10ba3d: 8d 45 e4 lea -0x1c(%ebp),%eax 10ba40: 50 push %eax 10ba41: e8 92 fc ff ff call 10b6d8 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10ba46: 83 c4 20 add $0x20,%esp 10ba49: 85 c0 test %eax,%eax
10ba4b: 75 0e jne 10ba5b <_POSIX_Threads_Initialize_user_threads_body+0x67>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
10ba4d: 43 inc %ebx 10ba4e: 39 5d 94 cmp %ebx,-0x6c(%ebp)
10ba51: 77 c5 ja 10ba18 <_POSIX_Threads_Initialize_user_threads_body+0x24><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10ba53: 8d 65 f4 lea -0xc(%ebp),%esp 10ba56: 5b pop %ebx 10ba57: 5e pop %esi 10ba58: 5f pop %edi 10ba59: c9 leave 10ba5a: c3 ret
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10ba5b: 52 push %edx 10ba5c: 50 push %eax 10ba5d: 6a 01 push $0x1 10ba5f: 6a 02 push $0x2 10ba61: e8 c2 1e 00 00 call 10d928 <_Internal_error_Occurred>
00110a7c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
110a7c: 55 push %ebp 110a7d: 89 e5 mov %esp,%ebp 110a7f: 56 push %esi 110a80: 53 push %ebx 110a81: 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 ];
110a84: 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 );
110a8a: 83 ec 0c sub $0xc,%esp 110a8d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax 110a93: 50 push %eax 110a94: e8 7f 0e 00 00 call 111918 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
110a99: 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);
110a9c: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax 110aa3: 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;
110aa9: 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 ) {
110aac: 83 c4 10 add $0x10,%esp 110aaf: 8b 4e 1c mov 0x1c(%esi),%ecx 110ab2: 85 c9 test %ecx,%ecx
110ab4: 75 05 jne 110abb <_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 ) {
110ab6: 39 46 14 cmp %eax,0x14(%esi)
110ab9: 77 35 ja 110af0 <_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 );
110abb: 83 ec 0c sub $0xc,%esp 110abe: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax 110ac4: 50 push %eax 110ac5: e8 4e 0e 00 00 call 111918 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
110aca: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
110ad0: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
110ad3: 81 c3 a8 00 00 00 add $0xa8,%ebx 110ad9: 89 5d 0c mov %ebx,0xc(%ebp) 110adc: c7 45 08 60 7e 12 00 movl $0x127e60,0x8(%ebp)
}
110ae3: 8d 65 f8 lea -0x8(%ebp),%esp 110ae6: 5b pop %ebx 110ae7: 5e pop %esi 110ae8: c9 leave 110ae9: e9 32 dc ff ff jmp 10e720 <_Watchdog_Insert> 110aee: 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 );
110af0: 52 push %edx 110af1: 6a 01 push $0x1 110af3: 50 push %eax 110af4: 56 push %esi 110af5: e8 7e ca ff ff call 10d578 <_Thread_Change_priority> 110afa: 83 c4 10 add $0x10,%esp 110afd: eb bc jmp 110abb <_POSIX_Threads_Sporadic_budget_TSR+0x3f>
00110b00 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
110b00: 55 push %ebp 110b01: 89 e5 mov %esp,%ebp 110b03: 83 ec 08 sub $0x8,%esp 110b06: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
110b09: 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 */
110b0f: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 110b16: 0f b6 15 74 3a 12 00 movzbl 0x123a74,%edx 110b1d: 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;
110b23: 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 ) {
110b26: 8b 48 1c mov 0x1c(%eax),%ecx 110b29: 85 c9 test %ecx,%ecx
110b2b: 75 05 jne 110b32 <_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 ) {
110b2d: 39 50 14 cmp %edx,0x14(%eax)
110b30: 72 02 jb 110b34 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110b32: c9 leave <== NOT EXECUTED 110b33: 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 );
110b34: 51 push %ecx 110b35: 6a 01 push $0x1 110b37: 52 push %edx 110b38: 50 push %eax 110b39: e8 3a ca ff ff call 10d578 <_Thread_Change_priority> 110b3e: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110b41: c9 leave 110b42: c3 ret
00112aa8 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
112aa8: 55 push %ebp 112aa9: 89 e5 mov %esp,%ebp 112aab: 57 push %edi 112aac: 56 push %esi 112aad: 53 push %ebx 112aae: 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 ];
112ab1: 8b 45 08 mov 0x8(%ebp),%eax 112ab4: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
112aba: c7 86 d8 00 00 00 01 movl $0x1,0xd8(%esi)
112ac1: 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 );
112ac4: 8d be e8 00 00 00 lea 0xe8(%esi),%edi
while ( !_Chain_Is_empty( handler_stack ) ) {
112aca: 39 be e4 00 00 00 cmp %edi,0xe4(%esi)
112ad0: 74 33 je 112b05 <_POSIX_Threads_cancel_run+0x5d>
112ad2: 66 90 xchg %ax,%ax
_ISR_Disable( level );
112ad4: 9c pushf 112ad5: fa cli 112ad6: 59 pop %ecx
handler = (POSIX_Cancel_Handler_control *)
112ad7: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
112add: 8b 13 mov (%ebx),%edx
previous = the_node->previous;
112adf: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
112ae2: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
112ae5: 89 10 mov %edx,(%eax)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
112ae7: 51 push %ecx 112ae8: 9d popf
(*handler->routine)( handler->arg );
112ae9: 83 ec 0c sub $0xc,%esp 112aec: ff 73 0c pushl 0xc(%ebx) 112aef: ff 53 08 call *0x8(%ebx)
_Workspace_Free( handler );
112af2: 89 1c 24 mov %ebx,(%esp) 112af5: e8 aa be ff ff call 10e9a4 <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
112afa: 83 c4 10 add $0x10,%esp 112afd: 39 be e4 00 00 00 cmp %edi,0xe4(%esi)
112b03: 75 cf jne 112ad4 <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
112b05: 8d 65 f4 lea -0xc(%ebp),%esp 112b08: 5b pop %ebx 112b09: 5e pop %esi 112b0a: 5f pop %edi 112b0b: c9 leave 112b0c: c3 ret
0011185c <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
11185c: 55 push %ebp 11185d: 89 e5 mov %esp,%ebp 11185f: 56 push %esi 111860: 53 push %ebx 111861: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
(void) _Watchdog_Remove( timer );
111864: 83 ec 0c sub $0xc,%esp 111867: 53 push %ebx 111868: e8 03 db ff ff call 10f370 <_Watchdog_Remove>
_ISR_Disable( level );
11186d: 9c pushf 11186e: fa cli 11186f: 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 ) {
111870: 83 c4 10 add $0x10,%esp 111873: 8b 43 08 mov 0x8(%ebx),%eax 111876: 85 c0 test %eax,%eax
111878: 74 0e je 111888 <_POSIX_Timer_Insert_helper+0x2c>
_ISR_Enable( level );
11187a: 56 push %esi 11187b: 9d popf
return false;
11187c: 31 c0 xor %eax,%eax
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
return true;
}
11187e: 8d 65 f8 lea -0x8(%ebp),%esp 111881: 5b pop %ebx 111882: 5e pop %esi 111883: c9 leave 111884: c3 ret 111885: 8d 76 00 lea 0x0(%esi),%esi
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
111888: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
the_watchdog->routine = routine;
11188f: 8b 45 14 mov 0x14(%ebp),%eax 111892: 89 43 1c mov %eax,0x1c(%ebx)
the_watchdog->id = id;
111895: 8b 45 10 mov 0x10(%ebp),%eax 111898: 89 43 20 mov %eax,0x20(%ebx)
the_watchdog->user_data = user_data;
11189b: 8b 45 18 mov 0x18(%ebp),%eax 11189e: 89 43 24 mov %eax,0x24(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
1118a1: 8b 45 0c mov 0xc(%ebp),%eax 1118a4: 89 43 0c mov %eax,0xc(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
1118a7: 83 ec 08 sub $0x8,%esp 1118aa: 53 push %ebx 1118ab: 68 a0 a1 12 00 push $0x12a1a0 1118b0: e8 7b d9 ff ff call 10f230 <_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 );
1118b5: 56 push %esi 1118b6: 9d popf
return true;
1118b7: 83 c4 10 add $0x10,%esp 1118ba: b0 01 mov $0x1,%al
}
1118bc: 8d 65 f8 lea -0x8(%ebp),%esp 1118bf: 5b pop %ebx 1118c0: 5e pop %esi 1118c1: c9 leave 1118c2: c3 ret
0010b804 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
10b804: 55 push %ebp 10b805: 89 e5 mov %esp,%ebp 10b807: 53 push %ebx 10b808: 83 ec 04 sub $0x4,%esp 10b80b: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10b80e: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10b811: 8b 53 54 mov 0x54(%ebx),%edx 10b814: 85 d2 test %edx,%edx
10b816: 75 28 jne 10b840 <_POSIX_Timer_TSR+0x3c>
10b818: 8b 43 58 mov 0x58(%ebx),%eax 10b81b: 85 c0 test %eax,%eax
10b81d: 75 21 jne 10b840 <_POSIX_Timer_TSR+0x3c> <== ALWAYS TAKEN
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10b81f: c6 43 3c 04 movb $0x4,0x3c(%ebx)
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
10b823: 83 ec 08 sub $0x8,%esp 10b826: ff 73 44 pushl 0x44(%ebx) 10b829: ff 73 38 pushl 0x38(%ebx) 10b82c: e8 bb 5b 00 00 call 1113ec <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10b831: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10b838: 83 c4 10 add $0x10,%esp
}
10b83b: 8b 5d fc mov -0x4(%ebp),%ebx 10b83e: c9 leave 10b83f: c3 ret
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10b840: 83 ec 0c sub $0xc,%esp 10b843: 53 push %ebx 10b844: 68 04 b8 10 00 push $0x10b804 10b849: ff 73 08 pushl 0x8(%ebx) 10b84c: ff 73 64 pushl 0x64(%ebx) 10b84f: 8d 43 10 lea 0x10(%ebx),%eax 10b852: 50 push %eax 10b853: e8 04 60 00 00 call 11185c <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10b858: 83 c4 20 add $0x20,%esp 10b85b: 84 c0 test %al,%al
10b85d: 74 dc je 10b83b <_POSIX_Timer_TSR+0x37> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10b85f: 83 ec 0c sub $0xc,%esp 10b862: 8d 43 6c lea 0x6c(%ebx),%eax 10b865: 50 push %eax 10b866: e8 91 16 00 00 call 10cefc <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10b86b: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10b86f: 83 c4 10 add $0x10,%esp 10b872: eb af jmp 10b823 <_POSIX_Timer_TSR+0x1f>
00112b94 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
112b94: 55 push %ebp 112b95: 89 e5 mov %esp,%ebp 112b97: 57 push %edi 112b98: 56 push %esi 112b99: 53 push %ebx 112b9a: 83 ec 78 sub $0x78,%esp 112b9d: 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,
112ba0: 6a 01 push $0x1 112ba2: 0f b6 45 10 movzbl 0x10(%ebp),%eax 112ba6: 50 push %eax 112ba7: 8d 55 dc lea -0x24(%ebp),%edx 112baa: 52 push %edx 112bab: 53 push %ebx 112bac: ff 75 08 pushl 0x8(%ebp) 112baf: 89 55 9c mov %edx,-0x64(%ebp) 112bb2: e8 b5 00 00 00 call 112c6c <_POSIX_signals_Clear_signals> 112bb7: 83 c4 20 add $0x20,%esp 112bba: 84 c0 test %al,%al 112bbc: 8b 55 9c mov -0x64(%ebp),%edx
112bbf: 0f 84 9b 00 00 00 je 112c60 <_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 )
112bc5: 8d 04 5b lea (%ebx,%ebx,2),%eax 112bc8: c1 e0 02 shl $0x2,%eax 112bcb: 8b 88 a8 83 12 00 mov 0x1283a8(%eax),%ecx 112bd1: 89 4d a4 mov %ecx,-0x5c(%ebp) 112bd4: 49 dec %ecx
112bd5: 0f 84 85 00 00 00 je 112c60 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
112bdb: 8b 75 08 mov 0x8(%ebp),%esi 112bde: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi 112be4: 89 75 a0 mov %esi,-0x60(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
112be7: 8b 88 a4 83 12 00 mov 0x1283a4(%eax),%ecx 112bed: 09 f1 or %esi,%ecx 112bef: 8b 75 08 mov 0x8(%ebp),%esi 112bf2: 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,
112bf8: 8d 75 b4 lea -0x4c(%ebp),%esi 112bfb: 89 75 94 mov %esi,-0x6c(%ebp) 112bfe: 8b 35 38 83 12 00 mov 0x128338,%esi 112c04: 83 c6 20 add $0x20,%esi 112c07: b9 0a 00 00 00 mov $0xa,%ecx 112c0c: 8b 7d 94 mov -0x6c(%ebp),%edi 112c0f: 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 ) {
112c11: 83 b8 a0 83 12 00 02 cmpl $0x2,0x1283a0(%eax)
112c18: 74 36 je 112c50 <_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 );
112c1a: 83 ec 0c sub $0xc,%esp 112c1d: 53 push %ebx 112c1e: ff 55 a4 call *-0x5c(%ebp)
break;
112c21: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
112c24: 8b 3d 38 83 12 00 mov 0x128338,%edi 112c2a: 83 c7 20 add $0x20,%edi 112c2d: b9 0a 00 00 00 mov $0xa,%ecx 112c32: 8b 75 94 mov -0x6c(%ebp),%esi 112c35: 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;
112c37: 8b 55 a0 mov -0x60(%ebp),%edx 112c3a: 8b 45 08 mov 0x8(%ebp),%eax 112c3d: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
return true;
112c43: b0 01 mov $0x1,%al
}
112c45: 8d 65 f4 lea -0xc(%ebp),%esp 112c48: 5b pop %ebx 112c49: 5e pop %esi 112c4a: 5f pop %edi 112c4b: c9 leave 112c4c: c3 ret 112c4d: 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)(
112c50: 50 push %eax 112c51: 6a 00 push $0x0 112c53: 52 push %edx 112c54: 53 push %ebx 112c55: ff 55 a4 call *-0x5c(%ebp)
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
112c58: 83 c4 10 add $0x10,%esp 112c5b: eb c7 jmp 112c24 <_POSIX_signals_Check_signal+0x90> 112c5d: 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;
112c60: 31 c0 xor %eax,%eax
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
112c62: 8d 65 f4 lea -0xc(%ebp),%esp 112c65: 5b pop %ebx 112c66: 5e pop %esi 112c67: 5f pop %edi 112c68: c9 leave 112c69: c3 ret
0011321c <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
11321c: 55 push %ebp 11321d: 89 e5 mov %esp,%ebp 11321f: 53 push %ebx 113220: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
113223: 9c pushf 113224: fa cli 113225: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
113226: 8d 04 49 lea (%ecx,%ecx,2),%eax 113229: c1 e0 02 shl $0x2,%eax 11322c: 83 b8 a0 83 12 00 02 cmpl $0x2,0x1283a0(%eax)
113233: 74 13 je 113248 <_POSIX_signals_Clear_process_signals+0x2c>
113235: 49 dec %ecx 113236: 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;
11323b: d3 c0 rol %cl,%eax 11323d: 21 05 a8 85 12 00 and %eax,0x1285a8
}
_ISR_Enable( level );
113243: 52 push %edx 113244: 9d popf
}
113245: 5b pop %ebx 113246: c9 leave 113247: 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 );
113248: 8d 98 c4 85 12 00 lea 0x1285c4(%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 ] ) )
11324e: 39 98 c0 85 12 00 cmp %ebx,0x1285c0(%eax)
113254: 75 ed jne 113243 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN
113256: eb dd jmp 113235 <_POSIX_signals_Clear_process_signals+0x19>
00112c6c <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
112c6c: 55 push %ebp 112c6d: 89 e5 mov %esp,%ebp 112c6f: 57 push %edi 112c70: 56 push %esi 112c71: 53 push %ebx 112c72: 83 ec 1c sub $0x1c,%esp 112c75: 8b 5d 0c mov 0xc(%ebp),%ebx 112c78: 0f b6 7d 14 movzbl 0x14(%ebp),%edi
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
112c7c: 8d 4b ff lea -0x1(%ebx),%ecx 112c7f: b8 01 00 00 00 mov $0x1,%eax 112c84: 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 )
112c86: 80 7d 18 00 cmpb $0x0,0x18(%ebp)
112c8a: 74 40 je 112ccc <_POSIX_signals_Clear_signals+0x60>
signals_blocked = ~api->signals_blocked;
112c8c: 8b 55 08 mov 0x8(%ebp),%edx 112c8f: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx 112c95: 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 );
112c97: 9c pushf 112c98: fa cli 112c99: 8f 45 e4 popl -0x1c(%ebp)
if ( is_global ) {
112c9c: 89 fa mov %edi,%edx 112c9e: 84 d2 test %dl,%dl
112ca0: 74 32 je 112cd4 <_POSIX_signals_Clear_signals+0x68>
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
112ca2: 23 05 a8 85 12 00 and 0x1285a8,%eax 112ca8: 85 c8 test %ecx,%eax
112caa: 74 54 je 112d00 <_POSIX_signals_Clear_signals+0x94>
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
112cac: 8d 14 5b lea (%ebx,%ebx,2),%edx 112caf: c1 e2 02 shl $0x2,%edx 112cb2: 83 ba a0 83 12 00 02 cmpl $0x2,0x1283a0(%edx)
112cb9: 74 49 je 112d04 <_POSIX_signals_Clear_signals+0x98>
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
112cbb: 83 ec 0c sub $0xc,%esp 112cbe: 53 push %ebx 112cbf: e8 58 05 00 00 call 11321c <_POSIX_signals_Clear_process_signals> 112cc4: 83 c4 10 add $0x10,%esp
do_callout = true;
112cc7: b0 01 mov $0x1,%al 112cc9: eb 26 jmp 112cf1 <_POSIX_signals_Clear_signals+0x85> 112ccb: 90 nop
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
else
signals_blocked = SIGNAL_ALL_MASK;
112ccc: b9 ff ff ff ff mov $0xffffffff,%ecx 112cd1: eb c4 jmp 112c97 <_POSIX_signals_Clear_signals+0x2b> 112cd3: 90 nop
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
112cd4: 8b 55 08 mov 0x8(%ebp),%edx 112cd7: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx 112cdd: 89 c6 mov %eax,%esi 112cdf: 21 de and %ebx,%esi 112ce1: 85 ce test %ecx,%esi
112ce3: 74 1b je 112d00 <_POSIX_signals_Clear_signals+0x94>
api->signals_pending &= ~mask;
112ce5: f7 d0 not %eax 112ce7: 21 d8 and %ebx,%eax 112ce9: 89 82 d4 00 00 00 mov %eax,0xd4(%edx)
do_callout = true;
112cef: b0 01 mov $0x1,%al
}
}
_ISR_Enable( level );
112cf1: ff 75 e4 pushl -0x1c(%ebp) 112cf4: 9d popf
return do_callout; }
112cf5: 8d 65 f4 lea -0xc(%ebp),%esp 112cf8: 5b pop %ebx 112cf9: 5e pop %esi 112cfa: 5f pop %edi 112cfb: c9 leave 112cfc: c3 ret 112cfd: 8d 76 00 lea 0x0(%esi),%esi
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
112d00: 31 c0 xor %eax,%eax 112d02: eb ed jmp 112cf1 <_POSIX_signals_Clear_signals+0x85>
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
112d04: 8d 8a c0 85 12 00 lea 0x1285c0(%edx),%ecx 112d0a: 8b 82 c0 85 12 00 mov 0x1285c0(%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 );
112d10: 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))
112d13: 39 f0 cmp %esi,%eax
112d15: 74 45 je 112d5c <_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;
112d17: 8b 30 mov (%eax),%esi
head->next = new_first;
112d19: 89 b2 c0 85 12 00 mov %esi,0x1285c0(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
112d1f: 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 );
112d22: 83 ec 0c sub $0xc,%esp 112d25: 53 push %ebx 112d26: 89 45 e0 mov %eax,-0x20(%ebp) 112d29: e8 ee 04 00 00 call 11321c <_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;
112d2e: 8b 45 e0 mov -0x20(%ebp),%eax 112d31: 8d 70 08 lea 0x8(%eax),%esi 112d34: b9 03 00 00 00 mov $0x3,%ecx 112d39: 8b 7d 10 mov 0x10(%ebp),%edi 112d3c: 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;
112d3e: 8b 15 28 85 12 00 mov 0x128528,%edx
the_node->next = tail;
112d44: c7 00 24 85 12 00 movl $0x128524,(%eax)
tail->previous = the_node;
112d4a: a3 28 85 12 00 mov %eax,0x128528
old_last->next = the_node;
112d4f: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
112d51: 89 50 04 mov %edx,0x4(%eax) 112d54: 83 c4 10 add $0x10,%esp 112d57: e9 5f ff ff ff jmp 112cbb <_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 );
112d5c: 83 ec 0c sub $0xc,%esp 112d5f: 53 push %ebx 112d60: e8 b7 04 00 00 call 11321c <_POSIX_signals_Clear_process_signals> 112d65: 83 c4 10 add $0x10,%esp 112d68: e9 4e ff ff ff jmp 112cbb <_POSIX_signals_Clear_signals+0x4f>
0010c0dc <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10c0dc: 55 push %ebp 10c0dd: 89 e5 mov %esp,%ebp 10c0df: 56 push %esi 10c0e0: 53 push %ebx 10c0e1: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10c0e4: b8 1b 00 00 00 mov $0x1b,%eax 10c0e9: bb 01 00 00 00 mov $0x1,%ebx
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10c0ee: 8d 48 ff lea -0x1(%eax),%ecx 10c0f1: 89 de mov %ebx,%esi 10c0f3: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10c0f5: 85 d6 test %edx,%esi
10c0f7: 75 20 jne 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10c0f9: 40 inc %eax 10c0fa: 83 f8 20 cmp $0x20,%eax
10c0fd: 75 ef jne 10c0ee <_POSIX_signals_Get_lowest+0x12>
10c0ff: b0 01 mov $0x1,%al 10c101: bb 01 00 00 00 mov $0x1,%ebx 10c106: eb 06 jmp 10c10e <_POSIX_signals_Get_lowest+0x32>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10c108: 40 inc %eax 10c109: 83 f8 1b cmp $0x1b,%eax
10c10c: 74 0b je 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10c10e: 8d 48 ff lea -0x1(%eax),%ecx 10c111: 89 de mov %ebx,%esi 10c113: d3 e6 shl %cl,%esi
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10c115: 85 d6 test %edx,%esi
10c117: 74 ef je 10c108 <_POSIX_signals_Get_lowest+0x2c> * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; }
10c119: 5b pop %ebx 10c11a: 5e pop %esi 10c11b: c9 leave 10c11c: c3 ret
00124c6c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
124c6c: 55 push %ebp 124c6d: 89 e5 mov %esp,%ebp 124c6f: 57 push %edi 124c70: 56 push %esi 124c71: 53 push %ebx 124c72: 83 ec 0c sub $0xc,%esp 124c75: 8b 5d 08 mov 0x8(%ebp),%ebx 124c78: 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 ];
124c7b: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi 124c81: 8d 4a ff lea -0x1(%edx),%ecx 124c84: b8 01 00 00 00 mov $0x1,%eax 124c89: d3 e0 shl %cl,%eax
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
124c8b: 8b 4b 10 mov 0x10(%ebx),%ecx 124c8e: 89 cf mov %ecx,%edi 124c90: 81 e7 00 80 00 10 and $0x10008000,%edi 124c96: 81 ff 00 80 00 10 cmp $0x10008000,%edi
124c9c: 74 72 je 124d10 <_POSIX_signals_Unblock_thread+0xa4>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
124c9e: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx 124ca4: f7 d2 not %edx 124ca6: 85 d0 test %edx,%eax
124ca8: 74 5a je 124d04 <_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 ) ) {
124caa: f7 c1 00 00 00 10 test $0x10000000,%ecx
124cb0: 74 3a je 124cec <_POSIX_signals_Unblock_thread+0x80>
the_thread->Wait.return_code = EINTR;
124cb2: 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) )
124cb9: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
124cbf: 0f 85 93 00 00 00 jne 124d58 <_POSIX_signals_Unblock_thread+0xec>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
124cc5: 83 e1 08 and $0x8,%ecx
124cc8: 74 3a je 124d04 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
124cca: 83 ec 0c sub $0xc,%esp 124ccd: 8d 43 48 lea 0x48(%ebx),%eax 124cd0: 50 push %eax 124cd1: e8 b2 ec fe ff call 113988 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
124cd6: 5a pop %edx 124cd7: 59 pop %ecx 124cd8: 68 f8 ff 03 10 push $0x1003fff8 124cdd: 53 push %ebx 124cde: e8 91 da fe ff call 112774 <_Thread_Clear_state> 124ce3: 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;
124ce6: 31 c0 xor %eax,%eax 124ce8: eb 1c jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a> 124cea: 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 ) {
124cec: 85 c9 test %ecx,%ecx
124cee: 75 14 jne 124d04 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124cf0: a1 b4 f0 12 00 mov 0x12f0b4,%eax 124cf5: 85 c0 test %eax,%eax
124cf7: 74 0b je 124d04 <_POSIX_signals_Unblock_thread+0x98>
124cf9: 3b 1d b8 f0 12 00 cmp 0x12f0b8,%ebx
124cff: 74 7b je 124d7c <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN
124d01: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
}
return false;
124d04: 31 c0 xor %eax,%eax
}
124d06: 8d 65 f4 lea -0xc(%ebp),%esp 124d09: 5b pop %ebx 124d0a: 5e pop %esi 124d0b: 5f pop %edi 124d0c: c9 leave 124d0d: c3 ret 124d0e: 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) ) {
124d10: 85 43 30 test %eax,0x30(%ebx)
124d13: 74 33 je 124d48 <_POSIX_signals_Unblock_thread+0xdc>
the_thread->Wait.return_code = EINTR;
124d15: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
124d1c: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
124d1f: 8b 75 10 mov 0x10(%ebp),%esi 124d22: 85 f6 test %esi,%esi
124d24: 74 42 je 124d68 <_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;
124d26: b9 03 00 00 00 mov $0x3,%ecx 124d2b: 89 c7 mov %eax,%edi 124d2d: 8b 75 10 mov 0x10(%ebp),%esi 124d30: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
124d32: 83 ec 0c sub $0xc,%esp 124d35: 53 push %ebx 124d36: e8 51 e4 fe ff call 11318c <_Thread_queue_Extract_with_proxy>
return true;
124d3b: 83 c4 10 add $0x10,%esp 124d3e: b0 01 mov $0x1,%al
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
124d40: 8d 65 f4 lea -0xc(%ebp),%esp 124d43: 5b pop %ebx 124d44: 5e pop %esi 124d45: 5f pop %edi 124d46: c9 leave 124d47: 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) ) {
124d48: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx 124d4e: f7 d1 not %ecx 124d50: 85 c8 test %ecx,%eax
124d52: 75 c1 jne 124d15 <_POSIX_signals_Unblock_thread+0xa9>
124d54: eb ae jmp 124d04 <_POSIX_signals_Unblock_thread+0x98> 124d56: 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 );
124d58: 83 ec 0c sub $0xc,%esp 124d5b: 53 push %ebx 124d5c: e8 2b e4 fe ff call 11318c <_Thread_queue_Extract_with_proxy> 124d61: 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;
124d64: 31 c0 xor %eax,%eax 124d66: eb 9e jmp 124d06 <_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;
124d68: 89 10 mov %edx,(%eax)
the_info->si_code = SI_USER;
124d6a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
124d71: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 124d78: eb b8 jmp 124d32 <_POSIX_signals_Unblock_thread+0xc6> 124d7a: 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;
124d7c: c6 05 c4 f0 12 00 01 movb $0x1,0x12f0c4
}
}
return false;
124d83: 31 c0 xor %eax,%eax 124d85: e9 7c ff ff ff jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a>
0010d848 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10d848: 55 push %ebp 10d849: 89 e5 mov %esp,%ebp 10d84b: 56 push %esi 10d84c: 53 push %ebx 10d84d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d850: 8b 75 0c mov 0xc(%ebp),%esi
if ( !the_heap )
10d853: 85 db test %ebx,%ebx
10d855: 74 35 je 10d88c <_Protected_heap_Get_information+0x44>
return false;
if ( !the_info )
10d857: 85 f6 test %esi,%esi
10d859: 74 31 je 10d88c <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
10d85b: 83 ec 0c sub $0xc,%esp 10d85e: ff 35 40 88 12 00 pushl 0x128840 10d864: e8 e7 ed ff ff call 10c650 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
10d869: 5a pop %edx 10d86a: 59 pop %ecx 10d86b: 56 push %esi 10d86c: 53 push %ebx 10d86d: e8 d2 47 00 00 call 112044 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
10d872: 58 pop %eax 10d873: ff 35 40 88 12 00 pushl 0x128840 10d879: e8 1a ee ff ff call 10c698 <_API_Mutex_Unlock>
return true;
10d87e: 83 c4 10 add $0x10,%esp 10d881: b0 01 mov $0x1,%al
}
10d883: 8d 65 f8 lea -0x8(%ebp),%esp 10d886: 5b pop %ebx 10d887: 5e pop %esi 10d888: c9 leave 10d889: c3 ret 10d88a: 66 90 xchg %ax,%ax
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
10d88c: 31 c0 xor %eax,%eax
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
10d88e: 8d 65 f8 lea -0x8(%ebp),%esp 10d891: 5b pop %ebx 10d892: 5e pop %esi 10d893: c9 leave 10d894: c3 ret
00110c04 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
110c04: 55 push %ebp 110c05: 89 e5 mov %esp,%ebp 110c07: 56 push %esi 110c08: 53 push %ebx 110c09: 83 ec 10 sub $0x10,%esp 110c0c: 8b 5d 08 mov 0x8(%ebp),%ebx 110c0f: 8b 75 0c mov 0xc(%ebp),%esi 110c12: 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 ) {
110c15: 8b 15 d0 f2 12 00 mov 0x12f2d0,%edx 110c1b: 85 d2 test %edx,%edx
110c1d: 74 19 je 110c38 <_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 );
110c1f: 0f b6 c0 movzbl %al,%eax 110c22: 89 45 10 mov %eax,0x10(%ebp) 110c25: 89 75 0c mov %esi,0xc(%ebp) 110c28: 89 5d 08 mov %ebx,0x8(%ebp)
} return status; }
110c2b: 8d 65 f8 lea -0x8(%ebp),%esp 110c2e: 5b pop %ebx 110c2f: 5e pop %esi 110c30: 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 );
110c31: e9 32 f2 ff ff jmp 10fe68 <_Heap_Walk> 110c36: 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();
110c38: 83 ec 0c sub $0xc,%esp 110c3b: ff 35 80 f3 12 00 pushl 0x12f380 110c41: 88 45 f4 mov %al,-0xc(%ebp) 110c44: e8 bf e3 ff ff call 10f008 <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
110c49: 83 c4 0c add $0xc,%esp 110c4c: 8a 45 f4 mov -0xc(%ebp),%al 110c4f: 0f b6 c0 movzbl %al,%eax 110c52: 50 push %eax 110c53: 56 push %esi 110c54: 53 push %ebx 110c55: e8 0e f2 ff ff call 10fe68 <_Heap_Walk>
_RTEMS_Unlock_allocator();
110c5a: 5a pop %edx 110c5b: ff 35 80 f3 12 00 pushl 0x12f380 110c61: 88 45 f4 mov %al,-0xc(%ebp) 110c64: e8 e7 e3 ff ff call 10f050 <_API_Mutex_Unlock> 110c69: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
110c6c: 8a 45 f4 mov -0xc(%ebp),%al 110c6f: 8d 65 f8 lea -0x8(%ebp),%esp 110c72: 5b pop %ebx 110c73: 5e pop %esi 110c74: c9 leave 110c75: c3 ret
00110e94 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
110e94: 55 push %ebp 110e95: 89 e5 mov %esp,%ebp 110e97: 53 push %ebx 110e98: 83 ec 10 sub $0x10,%esp 110e9b: 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 );
110e9e: 80 3d 44 3a 12 00 01 cmpb $0x1,0x123a44 110ea5: 19 c0 sbb %eax,%eax 110ea7: 83 e0 c0 and $0xffffffc0,%eax 110eaa: 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 );
110ead: 50 push %eax 110eae: e8 d5 da ff ff call 10e988 <_Workspace_Allocate>
if ( !api )
110eb3: 83 c4 10 add $0x10,%esp 110eb6: 85 c0 test %eax,%eax
110eb8: 74 6a je 110f24 <_RTEMS_tasks_Create_extension+0x90>
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
110eba: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
110ec0: c7 00 00 00 00 00 movl $0x0,(%eax)
api->event_condition = 0;
110ec6: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = false;
110ecd: c6 40 08 00 movb $0x0,0x8(%eax)
information->handler = NULL;
110ed1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
information->mode_set = RTEMS_DEFAULT_MODES;
110ed8: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
information->signals_posted = 0;
110edf: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
information->signals_pending = 0;
110ee6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
information->nest_level = 0;
110eed: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal ); created->task_variables = NULL;
110ef4: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
110efb: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
110efe: 80 3d 44 3a 12 00 00 cmpb $0x0,0x123a44
110f05: 74 13 je 110f1a <_RTEMS_tasks_Create_extension+0x86>
110f07: 31 d2 xor %edx,%edx 110f09: 8d 76 00 lea 0x0(%esi),%esi
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
110f0c: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4)
110f13: 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++)
110f14: 42 inc %edx 110f15: 83 fa 10 cmp $0x10,%edx
110f18: 75 f2 jne 110f0c <_RTEMS_tasks_Create_extension+0x78>
api->Notepads[i] = 0;
}
return true;
110f1a: b0 01 mov $0x1,%al
}
110f1c: 8b 5d fc mov -0x4(%ebp),%ebx 110f1f: c9 leave 110f20: c3 ret 110f21: 8d 76 00 lea 0x0(%esi),%esi
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
110f24: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
110f26: 8b 5d fc mov -0x4(%ebp),%ebx 110f29: c9 leave 110f2a: c3 ret
00110e3c <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
110e3c: 55 push %ebp 110e3d: 89 e5 mov %esp,%ebp 110e3f: 56 push %esi 110e40: 53 push %ebx 110e41: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
110e44: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
deleted->task_variables = NULL;
110e4a: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi)
110e51: 00 00 00
while (tvp) {
110e54: 85 c0 test %eax,%eax
110e56: 75 06 jne 110e5e <_RTEMS_tasks_Delete_extension+0x22>
110e58: eb 17 jmp 110e71 <_RTEMS_tasks_Delete_extension+0x35> 110e5a: 66 90 xchg %ax,%ax
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
110e5c: 89 d8 mov %ebx,%eax
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
110e5e: 8b 18 mov (%eax),%ebx
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
110e60: 83 ec 08 sub $0x8,%esp 110e63: 50 push %eax 110e64: 56 push %esi 110e65: e8 56 01 00 00 call 110fc0 <_RTEMS_Tasks_Invoke_task_variable_dtor>
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
110e6a: 83 c4 10 add $0x10,%esp 110e6d: 85 db test %ebx,%ebx
110e6f: 75 eb jne 110e5c <_RTEMS_tasks_Delete_extension+0x20>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
110e71: 83 ec 0c sub $0xc,%esp 110e74: ff b6 e8 00 00 00 pushl 0xe8(%esi) 110e7a: e8 25 db ff ff call 10e9a4 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
110e7f: c7 86 e8 00 00 00 00 movl $0x0,0xe8(%esi)
110e86: 00 00 00
110e89: 83 c4 10 add $0x10,%esp
}
110e8c: 8d 65 f8 lea -0x8(%ebp),%esp 110e8f: 5b pop %ebx 110e90: 5e pop %esi 110e91: c9 leave 110e92: c3 ret
00110dc0 <_RTEMS_tasks_Initialize_user_tasks>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
110dc0: 55 push %ebp 110dc1: 89 e5 mov %esp,%ebp 110dc3: 83 ec 08 sub $0x8,%esp
if ( _RTEMS_tasks_Initialize_user_tasks_p )
110dc6: a1 c0 3a 12 00 mov 0x123ac0,%eax 110dcb: 85 c0 test %eax,%eax
110dcd: 74 05 je 110dd4 <_RTEMS_tasks_Initialize_user_tasks+0x14>
(*_RTEMS_tasks_Initialize_user_tasks_p)();
}
110dcf: c9 leave
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
if ( _RTEMS_tasks_Initialize_user_tasks_p )
(*_RTEMS_tasks_Initialize_user_tasks_p)();
110dd0: ff e0 jmp *%eax 110dd2: 66 90 xchg %ax,%ax
}
110dd4: c9 leave 110dd5: c3 ret
0010ba80 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10ba80: 55 push %ebp 10ba81: 89 e5 mov %esp,%ebp 10ba83: 57 push %edi 10ba84: 56 push %esi 10ba85: 53 push %ebx 10ba86: 83 ec 1c sub $0x1c,%esp
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
10ba89: 8b 1d 6c 3a 12 00 mov 0x123a6c,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10ba8f: 8b 3d 68 3a 12 00 mov 0x123a68,%edi
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
10ba95: 85 db test %ebx,%ebx
10ba97: 74 46 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10ba99: 85 ff test %edi,%edi
10ba9b: 74 42 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN
10ba9d: 31 f6 xor %esi,%esi 10ba9f: 90 nop
return_value = rtems_task_create(
10baa0: 83 ec 08 sub $0x8,%esp 10baa3: 8d 45 e4 lea -0x1c(%ebp),%eax 10baa6: 50 push %eax 10baa7: ff 73 0c pushl 0xc(%ebx) 10baaa: ff 73 14 pushl 0x14(%ebx) 10baad: ff 73 04 pushl 0x4(%ebx) 10bab0: ff 73 08 pushl 0x8(%ebx) 10bab3: ff 33 pushl (%ebx) 10bab5: e8 92 fd ff ff call 10b84c <rtems_task_create>
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
10baba: 83 c4 20 add $0x20,%esp 10babd: 85 c0 test %eax,%eax
10babf: 75 26 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
10bac1: 51 push %ecx 10bac2: ff 73 18 pushl 0x18(%ebx) 10bac5: ff 73 10 pushl 0x10(%ebx) 10bac8: ff 75 e4 pushl -0x1c(%ebp) 10bacb: e8 24 00 00 00 call 10baf4 <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10bad0: 83 c4 10 add $0x10,%esp 10bad3: 85 c0 test %eax,%eax
10bad5: 75 10 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10bad7: 46 inc %esi 10bad8: 83 c3 1c add $0x1c,%ebx 10badb: 39 f7 cmp %esi,%edi
10badd: 77 c1 ja 10baa0 <_RTEMS_tasks_Initialize_user_tasks_body+0x20><== NEVER TAKEN
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
10badf: 8d 65 f4 lea -0xc(%ebp),%esp 10bae2: 5b pop %ebx 10bae3: 5e pop %esi 10bae4: 5f pop %edi 10bae5: c9 leave 10bae6: c3 ret
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
10bae7: 52 push %edx 10bae8: 50 push %eax 10bae9: 6a 01 push $0x1 10baeb: 6a 01 push $0x1 10baed: e8 02 0e 00 00 call 10c8f4 <_Internal_error_Occurred>
00110d78 <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
110d78: 55 push %ebp 110d79: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
110d7b: 8b 45 08 mov 0x8(%ebp),%eax 110d7e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110d84: 85 c0 test %eax,%eax
110d86: 74 13 je 110d9b <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
110d88: 8b 50 04 mov 0x4(%eax),%edx 110d8b: 8b 0a mov (%edx),%ecx 110d8d: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
110d90: 8b 48 08 mov 0x8(%eax),%ecx 110d93: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110d95: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
110d97: 85 c0 test %eax,%eax
110d99: 75 ed jne 110d88 <_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;
110d9b: 8b 45 0c mov 0xc(%ebp),%eax 110d9e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110da4: 85 c0 test %eax,%eax
110da6: 74 13 je 110dbb <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
110da8: 8b 50 04 mov 0x4(%eax),%edx 110dab: 8b 0a mov (%edx),%ecx 110dad: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
110db0: 8b 48 0c mov 0xc(%eax),%ecx 110db3: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110db5: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
110db7: 85 c0 test %eax,%eax
110db9: 75 ed jne 110da8 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
110dbb: c9 leave 110dbc: c3 ret
0010c4f0 <_Rate_monotonic_Initiate_statistics>:
}
void _Rate_monotonic_Initiate_statistics(
Rate_monotonic_Control *the_period
)
{
10c4f0: 55 push %ebp 10c4f1: 89 e5 mov %esp,%ebp 10c4f3: 57 push %edi 10c4f4: 56 push %esi 10c4f5: 53 push %ebx 10c4f6: 83 ec 28 sub $0x28,%esp 10c4f9: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *owning_thread = the_period->owner;
10c4fc: 8b 73 40 mov 0x40(%ebx),%esi
* If using nanosecond statistics, we need to obtain the uptime.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
_TOD_Get_uptime( &uptime );
10c4ff: 8d 7d e0 lea -0x20(%ebp),%edi 10c502: 57 push %edi 10c503: e8 98 18 00 00 call 10dda0 <_TOD_Get_uptime>
/*
* Set the starting point and the CPU time used for the statistics.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
the_period->time_period_initiated = uptime;
10c508: 8b 45 e0 mov -0x20(%ebp),%eax 10c50b: 8b 55 e4 mov -0x1c(%ebp),%edx 10c50e: 89 43 4c mov %eax,0x4c(%ebx) 10c511: 89 53 50 mov %edx,0x50(%ebx)
#else
the_period->time_period_initiated = _Watchdog_Ticks_since_boot;
#endif
the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used;
10c514: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10c51a: 8b 96 88 00 00 00 mov 0x88(%esi),%edx 10c520: 89 43 44 mov %eax,0x44(%ebx) 10c523: 89 53 48 mov %edx,0x48(%ebx)
* routine is invoked from rtems_rate_monotonic_period, the owner will
* be the executing thread. When this routine is invoked from
* _Rate_monotonic_Timeout, it will not.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
10c526: 83 c4 10 add $0x10,%esp 10c529: 39 35 f8 b6 12 00 cmp %esi,0x12b6f8
10c52f: 74 0b je 10c53c <_Rate_monotonic_Initiate_statistics+0x4c>
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
}
#endif
}
10c531: 8d 65 f4 lea -0xc(%ebp),%esp 10c534: 5b pop %ebx 10c535: 5e pop %esi 10c536: 5f pop %edi 10c537: c9 leave 10c538: c3 ret 10c539: 8d 76 00 lea 0x0(%esi),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10c53c: 50 push %eax
&_Thread_Time_of_last_context_switch, &uptime, &ran
10c53d: 8d 75 d8 lea -0x28(%ebp),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10c540: 56 push %esi 10c541: 57 push %edi 10c542: 68 0c b2 12 00 push $0x12b20c 10c547: e8 f0 39 00 00 call 10ff3c <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
10c54c: 59 pop %ecx 10c54d: 5f pop %edi 10c54e: 56 push %esi 10c54f: 83 c3 44 add $0x44,%ebx 10c552: 53 push %ebx 10c553: e8 e8 38 00 00 call 10fe40 <_Timespec_Add_to> 10c558: 83 c4 10 add $0x10,%esp
}
#endif
}
10c55b: 8d 65 f4 lea -0xc(%ebp),%esp 10c55e: 5b pop %ebx 10c55f: 5e pop %esi 10c560: 5f pop %edi 10c561: c9 leave 10c562: c3 ret
0010caac <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10caac: 55 push %ebp 10caad: 89 e5 mov %esp,%ebp 10caaf: 83 ec 2c sub $0x2c,%esp
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
10cab2: 8d 45 f4 lea -0xc(%ebp),%eax 10cab5: 50 push %eax 10cab6: ff 75 08 pushl 0x8(%ebp) 10cab9: 68 60 b0 12 00 push $0x12b060 10cabe: e8 71 1d 00 00 call 10e834 <_Objects_Get>
switch ( location ) {
10cac3: 83 c4 10 add $0x10,%esp 10cac6: 8b 55 f4 mov -0xc(%ebp),%edx 10cac9: 85 d2 test %edx,%edx
10cacb: 75 29 jne 10caf6 <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10cacd: 8b 50 40 mov 0x40(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10cad0: f6 42 11 40 testb $0x40,0x11(%edx)
10cad4: 74 08 je 10cade <_Rate_monotonic_Timeout+0x32>
10cad6: 8b 48 08 mov 0x8(%eax),%ecx 10cad9: 39 4a 20 cmp %ecx,0x20(%edx)
10cadc: 74 4e je 10cb2c <_Rate_monotonic_Timeout+0x80>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10cade: 83 78 38 01 cmpl $0x1,0x38(%eax)
10cae2: 74 14 je 10caf8 <_Rate_monotonic_Timeout+0x4c>
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10cae4: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10caeb: a1 50 b1 12 00 mov 0x12b150,%eax 10caf0: 48 dec %eax 10caf1: a3 50 b1 12 00 mov %eax,0x12b150
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10caf6: c9 leave 10caf7: c3 ret
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10caf8: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax)
_Rate_monotonic_Initiate_statistics( the_period );
10caff: 83 ec 0c sub $0xc,%esp 10cb02: 50 push %eax 10cb03: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb06: e8 e5 f9 ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10cb0b: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb0e: 8b 50 3c mov 0x3c(%eax),%edx 10cb11: 89 50 1c mov %edx,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10cb14: 5a pop %edx 10cb15: 59 pop %ecx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10cb16: 83 c0 10 add $0x10,%eax 10cb19: 50 push %eax 10cb1a: 68 20 b2 12 00 push $0x12b220 10cb1f: e8 f8 36 00 00 call 11021c <_Watchdog_Insert> 10cb24: 83 c4 10 add $0x10,%esp 10cb27: eb c2 jmp 10caeb <_Rate_monotonic_Timeout+0x3f> 10cb29: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10cb2c: 83 ec 08 sub $0x8,%esp 10cb2f: 68 f8 ff 03 10 push $0x1003fff8 10cb34: 52 push %edx 10cb35: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb38: e8 0b 25 00 00 call 10f048 <_Thread_Clear_state>
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10cb3d: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb40: 89 04 24 mov %eax,(%esp) 10cb43: eb c1 jmp 10cb06 <_Rate_monotonic_Timeout+0x5a>
0010c564 <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
10c564: 55 push %ebp 10c565: 89 e5 mov %esp,%ebp 10c567: 57 push %edi 10c568: 56 push %esi 10c569: 53 push %ebx 10c56a: 83 ec 1c sub $0x1c,%esp 10c56d: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
10c570: ff 43 54 incl 0x54(%ebx)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
10c573: 83 7b 38 04 cmpl $0x4,0x38(%ebx)
10c577: 0f 84 bf 00 00 00 je 10c63c <_Rate_monotonic_Update_statistics+0xd8>
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c57d: 51 push %ecx
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10c57e: 8d 7d e0 lea -0x20(%ebp),%edi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c581: 57 push %edi
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10c582: 8d 75 d8 lea -0x28(%ebp),%esi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c585: 56 push %esi 10c586: 53 push %ebx 10c587: e8 cc fe ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
10c58c: 83 c4 10 add $0x10,%esp 10c58f: 84 c0 test %al,%al
10c591: 75 09 jne 10c59c <_Rate_monotonic_Update_statistics+0x38>
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
10c593: 8d 65 f4 lea -0xc(%ebp),%esp 10c596: 5b pop %ebx 10c597: 5e pop %esi 10c598: 5f pop %edi 10c599: c9 leave 10c59a: c3 ret 10c59b: 90 nop
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
10c59c: 83 ec 08 sub $0x8,%esp 10c59f: 57 push %edi 10c5a0: 8d 43 6c lea 0x6c(%ebx),%eax 10c5a3: 50 push %eax 10c5a4: e8 97 38 00 00 call 10fe40 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
10c5a9: 58 pop %eax 10c5aa: 5a pop %edx 10c5ab: 8d 43 5c lea 0x5c(%ebx),%eax 10c5ae: 50 push %eax 10c5af: 57 push %edi 10c5b0: e8 63 39 00 00 call 10ff18 <_Timespec_Less_than> 10c5b5: 83 c4 10 add $0x10,%esp 10c5b8: 84 c0 test %al,%al
10c5ba: 74 0c je 10c5c8 <_Rate_monotonic_Update_statistics+0x64>
stats->min_cpu_time = executed;
10c5bc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5bf: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5c2: 89 43 5c mov %eax,0x5c(%ebx) 10c5c5: 89 53 60 mov %edx,0x60(%ebx)
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
10c5c8: 83 ec 08 sub $0x8,%esp 10c5cb: 8d 43 64 lea 0x64(%ebx),%eax 10c5ce: 50 push %eax 10c5cf: 57 push %edi 10c5d0: e8 1f 39 00 00 call 10fef4 <_Timespec_Greater_than> 10c5d5: 83 c4 10 add $0x10,%esp 10c5d8: 84 c0 test %al,%al
10c5da: 74 0c je 10c5e8 <_Rate_monotonic_Update_statistics+0x84>
stats->max_cpu_time = executed;
10c5dc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5df: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5e2: 89 43 64 mov %eax,0x64(%ebx) 10c5e5: 89 53 68 mov %edx,0x68(%ebx)
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
10c5e8: 83 ec 08 sub $0x8,%esp 10c5eb: 56 push %esi 10c5ec: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c5f2: 50 push %eax 10c5f3: e8 48 38 00 00 call 10fe40 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
10c5f8: 5a pop %edx 10c5f9: 59 pop %ecx 10c5fa: 8d 43 74 lea 0x74(%ebx),%eax 10c5fd: 50 push %eax 10c5fe: 56 push %esi 10c5ff: e8 14 39 00 00 call 10ff18 <_Timespec_Less_than> 10c604: 83 c4 10 add $0x10,%esp 10c607: 84 c0 test %al,%al
10c609: 75 39 jne 10c644 <_Rate_monotonic_Update_statistics+0xe0>
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
10c60b: 83 ec 08 sub $0x8,%esp 10c60e: 8d 43 7c lea 0x7c(%ebx),%eax 10c611: 50 push %eax 10c612: 56 push %esi 10c613: e8 dc 38 00 00 call 10fef4 <_Timespec_Greater_than> 10c618: 83 c4 10 add $0x10,%esp 10c61b: 84 c0 test %al,%al
10c61d: 0f 84 70 ff ff ff je 10c593 <_Rate_monotonic_Update_statistics+0x2f>
stats->max_wall_time = since_last_period;
10c623: 8b 45 d8 mov -0x28(%ebp),%eax 10c626: 8b 55 dc mov -0x24(%ebp),%edx 10c629: 89 43 7c mov %eax,0x7c(%ebx) 10c62c: 89 93 80 00 00 00 mov %edx,0x80(%ebx)
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
10c632: 8d 65 f4 lea -0xc(%ebp),%esp 10c635: 5b pop %ebx 10c636: 5e pop %esi 10c637: 5f pop %edi 10c638: c9 leave 10c639: c3 ret 10c63a: 66 90 xchg %ax,%ax
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
10c63c: ff 43 58 incl 0x58(%ebx) 10c63f: e9 39 ff ff ff jmp 10c57d <_Rate_monotonic_Update_statistics+0x19>
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
10c644: 8b 45 d8 mov -0x28(%ebp),%eax 10c647: 8b 55 dc mov -0x24(%ebp),%edx 10c64a: 89 43 74 mov %eax,0x74(%ebx) 10c64d: 89 53 78 mov %edx,0x78(%ebx) 10c650: eb b9 jmp 10c60b <_Rate_monotonic_Update_statistics+0xa7>
0010d18c <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10d18c: 55 push %ebp 10d18d: 89 e5 mov %esp,%ebp 10d18f: 53 push %ebx 10d190: 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;
10d193: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
ready = sched_info->ready_chain;
10d199: 8b 11 mov (%ecx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
10d19b: 8b 5a 08 mov 0x8(%edx),%ebx 10d19e: 39 1a cmp %ebx,(%edx)
10d1a0: 74 6e je 10d210 <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d1a2: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10d1a4: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10d1a7: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10d1aa: 89 0a mov %ecx,(%edx)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10d1ac: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d1b2: 74 18 je 10d1cc <_Scheduler_priority_Block+0x40>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10d1b4: 3b 05 38 83 12 00 cmp 0x128338,%eax
10d1ba: 74 04 je 10d1c0 <_Scheduler_priority_Block+0x34>
_Thread_Dispatch_necessary = true;
}
10d1bc: 5b pop %ebx 10d1bd: c9 leave 10d1be: c3 ret 10d1bf: 90 nop
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
10d1c0: c6 05 44 83 12 00 01 movb $0x1,0x128344
}
10d1c7: 5b pop %ebx 10d1c8: c9 leave 10d1c9: c3 ret 10d1ca: 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 );
10d1cc: 66 8b 1d 60 83 12 00 mov 0x128360,%bx 10d1d3: 31 d2 xor %edx,%edx 10d1d5: 89 d1 mov %edx,%ecx 10d1d7: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d1db: 0f b7 c9 movzwl %cx,%ecx 10d1de: 66 8b 9c 09 80 83 12 mov 0x128380(%ecx,%ecx,1),%bx
10d1e5: 00
10d1e6: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10d1ea: c1 e1 04 shl $0x4,%ecx 10d1ed: 0f b7 d2 movzwl %dx,%edx 10d1f0: 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 ] ) )
10d1f3: 8d 14 52 lea (%edx,%edx,2),%edx 10d1f6: c1 e2 02 shl $0x2,%edx 10d1f9: 03 15 80 39 12 00 add 0x123980,%edx 10d1ff: 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 );
10d201: 83 c2 04 add $0x4,%edx 10d204: 39 d1 cmp %edx,%ecx
10d206: 74 44 je 10d24c <_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(
10d208: 89 0d 3c 83 12 00 mov %ecx,0x12833c 10d20e: eb a4 jmp 10d1b4 <_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 );
10d210: 8d 5a 04 lea 0x4(%edx),%ebx 10d213: 89 1a mov %ebx,(%edx)
head->next = tail;
head->previous = NULL;
10d215: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
10d21c: 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;
10d21f: 8b 59 04 mov 0x4(%ecx),%ebx 10d222: 66 8b 13 mov (%ebx),%dx 10d225: 66 23 51 0e and 0xe(%ecx),%dx 10d229: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
10d22c: 66 85 d2 test %dx,%dx
10d22f: 0f 85 77 ff ff ff jne 10d1ac <_Scheduler_priority_Block+0x20>
_Priority_Major_bit_map &= the_priority_map->block_major;
10d235: 66 8b 15 60 83 12 00 mov 0x128360,%dx 10d23c: 23 51 0c and 0xc(%ecx),%edx 10d23f: 66 89 15 60 83 12 00 mov %dx,0x128360 10d246: e9 61 ff ff ff jmp 10d1ac <_Scheduler_priority_Block+0x20> 10d24b: 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;
10d24c: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10d24e: eb b8 jmp 10d208 <_Scheduler_priority_Block+0x7c><== NOT EXECUTED
0010d3a0 <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10d3a0: 55 push %ebp 10d3a1: 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 );
10d3a3: 66 8b 0d 60 83 12 00 mov 0x128360,%cx 10d3aa: 31 c0 xor %eax,%eax 10d3ac: 89 c2 mov %eax,%edx 10d3ae: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d3b2: 0f b7 d2 movzwl %dx,%edx 10d3b5: 66 8b 8c 12 80 83 12 mov 0x128380(%edx,%edx,1),%cx
10d3bc: 00
10d3bd: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10d3c1: c1 e2 04 shl $0x4,%edx 10d3c4: 0f b7 c0 movzwl %ax,%eax 10d3c7: 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 ] ) )
10d3ca: 8d 04 40 lea (%eax,%eax,2),%eax 10d3cd: c1 e0 02 shl $0x2,%eax 10d3d0: 03 05 80 39 12 00 add 0x123980,%eax
_Scheduler_priority_Schedule_body(); }
10d3d6: 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 );
10d3d8: 83 c0 04 add $0x4,%eax 10d3db: 39 c2 cmp %eax,%edx
10d3dd: 74 09 je 10d3e8 <_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(
10d3df: 89 15 3c 83 12 00 mov %edx,0x12833c 10d3e5: c9 leave 10d3e6: c3 ret 10d3e7: 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;
10d3e8: 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(
10d3ea: 89 15 3c 83 12 00 mov %edx,0x12833c <== NOT EXECUTED 10d3f0: c9 leave <== NOT EXECUTED 10d3f1: c3 ret <== NOT EXECUTED
0010d4c4 <_Scheduler_priority_Yield>:
* ready chain
* select heir
*/
void _Scheduler_priority_Yield(void)
{
10d4c4: 55 push %ebp 10d4c5: 89 e5 mov %esp,%ebp 10d4c7: 56 push %esi 10d4c8: 53 push %ebx
Scheduler_priority_Per_thread *sched_info;
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10d4c9: a1 38 83 12 00 mov 0x128338,%eax
sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info; ready = sched_info->ready_chain;
10d4ce: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10d4d4: 8b 12 mov (%edx),%edx
_ISR_Disable( level );
10d4d6: 9c pushf 10d4d7: fa cli 10d4d8: 59 pop %ecx
if ( !_Chain_Has_only_one_node( ready ) ) {
10d4d9: 8b 5a 08 mov 0x8(%edx),%ebx 10d4dc: 39 1a cmp %ebx,(%edx)
10d4de: 74 40 je 10d520 <_Scheduler_priority_Yield+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d4e0: 8b 30 mov (%eax),%esi
previous = the_node->previous;
10d4e2: 8b 58 04 mov 0x4(%eax),%ebx
next->previous = previous;
10d4e5: 89 5e 04 mov %ebx,0x4(%esi)
previous->next = next;
10d4e8: 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;
10d4ea: 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 );
10d4ed: 8d 72 04 lea 0x4(%edx),%esi 10d4f0: 89 30 mov %esi,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d4f2: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10d4f5: 89 03 mov %eax,(%ebx)
the_node->previous = old_last;
10d4f7: 89 58 04 mov %ebx,0x4(%eax)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10d4fa: 51 push %ecx 10d4fb: 9d popf 10d4fc: fa cli
if ( _Thread_Is_heir( executing ) )
10d4fd: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d503: 74 0f je 10d514 <_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;
10d505: c6 05 44 83 12 00 01 movb $0x1,0x128344
_ISR_Enable( level );
10d50c: 51 push %ecx 10d50d: 9d popf
}
10d50e: 5b pop %ebx 10d50f: 5e pop %esi 10d510: c9 leave 10d511: c3 ret 10d512: 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 );
10d514: 8b 02 mov (%edx),%eax 10d516: a3 3c 83 12 00 mov %eax,0x12833c 10d51b: eb e8 jmp 10d505 <_Scheduler_priority_Yield+0x41> 10d51d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
10d520: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d526: 75 dd jne 10d505 <_Scheduler_priority_Yield+0x41>
10d528: eb e2 jmp 10d50c <_Scheduler_priority_Yield+0x48>
0010dadc <_TOD_Set>:
*/
void _TOD_Set(
const struct timespec *time
)
{
10dadc: 55 push %ebp 10dadd: 89 e5 mov %esp,%ebp 10dadf: 53 push %ebx 10dae0: 83 ec 04 sub $0x4,%esp 10dae3: 8b 5d 08 mov 0x8(%ebp),%ebx 10dae6: a1 10 aa 12 00 mov 0x12aa10,%eax 10daeb: 40 inc %eax 10daec: a3 10 aa 12 00 mov %eax,0x12aa10
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10daf1: a1 a8 aa 12 00 mov 0x12aaa8,%eax
if ( time->tv_sec < seconds )
10daf6: 8b 13 mov (%ebx),%edx 10daf8: 39 d0 cmp %edx,%eax
10dafa: 7f 34 jg 10db30 <_TOD_Set+0x54>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
10dafc: 51 push %ecx
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
10dafd: 29 c2 sub %eax,%edx 10daff: 52 push %edx 10db00: 6a 00 push $0x0 10db02: 68 d4 aa 12 00 push $0x12aad4 10db07: e8 0c 25 00 00 call 110018 <_Watchdog_Adjust> 10db0c: 83 c4 10 add $0x10,%esp
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
10db0f: 8b 03 mov (%ebx),%eax 10db11: a3 a8 aa 12 00 mov %eax,0x12aaa8 10db16: 8b 43 04 mov 0x4(%ebx),%eax 10db19: a3 ac aa 12 00 mov %eax,0x12aaac
_TOD_Is_set = true;
10db1e: c6 05 24 aa 12 00 01 movb $0x1,0x12aa24
_TOD_Activate();
_Thread_Enable_dispatch();
}
10db25: 8b 5d fc mov -0x4(%ebp),%ebx 10db28: c9 leave
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
10db29: e9 02 16 00 00 jmp 10f130 <_Thread_Enable_dispatch> 10db2e: 66 90 xchg %ax,%ax 10db30: 51 push %ecx
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
if ( time->tv_sec < seconds )
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
10db31: 29 d0 sub %edx,%eax 10db33: 50 push %eax 10db34: 6a 01 push $0x1 10db36: 68 d4 aa 12 00 push $0x12aad4 10db3b: e8 d8 24 00 00 call 110018 <_Watchdog_Adjust> 10db40: 83 c4 10 add $0x10,%esp 10db43: eb ca jmp 10db0f <_TOD_Set+0x33>
0010c1e8 <_TOD_To_seconds>:
*/
uint32_t _TOD_To_seconds(
const rtems_time_of_day *the_tod
)
{
10c1e8: 55 push %ebp 10c1e9: 89 e5 mov %esp,%ebp 10c1eb: 56 push %esi 10c1ec: 53 push %ebx 10c1ed: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
10c1f0: 8b 72 08 mov 0x8(%edx),%esi 10c1f3: 4e dec %esi
year_mod_4 = the_tod->year & 3;
10c1f4: 8b 02 mov (%edx),%eax
if ( year_mod_4 == 0 )
10c1f6: 89 c3 mov %eax,%ebx 10c1f8: 83 e3 03 and $0x3,%ebx
10c1fb: 74 67 je 10c264 <_TOD_To_seconds+0x7c>
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
10c1fd: 8b 4a 04 mov 0x4(%edx),%ecx 10c200: 0f b7 8c 09 c0 42 12 movzwl 0x1242c0(%ecx,%ecx,1),%ecx
10c207: 00
10c208: 8d 34 31 lea (%ecx,%esi,1),%esi
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10c20b: 0f b7 8c 1b f4 42 12 movzwl 0x1242f4(%ebx,%ebx,1),%ecx
10c212: 00
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
10c213: 2d c4 07 00 00 sub $0x7c4,%eax 10c218: c1 e8 02 shr $0x2,%eax 10c21b: 8d 1c c0 lea (%eax,%eax,8),%ebx 10c21e: 8d 1c d8 lea (%eax,%ebx,8),%ebx 10c221: 8d 1c 9b lea (%ebx,%ebx,4),%ebx 10c224: 8d 04 98 lea (%eax,%ebx,4),%eax 10c227: 01 c1 add %eax,%ecx
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10c229: 01 f1 add %esi,%ecx
time *= TOD_SECONDS_PER_DAY;
10c22b: 8d 04 89 lea (%ecx,%ecx,4),%eax 10c22e: 8d 04 81 lea (%ecx,%eax,4),%eax 10c231: 8d 04 c1 lea (%ecx,%eax,8),%eax 10c234: c1 e0 02 shl $0x2,%eax 10c237: 29 c8 sub %ecx,%eax 10c239: c1 e0 07 shl $0x7,%eax
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
10c23c: 8b 5a 14 mov 0x14(%edx),%ebx 10c23f: 8b 4a 0c mov 0xc(%edx),%ecx 10c242: 8d 0c 49 lea (%ecx,%ecx,2),%ecx 10c245: 8d 0c 89 lea (%ecx,%ecx,4),%ecx 10c248: c1 e1 02 shl $0x2,%ecx 10c24b: 03 4a 10 add 0x10(%edx),%ecx
* TOD_SECONDS_PER_MINUTE;
10c24e: 8d 14 49 lea (%ecx,%ecx,2),%edx 10c251: 8d 14 92 lea (%edx,%edx,4),%edx
time += the_tod->second;
10c254: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx
time += TOD_SECONDS_1970_THROUGH_1988;
10c25b: 8d 04 02 lea (%edx,%eax,1),%eax
return( time );
}
10c25e: 5b pop %ebx 10c25f: 5e pop %esi 10c260: c9 leave 10c261: c3 ret 10c262: 66 90 xchg %ax,%ax
time = the_tod->day - 1;
year_mod_4 = the_tod->year & 3;
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
10c264: 8b 4a 04 mov 0x4(%edx),%ecx 10c267: 0f b7 8c 09 da 42 12 movzwl 0x1242da(%ecx,%ecx,1),%ecx
10c26e: 00
10c26f: 8d 34 31 lea (%ecx,%esi,1),%esi 10c272: eb 97 jmp 10c20b <_TOD_To_seconds+0x23>
0010c274 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10c274: 55 push %ebp 10c275: 89 e5 mov %esp,%ebp 10c277: 53 push %ebx 10c278: 8b 4d 08 mov 0x8(%ebp),%ecx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
10c27b: 8b 1d 6c 62 12 00 mov 0x12626c,%ebx
if ((!the_tod) ||
10c281: 85 c9 test %ecx,%ecx
10c283: 74 53 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10c285: b8 40 42 0f 00 mov $0xf4240,%eax 10c28a: 31 d2 xor %edx,%edx 10c28c: f7 f3 div %ebx
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
10c28e: 3b 41 18 cmp 0x18(%ecx),%eax
10c291: 76 45 jbe 10c2d8 <_TOD_Validate+0x64>
(the_tod->ticks >= ticks_per_second) ||
10c293: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10c297: 77 3f ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10c299: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10c29d: 77 39 ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10c29f: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10c2a3: 77 33 ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10c2a5: 8b 41 04 mov 0x4(%ecx),%eax
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
10c2a8: 85 c0 test %eax,%eax
10c2aa: 74 2c je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->month == 0) ||
10c2ac: 83 f8 0c cmp $0xc,%eax
10c2af: 77 27 ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10c2b1: 8b 11 mov (%ecx),%edx
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
10c2b3: 81 fa c3 07 00 00 cmp $0x7c3,%edx
10c2b9: 76 1d jbe 10c2d8 <_TOD_Validate+0x64>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10c2bb: 8b 49 08 mov 0x8(%ecx),%ecx
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10c2be: 85 c9 test %ecx,%ecx
10c2c0: 74 16 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10c2c2: 83 e2 03 and $0x3,%edx
10c2c5: 75 16 jne 10c2dd <_TOD_Validate+0x69>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10c2c7: 8b 04 85 34 43 12 00 mov 0x124334(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10c2ce: 39 c8 cmp %ecx,%eax 10c2d0: 0f 93 c0 setae %al 10c2d3: eb 05 jmp 10c2da <_TOD_Validate+0x66> 10c2d5: 8d 76 00 lea 0x0(%esi),%esi
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
10c2d8: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10c2da: 5b pop %ebx 10c2db: c9 leave 10c2dc: c3 ret
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10c2dd: 8b 04 85 00 43 12 00 mov 0x124300(,%eax,4),%eax 10c2e4: eb e8 jmp 10c2ce <_TOD_Validate+0x5a>
0010d578 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10d578: 55 push %ebp 10d579: 89 e5 mov %esp,%ebp 10d57b: 57 push %edi 10d57c: 56 push %esi 10d57d: 53 push %ebx 10d57e: 83 ec 28 sub $0x28,%esp 10d581: 8b 5d 08 mov 0x8(%ebp),%ebx 10d584: 8b 75 0c mov 0xc(%ebp),%esi 10d587: 8a 45 10 mov 0x10(%ebp),%al 10d58a: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10d58d: 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 );
10d590: 53 push %ebx 10d591: e8 76 0c 00 00 call 10e20c <_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 )
10d596: 83 c4 10 add $0x10,%esp 10d599: 39 73 14 cmp %esi,0x14(%ebx)
10d59c: 74 0d je 10d5ab <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10d59e: 83 ec 08 sub $0x8,%esp 10d5a1: 56 push %esi 10d5a2: 53 push %ebx 10d5a3: e8 10 0c 00 00 call 10e1b8 <_Thread_Set_priority> 10d5a8: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10d5ab: 9c pushf 10d5ac: fa cli 10d5ad: 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;
10d5ae: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10d5b1: 83 f8 04 cmp $0x4,%eax
10d5b4: 74 22 je 10d5d8 <_Thread_Change_priority+0x60>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10d5b6: 83 e7 04 and $0x4,%edi
10d5b9: 74 11 je 10d5cc <_Thread_Change_priority+0x54><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10d5bb: 56 push %esi 10d5bc: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d5bd: a9 e0 be 03 00 test $0x3bee0,%eax
10d5c2: 75 60 jne 10d624 <_Thread_Change_priority+0xac>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10d5c4: 8d 65 f4 lea -0xc(%ebp),%esp 10d5c7: 5b pop %ebx 10d5c8: 5e pop %esi 10d5c9: 5f pop %edi 10d5ca: c9 leave 10d5cb: c3 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10d5cc: 89 c2 mov %eax,%edx 10d5ce: 83 e2 fb and $0xfffffffb,%edx 10d5d1: 89 53 10 mov %edx,0x10(%ebx) 10d5d4: eb e5 jmp 10d5bb <_Thread_Change_priority+0x43> 10d5d6: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10d5d8: 83 e7 04 and $0x4,%edi
10d5db: 75 1a jne 10d5f7 <_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 );
10d5dd: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10d5e4: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10d5e8: 74 52 je 10d63c <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10d5ea: 83 ec 0c sub $0xc,%esp 10d5ed: 53 push %ebx 10d5ee: ff 15 a8 39 12 00 call *0x1239a8 10d5f4: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10d5f7: 56 push %esi 10d5f8: 9d popf 10d5f9: 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();
10d5fa: ff 15 88 39 12 00 call *0x123988
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10d600: a1 38 83 12 00 mov 0x128338,%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() &&
10d605: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d60b: 74 0d je 10d61a <_Thread_Change_priority+0xa2>
10d60d: 80 78 74 00 cmpb $0x0,0x74(%eax)
10d611: 74 07 je 10d61a <_Thread_Change_priority+0xa2>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10d613: c6 05 44 83 12 00 01 movb $0x1,0x128344
_ISR_Enable( level );
10d61a: 56 push %esi 10d61b: 9d popf
}
10d61c: 8d 65 f4 lea -0xc(%ebp),%esp 10d61f: 5b pop %ebx 10d620: 5e pop %esi 10d621: 5f pop %edi 10d622: c9 leave 10d623: 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 );
10d624: 89 5d 0c mov %ebx,0xc(%ebp) 10d627: 8b 43 44 mov 0x44(%ebx),%eax 10d62a: 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 );
}
10d62d: 8d 65 f4 lea -0xc(%ebp),%esp 10d630: 5b pop %ebx 10d631: 5e pop %esi 10d632: 5f pop %edi 10d633: 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 );
10d634: e9 e7 0a 00 00 jmp 10e120 <_Thread_queue_Requeue> 10d639: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10d63c: 83 ec 0c sub $0xc,%esp 10d63f: 53 push %ebx 10d640: ff 15 a4 39 12 00 call *0x1239a4 10d646: 83 c4 10 add $0x10,%esp 10d649: eb ac jmp 10d5f7 <_Thread_Change_priority+0x7f>
0010d64c <_Thread_Clear_state>:
*/
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10d64c: 55 push %ebp 10d64d: 89 e5 mov %esp,%ebp 10d64f: 53 push %ebx 10d650: 83 ec 04 sub $0x4,%esp 10d653: 8b 55 08 mov 0x8(%ebp),%edx 10d656: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10d659: 9c pushf 10d65a: fa cli 10d65b: 5b pop %ebx
current_state = the_thread->current_state;
10d65c: 8b 4a 10 mov 0x10(%edx),%ecx
if ( current_state & state ) {
10d65f: 85 c8 test %ecx,%eax
10d661: 74 0b je 10d66e <_Thread_Clear_state+0x22>
10d663: f7 d0 not %eax 10d665: 21 c8 and %ecx,%eax
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10d667: 89 42 10 mov %eax,0x10(%edx)
if ( _States_Is_ready( current_state ) ) {
10d66a: 85 c0 test %eax,%eax
10d66c: 74 0a je 10d678 <_Thread_Clear_state+0x2c>
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10d66e: 53 push %ebx 10d66f: 9d popf
}
10d670: 8b 5d fc mov -0x4(%ebp),%ebx 10d673: c9 leave 10d674: c3 ret 10d675: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10d678: 83 ec 0c sub $0xc,%esp 10d67b: 52 push %edx 10d67c: ff 15 94 39 12 00 call *0x123994 10d682: 83 c4 10 add $0x10,%esp 10d685: eb e7 jmp 10d66e <_Thread_Clear_state+0x22>
0010d7fc <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10d7fc: 55 push %ebp 10d7fd: 89 e5 mov %esp,%ebp 10d7ff: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d802: 8d 45 f4 lea -0xc(%ebp),%eax 10d805: 50 push %eax 10d806: ff 75 08 pushl 0x8(%ebp) 10d809: e8 c6 01 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10d80e: 83 c4 10 add $0x10,%esp 10d811: 8b 55 f4 mov -0xc(%ebp),%edx 10d814: 85 d2 test %edx,%edx
10d816: 75 1c jne 10d834 <_Thread_Delay_ended+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10d818: 83 ec 08 sub $0x8,%esp 10d81b: 68 18 00 00 10 push $0x10000018 10d820: 50 push %eax 10d821: e8 26 fe ff ff call 10d64c <_Thread_Clear_state> 10d826: a1 90 7d 12 00 mov 0x127d90,%eax 10d82b: 48 dec %eax 10d82c: a3 90 7d 12 00 mov %eax,0x127d90 10d831: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10d834: c9 leave 10d835: c3 ret
0010d838 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10d838: 55 push %ebp 10d839: 89 e5 mov %esp,%ebp 10d83b: 57 push %edi 10d83c: 56 push %esi 10d83d: 53 push %ebx 10d83e: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10d841: 8b 1d 38 83 12 00 mov 0x128338,%ebx
_ISR_Disable( level );
10d847: 9c pushf 10d848: fa cli 10d849: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10d84a: 8a 15 44 83 12 00 mov 0x128344,%dl 10d850: 84 d2 test %dl,%dl
10d852: 0f 84 3c 01 00 00 je 10d994 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d858: 8b 35 3c 83 12 00 mov 0x12833c,%esi
_Thread_Dispatch_disable_level = 1;
10d85e: c7 05 90 7d 12 00 01 movl $0x1,0x127d90
10d865: 00 00 00
_Thread_Dispatch_necessary = false;
10d868: c6 05 44 83 12 00 00 movb $0x0,0x128344
_Thread_Executing = heir;
10d86f: 89 35 38 83 12 00 mov %esi,0x128338
/*
* 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 )
10d875: 39 f3 cmp %esi,%ebx
10d877: 0f 84 17 01 00 00 je 10d994 <_Thread_Dispatch+0x15c>
10d87d: 8d 7d d8 lea -0x28(%ebp),%edi 10d880: e9 f5 00 00 00 jmp 10d97a <_Thread_Dispatch+0x142> 10d885: 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 );
10d888: 50 push %eax 10d889: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10d88a: 83 ec 0c sub $0xc,%esp 10d88d: 8d 45 e0 lea -0x20(%ebp),%eax 10d890: 50 push %eax 10d891: e8 2a 3a 00 00 call 1112c0 <_TOD_Get_uptime>
_Timestamp_Subtract(
10d896: 83 c4 0c add $0xc,%esp 10d899: 57 push %edi 10d89a: 8d 45 e0 lea -0x20(%ebp),%eax 10d89d: 50 push %eax 10d89e: 68 4c 7e 12 00 push $0x127e4c 10d8a3: e8 98 0b 00 00 call 10e440 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10d8a8: 58 pop %eax 10d8a9: 5a pop %edx 10d8aa: 57 push %edi 10d8ab: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10d8b1: 50 push %eax 10d8b2: e8 4d 0b 00 00 call 10e404 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10d8b7: 8b 45 e0 mov -0x20(%ebp),%eax 10d8ba: 8b 55 e4 mov -0x1c(%ebp),%edx 10d8bd: a3 4c 7e 12 00 mov %eax,0x127e4c 10d8c2: 89 15 50 7e 12 00 mov %edx,0x127e50
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10d8c8: a1 24 7e 12 00 mov 0x127e24,%eax 10d8cd: 83 c4 10 add $0x10,%esp 10d8d0: 85 c0 test %eax,%eax
10d8d2: 74 10 je 10d8e4 <_Thread_Dispatch+0xac> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10d8d4: 8b 10 mov (%eax),%edx 10d8d6: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10d8dc: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10d8e2: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10d8e4: 83 ec 08 sub $0x8,%esp 10d8e7: 56 push %esi 10d8e8: 53 push %ebx 10d8e9: e8 f2 0d 00 00 call 10e6e0 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10d8ee: 5a pop %edx 10d8ef: 59 pop %ecx 10d8f0: 81 c6 c8 00 00 00 add $0xc8,%esi 10d8f6: 56 push %esi 10d8f7: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10d8fd: 50 push %eax 10d8fe: e8 ed 10 00 00 call 10e9f0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10d903: 83 c4 10 add $0x10,%esp 10d906: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10d90c: 85 c0 test %eax,%eax
10d90e: 74 36 je 10d946 <_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 );
10d910: a1 20 7e 12 00 mov 0x127e20,%eax 10d915: 39 c3 cmp %eax,%ebx
10d917: 74 2d je 10d946 <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10d919: 85 c0 test %eax,%eax
10d91b: 74 11 je 10d92e <_Thread_Dispatch+0xf6>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10d91d: 83 ec 0c sub $0xc,%esp 10d920: 05 e0 00 00 00 add $0xe0,%eax 10d925: 50 push %eax 10d926: e8 f9 10 00 00 call 10ea24 <_CPU_Context_save_fp> 10d92b: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10d92e: 83 ec 0c sub $0xc,%esp 10d931: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10d937: 50 push %eax 10d938: e8 f1 10 00 00 call 10ea2e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10d93d: 89 1d 20 7e 12 00 mov %ebx,0x127e20 10d943: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10d946: 8b 1d 38 83 12 00 mov 0x128338,%ebx
_ISR_Disable( level );
10d94c: 9c pushf 10d94d: fa cli 10d94e: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10d94f: 8a 15 44 83 12 00 mov 0x128344,%dl 10d955: 84 d2 test %dl,%dl
10d957: 74 3b je 10d994 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d959: 8b 35 3c 83 12 00 mov 0x12833c,%esi
_Thread_Dispatch_disable_level = 1;
10d95f: c7 05 90 7d 12 00 01 movl $0x1,0x127d90
10d966: 00 00 00
_Thread_Dispatch_necessary = false;
10d969: c6 05 44 83 12 00 00 movb $0x0,0x128344
_Thread_Executing = heir;
10d970: 89 35 38 83 12 00 mov %esi,0x128338
/*
* 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 )
10d976: 39 de cmp %ebx,%esi
10d978: 74 1a je 10d994 <_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 )
10d97a: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10d97e: 0f 85 04 ff ff ff jne 10d888 <_Thread_Dispatch+0x50>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10d984: 8b 15 60 7d 12 00 mov 0x127d60,%edx 10d98a: 89 56 78 mov %edx,0x78(%esi) 10d98d: e9 f6 fe ff ff jmp 10d888 <_Thread_Dispatch+0x50> 10d992: 66 90 xchg %ax,%ax
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10d994: c7 05 90 7d 12 00 00 movl $0x0,0x127d90
10d99b: 00 00 00
_ISR_Enable( level );
10d99e: 50 push %eax 10d99f: 9d popf
_API_extensions_Run_postswitch();
10d9a0: e8 23 e5 ff ff call 10bec8 <_API_extensions_Run_postswitch>
}
10d9a5: 8d 65 f4 lea -0xc(%ebp),%esp 10d9a8: 5b pop %ebx 10d9a9: 5e pop %esi 10d9aa: 5f pop %edi 10d9ab: c9 leave 10d9ac: c3 ret
0010d9d4 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10d9d4: 55 push %ebp 10d9d5: 89 e5 mov %esp,%ebp 10d9d7: 53 push %ebx 10d9d8: 83 ec 04 sub $0x4,%esp 10d9db: 8b 45 08 mov 0x8(%ebp),%eax 10d9de: 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 ) ) {
10d9e1: 85 c0 test %eax,%eax
10d9e3: 74 47 je 10da2c <_Thread_Get+0x58>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10d9e5: 89 c2 mov %eax,%edx 10d9e7: c1 ea 18 shr $0x18,%edx 10d9ea: 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 )
10d9ed: 8d 5a ff lea -0x1(%edx),%ebx 10d9f0: 83 fb 02 cmp $0x2,%ebx
10d9f3: 77 27 ja 10da1c <_Thread_Get+0x48>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10d9f5: 89 c3 mov %eax,%ebx 10d9f7: 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 :) */
10d9fa: 4b dec %ebx
10d9fb: 75 1f jne 10da1c <_Thread_Get+0x48>
*location = OBJECTS_ERROR;
goto done;
}
#endif
information = api_information[ the_class ];
10d9fd: 8b 14 95 68 7d 12 00 mov 0x127d68(,%edx,4),%edx 10da04: 8b 52 04 mov 0x4(%edx),%edx
if ( !information ) {
10da07: 85 d2 test %edx,%edx
10da09: 74 11 je 10da1c <_Thread_Get+0x48>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10da0b: 53 push %ebx 10da0c: 51 push %ecx 10da0d: 50 push %eax 10da0e: 52 push %edx 10da0f: e8 24 f4 ff ff call 10ce38 <_Objects_Get> 10da14: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10da17: 8b 5d fc mov -0x4(%ebp),%ebx 10da1a: c9 leave 10da1b: c3 ret
}
#endif
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10da1c: 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;
10da22: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10da24: 8b 5d fc mov -0x4(%ebp),%ebx 10da27: c9 leave 10da28: c3 ret 10da29: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10da2c: a1 90 7d 12 00 mov 0x127d90,%eax 10da31: 40 inc %eax 10da32: a3 90 7d 12 00 mov %eax,0x127d90
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;
10da37: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10da3d: a1 38 83 12 00 mov 0x128338,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10da42: 8b 5d fc mov -0x4(%ebp),%ebx 10da45: c9 leave 10da46: c3 ret
001130a8 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
1130a8: 55 push %ebp 1130a9: 89 e5 mov %esp,%ebp 1130ab: 53 push %ebx 1130ac: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
1130af: 8b 1d 38 83 12 00 mov 0x128338,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
1130b5: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
1130bb: 85 c0 test %eax,%eax
1130bd: 74 79 je 113138 <_Thread_Handler+0x90>
1130bf: fa cli
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
1130c0: a0 0c 7a 12 00 mov 0x127a0c,%al 1130c5: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
1130c8: c6 05 0c 7a 12 00 01 movb $0x1,0x127a0c
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
1130cf: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 1130d5: 85 c0 test %eax,%eax
1130d7: 74 24 je 1130fd <_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 );
1130d9: a1 20 7e 12 00 mov 0x127e20,%eax 1130de: 39 c3 cmp %eax,%ebx
1130e0: 74 1b je 1130fd <_Thread_Handler+0x55>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
1130e2: 85 c0 test %eax,%eax
1130e4: 74 11 je 1130f7 <_Thread_Handler+0x4f>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
1130e6: 83 ec 0c sub $0xc,%esp 1130e9: 05 e0 00 00 00 add $0xe0,%eax 1130ee: 50 push %eax 1130ef: e8 30 b9 ff ff call 10ea24 <_CPU_Context_save_fp> 1130f4: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
1130f7: 89 1d 20 7e 12 00 mov %ebx,0x127e20
/* * 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 );
1130fd: 83 ec 0c sub $0xc,%esp 113100: 53 push %ebx 113101: e8 3e b4 ff ff call 10e544 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
113106: e8 a5 a8 ff ff call 10d9b0 <_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) */ {
11310b: 83 c4 10 add $0x10,%esp 11310e: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
113112: 74 28 je 11313c <_Thread_Handler+0x94>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
113114: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 11311a: 85 c0 test %eax,%eax
11311c: 74 2d je 11314b <_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 ) {
11311e: 48 dec %eax
11311f: 74 43 je 113164 <_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 );
113121: 83 ec 0c sub $0xc,%esp 113124: 53 push %ebx 113125: e8 56 b4 ff ff call 10e580 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
11312a: 83 c4 0c add $0xc,%esp 11312d: 6a 05 push $0x5 11312f: 6a 01 push $0x1 113131: 6a 00 push $0x0 113133: e8 bc 97 ff ff call 10c8f4 <_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);
113138: fb sti 113139: eb 85 jmp 1130c0 <_Thread_Handler+0x18> 11313b: 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 ();
11313c: e8 3f c7 00 00 call 11f880 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
113141: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 113147: 85 c0 test %eax,%eax
113149: 75 d3 jne 11311e <_Thread_Handler+0x76>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
11314b: 83 ec 0c sub $0xc,%esp 11314e: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 113154: ff 93 90 00 00 00 call *0x90(%ebx)
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
11315a: 89 43 28 mov %eax,0x28(%ebx) 11315d: 83 c4 10 add $0x10,%esp 113160: eb bf jmp 113121 <_Thread_Handler+0x79> 113162: 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)(
113164: 83 ec 0c sub $0xc,%esp 113167: ff b3 98 00 00 00 pushl 0x98(%ebx) 11316d: 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 =
113173: 89 43 28 mov %eax,0x28(%ebx) 113176: 83 c4 10 add $0x10,%esp 113179: eb a6 jmp 113121 <_Thread_Handler+0x79>
0010da48 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10da48: 55 push %ebp 10da49: 89 e5 mov %esp,%ebp 10da4b: 57 push %edi 10da4c: 56 push %esi 10da4d: 53 push %ebx 10da4e: 83 ec 1c sub $0x1c,%esp 10da51: 8b 5d 0c mov 0xc(%ebp),%ebx 10da54: 8b 4d 10 mov 0x10(%ebp),%ecx 10da57: 8b 75 14 mov 0x14(%ebp),%esi 10da5a: 8b 7d 1c mov 0x1c(%ebp),%edi 10da5d: 8a 55 18 mov 0x18(%ebp),%dl 10da60: 8a 45 20 mov 0x20(%ebp),%al 10da63: 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;
10da66: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10da6d: 00 00 00
10da70: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10da77: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10da7a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10da81: 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 ) {
10da84: 85 c9 test %ecx,%ecx
10da86: 0f 84 d3 01 00 00 je 10dc5f <_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;
10da8c: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10da93: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10da95: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10da9b: 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 ) {
10daa1: 84 d2 test %dl,%dl
10daa3: 0f 85 4f 01 00 00 jne 10dbf8 <_Thread_Initialize+0x1b0>
10daa9: 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;
10daab: 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;
10dab2: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10dab8: 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;
10dabe: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10dac5: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10dacc: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10dad3: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10dada: a1 30 7e 12 00 mov 0x127e30,%eax 10dadf: 85 c0 test %eax,%eax
10dae1: 0f 85 39 01 00 00 jne 10dc20 <_Thread_Initialize+0x1d8>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dae7: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10daee: 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;
10daf1: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10daf3: 8a 45 df mov -0x21(%ebp),%al 10daf6: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10dafc: 8b 45 24 mov 0x24(%ebp),%eax 10daff: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10db05: 8b 45 28 mov 0x28(%ebp),%eax 10db08: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10db0e: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10db12: 75 08 jne 10db1c <_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;
10db14: a1 60 7d 12 00 mov 0x127d60,%eax 10db19: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10db1c: 8b 45 2c mov 0x2c(%ebp),%eax 10db1f: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10db25: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10db2c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10db33: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10db3a: 89 7b 18 mov %edi,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10db3d: 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 );
10db43: 83 ec 0c sub $0xc,%esp 10db46: 53 push %ebx 10db47: ff 15 98 39 12 00 call *0x123998 10db4d: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Allocate( the_thread ); if ( !sched )
10db50: 83 c4 10 add $0x10,%esp 10db53: 85 c0 test %eax,%eax
10db55: 74 40 je 10db97 <_Thread_Initialize+0x14f>
goto failed;
_Thread_Set_priority( the_thread, priority );
10db57: 83 ec 08 sub $0x8,%esp 10db5a: 57 push %edi 10db5b: 53 push %ebx 10db5c: e8 57 06 00 00 call 10e1b8 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10db61: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10db68: 00 00 00
10db6b: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10db72: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10db75: 8b 45 08 mov 0x8(%ebp),%eax 10db78: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10db7b: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10db7f: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10db82: 8b 45 30 mov 0x30(%ebp),%eax 10db85: 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 );
10db88: 89 1c 24 mov %ebx,(%esp) 10db8b: e8 7c 0a 00 00 call 10e60c <_User_extensions_Thread_create>
if ( extension_status )
10db90: 83 c4 10 add $0x10,%esp 10db93: 84 c0 test %al,%al
10db95: 75 55 jne 10dbec <_Thread_Initialize+0x1a4>
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10db97: 83 ec 0c sub $0xc,%esp 10db9a: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10dba0: e8 ff 0d 00 00 call 10e9a4 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10dba5: 5f pop %edi 10dba6: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10dbac: e8 f3 0d 00 00 call 10e9a4 <_Workspace_Free> 10dbb1: 59 pop %ecx 10dbb2: ff b3 ec 00 00 00 pushl 0xec(%ebx) 10dbb8: e8 e7 0d 00 00 call 10e9a4 <_Workspace_Free>
_Workspace_Free( extensions_area );
10dbbd: 89 34 24 mov %esi,(%esp) 10dbc0: e8 df 0d 00 00 call 10e9a4 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10dbc5: 5a pop %edx 10dbc6: ff 75 e0 pushl -0x20(%ebp) 10dbc9: e8 d6 0d 00 00 call 10e9a4 <_Workspace_Free>
#endif
_Workspace_Free( sched );
10dbce: 58 pop %eax 10dbcf: ff 75 e4 pushl -0x1c(%ebp) 10dbd2: e8 cd 0d 00 00 call 10e9a4 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10dbd7: 89 1c 24 mov %ebx,(%esp) 10dbda: e8 c1 06 00 00 call 10e2a0 <_Thread_Stack_Free>
return false;
10dbdf: 83 c4 10 add $0x10,%esp 10dbe2: 31 c0 xor %eax,%eax
}
10dbe4: 8d 65 f4 lea -0xc(%ebp),%esp 10dbe7: 5b pop %ebx 10dbe8: 5e pop %esi 10dbe9: 5f pop %edi 10dbea: c9 leave 10dbeb: 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;
10dbec: b0 01 mov $0x1,%al
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10dbee: 8d 65 f4 lea -0xc(%ebp),%esp 10dbf1: 5b pop %ebx 10dbf2: 5e pop %esi 10dbf3: 5f pop %edi 10dbf4: c9 leave 10dbf5: c3 ret 10dbf6: 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 );
10dbf8: 83 ec 0c sub $0xc,%esp 10dbfb: 6a 6c push $0x6c 10dbfd: e8 86 0d 00 00 call 10e988 <_Workspace_Allocate> 10dc02: 89 45 e0 mov %eax,-0x20(%ebp)
if ( !fp_area )
10dc05: 83 c4 10 add $0x10,%esp 10dc08: 85 c0 test %eax,%eax
10dc0a: 0f 85 a2 fe ff ff jne 10dab2 <_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;
10dc10: 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;
10dc12: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10dc19: e9 79 ff ff ff jmp 10db97 <_Thread_Initialize+0x14f> 10dc1e: 66 90 xchg %ax,%ax
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10dc20: 83 ec 0c sub $0xc,%esp 10dc23: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10dc2a: 50 push %eax 10dc2b: e8 58 0d 00 00 call 10e988 <_Workspace_Allocate> 10dc30: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10dc32: 83 c4 10 add $0x10,%esp 10dc35: 85 c0 test %eax,%eax
10dc37: 74 5a je 10dc93 <_Thread_Initialize+0x24b>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dc39: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) 10dc3f: 8b 0d 30 7e 12 00 mov 0x127e30,%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++ )
10dc45: 31 d2 xor %edx,%edx
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dc47: 31 c0 xor %eax,%eax 10dc49: 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;
10dc4c: 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++ )
10dc53: 40 inc %eax 10dc54: 89 c2 mov %eax,%edx 10dc56: 39 c1 cmp %eax,%ecx
10dc58: 73 f2 jae 10dc4c <_Thread_Initialize+0x204>
10dc5a: e9 94 fe ff ff jmp 10daf3 <_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 );
10dc5f: 83 ec 08 sub $0x8,%esp 10dc62: 56 push %esi 10dc63: 53 push %ebx 10dc64: 88 55 d8 mov %dl,-0x28(%ebp) 10dc67: e8 d0 05 00 00 call 10e23c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10dc6c: 83 c4 10 add $0x10,%esp 10dc6f: 85 c0 test %eax,%eax 10dc71: 8a 55 d8 mov -0x28(%ebp),%dl
10dc74: 74 16 je 10dc8c <_Thread_Initialize+0x244>
10dc76: 39 c6 cmp %eax,%esi
10dc78: 77 12 ja 10dc8c <_Thread_Initialize+0x244><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10dc7a: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10dc80: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10dc87: e9 09 fe ff ff jmp 10da95 <_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 */
10dc8c: 31 c0 xor %eax,%eax 10dc8e: e9 51 ff ff ff jmp 10dbe4 <_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;
10dc93: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10dc9a: e9 f8 fe ff ff jmp 10db97 <_Thread_Initialize+0x14f>
00112560 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
112560: 55 push %ebp 112561: 89 e5 mov %esp,%ebp 112563: 53 push %ebx 112564: 83 ec 10 sub $0x10,%esp 112567: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
11256a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
112571: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 112577: 88 43 74 mov %al,0x74(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
11257a: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 112580: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
112583: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 112589: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
11258f: 8b 45 0c mov 0xc(%ebp),%eax 112592: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
112598: 8b 45 10 mov 0x10(%ebp),%eax 11259b: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
1125a1: 53 push %ebx 1125a2: e8 f9 c5 ff ff call 10eba0 <_Thread_queue_Extract_with_proxy> 1125a7: 83 c4 10 add $0x10,%esp 1125aa: 84 c0 test %al,%al
1125ac: 75 06 jne 1125b4 <_Thread_Reset+0x54>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
1125ae: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1125b2: 74 28 je 1125dc <_Thread_Reset+0x7c>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
1125b4: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 1125ba: 39 43 14 cmp %eax,0x14(%ebx)
1125bd: 74 15 je 1125d4 <_Thread_Reset+0x74>
the_thread->real_priority = the_thread->Start.initial_priority;
1125bf: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
1125c2: 89 45 0c mov %eax,0xc(%ebp) 1125c5: 89 5d 08 mov %ebx,0x8(%ebp)
} }
1125c8: 8b 5d fc mov -0x4(%ebp),%ebx 1125cb: 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 );
1125cc: e9 ab c7 ff ff jmp 10ed7c <_Thread_Set_priority> 1125d1: 8d 76 00 lea 0x0(%esi),%esi
} }
1125d4: 8b 5d fc mov -0x4(%ebp),%ebx 1125d7: c9 leave 1125d8: c3 ret 1125d9: 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 );
1125dc: 83 ec 0c sub $0xc,%esp 1125df: 8d 43 48 lea 0x48(%ebx),%eax 1125e2: 50 push %eax 1125e3: e8 7c ce ff ff call 10f464 <_Watchdog_Remove> 1125e8: 83 c4 10 add $0x10,%esp 1125eb: eb c7 jmp 1125b4 <_Thread_Reset+0x54>
001114f0 <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
1114f0: 55 push %ebp 1114f1: 89 e5 mov %esp,%ebp 1114f3: 53 push %ebx 1114f4: 83 ec 04 sub $0x4,%esp 1114f7: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
1114fa: 9c pushf 1114fb: fa cli 1114fc: 5b pop %ebx
current_state = the_thread->current_state;
1114fd: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
111500: f6 c2 02 test $0x2,%dl
111503: 74 0a je 11150f <_Thread_Resume+0x1f> <== NEVER TAKEN
111505: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
111508: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
11150b: 85 d2 test %edx,%edx
11150d: 74 09 je 111518 <_Thread_Resume+0x28>
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
11150f: 53 push %ebx 111510: 9d popf
}
111511: 8b 5d fc mov -0x4(%ebp),%ebx 111514: c9 leave 111515: c3 ret 111516: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
111518: 83 ec 0c sub $0xc,%esp 11151b: 50 push %eax 11151c: ff 15 74 72 12 00 call *0x127274 111522: 83 c4 10 add $0x10,%esp 111525: eb e8 jmp 11150f <_Thread_Resume+0x1f>
0010e23c <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10e23c: 55 push %ebp 10e23d: 89 e5 mov %esp,%ebp 10e23f: 53 push %ebx 10e240: 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;
10e243: a1 70 3a 12 00 mov 0x123a70,%eax 10e248: 8b 5d 0c mov 0xc(%ebp),%ebx 10e24b: 39 c3 cmp %eax,%ebx
10e24d: 73 02 jae 10e251 <_Thread_Stack_Allocate+0x15>
10e24f: 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 ) {
10e251: a1 a0 3a 12 00 mov 0x123aa0,%eax 10e256: 85 c0 test %eax,%eax
10e258: 74 32 je 10e28c <_Thread_Stack_Allocate+0x50>
stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size );
10e25a: 83 ec 0c sub $0xc,%esp 10e25d: 53 push %ebx 10e25e: ff d0 call *%eax 10e260: 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 )
10e263: 85 c0 test %eax,%eax
10e265: 74 11 je 10e278 <_Thread_Stack_Allocate+0x3c>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10e267: 8b 55 08 mov 0x8(%ebp),%edx 10e26a: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10e270: 89 d8 mov %ebx,%eax 10e272: 8b 5d fc mov -0x4(%ebp),%ebx 10e275: c9 leave 10e276: c3 ret 10e277: 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;
10e278: 31 db xor %ebx,%ebx
the_thread->Start.stack = stack_addr;
10e27a: 8b 55 08 mov 0x8(%ebp),%edx 10e27d: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10e283: 89 d8 mov %ebx,%eax 10e285: 8b 5d fc mov -0x4(%ebp),%ebx 10e288: c9 leave 10e289: c3 ret 10e28a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size (
size_t size
)
{
return size + CPU_STACK_ALIGNMENT;
10e28c: 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 );
10e28f: 83 ec 0c sub $0xc,%esp 10e292: 53 push %ebx 10e293: e8 f0 06 00 00 call 10e988 <_Workspace_Allocate> 10e298: 83 c4 10 add $0x10,%esp 10e29b: eb c6 jmp 10e263 <_Thread_Stack_Allocate+0x27>
0010e2a0 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10e2a0: 55 push %ebp 10e2a1: 89 e5 mov %esp,%ebp 10e2a3: 83 ec 08 sub $0x8,%esp 10e2a6: 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 )
10e2a9: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax)
10e2b0: 74 16 je 10e2c8 <_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 )
10e2b2: 8b 15 a4 3a 12 00 mov 0x123aa4,%edx 10e2b8: 85 d2 test %edx,%edx
10e2ba: 74 10 je 10e2cc <_Thread_Stack_Free+0x2c>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10e2bc: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e2c2: 89 45 08 mov %eax,0x8(%ebp)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e2c5: 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 );
10e2c6: ff e2 jmp *%edx
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e2c8: c9 leave 10e2c9: c3 ret 10e2ca: 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 );
10e2cc: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax 10e2d2: 89 45 08 mov %eax,0x8(%ebp)
}
10e2d5: 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 );
10e2d6: e9 c9 06 00 00 jmp 10e9a4 <_Workspace_Free>
001118d8 <_Thread_Suspend>:
* select map
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
1118d8: 55 push %ebp 1118d9: 89 e5 mov %esp,%ebp 1118db: 53 push %ebx 1118dc: 83 ec 04 sub $0x4,%esp 1118df: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
_ISR_Disable( level );
1118e2: 9c pushf 1118e3: fa cli 1118e4: 5b pop %ebx
if ( !_States_Is_ready( the_thread->current_state ) ) {
1118e5: 8b 50 10 mov 0x10(%eax),%edx 1118e8: 85 d2 test %edx,%edx
1118ea: 74 10 je 1118fc <_Thread_Suspend+0x24>
1118ec: 83 ca 02 or $0x2,%edx 1118ef: 89 50 10 mov %edx,0x10(%eax)
the_thread->current_state =
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
1118f2: 53 push %ebx 1118f3: 9d popf
the_thread->current_state = STATES_SUSPENDED;
_Scheduler_Block( the_thread );
_ISR_Enable( level );
}
1118f4: 8b 5d fc mov -0x4(%ebp),%ebx 1118f7: c9 leave 1118f8: c3 ret 1118f9: 8d 76 00 lea 0x0(%esi),%esi
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
1118fc: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax)
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Block(
Thread_Control *the_thread
)
{
_Scheduler.Operations.block( the_thread );
111903: 83 ec 0c sub $0xc,%esp 111906: 50 push %eax 111907: ff 15 90 39 12 00 call *0x123990
_Scheduler_Block( the_thread );
_ISR_Enable( level );
11190d: 53 push %ebx 11190e: 9d popf 11190f: 83 c4 10 add $0x10,%esp
}
111912: 8b 5d fc mov -0x4(%ebp),%ebx 111915: c9 leave 111916: c3 ret
0010e398 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10e398: 55 push %ebp 10e399: 89 e5 mov %esp,%ebp 10e39b: 53 push %ebx 10e39c: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10e39f: 8b 1d 38 83 12 00 mov 0x128338,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10e3a5: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10e3a9: 74 19 je 10e3c4 <_Thread_Tickle_timeslice+0x2c>
return;
if ( !_States_Is_ready( executing->current_state ) )
10e3ab: 8b 43 10 mov 0x10(%ebx),%eax 10e3ae: 85 c0 test %eax,%eax
10e3b0: 75 12 jne 10e3c4 <_Thread_Tickle_timeslice+0x2c>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10e3b2: 8b 43 7c mov 0x7c(%ebx),%eax 10e3b5: 83 f8 01 cmp $0x1,%eax
10e3b8: 72 0a jb 10e3c4 <_Thread_Tickle_timeslice+0x2c>
10e3ba: 83 f8 02 cmp $0x2,%eax
10e3bd: 76 29 jbe 10e3e8 <_Thread_Tickle_timeslice+0x50>
10e3bf: 83 f8 03 cmp $0x3,%eax
10e3c2: 74 08 je 10e3cc <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
10e3c4: 8b 5d fc mov -0x4(%ebp),%ebx 10e3c7: c9 leave 10e3c8: c3 ret 10e3c9: 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 )
10e3cc: 8b 43 78 mov 0x78(%ebx),%eax 10e3cf: 48 dec %eax 10e3d0: 89 43 78 mov %eax,0x78(%ebx) 10e3d3: 85 c0 test %eax,%eax
10e3d5: 75 ed jne 10e3c4 <_Thread_Tickle_timeslice+0x2c> (*executing->budget_callout)( executing );
10e3d7: 83 ec 0c sub $0xc,%esp 10e3da: 53 push %ebx 10e3db: ff 93 80 00 00 00 call *0x80(%ebx) 10e3e1: 83 c4 10 add $0x10,%esp 10e3e4: eb de jmp 10e3c4 <_Thread_Tickle_timeslice+0x2c> 10e3e6: 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 ) {
10e3e8: 8b 43 78 mov 0x78(%ebx),%eax 10e3eb: 48 dec %eax 10e3ec: 89 43 78 mov %eax,0x78(%ebx) 10e3ef: 85 c0 test %eax,%eax
10e3f1: 7f d1 jg 10e3c4 <_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();
10e3f3: ff 15 8c 39 12 00 call *0x12398c
* 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;
10e3f9: a1 60 7d 12 00 mov 0x127d60,%eax 10e3fe: 89 43 78 mov %eax,0x78(%ebx) 10e401: eb c1 jmp 10e3c4 <_Thread_Tickle_timeslice+0x2c>
0010dd78 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10dd78: 55 push %ebp 10dd79: 89 e5 mov %esp,%ebp 10dd7b: 57 push %edi 10dd7c: 56 push %esi 10dd7d: 53 push %ebx 10dd7e: 83 ec 2c sub $0x2c,%esp 10dd81: 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 );
10dd84: 9c pushf 10dd85: fa cli 10dd86: 58 pop %eax 10dd87: 89 f9 mov %edi,%ecx
for( index=0 ;
10dd89: 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 );
}
10dd8b: 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 );
10dd8d: 8d 34 52 lea (%edx,%edx,2),%esi 10dd90: 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 ] ) ) {
10dd94: 39 f3 cmp %esi,%ebx
10dd96: 75 18 jne 10ddb0 <_Thread_queue_Dequeue_priority+0x38>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10dd98: 42 inc %edx 10dd99: 83 c1 0c add $0xc,%ecx
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
10dd9c: 83 fa 04 cmp $0x4,%edx
10dd9f: 75 ea jne 10dd8b <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10dda1: 50 push %eax 10dda2: 9d popf
return NULL;
10dda3: 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 );
}
10dda5: 89 f0 mov %esi,%eax 10dda7: 8d 65 f4 lea -0xc(%ebp),%esp 10ddaa: 5b pop %ebx 10ddab: 5e pop %esi 10ddac: 5f pop %edi 10ddad: c9 leave 10ddae: c3 ret 10ddaf: 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(
10ddb0: 89 de mov %ebx,%esi
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10ddb2: 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 );
}
10ddb9: 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;
10ddbc: 8b 0b mov (%ebx),%ecx
previous_node = the_thread->Object.Node.previous;
10ddbe: 8b 7b 04 mov 0x4(%ebx),%edi 10ddc1: 89 7d d4 mov %edi,-0x2c(%ebp) 10ddc4: 8d 7b 3c lea 0x3c(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10ddc7: 39 fa cmp %edi,%edx
10ddc9: 74 7f je 10de4a <_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 );
}
10ddcb: 8b 7b 40 mov 0x40(%ebx),%edi 10ddce: 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;
10ddd1: 8b 3a mov (%edx),%edi 10ddd3: 89 7d e0 mov %edi,-0x20(%ebp)
previous_node->next = new_first_node;
10ddd6: 8b 7d d4 mov -0x2c(%ebp),%edi 10ddd9: 89 17 mov %edx,(%edi)
next_node->previous = new_first_node;
10dddb: 89 51 04 mov %edx,0x4(%ecx)
new_first_node->next = next_node;
10ddde: 89 0a mov %ecx,(%edx)
new_first_node->previous = previous_node;
10dde0: 89 7a 04 mov %edi,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10dde3: 8b 4b 40 mov 0x40(%ebx),%ecx 10dde6: 39 4b 38 cmp %ecx,0x38(%ebx)
10dde9: 74 17 je 10de02 <_Thread_queue_Dequeue_priority+0x8a>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
10ddeb: 8d 4a 38 lea 0x38(%edx),%ecx 10ddee: 8b 7d e0 mov -0x20(%ebp),%edi 10ddf1: 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;
10ddf4: 89 7a 38 mov %edi,0x38(%edx)
tail->previous = last_node;
10ddf7: 8b 4d e4 mov -0x1c(%ebp),%ecx 10ddfa: 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 );
10ddfd: 83 c2 3c add $0x3c,%edx 10de00: 89 11 mov %edx,(%ecx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10de02: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10de06: 74 18 je 10de20 <_Thread_queue_Dequeue_priority+0xa8>
_ISR_Enable( level );
10de08: 50 push %eax 10de09: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10de0a: 83 ec 08 sub $0x8,%esp 10de0d: 68 f8 ff 03 10 push $0x1003fff8 10de12: 53 push %ebx 10de13: e8 34 f8 ff ff call 10d64c <_Thread_Clear_state> 10de18: 83 c4 10 add $0x10,%esp 10de1b: eb 88 jmp 10dda5 <_Thread_queue_Dequeue_priority+0x2d> 10de1d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10de20: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10de27: 50 push %eax 10de28: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10de29: 83 ec 0c sub $0xc,%esp 10de2c: 8d 43 48 lea 0x48(%ebx),%eax 10de2f: 50 push %eax 10de30: e8 2b 0a 00 00 call 10e860 <_Watchdog_Remove> 10de35: 58 pop %eax 10de36: 5a pop %edx 10de37: 68 f8 ff 03 10 push $0x1003fff8 10de3c: 53 push %ebx 10de3d: e8 0a f8 ff ff call 10d64c <_Thread_Clear_state> 10de42: 83 c4 10 add $0x10,%esp 10de45: e9 5b ff ff ff jmp 10dda5 <_Thread_queue_Dequeue_priority+0x2d>
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
10de4a: 8b 7d d4 mov -0x2c(%ebp),%edi 10de4d: 89 0f mov %ecx,(%edi)
next_node->previous = previous_node;
10de4f: 89 79 04 mov %edi,0x4(%ecx) 10de52: eb ae jmp 10de02 <_Thread_queue_Dequeue_priority+0x8a>
0010deec <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
10deec: 55 push %ebp 10deed: 89 e5 mov %esp,%ebp 10deef: 57 push %edi 10def0: 56 push %esi 10def1: 53 push %ebx 10def2: 83 ec 0c sub $0xc,%esp 10def5: 8b 7d 0c mov 0xc(%ebp),%edi
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10def8: 8d 47 3c lea 0x3c(%edi),%eax 10defb: 89 47 38 mov %eax,0x38(%edi)
head->next = tail;
head->previous = NULL;
10defe: c7 47 3c 00 00 00 00 movl $0x0,0x3c(%edi)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10df05: 8d 47 38 lea 0x38(%edi),%eax 10df08: 89 47 40 mov %eax,0x40(%edi)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10df0b: 8b 57 14 mov 0x14(%edi),%edx
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
10df0e: 89 d0 mov %edx,%eax 10df10: c1 e8 06 shr $0x6,%eax
header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state;
10df13: 8b 4d 08 mov 0x8(%ebp),%ecx 10df16: 8b 59 38 mov 0x38(%ecx),%ebx
if ( _Thread_queue_Is_reverse_search( priority ) )
10df19: f6 c2 20 test $0x20,%dl
10df1c: 75 66 jne 10df84 <_Thread_queue_Enqueue_priority+0x98> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10df1e: 8d 04 40 lea (%eax,%eax,2),%eax 10df21: 8d 04 81 lea (%ecx,%eax,4),%eax 10df24: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10df27: 83 c0 04 add $0x4,%eax 10df2a: 89 7d e8 mov %edi,-0x18(%ebp) 10df2d: 89 c7 mov %eax,%edi
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10df2f: 9c pushf 10df30: fa cli 10df31: 5e pop %esi 10df32: 89 75 ec mov %esi,-0x14(%ebp)
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10df35: 8b 4d f0 mov -0x10(%ebp),%ecx 10df38: 8b 01 mov (%ecx),%eax
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10df3a: 39 f8 cmp %edi,%eax
10df3c: 75 18 jne 10df56 <_Thread_queue_Enqueue_priority+0x6a>
10df3e: e9 0e 01 00 00 jmp 10e051 <_Thread_queue_Enqueue_priority+0x165> 10df43: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10df44: 56 push %esi 10df45: 9d popf 10df46: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10df47: 85 58 10 test %ebx,0x10(%eax)
10df4a: 0f 84 ac 00 00 00 je 10dffc <_Thread_queue_Enqueue_priority+0x110>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10df50: 8b 00 mov (%eax),%eax
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10df52: 39 f8 cmp %edi,%eax
10df54: 74 07 je 10df5d <_Thread_queue_Enqueue_priority+0x71>
search_priority = search_thread->current_priority;
10df56: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority <= search_priority )
10df59: 39 ca cmp %ecx,%edx
10df5b: 77 e7 ja 10df44 <_Thread_queue_Enqueue_priority+0x58>
10df5d: 8b 7d e8 mov -0x18(%ebp),%edi 10df60: 89 75 f0 mov %esi,-0x10(%ebp)
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10df63: 8b 75 08 mov 0x8(%ebp),%esi 10df66: 8b 5e 30 mov 0x30(%esi),%ebx 10df69: 83 fb 01 cmp $0x1,%ebx
10df6c: 0f 84 92 00 00 00 je 10e004 <_Thread_queue_Enqueue_priority+0x118> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
10df72: 8b 45 10 mov 0x10(%ebp),%eax 10df75: 8b 55 ec mov -0x14(%ebp),%edx 10df78: 89 10 mov %edx,(%eax)
return the_thread_queue->sync_state; }
10df7a: 89 d8 mov %ebx,%eax 10df7c: 83 c4 0c add $0xc,%esp 10df7f: 5b pop %ebx 10df80: 5e pop %esi 10df81: 5f pop %edi 10df82: c9 leave 10df83: c3 ret 10df84: 8d 04 40 lea (%eax,%eax,2),%eax 10df87: 8b 4d 08 mov 0x8(%ebp),%ecx 10df8a: 8d 34 81 lea (%ecx,%eax,4),%esi 10df8d: 89 7d f0 mov %edi,-0x10(%ebp)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10df90: 0f b6 0d 74 3a 12 00 movzbl 0x123a74,%ecx 10df97: 41 inc %ecx
_ISR_Disable( level );
10df98: 9c pushf 10df99: fa cli 10df9a: 5f pop %edi 10df9b: 89 7d ec mov %edi,-0x14(%ebp)
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10df9e: 8b 46 08 mov 0x8(%esi),%eax
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10dfa1: 39 f0 cmp %esi,%eax
10dfa3: 75 12 jne 10dfb7 <_Thread_queue_Enqueue_priority+0xcb>
10dfa5: eb 17 jmp 10dfbe <_Thread_queue_Enqueue_priority+0xd2> 10dfa7: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10dfa8: 57 push %edi 10dfa9: 9d popf 10dfaa: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10dfab: 85 58 10 test %ebx,0x10(%eax)
10dfae: 74 48 je 10dff8 <_Thread_queue_Enqueue_priority+0x10c><== NEVER TAKEN
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10dfb0: 8b 40 04 mov 0x4(%eax),%eax
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10dfb3: 39 f0 cmp %esi,%eax
10dfb5: 74 07 je 10dfbe <_Thread_queue_Enqueue_priority+0xd2>
search_priority = search_thread->current_priority;
10dfb7: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority >= search_priority )
10dfba: 39 ca cmp %ecx,%edx
10dfbc: 72 ea jb 10dfa8 <_Thread_queue_Enqueue_priority+0xbc>
10dfbe: 89 7d e8 mov %edi,-0x18(%ebp) 10dfc1: 8b 7d f0 mov -0x10(%ebp),%edi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10dfc4: 8b 75 08 mov 0x8(%ebp),%esi 10dfc7: 8b 5e 30 mov 0x30(%esi),%ebx 10dfca: 83 fb 01 cmp $0x1,%ebx
10dfcd: 75 a3 jne 10df72 <_Thread_queue_Enqueue_priority+0x86>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10dfcf: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10dfd6: 39 ca cmp %ecx,%edx
10dfd8: 74 53 je 10e02d <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10dfda: 8b 10 mov (%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10dfdc: 89 17 mov %edx,(%edi)
the_node->previous = search_node;
10dfde: 89 47 04 mov %eax,0x4(%edi)
search_node->next = the_node;
10dfe1: 89 38 mov %edi,(%eax)
next_node->previous = the_node;
10dfe3: 89 7a 04 mov %edi,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10dfe6: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10dfe9: ff 75 e8 pushl -0x18(%ebp) 10dfec: 9d popf
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10dfed: 89 d8 mov %ebx,%eax 10dfef: 83 c4 0c add $0xc,%esp 10dff2: 5b pop %ebx 10dff3: 5e pop %esi 10dff4: 5f pop %edi 10dff5: c9 leave 10dff6: c3 ret 10dff7: 90 nop
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10dff8: 57 push %edi <== NOT EXECUTED 10dff9: 9d popf <== NOT EXECUTED
goto restart_reverse_search;
10dffa: eb 94 jmp 10df90 <_Thread_queue_Enqueue_priority+0xa4><== NOT EXECUTED
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10dffc: 56 push %esi 10dffd: 9d popf
goto restart_forward_search;
10dffe: e9 2c ff ff ff jmp 10df2f <_Thread_queue_Enqueue_priority+0x43> 10e003: 90 nop
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10e004: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10e00b: 39 ca cmp %ecx,%edx
10e00d: 74 1e je 10e02d <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10e00f: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10e012: 89 07 mov %eax,(%edi)
the_node->previous = previous_node;
10e014: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10e017: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10e019: 89 78 04 mov %edi,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10e01c: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10e01f: ff 75 f0 pushl -0x10(%ebp) 10e022: 9d popf
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10e023: 89 d8 mov %ebx,%eax 10e025: 83 c4 0c add $0xc,%esp 10e028: 5b pop %ebx 10e029: 5e pop %esi 10e02a: 5f pop %edi 10e02b: c9 leave 10e02c: c3 ret
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10e02d: 8b 50 40 mov 0x40(%eax),%edx
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
10e030: 8d 48 3c lea 0x3c(%eax),%ecx 10e033: 89 0f mov %ecx,(%edi)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
10e035: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10e038: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10e03a: 89 78 40 mov %edi,0x40(%eax)
the_thread->Wait.queue = the_thread_queue;
10e03d: 8b 45 08 mov 0x8(%ebp),%eax 10e040: 89 47 44 mov %eax,0x44(%edi)
_ISR_Enable( level );
10e043: ff 75 ec pushl -0x14(%ebp) 10e046: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10e047: bb 01 00 00 00 mov $0x1,%ebx 10e04c: e9 29 ff ff ff jmp 10df7a <_Thread_queue_Enqueue_priority+0x8e> 10e051: 8b 7d e8 mov -0x18(%ebp),%edi 10e054: 89 75 f0 mov %esi,-0x10(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10e057: b9 ff ff ff ff mov $0xffffffff,%ecx 10e05c: e9 02 ff ff ff jmp 10df63 <_Thread_queue_Enqueue_priority+0x77>
00111780 <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
111780: 55 push %ebp 111781: 89 e5 mov %esp,%ebp 111783: 83 ec 08 sub $0x8,%esp 111786: 8b 45 08 mov 0x8(%ebp),%eax 111789: 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 )
11178c: 83 78 34 01 cmpl $0x1,0x34(%eax)
111790: 74 0e je 1117a0 <_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 );
111792: 89 55 0c mov %edx,0xc(%ebp) 111795: 89 45 08 mov %eax,0x8(%ebp)
}
111798: 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 );
111799: e9 de 19 00 00 jmp 11317c <_Thread_queue_Extract_fifo> 11179e: 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 );
1117a0: 51 push %ecx 1117a1: 6a 00 push $0x0 1117a3: 52 push %edx 1117a4: 50 push %eax 1117a5: e8 06 00 00 00 call 1117b0 <_Thread_queue_Extract_priority_helper> 1117aa: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
1117ad: c9 leave 1117ae: c3 ret
0011317c <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
11317c: 55 push %ebp 11317d: 89 e5 mov %esp,%ebp 11317f: 53 push %ebx 113180: 83 ec 04 sub $0x4,%esp 113183: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
113186: 9c pushf 113187: fa cli 113188: 58 pop %eax
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
113189: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
113190: 74 2e je 1131c0 <_Thread_queue_Extract_fifo+0x44>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
113192: 8b 0b mov (%ebx),%ecx
previous = the_node->previous;
113194: 8b 53 04 mov 0x4(%ebx),%edx
next->previous = previous;
113197: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
11319a: 89 0a mov %ecx,(%edx)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
11319c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
1131a3: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1131a7: 74 1f je 1131c8 <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
1131a9: 50 push %eax 1131aa: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
1131ab: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 1131b2: 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
}
1131b5: 8b 5d fc mov -0x4(%ebp),%ebx 1131b8: c9 leave 1131b9: e9 8e a4 ff ff jmp 10d64c <_Thread_Clear_state> 1131be: 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 );
1131c0: 50 push %eax 1131c1: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1131c2: 8b 5d fc mov -0x4(%ebp),%ebx 1131c5: c9 leave 1131c6: c3 ret 1131c7: 90 nop 1131c8: 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 );
1131cf: 50 push %eax 1131d0: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
1131d1: 83 ec 0c sub $0xc,%esp 1131d4: 8d 43 48 lea 0x48(%ebx),%eax 1131d7: 50 push %eax 1131d8: e8 83 b6 ff ff call 10e860 <_Watchdog_Remove> 1131dd: 83 c4 10 add $0x10,%esp 1131e0: eb c9 jmp 1131ab <_Thread_queue_Extract_fifo+0x2f>
001117b0 <_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
)
{
1117b0: 55 push %ebp 1117b1: 89 e5 mov %esp,%ebp 1117b3: 57 push %edi 1117b4: 56 push %esi 1117b5: 53 push %ebx 1117b6: 83 ec 1c sub $0x1c,%esp 1117b9: 8b 5d 0c mov 0xc(%ebp),%ebx 1117bc: 8a 45 10 mov 0x10(%ebp),%al 1117bf: 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 );
1117c2: 9c pushf 1117c3: fa cli 1117c4: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
1117c7: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
1117ce: 74 6c je 11183c <_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;
1117d0: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
1117d2: 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
}
1117d5: 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 );
1117d8: 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 ) ) {
1117db: 39 f0 cmp %esi,%eax
1117dd: 74 69 je 111848 <_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
}
1117df: 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;
1117e2: 8b 30 mov (%eax),%esi
previous_node->next = new_first_node;
1117e4: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
1117e6: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
1117e9: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
1117eb: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
1117ee: 8b 53 40 mov 0x40(%ebx),%edx 1117f1: 39 53 38 cmp %edx,0x38(%ebx)
1117f4: 74 11 je 111807 <_Thread_queue_Extract_priority_helper+0x57>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
1117f6: 8d 50 38 lea 0x38(%eax),%edx 1117f9: 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;
1117fc: 89 70 38 mov %esi,0x38(%eax)
tail->previous = last_node;
1117ff: 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 );
111802: 83 c0 3c add $0x3c,%eax 111805: 89 07 mov %eax,(%edi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
111807: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
11180b: 75 23 jne 111830 <_Thread_queue_Extract_priority_helper+0x80>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
11180d: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
111811: 74 3d je 111850 <_Thread_queue_Extract_priority_helper+0xa0>
_ISR_Enable( level );
111813: ff 75 e4 pushl -0x1c(%ebp) 111816: 9d popf 111817: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 11181e: 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
}
111821: 8d 65 f4 lea -0xc(%ebp),%esp 111824: 5b pop %ebx 111825: 5e pop %esi 111826: 5f pop %edi 111827: c9 leave 111828: e9 1f be ff ff jmp 10d64c <_Thread_Clear_state> 11182d: 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 );
111830: ff 75 e4 pushl -0x1c(%ebp) 111833: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111834: 8d 65 f4 lea -0xc(%ebp),%esp 111837: 5b pop %ebx 111838: 5e pop %esi 111839: 5f pop %edi 11183a: c9 leave 11183b: 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 );
11183c: ff 75 e4 pushl -0x1c(%ebp) 11183f: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111840: 8d 65 f4 lea -0xc(%ebp),%esp 111843: 5b pop %ebx 111844: 5e pop %esi 111845: 5f pop %edi 111846: c9 leave 111847: c3 ret
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
111848: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
11184a: 89 4a 04 mov %ecx,0x4(%edx) 11184d: eb b8 jmp 111807 <_Thread_queue_Extract_priority_helper+0x57> 11184f: 90 nop 111850: 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 );
111857: ff 75 e4 pushl -0x1c(%ebp) 11185a: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
11185b: 83 ec 0c sub $0xc,%esp 11185e: 8d 43 48 lea 0x48(%ebx),%eax 111861: 50 push %eax 111862: e8 f9 cf ff ff call 10e860 <_Watchdog_Remove> 111867: 83 c4 10 add $0x10,%esp 11186a: eb ab jmp 111817 <_Thread_queue_Extract_priority_helper+0x67>
0010e064 <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10e064: 55 push %ebp 10e065: 89 e5 mov %esp,%ebp 10e067: 83 ec 08 sub $0x8,%esp 10e06a: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10e06d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10e074: 75 06 jne 10e07c <_Thread_queue_Extract_with_proxy+0x18>
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return true;
}
return false;
10e076: 31 c0 xor %eax,%eax
}
10e078: c9 leave 10e079: c3 ret 10e07a: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10e07c: 83 ec 08 sub $0x8,%esp 10e07f: 50 push %eax 10e080: ff 70 44 pushl 0x44(%eax) 10e083: e8 f8 36 00 00 call 111780 <_Thread_queue_Extract>
return true;
10e088: 83 c4 10 add $0x10,%esp 10e08b: b0 01 mov $0x1,%al
} return false; }
10e08d: c9 leave 10e08e: c3 ret
0010febc <_Thread_queue_First>:
*/
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue
)
{
10febc: 55 push %ebp 10febd: 89 e5 mov %esp,%ebp 10febf: 83 ec 08 sub $0x8,%esp 10fec2: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
10fec5: 83 78 34 01 cmpl $0x1,0x34(%eax)
10fec9: 74 0d je 10fed8 <_Thread_queue_First+0x1c>
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
10fecb: ba 04 37 11 00 mov $0x113704,%edx
return (*first_p)( the_thread_queue );
10fed0: 89 45 08 mov %eax,0x8(%ebp)
}
10fed3: 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 );
10fed4: ff e2 jmp *%edx 10fed6: 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;
10fed8: ba e4 fe 10 00 mov $0x10fee4,%edx
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
10fedd: 89 45 08 mov %eax,0x8(%ebp)
}
10fee0: 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 );
10fee1: ff e2 jmp *%edx
00113704 <_Thread_queue_First_fifo>:
*/
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
113704: 55 push %ebp 113705: 89 e5 mov %esp,%ebp 113707: 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;
}
11370a: 8b 02 mov (%edx),%eax 11370c: 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 ) )
11370f: 39 d0 cmp %edx,%eax
113711: 74 05 je 113718 <_Thread_queue_First_fifo+0x14>
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
113713: c9 leave 113714: c3 ret 113715: 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;
113718: 31 c0 xor %eax,%eax
}
11371a: c9 leave 11371b: c3 ret
0010e090 <_Thread_queue_Flush>:
#else
Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)),
#endif
uint32_t status
)
{
10e090: 55 push %ebp 10e091: 89 e5 mov %esp,%ebp 10e093: 56 push %esi 10e094: 53 push %ebx 10e095: 8b 5d 08 mov 0x8(%ebp),%ebx 10e098: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10e09b: eb 06 jmp 10e0a3 <_Thread_queue_Flush+0x13> 10e09d: 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;
10e0a0: 89 70 34 mov %esi,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10e0a3: 83 ec 0c sub $0xc,%esp 10e0a6: 53 push %ebx 10e0a7: e8 80 fc ff ff call 10dd2c <_Thread_queue_Dequeue> 10e0ac: 83 c4 10 add $0x10,%esp 10e0af: 85 c0 test %eax,%eax
10e0b1: 75 ed jne 10e0a0 <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10e0b3: 8d 65 f8 lea -0x8(%ebp),%esp 10e0b6: 5b pop %ebx 10e0b7: 5e pop %esi 10e0b8: c9 leave 10e0b9: c3 ret
0010e0bc <_Thread_queue_Initialize>:
Thread_queue_Control *the_thread_queue,
Thread_queue_Disciplines the_discipline,
States_Control state,
uint32_t timeout_status
)
{
10e0bc: 55 push %ebp 10e0bd: 89 e5 mov %esp,%ebp 10e0bf: 56 push %esi 10e0c0: 53 push %ebx 10e0c1: 8b 45 08 mov 0x8(%ebp),%eax 10e0c4: 8b 55 0c mov 0xc(%ebp),%edx
the_thread_queue->state = state;
10e0c7: 8b 4d 10 mov 0x10(%ebp),%ecx 10e0ca: 89 48 38 mov %ecx,0x38(%eax)
the_thread_queue->discipline = the_discipline;
10e0cd: 89 50 34 mov %edx,0x34(%eax)
the_thread_queue->timeout_status = timeout_status;
10e0d0: 8b 4d 14 mov 0x14(%ebp),%ecx 10e0d3: 89 48 3c mov %ecx,0x3c(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10e0d6: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10e0dd: 83 fa 01 cmp $0x1,%edx
10e0e0: 74 16 je 10e0f8 <_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 );
10e0e2: 8d 50 04 lea 0x4(%eax),%edx 10e0e5: 89 10 mov %edx,(%eax)
head->next = tail;
head->previous = NULL;
10e0e7: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10e0ee: 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 );
}
}
10e0f1: 5b pop %ebx 10e0f2: 5e pop %esi 10e0f3: c9 leave 10e0f4: c3 ret 10e0f5: 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 ) {
10e0f8: 89 c1 mov %eax,%ecx 10e0fa: 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 );
10e0fc: 8d 1c 52 lea (%edx,%edx,2),%ebx 10e0ff: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10e102: 8d 73 04 lea 0x4(%ebx),%esi 10e105: 89 31 mov %esi,(%ecx)
head->next = tail;
head->previous = NULL;
10e107: 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 );
10e10e: 89 59 08 mov %ebx,0x8(%ecx)
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++)
10e111: 42 inc %edx 10e112: 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 ;
10e115: 83 fa 04 cmp $0x4,%edx
10e118: 75 e2 jne 10e0fc <_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 );
}
}
10e11a: 5b pop %ebx 10e11b: 5e pop %esi 10e11c: c9 leave 10e11d: c3 ret
0011186c <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
11186c: 55 push %ebp 11186d: 89 e5 mov %esp,%ebp 11186f: 83 ec 08 sub $0x8,%esp 111872: 8b 45 08 mov 0x8(%ebp),%eax
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
111875: 8b 50 44 mov 0x44(%eax),%edx
* 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.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
111878: 8b 4a 30 mov 0x30(%edx),%ecx 11187b: 85 c9 test %ecx,%ecx
11187d: 74 08 je 111887 <_Thread_queue_Process_timeout+0x1b>
11187f: 3b 05 38 83 12 00 cmp 0x128338,%eax
111885: 74 15 je 11189c <_Thread_queue_Process_timeout+0x30><== ALWAYS TAKEN
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
111887: 8b 4a 3c mov 0x3c(%edx),%ecx 11188a: 89 48 34 mov %ecx,0x34(%eax)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
11188d: 83 ec 08 sub $0x8,%esp 111890: 50 push %eax 111891: 52 push %edx 111892: e8 e9 fe ff ff call 111780 <_Thread_queue_Extract> 111897: 83 c4 10 add $0x10,%esp
} }
11189a: c9 leave 11189b: c3 ret
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
11189c: 83 f9 03 cmp $0x3,%ecx
11189f: 74 f9 je 11189a <_Thread_queue_Process_timeout+0x2e>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
1118a1: 8b 4a 3c mov 0x3c(%edx),%ecx 1118a4: 89 48 34 mov %ecx,0x34(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
1118a7: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
}
}
1118ae: c9 leave 1118af: c3 ret
0010e120 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10e120: 55 push %ebp 10e121: 89 e5 mov %esp,%ebp 10e123: 57 push %edi 10e124: 56 push %esi 10e125: 53 push %ebx 10e126: 83 ec 1c sub $0x1c,%esp 10e129: 8b 75 08 mov 0x8(%ebp),%esi 10e12c: 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 )
10e12f: 85 f6 test %esi,%esi
10e131: 74 06 je 10e139 <_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 ) {
10e133: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10e137: 74 0b je 10e144 <_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 );
}
}
10e139: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e13c: 5b pop %ebx <== NOT EXECUTED 10e13d: 5e pop %esi <== NOT EXECUTED 10e13e: 5f pop %edi <== NOT EXECUTED 10e13f: c9 leave <== NOT EXECUTED 10e140: c3 ret <== NOT EXECUTED 10e141: 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 );
10e144: 9c pushf 10e145: fa cli 10e146: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10e147: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10e14e: 75 0c jne 10e15c <_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 );
10e150: 53 push %ebx 10e151: 9d popf
} }
10e152: 8d 65 f4 lea -0xc(%ebp),%esp 10e155: 5b pop %ebx 10e156: 5e pop %esi 10e157: 5f pop %edi 10e158: c9 leave 10e159: c3 ret 10e15a: 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;
10e15c: 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 );
10e163: 50 push %eax 10e164: 6a 01 push $0x1 10e166: 57 push %edi 10e167: 56 push %esi 10e168: e8 43 36 00 00 call 1117b0 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10e16d: 83 c4 0c add $0xc,%esp 10e170: 8d 45 e4 lea -0x1c(%ebp),%eax 10e173: 50 push %eax 10e174: 57 push %edi 10e175: 56 push %esi 10e176: e8 71 fd ff ff call 10deec <_Thread_queue_Enqueue_priority> 10e17b: 83 c4 10 add $0x10,%esp 10e17e: eb d0 jmp 10e150 <_Thread_queue_Requeue+0x30>
0010e180 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10e180: 55 push %ebp 10e181: 89 e5 mov %esp,%ebp 10e183: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e186: 8d 45 f4 lea -0xc(%ebp),%eax 10e189: 50 push %eax 10e18a: ff 75 08 pushl 0x8(%ebp) 10e18d: e8 42 f8 ff ff call 10d9d4 <_Thread_Get>
switch ( location ) {
10e192: 83 c4 10 add $0x10,%esp 10e195: 8b 55 f4 mov -0xc(%ebp),%edx 10e198: 85 d2 test %edx,%edx
10e19a: 75 17 jne 10e1b3 <_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 );
10e19c: 83 ec 0c sub $0xc,%esp 10e19f: 50 push %eax 10e1a0: e8 c7 36 00 00 call 11186c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e1a5: a1 90 7d 12 00 mov 0x127d90,%eax 10e1aa: 48 dec %eax 10e1ab: a3 90 7d 12 00 mov %eax,0x127d90 10e1b0: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e1b3: c9 leave 10e1b4: c3 ret
00118db8 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
118db8: 55 push %ebp 118db9: 89 e5 mov %esp,%ebp 118dbb: 57 push %edi 118dbc: 56 push %esi 118dbd: 53 push %ebx 118dbe: 83 ec 4c sub $0x4c,%esp 118dc1: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118dc4: 8d 45 e0 lea -0x20(%ebp),%eax 118dc7: 89 45 b4 mov %eax,-0x4c(%ebp) 118dca: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
118dcd: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
118dd4: 8d 4d dc lea -0x24(%ebp),%ecx 118dd7: 89 4d e4 mov %ecx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118dda: 8d 7d d0 lea -0x30(%ebp),%edi 118ddd: 8d 45 d4 lea -0x2c(%ebp),%eax 118de0: 89 45 b0 mov %eax,-0x50(%ebp) 118de3: 89 45 d0 mov %eax,-0x30(%ebp)
head->previous = NULL;
118de6: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
118ded: 89 7d d8 mov %edi,-0x28(%ebp) 118df0: 8d 73 30 lea 0x30(%ebx),%esi 118df3: 8d 4b 68 lea 0x68(%ebx),%ecx 118df6: 89 4d c4 mov %ecx,-0x3c(%ebp) 118df9: 8d 43 08 lea 0x8(%ebx),%eax 118dfc: 89 45 bc mov %eax,-0x44(%ebp) 118dff: 8d 53 40 lea 0x40(%ebx),%edx 118e02: 89 55 c0 mov %edx,-0x40(%ebp) 118e05: 8d 76 00 lea 0x0(%esi),%esi
Chain_Control *tmp; /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain;
118e08: 8d 4d dc lea -0x24(%ebp),%ecx 118e0b: 89 4b 78 mov %ecx,0x78(%ebx) 118e0e: 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;
118e10: a1 64 2b 14 00 mov 0x142b64,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e15: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
118e18: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e1b: 51 push %ecx 118e1c: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e1d: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e1f: 50 push %eax 118e20: 56 push %esi 118e21: e8 9e 3f 00 00 call 11cdc4 <_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();
118e26: a1 c8 2a 14 00 mov 0x142ac8,%eax
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
118e2b: 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 ) {
118e2e: 83 c4 10 add $0x10,%esp 118e31: 39 d0 cmp %edx,%eax
118e33: 0f 87 af 00 00 00 ja 118ee8 <_Timer_server_Body+0x130>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
118e39: 0f 82 c9 00 00 00 jb 118f08 <_Timer_server_Body+0x150>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
118e3f: 89 43 74 mov %eax,0x74(%ebx) 118e42: 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 );
118e44: 8b 43 78 mov 0x78(%ebx),%eax 118e47: 83 ec 0c sub $0xc,%esp 118e4a: 50 push %eax 118e4b: e8 0c 0a 00 00 call 11985c <_Chain_Get>
if ( timer == NULL ) {
118e50: 83 c4 10 add $0x10,%esp 118e53: 85 c0 test %eax,%eax
118e55: 74 35 je 118e8c <_Timer_server_Body+0xd4><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118e57: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 118e5a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 118e5d: 74 19 je 118e78 <_Timer_server_Body+0xc0><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
118e5f: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118e62: 75 e0 jne 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118e64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e67: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e6a: 50 push %eax <== NOT EXECUTED 118e6b: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 118e6e: e8 dd 3f 00 00 call 11ce50 <_Watchdog_Insert> <== NOT EXECUTED 118e73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e76: eb cc jmp 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
118e78: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e7b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e7e: 50 push %eax <== NOT EXECUTED 118e7f: 56 push %esi <== NOT EXECUTED 118e80: e8 cb 3f 00 00 call 11ce50 <_Watchdog_Insert> <== NOT EXECUTED 118e85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e88: eb ba jmp 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED 118e8a: 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 );
118e8c: 9c pushf 118e8d: fa cli 118e8e: 58 pop %eax
tmp = ts->insert_chain;
118e8f: 8b 53 78 mov 0x78(%ebx),%edx
if ( _Chain_Is_empty( insert_chain ) ) {
118e92: 8b 55 b4 mov -0x4c(%ebp),%edx 118e95: 39 55 dc cmp %edx,-0x24(%ebp)
118e98: 0f 84 86 00 00 00 je 118f24 <_Timer_server_Body+0x16c><== ALWAYS TAKEN
118e9e: b2 01 mov $0x1,%dl <== NOT EXECUTED
ts->insert_chain = NULL;
do_loop = false;
}
_ISR_Enable( level );
118ea0: 50 push %eax 118ea1: 9d popf
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
while ( do_loop ) {
118ea2: 84 d2 test %dl,%dl
118ea4: 0f 85 66 ff ff ff jne 118e10 <_Timer_server_Body+0x58><== NEVER TAKEN
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
118eaa: 8b 4d b0 mov -0x50(%ebp),%ecx 118ead: 39 4d d0 cmp %ecx,-0x30(%ebp)
118eb0: 75 22 jne 118ed4 <_Timer_server_Body+0x11c>
118eb2: eb 7e jmp 118f32 <_Timer_server_Body+0x17a>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
118eb4: 8b 10 mov (%eax),%edx
head->next = new_first;
118eb6: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
118eb9: 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;
118ebc: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
118ec3: 51 push %ecx 118ec4: 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 );
118ec5: 83 ec 08 sub $0x8,%esp 118ec8: ff 70 24 pushl 0x24(%eax) 118ecb: ff 70 20 pushl 0x20(%eax) 118ece: ff 50 1c call *0x1c(%eax)
}
118ed1: 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 );
118ed4: 9c pushf 118ed5: fa cli 118ed6: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
118ed7: 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))
118eda: 3b 45 b0 cmp -0x50(%ebp),%eax
118edd: 75 d5 jne 118eb4 <_Timer_server_Body+0xfc>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
118edf: 51 push %ecx 118ee0: 9d popf 118ee1: e9 22 ff ff ff jmp 118e08 <_Timer_server_Body+0x50> 118ee6: 66 90 xchg %ax,%ax
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118ee8: 51 push %ecx 118ee9: 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;
118eea: 89 c1 mov %eax,%ecx 118eec: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118eee: 51 push %ecx 118eef: ff 75 c4 pushl -0x3c(%ebp) 118ef2: 89 45 b8 mov %eax,-0x48(%ebp) 118ef5: e8 ca 3e 00 00 call 11cdc4 <_Watchdog_Adjust_to_chain> 118efa: 83 c4 10 add $0x10,%esp 118efd: 8b 45 b8 mov -0x48(%ebp),%eax 118f00: e9 3a ff ff ff jmp 118e3f <_Timer_server_Body+0x87> 118f05: 8d 76 00 lea 0x0(%esi),%esi
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
118f08: 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;
118f09: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
118f0b: 52 push %edx 118f0c: 6a 01 push $0x1 118f0e: ff 75 c4 pushl -0x3c(%ebp) 118f11: 89 45 b8 mov %eax,-0x48(%ebp) 118f14: e8 33 3e 00 00 call 11cd4c <_Watchdog_Adjust> 118f19: 83 c4 10 add $0x10,%esp 118f1c: 8b 45 b8 mov -0x48(%ebp),%eax 118f1f: e9 1b ff ff ff jmp 118e3f <_Timer_server_Body+0x87>
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
118f24: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
118f2b: 31 d2 xor %edx,%edx 118f2d: e9 6e ff ff ff jmp 118ea0 <_Timer_server_Body+0xe8>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
118f32: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118f36: a1 30 2a 14 00 mov 0x142a30,%eax 118f3b: 40 inc %eax 118f3c: a3 30 2a 14 00 mov %eax,0x142a30
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
118f41: 83 ec 08 sub $0x8,%esp 118f44: 6a 08 push $0x8 118f46: ff 33 pushl (%ebx) 118f48: e8 e7 37 00 00 call 11c734 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
118f4d: 89 d8 mov %ebx,%eax 118f4f: e8 c4 fd ff ff call 118d18 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
118f54: 89 d8 mov %ebx,%eax 118f56: e8 0d fe ff ff call 118d68 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
118f5b: e8 f4 2e 00 00 call 11be54 <_Thread_Enable_dispatch>
ts->active = true;
118f60: 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 );
118f64: 5a pop %edx 118f65: ff 75 bc pushl -0x44(%ebp) 118f68: e8 23 40 00 00 call 11cf90 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
118f6d: 58 pop %eax 118f6e: ff 75 c0 pushl -0x40(%ebp) 118f71: e8 1a 40 00 00 call 11cf90 <_Watchdog_Remove> 118f76: 83 c4 10 add $0x10,%esp 118f79: e9 8a fe ff ff jmp 118e08 <_Timer_server_Body+0x50>
00118f80 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
118f80: 55 push %ebp 118f81: 89 e5 mov %esp,%ebp 118f83: 57 push %edi 118f84: 56 push %esi 118f85: 53 push %ebx 118f86: 83 ec 2c sub $0x2c,%esp 118f89: 8b 5d 08 mov 0x8(%ebp),%ebx 118f8c: 8b 45 0c mov 0xc(%ebp),%eax
if ( ts->insert_chain == NULL ) {
118f8f: 8b 53 78 mov 0x78(%ebx),%edx 118f92: 85 d2 test %edx,%edx
118f94: 74 16 je 118fac <_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 );
118f96: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 118f99: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 118f9c: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
} }
118f9f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118fa2: 5b pop %ebx <== NOT EXECUTED 118fa3: 5e pop %esi <== NOT EXECUTED 118fa4: 5f pop %edi <== NOT EXECUTED 118fa5: 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 );
118fa6: e9 75 08 00 00 jmp 119820 <_Chain_Append> <== NOT EXECUTED 118fab: 90 nop <== NOT EXECUTED
118fac: 8b 15 30 2a 14 00 mov 0x142a30,%edx 118fb2: 42 inc %edx 118fb3: 89 15 30 2a 14 00 mov %edx,0x142a30
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118fb9: 8b 50 38 mov 0x38(%eax),%edx 118fbc: 83 fa 01 cmp $0x1,%edx
118fbf: 74 7b je 11903c <_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 ) {
118fc1: 83 fa 03 cmp $0x3,%edx
118fc4: 74 0e je 118fd4 <_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 );
}
}
118fc6: 8d 65 f4 lea -0xc(%ebp),%esp 118fc9: 5b pop %ebx 118fca: 5e pop %esi 118fcb: 5f pop %edi 118fcc: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
118fcd: e9 82 2e 00 00 jmp 11be54 <_Thread_Enable_dispatch> 118fd2: 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 );
118fd4: 9c pushf 118fd5: fa cli 118fd6: 8f 45 e4 popl -0x1c(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
118fd9: 8b 0d c8 2a 14 00 mov 0x142ac8,%ecx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
118fdf: 8b 53 74 mov 0x74(%ebx),%edx 118fe2: 89 55 d4 mov %edx,-0x2c(%ebp)
initialized = false;
}
#endif
return status;
}
118fe5: 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 );
118fe8: 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 ) ) {
118feb: 39 fa cmp %edi,%edx
118fed: 74 21 je 119010 <_Timer_server_Schedule_operation_method+0x90>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
118fef: 8b 7a 10 mov 0x10(%edx),%edi
if ( snapshot > last_snapshot ) {
118ff2: 3b 4d d4 cmp -0x2c(%ebp),%ecx
118ff5: 0f 86 a1 00 00 00 jbe 11909c <_Timer_server_Schedule_operation_method+0x11c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
118ffb: 89 ce mov %ecx,%esi 118ffd: 2b 75 d4 sub -0x2c(%ebp),%esi 119000: 89 75 d4 mov %esi,-0x2c(%ebp)
if (delta_interval > delta) {
119003: 39 f7 cmp %esi,%edi
119005: 0f 86 9b 00 00 00 jbe 1190a6 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN
delta_interval -= delta;
11900b: 29 f7 sub %esi,%edi
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
11900d: 89 7a 10 mov %edi,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
119010: 89 4b 74 mov %ecx,0x74(%ebx)
_ISR_Enable( level );
119013: ff 75 e4 pushl -0x1c(%ebp) 119016: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
119017: 83 ec 08 sub $0x8,%esp 11901a: 83 c0 10 add $0x10,%eax 11901d: 50 push %eax 11901e: 8d 43 68 lea 0x68(%ebx),%eax 119021: 50 push %eax 119022: e8 29 3e 00 00 call 11ce50 <_Watchdog_Insert>
if ( !ts->active ) {
119027: 8a 43 7c mov 0x7c(%ebx),%al 11902a: 83 c4 10 add $0x10,%esp 11902d: 84 c0 test %al,%al
11902f: 75 95 jne 118fc6 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_tod_system_watchdog( ts );
119031: 89 d8 mov %ebx,%eax 119033: e8 30 fd ff ff call 118d68 <_Timer_server_Reset_tod_system_watchdog> 119038: eb 8c jmp 118fc6 <_Timer_server_Schedule_operation_method+0x46> 11903a: 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 );
11903c: 9c pushf 11903d: fa cli 11903e: 8f 45 e4 popl -0x1c(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
119041: 8b 0d 64 2b 14 00 mov 0x142b64,%ecx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
119047: 8b 7b 3c mov 0x3c(%ebx),%edi
initialized = false;
}
#endif
return status;
}
11904a: 8b 53 30 mov 0x30(%ebx),%edx 11904d: 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 ) ) {
119050: 39 f2 cmp %esi,%edx
119052: 74 10 je 119064 <_Timer_server_Schedule_operation_method+0xe4>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
119054: 89 ce mov %ecx,%esi 119056: 29 fe sub %edi,%esi
delta_interval = first_watchdog->delta_interval;
119058: 8b 7a 10 mov 0x10(%edx),%edi
if (delta_interval > delta) {
11905b: 39 fe cmp %edi,%esi
11905d: 73 39 jae 119098 <_Timer_server_Schedule_operation_method+0x118>
delta_interval -= delta;
11905f: 29 f7 sub %esi,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
119061: 89 7a 10 mov %edi,0x10(%edx)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
119064: 89 4b 3c mov %ecx,0x3c(%ebx)
_ISR_Enable( level );
119067: ff 75 e4 pushl -0x1c(%ebp) 11906a: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
11906b: 83 ec 08 sub $0x8,%esp 11906e: 83 c0 10 add $0x10,%eax 119071: 50 push %eax 119072: 8d 43 30 lea 0x30(%ebx),%eax 119075: 50 push %eax 119076: e8 d5 3d 00 00 call 11ce50 <_Watchdog_Insert>
if ( !ts->active ) {
11907b: 8a 43 7c mov 0x7c(%ebx),%al 11907e: 83 c4 10 add $0x10,%esp 119081: 84 c0 test %al,%al
119083: 0f 85 3d ff ff ff jne 118fc6 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_interval_system_watchdog( ts );
119089: 89 d8 mov %ebx,%eax 11908b: e8 88 fc ff ff call 118d18 <_Timer_server_Reset_interval_system_watchdog> 119090: e9 31 ff ff ff jmp 118fc6 <_Timer_server_Schedule_operation_method+0x46> 119095: 8d 76 00 lea 0x0(%esi),%esi
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
119098: 31 ff xor %edi,%edi 11909a: eb c5 jmp 119061 <_Timer_server_Schedule_operation_method+0xe1>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
11909c: 03 7d d4 add -0x2c(%ebp),%edi
delta_interval += delta;
11909f: 29 cf sub %ecx,%edi 1190a1: e9 67 ff ff ff jmp 11900d <_Timer_server_Schedule_operation_method+0x8d>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1190a6: 31 ff xor %edi,%edi <== NOT EXECUTED 1190a8: e9 60 ff ff ff jmp 11900d <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED
0010fc38 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10fc38: 55 push %ebp 10fc39: 89 e5 mov %esp,%ebp 10fc3b: 57 push %edi 10fc3c: 56 push %esi 10fc3d: 53 push %ebx 10fc3e: 83 ec 2c sub $0x2c,%esp 10fc41: 8b 45 08 mov 0x8(%ebp),%eax 10fc44: 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;
10fc47: 8b 38 mov (%eax),%edi
left += lhs->tv_nsec;
10fc49: 8b 70 04 mov 0x4(%eax),%esi
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10fc4c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10fc51: 8b 01 mov (%ecx),%eax 10fc53: f7 eb imul %ebx 10fc55: 89 45 e0 mov %eax,-0x20(%ebp) 10fc58: 89 55 e4 mov %edx,-0x1c(%ebp)
right += rhs->tv_nsec;
10fc5b: 8b 41 04 mov 0x4(%ecx),%eax 10fc5e: 99 cltd 10fc5f: 01 45 e0 add %eax,-0x20(%ebp) 10fc62: 11 55 e4 adc %edx,-0x1c(%ebp)
if ( right == 0 ) {
10fc65: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc68: 0b 55 e0 or -0x20(%ebp),%edx
10fc6b: 74 73 je 10fce0 <_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;
10fc6d: 89 f8 mov %edi,%eax 10fc6f: f7 eb imul %ebx 10fc71: 89 45 d0 mov %eax,-0x30(%ebp) 10fc74: 89 55 d4 mov %edx,-0x2c(%ebp)
left += lhs->tv_nsec;
10fc77: 89 f7 mov %esi,%edi 10fc79: c1 ff 1f sar $0x1f,%edi 10fc7c: 01 75 d0 add %esi,-0x30(%ebp) 10fc7f: 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;
10fc82: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10fc89: bb a0 86 01 00 mov $0x186a0,%ebx 10fc8e: 8b 45 d0 mov -0x30(%ebp),%eax 10fc91: f7 e3 mul %ebx 10fc93: 8d 34 11 lea (%ecx,%edx,1),%esi 10fc96: ff 75 e4 pushl -0x1c(%ebp) 10fc99: ff 75 e0 pushl -0x20(%ebp) 10fc9c: 56 push %esi 10fc9d: 50 push %eax 10fc9e: e8 29 12 01 00 call 120ecc <__udivdi3> 10fca3: 83 c4 10 add $0x10,%esp 10fca6: 89 c3 mov %eax,%ebx 10fca8: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10fcaa: 6a 00 push $0x0 10fcac: 68 e8 03 00 00 push $0x3e8 10fcb1: 52 push %edx 10fcb2: 50 push %eax 10fcb3: e8 14 12 01 00 call 120ecc <__udivdi3> 10fcb8: 83 c4 10 add $0x10,%esp 10fcbb: 8b 55 10 mov 0x10(%ebp),%edx 10fcbe: 89 02 mov %eax,(%edx)
*fval_percentage = answer % 1000;
10fcc0: 6a 00 push $0x0 10fcc2: 68 e8 03 00 00 push $0x3e8 10fcc7: 56 push %esi 10fcc8: 53 push %ebx 10fcc9: e8 0e 13 01 00 call 120fdc <__umoddi3> 10fcce: 83 c4 10 add $0x10,%esp 10fcd1: 8b 55 14 mov 0x14(%ebp),%edx 10fcd4: 89 02 mov %eax,(%edx)
}
10fcd6: 8d 65 f4 lea -0xc(%ebp),%esp 10fcd9: 5b pop %ebx 10fcda: 5e pop %esi 10fcdb: 5f pop %edi 10fcdc: c9 leave 10fcdd: c3 ret 10fcde: 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;
10fce0: 8b 45 10 mov 0x10(%ebp),%eax 10fce3: c7 00 00 00 00 00 movl $0x0,(%eax)
*fval_percentage = 0;
10fce9: 8b 55 14 mov 0x14(%ebp),%edx 10fcec: c7 02 00 00 00 00 movl $0x0,(%edx)
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10fcf2: 8d 65 f4 lea -0xc(%ebp),%esp 10fcf5: 5b pop %ebx 10fcf6: 5e pop %esi 10fcf7: 5f pop %edi 10fcf8: c9 leave 10fcf9: c3 ret
0011ff98 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
11ff98: 55 push %ebp 11ff99: 89 e5 mov %esp,%ebp 11ff9b: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
11ff9e: 85 c0 test %eax,%eax
11ffa0: 74 1a je 11ffbc <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
11ffa2: 8b 10 mov (%eax),%edx 11ffa4: 85 d2 test %edx,%edx
11ffa6: 78 14 js 11ffbc <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
11ffa8: 8b 40 04 mov 0x4(%eax),%eax 11ffab: 85 c0 test %eax,%eax
11ffad: 78 0d js 11ffbc <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
11ffaf: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 11ffb4: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11ffb7: c9 leave 11ffb8: c3 ret 11ffb9: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
11ffbc: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11ffbe: c9 leave 11ffbf: c3 ret
00111918 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
111918: 55 push %ebp 111919: 89 e5 mov %esp,%ebp 11191b: 56 push %esi 11191c: 53 push %ebx 11191d: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
111920: 8b 33 mov (%ebx),%esi 111922: 85 f6 test %esi,%esi
111924: 75 07 jne 11192d <_Timespec_To_ticks+0x15>
111926: 8b 43 04 mov 0x4(%ebx),%eax 111929: 85 c0 test %eax,%eax
11192b: 74 37 je 111964 <_Timespec_To_ticks+0x4c>
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
11192d: e8 62 17 00 00 call 113094 <TOD_TICKS_PER_SECOND_method> 111932: 89 c1 mov %eax,%ecx 111934: 0f af ce imul %esi,%ecx
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
111937: a1 8c 3a 12 00 mov 0x123a8c,%eax 11193c: 8d 04 80 lea (%eax,%eax,4),%eax 11193f: 8d 04 80 lea (%eax,%eax,4),%eax 111942: 8d 34 80 lea (%eax,%eax,4),%esi 111945: c1 e6 03 shl $0x3,%esi 111948: 8b 43 04 mov 0x4(%ebx),%eax 11194b: 31 d2 xor %edx,%edx 11194d: f7 f6 div %esi
if (ticks)
11194f: 01 c8 add %ecx,%eax
111951: 74 05 je 111958 <_Timespec_To_ticks+0x40>
return ticks;
return 1;
}
111953: 5b pop %ebx 111954: 5e pop %esi 111955: c9 leave 111956: c3 ret 111957: 90 nop
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
if (ticks)
return ticks;
return 1;
111958: b8 01 00 00 00 mov $0x1,%eax
}
11195d: 5b pop %ebx 11195e: 5e pop %esi 11195f: c9 leave 111960: c3 ret 111961: 8d 76 00 lea 0x0(%esi),%esi
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
111964: 31 c0 xor %eax,%eax
if (ticks)
return ticks;
return 1;
}
111966: 5b pop %ebx 111967: 5e pop %esi 111968: c9 leave 111969: c3 ret
0010e5bc <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10e5bc: 55 push %ebp 10e5bd: 89 e5 mov %esp,%ebp 10e5bf: 57 push %edi 10e5c0: 56 push %esi 10e5c1: 53 push %ebx 10e5c2: 83 ec 1c sub $0x1c,%esp 10e5c5: 8b 75 08 mov 0x8(%ebp),%esi 10e5c8: 8b 7d 10 mov 0x10(%ebp),%edi 10e5cb: 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 );
}
}
10e5ce: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5d4: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e5da: 74 25 je 10e601 <_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 );
10e5dc: 0f b6 c0 movzbl %al,%eax 10e5df: 89 45 e4 mov %eax,-0x1c(%ebp) 10e5e2: 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 )
10e5e4: 8b 43 30 mov 0x30(%ebx),%eax 10e5e7: 85 c0 test %eax,%eax
10e5e9: 74 0b je 10e5f6 <_User_extensions_Fatal+0x3a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10e5eb: 52 push %edx 10e5ec: 57 push %edi 10e5ed: ff 75 e4 pushl -0x1c(%ebp) 10e5f0: 56 push %esi 10e5f1: ff d0 call *%eax
10e5f3: 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 ) {
10e5f6: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5f9: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e5ff: 75 e3 jne 10e5e4 <_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 );
}
}
10e601: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e604: 5b pop %ebx <== NOT EXECUTED 10e605: 5e pop %esi <== NOT EXECUTED 10e606: 5f pop %edi <== NOT EXECUTED 10e607: c9 leave <== NOT EXECUTED 10e608: c3 ret <== NOT EXECUTED
0010e480 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10e480: 55 push %ebp 10e481: 89 e5 mov %esp,%ebp 10e483: 57 push %edi 10e484: 56 push %esi 10e485: 53 push %ebx 10e486: 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;
10e489: a1 b8 3a 12 00 mov 0x123ab8,%eax 10e48e: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10e491: 8b 35 bc 3a 12 00 mov 0x123abc,%esi
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e497: c7 05 ac 7f 12 00 b0 movl $0x127fb0,0x127fac
10e49e: 7f 12 00 head->previous = NULL;
10e4a1: c7 05 b0 7f 12 00 00 movl $0x0,0x127fb0
10e4a8: 00 00 00 tail->previous = head;
10e4ab: c7 05 b4 7f 12 00 ac movl $0x127fac,0x127fb4
10e4b2: 7f 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e4b5: c7 05 94 7d 12 00 98 movl $0x127d98,0x127d94
10e4bc: 7d 12 00 head->previous = NULL;
10e4bf: c7 05 98 7d 12 00 00 movl $0x0,0x127d98
10e4c6: 00 00 00 tail->previous = head;
10e4c9: c7 05 9c 7d 12 00 94 movl $0x127d94,0x127d9c
10e4d0: 7d 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10e4d3: 85 f6 test %esi,%esi
10e4d5: 74 64 je 10e53b <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10e4d7: 89 c2 mov %eax,%edx 10e4d9: 8d 04 40 lea (%eax,%eax,2),%eax 10e4dc: 8d 0c 82 lea (%edx,%eax,4),%ecx 10e4df: c1 e1 02 shl $0x2,%ecx 10e4e2: 83 ec 0c sub $0xc,%esp 10e4e5: 51 push %ecx 10e4e6: 89 4d d8 mov %ecx,-0x28(%ebp) 10e4e9: e8 ce 04 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error> 10e4ee: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10e4f0: 31 c0 xor %eax,%eax 10e4f2: 8b 4d d8 mov -0x28(%ebp),%ecx 10e4f5: 89 df mov %ebx,%edi 10e4f7: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e4f9: 83 c4 10 add $0x10,%esp 10e4fc: 8b 45 dc mov -0x24(%ebp),%eax 10e4ff: 85 c0 test %eax,%eax
10e501: 74 38 je 10e53b <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
10e503: 89 75 e4 mov %esi,-0x1c(%ebp) 10e506: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10e50d: 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;
10e510: 8d 7b 14 lea 0x14(%ebx),%edi 10e513: 8b 75 e4 mov -0x1c(%ebp),%esi 10e516: b9 08 00 00 00 mov $0x8,%ecx 10e51b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10e51d: 83 ec 0c sub $0xc,%esp 10e520: 53 push %ebx 10e521: e8 46 34 00 00 call 11196c <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10e526: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e529: ff 45 e0 incl -0x20(%ebp) 10e52c: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10e530: 83 c4 10 add $0x10,%esp 10e533: 8b 45 e0 mov -0x20(%ebp),%eax 10e536: 39 45 dc cmp %eax,-0x24(%ebp)
10e539: 77 d5 ja 10e510 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10e53b: 8d 65 f4 lea -0xc(%ebp),%esp 10e53e: 5b pop %ebx 10e53f: 5e pop %esi 10e540: 5f pop %edi 10e541: c9 leave 10e542: c3 ret
0010fa00 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10fa00: 55 push %ebp 10fa01: 89 e5 mov %esp,%ebp 10fa03: 53 push %ebx 10fa04: 83 ec 10 sub $0x10,%esp 10fa07: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10fa0a: 53 push %ebx 10fa0b: e8 88 d9 ff ff call 10d398 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10fa10: 83 c4 10 add $0x10,%esp 10fa13: 8b 43 24 mov 0x24(%ebx),%eax 10fa16: 85 c0 test %eax,%eax
10fa18: 74 12 je 10fa2c <_User_extensions_Remove_set+0x2c>
_Chain_Extract( &the_extension->Switch.Node );
10fa1a: 83 c3 08 add $0x8,%ebx 10fa1d: 89 5d 08 mov %ebx,0x8(%ebp)
}
10fa20: 8b 5d fc mov -0x4(%ebp),%ebx 10fa23: c9 leave
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10fa24: e9 6f d9 ff ff jmp 10d398 <_Chain_Extract> 10fa29: 8d 76 00 lea 0x0(%esi),%esi
}
10fa2c: 8b 5d fc mov -0x4(%ebp),%ebx 10fa2f: c9 leave 10fa30: c3 ret
0010e544 <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10e544: 55 push %ebp 10e545: 89 e5 mov %esp,%ebp 10e547: 56 push %esi 10e548: 53 push %ebx 10e549: 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 );
}
}
10e54c: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e552: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e558: 74 1c je 10e576 <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10e55a: 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 )
10e55c: 8b 43 28 mov 0x28(%ebx),%eax 10e55f: 85 c0 test %eax,%eax
10e561: 74 09 je 10e56c <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10e563: 83 ec 0c sub $0xc,%esp 10e566: 56 push %esi 10e567: ff d0 call *%eax 10e569: 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 ) {
10e56c: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e56e: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e574: 75 e6 jne 10e55c <_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 );
}
}
10e576: 8d 65 f8 lea -0x8(%ebp),%esp 10e579: 5b pop %ebx 10e57a: 5e pop %esi 10e57b: c9 leave 10e57c: c3 ret
0010e60c <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10e60c: 55 push %ebp 10e60d: 89 e5 mov %esp,%ebp 10e60f: 56 push %esi 10e610: 53 push %ebx 10e611: 8b 75 08 mov 0x8(%ebp),%esi
return false;
}
}
return true;
}
10e614: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e61a: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e620: 74 26 je 10e648 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10e622: 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 ) {
10e624: 8b 43 14 mov 0x14(%ebx),%eax 10e627: 85 c0 test %eax,%eax
10e629: 74 13 je 10e63e <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10e62b: 83 ec 08 sub $0x8,%esp 10e62e: 56 push %esi 10e62f: ff 35 38 83 12 00 pushl 0x128338 10e635: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10e637: 83 c4 10 add $0x10,%esp 10e63a: 84 c0 test %al,%al
10e63c: 74 16 je 10e654 <_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 ) {
10e63e: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e640: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e646: 75 dc jne 10e624 <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10e648: b0 01 mov $0x1,%al
}
10e64a: 8d 65 f8 lea -0x8(%ebp),%esp 10e64d: 5b pop %ebx 10e64e: 5e pop %esi 10e64f: c9 leave 10e650: c3 ret 10e651: 8d 76 00 lea 0x0(%esi),%esi
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
10e654: 31 c0 xor %eax,%eax
}
}
return true;
}
10e656: 8d 65 f8 lea -0x8(%ebp),%esp 10e659: 5b pop %ebx 10e65a: 5e pop %esi 10e65b: c9 leave 10e65c: c3 ret
0010e660 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10e660: 55 push %ebp 10e661: 89 e5 mov %esp,%ebp 10e663: 56 push %esi 10e664: 53 push %ebx 10e665: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e668: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e66e: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e674: 74 23 je 10e699 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10e676: 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 )
10e678: 8b 43 20 mov 0x20(%ebx),%eax 10e67b: 85 c0 test %eax,%eax
10e67d: 74 0f je 10e68e <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10e67f: 83 ec 08 sub $0x8,%esp 10e682: 56 push %esi 10e683: ff 35 38 83 12 00 pushl 0x128338 10e689: ff d0 call *%eax 10e68b: 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 ) {
10e68e: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e691: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e697: 75 df jne 10e678 <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e699: 8d 65 f8 lea -0x8(%ebp),%esp 10e69c: 5b pop %ebx 10e69d: 5e pop %esi 10e69e: c9 leave 10e69f: c3 ret
0010e580 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10e580: 55 push %ebp 10e581: 89 e5 mov %esp,%ebp 10e583: 56 push %esi 10e584: 53 push %ebx 10e585: 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 );
}
}
10e588: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e58e: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e594: 74 1d je 10e5b3 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10e596: 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 )
10e598: 8b 43 2c mov 0x2c(%ebx),%eax 10e59b: 85 c0 test %eax,%eax
10e59d: 74 09 je 10e5a8 <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10e59f: 83 ec 0c sub $0xc,%esp 10e5a2: 56 push %esi 10e5a3: ff d0 call *%eax 10e5a5: 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 ) {
10e5a8: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5ab: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e5b1: 75 e5 jne 10e598 <_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 );
}
}
10e5b3: 8d 65 f8 lea -0x8(%ebp),%esp 10e5b6: 5b pop %ebx 10e5b7: 5e pop %esi 10e5b8: c9 leave 10e5b9: c3 ret
0010f264 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10f264: 55 push %ebp 10f265: 89 e5 mov %esp,%ebp 10f267: 56 push %esi 10f268: 53 push %ebx 10f269: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f26c: 8b 1d cc a2 12 00 mov 0x12a2cc,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f272: 81 fb d0 a2 12 00 cmp $0x12a2d0,%ebx
10f278: 74 22 je 10f29c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10f27a: 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 )
10f27c: 8b 43 1c mov 0x1c(%ebx),%eax 10f27f: 85 c0 test %eax,%eax
10f281: 74 0f je 10f292 <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10f283: 83 ec 08 sub $0x8,%esp 10f286: 56 push %esi 10f287: ff 35 58 a6 12 00 pushl 0x12a658 10f28d: ff d0 call *%eax 10f28f: 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 ) {
10f292: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f294: 81 fb d0 a2 12 00 cmp $0x12a2d0,%ebx
10f29a: 75 e0 jne 10f27c <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f29c: 8d 65 f8 lea -0x8(%ebp),%esp 10f29f: 5b pop %ebx 10f2a0: 5e pop %esi 10f2a1: c9 leave 10f2a2: c3 ret
0010e6a0 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10e6a0: 55 push %ebp 10e6a1: 89 e5 mov %esp,%ebp 10e6a3: 56 push %esi 10e6a4: 53 push %ebx 10e6a5: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e6a8: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e6ae: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e6b4: 74 22 je 10e6d8 <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10e6b6: 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 )
10e6b8: 8b 43 18 mov 0x18(%ebx),%eax 10e6bb: 85 c0 test %eax,%eax
10e6bd: 74 0f je 10e6ce <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10e6bf: 83 ec 08 sub $0x8,%esp 10e6c2: 56 push %esi 10e6c3: ff 35 38 83 12 00 pushl 0x128338 10e6c9: ff d0 call *%eax 10e6cb: 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 ) {
10e6ce: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e6d0: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e6d6: 75 e0 jne 10e6b8 <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e6d8: 8d 65 f8 lea -0x8(%ebp),%esp 10e6db: 5b pop %ebx 10e6dc: 5e pop %esi 10e6dd: c9 leave 10e6de: c3 ret
0010e6e0 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10e6e0: 55 push %ebp 10e6e1: 89 e5 mov %esp,%ebp 10e6e3: 57 push %edi 10e6e4: 56 push %esi 10e6e5: 53 push %ebx 10e6e6: 83 ec 0c sub $0xc,%esp 10e6e9: 8b 7d 08 mov 0x8(%ebp),%edi 10e6ec: 8b 75 0c mov 0xc(%ebp),%esi
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e6ef: 8b 1d 94 7d 12 00 mov 0x127d94,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e6f5: 81 fb 98 7d 12 00 cmp $0x127d98,%ebx
10e6fb: 74 18 je 10e715 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10e6fd: 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 );
10e700: 83 ec 08 sub $0x8,%esp 10e703: 56 push %esi 10e704: 57 push %edi 10e705: 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 ) {
10e708: 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 );
10e70a: 83 c4 10 add $0x10,%esp 10e70d: 81 fb 98 7d 12 00 cmp $0x127d98,%ebx
10e713: 75 eb jne 10e700 <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e715: 8d 65 f4 lea -0xc(%ebp),%esp 10e718: 5b pop %ebx 10e719: 5e pop %esi 10e71a: 5f pop %edi 10e71b: c9 leave 10e71c: c3 ret
00110018 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
110018: 55 push %ebp 110019: 89 e5 mov %esp,%ebp 11001b: 57 push %edi 11001c: 56 push %esi 11001d: 53 push %ebx 11001e: 83 ec 1c sub $0x1c,%esp 110021: 8b 75 08 mov 0x8(%ebp),%esi 110024: 8b 4d 0c mov 0xc(%ebp),%ecx 110027: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
11002a: 9c pushf 11002b: fa cli 11002c: 58 pop %eax
}
}
_ISR_Enable( level );
}
11002d: 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 );
11002f: 8d 7e 04 lea 0x4(%esi),%edi 110032: 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 ) ) {
110035: 39 fa cmp %edi,%edx
110037: 74 3d je 110076 <_Watchdog_Adjust+0x5e>
switch ( direction ) {
110039: 85 c9 test %ecx,%ecx
11003b: 75 43 jne 110080 <_Watchdog_Adjust+0x68>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
11003d: 85 db test %ebx,%ebx
11003f: 74 35 je 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
110041: 8b 7a 10 mov 0x10(%edx),%edi 110044: 39 fb cmp %edi,%ebx
110046: 73 0f jae 110057 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
110048: eb 3e jmp 110088 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 11004a: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
11004c: 29 fb sub %edi,%ebx
11004e: 74 26 je 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
110050: 8b 7a 10 mov 0x10(%edx),%edi 110053: 39 df cmp %ebx,%edi
110055: 77 31 ja 110088 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
110057: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
11005e: 50 push %eax 11005f: 9d popf
_Watchdog_Tickle( header );
110060: 83 ec 0c sub $0xc,%esp 110063: 56 push %esi 110064: e8 d3 01 00 00 call 11023c <_Watchdog_Tickle>
_ISR_Disable( level );
110069: 9c pushf 11006a: fa cli 11006b: 58 pop %eax
}
}
_ISR_Enable( level );
}
11006c: 8b 16 mov (%esi),%edx
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
11006e: 83 c4 10 add $0x10,%esp 110071: 39 55 e4 cmp %edx,-0x1c(%ebp)
110074: 75 d6 jne 11004c <_Watchdog_Adjust+0x34>
}
break;
}
}
_ISR_Enable( level );
110076: 50 push %eax 110077: 9d popf
}
110078: 8d 65 f4 lea -0xc(%ebp),%esp 11007b: 5b pop %ebx 11007c: 5e pop %esi 11007d: 5f pop %edi 11007e: c9 leave 11007f: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
110080: 49 dec %ecx
110081: 75 f3 jne 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
110083: 01 5a 10 add %ebx,0x10(%edx)
break;
110086: eb ee jmp 110076 <_Watchdog_Adjust+0x5e>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
110088: 29 df sub %ebx,%edi 11008a: 89 7a 10 mov %edi,0x10(%edx)
break;
11008d: eb e7 jmp 110076 <_Watchdog_Adjust+0x5e>
0010e720 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10e720: 55 push %ebp 10e721: 89 e5 mov %esp,%ebp 10e723: 57 push %edi 10e724: 56 push %esi 10e725: 53 push %ebx 10e726: 83 ec 04 sub $0x4,%esp 10e729: 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;
10e72c: 8b 3d 34 83 12 00 mov 0x128334,%edi
_ISR_Disable( level );
10e732: 9c pushf 10e733: fa cli 10e734: 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 ) {
10e737: 8b 43 08 mov 0x8(%ebx),%eax 10e73a: 85 c0 test %eax,%eax
10e73c: 0f 85 9e 00 00 00 jne 10e7e0 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10e742: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
_Watchdog_Sync_count++;
10e749: a1 c0 7e 12 00 mov 0x127ec0,%eax 10e74e: 40 inc %eax 10e74f: a3 c0 7e 12 00 mov %eax,0x127ec0
restart:
delta_interval = the_watchdog->initial;
10e754: 8b 43 0c mov 0xc(%ebx),%eax
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e757: 8b 4d 08 mov 0x8(%ebp),%ecx 10e75a: 8b 11 mov (%ecx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e75c: 85 c0 test %eax,%eax
10e75e: 74 5d je 10e7bd <_Watchdog_Insert+0x9d>
10e760: 8b 32 mov (%edx),%esi 10e762: 85 f6 test %esi,%esi
10e764: 74 57 je 10e7bd <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e766: 8b 4a 10 mov 0x10(%edx),%ecx 10e769: 39 c8 cmp %ecx,%eax
10e76b: 73 22 jae 10e78f <_Watchdog_Insert+0x6f>
10e76d: eb 49 jmp 10e7b8 <_Watchdog_Insert+0x98> 10e76f: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10e770: 8b 35 44 7e 12 00 mov 0x127e44,%esi 10e776: 39 f7 cmp %esi,%edi
10e778: 72 72 jb 10e7ec <_Watchdog_Insert+0xcc>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10e77a: 29 c8 sub %ecx,%eax
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e77c: 8b 12 mov (%edx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e77e: 85 c0 test %eax,%eax
10e780: 74 3b je 10e7bd <_Watchdog_Insert+0x9d>
10e782: 8b 0a mov (%edx),%ecx 10e784: 85 c9 test %ecx,%ecx
10e786: 74 35 je 10e7bd <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e788: 8b 4a 10 mov 0x10(%edx),%ecx 10e78b: 39 c1 cmp %eax,%ecx
10e78d: 77 29 ja 10e7b8 <_Watchdog_Insert+0x98>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
10e78f: ff 75 f0 pushl -0x10(%ebp) 10e792: 9d popf 10e793: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10e794: 83 7b 08 01 cmpl $0x1,0x8(%ebx)
10e798: 74 d6 je 10e770 <_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;
10e79a: 89 3d 44 7e 12 00 mov %edi,0x127e44
_Watchdog_Sync_count--;
10e7a0: a1 c0 7e 12 00 mov 0x127ec0,%eax 10e7a5: 48 dec %eax 10e7a6: a3 c0 7e 12 00 mov %eax,0x127ec0
_ISR_Enable( level );
10e7ab: ff 75 f0 pushl -0x10(%ebp) 10e7ae: 9d popf
}
10e7af: 58 pop %eax 10e7b0: 5b pop %ebx 10e7b1: 5e pop %esi 10e7b2: 5f pop %edi 10e7b3: c9 leave 10e7b4: c3 ret 10e7b5: 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;
10e7b8: 29 c1 sub %eax,%ecx 10e7ba: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
10e7bd: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10e7c4: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10e7c7: 8b 42 04 mov 0x4(%edx),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10e7ca: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10e7cd: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10e7cf: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10e7d1: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10e7d3: 89 5a 04 mov %ebx,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10e7d6: a1 c4 7e 12 00 mov 0x127ec4,%eax 10e7db: 89 43 14 mov %eax,0x14(%ebx) 10e7de: eb ba jmp 10e79a <_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 );
10e7e0: ff 75 f0 pushl -0x10(%ebp) 10e7e3: 9d popf
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e7e4: 58 pop %eax 10e7e5: 5b pop %ebx 10e7e6: 5e pop %esi 10e7e7: 5f pop %edi 10e7e8: c9 leave 10e7e9: c3 ret 10e7ea: 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;
10e7ec: 89 3d 44 7e 12 00 mov %edi,0x127e44
goto restart;
10e7f2: e9 5d ff ff ff jmp 10e754 <_Watchdog_Insert+0x34>
0010e860 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10e860: 55 push %ebp 10e861: 89 e5 mov %esp,%ebp 10e863: 56 push %esi 10e864: 53 push %ebx 10e865: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10e868: 9c pushf 10e869: fa cli 10e86a: 59 pop %ecx
previous_state = the_watchdog->state;
10e86b: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10e86e: 83 f8 01 cmp $0x1,%eax
10e871: 74 4d je 10e8c0 <_Watchdog_Remove+0x60>
10e873: 73 0f jae 10e884 <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10e875: 8b 1d c4 7e 12 00 mov 0x127ec4,%ebx 10e87b: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10e87e: 51 push %ecx 10e87f: 9d popf
return( previous_state ); }
10e880: 5b pop %ebx 10e881: 5e pop %esi 10e882: c9 leave 10e883: c3 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10e884: 83 f8 03 cmp $0x3,%eax
10e887: 77 ec ja 10e875 <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10e889: 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 );
}
10e890: 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) )
10e892: 8b 33 mov (%ebx),%esi 10e894: 85 f6 test %esi,%esi
10e896: 74 06 je 10e89e <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10e898: 8b 72 10 mov 0x10(%edx),%esi 10e89b: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10e89e: 8b 35 c0 7e 12 00 mov 0x127ec0,%esi 10e8a4: 85 f6 test %esi,%esi
10e8a6: 74 0c je 10e8b4 <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10e8a8: 8b 35 34 83 12 00 mov 0x128334,%esi 10e8ae: 89 35 44 7e 12 00 mov %esi,0x127e44
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10e8b4: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10e8b7: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10e8ba: 89 1e mov %ebx,(%esi) 10e8bc: eb b7 jmp 10e875 <_Watchdog_Remove+0x15> 10e8be: 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;
10e8c0: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10e8c7: eb ac jmp 10e875 <_Watchdog_Remove+0x15>
0010fc0c <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
10fc0c: 55 push %ebp 10fc0d: 89 e5 mov %esp,%ebp 10fc0f: 57 push %edi 10fc10: 56 push %esi 10fc11: 53 push %ebx 10fc12: 83 ec 2c sub $0x2c,%esp 10fc15: 8b 55 08 mov 0x8(%ebp),%edx 10fc18: 8b 45 0c mov 0xc(%ebp),%eax
printk(
10fc1b: 8b 78 24 mov 0x24(%eax),%edi 10fc1e: 8b 70 20 mov 0x20(%eax),%esi 10fc21: 8b 58 1c mov 0x1c(%eax),%ebx 10fc24: 8b 48 0c mov 0xc(%eax),%ecx 10fc27: 89 4d d4 mov %ecx,-0x2c(%ebp) 10fc2a: 8b 48 10 mov 0x10(%eax),%ecx 10fc2d: 89 4d e4 mov %ecx,-0x1c(%ebp) 10fc30: 85 d2 test %edx,%edx
10fc32: 74 2c je 10fc60 <_Watchdog_Report+0x54>
10fc34: b9 83 34 12 00 mov $0x123483,%ecx 10fc39: 83 ec 0c sub $0xc,%esp 10fc3c: 57 push %edi 10fc3d: 56 push %esi 10fc3e: 53 push %ebx 10fc3f: 50 push %eax 10fc40: ff 75 d4 pushl -0x2c(%ebp) 10fc43: ff 75 e4 pushl -0x1c(%ebp) 10fc46: 51 push %ecx 10fc47: 52 push %edx 10fc48: 68 d6 3e 12 00 push $0x123ed6 10fc4d: e8 46 9e ff ff call 109a98 <printk> 10fc52: 83 c4 30 add $0x30,%esp
watch,
watch->routine,
watch->id,
watch->user_data
);
}
10fc55: 8d 65 f4 lea -0xc(%ebp),%esp 10fc58: 5b pop %ebx 10fc59: 5e pop %esi 10fc5a: 5f pop %edi 10fc5b: c9 leave 10fc5c: c3 ret 10fc5d: 8d 76 00 lea 0x0(%esi),%esi
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
printk(
10fc60: b9 49 3d 12 00 mov $0x123d49,%ecx 10fc65: 89 ca mov %ecx,%edx 10fc67: eb d0 jmp 10fc39 <_Watchdog_Report+0x2d>
0010fb9c <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10fb9c: 55 push %ebp 10fb9d: 89 e5 mov %esp,%ebp 10fb9f: 57 push %edi 10fba0: 56 push %esi 10fba1: 53 push %ebx 10fba2: 83 ec 20 sub $0x20,%esp 10fba5: 8b 7d 08 mov 0x8(%ebp),%edi 10fba8: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10fbab: 9c pushf 10fbac: fa cli 10fbad: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10fbb0: 56 push %esi 10fbb1: 57 push %edi 10fbb2: 68 a0 3e 12 00 push $0x123ea0 10fbb7: e8 dc 9e ff ff call 109a98 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10fbbc: 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 );
10fbbe: 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 ) ) {
10fbc1: 83 c4 10 add $0x10,%esp 10fbc4: 39 f3 cmp %esi,%ebx
10fbc6: 74 31 je 10fbf9 <_Watchdog_Report_chain+0x5d>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10fbc8: 83 ec 08 sub $0x8,%esp 10fbcb: 53 push %ebx 10fbcc: 6a 00 push $0x0 10fbce: e8 39 00 00 00 call 10fc0c <_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 )
10fbd3: 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 ) ;
10fbd5: 83 c4 10 add $0x10,%esp 10fbd8: 39 f3 cmp %esi,%ebx
10fbda: 75 ec jne 10fbc8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10fbdc: 83 ec 08 sub $0x8,%esp 10fbdf: 57 push %edi 10fbe0: 68 b7 3e 12 00 push $0x123eb7 10fbe5: e8 ae 9e ff ff call 109a98 <printk> 10fbea: 83 c4 10 add $0x10,%esp
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10fbed: ff 75 e4 pushl -0x1c(%ebp) 10fbf0: 9d popf
}
10fbf1: 8d 65 f4 lea -0xc(%ebp),%esp 10fbf4: 5b pop %ebx 10fbf5: 5e pop %esi 10fbf6: 5f pop %edi 10fbf7: c9 leave 10fbf8: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10fbf9: 83 ec 0c sub $0xc,%esp 10fbfc: 68 c6 3e 12 00 push $0x123ec6 10fc01: e8 92 9e ff ff call 109a98 <printk> 10fc06: 83 c4 10 add $0x10,%esp 10fc09: eb e2 jmp 10fbed <_Watchdog_Report_chain+0x51>
0010e8cc <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10e8cc: 55 push %ebp 10e8cd: 89 e5 mov %esp,%ebp 10e8cf: 57 push %edi 10e8d0: 56 push %esi 10e8d1: 53 push %ebx 10e8d2: 83 ec 1c sub $0x1c,%esp 10e8d5: 8b 7d 08 mov 0x8(%ebp),%edi
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
10e8d8: 9c pushf 10e8d9: fa cli 10e8da: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e8db: 8b 1f mov (%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10e8dd: 8d 47 04 lea 0x4(%edi),%eax 10e8e0: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10e8e3: 39 c3 cmp %eax,%ebx
10e8e5: 74 11 je 10e8f8 <_Watchdog_Tickle+0x2c>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
10e8e7: 8b 43 10 mov 0x10(%ebx),%eax 10e8ea: 85 c0 test %eax,%eax
10e8ec: 74 34 je 10e922 <_Watchdog_Tickle+0x56>
the_watchdog->delta_interval--;
10e8ee: 48 dec %eax 10e8ef: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10e8f2: 85 c0 test %eax,%eax
10e8f4: 74 2c je 10e922 <_Watchdog_Tickle+0x56>
10e8f6: 66 90 xchg %ax,%ax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10e8f8: 56 push %esi 10e8f9: 9d popf
}
10e8fa: 8d 65 f4 lea -0xc(%ebp),%esp 10e8fd: 5b pop %ebx 10e8fe: 5e pop %esi 10e8ff: 5f pop %edi 10e900: c9 leave 10e901: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10e902: 83 ec 08 sub $0x8,%esp 10e905: ff 73 24 pushl 0x24(%ebx) 10e908: ff 73 20 pushl 0x20(%ebx) 10e90b: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10e90e: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10e911: 9c pushf 10e912: fa cli 10e913: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e914: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10e916: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10e919: 74 dd je 10e8f8 <_Watchdog_Tickle+0x2c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10e91b: 8b 43 10 mov 0x10(%ebx),%eax 10e91e: 85 c0 test %eax,%eax
10e920: 75 d6 jne 10e8f8 <_Watchdog_Tickle+0x2c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10e922: 83 ec 0c sub $0xc,%esp 10e925: 53 push %ebx 10e926: e8 35 ff ff ff call 10e860 <_Watchdog_Remove>
_ISR_Enable( level );
10e92b: 56 push %esi 10e92c: 9d popf
switch( watchdog_state ) {
10e92d: 83 c4 10 add $0x10,%esp 10e930: 83 f8 02 cmp $0x2,%eax
10e933: 75 dc jne 10e911 <_Watchdog_Tickle+0x45> <== NEVER TAKEN
10e935: eb cb jmp 10e902 <_Watchdog_Tickle+0x36>
0010e938 <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10e938: 55 push %ebp 10e939: 89 e5 mov %esp,%ebp 10e93b: 57 push %edi 10e93c: 53 push %ebx
uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start;
10e93d: 8b 1d 80 3a 12 00 mov 0x123a80,%ebx
uintptr_t size = Configuration.work_space_size;
10e943: 8b 15 84 3a 12 00 mov 0x123a84,%edx
if ( Configuration.do_zero_of_workspace )
10e949: 80 3d a8 3a 12 00 00 cmpb $0x0,0x123aa8
10e950: 75 1e jne 10e970 <_Workspace_Handler_initialization+0x38>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10e952: 6a 04 push $0x4 10e954: 52 push %edx 10e955: 53 push %ebx 10e956: 68 c0 7d 12 00 push $0x127dc0 10e95b: e8 8c dd ff ff call 10c6ec <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10e960: 83 c4 10 add $0x10,%esp 10e963: 85 c0 test %eax,%eax
10e965: 74 13 je 10e97a <_Workspace_Handler_initialization+0x42>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10e967: 8d 65 f8 lea -0x8(%ebp),%esp 10e96a: 5b pop %ebx 10e96b: 5f pop %edi 10e96c: c9 leave 10e96d: c3 ret 10e96e: 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 );
10e970: 31 c0 xor %eax,%eax 10e972: 89 df mov %ebx,%edi 10e974: 89 d1 mov %edx,%ecx 10e976: f3 aa rep stos %al,%es:(%edi) 10e978: eb d8 jmp 10e952 <_Workspace_Handler_initialization+0x1a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10e97a: 50 push %eax 10e97b: 6a 02 push $0x2 10e97d: 6a 01 push $0x1 10e97f: 6a 00 push $0x0 10e981: e8 6e df ff ff call 10c8f4 <_Internal_error_Occurred>
0010b5d4 <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
10b5d4: 55 push %ebp 10b5d5: 89 e5 mov %esp,%ebp 10b5d7: 57 push %edi 10b5d8: 56 push %esi 10b5d9: 53 push %ebx 10b5da: 83 ec 1c sub $0x1c,%esp 10b5dd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b5e0: 8b 75 0c mov 0xc(%ebp),%esi
long adjustment;
/*
* Simple validations
*/
if ( !delta )
10b5e3: 85 db test %ebx,%ebx
10b5e5: 0f 84 f1 00 00 00 je 10b6dc <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
10b5eb: 8b 53 04 mov 0x4(%ebx),%edx 10b5ee: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx
10b5f4: 0f 87 e2 00 00 00 ja 10b6dc <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
10b5fa: 85 f6 test %esi,%esi
10b5fc: 74 10 je 10b60e <adjtime+0x3a>
olddelta->tv_sec = 0;
10b5fe: c7 06 00 00 00 00 movl $0x0,(%esi)
olddelta->tv_usec = 0;
10b604: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) 10b60b: 8b 53 04 mov 0x4(%ebx),%edx
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
10b60e: 8b 03 mov (%ebx),%eax 10b610: 8d 04 80 lea (%eax,%eax,4),%eax 10b613: 8d 04 80 lea (%eax,%eax,4),%eax 10b616: 8d 04 80 lea (%eax,%eax,4),%eax 10b619: 8d 04 80 lea (%eax,%eax,4),%eax 10b61c: 8d 04 80 lea (%eax,%eax,4),%eax 10b61f: 8d 04 80 lea (%eax,%eax,4),%eax 10b622: c1 e0 06 shl $0x6,%eax
adjustment += delta->tv_usec;
10b625: 8d 04 02 lea (%edx,%eax,1),%eax
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
10b628: 3b 05 6c 42 12 00 cmp 0x12426c,%eax
10b62e: 73 0c jae 10b63c <adjtime+0x68>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
10b630: 31 c0 xor %eax,%eax
}
10b632: 8d 65 f4 lea -0xc(%ebp),%esp 10b635: 5b pop %ebx 10b636: 5e pop %esi 10b637: 5f pop %edi 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b63c: a1 d0 86 12 00 mov 0x1286d0,%eax 10b641: 40 inc %eax 10b642: a3 d0 86 12 00 mov %eax,0x1286d0
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
10b647: 83 ec 0c sub $0xc,%esp 10b64a: 8d 7d e0 lea -0x20(%ebp),%edi 10b64d: 57 push %edi 10b64e: e8 85 17 00 00 call 10cdd8 <_TOD_Get>
ts.tv_sec += delta->tv_sec;
10b653: 8b 03 mov (%ebx),%eax 10b655: 01 45 e0 add %eax,-0x20(%ebp)
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
10b658: 8b 43 04 mov 0x4(%ebx),%eax 10b65b: 8d 04 80 lea (%eax,%eax,4),%eax 10b65e: 8d 04 80 lea (%eax,%eax,4),%eax 10b661: 8d 04 80 lea (%eax,%eax,4),%eax 10b664: c1 e0 03 shl $0x3,%eax 10b667: 03 45 e4 add -0x1c(%ebp),%eax 10b66a: 89 45 e4 mov %eax,-0x1c(%ebp)
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10b66d: 83 c4 10 add $0x10,%esp 10b670: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10b675: 76 18 jbe 10b68f <adjtime+0xbb>
10b677: 8b 55 e0 mov -0x20(%ebp),%edx 10b67a: 66 90 xchg %ax,%ax
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
10b67c: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
10b681: 42 inc %edx
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10b682: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10b687: 77 f3 ja 10b67c <adjtime+0xa8> <== NEVER TAKEN
10b689: 89 45 e4 mov %eax,-0x1c(%ebp) 10b68c: 89 55 e0 mov %edx,-0x20(%ebp)
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
10b68f: 3d 00 36 65 c4 cmp $0xc4653600,%eax
10b694: 77 19 ja 10b6af <adjtime+0xdb> <== NEVER TAKEN
10b696: 8b 55 e0 mov -0x20(%ebp),%edx 10b699: 8d 76 00 lea 0x0(%esi),%esi
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
10b69c: 05 00 ca 9a 3b add $0x3b9aca00,%eax
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
10b6a1: 4a dec %edx
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
10b6a2: 3d 00 36 65 c4 cmp $0xc4653600,%eax
10b6a7: 76 f3 jbe 10b69c <adjtime+0xc8>
10b6a9: 89 45 e4 mov %eax,-0x1c(%ebp) 10b6ac: 89 55 e0 mov %edx,-0x20(%ebp)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
10b6af: 83 ec 0c sub $0xc,%esp 10b6b2: 57 push %edi 10b6b3: e8 a8 17 00 00 call 10ce60 <_TOD_Set>
_Thread_Enable_dispatch();
10b6b8: e8 ab 2c 00 00 call 10e368 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
10b6bd: 83 c4 10 add $0x10,%esp 10b6c0: 85 f6 test %esi,%esi
10b6c2: 0f 84 68 ff ff ff je 10b630 <adjtime+0x5c>
*olddelta = *delta;
10b6c8: 8b 03 mov (%ebx),%eax 10b6ca: 8b 53 04 mov 0x4(%ebx),%edx 10b6cd: 89 06 mov %eax,(%esi) 10b6cf: 89 56 04 mov %edx,0x4(%esi)
return 0;
10b6d2: 31 c0 xor %eax,%eax
}
10b6d4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6d7: 5b pop %ebx 10b6d8: 5e pop %esi 10b6d9: 5f pop %edi 10b6da: c9 leave 10b6db: c3 ret
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
10b6dc: e8 43 86 00 00 call 113d24 <__errno> 10b6e1: c7 00 16 00 00 00 movl $0x16,(%eax) 10b6e7: b8 ff ff ff ff mov $0xffffffff,%eax 10b6ec: e9 41 ff ff ff jmp 10b632 <adjtime+0x5e>
0010bd14 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10bd14: 55 push %ebp 10bd15: 89 e5 mov %esp,%ebp 10bd17: 57 push %edi 10bd18: 56 push %esi 10bd19: 53 push %ebx 10bd1a: 83 ec 18 sub $0x18,%esp 10bd1d: 8b 75 08 mov 0x8(%ebp),%esi 10bd20: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10bd23: 68 00 aa 12 00 push $0x12aa00 10bd28: e8 bf 11 00 00 call 10ceec <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10bd2d: 5a pop %edx 10bd2e: 59 pop %ecx 10bd2f: 6a 01 push $0x1 10bd31: 56 push %esi 10bd32: e8 01 6b 00 00 call 112838 <fcntl> 10bd37: 83 c4 10 add $0x10,%esp 10bd3a: 85 c0 test %eax,%eax
10bd3c: 0f 88 9b 01 00 00 js 10bedd <aio_cancel+0x1c9>
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
10bd42: 85 db test %ebx,%ebx
10bd44: 0f 84 ea 00 00 00 je 10be34 <aio_cancel+0x120>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10bd4a: 8b 3b mov (%ebx),%edi 10bd4c: 39 f7 cmp %esi,%edi
10bd4e: 0f 85 b8 00 00 00 jne 10be0c <aio_cancel+0xf8>
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10bd54: 56 push %esi 10bd55: 6a 00 push $0x0 10bd57: 57 push %edi 10bd58: 68 48 aa 12 00 push $0x12aa48 10bd5d: e8 9e 03 00 00 call 10c100 <rtems_aio_search_fd> 10bd62: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10bd64: 83 c4 10 add $0x10,%esp 10bd67: 85 c0 test %eax,%eax
10bd69: 74 3d je 10bda8 <aio_cancel+0x94>
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10bd6b: 8d 78 1c lea 0x1c(%eax),%edi 10bd6e: 83 ec 0c sub $0xc,%esp 10bd71: 57 push %edi 10bd72: e8 75 11 00 00 call 10ceec <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bd77: 58 pop %eax 10bd78: 5a pop %edx 10bd79: 53 push %ebx 10bd7a: 83 c6 08 add $0x8,%esi 10bd7d: 56 push %esi 10bd7e: e8 5d 07 00 00 call 10c4e0 <rtems_aio_remove_req> 10bd83: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10bd85: 89 3c 24 mov %edi,(%esp) 10bd88: e8 e7 11 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10bd8d: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10bd94: e8 db 11 00 00 call 10cf74 <pthread_mutex_unlock>
return result;
10bd99: 83 c4 10 add $0x10,%esp
} return AIO_ALLDONE; }
10bd9c: 89 d8 mov %ebx,%eax 10bd9e: 8d 65 f4 lea -0xc(%ebp),%esp 10bda1: 5b pop %ebx 10bda2: 5e pop %esi 10bda3: 5f pop %edi 10bda4: c9 leave 10bda5: c3 ret 10bda6: 66 90 xchg %ax,%ax
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10bda8: 81 3d 54 aa 12 00 58 cmpl $0x12aa58,0x12aa54
10bdaf: aa 12 00
10bdb2: 74 40 je 10bdf4 <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10bdb4: 51 push %ecx 10bdb5: 6a 00 push $0x0 10bdb7: 57 push %edi 10bdb8: 68 54 aa 12 00 push $0x12aa54 10bdbd: e8 3e 03 00 00 call 10c100 <rtems_aio_search_fd>
if (r_chain == NULL) {
10bdc2: 83 c4 10 add $0x10,%esp 10bdc5: 85 c0 test %eax,%eax
10bdc7: 74 43 je 10be0c <aio_cancel+0xf8>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bdc9: 83 ec 08 sub $0x8,%esp 10bdcc: 53 push %ebx 10bdcd: 83 c0 08 add $0x8,%eax 10bdd0: 50 push %eax 10bdd1: e8 0a 07 00 00 call 10c4e0 <rtems_aio_remove_req> 10bdd6: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
10bdd8: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10bddf: e8 90 11 00 00 call 10cf74 <pthread_mutex_unlock>
return result;
10bde4: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
10bde7: 89 d8 mov %ebx,%eax 10bde9: 8d 65 f4 lea -0xc(%ebp),%esp 10bdec: 5b pop %ebx 10bded: 5e pop %esi 10bdee: 5f pop %edi 10bdef: c9 leave 10bdf0: c3 ret 10bdf1: 8d 76 00 lea 0x0(%esi),%esi
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
10bdf4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdf7: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED 10bdfc: e8 73 11 00 00 call 10cf74 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10be01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be04: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10be09: eb 91 jmp 10bd9c <aio_cancel+0x88> <== NOT EXECUTED 10be0b: 90 nop <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
10be0c: 83 ec 0c sub $0xc,%esp 10be0f: 68 00 aa 12 00 push $0x12aa00 10be14: e8 5b 11 00 00 call 10cf74 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10be19: e8 7a 9d 00 00 call 115b98 <__errno> 10be1e: c7 00 16 00 00 00 movl $0x16,(%eax) 10be24: 83 c4 10 add $0x10,%esp 10be27: bb ff ff ff ff mov $0xffffffff,%ebx 10be2c: e9 6b ff ff ff jmp 10bd9c <aio_cancel+0x88> 10be31: 8d 76 00 lea 0x0(%esi),%esi
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10be34: 50 push %eax 10be35: 6a 00 push $0x0 10be37: 56 push %esi 10be38: 68 48 aa 12 00 push $0x12aa48 10be3d: e8 be 02 00 00 call 10c100 <rtems_aio_search_fd> 10be42: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10be44: 83 c4 10 add $0x10,%esp 10be47: 85 c0 test %eax,%eax
10be49: 74 3d je 10be88 <aio_cancel+0x174>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10be4b: 8d 70 1c lea 0x1c(%eax),%esi 10be4e: 83 ec 0c sub $0xc,%esp 10be51: 56 push %esi 10be52: e8 95 10 00 00 call 10ceec <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10be57: 89 1c 24 mov %ebx,(%esp) 10be5a: e8 5d 2a 00 00 call 10e8bc <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10be5f: 89 1c 24 mov %ebx,(%esp) 10be62: e8 29 06 00 00 call 10c490 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10be67: 89 34 24 mov %esi,(%esp) 10be6a: e8 05 11 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10be6f: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10be76: e8 f9 10 00 00 call 10cf74 <pthread_mutex_unlock>
return AIO_CANCELED;
10be7b: 83 c4 10 add $0x10,%esp 10be7e: 31 db xor %ebx,%ebx 10be80: e9 17 ff ff ff jmp 10bd9c <aio_cancel+0x88> 10be85: 8d 76 00 lea 0x0(%esi),%esi
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10be88: 81 3d 54 aa 12 00 58 cmpl $0x12aa58,0x12aa54
10be8f: aa 12 00
10be92: 0f 84 5c ff ff ff je 10bdf4 <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10be98: 57 push %edi 10be99: 6a 00 push $0x0 10be9b: 56 push %esi 10be9c: 68 54 aa 12 00 push $0x12aa54 10bea1: e8 5a 02 00 00 call 10c100 <rtems_aio_search_fd> 10bea6: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10bea8: 83 c4 10 add $0x10,%esp 10beab: 85 c0 test %eax,%eax
10bead: 74 53 je 10bf02 <aio_cancel+0x1ee>
10beaf: 83 ec 0c sub $0xc,%esp 10beb2: 50 push %eax 10beb3: e8 04 2a 00 00 call 10e8bc <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10beb8: 89 1c 24 mov %ebx,(%esp) 10bebb: e8 d0 05 00 00 call 10c490 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10bec0: 8d 73 1c lea 0x1c(%ebx),%esi 10bec3: 89 34 24 mov %esi,(%esp) 10bec6: e8 b5 0d 00 00 call 10cc80 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10becb: 89 34 24 mov %esi,(%esp) 10bece: e8 69 0a 00 00 call 10c93c <pthread_cond_destroy>
free (r_chain);
10bed3: 89 1c 24 mov %ebx,(%esp) 10bed6: e8 59 cc ff ff call 108b34 <free> 10bedb: eb 92 jmp 10be6f <aio_cancel+0x15b>
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
10bedd: 83 ec 0c sub $0xc,%esp 10bee0: 68 00 aa 12 00 push $0x12aa00 10bee5: e8 8a 10 00 00 call 10cf74 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10beea: e8 a9 9c 00 00 call 115b98 <__errno> 10beef: c7 00 09 00 00 00 movl $0x9,(%eax) 10bef5: 83 c4 10 add $0x10,%esp 10bef8: bb ff ff ff ff mov $0xffffffff,%ebx 10befd: e9 9a fe ff ff jmp 10bd9c <aio_cancel+0x88>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
10bf02: 83 ec 0c sub $0xc,%esp 10bf05: 68 00 aa 12 00 push $0x12aa00 10bf0a: e8 65 10 00 00 call 10cf74 <pthread_mutex_unlock>
return AIO_ALLDONE;
10bf0f: 83 c4 10 add $0x10,%esp 10bf12: b3 02 mov $0x2,%bl 10bf14: e9 83 fe ff ff jmp 10bd9c <aio_cancel+0x88>
0010bf28 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10bf28: 55 push %ebp 10bf29: 89 e5 mov %esp,%ebp 10bf2b: 53 push %ebx 10bf2c: 83 ec 04 sub $0x4,%esp 10bf2f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10bf32: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10bf39: 75 41 jne 10bf7c <aio_fsync+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10bf3b: 83 ec 08 sub $0x8,%esp 10bf3e: 6a 03 push $0x3 10bf40: ff 33 pushl (%ebx) 10bf42: e8 f1 68 00 00 call 112838 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10bf47: 83 e0 03 and $0x3,%eax 10bf4a: 48 dec %eax 10bf4b: 83 c4 10 add $0x10,%esp 10bf4e: 83 f8 01 cmp $0x1,%eax
10bf51: 77 4d ja 10bfa0 <aio_fsync+0x78>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10bf53: 83 ec 0c sub $0xc,%esp 10bf56: 6a 18 push $0x18 10bf58: e8 eb d0 ff ff call 109048 <malloc>
if (req == NULL)
10bf5d: 83 c4 10 add $0x10,%esp 10bf60: 85 c0 test %eax,%eax
10bf62: 74 57 je 10bfbb <aio_fsync+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10bf64: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10bf67: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10bf6e: 89 45 08 mov %eax,0x8(%ebp)
}
10bf71: 8b 5d fc mov -0x4(%ebp),%ebx 10bf74: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10bf75: e9 d6 05 00 00 jmp 10c550 <rtems_aio_enqueue> 10bf7a: 66 90 xchg %ax,%ax
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10bf7c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10bf83: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bf8a: e8 09 9c 00 00 call 115b98 <__errno> 10bf8f: c7 00 16 00 00 00 movl $0x16,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
10bf95: b8 ff ff ff ff mov $0xffffffff,%eax 10bf9a: 8b 5d fc mov -0x4(%ebp),%ebx 10bf9d: c9 leave 10bf9e: c3 ret 10bf9f: 90 nop
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10bfa0: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10bfa7: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10bfae: e8 e5 9b 00 00 call 115b98 <__errno> 10bfb3: c7 00 09 00 00 00 movl $0x9,(%eax) 10bfb9: eb da jmp 10bf95 <aio_fsync+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10bfbb: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10bfc2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10bfc9: e8 ca 9b 00 00 call 115b98 <__errno> <== NOT EXECUTED 10bfce: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10bfd4: eb bf jmp 10bf95 <aio_fsync+0x6d> <== NOT EXECUTED
0010c760 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10c760: 55 push %ebp 10c761: 89 e5 mov %esp,%ebp 10c763: 53 push %ebx 10c764: 83 ec 0c sub $0xc,%esp 10c767: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c76a: 6a 03 push $0x3 10c76c: ff 33 pushl (%ebx) 10c76e: e8 c5 60 00 00 call 112838 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c773: 83 c4 10 add $0x10,%esp 10c776: 83 e0 03 and $0x3,%eax
10c779: 74 05 je 10c780 <aio_read+0x20> <== NEVER TAKEN
10c77b: 83 f8 02 cmp $0x2,%eax
10c77e: 75 38 jne 10c7b8 <aio_read+0x58>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c780: 8b 53 14 mov 0x14(%ebx),%edx 10c783: 85 d2 test %edx,%edx
10c785: 75 55 jne 10c7dc <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c787: 8b 43 08 mov 0x8(%ebx),%eax 10c78a: 85 c0 test %eax,%eax
10c78c: 78 4e js 10c7dc <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c78e: 83 ec 0c sub $0xc,%esp 10c791: 6a 18 push $0x18 10c793: e8 b0 c8 ff ff call 109048 <malloc>
if (req == NULL)
10c798: 83 c4 10 add $0x10,%esp 10c79b: 85 c0 test %eax,%eax
10c79d: 74 58 je 10c7f7 <aio_read+0x97> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c79f: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10c7a2: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c7a9: 89 45 08 mov %eax,0x8(%ebp)
}
10c7ac: 8b 5d fc mov -0x4(%ebp),%ebx 10c7af: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
10c7b0: e9 9b fd ff ff jmp 10c550 <rtems_aio_enqueue> 10c7b5: 8d 76 00 lea 0x0(%esi),%esi
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10c7b8: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c7bf: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c7c6: e8 cd 93 00 00 call 115b98 <__errno> 10c7cb: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
10c7d1: b8 ff ff ff ff mov $0xffffffff,%eax 10c7d6: 8b 5d fc mov -0x4(%ebp),%ebx 10c7d9: c9 leave 10c7da: c3 ret 10c7db: 90 nop
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10c7dc: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c7e3: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c7ea: e8 a9 93 00 00 call 115b98 <__errno> 10c7ef: c7 00 16 00 00 00 movl $0x16,(%eax) 10c7f5: eb da jmp 10c7d1 <aio_read+0x71>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c7f7: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c7fe: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c805: e8 8e 93 00 00 call 115b98 <__errno> <== NOT EXECUTED 10c80a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c810: eb bf jmp 10c7d1 <aio_read+0x71> <== NOT EXECUTED
0010c820 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10c820: 55 push %ebp 10c821: 89 e5 mov %esp,%ebp 10c823: 53 push %ebx 10c824: 83 ec 0c sub $0xc,%esp 10c827: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c82a: 6a 03 push $0x3 10c82c: ff 33 pushl (%ebx) 10c82e: e8 05 60 00 00 call 112838 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c833: 83 e0 03 and $0x3,%eax 10c836: 48 dec %eax 10c837: 83 c4 10 add $0x10,%esp 10c83a: 83 f8 01 cmp $0x1,%eax
10c83d: 77 35 ja 10c874 <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c83f: 8b 53 14 mov 0x14(%ebx),%edx 10c842: 85 d2 test %edx,%edx
10c844: 75 52 jne 10c898 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c846: 8b 43 08 mov 0x8(%ebx),%eax 10c849: 85 c0 test %eax,%eax
10c84b: 78 4b js 10c898 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c84d: 83 ec 0c sub $0xc,%esp 10c850: 6a 18 push $0x18 10c852: e8 f1 c7 ff ff call 109048 <malloc>
if (req == NULL)
10c857: 83 c4 10 add $0x10,%esp 10c85a: 85 c0 test %eax,%eax
10c85c: 74 55 je 10c8b3 <aio_write+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c85e: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10c861: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c868: 89 45 08 mov %eax,0x8(%ebp)
}
10c86b: 8b 5d fc mov -0x4(%ebp),%ebx 10c86e: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
10c86f: e9 dc fc ff ff jmp 10c550 <rtems_aio_enqueue>
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10c874: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10c87b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c882: e8 11 93 00 00 call 115b98 <__errno> 10c887: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
10c88d: b8 ff ff ff ff mov $0xffffffff,%eax 10c892: 8b 5d fc mov -0x4(%ebp),%ebx 10c895: c9 leave 10c896: c3 ret 10c897: 90 nop
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10c898: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10c89f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10c8a6: e8 ed 92 00 00 call 115b98 <__errno> 10c8ab: c7 00 16 00 00 00 movl $0x16,(%eax) 10c8b1: eb da jmp 10c88d <aio_write+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c8b3: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10c8ba: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10c8c1: e8 d2 92 00 00 call 115b98 <__errno> <== NOT EXECUTED 10c8c6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10c8cc: eb bf jmp 10c88d <aio_write+0x6d> <== NOT EXECUTED
0010b454 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
10b454: 55 push %ebp 10b455: 89 e5 mov %esp,%ebp 10b457: 83 ec 08 sub $0x8,%esp 10b45a: 8b 45 08 mov 0x8(%ebp),%eax 10b45d: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10b460: 85 d2 test %edx,%edx
10b462: 74 14 je 10b478 <clock_gettime+0x24>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10b464: 83 f8 01 cmp $0x1,%eax
10b467: 74 47 je 10b4b0 <clock_gettime+0x5c>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
10b469: 83 f8 04 cmp $0x4,%eax
10b46c: 74 32 je 10b4a0 <clock_gettime+0x4c> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
10b46e: 83 f8 02 cmp $0x2,%eax
10b471: 74 2d je 10b4a0 <clock_gettime+0x4c>
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
10b473: 83 f8 03 cmp $0x3,%eax
10b476: 74 14 je 10b48c <clock_gettime+0x38>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
10b478: e8 ef 8d 00 00 call 11426c <__errno> 10b47d: c7 00 16 00 00 00 movl $0x16,(%eax) 10b483: b8 ff ff ff ff mov $0xffffffff,%eax
return 0;
}
10b488: c9 leave 10b489: c3 ret 10b48a: 66 90 xchg %ax,%ax
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
10b48c: e8 db 8d 00 00 call 11426c <__errno> 10b491: c7 00 58 00 00 00 movl $0x58,(%eax) 10b497: b8 ff ff ff ff mov $0xffffffff,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b49c: c9 leave 10b49d: c3 ret 10b49e: 66 90 xchg %ax,%ax
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
_TOD_Get_uptime_as_timespec( tp );
10b4a0: 83 ec 0c sub $0xc,%esp 10b4a3: 52 push %edx 10b4a4: e8 97 1e 00 00 call 10d340 <_TOD_Get_uptime_as_timespec>
return 0;
10b4a9: 83 c4 10 add $0x10,%esp 10b4ac: 31 c0 xor %eax,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b4ae: c9 leave 10b4af: c3 ret
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
10b4b0: 83 ec 0c sub $0xc,%esp 10b4b3: 52 push %edx 10b4b4: e8 33 1e 00 00 call 10d2ec <_TOD_Get>
return 0;
10b4b9: 83 c4 10 add $0x10,%esp 10b4bc: 31 c0 xor %eax,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b4be: c9 leave 10b4bf: c3 ret
0010b4c0 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10b4c0: 55 push %ebp 10b4c1: 89 e5 mov %esp,%ebp 10b4c3: 83 ec 08 sub $0x8,%esp 10b4c6: 8b 45 08 mov 0x8(%ebp),%eax 10b4c9: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10b4cc: 85 d2 test %edx,%edx
10b4ce: 74 0f je 10b4df <clock_settime+0x1f> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10b4d0: 83 f8 01 cmp $0x1,%eax
10b4d3: 74 1f je 10b4f4 <clock_settime+0x34>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10b4d5: 83 f8 02 cmp $0x2,%eax
10b4d8: 74 42 je 10b51c <clock_settime+0x5c>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10b4da: 83 f8 03 cmp $0x3,%eax
10b4dd: 74 3d je 10b51c <clock_settime+0x5c>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10b4df: e8 88 8d 00 00 call 11426c <__errno> 10b4e4: c7 00 16 00 00 00 movl $0x16,(%eax) 10b4ea: b8 ff ff ff ff mov $0xffffffff,%eax
return 0;
}
10b4ef: c9 leave 10b4f0: c3 ret 10b4f1: 8d 76 00 lea 0x0(%esi),%esi
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10b4f4: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10b4fa: 76 e3 jbe 10b4df <clock_settime+0x1f>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4fc: a1 b0 9d 12 00 mov 0x129db0,%eax 10b501: 40 inc %eax 10b502: a3 b0 9d 12 00 mov %eax,0x129db0
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10b507: 83 ec 0c sub $0xc,%esp 10b50a: 52 push %edx 10b50b: e8 88 1e 00 00 call 10d398 <_TOD_Set>
_Thread_Enable_dispatch();
10b510: e8 8b 33 00 00 call 10e8a0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10b515: 83 c4 10 add $0x10,%esp 10b518: 31 c0 xor %eax,%eax
}
10b51a: c9 leave 10b51b: c3 ret
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
10b51c: e8 4b 8d 00 00 call 11426c <__errno> 10b521: c7 00 58 00 00 00 movl $0x58,(%eax) 10b527: b8 ff ff ff ff mov $0xffffffff,%eax
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b52c: c9 leave 10b52d: c3 ret
0010b234 <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
10b234: 55 push %ebp 10b235: 89 e5 mov %esp,%ebp 10b237: 83 ec 08 sub $0x8,%esp
if ( !value )
10b23a: 8b 45 0c mov 0xc(%ebp),%eax 10b23d: 85 c0 test %eax,%eax
10b23f: 74 2f je 10b270 <getitimer+0x3c>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10b241: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b245: 76 15 jbe 10b25c <getitimer+0x28>
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b247: e8 34 87 00 00 call 113980 <__errno> 10b24c: c7 00 16 00 00 00 movl $0x16,(%eax)
}
10b252: b8 ff ff ff ff mov $0xffffffff,%eax 10b257: c9 leave 10b258: c3 ret 10b259: 8d 76 00 lea 0x0(%esi),%esi
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
10b25c: e8 1f 87 00 00 call 113980 <__errno> 10b261: c7 00 58 00 00 00 movl $0x58,(%eax)
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b267: b8 ff ff ff ff mov $0xffffffff,%eax 10b26c: c9 leave 10b26d: c3 ret 10b26e: 66 90 xchg %ax,%ax
int which,
struct itimerval *value
)
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
10b270: e8 0b 87 00 00 call 113980 <__errno> 10b275: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b27b: eb d5 jmp 10b252 <getitimer+0x1e>
001249b8 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
1249b8: 55 push %ebp 1249b9: 89 e5 mov %esp,%ebp 1249bb: 57 push %edi 1249bc: 56 push %esi 1249bd: 53 push %ebx 1249be: 83 ec 3c sub $0x3c,%esp 1249c1: 8b 75 0c mov 0xc(%ebp),%esi 1249c4: 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() )
1249c7: e8 00 fd ff ff call 1246cc <getpid> 1249cc: 3b 45 08 cmp 0x8(%ebp),%eax
1249cf: 0f 85 3f 02 00 00 jne 124c14 <killinfo+0x25c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
1249d5: 85 f6 test %esi,%esi
1249d7: 0f 84 4c 02 00 00 je 124c29 <killinfo+0x271>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
1249dd: 8d 4e ff lea -0x1(%esi),%ecx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
1249e0: 83 f9 1f cmp $0x1f,%ecx
1249e3: 0f 87 40 02 00 00 ja 124c29 <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 )
1249e9: 8d 04 76 lea (%esi,%esi,2),%eax 1249ec: 83 3c 85 28 f1 12 00 cmpl $0x1,0x12f128(,%eax,4)
1249f3: 01 1249f4: 0f 84 e6 01 00 00 je 124be0 <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 ) )
1249fa: 83 fe 08 cmp $0x8,%esi
1249fd: 0f 84 c9 00 00 00 je 124acc <killinfo+0x114>
124a03: 83 fe 04 cmp $0x4,%esi
124a06: 0f 84 c0 00 00 00 je 124acc <killinfo+0x114>
124a0c: 83 fe 0b cmp $0xb,%esi
124a0f: 0f 84 b7 00 00 00 je 124acc <killinfo+0x114>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124a15: bb 01 00 00 00 mov $0x1,%ebx 124a1a: d3 e3 shl %cl,%ebx
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
124a1c: 89 75 dc mov %esi,-0x24(%ebp)
siginfo->si_code = SI_USER;
124a1f: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
124a26: 85 ff test %edi,%edi
124a28: 0f 84 ba 01 00 00 je 124be8 <killinfo+0x230>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
124a2e: 8b 07 mov (%edi),%eax 124a30: 89 45 e4 mov %eax,-0x1c(%ebp) 124a33: a1 10 eb 12 00 mov 0x12eb10,%eax 124a38: 40 inc %eax 124a39: a3 10 eb 12 00 mov %eax,0x12eb10
/*
* 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;
124a3e: 8b 0d b8 f0 12 00 mov 0x12f0b8,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
124a44: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax 124a4a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 124a50: f7 d0 not %eax 124a52: 85 c3 test %eax,%ebx
124a54: 75 34 jne 124a8a <killinfo+0xd2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124a56: a1 c0 f2 12 00 mov 0x12f2c0,%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 );
124a5b: 3d c4 f2 12 00 cmp $0x12f2c4,%eax
124a60: 75 1b jne 124a7d <killinfo+0xc5>
124a62: e9 81 00 00 00 jmp 124ae8 <killinfo+0x130> 124a67: 90 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
124a68: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 124a6e: f7 d2 not %edx 124a70: 85 d3 test %edx,%ebx
124a72: 75 16 jne 124a8a <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 ) {
124a74: 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 );
124a76: 3d c4 f2 12 00 cmp $0x12f2c4,%eax
124a7b: 74 6b je 124ae8 <killinfo+0x130> <== ALWAYS TAKEN
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
124a7d: 89 c1 mov %eax,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124a7f: 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)
124a85: 85 58 30 test %ebx,0x30(%eax)
124a88: 74 de je 124a68 <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 ) ) {
124a8a: 50 push %eax
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
124a8b: 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 ) ) {
124a8e: 50 push %eax 124a8f: 56 push %esi 124a90: 51 push %ecx 124a91: e8 d6 01 00 00 call 124c6c <_POSIX_signals_Unblock_thread> 124a96: 83 c4 10 add $0x10,%esp 124a99: 84 c0 test %al,%al
124a9b: 75 1f jne 124abc <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 );
124a9d: 83 ec 0c sub $0xc,%esp 124aa0: 53 push %ebx 124aa1: e8 b2 01 00 00 call 124c58 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
124aa6: 8d 1c 76 lea (%esi,%esi,2),%ebx 124aa9: c1 e3 02 shl $0x2,%ebx 124aac: 83 c4 10 add $0x10,%esp 124aaf: 83 bb 20 f1 12 00 02 cmpl $0x2,0x12f120(%ebx)
124ab6: 0f 84 e4 00 00 00 je 124ba0 <killinfo+0x1e8>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
124abc: e8 17 e0 fe ff call 112ad8 <_Thread_Enable_dispatch>
return 0;
124ac1: 31 c0 xor %eax,%eax
}
124ac3: 8d 65 f4 lea -0xc(%ebp),%esp 124ac6: 5b pop %ebx 124ac7: 5e pop %esi 124ac8: 5f pop %edi 124ac9: c9 leave 124aca: c3 ret 124acb: 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 );
124acc: e8 7b 03 00 00 call 124e4c <pthread_self> 124ad1: 83 ec 08 sub $0x8,%esp 124ad4: 56 push %esi 124ad5: 50 push %eax 124ad6: e8 b1 02 00 00 call 124d8c <pthread_kill> 124adb: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124ade: 8d 65 f4 lea -0xc(%ebp),%esp 124ae1: 5b pop %ebx 124ae2: 5e pop %esi 124ae3: 5f pop %edi 124ae4: c9 leave 124ae5: c3 ret 124ae6: 66 90 xchg %ax,%ax
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
124ae8: 0f b6 05 54 a6 12 00 movzbl 0x12a654,%eax 124aef: 40 inc %eax 124af0: 89 45 d4 mov %eax,-0x2c(%ebp)
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
124af3: 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++) {
124afa: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) 124b01: 89 5d d0 mov %ebx,-0x30(%ebp) 124b04: 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 ] )
124b07: 8b 55 cc mov -0x34(%ebp),%edx 124b0a: 8b 04 95 e8 ea 12 00 mov 0x12eae8(,%edx,4),%eax 124b11: 85 c0 test %eax,%eax
124b13: 74 68 je 124b7d <killinfo+0x1c5> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
124b15: 8b 40 04 mov 0x4(%eax),%eax
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
124b18: 0f b7 70 10 movzwl 0x10(%eax),%esi
object_table = the_info->local_table;
124b1c: 8b 78 1c mov 0x1c(%eax),%edi
for ( index = 1 ; index <= maximum ; index++ ) {
124b1f: 85 f6 test %esi,%esi
124b21: 74 5a je 124b7d <killinfo+0x1c5>
124b23: b8 01 00 00 00 mov $0x1,%eax
the_thread = (Thread_Control *) object_table[ index ];
124b28: 8b 14 87 mov (%edi,%eax,4),%edx
if ( !the_thread )
124b2b: 85 d2 test %edx,%edx
124b2d: 74 49 je 124b78 <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 )
124b2f: 8b 4a 14 mov 0x14(%edx),%ecx 124b32: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124b35: 77 41 ja 124b78 <killinfo+0x1c0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
124b37: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx 124b3d: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx 124b43: f7 d3 not %ebx 124b45: 85 5d d0 test %ebx,-0x30(%ebp)
124b48: 74 2e je 124b78 <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 ) {
124b4a: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124b4d: 72 21 jb 124b70 <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 ) ) {
124b4f: 8b 5d c8 mov -0x38(%ebp),%ebx 124b52: 85 db test %ebx,%ebx
124b54: 74 22 je 124b78 <killinfo+0x1c0> <== NEVER TAKEN
124b56: 8b 5d c8 mov -0x38(%ebp),%ebx 124b59: 8b 5b 10 mov 0x10(%ebx),%ebx 124b5c: 89 5d c4 mov %ebx,-0x3c(%ebp) 124b5f: 85 db test %ebx,%ebx
124b61: 74 15 je 124b78 <killinfo+0x1c0> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
124b63: 8b 5a 10 mov 0x10(%edx),%ebx 124b66: 85 db test %ebx,%ebx
124b68: 0f 85 86 00 00 00 jne 124bf4 <killinfo+0x23c>
124b6e: 66 90 xchg %ax,%ax 124b70: 89 4d d4 mov %ecx,-0x2c(%ebp) 124b73: 89 55 c8 mov %edx,-0x38(%ebp) 124b76: 66 90 xchg %ax,%ax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
124b78: 40 inc %eax 124b79: 39 c6 cmp %eax,%esi
124b7b: 73 ab jae 124b28 <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++) {
124b7d: ff 45 cc incl -0x34(%ebp) 124b80: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
124b84: 75 81 jne 124b07 <killinfo+0x14f>
124b86: 8b 5d d0 mov -0x30(%ebp),%ebx 124b89: 8b 75 c0 mov -0x40(%ebp),%esi
}
}
}
}
if ( interested ) {
124b8c: 8b 55 c8 mov -0x38(%ebp),%edx 124b8f: 85 d2 test %edx,%edx
124b91: 0f 84 06 ff ff ff je 124a9d <killinfo+0xe5>
124b97: 8b 4d c8 mov -0x38(%ebp),%ecx 124b9a: e9 eb fe ff ff jmp 124a8a <killinfo+0xd2> 124b9f: 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 );
124ba0: 83 ec 0c sub $0xc,%esp 124ba3: 68 a0 f2 12 00 push $0x12f2a0 124ba8: e8 ef c4 fe ff call 11109c <_Chain_Get>
if ( !psiginfo ) {
124bad: 83 c4 10 add $0x10,%esp 124bb0: 85 c0 test %eax,%eax
124bb2: 0f 84 86 00 00 00 je 124c3e <killinfo+0x286>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
124bb8: 8d 78 08 lea 0x8(%eax),%edi 124bbb: 8d 75 dc lea -0x24(%ebp),%esi 124bbe: b9 03 00 00 00 mov $0x3,%ecx 124bc3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
124bc5: 83 ec 08 sub $0x8,%esp 124bc8: 50 push %eax 124bc9: 81 c3 40 f3 12 00 add $0x12f340,%ebx 124bcf: 53 push %ebx 124bd0: e8 8b c4 fe ff call 111060 <_Chain_Append> 124bd5: 83 c4 10 add $0x10,%esp 124bd8: e9 df fe ff ff jmp 124abc <killinfo+0x104> 124bdd: 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;
124be0: 31 c0 xor %eax,%eax 124be2: e9 f7 fe ff ff jmp 124ade <killinfo+0x126> 124be7: 90 nop
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
124be8: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 124bef: e9 3f fe ff ff jmp 124a33 <killinfo+0x7b>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
124bf4: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp)
124bfb: 0f 85 77 ff ff ff jne 124b78 <killinfo+0x1c0>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
124c01: 81 e3 00 00 00 10 and $0x10000000,%ebx
124c07: 0f 84 6b ff ff ff je 124b78 <killinfo+0x1c0>
124c0d: e9 5e ff ff ff jmp 124b70 <killinfo+0x1b8> 124c12: 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 );
124c14: e8 1f 38 ff ff call 118438 <__errno> 124c19: c7 00 03 00 00 00 movl $0x3,(%eax) 124c1f: b8 ff ff ff ff mov $0xffffffff,%eax 124c24: e9 b5 fe ff ff jmp 124ade <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 );
124c29: e8 0a 38 ff ff call 118438 <__errno> 124c2e: c7 00 16 00 00 00 movl $0x16,(%eax) 124c34: b8 ff ff ff ff mov $0xffffffff,%eax 124c39: e9 a0 fe ff ff jmp 124ade <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();
124c3e: e8 95 de fe ff call 112ad8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
124c43: e8 f0 37 ff ff call 118438 <__errno> 124c48: c7 00 0b 00 00 00 movl $0xb,(%eax) 124c4e: 83 c8 ff or $0xffffffff,%eax 124c51: e9 88 fe ff ff jmp 124ade <killinfo+0x126>
0010fb14 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
10fb14: 55 push %ebp 10fb15: 89 e5 mov %esp,%ebp 10fb17: 57 push %edi 10fb18: 56 push %esi 10fb19: 53 push %ebx 10fb1a: 83 ec 2c sub $0x2c,%esp 10fb1d: 8b 75 0c mov 0xc(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10fb20: a1 f0 0e 13 00 mov 0x130ef0,%eax 10fb25: 40 inc %eax 10fb26: a3 f0 0e 13 00 mov %eax,0x130ef0
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10fb2b: 89 f0 mov %esi,%eax 10fb2d: 25 00 02 00 00 and $0x200,%eax 10fb32: 89 45 d4 mov %eax,-0x2c(%ebp)
10fb35: 0f 85 c9 00 00 00 jne 10fc04 <mq_open+0xf0>
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
10fb3b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
_Objects_Allocate( &_POSIX_Message_queue_Information_fds );
10fb42: 83 ec 0c sub $0xc,%esp 10fb45: 68 20 14 13 00 push $0x131420 10fb4a: e8 55 2c 00 00 call 1127a4 <_Objects_Allocate> 10fb4f: 89 c3 mov %eax,%ebx
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
10fb51: 83 c4 10 add $0x10,%esp 10fb54: 85 c0 test %eax,%eax
10fb56: 0f 84 b4 00 00 00 je 10fc10 <mq_open+0xfc>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
10fb5c: 89 70 14 mov %esi,0x14(%eax)
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
10fb5f: 83 ec 08 sub $0x8,%esp 10fb62: 8d 45 e4 lea -0x1c(%ebp),%eax 10fb65: 50 push %eax 10fb66: ff 75 08 pushl 0x8(%ebp) 10fb69: e8 c2 69 00 00 call 116530 <_POSIX_Message_queue_Name_to_id> 10fb6e: 89 c7 mov %eax,%edi
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
10fb70: 83 c4 10 add $0x10,%esp 10fb73: 85 c0 test %eax,%eax
10fb75: 75 59 jne 10fbd0 <mq_open+0xbc>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10fb77: 81 e6 00 0a 00 00 and $0xa00,%esi 10fb7d: 81 fe 00 0a 00 00 cmp $0xa00,%esi
10fb83: 0f 84 a7 00 00 00 je 10fc30 <mq_open+0x11c>
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
10fb89: 50 push %eax
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
10fb8a: 8d 45 dc lea -0x24(%ebp),%eax 10fb8d: 50 push %eax 10fb8e: ff 75 e4 pushl -0x1c(%ebp) 10fb91: 68 80 12 13 00 push $0x131280 10fb96: e8 bd 30 00 00 call 112c58 <_Objects_Get> 10fb9b: 89 45 e0 mov %eax,-0x20(%ebp)
the_mq->open_count += 1;
10fb9e: ff 40 18 incl 0x18(%eax)
the_mq_fd->Queue = the_mq;
10fba1: 89 43 10 mov %eax,0x10(%ebx)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
10fba4: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10fba8: a1 3c 14 13 00 mov 0x13143c,%eax 10fbad: 89 1c 90 mov %ebx,(%eax,%edx,4)
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
10fbb0: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
10fbb7: e8 94 3c 00 00 call 113850 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10fbbc: e8 8f 3c 00 00 call 113850 <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
10fbc1: 8b 43 08 mov 0x8(%ebx),%eax 10fbc4: 83 c4 10 add $0x10,%esp
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fbc7: 8d 65 f4 lea -0xc(%ebp),%esp 10fbca: 5b pop %ebx 10fbcb: 5e pop %esi 10fbcc: 5f pop %edi 10fbcd: c9 leave 10fbce: c3 ret 10fbcf: 90 nop
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10fbd0: 83 f8 02 cmp $0x2,%eax
10fbd3: 0f 84 87 00 00 00 je 10fc60 <mq_open+0x14c>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
10fbd9: 83 ec 08 sub $0x8,%esp 10fbdc: 53 push %ebx 10fbdd: 68 20 14 13 00 push $0x131420 10fbe2: e8 31 2f 00 00 call 112b18 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fbe7: e8 64 3c 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
10fbec: e8 23 9c 00 00 call 119814 <__errno> 10fbf1: 89 38 mov %edi,(%eax) 10fbf3: 83 c4 10 add $0x10,%esp 10fbf6: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fbfb: 8d 65 f4 lea -0xc(%ebp),%esp 10fbfe: 5b pop %ebx 10fbff: 5e pop %esi 10fc00: 5f pop %edi 10fc01: c9 leave 10fc02: c3 ret 10fc03: 90 nop
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
10fc04: 8b 45 14 mov 0x14(%ebp),%eax 10fc07: 89 45 d0 mov %eax,-0x30(%ebp) 10fc0a: e9 33 ff ff ff jmp 10fb42 <mq_open+0x2e> 10fc0f: 90 nop
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
_Thread_Enable_dispatch();
10fc10: e8 3b 3c 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
10fc15: e8 fa 9b 00 00 call 119814 <__errno> 10fc1a: c7 00 17 00 00 00 movl $0x17,(%eax) 10fc20: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fc25: 8d 65 f4 lea -0xc(%ebp),%esp 10fc28: 5b pop %ebx 10fc29: 5e pop %esi 10fc2a: 5f pop %edi 10fc2b: c9 leave 10fc2c: c3 ret 10fc2d: 8d 76 00 lea 0x0(%esi),%esi 10fc30: 83 ec 08 sub $0x8,%esp 10fc33: 53 push %ebx 10fc34: 68 20 14 13 00 push $0x131420 10fc39: e8 da 2e 00 00 call 112b18 <_Objects_Free>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fc3e: e8 0d 3c 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
10fc43: e8 cc 9b 00 00 call 119814 <__errno> 10fc48: c7 00 11 00 00 00 movl $0x11,(%eax) 10fc4e: 83 c4 10 add $0x10,%esp 10fc51: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fc56: 8d 65 f4 lea -0xc(%ebp),%esp 10fc59: 5b pop %ebx 10fc5a: 5e pop %esi 10fc5b: 5f pop %edi 10fc5c: c9 leave 10fc5d: c3 ret 10fc5e: 66 90 xchg %ax,%ax
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10fc60: 8b 55 d4 mov -0x2c(%ebp),%edx 10fc63: 85 d2 test %edx,%edx
10fc65: 0f 84 6e ff ff ff je 10fbd9 <mq_open+0xc5>
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
10fc6b: 8d 45 e0 lea -0x20(%ebp),%eax 10fc6e: 50 push %eax 10fc6f: ff 75 d0 pushl -0x30(%ebp) 10fc72: 6a 01 push $0x1 10fc74: ff 75 08 pushl 0x8(%ebp) 10fc77: e8 2c 67 00 00 call 1163a8 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
10fc7c: 83 c4 10 add $0x10,%esp 10fc7f: 40 inc %eax
10fc80: 74 26 je 10fca8 <mq_open+0x194>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
10fc82: 8b 45 e0 mov -0x20(%ebp),%eax 10fc85: 89 43 10 mov %eax,0x10(%ebx)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
10fc88: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10fc8c: a1 3c 14 13 00 mov 0x13143c,%eax 10fc91: 89 1c 90 mov %ebx,(%eax,%edx,4)
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
10fc94: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
10fc9b: e8 b0 3b 00 00 call 113850 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
10fca0: 8b 43 08 mov 0x8(%ebx),%eax 10fca3: e9 1f ff ff ff jmp 10fbc7 <mq_open+0xb3> 10fca8: 83 ec 08 sub $0x8,%esp 10fcab: 53 push %ebx 10fcac: 68 20 14 13 00 push $0x131420 10fcb1: e8 62 2e 00 00 call 112b18 <_Objects_Free>
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fcb6: e8 95 3b 00 00 call 113850 <_Thread_Enable_dispatch>
return (mqd_t) -1;
10fcbb: 83 c4 10 add $0x10,%esp 10fcbe: b8 ff ff ff ff mov $0xffffffff,%eax 10fcc3: e9 ff fe ff ff jmp 10fbc7 <mq_open+0xb3>
0011fe04 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
11fe04: 55 push %ebp 11fe05: 89 e5 mov %esp,%ebp 11fe07: 56 push %esi 11fe08: 53 push %ebx 11fe09: 8b 75 08 mov 0x8(%ebp),%esi 11fe0c: 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 ) )
11fe0f: 83 ec 0c sub $0xc,%esp 11fe12: 56 push %esi 11fe13: e8 80 01 00 00 call 11ff98 <_Timespec_Is_valid> 11fe18: 83 c4 10 add $0x10,%esp 11fe1b: 84 c0 test %al,%al
11fe1d: 0f 84 e1 00 00 00 je 11ff04 <nanosleep+0x100>
rtems_set_errno_and_return_minus_one( EINVAL );
ticks = _Timespec_To_ticks( rqtp );
11fe23: 83 ec 0c sub $0xc,%esp 11fe26: 56 push %esi 11fe27: e8 6c 1f ff ff call 111d98 <_Timespec_To_ticks> 11fe2c: 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 ) {
11fe2e: 83 c4 10 add $0x10,%esp 11fe31: 85 c0 test %eax,%eax
11fe33: 75 37 jne 11fe6c <nanosleep+0x68>
11fe35: a1 90 8c 12 00 mov 0x128c90,%eax 11fe3a: 40 inc %eax 11fe3b: a3 90 8c 12 00 mov %eax,0x128c90
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
11fe40: ff 15 0c 48 12 00 call *0x12480c
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
11fe46: e8 75 df fe ff call 10ddc0 <_Thread_Enable_dispatch>
if ( rmtp ) {
11fe4b: 85 db test %ebx,%ebx
11fe4d: 0f 84 93 00 00 00 je 11fee6 <nanosleep+0xe2>
rmtp->tv_sec = 0;
11fe53: c7 03 00 00 00 00 movl $0x0,(%ebx)
rmtp->tv_nsec = 0;
11fe59: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
}
return 0;
11fe60: 31 c0 xor %eax,%eax
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
}
11fe62: 8d 65 f8 lea -0x8(%ebp),%esp 11fe65: 5b pop %ebx 11fe66: 5e pop %esi 11fe67: c9 leave 11fe68: c3 ret 11fe69: 8d 76 00 lea 0x0(%esi),%esi 11fe6c: a1 90 8c 12 00 mov 0x128c90,%eax 11fe71: 40 inc %eax 11fe72: a3 90 8c 12 00 mov %eax,0x128c90
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
11fe77: 83 ec 08 sub $0x8,%esp 11fe7a: 68 08 00 00 10 push $0x10000008 11fe7f: ff 35 38 92 12 00 pushl 0x129238 11fe85: e8 56 e7 fe ff call 10e5e0 <_Thread_Set_state>
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
11fe8a: 8b 15 38 92 12 00 mov 0x129238,%edx
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
11fe90: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
11fe93: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
11fe9a: c7 42 64 0c dc 10 00 movl $0x10dc0c,0x64(%edx)
the_watchdog->id = id;
11fea1: 89 42 68 mov %eax,0x68(%edx)
the_watchdog->user_data = user_data;
11fea4: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
11feab: 89 72 54 mov %esi,0x54(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
11feae: 58 pop %eax 11feaf: 59 pop %ecx
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
11feb0: 83 c2 48 add $0x48,%edx 11feb3: 52 push %edx 11feb4: 68 60 8d 12 00 push $0x128d60 11feb9: e8 ea ec fe ff call 10eba8 <_Watchdog_Insert>
_Thread_Enable_dispatch();
11febe: e8 fd de fe ff call 10ddc0 <_Thread_Enable_dispatch>
/* calculate time remaining */
if ( rmtp ) {
11fec3: 83 c4 10 add $0x10,%esp 11fec6: 85 db test %ebx,%ebx
11fec8: 74 1c je 11fee6 <nanosleep+0xe2>
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
11feca: a1 38 92 12 00 mov 0x129238,%eax 11fecf: 03 70 5c add 0x5c(%eax),%esi
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
11fed2: 2b 70 60 sub 0x60(%eax),%esi
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
11fed5: 83 ec 08 sub $0x8,%esp 11fed8: 53 push %ebx 11fed9: 56 push %esi 11feda: e8 71 00 00 00 call 11ff50 <_Timespec_From_ticks>
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
11fedf: 83 c4 10 add $0x10,%esp 11fee2: 85 f6 test %esi,%esi
11fee4: 75 09 jne 11feef <nanosleep+0xeb>
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
11fee6: 31 c0 xor %eax,%eax
}
11fee8: 8d 65 f8 lea -0x8(%ebp),%esp 11feeb: 5b pop %ebx 11feec: 5e pop %esi 11feed: c9 leave 11feee: 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 );
11feef: e8 1c 38 ff ff call 113710 <__errno> 11fef4: c7 00 04 00 00 00 movl $0x4,(%eax) 11fefa: b8 ff ff ff ff mov $0xffffffff,%eax 11feff: e9 5e ff ff ff jmp 11fe62 <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 );
11ff04: e8 07 38 ff ff call 113710 <__errno> 11ff09: c7 00 16 00 00 00 movl $0x16,(%eax) 11ff0f: b8 ff ff ff ff mov $0xffffffff,%eax 11ff14: e9 49 ff ff ff jmp 11fe62 <nanosleep+0x5e>
00110950 <pthread_attr_destroy>:
#include <rtems/system.h>
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
110950: 55 push %ebp 110951: 89 e5 mov %esp,%ebp 110953: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
110956: 85 c0 test %eax,%eax
110958: 74 12 je 11096c <pthread_attr_destroy+0x1c>
11095a: 8b 10 mov (%eax),%edx 11095c: 85 d2 test %edx,%edx
11095e: 74 0c je 11096c <pthread_attr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
110960: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
110966: 31 c0 xor %eax,%eax
}
110968: c9 leave 110969: c3 ret 11096a: 66 90 xchg %ax,%ax
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
11096c: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
110971: c9 leave 110972: c3 ret
00110ff0 <pthread_attr_getcputime>:
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
110ff0: 55 push %ebp 110ff1: 89 e5 mov %esp,%ebp 110ff3: 8b 45 08 mov 0x8(%ebp),%eax 110ff6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized || !clock_allowed )
110ff9: 85 c0 test %eax,%eax
110ffb: 74 13 je 111010 <pthread_attr_getcputime+0x20><== NEVER TAKEN
110ffd: 8b 08 mov (%eax),%ecx 110fff: 85 c9 test %ecx,%ecx
111001: 74 0d je 111010 <pthread_attr_getcputime+0x20>
111003: 85 d2 test %edx,%edx
111005: 74 09 je 111010 <pthread_attr_getcputime+0x20>
return EINVAL;
*clock_allowed = attr->cputime_clock_allowed;
111007: 8b 40 38 mov 0x38(%eax),%eax 11100a: 89 02 mov %eax,(%edx)
return 0;
11100c: 31 c0 xor %eax,%eax
}
11100e: c9 leave 11100f: c3 ret
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
return EINVAL;
111010: b8 16 00 00 00 mov $0x16,%eax
*clock_allowed = attr->cputime_clock_allowed;
return 0;
}
111015: c9 leave 111016: c3 ret
00110a9c <pthread_attr_getstack>:
int pthread_attr_getstack(
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
110a9c: 55 push %ebp 110a9d: 89 e5 mov %esp,%ebp 110a9f: 53 push %ebx 110aa0: 8b 45 08 mov 0x8(%ebp),%eax 110aa3: 8b 55 0c mov 0xc(%ebp),%edx 110aa6: 8b 4d 10 mov 0x10(%ebp),%ecx
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
110aa9: 85 c0 test %eax,%eax
110aab: 74 1f je 110acc <pthread_attr_getstack+0x30>
110aad: 8b 18 mov (%eax),%ebx 110aaf: 85 db test %ebx,%ebx
110ab1: 74 19 je 110acc <pthread_attr_getstack+0x30>
110ab3: 85 d2 test %edx,%edx
110ab5: 74 15 je 110acc <pthread_attr_getstack+0x30>
110ab7: 85 c9 test %ecx,%ecx
110ab9: 74 11 je 110acc <pthread_attr_getstack+0x30>
return EINVAL;
*stackaddr = attr->stackaddr;
110abb: 8b 58 04 mov 0x4(%eax),%ebx 110abe: 89 1a mov %ebx,(%edx)
*stacksize = attr->stacksize;
110ac0: 8b 40 08 mov 0x8(%eax),%eax 110ac3: 89 01 mov %eax,(%ecx)
return 0;
110ac5: 31 c0 xor %eax,%eax
}
110ac7: 5b pop %ebx 110ac8: c9 leave 110ac9: c3 ret 110aca: 66 90 xchg %ax,%ax
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
110acc: b8 16 00 00 00 mov $0x16,%eax
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
110ad1: 5b pop %ebx 110ad2: c9 leave 110ad3: c3 ret
00110b50 <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
110b50: 55 push %ebp 110b51: 89 e5 mov %esp,%ebp 110b53: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
110b56: 85 c0 test %eax,%eax
110b58: 74 12 je 110b6c <pthread_attr_setguardsize+0x1c>
110b5a: 8b 10 mov (%eax),%edx 110b5c: 85 d2 test %edx,%edx
110b5e: 74 0c je 110b6c <pthread_attr_setguardsize+0x1c>
return EINVAL;
attr->guardsize = guardsize;
110b60: 8b 55 0c mov 0xc(%ebp),%edx 110b63: 89 50 34 mov %edx,0x34(%eax)
return 0;
110b66: 31 c0 xor %eax,%eax
}
110b68: c9 leave 110b69: c3 ret 110b6a: 66 90 xchg %ax,%ax
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110b6c: b8 16 00 00 00 mov $0x16,%eax
attr->guardsize = guardsize;
return 0;
}
110b71: c9 leave 110b72: c3 ret
00111b7c <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
111b7c: 55 push %ebp 111b7d: 89 e5 mov %esp,%ebp 111b7f: 8b 45 08 mov 0x8(%ebp),%eax 111b82: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111b85: 85 c0 test %eax,%eax
111b87: 74 1f je 111ba8 <pthread_attr_setinheritsched+0x2c>
111b89: 8b 08 mov (%eax),%ecx 111b8b: 85 c9 test %ecx,%ecx
111b8d: 74 19 je 111ba8 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
111b8f: 8d 4a ff lea -0x1(%edx),%ecx 111b92: 83 f9 01 cmp $0x1,%ecx
111b95: 76 09 jbe 111ba0 <pthread_attr_setinheritsched+0x24>
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
111b97: b8 86 00 00 00 mov $0x86,%eax
} }
111b9c: c9 leave 111b9d: c3 ret 111b9e: 66 90 xchg %ax,%ax
return EINVAL;
switch ( inheritsched ) {
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
111ba0: 89 50 10 mov %edx,0x10(%eax)
return 0;
111ba3: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
111ba5: c9 leave 111ba6: c3 ret 111ba7: 90 nop
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111ba8: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
111bad: c9 leave 111bae: c3 ret
00110ba8 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
110ba8: 55 push %ebp 110ba9: 89 e5 mov %esp,%ebp 110bab: 57 push %edi 110bac: 56 push %esi 110bad: 8b 7d 08 mov 0x8(%ebp),%edi 110bb0: 8b 75 0c mov 0xc(%ebp),%esi
if ( !attr || !attr->is_initialized || !param )
110bb3: 85 ff test %edi,%edi
110bb5: 74 1d je 110bd4 <pthread_attr_setschedparam+0x2c>
110bb7: 8b 07 mov (%edi),%eax 110bb9: 85 c0 test %eax,%eax
110bbb: 74 17 je 110bd4 <pthread_attr_setschedparam+0x2c>
110bbd: 85 f6 test %esi,%esi
110bbf: 74 13 je 110bd4 <pthread_attr_setschedparam+0x2c>
return EINVAL;
attr->schedparam = *param;
110bc1: 83 c7 18 add $0x18,%edi 110bc4: b9 07 00 00 00 mov $0x7,%ecx 110bc9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
110bcb: 31 c0 xor %eax,%eax
}
110bcd: 5e pop %esi 110bce: 5f pop %edi 110bcf: c9 leave 110bd0: c3 ret 110bd1: 8d 76 00 lea 0x0(%esi),%esi
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
110bd4: b8 16 00 00 00 mov $0x16,%eax
attr->schedparam = *param;
return 0;
}
110bd9: 5e pop %esi 110bda: 5f pop %edi 110bdb: c9 leave 110bdc: c3 ret
00110be0 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
110be0: 55 push %ebp 110be1: 89 e5 mov %esp,%ebp 110be3: 8b 45 08 mov 0x8(%ebp),%eax 110be6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
110be9: 85 c0 test %eax,%eax
110beb: 74 23 je 110c10 <pthread_attr_setschedpolicy+0x30>
110bed: 8b 08 mov (%eax),%ecx 110bef: 85 c9 test %ecx,%ecx
110bf1: 74 1d je 110c10 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
110bf3: 85 d2 test %edx,%edx
110bf5: 78 0a js 110c01 <pthread_attr_setschedpolicy+0x21>
110bf7: 83 fa 02 cmp $0x2,%edx
110bfa: 7e 0c jle 110c08 <pthread_attr_setschedpolicy+0x28>
110bfc: 83 fa 04 cmp $0x4,%edx
110bff: 74 07 je 110c08 <pthread_attr_setschedpolicy+0x28><== ALWAYS TAKEN
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
110c01: b8 86 00 00 00 mov $0x86,%eax
} }
110c06: c9 leave 110c07: c3 ret
switch ( policy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
110c08: 89 50 14 mov %edx,0x14(%eax)
return 0;
110c0b: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
110c0d: c9 leave 110c0e: c3 ret 110c0f: 90 nop
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110c10: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
110c15: c9 leave 110c16: c3 ret
00110c18 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
110c18: 55 push %ebp 110c19: 89 e5 mov %esp,%ebp 110c1b: 8b 45 08 mov 0x8(%ebp),%eax 110c1e: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
110c21: 85 c0 test %eax,%eax
110c23: 74 1a je 110c3f <pthread_attr_setscope+0x27>
110c25: 8b 08 mov (%eax),%ecx 110c27: 85 c9 test %ecx,%ecx
110c29: 74 14 je 110c3f <pthread_attr_setscope+0x27>
return EINVAL;
switch ( contentionscope ) {
110c2b: 85 d2 test %edx,%edx
110c2d: 75 0d jne 110c3c <pthread_attr_setscope+0x24>
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
110c2f: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
return 0;
110c36: 31 c0 xor %eax,%eax
return ENOTSUP;
default:
return EINVAL;
}
}
110c38: c9 leave 110c39: c3 ret 110c3a: 66 90 xchg %ax,%ax
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
110c3c: 4a dec %edx
110c3d: 74 09 je 110c48 <pthread_attr_setscope+0x30>
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
110c3f: b8 16 00 00 00 mov $0x16,%eax
} }
110c44: c9 leave 110c45: c3 ret 110c46: 66 90 xchg %ax,%ax
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
return 0;
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
110c48: b8 86 00 00 00 mov $0x86,%eax
default:
return EINVAL;
}
}
110c4d: c9 leave 110c4e: c3 ret
00110c74 <pthread_attr_setstack>:
int pthread_attr_setstack(
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
110c74: 55 push %ebp 110c75: 89 e5 mov %esp,%ebp 110c77: 8b 45 08 mov 0x8(%ebp),%eax 110c7a: 8b 55 10 mov 0x10(%ebp),%edx
if ( !attr || !attr->is_initialized )
110c7d: 85 c0 test %eax,%eax
110c7f: 74 27 je 110ca8 <pthread_attr_setstack+0x34>
110c81: 8b 08 mov (%eax),%ecx 110c83: 85 c9 test %ecx,%ecx
110c85: 74 21 je 110ca8 <pthread_attr_setstack+0x34>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
110c87: 8b 0d 18 e4 12 00 mov 0x12e418,%ecx 110c8d: d1 e1 shl %ecx 110c8f: 39 d1 cmp %edx,%ecx
110c91: 77 0d ja 110ca0 <pthread_attr_setstack+0x2c>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
110c93: 89 50 08 mov %edx,0x8(%eax)
attr->stackaddr = stackaddr;
110c96: 8b 55 0c mov 0xc(%ebp),%edx 110c99: 89 50 04 mov %edx,0x4(%eax)
return 0;
110c9c: 31 c0 xor %eax,%eax
}
110c9e: c9 leave 110c9f: c3 ret
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
110ca0: 89 48 08 mov %ecx,0x8(%eax) 110ca3: eb f1 jmp 110c96 <pthread_attr_setstack+0x22> 110ca5: 8d 76 00 lea 0x0(%esi),%esi
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110ca8: b8 16 00 00 00 mov $0x16,%eax
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
110cad: c9 leave 110cae: c3 ret
00110c50 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
110c50: 55 push %ebp 110c51: 89 e5 mov %esp,%ebp 110c53: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
110c56: 85 c0 test %eax,%eax
110c58: 74 12 je 110c6c <pthread_attr_setstackaddr+0x1c>
110c5a: 8b 10 mov (%eax),%edx 110c5c: 85 d2 test %edx,%edx
110c5e: 74 0c je 110c6c <pthread_attr_setstackaddr+0x1c>
return EINVAL;
attr->stackaddr = stackaddr;
110c60: 8b 55 0c mov 0xc(%ebp),%edx 110c63: 89 50 04 mov %edx,0x4(%eax)
return 0;
110c66: 31 c0 xor %eax,%eax
}
110c68: c9 leave 110c69: c3 ret 110c6a: 66 90 xchg %ax,%ax
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110c6c: b8 16 00 00 00 mov $0x16,%eax
attr->stackaddr = stackaddr;
return 0;
}
110c71: c9 leave 110c72: c3 ret
00111bb0 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
111bb0: 55 push %ebp 111bb1: 89 e5 mov %esp,%ebp 111bb3: 8b 45 08 mov 0x8(%ebp),%eax 111bb6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111bb9: 85 c0 test %eax,%eax
111bbb: 74 23 je 111be0 <pthread_attr_setstacksize+0x30>
111bbd: 8b 08 mov (%eax),%ecx 111bbf: 85 c9 test %ecx,%ecx
111bc1: 74 1d je 111be0 <pthread_attr_setstacksize+0x30>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
111bc3: 8b 0d 98 4d 12 00 mov 0x124d98,%ecx 111bc9: d1 e1 shl %ecx 111bcb: 39 d1 cmp %edx,%ecx
111bcd: 77 09 ja 111bd8 <pthread_attr_setstacksize+0x28>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
111bcf: 89 50 08 mov %edx,0x8(%eax)
return 0;
111bd2: 31 c0 xor %eax,%eax
}
111bd4: c9 leave 111bd5: c3 ret 111bd6: 66 90 xchg %ax,%ax
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
111bd8: 89 48 08 mov %ecx,0x8(%eax)
else
attr->stacksize = stacksize;
return 0;
111bdb: 31 c0 xor %eax,%eax
}
111bdd: c9 leave 111bde: c3 ret 111bdf: 90 nop
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111be0: 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;
}
111be5: c9 leave 111be6: c3 ret
0010b99c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10b99c: 55 push %ebp 10b99d: 89 e5 mov %esp,%ebp 10b99f: 57 push %edi 10b9a0: 56 push %esi 10b9a1: 53 push %ebx 10b9a2: 83 ec 2c sub $0x2c,%esp 10b9a5: 8b 5d 08 mov 0x8(%ebp),%ebx 10b9a8: 8b 7d 0c mov 0xc(%ebp),%edi 10b9ab: 8b 75 10 mov 0x10(%ebp),%esi
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10b9ae: 85 db test %ebx,%ebx
10b9b0: 0f 84 82 00 00 00 je 10ba38 <pthread_barrier_init+0x9c>
return EINVAL;
if ( count == 0 )
10b9b6: 85 f6 test %esi,%esi
10b9b8: 74 7e je 10ba38 <pthread_barrier_init+0x9c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b9ba: 85 ff test %edi,%edi
10b9bc: 0f 84 92 00 00 00 je 10ba54 <pthread_barrier_init+0xb8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10b9c2: 8b 17 mov (%edi),%edx 10b9c4: 85 d2 test %edx,%edx
10b9c6: 74 70 je 10ba38 <pthread_barrier_init+0x9c>
return EINVAL;
switch ( the_attr->process_shared ) {
10b9c8: 8b 47 04 mov 0x4(%edi),%eax 10b9cb: 85 c0 test %eax,%eax
10b9cd: 75 69 jne 10ba38 <pthread_barrier_init+0x9c><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10b9cf: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10b9d6: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b9d9: a1 90 85 12 00 mov 0x128590,%eax 10b9de: 40 inc %eax 10b9df: a3 90 85 12 00 mov %eax,0x128590
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
10b9e4: 83 ec 0c sub $0xc,%esp 10b9e7: 68 a0 89 12 00 push $0x1289a0 10b9ec: e8 f7 20 00 00 call 10dae8 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10b9f1: 83 c4 10 add $0x10,%esp 10b9f4: 85 c0 test %eax,%eax
10b9f6: 74 50 je 10ba48 <pthread_barrier_init+0xac>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10b9f8: 83 ec 08 sub $0x8,%esp 10b9fb: 8d 55 e0 lea -0x20(%ebp),%edx 10b9fe: 52 push %edx 10b9ff: 8d 50 10 lea 0x10(%eax),%edx 10ba02: 52 push %edx 10ba03: 89 45 d4 mov %eax,-0x2c(%ebp) 10ba06: e8 d9 16 00 00 call 10d0e4 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10ba0b: 8b 45 d4 mov -0x2c(%ebp),%eax 10ba0e: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ba11: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ba14: 8b 0d bc 89 12 00 mov 0x1289bc,%ecx 10ba1a: 89 04 b1 mov %eax,(%ecx,%esi,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10ba1d: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
10ba24: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10ba26: e8 e9 30 00 00 call 10eb14 <_Thread_Enable_dispatch>
return 0;
10ba2b: 83 c4 10 add $0x10,%esp 10ba2e: 31 c0 xor %eax,%eax
}
10ba30: 8d 65 f4 lea -0xc(%ebp),%esp 10ba33: 5b pop %ebx 10ba34: 5e pop %esi 10ba35: 5f pop %edi 10ba36: c9 leave 10ba37: c3 ret
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
10ba38: b8 16 00 00 00 mov $0x16,%eax
* Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; }
10ba3d: 8d 65 f4 lea -0xc(%ebp),%esp 10ba40: 5b pop %ebx 10ba41: 5e pop %esi 10ba42: 5f pop %edi 10ba43: c9 leave 10ba44: c3 ret 10ba45: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
10ba48: e8 c7 30 00 00 call 10eb14 <_Thread_Enable_dispatch>
return EAGAIN;
10ba4d: b8 0b 00 00 00 mov $0xb,%eax 10ba52: eb e9 jmp 10ba3d <pthread_barrier_init+0xa1>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10ba54: 83 ec 0c sub $0xc,%esp 10ba57: 8d 7d d8 lea -0x28(%ebp),%edi 10ba5a: 57 push %edi 10ba5b: e8 7c fe ff ff call 10b8dc <pthread_barrierattr_init> 10ba60: 83 c4 10 add $0x10,%esp 10ba63: e9 5a ff ff ff jmp 10b9c2 <pthread_barrier_init+0x26>
0010ba68 <pthread_barrier_wait>:
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
10ba68: 55 push %ebp 10ba69: 89 e5 mov %esp,%ebp 10ba6b: 83 ec 18 sub $0x18,%esp 10ba6e: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
10ba71: 85 c0 test %eax,%eax
10ba73: 74 4f je 10bac4 <pthread_barrier_wait+0x5c>
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
10ba75: 51 push %ecx
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
10ba76: 8d 55 f4 lea -0xc(%ebp),%edx 10ba79: 52 push %edx 10ba7a: ff 30 pushl (%eax) 10ba7c: 68 a0 89 12 00 push $0x1289a0 10ba81: e8 16 25 00 00 call 10df9c <_Objects_Get>
switch ( location ) {
10ba86: 83 c4 10 add $0x10,%esp 10ba89: 8b 55 f4 mov -0xc(%ebp),%edx 10ba8c: 85 d2 test %edx,%edx
10ba8e: 75 34 jne 10bac4 <pthread_barrier_wait+0x5c>
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
10ba90: 83 ec 0c sub $0xc,%esp 10ba93: 6a 00 push $0x0 10ba95: 6a 00 push $0x0 10ba97: 6a 01 push $0x1 10ba99: ff 70 08 pushl 0x8(%eax) 10ba9c: 83 c0 10 add $0x10,%eax 10ba9f: 50 push %eax 10baa0: e8 73 16 00 00 call 10d118 <_CORE_barrier_Wait>
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
10baa5: 83 c4 20 add $0x20,%esp 10baa8: e8 67 30 00 00 call 10eb14 <_Thread_Enable_dispatch>
return _POSIX_Barrier_Translate_core_barrier_return_code(
10baad: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10bab0: a1 38 8b 12 00 mov 0x128b38,%eax
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
10bab5: ff 70 34 pushl 0x34(%eax) 10bab8: e8 07 5c 00 00 call 1116c4 <_POSIX_Barrier_Translate_core_barrier_return_code> 10babd: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10bac0: c9 leave 10bac1: c3 ret 10bac2: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10bac4: b8 16 00 00 00 mov $0x16,%eax
}
10bac9: c9 leave 10baca: c3 ret
0010b894 <pthread_barrierattr_destroy>:
*/
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
10b894: 55 push %ebp 10b895: 89 e5 mov %esp,%ebp 10b897: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10b89a: 85 c0 test %eax,%eax
10b89c: 74 12 je 10b8b0 <pthread_barrierattr_destroy+0x1c>
10b89e: 8b 10 mov (%eax),%edx 10b8a0: 85 d2 test %edx,%edx
10b8a2: 74 0c je 10b8b0 <pthread_barrierattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10b8a4: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10b8aa: 31 c0 xor %eax,%eax
}
10b8ac: c9 leave 10b8ad: c3 ret 10b8ae: 66 90 xchg %ax,%ax
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10b8b0: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10b8b5: c9 leave 10b8b6: c3 ret
0010b134 <pthread_cancel>:
*/
int pthread_cancel(
pthread_t thread
)
{
10b134: 55 push %ebp 10b135: 89 e5 mov %esp,%ebp 10b137: 83 ec 18 sub $0x18,%esp
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
10b13a: a1 54 96 12 00 mov 0x129654,%eax 10b13f: 85 c0 test %eax,%eax
10b141: 74 09 je 10b14c <pthread_cancel+0x18>
return EPROTO;
10b143: b8 47 00 00 00 mov $0x47,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b148: c9 leave 10b149: c3 ret 10b14a: 66 90 xchg %ax,%ax
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
10b14c: 51 push %ecx
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _POSIX_Threads_Get( thread, &location );
10b14d: 8d 45 f4 lea -0xc(%ebp),%eax 10b150: 50 push %eax 10b151: ff 75 08 pushl 0x8(%ebp) 10b154: 68 40 93 12 00 push $0x129340 10b159: e8 22 21 00 00 call 10d280 <_Objects_Get>
switch ( location ) {
10b15e: 83 c4 10 add $0x10,%esp 10b161: 8b 55 f4 mov -0xc(%ebp),%edx 10b164: 85 d2 test %edx,%edx
10b166: 75 20 jne 10b188 <pthread_cancel+0x54>
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
10b168: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 10b16e: c7 82 e0 00 00 00 01 movl $0x1,0xe0(%edx)
10b175: 00 00 00
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
10b178: 83 ec 0c sub $0xc,%esp 10b17b: 50 push %eax 10b17c: e8 7b 55 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
return 0;
10b181: 83 c4 10 add $0x10,%esp 10b184: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b186: c9 leave 10b187: c3 ret
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b188: b8 16 00 00 00 mov $0x16,%eax
}
10b18d: c9 leave 10b18e: c3 ret
0010afb4 <pthread_cleanup_pop>:
*/
void pthread_cleanup_pop(
int execute
)
{
10afb4: 55 push %ebp 10afb5: 89 e5 mov %esp,%ebp 10afb7: 57 push %edi 10afb8: 56 push %esi 10afb9: 53 push %ebx 10afba: 83 ec 0c sub $0xc,%esp 10afbd: 8b 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 ];
10afc0: a1 78 87 12 00 mov 0x128778,%eax 10afc5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10afcb: 8b 15 d0 81 12 00 mov 0x1281d0,%edx 10afd1: 42 inc %edx 10afd2: 89 15 d0 81 12 00 mov %edx,0x1281d0
* ensure that we do not get prempted and deleted while we are holding
* memory that needs to be freed.
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
10afd8: 9c pushf 10afd9: fa cli 10afda: 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 );
10afdb: 8d 90 e8 00 00 00 lea 0xe8(%eax),%edx
if ( _Chain_Is_empty( handler_stack ) ) {
10afe1: 39 90 e4 00 00 00 cmp %edx,0xe4(%eax)
10afe7: 74 47 je 10b030 <pthread_cleanup_pop+0x7c>
_Thread_Enable_dispatch();
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
10afe9: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10afef: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10aff1: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10aff4: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10aff7: 89 0a mov %ecx,(%edx)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
10aff9: 53 push %ebx 10affa: 9d popf 10affb: 8b 58 08 mov 0x8(%eax),%ebx 10affe: 8b 78 0c mov 0xc(%eax),%edi
tmp_handler = *handler;
_Workspace_Free( handler );
10b001: 83 ec 0c sub $0xc,%esp 10b004: 50 push %eax 10b005: e8 62 3a 00 00 call 10ea6c <_Workspace_Free>
_Thread_Enable_dispatch();
10b00a: e8 69 2a 00 00 call 10da78 <_Thread_Enable_dispatch>
if ( execute )
10b00f: 83 c4 10 add $0x10,%esp 10b012: 85 f6 test %esi,%esi
10b014: 75 0a jne 10b020 <pthread_cleanup_pop+0x6c>
(*tmp_handler.routine)( tmp_handler.arg );
}
10b016: 8d 65 f4 lea -0xc(%ebp),%esp 10b019: 5b pop %ebx 10b01a: 5e pop %esi 10b01b: 5f pop %edi 10b01c: c9 leave 10b01d: c3 ret 10b01e: 66 90 xchg %ax,%ax
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
10b020: 89 7d 08 mov %edi,0x8(%ebp) 10b023: 89 d8 mov %ebx,%eax
}
10b025: 8d 65 f4 lea -0xc(%ebp),%esp 10b028: 5b pop %ebx 10b029: 5e pop %esi 10b02a: 5f pop %edi 10b02b: c9 leave
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
10b02c: ff e0 jmp *%eax 10b02e: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
_Thread_Enable_dispatch();
10b030: e8 43 2a 00 00 call 10da78 <_Thread_Enable_dispatch>
_ISR_Enable( level );
10b035: 53 push %ebx 10b036: 9d popf
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
}
10b037: 8d 65 f4 lea -0xc(%ebp),%esp 10b03a: 5b pop %ebx 10b03b: 5e pop %esi 10b03c: 5f pop %edi 10b03d: c9 leave 10b03e: c3 ret
0010b360 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
10b360: 55 push %ebp 10b361: 89 e5 mov %esp,%ebp 10b363: 56 push %esi 10b364: 53 push %ebx 10b365: 8b 5d 08 mov 0x8(%ebp),%ebx 10b368: 8b 75 0c mov 0xc(%ebp),%esi
/* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine )
10b36b: 85 db test %ebx,%ebx
10b36d: 74 4d je 10b3bc <pthread_cleanup_push+0x5c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b36f: a1 30 98 12 00 mov 0x129830,%eax 10b374: 40 inc %eax 10b375: a3 30 98 12 00 mov %eax,0x129830
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
10b37a: 83 ec 0c sub $0xc,%esp 10b37d: 6a 10 push $0x10 10b37f: e8 28 42 00 00 call 10f5ac <_Workspace_Allocate>
if ( handler ) {
10b384: 83 c4 10 add $0x10,%esp 10b387: 85 c0 test %eax,%eax
10b389: 74 25 je 10b3b0 <pthread_cleanup_push+0x50><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b38b: 8b 15 d8 9d 12 00 mov 0x129dd8,%edx
handler_stack = &thread_support->Cancellation_Handlers;
10b391: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 10b397: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
10b39d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
10b3a0: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
10b3a3: 83 ec 08 sub $0x8,%esp 10b3a6: 50 push %eax 10b3a7: 52 push %edx 10b3a8: e8 bf 17 00 00 call 10cb6c <_Chain_Append> 10b3ad: 83 c4 10 add $0x10,%esp
} _Thread_Enable_dispatch(); }
10b3b0: 8d 65 f8 lea -0x8(%ebp),%esp 10b3b3: 5b pop %ebx 10b3b4: 5e pop %esi 10b3b5: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
10b3b6: e9 89 31 00 00 jmp 10e544 <_Thread_Enable_dispatch> 10b3bb: 90 nop
}
10b3bc: 8d 65 f8 lea -0x8(%ebp),%esp 10b3bf: 5b pop %ebx 10b3c0: 5e pop %esi 10b3c1: c9 leave 10b3c2: c3 ret
0010c054 <pthread_cond_destroy>:
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
10c054: 55 push %ebp 10c055: 89 e5 mov %esp,%ebp 10c057: 53 push %ebx 10c058: 83 ec 1c sub $0x1c,%esp
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10c05b: 8d 45 f4 lea -0xc(%ebp),%eax 10c05e: 50 push %eax 10c05f: ff 75 08 pushl 0x8(%ebp) 10c062: e8 65 00 00 00 call 10c0cc <_POSIX_Condition_variables_Get> 10c067: 89 c3 mov %eax,%ebx
switch ( location ) {
10c069: 83 c4 10 add $0x10,%esp 10c06c: 8b 4d f4 mov -0xc(%ebp),%ecx 10c06f: 85 c9 test %ecx,%ecx
10c071: 75 25 jne 10c098 <pthread_cond_destroy+0x44>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
10c073: 83 ec 0c sub $0xc,%esp 10c076: 8d 40 18 lea 0x18(%eax),%eax 10c079: 50 push %eax 10c07a: e8 3d 3e 00 00 call 10febc <_Thread_queue_First> 10c07f: 83 c4 10 add $0x10,%esp 10c082: 85 c0 test %eax,%eax
10c084: 74 1e je 10c0a4 <pthread_cond_destroy+0x50>
_Thread_Enable_dispatch();
10c086: e8 51 37 00 00 call 10f7dc <_Thread_Enable_dispatch>
return EBUSY;
10c08b: b8 10 00 00 00 mov $0x10,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c090: 8b 5d fc mov -0x4(%ebp),%ebx 10c093: c9 leave 10c094: c3 ret 10c095: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c098: b8 16 00 00 00 mov $0x16,%eax
}
10c09d: 8b 5d fc mov -0x4(%ebp),%ebx 10c0a0: c9 leave 10c0a1: c3 ret 10c0a2: 66 90 xchg %ax,%ax
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close(
10c0a4: 83 ec 08 sub $0x8,%esp 10c0a7: 53 push %ebx 10c0a8: 68 40 9a 12 00 push $0x129a40 10c0ad: e8 7a 27 00 00 call 10e82c <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
10c0b2: 58 pop %eax 10c0b3: 5a pop %edx 10c0b4: 53 push %ebx 10c0b5: 68 40 9a 12 00 push $0x129a40 10c0ba: e8 65 2a 00 00 call 10eb24 <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
10c0bf: e8 18 37 00 00 call 10f7dc <_Thread_Enable_dispatch>
return 0;
10c0c4: 83 c4 10 add $0x10,%esp 10c0c7: 31 c0 xor %eax,%eax 10c0c9: eb d2 jmp 10c09d <pthread_cond_destroy+0x49>
0010c120 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10c120: 55 push %ebp 10c121: 89 e5 mov %esp,%ebp 10c123: 53 push %ebx 10c124: 83 ec 14 sub $0x14,%esp 10c127: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10c12a: 85 db test %ebx,%ebx
10c12c: 0f 84 86 00 00 00 je 10c1b8 <pthread_cond_init+0x98>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10c132: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10c136: 74 06 je 10c13e <pthread_cond_init+0x1e><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10c138: 8b 03 mov (%ebx),%eax 10c13a: 85 c0 test %eax,%eax
10c13c: 75 0a jne 10c148 <pthread_cond_init+0x28>
return EINVAL;
10c13e: b8 16 00 00 00 mov $0x16,%eax
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10c143: 8b 5d fc mov -0x4(%ebp),%ebx 10c146: c9 leave 10c147: c3 ret
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c148: a1 90 95 12 00 mov 0x129590,%eax 10c14d: 40 inc %eax 10c14e: a3 90 95 12 00 mov %eax,0x129590
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10c153: 83 ec 0c sub $0xc,%esp 10c156: 68 40 9a 12 00 push $0x129a40 10c15b: e8 50 26 00 00 call 10e7b0 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10c160: 83 c4 10 add $0x10,%esp 10c163: 85 c0 test %eax,%eax
10c165: 74 5d je 10c1c4 <pthread_cond_init+0xa4>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
10c167: 8b 53 04 mov 0x4(%ebx),%edx 10c16a: 89 50 10 mov %edx,0x10(%eax)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10c16d: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
_Thread_queue_Initialize(
10c174: 6a 74 push $0x74 10c176: 68 00 08 00 10 push $0x10000800 10c17b: 6a 00 push $0x0 10c17d: 8d 50 18 lea 0x18(%eax),%edx 10c180: 52 push %edx 10c181: 89 45 f4 mov %eax,-0xc(%ebp) 10c184: e8 af 3d 00 00 call 10ff38 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c189: 8b 45 f4 mov -0xc(%ebp),%eax 10c18c: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10c18f: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c192: 8b 0d 5c 9a 12 00 mov 0x129a5c,%ecx 10c198: 89 04 99 mov %eax,(%ecx,%ebx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10c19b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10c1a2: 8b 45 08 mov 0x8(%ebp),%eax 10c1a5: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c1a7: e8 30 36 00 00 call 10f7dc <_Thread_Enable_dispatch>
return 0;
10c1ac: 83 c4 10 add $0x10,%esp 10c1af: 31 c0 xor %eax,%eax
}
10c1b1: 8b 5d fc mov -0x4(%ebp),%ebx 10c1b4: c9 leave 10c1b5: c3 ret 10c1b6: 66 90 xchg %ax,%ax
{
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10c1b8: bb 3c 3b 12 00 mov $0x123b3c,%ebx 10c1bd: e9 70 ff ff ff jmp 10c132 <pthread_cond_init+0x12> 10c1c2: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
10c1c4: e8 13 36 00 00 call 10f7dc <_Thread_Enable_dispatch>
return ENOMEM;
10c1c9: b8 0c 00 00 00 mov $0xc,%eax 10c1ce: e9 70 ff ff ff jmp 10c143 <pthread_cond_init+0x23>
0010bfb0 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10bfb0: 55 push %ebp 10bfb1: 89 e5 mov %esp,%ebp 10bfb3: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10bfb6: 85 c0 test %eax,%eax
10bfb8: 74 12 je 10bfcc <pthread_condattr_destroy+0x1c>
10bfba: 8b 10 mov (%eax),%edx 10bfbc: 85 d2 test %edx,%edx
10bfbe: 74 0c je 10bfcc <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10bfc0: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10bfc6: 31 c0 xor %eax,%eax
}
10bfc8: c9 leave 10bfc9: c3 ret 10bfca: 66 90 xchg %ax,%ax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10bfcc: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10bfd1: c9 leave 10bfd2: c3 ret
0010bfd4 <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
10bfd4: 55 push %ebp 10bfd5: 89 e5 mov %esp,%ebp 10bfd7: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr )
10bfda: 85 c0 test %eax,%eax
10bfdc: 74 0e je 10bfec <pthread_condattr_getpshared+0x18>
return EINVAL;
*pshared = attr->process_shared;
10bfde: 8b 50 04 mov 0x4(%eax),%edx 10bfe1: 8b 45 0c mov 0xc(%ebp),%eax 10bfe4: 89 10 mov %edx,(%eax)
return 0;
10bfe6: 31 c0 xor %eax,%eax
}
10bfe8: c9 leave 10bfe9: c3 ret 10bfea: 66 90 xchg %ax,%ax
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
10bfec: b8 16 00 00 00 mov $0x16,%eax
*pshared = attr->process_shared;
return 0;
}
10bff1: c9 leave 10bff2: c3 ret
0010bff4 <pthread_condattr_init>:
*/
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
10bff4: 55 push %ebp 10bff5: 89 e5 mov %esp,%ebp 10bff7: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr )
10bffa: 85 c0 test %eax,%eax
10bffc: 74 16 je 10c014 <pthread_condattr_init+0x20><== NEVER TAKEN
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
10bffe: 8b 15 3c 3b 12 00 mov 0x123b3c,%edx 10c004: 8b 0d 40 3b 12 00 mov 0x123b40,%ecx 10c00a: 89 10 mov %edx,(%eax) 10c00c: 89 48 04 mov %ecx,0x4(%eax)
return 0;
10c00f: 31 c0 xor %eax,%eax
}
10c011: c9 leave 10c012: c3 ret 10c013: 90 nop
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
return EINVAL;
10c014: b8 16 00 00 00 mov $0x16,%eax
*attr = _POSIX_Condition_variables_Default_attributes;
return 0;
}
10c019: c9 leave 10c01a: c3 ret
0010c01c <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
10c01c: 55 push %ebp 10c01d: 89 e5 mov %esp,%ebp 10c01f: 8b 45 08 mov 0x8(%ebp),%eax 10c022: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10c025: 85 c0 test %eax,%eax
10c027: 74 05 je 10c02e <pthread_condattr_setpshared+0x12>
return EINVAL;
switch ( pshared ) {
10c029: 83 fa 01 cmp $0x1,%edx
10c02c: 76 0a jbe 10c038 <pthread_condattr_setpshared+0x1c>
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10c02e: b8 16 00 00 00 mov $0x16,%eax
} }
10c033: c9 leave 10c034: c3 ret 10c035: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10c038: 89 50 04 mov %edx,0x4(%eax)
return 0;
10c03b: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10c03d: c9 leave 10c03e: c3 ret
0010b6d8 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10b6d8: 55 push %ebp 10b6d9: 89 e5 mov %esp,%ebp 10b6db: 57 push %edi 10b6dc: 56 push %esi 10b6dd: 53 push %ebx 10b6de: 83 ec 5c sub $0x5c,%esp 10b6e1: 8b 5d 0c mov 0xc(%ebp),%ebx
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10b6e4: 8b 75 10 mov 0x10(%ebp),%esi 10b6e7: 85 f6 test %esi,%esi
10b6e9: 0f 84 8d 01 00 00 je 10b87c <pthread_create+0x1a4>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10b6ef: 85 db test %ebx,%ebx
10b6f1: 74 65 je 10b758 <pthread_create+0x80>
if ( !the_attr->is_initialized )
10b6f3: 8b 0b mov (%ebx),%ecx 10b6f5: 85 c9 test %ecx,%ecx
10b6f7: 74 1e je 10b717 <pthread_create+0x3f> * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
10b6f9: 8b 53 04 mov 0x4(%ebx),%edx 10b6fc: 85 d2 test %edx,%edx
10b6fe: 74 0a je 10b70a <pthread_create+0x32>
10b700: a1 98 4d 12 00 mov 0x124d98,%eax 10b705: 39 43 08 cmp %eax,0x8(%ebx)
10b708: 72 0d jb 10b717 <pthread_create+0x3f>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
10b70a: 8b 43 10 mov 0x10(%ebx),%eax 10b70d: 83 f8 01 cmp $0x1,%eax
10b710: 74 4e je 10b760 <pthread_create+0x88>
10b712: 83 f8 02 cmp $0x2,%eax
10b715: 74 11 je 10b728 <pthread_create+0x50>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
10b717: ba 16 00 00 00 mov $0x16,%edx
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10b71c: 89 d0 mov %edx,%eax 10b71e: 8d 65 f4 lea -0xc(%ebp),%esp 10b721: 5b pop %ebx 10b722: 5e pop %esi 10b723: 5f pop %edi 10b724: c9 leave 10b725: c3 ret 10b726: 66 90 xchg %ax,%ax
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10b728: 8b 4b 14 mov 0x14(%ebx),%ecx 10b72b: 89 4d b0 mov %ecx,-0x50(%ebp)
schedparam = the_attr->schedparam;
10b72e: 8d 45 c4 lea -0x3c(%ebp),%eax 10b731: 89 45 b4 mov %eax,-0x4c(%ebp) 10b734: 8d 73 18 lea 0x18(%ebx),%esi 10b737: b9 07 00 00 00 mov $0x7,%ecx 10b73c: 89 c7 mov %eax,%edi 10b73e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10b740: 8b 43 0c mov 0xc(%ebx),%eax 10b743: 85 c0 test %eax,%eax
10b745: 74 49 je 10b790 <pthread_create+0xb8> <== ALWAYS TAKEN
return ENOTSUP;
10b747: ba 86 00 00 00 mov $0x86,%edx
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10b74c: 89 d0 mov %edx,%eax 10b74e: 8d 65 f4 lea -0xc(%ebp),%esp 10b751: 5b pop %ebx 10b752: 5e pop %esi 10b753: 5f pop %edi 10b754: c9 leave 10b755: c3 ret 10b756: 66 90 xchg %ax,%ax
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10b758: bb 00 27 12 00 mov $0x122700,%ebx 10b75d: eb 94 jmp 10b6f3 <pthread_create+0x1b> 10b75f: 90 nop
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b760: a1 38 96 12 00 mov 0x129638,%eax 10b765: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10b76b: 8b 8e 84 00 00 00 mov 0x84(%esi),%ecx 10b771: 89 4d b0 mov %ecx,-0x50(%ebp)
schedparam = api->schedparam;
10b774: 8d 45 c4 lea -0x3c(%ebp),%eax 10b777: 89 45 b4 mov %eax,-0x4c(%ebp) 10b77a: 81 c6 88 00 00 00 add $0x88,%esi 10b780: b9 07 00 00 00 mov $0x7,%ecx 10b785: 89 c7 mov %eax,%edi 10b787: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10b789: 8b 43 0c mov 0xc(%ebx),%eax 10b78c: 85 c0 test %eax,%eax
10b78e: 75 b7 jne 10b747 <pthread_create+0x6f>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10b790: 83 ec 0c sub $0xc,%esp 10b793: ff 75 c4 pushl -0x3c(%ebp) 10b796: e8 b5 62 00 00 call 111a50 <_POSIX_Priority_Is_valid> 10b79b: 83 c4 10 add $0x10,%esp 10b79e: 84 c0 test %al,%al
10b7a0: 0f 84 71 ff ff ff je 10b717 <pthread_create+0x3f> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10b7a6: 8b 7d c4 mov -0x3c(%ebp),%edi
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10b7a9: 0f b6 35 9c 4d 12 00 movzbl 0x124d9c,%esi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10b7b0: 8d 45 e0 lea -0x20(%ebp),%eax 10b7b3: 50 push %eax 10b7b4: 8d 45 e4 lea -0x1c(%ebp),%eax 10b7b7: 50 push %eax 10b7b8: ff 75 b4 pushl -0x4c(%ebp) 10b7bb: ff 75 b0 pushl -0x50(%ebp) 10b7be: e8 a9 62 00 00 call 111a6c <_POSIX_Thread_Translate_sched_param> 10b7c3: 89 c2 mov %eax,%edx
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 85 c0 test %eax,%eax
10b7ca: 0f 85 4c ff ff ff jne 10b71c <pthread_create+0x44>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b7d0: 83 ec 0c sub $0xc,%esp 10b7d3: ff 35 40 91 12 00 pushl 0x129140 10b7d9: 89 45 a0 mov %eax,-0x60(%ebp) 10b7dc: e8 b3 17 00 00 call 10cf94 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10b7e1: c7 04 24 20 93 12 00 movl $0x129320,(%esp) 10b7e8: e8 cb 21 00 00 call 10d9b8 <_Objects_Allocate> 10b7ed: 89 45 ac mov %eax,-0x54(%ebp)
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
10b7f0: 83 c4 10 add $0x10,%esp 10b7f3: 85 c0 test %eax,%eax 10b7f5: 8b 55 a0 mov -0x60(%ebp),%edx
10b7f8: 0f 84 0f 01 00 00 je 10b90d <pthread_create+0x235>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
10b7fe: 8b 4d e0 mov -0x20(%ebp),%ecx 10b801: 8b 45 e4 mov -0x1c(%ebp),%eax 10b804: 89 45 a4 mov %eax,-0x5c(%ebp) 10b807: 8b 43 08 mov 0x8(%ebx),%eax 10b80a: 89 45 a8 mov %eax,-0x58(%ebp) 10b80d: a1 98 4d 12 00 mov 0x124d98,%eax 10b812: d1 e0 shl %eax 10b814: 3b 45 a8 cmp -0x58(%ebp),%eax
10b817: 73 03 jae 10b81c <pthread_create+0x144>
10b819: 8b 45 a8 mov -0x58(%ebp),%eax 10b81c: 83 ec 04 sub $0x4,%esp 10b81f: 6a 00 push $0x0 10b821: 6a 00 push $0x0 10b823: 51 push %ecx 10b824: ff 75 a4 pushl -0x5c(%ebp) 10b827: 6a 01 push $0x1 10b829: 81 e6 ff 00 00 00 and $0xff,%esi 10b82f: 29 fe sub %edi,%esi 10b831: 56 push %esi 10b832: 6a 01 push $0x1 10b834: 50 push %eax 10b835: ff 73 04 pushl 0x4(%ebx) 10b838: ff 75 ac pushl -0x54(%ebp) 10b83b: 68 20 93 12 00 push $0x129320 10b840: 89 55 a0 mov %edx,-0x60(%ebp) 10b843: e8 34 32 00 00 call 10ea7c <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10b848: 83 c4 30 add $0x30,%esp 10b84b: 84 c0 test %al,%al 10b84d: 8b 55 a0 mov -0x60(%ebp),%edx
10b850: 75 34 jne 10b886 <pthread_create+0x1ae>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10b852: 83 ec 08 sub $0x8,%esp 10b855: ff 75 ac pushl -0x54(%ebp) 10b858: 68 20 93 12 00 push $0x129320 10b85d: e8 ca 24 00 00 call 10dd2c <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10b862: 59 pop %ecx 10b863: ff 35 40 91 12 00 pushl 0x129140 10b869: e8 6e 17 00 00 call 10cfdc <_API_Mutex_Unlock>
return EAGAIN;
10b86e: 83 c4 10 add $0x10,%esp 10b871: ba 0b 00 00 00 mov $0xb,%edx 10b876: e9 a1 fe ff ff jmp 10b71c <pthread_create+0x44> 10b87b: 90 nop
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10b87c: ba 0e 00 00 00 mov $0xe,%edx 10b881: e9 96 fe ff ff jmp 10b71c <pthread_create+0x44>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10b886: 8b 4d ac mov -0x54(%ebp),%ecx 10b889: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b88f: 89 4d a8 mov %ecx,-0x58(%ebp)
api->Attributes = *the_attr;
10b892: b9 10 00 00 00 mov $0x10,%ecx 10b897: 8b 7d a8 mov -0x58(%ebp),%edi 10b89a: 89 de mov %ebx,%esi 10b89c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10b89e: 8b 43 3c mov 0x3c(%ebx),%eax 10b8a1: 8b 4d a8 mov -0x58(%ebp),%ecx 10b8a4: 89 41 40 mov %eax,0x40(%ecx)
api->schedpolicy = schedpolicy;
10b8a7: 8b 45 b0 mov -0x50(%ebp),%eax 10b8aa: 89 81 84 00 00 00 mov %eax,0x84(%ecx)
api->schedparam = schedparam;
10b8b0: 89 cf mov %ecx,%edi 10b8b2: 81 c7 88 00 00 00 add $0x88,%edi 10b8b8: b9 07 00 00 00 mov $0x7,%ecx 10b8bd: 8b 75 b4 mov -0x4c(%ebp),%esi 10b8c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10b8c2: 83 ec 0c sub $0xc,%esp 10b8c5: 6a 00 push $0x0 10b8c7: ff 75 14 pushl 0x14(%ebp) 10b8ca: ff 75 10 pushl 0x10(%ebp) 10b8cd: 6a 01 push $0x1 10b8cf: ff 75 ac pushl -0x54(%ebp) 10b8d2: 89 55 a0 mov %edx,-0x60(%ebp) 10b8d5: e8 92 3a 00 00 call 10f36c <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10b8da: 83 c4 20 add $0x20,%esp 10b8dd: 83 7d b0 04 cmpl $0x4,-0x50(%ebp) 10b8e1: 8b 55 a0 mov -0x60(%ebp),%edx
10b8e4: 74 42 je 10b928 <pthread_create+0x250>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10b8e6: 8b 45 ac mov -0x54(%ebp),%eax 10b8e9: 8b 48 08 mov 0x8(%eax),%ecx 10b8ec: 8b 45 08 mov 0x8(%ebp),%eax 10b8ef: 89 08 mov %ecx,(%eax)
_RTEMS_Unlock_allocator();
10b8f1: 83 ec 0c sub $0xc,%esp 10b8f4: ff 35 40 91 12 00 pushl 0x129140 10b8fa: 89 55 a0 mov %edx,-0x60(%ebp) 10b8fd: e8 da 16 00 00 call 10cfdc <_API_Mutex_Unlock>
return 0;
10b902: 83 c4 10 add $0x10,%esp 10b905: 8b 55 a0 mov -0x60(%ebp),%edx 10b908: e9 0f fe ff ff jmp 10b71c <pthread_create+0x44>
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10b90d: 83 ec 0c sub $0xc,%esp 10b910: ff 35 40 91 12 00 pushl 0x129140 10b916: e8 c1 16 00 00 call 10cfdc <_API_Mutex_Unlock>
return EAGAIN;
10b91b: 83 c4 10 add $0x10,%esp 10b91e: ba 0b 00 00 00 mov $0xb,%edx 10b923: e9 f4 fd ff ff jmp 10b71c <pthread_create+0x44>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10b928: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10b92b: 8b 45 a8 mov -0x58(%ebp),%eax 10b92e: 05 90 00 00 00 add $0x90,%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10b933: 50 push %eax 10b934: e8 c3 3b 00 00 call 10f4fc <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b939: 8b 4d a8 mov -0x58(%ebp),%ecx 10b93c: 89 81 b4 00 00 00 mov %eax,0xb4(%ecx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b942: 58 pop %eax 10b943: 5a pop %edx 10b944: 89 c8 mov %ecx,%eax 10b946: 05 a8 00 00 00 add $0xa8,%eax 10b94b: 50 push %eax 10b94c: 68 60 91 12 00 push $0x129160 10b951: e8 d6 3e 00 00 call 10f82c <_Watchdog_Insert> 10b956: 83 c4 10 add $0x10,%esp 10b959: 8b 55 a0 mov -0x60(%ebp),%edx 10b95c: eb 88 jmp 10b8e6 <pthread_create+0x20e>
00112dd4 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
112dd4: 55 push %ebp 112dd5: 89 e5 mov %esp,%ebp 112dd7: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
112dda: ff 75 08 pushl 0x8(%ebp) 112ddd: ff 35 38 83 12 00 pushl 0x128338 112de3: e8 88 ff ff ff call 112d70 <_POSIX_Thread_Exit>
112de8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
112deb: c9 leave <== NOT EXECUTED 112dec: c3 ret <== NOT EXECUTED
0010d8d0 <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
10d8d0: 55 push %ebp 10d8d1: 89 e5 mov %esp,%ebp 10d8d3: 57 push %edi 10d8d4: 56 push %esi 10d8d5: 53 push %ebx 10d8d6: 83 ec 1c sub $0x1c,%esp 10d8d9: 8b 7d 0c mov 0xc(%ebp),%edi 10d8dc: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
10d8df: 85 ff test %edi,%edi
10d8e1: 74 69 je 10d94c <pthread_getschedparam+0x7c>
10d8e3: 85 db test %ebx,%ebx
10d8e5: 74 65 je 10d94c <pthread_getschedparam+0x7c>
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
10d8e7: 51 push %ecx
return EINVAL;
the_thread = _POSIX_Threads_Get( thread, &location );
10d8e8: 8d 45 e4 lea -0x1c(%ebp),%eax 10d8eb: 50 push %eax 10d8ec: ff 75 08 pushl 0x8(%ebp) 10d8ef: 68 80 cf 12 00 push $0x12cf80 10d8f4: e8 ff 23 00 00 call 10fcf8 <_Objects_Get>
switch ( location ) {
10d8f9: 83 c4 10 add $0x10,%esp 10d8fc: 8b 55 e4 mov -0x1c(%ebp),%edx 10d8ff: 85 d2 test %edx,%edx
10d901: 75 39 jne 10d93c <pthread_getschedparam+0x6c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10d903: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
if ( policy )
*policy = api->schedpolicy;
10d909: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 10d90f: 89 17 mov %edx,(%edi)
if ( param ) {
*param = api->schedparam;
10d911: 81 c6 88 00 00 00 add $0x88,%esi 10d917: b9 07 00 00 00 mov $0x7,%ecx 10d91c: 89 df mov %ebx,%edi 10d91e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10d920: 0f b6 15 9c 89 12 00 movzbl 0x12899c,%edx 10d927: 2b 50 14 sub 0x14(%eax),%edx 10d92a: 89 13 mov %edx,(%ebx)
param->sched_priority =
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
10d92c: e8 3f 2f 00 00 call 110870 <_Thread_Enable_dispatch>
return 0;
10d931: 31 c0 xor %eax,%eax
break;
}
return ESRCH;
}
10d933: 8d 65 f4 lea -0xc(%ebp),%esp 10d936: 5b pop %ebx 10d937: 5e pop %esi 10d938: 5f pop %edi 10d939: c9 leave 10d93a: c3 ret 10d93b: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10d93c: b8 03 00 00 00 mov $0x3,%eax
}
10d941: 8d 65 f4 lea -0xc(%ebp),%esp 10d944: 5b pop %ebx 10d945: 5e pop %esi 10d946: 5f pop %edi 10d947: c9 leave 10d948: c3 ret 10d949: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
10d94c: b8 16 00 00 00 mov $0x16,%eax
break;
}
return ESRCH;
}
10d951: 8d 65 f4 lea -0xc(%ebp),%esp 10d954: 5b pop %ebx 10d955: 5e pop %esi 10d956: 5f pop %edi 10d957: c9 leave 10d958: c3 ret
0010b6b8 <pthread_getspecific>:
*/
void *pthread_getspecific(
pthread_key_t key
)
{
10b6b8: 55 push %ebp 10b6b9: 89 e5 mov %esp,%ebp 10b6bb: 83 ec 2c sub $0x2c,%esp
uint32_t api;
uint32_t index;
Objects_Locations location;
void *key_data;
the_key = _POSIX_Keys_Get( key, &location );
10b6be: 8d 45 f4 lea -0xc(%ebp),%eax
pthread_key_t id,
Objects_Locations *location
)
{
return (POSIX_Keys_Control *)
_Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location );
10b6c1: 50 push %eax 10b6c2: ff 75 08 pushl 0x8(%ebp) 10b6c5: 68 20 a1 12 00 push $0x12a120 10b6ca: e8 9d 25 00 00 call 10dc6c <_Objects_Get>
switch ( location ) {
10b6cf: 83 c4 10 add $0x10,%esp 10b6d2: 8b 55 f4 mov -0xc(%ebp),%edx 10b6d5: 85 d2 test %edx,%edx
10b6d7: 75 2b jne 10b704 <pthread_getspecific+0x4c>
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
10b6d9: 8b 15 58 a2 12 00 mov 0x12a258,%edx 10b6df: 8b 4a 08 mov 0x8(%edx),%ecx
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10b6e2: 89 ca mov %ecx,%edx 10b6e4: c1 ea 18 shr $0x18,%edx 10b6e7: 83 e2 07 and $0x7,%edx
index = _Objects_Get_index( _Thread_Executing->Object.id );
10b6ea: 0f b7 c9 movzwl %cx,%ecx
key_data = (void *) the_key->Values[ api ][ index ];
10b6ed: 8b 44 90 14 mov 0x14(%eax,%edx,4),%eax 10b6f1: 8b 04 88 mov (%eax,%ecx,4),%eax
_Thread_Enable_dispatch();
10b6f4: 89 45 e4 mov %eax,-0x1c(%ebp) 10b6f7: e8 e8 30 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return key_data;
10b6fc: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return NULL;
}
10b6ff: c9 leave 10b700: c3 ret 10b701: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return NULL;
10b704: 31 c0 xor %eax,%eax
}
10b706: c9 leave 10b707: c3 ret
00111118 <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
111118: 55 push %ebp 111119: 89 e5 mov %esp,%ebp 11111b: 53 push %ebx 11111c: 83 ec 18 sub $0x18,%esp 11111f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _POSIX_Threads_Get( thread, &location );
111122: 8d 45 f4 lea -0xc(%ebp),%eax 111125: 50 push %eax 111126: ff 75 08 pushl 0x8(%ebp) 111129: 68 40 2a 13 00 push $0x132a40 11112e: e8 09 24 00 00 call 11353c <_Objects_Get>
switch ( location ) {
111133: 83 c4 10 add $0x10,%esp 111136: 8b 55 f4 mov -0xc(%ebp),%edx 111139: 85 d2 test %edx,%edx
11113b: 74 0b je 111148 <pthread_join+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
11113d: b8 03 00 00 00 mov $0x3,%eax
}
111142: 8b 5d fc mov -0x4(%ebp),%ebx 111145: c9 leave 111146: c3 ret 111147: 90 nop
the_thread = _POSIX_Threads_Get( thread, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
111148: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
11114e: 8b 4a 40 mov 0x40(%edx),%ecx 111151: 85 c9 test %ecx,%ecx
111153: 74 43 je 111198 <pthread_join+0x80>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
111155: 8b 0d 58 2d 13 00 mov 0x132d58,%ecx
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
11115b: 39 c8 cmp %ecx,%eax
11115d: 74 49 je 1111a8 <pthread_join+0x90>
/*
* Put ourself on the threads join list
*/
_Thread_Executing->Wait.return_argument = &return_pointer;
11115f: 8d 45 f0 lea -0x10(%ebp),%eax 111162: 89 41 28 mov %eax,0x28(%ecx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
111165: c7 42 74 01 00 00 00 movl $0x1,0x74(%edx)
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
11116c: 50 push %eax 11116d: 68 84 48 11 00 push $0x114884 111172: 6a 00 push $0x0 111174: 83 c2 44 add $0x44,%edx 111177: 52 push %edx 111178: e8 db 33 00 00 call 114558 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
11117d: e8 32 2f 00 00 call 1140b4 <_Thread_Enable_dispatch>
if ( value_ptr )
111182: 83 c4 10 add $0x10,%esp 111185: 85 db test %ebx,%ebx
111187: 74 2b je 1111b4 <pthread_join+0x9c>
*value_ptr = return_pointer;
111189: 8b 45 f0 mov -0x10(%ebp),%eax 11118c: 89 03 mov %eax,(%ebx)
return 0;
11118e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
111190: 8b 5d fc mov -0x4(%ebp),%ebx 111193: c9 leave 111194: c3 ret 111195: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
_Thread_Enable_dispatch();
111198: e8 17 2f 00 00 call 1140b4 <_Thread_Enable_dispatch>
return EINVAL;
11119d: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
1111a2: 8b 5d fc mov -0x4(%ebp),%ebx 1111a5: c9 leave 1111a6: c3 ret 1111a7: 90 nop
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
_Thread_Enable_dispatch();
1111a8: e8 07 2f 00 00 call 1140b4 <_Thread_Enable_dispatch>
return EDEADLK;
1111ad: b8 2d 00 00 00 mov $0x2d,%eax 1111b2: eb 8e jmp 111142 <pthread_join+0x2a>
_Thread_Enable_dispatch();
if ( value_ptr )
*value_ptr = return_pointer;
return 0;
1111b4: 31 c0 xor %eax,%eax 1111b6: eb 8a jmp 111142 <pthread_join+0x2a>
0010b544 <pthread_key_create>:
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
10b544: 55 push %ebp 10b545: 89 e5 mov %esp,%ebp 10b547: 57 push %edi 10b548: 56 push %esi 10b549: 53 push %ebx 10b54a: 83 ec 28 sub $0x28,%esp 10b54d: a1 b0 9c 12 00 mov 0x129cb0,%eax 10b552: 40 inc %eax 10b553: a3 b0 9c 12 00 mov %eax,0x129cb0
* the inactive chain of free keys control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )
{
return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );
10b558: 68 20 a1 12 00 push $0x12a120 10b55d: e8 56 22 00 00 call 10d7b8 <_Objects_Allocate> 10b562: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
10b564: 83 c4 10 add $0x10,%esp 10b567: 85 c0 test %eax,%eax
10b569: 74 79 je 10b5e4 <pthread_key_create+0xa0>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
10b56b: 8b 45 0c mov 0xc(%ebp),%eax 10b56e: 89 46 10 mov %eax,0x10(%esi)
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
10b571: bb 01 00 00 00 mov $0x1,%ebx
the_key->Values[ the_api ] = NULL;
10b576: c7 44 9e 14 00 00 00 movl $0x0,0x14(%esi,%ebx,4)
10b57d: 00
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
10b57e: 8b 04 9d 88 9c 12 00 mov 0x129c88(,%ebx,4),%eax 10b585: 8b 40 04 mov 0x4(%eax),%eax 10b588: 0f b7 40 10 movzwl 0x10(%eax),%eax
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
10b58c: 8d 0c 85 04 00 00 00 lea 0x4(,%eax,4),%ecx
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
10b593: 83 ec 0c sub $0xc,%esp 10b596: 51 push %ecx 10b597: 89 4d e4 mov %ecx,-0x1c(%ebp) 10b59a: e8 25 43 00 00 call 10f8c4 <_Workspace_Allocate>
if ( !table ) {
10b59f: 83 c4 10 add $0x10,%esp 10b5a2: 85 c0 test %eax,%eax 10b5a4: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b5a7: 74 4f je 10b5f8 <pthread_key_create+0xb4>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
10b5a9: 89 44 9e 14 mov %eax,0x14(%esi,%ebx,4)
memset( table, '\0', bytes_to_allocate );
10b5ad: 89 c7 mov %eax,%edi 10b5af: 31 c0 xor %eax,%eax 10b5b1: f3 aa rep stos %al,%es:(%edi)
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
10b5b3: 43 inc %ebx 10b5b4: 83 fb 04 cmp $0x4,%ebx
10b5b7: 75 bd jne 10b576 <pthread_key_create+0x32>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b5b9: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b5bc: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b5bf: 8b 15 3c a1 12 00 mov 0x12a13c,%edx 10b5c5: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10b5c8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
}
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
10b5cf: 8b 55 08 mov 0x8(%ebp),%edx 10b5d2: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10b5d4: e8 0b 32 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return 0;
10b5d9: 31 c0 xor %eax,%eax
}
10b5db: 8d 65 f4 lea -0xc(%ebp),%esp 10b5de: 5b pop %ebx 10b5df: 5e pop %esi 10b5e0: 5f pop %edi 10b5e1: c9 leave 10b5e2: c3 ret 10b5e3: 90 nop
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
_Thread_Enable_dispatch();
10b5e4: e8 fb 31 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return EAGAIN;
10b5e9: b8 0b 00 00 00 mov $0xb,%eax
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b5ee: 8d 65 f4 lea -0xc(%ebp),%esp 10b5f1: 5b pop %ebx 10b5f2: 5e pop %esi 10b5f3: 5f pop %edi 10b5f4: c9 leave 10b5f5: c3 ret 10b5f6: 66 90 xchg %ax,%ax
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
_POSIX_Keys_Free_memory( the_key );
10b5f8: 83 ec 0c sub $0xc,%esp 10b5fb: 56 push %esi 10b5fc: e8 87 00 00 00 call 10b688 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10b601: 58 pop %eax 10b602: 5a pop %edx 10b603: 56 push %esi 10b604: 68 20 a1 12 00 push $0x12a120 10b609: e8 1e 25 00 00 call 10db2c <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10b60e: e8 d1 31 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return ENOMEM;
10b613: 83 c4 10 add $0x10,%esp 10b616: b8 0c 00 00 00 mov $0xc,%eax
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b61b: 8d 65 f4 lea -0xc(%ebp),%esp 10b61e: 5b pop %ebx 10b61f: 5e pop %esi 10b620: 5f pop %edi 10b621: c9 leave 10b622: c3 ret
0010b624 <pthread_key_delete>:
* 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167
*/
int pthread_key_delete(
pthread_key_t key
)
{
10b624: 55 push %ebp 10b625: 89 e5 mov %esp,%ebp 10b627: 53 push %ebx 10b628: 83 ec 18 sub $0x18,%esp
POSIX_Keys_Control *the_key;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
10b62b: 8d 45 f4 lea -0xc(%ebp),%eax
pthread_key_t id,
Objects_Locations *location
)
{
return (POSIX_Keys_Control *)
_Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location );
10b62e: 50 push %eax 10b62f: ff 75 08 pushl 0x8(%ebp) 10b632: 68 20 a1 12 00 push $0x12a120 10b637: e8 30 26 00 00 call 10dc6c <_Objects_Get> 10b63c: 89 c3 mov %eax,%ebx
switch ( location ) {
10b63e: 83 c4 10 add $0x10,%esp 10b641: 8b 4d f4 mov -0xc(%ebp),%ecx 10b644: 85 c9 test %ecx,%ecx
10b646: 75 34 jne 10b67c <pthread_key_delete+0x58>
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
10b648: 83 ec 08 sub $0x8,%esp 10b64b: 50 push %eax 10b64c: 68 20 a1 12 00 push $0x12a120 10b651: e8 de 21 00 00 call 10d834 <_Objects_Close>
_POSIX_Keys_Free_memory( the_key );
10b656: 89 1c 24 mov %ebx,(%esp) 10b659: e8 2a 00 00 00 call 10b688 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10b65e: 58 pop %eax 10b65f: 5a pop %edx 10b660: 53 push %ebx 10b661: 68 20 a1 12 00 push $0x12a120 10b666: e8 c1 24 00 00 call 10db2c <_Objects_Free>
/*
* NOTE: The destructor is not called and it is the responsibility
* of the application to free the memory.
*/
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10b66b: e8 74 31 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return 0;
10b670: 83 c4 10 add $0x10,%esp 10b673: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b675: 8b 5d fc mov -0x4(%ebp),%ebx 10b678: c9 leave 10b679: c3 ret 10b67a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b67c: b8 16 00 00 00 mov $0x16,%eax
}
10b681: 8b 5d fc mov -0x4(%ebp),%ebx 10b684: c9 leave 10b685: c3 ret
00124d8c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
124d8c: 55 push %ebp 124d8d: 89 e5 mov %esp,%ebp 124d8f: 57 push %edi 124d90: 56 push %esi 124d91: 53 push %ebx 124d92: 83 ec 1c sub $0x1c,%esp 124d95: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
124d98: 85 db test %ebx,%ebx
124d9a: 0f 84 84 00 00 00 je 124e24 <pthread_kill+0x98>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
124da0: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
124da3: 83 ff 1f cmp $0x1f,%edi
124da6: 77 7c ja 124e24 <pthread_kill+0x98>
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
124da8: 56 push %esi
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _POSIX_Threads_Get( thread, &location );
124da9: 8d 45 e4 lea -0x1c(%ebp),%eax 124dac: 50 push %eax 124dad: ff 75 08 pushl 0x8(%ebp) 124db0: 68 a0 ed 12 00 push $0x12eda0 124db5: e8 26 d1 fe ff call 111ee0 <_Objects_Get> 124dba: 89 c6 mov %eax,%esi
switch ( location ) {
124dbc: 83 c4 10 add $0x10,%esp 124dbf: 8b 4d e4 mov -0x1c(%ebp),%ecx 124dc2: 85 c9 test %ecx,%ecx
124dc4: 75 72 jne 124e38 <pthread_kill+0xac>
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124dc6: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
124dcc: 8d 04 5b lea (%ebx,%ebx,2),%eax 124dcf: 83 3c 85 28 f1 12 00 cmpl $0x1,0x12f128(,%eax,4)
124dd6: 01
124dd7: 74 2d je 124e06 <pthread_kill+0x7a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124dd9: b8 01 00 00 00 mov $0x1,%eax 124dde: 89 f9 mov %edi,%ecx 124de0: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
124de2: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
124de8: 52 push %edx 124de9: 6a 00 push $0x0 124deb: 53 push %ebx 124dec: 56 push %esi 124ded: e8 7a fe ff ff call 124c6c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124df2: 83 c4 10 add $0x10,%esp 124df5: a1 b4 f0 12 00 mov 0x12f0b4,%eax 124dfa: 85 c0 test %eax,%eax
124dfc: 74 08 je 124e06 <pthread_kill+0x7a>
124dfe: 3b 35 b8 f0 12 00 cmp 0x12f0b8,%esi
124e04: 74 12 je 124e18 <pthread_kill+0x8c>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
124e06: e8 cd dc fe ff call 112ad8 <_Thread_Enable_dispatch>
return 0;
124e0b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
124e0d: 8d 65 f4 lea -0xc(%ebp),%esp 124e10: 5b pop %ebx 124e11: 5e pop %esi 124e12: 5f pop %edi 124e13: c9 leave 124e14: c3 ret 124e15: 8d 76 00 lea 0x0(%esi),%esi
api->signals_pending |= signo_to_mask( sig );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
124e18: c6 05 c4 f0 12 00 01 movb $0x1,0x12f0c4 124e1f: eb e5 jmp 124e06 <pthread_kill+0x7a> 124e21: 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 );
124e24: e8 0f 36 ff ff call 118438 <__errno> 124e29: c7 00 16 00 00 00 movl $0x16,(%eax) 124e2f: b8 ff ff ff ff mov $0xffffffff,%eax 124e34: eb d7 jmp 124e0d <pthread_kill+0x81> 124e36: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
124e38: e8 fb 35 ff ff call 118438 <__errno> 124e3d: c7 00 03 00 00 00 movl $0x3,(%eax) 124e43: b8 ff ff ff ff mov $0xffffffff,%eax 124e48: eb c3 jmp 124e0d <pthread_kill+0x81>
0010d19c <pthread_mutex_getprioceiling>:
int pthread_mutex_getprioceiling(
pthread_mutex_t *mutex,
int *prioceiling
)
{
10d19c: 55 push %ebp 10d19d: 89 e5 mov %esp,%ebp 10d19f: 53 push %ebx 10d1a0: 83 ec 14 sub $0x14,%esp 10d1a3: 8b 5d 0c mov 0xc(%ebp),%ebx
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
if ( !prioceiling )
10d1a6: 85 db test %ebx,%ebx
10d1a8: 74 19 je 10d1c3 <pthread_mutex_getprioceiling+0x27>
return EINVAL;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
10d1aa: 83 ec 08 sub $0x8,%esp 10d1ad: 8d 45 f4 lea -0xc(%ebp),%eax 10d1b0: 50 push %eax 10d1b1: ff 75 08 pushl 0x8(%ebp) 10d1b4: e8 3b ff ff ff call 10d0f4 <_POSIX_Mutex_Get>
switch ( location ) {
10d1b9: 83 c4 10 add $0x10,%esp 10d1bc: 8b 55 f4 mov -0xc(%ebp),%edx 10d1bf: 85 d2 test %edx,%edx
10d1c1: 74 0d je 10d1d0 <pthread_mutex_getprioceiling+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10d1c3: b8 16 00 00 00 mov $0x16,%eax
}
10d1c8: 8b 5d fc mov -0x4(%ebp),%ebx 10d1cb: c9 leave 10d1cc: c3 ret 10d1cd: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10d1d0: 0f b6 15 9c 89 12 00 movzbl 0x12899c,%edx 10d1d7: 2b 50 60 sub 0x60(%eax),%edx 10d1da: 89 13 mov %edx,(%ebx)
case OBJECTS_LOCAL:
*prioceiling = _POSIX_Priority_From_core(
the_mutex->Mutex.Attributes.priority_ceiling
);
_Thread_Enable_dispatch();
10d1dc: e8 8f 36 00 00 call 110870 <_Thread_Enable_dispatch>
return 0;
10d1e1: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10d1e3: 8b 5d fc mov -0x4(%ebp),%ebx 10d1e6: c9 leave 10d1e7: c3 ret
0010d1e8 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
10d1e8: 55 push %ebp 10d1e9: 89 e5 mov %esp,%ebp 10d1eb: 57 push %edi 10d1ec: 56 push %esi 10d1ed: 53 push %ebx 10d1ee: 83 ec 1c sub $0x1c,%esp 10d1f1: 8b 75 08 mov 0x8(%ebp),%esi 10d1f4: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Mutex_Control *the_mutex;
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
10d1f7: 85 db test %ebx,%ebx
10d1f9: 0f 84 09 01 00 00 je 10d308 <pthread_mutex_init+0x120>
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
10d1ff: 85 f6 test %esi,%esi
10d201: 0f 84 e5 00 00 00 je 10d2ec <pthread_mutex_init+0x104>
}
}
}
#endif
if ( !the_attr->is_initialized )
10d207: 8b 13 mov (%ebx),%edx 10d209: 85 d2 test %edx,%edx
10d20b: 0f 84 db 00 00 00 je 10d2ec <pthread_mutex_init+0x104>
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10d211: 8b 43 04 mov 0x4(%ebx),%eax 10d214: 83 f8 01 cmp $0x1,%eax
10d217: 0f 84 f7 00 00 00 je 10d314 <pthread_mutex_init+0x12c>
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
10d21d: 85 c0 test %eax,%eax
10d21f: 0f 85 c7 00 00 00 jne 10d2ec <pthread_mutex_init+0x104>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
10d225: 8b 43 0c mov 0xc(%ebx),%eax 10d228: 83 f8 01 cmp $0x1,%eax
10d22b: 0f 84 eb 00 00 00 je 10d31c <pthread_mutex_init+0x134>
10d231: 83 f8 02 cmp $0x2,%eax
10d234: 0f 84 c2 00 00 00 je 10d2fc <pthread_mutex_init+0x114>
10d23a: 85 c0 test %eax,%eax
10d23c: 0f 85 aa 00 00 00 jne 10d2ec <pthread_mutex_init+0x104>
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
10d242: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
10d249: 83 ec 0c sub $0xc,%esp 10d24c: ff 73 08 pushl 0x8(%ebx) 10d24f: e8 58 03 00 00 call 10d5ac <_POSIX_Priority_Is_valid> 10d254: 83 c4 10 add $0x10,%esp 10d257: 84 c0 test %al,%al
10d259: 0f 84 8d 00 00 00 je 10d2ec <pthread_mutex_init+0x104>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
10d25f: 83 7b 10 03 cmpl $0x3,0x10(%ebx)
10d263: 0f 87 83 00 00 00 ja 10d2ec <pthread_mutex_init+0x104>
10d269: a1 f0 cc 12 00 mov 0x12ccf0,%eax 10d26e: 40 inc %eax 10d26f: a3 f0 cc 12 00 mov %eax,0x12ccf0
* _POSIX_Mutex_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void )
{
return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information );
10d274: 83 ec 0c sub $0xc,%esp 10d277: 68 c0 d0 12 00 push $0x12d0c0 10d27c: e8 c3 25 00 00 call 10f844 <_Objects_Allocate> 10d281: 89 c7 mov %eax,%edi
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
10d283: 83 c4 10 add $0x10,%esp 10d286: 85 c0 test %eax,%eax
10d288: 0f 84 9a 00 00 00 je 10d328 <pthread_mutex_init+0x140>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
10d28e: 8b 43 04 mov 0x4(%ebx),%eax 10d291: 89 47 10 mov %eax,0x10(%edi)
the_mutex_attr = &the_mutex->Mutex.Attributes;
10d294: 8d 57 54 lea 0x54(%edi),%edx
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10d297: 31 c0 xor %eax,%eax 10d299: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10d29d: 0f 94 c0 sete %al 10d2a0: 89 47 54 mov %eax,0x54(%edi)
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
10d2a3: c6 47 58 01 movb $0x1,0x58(%edi)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10d2a7: 0f b6 05 9c 89 12 00 movzbl 0x12899c,%eax 10d2ae: 2b 43 08 sub 0x8(%ebx),%eax 10d2b1: 89 47 60 mov %eax,0x60(%edi)
the_mutex_attr->priority_ceiling =
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
10d2b4: 8b 45 e4 mov -0x1c(%ebp),%eax 10d2b7: 89 47 5c mov %eax,0x5c(%edi)
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
10d2ba: 50 push %eax 10d2bb: 6a 01 push $0x1 10d2bd: 52 push %edx 10d2be: 8d 47 14 lea 0x14(%edi),%eax 10d2c1: 50 push %eax 10d2c2: e8 09 1d 00 00 call 10efd0 <_CORE_mutex_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10d2c7: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10d2ca: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10d2cd: 8b 15 dc d0 12 00 mov 0x12d0dc,%edx 10d2d3: 89 3c 8a mov %edi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10d2d6: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
10d2dd: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10d2df: e8 8c 35 00 00 call 110870 <_Thread_Enable_dispatch>
return 0;
10d2e4: 83 c4 10 add $0x10,%esp 10d2e7: 31 c0 xor %eax,%eax 10d2e9: eb 06 jmp 10d2f1 <pthread_mutex_init+0x109> 10d2eb: 90 nop
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
10d2ec: b8 16 00 00 00 mov $0x16,%eax
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10d2f1: 8d 65 f4 lea -0xc(%ebp),%esp 10d2f4: 5b pop %ebx 10d2f5: 5e pop %esi 10d2f6: 5f pop %edi 10d2f7: c9 leave 10d2f8: c3 ret 10d2f9: 8d 76 00 lea 0x0(%esi),%esi
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
break;
case PTHREAD_PRIO_PROTECT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10d2fc: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp)
break;
10d303: e9 41 ff ff ff jmp 10d249 <pthread_mutex_init+0x61>
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Mutex_Default_attributes;
10d308: bb 40 d1 12 00 mov $0x12d140,%ebx 10d30d: e9 ed fe ff ff jmp 10d1ff <pthread_mutex_init+0x17> 10d312: 66 90 xchg %ax,%ax
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return ENOSYS;
10d314: b8 58 00 00 00 mov $0x58,%eax 10d319: eb d6 jmp 10d2f1 <pthread_mutex_init+0x109> 10d31b: 90 nop
switch ( the_attr->protocol ) {
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10d31c: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) 10d323: e9 21 ff ff ff jmp 10d249 <pthread_mutex_init+0x61>
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
_Thread_Enable_dispatch();
10d328: e8 43 35 00 00 call 110870 <_Thread_Enable_dispatch>
return EAGAIN;
10d32d: b8 0b 00 00 00 mov $0xb,%eax 10d332: eb bd jmp 10d2f1 <pthread_mutex_init+0x109>
0010d440 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10d440: 55 push %ebp 10d441: 89 e5 mov %esp,%ebp 10d443: 56 push %esi 10d444: 53 push %ebx 10d445: 83 ec 18 sub $0x18,%esp 10d448: 8b 75 08 mov 0x8(%ebp),%esi
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10d44b: 8d 45 f4 lea -0xc(%ebp),%eax 10d44e: 50 push %eax 10d44f: ff 75 0c pushl 0xc(%ebp) 10d452: e8 cd 00 00 00 call 10d524 <_POSIX_Absolute_timeout_to_ticks> 10d457: 89 c3 mov %eax,%ebx
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
10d459: 83 c4 10 add $0x10,%esp 10d45c: 83 f8 03 cmp $0x3,%eax
10d45f: 74 2f je 10d490 <pthread_mutex_timedlock+0x50>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10d461: 50 push %eax 10d462: ff 75 f4 pushl -0xc(%ebp) 10d465: 6a 00 push $0x0 10d467: 56 push %esi 10d468: e8 db fe ff ff call 10d348 <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
10d46d: 83 c4 10 add $0x10,%esp 10d470: 83 f8 10 cmp $0x10,%eax
10d473: 74 07 je 10d47c <pthread_mutex_timedlock+0x3c><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
10d475: 8d 65 f8 lea -0x8(%ebp),%esp 10d478: 5b pop %ebx 10d479: 5e pop %esi 10d47a: c9 leave 10d47b: c3 ret
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10d47c: 85 db test %ebx,%ebx
10d47e: 74 28 je 10d4a8 <pthread_mutex_timedlock+0x68><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10d480: 4b dec %ebx 10d481: 83 fb 01 cmp $0x1,%ebx
10d484: 77 ef ja 10d475 <pthread_mutex_timedlock+0x35><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10d486: b8 74 00 00 00 mov $0x74,%eax 10d48b: eb e8 jmp 10d475 <pthread_mutex_timedlock+0x35> 10d48d: 8d 76 00 lea 0x0(%esi),%esi
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10d490: 52 push %edx 10d491: ff 75 f4 pushl -0xc(%ebp) 10d494: 6a 01 push $0x1 10d496: 56 push %esi 10d497: e8 ac fe ff ff call 10d348 <_POSIX_Mutex_Lock_support> 10d49c: 83 c4 10 add $0x10,%esp
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
10d49f: 8d 65 f8 lea -0x8(%ebp),%esp 10d4a2: 5b pop %ebx 10d4a3: 5e pop %esi 10d4a4: c9 leave 10d4a5: c3 ret 10d4a6: 66 90 xchg %ax,%ax
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10d4a8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10d4ad: eb c6 jmp 10d475 <pthread_mutex_timedlock+0x35><== NOT EXECUTED
0010cf24 <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
10cf24: 55 push %ebp 10cf25: 89 e5 mov %esp,%ebp 10cf27: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
10cf2a: 85 c0 test %eax,%eax
10cf2c: 74 12 je 10cf40 <pthread_mutexattr_destroy+0x1c>
10cf2e: 8b 10 mov (%eax),%edx 10cf30: 85 d2 test %edx,%edx
10cf32: 74 0c je 10cf40 <pthread_mutexattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10cf34: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10cf3a: 31 c0 xor %eax,%eax
}
10cf3c: c9 leave 10cf3d: c3 ret 10cf3e: 66 90 xchg %ax,%ax
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
10cf40: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10cf45: c9 leave 10cf46: c3 ret
0010cfec <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
10cfec: 55 push %ebp 10cfed: 89 e5 mov %esp,%ebp 10cfef: 56 push %esi 10cff0: 53 push %ebx 10cff1: 8b 5d 08 mov 0x8(%ebp),%ebx 10cff4: 8b 75 0c mov 0xc(%ebp),%esi
if ( !attr || !attr->is_initialized )
10cff7: 85 db test %ebx,%ebx
10cff9: 74 06 je 10d001 <pthread_mutexattr_setprioceiling+0x15><== NEVER TAKEN
10cffb: 8b 03 mov (%ebx),%eax 10cffd: 85 c0 test %eax,%eax
10cfff: 75 0f jne 10d010 <pthread_mutexattr_setprioceiling+0x24>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
return EINVAL;
10d001: b8 16 00 00 00 mov $0x16,%eax
attr->prio_ceiling = prioceiling;
return 0;
}
10d006: 8d 65 f8 lea -0x8(%ebp),%esp 10d009: 5b pop %ebx 10d00a: 5e pop %esi 10d00b: c9 leave 10d00c: c3 ret 10d00d: 8d 76 00 lea 0x0(%esi),%esi
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
10d010: 83 ec 0c sub $0xc,%esp 10d013: 56 push %esi 10d014: e8 93 05 00 00 call 10d5ac <_POSIX_Priority_Is_valid> 10d019: 83 c4 10 add $0x10,%esp 10d01c: 84 c0 test %al,%al
10d01e: 74 e1 je 10d001 <pthread_mutexattr_setprioceiling+0x15>
return EINVAL;
attr->prio_ceiling = prioceiling;
10d020: 89 73 08 mov %esi,0x8(%ebx)
return 0;
10d023: 31 c0 xor %eax,%eax
}
10d025: 8d 65 f8 lea -0x8(%ebp),%esp 10d028: 5b pop %ebx 10d029: 5e pop %esi 10d02a: c9 leave 10d02b: c3 ret
0010d054 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10d054: 55 push %ebp 10d055: 89 e5 mov %esp,%ebp 10d057: 8b 45 08 mov 0x8(%ebp),%eax 10d05a: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10d05d: 85 c0 test %eax,%eax
10d05f: 74 0b je 10d06c <pthread_mutexattr_setpshared+0x18>
10d061: 8b 08 mov (%eax),%ecx 10d063: 85 c9 test %ecx,%ecx
10d065: 74 05 je 10d06c <pthread_mutexattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10d067: 83 fa 01 cmp $0x1,%edx
10d06a: 76 08 jbe 10d074 <pthread_mutexattr_setpshared+0x20><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10d06c: b8 16 00 00 00 mov $0x16,%eax
} }
10d071: c9 leave 10d072: c3 ret 10d073: 90 nop
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10d074: 89 50 04 mov %edx,0x4(%eax)
return 0;
10d077: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10d079: c9 leave 10d07a: c3 ret
0010b248 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
10b248: 55 push %ebp 10b249: 89 e5 mov %esp,%ebp 10b24b: 8b 45 08 mov 0x8(%ebp),%eax 10b24e: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10b251: 85 c0 test %eax,%eax
10b253: 74 0b je 10b260 <pthread_mutexattr_settype+0x18>
10b255: 8b 08 mov (%eax),%ecx 10b257: 85 c9 test %ecx,%ecx
10b259: 74 05 je 10b260 <pthread_mutexattr_settype+0x18><== NEVER TAKEN
return EINVAL;
switch ( type ) {
10b25b: 83 fa 03 cmp $0x3,%edx
10b25e: 76 08 jbe 10b268 <pthread_mutexattr_settype+0x20>
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
return 0;
default:
return EINVAL;
10b260: b8 16 00 00 00 mov $0x16,%eax
} }
10b265: c9 leave 10b266: c3 ret 10b267: 90 nop
switch ( type ) {
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
10b268: 89 50 10 mov %edx,0x10(%eax)
return 0;
10b26b: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10b26d: c9 leave 10b26e: c3 ret
0010bd9c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10bd9c: 55 push %ebp 10bd9d: 89 e5 mov %esp,%ebp 10bd9f: 57 push %edi 10bda0: 56 push %esi 10bda1: 53 push %ebx 10bda2: 83 ec 1c sub $0x1c,%esp 10bda5: 8b 5d 08 mov 0x8(%ebp),%ebx 10bda8: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10bdab: 85 db test %ebx,%ebx
10bdad: 74 51 je 10be00 <pthread_once+0x64>
10bdaf: 85 f6 test %esi,%esi
10bdb1: 74 4d je 10be00 <pthread_once+0x64>
return EINVAL;
if ( !once_control->init_executed ) {
10bdb3: 8b 7b 04 mov 0x4(%ebx),%edi 10bdb6: 85 ff test %edi,%edi
10bdb8: 74 0a je 10bdc4 <pthread_once+0x28>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10bdba: 31 c0 xor %eax,%eax
}
10bdbc: 8d 65 f4 lea -0xc(%ebp),%esp 10bdbf: 5b pop %ebx 10bdc0: 5e pop %esi 10bdc1: 5f pop %edi 10bdc2: c9 leave 10bdc3: c3 ret
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10bdc4: 51 push %ecx 10bdc5: 8d 7d e4 lea -0x1c(%ebp),%edi 10bdc8: 57 push %edi 10bdc9: 68 00 01 00 00 push $0x100 10bdce: 68 00 01 00 00 push $0x100 10bdd3: e8 ec 0b 00 00 call 10c9c4 <rtems_task_mode>
if ( !once_control->init_executed ) {
10bdd8: 83 c4 10 add $0x10,%esp 10bddb: 8b 53 04 mov 0x4(%ebx),%edx 10bdde: 85 d2 test %edx,%edx
10bde0: 74 2e je 10be10 <pthread_once+0x74> <== ALWAYS TAKEN
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10bde2: 50 push %eax 10bde3: 57 push %edi 10bde4: 68 00 01 00 00 push $0x100 10bde9: ff 75 e4 pushl -0x1c(%ebp) 10bdec: e8 d3 0b 00 00 call 10c9c4 <rtems_task_mode> 10bdf1: 83 c4 10 add $0x10,%esp
} return 0;
10bdf4: 31 c0 xor %eax,%eax
}
10bdf6: 8d 65 f4 lea -0xc(%ebp),%esp 10bdf9: 5b pop %ebx 10bdfa: 5e pop %esi 10bdfb: 5f pop %edi 10bdfc: c9 leave 10bdfd: c3 ret 10bdfe: 66 90 xchg %ax,%ax
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10be00: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10be05: 8d 65 f4 lea -0xc(%ebp),%esp 10be08: 5b pop %ebx 10be09: 5e pop %esi 10be0a: 5f pop %edi 10be0b: c9 leave 10be0c: c3 ret 10be0d: 8d 76 00 lea 0x0(%esi),%esi
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
10be10: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10be16: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10be1d: ff d6 call *%esi 10be1f: eb c1 jmp 10bde2 <pthread_once+0x46>
0010c480 <pthread_rwlock_destroy>:
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
10c480: 55 push %ebp 10c481: 89 e5 mov %esp,%ebp 10c483: 53 push %ebx 10c484: 83 ec 14 sub $0x14,%esp 10c487: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
10c48a: 85 c0 test %eax,%eax
10c48c: 74 42 je 10c4d0 <pthread_rwlock_destroy+0x50>
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
10c48e: 53 push %ebx
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10c48f: 8d 55 f4 lea -0xc(%ebp),%edx 10c492: 52 push %edx 10c493: ff 30 pushl (%eax) 10c495: 68 80 b9 12 00 push $0x12b980 10c49a: e8 d9 2b 00 00 call 10f078 <_Objects_Get> 10c49f: 89 c3 mov %eax,%ebx
switch ( location ) {
10c4a1: 83 c4 10 add $0x10,%esp 10c4a4: 8b 4d f4 mov -0xc(%ebp),%ecx 10c4a7: 85 c9 test %ecx,%ecx
10c4a9: 75 25 jne 10c4d0 <pthread_rwlock_destroy+0x50>
case OBJECTS_LOCAL:
/*
* If there is at least one thread waiting, then do not delete it.
*/
if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) {
10c4ab: 83 ec 0c sub $0xc,%esp 10c4ae: 8d 40 10 lea 0x10(%eax),%eax 10c4b1: 50 push %eax 10c4b2: e8 05 3f 00 00 call 1103bc <_Thread_queue_First> 10c4b7: 83 c4 10 add $0x10,%esp 10c4ba: 85 c0 test %eax,%eax
10c4bc: 74 1e je 10c4dc <pthread_rwlock_destroy+0x5c>
_Thread_Enable_dispatch();
10c4be: e8 2d 37 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return EBUSY;
10c4c3: b8 10 00 00 00 mov $0x10,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c4c8: 8b 5d fc mov -0x4(%ebp),%ebx 10c4cb: c9 leave 10c4cc: c3 ret 10c4cd: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c4d0: b8 16 00 00 00 mov $0x16,%eax
}
10c4d5: 8b 5d fc mov -0x4(%ebp),%ebx 10c4d8: c9 leave 10c4d9: c3 ret 10c4da: 66 90 xchg %ax,%ax
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
10c4dc: 83 ec 08 sub $0x8,%esp 10c4df: 53 push %ebx 10c4e0: 68 80 b9 12 00 push $0x12b980 10c4e5: e8 56 27 00 00 call 10ec40 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
10c4ea: 58 pop %eax 10c4eb: 5a pop %edx 10c4ec: 53 push %ebx 10c4ed: 68 80 b9 12 00 push $0x12b980 10c4f2: e8 41 2a 00 00 call 10ef38 <_Objects_Free>
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
10c4f7: e8 f4 36 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return 0;
10c4fc: 83 c4 10 add $0x10,%esp 10c4ff: 31 c0 xor %eax,%eax 10c501: eb d2 jmp 10c4d5 <pthread_rwlock_destroy+0x55>
0010c504 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10c504: 55 push %ebp 10c505: 89 e5 mov %esp,%ebp 10c507: 56 push %esi 10c508: 53 push %ebx 10c509: 83 ec 20 sub $0x20,%esp 10c50c: 8b 5d 08 mov 0x8(%ebp),%ebx 10c50f: 8b 75 0c mov 0xc(%ebp),%esi
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10c512: 85 db test %ebx,%ebx
10c514: 74 15 je 10c52b <pthread_rwlock_init+0x27>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10c516: 85 f6 test %esi,%esi
10c518: 0f 84 8e 00 00 00 je 10c5ac <pthread_rwlock_init+0xa8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10c51e: 8b 16 mov (%esi),%edx 10c520: 85 d2 test %edx,%edx
10c522: 74 07 je 10c52b <pthread_rwlock_init+0x27><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10c524: 8b 46 04 mov 0x4(%esi),%eax 10c527: 85 c0 test %eax,%eax
10c529: 74 0d je 10c538 <pthread_rwlock_init+0x34><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
10c52b: b8 16 00 00 00 mov $0x16,%eax
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10c530: 8d 65 f8 lea -0x8(%ebp),%esp 10c533: 5b pop %ebx 10c534: 5e pop %esi 10c535: c9 leave 10c536: c3 ret 10c537: 90 nop
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10c538: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c53f: a1 30 b7 12 00 mov 0x12b730,%eax 10c544: 40 inc %eax 10c545: a3 30 b7 12 00 mov %eax,0x12b730
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
10c54a: 83 ec 0c sub $0xc,%esp 10c54d: 68 80 b9 12 00 push $0x12b980 10c552: e8 6d 26 00 00 call 10ebc4 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10c557: 83 c4 10 add $0x10,%esp 10c55a: 85 c0 test %eax,%eax
10c55c: 74 42 je 10c5a0 <pthread_rwlock_init+0x9c>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10c55e: 83 ec 08 sub $0x8,%esp 10c561: 8d 55 f4 lea -0xc(%ebp),%edx 10c564: 52 push %edx 10c565: 8d 50 10 lea 0x10(%eax),%edx 10c568: 52 push %edx 10c569: 89 45 e4 mov %eax,-0x1c(%ebp) 10c56c: e8 3b 1e 00 00 call 10e3ac <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c571: 8b 45 e4 mov -0x1c(%ebp),%eax 10c574: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10c577: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c57a: 8b 0d 9c b9 12 00 mov 0x12b99c,%ecx 10c580: 89 04 b1 mov %eax,(%ecx,%esi,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10c583: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10c58a: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10c58c: e8 5f 36 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return 0;
10c591: 83 c4 10 add $0x10,%esp 10c594: 31 c0 xor %eax,%eax
}
10c596: 8d 65 f8 lea -0x8(%ebp),%esp 10c599: 5b pop %ebx 10c59a: 5e pop %esi 10c59b: c9 leave 10c59c: c3 ret 10c59d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
10c5a0: e8 4b 36 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return EAGAIN;
10c5a5: b8 0b 00 00 00 mov $0xb,%eax 10c5aa: eb 84 jmp 10c530 <pthread_rwlock_init+0x2c>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10c5ac: 83 ec 0c sub $0xc,%esp 10c5af: 8d 75 ec lea -0x14(%ebp),%esi 10c5b2: 56 push %esi 10c5b3: e8 84 09 00 00 call 10cf3c <pthread_rwlockattr_init> 10c5b8: 83 c4 10 add $0x10,%esp 10c5bb: e9 5e ff ff ff jmp 10c51e <pthread_rwlock_init+0x1a>
0010c628 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10c628: 55 push %ebp 10c629: 89 e5 mov %esp,%ebp 10c62b: 56 push %esi 10c62c: 53 push %ebx 10c62d: 83 ec 20 sub $0x20,%esp 10c630: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10c633: 85 db test %ebx,%ebx
10c635: 74 7d je 10c6b4 <pthread_rwlock_timedrdlock+0x8c> * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10c637: 83 ec 08 sub $0x8,%esp 10c63a: 8d 45 f0 lea -0x10(%ebp),%eax 10c63d: 50 push %eax 10c63e: ff 75 0c pushl 0xc(%ebp) 10c641: e8 de 62 00 00 call 112924 <_POSIX_Absolute_timeout_to_ticks> 10c646: 89 c6 mov %eax,%esi 10c648: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10c64b: 8d 45 f4 lea -0xc(%ebp),%eax 10c64e: 50 push %eax 10c64f: ff 33 pushl (%ebx) 10c651: 68 80 b9 12 00 push $0x12b980 10c656: e8 1d 2a 00 00 call 10f078 <_Objects_Get>
switch ( location ) {
10c65b: 83 c4 10 add $0x10,%esp 10c65e: 8b 55 f4 mov -0xc(%ebp),%edx 10c661: 85 d2 test %edx,%edx
10c663: 75 4f jne 10c6b4 <pthread_rwlock_timedrdlock+0x8c> int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock,
10c665: 83 fe 03 cmp $0x3,%esi 10c668: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10c66b: 83 ec 0c sub $0xc,%esp 10c66e: 6a 00 push $0x0 10c670: ff 75 f0 pushl -0x10(%ebp) 10c673: 0f b6 ca movzbl %dl,%ecx 10c676: 51 push %ecx 10c677: ff 33 pushl (%ebx) 10c679: 83 c0 10 add $0x10,%eax 10c67c: 50 push %eax 10c67d: 88 55 e4 mov %dl,-0x1c(%ebp) 10c680: e8 5b 1d 00 00 call 10e3e0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10c685: 83 c4 20 add $0x20,%esp 10c688: e8 63 35 00 00 call 10fbf0 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10c68d: 8a 55 e4 mov -0x1c(%ebp),%dl 10c690: 84 d2 test %dl,%dl
10c692: 75 40 jne 10c6d4 <pthread_rwlock_timedrdlock+0xac>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10c694: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c699: 8b 40 34 mov 0x34(%eax),%eax 10c69c: 83 f8 02 cmp $0x2,%eax
10c69f: 74 1f je 10c6c0 <pthread_rwlock_timedrdlock+0x98>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10c6a1: 83 ec 0c sub $0xc,%esp 10c6a4: 50 push %eax 10c6a5: e8 ee 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10c6aa: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c6ad: 8d 65 f8 lea -0x8(%ebp),%esp 10c6b0: 5b pop %ebx 10c6b1: 5e pop %esi 10c6b2: c9 leave 10c6b3: c3 ret
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10c6b4: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10c6bc: 5b pop %ebx 10c6bd: 5e pop %esi 10c6be: c9 leave 10c6bf: c3 ret
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10c6c0: 85 f6 test %esi,%esi
10c6c2: 74 f0 je 10c6b4 <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10c6c4: 4e dec %esi 10c6c5: 83 fe 01 cmp $0x1,%esi
10c6c8: 77 d7 ja 10c6a1 <pthread_rwlock_timedrdlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
10c6ca: b8 74 00 00 00 mov $0x74,%eax 10c6cf: eb e8 jmp 10c6b9 <pthread_rwlock_timedrdlock+0x91> 10c6d1: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
10c6d4: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c6d9: 8b 40 34 mov 0x34(%eax),%eax 10c6dc: eb c3 jmp 10c6a1 <pthread_rwlock_timedrdlock+0x79>
0010c6e0 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10c6e0: 55 push %ebp 10c6e1: 89 e5 mov %esp,%ebp 10c6e3: 56 push %esi 10c6e4: 53 push %ebx 10c6e5: 83 ec 20 sub $0x20,%esp 10c6e8: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10c6eb: 85 db test %ebx,%ebx
10c6ed: 74 7d je 10c76c <pthread_rwlock_timedwrlock+0x8c> * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10c6ef: 83 ec 08 sub $0x8,%esp 10c6f2: 8d 45 f0 lea -0x10(%ebp),%eax 10c6f5: 50 push %eax 10c6f6: ff 75 0c pushl 0xc(%ebp) 10c6f9: e8 26 62 00 00 call 112924 <_POSIX_Absolute_timeout_to_ticks> 10c6fe: 89 c6 mov %eax,%esi 10c700: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10c703: 8d 45 f4 lea -0xc(%ebp),%eax 10c706: 50 push %eax 10c707: ff 33 pushl (%ebx) 10c709: 68 80 b9 12 00 push $0x12b980 10c70e: e8 65 29 00 00 call 10f078 <_Objects_Get>
switch ( location ) {
10c713: 83 c4 10 add $0x10,%esp 10c716: 8b 55 f4 mov -0xc(%ebp),%edx 10c719: 85 d2 test %edx,%edx
10c71b: 75 4f jne 10c76c <pthread_rwlock_timedwrlock+0x8c>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
10c71d: 83 fe 03 cmp $0x3,%esi 10c720: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10c723: 83 ec 0c sub $0xc,%esp 10c726: 6a 00 push $0x0 10c728: ff 75 f0 pushl -0x10(%ebp) 10c72b: 0f b6 ca movzbl %dl,%ecx 10c72e: 51 push %ecx 10c72f: ff 33 pushl (%ebx) 10c731: 83 c0 10 add $0x10,%eax 10c734: 50 push %eax 10c735: 88 55 e4 mov %dl,-0x1c(%ebp) 10c738: e8 6b 1d 00 00 call 10e4a8 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10c73d: 83 c4 20 add $0x20,%esp 10c740: e8 ab 34 00 00 call 10fbf0 <_Thread_Enable_dispatch>
if ( !do_wait &&
10c745: 8a 55 e4 mov -0x1c(%ebp),%dl 10c748: 84 d2 test %dl,%dl
10c74a: 75 40 jne 10c78c <pthread_rwlock_timedwrlock+0xac>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10c74c: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c751: 8b 40 34 mov 0x34(%eax),%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10c754: 83 f8 02 cmp $0x2,%eax
10c757: 74 1f je 10c778 <pthread_rwlock_timedwrlock+0x98>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10c759: 83 ec 0c sub $0xc,%esp 10c75c: 50 push %eax 10c75d: e8 36 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10c762: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c765: 8d 65 f8 lea -0x8(%ebp),%esp 10c768: 5b pop %ebx 10c769: 5e pop %esi 10c76a: c9 leave 10c76b: c3 ret
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10c76c: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c771: 8d 65 f8 lea -0x8(%ebp),%esp 10c774: 5b pop %ebx 10c775: 5e pop %esi 10c776: c9 leave 10c777: c3 ret
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10c778: 85 f6 test %esi,%esi
10c77a: 74 f0 je 10c76c <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10c77c: 4e dec %esi 10c77d: 83 fe 01 cmp $0x1,%esi
10c780: 77 d7 ja 10c759 <pthread_rwlock_timedwrlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
10c782: b8 74 00 00 00 mov $0x74,%eax 10c787: eb e8 jmp 10c771 <pthread_rwlock_timedwrlock+0x91> 10c789: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10c78c: a1 d8 bc 12 00 mov 0x12bcd8,%eax 10c791: 8b 40 34 mov 0x34(%eax),%eax 10c794: eb c3 jmp 10c759 <pthread_rwlock_timedwrlock+0x79>
0010cef4 <pthread_rwlockattr_destroy>:
*/
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
10cef4: 55 push %ebp 10cef5: 89 e5 mov %esp,%ebp 10cef7: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10cefa: 85 c0 test %eax,%eax
10cefc: 74 12 je 10cf10 <pthread_rwlockattr_destroy+0x1c>
10cefe: 8b 10 mov (%eax),%edx 10cf00: 85 d2 test %edx,%edx
10cf02: 74 0c je 10cf10 <pthread_rwlockattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10cf04: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10cf0a: 31 c0 xor %eax,%eax
}
10cf0c: c9 leave 10cf0d: c3 ret 10cf0e: 66 90 xchg %ax,%ax
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10cf10: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10cf15: c9 leave 10cf16: c3 ret
0010cf60 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10cf60: 55 push %ebp 10cf61: 89 e5 mov %esp,%ebp 10cf63: 8b 45 08 mov 0x8(%ebp),%eax 10cf66: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10cf69: 85 c0 test %eax,%eax
10cf6b: 74 0b je 10cf78 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
if ( !attr->is_initialized )
10cf6d: 8b 08 mov (%eax),%ecx 10cf6f: 85 c9 test %ecx,%ecx
10cf71: 74 05 je 10cf78 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10cf73: 83 fa 01 cmp $0x1,%edx
10cf76: 76 08 jbe 10cf80 <pthread_rwlockattr_setpshared+0x20><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10cf78: b8 16 00 00 00 mov $0x16,%eax
} }
10cf7d: c9 leave 10cf7e: c3 ret 10cf7f: 90 nop
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10cf80: 89 50 04 mov %edx,0x4(%eax)
return 0;
10cf83: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10cf85: c9 leave 10cf86: c3 ret
0010b214 <pthread_setcancelstate>:
int pthread_setcancelstate(
int state,
int *oldstate
)
{
10b214: 55 push %ebp 10b215: 89 e5 mov %esp,%ebp 10b217: 53 push %ebx 10b218: 83 ec 04 sub $0x4,%esp 10b21b: 8b 55 08 mov 0x8(%ebp),%edx 10b21e: 8b 45 0c mov 0xc(%ebp),%eax
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10b221: 8b 0d 54 96 12 00 mov 0x129654,%ecx 10b227: 85 c9 test %ecx,%ecx
10b229: 75 15 jne 10b240 <pthread_setcancelstate+0x2c>
return EPROTO;
if ( !oldstate )
10b22b: 85 c0 test %eax,%eax
10b22d: 74 05 je 10b234 <pthread_setcancelstate+0x20>
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
10b22f: 83 fa 01 cmp $0x1,%edx
10b232: 76 18 jbe 10b24c <pthread_setcancelstate+0x38>
return EINVAL;
10b234: b8 16 00 00 00 mov $0x16,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b239: 8b 5d fc mov -0x4(%ebp),%ebx 10b23c: c9 leave 10b23d: c3 ret 10b23e: 66 90 xchg %ax,%ax
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
10b240: b8 47 00 00 00 mov $0x47,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b245: 8b 5d fc mov -0x4(%ebp),%ebx 10b248: c9 leave 10b249: c3 ret 10b24a: 66 90 xchg %ax,%ax
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b24c: 8b 0d 58 96 12 00 mov 0x129658,%ecx 10b252: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b258: 8b 1d b0 90 12 00 mov 0x1290b0,%ebx 10b25e: 43 inc %ebx 10b25f: 89 1d b0 90 12 00 mov %ebx,0x1290b0
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
10b265: 8b 99 d8 00 00 00 mov 0xd8(%ecx),%ebx 10b26b: 89 18 mov %ebx,(%eax)
thread_support->cancelability_state = state;
10b26d: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx)
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
10b273: 83 ec 0c sub $0xc,%esp 10b276: ff 35 58 96 12 00 pushl 0x129658 10b27c: e8 7b 54 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
10b281: 83 c4 10 add $0x10,%esp 10b284: 31 c0 xor %eax,%eax
}
10b286: 8b 5d fc mov -0x4(%ebp),%ebx 10b289: c9 leave 10b28a: c3 ret
0010b28c <pthread_setcanceltype>:
int pthread_setcanceltype(
int type,
int *oldtype
)
{
10b28c: 55 push %ebp 10b28d: 89 e5 mov %esp,%ebp 10b28f: 53 push %ebx 10b290: 83 ec 04 sub $0x4,%esp 10b293: 8b 55 08 mov 0x8(%ebp),%edx 10b296: 8b 45 0c mov 0xc(%ebp),%eax
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10b299: 8b 0d 54 96 12 00 mov 0x129654,%ecx 10b29f: 85 c9 test %ecx,%ecx
10b2a1: 75 15 jne 10b2b8 <pthread_setcanceltype+0x2c>
return EPROTO;
if ( !oldtype )
10b2a3: 85 c0 test %eax,%eax
10b2a5: 74 05 je 10b2ac <pthread_setcanceltype+0x20>
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
10b2a7: 83 fa 01 cmp $0x1,%edx
10b2aa: 76 18 jbe 10b2c4 <pthread_setcanceltype+0x38>
return EINVAL;
10b2ac: b8 16 00 00 00 mov $0x16,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b2b1: 8b 5d fc mov -0x4(%ebp),%ebx 10b2b4: c9 leave 10b2b5: c3 ret 10b2b6: 66 90 xchg %ax,%ax
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
10b2b8: b8 47 00 00 00 mov $0x47,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b2bd: 8b 5d fc mov -0x4(%ebp),%ebx 10b2c0: c9 leave 10b2c1: c3 ret 10b2c2: 66 90 xchg %ax,%ax
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b2c4: 8b 0d 58 96 12 00 mov 0x129658,%ecx 10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx 10b2d0: 8b 1d b0 90 12 00 mov 0x1290b0,%ebx 10b2d6: 43 inc %ebx 10b2d7: 89 1d b0 90 12 00 mov %ebx,0x1290b0
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
10b2dd: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx 10b2e3: 89 18 mov %ebx,(%eax)
thread_support->cancelability_type = type;
10b2e5: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx)
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
10b2eb: 83 ec 0c sub $0xc,%esp 10b2ee: ff 35 58 96 12 00 pushl 0x129658 10b2f4: e8 03 54 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
10b2f9: 83 c4 10 add $0x10,%esp 10b2fc: 31 c0 xor %eax,%eax
}
10b2fe: 8b 5d fc mov -0x4(%ebp),%ebx 10b301: c9 leave 10b302: c3 ret
0010dd14 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10dd14: 55 push %ebp 10dd15: 89 e5 mov %esp,%ebp 10dd17: 57 push %edi 10dd18: 56 push %esi 10dd19: 53 push %ebx 10dd1a: 83 ec 2c sub $0x2c,%esp 10dd1d: 8b 75 10 mov 0x10(%ebp),%esi
int rc;
/*
* Check all the parameters
*/
if ( !param )
10dd20: 85 f6 test %esi,%esi
10dd22: 0f 84 cc 00 00 00 je 10ddf4 <pthread_setschedparam+0xe0>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10dd28: 8d 45 e0 lea -0x20(%ebp),%eax 10dd2b: 50 push %eax 10dd2c: 8d 45 e4 lea -0x1c(%ebp),%eax 10dd2f: 50 push %eax 10dd30: 56 push %esi 10dd31: ff 75 0c pushl 0xc(%ebp) 10dd34: e8 17 5c 00 00 call 113950 <_POSIX_Thread_Translate_sched_param> 10dd39: 89 c3 mov %eax,%ebx
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10dd3b: 83 c4 10 add $0x10,%esp 10dd3e: 85 c0 test %eax,%eax
10dd40: 74 0a je 10dd4c <pthread_setschedparam+0x38>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10dd42: 89 d8 mov %ebx,%eax 10dd44: 8d 65 f4 lea -0xc(%ebp),%esp 10dd47: 5b pop %ebx 10dd48: 5e pop %esi 10dd49: 5f pop %edi 10dd4a: c9 leave 10dd4b: c3 ret 10dd4c: 50 push %eax
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10dd4d: 8d 45 dc lea -0x24(%ebp),%eax 10dd50: 50 push %eax 10dd51: ff 75 08 pushl 0x8(%ebp) 10dd54: 68 80 cf 12 00 push $0x12cf80 10dd59: e8 9a 1f 00 00 call 10fcf8 <_Objects_Get> 10dd5e: 89 c2 mov %eax,%edx
switch ( location ) {
10dd60: 83 c4 10 add $0x10,%esp 10dd63: 8b 7d dc mov -0x24(%ebp),%edi 10dd66: 85 ff test %edi,%edi
10dd68: 0f 85 96 00 00 00 jne 10de04 <pthread_setschedparam+0xf0>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10dd6e: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10dd74: 89 45 d4 mov %eax,-0x2c(%ebp)
if ( api->schedpolicy == SCHED_SPORADIC )
10dd77: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
10dd7e: 0f 84 cc 00 00 00 je 10de50 <pthread_setschedparam+0x13c>
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
10dd84: 8b 45 0c mov 0xc(%ebp),%eax 10dd87: 8b 4d d4 mov -0x2c(%ebp),%ecx 10dd8a: 89 81 84 00 00 00 mov %eax,0x84(%ecx)
api->schedparam = *param;
10dd90: 89 cf mov %ecx,%edi 10dd92: 81 c7 88 00 00 00 add $0x88,%edi 10dd98: b9 07 00 00 00 mov $0x7,%ecx 10dd9d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10dd9f: 8b 45 e4 mov -0x1c(%ebp),%eax 10dda2: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10dda5: 8b 45 e0 mov -0x20(%ebp),%eax 10dda8: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10ddae: 8b 75 0c mov 0xc(%ebp),%esi 10ddb1: 85 f6 test %esi,%esi
10ddb3: 78 2e js 10dde3 <pthread_setschedparam+0xcf><== NEVER TAKEN
10ddb5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10ddb9: 7f 59 jg 10de14 <pthread_setschedparam+0x100>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ddbb: a1 c0 cc 12 00 mov 0x12ccc0,%eax 10ddc0: 89 42 78 mov %eax,0x78(%edx) 10ddc3: 0f b6 05 9c 89 12 00 movzbl 0x12899c,%eax 10ddca: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ddcd: 2b 81 88 00 00 00 sub 0x88(%ecx),%eax
the_thread->real_priority =
10ddd3: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10ddd6: 51 push %ecx 10ddd7: 6a 01 push $0x1 10ddd9: 50 push %eax 10ddda: 52 push %edx 10dddb: e8 58 26 00 00 call 110438 <_Thread_Change_priority>
the_thread,
the_thread->real_priority,
true
);
break;
10dde0: 83 c4 10 add $0x10,%esp
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
10dde3: e8 88 2a 00 00 call 110870 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10dde8: 89 d8 mov %ebx,%eax 10ddea: 8d 65 f4 lea -0xc(%ebp),%esp 10dded: 5b pop %ebx 10ddee: 5e pop %esi 10ddef: 5f pop %edi 10ddf0: c9 leave 10ddf1: c3 ret 10ddf2: 66 90 xchg %ax,%ax
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10ddf4: bb 16 00 00 00 mov $0x16,%ebx
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10ddf9: 89 d8 mov %ebx,%eax 10ddfb: 8d 65 f4 lea -0xc(%ebp),%esp 10ddfe: 5b pop %ebx 10ddff: 5e pop %esi 10de00: 5f pop %edi 10de01: c9 leave 10de02: c3 ret 10de03: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10de04: bb 03 00 00 00 mov $0x3,%ebx
}
10de09: 89 d8 mov %ebx,%eax 10de0b: 8d 65 f4 lea -0xc(%ebp),%esp 10de0e: 5b pop %ebx 10de0f: 5e pop %esi 10de10: 5f pop %edi 10de11: c9 leave 10de12: c3 ret 10de13: 90 nop
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
10de14: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10de18: 75 c9 jne 10dde3 <pthread_setschedparam+0xcf><== NEVER TAKEN
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10de1a: 8b 4d d4 mov -0x2c(%ebp),%ecx 10de1d: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax 10de23: 89 81 a4 00 00 00 mov %eax,0xa4(%ecx)
_Watchdog_Remove( &api->Sporadic_timer );
10de29: 83 ec 0c sub $0xc,%esp 10de2c: 89 c8 mov %ecx,%eax 10de2e: 05 a8 00 00 00 add $0xa8,%eax 10de33: 50 push %eax 10de34: 89 55 d0 mov %edx,-0x30(%ebp) 10de37: e8 38 3a 00 00 call 111874 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10de3c: 58 pop %eax 10de3d: 5a pop %edx 10de3e: 8b 55 d0 mov -0x30(%ebp),%edx 10de41: 52 push %edx 10de42: 6a 00 push $0x0 10de44: e8 af fd ff ff call 10dbf8 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10de49: 83 c4 10 add $0x10,%esp 10de4c: eb 95 jmp 10dde3 <pthread_setschedparam+0xcf> 10de4e: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
10de50: 83 ec 0c sub $0xc,%esp 10de53: 05 a8 00 00 00 add $0xa8,%eax 10de58: 50 push %eax 10de59: 89 55 d0 mov %edx,-0x30(%ebp) 10de5c: e8 13 3a 00 00 call 111874 <_Watchdog_Remove> 10de61: 83 c4 10 add $0x10,%esp 10de64: 8b 55 d0 mov -0x30(%ebp),%edx 10de67: e9 18 ff ff ff jmp 10dd84 <pthread_setschedparam+0x70>
00111d14 <pthread_sigmask>:
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
111d14: 55 push %ebp 111d15: 89 e5 mov %esp,%ebp 111d17: 56 push %esi 111d18: 53 push %ebx 111d19: 8b 4d 08 mov 0x8(%ebp),%ecx 111d1c: 8b 55 0c mov 0xc(%ebp),%edx 111d1f: 8b 5d 10 mov 0x10(%ebp),%ebx
POSIX_API_Control *api;
if ( !set && !oset )
111d22: 85 d2 test %edx,%edx
111d24: 0f 84 8a 00 00 00 je 111db4 <pthread_sigmask+0xa0>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111d2a: a1 58 a3 12 00 mov 0x12a358,%eax 111d2f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
if ( oset )
111d35: 85 db test %ebx,%ebx
111d37: 74 0c je 111d45 <pthread_sigmask+0x31>
*oset = api->signals_blocked;
111d39: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi 111d3f: 89 33 mov %esi,(%ebx)
if ( !set )
111d41: 85 d2 test %edx,%edx
111d43: 74 3b je 111d80 <pthread_sigmask+0x6c>
return 0;
switch ( how ) {
111d45: 83 f9 01 cmp $0x1,%ecx
111d48: 74 5e je 111da8 <pthread_sigmask+0x94>
111d4a: 83 f9 02 cmp $0x2,%ecx
111d4d: 74 39 je 111d88 <pthread_sigmask+0x74>
111d4f: 85 c9 test %ecx,%ecx
111d51: 75 41 jne 111d94 <pthread_sigmask+0x80>
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
111d53: 8b 12 mov (%edx),%edx 111d55: 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) ) {
111d5b: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx 111d61: 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 &
111d67: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 111d6d: f7 d0 not %eax 111d6f: 85 c2 test %eax,%edx
111d71: 74 0d je 111d80 <pthread_sigmask+0x6c>
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
111d73: e8 b0 c9 ff ff call 10e728 <_Thread_Dispatch>
}
return 0;
111d78: 31 c0 xor %eax,%eax
}
111d7a: 5b pop %ebx 111d7b: 5e pop %esi 111d7c: c9 leave 111d7d: c3 ret 111d7e: 66 90 xchg %ax,%ax
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
111d80: 31 c0 xor %eax,%eax
}
111d82: 5b pop %ebx 111d83: 5e pop %esi 111d84: c9 leave 111d85: c3 ret 111d86: 66 90 xchg %ax,%ax
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
111d88: 8b 12 mov (%edx),%edx 111d8a: f7 d2 not %edx 111d8c: 21 90 d0 00 00 00 and %edx,0xd0(%eax)
break;
111d92: eb c7 jmp 111d5b <pthread_sigmask+0x47>
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
111d94: e8 d3 24 00 00 call 11426c <__errno> 111d99: c7 00 16 00 00 00 movl $0x16,(%eax) 111d9f: b8 ff ff ff ff mov $0xffffffff,%eax
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
111da4: 5b pop %ebx 111da5: 5e pop %esi 111da6: c9 leave 111da7: c3 ret
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
111da8: 8b 12 mov (%edx),%edx 111daa: 09 90 d0 00 00 00 or %edx,0xd0(%eax)
break;
111db0: eb a9 jmp 111d5b <pthread_sigmask+0x47> 111db2: 66 90 xchg %ax,%ax
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
111db4: 85 db test %ebx,%ebx
111db6: 74 dc je 111d94 <pthread_sigmask+0x80>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111db8: a1 58 a3 12 00 mov 0x12a358,%eax 111dbd: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 111dc3: e9 71 ff ff ff jmp 111d39 <pthread_sigmask+0x25>
0010bb84 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10bb84: 55 push %ebp 10bb85: 89 e5 mov %esp,%ebp 10bb87: 83 ec 08 sub $0x8,%esp
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10bb8a: 8b 0d d4 9d 12 00 mov 0x129dd4,%ecx 10bb90: 85 c9 test %ecx,%ecx
10bb92: 75 44 jne 10bbd8 <pthread_testcancel+0x54><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10bb94: a1 d8 9d 12 00 mov 0x129dd8,%eax 10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10bb9f: 8b 15 30 98 12 00 mov 0x129830,%edx 10bba5: 42 inc %edx 10bba6: 89 15 30 98 12 00 mov %edx,0x129830
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10bbac: 8b 90 d8 00 00 00 mov 0xd8(%eax),%edx 10bbb2: 85 d2 test %edx,%edx
10bbb4: 75 26 jne 10bbdc <pthread_testcancel+0x58><== NEVER TAKEN
10bbb6: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10bbbc: 85 c0 test %eax,%eax
10bbbe: 74 1c je 10bbdc <pthread_testcancel+0x58>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10bbc0: e8 7f 29 00 00 call 10e544 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10bbc5: 83 ec 08 sub $0x8,%esp 10bbc8: 6a ff push $0xffffffff 10bbca: ff 35 d8 9d 12 00 pushl 0x129dd8 10bbd0: e8 73 5b 00 00 call 111748 <_POSIX_Thread_Exit> 10bbd5: 83 c4 10 add $0x10,%esp
}
10bbd8: c9 leave 10bbd9: c3 ret 10bbda: 66 90 xchg %ax,%ax 10bbdc: c9 leave
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10bbdd: e9 62 29 00 00 jmp 10e544 <_Thread_Enable_dispatch>
0010c550 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10c550: 55 push %ebp 10c551: 89 e5 mov %esp,%ebp 10c553: 57 push %edi 10c554: 56 push %esi 10c555: 53 push %ebx 10c556: 83 ec 58 sub $0x58,%esp 10c559: 8b 5d 08 mov 0x8(%ebp),%ebx
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
10c55c: 68 00 aa 12 00 push $0x12aa00 10c561: e8 86 09 00 00 call 10ceec <pthread_mutex_lock> 10c566: 89 c6 mov %eax,%esi
if (result != 0) {
10c568: 83 c4 10 add $0x10,%esp 10c56b: 85 c0 test %eax,%eax
10c56d: 0f 85 c1 00 00 00 jne 10c634 <rtems_aio_enqueue+0xe4><== NEVER TAKEN
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10c573: e8 24 12 00 00 call 10d79c <pthread_self> 10c578: 51 push %ecx 10c579: 8d 55 c4 lea -0x3c(%ebp),%edx 10c57c: 52 push %edx 10c57d: 8d 55 e0 lea -0x20(%ebp),%edx 10c580: 52 push %edx 10c581: 50 push %eax 10c582: e8 e1 0d 00 00 call 10d368 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10c587: e8 10 12 00 00 call 10d79c <pthread_self> 10c58c: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10c58f: 8b 43 14 mov 0x14(%ebx),%eax 10c592: 8b 55 c4 mov -0x3c(%ebp),%edx 10c595: 2b 50 14 sub 0x14(%eax),%edx 10c598: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10c59b: 8b 55 e0 mov -0x20(%ebp),%edx 10c59e: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10c5a1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10c5a8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10c5af: 83 c4 10 add $0x10,%esp 10c5b2: 8b 15 68 aa 12 00 mov 0x12aa68,%edx 10c5b8: 85 d2 test %edx,%edx
10c5ba: 75 0d jne 10c5c9 <rtems_aio_enqueue+0x79><== NEVER TAKEN
10c5bc: 83 3d 64 aa 12 00 04 cmpl $0x4,0x12aa64
10c5c3: 0f 8e 83 00 00 00 jle 10c64c <rtems_aio_enqueue+0xfc>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10c5c9: 51 push %ecx 10c5ca: 6a 00 push $0x0 10c5cc: ff 30 pushl (%eax) 10c5ce: 68 48 aa 12 00 push $0x12aa48 10c5d3: e8 28 fb ff ff call 10c100 <rtems_aio_search_fd> 10c5d8: 89 c7 mov %eax,%edi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10c5da: 83 c4 10 add $0x10,%esp 10c5dd: 85 c0 test %eax,%eax
10c5df: 0f 84 df 00 00 00 je 10c6c4 <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
10c5e5: 8d 57 1c lea 0x1c(%edi),%edx 10c5e8: 83 ec 0c sub $0xc,%esp 10c5eb: 52 push %edx 10c5ec: 89 55 b4 mov %edx,-0x4c(%ebp) 10c5ef: e8 f8 08 00 00 call 10ceec <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10c5f4: 58 pop %eax 10c5f5: 5a pop %edx 10c5f6: 53 push %ebx 10c5f7: 8d 47 08 lea 0x8(%edi),%eax 10c5fa: 50 push %eax 10c5fb: e8 48 fe ff ff call 10c448 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10c600: 83 c7 20 add $0x20,%edi 10c603: 89 3c 24 mov %edi,(%esp) 10c606: e8 b1 04 00 00 call 10cabc <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10c60b: 8b 55 b4 mov -0x4c(%ebp),%edx 10c60e: 89 14 24 mov %edx,(%esp) 10c611: e8 5e 09 00 00 call 10cf74 <pthread_mutex_unlock> 10c616: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10c619: 83 ec 0c sub $0xc,%esp 10c61c: 68 00 aa 12 00 push $0x12aa00 10c621: e8 4e 09 00 00 call 10cf74 <pthread_mutex_unlock>
return 0;
10c626: 83 c4 10 add $0x10,%esp
}
10c629: 89 f0 mov %esi,%eax 10c62b: 8d 65 f4 lea -0xc(%ebp),%esp 10c62e: 5b pop %ebx 10c62f: 5e pop %esi 10c630: 5f pop %edi 10c631: c9 leave 10c632: c3 ret 10c633: 90 nop
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
10c634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c637: 53 push %ebx <== NOT EXECUTED 10c638: e8 f7 c4 ff ff call 108b34 <free> <== NOT EXECUTED
return result;
10c63d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
10c640: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c642: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c645: 5b pop %ebx <== NOT EXECUTED 10c646: 5e pop %esi <== NOT EXECUTED 10c647: 5f pop %edi <== NOT EXECUTED 10c648: c9 leave <== NOT EXECUTED 10c649: c3 ret <== NOT EXECUTED 10c64a: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10c64c: 57 push %edi 10c64d: 6a 01 push $0x1 10c64f: ff 30 pushl (%eax) 10c651: 68 48 aa 12 00 push $0x12aa48 10c656: e8 a5 fa ff ff call 10c100 <rtems_aio_search_fd> 10c65b: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c65d: 83 c4 10 add $0x10,%esp 10c660: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c664: 0f 85 7b ff ff ff jne 10c5e5 <rtems_aio_enqueue+0x95>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10c66a: 83 ec 08 sub $0x8,%esp 10c66d: 53 push %ebx 10c66e: 8d 40 08 lea 0x8(%eax),%eax 10c671: 50 push %eax 10c672: e8 81 22 00 00 call 10e8f8 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0;
10c677: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c67e: 5a pop %edx 10c67f: 59 pop %ecx 10c680: 6a 00 push $0x0 10c682: 8d 47 1c lea 0x1c(%edi),%eax 10c685: 50 push %eax 10c686: e8 15 07 00 00 call 10cda0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c68b: 5b pop %ebx 10c68c: 58 pop %eax 10c68d: 6a 00 push $0x0 10c68f: 8d 47 20 lea 0x20(%edi),%eax 10c692: 50 push %eax 10c693: e8 70 03 00 00 call 10ca08 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10c698: 57 push %edi 10c699: 68 fc c1 10 00 push $0x10c1fc 10c69e: 68 08 aa 12 00 push $0x12aa08 10c6a3: 8d 45 e4 lea -0x1c(%ebp),%eax 10c6a6: 50 push %eax 10c6a7: e8 34 0a 00 00 call 10d0e0 <pthread_create> 10c6ac: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10c6ae: 83 c4 20 add $0x20,%esp 10c6b1: 85 c0 test %eax,%eax
10c6b3: 0f 85 8e 00 00 00 jne 10c747 <rtems_aio_enqueue+0x1f7><== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
10c6b9: ff 05 64 aa 12 00 incl 0x12aa64 10c6bf: e9 55 ff ff ff jmp 10c619 <rtems_aio_enqueue+0xc9>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10c6c4: 57 push %edi 10c6c5: 6a 01 push $0x1 10c6c7: 8b 43 14 mov 0x14(%ebx),%eax 10c6ca: ff 30 pushl (%eax) 10c6cc: 68 54 aa 12 00 push $0x12aa54 10c6d1: e8 2a fa ff ff call 10c100 <rtems_aio_search_fd> 10c6d6: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c6d8: 83 c4 10 add $0x10,%esp 10c6db: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c6df: 74 33 je 10c714 <rtems_aio_enqueue+0x1c4> r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
10c6e1: 83 ec 08 sub $0x8,%esp 10c6e4: 53 push %ebx 10c6e5: 83 c7 08 add $0x8,%edi 10c6e8: 57 push %edi 10c6e9: e8 5a fd ff ff call 10c448 <rtems_aio_insert_prio> 10c6ee: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10c6f1: 8b 0d 68 aa 12 00 mov 0x12aa68,%ecx 10c6f7: 85 c9 test %ecx,%ecx
10c6f9: 0f 8e 1a ff ff ff jle 10c619 <rtems_aio_enqueue+0xc9><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10c6ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c702: 68 04 aa 12 00 push $0x12aa04 <== NOT EXECUTED 10c707: e8 b0 03 00 00 call 10cabc <pthread_cond_signal> <== NOT EXECUTED 10c70c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c70f: e9 05 ff ff ff jmp 10c619 <rtems_aio_enqueue+0xc9><== NOT EXECUTED
10c714: 83 ec 08 sub $0x8,%esp 10c717: 53 push %ebx 10c718: 8d 40 08 lea 0x8(%eax),%eax 10c71b: 50 push %eax 10c71c: e8 d7 21 00 00 call 10e8f8 <_Chain_Insert>
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10c721: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c728: 5a pop %edx 10c729: 59 pop %ecx 10c72a: 6a 00 push $0x0 10c72c: 8d 47 1c lea 0x1c(%edi),%eax 10c72f: 50 push %eax 10c730: e8 6b 06 00 00 call 10cda0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c735: 5b pop %ebx 10c736: 58 pop %eax 10c737: 6a 00 push $0x0 10c739: 83 c7 20 add $0x20,%edi 10c73c: 57 push %edi 10c73d: e8 c6 02 00 00 call 10ca08 <pthread_cond_init> 10c742: 83 c4 10 add $0x10,%esp 10c745: eb aa jmp 10c6f1 <rtems_aio_enqueue+0x1a1>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
10c747: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c74a: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED 10c74f: e8 20 08 00 00 call 10cf74 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10c754: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c757: 89 de mov %ebx,%esi <== NOT EXECUTED 10c759: e9 cb fe ff ff jmp 10c629 <rtems_aio_enqueue+0xd9><== NOT EXECUTED
0010c1fc <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10c1fc: 55 push %ebp 10c1fd: 89 e5 mov %esp,%ebp 10c1ff: 57 push %edi 10c200: 56 push %esi 10c201: 53 push %ebx 10c202: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10c205: 8b 7d 08 mov 0x8(%ebp),%edi 10c208: 8d 47 1c lea 0x1c(%edi),%eax 10c20b: 89 45 b4 mov %eax,-0x4c(%ebp) 10c20e: 66 90 xchg %ax,%ax
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
10c210: 83 ec 0c sub $0xc,%esp 10c213: ff 75 b4 pushl -0x4c(%ebp) 10c216: e8 d1 0c 00 00 call 10ceec <pthread_mutex_lock>
if (result != 0)
10c21b: 83 c4 10 add $0x10,%esp 10c21e: 85 c0 test %eax,%eax
10c220: 0f 85 2a 01 00 00 jne 10c350 <rtems_aio_handle+0x154><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c226: 8b 5f 08 mov 0x8(%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c229: 8d 47 0c lea 0xc(%edi),%eax
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
10c22c: 39 c3 cmp %eax,%ebx
10c22e: 0f 84 d0 00 00 00 je 10c304 <rtems_aio_handle+0x108>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10c234: e8 63 15 00 00 call 10d79c <pthread_self> 10c239: 52 push %edx 10c23a: 8d 55 c0 lea -0x40(%ebp),%edx 10c23d: 52 push %edx 10c23e: 8d 55 e4 lea -0x1c(%ebp),%edx 10c241: 52 push %edx 10c242: 50 push %eax 10c243: e8 20 11 00 00 call 10d368 <pthread_getschedparam>
param.sched_priority = req->priority;
10c248: 8b 43 0c mov 0xc(%ebx),%eax 10c24b: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10c24e: 8b 73 08 mov 0x8(%ebx),%esi 10c251: e8 46 15 00 00 call 10d79c <pthread_self> 10c256: 83 c4 0c add $0xc,%esp 10c259: 8d 55 c0 lea -0x40(%ebp),%edx 10c25c: 52 push %edx 10c25d: 56 push %esi 10c25e: 50 push %eax 10c25f: e8 48 15 00 00 call 10d7ac <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c264: 89 1c 24 mov %ebx,(%esp) 10c267: e8 50 26 00 00 call 10e8bc <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10c26c: 5e pop %esi 10c26d: ff 75 b4 pushl -0x4c(%ebp) 10c270: e8 ff 0c 00 00 call 10cf74 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10c275: 8b 73 14 mov 0x14(%ebx),%esi 10c278: 83 c4 10 add $0x10,%esp 10c27b: 8b 46 2c mov 0x2c(%esi),%eax 10c27e: 83 f8 02 cmp $0x2,%eax
10c281: 74 21 je 10c2a4 <rtems_aio_handle+0xa8>
10c283: 83 f8 03 cmp $0x3,%eax
10c286: 74 6c je 10c2f4 <rtems_aio_handle+0xf8> <== NEVER TAKEN
10c288: 48 dec %eax
10c289: 74 4d je 10c2d8 <rtems_aio_handle+0xdc> <== ALWAYS TAKEN
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
10c28b: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10c292: e8 01 99 00 00 call 115b98 <__errno> <== NOT EXECUTED 10c297: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10c299: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10c29c: e9 6f ff ff ff jmp 10c210 <rtems_aio_handle+0x14> <== NOT EXECUTED 10c2a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
10c2a4: 83 ec 0c sub $0xc,%esp 10c2a7: ff 76 08 pushl 0x8(%esi) 10c2aa: ff 76 04 pushl 0x4(%esi) 10c2ad: ff 76 10 pushl 0x10(%esi) 10c2b0: ff 76 0c pushl 0xc(%esi) 10c2b3: ff 36 pushl (%esi) 10c2b5: e8 76 a3 00 00 call 116630 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c2ba: 83 c4 20 add $0x20,%esp
break;
default:
result = -1;
}
if (result == -1) {
10c2bd: 83 f8 ff cmp $0xffffffff,%eax
10c2c0: 0f 84 78 01 00 00 je 10c43e <rtems_aio_handle+0x242><== NEVER TAKEN
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
10c2c6: 8b 53 14 mov 0x14(%ebx),%edx 10c2c9: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10c2cc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10c2d3: e9 38 ff ff ff jmp 10c210 <rtems_aio_handle+0x14>
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
10c2d8: 83 ec 0c sub $0xc,%esp 10c2db: ff 76 08 pushl 0x8(%esi) 10c2de: ff 76 04 pushl 0x4(%esi) 10c2e1: ff 76 10 pushl 0x10(%esi) 10c2e4: ff 76 0c pushl 0xc(%esi) 10c2e7: ff 36 pushl (%esi) 10c2e9: e8 8e a2 00 00 call 11657c <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c2ee: 83 c4 20 add $0x20,%esp 10c2f1: eb ca jmp 10c2bd <rtems_aio_handle+0xc1> 10c2f3: 90 nop
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10c2f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2f7: ff 36 pushl (%esi) <== NOT EXECUTED 10c2f9: e8 16 67 00 00 call 112a14 <fsync> <== NOT EXECUTED
break;
10c2fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c301: eb ba jmp 10c2bd <rtems_aio_handle+0xc1> <== NOT EXECUTED 10c303: 90 nop <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10c304: 83 ec 0c sub $0xc,%esp 10c307: ff 75 b4 pushl -0x4c(%ebp) 10c30a: e8 65 0c 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10c30f: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp) 10c316: e8 d1 0b 00 00 call 10ceec <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10c31b: 83 c4 10 add $0x10,%esp 10c31e: 3b 5f 08 cmp 0x8(%edi),%ebx
10c321: 74 39 je 10c35c <rtems_aio_handle+0x160><== ALWAYS TAKEN
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
10c323: 83 ec 0c sub $0xc,%esp 10c326: 68 00 aa 12 00 push $0x12aa00 10c32b: e8 44 0c 00 00 call 10cf74 <pthread_mutex_unlock> 10c330: 83 c4 10 add $0x10,%esp 10c333: e9 d8 fe ff ff jmp 10c210 <rtems_aio_handle+0x14>
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
10c338: ff 0d 68 aa 12 00 decl 0x12aa68
pthread_mutex_unlock (&aio_request_queue.mutex);
10c33e: 83 ec 0c sub $0xc,%esp 10c341: 68 00 aa 12 00 push $0x12aa00 10c346: e8 29 0c 00 00 call 10cf74 <pthread_mutex_unlock>
return NULL;
10c34b: 83 c4 10 add $0x10,%esp 10c34e: 66 90 xchg %ax,%ax
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c350: 31 c0 xor %eax,%eax 10c352: 8d 65 f4 lea -0xc(%ebp),%esp 10c355: 5b pop %ebx 10c356: 5e pop %esi 10c357: 5f pop %edi 10c358: c9 leave 10c359: c3 ret 10c35a: 66 90 xchg %ax,%ax
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
10c35c: 83 ec 08 sub $0x8,%esp 10c35f: 8d 45 dc lea -0x24(%ebp),%eax 10c362: 50 push %eax 10c363: 6a 01 push $0x1 10c365: e8 66 05 00 00 call 10c8d0 <clock_gettime>
timeout.tv_sec += 3;
10c36a: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10c36e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10c375: 8d 5f 20 lea 0x20(%edi),%ebx 10c378: 83 c4 0c add $0xc,%esp 10c37b: 8d 55 dc lea -0x24(%ebp),%edx 10c37e: 52 push %edx 10c37f: 68 00 aa 12 00 push $0x12aa00 10c384: 53 push %ebx 10c385: e8 b6 07 00 00 call 10cb40 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
10c38a: 83 c4 10 add $0x10,%esp 10c38d: 83 f8 74 cmp $0x74,%eax
10c390: 75 91 jne 10c323 <rtems_aio_handle+0x127><== NEVER TAKEN
10c392: 83 ec 0c sub $0xc,%esp 10c395: 57 push %edi 10c396: e8 21 25 00 00 call 10e8bc <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
10c39b: 59 pop %ecx 10c39c: ff 75 b4 pushl -0x4c(%ebp) 10c39f: e8 dc 08 00 00 call 10cc80 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10c3a4: 89 1c 24 mov %ebx,(%esp) 10c3a7: e8 90 05 00 00 call 10c93c <pthread_cond_destroy>
free (r_chain);
10c3ac: 89 3c 24 mov %edi,(%esp) 10c3af: e8 80 c7 ff ff call 108b34 <free>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c3b4: 8b 3d 54 aa 12 00 mov 0x12aa54,%edi
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10c3ba: 83 c4 10 add $0x10,%esp 10c3bd: 81 ff 58 aa 12 00 cmp $0x12aa58,%edi
10c3c3: 74 2b je 10c3f0 <rtems_aio_handle+0x1f4>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
10c3c5: ff 0d 68 aa 12 00 decl 0x12aa68
++aio_request_queue.active_threads;
10c3cb: ff 05 64 aa 12 00 incl 0x12aa64 10c3d1: 83 ec 0c sub $0xc,%esp 10c3d4: 57 push %edi 10c3d5: e8 e2 24 00 00 call 10e8bc <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
10c3da: 89 3c 24 mov %edi,(%esp) 10c3dd: e8 de fd ff ff call 10c1c0 <rtems_aio_move_to_work> 10c3e2: 83 c4 10 add $0x10,%esp 10c3e5: 8d 47 1c lea 0x1c(%edi),%eax 10c3e8: 89 45 b4 mov %eax,-0x4c(%ebp) 10c3eb: e9 33 ff ff ff jmp 10c323 <rtems_aio_handle+0x127>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
10c3f0: ff 05 68 aa 12 00 incl 0x12aa68
--aio_request_queue.active_threads;
10c3f6: ff 0d 64 aa 12 00 decl 0x12aa64
clock_gettime (CLOCK_REALTIME, &timeout);
10c3fc: 52 push %edx 10c3fd: 52 push %edx 10c3fe: 8d 45 dc lea -0x24(%ebp),%eax 10c401: 50 push %eax 10c402: 6a 01 push $0x1 10c404: e8 c7 04 00 00 call 10c8d0 <clock_gettime>
timeout.tv_sec += 3;
10c409: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10c40d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10c414: 83 c4 0c add $0xc,%esp 10c417: 8d 55 dc lea -0x24(%ebp),%edx 10c41a: 52 push %edx 10c41b: 68 00 aa 12 00 push $0x12aa00 10c420: 68 04 aa 12 00 push $0x12aa04 10c425: e8 16 07 00 00 call 10cb40 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10c42a: 83 c4 10 add $0x10,%esp 10c42d: 83 f8 74 cmp $0x74,%eax
10c430: 0f 84 02 ff ff ff je 10c338 <rtems_aio_handle+0x13c><== ALWAYS TAKEN
10c436: 8b 3d 54 aa 12 00 mov 0x12aa54,%edi <== NOT EXECUTED 10c43c: eb 87 jmp 10c3c5 <rtems_aio_handle+0x1c9><== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
10c43e: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED 10c441: e9 45 fe ff ff jmp 10c28b <rtems_aio_handle+0x8f> <== NOT EXECUTED
0010bfd8 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10bfd8: 55 push %ebp 10bfd9: 89 e5 mov %esp,%ebp 10bfdb: 53 push %ebx 10bfdc: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10bfdf: 68 08 aa 12 00 push $0x12aa08 10bfe4: e8 a3 10 00 00 call 10d08c <pthread_attr_init> 10bfe9: 89 c3 mov %eax,%ebx
if (result != 0)
10bfeb: 83 c4 10 add $0x10,%esp 10bfee: 85 c0 test %eax,%eax
10bff0: 74 0a je 10bffc <rtems_aio_init+0x24> <== ALWAYS TAKEN
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
10bff2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bff4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bff7: c9 leave <== NOT EXECUTED 10bff8: c3 ret <== NOT EXECUTED 10bff9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
10bffc: 83 ec 08 sub $0x8,%esp 10bfff: 6a 00 push $0x0 10c001: 68 08 aa 12 00 push $0x12aa08 10c006: e8 ad 10 00 00 call 10d0b8 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10c00b: 83 c4 10 add $0x10,%esp 10c00e: 85 c0 test %eax,%eax
10c010: 0f 85 96 00 00 00 jne 10c0ac <rtems_aio_init+0xd4> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10c016: 83 ec 08 sub $0x8,%esp 10c019: 6a 00 push $0x0 10c01b: 68 00 aa 12 00 push $0x12aa00 10c020: e8 7b 0d 00 00 call 10cda0 <pthread_mutex_init>
if (result != 0)
10c025: 83 c4 10 add $0x10,%esp 10c028: 85 c0 test %eax,%eax
10c02a: 0f 85 b8 00 00 00 jne 10c0e8 <rtems_aio_init+0x110> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10c030: 83 ec 08 sub $0x8,%esp 10c033: 6a 00 push $0x0 10c035: 68 04 aa 12 00 push $0x12aa04 10c03a: e8 c9 09 00 00 call 10ca08 <pthread_cond_init> 10c03f: 89 c3 mov %eax,%ebx
if (result != 0) {
10c041: 83 c4 10 add $0x10,%esp 10c044: 85 c0 test %eax,%eax
10c046: 75 7c jne 10c0c4 <rtems_aio_init+0xec> <== NEVER TAKEN
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c048: c7 05 48 aa 12 00 4c movl $0x12aa4c,0x12aa48
10c04f: aa 12 00 head->previous = NULL;
10c052: c7 05 4c aa 12 00 00 movl $0x0,0x12aa4c
10c059: 00 00 00 tail->previous = head;
10c05c: c7 05 50 aa 12 00 48 movl $0x12aa48,0x12aa50
10c063: aa 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c066: c7 05 54 aa 12 00 58 movl $0x12aa58,0x12aa54
10c06d: aa 12 00 head->previous = NULL;
10c070: c7 05 58 aa 12 00 00 movl $0x0,0x12aa58
10c077: 00 00 00 tail->previous = head;
10c07a: c7 05 5c aa 12 00 54 movl $0x12aa54,0x12aa5c
10c081: aa 12 00
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
10c084: c7 05 64 aa 12 00 00 movl $0x0,0x12aa64
10c08b: 00 00 00 aio_request_queue.idle_threads = 0;
10c08e: c7 05 68 aa 12 00 00 movl $0x0,0x12aa68
10c095: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10c098: c7 05 60 aa 12 00 0b movl $0xb00b,0x12aa60
10c09f: b0 00 00
return result;
}
10c0a2: 89 d8 mov %ebx,%eax 10c0a4: 8b 5d fc mov -0x4(%ebp),%ebx 10c0a7: c9 leave 10c0a8: c3 ret 10c0a9: 8d 76 00 lea 0x0(%esi),%esi
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
10c0ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0af: 68 08 aa 12 00 push $0x12aa08 <== NOT EXECUTED 10c0b4: e8 af 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED 10c0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0bc: e9 55 ff ff ff jmp 10c016 <rtems_aio_init+0x3e> <== NOT EXECUTED 10c0c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
if (result != 0) {
pthread_mutex_destroy (&aio_request_queue.mutex);
10c0c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0c7: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED 10c0cc: e8 af 0b 00 00 call 10cc80 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10c0d1: c7 04 24 08 aa 12 00 movl $0x12aa08,(%esp) <== NOT EXECUTED 10c0d8: e8 8b 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED 10c0dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0e0: e9 63 ff ff ff jmp 10c048 <rtems_aio_init+0x70> <== NOT EXECUTED 10c0e5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
10c0e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0eb: 68 08 aa 12 00 push $0x12aa08 <== NOT EXECUTED 10c0f0: e8 73 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED 10c0f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0f8: e9 33 ff ff ff jmp 10c030 <rtems_aio_init+0x58> <== NOT EXECUTED
0010c448 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10c448: 55 push %ebp 10c449: 89 e5 mov %esp,%ebp 10c44b: 56 push %esi 10c44c: 53 push %ebx 10c44d: 8b 55 08 mov 0x8(%ebp),%edx 10c450: 8b 75 0c mov 0xc(%ebp),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c453: 8b 02 mov (%edx),%eax 10c455: 8d 4a 04 lea 0x4(%edx),%ecx
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
10c458: 39 c8 cmp %ecx,%eax
10c45a: 74 27 je 10c483 <rtems_aio_insert_prio+0x3b><== NEVER TAKEN
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10c45c: 8b 56 14 mov 0x14(%esi),%edx 10c45f: 8b 5a 14 mov 0x14(%edx),%ebx
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10c462: 8b 50 14 mov 0x14(%eax),%edx
while (req->aiocbp->aio_reqprio > prio &&
10c465: 39 5a 14 cmp %ebx,0x14(%edx)
10c468: 7c 06 jl 10c470 <rtems_aio_insert_prio+0x28><== NEVER TAKEN
10c46a: eb 0e jmp 10c47a <rtems_aio_insert_prio+0x32>
10c46c: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10c46e: 74 1c je 10c48c <rtems_aio_insert_prio+0x44><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c470: 8b 00 mov (%eax),%eax <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10c472: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10c475: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED 10c478: 7c f2 jl 10c46c <rtems_aio_insert_prio+0x24><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10c47a: 89 75 0c mov %esi,0xc(%ebp) 10c47d: 8b 40 04 mov 0x4(%eax),%eax 10c480: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10c483: 5b pop %ebx 10c484: 5e pop %esi 10c485: c9 leave 10c486: e9 6d 24 00 00 jmp 10e8f8 <_Chain_Insert> 10c48b: 90 nop
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c48c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c48e: eb ea jmp 10c47a <rtems_aio_insert_prio+0x32><== NOT EXECUTED
0010c1c0 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10c1c0: 55 push %ebp 10c1c1: 89 e5 mov %esp,%ebp 10c1c3: 83 ec 08 sub $0x8,%esp 10c1c6: 8b 4d 08 mov 0x8(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1c9: a1 48 aa 12 00 mov 0x12aa48,%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10c1ce: 8b 51 14 mov 0x14(%ecx),%edx 10c1d1: 39 50 14 cmp %edx,0x14(%eax)
10c1d4: 7c 09 jl 10c1df <rtems_aio_move_to_work+0x1f><== ALWAYS TAKEN
10c1d6: eb 13 jmp 10c1eb <rtems_aio_move_to_work+0x2b><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1d8: 8b 00 mov (%eax),%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10c1da: 39 50 14 cmp %edx,0x14(%eax)
10c1dd: 7d 0c jge 10c1eb <rtems_aio_move_to_work+0x2b>
10c1df: 3d 4c aa 12 00 cmp $0x12aa4c,%eax
10c1e4: 75 f2 jne 10c1d8 <rtems_aio_move_to_work+0x18><== ALWAYS TAKEN
10c1e6: b8 4c aa 12 00 mov $0x12aa4c,%eax <== NOT EXECUTED
10c1eb: 83 ec 08 sub $0x8,%esp 10c1ee: 51 push %ecx 10c1ef: ff 70 04 pushl 0x4(%eax) 10c1f2: e8 01 27 00 00 call 10e8f8 <_Chain_Insert> 10c1f7: 83 c4 10 add $0x10,%esp
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
10c1fa: c9 leave 10c1fb: c3 ret
0010c490 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10c490: 55 push %ebp 10c491: 89 e5 mov %esp,%ebp 10c493: 57 push %edi 10c494: 56 push %esi 10c495: 53 push %ebx 10c496: 83 ec 0c sub $0xc,%esp 10c499: 8b 7d 08 mov 0x8(%ebp),%edi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c49c: 8b 5f 08 mov 0x8(%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c49f: 83 c7 0c add $0xc,%edi
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10c4a2: 39 fb cmp %edi,%ebx
10c4a4: 75 04 jne 10c4aa <rtems_aio_remove_fd+0x1a><== ALWAYS TAKEN
10c4a6: eb 2d jmp 10c4d5 <rtems_aio_remove_fd+0x45><== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
10c4a8: 89 f3 mov %esi,%ebx
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c4aa: 83 ec 0c sub $0xc,%esp 10c4ad: 53 push %ebx 10c4ae: e8 09 24 00 00 call 10e8bc <_Chain_Extract>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4b3: 8b 33 mov (%ebx),%esi
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
10c4b5: 8b 43 14 mov 0x14(%ebx),%eax 10c4b8: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
req->aiocbp->return_value = -1;
10c4bf: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (req);
10c4c6: 89 1c 24 mov %ebx,(%esp) 10c4c9: e8 66 c6 ff ff call 108b34 <free>
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10c4ce: 83 c4 10 add $0x10,%esp 10c4d1: 39 fe cmp %edi,%esi
10c4d3: 75 d3 jne 10c4a8 <rtems_aio_remove_fd+0x18>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10c4d5: 8d 65 f4 lea -0xc(%ebp),%esp 10c4d8: 5b pop %ebx 10c4d9: 5e pop %esi 10c4da: 5f pop %edi 10c4db: c9 leave 10c4dc: c3 ret
0010c4e0 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
10c4e0: 55 push %ebp 10c4e1: 89 e5 mov %esp,%ebp 10c4e3: 53 push %ebx 10c4e4: 83 ec 04 sub $0x4,%esp 10c4e7: 8b 55 08 mov 0x8(%ebp),%edx 10c4ea: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4ed: 8b 02 mov (%edx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c4ef: 83 c2 04 add $0x4,%edx
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
10c4f2: 39 d0 cmp %edx,%eax
10c4f4: 74 4e je 10c544 <rtems_aio_remove_req+0x64>
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
10c4f6: 89 c3 mov %eax,%ebx
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c4f8: 39 48 14 cmp %ecx,0x14(%eax)
10c4fb: 75 0a jne 10c507 <rtems_aio_remove_req+0x27><== NEVER TAKEN
10c4fd: eb 19 jmp 10c518 <rtems_aio_remove_req+0x38> 10c4ff: 90 nop
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10c500: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c502: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED 10c505: 74 11 je 10c518 <rtems_aio_remove_req+0x38><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c507: 8b 00 mov (%eax),%eax <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c509: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c50b: 75 f3 jne 10c500 <rtems_aio_remove_req+0x20><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10c50d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c512: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c515: c9 leave <== NOT EXECUTED 10c516: c3 ret <== NOT EXECUTED 10c517: 90 nop <== NOT EXECUTED
10c518: 83 ec 0c sub $0xc,%esp 10c51b: 50 push %eax 10c51c: e8 9b 23 00 00 call 10e8bc <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10c521: 8b 43 14 mov 0x14(%ebx),%eax 10c524: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10c52b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10c532: 89 1c 24 mov %ebx,(%esp) 10c535: e8 fa c5 ff ff call 108b34 <free>
}
return AIO_CANCELED;
10c53a: 83 c4 10 add $0x10,%esp 10c53d: 31 c0 xor %eax,%eax
}
10c53f: 8b 5d fc mov -0x4(%ebp),%ebx 10c542: c9 leave 10c543: c3 ret
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10c544: b8 02 00 00 00 mov $0x2,%eax
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c549: 8b 5d fc mov -0x4(%ebp),%ebx 10c54c: c9 leave 10c54d: c3 ret
0010c100 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
10c100: 55 push %ebp 10c101: 89 e5 mov %esp,%ebp 10c103: 57 push %edi 10c104: 56 push %esi 10c105: 53 push %ebx 10c106: 83 ec 1c sub $0x1c,%esp 10c109: 8b 75 08 mov 0x8(%ebp),%esi 10c10c: 8b 5d 0c mov 0xc(%ebp),%ebx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c10f: 8b 06 mov (%esi),%eax
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
10c111: 8b 50 14 mov 0x14(%eax),%edx 10c114: 39 d3 cmp %edx,%ebx
10c116: 7e 28 jle 10c140 <rtems_aio_search_fd+0x40>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c118: 8d 4e 04 lea 0x4(%esi),%ecx 10c11b: eb 0c jmp 10c129 <rtems_aio_search_fd+0x29> 10c11d: 8d 76 00 lea 0x0(%esi),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c120: 8b 00 mov (%eax),%eax
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
10c122: 8b 50 14 mov 0x14(%eax),%edx 10c125: 39 da cmp %ebx,%edx
10c127: 7d 17 jge 10c140 <rtems_aio_search_fd+0x40>
10c129: 39 c8 cmp %ecx,%eax
10c12b: 75 f3 jne 10c120 <rtems_aio_search_fd+0x20>
10c12d: 89 c7 mov %eax,%edi
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
10c12f: 8b 45 10 mov 0x10(%ebp),%eax 10c132: 85 c0 test %eax,%eax
10c134: 75 1f jne 10c155 <rtems_aio_search_fd+0x55>
r_chain = NULL;
10c136: 31 c0 xor %eax,%eax
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c138: 8d 65 f4 lea -0xc(%ebp),%esp 10c13b: 5b pop %ebx 10c13c: 5e pop %esi 10c13d: 5f pop %edi 10c13e: c9 leave 10c13f: c3 ret
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c140: 89 c7 mov %eax,%edi
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
10c142: 39 d3 cmp %edx,%ebx
10c144: 75 e9 jne 10c12f <rtems_aio_search_fd+0x2f>
r_chain->new_fd = 0;
10c146: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c14d: 8d 65 f4 lea -0xc(%ebp),%esp 10c150: 5b pop %ebx 10c151: 5e pop %esi 10c152: 5f pop %edi 10c153: c9 leave 10c154: c3 ret
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
10c155: 83 ec 0c sub $0xc,%esp 10c158: 6a 24 push $0x24 10c15a: e8 e9 ce ff ff call 109048 <malloc> 10c15f: 89 c2 mov %eax,%edx
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10c161: 8d 4a 0c lea 0xc(%edx),%ecx 10c164: 89 4a 08 mov %ecx,0x8(%edx)
head->next = tail;
head->previous = NULL;
10c167: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10c16e: 8d 4a 08 lea 0x8(%edx),%ecx 10c171: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c174: 8d 4e 04 lea 0x4(%esi),%ecx
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
10c177: 83 c4 10 add $0x10,%esp 10c17a: 39 0e cmp %ecx,(%esi)
10c17c: 74 27 je 10c1a5 <rtems_aio_search_fd+0xa5>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10c17e: 83 ec 08 sub $0x8,%esp 10c181: 52 push %edx 10c182: ff 77 04 pushl 0x4(%edi) 10c185: 89 45 e4 mov %eax,-0x1c(%ebp) 10c188: 89 55 e0 mov %edx,-0x20(%ebp) 10c18b: e8 68 27 00 00 call 10e8f8 <_Chain_Insert> 10c190: 83 c4 10 add $0x10,%esp 10c193: 8b 55 e0 mov -0x20(%ebp),%edx 10c196: 8b 45 e4 mov -0x1c(%ebp),%eax
rtems_chain_prepend (chain, &r_chain->next_fd);
else
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
r_chain->new_fd = 1;
10c199: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx)
r_chain->fildes = fildes;
10c1a0: 89 5a 14 mov %ebx,0x14(%edx) 10c1a3: eb a8 jmp 10c14d <rtems_aio_search_fd+0x4d>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10c1a5: 83 ec 08 sub $0x8,%esp 10c1a8: 52 push %edx 10c1a9: 56 push %esi 10c1aa: 89 45 e4 mov %eax,-0x1c(%ebp) 10c1ad: 89 55 e0 mov %edx,-0x20(%ebp) 10c1b0: e8 43 27 00 00 call 10e8f8 <_Chain_Insert> 10c1b5: 83 c4 10 add $0x10,%esp 10c1b8: 8b 45 e4 mov -0x1c(%ebp),%eax 10c1bb: 8b 55 e0 mov -0x20(%ebp),%edx 10c1be: eb d9 jmp 10c199 <rtems_aio_search_fd+0x99>
001136b4 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
1136b4: 55 push %ebp 1136b5: 89 e5 mov %esp,%ebp 1136b7: 57 push %edi 1136b8: 56 push %esi 1136b9: 53 push %ebx 1136ba: 83 ec 2c sub $0x2c,%esp 1136bd: 8b 5d 08 mov 0x8(%ebp),%ebx 1136c0: 8b 7d 0c mov 0xc(%ebp),%edi 1136c3: 8b 45 10 mov 0x10(%ebp),%eax 1136c6: 8b 75 14 mov 0x14(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
1136c9: 85 db test %ebx,%ebx
1136cb: 0f 84 87 00 00 00 je 113758 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
1136d1: 85 f6 test %esi,%esi
1136d3: 0f 84 bf 00 00 00 je 113798 <rtems_barrier_create+0xe4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
1136d9: f7 c7 10 00 00 00 test $0x10,%edi
1136df: 0f 84 83 00 00 00 je 113768 <rtems_barrier_create+0xb4>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
1136e5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( maximum_waiters == 0 )
1136ec: 85 c0 test %eax,%eax
1136ee: 0f 84 80 00 00 00 je 113774 <rtems_barrier_create+0xc0><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
1136f4: 89 45 e4 mov %eax,-0x1c(%ebp) 1136f7: a1 90 a7 12 00 mov 0x12a790,%eax 1136fc: 40 inc %eax 1136fd: a3 90 a7 12 00 mov %eax,0x12a790
* 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 );
113702: 83 ec 0c sub $0xc,%esp 113705: 68 80 b1 12 00 push $0x12b180 11370a: e8 51 b0 ff ff call 10e760 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
11370f: 83 c4 10 add $0x10,%esp 113712: 85 c0 test %eax,%eax
113714: 74 6e je 113784 <rtems_barrier_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
113716: 89 78 10 mov %edi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
113719: 83 ec 08 sub $0x8,%esp 11371c: 8d 55 e0 lea -0x20(%ebp),%edx 11371f: 52 push %edx 113720: 8d 50 14 lea 0x14(%eax),%edx 113723: 52 push %edx 113724: 89 45 d4 mov %eax,-0x2c(%ebp) 113727: e8 c0 07 00 00 call 113eec <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
11372c: 8b 45 d4 mov -0x2c(%ebp),%eax 11372f: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
113732: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
113735: 8b 0d 9c b1 12 00 mov 0x12b19c,%ecx 11373b: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
11373e: 89 58 0c mov %ebx,0xc(%eax)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
113741: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
113743: e8 74 c0 ff ff call 10f7bc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
113748: 83 c4 10 add $0x10,%esp 11374b: 31 c0 xor %eax,%eax
}
11374d: 8d 65 f4 lea -0xc(%ebp),%esp 113750: 5b pop %ebx 113751: 5e pop %esi 113752: 5f pop %edi 113753: c9 leave 113754: c3 ret 113755: 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;
113758: b8 03 00 00 00 mov $0x3,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11375d: 8d 65 f4 lea -0xc(%ebp),%esp 113760: 5b pop %ebx 113761: 5e pop %esi 113762: 5f pop %edi 113763: c9 leave 113764: c3 ret 113765: 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;
113768: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 11376f: eb 83 jmp 1136f4 <rtems_barrier_create+0x40> 113771: 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;
113774: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113779: 8d 65 f4 lea -0xc(%ebp),%esp 11377c: 5b pop %ebx 11377d: 5e pop %esi 11377e: 5f pop %edi 11377f: c9 leave 113780: c3 ret 113781: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
113784: e8 33 c0 ff ff call 10f7bc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
113789: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11378e: 8d 65 f4 lea -0xc(%ebp),%esp 113791: 5b pop %ebx 113792: 5e pop %esi 113793: 5f pop %edi 113794: c9 leave 113795: c3 ret 113796: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
113798: b8 09 00 00 00 mov $0x9,%eax 11379d: eb ae jmp 11374d <rtems_barrier_create+0x99>
0010c140 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c140: 55 push %ebp 10c141: 89 e5 mov %esp,%ebp 10c143: 56 push %esi 10c144: 53 push %ebx 10c145: 8b 5d 10 mov 0x10(%ebp),%ebx 10c148: 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 );
10c14b: 83 ec 08 sub $0x8,%esp 10c14e: ff 75 0c pushl 0xc(%ebp) 10c151: ff 75 08 pushl 0x8(%ebp) 10c154: e8 eb 04 00 00 call 10c644 <_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 ) {
10c159: 83 c4 10 add $0x10,%esp 10c15c: 84 c0 test %al,%al
10c15e: 75 0c jne 10c16c <rtems_chain_append_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c160: 31 c0 xor %eax,%eax
10c162: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c165: 5b pop %ebx <== NOT EXECUTED 10c166: 5e pop %esi <== NOT EXECUTED 10c167: c9 leave <== NOT EXECUTED 10c168: c3 ret <== NOT EXECUTED 10c169: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10c16c: 89 75 0c mov %esi,0xc(%ebp) 10c16f: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c172: 8d 65 f8 lea -0x8(%ebp),%esp 10c175: 5b pop %ebx 10c176: 5e pop %esi 10c177: 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 );
10c178: e9 af f5 ff ff jmp 10b72c <rtems_event_send>
0010c180 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
10c180: 55 push %ebp 10c181: 89 e5 mov %esp,%ebp 10c183: 56 push %esi 10c184: 53 push %ebx 10c185: 8b 5d 0c mov 0xc(%ebp),%ebx 10c188: 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 );
10c18b: 83 ec 08 sub $0x8,%esp 10c18e: ff 75 14 pushl 0x14(%ebp) 10c191: ff 75 08 pushl 0x8(%ebp) 10c194: e8 13 05 00 00 call 10c6ac <_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 ) {
10c199: 83 c4 10 add $0x10,%esp 10c19c: 84 c0 test %al,%al
10c19e: 75 0c jne 10c1ac <rtems_chain_get_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10c1a0: 31 c0 xor %eax,%eax 10c1a2: 8d 65 f8 lea -0x8(%ebp),%esp 10c1a5: 5b pop %ebx 10c1a6: 5e pop %esi 10c1a7: c9 leave 10c1a8: c3 ret 10c1a9: 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 );
10c1ac: 89 75 0c mov %esi,0xc(%ebp) 10c1af: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c1b2: 8d 65 f8 lea -0x8(%ebp),%esp 10c1b5: 5b pop %ebx 10c1b6: 5e pop %esi 10c1b7: 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 );
10c1b8: e9 6f f5 ff ff jmp 10b72c <rtems_event_send>
0010c1c0 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10c1c0: 55 push %ebp 10c1c1: 89 e5 mov %esp,%ebp 10c1c3: 57 push %edi 10c1c4: 56 push %esi 10c1c5: 53 push %ebx 10c1c6: 83 ec 1c sub $0x1c,%esp 10c1c9: 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(
10c1cc: 8d 7d e4 lea -0x1c(%ebp),%edi 10c1cf: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10c1d0: 83 ec 0c sub $0xc,%esp 10c1d3: 56 push %esi 10c1d4: e8 0f 05 00 00 call 10c6e8 <_Chain_Get> 10c1d9: 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
10c1db: 83 c4 10 add $0x10,%esp 10c1de: 85 c0 test %eax,%eax
10c1e0: 75 22 jne 10c204 <rtems_chain_get_with_wait+0x44>
) {
rtems_event_set out;
sc = rtems_event_receive(
10c1e2: 57 push %edi 10c1e3: ff 75 10 pushl 0x10(%ebp) 10c1e6: 6a 00 push $0x0 10c1e8: ff 75 0c pushl 0xc(%ebp) 10c1eb: e8 b4 f3 ff ff call 10b5a4 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10c1f0: 83 c4 10 add $0x10,%esp 10c1f3: 85 c0 test %eax,%eax
10c1f5: 74 d9 je 10c1d0 <rtems_chain_get_with_wait+0x10><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10c1f7: 8b 55 14 mov 0x14(%ebp),%edx 10c1fa: 89 1a mov %ebx,(%edx)
return sc;
}
10c1fc: 8d 65 f4 lea -0xc(%ebp),%esp 10c1ff: 5b pop %ebx 10c200: 5e pop %esi 10c201: 5f pop %edi 10c202: c9 leave 10c203: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c204: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10c206: 8b 55 14 mov 0x14(%ebp),%edx 10c209: 89 1a mov %ebx,(%edx)
return sc;
}
10c20b: 8d 65 f4 lea -0xc(%ebp),%esp 10c20e: 5b pop %ebx 10c20f: 5e pop %esi 10c210: 5f pop %edi 10c211: c9 leave 10c212: c3 ret
0010c214 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c214: 55 push %ebp 10c215: 89 e5 mov %esp,%ebp 10c217: 56 push %esi 10c218: 53 push %ebx 10c219: 8b 5d 10 mov 0x10(%ebp),%ebx 10c21c: 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 );
10c21f: 83 ec 08 sub $0x8,%esp 10c222: ff 75 0c pushl 0xc(%ebp) 10c225: ff 75 08 pushl 0x8(%ebp) 10c228: e8 ff 04 00 00 call 10c72c <_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) {
10c22d: 83 c4 10 add $0x10,%esp 10c230: 84 c0 test %al,%al
10c232: 75 0c jne 10c240 <rtems_chain_prepend_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c234: 31 c0 xor %eax,%eax
10c236: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c239: 5b pop %ebx <== NOT EXECUTED 10c23a: 5e pop %esi <== NOT EXECUTED 10c23b: c9 leave <== NOT EXECUTED 10c23c: c3 ret <== NOT EXECUTED 10c23d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10c240: 89 75 0c mov %esi,0xc(%ebp) 10c243: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c246: 8d 65 f8 lea -0x8(%ebp),%esp 10c249: 5b pop %ebx 10c24a: 5e pop %esi 10c24b: 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 );
10c24c: e9 db f4 ff ff jmp 10b72c <rtems_event_send>
00115a60 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
115a60: 55 push %ebp 115a61: 89 e5 mov %esp,%ebp 115a63: 53 push %ebx 115a64: 83 ec 04 sub $0x4,%esp 115a67: 8b 45 08 mov 0x8(%ebp),%eax 115a6a: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
115a6d: 85 db test %ebx,%ebx
115a6f: 74 3b je 115aac <rtems_clock_get+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
115a71: 85 c0 test %eax,%eax
115a73: 74 2b je 115aa0 <rtems_clock_get+0x40>
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
115a75: 83 f8 01 cmp $0x1,%eax
115a78: 74 3e je 115ab8 <rtems_clock_get+0x58>
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
115a7a: 83 f8 02 cmp $0x2,%eax
115a7d: 74 45 je 115ac4 <rtems_clock_get+0x64>
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
115a7f: 83 f8 03 cmp $0x3,%eax
115a82: 74 4c je 115ad0 <rtems_clock_get+0x70>
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
115a84: 83 f8 04 cmp $0x4,%eax
115a87: 74 0b je 115a94 <rtems_clock_get+0x34>
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
115a89: b8 0a 00 00 00 mov $0xa,%eax
}
115a8e: 5a pop %edx 115a8f: 5b pop %ebx 115a90: c9 leave 115a91: c3 ret 115a92: 66 90 xchg %ax,%ax
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
115a94: 89 5d 08 mov %ebx,0x8(%ebp)
return RTEMS_INVALID_NUMBER;
}
115a97: 59 pop %ecx 115a98: 5b pop %ebx 115a99: c9 leave
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
115a9a: e9 41 01 00 00 jmp 115be0 <rtems_clock_get_tod_timeval> 115a9f: 90 nop
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
115aa0: 89 5d 08 mov %ebx,0x8(%ebp)
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
115aa3: 58 pop %eax 115aa4: 5b pop %ebx 115aa5: c9 leave
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
115aa6: e9 81 00 00 00 jmp 115b2c <rtems_clock_get_tod> 115aab: 90 nop
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
115aac: b8 09 00 00 00 mov $0x9,%eax
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
115ab1: 5a pop %edx 115ab2: 5b pop %ebx 115ab3: c9 leave 115ab4: c3 ret 115ab5: 8d 76 00 lea 0x0(%esi),%esi
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
115ab8: 89 5d 08 mov %ebx,0x8(%ebp)
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
115abb: 5b pop %ebx 115abc: 5b pop %ebx 115abd: c9 leave
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
115abe: e9 19 00 00 00 jmp 115adc <rtems_clock_get_seconds_since_epoch> 115ac3: 90 nop
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
115ac4: e8 57 00 00 00 call 115b20 <rtems_clock_get_ticks_since_boot> 115ac9: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115acb: 31 c0 xor %eax,%eax 115acd: eb bf jmp 115a8e <rtems_clock_get+0x2e> 115acf: 90 nop
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
115ad0: e8 37 00 00 00 call 115b0c <rtems_clock_get_ticks_per_second> 115ad5: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115ad7: 31 c0 xor %eax,%eax 115ad9: eb b3 jmp 115a8e <rtems_clock_get+0x2e>
00115be0 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
115be0: 55 push %ebp 115be1: 89 e5 mov %esp,%ebp 115be3: 56 push %esi 115be4: 53 push %ebx 115be5: 83 ec 10 sub $0x10,%esp 115be8: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !time )
115beb: 85 db test %ebx,%ebx
115bed: 74 51 je 115c40 <rtems_clock_get_tod_timeval+0x60>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
115bef: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44
115bf6: 75 0c jne 115c04 <rtems_clock_get_tod_timeval+0x24>
return RTEMS_NOT_DEFINED;
115bf8: b8 0b 00 00 00 mov $0xb,%eax
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
115bfd: 8d 65 f8 lea -0x8(%ebp),%esp 115c00: 5b pop %ebx 115c01: 5e pop %esi 115c02: c9 leave 115c03: c3 ret
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
115c04: 9c pushf 115c05: fa cli 115c06: 5e pop %esi
_TOD_Get( &now );
115c07: 83 ec 0c sub $0xc,%esp 115c0a: 8d 45 f0 lea -0x10(%ebp),%eax 115c0d: 50 push %eax 115c0e: e8 1d 44 00 00 call 11a030 <_TOD_Get>
_ISR_Enable(level);
115c13: 56 push %esi 115c14: 9d popf
useconds = (suseconds_t)now.tv_nsec;
115c15: 8b 4d f4 mov -0xc(%ebp),%ecx
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
115c18: 8b 45 f0 mov -0x10(%ebp),%eax 115c1b: 89 03 mov %eax,(%ebx)
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
115c1d: b8 d3 4d 62 10 mov $0x10624dd3,%eax 115c22: f7 e9 imul %ecx 115c24: 89 d0 mov %edx,%eax 115c26: c1 f8 06 sar $0x6,%eax 115c29: c1 f9 1f sar $0x1f,%ecx 115c2c: 29 c8 sub %ecx,%eax 115c2e: 89 43 04 mov %eax,0x4(%ebx)
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
115c31: 83 c4 10 add $0x10,%esp 115c34: 31 c0 xor %eax,%eax
}
115c36: 8d 65 f8 lea -0x8(%ebp),%esp 115c39: 5b pop %ebx 115c3a: 5e pop %esi 115c3b: c9 leave 115c3c: c3 ret 115c3d: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
115c40: b8 09 00 00 00 mov $0x9,%eax 115c45: eb b6 jmp 115bfd <rtems_clock_get_tod_timeval+0x1d>
0010b1d4 <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
10b1d4: 55 push %ebp 10b1d5: 89 e5 mov %esp,%ebp 10b1d7: 83 ec 08 sub $0x8,%esp 10b1da: 8b 45 08 mov 0x8(%ebp),%eax
if ( !uptime )
10b1dd: 85 c0 test %eax,%eax
10b1df: 74 13 je 10b1f4 <rtems_clock_get_uptime+0x20>
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
10b1e1: 83 ec 0c sub $0xc,%esp 10b1e4: 50 push %eax 10b1e5: e8 76 16 00 00 call 10c860 <_TOD_Get_uptime_as_timespec>
return RTEMS_SUCCESSFUL;
10b1ea: 83 c4 10 add $0x10,%esp 10b1ed: 31 c0 xor %eax,%eax
}
10b1ef: c9 leave 10b1f0: c3 ret 10b1f1: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
10b1f4: b8 09 00 00 00 mov $0x9,%eax
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
10b1f9: c9 leave 10b1fa: c3 ret
0010c124 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
10c124: 55 push %ebp 10c125: 89 e5 mov %esp,%ebp 10c127: 53 push %ebx 10c128: 83 ec 14 sub $0x14,%esp 10c12b: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10c12e: 85 db test %ebx,%ebx
10c130: 74 66 je 10c198 <rtems_clock_set+0x74>
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
10c132: 83 ec 0c sub $0xc,%esp 10c135: 53 push %ebx 10c136: e8 39 01 00 00 call 10c274 <_TOD_Validate> 10c13b: 83 c4 10 add $0x10,%esp 10c13e: 84 c0 test %al,%al
10c140: 75 0a jne 10c14c <rtems_clock_set+0x28>
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
10c142: b8 14 00 00 00 mov $0x14,%eax
}
10c147: 8b 5d fc mov -0x4(%ebp),%ebx 10c14a: c9 leave 10c14b: c3 ret
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
10c14c: 83 ec 0c sub $0xc,%esp 10c14f: 53 push %ebx 10c150: e8 93 00 00 00 call 10c1e8 <_TOD_To_seconds> 10c155: 89 45 f0 mov %eax,-0x10(%ebp)
newtime.tv_nsec = time_buffer->ticks *
10c158: 8b 43 18 mov 0x18(%ebx),%eax 10c15b: 0f af 05 6c 62 12 00 imul 0x12626c,%eax 10c162: 8d 04 80 lea (%eax,%eax,4),%eax 10c165: 8d 04 80 lea (%eax,%eax,4),%eax 10c168: 8d 04 80 lea (%eax,%eax,4),%eax 10c16b: c1 e0 03 shl $0x3,%eax 10c16e: 89 45 f4 mov %eax,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c171: a1 10 aa 12 00 mov 0x12aa10,%eax 10c176: 40 inc %eax 10c177: a3 10 aa 12 00 mov %eax,0x12aa10
rtems_configuration_get_nanoseconds_per_tick();
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
10c17c: 8d 45 f0 lea -0x10(%ebp),%eax 10c17f: 89 04 24 mov %eax,(%esp) 10c182: e8 55 19 00 00 call 10dadc <_TOD_Set>
_Thread_Enable_dispatch();
10c187: e8 a4 2f 00 00 call 10f130 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c18c: 83 c4 10 add $0x10,%esp 10c18f: 31 c0 xor %eax,%eax
} return RTEMS_INVALID_CLOCK; }
10c191: 8b 5d fc mov -0x4(%ebp),%ebx 10c194: c9 leave 10c195: c3 ret 10c196: 66 90 xchg %ax,%ax
)
{
struct timespec newtime;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10c198: b8 09 00 00 00 mov $0x9,%eax
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10c19d: 8b 5d fc mov -0x4(%ebp),%ebx 10c1a0: c9 leave 10c1a1: c3 ret
0010afd0 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
10afd0: 55 push %ebp 10afd1: 89 e5 mov %esp,%ebp 10afd3: 83 ec 08 sub $0x8,%esp
_TOD_Tickle_ticks();
10afd6: e8 39 15 00 00 call 10c514 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
10afdb: 83 ec 0c sub $0xc,%esp 10afde: 68 60 7e 12 00 push $0x127e60 10afe3: e8 e4 38 00 00 call 10e8cc <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
10afe8: e8 ab 33 00 00 call 10e398 <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
10afed: a0 44 83 12 00 mov 0x128344,%al
if ( _Thread_Is_context_switch_necessary() &&
10aff2: 83 c4 10 add $0x10,%esp 10aff5: 84 c0 test %al,%al
10aff7: 74 09 je 10b002 <rtems_clock_tick+0x32>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
10aff9: a1 90 7d 12 00 mov 0x127d90,%eax 10affe: 85 c0 test %eax,%eax
10b000: 74 06 je 10b008 <rtems_clock_tick+0x38>
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
10b002: 31 c0 xor %eax,%eax 10b004: c9 leave 10b005: c3 ret 10b006: 66 90 xchg %ax,%ax
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
10b008: e8 2b 28 00 00 call 10d838 <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
}
10b00d: 31 c0 xor %eax,%eax 10b00f: c9 leave 10b010: c3 ret
0010b19c <rtems_event_send>:
rtems_status_code rtems_event_send(
rtems_id id,
rtems_event_set event_in
)
{
10b19c: 55 push %ebp 10b19d: 89 e5 mov %esp,%ebp 10b19f: 53 push %ebx 10b1a0: 83 ec 1c sub $0x1c,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
the_thread = _Thread_Get( id, &location );
10b1a3: 8d 45 f4 lea -0xc(%ebp),%eax 10b1a6: 50 push %eax 10b1a7: ff 75 08 pushl 0x8(%ebp) 10b1aa: e8 25 28 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10b1af: 83 c4 10 add $0x10,%esp 10b1b2: 8b 55 f4 mov -0xc(%ebp),%edx 10b1b5: 85 d2 test %edx,%edx
10b1b7: 75 2b jne 10b1e4 <rtems_event_send+0x48>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10b1b9: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
rtems_event_set *the_event_set
)
{
ISR_Level level;
_ISR_Disable( level );
10b1bf: 9c pushf 10b1c0: fa cli 10b1c1: 59 pop %ecx
*the_event_set |= the_new_events;
10b1c2: 8b 5d 0c mov 0xc(%ebp),%ebx 10b1c5: 09 1a or %ebx,(%edx)
_ISR_Enable( level );
10b1c7: 51 push %ecx 10b1c8: 9d popf
_Event_sets_Post( event_in, &api->pending_events );
_Event_Surrender( the_thread );
10b1c9: 83 ec 0c sub $0xc,%esp 10b1cc: 50 push %eax 10b1cd: e8 1e 00 00 00 call 10b1f0 <_Event_Surrender>
_Thread_Enable_dispatch();
10b1d2: e8 d9 27 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b1d7: 83 c4 10 add $0x10,%esp 10b1da: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b1dc: 8b 5d fc mov -0x4(%ebp),%ebx 10b1df: c9 leave 10b1e0: c3 ret 10b1e1: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1e4: b8 04 00 00 00 mov $0x4,%eax
}
10b1e9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ec: c9 leave 10b1ed: c3 ret
0010d000 <rtems_extension_delete>:
#include <rtems/extension.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
10d000: 55 push %ebp 10d001: 89 e5 mov %esp,%ebp 10d003: 53 push %ebx 10d004: 83 ec 18 sub $0x18,%esp
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
10d007: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Extension_Control *)
_Objects_Get( &_Extension_Information, id, location );
10d00a: 50 push %eax 10d00b: ff 75 08 pushl 0x8(%ebp) 10d00e: 68 20 b6 12 00 push $0x12b620 10d013: e8 28 12 00 00 call 10e240 <_Objects_Get> 10d018: 89 c3 mov %eax,%ebx
switch ( location ) {
10d01a: 83 c4 10 add $0x10,%esp 10d01d: 8b 55 f4 mov -0xc(%ebp),%edx 10d020: 85 d2 test %edx,%edx
10d022: 75 38 jne 10d05c <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10d024: 83 ec 0c sub $0xc,%esp 10d027: 8d 40 10 lea 0x10(%eax),%eax 10d02a: 50 push %eax 10d02b: e8 d0 29 00 00 call 10fa00 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10d030: 59 pop %ecx 10d031: 58 pop %eax 10d032: 53 push %ebx 10d033: 68 20 b6 12 00 push $0x12b620 10d038: e8 cb 0d 00 00 call 10de08 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _Extension_Free (
Extension_Control *the_extension
)
{
_Objects_Free( &_Extension_Information, &the_extension->Object );
10d03d: 58 pop %eax 10d03e: 5a pop %edx 10d03f: 53 push %ebx 10d040: 68 20 b6 12 00 push $0x12b620 10d045: e8 b6 10 00 00 call 10e100 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10d04a: e8 69 1d 00 00 call 10edb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d04f: 83 c4 10 add $0x10,%esp 10d052: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d054: 8b 5d fc mov -0x4(%ebp),%ebx 10d057: c9 leave 10d058: c3 ret 10d059: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d05c: b8 04 00 00 00 mov $0x4,%eax
}
10d061: 8b 5d fc mov -0x4(%ebp),%ebx 10d064: c9 leave 10d065: c3 ret
00112f54 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112f54: 55 push %ebp 112f55: 89 e5 mov %esp,%ebp 112f57: 53 push %ebx 112f58: 83 ec 04 sub $0x4,%esp 112f5b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112f5e: 39 05 00 88 12 00 cmp %eax,0x128800
112f64: 76 1a jbe 112f80 <rtems_io_close+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
112f66: 8d 14 40 lea (%eax,%eax,2),%edx 112f69: c1 e2 03 shl $0x3,%edx 112f6c: 03 15 04 88 12 00 add 0x128804,%edx 112f72: 8b 52 08 mov 0x8(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112f75: 85 d2 test %edx,%edx
112f77: 74 13 je 112f8c <rtems_io_close+0x38> }
112f79: 59 pop %ecx 112f7a: 5b pop %ebx 112f7b: 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;
112f7c: ff e2 jmp *%edx 112f7e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112f80: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112f85: 5a pop %edx 112f86: 5b pop %ebx 112f87: c9 leave 112f88: c3 ret 112f89: 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;
112f8c: 31 c0 xor %eax,%eax
}
112f8e: 5a pop %edx 112f8f: 5b pop %ebx 112f90: c9 leave 112f91: c3 ret
00112f94 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112f94: 55 push %ebp 112f95: 89 e5 mov %esp,%ebp 112f97: 53 push %ebx 112f98: 83 ec 04 sub $0x4,%esp 112f9b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112f9e: 39 05 00 88 12 00 cmp %eax,0x128800
112fa4: 76 1a jbe 112fc0 <rtems_io_control+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
112fa6: 8d 14 40 lea (%eax,%eax,2),%edx 112fa9: c1 e2 03 shl $0x3,%edx 112fac: 03 15 04 88 12 00 add 0x128804,%edx 112fb2: 8b 52 14 mov 0x14(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112fb5: 85 d2 test %edx,%edx
112fb7: 74 13 je 112fcc <rtems_io_control+0x38> }
112fb9: 59 pop %ecx 112fba: 5b pop %ebx 112fbb: 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;
112fbc: ff e2 jmp *%edx 112fbe: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112fc0: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112fc5: 5a pop %edx 112fc6: 5b pop %ebx 112fc7: c9 leave 112fc8: c3 ret 112fc9: 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;
112fcc: 31 c0 xor %eax,%eax
}
112fce: 5a pop %edx 112fcf: 5b pop %ebx 112fd0: c9 leave 112fd1: c3 ret
00111044 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111044: 55 push %ebp 111045: 89 e5 mov %esp,%ebp 111047: 53 push %ebx 111048: 83 ec 04 sub $0x4,%esp 11104b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11104e: 39 05 00 88 12 00 cmp %eax,0x128800
111054: 76 1a jbe 111070 <rtems_io_initialize+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
111056: 8d 14 40 lea (%eax,%eax,2),%edx 111059: c1 e2 03 shl $0x3,%edx 11105c: 03 15 04 88 12 00 add 0x128804,%edx 111062: 8b 12 mov (%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111064: 85 d2 test %edx,%edx
111066: 74 14 je 11107c <rtems_io_initialize+0x38> }
111068: 59 pop %ecx 111069: 5b pop %ebx 11106a: 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;
11106b: ff e2 jmp *%edx 11106d: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111070: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111075: 5a pop %edx 111076: 5b pop %ebx 111077: c9 leave 111078: c3 ret 111079: 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;
11107c: 31 c0 xor %eax,%eax
}
11107e: 5a pop %edx 11107f: 5b pop %ebx 111080: c9 leave 111081: c3 ret
00112fd4 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112fd4: 55 push %ebp 112fd5: 89 e5 mov %esp,%ebp 112fd7: 53 push %ebx 112fd8: 83 ec 04 sub $0x4,%esp 112fdb: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112fde: 39 05 00 88 12 00 cmp %eax,0x128800
112fe4: 76 1a jbe 113000 <rtems_io_open+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
112fe6: 8d 14 40 lea (%eax,%eax,2),%edx 112fe9: c1 e2 03 shl $0x3,%edx 112fec: 03 15 04 88 12 00 add 0x128804,%edx 112ff2: 8b 52 04 mov 0x4(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112ff5: 85 d2 test %edx,%edx
112ff7: 74 13 je 11300c <rtems_io_open+0x38> }
112ff9: 59 pop %ecx 112ffa: 5b pop %ebx 112ffb: 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;
112ffc: ff e2 jmp *%edx 112ffe: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113000: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113005: 5a pop %edx 113006: 5b pop %ebx 113007: c9 leave 113008: c3 ret 113009: 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;
11300c: 31 c0 xor %eax,%eax
}
11300e: 5a pop %edx 11300f: 5b pop %ebx 113010: c9 leave 113011: c3 ret
00113014 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
113014: 55 push %ebp 113015: 89 e5 mov %esp,%ebp 113017: 53 push %ebx 113018: 83 ec 04 sub $0x4,%esp 11301b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11301e: 39 05 00 88 12 00 cmp %eax,0x128800
113024: 76 1a jbe 113040 <rtems_io_read+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
113026: 8d 14 40 lea (%eax,%eax,2),%edx 113029: c1 e2 03 shl $0x3,%edx 11302c: 03 15 04 88 12 00 add 0x128804,%edx 113032: 8b 52 0c mov 0xc(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113035: 85 d2 test %edx,%edx
113037: 74 13 je 11304c <rtems_io_read+0x38> }
113039: 59 pop %ecx 11303a: 5b pop %ebx 11303b: 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;
11303c: ff e2 jmp *%edx 11303e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113040: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113045: 5a pop %edx 113046: 5b pop %ebx 113047: c9 leave 113048: c3 ret 113049: 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;
11304c: 31 c0 xor %eax,%eax
}
11304e: 5a pop %edx 11304f: 5b pop %ebx 113050: c9 leave 113051: c3 ret
0010cec0 <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
)
{
10cec0: 55 push %ebp 10cec1: 89 e5 mov %esp,%ebp 10cec3: 57 push %edi 10cec4: 56 push %esi 10cec5: 53 push %ebx 10cec6: 83 ec 0c sub $0xc,%esp 10cec9: 8b 5d 08 mov 0x8(%ebp),%ebx 10cecc: 8b 75 0c mov 0xc(%ebp),%esi 10cecf: 8b 55 10 mov 0x10(%ebp),%edx
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10ced2: a1 00 c5 12 00 mov 0x12c500,%eax
if ( rtems_interrupt_is_in_progress() )
10ced7: 8b 0d 34 c0 12 00 mov 0x12c034,%ecx 10cedd: 85 c9 test %ecx,%ecx
10cedf: 0f 85 ab 00 00 00 jne 10cf90 <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10cee5: 85 d2 test %edx,%edx
10cee7: 0f 84 e7 00 00 00 je 10cfd4 <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10ceed: 89 02 mov %eax,(%edx)
if ( driver_table == NULL )
10ceef: 85 f6 test %esi,%esi
10cef1: 0f 84 dd 00 00 00 je 10cfd4 <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;
10cef7: 8b 3e mov (%esi),%edi 10cef9: 85 ff test %edi,%edi
10cefb: 0f 84 c7 00 00 00 je 10cfc8 <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 )
10cf01: 39 d8 cmp %ebx,%eax
10cf03: 76 7b jbe 10cf80 <rtems_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10cf05: a1 90 ba 12 00 mov 0x12ba90,%eax 10cf0a: 40 inc %eax 10cf0b: a3 90 ba 12 00 mov %eax,0x12ba90
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10cf10: 85 db test %ebx,%ebx
10cf12: 0f 85 88 00 00 00 jne 10cfa0 <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;
10cf18: 8b 0d 00 c5 12 00 mov 0x12c500,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10cf1e: 85 c9 test %ecx,%ecx
10cf20: 0f 84 bb 00 00 00 je 10cfe1 <rtems_io_register_driver+0x121><== NEVER TAKEN
10cf26: 8b 3d 04 c5 12 00 mov 0x12c504,%edi 10cf2c: 89 f8 mov %edi,%eax 10cf2e: eb 08 jmp 10cf38 <rtems_io_register_driver+0x78> 10cf30: 43 inc %ebx 10cf31: 83 c0 18 add $0x18,%eax 10cf34: 39 d9 cmp %ebx,%ecx
10cf36: 76 0b jbe 10cf43 <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;
10cf38: 83 38 00 cmpl $0x0,(%eax)
10cf3b: 75 f3 jne 10cf30 <rtems_io_register_driver+0x70>
10cf3d: 83 78 04 00 cmpl $0x0,0x4(%eax)
10cf41: 75 ed jne 10cf30 <rtems_io_register_driver+0x70>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cf43: 89 1a mov %ebx,(%edx)
if ( m != n )
10cf45: 39 d9 cmp %ebx,%ecx
10cf47: 0f 84 9b 00 00 00 je 10cfe8 <rtems_io_register_driver+0x128>
10cf4d: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cf50: c1 e0 03 shl $0x3,%eax
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10cf53: 01 c7 add %eax,%edi 10cf55: b9 06 00 00 00 mov $0x6,%ecx 10cf5a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10cf5c: e8 6b 1d 00 00 call 10eccc <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10cf61: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10cf68: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10cf6f: 89 5d 08 mov %ebx,0x8(%ebp)
}
10cf72: 83 c4 0c add $0xc,%esp 10cf75: 5b pop %ebx 10cf76: 5e pop %esi 10cf77: 5f pop %edi 10cf78: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10cf79: e9 72 7e 00 00 jmp 114df0 <rtems_io_initialize> 10cf7e: 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;
10cf80: 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 );
}
10cf85: 83 c4 0c add $0xc,%esp 10cf88: 5b pop %ebx 10cf89: 5e pop %esi 10cf8a: 5f pop %edi 10cf8b: c9 leave 10cf8c: c3 ret 10cf8d: 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;
10cf90: 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 );
}
10cf95: 83 c4 0c add $0xc,%esp 10cf98: 5b pop %ebx 10cf99: 5e pop %esi 10cf9a: 5f pop %edi 10cf9b: c9 leave 10cf9c: c3 ret 10cf9d: 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;
10cfa0: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cfa3: c1 e0 03 shl $0x3,%eax 10cfa6: 8b 0d 04 c5 12 00 mov 0x12c504,%ecx 10cfac: 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;
10cfae: 8b 39 mov (%ecx),%edi 10cfb0: 85 ff test %edi,%edi
10cfb2: 74 40 je 10cff4 <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();
10cfb4: e8 13 1d 00 00 call 10eccc <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10cfb9: 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 );
}
10cfbe: 83 c4 0c add $0xc,%esp 10cfc1: 5b pop %ebx 10cfc2: 5e pop %esi 10cfc3: 5f pop %edi 10cfc4: c9 leave 10cfc5: c3 ret 10cfc6: 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;
10cfc8: 8b 4e 04 mov 0x4(%esi),%ecx 10cfcb: 85 c9 test %ecx,%ecx
10cfcd: 0f 85 2e ff ff ff jne 10cf01 <rtems_io_register_driver+0x41>
10cfd3: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10cfd4: 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 );
}
10cfd9: 83 c4 0c add $0xc,%esp 10cfdc: 5b pop %ebx 10cfdd: 5e pop %esi 10cfde: 5f pop %edi 10cfdf: c9 leave 10cfe0: c3 ret
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cfe1: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 10cfe7: 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();
10cfe8: e8 df 1c 00 00 call 10eccc <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10cfed: 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;
10cff2: eb 91 jmp 10cf85 <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;
10cff4: 8b 49 04 mov 0x4(%ecx),%ecx 10cff7: 85 c9 test %ecx,%ecx
10cff9: 75 b9 jne 10cfb4 <rtems_io_register_driver+0xf4>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10cffb: 89 1a mov %ebx,(%edx) 10cffd: 8b 3d 04 c5 12 00 mov 0x12c504,%edi 10d003: e9 4b ff ff ff jmp 10cf53 <rtems_io_register_driver+0x93>
0010d008 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10d008: 55 push %ebp 10d009: 89 e5 mov %esp,%ebp 10d00b: 57 push %edi 10d00c: 83 ec 04 sub $0x4,%esp 10d00f: 8b 45 08 mov 0x8(%ebp),%eax
if ( rtems_interrupt_is_in_progress() )
10d012: 8b 0d 34 c0 12 00 mov 0x12c034,%ecx 10d018: 85 c9 test %ecx,%ecx
10d01a: 75 44 jne 10d060 <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10d01c: 39 05 00 c5 12 00 cmp %eax,0x12c500
10d022: 77 0c ja 10d030 <rtems_io_unregister_driver+0x28>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
10d024: b8 0d 00 00 00 mov $0xd,%eax
}
10d029: 5a pop %edx 10d02a: 5f pop %edi 10d02b: c9 leave 10d02c: c3 ret 10d02d: 8d 76 00 lea 0x0(%esi),%esi 10d030: 8b 15 90 ba 12 00 mov 0x12ba90,%edx 10d036: 42 inc %edx 10d037: 89 15 90 ba 12 00 mov %edx,0x12ba90
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
&_IO_Driver_address_table[major],
10d03d: 8d 14 40 lea (%eax,%eax,2),%edx 10d040: 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(
10d043: 03 15 04 c5 12 00 add 0x12c504,%edx 10d049: b9 18 00 00 00 mov $0x18,%ecx 10d04e: 31 c0 xor %eax,%eax 10d050: 89 d7 mov %edx,%edi 10d052: f3 aa rep stos %al,%es:(%edi)
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
10d054: e8 73 1c 00 00 call 10eccc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d059: 31 c0 xor %eax,%eax
}
return RTEMS_UNSATISFIED;
}
10d05b: 5a pop %edx 10d05c: 5f pop %edi 10d05d: c9 leave 10d05e: c3 ret 10d05f: 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;
10d060: b8 12 00 00 00 mov $0x12,%eax
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10d065: 5a pop %edx 10d066: 5f pop %edi 10d067: c9 leave 10d068: c3 ret
00113054 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
113054: 55 push %ebp 113055: 89 e5 mov %esp,%ebp 113057: 53 push %ebx 113058: 83 ec 04 sub $0x4,%esp 11305b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11305e: 39 05 00 88 12 00 cmp %eax,0x128800
113064: 76 1a jbe 113080 <rtems_io_write+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
113066: 8d 14 40 lea (%eax,%eax,2),%edx 113069: c1 e2 03 shl $0x3,%edx 11306c: 03 15 04 88 12 00 add 0x128804,%edx 113072: 8b 52 10 mov 0x10(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113075: 85 d2 test %edx,%edx
113077: 74 13 je 11308c <rtems_io_write+0x38> }
113079: 59 pop %ecx 11307a: 5b pop %ebx 11307b: 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;
11307c: ff e2 jmp *%edx 11307e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113080: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113085: 5a pop %edx 113086: 5b pop %ebx 113087: c9 leave 113088: c3 ret 113089: 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;
11308c: 31 c0 xor %eax,%eax
}
11308e: 5a pop %edx 11308f: 5b pop %ebx 113090: c9 leave 113091: c3 ret
0010dfb8 <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)
{
10dfb8: 55 push %ebp 10dfb9: 89 e5 mov %esp,%ebp 10dfbb: 57 push %edi 10dfbc: 56 push %esi 10dfbd: 53 push %ebx 10dfbe: 83 ec 1c sub $0x1c,%esp 10dfc1: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10dfc4: 85 ff test %edi,%edi
10dfc6: 74 49 je 10e011 <rtems_iterate_over_all_threads+0x59><== NEVER TAKEN
10dfc8: 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 ];
10dfcf: 8b 55 e4 mov -0x1c(%ebp),%edx 10dfd2: 8b 04 95 e8 a9 12 00 mov 0x12a9e8(,%edx,4),%eax 10dfd9: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10dfdc: 85 f6 test %esi,%esi
10dfde: 74 28 je 10e008 <rtems_iterate_over_all_threads+0x50>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10dfe0: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10dfe5: 74 21 je 10e008 <rtems_iterate_over_all_threads+0x50>
10dfe7: bb 01 00 00 00 mov $0x1,%ebx
the_thread = (Thread_Control *)information->local_table[ i ];
10dfec: 8b 46 1c mov 0x1c(%esi),%eax 10dfef: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10dff2: 85 c0 test %eax,%eax
10dff4: 74 09 je 10dfff <rtems_iterate_over_all_threads+0x47><== NEVER TAKEN
continue;
(*routine)(the_thread);
10dff6: 83 ec 0c sub $0xc,%esp 10dff9: 50 push %eax 10dffa: ff d7 call *%edi 10dffc: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10dfff: 43 inc %ebx 10e000: 0f b7 46 10 movzwl 0x10(%esi),%eax 10e004: 39 d8 cmp %ebx,%eax
10e006: 73 e4 jae 10dfec <rtems_iterate_over_all_threads+0x34>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10e008: ff 45 e4 incl -0x1c(%ebp) 10e00b: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp)
10e00f: 75 be jne 10dfcf <rtems_iterate_over_all_threads+0x17>
(*routine)(the_thread);
}
}
}
10e011: 8d 65 f4 lea -0xc(%ebp),%esp 10e014: 5b pop %ebx 10e015: 5e pop %esi 10e016: 5f pop %edi 10e017: c9 leave 10e018: c3 ret
001163bc <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
1163bc: 55 push %ebp 1163bd: 89 e5 mov %esp,%ebp 1163bf: 57 push %edi 1163c0: 56 push %esi 1163c1: 53 push %ebx 1163c2: 83 ec 1c sub $0x1c,%esp 1163c5: 8b 7d 08 mov 0x8(%ebp),%edi 1163c8: 8b 5d 0c mov 0xc(%ebp),%ebx 1163cb: 8b 75 14 mov 0x14(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
1163ce: 85 db test %ebx,%ebx
1163d0: 74 62 je 116434 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
1163d2: 85 f6 test %esi,%esi
1163d4: 74 5e je 116434 <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1163d6: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1163d7: 8d 45 e4 lea -0x1c(%ebp),%eax 1163da: 50 push %eax 1163db: 57 push %edi 1163dc: 68 20 34 14 00 push $0x143420 1163e1: e8 f6 4e 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1163e6: 83 c4 10 add $0x10,%esp 1163e9: 8b 55 e4 mov -0x1c(%ebp),%edx 1163ec: 85 d2 test %edx,%edx
1163ee: 74 10 je 116400 <rtems_message_queue_broadcast+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163f0: b8 04 00 00 00 mov $0x4,%eax
}
1163f5: 8d 65 f4 lea -0xc(%ebp),%esp 1163f8: 5b pop %ebx 1163f9: 5e pop %esi 1163fa: 5f pop %edi 1163fb: c9 leave 1163fc: c3 ret 1163fd: 8d 76 00 lea 0x0(%esi),%esi
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
116400: 83 ec 08 sub $0x8,%esp 116403: 56 push %esi 116404: 6a 00 push $0x0 116406: 57 push %edi 116407: ff 75 10 pushl 0x10(%ebp) 11640a: 53 push %ebx 11640b: 83 c0 14 add $0x14,%eax 11640e: 50 push %eax 11640f: e8 c8 34 00 00 call 1198dc <_CORE_message_queue_Broadcast> 116414: 89 c3 mov %eax,%ebx
NULL,
#endif
count
);
_Thread_Enable_dispatch();
116416: 83 c4 20 add $0x20,%esp 116419: e8 36 5a 00 00 call 11be54 <_Thread_Enable_dispatch>
return
11641e: 83 ec 0c sub $0xc,%esp 116421: 53 push %ebx 116422: e8 69 03 00 00 call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116427: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11642a: 8d 65 f4 lea -0xc(%ebp),%esp 11642d: 5b pop %ebx 11642e: 5e pop %esi 11642f: 5f pop %edi 116430: c9 leave 116431: c3 ret 116432: 66 90 xchg %ax,%ax
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116434: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116439: 8d 65 f4 lea -0xc(%ebp),%esp 11643c: 5b pop %ebx 11643d: 5e pop %esi 11643e: 5f pop %edi 11643f: c9 leave 116440: c3 ret
00113858 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
113858: 55 push %ebp 113859: 89 e5 mov %esp,%ebp 11385b: 57 push %edi 11385c: 56 push %esi 11385d: 53 push %ebx 11385e: 83 ec 2c sub $0x2c,%esp 113861: 8b 5d 08 mov 0x8(%ebp),%ebx 113864: 8b 75 0c mov 0xc(%ebp),%esi 113867: 8b 4d 10 mov 0x10(%ebp),%ecx 11386a: 8b 7d 18 mov 0x18(%ebp),%edi
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
11386d: 85 db test %ebx,%ebx
11386f: 74 2f je 1138a0 <rtems_message_queue_create+0x48>
return RTEMS_INVALID_NAME;
if ( !id )
113871: 85 ff test %edi,%edi
113873: 0f 84 a3 00 00 00 je 11391c <rtems_message_queue_create+0xc4>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
113879: 85 f6 test %esi,%esi
11387b: 74 13 je 113890 <rtems_message_queue_create+0x38>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
11387d: 85 c9 test %ecx,%ecx
11387f: 75 2f jne 1138b0 <rtems_message_queue_create+0x58>
return RTEMS_INVALID_SIZE;
113881: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113886: 8d 65 f4 lea -0xc(%ebp),%esp 113889: 5b pop %ebx 11388a: 5e pop %esi 11388b: 5f pop %edi 11388c: c9 leave 11388d: c3 ret 11388e: 66 90 xchg %ax,%ax
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
113890: b8 0a 00 00 00 mov $0xa,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113895: 8d 65 f4 lea -0xc(%ebp),%esp 113898: 5b pop %ebx 113899: 5e pop %esi 11389a: 5f pop %edi 11389b: c9 leave 11389c: c3 ret 11389d: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1138a0: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1138a5: 8d 65 f4 lea -0xc(%ebp),%esp 1138a8: 5b pop %ebx 1138a9: 5e pop %esi 1138aa: 5f pop %edi 1138ab: c9 leave 1138ac: c3 ret 1138ad: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1138b0: a1 30 07 13 00 mov 0x130730,%eax 1138b5: 40 inc %eax 1138b6: a3 30 07 13 00 mov %eax,0x130730
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp) 1138be: e8 09 60 00 00 call 1198cc <_Message_queue_Allocate> 1138c3: 89 c2 mov %eax,%edx
if ( !the_message_queue ) {
1138c5: 85 c0 test %eax,%eax 1138c7: 8b 4d d4 mov -0x2c(%ebp),%ecx
1138ca: 74 7c je 113948 <rtems_message_queue_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
1138cc: 8b 45 14 mov 0x14(%ebp),%eax 1138cf: 89 42 10 mov %eax,0x10(%edx)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
1138d2: a8 04 test $0x4,%al 1138d4: 0f 95 c0 setne %al 1138d7: 0f b6 c0 movzbl %al,%eax 1138da: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
1138dd: 51 push %ecx 1138de: 56 push %esi 1138df: 8d 45 e4 lea -0x1c(%ebp),%eax 1138e2: 50 push %eax 1138e3: 8d 42 14 lea 0x14(%edx),%eax 1138e6: 50 push %eax 1138e7: 89 55 d4 mov %edx,-0x2c(%ebp) 1138ea: e8 2d 11 00 00 call 114a1c <_CORE_message_queue_Initialize> 1138ef: 83 c4 10 add $0x10,%esp 1138f2: 84 c0 test %al,%al 1138f4: 8b 55 d4 mov -0x2c(%ebp),%edx
1138f7: 75 2f jne 113928 <rtems_message_queue_create+0xd0>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
1138f9: 83 ec 08 sub $0x8,%esp 1138fc: 52 push %edx 1138fd: 68 20 11 13 00 push $0x131120 113902: e8 b1 1f 00 00 call 1158b8 <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
113907: e8 e4 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
11390c: 83 c4 10 add $0x10,%esp 11390f: b8 0d 00 00 00 mov $0xd,%eax 113914: e9 6d ff ff ff jmp 113886 <rtems_message_queue_create+0x2e> 113919: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
11391c: b8 09 00 00 00 mov $0x9,%eax 113921: e9 60 ff ff ff jmp 113886 <rtems_message_queue_create+0x2e> 113926: 66 90 xchg %ax,%ax
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
113928: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
11392b: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11392e: 8b 0d 3c 11 13 00 mov 0x13113c,%ecx 113934: 89 14 b1 mov %edx,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
113937: 89 5a 0c mov %ebx,0xc(%edx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
11393a: 89 07 mov %eax,(%edi)
name,
0
);
#endif
_Thread_Enable_dispatch();
11393c: e8 af 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
113941: 31 c0 xor %eax,%eax 113943: e9 3e ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
113948: e8 a3 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
11394d: b8 05 00 00 00 mov $0x5,%eax 113952: e9 2f ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
00116544 <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
116544: 55 push %ebp 116545: 89 e5 mov %esp,%ebp 116547: 53 push %ebx 116548: 83 ec 18 sub $0x18,%esp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
11654b: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
11654e: 50 push %eax 11654f: ff 75 08 pushl 0x8(%ebp) 116552: 68 20 34 14 00 push $0x143420 116557: e8 80 4d 00 00 call 11b2dc <_Objects_Get> 11655c: 89 c3 mov %eax,%ebx
switch ( location ) {
11655e: 83 c4 10 add $0x10,%esp 116561: 8b 4d f4 mov -0xc(%ebp),%ecx 116564: 85 c9 test %ecx,%ecx
116566: 75 3c jne 1165a4 <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
116568: 83 ec 08 sub $0x8,%esp 11656b: 50 push %eax 11656c: 68 20 34 14 00 push $0x143420 116571: e8 f2 48 00 00 call 11ae68 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
116576: 83 c4 0c add $0xc,%esp 116579: 6a 05 push $0x5 11657b: 6a 00 push $0x0 11657d: 8d 43 14 lea 0x14(%ebx),%eax 116580: 50 push %eax 116581: e8 da 33 00 00 call 119960 <_CORE_message_queue_Close>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
116586: 58 pop %eax 116587: 5a pop %edx 116588: 53 push %ebx 116589: 68 20 34 14 00 push $0x143420 11658e: e8 cd 4b 00 00 call 11b160 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
116593: e8 bc 58 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116598: 83 c4 10 add $0x10,%esp 11659b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11659d: 8b 5d fc mov -0x4(%ebp),%ebx 1165a0: c9 leave 1165a1: c3 ret 1165a2: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1165a4: b8 04 00 00 00 mov $0x4,%eax
}
1165a9: 8b 5d fc mov -0x4(%ebp),%ebx 1165ac: c9 leave 1165ad: c3 ret
001165b0 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
rtems_id id,
uint32_t *count
)
{
1165b0: 55 push %ebp 1165b1: 89 e5 mov %esp,%ebp 1165b3: 53 push %ebx 1165b4: 83 ec 14 sub $0x14,%esp 1165b7: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
1165ba: 85 db test %ebx,%ebx
1165bc: 74 46 je 116604 <rtems_message_queue_flush+0x54>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1165be: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1165bf: 8d 45 f4 lea -0xc(%ebp),%eax 1165c2: 50 push %eax 1165c3: ff 75 08 pushl 0x8(%ebp) 1165c6: 68 20 34 14 00 push $0x143420 1165cb: e8 0c 4d 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1165d0: 83 c4 10 add $0x10,%esp 1165d3: 8b 55 f4 mov -0xc(%ebp),%edx 1165d6: 85 d2 test %edx,%edx
1165d8: 74 0a je 1165e4 <rtems_message_queue_flush+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1165da: b8 04 00 00 00 mov $0x4,%eax
}
1165df: 8b 5d fc mov -0x4(%ebp),%ebx 1165e2: c9 leave 1165e3: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
1165e4: 83 ec 0c sub $0xc,%esp 1165e7: 83 c0 14 add $0x14,%eax 1165ea: 50 push %eax 1165eb: e8 ac 33 00 00 call 11999c <_CORE_message_queue_Flush> 1165f0: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
1165f2: e8 5d 58 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1165f7: 83 c4 10 add $0x10,%esp 1165fa: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1165fc: 8b 5d fc mov -0x4(%ebp),%ebx 1165ff: c9 leave 116600: c3 ret 116601: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116604: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116609: 8b 5d fc mov -0x4(%ebp),%ebx 11660c: c9 leave 11660d: c3 ret
00116610 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
116610: 55 push %ebp 116611: 89 e5 mov %esp,%ebp 116613: 53 push %ebx 116614: 83 ec 14 sub $0x14,%esp 116617: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
11661a: 85 db test %ebx,%ebx
11661c: 74 3a je 116658 <rtems_message_queue_get_number_pending+0x48>
11661e: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
11661f: 8d 45 f4 lea -0xc(%ebp),%eax 116622: 50 push %eax 116623: ff 75 08 pushl 0x8(%ebp) 116626: 68 20 34 14 00 push $0x143420 11662b: e8 ac 4c 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
116630: 83 c4 10 add $0x10,%esp 116633: 8b 55 f4 mov -0xc(%ebp),%edx 116636: 85 d2 test %edx,%edx
116638: 74 0a je 116644 <rtems_message_queue_get_number_pending+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11663a: b8 04 00 00 00 mov $0x4,%eax
}
11663f: 8b 5d fc mov -0x4(%ebp),%ebx 116642: c9 leave 116643: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
116644: 8b 40 5c mov 0x5c(%eax),%eax 116647: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
116649: e8 06 58 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11664e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116650: 8b 5d fc mov -0x4(%ebp),%ebx 116653: c9 leave 116654: c3 ret 116655: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116658: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11665d: 8b 5d fc mov -0x4(%ebp),%ebx 116660: c9 leave 116661: c3 ret
0011397c <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
11397c: 55 push %ebp 11397d: 89 e5 mov %esp,%ebp 11397f: 56 push %esi 113980: 53 push %ebx 113981: 83 ec 10 sub $0x10,%esp 113984: 8b 5d 0c mov 0xc(%ebp),%ebx 113987: 8b 75 10 mov 0x10(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
11398a: 85 db test %ebx,%ebx
11398c: 74 6e je 1139fc <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
11398e: 85 f6 test %esi,%esi
113990: 74 6a je 1139fc <rtems_message_queue_receive+0x80>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
113992: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
113993: 8d 45 f4 lea -0xc(%ebp),%eax 113996: 50 push %eax 113997: ff 75 08 pushl 0x8(%ebp) 11399a: 68 20 11 13 00 push $0x131120 11399f: e8 54 20 00 00 call 1159f8 <_Objects_Get>
switch ( location ) {
1139a4: 83 c4 10 add $0x10,%esp 1139a7: 8b 55 f4 mov -0xc(%ebp),%edx 1139aa: 85 d2 test %edx,%edx
1139ac: 75 42 jne 1139f0 <rtems_message_queue_receive+0x74>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
1139ae: 83 ec 08 sub $0x8,%esp 1139b1: ff 75 18 pushl 0x18(%ebp)
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
1139b4: 8b 55 14 mov 0x14(%ebp),%edx 1139b7: 83 e2 01 and $0x1,%edx 1139ba: 83 f2 01 xor $0x1,%edx 1139bd: 52 push %edx 1139be: 56 push %esi 1139bf: 53 push %ebx 1139c0: ff 70 08 pushl 0x8(%eax) 1139c3: 83 c0 14 add $0x14,%eax 1139c6: 50 push %eax 1139c7: e8 00 11 00 00 call 114acc <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
1139cc: 83 c4 20 add $0x20,%esp 1139cf: e8 1c 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
1139d4: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code
1139d7: a1 d8 0c 13 00 mov 0x130cd8,%eax
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
1139dc: ff 70 34 pushl 0x34(%eax) 1139df: e8 a0 00 00 00 call 113a84 <_Message_queue_Translate_core_message_queue_return_code> 1139e4: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1139e7: 8d 65 f8 lea -0x8(%ebp),%esp 1139ea: 5b pop %ebx 1139eb: 5e pop %esi 1139ec: c9 leave 1139ed: c3 ret 1139ee: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1139f0: b8 04 00 00 00 mov $0x4,%eax
}
1139f5: 8d 65 f8 lea -0x8(%ebp),%esp 1139f8: 5b pop %ebx 1139f9: 5e pop %esi 1139fa: c9 leave 1139fb: c3 ret
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
1139fc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113a01: 8d 65 f8 lea -0x8(%ebp),%esp 113a04: 5b pop %ebx 113a05: 5e pop %esi 113a06: c9 leave 113a07: c3 ret
0010b3a8 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
rtems_id id,
const void *buffer,
size_t size
)
{
10b3a8: 55 push %ebp 10b3a9: 89 e5 mov %esp,%ebp 10b3ab: 56 push %esi 10b3ac: 53 push %ebx 10b3ad: 83 ec 10 sub $0x10,%esp 10b3b0: 8b 75 08 mov 0x8(%ebp),%esi 10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
10b3b6: 85 db test %ebx,%ebx
10b3b8: 74 5e je 10b418 <rtems_message_queue_send+0x70>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
10b3ba: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: 56 push %esi 10b3c0: 68 80 87 12 00 push $0x128780 10b3c5: e8 6e 1a 00 00 call 10ce38 <_Objects_Get>
switch ( location ) {
10b3ca: 83 c4 10 add $0x10,%esp 10b3cd: 8b 55 f4 mov -0xc(%ebp),%edx 10b3d0: 85 d2 test %edx,%edx
10b3d2: 74 0c je 10b3e0 <rtems_message_queue_send+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b3d4: b8 04 00 00 00 mov $0x4,%eax
}
10b3d9: 8d 65 f8 lea -0x8(%ebp),%esp 10b3dc: 5b pop %ebx 10b3dd: 5e pop %esi 10b3de: c9 leave 10b3df: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
10b3e0: 6a 00 push $0x0 10b3e2: 6a 00 push $0x0 10b3e4: 68 ff ff ff 7f push $0x7fffffff 10b3e9: 6a 00 push $0x0 10b3eb: 56 push %esi 10b3ec: ff 75 10 pushl 0x10(%ebp) 10b3ef: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Send(
10b3f0: 83 c0 14 add $0x14,%eax 10b3f3: 50 push %eax 10b3f4: e8 3f 0c 00 00 call 10c038 <_CORE_message_queue_Submit> 10b3f9: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
10b3fb: 83 c4 20 add $0x20,%esp 10b3fe: e8 ad 25 00 00 call 10d9b0 <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
10b403: 83 ec 0c sub $0xc,%esp 10b406: 53 push %ebx 10b407: e8 18 00 00 00 call 10b424 <_Message_queue_Translate_core_message_queue_return_code> 10b40c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b40f: 8d 65 f8 lea -0x8(%ebp),%esp 10b412: 5b pop %ebx 10b413: 5e pop %esi 10b414: c9 leave 10b415: c3 ret 10b416: 66 90 xchg %ax,%ax
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
10b418: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b41d: 8d 65 f8 lea -0x8(%ebp),%esp 10b420: 5b pop %ebx 10b421: 5e pop %esi 10b422: c9 leave 10b423: c3 ret
001167a0 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
rtems_id id,
const void *buffer,
size_t size
)
{
1167a0: 55 push %ebp 1167a1: 89 e5 mov %esp,%ebp 1167a3: 56 push %esi 1167a4: 53 push %ebx 1167a5: 83 ec 10 sub $0x10,%esp 1167a8: 8b 75 08 mov 0x8(%ebp),%esi 1167ab: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
1167ae: 85 db test %ebx,%ebx
1167b0: 74 5e je 116810 <rtems_message_queue_urgent+0x70>
1167b2: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1167b3: 8d 45 f4 lea -0xc(%ebp),%eax 1167b6: 50 push %eax 1167b7: 56 push %esi 1167b8: 68 20 34 14 00 push $0x143420 1167bd: e8 1a 4b 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1167c2: 83 c4 10 add $0x10,%esp 1167c5: 8b 55 f4 mov -0xc(%ebp),%edx 1167c8: 85 d2 test %edx,%edx
1167ca: 74 0c je 1167d8 <rtems_message_queue_urgent+0x38>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1167cc: b8 04 00 00 00 mov $0x4,%eax
}
1167d1: 8d 65 f8 lea -0x8(%ebp),%esp 1167d4: 5b pop %ebx 1167d5: 5e pop %esi 1167d6: c9 leave 1167d7: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
1167d8: 6a 00 push $0x0 1167da: 6a 00 push $0x0 1167dc: 68 00 00 00 80 push $0x80000000 1167e1: 6a 00 push $0x0 1167e3: 56 push %esi 1167e4: ff 75 10 pushl 0x10(%ebp) 1167e7: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Urgent(
1167e8: 83 c0 14 add $0x14,%eax 1167eb: 50 push %eax 1167ec: e8 eb 33 00 00 call 119bdc <_CORE_message_queue_Submit> 1167f1: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
1167f3: 83 c4 20 add $0x20,%esp 1167f6: e8 59 56 00 00 call 11be54 <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
1167fb: 83 ec 0c sub $0xc,%esp 1167fe: 53 push %ebx 1167ff: e8 8c ff ff ff call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116804: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116807: 8d 65 f8 lea -0x8(%ebp),%esp 11680a: 5b pop %ebx 11680b: 5e pop %esi 11680c: c9 leave 11680d: c3 ret 11680e: 66 90 xchg %ax,%ax
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
116810: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116815: 8d 65 f8 lea -0x8(%ebp),%esp 116818: 5b pop %ebx 116819: 5e pop %esi 11681a: c9 leave 11681b: c3 ret
0010b978 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
10b978: 55 push %ebp 10b979: 89 e5 mov %esp,%ebp 10b97b: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
10b97e: ff 75 08 pushl 0x8(%ebp) 10b981: 68 40 7c 12 00 push $0x127c40 10b986: e8 d9 49 00 00 call 110364 <rtems_assoc_ptr_by_local>
if ( api_assoc )
10b98b: 83 c4 10 add $0x10,%esp 10b98e: 85 c0 test %eax,%eax
10b990: 74 06 je 10b998 <rtems_object_get_api_name+0x20>
return api_assoc->name;
10b992: 8b 00 mov (%eax),%eax
return "BAD CLASS"; }
10b994: c9 leave 10b995: c3 ret 10b996: 66 90 xchg %ax,%ax
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
if ( api_assoc )
return api_assoc->name;
return "BAD CLASS";
10b998: b8 63 2c 12 00 mov $0x122c63,%eax
}
10b99d: c9 leave 10b99e: c3 ret
0010cf60 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
10cf60: 55 push %ebp 10cf61: 89 e5 mov %esp,%ebp 10cf63: 57 push %edi 10cf64: 56 push %esi 10cf65: 53 push %ebx 10cf66: 83 ec 0c sub $0xc,%esp 10cf69: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10cf6c: 85 db test %ebx,%ebx
10cf6e: 74 60 je 10cfd0 <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10cf70: 83 ec 08 sub $0x8,%esp 10cf73: 0f b7 45 0c movzwl 0xc(%ebp),%eax 10cf77: 50 push %eax 10cf78: ff 75 08 pushl 0x8(%ebp) 10cf7b: e8 4c 1b 00 00 call 10eacc <_Objects_Get_information>
if ( !obj_info )
10cf80: 83 c4 10 add $0x10,%esp 10cf83: 85 c0 test %eax,%eax
10cf85: 74 59 je 10cfe0 <rtems_object_get_class_information+0x80>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
10cf87: 8b 50 08 mov 0x8(%eax),%edx 10cf8a: 89 13 mov %edx,(%ebx)
info->maximum_id = obj_info->maximum_id;
10cf8c: 8b 50 0c mov 0xc(%eax),%edx 10cf8f: 89 53 04 mov %edx,0x4(%ebx)
info->auto_extend = obj_info->auto_extend;
10cf92: 8a 50 12 mov 0x12(%eax),%dl 10cf95: 88 53 0c mov %dl,0xc(%ebx)
info->maximum = obj_info->maximum;
10cf98: 0f b7 70 10 movzwl 0x10(%eax),%esi 10cf9c: 89 73 08 mov %esi,0x8(%ebx)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cf9f: 85 f6 test %esi,%esi
10cfa1: 74 44 je 10cfe7 <rtems_object_get_class_information+0x87><== NEVER TAKEN
10cfa3: 8b 78 1c mov 0x1c(%eax),%edi 10cfa6: b9 01 00 00 00 mov $0x1,%ecx 10cfab: b8 01 00 00 00 mov $0x1,%eax 10cfb0: 31 d2 xor %edx,%edx 10cfb2: 66 90 xchg %ax,%ax
if ( !obj_info->local_table[i] )
unallocated++;
10cfb4: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4) 10cfb8: 83 d2 00 adc $0x0,%edx
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cfbb: 40 inc %eax 10cfbc: 89 c1 mov %eax,%ecx 10cfbe: 39 c6 cmp %eax,%esi
10cfc0: 73 f2 jae 10cfb4 <rtems_object_get_class_information+0x54>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10cfc2: 89 53 10 mov %edx,0x10(%ebx)
return RTEMS_SUCCESSFUL;
10cfc5: 31 c0 xor %eax,%eax
}
10cfc7: 8d 65 f4 lea -0xc(%ebp),%esp 10cfca: 5b pop %ebx 10cfcb: 5e pop %esi 10cfcc: 5f pop %edi 10cfcd: c9 leave 10cfce: c3 ret 10cfcf: 90 nop
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
10cfd0: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10cfd5: 8d 65 f4 lea -0xc(%ebp),%esp 10cfd8: 5b pop %ebx 10cfd9: 5e pop %esi 10cfda: 5f pop %edi 10cfdb: c9 leave 10cfdc: c3 ret 10cfdd: 8d 76 00 lea 0x0(%esi),%esi
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
10cfe0: b8 0a 00 00 00 mov $0xa,%eax 10cfe5: eb e0 jmp 10cfc7 <rtems_object_get_class_information+0x67>
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cfe7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cfe9: eb d7 jmp 10cfc2 <rtems_object_get_class_information+0x62><== NOT EXECUTED
0010c520 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
10c520: 55 push %ebp 10c521: 89 e5 mov %esp,%ebp 10c523: 53 push %ebx 10c524: 83 ec 14 sub $0x14,%esp 10c527: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10c52a: 85 db test %ebx,%ebx
10c52c: 74 26 je 10c554 <rtems_object_get_classic_name+0x34>
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
10c52e: 83 ec 08 sub $0x8,%esp 10c531: 8d 45 f4 lea -0xc(%ebp),%eax 10c534: 50 push %eax 10c535: ff 75 08 pushl 0x8(%ebp) 10c538: e8 a7 1b 00 00 call 10e0e4 <_Objects_Id_to_name>
*name = name_u.name_u32;
10c53d: 8b 55 f4 mov -0xc(%ebp),%edx 10c540: 89 13 mov %edx,(%ebx)
return _Status_Object_name_errors_to_status[ status ];
10c542: 8b 04 85 4c 38 12 00 mov 0x12384c(,%eax,4),%eax 10c549: 83 c4 10 add $0x10,%esp
}
10c54c: 8b 5d fc mov -0x4(%ebp),%ebx 10c54f: c9 leave 10c550: c3 ret 10c551: 8d 76 00 lea 0x0(%esi),%esi
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10c554: b8 09 00 00 00 mov $0x9,%eax
status = _Objects_Id_to_name( id, &name_u );
*name = name_u.name_u32;
return _Status_Object_name_errors_to_status[ status ];
}
10c559: 8b 5d fc mov -0x4(%ebp),%ebx 10c55c: c9 leave 10c55d: c3 ret
0010b9ac <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 57 push %edi 10b9b0: 56 push %esi 10b9b1: 53 push %ebx 10b9b2: 83 ec 1c sub $0x1c,%esp 10b9b5: 8b 75 08 mov 0x8(%ebp),%esi 10b9b8: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10b9bb: 85 ff test %edi,%edi
10b9bd: 74 61 je 10ba20 <rtems_object_set_name+0x74>
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b9bf: 85 f6 test %esi,%esi
10b9c1: 74 35 je 10b9f8 <rtems_object_set_name+0x4c>
information = _Objects_Get_information_id( tmpId );
10b9c3: 83 ec 0c sub $0xc,%esp 10b9c6: 56 push %esi 10b9c7: e8 24 19 00 00 call 10d2f0 <_Objects_Get_information_id> 10b9cc: 89 c3 mov %eax,%ebx
if ( !information )
10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 85 c0 test %eax,%eax
10b9d3: 74 16 je 10b9eb <rtems_object_set_name+0x3f>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10b9d5: 50 push %eax 10b9d6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b9d9: 50 push %eax 10b9da: 56 push %esi 10b9db: 53 push %ebx 10b9dc: e8 c7 1a 00 00 call 10d4a8 <_Objects_Get>
switch ( location ) {
10b9e1: 83 c4 10 add $0x10,%esp 10b9e4: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b9e7: 85 c9 test %ecx,%ecx
10b9e9: 74 19 je 10ba04 <rtems_object_set_name+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b9eb: b8 04 00 00 00 mov $0x4,%eax
}
10b9f0: 8d 65 f4 lea -0xc(%ebp),%esp 10b9f3: 5b pop %ebx 10b9f4: 5e pop %esi 10b9f5: 5f pop %edi 10b9f6: c9 leave 10b9f7: c3 ret
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b9f8: a1 f8 a5 12 00 mov 0x12a5f8,%eax 10b9fd: 8b 70 08 mov 0x8(%eax),%esi 10ba00: eb c1 jmp 10b9c3 <rtems_object_set_name+0x17> 10ba02: 66 90 xchg %ax,%ax
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10ba04: 52 push %edx 10ba05: 57 push %edi 10ba06: 50 push %eax 10ba07: 53 push %ebx 10ba08: e8 83 1c 00 00 call 10d690 <_Objects_Set_name>
_Thread_Enable_dispatch();
10ba0d: e8 ea 26 00 00 call 10e0fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ba12: 83 c4 10 add $0x10,%esp 10ba15: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ba17: 8d 65 f4 lea -0xc(%ebp),%esp 10ba1a: 5b pop %ebx 10ba1b: 5e pop %esi 10ba1c: 5f pop %edi 10ba1d: c9 leave 10ba1e: c3 ret 10ba1f: 90 nop
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10ba20: b8 09 00 00 00 mov $0x9,%eax 10ba25: eb c9 jmp 10b9f0 <rtems_object_set_name+0x44>
0011681c <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11681c: 55 push %ebp 11681d: 89 e5 mov %esp,%ebp 11681f: 57 push %edi 116820: 56 push %esi 116821: 53 push %ebx 116822: 83 ec 1c sub $0x1c,%esp 116825: 8b 5d 08 mov 0x8(%ebp),%ebx 116828: 8b 75 0c mov 0xc(%ebp),%esi 11682b: 8b 55 10 mov 0x10(%ebp),%edx 11682e: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
116831: 85 db test %ebx,%ebx
116833: 74 47 je 11687c <rtems_partition_create+0x60>
return RTEMS_INVALID_NAME;
if ( !starting_address )
116835: 85 f6 test %esi,%esi
116837: 74 23 je 11685c <rtems_partition_create+0x40>
return RTEMS_INVALID_ADDRESS;
if ( !id )
116839: 8b 45 1c mov 0x1c(%ebp),%eax 11683c: 85 c0 test %eax,%eax
11683e: 74 1c je 11685c <rtems_partition_create+0x40><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
116840: 85 d2 test %edx,%edx
116842: 74 28 je 11686c <rtems_partition_create+0x50>
116844: 85 ff test %edi,%edi
116846: 74 24 je 11686c <rtems_partition_create+0x50>
116848: 39 fa cmp %edi,%edx
11684a: 72 20 jb 11686c <rtems_partition_create+0x50>
11684c: f7 c7 03 00 00 00 test $0x3,%edi
116852: 75 18 jne 11686c <rtems_partition_create+0x50>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
116854: f7 c6 03 00 00 00 test $0x3,%esi
11685a: 74 30 je 11688c <rtems_partition_create+0x70>
return RTEMS_INVALID_ADDRESS;
11685c: b8 09 00 00 00 mov $0x9,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116861: 8d 65 f4 lea -0xc(%ebp),%esp 116864: 5b pop %ebx 116865: 5e pop %esi 116866: 5f pop %edi 116867: c9 leave 116868: c3 ret 116869: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
11686c: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116871: 8d 65 f4 lea -0xc(%ebp),%esp 116874: 5b pop %ebx 116875: 5e pop %esi 116876: 5f pop %edi 116877: c9 leave 116878: c3 ret 116879: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
11687c: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116881: 8d 65 f4 lea -0xc(%ebp),%esp 116884: 5b pop %ebx 116885: 5e pop %esi 116886: 5f pop %edi 116887: c9 leave 116888: c3 ret 116889: 8d 76 00 lea 0x0(%esi),%esi 11688c: a1 30 2a 14 00 mov 0x142a30,%eax 116891: 40 inc %eax 116892: a3 30 2a 14 00 mov %eax,0x142a30
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
116897: 83 ec 0c sub $0xc,%esp 11689a: 68 c0 28 14 00 push $0x1428c0 11689f: 89 55 e0 mov %edx,-0x20(%ebp) 1168a2: e8 45 45 00 00 call 11adec <_Objects_Allocate> 1168a7: 89 45 e4 mov %eax,-0x1c(%ebp)
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
1168aa: 83 c4 10 add $0x10,%esp 1168ad: 85 c0 test %eax,%eax 1168af: 8b 55 e0 mov -0x20(%ebp),%edx
1168b2: 74 58 je 11690c <rtems_partition_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
1168b4: 8b 45 e4 mov -0x1c(%ebp),%eax 1168b7: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
1168ba: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
1168bd: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
1168c0: 8b 4d 18 mov 0x18(%ebp),%ecx 1168c3: 89 48 1c mov %ecx,0x1c(%eax)
the_partition->number_of_used_blocks = 0;
1168c6: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
_Chain_Initialize( &the_partition->Memory, starting_address,
1168cd: 57 push %edi 1168ce: 89 d0 mov %edx,%eax 1168d0: 31 d2 xor %edx,%edx 1168d2: f7 f7 div %edi 1168d4: 50 push %eax 1168d5: 56 push %esi 1168d6: 8b 45 e4 mov -0x1c(%ebp),%eax 1168d9: 83 c0 24 add $0x24,%eax 1168dc: 50 push %eax 1168dd: e8 9e 2f 00 00 call 119880 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1168e2: 8b 7d e4 mov -0x1c(%ebp),%edi 1168e5: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1168e8: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1168eb: 8b 15 dc 28 14 00 mov 0x1428dc,%edx 1168f1: 89 3c b2 mov %edi,(%edx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1168f4: 89 5f 0c mov %ebx,0xc(%edi)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1168f7: 8b 55 1c mov 0x1c(%ebp),%edx 1168fa: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1168fc: e8 53 55 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116901: 83 c4 10 add $0x10,%esp 116904: 31 c0 xor %eax,%eax 116906: e9 66 ff ff ff jmp 116871 <rtems_partition_create+0x55> 11690b: 90 nop
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
11690c: e8 43 55 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
116911: b8 05 00 00 00 mov $0x5,%eax 116916: e9 56 ff ff ff jmp 116871 <rtems_partition_create+0x55>
00116988 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
116988: 55 push %ebp 116989: 89 e5 mov %esp,%ebp 11698b: 56 push %esi 11698c: 53 push %ebx 11698d: 83 ec 20 sub $0x20,%esp 116990: 8b 5d 0c mov 0xc(%ebp),%ebx
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
116993: 85 db test %ebx,%ebx
116995: 74 59 je 1169f0 <rtems_partition_get_buffer+0x68>
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116997: 52 push %edx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
116998: 8d 45 f4 lea -0xc(%ebp),%eax 11699b: 50 push %eax 11699c: ff 75 08 pushl 0x8(%ebp) 11699f: 68 c0 28 14 00 push $0x1428c0 1169a4: e8 33 49 00 00 call 11b2dc <_Objects_Get> 1169a9: 89 c6 mov %eax,%esi
switch ( location ) {
1169ab: 83 c4 10 add $0x10,%esp 1169ae: 8b 45 f4 mov -0xc(%ebp),%eax 1169b1: 85 c0 test %eax,%eax
1169b3: 75 2f jne 1169e4 <rtems_partition_get_buffer+0x5c>
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
1169b5: 83 ec 0c sub $0xc,%esp 1169b8: 8d 46 24 lea 0x24(%esi),%eax 1169bb: 50 push %eax 1169bc: e8 9b 2e 00 00 call 11985c <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
1169c1: 83 c4 10 add $0x10,%esp 1169c4: 85 c0 test %eax,%eax
1169c6: 74 34 je 1169fc <rtems_partition_get_buffer+0x74>
the_partition->number_of_used_blocks += 1;
1169c8: ff 46 20 incl 0x20(%esi)
_Thread_Enable_dispatch();
1169cb: 89 45 e4 mov %eax,-0x1c(%ebp) 1169ce: e8 81 54 00 00 call 11be54 <_Thread_Enable_dispatch>
*buffer = the_buffer;
1169d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1169d6: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1169d8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1169da: 8d 65 f8 lea -0x8(%ebp),%esp 1169dd: 5b pop %ebx 1169de: 5e pop %esi 1169df: c9 leave 1169e0: c3 ret 1169e1: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1169e4: b8 04 00 00 00 mov $0x4,%eax
}
1169e9: 8d 65 f8 lea -0x8(%ebp),%esp 1169ec: 5b pop %ebx 1169ed: 5e pop %esi 1169ee: c9 leave 1169ef: c3 ret
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
1169f0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1169f5: 8d 65 f8 lea -0x8(%ebp),%esp 1169f8: 5b pop %ebx 1169f9: 5e pop %esi 1169fa: c9 leave 1169fb: c3 ret
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1169fc: e8 53 54 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
116a01: b8 0d 00 00 00 mov $0xd,%eax 116a06: eb e1 jmp 1169e9 <rtems_partition_get_buffer+0x61>
00116a2c <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
116a2c: 55 push %ebp 116a2d: 89 e5 mov %esp,%ebp 116a2f: 56 push %esi 116a30: 53 push %ebx 116a31: 83 ec 14 sub $0x14,%esp 116a34: 8b 75 0c mov 0xc(%ebp),%esi
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
116a37: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116a3a: 50 push %eax 116a3b: ff 75 08 pushl 0x8(%ebp) 116a3e: 68 c0 28 14 00 push $0x1428c0 116a43: e8 94 48 00 00 call 11b2dc <_Objects_Get> 116a48: 89 c3 mov %eax,%ebx
switch ( location ) {
116a4a: 83 c4 10 add $0x10,%esp 116a4d: 8b 45 f4 mov -0xc(%ebp),%eax 116a50: 85 c0 test %eax,%eax
116a52: 74 0c je 116a60 <rtems_partition_return_buffer+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116a54: b8 04 00 00 00 mov $0x4,%eax
}
116a59: 8d 65 f8 lea -0x8(%ebp),%esp 116a5c: 5b pop %ebx 116a5d: 5e pop %esi 116a5e: c9 leave 116a5f: c3 ret
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
116a60: 8b 43 10 mov 0x10(%ebx),%eax
ending = _Addresses_Add_offset( starting, the_partition->length );
116a63: 8b 53 14 mov 0x14(%ebx),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116a66: 39 c6 cmp %eax,%esi
116a68: 72 3a jb 116aa4 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116a6a: 8d 14 10 lea (%eax,%edx,1),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116a6d: 39 d6 cmp %edx,%esi
116a6f: 77 33 ja 116aa4 <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
116a71: 89 f2 mov %esi,%edx 116a73: 29 c2 sub %eax,%edx 116a75: 89 d0 mov %edx,%eax
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
116a77: 31 d2 xor %edx,%edx 116a79: f7 73 18 divl 0x18(%ebx)
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
116a7c: 85 d2 test %edx,%edx
116a7e: 75 24 jne 116aa4 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
116a80: 83 ec 08 sub $0x8,%esp 116a83: 56 push %esi 116a84: 8d 43 24 lea 0x24(%ebx),%eax 116a87: 50 push %eax 116a88: e8 93 2d 00 00 call 119820 <_Chain_Append>
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
116a8d: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
116a90: e8 bf 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116a95: 83 c4 10 add $0x10,%esp 116a98: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116a9a: 8d 65 f8 lea -0x8(%ebp),%esp 116a9d: 5b pop %ebx 116a9e: 5e pop %esi 116a9f: c9 leave 116aa0: c3 ret 116aa1: 8d 76 00 lea 0x0(%esi),%esi
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
116aa4: e8 ab 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
116aa9: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116aae: 8d 65 f8 lea -0x8(%ebp),%esp 116ab1: 5b pop %ebx 116ab2: 5e pop %esi 116ab3: c9 leave 116ab4: c3 ret
00115e50 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
115e50: 55 push %ebp 115e51: 89 e5 mov %esp,%ebp 115e53: 57 push %edi 115e54: 56 push %esi 115e55: 53 push %ebx 115e56: 83 ec 1c sub $0x1c,%esp 115e59: 8b 5d 08 mov 0x8(%ebp),%ebx 115e5c: 8b 55 0c mov 0xc(%ebp),%edx 115e5f: 8b 7d 10 mov 0x10(%ebp),%edi 115e62: 8b 75 18 mov 0x18(%ebp),%esi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
115e65: 85 db test %ebx,%ebx
115e67: 74 1b je 115e84 <rtems_port_create+0x34>
return RTEMS_INVALID_NAME;
if ( !id )
115e69: 85 f6 test %esi,%esi
115e6b: 74 08 je 115e75 <rtems_port_create+0x25>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
115e6d: 89 f8 mov %edi,%eax 115e6f: 09 d0 or %edx,%eax
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
115e71: a8 03 test $0x3,%al
115e73: 74 1f je 115e94 <rtems_port_create+0x44>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
115e75: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e7a: 8d 65 f4 lea -0xc(%ebp),%esp 115e7d: 5b pop %ebx 115e7e: 5e pop %esi 115e7f: 5f pop %edi 115e80: c9 leave 115e81: c3 ret 115e82: 66 90 xchg %ax,%ax
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
115e84: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e89: 8d 65 f4 lea -0xc(%ebp),%esp 115e8c: 5b pop %ebx 115e8d: 5e pop %esi 115e8e: 5f pop %edi 115e8f: c9 leave 115e90: c3 ret 115e91: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
115e94: a1 30 2a 14 00 mov 0x142a30,%eax 115e99: 40 inc %eax 115e9a: a3 30 2a 14 00 mov %eax,0x142a30
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
115e9f: 83 ec 0c sub $0xc,%esp 115ea2: 68 80 28 14 00 push $0x142880 115ea7: 89 55 e4 mov %edx,-0x1c(%ebp) 115eaa: e8 3d 4f 00 00 call 11adec <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
115eaf: 83 c4 10 add $0x10,%esp 115eb2: 85 c0 test %eax,%eax 115eb4: 8b 55 e4 mov -0x1c(%ebp),%edx
115eb7: 74 33 je 115eec <rtems_port_create+0x9c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
115eb9: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
115ebc: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
115ebf: 8b 55 14 mov 0x14(%ebp),%edx 115ec2: 4a dec %edx 115ec3: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
115ec6: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
115ec9: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
115ecc: 8b 0d 9c 28 14 00 mov 0x14289c,%ecx 115ed2: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
115ed5: 89 58 0c mov %ebx,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
115ed8: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
115eda: e8 75 5f 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115edf: 31 c0 xor %eax,%eax
}
115ee1: 8d 65 f4 lea -0xc(%ebp),%esp 115ee4: 5b pop %ebx 115ee5: 5e pop %esi 115ee6: 5f pop %edi 115ee7: c9 leave 115ee8: c3 ret 115ee9: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
115eec: e8 63 5f 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115ef1: b8 05 00 00 00 mov $0x5,%eax 115ef6: eb 82 jmp 115e7a <rtems_port_create+0x2a>
00115ef8 <rtems_port_delete>:
*/
rtems_status_code rtems_port_delete(
rtems_id id
)
{
115ef8: 55 push %ebp 115ef9: 89 e5 mov %esp,%ebp 115efb: 83 ec 2c sub $0x2c,%esp
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
115efe: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
_Objects_Get( &_Dual_ported_memory_Information, id, location );
115f01: 50 push %eax 115f02: ff 75 08 pushl 0x8(%ebp) 115f05: 68 80 28 14 00 push $0x142880 115f0a: e8 cd 53 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
115f0f: 83 c4 10 add $0x10,%esp 115f12: 8b 4d f4 mov -0xc(%ebp),%ecx 115f15: 85 c9 test %ecx,%ecx
115f17: 75 2f jne 115f48 <rtems_port_delete+0x50>
case OBJECTS_LOCAL:
_Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
115f19: 83 ec 08 sub $0x8,%esp 115f1c: 50 push %eax 115f1d: 68 80 28 14 00 push $0x142880 115f22: 89 45 e4 mov %eax,-0x1c(%ebp) 115f25: e8 3e 4f 00 00 call 11ae68 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free (
Dual_ported_memory_Control *the_port
)
{
_Objects_Free( &_Dual_ported_memory_Information, &the_port->Object );
115f2a: 58 pop %eax 115f2b: 5a pop %edx 115f2c: 8b 45 e4 mov -0x1c(%ebp),%eax 115f2f: 50 push %eax 115f30: 68 80 28 14 00 push $0x142880 115f35: e8 26 52 00 00 call 11b160 <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
115f3a: e8 15 5f 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115f3f: 83 c4 10 add $0x10,%esp 115f42: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115f44: c9 leave 115f45: c3 ret 115f46: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115f48: b8 04 00 00 00 mov $0x4,%eax
}
115f4d: c9 leave 115f4e: c3 ret
00115f50 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
rtems_id id,
void *external,
void **internal
)
{
115f50: 55 push %ebp 115f51: 89 e5 mov %esp,%ebp 115f53: 56 push %esi 115f54: 53 push %ebx 115f55: 83 ec 10 sub $0x10,%esp 115f58: 8b 75 0c mov 0xc(%ebp),%esi 115f5b: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
115f5e: 85 db test %ebx,%ebx
115f60: 74 4e je 115fb0 <rtems_port_external_to_internal+0x60>
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
_Objects_Get( &_Dual_ported_memory_Information, id, location );
115f62: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
115f63: 8d 45 f4 lea -0xc(%ebp),%eax 115f66: 50 push %eax 115f67: ff 75 08 pushl 0x8(%ebp) 115f6a: 68 80 28 14 00 push $0x142880 115f6f: e8 68 53 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
115f74: 83 c4 10 add $0x10,%esp 115f77: 8b 55 f4 mov -0xc(%ebp),%edx 115f7a: 85 d2 test %edx,%edx
115f7c: 74 0e je 115f8c <rtems_port_external_to_internal+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115f7e: b8 04 00 00 00 mov $0x4,%eax
}
115f83: 8d 65 f8 lea -0x8(%ebp),%esp 115f86: 5b pop %ebx 115f87: 5e pop %esi 115f88: c9 leave 115f89: c3 ret 115f8a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
115f8c: 89 f2 mov %esi,%edx 115f8e: 2b 50 14 sub 0x14(%eax),%edx
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
115f91: 3b 50 18 cmp 0x18(%eax),%edx
115f94: 77 16 ja 115fac <rtems_port_external_to_internal+0x5c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
115f96: 03 50 10 add 0x10(%eax),%edx 115f99: 89 13 mov %edx,(%ebx)
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
115f9b: e8 b4 5e 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115fa0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115fa2: 8d 65 f8 lea -0x8(%ebp),%esp 115fa5: 5b pop %ebx 115fa6: 5e pop %esi 115fa7: c9 leave 115fa8: c3 ret 115fa9: 8d 76 00 lea 0x0(%esi),%esi
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
*internal = external;
115fac: 89 33 mov %esi,(%ebx) 115fae: eb eb jmp 115f9b <rtems_port_external_to_internal+0x4b>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
return RTEMS_INVALID_ADDRESS;
115fb0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115fb5: 8d 65 f8 lea -0x8(%ebp),%esp 115fb8: 5b pop %ebx 115fb9: 5e pop %esi 115fba: c9 leave 115fbb: c3 ret
00115fe0 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
115fe0: 55 push %ebp 115fe1: 89 e5 mov %esp,%ebp 115fe3: 56 push %esi 115fe4: 53 push %ebx 115fe5: 83 ec 10 sub $0x10,%esp 115fe8: 8b 75 0c mov 0xc(%ebp),%esi 115feb: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
115fee: 85 db test %ebx,%ebx
115ff0: 74 4e je 116040 <rtems_port_internal_to_external+0x60><== NEVER TAKEN
115ff2: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
115ff3: 8d 45 f4 lea -0xc(%ebp),%eax 115ff6: 50 push %eax 115ff7: ff 75 08 pushl 0x8(%ebp) 115ffa: 68 80 28 14 00 push $0x142880 115fff: e8 d8 52 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
116004: 83 c4 10 add $0x10,%esp 116007: 8b 55 f4 mov -0xc(%ebp),%edx 11600a: 85 d2 test %edx,%edx
11600c: 74 0e je 11601c <rtems_port_internal_to_external+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11600e: b8 04 00 00 00 mov $0x4,%eax
}
116013: 8d 65 f8 lea -0x8(%ebp),%esp 116016: 5b pop %ebx 116017: 5e pop %esi 116018: c9 leave 116019: c3 ret 11601a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
11601c: 89 f2 mov %esi,%edx 11601e: 2b 50 10 sub 0x10(%eax),%edx
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
116021: 3b 50 18 cmp 0x18(%eax),%edx
116024: 77 16 ja 11603c <rtems_port_internal_to_external+0x5c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116026: 03 50 14 add 0x14(%eax),%edx 116029: 89 13 mov %edx,(%ebx)
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
11602b: e8 24 5e 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116030: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116032: 8d 65 f8 lea -0x8(%ebp),%esp 116035: 5b pop %ebx 116036: 5e pop %esi 116037: c9 leave 116038: c3 ret 116039: 8d 76 00 lea 0x0(%esi),%esi
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
*external = internal;
11603c: 89 33 mov %esi,(%ebx) 11603e: eb eb jmp 11602b <rtems_port_internal_to_external+0x4b>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
return RTEMS_INVALID_ADDRESS;
116040: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116045: 8d 65 f8 lea -0x8(%ebp),%esp 116048: 5b pop %ebx 116049: 5e pop %esi 11604a: c9 leave 11604b: c3 ret
00116ab8 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
116ab8: 55 push %ebp 116ab9: 89 e5 mov %esp,%ebp 116abb: 53 push %ebx 116abc: 83 ec 18 sub $0x18,%esp
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
116abf: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
116ac2: 50 push %eax 116ac3: ff 75 08 pushl 0x8(%ebp) 116ac6: 68 00 29 14 00 push $0x142900 116acb: e8 0c 48 00 00 call 11b2dc <_Objects_Get> 116ad0: 89 c3 mov %eax,%ebx
switch ( location ) {
116ad2: 83 c4 10 add $0x10,%esp 116ad5: 8b 45 f4 mov -0xc(%ebp),%eax 116ad8: 85 c0 test %eax,%eax
116ada: 74 0c je 116ae8 <rtems_rate_monotonic_cancel+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116adc: b8 04 00 00 00 mov $0x4,%eax
}
116ae1: 8b 5d fc mov -0x4(%ebp),%ebx 116ae4: c9 leave 116ae5: c3 ret 116ae6: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
116ae8: a1 d8 2f 14 00 mov 0x142fd8,%eax 116aed: 39 43 40 cmp %eax,0x40(%ebx)
116af0: 74 12 je 116b04 <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
116af2: e8 5d 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
116af7: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116afc: 8b 5d fc mov -0x4(%ebp),%ebx 116aff: c9 leave 116b00: c3 ret 116b01: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
116b04: 83 ec 0c sub $0xc,%esp 116b07: 8d 43 10 lea 0x10(%ebx),%eax 116b0a: 50 push %eax 116b0b: e8 80 64 00 00 call 11cf90 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
116b10: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
_Thread_Enable_dispatch();
116b17: e8 38 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116b1c: 83 c4 10 add $0x10,%esp 116b1f: 31 c0 xor %eax,%eax 116b21: eb be jmp 116ae1 <rtems_rate_monotonic_cancel+0x29>
0010c340 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
10c340: 55 push %ebp 10c341: 89 e5 mov %esp,%ebp 10c343: 57 push %edi 10c344: 56 push %esi 10c345: 53 push %ebx 10c346: 83 ec 1c sub $0x1c,%esp 10c349: 8b 5d 08 mov 0x8(%ebp),%ebx 10c34c: 8b 75 0c mov 0xc(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10c34f: 85 db test %ebx,%ebx
10c351: 0f 84 a9 00 00 00 je 10c400 <rtems_rate_monotonic_create+0xc0>
return RTEMS_INVALID_NAME;
if ( !id )
10c357: 85 f6 test %esi,%esi
10c359: 0f 84 c5 00 00 00 je 10c424 <rtems_rate_monotonic_create+0xe4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c35f: a1 50 b1 12 00 mov 0x12b150,%eax 10c364: 40 inc %eax 10c365: a3 50 b1 12 00 mov %eax,0x12b150
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
_Objects_Allocate( &_Rate_monotonic_Information );
10c36a: 83 ec 0c sub $0xc,%esp 10c36d: 68 60 b0 12 00 push $0x12b060 10c372: e8 21 1f 00 00 call 10e298 <_Objects_Allocate> 10c377: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
10c379: 83 c4 10 add $0x10,%esp 10c37c: 85 c0 test %eax,%eax
10c37e: 0f 84 8c 00 00 00 je 10c410 <rtems_rate_monotonic_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10c384: a1 f8 b6 12 00 mov 0x12b6f8,%eax 10c389: 89 42 40 mov %eax,0x40(%edx)
the_period->state = RATE_MONOTONIC_INACTIVE;
10c38c: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c393: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
10c39a: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx)
the_watchdog->id = id;
10c3a1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
the_watchdog->user_data = user_data;
10c3a8: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
10c3af: 8d 42 54 lea 0x54(%edx),%eax 10c3b2: 89 45 e4 mov %eax,-0x1c(%ebp) 10c3b5: b9 38 00 00 00 mov $0x38,%ecx 10c3ba: 31 c0 xor %eax,%eax 10c3bc: 8b 7d e4 mov -0x1c(%ebp),%edi 10c3bf: f3 aa rep stos %al,%es:(%edi) 10c3c1: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10c3c8: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10c3cf: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10c3d6: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c3dd: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c3e0: 0f b7 f8 movzwl %ax,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c3e3: 8b 0d 7c b0 12 00 mov 0x12b07c,%ecx 10c3e9: 89 14 b9 mov %edx,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c3ec: 89 5a 0c mov %ebx,0xc(%edx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
10c3ef: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c3f1: e8 b6 2f 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c3f6: 31 c0 xor %eax,%eax
}
10c3f8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3fb: 5b pop %ebx 10c3fc: 5e pop %esi 10c3fd: 5f pop %edi 10c3fe: c9 leave 10c3ff: c3 ret
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c400: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c405: 8d 65 f4 lea -0xc(%ebp),%esp 10c408: 5b pop %ebx 10c409: 5e pop %esi 10c40a: 5f pop %edi 10c40b: c9 leave 10c40c: c3 ret 10c40d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
10c410: e8 97 2f 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c415: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c41a: 8d 65 f4 lea -0xc(%ebp),%esp 10c41d: 5b pop %ebx 10c41e: 5e pop %esi 10c41f: 5f pop %edi 10c420: c9 leave 10c421: c3 ret 10c422: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c424: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c429: 8d 65 f4 lea -0xc(%ebp),%esp 10c42c: 5b pop %ebx 10c42d: 5e pop %esi 10c42e: 5f pop %edi 10c42f: c9 leave 10c430: c3 ret
00112900 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
112900: 55 push %ebp 112901: 89 e5 mov %esp,%ebp 112903: 53 push %ebx 112904: 83 ec 24 sub $0x24,%esp 112907: 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 )
11290a: 85 db test %ebx,%ebx
11290c: 0f 84 92 00 00 00 je 1129a4 <rtems_rate_monotonic_get_status+0xa4>
112912: 50 push %eax
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
112913: 8d 45 f4 lea -0xc(%ebp),%eax 112916: 50 push %eax 112917: ff 75 08 pushl 0x8(%ebp) 11291a: 68 60 b0 12 00 push $0x12b060 11291f: e8 10 bf ff ff call 10e834 <_Objects_Get>
switch ( location ) {
112924: 83 c4 10 add $0x10,%esp 112927: 8b 4d f4 mov -0xc(%ebp),%ecx 11292a: 85 c9 test %ecx,%ecx
11292c: 74 0a je 112938 <rtems_rate_monotonic_get_status+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11292e: b8 04 00 00 00 mov $0x4,%eax
}
112933: 8b 5d fc mov -0x4(%ebp),%ebx 112936: c9 leave 112937: c3 ret
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
112938: 8b 50 40 mov 0x40(%eax),%edx 11293b: 8b 52 08 mov 0x8(%edx),%edx 11293e: 89 13 mov %edx,(%ebx)
status->state = the_period->state;
112940: 8b 50 38 mov 0x38(%eax),%edx 112943: 89 53 04 mov %edx,0x4(%ebx)
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
112946: 85 d2 test %edx,%edx
112948: 75 2a jne 112974 <rtems_rate_monotonic_get_status+0x74>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
11294a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 112951: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Timespec_Set_to_zero( &status->executed_since_last_period );
112958: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 11295f: 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();
112966: e8 41 ca ff ff call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11296b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11296d: 8b 5d fc mov -0x4(%ebp),%ebx 112970: c9 leave 112971: c3 ret 112972: 66 90 xchg %ax,%ax
} else {
/*
* Grab the current status.
*/
valid_status =
112974: 52 push %edx
_Rate_monotonic_Get_status(
112975: 8d 55 ec lea -0x14(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
112978: 52 push %edx
_Rate_monotonic_Get_status(
112979: 8d 55 e4 lea -0x1c(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
11297c: 52 push %edx 11297d: 50 push %eax 11297e: e8 d5 9a ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
112983: 83 c4 10 add $0x10,%esp 112986: 84 c0 test %al,%al
112988: 74 26 je 1129b0 <rtems_rate_monotonic_get_status+0xb0>
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
11298a: 8b 45 e4 mov -0x1c(%ebp),%eax 11298d: 8b 55 e8 mov -0x18(%ebp),%edx 112990: 89 43 08 mov %eax,0x8(%ebx) 112993: 89 53 0c mov %edx,0xc(%ebx)
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
112996: 8b 45 ec mov -0x14(%ebp),%eax 112999: 8b 55 f0 mov -0x10(%ebp),%edx 11299c: 89 43 10 mov %eax,0x10(%ebx) 11299f: 89 53 14 mov %edx,0x14(%ebx) 1129a2: eb c2 jmp 112966 <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;
1129a4: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1129a9: 8b 5d fc mov -0x4(%ebp),%ebx 1129ac: c9 leave 1129ad: c3 ret 1129ae: 66 90 xchg %ax,%ax
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
1129b0: e8 f7 c9 ff ff call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
1129b5: b8 0b 00 00 00 mov $0xb,%eax 1129ba: e9 74 ff ff ff jmp 112933 <rtems_rate_monotonic_get_status+0x33>
0010c654 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10c654: 55 push %ebp 10c655: 89 e5 mov %esp,%ebp 10c657: 57 push %edi 10c658: 56 push %esi 10c659: 53 push %ebx 10c65a: 83 ec 30 sub $0x30,%esp 10c65d: 8b 5d 08 mov 0x8(%ebp),%ebx 10c660: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
10c663: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10c666: 50 push %eax 10c667: 53 push %ebx 10c668: 68 60 b0 12 00 push $0x12b060 10c66d: e8 c2 21 00 00 call 10e834 <_Objects_Get>
switch ( location ) {
10c672: 83 c4 10 add $0x10,%esp 10c675: 8b 55 e4 mov -0x1c(%ebp),%edx 10c678: 85 d2 test %edx,%edx
10c67a: 74 10 je 10c68c <rtems_rate_monotonic_period+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c67c: b8 04 00 00 00 mov $0x4,%eax
}
10c681: 8d 65 f4 lea -0xc(%ebp),%esp 10c684: 5b pop %ebx 10c685: 5e pop %esi 10c686: 5f pop %edi 10c687: c9 leave 10c688: c3 ret 10c689: 8d 76 00 lea 0x0(%esi),%esi
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10c68c: 8b 15 f8 b6 12 00 mov 0x12b6f8,%edx 10c692: 39 50 40 cmp %edx,0x40(%eax)
10c695: 74 15 je 10c6ac <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10c697: e8 10 2d 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10c69c: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6a1: 8d 65 f4 lea -0xc(%ebp),%esp 10c6a4: 5b pop %ebx 10c6a5: 5e pop %esi 10c6a6: 5f pop %edi 10c6a7: c9 leave 10c6a8: c3 ret 10c6a9: 8d 76 00 lea 0x0(%esi),%esi
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
10c6ac: 85 f6 test %esi,%esi
10c6ae: 75 1c jne 10c6cc <rtems_rate_monotonic_period+0x78>
switch ( the_period->state ) {
10c6b0: 8b 40 38 mov 0x38(%eax),%eax 10c6b3: 83 f8 04 cmp $0x4,%eax
10c6b6: 77 6c ja 10c724 <rtems_rate_monotonic_period+0xd0><== NEVER TAKEN
10c6b8: 8b 04 85 1c 3d 12 00 mov 0x123d1c(,%eax,4),%eax
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10c6bf: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6c2: e8 e5 2c 00 00 call 10f3ac <_Thread_Enable_dispatch>
return( return_value );
10c6c7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6ca: eb b5 jmp 10c681 <rtems_rate_monotonic_period+0x2d>
}
_ISR_Disable( level );
10c6cc: 9c pushf 10c6cd: fa cli 10c6ce: 5f pop %edi
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10c6cf: 8b 50 38 mov 0x38(%eax),%edx 10c6d2: 85 d2 test %edx,%edx
10c6d4: 74 52 je 10c728 <rtems_rate_monotonic_period+0xd4>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10c6d6: 83 fa 02 cmp $0x2,%edx
10c6d9: 0f 84 9e 00 00 00 je 10c77d <rtems_rate_monotonic_period+0x129>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10c6df: 83 fa 04 cmp $0x4,%edx
10c6e2: 75 98 jne 10c67c <rtems_rate_monotonic_period+0x28><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10c6e4: 83 ec 0c sub $0xc,%esp 10c6e7: 50 push %eax 10c6e8: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6eb: e8 74 fe ff ff call 10c564 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10c6f0: 57 push %edi 10c6f1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10c6f2: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6f5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
the_period->next_length = length;
10c6fc: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c6ff: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c702: 5b pop %ebx 10c703: 5e pop %esi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10c704: 83 c0 10 add $0x10,%eax 10c707: 50 push %eax 10c708: 68 20 b2 12 00 push $0x12b220 10c70d: e8 0a 3b 00 00 call 11021c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c712: e8 95 2c 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10c717: 83 c4 10 add $0x10,%esp 10c71a: b8 06 00 00 00 mov $0x6,%eax 10c71f: e9 5d ff ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10c724: 31 c0 xor %eax,%eax
10c726: eb 97 jmp 10c6bf <rtems_rate_monotonic_period+0x6b><== NOT EXECUTED
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
10c728: 57 push %edi 10c729: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10c72a: 83 ec 0c sub $0xc,%esp 10c72d: 50 push %eax 10c72e: 89 45 d4 mov %eax,-0x2c(%ebp) 10c731: e8 ba fd ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10c736: 8b 45 d4 mov -0x2c(%ebp),%eax 10c739: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c740: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c747: c7 40 2c ac ca 10 00 movl $0x10caac,0x2c(%eax)
the_watchdog->id = id;
10c74e: 89 58 30 mov %ebx,0x30(%eax)
the_watchdog->user_data = user_data;
10c751: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10c758: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c75b: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c75e: 5e pop %esi 10c75f: 5f pop %edi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10c760: 83 c0 10 add $0x10,%eax 10c763: 50 push %eax 10c764: 68 20 b2 12 00 push $0x12b220 10c769: e8 ae 3a 00 00 call 11021c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c76e: e8 39 2c 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c773: 83 c4 10 add $0x10,%esp 10c776: 31 c0 xor %eax,%eax 10c778: e9 04 ff ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10c77d: 83 ec 0c sub $0xc,%esp 10c780: 50 push %eax 10c781: 89 45 d4 mov %eax,-0x2c(%ebp) 10c784: e8 db fd ff ff call 10c564 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
10c789: 8b 45 d4 mov -0x2c(%ebp),%eax 10c78c: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
the_period->next_length = length;
10c793: 89 70 3c mov %esi,0x3c(%eax)
_ISR_Enable( level );
10c796: 57 push %edi 10c797: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10c798: 8b 15 f8 b6 12 00 mov 0x12b6f8,%edx 10c79e: 8b 48 08 mov 0x8(%eax),%ecx 10c7a1: 89 4a 20 mov %ecx,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10c7a4: 59 pop %ecx 10c7a5: 5b pop %ebx 10c7a6: 68 00 40 00 00 push $0x4000 10c7ab: 52 push %edx 10c7ac: 89 45 d4 mov %eax,-0x2c(%ebp) 10c7af: e8 18 34 00 00 call 10fbcc <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10c7b4: 9c pushf 10c7b5: fa cli 10c7b6: 59 pop %ecx
local_state = the_period->state;
10c7b7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c7ba: 8b 50 38 mov 0x38(%eax),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10c7bd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
_ISR_Enable( level );
10c7c4: 51 push %ecx 10c7c5: 9d popf
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
10c7c6: 83 c4 10 add $0x10,%esp 10c7c9: 83 fa 03 cmp $0x3,%edx
10c7cc: 74 0c je 10c7da <rtems_rate_monotonic_period+0x186>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
10c7ce: e8 d9 2b 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c7d3: 31 c0 xor %eax,%eax 10c7d5: e9 a7 fe ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10c7da: 57 push %edi 10c7db: 57 push %edi 10c7dc: 68 00 40 00 00 push $0x4000 10c7e1: ff 35 f8 b6 12 00 pushl 0x12b6f8 10c7e7: e8 5c 28 00 00 call 10f048 <_Thread_Clear_state> 10c7ec: 83 c4 10 add $0x10,%esp 10c7ef: eb dd jmp 10c7ce <rtems_rate_monotonic_period+0x17a>
0010c7f4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10c7f4: 55 push %ebp 10c7f5: 89 e5 mov %esp,%ebp 10c7f7: 57 push %edi 10c7f8: 56 push %esi 10c7f9: 53 push %ebx 10c7fa: 81 ec 8c 00 00 00 sub $0x8c,%esp 10c800: 8b 75 08 mov 0x8(%ebp),%esi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10c803: 8b 7d 0c mov 0xc(%ebp),%edi 10c806: 85 ff test %edi,%edi
10c808: 0f 84 be 00 00 00 je 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10c80e: 83 ec 08 sub $0x8,%esp 10c811: 68 30 3d 12 00 push $0x123d30 10c816: 56 push %esi 10c817: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10c81a: 59 pop %ecx 10c81b: 5b pop %ebx 10c81c: 68 68 3d 12 00 push $0x123d68 10c821: 56 push %esi 10c822: ff 55 0c call *0xc(%ebp)
(*print)( context, "--- Wall times are in seconds ---\n" );
10c825: 58 pop %eax 10c826: 5a pop %edx 10c827: 68 8c 3d 12 00 push $0x123d8c 10c82c: 56 push %esi 10c82d: ff 55 0c call *0xc(%ebp)
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
10c830: 5b pop %ebx 10c831: 5f pop %edi 10c832: 68 b0 3d 12 00 push $0x123db0 10c837: 56 push %esi 10c838: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10c83b: 5a pop %edx 10c83c: 59 pop %ecx 10c83d: 68 fc 3d 12 00 push $0x123dfc 10c842: 56 push %esi 10c843: ff 55 0c call *0xc(%ebp)
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10c846: 8b 1d 68 b0 12 00 mov 0x12b068,%ebx 10c84c: 83 c4 10 add $0x10,%esp 10c84f: 3b 1d 6c b0 12 00 cmp 0x12b06c,%ebx
10c855: 77 75 ja 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
10c857: 8d 7d 88 lea -0x78(%ebp),%edi 10c85a: eb 09 jmp 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10c85c: 43 inc %ebx
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10c85d: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c
10c863: 72 67 jb 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10c865: 83 ec 08 sub $0x8,%esp 10c868: 57 push %edi 10c869: 53 push %ebx 10c86a: e8 e5 5f 00 00 call 112854 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10c86f: 83 c4 10 add $0x10,%esp 10c872: 85 c0 test %eax,%eax
10c874: 75 e6 jne 10c85c <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
10c876: 83 ec 08 sub $0x8,%esp 10c879: 8d 45 c0 lea -0x40(%ebp),%eax 10c87c: 50 push %eax 10c87d: 53 push %ebx 10c87e: e8 7d 60 00 00 call 112900 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10c883: 83 c4 0c add $0xc,%esp 10c886: 8d 55 e3 lea -0x1d(%ebp),%edx 10c889: 52 push %edx 10c88a: 6a 05 push $0x5 10c88c: ff 75 c0 pushl -0x40(%ebp) 10c88f: e8 b4 02 00 00 call 10cb48 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10c894: 59 pop %ecx 10c895: 58 pop %eax 10c896: ff 75 8c pushl -0x74(%ebp) 10c899: ff 75 88 pushl -0x78(%ebp) 10c89c: 8d 45 e3 lea -0x1d(%ebp),%eax 10c89f: 50 push %eax 10c8a0: 53 push %ebx 10c8a1: 68 4e 3d 12 00 push $0x123d4e 10c8a6: 56 push %esi 10c8a7: ff 55 0c call *0xc(%ebp)
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10c8aa: 8b 45 88 mov -0x78(%ebp),%eax 10c8ad: 83 c4 20 add $0x20,%esp 10c8b0: 85 c0 test %eax,%eax
10c8b2: 75 20 jne 10c8d4 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
(*print)( context, "\n" );
10c8b4: 83 ec 08 sub $0x8,%esp 10c8b7: 68 31 1e 12 00 push $0x121e31 10c8bc: 56 push %esi 10c8bd: ff 55 0c call *0xc(%ebp)
continue;
10c8c0: 83 c4 10 add $0x10,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10c8c3: 43 inc %ebx
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10c8c4: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c
10c8ca: 73 99 jae 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71><== ALWAYS TAKEN
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10c8cc: 8d 65 f4 lea -0xc(%ebp),%esp 10c8cf: 5b pop %ebx 10c8d0: 5e pop %esi 10c8d1: 5f pop %edi 10c8d2: c9 leave 10c8d3: c3 ret
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
10c8d4: 52 push %edx 10c8d5: 8d 55 d8 lea -0x28(%ebp),%edx 10c8d8: 52 push %edx 10c8d9: 50 push %eax 10c8da: 8d 45 a0 lea -0x60(%ebp),%eax 10c8dd: 50 push %eax 10c8de: e8 99 35 00 00 call 10fe7c <_Timespec_Divide_by_integer>
(*print)( context,
10c8e3: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 10c8e8: 8b 45 dc mov -0x24(%ebp),%eax 10c8eb: f7 e9 imul %ecx 10c8ed: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c8f3: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c8f9: c1 f8 06 sar $0x6,%eax 10c8fc: 8b 55 dc mov -0x24(%ebp),%edx 10c8ff: c1 fa 1f sar $0x1f,%edx 10c902: 29 d0 sub %edx,%eax 10c904: 50 push %eax 10c905: ff 75 d8 pushl -0x28(%ebp) 10c908: 8b 45 9c mov -0x64(%ebp),%eax 10c90b: f7 e9 imul %ecx 10c90d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c913: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c919: c1 f8 06 sar $0x6,%eax 10c91c: 8b 55 9c mov -0x64(%ebp),%edx 10c91f: c1 fa 1f sar $0x1f,%edx 10c922: 29 d0 sub %edx,%eax 10c924: 50 push %eax 10c925: ff 75 98 pushl -0x68(%ebp) 10c928: 8b 45 94 mov -0x6c(%ebp),%eax 10c92b: f7 e9 imul %ecx 10c92d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c933: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c939: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c93f: c1 f8 06 sar $0x6,%eax 10c942: 8b 55 94 mov -0x6c(%ebp),%edx 10c945: c1 fa 1f sar $0x1f,%edx 10c948: 29 d0 sub %edx,%eax 10c94a: 50 push %eax 10c94b: ff 75 90 pushl -0x70(%ebp) 10c94e: 68 48 3e 12 00 push $0x123e48 10c953: 56 push %esi 10c954: 89 4d 84 mov %ecx,-0x7c(%ebp) 10c957: ff 55 0c call *0xc(%ebp)
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10c95a: 83 c4 2c add $0x2c,%esp 10c95d: 8d 55 d8 lea -0x28(%ebp),%edx 10c960: 52 push %edx 10c961: ff 75 88 pushl -0x78(%ebp) 10c964: 8d 45 b8 lea -0x48(%ebp),%eax 10c967: 50 push %eax 10c968: e8 0f 35 00 00 call 10fe7c <_Timespec_Divide_by_integer>
(*print)( context,
10c96d: 8b 4d 84 mov -0x7c(%ebp),%ecx 10c970: 8b 45 dc mov -0x24(%ebp),%eax 10c973: f7 e9 imul %ecx 10c975: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c97b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c981: c1 f8 06 sar $0x6,%eax 10c984: 8b 55 dc mov -0x24(%ebp),%edx 10c987: c1 fa 1f sar $0x1f,%edx 10c98a: 29 d0 sub %edx,%eax 10c98c: 50 push %eax 10c98d: ff 75 d8 pushl -0x28(%ebp) 10c990: 8b 45 b4 mov -0x4c(%ebp),%eax 10c993: f7 e9 imul %ecx 10c995: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c99b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9a1: c1 f8 06 sar $0x6,%eax 10c9a4: 8b 55 b4 mov -0x4c(%ebp),%edx 10c9a7: c1 fa 1f sar $0x1f,%edx 10c9aa: 29 d0 sub %edx,%eax 10c9ac: 50 push %eax 10c9ad: ff 75 b0 pushl -0x50(%ebp) 10c9b0: 8b 45 ac mov -0x54(%ebp),%eax 10c9b3: f7 e9 imul %ecx 10c9b5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c9bb: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c9c1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9c7: c1 f8 06 sar $0x6,%eax 10c9ca: 8b 55 ac mov -0x54(%ebp),%edx 10c9cd: c1 fa 1f sar $0x1f,%edx 10c9d0: 29 d0 sub %edx,%eax 10c9d2: 50 push %eax 10c9d3: ff 75 a8 pushl -0x58(%ebp) 10c9d6: 68 68 3e 12 00 push $0x123e68 10c9db: 56 push %esi 10c9dc: ff 55 0c call *0xc(%ebp) 10c9df: 83 c4 30 add $0x30,%esp 10c9e2: e9 75 fe ff ff jmp 10c85c <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
0010ca00 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
10ca00: 55 push %ebp 10ca01: 89 e5 mov %esp,%ebp 10ca03: 53 push %ebx 10ca04: 83 ec 04 sub $0x4,%esp 10ca07: a1 50 b1 12 00 mov 0x12b150,%eax 10ca0c: 40 inc %eax 10ca0d: a3 50 b1 12 00 mov %eax,0x12b150
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10ca12: 8b 1d 68 b0 12 00 mov 0x12b068,%ebx 10ca18: 3b 1d 6c b0 12 00 cmp 0x12b06c,%ebx
10ca1e: 77 15 ja 10ca35 <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
10ca20: 83 ec 0c sub $0xc,%esp 10ca23: 53 push %ebx 10ca24: e8 17 00 00 00 call 10ca40 <rtems_rate_monotonic_reset_statistics>
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10ca29: 43 inc %ebx
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10ca2a: 83 c4 10 add $0x10,%esp 10ca2d: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c
10ca33: 73 eb jae 10ca20 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
10ca35: 8b 5d fc mov -0x4(%ebp),%ebx 10ca38: c9 leave
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
10ca39: e9 6e 29 00 00 jmp 10f3ac <_Thread_Enable_dispatch>
0010ca40 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
10ca40: 55 push %ebp 10ca41: 89 e5 mov %esp,%ebp 10ca43: 57 push %edi 10ca44: 53 push %ebx 10ca45: 83 ec 14 sub $0x14,%esp
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
10ca48: 8d 45 f4 lea -0xc(%ebp),%eax 10ca4b: 50 push %eax 10ca4c: ff 75 08 pushl 0x8(%ebp) 10ca4f: 68 60 b0 12 00 push $0x12b060 10ca54: e8 db 1d 00 00 call 10e834 <_Objects_Get> 10ca59: 89 c2 mov %eax,%edx
switch ( location ) {
10ca5b: 83 c4 10 add $0x10,%esp 10ca5e: 8b 45 f4 mov -0xc(%ebp),%eax 10ca61: 85 c0 test %eax,%eax
10ca63: 75 3b jne 10caa0 <rtems_rate_monotonic_reset_statistics+0x60>
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
10ca65: 8d 5a 54 lea 0x54(%edx),%ebx 10ca68: b9 38 00 00 00 mov $0x38,%ecx 10ca6d: 31 c0 xor %eax,%eax 10ca6f: 89 df mov %ebx,%edi 10ca71: f3 aa rep stos %al,%es:(%edi) 10ca73: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10ca7a: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10ca81: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10ca88: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
_Thread_Enable_dispatch();
10ca8f: e8 18 29 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca94: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ca96: 8d 65 f8 lea -0x8(%ebp),%esp 10ca99: 5b pop %ebx 10ca9a: 5f pop %edi 10ca9b: c9 leave 10ca9c: c3 ret 10ca9d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10caa0: b8 04 00 00 00 mov $0x4,%eax
}
10caa5: 8d 65 f8 lea -0x8(%ebp),%esp 10caa8: 5b pop %ebx 10caa9: 5f pop %edi 10caaa: c9 leave 10caab: c3 ret
0011724c <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11724c: 55 push %ebp 11724d: 89 e5 mov %esp,%ebp 11724f: 57 push %edi 117250: 56 push %esi 117251: 53 push %ebx 117252: 83 ec 1c sub $0x1c,%esp 117255: 8b 7d 08 mov 0x8(%ebp),%edi 117258: 8b 75 0c mov 0xc(%ebp),%esi
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
11725b: 85 ff test %edi,%edi
11725d: 0f 84 c1 00 00 00 je 117324 <rtems_region_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !starting_address )
117263: 85 f6 test %esi,%esi
117265: 0f 84 e1 00 00 00 je 11734c <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
if ( !id )
11726b: 8b 45 1c mov 0x1c(%ebp),%eax 11726e: 85 c0 test %eax,%eax
117270: 0f 84 d6 00 00 00 je 11734c <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
117276: 83 ec 0c sub $0xc,%esp 117279: ff 35 e0 2a 14 00 pushl 0x142ae0 11727f: e8 24 25 00 00 call 1197a8 <_API_Mutex_Lock>
* This function allocates a region control block from
* the inactive chain of free region control blocks.
*/
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
return (Region_Control *) _Objects_Allocate( &_Region_Information );
117284: c7 04 24 40 29 14 00 movl $0x142940,(%esp) 11728b: e8 5c 3b 00 00 call 11adec <_Objects_Allocate> 117290: 89 c3 mov %eax,%ebx
the_region = _Region_Allocate();
if ( !the_region )
117292: 83 c4 10 add $0x10,%esp 117295: 85 c0 test %eax,%eax
117297: 0f 84 bf 00 00 00 je 11735c <rtems_region_create+0x110>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
11729d: ff 75 14 pushl 0x14(%ebp) 1172a0: ff 75 10 pushl 0x10(%ebp) 1172a3: 56 push %esi 1172a4: 8d 40 68 lea 0x68(%eax),%eax 1172a7: 50 push %eax 1172a8: e8 4b 37 00 00 call 11a9f8 <_Heap_Initialize> 1172ad: 89 43 5c mov %eax,0x5c(%ebx)
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
1172b0: 83 c4 10 add $0x10,%esp 1172b3: 85 c0 test %eax,%eax
1172b5: 74 7d je 117334 <rtems_region_create+0xe8>
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
1172b7: 89 73 50 mov %esi,0x50(%ebx)
the_region->length = length;
1172ba: 8b 45 10 mov 0x10(%ebp),%eax 1172bd: 89 43 54 mov %eax,0x54(%ebx)
the_region->page_size = page_size;
1172c0: 8b 55 14 mov 0x14(%ebp),%edx 1172c3: 89 53 58 mov %edx,0x58(%ebx)
the_region->attribute_set = attribute_set;
1172c6: 8b 45 18 mov 0x18(%ebp),%eax 1172c9: 89 43 60 mov %eax,0x60(%ebx)
the_region->number_of_used_blocks = 0;
1172cc: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
_Thread_queue_Initialize(
1172d3: 6a 06 push $0x6 1172d5: 6a 40 push $0x40 1172d7: a8 04 test $0x4,%al 1172d9: 0f 95 c0 setne %al 1172dc: 0f b6 c0 movzbl %al,%eax 1172df: 50 push %eax 1172e0: 8d 43 10 lea 0x10(%ebx),%eax 1172e3: 50 push %eax 1172e4: e8 77 52 00 00 call 11c560 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1172e9: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1172ec: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1172ef: 8b 15 5c 29 14 00 mov 0x14295c,%edx 1172f5: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1172f8: 89 7b 0c mov %edi,0xc(%ebx)
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
1172fb: 8b 55 1c mov 0x1c(%ebp),%edx 1172fe: 89 02 mov %eax,(%edx) 117300: 83 c4 10 add $0x10,%esp
return_status = RTEMS_SUCCESSFUL;
117303: 31 c0 xor %eax,%eax
}
}
_RTEMS_Unlock_allocator();
117305: 83 ec 0c sub $0xc,%esp 117308: ff 35 e0 2a 14 00 pushl 0x142ae0 11730e: 89 45 e4 mov %eax,-0x1c(%ebp) 117311: e8 da 24 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
117316: 83 c4 10 add $0x10,%esp 117319: 8b 45 e4 mov -0x1c(%ebp),%eax
}
11731c: 8d 65 f4 lea -0xc(%ebp),%esp 11731f: 5b pop %ebx 117320: 5e pop %esi 117321: 5f pop %edi 117322: c9 leave 117323: c3 ret
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
117324: b8 03 00 00 00 mov $0x3,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
117329: 8d 65 f4 lea -0xc(%ebp),%esp 11732c: 5b pop %ebx 11732d: 5e pop %esi 11732e: 5f pop %edi 11732f: c9 leave 117330: c3 ret 117331: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
117334: 83 ec 08 sub $0x8,%esp 117337: 53 push %ebx 117338: 68 40 29 14 00 push $0x142940 11733d: e8 1e 3e 00 00 call 11b160 <_Objects_Free> 117342: 83 c4 10 add $0x10,%esp
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
117345: b8 08 00 00 00 mov $0x8,%eax 11734a: eb b9 jmp 117305 <rtems_region_create+0xb9>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
11734c: b8 09 00 00 00 mov $0x9,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
117351: 8d 65 f4 lea -0xc(%ebp),%esp 117354: 5b pop %ebx 117355: 5e pop %esi 117356: 5f pop %edi 117357: c9 leave 117358: c3 ret 117359: 8d 76 00 lea 0x0(%esi),%esi
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
return_status = RTEMS_TOO_MANY;
11735c: b8 05 00 00 00 mov $0x5,%eax 117361: eb a2 jmp 117305 <rtems_region_create+0xb9>
00117364 <rtems_region_delete>:
*/
rtems_status_code rtems_region_delete(
rtems_id id
)
{
117364: 55 push %ebp 117365: 89 e5 mov %esp,%ebp 117367: 53 push %ebx 117368: 83 ec 30 sub $0x30,%esp
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
_RTEMS_Lock_allocator();
11736b: ff 35 e0 2a 14 00 pushl 0x142ae0 117371: e8 32 24 00 00 call 1197a8 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
117376: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117379: 8d 45 f4 lea -0xc(%ebp),%eax 11737c: 50 push %eax 11737d: ff 75 08 pushl 0x8(%ebp) 117380: 68 40 29 14 00 push $0x142940 117385: e8 16 3f 00 00 call 11b2a0 <_Objects_Get_no_protection>
switch ( location ) {
11738a: 83 c4 10 add $0x10,%esp 11738d: 8b 5d f4 mov -0xc(%ebp),%ebx 117390: 85 db test %ebx,%ebx
117392: 74 1c je 1173b0 <rtems_region_delete+0x4c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117394: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
117399: 83 ec 0c sub $0xc,%esp 11739c: ff 35 e0 2a 14 00 pushl 0x142ae0 1173a2: e8 49 24 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status; }
1173a7: 89 d8 mov %ebx,%eax 1173a9: 8b 5d fc mov -0x4(%ebp),%ebx 1173ac: c9 leave 1173ad: c3 ret 1173ae: 66 90 xchg %ax,%ax
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 5 );
if ( the_region->number_of_used_blocks != 0 )
1173b0: 8b 48 64 mov 0x64(%eax),%ecx 1173b3: 85 c9 test %ecx,%ecx
1173b5: 74 09 je 1173c0 <rtems_region_delete+0x5c>
return_status = RTEMS_RESOURCE_IN_USE;
1173b7: bb 0c 00 00 00 mov $0xc,%ebx 1173bc: eb db jmp 117399 <rtems_region_delete+0x35> 1173be: 66 90 xchg %ax,%ax
else {
_Objects_Close( &_Region_Information, &the_region->Object );
1173c0: 83 ec 08 sub $0x8,%esp 1173c3: 50 push %eax 1173c4: 68 40 29 14 00 push $0x142940 1173c9: 89 45 e4 mov %eax,-0x1c(%ebp) 1173cc: e8 97 3a 00 00 call 11ae68 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
1173d1: 58 pop %eax 1173d2: 5a pop %edx 1173d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1173d6: 50 push %eax 1173d7: 68 40 29 14 00 push $0x142940 1173dc: e8 7f 3d 00 00 call 11b160 <_Objects_Free> 1173e1: 83 c4 10 add $0x10,%esp
_Region_Free( the_region );
return_status = RTEMS_SUCCESSFUL;
1173e4: 31 db xor %ebx,%ebx 1173e6: eb b1 jmp 117399 <rtems_region_delete+0x35>
001173e8 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
1173e8: 55 push %ebp 1173e9: 89 e5 mov %esp,%ebp 1173eb: 56 push %esi 1173ec: 53 push %ebx 1173ed: 83 ec 10 sub $0x10,%esp 1173f0: 8b 5d 0c mov 0xc(%ebp),%ebx
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
1173f3: 85 db test %ebx,%ebx
1173f5: 74 75 je 11746c <rtems_region_extend+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
1173f7: 83 ec 0c sub $0xc,%esp 1173fa: ff 35 e0 2a 14 00 pushl 0x142ae0 117400: e8 a3 23 00 00 call 1197a8 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
117405: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117408: 8d 45 f0 lea -0x10(%ebp),%eax 11740b: 50 push %eax 11740c: ff 75 08 pushl 0x8(%ebp) 11740f: 68 40 29 14 00 push $0x142940 117414: e8 87 3e 00 00 call 11b2a0 <_Objects_Get_no_protection> 117419: 89 c6 mov %eax,%esi
switch ( location ) {
11741b: 83 c4 10 add $0x10,%esp 11741e: 8b 45 f0 mov -0x10(%ebp),%eax 117421: 85 c0 test %eax,%eax
117423: 74 1f je 117444 <rtems_region_extend+0x5c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117425: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
11742a: 83 ec 0c sub $0xc,%esp 11742d: ff 35 e0 2a 14 00 pushl 0x142ae0 117433: e8 b8 23 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
117438: 83 c4 10 add $0x10,%esp
}
11743b: 89 d8 mov %ebx,%eax 11743d: 8d 65 f8 lea -0x8(%ebp),%esp 117440: 5b pop %ebx 117441: 5e pop %esi 117442: c9 leave 117443: c3 ret
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
117444: 8d 45 f4 lea -0xc(%ebp),%eax 117447: 50 push %eax 117448: ff 75 10 pushl 0x10(%ebp) 11744b: 53 push %ebx 11744c: 8d 46 68 lea 0x68(%esi),%eax 11744f: 50 push %eax 117450: e8 97 2f 00 00 call 11a3ec <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
117455: 83 c4 10 add $0x10,%esp 117458: 84 c0 test %al,%al
11745a: 74 20 je 11747c <rtems_region_extend+0x94>
the_region->length += amount_extended;
11745c: 8b 45 f4 mov -0xc(%ebp),%eax 11745f: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
117462: 01 46 5c add %eax,0x5c(%esi)
return_status = RTEMS_SUCCESSFUL;
117465: 31 db xor %ebx,%ebx 117467: eb c1 jmp 11742a <rtems_region_extend+0x42> 117469: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
11746c: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117471: 89 d8 mov %ebx,%eax 117473: 8d 65 f8 lea -0x8(%ebp),%esp 117476: 5b pop %ebx 117477: 5e pop %esi 117478: c9 leave 117479: c3 ret 11747a: 66 90 xchg %ax,%ax
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
11747c: bb 09 00 00 00 mov $0x9,%ebx 117481: eb a7 jmp 11742a <rtems_region_extend+0x42>
00117484 <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
117484: 55 push %ebp 117485: 89 e5 mov %esp,%ebp 117487: 53 push %ebx 117488: 83 ec 14 sub $0x14,%esp 11748b: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
11748e: 85 db test %ebx,%ebx
117490: 74 76 je 117508 <rtems_region_get_free_information+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
117492: 83 ec 0c sub $0xc,%esp 117495: ff 35 e0 2a 14 00 pushl 0x142ae0 11749b: e8 08 23 00 00 call 1197a8 <_API_Mutex_Lock> 1174a0: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1174a3: 8d 45 f4 lea -0xc(%ebp),%eax 1174a6: 50 push %eax 1174a7: ff 75 08 pushl 0x8(%ebp) 1174aa: 68 40 29 14 00 push $0x142940 1174af: e8 ec 3d 00 00 call 11b2a0 <_Objects_Get_no_protection>
switch ( location ) {
1174b4: 83 c4 10 add $0x10,%esp 1174b7: 8b 55 f4 mov -0xc(%ebp),%edx 1174ba: 85 d2 test %edx,%edx
1174bc: 74 1e je 1174dc <rtems_region_get_free_information+0x58>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
1174be: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
1174c3: 83 ec 0c sub $0xc,%esp 1174c6: ff 35 e0 2a 14 00 pushl 0x142ae0 1174cc: e8 1f 23 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
1174d1: 83 c4 10 add $0x10,%esp
}
1174d4: 89 d8 mov %ebx,%eax 1174d6: 8b 5d fc mov -0x4(%ebp),%ebx 1174d9: c9 leave 1174da: c3 ret 1174db: 90 nop
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
1174dc: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_info->Used.total = 0;
1174e3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
the_info->Used.largest = 0;
1174ea: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
1174f1: 83 ec 08 sub $0x8,%esp 1174f4: 53 push %ebx 1174f5: 83 c0 68 add $0x68,%eax 1174f8: 50 push %eax 1174f9: e8 d6 32 00 00 call 11a7d4 <_Heap_Get_free_information>
return_status = RTEMS_SUCCESSFUL;
break;
1174fe: 83 c4 10 add $0x10,%esp
the_info->Used.total = 0;
the_info->Used.largest = 0;
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
return_status = RTEMS_SUCCESSFUL;
117501: 31 db xor %ebx,%ebx
break;
117503: eb be jmp 1174c3 <rtems_region_get_free_information+0x3f> 117505: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
117508: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11750d: 89 d8 mov %ebx,%eax 11750f: 8b 5d fc mov -0x4(%ebp),%ebx 117512: c9 leave 117513: c3 ret
0011758c <rtems_region_get_segment>:
uintptr_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
11758c: 55 push %ebp 11758d: 89 e5 mov %esp,%ebp 11758f: 57 push %edi 117590: 56 push %esi 117591: 53 push %ebx 117592: 83 ec 2c sub $0x2c,%esp 117595: 8b 75 0c mov 0xc(%ebp),%esi 117598: 8b 5d 18 mov 0x18(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
11759b: 85 db test %ebx,%ebx
11759d: 0f 84 a1 00 00 00 je 117644 <rtems_region_get_segment+0xb8>
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
1175a3: c7 03 00 00 00 00 movl $0x0,(%ebx)
if ( size == 0 )
1175a9: 85 f6 test %esi,%esi
1175ab: 75 0f jne 1175bc <rtems_region_get_segment+0x30>
return RTEMS_INVALID_SIZE;
1175ad: b8 08 00 00 00 mov $0x8,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1175b2: 8d 65 f4 lea -0xc(%ebp),%esp 1175b5: 5b pop %ebx 1175b6: 5e pop %esi 1175b7: 5f pop %edi 1175b8: c9 leave 1175b9: c3 ret 1175ba: 66 90 xchg %ax,%ax
*segment = NULL;
if ( size == 0 )
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
1175bc: 83 ec 0c sub $0xc,%esp 1175bf: ff 35 e0 2a 14 00 pushl 0x142ae0 1175c5: e8 de 21 00 00 call 1197a8 <_API_Mutex_Lock>
executing = _Thread_Executing;
1175ca: a1 d8 2f 14 00 mov 0x142fd8,%eax 1175cf: 89 45 d4 mov %eax,-0x2c(%ebp) 1175d2: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1175d5: 8d 45 e4 lea -0x1c(%ebp),%eax 1175d8: 50 push %eax 1175d9: ff 75 08 pushl 0x8(%ebp) 1175dc: 68 40 29 14 00 push $0x142940 1175e1: e8 ba 3c 00 00 call 11b2a0 <_Objects_Get_no_protection> 1175e6: 89 c7 mov %eax,%edi
switch ( location ) {
1175e8: 83 c4 10 add $0x10,%esp 1175eb: 8b 45 e4 mov -0x1c(%ebp),%eax 1175ee: 85 c0 test %eax,%eax
1175f0: 75 2a jne 11761c <rtems_region_get_segment+0x90>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
1175f2: 3b 77 5c cmp 0x5c(%edi),%esi
1175f5: 76 2d jbe 117624 <rtems_region_get_segment+0x98>
return_status = RTEMS_INVALID_SIZE;
1175f7: b8 08 00 00 00 mov $0x8,%eax
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1175fc: 83 ec 0c sub $0xc,%esp 1175ff: ff 35 e0 2a 14 00 pushl 0x142ae0 117605: 89 45 d0 mov %eax,-0x30(%ebp) 117608: e8 e3 21 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
11760d: 83 c4 10 add $0x10,%esp 117610: 8b 45 d0 mov -0x30(%ebp),%eax
}
117613: 8d 65 f4 lea -0xc(%ebp),%esp 117616: 5b pop %ebx 117617: 5e pop %esi 117618: 5f pop %edi 117619: c9 leave 11761a: c3 ret 11761b: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
11761c: b8 04 00 00 00 mov $0x4,%eax 117621: eb d9 jmp 1175fc <rtems_region_get_segment+0x70> 117623: 90 nop
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
117624: 6a 00 push $0x0 117626: 6a 00 push $0x0 117628: 56 push %esi
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
117629: 8d 47 68 lea 0x68(%edi),%eax 11762c: 50 push %eax 11762d: e8 e6 2b 00 00 call 11a218 <_Heap_Allocate_aligned_with_boundary>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
117632: 83 c4 10 add $0x10,%esp 117635: 85 c0 test %eax,%eax
117637: 74 17 je 117650 <rtems_region_get_segment+0xc4>
the_region->number_of_used_blocks += 1;
117639: ff 47 64 incl 0x64(%edi)
*segment = the_segment;
11763c: 89 03 mov %eax,(%ebx)
return_status = RTEMS_SUCCESSFUL;
11763e: 31 c0 xor %eax,%eax 117640: eb ba jmp 1175fc <rtems_region_get_segment+0x70> 117642: 66 90 xchg %ax,%ax
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
return RTEMS_INVALID_ADDRESS;
117644: b8 09 00 00 00 mov $0x9,%eax 117649: e9 64 ff ff ff jmp 1175b2 <rtems_region_get_segment+0x26> 11764e: 66 90 xchg %ax,%ax
if ( the_segment ) {
the_region->number_of_used_blocks += 1;
*segment = the_segment;
return_status = RTEMS_SUCCESSFUL;
} else if ( _Options_Is_no_wait( option_set ) ) {
117650: f6 45 10 01 testb $0x1,0x10(%ebp)
117654: 74 07 je 11765d <rtems_region_get_segment+0xd1>
return_status = RTEMS_UNSATISFIED;
117656: b8 0d 00 00 00 mov $0xd,%eax 11765b: eb 9f jmp 1175fc <rtems_region_get_segment+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
11765d: a1 30 2a 14 00 mov 0x142a30,%eax 117662: 40 inc %eax 117663: a3 30 2a 14 00 mov %eax,0x142a30
* Switch from using the memory allocation mutex to using a
* dispatching disabled critical section. We have to do this
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
117668: 83 ec 0c sub $0xc,%esp 11766b: ff 35 e0 2a 14 00 pushl 0x142ae0 117671: e8 7a 21 00 00 call 1197f0 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
117676: 8d 47 10 lea 0x10(%edi),%eax 117679: 8b 55 d4 mov -0x2c(%ebp),%edx 11767c: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
11767f: 8b 4d 08 mov 0x8(%ebp),%ecx 117682: 89 4a 20 mov %ecx,0x20(%edx)
executing->Wait.count = size;
117685: 89 72 24 mov %esi,0x24(%edx)
executing->Wait.return_argument = segment;
117688: 89 5a 28 mov %ebx,0x28(%edx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
11768b: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi)
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
117692: 83 c4 0c add $0xc,%esp 117695: 68 24 c6 11 00 push $0x11c624 11769a: ff 75 14 pushl 0x14(%ebp) 11769d: 50 push %eax 11769e: e8 55 4c 00 00 call 11c2f8 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
1176a3: e8 ac 47 00 00 call 11be54 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
1176a8: 8b 55 d4 mov -0x2c(%ebp),%edx 1176ab: 8b 42 34 mov 0x34(%edx),%eax 1176ae: 83 c4 10 add $0x10,%esp 1176b1: e9 fc fe ff ff jmp 1175b2 <rtems_region_get_segment+0x26>
0011776c <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
11776c: 55 push %ebp 11776d: 89 e5 mov %esp,%ebp 11776f: 56 push %esi 117770: 53 push %ebx 117771: 83 ec 20 sub $0x20,%esp 117774: 8b 5d 14 mov 0x14(%ebp),%ebx
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
117777: 85 db test %ebx,%ebx
117779: 0f 84 89 00 00 00 je 117808 <rtems_region_resize_segment+0x9c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
11777f: 83 ec 0c sub $0xc,%esp 117782: ff 35 e0 2a 14 00 pushl 0x142ae0 117788: e8 1b 20 00 00 call 1197a8 <_API_Mutex_Lock> 11778d: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117790: 8d 45 f0 lea -0x10(%ebp),%eax 117793: 50 push %eax 117794: ff 75 08 pushl 0x8(%ebp) 117797: 68 40 29 14 00 push $0x142940 11779c: e8 ff 3a 00 00 call 11b2a0 <_Objects_Get_no_protection> 1177a1: 89 c6 mov %eax,%esi
switch ( location ) {
1177a3: 83 c4 10 add $0x10,%esp 1177a6: 8b 45 f0 mov -0x10(%ebp),%eax 1177a9: 85 c0 test %eax,%eax
1177ab: 74 1f je 1177cc <rtems_region_resize_segment+0x60>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1177ad: 83 ec 0c sub $0xc,%esp 1177b0: ff 35 e0 2a 14 00 pushl 0x142ae0 1177b6: e8 35 20 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
1177bb: 83 c4 10 add $0x10,%esp 1177be: b8 04 00 00 00 mov $0x4,%eax
}
1177c3: 8d 65 f8 lea -0x8(%ebp),%esp 1177c6: 5b pop %ebx 1177c7: 5e pop %esi 1177c8: c9 leave 1177c9: c3 ret 1177ca: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
1177cc: 83 ec 0c sub $0xc,%esp 1177cf: 8d 45 f4 lea -0xc(%ebp),%eax 1177d2: 50 push %eax 1177d3: 8d 45 ec lea -0x14(%ebp),%eax 1177d6: 50 push %eax 1177d7: ff 75 10 pushl 0x10(%ebp) 1177da: ff 75 0c pushl 0xc(%ebp) 1177dd: 8d 46 68 lea 0x68(%esi),%eax 1177e0: 50 push %eax 1177e1: e8 1a 34 00 00 call 11ac00 <_Heap_Resize_block>
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
1177e6: 8b 55 ec mov -0x14(%ebp),%edx 1177e9: 89 13 mov %edx,(%ebx)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
1177eb: 83 c4 20 add $0x20,%esp 1177ee: 85 c0 test %eax,%eax
1177f0: 75 22 jne 117814 <rtems_region_resize_segment+0xa8>
_Region_Process_queue( the_region ); /* unlocks allocator */
1177f2: 83 ec 0c sub $0xc,%esp 1177f5: 56 push %esi 1177f6: e8 d5 7c 00 00 call 11f4d0 <_Region_Process_queue> 1177fb: 83 c4 10 add $0x10,%esp
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
1177fe: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117800: 8d 65 f8 lea -0x8(%ebp),%esp 117803: 5b pop %ebx 117804: 5e pop %esi 117805: c9 leave 117806: c3 ret 117807: 90 nop
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
117808: b8 09 00 00 00 mov $0x9,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11780d: 8d 65 f8 lea -0x8(%ebp),%esp 117810: 5b pop %ebx 117811: 5e pop %esi 117812: c9 leave 117813: c3 ret
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
117814: 83 ec 0c sub $0xc,%esp 117817: ff 35 e0 2a 14 00 pushl 0x142ae0 11781d: 89 45 e4 mov %eax,-0x1c(%ebp) 117820: e8 cb 1f 00 00 call 1197f0 <_API_Mutex_Unlock>
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
117825: 83 c4 10 add $0x10,%esp
return RTEMS_UNSATISFIED;
117828: 8b 45 e4 mov -0x1c(%ebp),%eax 11782b: 48 dec %eax 11782c: 0f 94 c0 sete %al 11782f: 0f b6 c0 movzbl %al,%eax 117832: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117839: 8d 65 f8 lea -0x8(%ebp),%esp 11783c: 5b pop %ebx 11783d: 5e pop %esi 11783e: c9 leave 11783f: c3 ret
00117840 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
117840: 55 push %ebp 117841: 89 e5 mov %esp,%ebp 117843: 53 push %ebx 117844: 83 ec 20 sub $0x20,%esp
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
117847: ff 35 e0 2a 14 00 pushl 0x142ae0 11784d: e8 56 1f 00 00 call 1197a8 <_API_Mutex_Lock> 117852: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117855: 8d 45 f4 lea -0xc(%ebp),%eax 117858: 50 push %eax 117859: ff 75 08 pushl 0x8(%ebp) 11785c: 68 40 29 14 00 push $0x142940 117861: e8 3a 3a 00 00 call 11b2a0 <_Objects_Get_no_protection> 117866: 89 c3 mov %eax,%ebx
switch ( location ) {
117868: 83 c4 10 add $0x10,%esp 11786b: 8b 45 f4 mov -0xc(%ebp),%eax 11786e: 85 c0 test %eax,%eax
117870: 75 1e jne 117890 <rtems_region_return_segment+0x50>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
117872: 83 ec 08 sub $0x8,%esp 117875: ff 75 0c pushl 0xc(%ebp) 117878: 8d 43 68 lea 0x68(%ebx),%eax 11787b: 50 push %eax 11787c: e8 03 2e 00 00 call 11a684 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
117881: 83 c4 10 add $0x10,%esp 117884: 84 c0 test %al,%al
117886: 75 28 jne 1178b0 <rtems_region_return_segment+0x70>
return_status = RTEMS_INVALID_ADDRESS;
117888: bb 09 00 00 00 mov $0x9,%ebx 11788d: eb 06 jmp 117895 <rtems_region_return_segment+0x55> 11788f: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117890: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
117895: 83 ec 0c sub $0xc,%esp 117898: ff 35 e0 2a 14 00 pushl 0x142ae0 11789e: e8 4d 1f 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
1178a3: 83 c4 10 add $0x10,%esp
}
1178a6: 89 d8 mov %ebx,%eax 1178a8: 8b 5d fc mov -0x4(%ebp),%ebx 1178ab: c9 leave 1178ac: c3 ret 1178ad: 8d 76 00 lea 0x0(%esi),%esi
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
1178b0: ff 4b 64 decl 0x64(%ebx)
_Region_Process_queue(the_region); /* unlocks allocator */
1178b3: 83 ec 0c sub $0xc,%esp 1178b6: 53 push %ebx 1178b7: e8 14 7c 00 00 call 11f4d0 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
1178bc: 83 c4 10 add $0x10,%esp 1178bf: 31 db xor %ebx,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1178c1: 89 d8 mov %ebx,%eax 1178c3: 8b 5d fc mov -0x4(%ebp),%ebx 1178c6: c9 leave 1178c7: c3 ret
0010b434 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
10b434: 55 push %ebp 10b435: 89 e5 mov %esp,%ebp 10b437: 57 push %edi 10b438: 56 push %esi 10b439: 53 push %ebx 10b43a: 83 ec 3c sub $0x3c,%esp 10b43d: 8b 75 08 mov 0x8(%ebp),%esi 10b440: 8b 5d 10 mov 0x10(%ebp),%ebx 10b443: 8b 7d 18 mov 0x18(%ebp),%edi
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
10b446: 85 f6 test %esi,%esi
10b448: 74 4a je 10b494 <rtems_semaphore_create+0x60>
return RTEMS_INVALID_NAME;
if ( !id )
10b44a: 85 ff test %edi,%edi
10b44c: 0f 84 f6 00 00 00 je 10b548 <rtems_semaphore_create+0x114>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10b452: 89 da mov %ebx,%edx 10b454: 81 e2 c0 00 00 00 and $0xc0,%edx
10b45a: 74 48 je 10b4a4 <rtems_semaphore_create+0x70>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
10b45c: 89 d8 mov %ebx,%eax 10b45e: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10b461: 83 f8 10 cmp $0x10,%eax
10b464: 74 0e je 10b474 <rtems_semaphore_create+0x40>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
10b466: b8 0b 00 00 00 mov $0xb,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b46b: 8d 65 f4 lea -0xc(%ebp),%esp 10b46e: 5b pop %ebx 10b46f: 5e pop %esi 10b470: 5f pop %edi 10b471: c9 leave 10b472: c3 ret 10b473: 90 nop
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10b474: f6 c3 04 test $0x4,%bl
10b477: 74 ed je 10b466 <rtems_semaphore_create+0x32>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
10b479: 81 fa c0 00 00 00 cmp $0xc0,%edx
10b47f: 74 e5 je 10b466 <rtems_semaphore_create+0x32>
10b481: b9 10 00 00 00 mov $0x10,%ecx
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10b486: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10b48a: 76 1f jbe 10b4ab <rtems_semaphore_create+0x77>
return RTEMS_INVALID_NUMBER;
10b48c: b8 0a 00 00 00 mov $0xa,%eax 10b491: eb d8 jmp 10b46b <rtems_semaphore_create+0x37> 10b493: 90 nop
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b494: b8 03 00 00 00 mov $0x3,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b499: 8d 65 f4 lea -0xc(%ebp),%esp 10b49c: 5b pop %ebx 10b49d: 5e pop %esi 10b49e: 5f pop %edi 10b49f: c9 leave 10b4a0: c3 ret 10b4a1: 8d 76 00 lea 0x0(%esi),%esi
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10b4a4: 89 d9 mov %ebx,%ecx 10b4a6: 83 e1 30 and $0x30,%ecx
10b4a9: 75 db jne 10b486 <rtems_semaphore_create+0x52>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4ab: a1 90 7d 12 00 mov 0x127d90,%eax 10b4b0: 40 inc %eax 10b4b1: a3 90 7d 12 00 mov %eax,0x127d90
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
10b4b6: 83 ec 0c sub $0xc,%esp 10b4b9: 68 e0 7c 12 00 push $0x127ce0 10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp) 10b4c1: e8 be 14 00 00 call 10c984 <_Objects_Allocate> 10b4c6: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
10b4c8: 83 c4 10 add $0x10,%esp 10b4cb: 85 c0 test %eax,%eax 10b4cd: 8b 4d c4 mov -0x3c(%ebp),%ecx
10b4d0: 0f 84 ba 00 00 00 je 10b590 <rtems_semaphore_create+0x15c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
10b4d6: 89 58 10 mov %ebx,0x10(%eax)
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
10b4d9: 85 c9 test %ecx,%ecx
10b4db: 74 77 je 10b554 <rtems_semaphore_create+0x120>
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
10b4dd: 31 c0 xor %eax,%eax 10b4df: f6 c3 04 test $0x4,%bl 10b4e2: 0f 95 c0 setne %al 10b4e5: 89 45 d8 mov %eax,-0x28(%ebp)
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
10b4e8: 83 f9 10 cmp $0x10,%ecx
10b4eb: 0f 84 ae 00 00 00 je 10b59f <rtems_semaphore_create+0x16b>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
10b4f1: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10b4f8: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
}
mutex_status = _CORE_mutex_Initialize(
10b4fc: 50 push %eax 10b4fd: 31 c0 xor %eax,%eax 10b4ff: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b503: 0f 94 c0 sete %al 10b506: 50 push %eax 10b507: 8d 45 d0 lea -0x30(%ebp),%eax 10b50a: 50 push %eax 10b50b: 8d 42 14 lea 0x14(%edx),%eax 10b50e: 50 push %eax 10b50f: 89 55 c4 mov %edx,-0x3c(%ebp) 10b512: e8 65 0c 00 00 call 10c17c <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
10b517: 83 c4 10 add $0x10,%esp 10b51a: 83 f8 06 cmp $0x6,%eax 10b51d: 8b 55 c4 mov -0x3c(%ebp),%edx
10b520: 0f 84 a9 00 00 00 je 10b5cf <rtems_semaphore_create+0x19b>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b526: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b529: 0f b7 d8 movzwl %ax,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b52c: 8b 0d fc 7c 12 00 mov 0x127cfc,%ecx 10b532: 89 14 99 mov %edx,(%ecx,%ebx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b535: 89 72 0c mov %esi,0xc(%edx)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
10b538: 89 07 mov %eax,(%edi)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
10b53a: e8 71 24 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b53f: 31 c0 xor %eax,%eax 10b541: e9 25 ff ff ff jmp 10b46b <rtems_semaphore_create+0x37> 10b546: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b548: b8 09 00 00 00 mov $0x9,%eax 10b54d: e9 19 ff ff ff jmp 10b46b <rtems_semaphore_create+0x37> 10b552: 66 90 xchg %ax,%ax
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
10b554: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
10b55b: 31 c0 xor %eax,%eax 10b55d: f6 c3 04 test $0x4,%bl 10b560: 0f 95 c0 setne %al 10b563: 89 45 e4 mov %eax,-0x1c(%ebp)
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10b566: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
10b56d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
_CORE_semaphore_Initialize(
10b574: 51 push %ecx 10b575: ff 75 0c pushl 0xc(%ebp) 10b578: 8d 45 e0 lea -0x20(%ebp),%eax 10b57b: 50 push %eax 10b57c: 8d 42 14 lea 0x14(%edx),%eax 10b57f: 50 push %eax 10b580: 89 55 c4 mov %edx,-0x3c(%ebp) 10b583: e8 84 0e 00 00 call 10c40c <_CORE_semaphore_Initialize> 10b588: 83 c4 10 add $0x10,%esp 10b58b: 8b 55 c4 mov -0x3c(%ebp),%edx 10b58e: eb 96 jmp 10b526 <rtems_semaphore_create+0xf2>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
10b590: e8 1b 24 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b595: b8 05 00 00 00 mov $0x5,%eax 10b59a: e9 cc fe ff ff jmp 10b46b <rtems_semaphore_create+0x37>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
10b59f: 8b 45 14 mov 0x14(%ebp),%eax 10b5a2: 89 45 dc mov %eax,-0x24(%ebp)
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10b5a5: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10b5ac: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
10b5b0: 83 7d d8 01 cmpl $0x1,-0x28(%ebp)
10b5b4: 0f 85 42 ff ff ff jne 10b4fc <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
10b5ba: f6 c3 40 test $0x40,%bl
10b5bd: 74 30 je 10b5ef <rtems_semaphore_create+0x1bb>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10b5bf: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10b5c6: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b5ca: e9 2d ff ff ff jmp 10b4fc <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10b5cf: 83 ec 08 sub $0x8,%esp 10b5d2: 52 push %edx 10b5d3: 68 e0 7c 12 00 push $0x127ce0 10b5d8: e8 1b 17 00 00 call 10ccf8 <_Objects_Free>
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
10b5dd: e8 ce 23 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
10b5e2: 83 c4 10 add $0x10,%esp 10b5e5: b8 13 00 00 00 mov $0x13,%eax 10b5ea: e9 7c fe ff ff jmp 10b46b <rtems_semaphore_create+0x37>
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
10b5ef: 81 e3 80 00 00 00 and $0x80,%ebx
10b5f5: 0f 84 01 ff ff ff je 10b4fc <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10b5fb: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10b602: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b606: e9 f1 fe ff ff jmp 10b4fc <rtems_semaphore_create+0xc8>
0010b60c <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
10b60c: 55 push %ebp 10b60d: 89 e5 mov %esp,%ebp 10b60f: 53 push %ebx 10b610: 83 ec 18 sub $0x18,%esp
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
10b613: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10b616: 50 push %eax 10b617: ff 75 08 pushl 0x8(%ebp) 10b61a: 68 e0 7c 12 00 push $0x127ce0 10b61f: e8 14 18 00 00 call 10ce38 <_Objects_Get> 10b624: 89 c3 mov %eax,%ebx
switch ( location ) {
10b626: 83 c4 10 add $0x10,%esp 10b629: 8b 4d f4 mov -0xc(%ebp),%ecx 10b62c: 85 c9 test %ecx,%ecx
10b62e: 74 0c je 10b63c <rtems_semaphore_delete+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b630: b8 04 00 00 00 mov $0x4,%eax
}
10b635: 8b 5d fc mov -0x4(%ebp),%ebx 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
10b63c: 8b 40 10 mov 0x10(%eax),%eax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10b63f: 83 e0 30 and $0x30,%eax
10b642: 74 58 je 10b69c <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
10b644: 8b 53 64 mov 0x64(%ebx),%edx 10b647: 85 d2 test %edx,%edx
10b649: 75 15 jne 10b660 <rtems_semaphore_delete+0x54>
10b64b: 83 f8 20 cmp $0x20,%eax
10b64e: 74 10 je 10b660 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
10b650: e8 5b 23 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b655: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b65a: 8b 5d fc mov -0x4(%ebp),%ebx 10b65d: c9 leave 10b65e: c3 ret 10b65f: 90 nop
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
10b660: 50 push %eax 10b661: 6a 04 push $0x4 10b663: 6a 00 push $0x0 10b665: 8d 43 14 lea 0x14(%ebx),%eax 10b668: 50 push %eax 10b669: e8 02 0b 00 00 call 10c170 <_CORE_mutex_Flush> 10b66e: 83 c4 10 add $0x10,%esp
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
10b671: 83 ec 08 sub $0x8,%esp 10b674: 53 push %ebx 10b675: 68 e0 7c 12 00 push $0x127ce0 10b67a: e8 81 13 00 00 call 10ca00 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10b67f: 58 pop %eax 10b680: 5a pop %edx 10b681: 53 push %ebx 10b682: 68 e0 7c 12 00 push $0x127ce0 10b687: e8 6c 16 00 00 call 10ccf8 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10b68c: e8 1f 23 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b691: 83 c4 10 add $0x10,%esp 10b694: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b696: 8b 5d fc mov -0x4(%ebp),%ebx 10b699: c9 leave 10b69a: c3 ret 10b69b: 90 nop
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
10b69c: 51 push %ecx 10b69d: 6a 02 push $0x2 10b69f: 6a 00 push $0x0 10b6a1: 8d 43 14 lea 0x14(%ebx),%eax 10b6a4: 50 push %eax 10b6a5: e8 56 0d 00 00 call 10c400 <_CORE_semaphore_Flush> 10b6aa: 83 c4 10 add $0x10,%esp 10b6ad: eb c2 jmp 10b671 <rtems_semaphore_delete+0x65>
0010b6b0 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10b6b0: 55 push %ebp 10b6b1: 89 e5 mov %esp,%ebp 10b6b3: 57 push %edi 10b6b4: 56 push %esi 10b6b5: 53 push %ebx 10b6b6: 83 ec 1c sub $0x1c,%esp 10b6b9: 8b 5d 08 mov 0x8(%ebp),%ebx 10b6bc: 8b 75 0c mov 0xc(%ebp),%esi 10b6bf: 8b 7d 10 mov 0x10(%ebp),%edi
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
10b6c2: 8d 45 e0 lea -0x20(%ebp),%eax
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
_Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
10b6c5: 50 push %eax 10b6c6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b6c9: 50 push %eax 10b6ca: 53 push %ebx 10b6cb: 68 e0 7c 12 00 push $0x127ce0 10b6d0: e8 0b 17 00 00 call 10cde0 <_Objects_Get_isr_disable>
switch ( location ) {
10b6d5: 83 c4 10 add $0x10,%esp 10b6d8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b6db: 85 c9 test %ecx,%ecx
10b6dd: 74 0d je 10b6ec <rtems_semaphore_obtain+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b6df: b8 04 00 00 00 mov $0x4,%eax
}
10b6e4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6e7: 5b pop %ebx 10b6e8: 5e pop %esi 10b6e9: 5f pop %edi 10b6ea: c9 leave 10b6eb: c3 ret
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10b6ec: f6 40 10 30 testb $0x30,0x10(%eax)
10b6f0: 74 36 je 10b728 <rtems_semaphore_obtain+0x78>
_CORE_mutex_Seize(
10b6f2: 83 ec 0c sub $0xc,%esp 10b6f5: ff 75 e0 pushl -0x20(%ebp) 10b6f8: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
10b6f9: 83 e6 01 and $0x1,%esi 10b6fc: 83 f6 01 xor $0x1,%esi 10b6ff: 56 push %esi 10b700: 53 push %ebx 10b701: 83 c0 14 add $0x14,%eax 10b704: 50 push %eax 10b705: e8 6a 0b 00 00 call 10c274 <_CORE_mutex_Seize>
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10b70a: 83 c4 14 add $0x14,%esp
_Thread_Executing->Wait.return_code );
10b70d: a1 38 83 12 00 mov 0x128338,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10b712: ff 70 34 pushl 0x34(%eax) 10b715: e8 12 01 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b71a: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10b71d: 8d 65 f4 lea -0xc(%ebp),%esp 10b720: 5b pop %ebx 10b721: 5e pop %esi 10b722: 5f pop %edi 10b723: c9 leave 10b724: c3 ret 10b725: 8d 76 00 lea 0x0(%esi),%esi
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
10b728: 8b 15 38 83 12 00 mov 0x128338,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b72e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( the_semaphore->count != 0 ) {
10b735: 8b 48 5c mov 0x5c(%eax),%ecx 10b738: 85 c9 test %ecx,%ecx
10b73a: 75 2c jne 10b768 <rtems_semaphore_obtain+0xb8>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
10b73c: 83 e6 01 and $0x1,%esi
10b73f: 74 33 je 10b774 <rtems_semaphore_obtain+0xc4>
_ISR_Enable( *level_p );
10b741: ff 75 e0 pushl -0x20(%ebp) 10b744: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
10b745: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx)
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10b74c: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10b74f: a1 38 83 12 00 mov 0x128338,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10b754: ff 70 34 pushl 0x34(%eax) 10b757: e8 e0 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b75c: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10b75f: 8d 65 f4 lea -0xc(%ebp),%esp 10b762: 5b pop %ebx 10b763: 5e pop %esi 10b764: 5f pop %edi 10b765: c9 leave 10b766: c3 ret 10b767: 90 nop
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
10b768: 49 dec %ecx 10b769: 89 48 5c mov %ecx,0x5c(%eax)
_ISR_Enable( *level_p );
10b76c: ff 75 e0 pushl -0x20(%ebp) 10b76f: 9d popf 10b770: eb da jmp 10b74c <rtems_semaphore_obtain+0x9c> 10b772: 66 90 xchg %ax,%ax 10b774: 8b 0d 90 7d 12 00 mov 0x127d90,%ecx 10b77a: 41 inc %ecx 10b77b: 89 0d 90 7d 12 00 mov %ecx,0x127d90
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10b781: c7 40 44 01 00 00 00 movl $0x1,0x44(%eax)
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
10b788: 83 c0 14 add $0x14,%eax 10b78b: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10b78e: 89 5a 20 mov %ebx,0x20(%edx)
_ISR_Enable( *level_p );
10b791: ff 75 e0 pushl -0x20(%ebp) 10b794: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
10b795: 52 push %edx 10b796: 68 80 e1 10 00 push $0x10e180 10b79b: 57 push %edi 10b79c: 50 push %eax 10b79d: e8 b2 26 00 00 call 10de54 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10b7a2: e8 09 22 00 00 call 10d9b0 <_Thread_Enable_dispatch> 10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: eb a0 jmp 10b74c <rtems_semaphore_obtain+0x9c>
0010b7ac <rtems_semaphore_release>:
#endif
rtems_status_code rtems_semaphore_release(
rtems_id id
)
{
10b7ac: 55 push %ebp 10b7ad: 89 e5 mov %esp,%ebp 10b7af: 53 push %ebx 10b7b0: 83 ec 18 sub $0x18,%esp 10b7b3: 8b 5d 08 mov 0x8(%ebp),%ebx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
CORE_mutex_Status mutex_status;
CORE_semaphore_Status semaphore_status;
the_semaphore = _Semaphore_Get( id, &location );
10b7b6: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10b7b9: 50 push %eax 10b7ba: 53 push %ebx 10b7bb: 68 e0 7c 12 00 push $0x127ce0 10b7c0: e8 73 16 00 00 call 10ce38 <_Objects_Get>
switch ( location ) {
10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 8b 55 f4 mov -0xc(%ebp),%edx 10b7cb: 85 d2 test %edx,%edx
10b7cd: 74 0d je 10b7dc <rtems_semaphore_release+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b7cf: b8 04 00 00 00 mov $0x4,%eax
}
10b7d4: 8b 5d fc mov -0x4(%ebp),%ebx 10b7d7: c9 leave 10b7d8: c3 ret 10b7d9: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10b7dc: f6 40 10 30 testb $0x30,0x10(%eax)
10b7e0: 75 26 jne 10b808 <rtems_semaphore_release+0x5c>
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
} else {
semaphore_status = _CORE_semaphore_Surrender(
10b7e2: 52 push %edx 10b7e3: 6a 00 push $0x0 10b7e5: 53 push %ebx 10b7e6: 83 c0 14 add $0x14,%eax 10b7e9: 50 push %eax 10b7ea: e8 5d 0c 00 00 call 10c44c <_CORE_semaphore_Surrender> 10b7ef: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b7f1: e8 ba 21 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return
10b7f6: 89 1c 24 mov %ebx,(%esp) 10b7f9: e8 3e 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b7fe: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b801: 8b 5d fc mov -0x4(%ebp),%ebx 10b804: c9 leave 10b805: c3 ret 10b806: 66 90 xchg %ax,%ax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
mutex_status = _CORE_mutex_Surrender(
10b808: 51 push %ecx 10b809: 6a 00 push $0x0 10b80b: 53 push %ebx 10b80c: 83 c0 14 add $0x14,%eax 10b80f: 50 push %eax 10b810: e8 ff 0a 00 00 call 10c314 <_CORE_mutex_Surrender> 10b815: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b817: e8 94 21 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
10b81c: 89 1c 24 mov %ebx,(%esp) 10b81f: e8 08 00 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b824: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b827: 8b 5d fc mov -0x4(%ebp),%ebx 10b82a: c9 leave 10b82b: c3 ret
00117d60 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
117d60: 55 push %ebp 117d61: 89 e5 mov %esp,%ebp 117d63: 53 push %ebx 117d64: 83 ec 14 sub $0x14,%esp 117d67: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
117d6a: 85 db test %ebx,%ebx
117d6c: 75 0a jne 117d78 <rtems_signal_send+0x18>
return RTEMS_INVALID_NUMBER;
117d6e: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117d73: 8b 5d fc mov -0x4(%ebp),%ebx 117d76: c9 leave 117d77: c3 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
117d78: 83 ec 08 sub $0x8,%esp 117d7b: 8d 45 f4 lea -0xc(%ebp),%eax 117d7e: 50 push %eax 117d7f: ff 75 08 pushl 0x8(%ebp) 117d82: e8 f1 40 00 00 call 11be78 <_Thread_Get>
switch ( location ) {
117d87: 83 c4 10 add $0x10,%esp 117d8a: 8b 55 f4 mov -0xc(%ebp),%edx 117d8d: 85 d2 test %edx,%edx
117d8f: 74 0b je 117d9c <rtems_signal_send+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117d91: b8 04 00 00 00 mov $0x4,%eax
}
117d96: 8b 5d fc mov -0x4(%ebp),%ebx 117d99: c9 leave 117d9a: c3 ret 117d9b: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
117d9c: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
117da2: 8b 4a 0c mov 0xc(%edx),%ecx 117da5: 85 c9 test %ecx,%ecx
117da7: 74 3f je 117de8 <rtems_signal_send+0x88>
if ( asr->is_enabled ) {
117da9: 80 7a 08 00 cmpb $0x0,0x8(%edx)
117dad: 74 25 je 117dd4 <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
117daf: 9c pushf 117db0: fa cli 117db1: 59 pop %ecx
*signal_set |= signals;
117db2: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
117db5: 51 push %ecx 117db6: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
117db7: 8b 15 d4 2f 14 00 mov 0x142fd4,%edx 117dbd: 85 d2 test %edx,%edx
117dbf: 74 1b je 117ddc <rtems_signal_send+0x7c>
117dc1: 3b 05 d8 2f 14 00 cmp 0x142fd8,%eax
117dc7: 75 13 jne 117ddc <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
117dc9: c6 05 e4 2f 14 00 01 movb $0x1,0x142fe4 117dd0: eb 0a jmp 117ddc <rtems_signal_send+0x7c> 117dd2: 66 90 xchg %ax,%ax
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
117dd4: 9c pushf 117dd5: fa cli 117dd6: 58 pop %eax
*signal_set |= signals;
117dd7: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
117dda: 50 push %eax 117ddb: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
117ddc: e8 73 40 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117de1: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117de3: 8b 5d fc mov -0x4(%ebp),%ebx 117de6: c9 leave 117de7: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117de8: e8 67 40 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
117ded: b8 0b 00 00 00 mov $0xb,%eax 117df2: e9 7c ff ff ff jmp 117d73 <rtems_signal_send+0x13>
0010b84c <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
10b84c: 55 push %ebp 10b84d: 89 e5 mov %esp,%ebp 10b84f: 57 push %edi 10b850: 56 push %esi 10b851: 53 push %ebx 10b852: 83 ec 1c sub $0x1c,%esp 10b855: 8b 5d 08 mov 0x8(%ebp),%ebx 10b858: 8b 7d 0c mov 0xc(%ebp),%edi 10b85b: 8b 75 1c mov 0x1c(%ebp),%esi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10b85e: 85 f6 test %esi,%esi
10b860: 0f 84 3e 01 00 00 je 10b9a4 <rtems_task_create+0x158>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10b866: 85 db test %ebx,%ebx
10b868: 0f 84 d2 00 00 00 je 10b940 <rtems_task_create+0xf4>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
10b86e: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp)
10b875: 75 17 jne 10b88e <rtems_task_create+0x42>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10b877: 85 ff test %edi,%edi
10b879: 0f 84 b1 00 00 00 je 10b930 <rtems_task_create+0xe4>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10b87f: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10b886: 39 c7 cmp %eax,%edi
10b888: 0f 87 a2 00 00 00 ja 10b930 <rtems_task_create+0xe4>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b88e: 83 ec 0c sub $0xc,%esp 10b891: ff 35 40 7e 12 00 pushl 0x127e40 10b897: e8 c4 06 00 00 call 10bf60 <_API_Mutex_Lock>
* This function allocates a task control block from
* the inactive chain of free task control blocks.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
10b89c: c7 04 24 20 7d 12 00 movl $0x127d20,(%esp) 10b8a3: e8 dc 10 00 00 call 10c984 <_Objects_Allocate> 10b8a8: 89 c2 mov %eax,%edx
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10b8aa: 83 c4 10 add $0x10,%esp 10b8ad: 85 c0 test %eax,%eax
10b8af: 0f 84 cf 00 00 00 je 10b984 <rtems_task_create+0x138>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10b8b5: 50 push %eax 10b8b6: 53 push %ebx
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
10b8b7: 8b 45 14 mov 0x14(%ebp),%eax 10b8ba: 83 e0 01 and $0x1,%eax 10b8bd: 50 push %eax 10b8be: 6a 00 push $0x0 10b8c0: 31 c0 xor %eax,%eax 10b8c2: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp) 10b8c9: 0f 95 c0 setne %al 10b8cc: 50 push %eax 10b8cd: 31 c0 xor %eax,%eax 10b8cf: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp) 10b8d6: 0f 94 c0 sete %al 10b8d9: 50 push %eax 10b8da: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
10b8db: 8b 45 18 mov 0x18(%ebp),%eax 10b8de: 83 e0 01 and $0x1,%eax 10b8e1: 50 push %eax 10b8e2: ff 75 10 pushl 0x10(%ebp) 10b8e5: 6a 00 push $0x0 10b8e7: 52 push %edx 10b8e8: 68 20 7d 12 00 push $0x127d20 10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp) 10b8f0: e8 53 21 00 00 call 10da48 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
10b8f5: 83 c4 30 add $0x30,%esp 10b8f8: 84 c0 test %al,%al 10b8fa: 8b 55 e4 mov -0x1c(%ebp),%edx
10b8fd: 74 51 je 10b950 <rtems_task_create+0x104>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
10b8ff: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
10b905: f7 45 14 00 04 00 00 testl $0x400,0x14(%ebp)
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
10b90c: 0f 94 40 08 sete 0x8(%eax)
*id = the_thread->Object.id;
10b910: 8b 42 08 mov 0x8(%edx),%eax 10b913: 89 06 mov %eax,(%esi)
);
}
#endif
_RTEMS_Unlock_allocator();
10b915: 83 ec 0c sub $0xc,%esp 10b918: ff 35 40 7e 12 00 pushl 0x127e40 10b91e: e8 85 06 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
10b923: 83 c4 10 add $0x10,%esp 10b926: 31 c0 xor %eax,%eax
}
10b928: 8d 65 f4 lea -0xc(%ebp),%esp 10b92b: 5b pop %ebx 10b92c: 5e pop %esi 10b92d: 5f pop %edi 10b92e: c9 leave 10b92f: c3 ret
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
return RTEMS_INVALID_PRIORITY;
10b930: b8 13 00 00 00 mov $0x13,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b935: 8d 65 f4 lea -0xc(%ebp),%esp 10b938: 5b pop %ebx 10b939: 5e pop %esi 10b93a: 5f pop %edi 10b93b: c9 leave 10b93c: c3 ret 10b93d: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b940: b8 03 00 00 00 mov $0x3,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b945: 8d 65 f4 lea -0xc(%ebp),%esp 10b948: 5b pop %ebx 10b949: 5e pop %esi 10b94a: 5f pop %edi 10b94b: c9 leave 10b94c: c3 ret 10b94d: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
10b950: 83 ec 0c sub $0xc,%esp 10b953: ff 72 08 pushl 0x8(%edx) 10b956: e8 0d 14 00 00 call 10cd68 <_Objects_Get_information_id> 10b95b: 5a pop %edx 10b95c: 59 pop %ecx 10b95d: 8b 55 e4 mov -0x1c(%ebp),%edx 10b960: 52 push %edx 10b961: 50 push %eax 10b962: e8 91 13 00 00 call 10ccf8 <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10b967: 58 pop %eax 10b968: ff 35 40 7e 12 00 pushl 0x127e40 10b96e: e8 35 06 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
10b973: 83 c4 10 add $0x10,%esp 10b976: b8 0d 00 00 00 mov $0xd,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b97b: 8d 65 f4 lea -0xc(%ebp),%esp 10b97e: 5b pop %ebx 10b97f: 5e pop %esi 10b980: 5f pop %edi 10b981: c9 leave 10b982: c3 ret 10b983: 90 nop
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10b984: 83 ec 0c sub $0xc,%esp 10b987: ff 35 40 7e 12 00 pushl 0x127e40 10b98d: e8 16 06 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
10b992: 83 c4 10 add $0x10,%esp 10b995: b8 05 00 00 00 mov $0x5,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b99a: 8d 65 f4 lea -0xc(%ebp),%esp 10b99d: 5b pop %ebx 10b99e: 5e pop %esi 10b99f: 5f pop %edi 10b9a0: c9 leave 10b9a1: c3 ret 10b9a2: 66 90 xchg %ax,%ax
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b9a4: b8 09 00 00 00 mov $0x9,%eax 10b9a9: eb 8a jmp 10b935 <rtems_task_create+0xe9>
0010b9ac <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 53 push %ebx 10b9b0: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
10b9b3: ff 35 40 7e 12 00 pushl 0x127e40 10b9b9: e8 a2 05 00 00 call 10bf60 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
10b9be: 5a pop %edx 10b9bf: 59 pop %ecx 10b9c0: 8d 45 f4 lea -0xc(%ebp),%eax 10b9c3: 50 push %eax 10b9c4: ff 75 08 pushl 0x8(%ebp) 10b9c7: e8 08 20 00 00 call 10d9d4 <_Thread_Get> 10b9cc: 89 c3 mov %eax,%ebx
switch ( location ) {
10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 8b 45 f4 mov -0xc(%ebp),%eax 10b9d4: 85 c0 test %eax,%eax
10b9d6: 75 44 jne 10ba1c <rtems_task_delete+0x70>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
10b9d8: 83 ec 0c sub $0xc,%esp 10b9db: ff 73 08 pushl 0x8(%ebx) 10b9de: e8 85 13 00 00 call 10cd68 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
10b9e3: 5a pop %edx 10b9e4: 59 pop %ecx 10b9e5: 53 push %ebx 10b9e6: 50 push %eax 10b9e7: e8 9c 1c 00 00 call 10d688 <_Thread_Close> 10b9ec: 58 pop %eax 10b9ed: ff 73 08 pushl 0x8(%ebx) 10b9f0: e8 73 13 00 00 call 10cd68 <_Objects_Get_information_id> 10b9f5: 5a pop %edx 10b9f6: 59 pop %ecx 10b9f7: 53 push %ebx 10b9f8: 50 push %eax 10b9f9: e8 fa 12 00 00 call 10ccf8 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10b9fe: 58 pop %eax 10b9ff: ff 35 40 7e 12 00 pushl 0x127e40 10ba05: e8 9e 05 00 00 call 10bfa8 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10ba0a: e8 a1 1f 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ba0f: 83 c4 10 add $0x10,%esp 10ba12: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
10ba14: 8b 5d fc mov -0x4(%ebp),%ebx 10ba17: c9 leave 10ba18: c3 ret 10ba19: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
10ba1c: 83 ec 0c sub $0xc,%esp 10ba1f: ff 35 40 7e 12 00 pushl 0x127e40 10ba25: e8 7e 05 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_INVALID_ID;
10ba2a: 83 c4 10 add $0x10,%esp 10ba2d: b8 04 00 00 00 mov $0x4,%eax
}
10ba32: 8b 5d fc mov -0x4(%ebp),%ebx 10ba35: c9 leave 10ba36: c3 ret
0010d4e4 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
10d4e4: 55 push %ebp 10d4e5: 89 e5 mov %esp,%ebp 10d4e7: 56 push %esi 10d4e8: 53 push %ebx 10d4e9: 83 ec 10 sub $0x10,%esp 10d4ec: 8b 45 08 mov 0x8(%ebp),%eax 10d4ef: 8b 75 0c mov 0xc(%ebp),%esi 10d4f2: 8b 5d 10 mov 0x10(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10d4f5: 80 3d 04 79 12 00 00 cmpb $0x0,0x127904
10d4fc: 74 6e je 10d56c <rtems_task_get_note+0x88>
return RTEMS_NOT_CONFIGURED;
if ( !note )
10d4fe: 85 db test %ebx,%ebx
10d500: 74 7e je 10d580 <rtems_task_get_note+0x9c>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10d502: 83 fe 0f cmp $0xf,%esi
10d505: 77 3d ja 10d544 <rtems_task_get_note+0x60>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d507: 85 c0 test %eax,%eax
10d509: 74 45 je 10d550 <rtems_task_get_note+0x6c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d50b: 8b 15 38 c5 12 00 mov 0x12c538,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d511: 3b 42 08 cmp 0x8(%edx),%eax
10d514: 74 40 je 10d556 <rtems_task_get_note+0x72>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10d516: 83 ec 08 sub $0x8,%esp 10d519: 8d 55 f4 lea -0xc(%ebp),%edx 10d51c: 52 push %edx 10d51d: 50 push %eax 10d51e: e8 f9 22 00 00 call 10f81c <_Thread_Get>
switch ( location ) {
10d523: 83 c4 10 add $0x10,%esp 10d526: 8b 55 f4 mov -0xc(%ebp),%edx 10d529: 85 d2 test %edx,%edx
10d52b: 75 4b jne 10d578 <rtems_task_get_note+0x94>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10d52d: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10d533: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d537: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10d539: e8 ba 22 00 00 call 10f7f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d53e: 31 c0 xor %eax,%eax 10d540: eb 07 jmp 10d549 <rtems_task_get_note+0x65> 10d542: 66 90 xchg %ax,%ax
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
return RTEMS_INVALID_NUMBER;
10d544: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d549: 8d 65 f8 lea -0x8(%ebp),%esp 10d54c: 5b pop %ebx 10d54d: 5e pop %esi 10d54e: c9 leave 10d54f: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d550: 8b 15 38 c5 12 00 mov 0x12c538,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10d556: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10d55c: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d560: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
10d562: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d564: 8d 65 f8 lea -0x8(%ebp),%esp 10d567: 5b pop %ebx 10d568: 5e pop %esi 10d569: c9 leave 10d56a: c3 ret 10d56b: 90 nop
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10d56c: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d571: 8d 65 f8 lea -0x8(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: c9 leave 10d577: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d578: b8 04 00 00 00 mov $0x4,%eax 10d57d: eb ca jmp 10d549 <rtems_task_get_note+0x65> 10d57f: 90 nop
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
return RTEMS_INVALID_ADDRESS;
10d580: b8 09 00 00 00 mov $0x9,%eax 10d585: eb c2 jmp 10d549 <rtems_task_get_note+0x65>
00118144 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
118144: 55 push %ebp 118145: 89 e5 mov %esp,%ebp 118147: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
11814a: 8d 45 f4 lea -0xc(%ebp),%eax 11814d: 50 push %eax 11814e: ff 75 08 pushl 0x8(%ebp) 118151: e8 22 3d 00 00 call 11be78 <_Thread_Get>
switch ( location ) {
118156: 83 c4 10 add $0x10,%esp 118159: 8b 55 f4 mov -0xc(%ebp),%edx 11815c: 85 d2 test %edx,%edx
11815e: 74 08 je 118168 <rtems_task_is_suspended+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118160: b8 04 00 00 00 mov $0x4,%eax
}
118165: c9 leave 118166: c3 ret 118167: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
118168: f6 40 10 02 testb $0x2,0x10(%eax)
11816c: 74 0e je 11817c <rtems_task_is_suspended+0x38>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11816e: e8 e1 3c 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
118173: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118178: c9 leave 118179: c3 ret 11817a: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
11817c: e8 d3 3c 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118181: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118183: c9 leave 118184: c3 ret
00112df0 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
112df0: 55 push %ebp 112df1: 89 e5 mov %esp,%ebp 112df3: 57 push %edi 112df4: 56 push %esi 112df5: 53 push %ebx 112df6: 83 ec 1c sub $0x1c,%esp 112df9: 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 )
112dfc: 85 c9 test %ecx,%ecx
112dfe: 0f 84 40 01 00 00 je 112f44 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
112e04: 8b 1d 38 83 12 00 mov 0x128338,%ebx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
112e0a: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
112e10: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 112e14: 19 f6 sbb %esi,%esi 112e16: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
112e1c: 8b 53 7c mov 0x7c(%ebx),%edx 112e1f: 85 d2 test %edx,%edx
112e21: 0f 85 f1 00 00 00 jne 112f18 <rtems_task_mode+0x128>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
112e27: 80 7f 08 01 cmpb $0x1,0x8(%edi) 112e2b: 19 d2 sbb %edx,%edx 112e2d: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
112e33: 89 55 e4 mov %edx,-0x1c(%ebp) 112e36: 89 4d e0 mov %ecx,-0x20(%ebp) 112e39: e8 4e bf ff ff call 10ed8c <_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;
112e3e: 8b 55 e4 mov -0x1c(%ebp),%edx 112e41: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
112e43: 09 f0 or %esi,%eax 112e45: 8b 4d e0 mov -0x20(%ebp),%ecx 112e48: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
112e4a: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
112e51: 74 0b je 112e5e <rtems_task_mode+0x6e>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
112e53: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 112e5a: 0f 94 43 74 sete 0x74(%ebx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
112e5e: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
112e65: 74 1c je 112e83 <rtems_task_mode+0x93>
if ( _Modes_Is_timeslice(mode_set) ) {
112e67: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
112e6e: 0f 84 b8 00 00 00 je 112f2c <rtems_task_mode+0x13c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
112e74: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
112e7b: a1 60 7d 12 00 mov 0x127d60,%eax 112e80: 89 43 78 mov %eax,0x78(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112e83: f6 45 0c 01 testb $0x1,0xc(%ebp)
112e87: 74 0b je 112e94 <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 ) );
112e89: f6 45 08 01 testb $0x1,0x8(%ebp)
112e8d: 0f 84 91 00 00 00 je 112f24 <rtems_task_mode+0x134>
112e93: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
112e94: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
112e9b: 74 3f je 112edc <rtems_task_mode+0xec>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
112e9d: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 112ea4: 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 ) {
112ea7: 38 47 08 cmp %al,0x8(%edi)
112eaa: 74 30 je 112edc <rtems_task_mode+0xec>
asr->is_enabled = is_asr_enabled;
112eac: 88 47 08 mov %al,0x8(%edi)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
112eaf: 9c pushf 112eb0: fa cli 112eb1: 58 pop %eax
_signals = information->signals_pending;
112eb2: 8b 57 18 mov 0x18(%edi),%edx
information->signals_pending = information->signals_posted;
112eb5: 8b 4f 14 mov 0x14(%edi),%ecx 112eb8: 89 4f 18 mov %ecx,0x18(%edi)
information->signals_posted = _signals;
112ebb: 89 57 14 mov %edx,0x14(%edi)
_ISR_Enable( _level );
112ebe: 50 push %eax 112ebf: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112ec0: 8b 47 14 mov 0x14(%edi),%eax 112ec3: 85 c0 test %eax,%eax 112ec5: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112ec8: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
112ecf: 74 16 je 112ee7 <rtems_task_mode+0xf7> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
112ed1: 31 c0 xor %eax,%eax
}
112ed3: 83 c4 1c add $0x1c,%esp 112ed6: 5b pop %ebx 112ed7: 5e pop %esi 112ed8: 5f pop %edi 112ed9: c9 leave 112eda: c3 ret 112edb: 90 nop
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112edc: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112ede: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
112ee5: 75 ea jne 112ed1 <rtems_task_mode+0xe1> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
112ee7: 8b 15 38 83 12 00 mov 0x128338,%edx
if ( are_signals_pending ||
112eed: 84 c0 test %al,%al
112eef: 75 0e jne 112eff <rtems_task_mode+0x10f>
112ef1: 3b 15 3c 83 12 00 cmp 0x12833c,%edx
112ef7: 74 d8 je 112ed1 <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
112ef9: 80 7a 74 00 cmpb $0x0,0x74(%edx)
112efd: 74 d2 je 112ed1 <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
112eff: c6 05 44 83 12 00 01 movb $0x1,0x128344
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
112f06: e8 2d a9 ff ff call 10d838 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
112f0b: 31 c0 xor %eax,%eax
}
112f0d: 83 c4 1c add $0x1c,%esp 112f10: 5b pop %ebx 112f11: 5e pop %esi 112f12: 5f pop %edi 112f13: c9 leave 112f14: c3 ret 112f15: 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;
112f18: 81 ce 00 02 00 00 or $0x200,%esi 112f1e: e9 04 ff ff ff jmp 112e27 <rtems_task_mode+0x37> 112f23: 90 nop 112f24: fb sti 112f25: e9 6a ff ff ff jmp 112e94 <rtems_task_mode+0xa4> 112f2a: 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;
112f2c: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112f33: f6 45 0c 01 testb $0x1,0xc(%ebp)
112f37: 0f 84 57 ff ff ff je 112e94 <rtems_task_mode+0xa4>
112f3d: e9 47 ff ff ff jmp 112e89 <rtems_task_mode+0x99> 112f42: 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;
112f44: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
112f49: 83 c4 1c add $0x1c,%esp 112f4c: 5b pop %ebx 112f4d: 5e pop %esi 112f4e: 5f pop %edi 112f4f: c9 leave 112f50: c3 ret
0010ecdc <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
10ecdc: 55 push %ebp 10ecdd: 89 e5 mov %esp,%ebp 10ecdf: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ece2: 8d 45 f4 lea -0xc(%ebp),%eax 10ece5: 50 push %eax 10ece6: ff 75 08 pushl 0x8(%ebp) 10ece9: e8 1e 20 00 00 call 110d0c <_Thread_Get>
switch ( location ) {
10ecee: 83 c4 10 add $0x10,%esp 10ecf1: 8b 55 f4 mov -0xc(%ebp),%edx 10ecf4: 85 d2 test %edx,%edx
10ecf6: 74 08 je 10ed00 <rtems_task_resume+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ecf8: b8 04 00 00 00 mov $0x4,%eax
}
10ecfd: c9 leave 10ecfe: c3 ret 10ecff: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
10ed00: f6 40 10 02 testb $0x2,0x10(%eax)
10ed04: 75 0e jne 10ed14 <rtems_task_resume+0x38>
_Thread_Resume( the_thread, true );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10ed06: e8 dd 1f 00 00 call 110ce8 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10ed0b: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed10: c9 leave 10ed11: c3 ret 10ed12: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread, true );
10ed14: 83 ec 08 sub $0x8,%esp 10ed17: 6a 01 push $0x1 10ed19: 50 push %eax 10ed1a: e8 d1 27 00 00 call 1114f0 <_Thread_Resume>
_Thread_Enable_dispatch();
10ed1f: e8 c4 1f 00 00 call 110ce8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ed24: 83 c4 10 add $0x10,%esp 10ed27: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed29: c9 leave 10ed2a: c3 ret
0010d65c <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
10d65c: 55 push %ebp 10d65d: 89 e5 mov %esp,%ebp 10d65f: 56 push %esi 10d660: 53 push %ebx 10d661: 83 ec 10 sub $0x10,%esp 10d664: 8b 45 08 mov 0x8(%ebp),%eax 10d667: 8b 5d 0c mov 0xc(%ebp),%ebx 10d66a: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10d66d: 80 3d 04 79 12 00 00 cmpb $0x0,0x127904
10d674: 74 66 je 10d6dc <rtems_task_set_note+0x80>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10d676: 83 fb 0f cmp $0xf,%ebx
10d679: 77 39 ja 10d6b4 <rtems_task_set_note+0x58>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d67b: 85 c0 test %eax,%eax
10d67d: 74 41 je 10d6c0 <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d67f: 8b 15 38 c5 12 00 mov 0x12c538,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d685: 3b 42 08 cmp 0x8(%edx),%eax
10d688: 74 3c je 10d6c6 <rtems_task_set_note+0x6a>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10d68a: 83 ec 08 sub $0x8,%esp 10d68d: 8d 55 f4 lea -0xc(%ebp),%edx 10d690: 52 push %edx 10d691: 50 push %eax 10d692: e8 85 21 00 00 call 10f81c <_Thread_Get>
switch ( location ) {
10d697: 83 c4 10 add $0x10,%esp 10d69a: 8b 55 f4 mov -0xc(%ebp),%edx 10d69d: 85 d2 test %edx,%edx
10d69f: 75 47 jne 10d6e8 <rtems_task_set_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10d6a1: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax 10d6a7: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10d6ab: e8 48 21 00 00 call 10f7f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d6b0: 31 c0 xor %eax,%eax 10d6b2: eb 05 jmp 10d6b9 <rtems_task_set_note+0x5d>
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
return RTEMS_INVALID_NUMBER;
10d6b4: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10d6bc: 5b pop %ebx 10d6bd: 5e pop %esi 10d6be: c9 leave 10d6bf: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d6c0: 8b 15 38 c5 12 00 mov 0x12c538,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10d6c6: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax 10d6cc: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
return RTEMS_SUCCESSFUL;
10d6d0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6d2: 8d 65 f8 lea -0x8(%ebp),%esp 10d6d5: 5b pop %ebx 10d6d6: 5e pop %esi 10d6d7: c9 leave 10d6d8: c3 ret 10d6d9: 8d 76 00 lea 0x0(%esi),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10d6dc: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6e1: 8d 65 f8 lea -0x8(%ebp),%esp 10d6e4: 5b pop %ebx 10d6e5: 5e pop %esi 10d6e6: c9 leave 10d6e7: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d6e8: b8 04 00 00 00 mov $0x4,%eax
}
10d6ed: 8d 65 f8 lea -0x8(%ebp),%esp 10d6f0: 5b pop %ebx 10d6f1: 5e pop %esi 10d6f2: c9 leave 10d6f3: c3 ret
0010f9a0 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10f9a0: 55 push %ebp 10f9a1: 89 e5 mov %esp,%ebp 10f9a3: 56 push %esi 10f9a4: 53 push %ebx 10f9a5: 83 ec 10 sub $0x10,%esp 10f9a8: 8b 5d 0c mov 0xc(%ebp),%ebx 10f9ab: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10f9ae: 85 db test %ebx,%ebx
10f9b0: 74 0b je 10f9bd <rtems_task_set_priority+0x1d>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10f9b2: 0f b6 05 34 7a 12 00 movzbl 0x127a34,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10f9b9: 39 c3 cmp %eax,%ebx
10f9bb: 77 5f ja 10fa1c <rtems_task_set_priority+0x7c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10f9bd: 85 f6 test %esi,%esi
10f9bf: 74 67 je 10fa28 <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10f9c1: 83 ec 08 sub $0x8,%esp 10f9c4: 8d 45 f4 lea -0xc(%ebp),%eax 10f9c7: 50 push %eax 10f9c8: ff 75 08 pushl 0x8(%ebp) 10f9cb: e8 7c 21 00 00 call 111b4c <_Thread_Get>
switch ( location ) {
10f9d0: 83 c4 10 add $0x10,%esp 10f9d3: 8b 55 f4 mov -0xc(%ebp),%edx 10f9d6: 85 d2 test %edx,%edx
10f9d8: 75 36 jne 10fa10 <rtems_task_set_priority+0x70>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10f9da: 8b 50 14 mov 0x14(%eax),%edx 10f9dd: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10f9df: 85 db test %ebx,%ebx
10f9e1: 74 1c je 10f9ff <rtems_task_set_priority+0x5f>
the_thread->real_priority = new_priority;
10f9e3: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10f9e6: 8b 48 1c mov 0x1c(%eax),%ecx 10f9e9: 85 c9 test %ecx,%ecx
10f9eb: 74 05 je 10f9f2 <rtems_task_set_priority+0x52>
10f9ed: 3b 58 14 cmp 0x14(%eax),%ebx
10f9f0: 73 0d jae 10f9ff <rtems_task_set_priority+0x5f><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10f9f2: 52 push %edx 10f9f3: 6a 00 push $0x0 10f9f5: 53 push %ebx 10f9f6: 50 push %eax 10f9f7: e8 f4 1c 00 00 call 1116f0 <_Thread_Change_priority> 10f9fc: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10f9ff: e8 24 21 00 00 call 111b28 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10fa04: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa06: 8d 65 f8 lea -0x8(%ebp),%esp 10fa09: 5b pop %ebx 10fa0a: 5e pop %esi 10fa0b: c9 leave 10fa0c: c3 ret 10fa0d: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10fa10: b8 04 00 00 00 mov $0x4,%eax
}
10fa15: 8d 65 f8 lea -0x8(%ebp),%esp 10fa18: 5b pop %ebx 10fa19: 5e pop %esi 10fa1a: c9 leave 10fa1b: c3 ret
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10fa1c: b8 13 00 00 00 mov $0x13,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa21: 8d 65 f8 lea -0x8(%ebp),%esp 10fa24: 5b pop %ebx 10fa25: 5e pop %esi 10fa26: c9 leave 10fa27: c3 ret
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10fa28: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa2d: 8d 65 f8 lea -0x8(%ebp),%esp 10fa30: 5b pop %ebx 10fa31: 5e pop %esi 10fa32: c9 leave 10fa33: c3 ret
0010baf4 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
10baf4: 55 push %ebp 10baf5: 89 e5 mov %esp,%ebp 10baf7: 53 push %ebx 10baf8: 83 ec 14 sub $0x14,%esp 10bafb: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10bafe: 85 db test %ebx,%ebx
10bb00: 74 4e je 10bb50 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10bb02: 83 ec 08 sub $0x8,%esp 10bb05: 8d 45 f4 lea -0xc(%ebp),%eax 10bb08: 50 push %eax 10bb09: ff 75 08 pushl 0x8(%ebp) 10bb0c: e8 c3 1e 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10bb11: 83 c4 10 add $0x10,%esp 10bb14: 8b 55 f4 mov -0xc(%ebp),%edx 10bb17: 85 d2 test %edx,%edx
10bb19: 75 29 jne 10bb44 <rtems_task_start+0x50>
case OBJECTS_LOCAL:
if ( _Thread_Start(
10bb1b: 83 ec 0c sub $0xc,%esp 10bb1e: ff 75 10 pushl 0x10(%ebp) 10bb21: 6a 00 push $0x0 10bb23: 53 push %ebx 10bb24: 6a 00 push $0x0 10bb26: 50 push %eax 10bb27: e8 0c 28 00 00 call 10e338 <_Thread_Start> 10bb2c: 83 c4 20 add $0x20,%esp 10bb2f: 84 c0 test %al,%al
10bb31: 75 29 jne 10bb5c <rtems_task_start+0x68>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10bb33: e8 78 1e 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10bb38: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb3d: 8b 5d fc mov -0x4(%ebp),%ebx 10bb40: c9 leave 10bb41: c3 ret 10bb42: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb44: b8 04 00 00 00 mov $0x4,%eax
}
10bb49: 8b 5d fc mov -0x4(%ebp),%ebx 10bb4c: c9 leave 10bb4d: c3 ret 10bb4e: 66 90 xchg %ax,%ax
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
10bb50: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb55: 8b 5d fc mov -0x4(%ebp),%ebx 10bb58: c9 leave 10bb59: c3 ret 10bb5a: 66 90 xchg %ax,%ax
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
10bb5c: e8 4f 1e 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bb61: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb63: 8b 5d fc mov -0x4(%ebp),%ebx 10bb66: c9 leave 10bb67: c3 ret
00110f70 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
110f70: 55 push %ebp 110f71: 89 e5 mov %esp,%ebp 110f73: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
110f76: 8d 45 f4 lea -0xc(%ebp),%eax 110f79: 50 push %eax 110f7a: ff 75 08 pushl 0x8(%ebp) 110f7d: e8 52 ca ff ff call 10d9d4 <_Thread_Get>
switch ( location ) {
110f82: 83 c4 10 add $0x10,%esp 110f85: 8b 55 f4 mov -0xc(%ebp),%edx 110f88: 85 d2 test %edx,%edx
110f8a: 74 08 je 110f94 <rtems_task_suspend+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
110f8c: b8 04 00 00 00 mov $0x4,%eax
}
110f91: c9 leave 110f92: c3 ret 110f93: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
110f94: f6 40 10 02 testb $0x2,0x10(%eax)
110f98: 74 0e je 110fa8 <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
110f9a: e8 11 ca ff ff call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
110f9f: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110fa4: c9 leave 110fa5: c3 ret 110fa6: 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 );
110fa8: 83 ec 0c sub $0xc,%esp 110fab: 50 push %eax 110fac: e8 27 09 00 00 call 1118d8 <_Thread_Suspend>
_Thread_Enable_dispatch();
110fb1: e8 fa c9 ff ff call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
110fb6: 83 c4 10 add $0x10,%esp 110fb9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110fbb: c9 leave 110fbc: c3 ret
0010c650 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10c650: 55 push %ebp 10c651: 89 e5 mov %esp,%ebp 10c653: 57 push %edi 10c654: 56 push %esi 10c655: 53 push %ebx 10c656: 83 ec 1c sub $0x1c,%esp 10c659: 8b 5d 0c mov 0xc(%ebp),%ebx 10c65c: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10c65f: 85 db test %ebx,%ebx
10c661: 0f 84 9d 00 00 00 je 10c704 <rtems_task_variable_add+0xb4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10c667: 83 ec 08 sub $0x8,%esp 10c66a: 8d 45 e4 lea -0x1c(%ebp),%eax 10c66d: 50 push %eax 10c66e: ff 75 08 pushl 0x8(%ebp) 10c671: e8 6e 20 00 00 call 10e6e4 <_Thread_Get> 10c676: 89 c6 mov %eax,%esi
switch (location) {
10c678: 83 c4 10 add $0x10,%esp 10c67b: 8b 45 e4 mov -0x1c(%ebp),%eax 10c67e: 85 c0 test %eax,%eax
10c680: 74 0e je 10c690 <rtems_task_variable_add+0x40>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c682: b8 04 00 00 00 mov $0x4,%eax
}
10c687: 8d 65 f4 lea -0xc(%ebp),%esp 10c68a: 5b pop %ebx 10c68b: 5e pop %esi 10c68c: 5f pop %edi 10c68d: c9 leave 10c68e: c3 ret 10c68f: 90 nop
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10c690: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
while (tvp) {
10c696: 85 c0 test %eax,%eax
10c698: 75 44 jne 10c6de <rtems_task_variable_add+0x8e>
10c69a: 66 90 xchg %ax,%ax
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
10c69c: 83 ec 0c sub $0xc,%esp 10c69f: 6a 14 push $0x14 10c6a1: e8 f2 2f 00 00 call 10f698 <_Workspace_Allocate>
if (new == NULL) {
10c6a6: 83 c4 10 add $0x10,%esp 10c6a9: 85 c0 test %eax,%eax
10c6ab: 74 4b je 10c6f8 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10c6ad: 8b 13 mov (%ebx),%edx 10c6af: 89 50 08 mov %edx,0x8(%eax)
new->ptr = ptr;
10c6b2: 89 58 04 mov %ebx,0x4(%eax)
new->dtor = dtor;
10c6b5: 89 78 10 mov %edi,0x10(%eax)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10c6b8: 8b 96 f4 00 00 00 mov 0xf4(%esi),%edx 10c6be: 89 10 mov %edx,(%eax)
the_thread->task_variables = new;
10c6c0: 89 86 f4 00 00 00 mov %eax,0xf4(%esi)
_Thread_Enable_dispatch();
10c6c6: e8 f5 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6cb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6cd: 8d 65 f4 lea -0xc(%ebp),%esp 10c6d0: 5b pop %ebx 10c6d1: 5e pop %esi 10c6d2: 5f pop %edi 10c6d3: c9 leave 10c6d4: c3 ret 10c6d5: 8d 76 00 lea 0x0(%esi),%esi
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10c6d8: 8b 00 mov (%eax),%eax
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
10c6da: 85 c0 test %eax,%eax
10c6dc: 74 be je 10c69c <rtems_task_variable_add+0x4c>
if (tvp->ptr == ptr) {
10c6de: 39 58 04 cmp %ebx,0x4(%eax)
10c6e1: 75 f5 jne 10c6d8 <rtems_task_variable_add+0x88>
tvp->dtor = dtor;
10c6e3: 89 78 10 mov %edi,0x10(%eax)
_Thread_Enable_dispatch();
10c6e6: e8 d5 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6eb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6ed: 8d 65 f4 lea -0xc(%ebp),%esp 10c6f0: 5b pop %ebx 10c6f1: 5e pop %esi 10c6f2: 5f pop %edi 10c6f3: c9 leave 10c6f4: c3 ret 10c6f5: 8d 76 00 lea 0x0(%esi),%esi
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
10c6f8: e8 c3 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
10c6fd: b8 1a 00 00 00 mov $0x1a,%eax 10c702: eb 83 jmp 10c687 <rtems_task_variable_add+0x37>
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10c704: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c709: 8d 65 f4 lea -0xc(%ebp),%esp 10c70c: 5b pop %ebx 10c70d: 5e pop %esi 10c70e: 5f pop %edi 10c70f: c9 leave 10c710: c3 ret
0010c714 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10c714: 55 push %ebp 10c715: 89 e5 mov %esp,%ebp 10c717: 53 push %ebx 10c718: 83 ec 14 sub $0x14,%esp 10c71b: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10c71e: 85 db test %ebx,%ebx
10c720: 74 76 je 10c798 <rtems_task_variable_delete+0x84>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10c722: 83 ec 08 sub $0x8,%esp 10c725: 8d 45 f4 lea -0xc(%ebp),%eax 10c728: 50 push %eax 10c729: ff 75 08 pushl 0x8(%ebp) 10c72c: e8 b3 1f 00 00 call 10e6e4 <_Thread_Get>
switch (location) {
10c731: 83 c4 10 add $0x10,%esp 10c734: 8b 55 f4 mov -0xc(%ebp),%edx 10c737: 85 d2 test %edx,%edx
10c739: 74 0d je 10c748 <rtems_task_variable_delete+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c73b: b8 04 00 00 00 mov $0x4,%eax
}
10c740: 8b 5d fc mov -0x4(%ebp),%ebx 10c743: c9 leave 10c744: c3 ret 10c745: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10c748: 8b 88 f4 00 00 00 mov 0xf4(%eax),%ecx
while (tvp) {
10c74e: 85 c9 test %ecx,%ecx
10c750: 74 17 je 10c769 <rtems_task_variable_delete+0x55>
if (tvp->ptr == ptr) {
10c752: 39 59 04 cmp %ebx,0x4(%ecx)
10c755: 75 0c jne 10c763 <rtems_task_variable_delete+0x4f>
10c757: eb 49 jmp 10c7a2 <rtems_task_variable_delete+0x8e> 10c759: 8d 76 00 lea 0x0(%esi),%esi 10c75c: 39 5a 04 cmp %ebx,0x4(%edx)
10c75f: 74 17 je 10c778 <rtems_task_variable_delete+0x64>
10c761: 89 d1 mov %edx,%ecx
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
10c763: 8b 11 mov (%ecx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10c765: 85 d2 test %edx,%edx
10c767: 75 f3 jne 10c75c <rtems_task_variable_delete+0x48><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10c769: e8 52 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10c76e: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c773: 8b 5d fc mov -0x4(%ebp),%ebx 10c776: c9 leave 10c777: c3 ret
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
10c778: 8b 1a mov (%edx),%ebx 10c77a: 89 19 mov %ebx,(%ecx)
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
10c77c: 83 ec 08 sub $0x8,%esp 10c77f: 52 push %edx 10c780: 50 push %eax 10c781: e8 b2 00 00 00 call 10c838 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10c786: e8 35 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c78b: 83 c4 10 add $0x10,%esp 10c78e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c790: 8b 5d fc mov -0x4(%ebp),%ebx 10c793: c9 leave 10c794: c3 ret 10c795: 8d 76 00 lea 0x0(%esi),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10c798: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c79d: 8b 5d fc mov -0x4(%ebp),%ebx 10c7a0: c9 leave 10c7a1: c3 ret
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
10c7a2: 8b 11 mov (%ecx),%edx 10c7a4: 89 90 f4 00 00 00 mov %edx,0xf4(%eax) 10c7aa: 89 ca mov %ecx,%edx 10c7ac: eb ce jmp 10c77c <rtems_task_variable_delete+0x68>
0010c7b0 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10c7b0: 55 push %ebp 10c7b1: 89 e5 mov %esp,%ebp 10c7b3: 56 push %esi 10c7b4: 53 push %ebx 10c7b5: 83 ec 10 sub $0x10,%esp 10c7b8: 8b 5d 0c mov 0xc(%ebp),%ebx 10c7bb: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10c7be: 85 db test %ebx,%ebx
10c7c0: 74 56 je 10c818 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10c7c2: 85 f6 test %esi,%esi
10c7c4: 74 52 je 10c818 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10c7c6: 83 ec 08 sub $0x8,%esp 10c7c9: 8d 45 f4 lea -0xc(%ebp),%eax 10c7cc: 50 push %eax 10c7cd: ff 75 08 pushl 0x8(%ebp) 10c7d0: e8 0f 1f 00 00 call 10e6e4 <_Thread_Get>
switch (location) {
10c7d5: 83 c4 10 add $0x10,%esp 10c7d8: 8b 55 f4 mov -0xc(%ebp),%edx 10c7db: 85 d2 test %edx,%edx
10c7dd: 75 2d jne 10c80c <rtems_task_variable_get+0x5c>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10c7df: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
10c7e5: 85 c0 test %eax,%eax
10c7e7: 75 09 jne 10c7f2 <rtems_task_variable_get+0x42>
10c7e9: eb 39 jmp 10c824 <rtems_task_variable_get+0x74> 10c7eb: 90 nop
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10c7ec: 8b 00 mov (%eax),%eax
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
10c7ee: 85 c0 test %eax,%eax
10c7f0: 74 32 je 10c824 <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10c7f2: 39 58 04 cmp %ebx,0x4(%eax)
10c7f5: 75 f5 jne 10c7ec <rtems_task_variable_get+0x3c>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
10c7f7: 8b 40 0c mov 0xc(%eax),%eax 10c7fa: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c7fc: e8 bf 1e 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c801: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c803: 8d 65 f8 lea -0x8(%ebp),%esp 10c806: 5b pop %ebx 10c807: 5e pop %esi 10c808: c9 leave 10c809: c3 ret 10c80a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c80c: b8 04 00 00 00 mov $0x4,%eax
}
10c811: 8d 65 f8 lea -0x8(%ebp),%esp 10c814: 5b pop %ebx 10c815: 5e pop %esi 10c816: c9 leave 10c817: c3 ret
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
10c818: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c81d: 8d 65 f8 lea -0x8(%ebp),%esp 10c820: 5b pop %ebx 10c821: 5e pop %esi 10c822: c9 leave 10c823: c3 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10c824: e8 97 1e 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10c829: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c82e: 8d 65 f8 lea -0x8(%ebp),%esp 10c831: 5b pop %ebx 10c832: 5e pop %esi 10c833: c9 leave 10c834: c3 ret
0010c9c0 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10c9c0: 55 push %ebp 10c9c1: 89 e5 mov %esp,%ebp 10c9c3: 53 push %ebx 10c9c4: 83 ec 14 sub $0x14,%esp 10c9c7: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10c9ca: 80 3d c4 aa 12 00 00 cmpb $0x0,0x12aac4
10c9d1: 0f 84 a9 00 00 00 je 10ca80 <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10c9d7: 85 db test %ebx,%ebx
10c9d9: 0f 84 ad 00 00 00 je 10ca8c <rtems_task_wake_when+0xcc>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10c9df: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10c9e6: 83 ec 0c sub $0xc,%esp 10c9e9: 53 push %ebx 10c9ea: e8 d1 f3 ff ff call 10bdc0 <_TOD_Validate> 10c9ef: 83 c4 10 add $0x10,%esp 10c9f2: 84 c0 test %al,%al
10c9f4: 75 0a jne 10ca00 <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;
10c9f6: b8 14 00 00 00 mov $0x14,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c9fb: 8b 5d fc mov -0x4(%ebp),%ebx 10c9fe: c9 leave 10c9ff: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10ca00: 83 ec 0c sub $0xc,%esp 10ca03: 53 push %ebx 10ca04: e8 2b f3 ff ff call 10bd34 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
10ca09: 83 c4 10 add $0x10,%esp 10ca0c: 3b 05 48 ab 12 00 cmp 0x12ab48,%eax
10ca12: 76 e2 jbe 10c9f6 <rtems_task_wake_when+0x36>
10ca14: 8b 15 b0 aa 12 00 mov 0x12aab0,%edx 10ca1a: 42 inc %edx 10ca1b: 89 15 b0 aa 12 00 mov %edx,0x12aab0
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10ca21: 83 ec 08 sub $0x8,%esp 10ca24: 6a 10 push $0x10 10ca26: ff 35 58 b0 12 00 pushl 0x12b058 10ca2c: 89 45 f4 mov %eax,-0xc(%ebp) 10ca2f: e8 ec 26 00 00 call 10f120 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
10ca34: 8b 15 58 b0 12 00 mov 0x12b058,%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(
10ca3a: 8b 4a 08 mov 0x8(%edx),%ecx
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10ca3d: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
10ca44: c7 42 64 4c e7 10 00 movl $0x10e74c,0x64(%edx)
the_watchdog->id = id;
10ca4b: 89 4a 68 mov %ecx,0x68(%edx)
the_watchdog->user_data = user_data;
10ca4e: 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(
10ca55: 8b 45 f4 mov -0xc(%ebp),%eax 10ca58: 2b 05 48 ab 12 00 sub 0x12ab48,%eax 10ca5e: 89 42 54 mov %eax,0x54(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
10ca61: 58 pop %eax 10ca62: 59 pop %ecx 10ca63: 83 c2 48 add $0x48,%edx 10ca66: 52 push %edx 10ca67: 68 74 ab 12 00 push $0x12ab74 10ca6c: e8 77 2c 00 00 call 10f6e8 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
10ca71: e8 8a 1e 00 00 call 10e900 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca76: 83 c4 10 add $0x10,%esp 10ca79: 31 c0 xor %eax,%eax 10ca7b: e9 7b ff ff ff jmp 10c9fb <rtems_task_wake_when+0x3b>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
10ca80: b8 0b 00 00 00 mov $0xb,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca85: 8b 5d fc mov -0x4(%ebp),%ebx 10ca88: c9 leave 10ca89: c3 ret 10ca8a: 66 90 xchg %ax,%ax
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10ca8c: b8 09 00 00 00 mov $0x9,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca91: 8b 5d fc mov -0x4(%ebp),%ebx 10ca94: c9 leave 10ca95: c3 ret
001186d4 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1186d4: 55 push %ebp 1186d5: 89 e5 mov %esp,%ebp 1186d7: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1186da: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1186dd: 50 push %eax 1186de: ff 75 08 pushl 0x8(%ebp) 1186e1: 68 60 34 14 00 push $0x143460 1186e6: e8 f1 2b 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1186eb: 83 c4 10 add $0x10,%esp 1186ee: 8b 55 f4 mov -0xc(%ebp),%edx 1186f1: 85 d2 test %edx,%edx
1186f3: 74 07 je 1186fc <rtems_timer_cancel+0x28>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1186f5: b8 04 00 00 00 mov $0x4,%eax
}
1186fa: c9 leave 1186fb: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1186fc: 83 78 38 04 cmpl $0x4,0x38(%eax)
118700: 74 0f je 118711 <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
118702: 83 ec 0c sub $0xc,%esp 118705: 83 c0 10 add $0x10,%eax 118708: 50 push %eax 118709: e8 82 48 00 00 call 11cf90 <_Watchdog_Remove> 11870e: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
118711: e8 3e 37 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118716: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118718: c9 leave 118719: c3 ret
0010bff0 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
10bff0: 55 push %ebp 10bff1: 89 e5 mov %esp,%ebp 10bff3: 57 push %edi 10bff4: 56 push %esi 10bff5: 53 push %ebx 10bff6: 83 ec 0c sub $0xc,%esp 10bff9: 8b 5d 08 mov 0x8(%ebp),%ebx 10bffc: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10bfff: 85 db test %ebx,%ebx
10c001: 74 6d je 10c070 <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10c003: 85 f6 test %esi,%esi
10c005: 0f 84 89 00 00 00 je 10c094 <rtems_timer_create+0xa4>
10c00b: a1 10 98 12 00 mov 0x129810,%eax 10c010: 40 inc %eax 10c011: a3 10 98 12 00 mov %eax,0x129810
* 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 );
10c016: 83 ec 0c sub $0xc,%esp 10c019: 68 40 a2 12 00 push $0x12a240 10c01e: e8 31 0f 00 00 call 10cf54 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10c023: 83 c4 10 add $0x10,%esp 10c026: 85 c0 test %eax,%eax
10c028: 74 56 je 10c080 <rtems_timer_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10c02a: 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;
10c031: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c038: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10c03f: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10c046: 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 ),
10c04d: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c050: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c053: 8b 0d 5c a2 12 00 mov 0x12a25c,%ecx 10c059: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c05c: 89 58 0c mov %ebx,0xc(%eax)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10c05f: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10c061: e8 1a 1f 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c066: 31 c0 xor %eax,%eax
}
10c068: 8d 65 f4 lea -0xc(%ebp),%esp 10c06b: 5b pop %ebx 10c06c: 5e pop %esi 10c06d: 5f pop %edi 10c06e: c9 leave 10c06f: c3 ret
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c070: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c075: 8d 65 f4 lea -0xc(%ebp),%esp 10c078: 5b pop %ebx 10c079: 5e pop %esi 10c07a: 5f pop %edi 10c07b: c9 leave 10c07c: c3 ret 10c07d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
10c080: e8 fb 1e 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c085: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c08a: 8d 65 f4 lea -0xc(%ebp),%esp 10c08d: 5b pop %ebx 10c08e: 5e pop %esi 10c08f: 5f pop %edi 10c090: c9 leave 10c091: c3 ret 10c092: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c094: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c099: 8d 65 f4 lea -0xc(%ebp),%esp 10c09c: 5b pop %ebx 10c09d: 5e pop %esi 10c09e: 5f pop %edi 10c09f: c9 leave 10c0a0: c3 ret
001187d0 <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
rtems_id id
)
{
1187d0: 55 push %ebp 1187d1: 89 e5 mov %esp,%ebp 1187d3: 53 push %ebx 1187d4: 83 ec 18 sub $0x18,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1187d7: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1187da: 50 push %eax 1187db: ff 75 08 pushl 0x8(%ebp) 1187de: 68 60 34 14 00 push $0x143460 1187e3: e8 f4 2a 00 00 call 11b2dc <_Objects_Get> 1187e8: 89 c3 mov %eax,%ebx
switch ( location ) {
1187ea: 83 c4 10 add $0x10,%esp 1187ed: 8b 4d f4 mov -0xc(%ebp),%ecx 1187f0: 85 c9 test %ecx,%ecx
1187f2: 75 38 jne 11882c <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
1187f4: 83 ec 08 sub $0x8,%esp 1187f7: 50 push %eax 1187f8: 68 60 34 14 00 push $0x143460 1187fd: e8 66 26 00 00 call 11ae68 <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
118802: 8d 43 10 lea 0x10(%ebx),%eax 118805: 89 04 24 mov %eax,(%esp) 118808: e8 83 47 00 00 call 11cf90 <_Watchdog_Remove>
*/
RTEMS_INLINE_ROUTINE void _Timer_Free (
Timer_Control *the_timer
)
{
_Objects_Free( &_Timer_Information, &the_timer->Object );
11880d: 58 pop %eax 11880e: 5a pop %edx 11880f: 53 push %ebx 118810: 68 60 34 14 00 push $0x143460 118815: e8 46 29 00 00 call 11b160 <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
11881a: e8 35 36 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11881f: 83 c4 10 add $0x10,%esp 118822: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118824: 8b 5d fc mov -0x4(%ebp),%ebx 118827: c9 leave 118828: c3 ret 118829: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11882c: b8 04 00 00 00 mov $0x4,%eax
}
118831: 8b 5d fc mov -0x4(%ebp),%ebx 118834: c9 leave 118835: c3 ret
0010c0a4 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10c0a4: 55 push %ebp 10c0a5: 89 e5 mov %esp,%ebp 10c0a7: 57 push %edi 10c0a8: 56 push %esi 10c0a9: 53 push %ebx 10c0aa: 83 ec 2c sub $0x2c,%esp 10c0ad: 8b 5d 0c mov 0xc(%ebp),%ebx 10c0b0: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10c0b3: 85 db test %ebx,%ebx
10c0b5: 0f 84 99 00 00 00 je 10c154 <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10c0bb: 85 f6 test %esi,%esi
10c0bd: 0f 84 b1 00 00 00 je 10c174 <rtems_timer_fire_after+0xd0>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
10c0c3: 57 push %edi
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
10c0c4: 8d 45 e4 lea -0x1c(%ebp),%eax 10c0c7: 50 push %eax 10c0c8: ff 75 08 pushl 0x8(%ebp) 10c0cb: 68 40 a2 12 00 push $0x12a240 10c0d0: e8 33 13 00 00 call 10d408 <_Objects_Get> 10c0d5: 89 c7 mov %eax,%edi
switch ( location ) {
10c0d7: 83 c4 10 add $0x10,%esp 10c0da: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c0dd: 85 c9 test %ecx,%ecx
10c0df: 74 0f je 10c0f0 <rtems_timer_fire_after+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c0e1: b8 04 00 00 00 mov $0x4,%eax
}
10c0e6: 8d 65 f4 lea -0xc(%ebp),%esp 10c0e9: 5b pop %ebx 10c0ea: 5e pop %esi 10c0eb: 5f pop %edi 10c0ec: c9 leave 10c0ed: c3 ret 10c0ee: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10c0f0: 8d 50 10 lea 0x10(%eax),%edx 10c0f3: 83 ec 0c sub $0xc,%esp 10c0f6: 52 push %edx 10c0f7: 89 55 d4 mov %edx,-0x2c(%ebp) 10c0fa: e8 31 2d 00 00 call 10ee30 <_Watchdog_Remove>
_ISR_Disable( level );
10c0ff: 9c pushf 10c100: fa cli 10c101: 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 ) {
10c102: 83 c4 10 add $0x10,%esp 10c105: 8b 57 18 mov 0x18(%edi),%edx 10c108: 85 d2 test %edx,%edx 10c10a: 8b 55 d4 mov -0x2c(%ebp),%edx
10c10d: 75 55 jne 10c164 <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;
10c10f: 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;
10c116: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10c11d: 89 77 2c mov %esi,0x2c(%edi)
the_watchdog->id = id;
10c120: 8b 4d 08 mov 0x8(%ebp),%ecx 10c123: 89 4f 30 mov %ecx,0x30(%edi)
the_watchdog->user_data = user_data;
10c126: 8b 4d 14 mov 0x14(%ebp),%ecx 10c129: 89 4f 34 mov %ecx,0x34(%edi)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10c12c: 50 push %eax 10c12d: 9d popf
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c12e: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c131: 83 ec 08 sub $0x8,%esp 10c134: 52 push %edx 10c135: 68 e0 98 12 00 push $0x1298e0 10c13a: e8 b1 2b 00 00 call 10ecf0 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10c13f: e8 3c 1e 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c144: 83 c4 10 add $0x10,%esp 10c147: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c149: 8d 65 f4 lea -0xc(%ebp),%esp 10c14c: 5b pop %ebx 10c14d: 5e pop %esi 10c14e: 5f pop %edi 10c14f: c9 leave 10c150: c3 ret 10c151: 8d 76 00 lea 0x0(%esi),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
10c154: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c159: 8d 65 f4 lea -0xc(%ebp),%esp 10c15c: 5b pop %ebx 10c15d: 5e pop %esi 10c15e: 5f pop %edi 10c15f: c9 leave 10c160: c3 ret 10c161: 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 );
10c164: 50 push %eax 10c165: 9d popf
_Thread_Enable_dispatch();
10c166: e8 15 1e 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c16b: 31 c0 xor %eax,%eax 10c16d: e9 74 ff ff ff jmp 10c0e6 <rtems_timer_fire_after+0x42> 10c172: 66 90 xchg %ax,%ax
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
10c174: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c179: 8d 65 f4 lea -0xc(%ebp),%esp 10c17c: 5b pop %ebx 10c17d: 5e pop %esi 10c17e: 5f pop %edi 10c17f: c9 leave 10c180: c3 ret
00118918 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118918: 55 push %ebp 118919: 89 e5 mov %esp,%ebp 11891b: 57 push %edi 11891c: 56 push %esi 11891d: 53 push %ebx 11891e: 83 ec 2c sub $0x2c,%esp 118921: 8b 75 08 mov 0x8(%ebp),%esi 118924: 8b 7d 0c mov 0xc(%ebp),%edi 118927: 8b 5d 10 mov 0x10(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
11892a: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44
118931: 75 0d jne 118940 <rtems_timer_fire_when+0x28>
return RTEMS_NOT_DEFINED;
118933: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118938: 8d 65 f4 lea -0xc(%ebp),%esp 11893b: 5b pop %ebx 11893c: 5e pop %esi 11893d: 5f pop %edi 11893e: c9 leave 11893f: c3 ret
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
118940: 83 ec 0c sub $0xc,%esp 118943: 57 push %edi 118944: e8 93 d4 ff ff call 115ddc <_TOD_Validate> 118949: 83 c4 10 add $0x10,%esp 11894c: 84 c0 test %al,%al
11894e: 74 1e je 11896e <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
118950: 85 db test %ebx,%ebx
118952: 0f 84 a4 00 00 00 je 1189fc <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
118958: 83 ec 0c sub $0xc,%esp 11895b: 57 push %edi 11895c: e8 ef d3 ff ff call 115d50 <_TOD_To_seconds> 118961: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
118963: 83 c4 10 add $0x10,%esp 118966: 3b 05 c8 2a 14 00 cmp 0x142ac8,%eax
11896c: 77 0e ja 11897c <rtems_timer_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
11896e: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118973: 8d 65 f4 lea -0xc(%ebp),%esp 118976: 5b pop %ebx 118977: 5e pop %esi 118978: 5f pop %edi 118979: c9 leave 11897a: c3 ret 11897b: 90 nop 11897c: 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 );
11897d: 8d 45 e4 lea -0x1c(%ebp),%eax 118980: 50 push %eax 118981: 56 push %esi 118982: 68 60 34 14 00 push $0x143460 118987: e8 50 29 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
11898c: 83 c4 10 add $0x10,%esp 11898f: 8b 4d e4 mov -0x1c(%ebp),%ecx 118992: 85 c9 test %ecx,%ecx
118994: 75 5a jne 1189f0 <rtems_timer_fire_when+0xd8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118996: 8d 48 10 lea 0x10(%eax),%ecx 118999: 83 ec 0c sub $0xc,%esp 11899c: 51 push %ecx 11899d: 89 45 d0 mov %eax,-0x30(%ebp) 1189a0: 89 4d d4 mov %ecx,-0x2c(%ebp) 1189a3: e8 e8 45 00 00 call 11cf90 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
1189a8: 8b 55 d0 mov -0x30(%ebp),%edx 1189ab: 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;
1189b2: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1189b9: 89 5a 2c mov %ebx,0x2c(%edx)
the_watchdog->id = id;
1189bc: 89 72 30 mov %esi,0x30(%edx)
the_watchdog->user_data = user_data;
1189bf: 8b 45 14 mov 0x14(%ebp),%eax 1189c2: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
1189c5: 2b 3d c8 2a 14 00 sub 0x142ac8,%edi 1189cb: 89 7a 1c mov %edi,0x1c(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
1189ce: 58 pop %eax 1189cf: 5a pop %edx 1189d0: 8b 4d d4 mov -0x2c(%ebp),%ecx 1189d3: 51 push %ecx 1189d4: 68 f4 2a 14 00 push $0x142af4 1189d9: e8 72 44 00 00 call 11ce50 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
1189de: e8 71 34 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1189e3: 83 c4 10 add $0x10,%esp 1189e6: 31 c0 xor %eax,%eax 1189e8: e9 4b ff ff ff jmp 118938 <rtems_timer_fire_when+0x20> 1189ed: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1189f0: b8 04 00 00 00 mov $0x4,%eax 1189f5: e9 3e ff ff ff jmp 118938 <rtems_timer_fire_when+0x20> 1189fa: 66 90 xchg %ax,%ax
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
1189fc: b8 09 00 00 00 mov $0x9,%eax 118a01: e9 32 ff ff ff jmp 118938 <rtems_timer_fire_when+0x20>
001190b0 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
1190b0: 55 push %ebp 1190b1: 89 e5 mov %esp,%ebp 1190b3: 56 push %esi 1190b4: 53 push %ebx 1190b5: 83 ec 10 sub $0x10,%esp 1190b8: 8b 45 08 mov 0x8(%ebp),%eax 1190bb: 85 c0 test %eax,%eax
1190bd: 74 41 je 119100 <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1190bf: 0f b6 15 d4 a2 13 00 movzbl 0x13a2d4,%edx
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
1190c6: 39 d0 cmp %edx,%eax
1190c8: 76 42 jbe 11910c <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 )
1190ca: 40 inc %eax
1190cb: 75 33 jne 119100 <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1190cd: 31 f6 xor %esi,%esi 1190cf: 8b 15 30 2a 14 00 mov 0x142a30,%edx 1190d5: 42 inc %edx 1190d6: 89 15 30 2a 14 00 mov %edx,0x142a30
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1190dc: 8a 1d 60 e3 13 00 mov 0x13e360,%bl
initialized = true;
1190e2: c6 05 60 e3 13 00 01 movb $0x1,0x13e360
_Thread_Enable_dispatch();
1190e9: e8 66 2d 00 00 call 11be54 <_Thread_Enable_dispatch>
if ( tmpInitialized )
1190ee: 84 db test %bl,%bl
1190f0: 74 1e je 119110 <rtems_timer_initiate_server+0x60>
return RTEMS_INCORRECT_STATE;
1190f2: b8 0e 00 00 00 mov $0xe,%eax
initialized = false;
}
#endif
return status;
}
1190f7: 8d 65 f8 lea -0x8(%ebp),%esp 1190fa: 5b pop %ebx 1190fb: 5e pop %esi 1190fc: c9 leave 1190fd: c3 ret 1190fe: 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;
119100: b8 13 00 00 00 mov $0x13,%eax
initialized = false;
}
#endif
return status;
}
119105: 8d 65 f8 lea -0x8(%ebp),%esp 119108: 5b pop %ebx 119109: 5e pop %esi 11910a: c9 leave 11910b: c3 ret 11910c: 89 c6 mov %eax,%esi 11910e: eb bf jmp 1190cf <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(
119110: 83 ec 08 sub $0x8,%esp 119113: 8d 45 f4 lea -0xc(%ebp),%eax 119116: 50 push %eax 119117: 8b 45 10 mov 0x10(%ebp),%eax 11911a: 80 cc 80 or $0x80,%ah 11911d: 50 push %eax 11911e: 68 00 01 00 00 push $0x100 119123: ff 75 0c pushl 0xc(%ebp) 119126: 56 push %esi 119127: 68 45 4d 49 54 push $0x54494d45 11912c: e8 c7 ec ff ff call 117df8 <rtems_task_create>
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
119131: 83 c4 20 add $0x20,%esp 119134: 85 c0 test %eax,%eax
119136: 74 10 je 119148 <rtems_timer_initiate_server+0x98>
initialized = false;
119138: c6 05 60 e3 13 00 00 movb $0x0,0x13e360
initialized = false;
}
#endif
return status;
}
11913f: 8d 65 f8 lea -0x8(%ebp),%esp 119142: 5b pop %ebx 119143: 5e pop %esi 119144: c9 leave 119145: c3 ret 119146: 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)
119148: 8b 45 f4 mov -0xc(%ebp),%eax
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
11914b: 0f b7 c8 movzwl %ax,%ecx 11914e: 8b 15 dc 29 14 00 mov 0x1429dc,%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(
119154: 8b 14 8a mov (%edx,%ecx,4),%edx 119157: 89 15 e0 e2 13 00 mov %edx,0x13e2e0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11915d: c7 05 10 e3 13 00 14 movl $0x13e314,0x13e310
119164: e3 13 00 head->previous = NULL;
119167: c7 05 14 e3 13 00 00 movl $0x0,0x13e314
11916e: 00 00 00 tail->previous = head;
119171: c7 05 18 e3 13 00 10 movl $0x13e310,0x13e318
119178: e3 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11917b: c7 05 48 e3 13 00 4c movl $0x13e34c,0x13e348
119182: e3 13 00 head->previous = NULL;
119185: c7 05 4c e3 13 00 00 movl $0x0,0x13e34c
11918c: 00 00 00 tail->previous = head;
11918f: c7 05 50 e3 13 00 48 movl $0x13e348,0x13e350
119196: e3 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
119199: c7 05 f0 e2 13 00 00 movl $0x0,0x13e2f0
1191a0: 00 00 00 the_watchdog->routine = routine;
1191a3: c7 05 04 e3 13 00 a0 movl $0x11bca0,0x13e304
1191aa: bc 11 00 the_watchdog->id = id;
1191ad: a3 08 e3 13 00 mov %eax,0x13e308
the_watchdog->user_data = user_data;
1191b2: c7 05 0c e3 13 00 00 movl $0x0,0x13e30c
1191b9: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191bc: c7 05 28 e3 13 00 00 movl $0x0,0x13e328
1191c3: 00 00 00 the_watchdog->routine = routine;
1191c6: c7 05 3c e3 13 00 a0 movl $0x11bca0,0x13e33c
1191cd: bc 11 00 the_watchdog->id = id;
1191d0: a3 40 e3 13 00 mov %eax,0x13e340
the_watchdog->user_data = user_data;
1191d5: c7 05 44 e3 13 00 00 movl $0x0,0x13e344
1191dc: 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;
1191df: c7 05 e4 e2 13 00 80 movl $0x118f80,0x13e2e4
1191e6: 8f 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1191e9: 8b 15 64 2b 14 00 mov 0x142b64,%edx 1191ef: 89 15 1c e3 13 00 mov %edx,0x13e31c
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
1191f5: 8b 15 c8 2a 14 00 mov 0x142ac8,%edx 1191fb: 89 15 54 e3 13 00 mov %edx,0x13e354
ts->insert_chain = NULL;
119201: c7 05 58 e3 13 00 00 movl $0x0,0x13e358
119208: 00 00 00 ts->active = false;
11920b: c6 05 5c e3 13 00 00 movb $0x0,0x13e35c
/*
* The default timer server is now available.
*/
_Timer_server = ts;
119212: c7 05 a0 34 14 00 e0 movl $0x13e2e0,0x1434a0
119219: e2 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
11921c: 53 push %ebx 11921d: 68 e0 e2 13 00 push $0x13e2e0 119222: 68 b8 8d 11 00 push $0x118db8 119227: 50 push %eax 119228: e8 8b f2 ff ff call 1184b8 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
11922d: 83 c4 10 add $0x10,%esp 119230: e9 d0 fe ff ff jmp 119105 <rtems_timer_initiate_server+0x55>
00118a90 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
118a90: 55 push %ebp 118a91: 89 e5 mov %esp,%ebp 118a93: 56 push %esi 118a94: 53 push %ebx 118a95: 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 );
118a98: 8d 45 f4 lea -0xc(%ebp),%eax 118a9b: 50 push %eax 118a9c: ff 75 08 pushl 0x8(%ebp) 118a9f: 68 60 34 14 00 push $0x143460 118aa4: e8 33 28 00 00 call 11b2dc <_Objects_Get> 118aa9: 89 c3 mov %eax,%ebx
switch ( location ) {
118aab: 83 c4 10 add $0x10,%esp 118aae: 8b 45 f4 mov -0xc(%ebp),%eax 118ab1: 85 c0 test %eax,%eax
118ab3: 74 0f je 118ac4 <rtems_timer_reset+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118ab5: b8 04 00 00 00 mov $0x4,%eax
}
118aba: 8d 65 f8 lea -0x8(%ebp),%esp 118abd: 5b pop %ebx 118abe: 5e pop %esi 118abf: c9 leave 118ac0: c3 ret 118ac1: 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 ) {
118ac4: 8b 43 38 mov 0x38(%ebx),%eax 118ac7: 85 c0 test %eax,%eax
118ac9: 74 1d je 118ae8 <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 ) {
118acb: 48 dec %eax
118acc: 74 3a je 118b08 <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;
118ace: b8 0b 00 00 00 mov $0xb,%eax
}
_Thread_Enable_dispatch();
118ad3: 89 45 e4 mov %eax,-0x1c(%ebp) 118ad6: e8 79 33 00 00 call 11be54 <_Thread_Enable_dispatch>
return status;
118adb: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118ade: 8d 65 f8 lea -0x8(%ebp),%esp 118ae1: 5b pop %ebx 118ae2: 5e pop %esi 118ae3: c9 leave 118ae4: c3 ret 118ae5: 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 );
118ae8: 83 c3 10 add $0x10,%ebx 118aeb: 83 ec 0c sub $0xc,%esp 118aee: 53 push %ebx 118aef: e8 9c 44 00 00 call 11cf90 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
118af4: 59 pop %ecx 118af5: 5e pop %esi 118af6: 53 push %ebx 118af7: 68 00 2b 14 00 push $0x142b00 118afc: e8 4f 43 00 00 call 11ce50 <_Watchdog_Insert> 118b01: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b04: 31 c0 xor %eax,%eax 118b06: eb cb jmp 118ad3 <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;
118b08: 8b 35 a0 34 14 00 mov 0x1434a0,%esi
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
118b0e: 83 ec 0c sub $0xc,%esp 118b11: 8d 43 10 lea 0x10(%ebx),%eax 118b14: 50 push %eax 118b15: e8 76 44 00 00 call 11cf90 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
118b1a: 58 pop %eax 118b1b: 5a pop %edx 118b1c: 53 push %ebx 118b1d: 56 push %esi 118b1e: ff 56 04 call *0x4(%esi) 118b21: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b24: 31 c0 xor %eax,%eax 118b26: eb ab jmp 118ad3 <rtems_timer_reset+0x43>
00118b28 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118b28: 55 push %ebp 118b29: 89 e5 mov %esp,%ebp 118b2b: 57 push %edi 118b2c: 56 push %esi 118b2d: 53 push %ebx 118b2e: 83 ec 2c sub $0x2c,%esp 118b31: 8b 7d 0c mov 0xc(%ebp),%edi 118b34: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
118b37: 8b 1d a0 34 14 00 mov 0x1434a0,%ebx
if ( !timer_server )
118b3d: 85 db test %ebx,%ebx
118b3f: 0f 84 9f 00 00 00 je 118be4 <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
118b45: 85 f6 test %esi,%esi
118b47: 0f 84 a3 00 00 00 je 118bf0 <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118b4d: 85 ff test %edi,%edi
118b4f: 75 0f jne 118b60 <rtems_timer_server_fire_after+0x38>
return RTEMS_INVALID_NUMBER;
118b51: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118b56: 8d 65 f4 lea -0xc(%ebp),%esp 118b59: 5b pop %ebx 118b5a: 5e pop %esi 118b5b: 5f pop %edi 118b5c: c9 leave 118b5d: c3 ret 118b5e: 66 90 xchg %ax,%ax 118b60: 52 push %edx
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
118b61: 8d 45 e4 lea -0x1c(%ebp),%eax 118b64: 50 push %eax 118b65: ff 75 08 pushl 0x8(%ebp) 118b68: 68 60 34 14 00 push $0x143460 118b6d: e8 6a 27 00 00 call 11b2dc <_Objects_Get> 118b72: 89 c2 mov %eax,%edx
switch ( location ) {
118b74: 83 c4 10 add $0x10,%esp 118b77: 8b 45 e4 mov -0x1c(%ebp),%eax 118b7a: 85 c0 test %eax,%eax
118b7c: 75 56 jne 118bd4 <rtems_timer_server_fire_after+0xac>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118b7e: 83 ec 0c sub $0xc,%esp 118b81: 8d 42 10 lea 0x10(%edx),%eax 118b84: 50 push %eax 118b85: 89 55 d4 mov %edx,-0x2c(%ebp) 118b88: e8 03 44 00 00 call 11cf90 <_Watchdog_Remove>
_ISR_Disable( level );
118b8d: 9c pushf 118b8e: fa cli 118b8f: 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 ) {
118b90: 83 c4 10 add $0x10,%esp 118b93: 8b 55 d4 mov -0x2c(%ebp),%edx 118b96: 8b 4a 18 mov 0x18(%edx),%ecx 118b99: 85 c9 test %ecx,%ecx
118b9b: 75 5f jne 118bfc <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;
118b9d: 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;
118ba4: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118bab: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118bae: 8b 4d 08 mov 0x8(%ebp),%ecx 118bb1: 89 4a 30 mov %ecx,0x30(%edx)
the_watchdog->user_data = user_data;
118bb4: 8b 4d 14 mov 0x14(%ebp),%ecx 118bb7: 89 4a 34 mov %ecx,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
118bba: 89 7a 1c mov %edi,0x1c(%edx)
_ISR_Enable( level );
118bbd: 50 push %eax 118bbe: 9d popf
(*timer_server->schedule_operation)( timer_server, the_timer );
118bbf: 83 ec 08 sub $0x8,%esp 118bc2: 52 push %edx 118bc3: 53 push %ebx 118bc4: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118bc7: e8 88 32 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118bcc: 83 c4 10 add $0x10,%esp 118bcf: 31 c0 xor %eax,%eax 118bd1: eb 83 jmp 118b56 <rtems_timer_server_fire_after+0x2e> 118bd3: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118bd4: b8 04 00 00 00 mov $0x4,%eax
}
118bd9: 8d 65 f4 lea -0xc(%ebp),%esp 118bdc: 5b pop %ebx 118bdd: 5e pop %esi 118bde: 5f pop %edi 118bdf: c9 leave 118be0: c3 ret 118be1: 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;
118be4: b8 0e 00 00 00 mov $0xe,%eax 118be9: e9 68 ff ff ff jmp 118b56 <rtems_timer_server_fire_after+0x2e> 118bee: 66 90 xchg %ax,%ax
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118bf0: b8 09 00 00 00 mov $0x9,%eax 118bf5: e9 5c ff ff ff jmp 118b56 <rtems_timer_server_fire_after+0x2e> 118bfa: 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 );
118bfc: 50 push %eax 118bfd: 9d popf
_Thread_Enable_dispatch();
118bfe: e8 51 32 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118c03: 31 c0 xor %eax,%eax 118c05: e9 4c ff ff ff jmp 118b56 <rtems_timer_server_fire_after+0x2e>
00118c0c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118c0c: 55 push %ebp 118c0d: 89 e5 mov %esp,%ebp 118c0f: 57 push %edi 118c10: 56 push %esi 118c11: 53 push %ebx 118c12: 83 ec 2c sub $0x2c,%esp 118c15: 8b 7d 0c mov 0xc(%ebp),%edi 118c18: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
118c1b: 8b 1d a0 34 14 00 mov 0x1434a0,%ebx
if ( !timer_server )
118c21: 85 db test %ebx,%ebx
118c23: 0f 84 d7 00 00 00 je 118d00 <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118c29: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44
118c30: 0f 84 aa 00 00 00 je 118ce0 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
118c36: 85 f6 test %esi,%esi
118c38: 0f 84 b2 00 00 00 je 118cf0 <rtems_timer_server_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
118c3e: 83 ec 0c sub $0xc,%esp 118c41: 57 push %edi 118c42: e8 95 d1 ff ff call 115ddc <_TOD_Validate> 118c47: 83 c4 10 add $0x10,%esp 118c4a: 84 c0 test %al,%al
118c4c: 75 0e jne 118c5c <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;
118c4e: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118c53: 8d 65 f4 lea -0xc(%ebp),%esp 118c56: 5b pop %ebx 118c57: 5e pop %esi 118c58: 5f pop %edi 118c59: c9 leave 118c5a: c3 ret 118c5b: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
118c5c: 83 ec 0c sub $0xc,%esp 118c5f: 57 push %edi 118c60: e8 eb d0 ff ff call 115d50 <_TOD_To_seconds> 118c65: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
118c67: 83 c4 10 add $0x10,%esp 118c6a: 3b 05 c8 2a 14 00 cmp 0x142ac8,%eax
118c70: 76 dc jbe 118c4e <rtems_timer_server_fire_when+0x42>
118c72: 52 push %edx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
118c73: 8d 45 e4 lea -0x1c(%ebp),%eax 118c76: 50 push %eax 118c77: ff 75 08 pushl 0x8(%ebp) 118c7a: 68 60 34 14 00 push $0x143460 118c7f: e8 58 26 00 00 call 11b2dc <_Objects_Get> 118c84: 89 c2 mov %eax,%edx
switch ( location ) {
118c86: 83 c4 10 add $0x10,%esp 118c89: 8b 45 e4 mov -0x1c(%ebp),%eax 118c8c: 85 c0 test %eax,%eax
118c8e: 75 7c jne 118d0c <rtems_timer_server_fire_when+0x100>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118c90: 83 ec 0c sub $0xc,%esp 118c93: 8d 42 10 lea 0x10(%edx),%eax 118c96: 50 push %eax 118c97: 89 55 d4 mov %edx,-0x2c(%ebp) 118c9a: e8 f1 42 00 00 call 11cf90 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
118c9f: 8b 55 d4 mov -0x2c(%ebp),%edx 118ca2: 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;
118ca9: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118cb0: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118cb3: 8b 45 08 mov 0x8(%ebp),%eax 118cb6: 89 42 30 mov %eax,0x30(%edx)
the_watchdog->user_data = user_data;
118cb9: 8b 45 14 mov 0x14(%ebp),%eax 118cbc: 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();
118cbf: 2b 3d c8 2a 14 00 sub 0x142ac8,%edi 118cc5: 89 7a 1c mov %edi,0x1c(%edx)
(*timer_server->schedule_operation)( timer_server, the_timer );
118cc8: 58 pop %eax 118cc9: 59 pop %ecx 118cca: 52 push %edx 118ccb: 53 push %ebx 118ccc: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118ccf: e8 80 31 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118cd4: 83 c4 10 add $0x10,%esp 118cd7: 31 c0 xor %eax,%eax 118cd9: e9 75 ff ff ff jmp 118c53 <rtems_timer_server_fire_when+0x47> 118cde: 66 90 xchg %ax,%ax
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
118ce0: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118ce5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118ce8: 5b pop %ebx <== NOT EXECUTED 118ce9: 5e pop %esi <== NOT EXECUTED 118cea: 5f pop %edi <== NOT EXECUTED 118ceb: c9 leave <== NOT EXECUTED 118cec: c3 ret <== NOT EXECUTED 118ced: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118cf0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118cf5: 8d 65 f4 lea -0xc(%ebp),%esp 118cf8: 5b pop %ebx 118cf9: 5e pop %esi 118cfa: 5f pop %edi 118cfb: c9 leave 118cfc: c3 ret 118cfd: 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;
118d00: b8 0e 00 00 00 mov $0xe,%eax 118d05: e9 49 ff ff ff jmp 118c53 <rtems_timer_server_fire_when+0x47> 118d0a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118d0c: b8 04 00 00 00 mov $0x4,%eax 118d11: e9 3d ff ff ff jmp 118c53 <rtems_timer_server_fire_when+0x47>
0010be34 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10be34: 55 push %ebp 10be35: 89 e5 mov %esp,%ebp 10be37: 83 ec 08 sub $0x8,%esp 10be3a: 8b 45 08 mov 0x8(%ebp),%eax
switch ( policy ) {
10be3d: 85 c0 test %eax,%eax
10be3f: 78 0a js 10be4b <sched_get_priority_max+0x17>
10be41: 83 f8 02 cmp $0x2,%eax
10be44: 7e 1a jle 10be60 <sched_get_priority_max+0x2c>
10be46: 83 f8 04 cmp $0x4,%eax
10be49: 74 15 je 10be60 <sched_get_priority_max+0x2c><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10be4b: e8 20 81 00 00 call 113f70 <__errno> 10be50: c7 00 16 00 00 00 movl $0x16,(%eax) 10be56: b8 ff ff ff ff mov $0xffffffff,%eax
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
}
10be5b: c9 leave 10be5c: c3 ret 10be5d: 8d 76 00 lea 0x0(%esi),%esi
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10be60: 0f b6 05 9c 4d 12 00 movzbl 0x124d9c,%eax 10be67: 48 dec %eax
}
10be68: c9 leave 10be69: c3 ret
0010be6c <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10be6c: 55 push %ebp 10be6d: 89 e5 mov %esp,%ebp 10be6f: 83 ec 08 sub $0x8,%esp 10be72: 8b 45 08 mov 0x8(%ebp),%eax
switch ( policy ) {
10be75: 85 c0 test %eax,%eax
10be77: 78 0a js 10be83 <sched_get_priority_min+0x17>
10be79: 83 f8 02 cmp $0x2,%eax
10be7c: 7e 1a jle 10be98 <sched_get_priority_min+0x2c><== ALWAYS TAKEN
10be7e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10be81: 74 15 je 10be98 <sched_get_priority_min+0x2c><== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10be83: e8 e8 80 00 00 call 113f70 <__errno> 10be88: c7 00 16 00 00 00 movl $0x16,(%eax) 10be8e: b8 ff ff ff ff mov $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10be93: c9 leave 10be94: c3 ret 10be95: 8d 76 00 lea 0x0(%esi),%esi
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10be98: b8 01 00 00 00 mov $0x1,%eax
}
10be9d: c9 leave 10be9e: c3 ret
0010bea0 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10bea0: 55 push %ebp 10bea1: 89 e5 mov %esp,%ebp 10bea3: 56 push %esi 10bea4: 53 push %ebx 10bea5: 8b 75 08 mov 0x8(%ebp),%esi 10bea8: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10beab: 85 f6 test %esi,%esi
10bead: 75 21 jne 10bed0 <sched_rr_get_interval+0x30><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
10beaf: 85 db test %ebx,%ebx
10beb1: 74 38 je 10beeb <sched_rr_get_interval+0x4b>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10beb3: 83 ec 08 sub $0x8,%esp 10beb6: 53 push %ebx 10beb7: ff 35 60 90 12 00 pushl 0x129060 10bebd: e8 b2 35 00 00 call 10f474 <_Timespec_From_ticks>
return 0;
10bec2: 83 c4 10 add $0x10,%esp 10bec5: 31 c0 xor %eax,%eax
}
10bec7: 8d 65 f8 lea -0x8(%ebp),%esp 10beca: 5b pop %ebx 10becb: 5e pop %esi 10becc: c9 leave 10becd: c3 ret 10bece: 66 90 xchg %ax,%ax
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10bed0: e8 fb c8 ff ff call 1087d0 <getpid> 10bed5: 39 f0 cmp %esi,%eax
10bed7: 74 d6 je 10beaf <sched_rr_get_interval+0xf>
rtems_set_errno_and_return_minus_one( ESRCH );
10bed9: e8 92 80 00 00 call 113f70 <__errno> 10bede: c7 00 03 00 00 00 movl $0x3,(%eax) 10bee4: b8 ff ff ff ff mov $0xffffffff,%eax 10bee9: eb dc jmp 10bec7 <sched_rr_get_interval+0x27>
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
10beeb: e8 80 80 00 00 call 113f70 <__errno> 10bef0: c7 00 16 00 00 00 movl $0x16,(%eax) 10bef6: b8 ff ff ff ff mov $0xffffffff,%eax 10befb: eb ca jmp 10bec7 <sched_rr_get_interval+0x27>
0010e604 <sem_close>:
*/
int sem_close(
sem_t *sem
)
{
10e604: 55 push %ebp 10e605: 89 e5 mov %esp,%ebp 10e607: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e60a: 8d 45 f4 lea -0xc(%ebp),%eax
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
10e60d: 50 push %eax 10e60e: 8b 45 08 mov 0x8(%ebp),%eax 10e611: ff 30 pushl (%eax) 10e613: 68 20 de 12 00 push $0x12de20 10e618: e8 bf 21 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e61d: 83 c4 10 add $0x10,%esp 10e620: 8b 55 f4 mov -0xc(%ebp),%edx 10e623: 85 d2 test %edx,%edx
10e625: 74 15 je 10e63c <sem_close+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e627: e8 7c 8f 00 00 call 1175a8 <__errno> 10e62c: c7 00 16 00 00 00 movl $0x16,(%eax) 10e632: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e637: c9 leave 10e638: c3 ret 10e639: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
10e63c: ff 48 18 decl 0x18(%eax)
_POSIX_Semaphore_Delete( the_semaphore );
10e63f: 83 ec 0c sub $0xc,%esp 10e642: 50 push %eax 10e643: e8 3c 64 00 00 call 114a84 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10e648: e8 87 2d 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e64d: 83 c4 10 add $0x10,%esp 10e650: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e652: c9 leave 10e653: c3 ret
0010e654 <sem_destroy>:
*/
int sem_destroy(
sem_t *sem
)
{
10e654: 55 push %ebp 10e655: 89 e5 mov %esp,%ebp 10e657: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e65a: 8d 45 f4 lea -0xc(%ebp),%eax 10e65d: 50 push %eax 10e65e: 8b 45 08 mov 0x8(%ebp),%eax 10e661: ff 30 pushl (%eax) 10e663: 68 20 de 12 00 push $0x12de20 10e668: e8 6f 21 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e66d: 83 c4 10 add $0x10,%esp 10e670: 8b 55 f4 mov -0xc(%ebp),%edx 10e673: 85 d2 test %edx,%edx
10e675: 74 15 je 10e68c <sem_destroy+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e677: e8 2c 8f 00 00 call 1175a8 <__errno> 10e67c: c7 00 16 00 00 00 movl $0x16,(%eax) 10e682: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e687: c9 leave 10e688: c3 ret 10e689: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
10e68c: 80 78 14 00 cmpb $0x0,0x14(%eax)
10e690: 75 16 jne 10e6a8 <sem_destroy+0x54>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
10e692: 83 ec 0c sub $0xc,%esp 10e695: 50 push %eax 10e696: e8 e9 63 00 00 call 114a84 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10e69b: e8 34 2d 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e6a0: 83 c4 10 add $0x10,%esp 10e6a3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e6a5: c9 leave 10e6a6: c3 ret 10e6a7: 90 nop
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
_Thread_Enable_dispatch();
10e6a8: e8 27 2d 00 00 call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
10e6ad: e8 f6 8e 00 00 call 1175a8 <__errno> 10e6b2: c7 00 16 00 00 00 movl $0x16,(%eax) 10e6b8: b8 ff ff ff ff mov $0xffffffff,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e6bd: c9 leave 10e6be: c3 ret
0010e6c0 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
10e6c0: 55 push %ebp 10e6c1: 89 e5 mov %esp,%ebp 10e6c3: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e6c6: 8d 45 f4 lea -0xc(%ebp),%eax 10e6c9: 50 push %eax 10e6ca: 8b 45 08 mov 0x8(%ebp),%eax 10e6cd: ff 30 pushl (%eax) 10e6cf: 68 20 de 12 00 push $0x12de20 10e6d4: e8 03 21 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e6d9: 83 c4 10 add $0x10,%esp 10e6dc: 8b 55 f4 mov -0xc(%ebp),%edx 10e6df: 85 d2 test %edx,%edx
10e6e1: 74 15 je 10e6f8 <sem_getvalue+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e6e3: e8 c0 8e 00 00 call 1175a8 <__errno> 10e6e8: c7 00 16 00 00 00 movl $0x16,(%eax) 10e6ee: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e6f3: c9 leave 10e6f4: c3 ret 10e6f5: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
10e6f8: 8b 50 64 mov 0x64(%eax),%edx 10e6fb: 8b 45 0c mov 0xc(%ebp),%eax 10e6fe: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10e700: e8 cf 2c 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e705: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e707: c9 leave 10e708: c3 ret
0010e754 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10e754: 55 push %ebp 10e755: 89 e5 mov %esp,%ebp 10e757: 57 push %edi 10e758: 56 push %esi 10e759: 53 push %ebx 10e75a: 83 ec 2c sub $0x2c,%esp 10e75d: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10e760: a1 10 db 12 00 mov 0x12db10,%eax 10e765: 40 inc %eax 10e766: a3 10 db 12 00 mov %eax,0x12db10
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10e76b: 8b 7d 0c mov 0xc(%ebp),%edi 10e76e: 81 e7 00 02 00 00 and $0x200,%edi
10e774: 0f 85 86 00 00 00 jne 10e800 <sem_open+0xac>
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
10e77a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10e781: 83 ec 08 sub $0x8,%esp 10e784: 8d 45 e4 lea -0x1c(%ebp),%eax 10e787: 50 push %eax 10e788: 56 push %esi 10e789: e8 46 63 00 00 call 114ad4 <_POSIX_Semaphore_Name_to_id> 10e78e: 89 c3 mov %eax,%ebx
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
10e790: 83 c4 10 add $0x10,%esp 10e793: 85 c0 test %eax,%eax
10e795: 74 25 je 10e7bc <sem_open+0x68>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10e797: 83 f8 02 cmp $0x2,%eax
10e79a: 75 04 jne 10e7a0 <sem_open+0x4c> <== NEVER TAKEN
10e79c: 85 ff test %edi,%edi
10e79e: 75 6c jne 10e80c <sem_open+0xb8>
_Thread_Enable_dispatch();
10e7a0: e8 2f 2c 00 00 call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10e7a5: e8 fe 8d 00 00 call 1175a8 <__errno> 10e7aa: 89 18 mov %ebx,(%eax) 10e7ac: b8 ff ff ff ff mov $0xffffffff,%eax
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
10e7b1: 8d 65 f4 lea -0xc(%ebp),%esp 10e7b4: 5b pop %ebx 10e7b5: 5e pop %esi 10e7b6: 5f pop %edi 10e7b7: c9 leave 10e7b8: c3 ret 10e7b9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10e7bc: 8b 45 0c mov 0xc(%ebp),%eax 10e7bf: 25 00 0a 00 00 and $0xa00,%eax 10e7c4: 3d 00 0a 00 00 cmp $0xa00,%eax
10e7c9: 74 65 je 10e830 <sem_open+0xdc>
10e7cb: 50 push %eax
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10e7cc: 8d 45 dc lea -0x24(%ebp),%eax 10e7cf: 50 push %eax 10e7d0: ff 75 e4 pushl -0x1c(%ebp) 10e7d3: 68 20 de 12 00 push $0x12de20 10e7d8: e8 ff 1f 00 00 call 1107dc <_Objects_Get> 10e7dd: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10e7e0: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10e7e3: e8 ec 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10e7e8: e8 e7 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
goto return_id;
10e7ed: 83 c4 10 add $0x10,%esp
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
10e7f0: 8b 45 e0 mov -0x20(%ebp),%eax 10e7f3: 83 c0 08 add $0x8,%eax
#endif return id; }
10e7f6: 8d 65 f4 lea -0xc(%ebp),%esp 10e7f9: 5b pop %ebx 10e7fa: 5e pop %esi 10e7fb: 5f pop %edi 10e7fc: c9 leave 10e7fd: c3 ret 10e7fe: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10e800: 8b 45 14 mov 0x14(%ebp),%eax 10e803: 89 45 d4 mov %eax,-0x2c(%ebp) 10e806: e9 76 ff ff ff jmp 10e781 <sem_open+0x2d> 10e80b: 90 nop
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
10e80c: 8d 45 e0 lea -0x20(%ebp),%eax 10e80f: 50 push %eax 10e810: ff 75 d4 pushl -0x2c(%ebp) 10e813: 6a 00 push $0x0 10e815: 56 push %esi 10e816: e8 5d 61 00 00 call 114978 <_POSIX_Semaphore_Create_support> 10e81b: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10e81d: e8 b2 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
if ( status == -1 )
10e822: 83 c4 10 add $0x10,%esp 10e825: 43 inc %ebx
10e826: 75 c8 jne 10e7f0 <sem_open+0x9c>
return SEM_FAILED;
10e828: b8 ff ff ff ff mov $0xffffffff,%eax 10e82d: eb c7 jmp 10e7f6 <sem_open+0xa2> 10e82f: 90 nop
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
10e830: e8 9f 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10e835: e8 6e 8d 00 00 call 1175a8 <__errno> 10e83a: c7 00 11 00 00 00 movl $0x11,(%eax) 10e840: b8 ff ff ff ff mov $0xffffffff,%eax 10e845: eb af jmp 10e7f6 <sem_open+0xa2>
0010e848 <sem_post>:
*/
int sem_post(
sem_t *sem
)
{
10e848: 55 push %ebp 10e849: 89 e5 mov %esp,%ebp 10e84b: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e84e: 8d 45 f4 lea -0xc(%ebp),%eax 10e851: 50 push %eax 10e852: 8b 45 08 mov 0x8(%ebp),%eax 10e855: ff 30 pushl (%eax) 10e857: 68 20 de 12 00 push $0x12de20 10e85c: e8 7b 1f 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e861: 83 c4 10 add $0x10,%esp 10e864: 8b 4d f4 mov -0xc(%ebp),%ecx 10e867: 85 c9 test %ecx,%ecx
10e869: 74 15 je 10e880 <sem_post+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e86b: e8 38 8d 00 00 call 1175a8 <__errno> 10e870: c7 00 16 00 00 00 movl $0x16,(%eax) 10e876: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e87b: c9 leave 10e87c: c3 ret 10e87d: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
10e880: 52 push %edx 10e881: 6a 00 push $0x0 10e883: ff 70 08 pushl 0x8(%eax) 10e886: 83 c0 1c add $0x1c,%eax 10e889: 50 push %eax 10e88a: e8 61 15 00 00 call 10fdf0 <_CORE_semaphore_Surrender>
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
10e88f: e8 40 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e894: 83 c4 10 add $0x10,%esp 10e897: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e899: c9 leave 10e89a: c3 ret
0010e89c <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
10e89c: 55 push %ebp 10e89d: 89 e5 mov %esp,%ebp 10e89f: 53 push %ebx 10e8a0: 83 ec 1c sub $0x1c,%esp 10e8a3: 8b 5d 08 mov 0x8(%ebp),%ebx
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10e8a6: 8d 45 f4 lea -0xc(%ebp),%eax 10e8a9: 50 push %eax 10e8aa: ff 75 0c pushl 0xc(%ebp) 10e8ad: e8 56 55 00 00 call 113e08 <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
10e8b2: 83 c4 10 add $0x10,%esp 10e8b5: 83 f8 03 cmp $0x3,%eax
10e8b8: 74 16 je 10e8d0 <sem_timedwait+0x34> <== ALWAYS TAKEN
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
10e8ba: 50 push %eax <== NOT EXECUTED 10e8bb: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10e8be: 6a 00 push $0x0 <== NOT EXECUTED 10e8c0: 53 push %ebx <== NOT EXECUTED 10e8c1: e8 7a 62 00 00 call 114b40 <_POSIX_Semaphore_Wait_support><== NOT EXECUTED 10e8c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
10e8c9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e8cc: c9 leave <== NOT EXECUTED 10e8cd: c3 ret <== NOT EXECUTED 10e8ce: 66 90 xchg %ax,%ax <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
10e8d0: 52 push %edx 10e8d1: ff 75 f4 pushl -0xc(%ebp) 10e8d4: 6a 01 push $0x1 10e8d6: 53 push %ebx 10e8d7: e8 64 62 00 00 call 114b40 <_POSIX_Semaphore_Wait_support> 10e8dc: 83 c4 10 add $0x10,%esp
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
10e8df: 8b 5d fc mov -0x4(%ebp),%ebx 10e8e2: c9 leave 10e8e3: c3 ret
0010b2f4 <setitimer>:
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
10b2f4: 55 push %ebp 10b2f5: 89 e5 mov %esp,%ebp 10b2f7: 83 ec 08 sub $0x8,%esp
if ( !value )
10b2fa: 8b 55 0c mov 0xc(%ebp),%edx 10b2fd: 85 d2 test %edx,%edx
10b2ff: 74 33 je 10b334 <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
10b301: 8b 45 10 mov 0x10(%ebp),%eax 10b304: 85 c0 test %eax,%eax
10b306: 74 2c je 10b334 <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10b308: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b30c: 76 12 jbe 10b320 <setitimer+0x2c>
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b30e: e8 6d 86 00 00 call 113980 <__errno> 10b313: c7 00 16 00 00 00 movl $0x16,(%eax)
}
10b319: b8 ff ff ff ff mov $0xffffffff,%eax 10b31e: c9 leave 10b31f: c3 ret
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
10b320: e8 5b 86 00 00 call 113980 <__errno> 10b325: c7 00 58 00 00 00 movl $0x58,(%eax)
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b32b: b8 ff ff ff ff mov $0xffffffff,%eax 10b330: c9 leave 10b331: c3 ret 10b332: 66 90 xchg %ax,%ax
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
rtems_set_errno_and_return_minus_one( EFAULT );
10b334: e8 47 86 00 00 call 113980 <__errno> 10b339: c7 00 0e 00 00 00 movl $0xe,(%eax) 10b33f: eb d8 jmp 10b319 <setitimer+0x25>
0010bd48 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10bd48: 55 push %ebp 10bd49: 89 e5 mov %esp,%ebp 10bd4b: 57 push %edi 10bd4c: 56 push %esi 10bd4d: 53 push %ebx 10bd4e: 83 ec 1c sub $0x1c,%esp 10bd51: 8b 5d 08 mov 0x8(%ebp),%ebx 10bd54: 8b 45 0c mov 0xc(%ebp),%eax 10bd57: 8b 55 10 mov 0x10(%ebp),%edx
ISR_Level level;
if ( oact )
10bd5a: 85 d2 test %edx,%edx
10bd5c: 74 13 je 10bd71 <sigaction+0x29>
*oact = _POSIX_signals_Vectors[ sig ];
10bd5e: 8d 0c 5b lea (%ebx,%ebx,2),%ecx 10bd61: 8d 34 8d c0 a3 12 00 lea 0x12a3c0(,%ecx,4),%esi 10bd68: b9 03 00 00 00 mov $0x3,%ecx 10bd6d: 89 d7 mov %edx,%edi 10bd6f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10bd71: 85 db test %ebx,%ebx
10bd73: 74 77 je 10bdec <sigaction+0xa4>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10bd75: 8d 53 ff lea -0x1(%ebx),%edx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10bd78: 83 fa 1f cmp $0x1f,%edx
10bd7b: 77 6f ja 10bdec <sigaction+0xa4>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10bd7d: 83 fb 09 cmp $0x9,%ebx
10bd80: 74 6a je 10bdec <sigaction+0xa4>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10bd82: 85 c0 test %eax,%eax
10bd84: 74 62 je 10bde8 <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 );
10bd86: 9c pushf 10bd87: fa cli 10bd88: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10bd8b: 8b 50 08 mov 0x8(%eax),%edx 10bd8e: 85 d2 test %edx,%edx
10bd90: 74 36 je 10bdc8 <sigaction+0x80>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
10bd92: 83 ec 0c sub $0xc,%esp 10bd95: 53 push %ebx 10bd96: 89 45 e0 mov %eax,-0x20(%ebp) 10bd99: e8 be 57 00 00 call 11155c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10bd9e: 8d 14 5b lea (%ebx,%ebx,2),%edx 10bda1: 8d 14 95 c0 a3 12 00 lea 0x12a3c0(,%edx,4),%edx 10bda8: b9 03 00 00 00 mov $0x3,%ecx 10bdad: 8b 45 e0 mov -0x20(%ebp),%eax 10bdb0: 89 d7 mov %edx,%edi 10bdb2: 89 c6 mov %eax,%esi 10bdb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bdb6: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10bdb9: ff 75 e4 pushl -0x1c(%ebp) 10bdbc: 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;
10bdbd: 31 c0 xor %eax,%eax
}
10bdbf: 8d 65 f4 lea -0xc(%ebp),%esp 10bdc2: 5b pop %ebx 10bdc3: 5e pop %esi 10bdc4: 5f pop %edi 10bdc5: c9 leave 10bdc6: c3 ret 10bdc7: 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 ];
10bdc8: 8d 34 5b lea (%ebx,%ebx,2),%esi 10bdcb: c1 e6 02 shl $0x2,%esi 10bdce: 8d 86 c0 a3 12 00 lea 0x12a3c0(%esi),%eax 10bdd4: 81 c6 40 38 12 00 add $0x123840,%esi 10bdda: b9 03 00 00 00 mov $0x3,%ecx 10bddf: 89 c7 mov %eax,%edi 10bde1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10bde3: eb d4 jmp 10bdb9 <sigaction+0x71> 10bde5: 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;
10bde8: 31 c0 xor %eax,%eax 10bdea: eb d3 jmp 10bdbf <sigaction+0x77>
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
10bdec: e8 7b 84 00 00 call 11426c <__errno> 10bdf1: c7 00 16 00 00 00 movl $0x16,(%eax) 10bdf7: b8 ff ff ff ff mov $0xffffffff,%eax 10bdfc: eb c1 jmp 10bdbf <sigaction+0x77>
0010c120 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10c120: 55 push %ebp 10c121: 89 e5 mov %esp,%ebp 10c123: 57 push %edi 10c124: 56 push %esi 10c125: 53 push %ebx 10c126: 83 ec 2c sub $0x2c,%esp 10c129: 8b 5d 08 mov 0x8(%ebp),%ebx 10c12c: 8b 7d 0c mov 0xc(%ebp),%edi 10c12f: 8b 75 10 mov 0x10(%ebp),%esi
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10c132: 85 db test %ebx,%ebx
10c134: 0f 84 9e 01 00 00 je 10c2d8 <sigtimedwait+0x1b8>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10c13a: 85 f6 test %esi,%esi
10c13c: 0f 84 3e 01 00 00 je 10c280 <sigtimedwait+0x160>
if ( !_Timespec_Is_valid( timeout ) )
10c142: 83 ec 0c sub $0xc,%esp 10c145: 56 push %esi 10c146: e8 41 36 00 00 call 10f78c <_Timespec_Is_valid> 10c14b: 83 c4 10 add $0x10,%esp 10c14e: 84 c0 test %al,%al
10c150: 0f 84 82 01 00 00 je 10c2d8 <sigtimedwait+0x1b8>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10c156: 83 ec 0c sub $0xc,%esp 10c159: 56 push %esi 10c15a: e8 95 36 00 00 call 10f7f4 <_Timespec_To_ticks>
if ( !interval )
10c15f: 83 c4 10 add $0x10,%esp 10c162: 85 c0 test %eax,%eax
10c164: 0f 84 6e 01 00 00 je 10c2d8 <sigtimedwait+0x1b8> <== NEVER TAKEN
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10c16a: 85 ff test %edi,%edi
10c16c: 0f 84 18 01 00 00 je 10c28a <sigtimedwait+0x16a> <== NEVER TAKEN
the_thread = _Thread_Executing;
10c172: 8b 0d 98 9b 12 00 mov 0x129b98,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c178: 8b 91 ec 00 00 00 mov 0xec(%ecx),%edx
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10c17e: 9c pushf 10c17f: fa cli 10c180: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10c183: 8b 33 mov (%ebx),%esi 10c185: 89 75 d4 mov %esi,-0x2c(%ebp) 10c188: 8b b2 d4 00 00 00 mov 0xd4(%edx),%esi 10c18e: 85 75 d4 test %esi,-0x2c(%ebp)
10c191: 0f 85 fd 00 00 00 jne 10c294 <sigtimedwait+0x174>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10c197: 8b 35 08 9e 12 00 mov 0x129e08,%esi 10c19d: 85 75 d4 test %esi,-0x2c(%ebp)
10c1a0: 0f 85 96 00 00 00 jne 10c23c <sigtimedwait+0x11c>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
10c1a6: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10c1ac: 8b 35 f0 95 12 00 mov 0x1295f0,%esi 10c1b2: 46 inc %esi 10c1b3: 89 35 f0 95 12 00 mov %esi,0x1295f0
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10c1b9: c7 41 44 a0 9d 12 00 movl $0x129da0,0x44(%ecx)
the_thread->Wait.return_code = EINTR;
10c1c0: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx)
the_thread->Wait.option = *set;
10c1c7: 8b 33 mov (%ebx),%esi 10c1c9: 89 71 30 mov %esi,0x30(%ecx)
the_thread->Wait.return_argument = the_info;
10c1cc: 89 79 28 mov %edi,0x28(%ecx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c1cf: c7 05 d0 9d 12 00 01 movl $0x1,0x129dd0
10c1d6: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10c1d9: ff 75 d0 pushl -0x30(%ebp) 10c1dc: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10c1dd: 51 push %ecx 10c1de: 68 cc f4 10 00 push $0x10f4cc 10c1e3: 50 push %eax 10c1e4: 68 a0 9d 12 00 push $0x129da0 10c1e9: 89 55 cc mov %edx,-0x34(%ebp) 10c1ec: e8 af 2f 00 00 call 10f1a0 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10c1f1: e8 06 2b 00 00 call 10ecfc <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
10c1f6: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c1fd: 6a 00 push $0x0 10c1ff: 57 push %edi 10c200: ff 37 pushl (%edi) 10c202: 8b 55 cc mov -0x34(%ebp),%edx 10c205: 52 push %edx 10c206: e8 4d 5a 00 00 call 111c58 <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
10c20b: 83 c4 20 add $0x20,%esp 10c20e: a1 98 9b 12 00 mov 0x129b98,%eax 10c213: 83 78 34 04 cmpl $0x4,0x34(%eax)
10c217: 0f 85 d3 00 00 00 jne 10c2f0 <sigtimedwait+0x1d0>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10c21d: 8b 37 mov (%edi),%esi 10c21f: 8d 4e ff lea -0x1(%esi),%ecx 10c222: b8 01 00 00 00 mov $0x1,%eax 10c227: d3 e0 shl %cl,%eax 10c229: 85 03 test %eax,(%ebx)
10c22b: 0f 84 bf 00 00 00 je 10c2f0 <sigtimedwait+0x1d0>
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10c231: 89 f0 mov %esi,%eax 10c233: 8d 65 f4 lea -0xc(%ebp),%esp 10c236: 5b pop %ebx 10c237: 5e pop %esi 10c238: 5f pop %edi 10c239: c9 leave 10c23a: c3 ret 10c23b: 90 nop
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10c23c: 83 ec 0c sub $0xc,%esp 10c23f: 56 push %esi 10c240: 89 55 cc mov %edx,-0x34(%ebp) 10c243: e8 94 fe ff ff call 10c0dc <_POSIX_signals_Get_lowest> 10c248: 89 c6 mov %eax,%esi
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10c24a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c251: 6a 01 push $0x1 10c253: 57 push %edi 10c254: 50 push %eax 10c255: 8b 55 cc mov -0x34(%ebp),%edx 10c258: 52 push %edx 10c259: e8 fa 59 00 00 call 111c58 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10c25e: ff 75 d0 pushl -0x30(%ebp) 10c261: 9d popf
the_info->si_signo = signo;
10c262: 89 37 mov %esi,(%edi)
the_info->si_code = SI_USER;
10c264: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10c26b: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10c272: 83 c4 20 add $0x20,%esp
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10c275: 89 f0 mov %esi,%eax 10c277: 8d 65 f4 lea -0xc(%ebp),%esp 10c27a: 5b pop %ebx 10c27b: 5e pop %esi 10c27c: 5f pop %edi 10c27d: c9 leave 10c27e: c3 ret 10c27f: 90 nop
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10c280: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10c282: 85 ff test %edi,%edi
10c284: 0f 85 e8 fe ff ff jne 10c172 <sigtimedwait+0x52>
10c28a: 8d 7d dc lea -0x24(%ebp),%edi 10c28d: e9 e0 fe ff ff jmp 10c172 <sigtimedwait+0x52> 10c292: 66 90 xchg %ax,%ax
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10c294: 83 ec 0c sub $0xc,%esp 10c297: 56 push %esi 10c298: 89 55 cc mov %edx,-0x34(%ebp) 10c29b: e8 3c fe ff ff call 10c0dc <_POSIX_signals_Get_lowest> 10c2a0: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10c2a2: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c2a9: 6a 00 push $0x0 10c2ab: 57 push %edi 10c2ac: 50 push %eax 10c2ad: 8b 55 cc mov -0x34(%ebp),%edx 10c2b0: 52 push %edx 10c2b1: e8 a2 59 00 00 call 111c58 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10c2b6: ff 75 d0 pushl -0x30(%ebp) 10c2b9: 9d popf
the_info->si_code = SI_USER;
10c2ba: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10c2c1: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10c2c8: 8b 37 mov (%edi),%esi 10c2ca: 83 c4 20 add $0x20,%esp
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10c2cd: 89 f0 mov %esi,%eax 10c2cf: 8d 65 f4 lea -0xc(%ebp),%esp 10c2d2: 5b pop %ebx 10c2d3: 5e pop %esi 10c2d4: 5f pop %edi 10c2d5: c9 leave 10c2d6: c3 ret 10c2d7: 90 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
10c2d8: e8 e3 85 00 00 call 1148c0 <__errno> 10c2dd: c7 00 16 00 00 00 movl $0x16,(%eax) 10c2e3: be ff ff ff ff mov $0xffffffff,%esi 10c2e8: e9 44 ff ff ff jmp 10c231 <sigtimedwait+0x111> 10c2ed: 8d 76 00 lea 0x0(%esi),%esi
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
10c2f0: e8 cb 85 00 00 call 1148c0 <__errno> 10c2f5: 8b 15 98 9b 12 00 mov 0x129b98,%edx 10c2fb: 8b 52 34 mov 0x34(%edx),%edx 10c2fe: 89 10 mov %edx,(%eax)
return -1;
10c300: be ff ff ff ff mov $0xffffffff,%esi 10c305: e9 27 ff ff ff jmp 10c231 <sigtimedwait+0x111>
0010df98 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10df98: 55 push %ebp 10df99: 89 e5 mov %esp,%ebp 10df9b: 53 push %ebx 10df9c: 83 ec 08 sub $0x8,%esp 10df9f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10dfa2: 6a 00 push $0x0 10dfa4: 6a 00 push $0x0 10dfa6: ff 75 08 pushl 0x8(%ebp) 10dfa9: e8 e6 fd ff ff call 10dd94 <sigtimedwait>
if ( status != -1 ) {
10dfae: 83 c4 10 add $0x10,%esp 10dfb1: 83 f8 ff cmp $0xffffffff,%eax
10dfb4: 74 0e je 10dfc4 <sigwait+0x2c>
if ( sig )
10dfb6: 85 db test %ebx,%ebx
10dfb8: 74 16 je 10dfd0 <sigwait+0x38> <== NEVER TAKEN
*sig = status;
10dfba: 89 03 mov %eax,(%ebx)
return 0;
10dfbc: 31 c0 xor %eax,%eax
}
return errno;
}
10dfbe: 8b 5d fc mov -0x4(%ebp),%ebx 10dfc1: c9 leave 10dfc2: c3 ret 10dfc3: 90 nop
if ( sig )
*sig = status;
return 0;
}
return errno;
10dfc4: e8 a7 80 00 00 call 116070 <__errno> 10dfc9: 8b 00 mov (%eax),%eax
}
10dfcb: 8b 5d fc mov -0x4(%ebp),%ebx 10dfce: c9 leave 10dfcf: c3 ret
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
10dfd0: 31 c0 xor %eax,%eax
}
return errno;
}
10dfd2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dfd5: c9 leave <== NOT EXECUTED 10dfd6: c3 ret <== NOT EXECUTED
0010b500 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10b500: 55 push %ebp 10b501: 89 e5 mov %esp,%ebp 10b503: 56 push %esi 10b504: 53 push %ebx 10b505: 8b 5d 0c mov 0xc(%ebp),%ebx 10b508: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10b50b: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10b50f: 0f 85 db 00 00 00 jne 10b5f0 <timer_create+0xf0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10b515: 85 f6 test %esi,%esi
10b517: 0f 84 d3 00 00 00 je 10b5f0 <timer_create+0xf0>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10b51d: 85 db test %ebx,%ebx
10b51f: 74 21 je 10b542 <timer_create+0x42>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10b521: 8b 03 mov (%ebx),%eax 10b523: 48 dec %eax 10b524: 83 f8 01 cmp $0x1,%eax
10b527: 0f 87 c3 00 00 00 ja 10b5f0 <timer_create+0xf0> <== NEVER TAKEN
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
10b52d: 8b 43 04 mov 0x4(%ebx),%eax 10b530: 85 c0 test %eax,%eax
10b532: 0f 84 b8 00 00 00 je 10b5f0 <timer_create+0xf0> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10b538: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10b539: 83 f8 1f cmp $0x1f,%eax
10b53c: 0f 87 ae 00 00 00 ja 10b5f0 <timer_create+0xf0> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b542: a1 d0 a0 12 00 mov 0x12a0d0,%eax 10b547: 40 inc %eax 10b548: a3 d0 a0 12 00 mov %eax,0x12a0d0
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
10b54d: 83 ec 0c sub $0xc,%esp 10b550: 68 20 a4 12 00 push $0x12a420 10b555: e8 9a 1e 00 00 call 10d3f4 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10b55a: 83 c4 10 add $0x10,%esp 10b55d: 85 c0 test %eax,%eax
10b55f: 0f 84 a2 00 00 00 je 10b607 <timer_create+0x107>
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10b565: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10b569: 8b 15 78 a6 12 00 mov 0x12a678,%edx 10b56f: 8b 52 08 mov 0x8(%edx),%edx 10b572: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10b575: 85 db test %ebx,%ebx
10b577: 74 11 je 10b58a <timer_create+0x8a>
ptimer->inf.sigev_notify = evp->sigev_notify;
10b579: 8b 13 mov (%ebx),%edx 10b57b: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10b57e: 8b 53 04 mov 0x4(%ebx),%edx 10b581: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10b584: 8b 53 08 mov 0x8(%ebx),%edx 10b587: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10b58a: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10b591: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10b598: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10b59f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10b5a6: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b5ad: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10b5b4: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10b5bb: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10b5c2: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b5c9: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b5cc: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b5cf: 8b 0d 3c a4 12 00 mov 0x12a43c,%ecx 10b5d5: 89 04 99 mov %eax,(%ecx,%ebx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10b5d8: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
10b5df: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10b5e1: e8 3a 2e 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b5e6: 31 c0 xor %eax,%eax
}
10b5e8: 8d 65 f8 lea -0x8(%ebp),%esp 10b5eb: 5b pop %ebx 10b5ec: 5e pop %esi 10b5ed: c9 leave 10b5ee: c3 ret 10b5ef: 90 nop
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
10b5f0: e8 2f 8a 00 00 call 114024 <__errno> 10b5f5: c7 00 16 00 00 00 movl $0x16,(%eax) 10b5fb: b8 ff ff ff ff mov $0xffffffff,%eax
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b600: 8d 65 f8 lea -0x8(%ebp),%esp 10b603: 5b pop %ebx 10b604: 5e pop %esi 10b605: c9 leave 10b606: c3 ret
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
10b607: e8 14 2e 00 00 call 10e420 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10b60c: e8 13 8a 00 00 call 114024 <__errno> 10b611: c7 00 0b 00 00 00 movl $0xb,(%eax) 10b617: b8 ff ff ff ff mov $0xffffffff,%eax 10b61c: eb ca jmp 10b5e8 <timer_create+0xe8>
0010ba44 <timer_delete>:
int timer_delete(
timer_t timerid
)
{
10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 53 push %ebx 10ba48: 83 ec 18 sub $0x18,%esp
* because rtems_timer_delete stops the timer before deleting it.
*/
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
10ba4b: 8d 45 f4 lea -0xc(%ebp),%eax
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10ba4e: 50 push %eax 10ba4f: ff 75 08 pushl 0x8(%ebp) 10ba52: 68 00 a3 12 00 push $0x12a300 10ba57: e8 9c 21 00 00 call 10dbf8 <_Objects_Get> 10ba5c: 89 c3 mov %eax,%ebx
switch ( location ) {
10ba5e: 83 c4 10 add $0x10,%esp 10ba61: 8b 4d f4 mov -0xc(%ebp),%ecx 10ba64: 85 c9 test %ecx,%ecx
10ba66: 74 18 je 10ba80 <timer_delete+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10ba68: e8 b7 8c 00 00 call 114724 <__errno> 10ba6d: c7 00 16 00 00 00 movl $0x16,(%eax) 10ba73: b8 ff ff ff ff mov $0xffffffff,%eax
}
10ba78: 8b 5d fc mov -0x4(%ebp),%ebx 10ba7b: c9 leave 10ba7c: c3 ret 10ba7d: 8d 76 00 lea 0x0(%esi),%esi
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
10ba80: 83 ec 08 sub $0x8,%esp 10ba83: 50 push %eax 10ba84: 68 00 a3 12 00 push $0x12a300 10ba89: e8 32 1d 00 00 call 10d7c0 <_Objects_Close>
ptimer->state = POSIX_TIMER_STATE_FREE;
10ba8e: c6 43 3c 01 movb $0x1,0x3c(%ebx)
(void) _Watchdog_Remove( &ptimer->Timer );
10ba92: 8d 43 10 lea 0x10(%ebx),%eax 10ba95: 89 04 24 mov %eax,(%esp) 10ba98: e8 6b 3c 00 00 call 10f708 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
10ba9d: 58 pop %eax 10ba9e: 5a pop %edx 10ba9f: 53 push %ebx 10baa0: 68 00 a3 12 00 push $0x12a300 10baa5: e8 0e 20 00 00 call 10dab8 <_Objects_Free>
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
10baaa: e8 c1 2c 00 00 call 10e770 <_Thread_Enable_dispatch>
return 0;
10baaf: 83 c4 10 add $0x10,%esp 10bab2: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10bab4: 8b 5d fc mov -0x4(%ebp),%ebx 10bab7: c9 leave 10bab8: c3 ret
0010c900 <timer_getoverrun>:
* its execution, _POSIX_Timer_TSR will have to set this counter to 0.
*/
int timer_getoverrun(
timer_t timerid
)
{
10c900: 55 push %ebp 10c901: 89 e5 mov %esp,%ebp 10c903: 53 push %ebx 10c904: 83 ec 18 sub $0x18,%esp
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
10c907: 8d 45 f4 lea -0xc(%ebp),%eax
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10c90a: 50 push %eax 10c90b: ff 75 08 pushl 0x8(%ebp) 10c90e: 68 e0 b9 12 00 push $0x12b9e0 10c913: e8 24 21 00 00 call 10ea3c <_Objects_Get>
switch ( location ) {
10c918: 83 c4 10 add $0x10,%esp 10c91b: 8b 55 f4 mov -0xc(%ebp),%edx 10c91e: 85 d2 test %edx,%edx
10c920: 74 1a je 10c93c <timer_getoverrun+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10c922: e8 7d 88 00 00 call 1151a4 <__errno> 10c927: c7 00 16 00 00 00 movl $0x16,(%eax) 10c92d: bb ff ff ff ff mov $0xffffffff,%ebx
}
10c932: 89 d8 mov %ebx,%eax 10c934: 8b 5d fc mov -0x4(%ebp),%ebx 10c937: c9 leave 10c938: c3 ret 10c939: 8d 76 00 lea 0x0(%esi),%esi
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
10c93c: 8b 58 68 mov 0x68(%eax),%ebx
ptimer->overrun = 0;
10c93f: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
_Thread_Enable_dispatch();
10c946: e8 69 2c 00 00 call 10f5b4 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10c94b: 89 d8 mov %ebx,%eax 10c94d: 8b 5d fc mov -0x4(%ebp),%ebx 10c950: c9 leave 10c951: c3 ret
0010c954 <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
10c954: 55 push %ebp 10c955: 89 e5 mov %esp,%ebp 10c957: 56 push %esi 10c958: 53 push %ebx 10c959: 83 ec 10 sub $0x10,%esp 10c95c: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
10c95f: 85 db test %ebx,%ebx
10c961: 74 65 je 10c9c8 <timer_gettime+0x74>
rtems_set_errno_and_return_minus_one( EINVAL );
/* Reads the current time */
_TOD_Get( ¤t_time );
10c963: 83 ec 0c sub $0xc,%esp 10c966: 8d 45 ec lea -0x14(%ebp),%eax 10c969: 50 push %eax 10c96a: e8 fd 16 00 00 call 10e06c <_TOD_Get> 10c96f: 83 c4 0c add $0xc,%esp
ptimer = _POSIX_Timer_Get( timerid, &location );
10c972: 8d 45 f4 lea -0xc(%ebp),%eax 10c975: 50 push %eax 10c976: ff 75 08 pushl 0x8(%ebp) 10c979: 68 e0 b9 12 00 push $0x12b9e0 10c97e: e8 b9 20 00 00 call 10ea3c <_Objects_Get> 10c983: 89 c6 mov %eax,%esi
switch ( location ) {
10c985: 83 c4 10 add $0x10,%esp 10c988: 8b 45 f4 mov -0xc(%ebp),%eax 10c98b: 85 c0 test %eax,%eax
10c98d: 75 39 jne 10c9c8 <timer_gettime+0x74>
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10c98f: a1 c4 b7 12 00 mov 0x12b7c4,%eax
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
10c994: 83 ec 08 sub $0x8,%esp 10c997: 8d 53 08 lea 0x8(%ebx),%edx 10c99a: 52 push %edx
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10c99b: 8b 56 1c mov 0x1c(%esi),%edx 10c99e: 03 56 24 add 0x24(%esi),%edx
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
10c9a1: 29 c2 sub %eax,%edx
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
10c9a3: 52 push %edx 10c9a4: e8 9b 36 00 00 call 110044 <_Timespec_From_ticks>
value->it_interval = ptimer->timer_data.it_interval;
10c9a9: 8b 46 54 mov 0x54(%esi),%eax 10c9ac: 8b 56 58 mov 0x58(%esi),%edx 10c9af: 89 03 mov %eax,(%ebx) 10c9b1: 89 53 04 mov %edx,0x4(%ebx)
_Thread_Enable_dispatch();
10c9b4: e8 fb 2b 00 00 call 10f5b4 <_Thread_Enable_dispatch>
return 0;
10c9b9: 83 c4 10 add $0x10,%esp 10c9bc: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10c9be: 8d 65 f8 lea -0x8(%ebp),%esp 10c9c1: 5b pop %ebx 10c9c2: 5e pop %esi 10c9c3: c9 leave 10c9c4: c3 ret 10c9c5: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10c9c8: e8 d7 87 00 00 call 1151a4 <__errno> 10c9cd: c7 00 16 00 00 00 movl $0x16,(%eax) 10c9d3: b8 ff ff ff ff mov $0xffffffff,%eax 10c9d8: eb e4 jmp 10c9be <timer_gettime+0x6a>
0010b620 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10b620: 55 push %ebp 10b621: 89 e5 mov %esp,%ebp 10b623: 57 push %edi 10b624: 56 push %esi 10b625: 53 push %ebx 10b626: 83 ec 3c sub $0x3c,%esp 10b629: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10b62c: 85 db test %ebx,%ebx
10b62e: 0f 84 50 01 00 00 je 10b784 <timer_settime+0x164> <== NEVER TAKEN
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
10b634: 83 ec 0c sub $0xc,%esp 10b637: 8d 43 08 lea 0x8(%ebx),%eax 10b63a: 50 push %eax 10b63b: e8 94 38 00 00 call 10eed4 <_Timespec_Is_valid> 10b640: 83 c4 10 add $0x10,%esp 10b643: 84 c0 test %al,%al
10b645: 0f 84 39 01 00 00 je 10b784 <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10b64b: 83 ec 0c sub $0xc,%esp 10b64e: 53 push %ebx 10b64f: e8 80 38 00 00 call 10eed4 <_Timespec_Is_valid> 10b654: 83 c4 10 add $0x10,%esp 10b657: 84 c0 test %al,%al
10b659: 0f 84 25 01 00 00 je 10b784 <timer_settime+0x164> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10b65f: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10b663: 0f 84 db 00 00 00 je 10b744 <timer_settime+0x124>
10b669: 8b 45 0c mov 0xc(%ebp),%eax 10b66c: 85 c0 test %eax,%eax
10b66e: 0f 85 10 01 00 00 jne 10b784 <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10b674: 8d 45 cc lea -0x34(%ebp),%eax 10b677: 89 45 c4 mov %eax,-0x3c(%ebp) 10b67a: b9 04 00 00 00 mov $0x4,%ecx 10b67f: 89 c7 mov %eax,%edi 10b681: 89 de mov %ebx,%esi 10b683: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10b685: 50 push %eax
/* If the function reaches this point, then it will be necessary to do
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
10b686: 8d 45 e4 lea -0x1c(%ebp),%eax 10b689: 50 push %eax 10b68a: ff 75 08 pushl 0x8(%ebp) 10b68d: 68 20 a4 12 00 push $0x12a420 10b692: e8 11 22 00 00 call 10d8a8 <_Objects_Get> 10b697: 89 c2 mov %eax,%edx
switch ( location ) {
10b699: 83 c4 10 add $0x10,%esp 10b69c: 8b 7d e4 mov -0x1c(%ebp),%edi 10b69f: 85 ff test %edi,%edi
10b6a1: 0f 85 dd 00 00 00 jne 10b784 <timer_settime+0x164>
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
10b6a7: 8b 75 d4 mov -0x2c(%ebp),%esi 10b6aa: 85 f6 test %esi,%esi
10b6ac: 75 0b jne 10b6b9 <timer_settime+0x99>
10b6ae: 8b 4d d8 mov -0x28(%ebp),%ecx 10b6b1: 85 c9 test %ecx,%ecx
10b6b3: 0f 84 df 00 00 00 je 10b798 <timer_settime+0x178>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10b6b9: 83 ec 0c sub $0xc,%esp 10b6bc: 53 push %ebx 10b6bd: 89 55 c0 mov %edx,-0x40(%ebp) 10b6c0: e8 77 38 00 00 call 10ef3c <_Timespec_To_ticks> 10b6c5: 8b 55 c0 mov -0x40(%ebp),%edx 10b6c8: 89 42 64 mov %eax,0x64(%edx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10b6cb: 8d 45 d4 lea -0x2c(%ebp),%eax 10b6ce: 89 04 24 mov %eax,(%esp) 10b6d1: e8 66 38 00 00 call 10ef3c <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10b6d6: 8b 55 c0 mov -0x40(%ebp),%edx 10b6d9: 89 14 24 mov %edx,(%esp) 10b6dc: 68 04 b8 10 00 push $0x10b804 10b6e1: ff 72 08 pushl 0x8(%edx) 10b6e4: 50 push %eax 10b6e5: 8d 42 10 lea 0x10(%edx),%eax 10b6e8: 50 push %eax 10b6e9: e8 6e 61 00 00 call 11185c <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10b6ee: 83 c4 20 add $0x20,%esp 10b6f1: 84 c0 test %al,%al 10b6f3: 8b 55 c0 mov -0x40(%ebp),%edx
10b6f6: 0f 84 e8 00 00 00 je 10b7e4 <timer_settime+0x1c4>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10b6fc: 8b 45 14 mov 0x14(%ebp),%eax 10b6ff: 85 c0 test %eax,%eax
10b701: 0f 84 ed 00 00 00 je 10b7f4 <timer_settime+0x1d4>
*ovalue = ptimer->timer_data;
10b707: 8d 42 54 lea 0x54(%edx),%eax 10b70a: b9 04 00 00 00 mov $0x4,%ecx 10b70f: 8b 7d 14 mov 0x14(%ebp),%edi 10b712: 89 c6 mov %eax,%esi 10b714: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10b716: b9 04 00 00 00 mov $0x4,%ecx 10b71b: 89 c7 mov %eax,%edi 10b71d: 8b 75 c4 mov -0x3c(%ebp),%esi 10b720: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10b722: c6 42 3c 03 movb $0x3,0x3c(%edx)
_TOD_Get( &ptimer->time );
10b726: 83 ec 0c sub $0xc,%esp 10b729: 83 c2 6c add $0x6c,%edx 10b72c: 52 push %edx 10b72d: e8 ca 17 00 00 call 10cefc <_TOD_Get>
_Thread_Enable_dispatch();
10b732: e8 e9 2c 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b737: 83 c4 10 add $0x10,%esp 10b73a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b73c: 8d 65 f4 lea -0xc(%ebp),%esp 10b73f: 5b pop %ebx 10b740: 5e pop %esi 10b741: 5f pop %edi 10b742: c9 leave 10b743: c3 ret
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10b744: 8d 45 cc lea -0x34(%ebp),%eax 10b747: 89 45 c4 mov %eax,-0x3c(%ebp) 10b74a: 89 c7 mov %eax,%edi 10b74c: 89 de mov %ebx,%esi 10b74e: 8b 4d 0c mov 0xc(%ebp),%ecx 10b751: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
10b753: 83 ec 0c sub $0xc,%esp 10b756: 8d 75 dc lea -0x24(%ebp),%esi 10b759: 56 push %esi 10b75a: e8 9d 17 00 00 call 10cefc <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10b75f: 59 pop %ecx 10b760: 5f pop %edi 10b761: 8d 7d d4 lea -0x2c(%ebp),%edi 10b764: 57 push %edi 10b765: 56 push %esi 10b766: e8 45 37 00 00 call 10eeb0 <_Timespec_Greater_than> 10b76b: 83 c4 10 add $0x10,%esp 10b76e: 84 c0 test %al,%al
10b770: 75 12 jne 10b784 <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10b772: 52 push %edx 10b773: 57 push %edi 10b774: 57 push %edi 10b775: 56 push %esi 10b776: e8 81 37 00 00 call 10eefc <_Timespec_Subtract> 10b77b: 83 c4 10 add $0x10,%esp 10b77e: e9 02 ff ff ff jmp 10b685 <timer_settime+0x65> 10b783: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b784: e8 9b 88 00 00 call 114024 <__errno> 10b789: c7 00 16 00 00 00 movl $0x16,(%eax) 10b78f: b8 ff ff ff ff mov $0xffffffff,%eax 10b794: eb a6 jmp 10b73c <timer_settime+0x11c> 10b796: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10b798: 83 ec 0c sub $0xc,%esp 10b79b: 8d 40 10 lea 0x10(%eax),%eax 10b79e: 50 push %eax 10b79f: 89 55 c0 mov %edx,-0x40(%ebp) 10b7a2: e8 c9 3b 00 00 call 10f370 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: 8b 55 14 mov 0x14(%ebp),%edx 10b7ad: 85 d2 test %edx,%edx 10b7af: 8b 55 c0 mov -0x40(%ebp),%edx
10b7b2: 74 48 je 10b7fc <timer_settime+0x1dc>
*ovalue = ptimer->timer_data;
10b7b4: 8d 42 54 lea 0x54(%edx),%eax 10b7b7: b9 04 00 00 00 mov $0x4,%ecx 10b7bc: 8b 7d 14 mov 0x14(%ebp),%edi 10b7bf: 89 c6 mov %eax,%esi 10b7c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10b7c3: b9 04 00 00 00 mov $0x4,%ecx 10b7c8: 89 c7 mov %eax,%edi 10b7ca: 8b 75 c4 mov -0x3c(%ebp),%esi 10b7cd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10b7cf: c6 42 3c 04 movb $0x4,0x3c(%edx)
/* Returns with success */
_Thread_Enable_dispatch();
10b7d3: e8 48 2c 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b7d8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b7da: 8d 65 f4 lea -0xc(%ebp),%esp 10b7dd: 5b pop %ebx 10b7de: 5e pop %esi 10b7df: 5f pop %edi 10b7e0: c9 leave 10b7e1: c3 ret 10b7e2: 66 90 xchg %ax,%ax
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
_Thread_Enable_dispatch();
10b7e4: e8 37 2c 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b7e9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b7eb: 8d 65 f4 lea -0xc(%ebp),%esp 10b7ee: 5b pop %ebx 10b7ef: 5e pop %esi 10b7f0: 5f pop %edi 10b7f1: c9 leave 10b7f2: c3 ret 10b7f3: 90 nop 10b7f4: 8d 42 54 lea 0x54(%edx),%eax 10b7f7: e9 1a ff ff ff jmp 10b716 <timer_settime+0xf6> 10b7fc: 8d 42 54 lea 0x54(%edx),%eax 10b7ff: eb c2 jmp 10b7c3 <timer_settime+0x1a3>
0010b410 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
10b410: 55 push %ebp 10b411: 89 e5 mov %esp,%ebp 10b413: 56 push %esi 10b414: 53 push %ebx 10b415: 83 ec 10 sub $0x10,%esp 10b418: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
10b41b: 8b 0d 5c a6 12 00 mov 0x12a65c,%ecx 10b421: 85 c9 test %ecx,%ecx
10b423: 0f 84 8f 00 00 00 je 10b4b8 <ualarm+0xa8>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
10b429: 83 ec 0c sub $0xc,%esp 10b42c: 68 40 a6 12 00 push $0x12a640 10b431: e8 9a 3a 00 00 call 10eed0 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10b436: 83 e8 02 sub $0x2,%eax 10b439: 83 c4 10 add $0x10,%esp 10b43c: 83 f8 01 cmp $0x1,%eax
10b43f: 0f 86 a3 00 00 00 jbe 10b4e8 <ualarm+0xd8> <== ALWAYS TAKEN
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10b445: 31 f6 xor %esi,%esi
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
10b447: 85 db test %ebx,%ebx
10b449: 74 62 je 10b4ad <ualarm+0x9d>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10b44b: ba 83 de 1b 43 mov $0x431bde83,%edx 10b450: 89 d8 mov %ebx,%eax 10b452: f7 e2 mul %edx 10b454: c1 ea 12 shr $0x12,%edx 10b457: 89 55 f0 mov %edx,-0x10(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10b45a: 8d 04 92 lea (%edx,%edx,4),%eax 10b45d: 8d 04 80 lea (%eax,%eax,4),%eax 10b460: 8d 04 80 lea (%eax,%eax,4),%eax 10b463: 8d 04 80 lea (%eax,%eax,4),%eax 10b466: 8d 04 80 lea (%eax,%eax,4),%eax 10b469: 8d 04 80 lea (%eax,%eax,4),%eax 10b46c: c1 e0 06 shl $0x6,%eax 10b46f: 29 c3 sub %eax,%ebx 10b471: 8d 04 9b lea (%ebx,%ebx,4),%eax 10b474: 8d 04 80 lea (%eax,%eax,4),%eax 10b477: 8d 04 80 lea (%eax,%eax,4),%eax 10b47a: c1 e0 03 shl $0x3,%eax 10b47d: 89 45 f4 mov %eax,-0xc(%ebp)
ticks = _Timespec_To_ticks( &tp );
10b480: 83 ec 0c sub $0xc,%esp 10b483: 8d 5d f0 lea -0x10(%ebp),%ebx 10b486: 53 push %ebx 10b487: e8 98 35 00 00 call 10ea24 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10b48c: 89 1c 24 mov %ebx,(%esp) 10b48f: e8 90 35 00 00 call 10ea24 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b494: a3 4c a6 12 00 mov %eax,0x12a64c
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b499: 58 pop %eax 10b49a: 5a pop %edx 10b49b: 68 40 a6 12 00 push $0x12a640 10b4a0: 68 60 9d 12 00 push $0x129d60 10b4a5: e8 e6 38 00 00 call 10ed90 <_Watchdog_Insert> 10b4aa: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10b4ad: 89 f0 mov %esi,%eax 10b4af: 8d 65 f8 lea -0x8(%ebp),%esp 10b4b2: 5b pop %ebx 10b4b3: 5e pop %esi 10b4b4: c9 leave 10b4b5: c3 ret 10b4b6: 66 90 xchg %ax,%ax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b4b8: c7 05 48 a6 12 00 00 movl $0x0,0x12a648
10b4bf: 00 00 00 the_watchdog->routine = routine;
10b4c2: c7 05 5c a6 12 00 d4 movl $0x10b3d4,0x12a65c
10b4c9: b3 10 00 the_watchdog->id = id;
10b4cc: c7 05 60 a6 12 00 00 movl $0x0,0x12a660
10b4d3: 00 00 00 the_watchdog->user_data = user_data;
10b4d6: c7 05 64 a6 12 00 00 movl $0x0,0x12a664
10b4dd: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10b4e0: 31 f6 xor %esi,%esi 10b4e2: e9 60 ff ff ff jmp 10b447 <ualarm+0x37> 10b4e7: 90 nop
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
10b4e8: a1 54 a6 12 00 mov 0x12a654,%eax 10b4ed: 03 05 4c a6 12 00 add 0x12a64c,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10b4f3: 83 ec 08 sub $0x8,%esp 10b4f6: 8d 55 f0 lea -0x10(%ebp),%edx 10b4f9: 52 push %edx
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
10b4fa: 2b 05 58 a6 12 00 sub 0x12a658,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10b500: 50 push %eax 10b501: e8 96 34 00 00 call 10e99c <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
10b506: 8b 45 f0 mov -0x10(%ebp),%eax 10b509: 8d 04 80 lea (%eax,%eax,4),%eax 10b50c: 8d 04 80 lea (%eax,%eax,4),%eax 10b50f: 8d 04 80 lea (%eax,%eax,4),%eax 10b512: 8d 04 80 lea (%eax,%eax,4),%eax 10b515: 8d 04 80 lea (%eax,%eax,4),%eax 10b518: 8d 0c 80 lea (%eax,%eax,4),%ecx 10b51b: c1 e1 06 shl $0x6,%ecx
remaining += tp.tv_nsec / 1000;
10b51e: 8b 75 f4 mov -0xc(%ebp),%esi 10b521: b8 d3 4d 62 10 mov $0x10624dd3,%eax 10b526: f7 ee imul %esi 10b528: 89 d0 mov %edx,%eax 10b52a: c1 f8 06 sar $0x6,%eax 10b52d: c1 fe 1f sar $0x1f,%esi 10b530: 29 f0 sub %esi,%eax 10b532: 8d 34 08 lea (%eax,%ecx,1),%esi 10b535: 83 c4 10 add $0x10,%esp 10b538: e9 0a ff ff ff jmp 10b447 <ualarm+0x37>