RTEMS 4.11Annotated Report
Sun Jan 9 14:30:37 2011
0010ce0c <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10ce0c: 55 push %ebp
10ce0d: 89 e5 mov %esp,%ebp
10ce0f: 53 push %ebx
10ce10: 83 ec 04 sub $0x4,%esp
10ce13: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce16: 8b 15 38 88 12 00 mov 0x128838,%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 );
10ce1c: 9c pushf
10ce1d: fa cli
10ce1e: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce1f: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce22: 85 c9 test %ecx,%ecx
10ce24: 75 0b jne 10ce31 <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce26: 50 push %eax
10ce27: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce28: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce2f: eb 72 jmp 10cea3 <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce31: 49 dec %ecx
10ce32: 75 0f jne 10ce43 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce34: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce37: 49 dec %ecx
10ce38: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce3b: 85 c9 test %ecx,%ecx
10ce3d: 74 04 je 10ce43 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce3f: 50 push %eax
10ce40: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce41: eb 60 jmp 10cea3 <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce43: 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;
10ce4a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10ce51: 50 push %eax
10ce52: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10ce53: 83 ec 0c sub $0xc,%esp
10ce56: 53 push %ebx
10ce57: e8 58 17 00 00 call 10e5b4 <_Thread_queue_Dequeue>
if ( next ) {
10ce5c: 83 c4 10 add $0x10,%esp
10ce5f: 85 c0 test %eax,%eax
10ce61: 74 40 je 10cea3 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ce63: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce67: 75 09 jne 10ce72 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10ce69: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10ce70: eb 31 jmp 10cea3 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10ce72: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10ce75: 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 );
10ce7c: 83 ec 0c sub $0xc,%esp
10ce7f: 53 push %ebx
10ce80: e8 27 1b 00 00 call 10e9ac <_Thread_queue_First>
if ( !next ||
10ce85: 83 c4 10 add $0x10,%esp
10ce88: 85 c0 test %eax,%eax
10ce8a: 74 17 je 10cea3 <_CORE_RWLock_Release+0x97>
10ce8c: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce90: 74 11 je 10cea3 <_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;
10ce92: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10ce95: 52 push %edx
10ce96: 52 push %edx
10ce97: 50 push %eax
10ce98: 53 push %ebx
10ce99: e8 fe 19 00 00 call 10e89c <_Thread_queue_Extract>
}
10ce9e: 83 c4 10 add $0x10,%esp
10cea1: eb d9 jmp 10ce7c <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10cea3: 31 c0 xor %eax,%eax
10cea5: 8b 5d fc mov -0x4(%ebp),%ebx
10cea8: c9 leave
10cea9: c3 ret
0010ceac <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10ceac: 55 push %ebp
10cead: 89 e5 mov %esp,%ebp
10ceaf: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ceb2: 8d 45 f4 lea -0xc(%ebp),%eax
10ceb5: 50 push %eax
10ceb6: ff 75 08 pushl 0x8(%ebp)
10ceb9: e8 a2 13 00 00 call 10e260 <_Thread_Get>
switch ( location ) {
10cebe: 83 c4 10 add $0x10,%esp
10cec1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10cec5: 75 17 jne 10cede <_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 );
10cec7: 83 ec 0c sub $0xc,%esp
10ceca: 50 push %eax
10cecb: e8 a8 1b 00 00 call 10ea78 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10ced0: a1 f0 82 12 00 mov 0x1282f0,%eax
10ced5: 48 dec %eax
10ced6: a3 f0 82 12 00 mov %eax,0x1282f0
10cedb: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cede: c9 leave
10cedf: c3 ret
0011736c <_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
)
{
11736c: 55 push %ebp
11736d: 89 e5 mov %esp,%ebp
11736f: 57 push %edi
117370: 56 push %esi
117371: 53 push %ebx
117372: 83 ec 1c sub $0x1c,%esp
117375: 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;
117378: 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 ) {
11737d: 8b 55 10 mov 0x10(%ebp),%edx
117380: 3b 53 4c cmp 0x4c(%ebx),%edx
117383: 77 4e ja 1173d3 <_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 ) {
117385: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
117389: 75 09 jne 117394 <_CORE_message_queue_Broadcast+0x28>
11738b: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
117392: eb 23 jmp 1173b7 <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
117394: 8b 45 1c mov 0x1c(%ebp),%eax
117397: c7 00 00 00 00 00 movl $0x0,(%eax)
11739d: eb 32 jmp 1173d1 <_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;
11739f: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1173a2: 8b 42 2c mov 0x2c(%edx),%eax
1173a5: 89 c7 mov %eax,%edi
1173a7: 8b 75 0c mov 0xc(%ebp),%esi
1173aa: 8b 4d 10 mov 0x10(%ebp),%ecx
1173ad: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
1173af: 8b 42 28 mov 0x28(%edx),%eax
1173b2: 8b 55 10 mov 0x10(%ebp),%edx
1173b5: 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 =
1173b7: 83 ec 0c sub $0xc,%esp
1173ba: 53 push %ebx
1173bb: e8 84 24 00 00 call 119844 <_Thread_queue_Dequeue>
1173c0: 89 c2 mov %eax,%edx
1173c2: 83 c4 10 add $0x10,%esp
1173c5: 85 c0 test %eax,%eax
1173c7: 75 d6 jne 11739f <_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;
1173c9: 8b 55 e4 mov -0x1c(%ebp),%edx
1173cc: 8b 45 1c mov 0x1c(%ebp),%eax
1173cf: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1173d1: 31 c0 xor %eax,%eax
}
1173d3: 8d 65 f4 lea -0xc(%ebp),%esp
1173d6: 5b pop %ebx
1173d7: 5e pop %esi
1173d8: 5f pop %edi
1173d9: c9 leave
1173da: c3 ret
00112220 <_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
)
{
112220: 55 push %ebp
112221: 89 e5 mov %esp,%ebp
112223: 57 push %edi
112224: 56 push %esi
112225: 53 push %ebx
112226: 83 ec 1c sub $0x1c,%esp
112229: 8b 5d 08 mov 0x8(%ebp),%ebx
11222c: 8b 7d 10 mov 0x10(%ebp),%edi
11222f: 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;
112232: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
112235: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
11223c: 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;
11223f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
112246: 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)) {
11224d: 89 d0 mov %edx,%eax
11224f: f6 c2 03 test $0x3,%dl
112252: 74 0c je 112260 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
112254: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
112257: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
11225a: 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)
11225c: 39 d0 cmp %edx,%eax
11225e: 72 68 jb 1122c8 <_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));
112260: 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 *
112263: 89 d1 mov %edx,%ecx
112265: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
112268: 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)
11226a: 39 c1 cmp %eax,%ecx
11226c: 72 5a jb 1122c8 <_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 );
11226e: 83 ec 0c sub $0xc,%esp
112271: 51 push %ecx
112272: 89 55 e4 mov %edx,-0x1c(%ebp)
112275: e8 74 27 00 00 call 1149ee <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
11227a: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
11227d: 83 c4 10 add $0x10,%esp
112280: 85 c0 test %eax,%eax
112282: 8b 55 e4 mov -0x1c(%ebp),%edx
112285: 74 41 je 1122c8 <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
112287: 52 push %edx
112288: 57 push %edi
112289: 50 push %eax
11228a: 8d 43 68 lea 0x68(%ebx),%eax
11228d: 50 push %eax
11228e: e8 b9 4a 00 00 call 116d4c <_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 );
112293: 8d 43 54 lea 0x54(%ebx),%eax
112296: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
112299: 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 );
1122a0: 8d 43 50 lea 0x50(%ebx),%eax
1122a3: 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(
1122a6: 6a 06 push $0x6
1122a8: 68 80 00 00 00 push $0x80
1122ad: 8b 45 0c mov 0xc(%ebp),%eax
1122b0: 83 38 01 cmpl $0x1,(%eax)
1122b3: 0f 94 c0 sete %al
1122b6: 0f b6 c0 movzbl %al,%eax
1122b9: 50 push %eax
1122ba: 53 push %ebx
1122bb: e8 fc 1e 00 00 call 1141bc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
1122c0: 83 c4 20 add $0x20,%esp
1122c3: be 01 00 00 00 mov $0x1,%esi
}
1122c8: 89 f0 mov %esi,%eax
1122ca: 8d 65 f4 lea -0xc(%ebp),%esp
1122cd: 5b pop %ebx
1122ce: 5e pop %esi
1122cf: 5f pop %edi
1122d0: c9 leave
1122d1: c3 ret
001122d4 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
1122d4: 55 push %ebp
1122d5: 89 e5 mov %esp,%ebp
1122d7: 57 push %edi
1122d8: 56 push %esi
1122d9: 53 push %ebx
1122da: 83 ec 2c sub $0x2c,%esp
1122dd: 8b 55 08 mov 0x8(%ebp),%edx
1122e0: 8b 45 0c mov 0xc(%ebp),%eax
1122e3: 89 45 dc mov %eax,-0x24(%ebp)
1122e6: 8b 5d 10 mov 0x10(%ebp),%ebx
1122e9: 89 5d e0 mov %ebx,-0x20(%ebp)
1122ec: 8b 4d 14 mov 0x14(%ebp),%ecx
1122ef: 8b 75 1c mov 0x1c(%ebp),%esi
1122f2: 89 75 d4 mov %esi,-0x2c(%ebp)
1122f5: 8a 45 18 mov 0x18(%ebp),%al
1122f8: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
1122fb: a1 90 c9 12 00 mov 0x12c990,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
112300: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
112307: 9c pushf
112308: fa cli
112309: 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 );
}
11230c: 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 );
11230f: 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))
112312: 39 f3 cmp %esi,%ebx
112314: 0f 84 8a 00 00 00 je 1123a4 <_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;
11231a: 8b 33 mov (%ebx),%esi
head->next = new_first;
11231c: 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 );
11231f: 8d 7a 50 lea 0x50(%edx),%edi
112322: 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 ) {
112325: 85 db test %ebx,%ebx
112327: 74 7b je 1123a4 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
112329: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
11232c: ff 75 e4 pushl -0x1c(%ebp)
11232f: 9d popf
*size_p = the_message->Contents.size;
112330: 8b 43 0c mov 0xc(%ebx),%eax
112333: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
112335: 8b 73 08 mov 0x8(%ebx),%esi
112338: a1 90 c9 12 00 mov 0x12c990,%eax
11233d: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112340: 8d 73 10 lea 0x10(%ebx),%esi
112343: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
112346: 8b 09 mov (%ecx),%ecx
112348: 8b 7d e0 mov -0x20(%ebp),%edi
11234b: 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 );
11234d: 83 ec 0c sub $0xc,%esp
112350: 52 push %edx
112351: 89 55 d0 mov %edx,-0x30(%ebp)
112354: e8 2b 1b 00 00 call 113e84 <_Thread_queue_Dequeue>
if ( !the_thread ) {
112359: 83 c4 10 add $0x10,%esp
11235c: 85 c0 test %eax,%eax
11235e: 8b 55 d0 mov -0x30(%ebp),%edx
112361: 75 15 jne 112378 <_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 );
112363: 89 5d 0c mov %ebx,0xc(%ebp)
112366: 83 c2 68 add $0x68,%edx
112369: 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 );
}
11236c: 8d 65 f4 lea -0xc(%ebp),%esp
11236f: 5b pop %ebx
112370: 5e pop %esi
112371: 5f pop %edi
112372: c9 leave
112373: e9 28 fe ff ff jmp 1121a0 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
112378: 8b 48 24 mov 0x24(%eax),%ecx
11237b: 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;
11237e: 8b 48 30 mov 0x30(%eax),%ecx
112381: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
112384: 8b 70 2c mov 0x2c(%eax),%esi
112387: 8b 7d e4 mov -0x1c(%ebp),%edi
11238a: 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(
11238c: 8b 43 08 mov 0x8(%ebx),%eax
11238f: 89 45 10 mov %eax,0x10(%ebp)
112392: 89 5d 0c mov %ebx,0xc(%ebp)
112395: 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 );
}
112398: 8d 65 f4 lea -0xc(%ebp),%esp
11239b: 5b pop %ebx
11239c: 5e pop %esi
11239d: 5f pop %edi
11239e: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
11239f: e9 e0 49 00 00 jmp 116d84 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
1123a4: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
1123a8: 75 13 jne 1123bd <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
1123aa: ff 75 e4 pushl -0x1c(%ebp)
1123ad: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
1123ae: 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 );
}
1123b5: 8d 65 f4 lea -0xc(%ebp),%esp
1123b8: 5b pop %ebx
1123b9: 5e pop %esi
1123ba: 5f pop %edi
1123bb: c9 leave
1123bc: 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;
1123bd: 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;
1123c4: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
1123c7: 8b 5d dc mov -0x24(%ebp),%ebx
1123ca: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
1123cd: 8b 75 e0 mov -0x20(%ebp),%esi
1123d0: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
1123d3: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
1123d6: ff 75 e4 pushl -0x1c(%ebp)
1123d9: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
1123da: c7 45 10 6c 42 11 00 movl $0x11426c,0x10(%ebp)
1123e1: 8b 45 d4 mov -0x2c(%ebp),%eax
1123e4: 89 45 0c mov %eax,0xc(%ebp)
1123e7: 89 55 08 mov %edx,0x8(%ebp)
}
1123ea: 8d 65 f4 lea -0xc(%ebp),%esp
1123ed: 5b pop %ebx
1123ee: 5e pop %esi
1123ef: 5f pop %edi
1123f0: 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 );
1123f1: e9 9a 1b 00 00 jmp 113f90 <_Thread_queue_Enqueue_with_handler>
0010ac2d <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac2d: 55 push %ebp
10ac2e: 89 e5 mov %esp,%ebp
10ac30: 53 push %ebx
10ac31: 83 ec 14 sub $0x14,%esp
10ac34: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac37: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac3a: a1 e0 42 12 00 mov 0x1242e0,%eax
10ac3f: 85 c0 test %eax,%eax
10ac41: 74 19 je 10ac5c <_CORE_mutex_Seize+0x2f>
10ac43: 84 d2 test %dl,%dl
10ac45: 74 15 je 10ac5c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac47: 83 3d 5c 44 12 00 01 cmpl $0x1,0x12445c
10ac4e: 76 0c jbe 10ac5c <_CORE_mutex_Seize+0x2f>
10ac50: 53 push %ebx
10ac51: 6a 12 push $0x12
10ac53: 6a 00 push $0x0
10ac55: 6a 00 push $0x0
10ac57: e8 dc 05 00 00 call 10b238 <_Internal_error_Occurred>
10ac5c: 51 push %ecx
10ac5d: 51 push %ecx
10ac5e: 8d 45 18 lea 0x18(%ebp),%eax
10ac61: 50 push %eax
10ac62: 53 push %ebx
10ac63: 88 55 f4 mov %dl,-0xc(%ebp)
10ac66: e8 89 47 00 00 call 10f3f4 <_CORE_mutex_Seize_interrupt_trylock>
10ac6b: 83 c4 10 add $0x10,%esp
10ac6e: 85 c0 test %eax,%eax
10ac70: 8a 55 f4 mov -0xc(%ebp),%dl
10ac73: 74 48 je 10acbd <_CORE_mutex_Seize+0x90>
10ac75: 84 d2 test %dl,%dl
10ac77: 75 12 jne 10ac8b <_CORE_mutex_Seize+0x5e>
10ac79: ff 75 18 pushl 0x18(%ebp)
10ac7c: 9d popf
10ac7d: a1 28 48 12 00 mov 0x124828,%eax
10ac82: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10ac89: eb 32 jmp 10acbd <_CORE_mutex_Seize+0x90>
10ac8b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ac92: a1 28 48 12 00 mov 0x124828,%eax
10ac97: 89 58 44 mov %ebx,0x44(%eax)
10ac9a: 8b 55 0c mov 0xc(%ebp),%edx
10ac9d: 89 50 20 mov %edx,0x20(%eax)
10aca0: a1 e0 42 12 00 mov 0x1242e0,%eax
10aca5: 40 inc %eax
10aca6: a3 e0 42 12 00 mov %eax,0x1242e0
10acab: ff 75 18 pushl 0x18(%ebp)
10acae: 9d popf
10acaf: 50 push %eax
10acb0: 50 push %eax
10acb1: ff 75 14 pushl 0x14(%ebp)
10acb4: 53 push %ebx
10acb5: e8 26 ff ff ff call 10abe0 <_CORE_mutex_Seize_interrupt_blocking>
10acba: 83 c4 10 add $0x10,%esp
}
10acbd: 8b 5d fc mov -0x4(%ebp),%ebx
10acc0: c9 leave
10acc1: c3 ret
0010ade8 <_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
)
{
10ade8: 55 push %ebp
10ade9: 89 e5 mov %esp,%ebp
10adeb: 53 push %ebx
10adec: 83 ec 10 sub $0x10,%esp
10adef: 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)) ) {
10adf2: 53 push %ebx
10adf3: e8 54 16 00 00 call 10c44c <_Thread_queue_Dequeue>
10adf8: 89 c2 mov %eax,%edx
10adfa: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10adfd: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10adff: 85 d2 test %edx,%edx
10ae01: 75 15 jne 10ae18 <_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 );
10ae03: 9c pushf
10ae04: fa cli
10ae05: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae06: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10ae09: 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 )
10ae0b: 3b 53 40 cmp 0x40(%ebx),%edx
10ae0e: 73 06 jae 10ae16 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae10: 42 inc %edx
10ae11: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae14: 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 );
10ae16: 51 push %ecx
10ae17: 9d popf
}
return status;
}
10ae18: 8b 5d fc mov -0x4(%ebp),%ebx
10ae1b: c9 leave
10ae1c: c3 ret
00109d4c <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109d4c: 55 push %ebp
109d4d: 89 e5 mov %esp,%ebp
109d4f: 57 push %edi
109d50: 56 push %esi
109d51: 53 push %ebx
109d52: 83 ec 2c sub $0x2c,%esp
109d55: 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 ];
109d58: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109d5e: 8b 43 30 mov 0x30(%ebx),%eax
109d61: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109d64: 9c pushf
109d65: fa cli
109d66: 58 pop %eax
pending_events = api->pending_events;
109d67: 8b 17 mov (%edi),%edx
109d69: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109d6c: 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 ) ) {
109d6f: 21 f2 and %esi,%edx
109d71: 75 07 jne 109d7a <_Event_Surrender+0x2e>
_ISR_Enable( level );
109d73: 50 push %eax
109d74: 9d popf
return;
109d75: e9 af 00 00 00 jmp 109e29 <_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() &&
109d7a: 83 3d 24 48 12 00 00 cmpl $0x0,0x124824
109d81: 74 49 je 109dcc <_Event_Surrender+0x80>
109d83: 3b 1d 28 48 12 00 cmp 0x124828,%ebx
109d89: 75 41 jne 109dcc <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d8b: 8b 0d fc 4b 12 00 mov 0x124bfc,%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 ) &&
109d91: 83 f9 02 cmp $0x2,%ecx
109d94: 74 09 je 109d9f <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109d96: 8b 0d fc 4b 12 00 mov 0x124bfc,%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) ||
109d9c: 49 dec %ecx
109d9d: 75 2d jne 109dcc <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109d9f: 39 f2 cmp %esi,%edx
109da1: 74 06 je 109da9 <_Event_Surrender+0x5d>
109da3: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109da7: 74 1f je 109dc8 <_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) );
109da9: 89 d6 mov %edx,%esi
109dab: f7 d6 not %esi
109dad: 23 75 d4 and -0x2c(%ebp),%esi
109db0: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109db2: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109db9: 8b 4b 28 mov 0x28(%ebx),%ecx
109dbc: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109dbe: c7 05 fc 4b 12 00 03 movl $0x3,0x124bfc
109dc5: 00 00 00
}
_ISR_Enable( level );
109dc8: 50 push %eax
109dc9: 9d popf
return;
109dca: eb 5d jmp 109e29 <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109dcc: f6 43 11 01 testb $0x1,0x11(%ebx)
109dd0: 74 55 je 109e27 <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109dd2: 39 f2 cmp %esi,%edx
109dd4: 74 06 je 109ddc <_Event_Surrender+0x90>
109dd6: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dda: 74 4b je 109e27 <_Event_Surrender+0xdb> <== NEVER TAKEN
109ddc: 89 d6 mov %edx,%esi
109dde: f7 d6 not %esi
109de0: 23 75 d4 and -0x2c(%ebp),%esi
109de3: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109de5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109dec: 8b 4b 28 mov 0x28(%ebx),%ecx
109def: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109df1: 50 push %eax
109df2: 9d popf
109df3: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109df4: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109df8: 74 06 je 109e00 <_Event_Surrender+0xb4>
_ISR_Enable( level );
109dfa: 50 push %eax
109dfb: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109dfc: 51 push %ecx
109dfd: 51 push %ecx
109dfe: eb 17 jmp 109e17 <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109e00: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e07: 50 push %eax
109e08: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e09: 83 ec 0c sub $0xc,%esp
109e0c: 8d 43 48 lea 0x48(%ebx),%eax
109e0f: 50 push %eax
109e10: e8 87 30 00 00 call 10ce9c <_Watchdog_Remove>
109e15: 58 pop %eax
109e16: 5a pop %edx
109e17: 68 f8 ff 03 10 push $0x1003fff8
109e1c: 53 push %ebx
109e1d: e8 82 1f 00 00 call 10bda4 <_Thread_Clear_state>
109e22: 83 c4 10 add $0x10,%esp
109e25: eb 02 jmp 109e29 <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e27: 50 push %eax
109e28: 9d popf
}
109e29: 8d 65 f4 lea -0xc(%ebp),%esp
109e2c: 5b pop %ebx
109e2d: 5e pop %esi
109e2e: 5f pop %edi
109e2f: c9 leave
109e30: c3 ret
00109e34 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e34: 55 push %ebp
109e35: 89 e5 mov %esp,%ebp
109e37: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e3a: 8d 45 f4 lea -0xc(%ebp),%eax
109e3d: 50 push %eax
109e3e: ff 75 08 pushl 0x8(%ebp)
109e41: e8 b2 22 00 00 call 10c0f8 <_Thread_Get>
switch ( location ) {
109e46: 83 c4 10 add $0x10,%esp
109e49: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109e4d: 75 49 jne 109e98 <_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 );
109e4f: 9c pushf
109e50: fa cli
109e51: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109e52: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109e59: 3b 05 28 48 12 00 cmp 0x124828,%eax
109e5f: 75 13 jne 109e74 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109e61: 8b 0d fc 4b 12 00 mov 0x124bfc,%ecx
109e67: 49 dec %ecx
109e68: 75 0a jne 109e74 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109e6a: c7 05 fc 4b 12 00 02 movl $0x2,0x124bfc
109e71: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109e74: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109e7b: 52 push %edx
109e7c: 9d popf
109e7d: 52 push %edx
109e7e: 52 push %edx
109e7f: 68 f8 ff 03 10 push $0x1003fff8
109e84: 50 push %eax
109e85: e8 1a 1f 00 00 call 10bda4 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109e8a: a1 e0 42 12 00 mov 0x1242e0,%eax
109e8f: 48 dec %eax
109e90: a3 e0 42 12 00 mov %eax,0x1242e0
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109e95: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109e98: c9 leave
109e99: c3 ret
0010fa4b <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10fa4b: 55 push %ebp
10fa4c: 89 e5 mov %esp,%ebp
10fa4e: 57 push %edi
10fa4f: 56 push %esi
10fa50: 53 push %ebx
10fa51: 83 ec 4c sub $0x4c,%esp
10fa54: 8b 5d 08 mov 0x8(%ebp),%ebx
10fa57: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10fa5a: 8b 43 20 mov 0x20(%ebx),%eax
10fa5d: 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;
10fa60: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10fa67: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10fa6e: 8b 53 10 mov 0x10(%ebx),%edx
10fa71: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10fa74: 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;
10fa77: 8b 7b 30 mov 0x30(%ebx),%edi
10fa7a: 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;
10fa7d: 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 ) {
10fa7f: 8b 7d 0c mov 0xc(%ebp),%edi
10fa82: 01 cf add %ecx,%edi
10fa84: 0f 82 d4 01 00 00 jb 10fc5e <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10fa8a: 52 push %edx
10fa8b: 52 push %edx
10fa8c: 8d 55 e0 lea -0x20(%ebp),%edx
10fa8f: 52 push %edx
10fa90: 8d 55 e4 lea -0x1c(%ebp),%edx
10fa93: 52 push %edx
10fa94: 50 push %eax
10fa95: ff 75 c4 pushl -0x3c(%ebp)
10fa98: 51 push %ecx
10fa99: ff 75 0c pushl 0xc(%ebp)
10fa9c: e8 ba b8 ff ff call 10b35b <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10faa1: 83 c4 20 add $0x20,%esp
10faa4: 84 c0 test %al,%al
10faa6: 0f 84 b2 01 00 00 je 10fc5e <_Heap_Extend+0x213>
10faac: 8b 4d c0 mov -0x40(%ebp),%ecx
10faaf: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10fab6: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10fabd: 31 f6 xor %esi,%esi
10fabf: 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;
10fac6: 8b 43 18 mov 0x18(%ebx),%eax
10fac9: 89 5d b8 mov %ebx,-0x48(%ebp)
10facc: eb 02 jmp 10fad0 <_Heap_Extend+0x85>
10face: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10fad0: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10fad2: 39 c7 cmp %eax,%edi
10fad4: 76 09 jbe 10fadf <_Heap_Extend+0x94>
10fad6: 39 5d 0c cmp %ebx,0xc(%ebp)
10fad9: 0f 82 7d 01 00 00 jb 10fc5c <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fadf: 39 c7 cmp %eax,%edi
10fae1: 74 06 je 10fae9 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fae3: 39 df cmp %ebx,%edi
10fae5: 72 07 jb 10faee <_Heap_Extend+0xa3>
10fae7: eb 08 jmp 10faf1 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fae9: 89 4d d0 mov %ecx,-0x30(%ebp)
10faec: eb 03 jmp 10faf1 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10faee: 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);
10faf1: 8d 43 f8 lea -0x8(%ebx),%eax
10faf4: 89 45 d4 mov %eax,-0x2c(%ebp)
10faf7: 89 d8 mov %ebx,%eax
10faf9: 31 d2 xor %edx,%edx
10fafb: 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);
10fafe: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fb01: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fb04: 75 07 jne 10fb0d <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fb06: 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 )
10fb08: 8b 75 d4 mov -0x2c(%ebp),%esi
10fb0b: eb 08 jmp 10fb15 <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fb0d: 73 06 jae 10fb15 <_Heap_Extend+0xca>
10fb0f: 8b 55 d4 mov -0x2c(%ebp),%edx
10fb12: 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;
10fb15: 8b 45 d4 mov -0x2c(%ebp),%eax
10fb18: 8b 48 04 mov 0x4(%eax),%ecx
10fb1b: 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);
10fb1e: 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 );
10fb20: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fb23: 75 a9 jne 10face <_Heap_Extend+0x83>
10fb25: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fb28: 8b 55 0c mov 0xc(%ebp),%edx
10fb2b: 3b 53 18 cmp 0x18(%ebx),%edx
10fb2e: 73 05 jae 10fb35 <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fb30: 89 53 18 mov %edx,0x18(%ebx)
10fb33: eb 08 jmp 10fb3d <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fb35: 39 7b 1c cmp %edi,0x1c(%ebx)
10fb38: 73 03 jae 10fb3d <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fb3a: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fb3d: 8b 45 e0 mov -0x20(%ebp),%eax
10fb40: 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 =
10fb43: 89 c1 mov %eax,%ecx
10fb45: 29 d1 sub %edx,%ecx
10fb47: 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;
10fb4a: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fb4c: 83 c9 01 or $0x1,%ecx
10fb4f: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fb52: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fb55: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fb57: 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 ) {
10fb5e: 39 53 20 cmp %edx,0x20(%ebx)
10fb61: 76 05 jbe 10fb68 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fb63: 89 53 20 mov %edx,0x20(%ebx)
10fb66: eb 08 jmp 10fb70 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fb68: 39 43 24 cmp %eax,0x24(%ebx)
10fb6b: 73 03 jae 10fb70 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fb6d: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fb70: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fb74: 74 3b je 10fbb1 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fb76: 8b 43 10 mov 0x10(%ebx),%eax
10fb79: 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 );
10fb7c: 8b 4d 0c mov 0xc(%ebp),%ecx
10fb7f: 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;
10fb82: 89 c8 mov %ecx,%eax
10fb84: 31 d2 xor %edx,%edx
10fb86: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fb89: 85 d2 test %edx,%edx
10fb8b: 74 05 je 10fb92 <_Heap_Extend+0x147> <== ALWAYS TAKEN
return value - remainder + alignment;
10fb8d: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED
10fb90: 29 d1 sub %edx,%ecx <== NOT EXECUTED
uintptr_t const new_first_block_begin =
10fb92: 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;
10fb95: 8b 45 d0 mov -0x30(%ebp),%eax
10fb98: 8b 00 mov (%eax),%eax
10fb9a: 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 =
10fb9d: 8b 45 d0 mov -0x30(%ebp),%eax
10fba0: 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;
10fba2: 83 c8 01 or $0x1,%eax
10fba5: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fba8: 89 d8 mov %ebx,%eax
10fbaa: e8 81 fe ff ff call 10fa30 <_Heap_Free_block>
10fbaf: eb 14 jmp 10fbc5 <_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 ) {
10fbb1: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fbb5: 74 0e je 10fbc5 <_Heap_Extend+0x17a>
_Heap_Link_below(
10fbb7: 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;
10fbba: 8b 45 c8 mov -0x38(%ebp),%eax
10fbbd: 29 d0 sub %edx,%eax
10fbbf: 83 c8 01 or $0x1,%eax
10fbc2: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10fbc5: 85 f6 test %esi,%esi
10fbc7: 74 30 je 10fbf9 <_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,
10fbc9: 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(
10fbcc: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fbce: 89 f8 mov %edi,%eax
10fbd0: 31 d2 xor %edx,%edx
10fbd2: f7 73 10 divl 0x10(%ebx)
10fbd5: 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)
10fbd7: 8b 46 04 mov 0x4(%esi),%eax
10fbda: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fbdc: 83 c8 01 or $0x1,%eax
10fbdf: 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;
10fbe3: 8b 46 04 mov 0x4(%esi),%eax
10fbe6: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fbe9: 09 f8 or %edi,%eax
10fbeb: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fbee: 89 f2 mov %esi,%edx
10fbf0: 89 d8 mov %ebx,%eax
10fbf2: e8 39 fe ff ff call 10fa30 <_Heap_Free_block>
10fbf7: eb 21 jmp 10fc1a <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fbf9: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fbfd: 74 1b je 10fc1a <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fbff: 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 );
10fc02: 8b 45 e4 mov -0x1c(%ebp),%eax
10fc05: 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;
10fc08: 8b 7d cc mov -0x34(%ebp),%edi
10fc0b: 8b 57 04 mov 0x4(%edi),%edx
10fc0e: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fc11: 09 d0 or %edx,%eax
10fc13: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fc16: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fc1a: 85 f6 test %esi,%esi
10fc1c: 75 10 jne 10fc2e <_Heap_Extend+0x1e3>
10fc1e: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fc22: 75 0a jne 10fc2e <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fc24: 8b 55 e4 mov -0x1c(%ebp),%edx
10fc27: 89 d8 mov %ebx,%eax
10fc29: e8 02 fe ff ff call 10fa30 <_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
10fc2e: 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(
10fc31: 8b 43 20 mov 0x20(%ebx),%eax
10fc34: 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;
10fc36: 8b 4a 04 mov 0x4(%edx),%ecx
10fc39: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fc3c: 09 c8 or %ecx,%eax
10fc3e: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fc41: 8b 43 30 mov 0x30(%ebx),%eax
10fc44: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fc47: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fc4a: 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 )
10fc4f: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fc53: 74 09 je 10fc5e <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fc55: 8b 55 14 mov 0x14(%ebp),%edx
10fc58: 89 02 mov %eax,(%edx)
10fc5a: eb 02 jmp 10fc5e <_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;
10fc5c: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fc5e: 89 f0 mov %esi,%eax
10fc60: 8d 65 f4 lea -0xc(%ebp),%esp
10fc63: 5b pop %ebx
10fc64: 5e pop %esi
10fc65: 5f pop %edi
10fc66: c9 leave
10fc67: c3 ret
0010f690 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f690: 55 push %ebp
10f691: 89 e5 mov %esp,%ebp
10f693: 57 push %edi
10f694: 56 push %esi
10f695: 53 push %ebx
10f696: 83 ec 14 sub $0x14,%esp
10f699: 8b 4d 08 mov 0x8(%ebp),%ecx
10f69c: 8b 45 0c mov 0xc(%ebp),%eax
10f69f: 8d 58 f8 lea -0x8(%eax),%ebx
10f6a2: 31 d2 xor %edx,%edx
10f6a4: 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);
10f6a7: 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
10f6a9: 8b 41 20 mov 0x20(%ecx),%eax
10f6ac: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f6af: 31 d2 xor %edx,%edx
10f6b1: 39 c3 cmp %eax,%ebx
10f6b3: 72 08 jb 10f6bd <_Heap_Free+0x2d>
10f6b5: 31 d2 xor %edx,%edx
10f6b7: 39 59 24 cmp %ebx,0x24(%ecx)
10f6ba: 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;
10f6bd: 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 ) ) {
10f6bf: 85 d2 test %edx,%edx
10f6c1: 0f 84 21 01 00 00 je 10f7e8 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f6c7: 8b 43 04 mov 0x4(%ebx),%eax
10f6ca: 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;
10f6cd: 89 c6 mov %eax,%esi
10f6cf: 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);
10f6d2: 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;
10f6d5: 31 ff xor %edi,%edi
10f6d7: 3b 55 ec cmp -0x14(%ebp),%edx
10f6da: 72 0a jb 10f6e6 <_Heap_Free+0x56> <== NEVER TAKEN
10f6dc: 31 c0 xor %eax,%eax
10f6de: 39 51 24 cmp %edx,0x24(%ecx)
10f6e1: 0f 93 c0 setae %al
10f6e4: 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;
10f6e6: 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 ) ) {
10f6e8: 85 ff test %edi,%edi
10f6ea: 0f 84 f8 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f6f0: 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 ) ) {
10f6f3: f7 c7 01 00 00 00 test $0x1,%edi
10f6f9: 0f 84 e9 00 00 00 je 10f7e8 <_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;
10f6ff: 83 e7 fe and $0xfffffffe,%edi
10f702: 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
10f705: 8b 41 24 mov 0x24(%ecx),%eax
10f708: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f70b: 31 c0 xor %eax,%eax
10f70d: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f710: 74 0a je 10f71c <_Heap_Free+0x8c>
10f712: 31 c0 xor %eax,%eax
10f714: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f719: 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
10f71c: 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 ) ) {
10f71f: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f723: 75 62 jne 10f787 <_Heap_Free+0xf7>
uintptr_t const prev_size = block->prev_size;
10f725: 8b 03 mov (%ebx),%eax
10f727: 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);
10f72a: 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;
10f72c: 31 ff xor %edi,%edi
10f72e: 3b 5d ec cmp -0x14(%ebp),%ebx
10f731: 72 0a jb 10f73d <_Heap_Free+0xad> <== NEVER TAKEN
10f733: 31 c0 xor %eax,%eax
10f735: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f738: 0f 93 c0 setae %al
10f73b: 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 );
10f73d: 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 ) ) {
10f73f: 85 ff test %edi,%edi
10f741: 0f 84 a1 00 00 00 je 10f7e8 <_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) ) {
10f747: f6 43 04 01 testb $0x1,0x4(%ebx)
10f74b: 0f 84 97 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f751: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f755: 74 1a je 10f771 <_Heap_Free+0xe1>
uintptr_t const size = block_size + prev_size + next_block_size;
10f757: 8b 45 e8 mov -0x18(%ebp),%eax
10f75a: 8d 04 06 lea (%esi,%eax,1),%eax
10f75d: 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;
10f760: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f763: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f766: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f769: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f76c: ff 49 38 decl 0x38(%ecx)
10f76f: eb 33 jmp 10f7a4 <_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;
10f771: 8b 45 f0 mov -0x10(%ebp),%eax
10f774: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f777: 89 c7 mov %eax,%edi
10f779: 83 cf 01 or $0x1,%edi
10f77c: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f77f: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f783: 89 02 mov %eax,(%edx)
10f785: eb 56 jmp 10f7dd <_Heap_Free+0x14d>
}
} else if ( next_is_free ) { /* coalesce next */
10f787: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f78b: 74 24 je 10f7b1 <_Heap_Free+0x121>
uintptr_t const size = block_size + next_block_size;
10f78d: 8b 45 e8 mov -0x18(%ebp),%eax
10f790: 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;
10f792: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f795: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f798: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f79b: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f79e: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f7a1: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f7a4: 89 c2 mov %eax,%edx
10f7a6: 83 ca 01 or $0x1,%edx
10f7a9: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f7ac: 89 04 03 mov %eax,(%ebx,%eax,1)
10f7af: eb 2c jmp 10f7dd <_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;
10f7b1: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f7b4: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f7b7: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f7ba: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f7bd: 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;
10f7c0: 89 f0 mov %esi,%eax
10f7c2: 83 c8 01 or $0x1,%eax
10f7c5: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f7c8: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f7cc: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f7ce: 8b 41 38 mov 0x38(%ecx),%eax
10f7d1: 40 inc %eax
10f7d2: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f7d5: 39 41 3c cmp %eax,0x3c(%ecx)
10f7d8: 73 03 jae 10f7dd <_Heap_Free+0x14d>
stats->max_free_blocks = stats->free_blocks;
10f7da: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f7dd: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f7e0: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f7e3: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f7e6: b0 01 mov $0x1,%al
}
10f7e8: 83 c4 14 add $0x14,%esp
10f7eb: 5b pop %ebx
10f7ec: 5e pop %esi
10f7ed: 5f pop %edi
10f7ee: c9 leave
10f7ef: c3 ret
0011cc34 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11cc34: 55 push %ebp
11cc35: 89 e5 mov %esp,%ebp
11cc37: 57 push %edi
11cc38: 56 push %esi
11cc39: 53 push %ebx
11cc3a: 8b 5d 08 mov 0x8(%ebp),%ebx
11cc3d: 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);
11cc40: 8d 4e f8 lea -0x8(%esi),%ecx
11cc43: 89 f0 mov %esi,%eax
11cc45: 31 d2 xor %edx,%edx
11cc47: 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);
11cc4a: 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
11cc4c: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11cc4f: 31 ff xor %edi,%edi
11cc51: 39 d1 cmp %edx,%ecx
11cc53: 72 0a jb 11cc5f <_Heap_Size_of_alloc_area+0x2b>
11cc55: 31 c0 xor %eax,%eax
11cc57: 39 4b 24 cmp %ecx,0x24(%ebx)
11cc5a: 0f 93 c0 setae %al
11cc5d: 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;
11cc5f: 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 ) ) {
11cc61: 85 ff test %edi,%edi
11cc63: 74 30 je 11cc95 <_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;
11cc65: 8b 41 04 mov 0x4(%ecx),%eax
11cc68: 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);
11cc6b: 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;
11cc6d: 31 ff xor %edi,%edi
11cc6f: 39 d1 cmp %edx,%ecx
11cc71: 72 0a jb 11cc7d <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11cc73: 31 c0 xor %eax,%eax
11cc75: 39 4b 24 cmp %ecx,0x24(%ebx)
11cc78: 0f 93 c0 setae %al
11cc7b: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11cc7d: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11cc7f: 85 ff test %edi,%edi
11cc81: 74 12 je 11cc95 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11cc83: f6 41 04 01 testb $0x1,0x4(%ecx)
11cc87: 74 0c je 11cc95 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11cc89: 29 f1 sub %esi,%ecx
11cc8b: 8d 51 04 lea 0x4(%ecx),%edx
11cc8e: 8b 45 10 mov 0x10(%ebp),%eax
11cc91: 89 10 mov %edx,(%eax)
return true;
11cc93: b0 01 mov $0x1,%al
}
11cc95: 5b pop %ebx
11cc96: 5e pop %esi
11cc97: 5f pop %edi
11cc98: c9 leave
11cc99: c3 ret
0010bc16 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc16: 55 push %ebp
10bc17: 89 e5 mov %esp,%ebp
10bc19: 57 push %edi
10bc1a: 56 push %esi
10bc1b: 53 push %ebx
10bc1c: 83 ec 4c sub $0x4c,%esp
10bc1f: 8b 75 08 mov 0x8(%ebp),%esi
10bc22: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc25: 8b 46 10 mov 0x10(%esi),%eax
10bc28: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc2b: 8b 4e 14 mov 0x14(%esi),%ecx
10bc2e: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc31: 8b 46 20 mov 0x20(%esi),%eax
10bc34: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc37: 8b 4e 24 mov 0x24(%esi),%ecx
10bc3a: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc3d: c7 45 e4 d8 bb 10 00 movl $0x10bbd8,-0x1c(%ebp)
10bc44: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bc48: 74 07 je 10bc51 <_Heap_Walk+0x3b>
10bc4a: c7 45 e4 dd bb 10 00 movl $0x10bbdd,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bc51: 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() ) ) {
10bc53: 83 3d e4 64 12 00 03 cmpl $0x3,0x1264e4
10bc5a: 0f 85 e8 02 00 00 jne 10bf48 <_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)(
10bc60: 52 push %edx
10bc61: ff 76 0c pushl 0xc(%esi)
10bc64: ff 76 08 pushl 0x8(%esi)
10bc67: ff 75 c8 pushl -0x38(%ebp)
10bc6a: ff 75 d0 pushl -0x30(%ebp)
10bc6d: ff 76 1c pushl 0x1c(%esi)
10bc70: ff 76 18 pushl 0x18(%esi)
10bc73: ff 75 d4 pushl -0x2c(%ebp)
10bc76: ff 75 d8 pushl -0x28(%ebp)
10bc79: 68 b1 f7 11 00 push $0x11f7b1
10bc7e: 6a 00 push $0x0
10bc80: 53 push %ebx
10bc81: 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 ) {
10bc84: 83 c4 30 add $0x30,%esp
10bc87: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bc8b: 75 0b jne 10bc98 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bc8d: 50 push %eax
10bc8e: 68 42 f8 11 00 push $0x11f842
10bc93: e9 6b 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bc98: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bc9c: 74 0d je 10bcab <_Heap_Walk+0x95>
(*printer)(
10bc9e: ff 75 d8 pushl -0x28(%ebp)
10bca1: 68 55 f8 11 00 push $0x11f855
10bca6: e9 58 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcab: 8b 45 d4 mov -0x2c(%ebp),%eax
10bcae: 31 d2 xor %edx,%edx
10bcb0: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bcb3: 85 d2 test %edx,%edx
10bcb5: 74 0d je 10bcc4 <_Heap_Walk+0xae>
(*printer)(
10bcb7: ff 75 d4 pushl -0x2c(%ebp)
10bcba: 68 73 f8 11 00 push $0x11f873
10bcbf: e9 3f 02 00 00 jmp 10bf03 <_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;
10bcc4: 8b 45 d0 mov -0x30(%ebp),%eax
10bcc7: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcca: 31 d2 xor %edx,%edx
10bccc: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bccf: 85 d2 test %edx,%edx
10bcd1: 74 0d je 10bce0 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bcd3: ff 75 d0 pushl -0x30(%ebp)
10bcd6: 68 97 f8 11 00 push $0x11f897
10bcdb: e9 23 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bce0: 8b 45 d0 mov -0x30(%ebp),%eax
10bce3: f6 40 04 01 testb $0x1,0x4(%eax)
10bce7: 75 0b jne 10bcf4 <_Heap_Walk+0xde>
(*printer)(
10bce9: 57 push %edi
10bcea: 68 c8 f8 11 00 push $0x11f8c8
10bcef: e9 0f 02 00 00 jmp 10bf03 <_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;
10bcf4: 8b 4d c8 mov -0x38(%ebp),%ecx
10bcf7: 8b 79 04 mov 0x4(%ecx),%edi
10bcfa: 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);
10bcfd: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bcff: f6 47 04 01 testb $0x1,0x4(%edi)
10bd03: 75 0b jne 10bd10 <_Heap_Walk+0xfa>
(*printer)(
10bd05: 56 push %esi
10bd06: 68 f6 f8 11 00 push $0x11f8f6
10bd0b: e9 f3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd10: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd13: 74 0b je 10bd20 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd15: 51 push %ecx <== NOT EXECUTED
10bd16: 68 0b f9 11 00 push $0x11f90b <== NOT EXECUTED
10bd1b: e9 e3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd20: 8b 46 10 mov 0x10(%esi),%eax
10bd23: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd26: 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 );
10bd29: 89 75 dc mov %esi,-0x24(%ebp)
10bd2c: eb 75 jmp 10bda3 <_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;
10bd2e: 31 c0 xor %eax,%eax
10bd30: 39 4e 20 cmp %ecx,0x20(%esi)
10bd33: 77 08 ja 10bd3d <_Heap_Walk+0x127>
10bd35: 31 c0 xor %eax,%eax
10bd37: 39 4e 24 cmp %ecx,0x24(%esi)
10bd3a: 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 ) ) {
10bd3d: 85 c0 test %eax,%eax
10bd3f: 75 0b jne 10bd4c <_Heap_Walk+0x136>
(*printer)(
10bd41: 51 push %ecx
10bd42: 68 3a f9 11 00 push $0x11f93a
10bd47: e9 b7 01 00 00 jmp 10bf03 <_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;
10bd4c: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd4f: 31 d2 xor %edx,%edx
10bd51: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bd54: 85 d2 test %edx,%edx
10bd56: 74 0b je 10bd63 <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bd58: 51 push %ecx
10bd59: 68 5a f9 11 00 push $0x11f95a
10bd5e: e9 a0 01 00 00 jmp 10bf03 <_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;
10bd63: 8b 41 04 mov 0x4(%ecx),%eax
10bd66: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bd69: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bd6e: 74 0b je 10bd7b <_Heap_Walk+0x165>
(*printer)(
10bd70: 51 push %ecx
10bd71: 68 8a f9 11 00 push $0x11f98a
10bd76: e9 88 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bd7b: 8b 41 0c mov 0xc(%ecx),%eax
10bd7e: 3b 45 dc cmp -0x24(%ebp),%eax
10bd81: 74 1a je 10bd9d <_Heap_Walk+0x187>
(*printer)(
10bd83: 83 ec 0c sub $0xc,%esp
10bd86: 50 push %eax
10bd87: 51 push %ecx
10bd88: 68 a6 f9 11 00 push $0x11f9a6
10bd8d: 6a 01 push $0x1
10bd8f: 53 push %ebx
10bd90: ff 55 e4 call *-0x1c(%ebp)
10bd93: 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;
10bd96: 31 c0 xor %eax,%eax
10bd98: e9 ab 01 00 00 jmp 10bf48 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bd9d: 89 4d dc mov %ecx,-0x24(%ebp)
10bda0: 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 ) {
10bda3: 39 f1 cmp %esi,%ecx
10bda5: 75 87 jne 10bd2e <_Heap_Walk+0x118>
10bda7: 89 5d dc mov %ebx,-0x24(%ebp)
10bdaa: eb 02 jmp 10bdae <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bdac: 89 df mov %ebx,%edi
return true;
}
10bdae: 8b 4f 04 mov 0x4(%edi),%ecx
10bdb1: 89 4d cc mov %ecx,-0x34(%ebp)
10bdb4: 83 e1 fe and $0xfffffffe,%ecx
10bdb7: 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);
10bdba: 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;
10bdbd: 31 c0 xor %eax,%eax
10bdbf: 39 5e 20 cmp %ebx,0x20(%esi)
10bdc2: 77 08 ja 10bdcc <_Heap_Walk+0x1b6> <== NEVER TAKEN
10bdc4: 31 c0 xor %eax,%eax
10bdc6: 39 5e 24 cmp %ebx,0x24(%esi)
10bdc9: 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 ) ) {
10bdcc: 85 c0 test %eax,%eax
10bdce: 75 11 jne 10bde1 <_Heap_Walk+0x1cb>
10bdd0: 89 d9 mov %ebx,%ecx
10bdd2: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdd5: 83 ec 0c sub $0xc,%esp
10bdd8: 51 push %ecx
10bdd9: 57 push %edi
10bdda: 68 d8 f9 11 00 push $0x11f9d8
10bddf: eb ac jmp 10bd8d <_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;
10bde1: 3b 7d c8 cmp -0x38(%ebp),%edi
10bde4: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bde7: 8b 45 e0 mov -0x20(%ebp),%eax
10bdea: 31 d2 xor %edx,%edx
10bdec: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10bdef: 85 d2 test %edx,%edx
10bdf1: 74 15 je 10be08 <_Heap_Walk+0x1f2>
10bdf3: 84 c9 test %cl,%cl
10bdf5: 74 11 je 10be08 <_Heap_Walk+0x1f2>
10bdf7: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdfa: 83 ec 0c sub $0xc,%esp
10bdfd: ff 75 e0 pushl -0x20(%ebp)
10be00: 57 push %edi
10be01: 68 05 fa 11 00 push $0x11fa05
10be06: eb 85 jmp 10bd8d <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be08: 8b 45 d4 mov -0x2c(%ebp),%eax
10be0b: 39 45 e0 cmp %eax,-0x20(%ebp)
10be0e: 73 18 jae 10be28 <_Heap_Walk+0x212>
10be10: 84 c9 test %cl,%cl
10be12: 74 14 je 10be28 <_Heap_Walk+0x212> <== NEVER TAKEN
10be14: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be17: 52 push %edx
10be18: 52 push %edx
10be19: 50 push %eax
10be1a: ff 75 e0 pushl -0x20(%ebp)
10be1d: 57 push %edi
10be1e: 68 33 fa 11 00 push $0x11fa33
10be23: e9 65 ff ff ff jmp 10bd8d <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be28: 39 fb cmp %edi,%ebx
10be2a: 77 18 ja 10be44 <_Heap_Walk+0x22e>
10be2c: 84 c9 test %cl,%cl
10be2e: 74 14 je 10be44 <_Heap_Walk+0x22e>
10be30: 89 d9 mov %ebx,%ecx
10be32: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be35: 83 ec 0c sub $0xc,%esp
10be38: 51 push %ecx
10be39: 57 push %edi
10be3a: 68 5e fa 11 00 push $0x11fa5e
10be3f: e9 49 ff ff ff jmp 10bd8d <_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;
10be44: 8b 4d cc mov -0x34(%ebp),%ecx
10be47: 83 e1 01 and $0x1,%ecx
10be4a: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10be4d: f6 43 04 01 testb $0x1,0x4(%ebx)
10be51: 0f 85 ba 00 00 00 jne 10bf11 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10be57: 8b 46 08 mov 0x8(%esi),%eax
10be5a: 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 ?
10be5d: 8b 4f 08 mov 0x8(%edi),%ecx
10be60: 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)(
10be63: ba 7e f7 11 00 mov $0x11f77e,%edx
10be68: 3b 4e 0c cmp 0xc(%esi),%ecx
10be6b: 74 0e je 10be7b <_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)" : "")
10be6d: ba b5 f6 11 00 mov $0x11f6b5,%edx
10be72: 39 f1 cmp %esi,%ecx
10be74: 75 05 jne 10be7b <_Heap_Walk+0x265>
10be76: ba 8d f7 11 00 mov $0x11f78d,%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 ?
10be7b: 8b 47 0c mov 0xc(%edi),%eax
10be7e: 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)(
10be81: b8 97 f7 11 00 mov $0x11f797,%eax
10be86: 8b 4d c0 mov -0x40(%ebp),%ecx
10be89: 39 4d cc cmp %ecx,-0x34(%ebp)
10be8c: 74 0f je 10be9d <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10be8e: b8 b5 f6 11 00 mov $0x11f6b5,%eax
10be93: 39 75 cc cmp %esi,-0x34(%ebp)
10be96: 75 05 jne 10be9d <_Heap_Walk+0x287>
10be98: b8 a7 f7 11 00 mov $0x11f7a7,%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)(
10be9d: 83 ec 0c sub $0xc,%esp
10bea0: 52 push %edx
10bea1: ff 75 b4 pushl -0x4c(%ebp)
10bea4: 50 push %eax
10bea5: ff 75 cc pushl -0x34(%ebp)
10bea8: ff 75 e0 pushl -0x20(%ebp)
10beab: 57 push %edi
10beac: 68 92 fa 11 00 push $0x11fa92
10beb1: 6a 00 push $0x0
10beb3: ff 75 dc pushl -0x24(%ebp)
10beb6: 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 ) {
10beb9: 8b 03 mov (%ebx),%eax
10bebb: 83 c4 30 add $0x30,%esp
10bebe: 39 45 e0 cmp %eax,-0x20(%ebp)
10bec1: 74 16 je 10bed9 <_Heap_Walk+0x2c3>
10bec3: 89 d9 mov %ebx,%ecx
10bec5: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bec8: 56 push %esi
10bec9: 51 push %ecx
10beca: 50 push %eax
10becb: ff 75 e0 pushl -0x20(%ebp)
10bece: 57 push %edi
10becf: 68 c7 fa 11 00 push $0x11fac7
10bed4: e9 b4 fe ff ff jmp 10bd8d <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bed9: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bedd: 75 0b jne 10beea <_Heap_Walk+0x2d4>
10bedf: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bee2: 57 push %edi
10bee3: 68 00 fb 11 00 push $0x11fb00
10bee8: eb 19 jmp 10bf03 <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10beea: 8b 46 08 mov 0x8(%esi),%eax
10beed: eb 07 jmp 10bef6 <_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 ) {
10beef: 39 f8 cmp %edi,%eax
10bef1: 74 4a je 10bf3d <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10bef3: 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 ) {
10bef6: 39 f0 cmp %esi,%eax
10bef8: 75 f5 jne 10beef <_Heap_Walk+0x2d9>
10befa: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10befd: 57 push %edi
10befe: 68 6b fb 11 00 push $0x11fb6b
10bf03: 6a 01 push $0x1
10bf05: 53 push %ebx
10bf06: ff 55 e4 call *-0x1c(%ebp)
10bf09: 83 c4 10 add $0x10,%esp
10bf0c: e9 85 fe ff ff jmp 10bd96 <_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) {
10bf11: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf15: 74 0e je 10bf25 <_Heap_Walk+0x30f>
(*printer)(
10bf17: 83 ec 0c sub $0xc,%esp
10bf1a: ff 75 e0 pushl -0x20(%ebp)
10bf1d: 57 push %edi
10bf1e: 68 2f fb 11 00 push $0x11fb2f
10bf23: eb 0d jmp 10bf32 <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf25: 51 push %ecx
10bf26: 51 push %ecx
10bf27: ff 37 pushl (%edi)
10bf29: ff 75 e0 pushl -0x20(%ebp)
10bf2c: 57 push %edi
10bf2d: 68 46 fb 11 00 push $0x11fb46
10bf32: 6a 00 push $0x0
10bf34: ff 75 dc pushl -0x24(%ebp)
10bf37: ff 55 e4 call *-0x1c(%ebp)
10bf3a: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf3d: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bf40: 0f 85 66 fe ff ff jne 10bdac <_Heap_Walk+0x196>
return true;
10bf46: b0 01 mov $0x1,%al
}
10bf48: 8d 65 f4 lea -0xc(%ebp),%esp
10bf4b: 5b pop %ebx
10bf4c: 5e pop %esi
10bf4d: 5f pop %edi
10bf4e: c9 leave
10bf4f: c3 ret
0010b238 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b238: 55 push %ebp
10b239: 89 e5 mov %esp,%ebp
10b23b: 53 push %ebx
10b23c: 83 ec 08 sub $0x8,%esp
10b23f: 8b 45 08 mov 0x8(%ebp),%eax
10b242: 8b 55 0c mov 0xc(%ebp),%edx
10b245: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b248: a3 98 43 12 00 mov %eax,0x124398
_Internal_errors_What_happened.is_internal = is_internal;
10b24d: 88 15 9c 43 12 00 mov %dl,0x12439c
_Internal_errors_What_happened.the_error = the_error;
10b253: 89 1d a0 43 12 00 mov %ebx,0x1243a0
_User_extensions_Fatal( the_source, is_internal, the_error );
10b259: 53 push %ebx
10b25a: 0f b6 d2 movzbl %dl,%edx
10b25d: 52 push %edx
10b25e: 50 push %eax
10b25f: e8 f7 19 00 00 call 10cc5b <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b264: c7 05 5c 44 12 00 05 movl $0x5,0x12445c <== NOT EXECUTED
10b26b: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b26e: fa cli <== NOT EXECUTED
10b26f: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b271: f4 hlt <== NOT EXECUTED
10b272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b275: eb fe jmp 10b275 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b2c8 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b2c8: 55 push %ebp
10b2c9: 89 e5 mov %esp,%ebp
10b2cb: 56 push %esi
10b2cc: 53 push %ebx
10b2cd: 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;
10b2d0: 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 )
10b2d2: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b2d6: 74 53 je 10b32b <_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 );
10b2d8: 8d 73 20 lea 0x20(%ebx),%esi
10b2db: 83 ec 0c sub $0xc,%esp
10b2de: 56 push %esi
10b2df: e8 38 f7 ff ff call 10aa1c <_Chain_Get>
10b2e4: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b2e6: 83 c4 10 add $0x10,%esp
10b2e9: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b2ed: 74 3c je 10b32b <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b2ef: 85 c0 test %eax,%eax
10b2f1: 75 1a jne 10b30d <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b2f3: 83 ec 0c sub $0xc,%esp
10b2f6: 53 push %ebx
10b2f7: e8 60 00 00 00 call 10b35c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b2fc: 89 34 24 mov %esi,(%esp)
10b2ff: e8 18 f7 ff ff call 10aa1c <_Chain_Get>
10b304: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b306: 83 c4 10 add $0x10,%esp
10b309: 85 c0 test %eax,%eax
10b30b: 74 1e je 10b32b <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b30d: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b311: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b315: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b317: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b31b: 31 d2 xor %edx,%edx
10b31d: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b31f: c1 e0 02 shl $0x2,%eax
10b322: 03 43 30 add 0x30(%ebx),%eax
10b325: ff 08 decl (%eax)
information->inactive--;
10b327: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b32b: 89 c8 mov %ecx,%eax
10b32d: 8d 65 f8 lea -0x8(%ebp),%esp
10b330: 5b pop %ebx
10b331: 5e pop %esi
10b332: c9 leave
10b333: c3 ret
0010b650 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b650: 55 push %ebp
10b651: 89 e5 mov %esp,%ebp
10b653: 57 push %edi
10b654: 56 push %esi
10b655: 53 push %ebx
10b656: 83 ec 0c sub $0xc,%esp
10b659: 8b 75 08 mov 0x8(%ebp),%esi
10b65c: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b65f: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b661: 66 85 ff test %di,%di
10b664: 74 37 je 10b69d <_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 );
10b666: 83 ec 0c sub $0xc,%esp
10b669: 56 push %esi
10b66a: e8 81 41 00 00 call 10f7f0 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b66f: 83 c4 10 add $0x10,%esp
10b672: 85 c0 test %eax,%eax
10b674: 74 27 je 10b69d <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b676: 0f b7 ff movzwl %di,%edi
10b679: 39 c7 cmp %eax,%edi
10b67b: 77 20 ja 10b69d <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b67d: 8b 04 b5 b8 42 12 00 mov 0x1242b8(,%esi,4),%eax
10b684: 85 c0 test %eax,%eax
10b686: 74 15 je 10b69d <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b688: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b68b: 85 db test %ebx,%ebx
10b68d: 74 0e je 10b69d <_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;
10b68f: 31 c0 xor %eax,%eax
10b691: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b696: 0f 95 c0 setne %al
10b699: f7 d8 neg %eax
10b69b: 21 c3 and %eax,%ebx
#endif
return info;
}
10b69d: 89 d8 mov %ebx,%eax
10b69f: 8d 65 f4 lea -0xc(%ebp),%esp
10b6a2: 5b pop %ebx
10b6a3: 5e pop %esi
10b6a4: 5f pop %edi
10b6a5: c9 leave
10b6a6: c3 ret
00118ab4 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118ab4: 55 push %ebp
118ab5: 89 e5 mov %esp,%ebp
118ab7: 53 push %ebx
118ab8: 8b 55 08 mov 0x8(%ebp),%edx
118abb: 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;
118abe: b8 01 00 00 00 mov $0x1,%eax
118ac3: 2b 42 08 sub 0x8(%edx),%eax
118ac6: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118ac9: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118acd: 39 c3 cmp %eax,%ebx
118acf: 72 12 jb 118ae3 <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118ad1: 8b 52 1c mov 0x1c(%edx),%edx
118ad4: 8b 04 82 mov (%edx,%eax,4),%eax
118ad7: 85 c0 test %eax,%eax
118ad9: 74 08 je 118ae3 <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118adb: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118ae1: eb 08 jmp 118aeb <_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;
118ae3: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118ae9: 31 c0 xor %eax,%eax
}
118aeb: 5b pop %ebx
118aec: c9 leave
118aed: c3 ret
0010c86c <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c86c: 55 push %ebp
10c86d: 89 e5 mov %esp,%ebp
10c86f: 53 push %ebx
10c870: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c873: 8b 45 08 mov 0x8(%ebp),%eax
10c876: 85 c0 test %eax,%eax
10c878: 75 08 jne 10c882 <_Objects_Id_to_name+0x16>
10c87a: a1 94 78 12 00 mov 0x127894,%eax
10c87f: 8b 40 08 mov 0x8(%eax),%eax
10c882: 89 c2 mov %eax,%edx
10c884: c1 ea 18 shr $0x18,%edx
10c887: 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 )
10c88a: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c88d: bb 03 00 00 00 mov $0x3,%ebx
10c892: 83 f9 02 cmp $0x2,%ecx
10c895: 77 36 ja 10c8cd <_Objects_Id_to_name+0x61>
10c897: eb 3b jmp 10c8d4 <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c899: 89 c1 mov %eax,%ecx
10c89b: 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 ];
10c89e: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8a1: 85 d2 test %edx,%edx
10c8a3: 74 28 je 10c8cd <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8a5: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8a9: 75 22 jne 10c8cd <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8ab: 51 push %ecx
10c8ac: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8af: 51 push %ecx
10c8b0: 50 push %eax
10c8b1: 52 push %edx
10c8b2: e8 5d ff ff ff call 10c814 <_Objects_Get>
if ( !the_object )
10c8b7: 83 c4 10 add $0x10,%esp
10c8ba: 85 c0 test %eax,%eax
10c8bc: 74 0f je 10c8cd <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c8be: 8b 50 0c mov 0xc(%eax),%edx
10c8c1: 8b 45 0c mov 0xc(%ebp),%eax
10c8c4: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c8c6: e8 9f 09 00 00 call 10d26a <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c8cb: 31 db xor %ebx,%ebx
}
10c8cd: 89 d8 mov %ebx,%eax
10c8cf: 8b 5d fc mov -0x4(%ebp),%ebx
10c8d2: c9 leave
10c8d3: 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 ] )
10c8d4: 8b 14 95 24 73 12 00 mov 0x127324(,%edx,4),%edx
10c8db: 85 d2 test %edx,%edx
10c8dd: 75 ba jne 10c899 <_Objects_Id_to_name+0x2d>
10c8df: eb ec jmp 10c8cd <_Objects_Id_to_name+0x61>
0010e2bc <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e2bc: 55 push %ebp
10e2bd: 89 e5 mov %esp,%ebp
10e2bf: 57 push %edi
10e2c0: 56 push %esi
10e2c1: 53 push %ebx
10e2c2: 83 ec 30 sub $0x30,%esp
10e2c5: 8b 75 08 mov 0x8(%ebp),%esi
10e2c8: 8b 5d 14 mov 0x14(%ebp),%ebx
10e2cb: 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 );
10e2ce: 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(
10e2d1: 50 push %eax
10e2d2: 56 push %esi
10e2d3: 68 f0 cc 12 00 push $0x12ccf0
10e2d8: 88 55 d4 mov %dl,-0x2c(%ebp)
10e2db: e8 f4 2a 00 00 call 110dd4 <_Objects_Get>
switch ( location ) {
10e2e0: 83 c4 10 add $0x10,%esp
10e2e3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e2e7: 8a 55 d4 mov -0x2c(%ebp),%dl
10e2ea: 0f 85 aa 00 00 00 jne 10e39a <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e2f0: 8b 78 14 mov 0x14(%eax),%edi
10e2f3: 89 f9 mov %edi,%ecx
10e2f5: 83 e1 03 and $0x3,%ecx
10e2f8: 49 dec %ecx
10e2f9: 75 0a jne 10e305 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e2fb: e8 26 35 00 00 call 111826 <_Thread_Enable_dispatch>
10e300: e9 95 00 00 00 jmp 10e39a <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e305: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e308: 8b 48 68 mov 0x68(%eax),%ecx
10e30b: 39 4d 10 cmp %ecx,0x10(%ebp)
10e30e: 73 15 jae 10e325 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e310: e8 11 35 00 00 call 111826 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e315: e8 6a 8b 00 00 call 116e84 <__errno>
10e31a: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e320: e9 80 00 00 00 jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e325: 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 )
10e32c: 31 c9 xor %ecx,%ecx
10e32e: 84 d2 test %dl,%dl
10e330: 74 09 je 10e33b <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e332: 81 e7 00 40 00 00 and $0x4000,%edi
10e338: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e33b: 52 push %edx
10e33c: 52 push %edx
10e33d: ff 75 1c pushl 0x1c(%ebp)
10e340: 0f b6 c9 movzbl %cl,%ecx
10e343: 51 push %ecx
10e344: 8d 55 e0 lea -0x20(%ebp),%edx
10e347: 52 push %edx
10e348: ff 75 0c pushl 0xc(%ebp)
10e34b: 56 push %esi
10e34c: 83 c0 1c add $0x1c,%eax
10e34f: 50 push %eax
10e350: e8 7f 1c 00 00 call 10ffd4 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e355: 83 c4 20 add $0x20,%esp
10e358: e8 c9 34 00 00 call 111826 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e35d: a1 68 cd 12 00 mov 0x12cd68,%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);
10e362: 8b 50 24 mov 0x24(%eax),%edx
10e365: c1 fa 1f sar $0x1f,%edx
10e368: 8b 48 24 mov 0x24(%eax),%ecx
10e36b: 31 d1 xor %edx,%ecx
10e36d: 89 0b mov %ecx,(%ebx)
10e36f: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e371: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e375: 75 05 jne 10e37c <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e377: 8b 45 e0 mov -0x20(%ebp),%eax
10e37a: eb 2c jmp 10e3a8 <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e37c: e8 03 8b 00 00 call 116e84 <__errno>
10e381: 89 c3 mov %eax,%ebx
10e383: 83 ec 0c sub $0xc,%esp
10e386: a1 68 cd 12 00 mov 0x12cd68,%eax
10e38b: ff 70 34 pushl 0x34(%eax)
10e38e: e8 ed 01 00 00 call 10e580 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e393: 89 03 mov %eax,(%ebx)
10e395: 83 c4 10 add $0x10,%esp
10e398: eb 0b jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e39a: e8 e5 8a 00 00 call 116e84 <__errno>
10e39f: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3a5: 83 c8 ff or $0xffffffff,%eax
}
10e3a8: 8d 65 f4 lea -0xc(%ebp),%esp
10e3ab: 5b pop %ebx
10e3ac: 5e pop %esi
10e3ad: 5f pop %edi
10e3ae: c9 leave
10e3af: 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 e8 da ff ff jmp 10c47e <_Thread_Enable_dispatch>
0010fbe4 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10fbe4: 55 push %ebp
10fbe5: 89 e5 mov %esp,%ebp
10fbe7: 57 push %edi
10fbe8: 56 push %esi
10fbe9: 53 push %ebx
10fbea: 83 ec 28 sub $0x28,%esp
10fbed: 8b 55 08 mov 0x8(%ebp),%edx
10fbf0: 8b 5d 0c mov 0xc(%ebp),%ebx
10fbf3: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fbf6: ff 33 pushl (%ebx)
10fbf8: 89 55 e0 mov %edx,-0x20(%ebp)
10fbfb: e8 c4 ff ff ff call 10fbc4 <_POSIX_Priority_Is_valid>
10fc00: 83 c4 10 add $0x10,%esp
return EINVAL;
10fc03: 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 ) )
10fc08: 84 c0 test %al,%al
10fc0a: 8b 55 e0 mov -0x20(%ebp),%edx
10fc0d: 0f 84 a4 00 00 00 je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fc13: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fc19: 8b 45 14 mov 0x14(%ebp),%eax
10fc1c: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fc22: 85 d2 test %edx,%edx
10fc24: 75 0b jne 10fc31 <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fc26: c7 07 01 00 00 00 movl $0x1,(%edi)
10fc2c: e9 83 00 00 00 jmp 10fcb4 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fc31: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fc33: 83 fa 01 cmp $0x1,%edx
10fc36: 74 7f je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fc38: 83 fa 02 cmp $0x2,%edx
10fc3b: 75 08 jne 10fc45 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fc3d: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fc43: eb 72 jmp 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fc45: 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 ) {
10fc4a: 83 fa 04 cmp $0x4,%edx
10fc4d: 75 68 jne 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fc4f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fc53: 75 06 jne 10fc5b <_POSIX_Thread_Translate_sched_param+0x77>
10fc55: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fc59: 74 5c je 10fcb7 <_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) &&
10fc5b: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fc5f: 75 0b jne 10fc6c <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fc61: 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) &&
10fc66: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fc6a: 74 4b je 10fcb7 <_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 ) <
10fc6c: 83 ec 0c sub $0xc,%esp
10fc6f: 8d 43 08 lea 0x8(%ebx),%eax
10fc72: 50 push %eax
10fc73: e8 04 de ff ff call 10da7c <_Timespec_To_ticks>
10fc78: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fc7b: 8d 43 10 lea 0x10(%ebx),%eax
10fc7e: 89 04 24 mov %eax,(%esp)
10fc81: e8 f6 dd ff ff call 10da7c <_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 ) <
10fc86: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fc89: 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 ) <
10fc8e: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fc91: 72 24 jb 10fcb7 <_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 ) )
10fc93: 83 ec 0c sub $0xc,%esp
10fc96: ff 73 04 pushl 0x4(%ebx)
10fc99: e8 26 ff ff ff call 10fbc4 <_POSIX_Priority_Is_valid>
10fc9e: 83 c4 10 add $0x10,%esp
10fca1: 84 c0 test %al,%al
10fca3: 74 12 je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fca5: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fcab: 8b 45 14 mov 0x14(%ebp),%eax
10fcae: c7 00 ed a7 10 00 movl $0x10a7ed,(%eax)
return 0;
10fcb4: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fcb7: 89 f0 mov %esi,%eax
10fcb9: 8d 65 f4 lea -0xc(%ebp),%esp
10fcbc: 5b pop %ebx
10fcbd: 5e pop %esi
10fcbe: 5f pop %edi
10fcbf: c9 leave
10fcc0: c3 ret
0010a4f0 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a4f0: 55 push %ebp
10a4f1: 89 e5 mov %esp,%ebp
10a4f3: 57 push %edi
10a4f4: 56 push %esi
10a4f5: 53 push %ebx
10a4f6: 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;
10a4f9: 8b 3d 10 12 12 00 mov 0x121210,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a4ff: 8b 15 0c 12 12 00 mov 0x12120c,%edx
if ( !user_threads || maximum == 0 )
10a505: 85 d2 test %edx,%edx
10a507: 74 54 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a509: 85 ff test %edi,%edi
10a50b: 74 50 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a50d: 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 );
10a50f: 8d 75 a4 lea -0x5c(%ebp),%esi
10a512: 83 ec 0c sub $0xc,%esp
10a515: 56 push %esi
10a516: 89 55 94 mov %edx,-0x6c(%ebp)
10a519: e8 a6 57 00 00 call 10fcc4 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a51e: 5a pop %edx
10a51f: 59 pop %ecx
10a520: 6a 02 push $0x2
10a522: 56 push %esi
10a523: e8 c4 57 00 00 call 10fcec <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a528: 59 pop %ecx
10a529: 58 pop %eax
10a52a: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a52e: 56 push %esi
10a52f: e8 e4 57 00 00 call 10fd18 <pthread_attr_setstacksize>
status = pthread_create(
10a534: 6a 00 push $0x0
10a536: ff 34 df pushl (%edi,%ebx,8)
10a539: 56 push %esi
10a53a: 8d 45 e4 lea -0x1c(%ebp),%eax
10a53d: 50 push %eax
10a53e: e8 e5 fc ff ff call 10a228 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a543: 83 c4 20 add $0x20,%esp
10a546: 85 c0 test %eax,%eax
10a548: 8b 55 94 mov -0x6c(%ebp),%edx
10a54b: 74 0b je 10a558 <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a54d: 52 push %edx
10a54e: 50 push %eax
10a54f: 6a 01 push $0x1
10a551: 6a 02 push $0x2
10a553: e8 f0 1b 00 00 call 10c148 <_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++ ) {
10a558: 43 inc %ebx
10a559: 39 d3 cmp %edx,%ebx
10a55b: 72 b5 jb 10a512 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a55d: 8d 65 f4 lea -0xc(%ebp),%esp
10a560: 5b pop %ebx
10a561: 5e pop %esi
10a562: 5f pop %edi
10a563: c9 leave
10a564: 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 3c 0e 00 00 call 10fb88 <_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 19 cf ff ff call 10bc90 <_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 ff 0d 00 00 call 10fb88 <_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 cf df ff ff jmp 10cd7c <_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 a8 ce ff ff call 10bc90 <_Thread_Change_priority>
10ede8: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10edeb: c9 leave
10edec: c3 ret
0010a2b0 <_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)
{
10a2b0: 55 push %ebp
10a2b1: 89 e5 mov %esp,%ebp
10a2b3: 53 push %ebx
10a2b4: 83 ec 04 sub $0x4,%esp
10a2b7: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a2ba: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a2bd: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a2c1: 75 06 jne 10a2c9 <_POSIX_Timer_TSR+0x19>
10a2c3: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a2c7: 74 34 je 10a2fd <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a2c9: 83 ec 0c sub $0xc,%esp
10a2cc: 53 push %ebx
10a2cd: 68 b0 a2 10 00 push $0x10a2b0
10a2d2: ff 73 08 pushl 0x8(%ebx)
10a2d5: ff 73 64 pushl 0x64(%ebx)
10a2d8: 8d 43 10 lea 0x10(%ebx),%eax
10a2db: 50 push %eax
10a2dc: e8 af 56 00 00 call 10f990 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a2e1: 83 c4 20 add $0x20,%esp
10a2e4: 84 c0 test %al,%al
10a2e6: 74 30 je 10a318 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a2e8: 83 ec 0c sub $0xc,%esp
10a2eb: 8d 43 6c lea 0x6c(%ebx),%eax
10a2ee: 50 push %eax
10a2ef: e8 5c 14 00 00 call 10b750 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2f4: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a2f8: 83 c4 10 add $0x10,%esp
10a2fb: eb 04 jmp 10a301 <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a2fd: 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 ) ) {
10a301: 50 push %eax
10a302: 50 push %eax
10a303: ff 73 44 pushl 0x44(%ebx)
10a306: ff 73 38 pushl 0x38(%ebx)
10a309: e8 56 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;
10a30e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a315: 83 c4 10 add $0x10,%esp
}
10a318: 8b 5d fc mov -0x4(%ebp),%ebx
10a31b: c9 leave
10a31c: c3 ret
00110b68 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110b68: 55 push %ebp
110b69: 89 e5 mov %esp,%ebp
110b6b: 57 push %edi
110b6c: 56 push %esi
110b6d: 53 push %ebx
110b6e: 83 ec 68 sub $0x68,%esp
110b71: 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,
110b74: 6a 01 push $0x1
110b76: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110b7a: 50 push %eax
110b7b: 8d 45 dc lea -0x24(%ebp),%eax
110b7e: 50 push %eax
110b7f: 53 push %ebx
110b80: ff 75 08 pushl 0x8(%ebp)
110b83: e8 8c 00 00 00 call 110c14 <_POSIX_signals_Clear_signals>
110b88: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110b8b: 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,
110b8d: 84 c0 test %al,%al
110b8f: 74 78 je 110c09 <_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 )
110b91: 6b d3 0c imul $0xc,%ebx,%edx
110b94: 8b 82 64 48 12 00 mov 0x124864(%edx),%eax
110b9a: 83 f8 01 cmp $0x1,%eax
110b9d: 74 6a je 110c09 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110b9f: 8b 4d 08 mov 0x8(%ebp),%ecx
110ba2: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110ba8: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110bab: 0b 8a 60 48 12 00 or 0x124860(%edx),%ecx
110bb1: 8b 75 08 mov 0x8(%ebp),%esi
110bb4: 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,
110bba: 8d 7d b4 lea -0x4c(%ebp),%edi
110bbd: 8b 35 28 48 12 00 mov 0x124828,%esi
110bc3: 83 c6 20 add $0x20,%esi
110bc6: b9 0a 00 00 00 mov $0xa,%ecx
110bcb: 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 ) {
110bcd: 83 ba 5c 48 12 00 02 cmpl $0x2,0x12485c(%edx)
110bd4: 75 09 jne 110bdf <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110bd6: 52 push %edx
110bd7: 6a 00 push $0x0
110bd9: 8d 55 dc lea -0x24(%ebp),%edx
110bdc: 52 push %edx
110bdd: eb 03 jmp 110be2 <_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 );
110bdf: 83 ec 0c sub $0xc,%esp
110be2: 53 push %ebx
110be3: ff d0 call *%eax
break;
110be5: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110be8: 8b 3d 28 48 12 00 mov 0x124828,%edi
110bee: 83 c7 20 add $0x20,%edi
110bf1: 8d 75 b4 lea -0x4c(%ebp),%esi
110bf4: b9 0a 00 00 00 mov $0xa,%ecx
110bf9: 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;
110bfb: 8b 75 a4 mov -0x5c(%ebp),%esi
110bfe: 8b 4d 08 mov 0x8(%ebp),%ecx
110c01: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110c07: b1 01 mov $0x1,%cl
}
110c09: 88 c8 mov %cl,%al
110c0b: 8d 65 f4 lea -0xc(%ebp),%esp
110c0e: 5b pop %ebx
110c0f: 5e pop %esi
110c10: 5f pop %edi
110c11: c9 leave
110c12: c3 ret
001110fc <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
1110fc: 55 push %ebp
1110fd: 89 e5 mov %esp,%ebp
1110ff: 53 push %ebx
111100: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
111103: 9c pushf
111104: fa cli
111105: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
111106: 6b c1 0c imul $0xc,%ecx,%eax
111109: 83 b8 5c 48 12 00 02 cmpl $0x2,0x12485c(%eax)
111110: 75 0e jne 111120 <_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 );
111112: 8d 98 58 4a 12 00 lea 0x124a58(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111118: 39 98 54 4a 12 00 cmp %ebx,0x124a54(%eax)
11111e: 75 0e jne 11112e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
111120: 49 dec %ecx
111121: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
111126: d3 c0 rol %cl,%eax
111128: 21 05 50 4a 12 00 and %eax,0x124a50
}
_ISR_Enable( level );
11112e: 52 push %edx
11112f: 9d popf
}
111130: 5b pop %ebx
111131: c9 leave
111132: c3 ret
0010ab58 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10ab58: 55 push %ebp
10ab59: 89 e5 mov %esp,%ebp
10ab5b: 56 push %esi
10ab5c: 53 push %ebx
10ab5d: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab60: b8 1b 00 00 00 mov $0x1b,%eax
10ab65: 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(
10ab6a: 8d 48 ff lea -0x1(%eax),%ecx
10ab6d: 89 de mov %ebx,%esi
10ab6f: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab71: 85 d6 test %edx,%esi
10ab73: 75 1e jne 10ab93 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab75: 40 inc %eax
10ab76: 83 f8 20 cmp $0x20,%eax
10ab79: 75 ef jne 10ab6a <_POSIX_signals_Get_lowest+0x12>
10ab7b: b0 01 mov $0x1,%al
10ab7d: 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(
10ab82: 8d 48 ff lea -0x1(%eax),%ecx
10ab85: 89 de mov %ebx,%esi
10ab87: 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 ) ) {
10ab89: 85 d6 test %edx,%esi
10ab8b: 75 06 jne 10ab93 <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10ab8d: 40 inc %eax
10ab8e: 83 f8 1b cmp $0x1b,%eax
10ab91: 75 ef jne 10ab82 <_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;
}
10ab93: 5b pop %ebx
10ab94: 5e pop %esi
10ab95: c9 leave
10ab96: c3 ret
0012190c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
12190c: 55 push %ebp
12190d: 89 e5 mov %esp,%ebp
12190f: 57 push %edi
121910: 56 push %esi
121911: 53 push %ebx
121912: 83 ec 0c sub $0xc,%esp
121915: 8b 5d 08 mov 0x8(%ebp),%ebx
121918: 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 ];
12191b: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
121921: 8d 4e ff lea -0x1(%esi),%ecx
121924: ba 01 00 00 00 mov $0x1,%edx
121929: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
12192b: 8b 4b 10 mov 0x10(%ebx),%ecx
12192e: 89 cf mov %ecx,%edi
121930: 81 e7 00 80 00 10 and $0x10008000,%edi
121936: 81 ff 00 80 00 10 cmp $0x10008000,%edi
12193c: 75 58 jne 121996 <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
12193e: 85 53 30 test %edx,0x30(%ebx)
121941: 75 12 jne 121955 <_POSIX_signals_Unblock_thread+0x49>
121943: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
121949: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
12194b: 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) ) {
12194d: 85 c2 test %eax,%edx
12194f: 0f 84 b0 00 00 00 je 121a05 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
121955: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
12195c: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
12195f: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
121963: 75 12 jne 121977 <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
121965: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
121967: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
12196e: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
121975: eb 0c jmp 121983 <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
121977: b9 03 00 00 00 mov $0x3,%ecx
12197c: 89 c7 mov %eax,%edi
12197e: 8b 75 10 mov 0x10(%ebp),%esi
121981: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
121983: 83 ec 0c sub $0xc,%esp
121986: 53 push %ebx
121987: e8 68 f5 fe ff call 110ef4 <_Thread_queue_Extract_with_proxy>
return true;
12198c: 83 c4 10 add $0x10,%esp
12198f: bf 01 00 00 00 mov $0x1,%edi
121994: eb 6f jmp 121a05 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
121996: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
12199c: 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;
12199e: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1219a0: 85 c2 test %eax,%edx
1219a2: 74 61 je 121a05 <_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 ) ) {
1219a4: f7 c1 00 00 00 10 test $0x10000000,%ecx
1219aa: 74 3d je 1219e9 <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
1219ac: 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) )
1219b3: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
1219b9: 74 0b je 1219c6 <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
1219bb: 83 ec 0c sub $0xc,%esp
1219be: 53 push %ebx
1219bf: e8 30 f5 fe ff call 110ef4 <_Thread_queue_Extract_with_proxy>
1219c4: eb 1e jmp 1219e4 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
1219c6: 80 e1 08 and $0x8,%cl
1219c9: 74 3a je 121a05 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
1219cb: 83 ec 0c sub $0xc,%esp
1219ce: 8d 43 48 lea 0x48(%ebx),%eax
1219d1: 50 push %eax
1219d2: e8 85 fc fe ff call 11165c <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
1219d7: 58 pop %eax
1219d8: 5a pop %edx
1219d9: 68 f8 ff 03 10 push $0x1003fff8
1219de: 53 push %ebx
1219df: e8 80 eb fe ff call 110564 <_Thread_Clear_state>
1219e4: 83 c4 10 add $0x10,%esp
1219e7: eb 1c jmp 121a05 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
1219e9: 85 c9 test %ecx,%ecx
1219eb: 75 18 jne 121a05 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1219ed: 83 3d 98 a9 12 00 00 cmpl $0x0,0x12a998
1219f4: 74 0f je 121a05 <_POSIX_signals_Unblock_thread+0xf9>
1219f6: 3b 1d 9c a9 12 00 cmp 0x12a99c,%ebx
1219fc: 75 07 jne 121a05 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
1219fe: c6 05 a8 a9 12 00 01 movb $0x1,0x12a9a8
}
}
return false;
}
121a05: 89 f8 mov %edi,%eax
121a07: 8d 65 f4 lea -0xc(%ebp),%esp
121a0a: 5b pop %ebx
121a0b: 5e pop %esi
121a0c: 5f pop %edi
121a0d: c9 leave
121a0e: c3 ret
0010b3a8 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3a8: 55 push %ebp
10b3a9: 89 e5 mov %esp,%ebp
10b3ab: 53 push %ebx
10b3ac: 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 );
10b3af: 8d 45 f4 lea -0xc(%ebp),%eax
10b3b2: 50 push %eax
10b3b3: ff 75 08 pushl 0x8(%ebp)
10b3b6: 68 14 73 12 00 push $0x127314
10b3bb: e8 cc 1a 00 00 call 10ce8c <_Objects_Get>
10b3c0: 89 c3 mov %eax,%ebx
switch ( location ) {
10b3c2: 83 c4 10 add $0x10,%esp
10b3c5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b3c9: 75 64 jne 10b42f <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b3cb: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b3ce: f6 40 11 40 testb $0x40,0x11(%eax)
10b3d2: 74 18 je 10b3ec <_Rate_monotonic_Timeout+0x44>
10b3d4: 8b 53 08 mov 0x8(%ebx),%edx
10b3d7: 39 50 20 cmp %edx,0x20(%eax)
10b3da: 75 10 jne 10b3ec <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b3dc: 52 push %edx
10b3dd: 52 push %edx
10b3de: 68 f8 ff 03 10 push $0x1003fff8
10b3e3: 50 push %eax
10b3e4: e8 4f 21 00 00 call 10d538 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b3e9: 59 pop %ecx
10b3ea: eb 10 jmp 10b3fc <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b3ec: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b3f0: 75 2b jne 10b41d <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b3f2: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b3f9: 83 ec 0c sub $0xc,%esp
10b3fc: 53 push %ebx
10b3fd: e8 ec fa ff ff call 10aeee <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b402: 8b 43 3c mov 0x3c(%ebx),%eax
10b405: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b408: 58 pop %eax
10b409: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b40a: 83 c3 10 add $0x10,%ebx
10b40d: 53 push %ebx
10b40e: 68 e8 74 12 00 push $0x1274e8
10b413: e8 f8 31 00 00 call 10e610 <_Watchdog_Insert>
10b418: 83 c4 10 add $0x10,%esp
10b41b: eb 07 jmp 10b424 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b41d: 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;
10b424: a1 04 74 12 00 mov 0x127404,%eax
10b429: 48 dec %eax
10b42a: a3 04 74 12 00 mov %eax,0x127404
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b42f: 8b 5d fc mov -0x4(%ebp),%ebx
10b432: c9 leave
10b433: c3 ret
0010f808 <_Scheduler_priority_Block>:
void _Scheduler_priority_Block(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
10f808: 55 push %ebp
10f809: 89 e5 mov %esp,%ebp
10f80b: 56 push %esi
10f80c: 53 push %ebx
10f80d: 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;
10f810: 8b 82 8c 00 00 00 mov 0x8c(%edx),%eax
10f816: 8b 00 mov (%eax),%eax
if ( _Chain_Has_only_one_node( ready ) ) {
10f818: 8b 48 08 mov 0x8(%eax),%ecx
10f81b: 39 08 cmp %ecx,(%eax)
10f81d: 75 38 jne 10f857 <_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 );
10f81f: 8d 48 04 lea 0x4(%eax),%ecx
10f822: 89 08 mov %ecx,(%eax)
head->next = tail;
head->previous = NULL;
10f824: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10f82b: 89 40 08 mov %eax,0x8(%eax)
_Chain_Initialize_empty( ready );
_Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map );
10f82e: 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;
10f834: 8b 59 04 mov 0x4(%ecx),%ebx
10f837: 66 8b 03 mov (%ebx),%ax
10f83a: 66 23 41 0e and 0xe(%ecx),%ax
10f83e: 66 89 03 mov %ax,(%ebx)
if ( *the_priority_map->minor == 0 )
10f841: 66 85 c0 test %ax,%ax
10f844: 75 1b jne 10f861 <_Scheduler_priority_Block+0x59>
_Priority_Major_bit_map &= the_priority_map->block_major;
10f846: 66 a1 38 48 12 00 mov 0x124838,%ax
10f84c: 23 41 0c and 0xc(%ecx),%eax
10f84f: 66 a3 38 48 12 00 mov %ax,0x124838
10f855: eb 0a jmp 10f861 <_Scheduler_priority_Block+0x59>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10f857: 8b 0a mov (%edx),%ecx
previous = the_node->previous;
10f859: 8b 42 04 mov 0x4(%edx),%eax
next->previous = previous;
10f85c: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
10f85f: 89 08 mov %ecx,(%eax)
{
_Scheduler_priority_Ready_queue_extract(the_thread);
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
10f861: 3b 15 2c 48 12 00 cmp 0x12482c,%edx
10f867: 75 42 jne 10f8ab <_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 );
10f869: 66 8b 35 38 48 12 00 mov 0x124838,%si
10f870: 31 c9 xor %ecx,%ecx
10f872: 89 cb mov %ecx,%ebx
10f874: 66 0f bc de bsf %si,%bx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10f878: 0f b7 db movzwl %bx,%ebx
10f87b: 66 8b b4 1b 3c 48 12 mov 0x12483c(%ebx,%ebx,1),%si
10f882: 00
10f883: 66 0f bc ce bsf %si,%cx
return (_Priority_Bits_index( major ) << 4) +
10f887: c1 e3 04 shl $0x4,%ebx
10f88a: 0f b7 c9 movzwl %cx,%ecx
10f88d: 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 ] ) )
10f890: 6b c0 0c imul $0xc,%eax,%eax
10f893: 8b 4d 08 mov 0x8(%ebp),%ecx
10f896: 03 01 add (%ecx),%eax
_Scheduler_priority_Block_body(the_scheduler, the_thread);
}
10f898: 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 );
10f89a: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10f89d: 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 ] ) )
10f89f: 39 c3 cmp %eax,%ebx
10f8a1: 74 02 je 10f8a5 <_Scheduler_priority_Block+0x9d><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10f8a3: 89 d9 mov %ebx,%ecx
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10f8a5: 89 0d 2c 48 12 00 mov %ecx,0x12482c
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body(the_scheduler);
if ( _Thread_Is_executing( the_thread ) )
10f8ab: 3b 15 28 48 12 00 cmp 0x124828,%edx
10f8b1: 75 07 jne 10f8ba <_Scheduler_priority_Block+0xb2>
_Thread_Dispatch_necessary = true;
10f8b3: c6 05 34 48 12 00 01 movb $0x1,0x124834
10f8ba: 5b pop %ebx
10f8bb: 5e pop %esi
10f8bc: c9 leave
10f8bd: c3 ret
0010baa8 <_Scheduler_priority_Schedule>:
*/
void _Scheduler_priority_Schedule(
Scheduler_Control *the_scheduler
)
{
10baa8: 55 push %ebp
10baa9: 89 e5 mov %esp,%ebp
10baab: 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 );
10baac: 66 8b 1d 38 48 12 00 mov 0x124838,%bx
10bab3: 31 d2 xor %edx,%edx
10bab5: 89 d1 mov %edx,%ecx
10bab7: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10babb: 0f b7 c9 movzwl %cx,%ecx
10babe: 66 8b 9c 09 3c 48 12 mov 0x12483c(%ecx,%ecx,1),%bx
10bac5: 00
10bac6: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10baca: c1 e1 04 shl $0x4,%ecx
10bacd: 0f b7 d2 movzwl %dx,%edx
10bad0: 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 ] ) )
10bad3: 6b c0 0c imul $0xc,%eax,%eax
10bad6: 8b 55 08 mov 0x8(%ebp),%edx
10bad9: 03 02 add (%edx),%eax
_Scheduler_priority_Schedule_body( the_scheduler );
}
10badb: 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 );
10badd: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bae0: 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 ] ) )
10bae2: 39 c1 cmp %eax,%ecx
10bae4: 74 02 je 10bae8 <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10bae6: 89 ca mov %ecx,%edx
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10bae8: 89 15 2c 48 12 00 mov %edx,0x12482c
10baee: 5b pop %ebx
10baef: c9 leave
10baf0: c3 ret
0010acb8 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10acb8: 55 push %ebp
10acb9: 89 e5 mov %esp,%ebp
10acbb: 56 push %esi
10acbc: 53 push %ebx
10acbd: 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();
10acc0: 8b 35 c4 42 12 00 mov 0x1242c4,%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;
10acc6: 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) ||
10acc8: 85 c9 test %ecx,%ecx
10acca: 74 57 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10accc: b8 40 42 0f 00 mov $0xf4240,%eax
10acd1: 31 d2 xor %edx,%edx
10acd3: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acd5: 39 41 18 cmp %eax,0x18(%ecx)
10acd8: 73 49 jae 10ad23 <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10acda: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10acde: 77 43 ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10ace0: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ace4: 77 3d ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ace6: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10acea: 77 37 ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10acec: 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) ||
10acef: 85 c0 test %eax,%eax
10acf1: 74 30 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10acf3: 83 f8 0c cmp $0xc,%eax
10acf6: 77 2b ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10acf8: 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) ||
10acfa: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10ad00: 76 21 jbe 10ad23 <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10ad02: 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) ||
10ad05: 85 d2 test %edx,%edx
10ad07: 74 1a je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad09: 83 e6 03 and $0x3,%esi
10ad0c: 75 09 jne 10ad17 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad0e: 8b 04 85 ac 14 12 00 mov 0x1214ac(,%eax,4),%eax
10ad15: eb 07 jmp 10ad1e <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad17: 8b 04 85 78 14 12 00 mov 0x121478(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad1e: 39 c2 cmp %eax,%edx
10ad20: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad23: 88 d8 mov %bl,%al
10ad25: 5b pop %ebx
10ad26: 5e pop %esi
10ad27: c9 leave
10ad28: c3 ret
0010bc90 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10bc90: 55 push %ebp
10bc91: 89 e5 mov %esp,%ebp
10bc93: 57 push %edi
10bc94: 56 push %esi
10bc95: 53 push %ebx
10bc96: 83 ec 28 sub $0x28,%esp
10bc99: 8b 5d 08 mov 0x8(%ebp),%ebx
10bc9c: 8b 75 0c mov 0xc(%ebp),%esi
10bc9f: 8a 45 10 mov 0x10(%ebp),%al
10bca2: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10bca5: 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 );
10bca8: 53 push %ebx
10bca9: e8 1a 0c 00 00 call 10c8c8 <_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 )
10bcae: 83 c4 10 add $0x10,%esp
10bcb1: 39 73 14 cmp %esi,0x14(%ebx)
10bcb4: 74 0c je 10bcc2 <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10bcb6: 50 push %eax
10bcb7: 50 push %eax
10bcb8: 56 push %esi
10bcb9: 53 push %ebx
10bcba: e8 a9 0b 00 00 call 10c868 <_Thread_Set_priority>
10bcbf: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10bcc2: 9c pushf
10bcc3: fa cli
10bcc4: 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;
10bcc5: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10bcc8: 83 f8 04 cmp $0x4,%eax
10bccb: 74 2f je 10bcfc <_Thread_Change_priority+0x6c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10bccd: 83 e7 04 and $0x4,%edi
10bcd0: 75 08 jne 10bcda <_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);
10bcd2: 89 c2 mov %eax,%edx
10bcd4: 83 e2 fb and $0xfffffffb,%edx
10bcd7: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10bcda: 56 push %esi
10bcdb: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10bcdc: a9 e0 be 03 00 test $0x3bee0,%eax
10bce1: 0f 84 b5 00 00 00 je 10bd9c <_Thread_Change_priority+0x10c>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10bce7: 89 5d 0c mov %ebx,0xc(%ebp)
10bcea: 8b 43 44 mov 0x44(%ebx),%eax
10bced: 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 );
}
10bcf0: 8d 65 f4 lea -0xc(%ebp),%esp
10bcf3: 5b pop %ebx
10bcf4: 5e pop %esi
10bcf5: 5f pop %edi
10bcf6: 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 );
10bcf7: e9 e4 0a 00 00 jmp 10c7e0 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10bcfc: 83 e7 04 and $0x4,%edi
10bcff: 75 6b jne 10bd6c <_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 );
10bd01: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10bd08: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10bd0c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bd12: 74 2b je 10bd3f <_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;
10bd14: 8b 50 04 mov 0x4(%eax),%edx
10bd17: 66 8b 48 0a mov 0xa(%eax),%cx
10bd1b: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bd1e: 66 8b 15 38 48 12 00 mov 0x124838,%dx
10bd25: 0b 50 08 or 0x8(%eax),%edx
10bd28: 66 89 15 38 48 12 00 mov %dx,0x124838
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
_Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain,
10bd2f: 8b 00 mov (%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10bd31: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10bd34: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10bd36: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10bd38: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10bd3a: 89 5a 04 mov %ebx,0x4(%edx)
10bd3d: eb 2d jmp 10bd6c <_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;
10bd3f: 8b 50 04 mov 0x4(%eax),%edx
10bd42: 66 8b 48 0a mov 0xa(%eax),%cx
10bd46: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bd49: 66 8b 15 38 48 12 00 mov 0x124838,%dx
10bd50: 0b 50 08 or 0x8(%eax),%edx
10bd53: 66 89 15 38 48 12 00 mov %dx,0x124838
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
10bd5a: 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;
10bd5c: 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 );
10bd5f: 8d 48 04 lea 0x4(%eax),%ecx
10bd62: 89 0b mov %ecx,(%ebx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10bd64: 89 58 08 mov %ebx,0x8(%eax)
old_last->next = the_node;
10bd67: 89 1a mov %ebx,(%edx)
the_node->previous = old_last;
10bd69: 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 );
10bd6c: 56 push %esi
10bd6d: 9d popf
10bd6e: fa cli
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule(
Scheduler_Control *the_scheduler
)
{
the_scheduler->Operations.schedule( the_scheduler );
10bd6f: 83 ec 0c sub $0xc,%esp
10bd72: 68 68 43 12 00 push $0x124368
10bd77: 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 );
10bd7d: a1 28 48 12 00 mov 0x124828,%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() &&
10bd82: 83 c4 10 add $0x10,%esp
10bd85: 3b 05 2c 48 12 00 cmp 0x12482c,%eax
10bd8b: 74 0d je 10bd9a <_Thread_Change_priority+0x10a>
10bd8d: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bd91: 74 07 je 10bd9a <_Thread_Change_priority+0x10a>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10bd93: c6 05 34 48 12 00 01 movb $0x1,0x124834
_ISR_Enable( level );
10bd9a: 56 push %esi
10bd9b: 9d popf
}
10bd9c: 8d 65 f4 lea -0xc(%ebp),%esp
10bd9f: 5b pop %ebx
10bda0: 5e pop %esi
10bda1: 5f pop %edi
10bda2: c9 leave
10bda3: c3 ret
0010bf64 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10bf64: 55 push %ebp
10bf65: 89 e5 mov %esp,%ebp
10bf67: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10bf6a: 8d 45 f4 lea -0xc(%ebp),%eax
10bf6d: 50 push %eax
10bf6e: ff 75 08 pushl 0x8(%ebp)
10bf71: e8 82 01 00 00 call 10c0f8 <_Thread_Get>
switch ( location ) {
10bf76: 83 c4 10 add $0x10,%esp
10bf79: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10bf7d: 75 1b jne 10bf9a <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10bf7f: 52 push %edx
10bf80: 52 push %edx
10bf81: 68 18 00 00 10 push $0x10000018
10bf86: 50 push %eax
10bf87: e8 18 fe ff ff call 10bda4 <_Thread_Clear_state>
10bf8c: a1 e0 42 12 00 mov 0x1242e0,%eax
10bf91: 48 dec %eax
10bf92: a3 e0 42 12 00 mov %eax,0x1242e0
10bf97: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10bf9a: c9 leave
10bf9b: c3 ret
0010bf9c <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10bf9c: 55 push %ebp
10bf9d: 89 e5 mov %esp,%ebp
10bf9f: 57 push %edi
10bfa0: 56 push %esi
10bfa1: 53 push %ebx
10bfa2: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10bfa5: 8b 1d 28 48 12 00 mov 0x124828,%ebx
_ISR_Disable( level );
10bfab: 9c pushf
10bfac: fa cli
10bfad: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10bfae: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10bfb1: e9 f9 00 00 00 jmp 10c0af <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10bfb6: 8b 35 2c 48 12 00 mov 0x12482c,%esi
_Thread_Dispatch_disable_level = 1;
10bfbc: c7 05 e0 42 12 00 01 movl $0x1,0x1242e0
10bfc3: 00 00 00
_Thread_Dispatch_necessary = false;
10bfc6: c6 05 34 48 12 00 00 movb $0x0,0x124834
_Thread_Executing = heir;
10bfcd: 89 35 28 48 12 00 mov %esi,0x124828
/*
* 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 )
10bfd3: 39 de cmp %ebx,%esi
10bfd5: 0f 84 e2 00 00 00 je 10c0bd <_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 )
10bfdb: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10bfdf: 75 09 jne 10bfea <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10bfe1: 8b 15 b0 42 12 00 mov 0x1242b0,%edx
10bfe7: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10bfea: 50 push %eax
10bfeb: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10bfec: 83 ec 0c sub $0xc,%esp
10bfef: 8d 45 e0 lea -0x20(%ebp),%eax
10bff2: 50 push %eax
10bff3: e8 e0 34 00 00 call 10f4d8 <_TOD_Get_uptime>
_Timestamp_Subtract(
10bff8: 83 c4 0c add $0xc,%esp
10bffb: 57 push %edi
10bffc: 8d 45 e0 lea -0x20(%ebp),%eax
10bfff: 50 push %eax
10c000: 68 b0 43 12 00 push $0x1243b0
10c005: e8 06 0b 00 00 call 10cb10 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10c00a: 58 pop %eax
10c00b: 5a pop %edx
10c00c: 57 push %edi
10c00d: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10c013: 50 push %eax
10c014: e8 c7 0a 00 00 call 10cae0 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10c019: 8b 45 e0 mov -0x20(%ebp),%eax
10c01c: 8b 55 e4 mov -0x1c(%ebp),%edx
10c01f: a3 b0 43 12 00 mov %eax,0x1243b0
10c024: 89 15 b4 43 12 00 mov %edx,0x1243b4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10c02a: a1 88 43 12 00 mov 0x124388,%eax
10c02f: 83 c4 10 add $0x10,%esp
10c032: 85 c0 test %eax,%eax
10c034: 74 10 je 10c046 <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10c036: 8b 10 mov (%eax),%edx
10c038: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10c03e: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10c044: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10c046: 51 push %ecx
10c047: 51 push %ecx
10c048: 56 push %esi
10c049: 53 push %ebx
10c04a: e8 f9 0c 00 00 call 10cd48 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10c04f: 58 pop %eax
10c050: 5a pop %edx
10c051: 81 c6 c8 00 00 00 add $0xc8,%esi
10c057: 56 push %esi
10c058: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10c05e: 50 push %eax
10c05f: e8 ac 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) &&
10c064: 83 c4 10 add $0x10,%esp
10c067: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
10c06e: 74 36 je 10c0a6 <_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 );
10c070: a1 64 43 12 00 mov 0x124364,%eax
10c075: 39 c3 cmp %eax,%ebx
10c077: 74 2d je 10c0a6 <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10c079: 85 c0 test %eax,%eax
10c07b: 74 11 je 10c08e <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10c07d: 83 ec 0c sub $0xc,%esp
10c080: 05 e0 00 00 00 add $0xe0,%eax
10c085: 50 push %eax
10c086: e8 b9 0f 00 00 call 10d044 <_CPU_Context_save_fp>
10c08b: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10c08e: 83 ec 0c sub $0xc,%esp
10c091: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10c097: 50 push %eax
10c098: e8 b1 0f 00 00 call 10d04e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10c09d: 89 1d 64 43 12 00 mov %ebx,0x124364
10c0a3: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10c0a6: 8b 1d 28 48 12 00 mov 0x124828,%ebx
_ISR_Disable( level );
10c0ac: 9c pushf
10c0ad: fa cli
10c0ae: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c0af: 8a 15 34 48 12 00 mov 0x124834,%dl
10c0b5: 84 d2 test %dl,%dl
10c0b7: 0f 85 f9 fe ff ff jne 10bfb6 <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10c0bd: c7 05 e0 42 12 00 00 movl $0x0,0x1242e0
10c0c4: 00 00 00
_ISR_Enable( level );
10c0c7: 50 push %eax
10c0c8: 9d popf
_API_extensions_Run_postswitch();
10c0c9: e8 15 e8 ff ff call 10a8e3 <_API_extensions_Run_postswitch>
}
10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp
10c0d1: 5b pop %ebx
10c0d2: 5e pop %esi
10c0d3: 5f pop %edi
10c0d4: c9 leave
10c0d5: c3 ret
00110fb0 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110fb0: 55 push %ebp
110fb1: 89 e5 mov %esp,%ebp
110fb3: 53 push %ebx
110fb4: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110fb7: 8b 1d 28 48 12 00 mov 0x124828,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110fbd: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
110fc3: 85 c0 test %eax,%eax
110fc5: 74 03 je 110fca <_Thread_Handler+0x1a>
110fc7: fa cli
110fc8: eb 01 jmp 110fcb <_Thread_Handler+0x1b>
110fca: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110fcb: a0 a0 3f 12 00 mov 0x123fa0,%al
110fd0: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110fd3: 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) &&
110fda: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
110fe1: 74 24 je 111007 <_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 );
110fe3: a1 64 43 12 00 mov 0x124364,%eax
110fe8: 39 c3 cmp %eax,%ebx
110fea: 74 1b je 111007 <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110fec: 85 c0 test %eax,%eax
110fee: 74 11 je 111001 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110ff0: 83 ec 0c sub $0xc,%esp
110ff3: 05 e0 00 00 00 add $0xe0,%eax
110ff8: 50 push %eax
110ff9: e8 46 c0 ff ff call 10d044 <_CPU_Context_save_fp>
110ffe: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
111001: 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 );
111007: 83 ec 0c sub $0xc,%esp
11100a: 53 push %ebx
11100b: e8 e8 bb ff ff call 10cbf8 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
111010: e8 c1 b0 ff ff call 10c0d6 <_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) */ {
111015: 83 c4 10 add $0x10,%esp
111018: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
11101c: 75 05 jne 111023 <_Thread_Handler+0x73>
INIT_NAME ();
11101e: e8 6d be 00 00 call 11ce90 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
111023: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
111029: 85 c0 test %eax,%eax
11102b: 75 0b jne 111038 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
11102d: 83 ec 0c sub $0xc,%esp
111030: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
111036: eb 0c jmp 111044 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
111038: 48 dec %eax
111039: 75 15 jne 111050 <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
11103b: 83 ec 0c sub $0xc,%esp
11103e: ff b3 98 00 00 00 pushl 0x98(%ebx)
111044: 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 =
11104a: 89 43 28 mov %eax,0x28(%ebx)
11104d: 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 );
111050: 83 ec 0c sub $0xc,%esp
111053: 53 push %ebx
111054: e8 d0 bb ff ff call 10cc29 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
111059: 83 c4 0c add $0xc,%esp
11105c: 6a 05 push $0x5
11105e: 6a 01 push $0x1
111060: 6a 00 push $0x0
111062: e8 d1 a1 ff ff call 10b238 <_Internal_error_Occurred>
0010c168 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10c168: 55 push %ebp
10c169: 89 e5 mov %esp,%ebp
10c16b: 57 push %edi
10c16c: 56 push %esi
10c16d: 53 push %ebx
10c16e: 83 ec 1c sub $0x1c,%esp
10c171: 8b 5d 0c mov 0xc(%ebp),%ebx
10c174: 8b 4d 10 mov 0x10(%ebp),%ecx
10c177: 8b 75 14 mov 0x14(%ebp),%esi
10c17a: 8a 55 18 mov 0x18(%ebp),%dl
10c17d: 8a 45 20 mov 0x20(%ebp),%al
10c180: 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;
10c183: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10c18a: 00 00 00
10c18d: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10c194: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10c197: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10c19e: 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 ) {
10c1a1: 85 c9 test %ecx,%ecx
10c1a3: 75 31 jne 10c1d6 <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c1a5: 51 push %ecx
10c1a6: 51 push %ecx
10c1a7: 56 push %esi
10c1a8: 53 push %ebx
10c1a9: 88 55 dc mov %dl,-0x24(%ebp)
10c1ac: e8 87 07 00 00 call 10c938 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c1b1: 83 c4 10 add $0x10,%esp
10c1b4: 39 f0 cmp %esi,%eax
10c1b6: 8a 55 dc mov -0x24(%ebp),%dl
10c1b9: 0f 82 f9 01 00 00 jb 10c3b8 <_Thread_Initialize+0x250>
10c1bf: 85 c0 test %eax,%eax
10c1c1: 0f 84 f1 01 00 00 je 10c3b8 <_Thread_Initialize+0x250><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10c1c7: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10c1cd: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10c1d4: eb 09 jmp 10c1df <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10c1d6: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10c1dd: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10c1df: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10c1e5: 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;
10c1eb: 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 ) {
10c1ed: 84 d2 test %dl,%dl
10c1ef: 74 17 je 10c208 <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c1f1: 83 ec 0c sub $0xc,%esp
10c1f4: 6a 6c push $0x6c
10c1f6: e8 bb 0d 00 00 call 10cfb6 <_Workspace_Allocate>
10c1fb: 89 c7 mov %eax,%edi
if ( !fp_area )
10c1fd: 83 c4 10 add $0x10,%esp
10c200: 85 c0 test %eax,%eax
10c202: 0f 84 25 01 00 00 je 10c32d <_Thread_Initialize+0x1c5>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c208: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10c20e: 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;
10c214: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c21b: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c222: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c229: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c230: 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;
10c235: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c237: 85 c0 test %eax,%eax
10c239: 74 1d je 10c258 <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c23b: 83 ec 0c sub $0xc,%esp
10c23e: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c245: 50 push %eax
10c246: e8 6b 0d 00 00 call 10cfb6 <_Workspace_Allocate>
10c24b: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c24d: 83 c4 10 add $0x10,%esp
10c250: 85 c0 test %eax,%eax
10c252: 0f 84 d7 00 00 00 je 10c32f <_Thread_Initialize+0x1c7>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c258: 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 ) {
10c25e: 85 f6 test %esi,%esi
10c260: 74 16 je 10c278 <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c262: 8b 15 94 43 12 00 mov 0x124394,%edx
10c268: 31 c0 xor %eax,%eax
10c26a: eb 08 jmp 10c274 <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c26c: 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++ )
10c273: 40 inc %eax
10c274: 39 d0 cmp %edx,%eax
10c276: 76 f4 jbe 10c26c <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c278: 8a 45 e3 mov -0x1d(%ebp),%al
10c27b: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c281: 8b 45 24 mov 0x24(%ebp),%eax
10c284: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c28a: 8b 45 28 mov 0x28(%ebp),%eax
10c28d: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10c293: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c297: 75 08 jne 10c2a1 <_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;
10c299: a1 b0 42 12 00 mov 0x1242b0,%eax
10c29e: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c2a1: 8b 45 2c mov 0x2c(%ebp),%eax
10c2a4: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10c2aa: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c2b1: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c2b8: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c2bf: 8b 45 1c mov 0x1c(%ebp),%eax
10c2c2: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c2c5: 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
10c2cb: 52 push %edx
10c2cc: 52 push %edx
10c2cd: 53 push %ebx
10c2ce: 68 68 43 12 00 push $0x124368
10c2d3: ff 15 7c 43 12 00 call *0x12437c
10c2d9: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread );
if ( !sched )
10c2dc: 83 c4 10 add $0x10,%esp
10c2df: 85 c0 test %eax,%eax
10c2e1: 74 53 je 10c336 <_Thread_Initialize+0x1ce>
goto failed;
_Thread_Set_priority( the_thread, priority );
10c2e3: 50 push %eax
10c2e4: 50 push %eax
10c2e5: ff 75 1c pushl 0x1c(%ebp)
10c2e8: 53 push %ebx
10c2e9: e8 7a 05 00 00 call 10c868 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c2ee: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c2f5: 00 00 00
10c2f8: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c2ff: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10c302: 8b 45 08 mov 0x8(%ebp),%eax
10c305: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c308: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c30c: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c30f: 8b 45 30 mov 0x30(%ebp),%eax
10c312: 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 );
10c315: 89 1c 24 mov %ebx,(%esp)
10c318: e8 7b 09 00 00 call 10cc98 <_User_extensions_Thread_create>
10c31d: 88 c2 mov %al,%dl
if ( extension_status )
10c31f: 83 c4 10 add $0x10,%esp
return true;
10c322: 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 )
10c324: 84 d2 test %dl,%dl
10c326: 74 0e je 10c336 <_Thread_Initialize+0x1ce>
10c328: e9 8d 00 00 00 jmp 10c3ba <_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;
10c32d: 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;
10c32f: 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 )
10c336: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
10c33c: 85 c0 test %eax,%eax
10c33e: 74 0c je 10c34c <_Thread_Initialize+0x1e4>
_Workspace_Free( the_thread->libc_reent );
10c340: 83 ec 0c sub $0xc,%esp
10c343: 50 push %eax
10c344: e8 86 0c 00 00 call 10cfcf <_Workspace_Free>
10c349: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c34c: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax
10c352: 85 c0 test %eax,%eax
10c354: 74 0c je 10c362 <_Thread_Initialize+0x1fa>
_Workspace_Free( the_thread->API_Extensions[i] );
10c356: 83 ec 0c sub $0xc,%esp
10c359: 50 push %eax
10c35a: e8 70 0c 00 00 call 10cfcf <_Workspace_Free>
10c35f: 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] )
10c362: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
10c368: 85 c0 test %eax,%eax
10c36a: 74 0c je 10c378 <_Thread_Initialize+0x210>
_Workspace_Free( the_thread->API_Extensions[i] );
10c36c: 83 ec 0c sub $0xc,%esp
10c36f: 50 push %eax
10c370: e8 5a 0c 00 00 call 10cfcf <_Workspace_Free>
10c375: 83 c4 10 add $0x10,%esp
if ( extensions_area )
10c378: 85 f6 test %esi,%esi
10c37a: 74 0c je 10c388 <_Thread_Initialize+0x220>
(void) _Workspace_Free( extensions_area );
10c37c: 83 ec 0c sub $0xc,%esp
10c37f: 56 push %esi
10c380: e8 4a 0c 00 00 call 10cfcf <_Workspace_Free>
10c385: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10c388: 85 ff test %edi,%edi
10c38a: 74 0c je 10c398 <_Thread_Initialize+0x230>
(void) _Workspace_Free( fp_area );
10c38c: 83 ec 0c sub $0xc,%esp
10c38f: 57 push %edi
10c390: e8 3a 0c 00 00 call 10cfcf <_Workspace_Free>
10c395: 83 c4 10 add $0x10,%esp
#endif
if ( sched )
10c398: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10c39c: 74 0e je 10c3ac <_Thread_Initialize+0x244>
(void) _Workspace_Free( sched );
10c39e: 83 ec 0c sub $0xc,%esp
10c3a1: ff 75 e4 pushl -0x1c(%ebp)
10c3a4: e8 26 0c 00 00 call 10cfcf <_Workspace_Free>
10c3a9: 83 c4 10 add $0x10,%esp
_Thread_Stack_Free( the_thread );
10c3ac: 83 ec 0c sub $0xc,%esp
10c3af: 53 push %ebx
10c3b0: e8 d3 05 00 00 call 10c988 <_Thread_Stack_Free>
return false;
10c3b5: 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 */
10c3b8: 31 c0 xor %eax,%eax
_Thread_Stack_Free( the_thread );
return false;
}
10c3ba: 8d 65 f4 lea -0xc(%ebp),%esp
10c3bd: 5b pop %ebx
10c3be: 5e pop %esi
10c3bf: 5f pop %edi
10c3c0: c9 leave
10c3c1: c3 ret
0010f5f0 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f5f0: 55 push %ebp
10f5f1: 89 e5 mov %esp,%ebp
10f5f3: 53 push %ebx
10f5f4: 83 ec 04 sub $0x4,%esp
10f5f7: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f5fa: 9c pushf
10f5fb: fa cli
10f5fc: 5b pop %ebx
current_state = the_thread->current_state;
10f5fd: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f600: f6 c2 02 test $0x2,%dl
10f603: 74 1b je 10f620 <_Thread_Resume+0x30> <== NEVER TAKEN
10f605: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f608: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f60b: 85 d2 test %edx,%edx
10f60d: 75 11 jne 10f620 <_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 );
10f60f: 52 push %edx
10f610: 52 push %edx
10f611: 50 push %eax
10f612: 68 30 74 12 00 push $0x127430
10f617: ff 15 40 74 12 00 call *0x127440
10f61d: 83 c4 10 add $0x10,%esp
_Scheduler_Unblock( &_Scheduler, the_thread );
}
}
_ISR_Enable( level );
10f620: 53 push %ebx
10f621: 9d popf
}
10f622: 8b 5d fc mov -0x4(%ebp),%ebx
10f625: c9 leave
10f626: c3 ret
0010ca70 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10ca70: 55 push %ebp
10ca71: 89 e5 mov %esp,%ebp
10ca73: 53 push %ebx
10ca74: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10ca77: 8b 1d 28 48 12 00 mov 0x124828,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10ca7d: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10ca81: 74 55 je 10cad8 <_Thread_Tickle_timeslice+0x68>
return;
if ( !_States_Is_ready( executing->current_state ) )
10ca83: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10ca87: 75 4f jne 10cad8 <_Thread_Tickle_timeslice+0x68>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10ca89: 8b 43 7c mov 0x7c(%ebx),%eax
10ca8c: 83 f8 01 cmp $0x1,%eax
10ca8f: 72 47 jb 10cad8 <_Thread_Tickle_timeslice+0x68>
10ca91: 83 f8 02 cmp $0x2,%eax
10ca94: 76 07 jbe 10ca9d <_Thread_Tickle_timeslice+0x2d>
10ca96: 83 f8 03 cmp $0x3,%eax
10ca99: 75 3d jne 10cad8 <_Thread_Tickle_timeslice+0x68><== NEVER TAKEN
10ca9b: eb 23 jmp 10cac0 <_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 ) {
10ca9d: 8b 43 78 mov 0x78(%ebx),%eax
10caa0: 48 dec %eax
10caa1: 89 43 78 mov %eax,0x78(%ebx)
10caa4: 85 c0 test %eax,%eax
10caa6: 7f 30 jg 10cad8 <_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 );
10caa8: 83 ec 0c sub $0xc,%esp
10caab: 68 68 43 12 00 push $0x124368
10cab0: 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;
10cab6: a1 b0 42 12 00 mov 0x1242b0,%eax
10cabb: 89 43 78 mov %eax,0x78(%ebx)
10cabe: eb 15 jmp 10cad5 <_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 )
10cac0: 8b 43 78 mov 0x78(%ebx),%eax
10cac3: 48 dec %eax
10cac4: 89 43 78 mov %eax,0x78(%ebx)
10cac7: 85 c0 test %eax,%eax
10cac9: 75 0d jne 10cad8 <_Thread_Tickle_timeslice+0x68>
(*executing->budget_callout)( executing );
10cacb: 83 ec 0c sub $0xc,%esp
10cace: 53 push %ebx
10cacf: ff 93 80 00 00 00 call *0x80(%ebx)
10cad5: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10cad8: 8b 5d fc mov -0x4(%ebp),%ebx
10cadb: c9 leave
10cadc: c3 ret
0010c7e0 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c7e0: 55 push %ebp
10c7e1: 89 e5 mov %esp,%ebp
10c7e3: 57 push %edi
10c7e4: 56 push %esi
10c7e5: 53 push %ebx
10c7e6: 83 ec 1c sub $0x1c,%esp
10c7e9: 8b 75 08 mov 0x8(%ebp),%esi
10c7ec: 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 )
10c7ef: 85 f6 test %esi,%esi
10c7f1: 74 36 je 10c829 <_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 ) {
10c7f3: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c7f7: 75 30 jne 10c829 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c7f9: 9c pushf
10c7fa: fa cli
10c7fb: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c7fc: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c803: 74 22 je 10c827 <_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;
10c805: 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 );
10c80c: 50 push %eax
10c80d: 6a 01 push $0x1
10c80f: 57 push %edi
10c810: 56 push %esi
10c811: e8 0a 32 00 00 call 10fa20 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c816: 83 c4 0c add $0xc,%esp
10c819: 8d 45 e4 lea -0x1c(%ebp),%eax
10c81c: 50 push %eax
10c81d: 57 push %edi
10c81e: 56 push %esi
10c81f: e8 c0 fd ff ff call 10c5e4 <_Thread_queue_Enqueue_priority>
10c824: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c827: 53 push %ebx
10c828: 9d popf
}
}
10c829: 8d 65 f4 lea -0xc(%ebp),%esp
10c82c: 5b pop %ebx
10c82d: 5e pop %esi
10c82e: 5f pop %edi
10c82f: c9 leave
10c830: c3 ret
0010c834 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c834: 55 push %ebp
10c835: 89 e5 mov %esp,%ebp
10c837: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c83a: 8d 45 f4 lea -0xc(%ebp),%eax
10c83d: 50 push %eax
10c83e: ff 75 08 pushl 0x8(%ebp)
10c841: e8 b2 f8 ff ff call 10c0f8 <_Thread_Get>
switch ( location ) {
10c846: 83 c4 10 add $0x10,%esp
10c849: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c84d: 75 17 jne 10c866 <_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 );
10c84f: 83 ec 0c sub $0xc,%esp
10c852: 50 push %eax
10c853: e8 80 32 00 00 call 10fad8 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c858: a1 e0 42 12 00 mov 0x1242e0,%eax
10c85d: 48 dec %eax
10c85e: a3 e0 42 12 00 mov %eax,0x1242e0
10c863: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c866: c9 leave
10c867: c3 ret
00116978 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
116978: 55 push %ebp
116979: 89 e5 mov %esp,%ebp
11697b: 57 push %edi
11697c: 56 push %esi
11697d: 53 push %ebx
11697e: 83 ec 4c sub $0x4c,%esp
116981: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
116984: 8d 55 dc lea -0x24(%ebp),%edx
116987: 8d 45 e0 lea -0x20(%ebp),%eax
11698a: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
11698d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
116994: 89 55 e4 mov %edx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
116997: 8d 7d d0 lea -0x30(%ebp),%edi
11699a: 8d 4d d4 lea -0x2c(%ebp),%ecx
11699d: 89 4d d0 mov %ecx,-0x30(%ebp)
head->previous = NULL;
1169a0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
1169a7: 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 );
1169aa: 8d 53 30 lea 0x30(%ebx),%edx
1169ad: 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 );
1169b0: 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;
1169b3: 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;
1169b6: 8d 4d dc lea -0x24(%ebp),%ecx
1169b9: 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;
1169bc: a1 28 e8 13 00 mov 0x13e828,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169c1: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
1169c4: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169c7: 51 push %ecx
1169c8: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169c9: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169cb: 50 push %eax
1169cc: ff 75 c0 pushl -0x40(%ebp)
1169cf: e8 88 39 00 00 call 11a35c <_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();
1169d4: a1 a0 e7 13 00 mov 0x13e7a0,%eax
1169d9: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
1169dc: 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 ) {
1169df: 83 c4 10 add $0x10,%esp
1169e2: 39 45 c4 cmp %eax,-0x3c(%ebp)
1169e5: 76 10 jbe 1169f7 <_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 );
1169e7: 52 push %edx
1169e8: 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;
1169e9: 8b 55 c4 mov -0x3c(%ebp),%edx
1169ec: 29 c2 sub %eax,%edx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169ee: 52 push %edx
1169ef: 56 push %esi
1169f0: e8 67 39 00 00 call 11a35c <_Watchdog_Adjust_to_chain>
1169f5: eb 0f jmp 116a06 <_Timer_server_Body+0x8e>
} else if ( snapshot < last_snapshot ) {
1169f7: 73 10 jae 116a09 <_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 );
1169f9: 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;
1169fa: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169fd: 50 push %eax
1169fe: 6a 01 push $0x1
116a00: 56 push %esi
116a01: e8 ea 38 00 00 call 11a2f0 <_Watchdog_Adjust>
116a06: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a09: 8b 4d c4 mov -0x3c(%ebp),%ecx
116a0c: 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 );
116a0f: 8b 43 78 mov 0x78(%ebx),%eax
116a12: 83 ec 0c sub $0xc,%esp
116a15: 50 push %eax
116a16: e8 f5 08 00 00 call 117310 <_Chain_Get>
if ( timer == NULL ) {
116a1b: 83 c4 10 add $0x10,%esp
116a1e: 85 c0 test %eax,%eax
116a20: 74 29 je 116a4b <_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 ) {
116a22: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
116a25: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
116a28: 75 0b jne 116a35 <_Timer_server_Body+0xbd><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a2a: 52 push %edx <== NOT EXECUTED
116a2b: 52 push %edx <== NOT EXECUTED
116a2c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a2f: 50 push %eax <== NOT EXECUTED
116a30: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED
116a33: eb 0c jmp 116a41 <_Timer_server_Body+0xc9><== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a35: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
116a38: 75 d5 jne 116a0f <_Timer_server_Body+0x97><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a3a: 51 push %ecx <== NOT EXECUTED
116a3b: 51 push %ecx <== NOT EXECUTED
116a3c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a3f: 50 push %eax <== NOT EXECUTED
116a40: 56 push %esi <== NOT EXECUTED
116a41: e8 9e 39 00 00 call 11a3e4 <_Watchdog_Insert> <== NOT EXECUTED
116a46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116a49: eb c4 jmp 116a0f <_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 );
116a4b: 9c pushf
116a4c: fa cli
116a4d: 5a pop %edx
tmp = ts->insert_chain;
116a4e: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a51: b0 01 mov $0x1,%al
116a53: 8b 4d b4 mov -0x4c(%ebp),%ecx
116a56: 39 4d dc cmp %ecx,-0x24(%ebp)
116a59: 75 09 jne 116a64 <_Timer_server_Body+0xec><== NEVER TAKEN
ts->insert_chain = NULL;
116a5b: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116a62: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116a64: 52 push %edx
116a65: 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 ) {
116a66: 84 c0 test %al,%al
116a68: 0f 85 4e ff ff ff jne 1169bc <_Timer_server_Body+0x44><== NEVER TAKEN
116a6e: 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 ) ) {
116a71: 39 45 d0 cmp %eax,-0x30(%ebp)
116a74: 74 3a je 116ab0 <_Timer_server_Body+0x138>
116a76: 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 );
116a79: 9c pushf
116a7a: fa cli
116a7b: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
116a7c: 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))
116a7f: 3b 45 b0 cmp -0x50(%ebp),%eax
116a82: 74 25 je 116aa9 <_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;
116a84: 8b 10 mov (%eax),%edx
head->next = new_first;
116a86: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
116a89: 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 ) {
116a8c: 85 c0 test %eax,%eax
116a8e: 74 19 je 116aa9 <_Timer_server_Body+0x131><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116a97: 51 push %ecx
116a98: 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 );
116a99: 52 push %edx
116a9a: 52 push %edx
116a9b: ff 70 24 pushl 0x24(%eax)
116a9e: ff 70 20 pushl 0x20(%eax)
116aa1: ff 50 1c call *0x1c(%eax)
}
116aa4: 83 c4 10 add $0x10,%esp
116aa7: eb d0 jmp 116a79 <_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 );
116aa9: 51 push %ecx
116aaa: 9d popf
116aab: e9 06 ff ff ff jmp 1169b6 <_Timer_server_Body+0x3e>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116ab0: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116ab4: e8 23 fe ff ff call 1168dc <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116ab9: 51 push %ecx
116aba: 51 push %ecx
116abb: 6a 08 push $0x8
116abd: ff 33 pushl (%ebx)
116abf: e8 7c 32 00 00 call 119d40 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116ac4: 89 d8 mov %ebx,%eax
116ac6: e8 21 fe ff ff call 1168ec <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116acb: 89 d8 mov %ebx,%eax
116acd: e8 60 fe ff ff call 116932 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116ad2: e8 f7 29 00 00 call 1194ce <_Thread_Enable_dispatch>
ts->active = true;
116ad7: 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 );
116adb: 8d 43 08 lea 0x8(%ebx),%eax
116ade: 89 04 24 mov %eax,(%esp)
116ae1: e8 1e 3a 00 00 call 11a504 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116ae6: 8d 43 40 lea 0x40(%ebx),%eax
116ae9: 89 04 24 mov %eax,(%esp)
116aec: e8 13 3a 00 00 call 11a504 <_Watchdog_Remove>
116af1: 83 c4 10 add $0x10,%esp
116af4: e9 bd fe ff ff jmp 1169b6 <_Timer_server_Body+0x3e>
00116af9 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116af9: 55 push %ebp
116afa: 89 e5 mov %esp,%ebp
116afc: 57 push %edi
116afd: 56 push %esi
116afe: 53 push %ebx
116aff: 83 ec 2c sub $0x2c,%esp
116b02: 8b 5d 08 mov 0x8(%ebp),%ebx
116b05: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b08: 8b 43 78 mov 0x78(%ebx),%eax
116b0b: 85 c0 test %eax,%eax
116b0d: 0f 85 de 00 00 00 jne 116bf1 <_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();
116b13: e8 c4 fd ff ff call 1168dc <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b18: 8b 46 38 mov 0x38(%esi),%eax
116b1b: 83 f8 01 cmp $0x1,%eax
116b1e: 75 5a jne 116b7a <_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 );
116b20: 9c pushf
116b21: fa cli
116b22: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b25: 8b 15 28 e8 13 00 mov 0x13e828,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b2b: 8b 4b 3c mov 0x3c(%ebx),%ecx
initialized = false;
}
#endif
return status;
}
116b2e: 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 );
116b31: 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 ) ) {
116b34: 39 f8 cmp %edi,%eax
116b36: 74 19 je 116b51 <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b38: 89 d7 mov %edx,%edi
116b3a: 29 cf sub %ecx,%edi
116b3c: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b3f: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b42: 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) {
116b44: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b47: 76 05 jbe 116b4e <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b49: 89 f9 mov %edi,%ecx
116b4b: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b4e: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b51: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116b54: ff 75 e0 pushl -0x20(%ebp)
116b57: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116b58: 50 push %eax
116b59: 50 push %eax
116b5a: 83 c6 10 add $0x10,%esi
116b5d: 56 push %esi
116b5e: 8d 43 30 lea 0x30(%ebx),%eax
116b61: 50 push %eax
116b62: e8 7d 38 00 00 call 11a3e4 <_Watchdog_Insert>
if ( !ts->active ) {
116b67: 8a 43 7c mov 0x7c(%ebx),%al
116b6a: 83 c4 10 add $0x10,%esp
116b6d: 84 c0 test %al,%al
116b6f: 75 74 jne 116be5 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116b71: 89 d8 mov %ebx,%eax
116b73: e8 74 fd ff ff call 1168ec <_Timer_server_Reset_interval_system_watchdog>
116b78: eb 6b jmp 116be5 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116b7a: 83 f8 03 cmp $0x3,%eax
116b7d: 75 66 jne 116be5 <_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 );
116b7f: 9c pushf
116b80: fa cli
116b81: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116b84: 8b 15 a0 e7 13 00 mov 0x13e7a0,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116b8a: 8b 43 74 mov 0x74(%ebx),%eax
initialized = false;
}
#endif
return status;
}
116b8d: 8b 4b 68 mov 0x68(%ebx),%ecx
116b90: 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 ) ) {
116b93: 39 f9 cmp %edi,%ecx
116b95: 74 27 je 116bbe <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116b97: 8b 79 10 mov 0x10(%ecx),%edi
116b9a: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116b9d: 39 c2 cmp %eax,%edx
116b9f: 76 15 jbe 116bb6 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116ba1: 89 d7 mov %edx,%edi
116ba3: 29 c7 sub %eax,%edi
116ba5: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116ba8: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116baa: 39 7d d4 cmp %edi,-0x2c(%ebp)
116bad: 76 0c jbe 116bbb <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116baf: 8b 45 d4 mov -0x2c(%ebp),%eax
116bb2: 29 f8 sub %edi,%eax
116bb4: eb 05 jmp 116bbb <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116bb6: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116bb9: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116bbb: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116bbe: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116bc1: ff 75 e0 pushl -0x20(%ebp)
116bc4: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116bc5: 57 push %edi
116bc6: 57 push %edi
116bc7: 83 c6 10 add $0x10,%esi
116bca: 56 push %esi
116bcb: 8d 43 68 lea 0x68(%ebx),%eax
116bce: 50 push %eax
116bcf: e8 10 38 00 00 call 11a3e4 <_Watchdog_Insert>
if ( !ts->active ) {
116bd4: 8a 43 7c mov 0x7c(%ebx),%al
116bd7: 83 c4 10 add $0x10,%esp
116bda: 84 c0 test %al,%al
116bdc: 75 07 jne 116be5 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116bde: 89 d8 mov %ebx,%eax
116be0: e8 4d fd ff ff call 116932 <_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 );
}
}
116be5: 8d 65 f4 lea -0xc(%ebp),%esp
116be8: 5b pop %ebx
116be9: 5e pop %esi
116bea: 5f pop %edi
116beb: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116bec: e9 dd 28 00 00 jmp 1194ce <_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 );
116bf1: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
116bf4: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
116bf7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
116bfa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116bfd: 5b pop %ebx <== NOT EXECUTED
116bfe: 5e pop %esi <== NOT EXECUTED
116bff: 5f pop %edi <== NOT EXECUTED
116c00: 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 );
116c01: e9 ce 06 00 00 jmp 1172d4 <_Chain_Append> <== NOT EXECUTED
0010cc5b <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cc5b: 55 push %ebp
10cc5c: 89 e5 mov %esp,%ebp
10cc5e: 57 push %edi
10cc5f: 56 push %esi
10cc60: 53 push %ebx
10cc61: 83 ec 0c sub $0xc,%esp
10cc64: 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 );
}
}
10cc67: 8b 1d d4 44 12 00 mov 0x1244d4,%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 );
10cc6d: 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 );
10cc71: eb 15 jmp 10cc88 <_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 )
10cc73: 8b 43 30 mov 0x30(%ebx),%eax
10cc76: 85 c0 test %eax,%eax
10cc78: 74 0b je 10cc85 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cc7a: 52 push %edx
10cc7b: 57 push %edi
10cc7c: 56 push %esi
10cc7d: ff 75 08 pushl 0x8(%ebp)
10cc80: ff d0 call *%eax
10cc82: 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 ) {
10cc85: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10cc88: 81 fb cc 44 12 00 cmp $0x1244cc,%ebx
10cc8e: 75 e3 jne 10cc73 <_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 );
}
}
10cc90: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cc93: 5b pop %ebx <== NOT EXECUTED
10cc94: 5e pop %esi <== NOT EXECUTED
10cc95: 5f pop %edi <== NOT EXECUTED
10cc96: c9 leave <== NOT EXECUTED
10cc97: c3 ret <== NOT EXECUTED
0010cb44 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10cb44: 55 push %ebp
10cb45: 89 e5 mov %esp,%ebp
10cb47: 57 push %edi
10cb48: 56 push %esi
10cb49: 53 push %ebx
10cb4a: 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;
10cb4d: a1 34 02 12 00 mov 0x120234,%eax
10cb52: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10cb55: 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;
10cb5b: c7 05 cc 44 12 00 d0 movl $0x1244d0,0x1244cc
10cb62: 44 12 00
head->previous = NULL;
10cb65: c7 05 d0 44 12 00 00 movl $0x0,0x1244d0
10cb6c: 00 00 00
tail->previous = head;
10cb6f: c7 05 d4 44 12 00 cc movl $0x1244cc,0x1244d4
10cb76: 44 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cb79: c7 05 e4 42 12 00 e8 movl $0x1242e8,0x1242e4
10cb80: 42 12 00
head->previous = NULL;
10cb83: c7 05 e8 42 12 00 00 movl $0x0,0x1242e8
10cb8a: 00 00 00
tail->previous = head;
10cb8d: c7 05 ec 42 12 00 e4 movl $0x1242e4,0x1242ec
10cb94: 42 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cb97: 85 f6 test %esi,%esi
10cb99: 74 53 je 10cbee <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cb9b: 6b c8 34 imul $0x34,%eax,%ecx
10cb9e: 83 ec 0c sub $0xc,%esp
10cba1: 51 push %ecx
10cba2: 89 4d e0 mov %ecx,-0x20(%ebp)
10cba5: e8 3a 04 00 00 call 10cfe4 <_Workspace_Allocate_or_fatal_error>
10cbaa: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cbac: 31 c0 xor %eax,%eax
10cbae: 8b 4d e0 mov -0x20(%ebp),%ecx
10cbb1: 89 df mov %ebx,%edi
10cbb3: f3 aa rep stos %al,%es:(%edi)
10cbb5: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cbb7: 83 c4 10 add $0x10,%esp
10cbba: 31 d2 xor %edx,%edx
10cbbc: eb 2b jmp 10cbe9 <_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;
10cbbe: 8d 7b 14 lea 0x14(%ebx),%edi
10cbc1: 89 c6 mov %eax,%esi
10cbc3: b9 08 00 00 00 mov $0x8,%ecx
10cbc8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10cbca: 83 ec 0c sub $0xc,%esp
10cbcd: 53 push %ebx
10cbce: 89 45 dc mov %eax,-0x24(%ebp)
10cbd1: 89 55 e0 mov %edx,-0x20(%ebp)
10cbd4: e8 ef 2f 00 00 call 10fbc8 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cbd9: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cbdc: 8b 55 e0 mov -0x20(%ebp),%edx
10cbdf: 42 inc %edx
10cbe0: 8b 45 dc mov -0x24(%ebp),%eax
10cbe3: 83 c0 20 add $0x20,%eax
10cbe6: 83 c4 10 add $0x10,%esp
10cbe9: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cbec: 72 d0 jb 10cbbe <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cbee: 8d 65 f4 lea -0xc(%ebp),%esp
10cbf1: 5b pop %ebx
10cbf2: 5e pop %esi
10cbf3: 5f pop %edi
10cbf4: c9 leave
10cbf5: c3 ret
0010e4a4 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e4a4: 55 push %ebp
10e4a5: 89 e5 mov %esp,%ebp
10e4a7: 57 push %edi
10e4a8: 56 push %esi
10e4a9: 53 push %ebx
10e4aa: 83 ec 1c sub $0x1c,%esp
10e4ad: 8b 75 08 mov 0x8(%ebp),%esi
10e4b0: 8b 7d 0c mov 0xc(%ebp),%edi
10e4b3: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e4b6: 9c pushf
10e4b7: fa cli
10e4b8: 58 pop %eax
}
}
_ISR_Enable( level );
}
10e4b9: 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 );
10e4bb: 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 ) ) {
10e4be: 39 ca cmp %ecx,%edx
10e4c0: 74 44 je 10e506 <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e4c2: 85 ff test %edi,%edi
10e4c4: 74 3c je 10e502 <_Watchdog_Adjust+0x5e>
10e4c6: 4f dec %edi
10e4c7: 75 3d jne 10e506 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e4c9: 01 5a 10 add %ebx,0x10(%edx)
break;
10e4cc: eb 38 jmp 10e506 <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e4ce: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e4d0: 8b 7a 10 mov 0x10(%edx),%edi
10e4d3: 39 fb cmp %edi,%ebx
10e4d5: 73 07 jae 10e4de <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e4d7: 29 df sub %ebx,%edi
10e4d9: 89 7a 10 mov %edi,0x10(%edx)
break;
10e4dc: eb 28 jmp 10e506 <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e4de: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e4e5: 50 push %eax
10e4e6: 9d popf
_Watchdog_Tickle( header );
10e4e7: 83 ec 0c sub $0xc,%esp
10e4ea: 56 push %esi
10e4eb: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e4ee: e8 a5 01 00 00 call 10e698 <_Watchdog_Tickle>
_ISR_Disable( level );
10e4f3: 9c pushf
10e4f4: fa cli
10e4f5: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e4f6: 83 c4 10 add $0x10,%esp
10e4f9: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e4fc: 39 0e cmp %ecx,(%esi)
10e4fe: 74 06 je 10e506 <_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;
10e500: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e502: 85 db test %ebx,%ebx
10e504: 75 c8 jne 10e4ce <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e506: 50 push %eax
10e507: 9d popf
}
10e508: 8d 65 f4 lea -0xc(%ebp),%esp
10e50b: 5b pop %ebx
10e50c: 5e pop %esi
10e50d: 5f pop %edi
10e50e: c9 leave
10e50f: c3 ret
0010ce9c <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10ce9c: 55 push %ebp
10ce9d: 89 e5 mov %esp,%ebp
10ce9f: 56 push %esi
10cea0: 53 push %ebx
10cea1: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10cea4: 9c pushf
10cea5: fa cli
10cea6: 5e pop %esi
previous_state = the_watchdog->state;
10cea7: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10ceaa: 83 f8 01 cmp $0x1,%eax
10cead: 74 09 je 10ceb8 <_Watchdog_Remove+0x1c>
10ceaf: 72 42 jb 10cef3 <_Watchdog_Remove+0x57>
10ceb1: 83 f8 03 cmp $0x3,%eax
10ceb4: 77 3d ja 10cef3 <_Watchdog_Remove+0x57> <== NEVER TAKEN
10ceb6: eb 09 jmp 10cec1 <_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;
10ceb8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10cebf: eb 32 jmp 10cef3 <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cec1: 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 );
}
10cec8: 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) )
10ceca: 83 39 00 cmpl $0x0,(%ecx)
10cecd: 74 06 je 10ced5 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10cecf: 8b 5a 10 mov 0x10(%edx),%ebx
10ced2: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10ced5: 8b 1d 10 44 12 00 mov 0x124410,%ebx
10cedb: 85 db test %ebx,%ebx
10cedd: 74 0c je 10ceeb <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cedf: 8b 1d 24 48 12 00 mov 0x124824,%ebx
10cee5: 89 1d a8 43 12 00 mov %ebx,0x1243a8
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10ceeb: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10ceee: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10cef1: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10cef3: 8b 0d 14 44 12 00 mov 0x124414,%ecx
10cef9: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10cefc: 56 push %esi
10cefd: 9d popf
return( previous_state );
}
10cefe: 5b pop %ebx
10ceff: 5e pop %esi
10cf00: c9 leave
10cf01: c3 ret
0010e030 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e030: 55 push %ebp
10e031: 89 e5 mov %esp,%ebp
10e033: 57 push %edi
10e034: 56 push %esi
10e035: 53 push %ebx
10e036: 83 ec 20 sub $0x20,%esp
10e039: 8b 7d 08 mov 0x8(%ebp),%edi
10e03c: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e03f: 9c pushf
10e040: fa cli
10e041: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e044: 56 push %esi
10e045: 57 push %edi
10e046: 68 c8 0f 12 00 push $0x120fc8
10e04b: e8 88 aa ff ff call 108ad8 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10e050: 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 );
10e052: 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 ) ) {
10e055: 83 c4 10 add $0x10,%esp
10e058: 39 f3 cmp %esi,%ebx
10e05a: 74 1d je 10e079 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e05c: 52 push %edx
10e05d: 52 push %edx
10e05e: 53 push %ebx
10e05f: 6a 00 push $0x0
10e061: e8 32 00 00 00 call 10e098 <_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 )
10e066: 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 ) ;
10e068: 83 c4 10 add $0x10,%esp
10e06b: 39 f3 cmp %esi,%ebx
10e06d: 75 ed jne 10e05c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e06f: 50 push %eax
10e070: 50 push %eax
10e071: 57 push %edi
10e072: 68 df 0f 12 00 push $0x120fdf
10e077: eb 08 jmp 10e081 <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e079: 83 ec 0c sub $0xc,%esp
10e07c: 68 ee 0f 12 00 push $0x120fee
10e081: e8 52 aa ff ff call 108ad8 <printk>
10e086: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e089: ff 75 e4 pushl -0x1c(%ebp)
10e08c: 9d popf
}
10e08d: 8d 65 f4 lea -0xc(%ebp),%esp
10e090: 5b pop %ebx
10e091: 5e pop %esi
10e092: 5f pop %edi
10e093: c9 leave
10e094: c3 ret
0010a7b4 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a7b4: 55 push %ebp
10a7b5: 89 e5 mov %esp,%ebp
10a7b7: 57 push %edi
10a7b8: 56 push %esi
10a7b9: 53 push %ebx
10a7ba: 83 ec 18 sub $0x18,%esp
10a7bd: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7c0: 8b 75 0c mov 0xc(%ebp),%esi
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a7c3: 68 78 72 12 00 push $0x127278
10a7c8: e8 07 10 00 00 call 10b7d4 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10a7cd: 58 pop %eax
10a7ce: 5a pop %edx
10a7cf: 6a 01 push $0x1
10a7d1: 53 push %ebx
10a7d2: e8 85 60 00 00 call 11085c <fcntl>
10a7d7: 83 c4 10 add $0x10,%esp
10a7da: 85 c0 test %eax,%eax
10a7dc: 79 1d jns 10a7fb <aio_cancel+0x47>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a7de: 83 ec 0c sub $0xc,%esp
10a7e1: 68 78 72 12 00 push $0x127278
10a7e6: e8 69 10 00 00 call 10b854 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a7eb: e8 dc 8e 00 00 call 1136cc <__errno>
10a7f0: c7 00 09 00 00 00 movl $0x9,(%eax)
10a7f6: e9 fd 00 00 00 jmp 10a8f8 <aio_cancel+0x144>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
10a7fb: 85 f6 test %esi,%esi
10a7fd: 0f 85 d7 00 00 00 jne 10a8da <aio_cancel+0x126>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a803: 57 push %edi
10a804: 6a 00 push $0x0
10a806: 53 push %ebx
10a807: 68 c0 72 12 00 push $0x1272c0
10a80c: e8 0b 03 00 00 call 10ab1c <rtems_aio_search_fd>
10a811: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10a813: 83 c4 10 add $0x10,%esp
10a816: 85 c0 test %eax,%eax
10a818: 0f 85 82 00 00 00 jne 10a8a0 <aio_cancel+0xec>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a81e: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc
10a825: 72 12 00
10a828: 74 5c je 10a886 <aio_cancel+0xd2> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a82a: 56 push %esi
10a82b: 6a 00 push $0x0
10a82d: 53 push %ebx
10a82e: 68 cc 72 12 00 push $0x1272cc
10a833: e8 e4 02 00 00 call 10ab1c <rtems_aio_search_fd>
10a838: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a83a: 83 c4 10 add $0x10,%esp
10a83d: 85 c0 test %eax,%eax
10a83f: 75 17 jne 10a858 <aio_cancel+0xa4>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a841: 83 ec 0c sub $0xc,%esp
10a844: 68 78 72 12 00 push $0x127278
10a849: e8 06 10 00 00 call 10b854 <pthread_mutex_unlock>
return AIO_ALLDONE;
10a84e: 83 c4 10 add $0x10,%esp
10a851: b3 02 mov $0x2,%bl
10a853: e9 04 01 00 00 jmp 10a95c <aio_cancel+0x1a8>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a858: 83 ec 0c sub $0xc,%esp
10a85b: 50 push %eax
10a85c: e8 db 26 00 00 call 10cf3c <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a861: 89 1c 24 mov %ebx,(%esp)
10a864: e8 f2 05 00 00 call 10ae5b <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10a869: 8d 73 1c lea 0x1c(%ebx),%esi
10a86c: 89 34 24 mov %esi,(%esp)
10a86f: e8 40 0d 00 00 call 10b5b4 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10a874: 89 34 24 mov %esi,(%esp)
10a877: e8 44 0a 00 00 call 10b2c0 <pthread_cond_destroy>
free (r_chain);
10a87c: 89 1c 24 mov %ebx,(%esp)
10a87f: e8 ac d4 ff ff call 107d30 <free>
10a884: eb 3e jmp 10a8c4 <aio_cancel+0x110>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10a886: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a889: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a88e: e8 c1 0f 00 00 call 10b854 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a893: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a896: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a89b: e9 bc 00 00 00 jmp 10a95c <aio_cancel+0x1a8> <== NOT EXECUTED
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a8a0: 8d 58 1c lea 0x1c(%eax),%ebx
10a8a3: 83 ec 0c sub $0xc,%esp
10a8a6: 53 push %ebx
10a8a7: e8 28 0f 00 00 call 10b7d4 <pthread_mutex_lock>
10a8ac: 89 34 24 mov %esi,(%esp)
10a8af: e8 88 26 00 00 call 10cf3c <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8b4: 89 34 24 mov %esi,(%esp)
10a8b7: e8 9f 05 00 00 call 10ae5b <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10a8bc: 89 1c 24 mov %ebx,(%esp)
10a8bf: e8 90 0f 00 00 call 10b854 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8c4: c7 04 24 78 72 12 00 movl $0x127278,(%esp)
10a8cb: e8 84 0f 00 00 call 10b854 <pthread_mutex_unlock>
return AIO_CANCELED;
10a8d0: 83 c4 10 add $0x10,%esp
10a8d3: 31 db xor %ebx,%ebx
10a8d5: e9 82 00 00 00 jmp 10a95c <aio_cancel+0x1a8>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10a8da: 8b 3e mov (%esi),%edi
10a8dc: 39 df cmp %ebx,%edi
10a8de: 74 20 je 10a900 <aio_cancel+0x14c>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8e0: 83 ec 0c sub $0xc,%esp
10a8e3: 68 78 72 12 00 push $0x127278
10a8e8: e8 67 0f 00 00 call 10b854 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a8ed: e8 da 8d 00 00 call 1136cc <__errno>
10a8f2: c7 00 16 00 00 00 movl $0x16,(%eax)
10a8f8: 83 c4 10 add $0x10,%esp
10a8fb: 83 cb ff or $0xffffffff,%ebx
10a8fe: eb 5c jmp 10a95c <aio_cancel+0x1a8>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a900: 53 push %ebx
10a901: 6a 00 push $0x0
10a903: 57 push %edi
10a904: 68 c0 72 12 00 push $0x1272c0
10a909: e8 0e 02 00 00 call 10ab1c <rtems_aio_search_fd>
if (r_chain == NULL) {
10a90e: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
10a911: bb 02 00 00 00 mov $0x2,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
10a916: 85 c0 test %eax,%eax
10a918: 75 42 jne 10a95c <aio_cancel+0x1a8>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a91a: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc
10a921: 72 12 00
10a924: 74 26 je 10a94c <aio_cancel+0x198> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a926: 51 push %ecx
10a927: 6a 00 push $0x0
10a929: 57 push %edi
10a92a: 68 cc 72 12 00 push $0x1272cc
10a92f: e8 e8 01 00 00 call 10ab1c <rtems_aio_search_fd>
if (r_chain == NULL) {
10a934: 83 c4 10 add $0x10,%esp
10a937: 85 c0 test %eax,%eax
10a939: 74 a5 je 10a8e0 <aio_cancel+0x12c>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10a93b: 52 push %edx
10a93c: 52 push %edx
10a93d: 56 push %esi
10a93e: 83 c0 08 add $0x8,%eax
10a941: 50 push %eax
10a942: e8 5d 05 00 00 call 10aea4 <rtems_aio_remove_req>
10a947: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
10a949: 58 pop %eax
10a94a: eb 03 jmp 10a94f <aio_cancel+0x19b>
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
10a94c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a94f: 68 78 72 12 00 push $0x127278
10a954: e8 fb 0e 00 00 call 10b854 <pthread_mutex_unlock>
return AIO_ALLDONE;
10a959: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
}
10a95c: 89 d8 mov %ebx,%eax
10a95e: 8d 65 f4 lea -0xc(%ebp),%esp
10a961: 5b pop %ebx
10a962: 5e pop %esi
10a963: 5f pop %edi
10a964: c9 leave
10a965: c3 ret
0010a974 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a974: 55 push %ebp
10a975: 89 e5 mov %esp,%ebp
10a977: 53 push %ebx
10a978: 83 ec 04 sub $0x4,%esp
10a97b: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a97e: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10a985: 74 1b je 10a9a2 <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10a987: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10a98e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a995: e8 32 8d 00 00 call 1136cc <__errno>
10a99a: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9a0: eb 74 jmp 10aa16 <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10a9a2: 50 push %eax
10a9a3: 50 push %eax
10a9a4: 6a 03 push $0x3
10a9a6: ff 33 pushl (%ebx)
10a9a8: e8 af 5e 00 00 call 11085c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10a9ad: 83 e0 03 and $0x3,%eax
10a9b0: 48 dec %eax
10a9b1: 83 c4 10 add $0x10,%esp
10a9b4: 83 f8 01 cmp $0x1,%eax
10a9b7: 76 1b jbe 10a9d4 <aio_fsync+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10a9b9: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10a9c0: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9c7: e8 00 8d 00 00 call 1136cc <__errno>
10a9cc: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9d2: eb 42 jmp 10aa16 <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10a9d4: 83 ec 0c sub $0xc,%esp
10a9d7: 6a 18 push $0x18
10a9d9: e8 d6 d7 ff ff call 1081b4 <malloc>
if (req == NULL)
10a9de: 83 c4 10 add $0x10,%esp
10a9e1: 85 c0 test %eax,%eax
10a9e3: 75 1b jne 10aa00 <aio_fsync+0x8c> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10a9e5: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10a9ec: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10a9f3: e8 d4 8c 00 00 call 1136cc <__errno> <== NOT EXECUTED
10a9f8: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10a9fe: eb 16 jmp 10aa16 <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa00: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa03: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10aa0a: 89 45 08 mov %eax,0x8(%ebp)
}
10aa0d: 8b 5d fc mov -0x4(%ebp),%ebx
10aa10: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10aa11: e9 eb 04 00 00 jmp 10af01 <rtems_aio_enqueue>
}
10aa16: 83 c8 ff or $0xffffffff,%eax
10aa19: 8b 5d fc mov -0x4(%ebp),%ebx
10aa1c: c9 leave
10aa1d: c3 ret
0010b0fc <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b0fc: 55 push %ebp
10b0fd: 89 e5 mov %esp,%ebp
10b0ff: 53 push %ebx
10b100: 83 ec 0c sub $0xc,%esp
10b103: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b106: 6a 03 push $0x3
10b108: ff 33 pushl (%ebx)
10b10a: e8 4d 57 00 00 call 11085c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b10f: 83 e0 03 and $0x3,%eax
10b112: 83 c4 10 add $0x10,%esp
10b115: 83 f8 02 cmp $0x2,%eax
10b118: 74 1f je 10b139 <aio_read+0x3d>
10b11a: 85 c0 test %eax,%eax
10b11c: 74 1b je 10b139 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b11e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b125: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b12c: e8 9b 85 00 00 call 1136cc <__errno>
10b131: c7 00 09 00 00 00 movl $0x9,(%eax)
10b137: eb 69 jmp 10b1a2 <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b139: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b13d: 75 06 jne 10b145 <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b13f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b143: 79 1b jns 10b160 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b145: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b14c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b153: e8 74 85 00 00 call 1136cc <__errno>
10b158: c7 00 16 00 00 00 movl $0x16,(%eax)
10b15e: eb 42 jmp 10b1a2 <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b160: 83 ec 0c sub $0xc,%esp
10b163: 6a 18 push $0x18
10b165: e8 4a d0 ff ff call 1081b4 <malloc>
if (req == NULL)
10b16a: 83 c4 10 add $0x10,%esp
10b16d: 85 c0 test %eax,%eax
10b16f: 75 1b jne 10b18c <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b171: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b178: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b17f: e8 48 85 00 00 call 1136cc <__errno> <== NOT EXECUTED
10b184: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b18a: eb 16 jmp 10b1a2 <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b18c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b18f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b196: 89 45 08 mov %eax,0x8(%ebp)
}
10b199: 8b 5d fc mov -0x4(%ebp),%ebx
10b19c: 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);
10b19d: e9 5f fd ff ff jmp 10af01 <rtems_aio_enqueue>
}
10b1a2: 83 c8 ff or $0xffffffff,%eax
10b1a5: 8b 5d fc mov -0x4(%ebp),%ebx
10b1a8: c9 leave
10b1a9: c3 ret
0010b1b8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b1b8: 55 push %ebp
10b1b9: 89 e5 mov %esp,%ebp
10b1bb: 53 push %ebx
10b1bc: 83 ec 0c sub $0xc,%esp
10b1bf: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b1c2: 6a 03 push $0x3
10b1c4: ff 33 pushl (%ebx)
10b1c6: e8 91 56 00 00 call 11085c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b1cb: 83 e0 03 and $0x3,%eax
10b1ce: 48 dec %eax
10b1cf: 83 c4 10 add $0x10,%esp
10b1d2: 83 f8 01 cmp $0x1,%eax
10b1d5: 76 1b jbe 10b1f2 <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1d7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b1de: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1e5: e8 e2 84 00 00 call 1136cc <__errno>
10b1ea: c7 00 09 00 00 00 movl $0x9,(%eax)
10b1f0: eb 69 jmp 10b25b <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b1f2: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b1f6: 75 06 jne 10b1fe <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b1f8: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b1fc: 79 1b jns 10b219 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b1fe: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b205: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b20c: e8 bb 84 00 00 call 1136cc <__errno>
10b211: c7 00 16 00 00 00 movl $0x16,(%eax)
10b217: eb 42 jmp 10b25b <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b219: 83 ec 0c sub $0xc,%esp
10b21c: 6a 18 push $0x18
10b21e: e8 91 cf ff ff call 1081b4 <malloc>
if (req == NULL)
10b223: 83 c4 10 add $0x10,%esp
10b226: 85 c0 test %eax,%eax
10b228: 75 1b jne 10b245 <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b22a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b231: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b238: e8 8f 84 00 00 call 1136cc <__errno> <== NOT EXECUTED
10b23d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b243: eb 16 jmp 10b25b <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b245: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b248: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b24f: 89 45 08 mov %eax,0x8(%ebp)
}
10b252: 8b 5d fc mov -0x4(%ebp),%ebx
10b255: 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);
10b256: e9 a6 fc ff ff jmp 10af01 <rtems_aio_enqueue>
}
10b25b: 83 c8 ff or $0xffffffff,%eax
10b25e: 8b 5d fc mov -0x4(%ebp),%ebx
10b261: c9 leave
10b262: c3 ret
00109f98 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109f98: 55 push %ebp
109f99: 89 e5 mov %esp,%ebp
109f9b: 83 ec 08 sub $0x8,%esp
109f9e: 8b 45 08 mov 0x8(%ebp),%eax
109fa1: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109fa4: 85 d2 test %edx,%edx
109fa6: 74 3c je 109fe4 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109fa8: 83 f8 01 cmp $0x1,%eax
109fab: 75 0b jne 109fb8 <clock_gettime+0x20>
_TOD_Get(tp);
109fad: 83 ec 0c sub $0xc,%esp
109fb0: 52 push %edx
109fb1: e8 b6 1b 00 00 call 10bb6c <_TOD_Get>
109fb6: eb 13 jmp 109fcb <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
109fb8: 83 f8 04 cmp $0x4,%eax
109fbb: 74 05 je 109fc2 <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
109fbd: 83 f8 02 cmp $0x2,%eax
109fc0: 75 10 jne 109fd2 <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
109fc2: 83 ec 0c sub $0xc,%esp
109fc5: 52 push %edx
109fc6: e8 f5 1b 00 00 call 10bbc0 <_TOD_Get_uptime_as_timespec>
return 0;
109fcb: 83 c4 10 add $0x10,%esp
109fce: 31 c0 xor %eax,%eax
109fd0: eb 20 jmp 109ff2 <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
109fd2: 83 f8 03 cmp $0x3,%eax
109fd5: 75 0d jne 109fe4 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
109fd7: e8 14 80 00 00 call 111ff0 <__errno>
109fdc: c7 00 58 00 00 00 movl $0x58,(%eax)
109fe2: eb 0b jmp 109fef <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
109fe4: e8 07 80 00 00 call 111ff0 <__errno>
109fe9: c7 00 16 00 00 00 movl $0x16,(%eax)
109fef: 83 c8 ff or $0xffffffff,%eax
return 0;
}
109ff2: c9 leave
109ff3: c3 ret
00109ff4 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
109ff4: 55 push %ebp
109ff5: 89 e5 mov %esp,%ebp
109ff7: 83 ec 08 sub $0x8,%esp
109ffa: 8b 45 08 mov 0x8(%ebp),%eax
109ffd: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10a000: 85 d2 test %edx,%edx
10a002: 74 44 je 10a048 <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a004: 83 f8 01 cmp $0x1,%eax
10a007: 75 28 jne 10a031 <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a009: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a00f: 76 37 jbe 10a048 <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a011: a1 20 63 12 00 mov 0x126320,%eax
10a016: 40 inc %eax
10a017: a3 20 63 12 00 mov %eax,0x126320
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a01c: 83 ec 0c sub $0xc,%esp
10a01f: 52 push %edx
10a020: e8 f3 1b 00 00 call 10bc18 <_TOD_Set>
_Thread_Enable_dispatch();
10a025: e8 78 2e 00 00 call 10cea2 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a02a: 83 c4 10 add $0x10,%esp
10a02d: 31 c0 xor %eax,%eax
10a02f: eb 25 jmp 10a056 <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a031: 83 f8 02 cmp $0x2,%eax
10a034: 74 05 je 10a03b <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a036: 83 f8 03 cmp $0x3,%eax
10a039: 75 0d jne 10a048 <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a03b: e8 b0 7f 00 00 call 111ff0 <__errno>
10a040: c7 00 58 00 00 00 movl $0x58,(%eax)
10a046: eb 0b jmp 10a053 <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a048: e8 a3 7f 00 00 call 111ff0 <__errno>
10a04d: c7 00 16 00 00 00 movl $0x16,(%eax)
10a053: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a056: c9 leave
10a057: c3 ret
001216c4 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
1216c4: 55 push %ebp
1216c5: 89 e5 mov %esp,%ebp
1216c7: 57 push %edi
1216c8: 56 push %esi
1216c9: 53 push %ebx
1216ca: 83 ec 4c sub $0x4c,%esp
1216cd: 8b 5d 0c mov 0xc(%ebp),%ebx
1216d0: 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() )
1216d3: e8 64 fd ff ff call 12143c <getpid>
1216d8: 39 45 08 cmp %eax,0x8(%ebp)
1216db: 74 0d je 1216ea <killinfo+0x26>
rtems_set_errno_and_return_minus_one( ESRCH );
1216dd: e8 02 43 ff ff call 1159e4 <__errno>
1216e2: c7 00 03 00 00 00 movl $0x3,(%eax)
1216e8: eb 0f jmp 1216f9 <killinfo+0x35>
/*
* Validate the signal passed.
*/
if ( !sig )
1216ea: 85 db test %ebx,%ebx
1216ec: 75 13 jne 121701 <killinfo+0x3d>
rtems_set_errno_and_return_minus_one( EINVAL );
1216ee: e8 f1 42 ff ff call 1159e4 <__errno>
1216f3: c7 00 16 00 00 00 movl $0x16,(%eax)
1216f9: 83 c8 ff or $0xffffffff,%eax
1216fc: e9 ef 01 00 00 jmp 1218f0 <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
121701: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121704: 83 f9 1f cmp $0x1f,%ecx
121707: 77 e5 ja 1216ee <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 )
121709: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
12170c: 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 )
12170e: 83 ba d8 a9 12 00 01 cmpl $0x1,0x12a9d8(%edx)
121715: 0f 84 d5 01 00 00 je 1218f0 <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 ) )
12171b: 83 fb 04 cmp $0x4,%ebx
12171e: 74 0a je 12172a <killinfo+0x66>
121720: 83 fb 08 cmp $0x8,%ebx
121723: 74 05 je 12172a <killinfo+0x66>
121725: 83 fb 0b cmp $0xb,%ebx
121728: 75 16 jne 121740 <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
12172a: e8 89 03 00 00 call 121ab8 <pthread_self>
12172f: 56 push %esi
121730: 56 push %esi
121731: 53 push %ebx
121732: 50 push %eax
121733: e8 d8 02 00 00 call 121a10 <pthread_kill>
121738: 83 c4 10 add $0x10,%esp
12173b: e9 b0 01 00 00 jmp 1218f0 <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
121740: be 01 00 00 00 mov $0x1,%esi
121745: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
121747: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
12174a: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
121751: 85 ff test %edi,%edi
121753: 75 09 jne 12175e <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
121755: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
12175c: eb 05 jmp 121763 <killinfo+0x9f>
} else {
siginfo->si_value = *value;
12175e: 8b 07 mov (%edi),%eax
121760: 89 45 e4 mov %eax,-0x1c(%ebp)
121763: a1 54 a4 12 00 mov 0x12a454,%eax
121768: 40 inc %eax
121769: 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;
12176e: a1 9c a9 12 00 mov 0x12a99c,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
121773: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
121779: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
12177f: f7 d2 not %edx
121781: 85 d6 test %edx,%esi
121783: 0f 85 ed 00 00 00 jne 121876 <killinfo+0x1b2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
121789: 8b 15 5c ab 12 00 mov 0x12ab5c,%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 );
12178f: eb 23 jmp 1217b4 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
121791: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
121793: 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)
121799: 85 72 30 test %esi,0x30(%edx)
12179c: 0f 85 d4 00 00 00 jne 121876 <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
1217a2: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
1217a8: f7 d1 not %ecx
1217aa: 85 ce test %ecx,%esi
1217ac: 0f 85 c4 00 00 00 jne 121876 <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 ) {
1217b2: 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 );
1217b4: 81 fa 60 ab 12 00 cmp $0x12ab60,%edx
1217ba: 75 d5 jne 121791 <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
1217bc: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx
1217c3: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
1217c4: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
1217c6: 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 ] )
1217cd: 8b 7d cc mov -0x34(%ebp),%edi
1217d0: 8b 14 bd 2c a4 12 00 mov 0x12a42c(,%edi,4),%edx
1217d7: 85 d2 test %edx,%edx
1217d9: 0f 84 86 00 00 00 je 121865 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
1217df: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
1217e2: 0f b7 7a 10 movzwl 0x10(%edx),%edi
1217e6: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
1217e9: 8b 52 1c mov 0x1c(%edx),%edx
1217ec: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
1217ef: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
1217f6: 89 5d b4 mov %ebx,-0x4c(%ebp)
1217f9: eb 5f jmp 12185a <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
1217fb: 8b 5d d0 mov -0x30(%ebp),%ebx
1217fe: 8b 7d c0 mov -0x40(%ebp),%edi
121801: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
121804: 85 d2 test %edx,%edx
121806: 74 4f je 121857 <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 )
121808: 8b 5a 14 mov 0x14(%edx),%ebx
12180b: 89 5d d4 mov %ebx,-0x2c(%ebp)
12180e: 39 cb cmp %ecx,%ebx
121810: 77 45 ja 121857 <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
121812: 8b ba ec 00 00 00 mov 0xec(%edx),%edi
121818: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
12181e: f7 d7 not %edi
121820: 85 fe test %edi,%esi
121822: 74 33 je 121857 <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 ) {
121824: 39 cb cmp %ecx,%ebx
121826: 72 2a jb 121852 <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 ) ) {
121828: 85 c0 test %eax,%eax
12182a: 74 2b je 121857 <killinfo+0x193> <== NEVER TAKEN
12182c: 8b 78 10 mov 0x10(%eax),%edi
12182f: 89 7d c8 mov %edi,-0x38(%ebp)
121832: 85 ff test %edi,%edi
121834: 74 21 je 121857 <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
121836: 8b 7a 10 mov 0x10(%edx),%edi
121839: 85 ff test %edi,%edi
12183b: 74 15 je 121852 <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
12183d: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
121844: 75 11 jne 121857 <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
121846: 81 e7 00 00 00 10 and $0x10000000,%edi
12184c: 74 09 je 121857 <killinfo+0x193>
12184e: 89 d9 mov %ebx,%ecx
121850: eb 03 jmp 121855 <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 ) ) {
121852: 8b 4d d4 mov -0x2c(%ebp),%ecx
121855: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
121857: ff 45 d0 incl -0x30(%ebp)
12185a: 8b 55 c4 mov -0x3c(%ebp),%edx
12185d: 39 55 d0 cmp %edx,-0x30(%ebp)
121860: 76 99 jbe 1217fb <killinfo+0x137>
121862: 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++) {
121865: ff 45 cc incl -0x34(%ebp)
121868: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
12186c: 0f 85 5b ff ff ff jne 1217cd <killinfo+0x109>
}
}
}
}
if ( interested ) {
121872: 85 c0 test %eax,%eax
121874: 74 13 je 121889 <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 ) ) {
121876: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
121877: 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 ) ) {
12187a: 52 push %edx
12187b: 53 push %ebx
12187c: 50 push %eax
12187d: e8 8a 00 00 00 call 12190c <_POSIX_signals_Unblock_thread>
121882: 83 c4 10 add $0x10,%esp
121885: 84 c0 test %al,%al
121887: 75 60 jne 1218e9 <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 );
121889: 83 ec 0c sub $0xc,%esp
12188c: 56 push %esi
12188d: e8 66 00 00 00 call 1218f8 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
121892: 6b db 0c imul $0xc,%ebx,%ebx
121895: 83 c4 10 add $0x10,%esp
121898: 83 bb d0 a9 12 00 02 cmpl $0x2,0x12a9d0(%ebx)
12189f: 75 48 jne 1218e9 <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
1218a1: 83 ec 0c sub $0xc,%esp
1218a4: 68 50 ab 12 00 push $0x12ab50
1218a9: e8 8e d8 fe ff call 10f13c <_Chain_Get>
if ( !psiginfo ) {
1218ae: 83 c4 10 add $0x10,%esp
1218b1: 85 c0 test %eax,%eax
1218b3: 75 15 jne 1218ca <killinfo+0x206>
_Thread_Enable_dispatch();
1218b5: e8 dc ef fe ff call 110896 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
1218ba: e8 25 41 ff ff call 1159e4 <__errno>
1218bf: c7 00 0b 00 00 00 movl $0xb,(%eax)
1218c5: e9 2f fe ff ff jmp 1216f9 <killinfo+0x35>
}
psiginfo->Info = *siginfo;
1218ca: 8d 78 08 lea 0x8(%eax),%edi
1218cd: 8d 75 dc lea -0x24(%ebp),%esi
1218d0: b9 03 00 00 00 mov $0x3,%ecx
1218d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
1218d7: 52 push %edx
1218d8: 52 push %edx
1218d9: 50 push %eax
1218da: 81 c3 c8 ab 12 00 add $0x12abc8,%ebx
1218e0: 53 push %ebx
1218e1: e8 1a d8 fe ff call 10f100 <_Chain_Append>
1218e6: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
1218e9: e8 a8 ef fe ff call 110896 <_Thread_Enable_dispatch>
return 0;
1218ee: 31 c0 xor %eax,%eax
}
1218f0: 8d 65 f4 lea -0xc(%ebp),%esp
1218f3: 5b pop %ebx
1218f4: 5e pop %esi
1218f5: 5f pop %edi
1218f6: c9 leave
1218f7: c3 ret
0010efdc <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
10efdc: 55 push %ebp
10efdd: 89 e5 mov %esp,%ebp
10efdf: 8b 55 08 mov 0x8(%ebp),%edx
10efe2: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10efe5: 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 )
10efea: 85 d2 test %edx,%edx
10efec: 74 17 je 10f005 <pthread_attr_getinheritsched+0x29><== NEVER TAKEN
10efee: 85 c9 test %ecx,%ecx
10eff0: 74 0e je 10f000 <pthread_attr_getinheritsched+0x24><== NEVER TAKEN
10eff2: 83 3a 00 cmpl $0x0,(%edx)
10eff5: 74 09 je 10f000 <pthread_attr_getinheritsched+0x24><== NEVER TAKEN
return EINVAL;
*inheritsched = attr->inheritsched;
10eff7: 8b 42 10 mov 0x10(%edx),%eax
10effa: 89 01 mov %eax,(%ecx)
return 0;
10effc: 31 c0 xor %eax,%eax
10effe: eb 05 jmp 10f005 <pthread_attr_getinheritsched+0x29>
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10f000: b8 16 00 00 00 mov $0x16,%eax
*inheritsched = attr->inheritsched;
return 0;
}
10f005: c9 leave
10f006: c3 ret
0010f1f8 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f1f8: 55 push %ebp
10f1f9: 89 e5 mov %esp,%ebp
10f1fb: 8b 55 08 mov 0x8(%ebp),%edx
10f1fe: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f201: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f206: 85 d2 test %edx,%edx
10f208: 74 1e je 10f228 <pthread_attr_setschedpolicy+0x30>
10f20a: 83 3a 00 cmpl $0x0,(%edx)
10f20d: 74 19 je 10f228 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f20f: 83 f9 04 cmp $0x4,%ecx
10f212: 77 0f ja 10f223 <pthread_attr_setschedpolicy+0x2b>
10f214: b0 01 mov $0x1,%al
10f216: d3 e0 shl %cl,%eax
10f218: a8 17 test $0x17,%al
10f21a: 74 07 je 10f223 <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f21c: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f21f: 31 c0 xor %eax,%eax
10f221: eb 05 jmp 10f228 <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f223: b8 86 00 00 00 mov $0x86,%eax
}
}
10f228: c9 leave
10f229: c3 ret
0010a518 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a518: 55 push %ebp
10a519: 89 e5 mov %esp,%ebp
10a51b: 57 push %edi
10a51c: 56 push %esi
10a51d: 53 push %ebx
10a51e: 83 ec 1c sub $0x1c,%esp
10a521: 8b 5d 08 mov 0x8(%ebp),%ebx
10a524: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a527: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a52c: 85 db test %ebx,%ebx
10a52e: 0f 84 96 00 00 00 je 10a5ca <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a534: 85 f6 test %esi,%esi
10a536: 0f 84 8e 00 00 00 je 10a5ca <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a53c: 8b 7d 0c mov 0xc(%ebp),%edi
10a53f: 85 ff test %edi,%edi
10a541: 75 0f jne 10a552 <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a543: 83 ec 0c sub $0xc,%esp
10a546: 8d 7d d8 lea -0x28(%ebp),%edi
10a549: 57 push %edi
10a54a: e8 19 ff ff ff call 10a468 <pthread_barrierattr_init>
10a54f: 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;
10a552: 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 )
10a557: 83 3f 00 cmpl $0x0,(%edi)
10a55a: 74 6e je 10a5ca <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a55c: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a560: 75 68 jne 10a5ca <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a562: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a569: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a56c: a1 d0 64 12 00 mov 0x1264d0,%eax
10a571: 40 inc %eax
10a572: a3 d0 64 12 00 mov %eax,0x1264d0
* 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 );
10a577: 83 ec 0c sub $0xc,%esp
10a57a: 68 94 68 12 00 push $0x126894
10a57f: e8 0c 1e 00 00 call 10c390 <_Objects_Allocate>
10a584: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a586: 83 c4 10 add $0x10,%esp
10a589: 85 c0 test %eax,%eax
10a58b: 75 0c jne 10a599 <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a58d: e8 0c 2c 00 00 call 10d19e <_Thread_Enable_dispatch>
return EAGAIN;
10a592: b8 0b 00 00 00 mov $0xb,%eax
10a597: eb 31 jmp 10a5ca <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a599: 50 push %eax
10a59a: 50 push %eax
10a59b: 8d 45 e0 lea -0x20(%ebp),%eax
10a59e: 50 push %eax
10a59f: 8d 46 10 lea 0x10(%esi),%eax
10a5a2: 50 push %eax
10a5a3: e8 a8 14 00 00 call 10ba50 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5a8: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5ab: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a5ae: 8b 15 b0 68 12 00 mov 0x1268b0,%edx
10a5b4: 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;
10a5b7: 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;
10a5be: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a5c0: e8 d9 2b 00 00 call 10d19e <_Thread_Enable_dispatch>
return 0;
10a5c5: 83 c4 10 add $0x10,%esp
10a5c8: 31 c0 xor %eax,%eax
}
10a5ca: 8d 65 f4 lea -0xc(%ebp),%esp
10a5cd: 5b pop %ebx
10a5ce: 5e pop %esi
10a5cf: 5f pop %edi
10a5d0: c9 leave
10a5d1: c3 ret
00109ed0 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109ed0: 55 push %ebp
109ed1: 89 e5 mov %esp,%ebp
109ed3: 56 push %esi
109ed4: 53 push %ebx
109ed5: 8b 5d 08 mov 0x8(%ebp),%ebx
109ed8: 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 )
109edb: 85 db test %ebx,%ebx
109edd: 74 4b je 109f2a <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109edf: a1 c8 62 12 00 mov 0x1262c8,%eax
109ee4: 40 inc %eax
109ee5: a3 c8 62 12 00 mov %eax,0x1262c8
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109eea: 83 ec 0c sub $0xc,%esp
109eed: 6a 10 push $0x10
109eef: e8 02 3c 00 00 call 10daf6 <_Workspace_Allocate>
if ( handler ) {
109ef4: 83 c4 10 add $0x10,%esp
109ef7: 85 c0 test %eax,%eax
109ef9: 74 24 je 109f1f <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109efb: 8b 15 10 68 12 00 mov 0x126810,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109f01: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx
109f07: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f0d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f10: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f13: 51 push %ecx
109f14: 51 push %ecx
109f15: 50 push %eax
109f16: 52 push %edx
109f17: e8 88 15 00 00 call 10b4a4 <_Chain_Append>
109f1c: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f1f: 8d 65 f8 lea -0x8(%ebp),%esp
109f22: 5b pop %ebx
109f23: 5e pop %esi
109f24: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f25: e9 70 2c 00 00 jmp 10cb9a <_Thread_Enable_dispatch>
}
109f2a: 8d 65 f8 lea -0x8(%ebp),%esp
109f2d: 5b pop %ebx
109f2e: 5e pop %esi
109f2f: c9 leave
109f30: c3 ret
0010ac40 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac40: 55 push %ebp
10ac41: 89 e5 mov %esp,%ebp
10ac43: 56 push %esi
10ac44: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac45: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac48: 85 db test %ebx,%ebx
10ac4a: 75 05 jne 10ac51 <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10ac4c: bb f0 0c 12 00 mov $0x120cf0,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10ac51: 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 )
10ac56: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10ac5a: 74 76 je 10acd2 <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10ac5c: 83 3b 00 cmpl $0x0,(%ebx)
10ac5f: 74 71 je 10acd2 <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10ac61: a1 80 73 12 00 mov 0x127380,%eax
10ac66: 40 inc %eax
10ac67: a3 80 73 12 00 mov %eax,0x127380
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10ac6c: 83 ec 0c sub $0xc,%esp
10ac6f: 68 dc 77 12 00 push $0x1277dc
10ac74: e8 f7 22 00 00 call 10cf70 <_Objects_Allocate>
10ac79: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10ac7b: 83 c4 10 add $0x10,%esp
10ac7e: 85 c0 test %eax,%eax
10ac80: 75 0c jne 10ac8e <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10ac82: e8 f7 30 00 00 call 10dd7e <_Thread_Enable_dispatch>
return ENOMEM;
10ac87: b8 0c 00 00 00 mov $0xc,%eax
10ac8c: eb 44 jmp 10acd2 <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ac8e: 8b 43 04 mov 0x4(%ebx),%eax
10ac91: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ac94: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10ac9b: 6a 74 push $0x74
10ac9d: 68 00 08 00 10 push $0x10000800
10aca2: 6a 00 push $0x0
10aca4: 8d 46 18 lea 0x18(%esi),%eax
10aca7: 50 push %eax
10aca8: e8 c7 37 00 00 call 10e474 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10acad: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10acb0: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10acb3: 8b 15 f8 77 12 00 mov 0x1277f8,%edx
10acb9: 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;
10acbc: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10acc3: 8b 55 08 mov 0x8(%ebp),%edx
10acc6: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10acc8: e8 b1 30 00 00 call 10dd7e <_Thread_Enable_dispatch>
return 0;
10accd: 83 c4 10 add $0x10,%esp
10acd0: 31 c0 xor %eax,%eax
}
10acd2: 8d 65 f8 lea -0x8(%ebp),%esp
10acd5: 5b pop %ebx
10acd6: 5e pop %esi
10acd7: c9 leave
10acd8: c3 ret
0010aaf4 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10aaf4: 55 push %ebp
10aaf5: 89 e5 mov %esp,%ebp
10aaf7: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10aafa: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10aaff: 85 d2 test %edx,%edx
10ab01: 74 0d je 10ab10 <pthread_condattr_destroy+0x1c>
10ab03: 83 3a 00 cmpl $0x0,(%edx)
10ab06: 74 08 je 10ab10 <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab08: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab0e: 30 c0 xor %al,%al
}
10ab10: c9 leave
10ab11: c3 ret
0010a228 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a228: 55 push %ebp
10a229: 89 e5 mov %esp,%ebp
10a22b: 57 push %edi
10a22c: 56 push %esi
10a22d: 53 push %ebx
10a22e: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a231: 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 )
10a238: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a23c: 0f 84 0f 02 00 00 je 10a451 <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a242: 8b 5d 0c mov 0xc(%ebp),%ebx
10a245: 85 db test %ebx,%ebx
10a247: 75 05 jne 10a24e <pthread_create+0x26>
10a249: bb 5c f9 11 00 mov $0x11f95c,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a24e: 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 )
10a255: 83 3b 00 cmpl $0x0,(%ebx)
10a258: 0f 84 f3 01 00 00 je 10a451 <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) )
10a25e: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a262: 74 0e je 10a272 <pthread_create+0x4a>
10a264: a1 14 12 12 00 mov 0x121214,%eax
10a269: 39 43 08 cmp %eax,0x8(%ebx)
10a26c: 0f 82 df 01 00 00 jb 10a451 <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 ) {
10a272: 8b 43 10 mov 0x10(%ebx),%eax
10a275: 83 f8 01 cmp $0x1,%eax
10a278: 74 0b je 10a285 <pthread_create+0x5d>
10a27a: 83 f8 02 cmp $0x2,%eax
10a27d: 0f 85 c7 01 00 00 jne 10a44a <pthread_create+0x222>
10a283: eb 1f jmp 10a2a4 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a285: a1 18 58 12 00 mov 0x125818,%eax
10a28a: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10a290: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a296: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a299: 8d 7d c4 lea -0x3c(%ebp),%edi
10a29c: 81 c6 88 00 00 00 add $0x88,%esi
10a2a2: eb 0c jmp 10a2b0 <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2a4: 8b 43 14 mov 0x14(%ebx),%eax
10a2a7: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2aa: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2ad: 8d 73 18 lea 0x18(%ebx),%esi
10a2b0: b9 07 00 00 00 mov $0x7,%ecx
10a2b5: 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;
10a2b7: 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 )
10a2be: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a2c2: 0f 85 89 01 00 00 jne 10a451 <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2c8: 83 ec 0c sub $0xc,%esp
10a2cb: ff 75 c4 pushl -0x3c(%ebp)
10a2ce: e8 f1 58 00 00 call 10fbc4 <_POSIX_Priority_Is_valid>
10a2d3: 83 c4 10 add $0x10,%esp
return EINVAL;
10a2d6: 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 ) )
10a2dd: 84 c0 test %al,%al
10a2df: 0f 84 6c 01 00 00 je 10a451 <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a2e5: 8b 45 c4 mov -0x3c(%ebp),%eax
10a2e8: 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);
10a2eb: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a2f2: 8d 45 e0 lea -0x20(%ebp),%eax
10a2f5: 50 push %eax
10a2f6: 8d 45 e4 lea -0x1c(%ebp),%eax
10a2f9: 50 push %eax
10a2fa: 8d 45 c4 lea -0x3c(%ebp),%eax
10a2fd: 50 push %eax
10a2fe: ff 75 ac pushl -0x54(%ebp)
10a301: e8 de 58 00 00 call 10fbe4 <_POSIX_Thread_Translate_sched_param>
10a306: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a309: 83 c4 10 add $0x10,%esp
10a30c: 85 c0 test %eax,%eax
10a30e: 0f 85 3d 01 00 00 jne 10a451 <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a314: 83 ec 0c sub $0xc,%esp
10a317: ff 35 94 53 12 00 pushl 0x125394
10a31d: e8 56 15 00 00 call 10b878 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a322: c7 04 24 14 55 12 00 movl $0x125514,(%esp)
10a329: e8 aa 1e 00 00 call 10c1d8 <_Objects_Allocate>
10a32e: 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 ) {
10a331: 83 c4 10 add $0x10,%esp
10a334: 85 c0 test %eax,%eax
10a336: 75 05 jne 10a33d <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a338: 83 ec 0c sub $0xc,%esp
10a33b: eb 53 jmp 10a390 <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(
10a33d: 8b 4d e0 mov -0x20(%ebp),%ecx
10a340: 8b 75 e4 mov -0x1c(%ebp),%esi
10a343: 8b 53 08 mov 0x8(%ebx),%edx
10a346: a1 14 12 12 00 mov 0x121214,%eax
10a34b: d1 e0 shl %eax
10a34d: 39 d0 cmp %edx,%eax
10a34f: 73 02 jae 10a353 <pthread_create+0x12b>
10a351: 89 d0 mov %edx,%eax
10a353: 52 push %edx
10a354: 6a 00 push $0x0
10a356: 6a 00 push $0x0
10a358: 51 push %ecx
10a359: 56 push %esi
10a35a: 6a 01 push $0x1
10a35c: 81 e7 ff 00 00 00 and $0xff,%edi
10a362: 2b 7d a8 sub -0x58(%ebp),%edi
10a365: 57 push %edi
10a366: 6a 01 push $0x1
10a368: 50 push %eax
10a369: ff 73 04 pushl 0x4(%ebx)
10a36c: ff 75 b0 pushl -0x50(%ebp)
10a36f: 68 14 55 12 00 push $0x125514
10a374: e8 ff 2c 00 00 call 10d078 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a379: 83 c4 30 add $0x30,%esp
10a37c: 84 c0 test %al,%al
10a37e: 75 2a jne 10a3aa <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a380: 56 push %esi
10a381: 56 push %esi
10a382: ff 75 b0 pushl -0x50(%ebp)
10a385: 68 14 55 12 00 push $0x125514
10a38a: e8 41 21 00 00 call 10c4d0 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a38f: 5b pop %ebx
10a390: ff 35 94 53 12 00 pushl 0x125394
10a396: e8 25 15 00 00 call 10b8c0 <_API_Mutex_Unlock>
return EAGAIN;
10a39b: 83 c4 10 add $0x10,%esp
10a39e: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3a5: e9 a7 00 00 00 jmp 10a451 <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3aa: 8b 45 b0 mov -0x50(%ebp),%eax
10a3ad: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
api->Attributes = *the_attr;
10a3b3: b9 10 00 00 00 mov $0x10,%ecx
10a3b8: 89 d7 mov %edx,%edi
10a3ba: 89 de mov %ebx,%esi
10a3bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a3be: 8b 43 3c mov 0x3c(%ebx),%eax
10a3c1: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a3c4: 8b 45 ac mov -0x54(%ebp),%eax
10a3c7: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a3cd: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a3d3: 8d 75 c4 lea -0x3c(%ebp),%esi
10a3d6: b1 07 mov $0x7,%cl
10a3d8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a3da: 83 ec 0c sub $0xc,%esp
10a3dd: 6a 00 push $0x0
10a3df: ff 75 14 pushl 0x14(%ebp)
10a3e2: ff 75 10 pushl 0x10(%ebp)
10a3e5: 6a 01 push $0x1
10a3e7: ff 75 b0 pushl -0x50(%ebp)
10a3ea: 89 55 a4 mov %edx,-0x5c(%ebp)
10a3ed: e8 32 35 00 00 call 10d924 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a3f2: 83 c4 20 add $0x20,%esp
10a3f5: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a3f9: 8b 55 a4 mov -0x5c(%ebp),%edx
10a3fc: 75 2e jne 10a42c <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a3fe: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a401: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a407: 50 push %eax
10a408: e8 6f 36 00 00 call 10da7c <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a40d: 8b 55 a4 mov -0x5c(%ebp),%edx
10a410: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a416: 58 pop %eax
10a417: 59 pop %ecx
10a418: 81 c2 a8 00 00 00 add $0xa8,%edx
10a41e: 52 push %edx
10a41f: 68 b4 53 12 00 push $0x1253b4
10a424: e8 07 39 00 00 call 10dd30 <_Watchdog_Insert>
10a429: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a42c: 8b 45 b0 mov -0x50(%ebp),%eax
10a42f: 8b 50 08 mov 0x8(%eax),%edx
10a432: 8b 45 08 mov 0x8(%ebp),%eax
10a435: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a437: 83 ec 0c sub $0xc,%esp
10a43a: ff 35 94 53 12 00 pushl 0x125394
10a440: e8 7b 14 00 00 call 10b8c0 <_API_Mutex_Unlock>
return 0;
10a445: 83 c4 10 add $0x10,%esp
10a448: eb 07 jmp 10a451 <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a44a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a451: 8b 45 b4 mov -0x4c(%ebp),%eax
10a454: 8d 65 f4 lea -0xc(%ebp),%esp
10a457: 5b pop %ebx
10a458: 5e pop %esi
10a459: 5f pop %edi
10a45a: c9 leave
10a45b: c3 ret
00110d60 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110d60: 55 push %ebp
110d61: 89 e5 mov %esp,%ebp
110d63: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110d66: ff 75 08 pushl 0x8(%ebp)
110d69: ff 35 28 48 12 00 pushl 0x124828
110d6f: e8 88 ff ff ff call 110cfc <_POSIX_Thread_Exit>
110d74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110d77: c9 leave <== NOT EXECUTED
110d78: c3 ret <== NOT EXECUTED
0010bf24 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf24: 55 push %ebp
10bf25: 89 e5 mov %esp,%ebp
10bf27: 53 push %ebx
10bf28: 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 );
10bf2b: 8d 45 f4 lea -0xc(%ebp),%eax
10bf2e: 50 push %eax
10bf2f: ff 75 0c pushl 0xc(%ebp)
10bf32: e8 b9 00 00 00 call 10bff0 <_POSIX_Absolute_timeout_to_ticks>
10bf37: 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,
10bf39: 83 c4 0c add $0xc,%esp
10bf3c: 83 f8 03 cmp $0x3,%eax
10bf3f: 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 );
10bf42: ff 75 f4 pushl -0xc(%ebp)
10bf45: 0f b6 c2 movzbl %dl,%eax
10bf48: 50 push %eax
10bf49: ff 75 08 pushl 0x8(%ebp)
10bf4c: 88 55 e4 mov %dl,-0x1c(%ebp)
10bf4f: e8 e8 fe ff ff call 10be3c <_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) ) {
10bf54: 83 c4 10 add $0x10,%esp
10bf57: 8a 55 e4 mov -0x1c(%ebp),%dl
10bf5a: 84 d2 test %dl,%dl
10bf5c: 75 1d jne 10bf7b <pthread_mutex_timedlock+0x57>
10bf5e: 83 f8 10 cmp $0x10,%eax
10bf61: 75 18 jne 10bf7b <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bf63: 85 db test %ebx,%ebx
10bf65: 74 08 je 10bf6f <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bf67: 4b dec %ebx
10bf68: 83 fb 01 cmp $0x1,%ebx
10bf6b: 77 0e ja 10bf7b <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bf6d: eb 07 jmp 10bf76 <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;
10bf6f: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bf74: eb 05 jmp 10bf7b <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bf76: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bf7b: 8b 5d fc mov -0x4(%ebp),%ebx
10bf7e: c9 leave
10bf7f: c3 ret
0010bb9c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bb9c: 55 push %ebp
10bb9d: 89 e5 mov %esp,%ebp
10bb9f: 8b 55 08 mov 0x8(%ebp),%edx
10bba2: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bba5: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbaa: 85 d2 test %edx,%edx
10bbac: 74 0f je 10bbbd <pthread_mutexattr_setpshared+0x21>
10bbae: 83 3a 00 cmpl $0x0,(%edx)
10bbb1: 74 0a je 10bbbd <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bbb3: 83 f9 01 cmp $0x1,%ecx
10bbb6: 77 05 ja 10bbbd <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bbb8: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bbbb: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bbbd: c9 leave
10bbbe: c3 ret
00109dc4 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109dc4: 55 push %ebp
109dc5: 89 e5 mov %esp,%ebp
109dc7: 8b 55 08 mov 0x8(%ebp),%edx
109dca: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109dcd: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109dd2: 85 d2 test %edx,%edx
109dd4: 74 0f je 109de5 <pthread_mutexattr_settype+0x21>
109dd6: 83 3a 00 cmpl $0x0,(%edx)
109dd9: 74 0a je 109de5 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109ddb: 83 f9 03 cmp $0x3,%ecx
109dde: 77 05 ja 109de5 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109de0: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109de3: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109de5: c9 leave
109de6: c3 ret
0010a874 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a874: 55 push %ebp
10a875: 89 e5 mov %esp,%ebp
10a877: 56 push %esi
10a878: 53 push %ebx
10a879: 83 ec 10 sub $0x10,%esp
10a87c: 8b 5d 08 mov 0x8(%ebp),%ebx
10a87f: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a882: 85 f6 test %esi,%esi
10a884: 74 51 je 10a8d7 <pthread_once+0x63>
10a886: 85 db test %ebx,%ebx
10a888: 74 4d je 10a8d7 <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a88a: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a88c: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a890: 75 4a jne 10a8dc <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a892: 52 push %edx
10a893: 8d 45 f4 lea -0xc(%ebp),%eax
10a896: 50 push %eax
10a897: 68 00 01 00 00 push $0x100
10a89c: 68 00 01 00 00 push $0x100
10a8a1: e8 a6 0a 00 00 call 10b34c <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8a6: 83 c4 10 add $0x10,%esp
10a8a9: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8ad: 75 0f jne 10a8be <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a8af: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a8b5: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a8bc: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a8be: 50 push %eax
10a8bf: 8d 45 f4 lea -0xc(%ebp),%eax
10a8c2: 50 push %eax
10a8c3: 68 00 01 00 00 push $0x100
10a8c8: ff 75 f4 pushl -0xc(%ebp)
10a8cb: e8 7c 0a 00 00 call 10b34c <rtems_task_mode>
10a8d0: 83 c4 10 add $0x10,%esp
}
return 0;
10a8d3: 31 c0 xor %eax,%eax
10a8d5: eb 05 jmp 10a8dc <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a8d7: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a8dc: 8d 65 f8 lea -0x8(%ebp),%esp
10a8df: 5b pop %ebx
10a8e0: 5e pop %esi
10a8e1: c9 leave
10a8e2: c3 ret
0010b0a0 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b0a0: 55 push %ebp
10b0a1: 89 e5 mov %esp,%ebp
10b0a3: 56 push %esi
10b0a4: 53 push %ebx
10b0a5: 83 ec 10 sub $0x10,%esp
10b0a8: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0ab: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b0b0: 85 db test %ebx,%ebx
10b0b2: 0f 84 8b 00 00 00 je 10b143 <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b0b8: 8b 75 0c mov 0xc(%ebp),%esi
10b0bb: 85 f6 test %esi,%esi
10b0bd: 75 0f jne 10b0ce <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b0bf: 83 ec 0c sub $0xc,%esp
10b0c2: 8d 75 ec lea -0x14(%ebp),%esi
10b0c5: 56 push %esi
10b0c6: e8 5d 09 00 00 call 10ba28 <pthread_rwlockattr_init>
10b0cb: 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;
10b0ce: 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 )
10b0d3: 83 3e 00 cmpl $0x0,(%esi)
10b0d6: 74 6b je 10b143 <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b0d8: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b0dc: 75 65 jne 10b143 <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b0de: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b0e5: a1 f0 82 12 00 mov 0x1282f0,%eax
10b0ea: 40 inc %eax
10b0eb: 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 );
10b0f0: 83 ec 0c sub $0xc,%esp
10b0f3: 68 f4 84 12 00 push $0x1284f4
10b0f8: e8 33 23 00 00 call 10d430 <_Objects_Allocate>
10b0fd: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b0ff: 83 c4 10 add $0x10,%esp
10b102: 85 c0 test %eax,%eax
10b104: 75 0c jne 10b112 <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b106: e8 33 31 00 00 call 10e23e <_Thread_Enable_dispatch>
return EAGAIN;
10b10b: b8 0b 00 00 00 mov $0xb,%eax
10b110: eb 31 jmp 10b143 <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b112: 50 push %eax
10b113: 50 push %eax
10b114: 8d 45 f4 lea -0xc(%ebp),%eax
10b117: 50 push %eax
10b118: 8d 46 10 lea 0x10(%esi),%eax
10b11b: 50 push %eax
10b11c: e8 7b 1b 00 00 call 10cc9c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b121: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b124: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b127: 8b 15 10 85 12 00 mov 0x128510,%edx
10b12d: 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;
10b130: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b137: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b139: e8 00 31 00 00 call 10e23e <_Thread_Enable_dispatch>
return 0;
10b13e: 83 c4 10 add $0x10,%esp
10b141: 31 c0 xor %eax,%eax
}
10b143: 8d 65 f8 lea -0x8(%ebp),%esp
10b146: 5b pop %ebx
10b147: 5e pop %esi
10b148: c9 leave
10b149: c3 ret
0010b1b4 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
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 2c sub $0x2c,%esp
10b1bd: 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;
10b1c0: 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 )
10b1c5: 85 ff test %edi,%edi
10b1c7: 0f 84 87 00 00 00 je 10b254 <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 );
10b1cd: 50 push %eax
10b1ce: 50 push %eax
10b1cf: 8d 45 e0 lea -0x20(%ebp),%eax
10b1d2: 50 push %eax
10b1d3: ff 75 0c pushl 0xc(%ebp)
10b1d6: e8 29 59 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks>
10b1db: 89 c6 mov %eax,%esi
10b1dd: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b1e0: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1e3: 50 push %eax
10b1e4: ff 37 pushl (%edi)
10b1e6: 68 f4 84 12 00 push $0x1284f4
10b1eb: e8 70 26 00 00 call 10d860 <_Objects_Get>
switch ( location ) {
10b1f0: 83 c4 10 add $0x10,%esp
10b1f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b1f7: 75 5b jne 10b254 <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,
10b1f9: 83 fe 03 cmp $0x3,%esi
10b1fc: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b1ff: 83 ec 0c sub $0xc,%esp
10b202: 6a 00 push $0x0
10b204: ff 75 e0 pushl -0x20(%ebp)
10b207: 0f b6 ca movzbl %dl,%ecx
10b20a: 51 push %ecx
10b20b: ff 37 pushl (%edi)
10b20d: 83 c0 10 add $0x10,%eax
10b210: 50 push %eax
10b211: 88 55 d4 mov %dl,-0x2c(%ebp)
10b214: e8 b7 1a 00 00 call 10ccd0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b219: 83 c4 20 add $0x20,%esp
10b21c: e8 1d 30 00 00 call 10e23e <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b221: 8a 55 d4 mov -0x2c(%ebp),%dl
10b224: 84 d2 test %dl,%dl
10b226: 75 17 jne 10b23f <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b228: a1 38 88 12 00 mov 0x128838,%eax
10b22d: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b231: 75 0c jne 10b23f <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b233: 85 f6 test %esi,%esi
10b235: 74 1d je 10b254 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b237: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b238: 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 ||
10b23a: 83 fe 01 cmp $0x1,%esi
10b23d: 76 15 jbe 10b254 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b23f: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b242: a1 38 88 12 00 mov 0x128838,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b247: ff 70 34 pushl 0x34(%eax)
10b24a: e8 bd 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b24f: 89 c3 mov %eax,%ebx
10b251: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b254: 89 d8 mov %ebx,%eax
10b256: 8d 65 f4 lea -0xc(%ebp),%esp
10b259: 5b pop %ebx
10b25a: 5e pop %esi
10b25b: 5f pop %edi
10b25c: c9 leave
10b25d: c3 ret
0010b260 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b260: 55 push %ebp
10b261: 89 e5 mov %esp,%ebp
10b263: 57 push %edi
10b264: 56 push %esi
10b265: 53 push %ebx
10b266: 83 ec 2c sub $0x2c,%esp
10b269: 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;
10b26c: 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 )
10b271: 85 ff test %edi,%edi
10b273: 0f 84 87 00 00 00 je 10b300 <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 );
10b279: 50 push %eax
10b27a: 50 push %eax
10b27b: 8d 45 e0 lea -0x20(%ebp),%eax
10b27e: 50 push %eax
10b27f: ff 75 0c pushl 0xc(%ebp)
10b282: e8 7d 58 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks>
10b287: 89 c6 mov %eax,%esi
10b289: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b28c: 8d 45 e4 lea -0x1c(%ebp),%eax
10b28f: 50 push %eax
10b290: ff 37 pushl (%edi)
10b292: 68 f4 84 12 00 push $0x1284f4
10b297: e8 c4 25 00 00 call 10d860 <_Objects_Get>
switch ( location ) {
10b29c: 83 c4 10 add $0x10,%esp
10b29f: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b2a3: 75 5b jne 10b300 <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,
10b2a5: 83 fe 03 cmp $0x3,%esi
10b2a8: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2ab: 83 ec 0c sub $0xc,%esp
10b2ae: 6a 00 push $0x0
10b2b0: ff 75 e0 pushl -0x20(%ebp)
10b2b3: 0f b6 ca movzbl %dl,%ecx
10b2b6: 51 push %ecx
10b2b7: ff 37 pushl (%edi)
10b2b9: 83 c0 10 add $0x10,%eax
10b2bc: 50 push %eax
10b2bd: 88 55 d4 mov %dl,-0x2c(%ebp)
10b2c0: e8 c3 1a 00 00 call 10cd88 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b2c5: 83 c4 20 add $0x20,%esp
10b2c8: e8 71 2f 00 00 call 10e23e <_Thread_Enable_dispatch>
if ( !do_wait &&
10b2cd: 8a 55 d4 mov -0x2c(%ebp),%dl
10b2d0: 84 d2 test %dl,%dl
10b2d2: 75 17 jne 10b2eb <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b2d4: a1 38 88 12 00 mov 0x128838,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b2d9: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b2dd: 75 0c jne 10b2eb <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b2df: 85 f6 test %esi,%esi
10b2e1: 74 1d je 10b300 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2e3: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b2e4: 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 ||
10b2e6: 83 fe 01 cmp $0x1,%esi
10b2e9: 76 15 jbe 10b300 <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2eb: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b2ee: a1 38 88 12 00 mov 0x128838,%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(
10b2f3: ff 70 34 pushl 0x34(%eax)
10b2f6: e8 11 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2fb: 89 c3 mov %eax,%ebx
10b2fd: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b300: 89 d8 mov %ebx,%eax
10b302: 8d 65 f4 lea -0xc(%ebp),%esp
10b305: 5b pop %ebx
10b306: 5e pop %esi
10b307: 5f pop %edi
10b308: c9 leave
10b309: c3 ret
0010ba48 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba48: 55 push %ebp
10ba49: 89 e5 mov %esp,%ebp
10ba4b: 8b 55 08 mov 0x8(%ebp),%edx
10ba4e: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10ba51: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10ba56: 85 d2 test %edx,%edx
10ba58: 74 0f je 10ba69 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10ba5a: 83 3a 00 cmpl $0x0,(%edx)
10ba5d: 74 0a je 10ba69 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10ba5f: 83 f9 01 cmp $0x1,%ecx
10ba62: 77 05 ja 10ba69 <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10ba64: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10ba67: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10ba69: c9 leave
10ba6a: c3 ret
0010c748 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c748: 55 push %ebp
10c749: 89 e5 mov %esp,%ebp
10c74b: 57 push %edi
10c74c: 56 push %esi
10c74d: 53 push %ebx
10c74e: 83 ec 2c sub $0x2c,%esp
10c751: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c754: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c75b: 85 f6 test %esi,%esi
10c75d: 0f 84 00 01 00 00 je 10c863 <pthread_setschedparam+0x11b>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c763: 8d 45 e0 lea -0x20(%ebp),%eax
10c766: 50 push %eax
10c767: 8d 45 e4 lea -0x1c(%ebp),%eax
10c76a: 50 push %eax
10c76b: 56 push %esi
10c76c: ff 75 0c pushl 0xc(%ebp)
10c76f: e8 e0 52 00 00 call 111a54 <_POSIX_Thread_Translate_sched_param>
10c774: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c777: 83 c4 10 add $0x10,%esp
10c77a: 85 c0 test %eax,%eax
10c77c: 0f 85 e1 00 00 00 jne 10c863 <pthread_setschedparam+0x11b>
10c782: 53 push %ebx
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10c783: 8d 45 dc lea -0x24(%ebp),%eax
10c786: 50 push %eax
10c787: ff 75 08 pushl 0x8(%ebp)
10c78a: 68 74 95 12 00 push $0x129574
10c78f: e8 84 1c 00 00 call 10e418 <_Objects_Get>
10c794: 89 c2 mov %eax,%edx
switch ( location ) {
10c796: 83 c4 10 add $0x10,%esp
10c799: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c79d: 0f 85 b9 00 00 00 jne 10c85c <pthread_setschedparam+0x114>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7a3: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7a9: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7b0: 75 18 jne 10c7ca <pthread_setschedparam+0x82>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7b2: 83 ec 0c sub $0xc,%esp
10c7b5: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c7bb: 50 push %eax
10c7bc: 89 55 d0 mov %edx,-0x30(%ebp)
10c7bf: e8 28 35 00 00 call 10fcec <_Watchdog_Remove>
10c7c4: 83 c4 10 add $0x10,%esp
10c7c7: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c7ca: 8b 45 0c mov 0xc(%ebp),%eax
10c7cd: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c7d3: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c7d9: b9 07 00 00 00 mov $0x7,%ecx
10c7de: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c7e0: 8b 45 e4 mov -0x1c(%ebp),%eax
10c7e3: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c7e6: 8b 45 e0 mov -0x20(%ebp),%eax
10c7e9: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c7ef: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c7f3: 78 60 js 10c855 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c7f5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c7f9: 7e 08 jle 10c803 <pthread_setschedparam+0xbb>
10c7fb: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c7ff: 75 54 jne 10c855 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c801: eb 24 jmp 10c827 <pthread_setschedparam+0xdf>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c803: a1 00 93 12 00 mov 0x129300,%eax
10c808: 89 42 78 mov %eax,0x78(%edx)
10c80b: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax
10c812: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c818: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c81b: 51 push %ecx
10c81c: 6a 01 push $0x1
10c81e: 50 push %eax
10c81f: 52 push %edx
10c820: e8 8b 21 00 00 call 10e9b0 <_Thread_Change_priority>
10c825: eb 2b jmp 10c852 <pthread_setschedparam+0x10a>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c827: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c82d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c833: 83 ec 0c sub $0xc,%esp
10c836: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c83c: 53 push %ebx
10c83d: 89 55 d0 mov %edx,-0x30(%ebp)
10c840: e8 a7 34 00 00 call 10fcec <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c845: 58 pop %eax
10c846: 5a pop %edx
10c847: 8b 55 d0 mov -0x30(%ebp),%edx
10c84a: 52 push %edx
10c84b: 6a 00 push $0x0
10c84d: e8 e1 fd ff ff call 10c633 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c852: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c855: e8 9c 25 00 00 call 10edf6 <_Thread_Enable_dispatch>
return 0;
10c85a: eb 07 jmp 10c863 <pthread_setschedparam+0x11b>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c85c: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c863: 8b 45 d4 mov -0x2c(%ebp),%eax
10c866: 8d 65 f4 lea -0xc(%ebp),%esp
10c869: 5b pop %ebx
10c86a: 5e pop %esi
10c86b: 5f pop %edi
10c86c: c9 leave
10c86d: c3 ret
0010a644 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a644: 55 push %ebp
10a645: 89 e5 mov %esp,%ebp
10a647: 53 push %ebx
10a648: 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() )
10a64b: 83 3d 0c 68 12 00 00 cmpl $0x0,0x12680c
10a652: 75 48 jne 10a69c <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a654: a1 10 68 12 00 mov 0x126810,%eax
10a659: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10a65f: 8b 15 c8 62 12 00 mov 0x1262c8,%edx
10a665: 42 inc %edx
10a666: 89 15 c8 62 12 00 mov %edx,0x1262c8
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a66c: 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 &&
10a66e: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a675: 75 0a jne 10a681 <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));
10a677: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a67e: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a681: e8 14 25 00 00 call 10cb9a <_Thread_Enable_dispatch>
if ( cancel )
10a686: 84 db test %bl,%bl
10a688: 74 12 je 10a69c <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a68a: 50 push %eax
10a68b: 50 push %eax
10a68c: 6a ff push $0xffffffff
10a68e: ff 35 10 68 12 00 pushl 0x126810
10a694: e8 7b 52 00 00 call 10f914 <_POSIX_Thread_Exit>
10a699: 83 c4 10 add $0x10,%esp
}
10a69c: 8b 5d fc mov -0x4(%ebp),%ebx
10a69f: c9 leave
10a6a0: c3 ret
0010af01 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af01: 55 push %ebp
10af02: 89 e5 mov %esp,%ebp
10af04: 57 push %edi
10af05: 56 push %esi
10af06: 53 push %ebx
10af07: 83 ec 58 sub $0x58,%esp
10af0a: 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);
10af0d: 68 78 72 12 00 push $0x127278
10af12: e8 bd 08 00 00 call 10b7d4 <pthread_mutex_lock>
10af17: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af1a: 83 c4 10 add $0x10,%esp
10af1d: 85 c0 test %eax,%eax
10af1f: 74 0e je 10af2f <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10af21: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10af24: 53 push %ebx <== NOT EXECUTED
10af25: e8 06 ce ff ff call 107d30 <free> <== NOT EXECUTED
10af2a: e9 bf 01 00 00 jmp 10b0ee <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);
10af2f: e8 a0 10 00 00 call 10bfd4 <pthread_self>
10af34: 57 push %edi
10af35: 8d 55 c4 lea -0x3c(%ebp),%edx
10af38: 52 push %edx
10af39: 8d 55 e0 lea -0x20(%ebp),%edx
10af3c: 52 push %edx
10af3d: 50 push %eax
10af3e: e8 95 0c 00 00 call 10bbd8 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10af43: e8 8c 10 00 00 call 10bfd4 <pthread_self>
10af48: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10af4b: 8b 43 14 mov 0x14(%ebx),%eax
10af4e: 8b 55 c4 mov -0x3c(%ebp),%edx
10af51: 2b 50 14 sub 0x14(%eax),%edx
10af54: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10af57: 8b 55 e0 mov -0x20(%ebp),%edx
10af5a: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10af5d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10af64: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10af6b: 83 c4 10 add $0x10,%esp
10af6e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0
10af75: 0f 85 b7 00 00 00 jne 10b032 <rtems_aio_enqueue+0x131>
10af7b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc
10af82: 0f 8f aa 00 00 00 jg 10b032 <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);
10af88: 56 push %esi
10af89: 6a 01 push $0x1
10af8b: ff 30 pushl (%eax)
10af8d: 68 c0 72 12 00 push $0x1272c0
10af92: e8 85 fb ff ff call 10ab1c <rtems_aio_search_fd>
10af97: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10af99: 83 c4 10 add $0x10,%esp
10af9c: 83 78 18 01 cmpl $0x1,0x18(%eax)
10afa0: 8d 50 08 lea 0x8(%eax),%edx
10afa3: 8d 78 1c lea 0x1c(%eax),%edi
10afa6: 8d 40 20 lea 0x20(%eax),%eax
10afa9: 89 45 b0 mov %eax,-0x50(%ebp)
10afac: 75 66 jne 10b014 <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);
10afae: 51 push %ecx
10afaf: 51 push %ecx
10afb0: 53 push %ebx
10afb1: 52 push %edx
10afb2: e8 c1 1f 00 00 call 10cf78 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10afb7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10afbe: 58 pop %eax
10afbf: 5a pop %edx
10afc0: 6a 00 push $0x0
10afc2: 57 push %edi
10afc3: e8 ec 06 00 00 call 10b6b4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10afc8: 5b pop %ebx
10afc9: 5f pop %edi
10afca: 6a 00 push $0x0
10afcc: ff 75 b0 pushl -0x50(%ebp)
10afcf: e8 a0 03 00 00 call 10b374 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10afd4: 56 push %esi
10afd5: 68 c7 ab 10 00 push $0x10abc7
10afda: 68 80 72 12 00 push $0x127280
10afdf: 8d 45 e4 lea -0x1c(%ebp),%eax
10afe2: 50 push %eax
10afe3: e8 bc 09 00 00 call 10b9a4 <pthread_create>
10afe8: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10afea: 83 c4 20 add $0x20,%esp
10afed: 85 c0 test %eax,%eax
10afef: 74 18 je 10b009 <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10aff1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aff4: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10aff9: e8 56 08 00 00 call 10b854 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10affe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b001: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b004: e9 e8 00 00 00 jmp 10b0f1 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b009: ff 05 dc 72 12 00 incl 0x1272dc
10b00f: e9 cd 00 00 00 jmp 10b0e1 <rtems_aio_enqueue+0x1e0>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b014: 83 ec 0c sub $0xc,%esp
10b017: 57 push %edi
10b018: 89 55 ac mov %edx,-0x54(%ebp)
10b01b: e8 b4 07 00 00 call 10b7d4 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b020: 5a pop %edx
10b021: 59 pop %ecx
10b022: 53 push %ebx
10b023: 8b 55 ac mov -0x54(%ebp),%edx
10b026: 52 push %edx
10b027: e8 ec fd ff ff call 10ae18 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b02c: 58 pop %eax
10b02d: ff 75 b0 pushl -0x50(%ebp)
10b030: eb 36 jmp 10b068 <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,
10b032: 56 push %esi
10b033: 6a 00 push $0x0
10b035: ff 30 pushl (%eax)
10b037: 68 c0 72 12 00 push $0x1272c0
10b03c: e8 db fa ff ff call 10ab1c <rtems_aio_search_fd>
10b041: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b043: 83 c4 10 add $0x10,%esp
10b046: 85 c0 test %eax,%eax
10b048: 74 2d je 10b077 <rtems_aio_enqueue+0x176>
{
pthread_mutex_lock (&r_chain->mutex);
10b04a: 8d 78 1c lea 0x1c(%eax),%edi
10b04d: 83 ec 0c sub $0xc,%esp
10b050: 57 push %edi
10b051: e8 7e 07 00 00 call 10b7d4 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b056: 5a pop %edx
10b057: 59 pop %ecx
10b058: 53 push %ebx
10b059: 8d 46 08 lea 0x8(%esi),%eax
10b05c: 50 push %eax
10b05d: e8 b6 fd ff ff call 10ae18 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b062: 83 c6 20 add $0x20,%esi
10b065: 89 34 24 mov %esi,(%esp)
10b068: e8 a3 03 00 00 call 10b410 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b06d: 89 3c 24 mov %edi,(%esp)
10b070: e8 df 07 00 00 call 10b854 <pthread_mutex_unlock>
10b075: eb 67 jmp 10b0de <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);
10b077: 50 push %eax
10b078: 6a 01 push $0x1
10b07a: 8b 43 14 mov 0x14(%ebx),%eax
10b07d: ff 30 pushl (%eax)
10b07f: 68 cc 72 12 00 push $0x1272cc
10b084: e8 93 fa ff ff call 10ab1c <rtems_aio_search_fd>
10b089: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b08b: 83 c4 10 add $0x10,%esp
10b08e: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b092: 8d 40 08 lea 0x8(%eax),%eax
10b095: 75 3e jne 10b0d5 <rtems_aio_enqueue+0x1d4>
10b097: 57 push %edi
10b098: 57 push %edi
10b099: 53 push %ebx
10b09a: 50 push %eax
10b09b: e8 d8 1e 00 00 call 10cf78 <_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;
10b0a0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b0a7: 5a pop %edx
10b0a8: 59 pop %ecx
10b0a9: 6a 00 push $0x0
10b0ab: 8d 46 1c lea 0x1c(%esi),%eax
10b0ae: 50 push %eax
10b0af: e8 00 06 00 00 call 10b6b4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b0b4: 5f pop %edi
10b0b5: 58 pop %eax
10b0b6: 6a 00 push $0x0
10b0b8: 83 c6 20 add $0x20,%esi
10b0bb: 56 push %esi
10b0bc: e8 b3 02 00 00 call 10b374 <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
10b0c1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp)
10b0c8: e8 43 03 00 00 call 10b410 <pthread_cond_signal>
++aio_request_queue.idle_threads;
10b0cd: ff 05 e0 72 12 00 incl 0x1272e0
10b0d3: eb 09 jmp 10b0de <rtems_aio_enqueue+0x1dd>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0d5: 56 push %esi
10b0d6: 56 push %esi
10b0d7: 53 push %ebx
10b0d8: 50 push %eax
10b0d9: e8 3a fd ff ff call 10ae18 <rtems_aio_insert_prio>
10b0de: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b0e1: 83 ec 0c sub $0xc,%esp
10b0e4: 68 78 72 12 00 push $0x127278
10b0e9: e8 66 07 00 00 call 10b854 <pthread_mutex_unlock>
return 0;
10b0ee: 83 c4 10 add $0x10,%esp
}
10b0f1: 8b 45 b4 mov -0x4c(%ebp),%eax
10b0f4: 8d 65 f4 lea -0xc(%ebp),%esp
10b0f7: 5b pop %ebx
10b0f8: 5e pop %esi
10b0f9: 5f pop %edi
10b0fa: c9 leave
10b0fb: c3 ret
0010abc7 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10abc7: 55 push %ebp <== NOT EXECUTED
10abc8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10abca: 57 push %edi <== NOT EXECUTED
10abcb: 56 push %esi <== NOT EXECUTED
10abcc: 53 push %ebx <== NOT EXECUTED
10abcd: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED
rtems_aio_request_chain *r_chain = arg;
10abd0: 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);
10abd3: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED
10abd6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10abd9: 57 push %edi <== NOT EXECUTED
10abda: e8 f5 0b 00 00 call 10b7d4 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
10abdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10abe2: 85 c0 test %eax,%eax <== NOT EXECUTED
10abe4: 0f 85 24 02 00 00 jne 10ae0e <rtems_aio_handle+0x247><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10abea: 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 );
10abed: 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)) {
10abf0: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10abf2: 0f 84 cc 00 00 00 je 10acc4 <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);
10abf8: e8 d7 13 00 00 call 10bfd4 <pthread_self> <== NOT EXECUTED
10abfd: 51 push %ecx <== NOT EXECUTED
10abfe: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED
10ac01: 52 push %edx <== NOT EXECUTED
10ac02: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED
10ac05: 51 push %ecx <== NOT EXECUTED
10ac06: 50 push %eax <== NOT EXECUTED
10ac07: e8 cc 0f 00 00 call 10bbd8 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
10ac0c: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED
10ac0f: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10ac12: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED
10ac15: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED
10ac18: e8 b7 13 00 00 call 10bfd4 <pthread_self> <== NOT EXECUTED
10ac1d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ac20: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED
10ac23: 51 push %ecx <== NOT EXECUTED
10ac24: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED
10ac27: 52 push %edx <== NOT EXECUTED
10ac28: 50 push %eax <== NOT EXECUTED
10ac29: e8 b6 13 00 00 call 10bfe4 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ac2e: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ac31: e8 06 23 00 00 call 10cf3c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10ac36: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ac39: e8 16 0c 00 00 call 10b854 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
10ac3e: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10ac41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac44: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED
10ac47: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
10ac4a: 74 20 je 10ac6c <rtems_aio_handle+0xa5> <== NOT EXECUTED
10ac4c: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
10ac4f: 74 36 je 10ac87 <rtems_aio_handle+0xc0> <== NOT EXECUTED
10ac51: 4a dec %edx <== NOT EXECUTED
10ac52: 75 45 jne 10ac99 <rtems_aio_handle+0xd2> <== NOT EXECUTED
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
10ac54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac57: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac5a: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac5d: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac60: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac63: ff 30 pushl (%eax) <== NOT EXECUTED
10ac65: e8 9a 94 00 00 call 114104 <pread> <== NOT EXECUTED
10ac6a: eb 16 jmp 10ac82 <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,
10ac6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac6f: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac72: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac75: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac78: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac7b: ff 30 pushl (%eax) <== NOT EXECUTED
10ac7d: e8 36 95 00 00 call 1141b8 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10ac82: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10ac85: eb 0d jmp 10ac94 <rtems_aio_handle+0xcd> <== NOT EXECUTED
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
10ac87: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac8a: ff 30 pushl (%eax) <== NOT EXECUTED
10ac8c: e8 1b 5d 00 00 call 1109ac <fsync> <== NOT EXECUTED
break;
10ac91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10ac94: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10ac97: 75 19 jne 10acb2 <rtems_aio_handle+0xeb> <== NOT EXECUTED
req->aiocbp->return_value = -1;
10ac99: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10ac9c: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10aca3: e8 24 8a 00 00 call 1136cc <__errno> <== NOT EXECUTED
10aca8: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10acaa: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10acad: e9 21 ff ff ff jmp 10abd3 <rtems_aio_handle+0xc> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10acb2: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED
10acb5: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED
req->aiocbp->error_code = 0;
10acb8: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED
10acbf: e9 0f ff ff ff jmp 10abd3 <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);
10acc4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10acc7: 57 push %edi <== NOT EXECUTED
10acc8: e8 87 0b 00 00 call 10b854 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
10accd: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10acd4: e8 fb 0a 00 00 call 10b7d4 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
10acd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10acdc: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED
10acdf: 0f 85 ee fe ff ff jne 10abd3 <rtems_aio_handle+0xc> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ace5: 52 push %edx <== NOT EXECUTED
10ace6: 52 push %edx <== NOT EXECUTED
10ace7: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10acea: 50 push %eax <== NOT EXECUTED
10aceb: 6a 01 push $0x1 <== NOT EXECUTED
10aced: e8 72 05 00 00 call 10b264 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10acf2: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10acf6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
10acfd: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED
10ad00: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad03: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED
10ad06: 52 push %edx <== NOT EXECUTED
10ad07: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ad0c: 56 push %esi <== NOT EXECUTED
10ad0d: e8 6e 07 00 00 call 10b480 <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) {
10ad12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad15: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10ad18: 0f 85 b5 fe ff ff jne 10abd3 <rtems_aio_handle+0xc> <== NOT EXECUTED
10ad1e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad21: 53 push %ebx <== NOT EXECUTED
10ad22: e8 15 22 00 00 call 10cf3c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10ad27: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ad2a: e8 85 08 00 00 call 10b5b4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
10ad2f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ad32: e8 89 05 00 00 call 10b2c0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10ad37: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10ad3a: e8 f1 cf ff ff call 107d30 <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)) {
10ad3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad42: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10ad49: 72 12 00
10ad4c: 0f 85 a7 00 00 00 jne 10adf9 <rtems_aio_handle+0x232><== NOT EXECUTED
++aio_request_queue.idle_threads;
10ad52: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
10ad58: 50 push %eax <== NOT EXECUTED
10ad59: 50 push %eax <== NOT EXECUTED
10ad5a: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED
10ad5d: 51 push %ecx <== NOT EXECUTED
10ad5e: 6a 01 push $0x1 <== NOT EXECUTED
10ad60: e8 ff 04 00 00 call 10b264 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad65: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad69: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10ad70: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad73: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad76: 50 push %eax <== NOT EXECUTED
10ad77: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ad7c: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED
10ad81: e8 fa 06 00 00 call 10b480 <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) {
10ad86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad89: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10ad8c: 75 12 jne 10ada0 <rtems_aio_handle+0x1d9><== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10ad8e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad91: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ad96: e8 b9 0a 00 00 call 10b854 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
10ad9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad9e: eb 6e jmp 10ae0e <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;
10ada0: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ada6: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED
10adac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10adaf: 56 push %esi <== NOT EXECUTED
10adb0: e8 87 21 00 00 call 10cf3c <_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,
10adb5: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10adb8: 6a 01 push $0x1 <== NOT EXECUTED
10adba: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
10adbd: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10adc2: e8 55 fd ff ff call 10ab1c <rtems_aio_search_fd> <== NOT EXECUTED
10adc7: 89 c3 mov %eax,%ebx <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
10adc9: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
10add0: 59 pop %ecx <== NOT EXECUTED
10add1: 5f pop %edi <== NOT EXECUTED
10add2: 6a 00 push $0x0 <== NOT EXECUTED
10add4: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED
10add7: 50 push %eax <== NOT EXECUTED
10add8: e8 d7 08 00 00 call 10b6b4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
10addd: 58 pop %eax <== NOT EXECUTED
10adde: 5a pop %edx <== NOT EXECUTED
10addf: 6a 00 push $0x0 <== NOT EXECUTED
10ade1: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED
10ade4: 50 push %eax <== NOT EXECUTED
10ade5: e8 8a 05 00 00 call 10b374 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
10adea: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED
10aded: 83 c6 08 add $0x8,%esi <== NOT EXECUTED
10adf0: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED
10adf5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10adf7: eb 0d jmp 10ae06 <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);
10adf9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10adfc: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ae01: e8 4e 0a 00 00 call 10b854 <pthread_mutex_unlock> <== NOT EXECUTED
10ae06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ae09: e9 c5 fd ff ff jmp 10abd3 <rtems_aio_handle+0xc> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae0e: 31 c0 xor %eax,%eax <== NOT EXECUTED
10ae10: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ae13: 5b pop %ebx <== NOT EXECUTED
10ae14: 5e pop %esi <== NOT EXECUTED
10ae15: 5f pop %edi <== NOT EXECUTED
10ae16: c9 leave <== NOT EXECUTED
10ae17: c3 ret <== NOT EXECUTED
0010aa20 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aa20: 55 push %ebp
10aa21: 89 e5 mov %esp,%ebp
10aa23: 53 push %ebx
10aa24: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aa27: 68 80 72 12 00 push $0x127280
10aa2c: e8 27 0f 00 00 call 10b958 <pthread_attr_init>
10aa31: 89 c3 mov %eax,%ebx
if (result != 0)
10aa33: 83 c4 10 add $0x10,%esp
10aa36: 85 c0 test %eax,%eax
10aa38: 0f 85 d7 00 00 00 jne 10ab15 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aa3e: 51 push %ecx
10aa3f: 51 push %ecx
10aa40: 6a 00 push $0x0
10aa42: 68 80 72 12 00 push $0x127280
10aa47: e8 34 0f 00 00 call 10b980 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aa4c: 83 c4 10 add $0x10,%esp
10aa4f: 85 c0 test %eax,%eax
10aa51: 74 10 je 10aa63 <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa53: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa56: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aa5b: e8 d8 0e 00 00 call 10b938 <pthread_attr_destroy> <== NOT EXECUTED
10aa60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aa63: 52 push %edx
10aa64: 52 push %edx
10aa65: 6a 00 push $0x0
10aa67: 68 78 72 12 00 push $0x127278
10aa6c: e8 43 0c 00 00 call 10b6b4 <pthread_mutex_init>
if (result != 0)
10aa71: 83 c4 10 add $0x10,%esp
10aa74: 85 c0 test %eax,%eax
10aa76: 74 10 je 10aa88 <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa7b: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aa80: e8 b3 0e 00 00 call 10b938 <pthread_attr_destroy> <== NOT EXECUTED
10aa85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10aa88: 50 push %eax
10aa89: 50 push %eax
10aa8a: 6a 00 push $0x0
10aa8c: 68 7c 72 12 00 push $0x12727c
10aa91: e8 de 08 00 00 call 10b374 <pthread_cond_init>
10aa96: 89 c3 mov %eax,%ebx
if (result != 0) {
10aa98: 83 c4 10 add $0x10,%esp
10aa9b: 85 c0 test %eax,%eax
10aa9d: 74 1c je 10aabb <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10aa9f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aaa2: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10aaa7: e8 08 0b 00 00 call 10b5b4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10aaac: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED
10aab3: e8 80 0e 00 00 call 10b938 <pthread_attr_destroy> <== NOT EXECUTED
10aab8: 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;
10aabb: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0
10aac2: 72 12 00
head->previous = NULL;
10aac5: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4
10aacc: 00 00 00
tail->previous = head;
10aacf: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8
10aad6: 72 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10aad9: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc
10aae0: 72 12 00
head->previous = NULL;
10aae3: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0
10aaea: 00 00 00
tail->previous = head;
10aaed: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4
10aaf4: 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;
10aaf7: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc
10aafe: 00 00 00
aio_request_queue.idle_threads = 0;
10ab01: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0
10ab08: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab0b: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8
10ab12: b0 00 00
return result;
}
10ab15: 89 d8 mov %ebx,%eax
10ab17: 8b 5d fc mov -0x4(%ebp),%ebx
10ab1a: c9 leave
10ab1b: c3 ret
0010ae18 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae18: 55 push %ebp
10ae19: 89 e5 mov %esp,%ebp
10ae1b: 56 push %esi
10ae1c: 53 push %ebx
10ae1d: 8b 4d 08 mov 0x8(%ebp),%ecx
10ae20: 8b 55 0c mov 0xc(%ebp),%edx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae23: 8b 01 mov (%ecx),%eax
10ae25: 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)) {
10ae28: 39 d8 cmp %ebx,%eax
10ae2a: 74 27 je 10ae53 <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;
10ae2c: 8b 48 14 mov 0x14(%eax),%ecx
10ae2f: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10ae32: 8b 72 14 mov 0x14(%edx),%esi
10ae35: 8b 76 14 mov 0x14(%esi),%esi
10ae38: eb 08 jmp 10ae42 <rtems_aio_insert_prio+0x2a>
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae3a: 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;
10ae3c: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10ae3f: 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 &&
10ae42: 39 ce cmp %ecx,%esi
10ae44: 7e 04 jle 10ae4a <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10ae46: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10ae48: 75 f0 jne 10ae3a <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 );
10ae4a: 89 55 0c mov %edx,0xc(%ebp)
10ae4d: 8b 40 04 mov 0x4(%eax),%eax
10ae50: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10ae53: 5b pop %ebx
10ae54: 5e pop %esi
10ae55: c9 leave
10ae56: e9 1d 21 00 00 jmp 10cf78 <_Chain_Insert>
0010aea4 <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)
{
10aea4: 55 push %ebp
10aea5: 89 e5 mov %esp,%ebp
10aea7: 53 push %ebx
10aea8: 83 ec 04 sub $0x4,%esp
10aeab: 8b 55 08 mov 0x8(%ebp),%edx
10aeae: 8b 4d 0c mov 0xc(%ebp),%ecx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aeb1: 8b 1a mov (%edx),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10aeb3: 83 c2 04 add $0x4,%edx
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10aeb6: b8 02 00 00 00 mov $0x2,%eax
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
10aebb: 39 d3 cmp %edx,%ebx
10aebd: 75 08 jne 10aec7 <rtems_aio_remove_req+0x23><== ALWAYS TAKEN
10aebf: eb 3b jmp 10aefc <rtems_aio_remove_req+0x58>
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aec1: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aec3: 39 d3 cmp %edx,%ebx <== NOT EXECUTED
10aec5: 74 30 je 10aef7 <rtems_aio_remove_req+0x53><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10aec7: 89 d8 mov %ebx,%eax
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aec9: 39 4b 14 cmp %ecx,0x14(%ebx)
10aecc: 75 f3 jne 10aec1 <rtems_aio_remove_req+0x1d><== NEVER TAKEN
10aece: 83 ec 0c sub $0xc,%esp
10aed1: 53 push %ebx
10aed2: e8 65 20 00 00 call 10cf3c <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10aed7: 8b 43 14 mov 0x14(%ebx),%eax
10aeda: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10aee1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10aee8: 89 1c 24 mov %ebx,(%esp)
10aeeb: e8 40 ce ff ff call 107d30 <free>
}
return AIO_CANCELED;
10aef0: 83 c4 10 add $0x10,%esp
10aef3: 31 c0 xor %eax,%eax
10aef5: eb 05 jmp 10aefc <rtems_aio_remove_req+0x58>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10aef7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10aefc: 8b 5d fc mov -0x4(%ebp),%ebx
10aeff: c9 leave
10af00: c3 ret
0010ab34 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10ab34: 55 push %ebp
10ab35: 89 e5 mov %esp,%ebp
10ab37: 56 push %esi
10ab38: 53 push %ebx
10ab39: 8b 5d 10 mov 0x10(%ebp),%ebx
10ab3c: 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 );
10ab3f: 50 push %eax
10ab40: 50 push %eax
10ab41: ff 75 0c pushl 0xc(%ebp)
10ab44: ff 75 08 pushl 0x8(%ebp)
10ab47: e8 8c 04 00 00 call 10afd8 <_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 ) {
10ab4c: 83 c4 10 add $0x10,%esp
10ab4f: 84 c0 test %al,%al
10ab51: 74 11 je 10ab64 <rtems_chain_append_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ab53: 89 75 0c mov %esi,0xc(%ebp)
10ab56: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ab59: 8d 65 f8 lea -0x8(%ebp),%esp
10ab5c: 5b pop %ebx
10ab5d: 5e pop %esi
10ab5e: 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 );
10ab5f: e9 cc f6 ff ff jmp 10a230 <rtems_event_send>
}
return sc;
}
10ab64: 31 c0 xor %eax,%eax
10ab66: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ab69: 5b pop %ebx <== NOT EXECUTED
10ab6a: 5e pop %esi <== NOT EXECUTED
10ab6b: c9 leave <== NOT EXECUTED
10ab6c: c3 ret <== NOT EXECUTED
0010abac <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10abac: 55 push %ebp
10abad: 89 e5 mov %esp,%ebp
10abaf: 57 push %edi
10abb0: 56 push %esi
10abb1: 53 push %ebx
10abb2: 83 ec 1c sub $0x1c,%esp
10abb5: 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(
10abb8: 8d 75 e4 lea -0x1c(%ebp),%esi
10abbb: eb 13 jmp 10abd0 <rtems_chain_get_with_wait+0x24>
10abbd: 56 push %esi
10abbe: ff 75 10 pushl 0x10(%ebp)
10abc1: 6a 00 push $0x0
10abc3: 57 push %edi
10abc4: e8 07 f5 ff ff call 10a0d0 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10abc9: 83 c4 10 add $0x10,%esp
10abcc: 85 c0 test %eax,%eax
10abce: 75 16 jne 10abe6 <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 );
10abd0: 83 ec 0c sub $0xc,%esp
10abd3: ff 75 08 pushl 0x8(%ebp)
10abd6: e8 9d 04 00 00 call 10b078 <_Chain_Get>
10abdb: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10abdd: 83 c4 10 add $0x10,%esp
10abe0: 85 c0 test %eax,%eax
10abe2: 74 d9 je 10abbd <rtems_chain_get_with_wait+0x11>
10abe4: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10abe6: 8b 55 14 mov 0x14(%ebp),%edx
10abe9: 89 1a mov %ebx,(%edx)
return sc;
}
10abeb: 8d 65 f4 lea -0xc(%ebp),%esp
10abee: 5b pop %ebx
10abef: 5e pop %esi
10abf0: 5f pop %edi
10abf1: c9 leave
10abf2: c3 ret
0010abf4 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10abf4: 55 push %ebp
10abf5: 89 e5 mov %esp,%ebp
10abf7: 56 push %esi
10abf8: 53 push %ebx
10abf9: 8b 5d 10 mov 0x10(%ebp),%ebx
10abfc: 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 );
10abff: 50 push %eax
10ac00: 50 push %eax
10ac01: ff 75 0c pushl 0xc(%ebp)
10ac04: ff 75 08 pushl 0x8(%ebp)
10ac07: e8 b0 04 00 00 call 10b0bc <_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) {
10ac0c: 83 c4 10 add $0x10,%esp
10ac0f: 84 c0 test %al,%al
10ac11: 74 11 je 10ac24 <rtems_chain_prepend_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ac13: 89 75 0c mov %esi,0xc(%ebp)
10ac16: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ac19: 8d 65 f8 lea -0x8(%ebp),%esp
10ac1c: 5b pop %ebx
10ac1d: 5e pop %esi
10ac1e: 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 );
10ac1f: e9 0c f6 ff ff jmp 10a230 <rtems_event_send>
}
return sc;
}
10ac24: 31 c0 xor %eax,%eax
10ac26: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ac29: 5b pop %ebx <== NOT EXECUTED
10ac2a: 5e pop %esi <== NOT EXECUTED
10ac2b: c9 leave <== NOT EXECUTED
10ac2c: c3 ret <== NOT EXECUTED
0010b71c <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
)
{
10b71c: 55 push %ebp
10b71d: 89 e5 mov %esp,%ebp
10b71f: 57 push %edi
10b720: 56 push %esi
10b721: 53 push %ebx
10b722: 83 ec 0c sub $0xc,%esp
10b725: 8b 5d 08 mov 0x8(%ebp),%ebx
10b728: 8b 75 0c mov 0xc(%ebp),%esi
10b72b: 8b 45 10 mov 0x10(%ebp),%eax
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10b72e: 8b 15 b8 8d 12 00 mov 0x128db8,%edx
if ( rtems_interrupt_is_in_progress() )
10b734: 83 3d 5c 89 12 00 00 cmpl $0x0,0x12895c
10b73b: 0f 85 cc 00 00 00 jne 10b80d <rtems_io_register_driver+0xf1><== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10b741: 85 c0 test %eax,%eax
10b743: 0f 84 cb 00 00 00 je 10b814 <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10b749: 89 10 mov %edx,(%eax)
if ( driver_table == NULL )
10b74b: 85 f6 test %esi,%esi
10b74d: 0f 84 c1 00 00 00 je 10b814 <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;
10b753: 83 3e 00 cmpl $0x0,(%esi)
10b756: 0f 85 cc 00 00 00 jne 10b828 <rtems_io_register_driver+0x10c>
10b75c: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b760: 0f 85 c2 00 00 00 jne 10b828 <rtems_io_register_driver+0x10c>
10b766: e9 a9 00 00 00 jmp 10b814 <rtems_io_register_driver+0xf8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b76b: 8b 15 18 84 12 00 mov 0x128418,%edx
10b771: 42 inc %edx
10b772: 89 15 18 84 12 00 mov %edx,0x128418
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10b778: 85 db test %ebx,%ebx
10b77a: 75 32 jne 10b7ae <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;
10b77c: 8b 0d b8 8d 12 00 mov 0x128db8,%ecx
10b782: 8b 15 bc 8d 12 00 mov 0x128dbc,%edx
10b788: eb 15 jmp 10b79f <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;
10b78a: 83 3a 00 cmpl $0x0,(%edx)
10b78d: 0f 85 9f 00 00 00 jne 10b832 <rtems_io_register_driver+0x116>
10b793: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b797: 0f 85 95 00 00 00 jne 10b832 <rtems_io_register_driver+0x116>
10b79d: eb 04 jmp 10b7a3 <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 ) {
10b79f: 39 cb cmp %ecx,%ebx
10b7a1: 72 e7 jb 10b78a <rtems_io_register_driver+0x6e>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10b7a3: 89 18 mov %ebx,(%eax)
if ( m != n )
10b7a5: 39 cb cmp %ecx,%ebx
10b7a7: 75 30 jne 10b7d9 <rtems_io_register_driver+0xbd>
10b7a9: e9 8d 00 00 00 jmp 10b83b <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;
10b7ae: 6b d3 18 imul $0x18,%ebx,%edx
10b7b1: 03 15 bc 8d 12 00 add 0x128dbc,%edx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b7b7: 31 c9 xor %ecx,%ecx
10b7b9: 83 3a 00 cmpl $0x0,(%edx)
10b7bc: 75 09 jne 10b7c7 <rtems_io_register_driver+0xab>
10b7be: 31 c9 xor %ecx,%ecx
10b7c0: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b7c4: 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 ) ) {
10b7c7: 85 c9 test %ecx,%ecx
10b7c9: 75 0c jne 10b7d7 <rtems_io_register_driver+0xbb>
_Thread_Enable_dispatch();
10b7cb: e8 22 1a 00 00 call 10d1f2 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b7d0: b8 0c 00 00 00 mov $0xc,%eax
10b7d5: eb 49 jmp 10b820 <rtems_io_register_driver+0x104>
}
*registered_major = major;
10b7d7: 89 18 mov %ebx,(%eax)
}
_IO_Driver_address_table [major] = *driver_table;
10b7d9: 6b c3 18 imul $0x18,%ebx,%eax
10b7dc: 03 05 bc 8d 12 00 add 0x128dbc,%eax
10b7e2: b9 06 00 00 00 mov $0x6,%ecx
10b7e7: 89 c7 mov %eax,%edi
10b7e9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10b7eb: e8 02 1a 00 00 call 10d1f2 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10b7f0: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10b7f7: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10b7fe: 89 5d 08 mov %ebx,0x8(%ebp)
}
10b801: 83 c4 0c add $0xc,%esp
10b804: 5b pop %ebx
10b805: 5e pop %esi
10b806: 5f pop %edi
10b807: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10b808: e9 63 71 00 00 jmp 112970 <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10b80d: b8 12 00 00 00 mov $0x12,%eax
10b812: eb 0c jmp 10b820 <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;
10b814: b8 09 00 00 00 mov $0x9,%eax
10b819: eb 05 jmp 10b820 <rtems_io_register_driver+0x104>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10b81b: 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 );
}
10b820: 83 c4 0c add $0xc,%esp
10b823: 5b pop %ebx
10b824: 5e pop %esi
10b825: 5f pop %edi
10b826: c9 leave
10b827: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10b828: 39 d3 cmp %edx,%ebx
10b82a: 0f 82 3b ff ff ff jb 10b76b <rtems_io_register_driver+0x4f>
10b830: eb e9 jmp 10b81b <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 ) {
10b832: 43 inc %ebx
10b833: 83 c2 18 add $0x18,%edx
10b836: e9 64 ff ff ff jmp 10b79f <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();
10b83b: e8 b2 19 00 00 call 10d1f2 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10b840: 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;
10b845: eb d9 jmp 10b820 <rtems_io_register_driver+0x104>
0010c744 <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)
{
10c744: 55 push %ebp
10c745: 89 e5 mov %esp,%ebp
10c747: 57 push %edi
10c748: 56 push %esi
10c749: 53 push %ebx
10c74a: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c74d: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c751: 74 3d je 10c790 <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10c753: 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 ];
10c758: 8b 04 9d 7c 01 13 00 mov 0x13017c(,%ebx,4),%eax
10c75f: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c762: be 01 00 00 00 mov $0x1,%esi
10c767: 85 ff test %edi,%edi
10c769: 75 17 jne 10c782 <rtems_iterate_over_all_threads+0x3e>
10c76b: eb 1d jmp 10c78a <rtems_iterate_over_all_threads+0x46>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c76d: 8b 47 1c mov 0x1c(%edi),%eax
10c770: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c773: 85 c0 test %eax,%eax
10c775: 74 0a je 10c781 <rtems_iterate_over_all_threads+0x3d><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c777: 83 ec 0c sub $0xc,%esp
10c77a: 50 push %eax
10c77b: ff 55 08 call *0x8(%ebp)
10c77e: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c781: 46 inc %esi
10c782: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c786: 39 c6 cmp %eax,%esi
10c788: 76 e3 jbe 10c76d <rtems_iterate_over_all_threads+0x29>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c78a: 43 inc %ebx
10c78b: 83 fb 04 cmp $0x4,%ebx
10c78e: 75 c8 jne 10c758 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c790: 8d 65 f4 lea -0xc(%ebp),%esp
10c793: 5b pop %ebx
10c794: 5e pop %esi
10c795: 5f pop %edi
10c796: c9 leave
10c797: c3 ret
001147ec <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1147ec: 55 push %ebp
1147ed: 89 e5 mov %esp,%ebp
1147ef: 57 push %edi
1147f0: 56 push %esi
1147f1: 53 push %ebx
1147f2: 83 ec 1c sub $0x1c,%esp
1147f5: 8b 75 0c mov 0xc(%ebp),%esi
1147f8: 8b 55 10 mov 0x10(%ebp),%edx
1147fb: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1147fe: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
114803: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
114807: 0f 84 ce 00 00 00 je 1148db <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
11480d: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
11480f: 85 f6 test %esi,%esi
114811: 0f 84 c4 00 00 00 je 1148db <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
114817: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
11481b: 0f 84 ba 00 00 00 je 1148db <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114821: 85 ff test %edi,%edi
114823: 0f 84 ad 00 00 00 je 1148d6 <rtems_partition_create+0xea>
114829: 85 d2 test %edx,%edx
11482b: 0f 84 a5 00 00 00 je 1148d6 <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
114831: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114833: 39 fa cmp %edi,%edx
114835: 0f 82 a0 00 00 00 jb 1148db <rtems_partition_create+0xef>
11483b: f7 c7 03 00 00 00 test $0x3,%edi
114841: 0f 85 94 00 00 00 jne 1148db <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;
114847: 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 ) )
114849: f7 c6 03 00 00 00 test $0x3,%esi
11484f: 0f 85 86 00 00 00 jne 1148db <rtems_partition_create+0xef>
114855: a1 f4 e6 13 00 mov 0x13e6f4,%eax
11485a: 40 inc %eax
11485b: a3 f4 e6 13 00 mov %eax,0x13e6f4
* 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 );
114860: 83 ec 0c sub $0xc,%esp
114863: 68 84 e5 13 00 push $0x13e584
114868: 89 55 e4 mov %edx,-0x1c(%ebp)
11486b: e8 14 3e 00 00 call 118684 <_Objects_Allocate>
114870: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
114872: 83 c4 10 add $0x10,%esp
114875: 85 c0 test %eax,%eax
114877: 8b 55 e4 mov -0x1c(%ebp),%edx
11487a: 75 0c jne 114888 <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
11487c: e8 4d 4c 00 00 call 1194ce <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
114881: b8 05 00 00 00 mov $0x5,%eax
114886: eb 53 jmp 1148db <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
114888: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
11488b: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
11488e: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
114891: 8b 45 18 mov 0x18(%ebp),%eax
114894: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
114897: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
11489e: 57 push %edi
11489f: 89 d0 mov %edx,%eax
1148a1: 31 d2 xor %edx,%edx
1148a3: f7 f7 div %edi
1148a5: 50 push %eax
1148a6: 56 push %esi
1148a7: 8d 43 24 lea 0x24(%ebx),%eax
1148aa: 50 push %eax
1148ab: e8 84 2a 00 00 call 117334 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1148b0: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1148b3: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1148b6: 8b 15 a0 e5 13 00 mov 0x13e5a0,%edx
1148bc: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1148bf: 8b 55 08 mov 0x8(%ebp),%edx
1148c2: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1148c5: 8b 55 1c mov 0x1c(%ebp),%edx
1148c8: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1148ca: e8 ff 4b 00 00 call 1194ce <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1148cf: 83 c4 10 add $0x10,%esp
1148d2: 31 c0 xor %eax,%eax
1148d4: eb 05 jmp 1148db <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;
1148d6: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1148db: 8d 65 f4 lea -0xc(%ebp),%esp
1148de: 5b pop %ebx
1148df: 5e pop %esi
1148e0: 5f pop %edi
1148e1: c9 leave
1148e2: c3 ret
0010b031 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b031: 55 push %ebp
10b032: 89 e5 mov %esp,%ebp
10b034: 57 push %edi
10b035: 56 push %esi
10b036: 53 push %ebx
10b037: 83 ec 30 sub $0x30,%esp
10b03a: 8b 75 08 mov 0x8(%ebp),%esi
10b03d: 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 );
10b040: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b043: 50 push %eax
10b044: 56 push %esi
10b045: 68 14 73 12 00 push $0x127314
10b04a: e8 3d 1e 00 00 call 10ce8c <_Objects_Get>
10b04f: 89 c7 mov %eax,%edi
switch ( location ) {
10b051: 83 c4 10 add $0x10,%esp
10b054: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b058: 0f 85 3b 01 00 00 jne 10b199 <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b05e: a1 4c 79 12 00 mov 0x12794c,%eax
10b063: 39 47 40 cmp %eax,0x40(%edi)
10b066: 74 0f je 10b077 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b068: e8 fd 27 00 00 call 10d86a <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b06d: be 17 00 00 00 mov $0x17,%esi
10b072: e9 27 01 00 00 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b077: 85 db test %ebx,%ebx
10b079: 75 1b jne 10b096 <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b07b: 8b 47 38 mov 0x38(%edi),%eax
10b07e: 31 f6 xor %esi,%esi
10b080: 83 f8 04 cmp $0x4,%eax
10b083: 77 07 ja 10b08c <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b085: 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();
10b08c: e8 d9 27 00 00 call 10d86a <_Thread_Enable_dispatch>
return( return_value );
10b091: e9 08 01 00 00 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b096: 9c pushf
10b097: fa cli
10b098: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b09b: 8b 47 38 mov 0x38(%edi),%eax
10b09e: 85 c0 test %eax,%eax
10b0a0: 75 4c jne 10b0ee <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0a2: ff 75 d4 pushl -0x2c(%ebp)
10b0a5: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0a6: 83 ec 0c sub $0xc,%esp
10b0a9: 57 push %edi
10b0aa: e8 3f fe ff ff call 10aeee <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b0af: 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;
10b0b6: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b0bd: c7 47 2c a8 b3 10 00 movl $0x10b3a8,0x2c(%edi)
the_watchdog->id = id;
10b0c4: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b0c7: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b0ce: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b0d1: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b0d4: 58 pop %eax
10b0d5: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b0d6: 83 c7 10 add $0x10,%edi
10b0d9: 57 push %edi
10b0da: 68 e8 74 12 00 push $0x1274e8
10b0df: e8 2c 35 00 00 call 10e610 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b0e4: e8 81 27 00 00 call 10d86a <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b0e9: 83 c4 10 add $0x10,%esp
10b0ec: eb 65 jmp 10b153 <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b0ee: 83 f8 02 cmp $0x2,%eax
10b0f1: 75 64 jne 10b157 <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b0f3: 83 ec 0c sub $0xc,%esp
10b0f6: 57 push %edi
10b0f7: e8 5a fe ff ff call 10af56 <_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;
10b0fc: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b103: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b106: ff 75 d4 pushl -0x2c(%ebp)
10b109: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b10a: a1 4c 79 12 00 mov 0x12794c,%eax
10b10f: 8b 57 08 mov 0x8(%edi),%edx
10b112: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b115: 5b pop %ebx
10b116: 5e pop %esi
10b117: 68 00 40 00 00 push $0x4000
10b11c: 50 push %eax
10b11d: e8 fe 2e 00 00 call 10e020 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b122: 9c pushf
10b123: fa cli
10b124: 5a pop %edx
local_state = the_period->state;
10b125: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b128: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b12f: 52 push %edx
10b130: 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 )
10b131: 83 c4 10 add $0x10,%esp
10b134: 83 f8 03 cmp $0x3,%eax
10b137: 75 15 jne 10b14e <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b139: 51 push %ecx
10b13a: 51 push %ecx
10b13b: 68 00 40 00 00 push $0x4000
10b140: ff 35 4c 79 12 00 pushl 0x12794c
10b146: e8 ed 23 00 00 call 10d538 <_Thread_Clear_state>
10b14b: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b14e: e8 17 27 00 00 call 10d86a <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b153: 31 f6 xor %esi,%esi
10b155: eb 47 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b157: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b15c: 83 f8 04 cmp $0x4,%eax
10b15f: 75 3d jne 10b19e <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b161: 83 ec 0c sub $0xc,%esp
10b164: 57 push %edi
10b165: e8 ec fd ff ff call 10af56 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b16a: ff 75 d4 pushl -0x2c(%ebp)
10b16d: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b16e: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b175: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b178: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b17b: 58 pop %eax
10b17c: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b17d: 83 c7 10 add $0x10,%edi
10b180: 57 push %edi
10b181: 68 e8 74 12 00 push $0x1274e8
10b186: e8 85 34 00 00 call 10e610 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b18b: e8 da 26 00 00 call 10d86a <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b190: 83 c4 10 add $0x10,%esp
10b193: 66 be 06 00 mov $0x6,%si
10b197: eb 05 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b199: be 04 00 00 00 mov $0x4,%esi
}
10b19e: 89 f0 mov %esi,%eax
10b1a0: 8d 65 f4 lea -0xc(%ebp),%esp
10b1a3: 5b pop %ebx
10b1a4: 5e pop %esi
10b1a5: 5f pop %edi
10b1a6: c9 leave
10b1a7: c3 ret
0010b1a8 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1a8: 55 push %ebp
10b1a9: 89 e5 mov %esp,%ebp
10b1ab: 57 push %edi
10b1ac: 56 push %esi
10b1ad: 53 push %ebx
10b1ae: 83 ec 7c sub $0x7c,%esp
10b1b1: 8b 5d 08 mov 0x8(%ebp),%ebx
10b1b4: 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 )
10b1b7: 85 ff test %edi,%edi
10b1b9: 0f 84 2b 01 00 00 je 10b2ea <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b1bf: 52 push %edx
10b1c0: 52 push %edx
10b1c1: 68 bc 0d 12 00 push $0x120dbc
10b1c6: 53 push %ebx
10b1c7: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b1c9: 5e pop %esi
10b1ca: 58 pop %eax
10b1cb: 68 da 0d 12 00 push $0x120dda
10b1d0: 53 push %ebx
10b1d1: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b1d3: 5a pop %edx
10b1d4: 59 pop %ecx
10b1d5: 68 fc 0d 12 00 push $0x120dfc
10b1da: 53 push %ebx
10b1db: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b1dd: 5e pop %esi
10b1de: 58 pop %eax
10b1df: 68 1f 0e 12 00 push $0x120e1f
10b1e4: 53 push %ebx
10b1e5: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b1e7: 5a pop %edx
10b1e8: 59 pop %ecx
10b1e9: 68 6a 0e 12 00 push $0x120e6a
10b1ee: 53 push %ebx
10b1ef: 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 ;
10b1f1: 8b 35 1c 73 12 00 mov 0x12731c,%esi
10b1f7: 83 c4 10 add $0x10,%esp
10b1fa: e9 df 00 00 00 jmp 10b2de <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b1ff: 50 push %eax
10b200: 50 push %eax
10b201: 8d 45 88 lea -0x78(%ebp),%eax
10b204: 50 push %eax
10b205: 56 push %esi
10b206: e8 85 56 00 00 call 110890 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b20b: 83 c4 10 add $0x10,%esp
10b20e: 85 c0 test %eax,%eax
10b210: 0f 85 c7 00 00 00 jne 10b2dd <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 );
10b216: 51 push %ecx
10b217: 51 push %ecx
10b218: 8d 55 c0 lea -0x40(%ebp),%edx
10b21b: 52 push %edx
10b21c: 56 push %esi
10b21d: e8 12 57 00 00 call 110934 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b222: 83 c4 0c add $0xc,%esp
10b225: 8d 45 e3 lea -0x1d(%ebp),%eax
10b228: 50 push %eax
10b229: 6a 05 push $0x5
10b22b: ff 75 c0 pushl -0x40(%ebp)
10b22e: e8 01 02 00 00 call 10b434 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b233: 58 pop %eax
10b234: 5a pop %edx
10b235: ff 75 8c pushl -0x74(%ebp)
10b238: ff 75 88 pushl -0x78(%ebp)
10b23b: 8d 55 e3 lea -0x1d(%ebp),%edx
10b23e: 52 push %edx
10b23f: 56 push %esi
10b240: 68 b6 0e 12 00 push $0x120eb6
10b245: 53 push %ebx
10b246: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b248: 8b 45 88 mov -0x78(%ebp),%eax
10b24b: 83 c4 20 add $0x20,%esp
10b24e: 85 c0 test %eax,%eax
10b250: 75 0f jne 10b261 <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b252: 51 push %ecx
10b253: 51 push %ecx
10b254: 68 30 11 12 00 push $0x121130
10b259: 53 push %ebx
10b25a: ff d7 call *%edi
continue;
10b25c: 83 c4 10 add $0x10,%esp
10b25f: eb 7c jmp 10b2dd <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 );
10b261: 52 push %edx
10b262: 8d 55 d8 lea -0x28(%ebp),%edx
10b265: 52 push %edx
10b266: 50 push %eax
10b267: 8d 45 a0 lea -0x60(%ebp),%eax
10b26a: 50 push %eax
10b26b: e8 74 30 00 00 call 10e2e4 <_Timespec_Divide_by_integer>
(*print)( context,
10b270: 8b 45 dc mov -0x24(%ebp),%eax
10b273: b9 e8 03 00 00 mov $0x3e8,%ecx
10b278: 99 cltd
10b279: f7 f9 idiv %ecx
10b27b: 50 push %eax
10b27c: ff 75 d8 pushl -0x28(%ebp)
10b27f: 8b 45 9c mov -0x64(%ebp),%eax
10b282: 99 cltd
10b283: f7 f9 idiv %ecx
10b285: 50 push %eax
10b286: ff 75 98 pushl -0x68(%ebp)
10b289: 8b 45 94 mov -0x6c(%ebp),%eax
10b28c: 99 cltd
10b28d: f7 f9 idiv %ecx
10b28f: 50 push %eax
10b290: ff 75 90 pushl -0x70(%ebp)
10b293: 68 cd 0e 12 00 push $0x120ecd
10b298: 53 push %ebx
10b299: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b29c: 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);
10b29e: 83 c4 2c add $0x2c,%esp
10b2a1: 8d 55 d8 lea -0x28(%ebp),%edx
10b2a4: 52 push %edx
10b2a5: 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;
10b2a8: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2ab: 50 push %eax
10b2ac: e8 33 30 00 00 call 10e2e4 <_Timespec_Divide_by_integer>
(*print)( context,
10b2b1: 8b 45 dc mov -0x24(%ebp),%eax
10b2b4: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b2b7: 99 cltd
10b2b8: f7 f9 idiv %ecx
10b2ba: 50 push %eax
10b2bb: ff 75 d8 pushl -0x28(%ebp)
10b2be: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2c1: 99 cltd
10b2c2: f7 f9 idiv %ecx
10b2c4: 50 push %eax
10b2c5: ff 75 b0 pushl -0x50(%ebp)
10b2c8: 8b 45 ac mov -0x54(%ebp),%eax
10b2cb: 99 cltd
10b2cc: f7 f9 idiv %ecx
10b2ce: 50 push %eax
10b2cf: ff 75 a8 pushl -0x58(%ebp)
10b2d2: 68 ec 0e 12 00 push $0x120eec
10b2d7: 53 push %ebx
10b2d8: ff d7 call *%edi
10b2da: 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++ ) {
10b2dd: 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 ;
10b2de: 3b 35 20 73 12 00 cmp 0x127320,%esi
10b2e4: 0f 86 15 ff ff ff jbe 10b1ff <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b2ea: 8d 65 f4 lea -0xc(%ebp),%esp
10b2ed: 5b pop %ebx
10b2ee: 5e pop %esi
10b2ef: 5f pop %edi
10b2f0: c9 leave
10b2f1: c3 ret
00115b4c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115b4c: 55 push %ebp
115b4d: 89 e5 mov %esp,%ebp
115b4f: 53 push %ebx
115b50: 83 ec 14 sub $0x14,%esp
115b53: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115b56: 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 )
115b5b: 85 db test %ebx,%ebx
115b5d: 74 6d je 115bcc <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115b5f: 50 push %eax
115b60: 50 push %eax
115b61: 8d 45 f4 lea -0xc(%ebp),%eax
115b64: 50 push %eax
115b65: ff 75 08 pushl 0x8(%ebp)
115b68: e8 83 39 00 00 call 1194f0 <_Thread_Get>
switch ( location ) {
115b6d: 83 c4 10 add $0x10,%esp
115b70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115b74: 75 51 jne 115bc7 <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115b76: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115b7c: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115b80: 74 39 je 115bbb <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115b82: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115b86: 74 22 je 115baa <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115b88: 9c pushf
115b89: fa cli
115b8a: 59 pop %ecx
*signal_set |= signals;
115b8b: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115b8e: 51 push %ecx
115b8f: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115b90: 83 3d 40 ec 13 00 00 cmpl $0x0,0x13ec40
115b97: 74 19 je 115bb2 <rtems_signal_send+0x66>
115b99: 3b 05 44 ec 13 00 cmp 0x13ec44,%eax
115b9f: 75 11 jne 115bb2 <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115ba1: c6 05 50 ec 13 00 01 movb $0x1,0x13ec50
115ba8: eb 08 jmp 115bb2 <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115baa: 9c pushf
115bab: fa cli
115bac: 58 pop %eax
*signal_set |= signals;
115bad: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115bb0: 50 push %eax
115bb1: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115bb2: e8 17 39 00 00 call 1194ce <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115bb7: 31 c0 xor %eax,%eax
115bb9: eb 11 jmp 115bcc <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115bbb: e8 0e 39 00 00 call 1194ce <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115bc0: b8 0b 00 00 00 mov $0xb,%eax
115bc5: eb 05 jmp 115bcc <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115bc7: b8 04 00 00 00 mov $0x4,%eax
}
115bcc: 8b 5d fc mov -0x4(%ebp),%ebx
115bcf: c9 leave
115bd0: c3 ret
00110d7c <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110d7c: 55 push %ebp
110d7d: 89 e5 mov %esp,%ebp
110d7f: 57 push %edi
110d80: 56 push %esi
110d81: 53 push %ebx
110d82: 83 ec 1c sub $0x1c,%esp
110d85: 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;
110d88: 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 )
110d8d: 85 c9 test %ecx,%ecx
110d8f: 0f 84 fb 00 00 00 je 110e90 <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110d95: 8b 35 28 48 12 00 mov 0x124828,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110d9b: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110da1: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110da5: 19 ff sbb %edi,%edi
110da7: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110dad: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110db1: 74 06 je 110db9 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110db3: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110db9: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110dbd: 19 d2 sbb %edx,%edx
110dbf: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110dc5: 89 55 e4 mov %edx,-0x1c(%ebp)
110dc8: 89 4d e0 mov %ecx,-0x20(%ebp)
110dcb: e8 a5 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;
110dd0: 8b 55 e4 mov -0x1c(%ebp),%edx
110dd3: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110dd5: 09 f8 or %edi,%eax
110dd7: 8b 4d e0 mov -0x20(%ebp),%ecx
110dda: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110ddc: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110de3: 74 0b je 110df0 <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110de5: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110dec: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110df0: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110df7: 74 21 je 110e1a <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110df9: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110e00: 74 11 je 110e13 <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110e02: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110e09: a1 b0 42 12 00 mov 0x1242b0,%eax
110e0e: 89 46 78 mov %eax,0x78(%esi)
110e11: eb 07 jmp 110e1a <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110e13: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110e1a: f6 45 0c 01 testb $0x1,0xc(%ebp)
110e1e: 74 0a je 110e2a <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 ) );
110e20: f6 45 08 01 testb $0x1,0x8(%ebp)
110e24: 74 03 je 110e29 <rtems_task_mode+0xad>
110e26: fa cli
110e27: eb 01 jmp 110e2a <rtems_task_mode+0xae>
110e29: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e2a: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110e2c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110e33: 74 2a je 110e5f <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110e35: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110e3c: 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 ) {
110e3f: 3a 43 08 cmp 0x8(%ebx),%al
110e42: 74 1b je 110e5f <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110e44: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110e47: 9c pushf
110e48: fa cli
110e49: 58 pop %eax
_signals = information->signals_pending;
110e4a: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110e4d: 8b 4b 14 mov 0x14(%ebx),%ecx
110e50: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110e53: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110e56: 50 push %eax
110e57: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110e58: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110e5c: 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;
110e5f: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110e61: 83 3d 5c 44 12 00 03 cmpl $0x3,0x12445c
110e68: 75 26 jne 110e90 <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110e6a: 8b 15 28 48 12 00 mov 0x124828,%edx
if ( are_signals_pending ||
110e70: 84 c9 test %cl,%cl
110e72: 75 0e jne 110e82 <rtems_task_mode+0x106>
110e74: 3b 15 2c 48 12 00 cmp 0x12482c,%edx
110e7a: 74 14 je 110e90 <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110e7c: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110e80: 74 0e je 110e90 <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110e82: c6 05 34 48 12 00 01 movb $0x1,0x124834
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110e89: e8 0e b1 ff ff call 10bf9c <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110e8e: 31 c0 xor %eax,%eax
}
110e90: 83 c4 1c add $0x1c,%esp
110e93: 5b pop %ebx
110e94: 5e pop %esi
110e95: 5f pop %edi
110e96: c9 leave
110e97: c3 ret
0010dd30 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd30: 55 push %ebp
10dd31: 89 e5 mov %esp,%ebp
10dd33: 56 push %esi
10dd34: 53 push %ebx
10dd35: 83 ec 10 sub $0x10,%esp
10dd38: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd3b: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd3e: 85 db test %ebx,%ebx
10dd40: 74 10 je 10dd52 <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 ) );
10dd42: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd49: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd4e: 39 d3 cmp %edx,%ebx
10dd50: 77 52 ja 10dda4 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dd52: 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 )
10dd57: 85 f6 test %esi,%esi
10dd59: 74 49 je 10dda4 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10dd5b: 51 push %ecx
10dd5c: 51 push %ecx
10dd5d: 8d 45 f4 lea -0xc(%ebp),%eax
10dd60: 50 push %eax
10dd61: ff 75 08 pushl 0x8(%ebp)
10dd64: e8 fb 1d 00 00 call 10fb64 <_Thread_Get>
switch ( location ) {
10dd69: 83 c4 10 add $0x10,%esp
10dd6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10dd70: 75 2d jne 10dd9f <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10dd72: 8b 50 14 mov 0x14(%eax),%edx
10dd75: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10dd77: 85 db test %ebx,%ebx
10dd79: 74 1b je 10dd96 <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10dd7b: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10dd7e: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10dd82: 74 05 je 10dd89 <rtems_task_set_priority+0x59>
10dd84: 39 58 14 cmp %ebx,0x14(%eax)
10dd87: 76 0d jbe 10dd96 <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dd89: 52 push %edx
10dd8a: 6a 00 push $0x0
10dd8c: 53 push %ebx
10dd8d: 50 push %eax
10dd8e: e8 69 19 00 00 call 10f6fc <_Thread_Change_priority>
10dd93: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10dd96: e8 a7 1d 00 00 call 10fb42 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10dd9b: 31 c0 xor %eax,%eax
10dd9d: eb 05 jmp 10dda4 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10dd9f: b8 04 00 00 00 mov $0x4,%eax
}
10dda4: 8d 65 f8 lea -0x8(%ebp),%esp
10dda7: 5b pop %ebx
10dda8: 5e pop %esi
10dda9: c9 leave
10ddaa: c3 ret
001163a0 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1163a0: 55 push %ebp
1163a1: 89 e5 mov %esp,%ebp
1163a3: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1163a6: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1163a9: 50 push %eax
1163aa: ff 75 08 pushl 0x8(%ebp)
1163ad: 68 5c f0 13 00 push $0x13f05c
1163b2: e8 39 27 00 00 call 118af0 <_Objects_Get>
switch ( location ) {
1163b7: 83 c4 10 add $0x10,%esp
1163ba: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1163be: 75 1e jne 1163de <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1163c0: 83 78 38 04 cmpl $0x4,0x38(%eax)
1163c4: 74 0f je 1163d5 <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
1163c6: 83 ec 0c sub $0xc,%esp
1163c9: 83 c0 10 add $0x10,%eax
1163cc: 50 push %eax
1163cd: e8 32 41 00 00 call 11a504 <_Watchdog_Remove>
1163d2: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1163d5: e8 f4 30 00 00 call 1194ce <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1163da: 31 c0 xor %eax,%eax
1163dc: eb 05 jmp 1163e3 <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163de: b8 04 00 00 00 mov $0x4,%eax
}
1163e3: c9 leave
1163e4: c3 ret
00116800 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
116800: 55 push %ebp
116801: 89 e5 mov %esp,%ebp
116803: 57 push %edi
116804: 56 push %esi
116805: 53 push %ebx
116806: 83 ec 1c sub $0x1c,%esp
116809: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
11680c: 8b 35 9c f0 13 00 mov 0x13f09c,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
116812: 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 )
116817: 85 f6 test %esi,%esi
116819: 0f 84 b1 00 00 00 je 1168d0 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
11681f: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
116821: 80 3d 08 e7 13 00 00 cmpb $0x0,0x13e708
116828: 0f 84 a2 00 00 00 je 1168d0 <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
11682e: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
116830: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
116834: 0f 84 96 00 00 00 je 1168d0 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
11683a: 83 ec 0c sub $0xc,%esp
11683d: 57 push %edi
11683e: e8 ad d6 ff ff call 113ef0 <_TOD_Validate>
116843: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
116846: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116848: 84 c0 test %al,%al
11684a: 0f 84 80 00 00 00 je 1168d0 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
116850: 83 ec 0c sub $0xc,%esp
116853: 57 push %edi
116854: e8 2f d6 ff ff call 113e88 <_TOD_To_seconds>
116859: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11685b: 83 c4 10 add $0x10,%esp
11685e: 3b 05 a0 e7 13 00 cmp 0x13e7a0,%eax
116864: 76 6a jbe 1168d0 <rtems_timer_server_fire_when+0xd0>
116866: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
116867: 8d 45 e4 lea -0x1c(%ebp),%eax
11686a: 50 push %eax
11686b: ff 75 08 pushl 0x8(%ebp)
11686e: 68 5c f0 13 00 push $0x13f05c
116873: e8 78 22 00 00 call 118af0 <_Objects_Get>
116878: 89 c3 mov %eax,%ebx
switch ( location ) {
11687a: 83 c4 10 add $0x10,%esp
11687d: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
116881: 75 48 jne 1168cb <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
116883: 83 ec 0c sub $0xc,%esp
116886: 8d 40 10 lea 0x10(%eax),%eax
116889: 50 push %eax
11688a: e8 75 3c 00 00 call 11a504 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
11688f: 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;
116896: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
11689d: 8b 45 10 mov 0x10(%ebp),%eax
1168a0: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
1168a3: 8b 45 08 mov 0x8(%ebp),%eax
1168a6: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
1168a9: 8b 45 14 mov 0x14(%ebp),%eax
1168ac: 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();
1168af: 2b 3d a0 e7 13 00 sub 0x13e7a0,%edi
1168b5: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1168b8: 58 pop %eax
1168b9: 5a pop %edx
1168ba: 53 push %ebx
1168bb: 56 push %esi
1168bc: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
1168bf: e8 0a 2c 00 00 call 1194ce <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1168c4: 83 c4 10 add $0x10,%esp
1168c7: 31 db xor %ebx,%ebx
1168c9: eb 05 jmp 1168d0 <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1168cb: bb 04 00 00 00 mov $0x4,%ebx
}
1168d0: 89 d8 mov %ebx,%eax
1168d2: 8d 65 f4 lea -0xc(%ebp),%esp
1168d5: 5b pop %ebx
1168d6: 5e pop %esi
1168d7: 5f pop %edi
1168d8: c9 leave
1168d9: c3 ret
0010a8f4 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a8f4: 55 push %ebp
10a8f5: 89 e5 mov %esp,%ebp
10a8f7: 83 ec 08 sub $0x8,%esp
10a8fa: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a8fd: 83 f9 04 cmp $0x4,%ecx
10a900: 77 0b ja 10a90d <sched_get_priority_max+0x19>
10a902: b8 01 00 00 00 mov $0x1,%eax
10a907: d3 e0 shl %cl,%eax
10a909: a8 17 test $0x17,%al
10a90b: 75 10 jne 10a91d <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a90d: e8 5a 74 00 00 call 111d6c <__errno>
10a912: c7 00 16 00 00 00 movl $0x16,(%eax)
10a918: 83 c8 ff or $0xffffffff,%eax
10a91b: eb 08 jmp 10a925 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a91d: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax
10a924: 48 dec %eax
}
10a925: c9 leave
10a926: c3 ret
0010a928 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a928: 55 push %ebp
10a929: 89 e5 mov %esp,%ebp
10a92b: 83 ec 08 sub $0x8,%esp
10a92e: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a931: 83 f9 04 cmp $0x4,%ecx
10a934: 77 11 ja 10a947 <sched_get_priority_min+0x1f>
10a936: ba 01 00 00 00 mov $0x1,%edx
10a93b: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a93d: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a942: 80 e2 17 and $0x17,%dl
10a945: 75 0e jne 10a955 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a947: e8 20 74 00 00 call 111d6c <__errno>
10a94c: c7 00 16 00 00 00 movl $0x16,(%eax)
10a952: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a955: c9 leave
10a956: c3 ret
0010a958 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a958: 55 push %ebp
10a959: 89 e5 mov %esp,%ebp
10a95b: 56 push %esi
10a95c: 53 push %ebx
10a95d: 8b 75 08 mov 0x8(%ebp),%esi
10a960: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a963: 85 f6 test %esi,%esi
10a965: 74 16 je 10a97d <sched_rr_get_interval+0x25><== NEVER TAKEN
10a967: e8 b4 d0 ff ff call 107a20 <getpid>
10a96c: 39 c6 cmp %eax,%esi
10a96e: 74 0d je 10a97d <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a970: e8 f7 73 00 00 call 111d6c <__errno>
10a975: c7 00 03 00 00 00 movl $0x3,(%eax)
10a97b: eb 0f jmp 10a98c <sched_rr_get_interval+0x34>
if ( !interval )
10a97d: 85 db test %ebx,%ebx
10a97f: 75 10 jne 10a991 <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a981: e8 e6 73 00 00 call 111d6c <__errno>
10a986: c7 00 16 00 00 00 movl $0x16,(%eax)
10a98c: 83 c8 ff or $0xffffffff,%eax
10a98f: eb 13 jmp 10a9a4 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a991: 50 push %eax
10a992: 50 push %eax
10a993: 53 push %ebx
10a994: ff 35 a0 52 12 00 pushl 0x1252a0
10a99a: e8 81 30 00 00 call 10da20 <_Timespec_From_ticks>
return 0;
10a99f: 83 c4 10 add $0x10,%esp
10a9a2: 31 c0 xor %eax,%eax
}
10a9a4: 8d 65 f8 lea -0x8(%ebp),%esp
10a9a7: 5b pop %ebx
10a9a8: 5e pop %esi
10a9a9: c9 leave
10a9aa: c3 ret
0010cff0 <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
10cff0: 55 push %ebp
10cff1: 89 e5 mov %esp,%ebp
10cff3: 53 push %ebx
10cff4: 83 ec 14 sub $0x14,%esp
10cff7: 8b 5d 08 mov 0x8(%ebp),%ebx
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
10cffa: 85 db test %ebx,%ebx
10cffc: 75 10 jne 10d00e <sem_init+0x1e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10cffe: e8 65 80 00 00 call 115068 <__errno>
10d003: c7 00 16 00 00 00 movl $0x16,(%eax)
10d009: 83 c8 ff or $0xffffffff,%eax
10d00c: eb 21 jmp 10d02f <sem_init+0x3f>
status = _POSIX_Semaphore_Create_support(
10d00e: 8d 45 f4 lea -0xc(%ebp),%eax
10d011: 50 push %eax
10d012: ff 75 10 pushl 0x10(%ebp)
10d015: ff 75 0c pushl 0xc(%ebp)
10d018: 6a 00 push $0x0
10d01a: e8 8d 58 00 00 call 1128ac <_POSIX_Semaphore_Create_support>
pshared,
value,
&the_semaphore
);
if ( status != -1 )
10d01f: 83 c4 10 add $0x10,%esp
10d022: 83 f8 ff cmp $0xffffffff,%eax
10d025: 74 08 je 10d02f <sem_init+0x3f>
*sem = the_semaphore->Object.id;
10d027: 8b 55 f4 mov -0xc(%ebp),%edx
10d02a: 8b 52 08 mov 0x8(%edx),%edx
10d02d: 89 13 mov %edx,(%ebx)
return status;
}
10d02f: 8b 5d fc mov -0x4(%ebp),%ebx
10d032: c9 leave
10d033: c3 ret
0010d034 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d034: 55 push %ebp
10d035: 89 e5 mov %esp,%ebp
10d037: 57 push %edi
10d038: 56 push %esi
10d039: 53 push %ebx
10d03a: 83 ec 2c sub $0x2c,%esp
10d03d: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d040: a1 c8 a4 12 00 mov 0x12a4c8,%eax
10d045: 40 inc %eax
10d046: a3 c8 a4 12 00 mov %eax,0x12a4c8
va_list arg;
mode_t mode;
unsigned int value = 0;
10d04b: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d04d: 8b 45 0c mov 0xc(%ebp),%eax
10d050: 25 00 02 00 00 and $0x200,%eax
10d055: 89 45 d4 mov %eax,-0x2c(%ebp)
10d058: 74 03 je 10d05d <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d05a: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d05d: 52 push %edx
10d05e: 52 push %edx
10d05f: 8d 45 e4 lea -0x1c(%ebp),%eax
10d062: 50 push %eax
10d063: 56 push %esi
10d064: e8 77 59 00 00 call 1129e0 <_POSIX_Semaphore_Name_to_id>
10d069: 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 ) {
10d06b: 83 c4 10 add $0x10,%esp
10d06e: 85 c0 test %eax,%eax
10d070: 74 19 je 10d08b <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) ) ) {
10d072: 83 f8 02 cmp $0x2,%eax
10d075: 75 06 jne 10d07d <sem_open+0x49> <== NEVER TAKEN
10d077: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d07b: 75 59 jne 10d0d6 <sem_open+0xa2>
_Thread_Enable_dispatch();
10d07d: e8 6c 27 00 00 call 10f7ee <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d082: e8 e1 7f 00 00 call 115068 <__errno>
10d087: 89 18 mov %ebx,(%eax)
10d089: eb 1f jmp 10d0aa <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d08b: 8b 45 0c mov 0xc(%ebp),%eax
10d08e: 25 00 0a 00 00 and $0xa00,%eax
10d093: 3d 00 0a 00 00 cmp $0xa00,%eax
10d098: 75 15 jne 10d0af <sem_open+0x7b>
_Thread_Enable_dispatch();
10d09a: e8 4f 27 00 00 call 10f7ee <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d09f: e8 c4 7f 00 00 call 115068 <__errno>
10d0a4: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0aa: 83 c8 ff or $0xffffffff,%eax
10d0ad: eb 4a jmp 10d0f9 <sem_open+0xc5>
10d0af: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d0b0: 8d 45 dc lea -0x24(%ebp),%eax
10d0b3: 50 push %eax
10d0b4: ff 75 e4 pushl -0x1c(%ebp)
10d0b7: 68 8c a7 12 00 push $0x12a78c
10d0bc: e8 db 1c 00 00 call 10ed9c <_Objects_Get>
10d0c1: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d0c4: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d0c7: e8 22 27 00 00 call 10f7ee <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d0cc: e8 1d 27 00 00 call 10f7ee <_Thread_Enable_dispatch>
goto return_id;
10d0d1: 83 c4 10 add $0x10,%esp
10d0d4: eb 1d jmp 10d0f3 <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(
10d0d6: 8d 45 e0 lea -0x20(%ebp),%eax
10d0d9: 50 push %eax
10d0da: 57 push %edi
10d0db: 6a 00 push $0x0
10d0dd: 56 push %esi
10d0de: e8 c9 57 00 00 call 1128ac <_POSIX_Semaphore_Create_support>
10d0e3: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d0e5: e8 04 27 00 00 call 10f7ee <_Thread_Enable_dispatch>
if ( status == -1 )
10d0ea: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d0ed: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d0f0: 43 inc %ebx
10d0f1: 74 06 je 10d0f9 <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;
10d0f3: 8b 45 e0 mov -0x20(%ebp),%eax
10d0f6: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d0f9: 8d 65 f4 lea -0xc(%ebp),%esp
10d0fc: 5b pop %ebx
10d0fd: 5e pop %esi
10d0fe: 5f pop %edi
10d0ff: c9 leave
10d100: c3 ret
0010a7dc <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a7dc: 55 push %ebp
10a7dd: 89 e5 mov %esp,%ebp
10a7df: 57 push %edi
10a7e0: 56 push %esi
10a7e1: 53 push %ebx
10a7e2: 83 ec 1c sub $0x1c,%esp
10a7e5: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7e8: 8b 55 0c mov 0xc(%ebp),%edx
10a7eb: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a7ee: 85 c0 test %eax,%eax
10a7f0: 74 12 je 10a804 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a7f2: 6b f3 0c imul $0xc,%ebx,%esi
10a7f5: 81 c6 9c 68 12 00 add $0x12689c,%esi
10a7fb: b9 03 00 00 00 mov $0x3,%ecx
10a800: 89 c7 mov %eax,%edi
10a802: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a804: 85 db test %ebx,%ebx
10a806: 74 0d je 10a815 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a808: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a80b: 83 f8 1f cmp $0x1f,%eax
10a80e: 77 05 ja 10a815 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a810: 83 fb 09 cmp $0x9,%ebx
10a813: 75 10 jne 10a825 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a815: e8 d6 77 00 00 call 111ff0 <__errno>
10a81a: c7 00 16 00 00 00 movl $0x16,(%eax)
10a820: 83 c8 ff or $0xffffffff,%eax
10a823: eb 57 jmp 10a87c <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;
10a825: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a827: 85 d2 test %edx,%edx
10a829: 74 51 je 10a87c <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 );
10a82b: 9c pushf
10a82c: fa cli
10a82d: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a830: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a834: 75 1a jne 10a850 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a836: 6b f3 0c imul $0xc,%ebx,%esi
10a839: 8d 86 9c 68 12 00 lea 0x12689c(%esi),%eax
10a83f: 81 c6 9c 09 12 00 add $0x12099c,%esi
10a845: b9 03 00 00 00 mov $0x3,%ecx
10a84a: 89 c7 mov %eax,%edi
10a84c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a84e: eb 26 jmp 10a876 <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a850: 83 ec 0c sub $0xc,%esp
10a853: 53 push %ebx
10a854: 89 55 e0 mov %edx,-0x20(%ebp)
10a857: e8 70 4e 00 00 call 10f6cc <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a85c: 6b db 0c imul $0xc,%ebx,%ebx
10a85f: 81 c3 9c 68 12 00 add $0x12689c,%ebx
10a865: b9 03 00 00 00 mov $0x3,%ecx
10a86a: 8b 55 e0 mov -0x20(%ebp),%edx
10a86d: 89 df mov %ebx,%edi
10a86f: 89 d6 mov %edx,%esi
10a871: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a873: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a876: ff 75 e4 pushl -0x1c(%ebp)
10a879: 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;
10a87a: 31 c0 xor %eax,%eax
}
10a87c: 8d 65 f4 lea -0xc(%ebp),%esp
10a87f: 5b pop %ebx
10a880: 5e pop %esi
10a881: 5f pop %edi
10a882: c9 leave
10a883: c3 ret
0010ab97 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10ab97: 55 push %ebp
10ab98: 89 e5 mov %esp,%ebp
10ab9a: 57 push %edi
10ab9b: 56 push %esi
10ab9c: 53 push %ebx
10ab9d: 83 ec 3c sub $0x3c,%esp
10aba0: 8b 75 08 mov 0x8(%ebp),%esi
10aba3: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10aba6: 85 f6 test %esi,%esi
10aba8: 74 24 je 10abce <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abaa: 85 db test %ebx,%ebx
10abac: 74 30 je 10abde <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abae: 83 ec 0c sub $0xc,%esp
10abb1: 53 push %ebx
10abb2: e8 1d 31 00 00 call 10dcd4 <_Timespec_Is_valid>
10abb7: 83 c4 10 add $0x10,%esp
10abba: 84 c0 test %al,%al
10abbc: 74 10 je 10abce <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10abbe: 83 ec 0c sub $0xc,%esp
10abc1: 53 push %ebx
10abc2: e8 65 31 00 00 call 10dd2c <_Timespec_To_ticks>
if ( !interval )
10abc7: 83 c4 10 add $0x10,%esp
10abca: 85 c0 test %eax,%eax
10abcc: 75 12 jne 10abe0 <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10abce: e8 b5 79 00 00 call 112588 <__errno>
10abd3: c7 00 16 00 00 00 movl $0x16,(%eax)
10abd9: e9 39 01 00 00 jmp 10ad17 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10abde: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10abe0: 8b 7d 0c mov 0xc(%ebp),%edi
10abe3: 85 ff test %edi,%edi
10abe5: 75 03 jne 10abea <sigtimedwait+0x53>
10abe7: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10abea: 8b 15 68 68 12 00 mov 0x126868,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10abf0: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
10abf6: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10abf9: 9c pushf
10abfa: fa cli
10abfb: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10abfe: 8b 1e mov (%esi),%ebx
10ac00: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac03: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac06: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac0c: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac0f: 74 32 je 10ac43 <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac11: 83 ec 0c sub $0xc,%esp
10ac14: 51 push %ecx
10ac15: e8 3e ff ff ff call 10ab58 <_POSIX_signals_Get_lowest>
10ac1a: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac1c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac23: 6a 00 push $0x0
10ac25: 57 push %edi
10ac26: 50 push %eax
10ac27: 53 push %ebx
10ac28: e8 db 50 00 00 call 10fd08 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac2d: ff 75 d0 pushl -0x30(%ebp)
10ac30: 9d popf
the_info->si_code = SI_USER;
10ac31: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac38: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac3f: 8b 1f mov (%edi),%ebx
10ac41: eb 3d jmp 10ac80 <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac43: 8b 0d 90 6a 12 00 mov 0x126a90,%ecx
10ac49: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac4c: 74 3a je 10ac88 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac4e: 83 ec 0c sub $0xc,%esp
10ac51: 51 push %ecx
10ac52: e8 01 ff ff ff call 10ab58 <_POSIX_signals_Get_lowest>
10ac57: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10ac59: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac60: 6a 01 push $0x1
10ac62: 57 push %edi
10ac63: 50 push %eax
10ac64: ff 75 d4 pushl -0x2c(%ebp)
10ac67: e8 9c 50 00 00 call 10fd08 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10ac6c: ff 75 d0 pushl -0x30(%ebp)
10ac6f: 9d popf
the_info->si_signo = signo;
10ac70: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10ac72: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac79: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10ac80: 83 c4 20 add $0x20,%esp
10ac83: e9 92 00 00 00 jmp 10ad1a <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10ac88: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10ac8e: 8b 0d 20 63 12 00 mov 0x126320,%ecx
10ac94: 41 inc %ecx
10ac95: 89 0d 20 63 12 00 mov %ecx,0x126320
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10ac9b: c7 42 44 28 6a 12 00 movl $0x126a28,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10aca2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10aca9: 8b 0e mov (%esi),%ecx
10acab: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acae: 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;
10acb1: c7 05 58 6a 12 00 01 movl $0x1,0x126a58
10acb8: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10acbb: ff 75 d0 pushl -0x30(%ebp)
10acbe: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10acbf: 52 push %edx
10acc0: 68 f8 d9 10 00 push $0x10d9f8
10acc5: 50 push %eax
10acc6: 68 28 6a 12 00 push $0x126a28
10accb: e8 4c 2a 00 00 call 10d71c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10acd0: e8 c5 25 00 00 call 10d29a <_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 );
10acd5: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10acdc: 6a 00 push $0x0
10acde: 57 push %edi
10acdf: ff 37 pushl (%edi)
10ace1: ff 75 d4 pushl -0x2c(%ebp)
10ace4: e8 1f 50 00 00 call 10fd08 <_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)
10ace9: 83 c4 20 add $0x20,%esp
10acec: a1 68 68 12 00 mov 0x126868,%eax
10acf1: 83 78 34 04 cmpl $0x4,0x34(%eax)
10acf5: 75 10 jne 10ad07 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10acf7: 8b 1f mov (%edi),%ebx
10acf9: 8d 4b ff lea -0x1(%ebx),%ecx
10acfc: b8 01 00 00 00 mov $0x1,%eax
10ad01: d3 e0 shl %cl,%eax
10ad03: 85 06 test %eax,(%esi)
10ad05: 75 13 jne 10ad1a <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad07: e8 7c 78 00 00 call 112588 <__errno>
10ad0c: 8b 15 68 68 12 00 mov 0x126868,%edx
10ad12: 8b 52 34 mov 0x34(%edx),%edx
10ad15: 89 10 mov %edx,(%eax)
return -1;
10ad17: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad1a: 89 d8 mov %ebx,%eax
10ad1c: 8d 65 f4 lea -0xc(%ebp),%esp
10ad1f: 5b pop %ebx
10ad20: 5e pop %esi
10ad21: 5f pop %edi
10ad22: c9 leave
10ad23: c3 ret
0010ca18 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca18: 55 push %ebp
10ca19: 89 e5 mov %esp,%ebp
10ca1b: 53 push %ebx
10ca1c: 83 ec 08 sub $0x8,%esp
10ca1f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca22: 6a 00 push $0x0
10ca24: 6a 00 push $0x0
10ca26: ff 75 08 pushl 0x8(%ebp)
10ca29: e8 45 fe ff ff call 10c873 <sigtimedwait>
10ca2e: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca30: 83 c4 10 add $0x10,%esp
10ca33: 83 f8 ff cmp $0xffffffff,%eax
10ca36: 74 0a je 10ca42 <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca38: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca3a: 85 db test %ebx,%ebx
10ca3c: 74 0b je 10ca49 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca3e: 89 13 mov %edx,(%ebx)
10ca40: eb 07 jmp 10ca49 <sigwait+0x31>
return 0;
}
return errno;
10ca42: e8 79 73 00 00 call 113dc0 <__errno>
10ca47: 8b 00 mov (%eax),%eax
}
10ca49: 8b 5d fc mov -0x4(%ebp),%ebx
10ca4c: c9 leave
10ca4d: c3 ret
0010a030 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a030: 55 push %ebp
10a031: 89 e5 mov %esp,%ebp
10a033: 56 push %esi
10a034: 53 push %ebx
10a035: 8b 5d 0c mov 0xc(%ebp),%ebx
10a038: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a03b: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a03f: 75 1d jne 10a05e <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a041: 85 f6 test %esi,%esi
10a043: 74 19 je 10a05e <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a045: 85 db test %ebx,%ebx
10a047: 74 22 je 10a06b <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a049: 8b 03 mov (%ebx),%eax
10a04b: 48 dec %eax
10a04c: 83 f8 01 cmp $0x1,%eax
10a04f: 77 0d ja 10a05e <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 )
10a051: 8b 43 04 mov 0x4(%ebx),%eax
10a054: 85 c0 test %eax,%eax
10a056: 74 06 je 10a05e <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a058: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a059: 83 f8 1f cmp $0x1f,%eax
10a05c: 76 0d jbe 10a06b <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a05e: e8 19 7d 00 00 call 111d7c <__errno>
10a063: c7 00 16 00 00 00 movl $0x16,(%eax)
10a069: eb 2f jmp 10a09a <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a06b: a1 34 63 12 00 mov 0x126334,%eax
10a070: 40 inc %eax
10a071: 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 );
10a076: 83 ec 0c sub $0xc,%esp
10a079: 68 38 66 12 00 push $0x126638
10a07e: e8 75 1b 00 00 call 10bbf8 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a083: 83 c4 10 add $0x10,%esp
10a086: 85 c0 test %eax,%eax
10a088: 75 18 jne 10a0a2 <timer_create+0x72>
_Thread_Enable_dispatch();
10a08a: e8 77 29 00 00 call 10ca06 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a08f: e8 e8 7c 00 00 call 111d7c <__errno>
10a094: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a09a: 83 c8 ff or $0xffffffff,%eax
10a09d: e9 83 00 00 00 jmp 10a125 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a0a2: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0a6: 8b 15 7c 68 12 00 mov 0x12687c,%edx
10a0ac: 8b 52 08 mov 0x8(%edx),%edx
10a0af: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a0b2: 85 db test %ebx,%ebx
10a0b4: 74 11 je 10a0c7 <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a0b6: 8b 13 mov (%ebx),%edx
10a0b8: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a0bb: 8b 53 04 mov 0x4(%ebx),%edx
10a0be: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a0c1: 8b 53 08 mov 0x8(%ebx),%edx
10a0c4: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a0c7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a0ce: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a0d5: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a0dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a0e3: 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;
10a0ea: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a0f1: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a0f8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a0ff: 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 ),
10a106: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a109: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a10c: 8b 0d 54 66 12 00 mov 0x126654,%ecx
10a112: 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;
10a115: 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;
10a11c: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a11e: e8 e3 28 00 00 call 10ca06 <_Thread_Enable_dispatch>
return 0;
10a123: 31 c0 xor %eax,%eax
}
10a125: 8d 65 f8 lea -0x8(%ebp),%esp
10a128: 5b pop %ebx
10a129: 5e pop %esi
10a12a: c9 leave
10a12b: c3 ret
0010a12c <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a12c: 55 push %ebp
10a12d: 89 e5 mov %esp,%ebp
10a12f: 57 push %edi
10a130: 56 push %esi
10a131: 53 push %ebx
10a132: 83 ec 2c sub $0x2c,%esp
10a135: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a138: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a13c: 0f 84 58 01 00 00 je 10a29a <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) ) ) {
10a142: 83 ec 0c sub $0xc,%esp
10a145: 8b 45 10 mov 0x10(%ebp),%eax
10a148: 83 c0 08 add $0x8,%eax
10a14b: 50 push %eax
10a14c: e8 13 33 00 00 call 10d464 <_Timespec_Is_valid>
10a151: 83 c4 10 add $0x10,%esp
10a154: 84 c0 test %al,%al
10a156: 0f 84 3e 01 00 00 je 10a29a <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a15c: 83 ec 0c sub $0xc,%esp
10a15f: ff 75 10 pushl 0x10(%ebp)
10a162: e8 fd 32 00 00 call 10d464 <_Timespec_Is_valid>
10a167: 83 c4 10 add $0x10,%esp
10a16a: 84 c0 test %al,%al
10a16c: 0f 84 28 01 00 00 je 10a29a <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a172: 85 db test %ebx,%ebx
10a174: 74 09 je 10a17f <timer_settime+0x53>
10a176: 83 fb 04 cmp $0x4,%ebx
10a179: 0f 85 1b 01 00 00 jne 10a29a <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a17f: 8d 7d cc lea -0x34(%ebp),%edi
10a182: b9 04 00 00 00 mov $0x4,%ecx
10a187: 8b 75 10 mov 0x10(%ebp),%esi
10a18a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a18c: 83 fb 04 cmp $0x4,%ebx
10a18f: 75 2f jne 10a1c0 <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a191: 83 ec 0c sub $0xc,%esp
10a194: 8d 5d dc lea -0x24(%ebp),%ebx
10a197: 53 push %ebx
10a198: e8 b3 15 00 00 call 10b750 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a19d: 59 pop %ecx
10a19e: 5e pop %esi
10a19f: 8d 75 d4 lea -0x2c(%ebp),%esi
10a1a2: 56 push %esi
10a1a3: 53 push %ebx
10a1a4: e8 97 32 00 00 call 10d440 <_Timespec_Greater_than>
10a1a9: 83 c4 10 add $0x10,%esp
10a1ac: 84 c0 test %al,%al
10a1ae: 0f 85 e6 00 00 00 jne 10a29a <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a1b4: 52 push %edx
10a1b5: 56 push %esi
10a1b6: 56 push %esi
10a1b7: 53 push %ebx
10a1b8: e8 cb 32 00 00 call 10d488 <_Timespec_Subtract>
10a1bd: 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 );
10a1c0: 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 );
10a1c1: 8d 45 e4 lea -0x1c(%ebp),%eax
10a1c4: 50 push %eax
10a1c5: ff 75 08 pushl 0x8(%ebp)
10a1c8: 68 38 66 12 00 push $0x126638
10a1cd: e8 56 1e 00 00 call 10c028 <_Objects_Get>
10a1d2: 89 c3 mov %eax,%ebx
switch ( location ) {
10a1d4: 83 c4 10 add $0x10,%esp
10a1d7: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a1db: 0f 85 b9 00 00 00 jne 10a29a <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 ) {
10a1e1: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a1e5: 75 3b jne 10a222 <timer_settime+0xf6>
10a1e7: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a1eb: 75 35 jne 10a222 <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a1ed: 83 ec 0c sub $0xc,%esp
10a1f0: 8d 40 10 lea 0x10(%eax),%eax
10a1f3: 50 push %eax
10a1f4: e8 5b 36 00 00 call 10d854 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a1f9: 83 c4 10 add $0x10,%esp
10a1fc: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a200: 74 0d je 10a20f <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a202: 8d 73 54 lea 0x54(%ebx),%esi
10a205: b9 04 00 00 00 mov $0x4,%ecx
10a20a: 8b 7d 14 mov 0x14(%ebp),%edi
10a20d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a20f: 8d 7b 54 lea 0x54(%ebx),%edi
10a212: 8d 75 cc lea -0x34(%ebp),%esi
10a215: b9 04 00 00 00 mov $0x4,%ecx
10a21a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a21c: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a220: eb 35 jmp 10a257 <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a222: 83 ec 0c sub $0xc,%esp
10a225: ff 75 10 pushl 0x10(%ebp)
10a228: e8 8f 32 00 00 call 10d4bc <_Timespec_To_ticks>
10a22d: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a230: 8d 45 d4 lea -0x2c(%ebp),%eax
10a233: 89 04 24 mov %eax,(%esp)
10a236: e8 81 32 00 00 call 10d4bc <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a23b: 89 1c 24 mov %ebx,(%esp)
10a23e: 68 b0 a2 10 00 push $0x10a2b0
10a243: ff 73 08 pushl 0x8(%ebx)
10a246: 50 push %eax
10a247: 8d 43 10 lea 0x10(%ebx),%eax
10a24a: 50 push %eax
10a24b: e8 40 57 00 00 call 10f990 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a250: 83 c4 20 add $0x20,%esp
10a253: 84 c0 test %al,%al
10a255: 75 07 jne 10a25e <timer_settime+0x132>
_Thread_Enable_dispatch();
10a257: e8 aa 27 00 00 call 10ca06 <_Thread_Enable_dispatch>
10a25c: eb 38 jmp 10a296 <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a25e: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a262: 74 0d je 10a271 <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a264: 8d 73 54 lea 0x54(%ebx),%esi
10a267: b9 04 00 00 00 mov $0x4,%ecx
10a26c: 8b 7d 14 mov 0x14(%ebp),%edi
10a26f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a271: 8d 7b 54 lea 0x54(%ebx),%edi
10a274: 8d 75 cc lea -0x34(%ebp),%esi
10a277: b9 04 00 00 00 mov $0x4,%ecx
10a27c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a27e: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a282: 83 ec 0c sub $0xc,%esp
10a285: 83 c3 6c add $0x6c,%ebx
10a288: 53 push %ebx
10a289: e8 c2 14 00 00 call 10b750 <_TOD_Get>
_Thread_Enable_dispatch();
10a28e: e8 73 27 00 00 call 10ca06 <_Thread_Enable_dispatch>
return 0;
10a293: 83 c4 10 add $0x10,%esp
10a296: 31 c0 xor %eax,%eax
10a298: eb 0e jmp 10a2a8 <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a29a: e8 dd 7a 00 00 call 111d7c <__errno>
10a29f: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2a5: 83 c8 ff or $0xffffffff,%eax
}
10a2a8: 8d 65 f4 lea -0xc(%ebp),%esp
10a2ab: 5b pop %ebx
10a2ac: 5e pop %esi
10a2ad: 5f pop %edi
10a2ae: c9 leave
10a2af: c3 ret
00109f6c <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109f6c: 55 push %ebp
109f6d: 89 e5 mov %esp,%ebp
109f6f: 57 push %edi
109f70: 56 push %esi
109f71: 53 push %ebx
109f72: 83 ec 1c sub $0x1c,%esp
109f75: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109f78: 83 3d 40 6c 12 00 00 cmpl $0x0,0x126c40
109f7f: 75 2c jne 109fad <ualarm+0x41>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109f81: c7 05 2c 6c 12 00 00 movl $0x0,0x126c2c
109f88: 00 00 00
the_watchdog->routine = routine;
109f8b: c7 05 40 6c 12 00 34 movl $0x109f34,0x126c40
109f92: 9f 10 00
the_watchdog->id = id;
109f95: c7 05 44 6c 12 00 00 movl $0x0,0x126c44
109f9c: 00 00 00
the_watchdog->user_data = user_data;
109f9f: c7 05 48 6c 12 00 00 movl $0x0,0x126c48
109fa6: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fa9: 31 db xor %ebx,%ebx
109fab: eb 4f jmp 109ffc <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 );
109fad: 83 ec 0c sub $0xc,%esp
109fb0: 68 24 6c 12 00 push $0x126c24
109fb5: e8 82 34 00 00 call 10d43c <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fba: 83 e8 02 sub $0x2,%eax
109fbd: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fc0: 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) ) {
109fc2: 83 f8 01 cmp $0x1,%eax
109fc5: 77 35 ja 109ffc <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);
109fc7: a1 38 6c 12 00 mov 0x126c38,%eax
109fcc: 03 05 30 6c 12 00 add 0x126c30,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fd2: 57 push %edi
109fd3: 57 push %edi
109fd4: 8d 55 e0 lea -0x20(%ebp),%edx
109fd7: 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);
109fd8: 2b 05 3c 6c 12 00 sub 0x126c3c,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fde: 50 push %eax
109fdf: e8 f8 2f 00 00 call 10cfdc <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
109fe4: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
109feb: 8b 45 e4 mov -0x1c(%ebp),%eax
109fee: bf e8 03 00 00 mov $0x3e8,%edi
109ff3: 99 cltd
109ff4: f7 ff idiv %edi
109ff6: 8d 1c 08 lea (%eax,%ecx,1),%ebx
109ff9: 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 ) {
109ffc: 85 f6 test %esi,%esi
109ffe: 74 44 je 10a044 <ualarm+0xd8>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10a000: b9 40 42 0f 00 mov $0xf4240,%ecx
10a005: 89 f0 mov %esi,%eax
10a007: 31 d2 xor %edx,%edx
10a009: f7 f1 div %ecx
10a00b: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a00e: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a014: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a017: 83 ec 0c sub $0xc,%esp
10a01a: 8d 75 e0 lea -0x20(%ebp),%esi
10a01d: 56 push %esi
10a01e: e8 15 30 00 00 call 10d038 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a023: 89 34 24 mov %esi,(%esp)
10a026: e8 0d 30 00 00 call 10d038 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a02b: a3 30 6c 12 00 mov %eax,0x126c30
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a030: 59 pop %ecx
10a031: 5e pop %esi
10a032: 68 24 6c 12 00 push $0x126c24
10a037: 68 14 64 12 00 push $0x126414
10a03c: e8 db 32 00 00 call 10d31c <_Watchdog_Insert>
10a041: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a044: 89 d8 mov %ebx,%eax
10a046: 8d 65 f4 lea -0xc(%ebp),%esp
10a049: 5b pop %ebx
10a04a: 5e pop %esi
10a04b: 5f pop %edi
10a04c: c9 leave
10a04d: c3 ret