RTEMS 4.11Annotated Report
Thu Sep 27 18:20:13 2012
001272dc <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
1272dc: 55 push %ebp <== NOT EXECUTED
1272dd: 57 push %edi <== NOT EXECUTED
1272de: 56 push %esi <== NOT EXECUTED
1272df: 53 push %ebx <== NOT EXECUTED
1272e0: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED
1272e3: 8b 5c 24 60 mov 0x60(%esp),%ebx <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
1272e7: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
1272ea: 0f 84 58 01 00 00 je 127448 <Stack_check_Dump_threads_usage+0x16c><== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
1272f0: 8d b3 b0 00 00 00 lea 0xb0(%ebx),%esi <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
1272f6: 8b 93 c4 00 00 00 mov 0xc4(%ebx),%edx <== NOT EXECUTED
1272fc: 8b bb b4 00 00 00 mov 0xb4(%ebx),%edi <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
127302: 8b 2e mov (%esi),%ebp <== NOT EXECUTED
127304: 83 ed 10 sub $0x10,%ebp <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
127307: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
12730a: 89 e9 mov %ebp,%ecx <== NOT EXECUTED
12730c: 83 e1 fc and $0xfffffffc,%ecx <== NOT EXECUTED
12730f: 01 c1 add %eax,%ecx <== NOT EXECUTED
127311: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
127313: 73 22 jae 127337 <Stack_check_Dump_threads_usage+0x5b><== NOT EXECUTED
if (*base != U32_PATTERN)
127315: 81 7f 20 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x20(%edi) <== NOT EXECUTED
12731c: 74 12 je 127330 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
12731e: e9 e9 00 00 00 jmp 12740c <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
127323: 90 nop <== NOT EXECUTED
127324: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED
12732a: 0f 85 dc 00 00 00 jne 12740c <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
127330: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
127333: 39 c1 cmp %eax,%ecx <== NOT EXECUTED
127335: 77 ed ja 127324 <Stack_check_Dump_threads_usage+0x48><== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
127337: 31 ff xor %edi,%edi <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
127339: 85 db test %ebx,%ebx <== NOT EXECUTED
12733b: 0f 84 d9 00 00 00 je 12741a <Stack_check_Dump_threads_usage+0x13e><== NOT EXECUTED
#endif
{
(*print_handler)(
127341: 8b 0d 30 a9 17 00 mov 0x17a930,%ecx <== NOT EXECUTED
127347: 8d 44 24 3b lea 0x3b(%esp),%eax <== NOT EXECUTED
12734b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
12734f: c7 44 24 04 05 00 00 movl $0x5,0x4(%esp) <== NOT EXECUTED
127356: 00
127357: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
12735a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
12735d: 89 54 24 28 mov %edx,0x28(%esp) <== NOT EXECUTED
127361: 89 4c 24 2c mov %ecx,0x2c(%esp) <== NOT EXECUTED
127365: e8 02 b7 fe ff call 112a6c <rtems_object_get_name> <== NOT EXECUTED
12736a: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
12736e: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
127371: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
127375: c7 44 24 04 5e ad 15 movl $0x15ad5e,0x4(%esp) <== NOT EXECUTED
12737c: 00
12737d: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED
127382: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
127385: 8b 4c 24 2c mov 0x2c(%esp),%ecx <== NOT EXECUTED
127389: ff d1 call *%ecx <== NOT EXECUTED
12738b: 8b 54 24 28 mov 0x28(%esp),%edx <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
12738f: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
127392: 89 6c 24 14 mov %ebp,0x14(%esp) <== NOT EXECUTED
127396: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
12739a: 8b 16 mov (%esi),%edx <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
12739c: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
1273a0: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
1273a4: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1273a8: c7 44 24 04 79 ad 15 movl $0x15ad79,0x4(%esp) <== NOT EXECUTED
1273af: 00
1273b0: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED
1273b5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1273b8: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
1273be: a1 28 a9 17 00 mov 0x17a928,%eax <== NOT EXECUTED
1273c3: 85 c0 test %eax,%eax <== NOT EXECUTED
1273c5: 74 25 je 1273ec <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
1273c7: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
1273cb: c7 44 24 04 a4 ad 15 movl $0x15ada4,0x4(%esp) <== NOT EXECUTED
1273d2: 00
1273d3: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED
1273d8: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1273db: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED
}
}
1273e1: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
1273e4: 5b pop %ebx <== NOT EXECUTED
1273e5: 5e pop %esi <== NOT EXECUTED
1273e6: 5f pop %edi <== NOT EXECUTED
1273e7: 5d pop %ebp <== NOT EXECUTED
1273e8: c3 ret <== NOT EXECUTED
1273e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
1273ec: c7 44 24 04 97 ad 15 movl $0x15ad97,0x4(%esp) <== NOT EXECUTED
1273f3: 00
1273f4: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED
1273f9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1273fc: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
}
}
127402: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
127405: 5b pop %ebx <== NOT EXECUTED
127406: 5e pop %esi <== NOT EXECUTED
127407: 5f pop %edi <== NOT EXECUTED
127408: 5d pop %ebp <== NOT EXECUTED
127409: c3 ret <== NOT EXECUTED
12740a: 66 90 xchg %ax,%ax <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
12740c: 8d 7c 2f 10 lea 0x10(%edi,%ebp,1),%edi <== NOT EXECUTED
127410: 29 c7 sub %eax,%edi <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
127412: 85 db test %ebx,%ebx <== NOT EXECUTED
127414: 0f 85 27 ff ff ff jne 127341 <Stack_check_Dump_threads_usage+0x65><== NOT EXECUTED
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
12741a: c7 44 24 08 ff ff ff movl $0xffffffff,0x8(%esp) <== NOT EXECUTED
127421: ff
127422: c7 44 24 04 6b ad 15 movl $0x15ad6b,0x4(%esp) <== NOT EXECUTED
127429: 00
12742a: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED
12742f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
127432: 89 54 24 28 mov %edx,0x28(%esp) <== NOT EXECUTED
127436: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED
12743c: 8b 54 24 28 mov 0x28(%esp),%edx <== NOT EXECUTED
127440: e9 4a ff ff ff jmp 12738f <Stack_check_Dump_threads_usage+0xb3><== NOT EXECUTED
127445: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
127448: 8b 3d 80 b5 17 00 mov 0x17b580,%edi <== NOT EXECUTED
12744e: 85 ff test %edi,%edi <== NOT EXECUTED
127450: 74 8f je 1273e1 <Stack_check_Dump_threads_usage+0x105><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
127452: be 7c b5 17 00 mov $0x17b57c,%esi <== NOT EXECUTED
the_thread = 0;
current = 0;
127457: 31 d2 xor %edx,%edx <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
127459: 31 db xor %ebx,%ebx <== NOT EXECUTED
12745b: e9 a2 fe ff ff jmp 127302 <Stack_check_Dump_threads_usage+0x26><== NOT EXECUTED
00127510 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
127510: 56 push %esi <== NOT EXECUTED
127511: 53 push %ebx <== NOT EXECUTED
127512: 83 ec 44 sub $0x44,%esp <== NOT EXECUTED
127515: 8b 5c 24 50 mov 0x50(%esp),%ebx <== NOT EXECUTED
127519: 8a 4c 24 54 mov 0x54(%esp),%cl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
12751d: 8b b3 b4 00 00 00 mov 0xb4(%ebx),%esi <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
127523: c7 04 24 aa ad 15 00 movl $0x15adaa,(%esp) <== NOT EXECUTED
12752a: 88 4c 24 1c mov %cl,0x1c(%esp) <== NOT EXECUTED
12752e: e8 d5 10 fe ff call 108608 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
127533: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
127537: c7 04 24 ba ad 15 00 movl $0x15adba,(%esp) <== NOT EXECUTED
12753e: e8 c5 10 fe ff call 108608 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
127543: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
127546: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
12754a: c7 04 24 d7 ad 15 00 movl $0x15add7,(%esp) <== NOT EXECUTED
127551: e8 b2 10 fe ff call 108608 <printk> <== NOT EXECUTED
printk(
127556: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
127559: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
12755d: c7 04 24 e9 ad 15 00 movl $0x15ade9,(%esp) <== NOT EXECUTED
127564: e8 9f 10 fe ff call 108608 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
127569: 8d 44 24 20 lea 0x20(%esp),%eax <== NOT EXECUTED
12756d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
127571: c7 44 24 04 20 00 00 movl $0x20,0x4(%esp) <== NOT EXECUTED
127578: 00
127579: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
12757c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
12757f: e8 e8 b4 fe ff call 112a6c <rtems_object_get_name> <== NOT EXECUTED
127584: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
127588: c7 04 24 fd ad 15 00 movl $0x15adfd,(%esp) <== NOT EXECUTED
12758f: e8 74 10 fe ff call 108608 <printk> <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
127594: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx <== NOT EXECUTED
12759a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
1275a0: 8d 1c 02 lea (%edx,%eax,1),%ebx <== NOT EXECUTED
1275a3: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
1275a7: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
1275ab: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1275af: c7 04 24 2c ae 15 00 movl $0x15ae2c,(%esp) <== NOT EXECUTED
1275b6: e8 4d 10 fe ff call 108608 <printk> <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
1275bb: 8a 4c 24 1c mov 0x1c(%esp),%cl <== NOT EXECUTED
1275bf: 84 c9 test %cl,%cl <== NOT EXECUTED
1275c1: 74 0c je 1275cf <Stack_check_report_blown_task+0xbf><== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
1275c3: c7 04 24 81 00 00 00 movl $0x81,(%esp) <== NOT EXECUTED
1275ca: e8 29 48 fe ff call 10bdf8 <rtems_fatal_error_occurred><== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
1275cf: 8d 46 18 lea 0x18(%esi),%eax <== NOT EXECUTED
1275d2: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
1275d6: 83 c6 08 add $0x8,%esi <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
1275d9: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
1275dd: c7 44 24 04 10 00 00 movl $0x10,0x4(%esp) <== NOT EXECUTED
1275e4: 00
1275e5: c7 04 24 60 ae 15 00 movl $0x15ae60,(%esp) <== NOT EXECUTED
1275ec: e8 17 10 fe ff call 108608 <printk> <== NOT EXECUTED
1275f1: eb d0 jmp 1275c3 <Stack_check_report_blown_task+0xb3><== NOT EXECUTED
0010c214 <_API_extensions_Run_postdriver>:
/*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10c214: 53 push %ebx
10c215: 83 ec 08 sub $0x8,%esp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10c218: 8b 1d f8 f7 12 00 mov 0x12f7f8,%ebx
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10c21e: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx
10c224: 74 0f je 10c235 <_API_extensions_Run_postdriver+0x21><== NEVER TAKEN
10c226: 66 90 xchg %ax,%ax
* 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)();
10c228: 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 ) {
10c22b: 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 );
10c22d: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx
10c233: 75 f3 jne 10c228 <_API_extensions_Run_postdriver+0x14><== NEVER TAKEN
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10c235: 83 c4 08 add $0x8,%esp
10c238: 5b pop %ebx
10c239: c3 ret
0010c23c <_API_extensions_Run_postswitch>:
/*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10c23c: 53 push %ebx
10c23d: 83 ec 18 sub $0x18,%esp
10c240: 8b 1d f8 f7 12 00 mov 0x12f7f8,%ebx
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10c246: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx
10c24c: 74 17 je 10c265 <_API_extensions_Run_postswitch+0x29><== NEVER TAKEN
10c24e: 66 90 xchg %ax,%ax
!_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 );
10c250: a1 6c f8 12 00 mov 0x12f86c,%eax
10c255: 89 04 24 mov %eax,(%esp)
10c258: 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 ) {
10c25b: 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 );
10c25d: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx
10c263: 75 eb jne 10c250 <_API_extensions_Run_postswitch+0x14><== NEVER TAKEN
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10c265: 83 c4 18 add $0x18,%esp
10c268: 5b pop %ebx
10c269: c3 ret
00110c74 <_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
)
{
110c74: 57 push %edi
110c75: 56 push %esi
110c76: 53 push %ebx
110c77: 83 ec 20 sub $0x20,%esp
110c7a: 8b 5c 24 30 mov 0x30(%esp),%ebx
110c7e: 8b 74 24 38 mov 0x38(%esp),%esi
110c82: 8b 44 24 3c mov 0x3c(%esp),%eax
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
110c86: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
110c89: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
110c90: 89 43 4c mov %eax,0x4c(%ebx)
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
110c93: a8 03 test $0x3,%al
110c95: 74 15 je 110cac <_CORE_message_queue_Initialize+0x38>
allocated_message_size += sizeof(uintptr_t);
110c97: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uintptr_t) - 1);
110c9a: 83 e2 fc and $0xfffffffc,%edx
/*
* Check for an overflow. It can occur while increasing allocated_message_size
* to multiplicity of uintptr_t above.
*/
if (allocated_message_size < maximum_message_size)
110c9d: 39 d0 cmp %edx,%eax
110c9f: 76 0d jbe 110cae <_CORE_message_queue_Initialize+0x3a>
return false;
110ca1: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
110ca3: 83 c4 20 add $0x20,%esp
110ca6: 5b pop %ebx
110ca7: 5e pop %esi
110ca8: 5f pop %edi
110ca9: c3 ret
110caa: 66 90 xchg %ax,%ax
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
110cac: 89 c2 mov %eax,%edx
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
110cae: 8d 7a 10 lea 0x10(%edx),%edi
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
110cb1: 89 f0 mov %esi,%eax
110cb3: f7 e7 mul %edi
110cb5: 89 44 24 18 mov %eax,0x18(%esp)
110cb9: 89 54 24 1c mov %edx,0x1c(%esp)
if ( x > SIZE_MAX )
110cbd: 85 d2 test %edx,%edx
110cbf: 7f e0 jg 110ca1 <_CORE_message_queue_Initialize+0x2d>
return false;
*c = (size_t) x;
110cc1: 89 04 24 mov %eax,(%esp)
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
110cc4: e8 33 df ff ff call 10ebfc <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
110cc9: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
110ccc: 85 c0 test %eax,%eax
110cce: 74 d1 je 110ca1 <_CORE_message_queue_Initialize+0x2d><== NEVER TAKEN
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
110cd0: 89 7c 24 0c mov %edi,0xc(%esp)
110cd4: 89 74 24 08 mov %esi,0x8(%esp)
110cd8: 89 44 24 04 mov %eax,0x4(%esp)
110cdc: 8d 43 60 lea 0x60(%ebx),%eax
110cdf: 89 04 24 mov %eax,(%esp)
110ce2: e8 e5 b6 ff ff call 10c3cc <_Chain_Initialize>
Chain_Node *tail = _Chain_Tail( the_chain );
110ce7: 8d 43 50 lea 0x50(%ebx),%eax
110cea: 8d 53 54 lea 0x54(%ebx),%edx
110ced: 89 53 50 mov %edx,0x50(%ebx)
head->next = tail;
head->previous = NULL;
110cf0: 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 );
110cf7: 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(
110cfa: c7 44 24 0c 06 00 00 movl $0x6,0xc(%esp)
110d01: 00
110d02: c7 44 24 08 80 00 00 movl $0x80,0x8(%esp)
110d09: 00
*/
RTEMS_INLINE_ROUTINE bool _CORE_message_queue_Is_priority(
CORE_message_queue_Attributes *the_attribute
)
{
return
110d0a: 8b 44 24 34 mov 0x34(%esp),%eax
110d0e: 83 38 01 cmpl $0x1,(%eax)
110d11: 0f 94 c0 sete %al
110d14: 0f b6 c0 movzbl %al,%eax
110d17: 89 44 24 04 mov %eax,0x4(%esp)
110d1b: 89 1c 24 mov %ebx,(%esp)
110d1e: e8 89 d7 ff ff call 10e4ac <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
110d23: b0 01 mov $0x1,%al
}
110d25: 83 c4 20 add $0x20,%esp
110d28: 5b pop %ebx
110d29: 5e pop %esi
110d2a: 5f pop %edi
110d2b: c3 ret
0010c548 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10c548: 56 push %esi
10c549: 53 push %ebx
10c54a: 83 ec 14 sub $0x14,%esp
10c54d: 8b 74 24 20 mov 0x20(%esp),%esi
10c551: 8a 5c 24 28 mov 0x28(%esp),%bl
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
10c555: a1 04 f6 12 00 mov 0x12f604,%eax
10c55a: 85 c0 test %eax,%eax
10c55c: 74 6e je 10c5cc <_CORE_mutex_Seize+0x84>
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c55e: 84 db test %bl,%bl
10c560: 0f 84 95 00 00 00 je 10c5fb <_CORE_mutex_Seize+0xb3>
10c566: 83 3d 60 f7 12 00 01 cmpl $0x1,0x12f760
10c56d: 0f 87 9e 00 00 00 ja 10c611 <_CORE_mutex_Seize+0xc9>
10c573: 8d 44 24 30 lea 0x30(%esp),%eax
10c577: 89 44 24 04 mov %eax,0x4(%esp)
10c57b: 89 34 24 mov %esi,(%esp)
10c57e: e8 35 49 00 00 call 110eb8 <_CORE_mutex_Seize_interrupt_trylock>
10c583: 85 c0 test %eax,%eax
10c585: 74 3c je 10c5c3 <_CORE_mutex_Seize+0x7b><== ALWAYS TAKEN
10c587: 90 nop
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;
10c588: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
10c58f: a1 6c f8 12 00 mov 0x12f86c,%eax
10c594: 89 70 44 mov %esi,0x44(%eax)
10c597: 8b 54 24 24 mov 0x24(%esp),%edx
10c59b: 89 50 20 mov %edx,0x20(%eax)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
10c59e: a1 04 f6 12 00 mov 0x12f604,%eax
10c5a3: 40 inc %eax
10c5a4: a3 04 f6 12 00 mov %eax,0x12f604
return _Thread_Dispatch_disable_level;
10c5a9: a1 04 f6 12 00 mov 0x12f604,%eax
10c5ae: ff 74 24 30 pushl 0x30(%esp)
10c5b2: 9d popf
10c5b3: 8b 44 24 2c mov 0x2c(%esp),%eax
10c5b7: 89 44 24 04 mov %eax,0x4(%esp)
10c5bb: 89 34 24 mov %esi,(%esp)
10c5be: e8 11 ff ff ff call 10c4d4 <_CORE_mutex_Seize_interrupt_blocking>
}
10c5c3: 83 c4 14 add $0x14,%esp
10c5c6: 5b pop %ebx
10c5c7: 5e pop %esi
10c5c8: c3 ret
10c5c9: 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 );
10c5cc: 8d 44 24 30 lea 0x30(%esp),%eax
10c5d0: 89 44 24 04 mov %eax,0x4(%esp)
10c5d4: 89 34 24 mov %esi,(%esp)
10c5d7: e8 dc 48 00 00 call 110eb8 <_CORE_mutex_Seize_interrupt_trylock>
10c5dc: 85 c0 test %eax,%eax
10c5de: 74 e3 je 10c5c3 <_CORE_mutex_Seize+0x7b>
10c5e0: 84 db test %bl,%bl
10c5e2: 75 a4 jne 10c588 <_CORE_mutex_Seize+0x40>
10c5e4: ff 74 24 30 pushl 0x30(%esp)
10c5e8: 9d popf
10c5e9: a1 6c f8 12 00 mov 0x12f86c,%eax
10c5ee: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10c5f5: 83 c4 14 add $0x14,%esp
10c5f8: 5b pop %ebx
10c5f9: 5e pop %esi
10c5fa: c3 ret
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c5fb: 8d 44 24 30 lea 0x30(%esp),%eax
10c5ff: 89 44 24 04 mov %eax,0x4(%esp)
10c603: 89 34 24 mov %esi,(%esp)
10c606: e8 ad 48 00 00 call 110eb8 <_CORE_mutex_Seize_interrupt_trylock>
10c60b: 85 c0 test %eax,%eax
10c60d: 75 d5 jne 10c5e4 <_CORE_mutex_Seize+0x9c><== NEVER TAKEN
10c60f: eb b2 jmp 10c5c3 <_CORE_mutex_Seize+0x7b>
10c611: c7 44 24 08 12 00 00 movl $0x12,0x8(%esp)
10c618: 00
10c619: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10c620: 00
10c621: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10c628: e8 93 05 00 00 call 10cbc0 <_Internal_error_Occurred>
0010c768 <_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
)
{
10c768: 53 push %ebx
10c769: 83 ec 18 sub $0x18,%esp
10c76c: 8b 5c 24 20 mov 0x20(%esp),%ebx
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10c770: 89 1c 24 mov %ebx,(%esp)
10c773: e8 c4 19 00 00 call 10e13c <_Thread_queue_Dequeue>
10c778: 85 c0 test %eax,%eax
10c77a: 74 08 je 10c784 <_CORE_semaphore_Surrender+0x1c>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c77c: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10c77e: 83 c4 18 add $0x18,%esp
10c781: 5b pop %ebx
10c782: c3 ret
10c783: 90 nop
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10c784: 9c pushf
10c785: fa cli
10c786: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10c787: 8b 43 48 mov 0x48(%ebx),%eax
10c78a: 3b 43 40 cmp 0x40(%ebx),%eax
10c78d: 72 0d jb 10c79c <_CORE_semaphore_Surrender+0x34><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10c78f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10c794: 52 push %edx
10c795: 9d popf
}
return status;
}
10c796: 83 c4 18 add $0x18,%esp
10c799: 5b pop %ebx
10c79a: c3 ret
10c79b: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10c79c: 40 inc %eax
10c79d: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c7a0: 31 c0 xor %eax,%eax
10c7a2: eb f0 jmp 10c794 <_CORE_semaphore_Surrender+0x2c>
0010c3cc <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
10c3cc: 55 push %ebp
10c3cd: 57 push %edi
10c3ce: 56 push %esi
10c3cf: 53 push %ebx
10c3d0: 8b 74 24 14 mov 0x14(%esp),%esi
10c3d4: 8b 44 24 1c mov 0x1c(%esp),%eax
10c3d8: 8b 5c 24 20 mov 0x20(%esp),%ebx
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10c3dc: 8d 6e 04 lea 0x4(%esi),%ebp
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
10c3df: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
while ( count-- ) {
10c3e6: 8d 78 ff lea -0x1(%eax),%edi
10c3e9: 85 c0 test %eax,%eax
10c3eb: 74 2b je 10c418 <_Chain_Initialize+0x4c><== NEVER TAKEN
10c3ed: 89 f9 mov %edi,%ecx
10c3ef: 8b 44 24 18 mov 0x18(%esp),%eax
10c3f3: 89 f2 mov %esi,%edx
10c3f5: 8d 76 00 lea 0x0(%esi),%esi
current->next = next;
10c3f8: 89 02 mov %eax,(%edx)
next->previous = current;
10c3fa: 89 50 04 mov %edx,0x4(%eax)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
10c3fd: 49 dec %ecx
10c3fe: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
10c400: 01 d8 add %ebx,%eax
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
10c402: 83 f9 ff cmp $0xffffffff,%ecx
10c405: 75 f1 jne 10c3f8 <_Chain_Initialize+0x2c>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
10c407: 0f af df imul %edi,%ebx
10c40a: 03 5c 24 18 add 0x18(%esp),%ebx
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
10c40e: 89 2b mov %ebp,(%ebx)
tail->previous = current;
10c410: 89 5e 08 mov %ebx,0x8(%esi)
}
10c413: 5b pop %ebx
10c414: 5e pop %esi
10c415: 5f pop %edi
10c416: 5d pop %ebp
10c417: 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;
10c418: 89 f3 mov %esi,%ebx <== NOT EXECUTED
10c41a: eb f2 jmp 10c40e <_Chain_Initialize+0x42><== NOT EXECUTED
0010b544 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
10b544: 55 push %ebp
10b545: 57 push %edi
10b546: 56 push %esi
10b547: 53 push %ebx
10b548: 83 ec 2c sub $0x2c,%esp
10b54b: 8b 5c 24 40 mov 0x40(%esp),%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 ];
10b54f: 8b 8b e0 00 00 00 mov 0xe0(%ebx),%ecx
option_set = (rtems_option) the_thread->Wait.option;
10b555: 8b 6b 30 mov 0x30(%ebx),%ebp
_ISR_Disable( level );
10b558: 9c pushf
10b559: fa cli
10b55a: 5e pop %esi
pending_events = api->pending_events;
10b55b: 8b 11 mov (%ecx),%edx
event_condition = (rtems_event_set) the_thread->Wait.count;
10b55d: 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 ) ) {
10b560: 89 c7 mov %eax,%edi
10b562: 21 d7 and %edx,%edi
10b564: 89 7c 24 18 mov %edi,0x18(%esp)
10b568: 0f 84 ae 00 00 00 je 10b61c <_Event_Surrender+0xd8>
/*
* 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() &&
10b56e: 8b 3d 68 f8 12 00 mov 0x12f868,%edi
10b574: 85 ff test %edi,%edi
10b576: 74 08 je 10b580 <_Event_Surrender+0x3c>
10b578: 3b 1d 6c f8 12 00 cmp 0x12f86c,%ebx
10b57e: 74 58 je 10b5d8 <_Event_Surrender+0x94>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
10b580: f6 43 11 01 testb $0x1,0x11(%ebx)
10b584: 0f 84 92 00 00 00 je 10b61c <_Event_Surrender+0xd8>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
10b58a: 3b 44 24 18 cmp 0x18(%esp),%eax
10b58e: 74 09 je 10b599 <_Event_Surrender+0x55>
10b590: 83 e5 02 and $0x2,%ebp
10b593: 0f 84 83 00 00 00 je 10b61c <_Event_Surrender+0xd8> <== 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) );
10b599: 8b 44 24 18 mov 0x18(%esp),%eax
10b59d: f7 d0 not %eax
10b59f: 21 d0 and %edx,%eax
10b5a1: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
10b5a3: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b5aa: 8b 43 28 mov 0x28(%ebx),%eax
10b5ad: 8b 7c 24 18 mov 0x18(%esp),%edi
10b5b1: 89 38 mov %edi,(%eax)
_ISR_Flash( level );
10b5b3: 56 push %esi
10b5b4: 9d popf
10b5b5: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10b5b6: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10b5ba: 74 6c je 10b628 <_Event_Surrender+0xe4>
_ISR_Enable( level );
10b5bc: 56 push %esi
10b5bd: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b5be: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp)
10b5c5: 10
10b5c6: 89 1c 24 mov %ebx,(%esp)
10b5c9: e8 36 24 00 00 call 10da04 <_Thread_Clear_state>
}
return;
}
}
_ISR_Enable( level );
}
10b5ce: 83 c4 2c add $0x2c,%esp
10b5d1: 5b pop %ebx
10b5d2: 5e pop %esi
10b5d3: 5f pop %edi
10b5d4: 5d pop %ebp
10b5d5: c3 ret
10b5d6: 66 90 xchg %ax,%ax
* 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) ||
10b5d8: 8b 3d e0 f8 12 00 mov 0x12f8e0,%edi
/*
* 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 ) &&
10b5de: 83 ff 02 cmp $0x2,%edi
10b5e1: 74 09 je 10b5ec <_Event_Surrender+0xa8> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
10b5e3: 8b 3d e0 f8 12 00 mov 0x12f8e0,%edi
* 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) ||
10b5e9: 4f dec %edi
10b5ea: 75 94 jne 10b580 <_Event_Surrender+0x3c>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
10b5ec: 3b 44 24 18 cmp 0x18(%esp),%eax
10b5f0: 74 05 je 10b5f7 <_Event_Surrender+0xb3>
10b5f2: 83 e5 02 and $0x2,%ebp
10b5f5: 74 25 je 10b61c <_Event_Surrender+0xd8> <== NEVER TAKEN
10b5f7: 8b 44 24 18 mov 0x18(%esp),%eax
10b5fb: f7 d0 not %eax
10b5fd: 21 d0 and %edx,%eax
10b5ff: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
10b601: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b608: 8b 43 28 mov 0x28(%ebx),%eax
10b60b: 8b 54 24 18 mov 0x18(%esp),%edx
10b60f: 89 10 mov %edx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10b611: c7 05 e0 f8 12 00 03 movl $0x3,0x12f8e0
10b618: 00 00 00
10b61b: 90 nop
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
10b61c: 56 push %esi
10b61d: 9d popf
}
10b61e: 83 c4 2c add $0x2c,%esp
10b621: 5b pop %ebx
10b622: 5e pop %esi
10b623: 5f pop %edi
10b624: 5d pop %ebp
10b625: c3 ret
10b626: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10b628: 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 );
10b62f: 56 push %esi
10b630: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10b631: 8d 43 48 lea 0x48(%ebx),%eax
10b634: 89 04 24 mov %eax,(%esp)
10b637: e8 6c 34 00 00 call 10eaa8 <_Watchdog_Remove>
10b63c: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp)
10b643: 10
10b644: 89 1c 24 mov %ebx,(%esp)
10b647: e8 b8 23 00 00 call 10da04 <_Thread_Clear_state>
10b64c: eb d0 jmp 10b61e <_Event_Surrender+0xda>
0010b650 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10b650: 83 ec 2c sub $0x2c,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10b653: 8d 44 24 1c lea 0x1c(%esp),%eax
10b657: 89 44 24 04 mov %eax,0x4(%esp)
10b65b: 8b 44 24 30 mov 0x30(%esp),%eax
10b65f: 89 04 24 mov %eax,(%esp)
10b662: e8 61 27 00 00 call 10ddc8 <_Thread_Get>
switch ( location ) {
10b667: 8b 54 24 1c mov 0x1c(%esp),%edx
10b66b: 85 d2 test %edx,%edx
10b66d: 75 3b jne 10b6aa <_Event_Timeout+0x5a> <== 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 );
10b66f: 9c pushf
10b670: fa cli
10b671: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
10b672: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
10b679: 3b 05 6c f8 12 00 cmp 0x12f86c,%eax
10b67f: 74 2f je 10b6b0 <_Event_Timeout+0x60>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
10b681: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
10b688: 52 push %edx
10b689: 9d popf
10b68a: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp)
10b691: 10
10b692: 89 04 24 mov %eax,(%esp)
10b695: e8 6a 23 00 00 call 10da04 <_Thread_Clear_state>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
10b69a: a1 04 f6 12 00 mov 0x12f604,%eax
10b69f: 48 dec %eax
10b6a0: a3 04 f6 12 00 mov %eax,0x12f604
return _Thread_Dispatch_disable_level;
10b6a5: a1 04 f6 12 00 mov 0x12f604,%eax
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b6aa: 83 c4 2c add $0x2c,%esp
10b6ad: c3 ret
10b6ae: 66 90 xchg %ax,%ax
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
10b6b0: 8b 0d e0 f8 12 00 mov 0x12f8e0,%ecx
10b6b6: 49 dec %ecx
10b6b7: 75 c8 jne 10b681 <_Event_Timeout+0x31>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10b6b9: c7 05 e0 f8 12 00 02 movl $0x2,0x12f8e0
10b6c0: 00 00 00
10b6c3: eb bc jmp 10b681 <_Event_Timeout+0x31>
00110fd4 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
110fd4: 55 push %ebp
110fd5: 57 push %edi
110fd6: 56 push %esi
110fd7: 53 push %ebx
110fd8: 83 ec 3c sub $0x3c,%esp
110fdb: 8b 6c 24 54 mov 0x54(%esp),%ebp
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
110fdf: 8d 45 04 lea 0x4(%ebp),%eax
110fe2: 89 44 24 10 mov %eax,0x10(%esp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
110fe6: 8b 54 24 50 mov 0x50(%esp),%edx
110fea: 8b 52 10 mov 0x10(%edx),%edx
110fed: 89 54 24 18 mov %edx,0x18(%esp)
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
110ff1: 39 c5 cmp %eax,%ebp
110ff3: 0f 87 ab 01 00 00 ja 1111a4 <_Heap_Allocate_aligned_with_boundary+0x1d0>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
110ff9: 8b 5c 24 5c mov 0x5c(%esp),%ebx
110ffd: 85 db test %ebx,%ebx
110fff: 0f 85 77 01 00 00 jne 11117c <_Heap_Allocate_aligned_with_boundary+0x1a8>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
111005: 8b 54 24 50 mov 0x50(%esp),%edx
111009: 8b 72 08 mov 0x8(%edx),%esi
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
11100c: 31 ff xor %edi,%edi
11100e: 39 f2 cmp %esi,%edx
111010: 74 4a je 11105c <_Heap_Allocate_aligned_with_boundary+0x88>
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
111012: 8b 44 24 18 mov 0x18(%esp),%eax
111016: 83 c0 07 add $0x7,%eax
111019: 89 44 24 24 mov %eax,0x24(%esp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
11101d: c7 44 24 14 04 00 00 movl $0x4,0x14(%esp)
111024: 00
111025: 29 6c 24 14 sub %ebp,0x14(%esp)
111029: eb 1e jmp 111049 <_Heap_Allocate_aligned_with_boundary+0x75>
11102b: 90 nop
* 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 ) {
if ( alignment == 0 ) {
11102c: 8b 54 24 58 mov 0x58(%esp),%edx
111030: 85 d2 test %edx,%edx
111032: 75 40 jne 111074 <_Heap_Allocate_aligned_with_boundary+0xa0>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
111034: 8d 5e 08 lea 0x8(%esi),%ebx
);
}
}
/* Statistics */
++search_count;
111037: 47 inc %edi
if ( alloc_begin != 0 ) {
111038: 85 db test %ebx,%ebx
11103a: 0f 85 14 01 00 00 jne 111154 <_Heap_Allocate_aligned_with_boundary+0x180><== ALWAYS TAKEN
break;
}
block = block->next;
111040: 8b 76 08 mov 0x8(%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 ) {
111043: 39 74 24 50 cmp %esi,0x50(%esp)
111047: 74 13 je 11105c <_Heap_Allocate_aligned_with_boundary+0x88>
/*
* 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 ) {
111049: 8b 5e 04 mov 0x4(%esi),%ebx
11104c: 39 5c 24 10 cmp %ebx,0x10(%esp)
111050: 72 da jb 11102c <_Heap_Allocate_aligned_with_boundary+0x58>
);
}
}
/* Statistics */
++search_count;
111052: 47 inc %edi
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
111053: 8b 76 08 mov 0x8(%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 ) {
111056: 39 74 24 50 cmp %esi,0x50(%esp)
11105a: 75 ed jne 111049 <_Heap_Allocate_aligned_with_boundary+0x75>
);
}
}
/* Statistics */
++search_count;
11105c: 31 c0 xor %eax,%eax
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
11105e: 8b 54 24 50 mov 0x50(%esp),%edx
111062: 39 7a 44 cmp %edi,0x44(%edx)
111065: 73 03 jae 11106a <_Heap_Allocate_aligned_with_boundary+0x96>
stats->max_search = search_count;
111067: 89 7a 44 mov %edi,0x44(%edx)
}
return (void *) alloc_begin;
}
11106a: 83 c4 3c add $0x3c,%esp
11106d: 5b pop %ebx
11106e: 5e pop %esi
11106f: 5f pop %edi
111070: 5d pop %ebp
111071: c3 ret
111072: 66 90 xchg %ax,%ax
111074: 8b 54 24 50 mov 0x50(%esp),%edx
111078: 8b 52 14 mov 0x14(%edx),%edx
11107b: 89 54 24 1c mov %edx,0x1c(%esp)
- 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;
11107f: 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;
111082: 01 f3 add %esi,%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
111084: 8d 46 08 lea 0x8(%esi),%eax
111087: 89 44 24 20 mov %eax,0x20(%esp)
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;
11108b: 8b 4c 24 24 mov 0x24(%esp),%ecx
11108f: 29 d1 sub %edx,%ecx
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
111091: 01 d9 add %ebx,%ecx
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
111093: 03 5c 24 14 add 0x14(%esp),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
111097: 89 d8 mov %ebx,%eax
111099: 31 d2 xor %edx,%edx
11109b: f7 74 24 58 divl 0x58(%esp)
11109f: 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 ) {
1110a1: 39 d9 cmp %ebx,%ecx
1110a3: 73 0c jae 1110b1 <_Heap_Allocate_aligned_with_boundary+0xdd>
1110a5: 89 c8 mov %ecx,%eax
1110a7: 31 d2 xor %edx,%edx
1110a9: f7 74 24 58 divl 0x58(%esp)
1110ad: 89 cb mov %ecx,%ebx
1110af: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
1110b1: 8b 44 24 5c mov 0x5c(%esp),%eax
1110b5: 85 c0 test %eax,%eax
1110b7: 74 64 je 11111d <_Heap_Allocate_aligned_with_boundary+0x149>
/* 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;
1110b9: 8d 0c 2b lea (%ebx,%ebp,1),%ecx
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
1110bc: 8b 54 24 20 mov 0x20(%esp),%edx
1110c0: 01 ea add %ebp,%edx
1110c2: 89 54 24 28 mov %edx,0x28(%esp)
1110c6: 89 c8 mov %ecx,%eax
1110c8: 31 d2 xor %edx,%edx
1110ca: f7 74 24 5c divl 0x5c(%esp)
1110ce: 89 c8 mov %ecx,%eax
1110d0: 29 d0 sub %edx,%eax
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
1110d2: 39 c3 cmp %eax,%ebx
1110d4: 73 47 jae 11111d <_Heap_Allocate_aligned_with_boundary+0x149>
1110d6: 39 c1 cmp %eax,%ecx
1110d8: 76 43 jbe 11111d <_Heap_Allocate_aligned_with_boundary+0x149>
if ( boundary_line < boundary_floor ) {
1110da: 39 44 24 28 cmp %eax,0x28(%esp)
1110de: 77 68 ja 111148 <_Heap_Allocate_aligned_with_boundary+0x174>
1110e0: 89 74 24 2c mov %esi,0x2c(%esp)
1110e4: 8b 74 24 28 mov 0x28(%esp),%esi
1110e8: eb 0e jmp 1110f8 <_Heap_Allocate_aligned_with_boundary+0x124>
1110ea: 66 90 xchg %ax,%ax
/* 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 ) {
1110ec: 39 c1 cmp %eax,%ecx
1110ee: 76 29 jbe 111119 <_Heap_Allocate_aligned_with_boundary+0x145>
if ( boundary_line < boundary_floor ) {
1110f0: 39 c6 cmp %eax,%esi
1110f2: 0f 87 a0 00 00 00 ja 111198 <_Heap_Allocate_aligned_with_boundary+0x1c4><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
1110f8: 89 c3 mov %eax,%ebx
1110fa: 29 eb sub %ebp,%ebx
1110fc: 89 d8 mov %ebx,%eax
1110fe: 31 d2 xor %edx,%edx
111100: f7 74 24 58 divl 0x58(%esp)
111104: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
111106: 8d 0c 2b lea (%ebx,%ebp,1),%ecx
111109: 89 c8 mov %ecx,%eax
11110b: 31 d2 xor %edx,%edx
11110d: f7 74 24 5c divl 0x5c(%esp)
111111: 89 c8 mov %ecx,%eax
111113: 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 ) {
111115: 39 c3 cmp %eax,%ebx
111117: 72 d3 jb 1110ec <_Heap_Allocate_aligned_with_boundary+0x118>
111119: 8b 74 24 2c mov 0x2c(%esp),%esi
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 ) {
11111d: 39 5c 24 20 cmp %ebx,0x20(%esp)
111121: 77 25 ja 111148 <_Heap_Allocate_aligned_with_boundary+0x174>
111123: b9 f8 ff ff ff mov $0xfffffff8,%ecx
111128: 29 f1 sub %esi,%ecx
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
11112a: 01 d9 add %ebx,%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
11112c: 89 d8 mov %ebx,%eax
11112e: 31 d2 xor %edx,%edx
111130: f7 74 24 18 divl 0x18(%esp)
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;
111134: 29 d1 sub %edx,%ecx
if ( free_size >= min_block_size || free_size == 0 ) {
111136: 39 4c 24 1c cmp %ecx,0x1c(%esp)
11113a: 0f 86 f7 fe ff ff jbe 111037 <_Heap_Allocate_aligned_with_boundary+0x63>
111140: 85 c9 test %ecx,%ecx
111142: 0f 84 ef fe ff ff je 111037 <_Heap_Allocate_aligned_with_boundary+0x63>
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 ) {
if ( boundary_line < boundary_floor ) {
return 0;
111148: 31 db xor %ebx,%ebx
);
}
}
/* Statistics */
++search_count;
11114a: 47 inc %edi
if ( alloc_begin != 0 ) {
11114b: 85 db test %ebx,%ebx
11114d: 0f 84 ed fe ff ff je 111040 <_Heap_Allocate_aligned_with_boundary+0x6c><== ALWAYS TAKEN
111153: 90 nop
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
111154: 8b 44 24 50 mov 0x50(%esp),%eax
111158: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
11115b: 01 78 4c add %edi,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
11115e: 89 6c 24 0c mov %ebp,0xc(%esp)
111162: 89 5c 24 08 mov %ebx,0x8(%esp)
111166: 89 74 24 04 mov %esi,0x4(%esp)
11116a: 89 04 24 mov %eax,(%esp)
11116d: e8 6a b9 ff ff call 10cadc <_Heap_Block_allocate>
111172: 89 d8 mov %ebx,%eax
111174: e9 e5 fe ff ff jmp 11105e <_Heap_Allocate_aligned_with_boundary+0x8a>
111179: 8d 76 00 lea 0x0(%esi),%esi
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
11117c: 3b 6c 24 5c cmp 0x5c(%esp),%ebp
111180: 77 22 ja 1111a4 <_Heap_Allocate_aligned_with_boundary+0x1d0>
return NULL;
}
if ( alignment == 0 ) {
111182: 8b 4c 24 58 mov 0x58(%esp),%ecx
111186: 85 c9 test %ecx,%ecx
111188: 0f 85 77 fe ff ff jne 111005 <_Heap_Allocate_aligned_with_boundary+0x31>
alignment = page_size;
11118e: 89 54 24 58 mov %edx,0x58(%esp)
111192: e9 6e fe ff ff jmp 111005 <_Heap_Allocate_aligned_with_boundary+0x31>
111197: 90 nop
111198: 8b 74 24 2c mov 0x2c(%esp),%esi <== NOT EXECUTED
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 ) {
if ( boundary_line < boundary_floor ) {
return 0;
11119c: 31 db xor %ebx,%ebx <== NOT EXECUTED
11119e: e9 94 fe ff ff jmp 111037 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
1111a3: 90 nop <== NOT EXECUTED
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
/* Integer overflow occured */
return NULL;
1111a4: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
1111a6: 83 c4 3c add $0x3c,%esp
1111a9: 5b pop %ebx
1111aa: 5e pop %esi
1111ab: 5f pop %edi
1111ac: 5d pop %ebp
1111ad: c3 ret
0011120c <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
11120c: 55 push %ebp
11120d: 57 push %edi
11120e: 56 push %esi
11120f: 53 push %ebx
111210: 83 ec 5c sub $0x5c,%esp
111213: 8b 7c 24 70 mov 0x70(%esp),%edi
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
111217: 8b 4f 20 mov 0x20(%edi),%ecx
11121a: 89 4c 24 28 mov %ecx,0x28(%esp)
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;
11121e: c7 44 24 48 00 00 00 movl $0x0,0x48(%esp)
111225: 00
Heap_Block *extend_last_block = NULL;
111226: c7 44 24 4c 00 00 00 movl $0x0,0x4c(%esp)
11122d: 00
uintptr_t const page_size = heap->page_size;
11122e: 8b 4f 10 mov 0x10(%edi),%ecx
111231: 89 4c 24 24 mov %ecx,0x24(%esp)
uintptr_t const min_block_size = heap->min_block_size;
111235: 8b 47 14 mov 0x14(%edi),%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;
111238: 8b 4f 30 mov 0x30(%edi),%ecx
11123b: 89 4c 24 2c mov %ecx,0x2c(%esp)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
11123f: 8b 6c 24 74 mov 0x74(%esp),%ebp
111243: 03 6c 24 78 add 0x78(%esp),%ebp
111247: 73 0b jae 111254 <_Heap_Extend+0x48>
return false;
111249: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
11124b: 83 c4 5c add $0x5c,%esp
11124e: 5b pop %ebx
11124f: 5e pop %esi
111250: 5f pop %edi
111251: 5d pop %ebp
111252: c3 ret
111253: 90 nop
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
111254: 8d 54 24 4c lea 0x4c(%esp),%edx
111258: 89 54 24 14 mov %edx,0x14(%esp)
11125c: 8d 54 24 48 lea 0x48(%esp),%edx
111260: 89 54 24 10 mov %edx,0x10(%esp)
111264: 89 44 24 0c mov %eax,0xc(%esp)
111268: 8b 4c 24 24 mov 0x24(%esp),%ecx
11126c: 89 4c 24 08 mov %ecx,0x8(%esp)
111270: 8b 44 24 78 mov 0x78(%esp),%eax
111274: 89 44 24 04 mov %eax,0x4(%esp)
111278: 8b 4c 24 74 mov 0x74(%esp),%ecx
11127c: 89 0c 24 mov %ecx,(%esp)
11127f: e8 38 b7 ff ff call 10c9bc <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
111284: 84 c0 test %al,%al
111286: 74 c1 je 111249 <_Heap_Extend+0x3d>
111288: 8b 5c 24 28 mov 0x28(%esp),%ebx
11128c: c7 44 24 34 00 00 00 movl $0x0,0x34(%esp)
111293: 00
111294: c7 44 24 38 00 00 00 movl $0x0,0x38(%esp)
11129b: 00
11129c: c7 44 24 20 00 00 00 movl $0x0,0x20(%esp)
1112a3: 00
1112a4: c7 44 24 30 00 00 00 movl $0x0,0x30(%esp)
1112ab: 00
1112ac: 89 7c 24 3c mov %edi,0x3c(%esp)
1112b0: eb 28 jmp 1112da <_Heap_Extend+0xce>
1112b2: 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 ) {
1112b4: 39 cd cmp %ecx,%ebp
1112b6: 73 04 jae 1112bc <_Heap_Extend+0xb0>
1112b8: 89 5c 24 38 mov %ebx,0x38(%esp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
1112bc: 3b 4c 24 74 cmp 0x74(%esp),%ecx
1112c0: 74 4f je 111311 <_Heap_Extend+0x105>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
1112c2: 39 4c 24 74 cmp %ecx,0x74(%esp)
1112c6: 76 04 jbe 1112cc <_Heap_Extend+0xc0>
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 )
1112c8: 89 74 24 34 mov %esi,0x34(%esp)
- 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;
1112cc: 8b 5e 04 mov 0x4(%esi),%ebx
1112cf: 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);
1112d2: 01 f3 add %esi,%ebx
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
1112d4: 39 5c 24 28 cmp %ebx,0x28(%esp)
1112d8: 74 4b je 111325 <_Heap_Extend+0x119>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
1112da: 3b 5c 24 28 cmp 0x28(%esp),%ebx
1112de: 0f 84 40 01 00 00 je 111424 <_Heap_Extend+0x218>
1112e4: 89 df mov %ebx,%edi
uintptr_t const sub_area_end = start_block->prev_size;
1112e6: 8b 0b mov (%ebx),%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
1112e8: 8d 71 f8 lea -0x8(%ecx),%esi
1112eb: 89 c8 mov %ecx,%eax
1112ed: 31 d2 xor %edx,%edx
1112ef: f7 74 24 24 divl 0x24(%esp)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
1112f3: 29 d6 sub %edx,%esi
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
1112f5: 39 4c 24 74 cmp %ecx,0x74(%esp)
1112f9: 73 08 jae 111303 <_Heap_Extend+0xf7>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
1112fb: 39 ef cmp %ebp,%edi
1112fd: 0f 82 46 ff ff ff jb 111249 <_Heap_Extend+0x3d>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
111303: 39 ef cmp %ebp,%edi
111305: 75 ad jne 1112b4 <_Heap_Extend+0xa8>
111307: 89 5c 24 30 mov %ebx,0x30(%esp)
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
11130b: 3b 4c 24 74 cmp 0x74(%esp),%ecx
11130f: 75 b1 jne 1112c2 <_Heap_Extend+0xb6> <== ALWAYS TAKEN
start_block->prev_size = extend_area_end;
111311: 89 2b mov %ebp,(%ebx)
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 )
111313: 89 74 24 20 mov %esi,0x20(%esp)
- 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;
111317: 8b 5e 04 mov 0x4(%esi),%ebx
11131a: 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);
11131d: 01 f3 add %esi,%ebx
} 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 );
11131f: 39 5c 24 28 cmp %ebx,0x28(%esp)
111323: 75 b5 jne 1112da <_Heap_Extend+0xce> <== NEVER TAKEN
111325: 8b 7c 24 3c mov 0x3c(%esp),%edi
if ( extend_area_begin < heap->area_begin ) {
111329: 8b 4c 24 74 mov 0x74(%esp),%ecx
11132d: 3b 4f 18 cmp 0x18(%edi),%ecx
111330: 0f 82 fa 00 00 00 jb 111430 <_Heap_Extend+0x224>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
111336: 3b 6f 1c cmp 0x1c(%edi),%ebp
111339: 76 03 jbe 11133e <_Heap_Extend+0x132>
heap->area_end = extend_area_end;
11133b: 89 6f 1c mov %ebp,0x1c(%edi)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
11133e: 8b 54 24 4c mov 0x4c(%esp),%edx
111342: 8b 44 24 48 mov 0x48(%esp),%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 =
111346: 89 d1 mov %edx,%ecx
111348: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
11134a: 89 28 mov %ebp,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
11134c: 89 cb mov %ecx,%ebx
11134e: 83 cb 01 or $0x1,%ebx
111351: 89 58 04 mov %ebx,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
111354: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
111356: 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 ) {
11135d: 39 47 20 cmp %eax,0x20(%edi)
111360: 0f 86 d2 00 00 00 jbe 111438 <_Heap_Extend+0x22c>
heap->first_block = extend_first_block;
111366: 89 47 20 mov %eax,0x20(%edi)
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
111369: 8b 44 24 30 mov 0x30(%esp),%eax
11136d: 85 c0 test %eax,%eax
11136f: 0f 84 d7 00 00 00 je 11144c <_Heap_Extend+0x240>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
111375: 8b 4f 10 mov 0x10(%edi),%ecx
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
111378: 8b 5c 24 74 mov 0x74(%esp),%ebx
11137c: 83 c3 08 add $0x8,%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
11137f: 89 d8 mov %ebx,%eax
111381: 31 d2 xor %edx,%edx
111383: f7 f1 div %ecx
if ( remainder != 0 ) {
111385: 85 d2 test %edx,%edx
111387: 74 04 je 11138d <_Heap_Extend+0x181>
return value - remainder + alignment;
111389: 01 cb add %ecx,%ebx
11138b: 29 d3 sub %edx,%ebx
uintptr_t const new_first_block_begin =
11138d: 8d 53 f8 lea -0x8(%ebx),%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;
111390: 8b 4c 24 30 mov 0x30(%esp),%ecx
111394: 8b 01 mov (%ecx),%eax
111396: 89 43 f8 mov %eax,-0x8(%ebx)
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 =
111399: 89 c8 mov %ecx,%eax
11139b: 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;
11139d: 83 c8 01 or $0x1,%eax
1113a0: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
1113a3: 89 f8 mov %edi,%eax
1113a5: e8 46 fe ff ff call 1111f0 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
1113aa: 8b 5c 24 20 mov 0x20(%esp),%ebx
1113ae: 85 db test %ebx,%ebx
1113b0: 0f 84 b6 00 00 00 je 11146c <_Heap_Extend+0x260>
)
{
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,
1113b6: 8d 4d f8 lea -0x8(%ebp),%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(
1113b9: 2b 4c 24 20 sub 0x20(%esp),%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
1113bd: 89 c8 mov %ecx,%eax
1113bf: 31 d2 xor %edx,%edx
1113c1: f7 77 10 divl 0x10(%edi)
1113c4: 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)
1113c6: 8b 54 24 20 mov 0x20(%esp),%edx
1113ca: 8b 42 04 mov 0x4(%edx),%eax
1113cd: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
1113cf: 83 c8 01 or $0x1,%eax
1113d2: 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;
1113d6: 8b 42 04 mov 0x4(%edx),%eax
1113d9: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
1113dc: 09 c8 or %ecx,%eax
1113de: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
1113e1: 89 f8 mov %edi,%eax
1113e3: e8 08 fe ff ff call 1111f0 <_Heap_Free_block>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
1113e8: 8b 57 24 mov 0x24(%edi),%edx
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;
1113eb: 8b 42 04 mov 0x4(%edx),%eax
1113ee: 83 e0 01 and $0x1,%eax
* 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(
1113f1: 8b 4f 20 mov 0x20(%edi),%ecx
1113f4: 29 d1 sub %edx,%ecx
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
1113f6: 09 c8 or %ecx,%eax
1113f8: 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;
1113fb: 8b 47 30 mov 0x30(%edi),%eax
1113fe: 2b 44 24 2c sub 0x2c(%esp),%eax
/* Statistics */
stats->size += extended_size;
111402: 01 47 2c add %eax,0x2c(%edi)
if ( extended_size_ptr != NULL )
111405: 8b 54 24 7c mov 0x7c(%esp),%edx
111409: 85 d2 test %edx,%edx
11140b: 0f 84 a3 00 00 00 je 1114b4 <_Heap_Extend+0x2a8> <== NEVER TAKEN
*extended_size_ptr = extended_size;
111411: 8b 4c 24 7c mov 0x7c(%esp),%ecx
111415: 89 01 mov %eax,(%ecx)
return true;
111417: b0 01 mov $0x1,%al
}
111419: 83 c4 5c add $0x5c,%esp
11141c: 5b pop %ebx
11141d: 5e pop %esi
11141e: 5f pop %edi
11141f: 5d pop %ebp
111420: c3 ret
111421: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111424: 8b 4c 24 3c mov 0x3c(%esp),%ecx
111428: 8b 79 18 mov 0x18(%ecx),%edi
11142b: e9 b6 fe ff ff jmp 1112e6 <_Heap_Extend+0xda>
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;
111430: 89 4f 18 mov %ecx,0x18(%edi)
111433: e9 06 ff ff ff jmp 11133e <_Heap_Extend+0x132>
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 ) {
111438: 39 57 24 cmp %edx,0x24(%edi)
11143b: 0f 83 28 ff ff ff jae 111369 <_Heap_Extend+0x15d>
heap->last_block = extend_last_block;
111441: 89 57 24 mov %edx,0x24(%edi)
111444: e9 20 ff ff ff jmp 111369 <_Heap_Extend+0x15d>
111449: 8d 76 00 lea 0x0(%esi),%esi
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
11144c: 8b 74 24 38 mov 0x38(%esp),%esi
111450: 85 f6 test %esi,%esi
111452: 0f 84 52 ff ff ff je 1113aa <_Heap_Extend+0x19e>
{
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;
111458: 8b 44 24 38 mov 0x38(%esp),%eax
11145c: 29 d0 sub %edx,%eax
11145e: 83 c8 01 or $0x1,%eax
111461: 89 42 04 mov %eax,0x4(%edx)
111464: e9 41 ff ff ff jmp 1113aa <_Heap_Extend+0x19e>
111469: 8d 76 00 lea 0x0(%esi),%esi
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
11146c: 8b 4c 24 34 mov 0x34(%esp),%ecx
111470: 85 c9 test %ecx,%ecx
111472: 74 23 je 111497 <_Heap_Extend+0x28b>
_Heap_Link_above(
111474: 8b 4c 24 4c mov 0x4c(%esp),%ecx
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;
111478: 8b 54 24 34 mov 0x34(%esp),%edx
11147c: 8b 42 04 mov 0x4(%edx),%eax
11147f: 83 e0 01 and $0x1,%eax
)
{
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 );
111482: 8b 54 24 48 mov 0x48(%esp),%edx
111486: 2b 54 24 34 sub 0x34(%esp),%edx
block->size_and_flag = size | flag;
11148a: 09 d0 or %edx,%eax
11148c: 8b 54 24 34 mov 0x34(%esp),%edx
111490: 89 42 04 mov %eax,0x4(%edx)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
111493: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111497: 83 7c 24 30 00 cmpl $0x0,0x30(%esp)
11149c: 0f 85 46 ff ff ff jne 1113e8 <_Heap_Extend+0x1dc>
_Heap_Free_block( heap, extend_first_block );
1114a2: 8b 54 24 48 mov 0x48(%esp),%edx
1114a6: 89 f8 mov %edi,%eax
1114a8: e8 43 fd ff ff call 1111f0 <_Heap_Free_block>
1114ad: e9 36 ff ff ff jmp 1113e8 <_Heap_Extend+0x1dc>
1114b2: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
1114b4: b0 01 mov $0x1,%al <== NOT EXECUTED
1114b6: e9 90 fd ff ff jmp 11124b <_Heap_Extend+0x3f> <== NOT EXECUTED
001111b0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
1111b0: 55 push %ebp
1111b1: 57 push %edi
1111b2: 56 push %esi
1111b3: 53 push %ebx
1111b4: 83 ec 0c sub $0xc,%esp
1111b7: 8b 4c 24 20 mov 0x20(%esp),%ecx
1111bb: 8b 44 24 24 mov 0x24(%esp),%eax
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
1111bf: 85 c0 test %eax,%eax
1111c1: 0f 84 a1 00 00 00 je 111268 <_Heap_Free+0xb8>
1111c7: 8d 58 f8 lea -0x8(%eax),%ebx
1111ca: 31 d2 xor %edx,%edx
1111cc: f7 71 10 divl 0x10(%ecx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
1111cf: 29 d3 sub %edx,%ebx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
1111d1: 8b 41 20 mov 0x20(%ecx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1111d4: 39 c3 cmp %eax,%ebx
1111d6: 72 1c jb 1111f4 <_Heap_Free+0x44>
1111d8: 8b 71 24 mov 0x24(%ecx),%esi
1111db: 39 f3 cmp %esi,%ebx
1111dd: 77 15 ja 1111f4 <_Heap_Free+0x44>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1111df: 8b 53 04 mov 0x4(%ebx),%edx
1111e2: 89 14 24 mov %edx,(%esp)
- 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;
1111e5: 89 d7 mov %edx,%edi
1111e7: 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);
1111ea: 8d 14 1f lea (%edi,%ebx,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;
1111ed: 39 d0 cmp %edx,%eax
1111ef: 76 0f jbe 111200 <_Heap_Free+0x50> <== ALWAYS TAKEN
1111f1: 8d 76 00 lea 0x0(%esi),%esi
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
1111f4: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1111f6: 83 c4 0c add $0xc,%esp
1111f9: 5b pop %ebx
1111fa: 5e pop %esi
1111fb: 5f pop %edi
1111fc: 5d pop %ebp
1111fd: c3 ret
1111fe: 66 90 xchg %ax,%ax
111200: 39 d6 cmp %edx,%esi
111202: 72 f0 jb 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN
111204: 8b 6a 04 mov 0x4(%edx),%ebp
111207: 89 6c 24 04 mov %ebp,0x4(%esp)
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
11120b: 83 e5 01 and $0x1,%ebp
11120e: 74 e4 je 1111f4 <_Heap_Free+0x44> <== 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;
111210: 8b 6c 24 04 mov 0x4(%esp),%ebp
111214: 83 e5 fe and $0xfffffffe,%ebp
111217: 89 6c 24 04 mov %ebp,0x4(%esp)
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 ));
11121b: 39 d6 cmp %edx,%esi
11121d: 74 53 je 111272 <_Heap_Free+0xc2>
11121f: f6 44 2a 04 01 testb $0x1,0x4(%edx,%ebp,1)
111224: 75 4c jne 111272 <_Heap_Free+0xc2>
if ( !_Heap_Is_prev_used( block ) ) {
111226: f6 04 24 01 testb $0x1,(%esp)
11122a: 0f 84 df 00 00 00 je 11130f <_Heap_Free+0x15f>
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 */
uintptr_t const size = block_size + next_block_size;
111230: 8b 6c 24 04 mov 0x4(%esp),%ebp
111234: 01 fd add %edi,%ebp
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111236: 8b 72 08 mov 0x8(%edx),%esi
111239: 8b 42 0c mov 0xc(%edx),%eax
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
11123c: 89 73 08 mov %esi,0x8(%ebx)
new_block->prev = prev;
11123f: 89 43 0c mov %eax,0xc(%ebx)
next->prev = new_block;
111242: 89 5e 0c mov %ebx,0xc(%esi)
prev->next = new_block;
111245: 89 58 08 mov %ebx,0x8(%eax)
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;
111248: 89 e8 mov %ebp,%eax
11124a: 83 c8 01 or $0x1,%eax
11124d: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
111250: 89 6c 1d 00 mov %ebp,0x0(%ebp,%ebx,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
111254: ff 49 40 decl 0x40(%ecx)
++stats->frees;
111257: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
11125a: 01 79 30 add %edi,0x30(%ecx)
return( true );
11125d: b0 01 mov $0x1,%al
}
11125f: 83 c4 0c add $0xc,%esp
111262: 5b pop %ebx
111263: 5e pop %esi
111264: 5f pop %edi
111265: 5d pop %ebp
111266: c3 ret
111267: 90 nop
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
111268: b0 01 mov $0x1,%al
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
11126a: 83 c4 0c add $0xc,%esp
11126d: 5b pop %ebx
11126e: 5e pop %esi
11126f: 5f pop %edi
111270: 5d pop %ebp
111271: c3 ret
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 ) ) {
111272: f6 04 24 01 testb $0x1,(%esp)
111276: 75 4d jne 1112c5 <_Heap_Free+0x115>
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
111278: c6 44 24 0b 00 movb $0x0,0xb(%esp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
11127d: 8b 2b mov (%ebx),%ebp
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11127f: 29 eb sub %ebp,%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
111281: 39 d8 cmp %ebx,%eax
111283: 0f 87 6b ff ff ff ja 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN
111289: 39 de cmp %ebx,%esi
11128b: 0f 82 63 ff ff ff jb 1111f4 <_Heap_Free+0x44> <== 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) ) {
111291: f6 43 04 01 testb $0x1,0x4(%ebx)
111295: 0f 84 59 ff ff ff je 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
11129b: 01 fd add %edi,%ebp
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
11129d: 80 7c 24 0b 00 cmpb $0x0,0xb(%esp)
1112a2: 74 58 je 1112fc <_Heap_Free+0x14c>
uintptr_t const size = block_size + prev_size + next_block_size;
1112a4: 03 6c 24 04 add 0x4(%esp),%ebp
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1112a8: 8b 42 08 mov 0x8(%edx),%eax
1112ab: 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;
1112ae: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
1112b1: 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;
1112b4: ff 49 38 decl 0x38(%ecx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1112b7: 89 e8 mov %ebp,%eax
1112b9: 83 c8 01 or $0x1,%eax
1112bc: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
1112bf: 89 6c 1d 00 mov %ebp,0x0(%ebp,%ebx,1)
1112c3: eb 8f jmp 111254 <_Heap_Free+0xa4>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
1112c5: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
1112c8: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
1112cb: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
1112ce: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
1112d1: 89 58 0c mov %ebx,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;
1112d4: 89 f8 mov %edi,%eax
1112d6: 83 c8 01 or $0x1,%eax
1112d9: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
1112dc: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
1112e0: 89 3a mov %edi,(%edx)
/* Statistics */
++stats->free_blocks;
1112e2: 8b 41 38 mov 0x38(%ecx),%eax
1112e5: 40 inc %eax
1112e6: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
1112e9: 3b 41 3c cmp 0x3c(%ecx),%eax
1112ec: 0f 86 62 ff ff ff jbe 111254 <_Heap_Free+0xa4>
stats->max_free_blocks = stats->free_blocks;
1112f2: 89 41 3c mov %eax,0x3c(%ecx)
1112f5: e9 5a ff ff ff jmp 111254 <_Heap_Free+0xa4>
1112fa: 66 90 xchg %ax,%ax
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;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1112fc: 89 e8 mov %ebp,%eax
1112fe: 83 c8 01 or $0x1,%eax
111301: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
111304: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
111308: 89 2a mov %ebp,(%edx)
11130a: e9 45 ff ff ff jmp 111254 <_Heap_Free+0xa4>
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
11130f: c6 44 24 0b 01 movb $0x1,0xb(%esp)
111314: e9 64 ff ff ff jmp 11127d <_Heap_Free+0xcd>
00115330 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
115330: 55 push %ebp
115331: 57 push %edi
115332: 56 push %esi
115333: 53 push %ebx
115334: 8b 6c 24 14 mov 0x14(%esp),%ebp
115338: 8b 7c 24 18 mov 0x18(%esp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
11533c: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
115342: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
115349: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
115350: 8b 55 08 mov 0x8(%ebp),%edx
for(the_block = _Heap_Free_list_first(the_heap);
115353: 39 d5 cmp %edx,%ebp
115355: 74 30 je 115387 <_Heap_Get_free_information+0x57><== NEVER TAKEN
115357: bb 01 00 00 00 mov $0x1,%ebx
11535c: 31 f6 xor %esi,%esi
11535e: 31 c9 xor %ecx,%ecx
115360: eb 07 jmp 115369 <_Heap_Get_free_information+0x39>
115362: 66 90 xchg %ax,%ax
115364: 8b 77 04 mov 0x4(%edi),%esi
115367: 89 c3 mov %eax,%ebx
- 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;
115369: 8b 42 04 mov 0x4(%edx),%eax
11536c: 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;
11536f: 01 c1 add %eax,%ecx
if ( info->largest < the_size )
115371: 39 f0 cmp %esi,%eax
115373: 76 03 jbe 115378 <_Heap_Get_free_information+0x48>
info->largest = the_size;
115375: 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)
115378: 8b 52 08 mov 0x8(%edx),%edx
11537b: 8d 43 01 lea 0x1(%ebx),%eax
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
11537e: 39 d5 cmp %edx,%ebp
115380: 75 e2 jne 115364 <_Heap_Get_free_information+0x34>
115382: 89 1f mov %ebx,(%edi)
115384: 89 4f 08 mov %ecx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
115387: 5b pop %ebx
115388: 5e pop %esi
115389: 5f pop %edi
11538a: 5d pop %ebp
11538b: c3 ret
0010e818 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
10e818: 55 push %ebp
10e819: 57 push %edi
10e81a: 56 push %esi
10e81b: 53 push %ebx
10e81c: 83 ec 1c sub $0x1c,%esp
10e81f: 8b 5c 24 30 mov 0x30(%esp),%ebx
10e823: 8b 7c 24 34 mov 0x34(%esp),%edi
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
10e827: 8b 44 24 38 mov 0x38(%esp),%eax
10e82b: 85 c0 test %eax,%eax
10e82d: 0f 84 9f 00 00 00 je 10e8d2 <_Heap_Greedy_allocate+0xba>
10e833: 31 ed xor %ebp,%ebp
10e835: 31 f6 xor %esi,%esi
10e837: 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 );
10e838: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
10e83f: 00
10e840: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10e847: 00
10e848: 8b 04 af mov (%edi,%ebp,4),%eax
10e84b: 89 44 24 04 mov %eax,0x4(%esp)
10e84f: 89 1c 24 mov %ebx,(%esp)
10e852: e8 59 6d 00 00 call 1155b0 <_Heap_Allocate_aligned_with_boundary>
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
10e857: 85 c0 test %eax,%eax
10e859: 74 0f je 10e86a <_Heap_Greedy_allocate+0x52><== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10e85b: 8d 48 f8 lea -0x8(%eax),%ecx
10e85e: 31 d2 xor %edx,%edx
10e860: 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);
10e863: 29 d1 sub %edx,%ecx
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
10e865: 89 71 08 mov %esi,0x8(%ecx)
10e868: 89 ce mov %ecx,%esi
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
10e86a: 45 inc %ebp
10e86b: 3b 6c 24 38 cmp 0x38(%esp),%ebp
10e86f: 75 c7 jne 10e838 <_Heap_Greedy_allocate+0x20>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
10e871: 8b 7b 08 mov 0x8(%ebx),%edi
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
10e874: 39 fb cmp %edi,%ebx
10e876: 74 5e je 10e8d6 <_Heap_Greedy_allocate+0xbe><== NEVER TAKEN
10e878: 31 ed xor %ebp,%ebp
10e87a: eb 02 jmp 10e87e <_Heap_Greedy_allocate+0x66>
10e87c: 89 c7 mov %eax,%edi
- 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;
10e87e: 8b 47 04 mov 0x4(%edi),%eax
10e881: 83 e0 fe and $0xfffffffe,%eax
_Heap_Block_allocate(
10e884: 83 e8 08 sub $0x8,%eax
10e887: 89 44 24 0c mov %eax,0xc(%esp)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10e88b: 8d 47 08 lea 0x8(%edi),%eax
10e88e: 89 44 24 08 mov %eax,0x8(%esp)
10e892: 89 7c 24 04 mov %edi,0x4(%esp)
10e896: 89 1c 24 mov %ebx,(%esp)
10e899: e8 ce 02 00 00 call 10eb6c <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
10e89e: 89 6f 08 mov %ebp,0x8(%edi)
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
10e8a1: 8b 43 08 mov 0x8(%ebx),%eax
10e8a4: 89 fd mov %edi,%ebp
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
10e8a6: 39 c3 cmp %eax,%ebx
10e8a8: 75 d2 jne 10e87c <_Heap_Greedy_allocate+0x64>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
10e8aa: 85 f6 test %esi,%esi
10e8ac: 74 1a je 10e8c8 <_Heap_Greedy_allocate+0xb0>
10e8ae: 66 90 xchg %ax,%ax
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
10e8b0: 8b 6e 08 mov 0x8(%esi),%ebp
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10e8b3: 83 c6 08 add $0x8,%esi
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
10e8b6: 89 74 24 04 mov %esi,0x4(%esp)
10e8ba: 89 1c 24 mov %ebx,(%esp)
10e8bd: e8 ca 6e 00 00 call 11578c <_Heap_Free>
blocks = current;
}
while ( allocated_blocks != NULL ) {
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
10e8c2: 89 ee mov %ebp,%esi
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
10e8c4: 85 f6 test %esi,%esi
10e8c6: 75 e8 jne 10e8b0 <_Heap_Greedy_allocate+0x98>
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
10e8c8: 89 f8 mov %edi,%eax
10e8ca: 83 c4 1c add $0x1c,%esp
10e8cd: 5b pop %ebx
10e8ce: 5e pop %esi
10e8cf: 5f pop %edi
10e8d0: 5d pop %ebp
10e8d1: c3 ret
const uintptr_t *block_sizes,
size_t block_count
)
{
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *allocated_blocks = NULL;
10e8d2: 31 f6 xor %esi,%esi
10e8d4: eb 9b jmp 10e871 <_Heap_Greedy_allocate+0x59>
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
10e8d6: 31 ff xor %edi,%edi <== NOT EXECUTED
10e8d8: eb ea jmp 10e8c4 <_Heap_Greedy_allocate+0xac><== NOT EXECUTED
0010e8dc <_Heap_Greedy_free>:
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
10e8dc: 56 push %esi
10e8dd: 53 push %ebx
10e8de: 83 ec 14 sub $0x14,%esp
10e8e1: 8b 74 24 20 mov 0x20(%esp),%esi
10e8e5: 8b 44 24 24 mov 0x24(%esp),%eax
while ( blocks != NULL ) {
10e8e9: 85 c0 test %eax,%eax
10e8eb: 74 1b je 10e908 <_Heap_Greedy_free+0x2c><== NEVER TAKEN
10e8ed: 8d 76 00 lea 0x0(%esi),%esi
Heap_Block *current = blocks;
blocks = blocks->next;
10e8f0: 8b 58 08 mov 0x8(%eax),%ebx
10e8f3: 83 c0 08 add $0x8,%eax
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
10e8f6: 89 44 24 04 mov %eax,0x4(%esp)
10e8fa: 89 34 24 mov %esi,(%esp)
10e8fd: e8 8a 6e 00 00 call 11578c <_Heap_Free>
)
{
while ( blocks != NULL ) {
Heap_Block *current = blocks;
blocks = blocks->next;
10e902: 89 d8 mov %ebx,%eax
void _Heap_Greedy_free(
Heap_Control *heap,
Heap_Block *blocks
)
{
while ( blocks != NULL ) {
10e904: 85 db test %ebx,%ebx
10e906: 75 e8 jne 10e8f0 <_Heap_Greedy_free+0x14>
Heap_Block *current = blocks;
blocks = blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
}
10e908: 83 c4 14 add $0x14,%esp
10e90b: 5b pop %ebx
10e90c: 5e pop %esi
10e90d: c3 ret
001153e0 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
1153e0: 55 push %ebp
1153e1: 57 push %edi
1153e2: 56 push %esi
1153e3: 53 push %ebx
1153e4: 83 ec 1c sub $0x1c,%esp
1153e7: 8b 54 24 30 mov 0x30(%esp),%edx
1153eb: 8b 7c 24 34 mov 0x34(%esp),%edi
1153ef: 8b 74 24 38 mov 0x38(%esp),%esi
Heap_Block *current = heap->first_block;
1153f3: 8b 42 20 mov 0x20(%edx),%eax
Heap_Block *end = heap->last_block;
1153f6: 8b 5a 24 mov 0x24(%edx),%ebx
bool stop = false;
while ( !stop && current != end ) {
1153f9: 39 d8 cmp %ebx,%eax
1153fb: 75 09 jne 115406 <_Heap_Iterate+0x26> <== ALWAYS TAKEN
1153fd: eb 2b jmp 11542a <_Heap_Iterate+0x4a> <== NOT EXECUTED
1153ff: 90 nop <== NOT EXECUTED
115400: 89 e8 mov %ebp,%eax
115402: 39 eb cmp %ebp,%ebx
115404: 74 24 je 11542a <_Heap_Iterate+0x4a>
115406: 8b 50 04 mov 0x4(%eax),%edx
115409: 83 e2 fe and $0xfffffffe,%edx
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11540c: 8d 2c 10 lea (%eax,%edx,1),%ebp
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
11540f: 89 74 24 0c mov %esi,0xc(%esp)
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;
115413: 8b 4d 04 mov 0x4(%ebp),%ecx
115416: 83 e1 01 and $0x1,%ecx
115419: 89 4c 24 08 mov %ecx,0x8(%esp)
11541d: 89 54 24 04 mov %edx,0x4(%esp)
115421: 89 04 24 mov %eax,(%esp)
115424: ff d7 call *%edi
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
115426: 84 c0 test %al,%al
115428: 74 d6 je 115400 <_Heap_Iterate+0x20> <== ALWAYS TAKEN
stop = (*visitor)( current, size, used, visitor_arg );
current = next;
}
}
11542a: 83 c4 1c add $0x1c,%esp
11542d: 5b pop %ebx
11542e: 5e pop %esi
11542f: 5f pop %edi
115430: 5d pop %ebp
115431: c3 ret
00111428 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
111428: 56 push %esi
111429: 53 push %ebx
11142a: 8b 5c 24 0c mov 0xc(%esp),%ebx
11142e: 8b 74 24 10 mov 0x10(%esp),%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
111432: 8d 4e f8 lea -0x8(%esi),%ecx
111435: 89 f0 mov %esi,%eax
111437: 31 d2 xor %edx,%edx
111439: 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);
11143c: 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
11143e: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
111441: 39 c1 cmp %eax,%ecx
111443: 72 07 jb 11144c <_Heap_Size_of_alloc_area+0x24>
111445: 8b 53 24 mov 0x24(%ebx),%edx
111448: 39 d1 cmp %edx,%ecx
11144a: 76 08 jbe 111454 <_Heap_Size_of_alloc_area+0x2c><== ALWAYS TAKEN
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
11144c: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11144e: 5b pop %ebx
11144f: 5e pop %esi
111450: c3 ret
111451: 8d 76 00 lea 0x0(%esi),%esi
- 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;
111454: 8b 59 04 mov 0x4(%ecx),%ebx
111457: 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);
11145a: 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;
11145c: 39 c8 cmp %ecx,%eax
11145e: 77 ec ja 11144c <_Heap_Size_of_alloc_area+0x24><== NEVER TAKEN
111460: 39 ca cmp %ecx,%edx
111462: 72 e8 jb 11144c <_Heap_Size_of_alloc_area+0x24><== 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 )
111464: f6 41 04 01 testb $0x1,0x4(%ecx)
111468: 74 e2 je 11144c <_Heap_Size_of_alloc_area+0x24><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11146a: 29 f1 sub %esi,%ecx
11146c: 8d 51 04 lea 0x4(%ecx),%edx
11146f: 8b 44 24 14 mov 0x14(%esp),%eax
111473: 89 10 mov %edx,(%eax)
return true;
111475: b0 01 mov $0x1,%al
}
111477: 5b pop %ebx
111478: 5e pop %esi
111479: c3 ret
0010d4bc <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10d4bc: 55 push %ebp
10d4bd: 57 push %edi
10d4be: 56 push %esi
10d4bf: 53 push %ebx
10d4c0: 83 ec 5c sub $0x5c,%esp
10d4c3: 8b 5c 24 70 mov 0x70(%esp),%ebx
uintptr_t const page_size = heap->page_size;
10d4c7: 8b 4b 10 mov 0x10(%ebx),%ecx
10d4ca: 89 4c 24 30 mov %ecx,0x30(%esp)
uintptr_t const min_block_size = heap->min_block_size;
10d4ce: 8b 43 14 mov 0x14(%ebx),%eax
10d4d1: 89 44 24 38 mov %eax,0x38(%esp)
Heap_Block *const first_block = heap->first_block;
10d4d5: 8b 4b 20 mov 0x20(%ebx),%ecx
10d4d8: 89 4c 24 34 mov %ecx,0x34(%esp)
Heap_Block *const last_block = heap->last_block;
10d4dc: 8b 4b 24 mov 0x24(%ebx),%ecx
10d4df: 89 4c 24 3c mov %ecx,0x3c(%esp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10d4e3: 80 7c 24 78 00 cmpb $0x0,0x78(%esp)
10d4e8: 74 1a je 10d504 <_Heap_Walk+0x48>
10d4ea: bd 74 d4 10 00 mov $0x10d474,%ebp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d4ef: 83 3d 00 2a 13 00 03 cmpl $0x3,0x132a00
10d4f6: 74 1a je 10d512 <_Heap_Walk+0x56> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10d4f8: b0 01 mov $0x1,%al
}
10d4fa: 83 c4 5c add $0x5c,%esp
10d4fd: 5b pop %ebx
10d4fe: 5e pop %esi
10d4ff: 5f pop %edi
10d500: 5d pop %ebp
10d501: c3 ret
10d502: 66 90 xchg %ax,%ax
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;
10d504: bd 70 d4 10 00 mov $0x10d470,%ebp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d509: 83 3d 00 2a 13 00 03 cmpl $0x3,0x132a00
10d510: 75 e6 jne 10d4f8 <_Heap_Walk+0x3c>
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)(
10d512: 8b 43 0c mov 0xc(%ebx),%eax
10d515: 89 44 24 28 mov %eax,0x28(%esp)
10d519: 8b 43 08 mov 0x8(%ebx),%eax
10d51c: 89 44 24 24 mov %eax,0x24(%esp)
10d520: 8b 4c 24 3c mov 0x3c(%esp),%ecx
10d524: 89 4c 24 20 mov %ecx,0x20(%esp)
10d528: 8b 4c 24 34 mov 0x34(%esp),%ecx
10d52c: 89 4c 24 1c mov %ecx,0x1c(%esp)
10d530: 8b 43 1c mov 0x1c(%ebx),%eax
10d533: 89 44 24 18 mov %eax,0x18(%esp)
10d537: 8b 43 18 mov 0x18(%ebx),%eax
10d53a: 89 44 24 14 mov %eax,0x14(%esp)
10d53e: 8b 44 24 38 mov 0x38(%esp),%eax
10d542: 89 44 24 10 mov %eax,0x10(%esp)
10d546: 8b 4c 24 30 mov 0x30(%esp),%ecx
10d54a: 89 4c 24 0c mov %ecx,0xc(%esp)
10d54e: c7 44 24 08 50 28 12 movl $0x122850,0x8(%esp)
10d555: 00
10d556: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10d55d: 00
10d55e: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d562: 89 0c 24 mov %ecx,(%esp)
10d565: ff d5 call *%ebp
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
10d567: 8b 4c 24 30 mov 0x30(%esp),%ecx
10d56b: 85 c9 test %ecx,%ecx
10d56d: 0f 84 a1 00 00 00 je 10d614 <_Heap_Walk+0x158>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10d573: f6 44 24 30 03 testb $0x3,0x30(%esp)
10d578: 0f 85 b6 00 00 00 jne 10d634 <_Heap_Walk+0x178>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d57e: 8b 44 24 38 mov 0x38(%esp),%eax
10d582: 31 d2 xor %edx,%edx
10d584: f7 74 24 30 divl 0x30(%esp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10d588: 85 d2 test %edx,%edx
10d58a: 0f 85 cc 00 00 00 jne 10d65c <_Heap_Walk+0x1a0>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10d590: 8b 44 24 34 mov 0x34(%esp),%eax
10d594: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d597: 31 d2 xor %edx,%edx
10d599: f7 74 24 30 divl 0x30(%esp)
);
return false;
}
if (
10d59d: 85 d2 test %edx,%edx
10d59f: 0f 85 df 00 00 00 jne 10d684 <_Heap_Walk+0x1c8>
block = next_block;
} while ( block != first_block );
return true;
}
10d5a5: 8b 44 24 34 mov 0x34(%esp),%eax
10d5a9: 8b 48 04 mov 0x4(%eax),%ecx
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10d5ac: f6 c1 01 test $0x1,%cl
10d5af: 0f 84 f7 00 00 00 je 10d6ac <_Heap_Walk+0x1f0>
- 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;
10d5b5: 8b 54 24 3c mov 0x3c(%esp),%edx
10d5b9: 8b 42 04 mov 0x4(%edx),%eax
10d5bc: 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);
10d5bf: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10d5c1: f6 40 04 01 testb $0x1,0x4(%eax)
10d5c5: 74 2d je 10d5f4 <_Heap_Walk+0x138>
);
return false;
}
if (
10d5c7: 39 44 24 34 cmp %eax,0x34(%esp)
10d5cb: 0f 84 fb 00 00 00 je 10d6cc <_Heap_Walk+0x210>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10d5d1: c7 44 24 08 6c 29 12 movl $0x12296c,0x8(%esp)
10d5d8: 00
10d5d9: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d5e0: 00
10d5e1: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d5e5: 89 0c 24 mov %ecx,(%esp)
10d5e8: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d5ea: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d5ec: 83 c4 5c add $0x5c,%esp
10d5ef: 5b pop %ebx
10d5f0: 5e pop %esi
10d5f1: 5f pop %edi
10d5f2: 5d pop %ebp
10d5f3: c3 ret
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10d5f4: c7 44 24 08 05 28 12 movl $0x122805,0x8(%esp)
10d5fb: 00
10d5fc: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d603: 00
10d604: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d608: 89 0c 24 mov %ecx,(%esp)
10d60b: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d60d: 31 c0 xor %eax,%eax
10d60f: eb db jmp 10d5ec <_Heap_Walk+0x130>
10d611: 8d 76 00 lea 0x0(%esi),%esi
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
10d614: c7 44 24 08 d4 27 12 movl $0x1227d4,0x8(%esp)
10d61b: 00
10d61c: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d623: 00
10d624: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d628: 89 0c 24 mov %ecx,(%esp)
10d62b: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d62d: 31 c0 xor %eax,%eax
10d62f: eb bb jmp 10d5ec <_Heap_Walk+0x130>
10d631: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10d634: 8b 4c 24 30 mov 0x30(%esp),%ecx
10d638: 89 4c 24 0c mov %ecx,0xc(%esp)
10d63c: c7 44 24 08 e7 27 12 movl $0x1227e7,0x8(%esp)
10d643: 00
10d644: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d64b: 00
10d64c: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d650: 89 0c 24 mov %ecx,(%esp)
10d653: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d655: 31 c0 xor %eax,%eax
10d657: eb 93 jmp 10d5ec <_Heap_Walk+0x130>
10d659: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10d65c: 8b 44 24 38 mov 0x38(%esp),%eax
10d660: 89 44 24 0c mov %eax,0xc(%esp)
10d664: c7 44 24 08 e4 28 12 movl $0x1228e4,0x8(%esp)
10d66b: 00
10d66c: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d673: 00
10d674: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d678: 89 0c 24 mov %ecx,(%esp)
10d67b: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d67d: 31 c0 xor %eax,%eax
10d67f: e9 68 ff ff ff jmp 10d5ec <_Heap_Walk+0x130>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10d684: 8b 4c 24 34 mov 0x34(%esp),%ecx
10d688: 89 4c 24 0c mov %ecx,0xc(%esp)
10d68c: c7 44 24 08 08 29 12 movl $0x122908,0x8(%esp)
10d693: 00
10d694: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d69b: 00
10d69c: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d6a0: 89 0c 24 mov %ecx,(%esp)
10d6a3: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d6a5: 31 c0 xor %eax,%eax
10d6a7: e9 40 ff ff ff jmp 10d5ec <_Heap_Walk+0x130>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10d6ac: c7 44 24 08 3c 29 12 movl $0x12293c,0x8(%esp)
10d6b3: 00
10d6b4: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d6bb: 00
10d6bc: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d6c0: 89 0c 24 mov %ecx,(%esp)
10d6c3: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d6c5: 31 c0 xor %eax,%eax
10d6c7: e9 20 ff ff ff jmp 10d5ec <_Heap_Walk+0x130>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10d6cc: 8b 43 10 mov 0x10(%ebx),%eax
10d6cf: 89 44 24 40 mov %eax,0x40(%esp)
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
10d6d3: 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 ) {
10d6d6: 39 f3 cmp %esi,%ebx
10d6d8: 0f 84 f3 03 00 00 je 10dad1 <_Heap_Walk+0x615>
block = next_block;
} while ( block != first_block );
return true;
}
10d6de: 8b 43 20 mov 0x20(%ebx),%eax
10d6e1: 89 44 24 48 mov %eax,0x48(%esp)
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;
10d6e5: 39 f0 cmp %esi,%eax
10d6e7: 76 27 jbe 10d710 <_Heap_Walk+0x254> <== ALWAYS TAKEN
10d6e9: 8d 76 00 lea 0x0(%esi),%esi
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10d6ec: 89 74 24 0c mov %esi,0xc(%esp)
10d6f0: c7 44 24 08 9c 29 12 movl $0x12299c,0x8(%esp)
10d6f7: 00
10d6f8: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d6ff: 00
10d700: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d704: 89 0c 24 mov %ecx,(%esp)
10d707: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d709: 31 c0 xor %eax,%eax
10d70b: e9 dc fe ff ff jmp 10d5ec <_Heap_Walk+0x130>
10d710: 8b 53 24 mov 0x24(%ebx),%edx
10d713: 89 54 24 44 mov %edx,0x44(%esp)
10d717: 39 f2 cmp %esi,%edx
10d719: 72 d1 jb 10d6ec <_Heap_Walk+0x230> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10d71b: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d71e: 31 d2 xor %edx,%edx
10d720: f7 74 24 40 divl 0x40(%esp)
);
return false;
}
if (
10d724: 85 d2 test %edx,%edx
10d726: 0f 85 a2 00 00 00 jne 10d7ce <_Heap_Walk+0x312> <== 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;
10d72c: 8b 46 04 mov 0x4(%esi),%eax
10d72f: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d732: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10d737: 75 71 jne 10d7aa <_Heap_Walk+0x2ee> <== NEVER TAKEN
10d739: 89 da mov %ebx,%edx
10d73b: 89 f7 mov %esi,%edi
10d73d: 89 4c 24 4c mov %ecx,0x4c(%esp)
10d741: 8b 4c 24 48 mov 0x48(%esp),%ecx
10d745: eb 34 jmp 10d77b <_Heap_Walk+0x2bf>
10d747: 90 nop
return false;
}
prev_block = free_block;
free_block = free_block->next;
10d748: 8b 76 08 mov 0x8(%esi),%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 ) {
10d74b: 39 f3 cmp %esi,%ebx
10d74d: 0f 84 9f 00 00 00 je 10d7f2 <_Heap_Walk+0x336>
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;
10d753: 39 ce cmp %ecx,%esi
10d755: 72 95 jb 10d6ec <_Heap_Walk+0x230>
10d757: 3b 74 24 44 cmp 0x44(%esp),%esi
10d75b: 77 8f ja 10d6ec <_Heap_Walk+0x230> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10d75d: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d760: 31 d2 xor %edx,%edx
10d762: f7 74 24 40 divl 0x40(%esp)
);
return false;
}
if (
10d766: 85 d2 test %edx,%edx
10d768: 75 64 jne 10d7ce <_Heap_Walk+0x312>
10d76a: 89 fa mov %edi,%edx
- 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;
10d76c: 8b 46 04 mov 0x4(%esi),%eax
10d76f: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d772: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10d777: 75 31 jne 10d7aa <_Heap_Walk+0x2ee>
10d779: 89 f7 mov %esi,%edi
);
return false;
}
if ( free_block->prev != prev_block ) {
10d77b: 8b 46 0c mov 0xc(%esi),%eax
10d77e: 39 d0 cmp %edx,%eax
10d780: 74 c6 je 10d748 <_Heap_Walk+0x28c>
(*printer)(
10d782: 89 44 24 10 mov %eax,0x10(%esp)
10d786: 89 74 24 0c mov %esi,0xc(%esp)
10d78a: c7 44 24 08 ec 29 12 movl $0x1229ec,0x8(%esp)
10d791: 00
10d792: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d799: 00
10d79a: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d79e: 89 0c 24 mov %ecx,(%esp)
10d7a1: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d7a3: 31 c0 xor %eax,%eax
10d7a5: e9 42 fe ff ff jmp 10d5ec <_Heap_Walk+0x130>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
10d7aa: 89 74 24 0c mov %esi,0xc(%esp)
10d7ae: c7 44 24 08 1a 28 12 movl $0x12281a,0x8(%esp)
10d7b5: 00
10d7b6: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d7bd: 00
10d7be: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d7c2: 89 0c 24 mov %ecx,(%esp)
10d7c5: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d7c7: 31 c0 xor %eax,%eax
10d7c9: e9 1e fe ff ff jmp 10d5ec <_Heap_Walk+0x130>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10d7ce: 89 74 24 0c mov %esi,0xc(%esp)
10d7d2: c7 44 24 08 bc 29 12 movl $0x1229bc,0x8(%esp)
10d7d9: 00
10d7da: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d7e1: 00
10d7e2: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d7e6: 89 0c 24 mov %ecx,(%esp)
10d7e9: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d7eb: 31 c0 xor %eax,%eax
10d7ed: e9 fa fd ff ff jmp 10d5ec <_Heap_Walk+0x130>
10d7f2: 8b 4c 24 4c mov 0x4c(%esp),%ecx
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d7f6: 8b 74 24 34 mov 0x34(%esp),%esi
10d7fa: 89 6c 24 44 mov %ebp,0x44(%esp)
10d7fe: 8b 44 24 48 mov 0x48(%esp),%eax
10d802: 89 dd mov %ebx,%ebp
10d804: 89 cb mov %ecx,%ebx
10d806: 83 e3 fe and $0xfffffffe,%ebx
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;
10d809: 83 e1 01 and $0x1,%ecx
10d80c: 89 4c 24 40 mov %ecx,0x40(%esp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10d810: 8d 3c 33 lea (%ebx,%esi,1),%edi
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;
10d813: 39 f8 cmp %edi,%eax
10d815: 76 2d jbe 10d844 <_Heap_Walk+0x388> <== ALWAYS TAKEN
10d817: 8b 6c 24 44 mov 0x44(%esp),%ebp
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)(
10d81b: 89 7c 24 10 mov %edi,0x10(%esp)
10d81f: 89 74 24 0c mov %esi,0xc(%esp)
10d823: c7 44 24 08 20 2a 12 movl $0x122a20,0x8(%esp)
10d82a: 00
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10d82b: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d832: 00
10d833: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d837: 89 0c 24 mov %ecx,(%esp)
10d83a: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10d83c: 31 c0 xor %eax,%eax
10d83e: e9 a9 fd ff ff jmp 10d5ec <_Heap_Walk+0x130>
10d843: 90 nop
10d844: 39 7d 24 cmp %edi,0x24(%ebp)
10d847: 72 ce jb 10d817 <_Heap_Walk+0x35b>
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;
10d849: 3b 74 24 3c cmp 0x3c(%esp),%esi
10d84d: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d850: 89 d8 mov %ebx,%eax
10d852: 31 d2 xor %edx,%edx
10d854: f7 74 24 30 divl 0x30(%esp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10d858: 85 d2 test %edx,%edx
10d85a: 74 5c je 10d8b8 <_Heap_Walk+0x3fc>
10d85c: 84 c9 test %cl,%cl
10d85e: 0f 85 54 02 00 00 jne 10dab8 <_Heap_Walk+0x5fc>
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10d864: f6 47 04 01 testb $0x1,0x4(%edi)
10d868: 0f 84 e6 00 00 00 je 10d954 <_Heap_Walk+0x498>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10d86e: 8b 44 24 40 mov 0x40(%esp),%eax
10d872: 85 c0 test %eax,%eax
10d874: 0f 84 aa 00 00 00 je 10d924 <_Heap_Walk+0x468>
(*printer)(
10d87a: 89 5c 24 10 mov %ebx,0x10(%esp)
10d87e: 89 74 24 0c mov %esi,0xc(%esp)
10d882: c7 44 24 08 36 28 12 movl $0x122836,0x8(%esp)
10d889: 00
10d88a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10d891: 00
10d892: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d896: 89 0c 24 mov %ecx,(%esp)
10d899: 8b 4c 24 44 mov 0x44(%esp),%ecx
10d89d: ff d1 call *%ecx
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10d89f: 39 7c 24 34 cmp %edi,0x34(%esp)
10d8a3: 0f 84 4f fc ff ff je 10d4f8 <_Heap_Walk+0x3c>
10d8a9: 8b 4f 04 mov 0x4(%edi),%ecx
10d8ac: 8b 45 20 mov 0x20(%ebp),%eax
10d8af: 89 fe mov %edi,%esi
10d8b1: e9 4e ff ff ff jmp 10d804 <_Heap_Walk+0x348>
10d8b6: 66 90 xchg %ax,%ax
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10d8b8: 39 5c 24 38 cmp %ebx,0x38(%esp)
10d8bc: 76 3a jbe 10d8f8 <_Heap_Walk+0x43c>
10d8be: 84 c9 test %cl,%cl
10d8c0: 74 a2 je 10d864 <_Heap_Walk+0x3a8> <== NEVER TAKEN
10d8c2: 8b 6c 24 44 mov 0x44(%esp),%ebp
(*printer)(
10d8c6: 8b 44 24 38 mov 0x38(%esp),%eax
10d8ca: 89 44 24 14 mov %eax,0x14(%esp)
10d8ce: 89 5c 24 10 mov %ebx,0x10(%esp)
10d8d2: 89 74 24 0c mov %esi,0xc(%esp)
10d8d6: c7 44 24 08 80 2a 12 movl $0x122a80,0x8(%esp)
10d8dd: 00
10d8de: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10d8e5: 00
10d8e6: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d8ea: 89 0c 24 mov %ecx,(%esp)
10d8ed: ff d5 call *%ebp
block,
block_size,
min_block_size
);
return false;
10d8ef: 31 c0 xor %eax,%eax
10d8f1: e9 04 fc ff ff jmp 10d4fa <_Heap_Walk+0x3e>
10d8f6: 66 90 xchg %ax,%ax
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10d8f8: 39 fe cmp %edi,%esi
10d8fa: 0f 82 64 ff ff ff jb 10d864 <_Heap_Walk+0x3a8>
10d900: 84 c9 test %cl,%cl
10d902: 0f 84 5c ff ff ff je 10d864 <_Heap_Walk+0x3a8>
10d908: 8b 6c 24 44 mov 0x44(%esp),%ebp
(*printer)(
10d90c: 89 7c 24 10 mov %edi,0x10(%esp)
10d910: 89 74 24 0c mov %esi,0xc(%esp)
10d914: c7 44 24 08 ac 2a 12 movl $0x122aac,0x8(%esp)
10d91b: 00
10d91c: e9 0a ff ff ff jmp 10d82b <_Heap_Walk+0x36f>
10d921: 8d 76 00 lea 0x0(%esi),%esi
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10d924: 8b 06 mov (%esi),%eax
10d926: 89 44 24 14 mov %eax,0x14(%esp)
10d92a: 89 5c 24 10 mov %ebx,0x10(%esp)
10d92e: 89 74 24 0c mov %esi,0xc(%esp)
10d932: c7 44 24 08 84 2b 12 movl $0x122b84,0x8(%esp)
10d939: 00
10d93a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10d941: 00
10d942: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d946: 89 0c 24 mov %ecx,(%esp)
10d949: 8b 4c 24 44 mov 0x44(%esp),%ecx
10d94d: ff d1 call *%ecx
10d94f: e9 4b ff ff ff jmp 10d89f <_Heap_Walk+0x3e3>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
10d954: 8b 4d 08 mov 0x8(%ebp),%ecx
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
10d957: 8b 56 08 mov 0x8(%esi),%edx
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)(
10d95a: 39 55 0c cmp %edx,0xc(%ebp)
10d95d: 0f 84 fd 00 00 00 je 10da60 <_Heap_Walk+0x5a4>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10d963: 39 d5 cmp %edx,%ebp
10d965: 0f 84 05 01 00 00 je 10da70 <_Heap_Walk+0x5b4>
10d96b: c7 44 24 48 41 26 12 movl $0x122641,0x48(%esp)
10d972: 00
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 ?
10d973: 8b 46 0c mov 0xc(%esi),%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)(
10d976: 39 c1 cmp %eax,%ecx
10d978: 0f 84 d2 00 00 00 je 10da50 <_Heap_Walk+0x594>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d97e: 39 c5 cmp %eax,%ebp
10d980: 0f 84 fa 00 00 00 je 10da80 <_Heap_Walk+0x5c4>
10d986: c7 44 24 4c 41 26 12 movl $0x122641,0x4c(%esp)
10d98d: 00
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)(
10d98e: 8b 4c 24 48 mov 0x48(%esp),%ecx
10d992: 89 4c 24 20 mov %ecx,0x20(%esp)
10d996: 89 54 24 1c mov %edx,0x1c(%esp)
10d99a: 8b 54 24 4c mov 0x4c(%esp),%edx
10d99e: 89 54 24 18 mov %edx,0x18(%esp)
10d9a2: 89 44 24 14 mov %eax,0x14(%esp)
10d9a6: 89 5c 24 10 mov %ebx,0x10(%esp)
10d9aa: 89 74 24 0c mov %esi,0xc(%esp)
10d9ae: c7 44 24 08 e0 2a 12 movl $0x122ae0,0x8(%esp)
10d9b5: 00
10d9b6: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10d9bd: 00
10d9be: 8b 4c 24 74 mov 0x74(%esp),%ecx
10d9c2: 89 0c 24 mov %ecx,(%esp)
10d9c5: 8b 4c 24 44 mov 0x44(%esp),%ecx
10d9c9: ff d1 call *%ecx
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
10d9cb: 8b 07 mov (%edi),%eax
10d9cd: 39 c3 cmp %eax,%ebx
10d9cf: 75 4b jne 10da1c <_Heap_Walk+0x560>
);
return false;
}
if ( !prev_used ) {
10d9d1: 8b 54 24 40 mov 0x40(%esp),%edx
10d9d5: 85 d2 test %edx,%edx
10d9d7: 0f 84 b3 00 00 00 je 10da90 <_Heap_Walk+0x5d4>
10d9dd: 8b 45 08 mov 0x8(%ebp),%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 ) {
10d9e0: 39 c5 cmp %eax,%ebp
10d9e2: 74 0f je 10d9f3 <_Heap_Walk+0x537> <== NEVER TAKEN
if ( free_block == block ) {
10d9e4: 39 c6 cmp %eax,%esi
10d9e6: 0f 84 b3 fe ff ff je 10d89f <_Heap_Walk+0x3e3>
return true;
}
free_block = free_block->next;
10d9ec: 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 ) {
10d9ef: 39 c5 cmp %eax,%ebp
10d9f1: 75 f1 jne 10d9e4 <_Heap_Walk+0x528>
10d9f3: 8b 6c 24 44 mov 0x44(%esp),%ebp
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d9f7: 89 74 24 0c mov %esi,0xc(%esp)
10d9fb: c7 44 24 08 ac 2b 12 movl $0x122bac,0x8(%esp)
10da02: 00
10da03: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10da0a: 00
10da0b: 8b 4c 24 74 mov 0x74(%esp),%ecx
10da0f: 89 0c 24 mov %ecx,(%esp)
10da12: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10da14: 31 c0 xor %eax,%eax
10da16: e9 d1 fb ff ff jmp 10d5ec <_Heap_Walk+0x130>
10da1b: 90 nop
10da1c: 8b 6c 24 44 mov 0x44(%esp),%ebp
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10da20: 89 7c 24 18 mov %edi,0x18(%esp)
10da24: 89 44 24 14 mov %eax,0x14(%esp)
10da28: 89 5c 24 10 mov %ebx,0x10(%esp)
10da2c: 89 74 24 0c mov %esi,0xc(%esp)
10da30: c7 44 24 08 18 2b 12 movl $0x122b18,0x8(%esp)
10da37: 00
10da38: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10da3f: 00
10da40: 8b 4c 24 74 mov 0x74(%esp),%ecx
10da44: 89 0c 24 mov %ecx,(%esp)
10da47: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10da49: 31 c0 xor %eax,%eax
10da4b: e9 9c fb ff ff jmp 10d5ec <_Heap_Walk+0x130>
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)(
10da50: c7 44 24 4c ba 27 12 movl $0x1227ba,0x4c(%esp)
10da57: 00
10da58: e9 31 ff ff ff jmp 10d98e <_Heap_Walk+0x4d2>
10da5d: 8d 76 00 lea 0x0(%esi),%esi
10da60: c7 44 24 48 a1 27 12 movl $0x1227a1,0x48(%esp)
10da67: 00
10da68: e9 06 ff ff ff jmp 10d973 <_Heap_Walk+0x4b7>
10da6d: 8d 76 00 lea 0x0(%esi),%esi
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10da70: c7 44 24 48 b0 27 12 movl $0x1227b0,0x48(%esp)
10da77: 00
10da78: e9 f6 fe ff ff jmp 10d973 <_Heap_Walk+0x4b7>
10da7d: 8d 76 00 lea 0x0(%esi),%esi
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10da80: c7 44 24 4c ca 27 12 movl $0x1227ca,0x4c(%esp)
10da87: 00
10da88: e9 01 ff ff ff jmp 10d98e <_Heap_Walk+0x4d2>
10da8d: 8d 76 00 lea 0x0(%esi),%esi
10da90: 8b 6c 24 44 mov 0x44(%esp),%ebp
return false;
}
if ( !prev_used ) {
(*printer)(
10da94: 89 74 24 0c mov %esi,0xc(%esp)
10da98: c7 44 24 08 54 2b 12 movl $0x122b54,0x8(%esp)
10da9f: 00
10daa0: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10daa7: 00
10daa8: 8b 4c 24 74 mov 0x74(%esp),%ecx
10daac: 89 0c 24 mov %ecx,(%esp)
10daaf: ff d5 call *%ebp
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
10dab1: 31 c0 xor %eax,%eax
10dab3: e9 34 fb ff ff jmp 10d5ec <_Heap_Walk+0x130>
10dab8: 8b 6c 24 44 mov 0x44(%esp),%ebp
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10dabc: 89 5c 24 10 mov %ebx,0x10(%esp)
10dac0: 89 74 24 0c mov %esi,0xc(%esp)
10dac4: c7 44 24 08 50 2a 12 movl $0x122a50,0x8(%esp)
10dacb: 00
10dacc: e9 5a fd ff ff jmp 10d82b <_Heap_Walk+0x36f>
10dad1: 8b 53 20 mov 0x20(%ebx),%edx
10dad4: 89 54 24 48 mov %edx,0x48(%esp)
10dad8: e9 19 fd ff ff jmp 10d7f6 <_Heap_Walk+0x33a>
0010c158 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10c158: 53 push %ebx
10c159: 83 ec 18 sub $0x18,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10c15c: 31 db xor %ebx,%ebx
10c15e: a1 40 f9 12 00 mov 0x12f940,%eax
10c163: 85 c0 test %eax,%eax
10c165: 74 22 je 10c189 <_IO_Initialize_all_drivers+0x31><== NEVER TAKEN
10c167: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10c168: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10c16f: 00
10c170: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10c177: 00
10c178: 89 1c 24 mov %ebx,(%esp)
10c17b: e8 30 4a 00 00 call 110bb0 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10c180: 43 inc %ebx
10c181: 39 1d 40 f9 12 00 cmp %ebx,0x12f940
10c187: 77 df ja 10c168 <_IO_Initialize_all_drivers+0x10>
(void) rtems_io_initialize( major, 0, NULL );
}
10c189: 83 c4 18 add $0x18,%esp
10c18c: 5b pop %ebx
10c18d: c3 ret
0010c0d0 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
10c0d0: 55 push %ebp
10c0d1: 57 push %edi
10c0d2: 56 push %esi
10c0d3: 53 push %ebx
10c0d4: 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;
10c0d7: 8b 1d a0 b1 12 00 mov 0x12b1a0,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10c0dd: 8b 35 9c b1 12 00 mov 0x12b19c,%esi
number_of_drivers = Configuration.maximum_drivers;
10c0e3: 8b 3d 98 b1 12 00 mov 0x12b198,%edi
/*
* 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 )
10c0e9: 39 fe cmp %edi,%esi
10c0eb: 73 57 jae 10c144 <_IO_Manager_initialization+0x74>
* 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(
10c0ed: 8d 2c 7f lea (%edi,%edi,2),%ebp
10c0f0: c1 e5 03 shl $0x3,%ebp
10c0f3: 89 2c 24 mov %ebp,(%esp)
10c0f6: e8 49 2b 00 00 call 10ec44 <_Workspace_Allocate_or_fatal_error>
10c0fb: 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 *)
10c0fd: a3 44 f9 12 00 mov %eax,0x12f944
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10c102: 89 3d 40 f9 12 00 mov %edi,0x12f940
memset(
10c108: 31 c0 xor %eax,%eax
10c10a: 89 d7 mov %edx,%edi
10c10c: 89 e9 mov %ebp,%ecx
10c10e: 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++ )
10c110: 85 f6 test %esi,%esi
10c112: 74 28 je 10c13c <_IO_Manager_initialization+0x6c><== NEVER TAKEN
10c114: 8b 15 44 f9 12 00 mov 0x12f944,%edx
* registration. The driver table is now allocated in the
* workspace.
*
*/
void _IO_Manager_initialization(void)
10c11a: 8d 04 76 lea (%esi,%esi,2),%eax
10c11d: 8d 2c c5 00 00 00 00 lea 0x0(,%eax,8),%ebp
10c124: 31 c0 xor %eax,%eax
10c126: 66 90 xchg %ax,%ax
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
10c128: 8d 3c 02 lea (%edx,%eax,1),%edi
10c12b: 8d 34 03 lea (%ebx,%eax,1),%esi
10c12e: b9 06 00 00 00 mov $0x6,%ecx
10c133: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10c135: 83 c0 18 add $0x18,%eax
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10c138: 39 e8 cmp %ebp,%eax
10c13a: 75 ec jne 10c128 <_IO_Manager_initialization+0x58>
_IO_Driver_address_table[index] = driver_table[index];
}
10c13c: 83 c4 1c add $0x1c,%esp
10c13f: 5b pop %ebx
10c140: 5e pop %esi
10c141: 5f pop %edi
10c142: 5d pop %ebp
10c143: 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;
10c144: 89 1d 44 f9 12 00 mov %ebx,0x12f944
_IO_Number_of_drivers = number_of_drivers;
10c14a: 89 35 40 f9 12 00 mov %esi,0x12f940
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10c150: 83 c4 1c add $0x1c,%esp
10c153: 5b pop %ebx
10c154: 5e pop %esi
10c155: 5f pop %edi
10c156: 5d pop %ebp
10c157: c3 ret
0010cbc0 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cbc0: 53 push %ebx
10cbc1: 83 ec 18 sub $0x18,%esp
10cbc4: 8b 54 24 20 mov 0x20(%esp),%edx
10cbc8: 8b 44 24 24 mov 0x24(%esp),%eax
10cbcc: 8b 5c 24 28 mov 0x28(%esp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10cbd0: 89 15 84 f6 12 00 mov %edx,0x12f684
_Internal_errors_What_happened.is_internal = is_internal;
10cbd6: a2 88 f6 12 00 mov %al,0x12f688
_Internal_errors_What_happened.the_error = the_error;
10cbdb: 89 1d 8c f6 12 00 mov %ebx,0x12f68c
_User_extensions_Fatal( the_source, is_internal, the_error );
10cbe1: 89 5c 24 08 mov %ebx,0x8(%esp)
10cbe5: 0f b6 c0 movzbl %al,%eax
10cbe8: 89 44 24 04 mov %eax,0x4(%esp)
10cbec: 89 14 24 mov %edx,(%esp)
10cbef: e8 50 1c 00 00 call 10e844 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10cbf4: c7 05 60 f7 12 00 05 movl $0x5,0x12f760 <== NOT EXECUTED
10cbfb: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10cbfe: fa cli <== NOT EXECUTED
10cbff: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10cc01: f4 hlt <== NOT EXECUTED
10cc02: eb fe jmp 10cc02 <_Internal_error_Occurred+0x42><== NOT EXECUTED
0010cc5c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10cc5c: 56 push %esi
10cc5d: 53 push %ebx
10cc5e: 83 ec 14 sub $0x14,%esp
10cc61: 8b 5c 24 20 mov 0x20(%esp),%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 )
10cc65: 8b 43 18 mov 0x18(%ebx),%eax
10cc68: 85 c0 test %eax,%eax
10cc6a: 74 54 je 10ccc0 <_Objects_Allocate+0x64><== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10cc6c: 8d 73 20 lea 0x20(%ebx),%esi
10cc6f: 89 34 24 mov %esi,(%esp)
10cc72: e8 35 f7 ff ff call 10c3ac <_Chain_Get>
10cc77: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10cc79: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10cc7d: 74 20 je 10cc9f <_Objects_Allocate+0x43>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10cc7f: 85 c0 test %eax,%eax
10cc81: 74 25 je 10cca8 <_Objects_Allocate+0x4c>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10cc83: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10cc87: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10cc8b: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10cc8d: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10cc91: 31 d2 xor %edx,%edx
10cc93: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10cc95: 8b 53 30 mov 0x30(%ebx),%edx
10cc98: ff 0c 82 decl (%edx,%eax,4)
information->inactive--;
10cc9b: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10cc9f: 89 c8 mov %ecx,%eax
10cca1: 83 c4 14 add $0x14,%esp
10cca4: 5b pop %ebx
10cca5: 5e pop %esi
10cca6: c3 ret
10cca7: 90 nop
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
10cca8: 89 1c 24 mov %ebx,(%esp)
10ccab: e8 3c 00 00 00 call 10ccec <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10ccb0: 89 34 24 mov %esi,(%esp)
10ccb3: e8 f4 f6 ff ff call 10c3ac <_Chain_Get>
10ccb8: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10ccba: 85 c0 test %eax,%eax
10ccbc: 75 c5 jne 10cc83 <_Objects_Allocate+0x27>
10ccbe: 66 90 xchg %ax,%ax
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
return NULL;
10ccc0: 31 c9 xor %ecx,%ecx
);
}
#endif
return the_object;
}
10ccc2: 89 c8 mov %ecx,%eax
10ccc4: 83 c4 14 add $0x14,%esp
10ccc7: 5b pop %ebx
10ccc8: 5e pop %esi
10ccc9: c3 ret
0010ccec <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10ccec: 55 push %ebp
10cced: 57 push %edi
10ccee: 56 push %esi
10ccef: 53 push %ebx
10ccf0: 83 ec 4c sub $0x4c,%esp
10ccf3: 8b 5c 24 60 mov 0x60(%esp),%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 );
10ccf7: 0f b7 43 08 movzwl 0x8(%ebx),%eax
10ccfb: 89 44 24 20 mov %eax,0x20(%esp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10ccff: 8b 4b 34 mov 0x34(%ebx),%ecx
10cd02: 8b 7b 10 mov 0x10(%ebx),%edi
10cd05: 85 c9 test %ecx,%ecx
10cd07: 0f 84 73 02 00 00 je 10cf80 <_Objects_Extend_information+0x294>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10cd0d: 8b 73 14 mov 0x14(%ebx),%esi
10cd10: 89 f8 mov %edi,%eax
10cd12: 31 d2 xor %edx,%edx
10cd14: 66 f7 f6 div %si
10cd17: 0f b7 c0 movzwl %ax,%eax
10cd1a: 89 44 24 18 mov %eax,0x18(%esp)
for ( ; block < block_count; block++ ) {
10cd1e: 85 c0 test %eax,%eax
10cd20: 0f b7 c6 movzwl %si,%eax
10cd23: 0f 84 77 02 00 00 je 10cfa0 <_Objects_Extend_information+0x2b4><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10cd29: 8b 11 mov (%ecx),%edx
10cd2b: 85 d2 test %edx,%edx
10cd2d: 0f 84 81 02 00 00 je 10cfb4 <_Objects_Extend_information+0x2c8><== NEVER TAKEN
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
10cd33: 8b 74 24 18 mov 0x18(%esp),%esi
10cd37: 4e dec %esi
/*
* 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 );
10cd38: 8b 54 24 20 mov 0x20(%esp),%edx
10cd3c: 89 54 24 14 mov %edx,0x14(%esp)
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
10cd40: 31 d2 xor %edx,%edx
10cd42: 89 5c 24 1c mov %ebx,0x1c(%esp)
10cd46: 8b 5c 24 14 mov 0x14(%esp),%ebx
10cd4a: eb 0c jmp 10cd58 <_Objects_Extend_information+0x6c>
10cd4c: 89 ea mov %ebp,%edx
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
10cd4e: 83 3c a9 00 cmpl $0x0,(%ecx,%ebp,4)
10cd52: 0f 84 d4 01 00 00 je 10cf2c <_Objects_Extend_information+0x240>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10cd58: 01 c3 add %eax,%ebx
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
10cd5a: 8d 6a 01 lea 0x1(%edx),%ebp
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10cd5d: 39 f2 cmp %esi,%edx
10cd5f: 75 eb jne 10cd4c <_Objects_Extend_information+0x60>
10cd61: 89 5c 24 14 mov %ebx,0x14(%esp)
10cd65: 8b 5c 24 1c mov 0x1c(%esp),%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;
10cd69: be 01 00 00 00 mov $0x1,%esi
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10cd6e: 0f b7 d7 movzwl %di,%edx
10cd71: 01 c2 add %eax,%edx
10cd73: 89 54 24 1c mov %edx,0x1c(%esp)
/*
* 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 ) {
10cd77: 81 fa ff ff 00 00 cmp $0xffff,%edx
10cd7d: 0f 87 9f 01 00 00 ja 10cf22 <_Objects_Extend_information+0x236>
/*
* 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;
10cd83: 0f af 43 18 imul 0x18(%ebx),%eax
if ( information->auto_extend ) {
10cd87: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
new_object_block = _Workspace_Allocate( block_size );
10cd8b: 89 04 24 mov %eax,(%esp)
/*
* 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;
if ( information->auto_extend ) {
10cd8e: 0f 84 a8 01 00 00 je 10cf3c <_Objects_Extend_information+0x250>
new_object_block = _Workspace_Allocate( block_size );
10cd94: e8 63 1e 00 00 call 10ebfc <_Workspace_Allocate>
10cd99: 89 44 24 28 mov %eax,0x28(%esp)
if ( !new_object_block )
10cd9d: 85 c0 test %eax,%eax
10cd9f: 0f 84 7d 01 00 00 je 10cf22 <_Objects_Extend_information+0x236>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10cda5: 89 f0 mov %esi,%eax
10cda7: 84 c0 test %al,%al
10cda9: 0f 84 ee 00 00 00 je 10ce9d <_Objects_Extend_information+0x1b1>
*/
/*
* Up the block count and maximum
*/
block_count++;
10cdaf: 8b 74 24 18 mov 0x18(%esp),%esi
10cdb3: 46 inc %esi
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10cdb4: 8d 04 76 lea (%esi,%esi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10cdb7: 03 44 24 1c add 0x1c(%esp),%eax
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10cdbb: 03 44 24 20 add 0x20(%esp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10cdbf: 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 );
10cdc2: 89 04 24 mov %eax,(%esp)
10cdc5: e8 32 1e 00 00 call 10ebfc <_Workspace_Allocate>
10cdca: 89 c2 mov %eax,%edx
if ( !object_blocks ) {
10cdcc: 85 c0 test %eax,%eax
10cdce: 0f 84 f1 01 00 00 je 10cfc5 <_Objects_Extend_information+0x2d9>
10cdd4: 8d 3c b0 lea (%eax,%esi,4),%edi
10cdd7: 89 7c 24 2c mov %edi,0x2c(%esp)
10cddb: 8d 34 f0 lea (%eax,%esi,8),%esi
10cdde: 89 74 24 24 mov %esi,0x24(%esp)
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10cde2: 0f b7 43 10 movzwl 0x10(%ebx),%eax
10cde6: 39 44 24 20 cmp %eax,0x20(%esp)
10cdea: 0f 82 5a 01 00 00 jb 10cf4a <_Objects_Extend_information+0x25e>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10cdf0: 8b 44 24 20 mov 0x20(%esp),%eax
10cdf4: 85 c0 test %eax,%eax
10cdf6: 74 1d je 10ce15 <_Objects_Extend_information+0x129><== NEVER TAKEN
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
10cdf8: 8b 44 24 20 mov 0x20(%esp),%eax
10cdfc: 8b 7c 24 24 mov 0x24(%esp),%edi
10ce00: 8d 0c 87 lea (%edi,%eax,4),%ecx
10ce03: 89 f8 mov %edi,%eax
10ce05: 8d 76 00 lea 0x0(%esi),%esi
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
10ce08: c7 00 00 00 00 00 movl $0x0,(%eax)
10ce0e: 83 c0 04 add $0x4,%eax
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10ce11: 39 c8 cmp %ecx,%eax
10ce13: 75 f3 jne 10ce08 <_Objects_Extend_information+0x11c><== NEVER TAKEN
10ce15: 8b 44 24 18 mov 0x18(%esp),%eax
10ce19: c1 e0 02 shl $0x2,%eax
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10ce1c: c7 04 02 00 00 00 00 movl $0x0,(%edx,%eax,1)
inactive_per_block[block_count] = 0;
10ce23: 8b 7c 24 2c mov 0x2c(%esp),%edi
10ce27: c7 04 07 00 00 00 00 movl $0x0,(%edi,%eax,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10ce2e: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx
10ce32: 03 4c 24 14 add 0x14(%esp),%ecx
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10ce36: 39 4c 24 14 cmp %ecx,0x14(%esp)
10ce3a: 73 1d jae 10ce59 <_Objects_Extend_information+0x16d><== NEVER TAKEN
10ce3c: 8b 74 24 14 mov 0x14(%esp),%esi
10ce40: 8b 7c 24 24 mov 0x24(%esp),%edi
10ce44: 8d 04 b7 lea (%edi,%esi,4),%eax
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
10ce47: 8d 0c 8f lea (%edi,%ecx,4),%ecx
10ce4a: 66 90 xchg %ax,%ax
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10ce4c: c7 00 00 00 00 00 movl $0x0,(%eax)
10ce52: 83 c0 04 add $0x4,%eax
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10ce55: 39 c8 cmp %ecx,%eax
10ce57: 75 f3 jne 10ce4c <_Objects_Extend_information+0x160>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10ce59: 9c pushf
10ce5a: fa cli
10ce5b: 59 pop %ecx
old_tables = information->object_blocks;
10ce5c: 8b 43 34 mov 0x34(%ebx),%eax
information->object_blocks = object_blocks;
10ce5f: 89 53 34 mov %edx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10ce62: 8b 7c 24 2c mov 0x2c(%esp),%edi
10ce66: 89 7b 30 mov %edi,0x30(%ebx)
information->local_table = local_table;
10ce69: 8b 7c 24 24 mov 0x24(%esp),%edi
10ce6d: 89 7b 1c mov %edi,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10ce70: 8b 54 24 1c mov 0x1c(%esp),%edx
10ce74: 66 89 53 10 mov %dx,0x10(%ebx)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10ce78: 8b 13 mov (%ebx),%edx
10ce7a: c1 e2 18 shl $0x18,%edx
10ce7d: 81 ca 00 00 01 00 or $0x10000,%edx
information->maximum_id = _Objects_Build_id(
10ce83: 0f b7 73 04 movzwl 0x4(%ebx),%esi
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10ce87: c1 e6 1b shl $0x1b,%esi
10ce8a: 09 f2 or %esi,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10ce8c: 0b 54 24 1c or 0x1c(%esp),%edx
10ce90: 89 53 0c mov %edx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10ce93: 51 push %ecx
10ce94: 9d popf
_Workspace_Free( old_tables );
10ce95: 89 04 24 mov %eax,(%esp)
10ce98: e8 8b 1d 00 00 call 10ec28 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10ce9d: c1 e5 02 shl $0x2,%ebp
10cea0: 89 6c 24 18 mov %ebp,0x18(%esp)
10cea4: 8b 43 34 mov 0x34(%ebx),%eax
10cea7: 8b 54 24 28 mov 0x28(%esp),%edx
10ceab: 89 14 28 mov %edx,(%eax,%ebp,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10ceae: 8b 43 18 mov 0x18(%ebx),%eax
10ceb1: 89 44 24 0c mov %eax,0xc(%esp)
10ceb5: 0f b7 43 14 movzwl 0x14(%ebx),%eax
10ceb9: 89 44 24 08 mov %eax,0x8(%esp)
10cebd: 8b 43 34 mov 0x34(%ebx),%eax
10cec0: 8b 04 28 mov (%eax,%ebp,1),%eax
10cec3: 89 44 24 04 mov %eax,0x4(%esp)
10cec7: 8d 74 24 34 lea 0x34(%esp),%esi
10cecb: 89 34 24 mov %esi,(%esp)
10cece: e8 f9 f4 ff ff call 10c3cc <_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 ) {
10ced3: 8b 6c 24 14 mov 0x14(%esp),%ebp
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10ced7: 8d 7b 20 lea 0x20(%ebx),%edi
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10ceda: eb 26 jmp 10cf02 <_Objects_Extend_information+0x216>
10cedc: 8b 13 mov (%ebx),%edx
10cede: c1 e2 18 shl $0x18,%edx
10cee1: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10cee7: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10ceeb: c1 e1 1b shl $0x1b,%ecx
10ceee: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cef0: 09 ea or %ebp,%edx
10cef2: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cef5: 89 44 24 04 mov %eax,0x4(%esp)
10cef9: 89 3c 24 mov %edi,(%esp)
10cefc: e8 87 f4 ff ff call 10c388 <_Chain_Append>
index++;
10cf01: 45 inc %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 ) {
10cf02: 89 34 24 mov %esi,(%esp)
10cf05: e8 a2 f4 ff ff call 10c3ac <_Chain_Get>
10cf0a: 85 c0 test %eax,%eax
10cf0c: 75 ce jne 10cedc <_Objects_Extend_information+0x1f0>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10cf0e: 8b 43 14 mov 0x14(%ebx),%eax
10cf11: 8b 53 30 mov 0x30(%ebx),%edx
10cf14: 0f b7 c8 movzwl %ax,%ecx
10cf17: 8b 74 24 18 mov 0x18(%esp),%esi
10cf1b: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10cf1e: 66 01 43 2c add %ax,0x2c(%ebx)
}
10cf22: 83 c4 4c add $0x4c,%esp
10cf25: 5b pop %ebx
10cf26: 5e pop %esi
10cf27: 5f pop %edi
10cf28: 5d pop %ebp
10cf29: c3 ret
10cf2a: 66 90 xchg %ax,%ax
10cf2c: 89 5c 24 14 mov %ebx,0x14(%esp)
10cf30: 8b 5c 24 1c mov 0x1c(%esp),%ebx
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10cf34: 31 f6 xor %esi,%esi
10cf36: e9 33 fe ff ff jmp 10cd6e <_Objects_Extend_information+0x82>
10cf3b: 90 nop
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 );
10cf3c: e8 03 1d 00 00 call 10ec44 <_Workspace_Allocate_or_fatal_error>
10cf41: 89 44 24 28 mov %eax,0x28(%esp)
10cf45: e9 5b fe ff ff jmp 10cda5 <_Objects_Extend_information+0xb9>
/*
* 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,
10cf4a: 8b 44 24 18 mov 0x18(%esp),%eax
10cf4e: c1 e0 02 shl $0x2,%eax
10cf51: 8b 73 34 mov 0x34(%ebx),%esi
10cf54: 89 d7 mov %edx,%edi
10cf56: 89 c1 mov %eax,%ecx
10cf58: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10cf5a: 8b 73 30 mov 0x30(%ebx),%esi
10cf5d: 8b 7c 24 2c mov 0x2c(%esp),%edi
10cf61: 89 c1 mov %eax,%ecx
10cf63: 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 *) );
10cf65: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10cf69: 03 4c 24 20 add 0x20(%esp),%ecx
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10cf6d: c1 e1 02 shl $0x2,%ecx
10cf70: 8b 73 1c mov 0x1c(%ebx),%esi
10cf73: 8b 7c 24 24 mov 0x24(%esp),%edi
10cf77: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10cf79: e9 9e fe ff ff jmp 10ce1c <_Objects_Extend_information+0x130>
10cf7e: 66 90 xchg %ax,%ax
10cf80: 0f b7 43 14 movzwl 0x14(%ebx),%eax
/*
* 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 );
10cf84: 8b 54 24 20 mov 0x20(%esp),%edx
10cf88: 89 54 24 14 mov %edx,0x14(%esp)
/*
* 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;
10cf8c: be 01 00 00 00 mov $0x1,%esi
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10cf91: 31 ed xor %ebp,%ebp
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10cf93: c7 44 24 18 00 00 00 movl $0x0,0x18(%esp)
10cf9a: 00
10cf9b: e9 ce fd ff ff jmp 10cd6e <_Objects_Extend_information+0x82>
/*
* 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 );
10cfa0: 8b 4c 24 20 mov 0x20(%esp),%ecx <== NOT EXECUTED
10cfa4: 89 4c 24 14 mov %ecx,0x14(%esp) <== 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;
10cfa8: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10cfad: 31 ed xor %ebp,%ebp <== NOT EXECUTED
10cfaf: e9 ba fd ff ff jmp 10cd6e <_Objects_Extend_information+0x82><== 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 );
10cfb4: 8b 4c 24 20 mov 0x20(%esp),%ecx <== NOT EXECUTED
10cfb8: 89 4c 24 14 mov %ecx,0x14(%esp) <== NOT EXECUTED
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10cfbc: 31 f6 xor %esi,%esi <== 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;
10cfbe: 31 ed xor %ebp,%ebp <== NOT EXECUTED
10cfc0: e9 a9 fd ff ff jmp 10cd6e <_Objects_Extend_information+0x82><== 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 );
10cfc5: 8b 44 24 28 mov 0x28(%esp),%eax
10cfc9: 89 04 24 mov %eax,(%esp)
10cfcc: e8 57 1c 00 00 call 10ec28 <_Workspace_Free>
10cfd1: e9 4c ff ff ff jmp 10cf22 <_Objects_Extend_information+0x236>
0010d070 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10d070: 56 push %esi
10d071: 53 push %ebx
10d072: 83 ec 14 sub $0x14,%esp
10d075: 8b 74 24 20 mov 0x20(%esp),%esi
10d079: 0f b7 5c 24 24 movzwl 0x24(%esp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10d07e: 66 85 db test %bx,%bx
10d081: 74 31 je 10d0b4 <_Objects_Get_information+0x44>
/*
* 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 );
10d083: 89 34 24 mov %esi,(%esp)
10d086: e8 f1 43 00 00 call 11147c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10d08b: 85 c0 test %eax,%eax
10d08d: 74 25 je 10d0b4 <_Objects_Get_information+0x44>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10d08f: 39 d8 cmp %ebx,%eax
10d091: 72 21 jb 10d0b4 <_Objects_Get_information+0x44>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10d093: 8b 04 b5 dc f5 12 00 mov 0x12f5dc(,%esi,4),%eax
10d09a: 85 c0 test %eax,%eax
10d09c: 74 16 je 10d0b4 <_Objects_Get_information+0x44><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10d09e: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !info )
10d0a1: 85 c0 test %eax,%eax
10d0a3: 74 0f je 10d0b4 <_Objects_Get_information+0x44><== NEVER TAKEN
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
10d0a5: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10d0aa: 74 08 je 10d0b4 <_Objects_Get_information+0x44>
return NULL;
#endif
return info;
}
10d0ac: 83 c4 14 add $0x14,%esp
10d0af: 5b pop %ebx
10d0b0: 5e pop %esi
10d0b1: c3 ret
10d0b2: 66 90 xchg %ax,%ax
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10d0b4: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10d0b6: 83 c4 14 add $0x14,%esp
10d0b9: 5b pop %ebx
10d0ba: 5e pop %esi
10d0bb: c3 ret
001198b0 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
1198b0: 55 push %ebp
1198b1: 57 push %edi
1198b2: 56 push %esi
1198b3: 53 push %ebx
1198b4: 83 ec 2c sub $0x2c,%esp
1198b7: 8b 7c 24 40 mov 0x40(%esp),%edi
1198bb: 8b 5c 24 44 mov 0x44(%esp),%ebx
1198bf: 8b 74 24 48 mov 0x48(%esp),%esi
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
1198c3: 85 db test %ebx,%ebx
1198c5: 0f 84 c5 00 00 00 je 119990 <_Objects_Get_name_as_string+0xe0>
return NULL;
if ( name == NULL )
1198cb: 85 f6 test %esi,%esi
1198cd: 0f 84 bd 00 00 00 je 119990 <_Objects_Get_name_as_string+0xe0>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
1198d3: 85 ff test %edi,%edi
1198d5: 0f 84 a5 00 00 00 je 119980 <_Objects_Get_name_as_string+0xd0>
information = _Objects_Get_information_id( tmpId );
1198db: 89 3c 24 mov %edi,(%esp)
1198de: e8 bd 8f ff ff call 1128a0 <_Objects_Get_information_id>
if ( !information )
1198e3: 85 c0 test %eax,%eax
1198e5: 0f 84 a5 00 00 00 je 119990 <_Objects_Get_name_as_string+0xe0>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
1198eb: 8d 54 24 14 lea 0x14(%esp),%edx
1198ef: 89 54 24 08 mov %edx,0x8(%esp)
1198f3: 89 7c 24 04 mov %edi,0x4(%esp)
1198f7: 89 04 24 mov %eax,(%esp)
1198fa: e8 69 90 ff ff call 112968 <_Objects_Get>
switch ( location ) {
1198ff: 8b 54 24 14 mov 0x14(%esp),%edx
119903: 85 d2 test %edx,%edx
119905: 0f 85 85 00 00 00 jne 119990 <_Objects_Get_name_as_string+0xe0>
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
11990b: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
11990e: 89 c1 mov %eax,%ecx
119910: c1 e9 18 shr $0x18,%ecx
119913: 88 ca mov %cl,%dl
119915: 88 4c 24 1b mov %cl,0x1b(%esp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
119919: 89 c1 mov %eax,%ecx
11991b: c1 e9 10 shr $0x10,%ecx
11991e: 88 4c 24 1c mov %cl,0x1c(%esp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
119922: 89 c1 mov %eax,%ecx
119924: c1 e9 08 shr $0x8,%ecx
119927: 88 4c 24 1d mov %cl,0x1d(%esp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
11992b: 88 44 24 1e mov %al,0x1e(%esp)
lname[ 4 ] = '\0';
11992f: c6 44 24 1f 00 movb $0x0,0x1f(%esp)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
119934: 83 fb 01 cmp $0x1,%ebx
119937: 74 63 je 11999c <_Objects_Get_name_as_string+0xec><== NEVER TAKEN
119939: 84 d2 test %dl,%dl
11993b: 74 5f je 11999c <_Objects_Get_name_as_string+0xec>
* This method objects the name of an object and returns its name
* in the form of a C string. It attempts to be careful about
* overflowing the user's string and about returning unprintable characters.
*/
char *_Objects_Get_name_as_string(
11993d: 8d 7c 1e ff lea -0x1(%esi,%ebx,1),%edi
119941: 89 f1 mov %esi,%ecx
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
s = lname;
119943: 8d 5c 24 1b lea 0x1b(%esp),%ebx
119947: eb 09 jmp 119952 <_Objects_Get_name_as_string+0xa2>
119949: 8d 76 00 lea 0x0(%esi),%esi
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
11994c: 8a 13 mov (%ebx),%dl
11994e: 84 d2 test %dl,%dl
119950: 74 1c je 11996e <_Objects_Get_name_as_string+0xbe>
*d = (isprint((unsigned char)*s)) ? *s : '*';
119952: 0f b6 c2 movzbl %dl,%eax
119955: 8b 2d 28 db 13 00 mov 0x13db28,%ebp
11995b: 0f be 44 05 01 movsbl 0x1(%ebp,%eax,1),%eax
119960: a8 97 test $0x97,%al
119962: 75 02 jne 119966 <_Objects_Get_name_as_string+0xb6>
119964: b2 2a mov $0x2a,%dl
119966: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
119968: 43 inc %ebx
119969: 41 inc %ecx
11996a: 39 f9 cmp %edi,%ecx
11996c: 75 de jne 11994c <_Objects_Get_name_as_string+0x9c>
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
11996e: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
119971: e8 fa 9c ff ff call 113670 <_Thread_Enable_dispatch>
return name;
}
return NULL; /* unreachable path */
}
119976: 89 f0 mov %esi,%eax
119978: 83 c4 2c add $0x2c,%esp
11997b: 5b pop %ebx
11997c: 5e pop %esi
11997d: 5f pop %edi
11997e: 5d pop %ebp
11997f: c3 ret
return NULL;
if ( name == NULL )
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
119980: a1 ec 06 14 00 mov 0x1406ec,%eax
119985: 8b 78 08 mov 0x8(%eax),%edi
119988: e9 4e ff ff ff jmp 1198db <_Objects_Get_name_as_string+0x2b>
11998d: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
119990: 31 f6 xor %esi,%esi
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
119992: 89 f0 mov %esi,%eax
119994: 83 c4 2c add $0x2c,%esp
119997: 5b pop %ebx
119998: 5e pop %esi
119999: 5f pop %edi
11999a: 5d pop %ebp
11999b: c3 ret
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
11999c: 89 f1 mov %esi,%ecx
11999e: eb ce jmp 11996e <_Objects_Get_name_as_string+0xbe>
0011be2c <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
11be2c: 55 push %ebp
11be2d: 57 push %edi
11be2e: 56 push %esi
11be2f: 53 push %ebx
11be30: 83 ec 1c sub $0x1c,%esp
11be33: 8b 74 24 30 mov 0x30(%esp),%esi
11be37: 8b 5c 24 34 mov 0x34(%esp),%ebx
11be3b: 8b 7c 24 38 mov 0x38(%esp),%edi
11be3f: 8b 6c 24 3c mov 0x3c(%esp),%ebp
Objects_Control *object;
Objects_Id next_id;
if ( !information )
11be43: 85 f6 test %esi,%esi
11be45: 74 59 je 11bea0 <_Objects_Get_next+0x74>
return NULL;
if ( !location_p )
11be47: 85 ff test %edi,%edi
11be49: 74 55 je 11bea0 <_Objects_Get_next+0x74>
return NULL;
if ( !next_id_p )
11be4b: 85 ed test %ebp,%ebp
11be4d: 74 51 je 11bea0 <_Objects_Get_next+0x74>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
11be4f: 66 85 db test %bx,%bx
11be52: 74 28 je 11be7c <_Objects_Get_next+0x50>
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
11be54: 66 39 5e 10 cmp %bx,0x10(%esi)
11be58: 72 2e jb 11be88 <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
11be5a: 89 7c 24 08 mov %edi,0x8(%esp)
11be5e: 89 5c 24 04 mov %ebx,0x4(%esp)
11be62: 89 34 24 mov %esi,(%esp)
11be65: e8 fe 6a ff ff call 112968 <_Objects_Get>
next_id++;
11be6a: 43 inc %ebx
} while (*location_p != OBJECTS_LOCAL);
11be6b: 8b 17 mov (%edi),%edx
11be6d: 85 d2 test %edx,%edx
11be6f: 75 e3 jne 11be54 <_Objects_Get_next+0x28>
*next_id_p = next_id;
11be71: 89 5d 00 mov %ebx,0x0(%ebp)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
11be74: 83 c4 1c add $0x1c,%esp
11be77: 5b pop %ebx
11be78: 5e pop %esi
11be79: 5f pop %edi
11be7a: 5d pop %ebp
11be7b: c3 ret
if ( !next_id_p )
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
next_id = information->minimum_id;
11be7c: 8b 5e 08 mov 0x8(%esi),%ebx
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
11be7f: 66 39 5e 10 cmp %bx,0x10(%esi)
11be83: 73 d5 jae 11be5a <_Objects_Get_next+0x2e><== ALWAYS TAKEN
11be85: 8d 76 00 lea 0x0(%esi),%esi
{
*location_p = OBJECTS_ERROR;
11be88: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
11be8e: c7 45 00 ff ff ff ff movl $0xffffffff,0x0(%ebp)
return 0;
11be95: 31 c0 xor %eax,%eax
}
11be97: 83 c4 1c add $0x1c,%esp
11be9a: 5b pop %ebx
11be9b: 5e pop %esi
11be9c: 5f pop %edi
11be9d: 5d pop %ebp
11be9e: c3 ret
11be9f: 90 nop
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
11bea0: 31 c0 xor %eax,%eax
11bea2: eb d0 jmp 11be74 <_Objects_Get_next+0x48>
0011e390 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11e390: 8b 54 24 04 mov 0x4(%esp),%edx
/*
* 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;
11e394: b8 01 00 00 00 mov $0x1,%eax
11e399: 2b 42 08 sub 0x8(%edx),%eax
11e39c: 03 44 24 08 add 0x8(%esp),%eax
if ( information->maximum >= index ) {
11e3a0: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
11e3a4: 39 c8 cmp %ecx,%eax
11e3a6: 77 18 ja 11e3c0 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11e3a8: 8b 52 1c mov 0x1c(%edx),%edx
11e3ab: 8b 04 82 mov (%edx,%eax,4),%eax
11e3ae: 85 c0 test %eax,%eax
11e3b0: 74 0e je 11e3c0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11e3b2: 8b 54 24 0c mov 0xc(%esp),%edx
11e3b6: c7 02 00 00 00 00 movl $0x0,(%edx)
return the_object;
11e3bc: c3 ret
11e3bd: 8d 76 00 lea 0x0(%esi),%esi
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
11e3c0: 8b 44 24 0c mov 0xc(%esp),%eax
11e3c4: c7 00 01 00 00 00 movl $0x1,(%eax)
return NULL;
11e3ca: 31 c0 xor %eax,%eax
}
11e3cc: c3 ret
001129dc <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
1129dc: 83 ec 2c sub $0x2c,%esp
1129df: 8b 44 24 30 mov 0x30(%esp),%eax
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
1129e3: 85 c0 test %eax,%eax
1129e5: 75 65 jne 112a4c <_Objects_Id_to_name+0x70>
1129e7: a1 ec 06 14 00 mov 0x1406ec,%eax
1129ec: 8b 50 08 mov 0x8(%eax),%edx
1129ef: 89 d0 mov %edx,%eax
1129f1: c1 e8 18 shr $0x18,%eax
1129f4: 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 )
1129f7: 8d 48 ff lea -0x1(%eax),%ecx
1129fa: 83 f9 02 cmp $0x2,%ecx
1129fd: 77 41 ja 112a40 <_Objects_Id_to_name+0x64>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
1129ff: 8b 04 85 1c 04 14 00 mov 0x14041c(,%eax,4),%eax
112a06: 85 c0 test %eax,%eax
112a08: 74 36 je 112a40 <_Objects_Id_to_name+0x64>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
112a0a: 89 d1 mov %edx,%ecx
112a0c: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
112a0f: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
112a12: 85 c0 test %eax,%eax
112a14: 74 2a je 112a40 <_Objects_Id_to_name+0x64><== 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 );
112a16: 8d 4c 24 1c lea 0x1c(%esp),%ecx
112a1a: 89 4c 24 08 mov %ecx,0x8(%esp)
112a1e: 89 54 24 04 mov %edx,0x4(%esp)
112a22: 89 04 24 mov %eax,(%esp)
112a25: e8 3e ff ff ff call 112968 <_Objects_Get>
if ( !the_object )
112a2a: 85 c0 test %eax,%eax
112a2c: 74 12 je 112a40 <_Objects_Id_to_name+0x64>
return OBJECTS_INVALID_ID;
*name = the_object->name;
112a2e: 8b 50 0c mov 0xc(%eax),%edx
112a31: 8b 44 24 34 mov 0x34(%esp),%eax
112a35: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
112a37: e8 34 0c 00 00 call 113670 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
112a3c: 31 c0 xor %eax,%eax
112a3e: eb 05 jmp 112a45 <_Objects_Id_to_name+0x69>
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
112a40: 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;
}
112a45: 83 c4 2c add $0x2c,%esp
112a48: c3 ret
112a49: 8d 76 00 lea 0x0(%esi),%esi
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
112a4c: 89 c2 mov %eax,%edx
112a4e: eb 9f jmp 1129ef <_Objects_Id_to_name+0x13>
0010d2f8 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10d2f8: 55 push %ebp
10d2f9: 57 push %edi
10d2fa: 56 push %esi
10d2fb: 53 push %ebx
10d2fc: 83 ec 1c sub $0x1c,%esp
10d2ff: 8b 7c 24 30 mov 0x30(%esp),%edi
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
10d303: 0f b7 5f 08 movzwl 0x8(%edi),%ebx
block_count = (information->maximum - index_base) /
10d307: 0f b7 77 14 movzwl 0x14(%edi),%esi
10d30b: 0f b7 47 10 movzwl 0x10(%edi),%eax
10d30f: 29 d8 sub %ebx,%eax
10d311: 31 d2 xor %edx,%edx
10d313: f7 f6 div %esi
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10d315: 85 c0 test %eax,%eax
10d317: 74 1e je 10d337 <_Objects_Shrink_information+0x3f><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10d319: 8b 57 30 mov 0x30(%edi),%edx
10d31c: 3b 32 cmp (%edx),%esi
10d31e: 74 1f je 10d33f <_Objects_Shrink_information+0x47><== NEVER TAKEN
10d320: 31 c9 xor %ecx,%ecx
10d322: eb 0c jmp 10d330 <_Objects_Shrink_information+0x38>
* the_block - the block to remove
*
* Output parameters: NONE
*/
void _Objects_Shrink_information(
10d324: 8d 2c 8d 00 00 00 00 lea 0x0(,%ecx,4),%ebp
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 ] ==
10d32b: 3b 34 8a cmp (%edx,%ecx,4),%esi
10d32e: 74 14 je 10d344 <_Objects_Shrink_information+0x4c>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10d330: 01 f3 add %esi,%ebx
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10d332: 41 inc %ecx
10d333: 39 c1 cmp %eax,%ecx
10d335: 75 ed jne 10d324 <_Objects_Shrink_information+0x2c>
return;
}
index_base += information->allocation_size;
}
}
10d337: 83 c4 1c add $0x1c,%esp
10d33a: 5b pop %ebx
10d33b: 5e pop %esi
10d33c: 5f pop %edi
10d33d: 5d pop %ebp
10d33e: 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 ] ==
10d33f: 31 ed xor %ebp,%ebp <== NOT EXECUTED
10d341: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10d344: 8b 47 20 mov 0x20(%edi),%eax
10d347: eb 09 jmp 10d352 <_Objects_Shrink_information+0x5a>
10d349: 8d 76 00 lea 0x0(%esi),%esi
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;
10d34c: 89 f0 mov %esi,%eax
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10d34e: 85 f6 test %esi,%esi
10d350: 74 22 je 10d374 <_Objects_Shrink_information+0x7c>
* 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 );
10d352: 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;
10d356: 8b 30 mov (%eax),%esi
if ((index >= index_base) &&
10d358: 39 da cmp %ebx,%edx
10d35a: 72 f0 jb 10d34c <_Objects_Shrink_information+0x54>
(index < (index_base + information->allocation_size))) {
10d35c: 0f b7 4f 14 movzwl 0x14(%edi),%ecx
10d360: 01 d9 add %ebx,%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) &&
10d362: 39 ca cmp %ecx,%edx
10d364: 73 e6 jae 10d34c <_Objects_Shrink_information+0x54>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10d366: 89 04 24 mov %eax,(%esp)
10d369: e8 6e 38 00 00 call 110bdc <_Chain_Extract>
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;
10d36e: 89 f0 mov %esi,%eax
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10d370: 85 f6 test %esi,%esi
10d372: 75 de jne 10d352 <_Objects_Shrink_information+0x5a>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10d374: 8b 47 34 mov 0x34(%edi),%eax
10d377: 8b 04 28 mov (%eax,%ebp,1),%eax
10d37a: 89 04 24 mov %eax,(%esp)
10d37d: e8 a6 18 00 00 call 10ec28 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10d382: 8b 47 34 mov 0x34(%edi),%eax
10d385: c7 04 28 00 00 00 00 movl $0x0,(%eax,%ebp,1)
information->inactive_per_block[ block ] = 0;
10d38c: 8b 47 30 mov 0x30(%edi),%eax
10d38f: c7 04 28 00 00 00 00 movl $0x0,(%eax,%ebp,1)
information->inactive -= information->allocation_size;
10d396: 8b 47 14 mov 0x14(%edi),%eax
10d399: 66 29 47 2c sub %ax,0x2c(%edi)
return;
}
index_base += information->allocation_size;
}
}
10d39d: 83 c4 1c add $0x1c,%esp
10d3a0: 5b pop %ebx
10d3a1: 5e pop %esi
10d3a2: 5f pop %edi
10d3a3: 5d pop %ebp
10d3a4: c3 ret
0010e0fc <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
10e0fc: 55 push %ebp
10e0fd: 57 push %edi
10e0fe: 56 push %esi
10e0ff: 53 push %ebx
10e100: 83 ec 1c sub $0x1c,%esp
10e103: 8b 6c 24 30 mov 0x30(%esp),%ebp
10e107: 8b 74 24 34 mov 0x34(%esp),%esi
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
10e10b: 85 f6 test %esi,%esi
10e10d: 0f 84 ae 00 00 00 je 10e1c1 <_RBTree_Extract_unprotected+0xc5>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
10e113: 39 75 08 cmp %esi,0x8(%ebp)
10e116: 0f 84 d8 00 00 00 je 10e1f4 <_RBTree_Extract_unprotected+0xf8>
the_rbtree->first[RBT_LEFT] = next;
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
10e11c: 39 75 0c cmp %esi,0xc(%ebp)
10e11f: 0f 84 e7 00 00 00 je 10e20c <_RBTree_Extract_unprotected+0x110>
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
10e125: 8b 5e 04 mov 0x4(%esi),%ebx
10e128: 85 db test %ebx,%ebx
10e12a: 0f 84 00 01 00 00 je 10e230 <_RBTree_Extract_unprotected+0x134>
10e130: 8b 7e 08 mov 0x8(%esi),%edi
10e133: 85 ff test %edi,%edi
10e135: 75 07 jne 10e13e <_RBTree_Extract_unprotected+0x42>
10e137: e9 9d 00 00 00 jmp 10e1d9 <_RBTree_Extract_unprotected+0xdd>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
10e13c: 89 c3 mov %eax,%ebx
10e13e: 8b 43 08 mov 0x8(%ebx),%eax
10e141: 85 c0 test %eax,%eax
10e143: 75 f7 jne 10e13c <_RBTree_Extract_unprotected+0x40>
* target's position (target is the right child of target->parent)
* when target vacates it. if there is no child, then target->parent
* should become NULL. This may cause the coloring to be violated.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = target->child[RBT_LEFT];
10e145: 8b 7b 04 mov 0x4(%ebx),%edi
if(leaf) {
10e148: 85 ff test %edi,%edi
10e14a: 0f 84 d4 00 00 00 je 10e224 <_RBTree_Extract_unprotected+0x128>
leaf->parent = target->parent;
10e150: 8b 03 mov (%ebx),%eax
10e152: 89 07 mov %eax,(%edi)
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
}
victim_color = target->color;
10e154: 8b 53 0c mov 0xc(%ebx),%edx
dir = target != target->parent->child[0];
10e157: 8b 03 mov (%ebx),%eax
10e159: 31 c9 xor %ecx,%ecx
10e15b: 3b 58 04 cmp 0x4(%eax),%ebx
10e15e: 0f 95 c1 setne %cl
target->parent->child[dir] = leaf;
10e161: 89 7c 88 04 mov %edi,0x4(%eax,%ecx,4)
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
10e165: 8b 06 mov (%esi),%eax
10e167: 31 c9 xor %ecx,%ecx
10e169: 39 70 04 cmp %esi,0x4(%eax)
10e16c: 0f 95 c1 setne %cl
the_node->parent->child[dir] = target;
10e16f: 89 5c 88 04 mov %ebx,0x4(%eax,%ecx,4)
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
10e173: 8b 46 08 mov 0x8(%esi),%eax
10e176: 89 43 08 mov %eax,0x8(%ebx)
if (the_node->child[RBT_RIGHT])
10e179: 8b 46 08 mov 0x8(%esi),%eax
10e17c: 85 c0 test %eax,%eax
10e17e: 74 02 je 10e182 <_RBTree_Extract_unprotected+0x86><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
10e180: 89 18 mov %ebx,(%eax)
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
10e182: 8b 46 04 mov 0x4(%esi),%eax
10e185: 89 43 04 mov %eax,0x4(%ebx)
if (the_node->child[RBT_LEFT])
10e188: 8b 46 04 mov 0x4(%esi),%eax
10e18b: 85 c0 test %eax,%eax
10e18d: 74 02 je 10e191 <_RBTree_Extract_unprotected+0x95>
the_node->child[RBT_LEFT]->parent = target;
10e18f: 89 18 mov %ebx,(%eax)
/* finally, update the parent node and recolor. target has completely
* replaced the_node, and target's child has moved up the tree if needed.
* the_node is no longer part of the tree, although it has valid pointers
* still.
*/
target->parent = the_node->parent;
10e191: 8b 06 mov (%esi),%eax
10e193: 89 03 mov %eax,(%ebx)
target->color = the_node->color;
10e195: 8b 46 0c mov 0xc(%esi),%eax
10e198: 89 43 0c mov %eax,0xc(%ebx)
/* fix coloring. leaf has moved up the tree. The color of the deleted
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
10e19b: 85 d2 test %edx,%edx
10e19d: 74 2d je 10e1cc <_RBTree_Extract_unprotected+0xd0>
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
10e19f: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
10e1a6: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
10e1ad: c7 06 00 00 00 00 movl $0x0,(%esi)
/* Wipe the_node */
_RBTree_Set_off_rbtree(the_node);
/* set root to black, if it exists */
if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK;
10e1b3: 8b 45 04 mov 0x4(%ebp),%eax
10e1b6: 85 c0 test %eax,%eax
10e1b8: 74 07 je 10e1c1 <_RBTree_Extract_unprotected+0xc5>
10e1ba: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
}
10e1c1: 83 c4 1c add $0x1c,%esp
10e1c4: 5b pop %ebx
10e1c5: 5e pop %esi
10e1c6: 5f pop %edi
10e1c7: 5d pop %ebp
10e1c8: c3 ret
10e1c9: 8d 76 00 lea 0x0(%esi),%esi
* node is in victim_color. There are two cases:
* 1. Deleted a red node, its child must be black. Nothing must be done.
* 2. Deleted a black node, its child must be red. Paint child black.
*/
if (victim_color == RBT_BLACK) { /* eliminate case 1 */
if (leaf) {
10e1cc: 85 ff test %edi,%edi
10e1ce: 74 cf je 10e19f <_RBTree_Extract_unprotected+0xa3>
leaf->color = RBT_BLACK; /* case 2 */
10e1d0: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
10e1d7: eb c6 jmp 10e19f <_RBTree_Extract_unprotected+0xa3>
* either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT],
* and replace the_node with the target node. This maintains the binary
* search tree property, but may violate the red-black properties.
*/
if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) {
10e1d9: 89 df mov %ebx,%edi
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
if( leaf ) {
leaf->parent = the_node->parent;
10e1db: 8b 06 mov (%esi),%eax
10e1dd: 89 07 mov %eax,(%edi)
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
}
victim_color = the_node->color;
10e1df: 8b 56 0c mov 0xc(%esi),%edx
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
10e1e2: 8b 06 mov (%esi),%eax
10e1e4: 31 c9 xor %ecx,%ecx
10e1e6: 39 70 04 cmp %esi,0x4(%eax)
10e1e9: 0f 95 c1 setne %cl
the_node->parent->child[dir] = leaf;
10e1ec: 89 7c 88 04 mov %edi,0x4(%eax,%ecx,4)
10e1f0: eb a9 jmp 10e19b <_RBTree_Extract_unprotected+0x9f>
10e1f2: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
10e1f4: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10e1fb: 00
10e1fc: 89 34 24 mov %esi,(%esp)
10e1ff: e8 00 03 00 00 call 10e504 <_RBTree_Next_unprotected>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
10e204: 89 45 08 mov %eax,0x8(%ebp)
10e207: e9 10 ff ff ff jmp 10e11c <_RBTree_Extract_unprotected+0x20>
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
10e20c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10e213: 00
10e214: 89 34 24 mov %esi,(%esp)
10e217: e8 e8 02 00 00 call 10e504 <_RBTree_Next_unprotected>
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
10e21c: 89 45 0c mov %eax,0xc(%ebp)
10e21f: e9 01 ff ff ff jmp 10e125 <_RBTree_Extract_unprotected+0x29>
leaf = target->child[RBT_LEFT];
if(leaf) {
leaf->parent = target->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
10e224: 89 d8 mov %ebx,%eax
10e226: e8 95 fc ff ff call 10dec0 <_RBTree_Extract_validate_unprotected>
10e22b: e9 24 ff ff ff jmp 10e154 <_RBTree_Extract_unprotected+0x58>
* the_node's location in the tree. This may cause the coloring to be
* violated. We will fix it later.
* For now we store the color of the node being deleted in victim_color.
*/
leaf = the_node->child[RBT_LEFT] ?
the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT];
10e230: 8b 7e 08 mov 0x8(%esi),%edi
if( leaf ) {
10e233: 85 ff test %edi,%edi
10e235: 75 a4 jne 10e1db <_RBTree_Extract_unprotected+0xdf>
leaf->parent = the_node->parent;
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
10e237: 89 f0 mov %esi,%eax
10e239: e8 82 fc ff ff call 10dec0 <_RBTree_Extract_validate_unprotected>
10e23e: eb 9f jmp 10e1df <_RBTree_Extract_unprotected+0xe3>
0010dec0 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
10dec0: 8b 10 mov (%eax),%edx
if(!parent->parent) return;
10dec2: 8b 0a mov (%edx),%ecx
10dec4: 85 c9 test %ecx,%ecx
10dec6: 0f 84 8f 00 00 00 je 10df5b <_RBTree_Extract_validate_unprotected+0x9b>
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
10decc: 55 push %ebp
10decd: 57 push %edi
10dece: 56 push %esi
10decf: 53 push %ebx
10ded0: 83 ec 08 sub $0x8,%esp
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
10ded3: 8b 4a 04 mov 0x4(%edx),%ecx
10ded6: 39 c8 cmp %ecx,%eax
10ded8: 75 68 jne 10df42 <_RBTree_Extract_validate_unprotected+0x82>
return the_node->parent->child[RBT_RIGHT];
10deda: 8b 4a 08 mov 0x8(%edx),%ecx
10dedd: eb 63 jmp 10df42 <_RBTree_Extract_validate_unprotected+0x82>
10dedf: 90 nop
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
10dee0: 8b 1a mov (%edx),%ebx
10dee2: 85 db test %ebx,%ebx
10dee4: 74 62 je 10df48 <_RBTree_Extract_validate_unprotected+0x88>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
10dee6: 85 c9 test %ecx,%ecx
10dee8: 74 0a je 10def4 <_RBTree_Extract_validate_unprotected+0x34><== NEVER TAKEN
10deea: 83 79 0c 01 cmpl $0x1,0xc(%ecx)
10deee: 0f 84 18 01 00 00 je 10e00c <_RBTree_Extract_validate_unprotected+0x14c>
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
10def4: 8b 59 08 mov 0x8(%ecx),%ebx
10def7: 85 db test %ebx,%ebx
10def9: 74 06 je 10df01 <_RBTree_Extract_validate_unprotected+0x41>
10defb: 83 7b 0c 01 cmpl $0x1,0xc(%ebx)
10deff: 74 5b je 10df5c <_RBTree_Extract_validate_unprotected+0x9c>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
10df01: 8b 59 04 mov 0x4(%ecx),%ebx
10df04: 85 db test %ebx,%ebx
10df06: 74 06 je 10df0e <_RBTree_Extract_validate_unprotected+0x4e>
10df08: 83 7b 0c 01 cmpl $0x1,0xc(%ebx)
10df0c: 74 4e je 10df5c <_RBTree_Extract_validate_unprotected+0x9c>
sibling->color = RBT_RED;
10df0e: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx)
10df15: 83 7a 0c 01 cmpl $0x1,0xc(%edx)
10df19: 0f 84 d1 01 00 00 je 10e0f0 <_RBTree_Extract_validate_unprotected+0x230>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
10df1f: 8b 1a mov (%edx),%ebx
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
10df21: 85 db test %ebx,%ebx
10df23: 0f 84 3b 01 00 00 je 10e064 <_RBTree_Extract_validate_unprotected+0x1a4><== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
10df29: 8b 3b mov (%ebx),%edi
10df2b: 85 ff test %edi,%edi
10df2d: 0f 84 31 01 00 00 je 10e064 <_RBTree_Extract_validate_unprotected+0x1a4>
if(the_node == the_node->parent->child[RBT_LEFT])
10df33: 8b 4b 04 mov 0x4(%ebx),%ecx
10df36: 39 ca cmp %ecx,%edx
10df38: 0f 84 2e 01 00 00 je 10e06c <_RBTree_Extract_validate_unprotected+0x1ac>
10df3e: 89 d0 mov %edx,%eax
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
10df40: 89 da mov %ebx,%edx
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
10df42: 83 78 0c 01 cmpl $0x1,0xc(%eax)
10df46: 75 98 jne 10dee0 <_RBTree_Extract_validate_unprotected+0x20>
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
10df48: 8b 10 mov (%eax),%edx
10df4a: 8b 32 mov (%edx),%esi
10df4c: 85 f6 test %esi,%esi
10df4e: 0f 84 8e 01 00 00 je 10e0e2 <_RBTree_Extract_validate_unprotected+0x222>
}
10df54: 83 c4 08 add $0x8,%esp
10df57: 5b pop %ebx
10df58: 5e pop %esi
10df59: 5f pop %edi
10df5a: 5d pop %ebp
10df5b: c3 ret
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
10df5c: 3b 42 04 cmp 0x4(%edx),%eax
10df5f: 0f 95 c3 setne %bl
10df62: 89 dd mov %ebx,%ebp
10df64: 0f b6 f3 movzbl %bl,%esi
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
10df67: 83 f3 01 xor $0x1,%ebx
10df6a: 0f b6 db movzbl %bl,%ebx
10df6d: 89 1c 24 mov %ebx,(%esp)
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
10df70: 8b 7c 99 04 mov 0x4(%ecx,%ebx,4),%edi
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
10df74: 85 ff test %edi,%edi
10df76: 74 0a je 10df82 <_RBTree_Extract_validate_unprotected+0xc2>
10df78: 83 7f 0c 01 cmpl $0x1,0xc(%edi)
10df7c: 0f 84 f9 00 00 00 je 10e07b <_RBTree_Extract_validate_unprotected+0x1bb>
sibling->color = RBT_RED;
10df82: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx)
sibling->child[dir]->color = RBT_BLACK;
10df89: 8b 7c b1 04 mov 0x4(%ecx,%esi,4),%edi
10df8d: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
10df94: 89 eb mov %ebp,%ebx
10df96: 0f b6 eb movzbl %bl,%ebp
10df99: 89 6c 24 04 mov %ebp,0x4(%esp)
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
10df9d: 8b 6c a9 04 mov 0x4(%ecx,%ebp,4),%ebp
10dfa1: 85 ed test %ebp,%ebp
10dfa3: 74 36 je 10dfdb <_RBTree_Extract_validate_unprotected+0x11b><== NEVER TAKEN
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
10dfa5: 8b 3c 24 mov (%esp),%edi
10dfa8: 8b 5c bd 04 mov 0x4(%ebp,%edi,4),%ebx
10dfac: 8b 7c 24 04 mov 0x4(%esp),%edi
10dfb0: 89 5c b9 04 mov %ebx,0x4(%ecx,%edi,4)
if (c->child[dir])
10dfb4: 8b 1c 24 mov (%esp),%ebx
10dfb7: 8b 7c 9d 04 mov 0x4(%ebp,%ebx,4),%edi
10dfbb: 85 ff test %edi,%edi
10dfbd: 74 02 je 10dfc1 <_RBTree_Extract_validate_unprotected+0x101>
c->child[dir]->parent = the_node;
10dfbf: 89 0f mov %ecx,(%edi)
c->child[dir] = the_node;
10dfc1: 8b 3c 24 mov (%esp),%edi
10dfc4: 89 4c bd 04 mov %ecx,0x4(%ebp,%edi,4)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
10dfc8: 8b 39 mov (%ecx),%edi
10dfca: 31 db xor %ebx,%ebx
10dfcc: 3b 4f 04 cmp 0x4(%edi),%ecx
10dfcf: 0f 95 c3 setne %bl
10dfd2: 89 6c 9f 04 mov %ebp,0x4(%edi,%ebx,4)
c->parent = the_node->parent;
10dfd6: 89 7d 00 mov %edi,0x0(%ebp)
the_node->parent = c;
10dfd9: 89 29 mov %ebp,(%ecx)
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
10dfdb: 8b 3c 24 mov (%esp),%edi
10dfde: 8b 7c ba 04 mov 0x4(%edx,%edi,4),%edi
10dfe2: 89 7c 24 04 mov %edi,0x4(%esp)
10dfe6: 8b 2c 24 mov (%esp),%ebp
10dfe9: 8b 4c af 04 mov 0x4(%edi,%ebp,4),%ecx
}
sibling->color = parent->color;
10dfed: 8b 7a 0c mov 0xc(%edx),%edi
10dff0: 8b 5c 24 04 mov 0x4(%esp),%ebx
10dff4: 89 7b 0c mov %edi,0xc(%ebx)
parent->color = RBT_BLACK;
10dff7: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
10dffe: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
10e005: e9 95 00 00 00 jmp 10e09f <_RBTree_Extract_validate_unprotected+0x1df>
10e00a: 66 90 xchg %ax,%ax
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
10e00c: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
sibling->color = RBT_BLACK;
10e013: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
dir = the_node != parent->child[0];
10e01a: 39 42 04 cmp %eax,0x4(%edx)
10e01d: 0f 95 c3 setne %bl
10e020: 0f b6 f3 movzbl %bl,%esi
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
10e023: 83 f3 01 xor $0x1,%ebx
10e026: 0f b6 eb movzbl %bl,%ebp
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
10e029: 8b 4c aa 04 mov 0x4(%edx,%ebp,4),%ecx
10e02d: 85 c9 test %ecx,%ecx
10e02f: 74 43 je 10e074 <_RBTree_Extract_validate_unprotected+0x1b4><== NEVER TAKEN
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
10e031: 8b 7c b1 04 mov 0x4(%ecx,%esi,4),%edi
10e035: 89 7c aa 04 mov %edi,0x4(%edx,%ebp,4)
if (c->child[dir])
10e039: 8b 7c b1 04 mov 0x4(%ecx,%esi,4),%edi
10e03d: 85 ff test %edi,%edi
10e03f: 74 02 je 10e043 <_RBTree_Extract_validate_unprotected+0x183><== NEVER TAKEN
c->child[dir]->parent = the_node;
10e041: 89 17 mov %edx,(%edi)
c->child[dir] = the_node;
10e043: 89 54 b1 04 mov %edx,0x4(%ecx,%esi,4)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
10e047: 8b 32 mov (%edx),%esi
10e049: 31 db xor %ebx,%ebx
10e04b: 3b 56 04 cmp 0x4(%esi),%edx
10e04e: 0f 95 c3 setne %bl
10e051: 89 df mov %ebx,%edi
10e053: 89 4c be 04 mov %ecx,0x4(%esi,%edi,4)
c->parent = the_node->parent;
10e057: 89 31 mov %esi,(%ecx)
the_node->parent = c;
10e059: 89 0a mov %ecx,(%edx)
10e05b: 8b 4c aa 04 mov 0x4(%edx,%ebp,4),%ecx
10e05f: e9 90 fe ff ff jmp 10def4 <_RBTree_Extract_validate_unprotected+0x34>
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
10e064: 31 c9 xor %ecx,%ecx
10e066: e9 d3 fe ff ff jmp 10df3e <_RBTree_Extract_validate_unprotected+0x7e>
10e06b: 90 nop
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
10e06c: 8b 4b 08 mov 0x8(%ebx),%ecx
10e06f: e9 ca fe ff ff jmp 10df3e <_RBTree_Extract_validate_unprotected+0x7e>
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
10e074: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10e076: e9 79 fe ff ff jmp 10def4 <_RBTree_Extract_validate_unprotected+0x34><== NOT EXECUTED
10e07b: 8b 6c 9a 04 mov 0x4(%edx,%ebx,4),%ebp
10e07f: 89 6c 24 04 mov %ebp,0x4(%esp)
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
10e083: 8b 5a 0c mov 0xc(%edx),%ebx
10e086: 89 59 0c mov %ebx,0xc(%ecx)
parent->color = RBT_BLACK;
10e089: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
10e090: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
10e097: 85 ed test %ebp,%ebp
10e099: 0f 84 a9 fe ff ff je 10df48 <_RBTree_Extract_validate_unprotected+0x88><== NEVER TAKEN
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
10e09f: 8b 7c 24 04 mov 0x4(%esp),%edi
10e0a3: 8b 4c b7 04 mov 0x4(%edi,%esi,4),%ecx
10e0a7: 8b 2c 24 mov (%esp),%ebp
10e0aa: 89 4c aa 04 mov %ecx,0x4(%edx,%ebp,4)
if (c->child[dir])
10e0ae: 8b 4c b7 04 mov 0x4(%edi,%esi,4),%ecx
10e0b2: 85 c9 test %ecx,%ecx
10e0b4: 74 02 je 10e0b8 <_RBTree_Extract_validate_unprotected+0x1f8>
c->child[dir]->parent = the_node;
10e0b6: 89 11 mov %edx,(%ecx)
c->child[dir] = the_node;
10e0b8: 8b 4c 24 04 mov 0x4(%esp),%ecx
10e0bc: 89 54 b1 04 mov %edx,0x4(%ecx,%esi,4)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
10e0c0: 8b 0a mov (%edx),%ecx
10e0c2: 31 db xor %ebx,%ebx
10e0c4: 3b 51 04 cmp 0x4(%ecx),%edx
10e0c7: 0f 95 c3 setne %bl
10e0ca: 8b 74 24 04 mov 0x4(%esp),%esi
10e0ce: 89 74 99 04 mov %esi,0x4(%ecx,%ebx,4)
c->parent = the_node->parent;
10e0d2: 89 0e mov %ecx,(%esi)
the_node->parent = c;
10e0d4: 89 32 mov %esi,(%edx)
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
10e0d6: 8b 10 mov (%eax),%edx
10e0d8: 8b 32 mov (%edx),%esi
10e0da: 85 f6 test %esi,%esi
10e0dc: 0f 85 72 fe ff ff jne 10df54 <_RBTree_Extract_validate_unprotected+0x94><== ALWAYS TAKEN
10e0e2: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10e0e9: e9 66 fe ff ff jmp 10df54 <_RBTree_Extract_validate_unprotected+0x94>
10e0ee: 66 90 xchg %ax,%ax
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
10e0f0: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
break;
10e0f7: e9 4c fe ff ff jmp 10df48 <_RBTree_Extract_validate_unprotected+0x88>
0010e7c0 <_RBTree_Find>:
RBTree_Node *_RBTree_Find(
RBTree_Control *the_rbtree,
RBTree_Node *search_node
)
{
10e7c0: 55 push %ebp
10e7c1: 57 push %edi
10e7c2: 56 push %esi
10e7c3: 53 push %ebx
10e7c4: 83 ec 2c sub $0x2c,%esp
10e7c7: 8b 5c 24 40 mov 0x40(%esp),%ebx
10e7cb: 8b 74 24 44 mov 0x44(%esp),%esi
ISR_Level level;
RBTree_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
10e7cf: 9c pushf
10e7d0: fa cli
10e7d1: 8f 44 24 1c popl 0x1c(%esp)
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
10e7d5: 8b 6b 04 mov 0x4(%ebx),%ebp
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
10e7d8: 31 ff xor %edi,%edi
10e7da: 85 ed test %ebp,%ebp
10e7dc: 74 28 je 10e806 <_RBTree_Find+0x46> <== NEVER TAKEN
10e7de: 66 90 xchg %ax,%ax
compare_result = the_rbtree->compare_function(the_node, iter_node);
10e7e0: 89 6c 24 04 mov %ebp,0x4(%esp)
10e7e4: 89 34 24 mov %esi,(%esp)
10e7e7: ff 53 10 call *0x10(%ebx)
if ( _RBTree_Is_equal( compare_result ) ) {
10e7ea: 85 c0 test %eax,%eax
10e7ec: 75 08 jne 10e7f6 <_RBTree_Find+0x36>
found = iter_node;
if ( the_rbtree->is_unique )
10e7ee: 89 ef mov %ebp,%edi
10e7f0: 80 7b 14 00 cmpb $0x0,0x14(%ebx)
10e7f4: 75 10 jne 10e806 <_RBTree_Find+0x46>
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
10e7f6: 85 c0 test %eax,%eax
10e7f8: 0f 9f c0 setg %al
10e7fb: 0f b6 c0 movzbl %al,%eax
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
10e7fe: 8b 6c 85 04 mov 0x4(%ebp,%eax,4),%ebp
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
10e802: 85 ed test %ebp,%ebp
10e804: 75 da jne 10e7e0 <_RBTree_Find+0x20>
return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
_ISR_Enable( level );
10e806: ff 74 24 1c pushl 0x1c(%esp)
10e80a: 9d popf
return return_node;
}
10e80b: 89 f8 mov %edi,%eax
10e80d: 83 c4 2c add $0x2c,%esp
10e810: 5b pop %ebx
10e811: 5e pop %esi
10e812: 5f pop %edi
10e813: 5d pop %ebp
10e814: c3 ret
0010eb08 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
10eb08: 55 push %ebp
10eb09: 57 push %edi
10eb0a: 56 push %esi
10eb0b: 53 push %ebx
10eb0c: 83 ec 1c sub $0x1c,%esp
10eb0f: 8b 7c 24 30 mov 0x30(%esp),%edi
10eb13: 8b 5c 24 3c mov 0x3c(%esp),%ebx
10eb17: 8b 6c 24 40 mov 0x40(%esp),%ebp
10eb1b: 8b 44 24 44 mov 0x44(%esp),%eax
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
10eb1f: 85 ff test %edi,%edi
10eb21: 74 3e je 10eb61 <_RBTree_Initialize+0x59><== NEVER TAKEN
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
10eb23: c7 07 00 00 00 00 movl $0x0,(%edi)
the_rbtree->root = NULL;
10eb29: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
the_rbtree->first[0] = NULL;
10eb30: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
the_rbtree->first[1] = NULL;
10eb37: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
the_rbtree->compare_function = compare_function;
10eb3e: 8b 54 24 34 mov 0x34(%esp),%edx
10eb42: 89 57 10 mov %edx,0x10(%edi)
the_rbtree->is_unique = is_unique;
10eb45: 88 47 14 mov %al,0x14(%edi)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
10eb48: 85 db test %ebx,%ebx
10eb4a: 74 15 je 10eb61 <_RBTree_Initialize+0x59><== NEVER TAKEN
10eb4c: 8b 74 24 38 mov 0x38(%esp),%esi
_RBTree_Insert_unprotected(the_rbtree, next);
10eb50: 89 74 24 04 mov %esi,0x4(%esp)
10eb54: 89 3c 24 mov %edi,(%esp)
10eb57: e8 e8 fc ff ff call 10e844 <_RBTree_Insert_unprotected>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
10eb5c: 01 ee add %ebp,%esi
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
10eb5e: 4b dec %ebx
10eb5f: 75 ef jne 10eb50 <_RBTree_Initialize+0x48>
_RBTree_Insert_unprotected(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
10eb61: 83 c4 1c add $0x1c,%esp
10eb64: 5b pop %ebx
10eb65: 5e pop %esi
10eb66: 5f pop %edi
10eb67: 5d pop %ebp
10eb68: c3 ret
0010e264 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
10e264: 55 push %ebp
10e265: 57 push %edi
10e266: 56 push %esi
10e267: 53 push %ebx
10e268: 83 ec 2c sub $0x2c,%esp
10e26b: 8b 6c 24 40 mov 0x40(%esp),%ebp
10e26f: 8b 5c 24 44 mov 0x44(%esp),%ebx
if(!the_node) return (RBTree_Node*)-1;
10e273: 85 db test %ebx,%ebx
10e275: 0f 84 c5 01 00 00 je 10e440 <_RBTree_Insert_unprotected+0x1dc>
RBTree_Node *iter_node = the_rbtree->root;
10e27b: 8b 7d 04 mov 0x4(%ebp),%edi
int compare_result;
if (!iter_node) { /* special case: first node inserted */
10e27e: 85 ff test %edi,%edi
10e280: 75 08 jne 10e28a <_RBTree_Insert_unprotected+0x26>
10e282: e9 d6 01 00 00 jmp 10e45d <_RBTree_Insert_unprotected+0x1f9>
10e287: 90 nop
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
}
break;
} else {
iter_node = iter_node->child[dir];
10e288: 89 d7 mov %edx,%edi
the_node->parent = (RBTree_Node *) the_rbtree;
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
10e28a: 89 7c 24 04 mov %edi,0x4(%esp)
10e28e: 89 1c 24 mov %ebx,(%esp)
10e291: ff 55 10 call *0x10(%ebp)
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
10e294: 80 7d 14 00 cmpb $0x0,0x14(%ebp)
10e298: 74 08 je 10e2a2 <_RBTree_Insert_unprotected+0x3e>
10e29a: 85 c0 test %eax,%eax
10e29c: 0f 84 b2 01 00 00 je 10e454 <_RBTree_Insert_unprotected+0x1f0>
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
10e2a2: f7 d0 not %eax
10e2a4: c1 e8 1f shr $0x1f,%eax
if (!iter_node->child[dir]) {
10e2a7: 8b 54 87 04 mov 0x4(%edi,%eax,4),%edx
10e2ab: 85 d2 test %edx,%edx
10e2ad: 75 d9 jne 10e288 <_RBTree_Insert_unprotected+0x24>
10e2af: 89 54 24 1c mov %edx,0x1c(%esp)
10e2b3: 89 c6 mov %eax,%esi
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
10e2b5: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
10e2bc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
the_node->color = RBT_RED;
10e2c3: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx)
iter_node->child[dir] = the_node;
10e2ca: 89 5c 87 04 mov %ebx,0x4(%edi,%eax,4)
the_node->parent = iter_node;
10e2ce: 89 3b mov %edi,(%ebx)
/* update min/max */
compare_result = the_rbtree->compare_function(
10e2d0: 8b 44 85 08 mov 0x8(%ebp,%eax,4),%eax
10e2d4: 89 44 24 04 mov %eax,0x4(%esp)
10e2d8: 89 1c 24 mov %ebx,(%esp)
10e2db: ff 55 10 call *0x10(%ebp)
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
10e2de: 85 f6 test %esi,%esi
10e2e0: 75 2e jne 10e310 <_RBTree_Insert_unprotected+0xac>
10e2e2: 85 c0 test %eax,%eax
10e2e4: 78 2e js 10e314 <_RBTree_Insert_unprotected+0xb0>
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
10e2e6: 89 5c 24 18 mov %ebx,0x18(%esp)
_ISR_Disable( level );
return_node = _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
return return_node;
}
10e2ea: 8b 54 24 18 mov 0x18(%esp),%edx
10e2ee: 8b 02 mov (%edx),%eax
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
10e2f0: 8b 10 mov (%eax),%edx
10e2f2: 89 d1 mov %edx,%ecx
10e2f4: 85 d2 test %edx,%edx
10e2f6: 0f 84 03 01 00 00 je 10e3ff <_RBTree_Insert_unprotected+0x19b>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
10e2fc: 83 78 0c 01 cmpl $0x1,0xc(%eax)
10e300: 74 1a je 10e31c <_RBTree_Insert_unprotected+0xb8>
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
10e302: 8b 44 24 1c mov 0x1c(%esp),%eax
10e306: 83 c4 2c add $0x2c,%esp
10e309: 5b pop %ebx
10e30a: 5e pop %esi
10e30b: 5f pop %edi
10e30c: 5d pop %ebp
10e30d: c3 ret
10e30e: 66 90 xchg %ax,%ax
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
10e310: 85 c0 test %eax,%eax
10e312: 7e d2 jle 10e2e6 <_RBTree_Insert_unprotected+0x82>
the_rbtree->first[dir] = the_node;
10e314: 89 5c b5 08 mov %ebx,0x8(%ebp,%esi,4)
10e318: eb cc jmp 10e2e6 <_RBTree_Insert_unprotected+0x82>
10e31a: 66 90 xchg %ax,%ax
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(!(the_node->parent->parent->parent)) return NULL;
10e31c: 8b 1a mov (%edx),%ebx
10e31e: 85 db test %ebx,%ebx
10e320: 8b 72 04 mov 0x4(%edx),%esi
10e323: 74 18 je 10e33d <_RBTree_Insert_unprotected+0xd9><== NEVER TAKEN
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
10e325: 39 f0 cmp %esi,%eax
10e327: 0f 84 0b 01 00 00 je 10e438 <_RBTree_Insert_unprotected+0x1d4>
10e32d: 89 f7 mov %esi,%edi
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
10e32f: 85 ff test %edi,%edi
10e331: 74 0a je 10e33d <_RBTree_Insert_unprotected+0xd9>
10e333: 83 7f 0c 01 cmpl $0x1,0xc(%edi)
10e337: 0f 84 db 00 00 00 je 10e418 <_RBTree_Insert_unprotected+0x1b4>
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
RBTree_Direction pdir = the_node->parent != g->child[0];
10e33d: 31 db xor %ebx,%ebx
10e33f: 39 f0 cmp %esi,%eax
10e341: 0f 95 c3 setne %bl
10e344: 89 de mov %ebx,%esi
the_node->parent->color = RBT_BLACK;
u->color = RBT_BLACK;
g->color = RBT_RED;
the_node = g;
} else { /* if uncle is black */
RBTree_Direction dir = the_node != the_node->parent->child[0];
10e346: 8b 5c 24 18 mov 0x18(%esp),%ebx
10e34a: 3b 58 04 cmp 0x4(%eax),%ebx
10e34d: 0f 95 c3 setne %bl
10e350: 0f b6 db movzbl %bl,%ebx
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
10e353: 39 f3 cmp %esi,%ebx
10e355: 74 46 je 10e39d <_RBTree_Insert_unprotected+0x139>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
10e357: 89 f3 mov %esi,%ebx
10e359: 83 f3 01 xor $0x1,%ebx
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
10e35c: 8b 7c 98 04 mov 0x4(%eax,%ebx,4),%edi
10e360: 85 ff test %edi,%edi
10e362: 74 2b je 10e38f <_RBTree_Insert_unprotected+0x12b><== NEVER TAKEN
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
10e364: 8b 6c b7 04 mov 0x4(%edi,%esi,4),%ebp
10e368: 89 6c 98 04 mov %ebp,0x4(%eax,%ebx,4)
if (c->child[dir])
10e36c: 8b 6c b7 04 mov 0x4(%edi,%esi,4),%ebp
10e370: 85 ed test %ebp,%ebp
10e372: 74 05 je 10e379 <_RBTree_Insert_unprotected+0x115>
c->child[dir]->parent = the_node;
10e374: 89 45 00 mov %eax,0x0(%ebp)
10e377: 8b 10 mov (%eax),%edx
c->child[dir] = the_node;
10e379: 89 44 b7 04 mov %eax,0x4(%edi,%esi,4)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
10e37d: 31 db xor %ebx,%ebx
10e37f: 3b 42 04 cmp 0x4(%edx),%eax
10e382: 0f 95 c3 setne %bl
10e385: 89 dd mov %ebx,%ebp
10e387: 89 7c aa 04 mov %edi,0x4(%edx,%ebp,4)
c->parent = the_node->parent;
10e38b: 89 17 mov %edx,(%edi)
the_node->parent = c;
10e38d: 89 38 mov %edi,(%eax)
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
10e38f: 8b 44 24 18 mov 0x18(%esp),%eax
10e393: 8b 44 b0 04 mov 0x4(%eax,%esi,4),%eax
10e397: 89 44 24 18 mov %eax,0x18(%esp)
10e39b: 8b 00 mov (%eax),%eax
}
the_node->parent->color = RBT_BLACK;
10e39d: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
g->color = RBT_RED;
10e3a4: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx)
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
10e3ab: ba 01 00 00 00 mov $0x1,%edx
10e3b0: 29 f2 sub %esi,%edx
10e3b2: 89 d6 mov %edx,%esi
10e3b4: 83 f6 01 xor $0x1,%esi
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
10e3b7: 8b 44 b1 04 mov 0x4(%ecx,%esi,4),%eax
10e3bb: 85 c0 test %eax,%eax
10e3bd: 0f 84 27 ff ff ff je 10e2ea <_RBTree_Insert_unprotected+0x86><== NEVER TAKEN
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
10e3c3: 8b 7c 90 04 mov 0x4(%eax,%edx,4),%edi
10e3c7: 89 7c b1 04 mov %edi,0x4(%ecx,%esi,4)
if (c->child[dir])
10e3cb: 8b 74 90 04 mov 0x4(%eax,%edx,4),%esi
10e3cf: 85 f6 test %esi,%esi
10e3d1: 74 02 je 10e3d5 <_RBTree_Insert_unprotected+0x171>
c->child[dir]->parent = the_node;
10e3d3: 89 0e mov %ecx,(%esi)
c->child[dir] = the_node;
10e3d5: 89 4c 90 04 mov %ecx,0x4(%eax,%edx,4)
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
10e3d9: 8b 11 mov (%ecx),%edx
10e3db: 31 db xor %ebx,%ebx
10e3dd: 3b 4a 04 cmp 0x4(%edx),%ecx
10e3e0: 0f 95 c3 setne %bl
10e3e3: 89 de mov %ebx,%esi
10e3e5: 89 44 b2 04 mov %eax,0x4(%edx,%esi,4)
c->parent = the_node->parent;
10e3e9: 89 10 mov %edx,(%eax)
the_node->parent = c;
10e3eb: 89 01 mov %eax,(%ecx)
_ISR_Disable( level );
return_node = _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
return return_node;
}
10e3ed: 8b 54 24 18 mov 0x18(%esp),%edx
10e3f1: 8b 02 mov (%edx),%eax
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
10e3f3: 8b 10 mov (%eax),%edx
10e3f5: 89 d1 mov %edx,%ecx
10e3f7: 85 d2 test %edx,%edx
10e3f9: 0f 85 fd fe ff ff jne 10e2fc <_RBTree_Insert_unprotected+0x98><== ALWAYS TAKEN
10e3ff: 8b 5c 24 18 mov 0x18(%esp),%ebx
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
}
}
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
10e403: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
10e40a: 8b 44 24 1c mov 0x1c(%esp),%eax
10e40e: 83 c4 2c add $0x2c,%esp
10e411: 5b pop %ebx
10e412: 5e pop %esi
10e413: 5f pop %edi
10e414: 5d pop %ebp
10e415: c3 ret
10e416: 66 90 xchg %ax,%ax
u = _RBTree_Parent_sibling(the_node);
g = the_node->parent->parent;
/* if uncle is red, repaint uncle/parent black and grandparent red */
if(_RBTree_Is_red(u)) {
the_node->parent->color = RBT_BLACK;
10e418: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
u->color = RBT_BLACK;
10e41f: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
g->color = RBT_RED;
10e426: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
10e42d: 89 54 24 18 mov %edx,0x18(%esp)
10e431: e9 b4 fe ff ff jmp 10e2ea <_RBTree_Insert_unprotected+0x86>
10e436: 66 90 xchg %ax,%ax
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
10e438: 8b 7a 08 mov 0x8(%edx),%edi
10e43b: e9 ef fe ff ff jmp 10e32f <_RBTree_Insert_unprotected+0xcb>
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
if(!the_node) return (RBTree_Node*)-1;
10e440: c7 44 24 1c ff ff ff movl $0xffffffff,0x1c(%esp)
10e447: ff
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
10e448: 8b 44 24 1c mov 0x1c(%esp),%eax
10e44c: 83 c4 2c add $0x2c,%esp
10e44f: 5b pop %ebx
10e450: 5e pop %esi
10e451: 5f pop %edi
10e452: 5d pop %ebp
10e453: c3 ret
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
10e454: 89 7c 24 1c mov %edi,0x1c(%esp)
10e458: e9 a5 fe ff ff jmp 10e302 <_RBTree_Insert_unprotected+0x9e>
RBTree_Node *iter_node = the_rbtree->root;
int compare_result;
if (!iter_node) { /* special case: first node inserted */
the_node->color = RBT_BLACK;
10e45d: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_rbtree->root = the_node;
10e464: 89 5d 04 mov %ebx,0x4(%ebp)
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
10e467: 89 5d 0c mov %ebx,0xc(%ebp)
10e46a: 89 5d 08 mov %ebx,0x8(%ebp)
the_node->parent = (RBTree_Node *) the_rbtree;
10e46d: 89 2b mov %ebp,(%ebx)
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
10e46f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
10e476: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
} /* while(iter_node) */
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
10e47d: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp)
10e484: 00
10e485: e9 78 fe ff ff jmp 10e302 <_RBTree_Insert_unprotected+0x9e>
0010e4b0 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
10e4b0: 55 push %ebp
10e4b1: 57 push %edi
10e4b2: 56 push %esi
10e4b3: 53 push %ebx
10e4b4: 83 ec 1c sub $0x1c,%esp
10e4b7: 8b 74 24 34 mov 0x34(%esp),%esi
10e4bb: 8b 6c 24 38 mov 0x38(%esp),%ebp
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
10e4bf: 31 d2 xor %edx,%edx
10e4c1: 85 f6 test %esi,%esi
10e4c3: 0f 94 c2 sete %dl
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
10e4c6: 8b 44 24 30 mov 0x30(%esp),%eax
10e4ca: 8b 5c 90 08 mov 0x8(%eax,%edx,4),%ebx
10e4ce: 66 90 xchg %ax,%ax
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
10e4d0: 85 db test %ebx,%ebx
10e4d2: 74 27 je 10e4fb <_RBTree_Iterate_unprotected+0x4b>
stop = (*visitor)( current, dir, visitor_arg );
10e4d4: 8b 44 24 3c mov 0x3c(%esp),%eax
10e4d8: 89 44 24 08 mov %eax,0x8(%esp)
10e4dc: 89 74 24 04 mov %esi,0x4(%esp)
10e4e0: 89 1c 24 mov %ebx,(%esp)
10e4e3: ff d5 call *%ebp
10e4e5: 89 c7 mov %eax,%edi
current = _RBTree_Next_unprotected( current, dir );
10e4e7: 89 74 24 04 mov %esi,0x4(%esp)
10e4eb: 89 1c 24 mov %ebx,(%esp)
10e4ee: e8 11 00 00 00 call 10e504 <_RBTree_Next_unprotected>
10e4f3: 89 c3 mov %eax,%ebx
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
10e4f5: 89 f8 mov %edi,%eax
10e4f7: 84 c0 test %al,%al
10e4f9: 74 d5 je 10e4d0 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
stop = (*visitor)( current, dir, visitor_arg );
current = _RBTree_Next_unprotected( current, dir );
}
}
10e4fb: 83 c4 1c add $0x1c,%esp
10e4fe: 5b pop %ebx
10e4ff: 5e pop %esi
10e500: 5f pop %edi
10e501: 5d pop %ebp
10e502: c3 ret
0010bda0 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10bda0: 55 push %ebp
10bda1: 57 push %edi
10bda2: 56 push %esi
10bda3: 53 push %ebx
10bda4: 83 ec 3c sub $0x3c,%esp
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
10bda7: 8b 1d ec b1 12 00 mov 0x12b1ec,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10bdad: 8b 3d e8 b1 12 00 mov 0x12b1e8,%edi
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
10bdb3: 85 db test %ebx,%ebx
10bdb5: 74 61 je 10be18 <_RTEMS_tasks_Initialize_user_tasks_body+0x78>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10bdb7: 85 ff test %edi,%edi
10bdb9: 74 5d je 10be18 <_RTEMS_tasks_Initialize_user_tasks_body+0x78><== NEVER TAKEN
10bdbb: 31 f6 xor %esi,%esi
10bdbd: 8d 6c 24 2c lea 0x2c(%esp),%ebp
10bdc1: 8d 76 00 lea 0x0(%esi),%esi
return_value = rtems_task_create(
10bdc4: 89 6c 24 14 mov %ebp,0x14(%esp)
10bdc8: 8b 43 0c mov 0xc(%ebx),%eax
10bdcb: 89 44 24 10 mov %eax,0x10(%esp)
10bdcf: 8b 43 14 mov 0x14(%ebx),%eax
10bdd2: 89 44 24 0c mov %eax,0xc(%esp)
10bdd6: 8b 43 04 mov 0x4(%ebx),%eax
10bdd9: 89 44 24 08 mov %eax,0x8(%esp)
10bddd: 8b 43 08 mov 0x8(%ebx),%eax
10bde0: 89 44 24 04 mov %eax,0x4(%esp)
10bde4: 8b 03 mov (%ebx),%eax
10bde6: 89 04 24 mov %eax,(%esp)
10bde9: e8 5a fd ff ff call 10bb48 <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 ) )
10bdee: 85 c0 test %eax,%eax
10bdf0: 75 2e jne 10be20 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
10bdf2: 8b 43 18 mov 0x18(%ebx),%eax
10bdf5: 89 44 24 08 mov %eax,0x8(%esp)
10bdf9: 8b 43 10 mov 0x10(%ebx),%eax
10bdfc: 89 44 24 04 mov %eax,0x4(%esp)
10be00: 8b 44 24 2c mov 0x2c(%esp),%eax
10be04: 89 04 24 mov %eax,(%esp)
10be07: e8 2c 00 00 00 call 10be38 <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10be0c: 85 c0 test %eax,%eax
10be0e: 75 10 jne 10be20 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10be10: 46 inc %esi
10be11: 83 c3 1c add $0x1c,%ebx
10be14: 39 fe cmp %edi,%esi
10be16: 75 ac jne 10bdc4 <_RTEMS_tasks_Initialize_user_tasks_body+0x24><== NEVER TAKEN
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
10be18: 83 c4 3c add $0x3c,%esp
10be1b: 5b pop %ebx
10be1c: 5e pop %esi
10be1d: 5f pop %edi
10be1e: 5d pop %ebp
10be1f: 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 );
10be20: 89 44 24 08 mov %eax,0x8(%esp)
10be24: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10be2b: 00
10be2c: c7 04 24 01 00 00 00 movl $0x1,(%esp)
10be33: e8 88 0d 00 00 call 10cbc0 <_Internal_error_Occurred>
00110a64 <_RTEMS_tasks_Post_switch_extension>:
*/
static void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
110a64: 57 push %edi
110a65: 56 push %esi
110a66: 53 push %ebx
110a67: 83 ec 20 sub $0x20,%esp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110a6a: 8b 44 24 30 mov 0x30(%esp),%eax
110a6e: 8b 98 e0 00 00 00 mov 0xe0(%eax),%ebx
if ( !api )
110a74: 85 db test %ebx,%ebx
110a76: 74 13 je 110a8b <_RTEMS_tasks_Post_switch_extension+0x27><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
110a78: 9c pushf
110a79: fa cli
110a7a: 58 pop %eax
signal_set = asr->signals_posted;
110a7b: 8b 73 14 mov 0x14(%ebx),%esi
asr->signals_posted = 0;
110a7e: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
_ISR_Enable( level );
110a85: 50 push %eax
110a86: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
110a87: 85 f6 test %esi,%esi
110a89: 75 09 jne 110a94 <_RTEMS_tasks_Post_switch_extension+0x30>
(*asr->handler)( signal_set );
asr->nest_level -= 1;
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
}
110a8b: 83 c4 20 add $0x20,%esp
110a8e: 5b pop %ebx
110a8f: 5e pop %esi
110a90: 5f pop %edi
110a91: c3 ret
110a92: 66 90 xchg %ax,%ax
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
110a94: ff 43 1c incl 0x1c(%ebx)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
110a97: 8d 7c 24 1c lea 0x1c(%esp),%edi
110a9b: 89 7c 24 08 mov %edi,0x8(%esp)
110a9f: c7 44 24 04 ff ff 00 movl $0xffff,0x4(%esp)
110aa6: 00
110aa7: 8b 43 10 mov 0x10(%ebx),%eax
110aaa: 89 04 24 mov %eax,(%esp)
110aad: e8 16 1e 00 00 call 1128c8 <rtems_task_mode>
(*asr->handler)( signal_set );
110ab2: 89 34 24 mov %esi,(%esp)
110ab5: ff 53 0c call *0xc(%ebx)
asr->nest_level -= 1;
110ab8: ff 4b 1c decl 0x1c(%ebx)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
110abb: 89 7c 24 08 mov %edi,0x8(%esp)
110abf: c7 44 24 04 ff ff 00 movl $0xffff,0x4(%esp)
110ac6: 00
110ac7: 8b 44 24 1c mov 0x1c(%esp),%eax
110acb: 89 04 24 mov %eax,(%esp)
110ace: e8 f5 1d 00 00 call 1128c8 <rtems_task_mode>
}
110ad3: 83 c4 20 add $0x20,%esp
110ad6: 5b pop %ebx
110ad7: 5e pop %esi
110ad8: 5f pop %edi
110ad9: c3 ret
00110920 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
110920: 8b 44 24 04 mov 0x4(%esp),%eax
110924: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
while (tvp) {
11092a: 85 c0 test %eax,%eax
11092c: 74 15 je 110943 <_RTEMS_tasks_Switch_extension+0x23>
11092e: 66 90 xchg %ax,%ax
tvp->tval = *tvp->ptr;
110930: 8b 50 04 mov 0x4(%eax),%edx
110933: 8b 0a mov (%edx),%ecx
110935: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
110938: 8b 48 08 mov 0x8(%eax),%ecx
11093b: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
11093d: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
11093f: 85 c0 test %eax,%eax
110941: 75 ed jne 110930 <_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;
110943: 8b 44 24 08 mov 0x8(%esp),%eax
110947: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
while (tvp) {
11094d: 85 c0 test %eax,%eax
11094f: 74 17 je 110968 <_RTEMS_tasks_Switch_extension+0x48>
110951: 8d 76 00 lea 0x0(%esi),%esi
tvp->gval = *tvp->ptr;
110954: 8b 50 04 mov 0x4(%eax),%edx
110957: 8b 0a mov (%edx),%ecx
110959: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
11095c: 8b 48 0c mov 0xc(%eax),%ecx
11095f: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110961: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
110963: 85 c0 test %eax,%eax
110965: 75 ed jne 110954 <_RTEMS_tasks_Switch_extension+0x34><== NEVER TAKEN
110967: c3 ret
110968: c3 ret
001373e8 <_Rate_monotonic_Get_status>:
bool _Rate_monotonic_Get_status(
Rate_monotonic_Control *the_period,
Rate_monotonic_Period_time_t *wall_since_last_period,
Thread_CPU_usage_t *cpu_since_last_period
)
{
1373e8: 55 push %ebp
1373e9: 57 push %edi
1373ea: 56 push %esi
1373eb: 53 push %ebx
1373ec: 83 ec 2c sub $0x2c,%esp
1373ef: 8b 74 24 40 mov 0x40(%esp),%esi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
1373f3: 8b 7e 40 mov 0x40(%esi),%edi
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
1373f6: 8d 44 24 18 lea 0x18(%esp),%eax
1373fa: 89 04 24 mov %eax,(%esp)
1373fd: e8 a6 bd fd ff call 1131a8 <_TOD_Get_uptime>
_Timestamp_Subtract(
137402: 8b 44 24 18 mov 0x18(%esp),%eax
137406: 8b 54 24 1c mov 0x1c(%esp),%edx
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
13740a: 89 c1 mov %eax,%ecx
13740c: 89 d3 mov %edx,%ebx
13740e: 2b 4e 4c sub 0x4c(%esi),%ecx
137411: 1b 5e 50 sbb 0x50(%esi),%ebx
137414: 8b 6c 24 44 mov 0x44(%esp),%ebp
137418: 89 4d 00 mov %ecx,0x0(%ebp)
13741b: 89 5d 04 mov %ebx,0x4(%ebp)
#endif
/*
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
13741e: 8b 8f 80 00 00 00 mov 0x80(%edi),%ecx
137424: 8b 9f 84 00 00 00 mov 0x84(%edi),%ebx
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
13742a: 39 3d cc b3 17 00 cmp %edi,0x17b3cc
137430: 74 0a je 13743c <_Rate_monotonic_Get_status+0x54>
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
137432: b0 01 mov $0x1,%al
}
137434: 83 c4 2c add $0x2c,%esp
137437: 5b pop %ebx
137438: 5e pop %esi
137439: 5f pop %edi
13743a: 5d pop %ebp
13743b: c3 ret
13743c: 2b 05 dc b3 17 00 sub 0x17b3dc,%eax
137442: 1b 15 e0 b3 17 00 sbb 0x17b3e0,%edx
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
137448: 01 c8 add %ecx,%eax
13744a: 11 da adc %ebx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
13744c: 8b 4e 44 mov 0x44(%esi),%ecx
13744f: 8b 5e 48 mov 0x48(%esi),%ebx
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
137452: 39 d3 cmp %edx,%ebx
137454: 7f 06 jg 13745c <_Rate_monotonic_Get_status+0x74><== NEVER TAKEN
137456: 7c 08 jl 137460 <_Rate_monotonic_Get_status+0x78>
137458: 39 c1 cmp %eax,%ecx
13745a: 76 04 jbe 137460 <_Rate_monotonic_Get_status+0x78>
return false;
13745c: 31 c0 xor %eax,%eax
13745e: eb d4 jmp 137434 <_Rate_monotonic_Get_status+0x4c>
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
137460: 29 c8 sub %ecx,%eax
137462: 19 da sbb %ebx,%edx
137464: 8b 4c 24 48 mov 0x48(%esp),%ecx
137468: 89 01 mov %eax,(%ecx)
13746a: 89 51 04 mov %edx,0x4(%ecx)
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
13746d: b0 01 mov $0x1,%al
}
13746f: 83 c4 2c add $0x2c,%esp
137472: 5b pop %ebx
137473: 5e pop %esi
137474: 5f pop %edi
137475: 5d pop %ebp
137476: c3 ret
00137778 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
137778: 83 ec 3c sub $0x3c,%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 );
13777b: 8d 44 24 2c lea 0x2c(%esp),%eax
13777f: 89 44 24 08 mov %eax,0x8(%esp)
137783: 8b 44 24 40 mov 0x40(%esp),%eax
137787: 89 44 24 04 mov %eax,0x4(%esp)
13778b: c7 04 24 20 b6 17 00 movl $0x17b620,(%esp)
137792: e8 c5 56 fd ff call 10ce5c <_Objects_Get>
switch ( location ) {
137797: 8b 54 24 2c mov 0x2c(%esp),%edx
13779b: 85 d2 test %edx,%edx
13779d: 75 2e jne 1377cd <_Rate_monotonic_Timeout+0x55><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
13779f: 8b 50 40 mov 0x40(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
1377a2: f6 42 11 40 testb $0x40,0x11(%edx)
1377a6: 74 08 je 1377b0 <_Rate_monotonic_Timeout+0x38>
1377a8: 8b 48 08 mov 0x8(%eax),%ecx
1377ab: 39 4a 20 cmp %ecx,0x20(%edx)
1377ae: 74 58 je 137808 <_Rate_monotonic_Timeout+0x90>
_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 ) {
1377b0: 83 78 38 01 cmpl $0x1,0x38(%eax)
1377b4: 74 1e je 1377d4 <_Rate_monotonic_Timeout+0x5c>
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
1377b6: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
1377bd: a1 64 b1 17 00 mov 0x17b164,%eax
1377c2: 48 dec %eax
1377c3: a3 64 b1 17 00 mov %eax,0x17b164
return _Thread_Dispatch_disable_level;
1377c8: a1 64 b1 17 00 mov 0x17b164,%eax
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
1377cd: 83 c4 3c add $0x3c,%esp
1377d0: c3 ret
1377d1: 8d 76 00 lea 0x0(%esi),%esi
_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;
1377d4: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax)
_Rate_monotonic_Initiate_statistics( the_period );
1377db: 89 04 24 mov %eax,(%esp)
1377de: 89 44 24 1c mov %eax,0x1c(%esp)
1377e2: e8 71 fd ff ff call 137558 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
1377e7: 8b 44 24 1c mov 0x1c(%esp),%eax
1377eb: 8b 50 3c mov 0x3c(%eax),%edx
1377ee: 89 50 1c mov %edx,0x1c(%eax)
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
1377f1: 83 c0 10 add $0x10,%eax
1377f4: 89 44 24 04 mov %eax,0x4(%esp)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
1377f8: c7 04 24 08 b2 17 00 movl $0x17b208,(%esp)
1377ff: e8 50 6e fd ff call 10e654 <_Watchdog_Insert>
137804: eb b7 jmp 1377bd <_Rate_monotonic_Timeout+0x45>
137806: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
137808: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp)
13780f: 10
137810: 89 14 24 mov %edx,(%esp)
137813: 89 44 24 1c mov %eax,0x1c(%esp)
137817: e8 b0 5e fd ff call 10d6cc <_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 );
13781c: 8b 44 24 1c mov 0x1c(%esp),%eax
137820: 89 04 24 mov %eax,(%esp)
137823: eb bd jmp 1377e2 <_Rate_monotonic_Timeout+0x6a>
00137478 <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
137478: 56 push %esi
137479: 53 push %ebx
13747a: 83 ec 24 sub $0x24,%esp
13747d: 89 c6 mov %eax,%esi
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
13747f: ff 40 54 incl 0x54(%eax)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
137482: 83 78 38 04 cmpl $0x4,0x38(%eax)
137486: 0f 84 a0 00 00 00 je 13752c <_Rate_monotonic_Update_statistics+0xb4>
/*
* Grab status for time statistics.
*/
valid_status =
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
13748c: 8d 44 24 10 lea 0x10(%esp),%eax
137490: 89 44 24 08 mov %eax,0x8(%esp)
137494: 8d 44 24 18 lea 0x18(%esp),%eax
137498: 89 44 24 04 mov %eax,0x4(%esp)
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
13749c: 89 34 24 mov %esi,(%esp)
13749f: e8 44 ff ff ff call 1373e8 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
1374a4: 84 c0 test %al,%al
1374a6: 74 3c je 1374e4 <_Rate_monotonic_Update_statistics+0x6c>
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
1374a8: 8b 4c 24 10 mov 0x10(%esp),%ecx
1374ac: 8b 5c 24 14 mov 0x14(%esp),%ebx
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
1374b0: 01 4e 6c add %ecx,0x6c(%esi)
1374b3: 11 5e 70 adc %ebx,0x70(%esi)
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
1374b6: 3b 5e 60 cmp 0x60(%esi),%ebx
1374b9: 7e 59 jle 137514 <_Rate_monotonic_Update_statistics+0x9c><== ALWAYS TAKEN
stats->min_cpu_time = executed;
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
1374bb: 3b 5e 68 cmp 0x68(%esi),%ebx
1374be: 7d 61 jge 137521 <_Rate_monotonic_Update_statistics+0xa9><== ALWAYS TAKEN
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
1374c0: 8b 4c 24 18 mov 0x18(%esp),%ecx
1374c4: 8b 5c 24 1c mov 0x1c(%esp),%ebx
1374c8: 01 8e 84 00 00 00 add %ecx,0x84(%esi)
1374ce: 11 9e 88 00 00 00 adc %ebx,0x88(%esi)
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
1374d4: 3b 5e 78 cmp 0x78(%esi),%ebx
1374d7: 7e 27 jle 137500 <_Rate_monotonic_Update_statistics+0x88><== ALWAYS TAKEN
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
1374d9: 3b 9e 80 00 00 00 cmp 0x80(%esi),%ebx
1374df: 7d 0b jge 1374ec <_Rate_monotonic_Update_statistics+0x74>
1374e1: 8d 76 00 lea 0x0(%esi),%esi
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
1374e4: 83 c4 24 add $0x24,%esp
1374e7: 5b pop %ebx
1374e8: 5e pop %esi
1374e9: c3 ret
1374ea: 66 90 xchg %ax,%ax
_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;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
1374ec: 7e 62 jle 137550 <_Rate_monotonic_Update_statistics+0xd8><== ALWAYS TAKEN
stats->max_wall_time = since_last_period;
1374ee: 89 4e 7c mov %ecx,0x7c(%esi)
1374f1: 89 9e 80 00 00 00 mov %ebx,0x80(%esi)
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
1374f7: 83 c4 24 add $0x24,%esp
1374fa: 5b pop %ebx
1374fb: 5e pop %esi
1374fc: c3 ret
1374fd: 8d 76 00 lea 0x0(%esi),%esi
* Update Wall time
*/
#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 ) )
137500: 7d 46 jge 137548 <_Rate_monotonic_Update_statistics+0xd0>
stats->min_wall_time = since_last_period;
137502: 89 4e 74 mov %ecx,0x74(%esi)
137505: 89 5e 78 mov %ebx,0x78(%esi)
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
137508: 3b 9e 80 00 00 00 cmp 0x80(%esi),%ebx
13750e: 7c d4 jl 1374e4 <_Rate_monotonic_Update_statistics+0x6c>
137510: eb da jmp 1374ec <_Rate_monotonic_Update_statistics+0x74>
137512: 66 90 xchg %ax,%ax
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
137514: 7d 26 jge 13753c <_Rate_monotonic_Update_statistics+0xc4>
stats->min_cpu_time = executed;
137516: 89 4e 5c mov %ecx,0x5c(%esi)
137519: 89 5e 60 mov %ebx,0x60(%esi)
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
13751c: 3b 5e 68 cmp 0x68(%esi),%ebx
13751f: 7c 9f jl 1374c0 <_Rate_monotonic_Update_statistics+0x48><== NEVER TAKEN
137521: 7e 11 jle 137534 <_Rate_monotonic_Update_statistics+0xbc><== ALWAYS TAKEN
stats->max_cpu_time = executed;
137523: 89 4e 64 mov %ecx,0x64(%esi)
137526: 89 5e 68 mov %ebx,0x68(%esi)
137529: eb 95 jmp 1374c0 <_Rate_monotonic_Update_statistics+0x48>
13752b: 90 nop
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
13752c: ff 40 58 incl 0x58(%eax)
13752f: e9 58 ff ff ff jmp 13748c <_Rate_monotonic_Update_statistics+0x14>
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
stats->min_cpu_time = executed;
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
137534: 3b 4e 64 cmp 0x64(%esi),%ecx
137537: 76 87 jbe 1374c0 <_Rate_monotonic_Update_statistics+0x48>
137539: eb e8 jmp 137523 <_Rate_monotonic_Update_statistics+0xab>
13753b: 90 nop
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
13753c: 3b 4e 5c cmp 0x5c(%esi),%ecx
13753f: 0f 83 76 ff ff ff jae 1374bb <_Rate_monotonic_Update_statistics+0x43>
137545: eb cf jmp 137516 <_Rate_monotonic_Update_statistics+0x9e>
137547: 90 nop
* Update Wall time
*/
#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 ) )
137548: 3b 4e 74 cmp 0x74(%esi),%ecx
13754b: 73 8c jae 1374d9 <_Rate_monotonic_Update_statistics+0x61>
13754d: eb b3 jmp 137502 <_Rate_monotonic_Update_statistics+0x8a>
13754f: 90 nop
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
137550: 3b 4e 7c cmp 0x7c(%esi),%ecx
137553: 76 8f jbe 1374e4 <_Rate_monotonic_Update_statistics+0x6c>
137555: eb 97 jmp 1374ee <_Rate_monotonic_Update_statistics+0x76>
0010dd9c <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
10dd9c: 53 push %ebx
10dd9d: 83 ec 18 sub $0x18,%esp
10dda0: 8b 5c 24 20 mov 0x20(%esp),%ebx
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
10dda4: c7 04 24 1c 00 00 00 movl $0x1c,(%esp)
10ddab: e8 6c 17 00 00 call 10f51c <_Workspace_Allocate>
if ( sched ) {
10ddb0: 85 c0 test %eax,%eax
10ddb2: 74 16 je 10ddca <_Scheduler_CBS_Allocate+0x2e><== NEVER TAKEN
the_thread->scheduler_info = sched;
10ddb4: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
10ddba: 89 18 mov %ebx,(%eax)
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
10ddbc: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax)
schinfo->cbs_server = NULL;
10ddc3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
}
return sched;
}
10ddca: 83 c4 18 add $0x18,%esp
10ddcd: 5b pop %ebx
10ddce: c3 ret
0010f3bc <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
10f3bc: 53 push %ebx
10f3bd: 83 ec 28 sub $0x28,%esp
10f3c0: 8b 5c 24 30 mov 0x30(%esp),%ebx
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server_id server_id;
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
10f3c4: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
if ( the_thread->real_priority != new_priority )
10f3ca: 39 43 18 cmp %eax,0x18(%ebx)
10f3cd: 74 03 je 10f3d2 <_Scheduler_CBS_Budget_callout+0x16><== NEVER TAKEN
the_thread->real_priority = new_priority;
10f3cf: 89 43 18 mov %eax,0x18(%ebx)
if ( the_thread->current_priority != new_priority )
10f3d2: 39 43 14 cmp %eax,0x14(%ebx)
10f3d5: 74 14 je 10f3eb <_Scheduler_CBS_Budget_callout+0x2f><== NEVER TAKEN
_Thread_Change_priority(the_thread, new_priority, true);
10f3d7: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10f3de: 00
10f3df: 89 44 24 04 mov %eax,0x4(%esp)
10f3e3: 89 1c 24 mov %ebx,(%esp)
10f3e6: e8 e1 04 00 00 call 10f8cc <_Thread_Change_priority>
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
10f3eb: 8b 9b 88 00 00 00 mov 0x88(%ebx),%ebx
if ( sched_info->cbs_server->cbs_budget_overrun ) {
10f3f1: 8b 43 18 mov 0x18(%ebx),%eax
10f3f4: 8b 50 0c mov 0xc(%eax),%edx
10f3f7: 85 d2 test %edx,%edx
10f3f9: 74 1f je 10f41a <_Scheduler_CBS_Budget_callout+0x5e><== NEVER TAKEN
_Scheduler_CBS_Get_server_id(
10f3fb: 8d 54 24 1c lea 0x1c(%esp),%edx
10f3ff: 89 54 24 04 mov %edx,0x4(%esp)
10f403: 8b 00 mov (%eax),%eax
10f405: 89 04 24 mov %eax,(%esp)
10f408: e8 73 ff ff ff call 10f380 <_Scheduler_CBS_Get_server_id>
sched_info->cbs_server->task_id,
&server_id
);
sched_info->cbs_server->cbs_budget_overrun( server_id );
10f40d: 8b 43 18 mov 0x18(%ebx),%eax
10f410: 8b 54 24 1c mov 0x1c(%esp),%edx
10f414: 89 14 24 mov %edx,(%esp)
10f417: ff 50 0c call *0xc(%eax)
}
}
10f41a: 83 c4 28 add $0x28,%esp
10f41d: 5b pop %ebx
10f41e: c3 ret
0010efe4 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
10efe4: 53 push %ebx
10efe5: 83 ec 18 sub $0x18,%esp
10efe8: a1 24 39 13 00 mov 0x133924,%eax
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10efed: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx
10eff3: 31 db xor %ebx,%ebx
10eff5: 85 c9 test %ecx,%ecx
10eff7: 74 20 je 10f019 <_Scheduler_CBS_Cleanup+0x35><== NEVER TAKEN
10eff9: 8d 76 00 lea 0x0(%esi),%esi
if ( _Scheduler_CBS_Server_list[ i ] )
10effc: 8b 14 98 mov (%eax,%ebx,4),%edx
10efff: 85 d2 test %edx,%edx
10f001: 74 0d je 10f010 <_Scheduler_CBS_Cleanup+0x2c>
_Scheduler_CBS_Destroy_server( i );
10f003: 89 1c 24 mov %ebx,(%esp)
10f006: e8 d1 00 00 00 call 10f0dc <_Scheduler_CBS_Destroy_server>
10f00b: a1 24 39 13 00 mov 0x133924,%eax
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10f010: 43 inc %ebx
10f011: 39 1d bc f2 12 00 cmp %ebx,0x12f2bc
10f017: 77 e3 ja 10effc <_Scheduler_CBS_Cleanup+0x18>
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
10f019: 89 04 24 mov %eax,(%esp)
10f01c: e8 97 1b 00 00 call 110bb8 <_Workspace_Free>
return SCHEDULER_CBS_OK;
}
10f021: 31 c0 xor %eax,%eax
10f023: 83 c4 18 add $0x18,%esp
10f026: 5b pop %ebx
10f027: c3 ret
0010f028 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
10f028: 57 push %edi
10f029: 56 push %esi
10f02a: 53 push %ebx
10f02b: 83 ec 10 sub $0x10,%esp
10f02e: 8b 74 24 20 mov 0x20(%esp),%esi
10f032: 8b 5c 24 28 mov 0x28(%esp),%ebx
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
10f036: 8b 46 04 mov 0x4(%esi),%eax
10f039: 85 c0 test %eax,%eax
10f03b: 0f 8e 8d 00 00 00 jle 10f0ce <_Scheduler_CBS_Create_server+0xa6>
10f041: 8b 06 mov (%esi),%eax
10f043: 85 c0 test %eax,%eax
10f045: 0f 8e 83 00 00 00 jle 10f0ce <_Scheduler_CBS_Create_server+0xa6>
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10f04b: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx
10f051: 85 c9 test %ecx,%ecx
10f053: 74 1f je 10f074 <_Scheduler_CBS_Create_server+0x4c><== NEVER TAKEN
if ( !_Scheduler_CBS_Server_list[i] )
10f055: 8b 15 24 39 13 00 mov 0x133924,%edx
10f05b: 8b 02 mov (%edx),%eax
10f05d: 85 c0 test %eax,%eax
10f05f: 74 67 je 10f0c8 <_Scheduler_CBS_Create_server+0xa0>
10f061: 31 c0 xor %eax,%eax
10f063: eb 0a jmp 10f06f <_Scheduler_CBS_Create_server+0x47>
10f065: 8d 76 00 lea 0x0(%esi),%esi
10f068: 8b 3c 82 mov (%edx,%eax,4),%edi
10f06b: 85 ff test %edi,%edi
10f06d: 74 11 je 10f080 <_Scheduler_CBS_Create_server+0x58>
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10f06f: 40 inc %eax
10f070: 39 c8 cmp %ecx,%eax
10f072: 75 f4 jne 10f068 <_Scheduler_CBS_Create_server+0x40>
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
10f074: b8 e6 ff ff ff mov $0xffffffe6,%eax
the_server->parameters = *params;
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
10f079: 83 c4 10 add $0x10,%esp
10f07c: 5b pop %ebx
10f07d: 5e pop %esi
10f07e: 5f pop %edi
10f07f: c3 ret
10f080: 8d 3c 85 00 00 00 00 lea 0x0(,%eax,4),%edi
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
10f087: 89 03 mov %eax,(%ebx)
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
10f089: 01 d7 add %edx,%edi
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
10f08b: c7 04 24 10 00 00 00 movl $0x10,(%esp)
10f092: e8 f5 1a 00 00 call 110b8c <_Workspace_Allocate>
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
10f097: 89 07 mov %eax,(%edi)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
10f099: 8b 13 mov (%ebx),%edx
10f09b: a1 24 39 13 00 mov 0x133924,%eax
10f0a0: 8b 0c 90 mov (%eax,%edx,4),%ecx
if ( !the_server )
10f0a3: 85 c9 test %ecx,%ecx
10f0a5: 74 2e je 10f0d5 <_Scheduler_CBS_Create_server+0xad><== NEVER TAKEN
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
10f0a7: 8b 06 mov (%esi),%eax
10f0a9: 8b 56 04 mov 0x4(%esi),%edx
10f0ac: 89 41 04 mov %eax,0x4(%ecx)
10f0af: 89 51 08 mov %edx,0x8(%ecx)
the_server->task_id = -1;
10f0b2: c7 01 ff ff ff ff movl $0xffffffff,(%ecx)
the_server->cbs_budget_overrun = budget_overrun_callback;
10f0b8: 8b 44 24 24 mov 0x24(%esp),%eax
10f0bc: 89 41 0c mov %eax,0xc(%ecx)
return SCHEDULER_CBS_OK;
10f0bf: 31 c0 xor %eax,%eax
}
10f0c1: 83 c4 10 add $0x10,%esp
10f0c4: 5b pop %ebx
10f0c5: 5e pop %esi
10f0c6: 5f pop %edi
10f0c7: c3 ret
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
10f0c8: 31 ff xor %edi,%edi
10f0ca: 31 c0 xor %eax,%eax
10f0cc: eb b9 jmp 10f087 <_Scheduler_CBS_Create_server+0x5f>
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
10f0ce: b8 ee ff ff ff mov $0xffffffee,%eax
10f0d3: eb a4 jmp 10f079 <_Scheduler_CBS_Create_server+0x51>
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
10f0d5: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED
10f0da: eb 9d jmp 10f079 <_Scheduler_CBS_Create_server+0x51><== NOT EXECUTED
0010f154 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
10f154: 56 push %esi
10f155: 53 push %ebx
10f156: 83 ec 34 sub $0x34,%esp
10f159: 8b 74 24 40 mov 0x40(%esp),%esi
10f15d: 8b 5c 24 44 mov 0x44(%esp),%ebx
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
the_thread = _Thread_Get(task_id, &location);
10f161: 8d 44 24 2c lea 0x2c(%esp),%eax
10f165: 89 44 24 04 mov %eax,0x4(%esp)
10f169: 89 1c 24 mov %ebx,(%esp)
10f16c: e8 e7 0b 00 00 call 10fd58 <_Thread_Get>
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
10f171: 85 c0 test %eax,%eax
10f173: 74 5f je 10f1d4 <_Scheduler_CBS_Detach_thread+0x80>
_Thread_Enable_dispatch();
10f175: 89 44 24 1c mov %eax,0x1c(%esp)
10f179: e8 ba 0b 00 00 call 10fd38 <_Thread_Enable_dispatch>
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
10f17e: 3b 35 bc f2 12 00 cmp 0x12f2bc,%esi
10f184: 8b 44 24 1c mov 0x1c(%esp),%eax
10f188: 73 4a jae 10f1d4 <_Scheduler_CBS_Detach_thread+0x80>
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
10f18a: 8b 15 24 39 13 00 mov 0x133924,%edx
10f190: 8b 14 b2 mov (%edx,%esi,4),%edx
10f193: 85 d2 test %edx,%edx
10f195: 74 48 je 10f1df <_Scheduler_CBS_Detach_thread+0x8b>
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
10f197: 39 1a cmp %ebx,(%edx)
10f199: 75 39 jne 10f1d4 <_Scheduler_CBS_Detach_thread+0x80><== NEVER TAKEN
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
10f19b: c7 02 ff ff ff ff movl $0xffffffff,(%edx)
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
10f1a1: 8b 90 88 00 00 00 mov 0x88(%eax),%edx
10f1a7: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10f1ae: 8b 90 a0 00 00 00 mov 0xa0(%eax),%edx
10f1b4: 89 50 78 mov %edx,0x78(%eax)
the_thread->budget_callout = the_thread->Start.budget_callout;
10f1b7: 8b 90 a4 00 00 00 mov 0xa4(%eax),%edx
10f1bd: 89 50 7c mov %edx,0x7c(%eax)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10f1c0: 8a 90 9c 00 00 00 mov 0x9c(%eax),%dl
10f1c6: 88 50 70 mov %dl,0x70(%eax)
return SCHEDULER_CBS_OK;
10f1c9: 31 c0 xor %eax,%eax
}
10f1cb: 83 c4 34 add $0x34,%esp
10f1ce: 5b pop %ebx
10f1cf: 5e pop %esi
10f1d0: c3 ret
10f1d1: 8d 76 00 lea 0x0(%esi),%esi
if ( the_thread ) {
_Thread_Enable_dispatch();
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
10f1d4: b8 ee ff ff ff mov $0xffffffee,%eax
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
10f1d9: 83 c4 34 add $0x34,%esp
10f1dc: 5b pop %ebx
10f1dd: 5e pop %esi
10f1de: c3 ret
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
10f1df: b8 e7 ff ff ff mov $0xffffffe7,%eax
10f1e4: eb e5 jmp 10f1cb <_Scheduler_CBS_Detach_thread+0x77>
0010f380 <_Scheduler_CBS_Get_server_id>:
int _Scheduler_CBS_Get_server_id (
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
10f380: 56 push %esi
10f381: 53 push %ebx
10f382: 8b 74 24 0c mov 0xc(%esp),%esi
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10f386: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx
10f38c: 85 c9 test %ecx,%ecx
10f38e: 74 18 je 10f3a8 <_Scheduler_CBS_Get_server_id+0x28><== NEVER TAKEN
10f390: 8b 1d 24 39 13 00 mov 0x133924,%ebx
10f396: 31 c0 xor %eax,%eax
if ( _Scheduler_CBS_Server_list[i] &&
10f398: 8b 14 83 mov (%ebx,%eax,4),%edx
10f39b: 85 d2 test %edx,%edx
10f39d: 74 04 je 10f3a3 <_Scheduler_CBS_Get_server_id+0x23>
10f39f: 39 32 cmp %esi,(%edx)
10f3a1: 74 0d je 10f3b0 <_Scheduler_CBS_Get_server_id+0x30>
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10f3a3: 40 inc %eax
10f3a4: 39 c8 cmp %ecx,%eax
10f3a6: 75 f0 jne 10f398 <_Scheduler_CBS_Get_server_id+0x18>
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
10f3a8: b8 e7 ff ff ff mov $0xffffffe7,%eax
}
10f3ad: 5b pop %ebx
10f3ae: 5e pop %esi
10f3af: c3 ret
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
if ( _Scheduler_CBS_Server_list[i] &&
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
10f3b0: 8b 54 24 10 mov 0x10(%esp),%edx
10f3b4: 89 02 mov %eax,(%edx)
return SCHEDULER_CBS_OK;
10f3b6: 31 c0 xor %eax,%eax
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
10f3b8: 5b pop %ebx
10f3b9: 5e pop %esi
10f3ba: c3 ret
0010f420 <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
10f420: 83 ec 1c sub $0x1c,%esp
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
10f423: a1 bc f2 12 00 mov 0x12f2bc,%eax
10f428: c1 e0 02 shl $0x2,%eax
10f42b: 89 04 24 mov %eax,(%esp)
10f42e: e8 59 17 00 00 call 110b8c <_Workspace_Allocate>
10f433: a3 24 39 13 00 mov %eax,0x133924
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
10f438: 85 c0 test %eax,%eax
10f43a: 74 27 je 10f463 <_Scheduler_CBS_Initialize+0x43><== NEVER TAKEN
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
10f43c: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx
10f442: 31 d2 xor %edx,%edx
10f444: 85 c9 test %ecx,%ecx
10f446: 75 09 jne 10f451 <_Scheduler_CBS_Initialize+0x31><== ALWAYS TAKEN
10f448: eb 13 jmp 10f45d <_Scheduler_CBS_Initialize+0x3d><== NOT EXECUTED
10f44a: 66 90 xchg %ax,%ax <== NOT EXECUTED
10f44c: a1 24 39 13 00 mov 0x133924,%eax
_Scheduler_CBS_Server_list[i] = NULL;
10f451: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
10f458: 42 inc %edx
10f459: 39 ca cmp %ecx,%edx
10f45b: 75 ef jne 10f44c <_Scheduler_CBS_Initialize+0x2c>
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
10f45d: 31 c0 xor %eax,%eax
}
10f45f: 83 c4 1c add $0x1c,%esp
10f462: c3 ret
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
10f463: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED
10f468: eb f5 jmp 10f45f <_Scheduler_CBS_Initialize+0x3f><== NOT EXECUTED
0010ddd0 <_Scheduler_CBS_Release_job>:
void _Scheduler_CBS_Release_job(
Thread_Control *the_thread,
uint32_t deadline
)
{
10ddd0: 83 ec 1c sub $0x1c,%esp
10ddd3: 8b 44 24 20 mov 0x20(%esp),%eax
10ddd7: 8b 54 24 24 mov 0x24(%esp),%edx
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
(Scheduler_CBS_Server *) sched_info->cbs_server;
10dddb: 8b 88 88 00 00 00 mov 0x88(%eax),%ecx
)
{
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
10dde1: 8b 49 18 mov 0x18(%ecx),%ecx
(Scheduler_CBS_Server *) sched_info->cbs_server;
if (deadline) {
10dde4: 85 d2 test %edx,%edx
10dde6: 74 34 je 10de1c <_Scheduler_CBS_Release_job+0x4c>
/* Initializing or shifting deadline. */
if (serv_info)
10dde8: 85 c9 test %ecx,%ecx
10ddea: 74 3c je 10de28 <_Scheduler_CBS_Release_job+0x58>
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
10ddec: 8b 15 64 17 13 00 mov 0x131764,%edx
10ddf2: 03 51 04 add 0x4(%ecx),%edx
10ddf5: 81 e2 ff ff ff 7f and $0x7fffffff,%edx
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
the_thread->cpu_time_budget = serv_info->parameters.budget;
10ddfb: 8b 49 08 mov 0x8(%ecx),%ecx
10ddfe: 89 48 74 mov %ecx,0x74(%eax)
the_thread->real_priority = new_priority;
10de01: 89 50 18 mov %edx,0x18(%eax)
_Thread_Change_priority(the_thread, new_priority, true);
10de04: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10de0b: 00
10de0c: 89 54 24 04 mov %edx,0x4(%esp)
10de10: 89 04 24 mov %eax,(%esp)
10de13: e8 d4 03 00 00 call 10e1ec <_Thread_Change_priority>
}
10de18: 83 c4 1c add $0x1c,%esp
10de1b: c3 ret
new_priority = (_Watchdog_Ticks_since_boot + deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
10de1c: 8b 90 ac 00 00 00 mov 0xac(%eax),%edx
}
/* Budget replenishment for the next job. */
if (serv_info)
10de22: 85 c9 test %ecx,%ecx
10de24: 75 d5 jne 10ddfb <_Scheduler_CBS_Release_job+0x2b><== ALWAYS TAKEN
10de26: eb d9 jmp 10de01 <_Scheduler_CBS_Release_job+0x31><== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
10de28: 8b 0d 64 17 13 00 mov 0x131764,%ecx
10de2e: 01 ca add %ecx,%edx
10de30: 81 e2 ff ff ff 7f and $0x7fffffff,%edx
10de36: eb c9 jmp 10de01 <_Scheduler_CBS_Release_job+0x31>
0010de38 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
10de38: 56 push %esi
10de39: 53 push %ebx
10de3a: 83 ec 14 sub $0x14,%esp
10de3d: 8b 5c 24 20 mov 0x20(%esp),%ebx
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server *serv_info;
Priority_Control new_priority;
_Scheduler_EDF_Enqueue(the_thread);
10de41: 89 1c 24 mov %ebx,(%esp)
10de44: e8 e3 00 00 00 call 10df2c <_Scheduler_EDF_Enqueue>
/* TODO: flash critical section? */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server;
10de49: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10de4f: 8b 40 18 mov 0x18(%eax),%eax
* Late unblock rule for deadline-driven tasks. The remaining time to
* deadline must be sufficient to serve the remaining computation time
* without increased utilization of this task. It might cause a deadline
* miss of another task.
*/
if (serv_info) {
10de52: 85 c0 test %eax,%eax
10de54: 74 46 je 10de9c <_Scheduler_CBS_Unblock+0x64>
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
time_t deadline_left = the_thread->cpu_time_budget;
time_t budget_left = the_thread->real_priority -
10de56: 8b 4b 18 mov 0x18(%ebx),%ecx
10de59: 8b 15 64 17 13 00 mov 0x131764,%edx
10de5f: 89 ce mov %ecx,%esi
10de61: 29 d6 sub %edx,%esi
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
10de63: 8b 50 04 mov 0x4(%eax),%edx
10de66: 0f af d6 imul %esi,%edx
10de69: 8b 40 08 mov 0x8(%eax),%eax
10de6c: 0f af 43 74 imul 0x74(%ebx),%eax
10de70: 39 c2 cmp %eax,%edx
10de72: 7e 28 jle 10de9c <_Scheduler_CBS_Unblock+0x64>
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
10de74: 8b 93 ac 00 00 00 mov 0xac(%ebx),%edx
if ( the_thread->real_priority != new_priority )
10de7a: 39 d1 cmp %edx,%ecx
10de7c: 74 03 je 10de81 <_Scheduler_CBS_Unblock+0x49>
the_thread->real_priority = new_priority;
10de7e: 89 53 18 mov %edx,0x18(%ebx)
if ( the_thread->current_priority != new_priority )
10de81: 8b 43 14 mov 0x14(%ebx),%eax
10de84: 39 d0 cmp %edx,%eax
10de86: 74 17 je 10de9f <_Scheduler_CBS_Unblock+0x67>
_Thread_Change_priority(the_thread, new_priority, true);
10de88: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10de8f: 00
10de90: 89 54 24 04 mov %edx,0x4(%esp)
10de94: 89 1c 24 mov %ebx,(%esp)
10de97: e8 50 03 00 00 call 10e1ec <_Thread_Change_priority>
10de9c: 8b 43 14 mov 0x14(%ebx),%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 ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
10de9f: 8b 15 d0 18 13 00 mov 0x1318d0,%edx
10dea5: 8b 52 14 mov 0x14(%edx),%edx
10dea8: 89 54 24 04 mov %edx,0x4(%esp)
10deac: 89 04 24 mov %eax,(%esp)
10deaf: ff 15 b0 d2 12 00 call *0x12d2b0
10deb5: 85 c0 test %eax,%eax
10deb7: 7e 18 jle 10ded1 <_Scheduler_CBS_Unblock+0x99>
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
10deb9: 89 1d d0 18 13 00 mov %ebx,0x1318d0
if ( _Thread_Executing->is_preemptible ||
10debf: a1 cc 18 13 00 mov 0x1318cc,%eax
10dec4: 80 78 70 00 cmpb $0x0,0x70(%eax)
10dec8: 74 0e je 10ded8 <_Scheduler_CBS_Unblock+0xa0>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10deca: c6 05 d8 18 13 00 01 movb $0x1,0x1318d8
}
}
10ded1: 83 c4 14 add $0x14,%esp
10ded4: 5b pop %ebx
10ded5: 5e pop %esi
10ded6: c3 ret
10ded7: 90 nop
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
10ded8: 8b 43 14 mov 0x14(%ebx),%eax
10dedb: 85 c0 test %eax,%eax
10dedd: 74 eb je 10deca <_Scheduler_CBS_Unblock+0x92><== NEVER TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
10dedf: 83 c4 14 add $0x14,%esp
10dee2: 5b pop %ebx
10dee3: 5e pop %esi
10dee4: c3 ret
0010dd9c <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
10dd9c: 53 push %ebx
10dd9d: 83 ec 18 sub $0x18,%esp
10dda0: 8b 5c 24 20 mov 0x20(%esp),%ebx
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
10dda4: c7 04 24 18 00 00 00 movl $0x18,(%esp)
10ddab: e8 f0 16 00 00 call 10f4a0 <_Workspace_Allocate>
if ( sched ) {
10ddb0: 85 c0 test %eax,%eax
10ddb2: 74 0f je 10ddc3 <_Scheduler_EDF_Allocate+0x27><== NEVER TAKEN
the_thread->scheduler_info = sched;
10ddb4: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
10ddba: 89 18 mov %ebx,(%eax)
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
10ddbc: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax)
}
return sched;
}
10ddc3: 83 c4 18 add $0x18,%esp
10ddc6: 5b pop %ebx
10ddc7: c3 ret
0010df70 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
10df70: 53 push %ebx
10df71: 83 ec 18 sub $0x18,%esp
10df74: 8b 5c 24 20 mov 0x20(%esp),%ebx
_Scheduler_EDF_Enqueue(the_thread);
10df78: 89 1c 24 mov %ebx,(%esp)
10df7b: e8 8c fe ff ff call 10de0c <_Scheduler_EDF_Enqueue>
10df80: 8b 43 14 mov 0x14(%ebx),%eax
10df83: 89 44 24 04 mov %eax,0x4(%esp)
* 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 ( _Scheduler_Is_priority_lower_than(
10df87: a1 d0 18 13 00 mov 0x1318d0,%eax
10df8c: 8b 40 14 mov 0x14(%eax),%eax
10df8f: 89 04 24 mov %eax,(%esp)
10df92: ff 15 b0 d2 12 00 call *0x12d2b0
10df98: 85 c0 test %eax,%eax
10df9a: 78 08 js 10dfa4 <_Scheduler_EDF_Unblock+0x34>
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
}
}
10df9c: 83 c4 18 add $0x18,%esp
10df9f: 5b pop %ebx
10dfa0: c3 ret
10dfa1: 8d 76 00 lea 0x0(%esi),%esi
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
10dfa4: 89 1d d0 18 13 00 mov %ebx,0x1318d0
if ( _Thread_Executing->is_preemptible ||
10dfaa: a1 cc 18 13 00 mov 0x1318cc,%eax
10dfaf: 80 78 70 00 cmpb $0x0,0x70(%eax)
10dfb3: 74 0f je 10dfc4 <_Scheduler_EDF_Unblock+0x54>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10dfb5: c6 05 d8 18 13 00 01 movb $0x1,0x1318d8
}
}
10dfbc: 83 c4 18 add $0x18,%esp
10dfbf: 5b pop %ebx
10dfc0: c3 ret
10dfc1: 8d 76 00 lea 0x0(%esi),%esi
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
10dfc4: 8b 43 14 mov 0x14(%ebx),%eax
10dfc7: 85 c0 test %eax,%eax
10dfc9: 75 d1 jne 10df9c <_Scheduler_EDF_Unblock+0x2c><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10dfcb: c6 05 d8 18 13 00 01 movb $0x1,0x1318d8 <== NOT EXECUTED
10dfd2: eb e8 jmp 10dfbc <_Scheduler_EDF_Unblock+0x4c><== NOT EXECUTED
0010d508 <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10d508: 53 push %ebx
10d509: 8b 44 24 08 mov 0x8(%esp),%eax
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
10d50d: 8b 88 88 00 00 00 mov 0x88(%eax),%ecx
ready = sched_info->ready_chain;
10d513: 8b 11 mov (%ecx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
10d515: 8b 5a 08 mov 0x8(%edx),%ebx
10d518: 39 1a cmp %ebx,(%edx)
10d51a: 74 28 je 10d544 <_Scheduler_priority_Block+0x3c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d51c: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10d51e: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10d521: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10d524: 89 0a mov %ecx,(%edx)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10d526: 3b 05 70 f8 12 00 cmp 0x12f870,%eax
10d52c: 74 4a je 10d578 <_Scheduler_priority_Block+0x70>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10d52e: 3b 05 6c f8 12 00 cmp 0x12f86c,%eax
10d534: 74 02 je 10d538 <_Scheduler_priority_Block+0x30>
_Thread_Dispatch_necessary = true;
}
10d536: 5b pop %ebx
10d537: c3 ret
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
10d538: c6 05 78 f8 12 00 01 movb $0x1,0x12f878
}
10d53f: 5b pop %ebx
10d540: c3 ret
10d541: 8d 76 00 lea 0x0(%esi),%esi
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 );
10d544: 8d 5a 04 lea 0x4(%edx),%ebx
10d547: 89 1a mov %ebx,(%edx)
head->next = tail;
head->previous = NULL;
10d549: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
10d550: 89 52 08 mov %edx,0x8(%edx)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
10d553: 8b 59 04 mov 0x4(%ecx),%ebx
10d556: 66 8b 13 mov (%ebx),%dx
10d559: 66 23 51 0e and 0xe(%ecx),%dx
10d55d: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
10d560: 66 85 d2 test %dx,%dx
10d563: 75 c1 jne 10d526 <_Scheduler_priority_Block+0x1e>
_Priority_Major_bit_map &= the_priority_map->block_major;
10d565: 66 8b 15 a0 f8 12 00 mov 0x12f8a0,%dx
10d56c: 23 51 0c and 0xc(%ecx),%edx
10d56f: 66 89 15 a0 f8 12 00 mov %dx,0x12f8a0
10d576: eb ae jmp 10d526 <_Scheduler_priority_Block+0x1e>
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 );
10d578: 66 8b 1d a0 f8 12 00 mov 0x12f8a0,%bx
10d57f: 31 d2 xor %edx,%edx
10d581: 89 d1 mov %edx,%ecx
10d583: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d587: 0f b7 c9 movzwl %cx,%ecx
10d58a: 66 8b 9c 09 c0 f8 12 mov 0x12f8c0(%ecx,%ecx,1),%bx
10d591: 00
10d592: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10d596: c1 e1 04 shl $0x4,%ecx
10d599: 0f b7 d2 movzwl %dx,%edx
10d59c: 01 ca add %ecx,%edx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10d59e: 8d 0c 52 lea (%edx,%edx,2),%ecx
10d5a1: 8b 15 80 b2 12 00 mov 0x12b280,%edx
10d5a7: 8d 0c 8a lea (%edx,%ecx,4),%ecx
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
10d5aa: 8b 11 mov (%ecx),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10d5ac: 83 c1 04 add $0x4,%ecx
10d5af: 39 ca cmp %ecx,%edx
10d5b1: 74 0b je 10d5be <_Scheduler_priority_Block+0xb6><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d5b3: 89 15 70 f8 12 00 mov %edx,0x12f870
10d5b9: e9 70 ff ff ff jmp 10d52e <_Scheduler_priority_Block+0x26>
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;
10d5be: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d5c0: eb f1 jmp 10d5b3 <_Scheduler_priority_Block+0xab><== NOT EXECUTED
0010d720 <_Scheduler_priority_Schedule>:
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 );
10d720: 66 8b 0d a0 f8 12 00 mov 0x12f8a0,%cx
10d727: 31 c0 xor %eax,%eax
10d729: 89 c2 mov %eax,%edx
10d72b: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d72f: 0f b7 d2 movzwl %dx,%edx
10d732: 66 8b 8c 12 c0 f8 12 mov 0x12f8c0(%edx,%edx,1),%cx
10d739: 00
10d73a: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10d73e: c1 e2 04 shl $0x4,%edx
10d741: 0f b7 c0 movzwl %ax,%eax
10d744: 01 d0 add %edx,%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10d746: 8d 14 40 lea (%eax,%eax,2),%edx
10d749: a1 80 b2 12 00 mov 0x12b280,%eax
10d74e: 8d 14 90 lea (%eax,%edx,4),%edx
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
10d751: 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 );
10d753: 83 c2 04 add $0x4,%edx
10d756: 39 d0 cmp %edx,%eax
10d758: 74 06 je 10d760 <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d75a: a3 70 f8 12 00 mov %eax,0x12f870
10d75f: c3 ret
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;
10d760: 31 c0 xor %eax,%eax
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d762: a3 70 f8 12 00 mov %eax,0x12f870 <== NOT EXECUTED
10d767: c3 ret <== NOT EXECUTED
0010dee4 <_Scheduler_simple_Ready_queue_enqueue_first>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_enqueue_first(
Thread_Control *the_thread
)
{
10dee4: 8b 4c 24 04 mov 0x4(%esp),%ecx
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10dee8: a1 80 c2 12 00 mov 0x12c280,%eax
10deed: 8b 00 mov (%eax),%eax
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
10deef: 8b 51 14 mov 0x14(%ecx),%edx
10def2: 39 50 14 cmp %edx,0x14(%eax)
10def5: 73 08 jae 10deff <_Scheduler_simple_Ready_queue_enqueue_first+0x1b>
10def7: 90 nop
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
10def8: 8b 00 mov (%eax),%eax
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
10defa: 39 50 14 cmp %edx,0x14(%eax)
10defd: 72 f9 jb 10def8 <_Scheduler_simple_Ready_queue_enqueue_first+0x14><== NEVER TAKEN
current = (Thread_Control *)current->Object.Node.previous;
10deff: 8b 40 04 mov 0x4(%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10df02: 89 41 04 mov %eax,0x4(%ecx)
before_node = after_node->next;
10df05: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10df07: 89 08 mov %ecx,(%eax)
the_node->next = before_node;
10df09: 89 11 mov %edx,(%ecx)
before_node->previous = the_node;
10df0b: 89 4a 04 mov %ecx,0x4(%edx)
10df0e: c3 ret
0010c4e0 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10c4e0: 8b 4c 24 04 mov 0x4(%esp),%ecx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10c4e4: b8 40 42 0f 00 mov $0xf4240,%eax
10c4e9: 31 d2 xor %edx,%edx
10c4eb: f7 35 90 e1 12 00 divl 0x12e190
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10c4f1: 85 c9 test %ecx,%ecx
10c4f3: 74 47 je 10c53c <_TOD_Validate+0x5c> <== NEVER TAKEN
10c4f5: 3b 41 18 cmp 0x18(%ecx),%eax
10c4f8: 76 42 jbe 10c53c <_TOD_Validate+0x5c>
(the_tod->ticks >= ticks_per_second) ||
10c4fa: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10c4fe: 77 3c ja 10c53c <_TOD_Validate+0x5c>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10c500: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10c504: 77 36 ja 10c53c <_TOD_Validate+0x5c>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10c506: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10c50a: 77 30 ja 10c53c <_TOD_Validate+0x5c>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10c50c: 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) ||
10c50f: 85 c0 test %eax,%eax
10c511: 74 29 je 10c53c <_TOD_Validate+0x5c> <== NEVER TAKEN
(the_tod->month == 0) ||
10c513: 83 f8 0c cmp $0xc,%eax
10c516: 77 24 ja 10c53c <_TOD_Validate+0x5c>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10c518: 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) ||
10c51a: 81 fa c3 07 00 00 cmp $0x7c3,%edx
10c520: 76 1a jbe 10c53c <_TOD_Validate+0x5c>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10c522: 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) ||
10c525: 85 c9 test %ecx,%ecx
10c527: 74 13 je 10c53c <_TOD_Validate+0x5c> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10c529: 83 e2 03 and $0x3,%edx
10c52c: 75 11 jne 10c53f <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10c52e: 8b 04 85 54 39 12 00 mov 0x123954(,%eax,4),%eax
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
if ( the_tod->day > days_in_month )
10c535: 39 c8 cmp %ecx,%eax
10c537: 0f 93 c0 setae %al
10c53a: c3 ret
10c53b: 90 nop
(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;
10c53c: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10c53e: 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 ];
10c53f: 8b 04 85 20 39 12 00 mov 0x123920(,%eax,4),%eax
10c546: eb ed jmp 10c535 <_TOD_Validate+0x55>
0010d93c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10d93c: 57 push %edi
10d93d: 56 push %esi
10d93e: 53 push %ebx
10d93f: 83 ec 20 sub $0x20,%esp
10d942: 8b 5c 24 30 mov 0x30(%esp),%ebx
10d946: 8b 7c 24 34 mov 0x34(%esp),%edi
10d94a: 8a 44 24 38 mov 0x38(%esp),%al
10d94e: 88 44 24 1f mov %al,0x1f(%esp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10d952: 8b 73 10 mov 0x10(%ebx),%esi
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
10d955: 89 1c 24 mov %ebx,(%esp)
10d958: e8 9b 0c 00 00 call 10e5f8 <_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 )
10d95d: 39 7b 14 cmp %edi,0x14(%ebx)
10d960: 74 0c je 10d96e <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10d962: 89 7c 24 04 mov %edi,0x4(%esp)
10d966: 89 1c 24 mov %ebx,(%esp)
10d969: e8 3e 0c 00 00 call 10e5ac <_Thread_Set_priority>
_ISR_Disable( level );
10d96e: 9c pushf
10d96f: fa cli
10d970: 5f pop %edi
/*
* 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;
10d971: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10d974: 83 f8 04 cmp $0x4,%eax
10d977: 74 23 je 10d99c <_Thread_Change_priority+0x60>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10d979: 83 e6 04 and $0x4,%esi
10d97c: 74 12 je 10d990 <_Thread_Change_priority+0x54><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10d97e: 57 push %edi
10d97f: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d980: a9 e0 be 03 00 test $0x3bee0,%eax
10d985: 75 5d jne 10d9e4 <_Thread_Change_priority+0xa8>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10d987: 83 c4 20 add $0x20,%esp
10d98a: 5b pop %ebx
10d98b: 5e pop %esi
10d98c: 5f pop %edi
10d98d: c3 ret
10d98e: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10d990: 89 c2 mov %eax,%edx
10d992: 83 e2 fb and $0xfffffffb,%edx
10d995: 89 53 10 mov %edx,0x10(%ebx)
10d998: eb e4 jmp 10d97e <_Thread_Change_priority+0x42>
10d99a: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10d99c: 83 e6 04 and $0x4,%esi
10d99f: 75 17 jne 10d9b8 <_Thread_Change_priority+0x7c><== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10d9a1: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10d9a8: 80 7c 24 1f 00 cmpb $0x0,0x1f(%esp)
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10d9ad: 89 1c 24 mov %ebx,(%esp)
10d9b0: 74 4a je 10d9fc <_Thread_Change_priority+0xc0>
10d9b2: ff 15 a8 b2 12 00 call *0x12b2a8
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10d9b8: 57 push %edi
10d9b9: 9d popf
10d9ba: fa cli
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
10d9bb: ff 15 88 b2 12 00 call *0x12b288
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10d9c1: a1 6c f8 12 00 mov 0x12f86c,%eax
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
10d9c6: 3b 05 70 f8 12 00 cmp 0x12f870,%eax
10d9cc: 74 0d je 10d9db <_Thread_Change_priority+0x9f>
10d9ce: 80 78 70 00 cmpb $0x0,0x70(%eax)
10d9d2: 74 07 je 10d9db <_Thread_Change_priority+0x9f>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10d9d4: c6 05 78 f8 12 00 01 movb $0x1,0x12f878
_ISR_Enable( level );
10d9db: 57 push %edi
10d9dc: 9d popf
}
10d9dd: 83 c4 20 add $0x20,%esp
10d9e0: 5b pop %ebx
10d9e1: 5e pop %esi
10d9e2: 5f pop %edi
10d9e3: c3 ret
/* 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 );
10d9e4: 89 5c 24 34 mov %ebx,0x34(%esp)
10d9e8: 8b 43 44 mov 0x44(%ebx),%eax
10d9eb: 89 44 24 30 mov %eax,0x30(%esp)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10d9ef: 83 c4 20 add $0x20,%esp
10d9f2: 5b pop %ebx
10d9f3: 5e pop %esi
10d9f4: 5f pop %edi
/* 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 );
10d9f5: e9 0a 0b 00 00 jmp 10e504 <_Thread_queue_Requeue>
10d9fa: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10d9fc: ff 15 a4 b2 12 00 call *0x12b2a4
10da02: eb b4 jmp 10d9b8 <_Thread_Change_priority+0x7c>
0010dc00 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10dc00: 83 ec 2c sub $0x2c,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10dc03: 8d 44 24 1c lea 0x1c(%esp),%eax
10dc07: 89 44 24 04 mov %eax,0x4(%esp)
10dc0b: 8b 44 24 30 mov 0x30(%esp),%eax
10dc0f: 89 04 24 mov %eax,(%esp)
10dc12: e8 b1 01 00 00 call 10ddc8 <_Thread_Get>
switch ( location ) {
10dc17: 8b 54 24 1c mov 0x1c(%esp),%edx
10dc1b: 85 d2 test %edx,%edx
10dc1d: 75 20 jne 10dc3f <_Thread_Delay_ended+0x3f><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10dc1f: c7 44 24 04 18 00 00 movl $0x10000018,0x4(%esp)
10dc26: 10
10dc27: 89 04 24 mov %eax,(%esp)
10dc2a: e8 d5 fd ff ff call 10da04 <_Thread_Clear_state>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
10dc2f: a1 04 f6 12 00 mov 0x12f604,%eax
10dc34: 48 dec %eax
10dc35: a3 04 f6 12 00 mov %eax,0x12f604
return _Thread_Dispatch_disable_level;
10dc3a: a1 04 f6 12 00 mov 0x12f604,%eax
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10dc3f: 83 c4 2c add $0x2c,%esp
10dc42: c3 ret
0010dc44 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10dc44: 55 push %ebp
10dc45: 57 push %edi
10dc46: 56 push %esi
10dc47: 53 push %ebx
10dc48: 83 ec 2c sub $0x2c,%esp
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
10dc4b: a1 04 f6 12 00 mov 0x12f604,%eax
10dc50: 40 inc %eax
10dc51: a3 04 f6 12 00 mov %eax,0x12f604
return _Thread_Dispatch_disable_level;
10dc56: a1 04 f6 12 00 mov 0x12f604,%eax
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
10dc5b: 8b 35 6c f8 12 00 mov 0x12f86c,%esi
_ISR_Disable( level );
10dc61: 9c pushf
10dc62: fa cli
10dc63: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10dc64: 8a 15 78 f8 12 00 mov 0x12f878,%dl
10dc6a: 84 d2 test %dl,%dl
10dc6c: 0f 84 16 01 00 00 je 10dd88 <_Thread_Dispatch+0x144>
heir = _Thread_Heir;
10dc72: 8b 2d 70 f8 12 00 mov 0x12f870,%ebp
_Thread_Dispatch_necessary = false;
10dc78: c6 05 78 f8 12 00 00 movb $0x0,0x12f878
_Thread_Executing = heir;
10dc7f: 89 2d 6c f8 12 00 mov %ebp,0x12f86c
/*
* 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 )
10dc85: 39 ee cmp %ebp,%esi
10dc87: 0f 84 fb 00 00 00 je 10dd88 <_Thread_Dispatch+0x144>
10dc8d: 8d 7c 24 18 lea 0x18(%esp),%edi
10dc91: e9 da 00 00 00 jmp 10dd70 <_Thread_Dispatch+0x12c>
10dc96: 66 90 xchg %ax,%ax
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 );
10dc98: 50 push %eax
10dc99: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10dc9a: 89 3c 24 mov %edi,(%esp)
10dc9d: e8 06 33 00 00 call 110fa8 <_TOD_Get_uptime>
_Timestamp_Subtract(
10dca2: 8b 44 24 18 mov 0x18(%esp),%eax
10dca6: 8b 54 24 1c mov 0x1c(%esp),%edx
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
10dcaa: 89 c1 mov %eax,%ecx
10dcac: 89 d3 mov %edx,%ebx
10dcae: 2b 0d 7c f8 12 00 sub 0x12f87c,%ecx
10dcb4: 1b 1d 80 f8 12 00 sbb 0x12f880,%ebx
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
10dcba: 01 8e 80 00 00 00 add %ecx,0x80(%esi)
10dcc0: 11 9e 84 00 00 00 adc %ebx,0x84(%esi)
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
10dcc6: a3 7c f8 12 00 mov %eax,0x12f87c
10dccb: 89 15 80 f8 12 00 mov %edx,0x12f880
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10dcd1: a1 7c f6 12 00 mov 0x12f67c,%eax
10dcd6: 85 c0 test %eax,%eax
10dcd8: 74 10 je 10dcea <_Thread_Dispatch+0xa6> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10dcda: 8b 10 mov (%eax),%edx
10dcdc: 89 96 dc 00 00 00 mov %edx,0xdc(%esi)
*_Thread_libc_reent = heir->libc_reent;
10dce2: 8b 95 dc 00 00 00 mov 0xdc(%ebp),%edx
10dce8: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10dcea: 89 6c 24 04 mov %ebp,0x4(%esp)
10dcee: 89 34 24 mov %esi,(%esp)
10dcf1: e8 5e 0c 00 00 call 10e954 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10dcf6: 81 c5 c0 00 00 00 add $0xc0,%ebp
10dcfc: 89 6c 24 04 mov %ebp,0x4(%esp)
10dd00: 8d 86 c0 00 00 00 lea 0xc0(%esi),%eax
10dd06: 89 04 24 mov %eax,(%esp)
10dd09: e8 82 0f 00 00 call 10ec90 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10dd0e: 8b 86 d8 00 00 00 mov 0xd8(%esi),%eax
10dd14: 85 c0 test %eax,%eax
10dd16: 74 2e je 10dd46 <_Thread_Dispatch+0x102>
#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 );
10dd18: a1 78 f6 12 00 mov 0x12f678,%eax
10dd1d: 39 c6 cmp %eax,%esi
10dd1f: 74 25 je 10dd46 <_Thread_Dispatch+0x102>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10dd21: 85 c0 test %eax,%eax
10dd23: 74 0d je 10dd32 <_Thread_Dispatch+0xee>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10dd25: 05 d8 00 00 00 add $0xd8,%eax
10dd2a: 89 04 24 mov %eax,(%esp)
10dd2d: e8 92 0f 00 00 call 10ecc4 <_CPU_Context_save_fp>
_Context_Restore_fp( &executing->fp_context );
10dd32: 8d 86 d8 00 00 00 lea 0xd8(%esi),%eax
10dd38: 89 04 24 mov %eax,(%esp)
10dd3b: e8 8e 0f 00 00 call 10ecce <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10dd40: 89 35 78 f6 12 00 mov %esi,0x12f678
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10dd46: 8b 35 6c f8 12 00 mov 0x12f86c,%esi
_ISR_Disable( level );
10dd4c: 9c pushf
10dd4d: fa cli
10dd4e: 58 pop %eax
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10dd4f: 8a 15 78 f8 12 00 mov 0x12f878,%dl
10dd55: 84 d2 test %dl,%dl
10dd57: 74 2f je 10dd88 <_Thread_Dispatch+0x144>
heir = _Thread_Heir;
10dd59: 8b 2d 70 f8 12 00 mov 0x12f870,%ebp
_Thread_Dispatch_necessary = false;
10dd5f: c6 05 78 f8 12 00 00 movb $0x0,0x12f878
_Thread_Executing = heir;
10dd66: 89 2d 6c f8 12 00 mov %ebp,0x12f86c
/*
* 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 )
10dd6c: 39 f5 cmp %esi,%ebp
10dd6e: 74 18 je 10dd88 <_Thread_Dispatch+0x144><== 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 )
10dd70: 83 7d 78 01 cmpl $0x1,0x78(%ebp)
10dd74: 0f 85 1e ff ff ff jne 10dc98 <_Thread_Dispatch+0x54>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10dd7a: 8b 15 d8 f5 12 00 mov 0x12f5d8,%edx
10dd80: 89 55 74 mov %edx,0x74(%ebp)
10dd83: e9 10 ff ff ff jmp 10dc98 <_Thread_Dispatch+0x54>
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
10dd88: 50 push %eax
10dd89: 9d popf
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
10dd8a: a1 04 f6 12 00 mov 0x12f604,%eax
10dd8f: 48 dec %eax
10dd90: a3 04 f6 12 00 mov %eax,0x12f604
return _Thread_Dispatch_disable_level;
10dd95: a1 04 f6 12 00 mov 0x12f604,%eax
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
10dd9a: e8 9d e4 ff ff call 10c23c <_API_extensions_Run_postswitch>
}
10dd9f: 83 c4 2c add $0x2c,%esp
10dda2: 5b pop %ebx
10dda3: 5e pop %esi
10dda4: 5f pop %edi
10dda5: 5d pop %ebp
10dda6: c3 ret
00112b64 <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
112b64: 53 push %ebx
112b65: 83 ec 28 sub $0x28,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
112b68: 8b 1d 6c f8 12 00 mov 0x12f86c,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
112b6e: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
_ISR_Set_level(level);
112b74: 85 c0 test %eax,%eax
112b76: 74 7d je 112bf5 <_Thread_Handler+0x91>
112b78: fa cli
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
112b79: a0 b4 f2 12 00 mov 0x12f2b4,%al
112b7e: 88 44 24 1f mov %al,0x1f(%esp)
doneConstructors = true;
112b82: c6 05 b4 f2 12 00 01 movb $0x1,0x12f2b4
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
112b89: 8b 93 d8 00 00 00 mov 0xd8(%ebx),%edx
112b8f: 85 d2 test %edx,%edx
112b91: 74 20 je 112bb3 <_Thread_Handler+0x4f>
#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 );
112b93: a1 78 f6 12 00 mov 0x12f678,%eax
112b98: 39 c3 cmp %eax,%ebx
112b9a: 74 17 je 112bb3 <_Thread_Handler+0x4f>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
112b9c: 85 c0 test %eax,%eax
112b9e: 74 0d je 112bad <_Thread_Handler+0x49>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
112ba0: 05 d8 00 00 00 add $0xd8,%eax
112ba5: 89 04 24 mov %eax,(%esp)
112ba8: e8 17 c1 ff ff call 10ecc4 <_CPU_Context_save_fp>
_Thread_Allocated_fp = executing;
112bad: 89 1d 78 f6 12 00 mov %ebx,0x12f678
/*
* 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 );
112bb3: 89 1c 24 mov %ebx,(%esp)
112bb6: e8 1d bc ff ff call 10e7d8 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
112bbb: e8 e8 b1 ff ff call 10dda8 <_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 (doCons) /* && (volatile void *)_init) */ {
112bc0: 80 7c 24 1f 00 cmpb $0x0,0x1f(%esp)
112bc5: 74 31 je 112bf8 <_Thread_Handler+0x94>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
112bc7: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax
112bcd: 85 c0 test %eax,%eax
112bcf: 74 2e je 112bff <_Thread_Handler+0x9b> <== 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 );
112bd1: 89 1c 24 mov %ebx,(%esp)
112bd4: e8 33 bc ff ff call 10e80c <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
112bd9: c7 44 24 08 05 00 00 movl $0x5,0x8(%esp)
112be0: 00
112be1: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
112be8: 00
112be9: c7 04 24 00 00 00 00 movl $0x0,(%esp)
112bf0: e8 cb 9f ff ff call 10cbc0 <_Internal_error_Occurred>
/*
* 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);
112bf5: fb sti
112bf6: eb 81 jmp 112b79 <_Thread_Handler+0x15>
* _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 (doCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
112bf8: e8 07 cc 00 00 call 11f804 <__start_set_sysctl_set>
112bfd: eb c8 jmp 112bc7 <_Thread_Handler+0x63>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
112bff: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax
112c05: 89 04 24 mov %eax,(%esp)
112c08: ff 93 8c 00 00 00 call *0x8c(%ebx)
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
112c0e: 89 43 28 mov %eax,0x28(%ebx)
112c11: eb be jmp 112bd1 <_Thread_Handler+0x6d>
0010e06c <_Thread_Handler_initialization>:
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
10e06c: 56 push %esi
10e06d: 53 push %ebx
10e06e: 83 ec 24 sub $0x24,%esp
uint32_t ticks_per_timeslice =
10e071: 8b 1d 78 b1 12 00 mov 0x12b178,%ebx
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
10e077: 8b 35 6c b1 12 00 mov 0x12b16c,%esi
rtems_configuration_get_maximum_extensions();
rtems_stack_allocate_init_hook stack_allocate_init_hook =
10e07d: a1 88 b1 12 00 mov 0x12b188,%eax
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
10e082: 8b 0d 8c b1 12 00 mov 0x12b18c,%ecx
10e088: 85 c9 test %ecx,%ecx
10e08a: 0f 84 90 00 00 00 je 10e120 <_Thread_Handler_initialization+0xb4>
10e090: 8b 15 90 b1 12 00 mov 0x12b190,%edx
10e096: 85 d2 test %edx,%edx
10e098: 0f 84 82 00 00 00 je 10e120 <_Thread_Handler_initialization+0xb4><== NEVER TAKEN
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
10e09e: 85 c0 test %eax,%eax
10e0a0: 74 0b je 10e0ad <_Thread_Handler_initialization+0x41>
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
10e0a2: 8b 15 68 b1 12 00 mov 0x12b168,%edx
10e0a8: 89 14 24 mov %edx,(%esp)
10e0ab: ff d0 call *%eax
_Thread_Dispatch_necessary = false;
10e0ad: c6 05 78 f8 12 00 00 movb $0x0,0x12f878
_Thread_Executing = NULL;
10e0b4: c7 05 6c f8 12 00 00 movl $0x0,0x12f86c
10e0bb: 00 00 00
_Thread_Heir = NULL;
10e0be: c7 05 70 f8 12 00 00 movl $0x0,0x12f870
10e0c5: 00 00 00
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
10e0c8: c7 05 78 f6 12 00 00 movl $0x0,0x12f678
10e0cf: 00 00 00
#endif
_Thread_Maximum_extensions = maximum_extensions;
10e0d2: 89 35 80 f6 12 00 mov %esi,0x12f680
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
10e0d8: 89 1d d8 f5 12 00 mov %ebx,0x12f5d8
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
10e0de: c7 44 24 18 08 00 00 movl $0x8,0x18(%esp)
10e0e5: 00
10e0e6: c7 44 24 14 00 00 00 movl $0x0,0x14(%esp)
10e0ed: 00
10e0ee: c7 44 24 10 f0 00 00 movl $0xf0,0x10(%esp)
10e0f5: 00
10e0f6: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp)
10e0fd: 00
10e0fe: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10e105: 00
10e106: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10e10d: 00
10e10e: c7 04 24 20 f7 12 00 movl $0x12f720,(%esp)
10e115: e8 6e f0 ff ff call 10d188 <_Objects_Initialize_information>
false, /* true if this is a global object class */
NULL /* Proxy extraction support callout */
#endif
);
}
10e11a: 83 c4 24 add $0x24,%esp
10e11d: 5b pop %ebx
10e11e: 5e pop %esi
10e11f: c3 ret
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
10e120: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
10e127: 00
10e128: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10e12f: 00
10e130: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10e137: e8 84 ea ff ff call 10cbc0 <_Internal_error_Occurred>
0010de48 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10de48: 55 push %ebp
10de49: 57 push %edi
10de4a: 56 push %esi
10de4b: 53 push %ebx
10de4c: 83 ec 2c sub $0x2c,%esp
10de4f: 8b 5c 24 44 mov 0x44(%esp),%ebx
10de53: 8b 74 24 4c mov 0x4c(%esp),%esi
10de57: 0f b6 7c 24 50 movzbl 0x50(%esp),%edi
10de5c: 8a 44 24 58 mov 0x58(%esp),%al
10de60: 88 44 24 1f mov %al,0x1f(%esp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10de64: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
10de6b: 00 00 00
10de6e: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10de75: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10de78: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
10de7f: 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 );
10de82: 89 74 24 04 mov %esi,0x4(%esp)
10de86: 89 1c 24 mov %ebx,(%esp)
10de89: e8 96 07 00 00 call 10e624 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10de8e: 85 c0 test %eax,%eax
10de90: 0f 84 5a 01 00 00 je 10dff0 <_Thread_Initialize+0x1a8>
10de96: 39 c6 cmp %eax,%esi
10de98: 0f 87 52 01 00 00 ja 10dff0 <_Thread_Initialize+0x1a8><== NEVER TAKEN
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10de9e: 8b 93 bc 00 00 00 mov 0xbc(%ebx),%edx
10dea4: 89 93 b4 00 00 00 mov %edx,0xb4(%ebx)
the_stack->size = size;
10deaa: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10deb0: 89 f8 mov %edi,%eax
10deb2: 84 c0 test %al,%al
10deb4: 0f 85 46 01 00 00 jne 10e000 <_Thread_Initialize+0x1b8>
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10deba: 31 f6 xor %esi,%esi
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;
10debc: 89 b3 d8 00 00 00 mov %esi,0xd8(%ebx)
the_thread->Start.fp_context = fp_area;
10dec2: 89 b3 b8 00 00 00 mov %esi,0xb8(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10dec8: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10decf: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10ded6: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10dedd: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10dee4: a1 80 f6 12 00 mov 0x12f680,%eax
10dee9: 85 c0 test %eax,%eax
10deeb: 0f 85 2f 01 00 00 jne 10e020 <_Thread_Initialize+0x1d8>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10def1: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10def8: 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;
10defb: 31 ed xor %ebp,%ebp
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10defd: 8a 44 24 1f mov 0x1f(%esp),%al
10df01: 88 83 9c 00 00 00 mov %al,0x9c(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10df07: 8b 44 24 5c mov 0x5c(%esp),%eax
10df0b: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10df11: 8b 44 24 60 mov 0x60(%esp),%eax
10df15: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10df1b: 8b 44 24 64 mov 0x64(%esp),%eax
10df1f: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
the_thread->current_state = STATES_DORMANT;
10df25: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10df2c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10df33: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10df3a: 8b 44 24 54 mov 0x54(%esp),%eax
10df3e: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10df41: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
10df47: 89 1c 24 mov %ebx,(%esp)
10df4a: ff 15 98 b2 12 00 call *0x12b298
10df50: 89 c7 mov %eax,%edi
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
10df52: 85 c0 test %eax,%eax
10df54: 74 45 je 10df9b <_Thread_Initialize+0x153><== NEVER TAKEN
goto failed;
_Thread_Set_priority( the_thread, priority );
10df56: 8b 44 24 54 mov 0x54(%esp),%eax
10df5a: 89 44 24 04 mov %eax,0x4(%esp)
10df5e: 89 1c 24 mov %ebx,(%esp)
10df61: e8 46 06 00 00 call 10e5ac <_Thread_Set_priority>
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
10df66: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx)
10df6d: 00 00 00
10df70: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10df77: 00 00 00
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10df7a: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10df7e: 8b 44 24 40 mov 0x40(%esp),%eax
10df82: 8b 40 1c mov 0x1c(%eax),%eax
10df85: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10df88: 8b 44 24 68 mov 0x68(%esp),%eax
10df8c: 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 );
10df8f: 89 1c 24 mov %ebx,(%esp)
10df92: e8 f9 08 00 00 call 10e890 <_User_extensions_Thread_create>
if ( extension_status )
10df97: 84 c0 test %al,%al
10df99: 75 61 jne 10dffc <_Thread_Initialize+0x1b4>
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10df9b: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
10dfa1: 89 04 24 mov %eax,(%esp)
10dfa4: e8 7f 0c 00 00 call 10ec28 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10dfa9: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax
10dfaf: 89 04 24 mov %eax,(%esp)
10dfb2: e8 71 0c 00 00 call 10ec28 <_Workspace_Free>
10dfb7: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
10dfbd: 89 04 24 mov %eax,(%esp)
10dfc0: e8 63 0c 00 00 call 10ec28 <_Workspace_Free>
_Workspace_Free( extensions_area );
10dfc5: 89 2c 24 mov %ebp,(%esp)
10dfc8: e8 5b 0c 00 00 call 10ec28 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10dfcd: 89 34 24 mov %esi,(%esp)
10dfd0: e8 53 0c 00 00 call 10ec28 <_Workspace_Free>
#endif
_Workspace_Free( sched );
10dfd5: 89 3c 24 mov %edi,(%esp)
10dfd8: e8 4b 0c 00 00 call 10ec28 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10dfdd: 89 1c 24 mov %ebx,(%esp)
10dfe0: e8 77 06 00 00 call 10e65c <_Thread_Stack_Free>
return false;
10dfe5: 31 c0 xor %eax,%eax
}
10dfe7: 83 c4 2c add $0x2c,%esp
10dfea: 5b pop %ebx
10dfeb: 5e pop %esi
10dfec: 5f pop %edi
10dfed: 5d pop %ebp
10dfee: c3 ret
10dfef: 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 */
10dff0: 31 c0 xor %eax,%eax
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10dff2: 83 c4 2c add $0x2c,%esp
10dff5: 5b pop %ebx
10dff6: 5e pop %esi
10dff7: 5f pop %edi
10dff8: 5d pop %ebp
10dff9: c3 ret
10dffa: 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;
10dffc: b0 01 mov $0x1,%al
10dffe: eb f2 jmp 10dff2 <_Thread_Initialize+0x1aa>
/*
* 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 );
10e000: c7 04 24 6c 00 00 00 movl $0x6c,(%esp)
10e007: e8 f0 0b 00 00 call 10ebfc <_Workspace_Allocate>
10e00c: 89 c6 mov %eax,%esi
if ( !fp_area )
10e00e: 85 c0 test %eax,%eax
10e010: 0f 85 a6 fe ff ff jne 10debc <_Thread_Initialize+0x74>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10e016: 31 ed xor %ebp,%ebp
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;
10e018: 31 ff xor %edi,%edi
10e01a: e9 7c ff ff ff jmp 10df9b <_Thread_Initialize+0x153>
10e01f: 90 nop
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10e020: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10e027: 89 04 24 mov %eax,(%esp)
10e02a: e8 cd 0b 00 00 call 10ebfc <_Workspace_Allocate>
10e02f: 89 c5 mov %eax,%ebp
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10e031: 85 c0 test %eax,%eax
10e033: 74 30 je 10e065 <_Thread_Initialize+0x21d>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10e035: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx)
10e03b: 8b 3d 80 f6 12 00 mov 0x12f680,%edi
10e041: 89 c1 mov %eax,%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++ )
10e043: 31 c0 xor %eax,%eax
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10e045: 31 d2 xor %edx,%edx
10e047: eb 09 jmp 10e052 <_Thread_Initialize+0x20a>
10e049: 8d 76 00 lea 0x0(%esi),%esi
10e04c: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx
* 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;
10e052: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10e059: 42 inc %edx
10e05a: 89 d0 mov %edx,%eax
10e05c: 39 fa cmp %edi,%edx
10e05e: 76 ec jbe 10e04c <_Thread_Initialize+0x204>
10e060: e9 98 fe ff ff jmp 10defd <_Thread_Initialize+0xb5>
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;
10e065: 31 ff xor %edi,%edi
10e067: e9 2f ff ff ff jmp 10df9b <_Thread_Initialize+0x153>
001116c0 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
1116c0: 83 ec 1c sub $0x1c,%esp
1116c3: 8b 44 24 20 mov 0x20(%esp),%eax
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
1116c7: 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 &&
1116ca: 8b 4a 30 mov 0x30(%edx),%ecx
1116cd: 85 c9 test %ecx,%ecx
1116cf: 74 08 je 1116d9 <_Thread_queue_Process_timeout+0x19>
1116d1: 3b 05 6c f8 12 00 cmp 0x12f86c,%eax
1116d7: 74 17 je 1116f0 <_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;
1116d9: 8b 4a 3c mov 0x3c(%edx),%ecx
1116dc: 89 48 34 mov %ecx,0x34(%eax)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
1116df: 89 44 24 04 mov %eax,0x4(%esp)
1116e3: 89 14 24 mov %edx,(%esp)
1116e6: e8 ed fe ff ff call 1115d8 <_Thread_queue_Extract>
}
}
1116eb: 83 c4 1c add $0x1c,%esp
1116ee: c3 ret
1116ef: 90 nop
* 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 ) {
1116f0: 83 f9 03 cmp $0x3,%ecx
1116f3: 74 f6 je 1116eb <_Thread_queue_Process_timeout+0x2b>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
1116f5: 8b 4a 3c mov 0x3c(%edx),%ecx
1116f8: 89 48 34 mov %ecx,0x34(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
1116fb: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
111702: eb e7 jmp 1116eb <_Thread_queue_Process_timeout+0x2b>
0010e504 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10e504: 56 push %esi
10e505: 53 push %ebx
10e506: 83 ec 24 sub $0x24,%esp
10e509: 8b 5c 24 30 mov 0x30(%esp),%ebx
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
10e50d: 85 db test %ebx,%ebx
10e50f: 74 06 je 10e517 <_Thread_queue_Requeue+0x13><== 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 ) {
10e511: 83 7b 34 01 cmpl $0x1,0x34(%ebx)
10e515: 74 09 je 10e520 <_Thread_queue_Requeue+0x1c><== ALWAYS TAKEN
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
10e517: 83 c4 24 add $0x24,%esp <== NOT EXECUTED
10e51a: 5b pop %ebx <== NOT EXECUTED
10e51b: 5e pop %esi <== NOT EXECUTED
10e51c: c3 ret <== NOT EXECUTED
10e51d: 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 );
10e520: 9c pushf
10e521: fa cli
10e522: 5e pop %esi
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10e523: 8b 44 24 34 mov 0x34(%esp),%eax
10e527: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10e52e: 75 08 jne 10e538 <_Thread_queue_Requeue+0x34><== 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 );
10e530: 56 push %esi
10e531: 9d popf
}
}
10e532: 83 c4 24 add $0x24,%esp
10e535: 5b pop %ebx
10e536: 5e pop %esi
10e537: c3 ret
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10e538: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
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 );
10e53f: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10e546: 00
10e547: 89 44 24 04 mov %eax,0x4(%esp)
10e54b: 89 1c 24 mov %ebx,(%esp)
10e54e: e8 c1 30 00 00 call 111614 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10e553: 8d 44 24 1c lea 0x1c(%esp),%eax
10e557: 89 44 24 08 mov %eax,0x8(%esp)
10e55b: 8b 44 24 34 mov 0x34(%esp),%eax
10e55f: 89 44 24 04 mov %eax,0x4(%esp)
10e563: 89 1c 24 mov %ebx,(%esp)
10e566: e8 81 fd ff ff call 10e2ec <_Thread_queue_Enqueue_priority>
10e56b: eb c3 jmp 10e530 <_Thread_queue_Requeue+0x2c>
0010e570 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10e570: 83 ec 2c sub $0x2c,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e573: 8d 44 24 1c lea 0x1c(%esp),%eax
10e577: 89 44 24 04 mov %eax,0x4(%esp)
10e57b: 8b 44 24 30 mov 0x30(%esp),%eax
10e57f: 89 04 24 mov %eax,(%esp)
10e582: e8 41 f8 ff ff call 10ddc8 <_Thread_Get>
switch ( location ) {
10e587: 8b 54 24 1c mov 0x1c(%esp),%edx
10e58b: 85 d2 test %edx,%edx
10e58d: 75 18 jne 10e5a7 <_Thread_queue_Timeout+0x37><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10e58f: 89 04 24 mov %eax,(%esp)
10e592: e8 29 31 00 00 call 1116c0 <_Thread_queue_Process_timeout>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
10e597: a1 04 f6 12 00 mov 0x12f604,%eax
10e59c: 48 dec %eax
10e59d: a3 04 f6 12 00 mov %eax,0x12f604
return _Thread_Dispatch_disable_level;
10e5a2: a1 04 f6 12 00 mov 0x12f604,%eax
_Thread_Unnest_dispatch();
break;
}
}
10e5a7: 83 c4 2c add $0x2c,%esp
10e5aa: c3 ret
0011bf68 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
11bf68: 55 push %ebp
11bf69: 57 push %edi
11bf6a: 56 push %esi
11bf6b: 53 push %ebx
11bf6c: 83 ec 5c sub $0x5c,%esp
11bf6f: 8b 5c 24 70 mov 0x70(%esp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11bf73: 8d 4c 24 3c lea 0x3c(%esp),%ecx
11bf77: 89 4c 24 20 mov %ecx,0x20(%esp)
11bf7b: 89 4c 24 38 mov %ecx,0x38(%esp)
head->previous = NULL;
11bf7f: c7 44 24 3c 00 00 00 movl $0x0,0x3c(%esp)
11bf86: 00
tail->previous = head;
11bf87: 8d 44 24 38 lea 0x38(%esp),%eax
11bf8b: 89 44 24 40 mov %eax,0x40(%esp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11bf8f: 8d 7c 24 44 lea 0x44(%esp),%edi
11bf93: 8d 4c 24 48 lea 0x48(%esp),%ecx
11bf97: 89 4c 24 24 mov %ecx,0x24(%esp)
11bf9b: 89 4c 24 44 mov %ecx,0x44(%esp)
head->previous = NULL;
11bf9f: c7 44 24 48 00 00 00 movl $0x0,0x48(%esp)
11bfa6: 00
tail->previous = head;
11bfa7: 89 7c 24 4c mov %edi,0x4c(%esp)
11bfab: 8d 6b 30 lea 0x30(%ebx),%ebp
11bfae: 8d 73 68 lea 0x68(%ebx),%esi
11bfb1: 8d 4b 08 lea 0x8(%ebx),%ecx
11bfb4: 89 4c 24 28 mov %ecx,0x28(%esp)
11bfb8: 8d 4b 40 lea 0x40(%ebx),%ecx
11bfbb: 89 4c 24 2c mov %ecx,0x2c(%esp)
{
/*
* 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;
11bfbf: 8d 44 24 38 lea 0x38(%esp),%eax
11bfc3: 89 43 78 mov %eax,0x78(%ebx)
11bfc6: 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;
11bfc8: a1 04 db 14 00 mov 0x14db04,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
11bfcd: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
11bfd0: 89 43 3c mov %eax,0x3c(%ebx)
_Chain_Initialize_empty( &insert_chain );
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
11bfd3: 89 7c 24 08 mov %edi,0x8(%esp)
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
11bfd7: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
11bfd9: 89 44 24 04 mov %eax,0x4(%esp)
11bfdd: 89 2c 24 mov %ebp,(%esp)
11bfe0: e8 9b 3d 00 00 call 11fd80 <_Watchdog_Adjust_to_chain>
11bfe5: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
11bfec: 3b
11bfed: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
11bff4: 00
11bff5: a1 c0 d9 14 00 mov 0x14d9c0,%eax
11bffa: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx
11c000: 89 04 24 mov %eax,(%esp)
11c003: 89 54 24 04 mov %edx,0x4(%esp)
11c007: e8 38 40 01 00 call 130044 <__divdi3>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
11c00c: 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 ) {
11c00f: 39 d0 cmp %edx,%eax
11c011: 0f 87 89 00 00 00 ja 11c0a0 <_Timer_server_Body+0x138>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
11c017: 73 1e jae 11c037 <_Timer_server_Body+0xcf>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
11c019: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
11c01b: 89 54 24 08 mov %edx,0x8(%esp)
11c01f: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
11c026: 00
11c027: 89 34 24 mov %esi,(%esp)
11c02a: 89 44 24 1c mov %eax,0x1c(%esp)
11c02e: e8 dd 3c 00 00 call 11fd10 <_Watchdog_Adjust>
11c033: 8b 44 24 1c mov 0x1c(%esp),%eax
}
watchdogs->last_snapshot = snapshot;
11c037: 89 43 74 mov %eax,0x74(%ebx)
11c03a: 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 );
11c03c: 8b 43 78 mov 0x78(%ebx),%eax
11c03f: 89 04 24 mov %eax,(%esp)
11c042: e8 95 08 00 00 call 11c8dc <_Chain_Get>
if ( timer == NULL ) {
11c047: 85 c0 test %eax,%eax
11c049: 74 2d je 11c078 <_Timer_server_Body+0x110><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
11c04b: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
11c04e: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
11c051: 74 39 je 11c08c <_Timer_server_Body+0x124><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
11c053: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
11c056: 75 e4 jne 11c03c <_Timer_server_Body+0xd4><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
11c058: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
11c05b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11c05f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
11c062: e8 a1 3d 00 00 call 11fe08 <_Watchdog_Insert> <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
11c067: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
11c06a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11c06d: e8 6a 08 00 00 call 11c8dc <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
11c072: 85 c0 test %eax,%eax <== NOT EXECUTED
11c074: 75 d5 jne 11c04b <_Timer_server_Body+0xe3><== NOT EXECUTED
11c076: 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 );
11c078: 9c pushf
11c079: fa cli
11c07a: 58 pop %eax
if ( _Chain_Is_empty( insert_chain ) ) {
11c07b: 8b 4c 24 20 mov 0x20(%esp),%ecx
11c07f: 39 4c 24 38 cmp %ecx,0x38(%esp)
11c083: 74 3c je 11c0c1 <_Timer_server_Body+0x159><== ALWAYS TAKEN
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
11c085: 50 push %eax <== NOT EXECUTED
11c086: 9d popf <== NOT EXECUTED
11c087: e9 3c ff ff ff jmp 11bfc8 <_Timer_server_Body+0x60><== 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 );
11c08c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
11c08f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11c093: 89 2c 24 mov %ebp,(%esp) <== NOT EXECUTED
11c096: e8 6d 3d 00 00 call 11fe08 <_Watchdog_Insert> <== NOT EXECUTED
11c09b: eb 9f jmp 11c03c <_Timer_server_Body+0xd4><== NOT EXECUTED
11c09d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
_Chain_Initialize_empty( &insert_chain );
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
11c0a0: 89 7c 24 08 mov %edi,0x8(%esp)
if ( snapshot > last_snapshot ) {
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
11c0a4: 89 c1 mov %eax,%ecx
11c0a6: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
11c0a8: 89 4c 24 04 mov %ecx,0x4(%esp)
11c0ac: 89 34 24 mov %esi,(%esp)
11c0af: 89 44 24 1c mov %eax,0x1c(%esp)
11c0b3: e8 c8 3c 00 00 call 11fd80 <_Watchdog_Adjust_to_chain>
11c0b8: 8b 44 24 1c mov 0x1c(%esp),%eax
11c0bc: e9 76 ff ff ff jmp 11c037 <_Timer_server_Body+0xcf>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
11c0c1: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
_ISR_Enable( level );
11c0c8: 50 push %eax
11c0c9: 9d popf
_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 ) ) {
11c0ca: 8b 4c 24 24 mov 0x24(%esp),%ecx
11c0ce: 39 4c 24 44 cmp %ecx,0x44(%esp)
11c0d2: 75 26 jne 11c0fa <_Timer_server_Body+0x192>
11c0d4: eb 38 jmp 11c10e <_Timer_server_Body+0x1a6>
11c0d6: 66 90 xchg %ax,%ax
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
11c0d8: 8b 10 mov (%eax),%edx
head->next = new_first;
11c0da: 89 54 24 44 mov %edx,0x44(%esp)
new_first->previous = head;
11c0de: 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;
11c0e1: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
11c0e8: 51 push %ecx
11c0e9: 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 );
11c0ea: 8b 50 24 mov 0x24(%eax),%edx
11c0ed: 89 54 24 04 mov %edx,0x4(%esp)
11c0f1: 8b 50 20 mov 0x20(%eax),%edx
11c0f4: 89 14 24 mov %edx,(%esp)
11c0f7: ff 50 1c call *0x1c(%eax)
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
11c0fa: 9c pushf
11c0fb: fa cli
11c0fc: 59 pop %ecx
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
11c0fd: 8b 44 24 44 mov 0x44(%esp),%eax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
11c101: 3b 44 24 24 cmp 0x24(%esp),%eax
11c105: 75 d1 jne 11c0d8 <_Timer_server_Body+0x170>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
11c107: 51 push %ecx
11c108: 9d popf
11c109: e9 b1 fe ff ff jmp 11bfbf <_Timer_server_Body+0x57>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
11c10e: c6 43 7c 00 movb $0x0,0x7c(%ebx)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
11c112: a1 04 da 14 00 mov 0x14da04,%eax
11c117: 40 inc %eax
11c118: a3 04 da 14 00 mov %eax,0x14da04
return _Thread_Dispatch_disable_level;
11c11d: a1 04 da 14 00 mov 0x14da04,%eax
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
11c122: c7 44 24 04 08 00 00 movl $0x8,0x4(%esp)
11c129: 00
11c12a: 8b 03 mov (%ebx),%eax
11c12c: 89 04 24 mov %eax,(%esp)
11c12f: e8 d0 37 00 00 call 11f904 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
11c134: 89 d8 mov %ebx,%eax
11c136: e8 3d fc ff ff call 11bd78 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
11c13b: 89 d8 mov %ebx,%eax
11c13d: e8 7e fc ff ff call 11bdc0 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
11c142: e8 1d 2f 00 00 call 11f064 <_Thread_Enable_dispatch>
ts->active = true;
11c147: 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 );
11c14b: 8b 4c 24 28 mov 0x28(%esp),%ecx
11c14f: 89 0c 24 mov %ecx,(%esp)
11c152: e8 cd 3d 00 00 call 11ff24 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
11c157: 8b 4c 24 2c mov 0x2c(%esp),%ecx
11c15b: 89 0c 24 mov %ecx,(%esp)
11c15e: e8 c1 3d 00 00 call 11ff24 <_Watchdog_Remove>
11c163: e9 57 fe ff ff jmp 11bfbf <_Timer_server_Body+0x57>
0011be08 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
11be08: 55 push %ebp
11be09: 57 push %edi
11be0a: 56 push %esi
11be0b: 53 push %ebx
11be0c: 83 ec 2c sub $0x2c,%esp
11be0f: 8b 5c 24 40 mov 0x40(%esp),%ebx
11be13: 8b 74 24 44 mov 0x44(%esp),%esi
if ( ts->insert_chain == NULL ) {
11be17: 8b 43 78 mov 0x78(%ebx),%eax
11be1a: 85 c0 test %eax,%eax
11be1c: 74 1a je 11be38 <_Timer_server_Schedule_operation_method+0x30><== 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 );
11be1e: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
11be21: 89 74 24 44 mov %esi,0x44(%esp) <== NOT EXECUTED
11be25: 89 44 24 40 mov %eax,0x40(%esp) <== NOT EXECUTED
}
}
11be29: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
11be2c: 5b pop %ebx <== NOT EXECUTED
11be2d: 5e pop %esi <== NOT EXECUTED
11be2e: 5f pop %edi <== NOT EXECUTED
11be2f: 5d pop %ebp <== 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 );
11be30: e9 83 0a 00 00 jmp 11c8b8 <_Chain_Append> <== NOT EXECUTED
11be35: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
11be38: a1 04 da 14 00 mov 0x14da04,%eax
11be3d: 40 inc %eax
11be3e: a3 04 da 14 00 mov %eax,0x14da04
return _Thread_Dispatch_disable_level;
11be43: a1 04 da 14 00 mov 0x14da04,%eax
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
11be48: 8b 46 38 mov 0x38(%esi),%eax
11be4b: 83 f8 01 cmp $0x1,%eax
11be4e: 0f 84 a8 00 00 00 je 11befc <_Timer_server_Schedule_operation_method+0xf4>
_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 ) {
11be54: 83 f8 03 cmp $0x3,%eax
11be57: 74 0f je 11be68 <_Timer_server_Schedule_operation_method+0x60>
* 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 );
}
}
11be59: 83 c4 2c add $0x2c,%esp
11be5c: 5b pop %ebx
11be5d: 5e pop %esi
11be5e: 5f pop %edi
11be5f: 5d pop %ebp
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
11be60: e9 ff 31 00 00 jmp 11f064 <_Thread_Enable_dispatch>
11be65: 8d 76 00 lea 0x0(%esi),%esi
} 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 );
11be68: 9c pushf
11be69: fa cli
11be6a: 5f pop %edi
11be6b: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
11be72: 3b
11be73: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
11be7a: 00
11be7b: a1 c0 d9 14 00 mov 0x14d9c0,%eax
11be80: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx
11be86: 89 04 24 mov %eax,(%esp)
11be89: 89 54 24 04 mov %edx,0x4(%esp)
11be8d: e8 b2 41 01 00 call 130044 <__divdi3>
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
11be92: 8b 53 74 mov 0x74(%ebx),%edx
11be95: 89 54 24 1c mov %edx,0x1c(%esp)
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
11be99: 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 );
11be9c: 8d 6b 6c lea 0x6c(%ebx),%ebp
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
11be9f: 39 ea cmp %ebp,%edx
11bea1: 74 28 je 11becb <_Timer_server_Schedule_operation_method+0xc3>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
11bea3: 8b 6a 10 mov 0x10(%edx),%ebp
if ( snapshot > last_snapshot ) {
11bea6: 3b 44 24 1c cmp 0x1c(%esp),%eax
11beaa: 0f 86 a4 00 00 00 jbe 11bf54 <_Timer_server_Schedule_operation_method+0x14c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
11beb0: 89 c1 mov %eax,%ecx
11beb2: 2b 4c 24 1c sub 0x1c(%esp),%ecx
11beb6: 89 4c 24 1c mov %ecx,0x1c(%esp)
if (delta_interval > delta) {
11beba: 39 cd cmp %ecx,%ebp
11bebc: 0f 86 9f 00 00 00 jbe 11bf61 <_Timer_server_Schedule_operation_method+0x159><== NEVER TAKEN
delta_interval -= delta;
11bec2: 89 e9 mov %ebp,%ecx
11bec4: 2b 4c 24 1c sub 0x1c(%esp),%ecx
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
11bec8: 89 4a 10 mov %ecx,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
11becb: 89 43 74 mov %eax,0x74(%ebx)
_ISR_Enable( level );
11bece: 57 push %edi
11becf: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
11bed0: 83 c6 10 add $0x10,%esi
11bed3: 89 74 24 04 mov %esi,0x4(%esp)
11bed7: 8d 43 68 lea 0x68(%ebx),%eax
11beda: 89 04 24 mov %eax,(%esp)
11bedd: e8 26 3f 00 00 call 11fe08 <_Watchdog_Insert>
if ( !ts->active ) {
11bee2: 8a 43 7c mov 0x7c(%ebx),%al
11bee5: 84 c0 test %al,%al
11bee7: 0f 85 6c ff ff ff jne 11be59 <_Timer_server_Schedule_operation_method+0x51>
_Timer_server_Reset_tod_system_watchdog( ts );
11beed: 89 d8 mov %ebx,%eax
11beef: e8 cc fe ff ff call 11bdc0 <_Timer_server_Reset_tod_system_watchdog>
11bef4: e9 60 ff ff ff jmp 11be59 <_Timer_server_Schedule_operation_method+0x51>
11bef9: 8d 76 00 lea 0x0(%esi),%esi
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 );
11befc: 9c pushf
11befd: fa cli
11befe: 5d pop %ebp
snapshot = _Watchdog_Ticks_since_boot;
11beff: 8b 15 04 db 14 00 mov 0x14db04,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
11bf05: 8b 7b 3c mov 0x3c(%ebx),%edi
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
11bf08: 8b 43 30 mov 0x30(%ebx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
11bf0b: 8d 4b 34 lea 0x34(%ebx),%ecx
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
11bf0e: 39 c8 cmp %ecx,%eax
11bf10: 74 10 je 11bf22 <_Timer_server_Schedule_operation_method+0x11a>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
11bf12: 89 d1 mov %edx,%ecx
11bf14: 29 f9 sub %edi,%ecx
delta_interval = first_watchdog->delta_interval;
11bf16: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
11bf19: 39 f9 cmp %edi,%ecx
11bf1b: 73 33 jae 11bf50 <_Timer_server_Schedule_operation_method+0x148>
delta_interval -= delta;
11bf1d: 29 cf sub %ecx,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
11bf1f: 89 78 10 mov %edi,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
11bf22: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
11bf25: 55 push %ebp
11bf26: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
11bf27: 83 c6 10 add $0x10,%esi
11bf2a: 89 74 24 04 mov %esi,0x4(%esp)
11bf2e: 8d 43 30 lea 0x30(%ebx),%eax
11bf31: 89 04 24 mov %eax,(%esp)
11bf34: e8 cf 3e 00 00 call 11fe08 <_Watchdog_Insert>
if ( !ts->active ) {
11bf39: 8a 43 7c mov 0x7c(%ebx),%al
11bf3c: 84 c0 test %al,%al
11bf3e: 0f 85 15 ff ff ff jne 11be59 <_Timer_server_Schedule_operation_method+0x51>
_Timer_server_Reset_interval_system_watchdog( ts );
11bf44: 89 d8 mov %ebx,%eax
11bf46: e8 2d fe ff ff call 11bd78 <_Timer_server_Reset_interval_system_watchdog>
11bf4b: e9 09 ff ff ff jmp 11be59 <_Timer_server_Schedule_operation_method+0x51>
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
11bf50: 31 ff xor %edi,%edi
11bf52: eb cb jmp 11bf1f <_Timer_server_Schedule_operation_method+0x117>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
11bf54: 8b 4c 24 1c mov 0x1c(%esp),%ecx
11bf58: 01 e9 add %ebp,%ecx
delta_interval += delta;
11bf5a: 29 c1 sub %eax,%ecx
11bf5c: e9 67 ff ff ff jmp 11bec8 <_Timer_server_Schedule_operation_method+0xc0>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
11bf61: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11bf63: e9 60 ff ff ff jmp 11bec8 <_Timer_server_Schedule_operation_method+0xc0><== NOT EXECUTED
0010ec00 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
10ec00: 56 push %esi
10ec01: 53 push %ebx
10ec02: 8b 74 24 0c mov 0xc(%esp),%esi
10ec06: 8b 4c 24 10 mov 0x10(%esp),%ecx
uint32_t seconds = add->tv_sec;
10ec0a: 8b 01 mov (%ecx),%eax
/* Add the basics */
time->tv_sec += add->tv_sec;
10ec0c: 01 06 add %eax,(%esi)
time->tv_nsec += add->tv_nsec;
10ec0e: 8b 56 04 mov 0x4(%esi),%edx
10ec11: 03 51 04 add 0x4(%ecx),%edx
10ec14: 89 56 04 mov %edx,0x4(%esi)
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10ec17: 81 fa ff c9 9a 3b cmp $0x3b9ac9ff,%edx
10ec1d: 76 1c jbe 10ec3b <_Timespec_Add_to+0x3b>
10ec1f: 8b 0e mov (%esi),%ecx
10ec21: 41 inc %ecx
*
* This routines adds two timespecs. The second argument is added
* to the first.
*/
uint32_t _Timespec_Add_to(
10ec22: 29 c1 sub %eax,%ecx
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 ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
10ec24: 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(
10ec2a: 8d 1c 01 lea (%ecx,%eax,1),%ebx
/* 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++;
10ec2d: 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 ) {
10ec2e: 81 fa ff c9 9a 3b cmp $0x3b9ac9ff,%edx
10ec34: 77 ee ja 10ec24 <_Timespec_Add_to+0x24> <== NEVER TAKEN
10ec36: 89 56 04 mov %edx,0x4(%esi)
10ec39: 89 1e mov %ebx,(%esi)
time->tv_sec++;
seconds++;
}
return seconds;
}
10ec3b: 5b pop %ebx
10ec3c: 5e pop %esi
10ec3d: c3 ret
0010fd90 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
10fd90: 57 push %edi
10fd91: 56 push %esi
10fd92: 53 push %ebx
10fd93: 83 ec 10 sub $0x10,%esp
10fd96: 8b 54 24 20 mov 0x20(%esp),%edx
10fd9a: 8b 44 24 24 mov 0x24(%esp),%eax
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
10fd9e: 8b 18 mov (%eax),%ebx
10fda0: 8b 48 04 mov 0x4(%eax),%ecx
10fda3: 89 c8 mov %ecx,%eax
10fda5: 09 d8 or %ebx,%eax
10fda7: 74 73 je 10fe1c <_Timestamp64_Divide+0x8c><== NEVER TAKEN
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
10fda9: 69 72 04 a0 86 01 00 imul $0x186a0,0x4(%edx),%esi
10fdb0: b8 a0 86 01 00 mov $0x186a0,%eax
10fdb5: f7 22 mull (%edx)
10fdb7: 01 f2 add %esi,%edx
10fdb9: 89 5c 24 08 mov %ebx,0x8(%esp)
10fdbd: 89 4c 24 0c mov %ecx,0xc(%esp)
10fdc1: 89 04 24 mov %eax,(%esp)
10fdc4: 89 54 24 04 mov %edx,0x4(%esp)
10fdc8: e8 db 0d 01 00 call 120ba8 <__divdi3>
10fdcd: 89 c6 mov %eax,%esi
10fdcf: 89 d7 mov %edx,%edi
*_ival_percentage = answer / 1000;
10fdd1: c7 44 24 08 e8 03 00 movl $0x3e8,0x8(%esp)
10fdd8: 00
10fdd9: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
10fde0: 00
10fde1: 89 04 24 mov %eax,(%esp)
10fde4: 89 54 24 04 mov %edx,0x4(%esp)
10fde8: e8 bb 0d 01 00 call 120ba8 <__divdi3>
10fded: 8b 4c 24 28 mov 0x28(%esp),%ecx
10fdf1: 89 01 mov %eax,(%ecx)
*_fval_percentage = answer % 1000;
10fdf3: c7 44 24 08 e8 03 00 movl $0x3e8,0x8(%esp)
10fdfa: 00
10fdfb: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
10fe02: 00
10fe03: 89 34 24 mov %esi,(%esp)
10fe06: 89 7c 24 04 mov %edi,0x4(%esp)
10fe0a: e8 ed 0e 01 00 call 120cfc <__moddi3>
10fe0f: 8b 4c 24 2c mov 0x2c(%esp),%ecx
10fe13: 89 01 mov %eax,(%ecx)
}
10fe15: 83 c4 10 add $0x10,%esp
10fe18: 5b pop %ebx
10fe19: 5e pop %esi
10fe1a: 5f pop %edi
10fe1b: c3 ret
)
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
*_ival_percentage = 0;
10fe1c: 8b 4c 24 28 mov 0x28(%esp),%ecx <== NOT EXECUTED
10fe20: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
*_fval_percentage = 0;
10fe26: 8b 4c 24 2c mov 0x2c(%esp),%ecx <== NOT EXECUTED
10fe2a: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
*_fval_percentage = answer % 1000;
}
10fe30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fe33: 5b pop %ebx <== NOT EXECUTED
10fe34: 5e pop %esi <== NOT EXECUTED
10fe35: 5f pop %edi <== NOT EXECUTED
10fe36: c3 ret <== NOT EXECUTED
0010e844 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10e844: 55 push %ebp
10e845: 57 push %edi
10e846: 56 push %esi
10e847: 53 push %ebx
10e848: 83 ec 1c sub $0x1c,%esp
10e84b: 8b 74 24 30 mov 0x30(%esp),%esi
10e84f: 8b 7c 24 38 mov 0x38(%esp),%edi
10e853: 8a 44 24 34 mov 0x34(%esp),%al
10e857: 8b 1d f4 f7 12 00 mov 0x12f7f4,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e85d: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx
10e863: 74 22 je 10e887 <_User_extensions_Fatal+0x43><== 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 );
10e865: 0f b6 e8 movzbl %al,%ebp
!_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 )
10e868: 8b 43 30 mov 0x30(%ebx),%eax
10e86b: 85 c0 test %eax,%eax
10e86d: 74 0d je 10e87c <_User_extensions_Fatal+0x38>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10e86f: 89 7c 24 08 mov %edi,0x8(%esp)
10e873: 89 6c 24 04 mov %ebp,0x4(%esp)
10e877: 89 34 24 mov %esi,(%esp)
10e87a: ff d0 call *%eax
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 ) {
10e87c: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e87f: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx
10e885: 75 e1 jne 10e868 <_User_extensions_Fatal+0x24>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10e887: 83 c4 1c add $0x1c,%esp
10e88a: 5b pop %ebx
10e88b: 5e pop %esi
10e88c: 5f pop %edi
10e88d: 5d pop %ebp
10e88e: c3 ret
0010e728 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10e728: 55 push %ebp
10e729: 57 push %edi
10e72a: 56 push %esi
10e72b: 53 push %ebx
10e72c: 83 ec 2c sub $0x2c,%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;
10e72f: 8b 15 a4 b1 12 00 mov 0x12b1a4,%edx
10e735: 89 54 24 1c mov %edx,0x1c(%esp)
initial_extensions = Configuration.User_extension_table;
10e739: 8b 2d a8 b1 12 00 mov 0x12b1a8,%ebp
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e73f: c7 05 ec f7 12 00 f0 movl $0x12f7f0,0x12f7ec
10e746: f7 12 00
head->previous = NULL;
10e749: c7 05 f0 f7 12 00 00 movl $0x0,0x12f7f0
10e750: 00 00 00
tail->previous = head;
10e753: c7 05 f4 f7 12 00 ec movl $0x12f7ec,0x12f7f4
10e75a: f7 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e75d: c7 05 08 f6 12 00 0c movl $0x12f60c,0x12f608
10e764: f6 12 00
head->previous = NULL;
10e767: c7 05 0c f6 12 00 00 movl $0x0,0x12f60c
10e76e: 00 00 00
tail->previous = head;
10e771: c7 05 10 f6 12 00 08 movl $0x12f608,0x12f610
10e778: f6 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10e77b: 85 ed test %ebp,%ebp
10e77d: 74 4e je 10e7cd <_User_extensions_Handler_initialization+0xa5><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10e77f: 8d 04 52 lea (%edx,%edx,2),%eax
10e782: 8d 34 82 lea (%edx,%eax,4),%esi
10e785: c1 e6 02 shl $0x2,%esi
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
10e788: 89 34 24 mov %esi,(%esp)
10e78b: e8 b4 04 00 00 call 10ec44 <_Workspace_Allocate_or_fatal_error>
10e790: 89 c3 mov %eax,%ebx
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10e792: 31 c0 xor %eax,%eax
10e794: 89 df mov %ebx,%edi
10e796: 89 f1 mov %esi,%ecx
10e798: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e79a: 8b 44 24 1c mov 0x1c(%esp),%eax
10e79e: 85 c0 test %eax,%eax
10e7a0: 74 2b je 10e7cd <_User_extensions_Handler_initialization+0xa5><== NEVER TAKEN
10e7a2: 89 6c 24 18 mov %ebp,0x18(%esp)
10e7a6: 31 ed xor %ebp,%ebp
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10e7a8: 8d 7b 14 lea 0x14(%ebx),%edi
10e7ab: 8b 74 24 18 mov 0x18(%esp),%esi
10e7af: b9 08 00 00 00 mov $0x8,%ecx
10e7b4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10e7b6: 89 1c 24 mov %ebx,(%esp)
10e7b9: e8 6a 2f 00 00 call 111728 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10e7be: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e7c1: 45 inc %ebp
10e7c2: 83 44 24 18 20 addl $0x20,0x18(%esp)
10e7c7: 3b 6c 24 1c cmp 0x1c(%esp),%ebp
10e7cb: 75 db jne 10e7a8 <_User_extensions_Handler_initialization+0x80>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10e7cd: 83 c4 2c add $0x2c,%esp
10e7d0: 5b pop %ebx
10e7d1: 5e pop %esi
10e7d2: 5f pop %edi
10e7d3: 5d pop %ebp
10e7d4: c3 ret
0010e7d8 <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10e7d8: 56 push %esi
10e7d9: 53 push %ebx
10e7da: 83 ec 14 sub $0x14,%esp
10e7dd: 8b 74 24 20 mov 0x20(%esp),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10e7e1: 8b 1d ec f7 12 00 mov 0x12f7ec,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e7e7: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx
10e7ed: 74 17 je 10e806 <_User_extensions_Thread_begin+0x2e><== NEVER TAKEN
10e7ef: 90 nop
!_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 )
10e7f0: 8b 43 28 mov 0x28(%ebx),%eax
10e7f3: 85 c0 test %eax,%eax
10e7f5: 74 05 je 10e7fc <_User_extensions_Thread_begin+0x24>
(*the_extension->Callouts.thread_begin)( executing );
10e7f7: 89 34 24 mov %esi,(%esp)
10e7fa: ff d0 call *%eax
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 ) {
10e7fc: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e7fe: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx
10e804: 75 ea jne 10e7f0 <_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 );
}
}
10e806: 83 c4 14 add $0x14,%esp
10e809: 5b pop %ebx
10e80a: 5e pop %esi
10e80b: c3 ret
0010e890 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10e890: 56 push %esi
10e891: 53 push %ebx
10e892: 83 ec 14 sub $0x14,%esp
10e895: 8b 74 24 20 mov 0x20(%esp),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10e899: 8b 1d ec f7 12 00 mov 0x12f7ec,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e89f: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx
10e8a5: 74 25 je 10e8cc <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10e8a7: 90 nop
!_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 ) {
10e8a8: 8b 43 14 mov 0x14(%ebx),%eax
10e8ab: 85 c0 test %eax,%eax
10e8ad: 74 13 je 10e8c2 <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10e8af: 89 74 24 04 mov %esi,0x4(%esp)
10e8b3: 8b 15 6c f8 12 00 mov 0x12f86c,%edx
10e8b9: 89 14 24 mov %edx,(%esp)
10e8bc: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10e8be: 84 c0 test %al,%al
10e8c0: 74 0c je 10e8ce <_User_extensions_Thread_create+0x3e>
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 ) {
10e8c2: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e8c4: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx
10e8ca: 75 dc jne 10e8a8 <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10e8cc: b0 01 mov $0x1,%al
}
10e8ce: 83 c4 14 add $0x14,%esp
10e8d1: 5b pop %ebx
10e8d2: 5e pop %esi
10e8d3: c3 ret
0010e8d4 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10e8d4: 56 push %esi
10e8d5: 53 push %ebx
10e8d6: 83 ec 14 sub $0x14,%esp
10e8d9: 8b 74 24 20 mov 0x20(%esp),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
10e8dd: 8b 1d f4 f7 12 00 mov 0x12f7f4,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e8e3: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx
10e8e9: 74 22 je 10e90d <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10e8eb: 90 nop
!_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 )
10e8ec: 8b 43 20 mov 0x20(%ebx),%eax
10e8ef: 85 c0 test %eax,%eax
10e8f1: 74 0f je 10e902 <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10e8f3: 89 74 24 04 mov %esi,0x4(%esp)
10e8f7: 8b 15 6c f8 12 00 mov 0x12f86c,%edx
10e8fd: 89 14 24 mov %edx,(%esp)
10e900: ff d0 call *%eax
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 ) {
10e902: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e905: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx
10e90b: 75 df jne 10e8ec <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e90d: 83 c4 14 add $0x14,%esp
10e910: 5b pop %ebx
10e911: 5e pop %esi
10e912: c3 ret
0010e80c <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10e80c: 56 push %esi
10e80d: 53 push %ebx
10e80e: 83 ec 14 sub $0x14,%esp
10e811: 8b 74 24 20 mov 0x20(%esp),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
10e815: 8b 1d f4 f7 12 00 mov 0x12f7f4,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e81b: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx
10e821: 74 18 je 10e83b <_User_extensions_Thread_exitted+0x2f><== NEVER TAKEN
10e823: 90 nop
!_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 )
10e824: 8b 43 2c mov 0x2c(%ebx),%eax
10e827: 85 c0 test %eax,%eax
10e829: 74 05 je 10e830 <_User_extensions_Thread_exitted+0x24>
(*the_extension->Callouts.thread_exitted)( executing );
10e82b: 89 34 24 mov %esi,(%esp)
10e82e: ff d0 call *%eax
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 ) {
10e830: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e833: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx
10e839: 75 e9 jne 10e824 <_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 );
}
}
10e83b: 83 c4 14 add $0x14,%esp
10e83e: 5b pop %ebx
10e83f: 5e pop %esi
10e840: c3 ret
0010f114 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10f114: 56 push %esi
10f115: 53 push %ebx
10f116: 83 ec 14 sub $0x14,%esp
10f119: 8b 74 24 20 mov 0x20(%esp),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10f11d: 8b 1d 2c 08 13 00 mov 0x13082c,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f123: 81 fb 30 08 13 00 cmp $0x130830,%ebx
10f129: 74 21 je 10f14c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10f12b: 90 nop
!_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 )
10f12c: 8b 43 1c mov 0x1c(%ebx),%eax
10f12f: 85 c0 test %eax,%eax
10f131: 74 0f je 10f142 <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10f133: 89 74 24 04 mov %esi,0x4(%esp)
10f137: 8b 15 ac 08 13 00 mov 0x1308ac,%edx
10f13d: 89 14 24 mov %edx,(%esp)
10f140: ff d0 call *%eax
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 ) {
10f142: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f144: 81 fb 30 08 13 00 cmp $0x130830,%ebx
10f14a: 75 e0 jne 10f12c <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f14c: 83 c4 14 add $0x14,%esp
10f14f: 5b pop %ebx
10f150: 5e pop %esi
10f151: c3 ret
0010e914 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10e914: 56 push %esi
10e915: 53 push %ebx
10e916: 83 ec 14 sub $0x14,%esp
10e919: 8b 74 24 20 mov 0x20(%esp),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10e91d: 8b 1d ec f7 12 00 mov 0x12f7ec,%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e923: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx
10e929: 74 21 je 10e94c <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10e92b: 90 nop
!_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 )
10e92c: 8b 43 18 mov 0x18(%ebx),%eax
10e92f: 85 c0 test %eax,%eax
10e931: 74 0f je 10e942 <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10e933: 89 74 24 04 mov %esi,0x4(%esp)
10e937: 8b 15 6c f8 12 00 mov 0x12f86c,%edx
10e93d: 89 14 24 mov %edx,(%esp)
10e940: ff d0 call *%eax
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 ) {
10e942: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e944: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx
10e94a: 75 e0 jne 10e92c <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e94c: 83 c4 14 add $0x14,%esp
10e94f: 5b pop %ebx
10e950: 5e pop %esi
10e951: c3 ret
0010e954 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10e954: 57 push %edi
10e955: 56 push %esi
10e956: 53 push %ebx
10e957: 83 ec 10 sub $0x10,%esp
10e95a: 8b 7c 24 20 mov 0x20(%esp),%edi
10e95e: 8b 74 24 24 mov 0x24(%esp),%esi
10e962: 8b 1d 08 f6 12 00 mov 0x12f608,%ebx
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e968: 81 fb 0c f6 12 00 cmp $0x12f60c,%ebx
10e96e: 74 14 je 10e984 <_User_extensions_Thread_switch+0x30><== NEVER TAKEN
!_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 );
10e970: 89 74 24 04 mov %esi,0x4(%esp)
10e974: 89 3c 24 mov %edi,(%esp)
10e977: 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 ) {
10e97a: 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 );
10e97c: 81 fb 0c f6 12 00 cmp $0x12f60c,%ebx
10e982: 75 ec jne 10e970 <_User_extensions_Thread_switch+0x1c>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e984: 83 c4 10 add $0x10,%esp
10e987: 5b pop %ebx
10e988: 5e pop %esi
10e989: 5f pop %edi
10e98a: c3 ret
001100d8 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
1100d8: 57 push %edi
1100d9: 56 push %esi
1100da: 53 push %ebx
1100db: 83 ec 10 sub $0x10,%esp
1100de: 8b 74 24 20 mov 0x20(%esp),%esi
1100e2: 8b 4c 24 24 mov 0x24(%esp),%ecx
1100e6: 8b 5c 24 28 mov 0x28(%esp),%ebx
ISR_Level level;
_ISR_Disable( level );
1100ea: 9c pushf
1100eb: fa cli
1100ec: 5a pop %edx
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
1100ed: 8b 06 mov (%esi),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
1100ef: 8d 7e 04 lea 0x4(%esi),%edi
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
1100f2: 39 f8 cmp %edi,%eax
1100f4: 74 39 je 11012f <_Watchdog_Adjust+0x57>
switch ( direction ) {
1100f6: 85 c9 test %ecx,%ecx
1100f8: 75 3e jne 110138 <_Watchdog_Adjust+0x60>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
1100fa: 85 db test %ebx,%ebx
1100fc: 74 31 je 11012f <_Watchdog_Adjust+0x57> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
1100fe: 8b 48 10 mov 0x10(%eax),%ecx
110101: 39 cb cmp %ecx,%ebx
110103: 73 0e jae 110113 <_Watchdog_Adjust+0x3b> <== ALWAYS TAKEN
110105: eb 39 jmp 110140 <_Watchdog_Adjust+0x68> <== NOT EXECUTED
110107: 90 nop <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
110108: 85 db test %ebx,%ebx
11010a: 74 23 je 11012f <_Watchdog_Adjust+0x57> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
11010c: 8b 48 10 mov 0x10(%eax),%ecx
11010f: 39 d9 cmp %ebx,%ecx
110111: 77 2d ja 110140 <_Watchdog_Adjust+0x68>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
110113: 29 cb sub %ecx,%ebx
_Watchdog_First( header )->delta_interval = 1;
110115: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax)
_ISR_Enable( level );
11011c: 52 push %edx
11011d: 9d popf
_Watchdog_Tickle( header );
11011e: 89 34 24 mov %esi,(%esp)
110121: e8 aa 01 00 00 call 1102d0 <_Watchdog_Tickle>
_ISR_Disable( level );
110126: 9c pushf
110127: fa cli
110128: 5a pop %edx
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
110129: 8b 06 mov (%esi),%eax
if ( _Chain_Is_empty( header ) )
11012b: 39 c7 cmp %eax,%edi
11012d: 75 d9 jne 110108 <_Watchdog_Adjust+0x30>
}
break;
}
}
_ISR_Enable( level );
11012f: 52 push %edx
110130: 9d popf
}
110131: 83 c4 10 add $0x10,%esp
110134: 5b pop %ebx
110135: 5e pop %esi
110136: 5f pop %edi
110137: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
110138: 49 dec %ecx
110139: 75 f4 jne 11012f <_Watchdog_Adjust+0x57> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
11013b: 01 58 10 add %ebx,0x10(%eax)
break;
11013e: eb ef jmp 11012f <_Watchdog_Adjust+0x57>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
110140: 29 d9 sub %ebx,%ecx
110142: 89 48 10 mov %ecx,0x10(%eax)
break;
110145: eb e8 jmp 11012f <_Watchdog_Adjust+0x57>
0010eaa8 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10eaa8: 56 push %esi
10eaa9: 53 push %ebx
10eaaa: 8b 54 24 0c mov 0xc(%esp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10eaae: 9c pushf
10eaaf: fa cli
10eab0: 59 pop %ecx
previous_state = the_watchdog->state;
10eab1: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10eab4: 83 f8 01 cmp $0x1,%eax
10eab7: 74 4f je 10eb08 <_Watchdog_Remove+0x60>
10eab9: 73 11 jae 10eacc <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10eabb: 8b 1d 04 f7 12 00 mov 0x12f704,%ebx
10eac1: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10eac4: 51 push %ecx
10eac5: 9d popf
return( previous_state );
}
10eac6: 5b pop %ebx
10eac7: 5e pop %esi
10eac8: c3 ret
10eac9: 8d 76 00 lea 0x0(%esi),%esi
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10eacc: 83 f8 03 cmp $0x3,%eax
10eacf: 77 ea ja 10eabb <_Watchdog_Remove+0x13> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10ead1: 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 );
}
10ead8: 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) )
10eada: 8b 33 mov (%ebx),%esi
10eadc: 85 f6 test %esi,%esi
10eade: 74 06 je 10eae6 <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10eae0: 8b 72 10 mov 0x10(%edx),%esi
10eae3: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10eae6: 8b 35 00 f7 12 00 mov 0x12f700,%esi
10eaec: 85 f6 test %esi,%esi
10eaee: 74 0c je 10eafc <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10eaf0: 8b 35 68 f8 12 00 mov 0x12f868,%esi
10eaf6: 89 35 94 f6 12 00 mov %esi,0x12f694
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10eafc: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10eaff: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10eb02: 89 1e mov %ebx,(%esi)
10eb04: eb b5 jmp 10eabb <_Watchdog_Remove+0x13>
10eb06: 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;
10eb08: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10eb0f: eb aa jmp 10eabb <_Watchdog_Remove+0x13>
0010fab4 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10fab4: 55 push %ebp
10fab5: 57 push %edi
10fab6: 56 push %esi
10fab7: 53 push %ebx
10fab8: 83 ec 1c sub $0x1c,%esp
10fabb: 8b 7c 24 30 mov 0x30(%esp),%edi
10fabf: 8b 74 24 34 mov 0x34(%esp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10fac3: 9c pushf
10fac4: fa cli
10fac5: 5d pop %ebp
printk( "Watchdog Chain: %s %p\n", name, header );
10fac6: 89 74 24 08 mov %esi,0x8(%esp)
10faca: 89 7c 24 04 mov %edi,0x4(%esp)
10face: c7 04 24 2b 33 12 00 movl $0x12332b,(%esp)
10fad5: e8 3e 96 ff ff call 109118 <printk>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
10fada: 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 );
10fadc: 83 c6 04 add $0x4,%esi
if ( !_Chain_Is_empty( header ) ) {
10fadf: 39 f3 cmp %esi,%ebx
10fae1: 74 31 je 10fb14 <_Watchdog_Report_chain+0x60>
10fae3: 90 nop
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10fae4: 89 5c 24 04 mov %ebx,0x4(%esp)
10fae8: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10faef: e8 30 00 00 00 call 10fb24 <_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 )
10faf4: 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 ) ;
10faf6: 39 f3 cmp %esi,%ebx
10faf8: 75 ea jne 10fae4 <_Watchdog_Report_chain+0x30><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10fafa: 89 7c 24 04 mov %edi,0x4(%esp)
10fafe: c7 04 24 42 33 12 00 movl $0x123342,(%esp)
10fb05: e8 0e 96 ff ff call 109118 <printk>
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10fb0a: 55 push %ebp
10fb0b: 9d popf
}
10fb0c: 83 c4 1c add $0x1c,%esp
10fb0f: 5b pop %ebx
10fb10: 5e pop %esi
10fb11: 5f pop %edi
10fb12: 5d pop %ebp
10fb13: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10fb14: c7 04 24 51 33 12 00 movl $0x123351,(%esp)
10fb1b: e8 f8 95 ff ff call 109118 <printk>
10fb20: eb e8 jmp 10fb0a <_Watchdog_Report_chain+0x56>
0010eb14 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10eb14: 55 push %ebp
10eb15: 57 push %edi
10eb16: 56 push %esi
10eb17: 53 push %ebx
10eb18: 83 ec 1c sub $0x1c,%esp
10eb1b: 8b 7c 24 30 mov 0x30(%esp),%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 );
10eb1f: 9c pushf
10eb20: fa cli
10eb21: 5e pop %esi
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
10eb22: 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 );
10eb24: 8d 6f 04 lea 0x4(%edi),%ebp
if ( _Chain_Is_empty( header ) )
10eb27: 39 eb cmp %ebp,%ebx
10eb29: 74 11 je 10eb3c <_Watchdog_Tickle+0x28>
* 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) {
10eb2b: 8b 43 10 mov 0x10(%ebx),%eax
10eb2e: 85 c0 test %eax,%eax
10eb30: 74 34 je 10eb66 <_Watchdog_Tickle+0x52>
the_watchdog->delta_interval--;
10eb32: 48 dec %eax
10eb33: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10eb36: 85 c0 test %eax,%eax
10eb38: 74 2c je 10eb66 <_Watchdog_Tickle+0x52>
10eb3a: 66 90 xchg %ax,%ax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10eb3c: 56 push %esi
10eb3d: 9d popf
}
10eb3e: 83 c4 1c add $0x1c,%esp
10eb41: 5b pop %ebx
10eb42: 5e pop %esi
10eb43: 5f pop %edi
10eb44: 5d pop %ebp
10eb45: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10eb46: 8b 43 24 mov 0x24(%ebx),%eax
10eb49: 89 44 24 04 mov %eax,0x4(%esp)
10eb4d: 8b 43 20 mov 0x20(%ebx),%eax
10eb50: 89 04 24 mov %eax,(%esp)
10eb53: ff 53 1c call *0x1c(%ebx)
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10eb56: 9c pushf
10eb57: fa cli
10eb58: 5e pop %esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10eb59: 8b 1f mov (%edi),%ebx
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10eb5b: 39 dd cmp %ebx,%ebp
10eb5d: 74 dd je 10eb3c <_Watchdog_Tickle+0x28>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10eb5f: 8b 43 10 mov 0x10(%ebx),%eax
10eb62: 85 c0 test %eax,%eax
10eb64: 75 d6 jne 10eb3c <_Watchdog_Tickle+0x28>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10eb66: 89 1c 24 mov %ebx,(%esp)
10eb69: e8 3a ff ff ff call 10eaa8 <_Watchdog_Remove>
_ISR_Enable( level );
10eb6e: 56 push %esi
10eb6f: 9d popf
switch( watchdog_state ) {
10eb70: 83 f8 02 cmp $0x2,%eax
10eb73: 75 e1 jne 10eb56 <_Watchdog_Tickle+0x42> <== NEVER TAKEN
10eb75: eb cf jmp 10eb46 <_Watchdog_Tickle+0x32>
0010eb78 <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10eb78: 57 push %edi
10eb79: 53 push %ebx
10eb7a: 83 ec 14 sub $0x14,%esp
uintptr_t memory_available = 0;
void *starting_address = rtems_configuration_get_work_space_start();
10eb7d: 8b 15 60 b1 12 00 mov 0x12b160,%edx
uintptr_t size = rtems_configuration_get_work_space_size();
10eb83: a1 64 b1 12 00 mov 0x12b164,%eax
10eb88: 80 3d 96 b1 12 00 00 cmpb $0x0,0x12b196
10eb8f: 75 37 jne 10ebc8 <_Workspace_Handler_initialization+0x50>
10eb91: 8b 1d 68 b1 12 00 mov 0x12b168,%ebx
10eb97: 01 c3 add %eax,%ebx
if ( rtems_configuration_get_do_zero_of_workspace() )
10eb99: 80 3d 94 b1 12 00 00 cmpb $0x0,0x12b194
10eba0: 75 33 jne 10ebd5 <_Workspace_Handler_initialization+0x5d>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10eba2: c7 44 24 0c 04 00 00 movl $0x4,0xc(%esp)
10eba9: 00
10ebaa: 89 5c 24 08 mov %ebx,0x8(%esp)
10ebae: 89 54 24 04 mov %edx,0x4(%esp)
10ebb2: c7 04 24 20 f6 12 00 movl $0x12f620,(%esp)
10ebb9: e8 fa dd ff ff call 10c9b8 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10ebbe: 85 c0 test %eax,%eax
10ebc0: 74 1d je 10ebdf <_Workspace_Handler_initialization+0x67>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10ebc2: 83 c4 14 add $0x14,%esp
10ebc5: 5b pop %ebx
10ebc6: 5f pop %edi
10ebc7: c3 ret
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = rtems_configuration_get_work_space_start();
uintptr_t size = rtems_configuration_get_work_space_size();
10ebc8: 31 db xor %ebx,%ebx
10ebca: 01 c3 add %eax,%ebx
if ( rtems_configuration_get_do_zero_of_workspace() )
10ebcc: 80 3d 94 b1 12 00 00 cmpb $0x0,0x12b194
10ebd3: 74 cd je 10eba2 <_Workspace_Handler_initialization+0x2a><== ALWAYS TAKEN
memset( starting_address, 0, size );
10ebd5: 31 c0 xor %eax,%eax
10ebd7: 89 d7 mov %edx,%edi
10ebd9: 89 d9 mov %ebx,%ecx
10ebdb: f3 aa rep stos %al,%es:(%edi)
10ebdd: eb c3 jmp 10eba2 <_Workspace_Handler_initialization+0x2a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10ebdf: c7 44 24 08 02 00 00 movl $0x2,0x8(%esp)
10ebe6: 00
10ebe7: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10ebee: 00
10ebef: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ebf6: e8 c5 df ff ff call 10cbc0 <_Internal_error_Occurred>
0010eea4 <_Workspace_String_duplicate>:
char *_Workspace_String_duplicate(
const char *string,
size_t len
)
{
10eea4: 57 push %edi
10eea5: 56 push %esi
10eea6: 53 push %ebx
10eea7: 83 ec 10 sub $0x10,%esp
10eeaa: 8b 5c 24 24 mov 0x24(%esp),%ebx
char *dup = _Workspace_Allocate(len + 1);
10eeae: 8d 43 01 lea 0x1(%ebx),%eax
10eeb1: 89 04 24 mov %eax,(%esp)
10eeb4: e8 57 ff ff ff call 10ee10 <_Workspace_Allocate>
if (dup != NULL) {
10eeb9: 85 c0 test %eax,%eax
10eebb: 74 0e je 10eecb <_Workspace_String_duplicate+0x27><== NEVER TAKEN
dup [len] = '\0';
10eebd: c6 04 18 00 movb $0x0,(%eax,%ebx,1)
memcpy(dup, string, len);
10eec1: 89 c7 mov %eax,%edi
10eec3: 8b 74 24 20 mov 0x20(%esp),%esi
10eec7: 89 d9 mov %ebx,%ecx
10eec9: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
return dup;
}
10eecb: 83 c4 10 add $0x10,%esp
10eece: 5b pop %ebx
10eecf: 5e pop %esi
10eed0: 5f pop %edi
10eed1: c3 ret
0011f588 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
11f588: 31 c0 xor %eax,%eax <== NOT EXECUTED
11f58a: c3 ret <== NOT EXECUTED
00107a74 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
107a74: e9 43 ff ff ff jmp 1079bc <gettimeofday> <== NOT EXECUTED
0010582c <_lstat_r>:
int _STAT_R_NAME(
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
10582c: 8b 44 24 08 mov 0x8(%esp),%eax <== NOT EXECUTED
return _STAT_NAME( path, buf );
105830: 8b 54 24 0c mov 0xc(%esp),%edx <== NOT EXECUTED
105834: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
105838: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10583c: e9 93 ff ff ff jmp 1057d4 <lstat> <== NOT EXECUTED
001089f4 <_stat_r>:
int _STAT_R_NAME(
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
1089f4: 8b 44 24 08 mov 0x8(%esp),%eax <== NOT EXECUTED
return _STAT_NAME( path, buf );
1089f8: 8b 54 24 0c mov 0xc(%esp),%edx <== NOT EXECUTED
1089fc: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
108a00: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
108a04: e9 93 ff ff ff jmp 10899c <stat> <== NOT EXECUTED
0010c844 <check_and_merge>:
rtems_chain_control *free_chain,
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
10c844: 57 push %edi
10c845: 56 push %esi
10c846: 53 push %ebx
10c847: 83 ec 10 sub $0x10,%esp
10c84a: 8b 5c 24 20 mov 0x20(%esp),%ebx
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
10c84e: 83 fb f8 cmp $0xfffffff8,%ebx
10c851: 74 37 je 10c88a <check_and_merge+0x46>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
10c853: 8b 33 mov (%ebx),%esi
10c855: 85 f6 test %esi,%esi
10c857: 74 47 je 10c8a0 <check_and_merge+0x5c>
if (b->begin < a->begin) {
10c859: 8b 79 18 mov 0x18(%ecx),%edi
10c85c: 39 7b 18 cmp %edi,0x18(%ebx)
10c85f: 72 33 jb 10c894 <check_and_merge+0x50>
a = b;
b = t;
}
a->size += b->size;
10c861: 8b 7b 1c mov 0x1c(%ebx),%edi
10c864: 01 79 1c add %edi,0x1c(%ecx)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10c867: 8b 4b 04 mov 0x4(%ebx),%ecx
next->previous = previous;
10c86a: 89 4e 04 mov %ecx,0x4(%esi)
previous->next = next;
10c86d: 89 31 mov %esi,(%ecx)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10c86f: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10c872: 8b 08 mov (%eax),%ecx
after_node->next = the_node;
10c874: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10c876: 89 0b mov %ecx,(%ebx)
before_node->previous = the_node;
10c878: 89 59 04 mov %ebx,0x4(%ecx)
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
10c87b: 83 c3 08 add $0x8,%ebx
10c87e: 89 5c 24 04 mov %ebx,0x4(%esp)
10c882: 89 14 24 mov %edx,(%esp)
10c885: e8 72 18 00 00 call 10e0fc <_RBTree_Extract_unprotected>
}
}
10c88a: 83 c4 10 add $0x10,%esp
10c88d: 5b pop %ebx
10c88e: 5e pop %esi
10c88f: 5f pop %edi
10c890: c3 ret
10c891: 8d 76 00 lea 0x0(%esi),%esi
10c894: 8b 31 mov (%ecx),%esi
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
if (b->begin < a->begin) {
10c896: 89 cf mov %ecx,%edi
10c898: 89 d9 mov %ebx,%ecx
10c89a: 89 fb mov %edi,%ebx
10c89c: eb c3 jmp 10c861 <check_and_merge+0x1d>
10c89e: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
10c8a0: 8b 7b 04 mov 0x4(%ebx),%edi
10c8a3: 85 ff test %edi,%edi
10c8a5: 75 b2 jne 10c859 <check_and_merge+0x15> <== NEVER TAKEN
10c8a7: eb e1 jmp 10c88a <check_and_merge+0x46>
00105470 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
105470: 56 push %esi
105471: 53 push %ebx
105472: 81 ec 84 00 00 00 sub $0x84,%esp
/*
* We use the global environment for path evaluation. This makes it possible
* to escape from a chroot environment referencing an unmounted file system.
*/
rtems_filesystem_eval_path_start_with_root_and_current(
105478: c7 44 24 10 c0 9d 12 movl $0x129dc0,0x10(%esp)
10547f: 00
105480: c7 44 24 0c c4 9d 12 movl $0x129dc4,0xc(%esp)
105487: 00
105488: c7 44 24 08 19 00 00 movl $0x19,0x8(%esp)
10548f: 00
105490: 8b 84 24 90 00 00 00 mov 0x90(%esp),%eax
105497: 89 44 24 04 mov %eax,0x4(%esp)
10549b: 8d 74 24 48 lea 0x48(%esp),%esi
10549f: 89 34 24 mov %esi,(%esp)
1054a2: e8 e5 13 00 00 call 10688c <rtems_filesystem_eval_path_start_with_root_and_current>
1054a7: 8d 44 24 60 lea 0x60(%esp),%eax
1054ab: 89 44 24 04 mov %eax,0x4(%esp)
eval_flags,
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
1054af: 8d 5c 24 30 lea 0x30(%esp),%ebx
1054b3: 89 1c 24 mov %ebx,(%esp)
1054b6: e8 f5 17 00 00 call 106cb0 <rtems_filesystem_location_copy_and_detach>
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
1054bb: 89 1c 24 mov %ebx,(%esp)
1054be: e8 89 19 00 00 call 106e4c <rtems_filesystem_location_transform_to_global>
1054c3: 89 44 24 2c mov %eax,0x2c(%esp)
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
1054c7: 81 78 10 00 ef 11 00 cmpl $0x11ef00,0x10(%eax)
1054ce: 74 3a je 10550a <chroot+0x9a>
rtems_filesystem_global_location_t *new_root_loc =
rtems_filesystem_global_location_obtain( &new_current_loc );
1054d0: 8d 44 24 2c lea 0x2c(%esp),%eax
1054d4: 89 04 24 mov %eax,(%esp)
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
rtems_filesystem_global_location_t *new_root_loc =
1054d7: e8 e8 18 00 00 call 106dc4 <rtems_filesystem_global_location_obtain>
1054dc: 89 c3 mov %eax,%ebx
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
(*new_root_loc->location.mt_entry->ops->node_type_h)(
1054de: 8b 40 14 mov 0x14(%eax),%eax
1054e1: 8b 40 0c mov 0xc(%eax),%eax
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
rtems_filesystem_global_location_t *new_root_loc =
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
1054e4: 89 1c 24 mov %ebx,(%esp)
1054e7: ff 50 14 call *0x14(%eax)
(*new_root_loc->location.mt_entry->ops->node_type_h)(
&new_root_loc->location
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
1054ea: 85 c0 test %eax,%eax
1054ec: 74 3e je 10552c <chroot+0xbc>
static inline void rtems_filesystem_location_error(
const rtems_filesystem_location_info_t *loc,
int eno
)
{
if ( !rtems_filesystem_location_is_null( loc ) ) {
1054ee: 81 7b 10 00 ef 11 00 cmpl $0x11ef00,0x10(%ebx)
1054f5: 74 0b je 105502 <chroot+0x92> <== NEVER TAKEN
errno = eno;
1054f7: e8 c0 6d 00 00 call 10c2bc <__errno>
1054fc: c7 00 14 00 00 00 movl $0x14,(%eax)
rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
rv = -1;
}
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
105502: 89 1c 24 mov %ebx,(%esp)
105505: e8 62 18 00 00 call 106d6c <rtems_filesystem_global_location_release>
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
10550a: 89 34 24 mov %esi,(%esp)
10550d: e8 a2 14 00 00 call 1069b4 <rtems_filesystem_eval_path_cleanup>
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
105512: 8b 44 24 2c mov 0x2c(%esp),%eax
105516: 89 04 24 mov %eax,(%esp)
105519: e8 4e 18 00 00 call 106d6c <rtems_filesystem_global_location_release>
10551e: b8 ff ff ff ff mov $0xffffffff,%eax
}
return rv;
}
105523: 81 c4 84 00 00 00 add $0x84,%esp
105529: 5b pop %ebx
10552a: 5e pop %esi
10552b: c3 ret
(*new_root_loc->location.mt_entry->ops->node_type_h)(
&new_root_loc->location
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
sc = rtems_libio_set_private_env();
10552c: e8 f3 0c 00 00 call 106224 <rtems_libio_set_private_env>
if (sc == RTEMS_SUCCESSFUL) {
105531: 85 c0 test %eax,%eax
105533: 74 13 je 105548 <chroot+0xd8>
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
105535: 83 f8 0d cmp $0xd,%eax
105538: 74 c8 je 105502 <chroot+0x92> <== NEVER TAKEN
errno = ENOMEM;
10553a: e8 7d 6d 00 00 call 10c2bc <__errno>
10553f: c7 00 0c 00 00 00 movl $0xc,(%eax)
105545: eb bb jmp 105502 <chroot+0x92>
105547: 90 nop
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
sc = rtems_libio_set_private_env();
if (sc == RTEMS_SUCCESSFUL) {
rtems_filesystem_global_location_assign(
105548: 89 5c 24 04 mov %ebx,0x4(%esp)
10554c: a1 a0 9d 12 00 mov 0x129da0,%eax
105551: 83 c0 04 add $0x4,%eax
105554: 89 04 24 mov %eax,(%esp)
105557: e8 4c 18 00 00 call 106da8 <rtems_filesystem_global_location_assign>
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
10555c: 8b 44 24 2c mov 0x2c(%esp),%eax
105560: 89 44 24 04 mov %eax,0x4(%esp)
105564: a1 a0 9d 12 00 mov 0x129da0,%eax
105569: 89 04 24 mov %eax,(%esp)
10556c: e8 37 18 00 00 call 106da8 <rtems_filesystem_global_location_assign>
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
105571: 89 34 24 mov %esi,(%esp)
105574: e8 3b 14 00 00 call 1069b4 <rtems_filesystem_eval_path_cleanup>
105579: 31 c0 xor %eax,%eax
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
}
return rv;
}
10557b: 81 c4 84 00 00 00 add $0x84,%esp
105581: 5b pop %ebx
105582: 5e pop %esi
105583: c3 ret
001095cc <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
1095cc: 53 push %ebx
1095cd: 83 ec 18 sub $0x18,%esp
1095d0: 89 c3 mov %eax,%ebx
1095d2: eb 2e jmp 109602 <drainOutput.part.0+0x36>
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
1095d4: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1095db: 00 00 00
rtems_interrupt_enable (level);
1095de: 50 push %eax
1095df: 9d popf
sc = rtems_semaphore_obtain(
1095e0: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
1095e7: 00
1095e8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
1095ef: 00
1095f0: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
1095f6: 89 04 24 mov %eax,(%esp)
1095f9: e8 7e 23 00 00 call 10b97c <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1095fe: 85 c0 test %eax,%eax
109600: 75 1a jne 10961c <drainOutput.part.0+0x50><== NEVER TAKEN
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
109602: 9c pushf
109603: fa cli
109604: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
109605: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
10960b: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
109611: 39 d1 cmp %edx,%ecx
109613: 75 bf jne 1095d4 <drainOutput.part.0+0x8>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
109615: 50 push %eax
109616: 9d popf
}
}
109617: 83 c4 18 add $0x18,%esp
10961a: 5b pop %ebx
10961b: c3 ret
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
10961c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10961f: e8 8c 2a 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
00107ef4 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
107ef4: 57 push %edi
107ef5: 56 push %esi
107ef6: 53 push %ebx
107ef7: 83 ec 60 sub $0x60,%esp
107efa: 8b 74 24 70 mov 0x70(%esp),%esi
107efe: 8b 7c 24 74 mov 0x74(%esp),%edi
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
107f02: 8d 5c 24 18 lea 0x18(%esp),%ebx
107f06: 89 5c 24 04 mov %ebx,0x4(%esp)
107f0a: 89 34 24 mov %esi,(%esp)
107f0d: e8 fe 05 00 00 call 108510 <fstat>
if ( status == -1 )
107f12: 40 inc %eax
107f13: 74 2b je 107f40 <dup2+0x4c>
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
107f15: 89 5c 24 04 mov %ebx,0x4(%esp)
107f19: 89 3c 24 mov %edi,(%esp)
107f1c: e8 ef 05 00 00 call 108510 <fstat>
if ( status == -1 )
107f21: 40 inc %eax
107f22: 74 1c je 107f40 <dup2+0x4c> <== NEVER TAKEN
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
107f24: 89 7c 24 08 mov %edi,0x8(%esp)
107f28: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
107f2f: 00
107f30: 89 34 24 mov %esi,(%esp)
107f33: e8 50 02 00 00 call 108188 <fcntl>
}
107f38: 83 c4 60 add $0x60,%esp
107f3b: 5b pop %ebx
107f3c: 5e pop %esi
107f3d: 5f pop %edi
107f3e: c3 ret
107f3f: 90 nop
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
if ( status == -1 )
return -1;
107f40: b8 ff ff ff ff mov $0xffffffff,%eax
107f45: eb f1 jmp 107f38 <dup2+0x44>
0010a2dc <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
10a2dc: 53 push %ebx
10a2dd: 83 ec 38 sub $0x38,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
10a2e0: f6 42 3d 02 testb $0x2,0x3d(%edx)
10a2e4: 74 1a je 10a300 <echo+0x24> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
10a2e6: 0f b6 c8 movzbl %al,%ecx
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
10a2e9: 8b 1d 08 d4 12 00 mov 0x12d408,%ebx
10a2ef: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
10a2f4: 74 0a je 10a300 <echo+0x24>
iscntrl(c) && (c != '\t') && (c != '\n')) {
10a2f6: 3c 09 cmp $0x9,%al
10a2f8: 74 06 je 10a300 <echo+0x24>
10a2fa: 3c 0a cmp $0xa,%al
10a2fc: 75 12 jne 10a310 <echo+0x34>
10a2fe: 66 90 xchg %ax,%ax
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
10a300: 0f b6 c0 movzbl %al,%eax
10a303: e8 88 fe ff ff call 10a190 <oproc>
}
}
10a308: 83 c4 38 add $0x38,%esp
10a30b: 5b pop %ebx
10a30c: c3 ret
10a30d: 8d 76 00 lea 0x0(%esi),%esi
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
10a310: c6 44 24 2e 5e movb $0x5e,0x2e(%esp)
echobuf[1] = c ^ 0x40;
10a315: 83 f0 40 xor $0x40,%eax
10a318: 88 44 24 2f mov %al,0x2f(%esp)
rtems_termios_puts (echobuf, 2, tty);
10a31c: 89 54 24 08 mov %edx,0x8(%esp)
10a320: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
10a327: 00
10a328: 8d 44 24 2e lea 0x2e(%esp),%eax
10a32c: 89 04 24 mov %eax,(%esp)
10a32f: 89 54 24 1c mov %edx,0x1c(%esp)
10a333: e8 14 fd ff ff call 10a04c <rtems_termios_puts>
tty->column += 2;
10a338: 8b 54 24 1c mov 0x1c(%esp),%edx
10a33c: 83 42 28 02 addl $0x2,0x28(%edx)
} else {
oproc (c, tty);
}
}
10a340: 83 c4 38 add $0x38,%esp
10a343: 5b pop %ebx
10a344: c3 ret
0012957c <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
12957c: a1 28 ab 17 00 mov 0x17ab28,%eax
129581: 85 c0 test %eax,%eax
129583: 74 0e je 129593 <endgrent+0x17> <== NEVER TAKEN
fclose(group_fp);
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
129585: 83 ec 1c sub $0x1c,%esp
if (group_fp != NULL)
fclose(group_fp);
129588: 89 04 24 mov %eax,(%esp)
12958b: e8 64 1e 01 00 call 13b3f4 <fclose>
}
129590: 83 c4 1c add $0x1c,%esp
129593: c3 ret
00129410 <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
129410: a1 48 aa 17 00 mov 0x17aa48,%eax
129415: 85 c0 test %eax,%eax
129417: 74 0e je 129427 <endpwent+0x17> <== NEVER TAKEN
fclose(passwd_fp);
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
129419: 83 ec 1c sub $0x1c,%esp
if (passwd_fp != NULL)
fclose(passwd_fp);
12941c: 89 04 24 mov %eax,(%esp)
12941f: e8 d0 1f 01 00 call 13b3f4 <fclose>
}
129424: 83 c4 1c add $0x1c,%esp
129427: c3 ret
0010a348 <erase.part.2>:
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
10a348: 55 push %ebp
10a349: 57 push %edi
10a34a: 56 push %esi
10a34b: 53 push %ebx
10a34c: 83 ec 2c sub $0x2c,%esp
10a34f: 89 c5 mov %eax,%ebp
10a351: 89 d7 mov %edx,%edi
10a353: eb 13 jmp 10a368 <erase.part.2+0x20>
10a355: 8d 76 00 lea 0x0(%esi),%esi
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
10a358: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
10a35b: 0f 85 0f 01 00 00 jne 10a470 <erase.part.2+0x128> <== NOT EXECUTED
10a361: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
10a364: 85 ff test %edi,%edi
10a366: 74 60 je 10a3c8 <erase.part.2+0x80> <== NEVER TAKEN
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
10a368: 8b 4d 20 mov 0x20(%ebp),%ecx
10a36b: 85 c9 test %ecx,%ecx
10a36d: 74 59 je 10a3c8 <erase.part.2+0x80>
unsigned char c = tty->cbuf[--tty->ccount];
10a36f: 8b 75 1c mov 0x1c(%ebp),%esi
10a372: 49 dec %ecx
10a373: 89 4d 20 mov %ecx,0x20(%ebp)
10a376: 0f b6 04 0e movzbl (%esi,%ecx,1),%eax
if (tty->termios.c_lflag & ECHO) {
10a37a: 8b 55 3c mov 0x3c(%ebp),%edx
10a37d: f6 c2 08 test $0x8,%dl
10a380: 74 e2 je 10a364 <erase.part.2+0x1c> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
10a382: 85 ff test %edi,%edi
10a384: 75 09 jne 10a38f <erase.part.2+0x47>
10a386: f6 c2 10 test $0x10,%dl
10a389: 0f 84 cd 00 00 00 je 10a45c <erase.part.2+0x114> <== NEVER TAKEN
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
10a38f: 3c 09 cmp $0x9,%al
10a391: 74 3d je 10a3d0 <erase.part.2+0x88>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
10a393: 8d 58 01 lea 0x1(%eax),%ebx
10a396: a1 08 d4 12 00 mov 0x12d408,%eax
10a39b: f6 04 18 20 testb $0x20,(%eax,%ebx,1)
10a39f: 75 b7 jne 10a358 <erase.part.2+0x10> <== NEVER TAKEN
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
10a3a1: 89 6c 24 08 mov %ebp,0x8(%esp)
10a3a5: c7 44 24 04 03 00 00 movl $0x3,0x4(%esp)
10a3ac: 00
10a3ad: c7 04 24 5e 16 12 00 movl $0x12165e,(%esp)
10a3b4: e8 93 fc ff ff call 10a04c <rtems_termios_puts>
if (tty->column)
10a3b9: 8b 45 28 mov 0x28(%ebp),%eax
10a3bc: 85 c0 test %eax,%eax
10a3be: 74 a4 je 10a364 <erase.part.2+0x1c> <== NEVER TAKEN
tty->column--;
10a3c0: 48 dec %eax
10a3c1: 89 45 28 mov %eax,0x28(%ebp)
}
}
}
if (!lineFlag)
10a3c4: 85 ff test %edi,%edi
10a3c6: 75 a0 jne 10a368 <erase.part.2+0x20>
break;
}
}
10a3c8: 83 c4 2c add $0x2c,%esp
10a3cb: 5b pop %ebx
10a3cc: 5e pop %esi
10a3cd: 5f pop %edi
10a3ce: 5d pop %ebp
10a3cf: c3 ret
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
10a3d0: 8b 5d 2c mov 0x2c(%ebp),%ebx
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10a3d3: 85 c9 test %ecx,%ecx
10a3d5: 74 4a je 10a421 <erase.part.2+0xd9>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
10a3d7: a1 08 d4 12 00 mov 0x12d408,%eax
10a3dc: 89 44 24 18 mov %eax,0x18(%esp)
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
int i = 0;
10a3e0: 31 c0 xor %eax,%eax
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
10a3e2: 81 e2 00 02 00 00 and $0x200,%edx
10a3e8: 89 54 24 14 mov %edx,0x14(%esp)
10a3ec: 89 6c 24 1c mov %ebp,0x1c(%esp)
10a3f0: 8b 6c 24 18 mov 0x18(%esp),%ebp
10a3f4: eb 11 jmp 10a407 <erase.part.2+0xbf>
10a3f6: 66 90 xchg %ax,%ax
10a3f8: 8b 54 24 14 mov 0x14(%esp),%edx <== NOT EXECUTED
10a3fc: 85 d2 test %edx,%edx <== NOT EXECUTED
10a3fe: 74 03 je 10a403 <erase.part.2+0xbb> <== NOT EXECUTED
col += 2;
10a400: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10a403: 39 c1 cmp %eax,%ecx
10a405: 74 16 je 10a41d <erase.part.2+0xd5> <== NEVER TAKEN
c = tty->cbuf[i++];
10a407: 0f b6 14 06 movzbl (%esi,%eax,1),%edx
10a40b: 40 inc %eax
if (c == '\t') {
10a40c: 80 fa 09 cmp $0x9,%dl
10a40f: 74 43 je 10a454 <erase.part.2+0x10c>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
10a411: f6 44 15 01 20 testb $0x20,0x1(%ebp,%edx,1)
10a416: 75 e0 jne 10a3f8 <erase.part.2+0xb0> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
10a418: 43 inc %ebx
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10a419: 39 c1 cmp %eax,%ecx
10a41b: 75 ea jne 10a407 <erase.part.2+0xbf>
10a41d: 8b 6c 24 1c mov 0x1c(%esp),%ebp
}
/*
* Back up over the tab
*/
while (tty->column > col) {
10a421: 39 5d 28 cmp %ebx,0x28(%ebp)
10a424: 0f 8e 3a ff ff ff jle 10a364 <erase.part.2+0x1c> <== NEVER TAKEN
10a42a: 66 90 xchg %ax,%ax
rtems_termios_puts ("\b", 1, tty);
10a42c: 89 6c 24 08 mov %ebp,0x8(%esp)
10a430: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10a437: 00
10a438: c7 04 24 60 16 12 00 movl $0x121660,(%esp)
10a43f: e8 08 fc ff ff call 10a04c <rtems_termios_puts>
tty->column--;
10a444: 8b 45 28 mov 0x28(%ebp),%eax
10a447: 48 dec %eax
10a448: 89 45 28 mov %eax,0x28(%ebp)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
10a44b: 39 d8 cmp %ebx,%eax
10a44d: 7f dd jg 10a42c <erase.part.2+0xe4>
10a44f: e9 10 ff ff ff jmp 10a364 <erase.part.2+0x1c>
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
10a454: 83 cb 07 or $0x7,%ebx
10a457: 43 inc %ebx
10a458: eb a9 jmp 10a403 <erase.part.2+0xbb>
10a45a: 66 90 xchg %ax,%ax
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
10a45c: 0f b6 45 43 movzbl 0x43(%ebp),%eax <== NOT EXECUTED
10a460: 89 ea mov %ebp,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
10a462: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
10a465: 5b pop %ebx <== NOT EXECUTED
10a466: 5e pop %esi <== NOT EXECUTED
10a467: 5f pop %edi <== NOT EXECUTED
10a468: 5d pop %ebp <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
10a469: e9 6e fe ff ff jmp 10a2dc <echo> <== NOT EXECUTED
10a46e: 66 90 xchg %ax,%ax <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
10a470: 89 6c 24 08 mov %ebp,0x8(%esp) <== NOT EXECUTED
10a474: c7 44 24 04 03 00 00 movl $0x3,0x4(%esp) <== NOT EXECUTED
10a47b: 00
10a47c: c7 04 24 5e 16 12 00 movl $0x12165e,(%esp) <== NOT EXECUTED
10a483: e8 c4 fb ff ff call 10a04c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
10a488: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED
10a48b: 85 c0 test %eax,%eax <== NOT EXECUTED
10a48d: 75 21 jne 10a4b0 <erase.part.2+0x168> <== NOT EXECUTED
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
10a48f: a1 08 d4 12 00 mov 0x12d408,%eax <== NOT EXECUTED
10a494: f6 04 18 20 testb $0x20,(%eax,%ebx,1) <== NOT EXECUTED
10a498: 0f 84 03 ff ff ff je 10a3a1 <erase.part.2+0x59> <== NOT EXECUTED
10a49e: f6 45 3d 02 testb $0x2,0x3d(%ebp) <== NOT EXECUTED
10a4a2: 0f 85 f9 fe ff ff jne 10a3a1 <erase.part.2+0x59> <== NOT EXECUTED
10a4a8: e9 b7 fe ff ff jmp 10a364 <erase.part.2+0x1c> <== NOT EXECUTED
10a4ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
10a4b0: 48 dec %eax <== NOT EXECUTED
10a4b1: 89 45 28 mov %eax,0x28(%ebp) <== NOT EXECUTED
10a4b4: eb d9 jmp 10a48f <erase.part.2+0x147> <== NOT EXECUTED
00108bcc <eval_path_start>:
size_t pathlen,
int eval_flags,
rtems_filesystem_global_location_t *const *global_root_ptr,
rtems_filesystem_global_location_t *const *global_current_ptr
)
{
108bcc: 55 push %ebp
108bcd: 57 push %edi
108bce: 56 push %esi
108bcf: 53 push %ebx
108bd0: 83 ec 3c sub $0x3c,%esp
108bd3: 89 c6 mov %eax,%esi
108bd5: 89 cd mov %ecx,%ebp
memset(ctx, 0, sizeof(*ctx));
108bd7: b9 38 00 00 00 mov $0x38,%ecx
108bdc: 31 c0 xor %eax,%eax
108bde: 89 f7 mov %esi,%edi
108be0: f3 aa rep stos %al,%es:(%edi)
ctx->path = path;
108be2: 89 16 mov %edx,(%esi)
ctx->pathlen = pathlen;
108be4: 89 6e 04 mov %ebp,0x4(%esi)
ctx->flags = eval_flags;
108be7: 8b 44 24 50 mov 0x50(%esp),%eax
108beb: 89 46 10 mov %eax,0x10(%esi)
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_global_location_t *const *global_root_ptr,
rtems_filesystem_global_location_t *const *global_current_ptr
)
{
if (ctx->pathlen > 0) {
108bee: 85 ed test %ebp,%ebp
108bf0: 74 36 je 108c28 <eval_path_start+0x5c>
char c = ctx->path [0];
108bf2: 8a 1a mov (%edx),%bl
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
108bf4: 8b 44 24 54 mov 0x54(%esp),%eax
108bf8: 89 04 24 mov %eax,(%esp)
108bfb: e8 9c 05 00 00 call 10919c <rtems_filesystem_global_location_obtain>
108c00: 89 46 30 mov %eax,0x30(%esi)
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
108c03: 80 fb 2f cmp $0x2f,%bl
108c06: 0f 84 8c 00 00 00 je 108c98 <eval_path_start+0xcc>
108c0c: 80 fb 5c cmp $0x5c,%bl
108c0f: 0f 84 83 00 00 00 je 108c98 <eval_path_start+0xcc> <== NEVER TAKEN
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
);
} else {
ctx->startloc = rtems_filesystem_global_location_obtain(
108c15: 8b 44 24 58 mov 0x58(%esp),%eax
108c19: 89 04 24 mov %eax,(%esp)
108c1c: e8 7b 05 00 00 call 10919c <rtems_filesystem_global_location_obtain>
108c21: 89 46 34 mov %eax,0x34(%esi)
108c24: eb 3a jmp 108c60 <eval_path_start+0x94>
108c26: 66 90 xchg %ax,%ax
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
108c28: c7 44 24 2c 00 00 00 movl $0x0,0x2c(%esp)
108c2f: 00
return rtems_filesystem_global_location_obtain( &global_loc );
108c30: 8d 5c 24 2c lea 0x2c(%esp),%ebx
108c34: 89 1c 24 mov %ebx,(%esp)
108c37: e8 60 05 00 00 call 10919c <rtems_filesystem_global_location_obtain>
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
108c3c: 89 46 30 mov %eax,0x30(%esi)
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
108c3f: c7 44 24 2c 00 00 00 movl $0x0,0x2c(%esp)
108c46: 00
return rtems_filesystem_global_location_obtain( &global_loc );
108c47: 89 1c 24 mov %ebx,(%esp)
108c4a: e8 4d 05 00 00 call 10919c <rtems_filesystem_global_location_obtain>
ctx->startloc = rtems_filesystem_global_location_obtain_null();
108c4f: 89 46 34 mov %eax,0x34(%esi)
errno = ENOENT;
108c52: e8 a1 a0 00 00 call 112cf8 <__errno>
108c57: c7 00 02 00 00 00 movl $0x2,(%eax)
108c5d: 8b 46 34 mov 0x34(%esi),%eax
&ctx->startloc,
rtems_filesystem_global_location_obtain(newstartloc_ptr)
);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(&ctx->currentloc, &ctx->startloc->location);
}
108c60: 8b 40 14 mov 0x14(%eax),%eax
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
108c63: 8b 50 0c mov 0xc(%eax),%edx
108c66: 89 04 24 mov %eax,(%esp)
108c69: ff 12 call *(%edx)
set_startloc(ctx, global_root_ptr, global_current_ptr);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(
108c6b: 8d 46 18 lea 0x18(%esi),%eax
108c6e: 8b 56 34 mov 0x34(%esi),%edx
108c71: 89 54 24 04 mov %edx,0x4(%esp)
108c75: 89 04 24 mov %eax,(%esp)
108c78: 89 44 24 1c mov %eax,0x1c(%esp)
108c7c: e8 0b 6f 00 00 call 10fb8c <rtems_filesystem_location_clone>
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
108c81: 89 34 24 mov %esi,(%esp)
108c84: e8 bf fe ff ff call 108b48 <rtems_filesystem_eval_path_continue>
108c89: 8b 44 24 1c mov 0x1c(%esp),%eax
return &ctx->currentloc;
}
108c8d: 83 c4 3c add $0x3c,%esp
108c90: 5b pop %ebx
108c91: 5e pop %esi
108c92: 5f pop %edi
108c93: 5d pop %ebp
108c94: c3 ret
108c95: 8d 76 00 lea 0x0(%esi),%esi
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
108c98: ff 06 incl (%esi)
--ctx->pathlen;
108c9a: ff 4e 04 decl 0x4(%esi)
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
108c9d: 8d 46 30 lea 0x30(%esi),%eax
108ca0: 89 04 24 mov %eax,(%esp)
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
108ca3: e8 f4 04 00 00 call 10919c <rtems_filesystem_global_location_obtain>
108ca8: 89 46 34 mov %eax,0x34(%esi)
108cab: eb b3 jmp 108c60 <eval_path_start+0x94>
00136cc8 <fchdir>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchdir( int fd )
{
136cc8: 56 push %esi
136cc9: 53 push %ebx
136cca: 81 ec 84 00 00 00 sub $0x84,%esp
136cd0: 8b 84 24 90 00 00 00 mov 0x90(%esp),%eax
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
136cd7: c7 44 24 44 00 00 00 movl $0x0,0x44(%esp)
136cde: 00
st.st_uid = 0;
136cdf: 66 c7 44 24 4a 00 00 movw $0x0,0x4a(%esp)
st.st_gid = 0;
136ce6: 66 c7 44 24 4c 00 00 movw $0x0,0x4c(%esp)
rtems_libio_check_fd( fd );
136ced: 3b 05 20 36 17 00 cmp 0x173620,%eax
136cf3: 0f 83 c7 00 00 00 jae 136dc0 <fchdir+0xf8>
iop = rtems_libio_iop( fd );
136cf9: 8d 1c 40 lea (%eax,%eax,2),%ebx
136cfc: c1 e3 04 shl $0x4,%ebx
136cff: 03 1d 34 b0 17 00 add 0x17b034,%ebx
rtems_libio_check_is_open( iop );
136d05: f6 43 0d 01 testb $0x1,0xd(%ebx)
136d09: 0f 84 b1 00 00 00 je 136dc0 <fchdir+0xf8>
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
136d0f: 8b 43 24 mov 0x24(%ebx),%eax
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
136d12: 8b 50 0c mov 0xc(%eax),%edx
136d15: 89 04 24 mov %eax,(%esp)
136d18: ff 12 call *(%edx)
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
136d1a: 8d 73 10 lea 0x10(%ebx),%esi
136d1d: 8b 43 20 mov 0x20(%ebx),%eax
136d20: 8d 54 24 38 lea 0x38(%esp),%edx
136d24: 89 54 24 04 mov %edx,0x4(%esp)
136d28: 89 34 24 mov %esi,(%esp)
136d2b: ff 50 18 call *0x18(%eax)
if ( rv == 0 ) {
136d2e: 85 c0 test %eax,%eax
136d30: 74 1e je 136d50 <fchdir+0x88> <== ALWAYS TAKEN
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
136d32: 8b 53 24 mov 0x24(%ebx),%edx
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->unlock_h)( mt_entry );
136d35: 8b 4a 0c mov 0xc(%edx),%ecx
136d38: 89 14 24 mov %edx,(%esp)
136d3b: 89 44 24 1c mov %eax,0x1c(%esp)
136d3f: ff 51 04 call *0x4(%ecx)
136d42: 8b 44 24 1c mov 0x1c(%esp),%eax
136d46: 81 c4 84 00 00 00 add $0x84,%esp
136d4c: 5b pop %ebx
136d4d: 5e pop %esi
136d4e: c3 ret
136d4f: 90 nop
rtems_libio_check_is_open( iop );
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
if ( rv == 0 ) {
bool access_ok = rtems_filesystem_check_access(
136d50: 0f b7 44 24 4c movzwl 0x4c(%esp),%eax
136d55: 89 44 24 0c mov %eax,0xc(%esp)
136d59: 0f b7 44 24 4a movzwl 0x4a(%esp),%eax
136d5e: 89 44 24 08 mov %eax,0x8(%esp)
136d62: 8b 44 24 44 mov 0x44(%esp),%eax
136d66: 89 44 24 04 mov %eax,0x4(%esp)
136d6a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
136d71: e8 52 b5 fd ff call 1122c8 <rtems_filesystem_check_access>
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
136d76: 84 c0 test %al,%al
136d78: 74 2e je 136da8 <fchdir+0xe0>
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
136d7a: 89 74 24 04 mov %esi,0x4(%esp)
136d7e: 8d 74 24 20 lea 0x20(%esp),%esi
136d82: 89 34 24 mov %esi,(%esp)
136d85: e8 fa af fd ff call 111d84 <rtems_filesystem_location_clone>
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
136d8a: 8b 43 24 mov 0x24(%ebx),%eax
136d8d: 8b 50 0c mov 0xc(%eax),%edx
136d90: 89 04 24 mov %eax,(%esp)
136d93: ff 52 04 call *0x4(%edx)
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
rv = rtems_filesystem_chdir( &loc );
136d96: 89 34 24 mov %esi,(%esp)
136d99: e8 0e 1a ff ff call 1287ac <rtems_filesystem_chdir>
}
return rv;
}
136d9e: 81 c4 84 00 00 00 add $0x84,%esp
136da4: 5b pop %ebx
136da5: 5e pop %esi
136da6: c3 ret
136da7: 90 nop
);
if ( access_ok ) {
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
} else {
errno = EACCES;
136da8: e8 2b 45 00 00 call 13b2d8 <__errno>
136dad: c7 00 0d 00 00 00 movl $0xd,(%eax)
rv = -1;
136db3: b8 ff ff ff ff mov $0xffffffff,%eax
136db8: e9 75 ff ff ff jmp 136d32 <fchdir+0x6a>
136dbd: 8d 76 00 lea 0x0(%esi),%esi
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
136dc0: e8 13 45 00 00 call 13b2d8 <__errno>
136dc5: c7 00 09 00 00 00 movl $0x9,(%eax)
136dcb: b8 ff ff ff ff mov $0xffffffff,%eax
136dd0: e9 71 ff ff ff jmp 136d46 <fchdir+0x7e>
00128aac <fchmod>:
#include <sys/stat.h>
#include <rtems/libio_.h>
int fchmod( int fd, mode_t mode )
{
128aac: 53 push %ebx
128aad: 83 ec 28 sub $0x28,%esp
128ab0: 8b 44 24 30 mov 0x30(%esp),%eax
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
128ab4: 3b 05 20 36 17 00 cmp 0x173620,%eax
128aba: 73 68 jae 128b24 <fchmod+0x78>
iop = rtems_libio_iop( fd );
128abc: 8d 1c 40 lea (%eax,%eax,2),%ebx
128abf: c1 e3 04 shl $0x4,%ebx
128ac2: 03 1d 34 b0 17 00 add 0x17b034,%ebx
rtems_libio_check_is_open(iop);
128ac8: f6 43 0d 01 testb $0x1,0xd(%ebx)
128acc: 74 56 je 128b24 <fchmod+0x78>
if (iop->pathinfo.mt_entry->writeable) {
128ace: 8b 43 24 mov 0x24(%ebx),%eax
128ad1: 80 78 29 00 cmpb $0x0,0x29(%eax)
128ad5: 75 15 jne 128aec <fchmod+0x40> <== ALWAYS TAKEN
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
128ad7: e8 fc 27 01 00 call 13b2d8 <__errno> <== NOT EXECUTED
128adc: c7 00 1e 00 00 00 movl $0x1e,(%eax) <== NOT EXECUTED
rv = -1;
128ae2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
return rv;
}
128ae7: 83 c4 28 add $0x28,%esp
128aea: 5b pop %ebx
128aeb: c3 ret
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
128aec: 8b 50 0c mov 0xc(%eax),%edx
128aef: 89 04 24 mov %eax,(%esp)
128af2: ff 12 call *(%edx)
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
if (iop->pathinfo.mt_entry->writeable) {
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
128af4: 8b 43 24 mov 0x24(%ebx),%eax
128af7: 8b 40 0c mov 0xc(%eax),%eax
128afa: 8b 54 24 34 mov 0x34(%esp),%edx
128afe: 89 54 24 04 mov %edx,0x4(%esp)
128b02: 8d 53 10 lea 0x10(%ebx),%edx
128b05: 89 14 24 mov %edx,(%esp)
128b08: ff 50 20 call *0x20(%eax)
errno = EROFS;
rv = -1;
}
return rv;
}
128b0b: 8b 53 24 mov 0x24(%ebx),%edx
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->unlock_h)( mt_entry );
128b0e: 8b 4a 0c mov 0xc(%edx),%ecx
128b11: 89 14 24 mov %edx,(%esp)
128b14: 89 44 24 1c mov %eax,0x1c(%esp)
128b18: ff 51 04 call *0x4(%ecx)
128b1b: 8b 44 24 1c mov 0x1c(%esp),%eax
128b1f: 83 c4 28 add $0x28,%esp
128b22: 5b pop %ebx
128b23: c3 ret
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
128b24: e8 af 27 01 00 call 13b2d8 <__errno>
128b29: c7 00 09 00 00 00 movl $0x9,(%eax)
128b2f: b8 ff ff ff ff mov $0xffffffff,%eax
128b34: eb b1 jmp 128ae7 <fchmod+0x3b>
00128b38 <fchown>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchown( int fd, uid_t owner, gid_t group )
{
128b38: 57 push %edi
128b39: 56 push %esi
128b3a: 53 push %ebx
128b3b: 83 ec 20 sub $0x20,%esp
128b3e: 8b 44 24 30 mov 0x30(%esp),%eax
128b42: 0f b7 74 24 34 movzwl 0x34(%esp),%esi
128b47: 0f b7 7c 24 38 movzwl 0x38(%esp),%edi
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
128b4c: 3b 05 20 36 17 00 cmp 0x173620,%eax
128b52: 73 70 jae 128bc4 <fchown+0x8c>
iop = rtems_libio_iop( fd );
128b54: 8d 1c 40 lea (%eax,%eax,2),%ebx
128b57: c1 e3 04 shl $0x4,%ebx
128b5a: 03 1d 34 b0 17 00 add 0x17b034,%ebx
rtems_libio_check_is_open(iop);
128b60: f6 43 0d 01 testb $0x1,0xd(%ebx)
128b64: 74 5e je 128bc4 <fchown+0x8c>
if (iop->pathinfo.mt_entry->writeable) {
128b66: 8b 43 24 mov 0x24(%ebx),%eax
128b69: 80 78 29 00 cmpb $0x0,0x29(%eax)
128b6d: 75 19 jne 128b88 <fchown+0x50> <== ALWAYS TAKEN
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
128b6f: e8 64 27 01 00 call 13b2d8 <__errno> <== NOT EXECUTED
128b74: c7 00 1e 00 00 00 movl $0x1e,(%eax) <== NOT EXECUTED
rv = -1;
128b7a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
return rv;
}
128b7f: 83 c4 20 add $0x20,%esp
128b82: 5b pop %ebx
128b83: 5e pop %esi
128b84: 5f pop %edi
128b85: c3 ret
128b86: 66 90 xchg %ax,%ax
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
128b88: 8b 50 0c mov 0xc(%eax),%edx
128b8b: 89 04 24 mov %eax,(%esp)
128b8e: ff 12 call *(%edx)
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
if (iop->pathinfo.mt_entry->writeable) {
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
128b90: 8b 43 24 mov 0x24(%ebx),%eax
128b93: 8b 40 0c mov 0xc(%eax),%eax
128b96: 89 7c 24 08 mov %edi,0x8(%esp)
128b9a: 89 74 24 04 mov %esi,0x4(%esp)
&iop->pathinfo,
128b9e: 8d 53 10 lea 0x10(%ebx),%edx
128ba1: 89 14 24 mov %edx,(%esp)
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
if (iop->pathinfo.mt_entry->writeable) {
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
128ba4: ff 50 24 call *0x24(%eax)
errno = EROFS;
rv = -1;
}
return rv;
}
128ba7: 8b 53 24 mov 0x24(%ebx),%edx
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->unlock_h)( mt_entry );
128baa: 8b 4a 0c mov 0xc(%edx),%ecx
128bad: 89 14 24 mov %edx,(%esp)
128bb0: 89 44 24 1c mov %eax,0x1c(%esp)
128bb4: ff 51 04 call *0x4(%ecx)
128bb7: 8b 44 24 1c mov 0x1c(%esp),%eax
128bbb: 83 c4 20 add $0x20,%esp
128bbe: 5b pop %ebx
128bbf: 5e pop %esi
128bc0: 5f pop %edi
128bc1: c3 ret
128bc2: 66 90 xchg %ax,%ax
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
128bc4: e8 0f 27 01 00 call 13b2d8 <__errno>
128bc9: c7 00 09 00 00 00 movl $0x9,(%eax)
128bcf: b8 ff ff ff ff mov $0xffffffff,%eax
128bd4: eb a9 jmp 128b7f <fchown+0x47>
00132280 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
132280: 55 push %ebp
132281: 57 push %edi
132282: 56 push %esi
132283: 53 push %ebx
132284: 83 ec 2c sub $0x2c,%esp
132287: 8b 44 24 40 mov 0x40(%esp),%eax
13228b: 8b 7c 24 44 mov 0x44(%esp),%edi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
13228f: 3b 05 e0 52 14 00 cmp 0x1452e0,%eax
132295: 0f 83 91 01 00 00 jae 13242c <fcntl+0x1ac> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
13229b: 8d 1c 40 lea (%eax,%eax,2),%ebx
13229e: c1 e3 04 shl $0x4,%ebx
1322a1: 03 1d 74 96 15 00 add 0x159674,%ebx
rtems_libio_check_is_open(iop);
1322a7: 8b 73 0c mov 0xc(%ebx),%esi
1322aa: f7 c6 00 01 00 00 test $0x100,%esi
1322b0: 0f 84 76 01 00 00 je 13242c <fcntl+0x1ac> <== NEVER TAKEN
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
1322b6: 83 ff 09 cmp $0x9,%edi
1322b9: 76 0d jbe 1322c8 <fcntl+0x48>
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
1322bb: e8 8c 2c ff ff call 124f4c <__errno>
1322c0: c7 00 16 00 00 00 movl $0x16,(%eax)
1322c6: eb 13 jmp 1322db <fcntl+0x5b>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
1322c8: ff 24 bd c4 93 13 00 jmp *0x1393c4(,%edi,4)
1322cf: 90 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
1322d0: e8 77 2c ff ff call 124f4c <__errno>
1322d5: c7 00 86 00 00 00 movl $0x86,(%eax)
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
1322db: be ff ff ff ff mov $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
1322e0: 89 f0 mov %esi,%eax
1322e2: 83 c4 2c add $0x2c,%esp
1322e5: 5b pop %ebx
1322e6: 5e pop %esi
1322e7: 5f pop %edi
1322e8: 5d pop %ebp
1322e9: c3 ret
1322ea: 66 90 xchg %ax,%ax
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
1322ec: 8b 44 24 48 mov 0x48(%esp),%eax
1322f0: 89 04 24 mov %eax,(%esp)
1322f3: e8 14 a1 fd ff call 10c40c <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
1322f8: 25 01 02 00 00 and $0x201,%eax
1322fd: 8b 53 0c mov 0xc(%ebx),%edx
132300: 81 e2 fe fd ff ff and $0xfffffdfe,%edx
132306: 09 d0 or %edx,%eax
132308: 89 43 0c mov %eax,0xc(%ebx)
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
13230b: 31 f6 xor %esi,%esi
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
13230d: 8b 43 20 mov 0x20(%ebx),%eax
132310: 89 7c 24 04 mov %edi,0x4(%esp)
132314: 89 1c 24 mov %ebx,(%esp)
132317: ff 50 28 call *0x28(%eax)
13231a: 89 c3 mov %eax,%ebx
if (err) {
13231c: 85 c0 test %eax,%eax
13231e: 74 c0 je 1322e0 <fcntl+0x60> <== ALWAYS TAKEN
errno = err;
132320: e8 27 2c ff ff call 124f4c <__errno> <== NOT EXECUTED
132325: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
ret = -1;
132327: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
13232c: 89 f0 mov %esi,%eax <== NOT EXECUTED
13232e: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
132331: 5b pop %ebx <== NOT EXECUTED
132332: 5e pop %esi <== NOT EXECUTED
132333: 5f pop %edi <== NOT EXECUTED
132334: 5d pop %ebp <== NOT EXECUTED
132335: c3 ret <== NOT EXECUTED
132336: 66 90 xchg %ax,%ax <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
132338: 89 34 24 mov %esi,(%esp)
13233b: e8 08 a1 fd ff call 10c448 <rtems_libio_to_fcntl_flags>
132340: 89 c6 mov %eax,%esi
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
132342: 85 f6 test %esi,%esi
132344: 79 c7 jns 13230d <fcntl+0x8d> <== ALWAYS TAKEN
132346: eb 98 jmp 1322e0 <fcntl+0x60> <== NOT EXECUTED
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
132348: 8b 44 24 48 mov 0x48(%esp),%eax
13234c: 85 c0 test %eax,%eax
13234e: 0f 84 c8 00 00 00 je 13241c <fcntl+0x19c>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
132354: 81 ce 00 08 00 00 or $0x800,%esi
13235a: 89 73 0c mov %esi,0xc(%ebx)
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
13235d: 31 f6 xor %esi,%esi
13235f: eb ac jmp 13230d <fcntl+0x8d>
132361: 8d 76 00 lea 0x0(%esi),%esi
fd2 = va_arg( ap, int );
ret = duplicate_iop( iop, fd2 );
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
132364: c1 ee 0b shr $0xb,%esi
132367: 83 e6 01 and $0x1,%esi
13236a: eb a1 jmp 13230d <fcntl+0x8d>
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
13236c: e8 17 a1 fd ff call 10c488 <rtems_libio_allocate>
132371: 89 c5 mov %eax,%ebp
if (diop != NULL) {
132373: 85 c0 test %eax,%eax
132375: 0f 84 60 ff ff ff je 1322db <fcntl+0x5b>
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
13237b: 8b 43 0c mov 0xc(%ebx),%eax
13237e: 89 04 24 mov %eax,(%esp)
132381: e8 c2 a0 fd ff call 10c448 <rtems_libio_to_fcntl_flags>
132386: 89 c6 mov %eax,%esi
oflag &= ~O_CREAT;
132388: 81 e6 ff fd ff ff and $0xfffffdff,%esi
diop->flags |= rtems_libio_fcntl_flags( oflag );
13238e: 8b 45 0c mov 0xc(%ebp),%eax
132391: 89 44 24 1c mov %eax,0x1c(%esp)
132395: 89 34 24 mov %esi,(%esp)
132398: e8 6f a0 fd ff call 10c40c <rtems_libio_fcntl_flags>
13239d: 0b 44 24 1c or 0x1c(%esp),%eax
1323a1: 89 45 0c mov %eax,0xc(%ebp)
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
}
1323a4: 8b 43 24 mov 0x24(%ebx),%eax
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
1323a7: 8b 48 0c mov 0xc(%eax),%ecx
1323aa: 89 04 24 mov %eax,(%esp)
1323ad: ff 11 call *(%ecx)
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
1323af: 8d 43 10 lea 0x10(%ebx),%eax
1323b2: 89 44 24 04 mov %eax,0x4(%esp)
1323b6: 8d 45 10 lea 0x10(%ebp),%eax
1323b9: 89 04 24 mov %eax,(%esp)
1323bc: e8 7b 84 fe ff call 11a83c <rtems_filesystem_location_clone>
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
}
1323c1: 8b 43 24 mov 0x24(%ebx),%eax
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->unlock_h)( mt_entry );
1323c4: 8b 48 0c mov 0xc(%eax),%ecx
1323c7: 89 04 24 mov %eax,(%esp)
1323ca: ff 51 04 call *0x4(%ecx)
/*
* XXX: We call the open handler here to have a proper open and close pair.
*
* FIXME: What to do with the path?
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
1323cd: 8b 45 20 mov 0x20(%ebp),%eax
1323d0: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
1323d7: 00
1323d8: 89 74 24 08 mov %esi,0x8(%esp)
1323dc: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
1323e3: 00
1323e4: 89 2c 24 mov %ebp,(%esp)
1323e7: ff 10 call *(%eax)
1323e9: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
1323eb: 85 c0 test %eax,%eax
1323ed: 75 55 jne 132444 <fcntl+0x1c4> <== NEVER TAKEN
rv = diop - rtems_libio_iops;
1323ef: 2b 2d 74 96 15 00 sub 0x159674,%ebp
1323f5: c1 fd 04 sar $0x4,%ebp
1323f8: 8d 44 ad 00 lea 0x0(%ebp,%ebp,4),%eax
1323fc: 8d 44 85 00 lea 0x0(%ebp,%eax,4),%eax
132400: 8d 44 85 00 lea 0x0(%ebp,%eax,4),%eax
132404: 89 c2 mov %eax,%edx
132406: c1 e2 08 shl $0x8,%edx
132409: 01 d0 add %edx,%eax
13240b: 89 c2 mov %eax,%edx
13240d: c1 e2 10 shl $0x10,%edx
132410: 01 d0 add %edx,%eax
132412: 8d 74 45 00 lea 0x0(%ebp,%eax,2),%esi
132416: e9 27 ff ff ff jmp 132342 <fcntl+0xc2>
13241b: 90 nop
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
13241c: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi
132422: 89 73 0c mov %esi,0xc(%ebx)
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
132425: 31 f6 xor %esi,%esi
132427: e9 e1 fe ff ff jmp 13230d <fcntl+0x8d>
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
13242c: e8 1b 2b ff ff call 124f4c <__errno>
132431: c7 00 09 00 00 00 movl $0x9,(%eax)
132437: be ff ff ff ff mov $0xffffffff,%esi
13243c: e9 9f fe ff ff jmp 1322e0 <fcntl+0x60>
132441: 8d 76 00 lea 0x0(%esi),%esi
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
if ( rv == 0 ) {
rv = diop - rtems_libio_iops;
} else {
rtems_libio_free( diop );
132444: 89 2c 24 mov %ebp,(%esp) <== NOT EXECUTED
132447: e8 98 a0 fd ff call 10c4e4 <rtems_libio_free> <== NOT EXECUTED
13244c: e9 f1 fe ff ff jmp 132342 <fcntl+0xc2> <== NOT EXECUTED
0010ace4 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
10ace4: 83 ec 0c sub $0xc,%esp
10ace7: 8b 44 24 10 mov 0x10(%esp),%eax
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
10aceb: 3b 05 5c 94 12 00 cmp 0x12945c,%eax
10acf1: 0f 83 a1 00 00 00 jae 10ad98 <fpathconf+0xb4>
iop = rtems_libio_iop(fd);
10acf7: 8d 04 40 lea (%eax,%eax,2),%eax
10acfa: c1 e0 04 shl $0x4,%eax
10acfd: 03 05 30 d6 12 00 add 0x12d630,%eax
rtems_libio_check_is_open(iop);
10ad03: f6 40 0d 01 testb $0x1,0xd(%eax)
10ad07: 0f 84 8b 00 00 00 je 10ad98 <fpathconf+0xb4> <== NEVER TAKEN
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
10ad0d: 8b 40 24 mov 0x24(%eax),%eax
10ad10: 8b 40 2c mov 0x2c(%eax),%eax
switch ( name ) {
10ad13: 83 7c 24 14 0b cmpl $0xb,0x14(%esp)
10ad18: 76 16 jbe 10ad30 <fpathconf+0x4c>
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10ad1a: e8 9d 15 00 00 call 10c2bc <__errno>
10ad1f: c7 00 16 00 00 00 movl $0x16,(%eax)
10ad25: b8 ff ff ff ff mov $0xffffffff,%eax
10ad2a: 66 90 xchg %ax,%ax
break;
}
return return_value;
}
10ad2c: 83 c4 0c add $0xc,%esp
10ad2f: c3 ret
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
10ad30: 8b 54 24 14 mov 0x14(%esp),%edx
10ad34: ff 24 95 6c f2 11 00 jmp *0x11f26c(,%edx,4)
10ad3b: 90 nop
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
10ad3c: 8b 40 24 mov 0x24(%eax),%eax
break;
10ad3f: eb eb jmp 10ad2c <fpathconf+0x48>
10ad41: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
10ad44: 8b 40 18 mov 0x18(%eax),%eax
break;
10ad47: eb e3 jmp 10ad2c <fpathconf+0x48>
10ad49: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
10ad4c: 8b 40 2c mov 0x2c(%eax),%eax
break;
10ad4f: eb db jmp 10ad2c <fpathconf+0x48>
10ad51: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
10ad54: 8b 40 20 mov 0x20(%eax),%eax
break;
10ad57: eb d3 jmp 10ad2c <fpathconf+0x48>
10ad59: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
10ad5c: 8b 40 1c mov 0x1c(%eax),%eax
break;
10ad5f: eb cb jmp 10ad2c <fpathconf+0x48>
10ad61: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
10ad64: 8b 40 14 mov 0x14(%eax),%eax
break;
10ad67: eb c3 jmp 10ad2c <fpathconf+0x48>
10ad69: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
10ad6c: 8b 40 10 mov 0x10(%eax),%eax
break;
10ad6f: eb bb jmp 10ad2c <fpathconf+0x48>
10ad71: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
10ad74: 8b 40 0c mov 0xc(%eax),%eax
break;
10ad77: eb b3 jmp 10ad2c <fpathconf+0x48>
10ad79: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
10ad7c: 8b 40 08 mov 0x8(%eax),%eax
break;
10ad7f: eb ab jmp 10ad2c <fpathconf+0x48>
10ad81: 8d 76 00 lea 0x0(%esi),%esi
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
10ad84: 8b 40 04 mov 0x4(%eax),%eax
break;
10ad87: eb a3 jmp 10ad2c <fpathconf+0x48>
10ad89: 8d 76 00 lea 0x0(%esi),%esi
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
10ad8c: 8b 00 mov (%eax),%eax
break;
10ad8e: eb 9c jmp 10ad2c <fpathconf+0x48>
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
10ad90: 8b 40 28 mov 0x28(%eax),%eax
break;
10ad93: eb 97 jmp 10ad2c <fpathconf+0x48>
10ad95: 8d 76 00 lea 0x0(%esi),%esi
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
10ad98: e8 1f 15 00 00 call 10c2bc <__errno>
10ad9d: c7 00 09 00 00 00 movl $0x9,(%eax)
10ada3: b8 ff ff ff ff mov $0xffffffff,%eax
10ada8: eb 82 jmp 10ad2c <fpathconf+0x48>
0010793c <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
10793c: 53 push %ebx
10793d: 83 ec 18 sub $0x18,%esp
107940: 8b 5c 24 20 mov 0x20(%esp),%ebx
MSBUMP(free_calls, 1);
107944: ff 05 0c f5 12 00 incl 0x12f50c
if ( !ptr )
10794a: 85 db test %ebx,%ebx
10794c: 74 50 je 10799e <free+0x62>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10794e: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760
107955: 74 4d je 1079a4 <free+0x68> <== ALWAYS TAKEN
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107957: a1 48 d9 12 00 mov 0x12d948,%eax
10795c: 85 c0 test %eax,%eax
10795e: 74 06 je 107966 <free+0x2a>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
107960: 89 1c 24 mov %ebx,(%esp)
107963: ff 50 08 call *0x8(%eax)
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
107966: 89 5c 24 04 mov %ebx,0x4(%esp)
10796a: a1 6c b2 12 00 mov 0x12b26c,%eax
10796f: 89 04 24 mov %eax,(%esp)
107972: e8 81 5a 00 00 call 10d3f8 <_Protected_heap_Free>
107977: 84 c0 test %al,%al
107979: 75 23 jne 10799e <free+0x62>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
10797b: a1 6c b2 12 00 mov 0x12b26c,%eax
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
107980: 8b 50 1c mov 0x1c(%eax),%edx
107983: 89 54 24 0c mov %edx,0xc(%esp)
107987: 8b 40 18 mov 0x18(%eax),%eax
10798a: 89 44 24 08 mov %eax,0x8(%esp)
10798e: 89 5c 24 04 mov %ebx,0x4(%esp)
107992: c7 04 24 48 14 12 00 movl $0x121448,(%esp)
107999: e8 ca 0e 00 00 call 108868 <printk>
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
10799e: 83 c4 18 add $0x18,%esp
1079a1: 5b pop %ebx
1079a2: c3 ret
1079a3: 90 nop
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
1079a4: e8 83 01 00 00 call 107b2c <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1079a9: 84 c0 test %al,%al
1079ab: 75 aa jne 107957 <free+0x1b>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
1079ad: 89 5c 24 20 mov %ebx,0x20(%esp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1079b1: 83 c4 18 add $0x18,%esp
1079b4: 5b pop %ebx
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
1079b5: e9 ce 01 00 00 jmp 107b88 <malloc_deferred_free>
0011f4d8 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
11f4d8: 57 push %edi
11f4d9: 53 push %ebx
11f4da: 53 push %ebx
11f4db: 8b 44 24 10 mov 0x10(%esp),%eax
11f4df: 8b 5c 24 14 mov 0x14(%esp),%ebx
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
11f4e3: 85 db test %ebx,%ebx
11f4e5: 74 51 je 11f538 <fstat+0x60> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
11f4e7: 3b 05 c0 b2 12 00 cmp 0x12b2c0,%eax
11f4ed: 73 35 jae 11f524 <fstat+0x4c>
11f4ef: 8d 14 40 lea (%eax,%eax,2),%edx
11f4f2: c1 e2 04 shl $0x4,%edx
11f4f5: 03 15 d4 f4 12 00 add 0x12f4d4,%edx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
11f4fb: f6 42 0d 01 testb $0x1,0xd(%edx)
11f4ff: 74 23 je 11f524 <fstat+0x4c>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
11f501: b9 48 00 00 00 mov $0x48,%ecx
11f506: 31 c0 xor %eax,%eax
11f508: 89 df mov %ebx,%edi
11f50a: f3 aa rep stos %al,%es:(%edi)
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
11f50c: 8b 42 20 mov 0x20(%edx),%eax
11f50f: 89 5c 24 14 mov %ebx,0x14(%esp)
11f513: 83 c2 10 add $0x10,%edx
11f516: 89 54 24 10 mov %edx,0x10(%esp)
11f51a: 8b 40 18 mov 0x18(%eax),%eax
}
11f51d: 59 pop %ecx
11f51e: 5b pop %ebx
11f51f: 5f pop %edi
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
11f520: ff e0 jmp *%eax
11f522: 66 90 xchg %ax,%ax
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
11f524: e8 cf 37 ff ff call 112cf8 <__errno>
11f529: c7 00 09 00 00 00 movl $0x9,(%eax)
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
}
11f52f: b8 ff ff ff ff mov $0xffffffff,%eax
11f534: 5a pop %edx
11f535: 5b pop %ebx
11f536: 5f pop %edi
11f537: c3 ret
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
11f538: e8 bb 37 ff ff call 112cf8 <__errno> <== NOT EXECUTED
11f53d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
11f543: eb ea jmp 11f52f <fstat+0x57> <== NOT EXECUTED
00132484 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
132484: 57 push %edi
132485: 56 push %esi
132486: 53 push %ebx
132487: 83 ec 10 sub $0x10,%esp
13248a: 8b 44 24 20 mov 0x20(%esp),%eax
13248e: 8b 74 24 24 mov 0x24(%esp),%esi
132492: 8b 7c 24 28 mov 0x28(%esp),%edi
rtems_filesystem_node_types_t type;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
132496: 3b 05 e0 52 14 00 cmp 0x1452e0,%eax
13249c: 73 36 jae 1324d4 <getdents+0x50> <== NEVER TAKEN
13249e: 8d 1c 40 lea (%eax,%eax,2),%ebx
1324a1: c1 e3 04 shl $0x4,%ebx
1324a4: 03 1d 74 96 15 00 add 0x159674,%ebx
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
1324aa: 8d 43 10 lea 0x10(%ebx),%eax
1324ad: 89 04 24 mov %eax,(%esp)
1324b0: e8 9b bb fd ff call 10e050 <rtems_filesystem_node_type>
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
1324b5: 85 c0 test %eax,%eax
1324b7: 75 1f jne 1324d8 <getdents+0x54>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
1324b9: 8b 43 20 mov 0x20(%ebx),%eax
1324bc: 89 7c 24 28 mov %edi,0x28(%esp)
1324c0: 89 74 24 24 mov %esi,0x24(%esp)
1324c4: 89 5c 24 20 mov %ebx,0x20(%esp)
1324c8: 8b 40 08 mov 0x8(%eax),%eax
}
1324cb: 83 c4 10 add $0x10,%esp
1324ce: 5b pop %ebx
1324cf: 5e pop %esi
1324d0: 5f pop %edi
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
1324d1: ff e0 jmp *%eax
1324d3: 90 nop
rtems_filesystem_node_types_t type;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
1324d4: 31 db xor %ebx,%ebx <== NOT EXECUTED
1324d6: eb d2 jmp 1324aa <getdents+0x26> <== NOT EXECUTED
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
1324d8: e8 6f 2a ff ff call 124f4c <__errno>
1324dd: c7 00 14 00 00 00 movl $0x14,(%eax)
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
}
1324e3: b8 ff ff ff ff mov $0xffffffff,%eax
1324e8: 83 c4 10 add $0x10,%esp
1324eb: 5b pop %ebx
1324ec: 5e pop %esi
1324ed: 5f pop %edi
1324ee: c3 ret
001079bc <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
1079bc: 55 push %ebp
1079bd: 57 push %edi
1079be: 56 push %esi
1079bf: 53 push %ebx
1079c0: 83 ec 3c sub $0x3c,%esp
1079c3: 8b 5c 24 50 mov 0x50(%esp),%ebx
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
1079c7: 85 db test %ebx,%ebx
1079c9: 74 7d je 107a48 <gettimeofday+0x8c> <== NEVER TAKEN
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
1079cb: 9c pushf
1079cc: fa cli
1079cd: 5d pop %ebp
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
1079ce: 8d 44 24 28 lea 0x28(%esp),%eax
1079d2: 89 04 24 mov %eax,(%esp)
1079d5: e8 ca 4d 00 00 call 10c7a4 <_TOD_Get_as_timestamp>
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
1079da: 8b 74 24 28 mov 0x28(%esp),%esi
1079de: 8b 7c 24 2c mov 0x2c(%esp),%edi
_TOD_Get( &now );
_ISR_Enable(level);
1079e2: 55 push %ebp
1079e3: 9d popf
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
1079e4: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
1079eb: 3b
1079ec: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
1079f3: 00
1079f4: 89 34 24 mov %esi,(%esp)
1079f7: 89 7c 24 04 mov %edi,0x4(%esp)
1079fb: e8 48 75 01 00 call 11ef48 <__divdi3>
107a00: 89 03 mov %eax,(%ebx)
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
107a02: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
107a09: 3b
107a0a: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107a11: 00
107a12: 89 34 24 mov %esi,(%esp)
107a15: 89 7c 24 04 mov %edi,0x4(%esp)
107a19: e8 7e 76 01 00 call 11f09c <__moddi3>
107a1e: 89 c6 mov %eax,%esi
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
107a20: b9 d3 4d 62 10 mov $0x10624dd3,%ecx
107a25: f7 e9 imul %ecx
107a27: 89 44 24 18 mov %eax,0x18(%esp)
107a2b: 89 54 24 1c mov %edx,0x1c(%esp)
107a2f: 8b 54 24 1c mov 0x1c(%esp),%edx
107a33: c1 fa 06 sar $0x6,%edx
107a36: c1 fe 1f sar $0x1f,%esi
107a39: 29 f2 sub %esi,%edx
107a3b: 89 53 04 mov %edx,0x4(%ebx)
* Timezone information ignored by the OS proper. Per email
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
107a3e: 31 c0 xor %eax,%eax
}
107a40: 83 c4 3c add $0x3c,%esp
107a43: 5b pop %ebx
107a44: 5e pop %esi
107a45: 5f pop %edi
107a46: 5d pop %ebp
107a47: c3 ret
void * __tz __attribute__((unused))
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
rtems_set_errno_and_return_minus_one( EFAULT );
107a48: e8 ab b2 00 00 call 112cf8 <__errno> <== NOT EXECUTED
107a4d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
107a53: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107a58: eb e6 jmp 107a40 <gettimeofday+0x84> <== NOT EXECUTED
0012905c <init_etc_passwd_group>:
void init_etc_passwd_group(void)
{
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
12905c: 80 3d 60 a9 17 00 00 cmpb $0x0,0x17a960
129063: 74 03 je 129068 <init_etc_passwd_group+0xc>
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
129065: c3 ret
129066: 66 90 xchg %ax,%ax
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
129068: 53 push %ebx
129069: 83 ec 18 sub $0x18,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
12906c: c6 05 60 a9 17 00 01 movb $0x1,0x17a960
mkdir("/etc", 0777);
129073: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp)
12907a: 00
12907b: c7 04 24 6f b1 15 00 movl $0x15b16f,(%esp)
129082: e8 19 ea fd ff call 107aa0 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
129087: c7 44 24 04 55 6b 15 movl $0x156b55,0x4(%esp)
12908e: 00
12908f: c7 04 24 74 b1 15 00 movl $0x15b174,(%esp)
129096: e8 d1 2b 01 00 call 13bc6c <fopen>
12909b: 85 c0 test %eax,%eax
12909d: 74 71 je 129110 <init_etc_passwd_group+0xb4>
fclose(fp);
12909f: 89 04 24 mov %eax,(%esp)
1290a2: e8 4d 23 01 00 call 13b3f4 <fclose>
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
1290a7: c7 44 24 04 55 6b 15 movl $0x156b55,0x4(%esp)
1290ae: 00
1290af: c7 04 24 80 b1 15 00 movl $0x15b180,(%esp)
1290b6: e8 b1 2b 01 00 call 13bc6c <fopen>
1290bb: 85 c0 test %eax,%eax
1290bd: 74 0d je 1290cc <init_etc_passwd_group+0x70>
fclose(fp);
1290bf: 89 04 24 mov %eax,(%esp)
1290c2: e8 2d 23 01 00 call 13b3f4 <fclose>
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
1290c7: 83 c4 18 add $0x18,%esp
1290ca: 5b pop %ebx
1290cb: c3 ret
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
1290cc: c7 44 24 04 30 6b 15 movl $0x156b30,0x4(%esp)
1290d3: 00
1290d4: c7 04 24 80 b1 15 00 movl $0x15b180,(%esp)
1290db: e8 8c 2b 01 00 call 13bc6c <fopen>
1290e0: 89 c3 mov %eax,%ebx
1290e2: 85 c0 test %eax,%eax
1290e4: 74 e1 je 1290c7 <init_etc_passwd_group+0x6b><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
1290e6: 89 44 24 0c mov %eax,0xc(%esp)
1290ea: c7 44 24 08 2a 00 00 movl $0x2a,0x8(%esp)
1290f1: 00
1290f2: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
1290f9: 00
1290fa: c7 04 24 f4 b1 15 00 movl $0x15b1f4,(%esp)
129101: e8 9a 3e 01 00 call 13cfa0 <fwrite>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
129106: 89 1c 24 mov %ebx,(%esp)
129109: e8 e6 22 01 00 call 13b3f4 <fclose>
12910e: eb b7 jmp 1290c7 <init_etc_passwd_group+0x6b>
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
129110: c7 44 24 04 30 6b 15 movl $0x156b30,0x4(%esp)
129117: 00
129118: c7 04 24 74 b1 15 00 movl $0x15b174,(%esp)
12911f: e8 48 2b 01 00 call 13bc6c <fopen>
129124: 89 c3 mov %eax,%ebx
129126: 85 c0 test %eax,%eax
129128: 0f 84 79 ff ff ff je 1290a7 <init_etc_passwd_group+0x4b><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
12912e: 89 44 24 0c mov %eax,0xc(%esp)
129132: c7 44 24 08 66 00 00 movl $0x66,0x8(%esp)
129139: 00
12913a: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
129141: 00
129142: c7 04 24 8c b1 15 00 movl $0x15b18c,(%esp)
129149: e8 52 3e 01 00 call 13cfa0 <fwrite>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
12914e: 89 1c 24 mov %ebx,(%esp)
129151: e8 9e 22 01 00 call 13b3f4 <fclose>
129156: e9 4c ff ff ff jmp 1290a7 <init_etc_passwd_group+0x4b>
0010a4b8 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
10a4b8: 56 push %esi
10a4b9: 53 push %ebx
10a4ba: 53 push %ebx
10a4bb: 89 d6 mov %edx,%esi
10a4bd: 88 c3 mov %al,%bl
if (tty->termios.c_iflag & ISTRIP)
10a4bf: 8b 42 30 mov 0x30(%edx),%eax
10a4c2: a8 20 test $0x20,%al
10a4c4: 74 03 je 10a4c9 <iproc+0x11> <== ALWAYS TAKEN
c &= 0x7f;
10a4c6: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
10a4c9: f6 c4 02 test $0x2,%ah
10a4cc: 74 18 je 10a4e6 <iproc+0x2e>
c = tolower (c);
10a4ce: 0f b6 db movzbl %bl,%ebx
10a4d1: 8b 15 08 d4 12 00 mov 0x12d408,%edx
10a4d7: 8a 54 1a 01 mov 0x1(%edx,%ebx,1),%dl
10a4db: 83 e2 03 and $0x3,%edx
10a4de: fe ca dec %dl
10a4e0: 0f 84 aa 00 00 00 je 10a590 <iproc+0xd8>
if (c == '\r') {
10a4e6: 80 fb 0d cmp $0xd,%bl
10a4e9: 74 4d je 10a538 <iproc+0x80>
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
10a4eb: 80 fb 0a cmp $0xa,%bl
10a4ee: 0f 84 94 00 00 00 je 10a588 <iproc+0xd0>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
10a4f4: 84 db test %bl,%bl
10a4f6: 75 4c jne 10a544 <iproc+0x8c> <== ALWAYS TAKEN
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
10a4f8: 8b 46 20 mov 0x20(%esi),%eax
10a4fb: 8b 15 3c d2 12 00 mov 0x12d23c,%edx
10a501: 4a dec %edx
10a502: 39 d0 cmp %edx,%eax
10a504: 73 2a jae 10a530 <iproc+0x78> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
10a506: f6 46 3c 08 testb $0x8,0x3c(%esi)
10a50a: 0f 85 88 00 00 00 jne 10a598 <iproc+0xe0> <== ALWAYS TAKEN
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
10a510: 8b 56 1c mov 0x1c(%esi),%edx
10a513: 88 1c 02 mov %bl,(%edx,%eax,1)
10a516: 40 inc %eax
10a517: 89 46 20 mov %eax,0x20(%esi)
}
return 0;
10a51a: 31 c0 xor %eax,%eax
}
10a51c: 59 pop %ecx
10a51d: 5b pop %ebx
10a51e: 5e pop %esi
10a51f: c3 ret
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
10a520: 8b 4e 20 mov 0x20(%esi),%ecx
10a523: 85 c9 test %ecx,%ecx
10a525: 74 09 je 10a530 <iproc+0x78>
10a527: 31 d2 xor %edx,%edx
10a529: 89 f0 mov %esi,%eax
10a52b: e8 18 fe ff ff call 10a348 <erase.part.2>
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
10a530: 31 c0 xor %eax,%eax
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
10a532: 59 pop %ecx
10a533: 5b pop %ebx
10a534: 5e pop %esi
10a535: c3 ret
10a536: 66 90 xchg %ax,%ax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
10a538: a8 80 test $0x80,%al
10a53a: 75 f4 jne 10a530 <iproc+0x78> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
10a53c: f6 c4 01 test $0x1,%ah
10a53f: 74 03 je 10a544 <iproc+0x8c> <== NEVER TAKEN
c = '\n';
10a541: b3 0a mov $0xa,%bl
10a543: 90 nop
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
10a544: 8b 46 3c mov 0x3c(%esi),%eax
10a547: a8 02 test $0x2,%al
10a549: 74 ad je 10a4f8 <iproc+0x40>
if (c == tty->termios.c_cc[VERASE]) {
10a54b: 38 5e 43 cmp %bl,0x43(%esi)
10a54e: 74 d0 je 10a520 <iproc+0x68>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
10a550: 38 5e 44 cmp %bl,0x44(%esi)
10a553: 74 63 je 10a5b8 <iproc+0x100>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
10a555: 38 5e 45 cmp %bl,0x45(%esi)
10a558: 0f 84 aa 00 00 00 je 10a608 <iproc+0x150> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
10a55e: 80 fb 0a cmp $0xa,%bl
10a561: 74 7d je 10a5e0 <iproc+0x128>
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
10a563: 38 5e 4c cmp %bl,0x4c(%esi)
10a566: 74 05 je 10a56d <iproc+0xb5> <== NEVER TAKEN
10a568: 38 5e 51 cmp %bl,0x51(%esi)
10a56b: 75 8b jne 10a4f8 <iproc+0x40> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
10a56d: a8 08 test $0x8,%al <== NOT EXECUTED
10a56f: 75 3b jne 10a5ac <iproc+0xf4> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
10a571: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
10a574: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
10a577: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
10a57a: 40 inc %eax <== NOT EXECUTED
10a57b: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
return 1;
10a57e: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10a583: eb 97 jmp 10a51c <iproc+0x64> <== NOT EXECUTED
10a585: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
10a588: a8 40 test $0x40,%al
10a58a: 74 b8 je 10a544 <iproc+0x8c> <== ALWAYS TAKEN
c = '\r';
10a58c: b3 0d mov $0xd,%bl <== NOT EXECUTED
10a58e: eb b4 jmp 10a544 <iproc+0x8c> <== NOT EXECUTED
{
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
10a590: 83 c3 20 add $0x20,%ebx
10a593: e9 4e ff ff ff jmp 10a4e6 <iproc+0x2e>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
10a598: 0f b6 c3 movzbl %bl,%eax
10a59b: 89 f2 mov %esi,%edx
10a59d: e8 3a fd ff ff call 10a2dc <echo>
10a5a2: 8b 46 20 mov 0x20(%esi),%eax
10a5a5: e9 66 ff ff ff jmp 10a510 <iproc+0x58>
10a5aa: 66 90 xchg %ax,%ax
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
10a5ac: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
10a5af: 89 f2 mov %esi,%edx <== NOT EXECUTED
10a5b1: e8 26 fd ff ff call 10a2dc <echo> <== NOT EXECUTED
10a5b6: eb b9 jmp 10a571 <iproc+0xb9> <== NOT EXECUTED
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
10a5b8: 8b 56 20 mov 0x20(%esi),%edx
10a5bb: 85 d2 test %edx,%edx
10a5bd: 0f 84 6d ff ff ff je 10a530 <iproc+0x78> <== NEVER TAKEN
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
10a5c3: a8 08 test $0x8,%al
10a5c5: 74 4b je 10a612 <iproc+0x15a> <== NEVER TAKEN
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
10a5c7: a8 10 test $0x10,%al
10a5c9: 74 55 je 10a620 <iproc+0x168> <== NEVER TAKEN
10a5cb: ba 01 00 00 00 mov $0x1,%edx
10a5d0: 89 f0 mov %esi,%eax
10a5d2: e8 71 fd ff ff call 10a348 <erase.part.2>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
10a5d7: 31 c0 xor %eax,%eax
10a5d9: e9 3e ff ff ff jmp 10a51c <iproc+0x64>
10a5de: 66 90 xchg %ax,%ax
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
10a5e0: a8 48 test $0x48,%al
10a5e2: 74 0c je 10a5f0 <iproc+0x138> <== NEVER TAKEN
echo (c, tty);
10a5e4: 89 f2 mov %esi,%edx
10a5e6: b8 0a 00 00 00 mov $0xa,%eax
10a5eb: e8 ec fc ff ff call 10a2dc <echo>
tty->cbuf[tty->ccount++] = c;
10a5f0: 8b 46 20 mov 0x20(%esi),%eax
10a5f3: 8b 56 1c mov 0x1c(%esi),%edx
10a5f6: c6 04 02 0a movb $0xa,(%edx,%eax,1)
10a5fa: 40 inc %eax
10a5fb: 89 46 20 mov %eax,0x20(%esi)
return 1;
10a5fe: b8 01 00 00 00 mov $0x1,%eax
10a603: e9 14 ff ff ff jmp 10a51c <iproc+0x64>
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
10a608: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10a60d: e9 0a ff ff ff jmp 10a51c <iproc+0x64> <== NOT EXECUTED
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
10a612: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
10a619: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a61b: e9 fc fe ff ff jmp 10a51c <iproc+0x64> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
10a620: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
10a627: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
10a62a: 89 f2 mov %esi,%edx <== NOT EXECUTED
10a62c: e8 ab fc ff ff call 10a2dc <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
10a631: f6 46 3c 20 testb $0x20,0x3c(%esi) <== NOT EXECUTED
10a635: 0f 84 f5 fe ff ff je 10a530 <iproc+0x78> <== NOT EXECUTED
echo ('\n', tty);
10a63b: 89 f2 mov %esi,%edx <== NOT EXECUTED
10a63d: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
10a642: e8 95 fc ff ff call 10a2dc <echo> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
10a647: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a649: e9 ce fe ff ff jmp 10a51c <iproc+0x64> <== NOT EXECUTED
0011f580 <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
11f580: 31 c0 xor %eax,%eax <== NOT EXECUTED
11f582: c3 ret <== NOT EXECUTED
001081d0 <libc_wrapup>:
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
1081d0: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760
1081d7: 74 03 je 1081dc <libc_wrapup+0xc> <== ALWAYS TAKEN
*/
fclose (stdin);
fclose (stdout);
fclose (stderr);
}
1081d9: c3 ret <== NOT EXECUTED
1081da: 66 90 xchg %ax,%ax <== NOT EXECUTED
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
1081dc: 53 push %ebx
1081dd: 83 ec 18 sub $0x18,%esp
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
1081e0: 8b 1d 20 20 12 00 mov 0x122020,%ebx
1081e6: 39 1d 20 d4 12 00 cmp %ebx,0x12d420
1081ec: 74 0e je 1081fc <libc_wrapup+0x2c>
_wrapup_reent(_global_impure_ptr);
1081ee: 89 1c 24 mov %ebx,(%esp)
1081f1: e8 56 b5 00 00 call 11374c <_wrapup_reent>
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
1081f6: 89 1d 20 d4 12 00 mov %ebx,0x12d420
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
1081fc: 8b 43 04 mov 0x4(%ebx),%eax
1081ff: 89 04 24 mov %eax,(%esp)
108202: e8 0d ac 00 00 call 112e14 <fclose>
fclose (stdout);
108207: a1 20 d4 12 00 mov 0x12d420,%eax
10820c: 8b 40 08 mov 0x8(%eax),%eax
10820f: 89 04 24 mov %eax,(%esp)
108212: e8 fd ab 00 00 call 112e14 <fclose>
fclose (stderr);
108217: a1 20 d4 12 00 mov 0x12d420,%eax
10821c: 8b 40 0c mov 0xc(%eax),%eax
10821f: 89 04 24 mov %eax,(%esp)
108222: e8 ed ab 00 00 call 112e14 <fclose>
}
108227: 83 c4 18 add $0x18,%esp
10822a: 5b pop %ebx
10822b: c3 ret
00107c50 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
107c50: 56 push %esi
107c51: 53 push %ebx
107c52: 83 ec 14 sub $0x14,%esp
107c55: 8b 74 24 20 mov 0x20(%esp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
107c59: ff 05 04 f5 12 00 incl 0x12f504
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
107c5f: e8 00 ff ff ff call 107b64 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
107c64: 85 f6 test %esi,%esi
107c66: 74 65 je 107ccd <malloc+0x7d>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107c68: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760
107c6f: 74 53 je 107cc4 <malloc+0x74>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
107c71: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107c78: 00
107c79: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
107c80: 00
107c81: 89 74 24 04 mov %esi,0x4(%esp)
107c85: a1 6c b2 12 00 mov 0x12b26c,%eax
107c8a: 89 04 24 mov %eax,(%esp)
107c8d: e8 16 57 00 00 call 10d3a8 <_Protected_heap_Allocate_aligned_with_boundary>
107c92: 89 c3 mov %eax,%ebx
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
107c94: 85 c0 test %eax,%eax
107c96: 74 40 je 107cd8 <malloc+0x88>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
107c98: a1 40 d9 12 00 mov 0x12d940,%eax
107c9d: 85 c0 test %eax,%eax
107c9f: 74 09 je 107caa <malloc+0x5a>
(*rtems_malloc_dirty_helper)( return_this, size );
107ca1: 89 74 24 04 mov %esi,0x4(%esp)
107ca5: 89 1c 24 mov %ebx,(%esp)
107ca8: ff d0 call *%eax
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107caa: a1 48 d9 12 00 mov 0x12d948,%eax
107caf: 85 c0 test %eax,%eax
107cb1: 74 06 je 107cb9 <malloc+0x69>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
107cb3: 89 1c 24 mov %ebx,(%esp)
107cb6: ff 50 04 call *0x4(%eax)
return return_this;
}
107cb9: 89 d8 mov %ebx,%eax
107cbb: 83 c4 14 add $0x14,%esp
107cbe: 5b pop %ebx
107cbf: 5e pop %esi
107cc0: c3 ret
107cc1: 8d 76 00 lea 0x0(%esi),%esi
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
107cc4: e8 63 fe ff ff call 107b2c <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107cc9: 84 c0 test %al,%al
107ccb: 75 a4 jne 107c71 <malloc+0x21> <== ALWAYS TAKEN
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
107ccd: 31 db xor %ebx,%ebx
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
107ccf: 89 d8 mov %ebx,%eax
107cd1: 83 c4 14 add $0x14,%esp
107cd4: 5b pop %ebx
107cd5: 5e pop %esi
107cd6: c3 ret
107cd7: 90 nop
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
107cd8: a1 44 d9 12 00 mov 0x12d944,%eax
107cdd: 85 c0 test %eax,%eax
107cdf: 74 0f je 107cf0 <malloc+0xa0>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
107ce1: 89 34 24 mov %esi,(%esp)
107ce4: ff 50 04 call *0x4(%eax)
if ( !return_this ) {
107ce7: 85 c0 test %eax,%eax
107ce9: 74 05 je 107cf0 <malloc+0xa0>
107ceb: 89 c3 mov %eax,%ebx
107ced: eb a9 jmp 107c98 <malloc+0x48>
107cef: 90 nop
errno = ENOMEM;
107cf0: e8 03 b0 00 00 call 112cf8 <__errno>
107cf5: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
107cfb: eb bc jmp 107cb9 <malloc+0x69>
00107cd8 <malloc_sbrk_extend_and_allocate>:
}
static void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
107cd8: 56 push %esi
107cd9: 53 push %ebx
107cda: 83 ec 14 sub $0x14,%esp
107cdd: 8b 74 24 20 mov 0x20(%esp),%esi
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
107ce1: 8b 0d ec 06 13 00 mov 0x1306ec,%ecx
if ( sbrk_amount == 0 )
107ce7: 85 c9 test %ecx,%ecx
107ce9: 74 76 je 107d61 <malloc_sbrk_extend_and_allocate+0x89><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
107ceb: 8d 04 0e lea (%esi,%ecx,1),%eax
107cee: 31 d2 xor %edx,%edx
107cf0: f7 f1 div %ecx
107cf2: 89 c3 mov %eax,%ebx
107cf4: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
107cf7: 89 1c 24 mov %ebx,(%esp)
107cfa: e8 3d 87 ff ff call 10043c <sbrk>
if ( starting_address == (void*) -1 )
107cff: 83 f8 ff cmp $0xffffffff,%eax
107d02: 74 5d je 107d61 <malloc_sbrk_extend_and_allocate+0x89>
return (void *) 0;
if ( !_Protected_heap_Extend(
107d04: 89 5c 24 08 mov %ebx,0x8(%esp)
107d08: 89 44 24 04 mov %eax,0x4(%esp)
107d0c: a1 cc c2 12 00 mov 0x12c2cc,%eax
107d11: 89 04 24 mov %eax,(%esp)
107d14: e8 c3 56 00 00 call 10d3dc <_Protected_heap_Extend>
107d19: 84 c0 test %al,%al
107d1b: 74 2f je 107d4c <malloc_sbrk_extend_and_allocate+0x74>
sbrk(-the_size);
errno = ENOMEM;
return (void *) 0;
}
MSBUMP(space_available, the_size);
107d1d: 01 1d c0 06 13 00 add %ebx,0x1306c0
107d23: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107d2a: 00
107d2b: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
107d32: 00
107d33: 89 74 24 04 mov %esi,0x4(%esp)
107d37: a1 cc c2 12 00 mov 0x12c2cc,%eax
107d3c: 89 04 24 mov %eax,(%esp)
107d3f: e8 48 56 00 00 call 10d38c <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
107d44: 83 c4 14 add $0x14,%esp
107d47: 5b pop %ebx
107d48: 5e pop %esi
107d49: c3 ret
107d4a: 66 90 xchg %ax,%ax
if ( starting_address == (void*) -1 )
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
107d4c: f7 db neg %ebx
107d4e: 89 1c 24 mov %ebx,(%esp)
107d51: e8 e6 86 ff ff call 10043c <sbrk>
errno = ENOMEM;
107d56: e8 a9 b2 00 00 call 113004 <__errno>
107d5b: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
107d61: 31 c0 xor %eax,%eax
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
107d63: 83 c4 14 add $0x14,%esp
107d66: 5b pop %ebx
107d67: 5e pop %esi
107d68: c3 ret
00107d6c <malloc_sbrk_initialize>:
static void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
107d6c: 83 ec 1c sub $0x1c,%esp
107d6f: 8b 44 24 20 mov 0x20(%esp),%eax
107d73: 8b 54 24 24 mov 0x24(%esp),%edx
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
107d77: 89 15 ec 06 13 00 mov %edx,0x1306ec
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
107d7d: 85 c0 test %eax,%eax
107d7f: 74 07 je 107d88 <malloc_sbrk_initialize+0x1c>
}
starting_address = (void *)uaddress;
}
return starting_address;
}
107d81: 83 c4 1c add $0x1c,%esp
107d84: c3 ret
107d85: 8d 76 00 lea 0x0(%esi),%esi
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
uaddress = (uintptr_t)sbrk(length);
107d88: 89 14 24 mov %edx,(%esp)
107d8b: e8 ac 86 ff ff call 10043c <sbrk>
if (uaddress == (uintptr_t) -1) {
107d90: 83 f8 ff cmp $0xffffffff,%eax
107d93: 74 0c je 107da1 <malloc_sbrk_initialize+0x35><== ALWAYS TAKEN
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
107d95: a8 03 test $0x3,%al <== NOT EXECUTED
107d97: 74 e8 je 107d81 <malloc_sbrk_initialize+0x15><== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
107d99: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
107d9c: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
107d9f: eb e0 jmp 107d81 <malloc_sbrk_initialize+0x15><== NOT EXECUTED
if (!starting_address) {
uaddress = (uintptr_t)sbrk(length);
if (uaddress == (uintptr_t) -1) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
107da1: c7 04 24 1a 00 00 00 movl $0x1a,(%esp)
107da8: e8 67 43 00 00 call 10c114 <rtems_fatal_error_occurred>
00107e60 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107e60: 55 push %ebp
107e61: 57 push %edi
107e62: 56 push %esi
107e63: 53 push %ebx
107e64: 83 ec 7c sub $0x7c,%esp
107e67: 8b b4 24 98 00 00 00 mov 0x98(%esp),%esi
int rv = 0;
if (
107e6e: 83 bc 24 9c 00 00 00 cmpl $0x1,0x9c(%esp)
107e75: 01
107e76: 0f 87 6c 02 00 00 ja 1080e8 <mount+0x288>
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
107e7c: 89 34 24 mov %esi,(%esp)
107e7f: e8 6c 80 00 00 call 10fef0 <rtems_filesystem_get_mount_handler>
107e84: 89 c5 mov %eax,%ebp
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
107e86: 85 c0 test %eax,%eax
107e88: 0f 84 5a 02 00 00 je 1080e8 <mount+0x288>
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
107e8e: 8b 9c 24 94 00 00 00 mov 0x94(%esp),%ebx
107e95: 85 db test %ebx,%ebx
107e97: 0f 84 33 02 00 00 je 1080d0 <mount+0x270>
}
return rv;
}
int mount(
107e9d: 31 c0 xor %eax,%eax
107e9f: b9 ff ff ff ff mov $0xffffffff,%ecx
107ea4: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi
107eab: f2 ae repnz scas %es:(%edi),%al
107ead: f7 d1 not %ecx
107eaf: 89 4c 24 14 mov %ecx,0x14(%esp)
107eb3: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi
107eba: 89 7c 24 1c mov %edi,0x1c(%esp)
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
107ebe: bb ff ff ff ff mov $0xffffffff,%ebx
107ec3: 31 c0 xor %eax,%eax
107ec5: 89 d9 mov %ebx,%ecx
107ec7: 89 f7 mov %esi,%edi
107ec9: f2 ae repnz scas %es:(%edi),%al
107ecb: f7 d1 not %ecx
107ecd: 89 4c 24 10 mov %ecx,0x10(%esp)
107ed1: 89 ca mov %ecx,%edx
107ed3: 4a dec %edx
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
107ed4: 8b 8c 24 90 00 00 00 mov 0x90(%esp),%ecx
107edb: 85 c9 test %ecx,%ecx
107edd: 0f 84 dd 01 00 00 je 1080c0 <mount+0x260>
107ee3: 89 d9 mov %ebx,%ecx
107ee5: 8b bc 24 90 00 00 00 mov 0x90(%esp),%edi
107eec: f2 ae repnz scas %es:(%edi),%al
107eee: f7 d1 not %ecx
107ef0: 89 4c 24 18 mov %ecx,0x18(%esp)
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
107ef4: 8b 4c 24 14 mov 0x14(%esp),%ecx
107ef8: 8d 44 11 65 lea 0x65(%ecx,%edx,1),%eax
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
107efc: 03 44 24 18 add 0x18(%esp),%eax
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107f00: 89 44 24 04 mov %eax,0x4(%esp)
107f04: c7 04 24 01 00 00 00 movl $0x1,(%esp)
107f0b: e8 d8 f7 ff ff call 1076e8 <calloc>
107f10: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
107f12: 85 c0 test %eax,%eax
107f14: 0f 84 8a 01 00 00 je 1080a4 <mount+0x244> <== NEVER TAKEN
rtems_filesystem_global_location_t *mt_fs_root =
107f1a: 8d 50 40 lea 0x40(%eax),%edx
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
107f1d: 8d 40 64 lea 0x64(%eax),%eax
memcpy( str, filesystemtype, filesystemtype_size );
107f20: 89 c7 mov %eax,%edi
107f22: 8b 4c 24 10 mov 0x10(%esp),%ecx
107f26: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107f28: 89 7c 24 10 mov %edi,0x10(%esp)
mt_entry->type = str;
107f2c: 89 43 34 mov %eax,0x34(%ebx)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
107f2f: 8b b4 24 90 00 00 00 mov 0x90(%esp),%esi
107f36: 8b 4c 24 18 mov 0x18(%esp),%ecx
107f3a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107f3c: 89 f8 mov %edi,%eax
mt_entry->dev = str;
107f3e: 8b 7c 24 10 mov 0x10(%esp),%edi
107f42: 89 7b 38 mov %edi,0x38(%ebx)
str += source_size;
memcpy( str, target, target_size );
107f45: 89 c7 mov %eax,%edi
107f47: 8b 74 24 1c mov 0x1c(%esp),%esi
107f4b: 8b 4c 24 14 mov 0x14(%esp),%ecx
107f4f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->target = str;
107f51: 89 43 30 mov %eax,0x30(%ebx)
str += target_size;
mt_entry->mounted = true;
107f54: c6 43 28 01 movb $0x1,0x28(%ebx)
mt_entry->mt_fs_root = mt_fs_root;
107f58: 89 53 24 mov %edx,0x24(%ebx)
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
107f5b: c7 43 2c a0 14 12 00 movl $0x1214a0,0x2c(%ebx)
mt_fs_root->location.mt_entry = mt_entry;
107f62: 89 5b 54 mov %ebx,0x54(%ebx)
mt_fs_root->reference_count = 1;
107f65: c7 43 58 01 00 00 00 movl $0x1,0x58(%ebx)
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize( the_chain, starting_address, number_nodes, node_size );
107f6c: c7 44 24 0c 24 00 00 movl $0x24,0xc(%esp)
107f73: 00
107f74: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
107f7b: 00
107f7c: 89 54 24 04 mov %edx,0x4(%esp)
rtems_chain_initialize(
107f80: 8d 43 14 lea 0x14(%ebx),%eax
107f83: 89 04 24 mov %eax,(%esp)
107f86: e8 41 44 00 00 call 10c3cc <_Chain_Initialize>
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
107f8b: 8a 84 24 9c 00 00 00 mov 0x9c(%esp),%al
107f92: 88 43 29 mov %al,0x29(%ebx)
107f95: 80 63 29 01 andb $0x1,0x29(%ebx)
rv = (*fsmount_me_h)( mt_entry, data );
107f99: 8b 84 24 a0 00 00 00 mov 0xa0(%esp),%eax
107fa0: 89 44 24 04 mov %eax,0x4(%esp)
107fa4: 89 1c 24 mov %ebx,(%esp)
107fa7: ff d5 call *%ebp
107fa9: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
107fab: 85 c0 test %eax,%eax
107fad: 0f 85 99 00 00 00 jne 10804c <mount+0x1ec>
if ( target != NULL ) {
107fb3: 8b 84 24 94 00 00 00 mov 0x94(%esp),%eax
107fba: 85 c0 test %eax,%eax
107fbc: 0f 84 42 01 00 00 je 108104 <mount+0x2a4>
{
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_PERMS_RWX
| RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_location_info_t *currentloc =
107fc2: c7 44 24 08 1f 00 00 movl $0x1f,0x8(%esp)
107fc9: 00
107fca: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi
107fd1: 89 7c 24 04 mov %edi,0x4(%esp)
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
107fd5: 8d 6c 24 38 lea 0x38(%esp),%ebp
107fd9: 89 2c 24 mov %ebp,(%esp)
{
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_PERMS_RWX
| RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_location_info_t *currentloc =
107fdc: e8 0b 0d 00 00 call 108cec <rtems_filesystem_eval_path_start>
static inline bool rtems_filesystem_location_is_root(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
107fe1: 8b 50 14 mov 0x14(%eax),%edx
return (*mt_entry->ops->are_nodes_equal_h)(
107fe4: 8b 4a 0c mov 0xc(%edx),%ecx
107fe7: 8b 52 24 mov 0x24(%edx),%edx
107fea: 89 54 24 04 mov %edx,0x4(%esp)
107fee: 89 04 24 mov %eax,(%esp)
107ff1: ff 51 10 call *0x10(%ecx)
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_root( currentloc ) ) {
107ff4: 84 c0 test %al,%al
107ff6: 0f 85 95 01 00 00 jne 108191 <mount+0x331>
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
107ffc: 8d 44 24 50 lea 0x50(%esp),%eax
108000: 89 44 24 04 mov %eax,0x4(%esp)
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
108004: 8d 74 24 20 lea 0x20(%esp),%esi
108008: 89 34 24 mov %esi,(%esp)
10800b: e8 78 10 00 00 call 109088 <rtems_filesystem_location_copy_and_detach>
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
108010: 89 34 24 mov %esi,(%esp)
108013: e8 0c 12 00 00 call 109224 <rtems_filesystem_location_transform_to_global>
108018: 89 c7 mov %eax,%edi
mt_entry->mt_point_node = mt_point_node;
10801a: 89 43 20 mov %eax,0x20(%ebx)
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
10801d: 8b 40 14 mov 0x14(%eax),%eax
108020: 8b 40 0c mov 0xc(%eax),%eax
108023: 89 1c 24 mov %ebx,(%esp)
108026: ff 50 30 call *0x30(%eax)
108029: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
10802b: 85 c0 test %eax,%eax
10802d: 74 31 je 108060 <mount+0x200>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
10802f: 89 3c 24 mov %edi,(%esp)
108032: e8 0d 11 00 00 call 109144 <rtems_filesystem_global_location_release>
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
108037: 89 2c 24 mov %ebp,(%esp)
10803a: e8 99 0d 00 00 call 108dd8 <rtems_filesystem_eval_path_cleanup>
rv = register_subordinate_file_system( mt_entry, target );
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
10803f: 85 f6 test %esi,%esi
108041: 74 11 je 108054 <mount+0x1f4>
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
108043: 8b 43 0c mov 0xc(%ebx),%eax
108046: 89 1c 24 mov %ebx,(%esp)
108049: ff 50 3c call *0x3c(%eax)
}
}
if ( rv != 0 ) {
free( mt_entry );
10804c: 89 1c 24 mov %ebx,(%esp)
10804f: e8 e8 f8 ff ff call 10793c <free>
errno = EINVAL;
rv = -1;
}
return rv;
}
108054: 89 f0 mov %esi,%eax
108056: 83 c4 7c add $0x7c,%esp
108059: 5b pop %ebx
10805a: 5e pop %esi
10805b: 5f pop %edi
10805c: 5d pop %ebp
10805d: c3 ret
10805e: 66 90 xchg %ax,%ax
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
108060: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
108067: 00
108068: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10806f: 00
108070: a1 dc f4 12 00 mov 0x12f4dc,%eax
108075: 89 04 24 mov %eax,(%esp)
108078: e8 ff 38 00 00 call 10b97c <rtems_semaphore_obtain>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10807d: a1 2c d2 12 00 mov 0x12d22c,%eax
the_node->next = tail;
108082: c7 03 28 d2 12 00 movl $0x12d228,(%ebx)
tail->previous = the_node;
108088: 89 1d 2c d2 12 00 mov %ebx,0x12d22c
old_last->next = the_node;
10808e: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
108090: 89 43 04 mov %eax,0x4(%ebx)
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
108093: a1 dc f4 12 00 mov 0x12f4dc,%eax
108098: 89 04 24 mov %eax,(%esp)
10809b: e8 08 3a 00 00 call 10baa8 <rtems_semaphore_release>
1080a0: eb 95 jmp 108037 <mount+0x1d7>
1080a2: 66 90 xchg %ax,%ax
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
1080a4: e8 4f ac 00 00 call 112cf8 <__errno> <== NOT EXECUTED
1080a9: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
rv = -1;
1080af: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
errno = EINVAL;
rv = -1;
}
return rv;
}
1080b4: 89 f0 mov %esi,%eax <== NOT EXECUTED
1080b6: 83 c4 7c add $0x7c,%esp <== NOT EXECUTED
1080b9: 5b pop %ebx <== NOT EXECUTED
1080ba: 5e pop %esi <== NOT EXECUTED
1080bb: 5f pop %edi <== NOT EXECUTED
1080bc: 5d pop %ebp <== NOT EXECUTED
1080bd: c3 ret <== NOT EXECUTED
1080be: 66 90 xchg %ax,%ax <== NOT EXECUTED
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
1080c0: c7 44 24 18 00 00 00 movl $0x0,0x18(%esp)
1080c7: 00
1080c8: e9 27 fe ff ff jmp 107ef4 <mount+0x94>
1080cd: 8d 76 00 lea 0x0(%esi),%esi
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
1080d0: c7 44 24 14 02 00 00 movl $0x2,0x14(%esp)
1080d7: 00
1080d8: c7 44 24 1c 80 14 12 movl $0x121480,0x1c(%esp)
1080df: 00
1080e0: e9 d9 fd ff ff jmp 107ebe <mount+0x5e>
1080e5: 8d 76 00 lea 0x0(%esi),%esi
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
1080e8: e8 0b ac 00 00 call 112cf8 <__errno>
1080ed: c7 00 16 00 00 00 movl $0x16,(%eax)
rv = -1;
1080f3: be ff ff ff ff mov $0xffffffff,%esi
}
return rv;
}
1080f8: 89 f0 mov %esi,%eax
1080fa: 83 c4 7c add $0x7c,%esp
1080fd: 5b pop %ebx
1080fe: 5e pop %esi
1080ff: 5f pop %edi
108100: 5d pop %ebp
108101: c3 ret
108102: 66 90 xchg %ax,%ax
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
108104: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10810b: 00
10810c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
108113: 00
108114: a1 dc f4 12 00 mov 0x12f4dc,%eax
108119: 89 04 24 mov %eax,(%esp)
10811c: e8 5b 38 00 00 call 10b97c <rtems_semaphore_obtain>
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
108121: 81 3d 24 d2 12 00 28 cmpl $0x12d228,0x12d224
108128: d2 12 00
10812b: 75 7e jne 1081ab <mount+0x34b> <== NEVER TAKEN
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10812d: a1 2c d2 12 00 mov 0x12d22c,%eax
the_node->next = tail;
108132: c7 03 28 d2 12 00 movl $0x12d228,(%ebx)
tail->previous = the_node;
108138: 89 1d 2c d2 12 00 mov %ebx,0x12d22c
old_last->next = the_node;
10813e: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
108140: 89 43 04 mov %eax,0x4(%ebx)
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
108143: a1 dc f4 12 00 mov 0x12f4dc,%eax
108148: 89 04 24 mov %eax,(%esp)
10814b: e8 58 39 00 00 call 10baa8 <rtems_semaphore_release>
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
108150: 83 c3 24 add $0x24,%ebx
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
108153: 89 1c 24 mov %ebx,(%esp)
108156: e8 41 10 00 00 call 10919c <rtems_filesystem_global_location_obtain>
10815b: 89 c7 mov %eax,%edi
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
10815d: 89 1c 24 mov %ebx,(%esp)
108160: e8 37 10 00 00 call 10919c <rtems_filesystem_global_location_obtain>
108165: 89 c3 mov %eax,%ebx
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
108167: 89 7c 24 04 mov %edi,0x4(%esp)
10816b: a1 60 d2 12 00 mov 0x12d260,%eax
108170: 83 c0 04 add $0x4,%eax
108173: 89 04 24 mov %eax,(%esp)
108176: e8 05 10 00 00 call 109180 <rtems_filesystem_global_location_assign>
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
10817b: 89 5c 24 04 mov %ebx,0x4(%esp)
10817f: a1 60 d2 12 00 mov 0x12d260,%eax
108184: 89 04 24 mov %eax,(%esp)
108187: e8 f4 0f 00 00 call 109180 <rtems_filesystem_global_location_assign>
10818c: e9 c3 fe ff ff jmp 108054 <mount+0x1f4>
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
108191: c7 44 24 04 10 00 00 movl $0x10,0x4(%esp)
108198: 00
108199: 89 2c 24 mov %ebp,(%esp)
10819c: e8 93 08 00 00 call 108a34 <rtems_filesystem_eval_path_error>
rv = -1;
1081a1: be ff ff ff ff mov $0xffffffff,%esi
1081a6: e9 8c fe ff ff jmp 108037 <mount+0x1d7>
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
1081ab: e8 48 ab 00 00 call 112cf8 <__errno> <== NOT EXECUTED
1081b0: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
1081b6: a1 dc f4 12 00 mov 0x12f4dc,%eax <== NOT EXECUTED
1081bb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1081be: e8 e5 38 00 00 call 10baa8 <rtems_semaphore_release><== NOT EXECUTED
rv = -1;
1081c3: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
1081c8: e9 76 fe ff ff jmp 108043 <mount+0x1e3> <== NOT EXECUTED
0010c8fc <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
10c8fc: 55 push %ebp
10c8fd: 57 push %edi
10c8fe: 56 push %esi
10c8ff: 53 push %ebx
10c900: 83 ec 2c sub $0x2c,%esp
10c903: 8b 44 24 40 mov 0x40(%esp),%eax
10c907: 89 44 24 1c mov %eax,0x1c(%esp)
10c90b: 8b 5c 24 44 mov 0x44(%esp),%ebx
10c90f: 8b 74 24 48 mov 0x48(%esp),%esi
10c913: 8b 7c 24 4c mov 0x4c(%esp),%edi
10c917: 8b 6c 24 50 mov 0x50(%esp),%ebp
int rv = -1;
if (target != NULL) {
10c91b: 85 db test %ebx,%ebx
10c91d: 74 41 je 10c960 <mount_and_make_target_path+0x64>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
10c91f: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp)
10c926: 00
10c927: 89 1c 24 mov %ebx,(%esp)
10c92a: e8 ad 0c 00 00 call 10d5dc <rtems_mkdir>
if (rv == 0) {
10c92f: 85 c0 test %eax,%eax
10c931: 74 09 je 10c93c <mount_and_make_target_path+0x40><== ALWAYS TAKEN
} else {
errno = EINVAL;
}
return rv;
}
10c933: 83 c4 2c add $0x2c,%esp
10c936: 5b pop %ebx
10c937: 5e pop %esi
10c938: 5f pop %edi
10c939: 5d pop %ebp
10c93a: c3 ret
10c93b: 90 nop
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
10c93c: 89 6c 24 50 mov %ebp,0x50(%esp)
10c940: 89 7c 24 4c mov %edi,0x4c(%esp)
10c944: 89 74 24 48 mov %esi,0x48(%esp)
10c948: 89 5c 24 44 mov %ebx,0x44(%esp)
10c94c: 8b 44 24 1c mov 0x1c(%esp),%eax
10c950: 89 44 24 40 mov %eax,0x40(%esp)
} else {
errno = EINVAL;
}
return rv;
}
10c954: 83 c4 2c add $0x2c,%esp
10c957: 5b pop %ebx
10c958: 5e pop %esi
10c959: 5f pop %edi
10c95a: 5d pop %ebp
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
10c95b: e9 14 00 00 00 jmp 10c974 <mount>
options,
data
);
}
} else {
errno = EINVAL;
10c960: e8 e7 85 01 00 call 124f4c <__errno>
10c965: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
10c96b: b8 ff ff ff ff mov $0xffffffff,%eax
10c970: eb c1 jmp 10c933 <mount_and_make_target_path+0x37>
00108518 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
108518: 56 push %esi
108519: 53 push %ebx
10851a: 83 ec 14 sub $0x14,%esp
10851d: 8b 5c 24 24 mov 0x24(%esp),%ebx
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
108521: 39 5c 24 20 cmp %ebx,0x20(%esp)
108525: 74 51 je 108578 <newlib_delete_hook+0x60>
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
108527: 8b b3 dc 00 00 00 mov 0xdc(%ebx),%esi
}
if (ptr && ptr != _global_impure_ptr) {
10852d: 85 f6 test %esi,%esi
10852f: 74 20 je 108551 <newlib_delete_hook+0x39><== NEVER TAKEN
108531: 3b 35 20 20 12 00 cmp 0x122020,%esi
108537: 74 18 je 108551 <newlib_delete_hook+0x39>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
108539: c7 44 24 04 4c 82 10 movl $0x10824c,0x4(%esp)
108540: 00
108541: 89 34 24 mov %esi,(%esp)
108544: e8 03 af 00 00 call 11344c <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
108549: 89 34 24 mov %esi,(%esp)
10854c: e8 d7 66 00 00 call 10ec28 <_Workspace_Free>
#endif
}
deleted_task->libc_reent = NULL;
108551: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
108558: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
10855b: 39 5c 24 20 cmp %ebx,0x20(%esp)
10855f: 74 07 je 108568 <newlib_delete_hook+0x50>
_REENT = 0;
}
}
108561: 83 c4 14 add $0x14,%esp
108564: 5b pop %ebx
108565: 5e pop %esi
108566: c3 ret
108567: 90 nop
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
_REENT = 0;
108568: c7 05 20 d4 12 00 00 movl $0x0,0x12d420
10856f: 00 00 00
}
}
108572: 83 c4 14 add $0x14,%esp
108575: 5b pop %ebx
108576: 5e pop %esi
108577: c3 ret
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
108578: 8b 35 20 d4 12 00 mov 0x12d420,%esi
10857e: eb ad jmp 10852d <newlib_delete_hook+0x15>
0010824c <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
10824c: 53 push %ebx
10824d: 83 ec 18 sub $0x18,%esp
108250: 8b 5c 24 20 mov 0x20(%esp),%ebx
switch ( fileno(fp) ) {
108254: 89 1c 24 mov %ebx,(%esp)
108257: e8 40 ae 00 00 call 11309c <fileno>
10825c: 83 f8 02 cmp $0x2,%eax
10825f: 76 0f jbe 108270 <newlib_free_buffers+0x24><== ALWAYS TAKEN
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
108261: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
108264: e8 ab ab 00 00 call 112e14 <fclose> <== NOT EXECUTED
}
return 0;
}
108269: 31 c0 xor %eax,%eax
10826b: 83 c4 18 add $0x18,%esp
10826e: 5b pop %ebx
10826f: c3 ret
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
108270: f6 43 0c 80 testb $0x80,0xc(%ebx)
108274: 74 f3 je 108269 <newlib_free_buffers+0x1d><== ALWAYS TAKEN
free( fp->_bf._base );
108276: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
108279: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10827c: e8 bb f6 ff ff call 10793c <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
108281: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
108287: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
10828d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
108294: 31 c0 xor %eax,%eax <== NOT EXECUTED
108296: 83 c4 18 add $0x18,%esp <== NOT EXECUTED
108299: 5b pop %ebx <== NOT EXECUTED
10829a: c3 ret <== NOT EXECUTED
0010af64 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
10af64: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10af69: c3 ret <== NOT EXECUTED
0010af74 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
10af74: c3 ret <== NOT EXECUTED
0010af3c <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
10af3c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10af41: c3 ret <== NOT EXECUTED
0010af5c <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
10af5c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10af61: c3 ret <== NOT EXECUTED
0010af88 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
10af88: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10af8d: c3 ret <== NOT EXECUTED
0010af90 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
10af90: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10af95: c3 ret <== NOT EXECUTED
0010a190 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
10a190: 56 push %esi
10a191: 53 push %ebx
10a192: 83 ec 24 sub $0x24,%esp
10a195: 88 44 24 1c mov %al,0x1c(%esp)
int i;
if (tty->termios.c_oflag & OPOST) {
10a199: 8b 4a 34 mov 0x34(%edx),%ecx
10a19c: f6 c1 01 test $0x1,%cl
10a19f: 74 4b je 10a1ec <oproc+0x5c> <== NEVER TAKEN
switch (c) {
10a1a1: 3c 09 cmp $0x9,%al
10a1a3: 0f 84 b3 00 00 00 je 10a25c <oproc+0xcc>
10a1a9: 76 61 jbe 10a20c <oproc+0x7c> <== NEVER TAKEN
10a1ab: 3c 0a cmp $0xa,%al
10a1ad: 74 71 je 10a220 <oproc+0x90>
10a1af: 3c 0d cmp $0xd,%al
10a1b1: 0f 84 cd 00 00 00 je 10a284 <oproc+0xf4> <== NEVER TAKEN
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
10a1b7: 83 e1 02 and $0x2,%ecx
c = toupper(c);
10a1ba: 8b 0d 08 d4 12 00 mov 0x12d408,%ecx
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
10a1c0: 74 1b je 10a1dd <oproc+0x4d> <== ALWAYS TAKEN
c = toupper(c);
10a1c2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10a1c5: 8a 5c 01 01 mov 0x1(%ecx,%eax,1),%bl <== NOT EXECUTED
10a1c9: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED
10a1cc: 80 fb 02 cmp $0x2,%bl <== NOT EXECUTED
10a1cf: 0f 84 df 00 00 00 je 10a2b4 <oproc+0x124> <== NOT EXECUTED
10a1d5: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10a1d7: 88 d8 mov %bl,%al <== NOT EXECUTED
10a1d9: 88 5c 24 1c mov %bl,0x1c(%esp) <== NOT EXECUTED
if (!iscntrl(c))
10a1dd: 0f b6 c0 movzbl %al,%eax
10a1e0: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1)
10a1e5: 75 05 jne 10a1ec <oproc+0x5c> <== NEVER TAKEN
tty->column++;
10a1e7: ff 42 28 incl 0x28(%edx)
10a1ea: 66 90 xchg %ax,%ax
break;
}
}
rtems_termios_puts (&c, 1, tty);
10a1ec: 89 54 24 08 mov %edx,0x8(%esp)
10a1f0: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10a1f7: 00
10a1f8: 8d 44 24 1c lea 0x1c(%esp),%eax
10a1fc: 89 04 24 mov %eax,(%esp)
10a1ff: e8 48 fe ff ff call 10a04c <rtems_termios_puts>
}
10a204: 83 c4 24 add $0x24,%esp
10a207: 5b pop %ebx
10a208: 5e pop %esi
10a209: c3 ret
10a20a: 66 90 xchg %ax,%ax
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
10a20c: 3c 08 cmp $0x8,%al <== NOT EXECUTED
10a20e: 75 a7 jne 10a1b7 <oproc+0x27> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
10a210: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
10a213: 85 c0 test %eax,%eax <== NOT EXECUTED
10a215: 7e d5 jle 10a1ec <oproc+0x5c> <== NOT EXECUTED
tty->column--;
10a217: 48 dec %eax <== NOT EXECUTED
10a218: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED
10a21b: eb cf jmp 10a1ec <oproc+0x5c> <== NOT EXECUTED
10a21d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
10a220: f6 c1 20 test $0x20,%cl
10a223: 74 07 je 10a22c <oproc+0x9c> <== ALWAYS TAKEN
tty->column = 0;
10a225: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
10a22c: 83 e1 04 and $0x4,%ecx
10a22f: 74 bb je 10a1ec <oproc+0x5c> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
10a231: 89 54 24 08 mov %edx,0x8(%esp)
10a235: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10a23c: 00
10a23d: c7 04 24 5c 16 12 00 movl $0x12165c,(%esp)
10a244: 89 54 24 18 mov %edx,0x18(%esp)
10a248: e8 ff fd ff ff call 10a04c <rtems_termios_puts>
tty->column = 0;
10a24d: 8b 54 24 18 mov 0x18(%esp),%edx
10a251: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx)
10a258: eb 92 jmp 10a1ec <oproc+0x5c>
10a25a: 66 90 xchg %ax,%ax
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
10a25c: 8b 5a 28 mov 0x28(%edx),%ebx
10a25f: 89 de mov %ebx,%esi
10a261: 83 e6 07 and $0x7,%esi
10a264: b8 08 00 00 00 mov $0x8,%eax
10a269: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
10a26b: 81 e1 00 18 00 00 and $0x1800,%ecx
10a271: 81 f9 00 18 00 00 cmp $0x1800,%ecx
10a277: 74 43 je 10a2bc <oproc+0x12c> <== ALWAYS TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
10a279: 01 d8 add %ebx,%eax <== NOT EXECUTED
10a27b: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED
break;
10a27e: e9 69 ff ff ff jmp 10a1ec <oproc+0x5c> <== NOT EXECUTED
10a283: 90 nop <== NOT EXECUTED
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
10a284: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
10a287: 74 0b je 10a294 <oproc+0x104> <== NOT EXECUTED
10a289: 8b 5a 28 mov 0x28(%edx),%ebx <== NOT EXECUTED
10a28c: 85 db test %ebx,%ebx <== NOT EXECUTED
10a28e: 0f 84 70 ff ff ff je 10a204 <oproc+0x74> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
10a294: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
10a297: 74 0e je 10a2a7 <oproc+0x117> <== NOT EXECUTED
c = '\n';
10a299: c6 44 24 1c 0a movb $0xa,0x1c(%esp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
10a29e: 83 e1 20 and $0x20,%ecx <== NOT EXECUTED
10a2a1: 0f 84 45 ff ff ff je 10a1ec <oproc+0x5c> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
10a2a7: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
break;
10a2ae: e9 39 ff ff ff jmp 10a1ec <oproc+0x5c> <== NOT EXECUTED
10a2b3: 90 nop <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
10a2b4: 8d 58 e0 lea -0x20(%eax),%ebx <== NOT EXECUTED
10a2b7: e9 1b ff ff ff jmp 10a1d7 <oproc+0x47> <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
10a2bc: 01 c3 add %eax,%ebx
10a2be: 89 5a 28 mov %ebx,0x28(%edx)
rtems_termios_puts ( " ", i, tty);
10a2c1: 89 54 24 08 mov %edx,0x8(%esp)
10a2c5: 89 44 24 04 mov %eax,0x4(%esp)
10a2c9: c7 04 24 70 0a 12 00 movl $0x120a70,(%esp)
10a2d0: e8 77 fd ff ff call 10a04c <rtems_termios_puts>
return;
10a2d5: e9 2a ff ff ff jmp 10a204 <oproc+0x74>
0010614c <pathconf>:
long pathconf(
const char *path,
int name
)
{
10614c: 56 push %esi
10614d: 53 push %ebx
10614e: 83 ec 14 sub $0x14,%esp
int status;
int fd;
fd = open( path, O_RDONLY );
106151: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
106158: 00
106159: 8b 44 24 20 mov 0x20(%esp),%eax
10615d: 89 04 24 mov %eax,(%esp)
106160: e8 7b fd ff ff call 105ee0 <open>
106165: 89 c3 mov %eax,%ebx
if ( fd == -1 )
106167: 83 f8 ff cmp $0xffffffff,%eax
10616a: 74 24 je 106190 <pathconf+0x44> <== ALWAYS TAKEN
return -1;
status = fpathconf( fd, name );
10616c: 8b 44 24 24 mov 0x24(%esp),%eax <== NOT EXECUTED
106170: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106174: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
106177: e8 68 4b 00 00 call 10ace4 <fpathconf> <== NOT EXECUTED
10617c: 89 c6 mov %eax,%esi <== NOT EXECUTED
(void) close( fd );
10617e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
106181: e8 fa 4a 00 00 call 10ac80 <close> <== NOT EXECUTED
return status;
}
106186: 89 f0 mov %esi,%eax
106188: 83 c4 14 add $0x14,%esp
10618b: 5b pop %ebx
10618c: 5e pop %esi
10618d: c3 ret
10618e: 66 90 xchg %ax,%ax
int status;
int fd;
fd = open( path, O_RDONLY );
if ( fd == -1 )
return -1;
106190: be ff ff ff ff mov $0xffffffff,%esi
106195: eb ef jmp 106186 <pathconf+0x3a>
0010b7c8 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10b7c8: 53 push %ebx
10b7c9: 8b 44 24 0c mov 0xc(%esp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10b7cd: ff 05 c8 72 13 00 incl 0x1372c8
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10b7d3: 8d 50 ff lea -0x1(%eax),%edx
10b7d6: 85 c2 test %eax,%edx
10b7d8: 74 0a je 10b7e4 <posix_memalign+0x1c> <== ALWAYS TAKEN
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
10b7da: b8 16 00 00 00 mov $0x16,%eax
10b7df: 5b pop %ebx
10b7e0: c3 ret
10b7e1: 8d 76 00 lea 0x0(%esi),%esi
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10b7e4: 83 f8 03 cmp $0x3,%eax
10b7e7: 76 f1 jbe 10b7da <posix_memalign+0x12>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
10b7e9: 5b pop %ebx
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10b7ea: e9 b9 01 00 00 jmp 10b9a8 <rtems_memalign>
0011f628 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11f628: 53 push %ebx
11f629: 83 ec 08 sub $0x8,%esp
11f62c: 8b 44 24 10 mov 0x10(%esp),%eax
11f630: 8b 54 24 14 mov 0x14(%esp),%edx
11f634: 8b 4c 24 18 mov 0x18(%esp),%ecx
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11f638: 3b 05 c0 b2 12 00 cmp 0x12b2c0,%eax
11f63e: 73 44 jae 11f684 <read+0x5c>
iop = rtems_libio_iop( fd );
11f640: 8d 04 40 lea (%eax,%eax,2),%eax
11f643: c1 e0 04 shl $0x4,%eax
11f646: 03 05 d4 f4 12 00 add 0x12f4d4,%eax
rtems_libio_check_is_open( iop );
11f64c: 8b 58 0c mov 0xc(%eax),%ebx
11f64f: f6 c7 01 test $0x1,%bh
11f652: 74 30 je 11f684 <read+0x5c>
rtems_libio_check_buffer( buffer );
11f654: 85 d2 test %edx,%edx
11f656: 74 3e je 11f696 <read+0x6e> <== NEVER TAKEN
rtems_libio_check_count( count );
11f658: 85 c9 test %ecx,%ecx
11f65a: 74 20 je 11f67c <read+0x54>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
11f65c: 83 e3 02 and $0x2,%ebx
11f65f: 74 23 je 11f684 <read+0x5c>
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11f661: 8b 58 20 mov 0x20(%eax),%ebx
11f664: 89 4c 24 18 mov %ecx,0x18(%esp)
11f668: 89 54 24 14 mov %edx,0x14(%esp)
11f66c: 89 44 24 10 mov %eax,0x10(%esp)
11f670: 8b 43 08 mov 0x8(%ebx),%eax
}
11f673: 83 c4 08 add $0x8,%esp
11f676: 5b pop %ebx
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11f677: ff e0 jmp *%eax
11f679: 8d 76 00 lea 0x0(%esi),%esi
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
11f67c: 31 c0 xor %eax,%eax
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
}
11f67e: 83 c4 08 add $0x8,%esp
11f681: 5b pop %ebx
11f682: c3 ret
11f683: 90 nop
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
11f684: e8 6f 36 ff ff call 112cf8 <__errno>
11f689: c7 00 09 00 00 00 movl $0x9,(%eax)
11f68f: b8 ff ff ff ff mov $0xffffffff,%eax
11f694: eb e8 jmp 11f67e <read+0x56>
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
11f696: e8 5d 36 ff ff call 112cf8 <__errno> <== NOT EXECUTED
11f69b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
11f6a1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
11f6a6: eb d6 jmp 11f67e <read+0x56> <== NOT EXECUTED
0010940c <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10940c: 55 push %ebp
10940d: 57 push %edi
10940e: 56 push %esi
10940f: 53 push %ebx
109410: 83 ec 2c sub $0x2c,%esp
109413: 8b 54 24 40 mov 0x40(%esp),%edx
109417: 8b 5c 24 44 mov 0x44(%esp),%ebx
10941b: 8b 44 24 48 mov 0x48(%esp),%eax
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
10941f: 3b 15 c0 c2 12 00 cmp 0x12c2c0,%edx
109425: 0f 83 bf 00 00 00 jae 1094ea <readv+0xde>
iop = rtems_libio_iop( fd );
10942b: 8d 3c 52 lea (%edx,%edx,2),%edi
10942e: c1 e7 04 shl $0x4,%edi
109431: 03 3d d4 04 13 00 add 0x1304d4,%edi
rtems_libio_check_is_open( iop );
109437: 8b 57 0c mov 0xc(%edi),%edx
10943a: f6 c6 01 test $0x1,%dh
10943d: 0f 84 a7 00 00 00 je 1094ea <readv+0xde>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
109443: 83 e2 02 and $0x2,%edx
109446: 0f 84 9e 00 00 00 je 1094ea <readv+0xde> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10944c: 85 db test %ebx,%ebx
10944e: 74 4c je 10949c <readv+0x90>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
109450: 85 c0 test %eax,%eax
109452: 7e 48 jle 10949c <readv+0x90>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
109454: 3d 00 04 00 00 cmp $0x400,%eax
109459: 7f 41 jg 10949c <readv+0x90> <== NEVER TAKEN
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
10945b: 8d 34 c3 lea (%ebx,%eax,8),%esi
10945e: 89 d8 mov %ebx,%eax
109460: c6 44 24 1f 01 movb $0x1,0x1f(%esp)
109465: 31 d2 xor %edx,%edx
109467: eb 05 jmp 10946e <readv+0x62>
109469: 8d 76 00 lea 0x0(%esi),%esi
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
10946c: 89 ea mov %ebp,%edx
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
10946e: 8b 08 mov (%eax),%ecx
109470: 85 c9 test %ecx,%ecx
109472: 74 28 je 10949c <readv+0x90>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
109474: 8b 48 04 mov 0x4(%eax),%ecx
109477: 8d 2c 11 lea (%ecx,%edx,1),%ebp
if ( total < old )
10947a: 39 d5 cmp %edx,%ebp
10947c: 7c 1e jl 10949c <readv+0x90>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
10947e: 85 c9 test %ecx,%ecx
109480: 74 05 je 109487 <readv+0x7b>
all_zeros = false;
109482: c6 44 24 1f 00 movb $0x0,0x1f(%esp)
109487: 83 c0 08 add $0x8,%eax
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10948a: 39 f0 cmp %esi,%eax
10948c: 75 de jne 10946c <readv+0x60>
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
return 0;
10948e: 31 ed xor %ebp,%ebp
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
109490: 80 7c 24 1f 00 cmpb $0x0,0x1f(%esp)
109495: 74 31 je 1094c8 <readv+0xbc>
109497: eb 13 jmp 1094ac <readv+0xa0>
109499: 8d 76 00 lea 0x0(%esi),%esi
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
10949c: e8 7b a3 00 00 call 11381c <__errno>
1094a1: c7 00 16 00 00 00 movl $0x16,(%eax)
1094a7: bd ff ff ff ff mov $0xffffffff,%ebp
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
1094ac: 89 e8 mov %ebp,%eax
1094ae: 83 c4 2c add $0x2c,%esp
1094b1: 5b pop %ebx
1094b2: 5e pop %esi
1094b3: 5f pop %edi
1094b4: 5d pop %ebp
1094b5: c3 ret
1094b6: 66 90 xchg %ax,%ax
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
1094b8: 74 02 je 1094bc <readv+0xb0> <== NEVER TAKEN
total += bytes;
1094ba: 01 c5 add %eax,%ebp
}
if (bytes != iov[ v ].iov_len)
1094bc: 3b 43 04 cmp 0x4(%ebx),%eax
1094bf: 75 eb jne 1094ac <readv+0xa0> <== NEVER TAKEN
1094c1: 83 c3 08 add $0x8,%ebx
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
1094c4: 39 f3 cmp %esi,%ebx
1094c6: 74 e4 je 1094ac <readv+0xa0>
bytes = (*iop->pathinfo.handlers->read_h)(
1094c8: 8b 47 20 mov 0x20(%edi),%eax
1094cb: 8b 53 04 mov 0x4(%ebx),%edx
1094ce: 89 54 24 08 mov %edx,0x8(%esp)
1094d2: 8b 13 mov (%ebx),%edx
1094d4: 89 54 24 04 mov %edx,0x4(%esp)
1094d8: 89 3c 24 mov %edi,(%esp)
1094db: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
1094de: 83 f8 00 cmp $0x0,%eax
1094e1: 7d d5 jge 1094b8 <readv+0xac> <== ALWAYS TAKEN
return -1;
1094e3: bd ff ff ff ff mov $0xffffffff,%ebp <== NOT EXECUTED
1094e8: eb c2 jmp 1094ac <readv+0xa0> <== NOT EXECUTED
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
1094ea: e8 2d a3 00 00 call 11381c <__errno>
1094ef: c7 00 09 00 00 00 movl $0x9,(%eax)
1094f5: bd ff ff ff ff mov $0xffffffff,%ebp
1094fa: eb b0 jmp 1094ac <readv+0xa0>
00108884 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
108884: 55 push %ebp
108885: 57 push %edi
108886: 56 push %esi
108887: 53 push %ebx
108888: 83 ec 2c sub $0x2c,%esp
10888b: 8b 5c 24 40 mov 0x40(%esp),%ebx
10888f: 8b 74 24 44 mov 0x44(%esp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
108893: ff 05 10 f5 12 00 incl 0x12f510
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
108899: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760
1088a0: 0f 84 8e 00 00 00 je 108934 <realloc+0xb0>
}
/*
* Continue with realloc().
*/
if ( !ptr )
1088a6: 85 db test %ebx,%ebx
1088a8: 0f 84 de 00 00 00 je 10898c <realloc+0x108>
return malloc( size );
if ( !size ) {
1088ae: 85 f6 test %esi,%esi
1088b0: 0f 84 b6 00 00 00 je 10896c <realloc+0xe8> <== NEVER TAKEN
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
1088b6: 8d 44 24 1c lea 0x1c(%esp),%eax
1088ba: 89 44 24 08 mov %eax,0x8(%esp)
1088be: 89 5c 24 04 mov %ebx,0x4(%esp)
1088c2: a1 6c b2 12 00 mov 0x12b26c,%eax
1088c7: 89 04 24 mov %eax,(%esp)
1088ca: e8 69 4b 00 00 call 10d438 <_Protected_heap_Get_block_size>
1088cf: 84 c0 test %al,%al
1088d1: 0f 84 a5 00 00 00 je 10897c <realloc+0xf8>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
1088d7: 89 74 24 08 mov %esi,0x8(%esp)
1088db: 89 5c 24 04 mov %ebx,0x4(%esp)
1088df: a1 6c b2 12 00 mov 0x12b26c,%eax
1088e4: 89 04 24 mov %eax,(%esp)
1088e7: e8 9c 4b 00 00 call 10d488 <_Protected_heap_Resize_block>
1088ec: 84 c0 test %al,%al
1088ee: 74 0c je 1088fc <realloc+0x78>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
1088f0: 89 d8 mov %ebx,%eax
1088f2: 83 c4 2c add $0x2c,%esp
1088f5: 5b pop %ebx
1088f6: 5e pop %esi
1088f7: 5f pop %edi
1088f8: 5d pop %ebp
1088f9: c3 ret
1088fa: 66 90 xchg %ax,%ax
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
1088fc: 89 34 24 mov %esi,(%esp)
1088ff: e8 4c f3 ff ff call 107c50 <malloc>
108904: 89 c5 mov %eax,%ebp
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
108906: ff 0d 04 f5 12 00 decl 0x12f504
if ( !new_area ) {
10890c: 85 c0 test %eax,%eax
10890e: 74 3c je 10894c <realloc+0xc8>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
108910: 8b 44 24 1c mov 0x1c(%esp),%eax
108914: 89 f1 mov %esi,%ecx
108916: 39 c6 cmp %eax,%esi
108918: 77 3e ja 108958 <realloc+0xd4> <== ALWAYS TAKEN
10891a: 89 ef mov %ebp,%edi <== NOT EXECUTED
10891c: 89 de mov %ebx,%esi <== NOT EXECUTED
10891e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
free( ptr );
108920: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
108923: e8 14 f0 ff ff call 10793c <free> <== NOT EXECUTED
108928: 89 eb mov %ebp,%ebx <== NOT EXECUTED
return new_area;
}
10892a: 89 d8 mov %ebx,%eax
10892c: 83 c4 2c add $0x2c,%esp
10892f: 5b pop %ebx
108930: 5e pop %esi
108931: 5f pop %edi
108932: 5d pop %ebp
108933: c3 ret
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
108934: a1 04 f6 12 00 mov 0x12f604,%eax
108939: 85 c0 test %eax,%eax
10893b: 75 0f jne 10894c <realloc+0xc8> <== NEVER TAKEN
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
10893d: a1 68 f8 12 00 mov 0x12f868,%eax
108942: 85 c0 test %eax,%eax
108944: 0f 84 5c ff ff ff je 1088a6 <realloc+0x22> <== ALWAYS TAKEN
10894a: 66 90 xchg %ax,%ax
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
10894c: 31 db xor %ebx,%ebx
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
10894e: 89 d8 mov %ebx,%eax
108950: 83 c4 2c add $0x2c,%esp
108953: 5b pop %ebx
108954: 5e pop %esi
108955: 5f pop %edi
108956: 5d pop %ebp
108957: c3 ret
if ( !new_area ) {
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
108958: 89 c1 mov %eax,%ecx
10895a: 89 ef mov %ebp,%edi
10895c: 89 de mov %ebx,%esi
10895e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
108960: 89 1c 24 mov %ebx,(%esp)
108963: e8 d4 ef ff ff call 10793c <free>
108968: 89 eb mov %ebp,%ebx
10896a: eb be jmp 10892a <realloc+0xa6>
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
10896c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10896f: e8 c8 ef ff ff call 10793c <free> <== NOT EXECUTED
return (void *) 0;
108974: 31 db xor %ebx,%ebx <== NOT EXECUTED
108976: e9 75 ff ff ff jmp 1088f0 <realloc+0x6c> <== NOT EXECUTED
10897b: 90 nop <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
10897c: e8 77 a3 00 00 call 112cf8 <__errno>
108981: c7 00 16 00 00 00 movl $0x16,(%eax)
return (void *) 0;
108987: 31 db xor %ebx,%ebx
108989: eb c3 jmp 10894e <realloc+0xca>
10898b: 90 nop
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
10898c: 89 74 24 40 mov %esi,0x40(%esp)
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
108990: 83 c4 2c add $0x2c,%esp
108993: 5b pop %ebx
108994: 5e pop %esi
108995: 5f pop %edi
108996: 5d pop %ebp
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
108997: e9 b4 f2 ff ff jmp 107c50 <malloc>
00112650 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
112650: 55 push %ebp
112651: 57 push %edi
112652: 56 push %esi
112653: 53 push %ebx
112654: 83 ec 1c sub $0x1c,%esp
112657: 8b 74 24 34 mov 0x34(%esp),%esi
11265b: bd 20 00 00 00 mov $0x20,%ebp
uint32_t b;
uint32_t local_value = 0;
112660: 31 ff xor %edi,%edi
for (b = 1; b; b <<= 1) {
112662: bb 01 00 00 00 mov $0x1,%ebx
112667: eb 08 jmp 112671 <rtems_assoc_local_by_remote_bitfield+0x21>
112669: 8d 76 00 lea 0x0(%esi),%esi
11266c: d1 e3 shl %ebx
11266e: 4d dec %ebp
11266f: 74 1b je 11268c <rtems_assoc_local_by_remote_bitfield+0x3c>
if (b & remote_value)
112671: 85 f3 test %esi,%ebx
112673: 74 f7 je 11266c <rtems_assoc_local_by_remote_bitfield+0x1c>
local_value |= rtems_assoc_local_by_remote(ap, b);
112675: 89 5c 24 04 mov %ebx,0x4(%esp)
112679: 8b 44 24 30 mov 0x30(%esp),%eax
11267d: 89 04 24 mov %eax,(%esp)
112680: e8 f7 d3 ff ff call 10fa7c <rtems_assoc_local_by_remote>
112685: 09 c7 or %eax,%edi
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
112687: d1 e3 shl %ebx
112689: 4d dec %ebp
11268a: 75 e5 jne 112671 <rtems_assoc_local_by_remote_bitfield+0x21><== ALWAYS TAKEN
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
11268c: 89 f8 mov %edi,%eax
11268e: 83 c4 1c add $0x1c,%esp
112691: 5b pop %ebx
112692: 5e pop %esi
112693: 5f pop %edi
112694: 5d pop %ebp
112695: c3 ret
0010fadc <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10fadc: 57 push %edi
10fadd: 56 push %esi
10fade: 53 push %ebx
10fadf: 8b 44 24 10 mov 0x10(%esp),%eax
10fae3: 8b 54 24 14 mov 0x14(%esp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10fae7: 8b 30 mov (%eax),%esi
10fae9: 85 f6 test %esi,%esi
10faeb: 74 3f je 10fb2c <rtems_assoc_ptr_by_local+0x50>
10faed: bf 2c 1c 12 00 mov $0x121c2c,%edi
10faf2: b9 0a 00 00 00 mov $0xa,%ecx
10faf7: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10faf9: 74 19 je 10fb14 <rtems_assoc_ptr_by_local+0x38>
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
10fafb: 31 c9 xor %ecx,%ecx
10fafd: eb 0a jmp 10fb09 <rtems_assoc_ptr_by_local+0x2d>
10faff: 90 nop
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10fb00: 83 c0 0c add $0xc,%eax
10fb03: 8b 18 mov (%eax),%ebx
10fb05: 85 db test %ebx,%ebx
10fb07: 74 1b je 10fb24 <rtems_assoc_ptr_by_local+0x48>
if (ap->local_value == local_value)
10fb09: 39 50 04 cmp %edx,0x4(%eax)
10fb0c: 75 f2 jne 10fb00 <rtems_assoc_ptr_by_local+0x24>
return ap;
return default_ap;
}
10fb0e: 5b pop %ebx
10fb0f: 5e pop %esi
10fb10: 5f pop %edi
10fb11: c3 ret
10fb12: 66 90 xchg %ax,%ax
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fb14: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
10fb17: 8b 70 0c mov 0xc(%eax),%esi
10fb1a: 85 f6 test %esi,%esi
10fb1c: 74 f0 je 10fb0e <rtems_assoc_ptr_by_local+0x32><== NEVER TAKEN
10fb1e: 89 c1 mov %eax,%ecx
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fb20: 89 d8 mov %ebx,%eax
10fb22: eb e5 jmp 10fb09 <rtems_assoc_ptr_by_local+0x2d>
for ( ; ap->name; ap++)
10fb24: 89 c8 mov %ecx,%eax
if (ap->local_value == local_value)
return ap;
return default_ap;
}
10fb26: 5b pop %ebx
10fb27: 5e pop %esi
10fb28: 5f pop %edi
10fb29: c3 ret
10fb2a: 66 90 xchg %ax,%ax
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
10fb2c: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
10fb2e: 5b pop %ebx
10fb2f: 5e pop %esi
10fb30: 5f pop %edi
10fb31: c3 ret
001081d4 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
1081d4: 55 push %ebp
1081d5: 57 push %edi
1081d6: 56 push %esi
1081d7: 53 push %ebx
1081d8: 83 ec 1c sub $0x1c,%esp
1081db: 8b 5c 24 30 mov 0x30(%esp),%ebx
1081df: 8b 6c 24 34 mov 0x34(%esp),%ebp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
1081e3: 8b 03 mov (%ebx),%eax
1081e5: 85 c0 test %eax,%eax
1081e7: 74 57 je 108240 <rtems_assoc_ptr_by_name+0x6c>
1081e9: bf 42 0a 12 00 mov $0x120a42,%edi
1081ee: b9 0a 00 00 00 mov $0xa,%ecx
1081f3: 89 c6 mov %eax,%esi
1081f5: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
1081f7: 74 2b je 108224 <rtems_assoc_ptr_by_name+0x50>
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
1081f9: 31 f6 xor %esi,%esi
1081fb: eb 0c jmp 108209 <rtems_assoc_ptr_by_name+0x35>
1081fd: 8d 76 00 lea 0x0(%esi),%esi
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
108200: 83 c3 0c add $0xc,%ebx
108203: 8b 03 mov (%ebx),%eax
108205: 85 c0 test %eax,%eax
108207: 74 2b je 108234 <rtems_assoc_ptr_by_name+0x60>
if (strcmp(ap->name, name) == 0)
108209: 89 6c 24 04 mov %ebp,0x4(%esp)
10820d: 89 04 24 mov %eax,(%esp)
108210: e8 57 c3 00 00 call 11456c <strcmp>
108215: 85 c0 test %eax,%eax
108217: 75 e7 jne 108200 <rtems_assoc_ptr_by_name+0x2c>
return ap;
return default_ap;
}
108219: 89 d8 mov %ebx,%eax
10821b: 83 c4 1c add $0x1c,%esp
10821e: 5b pop %ebx
10821f: 5e pop %esi
108220: 5f pop %edi
108221: 5d pop %ebp
108222: c3 ret
108223: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
108224: 8d 53 0c lea 0xc(%ebx),%edx
for ( ; ap->name; ap++)
108227: 8b 43 0c mov 0xc(%ebx),%eax
10822a: 85 c0 test %eax,%eax
10822c: 74 eb je 108219 <rtems_assoc_ptr_by_name+0x45><== NEVER TAKEN
10822e: 89 de mov %ebx,%esi
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
108230: 89 d3 mov %edx,%ebx
108232: eb d5 jmp 108209 <rtems_assoc_ptr_by_name+0x35>
for ( ; ap->name; ap++)
108234: 89 f3 mov %esi,%ebx
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
108236: 89 d8 mov %ebx,%eax
108238: 83 c4 1c add $0x1c,%esp
10823b: 5b pop %ebx
10823c: 5e pop %esi
10823d: 5f pop %edi
10823e: 5d pop %ebp
10823f: c3 ret
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
108240: 31 db xor %ebx,%ebx
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
108242: 89 d8 mov %ebx,%eax
108244: 83 c4 1c add $0x1c,%esp
108247: 5b pop %ebx
108248: 5e pop %esi
108249: 5f pop %edi
10824a: 5d pop %ebp
10824b: c3 ret
0010fb34 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fb34: 57 push %edi
10fb35: 56 push %esi
10fb36: 53 push %ebx
10fb37: 8b 44 24 10 mov 0x10(%esp),%eax
10fb3b: 8b 54 24 14 mov 0x14(%esp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10fb3f: 8b 30 mov (%eax),%esi
10fb41: 85 f6 test %esi,%esi
10fb43: 74 3f je 10fb84 <rtems_assoc_ptr_by_remote+0x50>
10fb45: bf 2c 1c 12 00 mov $0x121c2c,%edi
10fb4a: b9 0a 00 00 00 mov $0xa,%ecx
10fb4f: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10fb51: 74 19 je 10fb6c <rtems_assoc_ptr_by_remote+0x38>
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
10fb53: 31 c9 xor %ecx,%ecx
10fb55: eb 0a jmp 10fb61 <rtems_assoc_ptr_by_remote+0x2d>
10fb57: 90 nop
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10fb58: 83 c0 0c add $0xc,%eax
10fb5b: 8b 18 mov (%eax),%ebx
10fb5d: 85 db test %ebx,%ebx
10fb5f: 74 1b je 10fb7c <rtems_assoc_ptr_by_remote+0x48>
if (ap->remote_value == remote_value)
10fb61: 39 50 08 cmp %edx,0x8(%eax)
10fb64: 75 f2 jne 10fb58 <rtems_assoc_ptr_by_remote+0x24>
return ap;
return default_ap;
}
10fb66: 5b pop %ebx
10fb67: 5e pop %esi
10fb68: 5f pop %edi
10fb69: c3 ret
10fb6a: 66 90 xchg %ax,%ax
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fb6c: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
10fb6f: 8b 70 0c mov 0xc(%eax),%esi
10fb72: 85 f6 test %esi,%esi
10fb74: 74 f0 je 10fb66 <rtems_assoc_ptr_by_remote+0x32><== NEVER TAKEN
10fb76: 89 c1 mov %eax,%ecx
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fb78: 89 d8 mov %ebx,%eax
10fb7a: eb e5 jmp 10fb61 <rtems_assoc_ptr_by_remote+0x2d>
for ( ; ap->name; ap++)
10fb7c: 89 c8 mov %ecx,%eax
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fb7e: 5b pop %ebx
10fb7f: 5e pop %esi
10fb80: 5f pop %edi
10fb81: c3 ret
10fb82: 66 90 xchg %ax,%ax
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
10fb84: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fb86: 5b pop %ebx
10fb87: 5e pop %esi
10fb88: 5f pop %edi
10fb89: c3 ret
001082a4 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
1082a4: 55 push %ebp
1082a5: 57 push %edi
1082a6: 56 push %esi
1082a7: 53 push %ebx
1082a8: 83 ec 1c sub $0x1c,%esp
1082ab: 8b 74 24 34 mov 0x34(%esp),%esi
1082af: bd 20 00 00 00 mov $0x20,%ebp
uint32_t b;
uint32_t remote_value = 0;
1082b4: 31 ff xor %edi,%edi
for (b = 1; b; b <<= 1)
1082b6: bb 01 00 00 00 mov $0x1,%ebx
1082bb: eb 08 jmp 1082c5 <rtems_assoc_remote_by_local_bitfield+0x21>
1082bd: 8d 76 00 lea 0x0(%esi),%esi
1082c0: d1 e3 shl %ebx
1082c2: 4d dec %ebp
1082c3: 74 1b je 1082e0 <rtems_assoc_remote_by_local_bitfield+0x3c>
if (b & local_value)
1082c5: 85 f3 test %esi,%ebx
1082c7: 74 f7 je 1082c0 <rtems_assoc_remote_by_local_bitfield+0x1c>
remote_value |= rtems_assoc_remote_by_local(ap, b);
1082c9: 89 5c 24 04 mov %ebx,0x4(%esp)
1082cd: 8b 44 24 30 mov 0x30(%esp),%eax
1082d1: 89 04 24 mov %eax,(%esp)
1082d4: e8 13 00 00 00 call 1082ec <rtems_assoc_remote_by_local>
1082d9: 09 c7 or %eax,%edi
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
1082db: d1 e3 shl %ebx
1082dd: 4d dec %ebp
1082de: 75 e5 jne 1082c5 <rtems_assoc_remote_by_local_bitfield+0x21><== ALWAYS TAKEN
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
1082e0: 89 f8 mov %edi,%eax
1082e2: 83 c4 1c add $0x1c,%esp
1082e5: 5b pop %ebx
1082e6: 5e pop %esi
1082e7: 5f pop %edi
1082e8: 5d pop %ebp
1082e9: c3 ret
0010744c <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
10744c: 55 push %ebp
10744d: 57 push %edi
10744e: 56 push %esi
10744f: 53 push %ebx
107450: 83 ec 1c sub $0x1c,%esp
107453: 8b 44 24 30 mov 0x30(%esp),%eax
107457: 8b 5c 24 34 mov 0x34(%esp),%ebx
10745b: 8b 6c 24 38 mov 0x38(%esp),%ebp
const char *p;
if ( !name )
10745f: 85 c0 test %eax,%eax
107461: 74 59 je 1074bc <rtems_bsp_cmdline_get_param+0x70>
return NULL;
if ( !value )
107463: 85 db test %ebx,%ebx
107465: 74 55 je 1074bc <rtems_bsp_cmdline_get_param+0x70>
return NULL;
if ( !length )
107467: 85 ed test %ebp,%ebp
107469: 74 51 je 1074bc <rtems_bsp_cmdline_get_param+0x70>
return NULL;
value[0] = '\0';
10746b: c6 03 00 movb $0x0,(%ebx)
p = rtems_bsp_cmdline_get_param_raw( name );
10746e: 89 04 24 mov %eax,(%esp)
107471: e8 52 00 00 00 call 1074c8 <rtems_bsp_cmdline_get_param_raw>
if ( !p )
107476: 85 c0 test %eax,%eax
107478: 74 42 je 1074bc <rtems_bsp_cmdline_get_param+0x70>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
10747a: 8a 08 mov (%eax),%cl
10747c: 84 c9 test %cl,%cl
10747e: 74 3e je 1074be <rtems_bsp_cmdline_get_param+0x72><== NEVER TAKEN
107480: 83 fd 01 cmp $0x1,%ebp
107483: 74 39 je 1074be <rtems_bsp_cmdline_get_param+0x72><== NEVER TAKEN
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
107485: 4d dec %ebp
107486: 31 d2 xor %edx,%edx
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
107488: 31 f6 xor %esi,%esi
value[i] = '\0';
}
}
const char *rtems_bsp_cmdline_get_param(
10748a: 31 ff xor %edi,%edi
10748c: eb 24 jmp 1074b2 <rtems_bsp_cmdline_get_param+0x66>
10748e: 66 90 xchg %ax,%ax
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
107490: f7 c7 01 00 00 00 test $0x1,%edi
107496: 75 05 jne 10749d <rtems_bsp_cmdline_get_param+0x51>
107498: 80 f9 20 cmp $0x20,%cl
10749b: 74 21 je 1074be <rtems_bsp_cmdline_get_param+0x72>
break;
value[i++] = *p++;
10749d: 88 0c 33 mov %cl,(%ebx,%esi,1)
1074a0: 42 inc %edx
value[i] = '\0';
1074a1: 89 d6 mov %edx,%esi
1074a3: c6 04 13 00 movb $0x0,(%ebx,%edx,1)
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
1074a7: 8a 0c 10 mov (%eax,%edx,1),%cl
1074aa: 84 c9 test %cl,%cl
1074ac: 74 10 je 1074be <rtems_bsp_cmdline_get_param+0x72>
1074ae: 39 ea cmp %ebp,%edx
1074b0: 74 0c je 1074be <rtems_bsp_cmdline_get_param+0x72>
if ( *p == '\"' ) {
1074b2: 80 f9 22 cmp $0x22,%cl
1074b5: 75 d9 jne 107490 <rtems_bsp_cmdline_get_param+0x44>
quotes++;
1074b7: 47 inc %edi
1074b8: eb e3 jmp 10749d <rtems_bsp_cmdline_get_param+0x51>
1074ba: 66 90 xchg %ax,%ax
)
{
const char *p;
if ( !name )
return NULL;
1074bc: 31 db xor %ebx,%ebx
return NULL;
copy_string( p, value, length );
return value;
}
1074be: 89 d8 mov %ebx,%eax
1074c0: 83 c4 1c add $0x1c,%esp
1074c3: 5b pop %ebx
1074c4: 5e pop %esi
1074c5: 5f pop %edi
1074c6: 5d pop %ebp
1074c7: c3 ret
0010c56c <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10c56c: 55 push %ebp
10c56d: 57 push %edi
10c56e: 56 push %esi
10c56f: 53 push %ebx
10c570: 83 ec 2c sub $0x2c,%esp
10c573: 8b 5c 24 40 mov 0x40(%esp),%ebx
10c577: 8b 6c 24 44 mov 0x44(%esp),%ebp
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
10c57b: 8d 74 24 1c lea 0x1c(%esp),%esi
10c57f: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10c580: 89 1c 24 mov %ebx,(%esp)
10c583: e8 5c 05 00 00 call 10cae4 <_Chain_Get>
10c588: 89 c7 mov %eax,%edi
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c58a: 85 c0 test %eax,%eax
10c58c: 75 2e jne 10c5bc <rtems_chain_get_with_wait+0x50>
) {
rtems_event_set out;
sc = rtems_event_receive(
10c58e: 89 74 24 0c mov %esi,0xc(%esp)
10c592: 8b 44 24 48 mov 0x48(%esp),%eax
10c596: 89 44 24 08 mov %eax,0x8(%esp)
10c59a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10c5a1: 00
10c5a2: 89 2c 24 mov %ebp,(%esp)
10c5a5: e8 7e f3 ff ff call 10b928 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10c5aa: 85 c0 test %eax,%eax
10c5ac: 74 d2 je 10c580 <rtems_chain_get_with_wait+0x14><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10c5ae: 8b 4c 24 4c mov 0x4c(%esp),%ecx
10c5b2: 89 39 mov %edi,(%ecx)
return sc;
}
10c5b4: 83 c4 2c add $0x2c,%esp
10c5b7: 5b pop %ebx
10c5b8: 5e pop %esi
10c5b9: 5f pop %edi
10c5ba: 5d pop %ebp
10c5bb: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c5bc: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10c5be: 8b 4c 24 4c mov 0x4c(%esp),%ecx
10c5c2: 89 39 mov %edi,(%ecx)
return sc;
}
10c5c4: 83 c4 2c add $0x2c,%esp
10c5c7: 5b pop %ebx
10c5c8: 5e pop %esi
10c5c9: 5f pop %edi
10c5ca: 5d pop %ebp
10c5cb: c3 ret
00107bf4 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107bf4: 55 push %ebp
107bf5: 57 push %edi
107bf6: 56 push %esi
107bf7: 53 push %ebx
107bf8: 83 ec 7c sub $0x7c,%esp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
107bfb: 8b 84 24 94 00 00 00 mov 0x94(%esp),%eax
107c02: 85 c0 test %eax,%eax
107c04: 0f 84 a6 02 00 00 je 107eb0 <rtems_cpu_usage_report_with_plugin+0x2bc><== NEVER TAKEN
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
107c0a: c7 44 24 50 00 00 00 movl $0x0,0x50(%esp)
107c11: 00
107c12: c7 44 24 54 00 00 00 movl $0x0,0x54(%esp)
107c19: 00
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
107c1a: 8b 35 40 2d 13 00 mov 0x132d40,%esi
107c20: 8b 3d 44 2d 13 00 mov 0x132d44,%edi
107c26: 89 74 24 30 mov %esi,0x30(%esp)
107c2a: 89 7c 24 34 mov %edi,0x34(%esp)
}
}
}
#endif
(*print)(
107c2e: c7 44 24 04 30 2e 12 movl $0x122e30,0x4(%esp)
107c35: 00
107c36: 8b bc 24 90 00 00 00 mov 0x90(%esp),%edi
107c3d: 89 3c 24 mov %edi,(%esp)
107c40: 8b 8c 24 94 00 00 00 mov 0x94(%esp),%ecx
107c47: ff d1 call *%ecx
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
107c49: c7 44 24 3c 01 00 00 movl $0x1,0x3c(%esp)
107c50: 00
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
107c51: 8b 74 24 3c mov 0x3c(%esp),%esi
107c55: 8b 04 b5 fc 29 13 00 mov 0x1329fc(,%esi,4),%eax
107c5c: 85 c0 test %eax,%eax
107c5e: 0f 84 c0 01 00 00 je 107e24 <rtems_cpu_usage_report_with_plugin+0x230>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
107c64: 8b 68 04 mov 0x4(%eax),%ebp
if ( information ) {
107c67: 85 ed test %ebp,%ebp
107c69: 0f 84 b5 01 00 00 je 107e24 <rtems_cpu_usage_report_with_plugin+0x230><== NEVER TAKEN
for ( i=1 ; i <= information->maximum ; i++ ) {
107c6f: 66 83 7d 10 00 cmpw $0x0,0x10(%ebp)
107c74: 0f 84 aa 01 00 00 je 107e24 <rtems_cpu_usage_report_with_plugin+0x230><== NEVER TAKEN
107c7a: bb 01 00 00 00 mov $0x1,%ebx
107c7f: e9 ea 00 00 00 jmp 107d6e <rtems_cpu_usage_report_with_plugin+0x17a>
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
107c84: 8d 44 24 48 lea 0x48(%esp),%eax
107c88: 89 04 24 mov %eax,(%esp)
107c8b: e8 c4 5f 00 00 call 10dc54 <_TOD_Get_uptime>
107c90: 8b 44 24 48 mov 0x48(%esp),%eax
107c94: 8b 54 24 4c mov 0x4c(%esp),%edx
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
107c98: 2b 44 24 30 sub 0x30(%esp),%eax
107c9c: 1b 54 24 34 sbb 0x34(%esp),%edx
107ca0: 89 44 24 50 mov %eax,0x50(%esp)
107ca4: 89 54 24 54 mov %edx,0x54(%esp)
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
107ca8: 8d 44 24 44 lea 0x44(%esp),%eax
107cac: 89 44 24 0c mov %eax,0xc(%esp)
107cb0: 8d 44 24 40 lea 0x40(%esp),%eax
107cb4: 89 44 24 08 mov %eax,0x8(%esp)
107cb8: 8d 44 24 50 lea 0x50(%esp),%eax
107cbc: 89 44 24 04 mov %eax,0x4(%esp)
107cc0: 8d 44 24 58 lea 0x58(%esp),%eax
107cc4: 89 04 24 mov %eax,(%esp)
107cc7: e8 c4 80 00 00 call 10fd90 <_Timestamp64_Divide>
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
107ccc: 8b 74 24 58 mov 0x58(%esp),%esi
107cd0: 8b 7c 24 5c mov 0x5c(%esp),%edi
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
107cd4: 8b 44 24 44 mov 0x44(%esp),%eax
107cd8: 89 44 24 14 mov %eax,0x14(%esp)
107cdc: 8b 44 24 40 mov 0x40(%esp),%eax
107ce0: 89 44 24 10 mov %eax,0x10(%esp)
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
107ce4: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
107ceb: 3b
107cec: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107cf3: 00
107cf4: 89 34 24 mov %esi,(%esp)
107cf7: 89 7c 24 04 mov %edi,0x4(%esp)
107cfb: e8 fc 8f 01 00 call 120cfc <__moddi3>
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
107d00: ba d3 4d 62 10 mov $0x10624dd3,%edx
107d05: f7 e2 mul %edx
107d07: c1 ea 06 shr $0x6,%edx
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
107d0a: 89 54 24 0c mov %edx,0xc(%esp)
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
107d0e: 8b 44 24 08 mov 0x8(%esp),%eax
107d12: 8b 54 24 0c mov 0xc(%esp),%edx
107d16: 89 44 24 28 mov %eax,0x28(%esp)
107d1a: 89 54 24 2c mov %edx,0x2c(%esp)
107d1e: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
107d25: 3b
107d26: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107d2d: 00
107d2e: 89 34 24 mov %esi,(%esp)
107d31: 89 7c 24 04 mov %edi,0x4(%esp)
107d35: e8 6e 8e 01 00 call 120ba8 <__divdi3>
107d3a: 8b 7c 24 2c mov 0x2c(%esp),%edi
107d3e: 89 7c 24 0c mov %edi,0xc(%esp)
107d42: 89 44 24 08 mov %eax,0x8(%esp)
107d46: c7 44 24 04 a3 30 12 movl $0x1230a3,0x4(%esp)
107d4d: 00
107d4e: 8b bc 24 90 00 00 00 mov 0x90(%esp),%edi
107d55: 89 3c 24 mov %edi,(%esp)
107d58: 8b 8c 24 94 00 00 00 mov 0x94(%esp),%ecx
107d5f: ff d1 call *%ecx
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
107d61: 43 inc %ebx
107d62: 0f b7 45 10 movzwl 0x10(%ebp),%eax
107d66: 39 d8 cmp %ebx,%eax
107d68: 0f 82 b6 00 00 00 jb 107e24 <rtems_cpu_usage_report_with_plugin+0x230>
the_thread = (Thread_Control *)information->local_table[ i ];
107d6e: 8b 45 1c mov 0x1c(%ebp),%eax
107d71: 8b 34 98 mov (%eax,%ebx,4),%esi
if ( !the_thread )
107d74: 85 f6 test %esi,%esi
107d76: 74 e9 je 107d61 <rtems_cpu_usage_report_with_plugin+0x16d><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107d78: 8d 7c 24 63 lea 0x63(%esp),%edi
107d7c: 89 7c 24 08 mov %edi,0x8(%esp)
107d80: c7 44 24 04 0d 00 00 movl $0xd,0x4(%esp)
107d87: 00
107d88: 8b 46 08 mov 0x8(%esi),%eax
107d8b: 89 04 24 mov %eax,(%esp)
107d8e: e8 45 4b 00 00 call 10c8d8 <rtems_object_get_name>
(*print)(
context,
" 0x%08" PRIx32 " | %-38s |",
the_thread->Object.id,
name
107d93: 8d 44 24 63 lea 0x63(%esp),%eax
107d97: 89 44 24 0c mov %eax,0xc(%esp)
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
107d9b: 8b 46 08 mov 0x8(%esi),%eax
107d9e: 89 44 24 08 mov %eax,0x8(%esp)
107da2: c7 44 24 04 90 30 12 movl $0x123090,0x4(%esp)
107da9: 00
107daa: 8b 8c 24 90 00 00 00 mov 0x90(%esp),%ecx
107db1: 89 0c 24 mov %ecx,(%esp)
107db4: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi
107dbb: ff d7 call *%edi
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
107dbd: 8b 86 80 00 00 00 mov 0x80(%esi),%eax
107dc3: 8b 96 84 00 00 00 mov 0x84(%esi),%edx
107dc9: 89 44 24 58 mov %eax,0x58(%esp)
107dcd: 89 54 24 5c mov %edx,0x5c(%esp)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
107dd1: a1 cc 2c 13 00 mov 0x132ccc,%eax
107dd6: 8b 50 08 mov 0x8(%eax),%edx
107dd9: 39 56 08 cmp %edx,0x8(%esi)
107ddc: 0f 85 a2 fe ff ff jne 107c84 <rtems_cpu_usage_report_with_plugin+0x90>
*time_of_context_switch = _Thread_Time_of_last_context_switch;
107de2: 8b 35 dc 2c 13 00 mov 0x132cdc,%esi
107de8: 8b 3d e0 2c 13 00 mov 0x132ce0,%edi
107dee: 89 74 24 28 mov %esi,0x28(%esp)
107df2: 89 7c 24 2c mov %edi,0x2c(%esp)
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( is_executing_on_a_core( the_thread, &last ) ) {
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
107df6: 8d 7c 24 48 lea 0x48(%esp),%edi
107dfa: 89 3c 24 mov %edi,(%esp)
107dfd: e8 52 5e 00 00 call 10dc54 <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
107e02: 8b 44 24 48 mov 0x48(%esp),%eax
107e06: 8b 54 24 4c mov 0x4c(%esp),%edx
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
107e0a: 89 c6 mov %eax,%esi
107e0c: 89 d7 mov %edx,%edi
107e0e: 2b 74 24 28 sub 0x28(%esp),%esi
107e12: 1b 7c 24 2c sbb 0x2c(%esp),%edi
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
107e16: 01 74 24 58 add %esi,0x58(%esp)
107e1a: 11 7c 24 5c adc %edi,0x5c(%esp)
107e1e: e9 75 fe ff ff jmp 107c98 <rtems_cpu_usage_report_with_plugin+0xa4>
107e23: 90 nop
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
107e24: ff 44 24 3c incl 0x3c(%esp)
107e28: 83 7c 24 3c 04 cmpl $0x4,0x3c(%esp)
107e2d: 0f 85 1e fe ff ff jne 107c51 <rtems_cpu_usage_report_with_plugin+0x5d>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
107e33: 8b 74 24 50 mov 0x50(%esp),%esi
107e37: 8b 7c 24 54 mov 0x54(%esp),%edi
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
107e3b: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
107e42: 3b
107e43: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107e4a: 00
107e4b: 89 34 24 mov %esi,(%esp)
107e4e: 89 7c 24 04 mov %edi,0x4(%esp)
107e52: e8 a5 8e 01 00 call 120cfc <__moddi3>
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
107e57: ba d3 4d 62 10 mov $0x10624dd3,%edx
107e5c: f7 e2 mul %edx
107e5e: c1 ea 06 shr $0x6,%edx
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
107e61: 89 54 24 0c mov %edx,0xc(%esp)
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
107e65: 8b 4c 24 08 mov 0x8(%esp),%ecx
107e69: 8b 5c 24 0c mov 0xc(%esp),%ebx
107e6d: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
107e74: 3b
107e75: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107e7c: 00
107e7d: 89 34 24 mov %esi,(%esp)
107e80: 89 7c 24 04 mov %edi,0x4(%esp)
107e84: 89 4c 24 24 mov %ecx,0x24(%esp)
107e88: e8 1b 8d 01 00 call 120ba8 <__divdi3>
107e8d: 89 5c 24 0c mov %ebx,0xc(%esp)
107e91: 89 44 24 08 mov %eax,0x8(%esp)
107e95: c7 44 24 04 a4 2f 12 movl $0x122fa4,0x4(%esp)
107e9c: 00
107e9d: 8b b4 24 90 00 00 00 mov 0x90(%esp),%esi
107ea4: 89 34 24 mov %esi,(%esp)
107ea7: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi
107eae: ff d7 call *%edi
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
107eb0: 83 c4 7c add $0x7c,%esp
107eb3: 5b pop %ebx
107eb4: 5e pop %esi
107eb5: 5f pop %edi
107eb6: 5d pop %ebp
107eb7: c3 ret
00112c78 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
112c78: 53 push %ebx
112c79: 83 ec 08 sub $0x8,%esp
112c7c: 8b 54 24 10 mov 0x10(%esp),%edx
if (sc == RTEMS_SUCCESSFUL) {
return 0;
112c80: 31 c0 xor %eax,%eax
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
112c82: 85 d2 test %edx,%edx
112c84: 75 06 jne 112c8c <rtems_deviceio_errno+0x14>
errno = eno;
return -1;
}
}
112c86: 83 c4 08 add $0x8,%esp
112c89: 5b pop %ebx
112c8a: c3 ret
112c8b: 90 nop
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
112c8c: 83 fa 1c cmp $0x1c,%edx
112c8f: 77 17 ja 112ca8 <rtems_deviceio_errno+0x30><== NEVER TAKEN
eno = status_code_to_errno [sc];
112c91: 8b 1c 95 00 1d 12 00 mov 0x121d00(,%edx,4),%ebx
}
errno = eno;
112c98: e8 5b 00 00 00 call 112cf8 <__errno>
112c9d: 89 18 mov %ebx,(%eax)
return -1;
112c9f: b8 ff ff ff ff mov $0xffffffff,%eax
112ca4: eb e0 jmp 112c86 <rtems_deviceio_errno+0xe>
112ca6: 66 90 xchg %ax,%ax
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
112ca8: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
112cad: eb e9 jmp 112c98 <rtems_deviceio_errno+0x20><== NOT EXECUTED
001100d0 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
1100d0: 57 push %edi
1100d1: 56 push %esi
1100d2: 53 push %ebx
1100d3: 8b 5c 24 10 mov 0x10(%esp),%ebx
1100d7: 8b 74 24 18 mov 0x18(%esp),%esi
1100db: 8b 7c 24 1c mov 0x1c(%esp),%edi
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
1100df: 83 e3 07 and $0x7,%ebx
uid_t task_uid = geteuid();
1100e2: e8 f1 25 00 00 call 1126d8 <geteuid>
if (task_uid == 0 || task_uid == node_uid) {
1100e7: 66 85 c0 test %ax,%ax
1100ea: 74 24 je 110110 <rtems_filesystem_check_access+0x40>
1100ec: 66 39 f0 cmp %si,%ax
1100ef: 74 1f je 110110 <rtems_filesystem_check_access+0x40>
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
1100f1: e8 d6 25 00 00 call 1126cc <getegid>
if (task_gid == 0 || task_gid == node_gid) {
1100f6: 66 85 c0 test %ax,%ax
1100f9: 75 29 jne 110124 <rtems_filesystem_check_access+0x54>
perm_flags <<= RTEMS_FS_GRP_SHIFT;
1100fb: c1 e3 03 shl $0x3,%ebx
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
1100fe: 8b 44 24 14 mov 0x14(%esp),%eax
110102: 21 d8 and %ebx,%eax
110104: 39 d8 cmp %ebx,%eax
110106: 0f 94 c0 sete %al
}
110109: 5b pop %ebx
11010a: 5e pop %esi
11010b: 5f pop %edi
11010c: c3 ret
11010d: 8d 76 00 lea 0x0(%esi),%esi
{
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
if (task_uid == 0 || task_uid == node_uid) {
perm_flags <<= RTEMS_FS_USR_SHIFT;
110110: c1 e3 06 shl $0x6,%ebx
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
110113: 8b 44 24 14 mov 0x14(%esp),%eax
110117: 21 d8 and %ebx,%eax
110119: 39 d8 cmp %ebx,%eax
11011b: 0f 94 c0 sete %al
}
11011e: 5b pop %ebx
11011f: 5e pop %esi
110120: 5f pop %edi
110121: c3 ret
110122: 66 90 xchg %ax,%ax
if (task_uid == 0 || task_uid == node_uid) {
perm_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = getegid();
if (task_gid == 0 || task_gid == node_gid) {
110124: 66 39 f8 cmp %di,%ax
110127: 74 d2 je 1100fb <rtems_filesystem_check_access+0x2b><== NEVER TAKEN
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
110129: 8b 44 24 14 mov 0x14(%esp),%eax
11012d: 21 d8 and %ebx,%eax
11012f: 39 d8 cmp %ebx,%eax
110131: 0f 94 c0 sete %al
}
110134: 5b pop %ebx
110135: 5e pop %esi
110136: 5f pop %edi
110137: c3 ret
00108fa4 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
108fa4: 53 push %ebx
108fa5: 83 ec 18 sub $0x18,%esp
108fa8: 8b 5c 24 20 mov 0x20(%esp),%ebx
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
108fac: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
108fb3: 00
108fb4: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
108fbb: 00
108fbc: a1 dc f4 12 00 mov 0x12f4dc,%eax
108fc1: 89 04 24 mov %eax,(%esp)
108fc4: e8 b3 29 00 00 call 10b97c <rtems_semaphore_obtain>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
108fc9: 8b 13 mov (%ebx),%edx
previous = the_node->previous;
108fcb: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
108fce: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
108fd1: 89 10 mov %edx,(%eax)
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
108fd3: a1 dc f4 12 00 mov 0x12f4dc,%eax
108fd8: 89 04 24 mov %eax,(%esp)
108fdb: e8 c8 2a 00 00 call 10baa8 <rtems_semaphore_release>
rtems_filesystem_mt_lock();
rtems_chain_extract_unprotected(&mt_entry->mt_node);
rtems_filesystem_mt_unlock();
rtems_filesystem_global_location_release(mt_entry->mt_point_node);
108fe0: 8b 43 20 mov 0x20(%ebx),%eax
108fe3: 89 04 24 mov %eax,(%esp)
108fe6: e8 59 01 00 00 call 109144 <rtems_filesystem_global_location_release>
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
108feb: 8b 43 0c mov 0xc(%ebx),%eax
108fee: 89 1c 24 mov %ebx,(%esp)
108ff1: ff 50 3c call *0x3c(%eax)
if (mt_entry->unmount_task != 0) {
108ff4: 8b 43 3c mov 0x3c(%ebx),%eax
108ff7: 85 c0 test %eax,%eax
108ff9: 74 14 je 10900f <rtems_filesystem_do_unmount+0x6b><== NEVER TAKEN
rtems_status_code sc =
108ffb: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
109002: 00
109003: 89 04 24 mov %eax,(%esp)
109006: e8 e5 24 00 00 call 10b4f0 <rtems_event_send>
rtems_event_send(mt_entry->unmount_task, RTEMS_FILESYSTEM_UNMOUNT_EVENT);
if (sc != RTEMS_SUCCESSFUL) {
10900b: 85 c0 test %eax,%eax
10900d: 75 0d jne 10901c <rtems_filesystem_do_unmount+0x78><== NEVER TAKEN
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
10900f: 89 5c 24 20 mov %ebx,0x20(%esp)
}
109013: 83 c4 18 add $0x18,%esp
109016: 5b pop %ebx
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
109017: e9 20 e9 ff ff jmp 10793c <free>
if (mt_entry->unmount_task != 0) {
rtems_status_code sc =
rtems_event_send(mt_entry->unmount_task, RTEMS_FILESYSTEM_UNMOUNT_EVENT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
10901c: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED
109023: e8 88 30 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
00110188 <rtems_filesystem_eval_path_generic>:
void rtems_filesystem_eval_path_generic(
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const rtems_filesystem_eval_path_generic_config *config
)
{
110188: 55 push %ebp
110189: 57 push %edi
11018a: 56 push %esi
11018b: 53 push %ebx
11018c: 83 ec 2c sub $0x2c,%esp
11018f: 8b 5c 24 40 mov 0x40(%esp),%ebx
110193: 8b 7c 24 44 mov 0x44(%esp),%edi
110197: 8b 54 24 48 mov 0x48(%esp),%edx
11019b: 89 54 24 18 mov %edx,0x18(%esp)
rtems_filesystem_eval_path_error(ctx, EINVAL);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
11019f: 8d 53 18 lea 0x18(%ebx),%edx
1101a2: 89 54 24 1c mov %edx,0x1c(%esp)
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
1101a6: 89 1c 24 mov %ebx,(%esp)
1101a9: e8 da 01 00 00 call 110388 <rtems_filesystem_eval_path_next_token>
*token = ctx->token;
1101ae: 8b 6b 08 mov 0x8(%ebx),%ebp
*tokenlen = ctx->tokenlen;
1101b1: 8b 73 0c mov 0xc(%ebx),%esi
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
1101b4: 85 f6 test %esi,%esi
1101b6: 75 08 jne 1101c0 <rtems_filesystem_eval_path_generic+0x38>
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
1101b8: 83 c4 2c add $0x2c,%esp
1101bb: 5b pop %ebx
1101bc: 5e pop %esi
1101bd: 5f pop %edi
1101be: 5d pop %ebp
1101bf: c3 ret
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
if ((*config->is_directory)(ctx, arg)) {
1101c0: 89 7c 24 04 mov %edi,0x4(%esp)
1101c4: 89 1c 24 mov %ebx,(%esp)
1101c7: 8b 54 24 18 mov 0x18(%esp),%edx
1101cb: ff 12 call *(%edx)
1101cd: 84 c0 test %al,%al
1101cf: 74 2f je 110200 <rtems_filesystem_eval_path_generic+0x78>
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
1101d1: 83 fe 01 cmp $0x1,%esi
1101d4: 74 76 je 11024c <rtems_filesystem_eval_path_generic+0xc4>
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
1101d6: 83 fe 02 cmp $0x2,%esi
1101d9: 0f 84 a1 00 00 00 je 110280 <rtems_filesystem_eval_path_generic+0xf8>
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
1101df: 89 74 24 0c mov %esi,0xc(%esp)
1101e3: 89 6c 24 08 mov %ebp,0x8(%esp)
1101e7: 89 7c 24 04 mov %edi,0x4(%esp)
1101eb: 89 1c 24 mov %ebx,(%esp)
1101ee: 8b 54 24 18 mov 0x18(%esp),%edx
1101f2: ff 52 04 call *0x4(%edx)
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
1101f5: 83 f8 02 cmp $0x2,%eax
1101f8: 74 1e je 110218 <rtems_filesystem_eval_path_generic+0x90>
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
1101fa: 85 c0 test %eax,%eax
1101fc: 74 a8 je 1101a6 <rtems_filesystem_eval_path_generic+0x1e>
1101fe: eb b8 jmp 1101b8 <rtems_filesystem_eval_path_generic+0x30>
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
110200: c7 44 24 44 14 00 00 movl $0x14,0x44(%esp)
110207: 00
110208: 89 5c 24 40 mov %ebx,0x40(%esp)
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
11020c: 83 c4 2c add $0x2c,%esp
11020f: 5b pop %ebx
110210: 5e pop %esi
110211: 5f pop %edi
110212: 5d pop %ebp
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
110213: e9 1c 88 ff ff jmp 108a34 <rtems_filesystem_eval_path_error>
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
110218: 8b 4b 04 mov 0x4(%ebx),%ecx
11021b: 85 c9 test %ecx,%ecx
11021d: 74 99 je 1101b8 <rtems_filesystem_eval_path_generic+0x30>
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
11021f: 89 1c 24 mov %ebx,(%esp)
110222: e8 29 01 00 00 call 110350 <rtems_filesystem_eval_path_eat_delimiter>
eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (
110227: f6 43 10 80 testb $0x80,0x10(%ebx)
11022b: 74 07 je 110234 <rtems_filesystem_eval_path_generic+0xac>
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
11022d: 8b 53 04 mov 0x4(%ebx),%edx
110230: 85 d2 test %edx,%edx
110232: 74 84 je 1101b8 <rtems_filesystem_eval_path_generic+0x30>
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
110234: c7 44 24 44 02 00 00 movl $0x2,0x44(%esp)
11023b: 00
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
11023c: 89 5c 24 40 mov %ebx,0x40(%esp)
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
110240: 83 c4 2c add $0x2c,%esp
110243: 5b pop %ebx
110244: 5e pop %esi
110245: 5f pop %edi
110246: 5d pop %ebp
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
110247: e9 e8 87 ff ff jmp 108a34 <rtems_filesystem_eval_path_error>
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
11024c: 80 7d 00 2e cmpb $0x2e,0x0(%ebp)
110250: 75 8d jne 1101df <rtems_filesystem_eval_path_generic+0x57>
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
if ((*config->is_directory)(ctx, arg)) {
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
if (rtems_filesystem_eval_path_has_path(ctx)) {
110252: 8b 43 04 mov 0x4(%ebx),%eax
110255: 85 c0 test %eax,%eax
110257: 0f 85 8f 00 00 00 jne 1102ec <rtems_filesystem_eval_path_generic+0x164>
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
11025d: f6 43 11 01 testb $0x1,0x11(%ebx)
110261: 0f 84 85 00 00 00 je 1102ec <rtems_filesystem_eval_path_generic+0x164>
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
110267: c7 44 24 44 16 00 00 movl $0x16,0x44(%esp)
11026e: 00
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
11026f: 89 5c 24 40 mov %ebx,0x40(%esp)
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
110273: 83 c4 2c add $0x2c,%esp
110276: 5b pop %ebx
110277: 5e pop %esi
110278: 5f pop %edi
110279: 5d pop %ebp
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
11027a: e9 b5 87 ff ff jmp 108a34 <rtems_filesystem_eval_path_error>
11027f: 90 nop
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
110280: 80 7d 00 2e cmpb $0x2e,0x0(%ebp)
110284: 0f 85 55 ff ff ff jne 1101df <rtems_filesystem_eval_path_generic+0x57>
11028a: 80 7d 01 2e cmpb $0x2e,0x1(%ebp)
11028e: 0f 85 4b ff ff ff jne 1101df <rtems_filesystem_eval_path_generic+0x57><== NEVER TAKEN
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
110294: 8b 53 30 mov 0x30(%ebx),%edx
static bool is_eval_path_root(
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
110297: 8b 43 2c mov 0x2c(%ebx),%eax
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
11029a: 3b 42 14 cmp 0x14(%edx),%eax
11029d: 0f 84 8f 00 00 00 je 110332 <rtems_filesystem_eval_path_generic+0x1aa>
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *mt_fs_root =
&mt_entry->mt_fs_root->location;
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
1102a3: 8b 50 0c mov 0xc(%eax),%edx
1102a6: 8b 40 24 mov 0x24(%eax),%eax
1102a9: 89 44 24 04 mov %eax,0x4(%esp)
1102ad: 8b 44 24 1c mov 0x1c(%esp),%eax
1102b1: 89 04 24 mov %eax,(%esp)
1102b4: ff 52 10 call *0x10(%edx)
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
} else if (is_fs_root(currentloc)) {
1102b7: 84 c0 test %al,%al
1102b9: 74 54 je 11030f <rtems_filesystem_eval_path_generic+0x187>
if (currentloc->mt_entry->mt_point_node != NULL) {
1102bb: 8b 43 2c mov 0x2c(%ebx),%eax
1102be: 8b 70 20 mov 0x20(%eax),%esi
1102c1: 85 f6 test %esi,%esi
1102c3: 74 27 je 1102ec <rtems_filesystem_eval_path_generic+0x164><== NEVER TAKEN
static inline void rtems_filesystem_eval_path_put_back_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
1102c5: 8b 53 0c mov 0xc(%ebx),%edx
ctx->path -= tokenlen;
1102c8: 29 13 sub %edx,(%ebx)
ctx->pathlen += tokenlen;
1102ca: 01 53 04 add %edx,0x4(%ebx)
ctx->tokenlen = 0;
1102cd: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
1102d4: 83 c0 20 add $0x20,%eax
1102d7: 89 44 24 44 mov %eax,0x44(%esp)
1102db: 89 5c 24 40 mov %ebx,0x40(%esp)
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
1102df: 83 c4 2c add $0x2c,%esp
1102e2: 5b pop %ebx
1102e3: 5e pop %esi
1102e4: 5f pop %edi
1102e5: 5d pop %ebp
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
} else if (is_fs_root(currentloc)) {
if (currentloc->mt_entry->mt_point_node != NULL) {
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
1102e6: e9 49 8b ff ff jmp 108e34 <rtems_filesystem_eval_path_restart>
1102eb: 90 nop
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
1102ec: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp)
1102f3: 00
1102f4: c7 44 24 08 d1 1c 12 movl $0x121cd1,0x8(%esp)
1102fb: 00
1102fc: 89 7c 24 04 mov %edi,0x4(%esp)
110300: 89 1c 24 mov %ebx,(%esp)
110303: 8b 54 24 18 mov 0x18(%esp),%edx
110307: ff 52 04 call *0x4(%edx)
11030a: e9 e6 fe ff ff jmp 1101f5 <rtems_filesystem_eval_path_generic+0x6d>
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
11030f: c7 44 24 0c 02 00 00 movl $0x2,0xc(%esp)
110316: 00
110317: c7 44 24 08 d0 1c 12 movl $0x121cd0,0x8(%esp)
11031e: 00
11031f: 89 7c 24 04 mov %edi,0x4(%esp)
110323: 89 1c 24 mov %ebx,(%esp)
110326: 8b 54 24 18 mov 0x18(%esp),%edx
11032a: ff 52 04 call *0x4(%edx)
11032d: e9 c3 fe ff ff jmp 1101f5 <rtems_filesystem_eval_path_generic+0x6d>
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
110332: 8b 40 0c mov 0xc(%eax),%eax
110335: 89 54 24 04 mov %edx,0x4(%esp)
110339: 8b 54 24 1c mov 0x1c(%esp),%edx
11033d: 89 14 24 mov %edx,(%esp)
110340: ff 50 10 call *0x10(%eax)
110343: 84 c0 test %al,%al
110345: 75 a5 jne 1102ec <rtems_filesystem_eval_path_generic+0x164>
110347: 8b 43 2c mov 0x2c(%ebx),%eax
11034a: e9 54 ff ff ff jmp 1102a3 <rtems_filesystem_eval_path_generic+0x11b>
00110388 <rtems_filesystem_eval_path_next_token>:
}
void rtems_filesystem_eval_path_next_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
110388: 57 push %edi
110389: 56 push %esi
11038a: 53 push %ebx
11038b: 52 push %edx
11038c: 8b 74 24 14 mov 0x14(%esp),%esi
rtems_filesystem_eval_path_eat_delimiter(ctx);
110390: 89 34 24 mov %esi,(%esp)
110393: e8 b8 ff ff ff call 110350 <rtems_filesystem_eval_path_eat_delimiter>
ctx->pathlen = (size_t) (end - current);
}
static void next_token(rtems_filesystem_eval_path_context_t *ctx)
{
const char *begin = ctx->path;
110398: 8b 0e mov (%esi),%ecx
const char *end = begin + ctx->pathlen;
11039a: 8b 5e 04 mov 0x4(%esi),%ebx
11039d: 01 cb add %ecx,%ebx
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
11039f: 39 d9 cmp %ebx,%ecx
1103a1: 74 2d je 1103d0 <rtems_filesystem_eval_path_next_token+0x48>
1103a3: 8a 01 mov (%ecx),%al
1103a5: 3c 2f cmp $0x2f,%al
1103a7: 74 27 je 1103d0 <rtems_filesystem_eval_path_next_token+0x48><== NEVER TAKEN
1103a9: 3c 5c cmp $0x5c,%al
1103ab: 74 23 je 1103d0 <rtems_filesystem_eval_path_next_token+0x48><== NEVER TAKEN
1103ad: 89 c8 mov %ecx,%eax
1103af: eb 08 jmp 1103b9 <rtems_filesystem_eval_path_next_token+0x31>
1103b1: 8d 76 00 lea 0x0(%esi),%esi
1103b4: 80 fa 5c cmp $0x5c,%dl
1103b7: 74 0c je 1103c5 <rtems_filesystem_eval_path_next_token+0x3d>
++current;
1103b9: 40 inc %eax
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
1103ba: 39 c3 cmp %eax,%ebx
1103bc: 74 2e je 1103ec <rtems_filesystem_eval_path_next_token+0x64>
1103be: 8a 10 mov (%eax),%dl
1103c0: 80 fa 2f cmp $0x2f,%dl
1103c3: 75 ef jne 1103b4 <rtems_filesystem_eval_path_next_token+0x2c>
1103c5: 89 c7 mov %eax,%edi
1103c7: 89 c2 mov %eax,%edx
1103c9: 29 ca sub %ecx,%edx
1103cb: eb 0b jmp 1103d8 <rtems_filesystem_eval_path_next_token+0x50>
1103cd: 8d 76 00 lea 0x0(%esi),%esi
1103d0: 89 cf mov %ecx,%edi
1103d2: 89 c8 mov %ecx,%eax
1103d4: 31 d2 xor %edx,%edx
1103d6: 66 90 xchg %ax,%ax
++current;
}
ctx->path = current;
1103d8: 89 06 mov %eax,(%esi)
ctx->pathlen = (size_t) (end - current);
1103da: 29 fb sub %edi,%ebx
1103dc: 89 5e 04 mov %ebx,0x4(%esi)
ctx->token = begin;
1103df: 89 4e 08 mov %ecx,0x8(%esi)
ctx->tokenlen = (size_t) (current - begin);
1103e2: 89 56 0c mov %edx,0xc(%esi)
rtems_filesystem_eval_path_context_t *ctx
)
{
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
1103e5: 58 pop %eax
1103e6: 5b pop %ebx
1103e7: 5e pop %esi
1103e8: 5f pop %edi
1103e9: c3 ret
1103ea: 66 90 xchg %ax,%ax
1103ec: 89 df mov %ebx,%edi
1103ee: 89 da mov %ebx,%edx
1103f0: 29 ca sub %ecx,%edx
1103f2: eb e4 jmp 1103d8 <rtems_filesystem_eval_path_next_token+0x50>
00108e98 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
108e98: 55 push %ebp
108e99: 57 push %edi
108e9a: 56 push %esi
108e9b: 53 push %ebx
108e9c: 83 ec 2c sub $0x2c,%esp
108e9f: 8b 5c 24 40 mov 0x40(%esp),%ebx
108ea3: 8b 54 24 44 mov 0x44(%esp),%edx
108ea7: 8b 6c 24 48 mov 0x48(%esp),%ebp
if (pathlen > 0) {
108eab: 85 ed test %ebp,%ebp
108ead: 74 5d je 108f0c <rtems_filesystem_eval_path_recursive+0x74><== NEVER TAKEN
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
108eaf: 83 7b 14 1f cmpl $0x1f,0x14(%ebx)
108eb3: 7f 6f jg 108f24 <rtems_filesystem_eval_path_recursive+0x8c>
const char *saved_path = ctx->path;
108eb5: 8b 33 mov (%ebx),%esi
size_t saved_pathlen = ctx->pathlen;
108eb7: 8b 7b 04 mov 0x4(%ebx),%edi
if (rtems_filesystem_is_delimiter(path [0])) {
108eba: 8a 02 mov (%edx),%al
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
108ebc: 3c 2f cmp $0x2f,%al
108ebe: 74 30 je 108ef0 <rtems_filesystem_eval_path_recursive+0x58>
108ec0: 3c 5c cmp $0x5c,%al
108ec2: 74 2c je 108ef0 <rtems_filesystem_eval_path_recursive+0x58><== NEVER TAKEN
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
108ec4: 89 13 mov %edx,(%ebx)
ctx->pathlen = pathlen;
108ec6: 89 6b 04 mov %ebp,0x4(%ebx)
++ctx->recursionlevel;
108ec9: ff 43 14 incl 0x14(%ebx)
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
108ecc: 8b 43 2c mov 0x2c(%ebx),%eax
108ecf: 8b 40 0c mov 0xc(%eax),%eax
108ed2: 89 1c 24 mov %ebx,(%esp)
108ed5: ff 50 08 call *0x8(%eax)
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
108ed8: 8b 43 04 mov 0x4(%ebx),%eax
108edb: 85 c0 test %eax,%eax
108edd: 75 ed jne 108ecc <rtems_filesystem_eval_path_recursive+0x34>
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
108edf: ff 4b 14 decl 0x14(%ebx)
ctx->path = saved_path;
108ee2: 89 33 mov %esi,(%ebx)
ctx->pathlen = saved_pathlen;
108ee4: 89 7b 04 mov %edi,0x4(%ebx)
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
108ee7: 83 c4 2c add $0x2c,%esp
108eea: 5b pop %ebx
108eeb: 5e pop %esi
108eec: 5f pop %edi
108eed: 5d pop %ebp
108eee: c3 ret
108eef: 90 nop
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
const char *saved_path = ctx->path;
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
108ef0: 8d 43 30 lea 0x30(%ebx),%eax
108ef3: 89 44 24 04 mov %eax,0x4(%esp)
108ef7: 89 1c 24 mov %ebx,(%esp)
108efa: 89 54 24 1c mov %edx,0x1c(%esp)
108efe: e8 31 ff ff ff call 108e34 <rtems_filesystem_eval_path_restart>
108f03: 8b 54 24 1c mov 0x1c(%esp),%edx
108f07: eb bb jmp 108ec4 <rtems_filesystem_eval_path_recursive+0x2c>
108f09: 8d 76 00 lea 0x0(%esi),%esi
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
108f0c: c7 44 24 44 02 00 00 movl $0x2,0x44(%esp) <== NOT EXECUTED
108f13: 00
108f14: 89 5c 24 40 mov %ebx,0x40(%esp) <== NOT EXECUTED
}
}
108f18: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
108f1b: 5b pop %ebx <== NOT EXECUTED
108f1c: 5e pop %esi <== NOT EXECUTED
108f1d: 5f pop %edi <== NOT EXECUTED
108f1e: 5d pop %ebp <== NOT EXECUTED
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
108f1f: e9 10 fb ff ff jmp 108a34 <rtems_filesystem_eval_path_error><== NOT EXECUTED
--ctx->recursionlevel;
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
108f24: c7 44 24 44 5c 00 00 movl $0x5c,0x44(%esp)
108f2b: 00
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
108f2c: 89 5c 24 40 mov %ebx,0x40(%esp)
}
}
108f30: 83 c4 2c add $0x2c,%esp
108f33: 5b pop %ebx
108f34: 5e pop %esi
108f35: 5f pop %edi
108f36: 5d pop %ebp
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
108f37: e9 f8 fa ff ff jmp 108a34 <rtems_filesystem_eval_path_error>
00108d20 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
108d20: 57 push %edi
108d21: 56 push %esi
108d22: 53 push %ebx
108d23: 83 ec 10 sub $0x10,%esp
108d26: 8b 5c 24 20 mov 0x20(%esp),%ebx
108d2a: 8b 54 24 24 mov 0x24(%esp),%edx
size_t pathlen = strlen(path);
108d2e: 31 c0 xor %eax,%eax
108d30: b9 ff ff ff ff mov $0xffffffff,%ecx
108d35: 89 d7 mov %edx,%edi
108d37: f2 ae repnz scas %es:(%edi),%al
108d39: f7 d1 not %ecx
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
108d3b: 89 cf mov %ecx,%edi
108d3d: 4f dec %edi
108d3e: 0f 84 8c 00 00 00 je 108dd0 <rtems_filesystem_eval_path_start_with_parent+0xb0>
size_t i = pathlen - 1;
108d44: 83 e9 02 sub $0x2,%ecx
if (rtems_filesystem_is_delimiter(path [i])) {
108d47: 8a 04 0a mov (%edx,%ecx,1),%al
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
108d4a: 3c 2f cmp $0x2f,%al
108d4c: 74 04 je 108d52 <rtems_filesystem_eval_path_start_with_parent+0x32>
108d4e: 3c 5c cmp $0x5c,%al
108d50: 75 0c jne 108d5e <rtems_filesystem_eval_path_start_with_parent+0x3e><== ALWAYS TAKEN
108d52: 89 f9 mov %edi,%ecx
108d54: 31 f6 xor %esi,%esi
108d56: eb 18 jmp 108d70 <rtems_filesystem_eval_path_start_with_parent+0x50>
108d58: 3c 5c cmp $0x5c,%al
108d5a: 74 10 je 108d6c <rtems_filesystem_eval_path_start_with_parent+0x4c><== NEVER TAKEN
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
108d5c: 89 f1 mov %esi,%ecx
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
108d5e: 85 c9 test %ecx,%ecx
108d60: 74 5e je 108dc0 <rtems_filesystem_eval_path_start_with_parent+0xa0>
size_t i = pathlen - 1;
108d62: 8d 71 ff lea -0x1(%ecx),%esi
if (rtems_filesystem_is_delimiter(path [i])) {
108d65: 8a 04 32 mov (%edx,%esi,1),%al
108d68: 3c 2f cmp $0x2f,%al
108d6a: 75 ec jne 108d58 <rtems_filesystem_eval_path_start_with_parent+0x38>
108d6c: 89 fe mov %edi,%esi
108d6e: 29 ce sub %ecx,%esi
parentpath = ".";
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
108d70: 8d 3c 0a lea (%edx,%ecx,1),%edi
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
108d73: a1 60 d2 12 00 mov 0x12d260,%eax
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
108d78: 89 44 24 08 mov %eax,0x8(%esp)
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
108d7c: 83 c0 04 add $0x4,%eax
108d7f: 89 44 24 04 mov %eax,0x4(%esp)
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
108d83: 8b 44 24 30 mov 0x30(%esp),%eax
108d87: 89 04 24 mov %eax,(%esp)
108d8a: 89 d8 mov %ebx,%eax
108d8c: e8 3b fe ff ff call 108bcc <eval_path_start>
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
108d91: 89 44 24 04 mov %eax,0x4(%esp)
108d95: 8b 44 24 2c mov 0x2c(%esp),%eax
108d99: 89 04 24 mov %eax,(%esp)
108d9c: e8 eb 6d 00 00 call 10fb8c <rtems_filesystem_location_clone>
ctx->path = name;
108da1: 89 3b mov %edi,(%ebx)
ctx->pathlen = namelen;
108da3: 89 73 04 mov %esi,0x4(%ebx)
ctx->flags = eval_flags;
108da6: 8b 44 24 28 mov 0x28(%esp),%eax
108daa: 89 43 10 mov %eax,0x10(%ebx)
rtems_filesystem_eval_path_continue(ctx);
108dad: 89 1c 24 mov %ebx,(%esp)
108db0: e8 93 fd ff ff call 108b48 <rtems_filesystem_eval_path_continue>
return &ctx->currentloc;
108db5: 8d 43 18 lea 0x18(%ebx),%eax
}
108db8: 83 c4 10 add $0x10,%esp
108dbb: 5b pop %ebx
108dbc: 5e pop %esi
108dbd: 5f pop %edi
108dbe: c3 ret
108dbf: 90 nop
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
108dc0: 89 fe mov %edi,%esi
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
name = path;
108dc2: 89 d7 mov %edx,%edi
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
parentpathlen = 1;
108dc4: b1 01 mov $0x1,%cl
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
108dc6: ba d1 1c 12 00 mov $0x121cd1,%edx
108dcb: eb a6 jmp 108d73 <rtems_filesystem_eval_path_start_with_parent+0x53>
108dcd: 8d 76 00 lea 0x0(%esi),%esi
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
108dd0: 31 f6 xor %esi,%esi
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
108dd2: 31 ff xor %edi,%edi
}
pathlen = i;
}
return 0;
108dd4: 31 c9 xor %ecx,%ecx
108dd6: eb 9b jmp 108d73 <rtems_filesystem_eval_path_start_with_parent+0x53>
0010fef0 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
10fef0: 83 ec 2c sub $0x2c,%esp
10fef3: 8b 44 24 30 mov 0x30(%esp),%eax
find_arg fa = {
10fef7: 89 44 24 18 mov %eax,0x18(%esp)
10fefb: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp)
10ff02: 00
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10ff03: 85 c0 test %eax,%eax
10ff05: 74 1d je 10ff24 <rtems_filesystem_get_mount_handler+0x34><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
10ff07: 8d 44 24 18 lea 0x18(%esp),%eax
10ff0b: 89 44 24 04 mov %eax,0x4(%esp)
10ff0f: c7 04 24 10 fe 10 00 movl $0x10fe10,(%esp)
10ff16: e8 2d ff ff ff call 10fe48 <rtems_filesystem_iterate>
10ff1b: 8b 44 24 1c mov 0x1c(%esp),%eax
}
return fa.mount_h;
}
10ff1f: 83 c4 2c add $0x2c,%esp
10ff22: c3 ret
10ff23: 90 nop
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10ff24: 31 c0 xor %eax,%eax <== NOT EXECUTED
rtems_filesystem_iterate( find_handler, &fa );
}
return fa.mount_h;
}
10ff26: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
10ff29: c3 ret <== NOT EXECUTED
0010767c <rtems_filesystem_initialize>:
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
10767c: 83 ec 2c sub $0x2c,%esp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
10767f: a1 58 f9 11 00 mov 0x11f958,%eax
107684: 89 44 24 10 mov %eax,0x10(%esp)
107688: a1 54 f9 11 00 mov 0x11f954,%eax
10768d: 89 44 24 0c mov %eax,0xc(%esp)
107691: a1 50 f9 11 00 mov 0x11f950,%eax
107696: 89 44 24 08 mov %eax,0x8(%esp)
10769a: a1 4c f9 11 00 mov 0x11f94c,%eax
10769f: 89 44 24 04 mov %eax,0x4(%esp)
1076a3: a1 48 f9 11 00 mov 0x11f948,%eax
1076a8: 89 04 24 mov %eax,(%esp)
1076ab: e8 b0 07 00 00 call 107e60 <mount>
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
1076b0: 85 c0 test %eax,%eax
1076b2: 75 1c jne 1076d0 <rtems_filesystem_initialize+0x54><== NEVER TAKEN
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
1076b4: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp)
1076bb: 00
1076bc: c7 04 24 c4 0f 12 00 movl $0x120fc4,(%esp)
1076c3: e8 38 06 00 00 call 107d00 <mkdir>
if ( rv != 0 )
1076c8: 85 c0 test %eax,%eax
1076ca: 75 10 jne 1076dc <rtems_filesystem_initialize+0x60><== NEVER TAKEN
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
1076cc: 83 c4 2c add $0x2c,%esp
1076cf: c3 ret
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0002 );
1076d0: c7 04 24 02 00 cd ab movl $0xabcd0002,(%esp) <== NOT EXECUTED
1076d7: e8 d4 49 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
1076dc: c7 04 24 03 00 cd ab movl $0xabcd0003,(%esp) <== NOT EXECUTED
1076e3: e8 c8 49 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
0010fe48 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10fe48: 57 push %edi
10fe49: 56 push %esi
10fe4a: 53 push %ebx
10fe4b: 83 ec 20 sub $0x20,%esp
10fe4e: 8b 74 24 30 mov 0x30(%esp),%esi
10fe52: 8b 7c 24 34 mov 0x34(%esp),%edi
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10fe56: bb 5c f9 11 00 mov $0x11f95c,%ebx
10fe5b: 8b 15 5c f9 11 00 mov 0x11f95c,%edx
10fe61: 85 d2 test %edx,%edx
10fe63: 75 07 jne 10fe6c <rtems_filesystem_iterate+0x24><== ALWAYS TAKEN
10fe65: eb 1d jmp 10fe84 <rtems_filesystem_iterate+0x3c><== NOT EXECUTED
10fe67: 90 nop <== NOT EXECUTED
10fe68: 84 d2 test %dl,%dl
10fe6a: 75 79 jne 10fee5 <rtems_filesystem_iterate+0x9d>
stop = (*routine)( table_entry, routine_arg );
10fe6c: 89 7c 24 04 mov %edi,0x4(%esp)
10fe70: 89 1c 24 mov %ebx,(%esp)
10fe73: ff d6 call *%esi
10fe75: 88 c2 mov %al,%dl
++table_entry;
10fe77: 83 c3 08 add $0x8,%ebx
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10fe7a: 8b 03 mov (%ebx),%eax
10fe7c: 85 c0 test %eax,%eax
10fe7e: 75 e8 jne 10fe68 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
10fe80: 84 d2 test %dl,%dl
10fe82: 75 61 jne 10fee5 <rtems_filesystem_iterate+0x9d>
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10fe84: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10fe8b: 00
10fe8c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10fe93: 00
10fe94: a1 dc f4 12 00 mov 0x12f4dc,%eax
10fe99: 89 04 24 mov %eax,(%esp)
10fe9c: e8 db ba ff ff call 10b97c <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10fea1: 8b 1d 48 d3 12 00 mov 0x12d348,%ebx
rtems_libio_lock();
for (
10fea7: 31 d2 xor %edx,%edx
10fea9: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx
10feaf: 75 07 jne 10feb8 <rtems_filesystem_iterate+0x70>
10feb1: eb 1d jmp 10fed0 <rtems_filesystem_iterate+0x88>
10feb3: 90 nop
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
10feb4: 84 c0 test %al,%al
10feb6: 75 18 jne 10fed0 <rtems_filesystem_iterate+0x88><== NEVER TAKEN
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
10feb8: 89 7c 24 04 mov %edi,0x4(%esp)
10febc: 8d 43 08 lea 0x8(%ebx),%eax
10febf: 89 04 24 mov %eax,(%esp)
10fec2: ff d6 call *%esi
10fec4: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10fec6: 8b 1b mov (%ebx),%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10fec8: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx
10fece: 75 e4 jne 10feb4 <rtems_filesystem_iterate+0x6c>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10fed0: a1 dc f4 12 00 mov 0x12f4dc,%eax
10fed5: 89 04 24 mov %eax,(%esp)
10fed8: 88 54 24 1c mov %dl,0x1c(%esp)
10fedc: e8 c7 bb ff ff call 10baa8 <rtems_semaphore_release>
10fee1: 8a 54 24 1c mov 0x1c(%esp),%dl
}
rtems_libio_unlock();
}
return stop;
}
10fee5: 88 d0 mov %dl,%al
10fee7: 83 c4 20 add $0x20,%esp
10feea: 5b pop %ebx
10feeb: 5e pop %esi
10feec: 5f pop %edi
10feed: c3 ret
00109028 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
109028: 56 push %esi
109029: 53 push %ebx
10902a: 8b 44 24 0c mov 0xc(%esp),%eax
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
bool do_unmount;
rtems_filesystem_mt_entry_lock(lock_context);
10902e: 9c pushf
10902f: fa cli
109030: 5b pop %ebx
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
109031: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
109033: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
109036: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
109039: 89 0a mov %ecx,(%edx)
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
10903b: 8b 50 14 mov 0x14(%eax),%edx
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
10903e: 80 7a 28 00 cmpb $0x0,0x28(%edx)
109042: 75 08 jne 10904c <rtems_filesystem_location_remove_from_mt_entry+0x24>
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
109044: 8b 4a 1c mov 0x1c(%edx),%ecx
109047: 39 4a 14 cmp %ecx,0x14(%edx)
10904a: 74 1c je 109068 <rtems_filesystem_location_remove_from_mt_entry+0x40>
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
10904c: 31 d2 xor %edx,%edx
rtems_filesystem_mt_entry_unlock(lock_context);
10904e: 53 push %ebx
10904f: 9d popf
if (do_unmount) {
109050: 84 d2 test %dl,%dl
109052: 75 04 jne 109058 <rtems_filesystem_location_remove_from_mt_entry+0x30><== NEVER TAKEN
rtems_filesystem_do_unmount(loc->mt_entry);
}
}
109054: 5b pop %ebx
109055: 5e pop %esi
109056: c3 ret
109057: 90 nop
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_unmount) {
rtems_filesystem_do_unmount(loc->mt_entry);
109058: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED
10905b: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
}
}
10905f: 5b pop %ebx <== NOT EXECUTED
109060: 5e pop %esi <== NOT EXECUTED
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_unmount) {
rtems_filesystem_do_unmount(loc->mt_entry);
109061: e9 3e ff ff ff jmp 108fa4 <rtems_filesystem_do_unmount><== NOT EXECUTED
109066: 66 90 xchg %ax,%ax <== NOT EXECUTED
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
109068: 8b 4a 24 mov 0x24(%edx),%ecx
10906b: 83 79 18 01 cmpl $0x1,0x18(%ecx)
10906f: 75 db jne 10904c <rtems_filesystem_location_remove_from_mt_entry+0x24><== ALWAYS TAKEN
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 );
109071: 8d 4a 14 lea 0x14(%edx),%ecx <== NOT EXECUTED
109074: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED
109077: 89 72 14 mov %esi,0x14(%edx) <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
10907a: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
109081: 89 4a 1c mov %ecx,0x1c(%edx) <== NOT EXECUTED
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
109084: b2 01 mov $0x1,%dl <== NOT EXECUTED
109086: eb c6 jmp 10904e <rtems_filesystem_location_remove_from_mt_entry+0x26><== NOT EXECUTED
00109224 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
109224: 56 push %esi
109225: 53 push %ebx
109226: 83 ec 24 sub $0x24,%esp
109229: 8b 74 24 30 mov 0x30(%esp),%esi
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
10922d: c7 04 24 24 00 00 00 movl $0x24,(%esp)
109234: e8 17 ea ff ff call 107c50 <malloc>
109239: 89 c3 mov %eax,%ebx
if (global_loc != NULL) {
10923b: 85 c0 test %eax,%eax
10923d: 74 31 je 109270 <rtems_filesystem_location_transform_to_global+0x4c><== NEVER TAKEN
global_loc->reference_count = 1;
10923f: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
global_loc->deferred_released_next = NULL;
109246: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
global_loc->deferred_released_count = 0;
10924d: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
rtems_filesystem_location_copy(&global_loc->location, loc);
109254: 89 74 24 04 mov %esi,0x4(%esp)
109258: 89 04 24 mov %eax,(%esp)
10925b: e8 dc fc ff ff call 108f3c <rtems_filesystem_location_copy>
rtems_filesystem_location_remove_from_mt_entry(loc);
109260: 89 34 24 mov %esi,(%esp)
109263: e8 c0 fd ff ff call 109028 <rtems_filesystem_location_remove_from_mt_entry>
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
109268: 89 d8 mov %ebx,%eax
10926a: 83 c4 24 add $0x24,%esp
10926d: 5b pop %ebx
10926e: 5e pop %esi
10926f: c3 ret
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
rtems_filesystem_location_remove_from_mt_entry(loc);
} else {
rtems_filesystem_location_free(loc);
109270: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
109273: e8 64 69 00 00 call 10fbdc <rtems_filesystem_location_free><== NOT EXECUTED
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
109278: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp) <== NOT EXECUTED
10927f: 00
return rtems_filesystem_global_location_obtain( &global_loc );
109280: 8d 44 24 1c lea 0x1c(%esp),%eax <== NOT EXECUTED
109284: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109287: e8 10 ff ff ff call 10919c <rtems_filesystem_global_location_obtain><== NOT EXECUTED
10928c: 89 c3 mov %eax,%ebx <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
10928e: e8 65 9a 00 00 call 112cf8 <__errno> <== NOT EXECUTED
109293: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
}
return global_loc;
}
109299: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10929b: 83 c4 24 add $0x24,%esp <== NOT EXECUTED
10929e: 5b pop %ebx <== NOT EXECUTED
10929f: 5e pop %esi <== NOT EXECUTED
1092a0: c3 ret <== NOT EXECUTED
00107d30 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
107d30: 55 push %ebp
107d31: 57 push %edi
107d32: 56 push %esi
107d33: 53 push %ebx
107d34: 83 ec 0c sub $0xc,%esp
107d37: 8b 74 24 20 mov 0x20(%esp),%esi
107d3b: 8b 7c 24 24 mov 0x24(%esp),%edi
107d3f: 8b 6c 24 28 mov 0x28(%esp),%ebp
107d43: 8b 44 24 30 mov 0x30(%esp),%eax
107d47: 8b 54 24 34 mov 0x34(%esp),%edx
int rv = 0;
mode &= ~rtems_filesystem_umask;
107d4b: 8b 0d 60 d2 12 00 mov 0x12d260,%ecx
107d51: 8b 49 08 mov 0x8(%ecx),%ecx
107d54: f7 d1 not %ecx
107d56: 23 4c 24 2c and 0x2c(%esp),%ecx
switch (mode & S_IFMT) {
107d5a: 89 cb mov %ecx,%ebx
107d5c: 81 e3 00 f0 00 00 and $0xf000,%ebx
107d62: 81 fb 00 40 00 00 cmp $0x4000,%ebx
107d68: 74 3a je 107da4 <rtems_filesystem_mknod+0x74>
107d6a: 76 28 jbe 107d94 <rtems_filesystem_mknod+0x64>
107d6c: 81 fb 00 60 00 00 cmp $0x6000,%ebx
107d72: 74 30 je 107da4 <rtems_filesystem_mknod+0x74>
107d74: 81 fb 00 80 00 00 cmp $0x8000,%ebx
107d7a: 74 28 je 107da4 <rtems_filesystem_mknod+0x74><== ALWAYS TAKEN
case S_IFDIR:
case S_IFIFO:
case S_IFREG:
break;
default:
errno = EINVAL;
107d7c: e8 77 af 00 00 call 112cf8 <__errno>
107d81: c7 00 16 00 00 00 movl $0x16,(%eax)
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
}
return rv;
}
107d87: b8 ff ff ff ff mov $0xffffffff,%eax
107d8c: 83 c4 0c add $0xc,%esp
107d8f: 5b pop %ebx
107d90: 5e pop %esi
107d91: 5f pop %edi
107d92: 5d pop %ebp
107d93: c3 ret
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
107d94: 81 fb 00 10 00 00 cmp $0x1000,%ebx
107d9a: 74 08 je 107da4 <rtems_filesystem_mknod+0x74>
107d9c: 81 fb 00 20 00 00 cmp $0x2000,%ebx
107da2: 75 d8 jne 107d7c <rtems_filesystem_mknod+0x4c>
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
107da4: 8b 5e 14 mov 0x14(%esi),%ebx
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
107da7: 8b 5b 0c mov 0xc(%ebx),%ebx
107daa: 89 44 24 30 mov %eax,0x30(%esp)
107dae: 89 54 24 34 mov %edx,0x34(%esp)
107db2: 89 4c 24 2c mov %ecx,0x2c(%esp)
107db6: 89 6c 24 28 mov %ebp,0x28(%esp)
107dba: 89 7c 24 24 mov %edi,0x24(%esp)
107dbe: 89 74 24 20 mov %esi,0x20(%esp)
107dc2: 8b 43 18 mov 0x18(%ebx),%eax
}
return rv;
}
107dc5: 83 c4 0c add $0xc,%esp
107dc8: 5b pop %ebx
107dc9: 5e pop %esi
107dca: 5f pop %edi
107dcb: 5d pop %ebp
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
107dcc: ff e0 jmp *%eax
00110004 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
110004: 56 push %esi
110005: 53 push %ebx
110006: 83 ec 14 sub $0x14,%esp
110009: 8b 74 24 20 mov 0x20(%esp),%esi
rtems_chain_node *node = NULL;
if ( type == NULL ) {
11000d: 85 f6 test %esi,%esi
11000f: 0f 84 96 00 00 00 je 1100ab <rtems_filesystem_unregister+0xa7>
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
110015: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
11001c: 00
11001d: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
110024: 00
110025: a1 dc f4 12 00 mov 0x12f4dc,%eax
11002a: 89 04 24 mov %eax,(%esp)
11002d: e8 4a b9 ff ff call 10b97c <rtems_semaphore_obtain>
110032: 8b 1d 48 d3 12 00 mov 0x12d348,%ebx
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
110038: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx
11003e: 75 0e jne 11004e <rtems_filesystem_unregister+0x4a>
110040: eb 46 jmp 110088 <rtems_filesystem_unregister+0x84>
110042: 66 90 xchg %ax,%ax
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110044: 8b 1b mov (%ebx),%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
110046: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx
11004c: 74 3a je 110088 <rtems_filesystem_unregister+0x84><== ALWAYS TAKEN
!rtems_chain_is_tail( &filesystem_chain, node );
node = rtems_chain_next( node )
) {
filesystem_node *fsn = (filesystem_node *) node;
if ( strcmp( fsn->entry.type, type ) == 0 ) {
11004e: 89 74 24 04 mov %esi,0x4(%esp)
110052: 8b 43 08 mov 0x8(%ebx),%eax
110055: 89 04 24 mov %eax,(%esp)
110058: e8 3f 3a 00 00 call 113a9c <strcmp>
11005d: 85 c0 test %eax,%eax
11005f: 75 e3 jne 110044 <rtems_filesystem_unregister+0x40>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
110061: 89 1c 24 mov %ebx,(%esp)
110064: e8 73 0b 00 00 call 110bdc <_Chain_Extract>
rtems_chain_extract( node );
free( fsn );
110069: 89 1c 24 mov %ebx,(%esp)
11006c: e8 cb 78 ff ff call 10793c <free>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110071: a1 dc f4 12 00 mov 0x12f4dc,%eax
110076: 89 04 24 mov %eax,(%esp)
110079: e8 2a ba ff ff call 10baa8 <rtems_semaphore_release>
rtems_libio_unlock();
return 0;
11007e: 31 c0 xor %eax,%eax
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110080: 83 c4 14 add $0x14,%esp
110083: 5b pop %ebx
110084: 5e pop %esi
110085: c3 ret
110086: 66 90 xchg %ax,%ax
110088: a1 dc f4 12 00 mov 0x12f4dc,%eax
11008d: 89 04 24 mov %eax,(%esp)
110090: e8 13 ba ff ff call 10baa8 <rtems_semaphore_release>
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
110095: e8 5e 2c 00 00 call 112cf8 <__errno>
11009a: c7 00 02 00 00 00 movl $0x2,(%eax)
1100a0: b8 ff ff ff ff mov $0xffffffff,%eax
}
1100a5: 83 c4 14 add $0x14,%esp
1100a8: 5b pop %ebx
1100a9: 5e pop %esi
1100aa: c3 ret
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
1100ab: e8 48 2c 00 00 call 112cf8 <__errno>
1100b0: c7 00 16 00 00 00 movl $0x16,(%eax)
1100b6: b8 ff ff ff ff mov $0xffffffff,%eax
1100bb: eb e8 jmp 1100a5 <rtems_filesystem_unregister+0xa1>
00108150 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
108150: 56 push %esi
108151: 53 push %ebx
108152: 83 ec 14 sub $0x14,%esp
108155: 8b 74 24 24 mov 0x24(%esp),%esi
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
108159: c7 04 24 08 00 00 00 movl $0x8,(%esp)
108160: e8 13 04 00 00 call 108578 <malloc>
108165: 89 c3 mov %eax,%ebx
*key = new_key;
108167: 8b 44 24 20 mov 0x20(%esp),%eax
10816b: 89 18 mov %ebx,(%eax)
new_key->val = NULL;
10816d: c7 03 00 00 00 00 movl $0x0,(%ebx)
new_key->dtor = dtor;
108173: 89 73 04 mov %esi,0x4(%ebx)
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
108176: 89 74 24 08 mov %esi,0x8(%esp)
10817a: 89 5c 24 04 mov %ebx,0x4(%esp)
10817e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
108185: e8 66 47 00 00 call 10c8f0 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
10818a: 85 c0 test %eax,%eax
10818c: 75 0a jne 108198 <rtems_gxx_key_create+0x48><== NEVER TAKEN
return 0;
10818e: 31 c0 xor %eax,%eax
free( new_key );
return -1;
}
108190: 83 c4 14 add $0x14,%esp
108193: 5b pop %ebx
108194: 5e pop %esi
108195: c3 ret
108196: 66 90 xchg %ax,%ax
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
if ( status == RTEMS_SUCCESSFUL )
return 0;
free( new_key );
108198: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10819b: e8 ec fd ff ff call 107f8c <free> <== NOT EXECUTED
return -1;
1081a0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1081a5: eb e9 jmp 108190 <rtems_gxx_key_create+0x40><== NOT EXECUTED
001081b8 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
1081b8: 53 push %ebx
1081b9: 83 ec 18 sub $0x18,%esp
1081bc: 8b 5c 24 20 mov 0x20(%esp),%ebx
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
1081c0: 89 5c 24 04 mov %ebx,0x4(%esp)
1081c4: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1081cb: e8 d0 47 00 00 call 10c9a0 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
1081d0: 85 c0 test %eax,%eax
1081d2: 75 0e jne 1081e2 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
1081d4: 85 db test %ebx,%ebx
1081d6: 74 0a je 1081e2 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
1081d8: 8b 03 mov (%ebx),%eax
1081da: 89 04 24 mov %eax,(%esp)
1081dd: e8 aa fd ff ff call 107f8c <free>
return 0;
}
key = NULL;
return 0;
}
1081e2: 31 c0 xor %eax,%eax
1081e4: 83 c4 18 add $0x18,%esp
1081e7: 5b pop %ebx
1081e8: c3 ret
001080cc <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
1080cc: 56 push %esi
1080cd: 53 push %ebx
1080ce: 83 ec 24 sub $0x24,%esp
1080d1: 8b 5c 24 30 mov 0x30(%esp),%ebx
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
1080d5: 8b 03 mov (%ebx),%eax
1080d7: 85 c0 test %eax,%eax
1080d9: 74 09 je 1080e4 <rtems_gxx_once+0x18>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
1080db: 31 c0 xor %eax,%eax
1080dd: 83 c4 24 add $0x24,%esp
1080e0: 5b pop %ebx
1080e1: 5e pop %esi
1080e2: c3 ret
1080e3: 90 nop
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
1080e4: 8d 74 24 1c lea 0x1c(%esp),%esi
1080e8: 89 74 24 08 mov %esi,0x8(%esp)
1080ec: c7 44 24 04 00 01 00 movl $0x100,0x4(%esp)
1080f3: 00
1080f4: c7 04 24 00 01 00 00 movl $0x100,(%esp)
1080fb: e8 08 46 00 00 call 10c708 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
108100: 8b 03 mov (%ebx),%eax
108102: 85 c0 test %eax,%eax
108104: 75 2a jne 108130 <rtems_gxx_once+0x64> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
108106: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10810c: 89 74 24 08 mov %esi,0x8(%esp)
108110: c7 44 24 04 00 01 00 movl $0x100,0x4(%esp)
108117: 00
108118: 8b 44 24 1c mov 0x1c(%esp),%eax
10811c: 89 04 24 mov %eax,(%esp)
10811f: e8 e4 45 00 00 call 10c708 <rtems_task_mode>
if ( o == 0 )
(*func)();
108124: ff 54 24 34 call *0x34(%esp)
}
return 0;
}
108128: 31 c0 xor %eax,%eax
10812a: 83 c4 24 add $0x24,%esp
10812d: 5b pop %ebx
10812e: 5e pop %esi
10812f: c3 ret
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
108130: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
108134: c7 44 24 04 00 01 00 movl $0x100,0x4(%esp) <== NOT EXECUTED
10813b: 00
10813c: 8b 44 24 1c mov 0x1c(%esp),%eax <== NOT EXECUTED
108140: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
108143: e8 c0 45 00 00 call 10c708 <rtems_task_mode> <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
108148: 31 c0 xor %eax,%eax <== NOT EXECUTED
10814a: 83 c4 24 add $0x24,%esp <== NOT EXECUTED
10814d: 5b pop %ebx <== NOT EXECUTED
10814e: 5e pop %esi <== NOT EXECUTED
10814f: c3 ret <== NOT EXECUTED
00108268 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
108268: 53 push %ebx
108269: 83 ec 18 sub $0x18,%esp
10826c: 8b 5c 24 20 mov 0x20(%esp),%ebx
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
108270: 8b 43 04 mov 0x4(%ebx),%eax
108273: 89 44 24 08 mov %eax,0x8(%esp)
108277: 89 5c 24 04 mov %ebx,0x4(%esp)
10827b: c7 04 24 00 00 00 00 movl $0x0,(%esp)
108282: e8 69 46 00 00 call 10c8f0 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
108287: 85 c0 test %eax,%eax
108289: 75 0d jne 108298 <rtems_gxx_setspecific+0x30><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
10828b: 8b 44 24 24 mov 0x24(%esp),%eax
10828f: 89 03 mov %eax,(%ebx)
return 0;
108291: 31 c0 xor %eax,%eax
}
return -1;
}
108293: 83 c4 18 add $0x18,%esp
108296: 5b pop %ebx
108297: c3 ret
if ( status == RTEMS_SUCCESSFUL ) {
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
108298: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10829d: eb f4 jmp 108293 <rtems_gxx_setspecific+0x2b><== NOT EXECUTED
0010b95c <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10b95c: 83 ec 1c sub $0x1c,%esp
if (
10b95f: 83 3d 20 75 13 00 03 cmpl $0x3,0x137520
10b966: 74 30 je 10b998 <rtems_heap_allocate_aligned_with_boundary+0x3c><== ALWAYS TAKEN
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
10b968: e8 37 ef ff ff call 10a8a4 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10b96d: 8b 44 24 28 mov 0x28(%esp),%eax
10b971: 89 44 24 0c mov %eax,0xc(%esp)
10b975: 8b 44 24 24 mov 0x24(%esp),%eax
10b979: 89 44 24 08 mov %eax,0x8(%esp)
10b97d: 8b 44 24 20 mov 0x20(%esp),%eax
10b981: 89 44 24 04 mov %eax,0x4(%esp)
10b985: a1 50 27 13 00 mov 0x132750,%eax
10b98a: 89 04 24 mov %eax,(%esp)
10b98d: e8 de 58 00 00 call 111270 <_Protected_heap_Allocate_aligned_with_boundary>
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10b992: 83 c4 1c add $0x1c,%esp
10b995: c3 ret
10b996: 66 90 xchg %ax,%ax
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10b998: e8 cf ee ff ff call 10a86c <malloc_is_system_state_OK>
10b99d: 84 c0 test %al,%al
10b99f: 75 c7 jne 10b968 <rtems_heap_allocate_aligned_with_boundary+0xc>
) {
return NULL;
10b9a1: 31 c0 xor %eax,%eax
10b9a3: eb ed jmp 10b992 <rtems_heap_allocate_aligned_with_boundary+0x36>
0010d56c <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
)
{
10d56c: 57 push %edi
10d56d: 56 push %esi
10d56e: 53 push %ebx
10d56f: 8b 5c 24 10 mov 0x10(%esp),%ebx
10d573: 8b 74 24 14 mov 0x14(%esp),%esi
10d577: 8b 44 24 18 mov 0x18(%esp),%eax
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10d57b: 8b 15 c0 49 13 00 mov 0x1349c0,%edx
if ( rtems_interrupt_is_in_progress() )
10d581: 8b 0d e8 48 13 00 mov 0x1348e8,%ecx
10d587: 85 c9 test %ecx,%ecx
10d589: 74 09 je 10d594 <rtems_io_register_driver+0x28>
return RTEMS_CALLED_FROM_ISR;
10d58b: 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 );
}
10d590: 5b pop %ebx
10d591: 5e pop %esi
10d592: 5f pop %edi
10d593: c3 ret
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10d594: 85 c0 test %eax,%eax
10d596: 74 24 je 10d5bc <rtems_io_register_driver+0x50>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10d598: 89 10 mov %edx,(%eax)
if ( driver_table == NULL )
10d59a: 85 f6 test %esi,%esi
10d59c: 74 1e je 10d5bc <rtems_io_register_driver+0x50>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10d59e: 8b 3e mov (%esi),%edi
10d5a0: 85 ff test %edi,%edi
10d5a2: 74 10 je 10d5b4 <rtems_io_register_driver+0x48>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10d5a4: 39 da cmp %ebx,%edx
10d5a6: 77 20 ja 10d5c8 <rtems_io_register_driver+0x5c>
return RTEMS_INVALID_NUMBER;
10d5a8: 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 );
}
10d5ad: 5b pop %ebx
10d5ae: 5e pop %esi
10d5af: 5f pop %edi
10d5b0: c3 ret
10d5b1: 8d 76 00 lea 0x0(%esi),%esi
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10d5b4: 8b 4e 04 mov 0x4(%esi),%ecx
10d5b7: 85 c9 test %ecx,%ecx
10d5b9: 75 e9 jne 10d5a4 <rtems_io_register_driver+0x38>
10d5bb: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10d5bc: 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 );
}
10d5c1: 5b pop %ebx
10d5c2: 5e pop %esi
10d5c3: 5f pop %edi
10d5c4: c3 ret
10d5c5: 8d 76 00 lea 0x0(%esi),%esi
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
10d5c8: 8b 15 84 46 13 00 mov 0x134684,%edx
10d5ce: 42 inc %edx
10d5cf: 89 15 84 46 13 00 mov %edx,0x134684
return _Thread_Dispatch_disable_level;
10d5d5: 8b 15 84 46 13 00 mov 0x134684,%edx
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10d5db: 85 db test %ebx,%ebx
10d5dd: 74 1e je 10d5fd <rtems_io_register_driver+0x91>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
10d5df: 8d 14 5b lea (%ebx,%ebx,2),%edx
10d5e2: 8b 3d c4 49 13 00 mov 0x1349c4,%edi
10d5e8: 8d 14 d7 lea (%edi,%edx,8),%edx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10d5eb: 8b 0a mov (%edx),%ecx
10d5ed: 85 c9 test %ecx,%ecx
10d5ef: 74 7d je 10d66e <rtems_io_register_driver+0x102>
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();
10d5f1: e8 8a 1c 00 00 call 10f280 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10d5f6: b8 0c 00 00 00 mov $0xc,%eax
10d5fb: eb 93 jmp 10d590 <rtems_io_register_driver+0x24>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
10d5fd: 8b 0d c0 49 13 00 mov 0x1349c0,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10d603: 85 c9 test %ecx,%ecx
10d605: 74 76 je 10d67d <rtems_io_register_driver+0x111><== NEVER TAKEN
10d607: 8b 3d c4 49 13 00 mov 0x1349c4,%edi
10d60d: 89 fa mov %edi,%edx
10d60f: eb 0b jmp 10d61c <rtems_io_register_driver+0xb0>
10d611: 8d 76 00 lea 0x0(%esi),%esi
10d614: 43 inc %ebx
10d615: 83 c2 18 add $0x18,%edx
10d618: 39 cb cmp %ecx,%ebx
10d61a: 74 41 je 10d65d <rtems_io_register_driver+0xf1>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10d61c: 83 3a 00 cmpl $0x0,(%edx)
10d61f: 75 f3 jne 10d614 <rtems_io_register_driver+0xa8>
10d621: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10d625: 75 ed jne 10d614 <rtems_io_register_driver+0xa8>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10d627: 89 18 mov %ebx,(%eax)
if ( m != n )
10d629: 39 d9 cmp %ebx,%ecx
10d62b: 74 32 je 10d65f <rtems_io_register_driver+0xf3><== NEVER TAKEN
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10d62d: 8d 04 5b lea (%ebx,%ebx,2),%eax
10d630: 8d 04 c7 lea (%edi,%eax,8),%eax
10d633: b9 06 00 00 00 mov $0x6,%ecx
10d638: 89 c7 mov %eax,%edi
10d63a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10d63c: e8 3f 1c 00 00 call 10f280 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10d641: c7 44 24 18 00 00 00 movl $0x0,0x18(%esp)
10d648: 00
10d649: c7 44 24 14 00 00 00 movl $0x0,0x14(%esp)
10d650: 00
10d651: 89 5c 24 10 mov %ebx,0x10(%esp)
}
10d655: 5b pop %ebx
10d656: 5e pop %esi
10d657: 5f pop %edi
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10d658: e9 0b 75 00 00 jmp 114b68 <rtems_io_initialize>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10d65d: 89 18 mov %ebx,(%eax)
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10d65f: e8 1c 1c 00 00 call 10f280 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10d664: 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;
10d669: e9 22 ff ff ff jmp 10d590 <rtems_io_register_driver+0x24>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10d66e: 8b 52 04 mov 0x4(%edx),%edx
10d671: 85 d2 test %edx,%edx
10d673: 0f 85 78 ff ff ff jne 10d5f1 <rtems_io_register_driver+0x85>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10d679: 89 18 mov %ebx,(%eax)
10d67b: eb b0 jmp 10d62d <rtems_io_register_driver+0xc1>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10d67d: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
10d683: eb da jmp 10d65f <rtems_io_register_driver+0xf3><== NOT EXECUTED
0010e1f8 <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)
{
10e1f8: 55 push %ebp
10e1f9: 57 push %edi
10e1fa: 56 push %esi
10e1fb: 53 push %ebx
10e1fc: 83 ec 1c sub $0x1c,%esp
10e1ff: 8b 74 24 30 mov 0x30(%esp),%esi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10e203: bf 01 00 00 00 mov $0x1,%edi
10e208: 85 f6 test %esi,%esi
10e20a: 74 3e je 10e24a <rtems_iterate_over_all_threads+0x52><== NEVER TAKEN
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 ] )
10e20c: 8b 04 bd fc 29 13 00 mov 0x1329fc(,%edi,4),%eax
10e213: 85 c0 test %eax,%eax
10e215: 74 2d je 10e244 <rtems_iterate_over_all_threads+0x4c>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10e217: 8b 68 04 mov 0x4(%eax),%ebp
if ( !information )
10e21a: 85 ed test %ebp,%ebp
10e21c: 74 26 je 10e244 <rtems_iterate_over_all_threads+0x4c>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10e21e: 66 83 7d 10 00 cmpw $0x0,0x10(%ebp)
10e223: 74 1f je 10e244 <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10e225: bb 01 00 00 00 mov $0x1,%ebx
10e22a: 66 90 xchg %ax,%ax
the_thread = (Thread_Control *)information->local_table[ i ];
10e22c: 8b 45 1c mov 0x1c(%ebp),%eax
10e22f: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10e232: 85 c0 test %eax,%eax
10e234: 74 05 je 10e23b <rtems_iterate_over_all_threads+0x43><== NEVER TAKEN
continue;
(*routine)(the_thread);
10e236: 89 04 24 mov %eax,(%esp)
10e239: ff d6 call *%esi
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10e23b: 43 inc %ebx
10e23c: 0f b7 45 10 movzwl 0x10(%ebp),%eax
10e240: 39 d8 cmp %ebx,%eax
10e242: 73 e8 jae 10e22c <rtems_iterate_over_all_threads+0x34>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10e244: 47 inc %edi
10e245: 83 ff 04 cmp $0x4,%edi
10e248: 75 c2 jne 10e20c <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10e24a: 83 c4 1c add $0x1c,%esp
10e24d: 5b pop %ebx
10e24e: 5e pop %esi
10e24f: 5f pop %edi
10e250: 5d pop %ebp
10e251: c3 ret
00107a7c <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
107a7c: 53 push %ebx
107a7d: 83 ec 28 sub $0x28,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
107a80: 8b 1d c0 b2 12 00 mov 0x12b2c0,%ebx
107a86: 85 db test %ebx,%ebx
107a88: 74 45 je 107acf <rtems_libio_init+0x53> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
107a8a: c7 44 24 04 30 00 00 movl $0x30,0x4(%esp)
107a91: 00
107a92: 89 1c 24 mov %ebx,(%esp)
107a95: e8 4e fc ff ff call 1076e8 <calloc>
107a9a: a3 d4 f4 12 00 mov %eax,0x12f4d4
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
107a9f: 85 c0 test %eax,%eax
107aa1: 74 7a je 107b1d <rtems_libio_init+0xa1>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
107aa3: a3 d8 f4 12 00 mov %eax,0x12f4d8
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107aa8: 83 fb 01 cmp $0x1,%ebx
107aab: 76 1b jbe 107ac8 <rtems_libio_init+0x4c>
107aad: 89 c2 mov %eax,%edx
107aaf: b9 01 00 00 00 mov $0x1,%ecx
iop->data1 = iop + 1;
107ab4: 83 c2 30 add $0x30,%edx
107ab7: 89 52 fc mov %edx,-0x4(%edx)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107aba: 41 inc %ecx
107abb: 39 d9 cmp %ebx,%ecx
107abd: 75 f5 jne 107ab4 <rtems_libio_init+0x38>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
107abf: 8d 54 49 fd lea -0x3(%ecx,%ecx,2),%edx
107ac3: c1 e2 04 shl $0x4,%edx
107ac6: 01 d0 add %edx,%eax
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
iop->data1 = iop + 1;
iop->data1 = NULL;
107ac8: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
107acf: c7 44 24 10 dc f4 12 movl $0x12f4dc,0x10(%esp)
107ad6: 00
107ad7: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
107ade: 00
107adf: c7 44 24 08 54 00 00 movl $0x54,0x8(%esp)
107ae6: 00
107ae7: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
107aee: 00
107aef: c7 04 24 4f 49 42 4c movl $0x4c42494f,(%esp)
107af6: e8 cd 3b 00 00 call 10b6c8 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
107afb: 85 c0 test %eax,%eax
107afd: 75 16 jne 107b15 <rtems_libio_init+0x99> <== NEVER TAKEN
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
107aff: a1 c4 b2 12 00 mov 0x12b2c4,%eax
107b04: 85 c0 test %eax,%eax
107b06: 74 08 je 107b10 <rtems_libio_init+0x94>
(* rtems_fs_init_helper)();
}
107b08: 83 c4 28 add $0x28,%esp
107b0b: 5b pop %ebx
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
107b0c: ff e0 jmp *%eax
107b0e: 66 90 xchg %ax,%ax
}
107b10: 83 c4 28 add $0x28,%esp
107b13: 5b pop %ebx
107b14: c3 ret
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
107b15: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
107b18: e8 93 45 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
107b1d: c7 04 24 1a 00 00 00 movl $0x1a,(%esp)
107b24: e8 87 45 00 00 call 10c0b0 <rtems_fatal_error_occurred>
00106224 <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
106224: 55 push %ebp
106225: 57 push %edi
106226: 56 push %esi
106227: 53 push %ebx
106228: 83 ec 2c sub $0x2c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
10622b: e8 f4 18 00 00 call 107b24 <rtems_task_self>
106230: 89 c2 mov %eax,%edx
rtems_user_env_t *old_env = rtems_current_user_env;
106232: 8b 2d a0 9d 12 00 mov 0x129da0,%ebp
bool uses_global_env = old_env == &rtems_global_user_env;
bool uses_shared_env = old_env->task_id != self_task_id;
106238: 8b 45 24 mov 0x24(%ebp),%eax
if (uses_global_env || uses_shared_env) {
10623b: 81 fd c0 9d 12 00 cmp $0x129dc0,%ebp
106241: 74 08 je 10624b <rtems_libio_set_private_env+0x27>
106243: 39 c2 cmp %eax,%edx
106245: 0f 84 bd 00 00 00 je 106308 <rtems_libio_set_private_env+0xe4>
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
10624b: c7 44 24 04 2c 00 00 movl $0x2c,0x4(%esp)
106252: 00
106253: c7 04 24 01 00 00 00 movl $0x1,(%esp)
10625a: 89 54 24 1c mov %edx,0x1c(%esp)
10625e: e8 95 49 00 00 call 10abf8 <calloc>
106263: 89 c3 mov %eax,%ebx
if (new_env != NULL) {
106265: 85 c0 test %eax,%eax
106267: 8b 54 24 1c mov 0x1c(%esp),%edx
10626b: 74 7b je 1062e8 <rtems_libio_set_private_env+0xc4>
*new_env = *old_env;
10626d: b9 0b 00 00 00 mov $0xb,%ecx
106272: 89 c7 mov %eax,%edi
106274: 89 ee mov %ebp,%esi
106276: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
new_env->reference_count = 1;
106278: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax)
new_env->task_id = self_task_id;
10627f: 89 50 24 mov %edx,0x24(%eax)
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
106282: 8d 45 04 lea 0x4(%ebp),%eax
106285: 89 04 24 mov %eax,(%esp)
106288: e8 37 0b 00 00 call 106dc4 <rtems_filesystem_global_location_obtain>
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
10628d: 89 43 04 mov %eax,0x4(%ebx)
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
106290: 89 2c 24 mov %ebp,(%esp)
106293: e8 2c 0b 00 00 call 106dc4 <rtems_filesystem_global_location_obtain>
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
106298: 89 03 mov %eax,(%ebx)
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
}
}
10629a: 8b 53 04 mov 0x4(%ebx),%edx
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
10629d: 81 7a 10 00 ef 11 00 cmpl $0x11ef00,0x10(%edx)
1062a4: 74 6e je 106314 <rtems_libio_set_private_env+0xf0>
!rtems_filesystem_global_location_is_null(new_env->root_directory)
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
1062a6: 81 78 10 00 ef 11 00 cmpl $0x11ef00,0x10(%eax)
1062ad: 74 65 je 106314 <rtems_libio_set_private_env+0xf0><== NEVER TAKEN
) {
sc = rtems_task_variable_add(
1062af: c7 44 24 08 b4 61 10 movl $0x1061b4,0x8(%esp)
1062b6: 00
1062b7: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp)
1062be: 00
1062bf: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1062c6: e8 e5 18 00 00 call 107bb0 <rtems_task_variable_add>
1062cb: 89 c6 mov %eax,%esi
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
1062cd: 85 c0 test %eax,%eax
1062cf: 74 27 je 1062f8 <rtems_libio_set_private_env+0xd4>
free_user_env_protected(old_env);
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
1062d1: be 05 00 00 00 mov $0x5,%esi
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
1062d6: 89 1c 24 mov %ebx,(%esp)
1062d9: e8 d6 fe ff ff call 1061b4 <free_user_env>
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
1062de: 89 f0 mov %esi,%eax
1062e0: 83 c4 2c add $0x2c,%esp
1062e3: 5b pop %ebx
1062e4: 5e pop %esi
1062e5: 5f pop %edi
1062e6: 5d pop %ebp
1062e7: c3 ret
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
}
} else {
sc = RTEMS_NO_MEMORY;
1062e8: be 1a 00 00 00 mov $0x1a,%esi
}
}
return sc;
}
1062ed: 89 f0 mov %esi,%eax
1062ef: 83 c4 2c add $0x2c,%esp
1062f2: 5b pop %ebx
1062f3: 5e pop %esi
1062f4: 5f pop %edi
1062f5: 5d pop %ebp
1062f6: c3 ret
1062f7: 90 nop
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(old_env);
1062f8: 89 e8 mov %ebp,%eax
1062fa: e8 fd fe ff ff call 1061fc <free_user_env_protected>
rtems_current_user_env = new_env;
1062ff: 89 1d a0 9d 12 00 mov %ebx,0x129da0
106305: eb e6 jmp 1062ed <rtems_libio_set_private_env+0xc9>
106307: 90 nop
_Thread_Enable_dispatch();
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
106308: 31 f6 xor %esi,%esi
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
10630a: 89 f0 mov %esi,%eax
10630c: 83 c4 2c add $0x2c,%esp
10630f: 5b pop %ebx
106310: 5e pop %esi
106311: 5f pop %edi
106312: 5d pop %ebp
106313: c3 ret
rtems_current_user_env = new_env;
} else {
sc = RTEMS_TOO_MANY;
}
} else {
sc = RTEMS_UNSATISFIED;
106314: be 0d 00 00 00 mov $0xd,%esi
106319: eb bb jmp 1062d6 <rtems_libio_set_private_env+0xb2>
0010631c <rtems_libio_share_private_env>:
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
10631c: 53 push %ebx
10631d: 83 ec 28 sub $0x28,%esp
106320: 8b 5c 24 30 mov 0x30(%esp),%ebx
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
106324: e8 fb 17 00 00 call 107b24 <rtems_task_self>
if (task_id != RTEMS_SELF && self_task_id != task_id) {
106329: 85 db test %ebx,%ebx
10632b: 74 73 je 1063a0 <rtems_libio_share_private_env+0x84>
10632d: 39 d8 cmp %ebx,%eax
10632f: 74 6f je 1063a0 <rtems_libio_share_private_env+0x84>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
106331: a1 24 d7 12 00 mov 0x12d724,%eax
106336: 40 inc %eax
106337: a3 24 d7 12 00 mov %eax,0x12d724
return _Thread_Dispatch_disable_level;
10633c: a1 24 d7 12 00 mov 0x12d724,%eax
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
task_id,
(void *) &rtems_current_user_env,
(void *) &env
106341: 8d 44 24 1c lea 0x1c(%esp),%eax
106345: 89 44 24 08 mov %eax,0x8(%esp)
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
106349: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp)
106350: 00
106351: 89 1c 24 mov %ebx,(%esp)
106354: e8 9f 19 00 00 call 107cf8 <rtems_task_variable_get>
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
106359: 85 c0 test %eax,%eax
10635b: 75 4f jne 1063ac <rtems_libio_share_private_env+0x90>
++env->reference_count;
10635d: 8b 44 24 1c mov 0x1c(%esp),%eax
106361: ff 40 28 incl 0x28(%eax)
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
106364: e8 47 35 00 00 call 1098b0 <_Thread_Enable_dispatch>
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_task_variable_add(
106369: c7 44 24 08 b4 61 10 movl $0x1061b4,0x8(%esp)
106370: 00
106371: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp)
106378: 00
106379: c7 04 24 00 00 00 00 movl $0x0,(%esp)
106380: e8 2b 18 00 00 call 107bb0 <rtems_task_variable_add>
106385: 89 c3 mov %eax,%ebx
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
106387: 85 c0 test %eax,%eax
106389: 75 35 jne 1063c0 <rtems_libio_share_private_env+0xa4><== NEVER TAKEN
free_user_env_protected(rtems_current_user_env);
10638b: a1 a0 9d 12 00 mov 0x129da0,%eax
106390: e8 67 fe ff ff call 1061fc <free_user_env_protected>
rtems_current_user_env = env;
106395: 8b 44 24 1c mov 0x1c(%esp),%eax
106399: a3 a0 9d 12 00 mov %eax,0x129da0
10639e: eb 02 jmp 1063a2 <rtems_libio_share_private_env+0x86>
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
1063a0: 31 db xor %ebx,%ebx
}
}
}
return sc;
}
1063a2: 89 d8 mov %ebx,%eax
1063a4: 83 c4 28 add $0x28,%esp
1063a7: 5b pop %ebx
1063a8: c3 ret
1063a9: 8d 76 00 lea 0x0(%esi),%esi
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
1063ac: e8 ff 34 00 00 call 1098b0 <_Thread_Enable_dispatch>
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
1063b1: bb 0d 00 00 00 mov $0xd,%ebx
}
}
}
return sc;
}
1063b6: 89 d8 mov %ebx,%eax
1063b8: 83 c4 28 add $0x28,%esp
1063bb: 5b pop %ebx
1063bc: c3 ret
1063bd: 8d 76 00 lea 0x0(%esi),%esi
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(rtems_current_user_env);
rtems_current_user_env = env;
} else {
free_user_env_protected(env);
1063c0: 8b 44 24 1c mov 0x1c(%esp),%eax <== NOT EXECUTED
1063c4: e8 33 fe ff ff call 1061fc <free_user_env_protected><== NOT EXECUTED
sc = RTEMS_TOO_MANY;
1063c9: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED
1063ce: eb d2 jmp 1063a2 <rtems_libio_share_private_env+0x86><== NOT EXECUTED
0010fd1c <rtems_libio_to_fcntl_flags>:
*
* Convert RTEMS internal flags to UNIX fnctl(2) flags
*/
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
10fd1c: 8b 54 24 04 mov 0x4(%esp),%edx
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10fd20: 89 d0 mov %edx,%eax
10fd22: 83 e0 06 and $0x6,%eax
10fd25: 83 f8 06 cmp $0x6,%eax
10fd28: 74 2a je 10fd54 <rtems_libio_to_fcntl_flags+0x38><== NEVER TAKEN
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10fd2a: f6 c2 02 test $0x2,%dl
10fd2d: 75 21 jne 10fd50 <rtems_libio_to_fcntl_flags+0x34><== ALWAYS TAKEN
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
10fd2f: 89 d0 mov %edx,%eax <== NOT EXECUTED
10fd31: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
10fd34: 83 e0 01 and $0x1,%eax <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
10fd37: f6 c2 01 test $0x1,%dl
10fd3a: 74 03 je 10fd3f <rtems_libio_to_fcntl_flags+0x23>
fcntl_flags |= O_NONBLOCK;
10fd3c: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10fd3f: f6 c6 02 test $0x2,%dh
10fd42: 74 03 je 10fd47 <rtems_libio_to_fcntl_flags+0x2b>
fcntl_flags |= O_APPEND;
10fd44: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10fd47: 80 e6 04 and $0x4,%dh
10fd4a: 74 03 je 10fd4f <rtems_libio_to_fcntl_flags+0x33>
fcntl_flags |= O_CREAT;
10fd4c: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10fd4f: c3 ret
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
10fd50: 31 c0 xor %eax,%eax
10fd52: eb e3 jmp 10fd37 <rtems_libio_to_fcntl_flags+0x1b>
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
10fd54: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
10fd59: eb dc jmp 10fd37 <rtems_libio_to_fcntl_flags+0x1b><== NOT EXECUTED
001063d0 <rtems_libio_use_global_env>:
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_user_env_t *env = rtems_current_user_env;
bool uses_private_env = env != &rtems_global_user_env;
if (uses_private_env) {
1063d0: 81 3d a0 9d 12 00 c0 cmpl $0x129dc0,0x129da0
1063d7: 9d 12 00
1063da: 74 28 je 106404 <rtems_libio_use_global_env+0x34>
return sc;
}
void rtems_libio_use_global_env(void)
{
1063dc: 83 ec 1c sub $0x1c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_user_env_t *env = rtems_current_user_env;
bool uses_private_env = env != &rtems_global_user_env;
if (uses_private_env) {
sc = rtems_task_variable_delete(
1063df: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp)
1063e6: 00
1063e7: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1063ee: e8 6d 18 00 00 call 107c60 <rtems_task_variable_delete>
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
1063f3: 85 c0 test %eax,%eax
1063f5: 75 0e jne 106405 <rtems_libio_use_global_env+0x35><== NEVER TAKEN
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
1063f7: c7 05 a0 9d 12 00 c0 movl $0x129dc0,0x129da0
1063fe: 9d 12 00
}
}
106401: 83 c4 1c add $0x1c,%esp
106404: c3 ret
sc = rtems_task_variable_delete(
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
106405: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED
10640c: e8 53 1b 00 00 call 107f64 <rtems_fatal_error_occurred><== NOT EXECUTED
0010ab88 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
10ab88: 83 ec 2c sub $0x2c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
10ab8b: 8d 44 24 1c lea 0x1c(%esp),%eax
10ab8f: 89 44 24 08 mov %eax,0x8(%esp)
10ab93: 8b 44 24 30 mov 0x30(%esp),%eax
10ab97: 89 44 24 04 mov %eax,0x4(%esp)
10ab9b: a1 50 27 13 00 mov 0x132750,%eax
10aba0: 89 04 24 mov %eax,(%esp)
10aba3: e8 a8 67 00 00 call 111350 <_Protected_heap_Get_block_size>
10aba8: 84 c0 test %al,%al
10abaa: 74 12 je 10abbe <rtems_malloc_statistics_at_free+0x36><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
10abac: 8b 44 24 1c mov 0x1c(%esp),%eax
10abb0: 31 d2 xor %edx,%edx
10abb2: 01 05 e4 72 13 00 add %eax,0x1372e4
10abb8: 11 15 e8 72 13 00 adc %edx,0x1372e8
}
}
10abbe: 83 c4 2c add $0x2c,%esp
10abc1: c3 ret
0010abc4 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
10abc4: 83 ec 2c sub $0x2c,%esp
10abc7: 8b 44 24 30 mov 0x30(%esp),%eax
uintptr_t actual_size = 0;
10abcb: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp)
10abd2: 00
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
10abd3: 85 c0 test %eax,%eax
10abd5: 74 49 je 10ac20 <rtems_malloc_statistics_at_malloc+0x5c><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
10abd7: 8d 54 24 1c lea 0x1c(%esp),%edx
10abdb: 89 54 24 08 mov %edx,0x8(%esp)
10abdf: 89 44 24 04 mov %eax,0x4(%esp)
10abe3: a1 50 27 13 00 mov 0x132750,%eax
10abe8: 89 04 24 mov %eax,(%esp)
10abeb: e8 60 67 00 00 call 111350 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
10abf0: 8b 44 24 1c mov 0x1c(%esp),%eax
10abf4: 31 d2 xor %edx,%edx
10abf6: 03 05 dc 72 13 00 add 0x1372dc,%eax
10abfc: 13 15 e0 72 13 00 adc 0x1372e0,%edx
10ac02: a3 dc 72 13 00 mov %eax,0x1372dc
10ac07: 89 15 e0 72 13 00 mov %edx,0x1372e0
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
10ac0d: 2b 05 e4 72 13 00 sub 0x1372e4,%eax
if (current_depth > s->max_depth)
10ac13: 3b 05 d8 72 13 00 cmp 0x1372d8,%eax
10ac19: 76 05 jbe 10ac20 <rtems_malloc_statistics_at_malloc+0x5c>
s->max_depth = current_depth;
10ac1b: a3 d8 72 13 00 mov %eax,0x1372d8
}
10ac20: 83 c4 2c add $0x2c,%esp
10ac23: c3 ret
00113e08 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
113e08: 53 push %ebx
113e09: 83 ec 28 sub $0x28,%esp
113e0c: 8b 5c 24 30 mov 0x30(%esp),%ebx
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
113e10: 85 db test %ebx,%ebx
113e12: 74 69 je 113e7d <rtems_memalign+0x75>
return EINVAL;
*pointer = NULL;
113e14: c7 03 00 00 00 00 movl $0x0,(%ebx)
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
113e1a: 83 3d e0 47 13 00 03 cmpl $0x3,0x1347e0
113e21: 74 51 je 113e74 <rtems_memalign+0x6c>
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
113e23: e8 fc 50 ff ff call 108f24 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
113e28: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
113e2f: 00
113e30: 8b 44 24 34 mov 0x34(%esp),%eax
113e34: 89 44 24 08 mov %eax,0x8(%esp)
113e38: 8b 44 24 38 mov 0x38(%esp),%eax
113e3c: 89 44 24 04 mov %eax,0x4(%esp)
113e40: a1 54 02 13 00 mov 0x130254,%eax
113e45: 89 04 24 mov %eax,(%esp)
113e48: e8 33 aa ff ff call 10e880 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
113e4d: 85 c0 test %eax,%eax
113e4f: 74 37 je 113e88 <rtems_memalign+0x80>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
113e51: 8b 15 28 29 13 00 mov 0x132928,%edx
113e57: 85 d2 test %edx,%edx
113e59: 74 0e je 113e69 <rtems_memalign+0x61>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
113e5b: 89 1c 24 mov %ebx,(%esp)
113e5e: 89 44 24 1c mov %eax,0x1c(%esp)
113e62: ff 52 04 call *0x4(%edx)
113e65: 8b 44 24 1c mov 0x1c(%esp),%eax
*pointer = return_this;
113e69: 89 03 mov %eax,(%ebx)
return 0;
113e6b: 31 c0 xor %eax,%eax
}
113e6d: 83 c4 28 add $0x28,%esp
113e70: 5b pop %ebx
113e71: c3 ret
113e72: 66 90 xchg %ax,%ax
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
113e74: e8 73 50 ff ff call 108eec <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
113e79: 84 c0 test %al,%al
113e7b: 75 a6 jne 113e23 <rtems_memalign+0x1b> <== ALWAYS TAKEN
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
113e7d: b8 16 00 00 00 mov $0x16,%eax
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
113e82: 83 c4 28 add $0x28,%esp
113e85: 5b pop %ebx
113e86: c3 ret
113e87: 90 nop
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
113e88: b8 0c 00 00 00 mov $0xc,%eax
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
113e8d: 83 c4 28 add $0x28,%esp
113e90: 5b pop %ebx
113e91: c3 ret
0010d5dc <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
10d5dc: 55 push %ebp
10d5dd: 57 push %edi
10d5de: 56 push %esi
10d5df: 53 push %ebx
10d5e0: 83 ec 6c sub $0x6c,%esp
int success = 0;
char *dup_path = strdup(path);
10d5e3: 8b 84 24 80 00 00 00 mov 0x80(%esp),%eax
10d5ea: 89 04 24 mov %eax,(%esp)
10d5ed: e8 42 95 01 00 call 126b34 <strdup>
10d5f2: 89 c6 mov %eax,%esi
if (dup_path != NULL) {
10d5f4: 85 c0 test %eax,%eax
10d5f6: 0f 84 1b 01 00 00 je 10d717 <rtems_mkdir+0x13b>
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
10d5fc: 8a 00 mov (%eax),%al
10d5fe: 3c 2f cmp $0x2f,%al
10d600: 0f 84 fa 00 00 00 je 10d700 <rtems_mkdir+0x124>
10d606: 89 f3 mov %esi,%ebx
10d608: 31 ff xor %edi,%edi
10d60a: b9 01 00 00 00 mov $0x1,%ecx
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
10d60f: 84 c0 test %al,%al
10d611: 74 10 je 10d623 <rtems_mkdir+0x47> <== NEVER TAKEN
10d613: 90 nop
last = 1;
else if (p[0] != '/')
10d614: 3c 2f cmp $0x2f,%al
10d616: 0f 84 84 00 00 00 je 10d6a0 <rtems_mkdir+0xc4>
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
10d61c: 43 inc %ebx
10d61d: 8a 03 mov (%ebx),%al
if (p[0] == '\0')
10d61f: 84 c0 test %al,%al
10d621: 75 f1 jne 10d614 <rtems_mkdir+0x38>
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
10d623: c6 03 00 movb $0x0,(%ebx)
10d626: bd 01 00 00 00 mov $0x1,%ebp
if (!last && p[1] == '\0')
last = 1;
if (first) {
10d62b: 85 c9 test %ecx,%ecx
10d62d: 75 55 jne 10d684 <rtems_mkdir+0xa8>
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
10d62f: 85 ed test %ebp,%ebp
10d631: 75 1d jne 10d650 <rtems_mkdir+0x74>
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
10d633: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp)
10d63a: 00
10d63b: 89 34 24 mov %esi,(%esp)
10d63e: e8 59 f1 ff ff call 10c79c <mkdir>
10d643: 85 c0 test %eax,%eax
10d645: 78 6d js 10d6b4 <rtems_mkdir+0xd8>
retval = 0;
break;
}
}
if (!last)
*p = '/';
10d647: c6 03 2f movb $0x2f,(%ebx)
10d64a: 31 c9 xor %ecx,%ecx
10d64c: eb ce jmp 10d61c <rtems_mkdir+0x40>
10d64e: 66 90 xchg %ax,%ax
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
10d650: 89 3c 24 mov %edi,(%esp)
10d653: e8 a4 26 00 00 call 10fcfc <umask>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
10d658: 8b 84 24 84 00 00 00 mov 0x84(%esp),%eax
10d65f: 89 44 24 04 mov %eax,0x4(%esp)
10d663: 89 34 24 mov %esi,(%esp)
10d666: e8 31 f1 ff ff call 10c79c <mkdir>
10d66b: 85 c0 test %eax,%eax
10d66d: 78 45 js 10d6b4 <rtems_mkdir+0xd8>
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
10d66f: 89 34 24 mov %esi,(%esp)
10d672: e8 c9 ea ff ff call 10c140 <free>
}
return success != 0 ? 0 : -1;
10d677: 31 c0 xor %eax,%eax
}
10d679: 83 c4 6c add $0x6c,%esp
10d67c: 5b pop %ebx
10d67d: 5e pop %esi
10d67e: 5f pop %edi
10d67f: 5d pop %ebp
10d680: c3 ret
10d681: 8d 76 00 lea 0x0(%esi),%esi
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
10d684: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10d68b: e8 6c 26 00 00 call 10fcfc <umask>
10d690: 89 c7 mov %eax,%edi
numask = oumask & ~(S_IWUSR | S_IXUSR);
10d692: 24 3f and $0x3f,%al
(void)umask(numask);
10d694: 89 04 24 mov %eax,(%esp)
10d697: e8 60 26 00 00 call 10fcfc <umask>
10d69c: eb 91 jmp 10d62f <rtems_mkdir+0x53>
10d69e: 66 90 xchg %ax,%ax
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
10d6a0: c6 03 00 movb $0x0,(%ebx)
10d6a3: 31 c0 xor %eax,%eax
10d6a5: 80 7b 01 00 cmpb $0x0,0x1(%ebx)
10d6a9: 0f 94 c0 sete %al
10d6ac: 89 c5 mov %eax,%ebp
10d6ae: e9 78 ff ff ff jmp 10d62b <rtems_mkdir+0x4f>
10d6b3: 90 nop
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
10d6b4: e8 93 78 01 00 call 124f4c <__errno>
10d6b9: 83 38 11 cmpl $0x11,(%eax)
10d6bc: 74 0a je 10d6c8 <rtems_mkdir+0xec>
10d6be: e8 89 78 01 00 call 124f4c <__errno>
10d6c3: 83 38 15 cmpl $0x15,(%eax)
10d6c6: 75 43 jne 10d70b <rtems_mkdir+0x12f> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
10d6c8: 8d 44 24 18 lea 0x18(%esp),%eax
10d6cc: 89 44 24 04 mov %eax,0x4(%esp)
10d6d0: 89 34 24 mov %esi,(%esp)
10d6d3: e8 70 00 00 00 call 10d748 <stat>
10d6d8: 85 c0 test %eax,%eax
10d6da: 78 2f js 10d70b <rtems_mkdir+0x12f> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
10d6dc: 8b 44 24 24 mov 0x24(%esp),%eax
10d6e0: 25 00 f0 00 00 and $0xf000,%eax
10d6e5: 3d 00 40 00 00 cmp $0x4000,%eax
10d6ea: 75 4a jne 10d736 <rtems_mkdir+0x15a>
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
10d6ec: 85 ed test %ebp,%ebp
10d6ee: 0f 85 7b ff ff ff jne 10d66f <rtems_mkdir+0x93>
retval = 0;
break;
}
}
if (!last)
*p = '/';
10d6f4: c6 03 2f movb $0x2f,(%ebx)
10d6f7: 31 c9 xor %ecx,%ecx
10d6f9: e9 1e ff ff ff jmp 10d61c <rtems_mkdir+0x40>
10d6fe: 66 90 xchg %ax,%ax
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
10d700: 8d 5e 01 lea 0x1(%esi),%ebx
10d703: 8a 46 01 mov 0x1(%esi),%al
10d706: e9 fd fe ff ff jmp 10d608 <rtems_mkdir+0x2c>
}
}
if (!last)
*p = '/';
}
if (!first && !last)
10d70b: 85 ed test %ebp,%ebp
10d70d: 74 1d je 10d72c <rtems_mkdir+0x150> <== NEVER TAKEN
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
10d70f: 89 34 24 mov %esi,(%esp)
10d712: e8 29 ea ff ff call 10c140 <free>
}
return success != 0 ? 0 : -1;
10d717: b8 ff ff ff ff mov $0xffffffff,%eax
10d71c: e9 58 ff ff ff jmp 10d679 <rtems_mkdir+0x9d>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
10d721: e8 26 78 01 00 call 124f4c <__errno>
10d726: c7 00 14 00 00 00 movl $0x14,(%eax)
}
if (!last)
*p = '/';
}
if (!first && !last)
(void)umask(oumask);
10d72c: 89 3c 24 mov %edi,(%esp)
10d72f: e8 c8 25 00 00 call 10fcfc <umask>
10d734: eb d9 jmp 10d70f <rtems_mkdir+0x133>
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
10d736: 85 ed test %ebp,%ebp
10d738: 74 e7 je 10d721 <rtems_mkdir+0x145>
errno = EEXIST;
10d73a: e8 0d 78 01 00 call 124f4c <__errno>
10d73f: c7 00 11 00 00 00 movl $0x11,(%eax)
10d745: eb c8 jmp 10d70f <rtems_mkdir+0x133>
0010d3f0 <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
)
{
10d3f0: 57 push %edi
10d3f1: 56 push %esi
10d3f2: 53 push %ebx
10d3f3: 83 ec 10 sub $0x10,%esp
10d3f6: 8b 7c 24 28 mov 0x28(%esp),%edi
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10d3fa: 85 ff test %edi,%edi
10d3fc: 74 62 je 10d460 <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10d3fe: 0f b7 44 24 24 movzwl 0x24(%esp),%eax
10d403: 89 44 24 04 mov %eax,0x4(%esp)
10d407: 8b 44 24 20 mov 0x20(%esp),%eax
10d40b: 89 04 24 mov %eax,(%esp)
10d40e: e8 41 1b 00 00 call 10ef54 <_Objects_Get_information>
if ( !obj_info )
10d413: 85 c0 test %eax,%eax
10d415: 74 55 je 10d46c <rtems_object_get_class_information+0x7c>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
10d417: 8b 50 08 mov 0x8(%eax),%edx
10d41a: 89 17 mov %edx,(%edi)
info->maximum_id = obj_info->maximum_id;
10d41c: 8b 50 0c mov 0xc(%eax),%edx
10d41f: 89 57 04 mov %edx,0x4(%edi)
info->auto_extend = obj_info->auto_extend;
10d422: 8a 50 12 mov 0x12(%eax),%dl
10d425: 88 57 0c mov %dl,0xc(%edi)
info->maximum = obj_info->maximum;
10d428: 0f b7 58 10 movzwl 0x10(%eax),%ebx
10d42c: 89 5f 08 mov %ebx,0x8(%edi)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10d42f: 85 db test %ebx,%ebx
10d431: 74 45 je 10d478 <rtems_object_get_class_information+0x88><== NEVER TAKEN
10d433: 8b 70 1c mov 0x1c(%eax),%esi
10d436: b9 01 00 00 00 mov $0x1,%ecx
10d43b: b8 01 00 00 00 mov $0x1,%eax
10d440: 31 d2 xor %edx,%edx
10d442: 66 90 xchg %ax,%ax
if ( !obj_info->local_table[i] )
unallocated++;
10d444: 83 3c 8e 01 cmpl $0x1,(%esi,%ecx,4)
10d448: 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++ )
10d44b: 40 inc %eax
10d44c: 89 c1 mov %eax,%ecx
10d44e: 39 c3 cmp %eax,%ebx
10d450: 73 f2 jae 10d444 <rtems_object_get_class_information+0x54>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10d452: 89 57 10 mov %edx,0x10(%edi)
return RTEMS_SUCCESSFUL;
10d455: 31 c0 xor %eax,%eax
}
10d457: 83 c4 10 add $0x10,%esp
10d45a: 5b pop %ebx
10d45b: 5e pop %esi
10d45c: 5f pop %edi
10d45d: c3 ret
10d45e: 66 90 xchg %ax,%ax
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
10d460: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10d465: 83 c4 10 add $0x10,%esp
10d468: 5b pop %ebx
10d469: 5e pop %esi
10d46a: 5f pop %edi
10d46b: c3 ret
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
10d46c: b8 0a 00 00 00 mov $0xa,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10d471: 83 c4 10 add $0x10,%esp
10d474: 5b pop %ebx
10d475: 5e pop %esi
10d476: 5f pop %edi
10d477: c3 ret
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++ )
10d478: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d47a: eb d6 jmp 10d452 <rtems_object_get_class_information+0x62><== NOT EXECUTED
001193f4 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1193f4: 56 push %esi
1193f5: 53 push %ebx
1193f6: 83 ec 14 sub $0x14,%esp
1193f9: 8b 74 24 20 mov 0x20(%esp),%esi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1193fd: 85 f6 test %esi,%esi
1193ff: 75 0b jne 11940c <rtems_partition_create+0x18>
return RTEMS_INVALID_NAME;
119401: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
119406: 83 c4 14 add $0x14,%esp
119409: 5b pop %ebx
11940a: 5e pop %esi
11940b: c3 ret
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
11940c: 8b 5c 24 24 mov 0x24(%esp),%ebx
119410: 85 db test %ebx,%ebx
119412: 74 1c je 119430 <rtems_partition_create+0x3c>
return RTEMS_INVALID_ADDRESS;
if ( !id )
119414: 8b 4c 24 34 mov 0x34(%esp),%ecx
119418: 85 c9 test %ecx,%ecx
11941a: 74 14 je 119430 <rtems_partition_create+0x3c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11941c: 8b 54 24 28 mov 0x28(%esp),%edx
119420: 85 d2 test %edx,%edx
119422: 75 18 jne 11943c <rtems_partition_create+0x48>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
119424: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
119429: 83 c4 14 add $0x14,%esp
11942c: 5b pop %ebx
11942d: 5e pop %esi
11942e: c3 ret
11942f: 90 nop
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
119430: b8 09 00 00 00 mov $0x9,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
119435: 83 c4 14 add $0x14,%esp
119438: 5b pop %ebx
119439: 5e pop %esi
11943a: c3 ret
11943b: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
11943c: 8b 44 24 2c mov 0x2c(%esp),%eax
119440: 85 c0 test %eax,%eax
119442: 74 e0 je 119424 <rtems_partition_create+0x30>
119444: 8b 44 24 2c mov 0x2c(%esp),%eax
119448: 39 44 24 28 cmp %eax,0x28(%esp)
11944c: 72 d6 jb 119424 <rtems_partition_create+0x30>
11944e: a8 03 test $0x3,%al
119450: 75 d2 jne 119424 <rtems_partition_create+0x30>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
119452: f6 44 24 24 03 testb $0x3,0x24(%esp)
119457: 75 d7 jne 119430 <rtems_partition_create+0x3c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
119459: a1 04 da 14 00 mov 0x14da04,%eax
11945e: 40 inc %eax
11945f: a3 04 da 14 00 mov %eax,0x14da04
return _Thread_Dispatch_disable_level;
119464: a1 04 da 14 00 mov 0x14da04,%eax
* 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 );
119469: c7 04 24 80 d8 14 00 movl $0x14d880,(%esp)
119470: e8 63 4a 00 00 call 11ded8 <_Objects_Allocate>
119475: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
119477: 85 c0 test %eax,%eax
119479: 74 6c je 1194e7 <rtems_partition_create+0xf3>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
11947b: 8b 54 24 24 mov 0x24(%esp),%edx
11947f: 89 50 10 mov %edx,0x10(%eax)
the_partition->length = length;
119482: 8b 44 24 28 mov 0x28(%esp),%eax
119486: 89 43 14 mov %eax,0x14(%ebx)
the_partition->buffer_size = buffer_size;
119489: 8b 54 24 2c mov 0x2c(%esp),%edx
11948d: 89 53 18 mov %edx,0x18(%ebx)
the_partition->attribute_set = attribute_set;
119490: 8b 44 24 30 mov 0x30(%esp),%eax
119494: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
119497: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
11949e: 89 54 24 0c mov %edx,0xc(%esp)
1194a2: 8b 44 24 28 mov 0x28(%esp),%eax
1194a6: 31 d2 xor %edx,%edx
1194a8: f7 74 24 2c divl 0x2c(%esp)
1194ac: 89 44 24 08 mov %eax,0x8(%esp)
1194b0: 8b 44 24 24 mov 0x24(%esp),%eax
1194b4: 89 44 24 04 mov %eax,0x4(%esp)
1194b8: 8d 43 24 lea 0x24(%ebx),%eax
1194bb: 89 04 24 mov %eax,(%esp)
1194be: e8 39 34 00 00 call 11c8fc <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1194c3: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1194c6: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1194c9: 8b 15 9c d8 14 00 mov 0x14d89c,%edx
1194cf: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1194d2: 89 73 0c mov %esi,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1194d5: 8b 54 24 34 mov 0x34(%esp),%edx
1194d9: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1194db: e8 84 5b 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1194e0: 31 c0 xor %eax,%eax
1194e2: e9 1f ff ff ff jmp 119406 <rtems_partition_create+0x12>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
1194e7: e8 78 5b 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
1194ec: b8 05 00 00 00 mov $0x5,%eax
1194f1: e9 10 ff ff ff jmp 119406 <rtems_partition_create+0x12>
00119624 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
119624: 53 push %ebx
119625: 83 ec 28 sub $0x28,%esp
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
119628: 8d 44 24 1c lea 0x1c(%esp),%eax
11962c: 89 44 24 08 mov %eax,0x8(%esp)
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
119630: 8b 44 24 30 mov 0x30(%esp),%eax
119634: 89 44 24 04 mov %eax,0x4(%esp)
119638: c7 04 24 80 d8 14 00 movl $0x14d880,(%esp)
11963f: e8 8c 4d 00 00 call 11e3d0 <_Objects_Get>
switch ( location ) {
119644: 8b 54 24 1c mov 0x1c(%esp),%edx
119648: 85 d2 test %edx,%edx
11964a: 75 48 jne 119694 <rtems_partition_return_buffer+0x70>
11964c: 89 c3 mov %eax,%ebx
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
11964e: 8b 40 10 mov 0x10(%eax),%eax
ending = _Addresses_Add_offset( starting, the_partition->length );
119651: 8b 53 14 mov 0x14(%ebx),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
119654: 39 44 24 34 cmp %eax,0x34(%esp)
119658: 72 46 jb 1196a0 <rtems_partition_return_buffer+0x7c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
11965a: 01 c2 add %eax,%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
11965c: 39 54 24 34 cmp %edx,0x34(%esp)
119660: 77 3e ja 1196a0 <rtems_partition_return_buffer+0x7c><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
119662: 8b 54 24 34 mov 0x34(%esp),%edx
119666: 29 c2 sub %eax,%edx
119668: 89 d0 mov %edx,%eax
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
11966a: 31 d2 xor %edx,%edx
11966c: 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 ) &&
11966f: 85 d2 test %edx,%edx
119671: 75 2d jne 1196a0 <rtems_partition_return_buffer+0x7c>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
119673: 8b 44 24 34 mov 0x34(%esp),%eax
119677: 89 44 24 04 mov %eax,0x4(%esp)
11967b: 8d 43 24 lea 0x24(%ebx),%eax
11967e: 89 04 24 mov %eax,(%esp)
119681: e8 32 32 00 00 call 11c8b8 <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
119686: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
119689: e8 d6 59 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11968e: 31 c0 xor %eax,%eax
119690: eb 07 jmp 119699 <rtems_partition_return_buffer+0x75>
119692: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
119694: b8 04 00 00 00 mov $0x4,%eax
}
119699: 83 c4 28 add $0x28,%esp
11969c: 5b pop %ebx
11969d: c3 ret
11969e: 66 90 xchg %ax,%ax
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1196a0: e8 bf 59 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
1196a5: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1196aa: 83 c4 28 add $0x28,%esp
1196ad: 5b pop %ebx
1196ae: c3 ret
001375cc <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
1375cc: 57 push %edi
1375cd: 56 push %esi
1375ce: 53 push %ebx
1375cf: 83 ec 30 sub $0x30,%esp
1375d2: 8b 5c 24 40 mov 0x40(%esp),%ebx
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
1375d6: 8d 44 24 2c lea 0x2c(%esp),%eax
1375da: 89 44 24 08 mov %eax,0x8(%esp)
1375de: 89 5c 24 04 mov %ebx,0x4(%esp)
1375e2: c7 04 24 20 b6 17 00 movl $0x17b620,(%esp)
1375e9: e8 6e 58 fd ff call 10ce5c <_Objects_Get>
switch ( location ) {
1375ee: 8b 54 24 2c mov 0x2c(%esp),%edx
1375f2: 85 d2 test %edx,%edx
1375f4: 75 1e jne 137614 <rtems_rate_monotonic_period+0x48>
1375f6: 89 c6 mov %eax,%esi
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
1375f8: a1 cc b3 17 00 mov 0x17b3cc,%eax
1375fd: 39 46 40 cmp %eax,0x40(%esi)
137600: 74 1e je 137620 <rtems_rate_monotonic_period+0x54>
_Thread_Enable_dispatch();
137602: e8 69 64 fd ff call 10da70 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
137607: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
13760c: 83 c4 30 add $0x30,%esp
13760f: 5b pop %ebx
137610: 5e pop %esi
137611: 5f pop %edi
137612: c3 ret
137613: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
137614: b8 04 00 00 00 mov $0x4,%eax
}
137619: 83 c4 30 add $0x30,%esp
13761c: 5b pop %ebx
13761d: 5e pop %esi
13761e: 5f pop %edi
13761f: c3 ret
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
137620: 8b 44 24 44 mov 0x44(%esp),%eax
137624: 85 c0 test %eax,%eax
137626: 74 68 je 137690 <rtems_rate_monotonic_period+0xc4>
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
137628: 9c pushf
137629: fa cli
13762a: 5f pop %edi
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
13762b: 8b 46 38 mov 0x38(%esi),%eax
13762e: 85 c0 test %eax,%eax
137630: 0f 84 82 00 00 00 je 1376b8 <rtems_rate_monotonic_period+0xec>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
137636: 83 f8 02 cmp $0x2,%eax
137639: 0f 84 cf 00 00 00 je 13770e <rtems_rate_monotonic_period+0x142>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
13763f: 83 f8 04 cmp $0x4,%eax
137642: 75 d0 jne 137614 <rtems_rate_monotonic_period+0x48><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
137644: 89 f0 mov %esi,%eax
137646: e8 2d fe ff ff call 137478 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
13764b: 57 push %edi
13764c: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
13764d: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi)
the_period->next_length = length;
137654: 8b 44 24 44 mov 0x44(%esp),%eax
137658: 89 46 3c mov %eax,0x3c(%esi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
13765b: 89 46 1c mov %eax,0x1c(%esi)
_Watchdog_Insert_ticks( &the_period->Timer, length );
13765e: 8d 46 10 lea 0x10(%esi),%eax
137661: 89 44 24 04 mov %eax,0x4(%esp)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
137665: c7 04 24 08 b2 17 00 movl $0x17b208,(%esp)
13766c: e8 e3 6f fd ff call 10e654 <_Watchdog_Insert>
137671: 8b 46 3c mov 0x3c(%esi),%eax
137674: 89 44 24 04 mov %eax,0x4(%esp)
137678: 8b 46 40 mov 0x40(%esi),%eax
13767b: 89 04 24 mov %eax,(%esp)
13767e: ff 15 14 36 17 00 call *0x173614
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
137684: e8 e7 63 fd ff call 10da70 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
137689: b8 06 00 00 00 mov $0x6,%eax
13768e: eb 89 jmp 137619 <rtems_rate_monotonic_period+0x4d>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
137690: 8b 46 38 mov 0x38(%esi),%eax
137693: 83 f8 04 cmp $0x4,%eax
137696: 77 1c ja 1376b4 <rtems_rate_monotonic_period+0xe8><== NEVER TAKEN
137698: 8b 04 85 f4 e2 15 00 mov 0x15e2f4(,%eax,4),%eax
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
13769f: 89 44 24 1c mov %eax,0x1c(%esp)
1376a3: e8 c8 63 fd ff call 10da70 <_Thread_Enable_dispatch>
1376a8: 8b 44 24 1c mov 0x1c(%esp),%eax
1376ac: e9 68 ff ff ff jmp 137619 <rtems_rate_monotonic_period+0x4d>
1376b1: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
1376b4: 31 c0 xor %eax,%eax <== NOT EXECUTED
1376b6: eb e7 jmp 13769f <rtems_rate_monotonic_period+0xd3><== NOT EXECUTED
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
1376b8: 57 push %edi
1376b9: 9d popf
the_period->next_length = length;
1376ba: 8b 44 24 44 mov 0x44(%esp),%eax
1376be: 89 46 3c mov %eax,0x3c(%esi)
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
1376c1: 89 34 24 mov %esi,(%esp)
1376c4: e8 8f fe ff ff call 137558 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
1376c9: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1376d0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
the_watchdog->routine = routine;
1376d7: c7 46 2c 78 77 13 00 movl $0x137778,0x2c(%esi)
the_watchdog->id = id;
1376de: 89 5e 30 mov %ebx,0x30(%esi)
the_watchdog->user_data = user_data;
1376e1: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
1376e8: 8b 44 24 44 mov 0x44(%esp),%eax
1376ec: 89 46 1c mov %eax,0x1c(%esi)
_Rate_monotonic_Timeout,
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
1376ef: 83 c6 10 add $0x10,%esi
1376f2: 89 74 24 04 mov %esi,0x4(%esp)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
1376f6: c7 04 24 08 b2 17 00 movl $0x17b208,(%esp)
1376fd: e8 52 6f fd ff call 10e654 <_Watchdog_Insert>
_Thread_Enable_dispatch();
137702: e8 69 63 fd ff call 10da70 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
137707: 31 c0 xor %eax,%eax
137709: e9 0b ff ff ff jmp 137619 <rtems_rate_monotonic_period+0x4d>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
13770e: 89 f0 mov %esi,%eax
137710: e8 63 fd ff ff call 137478 <_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;
137715: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi)
the_period->next_length = length;
13771c: 8b 44 24 44 mov 0x44(%esp),%eax
137720: 89 46 3c mov %eax,0x3c(%esi)
_ISR_Enable( level );
137723: 57 push %edi
137724: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
137725: a1 cc b3 17 00 mov 0x17b3cc,%eax
13772a: 8b 56 08 mov 0x8(%esi),%edx
13772d: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
137730: c7 44 24 04 00 40 00 movl $0x4000,0x4(%esp)
137737: 00
137738: 89 04 24 mov %eax,(%esp)
13773b: e8 48 6b fd ff call 10e288 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
137740: 9c pushf
137741: fa cli
137742: 5a pop %edx
local_state = the_period->state;
137743: 8b 46 38 mov 0x38(%esi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
137746: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi)
_ISR_Enable( level );
13774d: 52 push %edx
13774e: 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 )
13774f: 83 f8 03 cmp $0x3,%eax
137752: 74 0c je 137760 <rtems_rate_monotonic_period+0x194>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
137754: e8 17 63 fd ff call 10da70 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
137759: 31 c0 xor %eax,%eax
13775b: e9 b9 fe ff ff jmp 137619 <rtems_rate_monotonic_period+0x4d>
/*
* 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 );
137760: c7 44 24 04 00 40 00 movl $0x4000,0x4(%esp)
137767: 00
137768: a1 cc b3 17 00 mov 0x17b3cc,%eax
13776d: 89 04 24 mov %eax,(%esp)
137770: e8 57 5f fd ff call 10d6cc <_Thread_Clear_state>
137775: eb dd jmp 137754 <rtems_rate_monotonic_period+0x188>
0012a98c <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
12a98c: 55 push %ebp
12a98d: 57 push %edi
12a98e: 56 push %esi
12a98f: 53 push %ebx
12a990: 81 ec 9c 00 00 00 sub $0x9c,%esp
12a996: 8b b4 24 b0 00 00 00 mov 0xb0(%esp),%esi
12a99d: 8b 9c 24 b4 00 00 00 mov 0xb4(%esp),%ebx
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
12a9a4: 85 db test %ebx,%ebx
12a9a6: 0f 84 ec 00 00 00 je 12aa98 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
12a9ac: c7 44 24 04 a8 b3 15 movl $0x15b3a8,0x4(%esp)
12a9b3: 00
12a9b4: 89 34 24 mov %esi,(%esp)
12a9b7: ff d3 call *%ebx
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
12a9b9: c7 44 24 04 e0 b3 15 movl $0x15b3e0,0x4(%esp)
12a9c0: 00
12a9c1: 89 34 24 mov %esi,(%esp)
12a9c4: ff d3 call *%ebx
(*print)( context, "--- Wall times are in seconds ---\n" );
12a9c6: c7 44 24 04 04 b4 15 movl $0x15b404,0x4(%esp)
12a9cd: 00
12a9ce: 89 34 24 mov %esi,(%esp)
12a9d1: ff d3 call *%ebx
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
12a9d3: c7 44 24 04 28 b4 15 movl $0x15b428,0x4(%esp)
12a9da: 00
12a9db: 89 34 24 mov %esi,(%esp)
12a9de: ff d3 call *%ebx
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
12a9e0: c7 44 24 04 74 b4 15 movl $0x15b474,0x4(%esp)
12a9e7: 00
12a9e8: 89 34 24 mov %esi,(%esp)
12a9eb: ff d3 call *%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 ;
12a9ed: 8b 2d 28 b6 17 00 mov 0x17b628,%ebp
12a9f3: 8d 7c 24 58 lea 0x58(%esp),%edi
12a9f7: 3b 2d 2c b6 17 00 cmp 0x17b62c,%ebp
12a9fd: 76 12 jbe 12aa11 <rtems_rate_monotonic_report_statistics_with_plugin+0x85><== ALWAYS TAKEN
12a9ff: e9 94 00 00 00 jmp 12aa98 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
12aa04: 45 inc %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 ;
12aa05: 39 2d 2c b6 17 00 cmp %ebp,0x17b62c
12aa0b: 0f 82 87 00 00 00 jb 12aa98 <rtems_rate_monotonic_report_statistics_with_plugin+0x10c>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
12aa11: 89 7c 24 04 mov %edi,0x4(%esp)
12aa15: 89 2c 24 mov %ebp,(%esp)
12aa18: e8 73 c6 00 00 call 137090 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
12aa1d: 85 c0 test %eax,%eax
12aa1f: 75 e3 jne 12aa04 <rtems_rate_monotonic_report_statistics_with_plugin+0x78>
#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 );
12aa21: 8d 44 24 40 lea 0x40(%esp),%eax
12aa25: 89 44 24 04 mov %eax,0x4(%esp)
12aa29: 89 2c 24 mov %ebp,(%esp)
12aa2c: e8 6b c8 00 00 call 13729c <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
12aa31: 8d 54 24 33 lea 0x33(%esp),%edx
12aa35: 89 54 24 08 mov %edx,0x8(%esp)
12aa39: c7 44 24 04 05 00 00 movl $0x5,0x4(%esp)
12aa40: 00
12aa41: 8b 44 24 40 mov 0x40(%esp),%eax
12aa45: 89 04 24 mov %eax,(%esp)
12aa48: e8 1f 80 fe ff call 112a6c <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
12aa4d: 8b 44 24 5c mov 0x5c(%esp),%eax
12aa51: 89 44 24 14 mov %eax,0x14(%esp)
12aa55: 8b 44 24 58 mov 0x58(%esp),%eax
12aa59: 89 44 24 10 mov %eax,0x10(%esp)
"0x%08" PRIx32 " %4s %5" PRId32 " %6" PRId32 " ",
id, name,
12aa5d: 8d 44 24 33 lea 0x33(%esp),%eax
12aa61: 89 44 24 0c mov %eax,0xc(%esp)
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
12aa65: 89 6c 24 08 mov %ebp,0x8(%esp)
12aa69: c7 44 24 04 c6 b3 15 movl $0x15b3c6,0x4(%esp)
12aa70: 00
12aa71: 89 34 24 mov %esi,(%esp)
12aa74: ff d3 call *%ebx
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
12aa76: 8b 44 24 58 mov 0x58(%esp),%eax
12aa7a: 85 c0 test %eax,%eax
12aa7c: 75 26 jne 12aaa4 <rtems_rate_monotonic_report_statistics_with_plugin+0x118>
(*print)( context, "\n" );
12aa7e: c7 44 24 04 35 54 15 movl $0x155435,0x4(%esp)
12aa85: 00
12aa86: 89 34 24 mov %esi,(%esp)
12aa89: ff d3 call *%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 ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
12aa8b: 45 inc %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 ;
12aa8c: 39 2d 2c b6 17 00 cmp %ebp,0x17b62c
12aa92: 0f 83 79 ff ff ff jae 12aa11 <rtems_rate_monotonic_report_statistics_with_plugin+0x85><== ALWAYS TAKEN
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
12aa98: 81 c4 9c 00 00 00 add $0x9c,%esp
12aa9e: 5b pop %ebx
12aa9f: 5e pop %esi
12aaa0: 5f pop %edi
12aaa1: 5d pop %ebp
12aaa2: c3 ret
12aaa3: 90 nop
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 );
12aaa4: 8d 4c 24 38 lea 0x38(%esp),%ecx
12aaa8: 89 4c 24 08 mov %ecx,0x8(%esp)
12aaac: 89 44 24 04 mov %eax,0x4(%esp)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
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;
12aab0: 8d 44 24 70 lea 0x70(%esp),%eax
12aab4: 89 04 24 mov %eax,(%esp)
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
12aab7: 89 4c 24 2c mov %ecx,0x2c(%esp)
12aabb: e8 d8 0a 00 00 call 12b598 <_Timespec_Divide_by_integer>
(*print)( context,
12aac0: b8 d3 4d 62 10 mov $0x10624dd3,%eax
12aac5: f7 6c 24 3c imull 0x3c(%esp)
12aac9: c1 fa 06 sar $0x6,%edx
12aacc: 89 54 24 28 mov %edx,0x28(%esp)
12aad0: 8b 44 24 3c mov 0x3c(%esp),%eax
12aad4: 99 cltd
12aad5: 29 54 24 28 sub %edx,0x28(%esp)
12aad9: 8b 54 24 28 mov 0x28(%esp),%edx
12aadd: 89 54 24 1c mov %edx,0x1c(%esp)
12aae1: 8b 44 24 38 mov 0x38(%esp),%eax
12aae5: 89 44 24 18 mov %eax,0x18(%esp)
12aae9: b8 d3 4d 62 10 mov $0x10624dd3,%eax
12aaee: f7 6c 24 6c imull 0x6c(%esp)
12aaf2: c1 fa 06 sar $0x6,%edx
12aaf5: 89 54 24 28 mov %edx,0x28(%esp)
12aaf9: 8b 44 24 6c mov 0x6c(%esp),%eax
12aafd: 99 cltd
12aafe: 29 54 24 28 sub %edx,0x28(%esp)
12ab02: 8b 54 24 28 mov 0x28(%esp),%edx
12ab06: 89 54 24 14 mov %edx,0x14(%esp)
12ab0a: 8b 44 24 68 mov 0x68(%esp),%eax
12ab0e: 89 44 24 10 mov %eax,0x10(%esp)
12ab12: b8 d3 4d 62 10 mov $0x10624dd3,%eax
12ab17: f7 6c 24 64 imull 0x64(%esp)
12ab1b: 89 44 24 20 mov %eax,0x20(%esp)
12ab1f: 89 54 24 24 mov %edx,0x24(%esp)
12ab23: c1 fa 06 sar $0x6,%edx
12ab26: 89 54 24 28 mov %edx,0x28(%esp)
12ab2a: 8b 44 24 64 mov 0x64(%esp),%eax
12ab2e: 99 cltd
12ab2f: 29 54 24 28 sub %edx,0x28(%esp)
12ab33: 8b 54 24 28 mov 0x28(%esp),%edx
12ab37: 89 54 24 0c mov %edx,0xc(%esp)
12ab3b: 8b 44 24 60 mov 0x60(%esp),%eax
12ab3f: 89 44 24 08 mov %eax,0x8(%esp)
12ab43: c7 44 24 04 c0 b4 15 movl $0x15b4c0,0x4(%esp)
12ab4a: 00
12ab4b: 89 34 24 mov %esi,(%esp)
12ab4e: ff d3 call *%ebx
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);
12ab50: 8b 4c 24 2c mov 0x2c(%esp),%ecx
12ab54: 89 4c 24 08 mov %ecx,0x8(%esp)
12ab58: 8b 44 24 58 mov 0x58(%esp),%eax
12ab5c: 89 44 24 04 mov %eax,0x4(%esp)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
12ab60: 8d 84 24 88 00 00 00 lea 0x88(%esp),%eax
12ab67: 89 04 24 mov %eax,(%esp)
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
12ab6a: e8 29 0a 00 00 call 12b598 <_Timespec_Divide_by_integer>
(*print)( context,
12ab6f: 8b 4c 24 3c mov 0x3c(%esp),%ecx
12ab73: b8 d3 4d 62 10 mov $0x10624dd3,%eax
12ab78: f7 e9 imul %ecx
12ab7a: 89 54 24 24 mov %edx,0x24(%esp)
12ab7e: 8b 44 24 24 mov 0x24(%esp),%eax
12ab82: c1 f8 06 sar $0x6,%eax
12ab85: c1 f9 1f sar $0x1f,%ecx
12ab88: 29 c8 sub %ecx,%eax
12ab8a: 89 44 24 1c mov %eax,0x1c(%esp)
12ab8e: 8b 44 24 38 mov 0x38(%esp),%eax
12ab92: 89 44 24 18 mov %eax,0x18(%esp)
12ab96: 8b 8c 24 84 00 00 00 mov 0x84(%esp),%ecx
12ab9d: b8 d3 4d 62 10 mov $0x10624dd3,%eax
12aba2: f7 e9 imul %ecx
12aba4: 89 54 24 24 mov %edx,0x24(%esp)
12aba8: 8b 44 24 24 mov 0x24(%esp),%eax
12abac: c1 f8 06 sar $0x6,%eax
12abaf: c1 f9 1f sar $0x1f,%ecx
12abb2: 29 c8 sub %ecx,%eax
12abb4: 89 44 24 14 mov %eax,0x14(%esp)
12abb8: 8b 84 24 80 00 00 00 mov 0x80(%esp),%eax
12abbf: 89 44 24 10 mov %eax,0x10(%esp)
12abc3: 8b 4c 24 7c mov 0x7c(%esp),%ecx
12abc7: b8 d3 4d 62 10 mov $0x10624dd3,%eax
12abcc: f7 e9 imul %ecx
12abce: 89 44 24 20 mov %eax,0x20(%esp)
12abd2: 89 54 24 24 mov %edx,0x24(%esp)
12abd6: 8b 44 24 24 mov 0x24(%esp),%eax
12abda: c1 f8 06 sar $0x6,%eax
12abdd: c1 f9 1f sar $0x1f,%ecx
12abe0: 29 c8 sub %ecx,%eax
12abe2: 89 44 24 0c mov %eax,0xc(%esp)
12abe6: 8b 44 24 78 mov 0x78(%esp),%eax
12abea: 89 44 24 08 mov %eax,0x8(%esp)
12abee: c7 44 24 04 e0 b4 15 movl $0x15b4e0,0x4(%esp)
12abf5: 00
12abf6: 89 34 24 mov %esi,(%esp)
12abf9: ff d3 call *%ebx
12abfb: e9 04 fe ff ff jmp 12aa04 <rtems_rate_monotonic_report_statistics_with_plugin+0x78>
0012ac1c <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
12ac1c: 53 push %ebx
12ac1d: 83 ec 18 sub $0x18,%esp
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
12ac20: a1 64 b1 17 00 mov 0x17b164,%eax
12ac25: 40 inc %eax
12ac26: a3 64 b1 17 00 mov %eax,0x17b164
return _Thread_Dispatch_disable_level;
12ac2b: a1 64 b1 17 00 mov 0x17b164,%eax
/*
* 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 ;
12ac30: 8b 1d 28 b6 17 00 mov 0x17b628,%ebx
12ac36: 3b 1d 2c b6 17 00 cmp 0x17b62c,%ebx
12ac3c: 77 13 ja 12ac51 <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
12ac3e: 66 90 xchg %ax,%ax
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
12ac40: 89 1c 24 mov %ebx,(%esp)
12ac43: e8 14 00 00 00 call 12ac5c <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++ ) {
12ac48: 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 ;
12ac49: 39 1d 2c b6 17 00 cmp %ebx,0x17b62c
12ac4f: 73 ef jae 12ac40 <rtems_rate_monotonic_reset_all_statistics+0x24>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
12ac51: 83 c4 18 add $0x18,%esp
12ac54: 5b pop %ebx
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
12ac55: e9 16 2e fe ff jmp 10da70 <_Thread_Enable_dispatch>
0010c9e0 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
10c9e0: 55 push %ebp
10c9e1: 57 push %edi
10c9e2: 56 push %esi
10c9e3: 53 push %ebx
10c9e4: 83 ec 2c sub $0x2c,%esp
10c9e7: 8b 6c 24 40 mov 0x40(%esp),%ebp
10c9eb: 8b 4c 24 44 mov 0x44(%esp),%ecx
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
10c9ef: 8b 75 30 mov 0x30(%ebp),%esi
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
10c9f2: 89 c8 mov %ecx,%eax
10c9f4: 31 d2 xor %edx,%edx
10c9f6: f7 f6 div %esi
if (excess > 0) {
10c9f8: 85 d2 test %edx,%edx
10c9fa: 75 54 jne 10ca50 <rtems_rbheap_allocate+0x70><== NEVER TAKEN
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
10c9fc: 89 ce mov %ecx,%esi
10c9fe: 85 c9 test %ecx,%ecx
10ca00: 74 1a je 10ca1c <rtems_rbheap_allocate+0x3c>
10ca02: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10ca04: 8b 7d 00 mov 0x0(%ebp),%edi
rtems_chain_control *free_chain,
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
10ca07: 8d 45 04 lea 0x4(%ebp),%eax
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
10ca0a: 39 c7 cmp %eax,%edi
10ca0c: 74 0e je 10ca1c <rtems_rbheap_allocate+0x3c>
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
10ca0e: 8b 5f 1c mov 0x1c(%edi),%ebx
10ca11: 39 f3 cmp %esi,%ebx
10ca13: 73 13 jae 10ca28 <rtems_rbheap_allocate+0x48>
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
if (chunk != NULL) {
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
10ca15: 8b 3f mov (%edi),%edi
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
10ca17: 39 f8 cmp %edi,%eax
10ca19: 75 f3 jne 10ca0e <rtems_rbheap_allocate+0x2e><== NEVER TAKEN
10ca1b: 90 nop
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
10ca1c: 31 c0 xor %eax,%eax
}
}
}
return ptr;
}
10ca1e: 83 c4 2c add $0x2c,%esp
10ca21: 5b pop %ebx
10ca22: 5e pop %esi
10ca23: 5f pop %edi
10ca24: 5d pop %ebp
10ca25: c3 ret
10ca26: 66 90 xchg %ax,%ax
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
10ca28: 39 de cmp %ebx,%esi
10ca2a: 72 34 jb 10ca60 <rtems_rbheap_allocate+0x80>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10ca2c: 8b 17 mov (%edi),%edx
previous = the_node->previous;
10ca2e: 8b 47 04 mov 0x4(%edi),%eax
next->previous = previous;
10ca31: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
10ca34: 89 10 mov %edx,(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
10ca36: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
10ca3d: c7 07 00 00 00 00 movl $0x0,(%edi)
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
10ca43: 8b 47 18 mov 0x18(%edi),%eax
}
}
}
return ptr;
}
10ca46: 83 c4 2c add $0x2c,%esp
10ca49: 5b pop %ebx
10ca4a: 5e pop %esi
10ca4b: 5f pop %edi
10ca4c: 5d pop %ebp
10ca4d: c3 ret
10ca4e: 66 90 xchg %ax,%ax
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
value += alignment - excess;
10ca50: 01 ce add %ecx,%esi <== NOT EXECUTED
10ca52: 29 d6 sub %edx,%esi <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
10ca54: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10ca56: 74 c4 je 10ca1c <rtems_rbheap_allocate+0x3c><== NOT EXECUTED
10ca58: 39 f1 cmp %esi,%ecx <== NOT EXECUTED
10ca5a: 76 a8 jbe 10ca04 <rtems_rbheap_allocate+0x24><== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
10ca5c: 31 c0 xor %eax,%eax <== NOT EXECUTED
10ca5e: eb be jmp 10ca1e <rtems_rbheap_allocate+0x3e><== NOT EXECUTED
if (free_chunk != NULL) {
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
rtems_rbheap_chunk *new_chunk = get_chunk(control);
10ca60: 89 e8 mov %ebp,%eax
10ca62: e8 91 fd ff ff call 10c7f8 <get_chunk>
10ca67: 89 c2 mov %eax,%edx
if (new_chunk != NULL) {
10ca69: 85 c0 test %eax,%eax
10ca6b: 74 af je 10ca1c <rtems_rbheap_allocate+0x3c><== NEVER TAKEN
uintptr_t new_free_size = free_size - aligned_size;
10ca6d: 29 f3 sub %esi,%ebx
free_chunk->size = new_free_size;
10ca6f: 89 5f 1c mov %ebx,0x1c(%edi)
new_chunk->begin = free_chunk->begin + new_free_size;
10ca72: 03 5f 18 add 0x18(%edi),%ebx
10ca75: 89 58 18 mov %ebx,0x18(%eax)
new_chunk->size = aligned_size;
10ca78: 89 70 1c mov %esi,0x1c(%eax)
10ca7b: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
10ca82: c7 00 00 00 00 00 movl $0x0,(%eax)
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
10ca88: 8d 40 08 lea 0x8(%eax),%eax
10ca8b: 89 44 24 04 mov %eax,0x4(%esp)
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
10ca8f: 83 c5 18 add $0x18,%ebp
10ca92: 89 2c 24 mov %ebp,(%esp)
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
10ca95: 89 54 24 1c mov %edx,0x1c(%esp)
10ca99: e8 c6 17 00 00 call 10e264 <_RBTree_Insert_unprotected>
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
10ca9e: 8b 54 24 1c mov 0x1c(%esp),%edx
10caa2: 8b 42 18 mov 0x18(%edx),%eax
}
}
}
return ptr;
}
10caa5: 83 c4 2c add $0x2c,%esp
10caa8: 5b pop %ebx
10caa9: 5e pop %esi
10caaa: 5f pop %edi
10caab: 5d pop %ebp
10caac: c3 ret
0010cbc0 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
10cbc0: 53 push %ebx <== NOT EXECUTED
10cbc1: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
10cbc4: 8b 5c 24 20 mov 0x20(%esp),%ebx <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
10cbc8: c7 04 24 20 00 00 00 movl $0x20,(%esp) <== NOT EXECUTED
10cbcf: e8 2c b7 ff ff call 108300 <malloc> <== NOT EXECUTED
if (chunk != NULL) {
10cbd4: 85 c0 test %eax,%eax <== NOT EXECUTED
10cbd6: 74 11 je 10cbe9 <rtems_rbheap_extend_descriptors_with_malloc+0x29><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
10cbd8: 8d 53 0c lea 0xc(%ebx),%edx <== NOT EXECUTED
10cbdb: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
10cbde: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED
after_node->next = the_node;
10cbe1: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED
the_node->next = before_node;
10cbe4: 89 10 mov %edx,(%eax) <== NOT EXECUTED
before_node->previous = the_node;
10cbe6: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
rtems_rbheap_add_to_spare_descriptor_chain(control, chunk);
}
}
10cbe9: 83 c4 18 add $0x18,%esp <== NOT EXECUTED
10cbec: 5b pop %ebx <== NOT EXECUTED
10cbed: c3 ret <== NOT EXECUTED
0010cab0 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
10cab0: 55 push %ebp
10cab1: 57 push %edi
10cab2: 56 push %esi
10cab3: 53 push %ebx
10cab4: 83 ec 4c sub $0x4c,%esp
10cab7: 8b 54 24 64 mov 0x64(%esp),%edx
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
10cabb: 85 d2 test %edx,%edx
10cabd: 0f 84 dd 00 00 00 je 10cba0 <rtems_rbheap_free+0xf0>
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
10cac3: 8b 5c 24 60 mov 0x60(%esp),%ebx
10cac7: 83 c3 18 add $0x18,%ebx
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
10caca: 8d 7c 24 20 lea 0x20(%esp),%edi
10cace: b9 20 00 00 00 mov $0x20,%ecx
10cad3: 31 c0 xor %eax,%eax
10cad5: f3 aa rep stos %al,%es:(%edi)
10cad7: 89 54 24 38 mov %edx,0x38(%esp)
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
10cadb: 8b 44 24 60 mov 0x60(%esp),%eax
10cadf: 8b 68 1c mov 0x1c(%eax),%ebp
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
10cae2: 85 ed test %ebp,%ebp
10cae4: 0f 84 c2 00 00 00 je 10cbac <rtems_rbheap_free+0xfc><== NEVER TAKEN
10caea: 31 f6 xor %esi,%esi
10caec: 8d 7c 24 28 lea 0x28(%esp),%edi
compare_result = the_rbtree->compare_function(the_node, iter_node);
10caf0: 89 6c 24 04 mov %ebp,0x4(%esp)
return rtems_rbheap_chunk_of_node(
10caf4: 89 3c 24 mov %edi,(%esp)
10caf7: ff 53 10 call *0x10(%ebx)
if ( _RBTree_Is_equal( compare_result ) ) {
10cafa: 85 c0 test %eax,%eax
10cafc: 75 08 jne 10cb06 <rtems_rbheap_free+0x56>
found = iter_node;
if ( the_rbtree->is_unique )
10cafe: 89 ee mov %ebp,%esi
10cb00: 80 7b 14 00 cmpb $0x0,0x14(%ebx)
10cb04: 75 10 jne 10cb16 <rtems_rbheap_free+0x66><== ALWAYS TAKEN
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
10cb06: 85 c0 test %eax,%eax
10cb08: 0f 9f c0 setg %al
10cb0b: 0f b6 c0 movzbl %al,%eax
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
10cb0e: 8b 6c 85 04 mov 0x4(%ebp,%eax,4),%ebp
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
10cb12: 85 ed test %ebp,%ebp
10cb14: 75 da jne 10caf0 <rtems_rbheap_free+0x40>
10cb16: 8d 7e f8 lea -0x8(%esi),%edi
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
10cb19: 83 ff f8 cmp $0xfffffff8,%edi
10cb1c: 0f 84 8a 00 00 00 je 10cbac <rtems_rbheap_free+0xfc>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
10cb22: 8b 46 f8 mov -0x8(%esi),%eax
10cb25: 85 c0 test %eax,%eax
10cb27: 74 0d je 10cb36 <rtems_rbheap_free+0x86>
check_and_merge(free_chain, chunk_tree, chunk, succ);
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
10cb29: b8 0e 00 00 00 mov $0xe,%eax
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
10cb2e: 83 c4 4c add $0x4c,%esp
10cb31: 5b pop %ebx
10cb32: 5e pop %esi
10cb33: 5f pop %edi
10cb34: 5d pop %ebp
10cb35: c3 ret
10cb36: 8b 6f 04 mov 0x4(%edi),%ebp
10cb39: 85 ed test %ebp,%ebp
10cb3b: 75 ec jne 10cb29 <rtems_rbheap_free+0x79><== NEVER TAKEN
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
10cb3d: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10cb44: 00
10cb45: 89 34 24 mov %esi,(%esp)
10cb48: e8 b7 19 00 00 call 10e504 <_RBTree_Next_unprotected>
10cb4d: 89 44 24 1c mov %eax,0x1c(%esp)
10cb51: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
10cb58: 00
10cb59: 89 34 24 mov %esi,(%esp)
10cb5c: e8 a3 19 00 00 call 10e504 <_RBTree_Next_unprotected>
10cb61: 83 e8 08 sub $0x8,%eax
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
10cb64: 89 04 24 mov %eax,(%esp)
10cb67: 89 f9 mov %edi,%ecx
10cb69: 89 da mov %ebx,%edx
10cb6b: 8b 44 24 60 mov 0x60(%esp),%eax
10cb6f: e8 d0 fc ff ff call 10c844 <check_and_merge>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10cb74: 8b 44 24 60 mov 0x60(%esp),%eax
10cb78: 89 47 04 mov %eax,0x4(%edi)
before_node = after_node->next;
10cb7b: 89 c2 mov %eax,%edx
10cb7d: 8b 00 mov (%eax),%eax
after_node->next = the_node;
10cb7f: 89 3a mov %edi,(%edx)
the_node->next = before_node;
10cb81: 89 07 mov %eax,(%edi)
before_node->previous = the_node;
10cb83: 89 78 04 mov %edi,0x4(%eax)
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
10cb86: 8b 44 24 1c mov 0x1c(%esp),%eax
10cb8a: 83 e8 08 sub $0x8,%eax
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
10cb8d: 89 04 24 mov %eax,(%esp)
10cb90: 89 f9 mov %edi,%ecx
10cb92: 89 da mov %ebx,%edx
10cb94: 8b 44 24 60 mov 0x60(%esp),%eax
10cb98: e8 a7 fc ff ff call 10c844 <check_and_merge>
10cb9d: 8d 76 00 lea 0x0(%esi),%esi
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
10cba0: 31 c0 xor %eax,%eax
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
10cba2: 83 c4 4c add $0x4c,%esp
10cba5: 5b pop %ebx
10cba6: 5e pop %esi
10cba7: 5f pop %edi
10cba8: 5d pop %ebp
10cba9: c3 ret
10cbaa: 66 90 xchg %ax,%ax
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
}
} else {
sc = RTEMS_INVALID_ID;
10cbac: b8 04 00 00 00 mov $0x4,%eax
}
}
return sc;
}
10cbb1: 83 c4 4c add $0x4c,%esp
10cbb4: 5b pop %ebx
10cbb5: 5e pop %esi
10cbb6: 5f pop %edi
10cbb7: 5d pop %ebp
10cbb8: c3 ret
0010c8ac <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
10c8ac: 57 push %edi
10c8ad: 56 push %esi
10c8ae: 53 push %ebx
10c8af: 83 ec 10 sub $0x10,%esp
10c8b2: 8b 4c 24 2c mov 0x2c(%esp),%ecx
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
10c8b6: 85 c9 test %ecx,%ecx
10c8b8: 75 0e jne 10c8c8 <rtems_rbheap_initialize+0x1c>
}
} else {
sc = RTEMS_INVALID_ADDRESS;
}
} else {
sc = RTEMS_INVALID_NUMBER;
10c8ba: b8 0a 00 00 00 mov $0xa,%eax
}
return sc;
}
10c8bf: 83 c4 10 add $0x10,%esp
10c8c2: 5b pop %ebx
10c8c3: 5e pop %esi
10c8c4: 5f pop %edi
10c8c5: c3 ret
10c8c6: 66 90 xchg %ax,%ax
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
10c8c8: 8b 5c 24 24 mov 0x24(%esp),%ebx
10c8cc: 03 5c 24 28 add 0x28(%esp),%ebx
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
10c8d0: 8b 44 24 24 mov 0x24(%esp),%eax
10c8d4: 31 d2 xor %edx,%edx
10c8d6: f7 f1 div %ecx
if (excess > 0) {
10c8d8: 85 d2 test %edx,%edx
10c8da: 0f 85 c4 00 00 00 jne 10c9a4 <rtems_rbheap_initialize+0xf8>
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
10c8e0: 89 d8 mov %ebx,%eax
10c8e2: 31 d2 xor %edx,%edx
10c8e4: f7 f1 div %ecx
return value - excess;
10c8e6: 89 df mov %ebx,%edi
10c8e8: 29 d7 sub %edx,%edi
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
10c8ea: 39 5c 24 24 cmp %ebx,0x24(%esp)
10c8ee: 0f 83 b6 00 00 00 jae 10c9aa <rtems_rbheap_initialize+0xfe>
10c8f4: 8b 74 24 24 mov 0x24(%esp),%esi
10c8f8: 39 f7 cmp %esi,%edi
10c8fa: 0f 86 aa 00 00 00 jbe 10c9aa <rtems_rbheap_initialize+0xfe>
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 );
10c900: 8b 44 24 20 mov 0x20(%esp),%eax
10c904: 83 c0 04 add $0x4,%eax
10c907: 8b 54 24 20 mov 0x20(%esp),%edx
10c90b: 89 02 mov %eax,(%edx)
head->next = tail;
head->previous = NULL;
10c90d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
10c914: 89 52 08 mov %edx,0x8(%edx)
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 );
10c917: 89 d0 mov %edx,%eax
10c919: 83 c0 0c add $0xc,%eax
10c91c: 83 c2 10 add $0x10,%edx
10c91f: 8b 5c 24 20 mov 0x20(%esp),%ebx
10c923: 89 53 0c mov %edx,0xc(%ebx)
head->next = tail;
head->previous = NULL;
10c926: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10c92d: 89 43 14 mov %eax,0x14(%ebx)
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
10c930: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_rbtree->root = NULL;
10c937: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_rbtree->first[0] = NULL;
10c93e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
the_rbtree->first[1] = NULL;
10c945: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
the_rbtree->compare_function = compare_function;
10c94c: c7 43 28 e8 c7 10 00 movl $0x10c7e8,0x28(%ebx)
the_rbtree->is_unique = is_unique;
10c953: c6 43 2c 01 movb $0x1,0x2c(%ebx)
rtems_rbheap_chunk *first = NULL;
rtems_chain_initialize_empty(free_chain);
rtems_chain_initialize_empty(&control->spare_descriptor_chain);
rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true);
control->alignment = alignment;
10c957: 89 4b 30 mov %ecx,0x30(%ebx)
control->handler_arg = handler_arg;
10c95a: 8b 44 24 34 mov 0x34(%esp),%eax
10c95e: 89 43 38 mov %eax,0x38(%ebx)
control->extend_descriptors = extend_descriptors;
10c961: 8b 44 24 30 mov 0x30(%esp),%eax
10c965: 89 43 34 mov %eax,0x34(%ebx)
first = get_chunk(control);
10c968: 89 d8 mov %ebx,%eax
10c96a: e8 89 fe ff ff call 10c7f8 <get_chunk>
if (first != NULL) {
10c96f: 85 c0 test %eax,%eax
10c971: 74 62 je 10c9d5 <rtems_rbheap_initialize+0x129>
first->begin = aligned_begin;
10c973: 89 70 18 mov %esi,0x18(%eax)
first->size = aligned_end - aligned_begin;
10c976: 29 f7 sub %esi,%edi
10c978: 89 78 1c mov %edi,0x1c(%eax)
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10c97b: 89 58 04 mov %ebx,0x4(%eax)
before_node = after_node->next;
10c97e: 8b 13 mov (%ebx),%edx
after_node->next = the_node;
10c980: 89 03 mov %eax,(%ebx)
the_node->next = before_node;
10c982: 89 10 mov %edx,(%eax)
before_node->previous = the_node;
10c984: 89 42 04 mov %eax,0x4(%edx)
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
10c987: 83 c0 08 add $0x8,%eax
10c98a: 89 44 24 04 mov %eax,0x4(%esp)
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
10c98e: 89 d8 mov %ebx,%eax
10c990: 83 c0 18 add $0x18,%eax
10c993: 89 04 24 mov %eax,(%esp)
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
10c996: e8 c9 18 00 00 call 10e264 <_RBTree_Insert_unprotected>
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
10c99b: 31 c0 xor %eax,%eax
10c99d: e9 1d ff ff ff jmp 10c8bf <rtems_rbheap_initialize+0x13>
10c9a2: 66 90 xchg %ax,%ax
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
10c9a4: 39 5c 24 24 cmp %ebx,0x24(%esp)
10c9a8: 72 0e jb 10c9b8 <rtems_rbheap_initialize+0x10c>
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
10c9aa: b8 09 00 00 00 mov $0x9,%eax
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
10c9af: 83 c4 10 add $0x10,%esp
10c9b2: 5b pop %ebx
10c9b3: 5e pop %esi
10c9b4: 5f pop %edi
10c9b5: c3 ret
10c9b6: 66 90 xchg %ax,%ax
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
value += alignment - excess;
10c9b8: 8b 74 24 24 mov 0x24(%esp),%esi
10c9bc: 01 ce add %ecx,%esi
10c9be: 29 d6 sub %edx,%esi
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
10c9c0: 39 74 24 24 cmp %esi,0x24(%esp)
10c9c4: 77 e4 ja 10c9aa <rtems_rbheap_initialize+0xfe><== NEVER TAKEN
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
10c9c6: 89 d8 mov %ebx,%eax
10c9c8: 31 d2 xor %edx,%edx
10c9ca: f7 f1 div %ecx
return value - excess;
10c9cc: 89 df mov %ebx,%edi
10c9ce: 29 d7 sub %edx,%edi
10c9d0: e9 23 ff ff ff jmp 10c8f8 <rtems_rbheap_initialize+0x4c>
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
add_to_chain(free_chain, first);
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
10c9d5: b8 1a 00 00 00 mov $0x1a,%eax
10c9da: e9 e0 fe ff ff jmp 10c8bf <rtems_rbheap_initialize+0x13>
0011ac6c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
11ac6c: 53 push %ebx
11ac6d: 83 ec 28 sub $0x28,%esp
11ac70: 8b 5c 24 34 mov 0x34(%esp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
11ac74: 85 db test %ebx,%ebx
11ac76: 75 0c jne 11ac84 <rtems_signal_send+0x18>
return RTEMS_INVALID_NUMBER;
11ac78: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11ac7d: 83 c4 28 add $0x28,%esp
11ac80: 5b pop %ebx
11ac81: c3 ret
11ac82: 66 90 xchg %ax,%ax
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
11ac84: 8d 44 24 1c lea 0x1c(%esp),%eax
11ac88: 89 44 24 04 mov %eax,0x4(%esp)
11ac8c: 8b 44 24 30 mov 0x30(%esp),%eax
11ac90: 89 04 24 mov %eax,(%esp)
11ac93: e8 ec 43 00 00 call 11f084 <_Thread_Get>
switch ( location ) {
11ac98: 8b 54 24 1c mov 0x1c(%esp),%edx
11ac9c: 85 d2 test %edx,%edx
11ac9e: 75 38 jne 11acd8 <rtems_signal_send+0x6c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
11aca0: 8b 90 e0 00 00 00 mov 0xe0(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
11aca6: 8b 4a 0c mov 0xc(%edx),%ecx
11aca9: 85 c9 test %ecx,%ecx
11acab: 74 35 je 11ace2 <rtems_signal_send+0x76>
if ( asr->is_enabled ) {
11acad: 80 7a 08 00 cmpb $0x0,0x8(%edx)
11acb1: 74 3d je 11acf0 <rtems_signal_send+0x84>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
11acb3: 9c pushf
11acb4: fa cli
11acb5: 59 pop %ecx
*signal_set |= signals;
11acb6: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
11acb9: 51 push %ecx
11acba: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
11acbb: 8b 15 68 dc 14 00 mov 0x14dc68,%edx
11acc1: 85 d2 test %edx,%edx
11acc3: 74 08 je 11accd <rtems_signal_send+0x61>
11acc5: 3b 05 6c dc 14 00 cmp 0x14dc6c,%eax
11accb: 74 2d je 11acfa <rtems_signal_send+0x8e><== ALWAYS TAKEN
_Thread_Dispatch_necessary = true;
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
11accd: e8 92 43 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11acd2: 31 c0 xor %eax,%eax
11acd4: eb a7 jmp 11ac7d <rtems_signal_send+0x11>
11acd6: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11acd8: b8 04 00 00 00 mov $0x4,%eax
}
11acdd: 83 c4 28 add $0x28,%esp
11ace0: 5b pop %ebx
11ace1: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11ace2: e8 7d 43 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
11ace7: b8 0b 00 00 00 mov $0xb,%eax
11acec: eb 8f jmp 11ac7d <rtems_signal_send+0x11>
11acee: 66 90 xchg %ax,%ax
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
11acf0: 9c pushf
11acf1: fa cli
11acf2: 58 pop %eax
*signal_set |= signals;
11acf3: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
11acf6: 50 push %eax
11acf7: 9d popf
11acf8: eb d3 jmp 11accd <rtems_signal_send+0x61>
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
if ( asr->is_enabled ) {
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
11acfa: c6 05 78 dc 14 00 01 movb $0x1,0x14dc78
11ad01: eb ca jmp 11accd <rtems_signal_send+0x61>
001274e8 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
1274e8: 57 push %edi
1274e9: 56 push %esi
1274ea: 8b 44 24 0c mov 0xc(%esp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
1274ee: 8b 70 08 mov 0x8(%eax),%esi
1274f1: 85 f6 test %esi,%esi
1274f3: 74 15 je 12750a <rtems_stack_checker_begin_extension+0x22><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
1274f5: 8b b8 b4 00 00 00 mov 0xb4(%eax),%edi
1274fb: 83 c7 08 add $0x8,%edi
1274fe: be 6c b5 17 00 mov $0x17b56c,%esi
127503: b9 04 00 00 00 mov $0x4,%ecx
127508: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
12750a: 5e pop %esi
12750b: 5f pop %edi
12750c: c3 ret
00127460 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
127460: 57 push %edi
127461: 53 push %ebx
127462: 8b 54 24 10 mov 0x10(%esp),%edx
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
127466: 8b 0d 28 a9 17 00 mov 0x17a928,%ecx
12746c: 85 c9 test %ecx,%ecx
12746e: 75 5a jne 1274ca <rtems_stack_checker_create_extension+0x6a>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
127470: c7 05 6c b5 17 00 0d movl $0xfeedf00d,0x17b56c
127477: f0 ed fe
12747a: c7 05 70 b5 17 00 06 movl $0xbad0d06,0x17b570
127481: 0d ad 0b
127484: c7 05 74 b5 17 00 0d movl $0xdeadf00d,0x17b574
12748b: f0 ad de
12748e: c7 05 78 b5 17 00 06 movl $0x600d0d06,0x17b578
127495: 0d 0d 60
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
127498: 8b 1d c0 b3 17 00 mov 0x17b3c0,%ebx
12749e: 85 db test %ebx,%ebx
1274a0: 74 1e je 1274c0 <rtems_stack_checker_create_extension+0x60><== NEVER TAKEN
1274a2: 8b 0d c4 b3 17 00 mov 0x17b3c4,%ecx
1274a8: 85 c9 test %ecx,%ecx
1274aa: 74 14 je 1274c0 <rtems_stack_checker_create_extension+0x60><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
1274ac: 89 1d 80 b5 17 00 mov %ebx,0x17b580
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
1274b2: 29 d9 sub %ebx,%ecx
1274b4: 89 0d 7c b5 17 00 mov %ecx,0x17b57c
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
1274ba: b0 a5 mov $0xa5,%al
1274bc: 89 df mov %ebx,%edi
1274be: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
1274c0: c7 05 28 a9 17 00 01 movl $0x1,0x17a928
1274c7: 00 00 00
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
1274ca: 85 d2 test %edx,%edx
1274cc: 74 12 je 1274e0 <rtems_stack_checker_create_extension+0x80><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
1274ce: 8b 9a b4 00 00 00 mov 0xb4(%edx),%ebx
1274d4: 8b 8a b0 00 00 00 mov 0xb0(%edx),%ecx
1274da: b0 a5 mov $0xa5,%al
1274dc: 89 df mov %ebx,%edi
1274de: f3 aa rep stos %al,%es:(%edi)
return true;
}
1274e0: b0 01 mov $0x1,%al
1274e2: 5b pop %ebx
1274e3: 5f pop %edi
1274e4: c3 ret
0012766c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
12766c: 55 push %ebp
12766d: 89 e5 mov %esp,%ebp
12766f: 56 push %esi
127670: 53 push %ebx
127671: 83 ec 10 sub $0x10,%esp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
127674: 8b 35 cc b3 17 00 mov 0x17b3cc,%esi
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
12767a: 8b 86 b4 00 00 00 mov 0xb4(%esi),%eax
127680: 39 c5 cmp %eax,%ebp
127682: 73 30 jae 1276b4 <rtems_stack_checker_is_blown+0x48><== ALWAYS TAKEN
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
127684: b2 01 mov $0x1,%dl <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
127686: 83 3d 28 a9 17 00 00 cmpl $0x0,0x17a928 <== NOT EXECUTED
12768d: 74 42 je 1276d1 <rtems_stack_checker_is_blown+0x65><== NOT EXECUTED
pattern_ok = (!memcmp(
12768f: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp) <== NOT EXECUTED
127696: 00
127697: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp) <== NOT EXECUTED
12769e: 00
12769f: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
1276a2: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1276a5: e8 0e 6e 01 00 call 13e4b8 <memcmp> <== NOT EXECUTED
1276aa: 85 c0 test %eax,%eax <== NOT EXECUTED
1276ac: 0f 94 c2 sete %dl <== NOT EXECUTED
1276af: eb 20 jmp 1276d1 <rtems_stack_checker_is_blown+0x65><== NOT EXECUTED
1276b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1276b4: 8b 96 b0 00 00 00 mov 0xb0(%esi),%edx
1276ba: 01 c2 add %eax,%edx
1276bc: 39 d5 cmp %edx,%ebp
1276be: 0f 96 c3 setbe %bl
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
1276c1: 8b 15 28 a9 17 00 mov 0x17a928,%edx
1276c7: 85 d2 test %edx,%edx
1276c9: 75 15 jne 1276e0 <rtems_stack_checker_is_blown+0x74><== ALWAYS TAKEN
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
1276cb: b2 01 mov $0x1,%dl <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
1276cd: 84 db test %bl,%bl <== NOT EXECUTED
1276cf: 75 37 jne 127708 <rtems_stack_checker_is_blown+0x9c><== NOT EXECUTED
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
1276d1: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED
1276d4: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
1276d8: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1276db: e8 30 fe ff ff call 127510 <Stack_check_report_blown_task><== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
pattern_ok = (!memcmp(
1276e0: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
1276e7: 00
1276e8: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp)
1276ef: 00
1276f0: 83 c0 08 add $0x8,%eax
1276f3: 89 04 24 mov %eax,(%esp)
1276f6: e8 bd 6d 01 00 call 13e4b8 <memcmp>
1276fb: 85 c0 test %eax,%eax
1276fd: 0f 94 c2 sete %dl
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
127700: 84 db test %bl,%bl
127702: 74 cd je 1276d1 <rtems_stack_checker_is_blown+0x65><== NEVER TAKEN
127704: 84 d2 test %dl,%dl
127706: 74 c9 je 1276d1 <rtems_stack_checker_is_blown+0x65><== NEVER TAKEN
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
127708: 31 c0 xor %eax,%eax
12770a: 83 c4 10 add $0x10,%esp
12770d: 5b pop %ebx
12770e: 5e pop %esi
12770f: 5d pop %ebp
127710: c3 ret
00127780 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
127780: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
127783: c7 44 24 04 90 98 12 movl $0x129890,0x4(%esp) <== NOT EXECUTED
12778a: 00
12778b: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
127792: e8 7d ff ff ff call 127714 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
}
127797: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
12779a: c3 ret <== NOT EXECUTED
00127714 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
127714: 56 push %esi <== NOT EXECUTED
127715: 53 push %ebx <== NOT EXECUTED
127716: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
127719: 8b 74 24 20 mov 0x20(%esp),%esi <== NOT EXECUTED
12771d: 8b 5c 24 24 mov 0x24(%esp),%ebx <== NOT EXECUTED
if ( !print )
127721: 85 db test %ebx,%ebx <== NOT EXECUTED
127723: 74 52 je 127777 <rtems_stack_checker_report_usage_with_plugin+0x63><== NOT EXECUTED
return;
print_context = context;
127725: 89 35 2c a9 17 00 mov %esi,0x17a92c <== NOT EXECUTED
print_handler = print;
12772b: 89 1d 30 a9 17 00 mov %ebx,0x17a930 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
127731: c7 44 24 04 13 ae 15 movl $0x15ae13,0x4(%esp) <== NOT EXECUTED
127738: 00
127739: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
12773c: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
12773e: c7 44 24 04 98 ae 15 movl $0x15ae98,0x4(%esp) <== NOT EXECUTED
127745: 00
127746: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
127749: ff d3 call *%ebx <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
12774b: c7 04 24 dc 72 12 00 movl $0x1272dc,(%esp) <== NOT EXECUTED
127752: e8 8d 3b 00 00 call 12b2e4 <rtems_iterate_over_all_threads><== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
127757: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
12775e: e8 79 fb ff ff call 1272dc <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
127763: c7 05 2c a9 17 00 00 movl $0x0,0x17a92c <== NOT EXECUTED
12776a: 00 00 00
print_handler = NULL;
12776d: c7 05 30 a9 17 00 00 movl $0x0,0x17a930 <== NOT EXECUTED
127774: 00 00 00
}
127777: 83 c4 14 add $0x14,%esp <== NOT EXECUTED
12777a: 5b pop %ebx <== NOT EXECUTED
12777b: 5e pop %esi <== NOT EXECUTED
12777c: c3 ret <== NOT EXECUTED
001275f4 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
1275f4: 55 push %ebp
1275f5: 89 e5 mov %esp,%ebp
1275f7: 53 push %ebx
1275f8: 83 ec 14 sub $0x14,%esp
1275fb: 8b 5d 08 mov 0x8(%ebp),%ebx
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
1275fe: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax
127604: 8d 50 08 lea 0x8(%eax),%edx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
127607: 39 c5 cmp %eax,%ebp
127609: 72 0a jb 127615 <rtems_stack_checker_switch_extension+0x21><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
12760b: 03 83 b0 00 00 00 add 0xb0(%ebx),%eax
127611: 39 c5 cmp %eax,%ebp
127613: 76 2f jbe 127644 <rtems_stack_checker_switch_extension+0x50><== ALWAYS TAKEN
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
127615: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp) <== NOT EXECUTED
12761c: 00
12761d: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp) <== NOT EXECUTED
127624: 00
127625: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
127628: e8 8b 6e 01 00 call 13e4b8 <memcmp> <== NOT EXECUTED
12762d: 85 c0 test %eax,%eax <== NOT EXECUTED
12762f: 0f 94 c0 sete %al <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
127632: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
127635: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
127639: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
12763c: e8 cf fe ff ff call 127510 <Stack_check_report_blown_task><== NOT EXECUTED
127641: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
127644: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
12764b: 00
12764c: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp)
127653: 00
127654: 89 14 24 mov %edx,(%esp)
127657: e8 5c 6e 01 00 call 13e4b8 <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
12765c: 85 c0 test %eax,%eax
12765e: 75 06 jne 127666 <rtems_stack_checker_switch_extension+0x72><== NEVER TAKEN
Stack_check_report_blown_task( running, pattern_ok );
}
}
127660: 83 c4 14 add $0x14,%esp
127663: 5b pop %ebx
127664: 5d pop %ebp
127665: c3 ret
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
127666: 31 c0 xor %eax,%eax
127668: eb c8 jmp 127632 <rtems_stack_checker_switch_extension+0x3e><== NOT EXECUTED
00111454 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
111454: 53 push %ebx
111455: 83 ec 38 sub $0x38,%esp
111458: 8b 5c 24 44 mov 0x44(%esp),%ebx
double result;
char *end;
if ( !n )
11145c: 85 db test %ebx,%ebx
11145e: 74 6c je 1114cc <rtems_string_to_double+0x78>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111460: e8 fb 2a 00 00 call 113f60 <__errno>
111465: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
11146b: c7 03 00 00 00 00 movl $0x0,(%ebx)
111471: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtod( s, &end );
111478: 8d 44 24 2c lea 0x2c(%esp),%eax
11147c: 89 44 24 04 mov %eax,0x4(%esp)
111480: 8b 44 24 40 mov 0x40(%esp),%eax
111484: 89 04 24 mov %eax,(%esp)
111487: e8 58 57 00 00 call 116be4 <strtod>
if ( endptr )
*endptr = end;
11148c: 8b 44 24 2c mov 0x2c(%esp),%eax
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
111490: 8b 54 24 48 mov 0x48(%esp),%edx
111494: 85 d2 test %edx,%edx
111496: 74 06 je 11149e <rtems_string_to_double+0x4a>
*endptr = end;
111498: 8b 54 24 48 mov 0x48(%esp),%edx
11149c: 89 02 mov %eax,(%edx)
if ( end == s )
11149e: 39 44 24 40 cmp %eax,0x40(%esp)
1114a2: 74 1c je 1114c0 <rtems_string_to_double+0x6c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1114a4: dd 5c 24 10 fstpl 0x10(%esp)
1114a8: e8 b3 2a 00 00 call 113f60 <__errno>
1114ad: 83 38 22 cmpl $0x22,(%eax)
1114b0: dd 44 24 10 fldl 0x10(%esp)
1114b4: 74 22 je 1114d8 <rtems_string_to_double+0x84>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
1114b6: dd 1b fstpl (%ebx)
return RTEMS_SUCCESSFUL;
1114b8: 31 c0 xor %eax,%eax
}
1114ba: 83 c4 38 add $0x38,%esp
1114bd: 5b pop %ebx
1114be: c3 ret
1114bf: 90 nop
1114c0: dd d8 fstp %st(0)
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1114c2: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1114c7: 83 c4 38 add $0x38,%esp
1114ca: 5b pop %ebx
1114cb: c3 ret
{
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1114cc: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1114d1: 83 c4 38 add $0x38,%esp
1114d4: 5b pop %ebx
1114d5: c3 ret
1114d6: 66 90 xchg %ax,%ax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1114d8: d9 ee fldz
1114da: d9 c9 fxch %st(1)
1114dc: dd e1 fucom %st(1)
1114de: df e0 fnstsw %ax
1114e0: dd d9 fstp %st(1)
1114e2: 80 e4 45 and $0x45,%ah
1114e5: 80 fc 40 cmp $0x40,%ah
1114e8: 75 16 jne 111500 <rtems_string_to_double+0xac><== ALWAYS TAKEN
1114ea: dd d8 fstp %st(0) <== NOT EXECUTED
1114ec: eb 0a jmp 1114f8 <rtems_string_to_double+0xa4><== NOT EXECUTED
1114ee: 66 90 xchg %ax,%ax <== NOT EXECUTED
1114f0: dd d8 fstp %st(0)
1114f2: eb 04 jmp 1114f8 <rtems_string_to_double+0xa4>
1114f4: dd d8 fstp %st(0)
1114f6: 66 90 xchg %ax,%ax
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
1114f8: b8 0a 00 00 00 mov $0xa,%eax
1114fd: eb bb jmp 1114ba <rtems_string_to_double+0x66>
1114ff: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
111500: dd 05 30 6a 12 00 fldl 0x126a30
111506: d9 c9 fxch %st(1)
111508: dd e1 fucom %st(1)
11150a: df e0 fnstsw %ax
11150c: dd d9 fstp %st(1)
11150e: f6 c4 45 test $0x45,%ah
111511: 74 dd je 1114f0 <rtems_string_to_double+0x9c>
111513: dd 05 38 6a 12 00 fldl 0x126a38
111519: dd e9 fucomp %st(1)
11151b: df e0 fnstsw %ax
11151d: f6 c4 45 test $0x45,%ah
111520: 74 d2 je 1114f4 <rtems_string_to_double+0xa0><== ALWAYS TAKEN
111522: eb 92 jmp 1114b6 <rtems_string_to_double+0x62><== NOT EXECUTED
00111524 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
111524: 53 push %ebx
111525: 83 ec 38 sub $0x38,%esp
111528: 8b 5c 24 44 mov 0x44(%esp),%ebx
float result;
char *end;
if ( !n )
11152c: 85 db test %ebx,%ebx
11152e: 74 64 je 111594 <rtems_string_to_float+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111530: e8 2b 2a 00 00 call 113f60 <__errno>
111535: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
11153b: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtof( s, &end );
111541: 8d 44 24 2c lea 0x2c(%esp),%eax
111545: 89 44 24 04 mov %eax,0x4(%esp)
111549: 8b 44 24 40 mov 0x40(%esp),%eax
11154d: 89 04 24 mov %eax,(%esp)
111550: e8 b3 56 00 00 call 116c08 <strtof>
if ( endptr )
*endptr = end;
111555: 8b 44 24 2c mov 0x2c(%esp),%eax
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
111559: 8b 54 24 48 mov 0x48(%esp),%edx
11155d: 85 d2 test %edx,%edx
11155f: 74 06 je 111567 <rtems_string_to_float+0x43>
*endptr = end;
111561: 8b 54 24 48 mov 0x48(%esp),%edx
111565: 89 02 mov %eax,(%edx)
if ( end == s )
111567: 39 44 24 40 cmp %eax,0x40(%esp)
11156b: 74 1b je 111588 <rtems_string_to_float+0x64>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
11156d: d9 5c 24 10 fstps 0x10(%esp)
111571: e8 ea 29 00 00 call 113f60 <__errno>
111576: 83 38 22 cmpl $0x22,(%eax)
111579: d9 44 24 10 flds 0x10(%esp)
11157d: 74 21 je 1115a0 <rtems_string_to_float+0x7c>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
11157f: d9 1b fstps (%ebx)
return RTEMS_SUCCESSFUL;
111581: 31 c0 xor %eax,%eax
}
111583: 83 c4 38 add $0x38,%esp
111586: 5b pop %ebx
111587: c3 ret
111588: dd d8 fstp %st(0)
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
11158a: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
11158f: 83 c4 38 add $0x38,%esp
111592: 5b pop %ebx
111593: c3 ret
{
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
111594: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
111599: 83 c4 38 add $0x38,%esp
11159c: 5b pop %ebx
11159d: c3 ret
11159e: 66 90 xchg %ax,%ax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1115a0: d9 ee fldz
1115a2: d9 c9 fxch %st(1)
1115a4: dd e1 fucom %st(1)
1115a6: df e0 fnstsw %ax
1115a8: dd d9 fstp %st(1)
1115aa: 80 e4 45 and $0x45,%ah
1115ad: 80 fc 40 cmp $0x40,%ah
1115b0: 75 16 jne 1115c8 <rtems_string_to_float+0xa4><== ALWAYS TAKEN
1115b2: dd d8 fstp %st(0) <== NOT EXECUTED
1115b4: eb 0a jmp 1115c0 <rtems_string_to_float+0x9c><== NOT EXECUTED
1115b6: 66 90 xchg %ax,%ax <== NOT EXECUTED
1115b8: dd d8 fstp %st(0)
1115ba: eb 04 jmp 1115c0 <rtems_string_to_float+0x9c>
1115bc: dd d8 fstp %st(0)
1115be: 66 90 xchg %ax,%ax
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
1115c0: b8 0a 00 00 00 mov $0xa,%eax
1115c5: eb bc jmp 111583 <rtems_string_to_float+0x5f>
1115c7: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
1115c8: d9 05 40 6a 12 00 flds 0x126a40
1115ce: d9 c9 fxch %st(1)
1115d0: dd e1 fucom %st(1)
1115d2: df e0 fnstsw %ax
1115d4: dd d9 fstp %st(1)
1115d6: f6 c4 45 test $0x45,%ah
1115d9: 74 dd je 1115b8 <rtems_string_to_float+0x94>
1115db: d9 05 44 6a 12 00 flds 0x126a44
1115e1: dd e9 fucomp %st(1)
1115e3: df e0 fnstsw %ax
1115e5: f6 c4 45 test $0x45,%ah
1115e8: 74 d2 je 1115bc <rtems_string_to_float+0x98><== ALWAYS TAKEN
1115ea: eb 93 jmp 11157f <rtems_string_to_float+0x5b><== NOT EXECUTED
00121700 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
121700: 56 push %esi
121701: 53 push %ebx
121702: 83 ec 24 sub $0x24,%esp
121705: 8b 5c 24 34 mov 0x34(%esp),%ebx
long result;
char *end;
if ( !n )
121709: 85 db test %ebx,%ebx
12170b: 74 67 je 121774 <rtems_string_to_int+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
12170d: e8 c6 9b 01 00 call 13b2d8 <__errno>
121712: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
121718: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtol( s, &end, base );
12171e: 8b 44 24 3c mov 0x3c(%esp),%eax
121722: 89 44 24 08 mov %eax,0x8(%esp)
121726: 8d 44 24 1c lea 0x1c(%esp),%eax
12172a: 89 44 24 04 mov %eax,0x4(%esp)
12172e: 8b 44 24 30 mov 0x30(%esp),%eax
121732: 89 04 24 mov %eax,(%esp)
121735: e8 e2 12 02 00 call 142a1c <strtol>
12173a: 89 c6 mov %eax,%esi
if ( endptr )
*endptr = end;
12173c: 8b 54 24 1c mov 0x1c(%esp),%edx
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
121740: 8b 44 24 38 mov 0x38(%esp),%eax
121744: 85 c0 test %eax,%eax
121746: 74 06 je 12174e <rtems_string_to_int+0x4e>
*endptr = end;
121748: 8b 44 24 38 mov 0x38(%esp),%eax
12174c: 89 10 mov %edx,(%eax)
if ( end == s )
12174e: 39 54 24 30 cmp %edx,0x30(%esp)
121752: 74 14 je 121768 <rtems_string_to_int+0x68>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
121754: e8 7f 9b 01 00 call 13b2d8 <__errno>
121759: 83 38 22 cmpl $0x22,(%eax)
12175c: 74 22 je 121780 <rtems_string_to_int+0x80>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
12175e: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
121760: 31 c0 xor %eax,%eax
}
121762: 83 c4 24 add $0x24,%esp
121765: 5b pop %ebx
121766: 5e pop %esi
121767: c3 ret
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
121768: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
12176d: 83 c4 24 add $0x24,%esp
121770: 5b pop %ebx
121771: 5e pop %esi
121772: c3 ret
121773: 90 nop
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
121774: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
121779: 83 c4 24 add $0x24,%esp
12177c: 5b pop %ebx
12177d: 5e pop %esi
12177e: c3 ret
12177f: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
121780: 85 f6 test %esi,%esi
121782: 75 08 jne 12178c <rtems_string_to_int+0x8c><== ALWAYS TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
121784: b8 0a 00 00 00 mov $0xa,%eax
121789: eb d7 jmp 121762 <rtems_string_to_int+0x62>
12178b: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
12178c: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi
121792: 74 f0 je 121784 <rtems_string_to_int+0x84>
121794: 81 fe 00 00 00 80 cmp $0x80000000,%esi
12179a: 75 c2 jne 12175e <rtems_string_to_int+0x5e><== NEVER TAKEN
12179c: eb e6 jmp 121784 <rtems_string_to_int+0x84>
0011174c <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
11174c: 56 push %esi
11174d: 53 push %ebx
11174e: 83 ec 24 sub $0x24,%esp
111751: 8b 5c 24 34 mov 0x34(%esp),%ebx
long result;
char *end;
if ( !n )
111755: 85 db test %ebx,%ebx
111757: 74 67 je 1117c0 <rtems_string_to_long+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111759: e8 02 28 00 00 call 113f60 <__errno>
11175e: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
111764: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtol( s, &end, base );
11176a: 8b 44 24 3c mov 0x3c(%esp),%eax
11176e: 89 44 24 08 mov %eax,0x8(%esp)
111772: 8d 44 24 1c lea 0x1c(%esp),%eax
111776: 89 44 24 04 mov %eax,0x4(%esp)
11177a: 8b 44 24 30 mov 0x30(%esp),%eax
11177e: 89 04 24 mov %eax,(%esp)
111781: e8 96 56 00 00 call 116e1c <strtol>
111786: 89 c6 mov %eax,%esi
if ( endptr )
*endptr = end;
111788: 8b 54 24 1c mov 0x1c(%esp),%edx
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
11178c: 8b 44 24 38 mov 0x38(%esp),%eax
111790: 85 c0 test %eax,%eax
111792: 74 06 je 11179a <rtems_string_to_long+0x4e>
*endptr = end;
111794: 8b 44 24 38 mov 0x38(%esp),%eax
111798: 89 10 mov %edx,(%eax)
if ( end == s )
11179a: 39 54 24 30 cmp %edx,0x30(%esp)
11179e: 74 14 je 1117b4 <rtems_string_to_long+0x68>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1117a0: e8 bb 27 00 00 call 113f60 <__errno>
1117a5: 83 38 22 cmpl $0x22,(%eax)
1117a8: 74 22 je 1117cc <rtems_string_to_long+0x80>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
1117aa: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
1117ac: 31 c0 xor %eax,%eax
}
1117ae: 83 c4 24 add $0x24,%esp
1117b1: 5b pop %ebx
1117b2: 5e pop %esi
1117b3: c3 ret
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1117b4: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1117b9: 83 c4 24 add $0x24,%esp
1117bc: 5b pop %ebx
1117bd: 5e pop %esi
1117be: c3 ret
1117bf: 90 nop
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1117c0: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1117c5: 83 c4 24 add $0x24,%esp
1117c8: 5b pop %ebx
1117c9: 5e pop %esi
1117ca: c3 ret
1117cb: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1117cc: 85 f6 test %esi,%esi
1117ce: 75 08 jne 1117d8 <rtems_string_to_long+0x8c><== ALWAYS TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
1117d0: b8 0a 00 00 00 mov $0xa,%eax
1117d5: eb d7 jmp 1117ae <rtems_string_to_long+0x62>
1117d7: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
1117d8: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi
1117de: 74 f0 je 1117d0 <rtems_string_to_long+0x84>
1117e0: 81 fe 00 00 00 80 cmp $0x80000000,%esi
1117e6: 75 c2 jne 1117aa <rtems_string_to_long+0x5e><== NEVER TAKEN
1117e8: eb e6 jmp 1117d0 <rtems_string_to_long+0x84>
0011168c <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
11168c: 56 push %esi
11168d: 53 push %ebx
11168e: 83 ec 34 sub $0x34,%esp
111691: 8b 5c 24 44 mov 0x44(%esp),%ebx
long long result;
char *end;
if ( !n )
111695: 85 db test %ebx,%ebx
111697: 74 7b je 111714 <rtems_string_to_long_long+0x88>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111699: e8 c2 28 00 00 call 113f60 <__errno>
11169e: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1116a4: c7 03 00 00 00 00 movl $0x0,(%ebx)
1116aa: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoll( s, &end, base );
1116b1: 8b 44 24 4c mov 0x4c(%esp),%eax
1116b5: 89 44 24 08 mov %eax,0x8(%esp)
1116b9: 8d 44 24 2c lea 0x2c(%esp),%eax
1116bd: 89 44 24 04 mov %eax,0x4(%esp)
1116c1: 8b 44 24 40 mov 0x40(%esp),%eax
1116c5: 89 04 24 mov %eax,(%esp)
1116c8: e8 7b 57 00 00 call 116e48 <strtoll>
1116cd: 89 c6 mov %eax,%esi
if ( endptr )
*endptr = end;
1116cf: 8b 4c 24 2c mov 0x2c(%esp),%ecx
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
if ( endptr )
1116d3: 8b 44 24 48 mov 0x48(%esp),%eax
1116d7: 85 c0 test %eax,%eax
1116d9: 74 06 je 1116e1 <rtems_string_to_long_long+0x55>
*endptr = end;
1116db: 8b 44 24 48 mov 0x48(%esp),%eax
1116df: 89 08 mov %ecx,(%eax)
if ( end == s )
1116e1: 39 4c 24 40 cmp %ecx,0x40(%esp)
1116e5: 74 21 je 111708 <rtems_string_to_long_long+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1116e7: 89 54 24 1c mov %edx,0x1c(%esp)
1116eb: e8 70 28 00 00 call 113f60 <__errno>
1116f0: 83 38 22 cmpl $0x22,(%eax)
1116f3: 8b 54 24 1c mov 0x1c(%esp),%edx
1116f7: 74 27 je 111720 <rtems_string_to_long_long+0x94>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
1116f9: 89 33 mov %esi,(%ebx)
1116fb: 89 53 04 mov %edx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
1116fe: 31 c0 xor %eax,%eax
}
111700: 83 c4 34 add $0x34,%esp
111703: 5b pop %ebx
111704: 5e pop %esi
111705: c3 ret
111706: 66 90 xchg %ax,%ax
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
111708: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
11170d: 83 c4 34 add $0x34,%esp
111710: 5b pop %ebx
111711: 5e pop %esi
111712: c3 ret
111713: 90 nop
{
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
111714: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
111719: 83 c4 34 add $0x34,%esp
11171c: 5b pop %ebx
11171d: 5e pop %esi
11171e: c3 ret
11171f: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
111720: 89 d0 mov %edx,%eax
111722: 09 f0 or %esi,%eax
111724: 75 0a jne 111730 <rtems_string_to_long_long+0xa4><== ALWAYS TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
111726: b8 0a 00 00 00 mov $0xa,%eax
11172b: eb d3 jmp 111700 <rtems_string_to_long_long+0x74>
11172d: 8d 76 00 lea 0x0(%esi),%esi
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
111730: 89 d1 mov %edx,%ecx
111732: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx
111738: 89 f0 mov %esi,%eax
11173a: f7 d0 not %eax
11173c: 09 c1 or %eax,%ecx
11173e: 74 e6 je 111726 <rtems_string_to_long_long+0x9a>
111740: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax
111746: 09 f0 or %esi,%eax
111748: 75 af jne 1116f9 <rtems_string_to_long_long+0x6d><== NEVER TAKEN
11174a: eb da jmp 111726 <rtems_string_to_long_long+0x9a>
001217cc <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1217cc: 56 push %esi
1217cd: 53 push %ebx
1217ce: 83 ec 24 sub $0x24,%esp
1217d1: 8b 5c 24 34 mov 0x34(%esp),%ebx
unsigned long result;
char *end;
if ( !n )
1217d5: 85 db test %ebx,%ebx
1217d7: 74 6f je 121848 <rtems_string_to_unsigned_char+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1217d9: e8 fa 9a 01 00 call 13b2d8 <__errno>
1217de: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1217e4: c6 03 00 movb $0x0,(%ebx)
result = strtoul( s, &end, base );
1217e7: 8b 44 24 3c mov 0x3c(%esp),%eax
1217eb: 89 44 24 08 mov %eax,0x8(%esp)
1217ef: 8d 44 24 1c lea 0x1c(%esp),%eax
1217f3: 89 44 24 04 mov %eax,0x4(%esp)
1217f7: 8b 44 24 30 mov 0x30(%esp),%eax
1217fb: 89 04 24 mov %eax,(%esp)
1217fe: e8 95 17 02 00 call 142f98 <strtoul>
121803: 89 c6 mov %eax,%esi
if ( endptr )
*endptr = end;
121805: 8b 54 24 1c mov 0x1c(%esp),%edx
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
121809: 8b 44 24 38 mov 0x38(%esp),%eax
12180d: 85 c0 test %eax,%eax
12180f: 74 06 je 121817 <rtems_string_to_unsigned_char+0x4b>
*endptr = end;
121811: 8b 44 24 38 mov 0x38(%esp),%eax
121815: 89 10 mov %edx,(%eax)
if ( end == s )
121817: 39 54 24 30 cmp %edx,0x30(%esp)
12181b: 74 1f je 12183c <rtems_string_to_unsigned_char+0x70>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
12181d: e8 b6 9a 01 00 call 13b2d8 <__errno>
121822: 83 38 22 cmpl $0x22,(%eax)
121825: 74 45 je 12186c <rtems_string_to_unsigned_char+0xa0>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
121827: 81 fe ff 00 00 00 cmp $0xff,%esi
12182d: 77 25 ja 121854 <rtems_string_to_unsigned_char+0x88>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
12182f: 89 f0 mov %esi,%eax
121831: 88 03 mov %al,(%ebx)
return RTEMS_SUCCESSFUL;
121833: 31 c0 xor %eax,%eax
}
121835: 83 c4 24 add $0x24,%esp
121838: 5b pop %ebx
121839: 5e pop %esi
12183a: c3 ret
12183b: 90 nop
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
12183c: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
121841: 83 c4 24 add $0x24,%esp
121844: 5b pop %ebx
121845: 5e pop %esi
121846: c3 ret
121847: 90 nop
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
121848: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
12184d: 83 c4 24 add $0x24,%esp
121850: 5b pop %ebx
121851: 5e pop %esi
121852: c3 ret
121853: 90 nop
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
121854: e8 7f 9a 01 00 call 13b2d8 <__errno>
121859: c7 00 22 00 00 00 movl $0x22,(%eax)
return RTEMS_INVALID_NUMBER;
12185f: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
121864: 83 c4 24 add $0x24,%esp
121867: 5b pop %ebx
121868: 5e pop %esi
121869: c3 ret
12186a: 66 90 xchg %ax,%ax
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
12186c: 8d 46 ff lea -0x1(%esi),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
12186f: 83 f8 fd cmp $0xfffffffd,%eax
121872: 76 b3 jbe 121827 <rtems_string_to_unsigned_char+0x5b><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
121874: b8 0a 00 00 00 mov $0xa,%eax
121879: eb c6 jmp 121841 <rtems_string_to_unsigned_char+0x75>
001118c8 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
1118c8: 56 push %esi
1118c9: 53 push %ebx
1118ca: 83 ec 24 sub $0x24,%esp
1118cd: 8b 5c 24 34 mov 0x34(%esp),%ebx
unsigned long result;
char *end;
if ( !n )
1118d1: 85 db test %ebx,%ebx
1118d3: 74 67 je 11193c <rtems_string_to_unsigned_int+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1118d5: e8 86 26 00 00 call 113f60 <__errno>
1118da: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1118e0: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
1118e6: 8b 44 24 3c mov 0x3c(%esp),%eax
1118ea: 89 44 24 08 mov %eax,0x8(%esp)
1118ee: 8d 44 24 1c lea 0x1c(%esp),%eax
1118f2: 89 44 24 04 mov %eax,0x4(%esp)
1118f6: 8b 44 24 30 mov 0x30(%esp),%eax
1118fa: 89 04 24 mov %eax,(%esp)
1118fd: e8 96 5a 00 00 call 117398 <strtoul>
111902: 89 c6 mov %eax,%esi
if ( endptr )
*endptr = end;
111904: 8b 54 24 1c mov 0x1c(%esp),%edx
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
111908: 8b 44 24 38 mov 0x38(%esp),%eax
11190c: 85 c0 test %eax,%eax
11190e: 74 06 je 111916 <rtems_string_to_unsigned_int+0x4e>
*endptr = end;
111910: 8b 44 24 38 mov 0x38(%esp),%eax
111914: 89 10 mov %edx,(%eax)
if ( end == s )
111916: 39 54 24 30 cmp %edx,0x30(%esp)
11191a: 74 14 je 111930 <rtems_string_to_unsigned_int+0x68>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
11191c: e8 3f 26 00 00 call 113f60 <__errno>
111921: 83 38 22 cmpl $0x22,(%eax)
111924: 74 22 je 111948 <rtems_string_to_unsigned_int+0x80>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
111926: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
111928: 31 c0 xor %eax,%eax
}
11192a: 83 c4 24 add $0x24,%esp
11192d: 5b pop %ebx
11192e: 5e pop %esi
11192f: c3 ret
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
111930: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
111935: 83 c4 24 add $0x24,%esp
111938: 5b pop %ebx
111939: 5e pop %esi
11193a: c3 ret
11193b: 90 nop
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
11193c: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
111941: 83 c4 24 add $0x24,%esp
111944: 5b pop %ebx
111945: 5e pop %esi
111946: c3 ret
111947: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
111948: 8d 46 ff lea -0x1(%esi),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
11194b: 83 f8 fd cmp $0xfffffffd,%eax
11194e: 76 d6 jbe 111926 <rtems_string_to_unsigned_int+0x5e><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
111950: b8 0a 00 00 00 mov $0xa,%eax
111955: eb d3 jmp 11192a <rtems_string_to_unsigned_int+0x62>
0010f6f4 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
10f6f4: 56 push %esi
10f6f5: 53 push %ebx
10f6f6: 83 ec 24 sub $0x24,%esp
10f6f9: 8b 5c 24 34 mov 0x34(%esp),%ebx
unsigned long result;
char *end;
if ( !n )
10f6fd: 85 db test %ebx,%ebx
10f6ff: 74 67 je 10f768 <rtems_string_to_unsigned_long+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f701: e8 d2 bb 02 00 call 13b2d8 <__errno>
10f706: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f70c: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
10f712: 8b 44 24 3c mov 0x3c(%esp),%eax
10f716: 89 44 24 08 mov %eax,0x8(%esp)
10f71a: 8d 44 24 1c lea 0x1c(%esp),%eax
10f71e: 89 44 24 04 mov %eax,0x4(%esp)
10f722: 8b 44 24 30 mov 0x30(%esp),%eax
10f726: 89 04 24 mov %eax,(%esp)
10f729: e8 6a 38 03 00 call 142f98 <strtoul>
10f72e: 89 c6 mov %eax,%esi
if ( endptr )
*endptr = end;
10f730: 8b 54 24 1c mov 0x1c(%esp),%edx
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
10f734: 8b 44 24 38 mov 0x38(%esp),%eax
10f738: 85 c0 test %eax,%eax
10f73a: 74 06 je 10f742 <rtems_string_to_unsigned_long+0x4e>
*endptr = end;
10f73c: 8b 44 24 38 mov 0x38(%esp),%eax
10f740: 89 10 mov %edx,(%eax)
if ( end == s )
10f742: 39 54 24 30 cmp %edx,0x30(%esp)
10f746: 74 14 je 10f75c <rtems_string_to_unsigned_long+0x68>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f748: e8 8b bb 02 00 call 13b2d8 <__errno>
10f74d: 83 38 22 cmpl $0x22,(%eax)
10f750: 74 22 je 10f774 <rtems_string_to_unsigned_long+0x80>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
10f752: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
10f754: 31 c0 xor %eax,%eax
}
10f756: 83 c4 24 add $0x24,%esp
10f759: 5b pop %ebx
10f75a: 5e pop %esi
10f75b: c3 ret
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
10f75c: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
10f761: 83 c4 24 add $0x24,%esp
10f764: 5b pop %ebx
10f765: 5e pop %esi
10f766: c3 ret
10f767: 90 nop
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f768: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
10f76d: 83 c4 24 add $0x24,%esp
10f770: 5b pop %ebx
10f771: 5e pop %esi
10f772: c3 ret
10f773: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
10f774: 8d 46 ff lea -0x1(%esi),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f777: 83 f8 fd cmp $0xfffffffd,%eax
10f77a: 76 d6 jbe 10f752 <rtems_string_to_unsigned_long+0x5e><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
10f77c: b8 0a 00 00 00 mov $0xa,%eax
10f781: eb d3 jmp 10f756 <rtems_string_to_unsigned_long+0x62>
00111958 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
111958: 57 push %edi
111959: 56 push %esi
11195a: 53 push %ebx
11195b: 83 ec 20 sub $0x20,%esp
11195e: 8b 5c 24 34 mov 0x34(%esp),%ebx
unsigned long long result;
char *end;
if ( !n )
111962: 85 db test %ebx,%ebx
111964: 74 76 je 1119dc <rtems_string_to_unsigned_long_long+0x84>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111966: e8 f5 25 00 00 call 113f60 <__errno>
11196b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
111971: c7 03 00 00 00 00 movl $0x0,(%ebx)
111977: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoull( s, &end, base );
11197e: 8b 44 24 3c mov 0x3c(%esp),%eax
111982: 89 44 24 08 mov %eax,0x8(%esp)
111986: 8d 44 24 1c lea 0x1c(%esp),%eax
11198a: 89 44 24 04 mov %eax,0x4(%esp)
11198e: 8b 44 24 30 mov 0x30(%esp),%eax
111992: 89 04 24 mov %eax,(%esp)
111995: e8 2a 5a 00 00 call 1173c4 <strtoull>
11199a: 89 c6 mov %eax,%esi
11199c: 89 d7 mov %edx,%edi
if ( endptr )
*endptr = end;
11199e: 8b 44 24 1c mov 0x1c(%esp),%eax
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
if ( endptr )
1119a2: 8b 54 24 38 mov 0x38(%esp),%edx
1119a6: 85 d2 test %edx,%edx
1119a8: 74 06 je 1119b0 <rtems_string_to_unsigned_long_long+0x58>
*endptr = end;
1119aa: 8b 54 24 38 mov 0x38(%esp),%edx
1119ae: 89 02 mov %eax,(%edx)
if ( end == s )
1119b0: 39 44 24 30 cmp %eax,0x30(%esp)
1119b4: 74 1a je 1119d0 <rtems_string_to_unsigned_long_long+0x78>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1119b6: e8 a5 25 00 00 call 113f60 <__errno>
1119bb: 83 38 22 cmpl $0x22,(%eax)
1119be: 74 28 je 1119e8 <rtems_string_to_unsigned_long_long+0x90>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
1119c0: 89 33 mov %esi,(%ebx)
1119c2: 89 7b 04 mov %edi,0x4(%ebx)
return RTEMS_SUCCESSFUL;
1119c5: 31 c0 xor %eax,%eax
}
1119c7: 83 c4 20 add $0x20,%esp
1119ca: 5b pop %ebx
1119cb: 5e pop %esi
1119cc: 5f pop %edi
1119cd: c3 ret
1119ce: 66 90 xchg %ax,%ax
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1119d0: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1119d5: 83 c4 20 add $0x20,%esp
1119d8: 5b pop %ebx
1119d9: 5e pop %esi
1119da: 5f pop %edi
1119db: c3 ret
{
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1119dc: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1119e1: 83 c4 20 add $0x20,%esp
1119e4: 5b pop %ebx
1119e5: 5e pop %esi
1119e6: 5f pop %edi
1119e7: c3 ret
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
1119e8: 89 f0 mov %esi,%eax
1119ea: 89 fa mov %edi,%edx
1119ec: 83 c0 ff add $0xffffffff,%eax
1119ef: 83 d2 ff adc $0xffffffff,%edx
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1119f2: 83 fa ff cmp $0xffffffff,%edx
1119f5: 72 c9 jb 1119c0 <rtems_string_to_unsigned_long_long+0x68><== NEVER TAKEN
1119f7: 83 f8 fd cmp $0xfffffffd,%eax
1119fa: 76 c4 jbe 1119c0 <rtems_string_to_unsigned_long_long+0x68><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
1119fc: b8 0a 00 00 00 mov $0xa,%eax
111a01: eb c4 jmp 1119c7 <rtems_string_to_unsigned_long_long+0x6f>
001128c8 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
1128c8: 55 push %ebp
1128c9: 57 push %edi
1128ca: 56 push %esi
1128cb: 53 push %ebx
1128cc: 83 ec 0c sub $0xc,%esp
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
1128cf: 8b 4c 24 28 mov 0x28(%esp),%ecx
1128d3: 85 c9 test %ecx,%ecx
1128d5: 0f 84 25 01 00 00 je 112a00 <rtems_task_mode+0x138>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
1128db: 8b 35 6c f8 12 00 mov 0x12f86c,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
1128e1: 8b 9e e0 00 00 00 mov 0xe0(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
1128e7: 80 7e 70 01 cmpb $0x1,0x70(%esi)
1128eb: 19 ff sbb %edi,%edi
1128ed: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
1128f3: 8b 56 78 mov 0x78(%esi),%edx
1128f6: 85 d2 test %edx,%edx
1128f8: 0f 85 f6 00 00 00 jne 1129f4 <rtems_task_mode+0x12c>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
1128fe: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
112902: 19 ed sbb %ebp,%ebp
112904: 81 e5 00 04 00 00 and $0x400,%ebp
old_mode |= _ISR_Get_level();
11290a: e8 1d c7 ff ff call 10f02c <_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;
11290f: 09 e8 or %ebp,%eax
old_mode |= _ISR_Get_level();
112911: 09 f8 or %edi,%eax
112913: 8b 54 24 28 mov 0x28(%esp),%edx
112917: 89 02 mov %eax,(%edx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
112919: f7 44 24 24 00 01 00 testl $0x100,0x24(%esp)
112920: 00
112921: 74 10 je 112933 <rtems_task_mode+0x6b>
112923: 8b 44 24 20 mov 0x20(%esp),%eax
112927: c1 e8 08 shr $0x8,%eax
11292a: 83 f0 01 xor $0x1,%eax
11292d: 83 e0 01 and $0x1,%eax
112930: 88 46 70 mov %al,0x70(%esi)
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
112933: f7 44 24 24 00 02 00 testl $0x200,0x24(%esp)
11293a: 00
11293b: 74 1d je 11295a <rtems_task_mode+0x92>
if ( _Modes_Is_timeslice(mode_set) ) {
11293d: f7 44 24 20 00 02 00 testl $0x200,0x20(%esp)
112944: 00
112945: 0f 84 c5 00 00 00 je 112a10 <rtems_task_mode+0x148>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
11294b: c7 46 78 01 00 00 00 movl $0x1,0x78(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
112952: a1 d8 f5 12 00 mov 0x12f5d8,%eax
112957: 89 46 74 mov %eax,0x74(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
11295a: f6 44 24 24 01 testb $0x1,0x24(%esp)
11295f: 74 0c je 11296d <rtems_task_mode+0xa5>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
112961: f6 44 24 20 01 testb $0x1,0x20(%esp)
112966: 0f 84 bc 00 00 00 je 112a28 <rtems_task_mode+0x160>
11296c: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
11296d: f7 44 24 24 00 04 00 testl $0x400,0x24(%esp)
112974: 00
112975: 74 41 je 1129b8 <rtems_task_mode+0xf0>
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
112977: 8b 44 24 20 mov 0x20(%esp),%eax
11297b: c1 e8 0a shr $0xa,%eax
11297e: 83 f0 01 xor $0x1,%eax
112981: 83 e0 01 and $0x1,%eax
if ( is_asr_enabled != asr->is_enabled ) {
112984: 38 43 08 cmp %al,0x8(%ebx)
112987: 74 2f je 1129b8 <rtems_task_mode+0xf0>
asr->is_enabled = is_asr_enabled;
112989: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
11298c: 9c pushf
11298d: fa cli
11298e: 58 pop %eax
_signals = information->signals_pending;
11298f: 8b 4b 18 mov 0x18(%ebx),%ecx
information->signals_pending = information->signals_posted;
112992: 8b 53 14 mov 0x14(%ebx),%edx
112995: 89 53 18 mov %edx,0x18(%ebx)
information->signals_posted = _signals;
112998: 89 4b 14 mov %ecx,0x14(%ebx)
_ISR_Enable( _level );
11299b: 50 push %eax
11299c: 9d popf
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
11299d: 8b 43 14 mov 0x14(%ebx),%eax
1129a0: 85 c0 test %eax,%eax
1129a2: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
1129a5: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760
1129ac: 74 15 je 1129c3 <rtems_task_mode+0xfb> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
1129ae: 31 c0 xor %eax,%eax
}
1129b0: 83 c4 0c add $0xc,%esp
1129b3: 5b pop %ebx
1129b4: 5e pop %esi
1129b5: 5f pop %edi
1129b6: 5d pop %ebp
1129b7: c3 ret
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
1129b8: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
1129ba: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760
1129c1: 75 eb jne 1129ae <rtems_task_mode+0xe6>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
1129c3: 8b 15 6c f8 12 00 mov 0x12f86c,%edx
if ( are_signals_pending ||
1129c9: 84 c0 test %al,%al
1129cb: 75 0e jne 1129db <rtems_task_mode+0x113>
1129cd: 3b 15 70 f8 12 00 cmp 0x12f870,%edx
1129d3: 74 d9 je 1129ae <rtems_task_mode+0xe6>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
1129d5: 80 7a 70 00 cmpb $0x0,0x70(%edx)
1129d9: 74 d3 je 1129ae <rtems_task_mode+0xe6> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
1129db: c6 05 78 f8 12 00 01 movb $0x1,0x12f878
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
1129e2: e8 5d b2 ff ff call 10dc44 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
1129e7: 31 c0 xor %eax,%eax
}
1129e9: 83 c4 0c add $0xc,%esp
1129ec: 5b pop %ebx
1129ed: 5e pop %esi
1129ee: 5f pop %edi
1129ef: 5d pop %ebp
1129f0: c3 ret
1129f1: 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;
1129f4: 81 cf 00 02 00 00 or $0x200,%edi
1129fa: e9 ff fe ff ff jmp 1128fe <rtems_task_mode+0x36>
1129ff: 90 nop
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
112a00: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
112a05: 83 c4 0c add $0xc,%esp
112a08: 5b pop %ebx
112a09: 5e pop %esi
112a0a: 5f pop %edi
112a0b: 5d pop %ebp
112a0c: c3 ret
112a0d: 8d 76 00 lea 0x0(%esi),%esi
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;
112a10: c7 46 78 00 00 00 00 movl $0x0,0x78(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112a17: f6 44 24 24 01 testb $0x1,0x24(%esp)
112a1c: 0f 84 4b ff ff ff je 11296d <rtems_task_mode+0xa5>
112a22: e9 3a ff ff ff jmp 112961 <rtems_task_mode+0x99>
112a27: 90 nop
112a28: fb sti
112a29: e9 3f ff ff ff jmp 11296d <rtems_task_mode+0xa5>
0010f99c <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10f99c: 53 push %ebx
10f99d: 83 ec 28 sub $0x28,%esp
10f9a0: 8b 5c 24 34 mov 0x34(%esp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10f9a4: 85 db test %ebx,%ebx
10f9a6: 74 0b je 10f9b3 <rtems_task_set_priority+0x17>
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 ) );
10f9a8: 0f b6 05 ac 01 13 00 movzbl 0x1301ac,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10f9af: 39 c3 cmp %eax,%ebx
10f9b1: 77 79 ja 10fa2c <rtems_task_set_priority+0x90>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10f9b3: 8b 44 24 38 mov 0x38(%esp),%eax
10f9b7: 85 c0 test %eax,%eax
10f9b9: 74 59 je 10fa14 <rtems_task_set_priority+0x78>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10f9bb: 8d 44 24 1c lea 0x1c(%esp),%eax
10f9bf: 89 44 24 04 mov %eax,0x4(%esp)
10f9c3: 8b 44 24 30 mov 0x30(%esp),%eax
10f9c7: 89 04 24 mov %eax,(%esp)
10f9ca: e8 f1 20 00 00 call 111ac0 <_Thread_Get>
switch ( location ) {
10f9cf: 8b 4c 24 1c mov 0x1c(%esp),%ecx
10f9d3: 85 c9 test %ecx,%ecx
10f9d5: 75 49 jne 10fa20 <rtems_task_set_priority+0x84>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10f9d7: 8b 50 14 mov 0x14(%eax),%edx
10f9da: 8b 4c 24 38 mov 0x38(%esp),%ecx
10f9de: 89 11 mov %edx,(%ecx)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10f9e0: 85 db test %ebx,%ebx
10f9e2: 74 23 je 10fa07 <rtems_task_set_priority+0x6b>
the_thread->real_priority = new_priority;
10f9e4: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10f9e7: 8b 50 1c mov 0x1c(%eax),%edx
10f9ea: 85 d2 test %edx,%edx
10f9ec: 74 05 je 10f9f3 <rtems_task_set_priority+0x57>
10f9ee: 3b 58 14 cmp 0x14(%eax),%ebx
10f9f1: 73 14 jae 10fa07 <rtems_task_set_priority+0x6b><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10f9f3: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10f9fa: 00
10f9fb: 89 5c 24 04 mov %ebx,0x4(%esp)
10f9ff: 89 04 24 mov %eax,(%esp)
10fa02: e8 2d 1c 00 00 call 111634 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
10fa07: e8 94 20 00 00 call 111aa0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10fa0c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa0e: 83 c4 28 add $0x28,%esp
10fa11: 5b pop %ebx
10fa12: c3 ret
10fa13: 90 nop
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10fa14: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa19: 83 c4 28 add $0x28,%esp
10fa1c: 5b pop %ebx
10fa1d: c3 ret
10fa1e: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10fa20: b8 04 00 00 00 mov $0x4,%eax
}
10fa25: 83 c4 28 add $0x28,%esp
10fa28: 5b pop %ebx
10fa29: c3 ret
10fa2a: 66 90 xchg %ax,%ax
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;
10fa2c: b8 13 00 00 00 mov $0x13,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa31: 83 c4 28 add $0x28,%esp
10fa34: 5b pop %ebx
10fa35: c3 ret
00107c60 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
107c60: 53 push %ebx
107c61: 83 ec 28 sub $0x28,%esp
107c64: 8b 5c 24 34 mov 0x34(%esp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
107c68: 85 db test %ebx,%ebx
107c6a: 74 58 je 107cc4 <rtems_task_variable_delete+0x64>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
107c6c: 8d 44 24 1c lea 0x1c(%esp),%eax
107c70: 89 44 24 04 mov %eax,0x4(%esp)
107c74: 8b 44 24 30 mov 0x30(%esp),%eax
107c78: 89 04 24 mov %eax,(%esp)
107c7b: e8 50 1c 00 00 call 1098d0 <_Thread_Get>
switch (location) {
107c80: 8b 54 24 1c mov 0x1c(%esp),%edx
107c84: 85 d2 test %edx,%edx
107c86: 75 30 jne 107cb8 <rtems_task_variable_delete+0x58>
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
107c88: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx
while (tvp) {
107c8e: 85 c9 test %ecx,%ecx
107c90: 74 17 je 107ca9 <rtems_task_variable_delete+0x49>
if (tvp->ptr == ptr) {
107c92: 39 59 04 cmp %ebx,0x4(%ecx)
107c95: 75 0c jne 107ca3 <rtems_task_variable_delete+0x43>
107c97: eb 50 jmp 107ce9 <rtems_task_variable_delete+0x89>
107c99: 8d 76 00 lea 0x0(%esi),%esi
107c9c: 39 5a 04 cmp %ebx,0x4(%edx)
107c9f: 74 2f je 107cd0 <rtems_task_variable_delete+0x70>
107ca1: 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;
107ca3: 8b 11 mov (%ecx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
107ca5: 85 d2 test %edx,%edx
107ca7: 75 f3 jne 107c9c <rtems_task_variable_delete+0x3c><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
107ca9: e8 02 1c 00 00 call 1098b0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
107cae: b8 09 00 00 00 mov $0x9,%eax
107cb3: eb 08 jmp 107cbd <rtems_task_variable_delete+0x5d>
107cb5: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
107cb8: b8 04 00 00 00 mov $0x4,%eax
}
107cbd: 83 c4 28 add $0x28,%esp
107cc0: 5b pop %ebx
107cc1: c3 ret
107cc2: 66 90 xchg %ax,%ax
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
107cc4: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
107cc9: 83 c4 28 add $0x28,%esp
107ccc: 5b pop %ebx
107ccd: c3 ret
107cce: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
107cd0: 8b 1a mov (%edx),%ebx
107cd2: 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 );
107cd4: 89 54 24 04 mov %edx,0x4(%esp)
107cd8: 89 04 24 mov %eax,(%esp)
107cdb: e8 98 00 00 00 call 107d78 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
107ce0: e8 cb 1b 00 00 call 1098b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
107ce5: 31 c0 xor %eax,%eax
107ce7: eb d4 jmp 107cbd <rtems_task_variable_delete+0x5d>
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
107ce9: 8b 11 mov (%ecx),%edx
107ceb: 89 90 ec 00 00 00 mov %edx,0xec(%eax)
107cf1: 89 ca mov %ecx,%edx
107cf3: eb df jmp 107cd4 <rtems_task_variable_delete+0x74>
00107cf8 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
107cf8: 53 push %ebx
107cf9: 83 ec 28 sub $0x28,%esp
107cfc: 8b 5c 24 34 mov 0x34(%esp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
107d00: 85 db test %ebx,%ebx
107d02: 74 50 je 107d54 <rtems_task_variable_get+0x5c>
return RTEMS_INVALID_ADDRESS;
if ( !result )
107d04: 8b 4c 24 38 mov 0x38(%esp),%ecx
107d08: 85 c9 test %ecx,%ecx
107d0a: 74 48 je 107d54 <rtems_task_variable_get+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
107d0c: 8d 44 24 1c lea 0x1c(%esp),%eax
107d10: 89 44 24 04 mov %eax,0x4(%esp)
107d14: 8b 44 24 30 mov 0x30(%esp),%eax
107d18: 89 04 24 mov %eax,(%esp)
107d1b: e8 b0 1b 00 00 call 1098d0 <_Thread_Get>
switch (location) {
107d20: 8b 54 24 1c mov 0x1c(%esp),%edx
107d24: 85 d2 test %edx,%edx
107d26: 75 38 jne 107d60 <rtems_task_variable_get+0x68>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
107d28: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
while (tvp) {
107d2e: 85 c0 test %eax,%eax
107d30: 75 08 jne 107d3a <rtems_task_variable_get+0x42>
107d32: eb 38 jmp 107d6c <rtems_task_variable_get+0x74>
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
107d34: 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) {
107d36: 85 c0 test %eax,%eax
107d38: 74 32 je 107d6c <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
107d3a: 39 58 04 cmp %ebx,0x4(%eax)
107d3d: 75 f5 jne 107d34 <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;
107d3f: 8b 40 0c mov 0xc(%eax),%eax
107d42: 8b 54 24 38 mov 0x38(%esp),%edx
107d46: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
107d48: e8 63 1b 00 00 call 1098b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
107d4d: 31 c0 xor %eax,%eax
107d4f: eb 08 jmp 107d59 <rtems_task_variable_get+0x61>
107d51: 8d 76 00 lea 0x0(%esi),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
107d54: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
107d59: 83 c4 28 add $0x28,%esp
107d5c: 5b pop %ebx
107d5d: c3 ret
107d5e: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
107d60: b8 04 00 00 00 mov $0x4,%eax
}
107d65: 83 c4 28 add $0x28,%esp
107d68: 5b pop %ebx
107d69: c3 ret
107d6a: 66 90 xchg %ax,%ax
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
107d6c: e8 3f 1b 00 00 call 1098b0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
107d71: b8 09 00 00 00 mov $0x9,%eax
107d76: eb e1 jmp 107d59 <rtems_task_variable_get+0x61>
0010a530 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
10a530: 8b 44 24 04 mov 0x4(%esp),%eax
int baud_index;
switch (termios_baud) {
10a534: 83 f8 09 cmp $0x9,%eax
10a537: 0f 84 03 01 00 00 je 10a640 <rtems_termios_baud_to_index+0x110>
10a53d: 76 35 jbe 10a574 <rtems_termios_baud_to_index+0x44>
10a53f: 83 f8 0e cmp $0xe,%eax
10a542: 0f 84 08 01 00 00 je 10a650 <rtems_termios_baud_to_index+0x120>
10a548: 76 52 jbe 10a59c <rtems_termios_baud_to_index+0x6c>
10a54a: 3d 02 10 00 00 cmp $0x1002,%eax
10a54f: 0f 84 db 00 00 00 je 10a630 <rtems_termios_baud_to_index+0x100>
10a555: 0f 86 8d 00 00 00 jbe 10a5e8 <rtems_termios_baud_to_index+0xb8>
10a55b: 3d 03 10 00 00 cmp $0x1003,%eax
10a560: 0f 84 d2 00 00 00 je 10a638 <rtems_termios_baud_to_index+0x108>
10a566: 3d 04 10 00 00 cmp $0x1004,%eax
10a56b: 75 60 jne 10a5cd <rtems_termios_baud_to_index+0x9d>
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
10a56d: b8 13 00 00 00 mov $0x13,%eax
10a572: c3 ret
10a573: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a574: 83 f8 04 cmp $0x4,%eax
10a577: 0f 84 cb 00 00 00 je 10a648 <rtems_termios_baud_to_index+0x118>
10a57d: 76 3d jbe 10a5bc <rtems_termios_baud_to_index+0x8c>
10a57f: 83 f8 06 cmp $0x6,%eax
10a582: 74 7c je 10a600 <rtems_termios_baud_to_index+0xd0>
10a584: 72 4e jb 10a5d4 <rtems_termios_baud_to_index+0xa4>
10a586: 83 f8 07 cmp $0x7,%eax
10a589: 0f 84 89 00 00 00 je 10a618 <rtems_termios_baud_to_index+0xe8>
10a58f: 83 f8 08 cmp $0x8,%eax
10a592: 75 39 jne 10a5cd <rtems_termios_baud_to_index+0x9d><== NEVER TAKEN
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
10a594: b8 08 00 00 00 mov $0x8,%eax
10a599: c3 ret
10a59a: 66 90 xchg %ax,%ax
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a59c: 83 f8 0b cmp $0xb,%eax
10a59f: 0f 84 83 00 00 00 je 10a628 <rtems_termios_baud_to_index+0xf8>
10a5a5: 72 39 jb 10a5e0 <rtems_termios_baud_to_index+0xb0>
10a5a7: 83 f8 0c cmp $0xc,%eax
10a5aa: 0f 84 a8 00 00 00 je 10a658 <rtems_termios_baud_to_index+0x128>
10a5b0: 83 f8 0d cmp $0xd,%eax
10a5b3: 75 18 jne 10a5cd <rtems_termios_baud_to_index+0x9d><== NEVER TAKEN
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
10a5b5: b8 0d 00 00 00 mov $0xd,%eax
10a5ba: c3 ret
10a5bb: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a5bc: 83 f8 01 cmp $0x1,%eax
10a5bf: 74 5f je 10a620 <rtems_termios_baud_to_index+0xf0>
10a5c1: 72 19 jb 10a5dc <rtems_termios_baud_to_index+0xac>
10a5c3: 83 f8 02 cmp $0x2,%eax
10a5c6: 74 48 je 10a610 <rtems_termios_baud_to_index+0xe0>
10a5c8: 83 f8 03 cmp $0x3,%eax
10a5cb: 74 2d je 10a5fa <rtems_termios_baud_to_index+0xca><== ALWAYS TAKEN
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
10a5cd: b8 ff ff ff ff mov $0xffffffff,%eax
10a5d2: c3 ret
10a5d3: 90 nop
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
10a5d4: b8 05 00 00 00 mov $0x5,%eax
10a5d9: c3 ret
10a5da: 66 90 xchg %ax,%ax
)
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
10a5dc: 31 c0 xor %eax,%eax
10a5de: c3 ret
10a5df: 90 nop
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
10a5e0: b8 0a 00 00 00 mov $0xa,%eax
10a5e5: c3 ret
10a5e6: 66 90 xchg %ax,%ax
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a5e8: 83 f8 0f cmp $0xf,%eax
10a5eb: 74 1b je 10a608 <rtems_termios_baud_to_index+0xd8>
10a5ed: 3d 01 10 00 00 cmp $0x1001,%eax
10a5f2: 75 d9 jne 10a5cd <rtems_termios_baud_to_index+0x9d><== NEVER TAKEN
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
10a5f4: b8 10 00 00 00 mov $0x10,%eax
10a5f9: c3 ret
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
10a5fa: b8 03 00 00 00 mov $0x3,%eax
10a5ff: c3 ret
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
10a600: b8 06 00 00 00 mov $0x6,%eax
10a605: c3 ret
10a606: 66 90 xchg %ax,%ax
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
10a608: b8 0f 00 00 00 mov $0xf,%eax
10a60d: c3 ret
10a60e: 66 90 xchg %ax,%ax
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
10a610: b8 02 00 00 00 mov $0x2,%eax
10a615: c3 ret
10a616: 66 90 xchg %ax,%ax
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
10a618: b8 07 00 00 00 mov $0x7,%eax
10a61d: c3 ret
10a61e: 66 90 xchg %ax,%ax
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
10a620: b8 01 00 00 00 mov $0x1,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a625: c3 ret
10a626: 66 90 xchg %ax,%ax
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
10a628: b8 0b 00 00 00 mov $0xb,%eax
10a62d: c3 ret
10a62e: 66 90 xchg %ax,%ax
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
10a630: b8 11 00 00 00 mov $0x11,%eax
10a635: c3 ret
10a636: 66 90 xchg %ax,%ax
case B230400: baud_index = 18; break;
10a638: b8 12 00 00 00 mov $0x12,%eax
10a63d: c3 ret
10a63e: 66 90 xchg %ax,%ax
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
10a640: b8 09 00 00 00 mov $0x9,%eax
10a645: c3 ret
10a646: 66 90 xchg %ax,%ax
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
10a648: b8 04 00 00 00 mov $0x4,%eax
10a64d: c3 ret
10a64e: 66 90 xchg %ax,%ax
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
10a650: b8 0e 00 00 00 mov $0xe,%eax
10a655: c3 ret
10a656: 66 90 xchg %ax,%ax
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
10a658: b8 0c 00 00 00 mov $0xc,%eax
10a65d: c3 ret
00109aa8 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
109aa8: 56 push %esi
109aa9: 53 push %ebx
109aaa: 83 ec 14 sub $0x14,%esp
109aad: 8b 74 24 20 mov 0x20(%esp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109ab1: 8b 06 mov (%esi),%eax
109ab3: 8b 58 2c mov 0x2c(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
109ab6: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
109abd: 00
109abe: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
109ac5: 00
109ac6: a1 2c f5 12 00 mov 0x12f52c,%eax
109acb: 89 04 24 mov %eax,(%esp)
109ace: e8 a9 1e 00 00 call 10b97c <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
109ad3: 85 c0 test %eax,%eax
109ad5: 0f 85 a1 01 00 00 jne 109c7c <rtems_termios_close+0x1d4><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
109adb: ff 4b 08 decl 0x8(%ebx)
109ade: 0f 85 c3 00 00 00 jne 109ba7 <rtems_termios_close+0xff>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
109ae4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109aea: c1 e0 05 shl $0x5,%eax
109aed: 8b 80 a4 f1 12 00 mov 0x12f1a4(%eax),%eax
109af3: 85 c0 test %eax,%eax
109af5: 0f 84 01 01 00 00 je 109bfc <rtems_termios_close+0x154>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
109afb: 89 1c 24 mov %ebx,(%esp)
109afe: ff d0 call *%eax
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109b00: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109b07: 0f 84 37 01 00 00 je 109c44 <rtems_termios_close+0x19c><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
109b0d: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
109b13: 85 c0 test %eax,%eax
109b15: 74 13 je 109b2a <rtems_termios_close+0x82>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
109b17: 89 74 24 08 mov %esi,0x8(%esp)
109b1b: 8b 53 10 mov 0x10(%ebx),%edx
109b1e: 89 54 24 04 mov %edx,0x4(%esp)
109b22: 8b 53 0c mov 0xc(%ebx),%edx
109b25: 89 14 24 mov %edx,(%esp)
109b28: ff d0 call *%eax
if (tty->forw == NULL) {
109b2a: 8b 03 mov (%ebx),%eax
rtems_termios_ttyTail = tty->back;
109b2c: 8b 53 04 mov 0x4(%ebx),%edx
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
109b2f: 85 c0 test %eax,%eax
109b31: 0f 84 a9 00 00 00 je 109be0 <rtems_termios_close+0x138>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
109b37: 89 50 04 mov %edx,0x4(%eax)
109b3a: 8b 53 04 mov 0x4(%ebx),%edx
}
if (tty->back == NULL) {
109b3d: 85 d2 test %edx,%edx
109b3f: 0f 84 87 00 00 00 je 109bcc <rtems_termios_close+0x124><== ALWAYS TAKEN
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
109b45: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
109b47: 8b 43 14 mov 0x14(%ebx),%eax
109b4a: 89 04 24 mov %eax,(%esp)
109b4d: e8 52 1d 00 00 call 10b8a4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
109b52: 8b 43 18 mov 0x18(%ebx),%eax
109b55: 89 04 24 mov %eax,(%esp)
109b58: e8 47 1d 00 00 call 10b8a4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
109b5d: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
109b63: 89 04 24 mov %eax,(%esp)
109b66: e8 39 1d 00 00 call 10b8a4 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
109b6b: 8b 8b a0 00 00 00 mov 0xa0(%ebx),%ecx
109b71: 85 c9 test %ecx,%ecx
109b73: 74 47 je 109bbc <rtems_termios_close+0x114>
109b75: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109b7c: 74 3e je 109bbc <rtems_termios_close+0x114>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
109b7e: 8b 43 58 mov 0x58(%ebx),%eax
109b81: 89 04 24 mov %eax,(%esp)
109b84: e8 b3 dd ff ff call 10793c <free>
free (tty->rawOutBuf.theBuf);
109b89: 8b 43 7c mov 0x7c(%ebx),%eax
109b8c: 89 04 24 mov %eax,(%esp)
109b8f: e8 a8 dd ff ff call 10793c <free>
free (tty->cbuf);
109b94: 8b 43 1c mov 0x1c(%ebx),%eax
109b97: 89 04 24 mov %eax,(%esp)
109b9a: e8 9d dd ff ff call 10793c <free>
free (tty);
109b9f: 89 1c 24 mov %ebx,(%esp)
109ba2: e8 95 dd ff ff call 10793c <free>
}
rtems_semaphore_release (rtems_termios_ttyMutex);
109ba7: a1 2c f5 12 00 mov 0x12f52c,%eax
109bac: 89 04 24 mov %eax,(%esp)
109baf: e8 f4 1e 00 00 call 10baa8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
109bb4: 31 c0 xor %eax,%eax
109bb6: 83 c4 14 add $0x14,%esp
109bb9: 5b pop %ebx
109bba: 5e pop %esi
109bbb: c3 ret
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
109bbc: 8b 43 68 mov 0x68(%ebx),%eax
109bbf: 89 04 24 mov %eax,(%esp)
109bc2: e8 dd 1c 00 00 call 10b8a4 <rtems_semaphore_delete>
109bc7: eb b5 jmp 109b7e <rtems_termios_close+0xd6>
109bc9: 8d 76 00 lea 0x0(%esi),%esi
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
109bcc: a3 34 f5 12 00 mov %eax,0x12f534
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
109bd1: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
109bd8: e9 6a ff ff ff jmp 109b47 <rtems_termios_close+0x9f>
109bdd: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
109be0: 89 15 30 f5 12 00 mov %edx,0x12f530
if ( rtems_termios_ttyTail != NULL ) {
109be6: 85 d2 test %edx,%edx
109be8: 0f 84 96 00 00 00 je 109c84 <rtems_termios_close+0x1dc><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
109bee: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
109bf4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
109bf6: e9 4a ff ff ff jmp 109b45 <rtems_termios_close+0x9d><== NOT EXECUTED
109bfb: 90 nop <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109bfc: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
109c03: 00
109c04: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
109c0b: 00
109c0c: 8b 43 18 mov 0x18(%ebx),%eax
109c0f: 89 04 24 mov %eax,(%esp)
109c12: e8 65 1d 00 00 call 10b97c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
109c17: 85 c0 test %eax,%eax
109c19: 75 61 jne 109c7c <rtems_termios_close+0x1d4><== NEVER TAKEN
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
109c1b: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax
109c21: 85 c0 test %eax,%eax
109c23: 74 07 je 109c2c <rtems_termios_close+0x184>
109c25: 89 d8 mov %ebx,%eax
109c27: e8 a0 f9 ff ff call 1095cc <drainOutput.part.0>
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
109c2c: 8b 43 18 mov 0x18(%ebx),%eax
109c2f: 89 04 24 mov %eax,(%esp)
109c32: e8 71 1e 00 00 call 10baa8 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109c37: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109c3e: 0f 85 c9 fe ff ff jne 109b0d <rtems_termios_close+0x65>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
109c44: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
109c4b: 00
109c4c: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax
109c52: 89 04 24 mov %eax,(%esp)
109c55: e8 96 18 00 00 call 10b4f0 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
109c5a: 85 c0 test %eax,%eax
109c5c: 75 1e jne 109c7c <rtems_termios_close+0x1d4><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
109c5e: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
109c65: 00
109c66: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax
109c6c: 89 04 24 mov %eax,(%esp)
109c6f: e8 7c 18 00 00 call 10b4f0 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
109c74: 85 c0 test %eax,%eax
109c76: 0f 84 91 fe ff ff je 109b0d <rtems_termios_close+0x65><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
109c7c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109c7f: e8 2c 24 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
109c84: c7 05 34 f5 12 00 00 movl $0x0,0x12f534
109c8b: 00 00 00
109c8e: e9 b4 fe ff ff jmp 109b47 <rtems_termios_close+0x9f>
0010ae78 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
10ae78: 83 ec 1c sub $0x1c,%esp
10ae7b: 8b 44 24 20 mov 0x20(%esp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
10ae7f: 8b 54 24 24 mov 0x24(%esp),%edx
10ae83: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10ae89: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
10ae90: 74 2a je 10aebc <rtems_termios_dequeue_characters+0x44>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
10ae92: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
10ae99: 74 09 je 10aea4 <rtems_termios_dequeue_characters+0x2c>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
10ae9b: 83 c4 1c add $0x1c,%esp
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
10ae9e: e9 6d e4 ff ff jmp 109310 <rtems_termios_refill_transmitter>
10aea3: 90 nop
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10aea4: 8b 15 54 f2 12 00 mov 0x12f254,%edx
10aeaa: 85 d2 test %edx,%edx
10aeac: 74 05 je 10aeb3 <rtems_termios_dequeue_characters+0x3b><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10aeae: 89 04 24 mov %eax,(%esp)
10aeb1: ff d2 call *%edx
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
10aeb3: 31 c0 xor %eax,%eax
10aeb5: 83 c4 1c add $0x1c,%esp
10aeb8: c3 ret
10aeb9: 8d 76 00 lea 0x0(%esi),%esi
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
10aebc: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
10aec3: 00
10aec4: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax
10aeca: 89 04 24 mov %eax,(%esp)
10aecd: e8 1e 06 00 00 call 10b4f0 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10aed2: 85 c0 test %eax,%eax
10aed4: 74 dd je 10aeb3 <rtems_termios_dequeue_characters+0x3b><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10aed6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10aed9: e8 d2 11 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
0010aafc <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
10aafc: 55 push %ebp
10aafd: 57 push %edi
10aafe: 56 push %esi
10aaff: 53 push %ebx
10ab00: 83 ec 3c sub $0x3c,%esp
10ab03: 8b 5c 24 50 mov 0x50(%esp),%ebx
10ab07: 8b 6c 24 54 mov 0x54(%esp),%ebp
10ab0b: 8b 7c 24 58 mov 0x58(%esp),%edi
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
10ab0f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10ab15: c1 e0 05 shl $0x5,%eax
10ab18: 8b 80 b0 f1 12 00 mov 0x12f1b0(%eax),%eax
10ab1e: 85 c0 test %eax,%eax
10ab20: 74 6a je 10ab8c <rtems_termios_enqueue_raw_characters+0x90>
while (len--) {
10ab22: 85 ff test %edi,%edi
10ab24: 74 28 je 10ab4e <rtems_termios_enqueue_raw_characters+0x52><== NEVER TAKEN
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
10ab26: 4f dec %edi
10ab27: 31 f6 xor %esi,%esi
10ab29: eb 11 jmp 10ab3c <rtems_termios_enqueue_raw_characters+0x40>
10ab2b: 90 nop
10ab2c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10ab32: c1 e0 05 shl $0x5,%eax
10ab35: 8b 80 b0 f1 12 00 mov 0x12f1b0(%eax),%eax
10ab3b: 46 inc %esi
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
10ab3c: 89 5c 24 04 mov %ebx,0x4(%esp)
10ab40: 0f be 54 35 00 movsbl 0x0(%ebp,%esi,1),%edx
10ab45: 89 14 24 mov %edx,(%esp)
10ab48: ff d0 call *%eax
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
10ab4a: 39 fe cmp %edi,%esi
10ab4c: 75 de jne 10ab2c <rtems_termios_enqueue_raw_characters+0x30>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
10ab4e: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
10ab54: 85 c0 test %eax,%eax
10ab56: 75 26 jne 10ab7e <rtems_termios_enqueue_raw_characters+0x82><== NEVER TAKEN
10ab58: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
10ab5e: 85 c0 test %eax,%eax
10ab60: 74 1c je 10ab7e <rtems_termios_enqueue_raw_characters+0x82>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10ab62: 8b 93 e0 00 00 00 mov 0xe0(%ebx),%edx
10ab68: 89 54 24 04 mov %edx,0x4(%esp)
10ab6c: 8d 53 30 lea 0x30(%ebx),%edx
10ab6f: 89 14 24 mov %edx,(%esp)
10ab72: ff d0 call *%eax
tty->tty_rcvwakeup = 1;
10ab74: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx)
10ab7b: 00 00 00
}
return 0;
10ab7e: 31 ff xor %edi,%edi
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
10ab80: 89 f8 mov %edi,%eax
10ab82: 83 c4 3c add $0x3c,%esp
10ab85: 5b pop %ebx
10ab86: 5e pop %esi
10ab87: 5f pop %edi
10ab88: 5d pop %ebp
10ab89: c3 ret
10ab8a: 66 90 xchg %ax,%ax
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
10ab8c: 01 ef add %ebp,%edi
10ab8e: 89 7c 24 1c mov %edi,0x1c(%esp)
10ab92: c6 44 24 23 00 movb $0x0,0x23(%esp)
10ab97: 31 ff xor %edi,%edi
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10ab99: 8d 43 30 lea 0x30(%ebx),%eax
10ab9c: 89 44 24 28 mov %eax,0x28(%esp)
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
10aba0: 8d 53 4a lea 0x4a(%ebx),%edx
10aba3: 89 54 24 2c mov %edx,0x2c(%esp)
10aba7: 89 7c 24 10 mov %edi,0x10(%esp)
10abab: 90 nop
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
10abac: 3b 6c 24 1c cmp 0x1c(%esp),%ebp
10abb0: 0f 84 06 01 00 00 je 10acbc <rtems_termios_enqueue_raw_characters+0x1c0>
c = *buf++;
10abb6: 8a 4d 00 mov 0x0(%ebp),%cl
10abb9: 45 inc %ebp
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
10abba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10abc0: f6 c4 02 test $0x2,%ah
10abc3: 74 1b je 10abe0 <rtems_termios_enqueue_raw_characters+0xe4>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
10abc5: 0f be c1 movsbl %cl,%eax
10abc8: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
10abcc: 39 d0 cmp %edx,%eax
if (c == tty->termios.c_cc[VSTART]) {
10abce: 0f b6 53 49 movzbl 0x49(%ebx),%edx
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
10abd2: 0f 84 00 01 00 00 je 10acd8 <rtems_termios_enqueue_raw_characters+0x1dc>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
10abd8: 39 d0 cmp %edx,%eax
10abda: 0f 84 58 01 00 00 je 10ad38 <rtems_termios_enqueue_raw_characters+0x23c><== NEVER TAKEN
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
10abe0: 80 7c 24 23 00 cmpb $0x0,0x23(%esp)
10abe5: 0f 85 09 01 00 00 jne 10acf4 <rtems_termios_enqueue_raw_characters+0x1f8><== NEVER TAKEN
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
10abeb: 8b 43 60 mov 0x60(%ebx),%eax
10abee: 8b 7b 64 mov 0x64(%ebx),%edi
10abf1: 40 inc %eax
10abf2: 31 d2 xor %edx,%edx
10abf4: f7 f7 div %edi
10abf6: 89 d6 mov %edx,%esi
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
10abf8: 9c pushf
10abf9: fa cli
10abfa: 8f 44 24 24 popl 0x24(%esp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10abfe: 8b 53 5c mov 0x5c(%ebx),%edx
10ac01: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
10ac04: 8b 7b 64 mov 0x64(%ebx),%edi
10ac07: 89 7c 24 18 mov %edi,0x18(%esp)
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10ac0b: 29 d0 sub %edx,%eax
10ac0d: 01 f0 add %esi,%eax
% tty->rawInBuf.Size) > tty->highwater) &&
10ac0f: 31 d2 xor %edx,%edx
10ac11: f7 f7 div %edi
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10ac13: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
10ac19: 76 45 jbe 10ac60 <rtems_termios_enqueue_raw_characters+0x164><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
10ac1b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
10ac21: a8 01 test $0x1,%al <== NOT EXECUTED
10ac23: 75 3b jne 10ac60 <rtems_termios_enqueue_raw_characters+0x164><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
10ac25: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10ac2b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
10ac2e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
10ac34: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10ac3a: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
10ac3f: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
10ac44: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
10ac4a: 0f 84 2a 01 00 00 je 10ad7a <rtems_termios_enqueue_raw_characters+0x27e><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
10ac50: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
10ac55: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
10ac5a: 0f 84 64 01 00 00 je 10adc4 <rtems_termios_enqueue_raw_characters+0x2c8><== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10ac60: ff 74 24 24 pushl 0x24(%esp)
10ac64: 9d popf
if (newTail == tty->rawInBuf.Head) {
10ac65: 8b 43 5c mov 0x5c(%ebx),%eax
10ac68: 39 f0 cmp %esi,%eax
10ac6a: 0f 84 bc 00 00 00 je 10ad2c <rtems_termios_enqueue_raw_characters+0x230><== NEVER TAKEN
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
10ac70: 8b 43 58 mov 0x58(%ebx),%eax
10ac73: 88 0c 30 mov %cl,(%eax,%esi,1)
tty->rawInBuf.Tail = newTail;
10ac76: 89 73 60 mov %esi,0x60(%ebx)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
10ac79: 8b 8b e4 00 00 00 mov 0xe4(%ebx),%ecx
10ac7f: 85 c9 test %ecx,%ecx
10ac81: 0f 85 25 ff ff ff jne 10abac <rtems_termios_enqueue_raw_characters+0xb0><== NEVER TAKEN
10ac87: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
10ac8d: 85 c0 test %eax,%eax
10ac8f: 0f 84 17 ff ff ff je 10abac <rtems_termios_enqueue_raw_characters+0xb0><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10ac95: 8b 93 e0 00 00 00 mov 0xe0(%ebx),%edx <== NOT EXECUTED
10ac9b: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10ac9f: 8b 7c 24 28 mov 0x28(%esp),%edi <== NOT EXECUTED
10aca3: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10aca6: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
10aca8: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10acaf: 00 00 00
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
10acb2: 3b 6c 24 1c cmp 0x1c(%esp),%ebp <== NOT EXECUTED
10acb6: 0f 85 fa fe ff ff jne 10abb6 <rtems_termios_enqueue_raw_characters+0xba><== NOT EXECUTED
10acbc: 8b 7c 24 10 mov 0x10(%esp),%edi
}
}
}
}
tty->rawInBufDropped += dropped;
10acc0: 01 7b 78 add %edi,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
10acc3: 8b 43 68 mov 0x68(%ebx),%eax
10acc6: 89 04 24 mov %eax,(%esp)
10acc9: e8 da 0d 00 00 call 10baa8 <rtems_semaphore_release>
return dropped;
}
10acce: 89 f8 mov %edi,%eax
10acd0: 83 c4 3c add $0x3c,%esp
10acd3: 5b pop %ebx
10acd4: 5e pop %esi
10acd5: 5f pop %edi
10acd6: 5d pop %ebp
10acd7: c3 ret
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
10acd8: 39 d0 cmp %edx,%eax
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
10acda: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
10ace0: 0f 84 86 00 00 00 je 10ad6c <rtems_termios_enqueue_raw_characters+0x270><== NEVER TAKEN
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
10ace6: 83 c8 10 or $0x10,%eax
10ace9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
10acef: c6 44 24 23 01 movb $0x1,0x23(%esp)
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
10acf4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10acfa: 83 e0 30 and $0x30,%eax
10acfd: 83 f8 20 cmp $0x20,%eax
10ad00: 0f 85 a6 fe ff ff jne 10abac <rtems_termios_enqueue_raw_characters+0xb0><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
10ad06: 9c pushf <== NOT EXECUTED
10ad07: fa cli <== NOT EXECUTED
10ad08: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
10ad09: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10ad0f: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
10ad12: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
10ad18: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED
10ad1e: 85 c0 test %eax,%eax <== NOT EXECUTED
10ad20: 75 27 jne 10ad49 <rtems_termios_enqueue_raw_characters+0x24d><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10ad22: 56 push %esi <== NOT EXECUTED
10ad23: 9d popf <== NOT EXECUTED
10ad24: e9 83 fe ff ff jmp 10abac <rtems_termios_enqueue_raw_characters+0xb0><== NOT EXECUTED
10ad29: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
dropped++;
10ad2c: ff 44 24 10 incl 0x10(%esp) <== NOT EXECUTED
10ad30: e9 77 fe ff ff jmp 10abac <rtems_termios_enqueue_raw_characters+0xb0><== NOT EXECUTED
10ad35: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
10ad38: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10ad3e: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
10ad41: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
10ad47: eb a6 jmp 10acef <rtems_termios_enqueue_raw_characters+0x1f3><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
10ad49: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
10ad4f: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED
10ad56: 00
10ad57: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
10ad5a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10ad5e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10ad61: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10ad64: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10ad6a: eb b6 jmp 10ad22 <rtems_termios_enqueue_raw_characters+0x226><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
10ad6c: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
10ad6f: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
10ad75: e9 75 ff ff ff jmp 10acef <rtems_termios_enqueue_raw_characters+0x1f3><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
10ad7a: a8 20 test $0x20,%al <== NOT EXECUTED
10ad7c: 75 0e jne 10ad8c <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
10ad7e: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED
10ad84: 85 ff test %edi,%edi <== NOT EXECUTED
10ad86: 0f 85 d4 fe ff ff jne 10ac60 <rtems_termios_enqueue_raw_characters+0x164><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
10ad8c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10ad92: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10ad95: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
10ad9b: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED
10ada2: 00
(void *)&(tty->termios.c_cc[VSTOP]), 1);
10ada3: 8b 7c 24 2c mov 0x2c(%esp),%edi <== NOT EXECUTED
10ada7: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
10adab: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10adae: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10adb1: 88 4c 24 14 mov %cl,0x14(%esp) <== NOT EXECUTED
10adb5: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10adbb: 8a 4c 24 14 mov 0x14(%esp),%cl <== NOT EXECUTED
10adbf: e9 9c fe ff ff jmp 10ac60 <rtems_termios_enqueue_raw_characters+0x164><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
10adc4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10adca: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
10adcd: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
10add3: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
10add9: 85 c0 test %eax,%eax <== NOT EXECUTED
10addb: 0f 84 7f fe ff ff je 10ac60 <rtems_termios_enqueue_raw_characters+0x164><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
10ade1: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED
10ade4: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10ade7: 88 4c 24 14 mov %cl,0x14(%esp) <== NOT EXECUTED
10adeb: ff d0 call *%eax <== NOT EXECUTED
10aded: 8a 4c 24 14 mov 0x14(%esp),%cl <== NOT EXECUTED
10adf1: e9 6a fe ff ff jmp 10ac60 <rtems_termios_enqueue_raw_characters+0x164><== NOT EXECUTED
00109cb4 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
109cb4: 55 push %ebp
109cb5: 57 push %edi
109cb6: 56 push %esi
109cb7: 53 push %ebx
109cb8: 83 ec 2c sub $0x2c,%esp
109cbb: 8b 74 24 40 mov 0x40(%esp),%esi
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109cbf: 8b 06 mov (%esi),%eax
109cc1: 8b 58 2c mov 0x2c(%eax),%ebx
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
109cc4: 8b 7e 08 mov 0x8(%esi),%edi
rtems_status_code sc;
args->ioctl_return = 0;
109cc7: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109cce: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
109cd5: 00
109cd6: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
109cdd: 00
109cde: 8b 43 18 mov 0x18(%ebx),%eax
109ce1: 89 04 24 mov %eax,(%esp)
109ce4: e8 93 1c 00 00 call 10b97c <rtems_semaphore_obtain>
109ce9: 89 c5 mov %eax,%ebp
if (sc != RTEMS_SUCCESSFUL) {
109ceb: 85 c0 test %eax,%eax
109ced: 75 4c jne 109d3b <rtems_termios_ioctl+0x87><== NEVER TAKEN
return sc;
}
switch (args->command) {
109cef: 8b 46 04 mov 0x4(%esi),%eax
109cf2: 83 f8 04 cmp $0x4,%eax
109cf5: 74 25 je 109d1c <rtems_termios_ioctl+0x68>
109cf7: 77 4f ja 109d48 <rtems_termios_ioctl+0x94>
109cf9: 83 f8 02 cmp $0x2,%eax
109cfc: 0f 84 86 00 00 00 je 109d88 <rtems_termios_ioctl+0xd4>
109d02: 0f 86 fc 01 00 00 jbe 109f04 <rtems_termios_ioctl+0x250>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
109d08: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax
109d0e: 85 c0 test %eax,%eax
109d10: 74 1e je 109d30 <rtems_termios_ioctl+0x7c>
109d12: 89 d8 mov %ebx,%eax
109d14: e8 b3 f8 ff ff call 1095cc <drainOutput.part.0>
109d19: eb 15 jmp 109d30 <rtems_termios_ioctl+0x7c>
109d1b: 90 nop
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
109d1c: 8b 07 mov (%edi),%eax
109d1e: 8b 57 04 mov 0x4(%edi),%edx
109d21: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx)
109d27: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx)
109d2d: 8d 76 00 lea 0x0(%esi),%esi
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
109d30: 8b 43 18 mov 0x18(%ebx),%eax
109d33: 89 04 24 mov %eax,(%esp)
109d36: e8 6d 1d 00 00 call 10baa8 <rtems_semaphore_release>
return sc;
}
109d3b: 89 e8 mov %ebp,%eax
109d3d: 83 c4 2c add $0x2c,%esp
109d40: 5b pop %ebx
109d41: 5e pop %esi
109d42: 5f pop %edi
109d43: 5d pop %ebp
109d44: c3 ret
109d45: 8d 76 00 lea 0x0(%esi),%esi
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
109d48: 3d 7f 66 04 40 cmp $0x4004667f,%eax
109d4d: 0f 84 91 01 00 00 je 109ee4 <rtems_termios_ioctl+0x230><== NEVER TAKEN
109d53: 0f 87 c7 01 00 00 ja 109f20 <rtems_termios_ioctl+0x26c>
109d59: 83 f8 05 cmp $0x5,%eax
109d5c: 0f 84 2e 02 00 00 je 109f90 <rtems_termios_ioctl+0x2dc>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
109d62: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109d68: c1 e0 05 shl $0x5,%eax
109d6b: 8b 80 b8 f1 12 00 mov 0x12f1b8(%eax),%eax
109d71: 85 c0 test %eax,%eax
109d73: 0f 84 2f 02 00 00 je 109fa8 <rtems_termios_ioctl+0x2f4><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
109d79: 89 74 24 04 mov %esi,0x4(%esp)
109d7d: 89 1c 24 mov %ebx,(%esp)
109d80: ff d0 call *%eax
109d82: 89 c5 mov %eax,%ebp
109d84: eb aa jmp 109d30 <rtems_termios_ioctl+0x7c>
109d86: 66 90 xchg %ax,%ax
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
109d88: 8b 76 08 mov 0x8(%esi),%esi
109d8b: 8d 43 30 lea 0x30(%ebx),%eax
109d8e: 89 44 24 1c mov %eax,0x1c(%esp)
109d92: b9 09 00 00 00 mov $0x9,%ecx
109d97: 89 c7 mov %eax,%edi
109d99: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
109d9b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109da1: f6 c4 02 test $0x2,%ah
109da4: 74 46 je 109dec <rtems_termios_ioctl+0x138>
109da6: f6 43 31 04 testb $0x4,0x31(%ebx)
109daa: 75 40 jne 109dec <rtems_termios_ioctl+0x138>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
109dac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109db2: 25 ef fd ff ff and $0xfffffdef,%eax
109db7: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
109dbd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109dc3: a8 20 test $0x20,%al
109dc5: 74 25 je 109dec <rtems_termios_ioctl+0x138><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
109dc7: 9c pushf <== NOT EXECUTED
109dc8: fa cli <== NOT EXECUTED
109dc9: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109dca: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109dd0: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
109dd3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
109dd9: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED
109ddf: 85 c0 test %eax,%eax <== NOT EXECUTED
109de1: 0f 85 3f 02 00 00 jne 10a026 <rtems_termios_ioctl+0x372><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109de7: 56 push %esi <== NOT EXECUTED
109de8: 9d popf <== NOT EXECUTED
109de9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
109dec: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109df2: f6 c4 04 test $0x4,%ah
109df5: 74 24 je 109e1b <rtems_termios_ioctl+0x167>
109df7: f6 43 31 10 testb $0x10,0x31(%ebx)
109dfb: 75 1e jne 109e1b <rtems_termios_ioctl+0x167><== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
109dfd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109e03: 80 e4 fb and $0xfb,%ah
109e06: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
109e0c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109e12: 83 e0 fd and $0xfffffffd,%eax
109e15: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
109e1b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109e21: f6 c4 01 test $0x1,%ah
109e24: 8b 43 38 mov 0x38(%ebx),%eax
109e27: 74 46 je 109e6f <rtems_termios_ioctl+0x1bb><== ALWAYS TAKEN
109e29: 85 c0 test %eax,%eax <== NOT EXECUTED
109e2b: 0f 88 cb 01 00 00 js 109ffc <rtems_termios_ioctl+0x348><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
109e31: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED
109e37: 80 e6 fe and $0xfe,%dh <== NOT EXECUTED
109e3a: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
109e40: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED
109e46: 83 e2 04 and $0x4,%edx <== NOT EXECUTED
109e49: 74 15 je 109e60 <rtems_termios_ioctl+0x1ac><== NOT EXECUTED
109e4b: 8b 93 b0 00 00 00 mov 0xb0(%ebx),%edx <== NOT EXECUTED
109e51: 85 d2 test %edx,%edx <== NOT EXECUTED
109e53: 74 0b je 109e60 <rtems_termios_ioctl+0x1ac><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
109e55: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
109e58: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109e5b: ff d2 call *%edx <== NOT EXECUTED
109e5d: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
109e60: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED
109e66: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED
109e69: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx) <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
109e6f: 85 c0 test %eax,%eax
109e71: 0f 88 85 01 00 00 js 109ffc <rtems_termios_ioctl+0x348><== NEVER TAKEN
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
109e77: 8b 43 30 mov 0x30(%ebx),%eax
109e7a: f6 c4 10 test $0x10,%ah
109e7d: 74 0f je 109e8e <rtems_termios_ioctl+0x1da>
tty->flow_ctrl |= FL_MDXOF;
109e7f: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx
109e85: 80 ce 04 or $0x4,%dh
109e88: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
109e8e: f6 c4 04 test $0x4,%ah
109e91: 74 0f je 109ea2 <rtems_termios_ioctl+0x1ee>
tty->flow_ctrl |= FL_MDXON;
109e93: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109e99: 80 cc 02 or $0x2,%ah
109e9c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
109ea2: f6 43 3c 02 testb $0x2,0x3c(%ebx)
109ea6: 0f 84 08 01 00 00 je 109fb4 <rtems_termios_ioctl+0x300>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
109eac: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
109eb3: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
109eba: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx)
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
109ec1: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
109ec7: 85 c0 test %eax,%eax
109ec9: 0f 84 61 fe ff ff je 109d30 <rtems_termios_ioctl+0x7c><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
109ecf: 8b 54 24 1c mov 0x1c(%esp),%edx
109ed3: 89 54 24 04 mov %edx,0x4(%esp)
109ed7: 8b 53 10 mov 0x10(%ebx),%edx
109eda: 89 14 24 mov %edx,(%esp)
109edd: ff d0 call *%eax
109edf: e9 4c fe ff ff jmp 109d30 <rtems_termios_ioctl+0x7c>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
109ee4: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
109ee7: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
109eea: 29 d0 sub %edx,%eax <== NOT EXECUTED
109eec: 0f 88 fe 00 00 00 js 109ff0 <rtems_termios_ioctl+0x33c><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
109ef2: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED
109ef5: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED
109ef8: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED
109efb: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
109efd: e9 2e fe ff ff jmp 109d30 <rtems_termios_ioctl+0x7c><== NOT EXECUTED
109f02: 66 90 xchg %ax,%ax <== NOT EXECUTED
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
109f04: 48 dec %eax
109f05: 0f 85 57 fe ff ff jne 109d62 <rtems_termios_ioctl+0xae><== NEVER TAKEN
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
109f0b: 8b 46 08 mov 0x8(%esi),%eax
109f0e: 8d 73 30 lea 0x30(%ebx),%esi
109f11: b9 09 00 00 00 mov $0x9,%ecx
109f16: 89 c7 mov %eax,%edi
109f18: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
109f1a: e9 11 fe ff ff jmp 109d30 <rtems_termios_ioctl+0x7c>
109f1f: 90 nop
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
109f20: 3d 1a 74 04 40 cmp $0x4004741a,%eax
109f25: 74 59 je 109f80 <rtems_termios_ioctl+0x2cc>
109f27: 3d 1b 74 04 80 cmp $0x8004741b,%eax
109f2c: 0f 85 30 fe ff ff jne 109d62 <rtems_termios_ioctl+0xae><== NEVER TAKEN
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
109f32: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109f38: c1 e0 05 shl $0x5,%eax
109f3b: 8b 80 a4 f1 12 00 mov 0x12f1a4(%eax),%eax
109f41: 85 c0 test %eax,%eax
109f43: 74 07 je 109f4c <rtems_termios_ioctl+0x298>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
109f45: 89 1c 24 mov %ebx,(%esp)
109f48: ff d0 call *%eax
109f4a: 89 c5 mov %eax,%ebp
}
tty->t_line=*(int*)(args->buffer);
109f4c: 8b 46 08 mov 0x8(%esi),%eax
109f4f: 8b 00 mov (%eax),%eax
109f51: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
tty->t_sc = NULL; /* ensure that no more valid data */
109f57: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
109f5e: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
109f61: c1 e0 05 shl $0x5,%eax
109f64: 8b 80 a0 f1 12 00 mov 0x12f1a0(%eax),%eax
109f6a: 85 c0 test %eax,%eax
109f6c: 0f 84 be fd ff ff je 109d30 <rtems_termios_ioctl+0x7c>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
109f72: 89 1c 24 mov %ebx,(%esp)
109f75: ff d0 call *%eax
109f77: 89 c5 mov %eax,%ebp
109f79: e9 b2 fd ff ff jmp 109d30 <rtems_termios_ioctl+0x7c>
109f7e: 66 90 xchg %ax,%ax
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
109f80: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx
109f86: 8b 46 08 mov 0x8(%esi),%eax
109f89: 89 10 mov %edx,(%eax)
break;
109f8b: e9 a0 fd ff ff jmp 109d30 <rtems_termios_ioctl+0x7c>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
109f90: 8b 07 mov (%edi),%eax
109f92: 8b 57 04 mov 0x4(%edi),%edx
109f95: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx)
109f9b: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx)
break;
109fa1: e9 8a fd ff ff jmp 109d30 <rtems_termios_ioctl+0x7c>
109fa6: 66 90 xchg %ax,%ax
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
109fa8: bd 0a 00 00 00 mov $0xa,%ebp <== NOT EXECUTED
109fad: e9 7e fd ff ff jmp 109d30 <rtems_termios_ioctl+0x7c><== NOT EXECUTED
109fb2: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
109fb4: 0f b6 73 46 movzbl 0x46(%ebx),%esi
rtems_clock_get_ticks_per_second() / 10;
109fb8: e8 13 13 00 00 call 10b2d0 <rtems_clock_get_ticks_per_second>
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
109fbd: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
109fc0: ba cd cc cc cc mov $0xcccccccd,%edx
109fc5: f7 e2 mul %edx
109fc7: c1 ea 03 shr $0x3,%edx
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
109fca: 89 53 54 mov %edx,0x54(%ebx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
109fcd: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109fd1: 74 3d je 10a010 <rtems_termios_ioctl+0x35c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
109fd3: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
109fda: 89 53 70 mov %edx,0x70(%ebx)
if (tty->termios.c_cc[VMIN])
109fdd: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
109fe1: 0f 85 d3 fe ff ff jne 109eba <rtems_termios_ioctl+0x206>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
109fe7: 89 53 74 mov %edx,0x74(%ebx)
109fea: e9 d2 fe ff ff jmp 109ec1 <rtems_termios_ioctl+0x20d>
109fef: 90 nop
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
109ff0: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
109ff3: 01 d0 add %edx,%eax <== NOT EXECUTED
109ff5: e9 f8 fe ff ff jmp 109ef2 <rtems_termios_ioctl+0x23e><== NOT EXECUTED
109ffa: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
109ffc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a002: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
10a005: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
10a00b: e9 67 fe ff ff jmp 109e77 <rtems_termios_ioctl+0x1c3><== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
10a010: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10a014: 0f 85 92 fe ff ff jne 109eac <rtems_termios_ioctl+0x1f8><== NEVER TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
10a01a: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx)
10a021: e9 9b fe ff ff jmp 109ec1 <rtems_termios_ioctl+0x20d>
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
10a026: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
10a02c: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED
10a033: 00
10a034: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
10a037: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10a03b: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10a03e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a041: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10a047: e9 9b fd ff ff jmp 109de7 <rtems_termios_ioctl+0x133><== NOT EXECUTED
00109624 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
109624: 55 push %ebp
109625: 57 push %edi
109626: 56 push %esi
109627: 53 push %ebx
109628: 83 ec 3c sub $0x3c,%esp
10962b: 8b 6c 24 50 mov 0x50(%esp),%ebp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
10962f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
109636: 00
109637: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10963e: 00
10963f: a1 2c f5 12 00 mov 0x12f52c,%eax
109644: 89 04 24 mov %eax,(%esp)
109647: e8 30 23 00 00 call 10b97c <rtems_semaphore_obtain>
10964c: 89 44 24 2c mov %eax,0x2c(%esp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
109650: 85 c0 test %eax,%eax
109652: 75 73 jne 1096c7 <rtems_termios_open+0xa3><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
109654: 8b 3d 34 f5 12 00 mov 0x12f534,%edi
10965a: 85 ff test %edi,%edi
10965c: 74 76 je 1096d4 <rtems_termios_open+0xb0>
10965e: 89 fb mov %edi,%ebx
109660: 8b 44 24 54 mov 0x54(%esp),%eax
109664: eb 08 jmp 10966e <rtems_termios_open+0x4a>
109666: 66 90 xchg %ax,%ax
109668: 8b 1b mov (%ebx),%ebx
10966a: 85 db test %ebx,%ebx
10966c: 74 66 je 1096d4 <rtems_termios_open+0xb0><== ALWAYS TAKEN
if ((tty->major == major) && (tty->minor == minor))
10966e: 39 6b 0c cmp %ebp,0xc(%ebx)
109671: 75 f5 jne 109668 <rtems_termios_open+0x44>
109673: 39 43 10 cmp %eax,0x10(%ebx)
109676: 75 f0 jne 109668 <rtems_termios_open+0x44>
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
109678: 8b 54 24 58 mov 0x58(%esp),%edx
10967c: 8b 02 mov (%edx),%eax
10967e: 89 58 2c mov %ebx,0x2c(%eax)
if (!tty->refcount++) {
109681: 8b 43 08 mov 0x8(%ebx),%eax
109684: 8d 50 01 lea 0x1(%eax),%edx
109687: 89 53 08 mov %edx,0x8(%ebx)
10968a: 85 c0 test %eax,%eax
10968c: 75 2c jne 1096ba <rtems_termios_open+0x96>
if (tty->device.firstOpen)
10968e: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax
109694: 85 c0 test %eax,%eax
109696: 74 15 je 1096ad <rtems_termios_open+0x89>
(*tty->device.firstOpen)(major, minor, arg);
109698: 8b 54 24 58 mov 0x58(%esp),%edx
10969c: 89 54 24 08 mov %edx,0x8(%esp)
1096a0: 8b 54 24 54 mov 0x54(%esp),%edx
1096a4: 89 54 24 04 mov %edx,0x4(%esp)
1096a8: 89 2c 24 mov %ebp,(%esp)
1096ab: ff d0 call *%eax
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1096ad: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1096b4: 0f 84 85 02 00 00 je 10993f <rtems_termios_open+0x31b>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
1096ba: a1 2c f5 12 00 mov 0x12f52c,%eax
1096bf: 89 04 24 mov %eax,(%esp)
1096c2: e8 e1 23 00 00 call 10baa8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
1096c7: 8b 44 24 2c mov 0x2c(%esp),%eax
1096cb: 83 c4 3c add $0x3c,%esp
1096ce: 5b pop %ebx
1096cf: 5e pop %esi
1096d0: 5f pop %edi
1096d1: 5d pop %ebp
1096d2: c3 ret
1096d3: 90 nop
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
1096d4: c7 44 24 04 e8 00 00 movl $0xe8,0x4(%esp)
1096db: 00
1096dc: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1096e3: e8 00 e0 ff ff call 1076e8 <calloc>
1096e8: 89 c3 mov %eax,%ebx
if (tty == NULL) {
1096ea: 85 c0 test %eax,%eax
1096ec: 0f 84 ae 02 00 00 je 1099a0 <rtems_termios_open+0x37c>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
1096f2: a1 34 d2 12 00 mov 0x12d234,%eax
1096f7: 89 43 64 mov %eax,0x64(%ebx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
1096fa: 8b 43 64 mov 0x64(%ebx),%eax
1096fd: 89 04 24 mov %eax,(%esp)
109700: e8 4b e5 ff ff call 107c50 <malloc>
109705: 89 c6 mov %eax,%esi
109707: 89 43 58 mov %eax,0x58(%ebx)
if (tty->rawInBuf.theBuf == NULL) {
10970a: 85 c0 test %eax,%eax
10970c: 0f 84 86 02 00 00 je 109998 <rtems_termios_open+0x374>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
109712: a1 38 d2 12 00 mov 0x12d238,%eax
109717: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
10971d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
109723: 89 04 24 mov %eax,(%esp)
109726: e8 25 e5 ff ff call 107c50 <malloc>
10972b: 89 c2 mov %eax,%edx
10972d: 89 43 7c mov %eax,0x7c(%ebx)
if (tty->rawOutBuf.theBuf == NULL) {
109730: 85 c0 test %eax,%eax
109732: 0f 84 58 02 00 00 je 109990 <rtems_termios_open+0x36c>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
109738: a1 3c d2 12 00 mov 0x12d23c,%eax
10973d: 89 04 24 mov %eax,(%esp)
109740: 89 54 24 28 mov %edx,0x28(%esp)
109744: e8 07 e5 ff ff call 107c50 <malloc>
109749: 89 43 1c mov %eax,0x1c(%ebx)
if (tty->cbuf == NULL) {
10974c: 85 c0 test %eax,%eax
10974e: 8b 54 24 28 mov 0x28(%esp),%edx
109752: 0f 84 30 02 00 00 je 109988 <rtems_termios_open+0x364>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
109758: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx)
10975f: 00 00 00
tty->tty_snd.sw_arg = NULL;
109762: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx)
109769: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
10976c: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
109773: 00 00 00
tty->tty_rcv.sw_arg = NULL;
109776: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
10977d: 00 00 00
tty->tty_rcvwakeup = 0;
109780: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
109787: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
10978a: 89 3b mov %edi,(%ebx)
tty->back = NULL;
10978c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
if (rtems_termios_ttyHead != NULL)
109793: 85 ff test %edi,%edi
109795: 74 03 je 10979a <rtems_termios_open+0x176>
rtems_termios_ttyHead->back = tty;
109797: 89 5f 04 mov %ebx,0x4(%edi)
rtems_termios_ttyHead = tty;
10979a: 89 1d 34 f5 12 00 mov %ebx,0x12f534
if (rtems_termios_ttyTail == NULL)
1097a0: 8b 15 30 f5 12 00 mov 0x12f530,%edx
1097a6: 85 d2 test %edx,%edx
1097a8: 0f 84 ee 02 00 00 je 109a9c <rtems_termios_open+0x478>
rtems_termios_ttyTail = tty;
tty->minor = minor;
1097ae: 8b 54 24 54 mov 0x54(%esp),%edx
1097b2: 89 53 10 mov %edx,0x10(%ebx)
tty->major = major;
1097b5: 89 6b 0c mov %ebp,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1097b8: 8d 43 14 lea 0x14(%ebx),%eax
1097bb: 89 44 24 10 mov %eax,0x10(%esp)
1097bf: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
1097c6: 00
1097c7: c7 44 24 08 54 00 00 movl $0x54,0x8(%esp)
1097ce: 00
1097cf: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
1097d6: 00
rtems_build_name ('T', 'R', 'i', c),
1097d7: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1097de: 0d 00 69 52 54 or $0x54526900,%eax
1097e3: 89 04 24 mov %eax,(%esp)
1097e6: e8 dd 1e 00 00 call 10b6c8 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
1097eb: 85 c0 test %eax,%eax
1097ed: 0f 85 0e 02 00 00 jne 109a01 <rtems_termios_open+0x3dd>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1097f3: 8d 43 18 lea 0x18(%ebx),%eax
1097f6: 89 44 24 10 mov %eax,0x10(%esp)
1097fa: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
109801: 00
109802: c7 44 24 08 54 00 00 movl $0x54,0x8(%esp)
109809: 00
10980a: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
109811: 00
rtems_build_name ('T', 'R', 'o', c),
109812: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
109819: 0d 00 6f 52 54 or $0x54526f00,%eax
10981e: 89 04 24 mov %eax,(%esp)
109821: e8 a2 1e 00 00 call 10b6c8 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
109826: 85 c0 test %eax,%eax
109828: 0f 85 d3 01 00 00 jne 109a01 <rtems_termios_open+0x3dd>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
10982e: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
109834: 89 44 24 10 mov %eax,0x10(%esp)
109838: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
10983f: 00
109840: c7 44 24 08 20 00 00 movl $0x20,0x8(%esp)
109847: 00
109848: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10984f: 00
rtems_build_name ('T', 'R', 'x', c),
109850: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
109857: 0d 00 78 52 54 or $0x54527800,%eax
10985c: 89 04 24 mov %eax,(%esp)
10985f: e8 64 1e 00 00 call 10b6c8 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
109864: 85 c0 test %eax,%eax
109866: 0f 85 95 01 00 00 jne 109a01 <rtems_termios_open+0x3dd>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
10986c: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
109873: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
109876: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
10987c: b9 08 00 00 00 mov $0x8,%ecx
109881: 8b 74 24 5c mov 0x5c(%esp),%esi
109885: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109887: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
10988e: 0f 84 78 01 00 00 je 109a0c <rtems_termios_open+0x3e8>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
109894: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
10989a: 85 c0 test %eax,%eax
10989c: 0f 84 24 01 00 00 je 1099c6 <rtems_termios_open+0x3a2>
1098a2: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1098a9: 0f 84 17 01 00 00 je 1099c6 <rtems_termios_open+0x3a2>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
1098af: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
1098b6: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
1098bd: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag =
1098c4: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
1098cb: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
1098cf: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
1098d3: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
1098d7: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
1098db: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
1098df: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
1098e3: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
1098e7: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
1098eb: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
1098ef: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
1098f3: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
1098f7: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
1098fb: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
1098ff: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
109903: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
10990a: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
10990d: 8b 43 64 mov 0x64(%ebx),%eax
109910: d1 e8 shr %eax
109912: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
109918: 8b 43 64 mov 0x64(%ebx),%eax
10991b: 8d 04 40 lea (%eax,%eax,2),%eax
10991e: c1 e8 02 shr $0x2,%eax
109921: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
109927: a0 40 d2 12 00 mov 0x12d240,%al
10992c: 3c 7a cmp $0x7a,%al
10992e: 0f 84 86 00 00 00 je 1099ba <rtems_termios_open+0x396>
109934: 40 inc %eax
109935: a2 40 d2 12 00 mov %al,0x12d240
10993a: e9 39 fd ff ff jmp 109678 <rtems_termios_open+0x54>
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
10993f: 89 5c 24 08 mov %ebx,0x8(%esp)
109943: c7 44 24 04 f8 ad 10 movl $0x10adf8,0x4(%esp)
10994a: 00
10994b: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax
109951: 89 04 24 mov %eax,(%esp)
109954: e8 df 24 00 00 call 10be38 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
109959: 85 c0 test %eax,%eax
10995b: 0f 85 a0 00 00 00 jne 109a01 <rtems_termios_open+0x3dd><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
109961: 89 5c 24 08 mov %ebx,0x8(%esp)
109965: c7 44 24 04 5c 95 10 movl $0x10955c,0x4(%esp)
10996c: 00
10996d: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax
109973: 89 04 24 mov %eax,(%esp)
109976: e8 bd 24 00 00 call 10be38 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10997b: 85 c0 test %eax,%eax
10997d: 0f 84 37 fd ff ff je 1096ba <rtems_termios_open+0x96><== ALWAYS TAKEN
109983: eb 7c jmp 109a01 <rtems_termios_open+0x3dd><== NOT EXECUTED
109985: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
109988: 89 14 24 mov %edx,(%esp)
10998b: e8 ac df ff ff call 10793c <free>
free((void *)(tty->rawInBuf.theBuf));
109990: 89 34 24 mov %esi,(%esp)
109993: e8 a4 df ff ff call 10793c <free>
free(tty);
109998: 89 1c 24 mov %ebx,(%esp)
10999b: e8 9c df ff ff call 10793c <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
1099a0: a1 2c f5 12 00 mov 0x12f52c,%eax
1099a5: 89 04 24 mov %eax,(%esp)
1099a8: e8 fb 20 00 00 call 10baa8 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
1099ad: c7 44 24 2c 1a 00 00 movl $0x1a,0x2c(%esp)
1099b4: 00
1099b5: e9 0d fd ff ff jmp 1096c7 <rtems_termios_open+0xa3>
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
1099ba: c6 05 40 d2 12 00 61 movb $0x61,0x12d240
1099c1: e9 b2 fc ff ff jmp 109678 <rtems_termios_open+0x54>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
1099c6: 8d 43 68 lea 0x68(%ebx),%eax
1099c9: 89 44 24 10 mov %eax,0x10(%esp)
1099cd: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
1099d4: 00
1099d5: c7 44 24 08 24 00 00 movl $0x24,0x8(%esp)
1099dc: 00
1099dd: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
1099e4: 00
rtems_build_name ('T', 'R', 'r', c),
1099e5: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
1099ec: 0d 00 72 52 54 or $0x54527200,%eax
1099f1: 89 04 24 mov %eax,(%esp)
1099f4: e8 cf 1c 00 00 call 10b6c8 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
1099f9: 85 c0 test %eax,%eax
1099fb: 0f 84 ae fe ff ff je 1098af <rtems_termios_open+0x28b>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
109a01: 89 04 24 mov %eax,(%esp)
109a04: e8 a7 26 00 00 call 10c0b0 <rtems_fatal_error_occurred>
109a09: 8d 76 00 lea 0x0(%esi),%esi
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
109a0c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
109a12: 89 44 24 14 mov %eax,0x14(%esp)
109a16: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp)
109a1d: 00
109a1e: c7 44 24 0c 00 05 00 movl $0x500,0xc(%esp)
109a25: 00
109a26: c7 44 24 08 00 04 00 movl $0x400,0x8(%esp)
109a2d: 00
109a2e: c7 44 24 04 0a 00 00 movl $0xa,0x4(%esp)
109a35: 00
rtems_build_name ('T', 'x', 'T', c),
109a36: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
109a3d: 0d 00 54 78 54 or $0x54785400,%eax
109a42: 89 04 24 mov %eax,(%esp)
109a45: e8 fe 20 00 00 call 10bb48 <rtems_task_create>
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
109a4a: 85 c0 test %eax,%eax
109a4c: 75 b3 jne 109a01 <rtems_termios_open+0x3dd><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
109a4e: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax
109a54: 89 44 24 14 mov %eax,0x14(%esp)
109a58: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp)
109a5f: 00
109a60: c7 44 24 0c 00 05 00 movl $0x500,0xc(%esp)
109a67: 00
109a68: c7 44 24 08 00 04 00 movl $0x400,0x8(%esp)
109a6f: 00
109a70: c7 44 24 04 09 00 00 movl $0x9,0x4(%esp)
109a77: 00
rtems_build_name ('R', 'x', 'T', c),
109a78: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
109a7f: 0d 00 54 78 52 or $0x52785400,%eax
109a84: 89 04 24 mov %eax,(%esp)
109a87: e8 bc 20 00 00 call 10bb48 <rtems_task_create>
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
109a8c: 85 c0 test %eax,%eax
109a8e: 0f 84 00 fe ff ff je 109894 <rtems_termios_open+0x270><== ALWAYS TAKEN
109a94: e9 68 ff ff ff jmp 109a01 <rtems_termios_open+0x3dd><== NOT EXECUTED
109a99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
109a9c: 89 1d 30 f5 12 00 mov %ebx,0x12f530
109aa2: e9 07 fd ff ff jmp 1097ae <rtems_termios_open+0x18a>
0010a04c <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
10a04c: 55 push %ebp
10a04d: 57 push %edi
10a04e: 56 push %esi
10a04f: 53 push %ebx
10a050: 83 ec 2c sub $0x2c,%esp
10a053: 8b 74 24 40 mov 0x40(%esp),%esi
10a057: 8b 4c 24 44 mov 0x44(%esp),%ecx
10a05b: 89 4c 24 18 mov %ecx,0x18(%esp)
10a05f: 8b 6c 24 48 mov 0x48(%esp),%ebp
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
10a063: 8b 85 b4 00 00 00 mov 0xb4(%ebp),%eax
10a069: 85 c0 test %eax,%eax
10a06b: 0f 84 f7 00 00 00 je 10a168 <rtems_termios_puts+0x11c>
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
10a071: 8b bd 80 00 00 00 mov 0x80(%ebp),%edi
while (len) {
10a077: 8b 44 24 18 mov 0x18(%esp),%eax
10a07b: 85 c0 test %eax,%eax
10a07d: 0f 84 b2 00 00 00 je 10a135 <rtems_termios_puts+0xe9><== NEVER TAKEN
10a083: 90 nop
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
10a084: 8d 47 01 lea 0x1(%edi),%eax
10a087: 8b 8d 88 00 00 00 mov 0x88(%ebp),%ecx
10a08d: 31 d2 xor %edx,%edx
10a08f: f7 f1 div %ecx
10a091: 89 54 24 1c mov %edx,0x1c(%esp)
10a095: 89 d7 mov %edx,%edi
rtems_interrupt_disable (level);
10a097: 9c pushf
10a098: fa cli
10a099: 5a pop %edx
while (newHead == tty->rawOutBuf.Tail) {
10a09a: 8b 9d 84 00 00 00 mov 0x84(%ebp),%ebx
10a0a0: 39 fb cmp %edi,%ebx
10a0a2: 75 3f jne 10a0e3 <rtems_termios_puts+0x97>
tty->rawOutBufState = rob_wait;
10a0a4: c7 85 94 00 00 00 02 movl $0x2,0x94(%ebp)
10a0ab: 00 00 00
rtems_interrupt_enable (level);
10a0ae: 52 push %edx
10a0af: 9d popf
sc = rtems_semaphore_obtain(
10a0b0: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10a0b7: 00
10a0b8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10a0bf: 00
10a0c0: 8b 85 8c 00 00 00 mov 0x8c(%ebp),%eax
10a0c6: 89 04 24 mov %eax,(%esp)
10a0c9: e8 ae 18 00 00 call 10b97c <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
10a0ce: 85 c0 test %eax,%eax
10a0d0: 0f 85 b0 00 00 00 jne 10a186 <rtems_termios_puts+0x13a><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
10a0d6: 9c pushf
10a0d7: fa cli
10a0d8: 5a pop %edx
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
10a0d9: 8b 85 84 00 00 00 mov 0x84(%ebp),%eax
10a0df: 39 d8 cmp %ebx,%eax
10a0e1: 74 c1 je 10a0a4 <rtems_termios_puts+0x58><== NEVER TAKEN
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
10a0e3: 8b 85 80 00 00 00 mov 0x80(%ebp),%eax
10a0e9: 8b 5d 7c mov 0x7c(%ebp),%ebx
10a0ec: 8a 0e mov (%esi),%cl
10a0ee: 88 0c 03 mov %cl,(%ebx,%eax,1)
10a0f1: 46 inc %esi
tty->rawOutBuf.Head = newHead;
10a0f2: 8b 44 24 1c mov 0x1c(%esp),%eax
10a0f6: 89 85 80 00 00 00 mov %eax,0x80(%ebp)
if (tty->rawOutBufState == rob_idle) {
10a0fc: 8b 85 94 00 00 00 mov 0x94(%ebp),%eax
10a102: 85 c0 test %eax,%eax
10a104: 75 23 jne 10a129 <rtems_termios_puts+0xdd>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
10a106: 8b 85 b8 00 00 00 mov 0xb8(%ebp),%eax
10a10c: a8 10 test $0x10,%al
10a10e: 74 2d je 10a13d <rtems_termios_puts+0xf1><== ALWAYS TAKEN
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
10a110: 8b 85 b8 00 00 00 mov 0xb8(%ebp),%eax <== NOT EXECUTED
10a116: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10a119: 89 85 b8 00 00 00 mov %eax,0xb8(%ebp) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
10a11f: c7 85 94 00 00 00 01 movl $0x1,0x94(%ebp)
10a126: 00 00 00
}
rtems_interrupt_enable (level);
10a129: 52 push %edx
10a12a: 9d popf
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
10a12b: ff 4c 24 18 decl 0x18(%esp)
10a12f: 0f 85 4f ff ff ff jne 10a084 <rtems_termios_puts+0x38>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
10a135: 83 c4 2c add $0x2c,%esp
10a138: 5b pop %ebx
10a139: 5e pop %esi
10a13a: 5f pop %edi
10a13b: 5d pop %ebp
10a13c: c3 ret
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
10a13d: 8b 85 84 00 00 00 mov 0x84(%ebp),%eax
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
10a143: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10a14a: 00
10a14b: 03 45 7c add 0x7c(%ebp),%eax
10a14e: 89 44 24 04 mov %eax,0x4(%esp)
10a152: 8b 45 10 mov 0x10(%ebp),%eax
10a155: 89 04 24 mov %eax,(%esp)
10a158: 89 54 24 14 mov %edx,0x14(%esp)
10a15c: ff 95 a4 00 00 00 call *0xa4(%ebp)
10a162: 8b 54 24 14 mov 0x14(%esp),%edx
10a166: eb b7 jmp 10a11f <rtems_termios_puts+0xd3>
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
10a168: 89 4c 24 48 mov %ecx,0x48(%esp)
10a16c: 89 74 24 44 mov %esi,0x44(%esp)
10a170: 8b 45 10 mov 0x10(%ebp),%eax
10a173: 89 44 24 40 mov %eax,0x40(%esp)
10a177: 8b 85 a4 00 00 00 mov 0xa4(%ebp),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
10a17d: 83 c4 2c add $0x2c,%esp
10a180: 5b pop %ebx
10a181: 5e pop %esi
10a182: 5f pop %edi
10a183: 5d pop %ebp
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
10a184: ff e0 jmp *%eax
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
10a186: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a189: e8 22 1f 00 00 call 10c0b0 <rtems_fatal_error_occurred><== NOT EXECUTED
0010a774 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
10a774: 55 push %ebp
10a775: 57 push %edi
10a776: 56 push %esi
10a777: 53 push %ebx
10a778: 83 ec 3c sub $0x3c,%esp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10a77b: 8b 4c 24 50 mov 0x50(%esp),%ecx
10a77f: 8b 01 mov (%ecx),%eax
10a781: 8b 58 2c mov 0x2c(%eax),%ebx
uint32_t count = args->count;
10a784: 8b 49 10 mov 0x10(%ecx),%ecx
10a787: 89 4c 24 24 mov %ecx,0x24(%esp)
char *buffer = args->buffer;
10a78b: 8b 4c 24 50 mov 0x50(%esp),%ecx
10a78f: 8b 49 0c mov 0xc(%ecx),%ecx
10a792: 89 4c 24 28 mov %ecx,0x28(%esp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10a796: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10a79d: 00
10a79e: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10a7a5: 00
10a7a6: 8b 43 14 mov 0x14(%ebx),%eax
10a7a9: 89 04 24 mov %eax,(%esp)
10a7ac: e8 cb 11 00 00 call 10b97c <rtems_semaphore_obtain>
10a7b1: 89 44 24 20 mov %eax,0x20(%esp)
if (sc != RTEMS_SUCCESSFUL)
10a7b5: 85 c0 test %eax,%eax
10a7b7: 75 39 jne 10a7f2 <rtems_termios_read+0x7e><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
10a7b9: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10a7bf: c1 e0 05 shl $0x5,%eax
10a7c2: 8b 80 a8 f1 12 00 mov 0x12f1a8(%eax),%eax
10a7c8: 85 c0 test %eax,%eax
10a7ca: 74 34 je 10a800 <rtems_termios_read+0x8c>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
10a7cc: 8b 4c 24 50 mov 0x50(%esp),%ecx
10a7d0: 89 4c 24 04 mov %ecx,0x4(%esp)
10a7d4: 89 1c 24 mov %ebx,(%esp)
10a7d7: ff d0 call *%eax
10a7d9: 89 44 24 20 mov %eax,0x20(%esp)
tty->tty_rcvwakeup = 0;
10a7dd: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10a7e4: 00 00 00
rtems_semaphore_release (tty->isem);
10a7e7: 8b 43 14 mov 0x14(%ebx),%eax
10a7ea: 89 04 24 mov %eax,(%esp)
10a7ed: e8 b6 12 00 00 call 10baa8 <rtems_semaphore_release>
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
10a7f2: 8b 44 24 20 mov 0x20(%esp),%eax
10a7f6: 83 c4 3c add $0x3c,%esp
10a7f9: 5b pop %ebx
10a7fa: 5e pop %esi
10a7fb: 5f pop %edi
10a7fc: 5d pop %ebp
10a7fd: c3 ret
10a7fe: 66 90 xchg %ax,%ax
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
10a800: 8b 43 20 mov 0x20(%ebx),%eax
10a803: 39 43 24 cmp %eax,0x24(%ebx)
10a806: 74 70 je 10a878 <rtems_termios_read+0x104><== ALWAYS TAKEN
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
10a808: 8b 74 24 24 mov 0x24(%esp),%esi
10a80c: 85 f6 test %esi,%esi
10a80e: 74 31 je 10a841 <rtems_termios_read+0xcd><== NEVER TAKEN
10a810: 8b 43 24 mov 0x24(%ebx),%eax
10a813: 3b 43 20 cmp 0x20(%ebx),%eax
10a816: 7d 31 jge 10a849 <rtems_termios_read+0xd5>
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
10a818: 8b 4c 24 28 mov 0x28(%esp),%ecx
10a81c: 29 c1 sub %eax,%ecx
10a81e: 8b 54 24 24 mov 0x24(%esp),%edx
10a822: 89 cf mov %ecx,%edi
10a824: eb 0b jmp 10a831 <rtems_termios_read+0xbd>
10a826: 66 90 xchg %ax,%ax
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
10a828: 39 43 20 cmp %eax,0x20(%ebx)
10a82b: 0f 8e df 01 00 00 jle 10aa10 <rtems_termios_read+0x29c>
*buffer++ = tty->cbuf[tty->cindex++];
10a831: 8b 73 1c mov 0x1c(%ebx),%esi
10a834: 8a 0c 06 mov (%esi,%eax,1),%cl
10a837: 88 0c 07 mov %cl,(%edi,%eax,1)
10a83a: 40 inc %eax
10a83b: 89 43 24 mov %eax,0x24(%ebx)
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
10a83e: 4a dec %edx
10a83f: 75 e7 jne 10a828 <rtems_termios_read+0xb4>
10a841: c7 44 24 24 00 00 00 movl $0x0,0x24(%esp)
10a848: 00
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
10a849: 8b 4c 24 50 mov 0x50(%esp),%ecx
10a84d: 8b 41 10 mov 0x10(%ecx),%eax
10a850: 2b 44 24 24 sub 0x24(%esp),%eax
10a854: 89 41 18 mov %eax,0x18(%ecx)
tty->tty_rcvwakeup = 0;
10a857: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10a85e: 00 00 00
rtems_semaphore_release (tty->isem);
10a861: 8b 43 14 mov 0x14(%ebx),%eax
10a864: 89 04 24 mov %eax,(%esp)
10a867: e8 3c 12 00 00 call 10baa8 <rtems_semaphore_release>
return sc;
}
10a86c: 8b 44 24 20 mov 0x20(%esp),%eax
10a870: 83 c4 3c add $0x3c,%esp
10a873: 5b pop %ebx
10a874: 5e pop %esi
10a875: 5f pop %edi
10a876: 5d pop %ebp
10a877: c3 ret
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
10a878: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
10a87f: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
10a886: 8b 43 28 mov 0x28(%ebx),%eax
10a889: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
10a88c: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
10a892: 85 c0 test %eax,%eax
10a894: 74 0e je 10a8a4 <rtems_termios_read+0x130>
10a896: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx
10a89c: 85 d2 test %edx,%edx
10a89e: 0f 84 75 01 00 00 je 10aa19 <rtems_termios_read+0x2a5>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
10a8a4: 8b 7b 74 mov 0x74(%ebx),%edi
rtems_status_code sc;
int wait = 1;
10a8a7: be 01 00 00 00 mov $0x1,%esi
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
10a8ac: 8d 4b 49 lea 0x49(%ebx),%ecx
10a8af: 89 4c 24 2c mov %ecx,0x2c(%esp)
10a8b3: 90 nop
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a8b4: 8b 53 5c mov 0x5c(%ebx),%edx
10a8b7: 8b 43 60 mov 0x60(%ebx),%eax
10a8ba: 39 c2 cmp %eax,%edx
10a8bc: 0f 84 ca 00 00 00 je 10a98c <rtems_termios_read+0x218>
(tty->ccount < (CBUFSIZE-1))) {
10a8c2: a1 3c d2 12 00 mov 0x12d23c,%eax
10a8c7: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a8c8: 3b 43 20 cmp 0x20(%ebx),%eax
10a8cb: 0f 86 bb 00 00 00 jbe 10a98c <rtems_termios_read+0x218><== NEVER TAKEN
10a8d1: 8d 76 00 lea 0x0(%esi),%esi
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
10a8d4: 8b 43 5c mov 0x5c(%ebx),%eax
10a8d7: 8b 4b 64 mov 0x64(%ebx),%ecx
10a8da: 40 inc %eax
10a8db: 31 d2 xor %edx,%edx
10a8dd: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
10a8df: 8b 43 58 mov 0x58(%ebx),%eax
10a8e2: 8a 0c 10 mov (%eax,%edx,1),%cl
tty->rawInBuf.Head = newHead;
10a8e5: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
10a8e8: 8b 43 60 mov 0x60(%ebx),%eax
10a8eb: 8b 6b 64 mov 0x64(%ebx),%ebp
% tty->rawInBuf.Size)
10a8ee: 8b 7b 64 mov 0x64(%ebx),%edi
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
10a8f1: 01 e8 add %ebp,%eax
10a8f3: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
10a8f5: 31 d2 xor %edx,%edx
10a8f7: f7 f7 div %edi
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
10a8f9: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
10a8ff: 73 5b jae 10a95c <rtems_termios_read+0x1e8><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
10a901: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a907: 83 e0 fe and $0xfffffffe,%eax
10a90a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
10a910: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a916: 25 02 02 00 00 and $0x202,%eax
10a91b: 3d 02 02 00 00 cmp $0x202,%eax
10a920: 0f 84 a6 00 00 00 je 10a9cc <rtems_termios_read+0x258><== NEVER TAKEN
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
10a926: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a92c: f6 c4 01 test $0x1,%ah
10a92f: 74 2b je 10a95c <rtems_termios_read+0x1e8><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
10a931: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a937: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
10a93a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
10a940: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
10a946: 85 c0 test %eax,%eax <== NOT EXECUTED
10a948: 74 12 je 10a95c <rtems_termios_read+0x1e8><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
10a94a: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED
10a94d: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10a950: 88 4c 24 1c mov %cl,0x1c(%esp) <== NOT EXECUTED
10a954: ff d0 call *%eax <== NOT EXECUTED
10a956: 8a 4c 24 1c mov 0x1c(%esp),%cl <== NOT EXECUTED
10a95a: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
10a95c: 0f b6 c1 movzbl %cl,%eax
10a95f: 89 da mov %ebx,%edx
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
10a961: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10a965: 74 51 je 10a9b8 <rtems_termios_read+0x244><== NEVER TAKEN
if (siproc (c, tty))
10a967: e8 e4 fc ff ff call 10a650 <siproc>
10a96c: 85 c0 test %eax,%eax
10a96e: 75 56 jne 10a9c6 <rtems_termios_read+0x252>
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
10a970: 8b 7b 70 mov 0x70(%ebx),%edi
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a973: 8b 53 5c mov 0x5c(%ebx),%edx
10a976: 8b 43 60 mov 0x60(%ebx),%eax
10a979: 39 c2 cmp %eax,%edx
10a97b: 74 0f je 10a98c <rtems_termios_read+0x218>
(tty->ccount < (CBUFSIZE-1))) {
10a97d: a1 3c d2 12 00 mov 0x12d23c,%eax
10a982: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a983: 39 43 20 cmp %eax,0x20(%ebx)
10a986: 0f 82 48 ff ff ff jb 10a8d4 <rtems_termios_read+0x160><== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
10a98c: 85 f6 test %esi,%esi
10a98e: 0f 84 74 fe ff ff je 10a808 <rtems_termios_read+0x94>
sc = rtems_semaphore_obtain(
10a994: 89 7c 24 08 mov %edi,0x8(%esp)
10a998: 8b 43 6c mov 0x6c(%ebx),%eax
10a99b: 89 44 24 04 mov %eax,0x4(%esp)
10a99f: 8b 43 68 mov 0x68(%ebx),%eax
10a9a2: 89 04 24 mov %eax,(%esp)
10a9a5: e8 d2 0f 00 00 call 10b97c <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
10a9aa: 85 c0 test %eax,%eax
10a9ac: 0f 84 02 ff ff ff je 10a8b4 <rtems_termios_read+0x140>
10a9b2: e9 51 fe ff ff jmp 10a808 <rtems_termios_read+0x94>
10a9b7: 90 nop
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
10a9b8: e8 93 fc ff ff call 10a650 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
10a9bd: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
10a9c1: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
10a9c4: 7c aa jl 10a970 <rtems_termios_read+0x1fc><== NOT EXECUTED
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
10a9c6: 31 f6 xor %esi,%esi
10a9c8: eb a6 jmp 10a970 <rtems_termios_read+0x1fc>
10a9ca: 66 90 xchg %ax,%ax
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
10a9cc: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED
10a9d2: 85 ff test %edi,%edi <== NOT EXECUTED
10a9d4: 74 0e je 10a9e4 <rtems_termios_read+0x270><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
10a9d6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a9dc: a8 20 test $0x20,%al <== NOT EXECUTED
10a9de: 0f 84 42 ff ff ff je 10a926 <rtems_termios_read+0x1b2><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
10a9e4: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED
10a9eb: 00
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
10a9ec: 8b 44 24 2c mov 0x2c(%esp),%eax <== NOT EXECUTED
10a9f0: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
10a9f4: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10a9f7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a9fa: 88 4c 24 1c mov %cl,0x1c(%esp) <== NOT EXECUTED
10a9fe: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10aa04: 8a 4c 24 1c mov 0x1c(%esp),%cl <== NOT EXECUTED
10aa08: e9 4f ff ff ff jmp 10a95c <rtems_termios_read+0x1e8><== NOT EXECUTED
10aa0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
10aa10: 89 54 24 24 mov %edx,0x24(%esp)
10aa14: e9 30 fe ff ff jmp 10a849 <rtems_termios_read+0xd5>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
10aa19: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10aa1d: 75 1f jne 10aa3e <rtems_termios_read+0x2ca>
10aa1f: eb 37 jmp 10aa58 <rtems_termios_read+0x2e4>
10aa21: 8d 76 00 lea 0x0(%esi),%esi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
10aa24: 25 ff 00 00 00 and $0xff,%eax
10aa29: 89 da mov %ebx,%edx
10aa2b: e8 20 fc ff ff call 10a650 <siproc>
10aa30: 85 c0 test %eax,%eax
10aa32: 0f 85 d0 fd ff ff jne 10a808 <rtems_termios_read+0x94>
10aa38: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
10aa3e: 8b 53 10 mov 0x10(%ebx),%edx
10aa41: 89 14 24 mov %edx,(%esp)
10aa44: ff d0 call *%eax
if (n < 0) {
10aa46: 85 c0 test %eax,%eax
10aa48: 79 da jns 10aa24 <rtems_termios_read+0x2b0>
rtems_task_wake_after (1);
10aa4a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
10aa51: e8 62 14 00 00 call 10beb8 <rtems_task_wake_after>
10aa56: eb e0 jmp 10aa38 <rtems_termios_read+0x2c4>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
10aa58: e8 83 08 00 00 call 10b2e0 <rtems_clock_get_ticks_since_boot>
10aa5d: 89 c6 mov %eax,%esi
10aa5f: 90 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
10aa60: 8b 53 10 mov 0x10(%ebx),%edx
10aa63: 89 14 24 mov %edx,(%esp)
10aa66: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
10aa6c: 85 c0 test %eax,%eax
10aa6e: 78 28 js 10aa98 <rtems_termios_read+0x324>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
10aa70: 25 ff 00 00 00 and $0xff,%eax
10aa75: 89 da mov %ebx,%edx
10aa77: e8 d4 fb ff ff call 10a650 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
10aa7c: 8a 43 47 mov 0x47(%ebx),%al
10aa7f: 0f b6 d0 movzbl %al,%edx
10aa82: 39 53 20 cmp %edx,0x20(%ebx)
10aa85: 0f 8d 7d fd ff ff jge 10a808 <rtems_termios_read+0x94>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
10aa8b: 84 c0 test %al,%al
10aa8d: 74 d1 je 10aa60 <rtems_termios_read+0x2ec><== NEVER TAKEN
10aa8f: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
10aa93: 74 cb je 10aa60 <rtems_termios_read+0x2ec><== NEVER TAKEN
10aa95: eb c1 jmp 10aa58 <rtems_termios_read+0x2e4>
10aa97: 90 nop
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
10aa98: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10aa9c: 74 1c je 10aaba <rtems_termios_read+0x346><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
10aa9e: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
10aaa2: 74 08 je 10aaac <rtems_termios_read+0x338><== NEVER TAKEN
10aaa4: 8b 6b 20 mov 0x20(%ebx),%ebp
10aaa7: 85 ed test %ebp,%ebp
10aaa9: 75 19 jne 10aac4 <rtems_termios_read+0x350>
10aaab: 90 nop
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
10aaac: c7 04 24 01 00 00 00 movl $0x1,(%esp)
10aab3: e8 00 14 00 00 call 10beb8 <rtems_task_wake_after>
10aab8: eb a6 jmp 10aa60 <rtems_termios_read+0x2ec>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
10aaba: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10aabe: 0f 84 44 fd ff ff je 10a808 <rtems_termios_read+0x94><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
10aac4: e8 17 08 00 00 call 10b2e0 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
10aac9: 29 f0 sub %esi,%eax
10aacb: 3b 43 54 cmp 0x54(%ebx),%eax
10aace: 76 dc jbe 10aaac <rtems_termios_read+0x338>
10aad0: e9 33 fd ff ff jmp 10a808 <rtems_termios_read+0x94>
00109310 <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
static int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
109310: 57 push %edi
109311: 56 push %esi
109312: 53 push %ebx
109313: 83 ec 10 sub $0x10,%esp
109316: 89 c3 mov %eax,%ebx
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
109318: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax
10931e: 25 03 04 00 00 and $0x403,%eax
109323: 3d 01 04 00 00 cmp $0x401,%eax
109328: 0f 84 5e 01 00 00 je 10948c <rtems_termios_refill_transmitter+0x17c><== NEVER TAKEN
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
10932e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109334: 83 e0 03 and $0x3,%eax
109337: 83 f8 02 cmp $0x2,%eax
10933a: 0f 84 90 01 00 00 je 1094d0 <rtems_termios_refill_transmitter+0x1c0><== NEVER TAKEN
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
109340: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
109346: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10934c: 39 c2 cmp %eax,%edx
10934e: 0f 84 a8 00 00 00 je 1093fc <rtems_termios_refill_transmitter+0xec>
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
109354: 9c pushf
109355: fa cli
109356: 58 pop %eax
len = tty->t_dqlen;
109357: 8b b3 90 00 00 00 mov 0x90(%ebx),%esi
tty->t_dqlen = 0;
10935d: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
109364: 00 00 00
rtems_interrupt_enable(level);
109367: 50 push %eax
109368: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
109369: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10936f: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
109375: 01 f0 add %esi,%eax
109377: 31 d2 xor %edx,%edx
109379: f7 f1 div %ecx
10937b: 89 d6 mov %edx,%esi
tty->rawOutBuf.Tail = newTail;
10937d: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
109383: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10938a: 0f 84 e8 00 00 00 je 109478 <rtems_termios_refill_transmitter+0x168>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
109390: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109396: 39 f0 cmp %esi,%eax
109398: 74 7a je 109414 <rtems_termios_refill_transmitter+0x104>
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
10939a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1093a0: 25 10 02 00 00 and $0x210,%eax
1093a5: 3d 10 02 00 00 cmp $0x210,%eax
1093aa: 0f 84 64 01 00 00 je 109514 <rtems_termios_refill_transmitter+0x204><== NEVER TAKEN
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
1093b0: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1093b6: 39 c6 cmp %eax,%esi
1093b8: 0f 87 92 00 00 00 ja 109450 <rtems_termios_refill_transmitter+0x140>
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
1093be: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi
1093c4: 29 f7 sub %esi,%edi
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
1093c6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1093cc: f6 c4 06 test $0x6,%ah
1093cf: 0f 85 92 00 00 00 jne 109467 <rtems_termios_refill_transmitter+0x157>
1093d5: 89 f8 mov %edi,%eax
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
1093d7: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
1093de: 00 00 00
(*tty->device.write)(
1093e1: 89 44 24 08 mov %eax,0x8(%esp)
1093e5: 8b 43 7c mov 0x7c(%ebx),%eax
1093e8: 01 f0 add %esi,%eax
1093ea: 89 44 24 04 mov %eax,0x4(%esp)
1093ee: 8b 43 10 mov 0x10(%ebx),%eax
1093f1: 89 04 24 mov %eax,(%esp)
1093f4: ff 93 a4 00 00 00 call *0xa4(%ebx)
1093fa: eb 44 jmp 109440 <rtems_termios_refill_transmitter+0x130>
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
1093fc: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
109403: 0f 84 33 01 00 00 je 10953c <rtems_termios_refill_transmitter+0x22c><== NEVER TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
109409: 31 ff xor %edi,%edi
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10940b: 89 f8 mov %edi,%eax
10940d: 83 c4 10 add $0x10,%esp
109410: 5b pop %ebx
109411: 5e pop %esi
109412: 5f pop %edi
109413: c3 ret
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
109414: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10941b: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
10941e: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax
109424: 85 c0 test %eax,%eax
109426: 0f 84 28 01 00 00 je 109554 <rtems_termios_refill_transmitter+0x244><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
10942c: 8b 93 d8 00 00 00 mov 0xd8(%ebx),%edx <== NOT EXECUTED
109432: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
109436: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
109439: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10943c: ff d0 call *%eax <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
10943e: 31 ff xor %edi,%edi <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
109440: 89 b3 84 00 00 00 mov %esi,0x84(%ebx)
}
return nToSend;
}
109446: 89 f8 mov %edi,%eax
109448: 83 c4 10 add $0x10,%esp
10944b: 5b pop %ebx
10944c: 5e pop %esi
10944d: 5f pop %edi
10944e: c3 ret
10944f: 90 nop
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
109450: 8b bb 88 00 00 00 mov 0x88(%ebx),%edi
109456: 29 f7 sub %esi,%edi
else
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
109458: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10945e: f6 c4 06 test $0x6,%ah
109461: 0f 84 6e ff ff ff je 1093d5 <rtems_termios_refill_transmitter+0xc5><== ALWAYS TAKEN
109467: b8 01 00 00 00 mov $0x1,%eax
nToSend = 1;
10946c: bf 01 00 00 00 mov $0x1,%edi
109471: e9 61 ff ff ff jmp 1093d7 <rtems_termios_refill_transmitter+0xc7>
109476: 66 90 xchg %ax,%ax
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
109478: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10947e: 89 04 24 mov %eax,(%esp)
109481: e8 22 26 00 00 call 10baa8 <rtems_semaphore_release>
109486: e9 05 ff ff ff jmp 109390 <rtems_termios_refill_transmitter+0x80>
10948b: 90 nop
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
10948c: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED
109493: 00
109494: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
109497: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10949b: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10949e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1094a1: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
1094a7: 9c pushf <== NOT EXECUTED
1094a8: fa cli <== NOT EXECUTED
1094a9: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
1094aa: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
1094b0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094b6: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1094b9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
1094bf: 52 push %edx <== NOT EXECUTED
1094c0: 9d popf <== NOT EXECUTED
nToSend = 1;
1094c1: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
1094c6: 89 f8 mov %edi,%eax <== NOT EXECUTED
1094c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1094cb: 5b pop %ebx <== NOT EXECUTED
1094cc: 5e pop %esi <== NOT EXECUTED
1094cd: 5f pop %edi <== NOT EXECUTED
1094ce: c3 ret <== NOT EXECUTED
1094cf: 90 nop <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
1094d0: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED
1094d7: 00
1094d8: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
1094db: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1094df: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
1094e2: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1094e5: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
1094eb: 9c pushf <== NOT EXECUTED
1094ec: fa cli <== NOT EXECUTED
1094ed: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
1094ee: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
1094f4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094fa: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
1094fd: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
109503: 52 push %edx <== NOT EXECUTED
109504: 9d popf <== NOT EXECUTED
nToSend = 1;
109505: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10950a: 89 f8 mov %edi,%eax <== NOT EXECUTED
10950c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10950f: 5b pop %ebx <== NOT EXECUTED
109510: 5e pop %esi <== NOT EXECUTED
109511: 5f pop %edi <== NOT EXECUTED
109512: c3 ret <== NOT EXECUTED
109513: 90 nop <== NOT EXECUTED
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
109514: 9c pushf <== NOT EXECUTED
109515: fa cli <== NOT EXECUTED
109516: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
109517: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10951d: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
109520: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
109526: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
10952d: 00 00 00
rtems_interrupt_enable(level);
109530: 52 push %edx <== NOT EXECUTED
109531: 9d popf <== NOT EXECUTED
nToSend = 0;
109532: 31 ff xor %edi,%edi <== NOT EXECUTED
109534: e9 07 ff ff ff jmp 109440 <rtems_termios_refill_transmitter+0x130><== NOT EXECUTED
109539: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
10953c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED
109542: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109545: e8 5e 25 00 00 call 10baa8 <rtems_semaphore_release><== NOT EXECUTED
}
return 0;
10954a: 31 ff xor %edi,%edi <== NOT EXECUTED
10954c: e9 ba fe ff ff jmp 10940b <rtems_termios_refill_transmitter+0xfb><== NOT EXECUTED
109551: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
109554: 31 ff xor %edi,%edi
109556: e9 e5 fe ff ff jmp 109440 <rtems_termios_refill_transmitter+0x130>
0010adf8 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
10adf8: 57 push %edi
10adf9: 56 push %esi
10adfa: 53 push %ebx
10adfb: 83 ec 20 sub $0x20,%esp
10adfe: 8b 5c 24 30 mov 0x30(%esp),%ebx
10ae02: 8d 74 24 1c lea 0x1c(%esp),%esi
10ae06: 8d 7c 24 1b lea 0x1b(%esp),%edi
10ae0a: eb 11 jmp 10ae1d <rtems_termios_rxdaemon+0x25>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
10ae0c: 8b 43 10 mov 0x10(%ebx),%eax
10ae0f: 89 04 24 mov %eax,(%esp)
10ae12: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
10ae18: 83 f8 ff cmp $0xffffffff,%eax
10ae1b: 75 3f jne 10ae5c <rtems_termios_rxdaemon+0x64>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10ae1d: 89 74 24 0c mov %esi,0xc(%esp)
10ae21: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10ae28: 00
10ae29: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
10ae30: 00
10ae31: c7 04 24 03 00 00 00 movl $0x3,(%esp)
10ae38: e8 fb 04 00 00 call 10b338 <rtems_event_receive>
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
10ae3d: f6 44 24 1c 01 testb $0x1,0x1c(%esp)
10ae42: 74 c8 je 10ae0c <rtems_termios_rxdaemon+0x14><== ALWAYS TAKEN
tty->rxTaskId = 0;
10ae44: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
10ae4b: 00 00 00
rtems_task_delete(RTEMS_SELF);
10ae4e: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10ae55: e8 5e 0e 00 00 call 10bcb8 <rtems_task_delete> <== NOT EXECUTED
10ae5a: eb b0 jmp 10ae0c <rtems_termios_rxdaemon+0x14><== NOT EXECUTED
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
10ae5c: 88 44 24 1b mov %al,0x1b(%esp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
10ae60: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
10ae67: 00
10ae68: 89 7c 24 04 mov %edi,0x4(%esp)
10ae6c: 89 1c 24 mov %ebx,(%esp)
10ae6f: e8 88 fc ff ff call 10aafc <rtems_termios_enqueue_raw_characters>
10ae74: eb a7 jmp 10ae1d <rtems_termios_rxdaemon+0x25>
0010955c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
10955c: 56 push %esi
10955d: 53 push %ebx
10955e: 83 ec 24 sub $0x24,%esp
109561: 8b 5c 24 30 mov 0x30(%esp),%ebx
109565: 8d 74 24 1c lea 0x1c(%esp),%esi
109569: eb 20 jmp 10958b <rtems_termios_txdaemon+0x2f>
10956b: 90 nop
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10956c: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx
109572: c1 e2 05 shl $0x5,%edx
109575: 8b 82 b4 f1 12 00 mov 0x12f1b4(%edx),%eax
10957b: 85 c0 test %eax,%eax
10957d: 74 05 je 109584 <rtems_termios_txdaemon+0x28>
rtems_termios_linesw[tty->t_line].l_start(tty);
10957f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
109582: ff d0 call *%eax <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
109584: 89 d8 mov %ebx,%eax
109586: e8 85 fd ff ff call 109310 <rtems_termios_refill_transmitter>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10958b: 89 74 24 0c mov %esi,0xc(%esp)
10958f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
109596: 00
109597: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
10959e: 00
10959f: c7 04 24 03 00 00 00 movl $0x3,(%esp)
1095a6: e8 8d 1d 00 00 call 10b338 <rtems_event_receive>
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
1095ab: f6 44 24 1c 01 testb $0x1,0x1c(%esp)
1095b0: 74 ba je 10956c <rtems_termios_txdaemon+0x10>
tty->txTaskId = 0;
1095b2: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
1095b9: 00 00 00
rtems_task_delete(RTEMS_SELF);
1095bc: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
1095c3: e8 f0 26 00 00 call 10bcb8 <rtems_task_delete> <== NOT EXECUTED
1095c8: eb a2 jmp 10956c <rtems_termios_txdaemon+0x10><== NOT EXECUTED
0010a6b0 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
10a6b0: 55 push %ebp
10a6b1: 57 push %edi
10a6b2: 56 push %esi
10a6b3: 53 push %ebx
10a6b4: 83 ec 2c sub $0x2c,%esp
10a6b7: 8b 6c 24 40 mov 0x40(%esp),%ebp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10a6bb: 8b 45 00 mov 0x0(%ebp),%eax
10a6be: 8b 58 2c mov 0x2c(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10a6c1: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10a6c8: 00
10a6c9: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10a6d0: 00
10a6d1: 8b 43 18 mov 0x18(%ebx),%eax
10a6d4: 89 04 24 mov %eax,(%esp)
10a6d7: e8 a0 12 00 00 call 10b97c <rtems_semaphore_obtain>
10a6dc: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL)
10a6de: 85 c0 test %eax,%eax
10a6e0: 75 29 jne 10a70b <rtems_termios_write+0x5b><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
10a6e2: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10a6e8: c1 e0 05 shl $0x5,%eax
10a6eb: 8b 80 ac f1 12 00 mov 0x12f1ac(%eax),%eax
10a6f1: 85 c0 test %eax,%eax
10a6f3: 74 23 je 10a718 <rtems_termios_write+0x68>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
10a6f5: 89 6c 24 04 mov %ebp,0x4(%esp)
10a6f9: 89 1c 24 mov %ebx,(%esp)
10a6fc: ff d0 call *%eax
10a6fe: 89 c7 mov %eax,%edi
rtems_semaphore_release (tty->osem);
10a700: 8b 43 18 mov 0x18(%ebx),%eax
10a703: 89 04 24 mov %eax,(%esp)
10a706: e8 9d 13 00 00 call 10baa8 <rtems_semaphore_release>
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
10a70b: 89 f8 mov %edi,%eax
10a70d: 83 c4 2c add $0x2c,%esp
10a710: 5b pop %ebx
10a711: 5e pop %esi
10a712: 5f pop %edi
10a713: 5d pop %ebp
10a714: c3 ret
10a715: 8d 76 00 lea 0x0(%esi),%esi
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
10a718: f6 43 34 01 testb $0x1,0x34(%ebx)
10a71c: 74 3a je 10a758 <rtems_termios_write+0xa8><== NEVER TAKEN
uint32_t count = args->count;
10a71e: 8b 45 10 mov 0x10(%ebp),%eax
10a721: 89 44 24 1c mov %eax,0x1c(%esp)
char *buffer = args->buffer;
10a725: 8b 75 0c mov 0xc(%ebp),%esi
while (count--)
10a728: 85 c0 test %eax,%eax
10a72a: 74 44 je 10a770 <rtems_termios_write+0xc0><== NEVER TAKEN
oproc (*buffer++, tty);
10a72c: 0f b6 06 movzbl (%esi),%eax
10a72f: 46 inc %esi
10a730: 89 da mov %ebx,%edx
10a732: e8 59 fa ff ff call 10a190 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
10a737: ff 4c 24 1c decl 0x1c(%esp)
10a73b: 75 ef jne 10a72c <rtems_termios_write+0x7c>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
10a73d: 8b 45 10 mov 0x10(%ebp),%eax
10a740: 89 45 18 mov %eax,0x18(%ebp)
}
rtems_semaphore_release (tty->osem);
10a743: 8b 43 18 mov 0x18(%ebx),%eax
10a746: 89 04 24 mov %eax,(%esp)
10a749: e8 5a 13 00 00 call 10baa8 <rtems_semaphore_release>
return sc;
}
10a74e: 89 f8 mov %edi,%eax
10a750: 83 c4 2c add $0x2c,%esp
10a753: 5b pop %ebx
10a754: 5e pop %esi
10a755: 5f pop %edi
10a756: 5d pop %ebp
10a757: c3 ret
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
10a758: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10a75c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10a75f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10a763: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10a766: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10a769: e8 de f8 ff ff call 10a04c <rtems_termios_puts> <== NOT EXECUTED
10a76e: eb cd jmp 10a73d <rtems_termios_write+0x8d><== NOT EXECUTED
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
10a770: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a772: eb cc jmp 10a740 <rtems_termios_write+0x90><== NOT EXECUTED
0011b6b8 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
11b6b8: 83 ec 2c sub $0x2c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
11b6bb: 8d 44 24 1c lea 0x1c(%esp),%eax
11b6bf: 89 44 24 08 mov %eax,0x8(%esp)
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
11b6c3: 8b 44 24 30 mov 0x30(%esp),%eax
11b6c7: 89 44 24 04 mov %eax,0x4(%esp)
11b6cb: c7 04 24 40 dd 14 00 movl $0x14dd40,(%esp)
11b6d2: e8 f9 2c 00 00 call 11e3d0 <_Objects_Get>
switch ( location ) {
11b6d7: 8b 54 24 1c mov 0x1c(%esp),%edx
11b6db: 85 d2 test %edx,%edx
11b6dd: 75 1d jne 11b6fc <rtems_timer_cancel+0x44>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
11b6df: 83 78 38 04 cmpl $0x4,0x38(%eax)
11b6e3: 74 0b je 11b6f0 <rtems_timer_cancel+0x38><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
11b6e5: 83 c0 10 add $0x10,%eax
11b6e8: 89 04 24 mov %eax,(%esp)
11b6eb: e8 34 48 00 00 call 11ff24 <_Watchdog_Remove>
_Thread_Enable_dispatch();
11b6f0: e8 6f 39 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11b6f5: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11b6f7: 83 c4 2c add $0x2c,%esp
11b6fa: c3 ret
11b6fb: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11b6fc: b8 04 00 00 00 mov $0x4,%eax
}
11b701: 83 c4 2c add $0x2c,%esp
11b704: c3 ret
0011bc38 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
11bc38: 57 push %edi
11bc39: 56 push %esi
11bc3a: 53 push %ebx
11bc3b: 83 ec 20 sub $0x20,%esp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
11bc3e: 8b 1d 80 dd 14 00 mov 0x14dd80,%ebx
if ( !timer_server )
11bc44: 85 db test %ebx,%ebx
11bc46: 74 3c je 11bc84 <rtems_timer_server_fire_when+0x4c>
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
11bc48: 80 3d d4 d9 14 00 00 cmpb $0x0,0x14d9d4
11bc4f: 75 0f jne 11bc60 <rtems_timer_server_fire_when+0x28><== ALWAYS TAKEN
return RTEMS_NOT_DEFINED;
11bc51: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11bc56: 83 c4 20 add $0x20,%esp
11bc59: 5b pop %ebx
11bc5a: 5e pop %esi
11bc5b: 5f pop %edi
11bc5c: c3 ret
11bc5d: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
11bc60: 8b 54 24 38 mov 0x38(%esp),%edx
11bc64: 85 d2 test %edx,%edx
11bc66: 74 28 je 11bc90 <rtems_timer_server_fire_when+0x58>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
11bc68: 8b 44 24 34 mov 0x34(%esp),%eax
11bc6c: 89 04 24 mov %eax,(%esp)
11bc6f: e8 98 cc ff ff call 11890c <_TOD_Validate>
11bc74: 84 c0 test %al,%al
11bc76: 75 24 jne 11bc9c <rtems_timer_server_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
11bc78: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11bc7d: 83 c4 20 add $0x20,%esp
11bc80: 5b pop %ebx
11bc81: 5e pop %esi
11bc82: 5f pop %edi
11bc83: c3 ret
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11bc84: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11bc89: 83 c4 20 add $0x20,%esp
11bc8c: 5b pop %ebx
11bc8d: 5e pop %esi
11bc8e: 5f pop %edi
11bc8f: c3 ret
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
11bc90: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11bc95: 83 c4 20 add $0x20,%esp
11bc98: 5b pop %ebx
11bc99: 5e pop %esi
11bc9a: 5f pop %edi
11bc9b: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
11bc9c: 8b 54 24 34 mov 0x34(%esp),%edx
11bca0: 89 14 24 mov %edx,(%esp)
11bca3: e8 d4 cb ff ff call 11887c <_TOD_To_seconds>
11bca8: 89 c6 mov %eax,%esi
11bcaa: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
11bcb1: 3b
11bcb2: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
11bcb9: 00
11bcba: a1 c0 d9 14 00 mov 0x14d9c0,%eax
11bcbf: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx
11bcc5: 89 04 24 mov %eax,(%esp)
11bcc8: 89 54 24 04 mov %edx,0x4(%esp)
11bccc: e8 73 43 01 00 call 130044 <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
11bcd1: 39 c6 cmp %eax,%esi
11bcd3: 76 a3 jbe 11bc78 <rtems_timer_server_fire_when+0x40>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11bcd5: 8d 44 24 1c lea 0x1c(%esp),%eax
11bcd9: 89 44 24 08 mov %eax,0x8(%esp)
11bcdd: 8b 54 24 30 mov 0x30(%esp),%edx
11bce1: 89 54 24 04 mov %edx,0x4(%esp)
11bce5: c7 04 24 40 dd 14 00 movl $0x14dd40,(%esp)
11bcec: e8 df 26 00 00 call 11e3d0 <_Objects_Get>
11bcf1: 89 c7 mov %eax,%edi
switch ( location ) {
11bcf3: 8b 44 24 1c mov 0x1c(%esp),%eax
11bcf7: 85 c0 test %eax,%eax
11bcf9: 75 70 jne 11bd6b <rtems_timer_server_fire_when+0x133>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
11bcfb: 8d 47 10 lea 0x10(%edi),%eax
11bcfe: 89 04 24 mov %eax,(%esp)
11bd01: e8 1e 42 00 00 call 11ff24 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
11bd06: c7 47 38 03 00 00 00 movl $0x3,0x38(%edi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
11bd0d: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
11bd14: 8b 44 24 38 mov 0x38(%esp),%eax
11bd18: 89 47 2c mov %eax,0x2c(%edi)
the_watchdog->id = id;
11bd1b: 8b 54 24 30 mov 0x30(%esp),%edx
11bd1f: 89 57 30 mov %edx,0x30(%edi)
the_watchdog->user_data = user_data;
11bd22: 8b 44 24 3c mov 0x3c(%esp),%eax
11bd26: 89 47 34 mov %eax,0x34(%edi)
11bd29: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp)
11bd30: 3b
11bd31: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
11bd38: 00
11bd39: a1 c0 d9 14 00 mov 0x14d9c0,%eax
11bd3e: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx
11bd44: 89 04 24 mov %eax,(%esp)
11bd47: 89 54 24 04 mov %edx,0x4(%esp)
11bd4b: e8 f4 42 01 00 call 130044 <__divdi3>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
11bd50: 29 c6 sub %eax,%esi
11bd52: 89 77 1c mov %esi,0x1c(%edi)
(*timer_server->schedule_operation)( timer_server, the_timer );
11bd55: 89 7c 24 04 mov %edi,0x4(%esp)
11bd59: 89 1c 24 mov %ebx,(%esp)
11bd5c: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
11bd5f: e8 00 33 00 00 call 11f064 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11bd64: 31 c0 xor %eax,%eax
11bd66: e9 eb fe ff ff jmp 11bc56 <rtems_timer_server_fire_when+0x1e>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11bd6b: b8 04 00 00 00 mov $0x4,%eax
11bd70: e9 e1 fe ff ff jmp 11bc56 <rtems_timer_server_fire_when+0x1e>
0010773c <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10773c: 55 push %ebp
10773d: 57 push %edi
10773e: 56 push %esi
10773f: 53 push %ebx
107740: 83 ec 2c sub $0x2c,%esp
107743: 89 c3 mov %eax,%ebx
107745: 89 d5 mov %edx,%ebp
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
107747: a9 00 00 00 20 test $0x20000000,%eax
10774c: 74 30 je 10777e <rtems_verror+0x42>
if (rtems_panic_in_progress++)
10774e: 8b 15 d0 f4 12 00 mov 0x12f4d0,%edx
107754: 8d 42 01 lea 0x1(%edx),%eax
107757: a3 d0 f4 12 00 mov %eax,0x12f4d0
10775c: 85 d2 test %edx,%edx
10775e: 74 15 je 107775 <rtems_verror+0x39> <== ALWAYS TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
107760: a1 04 f6 12 00 mov 0x12f604,%eax <== NOT EXECUTED
107765: 40 inc %eax <== NOT EXECUTED
107766: a3 04 f6 12 00 mov %eax,0x12f604 <== NOT EXECUTED
return _Thread_Dispatch_disable_level;
10776b: a1 04 f6 12 00 mov 0x12f604,%eax <== NOT EXECUTED
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
RTEMS_COMPILER_MEMORY_BARRIER();
107770: a1 d0 f4 12 00 mov 0x12f4d0,%eax <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
107775: 83 f8 02 cmp $0x2,%eax
107778: 0f 8f b6 00 00 00 jg 107834 <rtems_verror+0xf8> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10777e: a1 20 d4 12 00 mov 0x12d420,%eax
107783: 8b 40 08 mov 0x8(%eax),%eax
107786: 89 04 24 mov %eax,(%esp)
107789: 89 4c 24 1c mov %ecx,0x1c(%esp)
10778d: e8 ce b8 00 00 call 113060 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
107792: 89 df mov %ebx,%edi
107794: 81 e7 ff ff ff 8f and $0x8fffffff,%edi
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10779a: 81 e3 00 00 00 40 and $0x40000000,%ebx
1077a0: 8b 4c 24 1c mov 0x1c(%esp),%ecx
1077a4: 0f 85 c2 00 00 00 jne 10786c <rtems_verror+0x130>
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
1077aa: 31 f6 xor %esi,%esi
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
1077ac: 89 4c 24 08 mov %ecx,0x8(%esp)
1077b0: 89 6c 24 04 mov %ebp,0x4(%esp)
1077b4: a1 20 d4 12 00 mov 0x12d420,%eax
1077b9: 8b 40 0c mov 0xc(%eax),%eax
1077bc: 89 04 24 mov %eax,(%esp)
1077bf: e8 ec 32 01 00 call 11aab0 <vfprintf>
1077c4: 89 c3 mov %eax,%ebx
if (status)
1077c6: 85 ff test %edi,%edi
1077c8: 75 76 jne 107840 <rtems_verror+0x104>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
1077ca: 83 fe 00 cmp $0x0,%esi
1077cd: 74 31 je 107800 <rtems_verror+0xc4>
if ((local_errno > 0) && *strerror(local_errno))
1077cf: 7e 11 jle 1077e2 <rtems_verror+0xa6>
1077d1: 89 34 24 mov %esi,(%esp)
1077d4: e8 8f c6 00 00 call 113e68 <strerror>
1077d9: 80 38 00 cmpb $0x0,(%eax)
1077dc: 0f 85 9e 00 00 00 jne 107880 <rtems_verror+0x144> <== ALWAYS TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
1077e2: 89 74 24 08 mov %esi,0x8(%esp)
1077e6: c7 44 24 04 e4 0f 12 movl $0x120fe4,0x4(%esp)
1077ed: 00
1077ee: a1 20 d4 12 00 mov 0x12d420,%eax
1077f3: 8b 40 0c mov 0xc(%eax),%eax
1077f6: 89 04 24 mov %eax,(%esp)
1077f9: e8 22 bc 00 00 call 113420 <fprintf>
1077fe: 01 c3 add %eax,%ebx
}
chars_written += fprintf(stderr, "\n");
107800: c7 44 24 04 c1 09 12 movl $0x1209c1,0x4(%esp)
107807: 00
107808: a1 20 d4 12 00 mov 0x12d420,%eax
10780d: 8b 40 0c mov 0xc(%eax),%eax
107810: 89 04 24 mov %eax,(%esp)
107813: e8 08 bc 00 00 call 113420 <fprintf>
107818: 01 c3 add %eax,%ebx
(void) fflush(stderr);
10781a: a1 20 d4 12 00 mov 0x12d420,%eax
10781f: 8b 40 0c mov 0xc(%eax),%eax
107822: 89 04 24 mov %eax,(%esp)
107825: e8 36 b8 00 00 call 113060 <fflush>
return chars_written;
}
10782a: 89 d8 mov %ebx,%eax
10782c: 83 c4 2c add $0x2c,%esp
10782f: 5b pop %ebx
107830: 5e pop %esi
107831: 5f pop %edi
107832: 5d pop %ebp
107833: c3 ret
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
107834: 31 db xor %ebx,%ebx
chars_written += fprintf(stderr, "\n");
(void) fflush(stderr);
return chars_written;
}
107836: 89 d8 mov %ebx,%eax <== NOT EXECUTED
107838: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
10783b: 5b pop %ebx <== NOT EXECUTED
10783c: 5e pop %esi <== NOT EXECUTED
10783d: 5f pop %edi <== NOT EXECUTED
10783e: 5d pop %ebp <== NOT EXECUTED
10783f: c3 ret <== NOT EXECUTED
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
107840: 89 3c 24 mov %edi,(%esp)
107843: e8 d8 fe ff ff call 107720 <rtems_status_text>
107848: 89 44 24 08 mov %eax,0x8(%esp)
10784c: c7 44 24 04 c9 0f 12 movl $0x120fc9,0x4(%esp)
107853: 00
107854: a1 20 d4 12 00 mov 0x12d420,%eax
107859: 8b 40 0c mov 0xc(%eax),%eax
10785c: 89 04 24 mov %eax,(%esp)
10785f: e8 bc bb 00 00 call 113420 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
107864: 01 c3 add %eax,%ebx
107866: e9 5f ff ff ff jmp 1077ca <rtems_verror+0x8e>
10786b: 90 nop
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
10786c: 89 4c 24 1c mov %ecx,0x1c(%esp)
107870: e8 83 b4 00 00 call 112cf8 <__errno>
107875: 8b 30 mov (%eax),%esi
107877: 8b 4c 24 1c mov 0x1c(%esp),%ecx
10787b: e9 2c ff ff ff jmp 1077ac <rtems_verror+0x70>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
107880: 89 34 24 mov %esi,(%esp)
107883: e8 e0 c5 00 00 call 113e68 <strerror>
107888: 89 44 24 08 mov %eax,0x8(%esp)
10788c: c7 44 24 04 d7 0f 12 movl $0x120fd7,0x4(%esp)
107893: 00
107894: e9 55 ff ff ff jmp 1077ee <rtems_verror+0xb2>
00128cc8 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
128cc8: 55 push %ebp
128cc9: 57 push %edi
128cca: 56 push %esi
128ccb: 53 push %ebx
128ccc: 83 ec 2c sub $0x2c,%esp
128ccf: 89 c3 mov %eax,%ebx
128cd1: 89 54 24 1c mov %edx,0x1c(%esp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
128cd5: 31 ff xor %edi,%edi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
128cd7: bd ff ff ff 7f mov $0x7fffffff,%ebp
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
128cdc: 31 f6 xor %esi,%esi
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
128cde: ff 4b 04 decl 0x4(%ebx)
128ce1: 78 45 js 128d28 <scanInt+0x60> <== NEVER TAKEN
128ce3: 8b 03 mov (%ebx),%eax
128ce5: 0f b6 10 movzbl (%eax),%edx
128ce8: 40 inc %eax
128ce9: 89 03 mov %eax,(%ebx)
if (c == ':')
128ceb: 83 fa 3a cmp $0x3a,%edx
128cee: 74 50 je 128d40 <scanInt+0x78>
break;
if (sign == 0) {
128cf0: 85 ff test %edi,%edi
128cf2: 75 0a jne 128cfe <scanInt+0x36>
if (c == '-') {
128cf4: 83 fa 2d cmp $0x2d,%edx
128cf7: 74 7f je 128d78 <scanInt+0xb0>
sign = -1;
limit++;
continue;
}
sign = 1;
128cf9: bf 01 00 00 00 mov $0x1,%edi
}
if (!isdigit(c))
128cfe: a1 74 5f 17 00 mov 0x175f74,%eax
128d03: f6 44 10 01 04 testb $0x4,0x1(%eax,%edx,1)
128d08: 74 62 je 128d6c <scanInt+0xa4>
return 0;
d = c - '0';
128d0a: 8d 4a d0 lea -0x30(%edx),%ecx
if ((i > (limit / 10))
128d0d: b8 cd cc cc cc mov $0xcccccccd,%eax
128d12: f7 e5 mul %ebp
128d14: c1 ea 03 shr $0x3,%edx
128d17: 39 d6 cmp %edx,%esi
128d19: 77 51 ja 128d6c <scanInt+0xa4>
|| ((i == (limit / 10)) && (d > (limit % 10))))
128d1b: 74 3f je 128d5c <scanInt+0x94>
return 0;
i = i * 10 + d;
128d1d: 8d 04 b6 lea (%esi,%esi,4),%eax
128d20: 8d 34 41 lea (%ecx,%eax,2),%esi
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
128d23: ff 4b 04 decl 0x4(%ebx)
128d26: 79 bb jns 128ce3 <scanInt+0x1b> <== ALWAYS TAKEN
128d28: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
128d2c: a1 80 5f 17 00 mov 0x175f80,%eax <== NOT EXECUTED
128d31: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
128d34: e8 57 76 01 00 call 140390 <__srget_r> <== NOT EXECUTED
128d39: 89 c2 mov %eax,%edx <== NOT EXECUTED
if (c == ':')
128d3b: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED
128d3e: 75 b0 jne 128cf0 <scanInt+0x28> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
128d40: 85 ff test %edi,%edi
128d42: 74 28 je 128d6c <scanInt+0xa4> <== NEVER TAKEN
return 0;
*val = i * sign;
128d44: 0f af f7 imul %edi,%esi
128d47: 8b 54 24 1c mov 0x1c(%esp),%edx
128d4b: 89 32 mov %esi,(%edx)
return 1;
128d4d: b8 01 00 00 00 mov $0x1,%eax
}
128d52: 83 c4 2c add $0x2c,%esp
128d55: 5b pop %ebx
128d56: 5e pop %esi
128d57: 5f pop %edi
128d58: 5d pop %ebp
128d59: c3 ret
128d5a: 66 90 xchg %ax,%ax
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
128d5c: 8d 04 b6 lea (%esi,%esi,4),%eax
128d5f: d1 e0 shl %eax
128d61: 89 ea mov %ebp,%edx
128d63: 29 c2 sub %eax,%edx
128d65: 39 d1 cmp %edx,%ecx
128d67: 76 b4 jbe 128d1d <scanInt+0x55> <== NEVER TAKEN
128d69: 8d 76 00 lea 0x0(%esi),%esi
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
128d6c: 31 c0 xor %eax,%eax
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
128d6e: 83 c4 2c add $0x2c,%esp
128d71: 5b pop %ebx
128d72: 5e pop %esi
128d73: 5f pop %edi
128d74: 5d pop %ebp
128d75: c3 ret
128d76: 66 90 xchg %ax,%ax
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
128d78: 45 inc %ebp
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
128d79: bf ff ff ff ff mov $0xffffffff,%edi
limit++;
continue;
128d7e: e9 5b ff ff ff jmp 128cde <scanInt+0x16>
00128d84 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
128d84: 57 push %edi
128d85: 56 push %esi
128d86: 53 push %ebx
128d87: 83 ec 10 sub $0x10,%esp
128d8a: 89 c3 mov %eax,%ebx
128d8c: 89 ce mov %ecx,%esi
128d8e: 8b 7c 24 20 mov 0x20(%esp),%edi
int c;
*name = *bufp;
128d92: 8b 01 mov (%ecx),%eax
128d94: 89 02 mov %eax,(%edx)
128d96: eb 24 jmp 128dbc <scanString+0x38>
for (;;) {
c = getc(fp);
128d98: 8b 13 mov (%ebx),%edx
128d9a: 0f b6 02 movzbl (%edx),%eax
128d9d: 42 inc %edx
128d9e: 89 13 mov %edx,(%ebx)
if (c == ':') {
128da0: 83 f8 3a cmp $0x3a,%eax
128da3: 74 33 je 128dd8 <scanString+0x54>
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
128da5: 83 f8 0a cmp $0xa,%eax
128da8: 74 4e je 128df8 <scanString+0x74>
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
128daa: 83 f8 ff cmp $0xffffffff,%eax
128dad: 74 51 je 128e00 <scanString+0x7c>
return 0;
if (*nleft < 2)
128daf: 83 3f 01 cmpl $0x1,(%edi)
128db2: 76 4c jbe 128e00 <scanString+0x7c>
return 0;
**bufp = c;
128db4: 8b 16 mov (%esi),%edx
128db6: 88 02 mov %al,(%edx)
++(*bufp);
128db8: ff 06 incl (%esi)
--(*nleft);
128dba: ff 0f decl (%edi)
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
128dbc: ff 4b 04 decl 0x4(%ebx)
128dbf: 79 d7 jns 128d98 <scanString+0x14>
128dc1: 89 5c 24 04 mov %ebx,0x4(%esp)
128dc5: a1 80 5f 17 00 mov 0x175f80,%eax
128dca: 89 04 24 mov %eax,(%esp)
128dcd: e8 be 75 01 00 call 140390 <__srget_r>
if (c == ':') {
128dd2: 83 f8 3a cmp $0x3a,%eax
128dd5: 75 ce jne 128da5 <scanString+0x21> <== ALWAYS TAKEN
128dd7: 90 nop
if (nlFlag)
128dd8: 8b 54 24 24 mov 0x24(%esp),%edx
128ddc: 85 d2 test %edx,%edx
128dde: 75 20 jne 128e00 <scanString+0x7c>
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
128de0: 8b 06 mov (%esi),%eax
128de2: c6 00 00 movb $0x0,(%eax)
++(*bufp);
128de5: ff 06 incl (%esi)
--(*nleft);
128de7: ff 0f decl (%edi)
return 1;
128de9: b8 01 00 00 00 mov $0x1,%eax
}
128dee: 83 c4 10 add $0x10,%esp
128df1: 5b pop %ebx
128df2: 5e pop %esi
128df3: 5f pop %edi
128df4: c3 ret
128df5: 8d 76 00 lea 0x0(%esi),%esi
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
128df8: 8b 44 24 24 mov 0x24(%esp),%eax
128dfc: 85 c0 test %eax,%eax
128dfe: 75 e0 jne 128de0 <scanString+0x5c>
*name = *bufp;
for (;;) {
c = getc(fp);
if (c == ':') {
if (nlFlag)
return 0;
128e00: 31 c0 xor %eax,%eax
}
**bufp = '\0';
++(*bufp);
--(*nleft);
return 1;
}
128e02: 83 c4 10 add $0x10,%esp
128e05: 5b pop %ebx
128e06: 5e pop %esi
128e07: 5f pop %edi
128e08: c3 ret
00128e0c <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
128e0c: 56 push %esi
128e0d: 53 push %ebx
128e0e: 83 ec 34 sub $0x34,%esp
128e11: 89 c3 mov %eax,%ebx
128e13: 89 d6 mov %edx,%esi
128e15: 89 4c 24 1c mov %ecx,0x1c(%esp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
128e19: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128e20: 00
128e21: 8d 44 24 40 lea 0x40(%esp),%eax
128e25: 89 04 24 mov %eax,(%esp)
128e28: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128e2c: 89 d8 mov %ebx,%eax
128e2e: e8 51 ff ff ff call 128d84 <scanString>
128e33: 85 c0 test %eax,%eax
128e35: 75 09 jne 128e40 <scangr+0x34>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
128e37: 31 c0 xor %eax,%eax
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
128e39: 83 c4 34 add $0x34,%esp
128e3c: 5b pop %ebx
128e3d: 5e pop %esi
128e3e: c3 ret
128e3f: 90 nop
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
128e40: 8d 56 04 lea 0x4(%esi),%edx
128e43: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128e4a: 00
128e4b: 8d 44 24 40 lea 0x40(%esp),%eax
128e4f: 89 04 24 mov %eax,(%esp)
128e52: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128e56: 89 d8 mov %ebx,%eax
128e58: e8 27 ff ff ff call 128d84 <scanString>
128e5d: 85 c0 test %eax,%eax
128e5f: 74 d6 je 128e37 <scangr+0x2b> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
128e61: 8d 54 24 28 lea 0x28(%esp),%edx
128e65: 89 d8 mov %ebx,%eax
128e67: e8 5c fe ff ff call 128cc8 <scanInt>
128e6c: 85 c0 test %eax,%eax
128e6e: 74 c7 je 128e37 <scangr+0x2b> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
128e70: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
128e77: 00
128e78: 8d 44 24 40 lea 0x40(%esp),%eax
128e7c: 89 04 24 mov %eax,(%esp)
128e7f: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128e83: 8d 54 24 2c lea 0x2c(%esp),%edx
128e87: 89 d8 mov %ebx,%eax
128e89: e8 f6 fe ff ff call 128d84 <scanString>
128e8e: 85 c0 test %eax,%eax
128e90: 74 a5 je 128e37 <scangr+0x2b> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
128e92: 8b 44 24 28 mov 0x28(%esp),%eax
128e96: 66 89 46 08 mov %ax,0x8(%esi)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
128e9a: 8b 5c 24 2c mov 0x2c(%esp),%ebx
128e9e: 8a 03 mov (%ebx),%al
128ea0: 84 c0 test %al,%al
128ea2: 0f 84 83 00 00 00 je 128f2b <scangr+0x11f> <== NEVER TAKEN
128ea8: 89 da mov %ebx,%edx
128eaa: b9 01 00 00 00 mov $0x1,%ecx
128eaf: eb 0a jmp 128ebb <scangr+0xaf>
128eb1: 8d 76 00 lea 0x0(%esi),%esi
128eb4: 42 inc %edx
128eb5: 8a 02 mov (%edx),%al
128eb7: 84 c0 test %al,%al
128eb9: 74 09 je 128ec4 <scangr+0xb8>
if(*cp == ',')
128ebb: 3c 2c cmp $0x2c,%al
128ebd: 75 f5 jne 128eb4 <scangr+0xa8>
memcount++;
128ebf: 41 inc %ecx
128ec0: eb f2 jmp 128eb4 <scangr+0xa8>
128ec2: 66 90 xchg %ax,%ax
128ec4: 8d 04 8d 13 00 00 00 lea 0x13(,%ecx,4),%eax
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
128ecb: 39 44 24 40 cmp %eax,0x40(%esp)
128ecf: 0f 82 62 ff ff ff jb 128e37 <scangr+0x2b> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
128ed5: 8b 44 24 1c mov 0x1c(%esp),%eax
128ed9: 83 c0 0f add $0xf,%eax
128edc: 83 e0 f0 and $0xfffffff0,%eax
128edf: 89 46 0c mov %eax,0xc(%esi)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
128ee2: 89 18 mov %ebx,(%eax)
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
128ee4: 8b 44 24 2c mov 0x2c(%esp),%eax
128ee8: 8a 10 mov (%eax),%dl
128eea: 84 d2 test %dl,%dl
128eec: 74 44 je 128f32 <scangr+0x126> <== NEVER TAKEN
}
/*
* Extract a single group record from the database
*/
static int scangr(
128eee: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
128eef: b9 01 00 00 00 mov $0x1,%ecx
128ef4: eb 09 jmp 128eff <scangr+0xf3>
128ef6: 66 90 xchg %ax,%ax
128ef8: 8a 10 mov (%eax),%dl
128efa: 40 inc %eax
128efb: 84 d2 test %dl,%dl
128efd: 74 15 je 128f14 <scangr+0x108>
if(*cp == ',') {
128eff: 80 fa 2c cmp $0x2c,%dl
128f02: 75 f4 jne 128ef8 <scangr+0xec>
*cp = '\0';
128f04: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
128f08: 8b 56 0c mov 0xc(%esi),%edx
128f0b: 89 04 8a mov %eax,(%edx,%ecx,4)
128f0e: 41 inc %ecx
128f0f: eb e7 jmp 128ef8 <scangr+0xec>
128f11: 8d 76 00 lea 0x0(%esi),%esi
128f14: c1 e1 02 shl $0x2,%ecx
}
}
grp->gr_mem[memcount] = NULL;
128f17: 8b 46 0c mov 0xc(%esi),%eax
128f1a: c7 04 08 00 00 00 00 movl $0x0,(%eax,%ecx,1)
return 1;
128f21: b8 01 00 00 00 mov $0x1,%eax
128f26: e9 0e ff ff ff jmp 128e39 <scangr+0x2d>
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
128f2b: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED
128f30: eb 99 jmp 128ecb <scangr+0xbf> <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
128f32: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
128f37: eb de jmp 128f17 <scangr+0x10b> <== NOT EXECUTED
00128f3c <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
128f3c: 56 push %esi
128f3d: 53 push %ebx
128f3e: 83 ec 34 sub $0x34,%esp
128f41: 89 c3 mov %eax,%ebx
128f43: 89 d6 mov %edx,%esi
128f45: 89 4c 24 1c mov %ecx,0x1c(%esp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
128f49: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128f50: 00
128f51: 8d 44 24 40 lea 0x40(%esp),%eax
128f55: 89 04 24 mov %eax,(%esp)
128f58: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128f5c: 89 d8 mov %ebx,%eax
128f5e: e8 21 fe ff ff call 128d84 <scanString>
128f63: 85 c0 test %eax,%eax
128f65: 75 09 jne 128f70 <scanpw+0x34>
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
128f67: 31 c0 xor %eax,%eax
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
128f69: 83 c4 34 add $0x34,%esp
128f6c: 5b pop %ebx
128f6d: 5e pop %esi
128f6e: c3 ret
128f6f: 90 nop
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
128f70: 8d 56 04 lea 0x4(%esi),%edx
128f73: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128f7a: 00
128f7b: 8d 44 24 40 lea 0x40(%esp),%eax
128f7f: 89 04 24 mov %eax,(%esp)
128f82: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128f86: 89 d8 mov %ebx,%eax
128f88: e8 f7 fd ff ff call 128d84 <scanString>
128f8d: 85 c0 test %eax,%eax
128f8f: 74 d6 je 128f67 <scanpw+0x2b> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
128f91: 8d 54 24 28 lea 0x28(%esp),%edx
128f95: 89 d8 mov %ebx,%eax
128f97: e8 2c fd ff ff call 128cc8 <scanInt>
128f9c: 85 c0 test %eax,%eax
128f9e: 74 c7 je 128f67 <scanpw+0x2b>
|| !scanInt(fp, &pwgid)
128fa0: 8d 54 24 2c lea 0x2c(%esp),%edx
128fa4: 89 d8 mov %ebx,%eax
128fa6: e8 1d fd ff ff call 128cc8 <scanInt>
128fab: 85 c0 test %eax,%eax
128fad: 74 b8 je 128f67 <scanpw+0x2b>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
128faf: 8d 56 0c lea 0xc(%esi),%edx
128fb2: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128fb9: 00
128fba: 8d 44 24 40 lea 0x40(%esp),%eax
128fbe: 89 04 24 mov %eax,(%esp)
128fc1: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128fc5: 89 d8 mov %ebx,%eax
128fc7: e8 b8 fd ff ff call 128d84 <scanString>
128fcc: 85 c0 test %eax,%eax
128fce: 74 97 je 128f67 <scanpw+0x2b> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
128fd0: 8d 56 10 lea 0x10(%esi),%edx
128fd3: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128fda: 00
128fdb: 8d 44 24 40 lea 0x40(%esp),%eax
128fdf: 89 04 24 mov %eax,(%esp)
128fe2: 8d 4c 24 1c lea 0x1c(%esp),%ecx
128fe6: 89 d8 mov %ebx,%eax
128fe8: e8 97 fd ff ff call 128d84 <scanString>
128fed: 85 c0 test %eax,%eax
128fef: 0f 84 72 ff ff ff je 128f67 <scanpw+0x2b> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
128ff5: 8d 56 14 lea 0x14(%esi),%edx
128ff8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
128fff: 00
129000: 8d 44 24 40 lea 0x40(%esp),%eax
129004: 89 04 24 mov %eax,(%esp)
129007: 8d 4c 24 1c lea 0x1c(%esp),%ecx
12900b: 89 d8 mov %ebx,%eax
12900d: e8 72 fd ff ff call 128d84 <scanString>
129012: 85 c0 test %eax,%eax
129014: 0f 84 4d ff ff ff je 128f67 <scanpw+0x2b> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
12901a: 8d 56 18 lea 0x18(%esi),%edx
12901d: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
129024: 00
129025: 8d 44 24 40 lea 0x40(%esp),%eax
129029: 89 04 24 mov %eax,(%esp)
12902c: 8d 4c 24 1c lea 0x1c(%esp),%ecx
129030: 89 d8 mov %ebx,%eax
129032: e8 4d fd ff ff call 128d84 <scanString>
129037: 85 c0 test %eax,%eax
129039: 0f 84 28 ff ff ff je 128f67 <scanpw+0x2b>
return 0;
pwd->pw_uid = pwuid;
12903f: 8b 44 24 28 mov 0x28(%esp),%eax
129043: 66 89 46 08 mov %ax,0x8(%esi)
pwd->pw_gid = pwgid;
129047: 8b 44 24 2c mov 0x2c(%esp),%eax
12904b: 66 89 46 0a mov %ax,0xa(%esi)
return 1;
12904f: b8 01 00 00 00 mov $0x1,%eax
129054: e9 10 ff ff ff jmp 128f69 <scanpw+0x2d>
0010a650 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
10a650: 56 push %esi
10a651: 53 push %ebx
10a652: 83 ec 14 sub $0x14,%esp
10a655: 89 d3 mov %edx,%ebx
10a657: 89 c6 mov %eax,%esi
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
10a659: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
10a660: 75 12 jne 10a674 <siproc+0x24> <== ALWAYS TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
10a662: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10a665: 89 da mov %ebx,%edx <== NOT EXECUTED
}
return i;
}
10a667: 83 c4 14 add $0x14,%esp <== NOT EXECUTED
10a66a: 5b pop %ebx <== NOT EXECUTED
10a66b: 5e pop %esi <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
10a66c: e9 47 fe ff ff jmp 10a4b8 <iproc> <== NOT EXECUTED
10a671: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10a674: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10a67b: 00
10a67c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10a683: 00
10a684: 8b 42 18 mov 0x18(%edx),%eax
10a687: 89 04 24 mov %eax,(%esp)
10a68a: e8 ed 12 00 00 call 10b97c <rtems_semaphore_obtain>
i = iproc (c, tty);
10a68f: 89 f2 mov %esi,%edx
10a691: 0f b6 c2 movzbl %dl,%eax
10a694: 89 da mov %ebx,%edx
10a696: e8 1d fe ff ff call 10a4b8 <iproc>
10a69b: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
10a69d: 8b 43 18 mov 0x18(%ebx),%eax
10a6a0: 89 04 24 mov %eax,(%esp)
10a6a3: e8 00 14 00 00 call 10baa8 <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
10a6a8: 89 f0 mov %esi,%eax
10a6aa: 83 c4 14 add $0x14,%esp
10a6ad: 5b pop %ebx
10a6ae: 5e pop %esi
10a6af: c3 ret
0010a0cc <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
10a0cc: 53 push %ebx
10a0cd: 83 ec 18 sub $0x18,%esp
10a0d0: 8b 44 24 20 mov 0x20(%esp),%eax
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
10a0d4: 8b 90 dc 00 00 00 mov 0xdc(%eax),%edx
if ( this_reent ) {
10a0da: 85 d2 test %edx,%edx
10a0dc: 74 33 je 10a111 <sync_per_thread+0x45> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
10a0de: 8b 0d 6c 18 13 00 mov 0x13186c,%ecx
10a0e4: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx
_Thread_Executing->libc_reent = this_reent;
10a0ea: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx)
_fwalk (t->libc_reent, sync_wrapper);
10a0f0: c7 44 24 04 18 a1 10 movl $0x10a118,0x4(%esp)
10a0f7: 00
10a0f8: 8b 80 dc 00 00 00 mov 0xdc(%eax),%eax
10a0fe: 89 04 24 mov %eax,(%esp)
10a101: e8 fe a8 00 00 call 114a04 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
10a106: a1 6c 18 13 00 mov 0x13186c,%eax
10a10b: 89 98 dc 00 00 00 mov %ebx,0xdc(%eax)
}
}
10a111: 83 c4 18 add $0x18,%esp
10a114: 5b pop %ebx
10a115: c3 ret
0011876c <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
11876c: 56 push %esi
11876d: 53 push %ebx
11876e: 83 ec 14 sub $0x14,%esp
118771: 8b 5c 24 20 mov 0x20(%esp),%ebx
118775: 8b 44 24 24 mov 0x24(%esp),%eax
118779: 8b 74 24 28 mov 0x28(%esp),%esi
switch (opt) {
11877d: 85 c0 test %eax,%eax
11877f: 74 37 je 1187b8 <tcsetattr+0x4c>
118781: 48 dec %eax
118782: 74 18 je 11879c <tcsetattr+0x30>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
118784: e8 af 38 00 00 call 11c038 <__errno>
118789: c7 00 86 00 00 00 movl $0x86,(%eax)
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
11878f: b8 ff ff ff ff mov $0xffffffff,%eax
118794: 83 c4 14 add $0x14,%esp
118797: 5b pop %ebx
118798: 5e pop %esi
118799: c3 ret
11879a: 66 90 xchg %ax,%ax
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
11879c: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
1187a3: 00
1187a4: c7 44 24 04 03 00 00 movl $0x3,0x4(%esp)
1187ab: 00
1187ac: 89 1c 24 mov %ebx,(%esp)
1187af: e8 8c f7 ff ff call 117f40 <ioctl>
1187b4: 85 c0 test %eax,%eax
1187b6: 78 d7 js 11878f <tcsetattr+0x23> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1187b8: 89 74 24 28 mov %esi,0x28(%esp)
1187bc: c7 44 24 24 02 00 00 movl $0x2,0x24(%esp)
1187c3: 00
1187c4: 89 5c 24 20 mov %ebx,0x20(%esp)
}
}
1187c8: 83 c4 14 add $0x14,%esp
1187cb: 5b pop %ebx
1187cc: 5e pop %esi
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1187cd: e9 6e f7 ff ff jmp 117f40 <ioctl>
0010b2c4 <unmount>:
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
}
int unmount( const char *path )
{
10b2c4: 57 push %edi
10b2c5: 56 push %esi
10b2c6: 53 push %ebx
10b2c7: 83 ec 50 sub $0x50,%esp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
10b2ca: c7 44 24 08 18 00 00 movl $0x18,0x8(%esp)
10b2d1: 00
10b2d2: 8b 44 24 60 mov 0x60(%esp),%eax
10b2d6: 89 44 24 04 mov %eax,0x4(%esp)
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
10b2da: 8d 7c 24 18 lea 0x18(%esp),%edi
10b2de: 89 3c 24 mov %edi,(%esp)
int unmount( const char *path )
{
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
10b2e1: e8 b2 dd ff ff call 109098 <rtems_filesystem_eval_path_start>
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
10b2e6: 8b 58 14 mov 0x14(%eax),%ebx
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
return (*mt_entry->ops->are_nodes_equal_h)(
10b2e9: 8b 53 0c mov 0xc(%ebx),%edx
10b2ec: 8b 4b 24 mov 0x24(%ebx),%ecx
10b2ef: 89 4c 24 04 mov %ecx,0x4(%esp)
10b2f3: 89 04 24 mov %eax,(%esp)
10b2f6: ff 52 10 call *0x10(%edx)
if ( rtems_filesystem_location_is_root( currentloc ) ) {
10b2f9: 84 c0 test %al,%al
10b2fb: 0f 84 9d 00 00 00 je 10b39e <unmount+0xda>
static bool contains_root_or_current_directory(
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
10b301: a1 00 e7 12 00 mov 0x12e700,%eax
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
10b306: 8b 10 mov (%eax),%edx
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
10b308: 8b 40 04 mov 0x4(%eax),%eax
10b30b: 3b 58 14 cmp 0x14(%eax),%ebx
10b30e: 74 7c je 10b38c <unmount+0xc8>
10b310: 3b 5a 14 cmp 0x14(%edx),%ebx
10b313: 74 77 je 10b38c <unmount+0xc8>
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
10b315: 8b 43 20 mov 0x20(%ebx),%eax
10b318: 8b 40 14 mov 0x14(%eax),%eax
rv = (*mt_point_ops->unmount_h)( mt_entry );
10b31b: 8b 40 0c mov 0xc(%eax),%eax
10b31e: 89 1c 24 mov %ebx,(%esp)
10b321: ff 50 38 call *0x38(%eax)
10b324: 89 c6 mov %eax,%esi
if ( rv == 0 ) {
10b326: 85 c0 test %eax,%eax
10b328: 74 12 je 10b33c <unmount+0x78>
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
10b32a: 89 3c 24 mov %edi,(%esp)
10b32d: e8 52 de ff ff call 109184 <rtems_filesystem_eval_path_cleanup>
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
10b332: 89 f0 mov %esi,%eax
10b334: 83 c4 50 add $0x50,%esp
10b337: 5b pop %ebx
10b338: 5e pop %esi
10b339: 5f pop %edi
10b33a: c3 ret
10b33b: 90 nop
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
rv = (*mt_point_ops->unmount_h)( mt_entry );
if ( rv == 0 ) {
rtems_id self_task_id = rtems_task_self();
10b33c: e8 3b 0f 00 00 call 10c27c <rtems_task_self>
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
10b341: 9c pushf
10b342: fa cli
10b343: 5a pop %edx
mt_entry->unmount_task = self_task_id;
10b344: 89 43 3c mov %eax,0x3c(%ebx)
mt_entry->mounted = false;
10b347: c6 43 28 00 movb $0x0,0x28(%ebx)
rtems_filesystem_mt_entry_unlock( lock_context );
10b34b: 52 push %edx
10b34c: 9d popf
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
10b34d: 89 3c 24 mov %edi,(%esp)
10b350: e8 2f de ff ff call 109184 <rtems_filesystem_eval_path_cleanup>
if ( rv == 0 ) {
rtems_event_set out;
rtems_status_code sc = rtems_event_receive(
10b355: 8d 44 24 14 lea 0x14(%esp),%eax
10b359: 89 44 24 0c mov %eax,0xc(%esp)
10b35d: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10b364: 00
10b365: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
10b36c: 00
10b36d: c7 04 24 02 00 00 00 movl $0x2,(%esp)
10b374: e8 5b 04 00 00 call 10b7d4 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out
);
if ( sc != RTEMS_SUCCESSFUL ) {
10b379: 85 c0 test %eax,%eax
10b37b: 74 b5 je 10b332 <unmount+0x6e> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xdeadbeef );
10b37d: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED
10b384: e8 77 11 00 00 call 10c500 <rtems_fatal_error_occurred><== NOT EXECUTED
10b389: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
mt_entry->mounted = false;
rtems_filesystem_mt_entry_unlock( lock_context );
}
} else {
errno = EBUSY;
10b38c: e8 bf 7d 00 00 call 113150 <__errno>
10b391: c7 00 10 00 00 00 movl $0x10,(%eax)
rv = -1;
10b397: be ff ff ff ff mov $0xffffffff,%esi
10b39c: eb 8c jmp 10b32a <unmount+0x66>
}
} else {
errno = EACCES;
10b39e: e8 ad 7d 00 00 call 113150 <__errno>
10b3a3: c7 00 0d 00 00 00 movl $0xd,(%eax)
rv = -1;
10b3a9: be ff ff ff ff mov $0xffffffff,%esi
10b3ae: e9 77 ff ff ff jmp 10b32a <unmount+0x66>
0010afa0 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
10afa0: 55 push %ebp
10afa1: 57 push %edi
10afa2: 56 push %esi
10afa3: 53 push %ebx
10afa4: 83 ec 5c sub $0x5c,%esp
10afa7: 8b 5c 24 70 mov 0x70(%esp),%ebx
for (; *fmt != '\0'; fmt++) {
10afab: 0f be 03 movsbl (%ebx),%eax
10afae: 84 c0 test %al,%al
10afb0: 0f 84 96 01 00 00 je 10b14c <vprintk+0x1ac> <== NEVER TAKEN
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
10afb6: 8d 54 24 3b lea 0x3b(%esp),%edx
10afba: 89 54 24 1c mov %edx,0x1c(%esp)
10afbe: eb 19 jmp 10afd9 <vprintk+0x39>
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
rtems_putc(*fmt);
10afc0: 89 04 24 mov %eax,(%esp)
10afc3: e8 f8 50 00 00 call 1100c0 <rtems_putc>
continue;
10afc8: 89 dd mov %ebx,%ebp
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
10afca: 8d 5d 01 lea 0x1(%ebp),%ebx
10afcd: 0f be 45 01 movsbl 0x1(%ebp),%eax
10afd1: 84 c0 test %al,%al
10afd3: 0f 84 73 01 00 00 je 10b14c <vprintk+0x1ac>
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
10afd9: 3c 25 cmp $0x25,%al
10afdb: 75 e3 jne 10afc0 <vprintk+0x20>
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
10afdd: 0f be 43 01 movsbl 0x1(%ebx),%eax
10afe1: 3c 30 cmp $0x30,%al
10afe3: 0f 84 b7 01 00 00 je 10b1a0 <vprintk+0x200>
if (*fmt != '%') {
rtems_putc(*fmt);
continue;
}
fmt++;
10afe9: 8d 6b 01 lea 0x1(%ebx),%ebp
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
10afec: c6 44 24 28 20 movb $0x20,0x28(%esp)
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
10aff1: 3c 2d cmp $0x2d,%al
10aff3: 0f 84 97 01 00 00 je 10b190 <vprintk+0x1f0>
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
10aff9: c6 44 24 20 00 movb $0x0,0x20(%esp)
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10affe: 8d 50 d0 lea -0x30(%eax),%edx
10b001: 31 f6 xor %esi,%esi
10b003: 80 fa 09 cmp $0x9,%dl
10b006: 77 14 ja 10b01c <vprintk+0x7c>
width *= 10;
10b008: 8d 14 b6 lea (%esi,%esi,4),%edx
width += ((unsigned) *fmt - '0');
10b00b: 8d 74 50 d0 lea -0x30(%eax,%edx,2),%esi
fmt++;
10b00f: 45 inc %ebp
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10b010: 0f be 45 00 movsbl 0x0(%ebp),%eax
10b014: 8d 50 d0 lea -0x30(%eax),%edx
10b017: 80 fa 09 cmp $0x9,%dl
10b01a: 76 ec jbe 10b008 <vprintk+0x68>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
10b01c: 3c 6c cmp $0x6c,%al
10b01e: 0f 84 40 01 00 00 je 10b164 <vprintk+0x1c4>
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
10b024: 3c 63 cmp $0x63,%al
10b026: 0f 84 45 01 00 00 je 10b171 <vprintk+0x1d1>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
rtems_putc(chr);
continue;
}
if ( c == 's' ) {
10b02c: 3c 73 cmp $0x73,%al
10b02e: 0f 84 80 01 00 00 je 10b1b4 <vprintk+0x214>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
10b034: 3c 6f cmp $0x6f,%al
10b036: 0f 84 18 01 00 00 je 10b154 <vprintk+0x1b4>
10b03c: 3c 4f cmp $0x4f,%al
10b03e: 0f 84 10 01 00 00 je 10b154 <vprintk+0x1b4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
10b044: 3c 69 cmp $0x69,%al
10b046: 74 44 je 10b08c <vprintk+0xec>
10b048: 3c 49 cmp $0x49,%al
10b04a: 74 40 je 10b08c <vprintk+0xec>
10b04c: 3c 64 cmp $0x64,%al
10b04e: 74 3c je 10b08c <vprintk+0xec>
c == 'd' || c == 'D' ) {
10b050: 3c 44 cmp $0x44,%al
10b052: 74 38 je 10b08c <vprintk+0xec>
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
10b054: 3c 75 cmp $0x75,%al
10b056: 0f 84 0a 02 00 00 je 10b266 <vprintk+0x2c6>
10b05c: 3c 55 cmp $0x55,%al
10b05e: 0f 84 02 02 00 00 je 10b266 <vprintk+0x2c6>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
10b064: 3c 78 cmp $0x78,%al
10b066: 0f 84 3d 02 00 00 je 10b2a9 <vprintk+0x309>
10b06c: 3c 58 cmp $0x58,%al
10b06e: 0f 84 35 02 00 00 je 10b2a9 <vprintk+0x309>
base = 16; sign = false;
} else if ( c == 'p' ) {
10b074: 3c 70 cmp $0x70,%al
10b076: 0f 84 2d 02 00 00 je 10b2a9 <vprintk+0x309>
base = 16; sign = false; lflag = true;
} else {
rtems_putc(c);
10b07c: 89 04 24 mov %eax,(%esp)
10b07f: e8 3c 50 00 00 call 1100c0 <rtems_putc>
continue;
10b084: e9 41 ff ff ff jmp 10afca <vprintk+0x2a>
10b089: 8d 76 00 lea 0x0(%esi),%esi
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
10b08c: b0 01 mov $0x1,%al
10b08e: c7 44 24 20 0a 00 00 movl $0xa,0x20(%esp)
10b095: 00
} else {
rtems_putc(c);
continue;
}
printNum(
10b096: 8b 54 24 74 mov 0x74(%esp),%edx
10b09a: 8b 1a mov (%edx),%ebx
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
10b09c: 83 c2 04 add $0x4,%edx
10b09f: 89 54 24 74 mov %edx,0x74(%esp)
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
10b0a3: 84 c0 test %al,%al
10b0a5: 74 08 je 10b0af <vprintk+0x10f>
10b0a7: 85 db test %ebx,%ebx
10b0a9: 0f 88 c6 01 00 00 js 10b275 <vprintk+0x2d5>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10b0af: 89 d8 mov %ebx,%eax
10b0b1: 31 d2 xor %edx,%edx
10b0b3: f7 74 24 20 divl 0x20(%esp)
10b0b7: 89 c1 mov %eax,%ecx
10b0b9: 85 c0 test %eax,%eax
10b0bb: 0f 84 da 01 00 00 je 10b29b <vprintk+0x2fb>
10b0c1: 8a 44 24 20 mov 0x20(%esp),%al
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
10b0c5: 31 ff xor %edi,%edi
10b0c7: 89 74 24 2c mov %esi,0x2c(%esp)
10b0cb: 8b 74 24 20 mov 0x20(%esp),%esi
10b0cf: 89 da mov %ebx,%edx
10b0d1: 88 c3 mov %al,%bl
10b0d3: eb 05 jmp 10b0da <vprintk+0x13a>
10b0d5: 8d 76 00 lea 0x0(%esi),%esi
while ((n = unsigned_num / base) > 0) {
10b0d8: 89 c1 mov %eax,%ecx
toPrint[count++] = (char) (unsigned_num - (n * base));
10b0da: 88 d8 mov %bl,%al
10b0dc: f6 e1 mul %cl
10b0de: 29 c2 sub %eax,%edx
10b0e0: 88 54 3c 3c mov %dl,0x3c(%esp,%edi,1)
10b0e4: 47 inc %edi
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10b0e5: 89 c8 mov %ecx,%eax
10b0e7: 31 d2 xor %edx,%edx
10b0e9: f7 f6 div %esi
10b0eb: 89 ca mov %ecx,%edx
10b0ed: 85 c0 test %eax,%eax
10b0ef: 75 e7 jne 10b0d8 <vprintk+0x138>
10b0f1: 8b 74 24 2c mov 0x2c(%esp),%esi
10b0f5: 8d 5f 01 lea 0x1(%edi),%ebx
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
10b0f8: 88 4c 3c 3c mov %cl,0x3c(%esp,%edi,1)
for (n=maxwidth ; n > count; n-- )
10b0fc: 39 f3 cmp %esi,%ebx
10b0fe: 73 15 jae 10b115 <vprintk+0x175>
10b100: 0f be 7c 24 28 movsbl 0x28(%esp),%edi
10b105: 8d 76 00 lea 0x0(%esi),%esi
rtems_putc(lead);
10b108: 89 3c 24 mov %edi,(%esp)
10b10b: e8 b0 4f 00 00 call 1100c0 <rtems_putc>
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
10b110: 4e dec %esi
10b111: 39 f3 cmp %esi,%ebx
10b113: 72 f3 jb 10b108 <vprintk+0x168>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
10b115: 8d 74 1c 3b lea 0x3b(%esp,%ebx,1),%esi
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
10b119: 85 db test %ebx,%ebx
10b11b: 0f 84 a9 fe ff ff je 10afca <vprintk+0x2a> <== NEVER TAKEN
10b121: 8d 76 00 lea 0x0(%esi),%esi
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
10b124: 0f be 06 movsbl (%esi),%eax
10b127: 0f be 80 14 17 12 00 movsbl 0x121714(%eax),%eax
10b12e: 89 04 24 mov %eax,(%esp)
10b131: e8 8a 4f 00 00 call 1100c0 <rtems_putc>
10b136: 4e dec %esi
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
10b137: 3b 74 24 1c cmp 0x1c(%esp),%esi
10b13b: 75 e7 jne 10b124 <vprintk+0x184>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
10b13d: 8d 5d 01 lea 0x1(%ebp),%ebx
10b140: 0f be 45 01 movsbl 0x1(%ebp),%eax
10b144: 84 c0 test %al,%al
10b146: 0f 85 8d fe ff ff jne 10afd9 <vprintk+0x39> <== ALWAYS TAKEN
sign,
width,
lead
);
}
}
10b14c: 83 c4 5c add $0x5c,%esp
10b14f: 5b pop %ebx
10b150: 5e pop %esi
10b151: 5f pop %edi
10b152: 5d pop %ebp
10b153: c3 ret
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
10b154: 31 c0 xor %eax,%eax
10b156: c7 44 24 20 08 00 00 movl $0x8,0x20(%esp)
10b15d: 00
10b15e: e9 33 ff ff ff jmp 10b096 <vprintk+0xf6>
10b163: 90 nop
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
10b164: 0f be 45 01 movsbl 0x1(%ebp),%eax
10b168: 45 inc %ebp
}
if ( c == 'c' ) {
10b169: 3c 63 cmp $0x63,%al
10b16b: 0f 85 bb fe ff ff jne 10b02c <vprintk+0x8c> <== ALWAYS TAKEN
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
10b171: 8b 5c 24 74 mov 0x74(%esp),%ebx
10b175: 83 c3 04 add $0x4,%ebx
rtems_putc(chr);
10b178: 8b 54 24 74 mov 0x74(%esp),%edx
10b17c: 0f be 02 movsbl (%edx),%eax
10b17f: 89 04 24 mov %eax,(%esp)
10b182: e8 39 4f 00 00 call 1100c0 <rtems_putc>
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
10b187: 89 5c 24 74 mov %ebx,0x74(%esp)
rtems_putc(chr);
continue;
10b18b: e9 3a fe ff ff jmp 10afca <vprintk+0x2a>
10b190: 0f be 45 01 movsbl 0x1(%ebp),%eax
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
fmt++;
10b194: 45 inc %ebp
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
10b195: c6 44 24 20 01 movb $0x1,0x20(%esp)
10b19a: e9 5f fe ff ff jmp 10affe <vprintk+0x5e>
10b19f: 90 nop
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
10b1a0: 8d 6b 02 lea 0x2(%ebx),%ebp
10b1a3: 0f be 43 02 movsbl 0x2(%ebx),%eax
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
10b1a7: c6 44 24 28 30 movb $0x30,0x28(%esp)
10b1ac: e9 40 fe ff ff jmp 10aff1 <vprintk+0x51>
10b1b1: 8d 76 00 lea 0x0(%esi),%esi
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10b1b4: 8b 44 24 74 mov 0x74(%esp),%eax
10b1b8: 83 c0 04 add $0x4,%eax
10b1bb: 89 44 24 28 mov %eax,0x28(%esp)
10b1bf: 8b 54 24 74 mov 0x74(%esp),%edx
10b1c3: 8b 02 mov (%edx),%eax
if ( str == NULL ) {
10b1c5: 85 c0 test %eax,%eax
10b1c7: 0f 84 eb 00 00 00 je 10b2b8 <vprintk+0x318>
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
10b1cd: 31 db xor %ebx,%ebx
10b1cf: 80 38 00 cmpb $0x0,(%eax)
10b1d2: 74 07 je 10b1db <vprintk+0x23b>
10b1d4: 43 inc %ebx
10b1d5: 80 3c 18 00 cmpb $0x0,(%eax,%ebx,1)
10b1d9: 75 f9 jne 10b1d4 <vprintk+0x234>
;
/* leading spaces */
if ( !minus )
10b1db: 80 7c 24 20 00 cmpb $0x0,0x20(%esp)
10b1e0: 75 1f jne 10b201 <vprintk+0x261>
for ( i=len ; i<width ; i++ )
10b1e2: 39 f3 cmp %esi,%ebx
10b1e4: 73 1b jae 10b201 <vprintk+0x261>
10b1e6: 89 df mov %ebx,%edi
10b1e8: 89 44 24 24 mov %eax,0x24(%esp)
rtems_putc(' ');
10b1ec: c7 04 24 20 00 00 00 movl $0x20,(%esp)
10b1f3: e8 c8 4e 00 00 call 1100c0 <rtems_putc>
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
10b1f8: 47 inc %edi
10b1f9: 39 f7 cmp %esi,%edi
10b1fb: 72 ef jb 10b1ec <vprintk+0x24c>
10b1fd: 8b 44 24 24 mov 0x24(%esp),%eax
rtems_putc(' ');
/* no width option */
if (width == 0) {
10b201: 85 f6 test %esi,%esi
10b203: 75 0a jne 10b20f <vprintk+0x26f>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10b205: 85 db test %ebx,%ebx
10b207: 0f 84 b5 00 00 00 je 10b2c2 <vprintk+0x322>
10b20d: 89 de mov %ebx,%esi
10b20f: 0f be 10 movsbl (%eax),%edx
10b212: 84 d2 test %dl,%dl
10b214: 74 26 je 10b23c <vprintk+0x29c> <== NEVER TAKEN
rtems_putc(*str);
10b216: 89 14 24 mov %edx,(%esp)
10b219: 89 44 24 18 mov %eax,0x18(%esp)
10b21d: e8 9e 4e 00 00 call 1100c0 <rtems_putc>
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10b222: 8b 44 24 18 mov 0x18(%esp),%eax
10b226: 8d 78 01 lea 0x1(%eax),%edi
10b229: eb 0a jmp 10b235 <vprintk+0x295>
10b22b: 90 nop
rtems_putc(*str);
10b22c: 89 04 24 mov %eax,(%esp)
10b22f: e8 8c 4e 00 00 call 1100c0 <rtems_putc>
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10b234: 47 inc %edi
10b235: 0f be 07 movsbl (%edi),%eax
10b238: 84 c0 test %al,%al
10b23a: 75 f0 jne 10b22c <vprintk+0x28c>
rtems_putc(*str);
/* trailing spaces */
if ( minus )
10b23c: 80 7c 24 20 00 cmpb $0x0,0x20(%esp)
10b241: 74 16 je 10b259 <vprintk+0x2b9>
for ( i=len ; i<width ; i++ )
10b243: 39 f3 cmp %esi,%ebx
10b245: 73 7b jae 10b2c2 <vprintk+0x322>
10b247: 90 nop
rtems_putc(' ');
10b248: c7 04 24 20 00 00 00 movl $0x20,(%esp)
10b24f: e8 6c 4e 00 00 call 1100c0 <rtems_putc>
for ( i=0 ; i<width && *str ; str++ )
rtems_putc(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
10b254: 43 inc %ebx
10b255: 39 f3 cmp %esi,%ebx
10b257: 72 ef jb 10b248 <vprintk+0x2a8>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10b259: 8b 44 24 28 mov 0x28(%esp),%eax
10b25d: 89 44 24 74 mov %eax,0x74(%esp)
10b261: e9 64 fd ff ff jmp 10afca <vprintk+0x2a>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
10b266: 31 c0 xor %eax,%eax
10b268: c7 44 24 20 0a 00 00 movl $0xa,0x20(%esp)
10b26f: 00
10b270: e9 21 fe ff ff jmp 10b096 <vprintk+0xf6>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
rtems_putc('-');
10b275: c7 04 24 2d 00 00 00 movl $0x2d,(%esp)
10b27c: e8 3f 4e 00 00 call 1100c0 <rtems_putc>
unsigned_num = (unsigned long) -num;
10b281: f7 db neg %ebx
if (maxwidth) maxwidth--;
10b283: 83 fe 01 cmp $0x1,%esi
10b286: 83 d6 ff adc $0xffffffff,%esi
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10b289: 89 d8 mov %ebx,%eax
10b28b: 31 d2 xor %edx,%edx
10b28d: f7 74 24 20 divl 0x20(%esp)
10b291: 89 c1 mov %eax,%ecx
10b293: 85 c0 test %eax,%eax
10b295: 0f 85 26 fe ff ff jne 10b0c1 <vprintk+0x121> <== ALWAYS TAKEN
10b29b: 89 d9 mov %ebx,%ecx
10b29d: bb 01 00 00 00 mov $0x1,%ebx
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
10b2a2: 31 ff xor %edi,%edi
10b2a4: e9 4f fe ff ff jmp 10b0f8 <vprintk+0x158>
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
10b2a9: 31 c0 xor %eax,%eax
10b2ab: c7 44 24 20 10 00 00 movl $0x10,0x20(%esp)
10b2b2: 00
10b2b3: e9 de fd ff ff jmp 10b096 <vprintk+0xf6>
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
10b2b8: b8 61 16 12 00 mov $0x121661,%eax
10b2bd: e9 0b ff ff ff jmp 10b1cd <vprintk+0x22d>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10b2c2: 8b 54 24 28 mov 0x28(%esp),%edx
10b2c6: 89 54 24 74 mov %edx,0x74(%esp)
10b2ca: e9 fb fc ff ff jmp 10afca <vprintk+0x2a>
0011f700 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11f700: 53 push %ebx
11f701: 83 ec 08 sub $0x8,%esp
11f704: 8b 44 24 10 mov 0x10(%esp),%eax
11f708: 8b 54 24 14 mov 0x14(%esp),%edx
11f70c: 8b 4c 24 18 mov 0x18(%esp),%ecx
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11f710: 3b 05 c0 b2 12 00 cmp 0x12b2c0,%eax
11f716: 73 44 jae 11f75c <write+0x5c>
iop = rtems_libio_iop( fd );
11f718: 8d 04 40 lea (%eax,%eax,2),%eax
11f71b: c1 e0 04 shl $0x4,%eax
11f71e: 03 05 d4 f4 12 00 add 0x12f4d4,%eax
rtems_libio_check_is_open( iop );
11f724: 8b 58 0c mov 0xc(%eax),%ebx
11f727: f6 c7 01 test $0x1,%bh
11f72a: 74 30 je 11f75c <write+0x5c>
rtems_libio_check_buffer( buffer );
11f72c: 85 d2 test %edx,%edx
11f72e: 74 3e je 11f76e <write+0x6e> <== NEVER TAKEN
rtems_libio_check_count( count );
11f730: 85 c9 test %ecx,%ecx
11f732: 74 20 je 11f754 <write+0x54>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
11f734: 83 e3 04 and $0x4,%ebx
11f737: 74 23 je 11f75c <write+0x5c>
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11f739: 8b 58 20 mov 0x20(%eax),%ebx
11f73c: 89 4c 24 18 mov %ecx,0x18(%esp)
11f740: 89 54 24 14 mov %edx,0x14(%esp)
11f744: 89 44 24 10 mov %eax,0x10(%esp)
11f748: 8b 43 0c mov 0xc(%ebx),%eax
}
11f74b: 83 c4 08 add $0x8,%esp
11f74e: 5b pop %ebx
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11f74f: ff e0 jmp *%eax
11f751: 8d 76 00 lea 0x0(%esi),%esi
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
11f754: 31 c0 xor %eax,%eax
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
}
11f756: 83 c4 08 add $0x8,%esp
11f759: 5b pop %ebx
11f75a: c3 ret
11f75b: 90 nop
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
11f75c: e8 97 35 ff ff call 112cf8 <__errno>
11f761: c7 00 09 00 00 00 movl $0x9,(%eax)
11f767: b8 ff ff ff ff mov $0xffffffff,%eax
11f76c: eb e8 jmp 11f756 <write+0x56>
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
11f76e: e8 85 35 ff ff call 112cf8 <__errno> <== NOT EXECUTED
11f773: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
11f779: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
11f77e: eb d6 jmp 11f756 <write+0x56> <== NOT EXECUTED
0010bfc8 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10bfc8: 55 push %ebp
10bfc9: 57 push %edi
10bfca: 56 push %esi
10bfcb: 53 push %ebx
10bfcc: 83 ec 1c sub $0x1c,%esp
10bfcf: 8b 54 24 30 mov 0x30(%esp),%edx
10bfd3: 8b 5c 24 34 mov 0x34(%esp),%ebx
10bfd7: 8b 44 24 38 mov 0x38(%esp),%eax
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10bfdb: 3b 15 c0 c2 12 00 cmp 0x12c2c0,%edx
10bfe1: 0f 83 c3 00 00 00 jae 10c0aa <writev+0xe2> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
10bfe7: 8d 3c 52 lea (%edx,%edx,2),%edi
10bfea: c1 e7 04 shl $0x4,%edi
10bfed: 03 3d d4 04 13 00 add 0x1304d4,%edi
rtems_libio_check_is_open( iop );
10bff3: 8b 57 0c mov 0xc(%edi),%edx
10bff6: f6 c6 01 test $0x1,%dh
10bff9: 0f 84 ab 00 00 00 je 10c0aa <writev+0xe2>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
10bfff: 83 e2 04 and $0x4,%edx
10c002: 0f 84 a2 00 00 00 je 10c0aa <writev+0xe2> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10c008: 85 db test %ebx,%ebx
10c00a: 0f 84 80 00 00 00 je 10c090 <writev+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10c010: 85 c0 test %eax,%eax
10c012: 7e 7c jle 10c090 <writev+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10c014: 3d 00 04 00 00 cmp $0x400,%eax
10c019: 7f 75 jg 10c090 <writev+0xc8> <== NEVER TAKEN
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
10c01b: 8d 34 c3 lea (%ebx,%eax,8),%esi
10c01e: 89 d8 mov %ebx,%eax
10c020: bd 01 00 00 00 mov $0x1,%ebp
10c025: 31 d2 xor %edx,%edx
10c027: eb 05 jmp 10c02e <writev+0x66>
10c029: 8d 76 00 lea 0x0(%esi),%esi
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
10c02c: 89 ca mov %ecx,%edx
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
10c02e: 8b 08 mov (%eax),%ecx
10c030: 85 c9 test %ecx,%ecx
10c032: 74 5c je 10c090 <writev+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
10c034: 8b 48 04 mov 0x4(%eax),%ecx
10c037: 85 c9 test %ecx,%ecx
10c039: 74 02 je 10c03d <writev+0x75>
all_zeros = false;
10c03b: 31 ed xor %ebp,%ebp
/* check for wrap */
old = total;
total += iov[v].iov_len;
10c03d: 01 d1 add %edx,%ecx
if ( total < old || total > SSIZE_MAX )
10c03f: 39 d1 cmp %edx,%ecx
10c041: 7c 4d jl 10c090 <writev+0xc8>
10c043: 83 c0 08 add $0x8,%eax
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
10c046: 39 f0 cmp %esi,%eax
10c048: 75 e2 jne 10c02c <writev+0x64>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10c04a: 89 e8 mov %ebp,%eax
return 0;
10c04c: 31 ed xor %ebp,%ebp
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10c04e: 84 c0 test %al,%al
10c050: 75 4e jne 10c0a0 <writev+0xd8>
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
10c052: 8b 53 04 mov 0x4(%ebx),%edx
10c055: 85 d2 test %edx,%edx
10c057: 75 11 jne 10c06a <writev+0xa2> <== ALWAYS TAKEN
10c059: 8d 76 00 lea 0x0(%esi),%esi
10c05c: 83 c3 08 add $0x8,%ebx
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10c05f: 39 f3 cmp %esi,%ebx
10c061: 74 3d je 10c0a0 <writev+0xd8>
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
10c063: 8b 53 04 mov 0x4(%ebx),%edx
10c066: 85 d2 test %edx,%edx
10c068: 74 f2 je 10c05c <writev+0x94> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
10c06a: 8b 47 20 mov 0x20(%edi),%eax
10c06d: 89 54 24 08 mov %edx,0x8(%esp)
10c071: 8b 13 mov (%ebx),%edx
10c073: 89 54 24 04 mov %edx,0x4(%esp)
10c077: 89 3c 24 mov %edi,(%esp)
10c07a: ff 50 0c call *0xc(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10c07d: 83 f8 00 cmp $0x0,%eax
10c080: 7c 3a jl 10c0bc <writev+0xf4> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10c082: 74 02 je 10c086 <writev+0xbe> <== NEVER TAKEN
total += bytes;
10c084: 01 c5 add %eax,%ebp
}
if (bytes != iov[ v ].iov_len)
10c086: 3b 43 04 cmp 0x4(%ebx),%eax
10c089: 74 d1 je 10c05c <writev+0x94> <== ALWAYS TAKEN
10c08b: eb 13 jmp 10c0a0 <writev+0xd8> <== NOT EXECUTED
10c08d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
10c090: e8 87 77 00 00 call 11381c <__errno>
10c095: c7 00 16 00 00 00 movl $0x16,(%eax)
10c09b: bd ff ff ff ff mov $0xffffffff,%ebp
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10c0a0: 89 e8 mov %ebp,%eax
10c0a2: 83 c4 1c add $0x1c,%esp
10c0a5: 5b pop %ebx
10c0a6: 5e pop %esi
10c0a7: 5f pop %edi
10c0a8: 5d pop %ebp
10c0a9: c3 ret
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
10c0aa: e8 6d 77 00 00 call 11381c <__errno>
10c0af: c7 00 09 00 00 00 movl $0x9,(%eax)
10c0b5: bd ff ff ff ff mov $0xffffffff,%ebp
10c0ba: eb e4 jmp 10c0a0 <writev+0xd8>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10c0bc: bd ff ff ff ff mov $0xffffffff,%ebp <== NOT EXECUTED
10c0c1: eb dd jmp 10c0a0 <writev+0xd8> <== NOT EXECUTED