RTEMS 4.11Annotated Report
Sat Nov 27 18:54:07 2010
0010ce08 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10ce08: 55 push %ebp
10ce09: 89 e5 mov %esp,%ebp
10ce0b: 53 push %ebx
10ce0c: 83 ec 04 sub $0x4,%esp
10ce0f: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce12: 8b 15 3c 88 12 00 mov 0x12883c,%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 );
10ce18: 9c pushf
10ce19: fa cli
10ce1a: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce1b: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce1e: 85 c9 test %ecx,%ecx
10ce20: 75 0b jne 10ce2d <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce22: 50 push %eax
10ce23: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce24: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce2b: eb 72 jmp 10ce9f <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce2d: 49 dec %ecx
10ce2e: 75 0f jne 10ce3f <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce30: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce33: 49 dec %ecx
10ce34: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce37: 85 c9 test %ecx,%ecx
10ce39: 74 04 je 10ce3f <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce3b: 50 push %eax
10ce3c: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce3d: eb 60 jmp 10ce9f <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce3f: 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;
10ce46: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10ce4d: 50 push %eax
10ce4e: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10ce4f: 83 ec 0c sub $0xc,%esp
10ce52: 53 push %ebx
10ce53: e8 60 17 00 00 call 10e5b8 <_Thread_queue_Dequeue>
if ( next ) {
10ce58: 83 c4 10 add $0x10,%esp
10ce5b: 85 c0 test %eax,%eax
10ce5d: 74 40 je 10ce9f <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ce5f: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce63: 75 09 jne 10ce6e <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10ce65: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10ce6c: eb 31 jmp 10ce9f <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10ce6e: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10ce71: 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 );
10ce78: 83 ec 0c sub $0xc,%esp
10ce7b: 53 push %ebx
10ce7c: e8 2f 1b 00 00 call 10e9b0 <_Thread_queue_First>
if ( !next ||
10ce81: 83 c4 10 add $0x10,%esp
10ce84: 85 c0 test %eax,%eax
10ce86: 74 17 je 10ce9f <_CORE_RWLock_Release+0x97>
10ce88: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce8c: 74 11 je 10ce9f <_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;
10ce8e: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10ce91: 52 push %edx
10ce92: 52 push %edx
10ce93: 50 push %eax
10ce94: 53 push %ebx
10ce95: e8 06 1a 00 00 call 10e8a0 <_Thread_queue_Extract>
}
10ce9a: 83 c4 10 add $0x10,%esp
10ce9d: eb d9 jmp 10ce78 <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10ce9f: 31 c0 xor %eax,%eax
10cea1: 8b 5d fc mov -0x4(%ebp),%ebx
10cea4: c9 leave
10cea5: c3 ret
0010cea8 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10cea8: 55 push %ebp
10cea9: 89 e5 mov %esp,%ebp
10ceab: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ceae: 8d 45 f4 lea -0xc(%ebp),%eax
10ceb1: 50 push %eax
10ceb2: ff 75 08 pushl 0x8(%ebp)
10ceb5: e8 aa 13 00 00 call 10e264 <_Thread_Get>
switch ( location ) {
10ceba: 83 c4 10 add $0x10,%esp
10cebd: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10cec1: 75 17 jne 10ceda <_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 );
10cec3: 83 ec 0c sub $0xc,%esp
10cec6: 50 push %eax
10cec7: e8 b0 1b 00 00 call 10ea7c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10cecc: a1 f0 82 12 00 mov 0x1282f0,%eax
10ced1: 48 dec %eax
10ced2: a3 f0 82 12 00 mov %eax,0x1282f0
10ced7: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10ceda: c9 leave
10cedb: c3 ret
00117368 <_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
)
{
117368: 55 push %ebp
117369: 89 e5 mov %esp,%ebp
11736b: 57 push %edi
11736c: 56 push %esi
11736d: 53 push %ebx
11736e: 83 ec 1c sub $0x1c,%esp
117371: 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;
117374: 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 ) {
117379: 8b 55 10 mov 0x10(%ebp),%edx
11737c: 3b 53 4c cmp 0x4c(%ebx),%edx
11737f: 77 4e ja 1173cf <_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 ) {
117381: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
117385: 75 09 jne 117390 <_CORE_message_queue_Broadcast+0x28>
117387: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
11738e: eb 23 jmp 1173b3 <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
117390: 8b 45 1c mov 0x1c(%ebp),%eax
117393: c7 00 00 00 00 00 movl $0x0,(%eax)
117399: eb 32 jmp 1173cd <_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;
11739b: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11739e: 8b 42 2c mov 0x2c(%edx),%eax
1173a1: 89 c7 mov %eax,%edi
1173a3: 8b 75 0c mov 0xc(%ebp),%esi
1173a6: 8b 4d 10 mov 0x10(%ebp),%ecx
1173a9: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
1173ab: 8b 42 28 mov 0x28(%edx),%eax
1173ae: 8b 55 10 mov 0x10(%ebp),%edx
1173b1: 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 =
1173b3: 83 ec 0c sub $0xc,%esp
1173b6: 53 push %ebx
1173b7: e8 94 24 00 00 call 119850 <_Thread_queue_Dequeue>
1173bc: 89 c2 mov %eax,%edx
1173be: 83 c4 10 add $0x10,%esp
1173c1: 85 c0 test %eax,%eax
1173c3: 75 d6 jne 11739b <_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;
1173c5: 8b 55 e4 mov -0x1c(%ebp),%edx
1173c8: 8b 45 1c mov 0x1c(%ebp),%eax
1173cb: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1173cd: 31 c0 xor %eax,%eax
}
1173cf: 8d 65 f4 lea -0xc(%ebp),%esp
1173d2: 5b pop %ebx
1173d3: 5e pop %esi
1173d4: 5f pop %edi
1173d5: c9 leave
1173d6: c3 ret
00112214 <_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
)
{
112214: 55 push %ebp
112215: 89 e5 mov %esp,%ebp
112217: 57 push %edi
112218: 56 push %esi
112219: 53 push %ebx
11221a: 83 ec 1c sub $0x1c,%esp
11221d: 8b 5d 08 mov 0x8(%ebp),%ebx
112220: 8b 7d 10 mov 0x10(%ebp),%edi
112223: 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;
112226: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
112229: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112230: 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;
112233: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
11223a: 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)) {
112241: 89 d0 mov %edx,%eax
112243: f6 c2 03 test $0x3,%dl
112246: 74 0c je 112254 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
112248: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
11224b: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
11224e: 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)
112250: 39 d0 cmp %edx,%eax
112252: 72 68 jb 1122bc <_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));
112254: 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 *
112257: 89 d1 mov %edx,%ecx
112259: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
11225c: 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)
11225e: 39 c1 cmp %eax,%ecx
112260: 72 5a jb 1122bc <_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 );
112262: 83 ec 0c sub $0xc,%esp
112265: 51 push %ecx
112266: 89 55 e4 mov %edx,-0x1c(%ebp)
112269: e8 74 27 00 00 call 1149e2 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
11226e: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
112271: 83 c4 10 add $0x10,%esp
112274: 85 c0 test %eax,%eax
112276: 8b 55 e4 mov -0x1c(%ebp),%edx
112279: 74 41 je 1122bc <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
11227b: 52 push %edx
11227c: 57 push %edi
11227d: 50 push %eax
11227e: 8d 43 68 lea 0x68(%ebx),%eax
112281: 50 push %eax
112282: e8 b5 4a 00 00 call 116d3c <_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 );
112287: 8d 43 54 lea 0x54(%ebx),%eax
11228a: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
11228d: 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 );
112294: 8d 43 50 lea 0x50(%ebx),%eax
112297: 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(
11229a: 6a 06 push $0x6
11229c: 68 80 00 00 00 push $0x80
1122a1: 8b 45 0c mov 0xc(%ebp),%eax
1122a4: 83 38 01 cmpl $0x1,(%eax)
1122a7: 0f 94 c0 sete %al
1122aa: 0f b6 c0 movzbl %al,%eax
1122ad: 50 push %eax
1122ae: 53 push %ebx
1122af: e8 04 1f 00 00 call 1141b8 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
1122b4: 83 c4 20 add $0x20,%esp
1122b7: be 01 00 00 00 mov $0x1,%esi
}
1122bc: 89 f0 mov %esi,%eax
1122be: 8d 65 f4 lea -0xc(%ebp),%esp
1122c1: 5b pop %ebx
1122c2: 5e pop %esi
1122c3: 5f pop %edi
1122c4: c9 leave
1122c5: c3 ret
001122c8 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
1122c8: 55 push %ebp
1122c9: 89 e5 mov %esp,%ebp
1122cb: 57 push %edi
1122cc: 56 push %esi
1122cd: 53 push %ebx
1122ce: 83 ec 2c sub $0x2c,%esp
1122d1: 8b 55 08 mov 0x8(%ebp),%edx
1122d4: 8b 45 0c mov 0xc(%ebp),%eax
1122d7: 89 45 dc mov %eax,-0x24(%ebp)
1122da: 8b 5d 10 mov 0x10(%ebp),%ebx
1122dd: 89 5d e0 mov %ebx,-0x20(%ebp)
1122e0: 8b 4d 14 mov 0x14(%ebp),%ecx
1122e3: 8b 75 1c mov 0x1c(%ebp),%esi
1122e6: 89 75 d4 mov %esi,-0x2c(%ebp)
1122e9: 8a 45 18 mov 0x18(%ebp),%al
1122ec: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
1122ef: a1 94 c9 12 00 mov 0x12c994,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1122f4: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
1122fb: 9c pushf
1122fc: fa cli
1122fd: 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 );
}
112300: 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 );
112303: 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))
112306: 39 f3 cmp %esi,%ebx
112308: 0f 84 8a 00 00 00 je 112398 <_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;
11230e: 8b 33 mov (%ebx),%esi
head->next = new_first;
112310: 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 );
112313: 8d 7a 50 lea 0x50(%edx),%edi
112316: 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 ) {
112319: 85 db test %ebx,%ebx
11231b: 74 7b je 112398 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
11231d: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
112320: ff 75 e4 pushl -0x1c(%ebp)
112323: 9d popf
*size_p = the_message->Contents.size;
112324: 8b 43 0c mov 0xc(%ebx),%eax
112327: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
112329: 8b 73 08 mov 0x8(%ebx),%esi
11232c: a1 94 c9 12 00 mov 0x12c994,%eax
112331: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112334: 8d 73 10 lea 0x10(%ebx),%esi
112337: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11233a: 8b 09 mov (%ecx),%ecx
11233c: 8b 7d e0 mov -0x20(%ebp),%edi
11233f: 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 );
112341: 83 ec 0c sub $0xc,%esp
112344: 52 push %edx
112345: 89 55 d0 mov %edx,-0x30(%ebp)
112348: e8 33 1b 00 00 call 113e80 <_Thread_queue_Dequeue>
if ( !the_thread ) {
11234d: 83 c4 10 add $0x10,%esp
112350: 85 c0 test %eax,%eax
112352: 8b 55 d0 mov -0x30(%ebp),%edx
112355: 75 15 jne 11236c <_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 );
112357: 89 5d 0c mov %ebx,0xc(%ebp)
11235a: 83 c2 68 add $0x68,%edx
11235d: 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 );
}
112360: 8d 65 f4 lea -0xc(%ebp),%esp
112363: 5b pop %ebx
112364: 5e pop %esi
112365: 5f pop %edi
112366: c9 leave
112367: e9 28 fe ff ff jmp 112194 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
11236c: 8b 48 24 mov 0x24(%eax),%ecx
11236f: 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;
112372: 8b 48 30 mov 0x30(%eax),%ecx
112375: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
112378: 8b 70 2c mov 0x2c(%eax),%esi
11237b: 8b 7d e4 mov -0x1c(%ebp),%edi
11237e: 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(
112380: 8b 43 08 mov 0x8(%ebx),%eax
112383: 89 45 10 mov %eax,0x10(%ebp)
112386: 89 5d 0c mov %ebx,0xc(%ebp)
112389: 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 );
}
11238c: 8d 65 f4 lea -0xc(%ebp),%esp
11238f: 5b pop %ebx
112390: 5e pop %esi
112391: 5f pop %edi
112392: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
112393: e9 dc 49 00 00 jmp 116d74 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
112398: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
11239c: 75 13 jne 1123b1 <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
11239e: ff 75 e4 pushl -0x1c(%ebp)
1123a1: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
1123a2: 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 );
}
1123a9: 8d 65 f4 lea -0xc(%ebp),%esp
1123ac: 5b pop %ebx
1123ad: 5e pop %esi
1123ae: 5f pop %edi
1123af: c9 leave
1123b0: 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;
1123b1: 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;
1123b8: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
1123bb: 8b 5d dc mov -0x24(%ebp),%ebx
1123be: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
1123c1: 8b 75 e0 mov -0x20(%ebp),%esi
1123c4: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
1123c7: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
1123ca: ff 75 e4 pushl -0x1c(%ebp)
1123cd: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
1123ce: c7 45 10 68 42 11 00 movl $0x114268,0x10(%ebp)
1123d5: 8b 45 d4 mov -0x2c(%ebp),%eax
1123d8: 89 45 0c mov %eax,0xc(%ebp)
1123db: 89 55 08 mov %edx,0x8(%ebp)
}
1123de: 8d 65 f4 lea -0xc(%ebp),%esp
1123e1: 5b pop %ebx
1123e2: 5e pop %esi
1123e3: 5f pop %edi
1123e4: 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 );
1123e5: e9 a2 1b 00 00 jmp 113f8c <_Thread_queue_Enqueue_with_handler>
0010ac29 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac29: 55 push %ebp
10ac2a: 89 e5 mov %esp,%ebp
10ac2c: 53 push %ebx
10ac2d: 83 ec 14 sub $0x14,%esp
10ac30: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac33: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac36: a1 e0 42 12 00 mov 0x1242e0,%eax
10ac3b: 85 c0 test %eax,%eax
10ac3d: 74 19 je 10ac58 <_CORE_mutex_Seize+0x2f>
10ac3f: 84 d2 test %dl,%dl
10ac41: 74 15 je 10ac58 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac43: 83 3d 5c 44 12 00 01 cmpl $0x1,0x12445c
10ac4a: 76 0c jbe 10ac58 <_CORE_mutex_Seize+0x2f>
10ac4c: 53 push %ebx
10ac4d: 6a 12 push $0x12
10ac4f: 6a 00 push $0x0
10ac51: 6a 00 push $0x0
10ac53: e8 e4 05 00 00 call 10b23c <_Internal_error_Occurred>
10ac58: 51 push %ecx
10ac59: 51 push %ecx
10ac5a: 8d 45 18 lea 0x18(%ebp),%eax
10ac5d: 50 push %eax
10ac5e: 53 push %ebx
10ac5f: 88 55 f4 mov %dl,-0xc(%ebp)
10ac62: e8 8d 47 00 00 call 10f3f4 <_CORE_mutex_Seize_interrupt_trylock>
10ac67: 83 c4 10 add $0x10,%esp
10ac6a: 85 c0 test %eax,%eax
10ac6c: 8a 55 f4 mov -0xc(%ebp),%dl
10ac6f: 74 48 je 10acb9 <_CORE_mutex_Seize+0x90>
10ac71: 84 d2 test %dl,%dl
10ac73: 75 12 jne 10ac87 <_CORE_mutex_Seize+0x5e>
10ac75: ff 75 18 pushl 0x18(%ebp)
10ac78: 9d popf
10ac79: a1 2c 48 12 00 mov 0x12482c,%eax
10ac7e: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10ac85: eb 32 jmp 10acb9 <_CORE_mutex_Seize+0x90>
10ac87: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ac8e: a1 2c 48 12 00 mov 0x12482c,%eax
10ac93: 89 58 44 mov %ebx,0x44(%eax)
10ac96: 8b 55 0c mov 0xc(%ebp),%edx
10ac99: 89 50 20 mov %edx,0x20(%eax)
10ac9c: a1 e0 42 12 00 mov 0x1242e0,%eax
10aca1: 40 inc %eax
10aca2: a3 e0 42 12 00 mov %eax,0x1242e0
10aca7: ff 75 18 pushl 0x18(%ebp)
10acaa: 9d popf
10acab: 50 push %eax
10acac: 50 push %eax
10acad: ff 75 14 pushl 0x14(%ebp)
10acb0: 53 push %ebx
10acb1: e8 26 ff ff ff call 10abdc <_CORE_mutex_Seize_interrupt_blocking>
10acb6: 83 c4 10 add $0x10,%esp
}
10acb9: 8b 5d fc mov -0x4(%ebp),%ebx
10acbc: c9 leave
10acbd: c3 ret
0010ade4 <_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
)
{
10ade4: 55 push %ebp
10ade5: 89 e5 mov %esp,%ebp
10ade7: 53 push %ebx
10ade8: 83 ec 10 sub $0x10,%esp
10adeb: 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)) ) {
10adee: 53 push %ebx
10adef: e8 5c 16 00 00 call 10c450 <_Thread_queue_Dequeue>
10adf4: 89 c2 mov %eax,%edx
10adf6: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10adf9: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10adfb: 85 d2 test %edx,%edx
10adfd: 75 15 jne 10ae14 <_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 );
10adff: 9c pushf
10ae00: fa cli
10ae01: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae02: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10ae05: 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 )
10ae07: 3b 53 40 cmp 0x40(%ebx),%edx
10ae0a: 73 06 jae 10ae12 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae0c: 42 inc %edx
10ae0d: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae10: 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 );
10ae12: 51 push %ecx
10ae13: 9d popf
}
return status;
}
10ae14: 8b 5d fc mov -0x4(%ebp),%ebx
10ae17: c9 leave
10ae18: c3 ret
00109d48 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109d48: 55 push %ebp
109d49: 89 e5 mov %esp,%ebp
109d4b: 57 push %edi
109d4c: 56 push %esi
109d4d: 53 push %ebx
109d4e: 83 ec 2c sub $0x2c,%esp
109d51: 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 ];
109d54: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109d5a: 8b 43 30 mov 0x30(%ebx),%eax
109d5d: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109d60: 9c pushf
109d61: fa cli
109d62: 58 pop %eax
pending_events = api->pending_events;
109d63: 8b 17 mov (%edi),%edx
109d65: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109d68: 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 ) ) {
109d6b: 21 f2 and %esi,%edx
109d6d: 75 07 jne 109d76 <_Event_Surrender+0x2e>
_ISR_Enable( level );
109d6f: 50 push %eax
109d70: 9d popf
return;
109d71: e9 af 00 00 00 jmp 109e25 <_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() &&
109d76: 83 3d 28 48 12 00 00 cmpl $0x0,0x124828
109d7d: 74 49 je 109dc8 <_Event_Surrender+0x80>
109d7f: 3b 1d 2c 48 12 00 cmp 0x12482c,%ebx
109d85: 75 41 jne 109dc8 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d87: 8b 0d 00 4c 12 00 mov 0x124c00,%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 ) &&
109d8d: 83 f9 02 cmp $0x2,%ecx
109d90: 74 09 je 109d9b <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109d92: 8b 0d 00 4c 12 00 mov 0x124c00,%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) ||
109d98: 49 dec %ecx
109d99: 75 2d jne 109dc8 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109d9b: 39 f2 cmp %esi,%edx
109d9d: 74 06 je 109da5 <_Event_Surrender+0x5d>
109d9f: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109da3: 74 1f je 109dc4 <_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) );
109da5: 89 d6 mov %edx,%esi
109da7: f7 d6 not %esi
109da9: 23 75 d4 and -0x2c(%ebp),%esi
109dac: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109dae: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109db5: 8b 4b 28 mov 0x28(%ebx),%ecx
109db8: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109dba: c7 05 00 4c 12 00 03 movl $0x3,0x124c00
109dc1: 00 00 00
}
_ISR_Enable( level );
109dc4: 50 push %eax
109dc5: 9d popf
return;
109dc6: eb 5d jmp 109e25 <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109dc8: f6 43 11 01 testb $0x1,0x11(%ebx)
109dcc: 74 55 je 109e23 <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109dce: 39 f2 cmp %esi,%edx
109dd0: 74 06 je 109dd8 <_Event_Surrender+0x90>
109dd2: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dd6: 74 4b je 109e23 <_Event_Surrender+0xdb> <== NEVER TAKEN
109dd8: 89 d6 mov %edx,%esi
109dda: f7 d6 not %esi
109ddc: 23 75 d4 and -0x2c(%ebp),%esi
109ddf: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109de1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109de8: 8b 4b 28 mov 0x28(%ebx),%ecx
109deb: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109ded: 50 push %eax
109dee: 9d popf
109def: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109df0: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109df4: 74 06 je 109dfc <_Event_Surrender+0xb4>
_ISR_Enable( level );
109df6: 50 push %eax
109df7: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109df8: 51 push %ecx
109df9: 51 push %ecx
109dfa: eb 17 jmp 109e13 <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109dfc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e03: 50 push %eax
109e04: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e05: 83 ec 0c sub $0xc,%esp
109e08: 8d 43 48 lea 0x48(%ebx),%eax
109e0b: 50 push %eax
109e0c: e8 87 30 00 00 call 10ce98 <_Watchdog_Remove>
109e11: 58 pop %eax
109e12: 5a pop %edx
109e13: 68 f8 ff 03 10 push $0x1003fff8
109e18: 53 push %ebx
109e19: e8 8a 1f 00 00 call 10bda8 <_Thread_Clear_state>
109e1e: 83 c4 10 add $0x10,%esp
109e21: eb 02 jmp 109e25 <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e23: 50 push %eax
109e24: 9d popf
}
109e25: 8d 65 f4 lea -0xc(%ebp),%esp
109e28: 5b pop %ebx
109e29: 5e pop %esi
109e2a: 5f pop %edi
109e2b: c9 leave
109e2c: c3 ret
00109e30 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e30: 55 push %ebp
109e31: 89 e5 mov %esp,%ebp
109e33: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e36: 8d 45 f4 lea -0xc(%ebp),%eax
109e39: 50 push %eax
109e3a: ff 75 08 pushl 0x8(%ebp)
109e3d: e8 ba 22 00 00 call 10c0fc <_Thread_Get>
switch ( location ) {
109e42: 83 c4 10 add $0x10,%esp
109e45: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109e49: 75 49 jne 109e94 <_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 );
109e4b: 9c pushf
109e4c: fa cli
109e4d: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109e4e: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109e55: 3b 05 2c 48 12 00 cmp 0x12482c,%eax
109e5b: 75 13 jne 109e70 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109e5d: 8b 0d 00 4c 12 00 mov 0x124c00,%ecx
109e63: 49 dec %ecx
109e64: 75 0a jne 109e70 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109e66: c7 05 00 4c 12 00 02 movl $0x2,0x124c00
109e6d: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109e70: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109e77: 52 push %edx
109e78: 9d popf
109e79: 52 push %edx
109e7a: 52 push %edx
109e7b: 68 f8 ff 03 10 push $0x1003fff8
109e80: 50 push %eax
109e81: e8 22 1f 00 00 call 10bda8 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109e86: a1 e0 42 12 00 mov 0x1242e0,%eax
109e8b: 48 dec %eax
109e8c: a3 e0 42 12 00 mov %eax,0x1242e0
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109e91: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109e94: c9 leave
109e95: c3 ret
0010fa53 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10fa53: 55 push %ebp
10fa54: 89 e5 mov %esp,%ebp
10fa56: 57 push %edi
10fa57: 56 push %esi
10fa58: 53 push %ebx
10fa59: 83 ec 4c sub $0x4c,%esp
10fa5c: 8b 5d 08 mov 0x8(%ebp),%ebx
10fa5f: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10fa62: 8b 43 20 mov 0x20(%ebx),%eax
10fa65: 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;
10fa68: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10fa6f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10fa76: 8b 53 10 mov 0x10(%ebx),%edx
10fa79: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10fa7c: 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;
10fa7f: 8b 7b 30 mov 0x30(%ebx),%edi
10fa82: 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;
10fa85: 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 ) {
10fa87: 8b 7d 0c mov 0xc(%ebp),%edi
10fa8a: 01 cf add %ecx,%edi
10fa8c: 0f 82 d4 01 00 00 jb 10fc66 <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10fa92: 52 push %edx
10fa93: 52 push %edx
10fa94: 8d 55 e0 lea -0x20(%ebp),%edx
10fa97: 52 push %edx
10fa98: 8d 55 e4 lea -0x1c(%ebp),%edx
10fa9b: 52 push %edx
10fa9c: 50 push %eax
10fa9d: ff 75 c4 pushl -0x3c(%ebp)
10faa0: 51 push %ecx
10faa1: ff 75 0c pushl 0xc(%ebp)
10faa4: e8 b6 b8 ff ff call 10b35f <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10faa9: 83 c4 20 add $0x20,%esp
10faac: 84 c0 test %al,%al
10faae: 0f 84 b2 01 00 00 je 10fc66 <_Heap_Extend+0x213>
10fab4: 8b 4d c0 mov -0x40(%ebp),%ecx
10fab7: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10fabe: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10fac5: 31 f6 xor %esi,%esi
10fac7: 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;
10face: 8b 43 18 mov 0x18(%ebx),%eax
10fad1: 89 5d b8 mov %ebx,-0x48(%ebp)
10fad4: eb 02 jmp 10fad8 <_Heap_Extend+0x85>
10fad6: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10fad8: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10fada: 39 c7 cmp %eax,%edi
10fadc: 76 09 jbe 10fae7 <_Heap_Extend+0x94>
10fade: 39 5d 0c cmp %ebx,0xc(%ebp)
10fae1: 0f 82 7d 01 00 00 jb 10fc64 <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fae7: 39 c7 cmp %eax,%edi
10fae9: 74 06 je 10faf1 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10faeb: 39 df cmp %ebx,%edi
10faed: 72 07 jb 10faf6 <_Heap_Extend+0xa3>
10faef: eb 08 jmp 10faf9 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10faf1: 89 4d d0 mov %ecx,-0x30(%ebp)
10faf4: eb 03 jmp 10faf9 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10faf6: 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);
10faf9: 8d 43 f8 lea -0x8(%ebx),%eax
10fafc: 89 45 d4 mov %eax,-0x2c(%ebp)
10faff: 89 d8 mov %ebx,%eax
10fb01: 31 d2 xor %edx,%edx
10fb03: 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);
10fb06: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fb09: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fb0c: 75 07 jne 10fb15 <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fb0e: 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 )
10fb10: 8b 75 d4 mov -0x2c(%ebp),%esi
10fb13: eb 08 jmp 10fb1d <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fb15: 73 06 jae 10fb1d <_Heap_Extend+0xca>
10fb17: 8b 55 d4 mov -0x2c(%ebp),%edx
10fb1a: 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;
10fb1d: 8b 45 d4 mov -0x2c(%ebp),%eax
10fb20: 8b 48 04 mov 0x4(%eax),%ecx
10fb23: 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);
10fb26: 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 );
10fb28: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fb2b: 75 a9 jne 10fad6 <_Heap_Extend+0x83>
10fb2d: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fb30: 8b 55 0c mov 0xc(%ebp),%edx
10fb33: 3b 53 18 cmp 0x18(%ebx),%edx
10fb36: 73 05 jae 10fb3d <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fb38: 89 53 18 mov %edx,0x18(%ebx)
10fb3b: eb 08 jmp 10fb45 <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fb3d: 39 7b 1c cmp %edi,0x1c(%ebx)
10fb40: 73 03 jae 10fb45 <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fb42: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fb45: 8b 45 e0 mov -0x20(%ebp),%eax
10fb48: 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 =
10fb4b: 89 c1 mov %eax,%ecx
10fb4d: 29 d1 sub %edx,%ecx
10fb4f: 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;
10fb52: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fb54: 83 c9 01 or $0x1,%ecx
10fb57: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fb5a: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fb5d: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fb5f: 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 ) {
10fb66: 39 53 20 cmp %edx,0x20(%ebx)
10fb69: 76 05 jbe 10fb70 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fb6b: 89 53 20 mov %edx,0x20(%ebx)
10fb6e: eb 08 jmp 10fb78 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fb70: 39 43 24 cmp %eax,0x24(%ebx)
10fb73: 73 03 jae 10fb78 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fb75: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fb78: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fb7c: 74 3b je 10fbb9 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fb7e: 8b 43 10 mov 0x10(%ebx),%eax
10fb81: 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 );
10fb84: 8b 4d 0c mov 0xc(%ebp),%ecx
10fb87: 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;
10fb8a: 89 c8 mov %ecx,%eax
10fb8c: 31 d2 xor %edx,%edx
10fb8e: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fb91: 85 d2 test %edx,%edx
10fb93: 74 05 je 10fb9a <_Heap_Extend+0x147> <== ALWAYS TAKEN
return value - remainder + alignment;
10fb95: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED
10fb98: 29 d1 sub %edx,%ecx <== NOT EXECUTED
uintptr_t const new_first_block_begin =
10fb9a: 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;
10fb9d: 8b 45 d0 mov -0x30(%ebp),%eax
10fba0: 8b 00 mov (%eax),%eax
10fba2: 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 =
10fba5: 8b 45 d0 mov -0x30(%ebp),%eax
10fba8: 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;
10fbaa: 83 c8 01 or $0x1,%eax
10fbad: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fbb0: 89 d8 mov %ebx,%eax
10fbb2: e8 81 fe ff ff call 10fa38 <_Heap_Free_block>
10fbb7: eb 14 jmp 10fbcd <_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 ) {
10fbb9: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fbbd: 74 0e je 10fbcd <_Heap_Extend+0x17a>
_Heap_Link_below(
10fbbf: 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;
10fbc2: 8b 45 c8 mov -0x38(%ebp),%eax
10fbc5: 29 d0 sub %edx,%eax
10fbc7: 83 c8 01 or $0x1,%eax
10fbca: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10fbcd: 85 f6 test %esi,%esi
10fbcf: 74 30 je 10fc01 <_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,
10fbd1: 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(
10fbd4: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fbd6: 89 f8 mov %edi,%eax
10fbd8: 31 d2 xor %edx,%edx
10fbda: f7 73 10 divl 0x10(%ebx)
10fbdd: 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)
10fbdf: 8b 46 04 mov 0x4(%esi),%eax
10fbe2: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fbe4: 83 c8 01 or $0x1,%eax
10fbe7: 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;
10fbeb: 8b 46 04 mov 0x4(%esi),%eax
10fbee: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fbf1: 09 f8 or %edi,%eax
10fbf3: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fbf6: 89 f2 mov %esi,%edx
10fbf8: 89 d8 mov %ebx,%eax
10fbfa: e8 39 fe ff ff call 10fa38 <_Heap_Free_block>
10fbff: eb 21 jmp 10fc22 <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fc01: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fc05: 74 1b je 10fc22 <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fc07: 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 );
10fc0a: 8b 45 e4 mov -0x1c(%ebp),%eax
10fc0d: 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;
10fc10: 8b 7d cc mov -0x34(%ebp),%edi
10fc13: 8b 57 04 mov 0x4(%edi),%edx
10fc16: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fc19: 09 d0 or %edx,%eax
10fc1b: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fc1e: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fc22: 85 f6 test %esi,%esi
10fc24: 75 10 jne 10fc36 <_Heap_Extend+0x1e3>
10fc26: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fc2a: 75 0a jne 10fc36 <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fc2c: 8b 55 e4 mov -0x1c(%ebp),%edx
10fc2f: 89 d8 mov %ebx,%eax
10fc31: e8 02 fe ff ff call 10fa38 <_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
10fc36: 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(
10fc39: 8b 43 20 mov 0x20(%ebx),%eax
10fc3c: 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;
10fc3e: 8b 4a 04 mov 0x4(%edx),%ecx
10fc41: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fc44: 09 c8 or %ecx,%eax
10fc46: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fc49: 8b 43 30 mov 0x30(%ebx),%eax
10fc4c: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fc4f: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fc52: 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 )
10fc57: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fc5b: 74 09 je 10fc66 <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fc5d: 8b 55 14 mov 0x14(%ebp),%edx
10fc60: 89 02 mov %eax,(%edx)
10fc62: eb 02 jmp 10fc66 <_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;
10fc64: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fc66: 89 f0 mov %esi,%eax
10fc68: 8d 65 f4 lea -0xc(%ebp),%esp
10fc6b: 5b pop %ebx
10fc6c: 5e pop %esi
10fc6d: 5f pop %edi
10fc6e: c9 leave
10fc6f: c3 ret
0010f698 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f698: 55 push %ebp
10f699: 89 e5 mov %esp,%ebp
10f69b: 57 push %edi
10f69c: 56 push %esi
10f69d: 53 push %ebx
10f69e: 83 ec 14 sub $0x14,%esp
10f6a1: 8b 4d 08 mov 0x8(%ebp),%ecx
10f6a4: 8b 45 0c mov 0xc(%ebp),%eax
10f6a7: 8d 58 f8 lea -0x8(%eax),%ebx
10f6aa: 31 d2 xor %edx,%edx
10f6ac: 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);
10f6af: 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
10f6b1: 8b 41 20 mov 0x20(%ecx),%eax
10f6b4: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f6b7: 31 d2 xor %edx,%edx
10f6b9: 39 c3 cmp %eax,%ebx
10f6bb: 72 08 jb 10f6c5 <_Heap_Free+0x2d>
10f6bd: 31 d2 xor %edx,%edx
10f6bf: 39 59 24 cmp %ebx,0x24(%ecx)
10f6c2: 0f 93 c2 setae %dl
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
10f6c5: 31 c0 xor %eax,%eax
uintptr_t next_block_size = 0;
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
10f6c7: 85 d2 test %edx,%edx
10f6c9: 0f 84 21 01 00 00 je 10f7f0 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f6cf: 8b 43 04 mov 0x4(%ebx),%eax
10f6d2: 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;
10f6d5: 89 c6 mov %eax,%esi
10f6d7: 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);
10f6da: 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;
10f6dd: 31 ff xor %edi,%edi
10f6df: 3b 55 ec cmp -0x14(%ebp),%edx
10f6e2: 72 0a jb 10f6ee <_Heap_Free+0x56> <== NEVER TAKEN
10f6e4: 31 c0 xor %eax,%eax
10f6e6: 39 51 24 cmp %edx,0x24(%ecx)
10f6e9: 0f 93 c0 setae %al
10f6ec: 89 c7 mov %eax,%edi
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
10f6ee: 31 c0 xor %eax,%eax
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10f6f0: 85 ff test %edi,%edi
10f6f2: 0f 84 f8 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f6f8: 8b 7a 04 mov 0x4(%edx),%edi
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10f6fb: f7 c7 01 00 00 00 test $0x1,%edi
10f701: 0f 84 e9 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== 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;
10f707: 83 e7 fe and $0xfffffffe,%edi
10f70a: 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
10f70d: 8b 41 24 mov 0x24(%ecx),%eax
10f710: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f713: 31 c0 xor %eax,%eax
10f715: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f718: 74 0a je 10f724 <_Heap_Free+0x8c>
10f71a: 31 c0 xor %eax,%eax
10f71c: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f721: 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
10f724: 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 ) ) {
10f727: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f72b: 75 62 jne 10f78f <_Heap_Free+0xf7>
uintptr_t const prev_size = block->prev_size;
10f72d: 8b 03 mov (%ebx),%eax
10f72f: 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);
10f732: 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;
10f734: 31 ff xor %edi,%edi
10f736: 3b 5d ec cmp -0x14(%ebp),%ebx
10f739: 72 0a jb 10f745 <_Heap_Free+0xad> <== NEVER TAKEN
10f73b: 31 c0 xor %eax,%eax
10f73d: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f740: 0f 93 c0 setae %al
10f743: 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 );
10f745: 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 ) ) {
10f747: 85 ff test %edi,%edi
10f749: 0f 84 a1 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== 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) ) {
10f74f: f6 43 04 01 testb $0x1,0x4(%ebx)
10f753: 0f 84 97 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f759: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f75d: 74 1a je 10f779 <_Heap_Free+0xe1>
uintptr_t const size = block_size + prev_size + next_block_size;
10f75f: 8b 45 e8 mov -0x18(%ebp),%eax
10f762: 8d 04 06 lea (%esi,%eax,1),%eax
10f765: 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;
10f768: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f76b: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f76e: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f771: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f774: ff 49 38 decl 0x38(%ecx)
10f777: eb 33 jmp 10f7ac <_Heap_Free+0x114>
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;
10f779: 8b 45 f0 mov -0x10(%ebp),%eax
10f77c: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f77f: 89 c7 mov %eax,%edi
10f781: 83 cf 01 or $0x1,%edi
10f784: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f787: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f78b: 89 02 mov %eax,(%edx)
10f78d: eb 56 jmp 10f7e5 <_Heap_Free+0x14d>
}
} else if ( next_is_free ) { /* coalesce next */
10f78f: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f793: 74 24 je 10f7b9 <_Heap_Free+0x121>
uintptr_t const size = block_size + next_block_size;
10f795: 8b 45 e8 mov -0x18(%ebp),%eax
10f798: 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;
10f79a: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f79d: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f7a0: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f7a3: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f7a6: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f7a9: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f7ac: 89 c2 mov %eax,%edx
10f7ae: 83 ca 01 or $0x1,%edx
10f7b1: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f7b4: 89 04 03 mov %eax,(%ebx,%eax,1)
10f7b7: eb 2c jmp 10f7e5 <_Heap_Free+0x14d>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
10f7b9: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f7bc: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f7bf: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f7c2: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f7c5: 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;
10f7c8: 89 f0 mov %esi,%eax
10f7ca: 83 c8 01 or $0x1,%eax
10f7cd: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f7d0: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f7d4: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f7d6: 8b 41 38 mov 0x38(%ecx),%eax
10f7d9: 40 inc %eax
10f7da: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f7dd: 39 41 3c cmp %eax,0x3c(%ecx)
10f7e0: 73 03 jae 10f7e5 <_Heap_Free+0x14d>
stats->max_free_blocks = stats->free_blocks;
10f7e2: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f7e5: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f7e8: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f7eb: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f7ee: b0 01 mov $0x1,%al
}
10f7f0: 83 c4 14 add $0x14,%esp
10f7f3: 5b pop %ebx
10f7f4: 5e pop %esi
10f7f5: 5f pop %edi
10f7f6: c9 leave
10f7f7: c3 ret
0011cc20 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11cc20: 55 push %ebp
11cc21: 89 e5 mov %esp,%ebp
11cc23: 57 push %edi
11cc24: 56 push %esi
11cc25: 53 push %ebx
11cc26: 8b 5d 08 mov 0x8(%ebp),%ebx
11cc29: 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);
11cc2c: 8d 4e f8 lea -0x8(%esi),%ecx
11cc2f: 89 f0 mov %esi,%eax
11cc31: 31 d2 xor %edx,%edx
11cc33: 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);
11cc36: 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
11cc38: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11cc3b: 31 ff xor %edi,%edi
11cc3d: 39 d1 cmp %edx,%ecx
11cc3f: 72 0a jb 11cc4b <_Heap_Size_of_alloc_area+0x2b>
11cc41: 31 c0 xor %eax,%eax
11cc43: 39 4b 24 cmp %ecx,0x24(%ebx)
11cc46: 0f 93 c0 setae %al
11cc49: 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;
11cc4b: 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 ) ) {
11cc4d: 85 ff test %edi,%edi
11cc4f: 74 30 je 11cc81 <_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;
11cc51: 8b 41 04 mov 0x4(%ecx),%eax
11cc54: 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);
11cc57: 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;
11cc59: 31 ff xor %edi,%edi
11cc5b: 39 d1 cmp %edx,%ecx
11cc5d: 72 0a jb 11cc69 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11cc5f: 31 c0 xor %eax,%eax
11cc61: 39 4b 24 cmp %ecx,0x24(%ebx)
11cc64: 0f 93 c0 setae %al
11cc67: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11cc69: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11cc6b: 85 ff test %edi,%edi
11cc6d: 74 12 je 11cc81 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11cc6f: f6 41 04 01 testb $0x1,0x4(%ecx)
11cc73: 74 0c je 11cc81 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11cc75: 29 f1 sub %esi,%ecx
11cc77: 8d 51 04 lea 0x4(%ecx),%edx
11cc7a: 8b 45 10 mov 0x10(%ebp),%eax
11cc7d: 89 10 mov %edx,(%eax)
return true;
11cc7f: b0 01 mov $0x1,%al
}
11cc81: 5b pop %ebx
11cc82: 5e pop %esi
11cc83: 5f pop %edi
11cc84: c9 leave
11cc85: c3 ret
0010bc1a <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc1a: 55 push %ebp
10bc1b: 89 e5 mov %esp,%ebp
10bc1d: 57 push %edi
10bc1e: 56 push %esi
10bc1f: 53 push %ebx
10bc20: 83 ec 4c sub $0x4c,%esp
10bc23: 8b 75 08 mov 0x8(%ebp),%esi
10bc26: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc29: 8b 46 10 mov 0x10(%esi),%eax
10bc2c: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc2f: 8b 4e 14 mov 0x14(%esi),%ecx
10bc32: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc35: 8b 46 20 mov 0x20(%esi),%eax
10bc38: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc3b: 8b 4e 24 mov 0x24(%esi),%ecx
10bc3e: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc41: c7 45 e4 dc bb 10 00 movl $0x10bbdc,-0x1c(%ebp)
10bc48: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bc4c: 74 07 je 10bc55 <_Heap_Walk+0x3b>
10bc4e: c7 45 e4 e1 bb 10 00 movl $0x10bbe1,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bc55: 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() ) ) {
10bc57: 83 3d e4 64 12 00 03 cmpl $0x3,0x1264e4
10bc5e: 0f 85 e8 02 00 00 jne 10bf4c <_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)(
10bc64: 52 push %edx
10bc65: ff 76 0c pushl 0xc(%esi)
10bc68: ff 76 08 pushl 0x8(%esi)
10bc6b: ff 75 c8 pushl -0x38(%ebp)
10bc6e: ff 75 d0 pushl -0x30(%ebp)
10bc71: ff 76 1c pushl 0x1c(%esi)
10bc74: ff 76 18 pushl 0x18(%esi)
10bc77: ff 75 d4 pushl -0x2c(%ebp)
10bc7a: ff 75 d8 pushl -0x28(%ebp)
10bc7d: 68 91 f7 11 00 push $0x11f791
10bc82: 6a 00 push $0x0
10bc84: 53 push %ebx
10bc85: 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 ) {
10bc88: 83 c4 30 add $0x30,%esp
10bc8b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bc8f: 75 0b jne 10bc9c <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bc91: 50 push %eax
10bc92: 68 22 f8 11 00 push $0x11f822
10bc97: e9 6b 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bc9c: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bca0: 74 0d je 10bcaf <_Heap_Walk+0x95>
(*printer)(
10bca2: ff 75 d8 pushl -0x28(%ebp)
10bca5: 68 35 f8 11 00 push $0x11f835
10bcaa: e9 58 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcaf: 8b 45 d4 mov -0x2c(%ebp),%eax
10bcb2: 31 d2 xor %edx,%edx
10bcb4: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bcb7: 85 d2 test %edx,%edx
10bcb9: 74 0d je 10bcc8 <_Heap_Walk+0xae>
(*printer)(
10bcbb: ff 75 d4 pushl -0x2c(%ebp)
10bcbe: 68 53 f8 11 00 push $0x11f853
10bcc3: e9 3f 02 00 00 jmp 10bf07 <_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;
10bcc8: 8b 45 d0 mov -0x30(%ebp),%eax
10bccb: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcce: 31 d2 xor %edx,%edx
10bcd0: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bcd3: 85 d2 test %edx,%edx
10bcd5: 74 0d je 10bce4 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bcd7: ff 75 d0 pushl -0x30(%ebp)
10bcda: 68 77 f8 11 00 push $0x11f877
10bcdf: e9 23 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bce4: 8b 45 d0 mov -0x30(%ebp),%eax
10bce7: f6 40 04 01 testb $0x1,0x4(%eax)
10bceb: 75 0b jne 10bcf8 <_Heap_Walk+0xde>
(*printer)(
10bced: 57 push %edi
10bcee: 68 a8 f8 11 00 push $0x11f8a8
10bcf3: e9 0f 02 00 00 jmp 10bf07 <_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;
10bcf8: 8b 4d c8 mov -0x38(%ebp),%ecx
10bcfb: 8b 79 04 mov 0x4(%ecx),%edi
10bcfe: 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);
10bd01: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bd03: f6 47 04 01 testb $0x1,0x4(%edi)
10bd07: 75 0b jne 10bd14 <_Heap_Walk+0xfa>
(*printer)(
10bd09: 56 push %esi
10bd0a: 68 d6 f8 11 00 push $0x11f8d6
10bd0f: e9 f3 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd14: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd17: 74 0b je 10bd24 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd19: 51 push %ecx <== NOT EXECUTED
10bd1a: 68 eb f8 11 00 push $0x11f8eb <== NOT EXECUTED
10bd1f: e9 e3 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd24: 8b 46 10 mov 0x10(%esi),%eax
10bd27: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd2a: 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 );
10bd2d: 89 75 dc mov %esi,-0x24(%ebp)
10bd30: eb 75 jmp 10bda7 <_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;
10bd32: 31 c0 xor %eax,%eax
10bd34: 39 4e 20 cmp %ecx,0x20(%esi)
10bd37: 77 08 ja 10bd41 <_Heap_Walk+0x127>
10bd39: 31 c0 xor %eax,%eax
10bd3b: 39 4e 24 cmp %ecx,0x24(%esi)
10bd3e: 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 ) ) {
10bd41: 85 c0 test %eax,%eax
10bd43: 75 0b jne 10bd50 <_Heap_Walk+0x136>
(*printer)(
10bd45: 51 push %ecx
10bd46: 68 1a f9 11 00 push $0x11f91a
10bd4b: e9 b7 01 00 00 jmp 10bf07 <_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;
10bd50: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd53: 31 d2 xor %edx,%edx
10bd55: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bd58: 85 d2 test %edx,%edx
10bd5a: 74 0b je 10bd67 <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bd5c: 51 push %ecx
10bd5d: 68 3a f9 11 00 push $0x11f93a
10bd62: e9 a0 01 00 00 jmp 10bf07 <_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;
10bd67: 8b 41 04 mov 0x4(%ecx),%eax
10bd6a: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bd6d: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bd72: 74 0b je 10bd7f <_Heap_Walk+0x165>
(*printer)(
10bd74: 51 push %ecx
10bd75: 68 6a f9 11 00 push $0x11f96a
10bd7a: e9 88 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bd7f: 8b 41 0c mov 0xc(%ecx),%eax
10bd82: 3b 45 dc cmp -0x24(%ebp),%eax
10bd85: 74 1a je 10bda1 <_Heap_Walk+0x187>
(*printer)(
10bd87: 83 ec 0c sub $0xc,%esp
10bd8a: 50 push %eax
10bd8b: 51 push %ecx
10bd8c: 68 86 f9 11 00 push $0x11f986
10bd91: 6a 01 push $0x1
10bd93: 53 push %ebx
10bd94: ff 55 e4 call *-0x1c(%ebp)
10bd97: 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;
10bd9a: 31 c0 xor %eax,%eax
10bd9c: e9 ab 01 00 00 jmp 10bf4c <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bda1: 89 4d dc mov %ecx,-0x24(%ebp)
10bda4: 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 ) {
10bda7: 39 f1 cmp %esi,%ecx
10bda9: 75 87 jne 10bd32 <_Heap_Walk+0x118>
10bdab: 89 5d dc mov %ebx,-0x24(%ebp)
10bdae: eb 02 jmp 10bdb2 <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bdb0: 89 df mov %ebx,%edi
return true;
}
10bdb2: 8b 4f 04 mov 0x4(%edi),%ecx
10bdb5: 89 4d cc mov %ecx,-0x34(%ebp)
10bdb8: 83 e1 fe and $0xfffffffe,%ecx
10bdbb: 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);
10bdbe: 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;
10bdc1: 31 c0 xor %eax,%eax
10bdc3: 39 5e 20 cmp %ebx,0x20(%esi)
10bdc6: 77 08 ja 10bdd0 <_Heap_Walk+0x1b6> <== NEVER TAKEN
10bdc8: 31 c0 xor %eax,%eax
10bdca: 39 5e 24 cmp %ebx,0x24(%esi)
10bdcd: 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 ) ) {
10bdd0: 85 c0 test %eax,%eax
10bdd2: 75 11 jne 10bde5 <_Heap_Walk+0x1cb>
10bdd4: 89 d9 mov %ebx,%ecx
10bdd6: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdd9: 83 ec 0c sub $0xc,%esp
10bddc: 51 push %ecx
10bddd: 57 push %edi
10bdde: 68 b8 f9 11 00 push $0x11f9b8
10bde3: eb ac jmp 10bd91 <_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;
10bde5: 3b 7d c8 cmp -0x38(%ebp),%edi
10bde8: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bdeb: 8b 45 e0 mov -0x20(%ebp),%eax
10bdee: 31 d2 xor %edx,%edx
10bdf0: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10bdf3: 85 d2 test %edx,%edx
10bdf5: 74 15 je 10be0c <_Heap_Walk+0x1f2>
10bdf7: 84 c9 test %cl,%cl
10bdf9: 74 11 je 10be0c <_Heap_Walk+0x1f2>
10bdfb: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdfe: 83 ec 0c sub $0xc,%esp
10be01: ff 75 e0 pushl -0x20(%ebp)
10be04: 57 push %edi
10be05: 68 e5 f9 11 00 push $0x11f9e5
10be0a: eb 85 jmp 10bd91 <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be0c: 8b 45 d4 mov -0x2c(%ebp),%eax
10be0f: 39 45 e0 cmp %eax,-0x20(%ebp)
10be12: 73 18 jae 10be2c <_Heap_Walk+0x212>
10be14: 84 c9 test %cl,%cl
10be16: 74 14 je 10be2c <_Heap_Walk+0x212> <== NEVER TAKEN
10be18: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be1b: 52 push %edx
10be1c: 52 push %edx
10be1d: 50 push %eax
10be1e: ff 75 e0 pushl -0x20(%ebp)
10be21: 57 push %edi
10be22: 68 13 fa 11 00 push $0x11fa13
10be27: e9 65 ff ff ff jmp 10bd91 <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be2c: 39 fb cmp %edi,%ebx
10be2e: 77 18 ja 10be48 <_Heap_Walk+0x22e>
10be30: 84 c9 test %cl,%cl
10be32: 74 14 je 10be48 <_Heap_Walk+0x22e>
10be34: 89 d9 mov %ebx,%ecx
10be36: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be39: 83 ec 0c sub $0xc,%esp
10be3c: 51 push %ecx
10be3d: 57 push %edi
10be3e: 68 3e fa 11 00 push $0x11fa3e
10be43: e9 49 ff ff ff jmp 10bd91 <_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;
10be48: 8b 4d cc mov -0x34(%ebp),%ecx
10be4b: 83 e1 01 and $0x1,%ecx
10be4e: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10be51: f6 43 04 01 testb $0x1,0x4(%ebx)
10be55: 0f 85 ba 00 00 00 jne 10bf15 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10be5b: 8b 46 08 mov 0x8(%esi),%eax
10be5e: 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 ?
10be61: 8b 4f 08 mov 0x8(%edi),%ecx
10be64: 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)(
10be67: ba 5e f7 11 00 mov $0x11f75e,%edx
10be6c: 3b 4e 0c cmp 0xc(%esi),%ecx
10be6f: 74 0e je 10be7f <_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)" : "")
10be71: ba 95 f6 11 00 mov $0x11f695,%edx
10be76: 39 f1 cmp %esi,%ecx
10be78: 75 05 jne 10be7f <_Heap_Walk+0x265>
10be7a: ba 6d f7 11 00 mov $0x11f76d,%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 ?
10be7f: 8b 47 0c mov 0xc(%edi),%eax
10be82: 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)(
10be85: b8 77 f7 11 00 mov $0x11f777,%eax
10be8a: 8b 4d c0 mov -0x40(%ebp),%ecx
10be8d: 39 4d cc cmp %ecx,-0x34(%ebp)
10be90: 74 0f je 10bea1 <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10be92: b8 95 f6 11 00 mov $0x11f695,%eax
10be97: 39 75 cc cmp %esi,-0x34(%ebp)
10be9a: 75 05 jne 10bea1 <_Heap_Walk+0x287>
10be9c: b8 87 f7 11 00 mov $0x11f787,%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)(
10bea1: 83 ec 0c sub $0xc,%esp
10bea4: 52 push %edx
10bea5: ff 75 b4 pushl -0x4c(%ebp)
10bea8: 50 push %eax
10bea9: ff 75 cc pushl -0x34(%ebp)
10beac: ff 75 e0 pushl -0x20(%ebp)
10beaf: 57 push %edi
10beb0: 68 72 fa 11 00 push $0x11fa72
10beb5: 6a 00 push $0x0
10beb7: ff 75 dc pushl -0x24(%ebp)
10beba: 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 ) {
10bebd: 8b 03 mov (%ebx),%eax
10bebf: 83 c4 30 add $0x30,%esp
10bec2: 39 45 e0 cmp %eax,-0x20(%ebp)
10bec5: 74 16 je 10bedd <_Heap_Walk+0x2c3>
10bec7: 89 d9 mov %ebx,%ecx
10bec9: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10becc: 56 push %esi
10becd: 51 push %ecx
10bece: 50 push %eax
10becf: ff 75 e0 pushl -0x20(%ebp)
10bed2: 57 push %edi
10bed3: 68 a7 fa 11 00 push $0x11faa7
10bed8: e9 b4 fe ff ff jmp 10bd91 <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bedd: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bee1: 75 0b jne 10beee <_Heap_Walk+0x2d4>
10bee3: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bee6: 57 push %edi
10bee7: 68 e0 fa 11 00 push $0x11fae0
10beec: eb 19 jmp 10bf07 <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10beee: 8b 46 08 mov 0x8(%esi),%eax
10bef1: eb 07 jmp 10befa <_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 ) {
10bef3: 39 f8 cmp %edi,%eax
10bef5: 74 4a je 10bf41 <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10bef7: 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 ) {
10befa: 39 f0 cmp %esi,%eax
10befc: 75 f5 jne 10bef3 <_Heap_Walk+0x2d9>
10befe: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10bf01: 57 push %edi
10bf02: 68 4b fb 11 00 push $0x11fb4b
10bf07: 6a 01 push $0x1
10bf09: 53 push %ebx
10bf0a: ff 55 e4 call *-0x1c(%ebp)
10bf0d: 83 c4 10 add $0x10,%esp
10bf10: e9 85 fe ff ff jmp 10bd9a <_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) {
10bf15: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf19: 74 0e je 10bf29 <_Heap_Walk+0x30f>
(*printer)(
10bf1b: 83 ec 0c sub $0xc,%esp
10bf1e: ff 75 e0 pushl -0x20(%ebp)
10bf21: 57 push %edi
10bf22: 68 0f fb 11 00 push $0x11fb0f
10bf27: eb 0d jmp 10bf36 <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf29: 51 push %ecx
10bf2a: 51 push %ecx
10bf2b: ff 37 pushl (%edi)
10bf2d: ff 75 e0 pushl -0x20(%ebp)
10bf30: 57 push %edi
10bf31: 68 26 fb 11 00 push $0x11fb26
10bf36: 6a 00 push $0x0
10bf38: ff 75 dc pushl -0x24(%ebp)
10bf3b: ff 55 e4 call *-0x1c(%ebp)
10bf3e: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf41: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bf44: 0f 85 66 fe ff ff jne 10bdb0 <_Heap_Walk+0x196>
return true;
10bf4a: b0 01 mov $0x1,%al
}
10bf4c: 8d 65 f4 lea -0xc(%ebp),%esp
10bf4f: 5b pop %ebx
10bf50: 5e pop %esi
10bf51: 5f pop %edi
10bf52: c9 leave
10bf53: c3 ret
0010b23c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b23c: 55 push %ebp
10b23d: 89 e5 mov %esp,%ebp
10b23f: 53 push %ebx
10b240: 83 ec 08 sub $0x8,%esp
10b243: 8b 45 08 mov 0x8(%ebp),%eax
10b246: 8b 55 0c mov 0xc(%ebp),%edx
10b249: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b24c: a3 98 43 12 00 mov %eax,0x124398
_Internal_errors_What_happened.is_internal = is_internal;
10b251: 88 15 9c 43 12 00 mov %dl,0x12439c
_Internal_errors_What_happened.the_error = the_error;
10b257: 89 1d a0 43 12 00 mov %ebx,0x1243a0
_User_extensions_Fatal( the_source, is_internal, the_error );
10b25d: 53 push %ebx
10b25e: 0f b6 d2 movzbl %dl,%edx
10b261: 52 push %edx
10b262: 50 push %eax
10b263: e8 f7 19 00 00 call 10cc5f <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b268: c7 05 5c 44 12 00 05 movl $0x5,0x12445c <== NOT EXECUTED
10b26f: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b272: fa cli <== NOT EXECUTED
10b273: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b275: f4 hlt <== NOT EXECUTED
10b276: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b279: eb fe jmp 10b279 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b2cc <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b2cc: 55 push %ebp
10b2cd: 89 e5 mov %esp,%ebp
10b2cf: 56 push %esi
10b2d0: 53 push %ebx
10b2d1: 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;
10b2d4: 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 )
10b2d6: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b2da: 74 53 je 10b32f <_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 );
10b2dc: 8d 73 20 lea 0x20(%ebx),%esi
10b2df: 83 ec 0c sub $0xc,%esp
10b2e2: 56 push %esi
10b2e3: e8 30 f7 ff ff call 10aa18 <_Chain_Get>
10b2e8: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b2ea: 83 c4 10 add $0x10,%esp
10b2ed: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b2f1: 74 3c je 10b32f <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b2f3: 85 c0 test %eax,%eax
10b2f5: 75 1a jne 10b311 <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b2f7: 83 ec 0c sub $0xc,%esp
10b2fa: 53 push %ebx
10b2fb: e8 60 00 00 00 call 10b360 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b300: 89 34 24 mov %esi,(%esp)
10b303: e8 10 f7 ff ff call 10aa18 <_Chain_Get>
10b308: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b30a: 83 c4 10 add $0x10,%esp
10b30d: 85 c0 test %eax,%eax
10b30f: 74 1e je 10b32f <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b311: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b315: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b319: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b31b: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b31f: 31 d2 xor %edx,%edx
10b321: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b323: c1 e0 02 shl $0x2,%eax
10b326: 03 43 30 add 0x30(%ebx),%eax
10b329: ff 08 decl (%eax)
information->inactive--;
10b32b: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b32f: 89 c8 mov %ecx,%eax
10b331: 8d 65 f8 lea -0x8(%ebp),%esp
10b334: 5b pop %ebx
10b335: 5e pop %esi
10b336: c9 leave
10b337: c3 ret
0010b654 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b654: 55 push %ebp
10b655: 89 e5 mov %esp,%ebp
10b657: 57 push %edi
10b658: 56 push %esi
10b659: 53 push %ebx
10b65a: 83 ec 0c sub $0xc,%esp
10b65d: 8b 75 08 mov 0x8(%ebp),%esi
10b660: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b663: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b665: 66 85 ff test %di,%di
10b668: 74 37 je 10b6a1 <_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 );
10b66a: 83 ec 0c sub $0xc,%esp
10b66d: 56 push %esi
10b66e: e8 85 41 00 00 call 10f7f8 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b673: 83 c4 10 add $0x10,%esp
10b676: 85 c0 test %eax,%eax
10b678: 74 27 je 10b6a1 <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b67a: 0f b7 ff movzwl %di,%edi
10b67d: 39 c7 cmp %eax,%edi
10b67f: 77 20 ja 10b6a1 <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b681: 8b 04 b5 b8 42 12 00 mov 0x1242b8(,%esi,4),%eax
10b688: 85 c0 test %eax,%eax
10b68a: 74 15 je 10b6a1 <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b68c: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b68f: 85 db test %ebx,%ebx
10b691: 74 0e je 10b6a1 <_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;
10b693: 31 c0 xor %eax,%eax
10b695: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b69a: 0f 95 c0 setne %al
10b69d: f7 d8 neg %eax
10b69f: 21 c3 and %eax,%ebx
#endif
return info;
}
10b6a1: 89 d8 mov %ebx,%eax
10b6a3: 8d 65 f4 lea -0xc(%ebp),%esp
10b6a6: 5b pop %ebx
10b6a7: 5e pop %esi
10b6a8: 5f pop %edi
10b6a9: c9 leave
10b6aa: c3 ret
00118ac0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118ac0: 55 push %ebp
118ac1: 89 e5 mov %esp,%ebp
118ac3: 53 push %ebx
118ac4: 8b 55 08 mov 0x8(%ebp),%edx
118ac7: 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;
118aca: b8 01 00 00 00 mov $0x1,%eax
118acf: 2b 42 08 sub 0x8(%edx),%eax
118ad2: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118ad5: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118ad9: 39 c3 cmp %eax,%ebx
118adb: 72 12 jb 118aef <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118add: 8b 52 1c mov 0x1c(%edx),%edx
118ae0: 8b 04 82 mov (%edx,%eax,4),%eax
118ae3: 85 c0 test %eax,%eax
118ae5: 74 08 je 118aef <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118ae7: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118aed: eb 08 jmp 118af7 <_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;
118aef: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118af5: 31 c0 xor %eax,%eax
}
118af7: 5b pop %ebx
118af8: c9 leave
118af9: c3 ret
0010c880 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c880: 55 push %ebp
10c881: 89 e5 mov %esp,%ebp
10c883: 53 push %ebx
10c884: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c887: 8b 45 08 mov 0x8(%ebp),%eax
10c88a: 85 c0 test %eax,%eax
10c88c: 75 08 jne 10c896 <_Objects_Id_to_name+0x16>
10c88e: a1 98 78 12 00 mov 0x127898,%eax
10c893: 8b 40 08 mov 0x8(%eax),%eax
10c896: 89 c2 mov %eax,%edx
10c898: c1 ea 18 shr $0x18,%edx
10c89b: 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 )
10c89e: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c8a1: bb 03 00 00 00 mov $0x3,%ebx
10c8a6: 83 f9 02 cmp $0x2,%ecx
10c8a9: 77 36 ja 10c8e1 <_Objects_Id_to_name+0x61>
10c8ab: eb 3b jmp 10c8e8 <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c8ad: 89 c1 mov %eax,%ecx
10c8af: 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 ];
10c8b2: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8b5: 85 d2 test %edx,%edx
10c8b7: 74 28 je 10c8e1 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8b9: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8bd: 75 22 jne 10c8e1 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8bf: 51 push %ecx
10c8c0: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8c3: 51 push %ecx
10c8c4: 50 push %eax
10c8c5: 52 push %edx
10c8c6: e8 5d ff ff ff call 10c828 <_Objects_Get>
if ( !the_object )
10c8cb: 83 c4 10 add $0x10,%esp
10c8ce: 85 c0 test %eax,%eax
10c8d0: 74 0f je 10c8e1 <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c8d2: 8b 50 0c mov 0xc(%eax),%edx
10c8d5: 8b 45 0c mov 0xc(%ebp),%eax
10c8d8: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c8da: e8 9f 09 00 00 call 10d27e <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c8df: 31 db xor %ebx,%ebx
}
10c8e1: 89 d8 mov %ebx,%eax
10c8e3: 8b 5d fc mov -0x4(%ebp),%ebx
10c8e6: c9 leave
10c8e7: 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 ] )
10c8e8: 8b 14 95 24 73 12 00 mov 0x127324(,%edx,4),%edx
10c8ef: 85 d2 test %edx,%edx
10c8f1: 75 ba jne 10c8ad <_Objects_Id_to_name+0x2d>
10c8f3: eb ec jmp 10c8e1 <_Objects_Id_to_name+0x61>
0010e2b8 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e2b8: 55 push %ebp
10e2b9: 89 e5 mov %esp,%ebp
10e2bb: 57 push %edi
10e2bc: 56 push %esi
10e2bd: 53 push %ebx
10e2be: 83 ec 30 sub $0x30,%esp
10e2c1: 8b 75 08 mov 0x8(%ebp),%esi
10e2c4: 8b 5d 14 mov 0x14(%ebp),%ebx
10e2c7: 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 );
10e2ca: 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(
10e2cd: 50 push %eax
10e2ce: 56 push %esi
10e2cf: 68 f4 cc 12 00 push $0x12ccf4
10e2d4: 88 55 d4 mov %dl,-0x2c(%ebp)
10e2d7: e8 fc 2a 00 00 call 110dd8 <_Objects_Get>
switch ( location ) {
10e2dc: 83 c4 10 add $0x10,%esp
10e2df: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e2e3: 8a 55 d4 mov -0x2c(%ebp),%dl
10e2e6: 0f 85 aa 00 00 00 jne 10e396 <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e2ec: 8b 78 14 mov 0x14(%eax),%edi
10e2ef: 89 f9 mov %edi,%ecx
10e2f1: 83 e1 03 and $0x3,%ecx
10e2f4: 49 dec %ecx
10e2f5: 75 0a jne 10e301 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e2f7: e8 2e 35 00 00 call 11182a <_Thread_Enable_dispatch>
10e2fc: e9 95 00 00 00 jmp 10e396 <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e301: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e304: 8b 48 68 mov 0x68(%eax),%ecx
10e307: 39 4d 10 cmp %ecx,0x10(%ebp)
10e30a: 73 15 jae 10e321 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e30c: e8 19 35 00 00 call 11182a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e311: e8 52 8b 00 00 call 116e68 <__errno>
10e316: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e31c: e9 80 00 00 00 jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e321: 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 )
10e328: 31 c9 xor %ecx,%ecx
10e32a: 84 d2 test %dl,%dl
10e32c: 74 09 je 10e337 <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e32e: 81 e7 00 40 00 00 and $0x4000,%edi
10e334: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e337: 52 push %edx
10e338: 52 push %edx
10e339: ff 75 1c pushl 0x1c(%ebp)
10e33c: 0f b6 c9 movzbl %cl,%ecx
10e33f: 51 push %ecx
10e340: 8d 55 e0 lea -0x20(%ebp),%edx
10e343: 52 push %edx
10e344: ff 75 0c pushl 0xc(%ebp)
10e347: 56 push %esi
10e348: 83 c0 1c add $0x1c,%eax
10e34b: 50 push %eax
10e34c: e8 7f 1c 00 00 call 10ffd0 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e351: 83 c4 20 add $0x20,%esp
10e354: e8 d1 34 00 00 call 11182a <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e359: a1 6c cd 12 00 mov 0x12cd6c,%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);
10e35e: 8b 50 24 mov 0x24(%eax),%edx
10e361: c1 fa 1f sar $0x1f,%edx
10e364: 8b 48 24 mov 0x24(%eax),%ecx
10e367: 31 d1 xor %edx,%ecx
10e369: 89 0b mov %ecx,(%ebx)
10e36b: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e36d: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e371: 75 05 jne 10e378 <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e373: 8b 45 e0 mov -0x20(%ebp),%eax
10e376: eb 2c jmp 10e3a4 <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e378: e8 eb 8a 00 00 call 116e68 <__errno>
10e37d: 89 c3 mov %eax,%ebx
10e37f: 83 ec 0c sub $0xc,%esp
10e382: a1 6c cd 12 00 mov 0x12cd6c,%eax
10e387: ff 70 34 pushl 0x34(%eax)
10e38a: e8 ed 01 00 00 call 10e57c <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e38f: 89 03 mov %eax,(%ebx)
10e391: 83 c4 10 add $0x10,%esp
10e394: eb 0b jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e396: e8 cd 8a 00 00 call 116e68 <__errno>
10e39b: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3a1: 83 c8 ff or $0xffffffff,%eax
}
10e3a4: 8d 65 f4 lea -0xc(%ebp),%esp
10e3a7: 5b pop %ebx
10e3a8: 5e pop %esi
10e3a9: 5f pop %edi
10e3aa: c9 leave
10e3ab: c3 ret
0010e94c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e94c: 55 push %ebp
10e94d: 89 e5 mov %esp,%ebp
10e94f: 83 ec 08 sub $0x8,%esp
10e952: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e955: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e95b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10e962: 75 2c jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e964: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10e96b: 75 23 jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e96d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10e974: 74 1a je 10e990 <_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;
10e976: a1 d0 52 12 00 mov 0x1252d0,%eax
10e97b: 48 dec %eax
10e97c: a3 d0 52 12 00 mov %eax,0x1252d0
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10e981: 50 push %eax
10e982: 50 push %eax
10e983: 6a ff push $0xffffffff
10e985: 52 push %edx
10e986: e8 51 08 00 00 call 10f1dc <_POSIX_Thread_Exit>
10e98b: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10e98e: c9 leave
10e98f: c3 ret
10e990: 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();
10e991: e9 ec da ff ff jmp 10c482 <_Thread_Enable_dispatch>
0010fbd4 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10fbd4: 55 push %ebp
10fbd5: 89 e5 mov %esp,%ebp
10fbd7: 57 push %edi
10fbd8: 56 push %esi
10fbd9: 53 push %ebx
10fbda: 83 ec 28 sub $0x28,%esp
10fbdd: 8b 55 08 mov 0x8(%ebp),%edx
10fbe0: 8b 5d 0c mov 0xc(%ebp),%ebx
10fbe3: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fbe6: ff 33 pushl (%ebx)
10fbe8: 89 55 e0 mov %edx,-0x20(%ebp)
10fbeb: e8 c4 ff ff ff call 10fbb4 <_POSIX_Priority_Is_valid>
10fbf0: 83 c4 10 add $0x10,%esp
return EINVAL;
10fbf3: 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 ) )
10fbf8: 84 c0 test %al,%al
10fbfa: 8b 55 e0 mov -0x20(%ebp),%edx
10fbfd: 0f 84 a4 00 00 00 je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fc03: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fc09: 8b 45 14 mov 0x14(%ebp),%eax
10fc0c: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fc12: 85 d2 test %edx,%edx
10fc14: 75 0b jne 10fc21 <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fc16: c7 07 01 00 00 00 movl $0x1,(%edi)
10fc1c: e9 83 00 00 00 jmp 10fca4 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fc21: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fc23: 83 fa 01 cmp $0x1,%edx
10fc26: 74 7f je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fc28: 83 fa 02 cmp $0x2,%edx
10fc2b: 75 08 jne 10fc35 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fc2d: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fc33: eb 72 jmp 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fc35: 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 ) {
10fc3a: 83 fa 04 cmp $0x4,%edx
10fc3d: 75 68 jne 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fc3f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fc43: 75 06 jne 10fc4b <_POSIX_Thread_Translate_sched_param+0x77>
10fc45: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fc49: 74 5c je 10fca7 <_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) &&
10fc4b: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fc4f: 75 0b jne 10fc5c <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fc51: 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) &&
10fc56: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fc5a: 74 4b je 10fca7 <_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 ) <
10fc5c: 83 ec 0c sub $0xc,%esp
10fc5f: 8d 43 08 lea 0x8(%ebx),%eax
10fc62: 50 push %eax
10fc63: e8 18 de ff ff call 10da80 <_Timespec_To_ticks>
10fc68: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fc6b: 8d 43 10 lea 0x10(%ebx),%eax
10fc6e: 89 04 24 mov %eax,(%esp)
10fc71: e8 0a de ff ff call 10da80 <_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 ) <
10fc76: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fc79: 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 ) <
10fc7e: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fc81: 72 24 jb 10fca7 <_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 ) )
10fc83: 83 ec 0c sub $0xc,%esp
10fc86: ff 73 04 pushl 0x4(%ebx)
10fc89: e8 26 ff ff ff call 10fbb4 <_POSIX_Priority_Is_valid>
10fc8e: 83 c4 10 add $0x10,%esp
10fc91: 84 c0 test %al,%al
10fc93: 74 12 je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fc95: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fc9b: 8b 45 14 mov 0x14(%ebp),%eax
10fc9e: c7 00 e9 a7 10 00 movl $0x10a7e9,(%eax)
return 0;
10fca4: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fca7: 89 f0 mov %esi,%eax
10fca9: 8d 65 f4 lea -0xc(%ebp),%esp
10fcac: 5b pop %ebx
10fcad: 5e pop %esi
10fcae: 5f pop %edi
10fcaf: c9 leave
10fcb0: c3 ret
0010a4ec <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a4ec: 55 push %ebp
10a4ed: 89 e5 mov %esp,%ebp
10a4ef: 57 push %edi
10a4f0: 56 push %esi
10a4f1: 53 push %ebx
10a4f2: 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;
10a4f5: 8b 3d 10 12 12 00 mov 0x121210,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a4fb: 8b 15 0c 12 12 00 mov 0x12120c,%edx
if ( !user_threads || maximum == 0 )
10a501: 85 d2 test %edx,%edx
10a503: 74 54 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a505: 85 ff test %edi,%edi
10a507: 74 50 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a509: 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 );
10a50b: 8d 75 a4 lea -0x5c(%ebp),%esi
10a50e: 83 ec 0c sub $0xc,%esp
10a511: 56 push %esi
10a512: 89 55 94 mov %edx,-0x6c(%ebp)
10a515: e8 9a 57 00 00 call 10fcb4 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a51a: 5a pop %edx
10a51b: 59 pop %ecx
10a51c: 6a 02 push $0x2
10a51e: 56 push %esi
10a51f: e8 b8 57 00 00 call 10fcdc <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a524: 59 pop %ecx
10a525: 58 pop %eax
10a526: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a52a: 56 push %esi
10a52b: e8 d8 57 00 00 call 10fd08 <pthread_attr_setstacksize>
status = pthread_create(
10a530: 6a 00 push $0x0
10a532: ff 34 df pushl (%edi,%ebx,8)
10a535: 56 push %esi
10a536: 8d 45 e4 lea -0x1c(%ebp),%eax
10a539: 50 push %eax
10a53a: e8 e5 fc ff ff call 10a224 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a53f: 83 c4 20 add $0x20,%esp
10a542: 85 c0 test %eax,%eax
10a544: 8b 55 94 mov -0x6c(%ebp),%edx
10a547: 74 0b je 10a554 <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a549: 52 push %edx
10a54a: 50 push %eax
10a54b: 6a 01 push $0x1
10a54d: 6a 02 push $0x2
10a54f: e8 f8 1b 00 00 call 10c14c <_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++ ) {
10a554: 43 inc %ebx
10a555: 39 d3 cmp %edx,%ebx
10a557: 72 b5 jb 10a50e <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a559: 8d 65 f4 lea -0xc(%ebp),%esp
10a55c: 5b pop %ebx
10a55d: 5e pop %esi
10a55e: 5f pop %edi
10a55f: c9 leave
10a560: c3 ret
0010ed2f <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10ed2f: 55 push %ebp
10ed30: 89 e5 mov %esp,%ebp
10ed32: 56 push %esi
10ed33: 53 push %ebx
10ed34: 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 ];
10ed37: 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 );
10ed3d: 83 ec 0c sub $0xc,%esp
10ed40: 8d 86 98 00 00 00 lea 0x98(%esi),%eax
10ed46: 50 push %eax
10ed47: e8 44 0e 00 00 call 10fb90 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10ed4c: 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);
10ed4f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax
10ed56: 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;
10ed5c: 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 ) {
10ed5f: 83 c4 10 add $0x10,%esp
10ed62: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10ed66: 75 12 jne 10ed7a <_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 ) {
10ed68: 39 43 14 cmp %eax,0x14(%ebx)
10ed6b: 76 0d jbe 10ed7a <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10ed6d: 52 push %edx
10ed6e: 6a 01 push $0x1
10ed70: 50 push %eax
10ed71: 53 push %ebx
10ed72: e8 1d cf ff ff call 10bc94 <_Thread_Change_priority>
10ed77: 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 );
10ed7a: 83 ec 0c sub $0xc,%esp
10ed7d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10ed83: 50 push %eax
10ed84: e8 07 0e 00 00 call 10fb90 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10ed89: 89 86 b4 00 00 00 mov %eax,0xb4(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10ed8f: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10ed92: 81 c6 a8 00 00 00 add $0xa8,%esi
10ed98: 89 75 0c mov %esi,0xc(%ebp)
10ed9b: c7 45 08 c4 43 12 00 movl $0x1243c4,0x8(%ebp)
}
10eda2: 8d 65 f8 lea -0x8(%ebp),%esp
10eda5: 5b pop %ebx
10eda6: 5e pop %esi
10eda7: c9 leave
10eda8: e9 d3 df ff ff jmp 10cd80 <_Watchdog_Insert>
0010edad <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10edad: 55 push %ebp
10edae: 89 e5 mov %esp,%ebp
10edb0: 83 ec 08 sub $0x8,%esp
10edb3: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10edb6: 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 */
10edbc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10edc3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx
10edca: 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;
10edd0: 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 ) {
10edd3: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10edd7: 75 12 jne 10edeb <_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 ) {
10edd9: 39 50 14 cmp %edx,0x14(%eax)
10eddc: 73 0d jae 10edeb <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10edde: 51 push %ecx
10eddf: 6a 01 push $0x1
10ede1: 52 push %edx
10ede2: 50 push %eax
10ede3: e8 ac ce ff ff call 10bc94 <_Thread_Change_priority>
10ede8: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10edeb: c9 leave
10edec: c3 ret
0010a2ac <_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)
{
10a2ac: 55 push %ebp
10a2ad: 89 e5 mov %esp,%ebp
10a2af: 53 push %ebx
10a2b0: 83 ec 04 sub $0x4,%esp
10a2b3: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a2b6: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a2b9: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a2bd: 75 06 jne 10a2c5 <_POSIX_Timer_TSR+0x19>
10a2bf: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a2c3: 74 34 je 10a2f9 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a2c5: 83 ec 0c sub $0xc,%esp
10a2c8: 53 push %ebx
10a2c9: 68 ac a2 10 00 push $0x10a2ac
10a2ce: ff 73 08 pushl 0x8(%ebx)
10a2d1: ff 73 64 pushl 0x64(%ebx)
10a2d4: 8d 43 10 lea 0x10(%ebx),%eax
10a2d7: 50 push %eax
10a2d8: e8 b3 56 00 00 call 10f990 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a2dd: 83 c4 20 add $0x20,%esp
10a2e0: 84 c0 test %al,%al
10a2e2: 74 30 je 10a314 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a2e4: 83 ec 0c sub $0xc,%esp
10a2e7: 8d 43 6c lea 0x6c(%ebx),%eax
10a2ea: 50 push %eax
10a2eb: e8 5c 14 00 00 call 10b74c <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2f0: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a2f4: 83 c4 10 add $0x10,%esp
10a2f7: eb 04 jmp 10a2fd <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a2f9: 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 ) ) {
10a2fd: 50 push %eax
10a2fe: 50 push %eax
10a2ff: ff 73 44 pushl 0x44(%ebx)
10a302: ff 73 38 pushl 0x38(%ebx)
10a305: e8 5a 52 00 00 call 10f564 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a30a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a311: 83 c4 10 add $0x10,%esp
}
10a314: 8b 5d fc mov -0x4(%ebp),%ebx
10a317: c9 leave
10a318: c3 ret
00110b5c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110b5c: 55 push %ebp
110b5d: 89 e5 mov %esp,%ebp
110b5f: 57 push %edi
110b60: 56 push %esi
110b61: 53 push %ebx
110b62: 83 ec 68 sub $0x68,%esp
110b65: 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,
110b68: 6a 01 push $0x1
110b6a: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110b6e: 50 push %eax
110b6f: 8d 45 dc lea -0x24(%ebp),%eax
110b72: 50 push %eax
110b73: 53 push %ebx
110b74: ff 75 08 pushl 0x8(%ebp)
110b77: e8 8c 00 00 00 call 110c08 <_POSIX_signals_Clear_signals>
110b7c: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110b7f: 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,
110b81: 84 c0 test %al,%al
110b83: 74 78 je 110bfd <_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 )
110b85: 6b d3 0c imul $0xc,%ebx,%edx
110b88: 8b 82 68 48 12 00 mov 0x124868(%edx),%eax
110b8e: 83 f8 01 cmp $0x1,%eax
110b91: 74 6a je 110bfd <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110b93: 8b 4d 08 mov 0x8(%ebp),%ecx
110b96: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110b9c: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110b9f: 0b 8a 64 48 12 00 or 0x124864(%edx),%ecx
110ba5: 8b 75 08 mov 0x8(%ebp),%esi
110ba8: 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,
110bae: 8d 7d b4 lea -0x4c(%ebp),%edi
110bb1: 8b 35 2c 48 12 00 mov 0x12482c,%esi
110bb7: 83 c6 20 add $0x20,%esi
110bba: b9 0a 00 00 00 mov $0xa,%ecx
110bbf: 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 ) {
110bc1: 83 ba 60 48 12 00 02 cmpl $0x2,0x124860(%edx)
110bc8: 75 09 jne 110bd3 <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110bca: 52 push %edx
110bcb: 6a 00 push $0x0
110bcd: 8d 55 dc lea -0x24(%ebp),%edx
110bd0: 52 push %edx
110bd1: eb 03 jmp 110bd6 <_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 );
110bd3: 83 ec 0c sub $0xc,%esp
110bd6: 53 push %ebx
110bd7: ff d0 call *%eax
break;
110bd9: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110bdc: 8b 3d 2c 48 12 00 mov 0x12482c,%edi
110be2: 83 c7 20 add $0x20,%edi
110be5: 8d 75 b4 lea -0x4c(%ebp),%esi
110be8: b9 0a 00 00 00 mov $0xa,%ecx
110bed: 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;
110bef: 8b 75 a4 mov -0x5c(%ebp),%esi
110bf2: 8b 4d 08 mov 0x8(%ebp),%ecx
110bf5: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110bfb: b1 01 mov $0x1,%cl
}
110bfd: 88 c8 mov %cl,%al
110bff: 8d 65 f4 lea -0xc(%ebp),%esp
110c02: 5b pop %ebx
110c03: 5e pop %esi
110c04: 5f pop %edi
110c05: c9 leave
110c06: c3 ret
001110f0 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
1110f0: 55 push %ebp
1110f1: 89 e5 mov %esp,%ebp
1110f3: 53 push %ebx
1110f4: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
1110f7: 9c pushf
1110f8: fa cli
1110f9: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
1110fa: 6b c1 0c imul $0xc,%ecx,%eax
1110fd: 83 b8 60 48 12 00 02 cmpl $0x2,0x124860(%eax)
111104: 75 0e jne 111114 <_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 );
111106: 8d 98 5c 4a 12 00 lea 0x124a5c(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
11110c: 39 98 58 4a 12 00 cmp %ebx,0x124a58(%eax)
111112: 75 0e jne 111122 <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
111114: 49 dec %ecx
111115: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
11111a: d3 c0 rol %cl,%eax
11111c: 21 05 54 4a 12 00 and %eax,0x124a54
}
_ISR_Enable( level );
111122: 52 push %edx
111123: 9d popf
}
111124: 5b pop %ebx
111125: c9 leave
111126: c3 ret
0010ab64 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10ab64: 55 push %ebp
10ab65: 89 e5 mov %esp,%ebp
10ab67: 56 push %esi
10ab68: 53 push %ebx
10ab69: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab6c: b8 1b 00 00 00 mov $0x1b,%eax
10ab71: 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(
10ab76: 8d 48 ff lea -0x1(%eax),%ecx
10ab79: 89 de mov %ebx,%esi
10ab7b: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab7d: 85 d6 test %edx,%esi
10ab7f: 75 1e jne 10ab9f <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab81: 40 inc %eax
10ab82: 83 f8 20 cmp $0x20,%eax
10ab85: 75 ef jne 10ab76 <_POSIX_signals_Get_lowest+0x12>
10ab87: b0 01 mov $0x1,%al
10ab89: 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(
10ab8e: 8d 48 ff lea -0x1(%eax),%ecx
10ab91: 89 de mov %ebx,%esi
10ab93: 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 ) ) {
10ab95: 85 d6 test %edx,%esi
10ab97: 75 06 jne 10ab9f <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10ab99: 40 inc %eax
10ab9a: 83 f8 1b cmp $0x1b,%eax
10ab9d: 75 ef jne 10ab8e <_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;
}
10ab9f: 5b pop %ebx
10aba0: 5e pop %esi
10aba1: c9 leave
10aba2: c3 ret
001218e8 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
1218e8: 55 push %ebp
1218e9: 89 e5 mov %esp,%ebp
1218eb: 57 push %edi
1218ec: 56 push %esi
1218ed: 53 push %ebx
1218ee: 83 ec 0c sub $0xc,%esp
1218f1: 8b 5d 08 mov 0x8(%ebp),%ebx
1218f4: 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 ];
1218f7: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
1218fd: 8d 4e ff lea -0x1(%esi),%ecx
121900: ba 01 00 00 00 mov $0x1,%edx
121905: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
121907: 8b 4b 10 mov 0x10(%ebx),%ecx
12190a: 89 cf mov %ecx,%edi
12190c: 81 e7 00 80 00 10 and $0x10008000,%edi
121912: 81 ff 00 80 00 10 cmp $0x10008000,%edi
121918: 75 58 jne 121972 <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
12191a: 85 53 30 test %edx,0x30(%ebx)
12191d: 75 12 jne 121931 <_POSIX_signals_Unblock_thread+0x49>
12191f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
121925: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
121927: 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) ) {
121929: 85 c2 test %eax,%edx
12192b: 0f 84 b0 00 00 00 je 1219e1 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
121931: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
121938: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
12193b: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
12193f: 75 12 jne 121953 <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
121941: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
121943: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
12194a: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
121951: eb 0c jmp 12195f <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
121953: b9 03 00 00 00 mov $0x3,%ecx
121958: 89 c7 mov %eax,%edi
12195a: 8b 75 10 mov 0x10(%ebp),%esi
12195d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
12195f: 83 ec 0c sub $0xc,%esp
121962: 53 push %ebx
121963: e8 88 f5 fe ff call 110ef0 <_Thread_queue_Extract_with_proxy>
return true;
121968: 83 c4 10 add $0x10,%esp
12196b: bf 01 00 00 00 mov $0x1,%edi
121970: eb 6f jmp 1219e1 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
121972: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
121978: 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;
12197a: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
12197c: 85 c2 test %eax,%edx
12197e: 74 61 je 1219e1 <_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 ) ) {
121980: f7 c1 00 00 00 10 test $0x10000000,%ecx
121986: 74 3d je 1219c5 <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
121988: 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) )
12198f: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
121995: 74 0b je 1219a2 <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
121997: 83 ec 0c sub $0xc,%esp
12199a: 53 push %ebx
12199b: e8 50 f5 fe ff call 110ef0 <_Thread_queue_Extract_with_proxy>
1219a0: eb 1e jmp 1219c0 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
1219a2: 80 e1 08 and $0x8,%cl
1219a5: 74 3a je 1219e1 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
1219a7: 83 ec 0c sub $0xc,%esp
1219aa: 8d 43 48 lea 0x48(%ebx),%eax
1219ad: 50 push %eax
1219ae: e8 9d fc fe ff call 111650 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
1219b3: 58 pop %eax
1219b4: 5a pop %edx
1219b5: 68 f8 ff 03 10 push $0x1003fff8
1219ba: 53 push %ebx
1219bb: e8 a0 eb fe ff call 110560 <_Thread_Clear_state>
1219c0: 83 c4 10 add $0x10,%esp
1219c3: eb 1c jmp 1219e1 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
1219c5: 85 c9 test %ecx,%ecx
1219c7: 75 18 jne 1219e1 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1219c9: 83 3d 9c a9 12 00 00 cmpl $0x0,0x12a99c
1219d0: 74 0f je 1219e1 <_POSIX_signals_Unblock_thread+0xf9>
1219d2: 3b 1d a0 a9 12 00 cmp 0x12a9a0,%ebx
1219d8: 75 07 jne 1219e1 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
1219da: c6 05 ac a9 12 00 01 movb $0x1,0x12a9ac
}
}
return false;
}
1219e1: 89 f8 mov %edi,%eax
1219e3: 8d 65 f4 lea -0xc(%ebp),%esp
1219e6: 5b pop %ebx
1219e7: 5e pop %esi
1219e8: 5f pop %edi
1219e9: c9 leave
1219ea: c3 ret
0010b3b4 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3b4: 55 push %ebp
10b3b5: 89 e5 mov %esp,%ebp
10b3b7: 53 push %ebx
10b3b8: 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 );
10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax
10b3be: 50 push %eax
10b3bf: ff 75 08 pushl 0x8(%ebp)
10b3c2: 68 14 73 12 00 push $0x127314
10b3c7: e8 d8 1a 00 00 call 10cea4 <_Objects_Get>
10b3cc: 89 c3 mov %eax,%ebx
switch ( location ) {
10b3ce: 83 c4 10 add $0x10,%esp
10b3d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b3d5: 75 64 jne 10b43b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b3d7: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b3da: f6 40 11 40 testb $0x40,0x11(%eax)
10b3de: 74 18 je 10b3f8 <_Rate_monotonic_Timeout+0x44>
10b3e0: 8b 53 08 mov 0x8(%ebx),%edx
10b3e3: 39 50 20 cmp %edx,0x20(%eax)
10b3e6: 75 10 jne 10b3f8 <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b3e8: 52 push %edx
10b3e9: 52 push %edx
10b3ea: 68 f8 ff 03 10 push $0x1003fff8
10b3ef: 50 push %eax
10b3f0: e8 5b 21 00 00 call 10d550 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b3f5: 59 pop %ecx
10b3f6: eb 10 jmp 10b408 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b3f8: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b3fc: 75 2b jne 10b429 <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b3fe: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b405: 83 ec 0c sub $0xc,%esp
10b408: 53 push %ebx
10b409: e8 ec fa ff ff call 10aefa <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b40e: 8b 43 3c mov 0x3c(%ebx),%eax
10b411: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b414: 58 pop %eax
10b415: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b416: 83 c3 10 add $0x10,%ebx
10b419: 53 push %ebx
10b41a: 68 e8 74 12 00 push $0x1274e8
10b41f: e8 04 32 00 00 call 10e628 <_Watchdog_Insert>
10b424: 83 c4 10 add $0x10,%esp
10b427: eb 07 jmp 10b430 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b429: 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;
10b430: a1 04 74 12 00 mov 0x127404,%eax
10b435: 48 dec %eax
10b436: a3 04 74 12 00 mov %eax,0x127404
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b43b: 8b 5d fc mov -0x4(%ebp),%ebx
10b43e: c9 leave
10b43f: c3 ret
0010f810 <_Scheduler_priority_Block>:
void _Scheduler_priority_Block(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
10f810: 55 push %ebp
10f811: 89 e5 mov %esp,%ebp
10f813: 56 push %esi
10f814: 53 push %ebx
10f815: 8b 55 0c mov 0xc(%ebp),%edx
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract(
Thread_Control *the_thread
)
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
10f818: 8b 82 8c 00 00 00 mov 0x8c(%edx),%eax
10f81e: 8b 00 mov (%eax),%eax
if ( _Chain_Has_only_one_node( ready ) ) {
10f820: 8b 48 08 mov 0x8(%eax),%ecx
10f823: 39 08 cmp %ecx,(%eax)
10f825: 75 38 jne 10f85f <_Scheduler_priority_Block+0x4f>
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 );
10f827: 8d 48 04 lea 0x4(%eax),%ecx
10f82a: 89 08 mov %ecx,(%eax)
head->next = tail;
head->previous = NULL;
10f82c: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10f833: 89 40 08 mov %eax,0x8(%eax)
_Chain_Initialize_empty( ready );
_Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map );
10f836: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
10f83c: 8b 59 04 mov 0x4(%ecx),%ebx
10f83f: 66 8b 03 mov (%ebx),%ax
10f842: 66 23 41 0e and 0xe(%ecx),%ax
10f846: 66 89 03 mov %ax,(%ebx)
if ( *the_priority_map->minor == 0 )
10f849: 66 85 c0 test %ax,%ax
10f84c: 75 1b jne 10f869 <_Scheduler_priority_Block+0x59>
_Priority_Major_bit_map &= the_priority_map->block_major;
10f84e: 66 a1 3c 48 12 00 mov 0x12483c,%ax
10f854: 23 41 0c and 0xc(%ecx),%eax
10f857: 66 a3 3c 48 12 00 mov %ax,0x12483c
10f85d: eb 0a jmp 10f869 <_Scheduler_priority_Block+0x59>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10f85f: 8b 0a mov (%edx),%ecx
previous = the_node->previous;
10f861: 8b 42 04 mov 0x4(%edx),%eax
next->previous = previous;
10f864: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
10f867: 89 08 mov %ecx,(%eax)
{
_Scheduler_priority_Ready_queue_extract(the_thread);
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
10f869: 3b 15 30 48 12 00 cmp 0x124830,%edx
10f86f: 75 42 jne 10f8b3 <_Scheduler_priority_Block+0xa3>
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 );
10f871: 66 8b 35 3c 48 12 00 mov 0x12483c,%si
10f878: 31 c9 xor %ecx,%ecx
10f87a: 89 cb mov %ecx,%ebx
10f87c: 66 0f bc de bsf %si,%bx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10f880: 0f b7 db movzwl %bx,%ebx
10f883: 66 8b b4 1b 40 48 12 mov 0x124840(%ebx,%ebx,1),%si
10f88a: 00
10f88b: 66 0f bc ce bsf %si,%cx
return (_Priority_Bits_index( major ) << 4) +
10f88f: c1 e3 04 shl $0x4,%ebx
10f892: 0f b7 c9 movzwl %cx,%ecx
10f895: 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 ] ) )
10f898: 6b c0 0c imul $0xc,%eax,%eax
10f89b: 8b 4d 08 mov 0x8(%ebp),%ecx
10f89e: 03 01 add (%ecx),%eax
_Scheduler_priority_Block_body(the_scheduler, the_thread);
}
10f8a0: 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 );
10f8a2: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10f8a5: 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 ] ) )
10f8a7: 39 c3 cmp %eax,%ebx
10f8a9: 74 02 je 10f8ad <_Scheduler_priority_Block+0x9d><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10f8ab: 89 d9 mov %ebx,%ecx
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10f8ad: 89 0d 30 48 12 00 mov %ecx,0x124830
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body(the_scheduler);
if ( _Thread_Is_executing( the_thread ) )
10f8b3: 3b 15 2c 48 12 00 cmp 0x12482c,%edx
10f8b9: 75 07 jne 10f8c2 <_Scheduler_priority_Block+0xb2>
_Thread_Dispatch_necessary = true;
10f8bb: c6 05 38 48 12 00 01 movb $0x1,0x124838
10f8c2: 5b pop %ebx
10f8c3: 5e pop %esi
10f8c4: c9 leave
10f8c5: c3 ret
0010baac <_Scheduler_priority_Schedule>:
*/
void _Scheduler_priority_Schedule(
Scheduler_Control *the_scheduler
)
{
10baac: 55 push %ebp
10baad: 89 e5 mov %esp,%ebp
10baaf: 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 );
10bab0: 66 8b 1d 3c 48 12 00 mov 0x12483c,%bx
10bab7: 31 d2 xor %edx,%edx
10bab9: 89 d1 mov %edx,%ecx
10babb: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10babf: 0f b7 c9 movzwl %cx,%ecx
10bac2: 66 8b 9c 09 40 48 12 mov 0x124840(%ecx,%ecx,1),%bx
10bac9: 00
10baca: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10bace: c1 e1 04 shl $0x4,%ecx
10bad1: 0f b7 d2 movzwl %dx,%edx
10bad4: 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 ] ) )
10bad7: 6b c0 0c imul $0xc,%eax,%eax
10bada: 8b 55 08 mov 0x8(%ebp),%edx
10badd: 03 02 add (%edx),%eax
_Scheduler_priority_Schedule_body( the_scheduler );
}
10badf: 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 );
10bae1: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bae4: 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 ] ) )
10bae6: 39 c1 cmp %eax,%ecx
10bae8: 74 02 je 10baec <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10baea: 89 ca mov %ecx,%edx
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10baec: 89 15 30 48 12 00 mov %edx,0x124830
10baf2: 5b pop %ebx
10baf3: c9 leave
10baf4: c3 ret
0010acb4 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10acb4: 55 push %ebp
10acb5: 89 e5 mov %esp,%ebp
10acb7: 56 push %esi
10acb8: 53 push %ebx
10acb9: 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();
10acbc: 8b 35 84 42 12 00 mov 0x124284,%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;
10acc2: 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) ||
10acc4: 85 c9 test %ecx,%ecx
10acc6: 74 57 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10acc8: b8 40 42 0f 00 mov $0xf4240,%eax
10accd: 31 d2 xor %edx,%edx
10accf: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acd1: 39 41 18 cmp %eax,0x18(%ecx)
10acd4: 73 49 jae 10ad1f <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10acd6: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10acda: 77 43 ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10acdc: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ace0: 77 3d ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ace2: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10ace6: 77 37 ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10ace8: 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) ||
10aceb: 85 c0 test %eax,%eax
10aced: 74 30 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10acef: 83 f8 0c cmp $0xc,%eax
10acf2: 77 2b ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10acf4: 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) ||
10acf6: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10acfc: 76 21 jbe 10ad1f <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10acfe: 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) ||
10ad01: 85 d2 test %edx,%edx
10ad03: 74 1a je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad05: 83 e6 03 and $0x3,%esi
10ad08: 75 09 jne 10ad13 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad0a: 8b 04 85 6c 14 12 00 mov 0x12146c(,%eax,4),%eax
10ad11: eb 07 jmp 10ad1a <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad13: 8b 04 85 38 14 12 00 mov 0x121438(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad1a: 39 c2 cmp %eax,%edx
10ad1c: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad1f: 88 d8 mov %bl,%al
10ad21: 5b pop %ebx
10ad22: 5e pop %esi
10ad23: c9 leave
10ad24: c3 ret
0010bc94 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10bc94: 55 push %ebp
10bc95: 89 e5 mov %esp,%ebp
10bc97: 57 push %edi
10bc98: 56 push %esi
10bc99: 53 push %ebx
10bc9a: 83 ec 28 sub $0x28,%esp
10bc9d: 8b 5d 08 mov 0x8(%ebp),%ebx
10bca0: 8b 75 0c mov 0xc(%ebp),%esi
10bca3: 8a 45 10 mov 0x10(%ebp),%al
10bca6: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10bca9: 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 );
10bcac: 53 push %ebx
10bcad: e8 1a 0c 00 00 call 10c8cc <_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 )
10bcb2: 83 c4 10 add $0x10,%esp
10bcb5: 39 73 14 cmp %esi,0x14(%ebx)
10bcb8: 74 0c je 10bcc6 <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10bcba: 50 push %eax
10bcbb: 50 push %eax
10bcbc: 56 push %esi
10bcbd: 53 push %ebx
10bcbe: e8 a9 0b 00 00 call 10c86c <_Thread_Set_priority>
10bcc3: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10bcc6: 9c pushf
10bcc7: fa cli
10bcc8: 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;
10bcc9: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10bccc: 83 f8 04 cmp $0x4,%eax
10bccf: 74 2f je 10bd00 <_Thread_Change_priority+0x6c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10bcd1: 83 e7 04 and $0x4,%edi
10bcd4: 75 08 jne 10bcde <_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);
10bcd6: 89 c2 mov %eax,%edx
10bcd8: 83 e2 fb and $0xfffffffb,%edx
10bcdb: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10bcde: 56 push %esi
10bcdf: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10bce0: a9 e0 be 03 00 test $0x3bee0,%eax
10bce5: 0f 84 b5 00 00 00 je 10bda0 <_Thread_Change_priority+0x10c>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10bceb: 89 5d 0c mov %ebx,0xc(%ebp)
10bcee: 8b 43 44 mov 0x44(%ebx),%eax
10bcf1: 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 );
}
10bcf4: 8d 65 f4 lea -0xc(%ebp),%esp
10bcf7: 5b pop %ebx
10bcf8: 5e pop %esi
10bcf9: 5f pop %edi
10bcfa: 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 );
10bcfb: e9 e4 0a 00 00 jmp 10c7e4 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10bd00: 83 e7 04 and $0x4,%edi
10bd03: 75 6b jne 10bd70 <_Thread_Change_priority+0xdc><== NEVER TAKEN
* Ready Queue with interrupts off.
*
* FIXME: hard-coded for priority scheduling. Might be ok since this
* function is specific to priority scheduling?
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10bd05: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10bd0c: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10bd10: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bd16: 74 2b je 10bd43 <_Thread_Change_priority+0xaf>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bd18: 8b 50 04 mov 0x4(%eax),%edx
10bd1b: 66 8b 48 0a mov 0xa(%eax),%cx
10bd1f: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bd22: 66 8b 15 3c 48 12 00 mov 0x12483c,%dx
10bd29: 0b 50 08 or 0x8(%eax),%edx
10bd2c: 66 89 15 3c 48 12 00 mov %dx,0x12483c
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
_Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain,
10bd33: 8b 00 mov (%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10bd35: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10bd38: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10bd3a: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10bd3c: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10bd3e: 89 5a 04 mov %ebx,0x4(%edx)
10bd41: eb 2d jmp 10bd70 <_Thread_Change_priority+0xdc>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bd43: 8b 50 04 mov 0x4(%eax),%edx
10bd46: 66 8b 48 0a mov 0xa(%eax),%cx
10bd4a: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bd4d: 66 8b 15 3c 48 12 00 mov 0x12483c,%dx
10bd54: 0b 50 08 or 0x8(%eax),%edx
10bd57: 66 89 15 3c 48 12 00 mov %dx,0x12483c
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
10bd5e: 8b 00 mov (%eax),%eax
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10bd60: 8b 50 08 mov 0x8(%eax),%edx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10bd63: 8d 48 04 lea 0x4(%eax),%ecx
10bd66: 89 0b mov %ecx,(%ebx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10bd68: 89 58 08 mov %ebx,0x8(%eax)
old_last->next = the_node;
10bd6b: 89 1a mov %ebx,(%edx)
the_node->previous = old_last;
10bd6d: 89 53 04 mov %edx,0x4(%ebx)
_Scheduler_priority_Ready_queue_enqueue_first( the_thread );
else
_Scheduler_priority_Ready_queue_enqueue( the_thread );
}
_ISR_Flash( level );
10bd70: 56 push %esi
10bd71: 9d popf
10bd72: fa cli
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule(
Scheduler_Control *the_scheduler
)
{
the_scheduler->Operations.schedule( the_scheduler );
10bd73: 83 ec 0c sub $0xc,%esp
10bd76: 68 68 43 12 00 push $0x124368
10bd7b: ff 15 6c 43 12 00 call *0x12436c
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10bd81: a1 2c 48 12 00 mov 0x12482c,%eax
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule(&_Scheduler);
if ( !_Thread_Is_executing_also_the_heir() &&
10bd86: 83 c4 10 add $0x10,%esp
10bd89: 3b 05 30 48 12 00 cmp 0x124830,%eax
10bd8f: 74 0d je 10bd9e <_Thread_Change_priority+0x10a>
10bd91: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bd95: 74 07 je 10bd9e <_Thread_Change_priority+0x10a>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10bd97: c6 05 38 48 12 00 01 movb $0x1,0x124838
_ISR_Enable( level );
10bd9e: 56 push %esi
10bd9f: 9d popf
}
10bda0: 8d 65 f4 lea -0xc(%ebp),%esp
10bda3: 5b pop %ebx
10bda4: 5e pop %esi
10bda5: 5f pop %edi
10bda6: c9 leave
10bda7: c3 ret
0010bf68 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10bf68: 55 push %ebp
10bf69: 89 e5 mov %esp,%ebp
10bf6b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10bf6e: 8d 45 f4 lea -0xc(%ebp),%eax
10bf71: 50 push %eax
10bf72: ff 75 08 pushl 0x8(%ebp)
10bf75: e8 82 01 00 00 call 10c0fc <_Thread_Get>
switch ( location ) {
10bf7a: 83 c4 10 add $0x10,%esp
10bf7d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10bf81: 75 1b jne 10bf9e <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10bf83: 52 push %edx
10bf84: 52 push %edx
10bf85: 68 18 00 00 10 push $0x10000018
10bf8a: 50 push %eax
10bf8b: e8 18 fe ff ff call 10bda8 <_Thread_Clear_state>
10bf90: a1 e0 42 12 00 mov 0x1242e0,%eax
10bf95: 48 dec %eax
10bf96: a3 e0 42 12 00 mov %eax,0x1242e0
10bf9b: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10bf9e: c9 leave
10bf9f: c3 ret
0010bfa0 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10bfa0: 55 push %ebp
10bfa1: 89 e5 mov %esp,%ebp
10bfa3: 57 push %edi
10bfa4: 56 push %esi
10bfa5: 53 push %ebx
10bfa6: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10bfa9: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx
_ISR_Disable( level );
10bfaf: 9c pushf
10bfb0: fa cli
10bfb1: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10bfb2: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10bfb5: e9 f9 00 00 00 jmp 10c0b3 <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10bfba: 8b 35 30 48 12 00 mov 0x124830,%esi
_Thread_Dispatch_disable_level = 1;
10bfc0: c7 05 e0 42 12 00 01 movl $0x1,0x1242e0
10bfc7: 00 00 00
_Thread_Dispatch_necessary = false;
10bfca: c6 05 38 48 12 00 00 movb $0x0,0x124838
_Thread_Executing = heir;
10bfd1: 89 35 2c 48 12 00 mov %esi,0x12482c
/*
* 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 )
10bfd7: 39 de cmp %ebx,%esi
10bfd9: 0f 84 e2 00 00 00 je 10c0c1 <_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 )
10bfdf: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10bfe3: 75 09 jne 10bfee <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10bfe5: 8b 15 b0 42 12 00 mov 0x1242b0,%edx
10bfeb: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10bfee: 50 push %eax
10bfef: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10bff0: 83 ec 0c sub $0xc,%esp
10bff3: 8d 45 e0 lea -0x20(%ebp),%eax
10bff6: 50 push %eax
10bff7: e8 dc 34 00 00 call 10f4d8 <_TOD_Get_uptime>
_Timestamp_Subtract(
10bffc: 83 c4 0c add $0xc,%esp
10bfff: 57 push %edi
10c000: 8d 45 e0 lea -0x20(%ebp),%eax
10c003: 50 push %eax
10c004: 68 b0 43 12 00 push $0x1243b0
10c009: e8 06 0b 00 00 call 10cb14 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10c00e: 58 pop %eax
10c00f: 5a pop %edx
10c010: 57 push %edi
10c011: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10c017: 50 push %eax
10c018: e8 c7 0a 00 00 call 10cae4 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10c01d: 8b 45 e0 mov -0x20(%ebp),%eax
10c020: 8b 55 e4 mov -0x1c(%ebp),%edx
10c023: a3 b0 43 12 00 mov %eax,0x1243b0
10c028: 89 15 b4 43 12 00 mov %edx,0x1243b4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10c02e: a1 88 43 12 00 mov 0x124388,%eax
10c033: 83 c4 10 add $0x10,%esp
10c036: 85 c0 test %eax,%eax
10c038: 74 10 je 10c04a <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10c03a: 8b 10 mov (%eax),%edx
10c03c: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10c042: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10c048: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10c04a: 51 push %ecx
10c04b: 51 push %ecx
10c04c: 56 push %esi
10c04d: 53 push %ebx
10c04e: e8 f9 0c 00 00 call 10cd4c <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10c053: 58 pop %eax
10c054: 5a pop %edx
10c055: 81 c6 c8 00 00 00 add $0xc8,%esi
10c05b: 56 push %esi
10c05c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10c062: 50 push %eax
10c063: e8 a8 0f 00 00 call 10d010 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10c068: 83 c4 10 add $0x10,%esp
10c06b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
10c072: 74 36 je 10c0aa <_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 );
10c074: a1 64 43 12 00 mov 0x124364,%eax
10c079: 39 c3 cmp %eax,%ebx
10c07b: 74 2d je 10c0aa <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10c07d: 85 c0 test %eax,%eax
10c07f: 74 11 je 10c092 <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10c081: 83 ec 0c sub $0xc,%esp
10c084: 05 e0 00 00 00 add $0xe0,%eax
10c089: 50 push %eax
10c08a: e8 b5 0f 00 00 call 10d044 <_CPU_Context_save_fp>
10c08f: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10c092: 83 ec 0c sub $0xc,%esp
10c095: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10c09b: 50 push %eax
10c09c: e8 ad 0f 00 00 call 10d04e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10c0a1: 89 1d 64 43 12 00 mov %ebx,0x124364
10c0a7: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10c0aa: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx
_ISR_Disable( level );
10c0b0: 9c pushf
10c0b1: fa cli
10c0b2: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c0b3: 8a 15 38 48 12 00 mov 0x124838,%dl
10c0b9: 84 d2 test %dl,%dl
10c0bb: 0f 85 f9 fe ff ff jne 10bfba <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10c0c1: c7 05 e0 42 12 00 00 movl $0x0,0x1242e0
10c0c8: 00 00 00
_ISR_Enable( level );
10c0cb: 50 push %eax
10c0cc: 9d popf
_API_extensions_Run_postswitch();
10c0cd: e8 0d e8 ff ff call 10a8df <_API_extensions_Run_postswitch>
}
10c0d2: 8d 65 f4 lea -0xc(%ebp),%esp
10c0d5: 5b pop %ebx
10c0d6: 5e pop %esi
10c0d7: 5f pop %edi
10c0d8: c9 leave
10c0d9: c3 ret
00110fa4 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110fa4: 55 push %ebp
110fa5: 89 e5 mov %esp,%ebp
110fa7: 53 push %ebx
110fa8: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110fab: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110fb1: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
110fb7: 85 c0 test %eax,%eax
110fb9: 74 03 je 110fbe <_Thread_Handler+0x1a>
110fbb: fa cli
110fbc: eb 01 jmp 110fbf <_Thread_Handler+0x1b>
110fbe: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110fbf: a0 a0 3f 12 00 mov 0x123fa0,%al
110fc4: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110fc7: c6 05 a0 3f 12 00 01 movb $0x1,0x123fa0
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
110fce: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
110fd5: 74 24 je 110ffb <_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 );
110fd7: a1 64 43 12 00 mov 0x124364,%eax
110fdc: 39 c3 cmp %eax,%ebx
110fde: 74 1b je 110ffb <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110fe0: 85 c0 test %eax,%eax
110fe2: 74 11 je 110ff5 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110fe4: 83 ec 0c sub $0xc,%esp
110fe7: 05 e0 00 00 00 add $0xe0,%eax
110fec: 50 push %eax
110fed: e8 52 c0 ff ff call 10d044 <_CPU_Context_save_fp>
110ff2: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110ff5: 89 1d 64 43 12 00 mov %ebx,0x124364
/*
* 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 );
110ffb: 83 ec 0c sub $0xc,%esp
110ffe: 53 push %ebx
110fff: e8 f8 bb ff ff call 10cbfc <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
111004: e8 d1 b0 ff ff call 10c0da <_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) */ {
111009: 83 c4 10 add $0x10,%esp
11100c: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
111010: 75 05 jne 111017 <_Thread_Handler+0x73>
INIT_NAME ();
111012: e8 69 be 00 00 call 11ce80 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
111017: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
11101d: 85 c0 test %eax,%eax
11101f: 75 0b jne 11102c <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
111021: 83 ec 0c sub $0xc,%esp
111024: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
11102a: eb 0c jmp 111038 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
11102c: 48 dec %eax
11102d: 75 15 jne 111044 <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
11102f: 83 ec 0c sub $0xc,%esp
111032: ff b3 98 00 00 00 pushl 0x98(%ebx)
111038: 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 =
11103e: 89 43 28 mov %eax,0x28(%ebx)
111041: 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 );
111044: 83 ec 0c sub $0xc,%esp
111047: 53 push %ebx
111048: e8 e0 bb ff ff call 10cc2d <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
11104d: 83 c4 0c add $0xc,%esp
111050: 6a 05 push $0x5
111052: 6a 01 push $0x1
111054: 6a 00 push $0x0
111056: e8 e1 a1 ff ff call 10b23c <_Internal_error_Occurred>
0010c16c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10c16c: 55 push %ebp
10c16d: 89 e5 mov %esp,%ebp
10c16f: 57 push %edi
10c170: 56 push %esi
10c171: 53 push %ebx
10c172: 83 ec 1c sub $0x1c,%esp
10c175: 8b 5d 0c mov 0xc(%ebp),%ebx
10c178: 8b 4d 10 mov 0x10(%ebp),%ecx
10c17b: 8b 75 14 mov 0x14(%ebp),%esi
10c17e: 8a 55 18 mov 0x18(%ebp),%dl
10c181: 8a 45 20 mov 0x20(%ebp),%al
10c184: 88 45 e3 mov %al,-0x1d(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10c187: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10c18e: 00 00 00
10c191: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10c198: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10c19b: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10c1a2: 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 ) {
10c1a5: 85 c9 test %ecx,%ecx
10c1a7: 75 31 jne 10c1da <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c1a9: 51 push %ecx
10c1aa: 51 push %ecx
10c1ab: 56 push %esi
10c1ac: 53 push %ebx
10c1ad: 88 55 dc mov %dl,-0x24(%ebp)
10c1b0: e8 87 07 00 00 call 10c93c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c1b5: 83 c4 10 add $0x10,%esp
10c1b8: 39 f0 cmp %esi,%eax
10c1ba: 8a 55 dc mov -0x24(%ebp),%dl
10c1bd: 0f 82 f9 01 00 00 jb 10c3bc <_Thread_Initialize+0x250>
10c1c3: 85 c0 test %eax,%eax
10c1c5: 0f 84 f1 01 00 00 je 10c3bc <_Thread_Initialize+0x250><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10c1cb: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10c1d1: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10c1d8: eb 09 jmp 10c1e3 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10c1da: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10c1e1: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10c1e3: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10c1e9: 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;
10c1ef: 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 ) {
10c1f1: 84 d2 test %dl,%dl
10c1f3: 74 17 je 10c20c <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c1f5: 83 ec 0c sub $0xc,%esp
10c1f8: 6a 6c push $0x6c
10c1fa: e8 b3 0d 00 00 call 10cfb2 <_Workspace_Allocate>
10c1ff: 89 c7 mov %eax,%edi
if ( !fp_area )
10c201: 83 c4 10 add $0x10,%esp
10c204: 85 c0 test %eax,%eax
10c206: 0f 84 25 01 00 00 je 10c331 <_Thread_Initialize+0x1c5>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c20c: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10c212: 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;
10c218: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c21f: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c226: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c22d: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c234: a1 94 43 12 00 mov 0x124394,%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;
10c239: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c23b: 85 c0 test %eax,%eax
10c23d: 74 1d je 10c25c <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c23f: 83 ec 0c sub $0xc,%esp
10c242: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c249: 50 push %eax
10c24a: e8 63 0d 00 00 call 10cfb2 <_Workspace_Allocate>
10c24f: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c251: 83 c4 10 add $0x10,%esp
10c254: 85 c0 test %eax,%eax
10c256: 0f 84 d7 00 00 00 je 10c333 <_Thread_Initialize+0x1c7>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c25c: 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 ) {
10c262: 85 f6 test %esi,%esi
10c264: 74 16 je 10c27c <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c266: 8b 15 94 43 12 00 mov 0x124394,%edx
10c26c: 31 c0 xor %eax,%eax
10c26e: eb 08 jmp 10c278 <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c270: 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++ )
10c277: 40 inc %eax
10c278: 39 d0 cmp %edx,%eax
10c27a: 76 f4 jbe 10c270 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c27c: 8a 45 e3 mov -0x1d(%ebp),%al
10c27f: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c285: 8b 45 24 mov 0x24(%ebp),%eax
10c288: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c28e: 8b 45 28 mov 0x28(%ebp),%eax
10c291: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10c297: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c29b: 75 08 jne 10c2a5 <_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;
10c29d: a1 b0 42 12 00 mov 0x1242b0,%eax
10c2a2: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c2a5: 8b 45 2c mov 0x2c(%ebp),%eax
10c2a8: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10c2ae: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c2b5: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c2bc: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c2c3: 8b 45 1c mov 0x1c(%ebp),%eax
10c2c6: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c2c9: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
return
10c2cf: 52 push %edx
10c2d0: 52 push %edx
10c2d1: 53 push %ebx
10c2d2: 68 68 43 12 00 push $0x124368
10c2d7: ff 15 7c 43 12 00 call *0x12437c
10c2dd: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread );
if ( !sched )
10c2e0: 83 c4 10 add $0x10,%esp
10c2e3: 85 c0 test %eax,%eax
10c2e5: 74 53 je 10c33a <_Thread_Initialize+0x1ce>
goto failed;
_Thread_Set_priority( the_thread, priority );
10c2e7: 50 push %eax
10c2e8: 50 push %eax
10c2e9: ff 75 1c pushl 0x1c(%ebp)
10c2ec: 53 push %ebx
10c2ed: e8 7a 05 00 00 call 10c86c <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c2f2: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c2f9: 00 00 00
10c2fc: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c303: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10c306: 8b 45 08 mov 0x8(%ebp),%eax
10c309: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c30c: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c310: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c313: 8b 45 30 mov 0x30(%ebp),%eax
10c316: 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 );
10c319: 89 1c 24 mov %ebx,(%esp)
10c31c: e8 7b 09 00 00 call 10cc9c <_User_extensions_Thread_create>
10c321: 88 c2 mov %al,%dl
if ( extension_status )
10c323: 83 c4 10 add $0x10,%esp
return true;
10c326: 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 )
10c328: 84 d2 test %dl,%dl
10c32a: 74 0e je 10c33a <_Thread_Initialize+0x1ce>
10c32c: e9 8d 00 00 00 jmp 10c3be <_Thread_Initialize+0x252>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c331: 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;
10c333: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
if ( the_thread->libc_reent )
10c33a: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
10c340: 85 c0 test %eax,%eax
10c342: 74 0c je 10c350 <_Thread_Initialize+0x1e4>
_Workspace_Free( the_thread->libc_reent );
10c344: 83 ec 0c sub $0xc,%esp
10c347: 50 push %eax
10c348: e8 7e 0c 00 00 call 10cfcb <_Workspace_Free>
10c34d: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c350: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax
10c356: 85 c0 test %eax,%eax
10c358: 74 0c je 10c366 <_Thread_Initialize+0x1fa>
_Workspace_Free( the_thread->API_Extensions[i] );
10c35a: 83 ec 0c sub $0xc,%esp
10c35d: 50 push %eax
10c35e: e8 68 0c 00 00 call 10cfcb <_Workspace_Free>
10c363: 83 c4 10 add $0x10,%esp
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c366: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
10c36c: 85 c0 test %eax,%eax
10c36e: 74 0c je 10c37c <_Thread_Initialize+0x210>
_Workspace_Free( the_thread->API_Extensions[i] );
10c370: 83 ec 0c sub $0xc,%esp
10c373: 50 push %eax
10c374: e8 52 0c 00 00 call 10cfcb <_Workspace_Free>
10c379: 83 c4 10 add $0x10,%esp
if ( extensions_area )
10c37c: 85 f6 test %esi,%esi
10c37e: 74 0c je 10c38c <_Thread_Initialize+0x220>
(void) _Workspace_Free( extensions_area );
10c380: 83 ec 0c sub $0xc,%esp
10c383: 56 push %esi
10c384: e8 42 0c 00 00 call 10cfcb <_Workspace_Free>
10c389: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10c38c: 85 ff test %edi,%edi
10c38e: 74 0c je 10c39c <_Thread_Initialize+0x230>
(void) _Workspace_Free( fp_area );
10c390: 83 ec 0c sub $0xc,%esp
10c393: 57 push %edi
10c394: e8 32 0c 00 00 call 10cfcb <_Workspace_Free>
10c399: 83 c4 10 add $0x10,%esp
#endif
if ( sched )
10c39c: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10c3a0: 74 0e je 10c3b0 <_Thread_Initialize+0x244>
(void) _Workspace_Free( sched );
10c3a2: 83 ec 0c sub $0xc,%esp
10c3a5: ff 75 e4 pushl -0x1c(%ebp)
10c3a8: e8 1e 0c 00 00 call 10cfcb <_Workspace_Free>
10c3ad: 83 c4 10 add $0x10,%esp
_Thread_Stack_Free( the_thread );
10c3b0: 83 ec 0c sub $0xc,%esp
10c3b3: 53 push %ebx
10c3b4: e8 d3 05 00 00 call 10c98c <_Thread_Stack_Free>
return false;
10c3b9: 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 */
10c3bc: 31 c0 xor %eax,%eax
_Thread_Stack_Free( the_thread );
return false;
}
10c3be: 8d 65 f4 lea -0xc(%ebp),%esp
10c3c1: 5b pop %ebx
10c3c2: 5e pop %esi
10c3c3: 5f pop %edi
10c3c4: c9 leave
10c3c5: c3 ret
0010f5fc <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f5fc: 55 push %ebp
10f5fd: 89 e5 mov %esp,%ebp
10f5ff: 53 push %ebx
10f600: 83 ec 04 sub $0x4,%esp
10f603: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f606: 9c pushf
10f607: fa cli
10f608: 5b pop %ebx
current_state = the_thread->current_state;
10f609: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f60c: f6 c2 02 test $0x2,%dl
10f60f: 74 1b je 10f62c <_Thread_Resume+0x30> <== NEVER TAKEN
10f611: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f614: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f617: 85 d2 test %edx,%edx
10f619: 75 11 jne 10f62c <_Thread_Resume+0x30>
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.unblock( the_scheduler, the_thread );
10f61b: 52 push %edx
10f61c: 52 push %edx
10f61d: 50 push %eax
10f61e: 68 30 74 12 00 push $0x127430
10f623: ff 15 40 74 12 00 call *0x127440
10f629: 83 c4 10 add $0x10,%esp
_Scheduler_Unblock( &_Scheduler, the_thread );
}
}
_ISR_Enable( level );
10f62c: 53 push %ebx
10f62d: 9d popf
}
10f62e: 8b 5d fc mov -0x4(%ebp),%ebx
10f631: c9 leave
10f632: c3 ret
0010ca74 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10ca74: 55 push %ebp
10ca75: 89 e5 mov %esp,%ebp
10ca77: 53 push %ebx
10ca78: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10ca7b: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10ca81: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10ca85: 74 55 je 10cadc <_Thread_Tickle_timeslice+0x68>
return;
if ( !_States_Is_ready( executing->current_state ) )
10ca87: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10ca8b: 75 4f jne 10cadc <_Thread_Tickle_timeslice+0x68>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10ca8d: 8b 43 7c mov 0x7c(%ebx),%eax
10ca90: 83 f8 01 cmp $0x1,%eax
10ca93: 72 47 jb 10cadc <_Thread_Tickle_timeslice+0x68>
10ca95: 83 f8 02 cmp $0x2,%eax
10ca98: 76 07 jbe 10caa1 <_Thread_Tickle_timeslice+0x2d>
10ca9a: 83 f8 03 cmp $0x3,%eax
10ca9d: 75 3d jne 10cadc <_Thread_Tickle_timeslice+0x68><== NEVER TAKEN
10ca9f: eb 23 jmp 10cac4 <_Thread_Tickle_timeslice+0x50>
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 ) {
10caa1: 8b 43 78 mov 0x78(%ebx),%eax
10caa4: 48 dec %eax
10caa5: 89 43 78 mov %eax,0x78(%ebx)
10caa8: 85 c0 test %eax,%eax
10caaa: 7f 30 jg 10cadc <_Thread_Tickle_timeslice+0x68>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield( &_Scheduler );
10caac: 83 ec 0c sub $0xc,%esp
10caaf: 68 68 43 12 00 push $0x124368
10cab4: ff 15 70 43 12 00 call *0x124370
* 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;
10caba: a1 b0 42 12 00 mov 0x1242b0,%eax
10cabf: 89 43 78 mov %eax,0x78(%ebx)
10cac2: eb 15 jmp 10cad9 <_Thread_Tickle_timeslice+0x65>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10cac4: 8b 43 78 mov 0x78(%ebx),%eax
10cac7: 48 dec %eax
10cac8: 89 43 78 mov %eax,0x78(%ebx)
10cacb: 85 c0 test %eax,%eax
10cacd: 75 0d jne 10cadc <_Thread_Tickle_timeslice+0x68>
(*executing->budget_callout)( executing );
10cacf: 83 ec 0c sub $0xc,%esp
10cad2: 53 push %ebx
10cad3: ff 93 80 00 00 00 call *0x80(%ebx)
10cad9: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10cadc: 8b 5d fc mov -0x4(%ebp),%ebx
10cadf: c9 leave
10cae0: c3 ret
0010c7e4 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c7e4: 55 push %ebp
10c7e5: 89 e5 mov %esp,%ebp
10c7e7: 57 push %edi
10c7e8: 56 push %esi
10c7e9: 53 push %ebx
10c7ea: 83 ec 1c sub $0x1c,%esp
10c7ed: 8b 75 08 mov 0x8(%ebp),%esi
10c7f0: 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 )
10c7f3: 85 f6 test %esi,%esi
10c7f5: 74 36 je 10c82d <_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 ) {
10c7f7: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c7fb: 75 30 jne 10c82d <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c7fd: 9c pushf
10c7fe: fa cli
10c7ff: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c800: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c807: 74 22 je 10c82b <_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;
10c809: 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 );
10c810: 50 push %eax
10c811: 6a 01 push $0x1
10c813: 57 push %edi
10c814: 56 push %esi
10c815: e8 0e 32 00 00 call 10fa28 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c81a: 83 c4 0c add $0xc,%esp
10c81d: 8d 45 e4 lea -0x1c(%ebp),%eax
10c820: 50 push %eax
10c821: 57 push %edi
10c822: 56 push %esi
10c823: e8 c0 fd ff ff call 10c5e8 <_Thread_queue_Enqueue_priority>
10c828: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c82b: 53 push %ebx
10c82c: 9d popf
}
}
10c82d: 8d 65 f4 lea -0xc(%ebp),%esp
10c830: 5b pop %ebx
10c831: 5e pop %esi
10c832: 5f pop %edi
10c833: c9 leave
10c834: c3 ret
0010c838 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c838: 55 push %ebp
10c839: 89 e5 mov %esp,%ebp
10c83b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c83e: 8d 45 f4 lea -0xc(%ebp),%eax
10c841: 50 push %eax
10c842: ff 75 08 pushl 0x8(%ebp)
10c845: e8 b2 f8 ff ff call 10c0fc <_Thread_Get>
switch ( location ) {
10c84a: 83 c4 10 add $0x10,%esp
10c84d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c851: 75 17 jne 10c86a <_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 );
10c853: 83 ec 0c sub $0xc,%esp
10c856: 50 push %eax
10c857: e8 84 32 00 00 call 10fae0 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c85c: a1 e0 42 12 00 mov 0x1242e0,%eax
10c861: 48 dec %eax
10c862: a3 e0 42 12 00 mov %eax,0x1242e0
10c867: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c86a: c9 leave
10c86b: c3 ret
00116974 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
116974: 55 push %ebp
116975: 89 e5 mov %esp,%ebp
116977: 57 push %edi
116978: 56 push %esi
116979: 53 push %ebx
11697a: 83 ec 4c sub $0x4c,%esp
11697d: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
116980: 8d 55 dc lea -0x24(%ebp),%edx
116983: 8d 45 e0 lea -0x20(%ebp),%eax
116986: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
116989: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
116990: 89 55 e4 mov %edx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
116993: 8d 7d d0 lea -0x30(%ebp),%edi
116996: 8d 4d d4 lea -0x2c(%ebp),%ecx
116999: 89 4d d0 mov %ecx,-0x30(%ebp)
head->previous = NULL;
11699c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
1169a3: 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 );
1169a6: 8d 53 30 lea 0x30(%ebx),%edx
1169a9: 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 );
1169ac: 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;
1169af: 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;
1169b2: 8d 4d dc lea -0x24(%ebp),%ecx
1169b5: 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;
1169b8: a1 08 d8 13 00 mov 0x13d808,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169bd: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
1169c0: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169c3: 51 push %ecx
1169c4: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169c5: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169c7: 50 push %eax
1169c8: ff 75 c0 pushl -0x40(%ebp)
1169cb: e8 98 39 00 00 call 11a368 <_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();
1169d0: a1 80 d7 13 00 mov 0x13d780,%eax
1169d5: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
1169d8: 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 ) {
1169db: 83 c4 10 add $0x10,%esp
1169de: 39 45 c4 cmp %eax,-0x3c(%ebp)
1169e1: 76 10 jbe 1169f3 <_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 );
1169e3: 52 push %edx
1169e4: 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;
1169e5: 8b 55 c4 mov -0x3c(%ebp),%edx
1169e8: 29 c2 sub %eax,%edx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169ea: 52 push %edx
1169eb: 56 push %esi
1169ec: e8 77 39 00 00 call 11a368 <_Watchdog_Adjust_to_chain>
1169f1: eb 0f jmp 116a02 <_Timer_server_Body+0x8e>
} else if ( snapshot < last_snapshot ) {
1169f3: 73 10 jae 116a05 <_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 );
1169f5: 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;
1169f6: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169f9: 50 push %eax
1169fa: 6a 01 push $0x1
1169fc: 56 push %esi
1169fd: e8 fa 38 00 00 call 11a2fc <_Watchdog_Adjust>
116a02: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a05: 8b 4d c4 mov -0x3c(%ebp),%ecx
116a08: 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 );
116a0b: 8b 43 78 mov 0x78(%ebx),%eax
116a0e: 83 ec 0c sub $0xc,%esp
116a11: 50 push %eax
116a12: e8 f5 08 00 00 call 11730c <_Chain_Get>
if ( timer == NULL ) {
116a17: 83 c4 10 add $0x10,%esp
116a1a: 85 c0 test %eax,%eax
116a1c: 74 29 je 116a47 <_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 ) {
116a1e: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
116a21: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
116a24: 75 0b jne 116a31 <_Timer_server_Body+0xbd><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a26: 52 push %edx <== NOT EXECUTED
116a27: 52 push %edx <== NOT EXECUTED
116a28: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a2b: 50 push %eax <== NOT EXECUTED
116a2c: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED
116a2f: eb 0c jmp 116a3d <_Timer_server_Body+0xc9><== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a31: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
116a34: 75 d5 jne 116a0b <_Timer_server_Body+0x97><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a36: 51 push %ecx <== NOT EXECUTED
116a37: 51 push %ecx <== NOT EXECUTED
116a38: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a3b: 50 push %eax <== NOT EXECUTED
116a3c: 56 push %esi <== NOT EXECUTED
116a3d: e8 ae 39 00 00 call 11a3f0 <_Watchdog_Insert> <== NOT EXECUTED
116a42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116a45: eb c4 jmp 116a0b <_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 );
116a47: 9c pushf
116a48: fa cli
116a49: 5a pop %edx
tmp = ts->insert_chain;
116a4a: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a4d: b0 01 mov $0x1,%al
116a4f: 8b 4d b4 mov -0x4c(%ebp),%ecx
116a52: 39 4d dc cmp %ecx,-0x24(%ebp)
116a55: 75 09 jne 116a60 <_Timer_server_Body+0xec><== NEVER TAKEN
ts->insert_chain = NULL;
116a57: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116a5e: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116a60: 52 push %edx
116a61: 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 ) {
116a62: 84 c0 test %al,%al
116a64: 0f 85 4e ff ff ff jne 1169b8 <_Timer_server_Body+0x44><== NEVER TAKEN
116a6a: 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 ) ) {
116a6d: 39 45 d0 cmp %eax,-0x30(%ebp)
116a70: 74 3a je 116aac <_Timer_server_Body+0x138>
116a72: 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 );
116a75: 9c pushf
116a76: fa cli
116a77: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
116a78: 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))
116a7b: 3b 45 b0 cmp -0x50(%ebp),%eax
116a7e: 74 25 je 116aa5 <_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;
116a80: 8b 10 mov (%eax),%edx
head->next = new_first;
116a82: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
116a85: 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 ) {
116a88: 85 c0 test %eax,%eax
116a8a: 74 19 je 116aa5 <_Timer_server_Body+0x131><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116a8c: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116a93: 51 push %ecx
116a94: 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 );
116a95: 52 push %edx
116a96: 52 push %edx
116a97: ff 70 24 pushl 0x24(%eax)
116a9a: ff 70 20 pushl 0x20(%eax)
116a9d: ff 50 1c call *0x1c(%eax)
}
116aa0: 83 c4 10 add $0x10,%esp
116aa3: eb d0 jmp 116a75 <_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 );
116aa5: 51 push %ecx
116aa6: 9d popf
116aa7: e9 06 ff ff ff jmp 1169b2 <_Timer_server_Body+0x3e>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116aac: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116ab0: e8 23 fe ff ff call 1168d8 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116ab5: 51 push %ecx
116ab6: 51 push %ecx
116ab7: 6a 08 push $0x8
116ab9: ff 33 pushl (%ebx)
116abb: e8 8c 32 00 00 call 119d4c <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116ac0: 89 d8 mov %ebx,%eax
116ac2: e8 21 fe ff ff call 1168e8 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116ac7: 89 d8 mov %ebx,%eax
116ac9: e8 60 fe ff ff call 11692e <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116ace: e8 07 2a 00 00 call 1194da <_Thread_Enable_dispatch>
ts->active = true;
116ad3: 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 );
116ad7: 8d 43 08 lea 0x8(%ebx),%eax
116ada: 89 04 24 mov %eax,(%esp)
116add: e8 26 3a 00 00 call 11a508 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116ae2: 8d 43 40 lea 0x40(%ebx),%eax
116ae5: 89 04 24 mov %eax,(%esp)
116ae8: e8 1b 3a 00 00 call 11a508 <_Watchdog_Remove>
116aed: 83 c4 10 add $0x10,%esp
116af0: e9 bd fe ff ff jmp 1169b2 <_Timer_server_Body+0x3e>
00116af5 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116af5: 55 push %ebp
116af6: 89 e5 mov %esp,%ebp
116af8: 57 push %edi
116af9: 56 push %esi
116afa: 53 push %ebx
116afb: 83 ec 2c sub $0x2c,%esp
116afe: 8b 5d 08 mov 0x8(%ebp),%ebx
116b01: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b04: 8b 43 78 mov 0x78(%ebx),%eax
116b07: 85 c0 test %eax,%eax
116b09: 0f 85 de 00 00 00 jne 116bed <_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();
116b0f: e8 c4 fd ff ff call 1168d8 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b14: 8b 46 38 mov 0x38(%esi),%eax
116b17: 83 f8 01 cmp $0x1,%eax
116b1a: 75 5a jne 116b76 <_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 );
116b1c: 9c pushf
116b1d: fa cli
116b1e: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b21: 8b 15 08 d8 13 00 mov 0x13d808,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b27: 8b 4b 3c mov 0x3c(%ebx),%ecx
initialized = false;
}
#endif
return status;
}
116b2a: 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 );
116b2d: 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 ) ) {
116b30: 39 f8 cmp %edi,%eax
116b32: 74 19 je 116b4d <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b34: 89 d7 mov %edx,%edi
116b36: 29 cf sub %ecx,%edi
116b38: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b3b: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b3e: 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) {
116b40: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b43: 76 05 jbe 116b4a <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b45: 89 f9 mov %edi,%ecx
116b47: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b4a: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b4d: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116b50: ff 75 e0 pushl -0x20(%ebp)
116b53: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116b54: 50 push %eax
116b55: 50 push %eax
116b56: 83 c6 10 add $0x10,%esi
116b59: 56 push %esi
116b5a: 8d 43 30 lea 0x30(%ebx),%eax
116b5d: 50 push %eax
116b5e: e8 8d 38 00 00 call 11a3f0 <_Watchdog_Insert>
if ( !ts->active ) {
116b63: 8a 43 7c mov 0x7c(%ebx),%al
116b66: 83 c4 10 add $0x10,%esp
116b69: 84 c0 test %al,%al
116b6b: 75 74 jne 116be1 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116b6d: 89 d8 mov %ebx,%eax
116b6f: e8 74 fd ff ff call 1168e8 <_Timer_server_Reset_interval_system_watchdog>
116b74: eb 6b jmp 116be1 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116b76: 83 f8 03 cmp $0x3,%eax
116b79: 75 66 jne 116be1 <_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 );
116b7b: 9c pushf
116b7c: fa cli
116b7d: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116b80: 8b 15 80 d7 13 00 mov 0x13d780,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116b86: 8b 43 74 mov 0x74(%ebx),%eax
initialized = false;
}
#endif
return status;
}
116b89: 8b 4b 68 mov 0x68(%ebx),%ecx
116b8c: 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 ) ) {
116b8f: 39 f9 cmp %edi,%ecx
116b91: 74 27 je 116bba <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116b93: 8b 79 10 mov 0x10(%ecx),%edi
116b96: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116b99: 39 c2 cmp %eax,%edx
116b9b: 76 15 jbe 116bb2 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116b9d: 89 d7 mov %edx,%edi
116b9f: 29 c7 sub %eax,%edi
116ba1: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116ba4: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116ba6: 39 7d d4 cmp %edi,-0x2c(%ebp)
116ba9: 76 0c jbe 116bb7 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116bab: 8b 45 d4 mov -0x2c(%ebp),%eax
116bae: 29 f8 sub %edi,%eax
116bb0: eb 05 jmp 116bb7 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116bb2: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116bb5: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116bb7: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116bba: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116bbd: ff 75 e0 pushl -0x20(%ebp)
116bc0: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116bc1: 57 push %edi
116bc2: 57 push %edi
116bc3: 83 c6 10 add $0x10,%esi
116bc6: 56 push %esi
116bc7: 8d 43 68 lea 0x68(%ebx),%eax
116bca: 50 push %eax
116bcb: e8 20 38 00 00 call 11a3f0 <_Watchdog_Insert>
if ( !ts->active ) {
116bd0: 8a 43 7c mov 0x7c(%ebx),%al
116bd3: 83 c4 10 add $0x10,%esp
116bd6: 84 c0 test %al,%al
116bd8: 75 07 jne 116be1 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116bda: 89 d8 mov %ebx,%eax
116bdc: e8 4d fd ff ff call 11692e <_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 );
}
}
116be1: 8d 65 f4 lea -0xc(%ebp),%esp
116be4: 5b pop %ebx
116be5: 5e pop %esi
116be6: 5f pop %edi
116be7: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116be8: e9 ed 28 00 00 jmp 1194da <_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 );
116bed: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
116bf0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
116bf3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
116bf6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116bf9: 5b pop %ebx <== NOT EXECUTED
116bfa: 5e pop %esi <== NOT EXECUTED
116bfb: 5f pop %edi <== NOT EXECUTED
116bfc: 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 );
116bfd: e9 ce 06 00 00 jmp 1172d0 <_Chain_Append> <== NOT EXECUTED
0010cc5f <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cc5f: 55 push %ebp
10cc60: 89 e5 mov %esp,%ebp
10cc62: 57 push %edi
10cc63: 56 push %esi
10cc64: 53 push %ebx
10cc65: 83 ec 0c sub $0xc,%esp
10cc68: 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 );
}
}
10cc6b: 8b 1d d8 44 12 00 mov 0x1244d8,%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 );
10cc71: 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 );
10cc75: eb 15 jmp 10cc8c <_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 )
10cc77: 8b 43 30 mov 0x30(%ebx),%eax
10cc7a: 85 c0 test %eax,%eax
10cc7c: 74 0b je 10cc89 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cc7e: 52 push %edx
10cc7f: 57 push %edi
10cc80: 56 push %esi
10cc81: ff 75 08 pushl 0x8(%ebp)
10cc84: ff d0 call *%eax
10cc86: 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 ) {
10cc89: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10cc8c: 81 fb d0 44 12 00 cmp $0x1244d0,%ebx
10cc92: 75 e3 jne 10cc77 <_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 );
}
}
10cc94: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cc97: 5b pop %ebx <== NOT EXECUTED
10cc98: 5e pop %esi <== NOT EXECUTED
10cc99: 5f pop %edi <== NOT EXECUTED
10cc9a: c9 leave <== NOT EXECUTED
10cc9b: c3 ret <== NOT EXECUTED
0010cb48 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10cb48: 55 push %ebp
10cb49: 89 e5 mov %esp,%ebp
10cb4b: 57 push %edi
10cb4c: 56 push %esi
10cb4d: 53 push %ebx
10cb4e: 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;
10cb51: a1 34 02 12 00 mov 0x120234,%eax
10cb56: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10cb59: 8b 35 38 02 12 00 mov 0x120238,%esi
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cb5f: c7 05 d0 44 12 00 d4 movl $0x1244d4,0x1244d0
10cb66: 44 12 00
head->previous = NULL;
10cb69: c7 05 d4 44 12 00 00 movl $0x0,0x1244d4
10cb70: 00 00 00
tail->previous = head;
10cb73: c7 05 d8 44 12 00 d0 movl $0x1244d0,0x1244d8
10cb7a: 44 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cb7d: c7 05 e4 42 12 00 e8 movl $0x1242e8,0x1242e4
10cb84: 42 12 00
head->previous = NULL;
10cb87: c7 05 e8 42 12 00 00 movl $0x0,0x1242e8
10cb8e: 00 00 00
tail->previous = head;
10cb91: c7 05 ec 42 12 00 e4 movl $0x1242e4,0x1242ec
10cb98: 42 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cb9b: 85 f6 test %esi,%esi
10cb9d: 74 53 je 10cbf2 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cb9f: 6b c8 34 imul $0x34,%eax,%ecx
10cba2: 83 ec 0c sub $0xc,%esp
10cba5: 51 push %ecx
10cba6: 89 4d e0 mov %ecx,-0x20(%ebp)
10cba9: e8 32 04 00 00 call 10cfe0 <_Workspace_Allocate_or_fatal_error>
10cbae: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cbb0: 31 c0 xor %eax,%eax
10cbb2: 8b 4d e0 mov -0x20(%ebp),%ecx
10cbb5: 89 df mov %ebx,%edi
10cbb7: f3 aa rep stos %al,%es:(%edi)
10cbb9: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cbbb: 83 c4 10 add $0x10,%esp
10cbbe: 31 d2 xor %edx,%edx
10cbc0: eb 2b jmp 10cbed <_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;
10cbc2: 8d 7b 14 lea 0x14(%ebx),%edi
10cbc5: 89 c6 mov %eax,%esi
10cbc7: b9 08 00 00 00 mov $0x8,%ecx
10cbcc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10cbce: 83 ec 0c sub $0xc,%esp
10cbd1: 53 push %ebx
10cbd2: 89 45 dc mov %eax,-0x24(%ebp)
10cbd5: 89 55 e0 mov %edx,-0x20(%ebp)
10cbd8: e8 f3 2f 00 00 call 10fbd0 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cbdd: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cbe0: 8b 55 e0 mov -0x20(%ebp),%edx
10cbe3: 42 inc %edx
10cbe4: 8b 45 dc mov -0x24(%ebp),%eax
10cbe7: 83 c0 20 add $0x20,%eax
10cbea: 83 c4 10 add $0x10,%esp
10cbed: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cbf0: 72 d0 jb 10cbc2 <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cbf2: 8d 65 f4 lea -0xc(%ebp),%esp
10cbf5: 5b pop %ebx
10cbf6: 5e pop %esi
10cbf7: 5f pop %edi
10cbf8: c9 leave
10cbf9: c3 ret
0010e4ac <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e4ac: 55 push %ebp
10e4ad: 89 e5 mov %esp,%ebp
10e4af: 57 push %edi
10e4b0: 56 push %esi
10e4b1: 53 push %ebx
10e4b2: 83 ec 1c sub $0x1c,%esp
10e4b5: 8b 75 08 mov 0x8(%ebp),%esi
10e4b8: 8b 7d 0c mov 0xc(%ebp),%edi
10e4bb: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e4be: 9c pushf
10e4bf: fa cli
10e4c0: 58 pop %eax
}
}
_ISR_Enable( level );
}
10e4c1: 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 );
10e4c3: 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 ) ) {
10e4c6: 39 ca cmp %ecx,%edx
10e4c8: 74 44 je 10e50e <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e4ca: 85 ff test %edi,%edi
10e4cc: 74 3c je 10e50a <_Watchdog_Adjust+0x5e>
10e4ce: 4f dec %edi
10e4cf: 75 3d jne 10e50e <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e4d1: 01 5a 10 add %ebx,0x10(%edx)
break;
10e4d4: eb 38 jmp 10e50e <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e4d6: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e4d8: 8b 7a 10 mov 0x10(%edx),%edi
10e4db: 39 fb cmp %edi,%ebx
10e4dd: 73 07 jae 10e4e6 <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e4df: 29 df sub %ebx,%edi
10e4e1: 89 7a 10 mov %edi,0x10(%edx)
break;
10e4e4: eb 28 jmp 10e50e <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e4e6: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e4ed: 50 push %eax
10e4ee: 9d popf
_Watchdog_Tickle( header );
10e4ef: 83 ec 0c sub $0xc,%esp
10e4f2: 56 push %esi
10e4f3: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e4f6: e8 9d 01 00 00 call 10e698 <_Watchdog_Tickle>
_ISR_Disable( level );
10e4fb: 9c pushf
10e4fc: fa cli
10e4fd: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e4fe: 83 c4 10 add $0x10,%esp
10e501: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e504: 39 0e cmp %ecx,(%esi)
10e506: 74 06 je 10e50e <_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;
10e508: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e50a: 85 db test %ebx,%ebx
10e50c: 75 c8 jne 10e4d6 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e50e: 50 push %eax
10e50f: 9d popf
}
10e510: 8d 65 f4 lea -0xc(%ebp),%esp
10e513: 5b pop %ebx
10e514: 5e pop %esi
10e515: 5f pop %edi
10e516: c9 leave
10e517: c3 ret
0010ce98 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10ce98: 55 push %ebp
10ce99: 89 e5 mov %esp,%ebp
10ce9b: 56 push %esi
10ce9c: 53 push %ebx
10ce9d: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10cea0: 9c pushf
10cea1: fa cli
10cea2: 5e pop %esi
previous_state = the_watchdog->state;
10cea3: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10cea6: 83 f8 01 cmp $0x1,%eax
10cea9: 74 09 je 10ceb4 <_Watchdog_Remove+0x1c>
10ceab: 72 42 jb 10ceef <_Watchdog_Remove+0x57>
10cead: 83 f8 03 cmp $0x3,%eax
10ceb0: 77 3d ja 10ceef <_Watchdog_Remove+0x57> <== NEVER TAKEN
10ceb2: eb 09 jmp 10cebd <_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;
10ceb4: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10cebb: eb 32 jmp 10ceef <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cebd: 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 );
}
10cec4: 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) )
10cec6: 83 39 00 cmpl $0x0,(%ecx)
10cec9: 74 06 je 10ced1 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10cecb: 8b 5a 10 mov 0x10(%edx),%ebx
10cece: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10ced1: 8b 1d 10 44 12 00 mov 0x124410,%ebx
10ced7: 85 db test %ebx,%ebx
10ced9: 74 0c je 10cee7 <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cedb: 8b 1d 28 48 12 00 mov 0x124828,%ebx
10cee1: 89 1d a8 43 12 00 mov %ebx,0x1243a8
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10cee7: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10ceea: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10ceed: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10ceef: 8b 0d 14 44 12 00 mov 0x124414,%ecx
10cef5: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10cef8: 56 push %esi
10cef9: 9d popf
return( previous_state );
}
10cefa: 5b pop %ebx
10cefb: 5e pop %esi
10cefc: c9 leave
10cefd: c3 ret
0010e03c <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e03c: 55 push %ebp
10e03d: 89 e5 mov %esp,%ebp
10e03f: 57 push %edi
10e040: 56 push %esi
10e041: 53 push %ebx
10e042: 83 ec 20 sub $0x20,%esp
10e045: 8b 7d 08 mov 0x8(%ebp),%edi
10e048: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e04b: 9c pushf
10e04c: fa cli
10e04d: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e050: 56 push %esi
10e051: 57 push %edi
10e052: 68 c8 0f 12 00 push $0x120fc8
10e057: e8 8c aa ff ff call 108ae8 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10e05c: 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 );
10e05e: 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 ) ) {
10e061: 83 c4 10 add $0x10,%esp
10e064: 39 f3 cmp %esi,%ebx
10e066: 74 1d je 10e085 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e068: 52 push %edx
10e069: 52 push %edx
10e06a: 53 push %ebx
10e06b: 6a 00 push $0x0
10e06d: e8 32 00 00 00 call 10e0a4 <_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 )
10e072: 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 ) ;
10e074: 83 c4 10 add $0x10,%esp
10e077: 39 f3 cmp %esi,%ebx
10e079: 75 ed jne 10e068 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e07b: 50 push %eax
10e07c: 50 push %eax
10e07d: 57 push %edi
10e07e: 68 df 0f 12 00 push $0x120fdf
10e083: eb 08 jmp 10e08d <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e085: 83 ec 0c sub $0xc,%esp
10e088: 68 ee 0f 12 00 push $0x120fee
10e08d: e8 56 aa ff ff call 108ae8 <printk>
10e092: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e095: ff 75 e4 pushl -0x1c(%ebp)
10e098: 9d popf
}
10e099: 8d 65 f4 lea -0xc(%ebp),%esp
10e09c: 5b pop %ebx
10e09d: 5e pop %esi
10e09e: 5f pop %edi
10e09f: c9 leave
10e0a0: c3 ret
0010cf00 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10cf00: 55 push %ebp
10cf01: 89 e5 mov %esp,%ebp
10cf03: 57 push %edi
10cf04: 56 push %esi
10cf05: 53 push %ebx
10cf06: 83 ec 1c sub $0x1c,%esp
10cf09: 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 );
10cf0c: 9c pushf
10cf0d: fa cli
10cf0e: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10cf0f: 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 );
10cf11: 8d 47 04 lea 0x4(%edi),%eax
10cf14: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10cf17: 39 c3 cmp %eax,%ebx
10cf19: 74 40 je 10cf5b <_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) {
10cf1b: 8b 43 10 mov 0x10(%ebx),%eax
10cf1e: 85 c0 test %eax,%eax
10cf20: 74 08 je 10cf2a <_Watchdog_Tickle+0x2a>
the_watchdog->delta_interval--;
10cf22: 48 dec %eax
10cf23: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10cf26: 85 c0 test %eax,%eax
10cf28: 75 31 jne 10cf5b <_Watchdog_Tickle+0x5b>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10cf2a: 83 ec 0c sub $0xc,%esp
10cf2d: 53 push %ebx
10cf2e: e8 65 ff ff ff call 10ce98 <_Watchdog_Remove>
_ISR_Enable( level );
10cf33: 56 push %esi
10cf34: 9d popf
switch( watchdog_state ) {
10cf35: 83 c4 10 add $0x10,%esp
10cf38: 83 f8 02 cmp $0x2,%eax
10cf3b: 75 0e jne 10cf4b <_Watchdog_Tickle+0x4b> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10cf3d: 50 push %eax
10cf3e: 50 push %eax
10cf3f: ff 73 24 pushl 0x24(%ebx)
10cf42: ff 73 20 pushl 0x20(%ebx)
10cf45: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10cf48: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10cf4b: 9c pushf
10cf4c: fa cli
10cf4d: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10cf4e: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10cf50: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10cf53: 74 06 je 10cf5b <_Watchdog_Tickle+0x5b>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10cf55: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cf59: eb cd jmp 10cf28 <_Watchdog_Tickle+0x28>
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10cf5b: 56 push %esi
10cf5c: 9d popf
}
10cf5d: 8d 65 f4 lea -0xc(%ebp),%esp
10cf60: 5b pop %ebx
10cf61: 5e pop %esi
10cf62: 5f pop %edi
10cf63: c9 leave
10cf64: c3 ret
0010a7c0 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a7c0: 55 push %ebp
10a7c1: 89 e5 mov %esp,%ebp
10a7c3: 57 push %edi
10a7c4: 56 push %esi
10a7c5: 53 push %ebx
10a7c6: 83 ec 18 sub $0x18,%esp
10a7c9: 8b 75 08 mov 0x8(%ebp),%esi
10a7cc: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a7cf: 68 78 72 12 00 push $0x127278
10a7d4: e8 0b 10 00 00 call 10b7e4 <pthread_mutex_lock>
if (aiocbp == NULL)
10a7d9: 83 c4 10 add $0x10,%esp
10a7dc: 85 db test %ebx,%ebx
10a7de: 0f 85 05 01 00 00 jne 10a8e9 <aio_cancel+0x129>
{
if (fcntl (fildes, F_GETFL) < 0) {
10a7e4: 53 push %ebx
10a7e5: 53 push %ebx
10a7e6: 6a 03 push $0x3
10a7e8: 56 push %esi
10a7e9: e8 7e 60 00 00 call 11086c <fcntl>
10a7ee: 83 c4 10 add $0x10,%esp
10a7f1: 85 c0 test %eax,%eax
10a7f3: 79 1d jns 10a812 <aio_cancel+0x52> <== NEVER TAKEN
pthread_mutex_unlock(&aio_request_queue.mutex);
10a7f5: 83 ec 0c sub $0xc,%esp
10a7f8: 68 78 72 12 00 push $0x127278
10a7fd: e8 62 10 00 00 call 10b864 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a802: e8 c9 8e 00 00 call 1136d0 <__errno>
10a807: c7 00 09 00 00 00 movl $0x9,(%eax)
10a80d: e9 f5 00 00 00 jmp 10a907 <aio_cancel+0x147>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10a812: 51 push %ecx <== NOT EXECUTED
10a813: 6a 00 push $0x0 <== NOT EXECUTED
10a815: 56 push %esi <== NOT EXECUTED
10a816: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10a81b: e8 20 03 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a820: 89 c3 mov %eax,%ebx <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a825: 85 c0 test %eax,%eax <== NOT EXECUTED
10a827: 0f 85 82 00 00 00 jne 10a8af <aio_cancel+0xef> <== NOT EXECUTED
{
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
10a82d: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10a834: 72 12 00
10a837: 74 5c je 10a895 <aio_cancel+0xd5> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
10a839: 52 push %edx <== NOT EXECUTED
10a83a: 6a 00 push $0x0 <== NOT EXECUTED
10a83c: 56 push %esi <== NOT EXECUTED
10a83d: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED
10a842: e8 f9 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a847: 89 c3 mov %eax,%ebx <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
10a849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a84c: 85 c0 test %eax,%eax <== NOT EXECUTED
10a84e: 75 17 jne 10a867 <aio_cancel+0xa7> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
10a850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a853: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a858: e8 07 10 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a85d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a860: b3 02 mov $0x2,%bl <== NOT EXECUTED
10a862: e9 1b 01 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a867: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a86a: 50 push %eax <== NOT EXECUTED
10a86b: e8 dc 26 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a870: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a873: e8 07 06 00 00 call 10ae7f <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
10a878: 8d 73 1c lea 0x1c(%ebx),%esi <== NOT EXECUTED
10a87b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a87e: e8 41 0d 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
10a883: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a886: e8 45 0a 00 00 call 10b2d0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10a88b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a88e: e8 ad d4 ff ff call 107d40 <free> <== NOT EXECUTED
10a893: eb 3e jmp 10a8d3 <aio_cancel+0x113> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10a895: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a898: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a89d: e8 c2 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a8aa: e9 d3 00 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
}
pthread_mutex_lock (&r_chain->mutex);
10a8af: 8d 70 1c lea 0x1c(%eax),%esi <== NOT EXECUTED
10a8b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a8b5: 56 push %esi <== NOT EXECUTED
10a8b6: e8 29 0f 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
10a8bb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a8be: e8 89 26 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a8c6: e8 b4 05 00 00 call 10ae7f <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
10a8cb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a8ce: e8 91 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8d3: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10a8da: e8 85 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
10a8df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8e2: 31 db xor %ebx,%ebx <== NOT EXECUTED
10a8e4: e9 99 00 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
}
else
{
if (aiocbp->aio_fildes != fildes) {
10a8e9: 8b 3b mov (%ebx),%edi
10a8eb: 39 f7 cmp %esi,%edi
10a8ed: 74 20 je 10a90f <aio_cancel+0x14f> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8ef: 83 ec 0c sub $0xc,%esp
10a8f2: 68 78 72 12 00 push $0x127278
10a8f7: e8 68 0f 00 00 call 10b864 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a8fc: e8 cf 8d 00 00 call 1136d0 <__errno>
10a901: c7 00 16 00 00 00 movl $0x16,(%eax)
10a907: 83 c4 10 add $0x10,%esp
10a90a: 83 cb ff or $0xffffffff,%ebx
10a90d: eb 73 jmp 10a982 <aio_cancel+0x1c2>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10a90f: 50 push %eax <== NOT EXECUTED
10a910: 6a 00 push $0x0 <== NOT EXECUTED
10a912: 57 push %edi <== NOT EXECUTED
10a913: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10a918: e8 23 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a91d: 89 c6 mov %eax,%esi <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a91f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a922: 85 c0 test %eax,%eax <== NOT EXECUTED
10a924: 75 2e jne 10a954 <aio_cancel+0x194> <== NOT EXECUTED
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
10a926: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10a92d: 72 12 00
10a930: 74 22 je 10a954 <aio_cancel+0x194> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
10a932: 56 push %esi <== NOT EXECUTED
10a933: 6a 00 push $0x0 <== NOT EXECUTED
10a935: 57 push %edi <== NOT EXECUTED
10a936: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED
10a93b: e8 00 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a943: 85 c0 test %eax,%eax <== NOT EXECUTED
10a945: 74 a8 je 10a8ef <aio_cancel+0x12f> <== NOT EXECUTED
{
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
10a947: 51 push %ecx <== NOT EXECUTED
10a948: 51 push %ecx <== NOT EXECUTED
10a949: 53 push %ebx <== NOT EXECUTED
10a94a: 50 push %eax <== NOT EXECUTED
10a94b: e8 6f 05 00 00 call 10aebf <rtems_aio_remove_req> <== NOT EXECUTED
10a950: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10a952: eb 1f jmp 10a973 <aio_cancel+0x1b3> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
pthread_mutex_lock (&r_chain->mutex);
10a954: 8d 7e 1c lea 0x1c(%esi),%edi <== NOT EXECUTED
10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a95a: 57 push %edi <== NOT EXECUTED
10a95b: e8 84 0e 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
10a960: 58 pop %eax <== NOT EXECUTED
10a961: 5a pop %edx <== NOT EXECUTED
10a962: 53 push %ebx <== NOT EXECUTED
10a963: 56 push %esi <== NOT EXECUTED
10a964: e8 56 05 00 00 call 10aebf <rtems_aio_remove_req> <== NOT EXECUTED
10a969: 89 c3 mov %eax,%ebx <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
10a96b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10a96e: e8 f1 0e 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10a973: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10a97a: e8 e5 0e 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10a97f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return AIO_ALLDONE;
}
10a982: 89 d8 mov %ebx,%eax
10a984: 8d 65 f4 lea -0xc(%ebp),%esp
10a987: 5b pop %ebx
10a988: 5e pop %esi
10a989: 5f pop %edi
10a98a: c9 leave
10a98b: c3 ret
0010a998 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a998: 55 push %ebp
10a999: 89 e5 mov %esp,%ebp
10a99b: 53 push %ebx
10a99c: 83 ec 04 sub $0x4,%esp
10a99f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a9a2: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10a9a9: 74 1b je 10a9c6 <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10a9ab: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10a9b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9b9: e8 12 8d 00 00 call 1136d0 <__errno>
10a9be: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9c4: eb 74 jmp 10aa3a <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10a9c6: 50 push %eax
10a9c7: 50 push %eax
10a9c8: 6a 03 push $0x3
10a9ca: ff 33 pushl (%ebx)
10a9cc: e8 9b 5e 00 00 call 11086c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10a9d1: 83 e0 03 and $0x3,%eax
10a9d4: 48 dec %eax
10a9d5: 83 c4 10 add $0x10,%esp
10a9d8: 83 f8 01 cmp $0x1,%eax
10a9db: 76 1b jbe 10a9f8 <aio_fsync+0x60> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10a9dd: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10a9e4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9eb: e8 e0 8c 00 00 call 1136d0 <__errno>
10a9f0: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9f6: eb 42 jmp 10aa3a <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10a9f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a9fb: 6a 18 push $0x18 <== NOT EXECUTED
10a9fd: e8 c2 d7 ff ff call 1081c4 <malloc> <== NOT EXECUTED
if (req == NULL)
10aa02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10aa05: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa07: 75 1b jne 10aa24 <aio_fsync+0x8c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10aa09: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10aa10: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10aa17: e8 b4 8c 00 00 call 1136d0 <__errno> <== NOT EXECUTED
10aa1c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10aa22: eb 16 jmp 10aa3a <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa24: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa27: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) <== NOT EXECUTED
return rtems_aio_enqueue (req);
10aa2e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10aa31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10aa34: c9 leave <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10aa35: e9 d7 04 00 00 jmp 10af11 <rtems_aio_enqueue> <== NOT EXECUTED
}
10aa3a: 83 c8 ff or $0xffffffff,%eax
10aa3d: 8b 5d fc mov -0x4(%ebp),%ebx
10aa40: c9 leave
10aa41: c3 ret
0010b10c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b10c: 55 push %ebp
10b10d: 89 e5 mov %esp,%ebp
10b10f: 53 push %ebx
10b110: 83 ec 0c sub $0xc,%esp
10b113: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b116: 6a 03 push $0x3
10b118: ff 33 pushl (%ebx)
10b11a: e8 4d 57 00 00 call 11086c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b11f: 83 e0 03 and $0x3,%eax
10b122: 83 c4 10 add $0x10,%esp
10b125: 83 f8 02 cmp $0x2,%eax
10b128: 74 1f je 10b149 <aio_read+0x3d>
10b12a: 85 c0 test %eax,%eax
10b12c: 74 1b je 10b149 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b12e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b135: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b13c: e8 8f 85 00 00 call 1136d0 <__errno>
10b141: c7 00 09 00 00 00 movl $0x9,(%eax)
10b147: eb 69 jmp 10b1b2 <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b149: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b14d: 75 06 jne 10b155 <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b14f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b153: 79 1b jns 10b170 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b155: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b15c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b163: e8 68 85 00 00 call 1136d0 <__errno>
10b168: c7 00 16 00 00 00 movl $0x16,(%eax)
10b16e: eb 42 jmp 10b1b2 <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b170: 83 ec 0c sub $0xc,%esp
10b173: 6a 18 push $0x18
10b175: e8 4a d0 ff ff call 1081c4 <malloc>
if (req == NULL)
10b17a: 83 c4 10 add $0x10,%esp
10b17d: 85 c0 test %eax,%eax
10b17f: 75 1b jne 10b19c <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b181: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b188: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b18f: e8 3c 85 00 00 call 1136d0 <__errno> <== NOT EXECUTED
10b194: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b19a: eb 16 jmp 10b1b2 <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b19c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b19f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b1a6: 89 45 08 mov %eax,0x8(%ebp)
}
10b1a9: 8b 5d fc mov -0x4(%ebp),%ebx
10b1ac: 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);
10b1ad: e9 5f fd ff ff jmp 10af11 <rtems_aio_enqueue>
}
10b1b2: 83 c8 ff or $0xffffffff,%eax
10b1b5: 8b 5d fc mov -0x4(%ebp),%ebx
10b1b8: c9 leave
10b1b9: c3 ret
0010b1c8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b1c8: 55 push %ebp
10b1c9: 89 e5 mov %esp,%ebp
10b1cb: 53 push %ebx
10b1cc: 83 ec 0c sub $0xc,%esp
10b1cf: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b1d2: 6a 03 push $0x3
10b1d4: ff 33 pushl (%ebx)
10b1d6: e8 91 56 00 00 call 11086c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b1db: 83 e0 03 and $0x3,%eax
10b1de: 48 dec %eax
10b1df: 83 c4 10 add $0x10,%esp
10b1e2: 83 f8 01 cmp $0x1,%eax
10b1e5: 76 1b jbe 10b202 <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1e7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b1ee: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1f5: e8 d6 84 00 00 call 1136d0 <__errno>
10b1fa: c7 00 09 00 00 00 movl $0x9,(%eax)
10b200: eb 69 jmp 10b26b <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b202: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b206: 75 06 jne 10b20e <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b208: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b20c: 79 1b jns 10b229 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b20e: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b215: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b21c: e8 af 84 00 00 call 1136d0 <__errno>
10b221: c7 00 16 00 00 00 movl $0x16,(%eax)
10b227: eb 42 jmp 10b26b <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b229: 83 ec 0c sub $0xc,%esp
10b22c: 6a 18 push $0x18
10b22e: e8 91 cf ff ff call 1081c4 <malloc>
if (req == NULL)
10b233: 83 c4 10 add $0x10,%esp
10b236: 85 c0 test %eax,%eax
10b238: 75 1b jne 10b255 <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b23a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b241: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b248: e8 83 84 00 00 call 1136d0 <__errno> <== NOT EXECUTED
10b24d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b253: eb 16 jmp 10b26b <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b255: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b258: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b25f: 89 45 08 mov %eax,0x8(%ebp)
}
10b262: 8b 5d fc mov -0x4(%ebp),%ebx
10b265: 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);
10b266: e9 a6 fc ff ff jmp 10af11 <rtems_aio_enqueue>
}
10b26b: 83 c8 ff or $0xffffffff,%eax
10b26e: 8b 5d fc mov -0x4(%ebp),%ebx
10b271: c9 leave
10b272: c3 ret
00109f94 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109f94: 55 push %ebp
109f95: 89 e5 mov %esp,%ebp
109f97: 83 ec 08 sub $0x8,%esp
109f9a: 8b 45 08 mov 0x8(%ebp),%eax
109f9d: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109fa0: 85 d2 test %edx,%edx
109fa2: 74 3c je 109fe0 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109fa4: 83 f8 01 cmp $0x1,%eax
109fa7: 75 0b jne 109fb4 <clock_gettime+0x20>
_TOD_Get(tp);
109fa9: 83 ec 0c sub $0xc,%esp
109fac: 52 push %edx
109fad: e8 b6 1b 00 00 call 10bb68 <_TOD_Get>
109fb2: eb 13 jmp 109fc7 <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
109fb4: 83 f8 04 cmp $0x4,%eax
109fb7: 74 05 je 109fbe <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
109fb9: 83 f8 02 cmp $0x2,%eax
109fbc: 75 10 jne 109fce <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
109fbe: 83 ec 0c sub $0xc,%esp
109fc1: 52 push %edx
109fc2: e8 fd 1b 00 00 call 10bbc4 <_TOD_Get_uptime_as_timespec>
return 0;
109fc7: 83 c4 10 add $0x10,%esp
109fca: 31 c0 xor %eax,%eax
109fcc: eb 20 jmp 109fee <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
109fce: 83 f8 03 cmp $0x3,%eax
109fd1: 75 0d jne 109fe0 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
109fd3: e8 0c 80 00 00 call 111fe4 <__errno>
109fd8: c7 00 58 00 00 00 movl $0x58,(%eax)
109fde: eb 0b jmp 109feb <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
109fe0: e8 ff 7f 00 00 call 111fe4 <__errno>
109fe5: c7 00 16 00 00 00 movl $0x16,(%eax)
109feb: 83 c8 ff or $0xffffffff,%eax
return 0;
}
109fee: c9 leave
109fef: c3 ret
00109ff0 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
109ff0: 55 push %ebp
109ff1: 89 e5 mov %esp,%ebp
109ff3: 83 ec 08 sub $0x8,%esp
109ff6: 8b 45 08 mov 0x8(%ebp),%eax
109ff9: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109ffc: 85 d2 test %edx,%edx
109ffe: 74 44 je 10a044 <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a000: 83 f8 01 cmp $0x1,%eax
10a003: 75 28 jne 10a02d <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a005: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a00b: 76 37 jbe 10a044 <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a00d: a1 20 63 12 00 mov 0x126320,%eax
10a012: 40 inc %eax
10a013: a3 20 63 12 00 mov %eax,0x126320
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a018: 83 ec 0c sub $0xc,%esp
10a01b: 52 push %edx
10a01c: e8 fb 1b 00 00 call 10bc1c <_TOD_Set>
_Thread_Enable_dispatch();
10a021: e8 80 2e 00 00 call 10cea6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a026: 83 c4 10 add $0x10,%esp
10a029: 31 c0 xor %eax,%eax
10a02b: eb 25 jmp 10a052 <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a02d: 83 f8 02 cmp $0x2,%eax
10a030: 74 05 je 10a037 <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a032: 83 f8 03 cmp $0x3,%eax
10a035: 75 0d jne 10a044 <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a037: e8 a8 7f 00 00 call 111fe4 <__errno>
10a03c: c7 00 58 00 00 00 movl $0x58,(%eax)
10a042: eb 0b jmp 10a04f <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a044: e8 9b 7f 00 00 call 111fe4 <__errno>
10a049: c7 00 16 00 00 00 movl $0x16,(%eax)
10a04f: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a052: c9 leave
10a053: c3 ret
001216a0 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
1216a0: 55 push %ebp
1216a1: 89 e5 mov %esp,%ebp
1216a3: 57 push %edi
1216a4: 56 push %esi
1216a5: 53 push %ebx
1216a6: 83 ec 4c sub $0x4c,%esp
1216a9: 8b 5d 0c mov 0xc(%ebp),%ebx
1216ac: 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() )
1216af: e8 64 fd ff ff call 121418 <getpid>
1216b4: 39 45 08 cmp %eax,0x8(%ebp)
1216b7: 74 0d je 1216c6 <killinfo+0x26>
rtems_set_errno_and_return_minus_one( ESRCH );
1216b9: e8 1a 43 ff ff call 1159d8 <__errno>
1216be: c7 00 03 00 00 00 movl $0x3,(%eax)
1216c4: eb 0f jmp 1216d5 <killinfo+0x35>
/*
* Validate the signal passed.
*/
if ( !sig )
1216c6: 85 db test %ebx,%ebx
1216c8: 75 13 jne 1216dd <killinfo+0x3d>
rtems_set_errno_and_return_minus_one( EINVAL );
1216ca: e8 09 43 ff ff call 1159d8 <__errno>
1216cf: c7 00 16 00 00 00 movl $0x16,(%eax)
1216d5: 83 c8 ff or $0xffffffff,%eax
1216d8: e9 ef 01 00 00 jmp 1218cc <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
1216dd: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
1216e0: 83 f9 1f cmp $0x1f,%ecx
1216e3: 77 e5 ja 1216ca <killinfo+0x2a>
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 )
1216e5: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
1216e8: 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 )
1216ea: 83 ba dc a9 12 00 01 cmpl $0x1,0x12a9dc(%edx)
1216f1: 0f 84 d5 01 00 00 je 1218cc <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 ) )
1216f7: 83 fb 04 cmp $0x4,%ebx
1216fa: 74 0a je 121706 <killinfo+0x66>
1216fc: 83 fb 08 cmp $0x8,%ebx
1216ff: 74 05 je 121706 <killinfo+0x66>
121701: 83 fb 0b cmp $0xb,%ebx
121704: 75 16 jne 12171c <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
121706: e8 89 03 00 00 call 121a94 <pthread_self>
12170b: 56 push %esi
12170c: 56 push %esi
12170d: 53 push %ebx
12170e: 50 push %eax
12170f: e8 d8 02 00 00 call 1219ec <pthread_kill>
121714: 83 c4 10 add $0x10,%esp
121717: e9 b0 01 00 00 jmp 1218cc <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
12171c: be 01 00 00 00 mov $0x1,%esi
121721: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
121723: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
121726: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
12172d: 85 ff test %edi,%edi
12172f: 75 09 jne 12173a <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
121731: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
121738: eb 05 jmp 12173f <killinfo+0x9f>
} else {
siginfo->si_value = *value;
12173a: 8b 07 mov (%edi),%eax
12173c: 89 45 e4 mov %eax,-0x1c(%ebp)
12173f: a1 54 a4 12 00 mov 0x12a454,%eax
121744: 40 inc %eax
121745: a3 54 a4 12 00 mov %eax,0x12a454
/*
* 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;
12174a: a1 a0 a9 12 00 mov 0x12a9a0,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
12174f: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
121755: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
12175b: f7 d2 not %edx
12175d: 85 d6 test %edx,%esi
12175f: 0f 85 ed 00 00 00 jne 121852 <killinfo+0x1b2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
121765: 8b 15 60 ab 12 00 mov 0x12ab60,%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 );
12176b: eb 23 jmp 121790 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
12176d: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
12176f: 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)
121775: 85 72 30 test %esi,0x30(%edx)
121778: 0f 85 d4 00 00 00 jne 121852 <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
12177e: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
121784: f7 d1 not %ecx
121786: 85 ce test %ecx,%esi
121788: 0f 85 c4 00 00 00 jne 121852 <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 ) {
12178e: 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 );
121790: 81 fa 64 ab 12 00 cmp $0x12ab64,%edx
121796: 75 d5 jne 12176d <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
121798: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx
12179f: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
1217a0: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
1217a2: 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 ] )
1217a9: 8b 7d cc mov -0x34(%ebp),%edi
1217ac: 8b 14 bd 2c a4 12 00 mov 0x12a42c(,%edi,4),%edx
1217b3: 85 d2 test %edx,%edx
1217b5: 0f 84 86 00 00 00 je 121841 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
1217bb: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
1217be: 0f b7 7a 10 movzwl 0x10(%edx),%edi
1217c2: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
1217c5: 8b 52 1c mov 0x1c(%edx),%edx
1217c8: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
1217cb: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
1217d2: 89 5d b4 mov %ebx,-0x4c(%ebp)
1217d5: eb 5f jmp 121836 <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
1217d7: 8b 5d d0 mov -0x30(%ebp),%ebx
1217da: 8b 7d c0 mov -0x40(%ebp),%edi
1217dd: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
1217e0: 85 d2 test %edx,%edx
1217e2: 74 4f je 121833 <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 )
1217e4: 8b 5a 14 mov 0x14(%edx),%ebx
1217e7: 89 5d d4 mov %ebx,-0x2c(%ebp)
1217ea: 39 cb cmp %ecx,%ebx
1217ec: 77 45 ja 121833 <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
1217ee: 8b ba ec 00 00 00 mov 0xec(%edx),%edi
1217f4: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
1217fa: f7 d7 not %edi
1217fc: 85 fe test %edi,%esi
1217fe: 74 33 je 121833 <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 ) {
121800: 39 cb cmp %ecx,%ebx
121802: 72 2a jb 12182e <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 ) ) {
121804: 85 c0 test %eax,%eax
121806: 74 2b je 121833 <killinfo+0x193> <== NEVER TAKEN
121808: 8b 78 10 mov 0x10(%eax),%edi
12180b: 89 7d c8 mov %edi,-0x38(%ebp)
12180e: 85 ff test %edi,%edi
121810: 74 21 je 121833 <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
121812: 8b 7a 10 mov 0x10(%edx),%edi
121815: 85 ff test %edi,%edi
121817: 74 15 je 12182e <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
121819: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
121820: 75 11 jne 121833 <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
121822: 81 e7 00 00 00 10 and $0x10000000,%edi
121828: 74 09 je 121833 <killinfo+0x193>
12182a: 89 d9 mov %ebx,%ecx
12182c: eb 03 jmp 121831 <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 ) ) {
12182e: 8b 4d d4 mov -0x2c(%ebp),%ecx
121831: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
121833: ff 45 d0 incl -0x30(%ebp)
121836: 8b 55 c4 mov -0x3c(%ebp),%edx
121839: 39 55 d0 cmp %edx,-0x30(%ebp)
12183c: 76 99 jbe 1217d7 <killinfo+0x137>
12183e: 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++) {
121841: ff 45 cc incl -0x34(%ebp)
121844: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
121848: 0f 85 5b ff ff ff jne 1217a9 <killinfo+0x109>
}
}
}
}
if ( interested ) {
12184e: 85 c0 test %eax,%eax
121850: 74 13 je 121865 <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 ) ) {
121852: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
121853: 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 ) ) {
121856: 52 push %edx
121857: 53 push %ebx
121858: 50 push %eax
121859: e8 8a 00 00 00 call 1218e8 <_POSIX_signals_Unblock_thread>
12185e: 83 c4 10 add $0x10,%esp
121861: 84 c0 test %al,%al
121863: 75 60 jne 1218c5 <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 );
121865: 83 ec 0c sub $0xc,%esp
121868: 56 push %esi
121869: e8 66 00 00 00 call 1218d4 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
12186e: 6b db 0c imul $0xc,%ebx,%ebx
121871: 83 c4 10 add $0x10,%esp
121874: 83 bb d4 a9 12 00 02 cmpl $0x2,0x12a9d4(%ebx)
12187b: 75 48 jne 1218c5 <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
12187d: 83 ec 0c sub $0xc,%esp
121880: 68 54 ab 12 00 push $0x12ab54
121885: e8 a6 d8 fe ff call 10f130 <_Chain_Get>
if ( !psiginfo ) {
12188a: 83 c4 10 add $0x10,%esp
12188d: 85 c0 test %eax,%eax
12188f: 75 15 jne 1218a6 <killinfo+0x206>
_Thread_Enable_dispatch();
121891: e8 fc ef fe ff call 110892 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
121896: e8 3d 41 ff ff call 1159d8 <__errno>
12189b: c7 00 0b 00 00 00 movl $0xb,(%eax)
1218a1: e9 2f fe ff ff jmp 1216d5 <killinfo+0x35>
}
psiginfo->Info = *siginfo;
1218a6: 8d 78 08 lea 0x8(%eax),%edi
1218a9: 8d 75 dc lea -0x24(%ebp),%esi
1218ac: b9 03 00 00 00 mov $0x3,%ecx
1218b1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
1218b3: 52 push %edx
1218b4: 52 push %edx
1218b5: 50 push %eax
1218b6: 81 c3 cc ab 12 00 add $0x12abcc,%ebx
1218bc: 53 push %ebx
1218bd: e8 32 d8 fe ff call 10f0f4 <_Chain_Append>
1218c2: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
1218c5: e8 c8 ef fe ff call 110892 <_Thread_Enable_dispatch>
return 0;
1218ca: 31 c0 xor %eax,%eax
}
1218cc: 8d 65 f4 lea -0xc(%ebp),%esp
1218cf: 5b pop %ebx
1218d0: 5e pop %esi
1218d1: 5f pop %edi
1218d2: c9 leave
1218d3: c3 ret
0010dff0 <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
10dff0: 55 push %ebp
10dff1: 89 e5 mov %esp,%ebp
10dff3: 53 push %ebx
10dff4: 83 ec 14 sub $0x14,%esp
10dff7: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Attributes *the_mq_attr;
if ( !mqstat )
10dffa: 85 db test %ebx,%ebx
10dffc: 75 0d jne 10e00b <mq_getattr+0x1b> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10dffe: e8 65 8e 00 00 call 116e68 <__errno>
10e003: c7 00 16 00 00 00 movl $0x16,(%eax)
10e009: eb 49 jmp 10e054 <mq_getattr+0x64>
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(
10e00b: 50 push %eax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10e00c: 8d 45 f4 lea -0xc(%ebp),%eax
10e00f: 50 push %eax
10e010: ff 75 08 pushl 0x8(%ebp)
10e013: 68 f4 cc 12 00 push $0x12ccf4
10e018: e8 bb 2d 00 00 call 110dd8 <_Objects_Get>
switch ( location ) {
10e01d: 83 c4 10 add $0x10,%esp
10e020: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10e024: 75 23 jne 10e049 <mq_getattr+0x59>
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
10e026: 8b 50 10 mov 0x10(%eax),%edx
* Return the old values.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
mqstat->mq_flags = the_mq_fd->oflag;
10e029: 8b 40 14 mov 0x14(%eax),%eax
10e02c: 89 03 mov %eax,(%ebx)
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
10e02e: 8b 42 68 mov 0x68(%edx),%eax
10e031: 89 43 08 mov %eax,0x8(%ebx)
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
10e034: 8b 42 60 mov 0x60(%edx),%eax
10e037: 89 43 04 mov %eax,0x4(%ebx)
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
10e03a: 8b 42 64 mov 0x64(%edx),%eax
10e03d: 89 43 0c mov %eax,0xc(%ebx)
_Thread_Enable_dispatch();
10e040: e8 e5 37 00 00 call 11182a <_Thread_Enable_dispatch>
return 0;
10e045: 31 c0 xor %eax,%eax
10e047: eb 0e jmp 10e057 <mq_getattr+0x67>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e049: e8 1a 8e 00 00 call 116e68 <__errno>
10e04e: c7 00 09 00 00 00 movl $0x9,(%eax)
10e054: 83 c8 ff or $0xffffffff,%eax
}
10e057: 8b 5d fc mov -0x4(%ebp),%ebx
10e05a: c9 leave
10e05b: c3 ret
0010efd8 <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
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 || !inheritsched )
return EINVAL;
10efe1: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
10efe6: 85 d2 test %edx,%edx
10efe8: 74 17 je 10f001 <pthread_attr_getinheritsched+0x29><== NEVER TAKEN
10efea: 85 c9 test %ecx,%ecx
10efec: 74 0e je 10effc <pthread_attr_getinheritsched+0x24>
10efee: 83 3a 00 cmpl $0x0,(%edx)
10eff1: 74 09 je 10effc <pthread_attr_getinheritsched+0x24>
return EINVAL;
*inheritsched = attr->inheritsched;
10eff3: 8b 42 10 mov 0x10(%edx),%eax
10eff6: 89 01 mov %eax,(%ecx)
return 0;
10eff8: 31 c0 xor %eax,%eax
10effa: eb 05 jmp 10f001 <pthread_attr_getinheritsched+0x29>
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10effc: b8 16 00 00 00 mov $0x16,%eax
*inheritsched = attr->inheritsched;
return 0;
}
10f001: c9 leave
10f002: c3 ret
0010f1f4 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f1f4: 55 push %ebp
10f1f5: 89 e5 mov %esp,%ebp
10f1f7: 8b 55 08 mov 0x8(%ebp),%edx
10f1fa: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f1fd: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f202: 85 d2 test %edx,%edx
10f204: 74 1e je 10f224 <pthread_attr_setschedpolicy+0x30>
10f206: 83 3a 00 cmpl $0x0,(%edx)
10f209: 74 19 je 10f224 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f20b: 83 f9 04 cmp $0x4,%ecx
10f20e: 77 0f ja 10f21f <pthread_attr_setschedpolicy+0x2b>
10f210: b0 01 mov $0x1,%al
10f212: d3 e0 shl %cl,%eax
10f214: a8 17 test $0x17,%al
10f216: 74 07 je 10f21f <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f218: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f21b: 31 c0 xor %eax,%eax
10f21d: eb 05 jmp 10f224 <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f21f: b8 86 00 00 00 mov $0x86,%eax
}
}
10f224: c9 leave
10f225: c3 ret
0010a514 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a514: 55 push %ebp
10a515: 89 e5 mov %esp,%ebp
10a517: 57 push %edi
10a518: 56 push %esi
10a519: 53 push %ebx
10a51a: 83 ec 1c sub $0x1c,%esp
10a51d: 8b 5d 08 mov 0x8(%ebp),%ebx
10a520: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a523: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a528: 85 db test %ebx,%ebx
10a52a: 0f 84 96 00 00 00 je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a530: 85 f6 test %esi,%esi
10a532: 0f 84 8e 00 00 00 je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a538: 8b 7d 0c mov 0xc(%ebp),%edi
10a53b: 85 ff test %edi,%edi
10a53d: 75 0f jne 10a54e <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a53f: 83 ec 0c sub $0xc,%esp
10a542: 8d 7d d8 lea -0x28(%ebp),%edi
10a545: 57 push %edi
10a546: e8 19 ff ff ff call 10a464 <pthread_barrierattr_init>
10a54b: 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;
10a54e: 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 )
10a553: 83 3f 00 cmpl $0x0,(%edi)
10a556: 74 6e je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a558: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a55c: 75 68 jne 10a5c6 <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a55e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a565: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a568: a1 90 64 12 00 mov 0x126490,%eax
10a56d: 40 inc %eax
10a56e: a3 90 64 12 00 mov %eax,0x126490
* 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 );
10a573: 83 ec 0c sub $0xc,%esp
10a576: 68 58 68 12 00 push $0x126858
10a57b: e8 14 1e 00 00 call 10c394 <_Objects_Allocate>
10a580: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a582: 83 c4 10 add $0x10,%esp
10a585: 85 c0 test %eax,%eax
10a587: 75 0c jne 10a595 <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a589: e8 14 2c 00 00 call 10d1a2 <_Thread_Enable_dispatch>
return EAGAIN;
10a58e: b8 0b 00 00 00 mov $0xb,%eax
10a593: eb 31 jmp 10a5c6 <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a595: 50 push %eax
10a596: 50 push %eax
10a597: 8d 45 e0 lea -0x20(%ebp),%eax
10a59a: 50 push %eax
10a59b: 8d 46 10 lea 0x10(%esi),%eax
10a59e: 50 push %eax
10a59f: e8 a8 14 00 00 call 10ba4c <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5a4: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5a7: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a5aa: 8b 15 74 68 12 00 mov 0x126874,%edx
10a5b0: 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;
10a5b3: 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;
10a5ba: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a5bc: e8 e1 2b 00 00 call 10d1a2 <_Thread_Enable_dispatch>
return 0;
10a5c1: 83 c4 10 add $0x10,%esp
10a5c4: 31 c0 xor %eax,%eax
}
10a5c6: 8d 65 f4 lea -0xc(%ebp),%esp
10a5c9: 5b pop %ebx
10a5ca: 5e pop %esi
10a5cb: 5f pop %edi
10a5cc: c9 leave
10a5cd: c3 ret
00109ecc <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109ecc: 55 push %ebp
109ecd: 89 e5 mov %esp,%ebp
109ecf: 56 push %esi
109ed0: 53 push %ebx
109ed1: 8b 5d 08 mov 0x8(%ebp),%ebx
109ed4: 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 )
109ed7: 85 db test %ebx,%ebx
109ed9: 74 4b je 109f26 <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109edb: a1 c8 62 12 00 mov 0x1262c8,%eax
109ee0: 40 inc %eax
109ee1: a3 c8 62 12 00 mov %eax,0x1262c8
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109ee6: 83 ec 0c sub $0xc,%esp
109ee9: 6a 10 push $0x10
109eeb: e8 02 3c 00 00 call 10daf2 <_Workspace_Allocate>
if ( handler ) {
109ef0: 83 c4 10 add $0x10,%esp
109ef3: 85 c0 test %eax,%eax
109ef5: 74 24 je 109f1b <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109ef7: 8b 15 14 68 12 00 mov 0x126814,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109efd: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx
109f03: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f09: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f0c: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f0f: 51 push %ecx
109f10: 51 push %ecx
109f11: 50 push %eax
109f12: 52 push %edx
109f13: e8 88 15 00 00 call 10b4a0 <_Chain_Append>
109f18: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f1b: 8d 65 f8 lea -0x8(%ebp),%esp
109f1e: 5b pop %ebx
109f1f: 5e pop %esi
109f20: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f21: e9 78 2c 00 00 jmp 10cb9e <_Thread_Enable_dispatch>
}
109f26: 8d 65 f8 lea -0x8(%ebp),%esp
109f29: 5b pop %ebx
109f2a: 5e pop %esi
109f2b: c9 leave
109f2c: c3 ret
0010ac3c <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac3c: 55 push %ebp
10ac3d: 89 e5 mov %esp,%ebp
10ac3f: 56 push %esi
10ac40: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac41: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac44: 85 db test %ebx,%ebx
10ac46: 75 05 jne 10ac4d <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10ac48: bb d0 0c 12 00 mov $0x120cd0,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10ac4d: 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 )
10ac52: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10ac56: 74 76 je 10acce <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10ac58: 83 3b 00 cmpl $0x0,(%ebx)
10ac5b: 74 71 je 10acce <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10ac5d: a1 60 73 12 00 mov 0x127360,%eax
10ac62: 40 inc %eax
10ac63: 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 );
10ac68: 83 ec 0c sub $0xc,%esp
10ac6b: 68 c0 77 12 00 push $0x1277c0
10ac70: e8 ff 22 00 00 call 10cf74 <_Objects_Allocate>
10ac75: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10ac77: 83 c4 10 add $0x10,%esp
10ac7a: 85 c0 test %eax,%eax
10ac7c: 75 0c jne 10ac8a <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10ac7e: e8 ff 30 00 00 call 10dd82 <_Thread_Enable_dispatch>
return ENOMEM;
10ac83: b8 0c 00 00 00 mov $0xc,%eax
10ac88: eb 44 jmp 10acce <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ac8a: 8b 43 04 mov 0x4(%ebx),%eax
10ac8d: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ac90: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10ac97: 6a 74 push $0x74
10ac99: 68 00 08 00 10 push $0x10000800
10ac9e: 6a 00 push $0x0
10aca0: 8d 46 18 lea 0x18(%esi),%eax
10aca3: 50 push %eax
10aca4: e8 cf 37 00 00 call 10e478 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10aca9: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10acac: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10acaf: 8b 15 dc 77 12 00 mov 0x1277dc,%edx
10acb5: 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;
10acb8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10acbf: 8b 55 08 mov 0x8(%ebp),%edx
10acc2: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10acc4: e8 b9 30 00 00 call 10dd82 <_Thread_Enable_dispatch>
return 0;
10acc9: 83 c4 10 add $0x10,%esp
10accc: 31 c0 xor %eax,%eax
}
10acce: 8d 65 f8 lea -0x8(%ebp),%esp
10acd1: 5b pop %ebx
10acd2: 5e pop %esi
10acd3: c9 leave
10acd4: c3 ret
0010aaf0 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10aaf0: 55 push %ebp
10aaf1: 89 e5 mov %esp,%ebp
10aaf3: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10aaf6: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10aafb: 85 d2 test %edx,%edx
10aafd: 74 0d je 10ab0c <pthread_condattr_destroy+0x1c>
10aaff: 83 3a 00 cmpl $0x0,(%edx)
10ab02: 74 08 je 10ab0c <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab04: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab0a: 30 c0 xor %al,%al
}
10ab0c: c9 leave
10ab0d: c3 ret
0010a224 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a224: 55 push %ebp
10a225: 89 e5 mov %esp,%ebp
10a227: 57 push %edi
10a228: 56 push %esi
10a229: 53 push %ebx
10a22a: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a22d: 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 )
10a234: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a238: 0f 84 0f 02 00 00 je 10a44d <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a23e: 8b 5d 0c mov 0xc(%ebp),%ebx
10a241: 85 db test %ebx,%ebx
10a243: 75 05 jne 10a24a <pthread_create+0x26>
10a245: bb 3c f9 11 00 mov $0x11f93c,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a24a: 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 )
10a251: 83 3b 00 cmpl $0x0,(%ebx)
10a254: 0f 84 f3 01 00 00 je 10a44d <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) )
10a25a: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a25e: 74 0e je 10a26e <pthread_create+0x4a>
10a260: a1 14 12 12 00 mov 0x121214,%eax
10a265: 39 43 08 cmp %eax,0x8(%ebx)
10a268: 0f 82 df 01 00 00 jb 10a44d <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 ) {
10a26e: 8b 43 10 mov 0x10(%ebx),%eax
10a271: 83 f8 01 cmp $0x1,%eax
10a274: 74 0b je 10a281 <pthread_create+0x5d>
10a276: 83 f8 02 cmp $0x2,%eax
10a279: 0f 85 c7 01 00 00 jne 10a446 <pthread_create+0x222>
10a27f: eb 1f jmp 10a2a0 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a281: a1 1c 58 12 00 mov 0x12581c,%eax
10a286: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10a28c: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a292: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a295: 8d 7d c4 lea -0x3c(%ebp),%edi
10a298: 81 c6 88 00 00 00 add $0x88,%esi
10a29e: eb 0c jmp 10a2ac <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2a0: 8b 43 14 mov 0x14(%ebx),%eax
10a2a3: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2a6: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2a9: 8d 73 18 lea 0x18(%ebx),%esi
10a2ac: b9 07 00 00 00 mov $0x7,%ecx
10a2b1: 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;
10a2b3: 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 )
10a2ba: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a2be: 0f 85 89 01 00 00 jne 10a44d <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2c4: 83 ec 0c sub $0xc,%esp
10a2c7: ff 75 c4 pushl -0x3c(%ebp)
10a2ca: e8 e5 58 00 00 call 10fbb4 <_POSIX_Priority_Is_valid>
10a2cf: 83 c4 10 add $0x10,%esp
return EINVAL;
10a2d2: 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 ) )
10a2d9: 84 c0 test %al,%al
10a2db: 0f 84 6c 01 00 00 je 10a44d <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a2e1: 8b 45 c4 mov -0x3c(%ebp),%eax
10a2e4: 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);
10a2e7: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a2ee: 8d 45 e0 lea -0x20(%ebp),%eax
10a2f1: 50 push %eax
10a2f2: 8d 45 e4 lea -0x1c(%ebp),%eax
10a2f5: 50 push %eax
10a2f6: 8d 45 c4 lea -0x3c(%ebp),%eax
10a2f9: 50 push %eax
10a2fa: ff 75 ac pushl -0x54(%ebp)
10a2fd: e8 d2 58 00 00 call 10fbd4 <_POSIX_Thread_Translate_sched_param>
10a302: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a305: 83 c4 10 add $0x10,%esp
10a308: 85 c0 test %eax,%eax
10a30a: 0f 85 3d 01 00 00 jne 10a44d <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a310: 83 ec 0c sub $0xc,%esp
10a313: ff 35 94 53 12 00 pushl 0x125394
10a319: e8 56 15 00 00 call 10b874 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a31e: c7 04 24 18 55 12 00 movl $0x125518,(%esp)
10a325: e8 b2 1e 00 00 call 10c1dc <_Objects_Allocate>
10a32a: 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 ) {
10a32d: 83 c4 10 add $0x10,%esp
10a330: 85 c0 test %eax,%eax
10a332: 75 05 jne 10a339 <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a334: 83 ec 0c sub $0xc,%esp
10a337: eb 53 jmp 10a38c <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(
10a339: 8b 4d e0 mov -0x20(%ebp),%ecx
10a33c: 8b 75 e4 mov -0x1c(%ebp),%esi
10a33f: 8b 53 08 mov 0x8(%ebx),%edx
10a342: a1 14 12 12 00 mov 0x121214,%eax
10a347: d1 e0 shl %eax
10a349: 39 d0 cmp %edx,%eax
10a34b: 73 02 jae 10a34f <pthread_create+0x12b>
10a34d: 89 d0 mov %edx,%eax
10a34f: 52 push %edx
10a350: 6a 00 push $0x0
10a352: 6a 00 push $0x0
10a354: 51 push %ecx
10a355: 56 push %esi
10a356: 6a 01 push $0x1
10a358: 81 e7 ff 00 00 00 and $0xff,%edi
10a35e: 2b 7d a8 sub -0x58(%ebp),%edi
10a361: 57 push %edi
10a362: 6a 01 push $0x1
10a364: 50 push %eax
10a365: ff 73 04 pushl 0x4(%ebx)
10a368: ff 75 b0 pushl -0x50(%ebp)
10a36b: 68 18 55 12 00 push $0x125518
10a370: e8 07 2d 00 00 call 10d07c <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a375: 83 c4 30 add $0x30,%esp
10a378: 84 c0 test %al,%al
10a37a: 75 2a jne 10a3a6 <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a37c: 56 push %esi
10a37d: 56 push %esi
10a37e: ff 75 b0 pushl -0x50(%ebp)
10a381: 68 18 55 12 00 push $0x125518
10a386: e8 49 21 00 00 call 10c4d4 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a38b: 5b pop %ebx
10a38c: ff 35 94 53 12 00 pushl 0x125394
10a392: e8 25 15 00 00 call 10b8bc <_API_Mutex_Unlock>
return EAGAIN;
10a397: 83 c4 10 add $0x10,%esp
10a39a: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3a1: e9 a7 00 00 00 jmp 10a44d <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3a6: 8b 45 b0 mov -0x50(%ebp),%eax
10a3a9: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
api->Attributes = *the_attr;
10a3af: b9 10 00 00 00 mov $0x10,%ecx
10a3b4: 89 d7 mov %edx,%edi
10a3b6: 89 de mov %ebx,%esi
10a3b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a3ba: 8b 43 3c mov 0x3c(%ebx),%eax
10a3bd: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a3c0: 8b 45 ac mov -0x54(%ebp),%eax
10a3c3: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a3c9: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a3cf: 8d 75 c4 lea -0x3c(%ebp),%esi
10a3d2: b1 07 mov $0x7,%cl
10a3d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a3d6: 83 ec 0c sub $0xc,%esp
10a3d9: 6a 00 push $0x0
10a3db: ff 75 14 pushl 0x14(%ebp)
10a3de: ff 75 10 pushl 0x10(%ebp)
10a3e1: 6a 01 push $0x1
10a3e3: ff 75 b0 pushl -0x50(%ebp)
10a3e6: 89 55 a4 mov %edx,-0x5c(%ebp)
10a3e9: e8 3a 35 00 00 call 10d928 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a3ee: 83 c4 20 add $0x20,%esp
10a3f1: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a3f5: 8b 55 a4 mov -0x5c(%ebp),%edx
10a3f8: 75 2e jne 10a428 <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a3fa: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a3fd: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a403: 50 push %eax
10a404: e8 77 36 00 00 call 10da80 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a409: 8b 55 a4 mov -0x5c(%ebp),%edx
10a40c: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a412: 58 pop %eax
10a413: 59 pop %ecx
10a414: 81 c2 a8 00 00 00 add $0xa8,%edx
10a41a: 52 push %edx
10a41b: 68 b4 53 12 00 push $0x1253b4
10a420: e8 0f 39 00 00 call 10dd34 <_Watchdog_Insert>
10a425: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a428: 8b 45 b0 mov -0x50(%ebp),%eax
10a42b: 8b 50 08 mov 0x8(%eax),%edx
10a42e: 8b 45 08 mov 0x8(%ebp),%eax
10a431: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a433: 83 ec 0c sub $0xc,%esp
10a436: ff 35 94 53 12 00 pushl 0x125394
10a43c: e8 7b 14 00 00 call 10b8bc <_API_Mutex_Unlock>
return 0;
10a441: 83 c4 10 add $0x10,%esp
10a444: eb 07 jmp 10a44d <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a446: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a44d: 8b 45 b4 mov -0x4c(%ebp),%eax
10a450: 8d 65 f4 lea -0xc(%ebp),%esp
10a453: 5b pop %ebx
10a454: 5e pop %esi
10a455: 5f pop %edi
10a456: c9 leave
10a457: c3 ret
00110d54 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110d54: 55 push %ebp
110d55: 89 e5 mov %esp,%ebp
110d57: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110d5a: ff 75 08 pushl 0x8(%ebp)
110d5d: ff 35 2c 48 12 00 pushl 0x12482c
110d63: e8 88 ff ff ff call 110cf0 <_POSIX_Thread_Exit>
110d68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110d6b: c9 leave <== NOT EXECUTED
110d6c: c3 ret <== NOT EXECUTED
0010bf30 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf30: 55 push %ebp
10bf31: 89 e5 mov %esp,%ebp
10bf33: 53 push %ebx
10bf34: 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 );
10bf37: 8d 45 f4 lea -0xc(%ebp),%eax
10bf3a: 50 push %eax
10bf3b: ff 75 0c pushl 0xc(%ebp)
10bf3e: e8 b9 00 00 00 call 10bffc <_POSIX_Absolute_timeout_to_ticks>
10bf43: 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,
10bf45: 83 c4 0c add $0xc,%esp
10bf48: 83 f8 03 cmp $0x3,%eax
10bf4b: 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 );
10bf4e: ff 75 f4 pushl -0xc(%ebp)
10bf51: 0f b6 c2 movzbl %dl,%eax
10bf54: 50 push %eax
10bf55: ff 75 08 pushl 0x8(%ebp)
10bf58: 88 55 e4 mov %dl,-0x1c(%ebp)
10bf5b: e8 e8 fe ff ff call 10be48 <_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) ) {
10bf60: 83 c4 10 add $0x10,%esp
10bf63: 8a 55 e4 mov -0x1c(%ebp),%dl
10bf66: 84 d2 test %dl,%dl
10bf68: 75 1d jne 10bf87 <pthread_mutex_timedlock+0x57>
10bf6a: 83 f8 10 cmp $0x10,%eax
10bf6d: 75 18 jne 10bf87 <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bf6f: 85 db test %ebx,%ebx
10bf71: 74 08 je 10bf7b <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bf73: 4b dec %ebx
10bf74: 83 fb 01 cmp $0x1,%ebx
10bf77: 77 0e ja 10bf87 <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bf79: eb 07 jmp 10bf82 <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;
10bf7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bf80: eb 05 jmp 10bf87 <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bf82: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bf87: 8b 5d fc mov -0x4(%ebp),%ebx
10bf8a: c9 leave
10bf8b: c3 ret
0010bba8 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bba8: 55 push %ebp
10bba9: 89 e5 mov %esp,%ebp
10bbab: 8b 55 08 mov 0x8(%ebp),%edx
10bbae: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bbb1: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbb6: 85 d2 test %edx,%edx
10bbb8: 74 0f je 10bbc9 <pthread_mutexattr_setpshared+0x21>
10bbba: 83 3a 00 cmpl $0x0,(%edx)
10bbbd: 74 0a je 10bbc9 <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bbbf: 83 f9 01 cmp $0x1,%ecx
10bbc2: 77 05 ja 10bbc9 <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bbc4: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bbc7: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bbc9: c9 leave
10bbca: c3 ret
00109dc0 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109dc0: 55 push %ebp
109dc1: 89 e5 mov %esp,%ebp
109dc3: 8b 55 08 mov 0x8(%ebp),%edx
109dc6: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109dc9: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109dce: 85 d2 test %edx,%edx
109dd0: 74 0f je 109de1 <pthread_mutexattr_settype+0x21>
109dd2: 83 3a 00 cmpl $0x0,(%edx)
109dd5: 74 0a je 109de1 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109dd7: 83 f9 03 cmp $0x3,%ecx
109dda: 77 05 ja 109de1 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109ddc: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109ddf: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109de1: c9 leave
109de2: c3 ret
0010a870 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a870: 55 push %ebp
10a871: 89 e5 mov %esp,%ebp
10a873: 56 push %esi
10a874: 53 push %ebx
10a875: 83 ec 10 sub $0x10,%esp
10a878: 8b 5d 08 mov 0x8(%ebp),%ebx
10a87b: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a87e: 85 f6 test %esi,%esi
10a880: 74 51 je 10a8d3 <pthread_once+0x63>
10a882: 85 db test %ebx,%ebx
10a884: 74 4d je 10a8d3 <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a886: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a888: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a88c: 75 4a jne 10a8d8 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a88e: 52 push %edx
10a88f: 8d 45 f4 lea -0xc(%ebp),%eax
10a892: 50 push %eax
10a893: 68 00 01 00 00 push $0x100
10a898: 68 00 01 00 00 push $0x100
10a89d: e8 a6 0a 00 00 call 10b348 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8a2: 83 c4 10 add $0x10,%esp
10a8a5: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8a9: 75 0f jne 10a8ba <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a8ab: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a8b1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a8b8: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a8ba: 50 push %eax
10a8bb: 8d 45 f4 lea -0xc(%ebp),%eax
10a8be: 50 push %eax
10a8bf: 68 00 01 00 00 push $0x100
10a8c4: ff 75 f4 pushl -0xc(%ebp)
10a8c7: e8 7c 0a 00 00 call 10b348 <rtems_task_mode>
10a8cc: 83 c4 10 add $0x10,%esp
}
return 0;
10a8cf: 31 c0 xor %eax,%eax
10a8d1: eb 05 jmp 10a8d8 <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a8d3: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a8d8: 8d 65 f8 lea -0x8(%ebp),%esp
10a8db: 5b pop %ebx
10a8dc: 5e pop %esi
10a8dd: c9 leave
10a8de: c3 ret
0010b09c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b09c: 55 push %ebp
10b09d: 89 e5 mov %esp,%ebp
10b09f: 56 push %esi
10b0a0: 53 push %ebx
10b0a1: 83 ec 10 sub $0x10,%esp
10b0a4: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0a7: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b0ac: 85 db test %ebx,%ebx
10b0ae: 0f 84 8b 00 00 00 je 10b13f <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b0b4: 8b 75 0c mov 0xc(%ebp),%esi
10b0b7: 85 f6 test %esi,%esi
10b0b9: 75 0f jne 10b0ca <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b0bb: 83 ec 0c sub $0xc,%esp
10b0be: 8d 75 ec lea -0x14(%ebp),%esi
10b0c1: 56 push %esi
10b0c2: e8 5d 09 00 00 call 10ba24 <pthread_rwlockattr_init>
10b0c7: 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;
10b0ca: 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 )
10b0cf: 83 3e 00 cmpl $0x0,(%esi)
10b0d2: 74 6b je 10b13f <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b0d4: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b0d8: 75 65 jne 10b13f <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b0da: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b0e1: a1 f0 82 12 00 mov 0x1282f0,%eax
10b0e6: 40 inc %eax
10b0e7: a3 f0 82 12 00 mov %eax,0x1282f0
* 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 );
10b0ec: 83 ec 0c sub $0xc,%esp
10b0ef: 68 f8 84 12 00 push $0x1284f8
10b0f4: e8 3b 23 00 00 call 10d434 <_Objects_Allocate>
10b0f9: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b0fb: 83 c4 10 add $0x10,%esp
10b0fe: 85 c0 test %eax,%eax
10b100: 75 0c jne 10b10e <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b102: e8 3b 31 00 00 call 10e242 <_Thread_Enable_dispatch>
return EAGAIN;
10b107: b8 0b 00 00 00 mov $0xb,%eax
10b10c: eb 31 jmp 10b13f <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b10e: 50 push %eax
10b10f: 50 push %eax
10b110: 8d 45 f4 lea -0xc(%ebp),%eax
10b113: 50 push %eax
10b114: 8d 46 10 lea 0x10(%esi),%eax
10b117: 50 push %eax
10b118: e8 7b 1b 00 00 call 10cc98 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b11d: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b120: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b123: 8b 15 14 85 12 00 mov 0x128514,%edx
10b129: 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;
10b12c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b133: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b135: e8 08 31 00 00 call 10e242 <_Thread_Enable_dispatch>
return 0;
10b13a: 83 c4 10 add $0x10,%esp
10b13d: 31 c0 xor %eax,%eax
}
10b13f: 8d 65 f8 lea -0x8(%ebp),%esp
10b142: 5b pop %ebx
10b143: 5e pop %esi
10b144: c9 leave
10b145: c3 ret
0010b1b0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b1b0: 55 push %ebp
10b1b1: 89 e5 mov %esp,%ebp
10b1b3: 57 push %edi
10b1b4: 56 push %esi
10b1b5: 53 push %ebx
10b1b6: 83 ec 2c sub $0x2c,%esp
10b1b9: 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;
10b1bc: 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 )
10b1c1: 85 ff test %edi,%edi
10b1c3: 0f 84 87 00 00 00 je 10b250 <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 );
10b1c9: 50 push %eax
10b1ca: 50 push %eax
10b1cb: 8d 45 e0 lea -0x20(%ebp),%eax
10b1ce: 50 push %eax
10b1cf: ff 75 0c pushl 0xc(%ebp)
10b1d2: e8 2d 59 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks>
10b1d7: 89 c6 mov %eax,%esi
10b1d9: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b1dc: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1df: 50 push %eax
10b1e0: ff 37 pushl (%edi)
10b1e2: 68 f8 84 12 00 push $0x1284f8
10b1e7: e8 78 26 00 00 call 10d864 <_Objects_Get>
switch ( location ) {
10b1ec: 83 c4 10 add $0x10,%esp
10b1ef: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b1f3: 75 5b jne 10b250 <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,
10b1f5: 83 fe 03 cmp $0x3,%esi
10b1f8: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b1fb: 83 ec 0c sub $0xc,%esp
10b1fe: 6a 00 push $0x0
10b200: ff 75 e0 pushl -0x20(%ebp)
10b203: 0f b6 ca movzbl %dl,%ecx
10b206: 51 push %ecx
10b207: ff 37 pushl (%edi)
10b209: 83 c0 10 add $0x10,%eax
10b20c: 50 push %eax
10b20d: 88 55 d4 mov %dl,-0x2c(%ebp)
10b210: e8 b7 1a 00 00 call 10cccc <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b215: 83 c4 20 add $0x20,%esp
10b218: e8 25 30 00 00 call 10e242 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b21d: 8a 55 d4 mov -0x2c(%ebp),%dl
10b220: 84 d2 test %dl,%dl
10b222: 75 17 jne 10b23b <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b224: a1 3c 88 12 00 mov 0x12883c,%eax
10b229: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b22d: 75 0c jne 10b23b <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b22f: 85 f6 test %esi,%esi
10b231: 74 1d je 10b250 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b233: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b234: 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 ||
10b236: 83 fe 01 cmp $0x1,%esi
10b239: 76 15 jbe 10b250 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b23b: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b23e: a1 3c 88 12 00 mov 0x12883c,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b243: ff 70 34 pushl 0x34(%eax)
10b246: e8 bd 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b24b: 89 c3 mov %eax,%ebx
10b24d: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b250: 89 d8 mov %ebx,%eax
10b252: 8d 65 f4 lea -0xc(%ebp),%esp
10b255: 5b pop %ebx
10b256: 5e pop %esi
10b257: 5f pop %edi
10b258: c9 leave
10b259: c3 ret
0010b25c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b25c: 55 push %ebp
10b25d: 89 e5 mov %esp,%ebp
10b25f: 57 push %edi
10b260: 56 push %esi
10b261: 53 push %ebx
10b262: 83 ec 2c sub $0x2c,%esp
10b265: 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;
10b268: 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 )
10b26d: 85 ff test %edi,%edi
10b26f: 0f 84 87 00 00 00 je 10b2fc <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 );
10b275: 50 push %eax
10b276: 50 push %eax
10b277: 8d 45 e0 lea -0x20(%ebp),%eax
10b27a: 50 push %eax
10b27b: ff 75 0c pushl 0xc(%ebp)
10b27e: e8 81 58 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks>
10b283: 89 c6 mov %eax,%esi
10b285: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b288: 8d 45 e4 lea -0x1c(%ebp),%eax
10b28b: 50 push %eax
10b28c: ff 37 pushl (%edi)
10b28e: 68 f8 84 12 00 push $0x1284f8
10b293: e8 cc 25 00 00 call 10d864 <_Objects_Get>
switch ( location ) {
10b298: 83 c4 10 add $0x10,%esp
10b29b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b29f: 75 5b jne 10b2fc <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,
10b2a1: 83 fe 03 cmp $0x3,%esi
10b2a4: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2a7: 83 ec 0c sub $0xc,%esp
10b2aa: 6a 00 push $0x0
10b2ac: ff 75 e0 pushl -0x20(%ebp)
10b2af: 0f b6 ca movzbl %dl,%ecx
10b2b2: 51 push %ecx
10b2b3: ff 37 pushl (%edi)
10b2b5: 83 c0 10 add $0x10,%eax
10b2b8: 50 push %eax
10b2b9: 88 55 d4 mov %dl,-0x2c(%ebp)
10b2bc: e8 c3 1a 00 00 call 10cd84 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b2c1: 83 c4 20 add $0x20,%esp
10b2c4: e8 79 2f 00 00 call 10e242 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b2c9: 8a 55 d4 mov -0x2c(%ebp),%dl
10b2cc: 84 d2 test %dl,%dl
10b2ce: 75 17 jne 10b2e7 <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b2d0: a1 3c 88 12 00 mov 0x12883c,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b2d5: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b2d9: 75 0c jne 10b2e7 <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b2db: 85 f6 test %esi,%esi
10b2dd: 74 1d je 10b2fc <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2df: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b2e0: 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 ||
10b2e2: 83 fe 01 cmp $0x1,%esi
10b2e5: 76 15 jbe 10b2fc <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2e7: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b2ea: a1 3c 88 12 00 mov 0x12883c,%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(
10b2ef: ff 70 34 pushl 0x34(%eax)
10b2f2: e8 11 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2f7: 89 c3 mov %eax,%ebx
10b2f9: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b2fc: 89 d8 mov %ebx,%eax
10b2fe: 8d 65 f4 lea -0xc(%ebp),%esp
10b301: 5b pop %ebx
10b302: 5e pop %esi
10b303: 5f pop %edi
10b304: c9 leave
10b305: c3 ret
0010ba44 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba44: 55 push %ebp
10ba45: 89 e5 mov %esp,%ebp
10ba47: 8b 55 08 mov 0x8(%ebp),%edx
10ba4a: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10ba4d: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10ba52: 85 d2 test %edx,%edx
10ba54: 74 0f je 10ba65 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10ba56: 83 3a 00 cmpl $0x0,(%edx)
10ba59: 74 0a je 10ba65 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10ba5b: 83 f9 01 cmp $0x1,%ecx
10ba5e: 77 05 ja 10ba65 <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10ba60: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10ba63: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10ba65: c9 leave
10ba66: c3 ret
0010c754 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c754: 55 push %ebp
10c755: 89 e5 mov %esp,%ebp
10c757: 57 push %edi
10c758: 56 push %esi
10c759: 53 push %ebx
10c75a: 83 ec 2c sub $0x2c,%esp
10c75d: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c760: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c767: 85 f6 test %esi,%esi
10c769: 0f 84 00 01 00 00 je 10c86f <pthread_setschedparam+0x11b>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c76f: 8d 45 e0 lea -0x20(%ebp),%eax
10c772: 50 push %eax
10c773: 8d 45 e4 lea -0x1c(%ebp),%eax
10c776: 50 push %eax
10c777: 56 push %esi
10c778: ff 75 0c pushl 0xc(%ebp)
10c77b: e8 e4 52 00 00 call 111a64 <_POSIX_Thread_Translate_sched_param>
10c780: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c783: 83 c4 10 add $0x10,%esp
10c786: 85 c0 test %eax,%eax
10c788: 0f 85 e1 00 00 00 jne 10c86f <pthread_setschedparam+0x11b>
10c78e: 53 push %ebx
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10c78f: 8d 45 dc lea -0x24(%ebp),%eax
10c792: 50 push %eax
10c793: ff 75 08 pushl 0x8(%ebp)
10c796: 68 78 95 12 00 push $0x129578
10c79b: e8 8c 1c 00 00 call 10e42c <_Objects_Get>
10c7a0: 89 c2 mov %eax,%edx
switch ( location ) {
10c7a2: 83 c4 10 add $0x10,%esp
10c7a5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c7a9: 0f 85 b9 00 00 00 jne 10c868 <pthread_setschedparam+0x114>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7af: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7b5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7bc: 75 18 jne 10c7d6 <pthread_setschedparam+0x82>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7be: 83 ec 0c sub $0xc,%esp
10c7c1: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c7c7: 50 push %eax
10c7c8: 89 55 d0 mov %edx,-0x30(%ebp)
10c7cb: e8 28 35 00 00 call 10fcf8 <_Watchdog_Remove>
10c7d0: 83 c4 10 add $0x10,%esp
10c7d3: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c7d6: 8b 45 0c mov 0xc(%ebp),%eax
10c7d9: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c7df: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c7e5: b9 07 00 00 00 mov $0x7,%ecx
10c7ea: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c7ec: 8b 45 e4 mov -0x1c(%ebp),%eax
10c7ef: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c7f2: 8b 45 e0 mov -0x20(%ebp),%eax
10c7f5: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c7fb: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c7ff: 78 60 js 10c861 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c801: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c805: 7e 08 jle 10c80f <pthread_setschedparam+0xbb>
10c807: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c80b: 75 54 jne 10c861 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c80d: eb 24 jmp 10c833 <pthread_setschedparam+0xdf>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c80f: a1 00 93 12 00 mov 0x129300,%eax
10c814: 89 42 78 mov %eax,0x78(%edx)
10c817: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax
10c81e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c824: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c827: 51 push %ecx
10c828: 6a 01 push $0x1
10c82a: 50 push %eax
10c82b: 52 push %edx
10c82c: e8 93 21 00 00 call 10e9c4 <_Thread_Change_priority>
10c831: eb 2b jmp 10c85e <pthread_setschedparam+0x10a>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c833: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c839: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c83f: 83 ec 0c sub $0xc,%esp
10c842: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c848: 53 push %ebx
10c849: 89 55 d0 mov %edx,-0x30(%ebp)
10c84c: e8 a7 34 00 00 call 10fcf8 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c851: 58 pop %eax
10c852: 5a pop %edx
10c853: 8b 55 d0 mov -0x30(%ebp),%edx
10c856: 52 push %edx
10c857: 6a 00 push $0x0
10c859: e8 e1 fd ff ff call 10c63f <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c85e: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c861: e8 a4 25 00 00 call 10ee0a <_Thread_Enable_dispatch>
return 0;
10c866: eb 07 jmp 10c86f <pthread_setschedparam+0x11b>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c868: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c86f: 8b 45 d4 mov -0x2c(%ebp),%eax
10c872: 8d 65 f4 lea -0xc(%ebp),%esp
10c875: 5b pop %ebx
10c876: 5e pop %esi
10c877: 5f pop %edi
10c878: c9 leave
10c879: c3 ret
0010a640 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a640: 55 push %ebp
10a641: 89 e5 mov %esp,%ebp
10a643: 53 push %ebx
10a644: 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() )
10a647: 83 3d 10 68 12 00 00 cmpl $0x0,0x126810
10a64e: 75 48 jne 10a698 <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a650: a1 14 68 12 00 mov 0x126814,%eax
10a655: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10a65b: 8b 15 c8 62 12 00 mov 0x1262c8,%edx
10a661: 42 inc %edx
10a662: 89 15 c8 62 12 00 mov %edx,0x1262c8
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a668: 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 &&
10a66a: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a671: 75 0a jne 10a67d <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));
10a673: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a67a: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a67d: e8 1c 25 00 00 call 10cb9e <_Thread_Enable_dispatch>
if ( cancel )
10a682: 84 db test %bl,%bl
10a684: 74 12 je 10a698 <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a686: 50 push %eax
10a687: 50 push %eax
10a688: 6a ff push $0xffffffff
10a68a: ff 35 14 68 12 00 pushl 0x126814
10a690: e8 7f 52 00 00 call 10f914 <_POSIX_Thread_Exit>
10a695: 83 c4 10 add $0x10,%esp
}
10a698: 8b 5d fc mov -0x4(%ebp),%ebx
10a69b: c9 leave
10a69c: c3 ret
0010af11 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af11: 55 push %ebp
10af12: 89 e5 mov %esp,%ebp
10af14: 57 push %edi
10af15: 56 push %esi
10af16: 53 push %ebx
10af17: 83 ec 58 sub $0x58,%esp
10af1a: 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);
10af1d: 68 78 72 12 00 push $0x127278
10af22: e8 bd 08 00 00 call 10b7e4 <pthread_mutex_lock>
10af27: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af2a: 83 c4 10 add $0x10,%esp
10af2d: 85 c0 test %eax,%eax
10af2f: 74 0e je 10af3f <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10af31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10af34: 53 push %ebx <== NOT EXECUTED
10af35: e8 06 ce ff ff call 107d40 <free> <== NOT EXECUTED
10af3a: e9 bf 01 00 00 jmp 10b0fe <rtems_aio_enqueue+0x1ed><== 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);
10af3f: e8 a0 10 00 00 call 10bfe4 <pthread_self>
10af44: 57 push %edi
10af45: 8d 55 c4 lea -0x3c(%ebp),%edx
10af48: 52 push %edx
10af49: 8d 55 e0 lea -0x20(%ebp),%edx
10af4c: 52 push %edx
10af4d: 50 push %eax
10af4e: e8 95 0c 00 00 call 10bbe8 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10af53: e8 8c 10 00 00 call 10bfe4 <pthread_self>
10af58: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10af5b: 8b 43 14 mov 0x14(%ebx),%eax
10af5e: 8b 55 c4 mov -0x3c(%ebp),%edx
10af61: 2b 50 14 sub 0x14(%eax),%edx
10af64: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10af67: 8b 55 e0 mov -0x20(%ebp),%edx
10af6a: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10af6d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10af74: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10af7b: 83 c4 10 add $0x10,%esp
10af7e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0
10af85: 0f 85 b7 00 00 00 jne 10b042 <rtems_aio_enqueue+0x131>
10af8b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc
10af92: 0f 8f aa 00 00 00 jg 10b042 <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);
10af98: 56 push %esi
10af99: 6a 01 push $0x1
10af9b: ff 30 pushl (%eax)
10af9d: 68 c0 72 12 00 push $0x1272c0
10afa2: e8 99 fb ff ff call 10ab40 <rtems_aio_search_fd>
10afa7: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10afa9: 83 c4 10 add $0x10,%esp
10afac: 83 78 18 01 cmpl $0x1,0x18(%eax)
10afb0: 8d 50 08 lea 0x8(%eax),%edx
10afb3: 8d 78 1c lea 0x1c(%eax),%edi
10afb6: 8d 40 20 lea 0x20(%eax),%eax
10afb9: 89 45 b0 mov %eax,-0x50(%ebp)
10afbc: 75 66 jne 10b024 <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);
10afbe: 51 push %ecx
10afbf: 51 push %ecx
10afc0: 53 push %ebx
10afc1: 52 push %edx
10afc2: e8 c1 1f 00 00 call 10cf88 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10afc7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10afce: 5b pop %ebx
10afcf: 58 pop %eax
10afd0: 6a 00 push $0x0
10afd2: 57 push %edi
10afd3: e8 ec 06 00 00 call 10b6c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10afd8: 5a pop %edx
10afd9: 59 pop %ecx
10afda: 6a 00 push $0x0
10afdc: ff 75 b0 pushl -0x50(%ebp)
10afdf: e8 a0 03 00 00 call 10b384 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10afe4: 56 push %esi
10afe5: 68 eb ab 10 00 push $0x10abeb
10afea: 68 80 72 12 00 push $0x127280
10afef: 8d 45 e4 lea -0x1c(%ebp),%eax
10aff2: 50 push %eax
10aff3: e8 bc 09 00 00 call 10b9b4 <pthread_create>
10aff8: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10affa: 83 c4 20 add $0x20,%esp
10affd: 85 c0 test %eax,%eax
10afff: 74 18 je 10b019 <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10b001: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b004: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10b009: e8 56 08 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10b00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b011: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b014: e9 e8 00 00 00 jmp 10b101 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b019: ff 05 dc 72 12 00 incl 0x1272dc
10b01f: e9 cd 00 00 00 jmp 10b0f1 <rtems_aio_enqueue+0x1e0>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b024: 83 ec 0c sub $0xc,%esp
10b027: 57 push %edi
10b028: 89 55 ac mov %edx,-0x54(%ebp)
10b02b: e8 b4 07 00 00 call 10b7e4 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b030: 5e pop %esi
10b031: 58 pop %eax
10b032: 53 push %ebx
10b033: 8b 55 ac mov -0x54(%ebp),%edx
10b036: 52 push %edx
10b037: e8 00 fe ff ff call 10ae3c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b03c: 5b pop %ebx
10b03d: ff 75 b0 pushl -0x50(%ebp)
10b040: eb 36 jmp 10b078 <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,
10b042: 51 push %ecx
10b043: 6a 00 push $0x0
10b045: ff 30 pushl (%eax)
10b047: 68 c0 72 12 00 push $0x1272c0
10b04c: e8 ef fa ff ff call 10ab40 <rtems_aio_search_fd>
10b051: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b053: 83 c4 10 add $0x10,%esp
10b056: 85 c0 test %eax,%eax
10b058: 74 2d je 10b087 <rtems_aio_enqueue+0x176><== ALWAYS TAKEN
{
pthread_mutex_lock (&r_chain->mutex);
10b05a: 8d 78 1c lea 0x1c(%eax),%edi <== NOT EXECUTED
10b05d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b060: 57 push %edi <== NOT EXECUTED
10b061: e8 7e 07 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
10b066: 58 pop %eax <== NOT EXECUTED
10b067: 5a pop %edx <== NOT EXECUTED
10b068: 53 push %ebx <== NOT EXECUTED
10b069: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
10b06c: 50 push %eax <== NOT EXECUTED
10b06d: e8 ca fd ff ff call 10ae3c <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
10b072: 83 c6 20 add $0x20,%esi <== NOT EXECUTED
10b075: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10b078: e8 a3 03 00 00 call 10b420 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b07d: 89 3c 24 mov %edi,(%esp)
10b080: e8 df 07 00 00 call 10b864 <pthread_mutex_unlock>
10b085: eb 67 jmp 10b0ee <rtems_aio_enqueue+0x1dd>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10b087: 56 push %esi
10b088: 6a 01 push $0x1
10b08a: 8b 43 14 mov 0x14(%ebx),%eax
10b08d: ff 30 pushl (%eax)
10b08f: 68 cc 72 12 00 push $0x1272cc
10b094: e8 a7 fa ff ff call 10ab40 <rtems_aio_search_fd>
10b099: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b09b: 83 c4 10 add $0x10,%esp
10b09e: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b0a2: 8d 40 08 lea 0x8(%eax),%eax
10b0a5: 75 3e jne 10b0e5 <rtems_aio_enqueue+0x1d4>
10b0a7: 51 push %ecx
10b0a8: 51 push %ecx
10b0a9: 53 push %ebx
10b0aa: 50 push %eax
10b0ab: e8 d8 1e 00 00 call 10cf88 <_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;
10b0b0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b0b7: 58 pop %eax
10b0b8: 5a pop %edx
10b0b9: 6a 00 push $0x0
10b0bb: 8d 46 1c lea 0x1c(%esi),%eax
10b0be: 50 push %eax
10b0bf: e8 00 06 00 00 call 10b6c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b0c4: 5b pop %ebx
10b0c5: 5f pop %edi
10b0c6: 6a 00 push $0x0
10b0c8: 83 c6 20 add $0x20,%esi
10b0cb: 56 push %esi
10b0cc: e8 b3 02 00 00 call 10b384 <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
10b0d1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp)
10b0d8: e8 43 03 00 00 call 10b420 <pthread_cond_signal>
++aio_request_queue.idle_threads;
10b0dd: ff 05 e0 72 12 00 incl 0x1272e0
10b0e3: eb 09 jmp 10b0ee <rtems_aio_enqueue+0x1dd>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0e5: 51 push %ecx
10b0e6: 51 push %ecx
10b0e7: 53 push %ebx
10b0e8: 50 push %eax
10b0e9: e8 4e fd ff ff call 10ae3c <rtems_aio_insert_prio>
10b0ee: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b0f1: 83 ec 0c sub $0xc,%esp
10b0f4: 68 78 72 12 00 push $0x127278
10b0f9: e8 66 07 00 00 call 10b864 <pthread_mutex_unlock>
return 0;
10b0fe: 83 c4 10 add $0x10,%esp
}
10b101: 8b 45 b4 mov -0x4c(%ebp),%eax
10b104: 8d 65 f4 lea -0xc(%ebp),%esp
10b107: 5b pop %ebx
10b108: 5e pop %esi
10b109: 5f pop %edi
10b10a: c9 leave
10b10b: c3 ret
0010abeb <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10abeb: 55 push %ebp <== NOT EXECUTED
10abec: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10abee: 57 push %edi <== NOT EXECUTED
10abef: 56 push %esi <== NOT EXECUTED
10abf0: 53 push %ebx <== NOT EXECUTED
10abf1: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED
rtems_aio_request_chain *r_chain = arg;
10abf4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
10abf7: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED
10abfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10abfd: 57 push %edi <== NOT EXECUTED
10abfe: e8 e1 0b 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
10ac03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac06: 85 c0 test %eax,%eax <== NOT EXECUTED
10ac08: 0f 85 24 02 00 00 jne 10ae32 <rtems_aio_handle+0x247><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ac0e: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10ac11: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
10ac14: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10ac16: 0f 84 cc 00 00 00 je 10ace8 <rtems_aio_handle+0xfd> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10ac1c: e8 c3 13 00 00 call 10bfe4 <pthread_self> <== NOT EXECUTED
10ac21: 52 push %edx <== NOT EXECUTED
10ac22: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED
10ac25: 52 push %edx <== NOT EXECUTED
10ac26: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED
10ac29: 51 push %ecx <== NOT EXECUTED
10ac2a: 50 push %eax <== NOT EXECUTED
10ac2b: e8 b8 0f 00 00 call 10bbe8 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
10ac30: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED
10ac33: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10ac36: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED
10ac39: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED
10ac3c: e8 a3 13 00 00 call 10bfe4 <pthread_self> <== NOT EXECUTED
10ac41: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ac44: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED
10ac47: 51 push %ecx <== NOT EXECUTED
10ac48: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED
10ac4b: 52 push %edx <== NOT EXECUTED
10ac4c: 50 push %eax <== NOT EXECUTED
10ac4d: e8 a2 13 00 00 call 10bff4 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ac52: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ac55: e8 f2 22 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10ac5a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ac5d: e8 02 0c 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
10ac62: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10ac65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac68: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED
10ac6b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
10ac6e: 74 20 je 10ac90 <rtems_aio_handle+0xa5> <== NOT EXECUTED
10ac70: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
10ac73: 74 36 je 10acab <rtems_aio_handle+0xc0> <== NOT EXECUTED
10ac75: 4a dec %edx <== NOT EXECUTED
10ac76: 75 45 jne 10acbd <rtems_aio_handle+0xd2> <== NOT EXECUTED
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
10ac78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac7b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac7e: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac81: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac84: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac87: ff 30 pushl (%eax) <== NOT EXECUTED
10ac89: e8 7e 94 00 00 call 11410c <pread> <== NOT EXECUTED
10ac8e: eb 16 jmp 10aca6 <rtems_aio_handle+0xbb> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
10ac90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac93: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac96: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac99: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac9c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac9f: ff 30 pushl (%eax) <== NOT EXECUTED
10aca1: e8 1e 95 00 00 call 1141c4 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10aca6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10aca9: eb 0d jmp 10acb8 <rtems_aio_handle+0xcd> <== NOT EXECUTED
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
10acab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10acae: ff 30 pushl (%eax) <== NOT EXECUTED
10acb0: e8 07 5d 00 00 call 1109bc <fsync> <== NOT EXECUTED
break;
10acb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10acb8: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10acbb: 75 19 jne 10acd6 <rtems_aio_handle+0xeb> <== NOT EXECUTED
req->aiocbp->return_value = -1;
10acbd: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10acc0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10acc7: e8 04 8a 00 00 call 1136d0 <__errno> <== NOT EXECUTED
10accc: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10acce: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10acd1: e9 21 ff ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10acd6: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED
10acd9: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED
req->aiocbp->error_code = 0;
10acdc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED
10ace3: e9 0f ff ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
10ace8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aceb: 57 push %edi <== NOT EXECUTED
10acec: e8 73 0b 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
10acf1: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10acf8: e8 e7 0a 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
10acfd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad00: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED
10ad03: 0f 85 ee fe ff ff jne 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ad09: 56 push %esi <== NOT EXECUTED
10ad0a: 56 push %esi <== NOT EXECUTED
10ad0b: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad0e: 50 push %eax <== NOT EXECUTED
10ad0f: 6a 01 push $0x1 <== NOT EXECUTED
10ad11: e8 5e 05 00 00 call 10b274 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad16: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad1a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
10ad21: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED
10ad24: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad27: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED
10ad2a: 52 push %edx <== NOT EXECUTED
10ad2b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ad30: 56 push %esi <== NOT EXECUTED
10ad31: e8 5a 07 00 00 call 10b490 <pthread_cond_timedwait><== NOT EXECUTED
&aio_request_queue.mutex, &timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad39: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10ad3c: 0f 85 b5 fe ff ff jne 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
10ad42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad45: 53 push %ebx <== NOT EXECUTED
10ad46: e8 01 22 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10ad4b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ad4e: e8 71 08 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
10ad53: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ad56: e8 75 05 00 00 call 10b2d0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10ad5b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10ad5e: e8 dd cf ff ff call 107d40 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad66: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10ad6d: 72 12 00
10ad70: 0f 85 a7 00 00 00 jne 10ae1d <rtems_aio_handle+0x232><== NOT EXECUTED
++aio_request_queue.idle_threads;
10ad76: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
10ad7c: 53 push %ebx <== NOT EXECUTED
10ad7d: 53 push %ebx <== NOT EXECUTED
10ad7e: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED
10ad81: 51 push %ecx <== NOT EXECUTED
10ad82: 6a 01 push $0x1 <== NOT EXECUTED
10ad84: e8 eb 04 00 00 call 10b274 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad89: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad8d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10ad94: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad97: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad9a: 50 push %eax <== NOT EXECUTED
10ad9b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ada0: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED
10ada5: e8 e6 06 00 00 call 10b490 <pthread_cond_timedwait><== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10adaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10adad: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10adb0: 75 12 jne 10adc4 <rtems_aio_handle+0x1d9><== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10adb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10adb5: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10adba: e8 a5 0a 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
10adbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10adc2: eb 6e jmp 10ae32 <rtems_aio_handle+0x247><== NOT EXECUTED
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
10adc4: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10adca: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED
10add0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10add3: 56 push %esi <== NOT EXECUTED
10add4: e8 73 21 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10add9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10addc: 6a 01 push $0x1 <== NOT EXECUTED
10adde: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
10ade1: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10ade6: e8 55 fd ff ff call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10adeb: 89 c3 mov %eax,%ebx <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
10aded: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
10adf4: 5a pop %edx <== NOT EXECUTED
10adf5: 59 pop %ecx <== NOT EXECUTED
10adf6: 6a 00 push $0x0 <== NOT EXECUTED
10adf8: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED
10adfb: 50 push %eax <== NOT EXECUTED
10adfc: e8 c3 08 00 00 call 10b6c4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
10ae01: 5f pop %edi <== NOT EXECUTED
10ae02: 58 pop %eax <== NOT EXECUTED
10ae03: 6a 00 push $0x0 <== NOT EXECUTED
10ae05: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED
10ae08: 50 push %eax <== NOT EXECUTED
10ae09: e8 76 05 00 00 call 10b384 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
10ae0e: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED
10ae11: 83 c6 08 add $0x8,%esi <== NOT EXECUTED
10ae14: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED
10ae19: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10ae1b: eb 0d jmp 10ae2a <rtems_aio_handle+0x23f><== NOT EXECUTED
}
else
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
10ae1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ae20: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ae25: e8 3a 0a 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
10ae2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ae2d: e9 c5 fd ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae32: 31 c0 xor %eax,%eax <== NOT EXECUTED
10ae34: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ae37: 5b pop %ebx <== NOT EXECUTED
10ae38: 5e pop %esi <== NOT EXECUTED
10ae39: 5f pop %edi <== NOT EXECUTED
10ae3a: c9 leave <== NOT EXECUTED
10ae3b: c3 ret <== NOT EXECUTED
0010aa44 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aa44: 55 push %ebp
10aa45: 89 e5 mov %esp,%ebp
10aa47: 53 push %ebx
10aa48: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aa4b: 68 80 72 12 00 push $0x127280
10aa50: e8 13 0f 00 00 call 10b968 <pthread_attr_init>
10aa55: 89 c3 mov %eax,%ebx
if (result != 0)
10aa57: 83 c4 10 add $0x10,%esp
10aa5a: 85 c0 test %eax,%eax
10aa5c: 0f 85 d7 00 00 00 jne 10ab39 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aa62: 51 push %ecx
10aa63: 51 push %ecx
10aa64: 6a 00 push $0x0
10aa66: 68 80 72 12 00 push $0x127280
10aa6b: e8 20 0f 00 00 call 10b990 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aa70: 83 c4 10 add $0x10,%esp
10aa73: 85 c0 test %eax,%eax
10aa75: 74 10 je 10aa87 <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa7a: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aa7f: e8 c4 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aa84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aa87: 52 push %edx
10aa88: 52 push %edx
10aa89: 6a 00 push $0x0
10aa8b: 68 78 72 12 00 push $0x127278
10aa90: e8 2f 0c 00 00 call 10b6c4 <pthread_mutex_init>
if (result != 0)
10aa95: 83 c4 10 add $0x10,%esp
10aa98: 85 c0 test %eax,%eax
10aa9a: 74 10 je 10aaac <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa9f: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aaa4: e8 9f 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aaa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10aaac: 50 push %eax
10aaad: 50 push %eax
10aaae: 6a 00 push $0x0
10aab0: 68 7c 72 12 00 push $0x12727c
10aab5: e8 ca 08 00 00 call 10b384 <pthread_cond_init>
10aaba: 89 c3 mov %eax,%ebx
if (result != 0) {
10aabc: 83 c4 10 add $0x10,%esp
10aabf: 85 c0 test %eax,%eax
10aac1: 74 1c je 10aadf <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10aac3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aac6: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10aacb: e8 f4 0a 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10aad0: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED
10aad7: e8 6c 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aadc: 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;
10aadf: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0
10aae6: 72 12 00
head->previous = NULL;
10aae9: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4
10aaf0: 00 00 00
tail->previous = head;
10aaf3: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8
10aafa: 72 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10aafd: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc
10ab04: 72 12 00
head->previous = NULL;
10ab07: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0
10ab0e: 00 00 00
tail->previous = head;
10ab11: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4
10ab18: 72 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;
10ab1b: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc
10ab22: 00 00 00
aio_request_queue.idle_threads = 0;
10ab25: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0
10ab2c: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab2f: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8
10ab36: b0 00 00
return result;
}
10ab39: 89 d8 mov %ebx,%eax
10ab3b: 8b 5d fc mov -0x4(%ebp),%ebx
10ab3e: c9 leave
10ab3f: c3 ret
0010ae3c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae3c: 55 push %ebp
10ae3d: 89 e5 mov %esp,%ebp
10ae3f: 56 push %esi
10ae40: 53 push %ebx
10ae41: 8b 4d 08 mov 0x8(%ebp),%ecx
10ae44: 8b 55 0c mov 0xc(%ebp),%edx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae47: 8b 01 mov (%ecx),%eax
10ae49: 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)) {
10ae4c: 39 d8 cmp %ebx,%eax
10ae4e: 74 27 je 10ae77 <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;
10ae50: 8b 48 14 mov 0x14(%eax),%ecx
10ae53: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10ae56: 8b 72 14 mov 0x14(%edx),%esi
10ae59: 8b 76 14 mov 0x14(%esi),%esi
10ae5c: eb 08 jmp 10ae66 <rtems_aio_insert_prio+0x2a>
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae5e: 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;
10ae60: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10ae63: 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 &&
10ae66: 39 ce cmp %ecx,%esi
10ae68: 7e 04 jle 10ae6e <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10ae6a: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10ae6c: 75 f0 jne 10ae5e <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 );
10ae6e: 89 55 0c mov %edx,0xc(%ebp)
10ae71: 8b 40 04 mov 0x4(%eax),%eax
10ae74: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10ae77: 5b pop %ebx
10ae78: 5e pop %esi
10ae79: c9 leave
10ae7a: e9 09 21 00 00 jmp 10cf88 <_Chain_Insert>
0010ae7f <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10ae7f: 55 push %ebp <== NOT EXECUTED
10ae80: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10ae82: 56 push %esi <== NOT EXECUTED
10ae83: 53 push %ebx <== NOT EXECUTED
10ae84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae87: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10ae8a: 8d 70 0c lea 0xc(%eax),%esi <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10ae8d: eb 25 jmp 10aeb4 <rtems_aio_remove_fd+0x35><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ae8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ae92: 53 push %ebx <== NOT EXECUTED
10ae93: e8 b4 20 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
10ae98: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED
10ae9b: c7 42 30 8c 00 00 00 movl $0x8c,0x30(%edx) <== NOT EXECUTED
req->aiocbp->return_value = -1;
10aea2: c7 42 34 ff ff ff ff movl $0xffffffff,0x34(%edx) <== NOT EXECUTED
free (req);
10aea9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aeac: e8 8f ce ff ff call 107d40 <free> <== NOT EXECUTED
10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10aeb4: 39 f3 cmp %esi,%ebx <== NOT EXECUTED
10aeb6: 75 d7 jne 10ae8f <rtems_aio_remove_fd+0x10><== NOT EXECUTED
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10aeb8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10aebb: 5b pop %ebx <== NOT EXECUTED
10aebc: 5e pop %esi <== NOT EXECUTED
10aebd: c9 leave <== NOT EXECUTED
10aebe: c3 ret <== NOT EXECUTED
0010aebf <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)
{
10aebf: 55 push %ebp <== NOT EXECUTED
10aec0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10aec2: 53 push %ebx <== NOT EXECUTED
10aec3: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
10aec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10aec9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aecc: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
10aece: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aed1: eb 02 jmp 10aed5 <rtems_aio_remove_req+0x16><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aed3: 8b 1b mov (%ebx),%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) {
10aed5: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10aed7: 74 2e je 10af07 <rtems_aio_remove_req+0x48><== NOT EXECUTED
10aed9: 39 53 14 cmp %edx,0x14(%ebx) <== NOT EXECUTED
10aedc: 75 f5 jne 10aed3 <rtems_aio_remove_req+0x14><== NOT EXECUTED
10aede: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aee1: 53 push %ebx <== NOT EXECUTED
10aee2: e8 65 20 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10aee7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
10aeea: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) <== NOT EXECUTED
current->aiocbp->return_value = -1;
10aef1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) <== NOT EXECUTED
free (current);
10aef8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aefb: e8 40 ce ff ff call 107d40 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
10af00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10af03: 31 c0 xor %eax,%eax <== NOT EXECUTED
10af05: eb 05 jmp 10af0c <rtems_aio_remove_req+0x4d><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10af07: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10af0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10af0f: c9 leave <== NOT EXECUTED
10af10: c3 ret <== NOT EXECUTED
0010ab40 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10ab40: 55 push %ebp
10ab41: 89 e5 mov %esp,%ebp
10ab43: 56 push %esi
10ab44: 53 push %ebx
10ab45: 8b 5d 10 mov 0x10(%ebp),%ebx
10ab48: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
10ab4b: 50 push %eax
10ab4c: 50 push %eax
10ab4d: ff 75 0c pushl 0xc(%ebp)
10ab50: ff 75 08 pushl 0x8(%ebp)
10ab53: e8 8c 04 00 00 call 10afe4 <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
10ab58: 83 c4 10 add $0x10,%esp
10ab5b: 84 c0 test %al,%al
10ab5d: 74 11 je 10ab70 <rtems_chain_append_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ab5f: 89 75 0c mov %esi,0xc(%ebp)
10ab62: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ab65: 8d 65 f8 lea -0x8(%ebp),%esp
10ab68: 5b pop %ebx
10ab69: 5e pop %esi
10ab6a: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10ab6b: e9 cc f6 ff ff jmp 10a23c <rtems_event_send>
}
return sc;
}
10ab70: 31 c0 xor %eax,%eax
10ab72: 8d 65 f8 lea -0x8(%ebp),%esp
10ab75: 5b pop %ebx
10ab76: 5e pop %esi
10ab77: c9 leave
10ab78: c3 ret <== NOT EXECUTED
0010abb8 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10abb8: 55 push %ebp
10abb9: 89 e5 mov %esp,%ebp
10abbb: 57 push %edi
10abbc: 56 push %esi
10abbd: 53 push %ebx
10abbe: 83 ec 1c sub $0x1c,%esp
10abc1: 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(
10abc4: 8d 75 e4 lea -0x1c(%ebp),%esi
10abc7: eb 13 jmp 10abdc <rtems_chain_get_with_wait+0x24>
10abc9: 56 push %esi
10abca: ff 75 10 pushl 0x10(%ebp)
10abcd: 6a 00 push $0x0
10abcf: 57 push %edi
10abd0: e8 07 f5 ff ff call 10a0dc <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10abd5: 83 c4 10 add $0x10,%esp
10abd8: 85 c0 test %eax,%eax
10abda: 75 16 jne 10abf2 <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 );
10abdc: 83 ec 0c sub $0xc,%esp
10abdf: ff 75 08 pushl 0x8(%ebp)
10abe2: e8 9d 04 00 00 call 10b084 <_Chain_Get>
10abe7: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10abe9: 83 c4 10 add $0x10,%esp
10abec: 85 c0 test %eax,%eax
10abee: 74 d9 je 10abc9 <rtems_chain_get_with_wait+0x11>
10abf0: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10abf2: 8b 55 14 mov 0x14(%ebp),%edx
10abf5: 89 1a mov %ebx,(%edx)
return sc;
}
10abf7: 8d 65 f4 lea -0xc(%ebp),%esp
10abfa: 5b pop %ebx
10abfb: 5e pop %esi
10abfc: 5f pop %edi
10abfd: c9 leave
10abfe: c3 ret
0010ac00 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10ac00: 55 push %ebp
10ac01: 89 e5 mov %esp,%ebp
10ac03: 56 push %esi
10ac04: 53 push %ebx
10ac05: 8b 5d 10 mov 0x10(%ebp),%ebx
10ac08: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
10ac0b: 50 push %eax
10ac0c: 50 push %eax
10ac0d: ff 75 0c pushl 0xc(%ebp)
10ac10: ff 75 08 pushl 0x8(%ebp)
10ac13: e8 b0 04 00 00 call 10b0c8 <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
10ac18: 83 c4 10 add $0x10,%esp
10ac1b: 84 c0 test %al,%al
10ac1d: 74 11 je 10ac30 <rtems_chain_prepend_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ac1f: 89 75 0c mov %esi,0xc(%ebp)
10ac22: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ac25: 8d 65 f8 lea -0x8(%ebp),%esp
10ac28: 5b pop %ebx
10ac29: 5e pop %esi
10ac2a: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10ac2b: e9 0c f6 ff ff jmp 10a23c <rtems_event_send>
}
return sc;
}
10ac30: 31 c0 xor %eax,%eax
10ac32: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ac35: 5b pop %ebx <== NOT EXECUTED
10ac36: 5e pop %esi <== NOT EXECUTED
10ac37: c9 leave <== NOT EXECUTED
10ac38: c3 ret <== NOT EXECUTED
0010b724 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
10b724: 55 push %ebp
10b725: 89 e5 mov %esp,%ebp
10b727: 57 push %edi
10b728: 56 push %esi
10b729: 53 push %ebx
10b72a: 83 ec 0c sub $0xc,%esp
10b72d: 8b 5d 08 mov 0x8(%ebp),%ebx
10b730: 8b 75 0c mov 0xc(%ebp),%esi
10b733: 8b 45 10 mov 0x10(%ebp),%eax
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10b736: 8b 15 9c 8d 12 00 mov 0x128d9c,%edx
if ( rtems_interrupt_is_in_progress() )
10b73c: 83 3d 40 89 12 00 00 cmpl $0x0,0x128940
10b743: 0f 85 cc 00 00 00 jne 10b815 <rtems_io_register_driver+0xf1><== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10b749: 85 c0 test %eax,%eax
10b74b: 0f 84 cb 00 00 00 je 10b81c <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10b751: 89 10 mov %edx,(%eax)
if ( driver_table == NULL )
10b753: 85 f6 test %esi,%esi
10b755: 0f 84 c1 00 00 00 je 10b81c <rtems_io_register_driver+0xf8>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b75b: 83 3e 00 cmpl $0x0,(%esi)
10b75e: 0f 85 cc 00 00 00 jne 10b830 <rtems_io_register_driver+0x10c>
10b764: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b768: 0f 85 c2 00 00 00 jne 10b830 <rtems_io_register_driver+0x10c>
10b76e: e9 a9 00 00 00 jmp 10b81c <rtems_io_register_driver+0xf8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b773: 8b 15 f8 83 12 00 mov 0x1283f8,%edx
10b779: 42 inc %edx
10b77a: 89 15 f8 83 12 00 mov %edx,0x1283f8
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10b780: 85 db test %ebx,%ebx
10b782: 75 32 jne 10b7b6 <rtems_io_register_driver+0x92>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
10b784: 8b 0d 9c 8d 12 00 mov 0x128d9c,%ecx
10b78a: 8b 15 a0 8d 12 00 mov 0x128da0,%edx
10b790: eb 15 jmp 10b7a7 <rtems_io_register_driver+0x83>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b792: 83 3a 00 cmpl $0x0,(%edx)
10b795: 0f 85 9f 00 00 00 jne 10b83a <rtems_io_register_driver+0x116>
10b79b: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b79f: 0f 85 95 00 00 00 jne 10b83a <rtems_io_register_driver+0x116>
10b7a5: eb 04 jmp 10b7ab <rtems_io_register_driver+0x87>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10b7a7: 39 cb cmp %ecx,%ebx
10b7a9: 72 e7 jb 10b792 <rtems_io_register_driver+0x6e>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10b7ab: 89 18 mov %ebx,(%eax)
if ( m != n )
10b7ad: 39 cb cmp %ecx,%ebx
10b7af: 75 30 jne 10b7e1 <rtems_io_register_driver+0xbd>
10b7b1: e9 8d 00 00 00 jmp 10b843 <rtems_io_register_driver+0x11f>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
10b7b6: 6b d3 18 imul $0x18,%ebx,%edx
10b7b9: 03 15 a0 8d 12 00 add 0x128da0,%edx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b7bf: 31 c9 xor %ecx,%ecx
10b7c1: 83 3a 00 cmpl $0x0,(%edx)
10b7c4: 75 09 jne 10b7cf <rtems_io_register_driver+0xab>
10b7c6: 31 c9 xor %ecx,%ecx
10b7c8: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b7cc: 0f 94 c1 sete %cl
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
10b7cf: 85 c9 test %ecx,%ecx
10b7d1: 75 0c jne 10b7df <rtems_io_register_driver+0xbb>
_Thread_Enable_dispatch();
10b7d3: e8 2a 1a 00 00 call 10d202 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b7d8: b8 0c 00 00 00 mov $0xc,%eax
10b7dd: eb 49 jmp 10b828 <rtems_io_register_driver+0x104>
}
*registered_major = major;
10b7df: 89 18 mov %ebx,(%eax)
}
_IO_Driver_address_table [major] = *driver_table;
10b7e1: 6b c3 18 imul $0x18,%ebx,%eax
10b7e4: 03 05 a0 8d 12 00 add 0x128da0,%eax
10b7ea: b9 06 00 00 00 mov $0x6,%ecx
10b7ef: 89 c7 mov %eax,%edi
10b7f1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10b7f3: e8 0a 1a 00 00 call 10d202 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10b7f8: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10b7ff: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10b806: 89 5d 08 mov %ebx,0x8(%ebp)
}
10b809: 83 c4 0c add $0xc,%esp
10b80c: 5b pop %ebx
10b80d: 5e pop %esi
10b80e: 5f pop %edi
10b80f: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10b810: e9 67 71 00 00 jmp 11297c <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10b815: b8 12 00 00 00 mov $0x12,%eax
10b81a: eb 0c jmp 10b828 <rtems_io_register_driver+0x104>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10b81c: b8 09 00 00 00 mov $0x9,%eax
10b821: eb 05 jmp 10b828 <rtems_io_register_driver+0x104>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10b823: b8 0a 00 00 00 mov $0xa,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10b828: 83 c4 0c add $0xc,%esp
10b82b: 5b pop %ebx
10b82c: 5e pop %esi
10b82d: 5f pop %edi
10b82e: c9 leave
10b82f: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10b830: 39 d3 cmp %edx,%ebx
10b832: 0f 82 3b ff ff ff jb 10b773 <rtems_io_register_driver+0x4f>
10b838: eb e9 jmp 10b823 <rtems_io_register_driver+0xff>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10b83a: 43 inc %ebx
10b83b: 83 c2 18 add $0x18,%edx
10b83e: e9 64 ff ff ff jmp 10b7a7 <rtems_io_register_driver+0x83>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10b843: e8 ba 19 00 00 call 10d202 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10b848: b8 05 00 00 00 mov $0x5,%eax
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
10b84d: eb d9 jmp 10b828 <rtems_io_register_driver+0x104>
0010c750 <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)
{
10c750: 55 push %ebp
10c751: 89 e5 mov %esp,%ebp
10c753: 57 push %edi
10c754: 56 push %esi
10c755: 53 push %ebx
10c756: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c759: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c75d: 74 3d je 10c79c <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10c75f: 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 ];
10c764: 8b 04 9d 3c 01 13 00 mov 0x13013c(,%ebx,4),%eax
10c76b: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c76e: be 01 00 00 00 mov $0x1,%esi
10c773: 85 ff test %edi,%edi
10c775: 75 17 jne 10c78e <rtems_iterate_over_all_threads+0x3e>
10c777: eb 1d jmp 10c796 <rtems_iterate_over_all_threads+0x46>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c779: 8b 47 1c mov 0x1c(%edi),%eax
10c77c: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c77f: 85 c0 test %eax,%eax
10c781: 74 0a je 10c78d <rtems_iterate_over_all_threads+0x3d><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c783: 83 ec 0c sub $0xc,%esp
10c786: 50 push %eax
10c787: ff 55 08 call *0x8(%ebp)
10c78a: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c78d: 46 inc %esi
10c78e: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c792: 39 c6 cmp %eax,%esi
10c794: 76 e3 jbe 10c779 <rtems_iterate_over_all_threads+0x29>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c796: 43 inc %ebx
10c797: 83 fb 04 cmp $0x4,%ebx
10c79a: 75 c8 jne 10c764 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c79c: 8d 65 f4 lea -0xc(%ebp),%esp
10c79f: 5b pop %ebx
10c7a0: 5e pop %esi
10c7a1: 5f pop %edi
10c7a2: c9 leave
10c7a3: c3 ret
001147e8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1147e8: 55 push %ebp
1147e9: 89 e5 mov %esp,%ebp
1147eb: 57 push %edi
1147ec: 56 push %esi
1147ed: 53 push %ebx
1147ee: 83 ec 1c sub $0x1c,%esp
1147f1: 8b 75 0c mov 0xc(%ebp),%esi
1147f4: 8b 55 10 mov 0x10(%ebp),%edx
1147f7: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1147fa: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1147ff: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
114803: 0f 84 ce 00 00 00 je 1148d7 <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
114809: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
11480b: 85 f6 test %esi,%esi
11480d: 0f 84 c4 00 00 00 je 1148d7 <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
114813: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
114817: 0f 84 ba 00 00 00 je 1148d7 <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11481d: 85 ff test %edi,%edi
11481f: 0f 84 ad 00 00 00 je 1148d2 <rtems_partition_create+0xea>
114825: 85 d2 test %edx,%edx
114827: 0f 84 a5 00 00 00 je 1148d2 <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
11482d: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11482f: 39 fa cmp %edi,%edx
114831: 0f 82 a0 00 00 00 jb 1148d7 <rtems_partition_create+0xef>
114837: f7 c7 03 00 00 00 test $0x3,%edi
11483d: 0f 85 94 00 00 00 jne 1148d7 <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;
114843: 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 ) )
114845: f7 c6 03 00 00 00 test $0x3,%esi
11484b: 0f 85 86 00 00 00 jne 1148d7 <rtems_partition_create+0xef>
114851: a1 d4 d6 13 00 mov 0x13d6d4,%eax
114856: 40 inc %eax
114857: a3 d4 d6 13 00 mov %eax,0x13d6d4
* 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 );
11485c: 83 ec 0c sub $0xc,%esp
11485f: 68 64 d5 13 00 push $0x13d564
114864: 89 55 e4 mov %edx,-0x1c(%ebp)
114867: e8 24 3e 00 00 call 118690 <_Objects_Allocate>
11486c: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
11486e: 83 c4 10 add $0x10,%esp
114871: 85 c0 test %eax,%eax
114873: 8b 55 e4 mov -0x1c(%ebp),%edx
114876: 75 0c jne 114884 <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
114878: e8 5d 4c 00 00 call 1194da <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
11487d: b8 05 00 00 00 mov $0x5,%eax
114882: eb 53 jmp 1148d7 <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
114884: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
114887: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
11488a: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
11488d: 8b 45 18 mov 0x18(%ebp),%eax
114890: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
114893: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
11489a: 57 push %edi
11489b: 89 d0 mov %edx,%eax
11489d: 31 d2 xor %edx,%edx
11489f: f7 f7 div %edi
1148a1: 50 push %eax
1148a2: 56 push %esi
1148a3: 8d 43 24 lea 0x24(%ebx),%eax
1148a6: 50 push %eax
1148a7: e8 84 2a 00 00 call 117330 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1148ac: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1148af: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1148b2: 8b 15 80 d5 13 00 mov 0x13d580,%edx
1148b8: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1148bb: 8b 55 08 mov 0x8(%ebp),%edx
1148be: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1148c1: 8b 55 1c mov 0x1c(%ebp),%edx
1148c4: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1148c6: e8 0f 4c 00 00 call 1194da <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1148cb: 83 c4 10 add $0x10,%esp
1148ce: 31 c0 xor %eax,%eax
1148d0: eb 05 jmp 1148d7 <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;
1148d2: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1148d7: 8d 65 f4 lea -0xc(%ebp),%esp
1148da: 5b pop %ebx
1148db: 5e pop %esi
1148dc: 5f pop %edi
1148dd: c9 leave
1148de: c3 ret
0010b03d <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b03d: 55 push %ebp
10b03e: 89 e5 mov %esp,%ebp
10b040: 57 push %edi
10b041: 56 push %esi
10b042: 53 push %ebx
10b043: 83 ec 30 sub $0x30,%esp
10b046: 8b 75 08 mov 0x8(%ebp),%esi
10b049: 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 );
10b04c: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b04f: 50 push %eax
10b050: 56 push %esi
10b051: 68 14 73 12 00 push $0x127314
10b056: e8 49 1e 00 00 call 10cea4 <_Objects_Get>
10b05b: 89 c7 mov %eax,%edi
switch ( location ) {
10b05d: 83 c4 10 add $0x10,%esp
10b060: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b064: 0f 85 3b 01 00 00 jne 10b1a5 <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b06a: a1 50 79 12 00 mov 0x127950,%eax
10b06f: 39 47 40 cmp %eax,0x40(%edi)
10b072: 74 0f je 10b083 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b074: e8 09 28 00 00 call 10d882 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b079: be 17 00 00 00 mov $0x17,%esi
10b07e: e9 27 01 00 00 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b083: 85 db test %ebx,%ebx
10b085: 75 1b jne 10b0a2 <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b087: 8b 47 38 mov 0x38(%edi),%eax
10b08a: 31 f6 xor %esi,%esi
10b08c: 83 f8 04 cmp $0x4,%eax
10b08f: 77 07 ja 10b098 <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b091: 8b 34 85 a8 0d 12 00 mov 0x120da8(,%eax,4),%esi
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b098: e8 e5 27 00 00 call 10d882 <_Thread_Enable_dispatch>
return( return_value );
10b09d: e9 08 01 00 00 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b0a2: 9c pushf
10b0a3: fa cli
10b0a4: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b0a7: 8b 47 38 mov 0x38(%edi),%eax
10b0aa: 85 c0 test %eax,%eax
10b0ac: 75 4c jne 10b0fa <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0ae: ff 75 d4 pushl -0x2c(%ebp)
10b0b1: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0b2: 83 ec 0c sub $0xc,%esp
10b0b5: 57 push %edi
10b0b6: e8 3f fe ff ff call 10aefa <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b0bb: 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;
10b0c2: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b0c9: c7 47 2c b4 b3 10 00 movl $0x10b3b4,0x2c(%edi)
the_watchdog->id = id;
10b0d0: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b0d3: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b0da: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b0dd: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b0e0: 58 pop %eax
10b0e1: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b0e2: 83 c7 10 add $0x10,%edi
10b0e5: 57 push %edi
10b0e6: 68 e8 74 12 00 push $0x1274e8
10b0eb: e8 38 35 00 00 call 10e628 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b0f0: e8 8d 27 00 00 call 10d882 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b0f5: 83 c4 10 add $0x10,%esp
10b0f8: eb 65 jmp 10b15f <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b0fa: 83 f8 02 cmp $0x2,%eax
10b0fd: 75 64 jne 10b163 <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b0ff: 83 ec 0c sub $0xc,%esp
10b102: 57 push %edi
10b103: e8 5a fe ff ff call 10af62 <_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;
10b108: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b10f: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b112: ff 75 d4 pushl -0x2c(%ebp)
10b115: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b116: a1 50 79 12 00 mov 0x127950,%eax
10b11b: 8b 57 08 mov 0x8(%edi),%edx
10b11e: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b121: 5b pop %ebx
10b122: 5e pop %esi
10b123: 68 00 40 00 00 push $0x4000
10b128: 50 push %eax
10b129: e8 0a 2f 00 00 call 10e038 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b12e: 9c pushf
10b12f: fa cli
10b130: 5a pop %edx
local_state = the_period->state;
10b131: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b134: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b13b: 52 push %edx
10b13c: 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 )
10b13d: 83 c4 10 add $0x10,%esp
10b140: 83 f8 03 cmp $0x3,%eax
10b143: 75 15 jne 10b15a <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b145: 51 push %ecx
10b146: 51 push %ecx
10b147: 68 00 40 00 00 push $0x4000
10b14c: ff 35 50 79 12 00 pushl 0x127950
10b152: e8 f9 23 00 00 call 10d550 <_Thread_Clear_state>
10b157: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b15a: e8 23 27 00 00 call 10d882 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b15f: 31 f6 xor %esi,%esi
10b161: eb 47 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b163: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b168: 83 f8 04 cmp $0x4,%eax
10b16b: 75 3d jne 10b1aa <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b16d: 83 ec 0c sub $0xc,%esp
10b170: 57 push %edi
10b171: e8 ec fd ff ff call 10af62 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b176: ff 75 d4 pushl -0x2c(%ebp)
10b179: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b17a: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b181: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b184: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b187: 58 pop %eax
10b188: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b189: 83 c7 10 add $0x10,%edi
10b18c: 57 push %edi
10b18d: 68 e8 74 12 00 push $0x1274e8
10b192: e8 91 34 00 00 call 10e628 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b197: e8 e6 26 00 00 call 10d882 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b19c: 83 c4 10 add $0x10,%esp
10b19f: 66 be 06 00 mov $0x6,%si
10b1a3: eb 05 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1a5: be 04 00 00 00 mov $0x4,%esi
}
10b1aa: 89 f0 mov %esi,%eax
10b1ac: 8d 65 f4 lea -0xc(%ebp),%esp
10b1af: 5b pop %ebx
10b1b0: 5e pop %esi
10b1b1: 5f pop %edi
10b1b2: c9 leave
10b1b3: c3 ret
0010b1b4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1b4: 55 push %ebp
10b1b5: 89 e5 mov %esp,%ebp
10b1b7: 57 push %edi
10b1b8: 56 push %esi
10b1b9: 53 push %ebx
10b1ba: 83 ec 7c sub $0x7c,%esp
10b1bd: 8b 5d 08 mov 0x8(%ebp),%ebx
10b1c0: 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 )
10b1c3: 85 ff test %edi,%edi
10b1c5: 0f 84 2b 01 00 00 je 10b2f6 <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b1cb: 52 push %edx
10b1cc: 52 push %edx
10b1cd: 68 bc 0d 12 00 push $0x120dbc
10b1d2: 53 push %ebx
10b1d3: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b1d5: 5e pop %esi
10b1d6: 58 pop %eax
10b1d7: 68 da 0d 12 00 push $0x120dda
10b1dc: 53 push %ebx
10b1dd: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b1df: 5a pop %edx
10b1e0: 59 pop %ecx
10b1e1: 68 fc 0d 12 00 push $0x120dfc
10b1e6: 53 push %ebx
10b1e7: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b1e9: 5e pop %esi
10b1ea: 58 pop %eax
10b1eb: 68 1f 0e 12 00 push $0x120e1f
10b1f0: 53 push %ebx
10b1f1: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b1f3: 5a pop %edx
10b1f4: 59 pop %ecx
10b1f5: 68 6a 0e 12 00 push $0x120e6a
10b1fa: 53 push %ebx
10b1fb: 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 ;
10b1fd: 8b 35 1c 73 12 00 mov 0x12731c,%esi
10b203: 83 c4 10 add $0x10,%esp
10b206: e9 df 00 00 00 jmp 10b2ea <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b20b: 50 push %eax
10b20c: 50 push %eax
10b20d: 8d 45 88 lea -0x78(%ebp),%eax
10b210: 50 push %eax
10b211: 56 push %esi
10b212: e8 89 56 00 00 call 1108a0 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b217: 83 c4 10 add $0x10,%esp
10b21a: 85 c0 test %eax,%eax
10b21c: 0f 85 c7 00 00 00 jne 10b2e9 <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 );
10b222: 51 push %ecx
10b223: 51 push %ecx
10b224: 8d 55 c0 lea -0x40(%ebp),%edx
10b227: 52 push %edx
10b228: 56 push %esi
10b229: e8 16 57 00 00 call 110944 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b22e: 83 c4 0c add $0xc,%esp
10b231: 8d 45 e3 lea -0x1d(%ebp),%eax
10b234: 50 push %eax
10b235: 6a 05 push $0x5
10b237: ff 75 c0 pushl -0x40(%ebp)
10b23a: e8 01 02 00 00 call 10b440 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b23f: 58 pop %eax
10b240: 5a pop %edx
10b241: ff 75 8c pushl -0x74(%ebp)
10b244: ff 75 88 pushl -0x78(%ebp)
10b247: 8d 55 e3 lea -0x1d(%ebp),%edx
10b24a: 52 push %edx
10b24b: 56 push %esi
10b24c: 68 b6 0e 12 00 push $0x120eb6
10b251: 53 push %ebx
10b252: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b254: 8b 45 88 mov -0x78(%ebp),%eax
10b257: 83 c4 20 add $0x20,%esp
10b25a: 85 c0 test %eax,%eax
10b25c: 75 0f jne 10b26d <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b25e: 51 push %ecx
10b25f: 51 push %ecx
10b260: 68 30 11 12 00 push $0x121130
10b265: 53 push %ebx
10b266: ff d7 call *%edi
continue;
10b268: 83 c4 10 add $0x10,%esp
10b26b: eb 7c jmp 10b2e9 <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 );
10b26d: 52 push %edx
10b26e: 8d 55 d8 lea -0x28(%ebp),%edx
10b271: 52 push %edx
10b272: 50 push %eax
10b273: 8d 45 a0 lea -0x60(%ebp),%eax
10b276: 50 push %eax
10b277: e8 80 30 00 00 call 10e2fc <_Timespec_Divide_by_integer>
(*print)( context,
10b27c: 8b 45 dc mov -0x24(%ebp),%eax
10b27f: b9 e8 03 00 00 mov $0x3e8,%ecx
10b284: 99 cltd
10b285: f7 f9 idiv %ecx
10b287: 50 push %eax
10b288: ff 75 d8 pushl -0x28(%ebp)
10b28b: 8b 45 9c mov -0x64(%ebp),%eax
10b28e: 99 cltd
10b28f: f7 f9 idiv %ecx
10b291: 50 push %eax
10b292: ff 75 98 pushl -0x68(%ebp)
10b295: 8b 45 94 mov -0x6c(%ebp),%eax
10b298: 99 cltd
10b299: f7 f9 idiv %ecx
10b29b: 50 push %eax
10b29c: ff 75 90 pushl -0x70(%ebp)
10b29f: 68 cd 0e 12 00 push $0x120ecd
10b2a4: 53 push %ebx
10b2a5: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b2a8: 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);
10b2aa: 83 c4 2c add $0x2c,%esp
10b2ad: 8d 55 d8 lea -0x28(%ebp),%edx
10b2b0: 52 push %edx
10b2b1: 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;
10b2b4: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2b7: 50 push %eax
10b2b8: e8 3f 30 00 00 call 10e2fc <_Timespec_Divide_by_integer>
(*print)( context,
10b2bd: 8b 45 dc mov -0x24(%ebp),%eax
10b2c0: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b2c3: 99 cltd
10b2c4: f7 f9 idiv %ecx
10b2c6: 50 push %eax
10b2c7: ff 75 d8 pushl -0x28(%ebp)
10b2ca: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2cd: 99 cltd
10b2ce: f7 f9 idiv %ecx
10b2d0: 50 push %eax
10b2d1: ff 75 b0 pushl -0x50(%ebp)
10b2d4: 8b 45 ac mov -0x54(%ebp),%eax
10b2d7: 99 cltd
10b2d8: f7 f9 idiv %ecx
10b2da: 50 push %eax
10b2db: ff 75 a8 pushl -0x58(%ebp)
10b2de: 68 ec 0e 12 00 push $0x120eec
10b2e3: 53 push %ebx
10b2e4: ff d7 call *%edi
10b2e6: 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++ ) {
10b2e9: 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 ;
10b2ea: 3b 35 20 73 12 00 cmp 0x127320,%esi
10b2f0: 0f 86 15 ff ff ff jbe 10b20b <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b2f6: 8d 65 f4 lea -0xc(%ebp),%esp
10b2f9: 5b pop %ebx
10b2fa: 5e pop %esi
10b2fb: 5f pop %edi
10b2fc: c9 leave
10b2fd: c3 ret
00115b48 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115b48: 55 push %ebp
115b49: 89 e5 mov %esp,%ebp
115b4b: 53 push %ebx
115b4c: 83 ec 14 sub $0x14,%esp
115b4f: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115b52: 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 )
115b57: 85 db test %ebx,%ebx
115b59: 74 6d je 115bc8 <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115b5b: 50 push %eax
115b5c: 50 push %eax
115b5d: 8d 45 f4 lea -0xc(%ebp),%eax
115b60: 50 push %eax
115b61: ff 75 08 pushl 0x8(%ebp)
115b64: e8 93 39 00 00 call 1194fc <_Thread_Get>
switch ( location ) {
115b69: 83 c4 10 add $0x10,%esp
115b6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115b70: 75 51 jne 115bc3 <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115b72: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115b78: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115b7c: 74 39 je 115bb7 <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115b7e: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115b82: 74 22 je 115ba6 <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115b84: 9c pushf
115b85: fa cli
115b86: 59 pop %ecx
*signal_set |= signals;
115b87: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115b8a: 51 push %ecx
115b8b: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115b8c: 83 3d 24 dc 13 00 00 cmpl $0x0,0x13dc24
115b93: 74 19 je 115bae <rtems_signal_send+0x66>
115b95: 3b 05 28 dc 13 00 cmp 0x13dc28,%eax
115b9b: 75 11 jne 115bae <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115b9d: c6 05 34 dc 13 00 01 movb $0x1,0x13dc34
115ba4: eb 08 jmp 115bae <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115ba6: 9c pushf
115ba7: fa cli
115ba8: 58 pop %eax
*signal_set |= signals;
115ba9: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115bac: 50 push %eax
115bad: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115bae: e8 27 39 00 00 call 1194da <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115bb3: 31 c0 xor %eax,%eax
115bb5: eb 11 jmp 115bc8 <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115bb7: e8 1e 39 00 00 call 1194da <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115bbc: b8 0b 00 00 00 mov $0xb,%eax
115bc1: eb 05 jmp 115bc8 <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115bc3: b8 04 00 00 00 mov $0x4,%eax
}
115bc8: 8b 5d fc mov -0x4(%ebp),%ebx
115bcb: c9 leave
115bcc: c3 ret
00110d70 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110d70: 55 push %ebp
110d71: 89 e5 mov %esp,%ebp
110d73: 57 push %edi
110d74: 56 push %esi
110d75: 53 push %ebx
110d76: 83 ec 1c sub $0x1c,%esp
110d79: 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;
110d7c: 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 )
110d81: 85 c9 test %ecx,%ecx
110d83: 0f 84 fb 00 00 00 je 110e84 <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110d89: 8b 35 2c 48 12 00 mov 0x12482c,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110d8f: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d95: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110d99: 19 ff sbb %edi,%edi
110d9b: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110da1: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110da5: 74 06 je 110dad <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110da7: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110dad: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110db1: 19 d2 sbb %edx,%edx
110db3: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110db9: 89 55 e4 mov %edx,-0x1c(%ebp)
110dbc: 89 4d e0 mov %ecx,-0x20(%ebp)
110dbf: e8 b1 c5 ff ff call 10d375 <_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;
110dc4: 8b 55 e4 mov -0x1c(%ebp),%edx
110dc7: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110dc9: 09 f8 or %edi,%eax
110dcb: 8b 4d e0 mov -0x20(%ebp),%ecx
110dce: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110dd0: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110dd7: 74 0b je 110de4 <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110dd9: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110de0: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110de4: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110deb: 74 21 je 110e0e <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110ded: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110df4: 74 11 je 110e07 <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110df6: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110dfd: a1 b0 42 12 00 mov 0x1242b0,%eax
110e02: 89 46 78 mov %eax,0x78(%esi)
110e05: eb 07 jmp 110e0e <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110e07: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110e0e: f6 45 0c 01 testb $0x1,0xc(%ebp)
110e12: 74 0a je 110e1e <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 ) );
110e14: f6 45 08 01 testb $0x1,0x8(%ebp)
110e18: 74 03 je 110e1d <rtems_task_mode+0xad>
110e1a: fa cli
110e1b: eb 01 jmp 110e1e <rtems_task_mode+0xae>
110e1d: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e1e: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110e20: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110e27: 74 2a je 110e53 <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110e29: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110e30: 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 ) {
110e33: 3a 43 08 cmp 0x8(%ebx),%al
110e36: 74 1b je 110e53 <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110e38: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110e3b: 9c pushf
110e3c: fa cli
110e3d: 58 pop %eax
_signals = information->signals_pending;
110e3e: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110e41: 8b 4b 14 mov 0x14(%ebx),%ecx
110e44: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110e47: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110e4a: 50 push %eax
110e4b: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e4c: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110e50: 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;
110e53: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110e55: 83 3d 5c 44 12 00 03 cmpl $0x3,0x12445c
110e5c: 75 26 jne 110e84 <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110e5e: 8b 15 2c 48 12 00 mov 0x12482c,%edx
if ( are_signals_pending ||
110e64: 84 c9 test %cl,%cl
110e66: 75 0e jne 110e76 <rtems_task_mode+0x106>
110e68: 3b 15 30 48 12 00 cmp 0x124830,%edx
110e6e: 74 14 je 110e84 <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110e70: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110e74: 74 0e je 110e84 <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110e76: c6 05 38 48 12 00 01 movb $0x1,0x124838
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110e7d: e8 1e b1 ff ff call 10bfa0 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110e82: 31 c0 xor %eax,%eax
}
110e84: 83 c4 1c add $0x1c,%esp
110e87: 5b pop %ebx
110e88: 5e pop %esi
110e89: 5f pop %edi
110e8a: c9 leave
110e8b: c3 ret
0010dd24 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd24: 55 push %ebp
10dd25: 89 e5 mov %esp,%ebp
10dd27: 56 push %esi
10dd28: 53 push %ebx
10dd29: 83 ec 10 sub $0x10,%esp
10dd2c: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd2f: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd32: 85 db test %ebx,%ebx
10dd34: 74 10 je 10dd46 <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 ) );
10dd36: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd3d: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd42: 39 d3 cmp %edx,%ebx
10dd44: 77 52 ja 10dd98 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dd46: 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 )
10dd4b: 85 f6 test %esi,%esi
10dd4d: 74 49 je 10dd98 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10dd4f: 51 push %ecx
10dd50: 51 push %ecx
10dd51: 8d 45 f4 lea -0xc(%ebp),%eax
10dd54: 50 push %eax
10dd55: ff 75 08 pushl 0x8(%ebp)
10dd58: e8 03 1e 00 00 call 10fb60 <_Thread_Get>
switch ( location ) {
10dd5d: 83 c4 10 add $0x10,%esp
10dd60: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10dd64: 75 2d jne 10dd93 <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10dd66: 8b 50 14 mov 0x14(%eax),%edx
10dd69: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10dd6b: 85 db test %ebx,%ebx
10dd6d: 74 1b je 10dd8a <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10dd6f: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10dd72: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10dd76: 74 05 je 10dd7d <rtems_task_set_priority+0x59>
10dd78: 39 58 14 cmp %ebx,0x14(%eax)
10dd7b: 76 0d jbe 10dd8a <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dd7d: 52 push %edx
10dd7e: 6a 00 push $0x0
10dd80: 53 push %ebx
10dd81: 50 push %eax
10dd82: e8 71 19 00 00 call 10f6f8 <_Thread_Change_priority>
10dd87: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10dd8a: e8 af 1d 00 00 call 10fb3e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10dd8f: 31 c0 xor %eax,%eax
10dd91: eb 05 jmp 10dd98 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10dd93: b8 04 00 00 00 mov $0x4,%eax
}
10dd98: 8d 65 f8 lea -0x8(%ebp),%esp
10dd9b: 5b pop %ebx
10dd9c: 5e pop %esi
10dd9d: c9 leave
10dd9e: c3 ret
0011639c <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
11639c: 55 push %ebp
11639d: 89 e5 mov %esp,%ebp
11639f: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1163a2: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1163a5: 50 push %eax
1163a6: ff 75 08 pushl 0x8(%ebp)
1163a9: 68 40 e0 13 00 push $0x13e040
1163ae: e8 49 27 00 00 call 118afc <_Objects_Get>
switch ( location ) {
1163b3: 83 c4 10 add $0x10,%esp
1163b6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1163ba: 75 1e jne 1163da <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1163bc: 83 78 38 04 cmpl $0x4,0x38(%eax)
1163c0: 74 0f je 1163d1 <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
1163c2: 83 ec 0c sub $0xc,%esp
1163c5: 83 c0 10 add $0x10,%eax
1163c8: 50 push %eax
1163c9: e8 3a 41 00 00 call 11a508 <_Watchdog_Remove>
1163ce: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1163d1: e8 04 31 00 00 call 1194da <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1163d6: 31 c0 xor %eax,%eax
1163d8: eb 05 jmp 1163df <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163da: b8 04 00 00 00 mov $0x4,%eax
}
1163df: c9 leave
1163e0: c3 ret
001167fc <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1167fc: 55 push %ebp
1167fd: 89 e5 mov %esp,%ebp
1167ff: 57 push %edi
116800: 56 push %esi
116801: 53 push %ebx
116802: 83 ec 1c sub $0x1c,%esp
116805: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116808: 8b 35 80 e0 13 00 mov 0x13e080,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11680e: 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 )
116813: 85 f6 test %esi,%esi
116815: 0f 84 b1 00 00 00 je 1168cc <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
11681b: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
11681d: 80 3d e8 d6 13 00 00 cmpb $0x0,0x13d6e8
116824: 0f 84 a2 00 00 00 je 1168cc <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
11682a: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
11682c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
116830: 0f 84 96 00 00 00 je 1168cc <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116836: 83 ec 0c sub $0xc,%esp
116839: 57 push %edi
11683a: e8 ad d6 ff ff call 113eec <_TOD_Validate>
11683f: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
116842: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116844: 84 c0 test %al,%al
116846: 0f 84 80 00 00 00 je 1168cc <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
11684c: 83 ec 0c sub $0xc,%esp
11684f: 57 push %edi
116850: e8 2f d6 ff ff call 113e84 <_TOD_To_seconds>
116855: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
116857: 83 c4 10 add $0x10,%esp
11685a: 3b 05 80 d7 13 00 cmp 0x13d780,%eax
116860: 76 6a jbe 1168cc <rtems_timer_server_fire_when+0xd0>
116862: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
116863: 8d 45 e4 lea -0x1c(%ebp),%eax
116866: 50 push %eax
116867: ff 75 08 pushl 0x8(%ebp)
11686a: 68 40 e0 13 00 push $0x13e040
11686f: e8 88 22 00 00 call 118afc <_Objects_Get>
116874: 89 c3 mov %eax,%ebx
switch ( location ) {
116876: 83 c4 10 add $0x10,%esp
116879: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
11687d: 75 48 jne 1168c7 <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
11687f: 83 ec 0c sub $0xc,%esp
116882: 8d 40 10 lea 0x10(%eax),%eax
116885: 50 push %eax
116886: e8 7d 3c 00 00 call 11a508 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
11688b: 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;
116892: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
116899: 8b 45 10 mov 0x10(%ebp),%eax
11689c: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
11689f: 8b 45 08 mov 0x8(%ebp),%eax
1168a2: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
1168a5: 8b 45 14 mov 0x14(%ebp),%eax
1168a8: 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();
1168ab: 2b 3d 80 d7 13 00 sub 0x13d780,%edi
1168b1: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1168b4: 58 pop %eax
1168b5: 5a pop %edx
1168b6: 53 push %ebx
1168b7: 56 push %esi
1168b8: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
1168bb: e8 1a 2c 00 00 call 1194da <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1168c0: 83 c4 10 add $0x10,%esp
1168c3: 31 db xor %ebx,%ebx
1168c5: eb 05 jmp 1168cc <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1168c7: bb 04 00 00 00 mov $0x4,%ebx
}
1168cc: 89 d8 mov %ebx,%eax
1168ce: 8d 65 f4 lea -0xc(%ebp),%esp
1168d1: 5b pop %ebx
1168d2: 5e pop %esi
1168d3: 5f pop %edi
1168d4: c9 leave
1168d5: c3 ret
0010a8f0 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a8f0: 55 push %ebp
10a8f1: 89 e5 mov %esp,%ebp
10a8f3: 83 ec 08 sub $0x8,%esp
10a8f6: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a8f9: 83 f9 04 cmp $0x4,%ecx
10a8fc: 77 0b ja 10a909 <sched_get_priority_max+0x19>
10a8fe: b8 01 00 00 00 mov $0x1,%eax
10a903: d3 e0 shl %cl,%eax
10a905: a8 17 test $0x17,%al
10a907: 75 10 jne 10a919 <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a909: e8 42 74 00 00 call 111d50 <__errno>
10a90e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a914: 83 c8 ff or $0xffffffff,%eax
10a917: eb 08 jmp 10a921 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a919: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax
10a920: 48 dec %eax
}
10a921: c9 leave
10a922: c3 ret
0010a924 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a924: 55 push %ebp
10a925: 89 e5 mov %esp,%ebp
10a927: 83 ec 08 sub $0x8,%esp
10a92a: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a92d: 83 f9 04 cmp $0x4,%ecx
10a930: 77 11 ja 10a943 <sched_get_priority_min+0x1f>
10a932: ba 01 00 00 00 mov $0x1,%edx
10a937: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a939: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a93e: 80 e2 17 and $0x17,%dl
10a941: 75 0e jne 10a951 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a943: e8 08 74 00 00 call 111d50 <__errno>
10a948: c7 00 16 00 00 00 movl $0x16,(%eax)
10a94e: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a951: c9 leave
10a952: c3 ret
0010a954 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a954: 55 push %ebp
10a955: 89 e5 mov %esp,%ebp
10a957: 56 push %esi
10a958: 53 push %ebx
10a959: 8b 75 08 mov 0x8(%ebp),%esi
10a95c: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a95f: 85 f6 test %esi,%esi
10a961: 74 16 je 10a979 <sched_rr_get_interval+0x25><== NEVER TAKEN
10a963: e8 b8 d0 ff ff call 107a20 <getpid>
10a968: 39 c6 cmp %eax,%esi
10a96a: 74 0d je 10a979 <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a96c: e8 df 73 00 00 call 111d50 <__errno>
10a971: c7 00 03 00 00 00 movl $0x3,(%eax)
10a977: eb 0f jmp 10a988 <sched_rr_get_interval+0x34>
if ( !interval )
10a979: 85 db test %ebx,%ebx
10a97b: 75 10 jne 10a98d <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a97d: e8 ce 73 00 00 call 111d50 <__errno>
10a982: c7 00 16 00 00 00 movl $0x16,(%eax)
10a988: 83 c8 ff or $0xffffffff,%eax
10a98b: eb 13 jmp 10a9a0 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a98d: 50 push %eax
10a98e: 50 push %eax
10a98f: 53 push %ebx
10a990: ff 35 a0 52 12 00 pushl 0x1252a0
10a996: e8 89 30 00 00 call 10da24 <_Timespec_From_ticks>
return 0;
10a99b: 83 c4 10 add $0x10,%esp
10a99e: 31 c0 xor %eax,%eax
}
10a9a0: 8d 65 f8 lea -0x8(%ebp),%esp
10a9a3: 5b pop %ebx
10a9a4: 5e pop %esi
10a9a5: c9 leave
10a9a6: c3 ret
0010d040 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d040: 55 push %ebp
10d041: 89 e5 mov %esp,%ebp
10d043: 57 push %edi
10d044: 56 push %esi
10d045: 53 push %ebx
10d046: 83 ec 2c sub $0x2c,%esp
10d049: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d04c: a1 c8 a4 12 00 mov 0x12a4c8,%eax
10d051: 40 inc %eax
10d052: a3 c8 a4 12 00 mov %eax,0x12a4c8
va_list arg;
mode_t mode;
unsigned int value = 0;
10d057: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d059: 8b 45 0c mov 0xc(%ebp),%eax
10d05c: 25 00 02 00 00 and $0x200,%eax
10d061: 89 45 d4 mov %eax,-0x2c(%ebp)
10d064: 74 03 je 10d069 <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d066: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d069: 52 push %edx
10d06a: 52 push %edx
10d06b: 8d 45 e4 lea -0x1c(%ebp),%eax
10d06e: 50 push %eax
10d06f: 56 push %esi
10d070: e8 7b 59 00 00 call 1129f0 <_POSIX_Semaphore_Name_to_id>
10d075: 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 ) {
10d077: 83 c4 10 add $0x10,%esp
10d07a: 85 c0 test %eax,%eax
10d07c: 74 19 je 10d097 <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) ) ) {
10d07e: 83 f8 02 cmp $0x2,%eax
10d081: 75 06 jne 10d089 <sem_open+0x49> <== NEVER TAKEN
10d083: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d087: 75 59 jne 10d0e2 <sem_open+0xa2>
_Thread_Enable_dispatch();
10d089: e8 74 27 00 00 call 10f802 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d08e: e8 d9 7f 00 00 call 11506c <__errno>
10d093: 89 18 mov %ebx,(%eax)
10d095: eb 1f jmp 10d0b6 <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d097: 8b 45 0c mov 0xc(%ebp),%eax
10d09a: 25 00 0a 00 00 and $0xa00,%eax
10d09f: 3d 00 0a 00 00 cmp $0xa00,%eax
10d0a4: 75 15 jne 10d0bb <sem_open+0x7b>
_Thread_Enable_dispatch();
10d0a6: e8 57 27 00 00 call 10f802 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d0ab: e8 bc 7f 00 00 call 11506c <__errno>
10d0b0: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0b6: 83 c8 ff or $0xffffffff,%eax
10d0b9: eb 4a jmp 10d105 <sem_open+0xc5>
10d0bb: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d0bc: 8d 45 dc lea -0x24(%ebp),%eax
10d0bf: 50 push %eax
10d0c0: ff 75 e4 pushl -0x1c(%ebp)
10d0c3: 68 90 a7 12 00 push $0x12a790
10d0c8: e8 e3 1c 00 00 call 10edb0 <_Objects_Get>
10d0cd: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d0d0: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d0d3: e8 2a 27 00 00 call 10f802 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d0d8: e8 25 27 00 00 call 10f802 <_Thread_Enable_dispatch>
goto return_id;
10d0dd: 83 c4 10 add $0x10,%esp
10d0e0: eb 1d jmp 10d0ff <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(
10d0e2: 8d 45 e0 lea -0x20(%ebp),%eax
10d0e5: 50 push %eax
10d0e6: 57 push %edi
10d0e7: 6a 00 push $0x0
10d0e9: 56 push %esi
10d0ea: e8 cd 57 00 00 call 1128bc <_POSIX_Semaphore_Create_support>
10d0ef: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d0f1: e8 0c 27 00 00 call 10f802 <_Thread_Enable_dispatch>
if ( status == -1 )
10d0f6: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d0f9: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d0fc: 43 inc %ebx
10d0fd: 74 06 je 10d105 <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;
10d0ff: 8b 45 e0 mov -0x20(%ebp),%eax
10d102: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d105: 8d 65 f4 lea -0xc(%ebp),%esp
10d108: 5b pop %ebx
10d109: 5e pop %esi
10d10a: 5f pop %edi
10d10b: c9 leave
10d10c: c3 ret
0010a7d8 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a7d8: 55 push %ebp
10a7d9: 89 e5 mov %esp,%ebp
10a7db: 57 push %edi
10a7dc: 56 push %esi
10a7dd: 53 push %ebx
10a7de: 83 ec 1c sub $0x1c,%esp
10a7e1: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7e4: 8b 55 0c mov 0xc(%ebp),%edx
10a7e7: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a7ea: 85 c0 test %eax,%eax
10a7ec: 74 12 je 10a800 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a7ee: 6b f3 0c imul $0xc,%ebx,%esi
10a7f1: 81 c6 a0 68 12 00 add $0x1268a0,%esi
10a7f7: b9 03 00 00 00 mov $0x3,%ecx
10a7fc: 89 c7 mov %eax,%edi
10a7fe: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a800: 85 db test %ebx,%ebx
10a802: 74 0d je 10a811 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a804: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a807: 83 f8 1f cmp $0x1f,%eax
10a80a: 77 05 ja 10a811 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a80c: 83 fb 09 cmp $0x9,%ebx
10a80f: 75 10 jne 10a821 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a811: e8 ce 77 00 00 call 111fe4 <__errno>
10a816: c7 00 16 00 00 00 movl $0x16,(%eax)
10a81c: 83 c8 ff or $0xffffffff,%eax
10a81f: eb 57 jmp 10a878 <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;
10a821: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a823: 85 d2 test %edx,%edx
10a825: 74 51 je 10a878 <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 );
10a827: 9c pushf
10a828: fa cli
10a829: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a82c: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a830: 75 1a jne 10a84c <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a832: 6b f3 0c imul $0xc,%ebx,%esi
10a835: 8d 86 a0 68 12 00 lea 0x1268a0(%esi),%eax
10a83b: 81 c6 9c 09 12 00 add $0x12099c,%esi
10a841: b9 03 00 00 00 mov $0x3,%ecx
10a846: 89 c7 mov %eax,%edi
10a848: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a84a: eb 26 jmp 10a872 <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a84c: 83 ec 0c sub $0xc,%esp
10a84f: 53 push %ebx
10a850: 89 55 e0 mov %edx,-0x20(%ebp)
10a853: e8 74 4e 00 00 call 10f6cc <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a858: 6b db 0c imul $0xc,%ebx,%ebx
10a85b: 81 c3 a0 68 12 00 add $0x1268a0,%ebx
10a861: b9 03 00 00 00 mov $0x3,%ecx
10a866: 8b 55 e0 mov -0x20(%ebp),%edx
10a869: 89 df mov %ebx,%edi
10a86b: 89 d6 mov %edx,%esi
10a86d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a86f: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a872: ff 75 e4 pushl -0x1c(%ebp)
10a875: 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;
10a876: 31 c0 xor %eax,%eax
}
10a878: 8d 65 f4 lea -0xc(%ebp),%esp
10a87b: 5b pop %ebx
10a87c: 5e pop %esi
10a87d: 5f pop %edi
10a87e: c9 leave
10a87f: c3 ret
0010aba3 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10aba3: 55 push %ebp
10aba4: 89 e5 mov %esp,%ebp
10aba6: 57 push %edi
10aba7: 56 push %esi
10aba8: 53 push %ebx
10aba9: 83 ec 3c sub $0x3c,%esp
10abac: 8b 75 08 mov 0x8(%ebp),%esi
10abaf: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10abb2: 85 f6 test %esi,%esi
10abb4: 74 24 je 10abda <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abb6: 85 db test %ebx,%ebx
10abb8: 74 30 je 10abea <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abba: 83 ec 0c sub $0xc,%esp
10abbd: 53 push %ebx
10abbe: e8 25 31 00 00 call 10dce8 <_Timespec_Is_valid>
10abc3: 83 c4 10 add $0x10,%esp
10abc6: 84 c0 test %al,%al
10abc8: 74 10 je 10abda <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10abca: 83 ec 0c sub $0xc,%esp
10abcd: 53 push %ebx
10abce: e8 6d 31 00 00 call 10dd40 <_Timespec_To_ticks>
if ( !interval )
10abd3: 83 c4 10 add $0x10,%esp
10abd6: 85 c0 test %eax,%eax
10abd8: 75 12 jne 10abec <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10abda: e8 ad 79 00 00 call 11258c <__errno>
10abdf: c7 00 16 00 00 00 movl $0x16,(%eax)
10abe5: e9 39 01 00 00 jmp 10ad23 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10abea: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10abec: 8b 7d 0c mov 0xc(%ebp),%edi
10abef: 85 ff test %edi,%edi
10abf1: 75 03 jne 10abf6 <sigtimedwait+0x53>
10abf3: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10abf6: 8b 15 6c 68 12 00 mov 0x12686c,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10abfc: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
10ac02: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10ac05: 9c pushf
10ac06: fa cli
10ac07: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10ac0a: 8b 1e mov (%esi),%ebx
10ac0c: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac0f: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac12: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac18: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac1b: 74 32 je 10ac4f <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac1d: 83 ec 0c sub $0xc,%esp
10ac20: 51 push %ecx
10ac21: e8 3e ff ff ff call 10ab64 <_POSIX_signals_Get_lowest>
10ac26: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac28: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac2f: 6a 00 push $0x0
10ac31: 57 push %edi
10ac32: 50 push %eax
10ac33: 53 push %ebx
10ac34: e8 df 50 00 00 call 10fd18 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac39: ff 75 d0 pushl -0x30(%ebp)
10ac3c: 9d popf
the_info->si_code = SI_USER;
10ac3d: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac44: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac4b: 8b 1f mov (%edi),%ebx
10ac4d: eb 3d jmp 10ac8c <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac4f: 8b 0d 94 6a 12 00 mov 0x126a94,%ecx
10ac55: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac58: 74 3a je 10ac94 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac5a: 83 ec 0c sub $0xc,%esp
10ac5d: 51 push %ecx
10ac5e: e8 01 ff ff ff call 10ab64 <_POSIX_signals_Get_lowest>
10ac63: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10ac65: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac6c: 6a 01 push $0x1
10ac6e: 57 push %edi
10ac6f: 50 push %eax
10ac70: ff 75 d4 pushl -0x2c(%ebp)
10ac73: e8 a0 50 00 00 call 10fd18 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10ac78: ff 75 d0 pushl -0x30(%ebp)
10ac7b: 9d popf
the_info->si_signo = signo;
10ac7c: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10ac7e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac85: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10ac8c: 83 c4 20 add $0x20,%esp
10ac8f: e9 92 00 00 00 jmp 10ad26 <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10ac94: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10ac9a: 8b 0d 20 63 12 00 mov 0x126320,%ecx
10aca0: 41 inc %ecx
10aca1: 89 0d 20 63 12 00 mov %ecx,0x126320
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10aca7: c7 42 44 2c 6a 12 00 movl $0x126a2c,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10acae: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10acb5: 8b 0e mov (%esi),%ecx
10acb7: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acba: 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;
10acbd: c7 05 5c 6a 12 00 01 movl $0x1,0x126a5c
10acc4: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10acc7: ff 75 d0 pushl -0x30(%ebp)
10acca: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10accb: 52 push %edx
10accc: 68 0c da 10 00 push $0x10da0c
10acd1: 50 push %eax
10acd2: 68 2c 6a 12 00 push $0x126a2c
10acd7: e8 54 2a 00 00 call 10d730 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10acdc: e8 cd 25 00 00 call 10d2ae <_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 );
10ace1: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ace8: 6a 00 push $0x0
10acea: 57 push %edi
10aceb: ff 37 pushl (%edi)
10aced: ff 75 d4 pushl -0x2c(%ebp)
10acf0: e8 23 50 00 00 call 10fd18 <_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)
10acf5: 83 c4 20 add $0x20,%esp
10acf8: a1 6c 68 12 00 mov 0x12686c,%eax
10acfd: 83 78 34 04 cmpl $0x4,0x34(%eax)
10ad01: 75 10 jne 10ad13 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10ad03: 8b 1f mov (%edi),%ebx
10ad05: 8d 4b ff lea -0x1(%ebx),%ecx
10ad08: b8 01 00 00 00 mov $0x1,%eax
10ad0d: d3 e0 shl %cl,%eax
10ad0f: 85 06 test %eax,(%esi)
10ad11: 75 13 jne 10ad26 <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad13: e8 74 78 00 00 call 11258c <__errno>
10ad18: 8b 15 6c 68 12 00 mov 0x12686c,%edx
10ad1e: 8b 52 34 mov 0x34(%edx),%edx
10ad21: 89 10 mov %edx,(%eax)
return -1;
10ad23: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad26: 89 d8 mov %ebx,%eax
10ad28: 8d 65 f4 lea -0xc(%ebp),%esp
10ad2b: 5b pop %ebx
10ad2c: 5e pop %esi
10ad2d: 5f pop %edi
10ad2e: c9 leave
10ad2f: c3 ret
0010ca14 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca14: 55 push %ebp
10ca15: 89 e5 mov %esp,%ebp
10ca17: 53 push %ebx
10ca18: 83 ec 08 sub $0x8,%esp
10ca1b: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca1e: 6a 00 push $0x0
10ca20: 6a 00 push $0x0
10ca22: ff 75 08 pushl 0x8(%ebp)
10ca25: e8 45 fe ff ff call 10c86f <sigtimedwait>
10ca2a: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca2c: 83 c4 10 add $0x10,%esp
10ca2f: 83 f8 ff cmp $0xffffffff,%eax
10ca32: 74 0a je 10ca3e <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca34: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca36: 85 db test %ebx,%ebx
10ca38: 74 0b je 10ca45 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca3a: 89 13 mov %edx,(%ebx)
10ca3c: eb 07 jmp 10ca45 <sigwait+0x31>
return 0;
}
return errno;
10ca3e: e8 61 73 00 00 call 113da4 <__errno>
10ca43: 8b 00 mov (%eax),%eax
}
10ca45: 8b 5d fc mov -0x4(%ebp),%ebx
10ca48: c9 leave
10ca49: c3 ret
0010a02c <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a02c: 55 push %ebp
10a02d: 89 e5 mov %esp,%ebp
10a02f: 56 push %esi
10a030: 53 push %ebx
10a031: 8b 5d 0c mov 0xc(%ebp),%ebx
10a034: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a037: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a03b: 75 1d jne 10a05a <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a03d: 85 f6 test %esi,%esi
10a03f: 74 19 je 10a05a <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a041: 85 db test %ebx,%ebx
10a043: 74 22 je 10a067 <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a045: 8b 03 mov (%ebx),%eax
10a047: 48 dec %eax
10a048: 83 f8 01 cmp $0x1,%eax
10a04b: 77 0d ja 10a05a <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 )
10a04d: 8b 43 04 mov 0x4(%ebx),%eax
10a050: 85 c0 test %eax,%eax
10a052: 74 06 je 10a05a <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a054: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a055: 83 f8 1f cmp $0x1f,%eax
10a058: 76 0d jbe 10a067 <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a05a: e8 11 7d 00 00 call 111d70 <__errno>
10a05f: c7 00 16 00 00 00 movl $0x16,(%eax)
10a065: eb 2f jmp 10a096 <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a067: a1 34 63 12 00 mov 0x126334,%eax
10a06c: 40 inc %eax
10a06d: a3 34 63 12 00 mov %eax,0x126334
* 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 );
10a072: 83 ec 0c sub $0xc,%esp
10a075: 68 3c 66 12 00 push $0x12663c
10a07a: e8 7d 1b 00 00 call 10bbfc <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a07f: 83 c4 10 add $0x10,%esp
10a082: 85 c0 test %eax,%eax
10a084: 75 18 jne 10a09e <timer_create+0x72>
_Thread_Enable_dispatch();
10a086: e8 7f 29 00 00 call 10ca0a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a08b: e8 e0 7c 00 00 call 111d70 <__errno>
10a090: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a096: 83 c8 ff or $0xffffffff,%eax
10a099: e9 83 00 00 00 jmp 10a121 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a09e: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0a2: 8b 15 80 68 12 00 mov 0x126880,%edx
10a0a8: 8b 52 08 mov 0x8(%edx),%edx
10a0ab: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a0ae: 85 db test %ebx,%ebx
10a0b0: 74 11 je 10a0c3 <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a0b2: 8b 13 mov (%ebx),%edx
10a0b4: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a0b7: 8b 53 04 mov 0x4(%ebx),%edx
10a0ba: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a0bd: 8b 53 08 mov 0x8(%ebx),%edx
10a0c0: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a0c3: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a0ca: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a0d1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a0d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a0df: 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;
10a0e6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a0ed: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a0f4: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a0fb: 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 ),
10a102: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a105: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a108: 8b 0d 58 66 12 00 mov 0x126658,%ecx
10a10e: 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;
10a111: 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;
10a118: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a11a: e8 eb 28 00 00 call 10ca0a <_Thread_Enable_dispatch>
return 0;
10a11f: 31 c0 xor %eax,%eax
}
10a121: 8d 65 f8 lea -0x8(%ebp),%esp
10a124: 5b pop %ebx
10a125: 5e pop %esi
10a126: c9 leave
10a127: c3 ret
0010a128 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a128: 55 push %ebp
10a129: 89 e5 mov %esp,%ebp
10a12b: 57 push %edi
10a12c: 56 push %esi
10a12d: 53 push %ebx
10a12e: 83 ec 2c sub $0x2c,%esp
10a131: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a134: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a138: 0f 84 58 01 00 00 je 10a296 <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) ) ) {
10a13e: 83 ec 0c sub $0xc,%esp
10a141: 8b 45 10 mov 0x10(%ebp),%eax
10a144: 83 c0 08 add $0x8,%eax
10a147: 50 push %eax
10a148: e8 1b 33 00 00 call 10d468 <_Timespec_Is_valid>
10a14d: 83 c4 10 add $0x10,%esp
10a150: 84 c0 test %al,%al
10a152: 0f 84 3e 01 00 00 je 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a158: 83 ec 0c sub $0xc,%esp
10a15b: ff 75 10 pushl 0x10(%ebp)
10a15e: e8 05 33 00 00 call 10d468 <_Timespec_Is_valid>
10a163: 83 c4 10 add $0x10,%esp
10a166: 84 c0 test %al,%al
10a168: 0f 84 28 01 00 00 je 10a296 <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a16e: 85 db test %ebx,%ebx
10a170: 74 09 je 10a17b <timer_settime+0x53>
10a172: 83 fb 04 cmp $0x4,%ebx
10a175: 0f 85 1b 01 00 00 jne 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a17b: 8d 7d cc lea -0x34(%ebp),%edi
10a17e: b9 04 00 00 00 mov $0x4,%ecx
10a183: 8b 75 10 mov 0x10(%ebp),%esi
10a186: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a188: 83 fb 04 cmp $0x4,%ebx
10a18b: 75 2f jne 10a1bc <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a18d: 83 ec 0c sub $0xc,%esp
10a190: 8d 5d dc lea -0x24(%ebp),%ebx
10a193: 53 push %ebx
10a194: e8 b3 15 00 00 call 10b74c <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a199: 59 pop %ecx
10a19a: 5e pop %esi
10a19b: 8d 75 d4 lea -0x2c(%ebp),%esi
10a19e: 56 push %esi
10a19f: 53 push %ebx
10a1a0: e8 9f 32 00 00 call 10d444 <_Timespec_Greater_than>
10a1a5: 83 c4 10 add $0x10,%esp
10a1a8: 84 c0 test %al,%al
10a1aa: 0f 85 e6 00 00 00 jne 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a1b0: 52 push %edx
10a1b1: 56 push %esi
10a1b2: 56 push %esi
10a1b3: 53 push %ebx
10a1b4: e8 d3 32 00 00 call 10d48c <_Timespec_Subtract>
10a1b9: 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 );
10a1bc: 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 );
10a1bd: 8d 45 e4 lea -0x1c(%ebp),%eax
10a1c0: 50 push %eax
10a1c1: ff 75 08 pushl 0x8(%ebp)
10a1c4: 68 3c 66 12 00 push $0x12663c
10a1c9: e8 5e 1e 00 00 call 10c02c <_Objects_Get>
10a1ce: 89 c3 mov %eax,%ebx
switch ( location ) {
10a1d0: 83 c4 10 add $0x10,%esp
10a1d3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a1d7: 0f 85 b9 00 00 00 jne 10a296 <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 ) {
10a1dd: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a1e1: 75 3b jne 10a21e <timer_settime+0xf6>
10a1e3: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a1e7: 75 35 jne 10a21e <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a1e9: 83 ec 0c sub $0xc,%esp
10a1ec: 8d 40 10 lea 0x10(%eax),%eax
10a1ef: 50 push %eax
10a1f0: e8 5b 36 00 00 call 10d850 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a1f5: 83 c4 10 add $0x10,%esp
10a1f8: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a1fc: 74 0d je 10a20b <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a1fe: 8d 73 54 lea 0x54(%ebx),%esi
10a201: b9 04 00 00 00 mov $0x4,%ecx
10a206: 8b 7d 14 mov 0x14(%ebp),%edi
10a209: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a20b: 8d 7b 54 lea 0x54(%ebx),%edi
10a20e: 8d 75 cc lea -0x34(%ebp),%esi
10a211: b9 04 00 00 00 mov $0x4,%ecx
10a216: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a218: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a21c: eb 35 jmp 10a253 <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a21e: 83 ec 0c sub $0xc,%esp
10a221: ff 75 10 pushl 0x10(%ebp)
10a224: e8 97 32 00 00 call 10d4c0 <_Timespec_To_ticks>
10a229: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a22c: 8d 45 d4 lea -0x2c(%ebp),%eax
10a22f: 89 04 24 mov %eax,(%esp)
10a232: e8 89 32 00 00 call 10d4c0 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a237: 89 1c 24 mov %ebx,(%esp)
10a23a: 68 ac a2 10 00 push $0x10a2ac
10a23f: ff 73 08 pushl 0x8(%ebx)
10a242: 50 push %eax
10a243: 8d 43 10 lea 0x10(%ebx),%eax
10a246: 50 push %eax
10a247: e8 44 57 00 00 call 10f990 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a24c: 83 c4 20 add $0x20,%esp
10a24f: 84 c0 test %al,%al
10a251: 75 07 jne 10a25a <timer_settime+0x132>
_Thread_Enable_dispatch();
10a253: e8 b2 27 00 00 call 10ca0a <_Thread_Enable_dispatch>
10a258: eb 38 jmp 10a292 <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a25e: 74 0d je 10a26d <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a260: 8d 73 54 lea 0x54(%ebx),%esi
10a263: b9 04 00 00 00 mov $0x4,%ecx
10a268: 8b 7d 14 mov 0x14(%ebp),%edi
10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a26d: 8d 7b 54 lea 0x54(%ebx),%edi
10a270: 8d 75 cc lea -0x34(%ebp),%esi
10a273: b9 04 00 00 00 mov $0x4,%ecx
10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a27a: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a27e: 83 ec 0c sub $0xc,%esp
10a281: 83 c3 6c add $0x6c,%ebx
10a284: 53 push %ebx
10a285: e8 c2 14 00 00 call 10b74c <_TOD_Get>
_Thread_Enable_dispatch();
10a28a: e8 7b 27 00 00 call 10ca0a <_Thread_Enable_dispatch>
return 0;
10a28f: 83 c4 10 add $0x10,%esp
10a292: 31 c0 xor %eax,%eax
10a294: eb 0e jmp 10a2a4 <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a296: e8 d5 7a 00 00 call 111d70 <__errno>
10a29b: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2a1: 83 c8 ff or $0xffffffff,%eax
}
10a2a4: 8d 65 f4 lea -0xc(%ebp),%esp
10a2a7: 5b pop %ebx
10a2a8: 5e pop %esi
10a2a9: 5f pop %edi
10a2aa: c9 leave
10a2ab: c3 ret
00109f68 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109f68: 55 push %ebp
109f69: 89 e5 mov %esp,%ebp
109f6b: 57 push %edi
109f6c: 56 push %esi
109f6d: 53 push %ebx
109f6e: 83 ec 1c sub $0x1c,%esp
109f71: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109f74: 83 3d 44 6c 12 00 00 cmpl $0x0,0x126c44
109f7b: 75 2c jne 109fa9 <ualarm+0x41>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109f7d: c7 05 30 6c 12 00 00 movl $0x0,0x126c30
109f84: 00 00 00
the_watchdog->routine = routine;
109f87: c7 05 44 6c 12 00 30 movl $0x109f30,0x126c44
109f8e: 9f 10 00
the_watchdog->id = id;
109f91: c7 05 48 6c 12 00 00 movl $0x0,0x126c48
109f98: 00 00 00
the_watchdog->user_data = user_data;
109f9b: c7 05 4c 6c 12 00 00 movl $0x0,0x126c4c
109fa2: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fa5: 31 db xor %ebx,%ebx
109fa7: eb 4f jmp 109ff8 <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 );
109fa9: 83 ec 0c sub $0xc,%esp
109fac: 68 28 6c 12 00 push $0x126c28
109fb1: e8 82 34 00 00 call 10d438 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fb6: 83 e8 02 sub $0x2,%eax
109fb9: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fbc: 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) ) {
109fbe: 83 f8 01 cmp $0x1,%eax
109fc1: 77 35 ja 109ff8 <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);
109fc3: a1 3c 6c 12 00 mov 0x126c3c,%eax
109fc8: 03 05 34 6c 12 00 add 0x126c34,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fce: 57 push %edi
109fcf: 57 push %edi
109fd0: 8d 55 e0 lea -0x20(%ebp),%edx
109fd3: 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);
109fd4: 2b 05 40 6c 12 00 sub 0x126c40,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fda: 50 push %eax
109fdb: e8 00 30 00 00 call 10cfe0 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
109fe0: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
109fe7: 8b 45 e4 mov -0x1c(%ebp),%eax
109fea: bf e8 03 00 00 mov $0x3e8,%edi
109fef: 99 cltd
109ff0: f7 ff idiv %edi
109ff2: 8d 1c 08 lea (%eax,%ecx,1),%ebx
109ff5: 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 ) {
109ff8: 85 f6 test %esi,%esi
109ffa: 74 44 je 10a040 <ualarm+0xd8> <== NEVER TAKEN
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
109ffc: b9 40 42 0f 00 mov $0xf4240,%ecx
10a001: 89 f0 mov %esi,%eax
10a003: 31 d2 xor %edx,%edx
10a005: f7 f1 div %ecx
10a007: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a00a: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a010: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a013: 83 ec 0c sub $0xc,%esp
10a016: 8d 75 e0 lea -0x20(%ebp),%esi
10a019: 56 push %esi
10a01a: e8 1d 30 00 00 call 10d03c <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a01f: 89 34 24 mov %esi,(%esp)
10a022: e8 15 30 00 00 call 10d03c <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a027: a3 34 6c 12 00 mov %eax,0x126c34
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a02c: 59 pop %ecx
10a02d: 5e pop %esi
10a02e: 68 28 6c 12 00 push $0x126c28
10a033: 68 14 64 12 00 push $0x126414
10a038: e8 e3 32 00 00 call 10d320 <_Watchdog_Insert>
10a03d: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a040: 89 d8 mov %ebx,%eax
10a042: 8d 65 f4 lea -0xc(%ebp),%esp
10a045: 5b pop %ebx
10a046: 5e pop %esi
10a047: 5f pop %edi
10a048: c9 leave
10a049: c3 ret