RTEMS 4.11Annotated Report
Mon Nov 1 14:21:15 2010
0010cdfc <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10cdfc: 55 push %ebp
10cdfd: 89 e5 mov %esp,%ebp
10cdff: 53 push %ebx
10ce00: 83 ec 04 sub $0x4,%esp
10ce03: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce06: 8b 15 44 88 12 00 mov 0x128844,%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 );
10ce0c: 9c pushf
10ce0d: fa cli
10ce0e: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce0f: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce12: 85 c9 test %ecx,%ecx
10ce14: 75 0b jne 10ce21 <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce16: 50 push %eax
10ce17: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce18: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce1f: eb 72 jmp 10ce93 <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce21: 49 dec %ecx
10ce22: 75 0f jne 10ce33 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce24: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce27: 49 dec %ecx
10ce28: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce2b: 85 c9 test %ecx,%ecx
10ce2d: 74 04 je 10ce33 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce2f: 50 push %eax
10ce30: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce31: eb 60 jmp 10ce93 <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce33: 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;
10ce3a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10ce41: 50 push %eax
10ce42: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10ce43: 83 ec 0c sub $0xc,%esp
10ce46: 53 push %ebx
10ce47: e8 68 15 00 00 call 10e3b4 <_Thread_queue_Dequeue>
if ( next ) {
10ce4c: 83 c4 10 add $0x10,%esp
10ce4f: 85 c0 test %eax,%eax
10ce51: 74 40 je 10ce93 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ce53: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce57: 75 09 jne 10ce62 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10ce59: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10ce60: eb 31 jmp 10ce93 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10ce62: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10ce65: 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 );
10ce6c: 83 ec 0c sub $0xc,%esp
10ce6f: 53 push %ebx
10ce70: e8 2b 19 00 00 call 10e7a0 <_Thread_queue_First>
if ( !next ||
10ce75: 83 c4 10 add $0x10,%esp
10ce78: 85 c0 test %eax,%eax
10ce7a: 74 17 je 10ce93 <_CORE_RWLock_Release+0x97>
10ce7c: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce80: 74 11 je 10ce93 <_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;
10ce82: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10ce85: 52 push %edx
10ce86: 52 push %edx
10ce87: 50 push %eax
10ce88: 53 push %ebx
10ce89: e8 06 18 00 00 call 10e694 <_Thread_queue_Extract>
}
10ce8e: 83 c4 10 add $0x10,%esp
10ce91: eb d9 jmp 10ce6c <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10ce93: 31 c0 xor %eax,%eax
10ce95: 8b 5d fc mov -0x4(%ebp),%ebx
10ce98: c9 leave
10ce99: c3 ret
0010ce9c <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10ce9c: 55 push %ebp
10ce9d: 89 e5 mov %esp,%ebp
10ce9f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cea2: 8d 45 f4 lea -0xc(%ebp),%eax
10cea5: 50 push %eax
10cea6: ff 75 08 pushl 0x8(%ebp)
10cea9: e8 aa 11 00 00 call 10e058 <_Thread_Get>
switch ( location ) {
10ceae: 83 c4 10 add $0x10,%esp
10ceb1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10ceb5: 75 17 jne 10cece <_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 );
10ceb7: 83 ec 0c sub $0xc,%esp
10ceba: 50 push %eax
10cebb: e8 ac 19 00 00 call 10e86c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10cec0: a1 f4 82 12 00 mov 0x1282f4,%eax
10cec5: 48 dec %eax
10cec6: a3 f4 82 12 00 mov %eax,0x1282f4
10cecb: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cece: c9 leave
10cecf: c3 ret
00117364 <_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
)
{
117364: 55 push %ebp
117365: 89 e5 mov %esp,%ebp
117367: 57 push %edi
117368: 56 push %esi
117369: 53 push %ebx
11736a: 83 ec 1c sub $0x1c,%esp
11736d: 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;
117370: 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 ) {
117375: 8b 55 10 mov 0x10(%ebp),%edx
117378: 3b 53 4c cmp 0x4c(%ebx),%edx
11737b: 77 4e ja 1173cb <_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 ) {
11737d: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
117381: 75 09 jne 11738c <_CORE_message_queue_Broadcast+0x28>
117383: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
11738a: eb 23 jmp 1173af <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
11738c: 8b 45 1c mov 0x1c(%ebp),%eax
11738f: c7 00 00 00 00 00 movl $0x0,(%eax)
117395: eb 32 jmp 1173c9 <_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;
117397: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11739a: 8b 42 2c mov 0x2c(%edx),%eax
11739d: 89 c7 mov %eax,%edi
11739f: 8b 75 0c mov 0xc(%ebp),%esi
1173a2: 8b 4d 10 mov 0x10(%ebp),%ecx
1173a5: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
1173a7: 8b 42 28 mov 0x28(%edx),%eax
1173aa: 8b 55 10 mov 0x10(%ebp),%edx
1173ad: 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 =
1173af: 83 ec 0c sub $0xc,%esp
1173b2: 53 push %ebx
1173b3: e8 9c 22 00 00 call 119654 <_Thread_queue_Dequeue>
1173b8: 89 c2 mov %eax,%edx
1173ba: 83 c4 10 add $0x10,%esp
1173bd: 85 c0 test %eax,%eax
1173bf: 75 d6 jne 117397 <_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;
1173c1: 8b 55 e4 mov -0x1c(%ebp),%edx
1173c4: 8b 45 1c mov 0x1c(%ebp),%eax
1173c7: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1173c9: 31 c0 xor %eax,%eax
}
1173cb: 8d 65 f4 lea -0xc(%ebp),%esp
1173ce: 5b pop %ebx
1173cf: 5e pop %esi
1173d0: 5f pop %edi
1173d1: c9 leave
1173d2: c3 ret
00112218 <_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
)
{
112218: 55 push %ebp
112219: 89 e5 mov %esp,%ebp
11221b: 57 push %edi
11221c: 56 push %esi
11221d: 53 push %ebx
11221e: 83 ec 1c sub $0x1c,%esp
112221: 8b 5d 08 mov 0x8(%ebp),%ebx
112224: 8b 7d 10 mov 0x10(%ebp),%edi
112227: 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;
11222a: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
11222d: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112234: 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;
112237: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
11223e: 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)) {
112245: 89 d0 mov %edx,%eax
112247: f6 c2 03 test $0x3,%dl
11224a: 74 0c je 112258 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
11224c: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
11224f: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
112252: 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)
112254: 39 d0 cmp %edx,%eax
112256: 72 68 jb 1122c0 <_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));
112258: 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 *
11225b: 89 d1 mov %edx,%ecx
11225d: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
112260: 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)
112262: 39 c1 cmp %eax,%ecx
112264: 72 5a jb 1122c0 <_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 );
112266: 83 ec 0c sub $0xc,%esp
112269: 51 push %ecx
11226a: 89 55 e4 mov %edx,-0x1c(%ebp)
11226d: e8 a0 26 00 00 call 114912 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
112272: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
112275: 83 c4 10 add $0x10,%esp
112278: 85 c0 test %eax,%eax
11227a: 8b 55 e4 mov -0x1c(%ebp),%edx
11227d: 74 41 je 1122c0 <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
11227f: 52 push %edx
112280: 57 push %edi
112281: 50 push %eax
112282: 8d 43 68 lea 0x68(%ebx),%eax
112285: 50 push %eax
112286: e8 e1 49 00 00 call 116c6c <_Chain_Initialize>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
11228b: 8d 43 54 lea 0x54(%ebx),%eax
11228e: 89 43 50 mov %eax,0x50(%ebx)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
112291: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
the_message_queue->message_buffers,
(size_t) maximum_pending_messages,
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
112298: 8d 43 50 lea 0x50(%ebx),%eax
11229b: 89 43 58 mov %eax,0x58(%ebx)
_Thread_queue_Initialize(
11229e: 6a 06 push $0x6
1122a0: 68 80 00 00 00 push $0x80
1122a5: 8b 45 0c mov 0xc(%ebp),%eax
1122a8: 83 38 01 cmpl $0x1,(%eax)
1122ab: 0f 94 c0 sete %al
1122ae: 0f b6 c0 movzbl %al,%eax
1122b1: 50 push %eax
1122b2: 53 push %ebx
1122b3: e8 04 1d 00 00 call 113fbc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
1122b8: 83 c4 20 add $0x20,%esp
1122bb: be 01 00 00 00 mov $0x1,%esi
}
1122c0: 89 f0 mov %esi,%eax
1122c2: 8d 65 f4 lea -0xc(%ebp),%esp
1122c5: 5b pop %ebx
1122c6: 5e pop %esi
1122c7: 5f pop %edi
1122c8: c9 leave
1122c9: c3 ret
001122cc <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
1122cc: 55 push %ebp
1122cd: 89 e5 mov %esp,%ebp
1122cf: 57 push %edi
1122d0: 56 push %esi
1122d1: 53 push %ebx
1122d2: 83 ec 2c sub $0x2c,%esp
1122d5: 8b 55 08 mov 0x8(%ebp),%edx
1122d8: 8b 45 0c mov 0xc(%ebp),%eax
1122db: 89 45 dc mov %eax,-0x24(%ebp)
1122de: 8b 5d 10 mov 0x10(%ebp),%ebx
1122e1: 89 5d e0 mov %ebx,-0x20(%ebp)
1122e4: 8b 4d 14 mov 0x14(%ebp),%ecx
1122e7: 8b 75 1c mov 0x1c(%ebp),%esi
1122ea: 89 75 d4 mov %esi,-0x2c(%ebp)
1122ed: 8a 45 18 mov 0x18(%ebp),%al
1122f0: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
1122f3: a1 9c c9 12 00 mov 0x12c99c,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1122f8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
1122ff: 9c pushf
112300: fa cli
112301: 8f 45 e4 popl -0x1c(%ebp)
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
112304: 8b 5a 50 mov 0x50(%edx),%ebx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
112307: 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))
11230a: 39 f3 cmp %esi,%ebx
11230c: 0f 84 8a 00 00 00 je 11239c <_CORE_message_queue_Seize+0xd0>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
112312: 8b 33 mov (%ebx),%esi
the_chain->first = new_first;
112314: 89 72 50 mov %esi,0x50(%edx)
CORE_message_queue_Buffer_control *_CORE_message_queue_Get_pending_message (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get_unprotected( &the_message_queue->Pending_messages );
112317: 8d 7a 50 lea 0x50(%edx),%edi
11231a: 89 7e 04 mov %edi,0x4(%esi)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
11231d: 85 db test %ebx,%ebx
11231f: 74 7b je 11239c <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
112321: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
112324: ff 75 e4 pushl -0x1c(%ebp)
112327: 9d popf
*size_p = the_message->Contents.size;
112328: 8b 43 0c mov 0xc(%ebx),%eax
11232b: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
11232d: 8b 73 08 mov 0x8(%ebx),%esi
112330: a1 9c c9 12 00 mov 0x12c99c,%eax
112335: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112338: 8d 73 10 lea 0x10(%ebx),%esi
11233b: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11233e: 8b 09 mov (%ecx),%ecx
112340: 8b 7d e0 mov -0x20(%ebp),%edi
112343: 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 );
112345: 83 ec 0c sub $0xc,%esp
112348: 52 push %edx
112349: 89 55 d0 mov %edx,-0x30(%ebp)
11234c: e8 3b 19 00 00 call 113c8c <_Thread_queue_Dequeue>
if ( !the_thread ) {
112351: 83 c4 10 add $0x10,%esp
112354: 85 c0 test %eax,%eax
112356: 8b 55 d0 mov -0x30(%ebp),%edx
112359: 75 15 jne 112370 <_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 );
11235b: 89 5d 0c mov %ebx,0xc(%ebp)
11235e: 83 c2 68 add $0x68,%edx
112361: 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 );
}
112364: 8d 65 f4 lea -0xc(%ebp),%esp
112367: 5b pop %ebx
112368: 5e pop %esi
112369: 5f pop %edi
11236a: c9 leave
11236b: e9 28 fe ff ff jmp 112198 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
112370: 8b 48 24 mov 0x24(%eax),%ecx
112373: 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;
112376: 8b 48 30 mov 0x30(%eax),%ecx
112379: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
11237c: 8b 70 2c mov 0x2c(%eax),%esi
11237f: 8b 7d e4 mov -0x1c(%ebp),%edi
112382: 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(
112384: 8b 43 08 mov 0x8(%ebx),%eax
112387: 89 45 10 mov %eax,0x10(%ebp)
11238a: 89 5d 0c mov %ebx,0xc(%ebp)
11238d: 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 );
}
112390: 8d 65 f4 lea -0xc(%ebp),%esp
112393: 5b pop %ebx
112394: 5e pop %esi
112395: 5f pop %edi
112396: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
112397: e9 08 49 00 00 jmp 116ca4 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
11239c: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
1123a0: 75 13 jne 1123b5 <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
1123a2: ff 75 e4 pushl -0x1c(%ebp)
1123a5: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
1123a6: 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 );
}
1123ad: 8d 65 f4 lea -0xc(%ebp),%esp
1123b0: 5b pop %ebx
1123b1: 5e pop %esi
1123b2: 5f pop %edi
1123b3: c9 leave
1123b4: 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;
1123b5: 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;
1123bc: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
1123bf: 8b 5d dc mov -0x24(%ebp),%ebx
1123c2: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
1123c5: 8b 75 e0 mov -0x20(%ebp),%esi
1123c8: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
1123cb: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
1123ce: ff 75 e4 pushl -0x1c(%ebp)
1123d1: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
1123d2: c7 45 10 6c 40 11 00 movl $0x11406c,0x10(%ebp)
1123d9: 8b 45 d4 mov -0x2c(%ebp),%eax
1123dc: 89 45 0c mov %eax,0xc(%ebp)
1123df: 89 55 08 mov %edx,0x8(%ebp)
}
1123e2: 8d 65 f4 lea -0xc(%ebp),%esp
1123e5: 5b pop %ebx
1123e6: 5e pop %esi
1123e7: 5f pop %edi
1123e8: 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 );
1123e9: e9 a6 19 00 00 jmp 113d94 <_Thread_queue_Enqueue_with_handler>
0010ac1d <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac1d: 55 push %ebp
10ac1e: 89 e5 mov %esp,%ebp
10ac20: 53 push %ebx
10ac21: 83 ec 14 sub $0x14,%esp
10ac24: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac27: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac2a: a1 e4 42 12 00 mov 0x1242e4,%eax
10ac2f: 85 c0 test %eax,%eax
10ac31: 74 19 je 10ac4c <_CORE_mutex_Seize+0x2f>
10ac33: 84 d2 test %dl,%dl
10ac35: 74 15 je 10ac4c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac37: 83 3d 64 44 12 00 01 cmpl $0x1,0x124464
10ac3e: 76 0c jbe 10ac4c <_CORE_mutex_Seize+0x2f>
10ac40: 53 push %ebx
10ac41: 6a 12 push $0x12
10ac43: 6a 00 push $0x0
10ac45: 6a 00 push $0x0
10ac47: e8 e4 05 00 00 call 10b230 <_Internal_error_Occurred>
10ac4c: 51 push %ecx
10ac4d: 51 push %ecx
10ac4e: 8d 45 18 lea 0x18(%ebp),%eax
10ac51: 50 push %eax
10ac52: 53 push %ebx
10ac53: 88 55 f4 mov %dl,-0xc(%ebp)
10ac56: e8 b9 46 00 00 call 10f314 <_CORE_mutex_Seize_interrupt_trylock>
10ac5b: 83 c4 10 add $0x10,%esp
10ac5e: 85 c0 test %eax,%eax
10ac60: 8a 55 f4 mov -0xc(%ebp),%dl
10ac63: 74 48 je 10acad <_CORE_mutex_Seize+0x90>
10ac65: 84 d2 test %dl,%dl
10ac67: 75 12 jne 10ac7b <_CORE_mutex_Seize+0x5e>
10ac69: ff 75 18 pushl 0x18(%ebp)
10ac6c: 9d popf
10ac6d: a1 34 48 12 00 mov 0x124834,%eax
10ac72: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10ac79: eb 32 jmp 10acad <_CORE_mutex_Seize+0x90>
10ac7b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ac82: a1 34 48 12 00 mov 0x124834,%eax
10ac87: 89 58 44 mov %ebx,0x44(%eax)
10ac8a: 8b 55 0c mov 0xc(%ebp),%edx
10ac8d: 89 50 20 mov %edx,0x20(%eax)
10ac90: a1 e4 42 12 00 mov 0x1242e4,%eax
10ac95: 40 inc %eax
10ac96: a3 e4 42 12 00 mov %eax,0x1242e4
10ac9b: ff 75 18 pushl 0x18(%ebp)
10ac9e: 9d popf
10ac9f: 50 push %eax
10aca0: 50 push %eax
10aca1: ff 75 14 pushl 0x14(%ebp)
10aca4: 53 push %ebx
10aca5: e8 26 ff ff ff call 10abd0 <_CORE_mutex_Seize_interrupt_blocking>
10acaa: 83 c4 10 add $0x10,%esp
}
10acad: 8b 5d fc mov -0x4(%ebp),%ebx
10acb0: c9 leave
10acb1: c3 ret
0010add8 <_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
)
{
10add8: 55 push %ebp
10add9: 89 e5 mov %esp,%ebp
10addb: 53 push %ebx
10addc: 83 ec 10 sub $0x10,%esp
10addf: 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)) ) {
10ade2: 53 push %ebx
10ade3: e8 64 14 00 00 call 10c24c <_Thread_queue_Dequeue>
10ade8: 89 c2 mov %eax,%edx
10adea: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10aded: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10adef: 85 d2 test %edx,%edx
10adf1: 75 15 jne 10ae08 <_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 );
10adf3: 9c pushf
10adf4: fa cli
10adf5: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10adf6: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10adf9: 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 )
10adfb: 3b 53 40 cmp 0x40(%ebx),%edx
10adfe: 73 06 jae 10ae06 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae00: 42 inc %edx
10ae01: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae04: 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 );
10ae06: 51 push %ecx
10ae07: 9d popf
}
return status;
}
10ae08: 8b 5d fc mov -0x4(%ebp),%ebx
10ae0b: c9 leave
10ae0c: c3 ret
00109d48 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109d48: 55 push %ebp
109d49: 89 e5 mov %esp,%ebp
109d4b: 57 push %edi
109d4c: 56 push %esi
109d4d: 53 push %ebx
109d4e: 83 ec 2c sub $0x2c,%esp
109d51: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
109d54: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109d5a: 8b 43 30 mov 0x30(%ebx),%eax
109d5d: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109d60: 9c pushf
109d61: fa cli
109d62: 58 pop %eax
pending_events = api->pending_events;
109d63: 8b 17 mov (%edi),%edx
109d65: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109d68: 8b 73 24 mov 0x24(%ebx),%esi
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
109d6b: 21 f2 and %esi,%edx
109d6d: 75 07 jne 109d76 <_Event_Surrender+0x2e>
_ISR_Enable( level );
109d6f: 50 push %eax
109d70: 9d popf
return;
109d71: e9 af 00 00 00 jmp 109e25 <_Event_Surrender+0xdd>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
109d76: 83 3d 30 48 12 00 00 cmpl $0x0,0x124830
109d7d: 74 49 je 109dc8 <_Event_Surrender+0x80>
109d7f: 3b 1d 34 48 12 00 cmp 0x124834,%ebx
109d85: 75 41 jne 109dc8 <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d87: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
109d8d: 83 f9 02 cmp $0x2,%ecx
109d90: 74 09 je 109d9b <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109d92: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d98: 49 dec %ecx
109d99: 75 2d jne 109dc8 <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109d9b: 39 f2 cmp %esi,%edx
109d9d: 74 06 je 109da5 <_Event_Surrender+0x5d>
109d9f: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109da3: 74 1f je 109dc4 <_Event_Surrender+0x7c> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
109da5: 89 d6 mov %edx,%esi
109da7: f7 d6 not %esi
109da9: 23 75 d4 and -0x2c(%ebp),%esi
109dac: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109dae: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109db5: 8b 4b 28 mov 0x28(%ebx),%ecx
109db8: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109dba: c7 05 e4 4b 12 00 03 movl $0x3,0x124be4
109dc1: 00 00 00
}
_ISR_Enable( level );
109dc4: 50 push %eax
109dc5: 9d popf
return;
109dc6: eb 5d jmp 109e25 <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109dc8: f6 43 11 01 testb $0x1,0x11(%ebx)
109dcc: 74 55 je 109e23 <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109dce: 39 f2 cmp %esi,%edx
109dd0: 74 06 je 109dd8 <_Event_Surrender+0x90>
109dd2: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dd6: 74 4b je 109e23 <_Event_Surrender+0xdb> <== NEVER TAKEN
109dd8: 89 d6 mov %edx,%esi
109dda: f7 d6 not %esi
109ddc: 23 75 d4 and -0x2c(%ebp),%esi
109ddf: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109de1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109de8: 8b 4b 28 mov 0x28(%ebx),%ecx
109deb: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109ded: 50 push %eax
109dee: 9d popf
109def: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109df0: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109df4: 74 06 je 109dfc <_Event_Surrender+0xb4>
_ISR_Enable( level );
109df6: 50 push %eax
109df7: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109df8: 51 push %ecx
109df9: 51 push %ecx
109dfa: eb 17 jmp 109e13 <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109dfc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e03: 50 push %eax
109e04: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e05: 83 ec 0c sub $0xc,%esp
109e08: 8d 43 48 lea 0x48(%ebx),%eax
109e0b: 50 push %eax
109e0c: e8 a7 2f 00 00 call 10cdb8 <_Watchdog_Remove>
109e11: 58 pop %eax
109e12: 5a pop %edx
109e13: 68 f8 ff 03 10 push $0x1003fff8
109e18: 53 push %ebx
109e19: e8 3e 1d 00 00 call 10bb5c <_Thread_Clear_state>
109e1e: 83 c4 10 add $0x10,%esp
109e21: eb 02 jmp 109e25 <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e23: 50 push %eax
109e24: 9d popf
}
109e25: 8d 65 f4 lea -0xc(%ebp),%esp
109e28: 5b pop %ebx
109e29: 5e pop %esi
109e2a: 5f pop %edi
109e2b: c9 leave
109e2c: c3 ret
00109e30 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e30: 55 push %ebp
109e31: 89 e5 mov %esp,%ebp
109e33: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e36: 8d 45 f4 lea -0xc(%ebp),%eax
109e39: 50 push %eax
109e3a: ff 75 08 pushl 0x8(%ebp)
109e3d: e8 ae 20 00 00 call 10bef0 <_Thread_Get>
switch ( location ) {
109e42: 83 c4 10 add $0x10,%esp
109e45: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109e49: 75 49 jne 109e94 <_Event_Timeout+0x64> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
109e4b: 9c pushf
109e4c: fa cli
109e4d: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109e4e: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109e55: 3b 05 34 48 12 00 cmp 0x124834,%eax
109e5b: 75 13 jne 109e70 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109e5d: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx
109e63: 49 dec %ecx
109e64: 75 0a jne 109e70 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109e66: c7 05 e4 4b 12 00 02 movl $0x2,0x124be4
109e6d: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109e70: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109e77: 52 push %edx
109e78: 9d popf
109e79: 52 push %edx
109e7a: 52 push %edx
109e7b: 68 f8 ff 03 10 push $0x1003fff8
109e80: 50 push %eax
109e81: e8 d6 1c 00 00 call 10bb5c <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109e86: a1 e4 42 12 00 mov 0x1242e4,%eax
109e8b: 48 dec %eax
109e8c: a3 e4 42 12 00 mov %eax,0x1242e4
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109e91: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109e94: c9 leave
109e95: c3 ret
0010f973 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10f973: 55 push %ebp
10f974: 89 e5 mov %esp,%ebp
10f976: 57 push %edi
10f977: 56 push %esi
10f978: 53 push %ebx
10f979: 83 ec 4c sub $0x4c,%esp
10f97c: 8b 5d 08 mov 0x8(%ebp),%ebx
10f97f: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10f982: 8b 43 20 mov 0x20(%ebx),%eax
10f985: 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;
10f988: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10f98f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10f996: 8b 53 10 mov 0x10(%ebx),%edx
10f999: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10f99c: 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;
10f99f: 8b 7b 30 mov 0x30(%ebx),%edi
10f9a2: 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;
10f9a5: 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 ) {
10f9a7: 8b 7d 0c mov 0xc(%ebp),%edi
10f9aa: 01 cf add %ecx,%edi
10f9ac: 0f 82 d4 01 00 00 jb 10fb86 <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10f9b2: 52 push %edx
10f9b3: 52 push %edx
10f9b4: 8d 55 e0 lea -0x20(%ebp),%edx
10f9b7: 52 push %edx
10f9b8: 8d 55 e4 lea -0x1c(%ebp),%edx
10f9bb: 52 push %edx
10f9bc: 50 push %eax
10f9bd: ff 75 c4 pushl -0x3c(%ebp)
10f9c0: 51 push %ecx
10f9c1: ff 75 0c pushl 0xc(%ebp)
10f9c4: e8 8a b9 ff ff call 10b353 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10f9c9: 83 c4 20 add $0x20,%esp
10f9cc: 84 c0 test %al,%al
10f9ce: 0f 84 b2 01 00 00 je 10fb86 <_Heap_Extend+0x213>
10f9d4: 8b 4d c0 mov -0x40(%ebp),%ecx
10f9d7: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10f9de: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10f9e5: 31 f6 xor %esi,%esi
10f9e7: 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;
10f9ee: 8b 43 18 mov 0x18(%ebx),%eax
10f9f1: 89 5d b8 mov %ebx,-0x48(%ebp)
10f9f4: eb 02 jmp 10f9f8 <_Heap_Extend+0x85>
10f9f6: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10f9f8: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10f9fa: 39 c7 cmp %eax,%edi
10f9fc: 76 09 jbe 10fa07 <_Heap_Extend+0x94>
10f9fe: 39 5d 0c cmp %ebx,0xc(%ebp)
10fa01: 0f 82 7d 01 00 00 jb 10fb84 <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fa07: 39 c7 cmp %eax,%edi
10fa09: 74 06 je 10fa11 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fa0b: 39 df cmp %ebx,%edi
10fa0d: 72 07 jb 10fa16 <_Heap_Extend+0xa3>
10fa0f: eb 08 jmp 10fa19 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fa11: 89 4d d0 mov %ecx,-0x30(%ebp)
10fa14: eb 03 jmp 10fa19 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fa16: 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);
10fa19: 8d 43 f8 lea -0x8(%ebx),%eax
10fa1c: 89 45 d4 mov %eax,-0x2c(%ebp)
10fa1f: 89 d8 mov %ebx,%eax
10fa21: 31 d2 xor %edx,%edx
10fa23: 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);
10fa26: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fa29: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fa2c: 75 07 jne 10fa35 <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fa2e: 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 )
10fa30: 8b 75 d4 mov -0x2c(%ebp),%esi
10fa33: eb 08 jmp 10fa3d <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fa35: 73 06 jae 10fa3d <_Heap_Extend+0xca>
10fa37: 8b 55 d4 mov -0x2c(%ebp),%edx
10fa3a: 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;
10fa3d: 8b 45 d4 mov -0x2c(%ebp),%eax
10fa40: 8b 48 04 mov 0x4(%eax),%ecx
10fa43: 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);
10fa46: 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 );
10fa48: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fa4b: 75 a9 jne 10f9f6 <_Heap_Extend+0x83>
10fa4d: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fa50: 8b 55 0c mov 0xc(%ebp),%edx
10fa53: 3b 53 18 cmp 0x18(%ebx),%edx
10fa56: 73 05 jae 10fa5d <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fa58: 89 53 18 mov %edx,0x18(%ebx)
10fa5b: eb 08 jmp 10fa65 <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fa5d: 39 7b 1c cmp %edi,0x1c(%ebx)
10fa60: 73 03 jae 10fa65 <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fa62: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fa65: 8b 45 e0 mov -0x20(%ebp),%eax
10fa68: 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 =
10fa6b: 89 c1 mov %eax,%ecx
10fa6d: 29 d1 sub %edx,%ecx
10fa6f: 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;
10fa72: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fa74: 83 c9 01 or $0x1,%ecx
10fa77: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fa7a: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fa7d: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fa7f: 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 ) {
10fa86: 39 53 20 cmp %edx,0x20(%ebx)
10fa89: 76 05 jbe 10fa90 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fa8b: 89 53 20 mov %edx,0x20(%ebx)
10fa8e: eb 08 jmp 10fa98 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fa90: 39 43 24 cmp %eax,0x24(%ebx)
10fa93: 73 03 jae 10fa98 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fa95: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fa98: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fa9c: 74 3b je 10fad9 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fa9e: 8b 43 10 mov 0x10(%ebx),%eax
10faa1: 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 );
10faa4: 8b 4d 0c mov 0xc(%ebp),%ecx
10faa7: 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;
10faaa: 89 c8 mov %ecx,%eax
10faac: 31 d2 xor %edx,%edx
10faae: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fab1: 85 d2 test %edx,%edx
10fab3: 74 05 je 10faba <_Heap_Extend+0x147> <== ALWAYS TAKEN
return value - remainder + alignment;
10fab5: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED
10fab8: 29 d1 sub %edx,%ecx <== NOT EXECUTED
uintptr_t const new_first_block_begin =
10faba: 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;
10fabd: 8b 45 d0 mov -0x30(%ebp),%eax
10fac0: 8b 00 mov (%eax),%eax
10fac2: 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 =
10fac5: 8b 45 d0 mov -0x30(%ebp),%eax
10fac8: 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;
10faca: 83 c8 01 or $0x1,%eax
10facd: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fad0: 89 d8 mov %ebx,%eax
10fad2: e8 81 fe ff ff call 10f958 <_Heap_Free_block>
10fad7: eb 14 jmp 10faed <_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 ) {
10fad9: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fadd: 74 0e je 10faed <_Heap_Extend+0x17a>
_Heap_Link_below(
10fadf: 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;
10fae2: 8b 45 c8 mov -0x38(%ebp),%eax
10fae5: 29 d0 sub %edx,%eax
10fae7: 83 c8 01 or $0x1,%eax
10faea: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10faed: 85 f6 test %esi,%esi
10faef: 74 30 je 10fb21 <_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,
10faf1: 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(
10faf4: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10faf6: 89 f8 mov %edi,%eax
10faf8: 31 d2 xor %edx,%edx
10fafa: f7 73 10 divl 0x10(%ebx)
10fafd: 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)
10faff: 8b 46 04 mov 0x4(%esi),%eax
10fb02: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fb04: 83 c8 01 or $0x1,%eax
10fb07: 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;
10fb0b: 8b 46 04 mov 0x4(%esi),%eax
10fb0e: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fb11: 09 f8 or %edi,%eax
10fb13: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fb16: 89 f2 mov %esi,%edx
10fb18: 89 d8 mov %ebx,%eax
10fb1a: e8 39 fe ff ff call 10f958 <_Heap_Free_block>
10fb1f: eb 21 jmp 10fb42 <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fb21: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fb25: 74 1b je 10fb42 <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fb27: 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 );
10fb2a: 8b 45 e4 mov -0x1c(%ebp),%eax
10fb2d: 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;
10fb30: 8b 7d cc mov -0x34(%ebp),%edi
10fb33: 8b 57 04 mov 0x4(%edi),%edx
10fb36: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fb39: 09 d0 or %edx,%eax
10fb3b: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fb3e: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fb42: 85 f6 test %esi,%esi
10fb44: 75 10 jne 10fb56 <_Heap_Extend+0x1e3>
10fb46: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fb4a: 75 0a jne 10fb56 <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fb4c: 8b 55 e4 mov -0x1c(%ebp),%edx
10fb4f: 89 d8 mov %ebx,%eax
10fb51: e8 02 fe ff ff call 10f958 <_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
10fb56: 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(
10fb59: 8b 43 20 mov 0x20(%ebx),%eax
10fb5c: 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;
10fb5e: 8b 4a 04 mov 0x4(%edx),%ecx
10fb61: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fb64: 09 c8 or %ecx,%eax
10fb66: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fb69: 8b 43 30 mov 0x30(%ebx),%eax
10fb6c: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fb6f: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fb72: 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 )
10fb77: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fb7b: 74 09 je 10fb86 <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fb7d: 8b 55 14 mov 0x14(%ebp),%edx
10fb80: 89 02 mov %eax,(%edx)
10fb82: eb 02 jmp 10fb86 <_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;
10fb84: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fb86: 89 f0 mov %esi,%eax
10fb88: 8d 65 f4 lea -0xc(%ebp),%esp
10fb8b: 5b pop %ebx
10fb8c: 5e pop %esi
10fb8d: 5f pop %edi
10fb8e: c9 leave
10fb8f: c3 ret
0010f5b8 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f5b8: 55 push %ebp
10f5b9: 89 e5 mov %esp,%ebp
10f5bb: 57 push %edi
10f5bc: 56 push %esi
10f5bd: 53 push %ebx
10f5be: 83 ec 14 sub $0x14,%esp
10f5c1: 8b 4d 08 mov 0x8(%ebp),%ecx
10f5c4: 8b 45 0c mov 0xc(%ebp),%eax
10f5c7: 8d 58 f8 lea -0x8(%eax),%ebx
10f5ca: 31 d2 xor %edx,%edx
10f5cc: 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);
10f5cf: 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
10f5d1: 8b 41 20 mov 0x20(%ecx),%eax
10f5d4: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f5d7: 31 d2 xor %edx,%edx
10f5d9: 39 c3 cmp %eax,%ebx
10f5db: 72 08 jb 10f5e5 <_Heap_Free+0x2d>
10f5dd: 31 d2 xor %edx,%edx
10f5df: 39 59 24 cmp %ebx,0x24(%ecx)
10f5e2: 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;
10f5e5: 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 ) ) {
10f5e7: 85 d2 test %edx,%edx
10f5e9: 0f 84 21 01 00 00 je 10f710 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f5ef: 8b 43 04 mov 0x4(%ebx),%eax
10f5f2: 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;
10f5f5: 89 c6 mov %eax,%esi
10f5f7: 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);
10f5fa: 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;
10f5fd: 31 ff xor %edi,%edi
10f5ff: 3b 55 ec cmp -0x14(%ebp),%edx
10f602: 72 0a jb 10f60e <_Heap_Free+0x56> <== NEVER TAKEN
10f604: 31 c0 xor %eax,%eax
10f606: 39 51 24 cmp %edx,0x24(%ecx)
10f609: 0f 93 c0 setae %al
10f60c: 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;
10f60e: 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 ) ) {
10f610: 85 ff test %edi,%edi
10f612: 0f 84 f8 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f618: 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 ) ) {
10f61b: f7 c7 01 00 00 00 test $0x1,%edi
10f621: 0f 84 e9 00 00 00 je 10f710 <_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;
10f627: 83 e7 fe and $0xfffffffe,%edi
10f62a: 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
10f62d: 8b 41 24 mov 0x24(%ecx),%eax
10f630: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f633: 31 c0 xor %eax,%eax
10f635: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f638: 74 0a je 10f644 <_Heap_Free+0x8c>
10f63a: 31 c0 xor %eax,%eax
10f63c: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f641: 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
10f644: 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 ) ) {
10f647: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f64b: 75 62 jne 10f6af <_Heap_Free+0xf7>
uintptr_t const prev_size = block->prev_size;
10f64d: 8b 03 mov (%ebx),%eax
10f64f: 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);
10f652: 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;
10f654: 31 ff xor %edi,%edi
10f656: 3b 5d ec cmp -0x14(%ebp),%ebx
10f659: 72 0a jb 10f665 <_Heap_Free+0xad> <== NEVER TAKEN
10f65b: 31 c0 xor %eax,%eax
10f65d: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f660: 0f 93 c0 setae %al
10f663: 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 );
10f665: 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 ) ) {
10f667: 85 ff test %edi,%edi
10f669: 0f 84 a1 00 00 00 je 10f710 <_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) ) {
10f66f: f6 43 04 01 testb $0x1,0x4(%ebx)
10f673: 0f 84 97 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f679: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f67d: 74 1a je 10f699 <_Heap_Free+0xe1>
uintptr_t const size = block_size + prev_size + next_block_size;
10f67f: 8b 45 e8 mov -0x18(%ebp),%eax
10f682: 8d 04 06 lea (%esi,%eax,1),%eax
10f685: 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;
10f688: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f68b: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f68e: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f691: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f694: ff 49 38 decl 0x38(%ecx)
10f697: eb 33 jmp 10f6cc <_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;
10f699: 8b 45 f0 mov -0x10(%ebp),%eax
10f69c: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f69f: 89 c7 mov %eax,%edi
10f6a1: 83 cf 01 or $0x1,%edi
10f6a4: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f6a7: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f6ab: 89 02 mov %eax,(%edx)
10f6ad: eb 56 jmp 10f705 <_Heap_Free+0x14d>
}
} else if ( next_is_free ) { /* coalesce next */
10f6af: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f6b3: 74 24 je 10f6d9 <_Heap_Free+0x121>
uintptr_t const size = block_size + next_block_size;
10f6b5: 8b 45 e8 mov -0x18(%ebp),%eax
10f6b8: 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;
10f6ba: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f6bd: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f6c0: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f6c3: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f6c6: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f6c9: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f6cc: 89 c2 mov %eax,%edx
10f6ce: 83 ca 01 or $0x1,%edx
10f6d1: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f6d4: 89 04 03 mov %eax,(%ebx,%eax,1)
10f6d7: eb 2c jmp 10f705 <_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;
10f6d9: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f6dc: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f6df: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f6e2: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f6e5: 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;
10f6e8: 89 f0 mov %esi,%eax
10f6ea: 83 c8 01 or $0x1,%eax
10f6ed: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f6f0: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f6f4: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f6f6: 8b 41 38 mov 0x38(%ecx),%eax
10f6f9: 40 inc %eax
10f6fa: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f6fd: 39 41 3c cmp %eax,0x3c(%ecx)
10f700: 73 03 jae 10f705 <_Heap_Free+0x14d>
stats->max_free_blocks = stats->free_blocks;
10f702: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f705: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f708: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f70b: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f70e: b0 01 mov $0x1,%al
}
10f710: 83 c4 14 add $0x14,%esp
10f713: 5b pop %ebx
10f714: 5e pop %esi
10f715: 5f pop %edi
10f716: c9 leave
10f717: c3 ret
0011cb80 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11cb80: 55 push %ebp
11cb81: 89 e5 mov %esp,%ebp
11cb83: 57 push %edi
11cb84: 56 push %esi
11cb85: 53 push %ebx
11cb86: 8b 5d 08 mov 0x8(%ebp),%ebx
11cb89: 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);
11cb8c: 8d 4e f8 lea -0x8(%esi),%ecx
11cb8f: 89 f0 mov %esi,%eax
11cb91: 31 d2 xor %edx,%edx
11cb93: 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);
11cb96: 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
11cb98: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11cb9b: 31 ff xor %edi,%edi
11cb9d: 39 d1 cmp %edx,%ecx
11cb9f: 72 0a jb 11cbab <_Heap_Size_of_alloc_area+0x2b>
11cba1: 31 c0 xor %eax,%eax
11cba3: 39 4b 24 cmp %ecx,0x24(%ebx)
11cba6: 0f 93 c0 setae %al
11cba9: 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;
11cbab: 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 ) ) {
11cbad: 85 ff test %edi,%edi
11cbaf: 74 30 je 11cbe1 <_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;
11cbb1: 8b 41 04 mov 0x4(%ecx),%eax
11cbb4: 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);
11cbb7: 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;
11cbb9: 31 ff xor %edi,%edi
11cbbb: 39 d1 cmp %edx,%ecx
11cbbd: 72 0a jb 11cbc9 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11cbbf: 31 c0 xor %eax,%eax
11cbc1: 39 4b 24 cmp %ecx,0x24(%ebx)
11cbc4: 0f 93 c0 setae %al
11cbc7: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11cbc9: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11cbcb: 85 ff test %edi,%edi
11cbcd: 74 12 je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11cbcf: f6 41 04 01 testb $0x1,0x4(%ecx)
11cbd3: 74 0c je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11cbd5: 29 f1 sub %esi,%ecx
11cbd7: 8d 51 04 lea 0x4(%ecx),%edx
11cbda: 8b 45 10 mov 0x10(%ebp),%eax
11cbdd: 89 10 mov %edx,(%eax)
return true;
11cbdf: b0 01 mov $0x1,%al
}
11cbe1: 5b pop %ebx
11cbe2: 5e pop %esi
11cbe3: 5f pop %edi
11cbe4: c9 leave
11cbe5: c3 ret
0010bc0e <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc0e: 55 push %ebp
10bc0f: 89 e5 mov %esp,%ebp
10bc11: 57 push %edi
10bc12: 56 push %esi
10bc13: 53 push %ebx
10bc14: 83 ec 4c sub $0x4c,%esp
10bc17: 8b 75 08 mov 0x8(%ebp),%esi
10bc1a: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc1d: 8b 46 10 mov 0x10(%esi),%eax
10bc20: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc23: 8b 4e 14 mov 0x14(%esi),%ecx
10bc26: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc29: 8b 46 20 mov 0x20(%esi),%eax
10bc2c: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc2f: 8b 4e 24 mov 0x24(%esi),%ecx
10bc32: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc35: c7 45 e4 d0 bb 10 00 movl $0x10bbd0,-0x1c(%ebp)
10bc3c: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bc40: 74 07 je 10bc49 <_Heap_Walk+0x3b>
10bc42: c7 45 e4 d5 bb 10 00 movl $0x10bbd5,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bc49: 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() ) ) {
10bc4b: 83 3d ec 64 12 00 03 cmpl $0x3,0x1264ec
10bc52: 0f 85 e8 02 00 00 jne 10bf40 <_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)(
10bc58: 52 push %edx
10bc59: ff 76 0c pushl 0xc(%esi)
10bc5c: ff 76 08 pushl 0x8(%esi)
10bc5f: ff 75 c8 pushl -0x38(%ebp)
10bc62: ff 75 d0 pushl -0x30(%ebp)
10bc65: ff 76 1c pushl 0x1c(%esi)
10bc68: ff 76 18 pushl 0x18(%esi)
10bc6b: ff 75 d4 pushl -0x2c(%ebp)
10bc6e: ff 75 d8 pushl -0x28(%ebp)
10bc71: 68 09 f7 11 00 push $0x11f709
10bc76: 6a 00 push $0x0
10bc78: 53 push %ebx
10bc79: 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 ) {
10bc7c: 83 c4 30 add $0x30,%esp
10bc7f: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bc83: 75 0b jne 10bc90 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bc85: 50 push %eax
10bc86: 68 9a f7 11 00 push $0x11f79a
10bc8b: e9 6b 02 00 00 jmp 10befb <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bc90: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bc94: 74 0d je 10bca3 <_Heap_Walk+0x95>
(*printer)(
10bc96: ff 75 d8 pushl -0x28(%ebp)
10bc99: 68 ad f7 11 00 push $0x11f7ad
10bc9e: e9 58 02 00 00 jmp 10befb <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bca3: 8b 45 d4 mov -0x2c(%ebp),%eax
10bca6: 31 d2 xor %edx,%edx
10bca8: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bcab: 85 d2 test %edx,%edx
10bcad: 74 0d je 10bcbc <_Heap_Walk+0xae>
(*printer)(
10bcaf: ff 75 d4 pushl -0x2c(%ebp)
10bcb2: 68 cb f7 11 00 push $0x11f7cb
10bcb7: e9 3f 02 00 00 jmp 10befb <_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;
10bcbc: 8b 45 d0 mov -0x30(%ebp),%eax
10bcbf: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcc2: 31 d2 xor %edx,%edx
10bcc4: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bcc7: 85 d2 test %edx,%edx
10bcc9: 74 0d je 10bcd8 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bccb: ff 75 d0 pushl -0x30(%ebp)
10bcce: 68 ef f7 11 00 push $0x11f7ef
10bcd3: e9 23 02 00 00 jmp 10befb <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bcd8: 8b 45 d0 mov -0x30(%ebp),%eax
10bcdb: f6 40 04 01 testb $0x1,0x4(%eax)
10bcdf: 75 0b jne 10bcec <_Heap_Walk+0xde>
(*printer)(
10bce1: 57 push %edi
10bce2: 68 20 f8 11 00 push $0x11f820
10bce7: e9 0f 02 00 00 jmp 10befb <_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;
10bcec: 8b 4d c8 mov -0x38(%ebp),%ecx
10bcef: 8b 79 04 mov 0x4(%ecx),%edi
10bcf2: 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);
10bcf5: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bcf7: f6 47 04 01 testb $0x1,0x4(%edi)
10bcfb: 75 0b jne 10bd08 <_Heap_Walk+0xfa>
(*printer)(
10bcfd: 56 push %esi
10bcfe: 68 4e f8 11 00 push $0x11f84e
10bd03: e9 f3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd08: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd0b: 74 0b je 10bd18 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd0d: 51 push %ecx <== NOT EXECUTED
10bd0e: 68 63 f8 11 00 push $0x11f863 <== NOT EXECUTED
10bd13: e9 e3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd18: 8b 46 10 mov 0x10(%esi),%eax
10bd1b: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd1e: 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 );
10bd21: 89 75 dc mov %esi,-0x24(%ebp)
10bd24: eb 75 jmp 10bd9b <_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;
10bd26: 31 c0 xor %eax,%eax
10bd28: 39 4e 20 cmp %ecx,0x20(%esi)
10bd2b: 77 08 ja 10bd35 <_Heap_Walk+0x127>
10bd2d: 31 c0 xor %eax,%eax
10bd2f: 39 4e 24 cmp %ecx,0x24(%esi)
10bd32: 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 ) ) {
10bd35: 85 c0 test %eax,%eax
10bd37: 75 0b jne 10bd44 <_Heap_Walk+0x136>
(*printer)(
10bd39: 51 push %ecx
10bd3a: 68 92 f8 11 00 push $0x11f892
10bd3f: e9 b7 01 00 00 jmp 10befb <_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;
10bd44: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd47: 31 d2 xor %edx,%edx
10bd49: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bd4c: 85 d2 test %edx,%edx
10bd4e: 74 0b je 10bd5b <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bd50: 51 push %ecx
10bd51: 68 b2 f8 11 00 push $0x11f8b2
10bd56: e9 a0 01 00 00 jmp 10befb <_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;
10bd5b: 8b 41 04 mov 0x4(%ecx),%eax
10bd5e: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bd61: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bd66: 74 0b je 10bd73 <_Heap_Walk+0x165>
(*printer)(
10bd68: 51 push %ecx
10bd69: 68 e2 f8 11 00 push $0x11f8e2
10bd6e: e9 88 01 00 00 jmp 10befb <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bd73: 8b 41 0c mov 0xc(%ecx),%eax
10bd76: 3b 45 dc cmp -0x24(%ebp),%eax
10bd79: 74 1a je 10bd95 <_Heap_Walk+0x187>
(*printer)(
10bd7b: 83 ec 0c sub $0xc,%esp
10bd7e: 50 push %eax
10bd7f: 51 push %ecx
10bd80: 68 fe f8 11 00 push $0x11f8fe
10bd85: 6a 01 push $0x1
10bd87: 53 push %ebx
10bd88: ff 55 e4 call *-0x1c(%ebp)
10bd8b: 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;
10bd8e: 31 c0 xor %eax,%eax
10bd90: e9 ab 01 00 00 jmp 10bf40 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bd95: 89 4d dc mov %ecx,-0x24(%ebp)
10bd98: 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 ) {
10bd9b: 39 f1 cmp %esi,%ecx
10bd9d: 75 87 jne 10bd26 <_Heap_Walk+0x118>
10bd9f: 89 5d dc mov %ebx,-0x24(%ebp)
10bda2: eb 02 jmp 10bda6 <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bda4: 89 df mov %ebx,%edi
return true;
}
10bda6: 8b 4f 04 mov 0x4(%edi),%ecx
10bda9: 89 4d cc mov %ecx,-0x34(%ebp)
10bdac: 83 e1 fe and $0xfffffffe,%ecx
10bdaf: 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);
10bdb2: 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;
10bdb5: 31 c0 xor %eax,%eax
10bdb7: 39 5e 20 cmp %ebx,0x20(%esi)
10bdba: 77 08 ja 10bdc4 <_Heap_Walk+0x1b6> <== NEVER TAKEN
10bdbc: 31 c0 xor %eax,%eax
10bdbe: 39 5e 24 cmp %ebx,0x24(%esi)
10bdc1: 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 ) ) {
10bdc4: 85 c0 test %eax,%eax
10bdc6: 75 11 jne 10bdd9 <_Heap_Walk+0x1cb>
10bdc8: 89 d9 mov %ebx,%ecx
10bdca: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdcd: 83 ec 0c sub $0xc,%esp
10bdd0: 51 push %ecx
10bdd1: 57 push %edi
10bdd2: 68 30 f9 11 00 push $0x11f930
10bdd7: eb ac jmp 10bd85 <_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;
10bdd9: 3b 7d c8 cmp -0x38(%ebp),%edi
10bddc: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bddf: 8b 45 e0 mov -0x20(%ebp),%eax
10bde2: 31 d2 xor %edx,%edx
10bde4: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10bde7: 85 d2 test %edx,%edx
10bde9: 74 15 je 10be00 <_Heap_Walk+0x1f2>
10bdeb: 84 c9 test %cl,%cl
10bded: 74 11 je 10be00 <_Heap_Walk+0x1f2>
10bdef: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdf2: 83 ec 0c sub $0xc,%esp
10bdf5: ff 75 e0 pushl -0x20(%ebp)
10bdf8: 57 push %edi
10bdf9: 68 5d f9 11 00 push $0x11f95d
10bdfe: eb 85 jmp 10bd85 <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be00: 8b 45 d4 mov -0x2c(%ebp),%eax
10be03: 39 45 e0 cmp %eax,-0x20(%ebp)
10be06: 73 18 jae 10be20 <_Heap_Walk+0x212>
10be08: 84 c9 test %cl,%cl
10be0a: 74 14 je 10be20 <_Heap_Walk+0x212> <== NEVER TAKEN
10be0c: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be0f: 52 push %edx
10be10: 52 push %edx
10be11: 50 push %eax
10be12: ff 75 e0 pushl -0x20(%ebp)
10be15: 57 push %edi
10be16: 68 8b f9 11 00 push $0x11f98b
10be1b: e9 65 ff ff ff jmp 10bd85 <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be20: 39 fb cmp %edi,%ebx
10be22: 77 18 ja 10be3c <_Heap_Walk+0x22e>
10be24: 84 c9 test %cl,%cl
10be26: 74 14 je 10be3c <_Heap_Walk+0x22e>
10be28: 89 d9 mov %ebx,%ecx
10be2a: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be2d: 83 ec 0c sub $0xc,%esp
10be30: 51 push %ecx
10be31: 57 push %edi
10be32: 68 b6 f9 11 00 push $0x11f9b6
10be37: e9 49 ff ff ff jmp 10bd85 <_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;
10be3c: 8b 4d cc mov -0x34(%ebp),%ecx
10be3f: 83 e1 01 and $0x1,%ecx
10be42: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10be45: f6 43 04 01 testb $0x1,0x4(%ebx)
10be49: 0f 85 ba 00 00 00 jne 10bf09 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10be4f: 8b 46 08 mov 0x8(%esi),%eax
10be52: 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 ?
10be55: 8b 4f 08 mov 0x8(%edi),%ecx
10be58: 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)(
10be5b: ba d6 f6 11 00 mov $0x11f6d6,%edx
10be60: 3b 4e 0c cmp 0xc(%esi),%ecx
10be63: 74 0e je 10be73 <_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)" : "")
10be65: ba 0d f6 11 00 mov $0x11f60d,%edx
10be6a: 39 f1 cmp %esi,%ecx
10be6c: 75 05 jne 10be73 <_Heap_Walk+0x265>
10be6e: ba e5 f6 11 00 mov $0x11f6e5,%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 ?
10be73: 8b 47 0c mov 0xc(%edi),%eax
10be76: 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)(
10be79: b8 ef f6 11 00 mov $0x11f6ef,%eax
10be7e: 8b 4d c0 mov -0x40(%ebp),%ecx
10be81: 39 4d cc cmp %ecx,-0x34(%ebp)
10be84: 74 0f je 10be95 <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10be86: b8 0d f6 11 00 mov $0x11f60d,%eax
10be8b: 39 75 cc cmp %esi,-0x34(%ebp)
10be8e: 75 05 jne 10be95 <_Heap_Walk+0x287>
10be90: b8 ff f6 11 00 mov $0x11f6ff,%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)(
10be95: 83 ec 0c sub $0xc,%esp
10be98: 52 push %edx
10be99: ff 75 b4 pushl -0x4c(%ebp)
10be9c: 50 push %eax
10be9d: ff 75 cc pushl -0x34(%ebp)
10bea0: ff 75 e0 pushl -0x20(%ebp)
10bea3: 57 push %edi
10bea4: 68 ea f9 11 00 push $0x11f9ea
10bea9: 6a 00 push $0x0
10beab: ff 75 dc pushl -0x24(%ebp)
10beae: 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 ) {
10beb1: 8b 03 mov (%ebx),%eax
10beb3: 83 c4 30 add $0x30,%esp
10beb6: 39 45 e0 cmp %eax,-0x20(%ebp)
10beb9: 74 16 je 10bed1 <_Heap_Walk+0x2c3>
10bebb: 89 d9 mov %ebx,%ecx
10bebd: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bec0: 56 push %esi
10bec1: 51 push %ecx
10bec2: 50 push %eax
10bec3: ff 75 e0 pushl -0x20(%ebp)
10bec6: 57 push %edi
10bec7: 68 1f fa 11 00 push $0x11fa1f
10becc: e9 b4 fe ff ff jmp 10bd85 <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bed1: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bed5: 75 0b jne 10bee2 <_Heap_Walk+0x2d4>
10bed7: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10beda: 57 push %edi
10bedb: 68 58 fa 11 00 push $0x11fa58
10bee0: eb 19 jmp 10befb <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10bee2: 8b 46 08 mov 0x8(%esi),%eax
10bee5: eb 07 jmp 10beee <_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 ) {
10bee7: 39 f8 cmp %edi,%eax
10bee9: 74 4a je 10bf35 <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10beeb: 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 ) {
10beee: 39 f0 cmp %esi,%eax
10bef0: 75 f5 jne 10bee7 <_Heap_Walk+0x2d9>
10bef2: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10bef5: 57 push %edi
10bef6: 68 c3 fa 11 00 push $0x11fac3
10befb: 6a 01 push $0x1
10befd: 53 push %ebx
10befe: ff 55 e4 call *-0x1c(%ebp)
10bf01: 83 c4 10 add $0x10,%esp
10bf04: e9 85 fe ff ff jmp 10bd8e <_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) {
10bf09: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf0d: 74 0e je 10bf1d <_Heap_Walk+0x30f>
(*printer)(
10bf0f: 83 ec 0c sub $0xc,%esp
10bf12: ff 75 e0 pushl -0x20(%ebp)
10bf15: 57 push %edi
10bf16: 68 87 fa 11 00 push $0x11fa87
10bf1b: eb 0d jmp 10bf2a <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf1d: 51 push %ecx
10bf1e: 51 push %ecx
10bf1f: ff 37 pushl (%edi)
10bf21: ff 75 e0 pushl -0x20(%ebp)
10bf24: 57 push %edi
10bf25: 68 9e fa 11 00 push $0x11fa9e
10bf2a: 6a 00 push $0x0
10bf2c: ff 75 dc pushl -0x24(%ebp)
10bf2f: ff 55 e4 call *-0x1c(%ebp)
10bf32: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf35: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bf38: 0f 85 66 fe ff ff jne 10bda4 <_Heap_Walk+0x196>
return true;
10bf3e: b0 01 mov $0x1,%al
}
10bf40: 8d 65 f4 lea -0xc(%ebp),%esp
10bf43: 5b pop %ebx
10bf44: 5e pop %esi
10bf45: 5f pop %edi
10bf46: c9 leave
10bf47: c3 ret
0010b230 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b230: 55 push %ebp
10b231: 89 e5 mov %esp,%ebp
10b233: 53 push %ebx
10b234: 83 ec 08 sub $0x8,%esp
10b237: 8b 45 08 mov 0x8(%ebp),%eax
10b23a: 8b 55 0c mov 0xc(%ebp),%edx
10b23d: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b240: a3 7c 43 12 00 mov %eax,0x12437c
_Internal_errors_What_happened.is_internal = is_internal;
10b245: 88 15 80 43 12 00 mov %dl,0x124380
_Internal_errors_What_happened.the_error = the_error;
10b24b: 89 1d 84 43 12 00 mov %ebx,0x124384
_User_extensions_Fatal( the_source, is_internal, the_error );
10b251: 53 push %ebx
10b252: 0f b6 d2 movzbl %dl,%edx
10b255: 52 push %edx
10b256: 50 push %eax
10b257: e8 23 19 00 00 call 10cb7f <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b25c: c7 05 64 44 12 00 05 movl $0x5,0x124464 <== NOT EXECUTED
10b263: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b266: fa cli <== NOT EXECUTED
10b267: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b269: f4 hlt <== NOT EXECUTED
10b26a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b26d: eb fe jmp 10b26d <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b2c0 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b2c0: 55 push %ebp
10b2c1: 89 e5 mov %esp,%ebp
10b2c3: 56 push %esi
10b2c4: 53 push %ebx
10b2c5: 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;
10b2c8: 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 )
10b2ca: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b2ce: 74 53 je 10b323 <_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 );
10b2d0: 8d 73 20 lea 0x20(%ebx),%esi
10b2d3: 83 ec 0c sub $0xc,%esp
10b2d6: 56 push %esi
10b2d7: e8 30 f7 ff ff call 10aa0c <_Chain_Get>
10b2dc: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b2de: 83 c4 10 add $0x10,%esp
10b2e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b2e5: 74 3c je 10b323 <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b2e7: 85 c0 test %eax,%eax
10b2e9: 75 1a jne 10b305 <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b2eb: 83 ec 0c sub $0xc,%esp
10b2ee: 53 push %ebx
10b2ef: e8 60 00 00 00 call 10b354 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b2f4: 89 34 24 mov %esi,(%esp)
10b2f7: e8 10 f7 ff ff call 10aa0c <_Chain_Get>
10b2fc: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b2fe: 83 c4 10 add $0x10,%esp
10b301: 85 c0 test %eax,%eax
10b303: 74 1e je 10b323 <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b305: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b309: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b30d: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b30f: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b313: 31 d2 xor %edx,%edx
10b315: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b317: c1 e0 02 shl $0x2,%eax
10b31a: 03 43 30 add 0x30(%ebx),%eax
10b31d: ff 08 decl (%eax)
information->inactive--;
10b31f: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b323: 89 c8 mov %ecx,%eax
10b325: 8d 65 f8 lea -0x8(%ebp),%esp
10b328: 5b pop %ebx
10b329: 5e pop %esi
10b32a: c9 leave
10b32b: c3 ret
0010b648 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b648: 55 push %ebp
10b649: 89 e5 mov %esp,%ebp
10b64b: 57 push %edi
10b64c: 56 push %esi
10b64d: 53 push %ebx
10b64e: 83 ec 0c sub $0xc,%esp
10b651: 8b 75 08 mov 0x8(%ebp),%esi
10b654: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b657: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b659: 66 85 ff test %di,%di
10b65c: 74 37 je 10b695 <_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 );
10b65e: 83 ec 0c sub $0xc,%esp
10b661: 56 push %esi
10b662: e8 b1 40 00 00 call 10f718 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b667: 83 c4 10 add $0x10,%esp
10b66a: 85 c0 test %eax,%eax
10b66c: 74 27 je 10b695 <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b66e: 0f b7 ff movzwl %di,%edi
10b671: 39 c7 cmp %eax,%edi
10b673: 77 20 ja 10b695 <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b675: 8b 04 b5 bc 42 12 00 mov 0x1242bc(,%esi,4),%eax
10b67c: 85 c0 test %eax,%eax
10b67e: 74 15 je 10b695 <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b680: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b683: 85 db test %ebx,%ebx
10b685: 74 0e je 10b695 <_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;
10b687: 31 c0 xor %eax,%eax
10b689: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b68e: 0f 95 c0 setne %al
10b691: f7 d8 neg %eax
10b693: 21 c3 and %eax,%ebx
#endif
return info;
}
10b695: 89 d8 mov %ebx,%eax
10b697: 8d 65 f4 lea -0xc(%ebp),%esp
10b69a: 5b pop %ebx
10b69b: 5e pop %esi
10b69c: 5f pop %edi
10b69d: c9 leave
10b69e: c3 ret
00118abc <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118abc: 55 push %ebp
118abd: 89 e5 mov %esp,%ebp
118abf: 53 push %ebx
118ac0: 8b 55 08 mov 0x8(%ebp),%edx
118ac3: 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;
118ac6: b8 01 00 00 00 mov $0x1,%eax
118acb: 2b 42 08 sub 0x8(%edx),%eax
118ace: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118ad1: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118ad5: 39 c3 cmp %eax,%ebx
118ad7: 72 12 jb 118aeb <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118ad9: 8b 52 1c mov 0x1c(%edx),%edx
118adc: 8b 04 82 mov (%edx,%eax,4),%eax
118adf: 85 c0 test %eax,%eax
118ae1: 74 08 je 118aeb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118ae3: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118ae9: eb 08 jmp 118af3 <_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;
118aeb: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118af1: 31 c0 xor %eax,%eax
}
118af3: 5b pop %ebx
118af4: c9 leave
118af5: c3 ret
0010c874 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c874: 55 push %ebp
10c875: 89 e5 mov %esp,%ebp
10c877: 53 push %ebx
10c878: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c87b: 8b 45 08 mov 0x8(%ebp),%eax
10c87e: 85 c0 test %eax,%eax
10c880: 75 08 jne 10c88a <_Objects_Id_to_name+0x16>
10c882: a1 80 78 12 00 mov 0x127880,%eax
10c887: 8b 40 08 mov 0x8(%eax),%eax
10c88a: 89 c2 mov %eax,%edx
10c88c: c1 ea 18 shr $0x18,%edx
10c88f: 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 )
10c892: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c895: bb 03 00 00 00 mov $0x3,%ebx
10c89a: 83 f9 02 cmp $0x2,%ecx
10c89d: 77 36 ja 10c8d5 <_Objects_Id_to_name+0x61>
10c89f: eb 3b jmp 10c8dc <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c8a1: 89 c1 mov %eax,%ecx
10c8a3: 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 ];
10c8a6: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c8a9: 85 d2 test %edx,%edx
10c8ab: 74 28 je 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8ad: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8b1: 75 22 jne 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8b3: 51 push %ecx
10c8b4: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8b7: 51 push %ecx
10c8b8: 50 push %eax
10c8b9: 52 push %edx
10c8ba: e8 5d ff ff ff call 10c81c <_Objects_Get>
if ( !the_object )
10c8bf: 83 c4 10 add $0x10,%esp
10c8c2: 85 c0 test %eax,%eax
10c8c4: 74 0f je 10c8d5 <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c8c6: 8b 50 0c mov 0xc(%eax),%edx
10c8c9: 8b 45 0c mov 0xc(%ebp),%eax
10c8cc: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c8ce: e8 9f 07 00 00 call 10d072 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c8d3: 31 db xor %ebx,%ebx
}
10c8d5: 89 d8 mov %ebx,%eax
10c8d7: 8b 5d fc mov -0x4(%ebp),%ebx
10c8da: c9 leave
10c8db: 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 ] )
10c8dc: 8b 14 95 08 73 12 00 mov 0x127308(,%edx,4),%edx
10c8e3: 85 d2 test %edx,%edx
10c8e5: 75 ba jne 10c8a1 <_Objects_Id_to_name+0x2d>
10c8e7: eb ec jmp 10c8d5 <_Objects_Id_to_name+0x61>
0010e2b8 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e2b8: 55 push %ebp
10e2b9: 89 e5 mov %esp,%ebp
10e2bb: 57 push %edi
10e2bc: 56 push %esi
10e2bd: 53 push %ebx
10e2be: 83 ec 30 sub $0x30,%esp
10e2c1: 8b 75 08 mov 0x8(%ebp),%esi
10e2c4: 8b 5d 14 mov 0x14(%ebp),%ebx
10e2c7: 8a 55 18 mov 0x18(%ebp),%dl
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10e2ca: 8d 45 e4 lea -0x1c(%ebp),%eax
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10e2cd: 50 push %eax
10e2ce: 56 push %esi
10e2cf: 68 7c d9 12 00 push $0x12d97c
10e2d4: 88 55 d4 mov %dl,-0x2c(%ebp)
10e2d7: e8 f0 2a 00 00 call 110dcc <_Objects_Get>
switch ( location ) {
10e2dc: 83 c4 10 add $0x10,%esp
10e2df: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e2e3: 8a 55 d4 mov -0x2c(%ebp),%dl
10e2e6: 0f 85 aa 00 00 00 jne 10e396 <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e2ec: 8b 78 14 mov 0x14(%eax),%edi
10e2ef: 89 f9 mov %edi,%ecx
10e2f1: 83 e1 03 and $0x3,%ecx
10e2f4: 49 dec %ecx
10e2f5: 75 0a jne 10e301 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e2f7: e8 22 33 00 00 call 11161e <_Thread_Enable_dispatch>
10e2fc: e9 95 00 00 00 jmp 10e396 <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e301: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e304: 8b 48 68 mov 0x68(%eax),%ecx
10e307: 39 4d 10 cmp %ecx,0x10(%ebp)
10e30a: 73 15 jae 10e321 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e30c: e8 0d 33 00 00 call 11161e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e311: e8 be 8a 00 00 call 116dd4 <__errno>
10e316: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e31c: e9 80 00 00 00 jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e321: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10e328: 31 c9 xor %ecx,%ecx
10e32a: 84 d2 test %dl,%dl
10e32c: 74 09 je 10e337 <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e32e: 81 e7 00 40 00 00 and $0x4000,%edi
10e334: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e337: 52 push %edx
10e338: 52 push %edx
10e339: ff 75 1c pushl 0x1c(%ebp)
10e33c: 0f b6 c9 movzbl %cl,%ecx
10e33f: 51 push %ecx
10e340: 8d 55 e0 lea -0x20(%ebp),%edx
10e343: 52 push %edx
10e344: ff 75 0c pushl 0xc(%ebp)
10e347: 56 push %esi
10e348: 83 c0 1c add $0x1c,%eax
10e34b: 50 push %eax
10e34c: e8 73 1c 00 00 call 10ffc4 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e351: 83 c4 20 add $0x20,%esp
10e354: e8 c5 32 00 00 call 11161e <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e359: a1 f4 d9 12 00 mov 0x12d9f4,%eax
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
10e35e: 8b 50 24 mov 0x24(%eax),%edx
10e361: c1 fa 1f sar $0x1f,%edx
10e364: 8b 48 24 mov 0x24(%eax),%ecx
10e367: 31 d1 xor %edx,%ecx
10e369: 89 0b mov %ecx,(%ebx)
10e36b: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e36d: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e371: 75 05 jne 10e378 <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e373: 8b 45 e0 mov -0x20(%ebp),%eax
10e376: eb 2c jmp 10e3a4 <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e378: e8 57 8a 00 00 call 116dd4 <__errno>
10e37d: 89 c3 mov %eax,%ebx
10e37f: 83 ec 0c sub $0xc,%esp
10e382: a1 f4 d9 12 00 mov 0x12d9f4,%eax
10e387: ff 70 34 pushl 0x34(%eax)
10e38a: e8 ed 01 00 00 call 10e57c <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e38f: 89 03 mov %eax,(%ebx)
10e391: 83 c4 10 add $0x10,%esp
10e394: eb 0b jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e396: e8 39 8a 00 00 call 116dd4 <__errno>
10e39b: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3a1: 83 c8 ff or $0xffffffff,%eax
}
10e3a4: 8d 65 f4 lea -0xc(%ebp),%esp
10e3a7: 5b pop %ebx
10e3a8: 5e pop %esi
10e3a9: 5f pop %edi
10e3aa: c9 leave
10e3ab: c3 ret
0010e86c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e86c: 55 push %ebp
10e86d: 89 e5 mov %esp,%ebp
10e86f: 83 ec 08 sub $0x8,%esp
10e872: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e875: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e87b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10e882: 75 2c jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e884: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10e88b: 75 23 jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e88d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10e894: 74 1a je 10e8b0 <_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;
10e896: a1 d4 52 12 00 mov 0x1252d4,%eax
10e89b: 48 dec %eax
10e89c: a3 d4 52 12 00 mov %eax,0x1252d4
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10e8a1: 50 push %eax
10e8a2: 50 push %eax
10e8a3: 6a ff push $0xffffffff
10e8a5: 52 push %edx
10e8a6: e8 51 08 00 00 call 10f0fc <_POSIX_Thread_Exit>
10e8ab: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10e8ae: c9 leave
10e8af: c3 ret
10e8b0: 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();
10e8b1: e9 c0 d9 ff ff jmp 10c276 <_Thread_Enable_dispatch>
0010faf0 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10faf0: 55 push %ebp
10faf1: 89 e5 mov %esp,%ebp
10faf3: 57 push %edi
10faf4: 56 push %esi
10faf5: 53 push %ebx
10faf6: 83 ec 28 sub $0x28,%esp
10faf9: 8b 55 08 mov 0x8(%ebp),%edx
10fafc: 8b 5d 0c mov 0xc(%ebp),%ebx
10faff: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fb02: ff 33 pushl (%ebx)
10fb04: 89 55 e0 mov %edx,-0x20(%ebp)
10fb07: e8 c4 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid>
10fb0c: 83 c4 10 add $0x10,%esp
return EINVAL;
10fb0f: 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 ) )
10fb14: 84 c0 test %al,%al
10fb16: 8b 55 e0 mov -0x20(%ebp),%edx
10fb19: 0f 84 a4 00 00 00 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fb1f: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fb25: 8b 45 14 mov 0x14(%ebp),%eax
10fb28: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fb2e: 85 d2 test %edx,%edx
10fb30: 75 0b jne 10fb3d <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fb32: c7 07 01 00 00 00 movl $0x1,(%edi)
10fb38: e9 83 00 00 00 jmp 10fbc0 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fb3d: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fb3f: 83 fa 01 cmp $0x1,%edx
10fb42: 74 7f je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fb44: 83 fa 02 cmp $0x2,%edx
10fb47: 75 08 jne 10fb51 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fb49: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fb4f: eb 72 jmp 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fb51: 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 ) {
10fb56: 83 fa 04 cmp $0x4,%edx
10fb59: 75 68 jne 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fb5b: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fb5f: 75 06 jne 10fb67 <_POSIX_Thread_Translate_sched_param+0x77>
10fb61: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fb65: 74 5c je 10fbc3 <_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) &&
10fb67: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fb6b: 75 0b jne 10fb78 <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fb6d: 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) &&
10fb72: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fb76: 74 4b je 10fbc3 <_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 ) <
10fb78: 83 ec 0c sub $0xc,%esp
10fb7b: 8d 43 08 lea 0x8(%ebx),%eax
10fb7e: 50 push %eax
10fb7f: e8 14 de ff ff call 10d998 <_Timespec_To_ticks>
10fb84: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fb87: 8d 43 10 lea 0x10(%ebx),%eax
10fb8a: 89 04 24 mov %eax,(%esp)
10fb8d: e8 06 de ff ff call 10d998 <_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 ) <
10fb92: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fb95: 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 ) <
10fb9a: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fb9d: 72 24 jb 10fbc3 <_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 ) )
10fb9f: 83 ec 0c sub $0xc,%esp
10fba2: ff 73 04 pushl 0x4(%ebx)
10fba5: e8 26 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid>
10fbaa: 83 c4 10 add $0x10,%esp
10fbad: 84 c0 test %al,%al
10fbaf: 74 12 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fbb1: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fbb7: 8b 45 14 mov 0x14(%ebp),%eax
10fbba: c7 00 e9 a7 10 00 movl $0x10a7e9,(%eax)
return 0;
10fbc0: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fbc3: 89 f0 mov %esi,%eax
10fbc5: 8d 65 f4 lea -0xc(%ebp),%esp
10fbc8: 5b pop %ebx
10fbc9: 5e pop %esi
10fbca: 5f pop %edi
10fbcb: c9 leave
10fbcc: c3 ret
0010a4ec <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a4ec: 55 push %ebp
10a4ed: 89 e5 mov %esp,%ebp
10a4ef: 57 push %edi
10a4f0: 56 push %esi
10a4f1: 53 push %ebx
10a4f2: 83 ec 6c sub $0x6c,%esp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
10a4f5: 8b 3d 10 12 12 00 mov 0x121210,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a4fb: 8b 15 0c 12 12 00 mov 0x12120c,%edx
if ( !user_threads || maximum == 0 )
10a501: 85 d2 test %edx,%edx
10a503: 74 54 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a505: 85 ff test %edi,%edi
10a507: 74 50 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a509: 31 db xor %ebx,%ebx
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
10a50b: 8d 75 a4 lea -0x5c(%ebp),%esi
10a50e: 83 ec 0c sub $0xc,%esp
10a511: 56 push %esi
10a512: 89 55 94 mov %edx,-0x6c(%ebp)
10a515: e8 b6 56 00 00 call 10fbd0 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a51a: 5a pop %edx
10a51b: 59 pop %ecx
10a51c: 6a 02 push $0x2
10a51e: 56 push %esi
10a51f: e8 d4 56 00 00 call 10fbf8 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a524: 59 pop %ecx
10a525: 58 pop %eax
10a526: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a52a: 56 push %esi
10a52b: e8 f4 56 00 00 call 10fc24 <pthread_attr_setstacksize>
status = pthread_create(
10a530: 6a 00 push $0x0
10a532: ff 34 df pushl (%edi,%ebx,8)
10a535: 56 push %esi
10a536: 8d 45 e4 lea -0x1c(%ebp),%eax
10a539: 50 push %eax
10a53a: e8 e5 fc ff ff call 10a224 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a53f: 83 c4 20 add $0x20,%esp
10a542: 85 c0 test %eax,%eax
10a544: 8b 55 94 mov -0x6c(%ebp),%edx
10a547: 74 0b je 10a554 <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a549: 52 push %edx
10a54a: 50 push %eax
10a54b: 6a 01 push $0x1
10a54d: 6a 02 push $0x2
10a54f: e8 e4 1b 00 00 call 10c138 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
10a554: 43 inc %ebx
10a555: 39 d3 cmp %edx,%ebx
10a557: 72 b5 jb 10a50e <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a559: 8d 65 f4 lea -0xc(%ebp),%esp
10a55c: 5b pop %ebx
10a55d: 5e pop %esi
10a55e: 5f pop %edi
10a55f: c9 leave
10a560: c3 ret
0010ec4f <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10ec4f: 55 push %ebp
10ec50: 89 e5 mov %esp,%ebp
10ec52: 56 push %esi
10ec53: 53 push %ebx
10ec54: 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 ];
10ec57: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
10ec5d: 83 ec 0c sub $0xc,%esp
10ec60: 8d 86 98 00 00 00 lea 0x98(%esi),%eax
10ec66: 50 push %eax
10ec67: e8 94 0e 00 00 call 10fb00 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10ec6c: 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);
10ec6f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax
10ec76: 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;
10ec7c: 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 ) {
10ec7f: 83 c4 10 add $0x10,%esp
10ec82: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10ec86: 75 12 jne 10ec9a <_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 ) {
10ec88: 39 43 14 cmp %eax,0x14(%ebx)
10ec8b: 76 0d jbe 10ec9a <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10ec8d: 52 push %edx
10ec8e: 6a 01 push $0x1
10ec90: 50 push %eax
10ec91: 53 push %ebx
10ec92: e8 a5 cd ff ff call 10ba3c <_Thread_Change_priority>
10ec97: 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 );
10ec9a: 83 ec 0c sub $0xc,%esp
10ec9d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10eca3: 50 push %eax
10eca4: e8 57 0e 00 00 call 10fb00 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10eca9: 89 86 b4 00 00 00 mov %eax,0xb4(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10ecaf: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10ecb2: 81 c6 a8 00 00 00 add $0xa8,%esi
10ecb8: 89 75 0c mov %esi,0xc(%ebp)
10ecbb: c7 45 08 ac 43 12 00 movl $0x1243ac,0x8(%ebp)
}
10ecc2: 8d 65 f8 lea -0x8(%ebp),%esp
10ecc5: 5b pop %ebx
10ecc6: 5e pop %esi
10ecc7: c9 leave
10ecc8: e9 d3 df ff ff jmp 10cca0 <_Watchdog_Insert>
0010eccd <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10eccd: 55 push %ebp
10ecce: 89 e5 mov %esp,%ebp
10ecd0: 83 ec 08 sub $0x8,%esp
10ecd3: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ecd6: 8b 88 f8 00 00 00 mov 0xf8(%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 */
10ecdc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10ece3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx
10ecea: 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;
10ecf0: 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 ) {
10ecf3: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ecf7: 75 12 jne 10ed0b <_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 ) {
10ecf9: 39 50 14 cmp %edx,0x14(%eax)
10ecfc: 73 0d jae 10ed0b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10ecfe: 51 push %ecx
10ecff: 6a 01 push $0x1
10ed01: 52 push %edx
10ed02: 50 push %eax
10ed03: e8 34 cd ff ff call 10ba3c <_Thread_Change_priority>
10ed08: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10ed0b: c9 leave
10ed0c: c3 ret
0010a2ac <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
10a2ac: 55 push %ebp
10a2ad: 89 e5 mov %esp,%ebp
10a2af: 53 push %ebx
10a2b0: 83 ec 04 sub $0x4,%esp
10a2b3: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a2b6: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a2b9: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a2bd: 75 06 jne 10a2c5 <_POSIX_Timer_TSR+0x19>
10a2bf: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a2c3: 74 34 je 10a2f9 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a2c5: 83 ec 0c sub $0xc,%esp
10a2c8: 53 push %ebx
10a2c9: 68 ac a2 10 00 push $0x10a2ac
10a2ce: ff 73 08 pushl 0x8(%ebx)
10a2d1: ff 73 64 pushl 0x64(%ebx)
10a2d4: 8d 43 10 lea 0x10(%ebx),%eax
10a2d7: 50 push %eax
10a2d8: e8 d3 55 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a2dd: 83 c4 20 add $0x20,%esp
10a2e0: 84 c0 test %al,%al
10a2e2: 74 30 je 10a314 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a2e4: 83 ec 0c sub $0xc,%esp
10a2e7: 8d 43 6c lea 0x6c(%ebx),%eax
10a2ea: 50 push %eax
10a2eb: e8 50 14 00 00 call 10b740 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2f0: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a2f4: 83 c4 10 add $0x10,%esp
10a2f7: eb 04 jmp 10a2fd <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a2f9: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
10a2fd: 50 push %eax
10a2fe: 50 push %eax
10a2ff: ff 73 44 pushl 0x44(%ebx)
10a302: ff 73 38 pushl 0x38(%ebx)
10a305: e8 7a 51 00 00 call 10f484 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a30a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a311: 83 c4 10 add $0x10,%esp
}
10a314: 8b 5d fc mov -0x4(%ebp),%ebx
10a317: c9 leave
10a318: c3 ret
00110ac8 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110ac8: 55 push %ebp
110ac9: 89 e5 mov %esp,%ebp
110acb: 57 push %edi
110acc: 56 push %esi
110acd: 53 push %ebx
110ace: 83 ec 68 sub $0x68,%esp
110ad1: 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,
110ad4: 6a 01 push $0x1
110ad6: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110ada: 50 push %eax
110adb: 8d 45 dc lea -0x24(%ebp),%eax
110ade: 50 push %eax
110adf: 53 push %ebx
110ae0: ff 75 08 pushl 0x8(%ebp)
110ae3: e8 8c 00 00 00 call 110b74 <_POSIX_signals_Clear_signals>
110ae8: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110aeb: 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,
110aed: 84 c0 test %al,%al
110aef: 74 78 je 110b69 <_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 )
110af1: 6b d3 0c imul $0xc,%ebx,%edx
110af4: 8b 82 4c 48 12 00 mov 0x12484c(%edx),%eax
110afa: 83 f8 01 cmp $0x1,%eax
110afd: 74 6a je 110b69 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110aff: 8b 4d 08 mov 0x8(%ebp),%ecx
110b02: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110b08: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110b0b: 0b 8a 48 48 12 00 or 0x124848(%edx),%ecx
110b11: 8b 75 08 mov 0x8(%ebp),%esi
110b14: 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,
110b1a: 8d 7d b4 lea -0x4c(%ebp),%edi
110b1d: 8b 35 34 48 12 00 mov 0x124834,%esi
110b23: 83 c6 20 add $0x20,%esi
110b26: b9 0a 00 00 00 mov $0xa,%ecx
110b2b: 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 ) {
110b2d: 83 ba 44 48 12 00 02 cmpl $0x2,0x124844(%edx)
110b34: 75 09 jne 110b3f <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110b36: 52 push %edx
110b37: 6a 00 push $0x0
110b39: 8d 55 dc lea -0x24(%ebp),%edx
110b3c: 52 push %edx
110b3d: eb 03 jmp 110b42 <_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 );
110b3f: 83 ec 0c sub $0xc,%esp
110b42: 53 push %ebx
110b43: ff d0 call *%eax
break;
110b45: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110b48: 8b 3d 34 48 12 00 mov 0x124834,%edi
110b4e: 83 c7 20 add $0x20,%edi
110b51: 8d 75 b4 lea -0x4c(%ebp),%esi
110b54: b9 0a 00 00 00 mov $0xa,%ecx
110b59: 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;
110b5b: 8b 75 a4 mov -0x5c(%ebp),%esi
110b5e: 8b 4d 08 mov 0x8(%ebp),%ecx
110b61: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110b67: b1 01 mov $0x1,%cl
}
110b69: 88 c8 mov %cl,%al
110b6b: 8d 65 f4 lea -0xc(%ebp),%esp
110b6e: 5b pop %ebx
110b6f: 5e pop %esi
110b70: 5f pop %edi
110b71: c9 leave
110b72: c3 ret
0011105c <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
11105c: 55 push %ebp
11105d: 89 e5 mov %esp,%ebp
11105f: 53 push %ebx
111060: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
111063: 9c pushf
111064: fa cli
111065: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
111066: 6b c1 0c imul $0xc,%ecx,%eax
111069: 83 b8 44 48 12 00 02 cmpl $0x2,0x124844(%eax)
111070: 75 0e jne 111080 <_POSIX_signals_Clear_process_signals+0x24>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
111072: 8d 98 40 4a 12 00 lea 0x124a40(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111078: 39 98 3c 4a 12 00 cmp %ebx,0x124a3c(%eax)
11107e: 75 0e jne 11108e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
111080: 49 dec %ecx
111081: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
111086: d3 c0 rol %cl,%eax
111088: 21 05 38 4a 12 00 and %eax,0x124a38
}
_ISR_Enable( level );
11108e: 52 push %edx
11108f: 9d popf
}
111090: 5b pop %ebx
111091: c9 leave
111092: c3 ret
0010ab64 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10ab64: 55 push %ebp
10ab65: 89 e5 mov %esp,%ebp
10ab67: 56 push %esi
10ab68: 53 push %ebx
10ab69: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab6c: b8 1b 00 00 00 mov $0x1b,%eax
10ab71: bb 01 00 00 00 mov $0x1,%ebx
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10ab76: 8d 48 ff lea -0x1(%eax),%ecx
10ab79: 89 de mov %ebx,%esi
10ab7b: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab7d: 85 d6 test %edx,%esi
10ab7f: 75 1e jne 10ab9f <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab81: 40 inc %eax
10ab82: 83 f8 20 cmp $0x20,%eax
10ab85: 75 ef jne 10ab76 <_POSIX_signals_Get_lowest+0x12>
10ab87: b0 01 mov $0x1,%al
10ab89: bb 01 00 00 00 mov $0x1,%ebx
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10ab8e: 8d 48 ff lea -0x1(%eax),%ecx
10ab91: 89 de mov %ebx,%esi
10ab93: d3 e6 shl %cl,%esi
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab95: 85 d6 test %edx,%esi
10ab97: 75 06 jne 10ab9f <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10ab99: 40 inc %eax
10ab9a: 83 f8 1b cmp $0x1b,%eax
10ab9d: 75 ef jne 10ab8e <_POSIX_signals_Get_lowest+0x2a><== ALWAYS TAKEN
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
10ab9f: 5b pop %ebx
10aba0: 5e pop %esi
10aba1: c9 leave
10aba2: c3 ret
00121868 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
121868: 55 push %ebp
121869: 89 e5 mov %esp,%ebp
12186b: 57 push %edi
12186c: 56 push %esi
12186d: 53 push %ebx
12186e: 83 ec 0c sub $0xc,%esp
121871: 8b 5d 08 mov 0x8(%ebp),%ebx
121874: 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 ];
121877: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax
12187d: 8d 4e ff lea -0x1(%esi),%ecx
121880: ba 01 00 00 00 mov $0x1,%edx
121885: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
121887: 8b 4b 10 mov 0x10(%ebx),%ecx
12188a: 89 cf mov %ecx,%edi
12188c: 81 e7 00 80 00 10 and $0x10008000,%edi
121892: 81 ff 00 80 00 10 cmp $0x10008000,%edi
121898: 75 58 jne 1218f2 <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
12189a: 85 53 30 test %edx,0x30(%ebx)
12189d: 75 12 jne 1218b1 <_POSIX_signals_Unblock_thread+0x49>
12189f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1218a5: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
1218a7: 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) ) {
1218a9: 85 c2 test %eax,%edx
1218ab: 0f 84 b0 00 00 00 je 121961 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
1218b1: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
1218b8: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
1218bb: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1218bf: 75 12 jne 1218d3 <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
1218c1: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
1218c3: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
1218ca: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
1218d1: eb 0c jmp 1218df <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
1218d3: b9 03 00 00 00 mov $0x3,%ecx
1218d8: 89 c7 mov %eax,%edi
1218da: 8b 75 10 mov 0x10(%ebp),%esi
1218dd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
1218df: 83 ec 0c sub $0xc,%esp
1218e2: 53 push %ebx
1218e3: e8 0c f4 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy>
return true;
1218e8: 83 c4 10 add $0x10,%esp
1218eb: bf 01 00 00 00 mov $0x1,%edi
1218f0: eb 6f jmp 121961 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1218f2: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1218f8: 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;
1218fa: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1218fc: 85 c2 test %eax,%edx
1218fe: 74 61 je 121961 <_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 ) ) {
121900: f7 c1 00 00 00 10 test $0x10000000,%ecx
121906: 74 3d je 121945 <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
121908: 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) )
12190f: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
121915: 74 0b je 121922 <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
121917: 83 ec 0c sub $0xc,%esp
12191a: 53 push %ebx
12191b: e8 d4 f3 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy>
121920: eb 1e jmp 121940 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
121922: 80 e1 08 and $0x8,%cl
121925: 74 3a je 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
121927: 83 ec 0c sub $0xc,%esp
12192a: 8d 43 48 lea 0x48(%ebx),%eax
12192d: 50 push %eax
12192e: e8 4d fc fe ff call 111580 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
121933: 58 pop %eax
121934: 5a pop %edx
121935: 68 f8 ff 03 10 push $0x1003fff8
12193a: 53 push %ebx
12193b: e8 e4 e9 fe ff call 110324 <_Thread_Clear_state>
121940: 83 c4 10 add $0x10,%esp
121943: eb 1c jmp 121961 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
121945: 85 c9 test %ecx,%ecx
121947: 75 18 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
121949: 83 3d a4 a9 12 00 00 cmpl $0x0,0x12a9a4
121950: 74 0f je 121961 <_POSIX_signals_Unblock_thread+0xf9>
121952: 3b 1d a8 a9 12 00 cmp 0x12a9a8,%ebx
121958: 75 07 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
12195a: c6 05 b4 a9 12 00 01 movb $0x1,0x12a9b4
}
}
return false;
}
121961: 89 f8 mov %edi,%eax
121963: 8d 65 f4 lea -0xc(%ebp),%esp
121966: 5b pop %ebx
121967: 5e pop %esi
121968: 5f pop %edi
121969: c9 leave
12196a: c3 ret
0010b3b4 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3b4: 55 push %ebp
10b3b5: 89 e5 mov %esp,%ebp
10b3b7: 53 push %ebx
10b3b8: 83 ec 18 sub $0x18,%esp
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax
10b3be: 50 push %eax
10b3bf: ff 75 08 pushl 0x8(%ebp)
10b3c2: 68 14 73 12 00 push $0x127314
10b3c7: e8 cc 1a 00 00 call 10ce98 <_Objects_Get>
10b3cc: 89 c3 mov %eax,%ebx
switch ( location ) {
10b3ce: 83 c4 10 add $0x10,%esp
10b3d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b3d5: 75 64 jne 10b43b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b3d7: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b3da: f6 40 11 40 testb $0x40,0x11(%eax)
10b3de: 74 18 je 10b3f8 <_Rate_monotonic_Timeout+0x44>
10b3e0: 8b 53 08 mov 0x8(%ebx),%edx
10b3e3: 39 50 20 cmp %edx,0x20(%eax)
10b3e6: 75 10 jne 10b3f8 <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b3e8: 52 push %edx
10b3e9: 52 push %edx
10b3ea: 68 f8 ff 03 10 push $0x1003fff8
10b3ef: 50 push %eax
10b3f0: e8 0f 1f 00 00 call 10d304 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b3f5: 59 pop %ecx
10b3f6: eb 10 jmp 10b408 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b3f8: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b3fc: 75 2b jne 10b429 <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b3fe: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b405: 83 ec 0c sub $0xc,%esp
10b408: 53 push %ebx
10b409: e8 ec fa ff ff call 10aefa <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b40e: 8b 43 3c mov 0x3c(%ebx),%eax
10b411: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b414: 58 pop %eax
10b415: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b416: 83 c3 10 add $0x10,%ebx
10b419: 53 push %ebx
10b41a: 68 d0 74 12 00 push $0x1274d0
10b41f: e8 b8 31 00 00 call 10e5dc <_Watchdog_Insert>
10b424: 83 c4 10 add $0x10,%esp
10b427: eb 07 jmp 10b430 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b429: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b430: a1 08 74 12 00 mov 0x127408,%eax
10b435: 48 dec %eax
10b436: a3 08 74 12 00 mov %eax,0x127408
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b43b: 8b 5d fc mov -0x4(%ebp),%ebx
10b43e: c9 leave
10b43f: c3 ret
0010acb4 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10acb4: 55 push %ebp
10acb5: 89 e5 mov %esp,%ebp
10acb7: 56 push %esi
10acb8: 53 push %ebx
10acb9: 8b 4d 08 mov 0x8(%ebp),%ecx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
10acbc: 8b 35 44 42 12 00 mov 0x124244,%esi
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
10acc2: 31 db xor %ebx,%ebx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acc4: 85 c9 test %ecx,%ecx
10acc6: 74 57 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10acc8: b8 40 42 0f 00 mov $0xf4240,%eax
10accd: 31 d2 xor %edx,%edx
10accf: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acd1: 39 41 18 cmp %eax,0x18(%ecx)
10acd4: 73 49 jae 10ad1f <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10acd6: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10acda: 77 43 ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10acdc: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ace0: 77 3d ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ace2: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10ace6: 77 37 ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10ace8: 8b 41 04 mov 0x4(%ecx),%eax
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
10aceb: 85 c0 test %eax,%eax
10aced: 74 30 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10acef: 83 f8 0c cmp $0xc,%eax
10acf2: 77 2b ja 10ad1f <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10acf4: 8b 31 mov (%ecx),%esi
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
10acf6: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10acfc: 76 21 jbe 10ad1f <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10acfe: 8b 51 08 mov 0x8(%ecx),%edx
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10ad01: 85 d2 test %edx,%edx
10ad03: 74 1a je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad05: 83 e6 03 and $0x3,%esi
10ad08: 75 09 jne 10ad13 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad0a: 8b 04 85 24 14 12 00 mov 0x121424(,%eax,4),%eax
10ad11: eb 07 jmp 10ad1a <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad13: 8b 04 85 f0 13 12 00 mov 0x1213f0(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad1a: 39 c2 cmp %eax,%edx
10ad1c: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad1f: 88 d8 mov %bl,%al
10ad21: 5b pop %ebx
10ad22: 5e pop %esi
10ad23: c9 leave
10ad24: c3 ret
0010ba3c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10ba3c: 55 push %ebp
10ba3d: 89 e5 mov %esp,%ebp
10ba3f: 57 push %edi
10ba40: 56 push %esi
10ba41: 53 push %ebx
10ba42: 83 ec 28 sub $0x28,%esp
10ba45: 8b 5d 08 mov 0x8(%ebp),%ebx
10ba48: 8b 7d 0c mov 0xc(%ebp),%edi
10ba4b: 8a 45 10 mov 0x10(%ebp),%al
10ba4e: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10ba51: 8b 73 10 mov 0x10(%ebx),%esi
/*
* 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 );
10ba54: 53 push %ebx
10ba55: e8 3e 0d 00 00 call 10c798 <_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 )
10ba5a: 83 c4 10 add $0x10,%esp
10ba5d: 39 7b 14 cmp %edi,0x14(%ebx)
10ba60: 74 0c je 10ba6e <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10ba62: 50 push %eax
10ba63: 50 push %eax
10ba64: 57 push %edi
10ba65: 53 push %ebx
10ba66: e8 f5 0b 00 00 call 10c660 <_Thread_Set_priority>
10ba6b: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10ba6e: 9c pushf
10ba6f: fa cli
10ba70: 59 pop %ecx
/*
* 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;
10ba71: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10ba74: 83 f8 04 cmp $0x4,%eax
10ba77: 74 2f je 10baa8 <_Thread_Change_priority+0x6c>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10ba79: 83 e6 04 and $0x4,%esi
10ba7c: 75 08 jne 10ba86 <_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);
10ba7e: 89 c2 mov %eax,%edx
10ba80: 83 e2 fb and $0xfffffffb,%edx
10ba83: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10ba86: 51 push %ecx
10ba87: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10ba88: a9 e0 be 03 00 test $0x3bee0,%eax
10ba8d: 0f 84 c0 00 00 00 je 10bb53 <_Thread_Change_priority+0x117>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10ba93: 89 5d 0c mov %ebx,0xc(%ebp)
10ba96: 8b 43 44 mov 0x44(%ebx),%eax
10ba99: 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 );
}
10ba9c: 8d 65 f4 lea -0xc(%ebp),%esp
10ba9f: 5b pop %ebx
10baa0: 5e pop %esi
10baa1: 5f pop %edi
10baa2: 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 );
10baa3: e9 30 0b 00 00 jmp 10c5d8 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10baa8: 83 e6 04 and $0x4,%esi
10baab: 75 53 jne 10bb00 <_Thread_Change_priority+0xc4><== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10baad: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bab4: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax
10baba: 66 8b 93 96 00 00 00 mov 0x96(%ebx),%dx
10bac1: 66 09 10 or %dx,(%eax)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bac4: 66 a1 88 43 12 00 mov 0x124388,%ax
10baca: 0b 83 94 00 00 00 or 0x94(%ebx),%eax
10bad0: 66 a3 88 43 12 00 mov %ax,0x124388
_Priority_bit_map_Add( &the_thread->Priority_map );
if ( prepend_it )
10bad6: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10bada: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bae0: 74 0e je 10baf0 <_Thread_Change_priority+0xb4>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10bae2: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10bae5: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10bae7: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10bae9: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10baeb: 89 5a 04 mov %ebx,0x4(%edx)
10baee: eb 10 jmp 10bb00 <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10baf0: 8d 50 04 lea 0x4(%eax),%edx
10baf3: 89 13 mov %edx,(%ebx)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10baf5: 8b 50 08 mov 0x8(%eax),%edx
the_chain->last = the_node;
10baf8: 89 58 08 mov %ebx,0x8(%eax)
old_last_node->next = the_node;
10bafb: 89 1a mov %ebx,(%edx)
the_node->previous = old_last_node;
10bafd: 89 53 04 mov %edx,0x4(%ebx)
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
10bb00: 51 push %ecx
10bb01: 9d popf
10bb02: fa cli
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 );
10bb03: 66 8b 1d 88 43 12 00 mov 0x124388,%bx
10bb0a: 31 c0 xor %eax,%eax
10bb0c: 89 c2 mov %eax,%edx
10bb0e: 66 0f bc d3 bsf %bx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bb12: 0f b7 d2 movzwl %dx,%edx
10bb15: 66 8b 9c 12 f8 43 12 mov 0x1243f8(%edx,%edx,1),%bx
10bb1c: 00
10bb1d: 66 0f bc c3 bsf %bx,%ax
return (_Priority_Bits_index( major ) << 4) +
10bb21: c1 e2 04 shl $0x4,%edx
10bb24: 0f b7 c0 movzwl %ax,%eax
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
_Thread_Ready_chain[ _Priority_bit_map_Get_highest() ].first;
10bb27: 8d 04 02 lea (%edx,%eax,1),%eax
10bb2a: 6b c0 0c imul $0xc,%eax,%eax
10bb2d: 03 05 b0 42 12 00 add 0x1242b0,%eax
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
10bb33: 8b 10 mov (%eax),%edx
10bb35: 89 15 38 48 12 00 mov %edx,0x124838
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10bb3b: a1 34 48 12 00 mov 0x124834,%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.
*/
_Thread_Calculate_heir();
if ( !_Thread_Is_executing_also_the_heir() &&
10bb40: 39 d0 cmp %edx,%eax
10bb42: 74 0d je 10bb51 <_Thread_Change_priority+0x115>
10bb44: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bb48: 74 07 je 10bb51 <_Thread_Change_priority+0x115>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10bb4a: c6 05 40 48 12 00 01 movb $0x1,0x124840
_ISR_Enable( level );
10bb51: 51 push %ecx
10bb52: 9d popf
}
10bb53: 8d 65 f4 lea -0xc(%ebp),%esp
10bb56: 5b pop %ebx
10bb57: 5e pop %esi
10bb58: 5f pop %edi
10bb59: c9 leave
10bb5a: c3 ret
0010bb5c <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10bb5c: 55 push %ebp
10bb5d: 89 e5 mov %esp,%ebp
10bb5f: 53 push %ebx
10bb60: 8b 45 08 mov 0x8(%ebp),%eax
10bb63: 8b 55 0c mov 0xc(%ebp),%edx
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10bb66: 9c pushf
10bb67: fa cli
10bb68: 59 pop %ecx
current_state = the_thread->current_state;
10bb69: 8b 58 10 mov 0x10(%eax),%ebx
if ( current_state & state ) {
10bb6c: 85 da test %ebx,%edx
10bb6e: 74 71 je 10bbe1 <_Thread_Clear_state+0x85>
10bb70: f7 d2 not %edx
10bb72: 21 da and %ebx,%edx
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10bb74: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10bb77: 85 d2 test %edx,%edx
10bb79: 75 66 jne 10bbe1 <_Thread_Clear_state+0x85>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10bb7b: 8b 90 90 00 00 00 mov 0x90(%eax),%edx
10bb81: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx
10bb88: 66 09 1a or %bx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10bb8b: 66 8b 15 88 43 12 00 mov 0x124388,%dx
10bb92: 0b 90 94 00 00 00 or 0x94(%eax),%edx
10bb98: 66 89 15 88 43 12 00 mov %dx,0x124388
_Priority_bit_map_Add( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10bb9f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10bba5: 8d 5a 04 lea 0x4(%edx),%ebx
10bba8: 89 18 mov %ebx,(%eax)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10bbaa: 8b 5a 08 mov 0x8(%edx),%ebx
the_chain->last = the_node;
10bbad: 89 42 08 mov %eax,0x8(%edx)
old_last_node->next = the_node;
10bbb0: 89 03 mov %eax,(%ebx)
the_node->previous = old_last_node;
10bbb2: 89 58 04 mov %ebx,0x4(%eax)
_ISR_Flash( level );
10bbb5: 51 push %ecx
10bbb6: 9d popf
10bbb7: fa cli
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10bbb8: 8b 50 14 mov 0x14(%eax),%edx
10bbbb: 8b 1d 38 48 12 00 mov 0x124838,%ebx
10bbc1: 3b 53 14 cmp 0x14(%ebx),%edx
10bbc4: 73 1b jae 10bbe1 <_Thread_Clear_state+0x85>
_Thread_Heir = the_thread;
10bbc6: a3 38 48 12 00 mov %eax,0x124838
if ( _Thread_Executing->is_preemptible ||
10bbcb: a1 34 48 12 00 mov 0x124834,%eax
10bbd0: 80 78 74 00 cmpb $0x0,0x74(%eax)
10bbd4: 75 04 jne 10bbda <_Thread_Clear_state+0x7e>
10bbd6: 85 d2 test %edx,%edx
10bbd8: 75 07 jne 10bbe1 <_Thread_Clear_state+0x85><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10bbda: c6 05 40 48 12 00 01 movb $0x1,0x124840
}
}
}
_ISR_Enable( level );
10bbe1: 51 push %ecx
10bbe2: 9d popf
}
10bbe3: 5b pop %ebx
10bbe4: c9 leave
10bbe5: c3 ret
0010bd5c <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10bd5c: 55 push %ebp
10bd5d: 89 e5 mov %esp,%ebp
10bd5f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10bd62: 8d 45 f4 lea -0xc(%ebp),%eax
10bd65: 50 push %eax
10bd66: ff 75 08 pushl 0x8(%ebp)
10bd69: e8 82 01 00 00 call 10bef0 <_Thread_Get>
switch ( location ) {
10bd6e: 83 c4 10 add $0x10,%esp
10bd71: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10bd75: 75 1b jne 10bd92 <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10bd77: 52 push %edx
10bd78: 52 push %edx
10bd79: 68 18 00 00 10 push $0x10000018
10bd7e: 50 push %eax
10bd7f: e8 d8 fd ff ff call 10bb5c <_Thread_Clear_state>
10bd84: a1 e4 42 12 00 mov 0x1242e4,%eax
10bd89: 48 dec %eax
10bd8a: a3 e4 42 12 00 mov %eax,0x1242e4
10bd8f: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10bd92: c9 leave
10bd93: c3 ret
0010bd94 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10bd94: 55 push %ebp
10bd95: 89 e5 mov %esp,%ebp
10bd97: 57 push %edi
10bd98: 56 push %esi
10bd99: 53 push %ebx
10bd9a: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10bd9d: 8b 1d 34 48 12 00 mov 0x124834,%ebx
_ISR_Disable( level );
10bda3: 9c pushf
10bda4: fa cli
10bda5: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10bda6: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10bda9: e9 f9 00 00 00 jmp 10bea7 <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10bdae: 8b 35 38 48 12 00 mov 0x124838,%esi
_Thread_Dispatch_disable_level = 1;
10bdb4: c7 05 e4 42 12 00 01 movl $0x1,0x1242e4
10bdbb: 00 00 00
_Thread_Dispatch_necessary = false;
10bdbe: c6 05 40 48 12 00 00 movb $0x0,0x124840
_Thread_Executing = heir;
10bdc5: 89 35 34 48 12 00 mov %esi,0x124834
/*
* 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 )
10bdcb: 39 de cmp %ebx,%esi
10bdcd: 0f 84 e2 00 00 00 je 10beb5 <_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 )
10bdd3: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10bdd7: 75 09 jne 10bde2 <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10bdd9: 8b 15 b4 42 12 00 mov 0x1242b4,%edx
10bddf: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10bde2: 50 push %eax
10bde3: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10bde4: 83 ec 0c sub $0xc,%esp
10bde7: 8d 45 e0 lea -0x20(%ebp),%eax
10bdea: 50 push %eax
10bdeb: e8 08 36 00 00 call 10f3f8 <_TOD_Get_uptime>
_Timestamp_Subtract(
10bdf0: 83 c4 0c add $0xc,%esp
10bdf3: 57 push %edi
10bdf4: 8d 45 e0 lea -0x20(%ebp),%eax
10bdf7: 50 push %eax
10bdf8: 68 98 43 12 00 push $0x124398
10bdfd: e8 32 0c 00 00 call 10ca34 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10be02: 58 pop %eax
10be03: 5a pop %edx
10be04: 57 push %edi
10be05: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10be0b: 50 push %eax
10be0c: e8 f3 0b 00 00 call 10ca04 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10be11: 8b 45 e0 mov -0x20(%ebp),%eax
10be14: 8b 55 e4 mov -0x1c(%ebp),%edx
10be17: a3 98 43 12 00 mov %eax,0x124398
10be1c: 89 15 9c 43 12 00 mov %edx,0x12439c
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10be22: a1 6c 43 12 00 mov 0x12436c,%eax
10be27: 83 c4 10 add $0x10,%esp
10be2a: 85 c0 test %eax,%eax
10be2c: 74 10 je 10be3e <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10be2e: 8b 10 mov (%eax),%edx
10be30: 89 93 f0 00 00 00 mov %edx,0xf0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10be36: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx
10be3c: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10be3e: 51 push %ecx
10be3f: 51 push %ecx
10be40: 56 push %esi
10be41: 53 push %ebx
10be42: e8 25 0e 00 00 call 10cc6c <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10be47: 58 pop %eax
10be48: 5a pop %edx
10be49: 81 c6 d4 00 00 00 add $0xd4,%esi
10be4f: 56 push %esi
10be50: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax
10be56: 50 push %eax
10be57: e8 d4 10 00 00 call 10cf30 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10be5c: 83 c4 10 add $0x10,%esp
10be5f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10be66: 74 36 je 10be9e <_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 );
10be68: a1 68 43 12 00 mov 0x124368,%eax
10be6d: 39 c3 cmp %eax,%ebx
10be6f: 74 2d je 10be9e <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10be71: 85 c0 test %eax,%eax
10be73: 74 11 je 10be86 <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10be75: 83 ec 0c sub $0xc,%esp
10be78: 05 ec 00 00 00 add $0xec,%eax
10be7d: 50 push %eax
10be7e: e8 e1 10 00 00 call 10cf64 <_CPU_Context_save_fp>
10be83: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10be86: 83 ec 0c sub $0xc,%esp
10be89: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10be8f: 50 push %eax
10be90: e8 d9 10 00 00 call 10cf6e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10be95: 89 1d 68 43 12 00 mov %ebx,0x124368
10be9b: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10be9e: 8b 1d 34 48 12 00 mov 0x124834,%ebx
_ISR_Disable( level );
10bea4: 9c pushf
10bea5: fa cli
10bea6: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10bea7: 8a 15 40 48 12 00 mov 0x124840,%dl
10bead: 84 d2 test %dl,%dl
10beaf: 0f 85 f9 fe ff ff jne 10bdae <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10beb5: c7 05 e4 42 12 00 00 movl $0x0,0x1242e4
10bebc: 00 00 00
_ISR_Enable( level );
10bebf: 50 push %eax
10bec0: 9d popf
_API_extensions_Run_postswitch();
10bec1: e8 0d ea ff ff call 10a8d3 <_API_extensions_Run_postswitch>
}
10bec6: 8d 65 f4 lea -0xc(%ebp),%esp
10bec9: 5b pop %ebx
10beca: 5e pop %esi
10becb: 5f pop %edi
10becc: c9 leave
10becd: c3 ret
00110f10 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110f10: 55 push %ebp
110f11: 89 e5 mov %esp,%ebp
110f13: 53 push %ebx
110f14: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110f17: 8b 1d 34 48 12 00 mov 0x124834,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110f1d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
_ISR_Set_level(level);
110f23: 85 c0 test %eax,%eax
110f25: 74 03 je 110f2a <_Thread_Handler+0x1a>
110f27: fa cli
110f28: eb 01 jmp 110f2b <_Thread_Handler+0x1b>
110f2a: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110f2b: a0 a0 3f 12 00 mov 0x123fa0,%al
110f30: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110f33: 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) &&
110f3a: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
110f41: 74 24 je 110f67 <_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 );
110f43: a1 68 43 12 00 mov 0x124368,%eax
110f48: 39 c3 cmp %eax,%ebx
110f4a: 74 1b je 110f67 <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110f4c: 85 c0 test %eax,%eax
110f4e: 74 11 je 110f61 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110f50: 83 ec 0c sub $0xc,%esp
110f53: 05 ec 00 00 00 add $0xec,%eax
110f58: 50 push %eax
110f59: e8 06 c0 ff ff call 10cf64 <_CPU_Context_save_fp>
110f5e: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110f61: 89 1d 68 43 12 00 mov %ebx,0x124368
/*
* 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 );
110f67: 83 ec 0c sub $0xc,%esp
110f6a: 53 push %ebx
110f6b: e8 ac bb ff ff call 10cb1c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
110f70: e8 59 af ff ff call 10bece <_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) */ {
110f75: 83 c4 10 add $0x10,%esp
110f78: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
110f7c: 75 05 jne 110f83 <_Thread_Handler+0x73>
INIT_NAME ();
110f7e: e8 5d be 00 00 call 11cde0 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
110f83: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
110f89: 85 c0 test %eax,%eax
110f8b: 75 0b jne 110f98 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
110f8d: 83 ec 0c sub $0xc,%esp
110f90: ff b3 a8 00 00 00 pushl 0xa8(%ebx)
110f96: eb 0c jmp 110fa4 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
110f98: 48 dec %eax
110f99: 75 15 jne 110fb0 <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
110f9b: 83 ec 0c sub $0xc,%esp
110f9e: ff b3 a4 00 00 00 pushl 0xa4(%ebx)
110fa4: ff 93 9c 00 00 00 call *0x9c(%ebx)
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
110faa: 89 43 28 mov %eax,0x28(%ebx)
110fad: 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 );
110fb0: 83 ec 0c sub $0xc,%esp
110fb3: 53 push %ebx
110fb4: e8 94 bb ff ff call 10cb4d <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
110fb9: 83 c4 0c add $0xc,%esp
110fbc: 6a 05 push $0x5
110fbe: 6a 01 push $0x1
110fc0: 6a 00 push $0x0
110fc2: e8 69 a2 ff ff call 10b230 <_Internal_error_Occurred>
0010bf60 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10bf60: 55 push %ebp
10bf61: 89 e5 mov %esp,%ebp
10bf63: 57 push %edi
10bf64: 56 push %esi
10bf65: 53 push %ebx
10bf66: 83 ec 1c sub $0x1c,%esp
10bf69: 8b 5d 0c mov 0xc(%ebp),%ebx
10bf6c: 8b 4d 10 mov 0x10(%ebp),%ecx
10bf6f: 8b 75 14 mov 0x14(%ebp),%esi
10bf72: 8a 55 18 mov 0x18(%ebp),%dl
10bf75: 8a 45 20 mov 0x20(%ebp),%al
10bf78: 88 45 e7 mov %al,-0x19(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10bf7b: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
10bf82: 00 00 00
10bf85: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx)
10bf8c: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10bf8f: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10bf96: 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 ) {
10bf99: 85 c9 test %ecx,%ecx
10bf9b: 75 31 jne 10bfce <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10bf9d: 51 push %ecx
10bf9e: 51 push %ecx
10bf9f: 56 push %esi
10bfa0: 53 push %ebx
10bfa1: 88 55 e0 mov %dl,-0x20(%ebp)
10bfa4: e8 63 08 00 00 call 10c80c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10bfa9: 83 c4 10 add $0x10,%esp
10bfac: 39 f0 cmp %esi,%eax
10bfae: 8a 55 e0 mov -0x20(%ebp),%dl
10bfb1: 0f 82 c1 01 00 00 jb 10c178 <_Thread_Initialize+0x218>
10bfb7: 85 c0 test %eax,%eax
10bfb9: 0f 84 b9 01 00 00 je 10c178 <_Thread_Initialize+0x218><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10bfbf: 8b 8b d0 00 00 00 mov 0xd0(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10bfc5: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx)
10bfcc: eb 09 jmp 10bfd7 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10bfce: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx)
10bfd5: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10bfd7: 89 8b c8 00 00 00 mov %ecx,0xc8(%ebx)
the_stack->size = size;
10bfdd: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10bfe3: 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 ) {
10bfe5: 84 d2 test %dl,%dl
10bfe7: 74 17 je 10c000 <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10bfe9: 83 ec 0c sub $0xc,%esp
10bfec: 6a 6c push $0x6c
10bfee: e8 df 0e 00 00 call 10ced2 <_Workspace_Allocate>
10bff3: 89 c7 mov %eax,%edi
if ( !fp_area )
10bff5: 83 c4 10 add $0x10,%esp
10bff8: 85 c0 test %eax,%eax
10bffa: 0f 84 08 01 00 00 je 10c108 <_Thread_Initialize+0x1a8>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c000: 89 bb ec 00 00 00 mov %edi,0xec(%ebx)
the_thread->Start.fp_context = fp_area;
10c006: 89 bb cc 00 00 00 mov %edi,0xcc(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c00c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c013: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c01a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c021: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c028: a1 78 43 12 00 mov 0x124378,%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;
10c02d: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c02f: 85 c0 test %eax,%eax
10c031: 74 1d je 10c050 <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c033: 83 ec 0c sub $0xc,%esp
10c036: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c03d: 50 push %eax
10c03e: e8 8f 0e 00 00 call 10ced2 <_Workspace_Allocate>
10c043: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c045: 83 c4 10 add $0x10,%esp
10c048: 85 c0 test %eax,%eax
10c04a: 0f 84 ba 00 00 00 je 10c10a <_Thread_Initialize+0x1aa>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c050: 89 b3 fc 00 00 00 mov %esi,0xfc(%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 ) {
10c056: 85 f6 test %esi,%esi
10c058: 74 16 je 10c070 <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c05a: 8b 15 78 43 12 00 mov 0x124378,%edx
10c060: 31 c0 xor %eax,%eax
10c062: eb 08 jmp 10c06c <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c064: 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++ )
10c06b: 40 inc %eax
10c06c: 39 d0 cmp %edx,%eax
10c06e: 76 f4 jbe 10c064 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c070: 8a 45 e7 mov -0x19(%ebp),%al
10c073: 88 83 ac 00 00 00 mov %al,0xac(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c079: 8b 45 24 mov 0x24(%ebp),%eax
10c07c: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c082: 8b 45 28 mov 0x28(%ebp),%eax
10c085: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
switch ( budget_algorithm ) {
10c08b: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c08f: 75 08 jne 10c099 <_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;
10c091: a1 b4 42 12 00 mov 0x1242b4,%eax
10c096: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c099: 8b 45 2c mov 0x2c(%ebp),%eax
10c09c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
the_thread->current_state = STATES_DORMANT;
10c0a2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c0a9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c0b0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c0b7: 8b 45 1c mov 0x1c(%ebp),%eax
10c0ba: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c0bd: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
_Thread_Set_priority( the_thread, priority );
10c0c3: 52 push %edx
10c0c4: 52 push %edx
10c0c5: 50 push %eax
10c0c6: 53 push %ebx
10c0c7: e8 94 05 00 00 call 10c660 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c0cc: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c0d3: 00 00 00
10c0d6: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c0dd: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10c0e0: 8b 45 08 mov 0x8(%ebp),%eax
10c0e3: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c0e6: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c0ea: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c0ed: 8b 45 30 mov 0x30(%ebp),%eax
10c0f0: 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 );
10c0f3: 89 1c 24 mov %ebx,(%esp)
10c0f6: e8 c1 0a 00 00 call 10cbbc <_User_extensions_Thread_create>
10c0fb: 88 c2 mov %al,%dl
if ( extension_status )
10c0fd: 83 c4 10 add $0x10,%esp
return true;
10c100: 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 )
10c102: 84 d2 test %dl,%dl
10c104: 74 04 je 10c10a <_Thread_Initialize+0x1aa>
10c106: eb 72 jmp 10c17a <_Thread_Initialize+0x21a>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c108: 31 f6 xor %esi,%esi
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
if ( the_thread->libc_reent )
10c10a: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax
10c110: 85 c0 test %eax,%eax
10c112: 74 0c je 10c120 <_Thread_Initialize+0x1c0>
_Workspace_Free( the_thread->libc_reent );
10c114: 83 ec 0c sub $0xc,%esp
10c117: 50 push %eax
10c118: e8 ce 0d 00 00 call 10ceeb <_Workspace_Free>
10c11d: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10c120: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax
10c126: 85 c0 test %eax,%eax
10c128: 74 0c je 10c136 <_Thread_Initialize+0x1d6>
_Workspace_Free( the_thread->API_Extensions[i] );
10c12a: 83 ec 0c sub $0xc,%esp
10c12d: 50 push %eax
10c12e: e8 b8 0d 00 00 call 10ceeb <_Workspace_Free>
10c133: 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] )
10c136: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax
10c13c: 85 c0 test %eax,%eax
10c13e: 74 0c je 10c14c <_Thread_Initialize+0x1ec>
_Workspace_Free( the_thread->API_Extensions[i] );
10c140: 83 ec 0c sub $0xc,%esp
10c143: 50 push %eax
10c144: e8 a2 0d 00 00 call 10ceeb <_Workspace_Free>
10c149: 83 c4 10 add $0x10,%esp
if ( extensions_area )
10c14c: 85 f6 test %esi,%esi
10c14e: 74 0c je 10c15c <_Thread_Initialize+0x1fc>
(void) _Workspace_Free( extensions_area );
10c150: 83 ec 0c sub $0xc,%esp
10c153: 56 push %esi
10c154: e8 92 0d 00 00 call 10ceeb <_Workspace_Free>
10c159: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10c15c: 85 ff test %edi,%edi
10c15e: 74 0c je 10c16c <_Thread_Initialize+0x20c>
(void) _Workspace_Free( fp_area );
10c160: 83 ec 0c sub $0xc,%esp
10c163: 57 push %edi
10c164: e8 82 0d 00 00 call 10ceeb <_Workspace_Free>
10c169: 83 c4 10 add $0x10,%esp
#endif
_Thread_Stack_Free( the_thread );
10c16c: 83 ec 0c sub $0xc,%esp
10c16f: 53 push %ebx
10c170: e8 e7 06 00 00 call 10c85c <_Thread_Stack_Free>
return false;
10c175: 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 */
10c178: 31 c0 xor %eax,%eax
_Thread_Stack_Free( the_thread );
return false;
}
10c17a: 8d 65 f4 lea -0xc(%ebp),%esp
10c17d: 5b pop %ebx
10c17e: 5e pop %esi
10c17f: 5f pop %edi
10c180: c9 leave
10c181: c3 ret
0010f400 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f400: 55 push %ebp
10f401: 89 e5 mov %esp,%ebp
10f403: 53 push %ebx
10f404: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f407: 9c pushf
10f408: fa cli
10f409: 59 pop %ecx
current_state = the_thread->current_state;
10f40a: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f40d: f6 c2 02 test $0x2,%dl
10f410: 74 70 je 10f482 <_Thread_Resume+0x82> <== NEVER TAKEN
10f412: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f415: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f418: 85 d2 test %edx,%edx
10f41a: 75 66 jne 10f482 <_Thread_Resume+0x82>
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10f41c: 8b 90 90 00 00 00 mov 0x90(%eax),%edx
10f422: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx
10f429: 66 09 1a or %bx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10f42c: 66 8b 15 50 74 12 00 mov 0x127450,%dx
10f433: 0b 90 94 00 00 00 or 0x94(%eax),%edx
10f439: 66 89 15 50 74 12 00 mov %dx,0x127450
_Priority_bit_map_Add( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10f440: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10f446: 8d 5a 04 lea 0x4(%edx),%ebx
10f449: 89 18 mov %ebx,(%eax)
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
10f44b: 8b 5a 08 mov 0x8(%edx),%ebx
the_chain->last = the_node;
10f44e: 89 42 08 mov %eax,0x8(%edx)
old_last_node->next = the_node;
10f451: 89 03 mov %eax,(%ebx)
the_node->previous = old_last_node;
10f453: 89 58 04 mov %ebx,0x4(%eax)
_ISR_Flash( level );
10f456: 51 push %ecx
10f457: 9d popf
10f458: fa cli
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10f459: 8b 50 14 mov 0x14(%eax),%edx
10f45c: 8b 1d 00 79 12 00 mov 0x127900,%ebx
10f462: 3b 53 14 cmp 0x14(%ebx),%edx
10f465: 73 1b jae 10f482 <_Thread_Resume+0x82>
_Thread_Heir = the_thread;
10f467: a3 00 79 12 00 mov %eax,0x127900
if ( _Thread_Executing->is_preemptible ||
10f46c: a1 fc 78 12 00 mov 0x1278fc,%eax
10f471: 80 78 74 00 cmpb $0x0,0x74(%eax)
10f475: 75 04 jne 10f47b <_Thread_Resume+0x7b>
10f477: 85 d2 test %edx,%edx
10f479: 75 07 jne 10f482 <_Thread_Resume+0x82> <== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10f47b: c6 05 08 79 12 00 01 movb $0x1,0x127908
}
}
}
_ISR_Enable( level );
10f482: 51 push %ecx
10f483: 9d popf
}
10f484: 5b pop %ebx
10f485: c9 leave
10f486: c3 ret
0010c944 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10c944: 55 push %ebp
10c945: 89 e5 mov %esp,%ebp
10c947: 53 push %ebx
10c948: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10c94b: 8b 1d 34 48 12 00 mov 0x124834,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10c951: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10c955: 74 4c je 10c9a3 <_Thread_Tickle_timeslice+0x5f>
return;
if ( !_States_Is_ready( executing->current_state ) )
10c957: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10c95b: 75 46 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10c95d: 8b 43 7c mov 0x7c(%ebx),%eax
10c960: 83 f8 01 cmp $0x1,%eax
10c963: 72 3e jb 10c9a3 <_Thread_Tickle_timeslice+0x5f>
10c965: 83 f8 02 cmp $0x2,%eax
10c968: 76 07 jbe 10c971 <_Thread_Tickle_timeslice+0x2d>
10c96a: 83 f8 03 cmp $0x3,%eax
10c96d: 75 34 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
10c96f: eb 1a jmp 10c98b <_Thread_Tickle_timeslice+0x47>
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 ) {
10c971: 8b 43 78 mov 0x78(%ebx),%eax
10c974: 48 dec %eax
10c975: 89 43 78 mov %eax,0x78(%ebx)
10c978: 85 c0 test %eax,%eax
10c97a: 7f 27 jg 10c9a3 <_Thread_Tickle_timeslice+0x5f>
* at the priority of the currently executing thread, then the
* 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.
*/
_Thread_Yield_processor();
10c97c: e8 27 00 00 00 call 10c9a8 <_Thread_Yield_processor>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c981: a1 b4 42 12 00 mov 0x1242b4,%eax
10c986: 89 43 78 mov %eax,0x78(%ebx)
10c989: eb 18 jmp 10c9a3 <_Thread_Tickle_timeslice+0x5f>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10c98b: 8b 43 78 mov 0x78(%ebx),%eax
10c98e: 48 dec %eax
10c98f: 89 43 78 mov %eax,0x78(%ebx)
10c992: 85 c0 test %eax,%eax
10c994: 75 0d jne 10c9a3 <_Thread_Tickle_timeslice+0x5f>
(*executing->budget_callout)( executing );
10c996: 83 ec 0c sub $0xc,%esp
10c999: 53 push %ebx
10c99a: ff 93 80 00 00 00 call *0x80(%ebx)
10c9a0: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10c9a3: 8b 5d fc mov -0x4(%ebp),%ebx
10c9a6: c9 leave
10c9a7: c3 ret
0010c3e0 <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
10c3e0: 55 push %ebp
10c3e1: 89 e5 mov %esp,%ebp
10c3e3: 57 push %edi
10c3e4: 56 push %esi
10c3e5: 53 push %ebx
10c3e6: 83 ec 14 sub $0x14,%esp
10c3e9: 8b 4d 08 mov 0x8(%ebp),%ecx
10c3ec: 8b 45 0c mov 0xc(%ebp),%eax
10c3ef: 8d 50 3c lea 0x3c(%eax),%edx
10c3f2: 89 50 38 mov %edx,0x38(%eax)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
10c3f5: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax)
Chain_Node *previous_node;
Chain_Node *search_node;
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
10c3fc: 8d 50 38 lea 0x38(%eax),%edx
10c3ff: 89 50 40 mov %edx,0x40(%eax)
priority = the_thread->current_priority;
10c402: 8b 58 14 mov 0x14(%eax),%ebx
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
10c405: 89 df mov %ebx,%edi
10c407: c1 ef 06 shr $0x6,%edi
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
10c40a: 6b ff 0c imul $0xc,%edi,%edi
10c40d: 8d 3c 39 lea (%ecx,%edi,1),%edi
10c410: 89 7d ec mov %edi,-0x14(%ebp)
block_state = the_thread_queue->state;
10c413: 8b 51 38 mov 0x38(%ecx),%edx
10c416: 89 55 e4 mov %edx,-0x1c(%ebp)
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
10c419: 89 7d e8 mov %edi,-0x18(%ebp)
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
10c41c: f6 c3 20 test $0x20,%bl
10c41f: 75 73 jne 10c494 <_Thread_queue_Enqueue_priority+0xb4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10c421: 8d 77 04 lea 0x4(%edi),%esi
10c424: 89 75 e8 mov %esi,-0x18(%ebp)
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10c427: 9c pushf
10c428: fa cli
10c429: 8f 45 f0 popl -0x10(%ebp)
10c42c: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) header->first;
10c42f: 8b 17 mov (%edi),%edx
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10c431: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp)
10c438: 89 75 e0 mov %esi,-0x20(%ebp)
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c43b: eb 1f jmp 10c45c <_Thread_queue_Enqueue_priority+0x7c>
search_priority = search_thread->current_priority;
10c43d: 8b 72 14 mov 0x14(%edx),%esi
10c440: 89 75 ec mov %esi,-0x14(%ebp)
if ( priority <= search_priority )
10c443: 39 f3 cmp %esi,%ebx
10c445: 76 1a jbe 10c461 <_Thread_queue_Enqueue_priority+0x81>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10c447: ff 75 f0 pushl -0x10(%ebp)
10c44a: 9d popf
10c44b: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c44c: 8b 75 e4 mov -0x1c(%ebp),%esi
10c44f: 85 72 10 test %esi,0x10(%edx)
10c452: 75 06 jne 10c45a <_Thread_queue_Enqueue_priority+0x7a><== ALWAYS TAKEN
_ISR_Enable( level );
10c454: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10c457: 9d popf <== NOT EXECUTED
goto restart_forward_search;
10c458: eb cd jmp 10c427 <_Thread_queue_Enqueue_priority+0x47><== NOT EXECUTED
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10c45a: 8b 12 mov (%edx),%edx
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c45c: 3b 55 e8 cmp -0x18(%ebp),%edx
10c45f: 75 dc jne 10c43d <_Thread_queue_Enqueue_priority+0x5d>
10c461: 8b 75 e0 mov -0x20(%ebp),%esi
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10c464: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c468: 0f 85 ae 00 00 00 jne 10c51c <_Thread_queue_Enqueue_priority+0x13c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c46e: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c475: 3b 5d ec cmp -0x14(%ebp),%ebx
10c478: 0f 84 87 00 00 00 je 10c505 <_Thread_queue_Enqueue_priority+0x125>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10c47e: 8b 5a 04 mov 0x4(%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c481: 89 10 mov %edx,(%eax)
the_node->previous = previous_node;
10c483: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c486: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c488: 89 42 04 mov %eax,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c48b: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c48e: ff 75 f0 pushl -0x10(%ebp)
10c491: 9d popf
10c492: eb 6a jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10c494: 0f b6 3d f4 01 12 00 movzbl 0x1201f4,%edi
10c49b: 47 inc %edi
10c49c: 89 7d e0 mov %edi,-0x20(%ebp)
_ISR_Disable( level );
10c49f: 9c pushf
10c4a0: fa cli
10c4a1: 8f 45 f0 popl -0x10(%ebp)
10c4a4: 8b 75 f0 mov -0x10(%ebp),%esi
search_thread = (Thread_Control *) header->last;
10c4a7: 8b 7d e8 mov -0x18(%ebp),%edi
10c4aa: 8b 57 08 mov 0x8(%edi),%edx
10c4ad: 8b 7d e0 mov -0x20(%ebp),%edi
10c4b0: 89 75 e0 mov %esi,-0x20(%ebp)
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c4b3: eb 1d jmp 10c4d2 <_Thread_queue_Enqueue_priority+0xf2>
search_priority = search_thread->current_priority;
10c4b5: 8b 7a 14 mov 0x14(%edx),%edi
if ( priority >= search_priority )
10c4b8: 39 fb cmp %edi,%ebx
10c4ba: 73 1b jae 10c4d7 <_Thread_queue_Enqueue_priority+0xf7>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10c4bc: ff 75 f0 pushl -0x10(%ebp)
10c4bf: 9d popf
10c4c0: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c4c1: 8b 75 e4 mov -0x1c(%ebp),%esi
10c4c4: 85 72 10 test %esi,0x10(%edx)
10c4c7: 75 06 jne 10c4cf <_Thread_queue_Enqueue_priority+0xef>
_ISR_Enable( level );
10c4c9: ff 75 f0 pushl -0x10(%ebp)
10c4cc: 9d popf
goto restart_reverse_search;
10c4cd: eb c5 jmp 10c494 <_Thread_queue_Enqueue_priority+0xb4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10c4cf: 8b 52 04 mov 0x4(%edx),%edx
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c4d2: 3b 55 ec cmp -0x14(%ebp),%edx
10c4d5: 75 de jne 10c4b5 <_Thread_queue_Enqueue_priority+0xd5>
10c4d7: 8b 75 e0 mov -0x20(%ebp),%esi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10c4da: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c4de: 75 3c jne 10c51c <_Thread_queue_Enqueue_priority+0x13c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c4e0: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c4e7: 39 fb cmp %edi,%ebx
10c4e9: 74 1a je 10c505 <_Thread_queue_Enqueue_priority+0x125>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10c4eb: 8b 1a mov (%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10c4ed: 89 18 mov %ebx,(%eax)
the_node->previous = search_node;
10c4ef: 89 50 04 mov %edx,0x4(%eax)
search_node->next = the_node;
10c4f2: 89 02 mov %eax,(%edx)
next_node->previous = the_node;
10c4f4: 89 43 04 mov %eax,0x4(%ebx)
the_thread->Wait.queue = the_thread_queue;
10c4f7: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c4fa: ff 75 f0 pushl -0x10(%ebp)
10c4fd: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c4fe: b8 01 00 00 00 mov $0x1,%eax
10c503: eb 1f jmp 10c524 <_Thread_queue_Enqueue_priority+0x144>
10c505: 83 c2 3c add $0x3c,%edx
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10c508: 8b 5a 04 mov 0x4(%edx),%ebx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c50b: 89 10 mov %edx,(%eax)
the_node->previous = previous_node;
10c50d: 89 58 04 mov %ebx,0x4(%eax)
previous_node->next = the_node;
10c510: 89 03 mov %eax,(%ebx)
search_node->previous = the_node;
10c512: 89 42 04 mov %eax,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c515: 89 48 44 mov %ecx,0x44(%eax)
_ISR_Enable( level );
10c518: 56 push %esi
10c519: 9d popf
10c51a: eb e2 jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
10c51c: 8b 45 10 mov 0x10(%ebp),%eax
10c51f: 89 30 mov %esi,(%eax)
return the_thread_queue->sync_state;
10c521: 8b 41 30 mov 0x30(%ecx),%eax
}
10c524: 83 c4 14 add $0x14,%esp
10c527: 5b pop %ebx
10c528: 5e pop %esi
10c529: 5f pop %edi
10c52a: c9 leave
10c52b: c3 ret
0010c5d8 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c5d8: 55 push %ebp
10c5d9: 89 e5 mov %esp,%ebp
10c5db: 57 push %edi
10c5dc: 56 push %esi
10c5dd: 53 push %ebx
10c5de: 83 ec 1c sub $0x1c,%esp
10c5e1: 8b 75 08 mov 0x8(%ebp),%esi
10c5e4: 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 )
10c5e7: 85 f6 test %esi,%esi
10c5e9: 74 36 je 10c621 <_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 ) {
10c5eb: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c5ef: 75 30 jne 10c621 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c5f1: 9c pushf
10c5f2: fa cli
10c5f3: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c5f4: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c5fb: 74 22 je 10c61f <_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;
10c5fd: 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 );
10c604: 50 push %eax
10c605: 6a 01 push $0x1
10c607: 57 push %edi
10c608: 56 push %esi
10c609: e8 82 32 00 00 call 10f890 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c60e: 83 c4 0c add $0xc,%esp
10c611: 8d 45 e4 lea -0x1c(%ebp),%eax
10c614: 50 push %eax
10c615: 57 push %edi
10c616: 56 push %esi
10c617: e8 c4 fd ff ff call 10c3e0 <_Thread_queue_Enqueue_priority>
10c61c: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c61f: 53 push %ebx
10c620: 9d popf
}
}
10c621: 8d 65 f4 lea -0xc(%ebp),%esp
10c624: 5b pop %ebx
10c625: 5e pop %esi
10c626: 5f pop %edi
10c627: c9 leave
10c628: c3 ret
0010c62c <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c62c: 55 push %ebp
10c62d: 89 e5 mov %esp,%ebp
10c62f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c632: 8d 45 f4 lea -0xc(%ebp),%eax
10c635: 50 push %eax
10c636: ff 75 08 pushl 0x8(%ebp)
10c639: e8 b2 f8 ff ff call 10bef0 <_Thread_Get>
switch ( location ) {
10c63e: 83 c4 10 add $0x10,%esp
10c641: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c645: 75 17 jne 10c65e <_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 );
10c647: 83 ec 0c sub $0xc,%esp
10c64a: 50 push %eax
10c64b: e8 f4 32 00 00 call 10f944 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c650: a1 e4 42 12 00 mov 0x1242e4,%eax
10c655: 48 dec %eax
10c656: a3 e4 42 12 00 mov %eax,0x1242e4
10c65b: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c65e: c9 leave
10c65f: c3 ret
0011696c <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
11696c: 55 push %ebp
11696d: 89 e5 mov %esp,%ebp
11696f: 57 push %edi
116970: 56 push %esi
116971: 53 push %ebx
116972: 83 ec 4c sub $0x4c,%esp
116975: 8b 5d 08 mov 0x8(%ebp),%ebx
116978: 8d 45 dc lea -0x24(%ebp),%eax
11697b: 8d 55 e0 lea -0x20(%ebp),%edx
11697e: 89 55 b4 mov %edx,-0x4c(%ebp)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
116981: 89 55 dc mov %edx,-0x24(%ebp)
the_chain->permanent_null = NULL;
116984: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
Timer_server_Control *ts = (Timer_server_Control *) arg;
Chain_Control insert_chain;
Chain_Control fire_chain;
_Chain_Initialize_empty( &insert_chain );
11698b: 89 45 e4 mov %eax,-0x1c(%ebp)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
11698e: 8d 7d d0 lea -0x30(%ebp),%edi
116991: 8d 55 d4 lea -0x2c(%ebp),%edx
116994: 89 55 b0 mov %edx,-0x50(%ebp)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
116997: 89 55 d0 mov %edx,-0x30(%ebp)
the_chain->permanent_null = NULL;
11699a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
the_chain->last = _Chain_Head(the_chain);
1169a1: 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 );
1169a4: 8d 43 30 lea 0x30(%ebx),%eax
1169a7: 89 45 c0 mov %eax,-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 );
1169aa: 8d 73 68 lea 0x68(%ebx),%esi
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
1169ad: 8d 53 08 lea 0x8(%ebx),%edx
1169b0: 89 55 bc mov %edx,-0x44(%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;
1169b3: 8d 4d dc lea -0x24(%ebp),%ecx
1169b6: 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;
1169b9: a1 f0 d7 13 00 mov 0x13d7f0,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169be: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
1169c1: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169c4: 51 push %ecx
1169c5: 8d 4d d0 lea -0x30(%ebp),%ecx
1169c8: 51 push %ecx
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 a0 39 00 00 call 11a374 <_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 44 d7 13 00 mov 0x13d744,%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 13 jbe 1169fa <_Timer_server_Body+0x8e>
/*
* 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: 8d 55 d0 lea -0x30(%ebp),%edx
1169eb: 52 push %edx
if ( snapshot > last_snapshot ) {
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
1169ec: 8b 4d c4 mov -0x3c(%ebp),%ecx
1169ef: 29 c1 sub %eax,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169f1: 51 push %ecx
1169f2: 56 push %esi
1169f3: e8 7c 39 00 00 call 11a374 <_Watchdog_Adjust_to_chain>
1169f8: eb 0f jmp 116a09 <_Timer_server_Body+0x9d>
} else if ( snapshot < last_snapshot ) {
1169fa: 73 10 jae 116a0c <_Timer_server_Body+0xa0>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169fc: 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;
1169fd: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
116a00: 50 push %eax
116a01: 6a 01 push $0x1
116a03: 56 push %esi
116a04: e8 ff 38 00 00 call 11a308 <_Watchdog_Adjust>
116a09: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a0c: 8b 45 c4 mov -0x3c(%ebp),%eax
116a0f: 89 43 74 mov %eax,0x74(%ebx)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
116a12: 8b 43 78 mov 0x78(%ebx),%eax
116a15: 83 ec 0c sub $0xc,%esp
116a18: 50 push %eax
116a19: e8 ea 08 00 00 call 117308 <_Chain_Get>
if ( timer == NULL ) {
116a1e: 83 c4 10 add $0x10,%esp
116a21: 85 c0 test %eax,%eax
116a23: 74 29 je 116a4e <_Timer_server_Body+0xe2>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116a25: 8b 50 38 mov 0x38(%eax),%edx
116a28: 83 fa 01 cmp $0x1,%edx
116a2b: 75 0b jne 116a38 <_Timer_server_Body+0xcc>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a2d: 52 push %edx
116a2e: 52 push %edx
116a2f: 83 c0 10 add $0x10,%eax
116a32: 50 push %eax
116a33: ff 75 c0 pushl -0x40(%ebp)
116a36: eb 0c jmp 116a44 <_Timer_server_Body+0xd8>
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a38: 83 fa 03 cmp $0x3,%edx
116a3b: 75 d5 jne 116a12 <_Timer_server_Body+0xa6><== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a3d: 51 push %ecx
116a3e: 51 push %ecx
116a3f: 83 c0 10 add $0x10,%eax
116a42: 50 push %eax
116a43: 56 push %esi
116a44: e8 b3 39 00 00 call 11a3fc <_Watchdog_Insert>
116a49: 83 c4 10 add $0x10,%esp
116a4c: eb c4 jmp 116a12 <_Timer_server_Body+0xa6>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
116a4e: 9c pushf
116a4f: fa cli
116a50: 5a pop %edx
tmp = ts->insert_chain;
116a51: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a54: b0 01 mov $0x1,%al
116a56: 8b 4d b4 mov -0x4c(%ebp),%ecx
116a59: 39 4d dc cmp %ecx,-0x24(%ebp)
116a5c: 75 09 jne 116a67 <_Timer_server_Body+0xfb>
ts->insert_chain = NULL;
116a5e: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116a65: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116a67: 52 push %edx
116a68: 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 ) {
116a69: 84 c0 test %al,%al
116a6b: 0f 85 48 ff ff ff jne 1169b9 <_Timer_server_Body+0x4d>
_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: 8b 45 b0 mov -0x50(%ebp),%eax
116a74: 39 45 d0 cmp %eax,-0x30(%ebp)
116a77: 74 37 je 116ab0 <_Timer_server_Body+0x144>
/*
* 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: 5a pop %edx
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
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+0x13d>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
116a84: 8b 08 mov (%eax),%ecx
the_chain->first = new_first;
116a86: 89 4d d0 mov %ecx,-0x30(%ebp)
new_first->previous = _Chain_Head(the_chain);
116a89: 89 79 04 mov %edi,0x4(%ecx)
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+0x13d><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116a97: 52 push %edx
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+0x10d>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
116aa9: 52 push %edx
116aaa: 9d popf
116aab: e9 03 ff ff ff jmp 1169b3 <_Timer_server_Body+0x47>
* 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 17 fe ff ff call 1168d0 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116ab9: 50 push %eax
116aba: 50 push %eax
116abb: 6a 08 push $0x8
116abd: ff 33 pushl (%ebx)
116abf: e8 18 31 00 00 call 119bdc <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116ac4: 89 d8 mov %ebx,%eax
116ac6: e8 15 fe ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116acb: 89 d8 mov %ebx,%eax
116acd: e8 54 fe ff ff call 116926 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116ad2: e8 ff 27 00 00 call 1192d6 <_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: 59 pop %ecx
116adc: ff 75 bc pushl -0x44(%ebp)
116adf: e8 30 3a 00 00 call 11a514 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116ae4: 8d 43 40 lea 0x40(%ebx),%eax
116ae7: 89 04 24 mov %eax,(%esp)
116aea: e8 25 3a 00 00 call 11a514 <_Watchdog_Remove>
116aef: 83 c4 10 add $0x10,%esp
116af2: e9 bc fe ff ff jmp 1169b3 <_Timer_server_Body+0x47>
00116af7 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116af7: 55 push %ebp
116af8: 89 e5 mov %esp,%ebp
116afa: 57 push %edi
116afb: 56 push %esi
116afc: 53 push %ebx
116afd: 83 ec 2c sub $0x2c,%esp
116b00: 8b 5d 08 mov 0x8(%ebp),%ebx
116b03: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b06: 8b 43 78 mov 0x78(%ebx),%eax
116b09: 85 c0 test %eax,%eax
116b0b: 0f 85 de 00 00 00 jne 116bef <_Timer_server_Schedule_operation_method+0xf8>
* 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();
116b11: e8 ba fd ff ff call 1168d0 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b16: 8b 46 38 mov 0x38(%esi),%eax
116b19: 83 f8 01 cmp $0x1,%eax
116b1c: 75 5a jne 116b78 <_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 );
116b1e: 9c pushf
116b1f: fa cli
116b20: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b23: 8b 15 f0 d7 13 00 mov 0x13d7f0,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b29: 8b 4b 3c mov 0x3c(%ebx),%ecx
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
116b2c: 8b 43 30 mov 0x30(%ebx),%eax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
116b2f: 8d 7b 34 lea 0x34(%ebx),%edi
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
116b32: 39 f8 cmp %edi,%eax
116b34: 74 19 je 116b4f <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b36: 89 d7 mov %edx,%edi
116b38: 29 cf sub %ecx,%edi
116b3a: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b3d: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b40: 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) {
116b42: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b45: 76 05 jbe 116b4c <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b47: 89 f9 mov %edi,%ecx
116b49: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b4c: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b4f: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116b52: ff 75 e0 pushl -0x20(%ebp)
116b55: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116b56: 50 push %eax
116b57: 50 push %eax
116b58: 83 c6 10 add $0x10,%esi
116b5b: 56 push %esi
116b5c: 8d 43 30 lea 0x30(%ebx),%eax
116b5f: 50 push %eax
116b60: e8 97 38 00 00 call 11a3fc <_Watchdog_Insert>
if ( !ts->active ) {
116b65: 8a 43 7c mov 0x7c(%ebx),%al
116b68: 83 c4 10 add $0x10,%esp
116b6b: 84 c0 test %al,%al
116b6d: 75 74 jne 116be3 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116b6f: 89 d8 mov %ebx,%eax
116b71: e8 6a fd ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog>
116b76: eb 6b jmp 116be3 <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116b78: 83 f8 03 cmp $0x3,%eax
116b7b: 75 66 jne 116be3 <_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 );
116b7d: 9c pushf
116b7e: fa cli
116b7f: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116b82: 8b 15 44 d7 13 00 mov 0x13d744,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116b88: 8b 43 74 mov 0x74(%ebx),%eax
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
116b8b: 8b 4b 68 mov 0x68(%ebx),%ecx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
116b8e: 8d 7b 6c lea 0x6c(%ebx),%edi
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
116b91: 39 f9 cmp %edi,%ecx
116b93: 74 27 je 116bbc <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116b95: 8b 79 10 mov 0x10(%ecx),%edi
116b98: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116b9b: 39 c2 cmp %eax,%edx
116b9d: 76 15 jbe 116bb4 <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116b9f: 89 d7 mov %edx,%edi
116ba1: 29 c7 sub %eax,%edi
116ba3: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116ba6: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116ba8: 39 7d d4 cmp %edi,-0x2c(%ebp)
116bab: 76 0c jbe 116bb9 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116bad: 8b 45 d4 mov -0x2c(%ebp),%eax
116bb0: 29 f8 sub %edi,%eax
116bb2: eb 05 jmp 116bb9 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116bb4: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116bb7: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116bb9: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116bbc: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116bbf: ff 75 e0 pushl -0x20(%ebp)
116bc2: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116bc3: 57 push %edi
116bc4: 57 push %edi
116bc5: 83 c6 10 add $0x10,%esi
116bc8: 56 push %esi
116bc9: 8d 43 68 lea 0x68(%ebx),%eax
116bcc: 50 push %eax
116bcd: e8 2a 38 00 00 call 11a3fc <_Watchdog_Insert>
if ( !ts->active ) {
116bd2: 8a 43 7c mov 0x7c(%ebx),%al
116bd5: 83 c4 10 add $0x10,%esp
116bd8: 84 c0 test %al,%al
116bda: 75 07 jne 116be3 <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116bdc: 89 d8 mov %ebx,%eax
116bde: e8 43 fd ff ff call 116926 <_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 );
}
}
116be3: 8d 65 f4 lea -0xc(%ebp),%esp
116be6: 5b pop %ebx
116be7: 5e pop %esi
116be8: 5f pop %edi
116be9: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116bea: e9 e7 26 00 00 jmp 1192d6 <_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 );
116bef: 8b 43 78 mov 0x78(%ebx),%eax
116bf2: 89 75 0c mov %esi,0xc(%ebp)
116bf5: 89 45 08 mov %eax,0x8(%ebp)
}
}
116bf8: 8d 65 f4 lea -0xc(%ebp),%esp
116bfb: 5b pop %ebx
116bfc: 5e pop %esi
116bfd: 5f pop %edi
116bfe: c9 leave
* 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 );
116bff: e9 c8 06 00 00 jmp 1172cc <_Chain_Append>
0010cb7f <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cb7f: 55 push %ebp
10cb80: 89 e5 mov %esp,%ebp
10cb82: 57 push %edi
10cb83: 56 push %esi
10cb84: 53 push %ebx
10cb85: 83 ec 0c sub $0xc,%esp
10cb88: 8b 7d 10 mov 0x10(%ebp),%edi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cb8b: 8b 1d e0 44 12 00 mov 0x1244e0,%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 );
10cb91: 0f b6 75 0c movzbl 0xc(%ebp),%esi
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cb95: eb 15 jmp 10cbac <_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 )
10cb97: 8b 43 30 mov 0x30(%ebx),%eax
10cb9a: 85 c0 test %eax,%eax
10cb9c: 74 0b je 10cba9 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cb9e: 52 push %edx
10cb9f: 57 push %edi
10cba0: 56 push %esi
10cba1: ff 75 08 pushl 0x8(%ebp)
10cba4: ff d0 call *%eax
10cba6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10cba9: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10cbac: 81 fb d8 44 12 00 cmp $0x1244d8,%ebx
10cbb2: 75 e3 jne 10cb97 <_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 );
}
}
10cbb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cbb7: 5b pop %ebx <== NOT EXECUTED
10cbb8: 5e pop %esi <== NOT EXECUTED
10cbb9: 5f pop %edi <== NOT EXECUTED
10cbba: c9 leave <== NOT EXECUTED
10cbbb: c3 ret <== NOT EXECUTED
0010ca68 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10ca68: 55 push %ebp
10ca69: 89 e5 mov %esp,%ebp
10ca6b: 57 push %edi
10ca6c: 56 push %esi
10ca6d: 53 push %ebx
10ca6e: 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;
10ca71: a1 30 02 12 00 mov 0x120230,%eax
10ca76: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10ca79: 8b 35 34 02 12 00 mov 0x120234,%esi
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10ca7f: c7 05 d8 44 12 00 dc movl $0x1244dc,0x1244d8
10ca86: 44 12 00
the_chain->permanent_null = NULL;
10ca89: c7 05 dc 44 12 00 00 movl $0x0,0x1244dc
10ca90: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10ca93: c7 05 e0 44 12 00 d8 movl $0x1244d8,0x1244e0
10ca9a: 44 12 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10ca9d: c7 05 e8 42 12 00 ec movl $0x1242ec,0x1242e8
10caa4: 42 12 00
the_chain->permanent_null = NULL;
10caa7: c7 05 ec 42 12 00 00 movl $0x0,0x1242ec
10caae: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10cab1: c7 05 f0 42 12 00 e8 movl $0x1242e8,0x1242f0
10cab8: 42 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cabb: 85 f6 test %esi,%esi
10cabd: 74 53 je 10cb12 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cabf: 6b c8 34 imul $0x34,%eax,%ecx
10cac2: 83 ec 0c sub $0xc,%esp
10cac5: 51 push %ecx
10cac6: 89 4d e0 mov %ecx,-0x20(%ebp)
10cac9: e8 32 04 00 00 call 10cf00 <_Workspace_Allocate_or_fatal_error>
10cace: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cad0: 31 c0 xor %eax,%eax
10cad2: 8b 4d e0 mov -0x20(%ebp),%ecx
10cad5: 89 df mov %ebx,%edi
10cad7: f3 aa rep stos %al,%es:(%edi)
10cad9: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cadb: 83 c4 10 add $0x10,%esp
10cade: 31 d2 xor %edx,%edx
10cae0: eb 2b jmp 10cb0d <_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;
10cae2: 8d 7b 14 lea 0x14(%ebx),%edi
10cae5: 89 c6 mov %eax,%esi
10cae7: b9 08 00 00 00 mov $0x8,%ecx
10caec: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10caee: 83 ec 0c sub $0xc,%esp
10caf1: 53 push %ebx
10caf2: 89 45 dc mov %eax,-0x24(%ebp)
10caf5: 89 55 e0 mov %edx,-0x20(%ebp)
10caf8: e8 43 30 00 00 call 10fb40 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cafd: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cb00: 8b 55 e0 mov -0x20(%ebp),%edx
10cb03: 42 inc %edx
10cb04: 8b 45 dc mov -0x24(%ebp),%eax
10cb07: 83 c0 20 add $0x20,%eax
10cb0a: 83 c4 10 add $0x10,%esp
10cb0d: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cb10: 72 d0 jb 10cae2 <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cb12: 8d 65 f4 lea -0xc(%ebp),%esp
10cb15: 5b pop %ebx
10cb16: 5e pop %esi
10cb17: 5f pop %edi
10cb18: c9 leave
10cb19: c3 ret
0010e4b0 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e4b0: 55 push %ebp
10e4b1: 89 e5 mov %esp,%ebp
10e4b3: 57 push %edi
10e4b4: 56 push %esi
10e4b5: 53 push %ebx
10e4b6: 83 ec 1c sub $0x1c,%esp
10e4b9: 8b 75 08 mov 0x8(%ebp),%esi
10e4bc: 8b 7d 0c mov 0xc(%ebp),%edi
10e4bf: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e4c2: 9c pushf
10e4c3: fa cli
10e4c4: 58 pop %eax
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10e4c5: 8b 16 mov (%esi),%edx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10e4c7: 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 ) ) {
10e4ca: 39 ca cmp %ecx,%edx
10e4cc: 74 44 je 10e512 <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e4ce: 85 ff test %edi,%edi
10e4d0: 74 3c je 10e50e <_Watchdog_Adjust+0x5e>
10e4d2: 4f dec %edi
10e4d3: 75 3d jne 10e512 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e4d5: 01 5a 10 add %ebx,0x10(%edx)
break;
10e4d8: eb 38 jmp 10e512 <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
10e4da: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e4dc: 8b 7a 10 mov 0x10(%edx),%edi
10e4df: 39 fb cmp %edi,%ebx
10e4e1: 73 07 jae 10e4ea <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e4e3: 29 df sub %ebx,%edi
10e4e5: 89 7a 10 mov %edi,0x10(%edx)
break;
10e4e8: eb 28 jmp 10e512 <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e4ea: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e4f1: 50 push %eax
10e4f2: 9d popf
_Watchdog_Tickle( header );
10e4f3: 83 ec 0c sub $0xc,%esp
10e4f6: 56 push %esi
10e4f7: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e4fa: e8 9d 01 00 00 call 10e69c <_Watchdog_Tickle>
_ISR_Disable( level );
10e4ff: 9c pushf
10e500: fa cli
10e501: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e502: 83 c4 10 add $0x10,%esp
10e505: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e508: 39 0e cmp %ecx,(%esi)
10e50a: 74 06 je 10e512 <_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;
10e50c: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e50e: 85 db test %ebx,%ebx
10e510: 75 c8 jne 10e4da <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e512: 50 push %eax
10e513: 9d popf
}
10e514: 8d 65 f4 lea -0xc(%ebp),%esp
10e517: 5b pop %ebx
10e518: 5e pop %esi
10e519: 5f pop %edi
10e51a: c9 leave
10e51b: c3 ret
0010cdb8 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10cdb8: 55 push %ebp
10cdb9: 89 e5 mov %esp,%ebp
10cdbb: 56 push %esi
10cdbc: 53 push %ebx
10cdbd: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10cdc0: 9c pushf
10cdc1: fa cli
10cdc2: 5e pop %esi
previous_state = the_watchdog->state;
10cdc3: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10cdc6: 83 f8 01 cmp $0x1,%eax
10cdc9: 74 09 je 10cdd4 <_Watchdog_Remove+0x1c>
10cdcb: 72 42 jb 10ce0f <_Watchdog_Remove+0x57>
10cdcd: 83 f8 03 cmp $0x3,%eax
10cdd0: 77 3d ja 10ce0f <_Watchdog_Remove+0x57> <== NEVER TAKEN
10cdd2: eb 09 jmp 10cddd <_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;
10cdd4: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10cddb: eb 32 jmp 10ce0f <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cddd: 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 );
}
10cde4: 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) )
10cde6: 83 39 00 cmpl $0x0,(%ecx)
10cde9: 74 06 je 10cdf1 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10cdeb: 8b 5a 10 mov 0x10(%edx),%ebx
10cdee: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10cdf1: 8b 1d 18 44 12 00 mov 0x124418,%ebx
10cdf7: 85 db test %ebx,%ebx
10cdf9: 74 0c je 10ce07 <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cdfb: 8b 1d 30 48 12 00 mov 0x124830,%ebx
10ce01: 89 1d 90 43 12 00 mov %ebx,0x124390
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10ce07: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10ce0a: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10ce0d: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10ce0f: 8b 0d 1c 44 12 00 mov 0x12441c,%ecx
10ce15: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10ce18: 56 push %esi
10ce19: 9d popf
return( previous_state );
}
10ce1a: 5b pop %ebx
10ce1b: 5e pop %esi
10ce1c: c9 leave
10ce1d: c3 ret
0010e040 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e040: 55 push %ebp
10e041: 89 e5 mov %esp,%ebp
10e043: 57 push %edi
10e044: 56 push %esi
10e045: 53 push %ebx
10e046: 83 ec 20 sub $0x20,%esp
10e049: 8b 7d 08 mov 0x8(%ebp),%edi
10e04c: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e04f: 9c pushf
10e050: fa cli
10e051: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e054: 56 push %esi
10e055: 57 push %edi
10e056: 68 80 0f 12 00 push $0x120f80
10e05b: e8 88 aa ff ff call 108ae8 <printk>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10e060: 8b 1e mov (%esi),%ebx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10e062: 83 c6 04 add $0x4,%esi
if ( !_Chain_Is_empty( header ) ) {
10e065: 83 c4 10 add $0x10,%esp
10e068: 39 f3 cmp %esi,%ebx
10e06a: 74 1d je 10e089 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e06c: 52 push %edx
10e06d: 52 push %edx
10e06e: 53 push %ebx
10e06f: 6a 00 push $0x0
10e071: e8 32 00 00 00 call 10e0a8 <_Watchdog_Report>
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = header->first ;
node != _Chain_Tail(header) ;
node = node->next )
10e076: 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 = header->first ;
10e078: 83 c4 10 add $0x10,%esp
10e07b: 39 f3 cmp %esi,%ebx
10e07d: 75 ed jne 10e06c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e07f: 50 push %eax
10e080: 50 push %eax
10e081: 57 push %edi
10e082: 68 97 0f 12 00 push $0x120f97
10e087: eb 08 jmp 10e091 <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e089: 83 ec 0c sub $0xc,%esp
10e08c: 68 a6 0f 12 00 push $0x120fa6
10e091: e8 52 aa ff ff call 108ae8 <printk>
10e096: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e099: ff 75 e4 pushl -0x1c(%ebp)
10e09c: 9d popf
}
10e09d: 8d 65 f4 lea -0xc(%ebp),%esp
10e0a0: 5b pop %ebx
10e0a1: 5e pop %esi
10e0a2: 5f pop %edi
10e0a3: c9 leave
10e0a4: c3 ret
0010a7c0 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a7c0: 55 push %ebp
10a7c1: 89 e5 mov %esp,%ebp
10a7c3: 57 push %edi
10a7c4: 56 push %esi
10a7c5: 53 push %ebx
10a7c6: 83 ec 18 sub $0x18,%esp
10a7c9: 8b 75 08 mov 0x8(%ebp),%esi
10a7cc: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a7cf: 68 78 72 12 00 push $0x127278
10a7d4: e8 0b 10 00 00 call 10b7e4 <pthread_mutex_lock>
if (aiocbp == NULL)
10a7d9: 83 c4 10 add $0x10,%esp
10a7dc: 85 db test %ebx,%ebx
10a7de: 0f 85 05 01 00 00 jne 10a8e9 <aio_cancel+0x129>
{
if (fcntl (fildes, F_GETFL) < 0) {
10a7e4: 53 push %ebx
10a7e5: 53 push %ebx
10a7e6: 6a 03 push $0x3
10a7e8: 56 push %esi
10a7e9: e8 9e 5f 00 00 call 11078c <fcntl>
10a7ee: 83 c4 10 add $0x10,%esp
10a7f1: 85 c0 test %eax,%eax
10a7f3: 79 1d jns 10a812 <aio_cancel+0x52> <== NEVER TAKEN
pthread_mutex_unlock(&aio_request_queue.mutex);
10a7f5: 83 ec 0c sub $0xc,%esp
10a7f8: 68 78 72 12 00 push $0x127278
10a7fd: e8 62 10 00 00 call 10b864 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a802: e8 35 8e 00 00 call 11363c <__errno>
10a807: c7 00 09 00 00 00 movl $0x9,(%eax)
10a80d: e9 f5 00 00 00 jmp 10a907 <aio_cancel+0x147>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10a812: 51 push %ecx <== NOT EXECUTED
10a813: 6a 00 push $0x0 <== NOT EXECUTED
10a815: 56 push %esi <== NOT EXECUTED
10a816: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10a81b: e8 20 03 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a820: 89 c3 mov %eax,%ebx <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a825: 85 c0 test %eax,%eax <== NOT EXECUTED
10a827: 0f 85 82 00 00 00 jne 10a8af <aio_cancel+0xef> <== NOT EXECUTED
{
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
10a82d: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10a834: 72 12 00
10a837: 74 5c je 10a895 <aio_cancel+0xd5> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
10a839: 52 push %edx <== NOT EXECUTED
10a83a: 6a 00 push $0x0 <== NOT EXECUTED
10a83c: 56 push %esi <== NOT EXECUTED
10a83d: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED
10a842: e8 f9 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a847: 89 c3 mov %eax,%ebx <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
10a849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a84c: 85 c0 test %eax,%eax <== NOT EXECUTED
10a84e: 75 17 jne 10a867 <aio_cancel+0xa7> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
10a850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a853: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a858: e8 07 10 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a85d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a860: b3 02 mov $0x2,%bl <== NOT EXECUTED
10a862: e9 1b 01 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a867: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a86a: 50 push %eax <== NOT EXECUTED
10a86b: e8 d0 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a870: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a873: e8 07 06 00 00 call 10ae7f <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
10a878: 8d 73 1c lea 0x1c(%ebx),%esi <== NOT EXECUTED
10a87b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a87e: e8 41 0d 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
10a883: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a886: e8 45 0a 00 00 call 10b2d0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10a88b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a88e: e8 ad d4 ff ff call 107d40 <free> <== NOT EXECUTED
10a893: eb 3e jmp 10a8d3 <aio_cancel+0x113> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10a895: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a898: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10a89d: e8 c2 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a8aa: e9 d3 00 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
}
pthread_mutex_lock (&r_chain->mutex);
10a8af: 8d 70 1c lea 0x1c(%eax),%esi <== NOT EXECUTED
10a8b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a8b5: 56 push %esi <== NOT EXECUTED
10a8b6: e8 29 0f 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
10a8bb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a8be: e8 7d 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a8c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a8c6: e8 b4 05 00 00 call 10ae7f <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
10a8cb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10a8ce: e8 91 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8d3: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10a8da: e8 85 0f 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
10a8df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8e2: 31 db xor %ebx,%ebx <== NOT EXECUTED
10a8e4: e9 99 00 00 00 jmp 10a982 <aio_cancel+0x1c2> <== NOT EXECUTED
}
else
{
if (aiocbp->aio_fildes != fildes) {
10a8e9: 8b 3b mov (%ebx),%edi
10a8eb: 39 f7 cmp %esi,%edi
10a8ed: 74 20 je 10a90f <aio_cancel+0x14f> <== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8ef: 83 ec 0c sub $0xc,%esp
10a8f2: 68 78 72 12 00 push $0x127278
10a8f7: e8 68 0f 00 00 call 10b864 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a8fc: e8 3b 8d 00 00 call 11363c <__errno>
10a901: c7 00 16 00 00 00 movl $0x16,(%eax)
10a907: 83 c4 10 add $0x10,%esp
10a90a: 83 cb ff or $0xffffffff,%ebx
10a90d: eb 73 jmp 10a982 <aio_cancel+0x1c2>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10a90f: 50 push %eax <== NOT EXECUTED
10a910: 6a 00 push $0x0 <== NOT EXECUTED
10a912: 57 push %edi <== NOT EXECUTED
10a913: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10a918: e8 23 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10a91d: 89 c6 mov %eax,%esi <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a91f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a922: 85 c0 test %eax,%eax <== NOT EXECUTED
10a924: 75 2e jne 10a954 <aio_cancel+0x194> <== NOT EXECUTED
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
10a926: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10a92d: 72 12 00
10a930: 74 22 je 10a954 <aio_cancel+0x194> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
10a932: 56 push %esi <== NOT EXECUTED
10a933: 6a 00 push $0x0 <== NOT EXECUTED
10a935: 57 push %edi <== NOT EXECUTED
10a936: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED
10a93b: e8 00 02 00 00 call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
10a940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a943: 85 c0 test %eax,%eax <== NOT EXECUTED
10a945: 74 a8 je 10a8ef <aio_cancel+0x12f> <== NOT EXECUTED
{
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
10a947: 51 push %ecx <== NOT EXECUTED
10a948: 51 push %ecx <== NOT EXECUTED
10a949: 53 push %ebx <== NOT EXECUTED
10a94a: 50 push %eax <== NOT EXECUTED
10a94b: e8 6f 05 00 00 call 10aebf <rtems_aio_remove_req> <== NOT EXECUTED
10a950: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10a952: eb 1f jmp 10a973 <aio_cancel+0x1b3> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
pthread_mutex_lock (&r_chain->mutex);
10a954: 8d 7e 1c lea 0x1c(%esi),%edi <== NOT EXECUTED
10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a95a: 57 push %edi <== NOT EXECUTED
10a95b: e8 84 0e 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
10a960: 58 pop %eax <== NOT EXECUTED
10a961: 5a pop %edx <== NOT EXECUTED
10a962: 53 push %ebx <== NOT EXECUTED
10a963: 56 push %esi <== NOT EXECUTED
10a964: e8 56 05 00 00 call 10aebf <rtems_aio_remove_req> <== NOT EXECUTED
10a969: 89 c3 mov %eax,%ebx <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
10a96b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10a96e: e8 f1 0e 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10a973: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10a97a: e8 e5 0e 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10a97f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return AIO_ALLDONE;
}
10a982: 89 d8 mov %ebx,%eax
10a984: 8d 65 f4 lea -0xc(%ebp),%esp
10a987: 5b pop %ebx
10a988: 5e pop %esi
10a989: 5f pop %edi
10a98a: c9 leave
10a98b: c3 ret
0010a998 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a998: 55 push %ebp
10a999: 89 e5 mov %esp,%ebp
10a99b: 53 push %ebx
10a99c: 83 ec 04 sub $0x4,%esp
10a99f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a9a2: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10a9a9: 74 1b je 10a9c6 <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10a9ab: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10a9b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9b9: e8 7e 8c 00 00 call 11363c <__errno>
10a9be: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9c4: eb 74 jmp 10aa3a <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10a9c6: 50 push %eax
10a9c7: 50 push %eax
10a9c8: 6a 03 push $0x3
10a9ca: ff 33 pushl (%ebx)
10a9cc: e8 bb 5d 00 00 call 11078c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10a9d1: 83 e0 03 and $0x3,%eax
10a9d4: 48 dec %eax
10a9d5: 83 c4 10 add $0x10,%esp
10a9d8: 83 f8 01 cmp $0x1,%eax
10a9db: 76 1b jbe 10a9f8 <aio_fsync+0x60> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10a9dd: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10a9e4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9eb: e8 4c 8c 00 00 call 11363c <__errno>
10a9f0: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9f6: eb 42 jmp 10aa3a <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10a9f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a9fb: 6a 18 push $0x18 <== NOT EXECUTED
10a9fd: e8 c2 d7 ff ff call 1081c4 <malloc> <== NOT EXECUTED
if (req == NULL)
10aa02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10aa05: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa07: 75 1b jne 10aa24 <aio_fsync+0x8c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10aa09: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10aa10: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10aa17: e8 20 8c 00 00 call 11363c <__errno> <== NOT EXECUTED
10aa1c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10aa22: eb 16 jmp 10aa3a <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa24: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa27: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) <== NOT EXECUTED
return rtems_aio_enqueue (req);
10aa2e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10aa31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10aa34: c9 leave <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10aa35: e9 d7 04 00 00 jmp 10af11 <rtems_aio_enqueue> <== NOT EXECUTED
}
10aa3a: 83 c8 ff or $0xffffffff,%eax
10aa3d: 8b 5d fc mov -0x4(%ebp),%ebx
10aa40: c9 leave
10aa41: c3 ret
0010b10c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b10c: 55 push %ebp
10b10d: 89 e5 mov %esp,%ebp
10b10f: 53 push %ebx
10b110: 83 ec 0c sub $0xc,%esp
10b113: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b116: 6a 03 push $0x3
10b118: ff 33 pushl (%ebx)
10b11a: e8 6d 56 00 00 call 11078c <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b11f: 83 e0 03 and $0x3,%eax
10b122: 83 c4 10 add $0x10,%esp
10b125: 83 f8 02 cmp $0x2,%eax
10b128: 74 1f je 10b149 <aio_read+0x3d>
10b12a: 85 c0 test %eax,%eax
10b12c: 74 1b je 10b149 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b12e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b135: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b13c: e8 fb 84 00 00 call 11363c <__errno>
10b141: c7 00 09 00 00 00 movl $0x9,(%eax)
10b147: eb 69 jmp 10b1b2 <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b149: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b14d: 75 06 jne 10b155 <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b14f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b153: 79 1b jns 10b170 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b155: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b15c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b163: e8 d4 84 00 00 call 11363c <__errno>
10b168: c7 00 16 00 00 00 movl $0x16,(%eax)
10b16e: eb 42 jmp 10b1b2 <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b170: 83 ec 0c sub $0xc,%esp
10b173: 6a 18 push $0x18
10b175: e8 4a d0 ff ff call 1081c4 <malloc>
if (req == NULL)
10b17a: 83 c4 10 add $0x10,%esp
10b17d: 85 c0 test %eax,%eax
10b17f: 75 1b jne 10b19c <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b181: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b188: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b18f: e8 a8 84 00 00 call 11363c <__errno> <== NOT EXECUTED
10b194: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b19a: eb 16 jmp 10b1b2 <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b19c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b19f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b1a6: 89 45 08 mov %eax,0x8(%ebp)
}
10b1a9: 8b 5d fc mov -0x4(%ebp),%ebx
10b1ac: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
10b1ad: e9 5f fd ff ff jmp 10af11 <rtems_aio_enqueue>
}
10b1b2: 83 c8 ff or $0xffffffff,%eax
10b1b5: 8b 5d fc mov -0x4(%ebp),%ebx
10b1b8: c9 leave
10b1b9: c3 ret
0010b1c8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b1c8: 55 push %ebp
10b1c9: 89 e5 mov %esp,%ebp
10b1cb: 53 push %ebx
10b1cc: 83 ec 0c sub $0xc,%esp
10b1cf: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b1d2: 6a 03 push $0x3
10b1d4: ff 33 pushl (%ebx)
10b1d6: e8 b1 55 00 00 call 11078c <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b1db: 83 e0 03 and $0x3,%eax
10b1de: 48 dec %eax
10b1df: 83 c4 10 add $0x10,%esp
10b1e2: 83 f8 01 cmp $0x1,%eax
10b1e5: 76 1b jbe 10b202 <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1e7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b1ee: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b1f5: e8 42 84 00 00 call 11363c <__errno>
10b1fa: c7 00 09 00 00 00 movl $0x9,(%eax)
10b200: eb 69 jmp 10b26b <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b202: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b206: 75 06 jne 10b20e <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b208: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b20c: 79 1b jns 10b229 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b20e: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b215: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b21c: e8 1b 84 00 00 call 11363c <__errno>
10b221: c7 00 16 00 00 00 movl $0x16,(%eax)
10b227: eb 42 jmp 10b26b <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b229: 83 ec 0c sub $0xc,%esp
10b22c: 6a 18 push $0x18
10b22e: e8 91 cf ff ff call 1081c4 <malloc>
if (req == NULL)
10b233: 83 c4 10 add $0x10,%esp
10b236: 85 c0 test %eax,%eax
10b238: 75 1b jne 10b255 <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b23a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b241: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b248: e8 ef 83 00 00 call 11363c <__errno> <== NOT EXECUTED
10b24d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b253: eb 16 jmp 10b26b <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b255: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b258: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b25f: 89 45 08 mov %eax,0x8(%ebp)
}
10b262: 8b 5d fc mov -0x4(%ebp),%ebx
10b265: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
10b266: e9 a6 fc ff ff jmp 10af11 <rtems_aio_enqueue>
}
10b26b: 83 c8 ff or $0xffffffff,%eax
10b26e: 8b 5d fc mov -0x4(%ebp),%ebx
10b271: c9 leave
10b272: c3 ret
00109f94 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109f94: 55 push %ebp
109f95: 89 e5 mov %esp,%ebp
109f97: 83 ec 08 sub $0x8,%esp
109f9a: 8b 45 08 mov 0x8(%ebp),%eax
109f9d: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109fa0: 85 d2 test %edx,%edx
109fa2: 74 3c je 109fe0 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109fa4: 83 f8 01 cmp $0x1,%eax
109fa7: 75 0b jne 109fb4 <clock_gettime+0x20>
_TOD_Get(tp);
109fa9: 83 ec 0c sub $0xc,%esp
109fac: 52 push %edx
109fad: e8 9e 1b 00 00 call 10bb50 <_TOD_Get>
109fb2: eb 13 jmp 109fc7 <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
109fb4: 83 f8 04 cmp $0x4,%eax
109fb7: 74 05 je 109fbe <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
109fb9: 83 f8 02 cmp $0x2,%eax
109fbc: 75 10 jne 109fce <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
109fbe: 83 ec 0c sub $0xc,%esp
109fc1: 52 push %edx
109fc2: e8 e5 1b 00 00 call 10bbac <_TOD_Get_uptime_as_timespec>
return 0;
109fc7: 83 c4 10 add $0x10,%esp
109fca: 31 c0 xor %eax,%eax
109fcc: eb 20 jmp 109fee <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
109fce: 83 f8 03 cmp $0x3,%eax
109fd1: 75 0d jne 109fe0 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
109fd3: e8 68 7f 00 00 call 111f40 <__errno>
109fd8: c7 00 58 00 00 00 movl $0x58,(%eax)
109fde: eb 0b jmp 109feb <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
109fe0: e8 5b 7f 00 00 call 111f40 <__errno>
109fe5: c7 00 16 00 00 00 movl $0x16,(%eax)
109feb: 83 c8 ff or $0xffffffff,%eax
return 0;
}
109fee: c9 leave
109fef: c3 ret
00109ff0 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
109ff0: 55 push %ebp
109ff1: 89 e5 mov %esp,%ebp
109ff3: 83 ec 08 sub $0x8,%esp
109ff6: 8b 45 08 mov 0x8(%ebp),%eax
109ff9: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109ffc: 85 d2 test %edx,%edx
109ffe: 74 44 je 10a044 <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a000: 83 f8 01 cmp $0x1,%eax
10a003: 75 28 jne 10a02d <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a005: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a00b: 76 37 jbe 10a044 <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a00d: a1 24 63 12 00 mov 0x126324,%eax
10a012: 40 inc %eax
10a013: a3 24 63 12 00 mov %eax,0x126324
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a018: 83 ec 0c sub $0xc,%esp
10a01b: 52 push %edx
10a01c: e8 e3 1b 00 00 call 10bc04 <_TOD_Set>
_Thread_Enable_dispatch();
10a021: e8 68 2c 00 00 call 10cc8e <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a026: 83 c4 10 add $0x10,%esp
10a029: 31 c0 xor %eax,%eax
10a02b: eb 25 jmp 10a052 <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a02d: 83 f8 02 cmp $0x2,%eax
10a030: 74 05 je 10a037 <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a032: 83 f8 03 cmp $0x3,%eax
10a035: 75 0d jne 10a044 <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a037: e8 04 7f 00 00 call 111f40 <__errno>
10a03c: c7 00 58 00 00 00 movl $0x58,(%eax)
10a042: eb 0b jmp 10a04f <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a044: e8 f7 7e 00 00 call 111f40 <__errno>
10a049: c7 00 16 00 00 00 movl $0x16,(%eax)
10a04f: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a052: c9 leave
10a053: c3 ret
00121620 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
121620: 55 push %ebp
121621: 89 e5 mov %esp,%ebp
121623: 57 push %edi
121624: 56 push %esi
121625: 53 push %ebx
121626: 83 ec 4c sub $0x4c,%esp
121629: 8b 5d 0c mov 0xc(%ebp),%ebx
12162c: 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() )
12162f: e8 64 fd ff ff call 121398 <getpid>
121634: 39 45 08 cmp %eax,0x8(%ebp)
121637: 74 0d je 121646 <killinfo+0x26>
rtems_set_errno_and_return_minus_one( ESRCH );
121639: e8 16 43 ff ff call 115954 <__errno>
12163e: c7 00 03 00 00 00 movl $0x3,(%eax)
121644: eb 0f jmp 121655 <killinfo+0x35>
/*
* Validate the signal passed.
*/
if ( !sig )
121646: 85 db test %ebx,%ebx
121648: 75 13 jne 12165d <killinfo+0x3d>
rtems_set_errno_and_return_minus_one( EINVAL );
12164a: e8 05 43 ff ff call 115954 <__errno>
12164f: c7 00 16 00 00 00 movl $0x16,(%eax)
121655: 83 c8 ff or $0xffffffff,%eax
121658: e9 ef 01 00 00 jmp 12184c <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
12165d: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121660: 83 f9 1f cmp $0x1f,%ecx
121663: 77 e5 ja 12164a <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 )
121665: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
121668: 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 )
12166a: 83 ba c0 a9 12 00 01 cmpl $0x1,0x12a9c0(%edx)
121671: 0f 84 d5 01 00 00 je 12184c <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 ) )
121677: 83 fb 04 cmp $0x4,%ebx
12167a: 74 0a je 121686 <killinfo+0x66>
12167c: 83 fb 08 cmp $0x8,%ebx
12167f: 74 05 je 121686 <killinfo+0x66>
121681: 83 fb 0b cmp $0xb,%ebx
121684: 75 16 jne 12169c <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
121686: e8 89 03 00 00 call 121a14 <pthread_self>
12168b: 56 push %esi
12168c: 56 push %esi
12168d: 53 push %ebx
12168e: 50 push %eax
12168f: e8 d8 02 00 00 call 12196c <pthread_kill>
121694: 83 c4 10 add $0x10,%esp
121697: e9 b0 01 00 00 jmp 12184c <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
12169c: be 01 00 00 00 mov $0x1,%esi
1216a1: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
1216a3: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
1216a6: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
1216ad: 85 ff test %edi,%edi
1216af: 75 09 jne 1216ba <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
1216b1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
1216b8: eb 05 jmp 1216bf <killinfo+0x9f>
} else {
siginfo->si_value = *value;
1216ba: 8b 07 mov (%edi),%eax
1216bc: 89 45 e4 mov %eax,-0x1c(%ebp)
1216bf: a1 58 a4 12 00 mov 0x12a458,%eax
1216c4: 40 inc %eax
1216c5: a3 58 a4 12 00 mov %eax,0x12a458
/*
* 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;
1216ca: a1 a8 a9 12 00 mov 0x12a9a8,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
1216cf: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
1216d5: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
1216db: f7 d2 not %edx
1216dd: 85 d6 test %edx,%esi
1216df: 0f 85 ed 00 00 00 jne 1217d2 <killinfo+0x1b2>
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
1216e5: 8b 15 44 ab 12 00 mov 0x12ab44,%edx
1216eb: eb 23 jmp 121710 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
1216ed: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1216ef: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
1216f5: 85 72 30 test %esi,0x30(%edx)
1216f8: 0f 85 d4 00 00 00 jne 1217d2 <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
1216fe: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
121704: f7 d1 not %ecx
121706: 85 ce test %ecx,%esi
121708: 0f 85 c4 00 00 00 jne 1217d2 <killinfo+0x1b2>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
12170e: 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 = the_chain->first ;
121710: 81 fa 48 ab 12 00 cmp $0x12ab48,%edx
121716: 75 d5 jne 1216ed <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
121718: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx
12171f: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
121720: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
121722: 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 ] )
121729: 8b 7d cc mov -0x34(%ebp),%edi
12172c: 8b 14 bd 30 a4 12 00 mov 0x12a430(,%edi,4),%edx
121733: 85 d2 test %edx,%edx
121735: 0f 84 86 00 00 00 je 1217c1 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
12173b: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
12173e: 0f b7 7a 10 movzwl 0x10(%edx),%edi
121742: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
121745: 8b 52 1c mov 0x1c(%edx),%edx
121748: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
12174b: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
121752: 89 5d b4 mov %ebx,-0x4c(%ebp)
121755: eb 5f jmp 1217b6 <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
121757: 8b 5d d0 mov -0x30(%ebp),%ebx
12175a: 8b 7d c0 mov -0x40(%ebp),%edi
12175d: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
121760: 85 d2 test %edx,%edx
121762: 74 4f je 1217b3 <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 )
121764: 8b 5a 14 mov 0x14(%edx),%ebx
121767: 89 5d d4 mov %ebx,-0x2c(%ebp)
12176a: 39 cb cmp %ecx,%ebx
12176c: 77 45 ja 1217b3 <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
12176e: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi
121774: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
12177a: f7 d7 not %edi
12177c: 85 fe test %edi,%esi
12177e: 74 33 je 1217b3 <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 ) {
121780: 39 cb cmp %ecx,%ebx
121782: 72 2a jb 1217ae <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 ) ) {
121784: 85 c0 test %eax,%eax
121786: 74 2b je 1217b3 <killinfo+0x193> <== NEVER TAKEN
121788: 8b 78 10 mov 0x10(%eax),%edi
12178b: 89 7d c8 mov %edi,-0x38(%ebp)
12178e: 85 ff test %edi,%edi
121790: 74 21 je 1217b3 <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
121792: 8b 7a 10 mov 0x10(%edx),%edi
121795: 85 ff test %edi,%edi
121797: 74 15 je 1217ae <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
121799: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
1217a0: 75 11 jne 1217b3 <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
1217a2: 81 e7 00 00 00 10 and $0x10000000,%edi
1217a8: 74 09 je 1217b3 <killinfo+0x193>
1217aa: 89 d9 mov %ebx,%ecx
1217ac: eb 03 jmp 1217b1 <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 ) ) {
1217ae: 8b 4d d4 mov -0x2c(%ebp),%ecx
1217b1: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
1217b3: ff 45 d0 incl -0x30(%ebp)
1217b6: 8b 55 c4 mov -0x3c(%ebp),%edx
1217b9: 39 55 d0 cmp %edx,-0x30(%ebp)
1217bc: 76 99 jbe 121757 <killinfo+0x137>
1217be: 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++) {
1217c1: ff 45 cc incl -0x34(%ebp)
1217c4: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
1217c8: 0f 85 5b ff ff ff jne 121729 <killinfo+0x109>
}
}
}
}
if ( interested ) {
1217ce: 85 c0 test %eax,%eax
1217d0: 74 13 je 1217e5 <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 ) ) {
1217d2: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
1217d3: 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 ) ) {
1217d6: 52 push %edx
1217d7: 53 push %ebx
1217d8: 50 push %eax
1217d9: e8 8a 00 00 00 call 121868 <_POSIX_signals_Unblock_thread>
1217de: 83 c4 10 add $0x10,%esp
1217e1: 84 c0 test %al,%al
1217e3: 75 60 jne 121845 <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 );
1217e5: 83 ec 0c sub $0xc,%esp
1217e8: 56 push %esi
1217e9: e8 66 00 00 00 call 121854 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
1217ee: 6b db 0c imul $0xc,%ebx,%ebx
1217f1: 83 c4 10 add $0x10,%esp
1217f4: 83 bb b8 a9 12 00 02 cmpl $0x2,0x12a9b8(%ebx)
1217fb: 75 48 jne 121845 <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
1217fd: 83 ec 0c sub $0xc,%esp
121800: 68 38 ab 12 00 push $0x12ab38
121805: e8 2a d9 fe ff call 10f134 <_Chain_Get>
if ( !psiginfo ) {
12180a: 83 c4 10 add $0x10,%esp
12180d: 85 c0 test %eax,%eax
12180f: 75 15 jne 121826 <killinfo+0x206>
_Thread_Enable_dispatch();
121811: e8 80 ee fe ff call 110696 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
121816: e8 39 41 ff ff call 115954 <__errno>
12181b: c7 00 0b 00 00 00 movl $0xb,(%eax)
121821: e9 2f fe ff ff jmp 121655 <killinfo+0x35>
}
psiginfo->Info = *siginfo;
121826: 8d 78 08 lea 0x8(%eax),%edi
121829: 8d 75 dc lea -0x24(%ebp),%esi
12182c: b9 03 00 00 00 mov $0x3,%ecx
121831: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
121833: 52 push %edx
121834: 52 push %edx
121835: 50 push %eax
121836: 81 c3 b0 ab 12 00 add $0x12abb0,%ebx
12183c: 53 push %ebx
12183d: e8 b6 d8 fe ff call 10f0f8 <_Chain_Append>
121842: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
121845: e8 4c ee fe ff call 110696 <_Thread_Enable_dispatch>
return 0;
12184a: 31 c0 xor %eax,%eax
}
12184c: 8d 65 f4 lea -0xc(%ebp),%esp
12184f: 5b pop %ebx
121850: 5e pop %esi
121851: 5f pop %edi
121852: c9 leave
121853: c3 ret
0010dff0 <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
10dff0: 55 push %ebp
10dff1: 89 e5 mov %esp,%ebp
10dff3: 53 push %ebx
10dff4: 83 ec 14 sub $0x14,%esp
10dff7: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Attributes *the_mq_attr;
if ( !mqstat )
10dffa: 85 db test %ebx,%ebx
10dffc: 75 0d jne 10e00b <mq_getattr+0x1b> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10dffe: e8 d1 8d 00 00 call 116dd4 <__errno>
10e003: c7 00 16 00 00 00 movl $0x16,(%eax)
10e009: eb 49 jmp 10e054 <mq_getattr+0x64>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10e00b: 50 push %eax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10e00c: 8d 45 f4 lea -0xc(%ebp),%eax
10e00f: 50 push %eax
10e010: ff 75 08 pushl 0x8(%ebp)
10e013: 68 7c d9 12 00 push $0x12d97c
10e018: e8 af 2d 00 00 call 110dcc <_Objects_Get>
switch ( location ) {
10e01d: 83 c4 10 add $0x10,%esp
10e020: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10e024: 75 23 jne 10e049 <mq_getattr+0x59>
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
10e026: 8b 50 10 mov 0x10(%eax),%edx
* Return the old values.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
mqstat->mq_flags = the_mq_fd->oflag;
10e029: 8b 40 14 mov 0x14(%eax),%eax
10e02c: 89 03 mov %eax,(%ebx)
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
10e02e: 8b 42 68 mov 0x68(%edx),%eax
10e031: 89 43 08 mov %eax,0x8(%ebx)
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
10e034: 8b 42 60 mov 0x60(%edx),%eax
10e037: 89 43 04 mov %eax,0x4(%ebx)
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
10e03a: 8b 42 64 mov 0x64(%edx),%eax
10e03d: 89 43 0c mov %eax,0xc(%ebx)
_Thread_Enable_dispatch();
10e040: e8 d9 35 00 00 call 11161e <_Thread_Enable_dispatch>
return 0;
10e045: 31 c0 xor %eax,%eax
10e047: eb 0e jmp 10e057 <mq_getattr+0x67>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e049: e8 86 8d 00 00 call 116dd4 <__errno>
10e04e: c7 00 09 00 00 00 movl $0x9,(%eax)
10e054: 83 c8 ff or $0xffffffff,%eax
}
10e057: 8b 5d fc mov -0x4(%ebp),%ebx
10e05a: c9 leave
10e05b: c3 ret
0010efd8 <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
10efd8: 55 push %ebp
10efd9: 89 e5 mov %esp,%ebp
10efdb: 8b 55 08 mov 0x8(%ebp),%edx
10efde: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10efe1: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
10efe6: 85 d2 test %edx,%edx
10efe8: 74 17 je 10f001 <pthread_attr_getinheritsched+0x29><== NEVER TAKEN
10efea: 85 c9 test %ecx,%ecx
10efec: 74 0e je 10effc <pthread_attr_getinheritsched+0x24>
10efee: 83 3a 00 cmpl $0x0,(%edx)
10eff1: 74 09 je 10effc <pthread_attr_getinheritsched+0x24>
return EINVAL;
*inheritsched = attr->inheritsched;
10eff3: 8b 42 10 mov 0x10(%edx),%eax
10eff6: 89 01 mov %eax,(%ecx)
return 0;
10eff8: 31 c0 xor %eax,%eax
10effa: eb 05 jmp 10f001 <pthread_attr_getinheritsched+0x29>
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10effc: b8 16 00 00 00 mov $0x16,%eax
*inheritsched = attr->inheritsched;
return 0;
}
10f001: c9 leave
10f002: c3 ret
0010f1f4 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f1f4: 55 push %ebp
10f1f5: 89 e5 mov %esp,%ebp
10f1f7: 8b 55 08 mov 0x8(%ebp),%edx
10f1fa: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f1fd: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f202: 85 d2 test %edx,%edx
10f204: 74 1e je 10f224 <pthread_attr_setschedpolicy+0x30>
10f206: 83 3a 00 cmpl $0x0,(%edx)
10f209: 74 19 je 10f224 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f20b: 83 f9 04 cmp $0x4,%ecx
10f20e: 77 0f ja 10f21f <pthread_attr_setschedpolicy+0x2b>
10f210: b0 01 mov $0x1,%al
10f212: d3 e0 shl %cl,%eax
10f214: a8 17 test $0x17,%al
10f216: 74 07 je 10f21f <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f218: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f21b: 31 c0 xor %eax,%eax
10f21d: eb 05 jmp 10f224 <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f21f: b8 86 00 00 00 mov $0x86,%eax
}
}
10f224: c9 leave
10f225: c3 ret
0010a514 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a514: 55 push %ebp
10a515: 89 e5 mov %esp,%ebp
10a517: 57 push %edi
10a518: 56 push %esi
10a519: 53 push %ebx
10a51a: 83 ec 1c sub $0x1c,%esp
10a51d: 8b 5d 08 mov 0x8(%ebp),%ebx
10a520: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a523: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a528: 85 db test %ebx,%ebx
10a52a: 0f 84 96 00 00 00 je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a530: 85 f6 test %esi,%esi
10a532: 0f 84 8e 00 00 00 je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a538: 8b 7d 0c mov 0xc(%ebp),%edi
10a53b: 85 ff test %edi,%edi
10a53d: 75 0f jne 10a54e <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a53f: 83 ec 0c sub $0xc,%esp
10a542: 8d 7d d8 lea -0x28(%ebp),%edi
10a545: 57 push %edi
10a546: e8 19 ff ff ff call 10a464 <pthread_barrierattr_init>
10a54b: 83 c4 10 add $0x10,%esp
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
10a54e: b8 16 00 00 00 mov $0x16,%eax
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10a553: 83 3f 00 cmpl $0x0,(%edi)
10a556: 74 6e je 10a5c6 <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a558: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a55c: 75 68 jne 10a5c6 <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a55e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a565: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a568: a1 f4 63 12 00 mov 0x1263f4,%eax
10a56d: 40 inc %eax
10a56e: a3 f4 63 12 00 mov %eax,0x1263f4
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
10a573: 83 ec 0c sub $0xc,%esp
10a576: 68 c0 67 12 00 push $0x1267c0
10a57b: e8 08 1e 00 00 call 10c388 <_Objects_Allocate>
10a580: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a582: 83 c4 10 add $0x10,%esp
10a585: 85 c0 test %eax,%eax
10a587: 75 0c jne 10a595 <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a589: e8 08 2a 00 00 call 10cf96 <_Thread_Enable_dispatch>
return EAGAIN;
10a58e: b8 0b 00 00 00 mov $0xb,%eax
10a593: eb 31 jmp 10a5c6 <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a595: 50 push %eax
10a596: 50 push %eax
10a597: 8d 45 e0 lea -0x20(%ebp),%eax
10a59a: 50 push %eax
10a59b: 8d 46 10 lea 0x10(%esi),%eax
10a59e: 50 push %eax
10a59f: e8 9c 14 00 00 call 10ba40 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5a4: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5a7: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a5aa: 8b 15 dc 67 12 00 mov 0x1267dc,%edx
10a5b0: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10a5b3: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
10a5ba: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a5bc: e8 d5 29 00 00 call 10cf96 <_Thread_Enable_dispatch>
return 0;
10a5c1: 83 c4 10 add $0x10,%esp
10a5c4: 31 c0 xor %eax,%eax
}
10a5c6: 8d 65 f4 lea -0xc(%ebp),%esp
10a5c9: 5b pop %ebx
10a5ca: 5e pop %esi
10a5cb: 5f pop %edi
10a5cc: c9 leave
10a5cd: c3 ret
00109ecc <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109ecc: 55 push %ebp
109ecd: 89 e5 mov %esp,%ebp
109ecf: 56 push %esi
109ed0: 53 push %ebx
109ed1: 8b 5d 08 mov 0x8(%ebp),%ebx
109ed4: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
109ed7: 85 db test %ebx,%ebx
109ed9: 74 4b je 109f26 <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109edb: a1 cc 62 12 00 mov 0x1262cc,%eax
109ee0: 40 inc %eax
109ee1: a3 cc 62 12 00 mov %eax,0x1262cc
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109ee6: 83 ec 0c sub $0xc,%esp
109ee9: 6a 10 push $0x10
109eeb: e8 22 3b 00 00 call 10da12 <_Workspace_Allocate>
if ( handler ) {
109ef0: 83 c4 10 add $0x10,%esp
109ef3: 85 c0 test %eax,%eax
109ef5: 74 24 je 109f1b <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109ef7: 8b 15 1c 68 12 00 mov 0x12681c,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109efd: 8b 92 f8 00 00 00 mov 0xf8(%edx),%edx
109f03: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f09: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f0c: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f0f: 51 push %ecx
109f10: 51 push %ecx
109f11: 50 push %eax
109f12: 52 push %edx
109f13: e8 7c 15 00 00 call 10b494 <_Chain_Append>
109f18: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f1b: 8d 65 f8 lea -0x8(%ebp),%esp
109f1e: 5b pop %ebx
109f1f: 5e pop %esi
109f20: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f21: e9 6c 2a 00 00 jmp 10c992 <_Thread_Enable_dispatch>
}
109f26: 8d 65 f8 lea -0x8(%ebp),%esp
109f29: 5b pop %ebx
109f2a: 5e pop %esi
109f2b: c9 leave
109f2c: c3 ret
0010ac3c <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac3c: 55 push %ebp
10ac3d: 89 e5 mov %esp,%ebp
10ac3f: 56 push %esi
10ac40: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac41: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac44: 85 db test %ebx,%ebx
10ac46: 75 05 jne 10ac4d <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10ac48: bb 28 0c 12 00 mov $0x120c28,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10ac4d: b8 16 00 00 00 mov $0x16,%eax
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10ac52: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10ac56: 74 76 je 10acce <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10ac58: 83 3b 00 cmpl $0x0,(%ebx)
10ac5b: 74 71 je 10acce <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10ac5d: a1 e4 62 12 00 mov 0x1262e4,%eax
10ac62: 40 inc %eax
10ac63: a3 e4 62 12 00 mov %eax,0x1262e4
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10ac68: 83 ec 0c sub $0xc,%esp
10ac6b: 68 48 67 12 00 push $0x126748
10ac70: e8 f3 22 00 00 call 10cf68 <_Objects_Allocate>
10ac75: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10ac77: 83 c4 10 add $0x10,%esp
10ac7a: 85 c0 test %eax,%eax
10ac7c: 75 0c jne 10ac8a <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10ac7e: e8 f3 2e 00 00 call 10db76 <_Thread_Enable_dispatch>
return ENOMEM;
10ac83: b8 0c 00 00 00 mov $0xc,%eax
10ac88: eb 44 jmp 10acce <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ac8a: 8b 43 04 mov 0x4(%ebx),%eax
10ac8d: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ac90: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10ac97: 6a 74 push $0x74
10ac99: 68 00 08 00 10 push $0x10000800
10ac9e: 6a 00 push $0x0
10aca0: 8d 46 18 lea 0x18(%esi),%eax
10aca3: 50 push %eax
10aca4: e8 c3 35 00 00 call 10e26c <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10aca9: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10acac: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10acaf: 8b 15 64 67 12 00 mov 0x126764,%edx
10acb5: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10acb8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10acbf: 8b 55 08 mov 0x8(%ebp),%edx
10acc2: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10acc4: e8 ad 2e 00 00 call 10db76 <_Thread_Enable_dispatch>
return 0;
10acc9: 83 c4 10 add $0x10,%esp
10accc: 31 c0 xor %eax,%eax
}
10acce: 8d 65 f8 lea -0x8(%ebp),%esp
10acd1: 5b pop %ebx
10acd2: 5e pop %esi
10acd3: c9 leave
10acd4: c3 ret
0010aaf0 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10aaf0: 55 push %ebp
10aaf1: 89 e5 mov %esp,%ebp
10aaf3: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10aaf6: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10aafb: 85 d2 test %edx,%edx
10aafd: 74 0d je 10ab0c <pthread_condattr_destroy+0x1c>
10aaff: 83 3a 00 cmpl $0x0,(%edx)
10ab02: 74 08 je 10ab0c <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab04: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab0a: 30 c0 xor %al,%al
}
10ab0c: c9 leave
10ab0d: c3 ret
0010a224 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a224: 55 push %ebp
10a225: 89 e5 mov %esp,%ebp
10a227: 57 push %edi
10a228: 56 push %esi
10a229: 53 push %ebx
10a22a: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a22d: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10a234: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a238: 0f 84 0f 02 00 00 je 10a44d <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a23e: 8b 5d 0c mov 0xc(%ebp),%ebx
10a241: 85 db test %ebx,%ebx
10a243: 75 05 jne 10a24a <pthread_create+0x26>
10a245: bb 94 f8 11 00 mov $0x11f894,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a24a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
10a251: 83 3b 00 cmpl $0x0,(%ebx)
10a254: 0f 84 f3 01 00 00 je 10a44d <pthread_create+0x229>
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
10a25a: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a25e: 74 0e je 10a26e <pthread_create+0x4a>
10a260: a1 14 12 12 00 mov 0x121214,%eax
10a265: 39 43 08 cmp %eax,0x8(%ebx)
10a268: 0f 82 df 01 00 00 jb 10a44d <pthread_create+0x229>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
10a26e: 8b 43 10 mov 0x10(%ebx),%eax
10a271: 83 f8 01 cmp $0x1,%eax
10a274: 74 0b je 10a281 <pthread_create+0x5d>
10a276: 83 f8 02 cmp $0x2,%eax
10a279: 0f 85 c7 01 00 00 jne 10a446 <pthread_create+0x222>
10a27f: eb 1f jmp 10a2a0 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a281: a1 24 58 12 00 mov 0x125824,%eax
10a286: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi
schedpolicy = api->schedpolicy;
10a28c: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a292: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a295: 8d 7d c4 lea -0x3c(%ebp),%edi
10a298: 81 c6 88 00 00 00 add $0x88,%esi
10a29e: eb 0c jmp 10a2ac <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2a0: 8b 43 14 mov 0x14(%ebx),%eax
10a2a3: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2a6: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2a9: 8d 73 18 lea 0x18(%ebx),%esi
10a2ac: b9 07 00 00 00 mov $0x7,%ecx
10a2b1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
10a2b3: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10a2ba: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a2be: 0f 85 89 01 00 00 jne 10a44d <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2c4: 83 ec 0c sub $0xc,%esp
10a2c7: ff 75 c4 pushl -0x3c(%ebp)
10a2ca: e8 01 58 00 00 call 10fad0 <_POSIX_Priority_Is_valid>
10a2cf: 83 c4 10 add $0x10,%esp
return EINVAL;
10a2d2: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2d9: 84 c0 test %al,%al
10a2db: 0f 84 6c 01 00 00 je 10a44d <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a2e1: 8b 45 c4 mov -0x3c(%ebp),%eax
10a2e4: 89 45 a8 mov %eax,-0x58(%ebp)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10a2e7: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a2ee: 8d 45 e0 lea -0x20(%ebp),%eax
10a2f1: 50 push %eax
10a2f2: 8d 45 e4 lea -0x1c(%ebp),%eax
10a2f5: 50 push %eax
10a2f6: 8d 45 c4 lea -0x3c(%ebp),%eax
10a2f9: 50 push %eax
10a2fa: ff 75 ac pushl -0x54(%ebp)
10a2fd: e8 ee 57 00 00 call 10faf0 <_POSIX_Thread_Translate_sched_param>
10a302: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a305: 83 c4 10 add $0x10,%esp
10a308: 85 c0 test %eax,%eax
10a30a: 0f 85 3d 01 00 00 jne 10a44d <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a310: 83 ec 0c sub $0xc,%esp
10a313: ff 35 7c 53 12 00 pushl 0x12537c
10a319: e8 42 15 00 00 call 10b860 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a31e: c7 04 24 20 55 12 00 movl $0x125520,(%esp)
10a325: e8 9e 1e 00 00 call 10c1c8 <_Objects_Allocate>
10a32a: 89 45 b0 mov %eax,-0x50(%ebp)
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
10a32d: 83 c4 10 add $0x10,%esp
10a330: 85 c0 test %eax,%eax
10a332: 75 05 jne 10a339 <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a334: 83 ec 0c sub $0xc,%esp
10a337: eb 53 jmp 10a38c <pthread_create+0x168>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
10a339: 8b 4d e0 mov -0x20(%ebp),%ecx
10a33c: 8b 75 e4 mov -0x1c(%ebp),%esi
10a33f: 8b 53 08 mov 0x8(%ebx),%edx
10a342: a1 14 12 12 00 mov 0x121214,%eax
10a347: d1 e0 shl %eax
10a349: 39 d0 cmp %edx,%eax
10a34b: 73 02 jae 10a34f <pthread_create+0x12b>
10a34d: 89 d0 mov %edx,%eax
10a34f: 52 push %edx
10a350: 6a 00 push $0x0
10a352: 6a 00 push $0x0
10a354: 51 push %ecx
10a355: 56 push %esi
10a356: 6a 01 push $0x1
10a358: 81 e7 ff 00 00 00 and $0xff,%edi
10a35e: 2b 7d a8 sub -0x58(%ebp),%edi
10a361: 57 push %edi
10a362: 6a 01 push $0x1
10a364: 50 push %eax
10a365: ff 73 04 pushl 0x4(%ebx)
10a368: ff 75 b0 pushl -0x50(%ebp)
10a36b: 68 20 55 12 00 push $0x125520
10a370: e8 f3 2a 00 00 call 10ce68 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a375: 83 c4 30 add $0x30,%esp
10a378: 84 c0 test %al,%al
10a37a: 75 2a jne 10a3a6 <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a37c: 56 push %esi
10a37d: 56 push %esi
10a37e: ff 75 b0 pushl -0x50(%ebp)
10a381: 68 20 55 12 00 push $0x125520
10a386: e8 35 21 00 00 call 10c4c0 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a38b: 5b pop %ebx
10a38c: ff 35 7c 53 12 00 pushl 0x12537c
10a392: e8 11 15 00 00 call 10b8a8 <_API_Mutex_Unlock>
return EAGAIN;
10a397: 83 c4 10 add $0x10,%esp
10a39a: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3a1: e9 a7 00 00 00 jmp 10a44d <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3a6: 8b 45 b0 mov -0x50(%ebp),%eax
10a3a9: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
api->Attributes = *the_attr;
10a3af: b9 10 00 00 00 mov $0x10,%ecx
10a3b4: 89 d7 mov %edx,%edi
10a3b6: 89 de mov %ebx,%esi
10a3b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a3ba: 8b 43 3c mov 0x3c(%ebx),%eax
10a3bd: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a3c0: 8b 45 ac mov -0x54(%ebp),%eax
10a3c3: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a3c9: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a3cf: 8d 75 c4 lea -0x3c(%ebp),%esi
10a3d2: b1 07 mov $0x7,%cl
10a3d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a3d6: 83 ec 0c sub $0xc,%esp
10a3d9: 6a 00 push $0x0
10a3db: ff 75 14 pushl 0x14(%ebp)
10a3de: ff 75 10 pushl 0x10(%ebp)
10a3e1: 6a 01 push $0x1
10a3e3: ff 75 b0 pushl -0x50(%ebp)
10a3e6: 89 55 a4 mov %edx,-0x5c(%ebp)
10a3e9: e8 02 34 00 00 call 10d7f0 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a3ee: 83 c4 20 add $0x20,%esp
10a3f1: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a3f5: 8b 55 a4 mov -0x5c(%ebp),%edx
10a3f8: 75 2e jne 10a428 <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a3fa: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a3fd: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a403: 50 push %eax
10a404: e8 8f 35 00 00 call 10d998 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a409: 8b 55 a4 mov -0x5c(%ebp),%edx
10a40c: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a412: 58 pop %eax
10a413: 59 pop %ecx
10a414: 81 c2 a8 00 00 00 add $0xa8,%edx
10a41a: 52 push %edx
10a41b: 68 9c 53 12 00 push $0x12539c
10a420: e8 27 38 00 00 call 10dc4c <_Watchdog_Insert>
10a425: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a428: 8b 45 b0 mov -0x50(%ebp),%eax
10a42b: 8b 50 08 mov 0x8(%eax),%edx
10a42e: 8b 45 08 mov 0x8(%ebp),%eax
10a431: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a433: 83 ec 0c sub $0xc,%esp
10a436: ff 35 7c 53 12 00 pushl 0x12537c
10a43c: e8 67 14 00 00 call 10b8a8 <_API_Mutex_Unlock>
return 0;
10a441: 83 c4 10 add $0x10,%esp
10a444: eb 07 jmp 10a44d <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a446: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a44d: 8b 45 b4 mov -0x4c(%ebp),%eax
10a450: 8d 65 f4 lea -0xc(%ebp),%esp
10a453: 5b pop %ebx
10a454: 5e pop %esi
10a455: 5f pop %edi
10a456: c9 leave
10a457: c3 ret
00110cc0 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110cc0: 55 push %ebp
110cc1: 89 e5 mov %esp,%ebp
110cc3: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110cc6: ff 75 08 pushl 0x8(%ebp)
110cc9: ff 35 34 48 12 00 pushl 0x124834
110ccf: e8 88 ff ff ff call 110c5c <_POSIX_Thread_Exit>
110cd4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110cd7: c9 leave <== NOT EXECUTED
110cd8: c3 ret <== NOT EXECUTED
0010bf30 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf30: 55 push %ebp
10bf31: 89 e5 mov %esp,%ebp
10bf33: 53 push %ebx
10bf34: 83 ec 2c sub $0x2c,%esp
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10bf37: 8d 45 f4 lea -0xc(%ebp),%eax
10bf3a: 50 push %eax
10bf3b: ff 75 0c pushl 0xc(%ebp)
10bf3e: e8 b9 00 00 00 call 10bffc <_POSIX_Absolute_timeout_to_ticks>
10bf43: 89 c3 mov %eax,%ebx
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
10bf45: 83 c4 0c add $0xc,%esp
10bf48: 83 f8 03 cmp $0x3,%eax
10bf4b: 0f 94 c2 sete %dl
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10bf4e: ff 75 f4 pushl -0xc(%ebp)
10bf51: 0f b6 c2 movzbl %dl,%eax
10bf54: 50 push %eax
10bf55: ff 75 08 pushl 0x8(%ebp)
10bf58: 88 55 e4 mov %dl,-0x1c(%ebp)
10bf5b: e8 e8 fe ff ff call 10be48 <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
10bf60: 83 c4 10 add $0x10,%esp
10bf63: 8a 55 e4 mov -0x1c(%ebp),%dl
10bf66: 84 d2 test %dl,%dl
10bf68: 75 1d jne 10bf87 <pthread_mutex_timedlock+0x57>
10bf6a: 83 f8 10 cmp $0x10,%eax
10bf6d: 75 18 jne 10bf87 <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bf6f: 85 db test %ebx,%ebx
10bf71: 74 08 je 10bf7b <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bf73: 4b dec %ebx
10bf74: 83 fb 01 cmp $0x1,%ebx
10bf77: 77 0e ja 10bf87 <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bf79: eb 07 jmp 10bf82 <pthread_mutex_timedlock+0x52>
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10bf7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bf80: eb 05 jmp 10bf87 <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bf82: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bf87: 8b 5d fc mov -0x4(%ebp),%ebx
10bf8a: c9 leave
10bf8b: c3 ret
0010bba8 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bba8: 55 push %ebp
10bba9: 89 e5 mov %esp,%ebp
10bbab: 8b 55 08 mov 0x8(%ebp),%edx
10bbae: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bbb1: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbb6: 85 d2 test %edx,%edx
10bbb8: 74 0f je 10bbc9 <pthread_mutexattr_setpshared+0x21>
10bbba: 83 3a 00 cmpl $0x0,(%edx)
10bbbd: 74 0a je 10bbc9 <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bbbf: 83 f9 01 cmp $0x1,%ecx
10bbc2: 77 05 ja 10bbc9 <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bbc4: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bbc7: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bbc9: c9 leave
10bbca: c3 ret
00109dc0 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109dc0: 55 push %ebp
109dc1: 89 e5 mov %esp,%ebp
109dc3: 8b 55 08 mov 0x8(%ebp),%edx
109dc6: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109dc9: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109dce: 85 d2 test %edx,%edx
109dd0: 74 0f je 109de1 <pthread_mutexattr_settype+0x21>
109dd2: 83 3a 00 cmpl $0x0,(%edx)
109dd5: 74 0a je 109de1 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109dd7: 83 f9 03 cmp $0x3,%ecx
109dda: 77 05 ja 109de1 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109ddc: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109ddf: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109de1: c9 leave
109de2: c3 ret
0010a870 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a870: 55 push %ebp
10a871: 89 e5 mov %esp,%ebp
10a873: 56 push %esi
10a874: 53 push %ebx
10a875: 83 ec 10 sub $0x10,%esp
10a878: 8b 5d 08 mov 0x8(%ebp),%ebx
10a87b: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a87e: 85 f6 test %esi,%esi
10a880: 74 51 je 10a8d3 <pthread_once+0x63>
10a882: 85 db test %ebx,%ebx
10a884: 74 4d je 10a8d3 <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a886: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a888: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a88c: 75 4a jne 10a8d8 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a88e: 52 push %edx
10a88f: 8d 45 f4 lea -0xc(%ebp),%eax
10a892: 50 push %eax
10a893: 68 00 01 00 00 push $0x100
10a898: 68 00 01 00 00 push $0x100
10a89d: e8 9e 0a 00 00 call 10b340 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8a2: 83 c4 10 add $0x10,%esp
10a8a5: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8a9: 75 0f jne 10a8ba <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a8ab: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a8b1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a8b8: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a8ba: 50 push %eax
10a8bb: 8d 45 f4 lea -0xc(%ebp),%eax
10a8be: 50 push %eax
10a8bf: 68 00 01 00 00 push $0x100
10a8c4: ff 75 f4 pushl -0xc(%ebp)
10a8c7: e8 74 0a 00 00 call 10b340 <rtems_task_mode>
10a8cc: 83 c4 10 add $0x10,%esp
}
return 0;
10a8cf: 31 c0 xor %eax,%eax
10a8d1: eb 05 jmp 10a8d8 <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a8d3: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a8d8: 8d 65 f8 lea -0x8(%ebp),%esp
10a8db: 5b pop %ebx
10a8dc: 5e pop %esi
10a8dd: c9 leave
10a8de: c3 ret
0010b09c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b09c: 55 push %ebp
10b09d: 89 e5 mov %esp,%ebp
10b09f: 56 push %esi
10b0a0: 53 push %ebx
10b0a1: 83 ec 10 sub $0x10,%esp
10b0a4: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0a7: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b0ac: 85 db test %ebx,%ebx
10b0ae: 0f 84 8b 00 00 00 je 10b13f <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b0b4: 8b 75 0c mov 0xc(%ebp),%esi
10b0b7: 85 f6 test %esi,%esi
10b0b9: 75 0f jne 10b0ca <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b0bb: 83 ec 0c sub $0xc,%esp
10b0be: 8d 75 ec lea -0x14(%ebp),%esi
10b0c1: 56 push %esi
10b0c2: e8 5d 09 00 00 call 10ba24 <pthread_rwlockattr_init>
10b0c7: 83 c4 10 add $0x10,%esp
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
10b0ca: b8 16 00 00 00 mov $0x16,%eax
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10b0cf: 83 3e 00 cmpl $0x0,(%esi)
10b0d2: 74 6b je 10b13f <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b0d4: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b0d8: 75 65 jne 10b13f <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b0da: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b0e1: a1 f4 82 12 00 mov 0x1282f4,%eax
10b0e6: 40 inc %eax
10b0e7: a3 f4 82 12 00 mov %eax,0x1282f4
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
10b0ec: 83 ec 0c sub $0xc,%esp
10b0ef: 68 00 85 12 00 push $0x128500
10b0f4: e8 2f 23 00 00 call 10d428 <_Objects_Allocate>
10b0f9: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b0fb: 83 c4 10 add $0x10,%esp
10b0fe: 85 c0 test %eax,%eax
10b100: 75 0c jne 10b10e <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b102: e8 2f 2f 00 00 call 10e036 <_Thread_Enable_dispatch>
return EAGAIN;
10b107: b8 0b 00 00 00 mov $0xb,%eax
10b10c: eb 31 jmp 10b13f <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b10e: 50 push %eax
10b10f: 50 push %eax
10b110: 8d 45 f4 lea -0xc(%ebp),%eax
10b113: 50 push %eax
10b114: 8d 46 10 lea 0x10(%esi),%eax
10b117: 50 push %eax
10b118: e8 6f 1b 00 00 call 10cc8c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b11d: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b120: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b123: 8b 15 1c 85 12 00 mov 0x12851c,%edx
10b129: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10b12c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b133: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b135: e8 fc 2e 00 00 call 10e036 <_Thread_Enable_dispatch>
return 0;
10b13a: 83 c4 10 add $0x10,%esp
10b13d: 31 c0 xor %eax,%eax
}
10b13f: 8d 65 f8 lea -0x8(%ebp),%esp
10b142: 5b pop %ebx
10b143: 5e pop %esi
10b144: c9 leave
10b145: c3 ret
0010b1b0 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b1b0: 55 push %ebp
10b1b1: 89 e5 mov %esp,%ebp
10b1b3: 57 push %edi
10b1b4: 56 push %esi
10b1b5: 53 push %ebx
10b1b6: 83 ec 2c sub $0x2c,%esp
10b1b9: 8b 7d 08 mov 0x8(%ebp),%edi
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
10b1bc: bb 16 00 00 00 mov $0x16,%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10b1c1: 85 ff test %edi,%edi
10b1c3: 0f 84 87 00 00 00 je 10b250 <pthread_rwlock_timedrdlock+0xa0>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10b1c9: 50 push %eax
10b1ca: 50 push %eax
10b1cb: 8d 45 e0 lea -0x20(%ebp),%eax
10b1ce: 50 push %eax
10b1cf: ff 75 0c pushl 0xc(%ebp)
10b1d2: e8 39 58 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks>
10b1d7: 89 c6 mov %eax,%esi
10b1d9: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b1dc: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1df: 50 push %eax
10b1e0: ff 37 pushl (%edi)
10b1e2: 68 00 85 12 00 push $0x128500
10b1e7: e8 6c 26 00 00 call 10d858 <_Objects_Get>
switch ( location ) {
10b1ec: 83 c4 10 add $0x10,%esp
10b1ef: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b1f3: 75 5b jne 10b250 <pthread_rwlock_timedrdlock+0xa0>
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
10b1f5: 83 fe 03 cmp $0x3,%esi
10b1f8: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b1fb: 83 ec 0c sub $0xc,%esp
10b1fe: 6a 00 push $0x0
10b200: ff 75 e0 pushl -0x20(%ebp)
10b203: 0f b6 ca movzbl %dl,%ecx
10b206: 51 push %ecx
10b207: ff 37 pushl (%edi)
10b209: 83 c0 10 add $0x10,%eax
10b20c: 50 push %eax
10b20d: 88 55 d4 mov %dl,-0x2c(%ebp)
10b210: e8 ab 1a 00 00 call 10ccc0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b215: 83 c4 20 add $0x20,%esp
10b218: e8 19 2e 00 00 call 10e036 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b21d: 8a 55 d4 mov -0x2c(%ebp),%dl
10b220: 84 d2 test %dl,%dl
10b222: 75 17 jne 10b23b <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b224: a1 44 88 12 00 mov 0x128844,%eax
10b229: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b22d: 75 0c jne 10b23b <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b22f: 85 f6 test %esi,%esi
10b231: 74 1d je 10b250 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b233: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b234: b3 74 mov $0x74,%bl
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b236: 83 fe 01 cmp $0x1,%esi
10b239: 76 15 jbe 10b250 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b23b: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b23e: a1 44 88 12 00 mov 0x128844,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b243: ff 70 34 pushl 0x34(%eax)
10b246: e8 bd 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b24b: 89 c3 mov %eax,%ebx
10b24d: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b250: 89 d8 mov %ebx,%eax
10b252: 8d 65 f4 lea -0xc(%ebp),%esp
10b255: 5b pop %ebx
10b256: 5e pop %esi
10b257: 5f pop %edi
10b258: c9 leave
10b259: c3 ret
0010b25c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b25c: 55 push %ebp
10b25d: 89 e5 mov %esp,%ebp
10b25f: 57 push %edi
10b260: 56 push %esi
10b261: 53 push %ebx
10b262: 83 ec 2c sub $0x2c,%esp
10b265: 8b 7d 08 mov 0x8(%ebp),%edi
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
10b268: bb 16 00 00 00 mov $0x16,%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10b26d: 85 ff test %edi,%edi
10b26f: 0f 84 87 00 00 00 je 10b2fc <pthread_rwlock_timedwrlock+0xa0>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10b275: 50 push %eax
10b276: 50 push %eax
10b277: 8d 45 e0 lea -0x20(%ebp),%eax
10b27a: 50 push %eax
10b27b: ff 75 0c pushl 0xc(%ebp)
10b27e: e8 8d 57 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks>
10b283: 89 c6 mov %eax,%esi
10b285: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b288: 8d 45 e4 lea -0x1c(%ebp),%eax
10b28b: 50 push %eax
10b28c: ff 37 pushl (%edi)
10b28e: 68 00 85 12 00 push $0x128500
10b293: e8 c0 25 00 00 call 10d858 <_Objects_Get>
switch ( location ) {
10b298: 83 c4 10 add $0x10,%esp
10b29b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b29f: 75 5b jne 10b2fc <pthread_rwlock_timedwrlock+0xa0>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
10b2a1: 83 fe 03 cmp $0x3,%esi
10b2a4: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2a7: 83 ec 0c sub $0xc,%esp
10b2aa: 6a 00 push $0x0
10b2ac: ff 75 e0 pushl -0x20(%ebp)
10b2af: 0f b6 ca movzbl %dl,%ecx
10b2b2: 51 push %ecx
10b2b3: ff 37 pushl (%edi)
10b2b5: 83 c0 10 add $0x10,%eax
10b2b8: 50 push %eax
10b2b9: 88 55 d4 mov %dl,-0x2c(%ebp)
10b2bc: e8 b7 1a 00 00 call 10cd78 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b2c1: 83 c4 20 add $0x20,%esp
10b2c4: e8 6d 2d 00 00 call 10e036 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b2c9: 8a 55 d4 mov -0x2c(%ebp),%dl
10b2cc: 84 d2 test %dl,%dl
10b2ce: 75 17 jne 10b2e7 <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b2d0: a1 44 88 12 00 mov 0x128844,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b2d5: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b2d9: 75 0c jne 10b2e7 <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b2db: 85 f6 test %esi,%esi
10b2dd: 74 1d je 10b2fc <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2df: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b2e0: b3 74 mov $0x74,%bl
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2e2: 83 fe 01 cmp $0x1,%esi
10b2e5: 76 15 jbe 10b2fc <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2e7: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b2ea: a1 44 88 12 00 mov 0x128844,%eax
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2ef: ff 70 34 pushl 0x34(%eax)
10b2f2: e8 11 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2f7: 89 c3 mov %eax,%ebx
10b2f9: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b2fc: 89 d8 mov %ebx,%eax
10b2fe: 8d 65 f4 lea -0xc(%ebp),%esp
10b301: 5b pop %ebx
10b302: 5e pop %esi
10b303: 5f pop %edi
10b304: c9 leave
10b305: c3 ret
0010ba44 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba44: 55 push %ebp
10ba45: 89 e5 mov %esp,%ebp
10ba47: 8b 55 08 mov 0x8(%ebp),%edx
10ba4a: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10ba4d: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10ba52: 85 d2 test %edx,%edx
10ba54: 74 0f je 10ba65 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10ba56: 83 3a 00 cmpl $0x0,(%edx)
10ba59: 74 0a je 10ba65 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10ba5b: 83 f9 01 cmp $0x1,%ecx
10ba5e: 77 05 ja 10ba65 <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10ba60: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10ba63: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10ba65: c9 leave
10ba66: c3 ret
0010c754 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10c754: 55 push %ebp
10c755: 89 e5 mov %esp,%ebp
10c757: 57 push %edi
10c758: 56 push %esi
10c759: 53 push %ebx
10c75a: 83 ec 2c sub $0x2c,%esp
10c75d: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c760: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c767: 85 f6 test %esi,%esi
10c769: 0f 84 00 01 00 00 je 10c86f <pthread_setschedparam+0x11b>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c76f: 8d 45 e0 lea -0x20(%ebp),%eax
10c772: 50 push %eax
10c773: 8d 45 e4 lea -0x1c(%ebp),%eax
10c776: 50 push %eax
10c777: 56 push %esi
10c778: ff 75 0c pushl 0xc(%ebp)
10c77b: e8 00 52 00 00 call 111980 <_POSIX_Thread_Translate_sched_param>
10c780: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c783: 83 c4 10 add $0x10,%esp
10c786: 85 c0 test %eax,%eax
10c788: 0f 85 e1 00 00 00 jne 10c86f <pthread_setschedparam+0x11b>
10c78e: 53 push %ebx
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10c78f: 8d 45 dc lea -0x24(%ebp),%eax
10c792: 50 push %eax
10c793: ff 75 08 pushl 0x8(%ebp)
10c796: 68 80 95 12 00 push $0x129580
10c79b: e8 80 1c 00 00 call 10e420 <_Objects_Get>
10c7a0: 89 c2 mov %eax,%edx
switch ( location ) {
10c7a2: 83 c4 10 add $0x10,%esp
10c7a5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c7a9: 0f 85 b9 00 00 00 jne 10c868 <pthread_setschedparam+0x114>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7af: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7b5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7bc: 75 18 jne 10c7d6 <pthread_setschedparam+0x82>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7be: 83 ec 0c sub $0xc,%esp
10c7c1: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c7c7: 50 push %eax
10c7c8: 89 55 d0 mov %edx,-0x30(%ebp)
10c7cb: e8 48 34 00 00 call 10fc18 <_Watchdog_Remove>
10c7d0: 83 c4 10 add $0x10,%esp
10c7d3: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c7d6: 8b 45 0c mov 0xc(%ebp),%eax
10c7d9: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c7df: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c7e5: b9 07 00 00 00 mov $0x7,%ecx
10c7ea: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c7ec: 8b 45 e4 mov -0x1c(%ebp),%eax
10c7ef: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c7f2: 8b 45 e0 mov -0x20(%ebp),%eax
10c7f5: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c7fb: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c7ff: 78 60 js 10c861 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c801: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c805: 7e 08 jle 10c80f <pthread_setschedparam+0xbb>
10c807: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c80b: 75 54 jne 10c861 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c80d: eb 24 jmp 10c833 <pthread_setschedparam+0xdf>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c80f: a1 04 93 12 00 mov 0x129304,%eax
10c814: 89 42 78 mov %eax,0x78(%edx)
10c817: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax
10c81e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c824: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c827: 51 push %ecx
10c828: 6a 01 push $0x1
10c82a: 50 push %eax
10c82b: 52 push %edx
10c82c: e8 3b 1f 00 00 call 10e76c <_Thread_Change_priority>
10c831: eb 2b jmp 10c85e <pthread_setschedparam+0x10a>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c833: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c839: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c83f: 83 ec 0c sub $0xc,%esp
10c842: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c848: 53 push %ebx
10c849: 89 55 d0 mov %edx,-0x30(%ebp)
10c84c: e8 c7 33 00 00 call 10fc18 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c851: 58 pop %eax
10c852: 5a pop %edx
10c853: 8b 55 d0 mov -0x30(%ebp),%edx
10c856: 52 push %edx
10c857: 6a 00 push $0x0
10c859: e8 e1 fd ff ff call 10c63f <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c85e: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c861: e8 98 23 00 00 call 10ebfe <_Thread_Enable_dispatch>
return 0;
10c866: eb 07 jmp 10c86f <pthread_setschedparam+0x11b>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c868: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c86f: 8b 45 d4 mov -0x2c(%ebp),%eax
10c872: 8d 65 f4 lea -0xc(%ebp),%esp
10c875: 5b pop %ebx
10c876: 5e pop %esi
10c877: 5f pop %edi
10c878: c9 leave
10c879: c3 ret
0010a640 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a640: 55 push %ebp
10a641: 89 e5 mov %esp,%ebp
10a643: 53 push %ebx
10a644: 83 ec 04 sub $0x4,%esp
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10a647: 83 3d 18 68 12 00 00 cmpl $0x0,0x126818
10a64e: 75 48 jne 10a698 <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a650: a1 1c 68 12 00 mov 0x12681c,%eax
10a655: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
10a65b: 8b 15 cc 62 12 00 mov 0x1262cc,%edx
10a661: 42 inc %edx
10a662: 89 15 cc 62 12 00 mov %edx,0x1262cc
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a668: 31 db xor %ebx,%ebx
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10a66a: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a671: 75 0a jne 10a67d <pthread_testcancel+0x3d><== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
10a673: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a67a: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a67d: e8 10 23 00 00 call 10c992 <_Thread_Enable_dispatch>
if ( cancel )
10a682: 84 db test %bl,%bl
10a684: 74 12 je 10a698 <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a686: 50 push %eax
10a687: 50 push %eax
10a688: 6a ff push $0xffffffff
10a68a: ff 35 1c 68 12 00 pushl 0x12681c
10a690: e8 9b 51 00 00 call 10f830 <_POSIX_Thread_Exit>
10a695: 83 c4 10 add $0x10,%esp
}
10a698: 8b 5d fc mov -0x4(%ebp),%ebx
10a69b: c9 leave
10a69c: c3 ret
0010af11 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af11: 55 push %ebp
10af12: 89 e5 mov %esp,%ebp
10af14: 57 push %edi
10af15: 56 push %esi
10af16: 53 push %ebx
10af17: 83 ec 58 sub $0x58,%esp
10af1a: 8b 5d 08 mov 0x8(%ebp),%ebx
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
10af1d: 68 78 72 12 00 push $0x127278
10af22: e8 bd 08 00 00 call 10b7e4 <pthread_mutex_lock>
10af27: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af2a: 83 c4 10 add $0x10,%esp
10af2d: 85 c0 test %eax,%eax
10af2f: 74 0e je 10af3f <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10af31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10af34: 53 push %ebx <== NOT EXECUTED
10af35: e8 06 ce ff ff call 107d40 <free> <== NOT EXECUTED
10af3a: e9 bf 01 00 00 jmp 10b0fe <rtems_aio_enqueue+0x1ed><== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10af3f: e8 a0 10 00 00 call 10bfe4 <pthread_self>
10af44: 57 push %edi
10af45: 8d 55 c4 lea -0x3c(%ebp),%edx
10af48: 52 push %edx
10af49: 8d 55 e0 lea -0x20(%ebp),%edx
10af4c: 52 push %edx
10af4d: 50 push %eax
10af4e: e8 95 0c 00 00 call 10bbe8 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10af53: e8 8c 10 00 00 call 10bfe4 <pthread_self>
10af58: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10af5b: 8b 43 14 mov 0x14(%ebx),%eax
10af5e: 8b 55 c4 mov -0x3c(%ebp),%edx
10af61: 2b 50 14 sub 0x14(%eax),%edx
10af64: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10af67: 8b 55 e0 mov -0x20(%ebp),%edx
10af6a: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10af6d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10af74: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10af7b: 83 c4 10 add $0x10,%esp
10af7e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0
10af85: 0f 85 b7 00 00 00 jne 10b042 <rtems_aio_enqueue+0x131>
10af8b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc
10af92: 0f 8f aa 00 00 00 jg 10b042 <rtems_aio_enqueue+0x131>
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10af98: 56 push %esi
10af99: 6a 01 push $0x1
10af9b: ff 30 pushl (%eax)
10af9d: 68 c0 72 12 00 push $0x1272c0
10afa2: e8 99 fb ff ff call 10ab40 <rtems_aio_search_fd>
10afa7: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10afa9: 83 c4 10 add $0x10,%esp
10afac: 83 78 18 01 cmpl $0x1,0x18(%eax)
10afb0: 8d 50 08 lea 0x8(%eax),%edx
10afb3: 8d 78 1c lea 0x1c(%eax),%edi
10afb6: 8d 40 20 lea 0x20(%eax),%eax
10afb9: 89 45 b0 mov %eax,-0x50(%ebp)
10afbc: 75 66 jne 10b024 <rtems_aio_enqueue+0x113>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10afbe: 51 push %ecx
10afbf: 51 push %ecx
10afc0: 53 push %ebx
10afc1: 52 push %edx
10afc2: e8 b5 1f 00 00 call 10cf7c <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10afc7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10afce: 5b pop %ebx
10afcf: 58 pop %eax
10afd0: 6a 00 push $0x0
10afd2: 57 push %edi
10afd3: e8 ec 06 00 00 call 10b6c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10afd8: 5a pop %edx
10afd9: 59 pop %ecx
10afda: 6a 00 push $0x0
10afdc: ff 75 b0 pushl -0x50(%ebp)
10afdf: e8 a0 03 00 00 call 10b384 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10afe4: 56 push %esi
10afe5: 68 eb ab 10 00 push $0x10abeb
10afea: 68 80 72 12 00 push $0x127280
10afef: 8d 45 e4 lea -0x1c(%ebp),%eax
10aff2: 50 push %eax
10aff3: e8 bc 09 00 00 call 10b9b4 <pthread_create>
10aff8: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10affa: 83 c4 20 add $0x20,%esp
10affd: 85 c0 test %eax,%eax
10afff: 74 18 je 10b019 <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10b001: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b004: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10b009: e8 56 08 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10b00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b011: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b014: e9 e8 00 00 00 jmp 10b101 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b019: ff 05 dc 72 12 00 incl 0x1272dc
10b01f: e9 cd 00 00 00 jmp 10b0f1 <rtems_aio_enqueue+0x1e0>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b024: 83 ec 0c sub $0xc,%esp
10b027: 57 push %edi
10b028: 89 55 ac mov %edx,-0x54(%ebp)
10b02b: e8 b4 07 00 00 call 10b7e4 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b030: 5e pop %esi
10b031: 58 pop %eax
10b032: 53 push %ebx
10b033: 8b 55 ac mov -0x54(%ebp),%edx
10b036: 52 push %edx
10b037: e8 00 fe ff ff call 10ae3c <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b03c: 5b pop %ebx
10b03d: ff 75 b0 pushl -0x50(%ebp)
10b040: eb 36 jmp 10b078 <rtems_aio_enqueue+0x167>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10b042: 51 push %ecx
10b043: 6a 00 push $0x0
10b045: ff 30 pushl (%eax)
10b047: 68 c0 72 12 00 push $0x1272c0
10b04c: e8 ef fa ff ff call 10ab40 <rtems_aio_search_fd>
10b051: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b053: 83 c4 10 add $0x10,%esp
10b056: 85 c0 test %eax,%eax
10b058: 74 2d je 10b087 <rtems_aio_enqueue+0x176><== ALWAYS TAKEN
{
pthread_mutex_lock (&r_chain->mutex);
10b05a: 8d 78 1c lea 0x1c(%eax),%edi <== NOT EXECUTED
10b05d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b060: 57 push %edi <== NOT EXECUTED
10b061: e8 7e 07 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
10b066: 58 pop %eax <== NOT EXECUTED
10b067: 5a pop %edx <== NOT EXECUTED
10b068: 53 push %ebx <== NOT EXECUTED
10b069: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
10b06c: 50 push %eax <== NOT EXECUTED
10b06d: e8 ca fd ff ff call 10ae3c <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
10b072: 83 c6 20 add $0x20,%esi <== NOT EXECUTED
10b075: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10b078: e8 a3 03 00 00 call 10b420 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b07d: 89 3c 24 mov %edi,(%esp)
10b080: e8 df 07 00 00 call 10b864 <pthread_mutex_unlock>
10b085: eb 67 jmp 10b0ee <rtems_aio_enqueue+0x1dd>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10b087: 56 push %esi
10b088: 6a 01 push $0x1
10b08a: 8b 43 14 mov 0x14(%ebx),%eax
10b08d: ff 30 pushl (%eax)
10b08f: 68 cc 72 12 00 push $0x1272cc
10b094: e8 a7 fa ff ff call 10ab40 <rtems_aio_search_fd>
10b099: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b09b: 83 c4 10 add $0x10,%esp
10b09e: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b0a2: 8d 40 08 lea 0x8(%eax),%eax
10b0a5: 75 3e jne 10b0e5 <rtems_aio_enqueue+0x1d4>
10b0a7: 51 push %ecx
10b0a8: 51 push %ecx
10b0a9: 53 push %ebx
10b0aa: 50 push %eax
10b0ab: e8 cc 1e 00 00 call 10cf7c <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10b0b0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b0b7: 58 pop %eax
10b0b8: 5a pop %edx
10b0b9: 6a 00 push $0x0
10b0bb: 8d 46 1c lea 0x1c(%esi),%eax
10b0be: 50 push %eax
10b0bf: e8 00 06 00 00 call 10b6c4 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b0c4: 5b pop %ebx
10b0c5: 5f pop %edi
10b0c6: 6a 00 push $0x0
10b0c8: 83 c6 20 add $0x20,%esi
10b0cb: 56 push %esi
10b0cc: e8 b3 02 00 00 call 10b384 <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
10b0d1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp)
10b0d8: e8 43 03 00 00 call 10b420 <pthread_cond_signal>
++aio_request_queue.idle_threads;
10b0dd: ff 05 e0 72 12 00 incl 0x1272e0
10b0e3: eb 09 jmp 10b0ee <rtems_aio_enqueue+0x1dd>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0e5: 51 push %ecx
10b0e6: 51 push %ecx
10b0e7: 53 push %ebx
10b0e8: 50 push %eax
10b0e9: e8 4e fd ff ff call 10ae3c <rtems_aio_insert_prio>
10b0ee: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b0f1: 83 ec 0c sub $0xc,%esp
10b0f4: 68 78 72 12 00 push $0x127278
10b0f9: e8 66 07 00 00 call 10b864 <pthread_mutex_unlock>
return 0;
10b0fe: 83 c4 10 add $0x10,%esp
}
10b101: 8b 45 b4 mov -0x4c(%ebp),%eax
10b104: 8d 65 f4 lea -0xc(%ebp),%esp
10b107: 5b pop %ebx
10b108: 5e pop %esi
10b109: 5f pop %edi
10b10a: c9 leave
10b10b: c3 ret
0010abeb <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10abeb: 55 push %ebp <== NOT EXECUTED
10abec: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10abee: 57 push %edi <== NOT EXECUTED
10abef: 56 push %esi <== NOT EXECUTED
10abf0: 53 push %ebx <== NOT EXECUTED
10abf1: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED
rtems_aio_request_chain *r_chain = arg;
10abf4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
10abf7: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED
10abfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10abfd: 57 push %edi <== NOT EXECUTED
10abfe: e8 e1 0b 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
10ac03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac06: 85 c0 test %eax,%eax <== NOT EXECUTED
10ac08: 0f 85 24 02 00 00 jne 10ae32 <rtems_aio_handle+0x247><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
10ac0e: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
10ac11: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
10ac14: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10ac16: 0f 84 cc 00 00 00 je 10ace8 <rtems_aio_handle+0xfd> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10ac1c: e8 c3 13 00 00 call 10bfe4 <pthread_self> <== NOT EXECUTED
10ac21: 52 push %edx <== NOT EXECUTED
10ac22: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED
10ac25: 52 push %edx <== NOT EXECUTED
10ac26: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED
10ac29: 51 push %ecx <== NOT EXECUTED
10ac2a: 50 push %eax <== NOT EXECUTED
10ac2b: e8 b8 0f 00 00 call 10bbe8 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
10ac30: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED
10ac33: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10ac36: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED
10ac39: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED
10ac3c: e8 a3 13 00 00 call 10bfe4 <pthread_self> <== NOT EXECUTED
10ac41: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ac44: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED
10ac47: 51 push %ecx <== NOT EXECUTED
10ac48: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED
10ac4b: 52 push %edx <== NOT EXECUTED
10ac4c: 50 push %eax <== NOT EXECUTED
10ac4d: e8 a2 13 00 00 call 10bff4 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ac52: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ac55: e8 e6 22 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10ac5a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ac5d: e8 02 0c 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
10ac62: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10ac65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ac68: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED
10ac6b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
10ac6e: 74 20 je 10ac90 <rtems_aio_handle+0xa5> <== NOT EXECUTED
10ac70: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
10ac73: 74 36 je 10acab <rtems_aio_handle+0xc0> <== NOT EXECUTED
10ac75: 4a dec %edx <== NOT EXECUTED
10ac76: 75 45 jne 10acbd <rtems_aio_handle+0xd2> <== NOT EXECUTED
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
10ac78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac7b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac7e: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac81: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac84: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac87: ff 30 pushl (%eax) <== NOT EXECUTED
10ac89: e8 ea 93 00 00 call 114078 <pread> <== NOT EXECUTED
10ac8e: eb 16 jmp 10aca6 <rtems_aio_handle+0xbb> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
10ac90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ac93: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10ac96: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED
10ac99: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED
10ac9c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
10ac9f: ff 30 pushl (%eax) <== NOT EXECUTED
10aca1: e8 8a 94 00 00 call 114130 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10aca6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10aca9: eb 0d jmp 10acb8 <rtems_aio_handle+0xcd> <== NOT EXECUTED
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
10acab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10acae: ff 30 pushl (%eax) <== NOT EXECUTED
10acb0: e8 27 5c 00 00 call 1108dc <fsync> <== NOT EXECUTED
break;
10acb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10acb8: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10acbb: 75 19 jne 10acd6 <rtems_aio_handle+0xeb> <== NOT EXECUTED
req->aiocbp->return_value = -1;
10acbd: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10acc0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10acc7: e8 70 89 00 00 call 11363c <__errno> <== NOT EXECUTED
10accc: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10acce: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10acd1: e9 21 ff ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10acd6: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED
10acd9: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED
req->aiocbp->error_code = 0;
10acdc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED
10ace3: e9 0f ff ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
10ace8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aceb: 57 push %edi <== NOT EXECUTED
10acec: e8 73 0b 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
10acf1: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED
10acf8: e8 e7 0a 00 00 call 10b7e4 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
10acfd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad00: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED
10ad03: 0f 85 ee fe ff ff jne 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ad09: 56 push %esi <== NOT EXECUTED
10ad0a: 56 push %esi <== NOT EXECUTED
10ad0b: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad0e: 50 push %eax <== NOT EXECUTED
10ad0f: 6a 01 push $0x1 <== NOT EXECUTED
10ad11: e8 5e 05 00 00 call 10b274 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad16: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad1a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
10ad21: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED
10ad24: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad27: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED
10ad2a: 52 push %edx <== NOT EXECUTED
10ad2b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ad30: 56 push %esi <== NOT EXECUTED
10ad31: e8 5a 07 00 00 call 10b490 <pthread_cond_timedwait><== NOT EXECUTED
&aio_request_queue.mutex, &timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad39: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10ad3c: 0f 85 b5 fe ff ff jne 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
10ad42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ad45: 53 push %ebx <== NOT EXECUTED
10ad46: e8 f5 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10ad4b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10ad4e: e8 71 08 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
10ad53: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ad56: e8 75 05 00 00 call 10b2d0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10ad5b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10ad5e: e8 dd cf ff ff call 107d40 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ad66: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED
10ad6d: 72 12 00
10ad70: 0f 85 a7 00 00 00 jne 10ae1d <rtems_aio_handle+0x232><== NOT EXECUTED
++aio_request_queue.idle_threads;
10ad76: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
10ad7c: 53 push %ebx <== NOT EXECUTED
10ad7d: 53 push %ebx <== NOT EXECUTED
10ad7e: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED
10ad81: 51 push %ecx <== NOT EXECUTED
10ad82: 6a 01 push $0x1 <== NOT EXECUTED
10ad84: e8 eb 04 00 00 call 10b274 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10ad89: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10ad8d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10ad94: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10ad97: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10ad9a: 50 push %eax <== NOT EXECUTED
10ad9b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ada0: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED
10ada5: e8 e6 06 00 00 call 10b490 <pthread_cond_timedwait><== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10adaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10adad: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10adb0: 75 12 jne 10adc4 <rtems_aio_handle+0x1d9><== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
10adb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10adb5: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10adba: e8 a5 0a 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
10adbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10adc2: eb 6e jmp 10ae32 <rtems_aio_handle+0x247><== NOT EXECUTED
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
10adc4: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10adca: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED
10add0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10add3: 56 push %esi <== NOT EXECUTED
10add4: e8 67 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10add9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10addc: 6a 01 push $0x1 <== NOT EXECUTED
10adde: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
10ade1: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED
10ade6: e8 55 fd ff ff call 10ab40 <rtems_aio_search_fd> <== NOT EXECUTED
10adeb: 89 c3 mov %eax,%ebx <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
10aded: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
10adf4: 5a pop %edx <== NOT EXECUTED
10adf5: 59 pop %ecx <== NOT EXECUTED
10adf6: 6a 00 push $0x0 <== NOT EXECUTED
10adf8: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED
10adfb: 50 push %eax <== NOT EXECUTED
10adfc: e8 c3 08 00 00 call 10b6c4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
10ae01: 5f pop %edi <== NOT EXECUTED
10ae02: 58 pop %eax <== NOT EXECUTED
10ae03: 6a 00 push $0x0 <== NOT EXECUTED
10ae05: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED
10ae08: 50 push %eax <== NOT EXECUTED
10ae09: e8 76 05 00 00 call 10b384 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
10ae0e: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED
10ae11: 83 c6 08 add $0x8,%esi <== NOT EXECUTED
10ae14: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED
10ae19: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10ae1b: eb 0d jmp 10ae2a <rtems_aio_handle+0x23f><== NOT EXECUTED
}
else
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
10ae1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ae20: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10ae25: e8 3a 0a 00 00 call 10b864 <pthread_mutex_unlock> <== NOT EXECUTED
10ae2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ae2d: e9 c5 fd ff ff jmp 10abf7 <rtems_aio_handle+0xc> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae32: 31 c0 xor %eax,%eax <== NOT EXECUTED
10ae34: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ae37: 5b pop %ebx <== NOT EXECUTED
10ae38: 5e pop %esi <== NOT EXECUTED
10ae39: 5f pop %edi <== NOT EXECUTED
10ae3a: c9 leave <== NOT EXECUTED
10ae3b: c3 ret <== NOT EXECUTED
0010aa44 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aa44: 55 push %ebp
10aa45: 89 e5 mov %esp,%ebp
10aa47: 53 push %ebx
10aa48: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aa4b: 68 80 72 12 00 push $0x127280
10aa50: e8 13 0f 00 00 call 10b968 <pthread_attr_init>
10aa55: 89 c3 mov %eax,%ebx
if (result != 0)
10aa57: 83 c4 10 add $0x10,%esp
10aa5a: 85 c0 test %eax,%eax
10aa5c: 0f 85 d7 00 00 00 jne 10ab39 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aa62: 51 push %ecx
10aa63: 51 push %ecx
10aa64: 6a 00 push $0x0
10aa66: 68 80 72 12 00 push $0x127280
10aa6b: e8 20 0f 00 00 call 10b990 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aa70: 83 c4 10 add $0x10,%esp
10aa73: 85 c0 test %eax,%eax
10aa75: 74 10 je 10aa87 <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa7a: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aa7f: e8 c4 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aa84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aa87: 52 push %edx
10aa88: 52 push %edx
10aa89: 6a 00 push $0x0
10aa8b: 68 78 72 12 00 push $0x127278
10aa90: e8 2f 0c 00 00 call 10b6c4 <pthread_mutex_init>
if (result != 0)
10aa95: 83 c4 10 add $0x10,%esp
10aa98: 85 c0 test %eax,%eax
10aa9a: 74 10 je 10aaac <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa9f: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED
10aaa4: e8 9f 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aaa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10aaac: 50 push %eax
10aaad: 50 push %eax
10aaae: 6a 00 push $0x0
10aab0: 68 7c 72 12 00 push $0x12727c
10aab5: e8 ca 08 00 00 call 10b384 <pthread_cond_init>
10aaba: 89 c3 mov %eax,%ebx
if (result != 0) {
10aabc: 83 c4 10 add $0x10,%esp
10aabf: 85 c0 test %eax,%eax
10aac1: 74 1c je 10aadf <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10aac3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aac6: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED
10aacb: e8 f4 0a 00 00 call 10b5c4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10aad0: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED
10aad7: e8 6c 0e 00 00 call 10b948 <pthread_attr_destroy> <== NOT EXECUTED
10aadc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10aadf: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0
10aae6: 72 12 00
the_chain->permanent_null = NULL;
10aae9: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4
10aaf0: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10aaf3: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8
10aafa: 72 12 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
10aafd: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc
10ab04: 72 12 00
the_chain->permanent_null = NULL;
10ab07: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0
10ab0e: 00 00 00
the_chain->last = _Chain_Head(the_chain);
10ab11: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4
10ab18: 72 12 00
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
10ab1b: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc
10ab22: 00 00 00
aio_request_queue.idle_threads = 0;
10ab25: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0
10ab2c: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab2f: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8
10ab36: b0 00 00
return result;
}
10ab39: 89 d8 mov %ebx,%eax
10ab3b: 8b 5d fc mov -0x4(%ebp),%ebx
10ab3e: c9 leave
10ab3f: c3 ret
0010ae3c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae3c: 55 push %ebp
10ae3d: 89 e5 mov %esp,%ebp
10ae3f: 56 push %esi
10ae40: 53 push %ebx
10ae41: 8b 4d 08 mov 0x8(%ebp),%ecx
10ae44: 8b 55 0c mov 0xc(%ebp),%edx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae47: 8b 01 mov (%ecx),%eax
10ae49: 8d 59 04 lea 0x4(%ecx),%ebx
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
10ae4c: 39 d8 cmp %ebx,%eax
10ae4e: 74 27 je 10ae77 <rtems_aio_insert_prio+0x3b><== NEVER TAKEN
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10ae50: 8b 48 14 mov 0x14(%eax),%ecx
10ae53: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10ae56: 8b 72 14 mov 0x14(%edx),%esi
10ae59: 8b 76 14 mov 0x14(%esi),%esi
10ae5c: eb 08 jmp 10ae66 <rtems_aio_insert_prio+0x2a>
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae5e: 8b 00 mov (%eax),%eax <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10ae60: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10ae63: 8b 49 14 mov 0x14(%ecx),%ecx <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10ae66: 39 ce cmp %ecx,%esi
10ae68: 7e 04 jle 10ae6e <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10ae6a: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10ae6c: 75 f0 jne 10ae5e <rtems_aio_insert_prio+0x22><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10ae6e: 89 55 0c mov %edx,0xc(%ebp)
10ae71: 8b 40 04 mov 0x4(%eax),%eax
10ae74: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10ae77: 5b pop %ebx
10ae78: 5e pop %esi
10ae79: c9 leave
10ae7a: e9 fd 20 00 00 jmp 10cf7c <_Chain_Insert>
0010ae7f <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10ae7f: 55 push %ebp <== NOT EXECUTED
10ae80: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10ae82: 56 push %esi <== NOT EXECUTED
10ae83: 53 push %ebx <== NOT EXECUTED
10ae84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae87: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED
10ae8a: 8d 70 0c lea 0xc(%eax),%esi <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10ae8d: eb 25 jmp 10aeb4 <rtems_aio_remove_fd+0x35><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ae8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ae92: 53 push %ebx <== NOT EXECUTED
10ae93: e8 a8 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
10ae98: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED
10ae9b: c7 42 30 8c 00 00 00 movl $0x8c,0x30(%edx) <== NOT EXECUTED
req->aiocbp->return_value = -1;
10aea2: c7 42 34 ff ff ff ff movl $0xffffffff,0x34(%edx) <== NOT EXECUTED
free (req);
10aea9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aeac: e8 8f ce ff ff call 107d40 <free> <== NOT EXECUTED
10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10aeb4: 39 f3 cmp %esi,%ebx <== NOT EXECUTED
10aeb6: 75 d7 jne 10ae8f <rtems_aio_remove_fd+0x10><== NOT EXECUTED
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10aeb8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10aebb: 5b pop %ebx <== NOT EXECUTED
10aebc: 5e pop %esi <== NOT EXECUTED
10aebd: c9 leave <== NOT EXECUTED
10aebe: c3 ret <== NOT EXECUTED
0010aebf <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
10aebf: 55 push %ebp <== NOT EXECUTED
10aec0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10aec2: 53 push %ebx <== NOT EXECUTED
10aec3: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
10aec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10aec9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aecc: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
10aece: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aed1: eb 02 jmp 10aed5 <rtems_aio_remove_req+0x16><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aed3: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aed5: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10aed7: 74 2e je 10af07 <rtems_aio_remove_req+0x48><== NOT EXECUTED
10aed9: 39 53 14 cmp %edx,0x14(%ebx) <== NOT EXECUTED
10aedc: 75 f5 jne 10aed3 <rtems_aio_remove_req+0x14><== NOT EXECUTED
10aede: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aee1: 53 push %ebx <== NOT EXECUTED
10aee2: e8 59 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10aee7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
10aeea: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) <== NOT EXECUTED
current->aiocbp->return_value = -1;
10aef1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) <== NOT EXECUTED
free (current);
10aef8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aefb: e8 40 ce ff ff call 107d40 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
10af00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10af03: 31 c0 xor %eax,%eax <== NOT EXECUTED
10af05: eb 05 jmp 10af0c <rtems_aio_remove_req+0x4d><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10af07: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10af0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10af0f: c9 leave <== NOT EXECUTED
10af10: c3 ret <== NOT EXECUTED
0010aaa8 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10aaa8: 55 push %ebp
10aaa9: 89 e5 mov %esp,%ebp
10aaab: 56 push %esi
10aaac: 53 push %ebx
10aaad: 8b 5d 10 mov 0x10(%ebp),%ebx
10aab0: 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 );
10aab3: 50 push %eax
10aab4: 50 push %eax
10aab5: ff 75 0c pushl 0xc(%ebp)
10aab8: ff 75 08 pushl 0x8(%ebp)
10aabb: e8 88 04 00 00 call 10af48 <_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 ) {
10aac0: 83 c4 10 add $0x10,%esp
10aac3: 84 c0 test %al,%al
10aac5: 74 11 je 10aad8 <rtems_chain_append_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10aac7: 89 75 0c mov %esi,0xc(%ebp)
10aaca: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10aacd: 8d 65 f8 lea -0x8(%ebp),%esp
10aad0: 5b pop %ebx
10aad1: 5e pop %esi
10aad2: 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 );
10aad3: e9 d4 f6 ff ff jmp 10a1ac <rtems_event_send>
}
return sc;
}
10aad8: 31 c0 xor %eax,%eax
10aada: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10aadd: 5b pop %ebx <== NOT EXECUTED
10aade: 5e pop %esi <== NOT EXECUTED
10aadf: c9 leave <== NOT EXECUTED
10aae0: c3 ret <== NOT EXECUTED
0010ab20 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10ab20: 55 push %ebp
10ab21: 89 e5 mov %esp,%ebp
10ab23: 57 push %edi
10ab24: 56 push %esi
10ab25: 53 push %ebx
10ab26: 83 ec 1c sub $0x1c,%esp
10ab29: 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(
10ab2c: 8d 75 e4 lea -0x1c(%ebp),%esi
10ab2f: eb 13 jmp 10ab44 <rtems_chain_get_with_wait+0x24>
10ab31: 56 push %esi
10ab32: ff 75 10 pushl 0x10(%ebp)
10ab35: 6a 00 push $0x0
10ab37: 57 push %edi
10ab38: e8 0f f5 ff ff call 10a04c <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10ab3d: 83 c4 10 add $0x10,%esp
10ab40: 85 c0 test %eax,%eax
10ab42: 75 16 jne 10ab5a <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 );
10ab44: 83 ec 0c sub $0xc,%esp
10ab47: ff 75 08 pushl 0x8(%ebp)
10ab4a: e8 99 04 00 00 call 10afe8 <_Chain_Get>
10ab4f: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10ab51: 83 c4 10 add $0x10,%esp
10ab54: 85 c0 test %eax,%eax
10ab56: 74 d9 je 10ab31 <rtems_chain_get_with_wait+0x11>
10ab58: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10ab5a: 8b 55 14 mov 0x14(%ebp),%edx
10ab5d: 89 1a mov %ebx,(%edx)
return sc;
}
10ab5f: 8d 65 f4 lea -0xc(%ebp),%esp
10ab62: 5b pop %ebx
10ab63: 5e pop %esi
10ab64: 5f pop %edi
10ab65: c9 leave
10ab66: c3 ret
0010ab68 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10ab68: 55 push %ebp
10ab69: 89 e5 mov %esp,%ebp
10ab6b: 56 push %esi
10ab6c: 53 push %ebx
10ab6d: 8b 5d 10 mov 0x10(%ebp),%ebx
10ab70: 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 );
10ab73: 50 push %eax
10ab74: 50 push %eax
10ab75: ff 75 0c pushl 0xc(%ebp)
10ab78: ff 75 08 pushl 0x8(%ebp)
10ab7b: e8 ac 04 00 00 call 10b02c <_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) {
10ab80: 83 c4 10 add $0x10,%esp
10ab83: 84 c0 test %al,%al
10ab85: 74 11 je 10ab98 <rtems_chain_prepend_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ab87: 89 75 0c mov %esi,0xc(%ebp)
10ab8a: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ab8d: 8d 65 f8 lea -0x8(%ebp),%esp
10ab90: 5b pop %ebx
10ab91: 5e pop %esi
10ab92: 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 );
10ab93: e9 14 f6 ff ff jmp 10a1ac <rtems_event_send>
}
return sc;
}
10ab98: 31 c0 xor %eax,%eax
10ab9a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ab9d: 5b pop %ebx <== NOT EXECUTED
10ab9e: 5e pop %esi <== NOT EXECUTED
10ab9f: c9 leave <== NOT EXECUTED
10aba0: c3 ret <== NOT EXECUTED
0010b718 <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
)
{
10b718: 55 push %ebp
10b719: 89 e5 mov %esp,%ebp
10b71b: 57 push %edi
10b71c: 56 push %esi
10b71d: 53 push %ebx
10b71e: 83 ec 0c sub $0xc,%esp
10b721: 8b 5d 08 mov 0x8(%ebp),%ebx
10b724: 8b 75 0c mov 0xc(%ebp),%esi
10b727: 8b 45 10 mov 0x10(%ebp),%eax
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10b72a: 8b 15 20 7d 12 00 mov 0x127d20,%edx
if ( rtems_interrupt_is_in_progress() )
10b730: 83 3d e8 78 12 00 00 cmpl $0x0,0x1278e8
10b737: 0f 85 cc 00 00 00 jne 10b809 <rtems_io_register_driver+0xf1><== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10b73d: 85 c0 test %eax,%eax
10b73f: 0f 84 cb 00 00 00 je 10b810 <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10b745: 89 10 mov %edx,(%eax)
if ( driver_table == NULL )
10b747: 85 f6 test %esi,%esi
10b749: 0f 84 c1 00 00 00 je 10b810 <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;
10b74f: 83 3e 00 cmpl $0x0,(%esi)
10b752: 0f 85 cc 00 00 00 jne 10b824 <rtems_io_register_driver+0x10c>
10b758: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b75c: 0f 85 c2 00 00 00 jne 10b824 <rtems_io_register_driver+0x10c>
10b762: e9 a9 00 00 00 jmp 10b810 <rtems_io_register_driver+0xf8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b767: 8b 15 9c 73 12 00 mov 0x12739c,%edx
10b76d: 42 inc %edx
10b76e: 89 15 9c 73 12 00 mov %edx,0x12739c
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10b774: 85 db test %ebx,%ebx
10b776: 75 32 jne 10b7aa <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;
10b778: 8b 0d 20 7d 12 00 mov 0x127d20,%ecx
10b77e: 8b 15 24 7d 12 00 mov 0x127d24,%edx
10b784: eb 15 jmp 10b79b <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;
10b786: 83 3a 00 cmpl $0x0,(%edx)
10b789: 0f 85 9f 00 00 00 jne 10b82e <rtems_io_register_driver+0x116>
10b78f: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b793: 0f 85 95 00 00 00 jne 10b82e <rtems_io_register_driver+0x116>
10b799: eb 04 jmp 10b79f <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 ) {
10b79b: 39 cb cmp %ecx,%ebx
10b79d: 72 e7 jb 10b786 <rtems_io_register_driver+0x6e>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10b79f: 89 18 mov %ebx,(%eax)
if ( m != n )
10b7a1: 39 cb cmp %ecx,%ebx
10b7a3: 75 30 jne 10b7d5 <rtems_io_register_driver+0xbd>
10b7a5: e9 8d 00 00 00 jmp 10b837 <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;
10b7aa: 6b d3 18 imul $0x18,%ebx,%edx
10b7ad: 03 15 24 7d 12 00 add 0x127d24,%edx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b7b3: 31 c9 xor %ecx,%ecx
10b7b5: 83 3a 00 cmpl $0x0,(%edx)
10b7b8: 75 09 jne 10b7c3 <rtems_io_register_driver+0xab>
10b7ba: 31 c9 xor %ecx,%ecx
10b7bc: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b7c0: 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 ) ) {
10b7c3: 85 c9 test %ecx,%ecx
10b7c5: 75 0c jne 10b7d3 <rtems_io_register_driver+0xbb>
_Thread_Enable_dispatch();
10b7c7: e8 2a 18 00 00 call 10cff6 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b7cc: b8 0c 00 00 00 mov $0xc,%eax
10b7d1: eb 49 jmp 10b81c <rtems_io_register_driver+0x104>
}
*registered_major = major;
10b7d3: 89 18 mov %ebx,(%eax)
}
_IO_Driver_address_table [major] = *driver_table;
10b7d5: 6b c3 18 imul $0x18,%ebx,%eax
10b7d8: 03 05 24 7d 12 00 add 0x127d24,%eax
10b7de: b9 06 00 00 00 mov $0x6,%ecx
10b7e3: 89 c7 mov %eax,%edi
10b7e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10b7e7: e8 0a 18 00 00 call 10cff6 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10b7ec: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10b7f3: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10b7fa: 89 5d 08 mov %ebx,0x8(%ebp)
}
10b7fd: 83 c4 0c add $0xc,%esp
10b800: 5b pop %ebx
10b801: 5e pop %esi
10b802: 5f pop %edi
10b803: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10b804: e9 a3 70 00 00 jmp 1128ac <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10b809: b8 12 00 00 00 mov $0x12,%eax
10b80e: eb 0c jmp 10b81c <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;
10b810: b8 09 00 00 00 mov $0x9,%eax
10b815: eb 05 jmp 10b81c <rtems_io_register_driver+0x104>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10b817: 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 );
}
10b81c: 83 c4 0c add $0xc,%esp
10b81f: 5b pop %ebx
10b820: 5e pop %esi
10b821: 5f pop %edi
10b822: c9 leave
10b823: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10b824: 39 d3 cmp %edx,%ebx
10b826: 0f 82 3b ff ff ff jb 10b767 <rtems_io_register_driver+0x4f>
10b82c: eb e9 jmp 10b817 <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 ) {
10b82e: 43 inc %ebx
10b82f: 83 c2 18 add $0x18,%edx
10b832: e9 64 ff ff ff jmp 10b79b <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();
10b837: e8 ba 17 00 00 call 10cff6 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10b83c: 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;
10b841: eb d9 jmp 10b81c <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_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10c758: 8b 04 9d e0 00 13 00 mov 0x1300e0(,%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
001147e8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1147e8: 55 push %ebp
1147e9: 89 e5 mov %esp,%ebp
1147eb: 57 push %edi
1147ec: 56 push %esi
1147ed: 53 push %ebx
1147ee: 83 ec 1c sub $0x1c,%esp
1147f1: 8b 75 0c mov 0xc(%ebp),%esi
1147f4: 8b 55 10 mov 0x10(%ebp),%edx
1147f7: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1147fa: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1147ff: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
114803: 0f 84 ce 00 00 00 je 1148d7 <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
114809: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
11480b: 85 f6 test %esi,%esi
11480d: 0f 84 c4 00 00 00 je 1148d7 <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
114813: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
114817: 0f 84 ba 00 00 00 je 1148d7 <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11481d: 85 ff test %edi,%edi
11481f: 0f 84 ad 00 00 00 je 1148d2 <rtems_partition_create+0xea>
114825: 85 d2 test %edx,%edx
114827: 0f 84 a5 00 00 00 je 1148d2 <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
11482d: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11482f: 39 fa cmp %edi,%edx
114831: 0f 82 a0 00 00 00 jb 1148d7 <rtems_partition_create+0xef>
114837: f7 c7 03 00 00 00 test $0x3,%edi
11483d: 0f 85 94 00 00 00 jne 1148d7 <rtems_partition_create+0xef>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
114843: b0 09 mov $0x9,%al
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
114845: f7 c6 03 00 00 00 test $0x3,%esi
11484b: 0f 85 86 00 00 00 jne 1148d7 <rtems_partition_create+0xef>
114851: a1 b8 d6 13 00 mov 0x13d6b8,%eax
114856: 40 inc %eax
114857: a3 b8 d6 13 00 mov %eax,0x13d6b8
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
11485c: 83 ec 0c sub $0xc,%esp
11485f: 68 44 d5 13 00 push $0x13d544
114864: 89 55 e4 mov %edx,-0x1c(%ebp)
114867: e8 20 3e 00 00 call 11868c <_Objects_Allocate>
11486c: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
11486e: 83 c4 10 add $0x10,%esp
114871: 85 c0 test %eax,%eax
114873: 8b 55 e4 mov -0x1c(%ebp),%edx
114876: 75 0c jne 114884 <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
114878: e8 59 4a 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
11487d: b8 05 00 00 00 mov $0x5,%eax
114882: eb 53 jmp 1148d7 <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
114884: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
114887: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
11488a: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
11488d: 8b 45 18 mov 0x18(%ebp),%eax
114890: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
114893: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
11489a: 57 push %edi
11489b: 89 d0 mov %edx,%eax
11489d: 31 d2 xor %edx,%edx
11489f: f7 f7 div %edi
1148a1: 50 push %eax
1148a2: 56 push %esi
1148a3: 8d 43 24 lea 0x24(%ebx),%eax
1148a6: 50 push %eax
1148a7: e8 80 2a 00 00 call 11732c <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1148ac: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1148af: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1148b2: 8b 15 60 d5 13 00 mov 0x13d560,%edx
1148b8: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1148bb: 8b 55 08 mov 0x8(%ebp),%edx
1148be: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1148c1: 8b 55 1c mov 0x1c(%ebp),%edx
1148c4: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1148c6: e8 0b 4a 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1148cb: 83 c4 10 add $0x10,%esp
1148ce: 31 c0 xor %eax,%eax
1148d0: eb 05 jmp 1148d7 <rtems_partition_create+0xef>
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
1148d2: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1148d7: 8d 65 f4 lea -0xc(%ebp),%esp
1148da: 5b pop %ebx
1148db: 5e pop %esi
1148dc: 5f pop %edi
1148dd: c9 leave
1148de: c3 ret
0010b03d <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b03d: 55 push %ebp
10b03e: 89 e5 mov %esp,%ebp
10b040: 57 push %edi
10b041: 56 push %esi
10b042: 53 push %ebx
10b043: 83 ec 30 sub $0x30,%esp
10b046: 8b 75 08 mov 0x8(%ebp),%esi
10b049: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
10b04c: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b04f: 50 push %eax
10b050: 56 push %esi
10b051: 68 14 73 12 00 push $0x127314
10b056: e8 3d 1e 00 00 call 10ce98 <_Objects_Get>
10b05b: 89 c7 mov %eax,%edi
switch ( location ) {
10b05d: 83 c4 10 add $0x10,%esp
10b060: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b064: 0f 85 3b 01 00 00 jne 10b1a5 <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b06a: a1 58 79 12 00 mov 0x127958,%eax
10b06f: 39 47 40 cmp %eax,0x40(%edi)
10b072: 74 0f je 10b083 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b074: e8 fd 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b079: be 17 00 00 00 mov $0x17,%esi
10b07e: e9 27 01 00 00 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b083: 85 db test %ebx,%ebx
10b085: 75 1b jne 10b0a2 <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b087: 8b 47 38 mov 0x38(%edi),%eax
10b08a: 31 f6 xor %esi,%esi
10b08c: 83 f8 04 cmp $0x4,%eax
10b08f: 77 07 ja 10b098 <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b091: 8b 34 85 00 0d 12 00 mov 0x120d00(,%eax,4),%esi
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b098: e8 d9 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return( return_value );
10b09d: e9 08 01 00 00 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b0a2: 9c pushf
10b0a3: fa cli
10b0a4: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b0a7: 8b 47 38 mov 0x38(%edi),%eax
10b0aa: 85 c0 test %eax,%eax
10b0ac: 75 4c jne 10b0fa <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0ae: ff 75 d4 pushl -0x2c(%ebp)
10b0b1: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0b2: 83 ec 0c sub $0xc,%esp
10b0b5: 57 push %edi
10b0b6: e8 3f fe ff ff call 10aefa <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b0bb: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b0c2: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b0c9: c7 47 2c b4 b3 10 00 movl $0x10b3b4,0x2c(%edi)
the_watchdog->id = id;
10b0d0: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b0d3: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b0da: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b0dd: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b0e0: 58 pop %eax
10b0e1: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b0e2: 83 c7 10 add $0x10,%edi
10b0e5: 57 push %edi
10b0e6: 68 d0 74 12 00 push $0x1274d0
10b0eb: e8 ec 34 00 00 call 10e5dc <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b0f0: e8 81 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b0f5: 83 c4 10 add $0x10,%esp
10b0f8: eb 65 jmp 10b15f <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b0fa: 83 f8 02 cmp $0x2,%eax
10b0fd: 75 64 jne 10b163 <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b0ff: 83 ec 0c sub $0xc,%esp
10b102: 57 push %edi
10b103: e8 5a fe ff ff call 10af62 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
10b108: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b10f: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b112: ff 75 d4 pushl -0x2c(%ebp)
10b115: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b116: a1 58 79 12 00 mov 0x127958,%eax
10b11b: 8b 57 08 mov 0x8(%edi),%edx
10b11e: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b121: 5b pop %ebx
10b122: 5e pop %esi
10b123: 68 00 40 00 00 push $0x4000
10b128: 50 push %eax
10b129: e8 42 2d 00 00 call 10de70 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b12e: 9c pushf
10b12f: fa cli
10b130: 5a pop %edx
local_state = the_period->state;
10b131: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b134: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b13b: 52 push %edx
10b13c: 9d popf
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
10b13d: 83 c4 10 add $0x10,%esp
10b140: 83 f8 03 cmp $0x3,%eax
10b143: 75 15 jne 10b15a <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b145: 51 push %ecx
10b146: 51 push %ecx
10b147: 68 00 40 00 00 push $0x4000
10b14c: ff 35 58 79 12 00 pushl 0x127958
10b152: e8 ad 21 00 00 call 10d304 <_Thread_Clear_state>
10b157: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b15a: e8 17 25 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b15f: 31 f6 xor %esi,%esi
10b161: eb 47 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b163: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b168: 83 f8 04 cmp $0x4,%eax
10b16b: 75 3d jne 10b1aa <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b16d: 83 ec 0c sub $0xc,%esp
10b170: 57 push %edi
10b171: e8 ec fd ff ff call 10af62 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b176: ff 75 d4 pushl -0x2c(%ebp)
10b179: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b17a: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b181: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b184: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b187: 58 pop %eax
10b188: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b189: 83 c7 10 add $0x10,%edi
10b18c: 57 push %edi
10b18d: 68 d0 74 12 00 push $0x1274d0
10b192: e8 45 34 00 00 call 10e5dc <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b197: e8 da 24 00 00 call 10d676 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b19c: 83 c4 10 add $0x10,%esp
10b19f: 66 be 06 00 mov $0x6,%si
10b1a3: eb 05 jmp 10b1aa <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1a5: be 04 00 00 00 mov $0x4,%esi
}
10b1aa: 89 f0 mov %esi,%eax
10b1ac: 8d 65 f4 lea -0xc(%ebp),%esp
10b1af: 5b pop %ebx
10b1b0: 5e pop %esi
10b1b1: 5f pop %edi
10b1b2: c9 leave
10b1b3: c3 ret
0010b1b4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1b4: 55 push %ebp
10b1b5: 89 e5 mov %esp,%ebp
10b1b7: 57 push %edi
10b1b8: 56 push %esi
10b1b9: 53 push %ebx
10b1ba: 83 ec 7c sub $0x7c,%esp
10b1bd: 8b 5d 08 mov 0x8(%ebp),%ebx
10b1c0: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10b1c3: 85 ff test %edi,%edi
10b1c5: 0f 84 2b 01 00 00 je 10b2f6 <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b1cb: 52 push %edx
10b1cc: 52 push %edx
10b1cd: 68 14 0d 12 00 push $0x120d14
10b1d2: 53 push %ebx
10b1d3: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b1d5: 5e pop %esi
10b1d6: 58 pop %eax
10b1d7: 68 32 0d 12 00 push $0x120d32
10b1dc: 53 push %ebx
10b1dd: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b1df: 5a pop %edx
10b1e0: 59 pop %ecx
10b1e1: 68 54 0d 12 00 push $0x120d54
10b1e6: 53 push %ebx
10b1e7: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b1e9: 5e pop %esi
10b1ea: 58 pop %eax
10b1eb: 68 77 0d 12 00 push $0x120d77
10b1f0: 53 push %ebx
10b1f1: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b1f3: 5a pop %edx
10b1f4: 59 pop %ecx
10b1f5: 68 c2 0d 12 00 push $0x120dc2
10b1fa: 53 push %ebx
10b1fb: ff d7 call *%edi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b1fd: 8b 35 1c 73 12 00 mov 0x12731c,%esi
10b203: 83 c4 10 add $0x10,%esp
10b206: e9 df 00 00 00 jmp 10b2ea <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b20b: 50 push %eax
10b20c: 50 push %eax
10b20d: 8d 45 88 lea -0x78(%ebp),%eax
10b210: 50 push %eax
10b211: 56 push %esi
10b212: e8 39 56 00 00 call 110850 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b217: 83 c4 10 add $0x10,%esp
10b21a: 85 c0 test %eax,%eax
10b21c: 0f 85 c7 00 00 00 jne 10b2e9 <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
10b222: 51 push %ecx
10b223: 51 push %ecx
10b224: 8d 55 c0 lea -0x40(%ebp),%edx
10b227: 52 push %edx
10b228: 56 push %esi
10b229: e8 c6 56 00 00 call 1108f4 <rtems_rate_monotonic_get_status>
#if defined(RTEMS_DEBUG)
if ( status != RTEMS_SUCCESSFUL )
continue;
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b22e: 83 c4 0c add $0xc,%esp
10b231: 8d 45 e3 lea -0x1d(%ebp),%eax
10b234: 50 push %eax
10b235: 6a 05 push $0x5
10b237: ff 75 c0 pushl -0x40(%ebp)
10b23a: e8 01 02 00 00 call 10b440 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b23f: 58 pop %eax
10b240: 5a pop %edx
10b241: ff 75 8c pushl -0x74(%ebp)
10b244: ff 75 88 pushl -0x78(%ebp)
10b247: 8d 55 e3 lea -0x1d(%ebp),%edx
10b24a: 52 push %edx
10b24b: 56 push %esi
10b24c: 68 0e 0e 12 00 push $0x120e0e
10b251: 53 push %ebx
10b252: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b254: 8b 45 88 mov -0x78(%ebp),%eax
10b257: 83 c4 20 add $0x20,%esp
10b25a: 85 c0 test %eax,%eax
10b25c: 75 0f jne 10b26d <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b25e: 51 push %ecx
10b25f: 51 push %ecx
10b260: 68 88 10 12 00 push $0x121088
10b265: 53 push %ebx
10b266: ff d7 call *%edi
continue;
10b268: 83 c4 10 add $0x10,%esp
10b26b: eb 7c jmp 10b2e9 <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
10b26d: 52 push %edx
10b26e: 8d 55 d8 lea -0x28(%ebp),%edx
10b271: 52 push %edx
10b272: 50 push %eax
10b273: 8d 45 a0 lea -0x60(%ebp),%eax
10b276: 50 push %eax
10b277: e8 34 30 00 00 call 10e2b0 <_Timespec_Divide_by_integer>
(*print)( context,
10b27c: 8b 45 dc mov -0x24(%ebp),%eax
10b27f: b9 e8 03 00 00 mov $0x3e8,%ecx
10b284: 99 cltd
10b285: f7 f9 idiv %ecx
10b287: 50 push %eax
10b288: ff 75 d8 pushl -0x28(%ebp)
10b28b: 8b 45 9c mov -0x64(%ebp),%eax
10b28e: 99 cltd
10b28f: f7 f9 idiv %ecx
10b291: 50 push %eax
10b292: ff 75 98 pushl -0x68(%ebp)
10b295: 8b 45 94 mov -0x6c(%ebp),%eax
10b298: 99 cltd
10b299: f7 f9 idiv %ecx
10b29b: 50 push %eax
10b29c: ff 75 90 pushl -0x70(%ebp)
10b29f: 68 25 0e 12 00 push $0x120e25
10b2a4: 53 push %ebx
10b2a5: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b2a8: ff d7 call *%edi
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2aa: 83 c4 2c add $0x2c,%esp
10b2ad: 8d 55 d8 lea -0x28(%ebp),%edx
10b2b0: 52 push %edx
10b2b1: ff 75 88 pushl -0x78(%ebp)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
10b2b4: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2b7: 50 push %eax
10b2b8: e8 f3 2f 00 00 call 10e2b0 <_Timespec_Divide_by_integer>
(*print)( context,
10b2bd: 8b 45 dc mov -0x24(%ebp),%eax
10b2c0: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b2c3: 99 cltd
10b2c4: f7 f9 idiv %ecx
10b2c6: 50 push %eax
10b2c7: ff 75 d8 pushl -0x28(%ebp)
10b2ca: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2cd: 99 cltd
10b2ce: f7 f9 idiv %ecx
10b2d0: 50 push %eax
10b2d1: ff 75 b0 pushl -0x50(%ebp)
10b2d4: 8b 45 ac mov -0x54(%ebp),%eax
10b2d7: 99 cltd
10b2d8: f7 f9 idiv %ecx
10b2da: 50 push %eax
10b2db: ff 75 a8 pushl -0x58(%ebp)
10b2de: 68 44 0e 12 00 push $0x120e44
10b2e3: 53 push %ebx
10b2e4: ff d7 call *%edi
10b2e6: 83 c4 30 add $0x30,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10b2e9: 46 inc %esi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b2ea: 3b 35 20 73 12 00 cmp 0x127320,%esi
10b2f0: 0f 86 15 ff ff ff jbe 10b20b <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b2f6: 8d 65 f4 lea -0xc(%ebp),%esp
10b2f9: 5b pop %ebx
10b2fa: 5e pop %esi
10b2fb: 5f pop %edi
10b2fc: c9 leave
10b2fd: c3 ret
00115b48 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115b48: 55 push %ebp
115b49: 89 e5 mov %esp,%ebp
115b4b: 53 push %ebx
115b4c: 83 ec 14 sub $0x14,%esp
115b4f: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115b52: b8 0a 00 00 00 mov $0xa,%eax
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
115b57: 85 db test %ebx,%ebx
115b59: 74 6d je 115bc8 <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115b5b: 50 push %eax
115b5c: 50 push %eax
115b5d: 8d 45 f4 lea -0xc(%ebp),%eax
115b60: 50 push %eax
115b61: ff 75 08 pushl 0x8(%ebp)
115b64: e8 8f 37 00 00 call 1192f8 <_Thread_Get>
switch ( location ) {
115b69: 83 c4 10 add $0x10,%esp
115b6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115b70: 75 51 jne 115bc3 <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115b72: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115b78: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115b7c: 74 39 je 115bb7 <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115b7e: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115b82: 74 22 je 115ba6 <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115b84: 9c pushf
115b85: fa cli
115b86: 59 pop %ecx
*signal_set |= signals;
115b87: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115b8a: 51 push %ecx
115b8b: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115b8c: 83 3d 0c dc 13 00 00 cmpl $0x0,0x13dc0c
115b93: 74 19 je 115bae <rtems_signal_send+0x66>
115b95: 3b 05 10 dc 13 00 cmp 0x13dc10,%eax
115b9b: 75 11 jne 115bae <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115b9d: c6 05 1c dc 13 00 01 movb $0x1,0x13dc1c
115ba4: eb 08 jmp 115bae <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115ba6: 9c pushf
115ba7: fa cli
115ba8: 58 pop %eax
*signal_set |= signals;
115ba9: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115bac: 50 push %eax
115bad: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115bae: e8 23 37 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115bb3: 31 c0 xor %eax,%eax
115bb5: eb 11 jmp 115bc8 <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115bb7: e8 1a 37 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115bbc: b8 0b 00 00 00 mov $0xb,%eax
115bc1: eb 05 jmp 115bc8 <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115bc3: b8 04 00 00 00 mov $0x4,%eax
}
115bc8: 8b 5d fc mov -0x4(%ebp),%ebx
115bcb: c9 leave
115bcc: c3 ret
00110cdc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110cdc: 55 push %ebp
110cdd: 89 e5 mov %esp,%ebp
110cdf: 57 push %edi
110ce0: 56 push %esi
110ce1: 53 push %ebx
110ce2: 83 ec 1c sub $0x1c,%esp
110ce5: 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;
110ce8: 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 )
110ced: 85 c9 test %ecx,%ecx
110cef: 0f 84 fb 00 00 00 je 110df0 <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110cf5: 8b 35 34 48 12 00 mov 0x124834,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110cfb: 8b 9e f4 00 00 00 mov 0xf4(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d01: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110d05: 19 ff sbb %edi,%edi
110d07: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110d0d: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110d11: 74 06 je 110d19 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110d13: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110d19: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110d1d: 19 d2 sbb %edx,%edx
110d1f: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110d25: 89 55 e4 mov %edx,-0x1c(%ebp)
110d28: 89 4d e0 mov %ecx,-0x20(%ebp)
110d2b: e8 65 c5 ff ff call 10d295 <_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;
110d30: 8b 55 e4 mov -0x1c(%ebp),%edx
110d33: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110d35: 09 f8 or %edi,%eax
110d37: 8b 4d e0 mov -0x20(%ebp),%ecx
110d3a: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110d3c: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110d43: 74 0b je 110d50 <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110d45: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110d4c: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110d50: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110d57: 74 21 je 110d7a <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110d59: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110d60: 74 11 je 110d73 <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110d62: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110d69: a1 b4 42 12 00 mov 0x1242b4,%eax
110d6e: 89 46 78 mov %eax,0x78(%esi)
110d71: eb 07 jmp 110d7a <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110d73: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110d7a: f6 45 0c 01 testb $0x1,0xc(%ebp)
110d7e: 74 0a je 110d8a <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 ) );
110d80: f6 45 08 01 testb $0x1,0x8(%ebp)
110d84: 74 03 je 110d89 <rtems_task_mode+0xad>
110d86: fa cli
110d87: eb 01 jmp 110d8a <rtems_task_mode+0xae>
110d89: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110d8a: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110d8c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110d93: 74 2a je 110dbf <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110d95: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110d9c: 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 ) {
110d9f: 3a 43 08 cmp 0x8(%ebx),%al
110da2: 74 1b je 110dbf <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110da4: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110da7: 9c pushf
110da8: fa cli
110da9: 58 pop %eax
_signals = information->signals_pending;
110daa: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110dad: 8b 4b 14 mov 0x14(%ebx),%ecx
110db0: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110db3: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110db6: 50 push %eax
110db7: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110db8: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110dbc: 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;
110dbf: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110dc1: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464
110dc8: 75 26 jne 110df0 <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110dca: 8b 15 34 48 12 00 mov 0x124834,%edx
if ( are_signals_pending ||
110dd0: 84 c9 test %cl,%cl
110dd2: 75 0e jne 110de2 <rtems_task_mode+0x106>
110dd4: 3b 15 38 48 12 00 cmp 0x124838,%edx
110dda: 74 14 je 110df0 <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110ddc: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110de0: 74 0e je 110df0 <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110de2: c6 05 40 48 12 00 01 movb $0x1,0x124840
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110de9: e8 a6 af ff ff call 10bd94 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110dee: 31 c0 xor %eax,%eax
}
110df0: 83 c4 1c add $0x1c,%esp
110df3: 5b pop %ebx
110df4: 5e pop %esi
110df5: 5f pop %edi
110df6: c9 leave
110df7: c3 ret
0010dd34 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd34: 55 push %ebp
10dd35: 89 e5 mov %esp,%ebp
10dd37: 56 push %esi
10dd38: 53 push %ebx
10dd39: 83 ec 10 sub $0x10,%esp
10dd3c: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd3f: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd42: 85 db test %ebx,%ebx
10dd44: 74 10 je 10dd56 <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 ) );
10dd46: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd4d: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd52: 39 d3 cmp %edx,%ebx
10dd54: 77 52 ja 10dda8 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dd56: 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 )
10dd5b: 85 f6 test %esi,%esi
10dd5d: 74 49 je 10dda8 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10dd5f: 51 push %ecx
10dd60: 51 push %ecx
10dd61: 8d 45 f4 lea -0xc(%ebp),%eax
10dd64: 50 push %eax
10dd65: ff 75 08 pushl 0x8(%ebp)
10dd68: e8 f7 1b 00 00 call 10f964 <_Thread_Get>
switch ( location ) {
10dd6d: 83 c4 10 add $0x10,%esp
10dd70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10dd74: 75 2d jne 10dda3 <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10dd76: 8b 50 14 mov 0x14(%eax),%edx
10dd79: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10dd7b: 85 db test %ebx,%ebx
10dd7d: 74 1b je 10dd9a <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10dd7f: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10dd82: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10dd86: 74 05 je 10dd8d <rtems_task_set_priority+0x59>
10dd88: 39 58 14 cmp %ebx,0x14(%eax)
10dd8b: 76 0d jbe 10dd9a <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dd8d: 52 push %edx
10dd8e: 6a 00 push $0x0
10dd90: 53 push %ebx
10dd91: 50 push %eax
10dd92: e8 19 17 00 00 call 10f4b0 <_Thread_Change_priority>
10dd97: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10dd9a: e8 a3 1b 00 00 call 10f942 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10dd9f: 31 c0 xor %eax,%eax
10dda1: eb 05 jmp 10dda8 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10dda3: b8 04 00 00 00 mov $0x4,%eax
}
10dda8: 8d 65 f8 lea -0x8(%ebp),%esp
10ddab: 5b pop %ebx
10ddac: 5e pop %esi
10ddad: c9 leave
10ddae: c3 ret
00116394 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
116394: 55 push %ebp
116395: 89 e5 mov %esp,%ebp
116397: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
11639a: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
11639d: 50 push %eax
11639e: ff 75 08 pushl 0x8(%ebp)
1163a1: 68 04 e0 13 00 push $0x13e004
1163a6: e8 4d 27 00 00 call 118af8 <_Objects_Get>
switch ( location ) {
1163ab: 83 c4 10 add $0x10,%esp
1163ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1163b2: 75 1e jne 1163d2 <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1163b4: 83 78 38 04 cmpl $0x4,0x38(%eax)
1163b8: 74 0f je 1163c9 <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
1163ba: 83 ec 0c sub $0xc,%esp
1163bd: 83 c0 10 add $0x10,%eax
1163c0: 50 push %eax
1163c1: e8 4e 41 00 00 call 11a514 <_Watchdog_Remove>
1163c6: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1163c9: e8 08 2f 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1163ce: 31 c0 xor %eax,%eax
1163d0: eb 05 jmp 1163d7 <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163d2: b8 04 00 00 00 mov $0x4,%eax
}
1163d7: c9 leave
1163d8: c3 ret
001167f4 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1167f4: 55 push %ebp
1167f5: 89 e5 mov %esp,%ebp
1167f7: 57 push %edi
1167f8: 56 push %esi
1167f9: 53 push %ebx
1167fa: 83 ec 1c sub $0x1c,%esp
1167fd: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116800: 8b 35 44 e0 13 00 mov 0x13e044,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
116806: 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 )
11680b: 85 f6 test %esi,%esi
11680d: 0f 84 b1 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
116813: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
116815: 80 3d cc d6 13 00 00 cmpb $0x0,0x13d6cc
11681c: 0f 84 a2 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
116822: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
116824: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
116828: 0f 84 96 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
11682e: 83 ec 0c sub $0xc,%esp
116831: 57 push %edi
116832: e8 b5 d6 ff ff call 113eec <_TOD_Validate>
116837: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
11683a: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
11683c: 84 c0 test %al,%al
11683e: 0f 84 80 00 00 00 je 1168c4 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
116844: 83 ec 0c sub $0xc,%esp
116847: 57 push %edi
116848: e8 37 d6 ff ff call 113e84 <_TOD_To_seconds>
11684d: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11684f: 83 c4 10 add $0x10,%esp
116852: 3b 05 44 d7 13 00 cmp 0x13d744,%eax
116858: 76 6a jbe 1168c4 <rtems_timer_server_fire_when+0xd0>
11685a: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11685b: 8d 45 e4 lea -0x1c(%ebp),%eax
11685e: 50 push %eax
11685f: ff 75 08 pushl 0x8(%ebp)
116862: 68 04 e0 13 00 push $0x13e004
116867: e8 8c 22 00 00 call 118af8 <_Objects_Get>
11686c: 89 c3 mov %eax,%ebx
switch ( location ) {
11686e: 83 c4 10 add $0x10,%esp
116871: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
116875: 75 48 jne 1168bf <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
116877: 83 ec 0c sub $0xc,%esp
11687a: 8d 40 10 lea 0x10(%eax),%eax
11687d: 50 push %eax
11687e: e8 91 3c 00 00 call 11a514 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
116883: 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;
11688a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
116891: 8b 45 10 mov 0x10(%ebp),%eax
116894: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
116897: 8b 45 08 mov 0x8(%ebp),%eax
11689a: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
11689d: 8b 45 14 mov 0x14(%ebp),%eax
1168a0: 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();
1168a3: 2b 3d 44 d7 13 00 sub 0x13d744,%edi
1168a9: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1168ac: 58 pop %eax
1168ad: 5a pop %edx
1168ae: 53 push %ebx
1168af: 56 push %esi
1168b0: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
1168b3: e8 1e 2a 00 00 call 1192d6 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1168b8: 83 c4 10 add $0x10,%esp
1168bb: 31 db xor %ebx,%ebx
1168bd: eb 05 jmp 1168c4 <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1168bf: bb 04 00 00 00 mov $0x4,%ebx
}
1168c4: 89 d8 mov %ebx,%eax
1168c6: 8d 65 f4 lea -0xc(%ebp),%esp
1168c9: 5b pop %ebx
1168ca: 5e pop %esi
1168cb: 5f pop %edi
1168cc: c9 leave
1168cd: c3 ret
0010a8f0 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a8f0: 55 push %ebp
10a8f1: 89 e5 mov %esp,%ebp
10a8f3: 83 ec 08 sub $0x8,%esp
10a8f6: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a8f9: 83 f9 04 cmp $0x4,%ecx
10a8fc: 77 0b ja 10a909 <sched_get_priority_max+0x19>
10a8fe: b8 01 00 00 00 mov $0x1,%eax
10a903: d3 e0 shl %cl,%eax
10a905: a8 17 test $0x17,%al
10a907: 75 10 jne 10a919 <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a909: e8 ae 73 00 00 call 111cbc <__errno>
10a90e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a914: 83 c8 ff or $0xffffffff,%eax
10a917: eb 08 jmp 10a921 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a919: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax
10a920: 48 dec %eax
}
10a921: c9 leave
10a922: c3 ret
0010a924 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a924: 55 push %ebp
10a925: 89 e5 mov %esp,%ebp
10a927: 83 ec 08 sub $0x8,%esp
10a92a: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a92d: 83 f9 04 cmp $0x4,%ecx
10a930: 77 11 ja 10a943 <sched_get_priority_min+0x1f>
10a932: ba 01 00 00 00 mov $0x1,%edx
10a937: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a939: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a93e: 80 e2 17 and $0x17,%dl
10a941: 75 0e jne 10a951 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a943: e8 74 73 00 00 call 111cbc <__errno>
10a948: c7 00 16 00 00 00 movl $0x16,(%eax)
10a94e: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a951: c9 leave
10a952: c3 ret
0010a954 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a954: 55 push %ebp
10a955: 89 e5 mov %esp,%ebp
10a957: 56 push %esi
10a958: 53 push %ebx
10a959: 8b 75 08 mov 0x8(%ebp),%esi
10a95c: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a95f: 85 f6 test %esi,%esi
10a961: 74 16 je 10a979 <sched_rr_get_interval+0x25><== NEVER TAKEN
10a963: e8 b8 d0 ff ff call 107a20 <getpid>
10a968: 39 c6 cmp %eax,%esi
10a96a: 74 0d je 10a979 <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a96c: e8 4b 73 00 00 call 111cbc <__errno>
10a971: c7 00 03 00 00 00 movl $0x3,(%eax)
10a977: eb 0f jmp 10a988 <sched_rr_get_interval+0x34>
if ( !interval )
10a979: 85 db test %ebx,%ebx
10a97b: 75 10 jne 10a98d <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a97d: e8 3a 73 00 00 call 111cbc <__errno>
10a982: c7 00 16 00 00 00 movl $0x16,(%eax)
10a988: 83 c8 ff or $0xffffffff,%eax
10a98b: eb 13 jmp 10a9a0 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a98d: 50 push %eax
10a98e: 50 push %eax
10a98f: 53 push %ebx
10a990: ff 35 a4 52 12 00 pushl 0x1252a4
10a996: e8 a1 2f 00 00 call 10d93c <_Timespec_From_ticks>
return 0;
10a99b: 83 c4 10 add $0x10,%esp
10a99e: 31 c0 xor %eax,%eax
}
10a9a0: 8d 65 f8 lea -0x8(%ebp),%esp
10a9a3: 5b pop %ebx
10a9a4: 5e pop %esi
10a9a5: c9 leave
10a9a6: c3 ret
0010d040 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d040: 55 push %ebp
10d041: 89 e5 mov %esp,%ebp
10d043: 57 push %edi
10d044: 56 push %esi
10d045: 53 push %ebx
10d046: 83 ec 2c sub $0x2c,%esp
10d049: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d04c: a1 cc a4 12 00 mov 0x12a4cc,%eax
10d051: 40 inc %eax
10d052: a3 cc a4 12 00 mov %eax,0x12a4cc
va_list arg;
mode_t mode;
unsigned int value = 0;
10d057: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d059: 8b 45 0c mov 0xc(%ebp),%eax
10d05c: 25 00 02 00 00 and $0x200,%eax
10d061: 89 45 d4 mov %eax,-0x2c(%ebp)
10d064: 74 03 je 10d069 <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d066: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d069: 52 push %edx
10d06a: 52 push %edx
10d06b: 8d 45 e4 lea -0x1c(%ebp),%eax
10d06e: 50 push %eax
10d06f: 56 push %esi
10d070: e8 9b 58 00 00 call 112910 <_POSIX_Semaphore_Name_to_id>
10d075: 89 c3 mov %eax,%ebx
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
10d077: 83 c4 10 add $0x10,%esp
10d07a: 85 c0 test %eax,%eax
10d07c: 74 19 je 10d097 <sem_open+0x57>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10d07e: 83 f8 02 cmp $0x2,%eax
10d081: 75 06 jne 10d089 <sem_open+0x49> <== NEVER TAKEN
10d083: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d087: 75 59 jne 10d0e2 <sem_open+0xa2>
_Thread_Enable_dispatch();
10d089: e8 68 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d08e: e8 45 7f 00 00 call 114fd8 <__errno>
10d093: 89 18 mov %ebx,(%eax)
10d095: eb 1f jmp 10d0b6 <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d097: 8b 45 0c mov 0xc(%ebp),%eax
10d09a: 25 00 0a 00 00 and $0xa00,%eax
10d09f: 3d 00 0a 00 00 cmp $0xa00,%eax
10d0a4: 75 15 jne 10d0bb <sem_open+0x7b>
_Thread_Enable_dispatch();
10d0a6: e8 4b 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d0ab: e8 28 7f 00 00 call 114fd8 <__errno>
10d0b0: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0b6: 83 c8 ff or $0xffffffff,%eax
10d0b9: eb 4a jmp 10d105 <sem_open+0xc5>
10d0bb: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d0bc: 8d 45 dc lea -0x24(%ebp),%eax
10d0bf: 50 push %eax
10d0c0: ff 75 e4 pushl -0x1c(%ebp)
10d0c3: 68 98 a7 12 00 push $0x12a798
10d0c8: e8 d7 1c 00 00 call 10eda4 <_Objects_Get>
10d0cd: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d0d0: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d0d3: e8 1e 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d0d8: e8 19 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
goto return_id;
10d0dd: 83 c4 10 add $0x10,%esp
10d0e0: eb 1d jmp 10d0ff <sem_open+0xbf>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
10d0e2: 8d 45 e0 lea -0x20(%ebp),%eax
10d0e5: 50 push %eax
10d0e6: 57 push %edi
10d0e7: 6a 00 push $0x0
10d0e9: 56 push %esi
10d0ea: e8 ed 56 00 00 call 1127dc <_POSIX_Semaphore_Create_support>
10d0ef: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d0f1: e8 00 25 00 00 call 10f5f6 <_Thread_Enable_dispatch>
if ( status == -1 )
10d0f6: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d0f9: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d0fc: 43 inc %ebx
10d0fd: 74 06 je 10d105 <sem_open+0xc5>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
10d0ff: 8b 45 e0 mov -0x20(%ebp),%eax
10d102: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d105: 8d 65 f4 lea -0xc(%ebp),%esp
10d108: 5b pop %ebx
10d109: 5e pop %esi
10d10a: 5f pop %edi
10d10b: c9 leave
10d10c: c3 ret
0010a7cc <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a7cc: 55 push %ebp
10a7cd: 89 e5 mov %esp,%ebp
10a7cf: 57 push %edi
10a7d0: 56 push %esi
10a7d1: 53 push %ebx
10a7d2: 83 ec 1c sub $0x1c,%esp
10a7d5: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7d8: 8b 55 0c mov 0xc(%ebp),%edx
10a7db: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a7de: 85 c0 test %eax,%eax
10a7e0: 74 12 je 10a7f4 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a7e2: 6b f3 0c imul $0xc,%ebx,%esi
10a7e5: 81 c6 84 68 12 00 add $0x126884,%esi
10a7eb: b9 03 00 00 00 mov $0x3,%ecx
10a7f0: 89 c7 mov %eax,%edi
10a7f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a7f4: 85 db test %ebx,%ebx
10a7f6: 74 0d je 10a805 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a7f8: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a7fb: 83 f8 1f cmp $0x1f,%eax
10a7fe: 77 05 ja 10a805 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a800: 83 fb 09 cmp $0x9,%ebx
10a803: 75 10 jne 10a815 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a805: e8 36 77 00 00 call 111f40 <__errno>
10a80a: c7 00 16 00 00 00 movl $0x16,(%eax)
10a810: 83 c8 ff or $0xffffffff,%eax
10a813: eb 57 jmp 10a86c <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;
10a815: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a817: 85 d2 test %edx,%edx
10a819: 74 51 je 10a86c <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 );
10a81b: 9c pushf
10a81c: fa cli
10a81d: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a820: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a824: 75 1a jne 10a840 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a826: 6b f3 0c imul $0xc,%ebx,%esi
10a829: 8d 86 84 68 12 00 lea 0x126884(%esi),%eax
10a82f: 81 c6 f4 08 12 00 add $0x1208f4,%esi
10a835: b9 03 00 00 00 mov $0x3,%ecx
10a83a: 89 c7 mov %eax,%edi
10a83c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a83e: eb 26 jmp 10a866 <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a840: 83 ec 0c sub $0xc,%esp
10a843: 53 push %ebx
10a844: 89 55 e0 mov %edx,-0x20(%ebp)
10a847: e8 8c 4d 00 00 call 10f5d8 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a84c: 6b db 0c imul $0xc,%ebx,%ebx
10a84f: 81 c3 84 68 12 00 add $0x126884,%ebx
10a855: b9 03 00 00 00 mov $0x3,%ecx
10a85a: 8b 55 e0 mov -0x20(%ebp),%edx
10a85d: 89 df mov %ebx,%edi
10a85f: 89 d6 mov %edx,%esi
10a861: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a863: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a866: ff 75 e4 pushl -0x1c(%ebp)
10a869: 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;
10a86a: 31 c0 xor %eax,%eax
}
10a86c: 8d 65 f4 lea -0xc(%ebp),%esp
10a86f: 5b pop %ebx
10a870: 5e pop %esi
10a871: 5f pop %edi
10a872: c9 leave
10a873: c3 ret
0010aba3 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10aba3: 55 push %ebp
10aba4: 89 e5 mov %esp,%ebp
10aba6: 57 push %edi
10aba7: 56 push %esi
10aba8: 53 push %ebx
10aba9: 83 ec 3c sub $0x3c,%esp
10abac: 8b 75 08 mov 0x8(%ebp),%esi
10abaf: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10abb2: 85 f6 test %esi,%esi
10abb4: 74 24 je 10abda <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abb6: 85 db test %ebx,%ebx
10abb8: 74 30 je 10abea <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abba: 83 ec 0c sub $0xc,%esp
10abbd: 53 push %ebx
10abbe: e8 45 30 00 00 call 10dc08 <_Timespec_Is_valid>
10abc3: 83 c4 10 add $0x10,%esp
10abc6: 84 c0 test %al,%al
10abc8: 74 10 je 10abda <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10abca: 83 ec 0c sub $0xc,%esp
10abcd: 53 push %ebx
10abce: e8 8d 30 00 00 call 10dc60 <_Timespec_To_ticks>
if ( !interval )
10abd3: 83 c4 10 add $0x10,%esp
10abd6: 85 c0 test %eax,%eax
10abd8: 75 12 jne 10abec <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10abda: e8 19 79 00 00 call 1124f8 <__errno>
10abdf: c7 00 16 00 00 00 movl $0x16,(%eax)
10abe5: e9 39 01 00 00 jmp 10ad23 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10abea: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10abec: 8b 7d 0c mov 0xc(%ebp),%edi
10abef: 85 ff test %edi,%edi
10abf1: 75 03 jne 10abf6 <sigtimedwait+0x53>
10abf3: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10abf6: 8b 15 74 68 12 00 mov 0x126874,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10abfc: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx
10ac02: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10ac05: 9c pushf
10ac06: fa cli
10ac07: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10ac0a: 8b 1e mov (%esi),%ebx
10ac0c: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac0f: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac12: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac18: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac1b: 74 32 je 10ac4f <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac1d: 83 ec 0c sub $0xc,%esp
10ac20: 51 push %ecx
10ac21: e8 3e ff ff ff call 10ab64 <_POSIX_signals_Get_lowest>
10ac26: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac28: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac2f: 6a 00 push $0x0
10ac31: 57 push %edi
10ac32: 50 push %eax
10ac33: 53 push %ebx
10ac34: e8 fb 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac39: ff 75 d0 pushl -0x30(%ebp)
10ac3c: 9d popf
the_info->si_code = SI_USER;
10ac3d: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac44: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac4b: 8b 1f mov (%edi),%ebx
10ac4d: eb 3d jmp 10ac8c <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac4f: 8b 0d 78 6a 12 00 mov 0x126a78,%ecx
10ac55: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac58: 74 3a je 10ac94 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac5a: 83 ec 0c sub $0xc,%esp
10ac5d: 51 push %ecx
10ac5e: e8 01 ff ff ff call 10ab64 <_POSIX_signals_Get_lowest>
10ac63: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10ac65: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac6c: 6a 01 push $0x1
10ac6e: 57 push %edi
10ac6f: 50 push %eax
10ac70: ff 75 d4 pushl -0x2c(%ebp)
10ac73: e8 bc 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10ac78: ff 75 d0 pushl -0x30(%ebp)
10ac7b: 9d popf
the_info->si_signo = signo;
10ac7c: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10ac7e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac85: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10ac8c: 83 c4 20 add $0x20,%esp
10ac8f: e9 92 00 00 00 jmp 10ad26 <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10ac94: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10ac9a: 8b 0d 24 63 12 00 mov 0x126324,%ecx
10aca0: 41 inc %ecx
10aca1: 89 0d 24 63 12 00 mov %ecx,0x126324
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10aca7: c7 42 44 10 6a 12 00 movl $0x126a10,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10acae: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10acb5: 8b 0e mov (%esi),%ecx
10acb7: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acba: 89 7a 28 mov %edi,0x28(%edx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10acbd: c7 05 40 6a 12 00 01 movl $0x1,0x126a40
10acc4: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10acc7: ff 75 d0 pushl -0x30(%ebp)
10acca: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10accb: 52 push %edx
10accc: 68 00 d8 10 00 push $0x10d800
10acd1: 50 push %eax
10acd2: 68 10 6a 12 00 push $0x126a10
10acd7: e8 4c 28 00 00 call 10d528 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10acdc: e8 c1 23 00 00 call 10d0a2 <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
10ace1: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ace8: 6a 00 push $0x0
10acea: 57 push %edi
10aceb: ff 37 pushl (%edi)
10aced: ff 75 d4 pushl -0x2c(%ebp)
10acf0: e8 3f 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
10acf5: 83 c4 20 add $0x20,%esp
10acf8: a1 74 68 12 00 mov 0x126874,%eax
10acfd: 83 78 34 04 cmpl $0x4,0x34(%eax)
10ad01: 75 10 jne 10ad13 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10ad03: 8b 1f mov (%edi),%ebx
10ad05: 8d 4b ff lea -0x1(%ebx),%ecx
10ad08: b8 01 00 00 00 mov $0x1,%eax
10ad0d: d3 e0 shl %cl,%eax
10ad0f: 85 06 test %eax,(%esi)
10ad11: 75 13 jne 10ad26 <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad13: e8 e0 77 00 00 call 1124f8 <__errno>
10ad18: 8b 15 74 68 12 00 mov 0x126874,%edx
10ad1e: 8b 52 34 mov 0x34(%edx),%edx
10ad21: 89 10 mov %edx,(%eax)
return -1;
10ad23: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad26: 89 d8 mov %ebx,%eax
10ad28: 8d 65 f4 lea -0xc(%ebp),%esp
10ad2b: 5b pop %ebx
10ad2c: 5e pop %esi
10ad2d: 5f pop %edi
10ad2e: c9 leave
10ad2f: c3 ret
0010ca14 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca14: 55 push %ebp
10ca15: 89 e5 mov %esp,%ebp
10ca17: 53 push %ebx
10ca18: 83 ec 08 sub $0x8,%esp
10ca1b: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca1e: 6a 00 push $0x0
10ca20: 6a 00 push $0x0
10ca22: ff 75 08 pushl 0x8(%ebp)
10ca25: e8 45 fe ff ff call 10c86f <sigtimedwait>
10ca2a: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca2c: 83 c4 10 add $0x10,%esp
10ca2f: 83 f8 ff cmp $0xffffffff,%eax
10ca32: 74 0a je 10ca3e <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca34: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca36: 85 db test %ebx,%ebx
10ca38: 74 0b je 10ca45 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca3a: 89 13 mov %edx,(%ebx)
10ca3c: eb 07 jmp 10ca45 <sigwait+0x31>
return 0;
}
return errno;
10ca3e: e8 cd 72 00 00 call 113d10 <__errno>
10ca43: 8b 00 mov (%eax),%eax
}
10ca45: 8b 5d fc mov -0x4(%ebp),%ebx
10ca48: c9 leave
10ca49: c3 ret
0010a02c <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a02c: 55 push %ebp
10a02d: 89 e5 mov %esp,%ebp
10a02f: 56 push %esi
10a030: 53 push %ebx
10a031: 8b 5d 0c mov 0xc(%ebp),%ebx
10a034: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a037: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a03b: 75 1d jne 10a05a <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a03d: 85 f6 test %esi,%esi
10a03f: 74 19 je 10a05a <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a041: 85 db test %ebx,%ebx
10a043: 74 22 je 10a067 <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a045: 8b 03 mov (%ebx),%eax
10a047: 48 dec %eax
10a048: 83 f8 01 cmp $0x1,%eax
10a04b: 77 0d ja 10a05a <timer_create+0x2e> <== NEVER TAKEN
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
10a04d: 8b 43 04 mov 0x4(%ebx),%eax
10a050: 85 c0 test %eax,%eax
10a052: 74 06 je 10a05a <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a054: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a055: 83 f8 1f cmp $0x1f,%eax
10a058: 76 0d jbe 10a067 <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a05a: e8 7d 7c 00 00 call 111cdc <__errno>
10a05f: c7 00 16 00 00 00 movl $0x16,(%eax)
10a065: eb 2f jmp 10a096 <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a067: a1 38 63 12 00 mov 0x126338,%eax
10a06c: 40 inc %eax
10a06d: a3 38 63 12 00 mov %eax,0x126338
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
10a072: 83 ec 0c sub $0xc,%esp
10a075: 68 44 66 12 00 push $0x126644
10a07a: e8 71 1b 00 00 call 10bbf0 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a07f: 83 c4 10 add $0x10,%esp
10a082: 85 c0 test %eax,%eax
10a084: 75 18 jne 10a09e <timer_create+0x72>
_Thread_Enable_dispatch();
10a086: e8 73 27 00 00 call 10c7fe <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a08b: e8 4c 7c 00 00 call 111cdc <__errno>
10a090: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a096: 83 c8 ff or $0xffffffff,%eax
10a099: e9 83 00 00 00 jmp 10a121 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a09e: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0a2: 8b 15 88 68 12 00 mov 0x126888,%edx
10a0a8: 8b 52 08 mov 0x8(%edx),%edx
10a0ab: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a0ae: 85 db test %ebx,%ebx
10a0b0: 74 11 je 10a0c3 <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a0b2: 8b 13 mov (%ebx),%edx
10a0b4: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a0b7: 8b 53 04 mov 0x4(%ebx),%edx
10a0ba: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a0bd: 8b 53 08 mov 0x8(%ebx),%edx
10a0c0: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a0c3: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a0ca: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a0d1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a0d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a0df: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10a0e6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a0ed: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a0f4: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a0fb: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a102: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a105: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a108: 8b 0d 60 66 12 00 mov 0x126660,%ecx
10a10e: 89 04 99 mov %eax,(%ecx,%ebx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10a111: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
10a118: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a11a: e8 df 26 00 00 call 10c7fe <_Thread_Enable_dispatch>
return 0;
10a11f: 31 c0 xor %eax,%eax
}
10a121: 8d 65 f8 lea -0x8(%ebp),%esp
10a124: 5b pop %ebx
10a125: 5e pop %esi
10a126: c9 leave
10a127: c3 ret
0010a128 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a128: 55 push %ebp
10a129: 89 e5 mov %esp,%ebp
10a12b: 57 push %edi
10a12c: 56 push %esi
10a12d: 53 push %ebx
10a12e: 83 ec 2c sub $0x2c,%esp
10a131: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a134: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a138: 0f 84 58 01 00 00 je 10a296 <timer_settime+0x16e> <== NEVER TAKEN
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
10a13e: 83 ec 0c sub $0xc,%esp
10a141: 8b 45 10 mov 0x10(%ebp),%eax
10a144: 83 c0 08 add $0x8,%eax
10a147: 50 push %eax
10a148: e8 3b 32 00 00 call 10d388 <_Timespec_Is_valid>
10a14d: 83 c4 10 add $0x10,%esp
10a150: 84 c0 test %al,%al
10a152: 0f 84 3e 01 00 00 je 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a158: 83 ec 0c sub $0xc,%esp
10a15b: ff 75 10 pushl 0x10(%ebp)
10a15e: e8 25 32 00 00 call 10d388 <_Timespec_Is_valid>
10a163: 83 c4 10 add $0x10,%esp
10a166: 84 c0 test %al,%al
10a168: 0f 84 28 01 00 00 je 10a296 <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a16e: 85 db test %ebx,%ebx
10a170: 74 09 je 10a17b <timer_settime+0x53>
10a172: 83 fb 04 cmp $0x4,%ebx
10a175: 0f 85 1b 01 00 00 jne 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a17b: 8d 7d cc lea -0x34(%ebp),%edi
10a17e: b9 04 00 00 00 mov $0x4,%ecx
10a183: 8b 75 10 mov 0x10(%ebp),%esi
10a186: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a188: 83 fb 04 cmp $0x4,%ebx
10a18b: 75 2f jne 10a1bc <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a18d: 83 ec 0c sub $0xc,%esp
10a190: 8d 5d dc lea -0x24(%ebp),%ebx
10a193: 53 push %ebx
10a194: e8 a7 15 00 00 call 10b740 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a199: 59 pop %ecx
10a19a: 5e pop %esi
10a19b: 8d 75 d4 lea -0x2c(%ebp),%esi
10a19e: 56 push %esi
10a19f: 53 push %ebx
10a1a0: e8 bf 31 00 00 call 10d364 <_Timespec_Greater_than>
10a1a5: 83 c4 10 add $0x10,%esp
10a1a8: 84 c0 test %al,%al
10a1aa: 0f 85 e6 00 00 00 jne 10a296 <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a1b0: 52 push %edx
10a1b1: 56 push %esi
10a1b2: 56 push %esi
10a1b3: 53 push %ebx
10a1b4: e8 f3 31 00 00 call 10d3ac <_Timespec_Subtract>
10a1b9: 83 c4 10 add $0x10,%esp
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10a1bc: 50 push %eax
/* If the function reaches this point, then it will be necessary to do
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
10a1bd: 8d 45 e4 lea -0x1c(%ebp),%eax
10a1c0: 50 push %eax
10a1c1: ff 75 08 pushl 0x8(%ebp)
10a1c4: 68 44 66 12 00 push $0x126644
10a1c9: e8 52 1e 00 00 call 10c020 <_Objects_Get>
10a1ce: 89 c3 mov %eax,%ebx
switch ( location ) {
10a1d0: 83 c4 10 add $0x10,%esp
10a1d3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a1d7: 0f 85 b9 00 00 00 jne 10a296 <timer_settime+0x16e>
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
10a1dd: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a1e1: 75 3b jne 10a21e <timer_settime+0xf6>
10a1e3: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a1e7: 75 35 jne 10a21e <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a1e9: 83 ec 0c sub $0xc,%esp
10a1ec: 8d 40 10 lea 0x10(%eax),%eax
10a1ef: 50 push %eax
10a1f0: e8 7b 35 00 00 call 10d770 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a1f5: 83 c4 10 add $0x10,%esp
10a1f8: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a1fc: 74 0d je 10a20b <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a1fe: 8d 73 54 lea 0x54(%ebx),%esi
10a201: b9 04 00 00 00 mov $0x4,%ecx
10a206: 8b 7d 14 mov 0x14(%ebp),%edi
10a209: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a20b: 8d 7b 54 lea 0x54(%ebx),%edi
10a20e: 8d 75 cc lea -0x34(%ebp),%esi
10a211: b9 04 00 00 00 mov $0x4,%ecx
10a216: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a218: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a21c: eb 35 jmp 10a253 <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a21e: 83 ec 0c sub $0xc,%esp
10a221: ff 75 10 pushl 0x10(%ebp)
10a224: e8 b7 31 00 00 call 10d3e0 <_Timespec_To_ticks>
10a229: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a22c: 8d 45 d4 lea -0x2c(%ebp),%eax
10a22f: 89 04 24 mov %eax,(%esp)
10a232: e8 a9 31 00 00 call 10d3e0 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a237: 89 1c 24 mov %ebx,(%esp)
10a23a: 68 ac a2 10 00 push $0x10a2ac
10a23f: ff 73 08 pushl 0x8(%ebx)
10a242: 50 push %eax
10a243: 8d 43 10 lea 0x10(%ebx),%eax
10a246: 50 push %eax
10a247: e8 64 56 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a24c: 83 c4 20 add $0x20,%esp
10a24f: 84 c0 test %al,%al
10a251: 75 07 jne 10a25a <timer_settime+0x132>
_Thread_Enable_dispatch();
10a253: e8 a6 25 00 00 call 10c7fe <_Thread_Enable_dispatch>
10a258: eb 38 jmp 10a292 <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a25e: 74 0d je 10a26d <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a260: 8d 73 54 lea 0x54(%ebx),%esi
10a263: b9 04 00 00 00 mov $0x4,%ecx
10a268: 8b 7d 14 mov 0x14(%ebp),%edi
10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a26d: 8d 7b 54 lea 0x54(%ebx),%edi
10a270: 8d 75 cc lea -0x34(%ebp),%esi
10a273: b9 04 00 00 00 mov $0x4,%ecx
10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a27a: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a27e: 83 ec 0c sub $0xc,%esp
10a281: 83 c3 6c add $0x6c,%ebx
10a284: 53 push %ebx
10a285: e8 b6 14 00 00 call 10b740 <_TOD_Get>
_Thread_Enable_dispatch();
10a28a: e8 6f 25 00 00 call 10c7fe <_Thread_Enable_dispatch>
return 0;
10a28f: 83 c4 10 add $0x10,%esp
10a292: 31 c0 xor %eax,%eax
10a294: eb 0e jmp 10a2a4 <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a296: e8 41 7a 00 00 call 111cdc <__errno>
10a29b: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2a1: 83 c8 ff or $0xffffffff,%eax
}
10a2a4: 8d 65 f4 lea -0xc(%ebp),%esp
10a2a7: 5b pop %ebx
10a2a8: 5e pop %esi
10a2a9: 5f pop %edi
10a2aa: c9 leave
10a2ab: c3 ret
00109f68 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109f68: 55 push %ebp
109f69: 89 e5 mov %esp,%ebp
109f6b: 57 push %edi
109f6c: 56 push %esi
109f6d: 53 push %ebx
109f6e: 83 ec 1c sub $0x1c,%esp
109f71: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109f74: 83 3d 28 6c 12 00 00 cmpl $0x0,0x126c28
109f7b: 75 2c jne 109fa9 <ualarm+0x41>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109f7d: c7 05 14 6c 12 00 00 movl $0x0,0x126c14
109f84: 00 00 00
the_watchdog->routine = routine;
109f87: c7 05 28 6c 12 00 30 movl $0x109f30,0x126c28
109f8e: 9f 10 00
the_watchdog->id = id;
109f91: c7 05 2c 6c 12 00 00 movl $0x0,0x126c2c
109f98: 00 00 00
the_watchdog->user_data = user_data;
109f9b: c7 05 30 6c 12 00 00 movl $0x0,0x126c30
109fa2: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fa5: 31 db xor %ebx,%ebx
109fa7: eb 4f jmp 109ff8 <ualarm+0x90>
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
109fa9: 83 ec 0c sub $0xc,%esp
109fac: 68 0c 6c 12 00 push $0x126c0c
109fb1: e8 a2 33 00 00 call 10d358 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fb6: 83 e8 02 sub $0x2,%eax
109fb9: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fbc: 31 db xor %ebx,%ebx
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fbe: 83 f8 01 cmp $0x1,%eax
109fc1: 77 35 ja 109ff8 <ualarm+0x90> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
109fc3: a1 20 6c 12 00 mov 0x126c20,%eax
109fc8: 03 05 18 6c 12 00 add 0x126c18,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fce: 57 push %edi
109fcf: 57 push %edi
109fd0: 8d 55 e0 lea -0x20(%ebp),%edx
109fd3: 52 push %edx
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
109fd4: 2b 05 24 6c 12 00 sub 0x126c24,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fda: 50 push %eax
109fdb: e8 20 2f 00 00 call 10cf00 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
109fe0: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
109fe7: 8b 45 e4 mov -0x1c(%ebp),%eax
109fea: bf e8 03 00 00 mov $0x3e8,%edi
109fef: 99 cltd
109ff0: f7 ff idiv %edi
109ff2: 8d 1c 08 lea (%eax,%ecx,1),%ebx
109ff5: 83 c4 10 add $0x10,%esp
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
109ff8: 85 f6 test %esi,%esi
109ffa: 74 44 je 10a040 <ualarm+0xd8> <== NEVER TAKEN
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
109ffc: b9 40 42 0f 00 mov $0xf4240,%ecx
10a001: 89 f0 mov %esi,%eax
10a003: 31 d2 xor %edx,%edx
10a005: f7 f1 div %ecx
10a007: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a00a: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a010: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a013: 83 ec 0c sub $0xc,%esp
10a016: 8d 75 e0 lea -0x20(%ebp),%esi
10a019: 56 push %esi
10a01a: e8 3d 2f 00 00 call 10cf5c <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a01f: 89 34 24 mov %esi,(%esp)
10a022: e8 35 2f 00 00 call 10cf5c <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a027: a3 18 6c 12 00 mov %eax,0x126c18
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a02c: 59 pop %ecx
10a02d: 5e pop %esi
10a02e: 68 0c 6c 12 00 push $0x126c0c
10a033: 68 fc 63 12 00 push $0x1263fc
10a038: e8 03 32 00 00 call 10d240 <_Watchdog_Insert>
10a03d: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a040: 89 d8 mov %ebx,%eax
10a042: 8d 65 f4 lea -0xc(%ebp),%esp
10a045: 5b pop %ebx
10a046: 5e pop %esi
10a047: 5f pop %edi
10a048: c9 leave
10a049: c3 ret