0010be5c <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10be5c: 55 push %ebp 10be5d: 89 e5 mov %esp,%ebp 10be5f: 53 push %ebx 10be60: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10be63: 8b 1d 18 67 12 00 mov 0x126718,%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10be69: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10be6f: 74 10 je 10be81 <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN
10be71: 8d 76 00 lea 0x0(%esi),%esi
* Currently all APIs configure this hook so it is always non-NULL.
*/
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
10be74: ff 53 08 call *0x8(%ebx)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
10be77: 8b 1b mov (%ebx),%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10be79: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10be7f: 75 f3 jne 10be74 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10be81: 58 pop %eax 10be82: 5b pop %ebx 10be83: c9 leave 10be84: c3 ret
0010be88 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10be88: 55 push %ebp 10be89: 89 e5 mov %esp,%ebp 10be8b: 53 push %ebx 10be8c: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10be8f: 8b 1d 18 67 12 00 mov 0x126718,%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10be95: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10be9b: 74 1c je 10beb9 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN
10be9d: 8d 76 00 lea 0x0(%esi),%esi
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
10bea0: 83 ec 0c sub $0xc,%esp 10bea3: ff 35 78 67 12 00 pushl 0x126778 10bea9: ff 53 0c call *0xc(%ebx)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
10beac: 8b 1b mov (%ebx),%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10beae: 83 c4 10 add $0x10,%esp 10beb1: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10beb7: 75 e7 jne 10bea0 <_API_extensions_Run_postswitch+0x18><== NEVER TAKEN
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10beb9: 8b 5d fc mov -0x4(%ebp),%ebx 10bebc: c9 leave 10bebd: c3 ret
00119894 <_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
)
{
119894: 55 push %ebp 119895: 89 e5 mov %esp,%ebp 119897: 57 push %edi 119898: 56 push %esi 119899: 53 push %ebx 11989a: 83 ec 1c sub $0x1c,%esp 11989d: 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 ) {
1198a0: 8b 45 10 mov 0x10(%ebp),%eax 1198a3: 39 43 4c cmp %eax,0x4c(%ebx)
1198a6: 72 60 jb 119908 <_CORE_message_queue_Broadcast+0x74><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
1198a8: 8b 43 48 mov 0x48(%ebx),%eax 1198ab: 85 c0 test %eax,%eax
1198ad: 75 45 jne 1198f4 <_CORE_message_queue_Broadcast+0x60>
1198af: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1198b6: eb 18 jmp 1198d0 <_CORE_message_queue_Broadcast+0x3c>
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
1198b8: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1198bb: 8b 42 2c mov 0x2c(%edx),%eax 1198be: 89 c7 mov %eax,%edi 1198c0: 8b 75 0c mov 0xc(%ebp),%esi 1198c3: 8b 4d 10 mov 0x10(%ebp),%ecx 1198c6: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
1198c8: 8b 42 28 mov 0x28(%edx),%eax 1198cb: 8b 55 10 mov 0x10(%ebp),%edx 1198ce: 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 =
1198d0: 83 ec 0c sub $0xc,%esp 1198d3: 53 push %ebx 1198d4: e8 eb 26 00 00 call 11bfc4 <_Thread_queue_Dequeue> 1198d9: 89 c2 mov %eax,%edx 1198db: 83 c4 10 add $0x10,%esp 1198de: 85 c0 test %eax,%eax
1198e0: 75 d6 jne 1198b8 <_CORE_message_queue_Broadcast+0x24>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
1198e2: 8b 55 e4 mov -0x1c(%ebp),%edx 1198e5: 8b 45 1c mov 0x1c(%ebp),%eax 1198e8: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1198ea: 31 c0 xor %eax,%eax
}
1198ec: 8d 65 f4 lea -0xc(%ebp),%esp 1198ef: 5b pop %ebx 1198f0: 5e pop %esi 1198f1: 5f pop %edi 1198f2: c9 leave 1198f3: c3 ret
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
*count = 0;
1198f4: 8b 55 1c mov 0x1c(%ebp),%edx 1198f7: c7 02 00 00 00 00 movl $0x0,(%edx)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1198fd: 31 c0 xor %eax,%eax
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
1198ff: 8d 65 f4 lea -0xc(%ebp),%esp 119902: 5b pop %ebx 119903: 5e pop %esi 119904: 5f pop %edi 119905: c9 leave 119906: c3 ret 119907: 90 nop
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
119908: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
11990d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119910: 5b pop %ebx <== NOT EXECUTED 119911: 5e pop %esi <== NOT EXECUTED 119912: 5f pop %edi <== NOT EXECUTED 119913: c9 leave <== NOT EXECUTED 119914: c3 ret <== NOT EXECUTED
001149d4 <_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
)
{
1149d4: 55 push %ebp 1149d5: 89 e5 mov %esp,%ebp 1149d7: 57 push %edi 1149d8: 56 push %esi 1149d9: 53 push %ebx 1149da: 83 ec 0c sub $0xc,%esp 1149dd: 8b 5d 08 mov 0x8(%ebp),%ebx 1149e0: 8b 75 10 mov 0x10(%ebp),%esi 1149e3: 8b 45 14 mov 0x14(%ebp),%eax
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
1149e6: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
1149e9: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
1149f0: 89 43 4c mov %eax,0x4c(%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)) {
1149f3: a8 03 test $0x3,%al
1149f5: 74 15 je 114a0c <_CORE_message_queue_Initialize+0x38>
allocated_message_size += sizeof(uint32_t);
1149f7: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uint32_t) - 1);
1149fa: 83 e2 fc and $0xfffffffc,%edx
}
if (allocated_message_size < maximum_message_size)
1149fd: 39 d0 cmp %edx,%eax
1149ff: 76 0d jbe 114a0e <_CORE_message_queue_Initialize+0x3a><== ALWAYS TAKEN
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
return false;
114a01: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
114a03: 8d 65 f4 lea -0xc(%ebp),%esp 114a06: 5b pop %ebx 114a07: 5e pop %esi 114a08: 5f pop %edi 114a09: c9 leave 114a0a: c3 ret 114a0b: 90 nop
/*
* 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)) {
114a0c: 89 c2 mov %eax,%edx
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
114a0e: 8d 7a 10 lea 0x10(%edx),%edi
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
114a11: 89 f8 mov %edi,%eax 114a13: 0f af c6 imul %esi,%eax
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
114a16: 39 d0 cmp %edx,%eax
114a18: 72 e7 jb 114a01 <_CORE_message_queue_Initialize+0x2d><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
114a1a: 83 ec 0c sub $0xc,%esp 114a1d: 50 push %eax 114a1e: e8 c1 29 00 00 call 1173e4 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
114a23: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
114a26: 83 c4 10 add $0x10,%esp 114a29: 85 c0 test %eax,%eax
114a2b: 74 d4 je 114a01 <_CORE_message_queue_Initialize+0x2d>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
114a2d: 57 push %edi 114a2e: 56 push %esi 114a2f: 50 push %eax 114a30: 8d 43 60 lea 0x60(%ebx),%eax 114a33: 50 push %eax 114a34: e8 f3 46 00 00 call 11912c <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
114a39: 8d 43 54 lea 0x54(%ebx),%eax 114a3c: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
114a3f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
114a46: 8d 43 50 lea 0x50(%ebx),%eax 114a49: 89 43 58 mov %eax,0x58(%ebx)
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
114a4c: 6a 06 push $0x6 114a4e: 68 80 00 00 00 push $0x80 114a53: 8b 45 0c mov 0xc(%ebp),%eax 114a56: 83 38 01 cmpl $0x1,(%eax) 114a59: 0f 94 c0 sete %al 114a5c: 0f b6 c0 movzbl %al,%eax 114a5f: 50 push %eax 114a60: 53 push %ebx 114a61: e8 8a 20 00 00 call 116af0 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
114a66: 83 c4 20 add $0x20,%esp 114a69: b0 01 mov $0x1,%al
}
114a6b: 8d 65 f4 lea -0xc(%ebp),%esp 114a6e: 5b pop %ebx 114a6f: 5e pop %esi 114a70: 5f pop %edi 114a71: c9 leave 114a72: c3 ret
00110594 <_CORE_message_queue_Insert_message>:
void _CORE_message_queue_Insert_message(
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message,
CORE_message_queue_Submit_types submit_type
)
{
110594: 55 push %ebp 110595: 89 e5 mov %esp,%ebp 110597: 56 push %esi 110598: 53 push %ebx 110599: 8b 45 08 mov 0x8(%ebp),%eax 11059c: 8b 55 0c mov 0xc(%ebp),%edx
#endif
_CORE_message_queue_Set_message_priority( the_message, submit_type );
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
_ISR_Disable( level );
11059f: 9c pushf 1105a0: fa cli 1105a1: 5b pop %ebx
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
1105a2: ff 40 48 incl 0x48(%eax)
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST )
1105a5: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp)
1105ac: 74 1a je 1105c8 <_CORE_message_queue_Insert_message+0x34>
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
1105ae: 8d 48 50 lea 0x50(%eax),%ecx 1105b1: 89 4a 04 mov %ecx,0x4(%edx)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
1105b4: 8b 48 50 mov 0x50(%eax),%ecx
after_node->next = the_node;
1105b7: 89 50 50 mov %edx,0x50(%eax)
the_node->next = before_node;
1105ba: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
1105bc: 89 51 04 mov %edx,0x4(%ecx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
1105bf: 53 push %ebx 1105c0: 9d popf
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
#endif
}
1105c1: 5b pop %ebx 1105c2: 5e pop %esi 1105c3: c9 leave 1105c4: c3 ret 1105c5: 8d 76 00 lea 0x0(%esi),%esi
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
1105c8: 8b 48 58 mov 0x58(%eax),%ecx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
1105cb: 8d 70 54 lea 0x54(%eax),%esi 1105ce: 89 32 mov %esi,(%edx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
1105d0: 89 50 58 mov %edx,0x58(%eax)
old_last->next = the_node;
1105d3: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
1105d5: 89 4a 04 mov %ecx,0x4(%edx) 1105d8: eb e5 jmp 1105bf <_CORE_message_queue_Insert_message+0x2b>
0010bff0 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
10bff0: 55 push %ebp 10bff1: 89 e5 mov %esp,%ebp 10bff3: 57 push %edi 10bff4: 56 push %esi 10bff5: 53 push %ebx 10bff6: 83 ec 0c sub $0xc,%esp 10bff9: 8b 5d 08 mov 0x8(%ebp),%ebx 10bffc: 8b 75 0c mov 0xc(%ebp),%esi
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
10bfff: 8b 45 10 mov 0x10(%ebp),%eax 10c002: 39 43 4c cmp %eax,0x4c(%ebx)
10c005: 72 51 jb 10c058 <_CORE_message_queue_Submit+0x68>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
10c007: 8b 43 48 mov 0x48(%ebx),%eax 10c00a: 85 c0 test %eax,%eax
10c00c: 74 5a je 10c068 <_CORE_message_queue_Submit+0x78>
/*
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
if ( the_message_queue->number_of_pending_messages <
10c00e: 39 43 44 cmp %eax,0x44(%ebx)
10c011: 77 0d ja 10c020 <_CORE_message_queue_Submit+0x30>
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
10c013: b8 02 00 00 00 mov $0x2,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c018: 8d 65 f4 lea -0xc(%ebp),%esp 10c01b: 5b pop %ebx 10c01c: 5e pop %esi 10c01d: 5f pop %edi 10c01e: c9 leave 10c01f: c3 ret
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
10c020: 83 ec 0c sub $0xc,%esp 10c023: 8d 43 60 lea 0x60(%ebx),%eax 10c026: 50 push %eax 10c027: e8 a0 ff ff ff call 10bfcc <_Chain_Get> 10c02c: 89 c2 mov %eax,%edx
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
#endif
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
10c02e: 8d 40 0c lea 0xc(%eax),%eax
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c031: 89 c7 mov %eax,%edi 10c033: 8b 4d 10 mov 0x10(%ebp),%ecx 10c036: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
size
);
the_message->Contents.size = size;
10c038: 8b 4d 10 mov 0x10(%ebp),%ecx 10c03b: 89 4a 08 mov %ecx,0x8(%edx)
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
10c03e: 83 c4 0c add $0xc,%esp 10c041: ff 75 1c pushl 0x1c(%ebp) 10c044: 52 push %edx 10c045: 53 push %ebx 10c046: e8 49 45 00 00 call 110594 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
10c04b: 83 c4 10 add $0x10,%esp 10c04e: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c050: 8d 65 f4 lea -0xc(%ebp),%esp 10c053: 5b pop %ebx 10c054: 5e pop %esi 10c055: 5f pop %edi 10c056: c9 leave 10c057: c3 ret
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
10c058: b8 01 00 00 00 mov $0x1,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c05d: 8d 65 f4 lea -0xc(%ebp),%esp 10c060: 5b pop %ebx 10c061: 5e pop %esi 10c062: 5f pop %edi 10c063: c9 leave 10c064: c3 ret 10c065: 8d 76 00 lea 0x0(%esi),%esi
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
10c068: 83 ec 0c sub $0xc,%esp 10c06b: 53 push %ebx 10c06c: e8 13 1b 00 00 call 10db84 <_Thread_queue_Dequeue> 10c071: 89 c2 mov %eax,%edx
if ( the_thread ) {
10c073: 83 c4 10 add $0x10,%esp 10c076: 85 c0 test %eax,%eax
10c078: 74 1e je 10c098 <_CORE_message_queue_Submit+0xa8>
10c07a: 8b 40 2c mov 0x2c(%eax),%eax 10c07d: 89 c7 mov %eax,%edi 10c07f: 8b 4d 10 mov 0x10(%ebp),%ecx 10c082: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
10c084: 8b 42 28 mov 0x28(%edx),%eax 10c087: 8b 4d 10 mov 0x10(%ebp),%ecx 10c08a: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = (uint32_t) submit_type;
10c08c: 8b 45 1c mov 0x1c(%ebp),%eax 10c08f: 89 42 24 mov %eax,0x24(%edx)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
10c092: 31 c0 xor %eax,%eax 10c094: eb 82 jmp 10c018 <_CORE_message_queue_Submit+0x28> 10c096: 66 90 xchg %ax,%ax
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
if ( the_thread ) {
10c098: 8b 43 48 mov 0x48(%ebx),%eax 10c09b: e9 6e ff ff ff jmp 10c00e <_CORE_message_queue_Submit+0x1e>
0010c0ac <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10c0ac: 55 push %ebp 10c0ad: 89 e5 mov %esp,%ebp 10c0af: 57 push %edi 10c0b0: 56 push %esi 10c0b1: 53 push %ebx 10c0b2: 83 ec 0c sub $0xc,%esp 10c0b5: 8b 45 08 mov 0x8(%ebp),%eax 10c0b8: 8b 5d 0c mov 0xc(%ebp),%ebx 10c0bb: 8b 55 10 mov 0x10(%ebp),%edx
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
10c0be: 8d 78 40 lea 0x40(%eax),%edi 10c0c1: b9 04 00 00 00 mov $0x4,%ecx 10c0c6: 89 de mov %ebx,%esi 10c0c8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10c0ca: 89 50 50 mov %edx,0x50(%eax)
the_mutex->blocked_count = 0;
10c0cd: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10c0d4: 85 d2 test %edx,%edx
10c0d6: 75 30 jne 10c108 <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10c0d8: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
the_mutex->holder = _Thread_Executing;
10c0df: 8b 15 78 67 12 00 mov 0x126778,%edx 10c0e5: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = _Thread_Executing->Object.id;
10c0e8: 8b 4a 08 mov 0x8(%edx),%ecx 10c0eb: 89 48 60 mov %ecx,0x60(%eax)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c0ee: 8b 48 48 mov 0x48(%eax),%ecx
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10c0f1: 83 f9 02 cmp $0x2,%ecx
10c0f4: 74 05 je 10c0fb <_CORE_mutex_Initialize+0x4f>
10c0f6: 83 f9 03 cmp $0x3,%ecx
10c0f9: 75 22 jne 10c11d <_CORE_mutex_Initialize+0x71>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10c0fb: 8b 48 4c mov 0x4c(%eax),%ecx 10c0fe: 39 4a 14 cmp %ecx,0x14(%edx)
10c101: 72 41 jb 10c144 <_CORE_mutex_Initialize+0x98>
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
10c103: ff 42 1c incl 0x1c(%edx) 10c106: eb 15 jmp 10c11d <_CORE_mutex_Initialize+0x71>
}
} else {
the_mutex->nest_count = 0;
10c108: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_mutex->holder = NULL;
10c10f: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
the_mutex->holder_id = 0;
10c116: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
}
_Thread_queue_Initialize(
10c11d: 6a 05 push $0x5 10c11f: 68 00 04 00 00 push $0x400 10c124: 31 d2 xor %edx,%edx 10c126: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10c12a: 0f 95 c2 setne %dl 10c12d: 52 push %edx 10c12e: 50 push %eax 10c12f: e8 e0 1d 00 00 call 10df14 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c134: 83 c4 10 add $0x10,%esp 10c137: 31 c0 xor %eax,%eax
}
10c139: 8d 65 f4 lea -0xc(%ebp),%esp 10c13c: 5b pop %ebx 10c13d: 5e pop %esi 10c13e: 5f pop %edi 10c13f: c9 leave 10c140: c3 ret 10c141: 8d 76 00 lea 0x0(%esi),%esi
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
10c144: b8 06 00 00 00 mov $0x6,%eax
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c149: 8d 65 f4 lea -0xc(%ebp),%esp 10c14c: 5b pop %ebx 10c14d: 5e pop %esi 10c14e: 5f pop %edi 10c14f: c9 leave 10c150: c3 ret
0010c1a4 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10c1a4: 55 push %ebp 10c1a5: 89 e5 mov %esp,%ebp 10c1a7: 53 push %ebx 10c1a8: 83 ec 14 sub $0x14,%esp 10c1ab: 8b 5d 08 mov 0x8(%ebp),%ebx 10c1ae: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c1b1: a1 b0 64 12 00 mov 0x1264b0,%eax 10c1b6: 85 c0 test %eax,%eax
10c1b8: 74 04 je 10c1be <_CORE_mutex_Seize+0x1a>
10c1ba: 84 d2 test %dl,%dl
10c1bc: 75 36 jne 10c1f4 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN
10c1be: 83 ec 08 sub $0x8,%esp 10c1c1: 8d 45 18 lea 0x18(%ebp),%eax 10c1c4: 50 push %eax 10c1c5: 53 push %ebx 10c1c6: 88 55 f4 mov %dl,-0xc(%ebp) 10c1c9: e8 0e 44 00 00 call 1105dc <_CORE_mutex_Seize_interrupt_trylock> 10c1ce: 83 c4 10 add $0x10,%esp 10c1d1: 85 c0 test %eax,%eax 10c1d3: 8a 55 f4 mov -0xc(%ebp),%dl
10c1d6: 74 14 je 10c1ec <_CORE_mutex_Seize+0x48>
10c1d8: 84 d2 test %dl,%dl
10c1da: 75 30 jne 10c20c <_CORE_mutex_Seize+0x68>
10c1dc: ff 75 18 pushl 0x18(%ebp) 10c1df: 9d popf 10c1e0: a1 78 67 12 00 mov 0x126778,%eax 10c1e5: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10c1ec: 8b 5d fc mov -0x4(%ebp),%ebx 10c1ef: c9 leave 10c1f0: c3 ret 10c1f1: 8d 76 00 lea 0x0(%esi),%esi
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c1f4: 83 3d 80 66 12 00 01 cmpl $0x1,0x126680
10c1fb: 76 c1 jbe 10c1be <_CORE_mutex_Seize+0x1a>
10c1fd: 53 push %ebx 10c1fe: 6a 12 push $0x12 10c200: 6a 00 push $0x0 10c202: 6a 00 push $0x0 10c204: e8 1b 06 00 00 call 10c824 <_Internal_error_Occurred> 10c209: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c20c: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10c213: a1 78 67 12 00 mov 0x126778,%eax 10c218: 89 58 44 mov %ebx,0x44(%eax) 10c21b: 8b 55 0c mov 0xc(%ebp),%edx 10c21e: 89 50 20 mov %edx,0x20(%eax) 10c221: a1 b0 64 12 00 mov 0x1264b0,%eax 10c226: 40 inc %eax 10c227: a3 b0 64 12 00 mov %eax,0x1264b0 10c22c: ff 75 18 pushl 0x18(%ebp) 10c22f: 9d popf 10c230: 83 ec 08 sub $0x8,%esp 10c233: ff 75 14 pushl 0x14(%ebp) 10c236: 53 push %ebx 10c237: e8 18 ff ff ff call 10c154 <_CORE_mutex_Seize_interrupt_blocking> 10c23c: 83 c4 10 add $0x10,%esp
}
10c23f: 8b 5d fc mov -0x4(%ebp),%ebx 10c242: c9 leave 10c243: c3 ret
001105dc <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
1105dc: 55 push %ebp 1105dd: 89 e5 mov %esp,%ebp 1105df: 56 push %esi 1105e0: 53 push %ebx 1105e1: 8b 45 08 mov 0x8(%ebp),%eax 1105e4: 8b 4d 0c mov 0xc(%ebp),%ecx
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
1105e7: 8b 15 78 67 12 00 mov 0x126778,%edx
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
1105ed: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
1105f4: 8b 58 50 mov 0x50(%eax),%ebx 1105f7: 85 db test %ebx,%ebx
1105f9: 74 31 je 11062c <_CORE_mutex_Seize_interrupt_trylock+0x50>
the_mutex->lock = CORE_MUTEX_LOCKED;
1105fb: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
the_mutex->holder = executing;
110602: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = executing->Object.id;
110605: 8b 5a 08 mov 0x8(%edx),%ebx 110608: 89 58 60 mov %ebx,0x60(%eax)
the_mutex->nest_count = 1;
11060b: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
110612: 8b 58 48 mov 0x48(%eax),%ebx
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
110615: 83 fb 02 cmp $0x2,%ebx
110618: 74 26 je 110640 <_CORE_mutex_Seize_interrupt_trylock+0x64>
11061a: 83 fb 03 cmp $0x3,%ebx
11061d: 74 3d je 11065c <_CORE_mutex_Seize_interrupt_trylock+0x80>
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
11061f: ff 31 pushl (%ecx) 110621: 9d popf
return 0;
110622: 31 c0 xor %eax,%eax 110624: 8d 65 f8 lea -0x8(%ebp),%esp 110627: 5b pop %ebx 110628: 5e pop %esi 110629: c9 leave 11062a: c3 ret 11062b: 90 nop
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
11062c: 3b 50 5c cmp 0x5c(%eax),%edx
11062f: 74 17 je 110648 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
110631: b8 01 00 00 00 mov $0x1,%eax 110636: 8d 65 f8 lea -0x8(%ebp),%esp 110639: 5b pop %ebx 11063a: 5e pop %esi 11063b: c9 leave 11063c: c3 ret 11063d: 8d 76 00 lea 0x0(%esi),%esi
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
110640: ff 42 1c incl 0x1c(%edx) 110643: eb da jmp 11061f <_CORE_mutex_Seize_interrupt_trylock+0x43> 110645: 8d 76 00 lea 0x0(%esi),%esi
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
110648: 8b 58 40 mov 0x40(%eax),%ebx 11064b: 85 db test %ebx,%ebx
11064d: 75 45 jne 110694 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
11064f: ff 40 54 incl 0x54(%eax)
_ISR_Enable( *level_p );
110652: ff 31 pushl (%ecx) 110654: 9d popf
return 0;
110655: 31 c0 xor %eax,%eax 110657: eb dd jmp 110636 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 110659: 8d 76 00 lea 0x0(%esi),%esi
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
11065c: 8b 5a 1c mov 0x1c(%edx),%ebx 11065f: 8d 73 01 lea 0x1(%ebx),%esi 110662: 89 72 1c mov %esi,0x1c(%edx)
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
110665: 8b 72 14 mov 0x14(%edx),%esi 110668: 39 70 4c cmp %esi,0x4c(%eax)
11066b: 74 6b je 1106d8 <_CORE_mutex_Seize_interrupt_trylock+0xfc>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
11066d: 72 39 jb 1106a8 <_CORE_mutex_Seize_interrupt_trylock+0xcc>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
11066f: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
110676: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax)
the_mutex->nest_count = 0; /* undo locking above */
11067d: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
executing->resource_count--; /* undo locking above */
110684: 89 5a 1c mov %ebx,0x1c(%edx)
_ISR_Enable( *level_p );
110687: ff 31 pushl (%ecx) 110689: 9d popf
return 0;
11068a: 31 c0 xor %eax,%eax 11068c: 8d 65 f8 lea -0x8(%ebp),%esp 11068f: 5b pop %ebx 110690: 5e pop %esi 110691: c9 leave 110692: c3 ret 110693: 90 nop
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
110694: 4b dec %ebx
110695: 75 9a jne 110631 <_CORE_mutex_Seize_interrupt_trylock+0x55><== ALWAYS TAKEN
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
110697: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED
_ISR_Enable( *level_p );
11069e: ff 31 pushl (%ecx) <== NOT EXECUTED 1106a0: 9d popf <== NOT EXECUTED
return 0;
1106a1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1106a3: eb 91 jmp 110636 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED 1106a5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1106a8: 8b 15 b0 64 12 00 mov 0x1264b0,%edx 1106ae: 42 inc %edx 1106af: 89 15 b0 64 12 00 mov %edx,0x1264b0
return 0;
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
1106b5: ff 31 pushl (%ecx) 1106b7: 9d popf
_Thread_Change_priority(
1106b8: 52 push %edx 1106b9: 6a 00 push $0x0 1106bb: ff 70 4c pushl 0x4c(%eax) 1106be: ff 70 5c pushl 0x5c(%eax) 1106c1: e8 7a cc ff ff call 10d340 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
1106c6: e8 29 d1 ff ff call 10d7f4 <_Thread_Enable_dispatch> 1106cb: 83 c4 10 add $0x10,%esp
return 0;
1106ce: 31 c0 xor %eax,%eax 1106d0: e9 61 ff ff ff jmp 110636 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 1106d5: 8d 76 00 lea 0x0(%esi),%esi
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
_ISR_Enable( *level_p );
1106d8: ff 31 pushl (%ecx) 1106da: 9d popf
return 0;
1106db: 31 c0 xor %eax,%eax 1106dd: e9 54 ff ff ff jmp 110636 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
0010c244 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
10c244: 55 push %ebp 10c245: 89 e5 mov %esp,%ebp 10c247: 53 push %ebx 10c248: 83 ec 04 sub $0x4,%esp 10c24b: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
10c24e: 8b 43 5c mov 0x5c(%ebx),%eax
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
10c251: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10c255: 74 15 je 10c26c <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10c257: 3b 05 78 67 12 00 cmp 0x126778,%eax
10c25d: 74 0d je 10c26c <_CORE_mutex_Surrender+0x28>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
10c25f: b8 03 00 00 00 mov $0x3,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c264: 8b 5d fc mov -0x4(%ebp),%ebx 10c267: c9 leave 10c268: c3 ret 10c269: 8d 76 00 lea 0x0(%esi),%esi
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
10c26c: 8b 53 54 mov 0x54(%ebx),%edx 10c26f: 85 d2 test %edx,%edx
10c271: 74 51 je 10c2c4 <_CORE_mutex_Surrender+0x80>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10c273: 4a dec %edx 10c274: 89 53 54 mov %edx,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10c277: 85 d2 test %edx,%edx
10c279: 75 49 jne 10c2c4 <_CORE_mutex_Surrender+0x80>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c27b: 8b 53 48 mov 0x48(%ebx),%edx
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10c27e: 83 fa 02 cmp $0x2,%edx
10c281: 74 69 je 10c2ec <_CORE_mutex_Surrender+0xa8>
10c283: 83 fa 03 cmp $0x3,%edx
10c286: 74 64 je 10c2ec <_CORE_mutex_Surrender+0xa8>
if ( holder->resource_count == 0 &&
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
}
}
the_mutex->holder = NULL;
10c288: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10c28f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
10c296: 83 ec 0c sub $0xc,%esp 10c299: 53 push %ebx 10c29a: e8 e5 18 00 00 call 10db84 <_Thread_queue_Dequeue> 10c29f: 83 c4 10 add $0x10,%esp 10c2a2: 85 c0 test %eax,%eax
10c2a4: 74 7a je 10c320 <_CORE_mutex_Surrender+0xdc>
} else
#endif
{
the_mutex->holder = the_thread;
10c2a6: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10c2a9: 8b 50 08 mov 0x8(%eax),%edx 10c2ac: 89 53 60 mov %edx,0x60(%ebx)
the_mutex->nest_count = 1;
10c2af: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10c2b6: 8b 53 48 mov 0x48(%ebx),%edx 10c2b9: 83 fa 02 cmp $0x2,%edx
10c2bc: 74 56 je 10c314 <_CORE_mutex_Surrender+0xd0>
10c2be: 83 fa 03 cmp $0x3,%edx
10c2c1: 74 09 je 10c2cc <_CORE_mutex_Surrender+0x88>
10c2c3: 90 nop
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c2c4: 31 c0 xor %eax,%eax
}
10c2c6: 8b 5d fc mov -0x4(%ebp),%ebx 10c2c9: c9 leave 10c2ca: c3 ret 10c2cb: 90 nop
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
10c2cc: ff 40 1c incl 0x1c(%eax)
if (the_mutex->Attributes.priority_ceiling <
10c2cf: 8b 53 4c mov 0x4c(%ebx),%edx 10c2d2: 3b 50 14 cmp 0x14(%eax),%edx
10c2d5: 73 ed jae 10c2c4 <_CORE_mutex_Surrender+0x80>
the_thread->current_priority){
_Thread_Change_priority(
10c2d7: 51 push %ecx 10c2d8: 6a 00 push $0x0 10c2da: 52 push %edx 10c2db: 50 push %eax 10c2dc: e8 5f 10 00 00 call 10d340 <_Thread_Change_priority> 10c2e1: 83 c4 10 add $0x10,%esp
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c2e4: 31 c0 xor %eax,%eax 10c2e6: e9 79 ff ff ff jmp 10c264 <_CORE_mutex_Surrender+0x20> 10c2eb: 90 nop
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
10c2ec: 8b 50 1c mov 0x1c(%eax),%edx 10c2ef: 4a dec %edx 10c2f0: 89 50 1c mov %edx,0x1c(%eax)
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
10c2f3: 85 d2 test %edx,%edx
10c2f5: 75 91 jne 10c288 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
10c2f7: 8b 50 18 mov 0x18(%eax),%edx
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
10c2fa: 3b 50 14 cmp 0x14(%eax),%edx
10c2fd: 74 89 je 10c288 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
10c2ff: 51 push %ecx 10c300: 6a 01 push $0x1 10c302: 52 push %edx 10c303: 50 push %eax 10c304: e8 37 10 00 00 call 10d340 <_Thread_Change_priority> 10c309: 83 c4 10 add $0x10,%esp 10c30c: e9 77 ff ff ff jmp 10c288 <_CORE_mutex_Surrender+0x44> 10c311: 8d 76 00 lea 0x0(%esi),%esi
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
10c314: ff 40 1c incl 0x1c(%eax)
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c317: 31 c0 xor %eax,%eax
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
10c319: e9 46 ff ff ff jmp 10c264 <_CORE_mutex_Surrender+0x20> 10c31e: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10c320: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c327: 31 c0 xor %eax,%eax 10c329: e9 36 ff ff ff jmp 10c264 <_CORE_mutex_Surrender+0x20>
0010c37c <_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
)
{
10c37c: 55 push %ebp 10c37d: 89 e5 mov %esp,%ebp 10c37f: 53 push %ebx 10c380: 83 ec 10 sub $0x10,%esp 10c383: 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)) ) {
10c386: 53 push %ebx 10c387: e8 f8 17 00 00 call 10db84 <_Thread_queue_Dequeue> 10c38c: 83 c4 10 add $0x10,%esp 10c38f: 85 c0 test %eax,%eax
10c391: 74 09 je 10c39c <_CORE_semaphore_Surrender+0x20>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c393: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10c395: 8b 5d fc mov -0x4(%ebp),%ebx 10c398: c9 leave 10c399: c3 ret 10c39a: 66 90 xchg %ax,%ax
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10c39c: 9c pushf 10c39d: fa cli 10c39e: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10c39f: 8b 43 48 mov 0x48(%ebx),%eax 10c3a2: 3b 43 40 cmp 0x40(%ebx),%eax
10c3a5: 72 0d jb 10c3b4 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10c3a7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10c3ac: 52 push %edx 10c3ad: 9d popf
}
return status;
}
10c3ae: 8b 5d fc mov -0x4(%ebp),%ebx 10c3b1: c9 leave 10c3b2: c3 ret 10c3b3: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10c3b4: 40 inc %eax 10c3b5: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c3b8: 31 c0 xor %eax,%eax 10c3ba: eb f0 jmp 10c3ac <_CORE_semaphore_Surrender+0x30>
0010c664 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
10c664: 55 push %ebp 10c665: 89 e5 mov %esp,%ebp 10c667: 57 push %edi 10c668: 56 push %esi 10c669: 53 push %ebx 10c66a: 8b 45 08 mov 0x8(%ebp),%eax 10c66d: 8b 7d 0c mov 0xc(%ebp),%edi
ISR_Level level;
bool is_empty_now;
_ISR_Disable( level );
10c670: 9c pushf 10c671: fa cli 10c672: 5e pop %esi
Chain_Node **the_node
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10c673: 8d 58 04 lea 0x4(%eax),%ebx
Chain_Node *old_first = head->next;
10c676: 8b 10 mov (%eax),%edx
if ( old_first != tail ) {
10c678: 39 d3 cmp %edx,%ebx
10c67a: 74 18 je 10c694 <_Chain_Get_with_empty_check+0x30>
Chain_Node *new_first = old_first->next;
10c67c: 8b 0a mov (%edx),%ecx
head->next = new_first;
10c67e: 89 08 mov %ecx,(%eax)
new_first->previous = head;
10c680: 89 41 04 mov %eax,0x4(%ecx)
*the_node = old_first;
10c683: 89 17 mov %edx,(%edi)
is_empty_now = new_first == tail;
10c685: 39 cb cmp %ecx,%ebx 10c687: 0f 94 c0 sete %al
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level );
10c68a: 56 push %esi 10c68b: 9d popf
return is_empty_now;
}
10c68c: 5b pop %ebx 10c68d: 5e pop %esi 10c68e: 5f pop %edi 10c68f: c9 leave 10c690: c3 ret 10c691: 8d 76 00 lea 0x0(%esi),%esi
} else
*the_node = NULL;
10c694: c7 07 00 00 00 00 movl $0x0,(%edi)
RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected(
Chain_Control *the_chain,
Chain_Node **the_node
)
{
bool is_empty_now = true;
10c69a: b0 01 mov $0x1,%al 10c69c: eb ec jmp 10c68a <_Chain_Get_with_empty_check+0x26>
00110538 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
110538: 55 push %ebp 110539: 89 e5 mov %esp,%ebp 11053b: 57 push %edi 11053c: 56 push %esi 11053d: 53 push %ebx 11053e: 83 ec 08 sub $0x8,%esp 110541: 8b 7d 08 mov 0x8(%ebp),%edi 110544: 8b 4d 10 mov 0x10(%ebp),%ecx 110547: 8b 75 14 mov 0x14(%ebp),%esi
size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain );
11054a: 8d 47 04 lea 0x4(%edi),%eax 11054d: 89 45 f0 mov %eax,-0x10(%ebp)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
110550: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
while ( count-- ) {
110557: 85 c9 test %ecx,%ecx
110559: 74 35 je 110590 <_Chain_Initialize+0x58><== NEVER TAKEN
11055b: 49 dec %ecx 11055c: 89 4d ec mov %ecx,-0x14(%ebp)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
11055f: 8b 45 0c mov 0xc(%ebp),%eax
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
110562: 89 fa mov %edi,%edx 110564: eb 07 jmp 11056d <_Chain_Initialize+0x35> 110566: 66 90 xchg %ax,%ax
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
110568: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
11056a: 89 d8 mov %ebx,%eax 11056c: 49 dec %ecx
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
11056d: 89 02 mov %eax,(%edx)
next->previous = current;
11056f: 89 50 04 mov %edx,0x4(%eax)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
110572: 8d 1c 30 lea (%eax,%esi,1),%ebx
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
110575: 85 c9 test %ecx,%ecx
110577: 75 ef jne 110568 <_Chain_Initialize+0x30>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
110579: 0f af 75 ec imul -0x14(%ebp),%esi 11057d: 03 75 0c add 0xc(%ebp),%esi
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
110580: 8b 45 f0 mov -0x10(%ebp),%eax 110583: 89 06 mov %eax,(%esi)
tail->previous = current;
110585: 89 77 08 mov %esi,0x8(%edi)
}
110588: 83 c4 08 add $0x8,%esp 11058b: 5b pop %ebx 11058c: 5e pop %esi 11058d: 5f pop %edi 11058e: c9 leave 11058f: c3 ret
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
110590: 89 fe mov %edi,%esi <== NOT EXECUTED 110592: eb ec jmp 110580 <_Chain_Initialize+0x48><== NOT EXECUTED
0010b070 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
10b070: 55 push %ebp 10b071: 89 e5 mov %esp,%ebp 10b073: 57 push %edi 10b074: 56 push %esi 10b075: 53 push %ebx 10b076: 83 ec 2c sub $0x2c,%esp 10b079: 8b 45 08 mov 0x8(%ebp),%eax 10b07c: 8b 4d 0c mov 0xc(%ebp),%ecx 10b07f: 8b 55 10 mov 0x10(%ebp),%edx 10b082: 89 55 dc mov %edx,-0x24(%ebp) 10b085: 8b 7d 14 mov 0x14(%ebp),%edi
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
10b088: 8b 1d 78 67 12 00 mov 0x126778,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
10b08e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10b095: 8b b3 e4 00 00 00 mov 0xe4(%ebx),%esi
_ISR_Disable( level );
10b09b: 9c pushf 10b09c: fa cli 10b09d: 8f 45 e0 popl -0x20(%ebp)
pending_events = api->pending_events;
10b0a0: 8b 16 mov (%esi),%edx 10b0a2: 89 55 d4 mov %edx,-0x2c(%ebp)
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
10b0a5: 21 c2 and %eax,%edx 10b0a7: 89 55 e4 mov %edx,-0x1c(%ebp)
10b0aa: 74 0d je 10b0b9 <_Event_Seize+0x49>
10b0ac: 39 d0 cmp %edx,%eax
10b0ae: 0f 84 84 00 00 00 je 10b138 <_Event_Seize+0xc8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
10b0b4: f6 c1 02 test $0x2,%cl
10b0b7: 75 7f jne 10b138 <_Event_Seize+0xc8>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
10b0b9: f6 c1 01 test $0x1,%cl
10b0bc: 75 62 jne 10b120 <_Event_Seize+0xb0> * set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set;
10b0be: 89 4b 30 mov %ecx,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
10b0c1: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
10b0c4: 89 7b 28 mov %edi,0x28(%ebx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10b0c7: c7 05 e0 67 12 00 01 movl $0x1,0x1267e0
10b0ce: 00 00 00
_ISR_Enable( level );
10b0d1: ff 75 e0 pushl -0x20(%ebp) 10b0d4: 9d popf
if ( ticks ) {
10b0d5: 8b 45 dc mov -0x24(%ebp),%eax 10b0d8: 85 c0 test %eax,%eax
10b0da: 0f 85 80 00 00 00 jne 10b160 <_Event_Seize+0xf0>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
10b0e0: 83 ec 08 sub $0x8,%esp 10b0e3: 68 00 01 00 00 push $0x100 10b0e8: 53 push %ebx 10b0e9: e8 46 2f 00 00 call 10e034 <_Thread_Set_state>
_ISR_Disable( level );
10b0ee: 9c pushf 10b0ef: fa cli 10b0f0: 5a pop %edx
sync_state = _Event_Sync_state;
10b0f1: a1 e0 67 12 00 mov 0x1267e0,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b0f6: c7 05 e0 67 12 00 00 movl $0x0,0x1267e0
10b0fd: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
10b100: 83 c4 10 add $0x10,%esp 10b103: 83 f8 01 cmp $0x1,%eax
10b106: 74 4c je 10b154 <_Event_Seize+0xe4> * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
10b108: 89 55 10 mov %edx,0x10(%ebp) 10b10b: 89 5d 0c mov %ebx,0xc(%ebp) 10b10e: 89 45 08 mov %eax,0x8(%ebp)
}
10b111: 8d 65 f4 lea -0xc(%ebp),%esp 10b114: 5b pop %ebx 10b115: 5e pop %esi 10b116: 5f pop %edi 10b117: c9 leave
* An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
10b118: e9 d7 21 00 00 jmp 10d2f4 <_Thread_blocking_operation_Cancel> 10b11d: 8d 76 00 lea 0x0(%esi),%esi
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
10b120: ff 75 e0 pushl -0x20(%ebp) 10b123: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
10b124: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
10b12b: 8b 55 e4 mov -0x1c(%ebp),%edx 10b12e: 89 17 mov %edx,(%edi)
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); }
10b130: 8d 65 f4 lea -0xc(%ebp),%esp 10b133: 5b pop %ebx 10b134: 5e pop %esi 10b135: 5f pop %edi 10b136: c9 leave 10b137: c3 ret
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
10b138: 8b 45 e4 mov -0x1c(%ebp),%eax 10b13b: f7 d0 not %eax 10b13d: 23 45 d4 and -0x2c(%ebp),%eax 10b140: 89 06 mov %eax,(%esi)
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
10b142: ff 75 e0 pushl -0x20(%ebp) 10b145: 9d popf
*event_out = seized_events;
10b146: 8b 45 e4 mov -0x1c(%ebp),%eax 10b149: 89 07 mov %eax,(%edi)
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); }
10b14b: 8d 65 f4 lea -0xc(%ebp),%esp 10b14e: 5b pop %ebx 10b14f: 5e pop %esi 10b150: 5f pop %edi 10b151: c9 leave 10b152: c3 ret 10b153: 90 nop
_ISR_Disable( level );
sync_state = _Event_Sync_state;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
_ISR_Enable( level );
10b154: 52 push %edx 10b155: 9d popf
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); }
10b156: 8d 65 f4 lea -0xc(%ebp),%esp 10b159: 5b pop %ebx 10b15a: 5e pop %esi 10b15b: 5f pop %edi 10b15c: c9 leave 10b15d: c3 ret 10b15e: 66 90 xchg %ax,%ax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
10b160: 8b 43 08 mov 0x8(%ebx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b163: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10b16a: c7 43 64 14 b3 10 00 movl $0x10b314,0x64(%ebx)
the_watchdog->id = id;
10b171: 89 43 68 mov %eax,0x68(%ebx)
the_watchdog->user_data = user_data;
10b174: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b17b: 8b 45 dc mov -0x24(%ebp),%eax 10b17e: 89 43 54 mov %eax,0x54(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b181: 83 ec 08 sub $0x8,%esp
&executing->Timer,
_Event_Timeout,
executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
10b184: 8d 43 48 lea 0x48(%ebx),%eax 10b187: 50 push %eax 10b188: 68 bc 65 12 00 push $0x1265bc 10b18d: e8 0e 34 00 00 call 10e5a0 <_Watchdog_Insert> 10b192: 83 c4 10 add $0x10,%esp 10b195: e9 46 ff ff ff jmp 10b0e0 <_Event_Seize+0x70>
0010b1f0 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
10b1f0: 55 push %ebp 10b1f1: 89 e5 mov %esp,%ebp 10b1f3: 57 push %edi 10b1f4: 56 push %esi 10b1f5: 53 push %ebx 10b1f6: 83 ec 2c sub $0x2c,%esp 10b1f9: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10b1fc: 8b 8b e4 00 00 00 mov 0xe4(%ebx),%ecx
option_set = (rtems_option) the_thread->Wait.option;
10b202: 8b 7b 30 mov 0x30(%ebx),%edi
_ISR_Disable( level );
10b205: 9c pushf 10b206: fa cli 10b207: 8f 45 d4 popl -0x2c(%ebp)
pending_events = api->pending_events;
10b20a: 8b 11 mov (%ecx),%edx
event_condition = (rtems_event_set) the_thread->Wait.count;
10b20c: 8b 43 24 mov 0x24(%ebx),%eax
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
10b20f: 89 c6 mov %eax,%esi 10b211: 21 d6 and %edx,%esi 10b213: 89 75 e4 mov %esi,-0x1c(%ebp)
10b216: 74 74 je 10b28c <_Event_Surrender+0x9c>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
10b218: 8b 35 74 67 12 00 mov 0x126774,%esi 10b21e: 85 f6 test %esi,%esi
10b220: 74 0c je 10b22e <_Event_Surrender+0x3e>
10b222: 3b 1d 78 67 12 00 cmp 0x126778,%ebx
10b228: 0f 84 96 00 00 00 je 10b2c4 <_Event_Surrender+0xd4>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
10b22e: f6 43 11 01 testb $0x1,0x11(%ebx)
10b232: 74 4c je 10b280 <_Event_Surrender+0x90>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
10b234: 3b 45 e4 cmp -0x1c(%ebp),%eax
10b237: 74 05 je 10b23e <_Event_Surrender+0x4e>
10b239: 83 e7 02 and $0x2,%edi
10b23c: 74 42 je 10b280 <_Event_Surrender+0x90> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
10b23e: 8b 45 e4 mov -0x1c(%ebp),%eax 10b241: f7 d0 not %eax 10b243: 21 d0 and %edx,%eax 10b245: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
10b247: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b24e: 8b 43 28 mov 0x28(%ebx),%eax 10b251: 8b 75 e4 mov -0x1c(%ebp),%esi 10b254: 89 30 mov %esi,(%eax)
_ISR_Flash( level );
10b256: ff 75 d4 pushl -0x2c(%ebp) 10b259: 9d popf 10b25a: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10b25b: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10b25f: 74 37 je 10b298 <_Event_Surrender+0xa8>
_ISR_Enable( level );
10b261: ff 75 d4 pushl -0x2c(%ebp) 10b264: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b265: 83 ec 08 sub $0x8,%esp 10b268: 68 f8 ff 03 10 push $0x1003fff8 10b26d: 53 push %ebx 10b26e: e8 01 22 00 00 call 10d474 <_Thread_Clear_state> 10b273: 83 c4 10 add $0x10,%esp
}
return;
}
}
_ISR_Enable( level );
}
10b276: 8d 65 f4 lea -0xc(%ebp),%esp 10b279: 5b pop %ebx 10b27a: 5e pop %esi 10b27b: 5f pop %edi 10b27c: c9 leave 10b27d: c3 ret 10b27e: 66 90 xchg %ax,%ax
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
10b280: ff 75 d4 pushl -0x2c(%ebp) 10b283: 9d popf
}
10b284: 8d 65 f4 lea -0xc(%ebp),%esp 10b287: 5b pop %ebx 10b288: 5e pop %esi 10b289: 5f pop %edi 10b28a: c9 leave 10b28b: c3 ret
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
10b28c: ff 75 d4 pushl -0x2c(%ebp) 10b28f: 9d popf
}
return;
}
}
_ISR_Enable( level );
}
10b290: 8d 65 f4 lea -0xc(%ebp),%esp 10b293: 5b pop %ebx 10b294: 5e pop %esi 10b295: 5f pop %edi 10b296: c9 leave 10b297: c3 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10b298: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10b29f: ff 75 d4 pushl -0x2c(%ebp) 10b2a2: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10b2a3: 83 ec 0c sub $0xc,%esp 10b2a6: 8d 43 48 lea 0x48(%ebx),%eax 10b2a9: 50 push %eax 10b2aa: e8 31 34 00 00 call 10e6e0 <_Watchdog_Remove> 10b2af: 58 pop %eax 10b2b0: 5a pop %edx 10b2b1: 68 f8 ff 03 10 push $0x1003fff8 10b2b6: 53 push %ebx 10b2b7: e8 b8 21 00 00 call 10d474 <_Thread_Clear_state> 10b2bc: 83 c4 10 add $0x10,%esp 10b2bf: eb c3 jmp 10b284 <_Event_Surrender+0x94> 10b2c1: 8d 76 00 lea 0x0(%esi),%esi
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
10b2c4: 8b 35 e0 67 12 00 mov 0x1267e0,%esi
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
10b2ca: 83 fe 02 cmp $0x2,%esi
10b2cd: 74 0d je 10b2dc <_Event_Surrender+0xec> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
10b2cf: 8b 35 e0 67 12 00 mov 0x1267e0,%esi
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
10b2d5: 4e dec %esi
10b2d6: 0f 85 52 ff ff ff jne 10b22e <_Event_Surrender+0x3e>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
10b2dc: 3b 45 e4 cmp -0x1c(%ebp),%eax
10b2df: 74 05 je 10b2e6 <_Event_Surrender+0xf6>
10b2e1: 83 e7 02 and $0x2,%edi
10b2e4: 74 22 je 10b308 <_Event_Surrender+0x118><== NEVER TAKEN
10b2e6: 8b 45 e4 mov -0x1c(%ebp),%eax 10b2e9: f7 d0 not %eax 10b2eb: 21 d0 and %edx,%eax 10b2ed: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
10b2ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b2f6: 8b 43 28 mov 0x28(%ebx),%eax 10b2f9: 8b 55 e4 mov -0x1c(%ebp),%edx 10b2fc: 89 10 mov %edx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10b2fe: c7 05 e0 67 12 00 03 movl $0x3,0x1267e0
10b305: 00 00 00
}
_ISR_Enable( level );
10b308: ff 75 d4 pushl -0x2c(%ebp) 10b30b: 9d popf
return;
10b30c: e9 73 ff ff ff jmp 10b284 <_Event_Surrender+0x94>
0010b314 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10b314: 55 push %ebp 10b315: 89 e5 mov %esp,%ebp 10b317: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10b31a: 8d 45 f4 lea -0xc(%ebp),%eax 10b31d: 50 push %eax 10b31e: ff 75 08 pushl 0x8(%ebp) 10b321: e8 f2 24 00 00 call 10d818 <_Thread_Get>
switch ( location ) {
10b326: 83 c4 10 add $0x10,%esp 10b329: 8b 55 f4 mov -0xc(%ebp),%edx 10b32c: 85 d2 test %edx,%edx
10b32e: 75 37 jne 10b367 <_Event_Timeout+0x53> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
10b330: 9c pushf 10b331: fa cli 10b332: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
10b333: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
10b33a: 3b 05 78 67 12 00 cmp 0x126778,%eax
10b340: 74 2a je 10b36c <_Event_Timeout+0x58>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
10b342: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
10b349: 52 push %edx 10b34a: 9d popf 10b34b: 83 ec 08 sub $0x8,%esp 10b34e: 68 f8 ff 03 10 push $0x1003fff8 10b353: 50 push %eax 10b354: e8 1b 21 00 00 call 10d474 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b359: a1 b0 64 12 00 mov 0x1264b0,%eax 10b35e: 48 dec %eax 10b35f: a3 b0 64 12 00 mov %eax,0x1264b0
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
10b364: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b367: c9 leave 10b368: c3 ret 10b369: 8d 76 00 lea 0x0(%esi),%esi
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
10b36c: 8b 0d e0 67 12 00 mov 0x1267e0,%ecx 10b372: 49 dec %ecx
10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10b375: c7 05 e0 67 12 00 02 movl $0x2,0x1267e0
10b37c: 00 00 00
10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e>
00110738 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
110738: 55 push %ebp 110739: 89 e5 mov %esp,%ebp 11073b: 57 push %edi 11073c: 56 push %esi 11073d: 53 push %ebx 11073e: 83 ec 2c sub $0x2c,%esp 110741: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
110744: 8d 47 04 lea 0x4(%edi),%eax 110747: 89 45 dc mov %eax,-0x24(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
11074a: 8b 55 08 mov 0x8(%ebp),%edx 11074d: 8b 52 10 mov 0x10(%edx),%edx 110750: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
110753: 39 c7 cmp %eax,%edi
110755: 0f 87 69 01 00 00 ja 1108c4 <_Heap_Allocate_aligned_with_boundary+0x18c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
11075b: 8b 5d 14 mov 0x14(%ebp),%ebx 11075e: 85 db test %ebx,%ebx
110760: 0f 85 56 01 00 00 jne 1108bc <_Heap_Allocate_aligned_with_boundary+0x184>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
110766: 8b 45 08 mov 0x8(%ebp),%eax 110769: 8b 48 08 mov 0x8(%eax),%ecx
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
11076c: 39 c8 cmp %ecx,%eax
11076e: 0f 84 50 01 00 00 je 1108c4 <_Heap_Allocate_aligned_with_boundary+0x18c>
110774: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
11077b: 8b 55 cc mov -0x34(%ebp),%edx 11077e: 83 c2 07 add $0x7,%edx 110781: 89 55 c8 mov %edx,-0x38(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
110784: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 11078b: 29 7d d0 sub %edi,-0x30(%ebp) 11078e: eb 1e jmp 1107ae <_Heap_Allocate_aligned_with_boundary+0x76>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
110790: 8d 59 08 lea 0x8(%ecx),%ebx
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
110793: 85 db test %ebx,%ebx
110795: 0f 85 f1 00 00 00 jne 11088c <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN
break;
}
block = block->next;
11079b: 8b 49 08 mov 0x8(%ecx),%ecx 11079e: 8b 45 e4 mov -0x1c(%ebp),%eax 1107a1: 40 inc %eax
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
1107a2: 39 4d 08 cmp %ecx,0x8(%ebp)
1107a5: 0f 84 25 01 00 00 je 1108d0 <_Heap_Allocate_aligned_with_boundary+0x198>
1107ab: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
1107ae: 8b 59 04 mov 0x4(%ecx),%ebx 1107b1: 39 5d dc cmp %ebx,-0x24(%ebp)
1107b4: 73 e5 jae 11079b <_Heap_Allocate_aligned_with_boundary+0x63>
if ( alignment == 0 ) {
1107b6: 8b 55 10 mov 0x10(%ebp),%edx 1107b9: 85 d2 test %edx,%edx
1107bb: 74 d3 je 110790 <_Heap_Allocate_aligned_with_boundary+0x58>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
1107bd: 8b 45 08 mov 0x8(%ebp),%eax 1107c0: 8b 40 14 mov 0x14(%eax),%eax 1107c3: 89 45 d8 mov %eax,-0x28(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1107c6: 83 e3 fe and $0xfffffffe,%ebx
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
1107c9: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
1107cc: 8d 51 08 lea 0x8(%ecx),%edx 1107cf: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
1107d2: 8b 75 c8 mov -0x38(%ebp),%esi 1107d5: 29 c6 sub %eax,%esi
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
1107d7: 01 de add %ebx,%esi
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
1107d9: 03 5d d0 add -0x30(%ebp),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
1107dc: 89 d8 mov %ebx,%eax 1107de: 31 d2 xor %edx,%edx 1107e0: f7 75 10 divl 0x10(%ebp) 1107e3: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
1107e5: 39 de cmp %ebx,%esi
1107e7: 73 0b jae 1107f4 <_Heap_Allocate_aligned_with_boundary+0xbc>
1107e9: 89 f0 mov %esi,%eax 1107eb: 31 d2 xor %edx,%edx 1107ed: f7 75 10 divl 0x10(%ebp) 1107f0: 89 f3 mov %esi,%ebx 1107f2: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
1107f4: 8b 45 14 mov 0x14(%ebp),%eax 1107f7: 85 c0 test %eax,%eax
1107f9: 74 5b je 110856 <_Heap_Allocate_aligned_with_boundary+0x11e>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
1107fb: 8d 34 3b lea (%ebx,%edi,1),%esi 1107fe: 89 f0 mov %esi,%eax 110800: 31 d2 xor %edx,%edx 110802: f7 75 14 divl 0x14(%ebp) 110805: 89 f0 mov %esi,%eax 110807: 29 d0 sub %edx,%eax
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
110809: 39 c3 cmp %eax,%ebx
11080b: 73 49 jae 110856 <_Heap_Allocate_aligned_with_boundary+0x11e>
11080d: 39 c6 cmp %eax,%esi
11080f: 76 45 jbe 110856 <_Heap_Allocate_aligned_with_boundary+0x11e>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
110811: 8b 55 d4 mov -0x2c(%ebp),%edx 110814: 01 fa add %edi,%edx 110816: 89 55 e0 mov %edx,-0x20(%ebp)
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
110819: 39 c2 cmp %eax,%edx
11081b: 0f 87 7a ff ff ff ja 11079b <_Heap_Allocate_aligned_with_boundary+0x63>
110821: 89 ce mov %ecx,%esi 110823: eb 10 jmp 110835 <_Heap_Allocate_aligned_with_boundary+0xfd> 110825: 8d 76 00 lea 0x0(%esi),%esi
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
110828: 39 c1 cmp %eax,%ecx
11082a: 76 28 jbe 110854 <_Heap_Allocate_aligned_with_boundary+0x11c>
if ( boundary_line < boundary_floor ) {
11082c: 39 45 e0 cmp %eax,-0x20(%ebp)
11082f: 0f 87 9f 00 00 00 ja 1108d4 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
110835: 89 c3 mov %eax,%ebx 110837: 29 fb sub %edi,%ebx 110839: 89 d8 mov %ebx,%eax 11083b: 31 d2 xor %edx,%edx 11083d: f7 75 10 divl 0x10(%ebp) 110840: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
110842: 8d 0c 3b lea (%ebx,%edi,1),%ecx 110845: 89 c8 mov %ecx,%eax 110847: 31 d2 xor %edx,%edx 110849: f7 75 14 divl 0x14(%ebp) 11084c: 89 c8 mov %ecx,%eax 11084e: 29 d0 sub %edx,%eax
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
110850: 39 c3 cmp %eax,%ebx
110852: 72 d4 jb 110828 <_Heap_Allocate_aligned_with_boundary+0xf0>
110854: 89 f1 mov %esi,%ecx
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
110856: 39 5d d4 cmp %ebx,-0x2c(%ebp)
110859: 0f 87 3c ff ff ff ja 11079b <_Heap_Allocate_aligned_with_boundary+0x63>
11085f: be f8 ff ff ff mov $0xfffffff8,%esi 110864: 29 ce sub %ecx,%esi
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
110866: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110868: 89 d8 mov %ebx,%eax 11086a: 31 d2 xor %edx,%edx 11086c: f7 75 cc divl -0x34(%ebp)
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
11086f: 29 d6 sub %edx,%esi
if ( free_size >= min_block_size || free_size == 0 ) {
110871: 39 75 d8 cmp %esi,-0x28(%ebp)
110874: 0f 86 19 ff ff ff jbe 110793 <_Heap_Allocate_aligned_with_boundary+0x5b>
11087a: 85 f6 test %esi,%esi
11087c: 0f 85 19 ff ff ff jne 11079b <_Heap_Allocate_aligned_with_boundary+0x63>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
110882: 85 db test %ebx,%ebx
110884: 0f 84 11 ff ff ff je 11079b <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN
11088a: 66 90 xchg %ax,%ax
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
11088c: 8b 45 08 mov 0x8(%ebp),%eax 11088f: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
110892: 8b 55 e4 mov -0x1c(%ebp),%edx 110895: 01 50 4c add %edx,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
110898: 57 push %edi 110899: 53 push %ebx 11089a: 51 push %ecx 11089b: 50 push %eax 11089c: e8 8f be ff ff call 10c730 <_Heap_Block_allocate> 1108a1: 89 d8 mov %ebx,%eax 1108a3: 83 c4 10 add $0x10,%esp
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
1108a6: 8b 55 e4 mov -0x1c(%ebp),%edx 1108a9: 8b 4d 08 mov 0x8(%ebp),%ecx 1108ac: 39 51 44 cmp %edx,0x44(%ecx)
1108af: 73 15 jae 1108c6 <_Heap_Allocate_aligned_with_boundary+0x18e>
stats->max_search = search_count;
1108b1: 89 51 44 mov %edx,0x44(%ecx)
}
return (void *) alloc_begin;
}
1108b4: 8d 65 f4 lea -0xc(%ebp),%esp 1108b7: 5b pop %ebx 1108b8: 5e pop %esi 1108b9: 5f pop %edi 1108ba: c9 leave 1108bb: c3 ret
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
1108bc: 3b 7d 14 cmp 0x14(%ebp),%edi
1108bf: 76 1a jbe 1108db <_Heap_Allocate_aligned_with_boundary+0x1a3>
1108c1: 8d 76 00 lea 0x0(%esi),%esi
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
1108c4: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
1108c6: 8d 65 f4 lea -0xc(%ebp),%esp 1108c9: 5b pop %ebx 1108ca: 5e pop %esi 1108cb: 5f pop %edi 1108cc: c9 leave 1108cd: c3 ret 1108ce: 66 90 xchg %ax,%ax
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
1108d0: 31 c0 xor %eax,%eax 1108d2: eb d2 jmp 1108a6 <_Heap_Allocate_aligned_with_boundary+0x16e>
1108d4: 89 f1 mov %esi,%ecx <== NOT EXECUTED 1108d6: e9 c0 fe ff ff jmp 11079b <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
1108db: 8b 4d 10 mov 0x10(%ebp),%ecx 1108de: 85 c9 test %ecx,%ecx
1108e0: 0f 85 80 fe ff ff jne 110766 <_Heap_Allocate_aligned_with_boundary+0x2e>
alignment = page_size;
1108e6: 89 55 10 mov %edx,0x10(%ebp) 1108e9: e9 78 fe ff ff jmp 110766 <_Heap_Allocate_aligned_with_boundary+0x2e>
00110ccc <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
110ccc: 55 push %ebp 110ccd: 89 e5 mov %esp,%ebp 110ccf: 57 push %edi 110cd0: 56 push %esi 110cd1: 53 push %ebx 110cd2: 83 ec 4c sub $0x4c,%esp 110cd5: 8b 5d 08 mov 0x8(%ebp),%ebx 110cd8: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
110cdb: 8b 43 20 mov 0x20(%ebx),%eax 110cde: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
110ce1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
110ce8: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
110cef: 8b 53 10 mov 0x10(%ebx),%edx 110cf2: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
110cf5: 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;
110cf8: 8b 73 30 mov 0x30(%ebx),%esi 110cfb: 89 75 c0 mov %esi,-0x40(%ebp)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
110cfe: 8b 55 0c mov 0xc(%ebp),%edx 110d01: 01 ca add %ecx,%edx 110d03: 89 55 cc mov %edx,-0x34(%ebp)
110d06: 73 0c jae 110d14 <_Heap_Extend+0x48>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
110d08: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
110d0a: 8d 65 f4 lea -0xc(%ebp),%esp 110d0d: 5b pop %ebx 110d0e: 5e pop %esi 110d0f: 5f pop %edi 110d10: c9 leave 110d11: c3 ret 110d12: 66 90 xchg %ax,%ax
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
110d14: 83 ec 08 sub $0x8,%esp 110d17: 8d 55 e0 lea -0x20(%ebp),%edx 110d1a: 52 push %edx 110d1b: 8d 55 e4 lea -0x1c(%ebp),%edx 110d1e: 52 push %edx 110d1f: 50 push %eax 110d20: ff 75 d4 pushl -0x2c(%ebp) 110d23: 51 push %ecx 110d24: ff 75 0c pushl 0xc(%ebp) 110d27: e8 20 bc ff ff call 10c94c <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
110d2c: 83 c4 20 add $0x20,%esp 110d2f: 84 c0 test %al,%al
110d31: 74 d5 je 110d08 <_Heap_Extend+0x3c>
110d33: 8b 7d d0 mov -0x30(%ebp),%edi 110d36: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 110d3d: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 110d44: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 110d4b: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 110d52: 8b 75 cc mov -0x34(%ebp),%esi 110d55: 89 5d b4 mov %ebx,-0x4c(%ebp) 110d58: eb 30 jmp 110d8a <_Heap_Extend+0xbe> 110d5a: 66 90 xchg %ax,%ax
return false;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
110d5c: 39 ce cmp %ecx,%esi
110d5e: 73 03 jae 110d63 <_Heap_Extend+0x97>
110d60: 89 7d b8 mov %edi,-0x48(%ebp)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110d63: 8d 59 f8 lea -0x8(%ecx),%ebx 110d66: 89 c8 mov %ecx,%eax 110d68: 31 d2 xor %edx,%edx 110d6a: f7 75 d4 divl -0x2c(%ebp)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
110d6d: 29 d3 sub %edx,%ebx
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
110d6f: 3b 4d 0c cmp 0xc(%ebp),%ecx
110d72: 74 3c je 110db0 <_Heap_Extend+0xe4>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
110d74: 39 4d 0c cmp %ecx,0xc(%ebp)
110d77: 76 03 jbe 110d7c <_Heap_Extend+0xb0>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
110d79: 89 5d bc mov %ebx,-0x44(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110d7c: 8b 7b 04 mov 0x4(%ebx),%edi 110d7f: 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);
110d82: 8d 3c 3b lea (%ebx,%edi,1),%edi
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
110d85: 39 7d d0 cmp %edi,-0x30(%ebp)
110d88: 74 39 je 110dc3 <_Heap_Extend+0xf7>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
110d8a: 3b 7d d0 cmp -0x30(%ebp),%edi
110d8d: 0f 84 39 01 00 00 je 110ecc <_Heap_Extend+0x200>
110d93: 89 f8 mov %edi,%eax
uintptr_t const sub_area_end = start_block->prev_size;
110d95: 8b 0f mov (%edi),%ecx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
110d97: 39 4d 0c cmp %ecx,0xc(%ebp)
110d9a: 73 08 jae 110da4 <_Heap_Extend+0xd8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
110d9c: 39 f0 cmp %esi,%eax
110d9e: 0f 82 64 ff ff ff jb 110d08 <_Heap_Extend+0x3c>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
110da4: 39 f0 cmp %esi,%eax
110da6: 75 b4 jne 110d5c <_Heap_Extend+0x90>
110da8: 89 7d c4 mov %edi,-0x3c(%ebp) 110dab: eb b6 jmp 110d63 <_Heap_Extend+0x97> 110dad: 8d 76 00 lea 0x0(%esi),%esi
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
start_block->prev_size = extend_area_end;
110db0: 89 37 mov %esi,(%edi)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
110db2: 89 5d c8 mov %ebx,-0x38(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110db5: 8b 7b 04 mov 0x4(%ebx),%edi 110db8: 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);
110dbb: 8d 3c 3b lea (%ebx,%edi,1),%edi
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
110dbe: 39 7d d0 cmp %edi,-0x30(%ebp)
110dc1: 75 c7 jne 110d8a <_Heap_Extend+0xbe> <== NEVER TAKEN
110dc3: 8b 5d b4 mov -0x4c(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
110dc6: 8b 75 0c mov 0xc(%ebp),%esi 110dc9: 3b 73 18 cmp 0x18(%ebx),%esi
110dcc: 0f 82 06 01 00 00 jb 110ed8 <_Heap_Extend+0x20c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
110dd2: 8b 45 cc mov -0x34(%ebp),%eax 110dd5: 3b 43 1c cmp 0x1c(%ebx),%eax
110dd8: 76 03 jbe 110ddd <_Heap_Extend+0x111>
heap->area_end = extend_area_end;
110dda: 89 43 1c mov %eax,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
110ddd: 8b 55 e0 mov -0x20(%ebp),%edx 110de0: 8b 45 e4 mov -0x1c(%ebp),%eax
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
110de3: 89 d1 mov %edx,%ecx 110de5: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
110de7: 8b 75 cc mov -0x34(%ebp),%esi 110dea: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
110dec: 89 ce mov %ecx,%esi 110dee: 83 ce 01 or $0x1,%esi 110df1: 89 70 04 mov %esi,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
110df4: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
110df6: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
110dfd: 39 43 20 cmp %eax,0x20(%ebx)
110e00: 0f 86 da 00 00 00 jbe 110ee0 <_Heap_Extend+0x214>
heap->first_block = extend_first_block;
110e06: 89 43 20 mov %eax,0x20(%ebx)
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
110e09: 8b 75 c4 mov -0x3c(%ebp),%esi 110e0c: 85 f6 test %esi,%esi
110e0e: 0f 84 10 01 00 00 je 110f24 <_Heap_Extend+0x258>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
110e14: 8b 73 10 mov 0x10(%ebx),%esi
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
110e17: 8b 4d 0c mov 0xc(%ebp),%ecx 110e1a: 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;
110e1d: 89 c8 mov %ecx,%eax 110e1f: 31 d2 xor %edx,%edx 110e21: f7 f6 div %esi
if ( remainder != 0 ) {
110e23: 85 d2 test %edx,%edx
110e25: 0f 84 c9 00 00 00 je 110ef4 <_Heap_Extend+0x228> <== ALWAYS TAKEN
return value - remainder + alignment;
110e2b: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 110e2e: 29 d0 sub %edx,%eax <== NOT EXECUTED
uintptr_t const new_first_block_begin =
110e30: 8d 50 f8 lea -0x8(%eax),%edx
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
110e33: 8b 75 c4 mov -0x3c(%ebp),%esi 110e36: 8b 0e mov (%esi),%ecx 110e38: 89 48 f8 mov %ecx,-0x8(%eax)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
110e3b: 89 f0 mov %esi,%eax 110e3d: 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;
110e3f: 83 c8 01 or $0x1,%eax 110e42: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
110e45: 89 d8 mov %ebx,%eax 110e47: e8 64 fe ff ff call 110cb0 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
110e4c: 8b 45 c8 mov -0x38(%ebp),%eax 110e4f: 85 c0 test %eax,%eax
110e51: 0f 84 a5 00 00 00 je 110efc <_Heap_Extend+0x230>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
110e57: 8b 4d cc mov -0x34(%ebp),%ecx 110e5a: 83 e9 08 sub $0x8,%ecx
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
110e5d: 2b 4d c8 sub -0x38(%ebp),%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110e60: 89 c8 mov %ecx,%eax 110e62: 31 d2 xor %edx,%edx 110e64: f7 73 10 divl 0x10(%ebx) 110e67: 29 d1 sub %edx,%ecx
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
110e69: 8b 55 c8 mov -0x38(%ebp),%edx 110e6c: 8b 42 04 mov 0x4(%edx),%eax 110e6f: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
110e71: 83 c8 01 or $0x1,%eax 110e74: 89 44 11 04 mov %eax,0x4(%ecx,%edx,1)
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
110e78: 8b 42 04 mov 0x4(%edx),%eax 110e7b: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
110e7e: 09 c8 or %ecx,%eax 110e80: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
110e83: 89 d8 mov %ebx,%eax 110e85: e8 26 fe ff ff call 110cb0 <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
110e8a: 8b 75 c4 mov -0x3c(%ebp),%esi 110e8d: 85 f6 test %esi,%esi
110e8f: 0f 84 ab 00 00 00 je 110f40 <_Heap_Extend+0x274>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
110e95: 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(
110e98: 8b 43 20 mov 0x20(%ebx),%eax 110e9b: 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;
110e9d: 8b 4a 04 mov 0x4(%edx),%ecx 110ea0: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
110ea3: 09 c8 or %ecx,%eax 110ea5: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
110ea8: 8b 43 30 mov 0x30(%ebx),%eax 110eab: 2b 45 c0 sub -0x40(%ebp),%eax
/* Statistics */
stats->size += extended_size;
110eae: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
110eb1: 8b 55 14 mov 0x14(%ebp),%edx 110eb4: 85 d2 test %edx,%edx
110eb6: 0f 84 a0 00 00 00 je 110f5c <_Heap_Extend+0x290> <== NEVER TAKEN
*extended_size_ptr = extended_size;
110ebc: 8b 55 14 mov 0x14(%ebp),%edx 110ebf: 89 02 mov %eax,(%edx)
return true;
110ec1: b0 01 mov $0x1,%al
}
110ec3: 8d 65 f4 lea -0xc(%ebp),%esp 110ec6: 5b pop %ebx 110ec7: 5e pop %esi 110ec8: 5f pop %edi 110ec9: c9 leave 110eca: c3 ret 110ecb: 90 nop
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
110ecc: 8b 55 b4 mov -0x4c(%ebp),%edx 110ecf: 8b 42 18 mov 0x18(%edx),%eax 110ed2: e9 be fe ff ff jmp 110d95 <_Heap_Extend+0xc9> 110ed7: 90 nop
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
heap->area_begin = extend_area_begin;
110ed8: 89 73 18 mov %esi,0x18(%ebx) 110edb: e9 fd fe ff ff jmp 110ddd <_Heap_Extend+0x111>
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
110ee0: 39 53 24 cmp %edx,0x24(%ebx)
110ee3: 0f 83 20 ff ff ff jae 110e09 <_Heap_Extend+0x13d>
heap->last_block = extend_last_block;
110ee9: 89 53 24 mov %edx,0x24(%ebx) 110eec: e9 18 ff ff ff jmp 110e09 <_Heap_Extend+0x13d> 110ef1: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
} else {
return value;
110ef4: 89 c8 mov %ecx,%eax 110ef6: e9 35 ff ff ff jmp 110e30 <_Heap_Extend+0x164> 110efb: 90 nop
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
110efc: 8b 7d bc mov -0x44(%ebp),%edi 110eff: 85 ff test %edi,%edi
110f01: 74 87 je 110e8a <_Heap_Extend+0x1be>
_Heap_Link_above(
110f03: 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 );
110f06: 8b 45 e4 mov -0x1c(%ebp),%eax 110f09: 2b 45 bc sub -0x44(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
110f0c: 8b 75 bc mov -0x44(%ebp),%esi 110f0f: 8b 56 04 mov 0x4(%esi),%edx 110f12: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
110f15: 09 d0 or %edx,%eax 110f17: 89 46 04 mov %eax,0x4(%esi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
110f1a: 83 49 04 01 orl $0x1,0x4(%ecx) 110f1e: e9 67 ff ff ff jmp 110e8a <_Heap_Extend+0x1be> 110f23: 90 nop
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
110f24: 8b 4d b8 mov -0x48(%ebp),%ecx 110f27: 85 c9 test %ecx,%ecx
110f29: 0f 84 1d ff ff ff je 110e4c <_Heap_Extend+0x180>
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
110f2f: 8b 45 b8 mov -0x48(%ebp),%eax 110f32: 29 d0 sub %edx,%eax 110f34: 83 c8 01 or $0x1,%eax 110f37: 89 42 04 mov %eax,0x4(%edx) 110f3a: e9 0d ff ff ff jmp 110e4c <_Heap_Extend+0x180> 110f3f: 90 nop
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
110f40: 8b 4d c8 mov -0x38(%ebp),%ecx 110f43: 85 c9 test %ecx,%ecx
110f45: 0f 85 4a ff ff ff jne 110e95 <_Heap_Extend+0x1c9>
_Heap_Free_block( heap, extend_first_block );
110f4b: 8b 55 e4 mov -0x1c(%ebp),%edx 110f4e: 89 d8 mov %ebx,%eax 110f50: e8 5b fd ff ff call 110cb0 <_Heap_Free_block> 110f55: e9 3b ff ff ff jmp 110e95 <_Heap_Extend+0x1c9> 110f5a: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
110f5c: b0 01 mov $0x1,%al <== NOT EXECUTED 110f5e: e9 a7 fd ff ff jmp 110d0a <_Heap_Extend+0x3e> <== NOT EXECUTED
001108f0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
1108f0: 55 push %ebp 1108f1: 89 e5 mov %esp,%ebp 1108f3: 57 push %edi 1108f4: 56 push %esi 1108f5: 53 push %ebx 1108f6: 83 ec 10 sub $0x10,%esp 1108f9: 8b 5d 08 mov 0x8(%ebp),%ebx 1108fc: 8b 45 0c mov 0xc(%ebp),%eax 1108ff: 8d 48 f8 lea -0x8(%eax),%ecx 110902: 31 d2 xor %edx,%edx 110904: 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);
110907: 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
110909: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11090c: 39 c1 cmp %eax,%ecx
11090e: 72 07 jb 110917 <_Heap_Free+0x27>
110910: 8b 73 24 mov 0x24(%ebx),%esi 110913: 39 f1 cmp %esi,%ecx
110915: 76 0d jbe 110924 <_Heap_Free+0x34>
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
110917: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
110919: 83 c4 10 add $0x10,%esp 11091c: 5b pop %ebx 11091d: 5e pop %esi 11091e: 5f pop %edi 11091f: c9 leave 110920: c3 ret 110921: 8d 76 00 lea 0x0(%esi),%esi 110924: 8b 51 04 mov 0x4(%ecx),%edx 110927: 89 55 f0 mov %edx,-0x10(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11092a: 83 e2 fe and $0xfffffffe,%edx 11092d: 89 55 ec mov %edx,-0x14(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
110930: 8d 14 11 lea (%ecx,%edx,1),%edx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
110933: 39 d0 cmp %edx,%eax
110935: 77 e0 ja 110917 <_Heap_Free+0x27> <== NEVER TAKEN
110937: 39 d6 cmp %edx,%esi
110939: 72 dc jb 110917 <_Heap_Free+0x27> <== NEVER TAKEN
11093b: 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 ) ) {
11093e: f7 c7 01 00 00 00 test $0x1,%edi
110944: 74 d1 je 110917 <_Heap_Free+0x27> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110946: 83 e7 fe and $0xfffffffe,%edi 110949: 89 7d e4 mov %edi,-0x1c(%ebp)
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
11094c: 39 d6 cmp %edx,%esi
11094e: 0f 84 c8 00 00 00 je 110a1c <_Heap_Free+0x12c>
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
110954: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 110959: 0f 94 45 eb sete -0x15(%ebp)
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
11095d: f6 45 f0 01 testb $0x1,-0x10(%ebp)
110961: 75 45 jne 1109a8 <_Heap_Free+0xb8>
uintptr_t const prev_size = block->prev_size;
110963: 8b 39 mov (%ecx),%edi 110965: 89 7d f0 mov %edi,-0x10(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
110968: 29 f9 sub %edi,%ecx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11096a: 39 c8 cmp %ecx,%eax
11096c: 77 a9 ja 110917 <_Heap_Free+0x27> <== NEVER TAKEN
11096e: 39 ce cmp %ecx,%esi
110970: 72 a5 jb 110917 <_Heap_Free+0x27> <== NEVER TAKEN
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
110972: f6 41 04 01 testb $0x1,0x4(%ecx)
110976: 74 9f je 110917 <_Heap_Free+0x27> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
110978: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
11097c: 0f 84 a6 00 00 00 je 110a28 <_Heap_Free+0x138>
uintptr_t const size = block_size + prev_size + next_block_size;
110982: 8b 7d e4 mov -0x1c(%ebp),%edi 110985: 03 7d ec add -0x14(%ebp),%edi 110988: 03 7d f0 add -0x10(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
11098b: 8b 42 08 mov 0x8(%edx),%eax 11098e: 8b 52 0c mov 0xc(%edx),%edx
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
110991: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
110994: 89 50 0c mov %edx,0xc(%eax)
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
110997: ff 4b 38 decl 0x38(%ebx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
11099a: 89 f8 mov %edi,%eax 11099c: 83 c8 01 or $0x1,%eax 11099f: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
1109a2: 89 3c 39 mov %edi,(%ecx,%edi,1) 1109a5: eb 2a jmp 1109d1 <_Heap_Free+0xe1> 1109a7: 90 nop
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
1109a8: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
1109ac: 74 3a je 1109e8 <_Heap_Free+0xf8>
uintptr_t const size = block_size + next_block_size;
1109ae: 8b 7d e4 mov -0x1c(%ebp),%edi 1109b1: 03 7d ec add -0x14(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1109b4: 8b 42 08 mov 0x8(%edx),%eax 1109b7: 8b 52 0c mov 0xc(%edx),%edx
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
1109ba: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = prev;
1109bd: 89 51 0c mov %edx,0xc(%ecx)
next->prev = new_block;
1109c0: 89 48 0c mov %ecx,0xc(%eax)
prev->next = new_block;
1109c3: 89 4a 08 mov %ecx,0x8(%edx)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1109c6: 89 f8 mov %edi,%eax 1109c8: 83 c8 01 or $0x1,%eax 1109cb: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
1109ce: 89 3c 39 mov %edi,(%ecx,%edi,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
1109d1: ff 4b 40 decl 0x40(%ebx)
++stats->frees;
1109d4: ff 43 50 incl 0x50(%ebx)
stats->free_size += block_size;
1109d7: 8b 55 ec mov -0x14(%ebp),%edx 1109da: 01 53 30 add %edx,0x30(%ebx)
return( true );
1109dd: b0 01 mov $0x1,%al
}
1109df: 83 c4 10 add $0x10,%esp 1109e2: 5b pop %ebx 1109e3: 5e pop %esi 1109e4: 5f pop %edi 1109e5: c9 leave 1109e6: c3 ret 1109e7: 90 nop
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
1109e8: 8b 43 08 mov 0x8(%ebx),%eax
new_block->next = next;
1109eb: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = block_before;
1109ee: 89 59 0c mov %ebx,0xc(%ecx)
block_before->next = new_block;
1109f1: 89 4b 08 mov %ecx,0x8(%ebx)
next->prev = new_block;
1109f4: 89 48 0c mov %ecx,0xc(%eax)
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
1109f7: 8b 45 ec mov -0x14(%ebp),%eax 1109fa: 83 c8 01 or $0x1,%eax 1109fd: 89 41 04 mov %eax,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
110a00: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
110a04: 8b 45 ec mov -0x14(%ebp),%eax 110a07: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->free_blocks;
110a09: 8b 43 38 mov 0x38(%ebx),%eax 110a0c: 40 inc %eax 110a0d: 89 43 38 mov %eax,0x38(%ebx)
if ( stats->max_free_blocks < stats->free_blocks ) {
110a10: 3b 43 3c cmp 0x3c(%ebx),%eax
110a13: 76 bc jbe 1109d1 <_Heap_Free+0xe1>
stats->max_free_blocks = stats->free_blocks;
110a15: 89 43 3c mov %eax,0x3c(%ebx) 110a18: eb b7 jmp 1109d1 <_Heap_Free+0xe1> 110a1a: 66 90 xchg %ax,%ax
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
110a1c: c6 45 eb 00 movb $0x0,-0x15(%ebp) 110a20: e9 38 ff ff ff jmp 11095d <_Heap_Free+0x6d> 110a25: 8d 76 00 lea 0x0(%esi),%esi
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
110a28: 8b 45 ec mov -0x14(%ebp),%eax 110a2b: 03 45 f0 add -0x10(%ebp),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
110a2e: 89 c6 mov %eax,%esi 110a30: 83 ce 01 or $0x1,%esi 110a33: 89 71 04 mov %esi,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
110a36: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
110a3a: 89 02 mov %eax,(%edx) 110a3c: eb 93 jmp 1109d1 <_Heap_Free+0xe1>
0010c5c0 <_Heap_Get_first_and_last_block>:
uintptr_t page_size,
uintptr_t min_block_size,
Heap_Block **first_block_ptr,
Heap_Block **last_block_ptr
)
{
10c5c0: 55 push %ebp 10c5c1: 89 e5 mov %esp,%ebp 10c5c3: 57 push %edi 10c5c4: 56 push %esi 10c5c5: 53 push %ebx 10c5c6: 8b 4d 08 mov 0x8(%ebp),%ecx 10c5c9: 8b 7d 0c mov 0xc(%ebp),%edi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
10c5cc: 8d 34 0f lea (%edi,%ecx,1),%esi
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
10c5cf: 8d 59 08 lea 0x8(%ecx),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
10c5d2: 89 d8 mov %ebx,%eax 10c5d4: 31 d2 xor %edx,%edx 10c5d6: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
10c5d9: 85 d2 test %edx,%edx
10c5db: 74 05 je 10c5e2 <_Heap_Get_first_and_last_block+0x22>
return value - remainder + alignment;
10c5dd: 03 5d 10 add 0x10(%ebp),%ebx 10c5e0: 29 d3 sub %edx,%ebx
_Heap_Align_down( heap_area_size - overhead, page_size );
Heap_Block *const first_block = (Heap_Block *) first_block_begin;
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
10c5e2: 39 f1 cmp %esi,%ecx
10c5e4: 77 2e ja 10c614 <_Heap_Get_first_and_last_block+0x54>
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
10c5e6: 8d 73 f8 lea -0x8(%ebx),%esi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
10c5e9: 29 cb sub %ecx,%ebx
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
10c5eb: 39 df cmp %ebx,%edi
10c5ed: 76 25 jbe 10c614 <_Heap_Get_first_and_last_block+0x54>
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
uintptr_t const first_block_size =
_Heap_Align_down( heap_area_size - overhead, page_size );
10c5ef: 29 df sub %ebx,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10c5f1: 89 f8 mov %edi,%eax 10c5f3: 31 d2 xor %edx,%edx 10c5f5: f7 75 10 divl 0x10(%ebp) 10c5f8: 29 d7 sub %edx,%edi
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
10c5fa: 39 7d 14 cmp %edi,0x14(%ebp)
10c5fd: 77 15 ja 10c614 <_Heap_Get_first_and_last_block+0x54>
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
10c5ff: 8b 45 18 mov 0x18(%ebp),%eax 10c602: 89 30 mov %esi,(%eax)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10c604: 01 f7 add %esi,%edi 10c606: 8b 45 1c mov 0x1c(%ebp),%eax 10c609: 89 38 mov %edi,(%eax)
*last_block_ptr = last_block;
return true;
10c60b: b0 01 mov $0x1,%al
}
10c60d: 5b pop %ebx 10c60e: 5e pop %esi 10c60f: 5f pop %edi 10c610: c9 leave 10c611: c3 ret 10c612: 66 90 xchg %ax,%ax
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
) {
/* Invalid area or area too small */
return false;
10c614: 31 c0 xor %eax,%eax
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
10c616: 5b pop %ebx 10c617: 5e pop %esi 10c618: 5f pop %edi 10c619: c9 leave 10c61a: c3 ret
00114604 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
114604: 55 push %ebp 114605: 89 e5 mov %esp,%ebp 114607: 57 push %edi 114608: 56 push %esi 114609: 53 push %ebx 11460a: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
11460d: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
114613: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
11461a: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
114621: 8b 45 08 mov 0x8(%ebp),%eax 114624: 8b 50 08 mov 0x8(%eax),%edx
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
114627: 39 d0 cmp %edx,%eax
114629: 74 31 je 11465c <_Heap_Get_free_information+0x58>
11462b: b9 01 00 00 00 mov $0x1,%ecx 114630: 31 f6 xor %esi,%esi 114632: 31 db xor %ebx,%ebx 114634: eb 07 jmp 11463d <_Heap_Get_free_information+0x39> 114636: 66 90 xchg %ax,%ax 114638: 8b 77 04 mov 0x4(%edi),%esi 11463b: 89 c1 mov %eax,%ecx
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11463d: 8b 42 04 mov 0x4(%edx),%eax 114640: 83 e0 fe and $0xfffffffe,%eax
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
114643: 01 c3 add %eax,%ebx
if ( info->largest < the_size )
114645: 39 f0 cmp %esi,%eax
114647: 76 03 jbe 11464c <_Heap_Get_free_information+0x48>
info->largest = the_size;
114649: 89 47 04 mov %eax,0x4(%edi)
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
the_block != tail;
the_block = the_block->next)
11464c: 8b 52 08 mov 0x8(%edx),%edx 11464f: 8d 41 01 lea 0x1(%ecx),%eax
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
114652: 39 55 08 cmp %edx,0x8(%ebp)
114655: 75 e1 jne 114638 <_Heap_Get_free_information+0x34>
114657: 89 0f mov %ecx,(%edi) 114659: 89 5f 08 mov %ebx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
11465c: 5b pop %ebx 11465d: 5e pop %esi 11465e: 5f pop %edi 11465f: c9 leave 114660: c3 ret
00111468 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
111468: 55 push %ebp 111469: 89 e5 mov %esp,%ebp 11146b: 57 push %edi 11146c: 56 push %esi 11146d: 53 push %ebx 11146e: 83 ec 04 sub $0x4,%esp 111471: 8b 45 08 mov 0x8(%ebp),%eax 111474: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->first_block;
111477: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->last_block;
11147a: 8b 40 24 mov 0x24(%eax),%eax 11147d: 89 45 f0 mov %eax,-0x10(%ebp)
memset(the_info, 0, sizeof(*the_info));
111480: b9 18 00 00 00 mov $0x18,%ecx 111485: 31 c0 xor %eax,%eax 111487: 89 df mov %ebx,%edi 111489: f3 aa rep stos %al,%es:(%edi)
while ( the_block != end ) {
11148b: 3b 55 f0 cmp -0x10(%ebp),%edx
11148e: 74 38 je 1114c8 <_Heap_Get_information+0x60><== NEVER TAKEN
111490: 8b 7a 04 mov 0x4(%edx),%edi 111493: eb 18 jmp 1114ad <_Heap_Get_information+0x45> 111495: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
Heap_Information *info;
if ( _Heap_Is_prev_used(next_block) )
info = &the_info->Used;
111498: 8d 43 0c lea 0xc(%ebx),%eax
else
info = &the_info->Free;
info->number++;
11149b: ff 00 incl (%eax)
info->total += the_size;
11149d: 01 48 08 add %ecx,0x8(%eax)
if ( info->largest < the_size )
1114a0: 39 48 04 cmp %ecx,0x4(%eax)
1114a3: 73 03 jae 1114a8 <_Heap_Get_information+0x40>
info->largest = the_size;
1114a5: 89 48 04 mov %ecx,0x4(%eax)
Heap_Block *the_block = the_heap->first_block;
Heap_Block *const end = the_heap->last_block;
memset(the_info, 0, sizeof(*the_info));
while ( the_block != end ) {
1114a8: 39 75 f0 cmp %esi,-0x10(%ebp)
1114ab: 74 1b je 1114c8 <_Heap_Get_information+0x60>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1114ad: 89 f9 mov %edi,%ecx 1114af: 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);
1114b2: 8d 34 0a lea (%edx,%ecx,1),%esi 1114b5: 89 f2 mov %esi,%edx
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
1114b7: 8b 7e 04 mov 0x4(%esi),%edi
while ( the_block != end ) {
uintptr_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
Heap_Information *info;
if ( _Heap_Is_prev_used(next_block) )
1114ba: f7 c7 01 00 00 00 test $0x1,%edi
1114c0: 75 d6 jne 111498 <_Heap_Get_information+0x30>
info = &the_info->Used;
else
info = &the_info->Free;
1114c2: 89 d8 mov %ebx,%eax 1114c4: eb d5 jmp 11149b <_Heap_Get_information+0x33> 1114c6: 66 90 xchg %ax,%ax
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
1114c8: 58 pop %eax 1114c9: 5b pop %ebx 1114ca: 5e pop %esi 1114cb: 5f pop %edi 1114cc: c9 leave 1114cd: c3 ret
0011e5f8 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11e5f8: 55 push %ebp 11e5f9: 89 e5 mov %esp,%ebp 11e5fb: 57 push %edi 11e5fc: 56 push %esi 11e5fd: 53 push %ebx 11e5fe: 83 ec 2c sub $0x2c,%esp 11e601: 8b 5d 08 mov 0x8(%ebp),%ebx 11e604: 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);
11e607: 8d 4e f8 lea -0x8(%esi),%ecx 11e60a: 89 f0 mov %esi,%eax 11e60c: 31 d2 xor %edx,%edx 11e60e: 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);
11e611: 29 d1 sub %edx,%ecx
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
11e613: 8b 45 14 mov 0x14(%ebp),%eax 11e616: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11e61c: 8b 55 18 mov 0x18(%ebp),%edx 11e61f: c7 02 00 00 00 00 movl $0x0,(%edx)
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11e625: 39 4b 20 cmp %ecx,0x20(%ebx)
11e628: 77 05 ja 11e62f <_Heap_Resize_block+0x37>
11e62a: 39 4b 24 cmp %ecx,0x24(%ebx)
11e62d: 73 0d jae 11e63c <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
11e62f: b8 02 00 00 00 mov $0x2,%eax
} }
11e634: 8d 65 f4 lea -0xc(%ebp),%esp 11e637: 5b pop %ebx 11e638: 5e pop %esi 11e639: 5f pop %edi 11e63a: c9 leave 11e63b: c3 ret
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11e63c: 8b 41 04 mov 0x4(%ecx),%eax 11e63f: 83 e0 fe and $0xfffffffe,%eax
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
11e642: 8d 3c 01 lea (%ecx,%eax,1),%edi 11e645: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11e648: 89 fa mov %edi,%edx 11e64a: 29 f2 sub %esi,%edx 11e64c: 83 c2 04 add $0x4,%edx 11e64f: 89 55 e0 mov %edx,-0x20(%ebp) 11e652: 8b 57 04 mov 0x4(%edi),%edx 11e655: 83 e2 fe and $0xfffffffe,%edx 11e658: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11e65b: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11e660: 0f 94 45 df sete -0x21(%ebp)
bool next_block_is_free = _Heap_Is_free( next_block );;
_HAssert( _Heap_Is_block_in_heap( heap, next_block ) );
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
11e664: 8b 55 e0 mov -0x20(%ebp),%edx 11e667: 8b 7d 14 mov 0x14(%ebp),%edi 11e66a: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11e66c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11e670: 75 6e jne 11e6e0 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11e672: 8b 55 e0 mov -0x20(%ebp),%edx 11e675: 39 55 10 cmp %edx,0x10(%ebp)
11e678: 77 79 ja 11e6f3 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11e67a: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11e67e: 74 31 je 11e6b1 <_Heap_Resize_block+0xb9>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
11e680: 8b 79 04 mov 0x4(%ecx),%edi 11e683: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11e686: 09 c7 or %eax,%edi 11e688: 89 79 04 mov %edi,0x4(%ecx)
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11e68b: 8b 7d d4 mov -0x2c(%ebp),%edi 11e68e: 8b 7f 08 mov 0x8(%edi),%edi 11e691: 89 7d e4 mov %edi,-0x1c(%ebp) 11e694: 8b 55 d4 mov -0x2c(%ebp),%edx 11e697: 8b 7a 0c mov 0xc(%edx),%edi
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
11e69a: 8b 55 e4 mov -0x1c(%ebp),%edx 11e69d: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11e6a0: 89 7a 0c mov %edi,0xc(%edx)
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
11e6a3: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11e6a8: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11e6ab: 8b 7d d0 mov -0x30(%ebp),%edi 11e6ae: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11e6b1: ff 75 10 pushl 0x10(%ebp) 11e6b4: 56 push %esi 11e6b5: 51 push %ecx 11e6b6: 53 push %ebx 11e6b7: e8 74 e0 fe ff call 10c730 <_Heap_Block_allocate>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11e6bc: 8b 50 04 mov 0x4(%eax),%edx 11e6bf: 83 e2 fe and $0xfffffffe,%edx
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
11e6c2: 29 f0 sub %esi,%eax 11e6c4: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11e6c8: 8b 55 18 mov 0x18(%ebp),%edx 11e6cb: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11e6cd: ff 43 54 incl 0x54(%ebx) 11e6d0: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11e6d3: 31 c0 xor %eax,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11e6d5: 8d 65 f4 lea -0xc(%ebp),%esp 11e6d8: 5b pop %ebx 11e6d9: 5e pop %esi 11e6da: 5f pop %edi 11e6db: c9 leave 11e6dc: c3 ret 11e6dd: 8d 76 00 lea 0x0(%esi),%esi
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
11e6e0: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11e6e3: 8b 7d d0 mov -0x30(%ebp),%edi 11e6e6: 01 fa add %edi,%edx 11e6e8: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11e6eb: 8b 55 e0 mov -0x20(%ebp),%edx 11e6ee: 39 55 10 cmp %edx,0x10(%ebp)
11e6f1: 76 87 jbe 11e67a <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11e6f3: b8 01 00 00 00 mov $0x1,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11e6f8: 8d 65 f4 lea -0xc(%ebp),%esp 11e6fb: 5b pop %ebx 11e6fc: 5e pop %esi 11e6fd: 5f pop %edi 11e6fe: c9 leave 11e6ff: c3 ret
0011e700 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11e700: 55 push %ebp 11e701: 89 e5 mov %esp,%ebp 11e703: 56 push %esi 11e704: 53 push %ebx 11e705: 8b 5d 08 mov 0x8(%ebp),%ebx 11e708: 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);
11e70b: 8d 4e f8 lea -0x8(%esi),%ecx 11e70e: 89 f0 mov %esi,%eax 11e710: 31 d2 xor %edx,%edx 11e712: 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);
11e715: 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
11e717: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11e71a: 39 c1 cmp %eax,%ecx
11e71c: 72 07 jb 11e725 <_Heap_Size_of_alloc_area+0x25>
11e71e: 8b 53 24 mov 0x24(%ebx),%edx 11e721: 39 d1 cmp %edx,%ecx
11e723: 76 07 jbe 11e72c <_Heap_Size_of_alloc_area+0x2c><== ALWAYS TAKEN
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11e725: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11e727: 5b pop %ebx 11e728: 5e pop %esi 11e729: c9 leave 11e72a: c3 ret 11e72b: 90 nop
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11e72c: 8b 59 04 mov 0x4(%ecx),%ebx 11e72f: 83 e3 fe and $0xfffffffe,%ebx
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11e732: 01 d9 add %ebx,%ecx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11e734: 39 c8 cmp %ecx,%eax
11e736: 77 ed ja 11e725 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11e738: 39 ca cmp %ecx,%edx
11e73a: 72 e9 jb 11e725 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11e73c: f6 41 04 01 testb $0x1,0x4(%ecx)
11e740: 74 e3 je 11e725 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11e742: 29 f1 sub %esi,%ecx 11e744: 8d 51 04 lea 0x4(%ecx),%edx 11e747: 8b 45 10 mov 0x10(%ebp),%eax 11e74a: 89 10 mov %edx,(%eax)
return true;
11e74c: b0 01 mov $0x1,%al
}
11e74e: 5b pop %ebx 11e74f: 5e pop %esi 11e750: c9 leave 11e751: c3 ret
0010d264 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10d264: 55 push %ebp 10d265: 89 e5 mov %esp,%ebp 10d267: 57 push %edi 10d268: 56 push %esi 10d269: 53 push %ebx 10d26a: 83 ec 4c sub $0x4c,%esp 10d26d: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10d270: 8b 43 10 mov 0x10(%ebx),%eax 10d273: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10d276: 8b 53 14 mov 0x14(%ebx),%edx 10d279: 89 55 d0 mov %edx,-0x30(%ebp)
Heap_Block *const first_block = heap->first_block;
10d27c: 8b 43 20 mov 0x20(%ebx),%eax 10d27f: 89 45 dc mov %eax,-0x24(%ebp)
Heap_Block *const last_block = heap->last_block;
10d282: 8b 53 24 mov 0x24(%ebx),%edx 10d285: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10d288: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10d28c: 74 1a je 10d2a8 <_Heap_Walk+0x44>
10d28e: c7 45 d8 1c d2 10 00 movl $0x10d21c,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d295: 83 3d 20 87 12 00 03 cmpl $0x3,0x128720
10d29c: 74 1a je 10d2b8 <_Heap_Walk+0x54> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10d29e: b0 01 mov $0x1,%al
}
10d2a0: 8d 65 f4 lea -0xc(%ebp),%esp 10d2a3: 5b pop %ebx 10d2a4: 5e pop %esi 10d2a5: 5f pop %edi 10d2a6: c9 leave 10d2a7: c3 ret
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10d2a8: c7 45 d8 14 d2 10 00 movl $0x10d214,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d2af: 83 3d 20 87 12 00 03 cmpl $0x3,0x128720
10d2b6: 75 e6 jne 10d29e <_Heap_Walk+0x3a>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
10d2b8: 52 push %edx 10d2b9: ff 73 0c pushl 0xc(%ebx) 10d2bc: ff 73 08 pushl 0x8(%ebx) 10d2bf: ff 75 cc pushl -0x34(%ebp) 10d2c2: ff 75 dc pushl -0x24(%ebp) 10d2c5: ff 73 1c pushl 0x1c(%ebx) 10d2c8: ff 73 18 pushl 0x18(%ebx) 10d2cb: ff 75 d0 pushl -0x30(%ebp) 10d2ce: ff 75 e0 pushl -0x20(%ebp) 10d2d1: 68 74 16 12 00 push $0x121674 10d2d6: 6a 00 push $0x0 10d2d8: ff 75 0c pushl 0xc(%ebp) 10d2db: ff 55 d8 call *-0x28(%ebp)
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
10d2de: 83 c4 30 add $0x30,%esp 10d2e1: 8b 45 e0 mov -0x20(%ebp),%eax 10d2e4: 85 c0 test %eax,%eax
10d2e6: 74 70 je 10d358 <_Heap_Walk+0xf4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10d2e8: f6 45 e0 03 testb $0x3,-0x20(%ebp)
10d2ec: 75 72 jne 10d360 <_Heap_Walk+0xfc>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d2ee: 8b 45 d0 mov -0x30(%ebp),%eax 10d2f1: 31 d2 xor %edx,%edx 10d2f3: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10d2f6: 85 d2 test %edx,%edx
10d2f8: 75 72 jne 10d36c <_Heap_Walk+0x108>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10d2fa: 8b 45 dc mov -0x24(%ebp),%eax 10d2fd: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d300: 31 d2 xor %edx,%edx 10d302: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10d305: 85 d2 test %edx,%edx
10d307: 75 6f jne 10d378 <_Heap_Walk+0x114>
block = next_block;
} while ( block != first_block );
return true;
}
10d309: 8b 45 dc mov -0x24(%ebp),%eax 10d30c: 8b 40 04 mov 0x4(%eax),%eax 10d30f: 89 45 e4 mov %eax,-0x1c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10d312: a8 01 test $0x1,%al
10d314: 0f 84 ce 02 00 00 je 10d5e8 <_Heap_Walk+0x384>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10d31a: 8b 55 cc mov -0x34(%ebp),%edx 10d31d: 8b 42 04 mov 0x4(%edx),%eax 10d320: 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);
10d323: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10d325: f6 40 04 01 testb $0x1,0x4(%eax)
10d329: 74 25 je 10d350 <_Heap_Walk+0xec>
);
return false;
}
if (
10d32b: 39 45 dc cmp %eax,-0x24(%ebp)
10d32e: 74 54 je 10d384 <_Heap_Walk+0x120> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10d330: 51 push %ecx <== NOT EXECUTED 10d331: 68 90 17 12 00 push $0x121790 <== NOT EXECUTED 10d336: 66 90 xchg %ax,%ax <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d338: 6a 01 push $0x1 10d33a: ff 75 0c pushl 0xc(%ebp) 10d33d: ff 55 d8 call *-0x28(%ebp) 10d340: 83 c4 10 add $0x10,%esp
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
10d343: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d345: 8d 65 f4 lea -0xc(%ebp),%esp 10d348: 5b pop %ebx 10d349: 5e pop %esi 10d34a: 5f pop %edi 10d34b: c9 leave 10d34c: c3 ret 10d34d: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10d350: 53 push %ebx 10d351: 68 2a 16 12 00 push $0x12162a 10d356: eb e0 jmp 10d338 <_Heap_Walk+0xd4>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
10d358: 57 push %edi 10d359: 68 f9 15 12 00 push $0x1215f9 10d35e: eb d8 jmp 10d338 <_Heap_Walk+0xd4>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10d360: ff 75 e0 pushl -0x20(%ebp) 10d363: 68 0c 16 12 00 push $0x12160c 10d368: eb ce jmp 10d338 <_Heap_Walk+0xd4> 10d36a: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10d36c: ff 75 d0 pushl -0x30(%ebp) 10d36f: 68 08 17 12 00 push $0x121708 10d374: eb c2 jmp 10d338 <_Heap_Walk+0xd4> 10d376: 66 90 xchg %ax,%ax
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10d378: ff 75 dc pushl -0x24(%ebp) 10d37b: 68 2c 17 12 00 push $0x12172c 10d380: eb b6 jmp 10d338 <_Heap_Walk+0xd4> 10d382: 66 90 xchg %ax,%ax
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10d384: 8b 43 10 mov 0x10(%ebx),%eax 10d387: 89 45 c8 mov %eax,-0x38(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10d38a: 8b 73 08 mov 0x8(%ebx),%esi
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10d38d: 39 f3 cmp %esi,%ebx
10d38f: 74 65 je 10d3f6 <_Heap_Walk+0x192>
block = next_block;
} while ( block != first_block );
return true;
}
10d391: 8b 43 20 mov 0x20(%ebx),%eax 10d394: 89 45 d4 mov %eax,-0x2c(%ebp)
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10d397: 39 f0 cmp %esi,%eax
10d399: 0f 87 55 02 00 00 ja 10d5f4 <_Heap_Walk+0x390> <== NEVER TAKEN
10d39f: 8b 7b 24 mov 0x24(%ebx),%edi 10d3a2: 39 f7 cmp %esi,%edi
10d3a4: 0f 82 4a 02 00 00 jb 10d5f4 <_Heap_Walk+0x390> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10d3aa: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3ad: 31 d2 xor %edx,%edx 10d3af: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d3b2: 85 d2 test %edx,%edx
10d3b4: 0f 85 71 02 00 00 jne 10d62b <_Heap_Walk+0x3c7> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10d3ba: 8b 46 04 mov 0x4(%esi),%eax 10d3bd: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d3c0: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10d3c5: 0f 85 6d 02 00 00 jne 10d638 <_Heap_Walk+0x3d4> <== NEVER TAKEN
10d3cb: 89 da mov %ebx,%edx 10d3cd: 8d 76 00 lea 0x0(%esi),%esi
);
return false;
}
if ( free_block->prev != prev_block ) {
10d3d0: 8b 46 0c mov 0xc(%esi),%eax 10d3d3: 39 d0 cmp %edx,%eax
10d3d5: 0f 85 6a 02 00 00 jne 10d645 <_Heap_Walk+0x3e1>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10d3db: 8b 4e 08 mov 0x8(%esi),%ecx
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10d3de: 39 cb cmp %ecx,%ebx
10d3e0: 74 1a je 10d3fc <_Heap_Walk+0x198>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10d3e2: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10d3e5: 0f 86 7d 01 00 00 jbe 10d568 <_Heap_Walk+0x304>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10d3eb: 51 push %ecx 10d3ec: 68 c0 17 12 00 push $0x1217c0 10d3f1: e9 42 ff ff ff jmp 10d338 <_Heap_Walk+0xd4>
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10d3f6: 8b 53 20 mov 0x20(%ebx),%edx 10d3f9: 89 55 d4 mov %edx,-0x2c(%ebp)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d3fc: 8b 7d dc mov -0x24(%ebp),%edi 10d3ff: 8b 45 d4 mov -0x2c(%ebp),%eax 10d402: 66 90 xchg %ax,%ax
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10d404: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d407: 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);
10d40a: 8d 34 39 lea (%ecx,%edi,1),%esi
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10d40d: 39 f0 cmp %esi,%eax
10d40f: 76 23 jbe 10d434 <_Heap_Walk+0x1d0> <== ALWAYS TAKEN
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
10d411: 83 ec 0c sub $0xc,%esp 10d414: 56 push %esi 10d415: 57 push %edi 10d416: 68 44 18 12 00 push $0x121844 10d41b: 90 nop 10d41c: 6a 01 push $0x1 10d41e: ff 75 0c pushl 0xc(%ebp) 10d421: ff 55 d8 call *-0x28(%ebp)
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
10d424: 83 c4 20 add $0x20,%esp 10d427: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d429: 8d 65 f4 lea -0xc(%ebp),%esp 10d42c: 5b pop %ebx 10d42d: 5e pop %esi 10d42e: 5f pop %edi 10d42f: c9 leave 10d430: c3 ret 10d431: 8d 76 00 lea 0x0(%esi),%esi 10d434: 39 73 24 cmp %esi,0x24(%ebx)
10d437: 72 d8 jb 10d411 <_Heap_Walk+0x1ad>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
10d439: 3b 7d cc cmp -0x34(%ebp),%edi 10d43c: 0f 95 45 d4 setne -0x2c(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d440: 89 c8 mov %ecx,%eax 10d442: 31 d2 xor %edx,%edx 10d444: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10d447: 85 d2 test %edx,%edx
10d449: 74 0a je 10d455 <_Heap_Walk+0x1f1>
10d44b: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d44f: 0f 85 a6 01 00 00 jne 10d5fb <_Heap_Walk+0x397>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10d455: 39 4d d0 cmp %ecx,-0x30(%ebp)
10d458: 76 0a jbe 10d464 <_Heap_Walk+0x200>
10d45a: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d45e: 0f 85 a6 01 00 00 jne 10d60a <_Heap_Walk+0x3a6> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10d464: 39 f7 cmp %esi,%edi
10d466: 72 0a jb 10d472 <_Heap_Walk+0x20e>
10d468: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d46c: 0f 85 aa 01 00 00 jne 10d61c <_Heap_Walk+0x3b8>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10d472: 8b 55 e4 mov -0x1c(%ebp),%edx 10d475: 83 e2 01 and $0x1,%edx
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10d478: f6 46 04 01 testb $0x1,0x4(%esi)
10d47c: 74 4e je 10d4cc <_Heap_Walk+0x268>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10d47e: 85 d2 test %edx,%edx
10d480: 74 2e je 10d4b0 <_Heap_Walk+0x24c>
(*printer)(
10d482: 83 ec 0c sub $0xc,%esp 10d485: 51 push %ecx 10d486: 57 push %edi 10d487: 68 5b 16 12 00 push $0x12165b 10d48c: 6a 00 push $0x0 10d48e: ff 75 0c pushl 0xc(%ebp) 10d491: ff 55 d8 call *-0x28(%ebp) 10d494: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10d497: 39 75 dc cmp %esi,-0x24(%ebp)
10d49a: 0f 84 fe fd ff ff je 10d29e <_Heap_Walk+0x3a>
10d4a0: 8b 56 04 mov 0x4(%esi),%edx 10d4a3: 89 55 e4 mov %edx,-0x1c(%ebp) 10d4a6: 8b 43 20 mov 0x20(%ebx),%eax 10d4a9: 89 f7 mov %esi,%edi 10d4ab: e9 54 ff ff ff jmp 10d404 <_Heap_Walk+0x1a0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10d4b0: 83 ec 08 sub $0x8,%esp 10d4b3: ff 37 pushl (%edi) 10d4b5: 51 push %ecx 10d4b6: 57 push %edi 10d4b7: 68 a8 19 12 00 push $0x1219a8 10d4bc: 6a 00 push $0x0 10d4be: ff 75 0c pushl 0xc(%ebp) 10d4c1: ff 55 d8 call *-0x28(%ebp) 10d4c4: 83 c4 20 add $0x20,%esp 10d4c7: eb ce jmp 10d497 <_Heap_Walk+0x233> 10d4c9: 8d 76 00 lea 0x0(%esi),%esi
block = next_block;
} while ( block != first_block );
return true;
}
10d4cc: 8b 43 08 mov 0x8(%ebx),%eax 10d4cf: 89 45 b4 mov %eax,-0x4c(%ebp)
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
10d4d2: 8b 47 08 mov 0x8(%edi),%eax 10d4d5: 89 45 e4 mov %eax,-0x1c(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10d4d8: 39 43 0c cmp %eax,0xc(%ebx)
10d4db: 0f 84 cb 00 00 00 je 10d5ac <_Heap_Walk+0x348>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10d4e1: 39 c3 cmp %eax,%ebx
10d4e3: 0f 84 db 00 00 00 je 10d5c4 <_Heap_Walk+0x360>
10d4e9: c7 45 c8 e9 14 12 00 movl $0x1214e9,-0x38(%ebp)
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
10d4f0: 8b 47 0c mov 0xc(%edi),%eax 10d4f3: 89 45 d4 mov %eax,-0x2c(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10d4f6: 39 45 b4 cmp %eax,-0x4c(%ebp)
10d4f9: 0f 84 b9 00 00 00 je 10d5b8 <_Heap_Walk+0x354>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d4ff: 39 c3 cmp %eax,%ebx
10d501: 0f 84 c9 00 00 00 je 10d5d0 <_Heap_Walk+0x36c>
10d507: b8 e9 14 12 00 mov $0x1214e9,%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)(
10d50c: 83 ec 0c sub $0xc,%esp 10d50f: ff 75 c8 pushl -0x38(%ebp) 10d512: ff 75 e4 pushl -0x1c(%ebp) 10d515: 50 push %eax 10d516: ff 75 d4 pushl -0x2c(%ebp) 10d519: 51 push %ecx 10d51a: 57 push %edi 10d51b: 68 04 19 12 00 push $0x121904 10d520: 6a 00 push $0x0 10d522: ff 75 0c pushl 0xc(%ebp) 10d525: 89 55 c4 mov %edx,-0x3c(%ebp) 10d528: 89 4d c0 mov %ecx,-0x40(%ebp) 10d52b: ff 55 d8 call *-0x28(%ebp)
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
10d52e: 8b 06 mov (%esi),%eax 10d530: 83 c4 30 add $0x30,%esp 10d533: 8b 4d c0 mov -0x40(%ebp),%ecx 10d536: 39 c1 cmp %eax,%ecx 10d538: 8b 55 c4 mov -0x3c(%ebp),%edx
10d53b: 75 5f jne 10d59c <_Heap_Walk+0x338>
);
return false;
}
if ( !prev_used ) {
10d53d: 85 d2 test %edx,%edx
10d53f: 0f 84 97 00 00 00 je 10d5dc <_Heap_Walk+0x378>
block = next_block;
} while ( block != first_block );
return true;
}
10d545: 8b 43 08 mov 0x8(%ebx),%eax
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
10d548: 39 c3 cmp %eax,%ebx
10d54a: 74 0f je 10d55b <_Heap_Walk+0x2f7> <== NEVER TAKEN
if ( free_block == block ) {
10d54c: 39 c7 cmp %eax,%edi
10d54e: 0f 84 43 ff ff ff je 10d497 <_Heap_Walk+0x233>
return true;
}
free_block = free_block->next;
10d554: 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 ) {
10d557: 39 c3 cmp %eax,%ebx
10d559: 75 f1 jne 10d54c <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d55b: 57 push %edi 10d55c: 68 d0 19 12 00 push $0x1219d0 10d561: e9 d2 fd ff ff jmp 10d338 <_Heap_Walk+0xd4> 10d566: 66 90 xchg %ax,%ax
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10d568: 39 f9 cmp %edi,%ecx
10d56a: 0f 87 7b fe ff ff ja 10d3eb <_Heap_Walk+0x187> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10d570: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d573: 31 d2 xor %edx,%edx 10d575: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d578: 85 d2 test %edx,%edx
10d57a: 0f 85 ad 00 00 00 jne 10d62d <_Heap_Walk+0x3c9>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10d580: 8b 41 04 mov 0x4(%ecx),%eax 10d583: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d586: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10d58b: 0f 85 a9 00 00 00 jne 10d63a <_Heap_Walk+0x3d6>
10d591: 89 f2 mov %esi,%edx 10d593: 89 ce mov %ecx,%esi 10d595: e9 36 fe ff ff jmp 10d3d0 <_Heap_Walk+0x16c> 10d59a: 66 90 xchg %ax,%ax
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10d59c: 52 push %edx 10d59d: 56 push %esi 10d59e: 50 push %eax 10d59f: 51 push %ecx 10d5a0: 57 push %edi 10d5a1: 68 3c 19 12 00 push $0x12193c 10d5a6: e9 71 fe ff ff jmp 10d41c <_Heap_Walk+0x1b8> 10d5ab: 90 nop
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10d5ac: c7 45 c8 c6 15 12 00 movl $0x1215c6,-0x38(%ebp) 10d5b3: e9 38 ff ff ff jmp 10d4f0 <_Heap_Walk+0x28c> 10d5b8: b8 df 15 12 00 mov $0x1215df,%eax 10d5bd: e9 4a ff ff ff jmp 10d50c <_Heap_Walk+0x2a8> 10d5c2: 66 90 xchg %ax,%ax
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10d5c4: c7 45 c8 d5 15 12 00 movl $0x1215d5,-0x38(%ebp) 10d5cb: e9 20 ff ff ff jmp 10d4f0 <_Heap_Walk+0x28c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d5d0: b8 ef 15 12 00 mov $0x1215ef,%eax 10d5d5: e9 32 ff ff ff jmp 10d50c <_Heap_Walk+0x2a8> 10d5da: 66 90 xchg %ax,%ax
return false;
}
if ( !prev_used ) {
(*printer)(
10d5dc: 57 push %edi 10d5dd: 68 78 19 12 00 push $0x121978 10d5e2: e9 51 fd ff ff jmp 10d338 <_Heap_Walk+0xd4> 10d5e7: 90 nop
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10d5e8: 56 push %esi 10d5e9: 68 60 17 12 00 push $0x121760 10d5ee: e9 45 fd ff ff jmp 10d338 <_Heap_Walk+0xd4> 10d5f3: 90 nop
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10d5f4: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10d5f6: e9 f0 fd ff ff jmp 10d3eb <_Heap_Walk+0x187> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10d5fb: 83 ec 0c sub $0xc,%esp 10d5fe: 51 push %ecx 10d5ff: 57 push %edi 10d600: 68 74 18 12 00 push $0x121874 10d605: e9 12 fe ff ff jmp 10d41c <_Heap_Walk+0x1b8>
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
10d60a: 83 ec 08 sub $0x8,%esp 10d60d: ff 75 d0 pushl -0x30(%ebp) 10d610: 51 push %ecx 10d611: 57 push %edi 10d612: 68 a4 18 12 00 push $0x1218a4 10d617: e9 00 fe ff ff jmp 10d41c <_Heap_Walk+0x1b8>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
10d61c: 83 ec 0c sub $0xc,%esp 10d61f: 56 push %esi 10d620: 57 push %edi 10d621: 68 d0 18 12 00 push $0x1218d0 10d626: e9 f1 fd ff ff jmp 10d41c <_Heap_Walk+0x1b8>
);
return false;
}
if (
10d62b: 89 f1 mov %esi,%ecx <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10d62d: 51 push %ecx 10d62e: 68 e0 17 12 00 push $0x1217e0 10d633: e9 00 fd ff ff jmp 10d338 <_Heap_Walk+0xd4>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d638: 89 f1 mov %esi,%ecx <== NOT EXECUTED
(*printer)(
10d63a: 51 push %ecx 10d63b: 68 3f 16 12 00 push $0x12163f 10d640: e9 f3 fc ff ff jmp 10d338 <_Heap_Walk+0xd4>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
10d645: 83 ec 0c sub $0xc,%esp 10d648: 50 push %eax 10d649: 56 push %esi 10d64a: 68 10 18 12 00 push $0x121810 10d64f: e9 c8 fd ff ff jmp 10d41c <_Heap_Walk+0x1b8>
0010bda8 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10bda8: 55 push %ebp 10bda9: 89 e5 mov %esp,%ebp 10bdab: 53 push %ebx 10bdac: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bdaf: 8b 0d 80 68 12 00 mov 0x126880,%ecx 10bdb5: 85 c9 test %ecx,%ecx
10bdb7: 74 1a je 10bdd3 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10bdb9: 31 db xor %ebx,%ebx 10bdbb: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10bdbc: 52 push %edx 10bdbd: 6a 00 push $0x0 10bdbf: 6a 00 push $0x0 10bdc1: 53 push %ebx 10bdc2: e8 31 47 00 00 call 1104f8 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bdc7: 43 inc %ebx 10bdc8: 83 c4 10 add $0x10,%esp 10bdcb: 39 1d 80 68 12 00 cmp %ebx,0x126880
10bdd1: 77 e9 ja 10bdbc <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10bdd3: 8b 5d fc mov -0x4(%ebp),%ebx 10bdd6: c9 leave 10bdd7: c3 ret
0010bd10 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
10bd10: 55 push %ebp 10bd11: 89 e5 mov %esp,%ebp 10bd13: 57 push %edi 10bd14: 56 push %esi 10bd15: 53 push %ebx 10bd16: 83 ec 1c sub $0x1c,%esp
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
10bd19: 8b 1d 58 22 12 00 mov 0x122258,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10bd1f: a1 54 22 12 00 mov 0x122254,%eax 10bd24: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10bd27: 8b 35 50 22 12 00 mov 0x122250,%esi
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
10bd2d: 39 f0 cmp %esi,%eax
10bd2f: 73 5f jae 10bd90 <_IO_Manager_initialization+0x80>
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
10bd31: 8d 0c 76 lea (%esi,%esi,2),%ecx 10bd34: c1 e1 03 shl $0x3,%ecx 10bd37: 83 ec 0c sub $0xc,%esp 10bd3a: 51 push %ecx 10bd3b: 89 4d dc mov %ecx,-0x24(%ebp) 10bd3e: e8 f9 2a 00 00 call 10e83c <_Workspace_Allocate_or_fatal_error> 10bd43: 89 c2 mov %eax,%edx
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
10bd45: a3 84 68 12 00 mov %eax,0x126884
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10bd4a: 89 35 80 68 12 00 mov %esi,0x126880
memset(
10bd50: 31 c0 xor %eax,%eax 10bd52: 8b 4d dc mov -0x24(%ebp),%ecx 10bd55: 89 d7 mov %edx,%edi 10bd57: f3 aa rep stos %al,%es:(%edi)
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10bd59: 83 c4 10 add $0x10,%esp 10bd5c: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd5f: 85 c0 test %eax,%eax
10bd61: 74 25 je 10bd88 <_IO_Manager_initialization+0x78><== NEVER TAKEN
10bd63: a1 84 68 12 00 mov 0x126884,%eax 10bd68: 89 45 e0 mov %eax,-0x20(%ebp) 10bd6b: 31 c0 xor %eax,%eax 10bd6d: 31 d2 xor %edx,%edx 10bd6f: 90 nop
_IO_Driver_address_table[index] = driver_table[index];
10bd70: 8b 7d e0 mov -0x20(%ebp),%edi 10bd73: 01 c7 add %eax,%edi 10bd75: 8d 34 03 lea (%ebx,%eax,1),%esi 10bd78: b9 06 00 00 00 mov $0x6,%ecx 10bd7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10bd7f: 42 inc %edx 10bd80: 83 c0 18 add $0x18,%eax 10bd83: 39 55 e4 cmp %edx,-0x1c(%ebp)
10bd86: 77 e8 ja 10bd70 <_IO_Manager_initialization+0x60>
_IO_Driver_address_table[index] = driver_table[index];
}
10bd88: 8d 65 f4 lea -0xc(%ebp),%esp 10bd8b: 5b pop %ebx 10bd8c: 5e pop %esi 10bd8d: 5f pop %edi 10bd8e: c9 leave 10bd8f: c3 ret
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
10bd90: 89 1d 84 68 12 00 mov %ebx,0x126884
_IO_Number_of_drivers = number_of_drivers;
10bd96: 8b 45 e4 mov -0x1c(%ebp),%eax 10bd99: a3 80 68 12 00 mov %eax,0x126880
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10bd9e: 8d 65 f4 lea -0xc(%ebp),%esp 10bda1: 5b pop %ebx 10bda2: 5e pop %esi 10bda3: 5f pop %edi 10bda4: c9 leave 10bda5: c3 ret
0010c824 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10c824: 55 push %ebp 10c825: 89 e5 mov %esp,%ebp 10c827: 53 push %ebx 10c828: 83 ec 08 sub $0x8,%esp 10c82b: 8b 45 08 mov 0x8(%ebp),%eax 10c82e: 8b 55 0c mov 0xc(%ebp),%edx 10c831: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10c834: a3 90 65 12 00 mov %eax,0x126590
_Internal_errors_What_happened.is_internal = is_internal;
10c839: 88 15 94 65 12 00 mov %dl,0x126594
_Internal_errors_What_happened.the_error = the_error;
10c83f: 89 1d 98 65 12 00 mov %ebx,0x126598
_User_extensions_Fatal( the_source, is_internal, the_error );
10c845: 53 push %ebx 10c846: 0f b6 d2 movzbl %dl,%edx 10c849: 52 push %edx 10c84a: 50 push %eax 10c84b: e8 ec 1b 00 00 call 10e43c <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10c850: c7 05 80 66 12 00 05 movl $0x5,0x126680 <== NOT EXECUTED
10c857: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10c85a: fa cli <== NOT EXECUTED 10c85b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c85d: f4 hlt <== NOT EXECUTED 10c85e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c861: eb fe jmp 10c861 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
00110a40 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
110a40: 55 push %ebp 110a41: 89 e5 mov %esp,%ebp 110a43: 8b 45 08 mov 0x8(%ebp),%eax 110a46: 48 dec %eax 110a47: 83 f8 02 cmp $0x2,%eax
110a4a: 77 0c ja 110a58 <_Objects_API_maximum_class+0x18>
110a4c: 8b 04 85 b0 0a 12 00 mov 0x120ab0(,%eax,4),%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
110a53: c9 leave 110a54: c3 ret 110a55: 8d 76 00 lea 0x0(%esi),%esi
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
110a58: 31 c0 xor %eax,%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
110a5a: c9 leave 110a5b: c3 ret
0010c8b4 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10c8b4: 55 push %ebp 10c8b5: 89 e5 mov %esp,%ebp 10c8b7: 56 push %esi 10c8b8: 53 push %ebx 10c8b9: 8b 5d 08 mov 0x8(%ebp),%ebx
* If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 )
10c8bc: 8b 43 18 mov 0x18(%ebx),%eax 10c8bf: 85 c0 test %eax,%eax
10c8c1: 75 0d jne 10c8d0 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
return NULL;
10c8c3: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
);
}
#endif
return the_object;
}
10c8c5: 89 c8 mov %ecx,%eax 10c8c7: 8d 65 f8 lea -0x8(%ebp),%esp 10c8ca: 5b pop %ebx 10c8cb: 5e pop %esi 10c8cc: c9 leave 10c8cd: c3 ret 10c8ce: 66 90 xchg %ax,%ax
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10c8d0: 8d 73 20 lea 0x20(%ebx),%esi 10c8d3: 83 ec 0c sub $0xc,%esp 10c8d6: 56 push %esi 10c8d7: e8 f0 f6 ff ff call 10bfcc <_Chain_Get> 10c8dc: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10c8de: 83 c4 10 add $0x10,%esp 10c8e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10c8e5: 74 de je 10c8c5 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10c8e7: 85 c0 test %eax,%eax
10c8e9: 74 29 je 10c914 <_Objects_Allocate+0x60>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10c8eb: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10c8ef: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10c8f3: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10c8f5: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10c8f9: 31 d2 xor %edx,%edx 10c8fb: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10c8fd: c1 e0 02 shl $0x2,%eax 10c900: 03 43 30 add 0x30(%ebx),%eax 10c903: ff 08 decl (%eax)
information->inactive--;
10c905: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10c909: 89 c8 mov %ecx,%eax 10c90b: 8d 65 f8 lea -0x8(%ebp),%esp 10c90e: 5b pop %ebx 10c90f: 5e pop %esi 10c910: c9 leave 10c911: c3 ret 10c912: 66 90 xchg %ax,%ax
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
10c914: 83 ec 0c sub $0xc,%esp 10c917: 53 push %ebx 10c918: e8 3b 00 00 00 call 10c958 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10c91d: 89 34 24 mov %esi,(%esp) 10c920: e8 a7 f6 ff ff call 10bfcc <_Chain_Get> 10c925: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10c927: 83 c4 10 add $0x10,%esp 10c92a: 85 c0 test %eax,%eax
10c92c: 74 97 je 10c8c5 <_Objects_Allocate+0x11>
10c92e: eb bb jmp 10c8eb <_Objects_Allocate+0x37>
0010c958 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10c958: 55 push %ebp 10c959: 89 e5 mov %esp,%ebp 10c95b: 57 push %edi 10c95c: 56 push %esi 10c95d: 53 push %ebx 10c95e: 83 ec 4c sub $0x4c,%esp 10c961: 8b 5d 08 mov 0x8(%ebp),%ebx
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
10c964: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10c968: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10c96b: 8b 4b 34 mov 0x34(%ebx),%ecx 10c96e: 85 c9 test %ecx,%ecx
10c970: 0f 84 66 02 00 00 je 10cbdc <_Objects_Extend_information+0x284>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10c976: 8b 73 10 mov 0x10(%ebx),%esi 10c979: 66 89 75 d0 mov %si,-0x30(%ebp) 10c97d: 8b 7b 14 mov 0x14(%ebx),%edi 10c980: 89 f0 mov %esi,%eax 10c982: 31 d2 xor %edx,%edx 10c984: 66 f7 f7 div %di 10c987: 0f b7 f0 movzwl %ax,%esi
for ( ; block < block_count; block++ ) {
10c98a: 85 f6 test %esi,%esi
10c98c: 0f 84 63 02 00 00 je 10cbf5 <_Objects_Extend_information+0x29d><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10c992: 8b 01 mov (%ecx),%eax 10c994: 85 c0 test %eax,%eax
10c996: 0f 84 6b 02 00 00 je 10cc07 <_Objects_Extend_information+0x2af><== NEVER TAKEN
10c99c: 0f b7 ff movzwl %di,%edi
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
10c99f: 8b 55 cc mov -0x34(%ebp),%edx 10c9a2: 89 55 d4 mov %edx,-0x2c(%ebp)
index_base = minimum_index; block = 0;
10c9a5: 31 d2 xor %edx,%edx 10c9a7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c9aa: eb 0a jmp 10c9b6 <_Objects_Extend_information+0x5e>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
10c9ac: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4)
10c9b0: 0f 84 c6 01 00 00 je 10cb7c <_Objects_Extend_information+0x224>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10c9b6: 01 f8 add %edi,%eax
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10c9b8: 42 inc %edx 10c9b9: 39 d6 cmp %edx,%esi
10c9bb: 77 ef ja 10c9ac <_Objects_Extend_information+0x54>
10c9bd: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10c9c0: b1 01 mov $0x1,%cl
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10c9c2: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10c9c6: 01 f8 add %edi,%eax 10c9c8: 89 45 d0 mov %eax,-0x30(%ebp)
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
10c9cb: 3d ff ff 00 00 cmp $0xffff,%eax
10c9d0: 0f 87 9e 01 00 00 ja 10cb74 <_Objects_Extend_information+0x21c>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
10c9d6: 0f af 7b 18 imul 0x18(%ebx),%edi
if ( information->auto_extend ) {
10c9da: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10c9de: 0f 84 a4 01 00 00 je 10cb88 <_Objects_Extend_information+0x230>
new_object_block = _Workspace_Allocate( block_size );
10c9e4: 83 ec 0c sub $0xc,%esp 10c9e7: 57 push %edi 10c9e8: 89 55 b8 mov %edx,-0x48(%ebp) 10c9eb: 88 4d b4 mov %cl,-0x4c(%ebp) 10c9ee: e8 15 1e 00 00 call 10e808 <_Workspace_Allocate> 10c9f3: 89 45 c8 mov %eax,-0x38(%ebp)
if ( !new_object_block )
10c9f6: 83 c4 10 add $0x10,%esp 10c9f9: 85 c0 test %eax,%eax 10c9fb: 8b 55 b8 mov -0x48(%ebp),%edx 10c9fe: 8a 4d b4 mov -0x4c(%ebp),%cl
10ca01: 0f 84 6d 01 00 00 je 10cb74 <_Objects_Extend_information+0x21c>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10ca07: 84 c9 test %cl,%cl
10ca09: 0f 84 ea 00 00 00 je 10caf9 <_Objects_Extend_information+0x1a1>
*/
/*
* Up the block count and maximum
*/
block_count++;
10ca0f: 8d 7e 01 lea 0x1(%esi),%edi
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
10ca12: 83 ec 0c sub $0xc,%esp
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10ca15: 8d 04 7f lea (%edi,%edi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10ca18: 03 45 d0 add -0x30(%ebp),%eax
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10ca1b: 03 45 cc add -0x34(%ebp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10ca1e: c1 e0 02 shl $0x2,%eax
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
10ca21: 50 push %eax 10ca22: 89 55 b8 mov %edx,-0x48(%ebp) 10ca25: e8 de 1d 00 00 call 10e808 <_Workspace_Allocate> 10ca2a: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !object_blocks ) {
10ca2d: 83 c4 10 add $0x10,%esp 10ca30: 85 c0 test %eax,%eax 10ca32: 8b 55 b8 mov -0x48(%ebp),%edx
10ca35: 0f 84 de 01 00 00 je 10cc19 <_Objects_Extend_information+0x2c1>
10ca3b: 8b 45 c4 mov -0x3c(%ebp),%eax 10ca3e: 8d 04 b8 lea (%eax,%edi,4),%eax 10ca41: 89 45 bc mov %eax,-0x44(%ebp) 10ca44: 8b 4d c4 mov -0x3c(%ebp),%ecx 10ca47: 8d 04 f9 lea (%ecx,%edi,8),%eax
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10ca4a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10ca4e: 39 4d cc cmp %ecx,-0x34(%ebp)
10ca51: 0f 82 51 01 00 00 jb 10cba8 <_Objects_Extend_information+0x250>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10ca57: 8b 4d cc mov -0x34(%ebp),%ecx 10ca5a: 85 c9 test %ecx,%ecx
10ca5c: 74 12 je 10ca70 <_Objects_Extend_information+0x118><== NEVER TAKEN
10ca5e: 31 c9 xor %ecx,%ecx 10ca60: 8b 7d cc mov -0x34(%ebp),%edi 10ca63: 90 nop
local_table[ index ] = NULL;
10ca64: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4)
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10ca6b: 41 inc %ecx 10ca6c: 39 cf cmp %ecx,%edi
10ca6e: 77 f4 ja 10ca64 <_Objects_Extend_information+0x10c><== NEVER TAKEN
10ca70: c1 e6 02 shl $0x2,%esi 10ca73: 89 75 c0 mov %esi,-0x40(%ebp)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10ca76: 8b 4d c4 mov -0x3c(%ebp),%ecx 10ca79: 8b 75 c0 mov -0x40(%ebp),%esi 10ca7c: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
inactive_per_block[block_count] = 0;
10ca83: 8b 4d bc mov -0x44(%ebp),%ecx 10ca86: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10ca8d: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10ca91: 03 75 d4 add -0x2c(%ebp),%esi
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10ca94: 39 75 d4 cmp %esi,-0x2c(%ebp)
10ca97: 73 0f jae 10caa8 <_Objects_Extend_information+0x150><== NEVER TAKEN
10ca99: 8b 4d d4 mov -0x2c(%ebp),%ecx
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10ca9c: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4)
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
10caa3: 41 inc %ecx
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10caa4: 39 f1 cmp %esi,%ecx
10caa6: 72 f4 jb 10ca9c <_Objects_Extend_information+0x144>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10caa8: 9c pushf 10caa9: fa cli 10caaa: 5f pop %edi
old_tables = information->object_blocks;
10caab: 8b 4b 34 mov 0x34(%ebx),%ecx
information->object_blocks = object_blocks;
10caae: 8b 75 c4 mov -0x3c(%ebp),%esi 10cab1: 89 73 34 mov %esi,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10cab4: 8b 75 bc mov -0x44(%ebp),%esi 10cab7: 89 73 30 mov %esi,0x30(%ebx)
information->local_table = local_table;
10caba: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10cabd: 8b 45 d0 mov -0x30(%ebp),%eax 10cac0: 66 89 43 10 mov %ax,0x10(%ebx)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cac4: 8b 33 mov (%ebx),%esi 10cac6: c1 e6 18 shl $0x18,%esi 10cac9: 81 ce 00 00 01 00 or $0x10000,%esi
information->maximum_id = _Objects_Build_id(
10cacf: 0f b7 43 04 movzwl 0x4(%ebx),%eax
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cad3: c1 e0 1b shl $0x1b,%eax 10cad6: 09 c6 or %eax,%esi 10cad8: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cadc: 09 c6 or %eax,%esi 10cade: 89 73 0c mov %esi,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10cae1: 57 push %edi 10cae2: 9d popf
if ( old_tables )
10cae3: 85 c9 test %ecx,%ecx
10cae5: 74 12 je 10caf9 <_Objects_Extend_information+0x1a1>
_Workspace_Free( old_tables );
10cae7: 83 ec 0c sub $0xc,%esp 10caea: 51 push %ecx 10caeb: 89 55 b8 mov %edx,-0x48(%ebp) 10caee: e8 31 1d 00 00 call 10e824 <_Workspace_Free> 10caf3: 83 c4 10 add $0x10,%esp 10caf6: 8b 55 b8 mov -0x48(%ebp),%edx
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10caf9: c1 e2 02 shl $0x2,%edx 10cafc: 89 55 d0 mov %edx,-0x30(%ebp) 10caff: 8b 43 34 mov 0x34(%ebx),%eax 10cb02: 8b 4d c8 mov -0x38(%ebp),%ecx 10cb05: 89 0c 10 mov %ecx,(%eax,%edx,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10cb08: ff 73 18 pushl 0x18(%ebx) 10cb0b: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10cb0f: 50 push %eax 10cb10: 51 push %ecx 10cb11: 8d 7d dc lea -0x24(%ebp),%edi 10cb14: 57 push %edi 10cb15: e8 1e 3a 00 00 call 110538 <_Chain_Initialize>
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10cb1a: 83 c4 10 add $0x10,%esp 10cb1d: 8b 75 d4 mov -0x2c(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cb20: 8d 43 20 lea 0x20(%ebx),%eax 10cb23: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10cb26: eb 29 jmp 10cb51 <_Objects_Extend_information+0x1f9> 10cb28: 8b 13 mov (%ebx),%edx 10cb2a: c1 e2 18 shl $0x18,%edx 10cb2d: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10cb33: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cb37: c1 e1 1b shl $0x1b,%ecx 10cb3a: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cb3c: 09 f2 or %esi,%edx 10cb3e: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cb41: 83 ec 08 sub $0x8,%esp 10cb44: 50 push %eax 10cb45: ff 75 d4 pushl -0x2c(%ebp) 10cb48: e8 43 f4 ff ff call 10bf90 <_Chain_Append>
index++;
10cb4d: 46 inc %esi 10cb4e: 83 c4 10 add $0x10,%esp
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10cb51: 83 ec 0c sub $0xc,%esp 10cb54: 57 push %edi 10cb55: e8 72 f4 ff ff call 10bfcc <_Chain_Get> 10cb5a: 83 c4 10 add $0x10,%esp 10cb5d: 85 c0 test %eax,%eax
10cb5f: 75 c7 jne 10cb28 <_Objects_Extend_information+0x1d0>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10cb61: 8b 43 14 mov 0x14(%ebx),%eax 10cb64: 8b 53 30 mov 0x30(%ebx),%edx 10cb67: 0f b7 c8 movzwl %ax,%ecx 10cb6a: 8b 75 d0 mov -0x30(%ebp),%esi 10cb6d: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10cb70: 66 01 43 2c add %ax,0x2c(%ebx)
}
10cb74: 8d 65 f4 lea -0xc(%ebp),%esp 10cb77: 5b pop %ebx 10cb78: 5e pop %esi 10cb79: 5f pop %edi 10cb7a: c9 leave 10cb7b: c3 ret 10cb7c: 89 45 d4 mov %eax,-0x2c(%ebp)
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10cb7f: 31 c9 xor %ecx,%ecx 10cb81: e9 3c fe ff ff jmp 10c9c2 <_Objects_Extend_information+0x6a> 10cb86: 66 90 xchg %ax,%ax
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
10cb88: 83 ec 0c sub $0xc,%esp 10cb8b: 57 push %edi 10cb8c: 89 55 b8 mov %edx,-0x48(%ebp) 10cb8f: 88 4d b4 mov %cl,-0x4c(%ebp) 10cb92: e8 a5 1c 00 00 call 10e83c <_Workspace_Allocate_or_fatal_error> 10cb97: 89 45 c8 mov %eax,-0x38(%ebp) 10cb9a: 83 c4 10 add $0x10,%esp 10cb9d: 8a 4d b4 mov -0x4c(%ebp),%cl 10cba0: 8b 55 b8 mov -0x48(%ebp),%edx 10cba3: e9 5f fe ff ff jmp 10ca07 <_Objects_Extend_information+0xaf>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
10cba8: c1 e6 02 shl $0x2,%esi 10cbab: 89 75 c0 mov %esi,-0x40(%ebp) 10cbae: 8b 73 34 mov 0x34(%ebx),%esi 10cbb1: 8b 7d c4 mov -0x3c(%ebp),%edi 10cbb4: 8b 4d c0 mov -0x40(%ebp),%ecx 10cbb7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10cbb9: 8b 73 30 mov 0x30(%ebx),%esi 10cbbc: 8b 7d bc mov -0x44(%ebp),%edi 10cbbf: 8b 4d c0 mov -0x40(%ebp),%ecx 10cbc2: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
10cbc4: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cbc8: 03 4d cc add -0x34(%ebp),%ecx
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10cbcb: c1 e1 02 shl $0x2,%ecx 10cbce: 8b 73 1c mov 0x1c(%ebx),%esi 10cbd1: 89 c7 mov %eax,%edi 10cbd3: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10cbd5: e9 9c fe ff ff jmp 10ca76 <_Objects_Extend_information+0x11e> 10cbda: 66 90 xchg %ax,%ax
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10cbdc: 8b 53 10 mov 0x10(%ebx),%edx 10cbdf: 66 89 55 d0 mov %dx,-0x30(%ebp) 10cbe3: 0f b7 7b 14 movzwl 0x14(%ebx),%edi
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
10cbe7: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10cbea: b1 01 mov $0x1,%cl
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10cbec: 31 d2 xor %edx,%edx
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10cbee: 31 f6 xor %esi,%esi 10cbf0: e9 cd fd ff ff jmp 10c9c2 <_Objects_Extend_information+0x6a>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10cbf5: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
10cbf8: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10cbfb: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10cbfe: b1 01 mov $0x1,%cl <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10cc00: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cc02: e9 bb fd ff ff jmp 10c9c2 <_Objects_Extend_information+0x6a><== NOT EXECUTED
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
10cc07: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
10cc0a: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10cc0d: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10cc10: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
* extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
10cc12: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cc14: e9 a9 fd ff ff jmp 10c9c2 <_Objects_Extend_information+0x6a><== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
10cc19: 83 ec 0c sub $0xc,%esp 10cc1c: ff 75 c8 pushl -0x38(%ebp) 10cc1f: e8 00 1c 00 00 call 10e824 <_Workspace_Free>
return;
10cc24: 83 c4 10 add $0x10,%esp 10cc27: e9 48 ff ff ff jmp 10cb74 <_Objects_Extend_information+0x21c>
0010ccbc <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10ccbc: 55 push %ebp 10ccbd: 89 e5 mov %esp,%ebp 10ccbf: 56 push %esi 10ccc0: 53 push %ebx 10ccc1: 8b 75 08 mov 0x8(%ebp),%esi 10ccc4: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10ccc7: 66 85 db test %bx,%bx
10ccca: 75 0c jne 10ccd8 <_Objects_Get_information+0x1c>
the_class_api_maximum = _Objects_API_maximum_class( the_api );
if ( the_class_api_maximum == 0 )
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
10cccc: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10ccce: 8d 65 f8 lea -0x8(%ebp),%esp 10ccd1: 5b pop %ebx 10ccd2: 5e pop %esi 10ccd3: c9 leave 10ccd4: c3 ret 10ccd5: 8d 76 00 lea 0x0(%esi),%esi
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10ccd8: 83 ec 0c sub $0xc,%esp 10ccdb: 56 push %esi 10ccdc: e8 5f 3d 00 00 call 110a40 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10cce1: 83 c4 10 add $0x10,%esp 10cce4: 85 c0 test %eax,%eax
10cce6: 74 e4 je 10cccc <_Objects_Get_information+0x10>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10cce8: 0f b7 db movzwl %bx,%ebx 10cceb: 39 d8 cmp %ebx,%eax
10cced: 72 dd jb 10cccc <_Objects_Get_information+0x10>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10ccef: 8b 14 b5 88 64 12 00 mov 0x126488(,%esi,4),%edx
return NULL;
10ccf6: 31 c0 xor %eax,%eax
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10ccf8: 85 d2 test %edx,%edx
10ccfa: 74 d2 je 10ccce <_Objects_Get_information+0x12><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10ccfc: 8b 04 9a mov (%edx,%ebx,4),%eax
if ( !info )
10ccff: 85 c0 test %eax,%eax
10cd01: 74 cb je 10ccce <_Objects_Get_information+0x12><== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
10cd03: 31 d2 xor %edx,%edx 10cd05: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10cd0a: 0f 95 c2 setne %dl 10cd0d: f7 da neg %edx 10cd0f: 21 d0 and %edx,%eax 10cd11: eb bb jmp 10ccce <_Objects_Get_information+0x12>
0010cd14 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10cd14: 55 push %ebp 10cd15: 89 e5 mov %esp,%ebp 10cd17: 56 push %esi 10cd18: 53 push %ebx 10cd19: 8b 55 08 mov 0x8(%ebp),%edx 10cd1c: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
10cd1f: b8 01 00 00 00 mov $0x1,%eax 10cd24: 2b 42 08 sub 0x8(%edx),%eax 10cd27: 03 45 0c add 0xc(%ebp),%eax
_ISR_Disable( level );
10cd2a: 9c pushf 10cd2b: fa cli 10cd2c: 5e pop %esi
if ( information->maximum >= index ) {
10cd2d: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10cd31: 39 c8 cmp %ecx,%eax
10cd33: 77 1b ja 10cd50 <_Objects_Get_isr_disable+0x3c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10cd35: 8b 52 1c mov 0x1c(%edx),%edx 10cd38: 8b 04 82 mov (%edx,%eax,4),%eax 10cd3b: 85 c0 test %eax,%eax
10cd3d: 74 21 je 10cd60 <_Objects_Get_isr_disable+0x4c>
*location = OBJECTS_LOCAL;
10cd3f: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10cd45: 8b 55 14 mov 0x14(%ebp),%edx 10cd48: 89 32 mov %esi,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
10cd4a: 5b pop %ebx 10cd4b: 5e pop %esi 10cd4c: c9 leave 10cd4d: c3 ret 10cd4e: 66 90 xchg %ax,%ax
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10cd50: 56 push %esi 10cd51: 9d popf
*location = OBJECTS_ERROR;
10cd52: c7 03 01 00 00 00 movl $0x1,(%ebx)
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
10cd58: 31 c0 xor %eax,%eax
#endif }
10cd5a: 5b pop %ebx 10cd5b: 5e pop %esi 10cd5c: c9 leave 10cd5d: c3 ret 10cd5e: 66 90 xchg %ax,%ax
if ( (the_object = information->local_table[ index ]) != NULL ) {
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
10cd60: 56 push %esi 10cd61: 9d popf
*location = OBJECTS_ERROR;
10cd62: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
10cd68: eb e0 jmp 10cd4a <_Objects_Get_isr_disable+0x36>
0010e410 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10e410: 55 push %ebp 10e411: 89 e5 mov %esp,%ebp 10e413: 57 push %edi 10e414: 56 push %esi 10e415: 53 push %ebx 10e416: 83 ec 3c sub $0x3c,%esp 10e419: 8b 7d 08 mov 0x8(%ebp),%edi 10e41c: 8b 75 0c mov 0xc(%ebp),%esi 10e41f: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10e422: 85 f6 test %esi,%esi
10e424: 75 0e jne 10e434 <_Objects_Get_name_as_string+0x24>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
10e426: 31 db xor %ebx,%ebx
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
10e428: 89 d8 mov %ebx,%eax 10e42a: 8d 65 f4 lea -0xc(%ebp),%esp 10e42d: 5b pop %ebx 10e42e: 5e pop %esi 10e42f: 5f pop %edi 10e430: c9 leave 10e431: c3 ret 10e432: 66 90 xchg %ax,%ax
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10e434: 85 db test %ebx,%ebx
10e436: 74 f0 je 10e428 <_Objects_Get_name_as_string+0x18>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e438: 85 ff test %edi,%edi
10e43a: 75 08 jne 10e444 <_Objects_Get_name_as_string+0x34>
10e43c: a1 18 16 13 00 mov 0x131618,%eax 10e441: 8b 78 08 mov 0x8(%eax),%edi
information = _Objects_Get_information_id( tmpId );
10e444: 83 ec 0c sub $0xc,%esp 10e447: 57 push %edi 10e448: e8 f3 fe ff ff call 10e340 <_Objects_Get_information_id>
if ( !information )
10e44d: 83 c4 10 add $0x10,%esp 10e450: 85 c0 test %eax,%eax
10e452: 74 d2 je 10e426 <_Objects_Get_name_as_string+0x16>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10e454: 51 push %ecx 10e455: 8d 55 e4 lea -0x1c(%ebp),%edx 10e458: 52 push %edx 10e459: 57 push %edi 10e45a: 50 push %eax 10e45b: e8 80 00 00 00 call 10e4e0 <_Objects_Get>
switch ( location ) {
10e460: 83 c4 10 add $0x10,%esp 10e463: 8b 55 e4 mov -0x1c(%ebp),%edx 10e466: 85 d2 test %edx,%edx
10e468: 75 bc jne 10e426 <_Objects_Get_name_as_string+0x16>
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
10e46a: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
10e46d: 89 c2 mov %eax,%edx 10e46f: c1 ea 18 shr $0x18,%edx 10e472: 88 55 c7 mov %dl,-0x39(%ebp) 10e475: 88 55 df mov %dl,-0x21(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10e478: 89 c7 mov %eax,%edi 10e47a: c1 ef 10 shr $0x10,%edi 10e47d: 89 f9 mov %edi,%ecx 10e47f: 88 4d e0 mov %cl,-0x20(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10e482: 89 c7 mov %eax,%edi 10e484: c1 ef 08 shr $0x8,%edi 10e487: 89 f9 mov %edi,%ecx 10e489: 88 4d e1 mov %cl,-0x1f(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10e48c: 88 45 e2 mov %al,-0x1e(%ebp)
lname[ 4 ] = '\0';
10e48f: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e493: 4e dec %esi 10e494: 89 75 d4 mov %esi,-0x2c(%ebp)
10e497: 74 41 je 10e4da <_Objects_Get_name_as_string+0xca><== NEVER TAKEN
10e499: 84 d2 test %dl,%dl
10e49b: 74 3d je 10e4da <_Objects_Get_name_as_string+0xca>
10e49d: 89 d9 mov %ebx,%ecx 10e49f: 31 c0 xor %eax,%eax 10e4a1: eb 09 jmp 10e4ac <_Objects_Get_name_as_string+0x9c> 10e4a3: 90 nop 10e4a4: 8a 54 05 df mov -0x21(%ebp,%eax,1),%dl 10e4a8: 84 d2 test %dl,%dl
10e4aa: 74 21 je 10e4cd <_Objects_Get_name_as_string+0xbd>
*d = (isprint((unsigned char)*s)) ? *s : '*';
10e4ac: 0f b6 f2 movzbl %dl,%esi 10e4af: 8b 3d 48 72 12 00 mov 0x127248,%edi 10e4b5: 0f be 74 37 01 movsbl 0x1(%edi,%esi,1),%esi 10e4ba: 81 e6 97 00 00 00 and $0x97,%esi
10e4c0: 75 02 jne 10e4c4 <_Objects_Get_name_as_string+0xb4>
10e4c2: b2 2a mov $0x2a,%dl 10e4c4: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e4c6: 40 inc %eax 10e4c7: 41 inc %ecx 10e4c8: 3b 45 d4 cmp -0x2c(%ebp),%eax
10e4cb: 72 d7 jb 10e4a4 <_Objects_Get_name_as_string+0x94>
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
10e4cd: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
10e4d0: e8 93 0a 00 00 call 10ef68 <_Thread_Enable_dispatch>
return name;
10e4d5: e9 4e ff ff ff jmp 10e428 <_Objects_Get_name_as_string+0x18>
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e4da: 89 d9 mov %ebx,%ecx 10e4dc: eb ef jmp 10e4cd <_Objects_Get_name_as_string+0xbd>
0010cec4 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
10cec4: 55 push %ebp 10cec5: 89 e5 mov %esp,%ebp 10cec7: 57 push %edi 10cec8: 56 push %esi 10cec9: 53 push %ebx 10ceca: 83 ec 0c sub $0xc,%esp 10cecd: 8b 5d 08 mov 0x8(%ebp),%ebx 10ced0: 8b 75 0c mov 0xc(%ebp),%esi 10ced3: 8b 7d 10 mov 0x10(%ebp),%edi
Objects_Control *object;
Objects_Id next_id;
if ( !information )
10ced6: 85 db test %ebx,%ebx
10ced8: 75 0a jne 10cee4 <_Objects_Get_next+0x20>
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
10ceda: 31 c0 xor %eax,%eax
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cedc: 8d 65 f4 lea -0xc(%ebp),%esp 10cedf: 5b pop %ebx 10cee0: 5e pop %esi 10cee1: 5f pop %edi 10cee2: c9 leave 10cee3: c3 ret
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
10cee4: 85 ff test %edi,%edi
10cee6: 74 f2 je 10ceda <_Objects_Get_next+0x16>
return NULL;
if ( !next_id_p )
10cee8: 8b 45 14 mov 0x14(%ebp),%eax 10ceeb: 85 c0 test %eax,%eax
10ceed: 74 eb je 10ceda <_Objects_Get_next+0x16>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
10ceef: 66 85 f6 test %si,%si
10cef2: 75 04 jne 10cef8 <_Objects_Get_next+0x34>
next_id = information->minimum_id;
10cef4: 8b 73 08 mov 0x8(%ebx),%esi 10cef7: 90 nop
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
10cef8: 66 39 73 10 cmp %si,0x10(%ebx)
10cefc: 72 22 jb 10cf20 <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
10cefe: 51 push %ecx 10ceff: 57 push %edi 10cf00: 56 push %esi 10cf01: 53 push %ebx 10cf02: e8 2d 00 00 00 call 10cf34 <_Objects_Get>
next_id++;
10cf07: 46 inc %esi
} while (*location_p != OBJECTS_LOCAL);
10cf08: 83 c4 10 add $0x10,%esp 10cf0b: 8b 17 mov (%edi),%edx 10cf0d: 85 d2 test %edx,%edx
10cf0f: 75 e7 jne 10cef8 <_Objects_Get_next+0x34>
*next_id_p = next_id;
10cf11: 8b 55 14 mov 0x14(%ebp),%edx 10cf14: 89 32 mov %esi,(%edx)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cf16: 8d 65 f4 lea -0xc(%ebp),%esp 10cf19: 5b pop %ebx 10cf1a: 5e pop %esi 10cf1b: 5f pop %edi 10cf1c: c9 leave 10cf1d: c3 ret 10cf1e: 66 90 xchg %ax,%ax
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
10cf20: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
10cf26: 8b 45 14 mov 0x14(%ebp),%eax 10cf29: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
return 0;
10cf2f: 31 c0 xor %eax,%eax 10cf31: eb a9 jmp 10cedc <_Objects_Get_next+0x18>
0011b170 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11b170: 55 push %ebp 11b171: 89 e5 mov %esp,%ebp 11b173: 53 push %ebx 11b174: 8b 55 08 mov 0x8(%ebp),%edx 11b177: 8b 5d 10 mov 0x10(%ebp),%ebx
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
11b17a: b8 01 00 00 00 mov $0x1,%eax 11b17f: 2b 42 08 sub 0x8(%edx),%eax 11b182: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
11b185: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11b189: 39 c8 cmp %ecx,%eax
11b18b: 77 13 ja 11b1a0 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11b18d: 8b 52 1c mov 0x1c(%edx),%edx 11b190: 8b 04 82 mov (%edx,%eax,4),%eax 11b193: 85 c0 test %eax,%eax
11b195: 74 09 je 11b1a0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11b197: c7 03 00 00 00 00 movl $0x0,(%ebx)
* This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; return NULL; }
11b19d: 5b pop %ebx 11b19e: c9 leave 11b19f: c3 ret
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
11b1a0: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
11b1a6: 31 c0 xor %eax,%eax
}
11b1a8: 5b pop %ebx 11b1a9: c9 leave 11b1aa: c3 ret
0010e018 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10e018: 55 push %ebp 10e019: 89 e5 mov %esp,%ebp 10e01b: 83 ec 18 sub $0x18,%esp 10e01e: 8b 55 08 mov 0x8(%ebp),%edx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e021: 85 d2 test %edx,%edx
10e023: 75 08 jne 10e02d <_Objects_Id_to_name+0x15>
10e025: a1 f8 87 12 00 mov 0x1287f8,%eax 10e02a: 8b 50 08 mov 0x8(%eax),%edx 10e02d: 89 d0 mov %edx,%eax 10e02f: c1 e8 18 shr $0x18,%eax 10e032: 83 e0 07 and $0x7,%eax
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
10e035: 8d 48 ff lea -0x1(%eax),%ecx 10e038: 83 f9 02 cmp $0x2,%ecx
10e03b: 77 3b ja 10e078 <_Objects_Id_to_name+0x60>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10e03d: 8b 04 85 08 85 12 00 mov 0x128508(,%eax,4),%eax 10e044: 85 c0 test %eax,%eax
10e046: 74 30 je 10e078 <_Objects_Id_to_name+0x60>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10e048: 89 d1 mov %edx,%ecx 10e04a: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10e04d: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
10e050: 85 c0 test %eax,%eax
10e052: 74 24 je 10e078 <_Objects_Id_to_name+0x60><== NEVER TAKEN
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10e054: 51 push %ecx 10e055: 8d 4d f4 lea -0xc(%ebp),%ecx 10e058: 51 push %ecx 10e059: 52 push %edx 10e05a: 50 push %eax 10e05b: e8 50 ff ff ff call 10dfb0 <_Objects_Get>
if ( !the_object )
10e060: 83 c4 10 add $0x10,%esp 10e063: 85 c0 test %eax,%eax
10e065: 74 11 je 10e078 <_Objects_Id_to_name+0x60>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10e067: 8b 50 0c mov 0xc(%eax),%edx 10e06a: 8b 45 0c mov 0xc(%ebp),%eax 10e06d: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10e06f: e8 2c 0a 00 00 call 10eaa0 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10e074: 31 c0 xor %eax,%eax
}
10e076: c9 leave 10e077: 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 ] )
return OBJECTS_INVALID_ID;
10e078: b8 03 00 00 00 mov $0x3,%eax
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
10e07d: c9 leave 10e07e: c3 ret
0010cdd4 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
10cdd4: 55 push %ebp 10cdd5: 89 e5 mov %esp,%ebp 10cdd7: 57 push %edi 10cdd8: 56 push %esi 10cdd9: 53 push %ebx 10cdda: 83 ec 0c sub $0xc,%esp 10cddd: 8b 45 08 mov 0x8(%ebp),%eax 10cde0: 8b 55 0c mov 0xc(%ebp),%edx 10cde3: 8b 5d 10 mov 0x10(%ebp),%ebx 10cde6: 8b 75 20 mov 0x20(%ebp),%esi 10cde9: 0f b7 7d 18 movzwl 0x18(%ebp),%edi
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
10cded: 89 10 mov %edx,(%eax)
information->the_class = the_class;
10cdef: 66 89 58 04 mov %bx,0x4(%eax)
information->size = size;
10cdf3: 89 78 18 mov %edi,0x18(%eax)
information->local_table = 0;
10cdf6: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
information->inactive_per_block = 0;
10cdfd: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
information->object_blocks = 0;
10ce04: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
information->inactive = 0;
10ce0b: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax)
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
10ce11: 66 c7 40 10 00 00 movw $0x0,0x10(%eax)
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
10ce17: 0f b7 db movzwl %bx,%ebx 10ce1a: 8b 3c 95 88 64 12 00 mov 0x126488(,%edx,4),%edi 10ce21: 89 04 9f mov %eax,(%edi,%ebx,4)
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
10ce24: 8b 7d 14 mov 0x14(%ebp),%edi 10ce27: c1 ef 1f shr $0x1f,%edi
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
10ce2a: 89 f9 mov %edi,%ecx 10ce2c: 88 48 12 mov %cl,0x12(%eax)
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
10ce2f: 8b 4d 14 mov 0x14(%ebp),%ecx 10ce32: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
10ce38: 85 ff test %edi,%edi
10ce3a: 74 04 je 10ce40 <_Objects_Initialize_information+0x6c>
10ce3c: 85 c9 test %ecx,%ecx
10ce3e: 74 67 je 10cea7 <_Objects_Initialize_information+0xd3>
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
10ce40: 66 89 48 14 mov %cx,0x14(%eax)
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
10ce44: c7 40 1c 24 61 12 00 movl $0x126124,0x1c(%eax)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10ce4b: c1 e2 18 shl $0x18,%edx 10ce4e: 81 ca 00 00 01 00 or $0x10000,%edx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10ce54: c1 e3 1b shl $0x1b,%ebx 10ce57: 09 da or %ebx,%edx
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
10ce59: 31 db xor %ebx,%ebx 10ce5b: 85 c9 test %ecx,%ecx 10ce5d: 0f 95 c3 setne %bl
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10ce60: 09 da or %ebx,%edx 10ce62: 89 50 08 mov %edx,0x8(%eax)
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
10ce65: f7 c6 03 00 00 00 test $0x3,%esi
10ce6b: 75 23 jne 10ce90 <_Objects_Initialize_information+0xbc><== NEVER TAKEN
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
10ce6d: 66 89 70 38 mov %si,0x38(%eax)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10ce71: 8d 50 24 lea 0x24(%eax),%edx 10ce74: 89 50 20 mov %edx,0x20(%eax)
head->next = tail;
head->previous = NULL;
10ce77: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10ce7e: 8d 50 20 lea 0x20(%eax),%edx 10ce81: 89 50 28 mov %edx,0x28(%eax)
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
10ce84: 85 c9 test %ecx,%ecx
10ce86: 75 10 jne 10ce98 <_Objects_Initialize_information+0xc4>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10ce88: 8d 65 f4 lea -0xc(%ebp),%esp 10ce8b: 5b pop %ebx 10ce8c: 5e pop %esi 10ce8d: 5f pop %edi 10ce8e: c9 leave 10ce8f: c3 ret
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
10ce90: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 10ce93: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED 10ce96: eb d5 jmp 10ce6d <_Objects_Initialize_information+0x99><== NOT EXECUTED
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10ce98: 89 45 08 mov %eax,0x8(%ebp)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10ce9b: 8d 65 f4 lea -0xc(%ebp),%esp 10ce9e: 5b pop %ebx 10ce9f: 5e pop %esi 10cea0: 5f pop %edi 10cea1: c9 leave
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10cea2: e9 b1 fa ff ff jmp 10c958 <_Objects_Extend_information>
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
_Internal_error_Occurred(
10cea7: 50 push %eax 10cea8: 6a 13 push $0x13 10ceaa: 6a 01 push $0x1 10ceac: 6a 00 push $0x0 10ceae: e8 71 f9 ff ff call 10c824 <_Internal_error_Occurred>
0010cec4 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10cec4: 55 push %ebp 10cec5: 89 e5 mov %esp,%ebp 10cec7: 57 push %edi 10cec8: 56 push %esi 10cec9: 53 push %ebx 10ceca: 8b 45 08 mov 0x8(%ebp),%eax 10cecd: 8b 4d 0c mov 0xc(%ebp),%ecx 10ced0: 8b 55 10 mov 0x10(%ebp),%edx 10ced3: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
10ced6: 85 ff test %edi,%edi
10ced8: 74 56 je 10cf30 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10ceda: 85 c9 test %ecx,%ecx
10cedc: 74 08 je 10cee6 <_Objects_Name_to_id_u32+0x22>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cede: 8b 70 10 mov 0x10(%eax),%esi 10cee1: 66 85 f6 test %si,%si
10cee4: 75 0a jne 10cef0 <_Objects_Name_to_id_u32+0x2c>
return OBJECTS_INVALID_NAME;
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
10cee6: b8 01 00 00 00 mov $0x1,%eax
#endif }
10ceeb: 5b pop %ebx 10ceec: 5e pop %esi 10ceed: 5f pop %edi 10ceee: c9 leave 10ceef: c3 ret
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cef0: 85 d2 test %edx,%edx
10cef2: 75 20 jne 10cf14 <_Objects_Name_to_id_u32+0x50>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
10cef4: 0f b7 f6 movzwl %si,%esi 10cef7: 8b 58 1c mov 0x1c(%eax),%ebx 10cefa: b8 01 00 00 00 mov $0x1,%eax 10ceff: 90 nop
the_object = information->local_table[ index ];
10cf00: 8b 14 83 mov (%ebx,%eax,4),%edx
if ( !the_object )
10cf03: 85 d2 test %edx,%edx
10cf05: 74 05 je 10cf0c <_Objects_Name_to_id_u32+0x48>
continue;
if ( name == the_object->name.name_u32 ) {
10cf07: 39 4a 0c cmp %ecx,0xc(%edx)
10cf0a: 74 18 je 10cf24 <_Objects_Name_to_id_u32+0x60>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
10cf0c: 40 inc %eax 10cf0d: 39 c6 cmp %eax,%esi
10cf0f: 73 ef jae 10cf00 <_Objects_Name_to_id_u32+0x3c>
10cf11: eb d3 jmp 10cee6 <_Objects_Name_to_id_u32+0x22> 10cf13: 90 nop
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
10cf14: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10cf1a: 74 d8 je 10cef4 <_Objects_Name_to_id_u32+0x30>
node == OBJECTS_SEARCH_LOCAL_NODE ||
10cf1c: 4a dec %edx
10cf1d: 75 c7 jne 10cee6 <_Objects_Name_to_id_u32+0x22>
10cf1f: eb d3 jmp 10cef4 <_Objects_Name_to_id_u32+0x30> 10cf21: 8d 76 00 lea 0x0(%esi),%esi
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
10cf24: 8b 42 08 mov 0x8(%edx),%eax 10cf27: 89 07 mov %eax,(%edi)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10cf29: 31 c0 xor %eax,%eax
name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif }
10cf2b: 5b pop %ebx 10cf2c: 5e pop %esi 10cf2d: 5f pop %edi 10cf2e: c9 leave 10cf2f: c3 ret
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
10cf30: b8 02 00 00 00 mov $0x2,%eax
name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif }
10cf35: 5b pop %ebx 10cf36: 5e pop %esi 10cf37: 5f pop %edi 10cf38: c9 leave 10cf39: c3 ret
0010edac <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10edac: 55 push %ebp 10edad: 89 e5 mov %esp,%ebp 10edaf: 53 push %ebx 10edb0: 83 ec 0c sub $0xc,%esp 10edb3: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10edb6: 8b 45 08 mov 0x8(%ebp),%eax 10edb9: 0f b7 40 38 movzwl 0x38(%eax),%eax 10edbd: 50 push %eax 10edbe: 53 push %ebx 10edbf: e8 c4 66 00 00 call 115488 <strnlen>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10edc4: 0f be 0b movsbl (%ebx),%ecx 10edc7: c1 e1 18 shl $0x18,%ecx 10edca: 83 c4 10 add $0x10,%esp 10edcd: 83 f8 01 cmp $0x1,%eax
10edd0: 76 32 jbe 10ee04 <_Objects_Set_name+0x58>
10edd2: 0f be 53 01 movsbl 0x1(%ebx),%edx 10edd6: c1 e2 10 shl $0x10,%edx 10edd9: 09 ca or %ecx,%edx 10eddb: 83 f8 02 cmp $0x2,%eax
10edde: 74 2c je 10ee0c <_Objects_Set_name+0x60>
10ede0: 0f be 4b 02 movsbl 0x2(%ebx),%ecx 10ede4: c1 e1 08 shl $0x8,%ecx 10ede7: 09 d1 or %edx,%ecx 10ede9: 83 f8 03 cmp $0x3,%eax
10edec: 74 37 je 10ee25 <_Objects_Set_name+0x79>
10edee: 0f be 43 03 movsbl 0x3(%ebx),%eax 10edf2: 09 c1 or %eax,%ecx 10edf4: 8b 55 0c mov 0xc(%ebp),%edx 10edf7: 89 4a 0c mov %ecx,0xc(%edx)
);
}
return true;
}
10edfa: b0 01 mov $0x1,%al 10edfc: 8b 5d fc mov -0x4(%ebp),%ebx 10edff: c9 leave 10ee00: c3 ret 10ee01: 8d 76 00 lea 0x0(%esi),%esi
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10ee04: 89 ca mov %ecx,%edx 10ee06: 81 ca 00 00 20 00 or $0x200000,%edx 10ee0c: 89 d1 mov %edx,%ecx 10ee0e: 80 cd 20 or $0x20,%ch 10ee11: b8 20 00 00 00 mov $0x20,%eax 10ee16: 09 c1 or %eax,%ecx 10ee18: 8b 55 0c mov 0xc(%ebp),%edx 10ee1b: 89 4a 0c mov %ecx,0xc(%edx)
);
}
return true;
}
10ee1e: b0 01 mov $0x1,%al 10ee20: 8b 5d fc mov -0x4(%ebp),%ebx 10ee23: c9 leave 10ee24: c3 ret
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10ee25: b8 20 00 00 00 mov $0x20,%eax 10ee2a: eb c6 jmp 10edf2 <_Objects_Set_name+0x46>
0010cf3c <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10cf3c: 55 push %ebp 10cf3d: 89 e5 mov %esp,%ebp 10cf3f: 57 push %edi 10cf40: 56 push %esi 10cf41: 53 push %ebx 10cf42: 83 ec 1c sub $0x1c,%esp
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
10cf45: 8b 45 08 mov 0x8(%ebp),%eax 10cf48: 0f b7 58 08 movzwl 0x8(%eax),%ebx
block_count = (information->maximum - index_base) /
10cf4c: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10cf50: 0f b7 40 10 movzwl 0x10(%eax),%eax 10cf54: 29 d8 sub %ebx,%eax 10cf56: 31 d2 xor %edx,%edx 10cf58: f7 f1 div %ecx
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10cf5a: 85 c0 test %eax,%eax
10cf5c: 74 21 je 10cf7f <_Objects_Shrink_information+0x43><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10cf5e: 8b 55 08 mov 0x8(%ebp),%edx 10cf61: 8b 7a 30 mov 0x30(%edx),%edi 10cf64: 3b 0f cmp (%edi),%ecx
10cf66: 74 1f je 10cf87 <_Objects_Shrink_information+0x4b><== NEVER TAKEN
10cf68: 31 d2 xor %edx,%edx 10cf6a: eb 0e jmp 10cf7a <_Objects_Shrink_information+0x3e>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10cf6c: 01 cb add %ecx,%ebx 10cf6e: 8d 34 95 00 00 00 00 lea 0x0(,%edx,4),%esi
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
10cf75: 3b 0c 97 cmp (%edi,%edx,4),%ecx
10cf78: 74 12 je 10cf8c <_Objects_Shrink_information+0x50>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10cf7a: 42 inc %edx 10cf7b: 39 d0 cmp %edx,%eax
10cf7d: 77 ed ja 10cf6c <_Objects_Shrink_information+0x30>
return;
}
index_base += information->allocation_size;
}
}
10cf7f: 8d 65 f4 lea -0xc(%ebp),%esp 10cf82: 5b pop %ebx 10cf83: 5e pop %esi 10cf84: 5f pop %edi 10cf85: c9 leave 10cf86: c3 ret
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
10cf87: 31 f6 xor %esi,%esi 10cf89: 8d 76 00 lea 0x0(%esi),%esi
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
10cf8c: 8b 55 08 mov 0x8(%ebp),%edx 10cf8f: 8b 42 20 mov 0x20(%edx),%eax 10cf92: 89 75 e4 mov %esi,-0x1c(%ebp) 10cf95: eb 07 jmp 10cf9e <_Objects_Shrink_information+0x62> 10cf97: 90 nop
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10cf98: 85 ff test %edi,%edi
10cf9a: 74 2c je 10cfc8 <_Objects_Shrink_information+0x8c>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
10cf9c: 89 f8 mov %edi,%eax
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
10cf9e: 0f b7 50 08 movzwl 0x8(%eax),%edx
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
10cfa2: 8b 38 mov (%eax),%edi
if ((index >= index_base) &&
10cfa4: 39 da cmp %ebx,%edx
10cfa6: 72 f0 jb 10cf98 <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
10cfa8: 8b 75 08 mov 0x8(%ebp),%esi 10cfab: 0f b7 4e 14 movzwl 0x14(%esi),%ecx 10cfaf: 8d 0c 0b lea (%ebx,%ecx,1),%ecx
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
10cfb2: 39 ca cmp %ecx,%edx
10cfb4: 73 e2 jae 10cf98 <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10cfb6: 83 ec 0c sub $0xc,%esp 10cfb9: 50 push %eax 10cfba: e8 f5 ef ff ff call 10bfb4 <_Chain_Extract> 10cfbf: 83 c4 10 add $0x10,%esp
}
}
while ( the_object );
10cfc2: 85 ff test %edi,%edi
10cfc4: 75 d6 jne 10cf9c <_Objects_Shrink_information+0x60>
10cfc6: 66 90 xchg %ax,%ax 10cfc8: 8b 75 e4 mov -0x1c(%ebp),%esi
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10cfcb: 83 ec 0c sub $0xc,%esp 10cfce: 8b 55 08 mov 0x8(%ebp),%edx 10cfd1: 8b 42 34 mov 0x34(%edx),%eax 10cfd4: ff 34 30 pushl (%eax,%esi,1) 10cfd7: e8 48 18 00 00 call 10e824 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10cfdc: 8b 55 08 mov 0x8(%ebp),%edx 10cfdf: 8b 42 34 mov 0x34(%edx),%eax 10cfe2: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1)
information->inactive_per_block[ block ] = 0;
10cfe9: 8b 42 30 mov 0x30(%edx),%eax 10cfec: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1)
information->inactive -= information->allocation_size;
10cff3: 8b 42 14 mov 0x14(%edx),%eax 10cff6: 66 29 42 2c sub %ax,0x2c(%edx)
return;
10cffa: 83 c4 10 add $0x10,%esp
}
index_base += information->allocation_size;
}
}
10cffd: 8d 65 f4 lea -0xc(%ebp),%esp 10d000: 5b pop %ebx 10d001: 5e pop %esi 10d002: 5f pop %edi 10d003: c9 leave 10d004: c3 ret
0010d764 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10d764: 55 push %ebp 10d765: 89 e5 mov %esp,%ebp 10d767: 56 push %esi 10d768: 53 push %ebx 10d769: 8b 5d 08 mov 0x8(%ebp),%ebx 10d76c: 8b 75 0c mov 0xc(%ebp),%esi
if ( !the_heap )
10d76f: 85 db test %ebx,%ebx
10d771: 74 35 je 10d7a8 <_Protected_heap_Get_information+0x44>
return false;
if ( !the_info )
10d773: 85 f6 test %esi,%esi
10d775: 74 31 je 10d7a8 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
10d777: 83 ec 0c sub $0xc,%esp 10d77a: ff 35 9c 76 12 00 pushl 0x12769c 10d780: e8 83 ee ff ff call 10c608 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
10d785: 5a pop %edx 10d786: 59 pop %ecx 10d787: 56 push %esi 10d788: 53 push %ebx 10d789: e8 da 3c 00 00 call 111468 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
10d78e: 58 pop %eax 10d78f: ff 35 9c 76 12 00 pushl 0x12769c 10d795: e8 b6 ee ff ff call 10c650 <_API_Mutex_Unlock>
return true;
10d79a: 83 c4 10 add $0x10,%esp 10d79d: b0 01 mov $0x1,%al
}
10d79f: 8d 65 f8 lea -0x8(%ebp),%esp 10d7a2: 5b pop %ebx 10d7a3: 5e pop %esi 10d7a4: c9 leave 10d7a5: c3 ret 10d7a6: 66 90 xchg %ax,%ax
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
10d7a8: 31 c0 xor %eax,%eax
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
10d7aa: 8d 65 f8 lea -0x8(%ebp),%esp 10d7ad: 5b pop %ebx 10d7ae: 5e pop %esi 10d7af: c9 leave 10d7b0: c3 ret
00110b20 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
110b20: 55 push %ebp 110b21: 89 e5 mov %esp,%ebp 110b23: 56 push %esi 110b24: 53 push %ebx 110b25: 83 ec 10 sub $0x10,%esp 110b28: 8b 5d 08 mov 0x8(%ebp),%ebx 110b2b: 8b 75 0c mov 0xc(%ebp),%esi 110b2e: 8a 45 10 mov 0x10(%ebp),%al
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
110b31: 8b 15 f0 cd 12 00 mov 0x12cdf0,%edx 110b37: 85 d2 test %edx,%edx
110b39: 74 19 je 110b54 <_Protected_heap_Walk+0x34>
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
110b3b: 0f b6 c0 movzbl %al,%eax 110b3e: 89 45 10 mov %eax,0x10(%ebp) 110b41: 89 75 0c mov %esi,0xc(%ebp) 110b44: 89 5d 08 mov %ebx,0x8(%ebp)
} return status; }
110b47: 8d 65 f8 lea -0x8(%ebp),%esp 110b4a: 5b pop %ebx 110b4b: 5e pop %esi 110b4c: c9 leave
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
110b4d: e9 46 f2 ff ff jmp 10fd98 <_Heap_Walk> 110b52: 66 90 xchg %ax,%ax
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
110b54: 83 ec 0c sub $0xc,%esp 110b57: ff 35 dc ce 12 00 pushl 0x12cedc 110b5d: 88 45 f4 mov %al,-0xc(%ebp) 110b60: e8 5b e4 ff ff call 10efc0 <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
110b65: 83 c4 0c add $0xc,%esp 110b68: 8a 45 f4 mov -0xc(%ebp),%al 110b6b: 0f b6 c0 movzbl %al,%eax 110b6e: 50 push %eax 110b6f: 56 push %esi 110b70: 53 push %ebx 110b71: e8 22 f2 ff ff call 10fd98 <_Heap_Walk>
_RTEMS_Unlock_allocator();
110b76: 5a pop %edx 110b77: ff 35 dc ce 12 00 pushl 0x12cedc 110b7d: 88 45 f4 mov %al,-0xc(%ebp) 110b80: e8 83 e4 ff ff call 10f008 <_API_Mutex_Unlock> 110b85: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
110b88: 8a 45 f4 mov -0xc(%ebp),%al 110b8b: 8d 65 f8 lea -0x8(%ebp),%esp 110b8e: 5b pop %ebx 110b8f: 5e pop %esi 110b90: c9 leave 110b91: c3 ret
00110348 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
110348: 55 push %ebp 110349: 89 e5 mov %esp,%ebp 11034b: 53 push %ebx 11034c: 83 ec 10 sub $0x10,%esp 11034f: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Notepads must be the last entry in the structure and they
* can be left off if disabled in the configuration.
*/
to_allocate = sizeof( RTEMS_API_Control );
110352: 80 3d e4 21 12 00 01 cmpb $0x1,0x1221e4 110359: 19 c0 sbb %eax,%eax 11035b: 83 e0 c0 and $0xffffffc0,%eax 11035e: 83 c0 60 add $0x60,%eax
if ( !rtems_configuration_get_notepads_enabled() )
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
110361: 50 push %eax 110362: e8 a1 e4 ff ff call 10e808 <_Workspace_Allocate>
if ( !api )
110367: 83 c4 10 add $0x10,%esp 11036a: 85 c0 test %eax,%eax
11036c: 74 6a je 1103d8 <_RTEMS_tasks_Create_extension+0x90>
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
11036e: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
110374: c7 00 00 00 00 00 movl $0x0,(%eax)
api->event_condition = 0;
11037a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = false;
110381: c6 40 08 00 movb $0x0,0x8(%eax)
information->handler = NULL;
110385: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
information->mode_set = RTEMS_DEFAULT_MODES;
11038c: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
information->signals_posted = 0;
110393: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
information->signals_pending = 0;
11039a: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
information->nest_level = 0;
1103a1: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal ); created->task_variables = NULL;
1103a8: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
1103af: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
1103b2: 80 3d e4 21 12 00 00 cmpb $0x0,0x1221e4
1103b9: 74 13 je 1103ce <_RTEMS_tasks_Create_extension+0x86>
1103bb: 31 d2 xor %edx,%edx 1103bd: 8d 76 00 lea 0x0(%esi),%esi
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
1103c0: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4)
1103c7: 00
api->event_condition = 0;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
1103c8: 42 inc %edx 1103c9: 83 fa 10 cmp $0x10,%edx
1103cc: 75 f2 jne 1103c0 <_RTEMS_tasks_Create_extension+0x78>
api->Notepads[i] = 0;
}
return true;
1103ce: b0 01 mov $0x1,%al
}
1103d0: 8b 5d fc mov -0x4(%ebp),%ebx 1103d3: c9 leave 1103d4: c3 ret 1103d5: 8d 76 00 lea 0x0(%esi),%esi
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
1103d8: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
1103da: 8b 5d fc mov -0x4(%ebp),%ebx 1103dd: c9 leave 1103de: c3 ret
001102f0 <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
1102f0: 55 push %ebp 1102f1: 89 e5 mov %esp,%ebp 1102f3: 56 push %esi 1102f4: 53 push %ebx 1102f5: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
1102f8: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax
deleted->task_variables = NULL;
1102fe: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
110305: 00 00 00
while (tvp) {
110308: 85 c0 test %eax,%eax
11030a: 75 06 jne 110312 <_RTEMS_tasks_Delete_extension+0x22>
11030c: eb 17 jmp 110325 <_RTEMS_tasks_Delete_extension+0x35> 11030e: 66 90 xchg %ax,%ax
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
110310: 89 f0 mov %esi,%eax
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
110312: 8b 30 mov (%eax),%esi
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
110314: 83 ec 08 sub $0x8,%esp 110317: 50 push %eax 110318: 53 push %ebx 110319: e8 56 01 00 00 call 110474 <_RTEMS_Tasks_Invoke_task_variable_dtor>
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
11031e: 83 c4 10 add $0x10,%esp 110321: 85 f6 test %esi,%esi
110323: 75 eb jne 110310 <_RTEMS_tasks_Delete_extension+0x20>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
110325: 83 ec 0c sub $0xc,%esp 110328: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 11032e: e8 f1 e4 ff ff call 10e824 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
110333: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
11033a: 00 00 00
11033d: 83 c4 10 add $0x10,%esp
}
110340: 8d 65 f8 lea -0x8(%ebp),%esp 110343: 5b pop %ebx 110344: 5e pop %esi 110345: c9 leave 110346: c3 ret
00110274 <_RTEMS_tasks_Initialize_user_tasks>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
110274: 55 push %ebp 110275: 89 e5 mov %esp,%ebp 110277: 83 ec 08 sub $0x8,%esp
if ( _RTEMS_tasks_Initialize_user_tasks_p )
11027a: a1 64 22 12 00 mov 0x122264,%eax 11027f: 85 c0 test %eax,%eax
110281: 74 05 je 110288 <_RTEMS_tasks_Initialize_user_tasks+0x14>
(*_RTEMS_tasks_Initialize_user_tasks_p)();
}
110283: c9 leave
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
if ( _RTEMS_tasks_Initialize_user_tasks_p )
(*_RTEMS_tasks_Initialize_user_tasks_p)();
110284: ff e0 jmp *%eax 110286: 66 90 xchg %ax,%ax
}
110288: c9 leave 110289: c3 ret
0010ba80 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10ba80: 55 push %ebp 10ba81: 89 e5 mov %esp,%ebp 10ba83: 57 push %edi 10ba84: 56 push %esi 10ba85: 53 push %ebx 10ba86: 83 ec 1c sub $0x1c,%esp
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
10ba89: 8b 1d 0c 22 12 00 mov 0x12220c,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10ba8f: 8b 3d 08 22 12 00 mov 0x122208,%edi
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
10ba95: 85 db test %ebx,%ebx
10ba97: 74 46 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10ba99: 85 ff test %edi,%edi
10ba9b: 74 42 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN
10ba9d: 31 f6 xor %esi,%esi 10ba9f: 90 nop
return_value = rtems_task_create(
10baa0: 83 ec 08 sub $0x8,%esp 10baa3: 8d 45 e4 lea -0x1c(%ebp),%eax 10baa6: 50 push %eax 10baa7: ff 73 0c pushl 0xc(%ebx) 10baaa: ff 73 14 pushl 0x14(%ebx) 10baad: ff 73 04 pushl 0x4(%ebx) 10bab0: ff 73 08 pushl 0x8(%ebx) 10bab3: ff 33 pushl (%ebx) 10bab5: e8 92 fd ff ff call 10b84c <rtems_task_create>
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
10baba: 83 c4 20 add $0x20,%esp 10babd: 85 c0 test %eax,%eax
10babf: 75 26 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
10bac1: 51 push %ecx 10bac2: ff 73 18 pushl 0x18(%ebx) 10bac5: ff 73 10 pushl 0x10(%ebx) 10bac8: ff 75 e4 pushl -0x1c(%ebp) 10bacb: e8 24 00 00 00 call 10baf4 <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10bad0: 83 c4 10 add $0x10,%esp 10bad3: 85 c0 test %eax,%eax
10bad5: 75 10 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10bad7: 46 inc %esi 10bad8: 83 c3 1c add $0x1c,%ebx 10badb: 39 f7 cmp %esi,%edi
10badd: 77 c1 ja 10baa0 <_RTEMS_tasks_Initialize_user_tasks_body+0x20><== NEVER TAKEN
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
10badf: 8d 65 f4 lea -0xc(%ebp),%esp 10bae2: 5b pop %ebx 10bae3: 5e pop %esi 10bae4: 5f pop %edi 10bae5: c9 leave 10bae6: c3 ret
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
10bae7: 52 push %edx 10bae8: 50 push %eax 10bae9: 6a 01 push $0x1 10baeb: 6a 01 push $0x1 10baed: e8 32 0d 00 00 call 10c824 <_Internal_error_Occurred>
0011028c <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
11028c: 55 push %ebp 11028d: 89 e5 mov %esp,%ebp 11028f: 57 push %edi 110290: 56 push %esi 110291: 53 push %ebx 110292: 83 ec 1c sub $0x1c,%esp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110295: 8b 45 08 mov 0x8(%ebp),%eax 110298: 8b 98 e4 00 00 00 mov 0xe4(%eax),%ebx
if ( !api )
11029e: 85 db test %ebx,%ebx
1102a0: 74 45 je 1102e7 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
1102a2: 9c pushf 1102a3: fa cli 1102a4: 58 pop %eax
signal_set = asr->signals_posted;
1102a5: 8b 73 14 mov 0x14(%ebx),%esi
asr->signals_posted = 0;
1102a8: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
_ISR_Enable( level );
1102af: 50 push %eax 1102b0: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
1102b1: 85 f6 test %esi,%esi
1102b3: 74 32 je 1102e7 <_RTEMS_tasks_Post_switch_extension+0x5b>
return;
asr->nest_level += 1;
1102b5: ff 43 1c incl 0x1c(%ebx)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
1102b8: 50 push %eax 1102b9: 8d 7d e4 lea -0x1c(%ebp),%edi 1102bc: 57 push %edi 1102bd: 68 ff ff 00 00 push $0xffff 1102c2: ff 73 10 pushl 0x10(%ebx) 1102c5: e8 5a 1c 00 00 call 111f24 <rtems_task_mode>
(*asr->handler)( signal_set );
1102ca: 89 34 24 mov %esi,(%esp) 1102cd: ff 53 0c call *0xc(%ebx)
asr->nest_level -= 1;
1102d0: ff 4b 1c decl 0x1c(%ebx)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
1102d3: 83 c4 0c add $0xc,%esp 1102d6: 57 push %edi 1102d7: 68 ff ff 00 00 push $0xffff 1102dc: ff 75 e4 pushl -0x1c(%ebp) 1102df: e8 40 1c 00 00 call 111f24 <rtems_task_mode> 1102e4: 83 c4 10 add $0x10,%esp
}
1102e7: 8d 65 f4 lea -0xc(%ebp),%esp 1102ea: 5b pop %ebx 1102eb: 5e pop %esi 1102ec: 5f pop %edi 1102ed: c9 leave 1102ee: c3 ret
0011022c <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
11022c: 55 push %ebp 11022d: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
11022f: 8b 45 08 mov 0x8(%ebp),%eax 110232: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax
while (tvp) {
110238: 85 c0 test %eax,%eax
11023a: 74 13 je 11024f <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
11023c: 8b 50 04 mov 0x4(%eax),%edx 11023f: 8b 0a mov (%edx),%ecx 110241: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
110244: 8b 48 08 mov 0x8(%eax),%ecx 110247: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110249: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
11024b: 85 c0 test %eax,%eax
11024d: 75 ed jne 11023c <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
11024f: 8b 45 0c mov 0xc(%ebp),%eax 110252: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax
while (tvp) {
110258: 85 c0 test %eax,%eax
11025a: 74 13 je 11026f <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
11025c: 8b 50 04 mov 0x4(%eax),%edx 11025f: 8b 0a mov (%edx),%ecx 110261: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
110264: 8b 48 0c mov 0xc(%eax),%ecx 110267: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110269: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
11026b: 85 c0 test %eax,%eax
11026d: 75 ed jne 11025c <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
11026f: c9 leave 110270: c3 ret
0010c4f0 <_Rate_monotonic_Initiate_statistics>:
}
void _Rate_monotonic_Initiate_statistics(
Rate_monotonic_Control *the_period
)
{
10c4f0: 55 push %ebp 10c4f1: 89 e5 mov %esp,%ebp 10c4f3: 57 push %edi 10c4f4: 56 push %esi 10c4f5: 53 push %ebx 10c4f6: 83 ec 28 sub $0x28,%esp 10c4f9: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *owning_thread = the_period->owner;
10c4fc: 8b 73 40 mov 0x40(%ebx),%esi
* If using nanosecond statistics, we need to obtain the uptime.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
_TOD_Get_uptime( &uptime );
10c4ff: 8d 7d e0 lea -0x20(%ebp),%edi 10c502: 57 push %edi 10c503: e8 c8 17 00 00 call 10dcd0 <_TOD_Get_uptime>
/*
* Set the starting point and the CPU time used for the statistics.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
the_period->time_period_initiated = uptime;
10c508: 8b 45 e0 mov -0x20(%ebp),%eax 10c50b: 8b 55 e4 mov -0x1c(%ebp),%edx 10c50e: 89 43 4c mov %eax,0x4c(%ebx) 10c511: 89 53 50 mov %edx,0x50(%ebx)
#else
the_period->time_period_initiated = _Watchdog_Ticks_since_boot;
#endif
the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used;
10c514: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10c51a: 8b 96 88 00 00 00 mov 0x88(%esi),%edx 10c520: 89 43 44 mov %eax,0x44(%ebx) 10c523: 89 53 48 mov %edx,0x48(%ebx)
* routine is invoked from rtems_rate_monotonic_period, the owner will
* be the executing thread. When this routine is invoked from
* _Rate_monotonic_Timeout, it will not.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
10c526: 83 c4 10 add $0x10,%esp 10c529: 39 35 38 9d 12 00 cmp %esi,0x129d38
10c52f: 74 0b je 10c53c <_Rate_monotonic_Initiate_statistics+0x4c>
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
}
#endif
}
10c531: 8d 65 f4 lea -0xc(%ebp),%esp 10c534: 5b pop %ebx 10c535: 5e pop %esi 10c536: 5f pop %edi 10c537: c9 leave 10c538: c3 ret 10c539: 8d 76 00 lea 0x0(%esi),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10c53c: 50 push %eax
&_Thread_Time_of_last_context_switch, &uptime, &ran
10c53d: 8d 75 d8 lea -0x28(%ebp),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10c540: 56 push %esi 10c541: 57 push %edi 10c542: 68 68 9b 12 00 push $0x129b68 10c547: e8 5c 38 00 00 call 10fda8 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
10c54c: 59 pop %ecx 10c54d: 5f pop %edi 10c54e: 56 push %esi 10c54f: 83 c3 44 add $0x44,%ebx 10c552: 53 push %ebx 10c553: e8 54 37 00 00 call 10fcac <_Timespec_Add_to> 10c558: 83 c4 10 add $0x10,%esp
}
#endif
}
10c55b: 8d 65 f4 lea -0xc(%ebp),%esp 10c55e: 5b pop %ebx 10c55f: 5e pop %esi 10c560: 5f pop %edi 10c561: c9 leave 10c562: c3 ret
0010caac <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10caac: 55 push %ebp 10caad: 89 e5 mov %esp,%ebp 10caaf: 83 ec 2c sub $0x2c,%esp
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
10cab2: 8d 45 f4 lea -0xc(%ebp),%eax 10cab5: 50 push %eax 10cab6: ff 75 08 pushl 0x8(%ebp) 10cab9: 68 80 99 12 00 push $0x129980 10cabe: e8 8d 1c 00 00 call 10e750 <_Objects_Get>
switch ( location ) {
10cac3: 83 c4 10 add $0x10,%esp 10cac6: 8b 55 f4 mov -0xc(%ebp),%edx 10cac9: 85 d2 test %edx,%edx
10cacb: 75 29 jne 10caf6 <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10cacd: 8b 50 40 mov 0x40(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10cad0: f6 42 11 40 testb $0x40,0x11(%edx)
10cad4: 74 08 je 10cade <_Rate_monotonic_Timeout+0x32>
10cad6: 8b 48 08 mov 0x8(%eax),%ecx 10cad9: 39 4a 20 cmp %ecx,0x20(%edx)
10cadc: 74 4e je 10cb2c <_Rate_monotonic_Timeout+0x80>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10cade: 83 78 38 01 cmpl $0x1,0x38(%eax)
10cae2: 74 14 je 10caf8 <_Rate_monotonic_Timeout+0x4c>
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10cae4: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10caeb: a1 70 9a 12 00 mov 0x129a70,%eax 10caf0: 48 dec %eax 10caf1: a3 70 9a 12 00 mov %eax,0x129a70
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10caf6: c9 leave 10caf7: c3 ret
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10caf8: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax)
_Rate_monotonic_Initiate_statistics( the_period );
10caff: 83 ec 0c sub $0xc,%esp 10cb02: 50 push %eax 10cb03: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb06: e8 e5 f9 ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10cb0b: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb0e: 8b 50 3c mov 0x3c(%eax),%edx 10cb11: 89 50 1c mov %edx,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10cb14: 5a pop %edx 10cb15: 59 pop %ecx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10cb16: 83 c0 10 add $0x10,%eax 10cb19: 50 push %eax 10cb1a: 68 7c 9b 12 00 push $0x129b7c 10cb1f: e8 64 35 00 00 call 110088 <_Watchdog_Insert> 10cb24: 83 c4 10 add $0x10,%esp 10cb27: eb c2 jmp 10caeb <_Rate_monotonic_Timeout+0x3f> 10cb29: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10cb2c: 83 ec 08 sub $0x8,%esp 10cb2f: 68 f8 ff 03 10 push $0x1003fff8 10cb34: 52 push %edx 10cb35: 89 45 e4 mov %eax,-0x1c(%ebp) 10cb38: e8 1b 23 00 00 call 10ee58 <_Thread_Clear_state>
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10cb3d: 8b 45 e4 mov -0x1c(%ebp),%eax 10cb40: 89 04 24 mov %eax,(%esp) 10cb43: eb c1 jmp 10cb06 <_Rate_monotonic_Timeout+0x5a>
0010c564 <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
10c564: 55 push %ebp 10c565: 89 e5 mov %esp,%ebp 10c567: 57 push %edi 10c568: 56 push %esi 10c569: 53 push %ebx 10c56a: 83 ec 1c sub $0x1c,%esp 10c56d: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
10c570: ff 43 54 incl 0x54(%ebx)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
10c573: 83 7b 38 04 cmpl $0x4,0x38(%ebx)
10c577: 0f 84 bf 00 00 00 je 10c63c <_Rate_monotonic_Update_statistics+0xd8>
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c57d: 51 push %ecx
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10c57e: 8d 7d e0 lea -0x20(%ebp),%edi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c581: 57 push %edi
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10c582: 8d 75 d8 lea -0x28(%ebp),%esi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c585: 56 push %esi 10c586: 53 push %ebx 10c587: e8 cc fe ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
10c58c: 83 c4 10 add $0x10,%esp 10c58f: 84 c0 test %al,%al
10c591: 75 09 jne 10c59c <_Rate_monotonic_Update_statistics+0x38>
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
10c593: 8d 65 f4 lea -0xc(%ebp),%esp 10c596: 5b pop %ebx 10c597: 5e pop %esi 10c598: 5f pop %edi 10c599: c9 leave 10c59a: c3 ret 10c59b: 90 nop
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
10c59c: 83 ec 08 sub $0x8,%esp 10c59f: 57 push %edi 10c5a0: 8d 43 6c lea 0x6c(%ebx),%eax 10c5a3: 50 push %eax 10c5a4: e8 03 37 00 00 call 10fcac <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
10c5a9: 58 pop %eax 10c5aa: 5a pop %edx 10c5ab: 8d 43 5c lea 0x5c(%ebx),%eax 10c5ae: 50 push %eax 10c5af: 57 push %edi 10c5b0: e8 cf 37 00 00 call 10fd84 <_Timespec_Less_than> 10c5b5: 83 c4 10 add $0x10,%esp 10c5b8: 84 c0 test %al,%al
10c5ba: 74 0c je 10c5c8 <_Rate_monotonic_Update_statistics+0x64>
stats->min_cpu_time = executed;
10c5bc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5bf: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5c2: 89 43 5c mov %eax,0x5c(%ebx) 10c5c5: 89 53 60 mov %edx,0x60(%ebx)
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
10c5c8: 83 ec 08 sub $0x8,%esp 10c5cb: 8d 43 64 lea 0x64(%ebx),%eax 10c5ce: 50 push %eax 10c5cf: 57 push %edi 10c5d0: e8 8b 37 00 00 call 10fd60 <_Timespec_Greater_than> 10c5d5: 83 c4 10 add $0x10,%esp 10c5d8: 84 c0 test %al,%al
10c5da: 74 0c je 10c5e8 <_Rate_monotonic_Update_statistics+0x84>
stats->max_cpu_time = executed;
10c5dc: 8b 45 e0 mov -0x20(%ebp),%eax 10c5df: 8b 55 e4 mov -0x1c(%ebp),%edx 10c5e2: 89 43 64 mov %eax,0x64(%ebx) 10c5e5: 89 53 68 mov %edx,0x68(%ebx)
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
10c5e8: 83 ec 08 sub $0x8,%esp 10c5eb: 56 push %esi 10c5ec: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c5f2: 50 push %eax 10c5f3: e8 b4 36 00 00 call 10fcac <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
10c5f8: 5a pop %edx 10c5f9: 59 pop %ecx 10c5fa: 8d 43 74 lea 0x74(%ebx),%eax 10c5fd: 50 push %eax 10c5fe: 56 push %esi 10c5ff: e8 80 37 00 00 call 10fd84 <_Timespec_Less_than> 10c604: 83 c4 10 add $0x10,%esp 10c607: 84 c0 test %al,%al
10c609: 75 39 jne 10c644 <_Rate_monotonic_Update_statistics+0xe0>
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
10c60b: 83 ec 08 sub $0x8,%esp 10c60e: 8d 43 7c lea 0x7c(%ebx),%eax 10c611: 50 push %eax 10c612: 56 push %esi 10c613: e8 48 37 00 00 call 10fd60 <_Timespec_Greater_than> 10c618: 83 c4 10 add $0x10,%esp 10c61b: 84 c0 test %al,%al
10c61d: 0f 84 70 ff ff ff je 10c593 <_Rate_monotonic_Update_statistics+0x2f>
stats->max_wall_time = since_last_period;
10c623: 8b 45 d8 mov -0x28(%ebp),%eax 10c626: 8b 55 dc mov -0x24(%ebp),%edx 10c629: 89 43 7c mov %eax,0x7c(%ebx) 10c62c: 89 93 80 00 00 00 mov %edx,0x80(%ebx)
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
10c632: 8d 65 f4 lea -0xc(%ebp),%esp 10c635: 5b pop %ebx 10c636: 5e pop %esi 10c637: 5f pop %edi 10c638: c9 leave 10c639: c3 ret 10c63a: 66 90 xchg %ax,%ax
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
10c63c: ff 43 58 incl 0x58(%ebx) 10c63f: e9 39 ff ff ff jmp 10c57d <_Rate_monotonic_Update_statistics+0x19>
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
10c644: 8b 45 d8 mov -0x28(%ebp),%eax 10c647: 8b 55 dc mov -0x24(%ebp),%edx 10c64a: 89 43 74 mov %eax,0x74(%ebx) 10c64d: 89 53 78 mov %edx,0x78(%ebx) 10c650: eb b9 jmp 10c60b <_Rate_monotonic_Update_statistics+0xa7>
00110a5c <_Scheduler_priority_Block>:
void _Scheduler_priority_Block(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
110a5c: 55 push %ebp 110a5d: 89 e5 mov %esp,%ebp 110a5f: 53 push %ebx 110a60: 8b 45 0c mov 0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract(
Thread_Control *the_thread
)
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
110a63: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 110a69: 8b 12 mov (%edx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
110a6b: 8b 4a 08 mov 0x8(%edx),%ecx 110a6e: 39 0a cmp %ecx,(%edx)
110a70: 74 6e je 110ae0 <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
110a72: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
110a74: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
110a77: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
110a7a: 89 0a mov %ecx,(%edx)
{
_Scheduler_priority_Ready_queue_extract(the_thread);
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
110a7c: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
110a82: 74 18 je 110a9c <_Scheduler_priority_Block+0x40>
_Scheduler_priority_Schedule_body(the_scheduler);
if ( _Thread_Is_executing( the_thread ) )
110a84: 3b 05 78 67 12 00 cmp 0x126778,%eax
110a8a: 74 04 je 110a90 <_Scheduler_priority_Block+0x34> _Scheduler_priority_Block_body(the_scheduler, the_thread); }
110a8c: 5b pop %ebx 110a8d: c9 leave 110a8e: c3 ret 110a8f: 90 nop
_Thread_Dispatch_necessary = true;
110a90: c6 05 84 67 12 00 01 movb $0x1,0x126784 110a97: 5b pop %ebx 110a98: c9 leave 110a99: c3 ret 110a9a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
110a9c: 66 8b 1d a0 67 12 00 mov 0x1267a0,%bx 110aa3: 31 d2 xor %edx,%edx 110aa5: 89 d1 mov %edx,%ecx 110aa7: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
110aab: 0f b7 c9 movzwl %cx,%ecx 110aae: 66 8b 9c 09 c0 67 12 mov 0x1267c0(%ecx,%ecx,1),%bx
110ab5: 00
110ab6: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
110aba: c1 e1 04 shl $0x4,%ecx 110abd: 0f b7 d2 movzwl %dx,%edx 110ac0: 8d 14 11 lea (%ecx,%edx,1),%edx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
110ac3: 8d 14 52 lea (%edx,%edx,2),%edx 110ac6: c1 e2 02 shl $0x2,%edx 110ac9: 8b 4d 08 mov 0x8(%ebp),%ecx 110acc: 03 11 add (%ecx),%edx 110ace: 8b 0a mov (%edx),%ecx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
110ad0: 83 c2 04 add $0x4,%edx 110ad3: 39 d1 cmp %edx,%ecx
110ad5: 74 4d je 110b24 <_Scheduler_priority_Block+0xc8><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
110ad7: 89 0d 7c 67 12 00 mov %ecx,0x12677c 110add: eb a5 jmp 110a84 <_Scheduler_priority_Block+0x28> 110adf: 90 nop
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
110ae0: 8d 4a 04 lea 0x4(%edx),%ecx 110ae3: 89 0a mov %ecx,(%edx)
head->next = tail;
head->previous = NULL;
110ae5: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
110aec: 89 52 08 mov %edx,0x8(%edx)
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
if ( _Chain_Has_only_one_node( ready ) ) {
_Chain_Initialize_empty( ready );
_Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map );
110aef: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
110af5: 8b 59 04 mov 0x4(%ecx),%ebx 110af8: 66 8b 13 mov (%ebx),%dx 110afb: 66 23 51 0e and 0xe(%ecx),%dx 110aff: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
110b02: 66 85 d2 test %dx,%dx
110b05: 0f 85 71 ff ff ff jne 110a7c <_Scheduler_priority_Block+0x20>
_Priority_Major_bit_map &= the_priority_map->block_major;
110b0b: 66 8b 15 a0 67 12 00 mov 0x1267a0,%dx 110b12: 23 51 0c and 0xc(%ecx),%edx 110b15: 66 89 15 a0 67 12 00 mov %dx,0x1267a0 110b1c: e9 5b ff ff ff jmp 110a7c <_Scheduler_priority_Block+0x20> 110b21: 8d 76 00 lea 0x0(%esi),%esi
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
110b24: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 110b26: eb af jmp 110ad7 <_Scheduler_priority_Block+0x7b><== NOT EXECUTED
0010d138 <_Scheduler_priority_Schedule>:
*/
void _Scheduler_priority_Schedule(
Scheduler_Control *the_scheduler
)
{
10d138: 55 push %ebp 10d139: 89 e5 mov %esp,%ebp
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
10d13b: 66 8b 0d a0 67 12 00 mov 0x1267a0,%cx 10d142: 31 c0 xor %eax,%eax 10d144: 89 c2 mov %eax,%edx 10d146: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d14a: 0f b7 d2 movzwl %dx,%edx 10d14d: 66 8b 8c 12 c0 67 12 mov 0x1267c0(%edx,%edx,1),%cx
10d154: 00
10d155: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10d159: c1 e2 04 shl $0x4,%edx 10d15c: 0f b7 c0 movzwl %ax,%eax 10d15f: 8d 04 02 lea (%edx,%eax,1),%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10d162: 8d 04 40 lea (%eax,%eax,2),%eax 10d165: c1 e0 02 shl $0x2,%eax 10d168: 8b 55 08 mov 0x8(%ebp),%edx 10d16b: 03 02 add (%edx),%eax
_Scheduler_priority_Schedule_body( the_scheduler ); }
10d16d: 8b 10 mov (%eax),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10d16f: 83 c0 04 add $0x4,%eax 10d172: 39 c2 cmp %eax,%edx
10d174: 74 0a je 10d180 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d176: 89 15 7c 67 12 00 mov %edx,0x12677c 10d17c: c9 leave 10d17d: c3 ret 10d17e: 66 90 xchg %ax,%ax
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10d180: 31 d2 xor %edx,%edx <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d182: 89 15 7c 67 12 00 mov %edx,0x12677c <== NOT EXECUTED 10d188: c9 leave <== NOT EXECUTED 10d189: c3 ret <== NOT EXECUTED
0010d218 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
10d218: 55 push %ebp 10d219: 89 e5 mov %esp,%ebp 10d21b: 53 push %ebx 10d21c: 8b 45 0c mov 0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
10d21f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10d225: 8b 4a 04 mov 0x4(%edx),%ecx 10d228: 66 8b 5a 0a mov 0xa(%edx),%bx 10d22c: 66 09 19 or %bx,(%ecx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10d22f: 66 8b 0d a0 67 12 00 mov 0x1267a0,%cx 10d236: 0b 4a 08 or 0x8(%edx),%ecx 10d239: 66 89 0d a0 67 12 00 mov %cx,0x1267a0
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
10d240: 8b 12 mov (%edx),%edx
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10d242: 8b 4a 08 mov 0x8(%edx),%ecx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10d245: 8d 5a 04 lea 0x4(%edx),%ebx 10d248: 89 18 mov %ebx,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d24a: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10d24d: 89 01 mov %eax,(%ecx)
the_node->previous = old_last;
10d24f: 89 48 04 mov %ecx,0x4(%eax)
* 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 ) {
10d252: 8b 50 14 mov 0x14(%eax),%edx 10d255: 8b 0d 7c 67 12 00 mov 0x12677c,%ecx 10d25b: 3b 51 14 cmp 0x14(%ecx),%edx
10d25e: 73 17 jae 10d277 <_Scheduler_priority_Unblock+0x5f>
_Thread_Heir = the_thread;
10d260: a3 7c 67 12 00 mov %eax,0x12677c
if ( _Thread_Executing->is_preemptible ||
10d265: a1 78 67 12 00 mov 0x126778,%eax 10d26a: 80 78 74 00 cmpb $0x0,0x74(%eax)
10d26e: 74 0c je 10d27c <_Scheduler_priority_Unblock+0x64>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10d270: c6 05 84 67 12 00 01 movb $0x1,0x126784
_Scheduler_priority_Unblock_body(the_scheduler, the_thread); }
10d277: 5b pop %ebx 10d278: c9 leave 10d279: c3 ret 10d27a: 66 90 xchg %ax,%ax
* 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 ) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
10d27c: 85 d2 test %edx,%edx
10d27e: 75 f7 jne 10d277 <_Scheduler_priority_Unblock+0x5f>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10d280: c6 05 84 67 12 00 01 movb $0x1,0x126784 10d287: eb ee jmp 10d277 <_Scheduler_priority_Unblock+0x5f>
0010d28c <_Scheduler_priority_Yield>:
*/
void _Scheduler_priority_Yield(
Scheduler_Control *the_scheduler __attribute__((unused))
)
{
10d28c: 55 push %ebp 10d28d: 89 e5 mov %esp,%ebp 10d28f: 56 push %esi 10d290: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10d291: a1 78 67 12 00 mov 0x126778,%eax
ready = executing->scheduler.priority->ready_chain;
10d296: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10d29c: 8b 12 mov (%edx),%edx
_ISR_Disable( level );
10d29e: 9c pushf 10d29f: fa cli 10d2a0: 59 pop %ecx
if ( !_Chain_Has_only_one_node( ready ) ) {
10d2a1: 8b 5a 08 mov 0x8(%edx),%ebx 10d2a4: 39 1a cmp %ebx,(%edx)
10d2a6: 74 40 je 10d2e8 <_Scheduler_priority_Yield+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d2a8: 8b 30 mov (%eax),%esi
previous = the_node->previous;
10d2aa: 8b 58 04 mov 0x4(%eax),%ebx
next->previous = previous;
10d2ad: 89 5e 04 mov %ebx,0x4(%esi)
previous->next = next;
10d2b0: 89 33 mov %esi,(%ebx)
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10d2b2: 8b 5a 08 mov 0x8(%edx),%ebx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10d2b5: 8d 72 04 lea 0x4(%edx),%esi 10d2b8: 89 30 mov %esi,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d2ba: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10d2bd: 89 03 mov %eax,(%ebx)
the_node->previous = old_last;
10d2bf: 89 58 04 mov %ebx,0x4(%eax)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10d2c2: 51 push %ecx 10d2c3: 9d popf 10d2c4: fa cli
if ( _Thread_Is_heir( executing ) )
10d2c5: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10d2cb: 74 0f je 10d2dc <_Scheduler_priority_Yield+0x50><== ALWAYS TAKEN
_Thread_Heir = (Thread_Control *) _Chain_First( ready );
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
_Thread_Dispatch_necessary = true;
10d2cd: c6 05 84 67 12 00 01 movb $0x1,0x126784
_ISR_Enable( level );
10d2d4: 51 push %ecx 10d2d5: 9d popf
}
10d2d6: 5b pop %ebx 10d2d7: 5e pop %esi 10d2d8: c9 leave 10d2d9: c3 ret 10d2da: 66 90 xchg %ax,%ax
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) _Chain_First( ready );
10d2dc: 8b 02 mov (%edx),%eax 10d2de: a3 7c 67 12 00 mov %eax,0x12677c 10d2e3: eb e8 jmp 10d2cd <_Scheduler_priority_Yield+0x41> 10d2e5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
10d2e8: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10d2ee: 75 dd jne 10d2cd <_Scheduler_priority_Yield+0x41><== NEVER TAKEN
10d2f0: eb e2 jmp 10d2d4 <_Scheduler_priority_Yield+0x48>
0010da14 <_TOD_Set>:
*/
void _TOD_Set(
const struct timespec *time
)
{
10da14: 55 push %ebp 10da15: 89 e5 mov %esp,%ebp 10da17: 53 push %ebx 10da18: 83 ec 04 sub $0x4,%esp 10da1b: 8b 5d 08 mov 0x8(%ebp),%ebx 10da1e: a1 10 13 13 00 mov 0x131310,%eax 10da23: 40 inc %eax 10da24: a3 10 13 13 00 mov %eax,0x131310
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10da29: a1 e4 13 13 00 mov 0x1313e4,%eax
if ( time->tv_sec < seconds )
10da2e: 8b 13 mov (%ebx),%edx 10da30: 39 d0 cmp %edx,%eax
10da32: 7f 34 jg 10da68 <_TOD_Set+0x54>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
10da34: 51 push %ecx
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
10da35: 29 c2 sub %eax,%edx 10da37: 52 push %edx 10da38: 6a 00 push $0x0 10da3a: 68 10 14 13 00 push $0x131410 10da3f: e8 50 24 00 00 call 10fe94 <_Watchdog_Adjust> 10da44: 83 c4 10 add $0x10,%esp
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
10da47: 8b 03 mov (%ebx),%eax 10da49: a3 e4 13 13 00 mov %eax,0x1313e4 10da4e: 8b 43 04 mov 0x4(%ebx),%eax 10da51: a3 e8 13 13 00 mov %eax,0x1313e8
_TOD_Is_set = true;
10da56: c6 05 24 13 13 00 01 movb $0x1,0x131324
_TOD_Activate();
_Thread_Enable_dispatch();
}
10da5d: 8b 5d fc mov -0x4(%ebp),%ebx 10da60: c9 leave
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
10da61: e9 02 15 00 00 jmp 10ef68 <_Thread_Enable_dispatch> 10da66: 66 90 xchg %ax,%ax 10da68: 51 push %ecx
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
if ( time->tv_sec < seconds )
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
10da69: 29 d0 sub %edx,%eax 10da6b: 50 push %eax 10da6c: 6a 01 push $0x1 10da6e: 68 10 14 13 00 push $0x131410 10da73: e8 1c 24 00 00 call 10fe94 <_Watchdog_Adjust> 10da78: 83 c4 10 add $0x10,%esp 10da7b: eb ca jmp 10da47 <_TOD_Set+0x33>
0010c444 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
10c444: 55 push %ebp 10c445: 89 e5 mov %esp,%ebp 10c447: 53 push %ebx 10c448: 83 ec 1c sub $0x1c,%esp
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
10c44b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) 10c452: a1 2c 22 12 00 mov 0x12222c,%eax 10c457: 8d 04 80 lea (%eax,%eax,4),%eax 10c45a: 8d 04 80 lea (%eax,%eax,4),%eax 10c45d: 8d 04 80 lea (%eax,%eax,4),%eax 10c460: c1 e0 03 shl $0x3,%eax 10c463: 89 45 f4 mov %eax,-0xc(%ebp)
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
10c466: a1 24 66 12 00 mov 0x126624,%eax 10c46b: 40 inc %eax 10c46c: a3 24 66 12 00 mov %eax,0x126624
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
10c471: 8d 5d f0 lea -0x10(%ebp),%ebx 10c474: 53 push %ebx 10c475: 68 38 65 12 00 push $0x126538 10c47a: e8 05 1e 00 00 call 10e284 <_Timespec_Add_to>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
10c47f: 58 pop %eax 10c480: 5a pop %edx 10c481: 53 push %ebx 10c482: 68 84 65 12 00 push $0x126584 10c487: e8 f8 1d 00 00 call 10e284 <_Timespec_Add_to> 10c48c: 89 c3 mov %eax,%ebx
while ( seconds ) {
10c48e: 83 c4 10 add $0x10,%esp 10c491: 85 c0 test %eax,%eax
10c493: 74 16 je 10c4ab <_TOD_Tickle_ticks+0x67>
10c495: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
10c498: 83 ec 0c sub $0xc,%esp 10c49b: 68 b0 65 12 00 push $0x1265b0 10c4a0: e8 a7 22 00 00 call 10e74c <_Watchdog_Tickle> 10c4a5: 83 c4 10 add $0x10,%esp 10c4a8: 4b dec %ebx
10c4a9: 75 ed jne 10c498 <_TOD_Tickle_ticks+0x54><== NEVER TAKEN
_Watchdog_Tickle_seconds();
seconds--;
}
}
10c4ab: 8b 5d fc mov -0x4(%ebp),%ebx 10c4ae: c9 leave 10c4af: c3 ret
0010c1f0 <_TOD_To_seconds>:
*/
uint32_t _TOD_To_seconds(
const rtems_time_of_day *the_tod
)
{
10c1f0: 55 push %ebp 10c1f1: 89 e5 mov %esp,%ebp 10c1f3: 56 push %esi 10c1f4: 53 push %ebx 10c1f5: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
10c1f8: 8b 72 08 mov 0x8(%edx),%esi 10c1fb: 4e dec %esi
year_mod_4 = the_tod->year & 3;
10c1fc: 8b 02 mov (%edx),%eax
if ( year_mod_4 == 0 )
10c1fe: 89 c3 mov %eax,%ebx 10c200: 83 e3 03 and $0x3,%ebx
10c203: 74 67 je 10c26c <_TOD_To_seconds+0x7c>
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
10c205: 8b 4a 04 mov 0x4(%edx),%ecx 10c208: 0f b7 8c 09 00 2f 12 movzwl 0x122f00(%ecx,%ecx,1),%ecx
10c20f: 00
10c210: 8d 34 31 lea (%ecx,%esi,1),%esi
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10c213: 0f b7 8c 1b 34 2f 12 movzwl 0x122f34(%ebx,%ebx,1),%ecx
10c21a: 00
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
10c21b: 2d c4 07 00 00 sub $0x7c4,%eax 10c220: c1 e8 02 shr $0x2,%eax 10c223: 8d 1c c0 lea (%eax,%eax,8),%ebx 10c226: 8d 1c d8 lea (%eax,%ebx,8),%ebx 10c229: 8d 1c 9b lea (%ebx,%ebx,4),%ebx 10c22c: 8d 04 98 lea (%eax,%ebx,4),%eax 10c22f: 01 c1 add %eax,%ecx
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10c231: 01 f1 add %esi,%ecx
time *= TOD_SECONDS_PER_DAY;
10c233: 8d 04 89 lea (%ecx,%ecx,4),%eax 10c236: 8d 04 81 lea (%ecx,%eax,4),%eax 10c239: 8d 04 c1 lea (%ecx,%eax,8),%eax 10c23c: c1 e0 02 shl $0x2,%eax 10c23f: 29 c8 sub %ecx,%eax 10c241: c1 e0 07 shl $0x7,%eax
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
10c244: 8b 5a 14 mov 0x14(%edx),%ebx 10c247: 8b 4a 0c mov 0xc(%edx),%ecx 10c24a: 8d 0c 49 lea (%ecx,%ecx,2),%ecx 10c24d: 8d 0c 89 lea (%ecx,%ecx,4),%ecx 10c250: c1 e1 02 shl $0x2,%ecx 10c253: 03 4a 10 add 0x10(%edx),%ecx
* TOD_SECONDS_PER_MINUTE;
10c256: 8d 14 49 lea (%ecx,%ecx,2),%edx 10c259: 8d 14 92 lea (%edx,%edx,4),%edx
time += the_tod->second;
10c25c: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx
time += TOD_SECONDS_1970_THROUGH_1988;
10c263: 8d 04 02 lea (%edx,%eax,1),%eax
return( time );
}
10c266: 5b pop %ebx 10c267: 5e pop %esi 10c268: c9 leave 10c269: c3 ret 10c26a: 66 90 xchg %ax,%ax
time = the_tod->day - 1;
year_mod_4 = the_tod->year & 3;
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
10c26c: 8b 4a 04 mov 0x4(%edx),%ecx 10c26f: 0f b7 8c 09 1a 2f 12 movzwl 0x122f1a(%ecx,%ecx,1),%ecx
10c276: 00
10c277: 8d 34 31 lea (%ecx,%esi,1),%esi 10c27a: eb 97 jmp 10c213 <_TOD_To_seconds+0x23>
0010c27c <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10c27c: 55 push %ebp 10c27d: 89 e5 mov %esp,%ebp 10c27f: 53 push %ebx 10c280: 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();
10c283: 8b 1d 2c 52 12 00 mov 0x12522c,%ebx
if ((!the_tod) ||
10c289: 85 c9 test %ecx,%ecx
10c28b: 74 53 je 10c2e0 <_TOD_Validate+0x64> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10c28d: b8 40 42 0f 00 mov $0xf4240,%eax 10c292: 31 d2 xor %edx,%edx 10c294: f7 f3 div %ebx
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
10c296: 3b 41 18 cmp 0x18(%ecx),%eax
10c299: 76 45 jbe 10c2e0 <_TOD_Validate+0x64>
(the_tod->ticks >= ticks_per_second) ||
10c29b: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10c29f: 77 3f ja 10c2e0 <_TOD_Validate+0x64>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10c2a1: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10c2a5: 77 39 ja 10c2e0 <_TOD_Validate+0x64>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10c2a7: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10c2ab: 77 33 ja 10c2e0 <_TOD_Validate+0x64>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10c2ad: 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) ||
10c2b0: 85 c0 test %eax,%eax
10c2b2: 74 2c je 10c2e0 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->month == 0) ||
10c2b4: 83 f8 0c cmp $0xc,%eax
10c2b7: 77 27 ja 10c2e0 <_TOD_Validate+0x64>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10c2b9: 8b 11 mov (%ecx),%edx
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
10c2bb: 81 fa c3 07 00 00 cmp $0x7c3,%edx
10c2c1: 76 1d jbe 10c2e0 <_TOD_Validate+0x64>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10c2c3: 8b 49 08 mov 0x8(%ecx),%ecx
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10c2c6: 85 c9 test %ecx,%ecx
10c2c8: 74 16 je 10c2e0 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10c2ca: 83 e2 03 and $0x3,%edx
10c2cd: 75 16 jne 10c2e5 <_TOD_Validate+0x69>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10c2cf: 8b 04 85 74 2f 12 00 mov 0x122f74(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10c2d6: 39 c8 cmp %ecx,%eax 10c2d8: 0f 93 c0 setae %al 10c2db: eb 05 jmp 10c2e2 <_TOD_Validate+0x66> 10c2dd: 8d 76 00 lea 0x0(%esi),%esi
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
10c2e0: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10c2e2: 5b pop %ebx 10c2e3: c9 leave 10c2e4: c3 ret
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10c2e5: 8b 04 85 40 2f 12 00 mov 0x122f40(,%eax,4),%eax 10c2ec: eb e8 jmp 10c2d6 <_TOD_Validate+0x5a>
0010d340 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10d340: 55 push %ebp 10d341: 89 e5 mov %esp,%ebp 10d343: 57 push %edi 10d344: 56 push %esi 10d345: 53 push %ebx 10d346: 83 ec 28 sub $0x28,%esp 10d349: 8b 5d 08 mov 0x8(%ebp),%ebx 10d34c: 8b 75 0c mov 0xc(%ebp),%esi 10d34f: 8a 45 10 mov 0x10(%ebp),%al 10d352: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10d355: 8b 7b 10 mov 0x10(%ebx),%edi
/* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread );
10d358: 53 push %ebx 10d359: e8 16 0d 00 00 call 10e074 <_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 )
10d35e: 83 c4 10 add $0x10,%esp 10d361: 39 73 14 cmp %esi,0x14(%ebx)
10d364: 74 0d je 10d373 <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10d366: 83 ec 08 sub $0x8,%esp 10d369: 56 push %esi 10d36a: 53 push %ebx 10d36b: e8 a0 0c 00 00 call 10e010 <_Thread_Set_priority> 10d370: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10d373: 9c pushf 10d374: fa cli 10d375: 5e pop %esi
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
10d376: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10d379: 83 f8 04 cmp $0x4,%eax
10d37c: 74 26 je 10d3a4 <_Thread_Change_priority+0x64>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10d37e: 83 e7 04 and $0x4,%edi
10d381: 74 15 je 10d398 <_Thread_Change_priority+0x58><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10d383: 56 push %esi 10d384: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d385: a9 e0 be 03 00 test $0x3bee0,%eax
10d38a: 0f 85 94 00 00 00 jne 10d424 <_Thread_Change_priority+0xe4>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10d390: 8d 65 f4 lea -0xc(%ebp),%esp 10d393: 5b pop %ebx 10d394: 5e pop %esi 10d395: 5f pop %edi 10d396: c9 leave 10d397: c3 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10d398: 89 c2 mov %eax,%edx 10d39a: 83 e2 fb and $0xfffffffb,%edx 10d39d: 89 53 10 mov %edx,0x10(%ebx) 10d3a0: eb e1 jmp 10d383 <_Thread_Change_priority+0x43> 10d3a2: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10d3a4: 83 e7 04 and $0x4,%edi
10d3a7: 75 40 jne 10d3e9 <_Thread_Change_priority+0xa9><== NEVER TAKEN
* Ready Queue with interrupts off.
*
* FIXME: hard-coded for priority scheduling. Might be ok since this
* function is specific to priority scheduling?
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10d3a9: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10d3b0: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10d3b4: 0f 84 82 00 00 00 je 10d43c <_Thread_Change_priority+0xfc>
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue_first(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
10d3ba: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10d3c0: 8b 50 04 mov 0x4(%eax),%edx 10d3c3: 66 8b 48 0a mov 0xa(%eax),%cx 10d3c7: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10d3ca: 66 8b 15 a0 67 12 00 mov 0x1267a0,%dx 10d3d1: 0b 50 08 or 0x8(%eax),%edx 10d3d4: 66 89 15 a0 67 12 00 mov %dx,0x1267a0
_Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain,
10d3db: 8b 00 mov (%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10d3dd: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10d3e0: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10d3e2: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10d3e4: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10d3e6: 89 5a 04 mov %ebx,0x4(%edx)
_Scheduler_priority_Ready_queue_enqueue_first( the_thread );
else
_Scheduler_priority_Ready_queue_enqueue( the_thread );
}
_ISR_Flash( level );
10d3e9: 56 push %esi 10d3ea: 9d popf 10d3eb: fa cli
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule(
Scheduler_Control *the_scheduler
)
{
the_scheduler->Operations.schedule( the_scheduler );
10d3ec: 83 ec 0c sub $0xc,%esp 10d3ef: 68 60 65 12 00 push $0x126560 10d3f4: ff 15 64 65 12 00 call *0x126564
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10d3fa: a1 78 67 12 00 mov 0x126778,%eax
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule(&_Scheduler);
if ( !_Thread_Is_executing_also_the_heir() &&
10d3ff: 83 c4 10 add $0x10,%esp 10d402: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10d408: 74 0d je 10d417 <_Thread_Change_priority+0xd7>
10d40a: 80 78 74 00 cmpb $0x0,0x74(%eax)
10d40e: 74 07 je 10d417 <_Thread_Change_priority+0xd7>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10d410: c6 05 84 67 12 00 01 movb $0x1,0x126784
_ISR_Enable( level );
10d417: 56 push %esi 10d418: 9d popf
}
10d419: 8d 65 f4 lea -0xc(%ebp),%esp 10d41c: 5b pop %ebx 10d41d: 5e pop %esi 10d41e: 5f pop %edi 10d41f: c9 leave 10d420: c3 ret 10d421: 8d 76 00 lea 0x0(%esi),%esi
/* 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 );
10d424: 89 5d 0c mov %ebx,0xc(%ebp) 10d427: 8b 43 44 mov 0x44(%ebx),%eax 10d42a: 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 );
}
10d42d: 8d 65 f4 lea -0xc(%ebp),%esp 10d430: 5b pop %ebx 10d431: 5e pop %esi 10d432: 5f pop %edi 10d433: 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 );
10d434: e9 3f 0b 00 00 jmp 10df78 <_Thread_queue_Requeue> 10d439: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
10d43c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10d442: 8b 50 04 mov 0x4(%eax),%edx 10d445: 66 8b 48 0a mov 0xa(%eax),%cx 10d449: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10d44c: 66 8b 15 a0 67 12 00 mov 0x1267a0,%dx 10d453: 0b 50 08 or 0x8(%eax),%edx 10d456: 66 89 15 a0 67 12 00 mov %dx,0x1267a0
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
10d45d: 8b 00 mov (%eax),%eax
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10d45f: 8b 50 08 mov 0x8(%eax),%edx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10d462: 8d 48 04 lea 0x4(%eax),%ecx 10d465: 89 0b mov %ecx,(%ebx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d467: 89 58 08 mov %ebx,0x8(%eax)
old_last->next = the_node;
10d46a: 89 1a mov %ebx,(%edx)
the_node->previous = old_last;
10d46c: 89 53 04 mov %edx,0x4(%ebx) 10d46f: e9 75 ff ff ff jmp 10d3e9 <_Thread_Change_priority+0xa9>
0010d474 <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10d474: 55 push %ebp 10d475: 89 e5 mov %esp,%ebp 10d477: 53 push %ebx 10d478: 83 ec 04 sub $0x4,%esp 10d47b: 8b 55 08 mov 0x8(%ebp),%edx 10d47e: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10d481: 9c pushf 10d482: fa cli 10d483: 5b pop %ebx
current_state = the_thread->current_state;
10d484: 8b 4a 10 mov 0x10(%edx),%ecx
if ( current_state & state ) {
10d487: 85 c8 test %ecx,%eax
10d489: 74 0b je 10d496 <_Thread_Clear_state+0x22>
10d48b: f7 d0 not %eax 10d48d: 21 c8 and %ecx,%eax
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10d48f: 89 42 10 mov %eax,0x10(%edx)
if ( _States_Is_ready( current_state ) ) {
10d492: 85 c0 test %eax,%eax
10d494: 74 0a je 10d4a0 <_Thread_Clear_state+0x2c>
_Scheduler_Unblock( &_Scheduler, the_thread);
}
}
_ISR_Enable( level );
10d496: 53 push %ebx 10d497: 9d popf
}
10d498: 8b 5d fc mov -0x4(%ebp),%ebx 10d49b: c9 leave 10d49c: c3 ret 10d49d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.unblock( the_scheduler, the_thread );
10d4a0: 83 ec 08 sub $0x8,%esp 10d4a3: 52 push %edx 10d4a4: 68 60 65 12 00 push $0x126560 10d4a9: ff 15 70 65 12 00 call *0x126570 10d4af: 83 c4 10 add $0x10,%esp 10d4b2: eb e2 jmp 10d496 <_Thread_Clear_state+0x22>
0010d640 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10d640: 55 push %ebp 10d641: 89 e5 mov %esp,%ebp 10d643: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d646: 8d 45 f4 lea -0xc(%ebp),%eax 10d649: 50 push %eax 10d64a: ff 75 08 pushl 0x8(%ebp) 10d64d: e8 c6 01 00 00 call 10d818 <_Thread_Get>
switch ( location ) {
10d652: 83 c4 10 add $0x10,%esp 10d655: 8b 55 f4 mov -0xc(%ebp),%edx 10d658: 85 d2 test %edx,%edx
10d65a: 75 1c jne 10d678 <_Thread_Delay_ended+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10d65c: 83 ec 08 sub $0x8,%esp 10d65f: 68 18 00 00 10 push $0x10000018 10d664: 50 push %eax 10d665: e8 0a fe ff ff call 10d474 <_Thread_Clear_state> 10d66a: a1 b0 64 12 00 mov 0x1264b0,%eax 10d66f: 48 dec %eax 10d670: a3 b0 64 12 00 mov %eax,0x1264b0 10d675: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10d678: c9 leave 10d679: c3 ret
0010d67c <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10d67c: 55 push %ebp 10d67d: 89 e5 mov %esp,%ebp 10d67f: 57 push %edi 10d680: 56 push %esi 10d681: 53 push %ebx 10d682: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10d685: 8b 1d 78 67 12 00 mov 0x126778,%ebx
_ISR_Disable( level );
10d68b: 9c pushf 10d68c: fa cli 10d68d: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10d68e: 8a 15 84 67 12 00 mov 0x126784,%dl 10d694: 84 d2 test %dl,%dl
10d696: 0f 84 3c 01 00 00 je 10d7d8 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d69c: 8b 35 7c 67 12 00 mov 0x12677c,%esi
_Thread_Dispatch_disable_level = 1;
10d6a2: c7 05 b0 64 12 00 01 movl $0x1,0x1264b0
10d6a9: 00 00 00
_Thread_Dispatch_necessary = false;
10d6ac: c6 05 84 67 12 00 00 movb $0x0,0x126784
_Thread_Executing = heir;
10d6b3: 89 35 78 67 12 00 mov %esi,0x126778
/*
* 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 )
10d6b9: 39 f3 cmp %esi,%ebx
10d6bb: 0f 84 17 01 00 00 je 10d7d8 <_Thread_Dispatch+0x15c>
10d6c1: 8d 7d d8 lea -0x28(%ebp),%edi 10d6c4: e9 f5 00 00 00 jmp 10d7be <_Thread_Dispatch+0x142> 10d6c9: 8d 76 00 lea 0x0(%esi),%esi
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
10d6cc: 50 push %eax 10d6cd: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10d6ce: 83 ec 0c sub $0xc,%esp 10d6d1: 8d 45 e0 lea -0x20(%ebp),%eax 10d6d4: 50 push %eax 10d6d5: e8 0a 30 00 00 call 1106e4 <_TOD_Get_uptime>
_Timestamp_Subtract(
10d6da: 83 c4 0c add $0xc,%esp 10d6dd: 57 push %edi 10d6de: 8d 45 e0 lea -0x20(%ebp),%eax 10d6e1: 50 push %eax 10d6e2: 68 a8 65 12 00 push $0x1265a8 10d6e7: e8 d4 0b 00 00 call 10e2c0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10d6ec: 58 pop %eax 10d6ed: 5a pop %edx 10d6ee: 57 push %edi 10d6ef: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10d6f5: 50 push %eax 10d6f6: e8 89 0b 00 00 call 10e284 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10d6fb: 8b 45 e0 mov -0x20(%ebp),%eax 10d6fe: 8b 55 e4 mov -0x1c(%ebp),%edx 10d701: a3 a8 65 12 00 mov %eax,0x1265a8 10d706: 89 15 ac 65 12 00 mov %edx,0x1265ac
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10d70c: a1 80 65 12 00 mov 0x126580,%eax 10d711: 83 c4 10 add $0x10,%esp 10d714: 85 c0 test %eax,%eax
10d716: 74 10 je 10d728 <_Thread_Dispatch+0xac> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10d718: 8b 10 mov (%eax),%edx 10d71a: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10d720: 8b 96 e0 00 00 00 mov 0xe0(%esi),%edx 10d726: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10d728: 83 ec 08 sub $0x8,%esp 10d72b: 56 push %esi 10d72c: 53 push %ebx 10d72d: e8 2e 0e 00 00 call 10e560 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10d732: 5a pop %edx 10d733: 59 pop %ecx 10d734: 81 c6 c4 00 00 00 add $0xc4,%esi 10d73a: 56 push %esi 10d73b: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax 10d741: 50 push %eax 10d742: e8 29 11 00 00 call 10e870 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10d747: 83 c4 10 add $0x10,%esp 10d74a: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10d750: 85 c0 test %eax,%eax
10d752: 74 36 je 10d78a <_Thread_Dispatch+0x10e>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
10d754: a1 40 65 12 00 mov 0x126540,%eax 10d759: 39 c3 cmp %eax,%ebx
10d75b: 74 2d je 10d78a <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10d75d: 85 c0 test %eax,%eax
10d75f: 74 11 je 10d772 <_Thread_Dispatch+0xf6>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10d761: 83 ec 0c sub $0xc,%esp 10d764: 05 dc 00 00 00 add $0xdc,%eax 10d769: 50 push %eax 10d76a: e8 35 11 00 00 call 10e8a4 <_CPU_Context_save_fp> 10d76f: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10d772: 83 ec 0c sub $0xc,%esp 10d775: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax 10d77b: 50 push %eax 10d77c: e8 2d 11 00 00 call 10e8ae <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10d781: 89 1d 40 65 12 00 mov %ebx,0x126540 10d787: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10d78a: 8b 1d 78 67 12 00 mov 0x126778,%ebx
_ISR_Disable( level );
10d790: 9c pushf 10d791: fa cli 10d792: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10d793: 8a 15 84 67 12 00 mov 0x126784,%dl 10d799: 84 d2 test %dl,%dl
10d79b: 74 3b je 10d7d8 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d79d: 8b 35 7c 67 12 00 mov 0x12677c,%esi
_Thread_Dispatch_disable_level = 1;
10d7a3: c7 05 b0 64 12 00 01 movl $0x1,0x1264b0
10d7aa: 00 00 00
_Thread_Dispatch_necessary = false;
10d7ad: c6 05 84 67 12 00 00 movb $0x0,0x126784
_Thread_Executing = heir;
10d7b4: 89 35 78 67 12 00 mov %esi,0x126778
/*
* 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 )
10d7ba: 39 de cmp %ebx,%esi
10d7bc: 74 1a je 10d7d8 <_Thread_Dispatch+0x15c><== NEVER TAKEN
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
10d7be: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10d7c2: 0f 85 04 ff ff ff jne 10d6cc <_Thread_Dispatch+0x50>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10d7c8: 8b 15 80 64 12 00 mov 0x126480,%edx 10d7ce: 89 56 78 mov %edx,0x78(%esi) 10d7d1: e9 f6 fe ff ff jmp 10d6cc <_Thread_Dispatch+0x50> 10d7d6: 66 90 xchg %ax,%ax
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10d7d8: c7 05 b0 64 12 00 00 movl $0x0,0x1264b0
10d7df: 00 00 00
_ISR_Enable( level );
10d7e2: 50 push %eax 10d7e3: 9d popf
_API_extensions_Run_postswitch();
10d7e4: e8 9f e6 ff ff call 10be88 <_API_extensions_Run_postswitch>
}
10d7e9: 8d 65 f4 lea -0xc(%ebp),%esp 10d7ec: 5b pop %ebx 10d7ed: 5e pop %esi 10d7ee: 5f pop %edi 10d7ef: c9 leave 10d7f0: c3 ret
0010d818 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10d818: 55 push %ebp 10d819: 89 e5 mov %esp,%ebp 10d81b: 53 push %ebx 10d81c: 83 ec 04 sub $0x4,%esp 10d81f: 8b 45 08 mov 0x8(%ebp),%eax 10d822: 8b 4d 0c mov 0xc(%ebp),%ecx
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
10d825: 85 c0 test %eax,%eax
10d827: 74 4b je 10d874 <_Thread_Get+0x5c>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10d829: 89 c2 mov %eax,%edx 10d82b: c1 ea 18 shr $0x18,%edx 10d82e: 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 )
10d831: 8d 5a ff lea -0x1(%edx),%ebx 10d834: 83 fb 02 cmp $0x2,%ebx
10d837: 77 2b ja 10d864 <_Thread_Get+0x4c>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10d839: 89 c3 mov %eax,%ebx 10d83b: c1 eb 1b shr $0x1b,%ebx
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
10d83e: 4b dec %ebx
10d83f: 75 23 jne 10d864 <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10d841: 8b 14 95 88 64 12 00 mov 0x126488(,%edx,4),%edx
/*
* There is no way for this to happen if POSIX is enabled.
*/
#if !defined(RTEMS_POSIX_API)
if ( !api_information ) {
10d848: 85 d2 test %edx,%edx
10d84a: 74 18 je 10d864 <_Thread_Get+0x4c> <== NEVER TAKEN
*location = OBJECTS_ERROR;
goto done;
}
#endif
information = api_information[ the_class ];
10d84c: 8b 52 04 mov 0x4(%edx),%edx
if ( !information ) {
10d84f: 85 d2 test %edx,%edx
10d851: 74 11 je 10d864 <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10d853: 53 push %ebx 10d854: 51 push %ecx 10d855: 50 push %eax 10d856: 52 push %edx 10d857: e8 10 f5 ff ff call 10cd6c <_Objects_Get> 10d85c: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10d85f: 8b 5d fc mov -0x4(%ebp),%ebx 10d862: c9 leave 10d863: c3 ret
}
#endif
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10d864: c7 01 01 00 00 00 movl $0x1,(%ecx)
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
10d86a: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10d86c: 8b 5d fc mov -0x4(%ebp),%ebx 10d86f: c9 leave 10d870: c3 ret 10d871: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d874: a1 b0 64 12 00 mov 0x1264b0,%eax 10d879: 40 inc %eax 10d87a: a3 b0 64 12 00 mov %eax,0x1264b0
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
10d87f: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10d885: a1 78 67 12 00 mov 0x126778,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10d88a: 8b 5d fc mov -0x4(%ebp),%ebx 10d88d: c9 leave 10d88e: c3 ret
001121c8 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
1121c8: 55 push %ebp 1121c9: 89 e5 mov %esp,%ebp 1121cb: 53 push %ebx 1121cc: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
1121cf: 8b 1d 78 67 12 00 mov 0x126778,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
1121d5: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
1121db: 85 c0 test %eax,%eax
1121dd: 74 79 je 112258 <_Thread_Handler+0x90>
1121df: fa cli
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
1121e0: a0 2c 61 12 00 mov 0x12612c,%al 1121e5: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
1121e8: c6 05 2c 61 12 00 01 movb $0x1,0x12612c
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
1121ef: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx 1121f5: 85 d2 test %edx,%edx
1121f7: 74 24 je 11221d <_Thread_Handler+0x55>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
1121f9: a1 40 65 12 00 mov 0x126540,%eax 1121fe: 39 c3 cmp %eax,%ebx
112200: 74 1b je 11221d <_Thread_Handler+0x55>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
112202: 85 c0 test %eax,%eax
112204: 74 11 je 112217 <_Thread_Handler+0x4f>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
112206: 83 ec 0c sub $0xc,%esp 112209: 05 dc 00 00 00 add $0xdc,%eax 11220e: 50 push %eax 11220f: e8 90 c6 ff ff call 10e8a4 <_CPU_Context_save_fp> 112214: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
112217: 89 1d 40 65 12 00 mov %ebx,0x126540
/* * 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 );
11221d: 83 ec 0c sub $0xc,%esp 112220: 53 push %ebx 112221: e8 9e c1 ff ff call 10e3c4 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
112226: e8 c9 b5 ff ff call 10d7f4 <_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) */ {
11222b: 83 c4 10 add $0x10,%esp 11222e: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
112232: 74 28 je 11225c <_Thread_Handler+0x94>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
112234: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 11223a: 85 c0 test %eax,%eax
11223c: 74 2d je 11226b <_Thread_Handler+0xa3> <== ALWAYS TAKEN
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
11223e: 83 ec 0c sub $0xc,%esp 112241: 53 push %ebx 112242: e8 b9 c1 ff ff call 10e400 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
112247: 83 c4 0c add $0xc,%esp 11224a: 6a 05 push $0x5 11224c: 6a 01 push $0x1 11224e: 6a 00 push $0x0 112250: e8 cf a5 ff ff call 10c824 <_Internal_error_Occurred> 112255: 8d 76 00 lea 0x0(%esi),%esi
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
_ISR_Set_level(level);
112258: fb sti 112259: eb 85 jmp 1121e0 <_Thread_Handler+0x18> 11225b: 90 nop
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
11225c: e8 ef c6 00 00 call 11e950 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
112261: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 112267: 85 c0 test %eax,%eax
112269: 75 d3 jne 11223e <_Thread_Handler+0x76> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
11226b: 83 ec 0c sub $0xc,%esp 11226e: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 112274: ff 93 90 00 00 00 call *0x90(%ebx)
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
11227a: 89 43 28 mov %eax,0x28(%ebx) 11227d: 83 c4 10 add $0x10,%esp 112280: eb bc jmp 11223e <_Thread_Handler+0x76>
0010d890 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10d890: 55 push %ebp 10d891: 89 e5 mov %esp,%ebp 10d893: 57 push %edi 10d894: 56 push %esi 10d895: 53 push %ebx 10d896: 83 ec 24 sub $0x24,%esp 10d899: 8b 5d 0c mov 0xc(%ebp),%ebx 10d89c: 8b 75 14 mov 0x14(%ebp),%esi 10d89f: 0f b6 7d 18 movzbl 0x18(%ebp),%edi 10d8a3: 8a 45 20 mov 0x20(%ebp),%al 10d8a6: 88 45 e4 mov %al,-0x1c(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10d8a9: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10d8b0: 00 00 00
10d8b3: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10d8ba: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10d8bd: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
10d8c4: 00 00 00
/*
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10d8c7: 56 push %esi 10d8c8: 53 push %ebx 10d8c9: e8 16 08 00 00 call 10e0e4 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10d8ce: 83 c4 10 add $0x10,%esp 10d8d1: 85 c0 test %eax,%eax
10d8d3: 0f 84 9b 01 00 00 je 10da74 <_Thread_Initialize+0x1e4>
10d8d9: 39 c6 cmp %eax,%esi
10d8db: 0f 87 93 01 00 00 ja 10da74 <_Thread_Initialize+0x1e4><== NEVER TAKEN
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10d8e1: 8b 93 c0 00 00 00 mov 0xc0(%ebx),%edx 10d8e7: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx)
the_stack->size = size;
10d8ed: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10d8f3: 89 f8 mov %edi,%eax 10d8f5: 84 c0 test %al,%al
10d8f7: 0f 85 87 01 00 00 jne 10da84 <_Thread_Initialize+0x1f4>
10d8fd: 31 c0 xor %eax,%eax
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10d8ff: 31 ff xor %edi,%edi
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10d901: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx)
the_thread->Start.fp_context = fp_area;
10d907: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10d90d: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10d914: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10d91b: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10d922: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10d929: a1 8c 65 12 00 mov 0x12658c,%eax 10d92e: 85 c0 test %eax,%eax
10d930: 0f 85 76 01 00 00 jne 10daac <_Thread_Initialize+0x21c>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10d936: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10d93d: 00 00 00
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10d940: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10d942: 8a 45 e4 mov -0x1c(%ebp),%al 10d945: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10d94b: 8b 45 24 mov 0x24(%ebp),%eax 10d94e: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10d954: 8b 45 28 mov 0x28(%ebp),%eax 10d957: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10d95d: 8b 45 2c mov 0x2c(%ebp),%eax 10d960: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10d966: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10d96d: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10d974: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10d97b: 8b 45 1c mov 0x1c(%ebp),%eax 10d97e: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10d981: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
return
10d987: 83 ec 08 sub $0x8,%esp 10d98a: 53 push %ebx 10d98b: 68 60 65 12 00 push $0x126560 10d990: ff 15 74 65 12 00 call *0x126574 10d996: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread ); if ( !sched )
10d999: 83 c4 10 add $0x10,%esp 10d99c: 85 c0 test %eax,%eax
10d99e: 74 46 je 10d9e6 <_Thread_Initialize+0x156>
goto failed;
_Thread_Set_priority( the_thread, priority );
10d9a0: 83 ec 08 sub $0x8,%esp 10d9a3: ff 75 1c pushl 0x1c(%ebp) 10d9a6: 53 push %ebx 10d9a7: e8 64 06 00 00 call 10e010 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10d9ac: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10d9b3: 00 00 00
10d9b6: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10d9bd: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10d9c0: 8b 45 08 mov 0x8(%ebp),%eax 10d9c3: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10d9c6: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10d9ca: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10d9cd: 8b 45 30 mov 0x30(%ebp),%eax 10d9d0: 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 );
10d9d3: 89 1c 24 mov %ebx,(%esp) 10d9d6: e8 b1 0a 00 00 call 10e48c <_User_extensions_Thread_create>
if ( extension_status )
10d9db: 83 c4 10 add $0x10,%esp 10d9de: 84 c0 test %al,%al
10d9e0: 0f 85 9a 00 00 00 jne 10da80 <_Thread_Initialize+0x1f0>
return true;
failed:
if ( the_thread->libc_reent )
10d9e6: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10d9ec: 85 c0 test %eax,%eax
10d9ee: 74 0c je 10d9fc <_Thread_Initialize+0x16c>
_Workspace_Free( the_thread->libc_reent );
10d9f0: 83 ec 0c sub $0xc,%esp 10d9f3: 50 push %eax 10d9f4: e8 2b 0e 00 00 call 10e824 <_Workspace_Free> 10d9f9: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10d9fc: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10da02: 85 c0 test %eax,%eax
10da04: 74 0c je 10da12 <_Thread_Initialize+0x182>
_Workspace_Free( the_thread->API_Extensions[i] );
10da06: 83 ec 0c sub $0xc,%esp 10da09: 50 push %eax 10da0a: e8 15 0e 00 00 call 10e824 <_Workspace_Free> 10da0f: 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] )
10da12: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax 10da18: 85 c0 test %eax,%eax
10da1a: 74 0c je 10da28 <_Thread_Initialize+0x198><== ALWAYS TAKEN
_Workspace_Free( the_thread->API_Extensions[i] );
10da1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10da1f: 50 push %eax <== NOT EXECUTED 10da20: e8 ff 0d 00 00 call 10e824 <_Workspace_Free> <== NOT EXECUTED 10da25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( extensions_area )
10da28: 85 f6 test %esi,%esi
10da2a: 74 0c je 10da38 <_Thread_Initialize+0x1a8>
(void) _Workspace_Free( extensions_area );
10da2c: 83 ec 0c sub $0xc,%esp 10da2f: 56 push %esi 10da30: e8 ef 0d 00 00 call 10e824 <_Workspace_Free> 10da35: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10da38: 85 ff test %edi,%edi
10da3a: 74 0c je 10da48 <_Thread_Initialize+0x1b8>
(void) _Workspace_Free( fp_area );
10da3c: 83 ec 0c sub $0xc,%esp 10da3f: 57 push %edi 10da40: e8 df 0d 00 00 call 10e824 <_Workspace_Free> 10da45: 83 c4 10 add $0x10,%esp
#endif
if ( sched )
10da48: 8b 45 e4 mov -0x1c(%ebp),%eax 10da4b: 85 c0 test %eax,%eax
10da4d: 74 0e je 10da5d <_Thread_Initialize+0x1cd>
(void) _Workspace_Free( sched );
10da4f: 83 ec 0c sub $0xc,%esp 10da52: ff 75 e4 pushl -0x1c(%ebp) 10da55: e8 ca 0d 00 00 call 10e824 <_Workspace_Free> 10da5a: 83 c4 10 add $0x10,%esp
_Thread_Stack_Free( the_thread );
10da5d: 83 ec 0c sub $0xc,%esp 10da60: 53 push %ebx 10da61: e8 e2 06 00 00 call 10e148 <_Thread_Stack_Free>
return false;
10da66: 83 c4 10 add $0x10,%esp 10da69: 31 c0 xor %eax,%eax
}
10da6b: 8d 65 f4 lea -0xc(%ebp),%esp 10da6e: 5b pop %ebx 10da6f: 5e pop %esi 10da70: 5f pop %edi 10da71: c9 leave 10da72: c3 ret 10da73: 90 nop
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
10da74: 31 c0 xor %eax,%eax
_Thread_Stack_Free( the_thread );
return false;
}
10da76: 8d 65 f4 lea -0xc(%ebp),%esp 10da79: 5b pop %ebx 10da7a: 5e pop %esi 10da7b: 5f pop %edi 10da7c: c9 leave 10da7d: c3 ret 10da7e: 66 90 xchg %ax,%ax
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
10da80: b0 01 mov $0x1,%al 10da82: eb f2 jmp 10da76 <_Thread_Initialize+0x1e6>
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10da84: 83 ec 0c sub $0xc,%esp 10da87: 6a 6c push $0x6c 10da89: e8 7a 0d 00 00 call 10e808 <_Workspace_Allocate> 10da8e: 89 c7 mov %eax,%edi
if ( !fp_area )
10da90: 83 c4 10 add $0x10,%esp 10da93: 85 c0 test %eax,%eax
10da95: 0f 85 66 fe ff ff jne 10d901 <_Thread_Initialize+0x71>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10da9b: 31 f6 xor %esi,%esi
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
10da9d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10daa4: e9 3d ff ff ff jmp 10d9e6 <_Thread_Initialize+0x156> 10daa9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10daac: 83 ec 0c sub $0xc,%esp 10daaf: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10dab6: 50 push %eax 10dab7: e8 4c 0d 00 00 call 10e808 <_Workspace_Allocate> 10dabc: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10dabe: 83 c4 10 add $0x10,%esp 10dac1: 85 c0 test %eax,%eax
10dac3: 74 26 je 10daeb <_Thread_Initialize+0x25b>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dac5: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) 10dacb: 8b 0d 8c 65 12 00 mov 0x12658c,%ecx
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10dad1: 31 d2 xor %edx,%edx
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dad3: 31 c0 xor %eax,%eax 10dad5: 8d 76 00 lea 0x0(%esi),%esi
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
the_thread->extensions[i] = NULL;
10dad8: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10dadf: 40 inc %eax 10dae0: 89 c2 mov %eax,%edx 10dae2: 39 c1 cmp %eax,%ecx
10dae4: 73 f2 jae 10dad8 <_Thread_Initialize+0x248>
10dae6: e9 57 fe ff ff jmp 10d942 <_Thread_Initialize+0xb2>
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
10daeb: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10daf2: e9 ef fe ff ff jmp 10d9e6 <_Thread_Initialize+0x156>
00111a54 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
111a54: 55 push %ebp 111a55: 89 e5 mov %esp,%ebp 111a57: 53 push %ebx 111a58: 83 ec 10 sub $0x10,%esp 111a5b: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
111a5e: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
111a65: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 111a6b: 88 43 74 mov %al,0x74(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
111a6e: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 111a74: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
111a77: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 111a7d: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
111a83: 8b 45 0c mov 0xc(%ebp),%eax 111a86: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
111a8c: 8b 45 10 mov 0x10(%ebp),%eax 111a8f: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
111a95: 53 push %ebx 111a96: e8 5d cf ff ff call 10e9f8 <_Thread_queue_Extract_with_proxy> 111a9b: 83 c4 10 add $0x10,%esp 111a9e: 84 c0 test %al,%al
111aa0: 75 06 jne 111aa8 <_Thread_Reset+0x54>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
111aa2: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
111aa6: 74 28 je 111ad0 <_Thread_Reset+0x7c>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
111aa8: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 111aae: 39 43 14 cmp %eax,0x14(%ebx)
111ab1: 74 15 je 111ac8 <_Thread_Reset+0x74>
the_thread->real_priority = the_thread->Start.initial_priority;
111ab3: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
111ab6: 89 45 0c mov %eax,0xc(%ebp) 111ab9: 89 5d 08 mov %ebx,0x8(%ebp)
} }
111abc: 8b 5d fc mov -0x4(%ebp),%ebx 111abf: c9 leave
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
111ac0: e9 0f d1 ff ff jmp 10ebd4 <_Thread_Set_priority> 111ac5: 8d 76 00 lea 0x0(%esi),%esi
} }
111ac8: 8b 5d fc mov -0x4(%ebp),%ebx 111acb: c9 leave 111acc: c3 ret 111acd: 8d 76 00 lea 0x0(%esi),%esi
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
111ad0: 83 ec 0c sub $0xc,%esp 111ad3: 8d 43 48 lea 0x48(%ebx),%eax 111ad6: 50 push %eax 111ad7: e8 08 d8 ff ff call 10f2e4 <_Watchdog_Remove> 111adc: 83 c4 10 add $0x10,%esp 111adf: eb c7 jmp 111aa8 <_Thread_Reset+0x54>
00111348 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
111348: 55 push %ebp 111349: 89 e5 mov %esp,%ebp 11134b: 53 push %ebx 11134c: 83 ec 04 sub $0x4,%esp 11134f: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
111352: 9c pushf 111353: fa cli 111354: 5b pop %ebx
current_state = the_thread->current_state;
111355: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
111358: f6 c2 02 test $0x2,%dl
11135b: 74 0a je 111367 <_Thread_Resume+0x1f> <== NEVER TAKEN
11135d: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
111360: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
111363: 85 d2 test %edx,%edx
111365: 74 09 je 111370 <_Thread_Resume+0x28>
_Scheduler_Unblock( &_Scheduler, the_thread );
}
}
_ISR_Enable( level );
111367: 53 push %ebx 111368: 9d popf
}
111369: 8b 5d fc mov -0x4(%ebp),%ebx 11136c: c9 leave 11136d: c3 ret 11136e: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.unblock( the_scheduler, the_thread );
111370: 83 ec 08 sub $0x8,%esp 111373: 50 push %eax 111374: 68 40 96 12 00 push $0x129640 111379: ff 15 50 96 12 00 call *0x129650 11137f: 83 c4 10 add $0x10,%esp 111382: eb e3 jmp 111367 <_Thread_Resume+0x1f>
0010e0e4 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10e0e4: 55 push %ebp 10e0e5: 89 e5 mov %esp,%ebp 10e0e7: 53 push %ebx 10e0e8: 83 ec 04 sub $0x4,%esp
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
the_stack_size = 0;
10e0eb: a1 10 22 12 00 mov 0x122210,%eax 10e0f0: 8b 5d 0c mov 0xc(%ebp),%ebx 10e0f3: 39 c3 cmp %eax,%ebx
10e0f5: 73 02 jae 10e0f9 <_Thread_Stack_Allocate+0x15>
10e0f7: 89 c3 mov %eax,%ebx
* Call ONLY the CPU table stack allocate hook, _or_ the
* the RTEMS workspace allocate. This is so the stack free
* routine can call the correct deallocation routine.
*/
if ( Configuration.stack_allocate_hook ) {
10e0f9: a1 44 22 12 00 mov 0x122244,%eax 10e0fe: 85 c0 test %eax,%eax
10e100: 74 32 je 10e134 <_Thread_Stack_Allocate+0x50>
stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size );
10e102: 83 ec 0c sub $0xc,%esp 10e105: 53 push %ebx 10e106: ff d0 call *%eax 10e108: 83 c4 10 add $0x10,%esp
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
10e10b: 85 c0 test %eax,%eax
10e10d: 74 11 je 10e120 <_Thread_Stack_Allocate+0x3c>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10e10f: 8b 55 08 mov 0x8(%ebp),%edx 10e112: 89 82 c0 00 00 00 mov %eax,0xc0(%edx)
return the_stack_size;
}
10e118: 89 d8 mov %ebx,%eax 10e11a: 8b 5d fc mov -0x4(%ebp),%ebx 10e11d: c9 leave 10e11e: c3 ret 10e11f: 90 nop
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
the_stack_size = 0;
10e120: 31 db xor %ebx,%ebx
the_thread->Start.stack = stack_addr;
10e122: 8b 55 08 mov 0x8(%ebp),%edx 10e125: 89 82 c0 00 00 00 mov %eax,0xc0(%edx)
return the_stack_size;
}
10e12b: 89 d8 mov %ebx,%eax 10e12d: 8b 5d fc mov -0x4(%ebp),%ebx 10e130: c9 leave 10e131: c3 ret 10e132: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size (
size_t size
)
{
return size + CPU_STACK_ALIGNMENT;
10e134: 83 c3 10 add $0x10,%ebx
* get and keep the stack adjust factor, the stack alignment, and
* the context initialization sequence in sync.
*/
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
10e137: 83 ec 0c sub $0xc,%esp 10e13a: 53 push %ebx 10e13b: e8 c8 06 00 00 call 10e808 <_Workspace_Allocate> 10e140: 83 c4 10 add $0x10,%esp 10e143: eb c6 jmp 10e10b <_Thread_Stack_Allocate+0x27>
0010e148 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10e148: 55 push %ebp 10e149: 89 e5 mov %esp,%ebp 10e14b: 83 ec 08 sub $0x8,%esp 10e14e: 8b 55 08 mov 0x8(%ebp),%edx
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
10e151: a1 48 22 12 00 mov 0x122248,%eax 10e156: 85 c0 test %eax,%eax
10e158: 74 0e je 10e168 <_Thread_Stack_Free+0x20>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10e15a: 8b 92 b8 00 00 00 mov 0xb8(%edx),%edx 10e160: 89 55 08 mov %edx,0x8(%ebp)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e163: c9 leave
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10e164: ff e0 jmp *%eax 10e166: 66 90 xchg %ax,%ax
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10e168: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 10e16e: 89 45 08 mov %eax,0x8(%ebp)
}
10e171: c9 leave
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10e172: e9 ad 06 00 00 jmp 10e824 <_Workspace_Free>
00110dcc <_Thread_Suspend>:
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
110dcc: 55 push %ebp 110dcd: 89 e5 mov %esp,%ebp 110dcf: 53 push %ebx 110dd0: 83 ec 04 sub $0x4,%esp 110dd3: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
_ISR_Disable( level );
110dd6: 9c pushf 110dd7: fa cli 110dd8: 5b pop %ebx
if ( !_States_Is_ready( the_thread->current_state ) ) {
110dd9: 8b 50 10 mov 0x10(%eax),%edx 110ddc: 85 d2 test %edx,%edx
110dde: 74 10 je 110df0 <_Thread_Suspend+0x24>
110de0: 83 ca 02 or $0x2,%edx 110de3: 89 50 10 mov %edx,0x10(%eax)
the_thread->current_state =
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
110de6: 53 push %ebx 110de7: 9d popf
the_thread->current_state = STATES_SUSPENDED;
_Scheduler_Block(&_Scheduler, the_thread);
_ISR_Enable( level );
}
110de8: 8b 5d fc mov -0x4(%ebp),%ebx 110deb: c9 leave 110dec: c3 ret 110ded: 8d 76 00 lea 0x0(%esi),%esi
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
110df0: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax)
RTEMS_INLINE_ROUTINE void _Scheduler_Block(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.block( the_scheduler, the_thread );
110df7: 83 ec 08 sub $0x8,%esp 110dfa: 50 push %eax 110dfb: 68 60 65 12 00 push $0x126560 110e00: ff 15 6c 65 12 00 call *0x12656c
_Scheduler_Block(&_Scheduler, the_thread);
_ISR_Enable( level );
110e06: 53 push %ebx 110e07: 9d popf 110e08: 83 c4 10 add $0x10,%esp
}
110e0b: 8b 5d fc mov -0x4(%ebp),%ebx 110e0e: c9 leave 110e0f: c3 ret
0010e234 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10e234: 55 push %ebp 10e235: 89 e5 mov %esp,%ebp 10e237: 53 push %ebx 10e238: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10e23b: 8b 1d 78 67 12 00 mov 0x126778,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10e241: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10e245: 74 0d je 10e254 <_Thread_Tickle_timeslice+0x20>
return;
if ( !_States_Is_ready( executing->current_state ) )
10e247: 8b 43 10 mov 0x10(%ebx),%eax 10e24a: 85 c0 test %eax,%eax
10e24c: 75 06 jne 10e254 <_Thread_Tickle_timeslice+0x20>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10e24e: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx)
10e252: 74 08 je 10e25c <_Thread_Tickle_timeslice+0x28>
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
10e254: 8b 5d fc mov -0x4(%ebp),%ebx 10e257: c9 leave 10e258: c3 ret 10e259: 8d 76 00 lea 0x0(%esi),%esi
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 ) {
10e25c: 8b 43 78 mov 0x78(%ebx),%eax 10e25f: 48 dec %eax 10e260: 89 43 78 mov %eax,0x78(%ebx) 10e263: 85 c0 test %eax,%eax
10e265: 7f ed jg 10e254 <_Thread_Tickle_timeslice+0x20>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield( &_Scheduler );
10e267: 83 ec 0c sub $0xc,%esp 10e26a: 68 60 65 12 00 push $0x126560 10e26f: ff 15 68 65 12 00 call *0x126568
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield( );
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10e275: a1 80 64 12 00 mov 0x126480,%eax 10e27a: 89 43 78 mov %eax,0x78(%ebx) 10e27d: 83 c4 10 add $0x10,%esp 10e280: eb d2 jmp 10e254 <_Thread_Tickle_timeslice+0x20>
0010dbd0 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10dbd0: 55 push %ebp 10dbd1: 89 e5 mov %esp,%ebp 10dbd3: 57 push %edi 10dbd4: 56 push %esi 10dbd5: 53 push %ebx 10dbd6: 83 ec 2c sub $0x2c,%esp 10dbd9: 8b 7d 08 mov 0x8(%ebp),%edi
Chain_Node *new_second_node;
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
10dbdc: 9c pushf 10dbdd: fa cli 10dbde: 58 pop %eax 10dbdf: 89 f9 mov %edi,%ecx
for( index=0 ;
10dbe1: 31 d2 xor %edx,%edx
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10dbe3: 8b 19 mov (%ecx),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10dbe5: 8d 34 52 lea (%edx,%edx,2),%esi 10dbe8: 8d 74 b7 04 lea 0x4(%edi,%esi,4),%esi
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
10dbec: 39 f3 cmp %esi,%ebx
10dbee: 75 18 jne 10dc08 <_Thread_queue_Dequeue_priority+0x38>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10dbf0: 42 inc %edx 10dbf1: 83 c1 0c add $0xc,%ecx
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
10dbf4: 83 fa 04 cmp $0x4,%edx
10dbf7: 75 ea jne 10dbe3 <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10dbf9: 50 push %eax 10dbfa: 9d popf
return NULL;
10dbfb: 31 f6 xor %esi,%esi
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10dbfd: 89 f0 mov %esi,%eax 10dbff: 8d 65 f4 lea -0xc(%ebp),%esp 10dc02: 5b pop %ebx 10dc03: 5e pop %esi 10dc04: 5f pop %edi 10dc05: c9 leave 10dc06: c3 ret 10dc07: 90 nop
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
the_thread = (Thread_Control *) _Chain_First(
10dc08: 89 de mov %ebx,%esi
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10dc0a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10dc11: 8b 53 38 mov 0x38(%ebx),%edx
dequeue:
the_thread->Wait.queue = NULL;
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
10dc14: 8b 0b mov (%ebx),%ecx
previous_node = the_thread->Object.Node.previous;
10dc16: 8b 7b 04 mov 0x4(%ebx),%edi 10dc19: 89 7d d4 mov %edi,-0x2c(%ebp) 10dc1c: 8d 7b 3c lea 0x3c(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10dc1f: 39 fa cmp %edi,%edx
10dc21: 74 7f je 10dca2 <_Thread_queue_Dequeue_priority+0xd2>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10dc23: 8b 7b 40 mov 0x40(%ebx),%edi 10dc26: 89 7d e4 mov %edi,-0x1c(%ebp)
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
10dc29: 8b 3a mov (%edx),%edi 10dc2b: 89 7d e0 mov %edi,-0x20(%ebp)
previous_node->next = new_first_node;
10dc2e: 8b 7d d4 mov -0x2c(%ebp),%edi 10dc31: 89 17 mov %edx,(%edi)
next_node->previous = new_first_node;
10dc33: 89 51 04 mov %edx,0x4(%ecx)
new_first_node->next = next_node;
10dc36: 89 0a mov %ecx,(%edx)
new_first_node->previous = previous_node;
10dc38: 89 7a 04 mov %edi,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10dc3b: 8b 4b 40 mov 0x40(%ebx),%ecx 10dc3e: 39 4b 38 cmp %ecx,0x38(%ebx)
10dc41: 74 17 je 10dc5a <_Thread_queue_Dequeue_priority+0x8a>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
10dc43: 8d 4a 38 lea 0x38(%edx),%ecx 10dc46: 8b 7d e0 mov -0x20(%ebp),%edi 10dc49: 89 4f 04 mov %ecx,0x4(%edi)
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
10dc4c: 89 7a 38 mov %edi,0x38(%edx)
tail->previous = last_node;
10dc4f: 8b 4d e4 mov -0x1c(%ebp),%ecx 10dc52: 89 4a 40 mov %ecx,0x40(%edx)
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
10dc55: 83 c2 3c add $0x3c,%edx 10dc58: 89 11 mov %edx,(%ecx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10dc5a: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10dc5e: 74 18 je 10dc78 <_Thread_queue_Dequeue_priority+0xa8>
_ISR_Enable( level );
10dc60: 50 push %eax 10dc61: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10dc62: 83 ec 08 sub $0x8,%esp 10dc65: 68 f8 ff 03 10 push $0x1003fff8 10dc6a: 53 push %ebx 10dc6b: e8 04 f8 ff ff call 10d474 <_Thread_Clear_state> 10dc70: 83 c4 10 add $0x10,%esp 10dc73: eb 88 jmp 10dbfd <_Thread_queue_Dequeue_priority+0x2d> 10dc75: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10dc78: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10dc7f: 50 push %eax 10dc80: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10dc81: 83 ec 0c sub $0xc,%esp 10dc84: 8d 43 48 lea 0x48(%ebx),%eax 10dc87: 50 push %eax 10dc88: e8 53 0a 00 00 call 10e6e0 <_Watchdog_Remove> 10dc8d: 58 pop %eax 10dc8e: 5a pop %edx 10dc8f: 68 f8 ff 03 10 push $0x1003fff8 10dc94: 53 push %ebx 10dc95: e8 da f7 ff ff call 10d474 <_Thread_Clear_state> 10dc9a: 83 c4 10 add $0x10,%esp 10dc9d: e9 5b ff ff ff jmp 10dbfd <_Thread_queue_Dequeue_priority+0x2d>
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
10dca2: 8b 7d d4 mov -0x2c(%ebp),%edi 10dca5: 89 0f mov %ecx,(%edi)
next_node->previous = previous_node;
10dca7: 89 79 04 mov %edi,0x4(%ecx) 10dcaa: eb ae jmp 10dc5a <_Thread_queue_Dequeue_priority+0x8a>
0010dd44 <_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
)
{
10dd44: 55 push %ebp 10dd45: 89 e5 mov %esp,%ebp 10dd47: 57 push %edi 10dd48: 56 push %esi 10dd49: 53 push %ebx 10dd4a: 83 ec 0c sub $0xc,%esp 10dd4d: 8b 7d 0c mov 0xc(%ebp),%edi
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10dd50: 8d 47 3c lea 0x3c(%edi),%eax 10dd53: 89 47 38 mov %eax,0x38(%edi)
head->next = tail;
head->previous = NULL;
10dd56: c7 47 3c 00 00 00 00 movl $0x0,0x3c(%edi)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10dd5d: 8d 47 38 lea 0x38(%edi),%eax 10dd60: 89 47 40 mov %eax,0x40(%edi)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10dd63: 8b 57 14 mov 0x14(%edi),%edx
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
10dd66: 89 d0 mov %edx,%eax 10dd68: c1 e8 06 shr $0x6,%eax
header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state;
10dd6b: 8b 4d 08 mov 0x8(%ebp),%ecx 10dd6e: 8b 59 38 mov 0x38(%ecx),%ebx
if ( _Thread_queue_Is_reverse_search( priority ) )
10dd71: f6 c2 20 test $0x20,%dl
10dd74: 75 66 jne 10dddc <_Thread_queue_Enqueue_priority+0x98> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10dd76: 8d 04 40 lea (%eax,%eax,2),%eax 10dd79: 8d 04 81 lea (%ecx,%eax,4),%eax 10dd7c: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10dd7f: 83 c0 04 add $0x4,%eax 10dd82: 89 7d e8 mov %edi,-0x18(%ebp) 10dd85: 89 c7 mov %eax,%edi
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10dd87: 9c pushf 10dd88: fa cli 10dd89: 5e pop %esi 10dd8a: 89 75 ec mov %esi,-0x14(%ebp)
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10dd8d: 8b 4d f0 mov -0x10(%ebp),%ecx 10dd90: 8b 01 mov (%ecx),%eax
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10dd92: 39 f8 cmp %edi,%eax
10dd94: 75 18 jne 10ddae <_Thread_queue_Enqueue_priority+0x6a>
10dd96: e9 0e 01 00 00 jmp 10dea9 <_Thread_queue_Enqueue_priority+0x165> 10dd9b: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10dd9c: 56 push %esi 10dd9d: 9d popf 10dd9e: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10dd9f: 85 58 10 test %ebx,0x10(%eax)
10dda2: 0f 84 ac 00 00 00 je 10de54 <_Thread_queue_Enqueue_priority+0x110>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10dda8: 8b 00 mov (%eax),%eax
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10ddaa: 39 f8 cmp %edi,%eax
10ddac: 74 07 je 10ddb5 <_Thread_queue_Enqueue_priority+0x71>
search_priority = search_thread->current_priority;
10ddae: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority <= search_priority )
10ddb1: 39 ca cmp %ecx,%edx
10ddb3: 77 e7 ja 10dd9c <_Thread_queue_Enqueue_priority+0x58>
10ddb5: 8b 7d e8 mov -0x18(%ebp),%edi 10ddb8: 89 75 f0 mov %esi,-0x10(%ebp)
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10ddbb: 8b 75 08 mov 0x8(%ebp),%esi 10ddbe: 8b 5e 30 mov 0x30(%esi),%ebx 10ddc1: 83 fb 01 cmp $0x1,%ebx
10ddc4: 0f 84 92 00 00 00 je 10de5c <_Thread_queue_Enqueue_priority+0x118> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
10ddca: 8b 45 10 mov 0x10(%ebp),%eax 10ddcd: 8b 55 ec mov -0x14(%ebp),%edx 10ddd0: 89 10 mov %edx,(%eax)
return the_thread_queue->sync_state; }
10ddd2: 89 d8 mov %ebx,%eax 10ddd4: 83 c4 0c add $0xc,%esp 10ddd7: 5b pop %ebx 10ddd8: 5e pop %esi 10ddd9: 5f pop %edi 10ddda: c9 leave 10dddb: c3 ret 10dddc: 8d 04 40 lea (%eax,%eax,2),%eax 10dddf: 8b 4d 08 mov 0x8(%ebp),%ecx 10dde2: 8d 34 81 lea (%ecx,%eax,4),%esi 10dde5: 89 7d f0 mov %edi,-0x10(%ebp)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10dde8: 0f b6 0d 14 22 12 00 movzbl 0x122214,%ecx 10ddef: 41 inc %ecx
_ISR_Disable( level );
10ddf0: 9c pushf 10ddf1: fa cli 10ddf2: 5f pop %edi 10ddf3: 89 7d ec mov %edi,-0x14(%ebp)
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10ddf6: 8b 46 08 mov 0x8(%esi),%eax
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10ddf9: 39 f0 cmp %esi,%eax
10ddfb: 75 12 jne 10de0f <_Thread_queue_Enqueue_priority+0xcb>
10ddfd: eb 17 jmp 10de16 <_Thread_queue_Enqueue_priority+0xd2> 10ddff: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10de00: 57 push %edi 10de01: 9d popf 10de02: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10de03: 85 58 10 test %ebx,0x10(%eax)
10de06: 74 48 je 10de50 <_Thread_queue_Enqueue_priority+0x10c><== NEVER TAKEN
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10de08: 8b 40 04 mov 0x4(%eax),%eax
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10de0b: 39 f0 cmp %esi,%eax
10de0d: 74 07 je 10de16 <_Thread_queue_Enqueue_priority+0xd2>
search_priority = search_thread->current_priority;
10de0f: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority >= search_priority )
10de12: 39 ca cmp %ecx,%edx
10de14: 72 ea jb 10de00 <_Thread_queue_Enqueue_priority+0xbc>
10de16: 89 7d e8 mov %edi,-0x18(%ebp) 10de19: 8b 7d f0 mov -0x10(%ebp),%edi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10de1c: 8b 75 08 mov 0x8(%ebp),%esi 10de1f: 8b 5e 30 mov 0x30(%esi),%ebx 10de22: 83 fb 01 cmp $0x1,%ebx
10de25: 75 a3 jne 10ddca <_Thread_queue_Enqueue_priority+0x86>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10de27: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10de2e: 39 ca cmp %ecx,%edx
10de30: 74 53 je 10de85 <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10de32: 8b 10 mov (%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10de34: 89 17 mov %edx,(%edi)
the_node->previous = search_node;
10de36: 89 47 04 mov %eax,0x4(%edi)
search_node->next = the_node;
10de39: 89 38 mov %edi,(%eax)
next_node->previous = the_node;
10de3b: 89 7a 04 mov %edi,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10de3e: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10de41: ff 75 e8 pushl -0x18(%ebp) 10de44: 9d popf
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10de45: 89 d8 mov %ebx,%eax 10de47: 83 c4 0c add $0xc,%esp 10de4a: 5b pop %ebx 10de4b: 5e pop %esi 10de4c: 5f pop %edi 10de4d: c9 leave 10de4e: c3 ret 10de4f: 90 nop
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10de50: 57 push %edi <== NOT EXECUTED 10de51: 9d popf <== NOT EXECUTED
goto restart_reverse_search;
10de52: eb 94 jmp 10dde8 <_Thread_queue_Enqueue_priority+0xa4><== NOT EXECUTED
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10de54: 56 push %esi 10de55: 9d popf
goto restart_forward_search;
10de56: e9 2c ff ff ff jmp 10dd87 <_Thread_queue_Enqueue_priority+0x43> 10de5b: 90 nop
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10de5c: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10de63: 39 ca cmp %ecx,%edx
10de65: 74 1e je 10de85 <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10de67: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10de6a: 89 07 mov %eax,(%edi)
the_node->previous = previous_node;
10de6c: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10de6f: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10de71: 89 78 04 mov %edi,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10de74: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10de77: ff 75 f0 pushl -0x10(%ebp) 10de7a: 9d popf
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
10de7b: 89 d8 mov %ebx,%eax 10de7d: 83 c4 0c add $0xc,%esp 10de80: 5b pop %ebx 10de81: 5e pop %esi 10de82: 5f pop %edi 10de83: c9 leave 10de84: c3 ret
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10de85: 8b 50 40 mov 0x40(%eax),%edx
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
10de88: 8d 48 3c lea 0x3c(%eax),%ecx 10de8b: 89 0f mov %ecx,(%edi)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
10de8d: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10de90: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10de92: 89 78 40 mov %edi,0x40(%eax)
the_thread->Wait.queue = the_thread_queue;
10de95: 8b 45 08 mov 0x8(%ebp),%eax 10de98: 89 47 44 mov %eax,0x44(%edi)
_ISR_Enable( level );
10de9b: ff 75 ec pushl -0x14(%ebp) 10de9e: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10de9f: bb 01 00 00 00 mov $0x1,%ebx 10dea4: e9 29 ff ff ff jmp 10ddd2 <_Thread_queue_Enqueue_priority+0x8e> 10dea9: 8b 7d e8 mov -0x18(%ebp),%edi 10deac: 89 75 f0 mov %esi,-0x10(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10deaf: b9 ff ff ff ff mov $0xffffffff,%ecx 10deb4: e9 02 ff ff ff jmp 10ddbb <_Thread_queue_Enqueue_priority+0x77>
00110c70 <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
110c70: 55 push %ebp 110c71: 89 e5 mov %esp,%ebp 110c73: 83 ec 08 sub $0x8,%esp 110c76: 8b 45 08 mov 0x8(%ebp),%eax 110c79: 8b 55 0c mov 0xc(%ebp),%edx
/* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
110c7c: 83 78 34 01 cmpl $0x1,0x34(%eax)
110c80: 74 0e je 110c90 <_Thread_queue_Extract+0x20>
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
110c82: 89 55 0c mov %edx,0xc(%ebp) 110c85: 89 45 08 mov %eax,0x8(%ebp)
}
110c88: c9 leave
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
110c89: e9 f6 15 00 00 jmp 112284 <_Thread_queue_Extract_fifo> 110c8e: 66 90 xchg %ax,%ax
/*
* Can not use indirect function pointer here since Extract priority
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
110c90: 51 push %ecx 110c91: 6a 00 push $0x0 110c93: 52 push %edx 110c94: 50 push %eax 110c95: e8 06 00 00 00 call 110ca0 <_Thread_queue_Extract_priority_helper> 110c9a: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
110c9d: c9 leave 110c9e: c3 ret
00112284 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
112284: 55 push %ebp 112285: 89 e5 mov %esp,%ebp 112287: 53 push %ebx 112288: 83 ec 04 sub $0x4,%esp 11228b: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
11228e: 9c pushf 11228f: fa cli 112290: 58 pop %eax
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
112291: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
112298: 74 2e je 1122c8 <_Thread_queue_Extract_fifo+0x44>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
11229a: 8b 0b mov (%ebx),%ecx
previous = the_node->previous;
11229c: 8b 53 04 mov 0x4(%ebx),%edx
next->previous = previous;
11229f: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
1122a2: 89 0a mov %ecx,(%edx)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
1122a4: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
1122ab: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1122af: 74 1f je 1122d0 <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
1122b1: 50 push %eax 1122b2: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
1122b3: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 1122ba: 89 5d 08 mov %ebx,0x8(%ebp)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1122bd: 8b 5d fc mov -0x4(%ebp),%ebx 1122c0: c9 leave 1122c1: e9 ae b1 ff ff jmp 10d474 <_Thread_Clear_state> 1122c6: 66 90 xchg %ax,%ax
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
1122c8: 50 push %eax 1122c9: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1122ca: 8b 5d fc mov -0x4(%ebp),%ebx 1122cd: c9 leave 1122ce: c3 ret 1122cf: 90 nop 1122d0: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
1122d7: 50 push %eax 1122d8: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
1122d9: 83 ec 0c sub $0xc,%esp 1122dc: 8d 43 48 lea 0x48(%ebx),%eax 1122df: 50 push %eax 1122e0: e8 fb c3 ff ff call 10e6e0 <_Watchdog_Remove> 1122e5: 83 c4 10 add $0x10,%esp 1122e8: eb c9 jmp 1122b3 <_Thread_queue_Extract_fifo+0x2f>
00110ca0 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread,
bool requeuing
)
{
110ca0: 55 push %ebp 110ca1: 89 e5 mov %esp,%ebp 110ca3: 57 push %edi 110ca4: 56 push %esi 110ca5: 53 push %ebx 110ca6: 83 ec 1c sub $0x1c,%esp 110ca9: 8b 5d 0c mov 0xc(%ebp),%ebx 110cac: 8a 45 10 mov 0x10(%ebp),%al 110caf: 88 45 e3 mov %al,-0x1d(%ebp)
Chain_Node *new_first_node;
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
110cb2: 9c pushf 110cb3: fa cli 110cb4: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
110cb7: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
110cbe: 74 6c je 110d2c <_Thread_queue_Extract_priority_helper+0x8c>
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
110cc0: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
110cc2: 8b 4b 04 mov 0x4(%ebx),%ecx
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
110cc5: 8b 43 38 mov 0x38(%ebx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
110cc8: 8d 73 3c lea 0x3c(%ebx),%esi
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
110ccb: 39 f0 cmp %esi,%eax
110ccd: 74 69 je 110d38 <_Thread_queue_Extract_priority_helper+0x98>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
110ccf: 8b 7b 40 mov 0x40(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
110cd2: 8b 30 mov (%eax),%esi
previous_node->next = new_first_node;
110cd4: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
110cd6: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
110cd9: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
110cdb: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
110cde: 8b 53 40 mov 0x40(%ebx),%edx 110ce1: 39 53 38 cmp %edx,0x38(%ebx)
110ce4: 74 11 je 110cf7 <_Thread_queue_Extract_priority_helper+0x57>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
110ce6: 8d 50 38 lea 0x38(%eax),%edx 110ce9: 89 56 04 mov %edx,0x4(%esi)
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
110cec: 89 70 38 mov %esi,0x38(%eax)
tail->previous = last_node;
110cef: 89 78 40 mov %edi,0x40(%eax)
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
110cf2: 83 c0 3c add $0x3c,%eax 110cf5: 89 07 mov %eax,(%edi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
110cf7: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
110cfb: 75 23 jne 110d20 <_Thread_queue_Extract_priority_helper+0x80>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
110cfd: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
110d01: 74 3d je 110d40 <_Thread_queue_Extract_priority_helper+0xa0>
_ISR_Enable( level );
110d03: ff 75 e4 pushl -0x1c(%ebp) 110d06: 9d popf 110d07: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 110d0e: 89 5d 08 mov %ebx,0x8(%ebp)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
110d11: 8d 65 f4 lea -0xc(%ebp),%esp 110d14: 5b pop %ebx 110d15: 5e pop %esi 110d16: 5f pop %edi 110d17: c9 leave 110d18: e9 57 c7 ff ff jmp 10d474 <_Thread_Clear_state> 110d1d: 8d 76 00 lea 0x0(%esi),%esi
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
_ISR_Enable( level );
110d20: ff 75 e4 pushl -0x1c(%ebp) 110d23: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
110d24: 8d 65 f4 lea -0xc(%ebp),%esp 110d27: 5b pop %ebx 110d28: 5e pop %esi 110d29: 5f pop %edi 110d2a: c9 leave 110d2b: c3 ret
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
110d2c: ff 75 e4 pushl -0x1c(%ebp) 110d2f: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
110d30: 8d 65 f4 lea -0xc(%ebp),%esp 110d33: 5b pop %ebx 110d34: 5e pop %esi 110d35: 5f pop %edi 110d36: c9 leave 110d37: c3 ret
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
110d38: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
110d3a: 89 4a 04 mov %ecx,0x4(%edx) 110d3d: eb b8 jmp 110cf7 <_Thread_queue_Extract_priority_helper+0x57> 110d3f: 90 nop 110d40: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
110d47: ff 75 e4 pushl -0x1c(%ebp) 110d4a: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
110d4b: 83 ec 0c sub $0xc,%esp 110d4e: 8d 43 48 lea 0x48(%ebx),%eax 110d51: 50 push %eax 110d52: e8 89 d9 ff ff call 10e6e0 <_Watchdog_Remove> 110d57: 83 c4 10 add $0x10,%esp 110d5a: eb ab jmp 110d07 <_Thread_queue_Extract_priority_helper+0x67>
0010debc <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10debc: 55 push %ebp 10debd: 89 e5 mov %esp,%ebp 10debf: 83 ec 08 sub $0x8,%esp 10dec2: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10dec5: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10decc: 75 06 jne 10ded4 <_Thread_queue_Extract_with_proxy+0x18>
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return true;
}
return false;
10dece: 31 c0 xor %eax,%eax
}
10ded0: c9 leave 10ded1: c3 ret 10ded2: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10ded4: 83 ec 08 sub $0x8,%esp 10ded7: 50 push %eax 10ded8: ff 70 44 pushl 0x44(%eax) 10dedb: e8 90 2d 00 00 call 110c70 <_Thread_queue_Extract>
return true;
10dee0: 83 c4 10 add $0x10,%esp 10dee3: b0 01 mov $0x1,%al
} return false; }
10dee5: c9 leave 10dee6: c3 ret
0011f0bc <_Thread_queue_First>:
*/
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue
)
{
11f0bc: 55 push %ebp 11f0bd: 89 e5 mov %esp,%ebp 11f0bf: 83 ec 08 sub $0x8,%esp 11f0c2: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
11f0c5: 83 78 34 01 cmpl $0x1,0x34(%eax)
11f0c9: 74 0d je 11f0d8 <_Thread_queue_First+0x1c>
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
11f0cb: ba 50 04 12 00 mov $0x120450,%edx
return (*first_p)( the_thread_queue );
11f0d0: 89 45 08 mov %eax,0x8(%ebp)
}
11f0d3: c9 leave
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
11f0d4: ff e2 jmp *%edx 11f0d6: 66 90 xchg %ax,%ax
)
{
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
first_p = _Thread_queue_First_priority;
11f0d8: ba e4 f0 11 00 mov $0x11f0e4,%edx
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
11f0dd: 89 45 08 mov %eax,0x8(%ebp)
}
11f0e0: c9 leave
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
11f0e1: ff e2 jmp *%edx
00120450 <_Thread_queue_First_fifo>:
*/
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
120450: 55 push %ebp 120451: 89 e5 mov %esp,%ebp 120453: 8b 55 08 mov 0x8(%ebp),%edx
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
120456: 8b 02 mov (%edx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
120458: 83 c2 04 add $0x4,%edx
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
12045b: 39 d0 cmp %edx,%eax
12045d: 74 05 je 120464 <_Thread_queue_First_fifo+0x14>
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
12045f: c9 leave 120460: c3 ret 120461: 8d 76 00 lea 0x0(%esi),%esi
)
{
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
120464: 31 c0 xor %eax,%eax
}
120466: c9 leave 120467: c3 ret
0010dee8 <_Thread_queue_Flush>:
#else
Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)),
#endif
uint32_t status
)
{
10dee8: 55 push %ebp 10dee9: 89 e5 mov %esp,%ebp 10deeb: 56 push %esi 10deec: 53 push %ebx 10deed: 8b 5d 08 mov 0x8(%ebp),%ebx 10def0: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10def3: eb 06 jmp 10defb <_Thread_queue_Flush+0x13> 10def5: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
10def8: 89 70 34 mov %esi,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10defb: 83 ec 0c sub $0xc,%esp 10defe: 53 push %ebx 10deff: e8 80 fc ff ff call 10db84 <_Thread_queue_Dequeue> 10df04: 83 c4 10 add $0x10,%esp 10df07: 85 c0 test %eax,%eax
10df09: 75 ed jne 10def8 <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10df0b: 8d 65 f8 lea -0x8(%ebp),%esp 10df0e: 5b pop %ebx 10df0f: 5e pop %esi 10df10: c9 leave 10df11: c3 ret
0010df14 <_Thread_queue_Initialize>:
Thread_queue_Control *the_thread_queue,
Thread_queue_Disciplines the_discipline,
States_Control state,
uint32_t timeout_status
)
{
10df14: 55 push %ebp 10df15: 89 e5 mov %esp,%ebp 10df17: 56 push %esi 10df18: 53 push %ebx 10df19: 8b 45 08 mov 0x8(%ebp),%eax 10df1c: 8b 55 0c mov 0xc(%ebp),%edx
the_thread_queue->state = state;
10df1f: 8b 4d 10 mov 0x10(%ebp),%ecx 10df22: 89 48 38 mov %ecx,0x38(%eax)
the_thread_queue->discipline = the_discipline;
10df25: 89 50 34 mov %edx,0x34(%eax)
the_thread_queue->timeout_status = timeout_status;
10df28: 8b 4d 14 mov 0x14(%ebp),%ecx 10df2b: 89 48 3c mov %ecx,0x3c(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10df2e: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10df35: 83 fa 01 cmp $0x1,%edx
10df38: 74 16 je 10df50 <_Thread_queue_Initialize+0x3c>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10df3a: 8d 50 04 lea 0x4(%eax),%edx 10df3d: 89 10 mov %edx,(%eax)
head->next = tail;
head->previous = NULL;
10df3f: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10df46: 89 40 08 mov %eax,0x8(%eax)
_Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] );
} else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Chain_Initialize_empty( &the_thread_queue->Queues.Fifo );
}
}
10df49: 5b pop %ebx 10df4a: 5e pop %esi 10df4b: c9 leave 10df4c: c3 ret 10df4d: 8d 76 00 lea 0x0(%esi),%esi
the_thread_queue->state = state;
the_thread_queue->discipline = the_discipline;
the_thread_queue->timeout_status = timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10df50: 89 c1 mov %eax,%ecx 10df52: 30 d2 xor %dl,%dl
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10df54: 8d 1c 52 lea (%edx,%edx,2),%ebx 10df57: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10df5a: 8d 73 04 lea 0x4(%ebx),%esi 10df5d: 89 31 mov %esi,(%ecx)
head->next = tail;
head->previous = NULL;
10df5f: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10df66: 89 59 08 mov %ebx,0x8(%ecx)
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++)
10df69: 42 inc %edx 10df6a: 83 c1 0c add $0xc,%ecx
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
uint32_t index;
for( index=0 ;
10df6d: 83 fa 04 cmp $0x4,%edx
10df70: 75 e2 jne 10df54 <_Thread_queue_Initialize+0x40>
_Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] );
} else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Chain_Initialize_empty( &the_thread_queue->Queues.Fifo );
}
}
10df72: 5b pop %ebx 10df73: 5e pop %esi 10df74: c9 leave 10df75: c3 ret
00110d5c <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
110d5c: 55 push %ebp 110d5d: 89 e5 mov %esp,%ebp 110d5f: 83 ec 08 sub $0x8,%esp 110d62: 8b 45 08 mov 0x8(%ebp),%eax
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
110d65: 8b 50 44 mov 0x44(%eax),%edx
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
110d68: 8b 4a 30 mov 0x30(%edx),%ecx 110d6b: 85 c9 test %ecx,%ecx
110d6d: 74 08 je 110d77 <_Thread_queue_Process_timeout+0x1b>
110d6f: 3b 05 78 67 12 00 cmp 0x126778,%eax
110d75: 74 15 je 110d8c <_Thread_queue_Process_timeout+0x30><== ALWAYS TAKEN
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
110d77: 8b 4a 3c mov 0x3c(%edx),%ecx 110d7a: 89 48 34 mov %ecx,0x34(%eax)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
110d7d: 83 ec 08 sub $0x8,%esp 110d80: 50 push %eax 110d81: 52 push %edx 110d82: e8 e9 fe ff ff call 110c70 <_Thread_queue_Extract> 110d87: 83 c4 10 add $0x10,%esp
} }
110d8a: c9 leave 110d8b: c3 ret
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
110d8c: 83 f9 03 cmp $0x3,%ecx
110d8f: 74 f9 je 110d8a <_Thread_queue_Process_timeout+0x2e>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
110d91: 8b 4a 3c mov 0x3c(%edx),%ecx 110d94: 89 48 34 mov %ecx,0x34(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
110d97: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
}
}
110d9e: c9 leave 110d9f: c3 ret
0010df78 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10df78: 55 push %ebp 10df79: 89 e5 mov %esp,%ebp 10df7b: 57 push %edi 10df7c: 56 push %esi 10df7d: 53 push %ebx 10df7e: 83 ec 1c sub $0x1c,%esp 10df81: 8b 75 08 mov 0x8(%ebp),%esi 10df84: 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 )
10df87: 85 f6 test %esi,%esi
10df89: 74 06 je 10df91 <_Thread_queue_Requeue+0x19><== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10df8b: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10df8f: 74 0b je 10df9c <_Thread_queue_Requeue+0x24><== ALWAYS TAKEN
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
10df91: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10df94: 5b pop %ebx <== NOT EXECUTED 10df95: 5e pop %esi <== NOT EXECUTED 10df96: 5f pop %edi <== NOT EXECUTED 10df97: c9 leave <== NOT EXECUTED 10df98: c3 ret <== NOT EXECUTED 10df99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10df9c: 9c pushf 10df9d: fa cli 10df9e: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10df9f: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10dfa6: 75 0c jne 10dfb4 <_Thread_queue_Requeue+0x3c><== ALWAYS TAKEN
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
10dfa8: 53 push %ebx 10dfa9: 9d popf
} }
10dfaa: 8d 65 f4 lea -0xc(%ebp),%esp 10dfad: 5b pop %ebx 10dfae: 5e pop %esi 10dfaf: 5f pop %edi 10dfb0: c9 leave 10dfb1: c3 ret 10dfb2: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10dfb4: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
10dfbb: 50 push %eax 10dfbc: 6a 01 push $0x1 10dfbe: 57 push %edi 10dfbf: 56 push %esi 10dfc0: e8 db 2c 00 00 call 110ca0 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10dfc5: 83 c4 0c add $0xc,%esp 10dfc8: 8d 45 e4 lea -0x1c(%ebp),%eax 10dfcb: 50 push %eax 10dfcc: 57 push %edi 10dfcd: 56 push %esi 10dfce: e8 71 fd ff ff call 10dd44 <_Thread_queue_Enqueue_priority> 10dfd3: 83 c4 10 add $0x10,%esp 10dfd6: eb d0 jmp 10dfa8 <_Thread_queue_Requeue+0x30>
0010dfd8 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10dfd8: 55 push %ebp 10dfd9: 89 e5 mov %esp,%ebp 10dfdb: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10dfde: 8d 45 f4 lea -0xc(%ebp),%eax 10dfe1: 50 push %eax 10dfe2: ff 75 08 pushl 0x8(%ebp) 10dfe5: e8 2e f8 ff ff call 10d818 <_Thread_Get>
switch ( location ) {
10dfea: 83 c4 10 add $0x10,%esp 10dfed: 8b 55 f4 mov -0xc(%ebp),%edx 10dff0: 85 d2 test %edx,%edx
10dff2: 75 17 jne 10e00b <_Thread_queue_Timeout+0x33><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10dff4: 83 ec 0c sub $0xc,%esp 10dff7: 50 push %eax 10dff8: e8 5f 2d 00 00 call 110d5c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10dffd: a1 b0 64 12 00 mov 0x1264b0,%eax 10e002: 48 dec %eax 10e003: a3 b0 64 12 00 mov %eax,0x1264b0 10e008: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e00b: c9 leave 10e00c: c3 ret
00118dc4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
118dc4: 55 push %ebp 118dc5: 89 e5 mov %esp,%ebp 118dc7: 57 push %edi 118dc8: 56 push %esi 118dc9: 53 push %ebx 118dca: 83 ec 4c sub $0x4c,%esp 118dcd: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118dd0: 8d 45 e0 lea -0x20(%ebp),%eax 118dd3: 89 45 b4 mov %eax,-0x4c(%ebp) 118dd6: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
118dd9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
118de0: 8d 4d dc lea -0x24(%ebp),%ecx 118de3: 89 4d e4 mov %ecx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118de6: 8d 7d d0 lea -0x30(%ebp),%edi 118de9: 8d 45 d4 lea -0x2c(%ebp),%eax 118dec: 89 45 b0 mov %eax,-0x50(%ebp) 118def: 89 45 d0 mov %eax,-0x30(%ebp)
head->previous = NULL;
118df2: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
118df9: 89 7d d8 mov %edi,-0x28(%ebp) 118dfc: 8d 73 30 lea 0x30(%ebx),%esi 118dff: 8d 4b 68 lea 0x68(%ebx),%ecx 118e02: 89 4d c4 mov %ecx,-0x3c(%ebp) 118e05: 8d 43 08 lea 0x8(%ebx),%eax 118e08: 89 45 bc mov %eax,-0x44(%ebp) 118e0b: 8d 53 40 lea 0x40(%ebx),%edx 118e0e: 89 55 c0 mov %edx,-0x40(%ebp) 118e11: 8d 76 00 lea 0x0(%esi),%esi
Chain_Control *tmp; /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain;
118e14: 8d 4d dc lea -0x24(%ebp),%ecx 118e17: 89 4b 78 mov %ecx,0x78(%ebx) 118e1a: 66 90 xchg %ax,%ax
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
118e1c: a1 64 0a 14 00 mov 0x140a64,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e21: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
118e24: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e27: 51 push %ecx 118e28: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e29: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e2b: 50 push %eax 118e2c: 56 push %esi 118e2d: e8 b6 3d 00 00 call 11cbe8 <_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();
118e32: a1 c4 09 14 00 mov 0x1409c4,%eax
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
118e37: 8b 53 74 mov 0x74(%ebx),%edx
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
118e3a: 83 c4 10 add $0x10,%esp 118e3d: 39 d0 cmp %edx,%eax
118e3f: 0f 87 af 00 00 00 ja 118ef4 <_Timer_server_Body+0x130>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
118e45: 0f 82 c9 00 00 00 jb 118f14 <_Timer_server_Body+0x150>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
118e4b: 89 43 74 mov %eax,0x74(%ebx) 118e4e: 66 90 xchg %ax,%ax
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
118e50: 8b 43 78 mov 0x78(%ebx),%eax 118e53: 83 ec 0c sub $0xc,%esp 118e56: 50 push %eax 118e57: e8 b8 09 00 00 call 119814 <_Chain_Get>
if ( timer == NULL ) {
118e5c: 83 c4 10 add $0x10,%esp 118e5f: 85 c0 test %eax,%eax
118e61: 74 35 je 118e98 <_Timer_server_Body+0xd4><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118e63: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 118e66: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 118e69: 74 19 je 118e84 <_Timer_server_Body+0xc0><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
118e6b: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118e6e: 75 e0 jne 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118e70: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e73: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e76: 50 push %eax <== NOT EXECUTED 118e77: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 118e7a: e8 f5 3d 00 00 call 11cc74 <_Watchdog_Insert> <== NOT EXECUTED 118e7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e82: eb cc jmp 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
118e84: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118e87: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 118e8a: 50 push %eax <== NOT EXECUTED 118e8b: 56 push %esi <== NOT EXECUTED 118e8c: e8 e3 3d 00 00 call 11cc74 <_Watchdog_Insert> <== NOT EXECUTED 118e91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118e94: eb ba jmp 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED 118e96: 66 90 xchg %ax,%ax <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
118e98: 9c pushf 118e99: fa cli 118e9a: 58 pop %eax
tmp = ts->insert_chain;
118e9b: 8b 53 78 mov 0x78(%ebx),%edx
if ( _Chain_Is_empty( insert_chain ) ) {
118e9e: 8b 55 b4 mov -0x4c(%ebp),%edx 118ea1: 39 55 dc cmp %edx,-0x24(%ebp)
118ea4: 0f 84 86 00 00 00 je 118f30 <_Timer_server_Body+0x16c><== ALWAYS TAKEN
118eaa: b2 01 mov $0x1,%dl <== NOT EXECUTED
ts->insert_chain = NULL;
do_loop = false;
}
_ISR_Enable( level );
118eac: 50 push %eax 118ead: 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 ) {
118eae: 84 d2 test %dl,%dl
118eb0: 0f 85 66 ff ff ff jne 118e1c <_Timer_server_Body+0x58><== NEVER TAKEN
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
118eb6: 8b 4d b0 mov -0x50(%ebp),%ecx 118eb9: 39 4d d0 cmp %ecx,-0x30(%ebp)
118ebc: 75 22 jne 118ee0 <_Timer_server_Body+0x11c>
118ebe: eb 7e jmp 118f3e <_Timer_server_Body+0x17a>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
118ec0: 8b 10 mov (%eax),%edx
head->next = new_first;
118ec2: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
118ec5: 89 7a 04 mov %edi,0x4(%edx)
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
118ec8: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
118ecf: 51 push %ecx 118ed0: 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 );
118ed1: 83 ec 08 sub $0x8,%esp 118ed4: ff 70 24 pushl 0x24(%eax) 118ed7: ff 70 20 pushl 0x20(%eax) 118eda: ff 50 1c call *0x1c(%eax)
}
118edd: 83 c4 10 add $0x10,%esp
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
118ee0: 9c pushf 118ee1: fa cli 118ee2: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
118ee3: 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))
118ee6: 3b 45 b0 cmp -0x50(%ebp),%eax
118ee9: 75 d5 jne 118ec0 <_Timer_server_Body+0xfc>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
118eeb: 51 push %ecx 118eec: 9d popf 118eed: e9 22 ff ff ff jmp 118e14 <_Timer_server_Body+0x50> 118ef2: 66 90 xchg %ax,%ax
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118ef4: 51 push %ecx 118ef5: 57 push %edi
if ( snapshot > last_snapshot ) {
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
118ef6: 89 c1 mov %eax,%ecx 118ef8: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118efa: 51 push %ecx 118efb: ff 75 c4 pushl -0x3c(%ebp) 118efe: 89 45 b8 mov %eax,-0x48(%ebp) 118f01: e8 e2 3c 00 00 call 11cbe8 <_Watchdog_Adjust_to_chain> 118f06: 83 c4 10 add $0x10,%esp 118f09: 8b 45 b8 mov -0x48(%ebp),%eax 118f0c: e9 3a ff ff ff jmp 118e4b <_Timer_server_Body+0x87> 118f11: 8d 76 00 lea 0x0(%esi),%esi
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
118f14: 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;
118f15: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
118f17: 52 push %edx 118f18: 6a 01 push $0x1 118f1a: ff 75 c4 pushl -0x3c(%ebp) 118f1d: 89 45 b8 mov %eax,-0x48(%ebp) 118f20: e8 4b 3c 00 00 call 11cb70 <_Watchdog_Adjust> 118f25: 83 c4 10 add $0x10,%esp 118f28: 8b 45 b8 mov -0x48(%ebp),%eax 118f2b: e9 1b ff ff ff jmp 118e4b <_Timer_server_Body+0x87>
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
118f30: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
118f37: 31 d2 xor %edx,%edx 118f39: e9 6e ff ff ff jmp 118eac <_Timer_server_Body+0xe8>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
118f3e: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118f42: a1 f0 08 14 00 mov 0x1408f0,%eax 118f47: 40 inc %eax 118f48: a3 f0 08 14 00 mov %eax,0x1408f0
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
118f4d: 83 ec 08 sub $0x8,%esp 118f50: 6a 08 push $0x8 118f52: ff 33 pushl (%ebx) 118f54: e8 df 35 00 00 call 11c538 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
118f59: 89 d8 mov %ebx,%eax 118f5b: e8 c4 fd ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
118f60: 89 d8 mov %ebx,%eax 118f62: e8 0d fe ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
118f67: e8 c8 2c 00 00 call 11bc34 <_Thread_Enable_dispatch>
ts->active = true;
118f6c: 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 );
118f70: 5a pop %edx 118f71: ff 75 bc pushl -0x44(%ebp) 118f74: e8 3b 3e 00 00 call 11cdb4 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
118f79: 58 pop %eax 118f7a: ff 75 c0 pushl -0x40(%ebp) 118f7d: e8 32 3e 00 00 call 11cdb4 <_Watchdog_Remove> 118f82: 83 c4 10 add $0x10,%esp 118f85: e9 8a fe ff ff jmp 118e14 <_Timer_server_Body+0x50>
00118f8c <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
118f8c: 55 push %ebp 118f8d: 89 e5 mov %esp,%ebp 118f8f: 57 push %edi 118f90: 56 push %esi 118f91: 53 push %ebx 118f92: 83 ec 2c sub $0x2c,%esp 118f95: 8b 5d 08 mov 0x8(%ebp),%ebx 118f98: 8b 45 0c mov 0xc(%ebp),%eax
if ( ts->insert_chain == NULL ) {
118f9b: 8b 53 78 mov 0x78(%ebx),%edx 118f9e: 85 d2 test %edx,%edx
118fa0: 74 16 je 118fb8 <_Timer_server_Schedule_operation_method+0x2c><== ALWAYS TAKEN
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
118fa2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 118fa5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 118fa8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
} }
118fab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118fae: 5b pop %ebx <== NOT EXECUTED 118faf: 5e pop %esi <== NOT EXECUTED 118fb0: 5f pop %edi <== NOT EXECUTED 118fb1: c9 leave <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
118fb2: e9 21 08 00 00 jmp 1197d8 <_Chain_Append> <== NOT EXECUTED 118fb7: 90 nop <== NOT EXECUTED
118fb8: 8b 15 f0 08 14 00 mov 0x1408f0,%edx 118fbe: 42 inc %edx 118fbf: 89 15 f0 08 14 00 mov %edx,0x1408f0
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118fc5: 8b 50 38 mov 0x38(%eax),%edx 118fc8: 83 fa 01 cmp $0x1,%edx
118fcb: 74 7b je 119048 <_Timer_server_Schedule_operation_method+0xbc>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
118fcd: 83 fa 03 cmp $0x3,%edx
118fd0: 74 0e je 118fe0 <_Timer_server_Schedule_operation_method+0x54>
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
118fd2: 8d 65 f4 lea -0xc(%ebp),%esp 118fd5: 5b pop %ebx 118fd6: 5e pop %esi 118fd7: 5f pop %edi 118fd8: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
118fd9: e9 56 2c 00 00 jmp 11bc34 <_Thread_Enable_dispatch> 118fde: 66 90 xchg %ax,%ax
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
118fe0: 9c pushf 118fe1: fa cli 118fe2: 8f 45 e4 popl -0x1c(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
118fe5: 8b 0d c4 09 14 00 mov 0x1409c4,%ecx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
118feb: 8b 53 74 mov 0x74(%ebx),%edx 118fee: 89 55 d4 mov %edx,-0x2c(%ebp)
initialized = false;
}
#endif
return status;
}
118ff1: 8b 53 68 mov 0x68(%ebx),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
118ff4: 8d 7b 6c lea 0x6c(%ebx),%edi
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
118ff7: 39 fa cmp %edi,%edx
118ff9: 74 21 je 11901c <_Timer_server_Schedule_operation_method+0x90>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
118ffb: 8b 7a 10 mov 0x10(%edx),%edi
if ( snapshot > last_snapshot ) {
118ffe: 3b 4d d4 cmp -0x2c(%ebp),%ecx
119001: 0f 86 a1 00 00 00 jbe 1190a8 <_Timer_server_Schedule_operation_method+0x11c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
119007: 89 ce mov %ecx,%esi 119009: 2b 75 d4 sub -0x2c(%ebp),%esi 11900c: 89 75 d4 mov %esi,-0x2c(%ebp)
if (delta_interval > delta) {
11900f: 39 f7 cmp %esi,%edi
119011: 0f 86 9b 00 00 00 jbe 1190b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN
delta_interval -= delta;
119017: 29 f7 sub %esi,%edi
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
119019: 89 7a 10 mov %edi,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
11901c: 89 4b 74 mov %ecx,0x74(%ebx)
_ISR_Enable( level );
11901f: ff 75 e4 pushl -0x1c(%ebp) 119022: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
119023: 83 ec 08 sub $0x8,%esp 119026: 83 c0 10 add $0x10,%eax 119029: 50 push %eax 11902a: 8d 43 68 lea 0x68(%ebx),%eax 11902d: 50 push %eax 11902e: e8 41 3c 00 00 call 11cc74 <_Watchdog_Insert>
if ( !ts->active ) {
119033: 8a 43 7c mov 0x7c(%ebx),%al 119036: 83 c4 10 add $0x10,%esp 119039: 84 c0 test %al,%al
11903b: 75 95 jne 118fd2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_tod_system_watchdog( ts );
11903d: 89 d8 mov %ebx,%eax 11903f: e8 30 fd ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog> 119044: eb 8c jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46> 119046: 66 90 xchg %ax,%ax
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
119048: 9c pushf 119049: fa cli 11904a: 8f 45 e4 popl -0x1c(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
11904d: 8b 0d 64 0a 14 00 mov 0x140a64,%ecx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
119053: 8b 7b 3c mov 0x3c(%ebx),%edi
initialized = false;
}
#endif
return status;
}
119056: 8b 53 30 mov 0x30(%ebx),%edx 119059: 8d 73 34 lea 0x34(%ebx),%esi
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
11905c: 39 f2 cmp %esi,%edx
11905e: 74 10 je 119070 <_Timer_server_Schedule_operation_method+0xe4>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
119060: 89 ce mov %ecx,%esi 119062: 29 fe sub %edi,%esi
delta_interval = first_watchdog->delta_interval;
119064: 8b 7a 10 mov 0x10(%edx),%edi
if (delta_interval > delta) {
119067: 39 fe cmp %edi,%esi
119069: 73 39 jae 1190a4 <_Timer_server_Schedule_operation_method+0x118>
delta_interval -= delta;
11906b: 29 f7 sub %esi,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
11906d: 89 7a 10 mov %edi,0x10(%edx)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
119070: 89 4b 3c mov %ecx,0x3c(%ebx)
_ISR_Enable( level );
119073: ff 75 e4 pushl -0x1c(%ebp) 119076: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
119077: 83 ec 08 sub $0x8,%esp 11907a: 83 c0 10 add $0x10,%eax 11907d: 50 push %eax 11907e: 8d 43 30 lea 0x30(%ebx),%eax 119081: 50 push %eax 119082: e8 ed 3b 00 00 call 11cc74 <_Watchdog_Insert>
if ( !ts->active ) {
119087: 8a 43 7c mov 0x7c(%ebx),%al 11908a: 83 c4 10 add $0x10,%esp 11908d: 84 c0 test %al,%al
11908f: 0f 85 3d ff ff ff jne 118fd2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_interval_system_watchdog( ts );
119095: 89 d8 mov %ebx,%eax 119097: e8 88 fc ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog> 11909c: e9 31 ff ff ff jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46> 1190a1: 8d 76 00 lea 0x0(%esi),%esi
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1190a4: 31 ff xor %edi,%edi 1190a6: eb c5 jmp 11906d <_Timer_server_Schedule_operation_method+0xe1>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
1190a8: 03 7d d4 add -0x2c(%ebp),%edi
delta_interval += delta;
1190ab: 29 cf sub %ecx,%edi 1190ad: e9 67 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1190b2: 31 ff xor %edi,%edi <== NOT EXECUTED 1190b4: e9 60 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED
0010e284 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
10e284: 55 push %ebp 10e285: 89 e5 mov %esp,%ebp 10e287: 53 push %ebx 10e288: 8b 5d 08 mov 0x8(%ebp),%ebx 10e28b: 8b 55 0c mov 0xc(%ebp),%edx
uint32_t seconds = add->tv_sec;
10e28e: 8b 02 mov (%edx),%eax
/* Add the basics */
time->tv_sec += add->tv_sec;
10e290: 01 03 add %eax,(%ebx)
time->tv_nsec += add->tv_nsec;
10e292: 8b 52 04 mov 0x4(%edx),%edx 10e295: 03 53 04 add 0x4(%ebx),%edx 10e298: 89 53 04 mov %edx,0x4(%ebx)
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10e29b: 81 fa ff c9 9a 3b cmp $0x3b9ac9ff,%edx
10e2a1: 76 1a jbe 10e2bd <_Timespec_Add_to+0x39>
10e2a3: 8b 0b mov (%ebx),%ecx 10e2a5: 8d 76 00 lea 0x0(%esi),%esi
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
10e2a8: 81 ea 00 ca 9a 3b sub $0x3b9aca00,%edx
*
* This routines adds two timespecs. The second argument is added
* to the first.
*/
uint32_t _Timespec_Add_to(
10e2ae: 41 inc %ecx
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
time->tv_sec++;
seconds++;
10e2af: 40 inc %eax
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10e2b0: 81 fa ff c9 9a 3b cmp $0x3b9ac9ff,%edx
10e2b6: 77 f0 ja 10e2a8 <_Timespec_Add_to+0x24> <== NEVER TAKEN
10e2b8: 89 53 04 mov %edx,0x4(%ebx) 10e2bb: 89 0b mov %ecx,(%ebx)
time->tv_sec++;
seconds++;
}
return seconds;
}
10e2bd: 5b pop %ebx 10e2be: c9 leave 10e2bf: c3 ret
0010fab4 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10fab4: 55 push %ebp 10fab5: 89 e5 mov %esp,%ebp 10fab7: 57 push %edi 10fab8: 56 push %esi 10fab9: 53 push %ebx 10faba: 83 ec 2c sub $0x2c,%esp 10fabd: 8b 45 08 mov 0x8(%ebp),%eax 10fac0: 8b 4d 0c mov 0xc(%ebp),%ecx
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10fac3: 8b 38 mov (%eax),%edi
left += lhs->tv_nsec;
10fac5: 8b 70 04 mov 0x4(%eax),%esi
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10fac8: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10facd: 8b 01 mov (%ecx),%eax 10facf: f7 eb imul %ebx 10fad1: 89 45 e0 mov %eax,-0x20(%ebp) 10fad4: 89 55 e4 mov %edx,-0x1c(%ebp)
right += rhs->tv_nsec;
10fad7: 8b 41 04 mov 0x4(%ecx),%eax 10fada: 99 cltd 10fadb: 01 45 e0 add %eax,-0x20(%ebp) 10fade: 11 55 e4 adc %edx,-0x1c(%ebp)
if ( right == 0 ) {
10fae1: 8b 55 e4 mov -0x1c(%ebp),%edx 10fae4: 0b 55 e0 or -0x20(%ebp),%edx
10fae7: 74 73 je 10fb5c <_Timespec_Divide+0xa8>
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10fae9: 89 f8 mov %edi,%eax 10faeb: f7 eb imul %ebx 10faed: 89 45 d0 mov %eax,-0x30(%ebp) 10faf0: 89 55 d4 mov %edx,-0x2c(%ebp)
left += lhs->tv_nsec;
10faf3: 89 f7 mov %esi,%edi 10faf5: c1 ff 1f sar $0x1f,%edi 10faf8: 01 75 d0 add %esi,-0x30(%ebp) 10fafb: 11 7d d4 adc %edi,-0x2c(%ebp)
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
10fafe: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10fb05: bb a0 86 01 00 mov $0x186a0,%ebx 10fb0a: 8b 45 d0 mov -0x30(%ebp),%eax 10fb0d: f7 e3 mul %ebx 10fb0f: 8d 34 11 lea (%ecx,%edx,1),%esi 10fb12: ff 75 e4 pushl -0x1c(%ebp) 10fb15: ff 75 e0 pushl -0x20(%ebp) 10fb18: 56 push %esi 10fb19: 50 push %eax 10fb1a: e8 6d 04 01 00 call 11ff8c <__udivdi3> 10fb1f: 83 c4 10 add $0x10,%esp 10fb22: 89 c3 mov %eax,%ebx 10fb24: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10fb26: 6a 00 push $0x0 10fb28: 68 e8 03 00 00 push $0x3e8 10fb2d: 52 push %edx 10fb2e: 50 push %eax 10fb2f: e8 58 04 01 00 call 11ff8c <__udivdi3> 10fb34: 83 c4 10 add $0x10,%esp 10fb37: 8b 55 10 mov 0x10(%ebp),%edx 10fb3a: 89 02 mov %eax,(%edx)
*fval_percentage = answer % 1000;
10fb3c: 6a 00 push $0x0 10fb3e: 68 e8 03 00 00 push $0x3e8 10fb43: 56 push %esi 10fb44: 53 push %ebx 10fb45: e8 52 05 01 00 call 12009c <__umoddi3> 10fb4a: 83 c4 10 add $0x10,%esp 10fb4d: 8b 55 14 mov 0x14(%ebp),%edx 10fb50: 89 02 mov %eax,(%edx)
}
10fb52: 8d 65 f4 lea -0xc(%ebp),%esp 10fb55: 5b pop %ebx 10fb56: 5e pop %esi 10fb57: 5f pop %edi 10fb58: c9 leave 10fb59: c3 ret 10fb5a: 66 90 xchg %ax,%ax
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
10fb5c: 8b 45 10 mov 0x10(%ebp),%eax 10fb5f: c7 00 00 00 00 00 movl $0x0,(%eax)
*fval_percentage = 0;
10fb65: 8b 55 14 mov 0x14(%ebp),%edx 10fb68: c7 02 00 00 00 00 movl $0x0,(%edx)
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10fb6e: 8d 65 f4 lea -0xc(%ebp),%esp 10fb71: 5b pop %ebx 10fb72: 5e pop %esi 10fb73: 5f pop %edi 10fb74: c9 leave 10fb75: c3 ret
0010fd60 <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
10fd60: 55 push %ebp 10fd61: 89 e5 mov %esp,%ebp 10fd63: 8b 55 08 mov 0x8(%ebp),%edx 10fd66: 8b 45 0c mov 0xc(%ebp),%eax
if ( lhs->tv_sec > rhs->tv_sec )
10fd69: 8b 08 mov (%eax),%ecx 10fd6b: 39 0a cmp %ecx,(%edx)
10fd6d: 7f 11 jg 10fd80 <_Timespec_Greater_than+0x20>
return true;
if ( lhs->tv_sec < rhs->tv_sec )
10fd6f: 7c 0b jl 10fd7c <_Timespec_Greater_than+0x1c><== NEVER TAKEN
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Greater_than(
10fd71: 8b 48 04 mov 0x4(%eax),%ecx 10fd74: 39 4a 04 cmp %ecx,0x4(%edx) 10fd77: 0f 9f c0 setg %al
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return true;
return false;
}
10fd7a: c9 leave 10fd7b: c3 ret
{
if ( lhs->tv_sec > rhs->tv_sec )
return true;
if ( lhs->tv_sec < rhs->tv_sec )
return false;
10fd7c: 31 c0 xor %eax,%eax
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return true;
return false;
}
10fd7e: c9 leave <== NOT EXECUTED 10fd7f: c3 ret <== NOT EXECUTED
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec > rhs->tv_sec )
return true;
10fd80: b0 01 mov $0x1,%al
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return true;
return false;
}
10fd82: c9 leave 10fd83: c3 ret
0010eee8 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
10eee8: 55 push %ebp 10eee9: 89 e5 mov %esp,%ebp 10eeeb: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
10eeee: 85 c0 test %eax,%eax
10eef0: 74 1a je 10ef0c <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
10eef2: 8b 10 mov (%eax),%edx 10eef4: 85 d2 test %edx,%edx
10eef6: 78 14 js 10ef0c <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
10eef8: 8b 40 04 mov 0x4(%eax),%eax 10eefb: 85 c0 test %eax,%eax
10eefd: 78 0d js 10ef0c <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
10eeff: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 10ef04: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
10ef07: c9 leave 10ef08: c3 ret 10ef09: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
10ef0c: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
10ef0e: c9 leave 10ef0f: c3 ret
0010ef50 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
10ef50: 55 push %ebp 10ef51: 89 e5 mov %esp,%ebp 10ef53: 56 push %esi 10ef54: 53 push %ebx 10ef55: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
10ef58: 8b 33 mov (%ebx),%esi 10ef5a: 85 f6 test %esi,%esi
10ef5c: 75 07 jne 10ef65 <_Timespec_To_ticks+0x15>
10ef5e: 8b 43 04 mov 0x4(%ebx),%eax 10ef61: 85 c0 test %eax,%eax
10ef63: 74 37 je 10ef9c <_Timespec_To_ticks+0x4c>
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
10ef65: e8 ee 24 00 00 call 111458 <TOD_TICKS_PER_SECOND_method> 10ef6a: 89 c1 mov %eax,%ecx 10ef6c: 0f af ce imul %esi,%ecx
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
10ef6f: a1 2c 42 12 00 mov 0x12422c,%eax 10ef74: 8d 04 80 lea (%eax,%eax,4),%eax 10ef77: 8d 04 80 lea (%eax,%eax,4),%eax 10ef7a: 8d 34 80 lea (%eax,%eax,4),%esi 10ef7d: c1 e6 03 shl $0x3,%esi 10ef80: 8b 43 04 mov 0x4(%ebx),%eax 10ef83: 31 d2 xor %edx,%edx 10ef85: f7 f6 div %esi
if (ticks)
10ef87: 01 c8 add %ecx,%eax
10ef89: 74 05 je 10ef90 <_Timespec_To_ticks+0x40>
return ticks;
return 1;
}
10ef8b: 5b pop %ebx 10ef8c: 5e pop %esi 10ef8d: c9 leave 10ef8e: c3 ret 10ef8f: 90 nop
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
if (ticks)
return ticks;
return 1;
10ef90: b8 01 00 00 00 mov $0x1,%eax
}
10ef95: 5b pop %ebx 10ef96: 5e pop %esi 10ef97: c9 leave 10ef98: c3 ret 10ef99: 8d 76 00 lea 0x0(%esi),%esi
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
10ef9c: 31 c0 xor %eax,%eax
if (ticks)
return ticks;
return 1;
}
10ef9e: 5b pop %ebx 10ef9f: 5e pop %esi 10efa0: c9 leave 10efa1: c3 ret
0010e43c <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10e43c: 55 push %ebp 10e43d: 89 e5 mov %esp,%ebp 10e43f: 57 push %edi 10e440: 56 push %esi 10e441: 53 push %ebx 10e442: 83 ec 1c sub $0x1c,%esp 10e445: 8b 75 08 mov 0x8(%ebp),%esi 10e448: 8b 7d 10 mov 0x10(%ebp),%edi 10e44b: 8a 45 0c mov 0xc(%ebp),%al
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10e44e: 8b 1d 14 67 12 00 mov 0x126714,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e454: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10e45a: 74 25 je 10e481 <_User_extensions_Fatal+0x45><== NEVER TAKEN
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10e45c: 0f b6 c0 movzbl %al,%eax 10e45f: 89 45 e4 mov %eax,-0x1c(%ebp) 10e462: 66 90 xchg %ax,%ax
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
10e464: 8b 43 30 mov 0x30(%ebx),%eax 10e467: 85 c0 test %eax,%eax
10e469: 74 0b je 10e476 <_User_extensions_Fatal+0x3a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10e46b: 52 push %edx 10e46c: 57 push %edi 10e46d: ff 75 e4 pushl -0x1c(%ebp) 10e470: 56 push %esi 10e471: ff d0 call *%eax
10e473: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10e476: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e479: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10e47f: 75 e3 jne 10e464 <_User_extensions_Fatal+0x28><== ALWAYS TAKEN
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10e481: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e484: 5b pop %ebx <== NOT EXECUTED 10e485: 5e pop %esi <== NOT EXECUTED 10e486: 5f pop %edi <== NOT EXECUTED 10e487: c9 leave <== NOT EXECUTED 10e488: c3 ret <== NOT EXECUTED
0010e300 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10e300: 55 push %ebp 10e301: 89 e5 mov %esp,%ebp 10e303: 57 push %edi 10e304: 56 push %esi 10e305: 53 push %ebx 10e306: 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;
10e309: a1 5c 22 12 00 mov 0x12225c,%eax 10e30e: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10e311: 8b 35 60 22 12 00 mov 0x122260,%esi
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e317: c7 05 0c 67 12 00 10 movl $0x126710,0x12670c
10e31e: 67 12 00 head->previous = NULL;
10e321: c7 05 10 67 12 00 00 movl $0x0,0x126710
10e328: 00 00 00 tail->previous = head;
10e32b: c7 05 14 67 12 00 0c movl $0x12670c,0x126714
10e332: 67 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e335: c7 05 b4 64 12 00 b8 movl $0x1264b8,0x1264b4
10e33c: 64 12 00 head->previous = NULL;
10e33f: c7 05 b8 64 12 00 00 movl $0x0,0x1264b8
10e346: 00 00 00 tail->previous = head;
10e349: c7 05 bc 64 12 00 b4 movl $0x1264b4,0x1264bc
10e350: 64 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10e353: 85 f6 test %esi,%esi
10e355: 74 64 je 10e3bb <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10e357: 89 c2 mov %eax,%edx 10e359: 8d 04 40 lea (%eax,%eax,2),%eax 10e35c: 8d 0c 82 lea (%edx,%eax,4),%ecx 10e35f: c1 e1 02 shl $0x2,%ecx 10e362: 83 ec 0c sub $0xc,%esp 10e365: 51 push %ecx 10e366: 89 4d d8 mov %ecx,-0x28(%ebp) 10e369: e8 ce 04 00 00 call 10e83c <_Workspace_Allocate_or_fatal_error> 10e36e: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10e370: 31 c0 xor %eax,%eax 10e372: 8b 4d d8 mov -0x28(%ebp),%ecx 10e375: 89 df mov %ebx,%edi 10e377: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e379: 83 c4 10 add $0x10,%esp 10e37c: 8b 45 dc mov -0x24(%ebp),%eax 10e37f: 85 c0 test %eax,%eax
10e381: 74 38 je 10e3bb <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
10e383: 89 75 e4 mov %esi,-0x1c(%ebp) 10e386: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10e38d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10e390: 8d 7b 14 lea 0x14(%ebx),%edi 10e393: 8b 75 e4 mov -0x1c(%ebp),%esi 10e396: b9 08 00 00 00 mov $0x8,%ecx 10e39b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10e39d: 83 ec 0c sub $0xc,%esp 10e3a0: 53 push %ebx 10e3a1: e8 6a 2a 00 00 call 110e10 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10e3a6: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e3a9: ff 45 e0 incl -0x20(%ebp) 10e3ac: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10e3b0: 83 c4 10 add $0x10,%esp 10e3b3: 8b 45 e0 mov -0x20(%ebp),%eax 10e3b6: 39 45 dc cmp %eax,-0x24(%ebp)
10e3b9: 77 d5 ja 10e390 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10e3bb: 8d 65 f4 lea -0xc(%ebp),%esp 10e3be: 5b pop %ebx 10e3bf: 5e pop %esi 10e3c0: 5f pop %edi 10e3c1: c9 leave 10e3c2: c3 ret
0010f888 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10f888: 55 push %ebp 10f889: 89 e5 mov %esp,%ebp 10f88b: 53 push %ebx 10f88c: 83 ec 10 sub $0x10,%esp 10f88f: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10f892: 53 push %ebx 10f893: e8 b8 da ff ff call 10d350 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10f898: 83 c4 10 add $0x10,%esp 10f89b: 8b 43 24 mov 0x24(%ebx),%eax 10f89e: 85 c0 test %eax,%eax
10f8a0: 74 12 je 10f8b4 <_User_extensions_Remove_set+0x2c>
_Chain_Extract( &the_extension->Switch.Node );
10f8a2: 83 c3 08 add $0x8,%ebx 10f8a5: 89 5d 08 mov %ebx,0x8(%ebp)
}
10f8a8: 8b 5d fc mov -0x4(%ebp),%ebx 10f8ab: c9 leave
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10f8ac: e9 9f da ff ff jmp 10d350 <_Chain_Extract> 10f8b1: 8d 76 00 lea 0x0(%esi),%esi
}
10f8b4: 8b 5d fc mov -0x4(%ebp),%ebx 10f8b7: c9 leave 10f8b8: c3 ret
0010e3c4 <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10e3c4: 55 push %ebp 10e3c5: 89 e5 mov %esp,%ebp 10e3c7: 56 push %esi 10e3c8: 53 push %ebx 10e3c9: 8b 75 08 mov 0x8(%ebp),%esi
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10e3cc: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e3d2: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10e3d8: 74 1c je 10e3f6 <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10e3da: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
10e3dc: 8b 43 28 mov 0x28(%ebx),%eax 10e3df: 85 c0 test %eax,%eax
10e3e1: 74 09 je 10e3ec <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10e3e3: 83 ec 0c sub $0xc,%esp 10e3e6: 56 push %esi 10e3e7: ff d0 call *%eax 10e3e9: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10e3ec: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e3ee: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10e3f4: 75 e6 jne 10e3dc <_User_extensions_Thread_begin+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
(*the_extension->Callouts.thread_begin)( executing );
}
}
10e3f6: 8d 65 f8 lea -0x8(%ebp),%esp 10e3f9: 5b pop %ebx 10e3fa: 5e pop %esi 10e3fb: c9 leave 10e3fc: c3 ret
0010e48c <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10e48c: 55 push %ebp 10e48d: 89 e5 mov %esp,%ebp 10e48f: 56 push %esi 10e490: 53 push %ebx 10e491: 8b 75 08 mov 0x8(%ebp),%esi
return false;
}
}
return true;
}
10e494: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e49a: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10e4a0: 74 26 je 10e4c8 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10e4a2: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
10e4a4: 8b 43 14 mov 0x14(%ebx),%eax 10e4a7: 85 c0 test %eax,%eax
10e4a9: 74 13 je 10e4be <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10e4ab: 83 ec 08 sub $0x8,%esp 10e4ae: 56 push %esi 10e4af: ff 35 78 67 12 00 pushl 0x126778 10e4b5: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10e4b7: 83 c4 10 add $0x10,%esp 10e4ba: 84 c0 test %al,%al
10e4bc: 74 16 je 10e4d4 <_User_extensions_Thread_create+0x48>
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10e4be: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e4c0: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10e4c6: 75 dc jne 10e4a4 <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10e4c8: b0 01 mov $0x1,%al
}
10e4ca: 8d 65 f8 lea -0x8(%ebp),%esp 10e4cd: 5b pop %ebx 10e4ce: 5e pop %esi 10e4cf: c9 leave 10e4d0: c3 ret 10e4d1: 8d 76 00 lea 0x0(%esi),%esi
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
10e4d4: 31 c0 xor %eax,%eax
}
}
return true;
}
10e4d6: 8d 65 f8 lea -0x8(%ebp),%esp 10e4d9: 5b pop %ebx 10e4da: 5e pop %esi 10e4db: c9 leave 10e4dc: c3 ret
0010e4e0 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10e4e0: 55 push %ebp 10e4e1: 89 e5 mov %esp,%ebp 10e4e3: 56 push %esi 10e4e4: 53 push %ebx 10e4e5: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e4e8: 8b 1d 14 67 12 00 mov 0x126714,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e4ee: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10e4f4: 74 23 je 10e519 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10e4f6: 66 90 xchg %ax,%ax
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
10e4f8: 8b 43 20 mov 0x20(%ebx),%eax 10e4fb: 85 c0 test %eax,%eax
10e4fd: 74 0f je 10e50e <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10e4ff: 83 ec 08 sub $0x8,%esp 10e502: 56 push %esi 10e503: ff 35 78 67 12 00 pushl 0x126778 10e509: ff d0 call *%eax 10e50b: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10e50e: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e511: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10e517: 75 df jne 10e4f8 <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e519: 8d 65 f8 lea -0x8(%ebp),%esp 10e51c: 5b pop %ebx 10e51d: 5e pop %esi 10e51e: c9 leave 10e51f: c3 ret
0010e400 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10e400: 55 push %ebp 10e401: 89 e5 mov %esp,%ebp 10e403: 56 push %esi 10e404: 53 push %ebx 10e405: 8b 75 08 mov 0x8(%ebp),%esi
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10e408: 8b 1d 14 67 12 00 mov 0x126714,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e40e: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10e414: 74 1d je 10e433 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10e416: 66 90 xchg %ax,%ax
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
10e418: 8b 43 2c mov 0x2c(%ebx),%eax 10e41b: 85 c0 test %eax,%eax
10e41d: 74 09 je 10e428 <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10e41f: 83 ec 0c sub $0xc,%esp 10e422: 56 push %esi 10e423: ff d0 call *%eax
10e425: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10e428: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e42b: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10e431: 75 e5 jne 10e418 <_User_extensions_Thread_exitted+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
10e433: 8d 65 f8 lea -0x8(%ebp),%esp 10e436: 5b pop %ebx 10e437: 5e pop %esi 10e438: c9 leave 10e439: c3 ret
0010f0e4 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10f0e4: 55 push %ebp 10f0e5: 89 e5 mov %esp,%ebp 10f0e7: 56 push %esi 10f0e8: 53 push %ebx 10f0e9: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f0ec: 8b 1d 8c 8c 12 00 mov 0x128c8c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f0f2: 81 fb 90 8c 12 00 cmp $0x128c90,%ebx
10f0f8: 74 22 je 10f11c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10f0fa: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
10f0fc: 8b 43 1c mov 0x1c(%ebx),%eax 10f0ff: 85 c0 test %eax,%eax
10f101: 74 0f je 10f112 <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10f103: 83 ec 08 sub $0x8,%esp 10f106: 56 push %esi 10f107: ff 35 f8 8c 12 00 pushl 0x128cf8 10f10d: ff d0 call *%eax 10f10f: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10f112: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f114: 81 fb 90 8c 12 00 cmp $0x128c90,%ebx
10f11a: 75 e0 jne 10f0fc <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f11c: 8d 65 f8 lea -0x8(%ebp),%esp 10f11f: 5b pop %ebx 10f120: 5e pop %esi 10f121: c9 leave 10f122: c3 ret
0010e520 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10e520: 55 push %ebp 10e521: 89 e5 mov %esp,%ebp 10e523: 56 push %esi 10e524: 53 push %ebx 10e525: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e528: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e52e: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10e534: 74 22 je 10e558 <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10e536: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
10e538: 8b 43 18 mov 0x18(%ebx),%eax 10e53b: 85 c0 test %eax,%eax
10e53d: 74 0f je 10e54e <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10e53f: 83 ec 08 sub $0x8,%esp 10e542: 56 push %esi 10e543: ff 35 78 67 12 00 pushl 0x126778 10e549: ff d0 call *%eax 10e54b: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10e54e: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e550: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10e556: 75 e0 jne 10e538 <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e558: 8d 65 f8 lea -0x8(%ebp),%esp 10e55b: 5b pop %ebx 10e55c: 5e pop %esi 10e55d: c9 leave 10e55e: c3 ret
0010e560 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10e560: 55 push %ebp 10e561: 89 e5 mov %esp,%ebp 10e563: 57 push %edi 10e564: 56 push %esi 10e565: 53 push %ebx 10e566: 83 ec 0c sub $0xc,%esp 10e569: 8b 7d 08 mov 0x8(%ebp),%edi 10e56c: 8b 75 0c mov 0xc(%ebp),%esi
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e56f: 8b 1d b4 64 12 00 mov 0x1264b4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e575: 81 fb b8 64 12 00 cmp $0x1264b8,%ebx
10e57b: 74 18 je 10e595 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10e57d: 8d 76 00 lea 0x0(%esi),%esi
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
10e580: 83 ec 08 sub $0x8,%esp 10e583: 56 push %esi 10e584: 57 push %edi 10e585: ff 53 08 call *0x8(%ebx)
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
10e588: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e58a: 83 c4 10 add $0x10,%esp 10e58d: 81 fb b8 64 12 00 cmp $0x1264b8,%ebx
10e593: 75 eb jne 10e580 <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e595: 8d 65 f4 lea -0xc(%ebp),%esp 10e598: 5b pop %ebx 10e599: 5e pop %esi 10e59a: 5f pop %edi 10e59b: c9 leave 10e59c: c3 ret
0010fe94 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10fe94: 55 push %ebp 10fe95: 89 e5 mov %esp,%ebp 10fe97: 57 push %edi 10fe98: 56 push %esi 10fe99: 53 push %ebx 10fe9a: 83 ec 1c sub $0x1c,%esp 10fe9d: 8b 75 08 mov 0x8(%ebp),%esi 10fea0: 8b 4d 0c mov 0xc(%ebp),%ecx 10fea3: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10fea6: 9c pushf 10fea7: fa cli 10fea8: 58 pop %eax
}
}
_ISR_Enable( level );
}
10fea9: 8b 16 mov (%esi),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10feab: 8d 7e 04 lea 0x4(%esi),%edi 10feae: 89 7d e4 mov %edi,-0x1c(%ebp)
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
10feb1: 39 fa cmp %edi,%edx
10feb3: 74 3d je 10fef2 <_Watchdog_Adjust+0x5e>
switch ( direction ) {
10feb5: 85 c9 test %ecx,%ecx
10feb7: 75 43 jne 10fefc <_Watchdog_Adjust+0x68>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10feb9: 85 db test %ebx,%ebx
10febb: 74 35 je 10fef2 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10febd: 8b 7a 10 mov 0x10(%edx),%edi 10fec0: 39 fb cmp %edi,%ebx
10fec2: 73 0f jae 10fed3 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
10fec4: eb 3e jmp 10ff04 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 10fec6: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10fec8: 29 fb sub %edi,%ebx
10feca: 74 26 je 10fef2 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10fecc: 8b 7a 10 mov 0x10(%edx),%edi 10fecf: 39 df cmp %ebx,%edi
10fed1: 77 31 ja 10ff04 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10fed3: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10feda: 50 push %eax 10fedb: 9d popf
_Watchdog_Tickle( header );
10fedc: 83 ec 0c sub $0xc,%esp 10fedf: 56 push %esi 10fee0: e8 d3 01 00 00 call 1100b8 <_Watchdog_Tickle>
_ISR_Disable( level );
10fee5: 9c pushf 10fee6: fa cli 10fee7: 58 pop %eax
}
}
_ISR_Enable( level );
}
10fee8: 8b 16 mov (%esi),%edx
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10feea: 83 c4 10 add $0x10,%esp 10feed: 39 55 e4 cmp %edx,-0x1c(%ebp)
10fef0: 75 d6 jne 10fec8 <_Watchdog_Adjust+0x34>
}
break;
}
}
_ISR_Enable( level );
10fef2: 50 push %eax 10fef3: 9d popf
}
10fef4: 8d 65 f4 lea -0xc(%ebp),%esp 10fef7: 5b pop %ebx 10fef8: 5e pop %esi 10fef9: 5f pop %edi 10fefa: c9 leave 10fefb: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
10fefc: 49 dec %ecx
10fefd: 75 f3 jne 10fef2 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10feff: 01 5a 10 add %ebx,0x10(%edx)
break;
10ff02: eb ee jmp 10fef2 <_Watchdog_Adjust+0x5e>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
10ff04: 29 df sub %ebx,%edi 10ff06: 89 7a 10 mov %edi,0x10(%edx)
break;
10ff09: eb e7 jmp 10fef2 <_Watchdog_Adjust+0x5e>
0010e5a0 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10e5a0: 55 push %ebp 10e5a1: 89 e5 mov %esp,%ebp 10e5a3: 57 push %edi 10e5a4: 56 push %esi 10e5a5: 53 push %ebx 10e5a6: 83 ec 04 sub $0x4,%esp 10e5a9: 8b 5d 0c mov 0xc(%ebp),%ebx
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
10e5ac: 8b 3d 74 67 12 00 mov 0x126774,%edi
_ISR_Disable( level );
10e5b2: 9c pushf 10e5b3: fa cli 10e5b4: 8f 45 f0 popl -0x10(%ebp)
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
10e5b7: 8b 43 08 mov 0x8(%ebx),%eax 10e5ba: 85 c0 test %eax,%eax
10e5bc: 0f 85 9e 00 00 00 jne 10e660 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10e5c2: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
_Watchdog_Sync_count++;
10e5c9: a1 20 66 12 00 mov 0x126620,%eax 10e5ce: 40 inc %eax 10e5cf: a3 20 66 12 00 mov %eax,0x126620
restart:
delta_interval = the_watchdog->initial;
10e5d4: 8b 43 0c mov 0xc(%ebx),%eax
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e5d7: 8b 4d 08 mov 0x8(%ebp),%ecx 10e5da: 8b 11 mov (%ecx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e5dc: 85 c0 test %eax,%eax
10e5de: 74 5d je 10e63d <_Watchdog_Insert+0x9d>
10e5e0: 8b 32 mov (%edx),%esi 10e5e2: 85 f6 test %esi,%esi
10e5e4: 74 57 je 10e63d <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e5e6: 8b 4a 10 mov 0x10(%edx),%ecx 10e5e9: 39 c8 cmp %ecx,%eax
10e5eb: 73 22 jae 10e60f <_Watchdog_Insert+0x6f>
10e5ed: eb 49 jmp 10e638 <_Watchdog_Insert+0x98> 10e5ef: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10e5f0: 8b 35 a0 65 12 00 mov 0x1265a0,%esi 10e5f6: 39 f7 cmp %esi,%edi
10e5f8: 72 72 jb 10e66c <_Watchdog_Insert+0xcc>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10e5fa: 29 c8 sub %ecx,%eax
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e5fc: 8b 12 mov (%edx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e5fe: 85 c0 test %eax,%eax
10e600: 74 3b je 10e63d <_Watchdog_Insert+0x9d>
10e602: 8b 0a mov (%edx),%ecx 10e604: 85 c9 test %ecx,%ecx
10e606: 74 35 je 10e63d <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e608: 8b 4a 10 mov 0x10(%edx),%ecx 10e60b: 39 c1 cmp %eax,%ecx
10e60d: 77 29 ja 10e638 <_Watchdog_Insert+0x98>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
10e60f: ff 75 f0 pushl -0x10(%ebp) 10e612: 9d popf 10e613: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10e614: 83 7b 08 01 cmpl $0x1,0x8(%ebx)
10e618: 74 d6 je 10e5f0 <_Watchdog_Insert+0x50>
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
10e61a: 89 3d a0 65 12 00 mov %edi,0x1265a0
_Watchdog_Sync_count--;
10e620: a1 20 66 12 00 mov 0x126620,%eax 10e625: 48 dec %eax 10e626: a3 20 66 12 00 mov %eax,0x126620
_ISR_Enable( level );
10e62b: ff 75 f0 pushl -0x10(%ebp) 10e62e: 9d popf
}
10e62f: 58 pop %eax 10e630: 5b pop %ebx 10e631: 5e pop %esi 10e632: 5f pop %edi 10e633: c9 leave 10e634: c3 ret 10e635: 8d 76 00 lea 0x0(%esi),%esi
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
10e638: 29 c1 sub %eax,%ecx 10e63a: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
10e63d: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10e644: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10e647: 8b 42 04 mov 0x4(%edx),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10e64a: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10e64d: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10e64f: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10e651: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10e653: 89 5a 04 mov %ebx,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10e656: a1 24 66 12 00 mov 0x126624,%eax 10e65b: 89 43 14 mov %eax,0x14(%ebx) 10e65e: eb ba jmp 10e61a <_Watchdog_Insert+0x7a>
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
10e660: ff 75 f0 pushl -0x10(%ebp) 10e663: 9d popf
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e664: 58 pop %eax 10e665: 5b pop %ebx 10e666: 5e pop %esi 10e667: 5f pop %edi 10e668: c9 leave 10e669: c3 ret 10e66a: 66 90 xchg %ax,%ax
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
10e66c: 89 3d a0 65 12 00 mov %edi,0x1265a0
goto restart;
10e672: e9 5d ff ff ff jmp 10e5d4 <_Watchdog_Insert+0x34>
0010e6e0 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10e6e0: 55 push %ebp 10e6e1: 89 e5 mov %esp,%ebp 10e6e3: 56 push %esi 10e6e4: 53 push %ebx 10e6e5: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10e6e8: 9c pushf 10e6e9: fa cli 10e6ea: 59 pop %ecx
previous_state = the_watchdog->state;
10e6eb: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10e6ee: 83 f8 01 cmp $0x1,%eax
10e6f1: 74 4d je 10e740 <_Watchdog_Remove+0x60>
10e6f3: 73 0f jae 10e704 <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10e6f5: 8b 1d 24 66 12 00 mov 0x126624,%ebx 10e6fb: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10e6fe: 51 push %ecx 10e6ff: 9d popf
return( previous_state ); }
10e700: 5b pop %ebx 10e701: 5e pop %esi 10e702: c9 leave 10e703: c3 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10e704: 83 f8 03 cmp $0x3,%eax
10e707: 77 ec ja 10e6f5 <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10e709: 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 );
}
10e710: 8b 1a mov (%edx),%ebx
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10e712: 8b 33 mov (%ebx),%esi 10e714: 85 f6 test %esi,%esi
10e716: 74 06 je 10e71e <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10e718: 8b 72 10 mov 0x10(%edx),%esi 10e71b: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10e71e: 8b 35 20 66 12 00 mov 0x126620,%esi 10e724: 85 f6 test %esi,%esi
10e726: 74 0c je 10e734 <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10e728: 8b 35 74 67 12 00 mov 0x126774,%esi 10e72e: 89 35 a0 65 12 00 mov %esi,0x1265a0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10e734: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10e737: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10e73a: 89 1e mov %ebx,(%esi) 10e73c: eb b7 jmp 10e6f5 <_Watchdog_Remove+0x15> 10e73e: 66 90 xchg %ax,%ax
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
10e740: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10e747: eb ac jmp 10e6f5 <_Watchdog_Remove+0x15>
0010fa94 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
10fa94: 55 push %ebp 10fa95: 89 e5 mov %esp,%ebp 10fa97: 57 push %edi 10fa98: 56 push %esi 10fa99: 53 push %ebx 10fa9a: 83 ec 2c sub $0x2c,%esp 10fa9d: 8b 55 08 mov 0x8(%ebp),%edx 10faa0: 8b 45 0c mov 0xc(%ebp),%eax
printk(
10faa3: 8b 78 24 mov 0x24(%eax),%edi 10faa6: 8b 70 20 mov 0x20(%eax),%esi 10faa9: 8b 58 1c mov 0x1c(%eax),%ebx 10faac: 8b 48 0c mov 0xc(%eax),%ecx 10faaf: 89 4d d4 mov %ecx,-0x2c(%ebp) 10fab2: 8b 48 10 mov 0x10(%eax),%ecx 10fab5: 89 4d e4 mov %ecx,-0x1c(%ebp) 10fab8: 85 d2 test %edx,%edx
10faba: 74 2c je 10fae8 <_Watchdog_Report+0x54>
10fabc: b9 c3 20 12 00 mov $0x1220c3,%ecx 10fac1: 83 ec 0c sub $0xc,%esp 10fac4: 57 push %edi 10fac5: 56 push %esi 10fac6: 53 push %ebx 10fac7: 50 push %eax 10fac8: ff 75 d4 pushl -0x2c(%ebp) 10facb: ff 75 e4 pushl -0x1c(%ebp) 10face: 51 push %ecx 10facf: 52 push %edx 10fad0: 68 26 2b 12 00 push $0x122b26 10fad5: e8 be 9f ff ff call 109a98 <printk> 10fada: 83 c4 30 add $0x30,%esp
watch,
watch->routine,
watch->id,
watch->user_data
);
}
10fadd: 8d 65 f4 lea -0xc(%ebp),%esp 10fae0: 5b pop %ebx 10fae1: 5e pop %esi 10fae2: 5f pop %edi 10fae3: c9 leave 10fae4: c3 ret 10fae5: 8d 76 00 lea 0x0(%esi),%esi
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
printk(
10fae8: b9 89 29 12 00 mov $0x122989,%ecx 10faed: 89 ca mov %ecx,%edx 10faef: eb d0 jmp 10fac1 <_Watchdog_Report+0x2d>
0010fa24 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10fa24: 55 push %ebp 10fa25: 89 e5 mov %esp,%ebp 10fa27: 57 push %edi 10fa28: 56 push %esi 10fa29: 53 push %ebx 10fa2a: 83 ec 20 sub $0x20,%esp 10fa2d: 8b 7d 08 mov 0x8(%ebp),%edi 10fa30: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10fa33: 9c pushf 10fa34: fa cli 10fa35: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10fa38: 56 push %esi 10fa39: 57 push %edi 10fa3a: 68 f0 2a 12 00 push $0x122af0 10fa3f: e8 54 a0 ff ff call 109a98 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10fa44: 8b 1e mov (%esi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10fa46: 83 c6 04 add $0x4,%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
10fa49: 83 c4 10 add $0x10,%esp 10fa4c: 39 f3 cmp %esi,%ebx
10fa4e: 74 31 je 10fa81 <_Watchdog_Report_chain+0x5d>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10fa50: 83 ec 08 sub $0x8,%esp 10fa53: 53 push %ebx 10fa54: 6a 00 push $0x0 10fa56: e8 39 00 00 00 call 10fa94 <_Watchdog_Report>
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
10fa5b: 8b 1b mov (%ebx),%ebx
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
10fa5d: 83 c4 10 add $0x10,%esp 10fa60: 39 f3 cmp %esi,%ebx
10fa62: 75 ec jne 10fa50 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10fa64: 83 ec 08 sub $0x8,%esp 10fa67: 57 push %edi 10fa68: 68 07 2b 12 00 push $0x122b07 10fa6d: e8 26 a0 ff ff call 109a98 <printk> 10fa72: 83 c4 10 add $0x10,%esp
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10fa75: ff 75 e4 pushl -0x1c(%ebp) 10fa78: 9d popf
}
10fa79: 8d 65 f4 lea -0xc(%ebp),%esp 10fa7c: 5b pop %ebx 10fa7d: 5e pop %esi 10fa7e: 5f pop %edi 10fa7f: c9 leave 10fa80: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10fa81: 83 ec 0c sub $0xc,%esp 10fa84: 68 16 2b 12 00 push $0x122b16 10fa89: e8 0a a0 ff ff call 109a98 <printk> 10fa8e: 83 c4 10 add $0x10,%esp 10fa91: eb e2 jmp 10fa75 <_Watchdog_Report_chain+0x51>
0010e74c <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10e74c: 55 push %ebp 10e74d: 89 e5 mov %esp,%ebp 10e74f: 57 push %edi 10e750: 56 push %esi 10e751: 53 push %ebx 10e752: 83 ec 1c sub $0x1c,%esp 10e755: 8b 7d 08 mov 0x8(%ebp),%edi
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
10e758: 9c pushf 10e759: fa cli 10e75a: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e75b: 8b 1f mov (%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10e75d: 8d 47 04 lea 0x4(%edi),%eax 10e760: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10e763: 39 c3 cmp %eax,%ebx
10e765: 74 11 je 10e778 <_Watchdog_Tickle+0x2c>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
10e767: 8b 43 10 mov 0x10(%ebx),%eax 10e76a: 85 c0 test %eax,%eax
10e76c: 74 34 je 10e7a2 <_Watchdog_Tickle+0x56>
the_watchdog->delta_interval--;
10e76e: 48 dec %eax 10e76f: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10e772: 85 c0 test %eax,%eax
10e774: 74 2c je 10e7a2 <_Watchdog_Tickle+0x56>
10e776: 66 90 xchg %ax,%ax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10e778: 56 push %esi 10e779: 9d popf
}
10e77a: 8d 65 f4 lea -0xc(%ebp),%esp 10e77d: 5b pop %ebx 10e77e: 5e pop %esi 10e77f: 5f pop %edi 10e780: c9 leave 10e781: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10e782: 83 ec 08 sub $0x8,%esp 10e785: ff 73 24 pushl 0x24(%ebx) 10e788: ff 73 20 pushl 0x20(%ebx) 10e78b: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10e78e: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10e791: 9c pushf 10e792: fa cli 10e793: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e794: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10e796: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10e799: 74 dd je 10e778 <_Watchdog_Tickle+0x2c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10e79b: 8b 43 10 mov 0x10(%ebx),%eax 10e79e: 85 c0 test %eax,%eax
10e7a0: 75 d6 jne 10e778 <_Watchdog_Tickle+0x2c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10e7a2: 83 ec 0c sub $0xc,%esp 10e7a5: 53 push %ebx 10e7a6: e8 35 ff ff ff call 10e6e0 <_Watchdog_Remove>
_ISR_Enable( level );
10e7ab: 56 push %esi 10e7ac: 9d popf
switch( watchdog_state ) {
10e7ad: 83 c4 10 add $0x10,%esp 10e7b0: 83 f8 02 cmp $0x2,%eax
10e7b3: 75 dc jne 10e791 <_Watchdog_Tickle+0x45> <== NEVER TAKEN
10e7b5: eb cb jmp 10e782 <_Watchdog_Tickle+0x36>
0010e7b8 <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10e7b8: 55 push %ebp 10e7b9: 89 e5 mov %esp,%ebp 10e7bb: 57 push %edi 10e7bc: 53 push %ebx
uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start;
10e7bd: 8b 1d 20 22 12 00 mov 0x122220,%ebx
uintptr_t size = Configuration.work_space_size;
10e7c3: 8b 15 24 22 12 00 mov 0x122224,%edx
if ( Configuration.do_zero_of_workspace )
10e7c9: 80 3d 4c 22 12 00 00 cmpb $0x0,0x12224c
10e7d0: 75 1e jne 10e7f0 <_Workspace_Handler_initialization+0x38>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10e7d2: 6a 04 push $0x4 10e7d4: 52 push %edx 10e7d5: 53 push %ebx 10e7d6: 68 e0 64 12 00 push $0x1264e0 10e7db: e8 3c de ff ff call 10c61c <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10e7e0: 83 c4 10 add $0x10,%esp 10e7e3: 85 c0 test %eax,%eax
10e7e5: 74 13 je 10e7fa <_Workspace_Handler_initialization+0x42>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10e7e7: 8d 65 f8 lea -0x8(%ebp),%esp 10e7ea: 5b pop %ebx 10e7eb: 5f pop %edi 10e7ec: c9 leave 10e7ed: c3 ret 10e7ee: 66 90 xchg %ax,%ax
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
memset( starting_address, 0, size );
10e7f0: 31 c0 xor %eax,%eax 10e7f2: 89 df mov %ebx,%edi 10e7f4: 89 d1 mov %edx,%ecx 10e7f6: f3 aa rep stos %al,%es:(%edi) 10e7f8: eb d8 jmp 10e7d2 <_Workspace_Handler_initialization+0x1a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10e7fa: 50 push %eax 10e7fb: 6a 02 push $0x2 10e7fd: 6a 01 push $0x1 10e7ff: 6a 00 push $0x0 10e801: e8 1e e0 ff ff call 10c824 <_Internal_error_Occurred>
00112ab4 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
112ab4: 55 push %ebp 112ab5: 89 e5 mov %esp,%ebp 112ab7: 57 push %edi 112ab8: 56 push %esi 112ab9: 53 push %ebx 112aba: 83 ec 2c sub $0x2c,%esp 112abd: 8b 5d 08 mov 0x8(%ebp),%ebx 112ac0: 8b 7d 0c mov 0xc(%ebp),%edi 112ac3: 8b 45 10 mov 0x10(%ebp),%eax 112ac6: 8b 75 14 mov 0x14(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
112ac9: 85 db test %ebx,%ebx
112acb: 0f 84 87 00 00 00 je 112b58 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
112ad1: 85 f6 test %esi,%esi
112ad3: 0f 84 bf 00 00 00 je 112b98 <rtems_barrier_create+0xe4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
112ad9: f7 c7 10 00 00 00 test $0x10,%edi
112adf: 0f 84 83 00 00 00 je 112b68 <rtems_barrier_create+0xb4>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
112ae5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( maximum_waiters == 0 )
112aec: 85 c0 test %eax,%eax
112aee: 0f 84 80 00 00 00 je 112b74 <rtems_barrier_create+0xc0><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
112af4: 89 45 e4 mov %eax,-0x1c(%ebp) 112af7: a1 d0 84 12 00 mov 0x1284d0,%eax 112afc: 40 inc %eax 112afd: a3 d0 84 12 00 mov %eax,0x1284d0
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )
{
return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
112b02: 83 ec 0c sub $0xc,%esp 112b05: 68 00 88 12 00 push $0x128800 112b0a: e8 01 bb ff ff call 10e610 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
112b0f: 83 c4 10 add $0x10,%esp 112b12: 85 c0 test %eax,%eax
112b14: 74 6e je 112b84 <rtems_barrier_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
112b16: 89 78 10 mov %edi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
112b19: 83 ec 08 sub $0x8,%esp 112b1c: 8d 55 e0 lea -0x20(%ebp),%edx 112b1f: 52 push %edx 112b20: 8d 50 14 lea 0x14(%eax),%edx 112b23: 52 push %edx 112b24: 89 45 d4 mov %eax,-0x2c(%ebp) 112b27: e8 c0 07 00 00 call 1132ec <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
112b2c: 8b 45 d4 mov -0x2c(%ebp),%eax 112b2f: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
112b32: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
112b35: 8b 0d 1c 88 12 00 mov 0x12881c,%ecx 112b3b: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
112b3e: 89 58 0c mov %ebx,0xc(%eax)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
112b41: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
112b43: e8 38 ca ff ff call 10f580 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
112b48: 83 c4 10 add $0x10,%esp 112b4b: 31 c0 xor %eax,%eax
}
112b4d: 8d 65 f4 lea -0xc(%ebp),%esp 112b50: 5b pop %ebx 112b51: 5e pop %esi 112b52: 5f pop %edi 112b53: c9 leave 112b54: c3 ret 112b55: 8d 76 00 lea 0x0(%esi),%esi
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
112b58: b8 03 00 00 00 mov $0x3,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112b5d: 8d 65 f4 lea -0xc(%ebp),%esp 112b60: 5b pop %ebx 112b61: 5e pop %esi 112b62: 5f pop %edi 112b63: c9 leave 112b64: c3 ret 112b65: 8d 76 00 lea 0x0(%esi),%esi
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
112b68: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 112b6f: eb 83 jmp 112af4 <rtems_barrier_create+0x40> 112b71: 8d 76 00 lea 0x0(%esi),%esi
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
112b74: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112b79: 8d 65 f4 lea -0xc(%ebp),%esp 112b7c: 5b pop %ebx 112b7d: 5e pop %esi 112b7e: 5f pop %edi 112b7f: c9 leave 112b80: c3 ret 112b81: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
112b84: e8 f7 c9 ff ff call 10f580 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
112b89: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112b8e: 8d 65 f4 lea -0xc(%ebp),%esp 112b91: 5b pop %ebx 112b92: 5e pop %esi 112b93: 5f pop %edi 112b94: c9 leave 112b95: c3 ret 112b96: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
112b98: b8 09 00 00 00 mov $0x9,%eax 112b9d: eb ae jmp 112b4d <rtems_barrier_create+0x99>
0010c14c <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c14c: 55 push %ebp 10c14d: 89 e5 mov %esp,%ebp 10c14f: 56 push %esi 10c150: 53 push %ebx 10c151: 8b 5d 10 mov 0x10(%ebp),%ebx 10c154: 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 );
10c157: 83 ec 08 sub $0x8,%esp 10c15a: ff 75 0c pushl 0xc(%ebp) 10c15d: ff 75 08 pushl 0x8(%ebp) 10c160: e8 97 04 00 00 call 10c5fc <_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 ) {
10c165: 83 c4 10 add $0x10,%esp 10c168: 84 c0 test %al,%al
10c16a: 75 0c jne 10c178 <rtems_chain_append_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c16c: 31 c0 xor %eax,%eax
10c16e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c171: 5b pop %ebx <== NOT EXECUTED 10c172: 5e pop %esi <== NOT EXECUTED 10c173: c9 leave <== NOT EXECUTED 10c174: c3 ret <== NOT EXECUTED 10c175: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10c178: 89 75 0c mov %esi,0xc(%ebp) 10c17b: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c17e: 8d 65 f8 lea -0x8(%ebp),%esp 10c181: 5b pop %ebx 10c182: 5e pop %esi 10c183: 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 );
10c184: e9 a3 f5 ff ff jmp 10b72c <rtems_event_send>
0010c18c <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
10c18c: 55 push %ebp 10c18d: 89 e5 mov %esp,%ebp 10c18f: 56 push %esi 10c190: 53 push %ebx 10c191: 8b 5d 0c mov 0xc(%ebp),%ebx 10c194: 8b 75 10 mov 0x10(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
10c197: 83 ec 08 sub $0x8,%esp 10c19a: ff 75 14 pushl 0x14(%ebp) 10c19d: ff 75 08 pushl 0x8(%ebp) 10c1a0: e8 bf 04 00 00 call 10c664 <_Chain_Get_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
10c1a5: 83 c4 10 add $0x10,%esp 10c1a8: 84 c0 test %al,%al
10c1aa: 75 0c jne 10c1b8 <rtems_chain_get_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10c1ac: 31 c0 xor %eax,%eax 10c1ae: 8d 65 f8 lea -0x8(%ebp),%esp 10c1b1: 5b pop %ebx 10c1b2: 5e pop %esi 10c1b3: c9 leave 10c1b4: c3 ret 10c1b5: 8d 76 00 lea 0x0(%esi),%esi
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
10c1b8: 89 75 0c mov %esi,0xc(%ebp) 10c1bb: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c1be: 8d 65 f8 lea -0x8(%ebp),%esp 10c1c1: 5b pop %ebx 10c1c2: 5e pop %esi 10c1c3: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
10c1c4: e9 63 f5 ff ff jmp 10b72c <rtems_event_send>
0010c1cc <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10c1cc: 55 push %ebp 10c1cd: 89 e5 mov %esp,%ebp 10c1cf: 57 push %edi 10c1d0: 56 push %esi 10c1d1: 53 push %ebx 10c1d2: 83 ec 1c sub $0x1c,%esp 10c1d5: 8b 75 08 mov 0x8(%ebp),%esi
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
10c1d8: 8d 7d e4 lea -0x1c(%ebp),%edi 10c1db: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10c1dc: 83 ec 0c sub $0xc,%esp 10c1df: 56 push %esi 10c1e0: e8 bb 04 00 00 call 10c6a0 <_Chain_Get> 10c1e5: 89 c3 mov %eax,%ebx
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c1e7: 83 c4 10 add $0x10,%esp 10c1ea: 85 c0 test %eax,%eax
10c1ec: 75 22 jne 10c210 <rtems_chain_get_with_wait+0x44>
) {
rtems_event_set out;
sc = rtems_event_receive(
10c1ee: 57 push %edi 10c1ef: ff 75 10 pushl 0x10(%ebp) 10c1f2: 6a 00 push $0x0 10c1f4: ff 75 0c pushl 0xc(%ebp) 10c1f7: e8 a8 f3 ff ff call 10b5a4 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10c1fc: 83 c4 10 add $0x10,%esp 10c1ff: 85 c0 test %eax,%eax
10c201: 74 d9 je 10c1dc <rtems_chain_get_with_wait+0x10><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10c203: 8b 55 14 mov 0x14(%ebp),%edx 10c206: 89 1a mov %ebx,(%edx)
return sc;
}
10c208: 8d 65 f4 lea -0xc(%ebp),%esp 10c20b: 5b pop %ebx 10c20c: 5e pop %esi 10c20d: 5f pop %edi 10c20e: c9 leave 10c20f: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c210: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10c212: 8b 55 14 mov 0x14(%ebp),%edx 10c215: 89 1a mov %ebx,(%edx)
return sc;
}
10c217: 8d 65 f4 lea -0xc(%ebp),%esp 10c21a: 5b pop %ebx 10c21b: 5e pop %esi 10c21c: 5f pop %edi 10c21d: c9 leave 10c21e: c3 ret
0010c220 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c220: 55 push %ebp 10c221: 89 e5 mov %esp,%ebp 10c223: 56 push %esi 10c224: 53 push %ebx 10c225: 8b 5d 10 mov 0x10(%ebp),%ebx 10c228: 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 );
10c22b: 83 ec 08 sub $0x8,%esp 10c22e: ff 75 0c pushl 0xc(%ebp) 10c231: ff 75 08 pushl 0x8(%ebp) 10c234: e8 ab 04 00 00 call 10c6e4 <_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) {
10c239: 83 c4 10 add $0x10,%esp 10c23c: 84 c0 test %al,%al
10c23e: 75 0c jne 10c24c <rtems_chain_prepend_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c240: 31 c0 xor %eax,%eax
10c242: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c245: 5b pop %ebx <== NOT EXECUTED 10c246: 5e pop %esi <== NOT EXECUTED 10c247: c9 leave <== NOT EXECUTED 10c248: c3 ret <== NOT EXECUTED 10c249: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10c24c: 89 75 0c mov %esi,0xc(%ebp) 10c24f: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c252: 8d 65 f8 lea -0x8(%ebp),%esp 10c255: 5b pop %ebx 10c256: 5e pop %esi 10c257: 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 );
10c258: e9 cf f4 ff ff jmp 10b72c <rtems_event_send>
00115a60 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
115a60: 55 push %ebp 115a61: 89 e5 mov %esp,%ebp 115a63: 53 push %ebx 115a64: 83 ec 04 sub $0x4,%esp 115a67: 8b 45 08 mov 0x8(%ebp),%eax 115a6a: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
115a6d: 85 db test %ebx,%ebx
115a6f: 74 3b je 115aac <rtems_clock_get+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
115a71: 85 c0 test %eax,%eax
115a73: 74 2b je 115aa0 <rtems_clock_get+0x40>
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
115a75: 83 f8 01 cmp $0x1,%eax
115a78: 74 3e je 115ab8 <rtems_clock_get+0x58>
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
115a7a: 83 f8 02 cmp $0x2,%eax
115a7d: 74 45 je 115ac4 <rtems_clock_get+0x64>
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
115a7f: 83 f8 03 cmp $0x3,%eax
115a82: 74 4c je 115ad0 <rtems_clock_get+0x70>
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
115a84: 83 f8 04 cmp $0x4,%eax
115a87: 74 0b je 115a94 <rtems_clock_get+0x34>
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
115a89: b8 0a 00 00 00 mov $0xa,%eax
}
115a8e: 5a pop %edx 115a8f: 5b pop %ebx 115a90: c9 leave 115a91: c3 ret 115a92: 66 90 xchg %ax,%ax
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
115a94: 89 5d 08 mov %ebx,0x8(%ebp)
return RTEMS_INVALID_NUMBER;
}
115a97: 59 pop %ecx 115a98: 5b pop %ebx 115a99: c9 leave
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
115a9a: e9 41 01 00 00 jmp 115be0 <rtems_clock_get_tod_timeval> 115a9f: 90 nop
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
115aa0: 89 5d 08 mov %ebx,0x8(%ebp)
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
115aa3: 58 pop %eax 115aa4: 5b pop %ebx 115aa5: c9 leave
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
115aa6: e9 81 00 00 00 jmp 115b2c <rtems_clock_get_tod> 115aab: 90 nop
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
115aac: b8 09 00 00 00 mov $0x9,%eax
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
115ab1: 5a pop %edx 115ab2: 5b pop %ebx 115ab3: c9 leave 115ab4: c3 ret 115ab5: 8d 76 00 lea 0x0(%esi),%esi
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
115ab8: 89 5d 08 mov %ebx,0x8(%ebp)
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
115abb: 5b pop %ebx 115abc: 5b pop %ebx 115abd: c9 leave
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
115abe: e9 19 00 00 00 jmp 115adc <rtems_clock_get_seconds_since_epoch> 115ac3: 90 nop
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
115ac4: e8 57 00 00 00 call 115b20 <rtems_clock_get_ticks_since_boot> 115ac9: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115acb: 31 c0 xor %eax,%eax 115acd: eb bf jmp 115a8e <rtems_clock_get+0x2e> 115acf: 90 nop
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
115ad0: e8 37 00 00 00 call 115b0c <rtems_clock_get_ticks_per_second> 115ad5: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115ad7: 31 c0 xor %eax,%eax 115ad9: eb b3 jmp 115a8e <rtems_clock_get+0x2e>
00115be0 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
115be0: 55 push %ebp 115be1: 89 e5 mov %esp,%ebp 115be3: 56 push %esi 115be4: 53 push %ebx 115be5: 83 ec 10 sub $0x10,%esp 115be8: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !time )
115beb: 85 db test %ebx,%ebx
115bed: 74 51 je 115c40 <rtems_clock_get_tod_timeval+0x60>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
115bef: 80 3d 04 09 14 00 00 cmpb $0x0,0x140904
115bf6: 75 0c jne 115c04 <rtems_clock_get_tod_timeval+0x24>
return RTEMS_NOT_DEFINED;
115bf8: b8 0b 00 00 00 mov $0xb,%eax
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
115bfd: 8d 65 f8 lea -0x8(%ebp),%esp 115c00: 5b pop %ebx 115c01: 5e pop %esi 115c02: c9 leave 115c03: c3 ret
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
115c04: 9c pushf 115c05: fa cli 115c06: 5e pop %esi
_TOD_Get( &now );
115c07: 83 ec 0c sub $0xc,%esp 115c0a: 8d 45 f0 lea -0x10(%ebp),%eax 115c0d: 50 push %eax 115c0e: e8 e9 42 00 00 call 119efc <_TOD_Get>
_ISR_Enable(level);
115c13: 56 push %esi 115c14: 9d popf
useconds = (suseconds_t)now.tv_nsec;
115c15: 8b 4d f4 mov -0xc(%ebp),%ecx
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
115c18: 8b 45 f0 mov -0x10(%ebp),%eax 115c1b: 89 03 mov %eax,(%ebx)
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
115c1d: b8 d3 4d 62 10 mov $0x10624dd3,%eax 115c22: f7 e9 imul %ecx 115c24: 89 d0 mov %edx,%eax 115c26: c1 f8 06 sar $0x6,%eax 115c29: c1 f9 1f sar $0x1f,%ecx 115c2c: 29 c8 sub %ecx,%eax 115c2e: 89 43 04 mov %eax,0x4(%ebx)
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
115c31: 83 c4 10 add $0x10,%esp 115c34: 31 c0 xor %eax,%eax
}
115c36: 8d 65 f8 lea -0x8(%ebp),%esp 115c39: 5b pop %ebx 115c3a: 5e pop %esi 115c3b: c9 leave 115c3c: c3 ret 115c3d: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
115c40: b8 09 00 00 00 mov $0x9,%eax 115c45: eb b6 jmp 115bfd <rtems_clock_get_tod_timeval+0x1d>
0010b1f0 <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
10b1f0: 55 push %ebp 10b1f1: 89 e5 mov %esp,%ebp 10b1f3: 83 ec 08 sub $0x8,%esp 10b1f6: 8b 45 08 mov 0x8(%ebp),%eax
if ( !uptime )
10b1f9: 85 c0 test %eax,%eax
10b1fb: 74 13 je 10b210 <rtems_clock_get_uptime+0x20>
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
10b1fd: 83 ec 0c sub $0xc,%esp 10b200: 50 push %eax 10b201: e8 a6 15 00 00 call 10c7ac <_TOD_Get_uptime_as_timespec>
return RTEMS_SUCCESSFUL;
10b206: 83 c4 10 add $0x10,%esp 10b209: 31 c0 xor %eax,%eax
}
10b20b: c9 leave 10b20c: c3 ret 10b20d: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
10b210: b8 09 00 00 00 mov $0x9,%eax
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
10b215: c9 leave 10b216: c3 ret
0010c12c <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
10c12c: 55 push %ebp 10c12d: 89 e5 mov %esp,%ebp 10c12f: 53 push %ebx 10c130: 83 ec 14 sub $0x14,%esp 10c133: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10c136: 85 db test %ebx,%ebx
10c138: 74 66 je 10c1a0 <rtems_clock_set+0x74>
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
10c13a: 83 ec 0c sub $0xc,%esp 10c13d: 53 push %ebx 10c13e: e8 39 01 00 00 call 10c27c <_TOD_Validate> 10c143: 83 c4 10 add $0x10,%esp 10c146: 84 c0 test %al,%al
10c148: 75 0a jne 10c154 <rtems_clock_set+0x28>
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
10c14a: b8 14 00 00 00 mov $0x14,%eax
}
10c14f: 8b 5d fc mov -0x4(%ebp),%ebx 10c152: c9 leave 10c153: c3 ret
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
10c154: 83 ec 0c sub $0xc,%esp 10c157: 53 push %ebx 10c158: e8 93 00 00 00 call 10c1f0 <_TOD_To_seconds> 10c15d: 89 45 f0 mov %eax,-0x10(%ebp)
newtime.tv_nsec = time_buffer->ticks *
10c160: 8b 43 18 mov 0x18(%ebx),%eax 10c163: 0f af 05 2c 52 12 00 imul 0x12522c,%eax 10c16a: 8d 04 80 lea (%eax,%eax,4),%eax 10c16d: 8d 04 80 lea (%eax,%eax,4),%eax 10c170: 8d 04 80 lea (%eax,%eax,4),%eax 10c173: c1 e0 03 shl $0x3,%eax 10c176: 89 45 f4 mov %eax,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c179: a1 10 13 13 00 mov 0x131310,%eax 10c17e: 40 inc %eax 10c17f: a3 10 13 13 00 mov %eax,0x131310
rtems_configuration_get_nanoseconds_per_tick();
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
10c184: 8d 45 f0 lea -0x10(%ebp),%eax 10c187: 89 04 24 mov %eax,(%esp) 10c18a: e8 85 18 00 00 call 10da14 <_TOD_Set>
_Thread_Enable_dispatch();
10c18f: e8 d4 2d 00 00 call 10ef68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c194: 83 c4 10 add $0x10,%esp 10c197: 31 c0 xor %eax,%eax
} return RTEMS_INVALID_CLOCK; }
10c199: 8b 5d fc mov -0x4(%ebp),%ebx 10c19c: c9 leave 10c19d: c3 ret 10c19e: 66 90 xchg %ax,%ax
)
{
struct timespec newtime;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10c1a0: b8 09 00 00 00 mov $0x9,%eax
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10c1a5: 8b 5d fc mov -0x4(%ebp),%ebx 10c1a8: c9 leave 10c1a9: c3 ret
0010afd0 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
10afd0: 55 push %ebp 10afd1: 89 e5 mov %esp,%ebp 10afd3: 83 ec 08 sub $0x8,%esp
_TOD_Tickle_ticks();
10afd6: e8 69 14 00 00 call 10c444 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
10afdb: 83 ec 0c sub $0xc,%esp 10afde: 68 bc 65 12 00 push $0x1265bc 10afe3: e8 64 37 00 00 call 10e74c <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
10afe8: e8 47 32 00 00 call 10e234 <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
10afed: a0 84 67 12 00 mov 0x126784,%al
if ( _Thread_Is_context_switch_necessary() &&
10aff2: 83 c4 10 add $0x10,%esp 10aff5: 84 c0 test %al,%al
10aff7: 74 09 je 10b002 <rtems_clock_tick+0x32>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
10aff9: a1 b0 64 12 00 mov 0x1264b0,%eax 10affe: 85 c0 test %eax,%eax
10b000: 74 06 je 10b008 <rtems_clock_tick+0x38>
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
10b002: 31 c0 xor %eax,%eax 10b004: c9 leave 10b005: c3 ret 10b006: 66 90 xchg %ax,%ax
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
10b008: e8 6f 26 00 00 call 10d67c <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
}
10b00d: 31 c0 xor %eax,%eax 10b00f: c9 leave 10b010: c3 ret
0010b19c <rtems_event_send>:
rtems_status_code rtems_event_send(
rtems_id id,
rtems_event_set event_in
)
{
10b19c: 55 push %ebp 10b19d: 89 e5 mov %esp,%ebp 10b19f: 53 push %ebx 10b1a0: 83 ec 1c sub $0x1c,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
the_thread = _Thread_Get( id, &location );
10b1a3: 8d 45 f4 lea -0xc(%ebp),%eax 10b1a6: 50 push %eax 10b1a7: ff 75 08 pushl 0x8(%ebp) 10b1aa: e8 69 26 00 00 call 10d818 <_Thread_Get>
switch ( location ) {
10b1af: 83 c4 10 add $0x10,%esp 10b1b2: 8b 55 f4 mov -0xc(%ebp),%edx 10b1b5: 85 d2 test %edx,%edx
10b1b7: 75 2b jne 10b1e4 <rtems_event_send+0x48>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10b1b9: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx
rtems_event_set *the_event_set
)
{
ISR_Level level;
_ISR_Disable( level );
10b1bf: 9c pushf 10b1c0: fa cli 10b1c1: 59 pop %ecx
*the_event_set |= the_new_events;
10b1c2: 8b 5d 0c mov 0xc(%ebp),%ebx 10b1c5: 09 1a or %ebx,(%edx)
_ISR_Enable( level );
10b1c7: 51 push %ecx 10b1c8: 9d popf
_Event_sets_Post( event_in, &api->pending_events );
_Event_Surrender( the_thread );
10b1c9: 83 ec 0c sub $0xc,%esp 10b1cc: 50 push %eax 10b1cd: e8 1e 00 00 00 call 10b1f0 <_Event_Surrender>
_Thread_Enable_dispatch();
10b1d2: e8 1d 26 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b1d7: 83 c4 10 add $0x10,%esp 10b1da: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b1dc: 8b 5d fc mov -0x4(%ebp),%ebx 10b1df: c9 leave 10b1e0: c3 ret 10b1e1: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1e4: b8 04 00 00 00 mov $0x4,%eax
}
10b1e9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ec: c9 leave 10b1ed: c3 ret
0010d008 <rtems_extension_delete>:
#include <rtems/extension.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
10d008: 55 push %ebp 10d009: 89 e5 mov %esp,%ebp 10d00b: 53 push %ebx 10d00c: 83 ec 18 sub $0x18,%esp
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
10d00f: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Extension_Control *)
_Objects_Get( &_Extension_Information, id, location );
10d012: 50 push %eax 10d013: ff 75 08 pushl 0x8(%ebp) 10d016: 68 a0 19 13 00 push $0x1319a0 10d01b: e8 54 11 00 00 call 10e174 <_Objects_Get> 10d020: 89 c3 mov %eax,%ebx
switch ( location ) {
10d022: 83 c4 10 add $0x10,%esp 10d025: 8b 55 f4 mov -0xc(%ebp),%edx 10d028: 85 d2 test %edx,%edx
10d02a: 75 38 jne 10d064 <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10d02c: 83 ec 0c sub $0xc,%esp 10d02f: 8d 40 10 lea 0x10(%eax),%eax 10d032: 50 push %eax 10d033: e8 50 28 00 00 call 10f888 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10d038: 59 pop %ecx 10d039: 58 pop %eax 10d03a: 53 push %ebx 10d03b: 68 a0 19 13 00 push $0x1319a0 10d040: e8 f3 0c 00 00 call 10dd38 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _Extension_Free (
Extension_Control *the_extension
)
{
_Objects_Free( &_Extension_Information, &the_extension->Object );
10d045: 58 pop %eax 10d046: 5a pop %edx 10d047: 53 push %ebx 10d048: 68 a0 19 13 00 push $0x1319a0 10d04d: e8 e2 0f 00 00 call 10e034 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10d052: e8 a5 1b 00 00 call 10ebfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d057: 83 c4 10 add $0x10,%esp 10d05a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d05c: 8b 5d fc mov -0x4(%ebp),%ebx 10d05f: c9 leave 10d060: c3 ret 10d061: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d064: b8 04 00 00 00 mov $0x4,%eax
}
10d069: 8b 5d fc mov -0x4(%ebp),%ebx 10d06c: c9 leave 10d06d: c3 ret
00112088 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112088: 55 push %ebp 112089: 89 e5 mov %esp,%ebp 11208b: 53 push %ebx 11208c: 83 ec 04 sub $0x4,%esp 11208f: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112092: 39 05 80 68 12 00 cmp %eax,0x126880
112098: 76 1a jbe 1120b4 <rtems_io_close+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
11209a: 8d 14 40 lea (%eax,%eax,2),%edx 11209d: c1 e2 03 shl $0x3,%edx 1120a0: 03 15 84 68 12 00 add 0x126884,%edx 1120a6: 8b 52 08 mov 0x8(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1120a9: 85 d2 test %edx,%edx
1120ab: 74 13 je 1120c0 <rtems_io_close+0x38> }
1120ad: 59 pop %ecx 1120ae: 5b pop %ebx 1120af: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1120b0: ff e2 jmp *%edx 1120b2: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
1120b4: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
1120b9: 5a pop %edx 1120ba: 5b pop %ebx 1120bb: c9 leave 1120bc: c3 ret 1120bd: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1120c0: 31 c0 xor %eax,%eax
}
1120c2: 5a pop %edx 1120c3: 5b pop %ebx 1120c4: c9 leave 1120c5: c3 ret
001120c8 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
1120c8: 55 push %ebp 1120c9: 89 e5 mov %esp,%ebp 1120cb: 53 push %ebx 1120cc: 83 ec 04 sub $0x4,%esp 1120cf: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
1120d2: 39 05 80 68 12 00 cmp %eax,0x126880
1120d8: 76 1a jbe 1120f4 <rtems_io_control+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
1120da: 8d 14 40 lea (%eax,%eax,2),%edx 1120dd: c1 e2 03 shl $0x3,%edx 1120e0: 03 15 84 68 12 00 add 0x126884,%edx 1120e6: 8b 52 14 mov 0x14(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1120e9: 85 d2 test %edx,%edx
1120eb: 74 13 je 112100 <rtems_io_control+0x38> }
1120ed: 59 pop %ecx 1120ee: 5b pop %ebx 1120ef: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1120f0: ff e2 jmp *%edx 1120f2: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
1120f4: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
1120f9: 5a pop %edx 1120fa: 5b pop %ebx 1120fb: c9 leave 1120fc: c3 ret 1120fd: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112100: 31 c0 xor %eax,%eax
}
112102: 5a pop %edx 112103: 5b pop %ebx 112104: c9 leave 112105: c3 ret
001104f8 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
1104f8: 55 push %ebp 1104f9: 89 e5 mov %esp,%ebp 1104fb: 53 push %ebx 1104fc: 83 ec 04 sub $0x4,%esp 1104ff: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
110502: 39 05 80 68 12 00 cmp %eax,0x126880
110508: 76 1a jbe 110524 <rtems_io_initialize+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
11050a: 8d 14 40 lea (%eax,%eax,2),%edx 11050d: c1 e2 03 shl $0x3,%edx 110510: 03 15 84 68 12 00 add 0x126884,%edx 110516: 8b 12 mov (%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
110518: 85 d2 test %edx,%edx
11051a: 74 14 je 110530 <rtems_io_initialize+0x38> }
11051c: 59 pop %ecx 11051d: 5b pop %ebx 11051e: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
11051f: ff e2 jmp *%edx 110521: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
110524: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
110529: 5a pop %edx 11052a: 5b pop %ebx 11052b: c9 leave 11052c: c3 ret 11052d: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
110530: 31 c0 xor %eax,%eax
}
110532: 5a pop %edx 110533: 5b pop %ebx 110534: c9 leave 110535: c3 ret
00112108 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112108: 55 push %ebp 112109: 89 e5 mov %esp,%ebp 11210b: 53 push %ebx 11210c: 83 ec 04 sub $0x4,%esp 11210f: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112112: 39 05 80 68 12 00 cmp %eax,0x126880
112118: 76 1a jbe 112134 <rtems_io_open+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
11211a: 8d 14 40 lea (%eax,%eax,2),%edx 11211d: c1 e2 03 shl $0x3,%edx 112120: 03 15 84 68 12 00 add 0x126884,%edx 112126: 8b 52 04 mov 0x4(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112129: 85 d2 test %edx,%edx
11212b: 74 13 je 112140 <rtems_io_open+0x38> }
11212d: 59 pop %ecx 11212e: 5b pop %ebx 11212f: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112130: ff e2 jmp *%edx 112132: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112134: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112139: 5a pop %edx 11213a: 5b pop %ebx 11213b: c9 leave 11213c: c3 ret 11213d: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112140: 31 c0 xor %eax,%eax
}
112142: 5a pop %edx 112143: 5b pop %ebx 112144: c9 leave 112145: c3 ret
00112148 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112148: 55 push %ebp 112149: 89 e5 mov %esp,%ebp 11214b: 53 push %ebx 11214c: 83 ec 04 sub $0x4,%esp 11214f: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112152: 39 05 80 68 12 00 cmp %eax,0x126880
112158: 76 1a jbe 112174 <rtems_io_read+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
11215a: 8d 14 40 lea (%eax,%eax,2),%edx 11215d: c1 e2 03 shl $0x3,%edx 112160: 03 15 84 68 12 00 add 0x126884,%edx 112166: 8b 52 0c mov 0xc(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112169: 85 d2 test %edx,%edx
11216b: 74 13 je 112180 <rtems_io_read+0x38> }
11216d: 59 pop %ecx 11216e: 5b pop %ebx 11216f: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112170: ff e2 jmp *%edx 112172: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112174: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112179: 5a pop %edx 11217a: 5b pop %ebx 11217b: c9 leave 11217c: c3 ret 11217d: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112180: 31 c0 xor %eax,%eax
}
112182: 5a pop %edx 112183: 5b pop %ebx 112184: c9 leave 112185: c3 ret
0010cec8 <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
)
{
10cec8: 55 push %ebp 10cec9: 89 e5 mov %esp,%ebp 10cecb: 57 push %edi 10cecc: 56 push %esi 10cecd: 53 push %ebx 10cece: 83 ec 0c sub $0xc,%esp 10ced1: 8b 5d 08 mov 0x8(%ebp),%ebx 10ced4: 8b 75 0c mov 0xc(%ebp),%esi 10ced7: 8b 55 10 mov 0x10(%ebp),%edx
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10ceda: a1 80 ac 12 00 mov 0x12ac80,%eax
if ( rtems_interrupt_is_in_progress() )
10cedf: 8b 0d 74 ab 12 00 mov 0x12ab74,%ecx 10cee5: 85 c9 test %ecx,%ecx
10cee7: 0f 85 ab 00 00 00 jne 10cf98 <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10ceed: 85 d2 test %edx,%edx
10ceef: 0f 84 e7 00 00 00 je 10cfdc <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10cef5: 89 02 mov %eax,(%edx)
if ( driver_table == NULL )
10cef7: 85 f6 test %esi,%esi
10cef9: 0f 84 dd 00 00 00 je 10cfdc <rtems_io_register_driver+0x114>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10ceff: 8b 3e mov (%esi),%edi 10cf01: 85 ff test %edi,%edi
10cf03: 0f 84 c7 00 00 00 je 10cfd0 <rtems_io_register_driver+0x108>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10cf09: 39 d8 cmp %ebx,%eax
10cf0b: 76 7b jbe 10cf88 <rtems_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10cf0d: a1 b0 a8 12 00 mov 0x12a8b0,%eax 10cf12: 40 inc %eax 10cf13: a3 b0 a8 12 00 mov %eax,0x12a8b0
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10cf18: 85 db test %ebx,%ebx
10cf1a: 0f 85 88 00 00 00 jne 10cfa8 <rtems_io_register_driver+0xe0>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
10cf20: 8b 0d 80 ac 12 00 mov 0x12ac80,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10cf26: 85 c9 test %ecx,%ecx
10cf28: 0f 84 bb 00 00 00 je 10cfe9 <rtems_io_register_driver+0x121><== NEVER TAKEN
10cf2e: 8b 3d 84 ac 12 00 mov 0x12ac84,%edi 10cf34: 89 f8 mov %edi,%eax 10cf36: eb 08 jmp 10cf40 <rtems_io_register_driver+0x78> 10cf38: 43 inc %ebx 10cf39: 83 c0 18 add $0x18,%eax 10cf3c: 39 d9 cmp %ebx,%ecx
10cf3e: 76 0b jbe 10cf4b <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;
10cf40: 83 38 00 cmpl $0x0,(%eax)
10cf43: 75 f3 jne 10cf38 <rtems_io_register_driver+0x70>
10cf45: 83 78 04 00 cmpl $0x0,0x4(%eax)
10cf49: 75 ed jne 10cf38 <rtems_io_register_driver+0x70>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cf4b: 89 1a mov %ebx,(%edx)
if ( m != n )
10cf4d: 39 d9 cmp %ebx,%ecx
10cf4f: 0f 84 9b 00 00 00 je 10cff0 <rtems_io_register_driver+0x128>
10cf55: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cf58: c1 e0 03 shl $0x3,%eax
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10cf5b: 01 c7 add %eax,%edi 10cf5d: b9 06 00 00 00 mov $0x6,%ecx 10cf62: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10cf64: e8 a7 1b 00 00 call 10eb10 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10cf69: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10cf70: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10cf77: 89 5d 08 mov %ebx,0x8(%ebp)
}
10cf7a: 83 c4 0c add $0xc,%esp 10cf7d: 5b pop %ebx 10cf7e: 5e pop %esi 10cf7f: 5f pop %edi 10cf80: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10cf81: e9 1e 73 00 00 jmp 1142a4 <rtems_io_initialize> 10cf86: 66 90 xchg %ax,%ax
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10cf88: 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 );
}
10cf8d: 83 c4 0c add $0xc,%esp 10cf90: 5b pop %ebx 10cf91: 5e pop %esi 10cf92: 5f pop %edi 10cf93: c9 leave 10cf94: c3 ret 10cf95: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10cf98: b8 12 00 00 00 mov $0x12,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10cf9d: 83 c4 0c add $0xc,%esp 10cfa0: 5b pop %ebx 10cfa1: 5e pop %esi 10cfa2: 5f pop %edi 10cfa3: c9 leave 10cfa4: c3 ret 10cfa5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
10cfa8: 8d 04 5b lea (%ebx,%ebx,2),%eax 10cfab: c1 e0 03 shl $0x3,%eax 10cfae: 8b 0d 84 ac 12 00 mov 0x12ac84,%ecx 10cfb4: 01 c1 add %eax,%ecx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10cfb6: 8b 39 mov (%ecx),%edi 10cfb8: 85 ff test %edi,%edi
10cfba: 74 40 je 10cffc <rtems_io_register_driver+0x134>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
10cfbc: e8 4f 1b 00 00 call 10eb10 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10cfc1: b8 0c 00 00 00 mov $0xc,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10cfc6: 83 c4 0c add $0xc,%esp 10cfc9: 5b pop %ebx 10cfca: 5e pop %esi 10cfcb: 5f pop %edi 10cfcc: c9 leave 10cfcd: c3 ret 10cfce: 66 90 xchg %ax,%ax
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10cfd0: 8b 4e 04 mov 0x4(%esi),%ecx 10cfd3: 85 c9 test %ecx,%ecx
10cfd5: 0f 85 2e ff ff ff jne 10cf09 <rtems_io_register_driver+0x41>
10cfdb: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10cfdc: b8 09 00 00 00 mov $0x9,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10cfe1: 83 c4 0c add $0xc,%esp 10cfe4: 5b pop %ebx 10cfe5: 5e pop %esi 10cfe6: 5f pop %edi 10cfe7: c9 leave 10cfe8: c3 ret
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cfe9: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 10cfef: 90 nop <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10cff0: e8 1b 1b 00 00 call 10eb10 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10cff5: 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;
10cffa: eb 91 jmp 10cf8d <rtems_io_register_driver+0xc5>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10cffc: 8b 49 04 mov 0x4(%ecx),%ecx 10cfff: 85 c9 test %ecx,%ecx
10d001: 75 b9 jne 10cfbc <rtems_io_register_driver+0xf4>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10d003: 89 1a mov %ebx,(%edx) 10d005: 8b 3d 84 ac 12 00 mov 0x12ac84,%edi 10d00b: e9 4b ff ff ff jmp 10cf5b <rtems_io_register_driver+0x93>
0010d010 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10d010: 55 push %ebp 10d011: 89 e5 mov %esp,%ebp 10d013: 57 push %edi 10d014: 83 ec 04 sub $0x4,%esp 10d017: 8b 45 08 mov 0x8(%ebp),%eax
if ( rtems_interrupt_is_in_progress() )
10d01a: 8b 0d 74 ab 12 00 mov 0x12ab74,%ecx 10d020: 85 c9 test %ecx,%ecx
10d022: 75 44 jne 10d068 <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10d024: 39 05 80 ac 12 00 cmp %eax,0x12ac80
10d02a: 77 0c ja 10d038 <rtems_io_unregister_driver+0x28>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
10d02c: b8 0d 00 00 00 mov $0xd,%eax
}
10d031: 5a pop %edx 10d032: 5f pop %edi 10d033: c9 leave 10d034: c3 ret 10d035: 8d 76 00 lea 0x0(%esi),%esi 10d038: 8b 15 b0 a8 12 00 mov 0x12a8b0,%edx 10d03e: 42 inc %edx 10d03f: 89 15 b0 a8 12 00 mov %edx,0x12a8b0
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
&_IO_Driver_address_table[major],
10d045: 8d 14 40 lea (%eax,%eax,2),%edx 10d048: c1 e2 03 shl $0x3,%edx
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
10d04b: 03 15 84 ac 12 00 add 0x12ac84,%edx 10d051: b9 18 00 00 00 mov $0x18,%ecx 10d056: 31 c0 xor %eax,%eax 10d058: 89 d7 mov %edx,%edi 10d05a: f3 aa rep stos %al,%es:(%edi)
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
10d05c: e8 af 1a 00 00 call 10eb10 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d061: 31 c0 xor %eax,%eax
}
return RTEMS_UNSATISFIED;
}
10d063: 5a pop %edx 10d064: 5f pop %edi 10d065: c9 leave 10d066: c3 ret 10d067: 90 nop
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10d068: b8 12 00 00 00 mov $0x12,%eax
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10d06d: 5a pop %edx 10d06e: 5f pop %edi 10d06f: c9 leave 10d070: c3 ret
00112188 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112188: 55 push %ebp 112189: 89 e5 mov %esp,%ebp 11218b: 53 push %ebx 11218c: 83 ec 04 sub $0x4,%esp 11218f: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112192: 39 05 80 68 12 00 cmp %eax,0x126880
112198: 76 1a jbe 1121b4 <rtems_io_write+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
11219a: 8d 14 40 lea (%eax,%eax,2),%edx 11219d: c1 e2 03 shl $0x3,%edx 1121a0: 03 15 84 68 12 00 add 0x126884,%edx 1121a6: 8b 52 10 mov 0x10(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1121a9: 85 d2 test %edx,%edx
1121ab: 74 13 je 1121c0 <rtems_io_write+0x38> }
1121ad: 59 pop %ecx 1121ae: 5b pop %ebx 1121af: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1121b0: ff e2 jmp *%edx 1121b2: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
1121b4: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
1121b9: 5a pop %edx 1121ba: 5b pop %ebx 1121bb: c9 leave 1121bc: c3 ret 1121bd: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1121c0: 31 c0 xor %eax,%eax
}
1121c2: 5a pop %edx 1121c3: 5b pop %ebx 1121c4: c9 leave 1121c5: c3 ret
0010def0 <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)
{
10def0: 55 push %ebp 10def1: 89 e5 mov %esp,%ebp 10def3: 57 push %edi 10def4: 56 push %esi 10def5: 53 push %ebx 10def6: 83 ec 1c sub $0x1c,%esp 10def9: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10defc: 85 ff test %edi,%edi
10defe: 74 4d je 10df4d <rtems_iterate_over_all_threads+0x5d><== NEVER TAKEN
10df00: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
10df07: 8b 55 e4 mov -0x1c(%ebp),%edx 10df0a: 8b 04 95 e8 12 13 00 mov 0x1312e8(,%edx,4),%eax 10df11: 85 c0 test %eax,%eax
10df13: 74 2f je 10df44 <rtems_iterate_over_all_threads+0x54>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10df15: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10df18: 85 f6 test %esi,%esi
10df1a: 74 28 je 10df44 <rtems_iterate_over_all_threads+0x54>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10df1c: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10df21: 74 21 je 10df44 <rtems_iterate_over_all_threads+0x54><== NEVER TAKEN
10df23: bb 01 00 00 00 mov $0x1,%ebx
the_thread = (Thread_Control *)information->local_table[ i ];
10df28: 8b 46 1c mov 0x1c(%esi),%eax 10df2b: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10df2e: 85 c0 test %eax,%eax
10df30: 74 09 je 10df3b <rtems_iterate_over_all_threads+0x4b><== NEVER TAKEN
continue;
(*routine)(the_thread);
10df32: 83 ec 0c sub $0xc,%esp 10df35: 50 push %eax 10df36: ff d7 call *%edi 10df38: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10df3b: 43 inc %ebx 10df3c: 0f b7 46 10 movzwl 0x10(%esi),%eax 10df40: 39 d8 cmp %ebx,%eax
10df42: 73 e4 jae 10df28 <rtems_iterate_over_all_threads+0x38>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10df44: ff 45 e4 incl -0x1c(%ebp) 10df47: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp)
10df4b: 75 ba jne 10df07 <rtems_iterate_over_all_threads+0x17>
(*routine)(the_thread);
}
}
}
10df4d: 8d 65 f4 lea -0xc(%ebp),%esp 10df50: 5b pop %ebx 10df51: 5e pop %esi 10df52: 5f pop %edi 10df53: c9 leave 10df54: c3 ret
001163bc <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
1163bc: 55 push %ebp 1163bd: 89 e5 mov %esp,%ebp 1163bf: 57 push %edi 1163c0: 56 push %esi 1163c1: 53 push %ebx 1163c2: 83 ec 1c sub $0x1c,%esp 1163c5: 8b 7d 08 mov 0x8(%ebp),%edi 1163c8: 8b 5d 0c mov 0xc(%ebp),%ebx 1163cb: 8b 75 14 mov 0x14(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
1163ce: 85 db test %ebx,%ebx
1163d0: 74 62 je 116434 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
1163d2: 85 f6 test %esi,%esi
1163d4: 74 5e je 116434 <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1163d6: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1163d7: 8d 45 e4 lea -0x1c(%ebp),%eax 1163da: 50 push %eax 1163db: 57 push %edi 1163dc: 68 40 0c 14 00 push $0x140c40 1163e1: e8 c6 4d 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
1163e6: 83 c4 10 add $0x10,%esp 1163e9: 8b 55 e4 mov -0x1c(%ebp),%edx 1163ec: 85 d2 test %edx,%edx
1163ee: 74 10 je 116400 <rtems_message_queue_broadcast+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163f0: b8 04 00 00 00 mov $0x4,%eax
}
1163f5: 8d 65 f4 lea -0xc(%ebp),%esp 1163f8: 5b pop %ebx 1163f9: 5e pop %esi 1163fa: 5f pop %edi 1163fb: c9 leave 1163fc: c3 ret 1163fd: 8d 76 00 lea 0x0(%esi),%esi
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
116400: 83 ec 08 sub $0x8,%esp 116403: 56 push %esi 116404: 6a 00 push $0x0 116406: 57 push %edi 116407: ff 75 10 pushl 0x10(%ebp) 11640a: 53 push %ebx 11640b: 83 c0 14 add $0x14,%eax 11640e: 50 push %eax 11640f: e8 80 34 00 00 call 119894 <_CORE_message_queue_Broadcast> 116414: 89 c3 mov %eax,%ebx
NULL,
#endif
count
);
_Thread_Enable_dispatch();
116416: 83 c4 20 add $0x20,%esp 116419: e8 16 58 00 00 call 11bc34 <_Thread_Enable_dispatch>
return
11641e: 83 ec 0c sub $0xc,%esp 116421: 53 push %ebx 116422: e8 69 03 00 00 call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116427: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11642a: 8d 65 f4 lea -0xc(%ebp),%esp 11642d: 5b pop %ebx 11642e: 5e pop %esi 11642f: 5f pop %edi 116430: c9 leave 116431: c3 ret 116432: 66 90 xchg %ax,%ax
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116434: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116439: 8d 65 f4 lea -0xc(%ebp),%esp 11643c: 5b pop %ebx 11643d: 5e pop %esi 11643e: 5f pop %edi 11643f: c9 leave 116440: c3 ret
00113858 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
113858: 55 push %ebp 113859: 89 e5 mov %esp,%ebp 11385b: 57 push %edi 11385c: 56 push %esi 11385d: 53 push %ebx 11385e: 83 ec 2c sub $0x2c,%esp 113861: 8b 5d 08 mov 0x8(%ebp),%ebx 113864: 8b 75 0c mov 0xc(%ebp),%esi 113867: 8b 4d 10 mov 0x10(%ebp),%ecx 11386a: 8b 7d 18 mov 0x18(%ebp),%edi
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
11386d: 85 db test %ebx,%ebx
11386f: 74 2f je 1138a0 <rtems_message_queue_create+0x48>
return RTEMS_INVALID_NAME;
if ( !id )
113871: 85 ff test %edi,%edi
113873: 0f 84 a3 00 00 00 je 11391c <rtems_message_queue_create+0xc4>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
113879: 85 f6 test %esi,%esi
11387b: 74 13 je 113890 <rtems_message_queue_create+0x38>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
11387d: 85 c9 test %ecx,%ecx
11387f: 75 2f jne 1138b0 <rtems_message_queue_create+0x58>
return RTEMS_INVALID_SIZE;
113881: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113886: 8d 65 f4 lea -0xc(%ebp),%esp 113889: 5b pop %ebx 11388a: 5e pop %esi 11388b: 5f pop %edi 11388c: c9 leave 11388d: c3 ret 11388e: 66 90 xchg %ax,%ax
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
113890: b8 0a 00 00 00 mov $0xa,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113895: 8d 65 f4 lea -0xc(%ebp),%esp 113898: 5b pop %ebx 113899: 5e pop %esi 11389a: 5f pop %edi 11389b: c9 leave 11389c: c3 ret 11389d: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1138a0: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1138a5: 8d 65 f4 lea -0xc(%ebp),%esp 1138a8: 5b pop %ebx 1138a9: 5e pop %esi 1138aa: 5f pop %edi 1138ab: c9 leave 1138ac: c3 ret 1138ad: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1138b0: a1 50 f6 12 00 mov 0x12f650,%eax 1138b5: 40 inc %eax 1138b6: a3 50 f6 12 00 mov %eax,0x12f650
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp) 1138be: e8 5d 54 00 00 call 118d20 <_Message_queue_Allocate> 1138c3: 89 c2 mov %eax,%edx
if ( !the_message_queue ) {
1138c5: 85 c0 test %eax,%eax 1138c7: 8b 4d d4 mov -0x2c(%ebp),%ecx
1138ca: 74 7c je 113948 <rtems_message_queue_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
1138cc: 8b 45 14 mov 0x14(%ebp),%eax 1138cf: 89 42 10 mov %eax,0x10(%edx)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
1138d2: a8 04 test $0x4,%al 1138d4: 0f 95 c0 setne %al 1138d7: 0f b6 c0 movzbl %al,%eax 1138da: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
1138dd: 51 push %ecx 1138de: 56 push %esi 1138df: 8d 45 e4 lea -0x1c(%ebp),%eax 1138e2: 50 push %eax 1138e3: 8d 42 14 lea 0x14(%edx),%eax 1138e6: 50 push %eax 1138e7: 89 55 d4 mov %edx,-0x2c(%ebp) 1138ea: e8 e5 10 00 00 call 1149d4 <_CORE_message_queue_Initialize> 1138ef: 83 c4 10 add $0x10,%esp 1138f2: 84 c0 test %al,%al 1138f4: 8b 55 d4 mov -0x2c(%ebp),%edx
1138f7: 75 2f jne 113928 <rtems_message_queue_create+0xd0>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
1138f9: 83 ec 08 sub $0x8,%esp 1138fc: 52 push %edx 1138fd: 68 a0 f9 12 00 push $0x12f9a0 113902: e8 81 1e 00 00 call 115788 <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
113907: e8 c4 2a 00 00 call 1163d0 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
11390c: 83 c4 10 add $0x10,%esp 11390f: b8 0d 00 00 00 mov $0xd,%eax 113914: e9 6d ff ff ff jmp 113886 <rtems_message_queue_create+0x2e> 113919: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
11391c: b8 09 00 00 00 mov $0x9,%eax 113921: e9 60 ff ff ff jmp 113886 <rtems_message_queue_create+0x2e> 113926: 66 90 xchg %ax,%ax
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
113928: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
11392b: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11392e: 8b 0d bc f9 12 00 mov 0x12f9bc,%ecx 113934: 89 14 b1 mov %edx,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
113937: 89 5a 0c mov %ebx,0xc(%edx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
11393a: 89 07 mov %eax,(%edi)
name,
0
);
#endif
_Thread_Enable_dispatch();
11393c: e8 8f 2a 00 00 call 1163d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
113941: 31 c0 xor %eax,%eax 113943: e9 3e ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
113948: e8 83 2a 00 00 call 1163d0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
11394d: b8 05 00 00 00 mov $0x5,%eax 113952: e9 2f ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
00116544 <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
116544: 55 push %ebp 116545: 89 e5 mov %esp,%ebp 116547: 53 push %ebx 116548: 83 ec 18 sub $0x18,%esp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
11654b: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
11654e: 50 push %eax 11654f: ff 75 08 pushl 0x8(%ebp) 116552: 68 40 0c 14 00 push $0x140c40 116557: e8 50 4c 00 00 call 11b1ac <_Objects_Get> 11655c: 89 c3 mov %eax,%ebx
switch ( location ) {
11655e: 83 c4 10 add $0x10,%esp 116561: 8b 4d f4 mov -0xc(%ebp),%ecx 116564: 85 c9 test %ecx,%ecx
116566: 75 3c jne 1165a4 <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
116568: 83 ec 08 sub $0x8,%esp 11656b: 50 push %eax 11656c: 68 40 0c 14 00 push $0x140c40 116571: e8 be 47 00 00 call 11ad34 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
116576: 83 c4 0c add $0xc,%esp 116579: 6a 05 push $0x5 11657b: 6a 00 push $0x0 11657d: 8d 43 14 lea 0x14(%ebx),%eax 116580: 50 push %eax 116581: e8 92 33 00 00 call 119918 <_CORE_message_queue_Close>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
116586: 58 pop %eax 116587: 5a pop %edx 116588: 53 push %ebx 116589: 68 40 0c 14 00 push $0x140c40 11658e: e8 9d 4a 00 00 call 11b030 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
116593: e8 9c 56 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116598: 83 c4 10 add $0x10,%esp 11659b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11659d: 8b 5d fc mov -0x4(%ebp),%ebx 1165a0: c9 leave 1165a1: c3 ret 1165a2: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1165a4: b8 04 00 00 00 mov $0x4,%eax
}
1165a9: 8b 5d fc mov -0x4(%ebp),%ebx 1165ac: c9 leave 1165ad: c3 ret
001165b0 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
rtems_id id,
uint32_t *count
)
{
1165b0: 55 push %ebp 1165b1: 89 e5 mov %esp,%ebp 1165b3: 53 push %ebx 1165b4: 83 ec 14 sub $0x14,%esp 1165b7: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
1165ba: 85 db test %ebx,%ebx
1165bc: 74 46 je 116604 <rtems_message_queue_flush+0x54>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1165be: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1165bf: 8d 45 f4 lea -0xc(%ebp),%eax 1165c2: 50 push %eax 1165c3: ff 75 08 pushl 0x8(%ebp) 1165c6: 68 40 0c 14 00 push $0x140c40 1165cb: e8 dc 4b 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
1165d0: 83 c4 10 add $0x10,%esp 1165d3: 8b 55 f4 mov -0xc(%ebp),%edx 1165d6: 85 d2 test %edx,%edx
1165d8: 74 0a je 1165e4 <rtems_message_queue_flush+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1165da: b8 04 00 00 00 mov $0x4,%eax
}
1165df: 8b 5d fc mov -0x4(%ebp),%ebx 1165e2: c9 leave 1165e3: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
1165e4: 83 ec 0c sub $0xc,%esp 1165e7: 83 c0 14 add $0x14,%eax 1165ea: 50 push %eax 1165eb: e8 64 33 00 00 call 119954 <_CORE_message_queue_Flush> 1165f0: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
1165f2: e8 3d 56 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1165f7: 83 c4 10 add $0x10,%esp 1165fa: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1165fc: 8b 5d fc mov -0x4(%ebp),%ebx 1165ff: c9 leave 116600: c3 ret 116601: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116604: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116609: 8b 5d fc mov -0x4(%ebp),%ebx 11660c: c9 leave 11660d: c3 ret
00116610 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
116610: 55 push %ebp 116611: 89 e5 mov %esp,%ebp 116613: 53 push %ebx 116614: 83 ec 14 sub $0x14,%esp 116617: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
11661a: 85 db test %ebx,%ebx
11661c: 74 3a je 116658 <rtems_message_queue_get_number_pending+0x48>
11661e: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
11661f: 8d 45 f4 lea -0xc(%ebp),%eax 116622: 50 push %eax 116623: ff 75 08 pushl 0x8(%ebp) 116626: 68 40 0c 14 00 push $0x140c40 11662b: e8 7c 4b 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
116630: 83 c4 10 add $0x10,%esp 116633: 8b 55 f4 mov -0xc(%ebp),%edx 116636: 85 d2 test %edx,%edx
116638: 74 0a je 116644 <rtems_message_queue_get_number_pending+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11663a: b8 04 00 00 00 mov $0x4,%eax
}
11663f: 8b 5d fc mov -0x4(%ebp),%ebx 116642: c9 leave 116643: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
116644: 8b 40 5c mov 0x5c(%eax),%eax 116647: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
116649: e8 e6 55 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11664e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116650: 8b 5d fc mov -0x4(%ebp),%ebx 116653: c9 leave 116654: c3 ret 116655: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116658: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11665d: 8b 5d fc mov -0x4(%ebp),%ebx 116660: c9 leave 116661: c3 ret
0011397c <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
11397c: 55 push %ebp 11397d: 89 e5 mov %esp,%ebp 11397f: 56 push %esi 113980: 53 push %ebx 113981: 83 ec 10 sub $0x10,%esp 113984: 8b 5d 0c mov 0xc(%ebp),%ebx 113987: 8b 75 10 mov 0x10(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
11398a: 85 db test %ebx,%ebx
11398c: 74 6e je 1139fc <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
11398e: 85 f6 test %esi,%esi
113990: 74 6a je 1139fc <rtems_message_queue_receive+0x80>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
113992: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
113993: 8d 45 f4 lea -0xc(%ebp),%eax 113996: 50 push %eax 113997: ff 75 08 pushl 0x8(%ebp) 11399a: 68 a0 f9 12 00 push $0x12f9a0 11399f: e8 24 1f 00 00 call 1158c8 <_Objects_Get>
switch ( location ) {
1139a4: 83 c4 10 add $0x10,%esp 1139a7: 8b 55 f4 mov -0xc(%ebp),%edx 1139aa: 85 d2 test %edx,%edx
1139ac: 75 42 jne 1139f0 <rtems_message_queue_receive+0x74>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
1139ae: 83 ec 08 sub $0x8,%esp 1139b1: ff 75 18 pushl 0x18(%ebp)
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
1139b4: 8b 55 14 mov 0x14(%ebp),%edx 1139b7: 83 e2 01 and $0x1,%edx 1139ba: 83 f2 01 xor $0x1,%edx 1139bd: 52 push %edx 1139be: 56 push %esi 1139bf: 53 push %ebx 1139c0: ff 70 08 pushl 0x8(%eax) 1139c3: 83 c0 14 add $0x14,%eax 1139c6: 50 push %eax 1139c7: e8 a8 10 00 00 call 114a74 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
1139cc: 83 c4 20 add $0x20,%esp 1139cf: e8 fc 29 00 00 call 1163d0 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
1139d4: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code
1139d7: a1 18 f9 12 00 mov 0x12f918,%eax
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
1139dc: ff 70 34 pushl 0x34(%eax) 1139df: e8 a0 00 00 00 call 113a84 <_Message_queue_Translate_core_message_queue_return_code> 1139e4: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1139e7: 8d 65 f8 lea -0x8(%ebp),%esp 1139ea: 5b pop %ebx 1139eb: 5e pop %esi 1139ec: c9 leave 1139ed: c3 ret 1139ee: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1139f0: b8 04 00 00 00 mov $0x4,%eax
}
1139f5: 8d 65 f8 lea -0x8(%ebp),%esp 1139f8: 5b pop %ebx 1139f9: 5e pop %esi 1139fa: c9 leave 1139fb: c3 ret
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
1139fc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113a01: 8d 65 f8 lea -0x8(%ebp),%esp 113a04: 5b pop %ebx 113a05: 5e pop %esi 113a06: c9 leave 113a07: c3 ret
0010b3a8 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
rtems_id id,
const void *buffer,
size_t size
)
{
10b3a8: 55 push %ebp 10b3a9: 89 e5 mov %esp,%ebp 10b3ab: 56 push %esi 10b3ac: 53 push %ebx 10b3ad: 83 ec 10 sub $0x10,%esp 10b3b0: 8b 75 08 mov 0x8(%ebp),%esi 10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
10b3b6: 85 db test %ebx,%ebx
10b3b8: 74 5e je 10b418 <rtems_message_queue_send+0x70>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
10b3ba: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: 56 push %esi 10b3c0: 68 00 68 12 00 push $0x126800 10b3c5: e8 a2 19 00 00 call 10cd6c <_Objects_Get>
switch ( location ) {
10b3ca: 83 c4 10 add $0x10,%esp 10b3cd: 8b 55 f4 mov -0xc(%ebp),%edx 10b3d0: 85 d2 test %edx,%edx
10b3d2: 74 0c je 10b3e0 <rtems_message_queue_send+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b3d4: b8 04 00 00 00 mov $0x4,%eax
}
10b3d9: 8d 65 f8 lea -0x8(%ebp),%esp 10b3dc: 5b pop %ebx 10b3dd: 5e pop %esi 10b3de: c9 leave 10b3df: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
10b3e0: 6a 00 push $0x0 10b3e2: 6a 00 push $0x0 10b3e4: 68 ff ff ff 7f push $0x7fffffff 10b3e9: 6a 00 push $0x0 10b3eb: 56 push %esi 10b3ec: ff 75 10 pushl 0x10(%ebp) 10b3ef: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Send(
10b3f0: 83 c0 14 add $0x14,%eax 10b3f3: 50 push %eax 10b3f4: e8 f7 0b 00 00 call 10bff0 <_CORE_message_queue_Submit> 10b3f9: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
10b3fb: 83 c4 20 add $0x20,%esp 10b3fe: e8 f1 23 00 00 call 10d7f4 <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
10b403: 83 ec 0c sub $0xc,%esp 10b406: 53 push %ebx 10b407: e8 18 00 00 00 call 10b424 <_Message_queue_Translate_core_message_queue_return_code> 10b40c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b40f: 8d 65 f8 lea -0x8(%ebp),%esp 10b412: 5b pop %ebx 10b413: 5e pop %esi 10b414: c9 leave 10b415: c3 ret 10b416: 66 90 xchg %ax,%ax
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
10b418: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b41d: 8d 65 f8 lea -0x8(%ebp),%esp 10b420: 5b pop %ebx 10b421: 5e pop %esi 10b422: c9 leave 10b423: c3 ret
001167a0 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
rtems_id id,
const void *buffer,
size_t size
)
{
1167a0: 55 push %ebp 1167a1: 89 e5 mov %esp,%ebp 1167a3: 56 push %esi 1167a4: 53 push %ebx 1167a5: 83 ec 10 sub $0x10,%esp 1167a8: 8b 75 08 mov 0x8(%ebp),%esi 1167ab: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
1167ae: 85 db test %ebx,%ebx
1167b0: 74 5e je 116810 <rtems_message_queue_urgent+0x70>
1167b2: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1167b3: 8d 45 f4 lea -0xc(%ebp),%eax 1167b6: 50 push %eax 1167b7: 56 push %esi 1167b8: 68 40 0c 14 00 push $0x140c40 1167bd: e8 ea 49 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
1167c2: 83 c4 10 add $0x10,%esp 1167c5: 8b 55 f4 mov -0xc(%ebp),%edx 1167c8: 85 d2 test %edx,%edx
1167ca: 74 0c je 1167d8 <rtems_message_queue_urgent+0x38>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1167cc: b8 04 00 00 00 mov $0x4,%eax
}
1167d1: 8d 65 f8 lea -0x8(%ebp),%esp 1167d4: 5b pop %ebx 1167d5: 5e pop %esi 1167d6: c9 leave 1167d7: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
1167d8: 6a 00 push $0x0 1167da: 6a 00 push $0x0 1167dc: 68 00 00 00 80 push $0x80000000 1167e1: 6a 00 push $0x0 1167e3: 56 push %esi 1167e4: ff 75 10 pushl 0x10(%ebp) 1167e7: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Urgent(
1167e8: 83 c0 14 add $0x14,%eax 1167eb: 50 push %eax 1167ec: e8 3f 33 00 00 call 119b30 <_CORE_message_queue_Submit> 1167f1: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
1167f3: 83 c4 20 add $0x20,%esp 1167f6: e8 39 54 00 00 call 11bc34 <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
1167fb: 83 ec 0c sub $0xc,%esp 1167fe: 53 push %ebx 1167ff: e8 8c ff ff ff call 116790 <_Message_queue_Translate_core_message_queue_return_code> 116804: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116807: 8d 65 f8 lea -0x8(%ebp),%esp 11680a: 5b pop %ebx 11680b: 5e pop %esi 11680c: c9 leave 11680d: c3 ret 11680e: 66 90 xchg %ax,%ax
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
116810: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116815: 8d 65 f8 lea -0x8(%ebp),%esp 116818: 5b pop %ebx 116819: 5e pop %esi 11681a: c9 leave 11681b: c3 ret
0010cea4 <rtems_object_get_api_class_name>:
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
10cea4: 55 push %ebp 10cea5: 89 e5 mov %esp,%ebp 10cea7: 83 ec 08 sub $0x8,%esp 10ceaa: 8b 45 08 mov 0x8(%ebp),%eax
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
10cead: 83 f8 01 cmp $0x1,%eax
10ceb0: 74 2a je 10cedc <rtems_object_get_api_class_name+0x38>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
10ceb2: 83 f8 02 cmp $0x2,%eax
10ceb5: 74 09 je 10cec0 <rtems_object_get_api_class_name+0x1c>
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
10ceb7: b8 3b 39 12 00 mov $0x12393b,%eax
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
}
10cebc: c9 leave 10cebd: c3 ret 10cebe: 66 90 xchg %ax,%ax
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
10cec0: b8 20 86 12 00 mov $0x128620,%eax
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
10cec5: 83 ec 08 sub $0x8,%esp 10cec8: ff 75 0c pushl 0xc(%ebp) 10cecb: 50 push %eax 10cecc: e8 4f 4a 00 00 call 111920 <rtems_assoc_ptr_by_local>
if ( class_assoc )
10ced1: 83 c4 10 add $0x10,%esp 10ced4: 85 c0 test %eax,%eax
10ced6: 74 0c je 10cee4 <rtems_object_get_api_class_name+0x40>
return class_assoc->name;
10ced8: 8b 00 mov (%eax),%eax
return "BAD CLASS"; }
10ceda: c9 leave 10cedb: c3 ret
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
10cedc: b8 00 86 12 00 mov $0x128600,%eax 10cee1: eb e2 jmp 10cec5 <rtems_object_get_api_class_name+0x21> 10cee3: 90 nop
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
10cee4: b8 43 39 12 00 mov $0x123943,%eax
}
10cee9: c9 leave 10ceea: c3 ret
0010ceec <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
10ceec: 55 push %ebp 10ceed: 89 e5 mov %esp,%ebp 10ceef: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
10cef2: ff 75 08 pushl 0x8(%ebp) 10cef5: 68 a0 86 12 00 push $0x1286a0 10cefa: e8 21 4a 00 00 call 111920 <rtems_assoc_ptr_by_local>
if ( api_assoc )
10ceff: 83 c4 10 add $0x10,%esp 10cf02: 85 c0 test %eax,%eax
10cf04: 74 06 je 10cf0c <rtems_object_get_api_name+0x20>
return api_assoc->name;
10cf06: 8b 00 mov (%eax),%eax
return "BAD CLASS"; }
10cf08: c9 leave 10cf09: c3 ret 10cf0a: 66 90 xchg %ax,%ax
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
if ( api_assoc )
return api_assoc->name;
return "BAD CLASS";
10cf0c: b8 43 39 12 00 mov $0x123943,%eax
}
10cf11: c9 leave 10cf12: c3 ret
0010cf54 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
10cf54: 55 push %ebp 10cf55: 89 e5 mov %esp,%ebp 10cf57: 57 push %edi 10cf58: 56 push %esi 10cf59: 53 push %ebx 10cf5a: 83 ec 0c sub $0xc,%esp 10cf5d: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10cf60: 85 db test %ebx,%ebx
10cf62: 74 60 je 10cfc4 <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10cf64: 83 ec 08 sub $0x8,%esp 10cf67: 0f b7 45 0c movzwl 0xc(%ebp),%eax 10cf6b: 50 push %eax 10cf6c: ff 75 08 pushl 0x8(%ebp) 10cf6f: e8 80 1a 00 00 call 10e9f4 <_Objects_Get_information>
if ( !obj_info )
10cf74: 83 c4 10 add $0x10,%esp 10cf77: 85 c0 test %eax,%eax
10cf79: 74 59 je 10cfd4 <rtems_object_get_class_information+0x80>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
10cf7b: 8b 50 08 mov 0x8(%eax),%edx 10cf7e: 89 13 mov %edx,(%ebx)
info->maximum_id = obj_info->maximum_id;
10cf80: 8b 50 0c mov 0xc(%eax),%edx 10cf83: 89 53 04 mov %edx,0x4(%ebx)
info->auto_extend = obj_info->auto_extend;
10cf86: 8a 50 12 mov 0x12(%eax),%dl 10cf89: 88 53 0c mov %dl,0xc(%ebx)
info->maximum = obj_info->maximum;
10cf8c: 0f b7 70 10 movzwl 0x10(%eax),%esi 10cf90: 89 73 08 mov %esi,0x8(%ebx)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cf93: 85 f6 test %esi,%esi
10cf95: 74 44 je 10cfdb <rtems_object_get_class_information+0x87><== NEVER TAKEN
10cf97: 8b 78 1c mov 0x1c(%eax),%edi 10cf9a: b9 01 00 00 00 mov $0x1,%ecx 10cf9f: b8 01 00 00 00 mov $0x1,%eax 10cfa4: 31 d2 xor %edx,%edx 10cfa6: 66 90 xchg %ax,%ax
if ( !obj_info->local_table[i] )
unallocated++;
10cfa8: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4) 10cfac: 83 d2 00 adc $0x0,%edx
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cfaf: 40 inc %eax 10cfb0: 89 c1 mov %eax,%ecx 10cfb2: 39 c6 cmp %eax,%esi
10cfb4: 73 f2 jae 10cfa8 <rtems_object_get_class_information+0x54>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10cfb6: 89 53 10 mov %edx,0x10(%ebx)
return RTEMS_SUCCESSFUL;
10cfb9: 31 c0 xor %eax,%eax
}
10cfbb: 8d 65 f4 lea -0xc(%ebp),%esp 10cfbe: 5b pop %ebx 10cfbf: 5e pop %esi 10cfc0: 5f pop %edi 10cfc1: c9 leave 10cfc2: c3 ret 10cfc3: 90 nop
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
10cfc4: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10cfc9: 8d 65 f4 lea -0xc(%ebp),%esp 10cfcc: 5b pop %ebx 10cfcd: 5e pop %esi 10cfce: 5f pop %edi 10cfcf: c9 leave 10cfd0: c3 ret 10cfd1: 8d 76 00 lea 0x0(%esi),%esi
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
10cfd4: b8 0a 00 00 00 mov $0xa,%eax 10cfd9: eb e0 jmp 10cfbb <rtems_object_get_class_information+0x67>
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cfdb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cfdd: eb d7 jmp 10cfb6 <rtems_object_get_class_information+0x62><== NOT EXECUTED
0010c520 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
10c520: 55 push %ebp 10c521: 89 e5 mov %esp,%ebp 10c523: 53 push %ebx 10c524: 83 ec 14 sub $0x14,%esp 10c527: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10c52a: 85 db test %ebx,%ebx
10c52c: 74 26 je 10c554 <rtems_object_get_classic_name+0x34>
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
10c52e: 83 ec 08 sub $0x8,%esp 10c531: 8d 45 f4 lea -0xc(%ebp),%eax 10c534: 50 push %eax 10c535: ff 75 08 pushl 0x8(%ebp) 10c538: e8 db 1a 00 00 call 10e018 <_Objects_Id_to_name>
*name = name_u.name_u32;
10c53d: 8b 55 f4 mov -0xc(%ebp),%edx 10c540: 89 13 mov %edx,(%ebx)
return _Status_Object_name_errors_to_status[ status ];
10c542: 8b 04 85 4c 24 12 00 mov 0x12244c(,%eax,4),%eax 10c549: 83 c4 10 add $0x10,%esp
}
10c54c: 8b 5d fc mov -0x4(%ebp),%ebx 10c54f: c9 leave 10c550: c3 ret 10c551: 8d 76 00 lea 0x0(%esi),%esi
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10c554: b8 09 00 00 00 mov $0x9,%eax
status = _Objects_Id_to_name( id, &name_u );
*name = name_u.name_u32;
return _Status_Object_name_errors_to_status[ status ];
}
10c559: 8b 5d fc mov -0x4(%ebp),%ebx 10c55c: c9 leave 10c55d: c3 ret
0010d038 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10d038: 55 push %ebp 10d039: 89 e5 mov %esp,%ebp 10d03b: 57 push %edi 10d03c: 56 push %esi 10d03d: 53 push %ebx 10d03e: 83 ec 1c sub $0x1c,%esp 10d041: 8b 75 08 mov 0x8(%ebp),%esi 10d044: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10d047: 85 ff test %edi,%edi
10d049: 74 61 je 10d0ac <rtems_object_set_name+0x74>
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10d04b: 85 f6 test %esi,%esi
10d04d: 74 35 je 10d084 <rtems_object_set_name+0x4c>
information = _Objects_Get_information_id( tmpId );
10d04f: 83 ec 0c sub $0xc,%esp 10d052: 56 push %esi 10d053: e8 7c 19 00 00 call 10e9d4 <_Objects_Get_information_id> 10d058: 89 c3 mov %eax,%ebx
if ( !information )
10d05a: 83 c4 10 add $0x10,%esp 10d05d: 85 c0 test %eax,%eax
10d05f: 74 16 je 10d077 <rtems_object_set_name+0x3f>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10d061: 50 push %eax 10d062: 8d 45 e4 lea -0x1c(%ebp),%eax 10d065: 50 push %eax 10d066: 56 push %esi 10d067: 53 push %ebx 10d068: e8 07 1b 00 00 call 10eb74 <_Objects_Get>
switch ( location ) {
10d06d: 83 c4 10 add $0x10,%esp 10d070: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d073: 85 c9 test %ecx,%ecx
10d075: 74 19 je 10d090 <rtems_object_set_name+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d077: b8 04 00 00 00 mov $0x4,%eax
}
10d07c: 8d 65 f4 lea -0xc(%ebp),%esp 10d07f: 5b pop %ebx 10d080: 5e pop %esi 10d081: 5f pop %edi 10d082: c9 leave 10d083: c3 ret
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10d084: a1 38 ad 12 00 mov 0x12ad38,%eax 10d089: 8b 70 08 mov 0x8(%eax),%esi 10d08c: eb c1 jmp 10d04f <rtems_object_set_name+0x17> 10d08e: 66 90 xchg %ax,%ax
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10d090: 52 push %edx 10d091: 57 push %edi 10d092: 50 push %eax 10d093: 53 push %ebx 10d094: e8 13 1d 00 00 call 10edac <_Objects_Set_name>
_Thread_Enable_dispatch();
10d099: e8 46 26 00 00 call 10f6e4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d09e: 83 c4 10 add $0x10,%esp 10d0a1: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d0a3: 8d 65 f4 lea -0xc(%ebp),%esp 10d0a6: 5b pop %ebx 10d0a7: 5e pop %esi 10d0a8: 5f pop %edi 10d0a9: c9 leave 10d0aa: c3 ret 10d0ab: 90 nop
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10d0ac: b8 09 00 00 00 mov $0x9,%eax 10d0b1: eb c9 jmp 10d07c <rtems_object_set_name+0x44>
0011681c <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11681c: 55 push %ebp 11681d: 89 e5 mov %esp,%ebp 11681f: 57 push %edi 116820: 56 push %esi 116821: 53 push %ebx 116822: 83 ec 1c sub $0x1c,%esp 116825: 8b 5d 08 mov 0x8(%ebp),%ebx 116828: 8b 75 0c mov 0xc(%ebp),%esi 11682b: 8b 55 10 mov 0x10(%ebp),%edx 11682e: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
116831: 85 db test %ebx,%ebx
116833: 74 47 je 11687c <rtems_partition_create+0x60>
return RTEMS_INVALID_NAME;
if ( !starting_address )
116835: 85 f6 test %esi,%esi
116837: 74 23 je 11685c <rtems_partition_create+0x40>
return RTEMS_INVALID_ADDRESS;
if ( !id )
116839: 8b 45 1c mov 0x1c(%ebp),%eax 11683c: 85 c0 test %eax,%eax
11683e: 74 1c je 11685c <rtems_partition_create+0x40><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
116840: 85 d2 test %edx,%edx
116842: 74 28 je 11686c <rtems_partition_create+0x50>
116844: 85 ff test %edi,%edi
116846: 74 24 je 11686c <rtems_partition_create+0x50>
116848: 39 fa cmp %edi,%edx
11684a: 72 20 jb 11686c <rtems_partition_create+0x50>
11684c: f7 c7 03 00 00 00 test $0x3,%edi
116852: 75 18 jne 11686c <rtems_partition_create+0x50>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
116854: f7 c6 03 00 00 00 test $0x3,%esi
11685a: 74 30 je 11688c <rtems_partition_create+0x70>
return RTEMS_INVALID_ADDRESS;
11685c: b8 09 00 00 00 mov $0x9,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116861: 8d 65 f4 lea -0xc(%ebp),%esp 116864: 5b pop %ebx 116865: 5e pop %esi 116866: 5f pop %edi 116867: c9 leave 116868: c3 ret 116869: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
11686c: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116871: 8d 65 f4 lea -0xc(%ebp),%esp 116874: 5b pop %ebx 116875: 5e pop %esi 116876: 5f pop %edi 116877: c9 leave 116878: c3 ret 116879: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
11687c: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116881: 8d 65 f4 lea -0xc(%ebp),%esp 116884: 5b pop %ebx 116885: 5e pop %esi 116886: 5f pop %edi 116887: c9 leave 116888: c3 ret 116889: 8d 76 00 lea 0x0(%esi),%esi 11688c: a1 f0 08 14 00 mov 0x1408f0,%eax 116891: 40 inc %eax 116892: a3 f0 08 14 00 mov %eax,0x1408f0
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
116897: 83 ec 0c sub $0xc,%esp 11689a: 68 80 07 14 00 push $0x140780 11689f: 89 55 e0 mov %edx,-0x20(%ebp) 1168a2: e8 11 44 00 00 call 11acb8 <_Objects_Allocate> 1168a7: 89 45 e4 mov %eax,-0x1c(%ebp)
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
1168aa: 83 c4 10 add $0x10,%esp 1168ad: 85 c0 test %eax,%eax 1168af: 8b 55 e0 mov -0x20(%ebp),%edx
1168b2: 74 58 je 11690c <rtems_partition_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
1168b4: 8b 45 e4 mov -0x1c(%ebp),%eax 1168b7: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
1168ba: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
1168bd: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
1168c0: 8b 4d 18 mov 0x18(%ebp),%ecx 1168c3: 89 48 1c mov %ecx,0x1c(%eax)
the_partition->number_of_used_blocks = 0;
1168c6: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
_Chain_Initialize( &the_partition->Memory, starting_address,
1168cd: 57 push %edi 1168ce: 89 d0 mov %edx,%eax 1168d0: 31 d2 xor %edx,%edx 1168d2: f7 f7 div %edi 1168d4: 50 push %eax 1168d5: 56 push %esi 1168d6: 8b 45 e4 mov -0x1c(%ebp),%eax 1168d9: 83 c0 24 add $0x24,%eax 1168dc: 50 push %eax 1168dd: e8 56 2f 00 00 call 119838 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1168e2: 8b 7d e4 mov -0x1c(%ebp),%edi 1168e5: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1168e8: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1168eb: 8b 15 9c 07 14 00 mov 0x14079c,%edx 1168f1: 89 3c b2 mov %edi,(%edx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1168f4: 89 5f 0c mov %ebx,0xc(%edi)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1168f7: 8b 55 1c mov 0x1c(%ebp),%edx 1168fa: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1168fc: e8 33 53 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116901: 83 c4 10 add $0x10,%esp 116904: 31 c0 xor %eax,%eax 116906: e9 66 ff ff ff jmp 116871 <rtems_partition_create+0x55> 11690b: 90 nop
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
11690c: e8 23 53 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
116911: b8 05 00 00 00 mov $0x5,%eax 116916: e9 56 ff ff ff jmp 116871 <rtems_partition_create+0x55>
00116988 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
116988: 55 push %ebp 116989: 89 e5 mov %esp,%ebp 11698b: 56 push %esi 11698c: 53 push %ebx 11698d: 83 ec 20 sub $0x20,%esp 116990: 8b 5d 0c mov 0xc(%ebp),%ebx
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
116993: 85 db test %ebx,%ebx
116995: 74 59 je 1169f0 <rtems_partition_get_buffer+0x68>
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116997: 52 push %edx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
116998: 8d 45 f4 lea -0xc(%ebp),%eax 11699b: 50 push %eax 11699c: ff 75 08 pushl 0x8(%ebp) 11699f: 68 80 07 14 00 push $0x140780 1169a4: e8 03 48 00 00 call 11b1ac <_Objects_Get> 1169a9: 89 c6 mov %eax,%esi
switch ( location ) {
1169ab: 83 c4 10 add $0x10,%esp 1169ae: 8b 45 f4 mov -0xc(%ebp),%eax 1169b1: 85 c0 test %eax,%eax
1169b3: 75 2f jne 1169e4 <rtems_partition_get_buffer+0x5c>
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
1169b5: 83 ec 0c sub $0xc,%esp 1169b8: 8d 46 24 lea 0x24(%esi),%eax 1169bb: 50 push %eax 1169bc: e8 53 2e 00 00 call 119814 <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
1169c1: 83 c4 10 add $0x10,%esp 1169c4: 85 c0 test %eax,%eax
1169c6: 74 34 je 1169fc <rtems_partition_get_buffer+0x74>
the_partition->number_of_used_blocks += 1;
1169c8: ff 46 20 incl 0x20(%esi)
_Thread_Enable_dispatch();
1169cb: 89 45 e4 mov %eax,-0x1c(%ebp) 1169ce: e8 61 52 00 00 call 11bc34 <_Thread_Enable_dispatch>
*buffer = the_buffer;
1169d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1169d6: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1169d8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1169da: 8d 65 f8 lea -0x8(%ebp),%esp 1169dd: 5b pop %ebx 1169de: 5e pop %esi 1169df: c9 leave 1169e0: c3 ret 1169e1: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1169e4: b8 04 00 00 00 mov $0x4,%eax
}
1169e9: 8d 65 f8 lea -0x8(%ebp),%esp 1169ec: 5b pop %ebx 1169ed: 5e pop %esi 1169ee: c9 leave 1169ef: c3 ret
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
1169f0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1169f5: 8d 65 f8 lea -0x8(%ebp),%esp 1169f8: 5b pop %ebx 1169f9: 5e pop %esi 1169fa: c9 leave 1169fb: c3 ret
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1169fc: e8 33 52 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
116a01: b8 0d 00 00 00 mov $0xd,%eax 116a06: eb e1 jmp 1169e9 <rtems_partition_get_buffer+0x61>
00116a2c <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
116a2c: 55 push %ebp 116a2d: 89 e5 mov %esp,%ebp 116a2f: 56 push %esi 116a30: 53 push %ebx 116a31: 83 ec 14 sub $0x14,%esp 116a34: 8b 75 0c mov 0xc(%ebp),%esi
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
116a37: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116a3a: 50 push %eax 116a3b: ff 75 08 pushl 0x8(%ebp) 116a3e: 68 80 07 14 00 push $0x140780 116a43: e8 64 47 00 00 call 11b1ac <_Objects_Get> 116a48: 89 c3 mov %eax,%ebx
switch ( location ) {
116a4a: 83 c4 10 add $0x10,%esp 116a4d: 8b 45 f4 mov -0xc(%ebp),%eax 116a50: 85 c0 test %eax,%eax
116a52: 74 0c je 116a60 <rtems_partition_return_buffer+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116a54: b8 04 00 00 00 mov $0x4,%eax
}
116a59: 8d 65 f8 lea -0x8(%ebp),%esp 116a5c: 5b pop %ebx 116a5d: 5e pop %esi 116a5e: c9 leave 116a5f: c3 ret
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
116a60: 8b 43 10 mov 0x10(%ebx),%eax
ending = _Addresses_Add_offset( starting, the_partition->length );
116a63: 8b 53 14 mov 0x14(%ebx),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116a66: 39 c6 cmp %eax,%esi
116a68: 72 3a jb 116aa4 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116a6a: 8d 14 10 lea (%eax,%edx,1),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116a6d: 39 d6 cmp %edx,%esi
116a6f: 77 33 ja 116aa4 <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
116a71: 89 f2 mov %esi,%edx 116a73: 29 c2 sub %eax,%edx 116a75: 89 d0 mov %edx,%eax
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
116a77: 31 d2 xor %edx,%edx 116a79: f7 73 18 divl 0x18(%ebx)
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
116a7c: 85 d2 test %edx,%edx
116a7e: 75 24 jne 116aa4 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
116a80: 83 ec 08 sub $0x8,%esp 116a83: 56 push %esi 116a84: 8d 43 24 lea 0x24(%ebx),%eax 116a87: 50 push %eax 116a88: e8 4b 2d 00 00 call 1197d8 <_Chain_Append>
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
116a8d: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
116a90: e8 9f 51 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116a95: 83 c4 10 add $0x10,%esp 116a98: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116a9a: 8d 65 f8 lea -0x8(%ebp),%esp 116a9d: 5b pop %ebx 116a9e: 5e pop %esi 116a9f: c9 leave 116aa0: c3 ret 116aa1: 8d 76 00 lea 0x0(%esi),%esi
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
116aa4: e8 8b 51 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
116aa9: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116aae: 8d 65 f8 lea -0x8(%ebp),%esp 116ab1: 5b pop %ebx 116ab2: 5e pop %esi 116ab3: c9 leave 116ab4: c3 ret
00115e50 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
115e50: 55 push %ebp 115e51: 89 e5 mov %esp,%ebp 115e53: 57 push %edi 115e54: 56 push %esi 115e55: 53 push %ebx 115e56: 83 ec 1c sub $0x1c,%esp 115e59: 8b 5d 08 mov 0x8(%ebp),%ebx 115e5c: 8b 55 0c mov 0xc(%ebp),%edx 115e5f: 8b 7d 10 mov 0x10(%ebp),%edi 115e62: 8b 75 18 mov 0x18(%ebp),%esi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
115e65: 85 db test %ebx,%ebx
115e67: 74 1b je 115e84 <rtems_port_create+0x34>
return RTEMS_INVALID_NAME;
if ( !id )
115e69: 85 f6 test %esi,%esi
115e6b: 74 08 je 115e75 <rtems_port_create+0x25>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
115e6d: 89 f8 mov %edi,%eax 115e6f: 09 d0 or %edx,%eax
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
115e71: a8 03 test $0x3,%al
115e73: 74 1f je 115e94 <rtems_port_create+0x44>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
115e75: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e7a: 8d 65 f4 lea -0xc(%ebp),%esp 115e7d: 5b pop %ebx 115e7e: 5e pop %esi 115e7f: 5f pop %edi 115e80: c9 leave 115e81: c3 ret 115e82: 66 90 xchg %ax,%ax
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
115e84: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e89: 8d 65 f4 lea -0xc(%ebp),%esp 115e8c: 5b pop %ebx 115e8d: 5e pop %esi 115e8e: 5f pop %edi 115e8f: c9 leave 115e90: c3 ret 115e91: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
115e94: a1 f0 08 14 00 mov 0x1408f0,%eax 115e99: 40 inc %eax 115e9a: a3 f0 08 14 00 mov %eax,0x1408f0
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
115e9f: 83 ec 0c sub $0xc,%esp 115ea2: 68 40 07 14 00 push $0x140740 115ea7: 89 55 e4 mov %edx,-0x1c(%ebp) 115eaa: e8 09 4e 00 00 call 11acb8 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
115eaf: 83 c4 10 add $0x10,%esp 115eb2: 85 c0 test %eax,%eax 115eb4: 8b 55 e4 mov -0x1c(%ebp),%edx
115eb7: 74 33 je 115eec <rtems_port_create+0x9c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
115eb9: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
115ebc: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
115ebf: 8b 55 14 mov 0x14(%ebp),%edx 115ec2: 4a dec %edx 115ec3: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
115ec6: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
115ec9: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
115ecc: 8b 0d 5c 07 14 00 mov 0x14075c,%ecx 115ed2: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
115ed5: 89 58 0c mov %ebx,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
115ed8: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
115eda: e8 55 5d 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115edf: 31 c0 xor %eax,%eax
}
115ee1: 8d 65 f4 lea -0xc(%ebp),%esp 115ee4: 5b pop %ebx 115ee5: 5e pop %esi 115ee6: 5f pop %edi 115ee7: c9 leave 115ee8: c3 ret 115ee9: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
115eec: e8 43 5d 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115ef1: b8 05 00 00 00 mov $0x5,%eax 115ef6: eb 82 jmp 115e7a <rtems_port_create+0x2a>
00115ef8 <rtems_port_delete>:
*/
rtems_status_code rtems_port_delete(
rtems_id id
)
{
115ef8: 55 push %ebp 115ef9: 89 e5 mov %esp,%ebp 115efb: 83 ec 2c sub $0x2c,%esp
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
115efe: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
_Objects_Get( &_Dual_ported_memory_Information, id, location );
115f01: 50 push %eax 115f02: ff 75 08 pushl 0x8(%ebp) 115f05: 68 40 07 14 00 push $0x140740 115f0a: e8 9d 52 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
115f0f: 83 c4 10 add $0x10,%esp 115f12: 8b 4d f4 mov -0xc(%ebp),%ecx 115f15: 85 c9 test %ecx,%ecx
115f17: 75 2f jne 115f48 <rtems_port_delete+0x50>
case OBJECTS_LOCAL:
_Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
115f19: 83 ec 08 sub $0x8,%esp 115f1c: 50 push %eax 115f1d: 68 40 07 14 00 push $0x140740 115f22: 89 45 e4 mov %eax,-0x1c(%ebp) 115f25: e8 0a 4e 00 00 call 11ad34 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free (
Dual_ported_memory_Control *the_port
)
{
_Objects_Free( &_Dual_ported_memory_Information, &the_port->Object );
115f2a: 58 pop %eax 115f2b: 5a pop %edx 115f2c: 8b 45 e4 mov -0x1c(%ebp),%eax 115f2f: 50 push %eax 115f30: 68 40 07 14 00 push $0x140740 115f35: e8 f6 50 00 00 call 11b030 <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
115f3a: e8 f5 5c 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115f3f: 83 c4 10 add $0x10,%esp 115f42: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115f44: c9 leave 115f45: c3 ret 115f46: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115f48: b8 04 00 00 00 mov $0x4,%eax
}
115f4d: c9 leave 115f4e: c3 ret
00115f50 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
rtems_id id,
void *external,
void **internal
)
{
115f50: 55 push %ebp 115f51: 89 e5 mov %esp,%ebp 115f53: 56 push %esi 115f54: 53 push %ebx 115f55: 83 ec 10 sub $0x10,%esp 115f58: 8b 75 0c mov 0xc(%ebp),%esi 115f5b: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
115f5e: 85 db test %ebx,%ebx
115f60: 74 4e je 115fb0 <rtems_port_external_to_internal+0x60>
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
_Objects_Get( &_Dual_ported_memory_Information, id, location );
115f62: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
115f63: 8d 45 f4 lea -0xc(%ebp),%eax 115f66: 50 push %eax 115f67: ff 75 08 pushl 0x8(%ebp) 115f6a: 68 40 07 14 00 push $0x140740 115f6f: e8 38 52 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
115f74: 83 c4 10 add $0x10,%esp 115f77: 8b 55 f4 mov -0xc(%ebp),%edx 115f7a: 85 d2 test %edx,%edx
115f7c: 74 0e je 115f8c <rtems_port_external_to_internal+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115f7e: b8 04 00 00 00 mov $0x4,%eax
}
115f83: 8d 65 f8 lea -0x8(%ebp),%esp 115f86: 5b pop %ebx 115f87: 5e pop %esi 115f88: c9 leave 115f89: c3 ret 115f8a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
115f8c: 89 f2 mov %esi,%edx 115f8e: 2b 50 14 sub 0x14(%eax),%edx
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
115f91: 3b 50 18 cmp 0x18(%eax),%edx
115f94: 77 16 ja 115fac <rtems_port_external_to_internal+0x5c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
115f96: 03 50 10 add 0x10(%eax),%edx 115f99: 89 13 mov %edx,(%ebx)
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
115f9b: e8 94 5c 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115fa0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115fa2: 8d 65 f8 lea -0x8(%ebp),%esp 115fa5: 5b pop %ebx 115fa6: 5e pop %esi 115fa7: c9 leave 115fa8: c3 ret 115fa9: 8d 76 00 lea 0x0(%esi),%esi
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
*internal = external;
115fac: 89 33 mov %esi,(%ebx) 115fae: eb eb jmp 115f9b <rtems_port_external_to_internal+0x4b>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
return RTEMS_INVALID_ADDRESS;
115fb0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115fb5: 8d 65 f8 lea -0x8(%ebp),%esp 115fb8: 5b pop %ebx 115fb9: 5e pop %esi 115fba: c9 leave 115fbb: c3 ret
00115fe0 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
115fe0: 55 push %ebp 115fe1: 89 e5 mov %esp,%ebp 115fe3: 56 push %esi 115fe4: 53 push %ebx 115fe5: 83 ec 10 sub $0x10,%esp 115fe8: 8b 75 0c mov 0xc(%ebp),%esi 115feb: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
115fee: 85 db test %ebx,%ebx
115ff0: 74 4e je 116040 <rtems_port_internal_to_external+0x60><== NEVER TAKEN
115ff2: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
115ff3: 8d 45 f4 lea -0xc(%ebp),%eax 115ff6: 50 push %eax 115ff7: ff 75 08 pushl 0x8(%ebp) 115ffa: 68 40 07 14 00 push $0x140740 115fff: e8 a8 51 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
116004: 83 c4 10 add $0x10,%esp 116007: 8b 55 f4 mov -0xc(%ebp),%edx 11600a: 85 d2 test %edx,%edx
11600c: 74 0e je 11601c <rtems_port_internal_to_external+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11600e: b8 04 00 00 00 mov $0x4,%eax
}
116013: 8d 65 f8 lea -0x8(%ebp),%esp 116016: 5b pop %ebx 116017: 5e pop %esi 116018: c9 leave 116019: c3 ret 11601a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
11601c: 89 f2 mov %esi,%edx 11601e: 2b 50 10 sub 0x10(%eax),%edx
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
116021: 3b 50 18 cmp 0x18(%eax),%edx
116024: 77 16 ja 11603c <rtems_port_internal_to_external+0x5c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116026: 03 50 14 add 0x14(%eax),%edx 116029: 89 13 mov %edx,(%ebx)
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
11602b: e8 04 5c 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116030: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116032: 8d 65 f8 lea -0x8(%ebp),%esp 116035: 5b pop %ebx 116036: 5e pop %esi 116037: c9 leave 116038: c3 ret 116039: 8d 76 00 lea 0x0(%esi),%esi
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
*external = internal;
11603c: 89 33 mov %esi,(%ebx) 11603e: eb eb jmp 11602b <rtems_port_internal_to_external+0x4b>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
return RTEMS_INVALID_ADDRESS;
116040: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116045: 8d 65 f8 lea -0x8(%ebp),%esp 116048: 5b pop %ebx 116049: 5e pop %esi 11604a: c9 leave 11604b: c3 ret
00116ab8 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
116ab8: 55 push %ebp 116ab9: 89 e5 mov %esp,%ebp 116abb: 53 push %ebx 116abc: 83 ec 18 sub $0x18,%esp
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
116abf: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
116ac2: 50 push %eax 116ac3: ff 75 08 pushl 0x8(%ebp) 116ac6: 68 c0 07 14 00 push $0x1407c0 116acb: e8 dc 46 00 00 call 11b1ac <_Objects_Get> 116ad0: 89 c3 mov %eax,%ebx
switch ( location ) {
116ad2: 83 c4 10 add $0x10,%esp 116ad5: 8b 45 f4 mov -0xc(%ebp),%eax 116ad8: 85 c0 test %eax,%eax
116ada: 74 0c je 116ae8 <rtems_rate_monotonic_cancel+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116adc: b8 04 00 00 00 mov $0x4,%eax
}
116ae1: 8b 5d fc mov -0x4(%ebp),%ebx 116ae4: c9 leave 116ae5: c3 ret 116ae6: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
116ae8: a1 b8 0b 14 00 mov 0x140bb8,%eax 116aed: 39 43 40 cmp %eax,0x40(%ebx)
116af0: 74 12 je 116b04 <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
116af2: e8 3d 51 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
116af7: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116afc: 8b 5d fc mov -0x4(%ebp),%ebx 116aff: c9 leave 116b00: c3 ret 116b01: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
116b04: 83 ec 0c sub $0xc,%esp 116b07: 8d 43 10 lea 0x10(%ebx),%eax 116b0a: 50 push %eax 116b0b: e8 a4 62 00 00 call 11cdb4 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
116b10: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
_Thread_Enable_dispatch();
116b17: e8 18 51 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116b1c: 83 c4 10 add $0x10,%esp 116b1f: 31 c0 xor %eax,%eax 116b21: eb be jmp 116ae1 <rtems_rate_monotonic_cancel+0x29>
0010c340 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
10c340: 55 push %ebp 10c341: 89 e5 mov %esp,%ebp 10c343: 57 push %edi 10c344: 56 push %esi 10c345: 53 push %ebx 10c346: 83 ec 1c sub $0x1c,%esp 10c349: 8b 5d 08 mov 0x8(%ebp),%ebx 10c34c: 8b 75 0c mov 0xc(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10c34f: 85 db test %ebx,%ebx
10c351: 0f 84 a9 00 00 00 je 10c400 <rtems_rate_monotonic_create+0xc0>
return RTEMS_INVALID_NAME;
if ( !id )
10c357: 85 f6 test %esi,%esi
10c359: 0f 84 c5 00 00 00 je 10c424 <rtems_rate_monotonic_create+0xe4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c35f: a1 70 9a 12 00 mov 0x129a70,%eax 10c364: 40 inc %eax 10c365: a3 70 9a 12 00 mov %eax,0x129a70
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
_Objects_Allocate( &_Rate_monotonic_Information );
10c36a: 83 ec 0c sub $0xc,%esp 10c36d: 68 80 99 12 00 push $0x129980 10c372: e8 51 1e 00 00 call 10e1c8 <_Objects_Allocate> 10c377: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
10c379: 83 c4 10 add $0x10,%esp 10c37c: 85 c0 test %eax,%eax
10c37e: 0f 84 8c 00 00 00 je 10c410 <rtems_rate_monotonic_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10c384: a1 38 9d 12 00 mov 0x129d38,%eax 10c389: 89 42 40 mov %eax,0x40(%edx)
the_period->state = RATE_MONOTONIC_INACTIVE;
10c38c: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c393: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
10c39a: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx)
the_watchdog->id = id;
10c3a1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
the_watchdog->user_data = user_data;
10c3a8: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
10c3af: 8d 42 54 lea 0x54(%edx),%eax 10c3b2: 89 45 e4 mov %eax,-0x1c(%ebp) 10c3b5: b9 38 00 00 00 mov $0x38,%ecx 10c3ba: 31 c0 xor %eax,%eax 10c3bc: 8b 7d e4 mov -0x1c(%ebp),%edi 10c3bf: f3 aa rep stos %al,%es:(%edi) 10c3c1: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10c3c8: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10c3cf: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10c3d6: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c3dd: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c3e0: 0f b7 f8 movzwl %ax,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c3e3: 8b 0d 9c 99 12 00 mov 0x12999c,%ecx 10c3e9: 89 14 b9 mov %edx,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c3ec: 89 5a 0c mov %ebx,0xc(%edx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
10c3ef: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c3f1: e8 e2 2d 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c3f6: 31 c0 xor %eax,%eax
}
10c3f8: 8d 65 f4 lea -0xc(%ebp),%esp 10c3fb: 5b pop %ebx 10c3fc: 5e pop %esi 10c3fd: 5f pop %edi 10c3fe: c9 leave 10c3ff: c3 ret
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c400: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c405: 8d 65 f4 lea -0xc(%ebp),%esp 10c408: 5b pop %ebx 10c409: 5e pop %esi 10c40a: 5f pop %edi 10c40b: c9 leave 10c40c: c3 ret 10c40d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
10c410: e8 c3 2d 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c415: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c41a: 8d 65 f4 lea -0xc(%ebp),%esp 10c41d: 5b pop %ebx 10c41e: 5e pop %esi 10c41f: 5f pop %edi 10c420: c9 leave 10c421: c3 ret 10c422: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c424: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c429: 8d 65 f4 lea -0xc(%ebp),%esp 10c42c: 5b pop %ebx 10c42d: 5e pop %esi 10c42e: 5f pop %edi 10c42f: c9 leave 10c430: c3 ret
00111d94 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
111d94: 55 push %ebp 111d95: 89 e5 mov %esp,%ebp 111d97: 53 push %ebx 111d98: 83 ec 24 sub $0x24,%esp 111d9b: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
111d9e: 85 db test %ebx,%ebx
111da0: 0f 84 92 00 00 00 je 111e38 <rtems_rate_monotonic_get_status+0xa4>
111da6: 50 push %eax
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
111da7: 8d 45 f4 lea -0xc(%ebp),%eax 111daa: 50 push %eax 111dab: ff 75 08 pushl 0x8(%ebp) 111dae: 68 80 99 12 00 push $0x129980 111db3: e8 98 c9 ff ff call 10e750 <_Objects_Get>
switch ( location ) {
111db8: 83 c4 10 add $0x10,%esp 111dbb: 8b 4d f4 mov -0xc(%ebp),%ecx 111dbe: 85 c9 test %ecx,%ecx
111dc0: 74 0a je 111dcc <rtems_rate_monotonic_get_status+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
111dc2: b8 04 00 00 00 mov $0x4,%eax
}
111dc7: 8b 5d fc mov -0x4(%ebp),%ebx 111dca: c9 leave 111dcb: c3 ret
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
111dcc: 8b 50 40 mov 0x40(%eax),%edx 111dcf: 8b 52 08 mov 0x8(%edx),%edx 111dd2: 89 13 mov %edx,(%ebx)
status->state = the_period->state;
111dd4: 8b 50 38 mov 0x38(%eax),%edx 111dd7: 89 53 04 mov %edx,0x4(%ebx)
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
111dda: 85 d2 test %edx,%edx
111ddc: 75 2a jne 111e08 <rtems_rate_monotonic_get_status+0x74>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
111dde: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 111de5: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Timespec_Set_to_zero( &status->executed_since_last_period );
111dec: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 111df3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
111dfa: e8 d9 d3 ff ff call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
111dff: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111e01: 8b 5d fc mov -0x4(%ebp),%ebx 111e04: c9 leave 111e05: c3 ret 111e06: 66 90 xchg %ax,%ax
} else {
/*
* Grab the current status.
*/
valid_status =
111e08: 52 push %edx
_Rate_monotonic_Get_status(
111e09: 8d 55 ec lea -0x14(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
111e0c: 52 push %edx
_Rate_monotonic_Get_status(
111e0d: 8d 55 e4 lea -0x1c(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
111e10: 52 push %edx 111e11: 50 push %eax 111e12: e8 41 a6 ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
111e17: 83 c4 10 add $0x10,%esp 111e1a: 84 c0 test %al,%al
111e1c: 74 26 je 111e44 <rtems_rate_monotonic_get_status+0xb0>
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
111e1e: 8b 45 e4 mov -0x1c(%ebp),%eax 111e21: 8b 55 e8 mov -0x18(%ebp),%edx 111e24: 89 43 08 mov %eax,0x8(%ebx) 111e27: 89 53 0c mov %edx,0xc(%ebx)
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
111e2a: 8b 45 ec mov -0x14(%ebp),%eax 111e2d: 8b 55 f0 mov -0x10(%ebp),%edx 111e30: 89 43 10 mov %eax,0x10(%ebx) 111e33: 89 53 14 mov %edx,0x14(%ebx) 111e36: eb c2 jmp 111dfa <rtems_rate_monotonic_get_status+0x66>
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
111e38: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111e3d: 8b 5d fc mov -0x4(%ebp),%ebx 111e40: c9 leave 111e41: c3 ret 111e42: 66 90 xchg %ax,%ax
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
111e44: e8 8f d3 ff ff call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
111e49: b8 0b 00 00 00 mov $0xb,%eax 111e4e: e9 74 ff ff ff jmp 111dc7 <rtems_rate_monotonic_get_status+0x33>
0010c654 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10c654: 55 push %ebp 10c655: 89 e5 mov %esp,%ebp 10c657: 57 push %edi 10c658: 56 push %esi 10c659: 53 push %ebx 10c65a: 83 ec 30 sub $0x30,%esp 10c65d: 8b 5d 08 mov 0x8(%ebp),%ebx 10c660: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
10c663: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10c666: 50 push %eax 10c667: 53 push %ebx 10c668: 68 80 99 12 00 push $0x129980 10c66d: e8 de 20 00 00 call 10e750 <_Objects_Get>
switch ( location ) {
10c672: 83 c4 10 add $0x10,%esp 10c675: 8b 55 e4 mov -0x1c(%ebp),%edx 10c678: 85 d2 test %edx,%edx
10c67a: 74 10 je 10c68c <rtems_rate_monotonic_period+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c67c: b8 04 00 00 00 mov $0x4,%eax
}
10c681: 8d 65 f4 lea -0xc(%ebp),%esp 10c684: 5b pop %ebx 10c685: 5e pop %esi 10c686: 5f pop %edi 10c687: c9 leave 10c688: c3 ret 10c689: 8d 76 00 lea 0x0(%esi),%esi
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10c68c: 8b 15 38 9d 12 00 mov 0x129d38,%edx 10c692: 39 50 40 cmp %edx,0x40(%eax)
10c695: 74 15 je 10c6ac <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10c697: e8 3c 2b 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10c69c: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6a1: 8d 65 f4 lea -0xc(%ebp),%esp 10c6a4: 5b pop %ebx 10c6a5: 5e pop %esi 10c6a6: 5f pop %edi 10c6a7: c9 leave 10c6a8: c3 ret 10c6a9: 8d 76 00 lea 0x0(%esi),%esi
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
10c6ac: 85 f6 test %esi,%esi
10c6ae: 75 1c jne 10c6cc <rtems_rate_monotonic_period+0x78>
switch ( the_period->state ) {
10c6b0: 8b 40 38 mov 0x38(%eax),%eax 10c6b3: 83 f8 04 cmp $0x4,%eax
10c6b6: 77 6c ja 10c724 <rtems_rate_monotonic_period+0xd0><== NEVER TAKEN
10c6b8: 8b 04 85 fc 28 12 00 mov 0x1228fc(,%eax,4),%eax
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10c6bf: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6c2: e8 11 2b 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return( return_value );
10c6c7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6ca: eb b5 jmp 10c681 <rtems_rate_monotonic_period+0x2d>
}
_ISR_Disable( level );
10c6cc: 9c pushf 10c6cd: fa cli 10c6ce: 5f pop %edi
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10c6cf: 8b 50 38 mov 0x38(%eax),%edx 10c6d2: 85 d2 test %edx,%edx
10c6d4: 74 52 je 10c728 <rtems_rate_monotonic_period+0xd4>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10c6d6: 83 fa 02 cmp $0x2,%edx
10c6d9: 0f 84 9e 00 00 00 je 10c77d <rtems_rate_monotonic_period+0x129>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10c6df: 83 fa 04 cmp $0x4,%edx
10c6e2: 75 98 jne 10c67c <rtems_rate_monotonic_period+0x28><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10c6e4: 83 ec 0c sub $0xc,%esp 10c6e7: 50 push %eax 10c6e8: 89 45 d4 mov %eax,-0x2c(%ebp) 10c6eb: e8 74 fe ff ff call 10c564 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10c6f0: 57 push %edi 10c6f1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10c6f2: 8b 45 d4 mov -0x2c(%ebp),%eax 10c6f5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
the_period->next_length = length;
10c6fc: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c6ff: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c702: 5b pop %ebx 10c703: 5e pop %esi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10c704: 83 c0 10 add $0x10,%eax 10c707: 50 push %eax 10c708: 68 7c 9b 12 00 push $0x129b7c 10c70d: e8 76 39 00 00 call 110088 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c712: e8 c1 2a 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10c717: 83 c4 10 add $0x10,%esp 10c71a: b8 06 00 00 00 mov $0x6,%eax 10c71f: e9 5d ff ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10c724: 31 c0 xor %eax,%eax
10c726: eb 97 jmp 10c6bf <rtems_rate_monotonic_period+0x6b><== NOT EXECUTED
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
10c728: 57 push %edi 10c729: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10c72a: 83 ec 0c sub $0xc,%esp 10c72d: 50 push %eax 10c72e: 89 45 d4 mov %eax,-0x2c(%ebp) 10c731: e8 ba fd ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10c736: 8b 45 d4 mov -0x2c(%ebp),%eax 10c739: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c740: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c747: c7 40 2c ac ca 10 00 movl $0x10caac,0x2c(%eax)
the_watchdog->id = id;
10c74e: 89 58 30 mov %ebx,0x30(%eax)
the_watchdog->user_data = user_data;
10c751: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10c758: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c75b: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c75e: 5e pop %esi 10c75f: 5f pop %edi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10c760: 83 c0 10 add $0x10,%eax 10c763: 50 push %eax 10c764: 68 7c 9b 12 00 push $0x129b7c 10c769: e8 1a 39 00 00 call 110088 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c76e: e8 65 2a 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c773: 83 c4 10 add $0x10,%esp 10c776: 31 c0 xor %eax,%eax 10c778: e9 04 ff ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10c77d: 83 ec 0c sub $0xc,%esp 10c780: 50 push %eax 10c781: 89 45 d4 mov %eax,-0x2c(%ebp) 10c784: e8 db fd ff ff call 10c564 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
10c789: 8b 45 d4 mov -0x2c(%ebp),%eax 10c78c: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
the_period->next_length = length;
10c793: 89 70 3c mov %esi,0x3c(%eax)
_ISR_Enable( level );
10c796: 57 push %edi 10c797: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10c798: 8b 15 38 9d 12 00 mov 0x129d38,%edx 10c79e: 8b 48 08 mov 0x8(%eax),%ecx 10c7a1: 89 4a 20 mov %ecx,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10c7a4: 59 pop %ecx 10c7a5: 5b pop %ebx 10c7a6: 68 00 40 00 00 push $0x4000 10c7ab: 52 push %edx 10c7ac: 89 45 d4 mov %eax,-0x2c(%ebp) 10c7af: e8 64 32 00 00 call 10fa18 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10c7b4: 9c pushf 10c7b5: fa cli 10c7b6: 59 pop %ecx
local_state = the_period->state;
10c7b7: 8b 45 d4 mov -0x2c(%ebp),%eax 10c7ba: 8b 50 38 mov 0x38(%eax),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10c7bd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
_ISR_Enable( level );
10c7c4: 51 push %ecx 10c7c5: 9d popf
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
10c7c6: 83 c4 10 add $0x10,%esp 10c7c9: 83 fa 03 cmp $0x3,%edx
10c7cc: 74 0c je 10c7da <rtems_rate_monotonic_period+0x186>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
10c7ce: e8 05 2a 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c7d3: 31 c0 xor %eax,%eax 10c7d5: e9 a7 fe ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10c7da: 57 push %edi 10c7db: 57 push %edi 10c7dc: 68 00 40 00 00 push $0x4000 10c7e1: ff 35 38 9d 12 00 pushl 0x129d38 10c7e7: e8 6c 26 00 00 call 10ee58 <_Thread_Clear_state> 10c7ec: 83 c4 10 add $0x10,%esp 10c7ef: eb dd jmp 10c7ce <rtems_rate_monotonic_period+0x17a>
0010c7f4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10c7f4: 55 push %ebp 10c7f5: 89 e5 mov %esp,%ebp 10c7f7: 57 push %edi 10c7f8: 56 push %esi 10c7f9: 53 push %ebx 10c7fa: 81 ec 8c 00 00 00 sub $0x8c,%esp 10c800: 8b 75 08 mov 0x8(%ebp),%esi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10c803: 8b 7d 0c mov 0xc(%ebp),%edi 10c806: 85 ff test %edi,%edi
10c808: 0f 84 be 00 00 00 je 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10c80e: 83 ec 08 sub $0x8,%esp 10c811: 68 10 29 12 00 push $0x122910 10c816: 56 push %esi 10c817: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10c81a: 59 pop %ecx 10c81b: 5b pop %ebx 10c81c: 68 48 29 12 00 push $0x122948 10c821: 56 push %esi 10c822: ff 55 0c call *0xc(%ebp)
(*print)( context, "--- Wall times are in seconds ---\n" );
10c825: 58 pop %eax 10c826: 5a pop %edx 10c827: 68 6c 29 12 00 push $0x12296c 10c82c: 56 push %esi 10c82d: ff 55 0c call *0xc(%ebp)
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
10c830: 5b pop %ebx 10c831: 5f pop %edi 10c832: 68 90 29 12 00 push $0x122990 10c837: 56 push %esi 10c838: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10c83b: 5a pop %edx 10c83c: 59 pop %ecx 10c83d: 68 dc 29 12 00 push $0x1229dc 10c842: 56 push %esi 10c843: ff 55 0c call *0xc(%ebp)
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10c846: 8b 1d 88 99 12 00 mov 0x129988,%ebx 10c84c: 83 c4 10 add $0x10,%esp 10c84f: 3b 1d 8c 99 12 00 cmp 0x12998c,%ebx
10c855: 77 75 ja 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
10c857: 8d 7d 88 lea -0x78(%ebp),%edi 10c85a: eb 09 jmp 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10c85c: 43 inc %ebx
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10c85d: 39 1d 8c 99 12 00 cmp %ebx,0x12998c
10c863: 72 67 jb 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10c865: 83 ec 08 sub $0x8,%esp 10c868: 57 push %edi 10c869: 53 push %ebx 10c86a: e8 79 54 00 00 call 111ce8 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10c86f: 83 c4 10 add $0x10,%esp 10c872: 85 c0 test %eax,%eax
10c874: 75 e6 jne 10c85c <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
10c876: 83 ec 08 sub $0x8,%esp 10c879: 8d 45 c0 lea -0x40(%ebp),%eax 10c87c: 50 push %eax 10c87d: 53 push %ebx 10c87e: e8 11 55 00 00 call 111d94 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10c883: 83 c4 0c add $0xc,%esp 10c886: 8d 55 e3 lea -0x1d(%ebp),%edx 10c889: 52 push %edx 10c88a: 6a 05 push $0x5 10c88c: ff 75 c0 pushl -0x40(%ebp) 10c88f: e8 b4 02 00 00 call 10cb48 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10c894: 59 pop %ecx 10c895: 58 pop %eax 10c896: ff 75 8c pushl -0x74(%ebp) 10c899: ff 75 88 pushl -0x78(%ebp) 10c89c: 8d 45 e3 lea -0x1d(%ebp),%eax 10c89f: 50 push %eax 10c8a0: 53 push %ebx 10c8a1: 68 2e 29 12 00 push $0x12292e 10c8a6: 56 push %esi 10c8a7: ff 55 0c call *0xc(%ebp)
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10c8aa: 8b 45 88 mov -0x78(%ebp),%eax 10c8ad: 83 c4 20 add $0x20,%esp 10c8b0: 85 c0 test %eax,%eax
10c8b2: 75 20 jne 10c8d4 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
(*print)( context, "\n" );
10c8b4: 83 ec 08 sub $0x8,%esp 10c8b7: 68 19 0a 12 00 push $0x120a19 10c8bc: 56 push %esi 10c8bd: ff 55 0c call *0xc(%ebp)
continue;
10c8c0: 83 c4 10 add $0x10,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10c8c3: 43 inc %ebx
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10c8c4: 39 1d 8c 99 12 00 cmp %ebx,0x12998c
10c8ca: 73 99 jae 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71><== ALWAYS TAKEN
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10c8cc: 8d 65 f4 lea -0xc(%ebp),%esp 10c8cf: 5b pop %ebx 10c8d0: 5e pop %esi 10c8d1: 5f pop %edi 10c8d2: c9 leave 10c8d3: c3 ret
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
10c8d4: 52 push %edx 10c8d5: 8d 55 d8 lea -0x28(%ebp),%edx 10c8d8: 52 push %edx 10c8d9: 50 push %eax 10c8da: 8d 45 a0 lea -0x60(%ebp),%eax 10c8dd: 50 push %eax 10c8de: e8 05 34 00 00 call 10fce8 <_Timespec_Divide_by_integer>
(*print)( context,
10c8e3: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 10c8e8: 8b 45 dc mov -0x24(%ebp),%eax 10c8eb: f7 e9 imul %ecx 10c8ed: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c8f3: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c8f9: c1 f8 06 sar $0x6,%eax 10c8fc: 8b 55 dc mov -0x24(%ebp),%edx 10c8ff: c1 fa 1f sar $0x1f,%edx 10c902: 29 d0 sub %edx,%eax 10c904: 50 push %eax 10c905: ff 75 d8 pushl -0x28(%ebp) 10c908: 8b 45 9c mov -0x64(%ebp),%eax 10c90b: f7 e9 imul %ecx 10c90d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c913: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c919: c1 f8 06 sar $0x6,%eax 10c91c: 8b 55 9c mov -0x64(%ebp),%edx 10c91f: c1 fa 1f sar $0x1f,%edx 10c922: 29 d0 sub %edx,%eax 10c924: 50 push %eax 10c925: ff 75 98 pushl -0x68(%ebp) 10c928: 8b 45 94 mov -0x6c(%ebp),%eax 10c92b: f7 e9 imul %ecx 10c92d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c933: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c939: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c93f: c1 f8 06 sar $0x6,%eax 10c942: 8b 55 94 mov -0x6c(%ebp),%edx 10c945: c1 fa 1f sar $0x1f,%edx 10c948: 29 d0 sub %edx,%eax 10c94a: 50 push %eax 10c94b: ff 75 90 pushl -0x70(%ebp) 10c94e: 68 28 2a 12 00 push $0x122a28 10c953: 56 push %esi 10c954: 89 4d 84 mov %ecx,-0x7c(%ebp) 10c957: ff 55 0c call *0xc(%ebp)
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10c95a: 83 c4 2c add $0x2c,%esp 10c95d: 8d 55 d8 lea -0x28(%ebp),%edx 10c960: 52 push %edx 10c961: ff 75 88 pushl -0x78(%ebp) 10c964: 8d 45 b8 lea -0x48(%ebp),%eax 10c967: 50 push %eax 10c968: e8 7b 33 00 00 call 10fce8 <_Timespec_Divide_by_integer>
(*print)( context,
10c96d: 8b 4d 84 mov -0x7c(%ebp),%ecx 10c970: 8b 45 dc mov -0x24(%ebp),%eax 10c973: f7 e9 imul %ecx 10c975: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c97b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c981: c1 f8 06 sar $0x6,%eax 10c984: 8b 55 dc mov -0x24(%ebp),%edx 10c987: c1 fa 1f sar $0x1f,%edx 10c98a: 29 d0 sub %edx,%eax 10c98c: 50 push %eax 10c98d: ff 75 d8 pushl -0x28(%ebp) 10c990: 8b 45 b4 mov -0x4c(%ebp),%eax 10c993: f7 e9 imul %ecx 10c995: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c99b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9a1: c1 f8 06 sar $0x6,%eax 10c9a4: 8b 55 b4 mov -0x4c(%ebp),%edx 10c9a7: c1 fa 1f sar $0x1f,%edx 10c9aa: 29 d0 sub %edx,%eax 10c9ac: 50 push %eax 10c9ad: ff 75 b0 pushl -0x50(%ebp) 10c9b0: 8b 45 ac mov -0x54(%ebp),%eax 10c9b3: f7 e9 imul %ecx 10c9b5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10c9bb: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10c9c1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10c9c7: c1 f8 06 sar $0x6,%eax 10c9ca: 8b 55 ac mov -0x54(%ebp),%edx 10c9cd: c1 fa 1f sar $0x1f,%edx 10c9d0: 29 d0 sub %edx,%eax 10c9d2: 50 push %eax 10c9d3: ff 75 a8 pushl -0x58(%ebp) 10c9d6: 68 48 2a 12 00 push $0x122a48 10c9db: 56 push %esi 10c9dc: ff 55 0c call *0xc(%ebp) 10c9df: 83 c4 30 add $0x30,%esp 10c9e2: e9 75 fe ff ff jmp 10c85c <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
0010ca00 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
10ca00: 55 push %ebp 10ca01: 89 e5 mov %esp,%ebp 10ca03: 53 push %ebx 10ca04: 83 ec 04 sub $0x4,%esp 10ca07: a1 70 9a 12 00 mov 0x129a70,%eax 10ca0c: 40 inc %eax 10ca0d: a3 70 9a 12 00 mov %eax,0x129a70
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10ca12: 8b 1d 88 99 12 00 mov 0x129988,%ebx 10ca18: 3b 1d 8c 99 12 00 cmp 0x12998c,%ebx
10ca1e: 77 15 ja 10ca35 <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
10ca20: 83 ec 0c sub $0xc,%esp 10ca23: 53 push %ebx 10ca24: e8 17 00 00 00 call 10ca40 <rtems_rate_monotonic_reset_statistics>
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10ca29: 43 inc %ebx
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10ca2a: 83 c4 10 add $0x10,%esp 10ca2d: 39 1d 8c 99 12 00 cmp %ebx,0x12998c
10ca33: 73 eb jae 10ca20 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
10ca35: 8b 5d fc mov -0x4(%ebp),%ebx 10ca38: c9 leave
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
10ca39: e9 9a 27 00 00 jmp 10f1d8 <_Thread_Enable_dispatch>
0010ca40 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
10ca40: 55 push %ebp 10ca41: 89 e5 mov %esp,%ebp 10ca43: 57 push %edi 10ca44: 53 push %ebx 10ca45: 83 ec 14 sub $0x14,%esp
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
10ca48: 8d 45 f4 lea -0xc(%ebp),%eax 10ca4b: 50 push %eax 10ca4c: ff 75 08 pushl 0x8(%ebp) 10ca4f: 68 80 99 12 00 push $0x129980 10ca54: e8 f7 1c 00 00 call 10e750 <_Objects_Get> 10ca59: 89 c2 mov %eax,%edx
switch ( location ) {
10ca5b: 83 c4 10 add $0x10,%esp 10ca5e: 8b 45 f4 mov -0xc(%ebp),%eax 10ca61: 85 c0 test %eax,%eax
10ca63: 75 3b jne 10caa0 <rtems_rate_monotonic_reset_statistics+0x60>
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
10ca65: 8d 5a 54 lea 0x54(%edx),%ebx 10ca68: b9 38 00 00 00 mov $0x38,%ecx 10ca6d: 31 c0 xor %eax,%eax 10ca6f: 89 df mov %ebx,%edi 10ca71: f3 aa rep stos %al,%es:(%edi) 10ca73: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10ca7a: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10ca81: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10ca88: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
_Thread_Enable_dispatch();
10ca8f: e8 44 27 00 00 call 10f1d8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca94: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ca96: 8d 65 f8 lea -0x8(%ebp),%esp 10ca99: 5b pop %ebx 10ca9a: 5f pop %edi 10ca9b: c9 leave 10ca9c: c3 ret 10ca9d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10caa0: b8 04 00 00 00 mov $0x4,%eax
}
10caa5: 8d 65 f8 lea -0x8(%ebp),%esp 10caa8: 5b pop %ebx 10caa9: 5f pop %edi 10caaa: c9 leave 10caab: c3 ret
0011724c <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11724c: 55 push %ebp 11724d: 89 e5 mov %esp,%ebp 11724f: 57 push %edi 117250: 56 push %esi 117251: 53 push %ebx 117252: 83 ec 1c sub $0x1c,%esp 117255: 8b 7d 08 mov 0x8(%ebp),%edi 117258: 8b 75 0c mov 0xc(%ebp),%esi
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
11725b: 85 ff test %edi,%edi
11725d: 0f 84 c1 00 00 00 je 117324 <rtems_region_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !starting_address )
117263: 85 f6 test %esi,%esi
117265: 0f 84 e1 00 00 00 je 11734c <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
if ( !id )
11726b: 8b 45 1c mov 0x1c(%ebp),%eax 11726e: 85 c0 test %eax,%eax
117270: 0f 84 d6 00 00 00 je 11734c <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
117276: 83 ec 0c sub $0xc,%esp 117279: ff 35 dc 09 14 00 pushl 0x1409dc 11727f: e8 dc 24 00 00 call 119760 <_API_Mutex_Lock>
* This function allocates a region control block from
* the inactive chain of free region control blocks.
*/
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
return (Region_Control *) _Objects_Allocate( &_Region_Information );
117284: c7 04 24 00 08 14 00 movl $0x140800,(%esp) 11728b: e8 28 3a 00 00 call 11acb8 <_Objects_Allocate> 117290: 89 c3 mov %eax,%ebx
the_region = _Region_Allocate();
if ( !the_region )
117292: 83 c4 10 add $0x10,%esp 117295: 85 c0 test %eax,%eax
117297: 0f 84 bf 00 00 00 je 11735c <rtems_region_create+0x110>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
11729d: ff 75 14 pushl 0x14(%ebp) 1172a0: ff 75 10 pushl 0x10(%ebp) 1172a3: 56 push %esi 1172a4: 8d 40 68 lea 0x68(%eax),%eax 1172a7: 50 push %eax 1172a8: e8 17 36 00 00 call 11a8c4 <_Heap_Initialize> 1172ad: 89 43 5c mov %eax,0x5c(%ebx)
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
1172b0: 83 c4 10 add $0x10,%esp 1172b3: 85 c0 test %eax,%eax
1172b5: 74 7d je 117334 <rtems_region_create+0xe8>
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
1172b7: 89 73 50 mov %esi,0x50(%ebx)
the_region->length = length;
1172ba: 8b 45 10 mov 0x10(%ebp),%eax 1172bd: 89 43 54 mov %eax,0x54(%ebx)
the_region->page_size = page_size;
1172c0: 8b 55 14 mov 0x14(%ebp),%edx 1172c3: 89 53 58 mov %edx,0x58(%ebx)
the_region->attribute_set = attribute_set;
1172c6: 8b 45 18 mov 0x18(%ebp),%eax 1172c9: 89 43 60 mov %eax,0x60(%ebx)
the_region->number_of_used_blocks = 0;
1172cc: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
_Thread_queue_Initialize(
1172d3: 6a 06 push $0x6 1172d5: 6a 40 push $0x40 1172d7: a8 04 test $0x4,%al 1172d9: 0f 95 c0 setne %al 1172dc: 0f b6 c0 movzbl %al,%eax 1172df: 50 push %eax 1172e0: 8d 43 10 lea 0x10(%ebx),%eax 1172e3: 50 push %eax 1172e4: e8 6b 50 00 00 call 11c354 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1172e9: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1172ec: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1172ef: 8b 15 1c 08 14 00 mov 0x14081c,%edx 1172f5: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1172f8: 89 7b 0c mov %edi,0xc(%ebx)
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
1172fb: 8b 55 1c mov 0x1c(%ebp),%edx 1172fe: 89 02 mov %eax,(%edx) 117300: 83 c4 10 add $0x10,%esp
return_status = RTEMS_SUCCESSFUL;
117303: 31 c0 xor %eax,%eax
}
}
_RTEMS_Unlock_allocator();
117305: 83 ec 0c sub $0xc,%esp 117308: ff 35 dc 09 14 00 pushl 0x1409dc 11730e: 89 45 e4 mov %eax,-0x1c(%ebp) 117311: e8 92 24 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status;
117316: 83 c4 10 add $0x10,%esp 117319: 8b 45 e4 mov -0x1c(%ebp),%eax
}
11731c: 8d 65 f4 lea -0xc(%ebp),%esp 11731f: 5b pop %ebx 117320: 5e pop %esi 117321: 5f pop %edi 117322: c9 leave 117323: c3 ret
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
117324: b8 03 00 00 00 mov $0x3,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
117329: 8d 65 f4 lea -0xc(%ebp),%esp 11732c: 5b pop %ebx 11732d: 5e pop %esi 11732e: 5f pop %edi 11732f: c9 leave 117330: c3 ret 117331: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
117334: 83 ec 08 sub $0x8,%esp 117337: 53 push %ebx 117338: 68 00 08 14 00 push $0x140800 11733d: e8 ee 3c 00 00 call 11b030 <_Objects_Free> 117342: 83 c4 10 add $0x10,%esp
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
117345: b8 08 00 00 00 mov $0x8,%eax 11734a: eb b9 jmp 117305 <rtems_region_create+0xb9>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
11734c: b8 09 00 00 00 mov $0x9,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
117351: 8d 65 f4 lea -0xc(%ebp),%esp 117354: 5b pop %ebx 117355: 5e pop %esi 117356: 5f pop %edi 117357: c9 leave 117358: c3 ret 117359: 8d 76 00 lea 0x0(%esi),%esi
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
return_status = RTEMS_TOO_MANY;
11735c: b8 05 00 00 00 mov $0x5,%eax 117361: eb a2 jmp 117305 <rtems_region_create+0xb9>
00117364 <rtems_region_delete>:
*/
rtems_status_code rtems_region_delete(
rtems_id id
)
{
117364: 55 push %ebp 117365: 89 e5 mov %esp,%ebp 117367: 53 push %ebx 117368: 83 ec 30 sub $0x30,%esp
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
_RTEMS_Lock_allocator();
11736b: ff 35 dc 09 14 00 pushl 0x1409dc 117371: e8 ea 23 00 00 call 119760 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
117376: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117379: 8d 45 f4 lea -0xc(%ebp),%eax 11737c: 50 push %eax 11737d: ff 75 08 pushl 0x8(%ebp) 117380: 68 00 08 14 00 push $0x140800 117385: e8 e6 3d 00 00 call 11b170 <_Objects_Get_no_protection>
switch ( location ) {
11738a: 83 c4 10 add $0x10,%esp 11738d: 8b 5d f4 mov -0xc(%ebp),%ebx 117390: 85 db test %ebx,%ebx
117392: 74 1c je 1173b0 <rtems_region_delete+0x4c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117394: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
117399: 83 ec 0c sub $0xc,%esp 11739c: ff 35 dc 09 14 00 pushl 0x1409dc 1173a2: e8 01 24 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status; }
1173a7: 89 d8 mov %ebx,%eax 1173a9: 8b 5d fc mov -0x4(%ebp),%ebx 1173ac: c9 leave 1173ad: c3 ret 1173ae: 66 90 xchg %ax,%ax
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 5 );
if ( the_region->number_of_used_blocks != 0 )
1173b0: 8b 48 64 mov 0x64(%eax),%ecx 1173b3: 85 c9 test %ecx,%ecx
1173b5: 74 09 je 1173c0 <rtems_region_delete+0x5c>
return_status = RTEMS_RESOURCE_IN_USE;
1173b7: bb 0c 00 00 00 mov $0xc,%ebx 1173bc: eb db jmp 117399 <rtems_region_delete+0x35> 1173be: 66 90 xchg %ax,%ax
else {
_Objects_Close( &_Region_Information, &the_region->Object );
1173c0: 83 ec 08 sub $0x8,%esp 1173c3: 50 push %eax 1173c4: 68 00 08 14 00 push $0x140800 1173c9: 89 45 e4 mov %eax,-0x1c(%ebp) 1173cc: e8 63 39 00 00 call 11ad34 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
1173d1: 58 pop %eax 1173d2: 5a pop %edx 1173d3: 8b 45 e4 mov -0x1c(%ebp),%eax 1173d6: 50 push %eax 1173d7: 68 00 08 14 00 push $0x140800 1173dc: e8 4f 3c 00 00 call 11b030 <_Objects_Free> 1173e1: 83 c4 10 add $0x10,%esp
_Region_Free( the_region );
return_status = RTEMS_SUCCESSFUL;
1173e4: 31 db xor %ebx,%ebx 1173e6: eb b1 jmp 117399 <rtems_region_delete+0x35>
001173e8 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
1173e8: 55 push %ebp 1173e9: 89 e5 mov %esp,%ebp 1173eb: 56 push %esi 1173ec: 53 push %ebx 1173ed: 83 ec 10 sub $0x10,%esp 1173f0: 8b 5d 0c mov 0xc(%ebp),%ebx
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
1173f3: 85 db test %ebx,%ebx
1173f5: 74 75 je 11746c <rtems_region_extend+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
1173f7: 83 ec 0c sub $0xc,%esp 1173fa: ff 35 dc 09 14 00 pushl 0x1409dc 117400: e8 5b 23 00 00 call 119760 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
117405: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117408: 8d 45 f0 lea -0x10(%ebp),%eax 11740b: 50 push %eax 11740c: ff 75 08 pushl 0x8(%ebp) 11740f: 68 00 08 14 00 push $0x140800 117414: e8 57 3d 00 00 call 11b170 <_Objects_Get_no_protection> 117419: 89 c6 mov %eax,%esi
switch ( location ) {
11741b: 83 c4 10 add $0x10,%esp 11741e: 8b 45 f0 mov -0x10(%ebp),%eax 117421: 85 c0 test %eax,%eax
117423: 74 1f je 117444 <rtems_region_extend+0x5c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117425: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
11742a: 83 ec 0c sub $0xc,%esp 11742d: ff 35 dc 09 14 00 pushl 0x1409dc 117433: e8 70 23 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status;
117438: 83 c4 10 add $0x10,%esp
}
11743b: 89 d8 mov %ebx,%eax 11743d: 8d 65 f8 lea -0x8(%ebp),%esp 117440: 5b pop %ebx 117441: 5e pop %esi 117442: c9 leave 117443: c3 ret
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
117444: 8d 45 f4 lea -0xc(%ebp),%eax 117447: 50 push %eax 117448: ff 75 10 pushl 0x10(%ebp) 11744b: 53 push %ebx 11744c: 8d 46 68 lea 0x68(%esi),%eax 11744f: 50 push %eax 117450: e8 63 2e 00 00 call 11a2b8 <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
117455: 83 c4 10 add $0x10,%esp 117458: 84 c0 test %al,%al
11745a: 74 20 je 11747c <rtems_region_extend+0x94>
the_region->length += amount_extended;
11745c: 8b 45 f4 mov -0xc(%ebp),%eax 11745f: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
117462: 01 46 5c add %eax,0x5c(%esi)
return_status = RTEMS_SUCCESSFUL;
117465: 31 db xor %ebx,%ebx 117467: eb c1 jmp 11742a <rtems_region_extend+0x42> 117469: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
11746c: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117471: 89 d8 mov %ebx,%eax 117473: 8d 65 f8 lea -0x8(%ebp),%esp 117476: 5b pop %ebx 117477: 5e pop %esi 117478: c9 leave 117479: c3 ret 11747a: 66 90 xchg %ax,%ax
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
11747c: bb 09 00 00 00 mov $0x9,%ebx 117481: eb a7 jmp 11742a <rtems_region_extend+0x42>
00117484 <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
117484: 55 push %ebp 117485: 89 e5 mov %esp,%ebp 117487: 53 push %ebx 117488: 83 ec 14 sub $0x14,%esp 11748b: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
11748e: 85 db test %ebx,%ebx
117490: 74 76 je 117508 <rtems_region_get_free_information+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
117492: 83 ec 0c sub $0xc,%esp 117495: ff 35 dc 09 14 00 pushl 0x1409dc 11749b: e8 c0 22 00 00 call 119760 <_API_Mutex_Lock> 1174a0: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1174a3: 8d 45 f4 lea -0xc(%ebp),%eax 1174a6: 50 push %eax 1174a7: ff 75 08 pushl 0x8(%ebp) 1174aa: 68 00 08 14 00 push $0x140800 1174af: e8 bc 3c 00 00 call 11b170 <_Objects_Get_no_protection>
switch ( location ) {
1174b4: 83 c4 10 add $0x10,%esp 1174b7: 8b 55 f4 mov -0xc(%ebp),%edx 1174ba: 85 d2 test %edx,%edx
1174bc: 74 1e je 1174dc <rtems_region_get_free_information+0x58>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
1174be: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
1174c3: 83 ec 0c sub $0xc,%esp 1174c6: ff 35 dc 09 14 00 pushl 0x1409dc 1174cc: e8 d7 22 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status;
1174d1: 83 c4 10 add $0x10,%esp
}
1174d4: 89 d8 mov %ebx,%eax 1174d6: 8b 5d fc mov -0x4(%ebp),%ebx 1174d9: c9 leave 1174da: c3 ret 1174db: 90 nop
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
1174dc: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_info->Used.total = 0;
1174e3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
the_info->Used.largest = 0;
1174ea: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
1174f1: 83 ec 08 sub $0x8,%esp 1174f4: 53 push %ebx 1174f5: 83 c0 68 add $0x68,%eax 1174f8: 50 push %eax 1174f9: e8 a2 31 00 00 call 11a6a0 <_Heap_Get_free_information>
return_status = RTEMS_SUCCESSFUL;
break;
1174fe: 83 c4 10 add $0x10,%esp
the_info->Used.total = 0;
the_info->Used.largest = 0;
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
return_status = RTEMS_SUCCESSFUL;
117501: 31 db xor %ebx,%ebx
break;
117503: eb be jmp 1174c3 <rtems_region_get_free_information+0x3f> 117505: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
117508: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11750d: 89 d8 mov %ebx,%eax 11750f: 8b 5d fc mov -0x4(%ebp),%ebx 117512: c9 leave 117513: c3 ret
0011758c <rtems_region_get_segment>:
uintptr_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
11758c: 55 push %ebp 11758d: 89 e5 mov %esp,%ebp 11758f: 57 push %edi 117590: 56 push %esi 117591: 53 push %ebx 117592: 83 ec 2c sub $0x2c,%esp 117595: 8b 75 0c mov 0xc(%ebp),%esi 117598: 8b 5d 18 mov 0x18(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
11759b: 85 db test %ebx,%ebx
11759d: 0f 84 a1 00 00 00 je 117644 <rtems_region_get_segment+0xb8>
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
1175a3: c7 03 00 00 00 00 movl $0x0,(%ebx)
if ( size == 0 )
1175a9: 85 f6 test %esi,%esi
1175ab: 75 0f jne 1175bc <rtems_region_get_segment+0x30>
return RTEMS_INVALID_SIZE;
1175ad: b8 08 00 00 00 mov $0x8,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1175b2: 8d 65 f4 lea -0xc(%ebp),%esp 1175b5: 5b pop %ebx 1175b6: 5e pop %esi 1175b7: 5f pop %edi 1175b8: c9 leave 1175b9: c3 ret 1175ba: 66 90 xchg %ax,%ax
*segment = NULL;
if ( size == 0 )
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
1175bc: 83 ec 0c sub $0xc,%esp 1175bf: ff 35 dc 09 14 00 pushl 0x1409dc 1175c5: e8 96 21 00 00 call 119760 <_API_Mutex_Lock>
executing = _Thread_Executing;
1175ca: a1 b8 0b 14 00 mov 0x140bb8,%eax 1175cf: 89 45 d4 mov %eax,-0x2c(%ebp) 1175d2: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1175d5: 8d 45 e4 lea -0x1c(%ebp),%eax 1175d8: 50 push %eax 1175d9: ff 75 08 pushl 0x8(%ebp) 1175dc: 68 00 08 14 00 push $0x140800 1175e1: e8 8a 3b 00 00 call 11b170 <_Objects_Get_no_protection> 1175e6: 89 c7 mov %eax,%edi
switch ( location ) {
1175e8: 83 c4 10 add $0x10,%esp 1175eb: 8b 45 e4 mov -0x1c(%ebp),%eax 1175ee: 85 c0 test %eax,%eax
1175f0: 75 2a jne 11761c <rtems_region_get_segment+0x90>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
1175f2: 3b 77 5c cmp 0x5c(%edi),%esi
1175f5: 76 2d jbe 117624 <rtems_region_get_segment+0x98>
return_status = RTEMS_INVALID_SIZE;
1175f7: b8 08 00 00 00 mov $0x8,%eax
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1175fc: 83 ec 0c sub $0xc,%esp 1175ff: ff 35 dc 09 14 00 pushl 0x1409dc 117605: 89 45 d0 mov %eax,-0x30(%ebp) 117608: e8 9b 21 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status;
11760d: 83 c4 10 add $0x10,%esp 117610: 8b 45 d0 mov -0x30(%ebp),%eax
}
117613: 8d 65 f4 lea -0xc(%ebp),%esp 117616: 5b pop %ebx 117617: 5e pop %esi 117618: 5f pop %edi 117619: c9 leave 11761a: c3 ret 11761b: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
11761c: b8 04 00 00 00 mov $0x4,%eax 117621: eb d9 jmp 1175fc <rtems_region_get_segment+0x70> 117623: 90 nop
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
117624: 6a 00 push $0x0 117626: 6a 00 push $0x0 117628: 56 push %esi
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
117629: 8d 47 68 lea 0x68(%edi),%eax 11762c: 50 push %eax 11762d: e8 b2 2a 00 00 call 11a0e4 <_Heap_Allocate_aligned_with_boundary>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
117632: 83 c4 10 add $0x10,%esp 117635: 85 c0 test %eax,%eax
117637: 74 17 je 117650 <rtems_region_get_segment+0xc4>
the_region->number_of_used_blocks += 1;
117639: ff 47 64 incl 0x64(%edi)
*segment = the_segment;
11763c: 89 03 mov %eax,(%ebx)
return_status = RTEMS_SUCCESSFUL;
11763e: 31 c0 xor %eax,%eax 117640: eb ba jmp 1175fc <rtems_region_get_segment+0x70> 117642: 66 90 xchg %ax,%ax
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
return RTEMS_INVALID_ADDRESS;
117644: b8 09 00 00 00 mov $0x9,%eax 117649: e9 64 ff ff ff jmp 1175b2 <rtems_region_get_segment+0x26> 11764e: 66 90 xchg %ax,%ax
if ( the_segment ) {
the_region->number_of_used_blocks += 1;
*segment = the_segment;
return_status = RTEMS_SUCCESSFUL;
} else if ( _Options_Is_no_wait( option_set ) ) {
117650: f6 45 10 01 testb $0x1,0x10(%ebp)
117654: 74 07 je 11765d <rtems_region_get_segment+0xd1>
return_status = RTEMS_UNSATISFIED;
117656: b8 0d 00 00 00 mov $0xd,%eax 11765b: eb 9f jmp 1175fc <rtems_region_get_segment+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
11765d: a1 f0 08 14 00 mov 0x1408f0,%eax 117662: 40 inc %eax 117663: a3 f0 08 14 00 mov %eax,0x1408f0
* Switch from using the memory allocation mutex to using a
* dispatching disabled critical section. We have to do this
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
117668: 83 ec 0c sub $0xc,%esp 11766b: ff 35 dc 09 14 00 pushl 0x1409dc 117671: e8 32 21 00 00 call 1197a8 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
117676: 8d 47 10 lea 0x10(%edi),%eax 117679: 8b 55 d4 mov -0x2c(%ebp),%edx 11767c: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
11767f: 8b 4d 08 mov 0x8(%ebp),%ecx 117682: 89 4a 20 mov %ecx,0x20(%edx)
executing->Wait.count = size;
117685: 89 72 24 mov %esi,0x24(%edx)
executing->Wait.return_argument = segment;
117688: 89 5a 28 mov %ebx,0x28(%edx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
11768b: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi)
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
117692: 83 c4 0c add $0xc,%esp 117695: 68 18 c4 11 00 push $0x11c418 11769a: ff 75 14 pushl 0x14(%ebp) 11769d: 50 push %eax 11769e: e8 49 4a 00 00 call 11c0ec <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
1176a3: e8 8c 45 00 00 call 11bc34 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
1176a8: 8b 55 d4 mov -0x2c(%ebp),%edx 1176ab: 8b 42 34 mov 0x34(%edx),%eax 1176ae: 83 c4 10 add $0x10,%esp 1176b1: e9 fc fe ff ff jmp 1175b2 <rtems_region_get_segment+0x26>
0011776c <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
11776c: 55 push %ebp 11776d: 89 e5 mov %esp,%ebp 11776f: 56 push %esi 117770: 53 push %ebx 117771: 83 ec 20 sub $0x20,%esp 117774: 8b 5d 14 mov 0x14(%ebp),%ebx
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
117777: 85 db test %ebx,%ebx
117779: 0f 84 89 00 00 00 je 117808 <rtems_region_resize_segment+0x9c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
11777f: 83 ec 0c sub $0xc,%esp 117782: ff 35 dc 09 14 00 pushl 0x1409dc 117788: e8 d3 1f 00 00 call 119760 <_API_Mutex_Lock> 11778d: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117790: 8d 45 f0 lea -0x10(%ebp),%eax 117793: 50 push %eax 117794: ff 75 08 pushl 0x8(%ebp) 117797: 68 00 08 14 00 push $0x140800 11779c: e8 cf 39 00 00 call 11b170 <_Objects_Get_no_protection> 1177a1: 89 c6 mov %eax,%esi
switch ( location ) {
1177a3: 83 c4 10 add $0x10,%esp 1177a6: 8b 45 f0 mov -0x10(%ebp),%eax 1177a9: 85 c0 test %eax,%eax
1177ab: 74 1f je 1177cc <rtems_region_resize_segment+0x60>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1177ad: 83 ec 0c sub $0xc,%esp 1177b0: ff 35 dc 09 14 00 pushl 0x1409dc 1177b6: e8 ed 1f 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status;
1177bb: 83 c4 10 add $0x10,%esp 1177be: b8 04 00 00 00 mov $0x4,%eax
}
1177c3: 8d 65 f8 lea -0x8(%ebp),%esp 1177c6: 5b pop %ebx 1177c7: 5e pop %esi 1177c8: c9 leave 1177c9: c3 ret 1177ca: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
1177cc: 83 ec 0c sub $0xc,%esp 1177cf: 8d 45 f4 lea -0xc(%ebp),%eax 1177d2: 50 push %eax 1177d3: 8d 45 ec lea -0x14(%ebp),%eax 1177d6: 50 push %eax 1177d7: ff 75 10 pushl 0x10(%ebp) 1177da: ff 75 0c pushl 0xc(%ebp) 1177dd: 8d 46 68 lea 0x68(%esi),%eax 1177e0: 50 push %eax 1177e1: e8 e6 32 00 00 call 11aacc <_Heap_Resize_block>
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
1177e6: 8b 55 ec mov -0x14(%ebp),%edx 1177e9: 89 13 mov %edx,(%ebx)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
1177eb: 83 c4 20 add $0x20,%esp 1177ee: 85 c0 test %eax,%eax
1177f0: 75 22 jne 117814 <rtems_region_resize_segment+0xa8>
_Region_Process_queue( the_region ); /* unlocks allocator */
1177f2: 83 ec 0c sub $0xc,%esp 1177f5: 56 push %esi 1177f6: e8 29 71 00 00 call 11e924 <_Region_Process_queue> 1177fb: 83 c4 10 add $0x10,%esp
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
1177fe: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117800: 8d 65 f8 lea -0x8(%ebp),%esp 117803: 5b pop %ebx 117804: 5e pop %esi 117805: c9 leave 117806: c3 ret 117807: 90 nop
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
117808: b8 09 00 00 00 mov $0x9,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11780d: 8d 65 f8 lea -0x8(%ebp),%esp 117810: 5b pop %ebx 117811: 5e pop %esi 117812: c9 leave 117813: c3 ret
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
117814: 83 ec 0c sub $0xc,%esp 117817: ff 35 dc 09 14 00 pushl 0x1409dc 11781d: 89 45 e4 mov %eax,-0x1c(%ebp) 117820: e8 83 1f 00 00 call 1197a8 <_API_Mutex_Unlock>
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
117825: 83 c4 10 add $0x10,%esp
return RTEMS_UNSATISFIED;
117828: 8b 45 e4 mov -0x1c(%ebp),%eax 11782b: 48 dec %eax 11782c: 0f 94 c0 sete %al 11782f: 0f b6 c0 movzbl %al,%eax 117832: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117839: 8d 65 f8 lea -0x8(%ebp),%esp 11783c: 5b pop %ebx 11783d: 5e pop %esi 11783e: c9 leave 11783f: c3 ret
00117840 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
117840: 55 push %ebp 117841: 89 e5 mov %esp,%ebp 117843: 53 push %ebx 117844: 83 ec 20 sub $0x20,%esp
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
117847: ff 35 dc 09 14 00 pushl 0x1409dc 11784d: e8 0e 1f 00 00 call 119760 <_API_Mutex_Lock> 117852: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117855: 8d 45 f4 lea -0xc(%ebp),%eax 117858: 50 push %eax 117859: ff 75 08 pushl 0x8(%ebp) 11785c: 68 00 08 14 00 push $0x140800 117861: e8 0a 39 00 00 call 11b170 <_Objects_Get_no_protection> 117866: 89 c3 mov %eax,%ebx
switch ( location ) {
117868: 83 c4 10 add $0x10,%esp 11786b: 8b 45 f4 mov -0xc(%ebp),%eax 11786e: 85 c0 test %eax,%eax
117870: 75 1e jne 117890 <rtems_region_return_segment+0x50>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
117872: 83 ec 08 sub $0x8,%esp 117875: ff 75 0c pushl 0xc(%ebp) 117878: 8d 43 68 lea 0x68(%ebx),%eax 11787b: 50 push %eax 11787c: e8 cf 2c 00 00 call 11a550 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
117881: 83 c4 10 add $0x10,%esp 117884: 84 c0 test %al,%al
117886: 75 28 jne 1178b0 <rtems_region_return_segment+0x70>
return_status = RTEMS_INVALID_ADDRESS;
117888: bb 09 00 00 00 mov $0x9,%ebx 11788d: eb 06 jmp 117895 <rtems_region_return_segment+0x55> 11788f: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117890: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
117895: 83 ec 0c sub $0xc,%esp 117898: ff 35 dc 09 14 00 pushl 0x1409dc 11789e: e8 05 1f 00 00 call 1197a8 <_API_Mutex_Unlock>
return return_status;
1178a3: 83 c4 10 add $0x10,%esp
}
1178a6: 89 d8 mov %ebx,%eax 1178a8: 8b 5d fc mov -0x4(%ebp),%ebx 1178ab: c9 leave 1178ac: c3 ret 1178ad: 8d 76 00 lea 0x0(%esi),%esi
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
1178b0: ff 4b 64 decl 0x64(%ebx)
_Region_Process_queue(the_region); /* unlocks allocator */
1178b3: 83 ec 0c sub $0xc,%esp 1178b6: 53 push %ebx 1178b7: e8 68 70 00 00 call 11e924 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
1178bc: 83 c4 10 add $0x10,%esp 1178bf: 31 db xor %ebx,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1178c1: 89 d8 mov %ebx,%eax 1178c3: 8b 5d fc mov -0x4(%ebp),%ebx 1178c6: c9 leave 1178c7: c3 ret
0010b434 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
10b434: 55 push %ebp 10b435: 89 e5 mov %esp,%ebp 10b437: 57 push %edi 10b438: 56 push %esi 10b439: 53 push %ebx 10b43a: 83 ec 3c sub $0x3c,%esp 10b43d: 8b 75 08 mov 0x8(%ebp),%esi 10b440: 8b 5d 10 mov 0x10(%ebp),%ebx 10b443: 8b 7d 18 mov 0x18(%ebp),%edi
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
10b446: 85 f6 test %esi,%esi
10b448: 74 4a je 10b494 <rtems_semaphore_create+0x60>
return RTEMS_INVALID_NAME;
if ( !id )
10b44a: 85 ff test %edi,%edi
10b44c: 0f 84 f6 00 00 00 je 10b548 <rtems_semaphore_create+0x114>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10b452: 89 da mov %ebx,%edx 10b454: 81 e2 c0 00 00 00 and $0xc0,%edx
10b45a: 74 48 je 10b4a4 <rtems_semaphore_create+0x70>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
10b45c: 89 d8 mov %ebx,%eax 10b45e: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10b461: 83 f8 10 cmp $0x10,%eax
10b464: 74 0e je 10b474 <rtems_semaphore_create+0x40>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
10b466: b8 0b 00 00 00 mov $0xb,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b46b: 8d 65 f4 lea -0xc(%ebp),%esp 10b46e: 5b pop %ebx 10b46f: 5e pop %esi 10b470: 5f pop %edi 10b471: c9 leave 10b472: c3 ret 10b473: 90 nop
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10b474: f6 c3 04 test $0x4,%bl
10b477: 74 ed je 10b466 <rtems_semaphore_create+0x32>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
10b479: 81 fa c0 00 00 00 cmp $0xc0,%edx
10b47f: 74 e5 je 10b466 <rtems_semaphore_create+0x32>
10b481: b9 10 00 00 00 mov $0x10,%ecx
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10b486: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10b48a: 76 1f jbe 10b4ab <rtems_semaphore_create+0x77>
return RTEMS_INVALID_NUMBER;
10b48c: b8 0a 00 00 00 mov $0xa,%eax 10b491: eb d8 jmp 10b46b <rtems_semaphore_create+0x37> 10b493: 90 nop
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b494: b8 03 00 00 00 mov $0x3,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b499: 8d 65 f4 lea -0xc(%ebp),%esp 10b49c: 5b pop %ebx 10b49d: 5e pop %esi 10b49e: 5f pop %edi 10b49f: c9 leave 10b4a0: c3 ret 10b4a1: 8d 76 00 lea 0x0(%esi),%esi
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10b4a4: 89 d9 mov %ebx,%ecx 10b4a6: 83 e1 30 and $0x30,%ecx
10b4a9: 75 db jne 10b486 <rtems_semaphore_create+0x52>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4ab: a1 b0 64 12 00 mov 0x1264b0,%eax 10b4b0: 40 inc %eax 10b4b1: a3 b0 64 12 00 mov %eax,0x1264b0
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
10b4b6: 83 ec 0c sub $0xc,%esp 10b4b9: 68 00 64 12 00 push $0x126400 10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp) 10b4c1: e8 ee 13 00 00 call 10c8b4 <_Objects_Allocate> 10b4c6: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
10b4c8: 83 c4 10 add $0x10,%esp 10b4cb: 85 c0 test %eax,%eax 10b4cd: 8b 4d c4 mov -0x3c(%ebp),%ecx
10b4d0: 0f 84 ba 00 00 00 je 10b590 <rtems_semaphore_create+0x15c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
10b4d6: 89 58 10 mov %ebx,0x10(%eax)
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
10b4d9: 85 c9 test %ecx,%ecx
10b4db: 74 77 je 10b554 <rtems_semaphore_create+0x120>
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
10b4dd: 31 c0 xor %eax,%eax 10b4df: f6 c3 04 test $0x4,%bl 10b4e2: 0f 95 c0 setne %al 10b4e5: 89 45 d8 mov %eax,-0x28(%ebp)
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
10b4e8: 83 f9 10 cmp $0x10,%ecx
10b4eb: 0f 84 ae 00 00 00 je 10b59f <rtems_semaphore_create+0x16b>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
10b4f1: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10b4f8: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
}
mutex_status = _CORE_mutex_Initialize(
10b4fc: 50 push %eax 10b4fd: 31 c0 xor %eax,%eax 10b4ff: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b503: 0f 94 c0 sete %al 10b506: 50 push %eax 10b507: 8d 45 d0 lea -0x30(%ebp),%eax 10b50a: 50 push %eax 10b50b: 8d 42 14 lea 0x14(%edx),%eax 10b50e: 50 push %eax 10b50f: 89 55 c4 mov %edx,-0x3c(%ebp) 10b512: e8 95 0b 00 00 call 10c0ac <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
10b517: 83 c4 10 add $0x10,%esp 10b51a: 83 f8 06 cmp $0x6,%eax 10b51d: 8b 55 c4 mov -0x3c(%ebp),%edx
10b520: 0f 84 a9 00 00 00 je 10b5cf <rtems_semaphore_create+0x19b>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b526: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b529: 0f b7 d8 movzwl %ax,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b52c: 8b 0d 1c 64 12 00 mov 0x12641c,%ecx 10b532: 89 14 99 mov %edx,(%ecx,%ebx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b535: 89 72 0c mov %esi,0xc(%edx)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
10b538: 89 07 mov %eax,(%edi)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
10b53a: e8 b5 22 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b53f: 31 c0 xor %eax,%eax 10b541: e9 25 ff ff ff jmp 10b46b <rtems_semaphore_create+0x37> 10b546: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b548: b8 09 00 00 00 mov $0x9,%eax 10b54d: e9 19 ff ff ff jmp 10b46b <rtems_semaphore_create+0x37> 10b552: 66 90 xchg %ax,%ax
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
10b554: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
10b55b: 31 c0 xor %eax,%eax 10b55d: f6 c3 04 test $0x4,%bl 10b560: 0f 95 c0 setne %al 10b563: 89 45 e4 mov %eax,-0x1c(%ebp)
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10b566: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
10b56d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
_CORE_semaphore_Initialize(
10b574: 51 push %ecx 10b575: ff 75 0c pushl 0xc(%ebp) 10b578: 8d 45 e0 lea -0x20(%ebp),%eax 10b57b: 50 push %eax 10b57c: 8d 42 14 lea 0x14(%edx),%eax 10b57f: 50 push %eax 10b580: 89 55 c4 mov %edx,-0x3c(%ebp) 10b583: e8 b4 0d 00 00 call 10c33c <_CORE_semaphore_Initialize> 10b588: 83 c4 10 add $0x10,%esp 10b58b: 8b 55 c4 mov -0x3c(%ebp),%edx 10b58e: eb 96 jmp 10b526 <rtems_semaphore_create+0xf2>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
10b590: e8 5f 22 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b595: b8 05 00 00 00 mov $0x5,%eax 10b59a: e9 cc fe ff ff jmp 10b46b <rtems_semaphore_create+0x37>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
10b59f: 8b 45 14 mov 0x14(%ebp),%eax 10b5a2: 89 45 dc mov %eax,-0x24(%ebp)
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10b5a5: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10b5ac: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
10b5b0: 83 7d d8 01 cmpl $0x1,-0x28(%ebp)
10b5b4: 0f 85 42 ff ff ff jne 10b4fc <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
10b5ba: f6 c3 40 test $0x40,%bl
10b5bd: 74 30 je 10b5ef <rtems_semaphore_create+0x1bb>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10b5bf: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10b5c6: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b5ca: e9 2d ff ff ff jmp 10b4fc <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10b5cf: 83 ec 08 sub $0x8,%esp 10b5d2: 52 push %edx 10b5d3: 68 00 64 12 00 push $0x126400 10b5d8: e8 4f 16 00 00 call 10cc2c <_Objects_Free>
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
10b5dd: e8 12 22 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
10b5e2: 83 c4 10 add $0x10,%esp 10b5e5: b8 13 00 00 00 mov $0x13,%eax 10b5ea: e9 7c fe ff ff jmp 10b46b <rtems_semaphore_create+0x37>
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
10b5ef: 81 e3 80 00 00 00 and $0x80,%ebx
10b5f5: 0f 84 01 ff ff ff je 10b4fc <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10b5fb: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10b602: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10b606: e9 f1 fe ff ff jmp 10b4fc <rtems_semaphore_create+0xc8>
0010b60c <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
10b60c: 55 push %ebp 10b60d: 89 e5 mov %esp,%ebp 10b60f: 53 push %ebx 10b610: 83 ec 18 sub $0x18,%esp
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
10b613: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10b616: 50 push %eax 10b617: ff 75 08 pushl 0x8(%ebp) 10b61a: 68 00 64 12 00 push $0x126400 10b61f: e8 48 17 00 00 call 10cd6c <_Objects_Get> 10b624: 89 c3 mov %eax,%ebx
switch ( location ) {
10b626: 83 c4 10 add $0x10,%esp 10b629: 8b 4d f4 mov -0xc(%ebp),%ecx 10b62c: 85 c9 test %ecx,%ecx
10b62e: 74 0c je 10b63c <rtems_semaphore_delete+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b630: b8 04 00 00 00 mov $0x4,%eax
}
10b635: 8b 5d fc mov -0x4(%ebp),%ebx 10b638: c9 leave 10b639: c3 ret 10b63a: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
10b63c: 8b 40 10 mov 0x10(%eax),%eax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10b63f: 83 e0 30 and $0x30,%eax
10b642: 74 58 je 10b69c <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
10b644: 8b 53 64 mov 0x64(%ebx),%edx 10b647: 85 d2 test %edx,%edx
10b649: 75 15 jne 10b660 <rtems_semaphore_delete+0x54>
10b64b: 83 f8 20 cmp $0x20,%eax
10b64e: 74 10 je 10b660 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
10b650: e8 9f 21 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b655: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b65a: 8b 5d fc mov -0x4(%ebp),%ebx 10b65d: c9 leave 10b65e: c3 ret 10b65f: 90 nop
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
10b660: 50 push %eax 10b661: 6a 04 push $0x4 10b663: 6a 00 push $0x0 10b665: 8d 43 14 lea 0x14(%ebx),%eax 10b668: 50 push %eax 10b669: e8 32 0a 00 00 call 10c0a0 <_CORE_mutex_Flush> 10b66e: 83 c4 10 add $0x10,%esp
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
10b671: 83 ec 08 sub $0x8,%esp 10b674: 53 push %ebx 10b675: 68 00 64 12 00 push $0x126400 10b67a: e8 b1 12 00 00 call 10c930 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10b67f: 58 pop %eax 10b680: 5a pop %edx 10b681: 53 push %ebx 10b682: 68 00 64 12 00 push $0x126400 10b687: e8 a0 15 00 00 call 10cc2c <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10b68c: e8 63 21 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b691: 83 c4 10 add $0x10,%esp 10b694: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b696: 8b 5d fc mov -0x4(%ebp),%ebx 10b699: c9 leave 10b69a: c3 ret 10b69b: 90 nop
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
10b69c: 51 push %ecx 10b69d: 6a 02 push $0x2 10b69f: 6a 00 push $0x0 10b6a1: 8d 43 14 lea 0x14(%ebx),%eax 10b6a4: 50 push %eax 10b6a5: e8 86 0c 00 00 call 10c330 <_CORE_semaphore_Flush> 10b6aa: 83 c4 10 add $0x10,%esp 10b6ad: eb c2 jmp 10b671 <rtems_semaphore_delete+0x65>
0010b6b0 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10b6b0: 55 push %ebp 10b6b1: 89 e5 mov %esp,%ebp 10b6b3: 57 push %edi 10b6b4: 56 push %esi 10b6b5: 53 push %ebx 10b6b6: 83 ec 1c sub $0x1c,%esp 10b6b9: 8b 5d 08 mov 0x8(%ebp),%ebx 10b6bc: 8b 75 0c mov 0xc(%ebp),%esi 10b6bf: 8b 7d 10 mov 0x10(%ebp),%edi
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
10b6c2: 8d 45 e0 lea -0x20(%ebp),%eax
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
_Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
10b6c5: 50 push %eax 10b6c6: 8d 45 e4 lea -0x1c(%ebp),%eax 10b6c9: 50 push %eax 10b6ca: 53 push %ebx 10b6cb: 68 00 64 12 00 push $0x126400 10b6d0: e8 3f 16 00 00 call 10cd14 <_Objects_Get_isr_disable>
switch ( location ) {
10b6d5: 83 c4 10 add $0x10,%esp 10b6d8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b6db: 85 c9 test %ecx,%ecx
10b6dd: 74 0d je 10b6ec <rtems_semaphore_obtain+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b6df: b8 04 00 00 00 mov $0x4,%eax
}
10b6e4: 8d 65 f4 lea -0xc(%ebp),%esp 10b6e7: 5b pop %ebx 10b6e8: 5e pop %esi 10b6e9: 5f pop %edi 10b6ea: c9 leave 10b6eb: c3 ret
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10b6ec: f6 40 10 30 testb $0x30,0x10(%eax)
10b6f0: 74 36 je 10b728 <rtems_semaphore_obtain+0x78>
_CORE_mutex_Seize(
10b6f2: 83 ec 0c sub $0xc,%esp 10b6f5: ff 75 e0 pushl -0x20(%ebp) 10b6f8: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
10b6f9: 83 e6 01 and $0x1,%esi 10b6fc: 83 f6 01 xor $0x1,%esi 10b6ff: 56 push %esi 10b700: 53 push %ebx 10b701: 83 c0 14 add $0x14,%eax 10b704: 50 push %eax 10b705: e8 9a 0a 00 00 call 10c1a4 <_CORE_mutex_Seize>
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10b70a: 83 c4 14 add $0x14,%esp
_Thread_Executing->Wait.return_code );
10b70d: a1 78 67 12 00 mov 0x126778,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10b712: ff 70 34 pushl 0x34(%eax) 10b715: e8 12 01 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b71a: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10b71d: 8d 65 f4 lea -0xc(%ebp),%esp 10b720: 5b pop %ebx 10b721: 5e pop %esi 10b722: 5f pop %edi 10b723: c9 leave 10b724: c3 ret 10b725: 8d 76 00 lea 0x0(%esi),%esi
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
10b728: 8b 15 78 67 12 00 mov 0x126778,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b72e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( the_semaphore->count != 0 ) {
10b735: 8b 48 5c mov 0x5c(%eax),%ecx 10b738: 85 c9 test %ecx,%ecx
10b73a: 75 2c jne 10b768 <rtems_semaphore_obtain+0xb8>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
10b73c: 83 e6 01 and $0x1,%esi
10b73f: 74 33 je 10b774 <rtems_semaphore_obtain+0xc4>
_ISR_Enable( *level_p );
10b741: ff 75 e0 pushl -0x20(%ebp) 10b744: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
10b745: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx)
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10b74c: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10b74f: a1 78 67 12 00 mov 0x126778,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10b754: ff 70 34 pushl 0x34(%eax) 10b757: e8 e0 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b75c: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10b75f: 8d 65 f4 lea -0xc(%ebp),%esp 10b762: 5b pop %ebx 10b763: 5e pop %esi 10b764: 5f pop %edi 10b765: c9 leave 10b766: c3 ret 10b767: 90 nop
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
10b768: 49 dec %ecx 10b769: 89 48 5c mov %ecx,0x5c(%eax)
_ISR_Enable( *level_p );
10b76c: ff 75 e0 pushl -0x20(%ebp) 10b76f: 9d popf 10b770: eb da jmp 10b74c <rtems_semaphore_obtain+0x9c> 10b772: 66 90 xchg %ax,%ax 10b774: 8b 0d b0 64 12 00 mov 0x1264b0,%ecx 10b77a: 41 inc %ecx 10b77b: 89 0d b0 64 12 00 mov %ecx,0x1264b0
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10b781: c7 40 44 01 00 00 00 movl $0x1,0x44(%eax)
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
10b788: 83 c0 14 add $0x14,%eax 10b78b: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10b78e: 89 5a 20 mov %ebx,0x20(%edx)
_ISR_Enable( *level_p );
10b791: ff 75 e0 pushl -0x20(%ebp) 10b794: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
10b795: 52 push %edx 10b796: 68 d8 df 10 00 push $0x10dfd8 10b79b: 57 push %edi 10b79c: 50 push %eax 10b79d: e8 0a 25 00 00 call 10dcac <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10b7a2: e8 4d 20 00 00 call 10d7f4 <_Thread_Enable_dispatch> 10b7a7: 83 c4 10 add $0x10,%esp 10b7aa: eb a0 jmp 10b74c <rtems_semaphore_obtain+0x9c>
0010b7ac <rtems_semaphore_release>:
#endif
rtems_status_code rtems_semaphore_release(
rtems_id id
)
{
10b7ac: 55 push %ebp 10b7ad: 89 e5 mov %esp,%ebp 10b7af: 53 push %ebx 10b7b0: 83 ec 18 sub $0x18,%esp 10b7b3: 8b 5d 08 mov 0x8(%ebp),%ebx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
CORE_mutex_Status mutex_status;
CORE_semaphore_Status semaphore_status;
the_semaphore = _Semaphore_Get( id, &location );
10b7b6: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10b7b9: 50 push %eax 10b7ba: 53 push %ebx 10b7bb: 68 00 64 12 00 push $0x126400 10b7c0: e8 a7 15 00 00 call 10cd6c <_Objects_Get>
switch ( location ) {
10b7c5: 83 c4 10 add $0x10,%esp 10b7c8: 8b 55 f4 mov -0xc(%ebp),%edx 10b7cb: 85 d2 test %edx,%edx
10b7cd: 74 0d je 10b7dc <rtems_semaphore_release+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b7cf: b8 04 00 00 00 mov $0x4,%eax
}
10b7d4: 8b 5d fc mov -0x4(%ebp),%ebx 10b7d7: c9 leave 10b7d8: c3 ret 10b7d9: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10b7dc: f6 40 10 30 testb $0x30,0x10(%eax)
10b7e0: 75 26 jne 10b808 <rtems_semaphore_release+0x5c>
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
} else {
semaphore_status = _CORE_semaphore_Surrender(
10b7e2: 52 push %edx 10b7e3: 6a 00 push $0x0 10b7e5: 53 push %ebx 10b7e6: 83 c0 14 add $0x14,%eax 10b7e9: 50 push %eax 10b7ea: e8 8d 0b 00 00 call 10c37c <_CORE_semaphore_Surrender> 10b7ef: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b7f1: e8 fe 1f 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return
10b7f6: 89 1c 24 mov %ebx,(%esp) 10b7f9: e8 3e 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code> 10b7fe: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b801: 8b 5d fc mov -0x4(%ebp),%ebx 10b804: c9 leave 10b805: c3 ret 10b806: 66 90 xchg %ax,%ax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
mutex_status = _CORE_mutex_Surrender(
10b808: 51 push %ecx 10b809: 6a 00 push $0x0 10b80b: 53 push %ebx 10b80c: 83 c0 14 add $0x14,%eax 10b80f: 50 push %eax 10b810: e8 2f 0a 00 00 call 10c244 <_CORE_mutex_Surrender> 10b815: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b817: e8 d8 1f 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
10b81c: 89 1c 24 mov %ebx,(%esp) 10b81f: e8 08 00 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code> 10b824: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b827: 8b 5d fc mov -0x4(%ebp),%ebx 10b82a: c9 leave 10b82b: c3 ret
00117d60 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
117d60: 55 push %ebp 117d61: 89 e5 mov %esp,%ebp 117d63: 53 push %ebx 117d64: 83 ec 14 sub $0x14,%esp 117d67: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
117d6a: 85 db test %ebx,%ebx
117d6c: 75 0a jne 117d78 <rtems_signal_send+0x18>
return RTEMS_INVALID_NUMBER;
117d6e: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117d73: 8b 5d fc mov -0x4(%ebp),%ebx 117d76: c9 leave 117d77: c3 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
117d78: 83 ec 08 sub $0x8,%esp 117d7b: 8d 45 f4 lea -0xc(%ebp),%eax 117d7e: 50 push %eax 117d7f: ff 75 08 pushl 0x8(%ebp) 117d82: e8 d1 3e 00 00 call 11bc58 <_Thread_Get>
switch ( location ) {
117d87: 83 c4 10 add $0x10,%esp 117d8a: 8b 55 f4 mov -0xc(%ebp),%edx 117d8d: 85 d2 test %edx,%edx
117d8f: 74 0b je 117d9c <rtems_signal_send+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117d91: b8 04 00 00 00 mov $0x4,%eax
}
117d96: 8b 5d fc mov -0x4(%ebp),%ebx 117d99: c9 leave 117d9a: c3 ret 117d9b: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
117d9c: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
117da2: 8b 4a 0c mov 0xc(%edx),%ecx 117da5: 85 c9 test %ecx,%ecx
117da7: 74 3f je 117de8 <rtems_signal_send+0x88>
if ( asr->is_enabled ) {
117da9: 80 7a 08 00 cmpb $0x0,0x8(%edx)
117dad: 74 25 je 117dd4 <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
117daf: 9c pushf 117db0: fa cli 117db1: 59 pop %ecx
*signal_set |= signals;
117db2: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
117db5: 51 push %ecx 117db6: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
117db7: 8b 15 b4 0b 14 00 mov 0x140bb4,%edx 117dbd: 85 d2 test %edx,%edx
117dbf: 74 1b je 117ddc <rtems_signal_send+0x7c>
117dc1: 3b 05 b8 0b 14 00 cmp 0x140bb8,%eax
117dc7: 75 13 jne 117ddc <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
117dc9: c6 05 c4 0b 14 00 01 movb $0x1,0x140bc4 117dd0: eb 0a jmp 117ddc <rtems_signal_send+0x7c> 117dd2: 66 90 xchg %ax,%ax
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
117dd4: 9c pushf 117dd5: fa cli 117dd6: 58 pop %eax
*signal_set |= signals;
117dd7: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
117dda: 50 push %eax 117ddb: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
117ddc: e8 53 3e 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117de1: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117de3: 8b 5d fc mov -0x4(%ebp),%ebx 117de6: c9 leave 117de7: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117de8: e8 47 3e 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
117ded: b8 0b 00 00 00 mov $0xb,%eax 117df2: e9 7c ff ff ff jmp 117d73 <rtems_signal_send+0x13>
0010b84c <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
10b84c: 55 push %ebp 10b84d: 89 e5 mov %esp,%ebp 10b84f: 57 push %edi 10b850: 56 push %esi 10b851: 53 push %ebx 10b852: 83 ec 1c sub $0x1c,%esp 10b855: 8b 5d 08 mov 0x8(%ebp),%ebx 10b858: 8b 7d 0c mov 0xc(%ebp),%edi 10b85b: 8b 75 1c mov 0x1c(%ebp),%esi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10b85e: 85 f6 test %esi,%esi
10b860: 0f 84 3e 01 00 00 je 10b9a4 <rtems_task_create+0x158>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10b866: 85 db test %ebx,%ebx
10b868: 0f 84 d2 00 00 00 je 10b940 <rtems_task_create+0xf4>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
10b86e: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp)
10b875: 75 17 jne 10b88e <rtems_task_create+0x42>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10b877: 85 ff test %edi,%edi
10b879: 0f 84 b1 00 00 00 je 10b930 <rtems_task_create+0xe4>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10b87f: 0f b6 05 14 22 12 00 movzbl 0x122214,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10b886: 39 c7 cmp %eax,%edi
10b888: 0f 87 a2 00 00 00 ja 10b930 <rtems_task_create+0xe4>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b88e: 83 ec 0c sub $0xc,%esp 10b891: ff 35 9c 65 12 00 pushl 0x12659c 10b897: e8 7c 06 00 00 call 10bf18 <_API_Mutex_Lock>
* This function allocates a task control block from
* the inactive chain of free task control blocks.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
10b89c: c7 04 24 40 64 12 00 movl $0x126440,(%esp) 10b8a3: e8 0c 10 00 00 call 10c8b4 <_Objects_Allocate> 10b8a8: 89 c2 mov %eax,%edx
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10b8aa: 83 c4 10 add $0x10,%esp 10b8ad: 85 c0 test %eax,%eax
10b8af: 0f 84 cf 00 00 00 je 10b984 <rtems_task_create+0x138>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10b8b5: 50 push %eax 10b8b6: 53 push %ebx
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
10b8b7: 8b 45 14 mov 0x14(%ebp),%eax 10b8ba: 83 e0 01 and $0x1,%eax 10b8bd: 50 push %eax 10b8be: 6a 00 push $0x0 10b8c0: 31 c0 xor %eax,%eax 10b8c2: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp) 10b8c9: 0f 95 c0 setne %al 10b8cc: 50 push %eax 10b8cd: 31 c0 xor %eax,%eax 10b8cf: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp) 10b8d6: 0f 94 c0 sete %al 10b8d9: 50 push %eax 10b8da: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
10b8db: 8b 45 18 mov 0x18(%ebp),%eax 10b8de: 83 e0 01 and $0x1,%eax 10b8e1: 50 push %eax 10b8e2: ff 75 10 pushl 0x10(%ebp) 10b8e5: 6a 00 push $0x0 10b8e7: 52 push %edx 10b8e8: 68 40 64 12 00 push $0x126440 10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp) 10b8f0: e8 9b 1f 00 00 call 10d890 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
10b8f5: 83 c4 30 add $0x30,%esp 10b8f8: 84 c0 test %al,%al 10b8fa: 8b 55 e4 mov -0x1c(%ebp),%edx
10b8fd: 74 51 je 10b950 <rtems_task_create+0x104>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
10b8ff: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
10b905: f7 45 14 00 04 00 00 testl $0x400,0x14(%ebp)
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
10b90c: 0f 94 40 08 sete 0x8(%eax)
*id = the_thread->Object.id;
10b910: 8b 42 08 mov 0x8(%edx),%eax 10b913: 89 06 mov %eax,(%esi)
);
}
#endif
_RTEMS_Unlock_allocator();
10b915: 83 ec 0c sub $0xc,%esp 10b918: ff 35 9c 65 12 00 pushl 0x12659c 10b91e: e8 3d 06 00 00 call 10bf60 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
10b923: 83 c4 10 add $0x10,%esp 10b926: 31 c0 xor %eax,%eax
}
10b928: 8d 65 f4 lea -0xc(%ebp),%esp 10b92b: 5b pop %ebx 10b92c: 5e pop %esi 10b92d: 5f pop %edi 10b92e: c9 leave 10b92f: c3 ret
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
return RTEMS_INVALID_PRIORITY;
10b930: b8 13 00 00 00 mov $0x13,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b935: 8d 65 f4 lea -0xc(%ebp),%esp 10b938: 5b pop %ebx 10b939: 5e pop %esi 10b93a: 5f pop %edi 10b93b: c9 leave 10b93c: c3 ret 10b93d: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b940: b8 03 00 00 00 mov $0x3,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b945: 8d 65 f4 lea -0xc(%ebp),%esp 10b948: 5b pop %ebx 10b949: 5e pop %esi 10b94a: 5f pop %edi 10b94b: c9 leave 10b94c: c3 ret 10b94d: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
10b950: 83 ec 0c sub $0xc,%esp 10b953: ff 72 08 pushl 0x8(%edx) 10b956: e8 41 13 00 00 call 10cc9c <_Objects_Get_information_id> 10b95b: 5a pop %edx 10b95c: 59 pop %ecx 10b95d: 8b 55 e4 mov -0x1c(%ebp),%edx 10b960: 52 push %edx 10b961: 50 push %eax 10b962: e8 c5 12 00 00 call 10cc2c <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10b967: 58 pop %eax 10b968: ff 35 9c 65 12 00 pushl 0x12659c 10b96e: e8 ed 05 00 00 call 10bf60 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
10b973: 83 c4 10 add $0x10,%esp 10b976: b8 0d 00 00 00 mov $0xd,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b97b: 8d 65 f4 lea -0xc(%ebp),%esp 10b97e: 5b pop %ebx 10b97f: 5e pop %esi 10b980: 5f pop %edi 10b981: c9 leave 10b982: c3 ret 10b983: 90 nop
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10b984: 83 ec 0c sub $0xc,%esp 10b987: ff 35 9c 65 12 00 pushl 0x12659c 10b98d: e8 ce 05 00 00 call 10bf60 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
10b992: 83 c4 10 add $0x10,%esp 10b995: b8 05 00 00 00 mov $0x5,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b99a: 8d 65 f4 lea -0xc(%ebp),%esp 10b99d: 5b pop %ebx 10b99e: 5e pop %esi 10b99f: 5f pop %edi 10b9a0: c9 leave 10b9a1: c3 ret 10b9a2: 66 90 xchg %ax,%ax
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b9a4: b8 09 00 00 00 mov $0x9,%eax 10b9a9: eb 8a jmp 10b935 <rtems_task_create+0xe9>
0010b9ac <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 53 push %ebx 10b9b0: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
10b9b3: ff 35 9c 65 12 00 pushl 0x12659c 10b9b9: e8 5a 05 00 00 call 10bf18 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
10b9be: 5a pop %edx 10b9bf: 59 pop %ecx 10b9c0: 8d 45 f4 lea -0xc(%ebp),%eax 10b9c3: 50 push %eax 10b9c4: ff 75 08 pushl 0x8(%ebp) 10b9c7: e8 4c 1e 00 00 call 10d818 <_Thread_Get> 10b9cc: 89 c3 mov %eax,%ebx
switch ( location ) {
10b9ce: 83 c4 10 add $0x10,%esp 10b9d1: 8b 45 f4 mov -0xc(%ebp),%eax 10b9d4: 85 c0 test %eax,%eax
10b9d6: 75 44 jne 10ba1c <rtems_task_delete+0x70>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
10b9d8: 83 ec 0c sub $0xc,%esp 10b9db: ff 73 08 pushl 0x8(%ebx) 10b9de: e8 b9 12 00 00 call 10cc9c <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
10b9e3: 5a pop %edx 10b9e4: 59 pop %ecx 10b9e5: 53 push %ebx 10b9e6: 50 push %eax 10b9e7: e8 c8 1a 00 00 call 10d4b4 <_Thread_Close> 10b9ec: 58 pop %eax 10b9ed: ff 73 08 pushl 0x8(%ebx) 10b9f0: e8 a7 12 00 00 call 10cc9c <_Objects_Get_information_id> 10b9f5: 5a pop %edx 10b9f6: 59 pop %ecx 10b9f7: 53 push %ebx 10b9f8: 50 push %eax 10b9f9: e8 2e 12 00 00 call 10cc2c <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10b9fe: 58 pop %eax 10b9ff: ff 35 9c 65 12 00 pushl 0x12659c 10ba05: e8 56 05 00 00 call 10bf60 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10ba0a: e8 e5 1d 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ba0f: 83 c4 10 add $0x10,%esp 10ba12: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
10ba14: 8b 5d fc mov -0x4(%ebp),%ebx 10ba17: c9 leave 10ba18: c3 ret 10ba19: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
10ba1c: 83 ec 0c sub $0xc,%esp 10ba1f: ff 35 9c 65 12 00 pushl 0x12659c 10ba25: e8 36 05 00 00 call 10bf60 <_API_Mutex_Unlock>
return RTEMS_INVALID_ID;
10ba2a: 83 c4 10 add $0x10,%esp 10ba2d: b8 04 00 00 00 mov $0x4,%eax
}
10ba32: 8b 5d fc mov -0x4(%ebp),%ebx 10ba35: c9 leave 10ba36: c3 ret
0010d4e4 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
10d4e4: 55 push %ebp 10d4e5: 89 e5 mov %esp,%ebp 10d4e7: 56 push %esi 10d4e8: 53 push %ebx 10d4e9: 83 ec 10 sub $0x10,%esp 10d4ec: 8b 45 08 mov 0x8(%ebp),%eax 10d4ef: 8b 75 0c mov 0xc(%ebp),%esi 10d4f2: 8b 5d 10 mov 0x10(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10d4f5: 80 3d e4 62 12 00 00 cmpb $0x0,0x1262e4
10d4fc: 74 6e je 10d56c <rtems_task_get_note+0x88>
return RTEMS_NOT_CONFIGURED;
if ( !note )
10d4fe: 85 db test %ebx,%ebx
10d500: 74 7e je 10d580 <rtems_task_get_note+0x9c>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10d502: 83 fe 0f cmp $0xf,%esi
10d505: 77 3d ja 10d544 <rtems_task_get_note+0x60>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d507: 85 c0 test %eax,%eax
10d509: 74 45 je 10d550 <rtems_task_get_note+0x6c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d50b: 8b 15 98 ab 12 00 mov 0x12ab98,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d511: 3b 42 08 cmp 0x8(%edx),%eax
10d514: 74 40 je 10d556 <rtems_task_get_note+0x72>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10d516: 83 ec 08 sub $0x8,%esp 10d519: 8d 55 f4 lea -0xc(%ebp),%edx 10d51c: 52 push %edx 10d51d: 50 push %eax 10d51e: e8 3d 21 00 00 call 10f660 <_Thread_Get>
switch ( location ) {
10d523: 83 c4 10 add $0x10,%esp 10d526: 8b 55 f4 mov -0xc(%ebp),%edx 10d529: 85 d2 test %edx,%edx
10d52b: 75 4b jne 10d578 <rtems_task_get_note+0x94>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10d52d: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax 10d533: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d537: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10d539: e8 fe 20 00 00 call 10f63c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d53e: 31 c0 xor %eax,%eax 10d540: eb 07 jmp 10d549 <rtems_task_get_note+0x65> 10d542: 66 90 xchg %ax,%ax
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
return RTEMS_INVALID_NUMBER;
10d544: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d549: 8d 65 f8 lea -0x8(%ebp),%esp 10d54c: 5b pop %ebx 10d54d: 5e pop %esi 10d54e: c9 leave 10d54f: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d550: 8b 15 98 ab 12 00 mov 0x12ab98,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10d556: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax 10d55c: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10d560: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
10d562: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d564: 8d 65 f8 lea -0x8(%ebp),%esp 10d567: 5b pop %ebx 10d568: 5e pop %esi 10d569: c9 leave 10d56a: c3 ret 10d56b: 90 nop
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10d56c: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d571: 8d 65 f8 lea -0x8(%ebp),%esp 10d574: 5b pop %ebx 10d575: 5e pop %esi 10d576: c9 leave 10d577: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d578: b8 04 00 00 00 mov $0x4,%eax 10d57d: eb ca jmp 10d549 <rtems_task_get_note+0x65> 10d57f: 90 nop
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
return RTEMS_INVALID_ADDRESS;
10d580: b8 09 00 00 00 mov $0x9,%eax 10d585: eb c2 jmp 10d549 <rtems_task_get_note+0x65>
00118144 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
118144: 55 push %ebp 118145: 89 e5 mov %esp,%ebp 118147: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
11814a: 8d 45 f4 lea -0xc(%ebp),%eax 11814d: 50 push %eax 11814e: ff 75 08 pushl 0x8(%ebp) 118151: e8 02 3b 00 00 call 11bc58 <_Thread_Get>
switch ( location ) {
118156: 83 c4 10 add $0x10,%esp 118159: 8b 55 f4 mov -0xc(%ebp),%edx 11815c: 85 d2 test %edx,%edx
11815e: 74 08 je 118168 <rtems_task_is_suspended+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118160: b8 04 00 00 00 mov $0x4,%eax
}
118165: c9 leave 118166: c3 ret 118167: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
118168: f6 40 10 02 testb $0x2,0x10(%eax)
11816c: 74 0e je 11817c <rtems_task_is_suspended+0x38>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11816e: e8 c1 3a 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
118173: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118178: c9 leave 118179: c3 ret 11817a: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
11817c: e8 b3 3a 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118181: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118183: c9 leave 118184: c3 ret
00111f24 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
111f24: 55 push %ebp 111f25: 89 e5 mov %esp,%ebp 111f27: 57 push %edi 111f28: 56 push %esi 111f29: 53 push %ebx 111f2a: 83 ec 1c sub $0x1c,%esp 111f2d: 8b 4d 10 mov 0x10(%ebp),%ecx
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
111f30: 85 c9 test %ecx,%ecx
111f32: 0f 84 40 01 00 00 je 112078 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
111f38: 8b 1d 78 67 12 00 mov 0x126778,%ebx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
111f3e: 8b bb e4 00 00 00 mov 0xe4(%ebx),%edi
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
111f44: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 111f48: 19 f6 sbb %esi,%esi 111f4a: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
111f50: 8b 53 7c mov 0x7c(%ebx),%edx 111f53: 85 d2 test %edx,%edx
111f55: 0f 85 f1 00 00 00 jne 11204c <rtems_task_mode+0x128>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
111f5b: 80 7f 08 01 cmpb $0x1,0x8(%edi) 111f5f: 19 d2 sbb %edx,%edx 111f61: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
111f67: 89 55 e4 mov %edx,-0x1c(%ebp) 111f6a: 89 4d e0 mov %ecx,-0x20(%ebp) 111f6d: e8 9a cc ff ff call 10ec0c <_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;
111f72: 8b 55 e4 mov -0x1c(%ebp),%edx 111f75: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
111f77: 09 f0 or %esi,%eax 111f79: 8b 4d e0 mov -0x20(%ebp),%ecx 111f7c: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
111f7e: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
111f85: 74 0b je 111f92 <rtems_task_mode+0x6e>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
111f87: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 111f8e: 0f 94 43 74 sete 0x74(%ebx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
111f92: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
111f99: 74 1c je 111fb7 <rtems_task_mode+0x93>
if ( _Modes_Is_timeslice(mode_set) ) {
111f9b: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
111fa2: 0f 84 b8 00 00 00 je 112060 <rtems_task_mode+0x13c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
111fa8: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
111faf: a1 80 64 12 00 mov 0x126480,%eax 111fb4: 89 43 78 mov %eax,0x78(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
111fb7: f6 45 0c 01 testb $0x1,0xc(%ebp)
111fbb: 74 0b je 111fc8 <rtems_task_mode+0xa4>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
111fbd: f6 45 08 01 testb $0x1,0x8(%ebp)
111fc1: 0f 84 91 00 00 00 je 112058 <rtems_task_mode+0x134>
111fc7: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
111fc8: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
111fcf: 74 3f je 112010 <rtems_task_mode+0xec>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
111fd1: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 111fd8: 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 ) {
111fdb: 38 47 08 cmp %al,0x8(%edi)
111fde: 74 30 je 112010 <rtems_task_mode+0xec>
asr->is_enabled = is_asr_enabled;
111fe0: 88 47 08 mov %al,0x8(%edi)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
111fe3: 9c pushf 111fe4: fa cli 111fe5: 58 pop %eax
_signals = information->signals_pending;
111fe6: 8b 57 18 mov 0x18(%edi),%edx
information->signals_pending = information->signals_posted;
111fe9: 8b 4f 14 mov 0x14(%edi),%ecx 111fec: 89 4f 18 mov %ecx,0x18(%edi)
information->signals_posted = _signals;
111fef: 89 57 14 mov %edx,0x14(%edi)
_ISR_Enable( _level );
111ff2: 50 push %eax 111ff3: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
111ff4: 8b 47 14 mov 0x14(%edi),%eax 111ff7: 85 c0 test %eax,%eax 111ff9: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
111ffc: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
112003: 74 16 je 11201b <rtems_task_mode+0xf7> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
112005: 31 c0 xor %eax,%eax
}
112007: 83 c4 1c add $0x1c,%esp 11200a: 5b pop %ebx 11200b: 5e pop %esi 11200c: 5f pop %edi 11200d: c9 leave 11200e: c3 ret 11200f: 90 nop
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112010: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112012: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
112019: 75 ea jne 112005 <rtems_task_mode+0xe1> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
11201b: 8b 15 78 67 12 00 mov 0x126778,%edx
if ( are_signals_pending ||
112021: 84 c0 test %al,%al
112023: 75 0e jne 112033 <rtems_task_mode+0x10f>
112025: 3b 15 7c 67 12 00 cmp 0x12677c,%edx
11202b: 74 d8 je 112005 <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
11202d: 80 7a 74 00 cmpb $0x0,0x74(%edx)
112031: 74 d2 je 112005 <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
112033: c6 05 84 67 12 00 01 movb $0x1,0x126784
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
11203a: e8 3d b6 ff ff call 10d67c <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
11203f: 31 c0 xor %eax,%eax
}
112041: 83 c4 1c add $0x1c,%esp 112044: 5b pop %ebx 112045: 5e pop %esi 112046: 5f pop %edi 112047: c9 leave 112048: c3 ret 112049: 8d 76 00 lea 0x0(%esi),%esi
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
11204c: 81 ce 00 02 00 00 or $0x200,%esi 112052: e9 04 ff ff ff jmp 111f5b <rtems_task_mode+0x37> 112057: 90 nop 112058: fb sti 112059: e9 6a ff ff ff jmp 111fc8 <rtems_task_mode+0xa4> 11205e: 66 90 xchg %ax,%ax
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
112060: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112067: f6 45 0c 01 testb $0x1,0xc(%ebp)
11206b: 0f 84 57 ff ff ff je 111fc8 <rtems_task_mode+0xa4>
112071: e9 47 ff ff ff jmp 111fbd <rtems_task_mode+0x99> 112076: 66 90 xchg %ax,%ax
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
112078: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
11207d: 83 c4 1c add $0x1c,%esp 112080: 5b pop %ebx 112081: 5e pop %esi 112082: 5f pop %edi 112083: c9 leave 112084: c3 ret
0010ecdc <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
10ecdc: 55 push %ebp 10ecdd: 89 e5 mov %esp,%ebp 10ecdf: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ece2: 8d 45 f4 lea -0xc(%ebp),%eax 10ece5: 50 push %eax 10ece6: ff 75 08 pushl 0x8(%ebp) 10ece9: e8 62 1e 00 00 call 110b50 <_Thread_Get>
switch ( location ) {
10ecee: 83 c4 10 add $0x10,%esp 10ecf1: 8b 55 f4 mov -0xc(%ebp),%edx 10ecf4: 85 d2 test %edx,%edx
10ecf6: 74 08 je 10ed00 <rtems_task_resume+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ecf8: b8 04 00 00 00 mov $0x4,%eax
}
10ecfd: c9 leave 10ecfe: c3 ret 10ecff: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
10ed00: f6 40 10 02 testb $0x2,0x10(%eax)
10ed04: 75 0e jne 10ed14 <rtems_task_resume+0x38>
_Thread_Resume( the_thread, true );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10ed06: e8 21 1e 00 00 call 110b2c <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10ed0b: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed10: c9 leave 10ed11: c3 ret 10ed12: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread, true );
10ed14: 83 ec 08 sub $0x8,%esp 10ed17: 6a 01 push $0x1 10ed19: 50 push %eax 10ed1a: e8 29 26 00 00 call 111348 <_Thread_Resume>
_Thread_Enable_dispatch();
10ed1f: e8 08 1e 00 00 call 110b2c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ed24: 83 c4 10 add $0x10,%esp 10ed27: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed29: c9 leave 10ed2a: c3 ret
0010d65c <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
10d65c: 55 push %ebp 10d65d: 89 e5 mov %esp,%ebp 10d65f: 56 push %esi 10d660: 53 push %ebx 10d661: 83 ec 10 sub $0x10,%esp 10d664: 8b 45 08 mov 0x8(%ebp),%eax 10d667: 8b 5d 0c mov 0xc(%ebp),%ebx 10d66a: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10d66d: 80 3d e4 62 12 00 00 cmpb $0x0,0x1262e4
10d674: 74 66 je 10d6dc <rtems_task_set_note+0x80>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10d676: 83 fb 0f cmp $0xf,%ebx
10d679: 77 39 ja 10d6b4 <rtems_task_set_note+0x58>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d67b: 85 c0 test %eax,%eax
10d67d: 74 41 je 10d6c0 <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d67f: 8b 15 98 ab 12 00 mov 0x12ab98,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d685: 3b 42 08 cmp 0x8(%edx),%eax
10d688: 74 3c je 10d6c6 <rtems_task_set_note+0x6a>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10d68a: 83 ec 08 sub $0x8,%esp 10d68d: 8d 55 f4 lea -0xc(%ebp),%edx 10d690: 52 push %edx 10d691: 50 push %eax 10d692: e8 c9 1f 00 00 call 10f660 <_Thread_Get>
switch ( location ) {
10d697: 83 c4 10 add $0x10,%esp 10d69a: 8b 55 f4 mov -0xc(%ebp),%edx 10d69d: 85 d2 test %edx,%edx
10d69f: 75 47 jne 10d6e8 <rtems_task_set_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10d6a1: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax 10d6a7: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10d6ab: e8 8c 1f 00 00 call 10f63c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d6b0: 31 c0 xor %eax,%eax 10d6b2: eb 05 jmp 10d6b9 <rtems_task_set_note+0x5d>
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
return RTEMS_INVALID_NUMBER;
10d6b4: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6b9: 8d 65 f8 lea -0x8(%ebp),%esp 10d6bc: 5b pop %ebx 10d6bd: 5e pop %esi 10d6be: c9 leave 10d6bf: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d6c0: 8b 15 98 ab 12 00 mov 0x12ab98,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10d6c6: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax 10d6cc: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
return RTEMS_SUCCESSFUL;
10d6d0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6d2: 8d 65 f8 lea -0x8(%ebp),%esp 10d6d5: 5b pop %ebx 10d6d6: 5e pop %esi 10d6d7: c9 leave 10d6d8: c3 ret 10d6d9: 8d 76 00 lea 0x0(%esi),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10d6dc: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6e1: 8d 65 f8 lea -0x8(%ebp),%esp 10d6e4: 5b pop %ebx 10d6e5: 5e pop %esi 10d6e6: c9 leave 10d6e7: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d6e8: b8 04 00 00 00 mov $0x4,%eax
}
10d6ed: 8d 65 f8 lea -0x8(%ebp),%esp 10d6f0: 5b pop %ebx 10d6f1: 5e pop %esi 10d6f2: c9 leave 10d6f3: c3 ret
0010f9a0 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10f9a0: 55 push %ebp 10f9a1: 89 e5 mov %esp,%ebp 10f9a3: 56 push %esi 10f9a4: 53 push %ebx 10f9a5: 83 ec 10 sub $0x10,%esp 10f9a8: 8b 5d 0c mov 0xc(%ebp),%ebx 10f9ab: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10f9ae: 85 db test %ebx,%ebx
10f9b0: 74 0b je 10f9bd <rtems_task_set_priority+0x1d>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10f9b2: 0f b6 05 14 62 12 00 movzbl 0x126214,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10f9b9: 39 c3 cmp %eax,%ebx
10f9bb: 77 5f ja 10fa1c <rtems_task_set_priority+0x7c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10f9bd: 85 f6 test %esi,%esi
10f9bf: 74 67 je 10fa28 <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10f9c1: 83 ec 08 sub $0x8,%esp 10f9c4: 8d 45 f4 lea -0xc(%ebp),%eax 10f9c7: 50 push %eax 10f9c8: ff 75 08 pushl 0x8(%ebp) 10f9cb: e8 c0 1f 00 00 call 111990 <_Thread_Get>
switch ( location ) {
10f9d0: 83 c4 10 add $0x10,%esp 10f9d3: 8b 55 f4 mov -0xc(%ebp),%edx 10f9d6: 85 d2 test %edx,%edx
10f9d8: 75 36 jne 10fa10 <rtems_task_set_priority+0x70>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10f9da: 8b 50 14 mov 0x14(%eax),%edx 10f9dd: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10f9df: 85 db test %ebx,%ebx
10f9e1: 74 1c je 10f9ff <rtems_task_set_priority+0x5f>
the_thread->real_priority = new_priority;
10f9e3: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10f9e6: 8b 48 1c mov 0x1c(%eax),%ecx 10f9e9: 85 c9 test %ecx,%ecx
10f9eb: 74 05 je 10f9f2 <rtems_task_set_priority+0x52>
10f9ed: 3b 58 14 cmp 0x14(%eax),%ebx
10f9f0: 73 0d jae 10f9ff <rtems_task_set_priority+0x5f><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10f9f2: 52 push %edx 10f9f3: 6a 00 push $0x0 10f9f5: 53 push %ebx 10f9f6: 50 push %eax 10f9f7: e8 bc 1a 00 00 call 1114b8 <_Thread_Change_priority> 10f9fc: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10f9ff: e8 68 1f 00 00 call 11196c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10fa04: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa06: 8d 65 f8 lea -0x8(%ebp),%esp 10fa09: 5b pop %ebx 10fa0a: 5e pop %esi 10fa0b: c9 leave 10fa0c: c3 ret 10fa0d: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10fa10: b8 04 00 00 00 mov $0x4,%eax
}
10fa15: 8d 65 f8 lea -0x8(%ebp),%esp 10fa18: 5b pop %ebx 10fa19: 5e pop %esi 10fa1a: c9 leave 10fa1b: c3 ret
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10fa1c: b8 13 00 00 00 mov $0x13,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa21: 8d 65 f8 lea -0x8(%ebp),%esp 10fa24: 5b pop %ebx 10fa25: 5e pop %esi 10fa26: c9 leave 10fa27: c3 ret
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10fa28: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa2d: 8d 65 f8 lea -0x8(%ebp),%esp 10fa30: 5b pop %ebx 10fa31: 5e pop %esi 10fa32: c9 leave 10fa33: c3 ret
0010baf4 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
10baf4: 55 push %ebp 10baf5: 89 e5 mov %esp,%ebp 10baf7: 53 push %ebx 10baf8: 83 ec 14 sub $0x14,%esp 10bafb: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10bafe: 85 db test %ebx,%ebx
10bb00: 74 4e je 10bb50 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10bb02: 83 ec 08 sub $0x8,%esp 10bb05: 8d 45 f4 lea -0xc(%ebp),%eax 10bb08: 50 push %eax 10bb09: ff 75 08 pushl 0x8(%ebp) 10bb0c: e8 07 1d 00 00 call 10d818 <_Thread_Get>
switch ( location ) {
10bb11: 83 c4 10 add $0x10,%esp 10bb14: 8b 55 f4 mov -0xc(%ebp),%edx 10bb17: 85 d2 test %edx,%edx
10bb19: 75 29 jne 10bb44 <rtems_task_start+0x50>
case OBJECTS_LOCAL:
if ( _Thread_Start(
10bb1b: 83 ec 0c sub $0xc,%esp 10bb1e: ff 75 10 pushl 0x10(%ebp) 10bb21: 6a 00 push $0x0 10bb23: 53 push %ebx 10bb24: 6a 00 push $0x0 10bb26: 50 push %eax 10bb27: e8 a8 26 00 00 call 10e1d4 <_Thread_Start> 10bb2c: 83 c4 20 add $0x20,%esp 10bb2f: 84 c0 test %al,%al
10bb31: 75 29 jne 10bb5c <rtems_task_start+0x68>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10bb33: e8 bc 1c 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10bb38: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb3d: 8b 5d fc mov -0x4(%ebp),%ebx 10bb40: c9 leave 10bb41: c3 ret 10bb42: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb44: b8 04 00 00 00 mov $0x4,%eax
}
10bb49: 8b 5d fc mov -0x4(%ebp),%ebx 10bb4c: c9 leave 10bb4d: c3 ret 10bb4e: 66 90 xchg %ax,%ax
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
10bb50: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb55: 8b 5d fc mov -0x4(%ebp),%ebx 10bb58: c9 leave 10bb59: c3 ret 10bb5a: 66 90 xchg %ax,%ax
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
10bb5c: e8 93 1c 00 00 call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bb61: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb63: 8b 5d fc mov -0x4(%ebp),%ebx 10bb66: c9 leave 10bb67: c3 ret
00110424 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
110424: 55 push %ebp 110425: 89 e5 mov %esp,%ebp 110427: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
11042a: 8d 45 f4 lea -0xc(%ebp),%eax 11042d: 50 push %eax 11042e: ff 75 08 pushl 0x8(%ebp) 110431: e8 e2 d3 ff ff call 10d818 <_Thread_Get>
switch ( location ) {
110436: 83 c4 10 add $0x10,%esp 110439: 8b 55 f4 mov -0xc(%ebp),%edx 11043c: 85 d2 test %edx,%edx
11043e: 74 08 je 110448 <rtems_task_suspend+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
110440: b8 04 00 00 00 mov $0x4,%eax
}
110445: c9 leave 110446: c3 ret 110447: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
110448: f6 40 10 02 testb $0x2,0x10(%eax)
11044c: 74 0e je 11045c <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11044e: e8 a1 d3 ff ff call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
110453: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110458: c9 leave 110459: c3 ret 11045a: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Suspend( the_thread );
11045c: 83 ec 0c sub $0xc,%esp 11045f: 50 push %eax 110460: e8 67 09 00 00 call 110dcc <_Thread_Suspend>
_Thread_Enable_dispatch();
110465: e8 8a d3 ff ff call 10d7f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11046a: 83 c4 10 add $0x10,%esp 11046d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11046f: c9 leave 110470: c3 ret
0010c650 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10c650: 55 push %ebp 10c651: 89 e5 mov %esp,%ebp 10c653: 57 push %edi 10c654: 56 push %esi 10c655: 53 push %ebx 10c656: 83 ec 1c sub $0x1c,%esp 10c659: 8b 5d 0c mov 0xc(%ebp),%ebx 10c65c: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10c65f: 85 db test %ebx,%ebx
10c661: 0f 84 9d 00 00 00 je 10c704 <rtems_task_variable_add+0xb4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10c667: 83 ec 08 sub $0x8,%esp 10c66a: 8d 45 e4 lea -0x1c(%ebp),%eax 10c66d: 50 push %eax 10c66e: ff 75 08 pushl 0x8(%ebp) 10c671: e8 b2 1e 00 00 call 10e528 <_Thread_Get> 10c676: 89 c6 mov %eax,%esi
switch (location) {
10c678: 83 c4 10 add $0x10,%esp 10c67b: 8b 45 e4 mov -0x1c(%ebp),%eax 10c67e: 85 c0 test %eax,%eax
10c680: 74 0e je 10c690 <rtems_task_variable_add+0x40>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c682: b8 04 00 00 00 mov $0x4,%eax
}
10c687: 8d 65 f4 lea -0xc(%ebp),%esp 10c68a: 5b pop %ebx 10c68b: 5e pop %esi 10c68c: 5f pop %edi 10c68d: c9 leave 10c68e: c3 ret 10c68f: 90 nop
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10c690: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax
while (tvp) {
10c696: 85 c0 test %eax,%eax
10c698: 75 44 jne 10c6de <rtems_task_variable_add+0x8e>
10c69a: 66 90 xchg %ax,%ax
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
10c69c: 83 ec 0c sub $0xc,%esp 10c69f: 6a 14 push $0x14 10c6a1: e8 72 2e 00 00 call 10f518 <_Workspace_Allocate>
if (new == NULL) {
10c6a6: 83 c4 10 add $0x10,%esp 10c6a9: 85 c0 test %eax,%eax
10c6ab: 74 4b je 10c6f8 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10c6ad: 8b 13 mov (%ebx),%edx 10c6af: 89 50 08 mov %edx,0x8(%eax)
new->ptr = ptr;
10c6b2: 89 58 04 mov %ebx,0x4(%eax)
new->dtor = dtor;
10c6b5: 89 78 10 mov %edi,0x10(%eax)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10c6b8: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx 10c6be: 89 10 mov %edx,(%eax)
the_thread->task_variables = new;
10c6c0: 89 86 f0 00 00 00 mov %eax,0xf0(%esi)
_Thread_Enable_dispatch();
10c6c6: e8 39 1e 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6cb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6cd: 8d 65 f4 lea -0xc(%ebp),%esp 10c6d0: 5b pop %ebx 10c6d1: 5e pop %esi 10c6d2: 5f pop %edi 10c6d3: c9 leave 10c6d4: c3 ret 10c6d5: 8d 76 00 lea 0x0(%esi),%esi
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10c6d8: 8b 00 mov (%eax),%eax
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
10c6da: 85 c0 test %eax,%eax
10c6dc: 74 be je 10c69c <rtems_task_variable_add+0x4c>
if (tvp->ptr == ptr) {
10c6de: 39 58 04 cmp %ebx,0x4(%eax)
10c6e1: 75 f5 jne 10c6d8 <rtems_task_variable_add+0x88>
tvp->dtor = dtor;
10c6e3: 89 78 10 mov %edi,0x10(%eax)
_Thread_Enable_dispatch();
10c6e6: e8 19 1e 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6eb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6ed: 8d 65 f4 lea -0xc(%ebp),%esp 10c6f0: 5b pop %ebx 10c6f1: 5e pop %esi 10c6f2: 5f pop %edi 10c6f3: c9 leave 10c6f4: c3 ret 10c6f5: 8d 76 00 lea 0x0(%esi),%esi
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
10c6f8: e8 07 1e 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
10c6fd: b8 1a 00 00 00 mov $0x1a,%eax 10c702: eb 83 jmp 10c687 <rtems_task_variable_add+0x37>
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10c704: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c709: 8d 65 f4 lea -0xc(%ebp),%esp 10c70c: 5b pop %ebx 10c70d: 5e pop %esi 10c70e: 5f pop %edi 10c70f: c9 leave 10c710: c3 ret
0010c714 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10c714: 55 push %ebp 10c715: 89 e5 mov %esp,%ebp 10c717: 53 push %ebx 10c718: 83 ec 14 sub $0x14,%esp 10c71b: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10c71e: 85 db test %ebx,%ebx
10c720: 74 76 je 10c798 <rtems_task_variable_delete+0x84>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10c722: 83 ec 08 sub $0x8,%esp 10c725: 8d 45 f4 lea -0xc(%ebp),%eax 10c728: 50 push %eax 10c729: ff 75 08 pushl 0x8(%ebp) 10c72c: e8 f7 1d 00 00 call 10e528 <_Thread_Get>
switch (location) {
10c731: 83 c4 10 add $0x10,%esp 10c734: 8b 55 f4 mov -0xc(%ebp),%edx 10c737: 85 d2 test %edx,%edx
10c739: 74 0d je 10c748 <rtems_task_variable_delete+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c73b: b8 04 00 00 00 mov $0x4,%eax
}
10c740: 8b 5d fc mov -0x4(%ebp),%ebx 10c743: c9 leave 10c744: c3 ret 10c745: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10c748: 8b 88 f0 00 00 00 mov 0xf0(%eax),%ecx
while (tvp) {
10c74e: 85 c9 test %ecx,%ecx
10c750: 74 17 je 10c769 <rtems_task_variable_delete+0x55>
if (tvp->ptr == ptr) {
10c752: 39 59 04 cmp %ebx,0x4(%ecx)
10c755: 75 0c jne 10c763 <rtems_task_variable_delete+0x4f>
10c757: eb 49 jmp 10c7a2 <rtems_task_variable_delete+0x8e> 10c759: 8d 76 00 lea 0x0(%esi),%esi 10c75c: 39 5a 04 cmp %ebx,0x4(%edx)
10c75f: 74 17 je 10c778 <rtems_task_variable_delete+0x64>
10c761: 89 d1 mov %edx,%ecx
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
10c763: 8b 11 mov (%ecx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10c765: 85 d2 test %edx,%edx
10c767: 75 f3 jne 10c75c <rtems_task_variable_delete+0x48><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10c769: e8 96 1d 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10c76e: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c773: 8b 5d fc mov -0x4(%ebp),%ebx 10c776: c9 leave 10c777: c3 ret
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
10c778: 8b 1a mov (%edx),%ebx 10c77a: 89 19 mov %ebx,(%ecx)
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
10c77c: 83 ec 08 sub $0x8,%esp 10c77f: 52 push %edx 10c780: 50 push %eax 10c781: e8 b2 00 00 00 call 10c838 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10c786: e8 79 1d 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c78b: 83 c4 10 add $0x10,%esp 10c78e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c790: 8b 5d fc mov -0x4(%ebp),%ebx 10c793: c9 leave 10c794: c3 ret 10c795: 8d 76 00 lea 0x0(%esi),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10c798: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c79d: 8b 5d fc mov -0x4(%ebp),%ebx 10c7a0: c9 leave 10c7a1: c3 ret
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
10c7a2: 8b 11 mov (%ecx),%edx 10c7a4: 89 90 f0 00 00 00 mov %edx,0xf0(%eax) 10c7aa: 89 ca mov %ecx,%edx 10c7ac: eb ce jmp 10c77c <rtems_task_variable_delete+0x68>
0010c7b0 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10c7b0: 55 push %ebp 10c7b1: 89 e5 mov %esp,%ebp 10c7b3: 56 push %esi 10c7b4: 53 push %ebx 10c7b5: 83 ec 10 sub $0x10,%esp 10c7b8: 8b 5d 0c mov 0xc(%ebp),%ebx 10c7bb: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10c7be: 85 db test %ebx,%ebx
10c7c0: 74 56 je 10c818 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10c7c2: 85 f6 test %esi,%esi
10c7c4: 74 52 je 10c818 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10c7c6: 83 ec 08 sub $0x8,%esp 10c7c9: 8d 45 f4 lea -0xc(%ebp),%eax 10c7cc: 50 push %eax 10c7cd: ff 75 08 pushl 0x8(%ebp) 10c7d0: e8 53 1d 00 00 call 10e528 <_Thread_Get>
switch (location) {
10c7d5: 83 c4 10 add $0x10,%esp 10c7d8: 8b 55 f4 mov -0xc(%ebp),%edx 10c7db: 85 d2 test %edx,%edx
10c7dd: 75 2d jne 10c80c <rtems_task_variable_get+0x5c>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10c7df: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax
while (tvp) {
10c7e5: 85 c0 test %eax,%eax
10c7e7: 75 09 jne 10c7f2 <rtems_task_variable_get+0x42>
10c7e9: eb 39 jmp 10c824 <rtems_task_variable_get+0x74> 10c7eb: 90 nop
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10c7ec: 8b 00 mov (%eax),%eax
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
10c7ee: 85 c0 test %eax,%eax
10c7f0: 74 32 je 10c824 <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10c7f2: 39 58 04 cmp %ebx,0x4(%eax)
10c7f5: 75 f5 jne 10c7ec <rtems_task_variable_get+0x3c>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
10c7f7: 8b 40 0c mov 0xc(%eax),%eax 10c7fa: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c7fc: e8 03 1d 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c801: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c803: 8d 65 f8 lea -0x8(%ebp),%esp 10c806: 5b pop %ebx 10c807: 5e pop %esi 10c808: c9 leave 10c809: c3 ret 10c80a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c80c: b8 04 00 00 00 mov $0x4,%eax
}
10c811: 8d 65 f8 lea -0x8(%ebp),%esp 10c814: 5b pop %ebx 10c815: 5e pop %esi 10c816: c9 leave 10c817: c3 ret
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
10c818: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c81d: 8d 65 f8 lea -0x8(%ebp),%esp 10c820: 5b pop %ebx 10c821: 5e pop %esi 10c822: c9 leave 10c823: c3 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10c824: e8 db 1c 00 00 call 10e504 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10c829: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c82e: 8d 65 f8 lea -0x8(%ebp),%esp 10c831: 5b pop %ebx 10c832: 5e pop %esi 10c833: c9 leave 10c834: c3 ret
0010c9cc <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10c9cc: 55 push %ebp 10c9cd: 89 e5 mov %esp,%ebp 10c9cf: 53 push %ebx 10c9d0: 83 ec 14 sub $0x14,%esp 10c9d3: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10c9d6: 80 3d 84 85 12 00 00 cmpb $0x0,0x128584
10c9dd: 0f 84 a9 00 00 00 je 10ca8c <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10c9e3: 85 db test %ebx,%ebx
10c9e5: 0f 84 ad 00 00 00 je 10ca98 <rtems_task_wake_when+0xcc>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10c9eb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10c9f2: 83 ec 0c sub $0xc,%esp 10c9f5: 53 push %ebx 10c9f6: e8 c5 f3 ff ff call 10bdc0 <_TOD_Validate> 10c9fb: 83 c4 10 add $0x10,%esp 10c9fe: 84 c0 test %al,%al
10ca00: 75 0a jne 10ca0c <rtems_task_wake_when+0x40>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
10ca02: b8 14 00 00 00 mov $0x14,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca07: 8b 5d fc mov -0x4(%ebp),%ebx 10ca0a: c9 leave 10ca0b: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10ca0c: 83 ec 0c sub $0xc,%esp 10ca0f: 53 push %ebx 10ca10: e8 1f f3 ff ff call 10bd34 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
10ca15: 83 c4 10 add $0x10,%esp 10ca18: 3b 05 44 86 12 00 cmp 0x128644,%eax
10ca1e: 76 e2 jbe 10ca02 <rtems_task_wake_when+0x36>
10ca20: 8b 15 70 85 12 00 mov 0x128570,%edx 10ca26: 42 inc %edx 10ca27: 89 15 70 85 12 00 mov %edx,0x128570
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10ca2d: 83 ec 08 sub $0x8,%esp 10ca30: 6a 10 push $0x10 10ca32: ff 35 38 88 12 00 pushl 0x128838 10ca38: 89 45 f4 mov %eax,-0xc(%ebp) 10ca3b: e8 44 25 00 00 call 10ef84 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
10ca40: 8b 15 38 88 12 00 mov 0x128838,%edx
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
10ca46: 8b 4a 08 mov 0x8(%edx),%ecx
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10ca49: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
10ca50: c7 42 64 90 e5 10 00 movl $0x10e590,0x64(%edx)
the_watchdog->id = id;
10ca57: 89 4a 68 mov %ecx,0x68(%edx)
the_watchdog->user_data = user_data;
10ca5a: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx)
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
10ca61: 8b 45 f4 mov -0xc(%ebp),%eax 10ca64: 2b 05 44 86 12 00 sub 0x128644,%eax 10ca6a: 89 42 54 mov %eax,0x54(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
10ca6d: 58 pop %eax 10ca6e: 59 pop %ecx 10ca6f: 83 c2 48 add $0x48,%edx 10ca72: 52 push %edx 10ca73: 68 70 86 12 00 push $0x128670 10ca78: e8 eb 2a 00 00 call 10f568 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
10ca7d: e8 c2 1c 00 00 call 10e744 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca82: 83 c4 10 add $0x10,%esp 10ca85: 31 c0 xor %eax,%eax 10ca87: e9 7b ff ff ff jmp 10ca07 <rtems_task_wake_when+0x3b>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
10ca8c: b8 0b 00 00 00 mov $0xb,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca91: 8b 5d fc mov -0x4(%ebp),%ebx 10ca94: c9 leave 10ca95: c3 ret 10ca96: 66 90 xchg %ax,%ax
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10ca98: b8 09 00 00 00 mov $0x9,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca9d: 8b 5d fc mov -0x4(%ebp),%ebx 10caa0: c9 leave 10caa1: c3 ret
001186e0 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1186e0: 55 push %ebp 1186e1: 89 e5 mov %esp,%ebp 1186e3: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1186e6: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1186e9: 50 push %eax 1186ea: ff 75 08 pushl 0x8(%ebp) 1186ed: 68 80 0c 14 00 push $0x140c80 1186f2: e8 b5 2a 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
1186f7: 83 c4 10 add $0x10,%esp 1186fa: 8b 55 f4 mov -0xc(%ebp),%edx 1186fd: 85 d2 test %edx,%edx
1186ff: 74 07 je 118708 <rtems_timer_cancel+0x28>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118701: b8 04 00 00 00 mov $0x4,%eax
}
118706: c9 leave 118707: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
118708: 83 78 38 04 cmpl $0x4,0x38(%eax)
11870c: 74 0f je 11871d <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
11870e: 83 ec 0c sub $0xc,%esp 118711: 83 c0 10 add $0x10,%eax 118714: 50 push %eax 118715: e8 9a 46 00 00 call 11cdb4 <_Watchdog_Remove> 11871a: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
11871d: e8 12 35 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118722: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118724: c9 leave 118725: c3 ret
0010bffc <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
10bffc: 55 push %ebp 10bffd: 89 e5 mov %esp,%ebp 10bfff: 57 push %edi 10c000: 56 push %esi 10c001: 53 push %ebx 10c002: 83 ec 0c sub $0xc,%esp 10c005: 8b 5d 08 mov 0x8(%ebp),%ebx 10c008: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10c00b: 85 db test %ebx,%ebx
10c00d: 74 6d je 10c07c <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10c00f: 85 f6 test %esi,%esi
10c011: 0f 84 89 00 00 00 je 10c0a0 <rtems_timer_create+0xa4>
10c017: a1 10 75 12 00 mov 0x127510,%eax 10c01c: 40 inc %eax 10c01d: a3 10 75 12 00 mov %eax,0x127510
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
10c022: 83 ec 0c sub $0xc,%esp 10c025: 68 a0 78 12 00 push $0x1278a0 10c02a: e8 55 0e 00 00 call 10ce84 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10c02f: 83 c4 10 add $0x10,%esp 10c032: 85 c0 test %eax,%eax
10c034: 74 56 je 10c08c <rtems_timer_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10c036: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c03d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c044: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10c04b: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10c052: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c059: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c05c: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c05f: 8b 0d bc 78 12 00 mov 0x1278bc,%ecx 10c065: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c068: 89 58 0c mov %ebx,0xc(%eax)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10c06b: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10c06d: e8 52 1d 00 00 call 10ddc4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c072: 31 c0 xor %eax,%eax
}
10c074: 8d 65 f4 lea -0xc(%ebp),%esp 10c077: 5b pop %ebx 10c078: 5e pop %esi 10c079: 5f pop %edi 10c07a: c9 leave 10c07b: c3 ret
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c07c: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c081: 8d 65 f4 lea -0xc(%ebp),%esp 10c084: 5b pop %ebx 10c085: 5e pop %esi 10c086: 5f pop %edi 10c087: c9 leave 10c088: c3 ret 10c089: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
10c08c: e8 33 1d 00 00 call 10ddc4 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c091: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c096: 8d 65 f4 lea -0xc(%ebp),%esp 10c099: 5b pop %ebx 10c09a: 5e pop %esi 10c09b: 5f pop %edi 10c09c: c9 leave 10c09d: c3 ret 10c09e: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c0a0: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c0a5: 8d 65 f4 lea -0xc(%ebp),%esp 10c0a8: 5b pop %ebx 10c0a9: 5e pop %esi 10c0aa: 5f pop %edi 10c0ab: c9 leave 10c0ac: c3 ret
001187dc <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
rtems_id id
)
{
1187dc: 55 push %ebp 1187dd: 89 e5 mov %esp,%ebp 1187df: 53 push %ebx 1187e0: 83 ec 18 sub $0x18,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1187e3: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1187e6: 50 push %eax 1187e7: ff 75 08 pushl 0x8(%ebp) 1187ea: 68 80 0c 14 00 push $0x140c80 1187ef: e8 b8 29 00 00 call 11b1ac <_Objects_Get> 1187f4: 89 c3 mov %eax,%ebx
switch ( location ) {
1187f6: 83 c4 10 add $0x10,%esp 1187f9: 8b 4d f4 mov -0xc(%ebp),%ecx 1187fc: 85 c9 test %ecx,%ecx
1187fe: 75 38 jne 118838 <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
118800: 83 ec 08 sub $0x8,%esp 118803: 50 push %eax 118804: 68 80 0c 14 00 push $0x140c80 118809: e8 26 25 00 00 call 11ad34 <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
11880e: 8d 43 10 lea 0x10(%ebx),%eax 118811: 89 04 24 mov %eax,(%esp) 118814: e8 9b 45 00 00 call 11cdb4 <_Watchdog_Remove>
*/
RTEMS_INLINE_ROUTINE void _Timer_Free (
Timer_Control *the_timer
)
{
_Objects_Free( &_Timer_Information, &the_timer->Object );
118819: 58 pop %eax 11881a: 5a pop %edx 11881b: 53 push %ebx 11881c: 68 80 0c 14 00 push $0x140c80 118821: e8 0a 28 00 00 call 11b030 <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
118826: e8 09 34 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11882b: 83 c4 10 add $0x10,%esp 11882e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118830: 8b 5d fc mov -0x4(%ebp),%ebx 118833: c9 leave 118834: c3 ret 118835: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118838: b8 04 00 00 00 mov $0x4,%eax
}
11883d: 8b 5d fc mov -0x4(%ebp),%ebx 118840: c9 leave 118841: c3 ret
0010c0b0 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10c0b0: 55 push %ebp 10c0b1: 89 e5 mov %esp,%ebp 10c0b3: 57 push %edi 10c0b4: 56 push %esi 10c0b5: 53 push %ebx 10c0b6: 83 ec 2c sub $0x2c,%esp 10c0b9: 8b 5d 0c mov 0xc(%ebp),%ebx 10c0bc: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10c0bf: 85 db test %ebx,%ebx
10c0c1: 0f 84 99 00 00 00 je 10c160 <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10c0c7: 85 f6 test %esi,%esi
10c0c9: 0f 84 b1 00 00 00 je 10c180 <rtems_timer_fire_after+0xd0>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
10c0cf: 57 push %edi
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
10c0d0: 8d 45 e4 lea -0x1c(%ebp),%eax 10c0d3: 50 push %eax 10c0d4: ff 75 08 pushl 0x8(%ebp) 10c0d7: 68 a0 78 12 00 push $0x1278a0 10c0dc: e8 5b 12 00 00 call 10d33c <_Objects_Get> 10c0e1: 89 c7 mov %eax,%edi
switch ( location ) {
10c0e3: 83 c4 10 add $0x10,%esp 10c0e6: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c0e9: 85 c9 test %ecx,%ecx
10c0eb: 74 0f je 10c0fc <rtems_timer_fire_after+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c0ed: b8 04 00 00 00 mov $0x4,%eax
}
10c0f2: 8d 65 f4 lea -0xc(%ebp),%esp 10c0f5: 5b pop %ebx 10c0f6: 5e pop %esi 10c0f7: 5f pop %edi 10c0f8: c9 leave 10c0f9: c3 ret 10c0fa: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10c0fc: 8d 50 10 lea 0x10(%eax),%edx 10c0ff: 83 ec 0c sub $0xc,%esp 10c102: 52 push %edx 10c103: 89 55 d4 mov %edx,-0x2c(%ebp) 10c106: e8 a5 2b 00 00 call 10ecb0 <_Watchdog_Remove>
_ISR_Disable( level );
10c10b: 9c pushf 10c10c: fa cli 10c10d: 58 pop %eax
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
10c10e: 83 c4 10 add $0x10,%esp 10c111: 8b 57 18 mov 0x18(%edi),%edx 10c114: 85 d2 test %edx,%edx 10c116: 8b 55 d4 mov -0x2c(%ebp),%edx
10c119: 75 55 jne 10c170 <rtems_timer_fire_after+0xc0>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL;
10c11b: c7 47 38 00 00 00 00 movl $0x0,0x38(%edi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c122: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10c129: 89 77 2c mov %esi,0x2c(%edi)
the_watchdog->id = id;
10c12c: 8b 4d 08 mov 0x8(%ebp),%ecx 10c12f: 89 4f 30 mov %ecx,0x30(%edi)
the_watchdog->user_data = user_data;
10c132: 8b 4d 14 mov 0x14(%ebp),%ecx 10c135: 89 4f 34 mov %ecx,0x34(%edi)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10c138: 50 push %eax 10c139: 9d popf
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c13a: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c13d: 83 ec 08 sub $0x8,%esp 10c140: 52 push %edx 10c141: 68 1c 76 12 00 push $0x12761c 10c146: e8 25 2a 00 00 call 10eb70 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10c14b: e8 74 1c 00 00 call 10ddc4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c150: 83 c4 10 add $0x10,%esp 10c153: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c155: 8d 65 f4 lea -0xc(%ebp),%esp 10c158: 5b pop %ebx 10c159: 5e pop %esi 10c15a: 5f pop %edi 10c15b: c9 leave 10c15c: c3 ret 10c15d: 8d 76 00 lea 0x0(%esi),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
10c160: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c165: 8d 65 f4 lea -0xc(%ebp),%esp 10c168: 5b pop %ebx 10c169: 5e pop %esi 10c16a: 5f pop %edi 10c16b: c9 leave 10c16c: c3 ret 10c16d: 8d 76 00 lea 0x0(%esi),%esi
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
10c170: 50 push %eax 10c171: 9d popf
_Thread_Enable_dispatch();
10c172: e8 4d 1c 00 00 call 10ddc4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c177: 31 c0 xor %eax,%eax 10c179: e9 74 ff ff ff jmp 10c0f2 <rtems_timer_fire_after+0x42> 10c17e: 66 90 xchg %ax,%ax
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
10c180: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c185: 8d 65 f4 lea -0xc(%ebp),%esp 10c188: 5b pop %ebx 10c189: 5e pop %esi 10c18a: 5f pop %edi 10c18b: c9 leave 10c18c: c3 ret
00118924 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118924: 55 push %ebp 118925: 89 e5 mov %esp,%ebp 118927: 57 push %edi 118928: 56 push %esi 118929: 53 push %ebx 11892a: 83 ec 2c sub $0x2c,%esp 11892d: 8b 75 08 mov 0x8(%ebp),%esi 118930: 8b 7d 0c mov 0xc(%ebp),%edi 118933: 8b 5d 10 mov 0x10(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
118936: 80 3d 04 09 14 00 00 cmpb $0x0,0x140904
11893d: 75 0d jne 11894c <rtems_timer_fire_when+0x28>
return RTEMS_NOT_DEFINED;
11893f: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118944: 8d 65 f4 lea -0xc(%ebp),%esp 118947: 5b pop %ebx 118948: 5e pop %esi 118949: 5f pop %edi 11894a: c9 leave 11894b: c3 ret
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
11894c: 83 ec 0c sub $0xc,%esp 11894f: 57 push %edi 118950: e8 87 d4 ff ff call 115ddc <_TOD_Validate> 118955: 83 c4 10 add $0x10,%esp 118958: 84 c0 test %al,%al
11895a: 74 1e je 11897a <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
11895c: 85 db test %ebx,%ebx
11895e: 0f 84 a4 00 00 00 je 118a08 <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
118964: 83 ec 0c sub $0xc,%esp 118967: 57 push %edi 118968: e8 e3 d3 ff ff call 115d50 <_TOD_To_seconds> 11896d: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11896f: 83 c4 10 add $0x10,%esp 118972: 3b 05 c4 09 14 00 cmp 0x1409c4,%eax
118978: 77 0e ja 118988 <rtems_timer_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
11897a: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11897f: 8d 65 f4 lea -0xc(%ebp),%esp 118982: 5b pop %ebx 118983: 5e pop %esi 118984: 5f pop %edi 118985: c9 leave 118986: c3 ret 118987: 90 nop 118988: 50 push %eax
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
118989: 8d 45 e4 lea -0x1c(%ebp),%eax 11898c: 50 push %eax 11898d: 56 push %esi 11898e: 68 80 0c 14 00 push $0x140c80 118993: e8 14 28 00 00 call 11b1ac <_Objects_Get>
switch ( location ) {
118998: 83 c4 10 add $0x10,%esp 11899b: 8b 4d e4 mov -0x1c(%ebp),%ecx 11899e: 85 c9 test %ecx,%ecx
1189a0: 75 5a jne 1189fc <rtems_timer_fire_when+0xd8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1189a2: 8d 48 10 lea 0x10(%eax),%ecx 1189a5: 83 ec 0c sub $0xc,%esp 1189a8: 51 push %ecx 1189a9: 89 45 d0 mov %eax,-0x30(%ebp) 1189ac: 89 4d d4 mov %ecx,-0x2c(%ebp) 1189af: e8 00 44 00 00 call 11cdb4 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
1189b4: 8b 55 d0 mov -0x30(%ebp),%edx 1189b7: c7 42 38 02 00 00 00 movl $0x2,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1189be: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1189c5: 89 5a 2c mov %ebx,0x2c(%edx)
the_watchdog->id = id;
1189c8: 89 72 30 mov %esi,0x30(%edx)
the_watchdog->user_data = user_data;
1189cb: 8b 45 14 mov 0x14(%ebp),%eax 1189ce: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
1189d1: 2b 3d c4 09 14 00 sub 0x1409c4,%edi 1189d7: 89 7a 1c mov %edi,0x1c(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
1189da: 58 pop %eax 1189db: 5a pop %edx 1189dc: 8b 4d d4 mov -0x2c(%ebp),%ecx 1189df: 51 push %ecx 1189e0: 68 f0 09 14 00 push $0x1409f0 1189e5: e8 8a 42 00 00 call 11cc74 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
1189ea: e8 45 32 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1189ef: 83 c4 10 add $0x10,%esp 1189f2: 31 c0 xor %eax,%eax 1189f4: e9 4b ff ff ff jmp 118944 <rtems_timer_fire_when+0x20> 1189f9: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1189fc: b8 04 00 00 00 mov $0x4,%eax 118a01: e9 3e ff ff ff jmp 118944 <rtems_timer_fire_when+0x20> 118a06: 66 90 xchg %ax,%ax
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118a08: b8 09 00 00 00 mov $0x9,%eax 118a0d: e9 32 ff ff ff jmp 118944 <rtems_timer_fire_when+0x20>
001190bc <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
1190bc: 55 push %ebp 1190bd: 89 e5 mov %esp,%ebp 1190bf: 56 push %esi 1190c0: 53 push %ebx 1190c1: 83 ec 10 sub $0x10,%esp 1190c4: 8b 45 08 mov 0x8(%ebp),%eax 1190c7: 85 c0 test %eax,%eax
1190c9: 74 41 je 11910c <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1190cb: 0f b6 15 14 82 13 00 movzbl 0x138214,%edx
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
1190d2: 39 d0 cmp %edx,%eax
1190d4: 76 42 jbe 119118 <rtems_timer_initiate_server+0x5c>
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
1190d6: 40 inc %eax
1190d7: 75 33 jne 11910c <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1190d9: 31 f6 xor %esi,%esi 1190db: 8b 15 f0 08 14 00 mov 0x1408f0,%edx 1190e1: 42 inc %edx 1190e2: 89 15 f0 08 14 00 mov %edx,0x1408f0
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1190e8: 8a 1d 20 c2 13 00 mov 0x13c220,%bl
initialized = true;
1190ee: c6 05 20 c2 13 00 01 movb $0x1,0x13c220
_Thread_Enable_dispatch();
1190f5: e8 3a 2b 00 00 call 11bc34 <_Thread_Enable_dispatch>
if ( tmpInitialized )
1190fa: 84 db test %bl,%bl
1190fc: 74 1e je 11911c <rtems_timer_initiate_server+0x60>
return RTEMS_INCORRECT_STATE;
1190fe: b8 0e 00 00 00 mov $0xe,%eax
initialized = false;
}
#endif
return status;
}
119103: 8d 65 f8 lea -0x8(%ebp),%esp 119106: 5b pop %ebx 119107: 5e pop %esi 119108: c9 leave 119109: c3 ret 11910a: 66 90 xchg %ax,%ax
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
return RTEMS_INVALID_PRIORITY;
11910c: b8 13 00 00 00 mov $0x13,%eax
initialized = false;
}
#endif
return status;
}
119111: 8d 65 f8 lea -0x8(%ebp),%esp 119114: 5b pop %ebx 119115: 5e pop %esi 119116: c9 leave 119117: c3 ret 119118: 89 c6 mov %eax,%esi 11911a: eb bf jmp 1190db <rtems_timer_initiate_server+0x1f>
* other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create(
11911c: 83 ec 08 sub $0x8,%esp 11911f: 8d 45 f4 lea -0xc(%ebp),%eax 119122: 50 push %eax 119123: 8b 45 10 mov 0x10(%ebp),%eax 119126: 80 cc 80 or $0x80,%ah 119129: 50 push %eax 11912a: 68 00 01 00 00 push $0x100 11912f: ff 75 0c pushl 0xc(%ebp) 119132: 56 push %esi 119133: 68 45 4d 49 54 push $0x54494d45 119138: e8 bb ec ff ff call 117df8 <rtems_task_create>
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
11913d: 83 c4 20 add $0x20,%esp 119140: 85 c0 test %eax,%eax
119142: 74 10 je 119154 <rtems_timer_initiate_server+0x98>
initialized = false;
119144: c6 05 20 c2 13 00 00 movb $0x0,0x13c220
initialized = false;
}
#endif
return status;
}
11914b: 8d 65 f8 lea -0x8(%ebp),%esp 11914e: 5b pop %ebx 11914f: 5e pop %esi 119150: c9 leave 119151: c3 ret 119152: 66 90 xchg %ax,%ax
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
&_RTEMS_tasks_Information,
_Objects_Get_index(id)
119154: 8b 45 f4 mov -0xc(%ebp),%eax
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
119157: 0f b7 c8 movzwl %ax,%ecx 11915a: 8b 15 9c 08 14 00 mov 0x14089c,%edx
/*
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
119160: 8b 14 8a mov (%edx,%ecx,4),%edx 119163: 89 15 a0 c1 13 00 mov %edx,0x13c1a0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
119169: c7 05 d0 c1 13 00 d4 movl $0x13c1d4,0x13c1d0
119170: c1 13 00 head->previous = NULL;
119173: c7 05 d4 c1 13 00 00 movl $0x0,0x13c1d4
11917a: 00 00 00 tail->previous = head;
11917d: c7 05 d8 c1 13 00 d0 movl $0x13c1d0,0x13c1d8
119184: c1 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
119187: c7 05 08 c2 13 00 0c movl $0x13c20c,0x13c208
11918e: c2 13 00 head->previous = NULL;
119191: c7 05 0c c2 13 00 00 movl $0x0,0x13c20c
119198: 00 00 00 tail->previous = head;
11919b: c7 05 10 c2 13 00 08 movl $0x13c208,0x13c210
1191a2: c2 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191a5: c7 05 b0 c1 13 00 00 movl $0x0,0x13c1b0
1191ac: 00 00 00 the_watchdog->routine = routine;
1191af: c7 05 c4 c1 13 00 80 movl $0x11ba80,0x13c1c4
1191b6: ba 11 00 the_watchdog->id = id;
1191b9: a3 c8 c1 13 00 mov %eax,0x13c1c8
the_watchdog->user_data = user_data;
1191be: c7 05 cc c1 13 00 00 movl $0x0,0x13c1cc
1191c5: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191c8: c7 05 e8 c1 13 00 00 movl $0x0,0x13c1e8
1191cf: 00 00 00 the_watchdog->routine = routine;
1191d2: c7 05 fc c1 13 00 80 movl $0x11ba80,0x13c1fc
1191d9: ba 11 00 the_watchdog->id = id;
1191dc: a3 00 c2 13 00 mov %eax,0x13c200
the_watchdog->user_data = user_data;
1191e1: c7 05 04 c2 13 00 00 movl $0x0,0x13c204
1191e8: 00 00 00
/*
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
1191eb: c7 05 a4 c1 13 00 8c movl $0x118f8c,0x13c1a4
1191f2: 8f 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1191f5: 8b 15 64 0a 14 00 mov 0x140a64,%edx 1191fb: 89 15 dc c1 13 00 mov %edx,0x13c1dc
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
119201: 8b 15 c4 09 14 00 mov 0x1409c4,%edx 119207: 89 15 14 c2 13 00 mov %edx,0x13c214
ts->insert_chain = NULL;
11920d: c7 05 18 c2 13 00 00 movl $0x0,0x13c218
119214: 00 00 00 ts->active = false;
119217: c6 05 1c c2 13 00 00 movb $0x0,0x13c21c
/*
* The default timer server is now available.
*/
_Timer_server = ts;
11921e: c7 05 c0 0c 14 00 a0 movl $0x13c1a0,0x140cc0
119225: c1 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
119228: 53 push %ebx 119229: 68 a0 c1 13 00 push $0x13c1a0 11922e: 68 c4 8d 11 00 push $0x118dc4 119233: 50 push %eax 119234: e8 7f f2 ff ff call 1184b8 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
119239: 83 c4 10 add $0x10,%esp 11923c: e9 d0 fe ff ff jmp 119111 <rtems_timer_initiate_server+0x55>
00118a9c <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
118a9c: 55 push %ebp 118a9d: 89 e5 mov %esp,%ebp 118a9f: 56 push %esi 118aa0: 53 push %ebx 118aa1: 83 ec 24 sub $0x24,%esp
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
118aa4: 8d 45 f4 lea -0xc(%ebp),%eax 118aa7: 50 push %eax 118aa8: ff 75 08 pushl 0x8(%ebp) 118aab: 68 80 0c 14 00 push $0x140c80 118ab0: e8 f7 26 00 00 call 11b1ac <_Objects_Get> 118ab5: 89 c3 mov %eax,%ebx
switch ( location ) {
118ab7: 83 c4 10 add $0x10,%esp 118aba: 8b 45 f4 mov -0xc(%ebp),%eax 118abd: 85 c0 test %eax,%eax
118abf: 74 0f je 118ad0 <rtems_timer_reset+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118ac1: b8 04 00 00 00 mov $0x4,%eax
}
118ac6: 8d 65 f8 lea -0x8(%ebp),%esp 118ac9: 5b pop %ebx 118aca: 5e pop %esi 118acb: c9 leave 118acc: c3 ret 118acd: 8d 76 00 lea 0x0(%esi),%esi
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
118ad0: 8b 43 38 mov 0x38(%ebx),%eax 118ad3: 85 c0 test %eax,%eax
118ad5: 74 1d je 118af4 <rtems_timer_reset+0x58>
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118ad7: 48 dec %eax
118ad8: 74 3a je 118b14 <rtems_timer_reset+0x78>
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
118ada: b8 0b 00 00 00 mov $0xb,%eax
}
_Thread_Enable_dispatch();
118adf: 89 45 e4 mov %eax,-0x1c(%ebp) 118ae2: e8 4d 31 00 00 call 11bc34 <_Thread_Enable_dispatch>
return status;
118ae7: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118aea: 8d 65 f8 lea -0x8(%ebp),%esp 118aed: 5b pop %ebx 118aee: 5e pop %esi 118aef: c9 leave 118af0: c3 ret 118af1: 8d 76 00 lea 0x0(%esi),%esi
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
118af4: 83 c3 10 add $0x10,%ebx 118af7: 83 ec 0c sub $0xc,%esp 118afa: 53 push %ebx 118afb: e8 b4 42 00 00 call 11cdb4 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
118b00: 59 pop %ecx 118b01: 5e pop %esi 118b02: 53 push %ebx 118b03: 68 fc 09 14 00 push $0x1409fc 118b08: e8 67 41 00 00 call 11cc74 <_Watchdog_Insert> 118b0d: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b10: 31 c0 xor %eax,%eax 118b12: eb cb jmp 118adf <rtems_timer_reset+0x43>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
118b14: 8b 35 c0 0c 14 00 mov 0x140cc0,%esi
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
118b1a: 83 ec 0c sub $0xc,%esp 118b1d: 8d 43 10 lea 0x10(%ebx),%eax 118b20: 50 push %eax 118b21: e8 8e 42 00 00 call 11cdb4 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
118b26: 58 pop %eax 118b27: 5a pop %edx 118b28: 53 push %ebx 118b29: 56 push %esi 118b2a: ff 56 04 call *0x4(%esi) 118b2d: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b30: 31 c0 xor %eax,%eax 118b32: eb ab jmp 118adf <rtems_timer_reset+0x43>
00118b34 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118b34: 55 push %ebp 118b35: 89 e5 mov %esp,%ebp 118b37: 57 push %edi 118b38: 56 push %esi 118b39: 53 push %ebx 118b3a: 83 ec 2c sub $0x2c,%esp 118b3d: 8b 7d 0c mov 0xc(%ebp),%edi 118b40: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
118b43: 8b 1d c0 0c 14 00 mov 0x140cc0,%ebx
if ( !timer_server )
118b49: 85 db test %ebx,%ebx
118b4b: 0f 84 9f 00 00 00 je 118bf0 <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
118b51: 85 f6 test %esi,%esi
118b53: 0f 84 a3 00 00 00 je 118bfc <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118b59: 85 ff test %edi,%edi
118b5b: 75 0f jne 118b6c <rtems_timer_server_fire_after+0x38>
return RTEMS_INVALID_NUMBER;
118b5d: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118b62: 8d 65 f4 lea -0xc(%ebp),%esp 118b65: 5b pop %ebx 118b66: 5e pop %esi 118b67: 5f pop %edi 118b68: c9 leave 118b69: c3 ret 118b6a: 66 90 xchg %ax,%ax 118b6c: 52 push %edx
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
118b6d: 8d 45 e4 lea -0x1c(%ebp),%eax 118b70: 50 push %eax 118b71: ff 75 08 pushl 0x8(%ebp) 118b74: 68 80 0c 14 00 push $0x140c80 118b79: e8 2e 26 00 00 call 11b1ac <_Objects_Get> 118b7e: 89 c2 mov %eax,%edx
switch ( location ) {
118b80: 83 c4 10 add $0x10,%esp 118b83: 8b 45 e4 mov -0x1c(%ebp),%eax 118b86: 85 c0 test %eax,%eax
118b88: 75 56 jne 118be0 <rtems_timer_server_fire_after+0xac>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118b8a: 83 ec 0c sub $0xc,%esp 118b8d: 8d 42 10 lea 0x10(%edx),%eax 118b90: 50 push %eax 118b91: 89 55 d4 mov %edx,-0x2c(%ebp) 118b94: e8 1b 42 00 00 call 11cdb4 <_Watchdog_Remove>
_ISR_Disable( level );
118b99: 9c pushf 118b9a: fa cli 118b9b: 58 pop %eax
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
118b9c: 83 c4 10 add $0x10,%esp 118b9f: 8b 55 d4 mov -0x2c(%ebp),%edx 118ba2: 8b 4a 18 mov 0x18(%edx),%ecx 118ba5: 85 c9 test %ecx,%ecx
118ba7: 75 5f jne 118c08 <rtems_timer_server_fire_after+0xd4>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
118ba9: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
118bb0: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118bb7: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118bba: 8b 4d 08 mov 0x8(%ebp),%ecx 118bbd: 89 4a 30 mov %ecx,0x30(%edx)
the_watchdog->user_data = user_data;
118bc0: 8b 4d 14 mov 0x14(%ebp),%ecx 118bc3: 89 4a 34 mov %ecx,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
118bc6: 89 7a 1c mov %edi,0x1c(%edx)
_ISR_Enable( level );
118bc9: 50 push %eax 118bca: 9d popf
(*timer_server->schedule_operation)( timer_server, the_timer );
118bcb: 83 ec 08 sub $0x8,%esp 118bce: 52 push %edx 118bcf: 53 push %ebx 118bd0: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118bd3: e8 5c 30 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118bd8: 83 c4 10 add $0x10,%esp 118bdb: 31 c0 xor %eax,%eax 118bdd: eb 83 jmp 118b62 <rtems_timer_server_fire_after+0x2e> 118bdf: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118be0: b8 04 00 00 00 mov $0x4,%eax
}
118be5: 8d 65 f4 lea -0xc(%ebp),%esp 118be8: 5b pop %ebx 118be9: 5e pop %esi 118bea: 5f pop %edi 118beb: c9 leave 118bec: c3 ret 118bed: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
118bf0: b8 0e 00 00 00 mov $0xe,%eax 118bf5: e9 68 ff ff ff jmp 118b62 <rtems_timer_server_fire_after+0x2e> 118bfa: 66 90 xchg %ax,%ax
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118bfc: b8 09 00 00 00 mov $0x9,%eax 118c01: e9 5c ff ff ff jmp 118b62 <rtems_timer_server_fire_after+0x2e> 118c06: 66 90 xchg %ax,%ax
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
118c08: 50 push %eax 118c09: 9d popf
_Thread_Enable_dispatch();
118c0a: e8 25 30 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118c0f: 31 c0 xor %eax,%eax 118c11: e9 4c ff ff ff jmp 118b62 <rtems_timer_server_fire_after+0x2e>
00118c18 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118c18: 55 push %ebp 118c19: 89 e5 mov %esp,%ebp 118c1b: 57 push %edi 118c1c: 56 push %esi 118c1d: 53 push %ebx 118c1e: 83 ec 2c sub $0x2c,%esp 118c21: 8b 7d 0c mov 0xc(%ebp),%edi 118c24: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
118c27: 8b 1d c0 0c 14 00 mov 0x140cc0,%ebx
if ( !timer_server )
118c2d: 85 db test %ebx,%ebx
118c2f: 0f 84 d7 00 00 00 je 118d0c <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118c35: 80 3d 04 09 14 00 00 cmpb $0x0,0x140904
118c3c: 0f 84 aa 00 00 00 je 118cec <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
118c42: 85 f6 test %esi,%esi
118c44: 0f 84 b2 00 00 00 je 118cfc <rtems_timer_server_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
118c4a: 83 ec 0c sub $0xc,%esp 118c4d: 57 push %edi 118c4e: e8 89 d1 ff ff call 115ddc <_TOD_Validate> 118c53: 83 c4 10 add $0x10,%esp 118c56: 84 c0 test %al,%al
118c58: 75 0e jne 118c68 <rtems_timer_server_fire_when+0x50>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
118c5a: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118c5f: 8d 65 f4 lea -0xc(%ebp),%esp 118c62: 5b pop %ebx 118c63: 5e pop %esi 118c64: 5f pop %edi 118c65: c9 leave 118c66: c3 ret 118c67: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
118c68: 83 ec 0c sub $0xc,%esp 118c6b: 57 push %edi 118c6c: e8 df d0 ff ff call 115d50 <_TOD_To_seconds> 118c71: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
118c73: 83 c4 10 add $0x10,%esp 118c76: 3b 05 c4 09 14 00 cmp 0x1409c4,%eax
118c7c: 76 dc jbe 118c5a <rtems_timer_server_fire_when+0x42>
118c7e: 52 push %edx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
118c7f: 8d 45 e4 lea -0x1c(%ebp),%eax 118c82: 50 push %eax 118c83: ff 75 08 pushl 0x8(%ebp) 118c86: 68 80 0c 14 00 push $0x140c80 118c8b: e8 1c 25 00 00 call 11b1ac <_Objects_Get> 118c90: 89 c2 mov %eax,%edx
switch ( location ) {
118c92: 83 c4 10 add $0x10,%esp 118c95: 8b 45 e4 mov -0x1c(%ebp),%eax 118c98: 85 c0 test %eax,%eax
118c9a: 75 7c jne 118d18 <rtems_timer_server_fire_when+0x100>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118c9c: 83 ec 0c sub $0xc,%esp 118c9f: 8d 42 10 lea 0x10(%edx),%eax 118ca2: 50 push %eax 118ca3: 89 55 d4 mov %edx,-0x2c(%ebp) 118ca6: e8 09 41 00 00 call 11cdb4 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
118cab: 8b 55 d4 mov -0x2c(%ebp),%edx 118cae: c7 42 38 03 00 00 00 movl $0x3,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
118cb5: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118cbc: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118cbf: 8b 45 08 mov 0x8(%ebp),%eax 118cc2: 89 42 30 mov %eax,0x30(%edx)
the_watchdog->user_data = user_data;
118cc5: 8b 45 14 mov 0x14(%ebp),%eax 118cc8: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
118ccb: 2b 3d c4 09 14 00 sub 0x1409c4,%edi 118cd1: 89 7a 1c mov %edi,0x1c(%edx)
(*timer_server->schedule_operation)( timer_server, the_timer );
118cd4: 58 pop %eax 118cd5: 59 pop %ecx 118cd6: 52 push %edx 118cd7: 53 push %ebx 118cd8: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118cdb: e8 54 2f 00 00 call 11bc34 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118ce0: 83 c4 10 add $0x10,%esp 118ce3: 31 c0 xor %eax,%eax 118ce5: e9 75 ff ff ff jmp 118c5f <rtems_timer_server_fire_when+0x47> 118cea: 66 90 xchg %ax,%ax
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
118cec: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118cf1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118cf4: 5b pop %ebx <== NOT EXECUTED 118cf5: 5e pop %esi <== NOT EXECUTED 118cf6: 5f pop %edi <== NOT EXECUTED 118cf7: c9 leave <== NOT EXECUTED 118cf8: c3 ret <== NOT EXECUTED 118cf9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118cfc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118d01: 8d 65 f4 lea -0xc(%ebp),%esp 118d04: 5b pop %ebx 118d05: 5e pop %esi 118d06: 5f pop %edi 118d07: c9 leave 118d08: c3 ret 118d09: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
118d0c: b8 0e 00 00 00 mov $0xe,%eax 118d11: e9 49 ff ff ff jmp 118c5f <rtems_timer_server_fire_when+0x47> 118d16: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118d18: b8 04 00 00 00 mov $0x4,%eax 118d1d: e9 3d ff ff ff jmp 118c5f <rtems_timer_server_fire_when+0x47>