RTEMS 4.11Annotated Report
Wed Mar 9 16:11:11 2011
0010ce60 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10ce60: 55 push %ebp
10ce61: 89 e5 mov %esp,%ebp
10ce63: 53 push %ebx
10ce64: 83 ec 04 sub $0x4,%esp
10ce67: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce6a: 8b 15 78 88 12 00 mov 0x128878,%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 );
10ce70: 9c pushf
10ce71: fa cli
10ce72: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce73: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce76: 85 c9 test %ecx,%ecx
10ce78: 75 0b jne 10ce85 <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce7a: 50 push %eax
10ce7b: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce7c: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce83: eb 72 jmp 10cef7 <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce85: 49 dec %ecx
10ce86: 75 0f jne 10ce97 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce88: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce8b: 49 dec %ecx
10ce8c: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce8f: 85 c9 test %ecx,%ecx
10ce91: 74 04 je 10ce97 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce93: 50 push %eax
10ce94: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce95: eb 60 jmp 10cef7 <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce97: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
10ce9e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10cea5: 50 push %eax
10cea6: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10cea7: 83 ec 0c sub $0xc,%esp
10ceaa: 53 push %ebx
10ceab: e8 f0 17 00 00 call 10e6a0 <_Thread_queue_Dequeue>
if ( next ) {
10ceb0: 83 c4 10 add $0x10,%esp
10ceb3: 85 c0 test %eax,%eax
10ceb5: 74 40 je 10cef7 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ceb7: 83 78 30 01 cmpl $0x1,0x30(%eax)
10cebb: 75 09 jne 10cec6 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10cebd: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10cec4: eb 31 jmp 10cef7 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10cec6: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10cec9: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
10ced0: 83 ec 0c sub $0xc,%esp
10ced3: 53 push %ebx
10ced4: e8 bf 1b 00 00 call 10ea98 <_Thread_queue_First>
if ( !next ||
10ced9: 83 c4 10 add $0x10,%esp
10cedc: 85 c0 test %eax,%eax
10cede: 74 17 je 10cef7 <_CORE_RWLock_Release+0x97>
10cee0: 83 78 30 01 cmpl $0x1,0x30(%eax)
10cee4: 74 11 je 10cef7 <_CORE_RWLock_Release+0x97><== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
10cee6: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10cee9: 52 push %edx
10ceea: 52 push %edx
10ceeb: 50 push %eax
10ceec: 53 push %ebx
10ceed: e8 96 1a 00 00 call 10e988 <_Thread_queue_Extract>
}
10cef2: 83 c4 10 add $0x10,%esp
10cef5: eb d9 jmp 10ced0 <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10cef7: 31 c0 xor %eax,%eax
10cef9: 8b 5d fc mov -0x4(%ebp),%ebx
10cefc: c9 leave
10cefd: c3 ret
0010cf00 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10cf00: 55 push %ebp
10cf01: 89 e5 mov %esp,%ebp
10cf03: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cf06: 8d 45 f4 lea -0xc(%ebp),%eax
10cf09: 50 push %eax
10cf0a: ff 75 08 pushl 0x8(%ebp)
10cf0d: e8 72 14 00 00 call 10e384 <_Thread_Get>
switch ( location ) {
10cf12: 83 c4 10 add $0x10,%esp
10cf15: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10cf19: 75 17 jne 10cf32 <_CORE_RWLock_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10cf1b: 83 ec 0c sub $0xc,%esp
10cf1e: 50 push %eax
10cf1f: e8 40 1c 00 00 call 10eb64 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10cf24: a1 50 83 12 00 mov 0x128350,%eax
10cf29: 48 dec %eax
10cf2a: a3 50 83 12 00 mov %eax,0x128350
10cf2f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cf32: c9 leave
10cf33: c3 ret
001173c0 <_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
)
{
1173c0: 55 push %ebp
1173c1: 89 e5 mov %esp,%ebp
1173c3: 57 push %edi
1173c4: 56 push %esi
1173c5: 53 push %ebx
1173c6: 83 ec 1c sub $0x1c,%esp
1173c9: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
1173cc: b8 01 00 00 00 mov $0x1,%eax
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
1173d1: 8b 55 10 mov 0x10(%ebp),%edx
1173d4: 3b 53 4c cmp 0x4c(%ebx),%edx
1173d7: 77 4e ja 117427 <_CORE_message_queue_Broadcast+0x67><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
1173d9: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
1173dd: 75 09 jne 1173e8 <_CORE_message_queue_Broadcast+0x28>
1173df: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
1173e6: eb 23 jmp 11740b <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
1173e8: 8b 45 1c mov 0x1c(%ebp),%eax
1173eb: c7 00 00 00 00 00 movl $0x0,(%eax)
1173f1: eb 32 jmp 117425 <_CORE_message_queue_Broadcast+0x65>
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
1173f3: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1173f6: 8b 42 2c mov 0x2c(%edx),%eax
1173f9: 89 c7 mov %eax,%edi
1173fb: 8b 75 0c mov 0xc(%ebp),%esi
1173fe: 8b 4d 10 mov 0x10(%ebp),%ecx
117401: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
117403: 8b 42 28 mov 0x28(%edx),%eax
117406: 8b 55 10 mov 0x10(%ebp),%edx
117409: 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 =
11740b: 83 ec 0c sub $0xc,%esp
11740e: 53 push %ebx
11740f: e8 28 25 00 00 call 11993c <_Thread_queue_Dequeue>
117414: 89 c2 mov %eax,%edx
117416: 83 c4 10 add $0x10,%esp
117419: 85 c0 test %eax,%eax
11741b: 75 d6 jne 1173f3 <_CORE_message_queue_Broadcast+0x33>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
11741d: 8b 55 e4 mov -0x1c(%ebp),%edx
117420: 8b 45 1c mov 0x1c(%ebp),%eax
117423: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
117425: 31 c0 xor %eax,%eax
}
117427: 8d 65 f4 lea -0xc(%ebp),%esp
11742a: 5b pop %ebx
11742b: 5e pop %esi
11742c: 5f pop %edi
11742d: c9 leave
11742e: c3 ret
00112274 <_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
)
{
112274: 55 push %ebp
112275: 89 e5 mov %esp,%ebp
112277: 57 push %edi
112278: 56 push %esi
112279: 53 push %ebx
11227a: 83 ec 1c sub $0x1c,%esp
11227d: 8b 5d 08 mov 0x8(%ebp),%ebx
112280: 8b 7d 10 mov 0x10(%ebp),%edi
112283: 8b 55 14 mov 0x14(%ebp),%edx
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
112286: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
112289: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112290: 89 53 4c mov %edx,0x4c(%ebx)
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
112293: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
11229a: 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)) {
1122a1: 89 d0 mov %edx,%eax
1122a3: f6 c2 03 test $0x3,%dl
1122a6: 74 0c je 1122b4 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
1122a8: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
1122ab: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
1122ae: 31 f6 xor %esi,%esi
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
allocated_message_size += sizeof(uint32_t);
allocated_message_size &= ~(sizeof(uint32_t) - 1);
}
if (allocated_message_size < maximum_message_size)
1122b0: 39 d0 cmp %edx,%eax
1122b2: 72 68 jb 11231c <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
1122b4: 8d 50 14 lea 0x14(%eax),%edx
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
1122b7: 89 d1 mov %edx,%ecx
1122b9: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
1122bc: 31 f6 xor %esi,%esi
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
1122be: 39 c1 cmp %eax,%ecx
1122c0: 72 5a jb 11231c <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
1122c2: 83 ec 0c sub $0xc,%esp
1122c5: 51 push %ecx
1122c6: 89 55 e4 mov %edx,-0x1c(%ebp)
1122c9: e8 b4 27 00 00 call 114a82 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
1122ce: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
1122d1: 83 c4 10 add $0x10,%esp
1122d4: 85 c0 test %eax,%eax
1122d6: 8b 55 e4 mov -0x1c(%ebp),%edx
1122d9: 74 41 je 11231c <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
1122db: 52 push %edx
1122dc: 57 push %edi
1122dd: 50 push %eax
1122de: 8d 43 68 lea 0x68(%ebx),%eax
1122e1: 50 push %eax
1122e2: e8 f5 4a 00 00 call 116ddc <_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 );
1122e7: 8d 43 54 lea 0x54(%ebx),%eax
1122ea: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
1122ed: 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 );
1122f4: 8d 43 50 lea 0x50(%ebx),%eax
1122f7: 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(
1122fa: 6a 06 push $0x6
1122fc: 68 80 00 00 00 push $0x80
112301: 8b 45 0c mov 0xc(%ebp),%eax
112304: 83 38 01 cmpl $0x1,(%eax)
112307: 0f 94 c0 sete %al
11230a: 0f b6 c0 movzbl %al,%eax
11230d: 50 push %eax
11230e: 53 push %ebx
11230f: e8 94 1f 00 00 call 1142a8 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
112314: 83 c4 20 add $0x20,%esp
112317: be 01 00 00 00 mov $0x1,%esi
}
11231c: 89 f0 mov %esi,%eax
11231e: 8d 65 f4 lea -0xc(%ebp),%esp
112321: 5b pop %ebx
112322: 5e pop %esi
112323: 5f pop %edi
112324: c9 leave
112325: c3 ret
00112328 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
112328: 55 push %ebp
112329: 89 e5 mov %esp,%ebp
11232b: 57 push %edi
11232c: 56 push %esi
11232d: 53 push %ebx
11232e: 83 ec 2c sub $0x2c,%esp
112331: 8b 55 08 mov 0x8(%ebp),%edx
112334: 8b 45 0c mov 0xc(%ebp),%eax
112337: 89 45 dc mov %eax,-0x24(%ebp)
11233a: 8b 5d 10 mov 0x10(%ebp),%ebx
11233d: 89 5d e0 mov %ebx,-0x20(%ebp)
112340: 8b 4d 14 mov 0x14(%ebp),%ecx
112343: 8b 75 1c mov 0x1c(%ebp),%esi
112346: 89 75 d4 mov %esi,-0x2c(%ebp)
112349: 8a 45 18 mov 0x18(%ebp),%al
11234c: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
11234f: a1 f0 d9 12 00 mov 0x12d9f0,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
112354: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
11235b: 9c pushf
11235c: fa cli
11235d: 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 );
}
112360: 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 );
112363: 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))
112366: 39 f3 cmp %esi,%ebx
112368: 0f 84 8a 00 00 00 je 1123f8 <_CORE_message_queue_Seize+0xd0>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
11236e: 8b 33 mov (%ebx),%esi
head->next = new_first;
112370: 89 72 50 mov %esi,0x50(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
112373: 8d 7a 50 lea 0x50(%edx),%edi
112376: 89 7e 04 mov %edi,0x4(%esi)
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 ) {
112379: 85 db test %ebx,%ebx
11237b: 74 7b je 1123f8 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
11237d: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
112380: ff 75 e4 pushl -0x1c(%ebp)
112383: 9d popf
*size_p = the_message->Contents.size;
112384: 8b 43 0c mov 0xc(%ebx),%eax
112387: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
112389: 8b 73 08 mov 0x8(%ebx),%esi
11238c: a1 f0 d9 12 00 mov 0x12d9f0,%eax
112391: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112394: 8d 73 10 lea 0x10(%ebx),%esi
112397: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11239a: 8b 09 mov (%ecx),%ecx
11239c: 8b 7d e0 mov -0x20(%ebp),%edi
11239f: 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 );
1123a1: 83 ec 0c sub $0xc,%esp
1123a4: 52 push %edx
1123a5: 89 55 d0 mov %edx,-0x30(%ebp)
1123a8: e8 c3 1b 00 00 call 113f70 <_Thread_queue_Dequeue>
if ( !the_thread ) {
1123ad: 83 c4 10 add $0x10,%esp
1123b0: 85 c0 test %eax,%eax
1123b2: 8b 55 d0 mov -0x30(%ebp),%edx
1123b5: 75 15 jne 1123cc <_CORE_message_queue_Seize+0xa4>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
1123b7: 89 5d 0c mov %ebx,0xc(%ebp)
1123ba: 83 c2 68 add $0x68,%edx
1123bd: 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 );
}
1123c0: 8d 65 f4 lea -0xc(%ebp),%esp
1123c3: 5b pop %ebx
1123c4: 5e pop %esi
1123c5: 5f pop %edi
1123c6: c9 leave
1123c7: e9 28 fe ff ff jmp 1121f4 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
1123cc: 8b 48 24 mov 0x24(%eax),%ecx
1123cf: 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;
1123d2: 8b 48 30 mov 0x30(%eax),%ecx
1123d5: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1123d8: 8b 70 2c mov 0x2c(%eax),%esi
1123db: 8b 7d e4 mov -0x1c(%ebp),%edi
1123de: 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(
1123e0: 8b 43 08 mov 0x8(%ebx),%eax
1123e3: 89 45 10 mov %eax,0x10(%ebp)
1123e6: 89 5d 0c mov %ebx,0xc(%ebp)
1123e9: 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 );
}
1123ec: 8d 65 f4 lea -0xc(%ebp),%esp
1123ef: 5b pop %ebx
1123f0: 5e pop %esi
1123f1: 5f pop %edi
1123f2: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
1123f3: e9 1c 4a 00 00 jmp 116e14 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
1123f8: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
1123fc: 75 13 jne 112411 <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
1123fe: ff 75 e4 pushl -0x1c(%ebp)
112401: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
112402: c7 40 34 04 00 00 00 movl $0x4,0x34(%eax)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
112409: 8d 65 f4 lea -0xc(%ebp),%esp
11240c: 5b pop %ebx
11240d: 5e pop %esi
11240e: 5f pop %edi
11240f: c9 leave
112410: c3 ret
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
112411: 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;
112418: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
11241b: 8b 5d dc mov -0x24(%ebp),%ebx
11241e: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
112421: 8b 75 e0 mov -0x20(%ebp),%esi
112424: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
112427: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
11242a: ff 75 e4 pushl -0x1c(%ebp)
11242d: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
11242e: c7 45 10 58 43 11 00 movl $0x114358,0x10(%ebp)
112435: 8b 45 d4 mov -0x2c(%ebp),%eax
112438: 89 45 0c mov %eax,0xc(%ebp)
11243b: 89 55 08 mov %edx,0x8(%ebp)
}
11243e: 8d 65 f4 lea -0xc(%ebp),%esp
112441: 5b pop %ebx
112442: 5e pop %esi
112443: 5f pop %edi
112444: 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 );
112445: e9 32 1c 00 00 jmp 11407c <_Thread_queue_Enqueue_with_handler>
0010ab98 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10ab98: 55 push %ebp
10ab99: 89 e5 mov %esp,%ebp
10ab9b: 57 push %edi
10ab9c: 56 push %esi
10ab9d: 53 push %ebx
10ab9e: 83 ec 0c sub $0xc,%esp
10aba1: 8b 55 08 mov 0x8(%ebp),%edx
10aba4: 8b 5d 0c mov 0xc(%ebp),%ebx
10aba7: 8b 45 10 mov 0x10(%ebp),%eax
/* 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;
10abaa: 8d 7a 40 lea 0x40(%edx),%edi
10abad: b9 04 00 00 00 mov $0x4,%ecx
10abb2: 89 de mov %ebx,%esi
10abb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10abb6: 89 42 50 mov %eax,0x50(%edx)
the_mutex->blocked_count = 0;
10abb9: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10abc0: 85 c0 test %eax,%eax
10abc2: 75 35 jne 10abf9 <_CORE_mutex_Initialize+0x61>
the_mutex->nest_count = 1;
10abc4: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx)
the_mutex->holder = _Thread_Executing;
10abcb: 8b 0d 68 58 12 00 mov 0x125868,%ecx
10abd1: 89 4a 5c mov %ecx,0x5c(%edx)
the_mutex->holder_id = _Thread_Executing->Object.id;
10abd4: 8b 41 08 mov 0x8(%ecx),%eax
10abd7: 89 42 60 mov %eax,0x60(%edx)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10abda: 8b 42 48 mov 0x48(%edx),%eax
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 ) ||
10abdd: 83 f8 02 cmp $0x2,%eax
10abe0: 74 05 je 10abe7 <_CORE_mutex_Initialize+0x4f>
10abe2: 83 f8 03 cmp $0x3,%eax
10abe5: 75 27 jne 10ac0e <_CORE_mutex_Initialize+0x76>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
10abe7: b8 06 00 00 00 mov $0x6,%eax
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10abec: 8b 72 4c mov 0x4c(%edx),%esi
10abef: 39 71 14 cmp %esi,0x14(%ecx)
10abf2: 72 36 jb 10ac2a <_CORE_mutex_Initialize+0x92><== NEVER TAKEN
_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++;
10abf4: ff 41 1c incl 0x1c(%ecx)
10abf7: eb 15 jmp 10ac0e <_CORE_mutex_Initialize+0x76>
}
} else {
the_mutex->nest_count = 0;
10abf9: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
the_mutex->holder = NULL;
10ac00: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
the_mutex->holder_id = 0;
10ac07: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx)
}
_Thread_queue_Initialize(
10ac0e: 6a 05 push $0x5
10ac10: 68 00 04 00 00 push $0x400
10ac15: 31 c0 xor %eax,%eax
10ac17: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10ac1b: 0f 95 c0 setne %al
10ac1e: 50 push %eax
10ac1f: 52 push %edx
10ac20: e8 4b 1c 00 00 call 10c870 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10ac25: 83 c4 10 add $0x10,%esp
10ac28: 31 c0 xor %eax,%eax
}
10ac2a: 8d 65 f4 lea -0xc(%ebp),%esp
10ac2d: 5b pop %ebx
10ac2e: 5e pop %esi
10ac2f: 5f pop %edi
10ac30: c9 leave
10ac31: c3 ret
0010ac81 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac81: 55 push %ebp
10ac82: 89 e5 mov %esp,%ebp
10ac84: 53 push %ebx
10ac85: 83 ec 14 sub $0x14,%esp
10ac88: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac8b: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac8e: a1 40 53 12 00 mov 0x125340,%eax
10ac93: 85 c0 test %eax,%eax
10ac95: 74 19 je 10acb0 <_CORE_mutex_Seize+0x2f>
10ac97: 84 d2 test %dl,%dl
10ac99: 74 15 je 10acb0 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac9b: 83 3d 9c 54 12 00 01 cmpl $0x1,0x12549c
10aca2: 76 0c jbe 10acb0 <_CORE_mutex_Seize+0x2f>
10aca4: 53 push %ebx
10aca5: 6a 12 push $0x12
10aca7: 6a 00 push $0x0
10aca9: 6a 00 push $0x0
10acab: e8 dc 05 00 00 call 10b28c <_Internal_error_Occurred>
10acb0: 51 push %ecx
10acb1: 51 push %ecx
10acb2: 8d 45 18 lea 0x18(%ebp),%eax
10acb5: 50 push %eax
10acb6: 53 push %ebx
10acb7: 88 55 f4 mov %dl,-0xc(%ebp)
10acba: e8 d5 47 00 00 call 10f494 <_CORE_mutex_Seize_interrupt_trylock>
10acbf: 83 c4 10 add $0x10,%esp
10acc2: 85 c0 test %eax,%eax
10acc4: 8a 55 f4 mov -0xc(%ebp),%dl
10acc7: 74 48 je 10ad11 <_CORE_mutex_Seize+0x90>
10acc9: 84 d2 test %dl,%dl
10accb: 75 12 jne 10acdf <_CORE_mutex_Seize+0x5e>
10accd: ff 75 18 pushl 0x18(%ebp)
10acd0: 9d popf
10acd1: a1 68 58 12 00 mov 0x125868,%eax
10acd6: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10acdd: eb 32 jmp 10ad11 <_CORE_mutex_Seize+0x90>
10acdf: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ace6: a1 68 58 12 00 mov 0x125868,%eax
10aceb: 89 58 44 mov %ebx,0x44(%eax)
10acee: 8b 55 0c mov 0xc(%ebp),%edx
10acf1: 89 50 20 mov %edx,0x20(%eax)
10acf4: a1 40 53 12 00 mov 0x125340,%eax
10acf9: 40 inc %eax
10acfa: a3 40 53 12 00 mov %eax,0x125340
10acff: ff 75 18 pushl 0x18(%ebp)
10ad02: 9d popf
10ad03: 50 push %eax
10ad04: 50 push %eax
10ad05: ff 75 14 pushl 0x14(%ebp)
10ad08: 53 push %ebx
10ad09: e8 26 ff ff ff call 10ac34 <_CORE_mutex_Seize_interrupt_blocking>
10ad0e: 83 c4 10 add $0x10,%esp
}
10ad11: 8b 5d fc mov -0x4(%ebp),%ebx
10ad14: c9 leave
10ad15: c3 ret
0010ae3c <_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
)
{
10ae3c: 55 push %ebp
10ae3d: 89 e5 mov %esp,%ebp
10ae3f: 53 push %ebx
10ae40: 83 ec 10 sub $0x10,%esp
10ae43: 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)) ) {
10ae46: 53 push %ebx
10ae47: e8 ec 16 00 00 call 10c538 <_Thread_queue_Dequeue>
10ae4c: 89 c2 mov %eax,%edx
10ae4e: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae51: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10ae53: 85 d2 test %edx,%edx
10ae55: 75 15 jne 10ae6c <_CORE_semaphore_Surrender+0x30>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10ae57: 9c pushf
10ae58: fa cli
10ae59: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae5a: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10ae5d: b0 04 mov $0x4,%al
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae5f: 3b 53 40 cmp 0x40(%ebx),%edx
10ae62: 73 06 jae 10ae6a <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae64: 42 inc %edx
10ae65: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae68: 30 c0 xor %al,%al
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
10ae6a: 51 push %ecx
10ae6b: 9d popf
}
return status;
}
10ae6c: 8b 5d fc mov -0x4(%ebp),%ebx
10ae6f: c9 leave
10ae70: c3 ret
00109da0 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109da0: 55 push %ebp
109da1: 89 e5 mov %esp,%ebp
109da3: 57 push %edi
109da4: 56 push %esi
109da5: 53 push %ebx
109da6: 83 ec 2c sub $0x2c,%esp
109da9: 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 ];
109dac: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109db2: 8b 43 30 mov 0x30(%ebx),%eax
109db5: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109db8: 9c pushf
109db9: fa cli
109dba: 58 pop %eax
pending_events = api->pending_events;
109dbb: 8b 17 mov (%edi),%edx
109dbd: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109dc0: 8b 73 24 mov 0x24(%ebx),%esi
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
109dc3: 21 f2 and %esi,%edx
109dc5: 75 07 jne 109dce <_Event_Surrender+0x2e>
_ISR_Enable( level );
109dc7: 50 push %eax
109dc8: 9d popf
return;
109dc9: e9 af 00 00 00 jmp 109e7d <_Event_Surrender+0xdd>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
109dce: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864
109dd5: 74 49 je 109e20 <_Event_Surrender+0x80>
109dd7: 3b 1d 68 58 12 00 cmp 0x125868,%ebx
109ddd: 75 41 jne 109e20 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109ddf: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
109de5: 83 f9 02 cmp $0x2,%ecx
109de8: 74 09 je 109df3 <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109dea: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109df0: 49 dec %ecx
109df1: 75 2d jne 109e20 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109df3: 39 f2 cmp %esi,%edx
109df5: 74 06 je 109dfd <_Event_Surrender+0x5d>
109df7: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dfb: 74 1f je 109e1c <_Event_Surrender+0x7c> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
109dfd: 89 d6 mov %edx,%esi
109dff: f7 d6 not %esi
109e01: 23 75 d4 and -0x2c(%ebp),%esi
109e04: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109e06: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109e0d: 8b 4b 28 mov 0x28(%ebx),%ecx
109e10: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109e12: c7 05 3c 5c 12 00 03 movl $0x3,0x125c3c
109e19: 00 00 00
}
_ISR_Enable( level );
109e1c: 50 push %eax
109e1d: 9d popf
return;
109e1e: eb 5d jmp 109e7d <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109e20: f6 43 11 01 testb $0x1,0x11(%ebx)
109e24: 74 55 je 109e7b <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109e26: 39 f2 cmp %esi,%edx
109e28: 74 06 je 109e30 <_Event_Surrender+0x90>
109e2a: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109e2e: 74 4b je 109e7b <_Event_Surrender+0xdb> <== NEVER TAKEN
109e30: 89 d6 mov %edx,%esi
109e32: f7 d6 not %esi
109e34: 23 75 d4 and -0x2c(%ebp),%esi
109e37: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109e39: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109e40: 8b 4b 28 mov 0x28(%ebx),%ecx
109e43: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109e45: 50 push %eax
109e46: 9d popf
109e47: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109e48: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109e4c: 74 06 je 109e54 <_Event_Surrender+0xb4>
_ISR_Enable( level );
109e4e: 50 push %eax
109e4f: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109e50: 51 push %ecx
109e51: 51 push %ecx
109e52: eb 17 jmp 109e6b <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109e54: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e5b: 50 push %eax
109e5c: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e5d: 83 ec 0c sub $0xc,%esp
109e60: 8d 43 48 lea 0x48(%ebx),%eax
109e63: 50 push %eax
109e64: e8 c7 30 00 00 call 10cf30 <_Watchdog_Remove>
109e69: 58 pop %eax
109e6a: 5a pop %edx
109e6b: 68 f8 ff 03 10 push $0x1003fff8
109e70: 53 push %ebx
109e71: e8 6e 20 00 00 call 10bee4 <_Thread_Clear_state>
109e76: 83 c4 10 add $0x10,%esp
109e79: eb 02 jmp 109e7d <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e7b: 50 push %eax
109e7c: 9d popf
}
109e7d: 8d 65 f4 lea -0xc(%ebp),%esp
109e80: 5b pop %ebx
109e81: 5e pop %esi
109e82: 5f pop %edi
109e83: c9 leave
109e84: c3 ret
00109e88 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e88: 55 push %ebp
109e89: 89 e5 mov %esp,%ebp
109e8b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e8e: 8d 45 f4 lea -0xc(%ebp),%eax
109e91: 50 push %eax
109e92: ff 75 08 pushl 0x8(%ebp)
109e95: e8 82 23 00 00 call 10c21c <_Thread_Get>
switch ( location ) {
109e9a: 83 c4 10 add $0x10,%esp
109e9d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109ea1: 75 49 jne 109eec <_Event_Timeout+0x64> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
109ea3: 9c pushf
109ea4: fa cli
109ea5: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109ea6: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109ead: 3b 05 68 58 12 00 cmp 0x125868,%eax
109eb3: 75 13 jne 109ec8 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109eb5: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
109ebb: 49 dec %ecx
109ebc: 75 0a jne 109ec8 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109ebe: c7 05 3c 5c 12 00 02 movl $0x2,0x125c3c
109ec5: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109ec8: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109ecf: 52 push %edx
109ed0: 9d popf
109ed1: 52 push %edx
109ed2: 52 push %edx
109ed3: 68 f8 ff 03 10 push $0x1003fff8
109ed8: 50 push %eax
109ed9: e8 06 20 00 00 call 10bee4 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109ede: a1 40 53 12 00 mov 0x125340,%eax
109ee3: 48 dec %eax
109ee4: a3 40 53 12 00 mov %eax,0x125340
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109ee9: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109eec: c9 leave
109eed: c3 ret
0010faeb <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10faeb: 55 push %ebp
10faec: 89 e5 mov %esp,%ebp
10faee: 57 push %edi
10faef: 56 push %esi
10faf0: 53 push %ebx
10faf1: 83 ec 4c sub $0x4c,%esp
10faf4: 8b 5d 08 mov 0x8(%ebp),%ebx
10faf7: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10fafa: 8b 43 20 mov 0x20(%ebx),%eax
10fafd: 89 45 c0 mov %eax,-0x40(%ebp)
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
10fb00: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10fb07: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10fb0e: 8b 53 10 mov 0x10(%ebx),%edx
10fb11: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10fb14: 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;
10fb17: 8b 7b 30 mov 0x30(%ebx),%edi
10fb1a: 89 7d bc mov %edi,-0x44(%ebp)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return false;
10fb1d: 31 f6 xor %esi,%esi
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
10fb1f: 8b 7d 0c mov 0xc(%ebp),%edi
10fb22: 01 cf add %ecx,%edi
10fb24: 0f 82 d4 01 00 00 jb 10fcfe <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10fb2a: 52 push %edx
10fb2b: 52 push %edx
10fb2c: 8d 55 e0 lea -0x20(%ebp),%edx
10fb2f: 52 push %edx
10fb30: 8d 55 e4 lea -0x1c(%ebp),%edx
10fb33: 52 push %edx
10fb34: 50 push %eax
10fb35: ff 75 c4 pushl -0x3c(%ebp)
10fb38: 51 push %ecx
10fb39: ff 75 0c pushl 0xc(%ebp)
10fb3c: e8 6e b8 ff ff call 10b3af <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10fb41: 83 c4 20 add $0x20,%esp
10fb44: 84 c0 test %al,%al
10fb46: 0f 84 b2 01 00 00 je 10fcfe <_Heap_Extend+0x213>
10fb4c: 8b 4d c0 mov -0x40(%ebp),%ecx
10fb4f: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10fb56: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10fb5d: 31 f6 xor %esi,%esi
10fb5f: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
10fb66: 8b 43 18 mov 0x18(%ebx),%eax
10fb69: 89 5d b8 mov %ebx,-0x48(%ebp)
10fb6c: eb 02 jmp 10fb70 <_Heap_Extend+0x85>
10fb6e: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10fb70: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10fb72: 39 c7 cmp %eax,%edi
10fb74: 76 09 jbe 10fb7f <_Heap_Extend+0x94>
10fb76: 39 5d 0c cmp %ebx,0xc(%ebp)
10fb79: 0f 82 7d 01 00 00 jb 10fcfc <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fb7f: 39 c7 cmp %eax,%edi
10fb81: 74 06 je 10fb89 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fb83: 39 df cmp %ebx,%edi
10fb85: 72 07 jb 10fb8e <_Heap_Extend+0xa3>
10fb87: eb 08 jmp 10fb91 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fb89: 89 4d d0 mov %ecx,-0x30(%ebp)
10fb8c: eb 03 jmp 10fb91 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fb8e: 89 4d c8 mov %ecx,-0x38(%ebp)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fb91: 8d 43 f8 lea -0x8(%ebx),%eax
10fb94: 89 45 d4 mov %eax,-0x2c(%ebp)
10fb97: 89 d8 mov %ebx,%eax
10fb99: 31 d2 xor %edx,%edx
10fb9b: f7 75 c4 divl -0x3c(%ebp)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
10fb9e: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fba1: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fba4: 75 07 jne 10fbad <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fba6: 89 39 mov %edi,(%ecx)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
10fba8: 8b 75 d4 mov -0x2c(%ebp),%esi
10fbab: eb 08 jmp 10fbb5 <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fbad: 73 06 jae 10fbb5 <_Heap_Extend+0xca>
10fbaf: 8b 55 d4 mov -0x2c(%ebp),%edx
10fbb2: 89 55 cc mov %edx,-0x34(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10fbb5: 8b 45 d4 mov -0x2c(%ebp),%eax
10fbb8: 8b 48 04 mov 0x4(%eax),%ecx
10fbbb: 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);
10fbbe: 01 c1 add %eax,%ecx
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
10fbc0: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fbc3: 75 a9 jne 10fb6e <_Heap_Extend+0x83>
10fbc5: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fbc8: 8b 55 0c mov 0xc(%ebp),%edx
10fbcb: 3b 53 18 cmp 0x18(%ebx),%edx
10fbce: 73 05 jae 10fbd5 <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fbd0: 89 53 18 mov %edx,0x18(%ebx)
10fbd3: eb 08 jmp 10fbdd <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fbd5: 39 7b 1c cmp %edi,0x1c(%ebx)
10fbd8: 73 03 jae 10fbdd <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fbda: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fbdd: 8b 45 e0 mov -0x20(%ebp),%eax
10fbe0: 8b 55 e4 mov -0x1c(%ebp),%edx
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
10fbe3: 89 c1 mov %eax,%ecx
10fbe5: 29 d1 sub %edx,%ecx
10fbe7: 89 4d d4 mov %ecx,-0x2c(%ebp)
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
10fbea: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fbec: 83 c9 01 or $0x1,%ecx
10fbef: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fbf2: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fbf5: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fbf7: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
10fbfe: 39 53 20 cmp %edx,0x20(%ebx)
10fc01: 76 05 jbe 10fc08 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fc03: 89 53 20 mov %edx,0x20(%ebx)
10fc06: eb 08 jmp 10fc10 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fc08: 39 43 24 cmp %eax,0x24(%ebx)
10fc0b: 73 03 jae 10fc10 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fc0d: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fc10: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fc14: 74 3b je 10fc51 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fc16: 8b 43 10 mov 0x10(%ebx),%eax
10fc19: 89 45 d4 mov %eax,-0x2c(%ebp)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
10fc1c: 8b 4d 0c mov 0xc(%ebp),%ecx
10fc1f: 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;
10fc22: 89 c8 mov %ecx,%eax
10fc24: 31 d2 xor %edx,%edx
10fc26: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fc29: 85 d2 test %edx,%edx
10fc2b: 74 05 je 10fc32 <_Heap_Extend+0x147>
return value - remainder + alignment;
10fc2d: 03 4d d4 add -0x2c(%ebp),%ecx
10fc30: 29 d1 sub %edx,%ecx
uintptr_t const new_first_block_begin =
10fc32: 8d 51 f8 lea -0x8(%ecx),%edx
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
10fc35: 8b 45 d0 mov -0x30(%ebp),%eax
10fc38: 8b 00 mov (%eax),%eax
10fc3a: 89 41 f8 mov %eax,-0x8(%ecx)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
10fc3d: 8b 45 d0 mov -0x30(%ebp),%eax
10fc40: 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;
10fc42: 83 c8 01 or $0x1,%eax
10fc45: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fc48: 89 d8 mov %ebx,%eax
10fc4a: e8 81 fe ff ff call 10fad0 <_Heap_Free_block>
10fc4f: eb 14 jmp 10fc65 <_Heap_Extend+0x17a>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
10fc51: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fc55: 74 0e je 10fc65 <_Heap_Extend+0x17a>
_Heap_Link_below(
10fc57: 8b 55 e0 mov -0x20(%ebp),%edx
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
10fc5a: 8b 45 c8 mov -0x38(%ebp),%eax
10fc5d: 29 d0 sub %edx,%eax
10fc5f: 83 c8 01 or $0x1,%eax
10fc62: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10fc65: 85 f6 test %esi,%esi
10fc67: 74 30 je 10fc99 <_Heap_Extend+0x1ae>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
10fc69: 83 ef 08 sub $0x8,%edi
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
10fc6c: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fc6e: 89 f8 mov %edi,%eax
10fc70: 31 d2 xor %edx,%edx
10fc72: f7 73 10 divl 0x10(%ebx)
10fc75: 29 d7 sub %edx,%edi
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
10fc77: 8b 46 04 mov 0x4(%esi),%eax
10fc7a: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fc7c: 83 c8 01 or $0x1,%eax
10fc7f: 89 44 37 04 mov %eax,0x4(%edi,%esi,1)
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10fc83: 8b 46 04 mov 0x4(%esi),%eax
10fc86: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fc89: 09 f8 or %edi,%eax
10fc8b: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fc8e: 89 f2 mov %esi,%edx
10fc90: 89 d8 mov %ebx,%eax
10fc92: e8 39 fe ff ff call 10fad0 <_Heap_Free_block>
10fc97: eb 21 jmp 10fcba <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fc99: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fc9d: 74 1b je 10fcba <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fc9f: 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 );
10fca2: 8b 45 e4 mov -0x1c(%ebp),%eax
10fca5: 2b 45 cc sub -0x34(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10fca8: 8b 7d cc mov -0x34(%ebp),%edi
10fcab: 8b 57 04 mov 0x4(%edi),%edx
10fcae: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fcb1: 09 d0 or %edx,%eax
10fcb3: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fcb6: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fcba: 85 f6 test %esi,%esi
10fcbc: 75 10 jne 10fcce <_Heap_Extend+0x1e3>
10fcbe: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fcc2: 75 0a jne 10fcce <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fcc4: 8b 55 e4 mov -0x1c(%ebp),%edx
10fcc7: 89 d8 mov %ebx,%eax
10fcc9: e8 02 fe ff ff call 10fad0 <_Heap_Free_block>
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
10fcce: 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(
10fcd1: 8b 43 20 mov 0x20(%ebx),%eax
10fcd4: 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;
10fcd6: 8b 4a 04 mov 0x4(%edx),%ecx
10fcd9: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fcdc: 09 c8 or %ecx,%eax
10fcde: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fce1: 8b 43 30 mov 0x30(%ebx),%eax
10fce4: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fce7: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fcea: be 01 00 00 00 mov $0x1,%esi
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
10fcef: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fcf3: 74 09 je 10fcfe <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fcf5: 8b 55 14 mov 0x14(%ebp),%edx
10fcf8: 89 02 mov %eax,(%edx)
10fcfa: eb 02 jmp 10fcfe <_Heap_Extend+0x213>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
10fcfc: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fcfe: 89 f0 mov %esi,%eax
10fd00: 8d 65 f4 lea -0xc(%ebp),%esp
10fd03: 5b pop %ebx
10fd04: 5e pop %esi
10fd05: 5f pop %edi
10fd06: c9 leave
10fd07: c3 ret
0010f730 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f730: 55 push %ebp
10f731: 89 e5 mov %esp,%ebp
10f733: 57 push %edi
10f734: 56 push %esi
10f735: 53 push %ebx
10f736: 83 ec 14 sub $0x14,%esp
10f739: 8b 4d 08 mov 0x8(%ebp),%ecx
10f73c: 8b 55 0c mov 0xc(%ebp),%edx
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
10f73f: b0 01 mov $0x1,%al
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
10f741: 85 d2 test %edx,%edx
10f743: 0f 84 4b 01 00 00 je 10f894 <_Heap_Free+0x164>
10f749: 8d 5a f8 lea -0x8(%edx),%ebx
10f74c: 89 d0 mov %edx,%eax
10f74e: 31 d2 xor %edx,%edx
10f750: f7 71 10 divl 0x10(%ecx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
10f753: 29 d3 sub %edx,%ebx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
10f755: 8b 41 20 mov 0x20(%ecx),%eax
10f758: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f75b: 31 d2 xor %edx,%edx
10f75d: 39 c3 cmp %eax,%ebx
10f75f: 72 08 jb 10f769 <_Heap_Free+0x39>
10f761: 31 d2 xor %edx,%edx
10f763: 39 59 24 cmp %ebx,0x24(%ecx)
10f766: 0f 93 c2 setae %dl
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
10f769: 31 c0 xor %eax,%eax
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
10f76b: 85 d2 test %edx,%edx
10f76d: 0f 84 21 01 00 00 je 10f894 <_Heap_Free+0x164>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f773: 8b 43 04 mov 0x4(%ebx),%eax
10f776: 89 45 f0 mov %eax,-0x10(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10f779: 89 c6 mov %eax,%esi
10f77b: 83 e6 fe and $0xfffffffe,%esi
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10f77e: 8d 14 33 lea (%ebx,%esi,1),%edx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f781: 31 ff xor %edi,%edi
10f783: 3b 55 ec cmp -0x14(%ebp),%edx
10f786: 72 0a jb 10f792 <_Heap_Free+0x62> <== NEVER TAKEN
10f788: 31 c0 xor %eax,%eax
10f78a: 39 51 24 cmp %edx,0x24(%ecx)
10f78d: 0f 93 c0 setae %al
10f790: 89 c7 mov %eax,%edi
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
10f792: 31 c0 xor %eax,%eax
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10f794: 85 ff test %edi,%edi
10f796: 0f 84 f8 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f79c: 8b 7a 04 mov 0x4(%edx),%edi
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
10f79f: f7 c7 01 00 00 00 test $0x1,%edi
10f7a5: 0f 84 e9 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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;
10f7ab: 83 e7 fe and $0xfffffffe,%edi
10f7ae: 89 7d e8 mov %edi,-0x18(%ebp)
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
10f7b1: 8b 41 24 mov 0x24(%ecx),%eax
10f7b4: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f7b7: 31 c0 xor %eax,%eax
10f7b9: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f7bc: 74 0a je 10f7c8 <_Heap_Free+0x98>
10f7be: 31 c0 xor %eax,%eax
10f7c0: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f7c5: 0f 94 c0 sete %al
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
10f7c8: 88 45 e3 mov %al,-0x1d(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
10f7cb: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f7cf: 75 62 jne 10f833 <_Heap_Free+0x103>
uintptr_t const prev_size = block->prev_size;
10f7d1: 8b 03 mov (%ebx),%eax
10f7d3: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10f7d6: 29 c3 sub %eax,%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f7d8: 31 ff xor %edi,%edi
10f7da: 3b 5d ec cmp -0x14(%ebp),%ebx
10f7dd: 72 0a jb 10f7e9 <_Heap_Free+0xb9> <== NEVER TAKEN
10f7df: 31 c0 xor %eax,%eax
10f7e1: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f7e4: 0f 93 c0 setae %al
10f7e7: 89 c7 mov %eax,%edi
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
_HAssert( false );
return( false );
10f7e9: 31 c0 xor %eax,%eax
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
10f7eb: 85 ff test %edi,%edi
10f7ed: 0f 84 a1 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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) ) {
10f7f3: f6 43 04 01 testb $0x1,0x4(%ebx)
10f7f7: 0f 84 97 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f7fd: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f801: 74 1a je 10f81d <_Heap_Free+0xed>
uintptr_t const size = block_size + prev_size + next_block_size;
10f803: 8b 45 e8 mov -0x18(%ebp),%eax
10f806: 8d 04 06 lea (%esi,%eax,1),%eax
10f809: 03 45 f0 add -0x10(%ebp),%eax
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
10f80c: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f80f: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f812: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f815: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f818: ff 49 38 decl 0x38(%ecx)
10f81b: eb 33 jmp 10f850 <_Heap_Free+0x120>
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;
10f81d: 8b 45 f0 mov -0x10(%ebp),%eax
10f820: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f823: 89 c7 mov %eax,%edi
10f825: 83 cf 01 or $0x1,%edi
10f828: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f82b: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f82f: 89 02 mov %eax,(%edx)
10f831: eb 56 jmp 10f889 <_Heap_Free+0x159>
}
} else if ( next_is_free ) { /* coalesce next */
10f833: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f837: 74 24 je 10f85d <_Heap_Free+0x12d>
uintptr_t const size = block_size + next_block_size;
10f839: 8b 45 e8 mov -0x18(%ebp),%eax
10f83c: 01 f0 add %esi,%eax
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
10f83e: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f841: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f844: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f847: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f84a: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f84d: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f850: 89 c2 mov %eax,%edx
10f852: 83 ca 01 or $0x1,%edx
10f855: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f858: 89 04 03 mov %eax,(%ebx,%eax,1)
10f85b: eb 2c jmp 10f889 <_Heap_Free+0x159>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
10f85d: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f860: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f863: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f866: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f869: 89 58 0c mov %ebx,0xc(%eax)
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
10f86c: 89 f0 mov %esi,%eax
10f86e: 83 c8 01 or $0x1,%eax
10f871: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f874: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f878: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f87a: 8b 41 38 mov 0x38(%ecx),%eax
10f87d: 40 inc %eax
10f87e: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f881: 39 41 3c cmp %eax,0x3c(%ecx)
10f884: 73 03 jae 10f889 <_Heap_Free+0x159>
stats->max_free_blocks = stats->free_blocks;
10f886: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f889: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f88c: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f88f: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f892: b0 01 mov $0x1,%al
}
10f894: 83 c4 14 add $0x14,%esp
10f897: 5b pop %ebx
10f898: 5e pop %esi
10f899: 5f pop %edi
10f89a: c9 leave
10f89b: c3 ret
0011d4e0 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11d4e0: 55 push %ebp
11d4e1: 89 e5 mov %esp,%ebp
11d4e3: 57 push %edi
11d4e4: 56 push %esi
11d4e5: 53 push %ebx
11d4e6: 8b 5d 08 mov 0x8(%ebp),%ebx
11d4e9: 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);
11d4ec: 8d 4e f8 lea -0x8(%esi),%ecx
11d4ef: 89 f0 mov %esi,%eax
11d4f1: 31 d2 xor %edx,%edx
11d4f3: 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);
11d4f6: 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
11d4f8: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11d4fb: 31 ff xor %edi,%edi
11d4fd: 39 d1 cmp %edx,%ecx
11d4ff: 72 0a jb 11d50b <_Heap_Size_of_alloc_area+0x2b>
11d501: 31 c0 xor %eax,%eax
11d503: 39 4b 24 cmp %ecx,0x24(%ebx)
11d506: 0f 93 c0 setae %al
11d509: 89 c7 mov %eax,%edi
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
11d50b: 31 c0 xor %eax,%eax
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
11d50d: 85 ff test %edi,%edi
11d50f: 74 30 je 11d541 <_Heap_Size_of_alloc_area+0x61>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11d511: 8b 41 04 mov 0x4(%ecx),%eax
11d514: 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);
11d517: 01 c1 add %eax,%ecx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11d519: 31 ff xor %edi,%edi
11d51b: 39 d1 cmp %edx,%ecx
11d51d: 72 0a jb 11d529 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11d51f: 31 c0 xor %eax,%eax
11d521: 39 4b 24 cmp %ecx,0x24(%ebx)
11d524: 0f 93 c0 setae %al
11d527: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11d529: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11d52b: 85 ff test %edi,%edi
11d52d: 74 12 je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11d52f: f6 41 04 01 testb $0x1,0x4(%ecx)
11d533: 74 0c je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11d535: 29 f1 sub %esi,%ecx
11d537: 8d 51 04 lea 0x4(%ecx),%edx
11d53a: 8b 45 10 mov 0x10(%ebp),%eax
11d53d: 89 10 mov %edx,(%eax)
return true;
11d53f: b0 01 mov $0x1,%al
}
11d541: 5b pop %ebx
11d542: 5e pop %esi
11d543: 5f pop %edi
11d544: c9 leave
11d545: c3 ret
0010bc76 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc76: 55 push %ebp
10bc77: 89 e5 mov %esp,%ebp
10bc79: 57 push %edi
10bc7a: 56 push %esi
10bc7b: 53 push %ebx
10bc7c: 83 ec 4c sub $0x4c,%esp
10bc7f: 8b 75 08 mov 0x8(%ebp),%esi
10bc82: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc85: 8b 46 10 mov 0x10(%esi),%eax
10bc88: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc8b: 8b 4e 14 mov 0x14(%esi),%ecx
10bc8e: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc91: 8b 46 20 mov 0x20(%esi),%eax
10bc94: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc97: 8b 4e 24 mov 0x24(%esi),%ecx
10bc9a: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc9d: c7 45 e4 38 bc 10 00 movl $0x10bc38,-0x1c(%ebp)
10bca4: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bca8: 74 07 je 10bcb1 <_Heap_Walk+0x3b>
10bcaa: c7 45 e4 3d bc 10 00 movl $0x10bc3d,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bcb1: b0 01 mov $0x1,%al
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10bcb3: 83 3d 24 75 12 00 03 cmpl $0x3,0x127524
10bcba: 0f 85 e8 02 00 00 jne 10bfa8 <_Heap_Walk+0x332>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
10bcc0: 52 push %edx
10bcc1: ff 76 0c pushl 0xc(%esi)
10bcc4: ff 76 08 pushl 0x8(%esi)
10bcc7: ff 75 c8 pushl -0x38(%ebp)
10bcca: ff 75 d0 pushl -0x30(%ebp)
10bccd: ff 76 1c pushl 0x1c(%esi)
10bcd0: ff 76 18 pushl 0x18(%esi)
10bcd3: ff 75 d4 pushl -0x2c(%ebp)
10bcd6: ff 75 d8 pushl -0x28(%ebp)
10bcd9: 68 85 00 12 00 push $0x120085
10bcde: 6a 00 push $0x0
10bce0: 53 push %ebx
10bce1: ff 55 e4 call *-0x1c(%ebp)
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
10bce4: 83 c4 30 add $0x30,%esp
10bce7: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bceb: 75 0b jne 10bcf8 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bced: 50 push %eax
10bcee: 68 16 01 12 00 push $0x120116
10bcf3: e9 6b 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bcf8: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bcfc: 74 0d je 10bd0b <_Heap_Walk+0x95>
(*printer)(
10bcfe: ff 75 d8 pushl -0x28(%ebp)
10bd01: 68 29 01 12 00 push $0x120129
10bd06: e9 58 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd0b: 8b 45 d4 mov -0x2c(%ebp),%eax
10bd0e: 31 d2 xor %edx,%edx
10bd10: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bd13: 85 d2 test %edx,%edx
10bd15: 74 0d je 10bd24 <_Heap_Walk+0xae>
(*printer)(
10bd17: ff 75 d4 pushl -0x2c(%ebp)
10bd1a: 68 47 01 12 00 push $0x120147
10bd1f: e9 3f 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10bd24: 8b 45 d0 mov -0x30(%ebp),%eax
10bd27: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd2a: 31 d2 xor %edx,%edx
10bd2c: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bd2f: 85 d2 test %edx,%edx
10bd31: 74 0d je 10bd40 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bd33: ff 75 d0 pushl -0x30(%ebp)
10bd36: 68 6b 01 12 00 push $0x12016b
10bd3b: e9 23 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bd40: 8b 45 d0 mov -0x30(%ebp),%eax
10bd43: f6 40 04 01 testb $0x1,0x4(%eax)
10bd47: 75 0b jne 10bd54 <_Heap_Walk+0xde>
(*printer)(
10bd49: 57 push %edi
10bd4a: 68 9c 01 12 00 push $0x12019c
10bd4f: e9 0f 02 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10bd54: 8b 4d c8 mov -0x38(%ebp),%ecx
10bd57: 8b 79 04 mov 0x4(%ecx),%edi
10bd5a: 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);
10bd5d: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bd5f: f6 47 04 01 testb $0x1,0x4(%edi)
10bd63: 75 0b jne 10bd70 <_Heap_Walk+0xfa>
(*printer)(
10bd65: 56 push %esi
10bd66: 68 ca 01 12 00 push $0x1201ca
10bd6b: e9 f3 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd70: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd73: 74 0b je 10bd80 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd75: 51 push %ecx <== NOT EXECUTED
10bd76: 68 df 01 12 00 push $0x1201df <== NOT EXECUTED
10bd7b: e9 e3 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd80: 8b 46 10 mov 0x10(%esi),%eax
10bd83: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd86: 8b 4e 08 mov 0x8(%esi),%ecx
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
10bd89: 89 75 dc mov %esi,-0x24(%ebp)
10bd8c: eb 75 jmp 10be03 <_Heap_Walk+0x18d>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10bd8e: 31 c0 xor %eax,%eax
10bd90: 39 4e 20 cmp %ecx,0x20(%esi)
10bd93: 77 08 ja 10bd9d <_Heap_Walk+0x127>
10bd95: 31 c0 xor %eax,%eax
10bd97: 39 4e 24 cmp %ecx,0x24(%esi)
10bd9a: 0f 93 c0 setae %al
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
10bd9d: 85 c0 test %eax,%eax
10bd9f: 75 0b jne 10bdac <_Heap_Walk+0x136>
(*printer)(
10bda1: 51 push %ecx
10bda2: 68 0e 02 12 00 push $0x12020e
10bda7: e9 b7 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10bdac: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bdaf: 31 d2 xor %edx,%edx
10bdb1: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bdb4: 85 d2 test %edx,%edx
10bdb6: 74 0b je 10bdc3 <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bdb8: 51 push %ecx
10bdb9: 68 2e 02 12 00 push $0x12022e
10bdbe: e9 a0 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10bdc3: 8b 41 04 mov 0x4(%ecx),%eax
10bdc6: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bdc9: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bdce: 74 0b je 10bddb <_Heap_Walk+0x165>
(*printer)(
10bdd0: 51 push %ecx
10bdd1: 68 5e 02 12 00 push $0x12025e
10bdd6: e9 88 01 00 00 jmp 10bf63 <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bddb: 8b 41 0c mov 0xc(%ecx),%eax
10bdde: 3b 45 dc cmp -0x24(%ebp),%eax
10bde1: 74 1a je 10bdfd <_Heap_Walk+0x187>
(*printer)(
10bde3: 83 ec 0c sub $0xc,%esp
10bde6: 50 push %eax
10bde7: 51 push %ecx
10bde8: 68 7a 02 12 00 push $0x12027a
10bded: 6a 01 push $0x1
10bdef: 53 push %ebx
10bdf0: ff 55 e4 call *-0x1c(%ebp)
10bdf3: 83 c4 20 add $0x20,%esp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
10bdf6: 31 c0 xor %eax,%eax
10bdf8: e9 ab 01 00 00 jmp 10bfa8 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bdfd: 89 4d dc mov %ecx,-0x24(%ebp)
10be00: 8b 49 08 mov 0x8(%ecx),%ecx
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10be03: 39 f1 cmp %esi,%ecx
10be05: 75 87 jne 10bd8e <_Heap_Walk+0x118>
10be07: 89 5d dc mov %ebx,-0x24(%ebp)
10be0a: eb 02 jmp 10be0e <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10be0c: 89 df mov %ebx,%edi
return true;
}
10be0e: 8b 4f 04 mov 0x4(%edi),%ecx
10be11: 89 4d cc mov %ecx,-0x34(%ebp)
10be14: 83 e1 fe and $0xfffffffe,%ecx
10be17: 89 4d e0 mov %ecx,-0x20(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10be1a: 8d 1c 0f lea (%edi,%ecx,1),%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10be1d: 31 c0 xor %eax,%eax
10be1f: 39 5e 20 cmp %ebx,0x20(%esi)
10be22: 77 08 ja 10be2c <_Heap_Walk+0x1b6> <== NEVER TAKEN
10be24: 31 c0 xor %eax,%eax
10be26: 39 5e 24 cmp %ebx,0x24(%esi)
10be29: 0f 93 c0 setae %al
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10be2c: 85 c0 test %eax,%eax
10be2e: 75 11 jne 10be41 <_Heap_Walk+0x1cb>
10be30: 89 d9 mov %ebx,%ecx
10be32: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be35: 83 ec 0c sub $0xc,%esp
10be38: 51 push %ecx
10be39: 57 push %edi
10be3a: 68 ac 02 12 00 push $0x1202ac
10be3f: eb ac jmp 10bded <_Heap_Walk+0x177>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
10be41: 3b 7d c8 cmp -0x38(%ebp),%edi
10be44: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10be47: 8b 45 e0 mov -0x20(%ebp),%eax
10be4a: 31 d2 xor %edx,%edx
10be4c: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10be4f: 85 d2 test %edx,%edx
10be51: 74 15 je 10be68 <_Heap_Walk+0x1f2>
10be53: 84 c9 test %cl,%cl
10be55: 74 11 je 10be68 <_Heap_Walk+0x1f2>
10be57: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be5a: 83 ec 0c sub $0xc,%esp
10be5d: ff 75 e0 pushl -0x20(%ebp)
10be60: 57 push %edi
10be61: 68 d9 02 12 00 push $0x1202d9
10be66: eb 85 jmp 10bded <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be68: 8b 45 d4 mov -0x2c(%ebp),%eax
10be6b: 39 45 e0 cmp %eax,-0x20(%ebp)
10be6e: 73 18 jae 10be88 <_Heap_Walk+0x212>
10be70: 84 c9 test %cl,%cl
10be72: 74 14 je 10be88 <_Heap_Walk+0x212> <== NEVER TAKEN
10be74: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be77: 52 push %edx
10be78: 52 push %edx
10be79: 50 push %eax
10be7a: ff 75 e0 pushl -0x20(%ebp)
10be7d: 57 push %edi
10be7e: 68 07 03 12 00 push $0x120307
10be83: e9 65 ff ff ff jmp 10bded <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be88: 39 fb cmp %edi,%ebx
10be8a: 77 18 ja 10bea4 <_Heap_Walk+0x22e>
10be8c: 84 c9 test %cl,%cl
10be8e: 74 14 je 10bea4 <_Heap_Walk+0x22e>
10be90: 89 d9 mov %ebx,%ecx
10be92: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be95: 83 ec 0c sub $0xc,%esp
10be98: 51 push %ecx
10be99: 57 push %edi
10be9a: 68 32 03 12 00 push $0x120332
10be9f: e9 49 ff ff ff jmp 10bded <_Heap_Walk+0x177>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10bea4: 8b 4d cc mov -0x34(%ebp),%ecx
10bea7: 83 e1 01 and $0x1,%ecx
10beaa: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10bead: f6 43 04 01 testb $0x1,0x4(%ebx)
10beb1: 0f 85 ba 00 00 00 jne 10bf71 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10beb7: 8b 46 08 mov 0x8(%esi),%eax
10beba: 89 45 c0 mov %eax,-0x40(%ebp)
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
10bebd: 8b 4f 08 mov 0x8(%edi),%ecx
10bec0: 89 4d b4 mov %ecx,-0x4c(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10bec3: ba 52 00 12 00 mov $0x120052,%edx
10bec8: 3b 4e 0c cmp 0xc(%esi),%ecx
10becb: 74 0e je 10bedb <_Heap_Walk+0x265>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10becd: ba 99 ff 11 00 mov $0x11ff99,%edx
10bed2: 39 f1 cmp %esi,%ecx
10bed4: 75 05 jne 10bedb <_Heap_Walk+0x265>
10bed6: ba 61 00 12 00 mov $0x120061,%edx
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
10bedb: 8b 47 0c mov 0xc(%edi),%eax
10bede: 89 45 cc mov %eax,-0x34(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10bee1: b8 6b 00 12 00 mov $0x12006b,%eax
10bee6: 8b 4d c0 mov -0x40(%ebp),%ecx
10bee9: 39 4d cc cmp %ecx,-0x34(%ebp)
10beec: 74 0f je 10befd <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10beee: b8 99 ff 11 00 mov $0x11ff99,%eax
10bef3: 39 75 cc cmp %esi,-0x34(%ebp)
10bef6: 75 05 jne 10befd <_Heap_Walk+0x287>
10bef8: b8 7b 00 12 00 mov $0x12007b,%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)(
10befd: 83 ec 0c sub $0xc,%esp
10bf00: 52 push %edx
10bf01: ff 75 b4 pushl -0x4c(%ebp)
10bf04: 50 push %eax
10bf05: ff 75 cc pushl -0x34(%ebp)
10bf08: ff 75 e0 pushl -0x20(%ebp)
10bf0b: 57 push %edi
10bf0c: 68 66 03 12 00 push $0x120366
10bf11: 6a 00 push $0x0
10bf13: ff 75 dc pushl -0x24(%ebp)
10bf16: ff 55 e4 call *-0x1c(%ebp)
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
10bf19: 8b 03 mov (%ebx),%eax
10bf1b: 83 c4 30 add $0x30,%esp
10bf1e: 39 45 e0 cmp %eax,-0x20(%ebp)
10bf21: 74 16 je 10bf39 <_Heap_Walk+0x2c3>
10bf23: 89 d9 mov %ebx,%ecx
10bf25: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bf28: 56 push %esi
10bf29: 51 push %ecx
10bf2a: 50 push %eax
10bf2b: ff 75 e0 pushl -0x20(%ebp)
10bf2e: 57 push %edi
10bf2f: 68 9b 03 12 00 push $0x12039b
10bf34: e9 b4 fe ff ff jmp 10bded <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bf39: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf3d: 75 0b jne 10bf4a <_Heap_Walk+0x2d4>
10bf3f: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bf42: 57 push %edi
10bf43: 68 d4 03 12 00 push $0x1203d4
10bf48: eb 19 jmp 10bf63 <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10bf4a: 8b 46 08 mov 0x8(%esi),%eax
10bf4d: eb 07 jmp 10bf56 <_Heap_Walk+0x2e0>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
10bf4f: 39 f8 cmp %edi,%eax
10bf51: 74 4a je 10bf9d <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10bf53: 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 ) {
10bf56: 39 f0 cmp %esi,%eax
10bf58: 75 f5 jne 10bf4f <_Heap_Walk+0x2d9>
10bf5a: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10bf5d: 57 push %edi
10bf5e: 68 3f 04 12 00 push $0x12043f
10bf63: 6a 01 push $0x1
10bf65: 53 push %ebx
10bf66: ff 55 e4 call *-0x1c(%ebp)
10bf69: 83 c4 10 add $0x10,%esp
10bf6c: e9 85 fe ff ff jmp 10bdf6 <_Heap_Walk+0x180>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10bf71: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf75: 74 0e je 10bf85 <_Heap_Walk+0x30f>
(*printer)(
10bf77: 83 ec 0c sub $0xc,%esp
10bf7a: ff 75 e0 pushl -0x20(%ebp)
10bf7d: 57 push %edi
10bf7e: 68 03 04 12 00 push $0x120403
10bf83: eb 0d jmp 10bf92 <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf85: 51 push %ecx
10bf86: 51 push %ecx
10bf87: ff 37 pushl (%edi)
10bf89: ff 75 e0 pushl -0x20(%ebp)
10bf8c: 57 push %edi
10bf8d: 68 1a 04 12 00 push $0x12041a
10bf92: 6a 00 push $0x0
10bf94: ff 75 dc pushl -0x24(%ebp)
10bf97: ff 55 e4 call *-0x1c(%ebp)
10bf9a: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf9d: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bfa0: 0f 85 66 fe ff ff jne 10be0c <_Heap_Walk+0x196>
return true;
10bfa6: b0 01 mov $0x1,%al
}
10bfa8: 8d 65 f4 lea -0xc(%ebp),%esp
10bfab: 5b pop %ebx
10bfac: 5e pop %esi
10bfad: 5f pop %edi
10bfae: c9 leave
10bfaf: c3 ret
0010b28c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b28c: 55 push %ebp
10b28d: 89 e5 mov %esp,%ebp
10b28f: 53 push %ebx
10b290: 83 ec 08 sub $0x8,%esp
10b293: 8b 45 08 mov 0x8(%ebp),%eax
10b296: 8b 55 0c mov 0xc(%ebp),%edx
10b299: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b29c: a3 d8 53 12 00 mov %eax,0x1253d8
_Internal_errors_What_happened.is_internal = is_internal;
10b2a1: 88 15 dc 53 12 00 mov %dl,0x1253dc
_Internal_errors_What_happened.the_error = the_error;
10b2a7: 89 1d e0 53 12 00 mov %ebx,0x1253e0
_User_extensions_Fatal( the_source, is_internal, the_error );
10b2ad: 53 push %ebx
10b2ae: 0f b6 d2 movzbl %dl,%edx
10b2b1: 52 push %edx
10b2b2: 50 push %eax
10b2b3: e8 37 1a 00 00 call 10ccef <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b2b8: c7 05 9c 54 12 00 05 movl $0x5,0x12549c <== NOT EXECUTED
10b2bf: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b2c2: fa cli <== NOT EXECUTED
10b2c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b2c5: f4 hlt <== NOT EXECUTED
10b2c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b2c9: eb fe jmp 10b2c9 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b31c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b31c: 55 push %ebp
10b31d: 89 e5 mov %esp,%ebp
10b31f: 56 push %esi
10b320: 53 push %ebx
10b321: 8b 5d 08 mov 0x8(%ebp),%ebx
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
10b324: 31 c9 xor %ecx,%ecx
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
10b326: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b32a: 74 53 je 10b37f <_Objects_Allocate+0x63><== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b32c: 8d 73 20 lea 0x20(%ebx),%esi
10b32f: 83 ec 0c sub $0xc,%esp
10b332: 56 push %esi
10b333: e8 38 f7 ff ff call 10aa70 <_Chain_Get>
10b338: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b33a: 83 c4 10 add $0x10,%esp
10b33d: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b341: 74 3c je 10b37f <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b343: 85 c0 test %eax,%eax
10b345: 75 1a jne 10b361 <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b347: 83 ec 0c sub $0xc,%esp
10b34a: 53 push %ebx
10b34b: e8 60 00 00 00 call 10b3b0 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b350: 89 34 24 mov %esi,(%esp)
10b353: e8 18 f7 ff ff call 10aa70 <_Chain_Get>
10b358: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b35a: 83 c4 10 add $0x10,%esp
10b35d: 85 c0 test %eax,%eax
10b35f: 74 1e je 10b37f <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b361: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b365: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b369: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b36b: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b36f: 31 d2 xor %edx,%edx
10b371: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b373: c1 e0 02 shl $0x2,%eax
10b376: 03 43 30 add 0x30(%ebx),%eax
10b379: ff 08 decl (%eax)
information->inactive--;
10b37b: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b37f: 89 c8 mov %ecx,%eax
10b381: 8d 65 f8 lea -0x8(%ebp),%esp
10b384: 5b pop %ebx
10b385: 5e pop %esi
10b386: c9 leave
10b387: c3 ret
0010b6a0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b6a0: 55 push %ebp
10b6a1: 89 e5 mov %esp,%ebp
10b6a3: 57 push %edi
10b6a4: 56 push %esi
10b6a5: 53 push %ebx
10b6a6: 83 ec 0c sub $0xc,%esp
10b6a9: 8b 75 08 mov 0x8(%ebp),%esi
10b6ac: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b6af: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b6b1: 66 85 ff test %di,%di
10b6b4: 74 37 je 10b6ed <_Objects_Get_information+0x4d>
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10b6b6: 83 ec 0c sub $0xc,%esp
10b6b9: 56 push %esi
10b6ba: e8 dd 41 00 00 call 10f89c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b6bf: 83 c4 10 add $0x10,%esp
10b6c2: 85 c0 test %eax,%eax
10b6c4: 74 27 je 10b6ed <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b6c6: 0f b7 ff movzwl %di,%edi
10b6c9: 39 c7 cmp %eax,%edi
10b6cb: 77 20 ja 10b6ed <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b6cd: 8b 04 b5 18 53 12 00 mov 0x125318(,%esi,4),%eax
10b6d4: 85 c0 test %eax,%eax
10b6d6: 74 15 je 10b6ed <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b6d8: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b6db: 85 db test %ebx,%ebx
10b6dd: 74 0e je 10b6ed <_Objects_Get_information+0x4d><== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
10b6df: 31 c0 xor %eax,%eax
10b6e1: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b6e6: 0f 95 c0 setne %al
10b6e9: f7 d8 neg %eax
10b6eb: 21 c3 and %eax,%ebx
#endif
return info;
}
10b6ed: 89 d8 mov %ebx,%eax
10b6ef: 8d 65 f4 lea -0xc(%ebp),%esp
10b6f2: 5b pop %ebx
10b6f3: 5e pop %esi
10b6f4: 5f pop %edi
10b6f5: c9 leave
10b6f6: c3 ret
00118b10 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118b10: 55 push %ebp
118b11: 89 e5 mov %esp,%ebp
118b13: 53 push %ebx
118b14: 8b 55 08 mov 0x8(%ebp),%edx
118b17: 8b 4d 10 mov 0x10(%ebp),%ecx
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
118b1a: b8 01 00 00 00 mov $0x1,%eax
118b1f: 2b 42 08 sub 0x8(%edx),%eax
118b22: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118b25: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118b29: 39 c3 cmp %eax,%ebx
118b2b: 72 12 jb 118b3f <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118b2d: 8b 52 1c mov 0x1c(%edx),%edx
118b30: 8b 04 82 mov (%edx,%eax,4),%eax
118b33: 85 c0 test %eax,%eax
118b35: 74 08 je 118b3f <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118b37: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118b3d: eb 08 jmp 118b47 <_Objects_Get_no_protection+0x37>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
118b3f: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118b45: 31 c0 xor %eax,%eax
}
118b47: 5b pop %ebx
118b48: c9 leave
118b49: c3 ret
0010c8bc <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c8bc: 55 push %ebp
10c8bd: 89 e5 mov %esp,%ebp
10c8bf: 53 push %ebx
10c8c0: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c8c3: 8b 45 08 mov 0x8(%ebp),%eax
10c8c6: 85 c0 test %eax,%eax
10c8c8: 75 08 jne 10c8d2 <_Objects_Id_to_name+0x16>
10c8ca: a1 d4 78 12 00 mov 0x1278d4,%eax
10c8cf: 8b 40 08 mov 0x8(%eax),%eax
10c8d2: 89 c2 mov %eax,%edx
10c8d4: c1 ea 18 shr $0x18,%edx
10c8d7: 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 )
10c8da: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c8dd: bb 03 00 00 00 mov $0x3,%ebx
10c8e2: 83 f9 02 cmp $0x2,%ecx
10c8e5: 77 36 ja 10c91d <_Objects_Id_to_name+0x61>
10c8e7: eb 3b jmp 10c924 <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c8e9: 89 c1 mov %eax,%ecx
10c8eb: c1 e9 1b shr $0x1b,%ecx
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10c8ee: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8f1: 85 d2 test %edx,%edx
10c8f3: 74 28 je 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8f5: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8f9: 75 22 jne 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8fb: 51 push %ecx
10c8fc: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8ff: 51 push %ecx
10c900: 50 push %eax
10c901: 52 push %edx
10c902: e8 5d ff ff ff call 10c864 <_Objects_Get>
if ( !the_object )
10c907: 83 c4 10 add $0x10,%esp
10c90a: 85 c0 test %eax,%eax
10c90c: 74 0f je 10c91d <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c90e: 8b 50 0c mov 0xc(%eax),%edx
10c911: 8b 45 0c mov 0xc(%ebp),%eax
10c914: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c916: e8 73 0a 00 00 call 10d38e <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c91b: 31 db xor %ebx,%ebx
}
10c91d: 89 d8 mov %ebx,%eax
10c91f: 8b 5d fc mov -0x4(%ebp),%ebx
10c922: c9 leave
10c923: c3 ret
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10c924: 8b 14 95 84 73 12 00 mov 0x127384(,%edx,4),%edx
10c92b: 85 d2 test %edx,%edx
10c92d: 75 ba jne 10c8e9 <_Objects_Id_to_name+0x2d>
10c92f: eb ec jmp 10c91d <_Objects_Id_to_name+0x61>
0010e310 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e310: 55 push %ebp
10e311: 89 e5 mov %esp,%ebp
10e313: 57 push %edi
10e314: 56 push %esi
10e315: 53 push %ebx
10e316: 83 ec 30 sub $0x30,%esp
10e319: 8b 75 08 mov 0x8(%ebp),%esi
10e31c: 8b 5d 14 mov 0x14(%ebp),%ebx
10e31f: 8a 55 18 mov 0x18(%ebp),%dl
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10e322: 8d 45 e4 lea -0x1c(%ebp),%eax
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10e325: 50 push %eax
10e326: 56 push %esi
10e327: 68 30 e3 12 00 push $0x12e330
10e32c: 88 55 d4 mov %dl,-0x2c(%ebp)
10e32f: e8 f0 2a 00 00 call 110e24 <_Objects_Get>
switch ( location ) {
10e334: 83 c4 10 add $0x10,%esp
10e337: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e33b: 8a 55 d4 mov -0x2c(%ebp),%dl
10e33e: 0f 85 aa 00 00 00 jne 10e3ee <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e344: 8b 78 14 mov 0x14(%eax),%edi
10e347: 89 f9 mov %edi,%ecx
10e349: 83 e1 03 and $0x3,%ecx
10e34c: 49 dec %ecx
10e34d: 75 0a jne 10e359 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e34f: e8 f6 35 00 00 call 11194a <_Thread_Enable_dispatch>
10e354: e9 95 00 00 00 jmp 10e3ee <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e359: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e35c: 8b 48 68 mov 0x68(%eax),%ecx
10e35f: 39 4d 10 cmp %ecx,0x10(%ebp)
10e362: 73 15 jae 10e379 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e364: e8 e1 35 00 00 call 11194a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e369: e8 ee 8a 00 00 call 116e5c <__errno>
10e36e: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e374: e9 80 00 00 00 jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e379: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10e380: 31 c9 xor %ecx,%ecx
10e382: 84 d2 test %dl,%dl
10e384: 74 09 je 10e38f <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e386: 81 e7 00 40 00 00 and $0x4000,%edi
10e38c: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e38f: 52 push %edx
10e390: 52 push %edx
10e391: ff 75 1c pushl 0x1c(%ebp)
10e394: 0f b6 c9 movzbl %cl,%ecx
10e397: 51 push %ecx
10e398: 8d 55 e0 lea -0x20(%ebp),%edx
10e39b: 52 push %edx
10e39c: ff 75 0c pushl 0xc(%ebp)
10e39f: 56 push %esi
10e3a0: 83 c0 1c add $0x1c,%eax
10e3a3: 50 push %eax
10e3a4: e8 7f 1c 00 00 call 110028 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e3a9: 83 c4 20 add $0x20,%esp
10e3ac: e8 99 35 00 00 call 11194a <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e3b1: a1 a8 e3 12 00 mov 0x12e3a8,%eax
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
10e3b6: 8b 50 24 mov 0x24(%eax),%edx
10e3b9: c1 fa 1f sar $0x1f,%edx
10e3bc: 8b 48 24 mov 0x24(%eax),%ecx
10e3bf: 31 d1 xor %edx,%ecx
10e3c1: 89 0b mov %ecx,(%ebx)
10e3c3: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e3c5: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e3c9: 75 05 jne 10e3d0 <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e3cb: 8b 45 e0 mov -0x20(%ebp),%eax
10e3ce: eb 2c jmp 10e3fc <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e3d0: e8 87 8a 00 00 call 116e5c <__errno>
10e3d5: 89 c3 mov %eax,%ebx
10e3d7: 83 ec 0c sub $0xc,%esp
10e3da: a1 a8 e3 12 00 mov 0x12e3a8,%eax
10e3df: ff 70 34 pushl 0x34(%eax)
10e3e2: e8 ed 01 00 00 call 10e5d4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e3e7: 89 03 mov %eax,(%ebx)
10e3e9: 83 c4 10 add $0x10,%esp
10e3ec: eb 0b jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e3ee: e8 69 8a 00 00 call 116e5c <__errno>
10e3f3: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3f9: 83 c8 ff or $0xffffffff,%eax
}
10e3fc: 8d 65 f4 lea -0xc(%ebp),%esp
10e3ff: 5b pop %ebx
10e400: 5e pop %esi
10e401: 5f pop %edi
10e402: c9 leave
10e403: c3 ret
0010bccb <_POSIX_Mutex_Get_interrupt_disable>:
POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable (
pthread_mutex_t *mutex,
Objects_Locations *location,
ISR_Level *level
)
{
10bccb: 55 push %ebp
10bccc: 89 e5 mov %esp,%ebp
10bcce: 56 push %esi
10bccf: 53 push %ebx
10bcd0: 8b 5d 08 mov 0x8(%ebp),%ebx
10bcd3: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10bcd6: 85 db test %ebx,%ebx
10bcd8: 74 16 je 10bcf0 <_POSIX_Mutex_Get_interrupt_disable+0x25>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10bcda: 83 3b ff cmpl $0xffffffff,(%ebx)
10bcdd: 75 1b jne 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f>
10bcdf: 51 push %ecx
10bce0: 51 push %ecx
10bce1: 6a 00 push $0x0
10bce3: 53 push %ebx
10bce4: e8 73 00 00 00 call 10bd5c <pthread_mutex_init>
10bce9: 83 c4 10 add $0x10,%esp
10bcec: 85 c0 test %eax,%eax
10bcee: 74 0a je 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NEVER TAKEN
10bcf0: c7 06 01 00 00 00 movl $0x1,(%esi)
10bcf6: 31 c0 xor %eax,%eax
10bcf8: eb 13 jmp 10bd0d <_POSIX_Mutex_Get_interrupt_disable+0x42>
return (POSIX_Mutex_Control *) _Objects_Get_isr_disable(
10bcfa: ff 75 10 pushl 0x10(%ebp)
10bcfd: 56 push %esi
10bcfe: ff 33 pushl (%ebx)
10bd00: 68 54 a7 12 00 push $0x12a754
10bd05: e8 06 27 00 00 call 10e410 <_Objects_Get_isr_disable>
10bd0a: 83 c4 10 add $0x10,%esp
&_POSIX_Mutex_Information,
(Objects_Id) *mutex,
location,
level
);
}
10bd0d: 8d 65 f8 lea -0x8(%ebp),%esp
10bd10: 5b pop %ebx
10bd11: 5e pop %esi
10bd12: c9 leave
10bd13: c3 ret
0010e9dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e9dc: 55 push %ebp
10e9dd: 89 e5 mov %esp,%ebp
10e9df: 83 ec 08 sub $0x8,%esp
10e9e2: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e9e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e9eb: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10e9f2: 75 2c jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e9f4: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10e9fb: 75 23 jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e9fd: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10ea04: 74 1a je 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10ea06: a1 50 63 12 00 mov 0x126350,%eax
10ea0b: 48 dec %eax
10ea0c: a3 50 63 12 00 mov %eax,0x126350
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10ea11: 50 push %eax
10ea12: 50 push %eax
10ea13: 6a ff push $0xffffffff
10ea15: 52 push %edx
10ea16: e8 51 08 00 00 call 10f26c <_POSIX_Thread_Exit>
10ea1b: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10ea1e: c9 leave
10ea1f: c3 ret
10ea20: 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();
10ea21: e9 78 db ff ff jmp 10c59e <_Thread_Enable_dispatch>
0010fc74 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10fc74: 55 push %ebp
10fc75: 89 e5 mov %esp,%ebp
10fc77: 57 push %edi
10fc78: 56 push %esi
10fc79: 53 push %ebx
10fc7a: 83 ec 28 sub $0x28,%esp
10fc7d: 8b 55 08 mov 0x8(%ebp),%edx
10fc80: 8b 5d 0c mov 0xc(%ebp),%ebx
10fc83: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fc86: ff 33 pushl (%ebx)
10fc88: 89 55 e0 mov %edx,-0x20(%ebp)
10fc8b: e8 c4 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid>
10fc90: 83 c4 10 add $0x10,%esp
return EINVAL;
10fc93: be 16 00 00 00 mov $0x16,%esi
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fc98: 84 c0 test %al,%al
10fc9a: 8b 55 e0 mov -0x20(%ebp),%edx
10fc9d: 0f 84 a4 00 00 00 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fca3: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fca9: 8b 45 14 mov 0x14(%ebp),%eax
10fcac: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fcb2: 85 d2 test %edx,%edx
10fcb4: 75 0b jne 10fcc1 <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fcb6: c7 07 01 00 00 00 movl $0x1,(%edi)
10fcbc: e9 83 00 00 00 jmp 10fd44 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fcc1: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fcc3: 83 fa 01 cmp $0x1,%edx
10fcc6: 74 7f je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fcc8: 83 fa 02 cmp $0x2,%edx
10fccb: 75 08 jne 10fcd5 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fccd: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fcd3: eb 72 jmp 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fcd5: be 16 00 00 00 mov $0x16,%esi
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
10fcda: 83 fa 04 cmp $0x4,%edx
10fcdd: 75 68 jne 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fcdf: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fce3: 75 06 jne 10fceb <_POSIX_Thread_Translate_sched_param+0x77>
10fce5: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fce9: 74 5c je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
10fceb: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fcef: 75 0b jne 10fcfc <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fcf1: be 16 00 00 00 mov $0x16,%esi
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
10fcf6: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fcfa: 74 4b je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
10fcfc: 83 ec 0c sub $0xc,%esp
10fcff: 8d 43 08 lea 0x8(%ebx),%eax
10fd02: 50 push %eax
10fd03: e8 00 de ff ff call 10db08 <_Timespec_To_ticks>
10fd08: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fd0b: 8d 43 10 lea 0x10(%ebx),%eax
10fd0e: 89 04 24 mov %eax,(%esp)
10fd11: e8 f2 dd ff ff call 10db08 <_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 ) <
10fd16: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fd19: be 16 00 00 00 mov $0x16,%esi
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
10fd1e: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fd21: 72 24 jb 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
10fd23: 83 ec 0c sub $0xc,%esp
10fd26: ff 73 04 pushl 0x4(%ebx)
10fd29: e8 26 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid>
10fd2e: 83 c4 10 add $0x10,%esp
10fd31: 84 c0 test %al,%al
10fd33: 74 12 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fd35: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fd3b: 8b 45 14 mov 0x14(%ebp),%eax
10fd3e: c7 00 41 a8 10 00 movl $0x10a841,(%eax)
return 0;
10fd44: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fd47: 89 f0 mov %esi,%eax
10fd49: 8d 65 f4 lea -0xc(%ebp),%esp
10fd4c: 5b pop %ebx
10fd4d: 5e pop %esi
10fd4e: 5f pop %edi
10fd4f: c9 leave
10fd50: c3 ret
0010a544 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a544: 55 push %ebp
10a545: 89 e5 mov %esp,%ebp
10a547: 57 push %edi
10a548: 56 push %esi
10a549: 53 push %ebx
10a54a: 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;
10a54d: 8b 3d 40 22 12 00 mov 0x122240,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a553: 8b 15 3c 22 12 00 mov 0x12223c,%edx
if ( !user_threads || maximum == 0 )
10a559: 85 d2 test %edx,%edx
10a55b: 74 54 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a55d: 85 ff test %edi,%edi
10a55f: 74 50 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a561: 31 db xor %ebx,%ebx
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
10a563: 8d 75 a4 lea -0x5c(%ebp),%esi
10a566: 83 ec 0c sub $0xc,%esp
10a569: 56 push %esi
10a56a: 89 55 94 mov %edx,-0x6c(%ebp)
10a56d: e8 e2 57 00 00 call 10fd54 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a572: 5a pop %edx
10a573: 59 pop %ecx
10a574: 6a 02 push $0x2
10a576: 56 push %esi
10a577: e8 00 58 00 00 call 10fd7c <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a57c: 59 pop %ecx
10a57d: 58 pop %eax
10a57e: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a582: 56 push %esi
10a583: e8 20 58 00 00 call 10fda8 <pthread_attr_setstacksize>
status = pthread_create(
10a588: 6a 00 push $0x0
10a58a: ff 34 df pushl (%edi,%ebx,8)
10a58d: 56 push %esi
10a58e: 8d 45 e4 lea -0x1c(%ebp),%eax
10a591: 50 push %eax
10a592: e8 e5 fc ff ff call 10a27c <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a597: 83 c4 20 add $0x20,%esp
10a59a: 85 c0 test %eax,%eax
10a59c: 8b 55 94 mov -0x6c(%ebp),%edx
10a59f: 74 0b je 10a5ac <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a5a1: 52 push %edx
10a5a2: 50 push %eax
10a5a3: 6a 01 push $0x1
10a5a5: 6a 02 push $0x2
10a5a7: e8 e8 1b 00 00 call 10c194 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
10a5ac: 43 inc %ebx
10a5ad: 39 d3 cmp %edx,%ebx
10a5af: 72 b5 jb 10a566 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a5b1: 8d 65 f4 lea -0xc(%ebp),%esp
10a5b4: 5b pop %ebx
10a5b5: 5e pop %esi
10a5b6: 5f pop %edi
10a5b7: c9 leave
10a5b8: c3 ret
0010edcf <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10edcf: 55 push %ebp
10edd0: 89 e5 mov %esp,%ebp
10edd2: 56 push %esi
10edd3: 53 push %ebx
10edd4: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10edd7: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
10eddd: 83 ec 0c sub $0xc,%esp
10ede0: 8d 86 98 00 00 00 lea 0x98(%esi),%eax
10ede6: 50 push %eax
10ede7: e8 88 0d 00 00 call 10fb74 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10edec: 89 43 78 mov %eax,0x78(%ebx)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10edef: 0f b6 05 24 12 12 00 movzbl 0x121224,%eax
10edf6: 2b 86 88 00 00 00 sub 0x88(%esi),%eax
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
10edfc: 89 43 18 mov %eax,0x18(%ebx)
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
10edff: 83 c4 10 add $0x10,%esp
10ee02: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10ee06: 75 12 jne 10ee1a <_POSIX_Threads_Sporadic_budget_TSR+0x4b><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
10ee08: 39 43 14 cmp %eax,0x14(%ebx)
10ee0b: 76 0d jbe 10ee1a <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10ee0d: 52 push %edx
10ee0e: 6a 01 push $0x1
10ee10: 50 push %eax
10ee11: 53 push %ebx
10ee12: e8 0d d0 ff ff call 10be24 <_Thread_Change_priority>
10ee17: 83 c4 10 add $0x10,%esp
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
10ee1a: 83 ec 0c sub $0xc,%esp
10ee1d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10ee23: 50 push %eax
10ee24: e8 4b 0d 00 00 call 10fb74 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10ee29: 89 86 b4 00 00 00 mov %eax,0xb4(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10ee2f: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10ee32: 81 c6 a8 00 00 00 add $0xa8,%esi
10ee38: 89 75 0c mov %esi,0xc(%ebp)
10ee3b: c7 45 08 04 54 12 00 movl $0x125404,0x8(%ebp)
}
10ee42: 8d 65 f8 lea -0x8(%ebp),%esp
10ee45: 5b pop %ebx
10ee46: 5e pop %esi
10ee47: c9 leave
10ee48: e9 c3 df ff ff jmp 10ce10 <_Watchdog_Insert>
0010ee4d <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10ee4d: 55 push %ebp
10ee4e: 89 e5 mov %esp,%ebp
10ee50: 83 ec 08 sub $0x8,%esp
10ee53: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ee56: 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 */
10ee5c: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10ee63: 0f b6 15 24 12 12 00 movzbl 0x121224,%edx
10ee6a: 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;
10ee70: 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 ) {
10ee73: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ee77: 75 12 jne 10ee8b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
10ee79: 39 50 14 cmp %edx,0x14(%eax)
10ee7c: 73 0d jae 10ee8b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10ee7e: 51 push %ecx
10ee7f: 6a 01 push $0x1
10ee81: 52 push %edx
10ee82: 50 push %eax
10ee83: e8 9c cf ff ff call 10be24 <_Thread_Change_priority>
10ee88: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10ee8b: c9 leave
10ee8c: c3 ret
0010a304 <_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)
{
10a304: 55 push %ebp
10a305: 89 e5 mov %esp,%ebp
10a307: 53 push %ebx
10a308: 83 ec 04 sub $0x4,%esp
10a30b: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a30e: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a311: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a315: 75 06 jne 10a31d <_POSIX_Timer_TSR+0x19>
10a317: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a31b: 74 34 je 10a351 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a31d: 83 ec 0c sub $0xc,%esp
10a320: 53 push %ebx
10a321: 68 04 a3 10 00 push $0x10a304
10a326: ff 73 08 pushl 0x8(%ebx)
10a329: ff 73 64 pushl 0x64(%ebx)
10a32c: 8d 43 10 lea 0x10(%ebx),%eax
10a32f: 50 push %eax
10a330: e8 e7 56 00 00 call 10fa1c <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a335: 83 c4 20 add $0x20,%esp
10a338: 84 c0 test %al,%al
10a33a: 74 30 je 10a36c <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a33c: 83 ec 0c sub $0xc,%esp
10a33f: 8d 43 6c lea 0x6c(%ebx),%eax
10a342: 50 push %eax
10a343: e8 5c 14 00 00 call 10b7a4 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a348: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a34c: 83 c4 10 add $0x10,%esp
10a34f: eb 04 jmp 10a355 <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a351: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
10a355: 50 push %eax
10a356: 50 push %eax
10a357: ff 73 44 pushl 0x44(%ebx)
10a35a: ff 73 38 pushl 0x38(%ebx)
10a35d: e8 92 52 00 00 call 10f5f4 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a362: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a369: 83 c4 10 add $0x10,%esp
}
10a36c: 8b 5d fc mov -0x4(%ebp),%ebx
10a36f: c9 leave
10a370: c3 ret
00110b54 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110b54: 55 push %ebp
110b55: 89 e5 mov %esp,%ebp
110b57: 57 push %edi
110b58: 56 push %esi
110b59: 53 push %ebx
110b5a: 83 ec 68 sub $0x68,%esp
110b5d: 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,
110b60: 6a 01 push $0x1
110b62: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110b66: 50 push %eax
110b67: 8d 45 dc lea -0x24(%ebp),%eax
110b6a: 50 push %eax
110b6b: 53 push %ebx
110b6c: ff 75 08 pushl 0x8(%ebp)
110b6f: e8 8c 00 00 00 call 110c00 <_POSIX_signals_Clear_signals>
110b74: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110b77: 31 c9 xor %ecx,%ecx
{
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
110b79: 84 c0 test %al,%al
110b7b: 74 78 je 110bf5 <_POSIX_signals_Check_signal+0xa1>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
110b7d: 6b d3 0c imul $0xc,%ebx,%edx
110b80: 8b 82 a4 58 12 00 mov 0x1258a4(%edx),%eax
110b86: 83 f8 01 cmp $0x1,%eax
110b89: 74 6a je 110bf5 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110b8b: 8b 4d 08 mov 0x8(%ebp),%ecx
110b8e: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110b94: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110b97: 0b 8a a0 58 12 00 or 0x1258a0(%edx),%ecx
110b9d: 8b 75 08 mov 0x8(%ebp),%esi
110ba0: 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,
110ba6: 8d 7d b4 lea -0x4c(%ebp),%edi
110ba9: 8b 35 68 58 12 00 mov 0x125868,%esi
110baf: 83 c6 20 add $0x20,%esi
110bb2: b9 0a 00 00 00 mov $0xa,%ecx
110bb7: 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 ) {
110bb9: 83 ba 9c 58 12 00 02 cmpl $0x2,0x12589c(%edx)
110bc0: 75 09 jne 110bcb <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110bc2: 52 push %edx
110bc3: 6a 00 push $0x0
110bc5: 8d 55 dc lea -0x24(%ebp),%edx
110bc8: 52 push %edx
110bc9: eb 03 jmp 110bce <_POSIX_signals_Check_signal+0x7a>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
110bcb: 83 ec 0c sub $0xc,%esp
110bce: 53 push %ebx
110bcf: ff d0 call *%eax
break;
110bd1: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110bd4: 8b 3d 68 58 12 00 mov 0x125868,%edi
110bda: 83 c7 20 add $0x20,%edi
110bdd: 8d 75 b4 lea -0x4c(%ebp),%esi
110be0: b9 0a 00 00 00 mov $0xa,%ecx
110be5: 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;
110be7: 8b 75 a4 mov -0x5c(%ebp),%esi
110bea: 8b 4d 08 mov 0x8(%ebp),%ecx
110bed: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110bf3: b1 01 mov $0x1,%cl
}
110bf5: 88 c8 mov %cl,%al
110bf7: 8d 65 f4 lea -0xc(%ebp),%esp
110bfa: 5b pop %ebx
110bfb: 5e pop %esi
110bfc: 5f pop %edi
110bfd: c9 leave
110bfe: c3 ret
001110e8 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
1110e8: 55 push %ebp
1110e9: 89 e5 mov %esp,%ebp
1110eb: 53 push %ebx
1110ec: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
1110ef: 9c pushf
1110f0: fa cli
1110f1: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
1110f2: 6b c1 0c imul $0xc,%ecx,%eax
1110f5: 83 b8 9c 58 12 00 02 cmpl $0x2,0x12589c(%eax)
1110fc: 75 0e jne 11110c <_POSIX_signals_Clear_process_signals+0x24>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
1110fe: 8d 98 98 5a 12 00 lea 0x125a98(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111104: 39 98 94 5a 12 00 cmp %ebx,0x125a94(%eax)
11110a: 75 0e jne 11111a <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
11110c: 49 dec %ecx
11110d: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
111112: d3 c0 rol %cl,%eax
111114: 21 05 90 5a 12 00 and %eax,0x125a90
}
_ISR_Enable( level );
11111a: 52 push %edx
11111b: 9d popf
}
11111c: 5b pop %ebx
11111d: c9 leave
11111e: c3 ret
0010aba8 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10aba8: 55 push %ebp
10aba9: 89 e5 mov %esp,%ebp
10abab: 56 push %esi
10abac: 53 push %ebx
10abad: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10abb0: b8 1b 00 00 00 mov $0x1b,%eax
10abb5: 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(
10abba: 8d 48 ff lea -0x1(%eax),%ecx
10abbd: 89 de mov %ebx,%esi
10abbf: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10abc1: 85 d6 test %edx,%esi
10abc3: 75 1e jne 10abe3 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10abc5: 40 inc %eax
10abc6: 83 f8 20 cmp $0x20,%eax
10abc9: 75 ef jne 10abba <_POSIX_signals_Get_lowest+0x12>
10abcb: b0 01 mov $0x1,%al
10abcd: 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(
10abd2: 8d 48 ff lea -0x1(%eax),%ecx
10abd5: 89 de mov %ebx,%esi
10abd7: 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 ) ) {
10abd9: 85 d6 test %edx,%esi
10abdb: 75 06 jne 10abe3 <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10abdd: 40 inc %eax
10abde: 83 f8 1b cmp $0x1b,%eax
10abe1: 75 ef jne 10abd2 <_POSIX_signals_Get_lowest+0x2a><== ALWAYS TAKEN
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
10abe3: 5b pop %ebx
10abe4: 5e pop %esi
10abe5: c9 leave
10abe6: c3 ret
001221a0 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
1221a0: 55 push %ebp
1221a1: 89 e5 mov %esp,%ebp
1221a3: 57 push %edi
1221a4: 56 push %esi
1221a5: 53 push %ebx
1221a6: 83 ec 0c sub $0xc,%esp
1221a9: 8b 5d 08 mov 0x8(%ebp),%ebx
1221ac: 8b 75 0c mov 0xc(%ebp),%esi
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1221af: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
1221b5: 8d 4e ff lea -0x1(%esi),%ecx
1221b8: ba 01 00 00 00 mov $0x1,%edx
1221bd: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
1221bf: 8b 4b 10 mov 0x10(%ebx),%ecx
1221c2: 89 cf mov %ecx,%edi
1221c4: 81 e7 00 80 00 10 and $0x10008000,%edi
1221ca: 81 ff 00 80 00 10 cmp $0x10008000,%edi
1221d0: 75 58 jne 12222a <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
1221d2: 85 53 30 test %edx,0x30(%ebx)
1221d5: 75 12 jne 1221e9 <_POSIX_signals_Unblock_thread+0x49>
1221d7: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1221dd: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
1221df: 31 ff xor %edi,%edi
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
1221e1: 85 c2 test %eax,%edx
1221e3: 0f 84 b0 00 00 00 je 122299 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
1221e9: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
1221f0: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
1221f3: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1221f7: 75 12 jne 12220b <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
1221f9: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
1221fb: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
122202: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
122209: eb 0c jmp 122217 <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
12220b: b9 03 00 00 00 mov $0x3,%ecx
122210: 89 c7 mov %eax,%edi
122212: 8b 75 10 mov 0x10(%ebp),%esi
122215: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
122217: 83 ec 0c sub $0xc,%esp
12221a: 53 push %ebx
12221b: e8 c0 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy>
return true;
122220: 83 c4 10 add $0x10,%esp
122223: bf 01 00 00 00 mov $0x1,%edi
122228: eb 6f jmp 122299 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
12222a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
122230: f7 d0 not %eax
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
122232: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
122234: 85 c2 test %eax,%edx
122236: 74 61 je 122299 <_POSIX_signals_Unblock_thread+0xf9>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
122238: f7 c1 00 00 00 10 test $0x10000000,%ecx
12223e: 74 3d je 12227d <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
122240: 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) )
122247: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
12224d: 74 0b je 12225a <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
12224f: 83 ec 0c sub $0xc,%esp
122252: 53 push %ebx
122253: e8 88 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy>
122258: eb 1e jmp 122278 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
12225a: 80 e1 08 and $0x8,%cl
12225d: 74 3a je 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
12225f: 83 ec 0c sub $0xc,%esp
122262: 8d 43 48 lea 0x48(%ebx),%eax
122265: 50 push %eax
122266: e8 85 f4 fe ff call 1116f0 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
12226b: 58 pop %eax
12226c: 5a pop %edx
12226d: 68 f8 ff 03 10 push $0x1003fff8
122272: 53 push %ebx
122273: e8 2c e4 fe ff call 1106a4 <_Thread_Clear_state>
122278: 83 c4 10 add $0x10,%esp
12227b: eb 1c jmp 122299 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
12227d: 85 c9 test %ecx,%ecx
12227f: 75 18 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
122281: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8
122288: 74 0f je 122299 <_POSIX_signals_Unblock_thread+0xf9>
12228a: 3b 1d dc b9 12 00 cmp 0x12b9dc,%ebx
122290: 75 07 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
122292: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8
}
}
return false;
}
122299: 89 f8 mov %edi,%eax
12229b: 8d 65 f4 lea -0xc(%ebp),%esp
12229e: 5b pop %ebx
12229f: 5e pop %esi
1222a0: 5f pop %edi
1222a1: c9 leave
1222a2: c3 ret
0010efb0 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
10efb0: 55 push %ebp
10efb1: 89 e5 mov %esp,%ebp
10efb3: 57 push %edi
10efb4: 56 push %esi
10efb5: 53 push %ebx
10efb6: 83 ec 1c sub $0x1c,%esp
10efb9: 8b 5d 08 mov 0x8(%ebp),%ebx
10efbc: 8b 75 0c mov 0xc(%ebp),%esi
10efbf: 8b 7d 10 mov 0x10(%ebp),%edi
* 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 ) {
10efc2: a1 6c bc 12 00 mov 0x12bc6c,%eax
10efc7: 85 c0 test %eax,%eax
10efc9: 75 3c jne 10f007 <_Protected_heap_Walk+0x57><== NEVER TAKEN
_RTEMS_Lock_allocator();
10efcb: 83 ec 0c sub $0xc,%esp
10efce: ff 35 10 bd 12 00 pushl 0x12bd10
10efd4: e8 93 e6 ff ff call 10d66c <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
10efd9: 83 c4 0c add $0xc,%esp
10efdc: 81 e7 ff 00 00 00 and $0xff,%edi
10efe2: 57 push %edi
10efe3: 56 push %esi
10efe4: 53 push %ebx
10efe5: e8 a4 f3 ff ff call 10e38e <_Heap_Walk>
_RTEMS_Unlock_allocator();
10efea: 5a pop %edx
10efeb: ff 35 10 bd 12 00 pushl 0x12bd10
10eff1: 88 45 e4 mov %al,-0x1c(%ebp)
10eff4: e8 bb e6 ff ff call 10d6b4 <_API_Mutex_Unlock>
10eff9: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
10effc: 8a 45 e4 mov -0x1c(%ebp),%al
10efff: 8d 65 f4 lea -0xc(%ebp),%esp
10f002: 5b pop %ebx
10f003: 5e pop %esi
10f004: 5f pop %edi
10f005: c9 leave
10f006: c3 ret
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 );
10f007: 81 e7 ff 00 00 00 and $0xff,%edi
10f00d: 89 7d 10 mov %edi,0x10(%ebp)
10f010: 89 75 0c mov %esi,0xc(%ebp)
10f013: 89 5d 08 mov %ebx,0x8(%ebp)
}
return status;
}
10f016: 8d 65 f4 lea -0xc(%ebp),%esp
10f019: 5b pop %ebx
10f01a: 5e pop %esi
10f01b: 5f pop %edi
10f01c: 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 );
10f01d: e9 6c f3 ff ff jmp 10e38e <_Heap_Walk>
0010b3fc <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3fc: 55 push %ebp
10b3fd: 89 e5 mov %esp,%ebp
10b3ff: 53 push %ebx
10b400: 83 ec 18 sub $0x18,%esp
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
10b403: 8d 45 f4 lea -0xc(%ebp),%eax
10b406: 50 push %eax
10b407: ff 75 08 pushl 0x8(%ebp)
10b40a: 68 74 83 12 00 push $0x128374
10b40f: e8 c8 1a 00 00 call 10cedc <_Objects_Get>
10b414: 89 c3 mov %eax,%ebx
switch ( location ) {
10b416: 83 c4 10 add $0x10,%esp
10b419: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b41d: 75 64 jne 10b483 <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b41f: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b422: f6 40 11 40 testb $0x40,0x11(%eax)
10b426: 74 18 je 10b440 <_Rate_monotonic_Timeout+0x44>
10b428: 8b 53 08 mov 0x8(%ebx),%edx
10b42b: 39 50 20 cmp %edx,0x20(%eax)
10b42e: 75 10 jne 10b440 <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b430: 52 push %edx
10b431: 52 push %edx
10b432: 68 f8 ff 03 10 push $0x1003fff8
10b437: 50 push %eax
10b438: e8 3b 22 00 00 call 10d678 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b43d: 59 pop %ecx
10b43e: eb 10 jmp 10b450 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b440: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b444: 75 2b jne 10b471 <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b446: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b44d: 83 ec 0c sub $0xc,%esp
10b450: 53 push %ebx
10b451: e8 ec fa ff ff call 10af42 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b456: 8b 43 3c mov 0x3c(%ebx),%eax
10b459: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b45c: 58 pop %eax
10b45d: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b45e: 83 c3 10 add $0x10,%ebx
10b461: 53 push %ebx
10b462: 68 28 85 12 00 push $0x128528
10b467: e8 34 32 00 00 call 10e6a0 <_Watchdog_Insert>
10b46c: 83 c4 10 add $0x10,%esp
10b46f: eb 07 jmp 10b478 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b471: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b478: a1 64 84 12 00 mov 0x128464,%eax
10b47d: 48 dec %eax
10b47e: a3 64 84 12 00 mov %eax,0x128464
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b483: 8b 5d fc mov -0x4(%ebp),%ebx
10b486: c9 leave
10b487: c3 ret
0010ba6c <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10ba6c: 55 push %ebp
10ba6d: 89 e5 mov %esp,%ebp
10ba6f: 56 push %esi
10ba70: 53 push %ebx
10ba71: 8b 55 08 mov 0x8(%ebp),%edx
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
10ba74: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx
ready = sched_info->ready_chain;
10ba7a: 8b 01 mov (%ecx),%eax
if ( _Chain_Has_only_one_node( ready ) ) {
10ba7c: 8b 58 08 mov 0x8(%eax),%ebx
10ba7f: 39 18 cmp %ebx,(%eax)
10ba81: 75 32 jne 10bab5 <_Scheduler_priority_Block+0x49>
Chain_Node *tail = _Chain_Tail( the_chain );
10ba83: 8d 58 04 lea 0x4(%eax),%ebx
10ba86: 89 18 mov %ebx,(%eax)
head->next = tail;
head->previous = NULL;
10ba88: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10ba8f: 89 40 08 mov %eax,0x8(%eax)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
10ba92: 8b 59 04 mov 0x4(%ecx),%ebx
10ba95: 66 8b 03 mov (%ebx),%ax
10ba98: 66 23 41 0e and 0xe(%ecx),%ax
10ba9c: 66 89 03 mov %ax,(%ebx)
if ( *the_priority_map->minor == 0 )
10ba9f: 66 85 c0 test %ax,%ax
10baa2: 75 1b jne 10babf <_Scheduler_priority_Block+0x53>
_Priority_Major_bit_map &= the_priority_map->block_major;
10baa4: 66 a1 78 58 12 00 mov 0x125878,%ax
10baaa: 23 41 0c and 0xc(%ecx),%eax
10baad: 66 a3 78 58 12 00 mov %ax,0x125878
10bab3: eb 0a jmp 10babf <_Scheduler_priority_Block+0x53>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10bab5: 8b 0a mov (%edx),%ecx
previous = the_node->previous;
10bab7: 8b 42 04 mov 0x4(%edx),%eax
next->previous = previous;
10baba: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
10babd: 89 08 mov %ecx,(%eax)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10babf: 3b 15 6c 58 12 00 cmp 0x12586c,%edx
10bac5: 75 43 jne 10bb0a <_Scheduler_priority_Block+0x9e>
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 );
10bac7: 66 8b 35 78 58 12 00 mov 0x125878,%si
10bace: 31 c9 xor %ecx,%ecx
10bad0: 89 cb mov %ecx,%ebx
10bad2: 66 0f bc de bsf %si,%bx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bad6: 0f b7 db movzwl %bx,%ebx
10bad9: 66 8b b4 1b 7c 58 12 mov 0x12587c(%ebx,%ebx,1),%si
10bae0: 00
10bae1: 66 0f bc ce bsf %si,%cx
return (_Priority_Bits_index( major ) << 4) +
10bae5: c1 e3 04 shl $0x4,%ebx
10bae8: 0f b7 c9 movzwl %cx,%ecx
10baeb: 8d 04 0b lea (%ebx,%ecx,1),%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10baee: 6b c0 0c imul $0xc,%eax,%eax
10baf1: 03 05 50 11 12 00 add 0x121150,%eax
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
10baf7: 8b 18 mov (%eax),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10baf9: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bafc: 31 c9 xor %ecx,%ecx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10bafe: 39 c3 cmp %eax,%ebx
10bb00: 74 02 je 10bb04 <_Scheduler_priority_Block+0x98><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10bb02: 89 d9 mov %ebx,%ecx
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10bb04: 89 0d 6c 58 12 00 mov %ecx,0x12586c
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10bb0a: 3b 15 68 58 12 00 cmp 0x125868,%edx
10bb10: 75 07 jne 10bb19 <_Scheduler_priority_Block+0xad>
_Thread_Dispatch_necessary = true;
10bb12: c6 05 74 58 12 00 01 movb $0x1,0x125874
}
10bb19: 5b pop %ebx
10bb1a: 5e pop %esi
10bb1b: c9 leave
10bb1c: c3 ret
0010bc6c <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10bc6c: 55 push %ebp
10bc6d: 89 e5 mov %esp,%ebp
10bc6f: 53 push %ebx
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 );
10bc70: 66 8b 1d 78 58 12 00 mov 0x125878,%bx
10bc77: 31 d2 xor %edx,%edx
10bc79: 89 d1 mov %edx,%ecx
10bc7b: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bc7f: 0f b7 c9 movzwl %cx,%ecx
10bc82: 66 8b 9c 09 7c 58 12 mov 0x12587c(%ecx,%ecx,1),%bx
10bc89: 00
10bc8a: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10bc8e: c1 e1 04 shl $0x4,%ecx
10bc91: 0f b7 d2 movzwl %dx,%edx
10bc94: 8d 04 11 lea (%ecx,%edx,1),%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10bc97: 6b c0 0c imul $0xc,%eax,%eax
10bc9a: 03 05 50 11 12 00 add 0x121150,%eax
_Scheduler_priority_Schedule_body();
}
10bca0: 8b 08 mov (%eax),%ecx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10bca2: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bca5: 31 d2 xor %edx,%edx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10bca7: 39 c1 cmp %eax,%ecx
10bca9: 74 02 je 10bcad <_Scheduler_priority_Schedule+0x41><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10bcab: 89 ca mov %ecx,%edx
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10bcad: 89 15 6c 58 12 00 mov %edx,0x12586c
10bcb3: 5b pop %ebx
10bcb4: c9 leave
10bcb5: c3 ret
0010ad28 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10ad28: 55 push %ebp
10ad29: 89 e5 mov %esp,%ebp
10ad2b: 56 push %esi
10ad2c: 53 push %ebx
10ad2d: 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();
10ad30: 8b 35 94 4b 12 00 mov 0x124b94,%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;
10ad36: 31 db xor %ebx,%ebx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10ad38: 85 c9 test %ecx,%ecx
10ad3a: 74 57 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10ad3c: b8 40 42 0f 00 mov $0xf4240,%eax
10ad41: 31 d2 xor %edx,%edx
10ad43: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10ad45: 39 41 18 cmp %eax,0x18(%ecx)
10ad48: 73 49 jae 10ad93 <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10ad4a: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10ad4e: 77 43 ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10ad50: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ad54: 77 3d ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ad56: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10ad5a: 77 37 ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10ad5c: 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) ||
10ad5f: 85 c0 test %eax,%eax
10ad61: 74 30 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10ad63: 83 f8 0c cmp $0xc,%eax
10ad66: 77 2b ja 10ad93 <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10ad68: 8b 31 mov (%ecx),%esi
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
10ad6a: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10ad70: 76 21 jbe 10ad93 <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10ad72: 8b 51 08 mov 0x8(%ecx),%edx
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10ad75: 85 d2 test %edx,%edx
10ad77: 74 1a je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad79: 83 e6 03 and $0x3,%esi
10ad7c: 75 09 jne 10ad87 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad7e: 8b 04 85 90 1d 12 00 mov 0x121d90(,%eax,4),%eax
10ad85: eb 07 jmp 10ad8e <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad87: 8b 04 85 5c 1d 12 00 mov 0x121d5c(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad8e: 39 c2 cmp %eax,%edx
10ad90: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad93: 88 d8 mov %bl,%al
10ad95: 5b pop %ebx
10ad96: 5e pop %esi
10ad97: c9 leave
10ad98: c3 ret
0010be24 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10be24: 55 push %ebp
10be25: 89 e5 mov %esp,%ebp
10be27: 57 push %edi
10be28: 56 push %esi
10be29: 53 push %ebx
10be2a: 83 ec 28 sub $0x28,%esp
10be2d: 8b 5d 08 mov 0x8(%ebp),%ebx
10be30: 8b 75 0c mov 0xc(%ebp),%esi
10be33: 8a 45 10 mov 0x10(%ebp),%al
10be36: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10be39: 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 );
10be3c: 53 push %ebx
10be3d: e8 62 0b 00 00 call 10c9a4 <_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 )
10be42: 83 c4 10 add $0x10,%esp
10be45: 39 73 14 cmp %esi,0x14(%ebx)
10be48: 74 0c je 10be56 <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10be4a: 50 push %eax
10be4b: 50 push %eax
10be4c: 56 push %esi
10be4d: 53 push %ebx
10be4e: e8 01 0b 00 00 call 10c954 <_Thread_Set_priority>
10be53: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10be56: 9c pushf
10be57: fa cli
10be58: 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;
10be59: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10be5c: 83 f8 04 cmp $0x4,%eax
10be5f: 74 2b je 10be8c <_Thread_Change_priority+0x68>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10be61: 83 e7 04 and $0x4,%edi
10be64: 75 08 jne 10be6e <_Thread_Change_priority+0x4a><== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10be66: 89 c2 mov %eax,%edx
10be68: 83 e2 fb and $0xfffffffb,%edx
10be6b: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10be6e: 56 push %esi
10be6f: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10be70: a9 e0 be 03 00 test $0x3bee0,%eax
10be75: 74 65 je 10bedc <_Thread_Change_priority+0xb8>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10be77: 89 5d 0c mov %ebx,0xc(%ebp)
10be7a: 8b 43 44 mov 0x44(%ebx),%eax
10be7d: 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 );
}
10be80: 8d 65 f4 lea -0xc(%ebp),%esp
10be83: 5b pop %ebx
10be84: 5e pop %esi
10be85: 5f pop %edi
10be86: 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 );
10be87: e9 40 0a 00 00 jmp 10c8cc <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10be8c: 83 e7 04 and $0x4,%edi
10be8f: 75 26 jne 10beb7 <_Thread_Change_priority+0x93><== 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 );
10be91: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10be98: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10be9c: 74 0c je 10beaa <_Thread_Change_priority+0x86>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10be9e: 83 ec 0c sub $0xc,%esp
10bea1: 53 push %ebx
10bea2: ff 15 78 11 12 00 call *0x121178
10bea8: eb 0a jmp 10beb4 <_Thread_Change_priority+0x90>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10beaa: 83 ec 0c sub $0xc,%esp
10bead: 53 push %ebx
10beae: ff 15 74 11 12 00 call *0x121174
10beb4: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10beb7: 56 push %esi
10beb8: 9d popf
10beb9: 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();
10beba: ff 15 58 11 12 00 call *0x121158
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10bec0: a1 68 58 12 00 mov 0x125868,%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() &&
10bec5: 3b 05 6c 58 12 00 cmp 0x12586c,%eax
10becb: 74 0d je 10beda <_Thread_Change_priority+0xb6>
10becd: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bed1: 74 07 je 10beda <_Thread_Change_priority+0xb6>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10bed3: c6 05 74 58 12 00 01 movb $0x1,0x125874
_ISR_Enable( level );
10beda: 56 push %esi
10bedb: 9d popf
}
10bedc: 8d 65 f4 lea -0xc(%ebp),%esp
10bedf: 5b pop %ebx
10bee0: 5e pop %esi
10bee1: 5f pop %edi
10bee2: c9 leave
10bee3: c3 ret
0010c088 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c088: 55 push %ebp
10c089: 89 e5 mov %esp,%ebp
10c08b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c08e: 8d 45 f4 lea -0xc(%ebp),%eax
10c091: 50 push %eax
10c092: ff 75 08 pushl 0x8(%ebp)
10c095: e8 82 01 00 00 call 10c21c <_Thread_Get>
switch ( location ) {
10c09a: 83 c4 10 add $0x10,%esp
10c09d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c0a1: 75 1b jne 10c0be <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10c0a3: 52 push %edx
10c0a4: 52 push %edx
10c0a5: 68 18 00 00 10 push $0x10000018
10c0aa: 50 push %eax
10c0ab: e8 34 fe ff ff call 10bee4 <_Thread_Clear_state>
10c0b0: a1 40 53 12 00 mov 0x125340,%eax
10c0b5: 48 dec %eax
10c0b6: a3 40 53 12 00 mov %eax,0x125340
10c0bb: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10c0be: c9 leave
10c0bf: c3 ret
0010c0c0 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10c0c0: 55 push %ebp
10c0c1: 89 e5 mov %esp,%ebp
10c0c3: 57 push %edi
10c0c4: 56 push %esi
10c0c5: 53 push %ebx
10c0c6: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10c0c9: 8b 1d 68 58 12 00 mov 0x125868,%ebx
_ISR_Disable( level );
10c0cf: 9c pushf
10c0d0: fa cli
10c0d1: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10c0d2: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c0d5: e9 f9 00 00 00 jmp 10c1d3 <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10c0da: 8b 35 6c 58 12 00 mov 0x12586c,%esi
_Thread_Dispatch_disable_level = 1;
10c0e0: c7 05 40 53 12 00 01 movl $0x1,0x125340
10c0e7: 00 00 00
_Thread_Dispatch_necessary = false;
10c0ea: c6 05 74 58 12 00 00 movb $0x0,0x125874
_Thread_Executing = heir;
10c0f1: 89 35 68 58 12 00 mov %esi,0x125868
/*
* 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 )
10c0f7: 39 de cmp %ebx,%esi
10c0f9: 0f 84 e2 00 00 00 je 10c1e1 <_Thread_Dispatch+0x121>
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
10c0ff: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10c103: 75 09 jne 10c10e <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c105: 8b 15 10 53 12 00 mov 0x125310,%edx
10c10b: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10c10e: 50 push %eax
10c10f: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10c110: 83 ec 0c sub $0xc,%esp
10c113: 8d 45 e0 lea -0x20(%ebp),%eax
10c116: 50 push %eax
10c117: e8 5c 34 00 00 call 10f578 <_TOD_Get_uptime>
_Timestamp_Subtract(
10c11c: 83 c4 0c add $0xc,%esp
10c11f: 57 push %edi
10c120: 8d 45 e0 lea -0x20(%ebp),%eax
10c123: 50 push %eax
10c124: 68 f0 53 12 00 push $0x1253f0
10c129: e8 76 0a 00 00 call 10cba4 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10c12e: 58 pop %eax
10c12f: 5a pop %edx
10c130: 57 push %edi
10c131: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10c137: 50 push %eax
10c138: e8 37 0a 00 00 call 10cb74 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10c13d: 8b 45 e0 mov -0x20(%ebp),%eax
10c140: 8b 55 e4 mov -0x1c(%ebp),%edx
10c143: a3 f0 53 12 00 mov %eax,0x1253f0
10c148: 89 15 f4 53 12 00 mov %edx,0x1253f4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10c14e: a1 c8 53 12 00 mov 0x1253c8,%eax
10c153: 83 c4 10 add $0x10,%esp
10c156: 85 c0 test %eax,%eax
10c158: 74 10 je 10c16a <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10c15a: 8b 10 mov (%eax),%edx
10c15c: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10c162: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10c168: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10c16a: 51 push %ecx
10c16b: 51 push %ecx
10c16c: 56 push %esi
10c16d: 53 push %ebx
10c16e: e8 69 0c 00 00 call 10cddc <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10c173: 58 pop %eax
10c174: 5a pop %edx
10c175: 81 c6 c8 00 00 00 add $0xc8,%esi
10c17b: 56 push %esi
10c17c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10c182: 50 push %eax
10c183: e8 28 0f 00 00 call 10d0b0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10c188: 83 c4 10 add $0x10,%esp
10c18b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
10c192: 74 36 je 10c1ca <_Thread_Dispatch+0x10a>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
10c194: a1 c4 53 12 00 mov 0x1253c4,%eax
10c199: 39 c3 cmp %eax,%ebx
10c19b: 74 2d je 10c1ca <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10c19d: 85 c0 test %eax,%eax
10c19f: 74 11 je 10c1b2 <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10c1a1: 83 ec 0c sub $0xc,%esp
10c1a4: 05 e0 00 00 00 add $0xe0,%eax
10c1a9: 50 push %eax
10c1aa: e8 35 0f 00 00 call 10d0e4 <_CPU_Context_save_fp>
10c1af: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10c1b2: 83 ec 0c sub $0xc,%esp
10c1b5: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10c1bb: 50 push %eax
10c1bc: e8 2d 0f 00 00 call 10d0ee <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10c1c1: 89 1d c4 53 12 00 mov %ebx,0x1253c4
10c1c7: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10c1ca: 8b 1d 68 58 12 00 mov 0x125868,%ebx
_ISR_Disable( level );
10c1d0: 9c pushf
10c1d1: fa cli
10c1d2: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c1d3: 8a 15 74 58 12 00 mov 0x125874,%dl
10c1d9: 84 d2 test %dl,%dl
10c1db: 0f 85 f9 fe ff ff jne 10c0da <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10c1e1: c7 05 40 53 12 00 00 movl $0x0,0x125340
10c1e8: 00 00 00
_ISR_Enable( level );
10c1eb: 50 push %eax
10c1ec: 9d popf
_API_extensions_Run_postswitch();
10c1ed: e8 3d e7 ff ff call 10a92f <_API_extensions_Run_postswitch>
}
10c1f2: 8d 65 f4 lea -0xc(%ebp),%esp
10c1f5: 5b pop %ebx
10c1f6: 5e pop %esi
10c1f7: 5f pop %edi
10c1f8: c9 leave
10c1f9: c3 ret
00110f9c <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110f9c: 55 push %ebp
110f9d: 89 e5 mov %esp,%ebp
110f9f: 53 push %ebx
110fa0: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110fa3: 8b 1d 68 58 12 00 mov 0x125868,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110fa9: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
110faf: 85 c0 test %eax,%eax
110fb1: 74 03 je 110fb6 <_Thread_Handler+0x1a>
110fb3: fa cli
110fb4: eb 01 jmp 110fb7 <_Thread_Handler+0x1b>
110fb6: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110fb7: a0 00 50 12 00 mov 0x125000,%al
110fbc: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110fbf: c6 05 00 50 12 00 01 movb $0x1,0x125000
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
110fc6: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
110fcd: 74 24 je 110ff3 <_Thread_Handler+0x57>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
110fcf: a1 c4 53 12 00 mov 0x1253c4,%eax
110fd4: 39 c3 cmp %eax,%ebx
110fd6: 74 1b je 110ff3 <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110fd8: 85 c0 test %eax,%eax
110fda: 74 11 je 110fed <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110fdc: 83 ec 0c sub $0xc,%esp
110fdf: 05 e0 00 00 00 add $0xe0,%eax
110fe4: 50 push %eax
110fe5: e8 fa c0 ff ff call 10d0e4 <_CPU_Context_save_fp>
110fea: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110fed: 89 1d c4 53 12 00 mov %ebx,0x1253c4
/*
* 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 );
110ff3: 83 ec 0c sub $0xc,%esp
110ff6: 53 push %ebx
110ff7: e8 90 bc ff ff call 10cc8c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
110ffc: e8 f9 b1 ff ff call 10c1fa <_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) */ {
111001: 83 c4 10 add $0x10,%esp
111004: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
111008: 75 05 jne 11100f <_Thread_Handler+0x73>
INIT_NAME ();
11100a: e8 31 c7 00 00 call 11d740 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
11100f: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
111015: 85 c0 test %eax,%eax
111017: 75 0b jne 111024 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
111019: 83 ec 0c sub $0xc,%esp
11101c: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
111022: eb 0c jmp 111030 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
111024: 48 dec %eax
111025: 75 15 jne 11103c <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
111027: 83 ec 0c sub $0xc,%esp
11102a: ff b3 98 00 00 00 pushl 0x98(%ebx)
111030: 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 =
111036: 89 43 28 mov %eax,0x28(%ebx)
111039: 83 c4 10 add $0x10,%esp
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
11103c: 83 ec 0c sub $0xc,%esp
11103f: 53 push %ebx
111040: e8 78 bc ff ff call 10ccbd <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
111045: 83 c4 0c add $0xc,%esp
111048: 6a 05 push $0x5
11104a: 6a 01 push $0x1
11104c: 6a 00 push $0x0
11104e: e8 39 a2 ff ff call 10b28c <_Internal_error_Occurred>
0010c290 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10c290: 55 push %ebp
10c291: 89 e5 mov %esp,%ebp
10c293: 57 push %edi
10c294: 56 push %esi
10c295: 53 push %ebx
10c296: 83 ec 1c sub $0x1c,%esp
10c299: 8b 5d 0c mov 0xc(%ebp),%ebx
10c29c: 8b 4d 10 mov 0x10(%ebp),%ecx
10c29f: 8b 75 14 mov 0x14(%ebp),%esi
10c2a2: 8a 55 18 mov 0x18(%ebp),%dl
10c2a5: 8a 45 20 mov 0x20(%ebp),%al
10c2a8: 88 45 e7 mov %al,-0x19(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10c2ab: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10c2b2: 00 00 00
10c2b5: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10c2bc: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10c2bf: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10c2c6: 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 ) {
10c2c9: 85 c9 test %ecx,%ecx
10c2cb: 75 31 jne 10c2fe <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c2cd: 57 push %edi
10c2ce: 57 push %edi
10c2cf: 56 push %esi
10c2d0: 53 push %ebx
10c2d1: 88 55 e0 mov %dl,-0x20(%ebp)
10c2d4: e8 fb 06 00 00 call 10c9d4 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c2d9: 83 c4 10 add $0x10,%esp
10c2dc: 39 f0 cmp %esi,%eax
10c2de: 8a 55 e0 mov -0x20(%ebp),%dl
10c2e1: 0f 82 bf 01 00 00 jb 10c4a6 <_Thread_Initialize+0x216>
10c2e7: 85 c0 test %eax,%eax
10c2e9: 0f 84 b7 01 00 00 je 10c4a6 <_Thread_Initialize+0x216><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10c2ef: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10c2f5: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10c2fc: eb 09 jmp 10c307 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10c2fe: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10c305: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10c307: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10c30d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10c313: 31 ff xor %edi,%edi
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10c315: 84 d2 test %dl,%dl
10c317: 74 17 je 10c330 <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c319: 83 ec 0c sub $0xc,%esp
10c31c: 6a 6c push $0x6c
10c31e: e8 27 0d 00 00 call 10d04a <_Workspace_Allocate>
10c323: 89 c7 mov %eax,%edi
if ( !fp_area )
10c325: 83 c4 10 add $0x10,%esp
10c328: 85 c0 test %eax,%eax
10c32a: 0f 84 23 01 00 00 je 10c453 <_Thread_Initialize+0x1c3>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c330: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10c336: 89 bb c0 00 00 00 mov %edi,0xc0(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c33c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c343: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c34a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c351: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c358: a1 d4 53 12 00 mov 0x1253d4,%eax
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c35d: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c35f: 85 c0 test %eax,%eax
10c361: 74 1d je 10c380 <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c363: 83 ec 0c sub $0xc,%esp
10c366: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c36d: 50 push %eax
10c36e: e8 d7 0c 00 00 call 10d04a <_Workspace_Allocate>
10c373: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c375: 83 c4 10 add $0x10,%esp
10c378: 85 c0 test %eax,%eax
10c37a: 0f 84 d5 00 00 00 je 10c455 <_Thread_Initialize+0x1c5>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c380: 89 b3 f0 00 00 00 mov %esi,0xf0(%ebx)
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
10c386: 85 f6 test %esi,%esi
10c388: 74 16 je 10c3a0 <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c38a: 8b 15 d4 53 12 00 mov 0x1253d4,%edx
10c390: 31 c0 xor %eax,%eax
10c392: eb 08 jmp 10c39c <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c394: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c39b: 40 inc %eax
10c39c: 39 d0 cmp %edx,%eax
10c39e: 76 f4 jbe 10c394 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c3a0: 8a 45 e7 mov -0x19(%ebp),%al
10c3a3: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c3a9: 8b 45 24 mov 0x24(%ebp),%eax
10c3ac: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c3b2: 8b 45 28 mov 0x28(%ebp),%eax
10c3b5: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10c3bb: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c3bf: 75 08 jne 10c3c9 <_Thread_Initialize+0x139>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c3c1: a1 10 53 12 00 mov 0x125310,%eax
10c3c6: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c3c9: 8b 45 2c mov 0x2c(%ebp),%eax
10c3cc: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10c3d2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c3d9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c3e0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c3e7: 8b 45 1c mov 0x1c(%ebp),%eax
10c3ea: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c3ed: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
10c3f3: 83 ec 0c sub $0xc,%esp
10c3f6: 53 push %ebx
10c3f7: ff 15 68 11 12 00 call *0x121168
10c3fd: 89 c2 mov %eax,%edx
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
10c3ff: 83 c4 10 add $0x10,%esp
10c402: 85 c0 test %eax,%eax
10c404: 74 51 je 10c457 <_Thread_Initialize+0x1c7>
goto failed;
_Thread_Set_priority( the_thread, priority );
10c406: 51 push %ecx
10c407: 51 push %ecx
10c408: ff 75 1c pushl 0x1c(%ebp)
10c40b: 53 push %ebx
10c40c: 89 45 e0 mov %eax,-0x20(%ebp)
10c40f: e8 40 05 00 00 call 10c954 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c414: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c41b: 00 00 00
10c41e: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c425: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10c428: 8b 45 08 mov 0x8(%ebp),%eax
10c42b: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c42e: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c432: 89 1c 88 mov %ebx,(%eax,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c435: 8b 45 30 mov 0x30(%ebp),%eax
10c438: 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 );
10c43b: 89 1c 24 mov %ebx,(%esp)
10c43e: e8 e9 08 00 00 call 10cd2c <_User_extensions_Thread_create>
10c443: 88 c1 mov %al,%cl
if ( extension_status )
10c445: 83 c4 10 add $0x10,%esp
return true;
10c448: b0 01 mov $0x1,%al
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
10c44a: 84 c9 test %cl,%cl
10c44c: 8b 55 e0 mov -0x20(%ebp),%edx
10c44f: 74 06 je 10c457 <_Thread_Initialize+0x1c7>
10c451: eb 55 jmp 10c4a8 <_Thread_Initialize+0x218>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c453: 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;
10c455: 31 d2 xor %edx,%edx
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10c457: 83 ec 0c sub $0xc,%esp
10c45a: ff b3 e4 00 00 00 pushl 0xe4(%ebx)
10c460: 89 55 e0 mov %edx,-0x20(%ebp)
10c463: e8 fb 0b 00 00 call 10d063 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10c468: 5a pop %edx
10c469: ff b3 e8 00 00 00 pushl 0xe8(%ebx)
10c46f: e8 ef 0b 00 00 call 10d063 <_Workspace_Free>
10c474: 58 pop %eax
10c475: ff b3 ec 00 00 00 pushl 0xec(%ebx)
10c47b: e8 e3 0b 00 00 call 10d063 <_Workspace_Free>
_Workspace_Free( extensions_area );
10c480: 89 34 24 mov %esi,(%esp)
10c483: e8 db 0b 00 00 call 10d063 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10c488: 89 3c 24 mov %edi,(%esp)
10c48b: e8 d3 0b 00 00 call 10d063 <_Workspace_Free>
#endif
_Workspace_Free( sched );
10c490: 8b 55 e0 mov -0x20(%ebp),%edx
10c493: 89 14 24 mov %edx,(%esp)
10c496: e8 c8 0b 00 00 call 10d063 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10c49b: 89 1c 24 mov %ebx,(%esp)
10c49e: e8 81 05 00 00 call 10ca24 <_Thread_Stack_Free>
return false;
10c4a3: 83 c4 10 add $0x10,%esp
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
10c4a6: 31 c0 xor %eax,%eax
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10c4a8: 8d 65 f4 lea -0xc(%ebp),%esp
10c4ab: 5b pop %ebx
10c4ac: 5e pop %esi
10c4ad: 5f pop %edi
10c4ae: c9 leave
10c4af: c3 ret
0010f6dc <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f6dc: 55 push %ebp
10f6dd: 89 e5 mov %esp,%ebp
10f6df: 53 push %ebx
10f6e0: 83 ec 04 sub $0x4,%esp
10f6e3: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f6e6: 9c pushf
10f6e7: fa cli
10f6e8: 5b pop %ebx
current_state = the_thread->current_state;
10f6e9: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f6ec: f6 c2 02 test $0x2,%dl
10f6ef: 74 17 je 10f708 <_Thread_Resume+0x2c> <== NEVER TAKEN
10f6f1: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f6f4: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f6f7: 85 d2 test %edx,%edx
10f6f9: 75 0d jne 10f708 <_Thread_Resume+0x2c>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10f6fb: 83 ec 0c sub $0xc,%esp
10f6fe: 50 push %eax
10f6ff: ff 15 64 41 12 00 call *0x124164
10f705: 83 c4 10 add $0x10,%esp
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10f708: 53 push %ebx
10f709: 9d popf
}
10f70a: 8b 5d fc mov -0x4(%ebp),%ebx
10f70d: c9 leave
10f70e: c3 ret
0010cb0c <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10cb0c: 55 push %ebp
10cb0d: 89 e5 mov %esp,%ebp
10cb0f: 53 push %ebx
10cb10: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10cb13: 8b 1d 68 58 12 00 mov 0x125868,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10cb19: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10cb1d: 74 4d je 10cb6c <_Thread_Tickle_timeslice+0x60>
return;
if ( !_States_Is_ready( executing->current_state ) )
10cb1f: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cb23: 75 47 jne 10cb6c <_Thread_Tickle_timeslice+0x60>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10cb25: 8b 43 7c mov 0x7c(%ebx),%eax
10cb28: 83 f8 01 cmp $0x1,%eax
10cb2b: 72 3f jb 10cb6c <_Thread_Tickle_timeslice+0x60>
10cb2d: 83 f8 02 cmp $0x2,%eax
10cb30: 76 07 jbe 10cb39 <_Thread_Tickle_timeslice+0x2d>
10cb32: 83 f8 03 cmp $0x3,%eax
10cb35: 75 35 jne 10cb6c <_Thread_Tickle_timeslice+0x60><== NEVER TAKEN
10cb37: eb 1b jmp 10cb54 <_Thread_Tickle_timeslice+0x48>
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 ) {
10cb39: 8b 43 78 mov 0x78(%ebx),%eax
10cb3c: 48 dec %eax
10cb3d: 89 43 78 mov %eax,0x78(%ebx)
10cb40: 85 c0 test %eax,%eax
10cb42: 7f 28 jg 10cb6c <_Thread_Tickle_timeslice+0x60>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
10cb44: ff 15 5c 11 12 00 call *0x12115c
* 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;
10cb4a: a1 10 53 12 00 mov 0x125310,%eax
10cb4f: 89 43 78 mov %eax,0x78(%ebx)
10cb52: eb 18 jmp 10cb6c <_Thread_Tickle_timeslice+0x60>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10cb54: 8b 43 78 mov 0x78(%ebx),%eax
10cb57: 48 dec %eax
10cb58: 89 43 78 mov %eax,0x78(%ebx)
10cb5b: 85 c0 test %eax,%eax
10cb5d: 75 0d jne 10cb6c <_Thread_Tickle_timeslice+0x60>
(*executing->budget_callout)( executing );
10cb5f: 83 ec 0c sub $0xc,%esp
10cb62: 53 push %ebx
10cb63: ff 93 80 00 00 00 call *0x80(%ebx)
10cb69: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10cb6c: 8b 5d fc mov -0x4(%ebp),%ebx
10cb6f: c9 leave
10cb70: c3 ret
0010c6d0 <_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
)
{
10c6d0: 55 push %ebp
10c6d1: 89 e5 mov %esp,%ebp
10c6d3: 57 push %edi
10c6d4: 56 push %esi
10c6d5: 53 push %ebx
10c6d6: 83 ec 14 sub $0x14,%esp
10c6d9: 8b 4d 08 mov 0x8(%ebp),%ecx
10c6dc: 8b 45 0c mov 0xc(%ebp),%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 );
10c6df: 8d 50 3c lea 0x3c(%eax),%edx
10c6e2: 89 50 38 mov %edx,0x38(%eax)
head->next = tail;
head->previous = NULL;
10c6e5: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10c6ec: 8d 50 38 lea 0x38(%eax),%edx
10c6ef: 89 50 40 mov %edx,0x40(%eax)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10c6f2: 8b 58 14 mov 0x14(%eax),%ebx
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
10c6f5: 89 da mov %ebx,%edx
10c6f7: c1 ea 06 shr $0x6,%edx
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
10c6fa: 8b 71 38 mov 0x38(%ecx),%esi
10c6fd: 89 75 e8 mov %esi,-0x18(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
10c700: f6 c3 20 test $0x20,%bl
10c703: 75 77 jne 10c77c <_Thread_queue_Enqueue_priority+0xac>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10c705: 6b d2 0c imul $0xc,%edx,%edx
10c708: 8d 14 11 lea (%ecx,%edx,1),%edx
10c70b: 89 55 ec mov %edx,-0x14(%ebp)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c70e: 83 c2 04 add $0x4,%edx
10c711: 89 55 e4 mov %edx,-0x1c(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10c714: 9c pushf
10c715: fa cli
10c716: 8f 45 f0 popl -0x10(%ebp)
10c719: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) _Chain_First( header );
10c71c: 8b 7d ec mov -0x14(%ebp),%edi
10c71f: 8b 17 mov (%edi),%edx
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10c721: 83 cf ff or $0xffffffff,%edi
10c724: 89 75 e0 mov %esi,-0x20(%ebp)
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c727: eb 1c jmp 10c745 <_Thread_queue_Enqueue_priority+0x75>
search_priority = search_thread->current_priority;
10c729: 8b 7a 14 mov 0x14(%edx),%edi
if ( priority <= search_priority )
10c72c: 39 fb cmp %edi,%ebx
10c72e: 76 1a jbe 10c74a <_Thread_queue_Enqueue_priority+0x7a>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10c730: ff 75 f0 pushl -0x10(%ebp)
10c733: 9d popf
10c734: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c735: 8b 75 e8 mov -0x18(%ebp),%esi
10c738: 85 72 10 test %esi,0x10(%edx)
10c73b: 75 06 jne 10c743 <_Thread_queue_Enqueue_priority+0x73>
_ISR_Enable( level );
10c73d: ff 75 f0 pushl -0x10(%ebp)
10c740: 9d popf
goto restart_forward_search;
10c741: eb d1 jmp 10c714 <_Thread_queue_Enqueue_priority+0x44>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10c743: 8b 12 mov (%edx),%edx
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 ) ) {
10c745: 3b 55 e4 cmp -0x1c(%ebp),%edx
10c748: 75 df jne 10c729 <_Thread_queue_Enqueue_priority+0x59>
10c74a: 8b 75 e0 mov -0x20(%ebp),%esi
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10c74d: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c751: 0f 85 b6 00 00 00 jne 10c80d <_Thread_queue_Enqueue_priority+0x13d>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c757: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c75e: 39 fb cmp %edi,%ebx
10c760: 0f 84 90 00 00 00 je 10c7f6 <_Thread_queue_Enqueue_priority+0x126>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10c766: 8b 5a 04 mov 0x4(%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c769: 89 10 mov %edx,(%eax)
the_node->previous = previous_node;
10c76b: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c76e: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c770: 89 42 04 mov %eax,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c773: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c776: ff 75 f0 pushl -0x10(%ebp)
10c779: 9d popf
10c77a: eb 73 jmp 10c7ef <_Thread_queue_Enqueue_priority+0x11f>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10c77c: 6b d2 0c imul $0xc,%edx,%edx
10c77f: 8d 14 11 lea (%ecx,%edx,1),%edx
10c782: 89 55 ec mov %edx,-0x14(%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;
10c785: 0f b6 3d 24 12 12 00 movzbl 0x121224,%edi
10c78c: 47 inc %edi
10c78d: 89 7d e4 mov %edi,-0x1c(%ebp)
_ISR_Disable( level );
10c790: 9c pushf
10c791: fa cli
10c792: 8f 45 f0 popl -0x10(%ebp)
10c795: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) _Chain_Last( header );
10c798: 8b 7d ec mov -0x14(%ebp),%edi
10c79b: 8b 57 08 mov 0x8(%edi),%edx
10c79e: 8b 7d e4 mov -0x1c(%ebp),%edi
10c7a1: 89 75 e4 mov %esi,-0x1c(%ebp)
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c7a4: eb 1d jmp 10c7c3 <_Thread_queue_Enqueue_priority+0xf3>
search_priority = search_thread->current_priority;
10c7a6: 8b 7a 14 mov 0x14(%edx),%edi
if ( priority >= search_priority )
10c7a9: 39 fb cmp %edi,%ebx
10c7ab: 73 1b jae 10c7c8 <_Thread_queue_Enqueue_priority+0xf8>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10c7ad: ff 75 f0 pushl -0x10(%ebp)
10c7b0: 9d popf
10c7b1: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c7b2: 8b 75 e8 mov -0x18(%ebp),%esi
10c7b5: 85 72 10 test %esi,0x10(%edx)
10c7b8: 75 06 jne 10c7c0 <_Thread_queue_Enqueue_priority+0xf0><== ALWAYS TAKEN
_ISR_Enable( level );
10c7ba: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10c7bd: 9d popf <== NOT EXECUTED
goto restart_reverse_search;
10c7be: eb c5 jmp 10c785 <_Thread_queue_Enqueue_priority+0xb5><== NOT EXECUTED
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10c7c0: 8b 52 04 mov 0x4(%edx),%edx
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 ) ) {
10c7c3: 3b 55 ec cmp -0x14(%ebp),%edx
10c7c6: 75 de jne 10c7a6 <_Thread_queue_Enqueue_priority+0xd6>
10c7c8: 8b 75 e4 mov -0x1c(%ebp),%esi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10c7cb: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c7cf: 75 3c jne 10c80d <_Thread_queue_Enqueue_priority+0x13d>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c7d1: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c7d8: 39 fb cmp %edi,%ebx
10c7da: 74 1a je 10c7f6 <_Thread_queue_Enqueue_priority+0x126>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10c7dc: 8b 1a mov (%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10c7de: 89 18 mov %ebx,(%eax)
the_node->previous = search_node;
10c7e0: 89 50 04 mov %edx,0x4(%eax)
search_node->next = the_node;
10c7e3: 89 02 mov %eax,(%edx)
next_node->previous = the_node;
10c7e5: 89 43 04 mov %eax,0x4(%ebx)
the_thread->Wait.queue = the_thread_queue;
10c7e8: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c7eb: ff 75 f0 pushl -0x10(%ebp)
10c7ee: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c7ef: b8 01 00 00 00 mov $0x1,%eax
10c7f4: eb 1f jmp 10c815 <_Thread_queue_Enqueue_priority+0x145>
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10c7f6: 8b 5a 40 mov 0x40(%edx),%ebx
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 );
10c7f9: 8d 7a 3c lea 0x3c(%edx),%edi
10c7fc: 89 38 mov %edi,(%eax)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
10c7fe: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c801: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c803: 89 42 40 mov %eax,0x40(%edx)
the_thread->Wait.queue = the_thread_queue;
10c806: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c809: 56 push %esi
10c80a: 9d popf
10c80b: eb e2 jmp 10c7ef <_Thread_queue_Enqueue_priority+0x11f>
* 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;
10c80d: 8b 45 10 mov 0x10(%ebp),%eax
10c810: 89 30 mov %esi,(%eax)
return the_thread_queue->sync_state;
10c812: 8b 41 30 mov 0x30(%ecx),%eax
}
10c815: 83 c4 14 add $0x14,%esp
10c818: 5b pop %ebx
10c819: 5e pop %esi
10c81a: 5f pop %edi
10c81b: c9 leave
10c81c: c3 ret
0010c8cc <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c8cc: 55 push %ebp
10c8cd: 89 e5 mov %esp,%ebp
10c8cf: 57 push %edi
10c8d0: 56 push %esi
10c8d1: 53 push %ebx
10c8d2: 83 ec 1c sub $0x1c,%esp
10c8d5: 8b 75 08 mov 0x8(%ebp),%esi
10c8d8: 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 )
10c8db: 85 f6 test %esi,%esi
10c8dd: 74 36 je 10c915 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10c8df: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c8e3: 75 30 jne 10c915 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c8e5: 9c pushf
10c8e6: fa cli
10c8e7: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c8e8: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c8ef: 74 22 je 10c913 <_Thread_queue_Requeue+0x47><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c8f1: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
10c8f8: 50 push %eax
10c8f9: 6a 01 push $0x1
10c8fb: 57 push %edi
10c8fc: 56 push %esi
10c8fd: e8 12 31 00 00 call 10fa14 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c902: 83 c4 0c add $0xc,%esp
10c905: 8d 45 e4 lea -0x1c(%ebp),%eax
10c908: 50 push %eax
10c909: 57 push %edi
10c90a: 56 push %esi
10c90b: e8 c0 fd ff ff call 10c6d0 <_Thread_queue_Enqueue_priority>
10c910: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c913: 53 push %ebx
10c914: 9d popf
}
}
10c915: 8d 65 f4 lea -0xc(%ebp),%esp
10c918: 5b pop %ebx
10c919: 5e pop %esi
10c91a: 5f pop %edi
10c91b: c9 leave
10c91c: c3 ret
0010c920 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c920: 55 push %ebp
10c921: 89 e5 mov %esp,%ebp
10c923: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c926: 8d 45 f4 lea -0xc(%ebp),%eax
10c929: 50 push %eax
10c92a: ff 75 08 pushl 0x8(%ebp)
10c92d: e8 ea f8 ff ff call 10c21c <_Thread_Get>
switch ( location ) {
10c932: 83 c4 10 add $0x10,%esp
10c935: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c939: 75 17 jne 10c952 <_Thread_queue_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10c93b: 83 ec 0c sub $0xc,%esp
10c93e: 50 push %eax
10c93f: e8 88 31 00 00 call 10facc <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c944: a1 40 53 12 00 mov 0x125340,%eax
10c949: 48 dec %eax
10c94a: a3 40 53 12 00 mov %eax,0x125340
10c94f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c952: c9 leave
10c953: c3 ret
001169c4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
1169c4: 55 push %ebp
1169c5: 89 e5 mov %esp,%ebp
1169c7: 57 push %edi
1169c8: 56 push %esi
1169c9: 53 push %ebx
1169ca: 83 ec 4c sub $0x4c,%esp
1169cd: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1169d0: 8d 55 dc lea -0x24(%ebp),%edx
1169d3: 8d 45 e0 lea -0x20(%ebp),%eax
1169d6: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
1169d9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
1169e0: 89 55 e4 mov %edx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1169e3: 8d 7d d0 lea -0x30(%ebp),%edi
1169e6: 8d 4d d4 lea -0x2c(%ebp),%ecx
1169e9: 89 4d d0 mov %ecx,-0x30(%ebp)
head->previous = NULL;
1169ec: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
1169f3: 89 7d d8 mov %edi,-0x28(%ebp)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169f6: 8d 53 30 lea 0x30(%ebx),%edx
1169f9: 89 55 c0 mov %edx,-0x40(%ebp)
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169fc: 8d 73 68 lea 0x68(%ebx),%esi
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
1169ff: 89 45 b4 mov %eax,-0x4c(%ebp)
Chain_Control *tmp;
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
116a02: 8d 4d dc lea -0x24(%ebp),%ecx
116a05: 89 4b 78 mov %ecx,0x78(%ebx)
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
116a08: a1 e8 f0 13 00 mov 0x13f0e8,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
116a0d: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
116a10: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116a13: 51 push %ecx
116a14: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
116a15: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116a17: 50 push %eax
116a18: ff 75 c0 pushl -0x40(%ebp)
116a1b: e8 d4 39 00 00 call 11a3f4 <_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();
116a20: a1 60 f0 13 00 mov 0x13f060,%eax
116a25: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
116a28: 8b 43 74 mov 0x74(%ebx),%eax
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
116a2b: 83 c4 10 add $0x10,%esp
116a2e: 39 45 c4 cmp %eax,-0x3c(%ebp)
116a31: 76 10 jbe 116a43 <_Timer_server_Body+0x7f>
/*
* 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 );
116a33: 52 push %edx
116a34: 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;
116a35: 8b 55 c4 mov -0x3c(%ebp),%edx
116a38: 29 c2 sub %eax,%edx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
116a3a: 52 push %edx
116a3b: 56 push %esi
116a3c: e8 b3 39 00 00 call 11a3f4 <_Watchdog_Adjust_to_chain>
116a41: eb 0f jmp 116a52 <_Timer_server_Body+0x8e>
} else if ( snapshot < last_snapshot ) {
116a43: 73 10 jae 116a55 <_Timer_server_Body+0x91>
/*
* 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 );
116a45: 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;
116a46: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
116a49: 50 push %eax
116a4a: 6a 01 push $0x1
116a4c: 56 push %esi
116a4d: e8 36 39 00 00 call 11a388 <_Watchdog_Adjust>
116a52: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a55: 8b 4d c4 mov -0x3c(%ebp),%ecx
116a58: 89 4b 74 mov %ecx,0x74(%ebx)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
116a5b: 8b 43 78 mov 0x78(%ebx),%eax
116a5e: 83 ec 0c sub $0xc,%esp
116a61: 50 push %eax
116a62: e8 fd 08 00 00 call 117364 <_Chain_Get>
if ( timer == NULL ) {
116a67: 83 c4 10 add $0x10,%esp
116a6a: 85 c0 test %eax,%eax
116a6c: 74 29 je 116a97 <_Timer_server_Body+0xd3><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116a6e: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
116a71: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
116a74: 75 0b jne 116a81 <_Timer_server_Body+0xbd><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a76: 52 push %edx <== NOT EXECUTED
116a77: 52 push %edx <== NOT EXECUTED
116a78: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a7b: 50 push %eax <== NOT EXECUTED
116a7c: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED
116a7f: eb 0c jmp 116a8d <_Timer_server_Body+0xc9><== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a81: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
116a84: 75 d5 jne 116a5b <_Timer_server_Body+0x97><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a86: 51 push %ecx <== NOT EXECUTED
116a87: 51 push %ecx <== NOT EXECUTED
116a88: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a8b: 50 push %eax <== NOT EXECUTED
116a8c: 56 push %esi <== NOT EXECUTED
116a8d: e8 ea 39 00 00 call 11a47c <_Watchdog_Insert> <== NOT EXECUTED
116a92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116a95: eb c4 jmp 116a5b <_Timer_server_Body+0x97><== 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 );
116a97: 9c pushf
116a98: fa cli
116a99: 5a pop %edx
tmp = ts->insert_chain;
116a9a: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a9d: b0 01 mov $0x1,%al
116a9f: 8b 4d b4 mov -0x4c(%ebp),%ecx
116aa2: 39 4d dc cmp %ecx,-0x24(%ebp)
116aa5: 75 09 jne 116ab0 <_Timer_server_Body+0xec><== NEVER TAKEN
ts->insert_chain = NULL;
116aa7: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116aae: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116ab0: 52 push %edx
116ab1: 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 ) {
116ab2: 84 c0 test %al,%al
116ab4: 0f 85 4e ff ff ff jne 116a08 <_Timer_server_Body+0x44><== NEVER TAKEN
116aba: 8d 45 d4 lea -0x2c(%ebp),%eax
_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 ) ) {
116abd: 39 45 d0 cmp %eax,-0x30(%ebp)
116ac0: 74 3a je 116afc <_Timer_server_Body+0x138>
116ac2: 89 45 b0 mov %eax,-0x50(%ebp)
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
116ac5: 9c pushf
116ac6: fa cli
116ac7: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
116ac8: 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))
116acb: 3b 45 b0 cmp -0x50(%ebp),%eax
116ace: 74 25 je 116af5 <_Timer_server_Body+0x131>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
116ad0: 8b 10 mov (%eax),%edx
head->next = new_first;
116ad2: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
116ad5: 89 7a 04 mov %edi,0x4(%edx)
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
116ad8: 85 c0 test %eax,%eax
116ada: 74 19 je 116af5 <_Timer_server_Body+0x131><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116adc: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116ae3: 51 push %ecx
116ae4: 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 );
116ae5: 52 push %edx
116ae6: 52 push %edx
116ae7: ff 70 24 pushl 0x24(%eax)
116aea: ff 70 20 pushl 0x20(%eax)
116aed: ff 50 1c call *0x1c(%eax)
}
116af0: 83 c4 10 add $0x10,%esp
116af3: eb d0 jmp 116ac5 <_Timer_server_Body+0x101>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
116af5: 51 push %ecx
116af6: 9d popf
116af7: e9 06 ff ff ff jmp 116a02 <_Timer_server_Body+0x3e>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116afc: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116b00: e8 23 fe ff ff call 116928 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116b05: 51 push %ecx
116b06: 51 push %ecx
116b07: 6a 08 push $0x8
116b09: ff 33 pushl (%ebx)
116b0b: e8 18 33 00 00 call 119e28 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116b10: 89 d8 mov %ebx,%eax
116b12: e8 21 fe ff ff call 116938 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116b17: 89 d8 mov %ebx,%eax
116b19: e8 60 fe ff ff call 11697e <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116b1e: e8 db 2a 00 00 call 1195fe <_Thread_Enable_dispatch>
ts->active = true;
116b23: 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 );
116b27: 8d 43 08 lea 0x8(%ebx),%eax
116b2a: 89 04 24 mov %eax,(%esp)
116b2d: e8 6a 3a 00 00 call 11a59c <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116b32: 8d 43 40 lea 0x40(%ebx),%eax
116b35: 89 04 24 mov %eax,(%esp)
116b38: e8 5f 3a 00 00 call 11a59c <_Watchdog_Remove>
116b3d: 83 c4 10 add $0x10,%esp
116b40: e9 bd fe ff ff jmp 116a02 <_Timer_server_Body+0x3e>
00116b45 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116b45: 55 push %ebp
116b46: 89 e5 mov %esp,%ebp
116b48: 57 push %edi
116b49: 56 push %esi
116b4a: 53 push %ebx
116b4b: 83 ec 2c sub $0x2c,%esp
116b4e: 8b 5d 08 mov 0x8(%ebp),%ebx
116b51: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b54: 8b 43 78 mov 0x78(%ebx),%eax
116b57: 85 c0 test %eax,%eax
116b59: 0f 85 de 00 00 00 jne 116c3d <_Timer_server_Schedule_operation_method+0xf8><== NEVER TAKEN
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
116b5f: e8 c4 fd ff ff call 116928 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b64: 8b 46 38 mov 0x38(%esi),%eax
116b67: 83 f8 01 cmp $0x1,%eax
116b6a: 75 5a jne 116bc6 <_Timer_server_Schedule_operation_method+0x81>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
116b6c: 9c pushf
116b6d: fa cli
116b6e: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b71: 8b 15 e8 f0 13 00 mov 0x13f0e8,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b77: 8b 4b 3c mov 0x3c(%ebx),%ecx
initialized = false;
}
#endif
return status;
}
116b7a: 8b 43 30 mov 0x30(%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 );
116b7d: 8d 7b 34 lea 0x34(%ebx),%edi
* 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 ) ) {
116b80: 39 f8 cmp %edi,%eax
116b82: 74 19 je 116b9d <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b84: 89 d7 mov %edx,%edi
116b86: 29 cf sub %ecx,%edi
116b88: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b8b: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b8e: 31 c9 xor %ecx,%ecx
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
116b90: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b93: 76 05 jbe 116b9a <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b95: 89 f9 mov %edi,%ecx
116b97: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b9a: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b9d: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116ba0: ff 75 e0 pushl -0x20(%ebp)
116ba3: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116ba4: 50 push %eax
116ba5: 50 push %eax
116ba6: 83 c6 10 add $0x10,%esi
116ba9: 56 push %esi
116baa: 8d 43 30 lea 0x30(%ebx),%eax
116bad: 50 push %eax
116bae: e8 c9 38 00 00 call 11a47c <_Watchdog_Insert>
if ( !ts->active ) {
116bb3: 8a 43 7c mov 0x7c(%ebx),%al
116bb6: 83 c4 10 add $0x10,%esp
116bb9: 84 c0 test %al,%al
116bbb: 75 74 jne 116c31 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116bbd: 89 d8 mov %ebx,%eax
116bbf: e8 74 fd ff ff call 116938 <_Timer_server_Reset_interval_system_watchdog>
116bc4: eb 6b jmp 116c31 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116bc6: 83 f8 03 cmp $0x3,%eax
116bc9: 75 66 jne 116c31 <_Timer_server_Schedule_operation_method+0xec>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
116bcb: 9c pushf
116bcc: fa cli
116bcd: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116bd0: 8b 15 60 f0 13 00 mov 0x13f060,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116bd6: 8b 43 74 mov 0x74(%ebx),%eax
initialized = false;
}
#endif
return status;
}
116bd9: 8b 4b 68 mov 0x68(%ebx),%ecx
116bdc: 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 ) ) {
116bdf: 39 f9 cmp %edi,%ecx
116be1: 74 27 je 116c0a <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116be3: 8b 79 10 mov 0x10(%ecx),%edi
116be6: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116be9: 39 c2 cmp %eax,%edx
116beb: 76 15 jbe 116c02 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116bed: 89 d7 mov %edx,%edi
116bef: 29 c7 sub %eax,%edi
116bf1: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116bf4: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116bf6: 39 7d d4 cmp %edi,-0x2c(%ebp)
116bf9: 76 0c jbe 116c07 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116bfb: 8b 45 d4 mov -0x2c(%ebp),%eax
116bfe: 29 f8 sub %edi,%eax
116c00: eb 05 jmp 116c07 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116c02: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116c05: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116c07: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116c0a: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116c0d: ff 75 e0 pushl -0x20(%ebp)
116c10: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116c11: 57 push %edi
116c12: 57 push %edi
116c13: 83 c6 10 add $0x10,%esi
116c16: 56 push %esi
116c17: 8d 43 68 lea 0x68(%ebx),%eax
116c1a: 50 push %eax
116c1b: e8 5c 38 00 00 call 11a47c <_Watchdog_Insert>
if ( !ts->active ) {
116c20: 8a 43 7c mov 0x7c(%ebx),%al
116c23: 83 c4 10 add $0x10,%esp
116c26: 84 c0 test %al,%al
116c28: 75 07 jne 116c31 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116c2a: 89 d8 mov %ebx,%eax
116c2c: e8 4d fd ff ff call 11697e <_Timer_server_Reset_tod_system_watchdog>
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
116c31: 8d 65 f4 lea -0xc(%ebp),%esp
116c34: 5b pop %ebx
116c35: 5e pop %esi
116c36: 5f pop %edi
116c37: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116c38: e9 c1 29 00 00 jmp 1195fe <_Thread_Enable_dispatch>
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
116c3d: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
116c40: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
116c43: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
116c46: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116c49: 5b pop %ebx <== NOT EXECUTED
116c4a: 5e pop %esi <== NOT EXECUTED
116c4b: 5f pop %edi <== NOT EXECUTED
116c4c: 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 );
116c4d: e9 d6 06 00 00 jmp 117328 <_Chain_Append> <== NOT EXECUTED
0010ccef <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10ccef: 55 push %ebp
10ccf0: 89 e5 mov %esp,%ebp
10ccf2: 57 push %edi
10ccf3: 56 push %esi
10ccf4: 53 push %ebx
10ccf5: 83 ec 0c sub $0xc,%esp
10ccf8: 8b 7d 10 mov 0x10(%ebp),%edi
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10ccfb: 8b 1d 14 55 12 00 mov 0x125514,%ebx
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cd01: 0f b6 75 0c movzbl 0xc(%ebp),%esi
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10cd05: eb 15 jmp 10cd1c <_User_extensions_Fatal+0x2d>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
10cd07: 8b 43 30 mov 0x30(%ebx),%eax
10cd0a: 85 c0 test %eax,%eax
10cd0c: 74 0b je 10cd19 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cd0e: 52 push %edx
10cd0f: 57 push %edi
10cd10: 56 push %esi
10cd11: ff 75 08 pushl 0x8(%ebp)
10cd14: ff d0 call *%eax
10cd16: 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 ) {
10cd19: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10cd1c: 81 fb 0c 55 12 00 cmp $0x12550c,%ebx
10cd22: 75 e3 jne 10cd07 <_User_extensions_Fatal+0x18><== ALWAYS TAKEN
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10cd24: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cd27: 5b pop %ebx <== NOT EXECUTED
10cd28: 5e pop %esi <== NOT EXECUTED
10cd29: 5f pop %edi <== NOT EXECUTED
10cd2a: c9 leave <== NOT EXECUTED
10cd2b: c3 ret <== NOT EXECUTED
0010cbd8 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10cbd8: 55 push %ebp
10cbd9: 89 e5 mov %esp,%ebp
10cbdb: 57 push %edi
10cbdc: 56 push %esi
10cbdd: 53 push %ebx
10cbde: 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;
10cbe1: a1 60 12 12 00 mov 0x121260,%eax
10cbe6: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10cbe9: 8b 35 64 12 12 00 mov 0x121264,%esi
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cbef: c7 05 0c 55 12 00 10 movl $0x125510,0x12550c
10cbf6: 55 12 00
head->previous = NULL;
10cbf9: c7 05 10 55 12 00 00 movl $0x0,0x125510
10cc00: 00 00 00
tail->previous = head;
10cc03: c7 05 14 55 12 00 0c movl $0x12550c,0x125514
10cc0a: 55 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cc0d: c7 05 44 53 12 00 48 movl $0x125348,0x125344
10cc14: 53 12 00
head->previous = NULL;
10cc17: c7 05 48 53 12 00 00 movl $0x0,0x125348
10cc1e: 00 00 00
tail->previous = head;
10cc21: c7 05 4c 53 12 00 44 movl $0x125344,0x12534c
10cc28: 53 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cc2b: 85 f6 test %esi,%esi
10cc2d: 74 53 je 10cc82 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cc2f: 6b c8 34 imul $0x34,%eax,%ecx
10cc32: 83 ec 0c sub $0xc,%esp
10cc35: 51 push %ecx
10cc36: 89 4d e0 mov %ecx,-0x20(%ebp)
10cc39: e8 3d 04 00 00 call 10d07b <_Workspace_Allocate_or_fatal_error>
10cc3e: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cc40: 31 c0 xor %eax,%eax
10cc42: 8b 4d e0 mov -0x20(%ebp),%ecx
10cc45: 89 df mov %ebx,%edi
10cc47: f3 aa rep stos %al,%es:(%edi)
10cc49: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cc4b: 83 c4 10 add $0x10,%esp
10cc4e: 31 d2 xor %edx,%edx
10cc50: eb 2b jmp 10cc7d <_User_extensions_Handler_initialization+0xa5>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10cc52: 8d 7b 14 lea 0x14(%ebx),%edi
10cc55: 89 c6 mov %eax,%esi
10cc57: b9 08 00 00 00 mov $0x8,%ecx
10cc5c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10cc5e: 83 ec 0c sub $0xc,%esp
10cc61: 53 push %ebx
10cc62: 89 45 dc mov %eax,-0x24(%ebp)
10cc65: 89 55 e0 mov %edx,-0x20(%ebp)
10cc68: e8 47 2f 00 00 call 10fbb4 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cc6d: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cc70: 8b 55 e0 mov -0x20(%ebp),%edx
10cc73: 42 inc %edx
10cc74: 8b 45 dc mov -0x24(%ebp),%eax
10cc77: 83 c0 20 add $0x20,%eax
10cc7a: 83 c4 10 add $0x10,%esp
10cc7d: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cc80: 72 d0 jb 10cc52 <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cc82: 8d 65 f4 lea -0xc(%ebp),%esp
10cc85: 5b pop %ebx
10cc86: 5e pop %esi
10cc87: 5f pop %edi
10cc88: c9 leave
10cc89: c3 ret
0010e54c <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e54c: 55 push %ebp
10e54d: 89 e5 mov %esp,%ebp
10e54f: 57 push %edi
10e550: 56 push %esi
10e551: 53 push %ebx
10e552: 83 ec 1c sub $0x1c,%esp
10e555: 8b 75 08 mov 0x8(%ebp),%esi
10e558: 8b 7d 0c mov 0xc(%ebp),%edi
10e55b: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e55e: 9c pushf
10e55f: fa cli
10e560: 58 pop %eax
}
}
_ISR_Enable( level );
}
10e561: 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 );
10e563: 8d 4e 04 lea 0x4(%esi),%ecx
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
10e566: 39 ca cmp %ecx,%edx
10e568: 74 44 je 10e5ae <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e56a: 85 ff test %edi,%edi
10e56c: 74 3c je 10e5aa <_Watchdog_Adjust+0x5e>
10e56e: 4f dec %edi
10e56f: 75 3d jne 10e5ae <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e571: 01 5a 10 add %ebx,0x10(%edx)
break;
10e574: eb 38 jmp 10e5ae <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e576: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e578: 8b 7a 10 mov 0x10(%edx),%edi
10e57b: 39 fb cmp %edi,%ebx
10e57d: 73 07 jae 10e586 <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e57f: 29 df sub %ebx,%edi
10e581: 89 7a 10 mov %edi,0x10(%edx)
break;
10e584: eb 28 jmp 10e5ae <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e586: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e58d: 50 push %eax
10e58e: 9d popf
_Watchdog_Tickle( header );
10e58f: 83 ec 0c sub $0xc,%esp
10e592: 56 push %esi
10e593: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e596: e8 a5 01 00 00 call 10e740 <_Watchdog_Tickle>
_ISR_Disable( level );
10e59b: 9c pushf
10e59c: fa cli
10e59d: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e59e: 83 c4 10 add $0x10,%esp
10e5a1: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e5a4: 39 0e cmp %ecx,(%esi)
10e5a6: 74 06 je 10e5ae <_Watchdog_Adjust+0x62>
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
10e5a8: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e5aa: 85 db test %ebx,%ebx
10e5ac: 75 c8 jne 10e576 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e5ae: 50 push %eax
10e5af: 9d popf
}
10e5b0: 8d 65 f4 lea -0xc(%ebp),%esp
10e5b3: 5b pop %ebx
10e5b4: 5e pop %esi
10e5b5: 5f pop %edi
10e5b6: c9 leave
10e5b7: c3 ret
0010cf30 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10cf30: 55 push %ebp
10cf31: 89 e5 mov %esp,%ebp
10cf33: 56 push %esi
10cf34: 53 push %ebx
10cf35: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10cf38: 9c pushf
10cf39: fa cli
10cf3a: 5e pop %esi
previous_state = the_watchdog->state;
10cf3b: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10cf3e: 83 f8 01 cmp $0x1,%eax
10cf41: 74 09 je 10cf4c <_Watchdog_Remove+0x1c>
10cf43: 72 42 jb 10cf87 <_Watchdog_Remove+0x57>
10cf45: 83 f8 03 cmp $0x3,%eax
10cf48: 77 3d ja 10cf87 <_Watchdog_Remove+0x57> <== NEVER TAKEN
10cf4a: eb 09 jmp 10cf55 <_Watchdog_Remove+0x25>
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
10cf4c: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10cf53: eb 32 jmp 10cf87 <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cf55: 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 );
}
10cf5c: 8b 0a mov (%edx),%ecx
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10cf5e: 83 39 00 cmpl $0x0,(%ecx)
10cf61: 74 06 je 10cf69 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10cf63: 8b 5a 10 mov 0x10(%edx),%ebx
10cf66: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10cf69: 8b 1d 50 54 12 00 mov 0x125450,%ebx
10cf6f: 85 db test %ebx,%ebx
10cf71: 74 0c je 10cf7f <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cf73: 8b 1d 64 58 12 00 mov 0x125864,%ebx
10cf79: 89 1d e8 53 12 00 mov %ebx,0x1253e8
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10cf7f: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10cf82: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10cf85: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10cf87: 8b 0d 54 54 12 00 mov 0x125454,%ecx
10cf8d: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10cf90: 56 push %esi
10cf91: 9d popf
return( previous_state );
}
10cf92: 5b pop %ebx
10cf93: 5e pop %esi
10cf94: c9 leave
10cf95: c3 ret
0010e0bc <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e0bc: 55 push %ebp
10e0bd: 89 e5 mov %esp,%ebp
10e0bf: 57 push %edi
10e0c0: 56 push %esi
10e0c1: 53 push %ebx
10e0c2: 83 ec 20 sub $0x20,%esp
10e0c5: 8b 7d 08 mov 0x8(%ebp),%edi
10e0c8: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e0cb: 9c pushf
10e0cc: fa cli
10e0cd: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e0d0: 56 push %esi
10e0d1: 57 push %edi
10e0d2: 68 9c 18 12 00 push $0x12189c
10e0d7: e8 50 aa ff ff call 108b2c <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10e0dc: 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 );
10e0de: 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 ) ) {
10e0e1: 83 c4 10 add $0x10,%esp
10e0e4: 39 f3 cmp %esi,%ebx
10e0e6: 74 1d je 10e105 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e0e8: 52 push %edx
10e0e9: 52 push %edx
10e0ea: 53 push %ebx
10e0eb: 6a 00 push $0x0
10e0ed: e8 32 00 00 00 call 10e124 <_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 )
10e0f2: 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 ) ;
10e0f4: 83 c4 10 add $0x10,%esp
10e0f7: 39 f3 cmp %esi,%ebx
10e0f9: 75 ed jne 10e0e8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e0fb: 50 push %eax
10e0fc: 50 push %eax
10e0fd: 57 push %edi
10e0fe: 68 b3 18 12 00 push $0x1218b3
10e103: eb 08 jmp 10e10d <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e105: 83 ec 0c sub $0xc,%esp
10e108: 68 c2 18 12 00 push $0x1218c2
10e10d: e8 1a aa ff ff call 108b2c <printk>
10e112: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e115: ff 75 e4 pushl -0x1c(%ebp)
10e118: 9d popf
}
10e119: 8d 65 f4 lea -0xc(%ebp),%esp
10e11c: 5b pop %ebx
10e11d: 5e pop %esi
10e11e: 5f pop %edi
10e11f: c9 leave
10e120: c3 ret
0010cf98 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10cf98: 55 push %ebp
10cf99: 89 e5 mov %esp,%ebp
10cf9b: 57 push %edi
10cf9c: 56 push %esi
10cf9d: 53 push %ebx
10cf9e: 83 ec 1c sub $0x1c,%esp
10cfa1: 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 );
10cfa4: 9c pushf
10cfa5: fa cli
10cfa6: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10cfa7: 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 );
10cfa9: 8d 47 04 lea 0x4(%edi),%eax
10cfac: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10cfaf: 39 c3 cmp %eax,%ebx
10cfb1: 74 40 je 10cff3 <_Watchdog_Tickle+0x5b>
* 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) {
10cfb3: 8b 43 10 mov 0x10(%ebx),%eax
10cfb6: 85 c0 test %eax,%eax
10cfb8: 74 08 je 10cfc2 <_Watchdog_Tickle+0x2a>
the_watchdog->delta_interval--;
10cfba: 48 dec %eax
10cfbb: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10cfbe: 85 c0 test %eax,%eax
10cfc0: 75 31 jne 10cff3 <_Watchdog_Tickle+0x5b>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10cfc2: 83 ec 0c sub $0xc,%esp
10cfc5: 53 push %ebx
10cfc6: e8 65 ff ff ff call 10cf30 <_Watchdog_Remove>
_ISR_Enable( level );
10cfcb: 56 push %esi
10cfcc: 9d popf
switch( watchdog_state ) {
10cfcd: 83 c4 10 add $0x10,%esp
10cfd0: 83 f8 02 cmp $0x2,%eax
10cfd3: 75 0e jne 10cfe3 <_Watchdog_Tickle+0x4b> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10cfd5: 50 push %eax
10cfd6: 50 push %eax
10cfd7: ff 73 24 pushl 0x24(%ebx)
10cfda: ff 73 20 pushl 0x20(%ebx)
10cfdd: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10cfe0: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10cfe3: 9c pushf
10cfe4: fa cli
10cfe5: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10cfe6: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10cfe8: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10cfeb: 74 06 je 10cff3 <_Watchdog_Tickle+0x5b>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10cfed: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cff1: eb cd jmp 10cfc0 <_Watchdog_Tickle+0x28>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10cff3: 56 push %esi
10cff4: 9d popf
}
10cff5: 8d 65 f4 lea -0xc(%ebp),%esp
10cff8: 5b pop %ebx
10cff9: 5e pop %esi
10cffa: 5f pop %edi
10cffb: c9 leave
10cffc: c3 ret
0010a818 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a818: 55 push %ebp
10a819: 89 e5 mov %esp,%ebp
10a81b: 57 push %edi
10a81c: 56 push %esi
10a81d: 53 push %ebx
10a81e: 83 ec 18 sub $0x18,%esp
10a821: 8b 75 08 mov 0x8(%ebp),%esi
10a824: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a827: 68 d8 72 12 00 push $0x1272d8
10a82c: e8 2f 10 00 00 call 10b860 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10a831: 5f pop %edi
10a832: 58 pop %eax
10a833: 6a 01 push $0x1
10a835: 56 push %esi
10a836: e8 f1 60 00 00 call 11092c <fcntl>
10a83b: 83 c4 10 add $0x10,%esp
10a83e: 85 c0 test %eax,%eax
10a840: 79 1d jns 10a85f <aio_cancel+0x47>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a842: 83 ec 0c sub $0xc,%esp
10a845: 68 d8 72 12 00 push $0x1272d8
10a84a: e8 91 10 00 00 call 10b8e0 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a84f: e8 94 8e 00 00 call 1136e8 <__errno>
10a854: c7 00 09 00 00 00 movl $0x9,(%eax)
10a85a: e9 e3 00 00 00 jmp 10a942 <aio_cancel+0x12a>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
10a85f: 85 db test %ebx,%ebx
10a861: 0f 85 bd 00 00 00 jne 10a924 <aio_cancel+0x10c>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a867: 51 push %ecx
10a868: 6a 00 push $0x0
10a86a: 56 push %esi
10a86b: 68 20 73 12 00 push $0x127320
10a870: e8 27 03 00 00 call 10ab9c <rtems_aio_search_fd>
10a875: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a877: 83 c4 10 add $0x10,%esp
10a87a: 85 c0 test %eax,%eax
10a87c: 75 6c jne 10a8ea <aio_cancel+0xd2>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a87e: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10a885: 73 12 00
10a888: 0f 84 07 01 00 00 je 10a995 <aio_cancel+0x17d> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a88e: 52 push %edx
10a88f: 6a 00 push $0x0
10a891: 56 push %esi
10a892: 68 2c 73 12 00 push $0x12732c
10a897: e8 00 03 00 00 call 10ab9c <rtems_aio_search_fd>
10a89c: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a89e: 83 c4 10 add $0x10,%esp
10a8a1: 85 c0 test %eax,%eax
10a8a3: 75 17 jne 10a8bc <aio_cancel+0xa4>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a8a5: 83 ec 0c sub $0xc,%esp
10a8a8: 68 d8 72 12 00 push $0x1272d8
10a8ad: e8 2e 10 00 00 call 10b8e0 <pthread_mutex_unlock>
return AIO_ALLDONE;
10a8b2: 83 c4 10 add $0x10,%esp
10a8b5: b3 02 mov $0x2,%bl
10a8b7: e9 21 01 00 00 jmp 10a9dd <aio_cancel+0x1c5>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a8bc: 83 ec 0c sub $0xc,%esp
10a8bf: 50 push %eax
10a8c0: e8 fb 26 00 00 call 10cfc0 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8c5: 89 1c 24 mov %ebx,(%esp)
10a8c8: e8 12 06 00 00 call 10aedf <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10a8cd: 8d 73 1c lea 0x1c(%ebx),%esi
10a8d0: 89 34 24 mov %esi,(%esp)
10a8d3: e8 68 0d 00 00 call 10b640 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10a8d8: 89 34 24 mov %esi,(%esp)
10a8db: e8 6c 0a 00 00 call 10b34c <pthread_cond_destroy>
free (r_chain);
10a8e0: 89 1c 24 mov %ebx,(%esp)
10a8e3: e8 88 d4 ff ff call 107d70 <free>
10a8e8: eb 24 jmp 10a90e <aio_cancel+0xf6>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a8ea: 8d 70 1c lea 0x1c(%eax),%esi
10a8ed: 83 ec 0c sub $0xc,%esp
10a8f0: 56 push %esi
10a8f1: e8 6a 0f 00 00 call 10b860 <pthread_mutex_lock>
10a8f6: 89 1c 24 mov %ebx,(%esp)
10a8f9: e8 c2 26 00 00 call 10cfc0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8fe: 89 1c 24 mov %ebx,(%esp)
10a901: e8 d9 05 00 00 call 10aedf <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10a906: 89 34 24 mov %esi,(%esp)
10a909: e8 d2 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a90e: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10a915: e8 c6 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
return AIO_CANCELED;
10a91a: 83 c4 10 add $0x10,%esp
10a91d: 31 db xor %ebx,%ebx
10a91f: e9 b9 00 00 00 jmp 10a9dd <aio_cancel+0x1c5>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10a924: 8b 3b mov (%ebx),%edi
10a926: 39 f7 cmp %esi,%edi
10a928: 74 23 je 10a94d <aio_cancel+0x135>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a92a: 83 ec 0c sub $0xc,%esp
10a92d: 68 d8 72 12 00 push $0x1272d8
10a932: e8 a9 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a937: e8 ac 8d 00 00 call 1136e8 <__errno>
10a93c: c7 00 16 00 00 00 movl $0x16,(%eax)
10a942: 83 c4 10 add $0x10,%esp
10a945: 83 cb ff or $0xffffffff,%ebx
10a948: e9 90 00 00 00 jmp 10a9dd <aio_cancel+0x1c5>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a94d: 50 push %eax
10a94e: 6a 00 push $0x0
10a950: 57 push %edi
10a951: 68 20 73 12 00 push $0x127320
10a956: e8 41 02 00 00 call 10ab9c <rtems_aio_search_fd>
10a95b: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10a95d: 83 c4 10 add $0x10,%esp
10a960: 85 c0 test %eax,%eax
10a962: 75 48 jne 10a9ac <aio_cancel+0x194>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a964: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10a96b: 73 12 00
10a96e: 74 25 je 10a995 <aio_cancel+0x17d> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a970: 56 push %esi
10a971: 6a 00 push $0x0
10a973: 57 push %edi
10a974: 68 2c 73 12 00 push $0x12732c
10a979: e8 1e 02 00 00 call 10ab9c <rtems_aio_search_fd>
if (r_chain == NULL) {
10a97e: 83 c4 10 add $0x10,%esp
10a981: 85 c0 test %eax,%eax
10a983: 74 a5 je 10a92a <aio_cancel+0x112>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10a985: 51 push %ecx
10a986: 51 push %ecx
10a987: 53 push %ebx
10a988: 83 c0 08 add $0x8,%eax
10a98b: 50 push %eax
10a98c: e8 97 05 00 00 call 10af28 <rtems_aio_remove_req>
10a991: 89 c3 mov %eax,%ebx
10a993: eb 39 jmp 10a9ce <aio_cancel+0x1b6>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
10a995: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a998: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10a99d: e8 3e 0f 00 00 call 10b8e0 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a9a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a9a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a9aa: eb 31 jmp 10a9dd <aio_cancel+0x1c5> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a9ac: 8d 78 1c lea 0x1c(%eax),%edi
10a9af: 83 ec 0c sub $0xc,%esp
10a9b2: 57 push %edi
10a9b3: e8 a8 0e 00 00 call 10b860 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10a9b8: 58 pop %eax
10a9b9: 5a pop %edx
10a9ba: 53 push %ebx
10a9bb: 83 c6 08 add $0x8,%esi
10a9be: 56 push %esi
10a9bf: e8 64 05 00 00 call 10af28 <rtems_aio_remove_req>
10a9c4: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10a9c6: 89 3c 24 mov %edi,(%esp)
10a9c9: e8 12 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a9ce: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10a9d5: e8 06 0f 00 00 call 10b8e0 <pthread_mutex_unlock>
return result;
10a9da: 83 c4 10 add $0x10,%esp
}
return AIO_ALLDONE;
}
10a9dd: 89 d8 mov %ebx,%eax
10a9df: 8d 65 f4 lea -0xc(%ebp),%esp
10a9e2: 5b pop %ebx
10a9e3: 5e pop %esi
10a9e4: 5f pop %edi
10a9e5: c9 leave
10a9e6: c3 ret
0010a9f4 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a9f4: 55 push %ebp
10a9f5: 89 e5 mov %esp,%ebp
10a9f7: 53 push %ebx
10a9f8: 83 ec 04 sub $0x4,%esp
10a9fb: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a9fe: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10aa05: 74 1b je 10aa22 <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10aa07: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10aa0e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10aa15: e8 ce 8c 00 00 call 1136e8 <__errno>
10aa1a: c7 00 16 00 00 00 movl $0x16,(%eax)
10aa20: eb 74 jmp 10aa96 <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10aa22: 50 push %eax
10aa23: 50 push %eax
10aa24: 6a 03 push $0x3
10aa26: ff 33 pushl (%ebx)
10aa28: e8 ff 5e 00 00 call 11092c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10aa2d: 83 e0 03 and $0x3,%eax
10aa30: 48 dec %eax
10aa31: 83 c4 10 add $0x10,%esp
10aa34: 83 f8 01 cmp $0x1,%eax
10aa37: 76 1b jbe 10aa54 <aio_fsync+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10aa39: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10aa40: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10aa47: e8 9c 8c 00 00 call 1136e8 <__errno>
10aa4c: c7 00 09 00 00 00 movl $0x9,(%eax)
10aa52: eb 42 jmp 10aa96 <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10aa54: 83 ec 0c sub $0xc,%esp
10aa57: 6a 18 push $0x18
10aa59: e8 96 d7 ff ff call 1081f4 <malloc>
if (req == NULL)
10aa5e: 83 c4 10 add $0x10,%esp
10aa61: 85 c0 test %eax,%eax
10aa63: 75 1b jne 10aa80 <aio_fsync+0x8c> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10aa65: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10aa6c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10aa73: e8 70 8c 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10aa78: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10aa7e: eb 16 jmp 10aa96 <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa80: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa83: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10aa8a: 89 45 08 mov %eax,0x8(%ebp)
}
10aa8d: 8b 5d fc mov -0x4(%ebp),%ebx
10aa90: 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);
10aa91: e9 ef 04 00 00 jmp 10af85 <rtems_aio_enqueue>
}
10aa96: 83 c8 ff or $0xffffffff,%eax
10aa99: 8b 5d fc mov -0x4(%ebp),%ebx
10aa9c: c9 leave
10aa9d: c3 ret
0010b188 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b188: 55 push %ebp
10b189: 89 e5 mov %esp,%ebp
10b18b: 53 push %ebx
10b18c: 83 ec 0c sub $0xc,%esp
10b18f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b192: 6a 03 push $0x3
10b194: ff 33 pushl (%ebx)
10b196: e8 91 57 00 00 call 11092c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b19b: 83 e0 03 and $0x3,%eax
10b19e: 83 c4 10 add $0x10,%esp
10b1a1: 83 f8 02 cmp $0x2,%eax
10b1a4: 74 1f je 10b1c5 <aio_read+0x3d>
10b1a6: 85 c0 test %eax,%eax
10b1a8: 74 1b je 10b1c5 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1aa: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b1b1: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1b8: e8 2b 85 00 00 call 1136e8 <__errno>
10b1bd: c7 00 09 00 00 00 movl $0x9,(%eax)
10b1c3: eb 69 jmp 10b22e <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b1c5: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b1c9: 75 06 jne 10b1d1 <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b1cb: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b1cf: 79 1b jns 10b1ec <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b1d1: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b1d8: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1df: e8 04 85 00 00 call 1136e8 <__errno>
10b1e4: c7 00 16 00 00 00 movl $0x16,(%eax)
10b1ea: eb 42 jmp 10b22e <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b1ec: 83 ec 0c sub $0xc,%esp
10b1ef: 6a 18 push $0x18
10b1f1: e8 fe cf ff ff call 1081f4 <malloc>
if (req == NULL)
10b1f6: 83 c4 10 add $0x10,%esp
10b1f9: 85 c0 test %eax,%eax
10b1fb: 75 1b jne 10b218 <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b1fd: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b204: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b20b: e8 d8 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10b210: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b216: eb 16 jmp 10b22e <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b218: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b21b: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b222: 89 45 08 mov %eax,0x8(%ebp)
}
10b225: 8b 5d fc mov -0x4(%ebp),%ebx
10b228: 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);
10b229: e9 57 fd ff ff jmp 10af85 <rtems_aio_enqueue>
}
10b22e: 83 c8 ff or $0xffffffff,%eax
10b231: 8b 5d fc mov -0x4(%ebp),%ebx
10b234: c9 leave
10b235: c3 ret
0010b244 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b244: 55 push %ebp
10b245: 89 e5 mov %esp,%ebp
10b247: 53 push %ebx
10b248: 83 ec 0c sub $0xc,%esp
10b24b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b24e: 6a 03 push $0x3
10b250: ff 33 pushl (%ebx)
10b252: e8 d5 56 00 00 call 11092c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b257: 83 e0 03 and $0x3,%eax
10b25a: 48 dec %eax
10b25b: 83 c4 10 add $0x10,%esp
10b25e: 83 f8 01 cmp $0x1,%eax
10b261: 76 1b jbe 10b27e <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b263: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b26a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b271: e8 72 84 00 00 call 1136e8 <__errno>
10b276: c7 00 09 00 00 00 movl $0x9,(%eax)
10b27c: eb 69 jmp 10b2e7 <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b27e: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b282: 75 06 jne 10b28a <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b284: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b288: 79 1b jns 10b2a5 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b28a: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b291: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b298: e8 4b 84 00 00 call 1136e8 <__errno>
10b29d: c7 00 16 00 00 00 movl $0x16,(%eax)
10b2a3: eb 42 jmp 10b2e7 <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b2a5: 83 ec 0c sub $0xc,%esp
10b2a8: 6a 18 push $0x18
10b2aa: e8 45 cf ff ff call 1081f4 <malloc>
if (req == NULL)
10b2af: 83 c4 10 add $0x10,%esp
10b2b2: 85 c0 test %eax,%eax
10b2b4: 75 1b jne 10b2d1 <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b2b6: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b2bd: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b2c4: e8 1f 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10b2c9: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b2cf: eb 16 jmp 10b2e7 <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b2d1: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b2d4: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b2db: 89 45 08 mov %eax,0x8(%ebp)
}
10b2de: 8b 5d fc mov -0x4(%ebp),%ebx
10b2e1: 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);
10b2e2: e9 9e fc ff ff jmp 10af85 <rtems_aio_enqueue>
}
10b2e7: 83 c8 ff or $0xffffffff,%eax
10b2ea: 8b 5d fc mov -0x4(%ebp),%ebx
10b2ed: c9 leave
10b2ee: c3 ret
00109fec <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109fec: 55 push %ebp
109fed: 89 e5 mov %esp,%ebp
109fef: 83 ec 08 sub $0x8,%esp
109ff2: 8b 45 08 mov 0x8(%ebp),%eax
109ff5: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109ff8: 85 d2 test %edx,%edx
109ffa: 74 3c je 10a038 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109ffc: 83 f8 01 cmp $0x1,%eax
109fff: 75 0b jne 10a00c <clock_gettime+0x20>
_TOD_Get(tp);
10a001: 83 ec 0c sub $0xc,%esp
10a004: 52 push %edx
10a005: e8 a6 1b 00 00 call 10bbb0 <_TOD_Get>
10a00a: eb 13 jmp 10a01f <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
10a00c: 83 f8 04 cmp $0x4,%eax
10a00f: 74 05 je 10a016 <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
10a011: 83 f8 02 cmp $0x2,%eax
10a014: 75 10 jne 10a026 <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
10a016: 83 ec 0c sub $0xc,%esp
10a019: 52 push %edx
10a01a: e8 e5 1b 00 00 call 10bc04 <_TOD_Get_uptime_as_timespec>
return 0;
10a01f: 83 c4 10 add $0x10,%esp
10a022: 31 c0 xor %eax,%eax
10a024: eb 20 jmp 10a046 <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
10a026: 83 f8 03 cmp $0x3,%eax
10a029: 75 0d jne 10a038 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a02b: e8 9c 7f 00 00 call 111fcc <__errno>
10a030: c7 00 58 00 00 00 movl $0x58,(%eax)
10a036: eb 0b jmp 10a043 <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
10a038: e8 8f 7f 00 00 call 111fcc <__errno>
10a03d: c7 00 16 00 00 00 movl $0x16,(%eax)
10a043: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a046: c9 leave
10a047: c3 ret
0010a048 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10a048: 55 push %ebp
10a049: 89 e5 mov %esp,%ebp
10a04b: 83 ec 08 sub $0x8,%esp
10a04e: 8b 45 08 mov 0x8(%ebp),%eax
10a051: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10a054: 85 d2 test %edx,%edx
10a056: 74 44 je 10a09c <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a058: 83 f8 01 cmp $0x1,%eax
10a05b: 75 28 jne 10a085 <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a05d: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a063: 76 37 jbe 10a09c <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a065: a1 a0 73 12 00 mov 0x1273a0,%eax
10a06a: 40 inc %eax
10a06b: a3 a0 73 12 00 mov %eax,0x1273a0
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a070: 83 ec 0c sub $0xc,%esp
10a073: 52 push %edx
10a074: e8 e3 1b 00 00 call 10bc5c <_TOD_Set>
_Thread_Enable_dispatch();
10a079: e8 38 2f 00 00 call 10cfb6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a07e: 83 c4 10 add $0x10,%esp
10a081: 31 c0 xor %eax,%eax
10a083: eb 25 jmp 10a0aa <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a085: 83 f8 02 cmp $0x2,%eax
10a088: 74 05 je 10a08f <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a08a: 83 f8 03 cmp $0x3,%eax
10a08d: 75 0d jne 10a09c <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a08f: e8 38 7f 00 00 call 111fcc <__errno>
10a094: c7 00 58 00 00 00 movl $0x58,(%eax)
10a09a: eb 0b jmp 10a0a7 <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a09c: e8 2b 7f 00 00 call 111fcc <__errno>
10a0a1: c7 00 16 00 00 00 movl $0x16,(%eax)
10a0a7: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a0aa: c9 leave
10a0ab: c3 ret
00121f58 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
121f58: 55 push %ebp
121f59: 89 e5 mov %esp,%ebp
121f5b: 57 push %edi
121f5c: 56 push %esi
121f5d: 53 push %ebx
121f5e: 83 ec 4c sub $0x4c,%esp
121f61: 8b 5d 0c mov 0xc(%ebp),%ebx
121f64: 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() )
121f67: e8 64 fd ff ff call 121cd0 <getpid>
121f6c: 39 45 08 cmp %eax,0x8(%ebp)
121f6f: 74 0d je 121f7e <killinfo+0x26> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
121f71: e8 5a 3a ff ff call 1159d0 <__errno> <== NOT EXECUTED
121f76: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED
121f7c: eb 0f jmp 121f8d <killinfo+0x35> <== NOT EXECUTED
/*
* Validate the signal passed.
*/
if ( !sig )
121f7e: 85 db test %ebx,%ebx
121f80: 75 13 jne 121f95 <killinfo+0x3d> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
121f82: e8 49 3a ff ff call 1159d0 <__errno> <== NOT EXECUTED
121f87: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
121f8d: 83 c8 ff or $0xffffffff,%eax
121f90: e9 ef 01 00 00 jmp 122184 <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
121f95: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121f98: 83 f9 1f cmp $0x1f,%ecx
121f9b: 77 e5 ja 121f82 <killinfo+0x2a> <== NEVER TAKEN
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 )
121f9d: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
121fa0: 31 c0 xor %eax,%eax
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
121fa2: 83 ba 18 ba 12 00 01 cmpl $0x1,0x12ba18(%edx)
121fa9: 0f 84 d5 01 00 00 je 122184 <killinfo+0x22c>
/*
* 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 ) )
121faf: 83 fb 04 cmp $0x4,%ebx
121fb2: 74 0a je 121fbe <killinfo+0x66>
121fb4: 83 fb 08 cmp $0x8,%ebx
121fb7: 74 05 je 121fbe <killinfo+0x66>
121fb9: 83 fb 0b cmp $0xb,%ebx
121fbc: 75 16 jne 121fd4 <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
121fbe: e8 85 03 00 00 call 122348 <pthread_self>
121fc3: 56 push %esi
121fc4: 56 push %esi
121fc5: 53 push %ebx
121fc6: 50 push %eax
121fc7: e8 d8 02 00 00 call 1222a4 <pthread_kill>
121fcc: 83 c4 10 add $0x10,%esp
121fcf: e9 b0 01 00 00 jmp 122184 <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
121fd4: be 01 00 00 00 mov $0x1,%esi
121fd9: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
121fdb: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
121fde: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
121fe5: 85 ff test %edi,%edi
121fe7: 75 09 jne 121ff2 <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
121fe9: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
121ff0: eb 05 jmp 121ff7 <killinfo+0x9f>
} else {
siginfo->si_value = *value;
121ff2: 8b 07 mov (%edi),%eax
121ff4: 89 45 e4 mov %eax,-0x1c(%ebp)
121ff7: a1 b4 b4 12 00 mov 0x12b4b4,%eax
121ffc: 40 inc %eax
121ffd: a3 b4 b4 12 00 mov %eax,0x12b4b4
/*
* 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;
122002: a1 dc b9 12 00 mov 0x12b9dc,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
122007: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
12200d: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
122013: f7 d2 not %edx
122015: 85 d6 test %edx,%esi
122017: 0f 85 ed 00 00 00 jne 12210a <killinfo+0x1b2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
12201d: 8b 15 9c bb 12 00 mov 0x12bb9c,%edx
/* 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 );
122023: eb 23 jmp 122048 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
122025: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
122027: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
12202d: 85 72 30 test %esi,0x30(%edx)
122030: 0f 85 d4 00 00 00 jne 12210a <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
122036: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
12203c: f7 d1 not %ecx
12203e: 85 ce test %ecx,%esi
122040: 0f 85 c4 00 00 00 jne 12210a <killinfo+0x1b2>
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 ) {
122046: 8b 12 mov (%edx),%edx
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
122048: 81 fa a0 bb 12 00 cmp $0x12bba0,%edx
12204e: 75 d5 jne 122025 <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
122050: 0f b6 0d 24 72 12 00 movzbl 0x127224,%ecx
122057: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
122058: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
12205a: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp)
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
122061: 8b 7d cc mov -0x34(%ebp),%edi
122064: 8b 14 bd 8c b4 12 00 mov 0x12b48c(,%edi,4),%edx
12206b: 85 d2 test %edx,%edx
12206d: 0f 84 86 00 00 00 je 1220f9 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
122073: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
122076: 0f b7 7a 10 movzwl 0x10(%edx),%edi
12207a: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
12207d: 8b 52 1c mov 0x1c(%edx),%edx
122080: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
122083: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
12208a: 89 5d b4 mov %ebx,-0x4c(%ebp)
12208d: eb 5f jmp 1220ee <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
12208f: 8b 5d d0 mov -0x30(%ebp),%ebx
122092: 8b 7d c0 mov -0x40(%ebp),%edi
122095: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
122098: 85 d2 test %edx,%edx
12209a: 74 4f je 1220eb <killinfo+0x193>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
12209c: 8b 5a 14 mov 0x14(%edx),%ebx
12209f: 89 5d d4 mov %ebx,-0x2c(%ebp)
1220a2: 39 cb cmp %ecx,%ebx
1220a4: 77 45 ja 1220eb <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
1220a6: 8b ba ec 00 00 00 mov 0xec(%edx),%edi
1220ac: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
1220b2: f7 d7 not %edi
1220b4: 85 fe test %edi,%esi
1220b6: 74 33 je 1220eb <killinfo+0x193>
*
* 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 ) {
1220b8: 39 cb cmp %ecx,%ebx
1220ba: 72 2a jb 1220e6 <killinfo+0x18e>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
1220bc: 85 c0 test %eax,%eax
1220be: 74 2b je 1220eb <killinfo+0x193> <== NEVER TAKEN
1220c0: 8b 78 10 mov 0x10(%eax),%edi
1220c3: 89 7d c8 mov %edi,-0x38(%ebp)
1220c6: 85 ff test %edi,%edi
1220c8: 74 21 je 1220eb <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
1220ca: 8b 7a 10 mov 0x10(%edx),%edi
1220cd: 85 ff test %edi,%edi
1220cf: 74 15 je 1220e6 <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
1220d1: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
1220d8: 75 11 jne 1220eb <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
1220da: 81 e7 00 00 00 10 and $0x10000000,%edi
1220e0: 74 09 je 1220eb <killinfo+0x193>
1220e2: 89 d9 mov %ebx,%ecx
1220e4: eb 03 jmp 1220e9 <killinfo+0x191>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
1220e6: 8b 4d d4 mov -0x2c(%ebp),%ecx
1220e9: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
1220eb: ff 45 d0 incl -0x30(%ebp)
1220ee: 8b 55 c4 mov -0x3c(%ebp),%edx
1220f1: 39 55 d0 cmp %edx,-0x30(%ebp)
1220f4: 76 99 jbe 12208f <killinfo+0x137>
1220f6: 8b 5d b4 mov -0x4c(%ebp),%ebx
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
1220f9: ff 45 cc incl -0x34(%ebp)
1220fc: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
122100: 0f 85 5b ff ff ff jne 122061 <killinfo+0x109>
}
}
}
}
if ( interested ) {
122106: 85 c0 test %eax,%eax
122108: 74 13 je 12211d <killinfo+0x1c5>
/*
* 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 ) ) {
12210a: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
12210b: 8d 55 dc lea -0x24(%ebp),%edx
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
12210e: 52 push %edx
12210f: 53 push %ebx
122110: 50 push %eax
122111: e8 8a 00 00 00 call 1221a0 <_POSIX_signals_Unblock_thread>
122116: 83 c4 10 add $0x10,%esp
122119: 84 c0 test %al,%al
12211b: 75 60 jne 12217d <killinfo+0x225>
/*
* 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 );
12211d: 83 ec 0c sub $0xc,%esp
122120: 56 push %esi
122121: e8 66 00 00 00 call 12218c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
122126: 6b db 0c imul $0xc,%ebx,%ebx
122129: 83 c4 10 add $0x10,%esp
12212c: 83 bb 10 ba 12 00 02 cmpl $0x2,0x12ba10(%ebx)
122133: 75 48 jne 12217d <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
122135: 83 ec 0c sub $0xc,%esp
122138: 68 90 bb 12 00 push $0x12bb90
12213d: e8 4e d0 fe ff call 10f190 <_Chain_Get>
if ( !psiginfo ) {
122142: 83 c4 10 add $0x10,%esp
122145: 85 c0 test %eax,%eax
122147: 75 15 jne 12215e <killinfo+0x206>
_Thread_Enable_dispatch();
122149: e8 6c e8 fe ff call 1109ba <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
12214e: e8 7d 38 ff ff call 1159d0 <__errno>
122153: c7 00 0b 00 00 00 movl $0xb,(%eax)
122159: e9 2f fe ff ff jmp 121f8d <killinfo+0x35>
}
psiginfo->Info = *siginfo;
12215e: 8d 78 08 lea 0x8(%eax),%edi
122161: 8d 75 dc lea -0x24(%ebp),%esi
122164: b9 03 00 00 00 mov $0x3,%ecx
122169: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
12216b: 52 push %edx
12216c: 52 push %edx
12216d: 50 push %eax
12216e: 81 c3 08 bc 12 00 add $0x12bc08,%ebx
122174: 53 push %ebx
122175: e8 da cf fe ff call 10f154 <_Chain_Append>
12217a: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
12217d: e8 38 e8 fe ff call 1109ba <_Thread_Enable_dispatch>
return 0;
122182: 31 c0 xor %eax,%eax
}
122184: 8d 65 f4 lea -0xc(%ebp),%esp
122187: 5b pop %ebx
122188: 5e pop %esi
122189: 5f pop %edi
12218a: c9 leave
12218b: c3 ret
0010efd8 <pthread_attr_getdetachstate>:
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
10efd8: 55 push %ebp
10efd9: 89 e5 mov %esp,%ebp
10efdb: 8b 55 08 mov 0x8(%ebp),%edx
10efde: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
10efe1: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
10efe6: 85 d2 test %edx,%edx
10efe8: 74 17 je 10f001 <pthread_attr_getdetachstate+0x29><== NEVER TAKEN
10efea: 85 c9 test %ecx,%ecx
10efec: 74 0e je 10effc <pthread_attr_getdetachstate+0x24>
10efee: 83 3a 00 cmpl $0x0,(%edx)
10eff1: 74 09 je 10effc <pthread_attr_getdetachstate+0x24>
return EINVAL;
*detachstate = attr->detachstate;
10eff3: 8b 42 3c mov 0x3c(%edx),%eax
10eff6: 89 01 mov %eax,(%ecx)
return 0;
10eff8: 31 c0 xor %eax,%eax
10effa: eb 05 jmp 10f001 <pthread_attr_getdetachstate+0x29>
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
10effc: b8 16 00 00 00 mov $0x16,%eax
*detachstate = attr->detachstate;
return 0;
}
10f001: c9 leave
10f002: c3 ret
0010f24c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f24c: 55 push %ebp
10f24d: 89 e5 mov %esp,%ebp
10f24f: 8b 55 08 mov 0x8(%ebp),%edx
10f252: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f255: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f25a: 85 d2 test %edx,%edx
10f25c: 74 1e je 10f27c <pthread_attr_setschedpolicy+0x30>
10f25e: 83 3a 00 cmpl $0x0,(%edx)
10f261: 74 19 je 10f27c <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f263: 83 f9 04 cmp $0x4,%ecx
10f266: 77 0f ja 10f277 <pthread_attr_setschedpolicy+0x2b>
10f268: b0 01 mov $0x1,%al
10f26a: d3 e0 shl %cl,%eax
10f26c: a8 17 test $0x17,%al
10f26e: 74 07 je 10f277 <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f270: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f273: 31 c0 xor %eax,%eax
10f275: eb 05 jmp 10f27c <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f277: b8 86 00 00 00 mov $0x86,%eax
}
}
10f27c: c9 leave
10f27d: c3 ret
0010a56c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a56c: 55 push %ebp
10a56d: 89 e5 mov %esp,%ebp
10a56f: 57 push %edi
10a570: 56 push %esi
10a571: 53 push %ebx
10a572: 83 ec 1c sub $0x1c,%esp
10a575: 8b 5d 08 mov 0x8(%ebp),%ebx
10a578: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a57b: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a580: 85 db test %ebx,%ebx
10a582: 0f 84 96 00 00 00 je 10a61e <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a588: 85 f6 test %esi,%esi
10a58a: 0f 84 8e 00 00 00 je 10a61e <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a590: 8b 7d 0c mov 0xc(%ebp),%edi
10a593: 85 ff test %edi,%edi
10a595: 75 0f jne 10a5a6 <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a597: 83 ec 0c sub $0xc,%esp
10a59a: 8d 7d d8 lea -0x28(%ebp),%edi
10a59d: 57 push %edi
10a59e: e8 19 ff ff ff call 10a4bc <pthread_barrierattr_init>
10a5a3: 83 c4 10 add $0x10,%esp
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
10a5a6: b8 16 00 00 00 mov $0x16,%eax
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10a5ab: 83 3f 00 cmpl $0x0,(%edi)
10a5ae: 74 6e je 10a61e <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a5b0: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a5b4: 75 68 jne 10a61e <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a5b6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a5bd: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a5c0: a1 50 63 12 00 mov 0x126350,%eax
10a5c5: 40 inc %eax
10a5c6: a3 50 63 12 00 mov %eax,0x126350
* 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 );
10a5cb: 83 ec 0c sub $0xc,%esp
10a5ce: 68 f4 66 12 00 push $0x1266f4
10a5d3: e8 0c 1e 00 00 call 10c3e4 <_Objects_Allocate>
10a5d8: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a5da: 83 c4 10 add $0x10,%esp
10a5dd: 85 c0 test %eax,%eax
10a5df: 75 0c jne 10a5ed <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a5e1: e8 dc 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch>
return EAGAIN;
10a5e6: b8 0b 00 00 00 mov $0xb,%eax
10a5eb: eb 31 jmp 10a61e <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a5ed: 50 push %eax
10a5ee: 50 push %eax
10a5ef: 8d 45 e0 lea -0x20(%ebp),%eax
10a5f2: 50 push %eax
10a5f3: 8d 46 10 lea 0x10(%esi),%eax
10a5f6: 50 push %eax
10a5f7: e8 a8 14 00 00 call 10baa4 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5fc: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5ff: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a602: 8b 15 10 67 12 00 mov 0x126710,%edx
10a608: 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;
10a60b: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
10a612: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a614: e8 a9 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch>
return 0;
10a619: 83 c4 10 add $0x10,%esp
10a61c: 31 c0 xor %eax,%eax
}
10a61e: 8d 65 f4 lea -0xc(%ebp),%esp
10a621: 5b pop %ebx
10a622: 5e pop %esi
10a623: 5f pop %edi
10a624: c9 leave
10a625: c3 ret
00109f20 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109f20: 55 push %ebp
109f21: 89 e5 mov %esp,%ebp
109f23: 56 push %esi
109f24: 53 push %ebx
109f25: 8b 5d 08 mov 0x8(%ebp),%ebx
109f28: 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 )
109f2b: 85 db test %ebx,%ebx
109f2d: 74 4b je 109f7a <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109f2f: a1 48 63 12 00 mov 0x126348,%eax
109f34: 40 inc %eax
109f35: a3 48 63 12 00 mov %eax,0x126348
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109f3a: 83 ec 0c sub $0xc,%esp
109f3d: 6a 10 push $0x10
109f3f: e8 3e 3c 00 00 call 10db82 <_Workspace_Allocate>
if ( handler ) {
109f44: 83 c4 10 add $0x10,%esp
109f47: 85 c0 test %eax,%eax
109f49: 74 24 je 109f6f <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109f4b: 8b 15 70 68 12 00 mov 0x126870,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109f51: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx
109f57: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f5d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f60: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f63: 51 push %ecx
109f64: 51 push %ecx
109f65: 50 push %eax
109f66: 52 push %edx
109f67: e8 84 15 00 00 call 10b4f0 <_Chain_Append>
109f6c: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f6f: 8d 65 f8 lea -0x8(%ebp),%esp
109f72: 5b pop %ebx
109f73: 5e pop %esi
109f74: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f75: e9 3c 2d 00 00 jmp 10ccb6 <_Thread_Enable_dispatch>
}
109f7a: 8d 65 f8 lea -0x8(%ebp),%esp
109f7d: 5b pop %ebx
109f7e: 5e pop %esi
109f7f: c9 leave
109f80: c3 ret
0010ac94 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac94: 55 push %ebp
10ac95: 89 e5 mov %esp,%ebp
10ac97: 56 push %esi
10ac98: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac99: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac9c: 85 db test %ebx,%ebx
10ac9e: 75 05 jne 10aca5 <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10aca0: bb b4 15 12 00 mov $0x1215b4,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10aca5: b8 16 00 00 00 mov $0x16,%eax
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10acaa: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10acae: 74 76 je 10ad26 <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10acb0: 83 3b 00 cmpl $0x0,(%ebx)
10acb3: 74 71 je 10ad26 <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10acb5: a1 60 73 12 00 mov 0x127360,%eax
10acba: 40 inc %eax
10acbb: a3 60 73 12 00 mov %eax,0x127360
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10acc0: 83 ec 0c sub $0xc,%esp
10acc3: 68 9c 77 12 00 push $0x12779c
10acc8: e8 f7 22 00 00 call 10cfc4 <_Objects_Allocate>
10accd: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10accf: 83 c4 10 add $0x10,%esp
10acd2: 85 c0 test %eax,%eax
10acd4: 75 0c jne 10ace2 <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10acd6: e8 c7 31 00 00 call 10dea2 <_Thread_Enable_dispatch>
return ENOMEM;
10acdb: b8 0c 00 00 00 mov $0xc,%eax
10ace0: eb 44 jmp 10ad26 <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ace2: 8b 43 04 mov 0x4(%ebx),%eax
10ace5: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ace8: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10acef: 6a 74 push $0x74
10acf1: 68 00 08 00 10 push $0x10000800
10acf6: 6a 00 push $0x0
10acf8: 8d 46 18 lea 0x18(%esi),%eax
10acfb: 50 push %eax
10acfc: e8 5f 38 00 00 call 10e560 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10ad01: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ad04: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ad07: 8b 15 b8 77 12 00 mov 0x1277b8,%edx
10ad0d: 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;
10ad10: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10ad17: 8b 55 08 mov 0x8(%ebp),%edx
10ad1a: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10ad1c: e8 81 31 00 00 call 10dea2 <_Thread_Enable_dispatch>
return 0;
10ad21: 83 c4 10 add $0x10,%esp
10ad24: 31 c0 xor %eax,%eax
}
10ad26: 8d 65 f8 lea -0x8(%ebp),%esp
10ad29: 5b pop %ebx
10ad2a: 5e pop %esi
10ad2b: c9 leave
10ad2c: c3 ret
0010ab48 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10ab48: 55 push %ebp
10ab49: 89 e5 mov %esp,%ebp
10ab4b: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10ab4e: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10ab53: 85 d2 test %edx,%edx
10ab55: 74 0d je 10ab64 <pthread_condattr_destroy+0x1c>
10ab57: 83 3a 00 cmpl $0x0,(%edx)
10ab5a: 74 08 je 10ab64 <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab5c: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab62: 30 c0 xor %al,%al
}
10ab64: c9 leave
10ab65: c3 ret
0010a27c <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a27c: 55 push %ebp
10a27d: 89 e5 mov %esp,%ebp
10a27f: 57 push %edi
10a280: 56 push %esi
10a281: 53 push %ebx
10a282: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a285: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10a28c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a290: 0f 84 0f 02 00 00 je 10a4a5 <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a296: 8b 5d 0c mov 0xc(%ebp),%ebx
10a299: 85 db test %ebx,%ebx
10a29b: 75 05 jne 10a2a2 <pthread_create+0x26>
10a29d: bb 40 02 12 00 mov $0x120240,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a2a2: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
10a2a9: 83 3b 00 cmpl $0x0,(%ebx)
10a2ac: 0f 84 f3 01 00 00 je 10a4a5 <pthread_create+0x229>
* 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) )
10a2b2: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a2b6: 74 0e je 10a2c6 <pthread_create+0x4a>
10a2b8: a1 44 22 12 00 mov 0x122244,%eax
10a2bd: 39 43 08 cmp %eax,0x8(%ebx)
10a2c0: 0f 82 df 01 00 00 jb 10a4a5 <pthread_create+0x229>
* 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 ) {
10a2c6: 8b 43 10 mov 0x10(%ebx),%eax
10a2c9: 83 f8 01 cmp $0x1,%eax
10a2cc: 74 0b je 10a2d9 <pthread_create+0x5d>
10a2ce: 83 f8 02 cmp $0x2,%eax
10a2d1: 0f 85 c7 01 00 00 jne 10a49e <pthread_create+0x222>
10a2d7: eb 1f jmp 10a2f8 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a2d9: a1 78 68 12 00 mov 0x126878,%eax
10a2de: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10a2e4: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a2ea: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a2ed: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2f0: 81 c6 88 00 00 00 add $0x88,%esi
10a2f6: eb 0c jmp 10a304 <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2f8: 8b 43 14 mov 0x14(%ebx),%eax
10a2fb: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2fe: 8d 7d c4 lea -0x3c(%ebp),%edi
10a301: 8d 73 18 lea 0x18(%ebx),%esi
10a304: b9 07 00 00 00 mov $0x7,%ecx
10a309: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
10a30b: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10a312: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a316: 0f 85 89 01 00 00 jne 10a4a5 <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a31c: 83 ec 0c sub $0xc,%esp
10a31f: ff 75 c4 pushl -0x3c(%ebp)
10a322: e8 2d 59 00 00 call 10fc54 <_POSIX_Priority_Is_valid>
10a327: 83 c4 10 add $0x10,%esp
return EINVAL;
10a32a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a331: 84 c0 test %al,%al
10a333: 0f 84 6c 01 00 00 je 10a4a5 <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a339: 8b 45 c4 mov -0x3c(%ebp),%eax
10a33c: 89 45 a8 mov %eax,-0x58(%ebp)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10a33f: 0f b6 3d 48 22 12 00 movzbl 0x122248,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a346: 8d 45 e0 lea -0x20(%ebp),%eax
10a349: 50 push %eax
10a34a: 8d 45 e4 lea -0x1c(%ebp),%eax
10a34d: 50 push %eax
10a34e: 8d 45 c4 lea -0x3c(%ebp),%eax
10a351: 50 push %eax
10a352: ff 75 ac pushl -0x54(%ebp)
10a355: e8 1a 59 00 00 call 10fc74 <_POSIX_Thread_Translate_sched_param>
10a35a: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a35d: 83 c4 10 add $0x10,%esp
10a360: 85 c0 test %eax,%eax
10a362: 0f 85 3d 01 00 00 jne 10a4a5 <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a368: 83 ec 0c sub $0xc,%esp
10a36b: ff 35 f4 63 12 00 pushl 0x1263f4
10a371: e8 4e 15 00 00 call 10b8c4 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a376: c7 04 24 74 65 12 00 movl $0x126574,(%esp)
10a37d: e8 a2 1e 00 00 call 10c224 <_Objects_Allocate>
10a382: 89 45 b0 mov %eax,-0x50(%ebp)
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
10a385: 83 c4 10 add $0x10,%esp
10a388: 85 c0 test %eax,%eax
10a38a: 75 05 jne 10a391 <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a38c: 83 ec 0c sub $0xc,%esp
10a38f: eb 53 jmp 10a3e4 <pthread_create+0x168>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
10a391: 8b 4d e0 mov -0x20(%ebp),%ecx
10a394: 8b 75 e4 mov -0x1c(%ebp),%esi
10a397: 8b 53 08 mov 0x8(%ebx),%edx
10a39a: a1 44 22 12 00 mov 0x122244,%eax
10a39f: d1 e0 shl %eax
10a3a1: 39 d0 cmp %edx,%eax
10a3a3: 73 02 jae 10a3a7 <pthread_create+0x12b>
10a3a5: 89 d0 mov %edx,%eax
10a3a7: 52 push %edx
10a3a8: 6a 00 push $0x0
10a3aa: 6a 00 push $0x0
10a3ac: 51 push %ecx
10a3ad: 56 push %esi
10a3ae: 6a 01 push $0x1
10a3b0: 81 e7 ff 00 00 00 and $0xff,%edi
10a3b6: 2b 7d a8 sub -0x58(%ebp),%edi
10a3b9: 57 push %edi
10a3ba: 6a 01 push $0x1
10a3bc: 50 push %eax
10a3bd: ff 73 04 pushl 0x4(%ebx)
10a3c0: ff 75 b0 pushl -0x50(%ebp)
10a3c3: 68 74 65 12 00 push $0x126574
10a3c8: e8 cb 2d 00 00 call 10d198 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a3cd: 83 c4 30 add $0x30,%esp
10a3d0: 84 c0 test %al,%al
10a3d2: 75 2a jne 10a3fe <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a3d4: 56 push %esi
10a3d5: 56 push %esi
10a3d6: ff 75 b0 pushl -0x50(%ebp)
10a3d9: 68 74 65 12 00 push $0x126574
10a3de: e8 35 21 00 00 call 10c518 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a3e3: 5b pop %ebx
10a3e4: ff 35 f4 63 12 00 pushl 0x1263f4
10a3ea: e8 1d 15 00 00 call 10b90c <_API_Mutex_Unlock>
return EAGAIN;
10a3ef: 83 c4 10 add $0x10,%esp
10a3f2: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3f9: e9 a7 00 00 00 jmp 10a4a5 <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3fe: 8b 45 b0 mov -0x50(%ebp),%eax
10a401: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
api->Attributes = *the_attr;
10a407: b9 10 00 00 00 mov $0x10,%ecx
10a40c: 89 d7 mov %edx,%edi
10a40e: 89 de mov %ebx,%esi
10a410: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a412: 8b 43 3c mov 0x3c(%ebx),%eax
10a415: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a418: 8b 45 ac mov -0x54(%ebp),%eax
10a41b: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a421: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a427: 8d 75 c4 lea -0x3c(%ebp),%esi
10a42a: b1 07 mov $0x7,%cl
10a42c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a42e: 83 ec 0c sub $0xc,%esp
10a431: 6a 00 push $0x0
10a433: ff 75 14 pushl 0x14(%ebp)
10a436: ff 75 10 pushl 0x10(%ebp)
10a439: 6a 01 push $0x1
10a43b: ff 75 b0 pushl -0x50(%ebp)
10a43e: 89 55 a4 mov %edx,-0x5c(%ebp)
10a441: e8 72 35 00 00 call 10d9b8 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a446: 83 c4 20 add $0x20,%esp
10a449: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a44d: 8b 55 a4 mov -0x5c(%ebp),%edx
10a450: 75 2e jne 10a480 <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a452: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a455: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a45b: 50 push %eax
10a45c: e8 a7 36 00 00 call 10db08 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a461: 8b 55 a4 mov -0x5c(%ebp),%edx
10a464: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a46a: 58 pop %eax
10a46b: 59 pop %ecx
10a46c: 81 c2 a8 00 00 00 add $0xa8,%edx
10a472: 52 push %edx
10a473: 68 14 64 12 00 push $0x126414
10a478: e8 3f 39 00 00 call 10ddbc <_Watchdog_Insert>
10a47d: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a480: 8b 45 b0 mov -0x50(%ebp),%eax
10a483: 8b 50 08 mov 0x8(%eax),%edx
10a486: 8b 45 08 mov 0x8(%ebp),%eax
10a489: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a48b: 83 ec 0c sub $0xc,%esp
10a48e: ff 35 f4 63 12 00 pushl 0x1263f4
10a494: e8 73 14 00 00 call 10b90c <_API_Mutex_Unlock>
return 0;
10a499: 83 c4 10 add $0x10,%esp
10a49c: eb 07 jmp 10a4a5 <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a49e: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a4a5: 8b 45 b4 mov -0x4c(%ebp),%eax
10a4a8: 8d 65 f4 lea -0xc(%ebp),%esp
10a4ab: 5b pop %ebx
10a4ac: 5e pop %esi
10a4ad: 5f pop %edi
10a4ae: c9 leave
10a4af: c3 ret
00110d4c <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110d4c: 55 push %ebp
110d4d: 89 e5 mov %esp,%ebp
110d4f: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110d52: ff 75 08 pushl 0x8(%ebp)
110d55: ff 35 68 58 12 00 pushl 0x125868
110d5b: e8 88 ff ff ff call 110ce8 <_POSIX_Thread_Exit>
110d60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110d63: c9 leave <== NOT EXECUTED
110d64: c3 ret <== NOT EXECUTED
001222a4 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
1222a4: 55 push %ebp
1222a5: 89 e5 mov %esp,%ebp
1222a7: 57 push %edi
1222a8: 56 push %esi
1222a9: 53 push %ebx
1222aa: 83 ec 1c sub $0x1c,%esp
1222ad: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
1222b0: 85 db test %ebx,%ebx
1222b2: 74 08 je 1222bc <pthread_kill+0x18> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
1222b4: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
1222b7: 83 ff 1f cmp $0x1f,%edi
1222ba: 76 0d jbe 1222c9 <pthread_kill+0x25>
rtems_set_errno_and_return_minus_one( EINVAL );
1222bc: e8 0f 37 ff ff call 1159d0 <__errno>
1222c1: c7 00 16 00 00 00 movl $0x16,(%eax)
1222c7: eb 73 jmp 12233c <pthread_kill+0x98>
the_thread = _Thread_Get( thread, &location );
1222c9: 52 push %edx
1222ca: 52 push %edx
1222cb: 8d 45 e4 lea -0x1c(%ebp),%eax
1222ce: 50 push %eax
1222cf: ff 75 08 pushl 0x8(%ebp)
1222d2: e8 05 e7 fe ff call 1109dc <_Thread_Get>
1222d7: 89 c6 mov %eax,%esi
switch ( location ) {
1222d9: 83 c4 10 add $0x10,%esp
1222dc: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
1222e0: 75 4f jne 122331 <pthread_kill+0x8d> <== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1222e2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
1222e8: 6b c3 0c imul $0xc,%ebx,%eax
1222eb: 83 b8 18 ba 12 00 01 cmpl $0x1,0x12ba18(%eax)
1222f2: 74 34 je 122328 <pthread_kill+0x84> <== NEVER TAKEN
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
1222f4: b8 01 00 00 00 mov $0x1,%eax
1222f9: 89 f9 mov %edi,%ecx
1222fb: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
1222fd: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
122303: 50 push %eax
122304: 6a 00 push $0x0
122306: 53 push %ebx
122307: 56 push %esi
122308: e8 93 fe ff ff call 1221a0 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
12230d: 83 c4 10 add $0x10,%esp
122310: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8
122317: 74 0f je 122328 <pthread_kill+0x84>
122319: 3b 35 dc b9 12 00 cmp 0x12b9dc,%esi
12231f: 75 07 jne 122328 <pthread_kill+0x84>
_Thread_Dispatch_necessary = true;
122321: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8
}
_Thread_Enable_dispatch();
122328: e8 8d e6 fe ff call 1109ba <_Thread_Enable_dispatch>
return 0;
12232d: 31 c0 xor %eax,%eax
12232f: eb 0e jmp 12233f <pthread_kill+0x9b>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
122331: e8 9a 36 ff ff call 1159d0 <__errno> <== NOT EXECUTED
122336: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED
12233c: 83 c8 ff or $0xffffffff,%eax
}
12233f: 8d 65 f4 lea -0xc(%ebp),%esp
122342: 5b pop %ebx
122343: 5e pop %esi
122344: 5f pop %edi
122345: c9 leave
122346: c3 ret
0010bf78 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf78: 55 push %ebp
10bf79: 89 e5 mov %esp,%ebp
10bf7b: 53 push %ebx
10bf7c: 83 ec 2c sub $0x2c,%esp
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10bf7f: 8d 45 f4 lea -0xc(%ebp),%eax
10bf82: 50 push %eax
10bf83: ff 75 0c pushl 0xc(%ebp)
10bf86: e8 b9 00 00 00 call 10c044 <_POSIX_Absolute_timeout_to_ticks>
10bf8b: 89 c3 mov %eax,%ebx
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
10bf8d: 83 c4 0c add $0xc,%esp
10bf90: 83 f8 03 cmp $0x3,%eax
10bf93: 0f 94 c2 sete %dl
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10bf96: ff 75 f4 pushl -0xc(%ebp)
10bf99: 0f b6 c2 movzbl %dl,%eax
10bf9c: 50 push %eax
10bf9d: ff 75 08 pushl 0x8(%ebp)
10bfa0: 88 55 e4 mov %dl,-0x1c(%ebp)
10bfa3: e8 e8 fe ff ff call 10be90 <_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) ) {
10bfa8: 83 c4 10 add $0x10,%esp
10bfab: 8a 55 e4 mov -0x1c(%ebp),%dl
10bfae: 84 d2 test %dl,%dl
10bfb0: 75 1d jne 10bfcf <pthread_mutex_timedlock+0x57>
10bfb2: 83 f8 10 cmp $0x10,%eax
10bfb5: 75 18 jne 10bfcf <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bfb7: 85 db test %ebx,%ebx
10bfb9: 74 08 je 10bfc3 <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bfbb: 4b dec %ebx
10bfbc: 83 fb 01 cmp $0x1,%ebx
10bfbf: 77 0e ja 10bfcf <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bfc1: eb 07 jmp 10bfca <pthread_mutex_timedlock+0x52>
* 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;
10bfc3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bfc8: eb 05 jmp 10bfcf <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bfca: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bfcf: 8b 5d fc mov -0x4(%ebp),%ebx
10bfd2: c9 leave
10bfd3: c3 ret
0010bbf0 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bbf0: 55 push %ebp
10bbf1: 89 e5 mov %esp,%ebp
10bbf3: 8b 55 08 mov 0x8(%ebp),%edx
10bbf6: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bbf9: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbfe: 85 d2 test %edx,%edx
10bc00: 74 0f je 10bc11 <pthread_mutexattr_setpshared+0x21>
10bc02: 83 3a 00 cmpl $0x0,(%edx)
10bc05: 74 0a je 10bc11 <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bc07: 83 f9 01 cmp $0x1,%ecx
10bc0a: 77 05 ja 10bc11 <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bc0c: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bc0f: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bc11: c9 leave
10bc12: c3 ret
00109e18 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109e18: 55 push %ebp
109e19: 89 e5 mov %esp,%ebp
109e1b: 8b 55 08 mov 0x8(%ebp),%edx
109e1e: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109e21: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109e26: 85 d2 test %edx,%edx
109e28: 74 0f je 109e39 <pthread_mutexattr_settype+0x21>
109e2a: 83 3a 00 cmpl $0x0,(%edx)
109e2d: 74 0a je 109e39 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109e2f: 83 f9 03 cmp $0x3,%ecx
109e32: 77 05 ja 109e39 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109e34: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109e37: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109e39: c9 leave
109e3a: c3 ret
0010a8c8 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a8c8: 55 push %ebp
10a8c9: 89 e5 mov %esp,%ebp
10a8cb: 56 push %esi
10a8cc: 53 push %ebx
10a8cd: 83 ec 10 sub $0x10,%esp
10a8d0: 8b 5d 08 mov 0x8(%ebp),%ebx
10a8d3: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a8d6: 85 f6 test %esi,%esi
10a8d8: 74 51 je 10a92b <pthread_once+0x63>
10a8da: 85 db test %ebx,%ebx
10a8dc: 74 4d je 10a92b <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a8de: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a8e0: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8e4: 75 4a jne 10a930 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a8e6: 52 push %edx
10a8e7: 8d 45 f4 lea -0xc(%ebp),%eax
10a8ea: 50 push %eax
10a8eb: 68 00 01 00 00 push $0x100
10a8f0: 68 00 01 00 00 push $0x100
10a8f5: e8 9e 0a 00 00 call 10b398 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8fa: 83 c4 10 add $0x10,%esp
10a8fd: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a901: 75 0f jne 10a912 <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a903: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a909: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a910: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a912: 50 push %eax
10a913: 8d 45 f4 lea -0xc(%ebp),%eax
10a916: 50 push %eax
10a917: 68 00 01 00 00 push $0x100
10a91c: ff 75 f4 pushl -0xc(%ebp)
10a91f: e8 74 0a 00 00 call 10b398 <rtems_task_mode>
10a924: 83 c4 10 add $0x10,%esp
}
return 0;
10a927: 31 c0 xor %eax,%eax
10a929: eb 05 jmp 10a930 <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a92b: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a930: 8d 65 f8 lea -0x8(%ebp),%esp
10a933: 5b pop %ebx
10a934: 5e pop %esi
10a935: c9 leave
10a936: c3 ret
0010b0f4 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b0f4: 55 push %ebp
10b0f5: 89 e5 mov %esp,%ebp
10b0f7: 56 push %esi
10b0f8: 53 push %ebx
10b0f9: 83 ec 10 sub $0x10,%esp
10b0fc: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0ff: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b104: 85 db test %ebx,%ebx
10b106: 0f 84 8b 00 00 00 je 10b197 <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b10c: 8b 75 0c mov 0xc(%ebp),%esi
10b10f: 85 f6 test %esi,%esi
10b111: 75 0f jne 10b122 <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b113: 83 ec 0c sub $0xc,%esp
10b116: 8d 75 ec lea -0x14(%ebp),%esi
10b119: 56 push %esi
10b11a: e8 5d 09 00 00 call 10ba7c <pthread_rwlockattr_init>
10b11f: 83 c4 10 add $0x10,%esp
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
10b122: b8 16 00 00 00 mov $0x16,%eax
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10b127: 83 3e 00 cmpl $0x0,(%esi)
10b12a: 74 6b je 10b197 <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b12c: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b130: 75 65 jne 10b197 <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b132: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b139: a1 50 83 12 00 mov 0x128350,%eax
10b13e: 40 inc %eax
10b13f: a3 50 83 12 00 mov %eax,0x128350
* 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 );
10b144: 83 ec 0c sub $0xc,%esp
10b147: 68 34 85 12 00 push $0x128534
10b14c: e8 33 23 00 00 call 10d484 <_Objects_Allocate>
10b151: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b153: 83 c4 10 add $0x10,%esp
10b156: 85 c0 test %eax,%eax
10b158: 75 0c jne 10b166 <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b15a: e8 03 32 00 00 call 10e362 <_Thread_Enable_dispatch>
return EAGAIN;
10b15f: b8 0b 00 00 00 mov $0xb,%eax
10b164: eb 31 jmp 10b197 <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b166: 50 push %eax
10b167: 50 push %eax
10b168: 8d 45 f4 lea -0xc(%ebp),%eax
10b16b: 50 push %eax
10b16c: 8d 46 10 lea 0x10(%esi),%eax
10b16f: 50 push %eax
10b170: e8 7b 1b 00 00 call 10ccf0 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b175: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b178: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b17b: 8b 15 50 85 12 00 mov 0x128550,%edx
10b181: 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;
10b184: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b18b: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b18d: e8 d0 31 00 00 call 10e362 <_Thread_Enable_dispatch>
return 0;
10b192: 83 c4 10 add $0x10,%esp
10b195: 31 c0 xor %eax,%eax
}
10b197: 8d 65 f8 lea -0x8(%ebp),%esp
10b19a: 5b pop %ebx
10b19b: 5e pop %esi
10b19c: c9 leave
10b19d: c3 ret
0010b208 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b208: 55 push %ebp
10b209: 89 e5 mov %esp,%ebp
10b20b: 57 push %edi
10b20c: 56 push %esi
10b20d: 53 push %ebx
10b20e: 83 ec 2c sub $0x2c,%esp
10b211: 8b 7d 08 mov 0x8(%ebp),%edi
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
10b214: bb 16 00 00 00 mov $0x16,%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10b219: 85 ff test %edi,%edi
10b21b: 0f 84 87 00 00 00 je 10b2a8 <pthread_rwlock_timedrdlock+0xa0>
*
* 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 );
10b221: 50 push %eax
10b222: 50 push %eax
10b223: 8d 45 e0 lea -0x20(%ebp),%eax
10b226: 50 push %eax
10b227: ff 75 0c pushl 0xc(%ebp)
10b22a: e8 65 59 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks>
10b22f: 89 c6 mov %eax,%esi
10b231: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b234: 8d 45 e4 lea -0x1c(%ebp),%eax
10b237: 50 push %eax
10b238: ff 37 pushl (%edi)
10b23a: 68 34 85 12 00 push $0x128534
10b23f: e8 6c 26 00 00 call 10d8b0 <_Objects_Get>
switch ( location ) {
10b244: 83 c4 10 add $0x10,%esp
10b247: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b24b: 75 5b jne 10b2a8 <pthread_rwlock_timedrdlock+0xa0>
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,
10b24d: 83 fe 03 cmp $0x3,%esi
10b250: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b253: 83 ec 0c sub $0xc,%esp
10b256: 6a 00 push $0x0
10b258: ff 75 e0 pushl -0x20(%ebp)
10b25b: 0f b6 ca movzbl %dl,%ecx
10b25e: 51 push %ecx
10b25f: ff 37 pushl (%edi)
10b261: 83 c0 10 add $0x10,%eax
10b264: 50 push %eax
10b265: 88 55 d4 mov %dl,-0x2c(%ebp)
10b268: e8 b7 1a 00 00 call 10cd24 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b26d: 83 c4 20 add $0x20,%esp
10b270: e8 ed 30 00 00 call 10e362 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b275: 8a 55 d4 mov -0x2c(%ebp),%dl
10b278: 84 d2 test %dl,%dl
10b27a: 75 17 jne 10b293 <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b27c: a1 78 88 12 00 mov 0x128878,%eax
10b281: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b285: 75 0c jne 10b293 <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b287: 85 f6 test %esi,%esi
10b289: 74 1d je 10b2a8 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b28b: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b28c: b3 74 mov $0x74,%bl
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b28e: 83 fe 01 cmp $0x1,%esi
10b291: 76 15 jbe 10b2a8 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b293: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b296: a1 78 88 12 00 mov 0x128878,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b29b: ff 70 34 pushl 0x34(%eax)
10b29e: e8 bd 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2a3: 89 c3 mov %eax,%ebx
10b2a5: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b2a8: 89 d8 mov %ebx,%eax
10b2aa: 8d 65 f4 lea -0xc(%ebp),%esp
10b2ad: 5b pop %ebx
10b2ae: 5e pop %esi
10b2af: 5f pop %edi
10b2b0: c9 leave
10b2b1: c3 ret
0010b2b4 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b2b4: 55 push %ebp
10b2b5: 89 e5 mov %esp,%ebp
10b2b7: 57 push %edi
10b2b8: 56 push %esi
10b2b9: 53 push %ebx
10b2ba: 83 ec 2c sub $0x2c,%esp
10b2bd: 8b 7d 08 mov 0x8(%ebp),%edi
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
10b2c0: bb 16 00 00 00 mov $0x16,%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10b2c5: 85 ff test %edi,%edi
10b2c7: 0f 84 87 00 00 00 je 10b354 <pthread_rwlock_timedwrlock+0xa0>
*
* 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 );
10b2cd: 50 push %eax
10b2ce: 50 push %eax
10b2cf: 8d 45 e0 lea -0x20(%ebp),%eax
10b2d2: 50 push %eax
10b2d3: ff 75 0c pushl 0xc(%ebp)
10b2d6: e8 b9 58 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks>
10b2db: 89 c6 mov %eax,%esi
10b2dd: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b2e0: 8d 45 e4 lea -0x1c(%ebp),%eax
10b2e3: 50 push %eax
10b2e4: ff 37 pushl (%edi)
10b2e6: 68 34 85 12 00 push $0x128534
10b2eb: e8 c0 25 00 00 call 10d8b0 <_Objects_Get>
switch ( location ) {
10b2f0: 83 c4 10 add $0x10,%esp
10b2f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b2f7: 75 5b jne 10b354 <pthread_rwlock_timedwrlock+0xa0>
(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,
10b2f9: 83 fe 03 cmp $0x3,%esi
10b2fc: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2ff: 83 ec 0c sub $0xc,%esp
10b302: 6a 00 push $0x0
10b304: ff 75 e0 pushl -0x20(%ebp)
10b307: 0f b6 ca movzbl %dl,%ecx
10b30a: 51 push %ecx
10b30b: ff 37 pushl (%edi)
10b30d: 83 c0 10 add $0x10,%eax
10b310: 50 push %eax
10b311: 88 55 d4 mov %dl,-0x2c(%ebp)
10b314: e8 c3 1a 00 00 call 10cddc <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b319: 83 c4 20 add $0x20,%esp
10b31c: e8 41 30 00 00 call 10e362 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b321: 8a 55 d4 mov -0x2c(%ebp),%dl
10b324: 84 d2 test %dl,%dl
10b326: 75 17 jne 10b33f <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b328: a1 78 88 12 00 mov 0x128878,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b32d: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b331: 75 0c jne 10b33f <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b333: 85 f6 test %esi,%esi
10b335: 74 1d je 10b354 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b337: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b338: b3 74 mov $0x74,%bl
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b33a: 83 fe 01 cmp $0x1,%esi
10b33d: 76 15 jbe 10b354 <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b33f: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b342: a1 78 88 12 00 mov 0x128878,%eax
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b347: ff 70 34 pushl 0x34(%eax)
10b34a: e8 11 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b34f: 89 c3 mov %eax,%ebx
10b351: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b354: 89 d8 mov %ebx,%eax
10b356: 8d 65 f4 lea -0xc(%ebp),%esp
10b359: 5b pop %ebx
10b35a: 5e pop %esi
10b35b: 5f pop %edi
10b35c: c9 leave
10b35d: c3 ret
0010ba9c <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba9c: 55 push %ebp
10ba9d: 89 e5 mov %esp,%ebp
10ba9f: 8b 55 08 mov 0x8(%ebp),%edx
10baa2: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10baa5: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10baaa: 85 d2 test %edx,%edx
10baac: 74 0f je 10babd <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10baae: 83 3a 00 cmpl $0x0,(%edx)
10bab1: 74 0a je 10babd <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bab3: 83 f9 01 cmp $0x1,%ecx
10bab6: 77 05 ja 10babd <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bab8: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10babb: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10babd: c9 leave
10babe: c3 ret
0010c798 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c798: 55 push %ebp
10c799: 89 e5 mov %esp,%ebp
10c79b: 57 push %edi
10c79c: 56 push %esi
10c79d: 53 push %ebx
10c79e: 83 ec 2c sub $0x2c,%esp
10c7a1: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c7a4: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c7ab: 85 f6 test %esi,%esi
10c7ad: 0f 84 fc 00 00 00 je 10c8af <pthread_setschedparam+0x117>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c7b3: 8d 45 e0 lea -0x20(%ebp),%eax
10c7b6: 50 push %eax
10c7b7: 8d 45 e4 lea -0x1c(%ebp),%eax
10c7ba: 50 push %eax
10c7bb: 56 push %esi
10c7bc: ff 75 0c pushl 0xc(%ebp)
10c7bf: e8 20 53 00 00 call 111ae4 <_POSIX_Thread_Translate_sched_param>
10c7c4: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c7c7: 83 c4 10 add $0x10,%esp
10c7ca: 85 c0 test %eax,%eax
10c7cc: 0f 85 dd 00 00 00 jne 10c8af <pthread_setschedparam+0x117>
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
10c7d2: 53 push %ebx
10c7d3: 53 push %ebx
10c7d4: 8d 45 dc lea -0x24(%ebp),%eax
10c7d7: 50 push %eax
10c7d8: ff 75 08 pushl 0x8(%ebp)
10c7db: e8 54 27 00 00 call 10ef34 <_Thread_Get>
10c7e0: 89 c2 mov %eax,%edx
switch ( location ) {
10c7e2: 83 c4 10 add $0x10,%esp
10c7e5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c7e9: 0f 85 b9 00 00 00 jne 10c8a8 <pthread_setschedparam+0x110>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7ef: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7f5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7fc: 75 18 jne 10c816 <pthread_setschedparam+0x7e>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7fe: 83 ec 0c sub $0xc,%esp
10c801: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c807: 50 push %eax
10c808: 89 55 d0 mov %edx,-0x30(%ebp)
10c80b: e8 68 35 00 00 call 10fd78 <_Watchdog_Remove>
10c810: 83 c4 10 add $0x10,%esp
10c813: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c816: 8b 45 0c mov 0xc(%ebp),%eax
10c819: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c81f: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c825: b9 07 00 00 00 mov $0x7,%ecx
10c82a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c82c: 8b 45 e4 mov -0x1c(%ebp),%eax
10c82f: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c832: 8b 45 e0 mov -0x20(%ebp),%eax
10c835: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c83b: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c83f: 78 60 js 10c8a1 <pthread_setschedparam+0x109><== NEVER TAKEN
10c841: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c845: 7e 08 jle 10c84f <pthread_setschedparam+0xb7>
10c847: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c84b: 75 54 jne 10c8a1 <pthread_setschedparam+0x109><== NEVER TAKEN
10c84d: eb 24 jmp 10c873 <pthread_setschedparam+0xdb>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c84f: a1 c0 a3 12 00 mov 0x12a3c0,%eax
10c854: 89 42 78 mov %eax,0x78(%edx)
10c857: 0f b6 05 88 62 12 00 movzbl 0x126288,%eax
10c85e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c864: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c867: 51 push %ecx
10c868: 6a 01 push $0x1
10c86a: 50 push %eax
10c86b: 52 push %edx
10c86c: e8 cb 22 00 00 call 10eb3c <_Thread_Change_priority>
10c871: eb 2b jmp 10c89e <pthread_setschedparam+0x106>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c873: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c879: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c87f: 83 ec 0c sub $0xc,%esp
10c882: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c888: 53 push %ebx
10c889: 89 55 d0 mov %edx,-0x30(%ebp)
10c88c: e8 e7 34 00 00 call 10fd78 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c891: 58 pop %eax
10c892: 5a pop %edx
10c893: 8b 55 d0 mov -0x30(%ebp),%edx
10c896: 52 push %edx
10c897: 6a 00 push $0x0
10c899: e8 e5 fd ff ff call 10c683 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c89e: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c8a1: e8 6c 26 00 00 call 10ef12 <_Thread_Enable_dispatch>
return 0;
10c8a6: eb 07 jmp 10c8af <pthread_setschedparam+0x117>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c8a8: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c8af: 8b 45 d4 mov -0x2c(%ebp),%eax
10c8b2: 8d 65 f4 lea -0xc(%ebp),%esp
10c8b5: 5b pop %ebx
10c8b6: 5e pop %esi
10c8b7: 5f pop %edi
10c8b8: c9 leave
10c8b9: c3 ret
0010a690 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a690: 55 push %ebp
10a691: 89 e5 mov %esp,%ebp
10a693: 53 push %ebx
10a694: 83 ec 04 sub $0x4,%esp
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10a697: 83 3d 6c 68 12 00 00 cmpl $0x0,0x12686c
10a69e: 75 48 jne 10a6e8 <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a6a0: a1 70 68 12 00 mov 0x126870,%eax
10a6a5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10a6ab: 8b 15 48 63 12 00 mov 0x126348,%edx
10a6b1: 42 inc %edx
10a6b2: 89 15 48 63 12 00 mov %edx,0x126348
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a6b8: 31 db xor %ebx,%ebx
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10a6ba: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a6c1: 75 0a jne 10a6cd <pthread_testcancel+0x3d><== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
10a6c3: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a6ca: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a6cd: e8 e4 25 00 00 call 10ccb6 <_Thread_Enable_dispatch>
if ( cancel )
10a6d2: 84 db test %bl,%bl
10a6d4: 74 12 je 10a6e8 <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a6d6: 50 push %eax
10a6d7: 50 push %eax
10a6d8: 6a ff push $0xffffffff
10a6da: ff 35 70 68 12 00 pushl 0x126870
10a6e0: e8 bf 52 00 00 call 10f9a4 <_POSIX_Thread_Exit>
10a6e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10a6e8: 8b 5d fc mov -0x4(%ebp),%ebx
10a6eb: c9 leave
10a6ec: c3 ret
0010af85 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af85: 55 push %ebp
10af86: 89 e5 mov %esp,%ebp
10af88: 57 push %edi
10af89: 56 push %esi
10af8a: 53 push %ebx
10af8b: 83 ec 58 sub $0x58,%esp
10af8e: 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);
10af91: 68 d8 72 12 00 push $0x1272d8
10af96: e8 c5 08 00 00 call 10b860 <pthread_mutex_lock>
10af9b: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af9e: 83 c4 10 add $0x10,%esp
10afa1: 85 c0 test %eax,%eax
10afa3: 74 0e je 10afb3 <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10afa5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10afa8: 53 push %ebx <== NOT EXECUTED
10afa9: e8 c2 cd ff ff call 107d70 <free> <== NOT EXECUTED
10afae: e9 c6 01 00 00 jmp 10b179 <rtems_aio_enqueue+0x1f4><== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10afb3: e8 a4 10 00 00 call 10c05c <pthread_self>
10afb8: 57 push %edi
10afb9: 8d 55 c4 lea -0x3c(%ebp),%edx
10afbc: 52 push %edx
10afbd: 8d 55 e0 lea -0x20(%ebp),%edx
10afc0: 52 push %edx
10afc1: 50 push %eax
10afc2: e8 9d 0c 00 00 call 10bc64 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10afc7: e8 90 10 00 00 call 10c05c <pthread_self>
10afcc: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10afcf: 8b 43 14 mov 0x14(%ebx),%eax
10afd2: 8b 55 c4 mov -0x3c(%ebp),%edx
10afd5: 2b 50 14 sub 0x14(%eax),%edx
10afd8: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10afdb: 8b 55 e0 mov -0x20(%ebp),%edx
10afde: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10afe1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10afe8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10afef: 83 c4 10 add $0x10,%esp
10aff2: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340
10aff9: 0f 85 b7 00 00 00 jne 10b0b6 <rtems_aio_enqueue+0x131><== NEVER TAKEN
10afff: 83 3d 3c 73 12 00 04 cmpl $0x4,0x12733c
10b006: 0f 8f aa 00 00 00 jg 10b0b6 <rtems_aio_enqueue+0x131>
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);
10b00c: 56 push %esi
10b00d: 6a 01 push $0x1
10b00f: ff 30 pushl (%eax)
10b011: 68 20 73 12 00 push $0x127320
10b016: e8 81 fb ff ff call 10ab9c <rtems_aio_search_fd>
10b01b: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b01d: 83 c4 10 add $0x10,%esp
10b020: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b024: 8d 50 08 lea 0x8(%eax),%edx
10b027: 8d 78 1c lea 0x1c(%eax),%edi
10b02a: 8d 40 20 lea 0x20(%eax),%eax
10b02d: 89 45 b0 mov %eax,-0x50(%ebp)
10b030: 75 66 jne 10b098 <rtems_aio_enqueue+0x113>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10b032: 51 push %ecx
10b033: 51 push %ecx
10b034: 53 push %ebx
10b035: 52 push %edx
10b036: e8 c1 1f 00 00 call 10cffc <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10b03b: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b042: 5b pop %ebx
10b043: 58 pop %eax
10b044: 6a 00 push $0x0
10b046: 57 push %edi
10b047: e8 f4 06 00 00 call 10b740 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b04c: 5a pop %edx
10b04d: 59 pop %ecx
10b04e: 6a 00 push $0x0
10b050: ff 75 b0 pushl -0x50(%ebp)
10b053: e8 a8 03 00 00 call 10b400 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10b058: 56 push %esi
10b059: 68 78 ac 10 00 push $0x10ac78
10b05e: 68 e0 72 12 00 push $0x1272e0
10b063: 8d 45 e4 lea -0x1c(%ebp),%eax
10b066: 50 push %eax
10b067: e8 c4 09 00 00 call 10ba30 <pthread_create>
10b06c: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10b06e: 83 c4 20 add $0x20,%esp
10b071: 85 c0 test %eax,%eax
10b073: 74 18 je 10b08d <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10b075: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b078: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10b07d: e8 5e 08 00 00 call 10b8e0 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10b082: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b085: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b088: e9 ef 00 00 00 jmp 10b17c <rtems_aio_enqueue+0x1f7><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b08d: ff 05 3c 73 12 00 incl 0x12733c
10b093: e9 d4 00 00 00 jmp 10b16c <rtems_aio_enqueue+0x1e7>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b098: 83 ec 0c sub $0xc,%esp
10b09b: 57 push %edi
10b09c: 89 55 ac mov %edx,-0x54(%ebp)
10b09f: e8 bc 07 00 00 call 10b860 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0a4: 5e pop %esi
10b0a5: 58 pop %eax
10b0a6: 53 push %ebx
10b0a7: 8b 55 ac mov -0x54(%ebp),%edx
10b0aa: 52 push %edx
10b0ab: e8 ec fd ff ff call 10ae9c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b0b0: 5b pop %ebx
10b0b1: ff 75 b0 pushl -0x50(%ebp)
10b0b4: eb 36 jmp 10b0ec <rtems_aio_enqueue+0x167>
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,
10b0b6: 51 push %ecx
10b0b7: 6a 00 push $0x0
10b0b9: ff 30 pushl (%eax)
10b0bb: 68 20 73 12 00 push $0x127320
10b0c0: e8 d7 fa ff ff call 10ab9c <rtems_aio_search_fd>
10b0c5: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b0c7: 83 c4 10 add $0x10,%esp
10b0ca: 85 c0 test %eax,%eax
10b0cc: 74 2d je 10b0fb <rtems_aio_enqueue+0x176>
{
pthread_mutex_lock (&r_chain->mutex);
10b0ce: 8d 78 1c lea 0x1c(%eax),%edi
10b0d1: 83 ec 0c sub $0xc,%esp
10b0d4: 57 push %edi
10b0d5: e8 86 07 00 00 call 10b860 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0da: 58 pop %eax
10b0db: 5a pop %edx
10b0dc: 53 push %ebx
10b0dd: 8d 46 08 lea 0x8(%esi),%eax
10b0e0: 50 push %eax
10b0e1: e8 b6 fd ff ff call 10ae9c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b0e6: 83 c6 20 add $0x20,%esi
10b0e9: 89 34 24 mov %esi,(%esp)
10b0ec: e8 ab 03 00 00 call 10b49c <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b0f1: 89 3c 24 mov %edi,(%esp)
10b0f4: e8 e7 07 00 00 call 10b8e0 <pthread_mutex_unlock>
10b0f9: eb 6e jmp 10b169 <rtems_aio_enqueue+0x1e4>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10b0fb: 56 push %esi
10b0fc: 6a 01 push $0x1
10b0fe: 8b 43 14 mov 0x14(%ebx),%eax
10b101: ff 30 pushl (%eax)
10b103: 68 2c 73 12 00 push $0x12732c
10b108: e8 8f fa ff ff call 10ab9c <rtems_aio_search_fd>
10b10d: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b10f: 83 c4 10 add $0x10,%esp
10b112: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b116: 8d 40 08 lea 0x8(%eax),%eax
10b119: 75 2c jne 10b147 <rtems_aio_enqueue+0x1c2>
10b11b: 51 push %ecx
10b11c: 51 push %ecx
10b11d: 53 push %ebx
10b11e: 50 push %eax
10b11f: e8 d8 1e 00 00 call 10cffc <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10b124: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b12b: 58 pop %eax
10b12c: 5a pop %edx
10b12d: 6a 00 push $0x0
10b12f: 8d 46 1c lea 0x1c(%esi),%eax
10b132: 50 push %eax
10b133: e8 08 06 00 00 call 10b740 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b138: 5b pop %ebx
10b139: 5f pop %edi
10b13a: 6a 00 push $0x0
10b13c: 83 c6 20 add $0x20,%esi
10b13f: 56 push %esi
10b140: e8 bb 02 00 00 call 10b400 <pthread_cond_init>
10b145: eb 09 jmp 10b150 <rtems_aio_enqueue+0x1cb>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b147: 51 push %ecx
10b148: 51 push %ecx
10b149: 53 push %ebx
10b14a: 50 push %eax
10b14b: e8 4c fd ff ff call 10ae9c <rtems_aio_insert_prio>
10b150: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10b153: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340
10b15a: 7e 10 jle 10b16c <rtems_aio_enqueue+0x1e7><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10b15c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b15f: 68 dc 72 12 00 push $0x1272dc <== NOT EXECUTED
10b164: e8 33 03 00 00 call 10b49c <pthread_cond_signal> <== NOT EXECUTED
10b169: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b16c: 83 ec 0c sub $0xc,%esp
10b16f: 68 d8 72 12 00 push $0x1272d8
10b174: e8 67 07 00 00 call 10b8e0 <pthread_mutex_unlock>
return 0;
10b179: 83 c4 10 add $0x10,%esp
}
10b17c: 8b 45 b4 mov -0x4c(%ebp),%eax
10b17f: 8d 65 f4 lea -0xc(%ebp),%esp
10b182: 5b pop %ebx
10b183: 5e pop %esi
10b184: 5f pop %edi
10b185: c9 leave
10b186: c3 ret
0010ac78 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10ac78: 55 push %ebp
10ac79: 89 e5 mov %esp,%ebp
10ac7b: 57 push %edi
10ac7c: 56 push %esi
10ac7d: 53 push %ebx
10ac7e: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10ac81: 8b 5d 08 mov 0x8(%ebp),%ebx
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ac84: 8d 7d dc lea -0x24(%ebp),%edi
/* 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);
10ac87: 8d 43 1c lea 0x1c(%ebx),%eax
10ac8a: 89 45 b4 mov %eax,-0x4c(%ebp)
10ac8d: 83 ec 0c sub $0xc,%esp
10ac90: 50 push %eax
10ac91: e8 ca 0b 00 00 call 10b860 <pthread_mutex_lock>
if (result != 0)
10ac96: 83 c4 10 add $0x10,%esp
10ac99: 85 c0 test %eax,%eax
10ac9b: 0f 85 f1 01 00 00 jne 10ae92 <rtems_aio_handle+0x21a><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aca1: 8b 73 08 mov 0x8(%ebx),%esi
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10aca4: 8d 43 0c lea 0xc(%ebx),%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)) {
10aca7: 39 c6 cmp %eax,%esi
10aca9: 0f 84 cd 00 00 00 je 10ad7c <rtems_aio_handle+0x104>
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);
10acaf: e8 a8 13 00 00 call 10c05c <pthread_self>
10acb4: 52 push %edx
10acb5: 8d 55 c0 lea -0x40(%ebp),%edx
10acb8: 52 push %edx
10acb9: 8d 4d e4 lea -0x1c(%ebp),%ecx
10acbc: 51 push %ecx
10acbd: 50 push %eax
10acbe: e8 a1 0f 00 00 call 10bc64 <pthread_getschedparam>
param.sched_priority = req->priority;
10acc3: 8b 46 0c mov 0xc(%esi),%eax
10acc6: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10acc9: 8b 56 08 mov 0x8(%esi),%edx
10accc: 89 55 b0 mov %edx,-0x50(%ebp)
10accf: e8 88 13 00 00 call 10c05c <pthread_self>
10acd4: 83 c4 0c add $0xc,%esp
10acd7: 8d 4d c0 lea -0x40(%ebp),%ecx
10acda: 51 push %ecx
10acdb: 8b 55 b0 mov -0x50(%ebp),%edx
10acde: 52 push %edx
10acdf: 50 push %eax
10ace0: e8 87 13 00 00 call 10c06c <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ace5: 89 34 24 mov %esi,(%esp)
10ace8: e8 d3 22 00 00 call 10cfc0 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10aced: 59 pop %ecx
10acee: ff 75 b4 pushl -0x4c(%ebp)
10acf1: e8 ea 0b 00 00 call 10b8e0 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10acf6: 8b 46 14 mov 0x14(%esi),%eax
10acf9: 83 c4 10 add $0x10,%esp
10acfc: 8b 50 2c mov 0x2c(%eax),%edx
10acff: 83 fa 02 cmp $0x2,%edx
10ad02: 74 20 je 10ad24 <rtems_aio_handle+0xac>
10ad04: 83 fa 03 cmp $0x3,%edx
10ad07: 74 36 je 10ad3f <rtems_aio_handle+0xc7> <== NEVER TAKEN
10ad09: 4a dec %edx
10ad0a: 75 45 jne 10ad51 <rtems_aio_handle+0xd9> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
10ad0c: 83 ec 0c sub $0xc,%esp
10ad0f: ff 70 08 pushl 0x8(%eax)
10ad12: ff 70 04 pushl 0x4(%eax)
10ad15: ff 70 10 pushl 0x10(%eax)
10ad18: ff 70 0c pushl 0xc(%eax)
10ad1b: ff 30 pushl (%eax)
10ad1d: e8 fe 93 00 00 call 114120 <pread>
10ad22: eb 16 jmp 10ad3a <rtems_aio_handle+0xc2>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
10ad24: 83 ec 0c sub $0xc,%esp
10ad27: ff 70 08 pushl 0x8(%eax)
10ad2a: ff 70 04 pushl 0x4(%eax)
10ad2d: ff 70 10 pushl 0x10(%eax)
10ad30: ff 70 0c pushl 0xc(%eax)
10ad33: ff 30 pushl (%eax)
10ad35: e8 9a 94 00 00 call 1141d4 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10ad3a: 83 c4 20 add $0x20,%esp
10ad3d: eb 0d jmp 10ad4c <rtems_aio_handle+0xd4>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10ad3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad42: ff 30 pushl (%eax) <== NOT EXECUTED
10ad44: e8 33 5d 00 00 call 110a7c <fsync> <== NOT EXECUTED
break;
10ad49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10ad4c: 83 f8 ff cmp $0xffffffff,%eax
10ad4f: 75 19 jne 10ad6a <rtems_aio_handle+0xf2> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
10ad51: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10ad54: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10ad5b: e8 88 89 00 00 call 1136e8 <__errno> <== NOT EXECUTED
10ad60: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10ad62: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10ad65: e9 1d ff ff ff jmp 10ac87 <rtems_aio_handle+0xf> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10ad6a: 8b 56 14 mov 0x14(%esi),%edx
10ad6d: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10ad70: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
10ad77: e9 0b ff ff ff jmp 10ac87 <rtems_aio_handle+0xf>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10ad7c: 83 ec 0c sub $0xc,%esp
10ad7f: ff 75 b4 pushl -0x4c(%ebp)
10ad82: e8 59 0b 00 00 call 10b8e0 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10ad87: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10ad8e: e8 cd 0a 00 00 call 10b860 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10ad93: 83 c4 10 add $0x10,%esp
10ad96: 39 73 08 cmp %esi,0x8(%ebx)
10ad99: 0f 85 de 00 00 00 jne 10ae7d <rtems_aio_handle+0x205><== NEVER TAKEN
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ad9f: 52 push %edx
10ada0: 52 push %edx
10ada1: 57 push %edi
10ada2: 6a 01 push $0x1
10ada4: e8 47 05 00 00 call 10b2f0 <clock_gettime>
timeout.tv_sec += 3;
10ada9: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10adad: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10adb4: 8d 73 20 lea 0x20(%ebx),%esi
10adb7: 83 c4 0c add $0xc,%esp
10adba: 57 push %edi
10adbb: 68 d8 72 12 00 push $0x1272d8
10adc0: 56 push %esi
10adc1: e8 46 07 00 00 call 10b50c <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) {
10adc6: 83 c4 10 add $0x10,%esp
10adc9: 83 f8 74 cmp $0x74,%eax
10adcc: 0f 85 ab 00 00 00 jne 10ae7d <rtems_aio_handle+0x205><== NEVER TAKEN
10add2: 83 ec 0c sub $0xc,%esp
10add5: 53 push %ebx
10add6: e8 e5 21 00 00 call 10cfc0 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10addb: 58 pop %eax
10addc: ff 75 b4 pushl -0x4c(%ebp)
10addf: e8 5c 08 00 00 call 10b640 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10ade4: 89 34 24 mov %esi,(%esp)
10ade7: e8 60 05 00 00 call 10b34c <pthread_cond_destroy>
free (r_chain);
10adec: 89 1c 24 mov %ebx,(%esp)
10adef: e8 7c cf ff ff call 107d70 <free>
/* 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)) {
10adf4: 83 c4 10 add $0x10,%esp
10adf7: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10adfe: 73 12 00
10ae01: 75 54 jne 10ae57 <rtems_aio_handle+0x1df>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
10ae03: ff 05 40 73 12 00 incl 0x127340
--aio_request_queue.active_threads;
10ae09: ff 0d 3c 73 12 00 decl 0x12733c
clock_gettime (CLOCK_REALTIME, &timeout);
10ae0f: 53 push %ebx
10ae10: 53 push %ebx
10ae11: 57 push %edi
10ae12: 6a 01 push $0x1
10ae14: e8 d7 04 00 00 call 10b2f0 <clock_gettime>
timeout.tv_sec += 3;
10ae19: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10ae1d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10ae24: 83 c4 0c add $0xc,%esp
10ae27: 57 push %edi
10ae28: 68 d8 72 12 00 push $0x1272d8
10ae2d: 68 dc 72 12 00 push $0x1272dc
10ae32: e8 d5 06 00 00 call 10b50c <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) {
10ae37: 83 c4 10 add $0x10,%esp
10ae3a: 83 f8 74 cmp $0x74,%eax
10ae3d: 75 18 jne 10ae57 <rtems_aio_handle+0x1df><== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
10ae3f: ff 0d 40 73 12 00 decl 0x127340
pthread_mutex_unlock (&aio_request_queue.mutex);
10ae45: 83 ec 0c sub $0xc,%esp
10ae48: 68 d8 72 12 00 push $0x1272d8
10ae4d: e8 8e 0a 00 00 call 10b8e0 <pthread_mutex_unlock>
return NULL;
10ae52: 83 c4 10 add $0x10,%esp
10ae55: eb 3b jmp 10ae92 <rtems_aio_handle+0x21a>
}
}
/* 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;
10ae57: ff 0d 40 73 12 00 decl 0x127340
++aio_request_queue.active_threads;
10ae5d: ff 05 3c 73 12 00 incl 0x12733c
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae63: 8b 1d 2c 73 12 00 mov 0x12732c,%ebx
10ae69: 83 ec 0c sub $0xc,%esp
10ae6c: 53 push %ebx
10ae6d: e8 4e 21 00 00 call 10cfc0 <_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);
10ae72: 89 1c 24 mov %ebx,(%esp)
10ae75: e8 cd fd ff ff call 10ac47 <rtems_aio_move_to_work>
10ae7a: 83 c4 10 add $0x10,%esp
}
}
/* 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);
10ae7d: 83 ec 0c sub $0xc,%esp
10ae80: 68 d8 72 12 00 push $0x1272d8
10ae85: e8 56 0a 00 00 call 10b8e0 <pthread_mutex_unlock>
10ae8a: 83 c4 10 add $0x10,%esp
10ae8d: e9 f5 fd ff ff jmp 10ac87 <rtems_aio_handle+0xf>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae92: 31 c0 xor %eax,%eax
10ae94: 8d 65 f4 lea -0xc(%ebp),%esp
10ae97: 5b pop %ebx
10ae98: 5e pop %esi
10ae99: 5f pop %edi
10ae9a: c9 leave
10ae9b: c3 ret
0010aaa0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aaa0: 55 push %ebp
10aaa1: 89 e5 mov %esp,%ebp
10aaa3: 53 push %ebx
10aaa4: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aaa7: 68 e0 72 12 00 push $0x1272e0
10aaac: e8 33 0f 00 00 call 10b9e4 <pthread_attr_init>
10aab1: 89 c3 mov %eax,%ebx
if (result != 0)
10aab3: 83 c4 10 add $0x10,%esp
10aab6: 85 c0 test %eax,%eax
10aab8: 0f 85 d7 00 00 00 jne 10ab95 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aabe: 51 push %ecx
10aabf: 51 push %ecx
10aac0: 6a 00 push $0x0
10aac2: 68 e0 72 12 00 push $0x1272e0
10aac7: e8 40 0f 00 00 call 10ba0c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aacc: 83 c4 10 add $0x10,%esp
10aacf: 85 c0 test %eax,%eax
10aad1: 74 10 je 10aae3 <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aad3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aad6: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED
10aadb: e8 e4 0e 00 00 call 10b9c4 <pthread_attr_destroy> <== NOT EXECUTED
10aae0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aae3: 52 push %edx
10aae4: 52 push %edx
10aae5: 6a 00 push $0x0
10aae7: 68 d8 72 12 00 push $0x1272d8
10aaec: e8 4f 0c 00 00 call 10b740 <pthread_mutex_init>
if (result != 0)
10aaf1: 83 c4 10 add $0x10,%esp
10aaf4: 85 c0 test %eax,%eax
10aaf6: 74 10 je 10ab08 <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aaf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aafb: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED
10ab00: e8 bf 0e 00 00 call 10b9c4 <pthread_attr_destroy> <== NOT EXECUTED
10ab05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10ab08: 50 push %eax
10ab09: 50 push %eax
10ab0a: 6a 00 push $0x0
10ab0c: 68 dc 72 12 00 push $0x1272dc
10ab11: e8 ea 08 00 00 call 10b400 <pthread_cond_init>
10ab16: 89 c3 mov %eax,%ebx
if (result != 0) {
10ab18: 83 c4 10 add $0x10,%esp
10ab1b: 85 c0 test %eax,%eax
10ab1d: 74 1c je 10ab3b <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10ab1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ab22: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10ab27: e8 14 0b 00 00 call 10b640 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10ab2c: c7 04 24 e0 72 12 00 movl $0x1272e0,(%esp) <== NOT EXECUTED
10ab33: e8 8c 0e 00 00 call 10b9c4 <pthread_attr_destroy> <== NOT EXECUTED
10ab38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10ab3b: c7 05 20 73 12 00 24 movl $0x127324,0x127320
10ab42: 73 12 00
head->previous = NULL;
10ab45: c7 05 24 73 12 00 00 movl $0x0,0x127324
10ab4c: 00 00 00
tail->previous = head;
10ab4f: c7 05 28 73 12 00 20 movl $0x127320,0x127328
10ab56: 73 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10ab59: c7 05 2c 73 12 00 30 movl $0x127330,0x12732c
10ab60: 73 12 00
head->previous = NULL;
10ab63: c7 05 30 73 12 00 00 movl $0x0,0x127330
10ab6a: 00 00 00
tail->previous = head;
10ab6d: c7 05 34 73 12 00 2c movl $0x12732c,0x127334
10ab74: 73 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;
10ab77: c7 05 3c 73 12 00 00 movl $0x0,0x12733c
10ab7e: 00 00 00
aio_request_queue.idle_threads = 0;
10ab81: c7 05 40 73 12 00 00 movl $0x0,0x127340
10ab88: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab8b: c7 05 38 73 12 00 0b movl $0xb00b,0x127338
10ab92: b0 00 00
return result;
}
10ab95: 89 d8 mov %ebx,%eax
10ab97: 8b 5d fc mov -0x4(%ebp),%ebx
10ab9a: c9 leave
10ab9b: c3 ret
0010ae9c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae9c: 55 push %ebp
10ae9d: 89 e5 mov %esp,%ebp
10ae9f: 56 push %esi
10aea0: 53 push %ebx
10aea1: 8b 4d 08 mov 0x8(%ebp),%ecx
10aea4: 8b 55 0c mov 0xc(%ebp),%edx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aea7: 8b 01 mov (%ecx),%eax
10aea9: 8d 59 04 lea 0x4(%ecx),%ebx
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
10aeac: 39 d8 cmp %ebx,%eax
10aeae: 74 27 je 10aed7 <rtems_aio_insert_prio+0x3b><== NEVER TAKEN
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10aeb0: 8b 48 14 mov 0x14(%eax),%ecx
10aeb3: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10aeb6: 8b 72 14 mov 0x14(%edx),%esi
10aeb9: 8b 76 14 mov 0x14(%esi),%esi
10aebc: eb 08 jmp 10aec6 <rtems_aio_insert_prio+0x2a>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aebe: 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;
10aec0: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10aec3: 8b 49 14 mov 0x14(%ecx),%ecx <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10aec6: 39 ce cmp %ecx,%esi
10aec8: 7e 04 jle 10aece <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10aeca: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10aecc: 75 f0 jne 10aebe <rtems_aio_insert_prio+0x22><== 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 );
10aece: 89 55 0c mov %edx,0xc(%ebp)
10aed1: 8b 40 04 mov 0x4(%eax),%eax
10aed4: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10aed7: 5b pop %ebx
10aed8: 5e pop %esi
10aed9: c9 leave
10aeda: e9 1d 21 00 00 jmp 10cffc <_Chain_Insert>
0010ac47 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10ac47: 55 push %ebp
10ac48: 89 e5 mov %esp,%ebp
10ac4a: 83 ec 08 sub $0x8,%esp
10ac4d: 8b 55 08 mov 0x8(%ebp),%edx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ac50: a1 20 73 12 00 mov 0x127320,%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 &&
10ac55: 8b 4a 14 mov 0x14(%edx),%ecx
10ac58: eb 02 jmp 10ac5c <rtems_aio_move_to_work+0x15>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ac5a: 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 &&
10ac5c: 39 48 14 cmp %ecx,0x14(%eax)
10ac5f: 7d 07 jge 10ac68 <rtems_aio_move_to_work+0x21>
10ac61: 3d 24 73 12 00 cmp $0x127324,%eax
10ac66: 75 f2 jne 10ac5a <rtems_aio_move_to_work+0x13><== ALWAYS TAKEN
10ac68: 51 push %ecx
10ac69: 51 push %ecx
10ac6a: 52 push %edx
10ac6b: ff 70 04 pushl 0x4(%eax)
10ac6e: e8 89 23 00 00 call 10cffc <_Chain_Insert>
10ac73: 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);
}
10ac76: c9 leave
10ac77: c3 ret
0010af28 <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)
{
10af28: 55 push %ebp
10af29: 89 e5 mov %esp,%ebp
10af2b: 53 push %ebx
10af2c: 83 ec 04 sub $0x4,%esp
10af2f: 8b 55 08 mov 0x8(%ebp),%edx
10af32: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10af35: 8b 1a mov (%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 );
10af37: 83 c2 04 add $0x4,%edx
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10af3a: b8 02 00 00 00 mov $0x2,%eax
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
10af3f: 39 d3 cmp %edx,%ebx
10af41: 75 08 jne 10af4b <rtems_aio_remove_req+0x23>
10af43: eb 3b jmp 10af80 <rtems_aio_remove_req+0x58>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10af45: 8b 18 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) {
10af47: 39 d3 cmp %edx,%ebx <== NOT EXECUTED
10af49: 74 30 je 10af7b <rtems_aio_remove_req+0x53><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10af4b: 89 d8 mov %ebx,%eax
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) {
10af4d: 39 4b 14 cmp %ecx,0x14(%ebx)
10af50: 75 f3 jne 10af45 <rtems_aio_remove_req+0x1d><== NEVER TAKEN
10af52: 83 ec 0c sub $0xc,%esp
10af55: 53 push %ebx
10af56: e8 65 20 00 00 call 10cfc0 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10af5b: 8b 43 14 mov 0x14(%ebx),%eax
10af5e: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10af65: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10af6c: 89 1c 24 mov %ebx,(%esp)
10af6f: e8 fc cd ff ff call 107d70 <free>
}
return AIO_CANCELED;
10af74: 83 c4 10 add $0x10,%esp
10af77: 31 c0 xor %eax,%eax
10af79: eb 05 jmp 10af80 <rtems_aio_remove_req+0x58>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10af7b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10af80: 8b 5d fc mov -0x4(%ebp),%ebx
10af83: c9 leave
10af84: c3 ret
0010acc8 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10acc8: 55 push %ebp
10acc9: 89 e5 mov %esp,%ebp
10accb: 57 push %edi
10accc: 56 push %esi
10accd: 53 push %ebx
10acce: 83 ec 1c sub $0x1c,%esp
10acd1: 8b 7d 0c mov 0xc(%ebp),%edi
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
10acd4: 8d 75 e4 lea -0x1c(%ebp),%esi
10acd7: eb 13 jmp 10acec <rtems_chain_get_with_wait+0x24>
10acd9: 56 push %esi
10acda: ff 75 10 pushl 0x10(%ebp)
10acdd: 6a 00 push $0x0
10acdf: 57 push %edi
10ace0: e8 0f f5 ff ff call 10a1f4 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10ace5: 83 c4 10 add $0x10,%esp
10ace8: 85 c0 test %eax,%eax
10acea: 75 16 jne 10ad02 <rtems_chain_get_with_wait+0x3a><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10acec: 83 ec 0c sub $0xc,%esp
10acef: ff 75 08 pushl 0x8(%ebp)
10acf2: e8 a5 04 00 00 call 10b19c <_Chain_Get>
10acf7: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10acf9: 83 c4 10 add $0x10,%esp
10acfc: 85 c0 test %eax,%eax
10acfe: 74 d9 je 10acd9 <rtems_chain_get_with_wait+0x11>
10ad00: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10ad02: 8b 55 14 mov 0x14(%ebp),%edx
10ad05: 89 1a mov %ebx,(%edx)
return sc;
}
10ad07: 8d 65 f4 lea -0xc(%ebp),%esp
10ad0a: 5b pop %ebx
10ad0b: 5e pop %esi
10ad0c: 5f pop %edi
10ad0d: c9 leave
10ad0e: c3 ret
0010c7b4 <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)
{
10c7b4: 55 push %ebp
10c7b5: 89 e5 mov %esp,%ebp
10c7b7: 57 push %edi
10c7b8: 56 push %esi
10c7b9: 53 push %ebx
10c7ba: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c7bd: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c7c1: 74 3d je 10c800 <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10c7c3: bb 01 00 00 00 mov $0x1,%ebx
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10c7c8: 8b 04 9d 9c 90 12 00 mov 0x12909c(,%ebx,4),%eax
10c7cf: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c7d2: be 01 00 00 00 mov $0x1,%esi
10c7d7: 85 ff test %edi,%edi
10c7d9: 75 17 jne 10c7f2 <rtems_iterate_over_all_threads+0x3e>
10c7db: eb 1d jmp 10c7fa <rtems_iterate_over_all_threads+0x46>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c7dd: 8b 47 1c mov 0x1c(%edi),%eax
10c7e0: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c7e3: 85 c0 test %eax,%eax
10c7e5: 74 0a je 10c7f1 <rtems_iterate_over_all_threads+0x3d><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c7e7: 83 ec 0c sub $0xc,%esp
10c7ea: 50 push %eax
10c7eb: ff 55 08 call *0x8(%ebp)
10c7ee: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c7f1: 46 inc %esi
10c7f2: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c7f6: 39 c6 cmp %eax,%esi
10c7f8: 76 e3 jbe 10c7dd <rtems_iterate_over_all_threads+0x29>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c7fa: 43 inc %ebx
10c7fb: 83 fb 04 cmp $0x4,%ebx
10c7fe: 75 c8 jne 10c7c8 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c800: 8d 65 f4 lea -0xc(%ebp),%esp
10c803: 5b pop %ebx
10c804: 5e pop %esi
10c805: 5f pop %edi
10c806: c9 leave
10c807: c3 ret
00114840 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
114840: 55 push %ebp
114841: 89 e5 mov %esp,%ebp
114843: 57 push %edi
114844: 56 push %esi
114845: 53 push %ebx
114846: 83 ec 1c sub $0x1c,%esp
114849: 8b 75 0c mov 0xc(%ebp),%esi
11484c: 8b 55 10 mov 0x10(%ebp),%edx
11484f: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
114852: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
114857: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
11485b: 0f 84 ce 00 00 00 je 11492f <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
114861: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
114863: 85 f6 test %esi,%esi
114865: 0f 84 c4 00 00 00 je 11492f <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
11486b: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
11486f: 0f 84 ba 00 00 00 je 11492f <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114875: 85 ff test %edi,%edi
114877: 0f 84 ad 00 00 00 je 11492a <rtems_partition_create+0xea>
11487d: 85 d2 test %edx,%edx
11487f: 0f 84 a5 00 00 00 je 11492a <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
114885: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114887: 39 fa cmp %edi,%edx
114889: 0f 82 a0 00 00 00 jb 11492f <rtems_partition_create+0xef>
11488f: f7 c7 03 00 00 00 test $0x3,%edi
114895: 0f 85 94 00 00 00 jne 11492f <rtems_partition_create+0xef>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
11489b: b0 09 mov $0x9,%al
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
11489d: f7 c6 03 00 00 00 test $0x3,%esi
1148a3: 0f 85 86 00 00 00 jne 11492f <rtems_partition_create+0xef>
1148a9: a1 d4 ef 13 00 mov 0x13efd4,%eax
1148ae: 40 inc %eax
1148af: a3 d4 ef 13 00 mov %eax,0x13efd4
* 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 );
1148b4: 83 ec 0c sub $0xc,%esp
1148b7: 68 64 ee 13 00 push $0x13ee64
1148bc: 89 55 e4 mov %edx,-0x1c(%ebp)
1148bf: e8 20 3e 00 00 call 1186e4 <_Objects_Allocate>
1148c4: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
1148c6: 83 c4 10 add $0x10,%esp
1148c9: 85 c0 test %eax,%eax
1148cb: 8b 55 e4 mov -0x1c(%ebp),%edx
1148ce: 75 0c jne 1148dc <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
1148d0: e8 29 4d 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
1148d5: b8 05 00 00 00 mov $0x5,%eax
1148da: eb 53 jmp 11492f <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
1148dc: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
1148df: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
1148e2: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
1148e5: 8b 45 18 mov 0x18(%ebp),%eax
1148e8: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
1148eb: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
1148f2: 57 push %edi
1148f3: 89 d0 mov %edx,%eax
1148f5: 31 d2 xor %edx,%edx
1148f7: f7 f7 div %edi
1148f9: 50 push %eax
1148fa: 56 push %esi
1148fb: 8d 43 24 lea 0x24(%ebx),%eax
1148fe: 50 push %eax
1148ff: e8 84 2a 00 00 call 117388 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
114904: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
114907: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11490a: 8b 15 80 ee 13 00 mov 0x13ee80,%edx
114910: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
114913: 8b 55 08 mov 0x8(%ebp),%edx
114916: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
114919: 8b 55 1c mov 0x1c(%ebp),%edx
11491c: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
11491e: e8 db 4c 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
114923: 83 c4 10 add $0x10,%esp
114926: 31 c0 xor %eax,%eax
114928: eb 05 jmp 11492f <rtems_partition_create+0xef>
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;
11492a: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11492f: 8d 65 f4 lea -0xc(%ebp),%esp
114932: 5b pop %ebx
114933: 5e pop %esi
114934: 5f pop %edi
114935: c9 leave
114936: c3 ret
00113fb8 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
113fb8: 55 push %ebp
113fb9: 89 e5 mov %esp,%ebp
113fbb: 57 push %edi
113fbc: 56 push %esi
113fbd: 53 push %ebx
113fbe: 83 ec 0c sub $0xc,%esp
113fc1: 8b 75 08 mov 0x8(%ebp),%esi
113fc4: 8b 7d 10 mov 0x10(%ebp),%edi
113fc7: 8b 5d 18 mov 0x18(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
113fca: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
113fcf: 85 f6 test %esi,%esi
113fd1: 74 66 je 114039 <rtems_port_create+0x81><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
113fd3: b0 09 mov $0x9,%al
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
113fd5: 85 db test %ebx,%ebx
113fd7: 74 60 je 114039 <rtems_port_create+0x81><== NEVER TAKEN
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
113fd9: 8b 55 0c mov 0xc(%ebp),%edx
113fdc: 09 fa or %edi,%edx
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
113fde: 80 e2 03 and $0x3,%dl
113fe1: 75 56 jne 114039 <rtems_port_create+0x81><== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
113fe3: a1 d4 ef 13 00 mov 0x13efd4,%eax
113fe8: 40 inc %eax
113fe9: a3 d4 ef 13 00 mov %eax,0x13efd4
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
113fee: 83 ec 0c sub $0xc,%esp
113ff1: 68 24 ee 13 00 push $0x13ee24
113ff6: e8 e9 46 00 00 call 1186e4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
113ffb: 83 c4 10 add $0x10,%esp
113ffe: 85 c0 test %eax,%eax
114000: 75 0c jne 11400e <rtems_port_create+0x56>
_Thread_Enable_dispatch();
114002: e8 f7 55 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
114007: b8 05 00 00 00 mov $0x5,%eax
11400c: eb 2b jmp 114039 <rtems_port_create+0x81>
}
the_port->internal_base = internal_start;
11400e: 8b 55 0c mov 0xc(%ebp),%edx
114011: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
114014: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
114017: 8b 55 14 mov 0x14(%ebp),%edx
11401a: 4a dec %edx
11401b: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
11401e: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
114021: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
114024: 8b 0d 40 ee 13 00 mov 0x13ee40,%ecx
11402a: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
11402d: 89 70 0c mov %esi,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
114030: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
114032: e8 c7 55 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
114037: 31 c0 xor %eax,%eax
}
114039: 8d 65 f4 lea -0xc(%ebp),%esp
11403c: 5b pop %ebx
11403d: 5e pop %esi
11403e: 5f pop %edi
11403f: c9 leave
114040: c3 ret
0010b085 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b085: 55 push %ebp
10b086: 89 e5 mov %esp,%ebp
10b088: 57 push %edi
10b089: 56 push %esi
10b08a: 53 push %ebx
10b08b: 83 ec 30 sub $0x30,%esp
10b08e: 8b 75 08 mov 0x8(%ebp),%esi
10b091: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
10b094: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b097: 50 push %eax
10b098: 56 push %esi
10b099: 68 74 83 12 00 push $0x128374
10b09e: e8 39 1e 00 00 call 10cedc <_Objects_Get>
10b0a3: 89 c7 mov %eax,%edi
switch ( location ) {
10b0a5: 83 c4 10 add $0x10,%esp
10b0a8: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b0ac: 0f 85 3b 01 00 00 jne 10b1ed <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b0b2: a1 8c 89 12 00 mov 0x12898c,%eax
10b0b7: 39 47 40 cmp %eax,0x40(%edi)
10b0ba: 74 0f je 10b0cb <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b0bc: e8 cd 28 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b0c1: be 17 00 00 00 mov $0x17,%esi
10b0c6: e9 27 01 00 00 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b0cb: 85 db test %ebx,%ebx
10b0cd: 75 1b jne 10b0ea <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b0cf: 8b 47 38 mov 0x38(%edi),%eax
10b0d2: 31 f6 xor %esi,%esi
10b0d4: 83 f8 04 cmp $0x4,%eax
10b0d7: 77 07 ja 10b0e0 <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b0d9: 8b 34 85 8c 16 12 00 mov 0x12168c(,%eax,4),%esi
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b0e0: e8 a9 28 00 00 call 10d98e <_Thread_Enable_dispatch>
return( return_value );
10b0e5: e9 08 01 00 00 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b0ea: 9c pushf
10b0eb: fa cli
10b0ec: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b0ef: 8b 47 38 mov 0x38(%edi),%eax
10b0f2: 85 c0 test %eax,%eax
10b0f4: 75 4c jne 10b142 <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0f6: ff 75 d4 pushl -0x2c(%ebp)
10b0f9: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0fa: 83 ec 0c sub $0xc,%esp
10b0fd: 57 push %edi
10b0fe: e8 3f fe ff ff call 10af42 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b103: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b10a: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b111: c7 47 2c fc b3 10 00 movl $0x10b3fc,0x2c(%edi)
the_watchdog->id = id;
10b118: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b11b: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b122: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b125: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b128: 58 pop %eax
10b129: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b12a: 83 c7 10 add $0x10,%edi
10b12d: 57 push %edi
10b12e: 68 28 85 12 00 push $0x128528
10b133: e8 68 35 00 00 call 10e6a0 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b138: e8 51 28 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b13d: 83 c4 10 add $0x10,%esp
10b140: eb 65 jmp 10b1a7 <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b142: 83 f8 02 cmp $0x2,%eax
10b145: 75 64 jne 10b1ab <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b147: 83 ec 0c sub $0xc,%esp
10b14a: 57 push %edi
10b14b: e8 5a fe ff ff call 10afaa <_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;
10b150: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b157: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b15a: ff 75 d4 pushl -0x2c(%ebp)
10b15d: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b15e: a1 8c 89 12 00 mov 0x12898c,%eax
10b163: 8b 57 08 mov 0x8(%edi),%edx
10b166: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b169: 5b pop %ebx
10b16a: 5e pop %esi
10b16b: 68 00 40 00 00 push $0x4000
10b170: 50 push %eax
10b171: e8 8a 2f 00 00 call 10e100 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b176: 9c pushf
10b177: fa cli
10b178: 5a pop %edx
local_state = the_period->state;
10b179: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b17c: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b183: 52 push %edx
10b184: 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 )
10b185: 83 c4 10 add $0x10,%esp
10b188: 83 f8 03 cmp $0x3,%eax
10b18b: 75 15 jne 10b1a2 <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b18d: 51 push %ecx
10b18e: 51 push %ecx
10b18f: 68 00 40 00 00 push $0x4000
10b194: ff 35 8c 89 12 00 pushl 0x12898c
10b19a: e8 d9 24 00 00 call 10d678 <_Thread_Clear_state>
10b19f: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b1a2: e8 e7 27 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b1a7: 31 f6 xor %esi,%esi
10b1a9: eb 47 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1ab: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b1b0: 83 f8 04 cmp $0x4,%eax
10b1b3: 75 3d jne 10b1f2 <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b1b5: 83 ec 0c sub $0xc,%esp
10b1b8: 57 push %edi
10b1b9: e8 ec fd ff ff call 10afaa <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b1be: ff 75 d4 pushl -0x2c(%ebp)
10b1c1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b1c2: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b1c9: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b1cc: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b1cf: 58 pop %eax
10b1d0: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b1d1: 83 c7 10 add $0x10,%edi
10b1d4: 57 push %edi
10b1d5: 68 28 85 12 00 push $0x128528
10b1da: e8 c1 34 00 00 call 10e6a0 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b1df: e8 aa 27 00 00 call 10d98e <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b1e4: 83 c4 10 add $0x10,%esp
10b1e7: 66 be 06 00 mov $0x6,%si
10b1eb: eb 05 jmp 10b1f2 <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1ed: be 04 00 00 00 mov $0x4,%esi
}
10b1f2: 89 f0 mov %esi,%eax
10b1f4: 8d 65 f4 lea -0xc(%ebp),%esp
10b1f7: 5b pop %ebx
10b1f8: 5e pop %esi
10b1f9: 5f pop %edi
10b1fa: c9 leave
10b1fb: c3 ret
0010b1fc <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1fc: 55 push %ebp
10b1fd: 89 e5 mov %esp,%ebp
10b1ff: 57 push %edi
10b200: 56 push %esi
10b201: 53 push %ebx
10b202: 83 ec 7c sub $0x7c,%esp
10b205: 8b 5d 08 mov 0x8(%ebp),%ebx
10b208: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10b20b: 85 ff test %edi,%edi
10b20d: 0f 84 2b 01 00 00 je 10b33e <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b213: 52 push %edx
10b214: 52 push %edx
10b215: 68 a0 16 12 00 push $0x1216a0
10b21a: 53 push %ebx
10b21b: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b21d: 5e pop %esi
10b21e: 58 pop %eax
10b21f: 68 be 16 12 00 push $0x1216be
10b224: 53 push %ebx
10b225: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b227: 5a pop %edx
10b228: 59 pop %ecx
10b229: 68 e0 16 12 00 push $0x1216e0
10b22e: 53 push %ebx
10b22f: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b231: 5e pop %esi
10b232: 58 pop %eax
10b233: 68 03 17 12 00 push $0x121703
10b238: 53 push %ebx
10b239: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b23b: 5a pop %edx
10b23c: 59 pop %ecx
10b23d: 68 4e 17 12 00 push $0x12174e
10b242: 53 push %ebx
10b243: ff d7 call *%edi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b245: 8b 35 7c 83 12 00 mov 0x12837c,%esi
10b24b: 83 c4 10 add $0x10,%esp
10b24e: e9 df 00 00 00 jmp 10b332 <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b253: 50 push %eax
10b254: 50 push %eax
10b255: 8d 45 88 lea -0x78(%ebp),%eax
10b258: 50 push %eax
10b259: 56 push %esi
10b25a: e8 c1 56 00 00 call 110920 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b25f: 83 c4 10 add $0x10,%esp
10b262: 85 c0 test %eax,%eax
10b264: 0f 85 c7 00 00 00 jne 10b331 <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
#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 );
10b26a: 51 push %ecx
10b26b: 51 push %ecx
10b26c: 8d 55 c0 lea -0x40(%ebp),%edx
10b26f: 52 push %edx
10b270: 56 push %esi
10b271: e8 4e 57 00 00 call 1109c4 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b276: 83 c4 0c add $0xc,%esp
10b279: 8d 45 e3 lea -0x1d(%ebp),%eax
10b27c: 50 push %eax
10b27d: 6a 05 push $0x5
10b27f: ff 75 c0 pushl -0x40(%ebp)
10b282: e8 01 02 00 00 call 10b488 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b287: 58 pop %eax
10b288: 5a pop %edx
10b289: ff 75 8c pushl -0x74(%ebp)
10b28c: ff 75 88 pushl -0x78(%ebp)
10b28f: 8d 55 e3 lea -0x1d(%ebp),%edx
10b292: 52 push %edx
10b293: 56 push %esi
10b294: 68 9a 17 12 00 push $0x12179a
10b299: 53 push %ebx
10b29a: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b29c: 8b 45 88 mov -0x78(%ebp),%eax
10b29f: 83 c4 20 add $0x20,%esp
10b2a2: 85 c0 test %eax,%eax
10b2a4: 75 0f jne 10b2b5 <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b2a6: 51 push %ecx
10b2a7: 51 push %ecx
10b2a8: 68 04 1a 12 00 push $0x121a04
10b2ad: 53 push %ebx
10b2ae: ff d7 call *%edi
continue;
10b2b0: 83 c4 10 add $0x10,%esp
10b2b3: eb 7c jmp 10b331 <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
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 );
10b2b5: 52 push %edx
10b2b6: 8d 55 d8 lea -0x28(%ebp),%edx
10b2b9: 52 push %edx
10b2ba: 50 push %eax
10b2bb: 8d 45 a0 lea -0x60(%ebp),%eax
10b2be: 50 push %eax
10b2bf: e8 b0 30 00 00 call 10e374 <_Timespec_Divide_by_integer>
(*print)( context,
10b2c4: 8b 45 dc mov -0x24(%ebp),%eax
10b2c7: b9 e8 03 00 00 mov $0x3e8,%ecx
10b2cc: 99 cltd
10b2cd: f7 f9 idiv %ecx
10b2cf: 50 push %eax
10b2d0: ff 75 d8 pushl -0x28(%ebp)
10b2d3: 8b 45 9c mov -0x64(%ebp),%eax
10b2d6: 99 cltd
10b2d7: f7 f9 idiv %ecx
10b2d9: 50 push %eax
10b2da: ff 75 98 pushl -0x68(%ebp)
10b2dd: 8b 45 94 mov -0x6c(%ebp),%eax
10b2e0: 99 cltd
10b2e1: f7 f9 idiv %ecx
10b2e3: 50 push %eax
10b2e4: ff 75 90 pushl -0x70(%ebp)
10b2e7: 68 b1 17 12 00 push $0x1217b1
10b2ec: 53 push %ebx
10b2ed: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b2f0: ff d7 call *%edi
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2f2: 83 c4 2c add $0x2c,%esp
10b2f5: 8d 55 d8 lea -0x28(%ebp),%edx
10b2f8: 52 push %edx
10b2f9: ff 75 88 pushl -0x78(%ebp)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
10b2fc: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2ff: 50 push %eax
10b300: e8 6f 30 00 00 call 10e374 <_Timespec_Divide_by_integer>
(*print)( context,
10b305: 8b 45 dc mov -0x24(%ebp),%eax
10b308: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b30b: 99 cltd
10b30c: f7 f9 idiv %ecx
10b30e: 50 push %eax
10b30f: ff 75 d8 pushl -0x28(%ebp)
10b312: 8b 45 b4 mov -0x4c(%ebp),%eax
10b315: 99 cltd
10b316: f7 f9 idiv %ecx
10b318: 50 push %eax
10b319: ff 75 b0 pushl -0x50(%ebp)
10b31c: 8b 45 ac mov -0x54(%ebp),%eax
10b31f: 99 cltd
10b320: f7 f9 idiv %ecx
10b322: 50 push %eax
10b323: ff 75 a8 pushl -0x58(%ebp)
10b326: 68 d0 17 12 00 push $0x1217d0
10b32b: 53 push %ebx
10b32c: ff d7 call *%edi
10b32e: 83 c4 30 add $0x30,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10b331: 46 inc %esi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b332: 3b 35 80 83 12 00 cmp 0x128380,%esi
10b338: 0f 86 15 ff ff ff jbe 10b253 <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b33e: 8d 65 f4 lea -0xc(%ebp),%esp
10b341: 5b pop %ebx
10b342: 5e pop %esi
10b343: 5f pop %edi
10b344: c9 leave
10b345: c3 ret
00115ba0 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115ba0: 55 push %ebp
115ba1: 89 e5 mov %esp,%ebp
115ba3: 53 push %ebx
115ba4: 83 ec 14 sub $0x14,%esp
115ba7: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115baa: b8 0a 00 00 00 mov $0xa,%eax
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
115baf: 85 db test %ebx,%ebx
115bb1: 74 6d je 115c20 <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115bb3: 50 push %eax
115bb4: 50 push %eax
115bb5: 8d 45 f4 lea -0xc(%ebp),%eax
115bb8: 50 push %eax
115bb9: ff 75 08 pushl 0x8(%ebp)
115bbc: e8 5f 3a 00 00 call 119620 <_Thread_Get>
switch ( location ) {
115bc1: 83 c4 10 add $0x10,%esp
115bc4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115bc8: 75 51 jne 115c1b <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115bca: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115bd0: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115bd4: 74 39 je 115c0f <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115bd6: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115bda: 74 22 je 115bfe <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115bdc: 9c pushf
115bdd: fa cli
115bde: 59 pop %ecx
*signal_set |= signals;
115bdf: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115be2: 51 push %ecx
115be3: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115be4: 83 3d 00 f5 13 00 00 cmpl $0x0,0x13f500
115beb: 74 19 je 115c06 <rtems_signal_send+0x66>
115bed: 3b 05 04 f5 13 00 cmp 0x13f504,%eax
115bf3: 75 11 jne 115c06 <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115bf5: c6 05 10 f5 13 00 01 movb $0x1,0x13f510
115bfc: eb 08 jmp 115c06 <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115bfe: 9c pushf
115bff: fa cli
115c00: 58 pop %eax
*signal_set |= signals;
115c01: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115c04: 50 push %eax
115c05: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115c06: e8 f3 39 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115c0b: 31 c0 xor %eax,%eax
115c0d: eb 11 jmp 115c20 <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115c0f: e8 ea 39 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115c14: b8 0b 00 00 00 mov $0xb,%eax
115c19: eb 05 jmp 115c20 <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115c1b: b8 04 00 00 00 mov $0x4,%eax
}
115c20: 8b 5d fc mov -0x4(%ebp),%ebx
115c23: c9 leave
115c24: c3 ret
00110d68 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110d68: 55 push %ebp
110d69: 89 e5 mov %esp,%ebp
110d6b: 57 push %edi
110d6c: 56 push %esi
110d6d: 53 push %ebx
110d6e: 83 ec 1c sub $0x1c,%esp
110d71: 8b 4d 10 mov 0x10(%ebp),%ecx
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
110d74: b8 09 00 00 00 mov $0x9,%eax
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
110d79: 85 c9 test %ecx,%ecx
110d7b: 0f 84 fb 00 00 00 je 110e7c <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110d81: 8b 35 68 58 12 00 mov 0x125868,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110d87: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d8d: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110d91: 19 ff sbb %edi,%edi
110d93: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110d99: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110d9d: 74 06 je 110da5 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110d9f: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110da5: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110da9: 19 d2 sbb %edx,%edx
110dab: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110db1: 89 55 e4 mov %edx,-0x1c(%ebp)
110db4: 89 4d e0 mov %ecx,-0x20(%ebp)
110db7: e8 59 c6 ff ff call 10d415 <_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;
110dbc: 8b 55 e4 mov -0x1c(%ebp),%edx
110dbf: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110dc1: 09 f8 or %edi,%eax
110dc3: 8b 4d e0 mov -0x20(%ebp),%ecx
110dc6: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110dc8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110dcf: 74 0b je 110ddc <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110dd1: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110dd8: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110ddc: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110de3: 74 21 je 110e06 <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110de5: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110dec: 74 11 je 110dff <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110dee: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110df5: a1 10 53 12 00 mov 0x125310,%eax
110dfa: 89 46 78 mov %eax,0x78(%esi)
110dfd: eb 07 jmp 110e06 <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110dff: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110e06: f6 45 0c 01 testb $0x1,0xc(%ebp)
110e0a: 74 0a je 110e16 <rtems_task_mode+0xae>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
110e0c: f6 45 08 01 testb $0x1,0x8(%ebp)
110e10: 74 03 je 110e15 <rtems_task_mode+0xad>
110e12: fa cli
110e13: eb 01 jmp 110e16 <rtems_task_mode+0xae>
110e15: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e16: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110e18: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110e1f: 74 2a je 110e4b <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110e21: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110e28: 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 ) {
110e2b: 3a 43 08 cmp 0x8(%ebx),%al
110e2e: 74 1b je 110e4b <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110e30: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110e33: 9c pushf
110e34: fa cli
110e35: 58 pop %eax
_signals = information->signals_pending;
110e36: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110e39: 8b 4b 14 mov 0x14(%ebx),%ecx
110e3c: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110e3f: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110e42: 50 push %eax
110e43: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e44: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110e48: 0f 95 c1 setne %cl
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
110e4b: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110e4d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
110e54: 75 26 jne 110e7c <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110e56: 8b 15 68 58 12 00 mov 0x125868,%edx
if ( are_signals_pending ||
110e5c: 84 c9 test %cl,%cl
110e5e: 75 0e jne 110e6e <rtems_task_mode+0x106>
110e60: 3b 15 6c 58 12 00 cmp 0x12586c,%edx
110e66: 74 14 je 110e7c <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110e68: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110e6c: 74 0e je 110e7c <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110e6e: c6 05 74 58 12 00 01 movb $0x1,0x125874
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110e75: e8 46 b2 ff ff call 10c0c0 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110e7a: 31 c0 xor %eax,%eax
}
110e7c: 83 c4 1c add $0x1c,%esp
110e7f: 5b pop %ebx
110e80: 5e pop %esi
110e81: 5f pop %edi
110e82: c9 leave
110e83: c3 ret
0010dd84 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd84: 55 push %ebp
10dd85: 89 e5 mov %esp,%ebp
10dd87: 56 push %esi
10dd88: 53 push %ebx
10dd89: 83 ec 10 sub $0x10,%esp
10dd8c: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd8f: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd92: 85 db test %ebx,%ebx
10dd94: 74 10 je 10dda6 <rtems_task_set_priority+0x22>
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 ) );
10dd96: 0f b6 15 24 42 12 00 movzbl 0x124224,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd9d: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dda2: 39 d3 cmp %edx,%ebx
10dda4: 77 52 ja 10ddf8 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dda6: b8 09 00 00 00 mov $0x9,%eax
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10ddab: 85 f6 test %esi,%esi
10ddad: 74 49 je 10ddf8 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10ddaf: 51 push %ecx
10ddb0: 51 push %ecx
10ddb1: 8d 45 f4 lea -0xc(%ebp),%eax
10ddb4: 50 push %eax
10ddb5: ff 75 08 pushl 0x8(%ebp)
10ddb8: e8 cb 1e 00 00 call 10fc88 <_Thread_Get>
switch ( location ) {
10ddbd: 83 c4 10 add $0x10,%esp
10ddc0: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10ddc4: 75 2d jne 10ddf3 <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10ddc6: 8b 50 14 mov 0x14(%eax),%edx
10ddc9: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10ddcb: 85 db test %ebx,%ebx
10ddcd: 74 1b je 10ddea <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10ddcf: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10ddd2: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ddd6: 74 05 je 10dddd <rtems_task_set_priority+0x59>
10ddd8: 39 58 14 cmp %ebx,0x14(%eax)
10dddb: 76 0d jbe 10ddea <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dddd: 52 push %edx
10ddde: 6a 00 push $0x0
10dde0: 53 push %ebx
10dde1: 50 push %eax
10dde2: e8 a9 1a 00 00 call 10f890 <_Thread_Change_priority>
10dde7: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10ddea: e8 77 1e 00 00 call 10fc66 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ddef: 31 c0 xor %eax,%eax
10ddf1: eb 05 jmp 10ddf8 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ddf3: b8 04 00 00 00 mov $0x4,%eax
}
10ddf8: 8d 65 f8 lea -0x8(%ebp),%esp
10ddfb: 5b pop %ebx
10ddfc: 5e pop %esi
10ddfd: c9 leave
10ddfe: c3 ret
001163ec <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1163ec: 55 push %ebp
1163ed: 89 e5 mov %esp,%ebp
1163ef: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1163f2: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1163f5: 50 push %eax
1163f6: ff 75 08 pushl 0x8(%ebp)
1163f9: 68 1c f9 13 00 push $0x13f91c
1163fe: e8 49 27 00 00 call 118b4c <_Objects_Get>
switch ( location ) {
116403: 83 c4 10 add $0x10,%esp
116406: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
11640a: 75 1e jne 11642a <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
11640c: 83 78 38 04 cmpl $0x4,0x38(%eax)
116410: 74 0f je 116421 <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
116412: 83 ec 0c sub $0xc,%esp
116415: 83 c0 10 add $0x10,%eax
116418: 50 push %eax
116419: e8 7e 41 00 00 call 11a59c <_Watchdog_Remove>
11641e: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
116421: e8 d8 31 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116426: 31 c0 xor %eax,%eax
116428: eb 05 jmp 11642f <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11642a: b8 04 00 00 00 mov $0x4,%eax
}
11642f: c9 leave
116430: c3 ret
0011684c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
11684c: 55 push %ebp
11684d: 89 e5 mov %esp,%ebp
11684f: 57 push %edi
116850: 56 push %esi
116851: 53 push %ebx
116852: 83 ec 1c sub $0x1c,%esp
116855: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116858: 8b 35 5c f9 13 00 mov 0x13f95c,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11685e: bb 0e 00 00 00 mov $0xe,%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
116863: 85 f6 test %esi,%esi
116865: 0f 84 b1 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
11686b: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
11686d: 80 3d e8 ef 13 00 00 cmpb $0x0,0x13efe8
116874: 0f 84 a2 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
11687a: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
11687c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
116880: 0f 84 96 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116886: 83 ec 0c sub $0xc,%esp
116889: 57 push %edi
11688a: e8 b5 d6 ff ff call 113f44 <_TOD_Validate>
11688f: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
116892: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116894: 84 c0 test %al,%al
116896: 0f 84 80 00 00 00 je 11691c <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
11689c: 83 ec 0c sub $0xc,%esp
11689f: 57 push %edi
1168a0: e8 37 d6 ff ff call 113edc <_TOD_To_seconds>
1168a5: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
1168a7: 83 c4 10 add $0x10,%esp
1168aa: 3b 05 60 f0 13 00 cmp 0x13f060,%eax
1168b0: 76 6a jbe 11691c <rtems_timer_server_fire_when+0xd0>
1168b2: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
1168b3: 8d 45 e4 lea -0x1c(%ebp),%eax
1168b6: 50 push %eax
1168b7: ff 75 08 pushl 0x8(%ebp)
1168ba: 68 1c f9 13 00 push $0x13f91c
1168bf: e8 88 22 00 00 call 118b4c <_Objects_Get>
1168c4: 89 c3 mov %eax,%ebx
switch ( location ) {
1168c6: 83 c4 10 add $0x10,%esp
1168c9: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
1168cd: 75 48 jne 116917 <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1168cf: 83 ec 0c sub $0xc,%esp
1168d2: 8d 40 10 lea 0x10(%eax),%eax
1168d5: 50 push %eax
1168d6: e8 c1 3c 00 00 call 11a59c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
1168db: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1168e2: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
1168e9: 8b 45 10 mov 0x10(%ebp),%eax
1168ec: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
1168ef: 8b 45 08 mov 0x8(%ebp),%eax
1168f2: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
1168f5: 8b 45 14 mov 0x14(%ebp),%eax
1168f8: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
1168fb: 2b 3d 60 f0 13 00 sub 0x13f060,%edi
116901: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
116904: 58 pop %eax
116905: 5a pop %edx
116906: 53 push %ebx
116907: 56 push %esi
116908: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
11690b: e8 ee 2c 00 00 call 1195fe <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116910: 83 c4 10 add $0x10,%esp
116913: 31 db xor %ebx,%ebx
116915: eb 05 jmp 11691c <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116917: bb 04 00 00 00 mov $0x4,%ebx
}
11691c: 89 d8 mov %ebx,%eax
11691e: 8d 65 f4 lea -0xc(%ebp),%esp
116921: 5b pop %ebx
116922: 5e pop %esi
116923: 5f pop %edi
116924: c9 leave
116925: c3 ret
0010a948 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a948: 55 push %ebp
10a949: 89 e5 mov %esp,%ebp
10a94b: 83 ec 08 sub $0x8,%esp
10a94e: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a951: 83 f9 04 cmp $0x4,%ecx
10a954: 77 0b ja 10a961 <sched_get_priority_max+0x19>
10a956: b8 01 00 00 00 mov $0x1,%eax
10a95b: d3 e0 shl %cl,%eax
10a95d: a8 17 test $0x17,%al
10a95f: 75 10 jne 10a971 <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a961: e8 e2 73 00 00 call 111d48 <__errno>
10a966: c7 00 16 00 00 00 movl $0x16,(%eax)
10a96c: 83 c8 ff or $0xffffffff,%eax
10a96f: eb 08 jmp 10a979 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a971: 0f b6 05 48 22 12 00 movzbl 0x122248,%eax
10a978: 48 dec %eax
}
10a979: c9 leave
10a97a: c3 ret
0010a97c <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a97c: 55 push %ebp
10a97d: 89 e5 mov %esp,%ebp
10a97f: 83 ec 08 sub $0x8,%esp
10a982: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a985: 83 f9 04 cmp $0x4,%ecx
10a988: 77 11 ja 10a99b <sched_get_priority_min+0x1f>
10a98a: ba 01 00 00 00 mov $0x1,%edx
10a98f: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a991: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a996: 80 e2 17 and $0x17,%dl
10a999: 75 0e jne 10a9a9 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a99b: e8 a8 73 00 00 call 111d48 <__errno>
10a9a0: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9a6: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a9a9: c9 leave
10a9aa: c3 ret
0010a9ac <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a9ac: 55 push %ebp
10a9ad: 89 e5 mov %esp,%ebp
10a9af: 56 push %esi
10a9b0: 53 push %ebx
10a9b1: 8b 75 08 mov 0x8(%ebp),%esi
10a9b4: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a9b7: 85 f6 test %esi,%esi
10a9b9: 74 16 je 10a9d1 <sched_rr_get_interval+0x25><== NEVER TAKEN
10a9bb: e8 90 d0 ff ff call 107a50 <getpid>
10a9c0: 39 c6 cmp %eax,%esi
10a9c2: 74 0d je 10a9d1 <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a9c4: e8 7f 73 00 00 call 111d48 <__errno>
10a9c9: c7 00 03 00 00 00 movl $0x3,(%eax)
10a9cf: eb 0f jmp 10a9e0 <sched_rr_get_interval+0x34>
if ( !interval )
10a9d1: 85 db test %ebx,%ebx
10a9d3: 75 10 jne 10a9e5 <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a9d5: e8 6e 73 00 00 call 111d48 <__errno>
10a9da: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9e0: 83 c8 ff or $0xffffffff,%eax
10a9e3: eb 13 jmp 10a9f8 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a9e5: 50 push %eax
10a9e6: 50 push %eax
10a9e7: 53 push %ebx
10a9e8: ff 35 20 63 12 00 pushl 0x126320
10a9ee: e8 b9 30 00 00 call 10daac <_Timespec_From_ticks>
return 0;
10a9f3: 83 c4 10 add $0x10,%esp
10a9f6: 31 c0 xor %eax,%eax
}
10a9f8: 8d 65 f8 lea -0x8(%ebp),%esp
10a9fb: 5b pop %ebx
10a9fc: 5e pop %esi
10a9fd: c9 leave
10a9fe: c3 ret
0010d088 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d088: 55 push %ebp
10d089: 89 e5 mov %esp,%ebp
10d08b: 57 push %edi
10d08c: 56 push %esi
10d08d: 53 push %ebx
10d08e: 83 ec 2c sub $0x2c,%esp
10d091: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d094: a1 a8 af 12 00 mov 0x12afa8,%eax
10d099: 40 inc %eax
10d09a: a3 a8 af 12 00 mov %eax,0x12afa8
va_list arg;
mode_t mode;
unsigned int value = 0;
10d09f: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d0a1: 8b 45 0c mov 0xc(%ebp),%eax
10d0a4: 25 00 02 00 00 and $0x200,%eax
10d0a9: 89 45 d4 mov %eax,-0x2c(%ebp)
10d0ac: 74 03 je 10d0b1 <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d0ae: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d0b1: 52 push %edx
10d0b2: 52 push %edx
10d0b3: 8d 45 e4 lea -0x1c(%ebp),%eax
10d0b6: 50 push %eax
10d0b7: 56 push %esi
10d0b8: e8 b3 59 00 00 call 112a70 <_POSIX_Semaphore_Name_to_id>
10d0bd: 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 ) {
10d0bf: 83 c4 10 add $0x10,%esp
10d0c2: 85 c0 test %eax,%eax
10d0c4: 74 19 je 10d0df <sem_open+0x57>
/*
* 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) ) ) {
10d0c6: 83 f8 02 cmp $0x2,%eax
10d0c9: 75 06 jne 10d0d1 <sem_open+0x49> <== NEVER TAKEN
10d0cb: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d0cf: 75 59 jne 10d12a <sem_open+0xa2>
_Thread_Enable_dispatch();
10d0d1: e8 3c 28 00 00 call 10f912 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d0d6: e8 69 7f 00 00 call 115044 <__errno>
10d0db: 89 18 mov %ebx,(%eax)
10d0dd: eb 1f jmp 10d0fe <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d0df: 8b 45 0c mov 0xc(%ebp),%eax
10d0e2: 25 00 0a 00 00 and $0xa00,%eax
10d0e7: 3d 00 0a 00 00 cmp $0xa00,%eax
10d0ec: 75 15 jne 10d103 <sem_open+0x7b>
_Thread_Enable_dispatch();
10d0ee: e8 1f 28 00 00 call 10f912 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d0f3: e8 4c 7f 00 00 call 115044 <__errno>
10d0f8: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0fe: 83 c8 ff or $0xffffffff,%eax
10d101: eb 4a jmp 10d14d <sem_open+0xc5>
10d103: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d104: 8d 45 dc lea -0x24(%ebp),%eax
10d107: 50 push %eax
10d108: ff 75 e4 pushl -0x1c(%ebp)
10d10b: 68 4c b2 12 00 push $0x12b24c
10d110: e8 d7 1c 00 00 call 10edec <_Objects_Get>
10d115: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d118: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d11b: e8 f2 27 00 00 call 10f912 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d120: e8 ed 27 00 00 call 10f912 <_Thread_Enable_dispatch>
goto return_id;
10d125: 83 c4 10 add $0x10,%esp
10d128: eb 1d jmp 10d147 <sem_open+0xbf>
/*
* 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(
10d12a: 8d 45 e0 lea -0x20(%ebp),%eax
10d12d: 50 push %eax
10d12e: 57 push %edi
10d12f: 6a 00 push $0x0
10d131: 56 push %esi
10d132: e8 05 58 00 00 call 11293c <_POSIX_Semaphore_Create_support>
10d137: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d139: e8 d4 27 00 00 call 10f912 <_Thread_Enable_dispatch>
if ( status == -1 )
10d13e: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d141: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d144: 43 inc %ebx
10d145: 74 06 je 10d14d <sem_open+0xc5>
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;
10d147: 8b 45 e0 mov -0x20(%ebp),%eax
10d14a: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d14d: 8d 65 f4 lea -0xc(%ebp),%esp
10d150: 5b pop %ebx
10d151: 5e pop %esi
10d152: 5f pop %edi
10d153: c9 leave
10d154: c3 ret
0010a820 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a820: 55 push %ebp
10a821: 89 e5 mov %esp,%ebp
10a823: 57 push %edi
10a824: 56 push %esi
10a825: 53 push %ebx
10a826: 83 ec 1c sub $0x1c,%esp
10a829: 8b 5d 08 mov 0x8(%ebp),%ebx
10a82c: 8b 55 0c mov 0xc(%ebp),%edx
10a82f: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a832: 85 c0 test %eax,%eax
10a834: 74 12 je 10a848 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a836: 6b f3 0c imul $0xc,%ebx,%esi
10a839: 81 c6 fc 78 12 00 add $0x1278fc,%esi
10a83f: b9 03 00 00 00 mov $0x3,%ecx
10a844: 89 c7 mov %eax,%edi
10a846: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a848: 85 db test %ebx,%ebx
10a84a: 74 0d je 10a859 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a84c: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a84f: 83 f8 1f cmp $0x1f,%eax
10a852: 77 05 ja 10a859 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a854: 83 fb 09 cmp $0x9,%ebx
10a857: 75 10 jne 10a869 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a859: e8 6e 77 00 00 call 111fcc <__errno>
10a85e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a864: 83 c8 ff or $0xffffffff,%eax
10a867: eb 57 jmp 10a8c0 <sigaction+0xa0>
* 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;
10a869: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a86b: 85 d2 test %edx,%edx
10a86d: 74 51 je 10a8c0 <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 );
10a86f: 9c pushf
10a870: fa cli
10a871: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a874: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a878: 75 1a jne 10a894 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a87a: 6b f3 0c imul $0xc,%ebx,%esi
10a87d: 8d 86 fc 78 12 00 lea 0x1278fc(%esi),%eax
10a883: 81 c6 70 12 12 00 add $0x121270,%esi
10a889: b9 03 00 00 00 mov $0x3,%ecx
10a88e: 89 c7 mov %eax,%edi
10a890: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a892: eb 26 jmp 10a8ba <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a894: 83 ec 0c sub $0xc,%esp
10a897: 53 push %ebx
10a898: 89 55 e0 mov %edx,-0x20(%ebp)
10a89b: e8 bc 4e 00 00 call 10f75c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a8a0: 6b db 0c imul $0xc,%ebx,%ebx
10a8a3: 81 c3 fc 78 12 00 add $0x1278fc,%ebx
10a8a9: b9 03 00 00 00 mov $0x3,%ecx
10a8ae: 8b 55 e0 mov -0x20(%ebp),%edx
10a8b1: 89 df mov %ebx,%edi
10a8b3: 89 d6 mov %edx,%esi
10a8b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a8b7: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a8ba: ff 75 e4 pushl -0x1c(%ebp)
10a8bd: 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;
10a8be: 31 c0 xor %eax,%eax
}
10a8c0: 8d 65 f4 lea -0xc(%ebp),%esp
10a8c3: 5b pop %ebx
10a8c4: 5e pop %esi
10a8c5: 5f pop %edi
10a8c6: c9 leave
10a8c7: c3 ret
0010abe7 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10abe7: 55 push %ebp
10abe8: 89 e5 mov %esp,%ebp
10abea: 57 push %edi
10abeb: 56 push %esi
10abec: 53 push %ebx
10abed: 83 ec 3c sub $0x3c,%esp
10abf0: 8b 75 08 mov 0x8(%ebp),%esi
10abf3: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10abf6: 85 f6 test %esi,%esi
10abf8: 74 24 je 10ac1e <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abfa: 85 db test %ebx,%ebx
10abfc: 74 30 je 10ac2e <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abfe: 83 ec 0c sub $0xc,%esp
10ac01: 53 push %ebx
10ac02: e8 5d 31 00 00 call 10dd64 <_Timespec_Is_valid>
10ac07: 83 c4 10 add $0x10,%esp
10ac0a: 84 c0 test %al,%al
10ac0c: 74 10 je 10ac1e <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10ac0e: 83 ec 0c sub $0xc,%esp
10ac11: 53 push %ebx
10ac12: e8 a5 31 00 00 call 10ddbc <_Timespec_To_ticks>
if ( !interval )
10ac17: 83 c4 10 add $0x10,%esp
10ac1a: 85 c0 test %eax,%eax
10ac1c: 75 12 jne 10ac30 <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10ac1e: e8 51 79 00 00 call 112574 <__errno>
10ac23: c7 00 16 00 00 00 movl $0x16,(%eax)
10ac29: e9 39 01 00 00 jmp 10ad67 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10ac2e: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10ac30: 8b 7d 0c mov 0xc(%ebp),%edi
10ac33: 85 ff test %edi,%edi
10ac35: 75 03 jne 10ac3a <sigtimedwait+0x53>
10ac37: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10ac3a: 8b 15 c8 78 12 00 mov 0x1278c8,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ac40: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
10ac46: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10ac49: 9c pushf
10ac4a: fa cli
10ac4b: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10ac4e: 8b 1e mov (%esi),%ebx
10ac50: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac53: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac56: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac5c: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac5f: 74 32 je 10ac93 <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac61: 83 ec 0c sub $0xc,%esp
10ac64: 51 push %ecx
10ac65: e8 3e ff ff ff call 10aba8 <_POSIX_signals_Get_lowest>
10ac6a: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac6c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac73: 6a 00 push $0x0
10ac75: 57 push %edi
10ac76: 50 push %eax
10ac77: 53 push %ebx
10ac78: e8 2b 51 00 00 call 10fda8 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac7d: ff 75 d0 pushl -0x30(%ebp)
10ac80: 9d popf
the_info->si_code = SI_USER;
10ac81: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac88: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac8f: 8b 1f mov (%edi),%ebx
10ac91: eb 3d jmp 10acd0 <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac93: 8b 0d f0 7a 12 00 mov 0x127af0,%ecx
10ac99: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac9c: 74 3a je 10acd8 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac9e: 83 ec 0c sub $0xc,%esp
10aca1: 51 push %ecx
10aca2: e8 01 ff ff ff call 10aba8 <_POSIX_signals_Get_lowest>
10aca7: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10aca9: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10acb0: 6a 01 push $0x1
10acb2: 57 push %edi
10acb3: 50 push %eax
10acb4: ff 75 d4 pushl -0x2c(%ebp)
10acb7: e8 ec 50 00 00 call 10fda8 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10acbc: ff 75 d0 pushl -0x30(%ebp)
10acbf: 9d popf
the_info->si_signo = signo;
10acc0: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10acc2: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10acc9: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10acd0: 83 c4 20 add $0x20,%esp
10acd3: e9 92 00 00 00 jmp 10ad6a <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10acd8: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10acde: 8b 0d a0 73 12 00 mov 0x1273a0,%ecx
10ace4: 41 inc %ecx
10ace5: 89 0d a0 73 12 00 mov %ecx,0x1273a0
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10aceb: c7 42 44 88 7a 12 00 movl $0x127a88,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10acf2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10acf9: 8b 0e mov (%esi),%ecx
10acfb: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acfe: 89 7a 28 mov %edi,0x28(%edx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10ad01: c7 05 b8 7a 12 00 01 movl $0x1,0x127ab8
10ad08: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10ad0b: ff 75 d0 pushl -0x30(%ebp)
10ad0e: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10ad0f: 52 push %edx
10ad10: 68 e0 da 10 00 push $0x10dae0
10ad15: 50 push %eax
10ad16: 68 88 7a 12 00 push $0x127a88
10ad1b: e8 e4 2a 00 00 call 10d804 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10ad20: e8 95 26 00 00 call 10d3ba <_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 );
10ad25: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ad2c: 6a 00 push $0x0
10ad2e: 57 push %edi
10ad2f: ff 37 pushl (%edi)
10ad31: ff 75 d4 pushl -0x2c(%ebp)
10ad34: e8 6f 50 00 00 call 10fda8 <_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)
10ad39: 83 c4 20 add $0x20,%esp
10ad3c: a1 c8 78 12 00 mov 0x1278c8,%eax
10ad41: 83 78 34 04 cmpl $0x4,0x34(%eax)
10ad45: 75 10 jne 10ad57 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10ad47: 8b 1f mov (%edi),%ebx
10ad49: 8d 4b ff lea -0x1(%ebx),%ecx
10ad4c: b8 01 00 00 00 mov $0x1,%eax
10ad51: d3 e0 shl %cl,%eax
10ad53: 85 06 test %eax,(%esi)
10ad55: 75 13 jne 10ad6a <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad57: e8 18 78 00 00 call 112574 <__errno>
10ad5c: 8b 15 c8 78 12 00 mov 0x1278c8,%edx
10ad62: 8b 52 34 mov 0x34(%edx),%edx
10ad65: 89 10 mov %edx,(%eax)
return -1;
10ad67: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad6a: 89 d8 mov %ebx,%eax
10ad6c: 8d 65 f4 lea -0xc(%ebp),%esp
10ad6f: 5b pop %ebx
10ad70: 5e pop %esi
10ad71: 5f pop %edi
10ad72: c9 leave
10ad73: c3 ret
0010ca68 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca68: 55 push %ebp
10ca69: 89 e5 mov %esp,%ebp
10ca6b: 53 push %ebx
10ca6c: 83 ec 08 sub $0x8,%esp
10ca6f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca72: 6a 00 push $0x0
10ca74: 6a 00 push $0x0
10ca76: ff 75 08 pushl 0x8(%ebp)
10ca79: e8 45 fe ff ff call 10c8c3 <sigtimedwait>
10ca7e: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca80: 83 c4 10 add $0x10,%esp
10ca83: 83 f8 ff cmp $0xffffffff,%eax
10ca86: 74 0a je 10ca92 <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca88: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca8a: 85 db test %ebx,%ebx
10ca8c: 74 0b je 10ca99 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca8e: 89 13 mov %edx,(%ebx)
10ca90: eb 07 jmp 10ca99 <sigwait+0x31>
return 0;
}
return errno;
10ca92: e8 05 73 00 00 call 113d9c <__errno>
10ca97: 8b 00 mov (%eax),%eax
}
10ca99: 8b 5d fc mov -0x4(%ebp),%ebx
10ca9c: c9 leave
10ca9d: c3 ret
0010a084 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a084: 55 push %ebp
10a085: 89 e5 mov %esp,%ebp
10a087: 56 push %esi
10a088: 53 push %ebx
10a089: 8b 5d 0c mov 0xc(%ebp),%ebx
10a08c: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a08f: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a093: 75 1d jne 10a0b2 <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a095: 85 f6 test %esi,%esi
10a097: 74 19 je 10a0b2 <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a099: 85 db test %ebx,%ebx
10a09b: 74 22 je 10a0bf <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a09d: 8b 03 mov (%ebx),%eax
10a09f: 48 dec %eax
10a0a0: 83 f8 01 cmp $0x1,%eax
10a0a3: 77 0d ja 10a0b2 <timer_create+0x2e> <== 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 )
10a0a5: 8b 43 04 mov 0x4(%ebx),%eax
10a0a8: 85 c0 test %eax,%eax
10a0aa: 74 06 je 10a0b2 <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a0ac: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a0ad: 83 f8 1f cmp $0x1f,%eax
10a0b0: 76 0d jbe 10a0bf <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a0b2: e8 9d 7c 00 00 call 111d54 <__errno>
10a0b7: c7 00 16 00 00 00 movl $0x16,(%eax)
10a0bd: eb 2f jmp 10a0ee <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a0bf: a1 b4 73 12 00 mov 0x1273b4,%eax
10a0c4: 40 inc %eax
10a0c5: a3 b4 73 12 00 mov %eax,0x1273b4
* 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 );
10a0ca: 83 ec 0c sub $0xc,%esp
10a0cd: 68 98 76 12 00 push $0x127698
10a0d2: e8 75 1b 00 00 call 10bc4c <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a0d7: 83 c4 10 add $0x10,%esp
10a0da: 85 c0 test %eax,%eax
10a0dc: 75 18 jne 10a0f6 <timer_create+0x72>
_Thread_Enable_dispatch();
10a0de: e8 47 2a 00 00 call 10cb2a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a0e3: e8 6c 7c 00 00 call 111d54 <__errno>
10a0e8: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a0ee: 83 c8 ff or $0xffffffff,%eax
10a0f1: e9 83 00 00 00 jmp 10a179 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a0f6: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0fa: 8b 15 dc 78 12 00 mov 0x1278dc,%edx
10a100: 8b 52 08 mov 0x8(%edx),%edx
10a103: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a106: 85 db test %ebx,%ebx
10a108: 74 11 je 10a11b <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a10a: 8b 13 mov (%ebx),%edx
10a10c: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a10f: 8b 53 04 mov 0x4(%ebx),%edx
10a112: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a115: 8b 53 08 mov 0x8(%ebx),%edx
10a118: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a11b: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a122: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a129: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a130: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a137: 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;
10a13e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a145: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a14c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a153: 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 ),
10a15a: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a15d: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a160: 8b 0d b4 76 12 00 mov 0x1276b4,%ecx
10a166: 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;
10a169: 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;
10a170: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a172: e8 b3 29 00 00 call 10cb2a <_Thread_Enable_dispatch>
return 0;
10a177: 31 c0 xor %eax,%eax
}
10a179: 8d 65 f8 lea -0x8(%ebp),%esp
10a17c: 5b pop %ebx
10a17d: 5e pop %esi
10a17e: c9 leave
10a17f: c3 ret
0010a180 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a180: 55 push %ebp
10a181: 89 e5 mov %esp,%ebp
10a183: 57 push %edi
10a184: 56 push %esi
10a185: 53 push %ebx
10a186: 83 ec 2c sub $0x2c,%esp
10a189: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a18c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a190: 0f 84 58 01 00 00 je 10a2ee <timer_settime+0x16e> <== 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) ) ) {
10a196: 83 ec 0c sub $0xc,%esp
10a199: 8b 45 10 mov 0x10(%ebp),%eax
10a19c: 83 c0 08 add $0x8,%eax
10a19f: 50 push %eax
10a1a0: e8 53 33 00 00 call 10d4f8 <_Timespec_Is_valid>
10a1a5: 83 c4 10 add $0x10,%esp
10a1a8: 84 c0 test %al,%al
10a1aa: 0f 84 3e 01 00 00 je 10a2ee <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a1b0: 83 ec 0c sub $0xc,%esp
10a1b3: ff 75 10 pushl 0x10(%ebp)
10a1b6: e8 3d 33 00 00 call 10d4f8 <_Timespec_Is_valid>
10a1bb: 83 c4 10 add $0x10,%esp
10a1be: 84 c0 test %al,%al
10a1c0: 0f 84 28 01 00 00 je 10a2ee <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a1c6: 85 db test %ebx,%ebx
10a1c8: 74 09 je 10a1d3 <timer_settime+0x53>
10a1ca: 83 fb 04 cmp $0x4,%ebx
10a1cd: 0f 85 1b 01 00 00 jne 10a2ee <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a1d3: 8d 7d cc lea -0x34(%ebp),%edi
10a1d6: b9 04 00 00 00 mov $0x4,%ecx
10a1db: 8b 75 10 mov 0x10(%ebp),%esi
10a1de: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a1e0: 83 fb 04 cmp $0x4,%ebx
10a1e3: 75 2f jne 10a214 <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a1e5: 83 ec 0c sub $0xc,%esp
10a1e8: 8d 5d dc lea -0x24(%ebp),%ebx
10a1eb: 53 push %ebx
10a1ec: e8 b3 15 00 00 call 10b7a4 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a1f1: 59 pop %ecx
10a1f2: 5e pop %esi
10a1f3: 8d 75 d4 lea -0x2c(%ebp),%esi
10a1f6: 56 push %esi
10a1f7: 53 push %ebx
10a1f8: e8 d7 32 00 00 call 10d4d4 <_Timespec_Greater_than>
10a1fd: 83 c4 10 add $0x10,%esp
10a200: 84 c0 test %al,%al
10a202: 0f 85 e6 00 00 00 jne 10a2ee <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a208: 52 push %edx
10a209: 56 push %esi
10a20a: 56 push %esi
10a20b: 53 push %ebx
10a20c: e8 0b 33 00 00 call 10d51c <_Timespec_Subtract>
10a211: 83 c4 10 add $0x10,%esp
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10a214: 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 );
10a215: 8d 45 e4 lea -0x1c(%ebp),%eax
10a218: 50 push %eax
10a219: ff 75 08 pushl 0x8(%ebp)
10a21c: 68 98 76 12 00 push $0x127698
10a221: e8 52 1e 00 00 call 10c078 <_Objects_Get>
10a226: 89 c3 mov %eax,%ebx
switch ( location ) {
10a228: 83 c4 10 add $0x10,%esp
10a22b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a22f: 0f 85 b9 00 00 00 jne 10a2ee <timer_settime+0x16e>
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 ) {
10a235: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a239: 75 3b jne 10a276 <timer_settime+0xf6>
10a23b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a23f: 75 35 jne 10a276 <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a241: 83 ec 0c sub $0xc,%esp
10a244: 8d 40 10 lea 0x10(%eax),%eax
10a247: 50 push %eax
10a248: e8 9b 36 00 00 call 10d8e8 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a24d: 83 c4 10 add $0x10,%esp
10a250: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a254: 74 0d je 10a263 <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a256: 8d 73 54 lea 0x54(%ebx),%esi
10a259: b9 04 00 00 00 mov $0x4,%ecx
10a25e: 8b 7d 14 mov 0x14(%ebp),%edi
10a261: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a263: 8d 7b 54 lea 0x54(%ebx),%edi
10a266: 8d 75 cc lea -0x34(%ebp),%esi
10a269: b9 04 00 00 00 mov $0x4,%ecx
10a26e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a270: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a274: eb 35 jmp 10a2ab <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a276: 83 ec 0c sub $0xc,%esp
10a279: ff 75 10 pushl 0x10(%ebp)
10a27c: e8 cf 32 00 00 call 10d550 <_Timespec_To_ticks>
10a281: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a284: 8d 45 d4 lea -0x2c(%ebp),%eax
10a287: 89 04 24 mov %eax,(%esp)
10a28a: e8 c1 32 00 00 call 10d550 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a28f: 89 1c 24 mov %ebx,(%esp)
10a292: 68 04 a3 10 00 push $0x10a304
10a297: ff 73 08 pushl 0x8(%ebx)
10a29a: 50 push %eax
10a29b: 8d 43 10 lea 0x10(%ebx),%eax
10a29e: 50 push %eax
10a29f: e8 78 57 00 00 call 10fa1c <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a2a4: 83 c4 20 add $0x20,%esp
10a2a7: 84 c0 test %al,%al
10a2a9: 75 07 jne 10a2b2 <timer_settime+0x132>
_Thread_Enable_dispatch();
10a2ab: e8 7a 28 00 00 call 10cb2a <_Thread_Enable_dispatch>
10a2b0: eb 38 jmp 10a2ea <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a2b2: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a2b6: 74 0d je 10a2c5 <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a2b8: 8d 73 54 lea 0x54(%ebx),%esi
10a2bb: b9 04 00 00 00 mov $0x4,%ecx
10a2c0: 8b 7d 14 mov 0x14(%ebp),%edi
10a2c3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a2c5: 8d 7b 54 lea 0x54(%ebx),%edi
10a2c8: 8d 75 cc lea -0x34(%ebp),%esi
10a2cb: b9 04 00 00 00 mov $0x4,%ecx
10a2d0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2d2: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a2d6: 83 ec 0c sub $0xc,%esp
10a2d9: 83 c3 6c add $0x6c,%ebx
10a2dc: 53 push %ebx
10a2dd: e8 c2 14 00 00 call 10b7a4 <_TOD_Get>
_Thread_Enable_dispatch();
10a2e2: e8 43 28 00 00 call 10cb2a <_Thread_Enable_dispatch>
return 0;
10a2e7: 83 c4 10 add $0x10,%esp
10a2ea: 31 c0 xor %eax,%eax
10a2ec: eb 0e jmp 10a2fc <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a2ee: e8 61 7a 00 00 call 111d54 <__errno>
10a2f3: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2f9: 83 c8 ff or $0xffffffff,%eax
}
10a2fc: 8d 65 f4 lea -0xc(%ebp),%esp
10a2ff: 5b pop %ebx
10a300: 5e pop %esi
10a301: 5f pop %edi
10a302: c9 leave
10a303: c3 ret
00109fc0 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109fc0: 55 push %ebp
109fc1: 89 e5 mov %esp,%ebp
109fc3: 57 push %edi
109fc4: 56 push %esi
109fc5: 53 push %ebx
109fc6: 83 ec 1c sub $0x1c,%esp
109fc9: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109fcc: 83 3d 00 7d 12 00 00 cmpl $0x0,0x127d00
109fd3: 75 2c jne 10a001 <ualarm+0x41> <== NEVER TAKEN
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109fd5: c7 05 ec 7c 12 00 00 movl $0x0,0x127cec
109fdc: 00 00 00
the_watchdog->routine = routine;
109fdf: c7 05 00 7d 12 00 88 movl $0x109f88,0x127d00
109fe6: 9f 10 00
the_watchdog->id = id;
109fe9: c7 05 04 7d 12 00 00 movl $0x0,0x127d04
109ff0: 00 00 00
the_watchdog->user_data = user_data;
109ff3: c7 05 08 7d 12 00 00 movl $0x0,0x127d08
109ffa: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109ffd: 31 db xor %ebx,%ebx
109fff: eb 4f jmp 10a050 <ualarm+0x90>
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
10a001: 83 ec 0c sub $0xc,%esp
10a004: 68 e4 7c 12 00 push $0x127ce4
10a009: e8 c2 34 00 00 call 10d4d0 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10a00e: 83 e8 02 sub $0x2,%eax
10a011: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10a014: 31 db xor %ebx,%ebx
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10a016: 83 f8 01 cmp $0x1,%eax
10a019: 77 35 ja 10a050 <ualarm+0x90> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
10a01b: a1 f8 7c 12 00 mov 0x127cf8,%eax
10a020: 03 05 f0 7c 12 00 add 0x127cf0,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10a026: 57 push %edi
10a027: 57 push %edi
10a028: 8d 55 e0 lea -0x20(%ebp),%edx
10a02b: 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);
10a02c: 2b 05 fc 7c 12 00 sub 0x127cfc,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10a032: 50 push %eax
10a033: e8 38 30 00 00 call 10d070 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
10a038: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
10a03f: 8b 45 e4 mov -0x1c(%ebp),%eax
10a042: bf e8 03 00 00 mov $0x3e8,%edi
10a047: 99 cltd
10a048: f7 ff idiv %edi
10a04a: 8d 1c 08 lea (%eax,%ecx,1),%ebx
10a04d: 83 c4 10 add $0x10,%esp
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
10a050: 85 f6 test %esi,%esi
10a052: 74 44 je 10a098 <ualarm+0xd8>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10a054: b9 40 42 0f 00 mov $0xf4240,%ecx
10a059: 89 f0 mov %esi,%eax
10a05b: 31 d2 xor %edx,%edx
10a05d: f7 f1 div %ecx
10a05f: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a062: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a068: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a06b: 83 ec 0c sub $0xc,%esp
10a06e: 8d 75 e0 lea -0x20(%ebp),%esi
10a071: 56 push %esi
10a072: e8 55 30 00 00 call 10d0cc <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a077: 89 34 24 mov %esi,(%esp)
10a07a: e8 4d 30 00 00 call 10d0cc <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a07f: a3 f0 7c 12 00 mov %eax,0x127cf0
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a084: 59 pop %ecx
10a085: 5e pop %esi
10a086: 68 e4 7c 12 00 push $0x127ce4
10a08b: 68 d4 74 12 00 push $0x1274d4
10a090: e8 1b 33 00 00 call 10d3b0 <_Watchdog_Insert>
10a095: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a098: 89 d8 mov %ebx,%eax
10a09a: 8d 65 f4 lea -0xc(%ebp),%esp
10a09d: 5b pop %ebx
10a09e: 5e pop %esi
10a09f: 5f pop %edi
10a0a0: c9 leave
10a0a1: c3 ret