=============================================================================== 001208e4 : static rtems_printk_plugin_t print_handler; static void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 1208e4: 55 push %ebp <== NOT EXECUTED 1208e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1208e7: 57 push %edi <== NOT EXECUTED 1208e8: 56 push %esi <== NOT EXECUTED 1208e9: 53 push %ebx <== NOT EXECUTED 1208ea: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 1208ed: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Obtain interrupt stack information */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { 1208f0: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 1208f3: 75 1d jne 120912 <== NOT EXECUTED if (!Stack_check_Interrupt_stack.area) 1208f5: 83 3d 1c ec 16 00 00 cmpl $0x0,0x16ec1c <== NOT EXECUTED 1208fc: 0f 84 f2 00 00 00 je 1209f4 <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 120902: bf 18 ec 16 00 mov $0x16ec18,%edi <== NOT EXECUTED the_thread = 0; current = 0; 120907: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) <== 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; 12090e: 31 db xor %ebx,%ebx <== NOT EXECUTED 120910: eb 0f jmp 120921 <== NOT EXECUTED current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 120912: 8d bb b4 00 00 00 lea 0xb4(%ebx),%edi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 120918: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx <== NOT EXECUTED 12091e: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 120921: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 120924: 8d 50 10 lea 0x10(%eax),%edx <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 120927: 8b 0f mov (%edi),%ecx <== NOT EXECUTED 120929: 83 e9 10 sub $0x10,%ecx <== NOT EXECUTED 12092c: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 12092f: 83 c0 20 add $0x20,%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 120932: 83 e1 fc and $0xfffffffc,%ecx <== NOT EXECUTED 120935: 01 c1 add %eax,%ecx <== NOT EXECUTED 120937: eb 0b jmp 120944 <== NOT EXECUTED if (*base != U32_PATTERN) 120939: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 12093f: 75 0b jne 12094c <== 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++) 120941: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 120944: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 120946: 72 f1 jb 120939 <== 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; 120948: 31 f6 xor %esi,%esi <== NOT EXECUTED 12094a: eb 0d jmp 120959 <== NOT EXECUTED 12094c: 31 f6 xor %esi,%esi <== NOT EXECUTED low = Stack_check_usable_stack_start(stack); size = Stack_check_usable_stack_size(stack); high_water_mark = Stack_check_find_high_water_mark(low, size); if ( high_water_mark ) 12094e: 85 c0 test %eax,%eax <== NOT EXECUTED 120950: 74 07 je 120959 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 120952: 8b 75 d4 mov -0x2c(%ebp),%esi <== NOT EXECUTED 120955: 01 d6 add %edx,%esi <== NOT EXECUTED 120957: 29 c6 sub %eax,%esi <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 120959: 85 db test %ebx,%ebx <== NOT EXECUTED 12095b: 74 31 je 12098e <== NOT EXECUTED #endif { (*print_handler)( 12095d: 8b 0d 48 da 16 00 mov 0x16da48,%ecx <== NOT EXECUTED 120963: 50 push %eax <== NOT EXECUTED 120964: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 120967: 50 push %eax <== NOT EXECUTED 120968: 6a 05 push $0x5 <== NOT EXECUTED 12096a: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 12096d: 89 4d cc mov %ecx,-0x34(%ebp) <== NOT EXECUTED 120970: e8 0f fc fe ff call 110584 <== NOT EXECUTED 120975: 50 push %eax <== NOT EXECUTED 120976: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 120979: 68 3b ff 14 00 push $0x14ff3b <== NOT EXECUTED 12097e: ff 35 44 da 16 00 pushl 0x16da44 <== NOT EXECUTED 120984: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 120987: ff d1 call *%ecx <== NOT EXECUTED 120989: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 12098c: eb 17 jmp 1209a5 <== 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 ); 12098e: 53 push %ebx <== NOT EXECUTED 12098f: 6a ff push $0xffffffff <== NOT EXECUTED 120991: 68 48 ff 14 00 push $0x14ff48 <== NOT EXECUTED 120996: ff 35 44 da 16 00 pushl 0x16da44 <== NOT EXECUTED 12099c: ff 15 48 da 16 00 call *0x16da48 <== NOT EXECUTED 1209a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (*print_handler)( print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 1209a5: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 1209a8: 51 push %ecx <== NOT EXECUTED 1209a9: 51 push %ecx <== NOT EXECUTED 1209aa: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1209ad: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 1209b0: 8b 17 mov (%edi),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 1209b2: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 1209b6: 52 push %edx <== NOT EXECUTED 1209b7: 50 push %eax <== NOT EXECUTED 1209b8: 68 56 ff 14 00 push $0x14ff56 <== NOT EXECUTED 1209bd: ff 35 44 da 16 00 pushl 0x16da44 <== NOT EXECUTED 1209c3: ff 15 48 da 16 00 call *0x16da48 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 1209c9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1209cc: 83 3d 40 da 16 00 00 cmpl $0x0,0x16da40 <== NOT EXECUTED 1209d3: 75 09 jne 1209de <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 1209d5: 52 push %edx <== NOT EXECUTED 1209d6: 52 push %edx <== NOT EXECUTED 1209d7: 68 74 ff 14 00 push $0x14ff74 <== NOT EXECUTED 1209dc: eb 07 jmp 1209e5 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 1209de: 50 push %eax <== NOT EXECUTED 1209df: 56 push %esi <== NOT EXECUTED 1209e0: 68 81 ff 14 00 push $0x14ff81 <== NOT EXECUTED 1209e5: ff 35 44 da 16 00 pushl 0x16da44 <== NOT EXECUTED 1209eb: ff 15 48 da 16 00 call *0x16da48 <== NOT EXECUTED 1209f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 1209f4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1209f7: 5b pop %ebx <== NOT EXECUTED 1209f8: 5e pop %esi <== NOT EXECUTED 1209f9: 5f pop %edi <== NOT EXECUTED 1209fa: 5d pop %ebp <== NOT EXECUTED 1209fb: c3 ret <== NOT EXECUTED =============================================================================== 00120aaa : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 120aaa: 55 push %ebp <== NOT EXECUTED 120aab: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120aad: 56 push %esi <== NOT EXECUTED 120aae: 53 push %ebx <== NOT EXECUTED 120aaf: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 120ab2: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 120ab5: 8a 4d 0c mov 0xc(%ebp),%cl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 120ab8: 8b b3 b8 00 00 00 mov 0xb8(%ebx),%esi <== NOT EXECUTED char name[32]; printk("BLOWN STACK!!!\n"); 120abe: 68 87 ff 14 00 push $0x14ff87 <== NOT EXECUTED 120ac3: 88 4d d4 mov %cl,-0x2c(%ebp) <== NOT EXECUTED 120ac6: e8 91 67 fe ff call 10725c <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 120acb: 58 pop %eax <== NOT EXECUTED 120acc: 5a pop %edx <== NOT EXECUTED 120acd: 53 push %ebx <== NOT EXECUTED 120ace: 68 97 ff 14 00 push $0x14ff97 <== NOT EXECUTED 120ad3: e8 84 67 fe ff call 10725c <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 120ad8: 59 pop %ecx <== NOT EXECUTED 120ad9: 58 pop %eax <== NOT EXECUTED 120ada: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 120add: 68 b4 ff 14 00 push $0x14ffb4 <== NOT EXECUTED 120ae2: e8 75 67 fe ff call 10725c <== NOT EXECUTED printk( 120ae7: 58 pop %eax <== NOT EXECUTED 120ae8: 5a pop %edx <== NOT EXECUTED 120ae9: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 120aec: 68 c6 ff 14 00 push $0x14ffc6 <== NOT EXECUTED 120af1: e8 66 67 fe ff call 10725c <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 120af6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 120af9: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 120afc: 50 push %eax <== NOT EXECUTED 120afd: 6a 20 push $0x20 <== NOT EXECUTED 120aff: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 120b02: e8 7d fa fe ff call 110584 <== NOT EXECUTED 120b07: 59 pop %ecx <== NOT EXECUTED 120b08: 5a pop %edx <== NOT EXECUTED 120b09: 50 push %eax <== NOT EXECUTED 120b0a: 68 da ff 14 00 push $0x14ffda <== NOT EXECUTED 120b0f: e8 48 67 fe ff call 10725c <== 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) 120b14: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED 120b1a: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED ); printk( "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 120b20: 8d 1c 02 lea (%edx,%eax,1),%ebx <== NOT EXECUTED 120b23: 53 push %ebx <== NOT EXECUTED 120b24: 52 push %edx <== NOT EXECUTED 120b25: 50 push %eax <== NOT EXECUTED 120b26: 68 f0 ff 14 00 push $0x14fff0 <== NOT EXECUTED 120b2b: e8 2c 67 fe ff call 10725c <== 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) { 120b30: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 120b33: 8a 4d d4 mov -0x2c(%ebp),%cl <== NOT EXECUTED 120b36: 84 c9 test %cl,%cl <== NOT EXECUTED 120b38: 75 17 jne 120b51 <== NOT EXECUTED printk( 120b3a: 8d 46 18 lea 0x18(%esi),%eax <== NOT EXECUTED 120b3d: 50 push %eax <== 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); 120b3e: 83 c6 08 add $0x8,%esi <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 120b41: 56 push %esi <== NOT EXECUTED 120b42: 6a 10 push $0x10 <== NOT EXECUTED 120b44: 68 21 00 15 00 push $0x150021 <== NOT EXECUTED 120b49: e8 0e 67 fe ff call 10725c <== NOT EXECUTED 120b4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 120b51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120b54: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 120b59: e8 2e 96 fe ff call 10a18c <== NOT EXECUTED =============================================================================== 0010c774 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10c774: 55 push %ebp 10c775: 89 e5 mov %esp,%ebp 10c777: 53 push %ebx 10c778: 51 push %ecx 10c779: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10c77c: 8b 15 e4 18 13 00 mov 0x1318e4,%edx * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10c782: 9c pushf 10c783: fa cli 10c784: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10c785: 8b 4b 44 mov 0x44(%ebx),%ecx 10c788: 85 c9 test %ecx,%ecx 10c78a: 75 0b jne 10c797 <_CORE_RWLock_Release+0x23> _ISR_Enable( level ); 10c78c: 50 push %eax 10c78d: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10c78e: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10c795: eb 6c jmp 10c803 <_CORE_RWLock_Release+0x8f> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10c797: 49 dec %ecx 10c798: 75 09 jne 10c7a3 <_CORE_RWLock_Release+0x2f> the_rwlock->number_of_readers -= 1; if ( the_rwlock->number_of_readers != 0 ) { 10c79a: ff 4b 48 decl 0x48(%ebx) 10c79d: 74 04 je 10c7a3 <_CORE_RWLock_Release+0x2f> /* must be unlocked again */ _ISR_Enable( level ); 10c79f: 50 push %eax 10c7a0: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10c7a1: eb 60 jmp 10c803 <_CORE_RWLock_Release+0x8f> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10c7a3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10c7aa: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10c7b1: 50 push %eax 10c7b2: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10c7b3: 83 ec 0c sub $0xc,%esp 10c7b6: 53 push %ebx 10c7b7: e8 80 18 00 00 call 10e03c <_Thread_queue_Dequeue> if ( next ) { 10c7bc: 83 c4 10 add $0x10,%esp 10c7bf: 85 c0 test %eax,%eax 10c7c1: 74 40 je 10c803 <_CORE_RWLock_Release+0x8f> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10c7c3: 83 78 30 01 cmpl $0x1,0x30(%eax) 10c7c7: 75 09 jne 10c7d2 <_CORE_RWLock_Release+0x5e> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10c7c9: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10c7d0: eb 31 jmp 10c803 <_CORE_RWLock_Release+0x8f> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10c7d2: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10c7d5: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10c7dc: 83 ec 0c sub $0xc,%esp 10c7df: 53 push %ebx 10c7e0: e8 1b 1c 00 00 call 10e400 <_Thread_queue_First> if ( !next || 10c7e5: 83 c4 10 add $0x10,%esp 10c7e8: 85 c0 test %eax,%eax 10c7ea: 74 17 je 10c803 <_CORE_RWLock_Release+0x8f> 10c7ec: 83 78 30 01 cmpl $0x1,0x30(%eax) 10c7f0: 74 11 je 10c803 <_CORE_RWLock_Release+0x8f><== NEVER TAKEN next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10c7f2: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10c7f5: 52 push %edx 10c7f6: 52 push %edx 10c7f7: 50 push %eax 10c7f8: 53 push %ebx 10c7f9: e8 fa 1a 00 00 call 10e2f8 <_Thread_queue_Extract> } 10c7fe: 83 c4 10 add $0x10,%esp 10c801: eb d9 jmp 10c7dc <_CORE_RWLock_Release+0x68> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10c803: 31 c0 xor %eax,%eax 10c805: 8b 5d fc mov -0x4(%ebp),%ebx 10c808: c9 leave 10c809: c3 ret =============================================================================== 0010c80c <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10c80c: 55 push %ebp 10c80d: 89 e5 mov %esp,%ebp 10c80f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c812: 8d 45 f4 lea -0xc(%ebp),%eax 10c815: 50 push %eax 10c816: ff 75 08 pushl 0x8(%ebp) 10c819: e8 d6 14 00 00 call 10dcf4 <_Thread_Get> switch ( location ) { 10c81e: 83 c4 10 add $0x10,%esp 10c821: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c825: 75 1c jne 10c843 <_CORE_RWLock_Timeout+0x37><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10c827: 83 ec 0c sub $0xc,%esp 10c82a: 50 push %eax 10c82b: e8 84 1c 00 00 call 10e4b4 <_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--; 10c830: a1 dc 13 13 00 mov 0x1313dc,%eax 10c835: 48 dec %eax 10c836: a3 dc 13 13 00 mov %eax,0x1313dc return _Thread_Dispatch_disable_level; 10c83b: a1 dc 13 13 00 mov 0x1313dc,%eax 10c840: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c843: c9 leave 10c844: c3 ret =============================================================================== 0010a9a4 <_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 ) { 10a9a4: 55 push %ebp 10a9a5: 89 e5 mov %esp,%ebp 10a9a7: 53 push %ebx 10a9a8: 83 ec 10 sub $0x10,%esp 10a9ab: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10a9ae: 53 push %ebx 10a9af: e8 c0 17 00 00 call 10c174 <_Thread_queue_Dequeue> 10a9b4: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10a9b7: 31 d2 xor %edx,%edx if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10a9b9: 85 c0 test %eax,%eax 10a9bb: 75 15 jne 10a9d2 <_CORE_semaphore_Surrender+0x2e> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10a9bd: 9c pushf 10a9be: fa cli 10a9bf: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10a9c0: 8b 43 48 mov 0x48(%ebx),%eax the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10a9c3: b2 04 mov $0x4,%dl (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10a9c5: 3b 43 40 cmp 0x40(%ebx),%eax 10a9c8: 73 06 jae 10a9d0 <_CORE_semaphore_Surrender+0x2c><== NEVER TAKEN the_semaphore->count += 1; 10a9ca: 40 inc %eax 10a9cb: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10a9ce: 30 d2 xor %dl,%dl _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10a9d0: 51 push %ecx 10a9d1: 9d popf } return status; } 10a9d2: 89 d0 mov %edx,%eax 10a9d4: 8b 5d fc mov -0x4(%ebp),%ebx 10a9d7: c9 leave 10a9d8: c3 ret =============================================================================== 00109a10 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109a10: 55 push %ebp 109a11: 89 e5 mov %esp,%ebp 109a13: 57 push %edi 109a14: 56 push %esi 109a15: 53 push %ebx 109a16: 83 ec 1c sub $0x1c,%esp 109a19: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 109a1c: 8b b3 e4 00 00 00 mov 0xe4(%ebx),%esi option_set = (rtems_option) the_thread->Wait.option; 109a22: 8b 43 30 mov 0x30(%ebx),%eax 109a25: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109a28: 9c pushf 109a29: fa cli 109a2a: 58 pop %eax pending_events = api->pending_events; 109a2b: 8b 16 mov (%esi),%edx 109a2d: 89 55 e4 mov %edx,-0x1c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109a30: 8b 4b 24 mov 0x24(%ebx),%ecx seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109a33: 21 ca and %ecx,%edx 109a35: 75 05 jne 109a3c <_Event_Surrender+0x2c> 109a37: e9 ab 00 00 00 jmp 109ae7 <_Event_Surrender+0xd7> /* * 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() && 109a3c: 83 3d e8 e8 12 00 00 cmpl $0x0,0x12e8e8 109a43: 74 47 je 109a8c <_Event_Surrender+0x7c> 109a45: 3b 1d ec e8 12 00 cmp 0x12e8ec,%ebx 109a4b: 75 3f jne 109a8c <_Event_Surrender+0x7c> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109a4d: 8b 3d c8 ec 12 00 mov 0x12ecc8,%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 ) && 109a53: 83 ff 02 cmp $0x2,%edi 109a56: 74 09 je 109a61 <_Event_Surrender+0x51> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109a58: 8b 3d c8 ec 12 00 mov 0x12ecc8,%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) || 109a5e: 4f dec %edi 109a5f: 75 2b jne 109a8c <_Event_Surrender+0x7c> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109a61: 39 ca cmp %ecx,%edx 109a63: 74 06 je 109a6b <_Event_Surrender+0x5b> 109a65: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109a69: 74 7c je 109ae7 <_Event_Surrender+0xd7> <== 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) ); 109a6b: 89 d1 mov %edx,%ecx 109a6d: f7 d1 not %ecx 109a6f: 23 4d e4 and -0x1c(%ebp),%ecx 109a72: 89 0e mov %ecx,(%esi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109a74: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109a7b: 8b 4b 28 mov 0x28(%ebx),%ecx 109a7e: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109a80: c7 05 c8 ec 12 00 03 movl $0x3,0x12ecc8 109a87: 00 00 00 109a8a: eb 5b jmp 109ae7 <_Event_Surrender+0xd7> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109a8c: f6 43 11 01 testb $0x1,0x11(%ebx) 109a90: 74 55 je 109ae7 <_Event_Surrender+0xd7> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109a92: 39 ca cmp %ecx,%edx 109a94: 74 06 je 109a9c <_Event_Surrender+0x8c> 109a96: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109a9a: 74 4b je 109ae7 <_Event_Surrender+0xd7> <== NEVER TAKEN 109a9c: 89 d1 mov %edx,%ecx 109a9e: f7 d1 not %ecx 109aa0: 23 4d e4 and -0x1c(%ebp),%ecx 109aa3: 89 0e mov %ecx,(%esi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109aa5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109aac: 8b 4b 28 mov 0x28(%ebx),%ecx 109aaf: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109ab1: 50 push %eax 109ab2: 9d popf 109ab3: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109ab4: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109ab8: 74 06 je 109ac0 <_Event_Surrender+0xb0> _ISR_Enable( level ); 109aba: 50 push %eax 109abb: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109abc: 51 push %ecx 109abd: 51 push %ecx 109abe: eb 17 jmp 109ad7 <_Event_Surrender+0xc7> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109ac0: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109ac7: 50 push %eax 109ac8: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109ac9: 83 ec 0c sub $0xc,%esp 109acc: 8d 43 48 lea 0x48(%ebx),%eax 109acf: 50 push %eax 109ad0: e8 43 2f 00 00 call 10ca18 <_Watchdog_Remove> 109ad5: 58 pop %eax 109ad6: 5a pop %edx 109ad7: 68 f8 ff 03 10 push $0x1003fff8 109adc: 53 push %ebx 109add: e8 fa 1f 00 00 call 10badc <_Thread_Clear_state> 109ae2: 83 c4 10 add $0x10,%esp 109ae5: eb 02 jmp 109ae9 <_Event_Surrender+0xd9> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109ae7: 50 push %eax 109ae8: 9d popf } 109ae9: 8d 65 f4 lea -0xc(%ebp),%esp 109aec: 5b pop %ebx 109aed: 5e pop %esi 109aee: 5f pop %edi 109aef: 5d pop %ebp 109af0: c3 ret =============================================================================== 00109af4 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109af4: 55 push %ebp 109af5: 89 e5 mov %esp,%ebp 109af7: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109afa: 8d 45 f4 lea -0xc(%ebp),%eax 109afd: 50 push %eax 109afe: ff 75 08 pushl 0x8(%ebp) 109b01: e8 26 23 00 00 call 10be2c <_Thread_Get> switch ( location ) { 109b06: 83 c4 10 add $0x10,%esp 109b09: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109b0d: 75 4e jne 109b5d <_Event_Timeout+0x69> <== 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 ); 109b0f: 9c pushf 109b10: fa cli 109b11: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109b12: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109b19: 3b 05 ec e8 12 00 cmp 0x12e8ec,%eax 109b1f: 75 13 jne 109b34 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109b21: 8b 0d c8 ec 12 00 mov 0x12ecc8,%ecx 109b27: 49 dec %ecx 109b28: 75 0a jne 109b34 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109b2a: c7 05 c8 ec 12 00 02 movl $0x2,0x12ecc8 109b31: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109b34: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109b3b: 52 push %edx 109b3c: 9d popf 109b3d: 52 push %edx 109b3e: 52 push %edx 109b3f: 68 f8 ff 03 10 push $0x1003fff8 109b44: 50 push %eax 109b45: e8 92 1f 00 00 call 10badc <_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--; 109b4a: a1 e4 e3 12 00 mov 0x12e3e4,%eax 109b4f: 48 dec %eax 109b50: a3 e4 e3 12 00 mov %eax,0x12e3e4 return _Thread_Dispatch_disable_level; 109b55: a1 e4 e3 12 00 mov 0x12e3e4,%eax 109b5a: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109b5d: c9 leave 109b5e: c3 ret =============================================================================== 0010f33f <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10f33f: 55 push %ebp 10f340: 89 e5 mov %esp,%ebp 10f342: 57 push %edi 10f343: 56 push %esi 10f344: 53 push %ebx 10f345: 83 ec 4c sub $0x4c,%esp 10f348: 8b 5d 08 mov 0x8(%ebp),%ebx 10f34b: 8b 45 10 mov 0x10(%ebp),%eax Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10f34e: 8b 4b 20 mov 0x20(%ebx),%ecx 10f351: 89 4d b8 mov %ecx,-0x48(%ebp) Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 10f354: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) Heap_Block *extend_last_block = NULL; 10f35b: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) uintptr_t const page_size = heap->page_size; 10f362: 8b 73 10 mov 0x10(%ebx),%esi 10f365: 89 75 bc mov %esi,-0x44(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10f368: 8b 53 14 mov 0x14(%ebx),%edx 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; 10f36b: 8b 4b 30 mov 0x30(%ebx),%ecx 10f36e: 89 4d b4 mov %ecx,-0x4c(%ebp) uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 10f371: 8b 75 0c mov 0xc(%ebp),%esi 10f374: 01 c6 add %eax,%esi 10f376: 89 75 d4 mov %esi,-0x2c(%ebp) 10f379: 73 07 jae 10f382 <_Heap_Extend+0x43> return false; 10f37b: 31 c0 xor %eax,%eax 10f37d: e9 cb 01 00 00 jmp 10f54d <_Heap_Extend+0x20e> } extend_area_ok = _Heap_Get_first_and_last_block( 10f382: 51 push %ecx 10f383: 51 push %ecx 10f384: 8d 4d e4 lea -0x1c(%ebp),%ecx 10f387: 51 push %ecx 10f388: 8d 4d e0 lea -0x20(%ebp),%ecx 10f38b: 51 push %ecx 10f38c: 52 push %edx 10f38d: ff 75 bc pushl -0x44(%ebp) 10f390: 50 push %eax 10f391: ff 75 0c pushl 0xc(%ebp) 10f394: e8 89 b8 ff ff call 10ac22 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10f399: 83 c4 20 add $0x20,%esp 10f39c: 84 c0 test %al,%al 10f39e: 74 db je 10f37b <_Heap_Extend+0x3c> 10f3a0: 8b 4d b8 mov -0x48(%ebp),%ecx 10f3a3: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10f3aa: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 10f3b1: 31 ff xor %edi,%edi 10f3b3: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 10f3ba: 8b 73 18 mov 0x18(%ebx),%esi 10f3bd: 89 75 c0 mov %esi,-0x40(%ebp) 10f3c0: eb 03 jmp 10f3c5 <_Heap_Extend+0x86> 10f3c2: 89 4d c0 mov %ecx,-0x40(%ebp) uintptr_t const sub_area_end = start_block->prev_size; 10f3c5: 8b 01 mov (%ecx),%eax 10f3c7: 89 45 d0 mov %eax,-0x30(%ebp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10f3ca: 89 c6 mov %eax,%esi 10f3cc: 83 ee 08 sub $0x8,%esi 10f3cf: 31 d2 xor %edx,%edx 10f3d1: f7 75 bc divl -0x44(%ebp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10f3d4: 29 d6 sub %edx,%esi Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10f3d6: 8b 55 c0 mov -0x40(%ebp),%edx 10f3d9: 39 55 d4 cmp %edx,-0x2c(%ebp) 10f3dc: 76 08 jbe 10f3e6 <_Heap_Extend+0xa7> 10f3de: 8b 45 d0 mov -0x30(%ebp),%eax 10f3e1: 39 45 0c cmp %eax,0xc(%ebp) 10f3e4: 72 95 jb 10f37b <_Heap_Extend+0x3c> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10f3e6: 8b 55 c0 mov -0x40(%ebp),%edx 10f3e9: 39 55 d4 cmp %edx,-0x2c(%ebp) 10f3ec: 74 0a je 10f3f8 <_Heap_Extend+0xb9> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10f3ee: 8b 45 d0 mov -0x30(%ebp),%eax 10f3f1: 39 45 d4 cmp %eax,-0x2c(%ebp) 10f3f4: 72 07 jb 10f3fd <_Heap_Extend+0xbe> 10f3f6: eb 08 jmp 10f400 <_Heap_Extend+0xc1> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10f3f8: 89 4d cc mov %ecx,-0x34(%ebp) 10f3fb: eb 03 jmp 10f400 <_Heap_Extend+0xc1> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10f3fd: 89 4d c4 mov %ecx,-0x3c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10f400: 8b 55 0c mov 0xc(%ebp),%edx 10f403: 39 55 d0 cmp %edx,-0x30(%ebp) 10f406: 75 09 jne 10f411 <_Heap_Extend+0xd2> start_block->prev_size = extend_area_end; 10f408: 8b 45 d4 mov -0x2c(%ebp),%eax 10f40b: 89 01 mov %eax,(%ecx) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 10f40d: 89 f7 mov %esi,%edi 10f40f: eb 05 jmp 10f416 <_Heap_Extend+0xd7> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10f411: 73 03 jae 10f416 <_Heap_Extend+0xd7> 10f413: 89 75 c8 mov %esi,-0x38(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10f416: 8b 4e 04 mov 0x4(%esi),%ecx 10f419: 83 e1 fe and $0xfffffffe,%ecx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10f41c: 01 f1 add %esi,%ecx link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 10f41e: 3b 4d b8 cmp -0x48(%ebp),%ecx 10f421: 75 9f jne 10f3c2 <_Heap_Extend+0x83> if ( extend_area_begin < heap->area_begin ) { 10f423: 8b 4d 0c mov 0xc(%ebp),%ecx 10f426: 3b 4b 18 cmp 0x18(%ebx),%ecx 10f429: 73 05 jae 10f430 <_Heap_Extend+0xf1> heap->area_begin = extend_area_begin; 10f42b: 89 4b 18 mov %ecx,0x18(%ebx) 10f42e: eb 0b jmp 10f43b <_Heap_Extend+0xfc> } else if ( heap->area_end < extend_area_end ) { 10f430: 8b 75 d4 mov -0x2c(%ebp),%esi 10f433: 39 73 1c cmp %esi,0x1c(%ebx) 10f436: 73 03 jae 10f43b <_Heap_Extend+0xfc> heap->area_end = extend_area_end; 10f438: 89 73 1c mov %esi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10f43b: 8b 45 e4 mov -0x1c(%ebp),%eax 10f43e: 8b 55 e0 mov -0x20(%ebp),%edx heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 10f441: 89 c1 mov %eax,%ecx 10f443: 29 d1 sub %edx,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 10f445: 8b 75 d4 mov -0x2c(%ebp),%esi 10f448: 89 32 mov %esi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10f44a: 89 ce mov %ecx,%esi 10f44c: 83 ce 01 or $0x1,%esi 10f44f: 89 72 04 mov %esi,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10f452: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10f454: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 10f45b: 39 53 20 cmp %edx,0x20(%ebx) 10f45e: 76 05 jbe 10f465 <_Heap_Extend+0x126> heap->first_block = extend_first_block; 10f460: 89 53 20 mov %edx,0x20(%ebx) 10f463: eb 08 jmp 10f46d <_Heap_Extend+0x12e> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10f465: 39 43 24 cmp %eax,0x24(%ebx) 10f468: 73 03 jae 10f46d <_Heap_Extend+0x12e> heap->last_block = extend_last_block; 10f46a: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10f46d: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10f471: 74 35 je 10f4a8 <_Heap_Extend+0x169> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10f473: 8b 73 10 mov 0x10(%ebx),%esi uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 10f476: 8b 4d 0c mov 0xc(%ebp),%ecx 10f479: 83 c1 08 add $0x8,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 10f47c: 89 c8 mov %ecx,%eax 10f47e: 31 d2 xor %edx,%edx 10f480: f7 f6 div %esi if ( remainder != 0 ) { 10f482: 85 d2 test %edx,%edx 10f484: 74 04 je 10f48a <_Heap_Extend+0x14b> return value - remainder + alignment; 10f486: 01 f1 add %esi,%ecx 10f488: 29 d1 sub %edx,%ecx uintptr_t const new_first_block_begin = 10f48a: 8d 51 f8 lea -0x8(%ecx),%edx uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 10f48d: 8b 75 cc mov -0x34(%ebp),%esi 10f490: 8b 06 mov (%esi),%eax 10f492: 89 41 f8 mov %eax,-0x8(%ecx) uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = 10f495: 89 f0 mov %esi,%eax 10f497: 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; 10f499: 83 c8 01 or $0x1,%eax 10f49c: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10f49f: 89 d8 mov %ebx,%eax 10f4a1: e8 7e fe ff ff call 10f324 <_Heap_Free_block> 10f4a6: eb 11 jmp 10f4b9 <_Heap_Extend+0x17a> heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { _Heap_Merge_below( heap, extend_area_begin, merge_below_block ); } else if ( link_below_block != NULL ) { 10f4a8: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10f4ac: 74 0b je 10f4b9 <_Heap_Extend+0x17a> { 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; 10f4ae: 8b 55 c4 mov -0x3c(%ebp),%edx 10f4b1: 29 c2 sub %eax,%edx 10f4b3: 83 ca 01 or $0x1,%edx 10f4b6: 89 50 04 mov %edx,0x4(%eax) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10f4b9: 85 ff test %edi,%edi 10f4bb: 74 33 je 10f4f0 <_Heap_Extend+0x1b1> ) { 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, 10f4bd: 8b 4d d4 mov -0x2c(%ebp),%ecx 10f4c0: 83 e9 08 sub $0x8,%ecx uintptr_t extend_area_end ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( 10f4c3: 29 f9 sub %edi,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10f4c5: 89 c8 mov %ecx,%eax 10f4c7: 31 d2 xor %edx,%edx 10f4c9: f7 73 10 divl 0x10(%ebx) 10f4cc: 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) 10f4ce: 8b 47 04 mov 0x4(%edi),%eax 10f4d1: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 10f4d3: 83 c8 01 or $0x1,%eax 10f4d6: 89 44 39 04 mov %eax,0x4(%ecx,%edi,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; 10f4da: 8b 47 04 mov 0x4(%edi),%eax 10f4dd: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10f4e0: 09 c8 or %ecx,%eax 10f4e2: 89 47 04 mov %eax,0x4(%edi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10f4e5: 89 fa mov %edi,%edx 10f4e7: 89 d8 mov %ebx,%eax 10f4e9: e8 36 fe ff ff call 10f324 <_Heap_Free_block> 10f4ee: eb 20 jmp 10f510 <_Heap_Extend+0x1d1> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10f4f0: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10f4f4: 74 1a je 10f510 <_Heap_Extend+0x1d1> _Heap_Link_above( 10f4f6: 8b 4d e4 mov -0x1c(%ebp),%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; 10f4f9: 8b 75 c8 mov -0x38(%ebp),%esi 10f4fc: 8b 46 04 mov 0x4(%esi),%eax 10f4ff: 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 ); 10f502: 8b 55 e0 mov -0x20(%ebp),%edx 10f505: 29 f2 sub %esi,%edx block->size_and_flag = size | flag; 10f507: 09 d0 or %edx,%eax 10f509: 89 46 04 mov %eax,0x4(%esi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10f50c: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10f510: 85 ff test %edi,%edi 10f512: 75 10 jne 10f524 <_Heap_Extend+0x1e5> 10f514: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10f518: 75 0a jne 10f524 <_Heap_Extend+0x1e5> _Heap_Free_block( heap, extend_first_block ); 10f51a: 8b 55 e0 mov -0x20(%ebp),%edx 10f51d: 89 d8 mov %ebx,%eax 10f51f: e8 00 fe ff ff call 10f324 <_Heap_Free_block> */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( heap->last_block, (uintptr_t) heap->first_block - (uintptr_t) heap->last_block 10f524: 8b 53 24 mov 0x24(%ebx),%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; 10f527: 8b 42 04 mov 0x4(%edx),%eax 10f52a: 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( 10f52d: 8b 4b 20 mov 0x20(%ebx),%ecx 10f530: 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; 10f532: 09 c8 or %ecx,%eax 10f534: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10f537: 8b 43 30 mov 0x30(%ebx),%eax 10f53a: 2b 45 b4 sub -0x4c(%ebp),%eax /* Statistics */ stats->size += extended_size; 10f53d: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) 10f540: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10f544: 74 05 je 10f54b <_Heap_Extend+0x20c> <== NEVER TAKEN *extended_size_ptr = extended_size; 10f546: 8b 4d 14 mov 0x14(%ebp),%ecx 10f549: 89 01 mov %eax,(%ecx) return true; 10f54b: b0 01 mov $0x1,%al } 10f54d: 8d 65 f4 lea -0xc(%ebp),%esp 10f550: 5b pop %ebx 10f551: 5e pop %esi 10f552: 5f pop %edi 10f553: 5d pop %ebp 10f554: c3 ret =============================================================================== 0010f2d4 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f2d4: 55 push %ebp 10f2d5: 89 e5 mov %esp,%ebp 10f2d7: 57 push %edi 10f2d8: 56 push %esi 10f2d9: 53 push %ebx 10f2da: 83 ec 14 sub $0x14,%esp 10f2dd: 8b 4d 08 mov 0x8(%ebp),%ecx 10f2e0: 8b 45 0c mov 0xc(%ebp),%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 ) { 10f2e3: 85 c0 test %eax,%eax 10f2e5: 0f 84 46 01 00 00 je 10f431 <_Heap_Free+0x15d> 10f2eb: 8d 58 f8 lea -0x8(%eax),%ebx 10f2ee: 31 d2 xor %edx,%edx 10f2f0: 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); 10f2f3: 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 10f2f5: 8b 41 20 mov 0x20(%ecx),%eax 10f2f8: 89 45 e8 mov %eax,-0x18(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f2fb: 31 d2 xor %edx,%edx 10f2fd: 39 c3 cmp %eax,%ebx 10f2ff: 72 08 jb 10f309 <_Heap_Free+0x35> 10f301: 31 d2 xor %edx,%edx 10f303: 39 59 24 cmp %ebx,0x24(%ecx) 10f306: 0f 93 c2 setae %dl 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; 10f309: 31 c0 xor %eax,%eax } 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 ) ) { 10f30b: 85 d2 test %edx,%edx 10f30d: 0f 84 20 01 00 00 je 10f433 <_Heap_Free+0x15f> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f313: 8b 43 04 mov 0x4(%ebx),%eax 10f316: 89 45 ec mov %eax,-0x14(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10f319: 89 c7 mov %eax,%edi 10f31b: 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); 10f31e: 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; 10f321: 31 f6 xor %esi,%esi 10f323: 3b 55 e8 cmp -0x18(%ebp),%edx 10f326: 72 0a jb 10f332 <_Heap_Free+0x5e> <== NEVER TAKEN 10f328: 31 c0 xor %eax,%eax 10f32a: 39 51 24 cmp %edx,0x24(%ecx) 10f32d: 0f 93 c0 setae %al 10f330: 89 c6 mov %eax,%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; 10f332: 31 c0 xor %eax,%eax _Heap_Protection_block_check( heap, block ); block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10f334: 85 f6 test %esi,%esi 10f336: 0f 84 f7 00 00 00 je 10f433 <_Heap_Free+0x15f> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f33c: 8b 72 04 mov 0x4(%edx),%esi return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 10f33f: f7 c6 01 00 00 00 test $0x1,%esi 10f345: 0f 84 e8 00 00 00 je 10f433 <_Heap_Free+0x15f> <== 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; 10f34b: 83 e6 fe and $0xfffffffe,%esi 10f34e: 89 75 f0 mov %esi,-0x10(%ebp) if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 10f351: 8b 41 24 mov 0x24(%ecx),%eax 10f354: 89 45 e0 mov %eax,-0x20(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f357: 39 c2 cmp %eax,%edx 10f359: 74 0c je 10f367 <_Heap_Free+0x93> 10f35b: 8b 74 32 04 mov 0x4(%edx,%esi,1),%esi 10f35f: 83 f6 01 xor $0x1,%esi 10f362: 83 e6 01 and $0x1,%esi 10f365: eb 02 jmp 10f369 <_Heap_Free+0x95> 10f367: 31 f6 xor %esi,%esi 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 10f369: 89 f0 mov %esi,%eax 10f36b: 88 45 e7 mov %al,-0x19(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 10f36e: f6 45 ec 01 testb $0x1,-0x14(%ebp) 10f372: 75 5e jne 10f3d2 <_Heap_Free+0xfe> uintptr_t const prev_size = block->prev_size; 10f374: 8b 33 mov (%ebx),%esi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10f376: 29 f3 sub %esi,%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; 10f378: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) 10f37f: 3b 5d e8 cmp -0x18(%ebp),%ebx 10f382: 72 0b jb 10f38f <_Heap_Free+0xbb> <== NEVER TAKEN 10f384: 31 c0 xor %eax,%eax 10f386: 39 5d e0 cmp %ebx,-0x20(%ebp) 10f389: 0f 93 c0 setae %al 10f38c: 89 45 ec mov %eax,-0x14(%ebp) 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; 10f38f: 31 c0 xor %eax,%eax if ( !_Heap_Is_prev_used( block ) ) { uintptr_t const prev_size = block->prev_size; Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size ); if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) { 10f391: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) 10f395: 0f 84 98 00 00 00 je 10f433 <_Heap_Free+0x15f> <== 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) ) { 10f39b: f6 43 04 01 testb $0x1,0x4(%ebx) 10f39f: 0f 84 8e 00 00 00 je 10f433 <_Heap_Free+0x15f> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f3a5: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10f3a9: 8d 34 37 lea (%edi,%esi,1),%esi 10f3ac: 74 14 je 10f3c2 <_Heap_Free+0xee> uintptr_t const size = block_size + prev_size + next_block_size; 10f3ae: 03 75 f0 add -0x10(%ebp),%esi return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 10f3b1: 8b 42 08 mov 0x8(%edx),%eax Heap_Block *prev = block->prev; 10f3b4: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f3b7: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 10f3ba: 89 50 0c mov %edx,0xc(%eax) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f3bd: ff 49 38 decl 0x38(%ecx) 10f3c0: eb 2d jmp 10f3ef <_Heap_Free+0x11b> 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; 10f3c2: 89 f0 mov %esi,%eax 10f3c4: 83 c8 01 or $0x1,%eax 10f3c7: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f3ca: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f3ce: 89 32 mov %esi,(%edx) 10f3d0: eb 56 jmp 10f428 <_Heap_Free+0x154> } } else if ( next_is_free ) { /* coalesce next */ 10f3d2: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10f3d6: 74 24 je 10f3fc <_Heap_Free+0x128> uintptr_t const size = block_size + next_block_size; 10f3d8: 8b 75 f0 mov -0x10(%ebp),%esi 10f3db: 01 fe add %edi,%esi RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace( Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *next = old_block->next; 10f3dd: 8b 42 08 mov 0x8(%edx),%eax Heap_Block *prev = old_block->prev; 10f3e0: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f3e3: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = prev; 10f3e6: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f3e9: 89 58 0c mov %ebx,0xc(%eax) prev->next = new_block; 10f3ec: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f3ef: 89 f0 mov %esi,%eax 10f3f1: 83 c8 01 or $0x1,%eax 10f3f4: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f3f7: 89 34 1e mov %esi,(%esi,%ebx,1) 10f3fa: eb 2c jmp 10f428 <_Heap_Free+0x154> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10f3fc: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f3ff: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f402: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f405: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f408: 89 58 0c mov %ebx,0xc(%eax) } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 10f40b: 89 f8 mov %edi,%eax 10f40d: 83 c8 01 or $0x1,%eax 10f410: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f413: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f417: 89 3a mov %edi,(%edx) /* Statistics */ ++stats->free_blocks; 10f419: 8b 41 38 mov 0x38(%ecx),%eax 10f41c: 40 inc %eax 10f41d: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f420: 39 41 3c cmp %eax,0x3c(%ecx) 10f423: 73 03 jae 10f428 <_Heap_Free+0x154> stats->max_free_blocks = stats->free_blocks; 10f425: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f428: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f42b: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f42e: 01 79 30 add %edi,0x30(%ecx) * 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; 10f431: b0 01 mov $0x1,%al --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f433: 83 c4 14 add $0x14,%esp 10f436: 5b pop %ebx 10f437: 5e pop %esi 10f438: 5f pop %edi 10f439: 5d pop %ebp 10f43a: c3 ret =============================================================================== 0010c528 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 10c528: 55 push %ebp 10c529: 89 e5 mov %esp,%ebp 10c52b: 57 push %edi 10c52c: 56 push %esi 10c52d: 53 push %ebx 10c52e: 83 ec 1c sub $0x1c,%esp 10c531: 8b 5d 08 mov 0x8(%ebp),%ebx Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10c534: 31 f6 xor %esi,%esi 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; 10c536: 31 c9 xor %ecx,%ecx Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10c538: eb 2d jmp 10c567 <_Heap_Greedy_allocate+0x3f> * @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 ); 10c53a: 6a 00 push $0x0 10c53c: 6a 00 push $0x0 10c53e: 8b 45 0c mov 0xc(%ebp),%eax 10c541: ff 34 b0 pushl (%eax,%esi,4) 10c544: 53 push %ebx 10c545: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c548: e8 bb 67 00 00 call 112d08 <_Heap_Allocate_aligned_with_boundary> void *next = _Heap_Allocate( heap, block_sizes [i] ); if ( next != NULL ) { 10c54d: 83 c4 10 add $0x10,%esp 10c550: 85 c0 test %eax,%eax 10c552: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c555: 74 0f je 10c566 <_Heap_Greedy_allocate+0x3e><== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10c557: 8d 78 f8 lea -0x8(%eax),%edi 10c55a: 31 d2 xor %edx,%edx 10c55c: 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); 10c55f: 29 d7 sub %edx,%edi Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 10c561: 89 4f 08 mov %ecx,0x8(%edi) 10c564: 89 f9 mov %edi,%ecx Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10c566: 46 inc %esi 10c567: 3b 75 10 cmp 0x10(%ebp),%esi 10c56a: 75 ce jne 10c53a <_Heap_Greedy_allocate+0x12> 10c56c: 31 f6 xor %esi,%esi 10c56e: eb 23 jmp 10c593 <_Heap_Greedy_allocate+0x6b> } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10c570: 8b 47 04 mov 0x4(%edi),%eax 10c573: 83 e0 fe and $0xfffffffe,%eax allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { _Heap_Block_allocate( 10c576: 83 e8 08 sub $0x8,%eax 10c579: 50 push %eax RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10c57a: 8d 47 08 lea 0x8(%edi),%eax 10c57d: 50 push %eax 10c57e: 57 push %edi 10c57f: 53 push %ebx 10c580: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c583: e8 8e 02 00 00 call 10c816 <_Heap_Block_allocate> current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 10c588: 89 77 08 mov %esi,0x8(%edi) 10c58b: 89 fe mov %edi,%esi 10c58d: 83 c4 10 add $0x10,%esp 10c590: 8b 4d e4 mov -0x1c(%ebp),%ecx return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10c593: 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 ) { 10c596: 39 df cmp %ebx,%edi 10c598: 75 d6 jne 10c570 <_Heap_Greedy_allocate+0x48> 10c59a: eb 14 jmp 10c5b0 <_Heap_Greedy_allocate+0x88> blocks = current; } while ( allocated_blocks != NULL ) { current = allocated_blocks; allocated_blocks = allocated_blocks->next; 10c59c: 8b 79 08 mov 0x8(%ecx),%edi _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 10c59f: 50 push %eax 10c5a0: 50 push %eax RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10c5a1: 83 c1 08 add $0x8,%ecx 10c5a4: 51 push %ecx 10c5a5: 53 push %ebx 10c5a6: e8 b5 68 00 00 call 112e60 <_Heap_Free> 10c5ab: 83 c4 10 add $0x10,%esp blocks = current; } while ( allocated_blocks != NULL ) { current = allocated_blocks; allocated_blocks = allocated_blocks->next; 10c5ae: 89 f9 mov %edi,%ecx current->next = blocks; blocks = current; } while ( allocated_blocks != NULL ) { 10c5b0: 85 c9 test %ecx,%ecx 10c5b2: 75 e8 jne 10c59c <_Heap_Greedy_allocate+0x74> allocated_blocks = allocated_blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); } return blocks; } 10c5b4: 89 f0 mov %esi,%eax 10c5b6: 8d 65 f4 lea -0xc(%ebp),%esp 10c5b9: 5b pop %ebx 10c5ba: 5e pop %esi 10c5bb: 5f pop %edi 10c5bc: 5d pop %ebp 10c5bd: c3 ret =============================================================================== 00112620 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 112620: 55 push %ebp 112621: 89 e5 mov %esp,%ebp 112623: 56 push %esi 112624: 53 push %ebx 112625: 8b 45 08 mov 0x8(%ebp),%eax Heap_Block *current = heap->first_block; 112628: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *end = heap->last_block; 11262b: 8b 58 24 mov 0x24(%eax),%ebx bool stop = false; 11262e: 31 c0 xor %eax,%eax while ( !stop && current != end ) { 112630: eb 1f jmp 112651 <_Heap_Iterate+0x31> 112632: 8b 42 04 mov 0x4(%edx),%eax 112635: 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); 112638: 8d 34 02 lea (%edx,%eax,1),%esi 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 ); 11263b: ff 75 10 pushl 0x10(%ebp) 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; 11263e: 8b 4e 04 mov 0x4(%esi),%ecx 112641: 83 e1 01 and $0x1,%ecx 112644: 51 push %ecx 112645: 50 push %eax 112646: 52 push %edx 112647: 8b 55 0c mov 0xc(%ebp),%edx 11264a: ff d2 call *%edx 11264c: 89 f2 mov %esi,%edx 11264e: 83 c4 10 add $0x10,%esp { Heap_Block *current = heap->first_block; Heap_Block *end = heap->last_block; bool stop = false; while ( !stop && current != end ) { 112651: 39 da cmp %ebx,%edx 112653: 74 04 je 112659 <_Heap_Iterate+0x39> 112655: fe c8 dec %al 112657: 75 d9 jne 112632 <_Heap_Iterate+0x12> <== ALWAYS TAKEN stop = (*visitor)( current, size, used, visitor_arg ); current = next; } } 112659: 8d 65 f8 lea -0x8(%ebp),%esp 11265c: 5b pop %ebx 11265d: 5e pop %esi 11265e: 5d pop %ebp 11265f: c3 ret =============================================================================== 0010f534 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 10f534: 55 push %ebp 10f535: 89 e5 mov %esp,%ebp 10f537: 57 push %edi 10f538: 56 push %esi 10f539: 53 push %ebx 10f53a: 8b 5d 08 mov 0x8(%ebp),%ebx 10f53d: 8b 75 0c mov 0xc(%ebp),%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10f540: 8d 4e f8 lea -0x8(%esi),%ecx 10f543: 89 f0 mov %esi,%eax 10f545: 31 d2 xor %edx,%edx 10f547: 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); 10f54a: 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 10f54c: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f54f: 31 ff xor %edi,%edi 10f551: 39 d1 cmp %edx,%ecx 10f553: 72 0a jb 10f55f <_Heap_Size_of_alloc_area+0x2b> 10f555: 31 c0 xor %eax,%eax 10f557: 39 4b 24 cmp %ecx,0x24(%ebx) 10f55a: 0f 93 c0 setae %al 10f55d: 89 c7 mov %eax,%edi Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10f55f: 31 c0 xor %eax,%eax uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10f561: 85 ff test %edi,%edi 10f563: 74 30 je 10f595 <_Heap_Size_of_alloc_area+0x61> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10f565: 8b 41 04 mov 0x4(%ecx),%eax 10f568: 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); 10f56b: 01 c1 add %eax,%ecx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f56d: 31 ff xor %edi,%edi 10f56f: 39 d1 cmp %edx,%ecx 10f571: 72 0a jb 10f57d <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 10f573: 31 c0 xor %eax,%eax 10f575: 39 4b 24 cmp %ecx,0x24(%ebx) 10f578: 0f 93 c0 setae %al 10f57b: 89 c7 mov %eax,%edi return false; 10f57d: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 10f57f: 85 ff test %edi,%edi 10f581: 74 12 je 10f595 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 10f583: f6 41 04 01 testb $0x1,0x4(%ecx) 10f587: 74 0c je 10f595 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 10f589: 29 f1 sub %esi,%ecx 10f58b: 8d 51 04 lea 0x4(%ecx),%edx 10f58e: 8b 45 10 mov 0x10(%ebp),%eax 10f591: 89 10 mov %edx,(%eax) return true; 10f593: b0 01 mov $0x1,%al } 10f595: 5b pop %ebx 10f596: 5e pop %esi 10f597: 5f pop %edi 10f598: 5d pop %ebp 10f599: c3 ret =============================================================================== 0010b5d2 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10b5d2: 55 push %ebp 10b5d3: 89 e5 mov %esp,%ebp 10b5d5: 57 push %edi 10b5d6: 56 push %esi 10b5d7: 53 push %ebx 10b5d8: 83 ec 3c sub $0x3c,%esp 10b5db: 8b 7d 0c mov 0xc(%ebp),%edi uintptr_t const page_size = heap->page_size; 10b5de: 8b 4d 08 mov 0x8(%ebp),%ecx 10b5e1: 8b 49 10 mov 0x10(%ecx),%ecx 10b5e4: 89 4d e0 mov %ecx,-0x20(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10b5e7: 8b 4d 08 mov 0x8(%ebp),%ecx 10b5ea: 8b 49 14 mov 0x14(%ecx),%ecx 10b5ed: 89 4d d8 mov %ecx,-0x28(%ebp) Heap_Block *const first_block = heap->first_block; 10b5f0: 8b 4d 08 mov 0x8(%ebp),%ecx 10b5f3: 8b 71 20 mov 0x20(%ecx),%esi Heap_Block *const last_block = heap->last_block; 10b5f6: 8b 49 24 mov 0x24(%ecx),%ecx 10b5f9: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10b5fc: bb 94 b5 10 00 mov $0x10b594,%ebx 10b601: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10b605: 74 05 je 10b60c <_Heap_Walk+0x3a> 10b607: bb 99 b5 10 00 mov $0x10b599,%ebx if ( !_System_state_Is_up( _System_state_Get() ) ) { 10b60c: 83 3d a8 05 13 00 03 cmpl $0x3,0x1305a8 10b613: 74 07 je 10b61c <_Heap_Walk+0x4a> return true; 10b615: b0 01 mov $0x1,%al 10b617: e9 ec 02 00 00 jmp 10b908 <_Heap_Walk+0x336> 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)( 10b61c: 50 push %eax 10b61d: 8b 4d 08 mov 0x8(%ebp),%ecx 10b620: ff 71 0c pushl 0xc(%ecx) 10b623: ff 71 08 pushl 0x8(%ecx) 10b626: ff 75 d4 pushl -0x2c(%ebp) 10b629: 56 push %esi 10b62a: ff 71 1c pushl 0x1c(%ecx) 10b62d: ff 71 18 pushl 0x18(%ecx) 10b630: ff 75 d8 pushl -0x28(%ebp) 10b633: ff 75 e0 pushl -0x20(%ebp) 10b636: 68 e4 07 12 00 push $0x1207e4 10b63b: 6a 00 push $0x0 10b63d: 57 push %edi 10b63e: ff d3 call *%ebx heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10b640: 83 c4 30 add $0x30,%esp 10b643: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 10b647: 75 0b jne 10b654 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10b649: 50 push %eax 10b64a: 68 75 08 12 00 push $0x120875 10b64f: e9 d5 00 00 00 jmp 10b729 <_Heap_Walk+0x157> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10b654: f6 45 e0 03 testb $0x3,-0x20(%ebp) 10b658: 74 0d je 10b667 <_Heap_Walk+0x95> (*printer)( 10b65a: ff 75 e0 pushl -0x20(%ebp) 10b65d: 68 88 08 12 00 push $0x120888 10b662: e9 c2 00 00 00 jmp 10b729 <_Heap_Walk+0x157> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b667: 8b 45 d8 mov -0x28(%ebp),%eax 10b66a: 31 d2 xor %edx,%edx 10b66c: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10b66f: 85 d2 test %edx,%edx 10b671: 74 0d je 10b680 <_Heap_Walk+0xae> (*printer)( 10b673: ff 75 d8 pushl -0x28(%ebp) 10b676: 68 a6 08 12 00 push $0x1208a6 10b67b: e9 a9 00 00 00 jmp 10b729 <_Heap_Walk+0x157> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10b680: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b683: 31 d2 xor %edx,%edx 10b685: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10b688: 85 d2 test %edx,%edx 10b68a: 74 0b je 10b697 <_Heap_Walk+0xc5> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10b68c: 56 push %esi 10b68d: 68 ca 08 12 00 push $0x1208ca 10b692: e9 92 00 00 00 jmp 10b729 <_Heap_Walk+0x157> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10b697: f6 46 04 01 testb $0x1,0x4(%esi) 10b69b: 75 0b jne 10b6a8 <_Heap_Walk+0xd6> (*printer)( 10b69d: 50 push %eax 10b69e: 68 fb 08 12 00 push $0x1208fb 10b6a3: e9 81 00 00 00 jmp 10b729 <_Heap_Walk+0x157> - 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; 10b6a8: 8b 4d d4 mov -0x2c(%ebp),%ecx 10b6ab: 8b 41 04 mov 0x4(%ecx),%eax 10b6ae: 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); 10b6b1: 01 c8 add %ecx,%eax 10b6b3: 89 45 d0 mov %eax,-0x30(%ebp) ); return false; } if ( _Heap_Is_free( last_block ) ) { 10b6b6: f6 40 04 01 testb $0x1,0x4(%eax) 10b6ba: 75 08 jne 10b6c4 <_Heap_Walk+0xf2> (*printer)( 10b6bc: 50 push %eax 10b6bd: 68 29 09 12 00 push $0x120929 10b6c2: eb 65 jmp 10b729 <_Heap_Walk+0x157> ); return false; } if ( 10b6c4: 39 75 d0 cmp %esi,-0x30(%ebp) 10b6c7: 74 08 je 10b6d1 <_Heap_Walk+0xff> _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10b6c9: 56 push %esi 10b6ca: 68 3e 09 12 00 push $0x12093e 10b6cf: eb 58 jmp 10b729 <_Heap_Walk+0x157> int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10b6d1: 8b 4d 08 mov 0x8(%ebp),%ecx 10b6d4: 8b 49 10 mov 0x10(%ecx),%ecx 10b6d7: 89 4d e4 mov %ecx,-0x1c(%ebp) return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10b6da: 8b 45 08 mov 0x8(%ebp),%eax 10b6dd: 8b 48 08 mov 0x8(%eax),%ecx const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); 10b6e0: 89 c6 mov %eax,%esi 10b6e2: eb 6d jmp 10b751 <_Heap_Walk+0x17f> 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; 10b6e4: 31 c0 xor %eax,%eax 10b6e6: 8b 55 08 mov 0x8(%ebp),%edx 10b6e9: 39 4a 20 cmp %ecx,0x20(%edx) 10b6ec: 77 08 ja 10b6f6 <_Heap_Walk+0x124> 10b6ee: 31 c0 xor %eax,%eax 10b6f0: 39 4a 24 cmp %ecx,0x24(%edx) 10b6f3: 0f 93 c0 setae %al const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { 10b6f6: 85 c0 test %eax,%eax 10b6f8: 75 08 jne 10b702 <_Heap_Walk+0x130> (*printer)( 10b6fa: 51 push %ecx 10b6fb: 68 6d 09 12 00 push $0x12096d 10b700: eb 27 jmp 10b729 <_Heap_Walk+0x157> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10b702: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b705: 31 d2 xor %edx,%edx 10b707: f7 75 e4 divl -0x1c(%ebp) ); return false; } if ( 10b70a: 85 d2 test %edx,%edx 10b70c: 74 08 je 10b716 <_Heap_Walk+0x144> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10b70e: 51 push %ecx 10b70f: 68 8d 09 12 00 push $0x12098d 10b714: eb 13 jmp 10b729 <_Heap_Walk+0x157> - 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; 10b716: 8b 41 04 mov 0x4(%ecx),%eax 10b719: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10b71c: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10b721: 74 13 je 10b736 <_Heap_Walk+0x164> (*printer)( 10b723: 51 push %ecx 10b724: 68 bd 09 12 00 push $0x1209bd 10b729: 6a 01 push $0x1 10b72b: 57 push %edi 10b72c: ff d3 call *%ebx 10b72e: 83 c4 10 add $0x10,%esp 10b731: e9 c3 01 00 00 jmp 10b8f9 <_Heap_Walk+0x327> ); return false; } if ( free_block->prev != prev_block ) { 10b736: 8b 41 0c mov 0xc(%ecx),%eax 10b739: 39 f0 cmp %esi,%eax 10b73b: 74 0f je 10b74c <_Heap_Walk+0x17a> (*printer)( 10b73d: 83 ec 0c sub $0xc,%esp 10b740: 50 push %eax 10b741: 51 push %ecx 10b742: 68 d9 09 12 00 push $0x1209d9 10b747: e9 42 01 00 00 jmp 10b88e <_Heap_Walk+0x2bc> return false; } prev_block = free_block; free_block = free_block->next; 10b74c: 89 ce mov %ecx,%esi 10b74e: 8b 49 08 mov 0x8(%ecx),%ecx const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10b751: 3b 4d 08 cmp 0x8(%ebp),%ecx 10b754: 75 8e jne 10b6e4 <_Heap_Walk+0x112> 10b756: 8b 75 d0 mov -0x30(%ebp),%esi block = next_block; } while ( block != first_block ); return true; } 10b759: 8b 46 04 mov 0x4(%esi),%eax 10b75c: 89 c1 mov %eax,%ecx 10b75e: 83 e1 fe and $0xfffffffe,%ecx 10b761: 89 4d e4 mov %ecx,-0x1c(%ebp) 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; 10b764: 83 e0 01 and $0x1,%eax 10b767: 89 45 c8 mov %eax,-0x38(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10b76a: 01 f1 add %esi,%ecx 10b76c: 89 4d dc mov %ecx,-0x24(%ebp) 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; 10b76f: 3b 75 d4 cmp -0x2c(%ebp),%esi 10b772: 0f 95 c1 setne %cl 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; 10b775: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10b77c: 8b 55 dc mov -0x24(%ebp),%edx 10b77f: 8b 45 08 mov 0x8(%ebp),%eax 10b782: 39 50 20 cmp %edx,0x20(%eax) 10b785: 77 0c ja 10b793 <_Heap_Walk+0x1c1> <== NEVER TAKEN 10b787: 39 50 24 cmp %edx,0x24(%eax) 10b78a: 0f 93 c0 setae %al 10b78d: 0f b6 c0 movzbl %al,%eax 10b790: 89 45 cc mov %eax,-0x34(%ebp) if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10b793: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10b797: 75 11 jne 10b7aa <_Heap_Walk+0x1d8> (*printer)( 10b799: 83 ec 0c sub $0xc,%esp 10b79c: ff 75 dc pushl -0x24(%ebp) 10b79f: 56 push %esi 10b7a0: 68 0b 0a 12 00 push $0x120a0b 10b7a5: e9 e4 00 00 00 jmp 10b88e <_Heap_Walk+0x2bc> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b7aa: 8b 45 e4 mov -0x1c(%ebp),%eax 10b7ad: 31 d2 xor %edx,%edx 10b7af: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10b7b2: 85 d2 test %edx,%edx 10b7b4: 74 15 je 10b7cb <_Heap_Walk+0x1f9> 10b7b6: 84 c9 test %cl,%cl 10b7b8: 74 11 je 10b7cb <_Heap_Walk+0x1f9> (*printer)( 10b7ba: 83 ec 0c sub $0xc,%esp 10b7bd: ff 75 e4 pushl -0x1c(%ebp) 10b7c0: 56 push %esi 10b7c1: 68 38 0a 12 00 push $0x120a38 10b7c6: e9 c3 00 00 00 jmp 10b88e <_Heap_Walk+0x2bc> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10b7cb: 8b 45 d8 mov -0x28(%ebp),%eax 10b7ce: 39 45 e4 cmp %eax,-0x1c(%ebp) 10b7d1: 73 15 jae 10b7e8 <_Heap_Walk+0x216> 10b7d3: 84 c9 test %cl,%cl 10b7d5: 74 11 je 10b7e8 <_Heap_Walk+0x216> <== NEVER TAKEN (*printer)( 10b7d7: 51 push %ecx 10b7d8: 51 push %ecx 10b7d9: 50 push %eax 10b7da: ff 75 e4 pushl -0x1c(%ebp) 10b7dd: 56 push %esi 10b7de: 68 66 0a 12 00 push $0x120a66 10b7e3: e9 a6 00 00 00 jmp 10b88e <_Heap_Walk+0x2bc> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10b7e8: 3b 75 dc cmp -0x24(%ebp),%esi 10b7eb: 72 15 jb 10b802 <_Heap_Walk+0x230> 10b7ed: 84 c9 test %cl,%cl 10b7ef: 74 11 je 10b802 <_Heap_Walk+0x230> (*printer)( 10b7f1: 83 ec 0c sub $0xc,%esp 10b7f4: ff 75 dc pushl -0x24(%ebp) 10b7f7: 56 push %esi 10b7f8: 68 91 0a 12 00 push $0x120a91 10b7fd: e9 8c 00 00 00 jmp 10b88e <_Heap_Walk+0x2bc> ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10b802: 8b 4d dc mov -0x24(%ebp),%ecx 10b805: f6 41 04 01 testb $0x1,0x4(%ecx) 10b809: 0f 85 b0 00 00 00 jne 10b8bf <_Heap_Walk+0x2ed> return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10b80f: 8b 45 08 mov 0x8(%ebp),%eax 10b812: 8b 48 08 mov 0x8(%eax),%ecx block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10b815: 8b 56 08 mov 0x8(%esi),%edx 10b818: 89 55 c4 mov %edx,-0x3c(%ebp) Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10b81b: 3b 50 0c cmp 0xc(%eax),%edx 10b81e: 74 14 je 10b834 <_Heap_Walk+0x262> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10b820: b8 89 06 12 00 mov $0x120689,%eax 10b825: 8b 55 08 mov 0x8(%ebp),%edx 10b828: 39 55 c4 cmp %edx,-0x3c(%ebp) 10b82b: 75 0c jne 10b839 <_Heap_Walk+0x267> 10b82d: b8 c0 07 12 00 mov $0x1207c0,%eax 10b832: eb 05 jmp 10b839 <_Heap_Walk+0x267> 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)( 10b834: b8 b1 07 12 00 mov $0x1207b1,%eax 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 ? 10b839: 8b 56 0c mov 0xc(%esi),%edx 10b83c: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10b83f: 39 ca cmp %ecx,%edx 10b841: 74 14 je 10b857 <_Heap_Walk+0x285> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10b843: ba 89 06 12 00 mov $0x120689,%edx 10b848: 8b 4d 08 mov 0x8(%ebp),%ecx 10b84b: 39 4d cc cmp %ecx,-0x34(%ebp) 10b84e: 75 0c jne 10b85c <_Heap_Walk+0x28a> 10b850: ba da 07 12 00 mov $0x1207da,%edx 10b855: eb 05 jmp 10b85c <_Heap_Walk+0x28a> 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)( 10b857: ba ca 07 12 00 mov $0x1207ca,%edx 10b85c: 83 ec 0c sub $0xc,%esp 10b85f: 50 push %eax 10b860: ff 75 c4 pushl -0x3c(%ebp) 10b863: 52 push %edx 10b864: ff 75 cc pushl -0x34(%ebp) 10b867: ff 75 e4 pushl -0x1c(%ebp) 10b86a: 56 push %esi 10b86b: 68 c5 0a 12 00 push $0x120ac5 10b870: 6a 00 push $0x0 10b872: 57 push %edi 10b873: ff d3 call *%ebx block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10b875: 8b 4d dc mov -0x24(%ebp),%ecx 10b878: 8b 01 mov (%ecx),%eax 10b87a: 83 c4 30 add $0x30,%esp 10b87d: 39 45 e4 cmp %eax,-0x1c(%ebp) 10b880: 74 16 je 10b898 <_Heap_Walk+0x2c6> (*printer)( 10b882: 52 push %edx 10b883: 51 push %ecx 10b884: 50 push %eax 10b885: ff 75 e4 pushl -0x1c(%ebp) 10b888: 56 push %esi 10b889: 68 fa 0a 12 00 push $0x120afa 10b88e: 6a 01 push $0x1 10b890: 57 push %edi 10b891: ff d3 call *%ebx 10b893: 83 c4 20 add $0x20,%esp 10b896: eb 61 jmp 10b8f9 <_Heap_Walk+0x327> ); return false; } if ( !prev_used ) { 10b898: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10b89c: 75 0b jne 10b8a9 <_Heap_Walk+0x2d7> (*printer)( 10b89e: 56 push %esi 10b89f: 68 33 0b 12 00 push $0x120b33 10b8a4: e9 80 fe ff ff jmp 10b729 <_Heap_Walk+0x157> 10b8a9: 8b 4d 08 mov 0x8(%ebp),%ecx 10b8ac: 8b 41 08 mov 0x8(%ecx),%eax 10b8af: eb 07 jmp 10b8b8 <_Heap_Walk+0x2e6> { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { if ( free_block == block ) { 10b8b1: 39 f0 cmp %esi,%eax 10b8b3: 74 33 je 10b8e8 <_Heap_Walk+0x316> return true; } free_block = free_block->next; 10b8b5: 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 ) { 10b8b8: 3b 45 08 cmp 0x8(%ebp),%eax 10b8bb: 75 f4 jne 10b8b1 <_Heap_Walk+0x2df> 10b8bd: eb 3e jmp 10b8fd <_Heap_Walk+0x32b> if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10b8bf: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10b8c3: 74 0e je 10b8d3 <_Heap_Walk+0x301> (*printer)( 10b8c5: 83 ec 0c sub $0xc,%esp 10b8c8: ff 75 e4 pushl -0x1c(%ebp) 10b8cb: 56 push %esi 10b8cc: 68 62 0b 12 00 push $0x120b62 10b8d1: eb 0d jmp 10b8e0 <_Heap_Walk+0x30e> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10b8d3: 50 push %eax 10b8d4: 50 push %eax 10b8d5: ff 36 pushl (%esi) 10b8d7: ff 75 e4 pushl -0x1c(%ebp) 10b8da: 56 push %esi 10b8db: 68 79 0b 12 00 push $0x120b79 10b8e0: 6a 00 push $0x0 10b8e2: 57 push %edi 10b8e3: ff d3 call *%ebx 10b8e5: 83 c4 20 add $0x20,%esp 10b8e8: 8b 75 dc mov -0x24(%ebp),%esi block->prev_size ); } block = next_block; } while ( block != first_block ); 10b8eb: 3b 75 d0 cmp -0x30(%ebp),%esi 10b8ee: 0f 85 65 fe ff ff jne 10b759 <_Heap_Walk+0x187> 10b8f4: e9 1c fd ff ff jmp 10b615 <_Heap_Walk+0x43> if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 10b8f9: 31 c0 xor %eax,%eax 10b8fb: eb 0b jmp 10b908 <_Heap_Walk+0x336> return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10b8fd: 56 push %esi 10b8fe: 68 9e 0b 12 00 push $0x120b9e 10b903: e9 21 fe ff ff jmp 10b729 <_Heap_Walk+0x157> block = next_block; } while ( block != first_block ); return true; } 10b908: 8d 65 f4 lea -0xc(%ebp),%esp 10b90b: 5b pop %ebx 10b90c: 5e pop %esi 10b90d: 5f pop %edi 10b90e: 5d pop %ebp 10b90f: c3 ret =============================================================================== 0010adcc <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10adcc: 55 push %ebp 10adcd: 89 e5 mov %esp,%ebp 10adcf: 53 push %ebx 10add0: 83 ec 08 sub $0x8,%esp 10add3: 8b 55 08 mov 0x8(%ebp),%edx 10add6: 8b 45 0c mov 0xc(%ebp),%eax 10add9: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10addc: 89 15 64 e4 12 00 mov %edx,0x12e464 _Internal_errors_What_happened.is_internal = is_internal; 10ade2: a2 68 e4 12 00 mov %al,0x12e468 _Internal_errors_What_happened.the_error = the_error; 10ade7: 89 1d 6c e4 12 00 mov %ebx,0x12e46c _User_extensions_Fatal( the_source, is_internal, the_error ); 10aded: 53 push %ebx 10adee: 0f b6 c0 movzbl %al,%eax 10adf1: 50 push %eax 10adf2: 52 push %edx 10adf3: e8 01 1a 00 00 call 10c7f9 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10adf8: c7 05 20 e5 12 00 05 movl $0x5,0x12e520 <== NOT EXECUTED 10adff: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10ae02: fa cli <== NOT EXECUTED 10ae03: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ae05: f4 hlt <== NOT EXECUTED 10ae06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae09: eb fe jmp 10ae09 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010ae5c <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10ae5c: 55 push %ebp 10ae5d: 89 e5 mov %esp,%ebp 10ae5f: 56 push %esi 10ae60: 53 push %ebx 10ae61: 8b 5d 08 mov 0x8(%ebp),%ebx * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10ae64: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10ae68: 75 04 jne 10ae6e <_Objects_Allocate+0x12><== ALWAYS TAKEN return NULL; 10ae6a: 31 c9 xor %ecx,%ecx 10ae6c: eb 51 jmp 10aebf <_Objects_Allocate+0x63> /* * 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 ); 10ae6e: 8d 73 20 lea 0x20(%ebx),%esi 10ae71: 83 ec 0c sub $0xc,%esp 10ae74: 56 push %esi 10ae75: e8 06 f8 ff ff call 10a680 <_Chain_Get> 10ae7a: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10ae7c: 83 c4 10 add $0x10,%esp 10ae7f: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10ae83: 74 3a je 10aebf <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10ae85: 85 c0 test %eax,%eax 10ae87: 75 1a jne 10aea3 <_Objects_Allocate+0x47> _Objects_Extend_information( information ); 10ae89: 83 ec 0c sub $0xc,%esp 10ae8c: 53 push %ebx 10ae8d: e8 56 00 00 00 call 10aee8 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10ae92: 89 34 24 mov %esi,(%esp) 10ae95: e8 e6 f7 ff ff call 10a680 <_Chain_Get> 10ae9a: 89 c1 mov %eax,%ecx } if ( the_object ) { 10ae9c: 83 c4 10 add $0x10,%esp 10ae9f: 85 c0 test %eax,%eax 10aea1: 74 c7 je 10ae6a <_Objects_Allocate+0xe> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10aea3: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10aea7: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10aeab: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10aead: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10aeb1: 31 d2 xor %edx,%edx 10aeb3: f7 f6 div %esi information->inactive_per_block[ block ]--; 10aeb5: 8b 53 30 mov 0x30(%ebx),%edx 10aeb8: ff 0c 82 decl (%edx,%eax,4) information->inactive--; 10aebb: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10aebf: 89 c8 mov %ecx,%eax 10aec1: 8d 65 f8 lea -0x8(%ebp),%esp 10aec4: 5b pop %ebx 10aec5: 5e pop %esi 10aec6: 5d pop %ebp 10aec7: c3 ret =============================================================================== 0010aee8 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10aee8: 55 push %ebp 10aee9: 89 e5 mov %esp,%ebp 10aeeb: 57 push %edi 10aeec: 56 push %esi 10aeed: 53 push %ebx 10aeee: 83 ec 3c sub $0x3c,%esp 10aef1: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10aef4: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10aef8: 89 45 c8 mov %eax,-0x38(%ebp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10aefb: 8b 73 34 mov 0x34(%ebx),%esi 10aefe: 85 f6 test %esi,%esi 10af00: 74 40 je 10af42 <_Objects_Extend_information+0x5a> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10af02: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx 10af06: 8b 43 10 mov 0x10(%ebx),%eax 10af09: 31 d2 xor %edx,%edx 10af0b: 66 f7 f1 div %cx 10af0e: 0f b7 c0 movzwl %ax,%eax 10af11: 89 45 d0 mov %eax,-0x30(%ebp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10af14: 8b 55 c8 mov -0x38(%ebp),%edx 10af17: 89 55 cc mov %edx,-0x34(%ebp) index_base = minimum_index; block = 0; 10af1a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10af21: eb 10 jmp 10af33 <_Objects_Extend_information+0x4b> if ( information->object_blocks[ block ] == NULL ) { 10af23: 8b 55 d4 mov -0x2c(%ebp),%edx 10af26: 83 3c 96 00 cmpl $0x0,(%esi,%edx,4) 10af2a: 74 31 je 10af5d <_Objects_Extend_information+0x75> * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10af2c: 01 4d cc add %ecx,-0x34(%ebp) if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10af2f: 42 inc %edx 10af30: 89 55 d4 mov %edx,-0x2c(%ebp) 10af33: 8b 55 d0 mov -0x30(%ebp),%edx 10af36: 39 55 d4 cmp %edx,-0x2c(%ebp) 10af39: 72 e8 jb 10af23 <_Objects_Extend_information+0x3b> /* * 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; 10af3b: be 01 00 00 00 mov $0x1,%esi 10af40: eb 1d jmp 10af5f <_Objects_Extend_information+0x77> minimum_index = _Objects_Get_index( information->minimum_id ); 10af42: 8b 4d c8 mov -0x38(%ebp),%ecx 10af45: 89 4d cc mov %ecx,-0x34(%ebp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10af48: be 01 00 00 00 mov $0x1,%esi minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10af4d: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10af54: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 10af5b: eb 02 jmp 10af5f <_Objects_Extend_information+0x77> else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10af5d: 31 f6 xor %esi,%esi } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10af5f: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10af63: 0f b7 53 10 movzwl 0x10(%ebx),%edx 10af67: 01 c2 add %eax,%edx 10af69: 89 55 bc mov %edx,-0x44(%ebp) /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 10af6c: 81 fa ff ff 00 00 cmp $0xffff,%edx 10af72: 0f 87 bb 01 00 00 ja 10b133 <_Objects_Extend_information+0x24b><== NEVER TAKEN /* * 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; 10af78: 0f af 43 18 imul 0x18(%ebx),%eax if ( information->auto_extend ) { 10af7c: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10af80: 74 18 je 10af9a <_Objects_Extend_information+0xb2> new_object_block = _Workspace_Allocate( block_size ); 10af82: 83 ec 0c sub $0xc,%esp 10af85: 50 push %eax 10af86: e8 b9 1b 00 00 call 10cb44 <_Workspace_Allocate> 10af8b: 89 45 c0 mov %eax,-0x40(%ebp) if ( !new_object_block ) 10af8e: 83 c4 10 add $0x10,%esp 10af91: 85 c0 test %eax,%eax 10af93: 75 14 jne 10afa9 <_Objects_Extend_information+0xc1> 10af95: e9 99 01 00 00 jmp 10b133 <_Objects_Extend_information+0x24b> return; } else { new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 10af9a: 83 ec 0c sub $0xc,%esp 10af9d: 50 push %eax 10af9e: e8 d2 1b 00 00 call 10cb75 <_Workspace_Allocate_or_fatal_error> 10afa3: 89 45 c0 mov %eax,-0x40(%ebp) 10afa6: 83 c4 10 add $0x10,%esp } /* * Do we need to grow the tables? */ if ( do_extend ) { 10afa9: 89 f0 mov %esi,%eax 10afab: 84 c0 test %al,%al 10afad: 0f 84 fd 00 00 00 je 10b0b0 <_Objects_Extend_information+0x1c8> */ /* * Up the block count and maximum */ block_count++; 10afb3: 8b 75 d0 mov -0x30(%ebp),%esi 10afb6: 46 inc %esi * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10afb7: 83 ec 0c sub $0xc,%esp /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); 10afba: 8b 55 bc mov -0x44(%ebp),%edx 10afbd: 03 55 c8 add -0x38(%ebp),%edx /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10afc0: 8d 04 76 lea (%esi,%esi,2),%eax 10afc3: 01 d0 add %edx,%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10afc5: 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 ); 10afc8: 50 push %eax 10afc9: e8 76 1b 00 00 call 10cb44 <_Workspace_Allocate> 10afce: 89 c2 mov %eax,%edx if ( !object_blocks ) { 10afd0: 83 c4 10 add $0x10,%esp 10afd3: 85 c0 test %eax,%eax 10afd5: 75 13 jne 10afea <_Objects_Extend_information+0x102> _Workspace_Free( new_object_block ); 10afd7: 83 ec 0c sub $0xc,%esp 10afda: ff 75 c0 pushl -0x40(%ebp) 10afdd: e8 7b 1b 00 00 call 10cb5d <_Workspace_Free> 10afe2: 83 c4 10 add $0x10,%esp 10afe5: e9 49 01 00 00 jmp 10b133 <_Objects_Extend_information+0x24b> 10afea: 8d 0c b0 lea (%eax,%esi,4),%ecx 10afed: 89 4d b8 mov %ecx,-0x48(%ebp) 10aff0: 8d 34 f0 lea (%eax,%esi,8),%esi 10aff3: 89 75 c4 mov %esi,-0x3c(%ebp) * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10aff6: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10affa: 31 c0 xor %eax,%eax 10affc: 3b 4d c8 cmp -0x38(%ebp),%ecx 10afff: 76 38 jbe 10b039 <_Objects_Extend_information+0x151> /* * 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, 10b001: 8b 45 d0 mov -0x30(%ebp),%eax 10b004: c1 e0 02 shl $0x2,%eax 10b007: 8b 73 34 mov 0x34(%ebx),%esi 10b00a: 89 d7 mov %edx,%edi 10b00c: 89 c1 mov %eax,%ecx 10b00e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10b010: 8b 73 30 mov 0x30(%ebx),%esi 10b013: 8b 7d b8 mov -0x48(%ebp),%edi 10b016: 89 c1 mov %eax,%ecx 10b018: 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 *) ); 10b01a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10b01e: 03 4d c8 add -0x38(%ebp),%ecx information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b021: c1 e1 02 shl $0x2,%ecx 10b024: 8b 73 1c mov 0x1c(%ebx),%esi 10b027: 8b 7d c4 mov -0x3c(%ebp),%edi 10b02a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10b02c: eb 10 jmp 10b03e <_Objects_Extend_information+0x156> /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10b02e: 8b 75 c4 mov -0x3c(%ebp),%esi 10b031: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4) } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b038: 40 inc %eax 10b039: 3b 45 c8 cmp -0x38(%ebp),%eax 10b03c: 75 f0 jne 10b02e <_Objects_Extend_information+0x146> } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10b03e: 8b 45 d0 mov -0x30(%ebp),%eax 10b041: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4) inactive_per_block[block_count] = 0; 10b048: 8b 4d b8 mov -0x48(%ebp),%ecx 10b04b: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b052: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx 10b056: 03 4d cc add -0x34(%ebp),%ecx * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10b059: 8b 45 cc mov -0x34(%ebp),%eax 10b05c: eb 0b jmp 10b069 <_Objects_Extend_information+0x181> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10b05e: 8b 75 c4 mov -0x3c(%ebp),%esi 10b061: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4) object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10b068: 40 inc %eax * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10b069: 39 c8 cmp %ecx,%eax 10b06b: 72 f1 jb 10b05e <_Objects_Extend_information+0x176> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b06d: 9c pushf 10b06e: fa cli 10b06f: 5e pop %esi old_tables = information->object_blocks; 10b070: 8b 4b 34 mov 0x34(%ebx),%ecx information->object_blocks = object_blocks; 10b073: 89 53 34 mov %edx,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10b076: 8b 45 b8 mov -0x48(%ebp),%eax 10b079: 89 43 30 mov %eax,0x30(%ebx) information->local_table = local_table; 10b07c: 8b 55 c4 mov -0x3c(%ebp),%edx 10b07f: 89 53 1c mov %edx,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10b082: 8b 45 bc mov -0x44(%ebp),%eax 10b085: 66 89 43 10 mov %ax,0x10(%ebx) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10b089: 8b 03 mov (%ebx),%eax 10b08b: c1 e0 18 shl $0x18,%eax 10b08e: 0d 00 00 01 00 or $0x10000,%eax (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10b093: 0b 45 bc or -0x44(%ebp),%eax information->maximum_id = _Objects_Build_id( 10b096: 0f b7 53 04 movzwl 0x4(%ebx),%edx 10b09a: c1 e2 1b shl $0x1b,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10b09d: 09 d0 or %edx,%eax 10b09f: 89 43 0c mov %eax,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b0a2: 56 push %esi 10b0a3: 9d popf _Workspace_Free( old_tables ); 10b0a4: 83 ec 0c sub $0xc,%esp 10b0a7: 51 push %ecx 10b0a8: e8 b0 1a 00 00 call 10cb5d <_Workspace_Free> 10b0ad: 83 c4 10 add $0x10,%esp } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10b0b0: 8b 55 d4 mov -0x2c(%ebp),%edx 10b0b3: c1 e2 02 shl $0x2,%edx 10b0b6: 89 55 d0 mov %edx,-0x30(%ebp) 10b0b9: 8b 43 34 mov 0x34(%ebx),%eax 10b0bc: 8b 4d c0 mov -0x40(%ebp),%ecx 10b0bf: 8b 55 d4 mov -0x2c(%ebp),%edx 10b0c2: 89 0c 90 mov %ecx,(%eax,%edx,4) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b0c5: ff 73 18 pushl 0x18(%ebx) 10b0c8: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10b0cc: 50 push %eax 10b0cd: 8b 43 34 mov 0x34(%ebx),%eax 10b0d0: ff 34 90 pushl (%eax,%edx,4) 10b0d3: 8d 7d dc lea -0x24(%ebp),%edi 10b0d6: 57 push %edi 10b0d7: e8 c8 f5 ff ff call 10a6a4 <_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 ) { 10b0dc: 83 c4 10 add $0x10,%esp ); /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; 10b0df: 8b 75 cc mov -0x34(%ebp),%esi information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b0e2: 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 ) { 10b0e5: eb 26 jmp 10b10d <_Objects_Extend_information+0x225> 10b0e7: 8b 13 mov (%ebx),%edx 10b0e9: c1 e2 18 shl $0x18,%edx 10b0ec: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10b0f2: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10b0f6: c1 e1 1b shl $0x1b,%ecx 10b0f9: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10b0fb: 09 f2 or %esi,%edx 10b0fd: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b100: 52 push %edx 10b101: 52 push %edx 10b102: 50 push %eax 10b103: 57 push %edi 10b104: e8 53 f5 ff ff call 10a65c <_Chain_Append> index++; 10b109: 46 inc %esi 10b10a: 83 c4 10 add $0x10,%esp /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10b10d: 83 ec 0c sub $0xc,%esp 10b110: 8d 45 dc lea -0x24(%ebp),%eax 10b113: 50 push %eax 10b114: e8 67 f5 ff ff call 10a680 <_Chain_Get> 10b119: 83 c4 10 add $0x10,%esp 10b11c: 85 c0 test %eax,%eax 10b11e: 75 c7 jne 10b0e7 <_Objects_Extend_information+0x1ff> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b120: 8b 43 14 mov 0x14(%ebx),%eax 10b123: 8b 53 30 mov 0x30(%ebx),%edx 10b126: 0f b7 c8 movzwl %ax,%ecx 10b129: 8b 75 d0 mov -0x30(%ebp),%esi 10b12c: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10b12f: 66 01 43 2c add %ax,0x2c(%ebx) } 10b133: 8d 65 f4 lea -0xc(%ebp),%esp 10b136: 5b pop %ebx 10b137: 5e pop %esi 10b138: 5f pop %edi 10b139: 5d pop %ebp 10b13a: c3 ret =============================================================================== 0010b1cc <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b1cc: 55 push %ebp 10b1cd: 89 e5 mov %esp,%ebp 10b1cf: 56 push %esi 10b1d0: 53 push %ebx 10b1d1: 8b 5d 08 mov 0x8(%ebp),%ebx 10b1d4: 0f b7 75 0c movzwl 0xc(%ebp),%esi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b1d8: 66 85 f6 test %si,%si 10b1db: 75 04 jne 10b1e1 <_Objects_Get_information+0x15> return NULL; 10b1dd: 31 c0 xor %eax,%eax 10b1df: eb 2d jmp 10b20e <_Objects_Get_information+0x42> /* * 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 ); 10b1e1: 83 ec 0c sub $0xc,%esp 10b1e4: 53 push %ebx 10b1e5: e8 b2 43 00 00 call 10f59c <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b1ea: 83 c4 10 add $0x10,%esp 10b1ed: 85 c0 test %eax,%eax 10b1ef: 74 ec je 10b1dd <_Objects_Get_information+0x11> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b1f1: 39 c6 cmp %eax,%esi 10b1f3: 77 e8 ja 10b1dd <_Objects_Get_information+0x11> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b1f5: 8b 04 9d bc e3 12 00 mov 0x12e3bc(,%ebx,4),%eax 10b1fc: 85 c0 test %eax,%eax 10b1fe: 74 dd je 10b1dd <_Objects_Get_information+0x11><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b200: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !info ) 10b203: 85 c0 test %eax,%eax 10b205: 74 d6 je 10b1dd <_Objects_Get_information+0x11><== 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 ) 10b207: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10b20c: 74 cf je 10b1dd <_Objects_Get_information+0x11> return NULL; #endif return info; } 10b20e: 8d 65 f8 lea -0x8(%ebp),%esp 10b211: 5b pop %ebx 10b212: 5e pop %esi 10b213: 5d pop %ebp 10b214: c3 ret =============================================================================== 001187b4 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 1187b4: 55 push %ebp 1187b5: 89 e5 mov %esp,%ebp 1187b7: 53 push %ebx 1187b8: 8b 55 08 mov 0x8(%ebp),%edx 1187bb: 8b 4d 10 mov 0x10(%ebp),%ecx /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 1187be: b8 01 00 00 00 mov $0x1,%eax 1187c3: 2b 42 08 sub 0x8(%edx),%eax 1187c6: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 1187c9: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 1187cd: 39 c3 cmp %eax,%ebx 1187cf: 72 12 jb 1187e3 <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 1187d1: 8b 52 1c mov 0x1c(%edx),%edx 1187d4: 8b 04 82 mov (%edx,%eax,4),%eax 1187d7: 85 c0 test %eax,%eax 1187d9: 74 08 je 1187e3 <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 1187db: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 1187e1: eb 08 jmp 1187eb <_Objects_Get_no_protection+0x37> /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 1187e3: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 1187e9: 31 c0 xor %eax,%eax } 1187eb: 5b pop %ebx 1187ec: 5d pop %ebp 1187ed: c3 ret =============================================================================== 0010e310 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10e310: 55 push %ebp 10e311: 89 e5 mov %esp,%ebp 10e313: 83 ec 18 sub $0x18,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e316: 8b 45 08 mov 0x8(%ebp),%eax 10e319: 85 c0 test %eax,%eax 10e31b: 75 08 jne 10e325 <_Objects_Id_to_name+0x15> 10e31d: a1 ec a1 13 00 mov 0x13a1ec,%eax 10e322: 8b 40 08 mov 0x8(%eax),%eax 10e325: 89 c2 mov %eax,%edx 10e327: c1 ea 18 shr $0x18,%edx 10e32a: 83 e2 07 and $0x7,%edx */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 10e32d: 8d 4a ff lea -0x1(%edx),%ecx 10e330: 83 f9 02 cmp $0x2,%ecx 10e333: 76 3d jbe 10e372 <_Objects_Id_to_name+0x62> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10e335: b8 03 00 00 00 mov $0x3,%eax 10e33a: eb 43 jmp 10e37f <_Objects_Id_to_name+0x6f> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10e33c: 89 c1 mov %eax,%ecx 10e33e: c1 e9 1b shr $0x1b,%ecx if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10e341: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10e344: 85 d2 test %edx,%edx 10e346: 74 ed je 10e335 <_Objects_Id_to_name+0x25><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10e348: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10e34c: 75 e7 jne 10e335 <_Objects_Id_to_name+0x25><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10e34e: 51 push %ecx 10e34f: 8d 4d f4 lea -0xc(%ebp),%ecx 10e352: 51 push %ecx 10e353: 50 push %eax 10e354: 52 push %edx 10e355: e8 56 ff ff ff call 10e2b0 <_Objects_Get> if ( !the_object ) 10e35a: 83 c4 10 add $0x10,%esp 10e35d: 85 c0 test %eax,%eax 10e35f: 74 d4 je 10e335 <_Objects_Id_to_name+0x25> return OBJECTS_INVALID_ID; *name = the_object->name; 10e361: 8b 50 0c mov 0xc(%eax),%edx 10e364: 8b 45 0c mov 0xc(%ebp),%eax 10e367: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e369: e8 5a 0b 00 00 call 10eec8 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10e36e: 31 c0 xor %eax,%eax 10e370: eb 0d jmp 10e37f <_Objects_Id_to_name+0x6f> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10e372: 8b 14 95 7c 9c 13 00 mov 0x139c7c(,%edx,4),%edx 10e379: 85 d2 test %edx,%edx 10e37b: 75 bf jne 10e33c <_Objects_Id_to_name+0x2c> 10e37d: eb b6 jmp 10e335 <_Objects_Id_to_name+0x25> return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10e37f: c9 leave 10e380: c3 ret =============================================================================== 00110704 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 110704: 55 push %ebp 110705: 89 e5 mov %esp,%ebp 110707: 57 push %edi 110708: 56 push %esi 110709: 53 push %ebx 11070a: 83 ec 1c sub $0x1c,%esp Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id ); 11070d: 8b 45 08 mov 0x8(%ebp),%eax 110710: 8b 40 08 mov 0x8(%eax),%eax 110713: 89 c6 mov %eax,%esi 110715: c1 ee 18 shr $0x18,%esi 110718: 83 e6 07 and $0x7,%esi for ( index = 1 ; index <= max ; ++index ) { POSIX_Keys_Control *key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table [ index ]; if ( key != NULL && key->destructor != NULL ) { void *value = key->Values [ thread_api ][ thread_index ]; 11071b: 25 ff ff 00 00 and $0xffff,%eax 110720: c1 e0 02 shl $0x2,%eax 110723: 89 45 e0 mov %eax,-0x20(%ebp) * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ while ( !done ) { Objects_Maximum index = 0; Objects_Maximum max = _POSIX_Keys_Information.maximum; 110726: a1 d0 e7 12 00 mov 0x12e7d0,%eax 11072b: 66 89 45 e6 mov %ax,-0x1a(%ebp) done = true; for ( index = 1 ; index <= max ; ++index ) { 11072f: bb 01 00 00 00 mov $0x1,%ebx */ while ( !done ) { Objects_Maximum index = 0; Objects_Maximum max = _POSIX_Keys_Information.maximum; done = true; 110734: b2 01 mov $0x1,%dl for ( index = 1 ; index <= max ; ++index ) { 110736: eb 35 jmp 11076d <_POSIX_Keys_Run_destructors+0x69> POSIX_Keys_Control *key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table [ index ]; 110738: 0f b7 cb movzwl %bx,%ecx Objects_Maximum max = _POSIX_Keys_Information.maximum; done = true; for ( index = 1 ; index <= max ; ++index ) { POSIX_Keys_Control *key = (POSIX_Keys_Control *) 11073b: a1 dc e7 12 00 mov 0x12e7dc,%eax 110740: 8b 04 88 mov (%eax,%ecx,4),%eax _POSIX_Keys_Information.local_table [ index ]; if ( key != NULL && key->destructor != NULL ) { 110743: 85 c0 test %eax,%eax 110745: 74 25 je 11076c <_POSIX_Keys_Run_destructors+0x68> 110747: 83 78 10 00 cmpl $0x0,0x10(%eax) 11074b: 74 1f je 11076c <_POSIX_Keys_Run_destructors+0x68> void *value = key->Values [ thread_api ][ thread_index ]; 11074d: 8b 7d e0 mov -0x20(%ebp),%edi 110750: 03 7c b0 14 add 0x14(%eax,%esi,4),%edi 110754: 8b 0f mov (%edi),%ecx if ( value != NULL ) { 110756: 85 c9 test %ecx,%ecx 110758: 74 12 je 11076c <_POSIX_Keys_Run_destructors+0x68><== ALWAYS TAKEN key->Values [ thread_api ][ thread_index ] = NULL; 11075a: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED (*key->destructor)( value ); 110760: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110763: 51 push %ecx <== NOT EXECUTED 110764: ff 50 10 call *0x10(%eax) <== NOT EXECUTED 110767: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done = false; 11076a: 31 d2 xor %edx,%edx <== NOT EXECUTED Objects_Maximum index = 0; Objects_Maximum max = _POSIX_Keys_Information.maximum; done = true; for ( index = 1 ; index <= max ; ++index ) { 11076c: 43 inc %ebx 11076d: 66 3b 5d e6 cmp -0x1a(%ebp),%bx 110771: 76 c5 jbe 110738 <_POSIX_Keys_Run_destructors+0x34> * number of iterations. An infinite loop may happen if destructors set * thread specific data. This can be considered dubious. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ while ( !done ) { 110773: 84 d2 test %dl,%dl 110775: 74 af je 110726 <_POSIX_Keys_Run_destructors+0x22><== NEVER TAKEN done = false; } } } } } 110777: 8d 65 f4 lea -0xc(%ebp),%esp 11077a: 5b pop %ebx 11077b: 5e pop %esi 11077c: 5f pop %edi 11077d: 5d pop %ebp 11077e: c3 ret =============================================================================== 0010dd3c <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10dd3c: 55 push %ebp 10dd3d: 89 e5 mov %esp,%ebp 10dd3f: 57 push %edi 10dd40: 56 push %esi 10dd41: 53 push %ebx 10dd42: 83 ec 30 sub $0x30,%esp 10dd45: 8b 75 08 mov 0x8(%ebp),%esi 10dd48: 8b 5d 14 mov 0x14(%ebp),%ebx 10dd4b: 8a 4d 18 mov 0x18(%ebp),%cl POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10dd4e: 8d 45 e0 lea -0x20(%ebp),%eax RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10dd51: 50 push %eax 10dd52: 56 push %esi 10dd53: 68 b4 5d 13 00 push $0x135db4 10dd58: 88 4d d4 mov %cl,-0x2c(%ebp) 10dd5b: e8 34 2b 00 00 call 110894 <_Objects_Get> switch ( location ) { 10dd60: 83 c4 10 add $0x10,%esp 10dd63: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 10dd67: 8a 4d d4 mov -0x2c(%ebp),%cl 10dd6a: 0f 85 b6 00 00 00 jne 10de26 <_POSIX_Message_queue_Receive_support+0xea> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10dd70: 8b 78 14 mov 0x14(%eax),%edi 10dd73: 89 fa mov %edi,%edx 10dd75: 83 e2 03 and $0x3,%edx 10dd78: 4a dec %edx 10dd79: 75 0a jne 10dd85 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10dd7b: e8 c4 36 00 00 call 111444 <_Thread_Enable_dispatch> 10dd80: e9 a1 00 00 00 jmp 10de26 <_POSIX_Message_queue_Receive_support+0xea> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10dd85: 8b 50 10 mov 0x10(%eax),%edx if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10dd88: 8b 42 68 mov 0x68(%edx),%eax 10dd8b: 39 45 10 cmp %eax,0x10(%ebp) 10dd8e: 73 15 jae 10dda5 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10dd90: e8 af 36 00 00 call 111444 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10dd95: e8 a6 88 00 00 call 116640 <__errno> 10dd9a: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10dda0: e9 8c 00 00 00 jmp 10de31 <_POSIX_Message_queue_Receive_support+0xf5> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10dda5: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10ddac: 31 c0 xor %eax,%eax 10ddae: 84 c9 test %cl,%cl 10ddb0: 74 0b je 10ddbd <_POSIX_Message_queue_Receive_support+0x81> do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10ddb2: 89 f8 mov %edi,%eax 10ddb4: c1 e8 0e shr $0xe,%eax 10ddb7: 83 f0 01 xor $0x1,%eax 10ddba: 83 e0 01 and $0x1,%eax do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10ddbd: 51 push %ecx 10ddbe: 51 push %ecx 10ddbf: ff 75 1c pushl 0x1c(%ebp) 10ddc2: 0f b6 c0 movzbl %al,%eax 10ddc5: 50 push %eax 10ddc6: 8d 45 e4 lea -0x1c(%ebp),%eax 10ddc9: 50 push %eax 10ddca: ff 75 0c pushl 0xc(%ebp) 10ddcd: 56 push %esi 10ddce: 83 c2 1c add $0x1c,%edx 10ddd1: 52 push %edx 10ddd2: e8 dd 1c 00 00 call 10fab4 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10ddd7: 83 c4 20 add $0x20,%esp 10ddda: e8 65 36 00 00 call 111444 <_Thread_Enable_dispatch> if (msg_prio) { 10dddf: 85 db test %ebx,%ebx 10dde1: 74 15 je 10ddf8 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN *msg_prio = _POSIX_Message_queue_Priority_from_core( _Thread_Executing->Wait.count 10dde3: 8b 15 2c 5e 13 00 mov 0x135e2c,%edx RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core( CORE_message_queue_Submit_types priority ) { /* absolute value without a library dependency */ return (unsigned int) ((priority >= 0) ? priority : -priority); 10dde9: 8b 42 24 mov 0x24(%edx),%eax 10ddec: c1 f8 1f sar $0x1f,%eax 10ddef: 8b 52 24 mov 0x24(%edx),%edx 10ddf2: 31 c2 xor %eax,%edx 10ddf4: 89 13 mov %edx,(%ebx) 10ddf6: 29 03 sub %eax,(%ebx) ); } if ( !_Thread_Executing->Wait.return_code ) 10ddf8: a1 2c 5e 13 00 mov 0x135e2c,%eax 10ddfd: 83 78 34 00 cmpl $0x0,0x34(%eax) 10de01: 75 05 jne 10de08 <_POSIX_Message_queue_Receive_support+0xcc> return length_out; 10de03: 8b 45 e4 mov -0x1c(%ebp),%eax 10de06: eb 2c jmp 10de34 <_POSIX_Message_queue_Receive_support+0xf8> rtems_set_errno_and_return_minus_one( 10de08: e8 33 88 00 00 call 116640 <__errno> 10de0d: 89 c3 mov %eax,%ebx 10de0f: 83 ec 0c sub $0xc,%esp 10de12: a1 2c 5e 13 00 mov 0x135e2c,%eax 10de17: ff 70 34 pushl 0x34(%eax) 10de1a: e8 f1 01 00 00 call 10e010 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10de1f: 89 03 mov %eax,(%ebx) 10de21: 83 c4 10 add $0x10,%esp 10de24: eb 0b jmp 10de31 <_POSIX_Message_queue_Receive_support+0xf5> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10de26: e8 15 88 00 00 call 116640 <__errno> 10de2b: c7 00 09 00 00 00 movl $0x9,(%eax) 10de31: 83 c8 ff or $0xffffffff,%eax } 10de34: 8d 65 f4 lea -0xc(%ebp),%esp 10de37: 5b pop %ebx 10de38: 5e pop %esi 10de39: 5f pop %edi 10de3a: 5d pop %ebp 10de3b: c3 ret =============================================================================== 001100d8 <_POSIX_Semaphore_Create_support>: size_t name_len, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 1100d8: 55 push %ebp 1100d9: 89 e5 mov %esp,%ebp 1100db: 56 push %esi 1100dc: 53 push %ebx 1100dd: 8b 75 08 mov 0x8(%ebp),%esi POSIX_Semaphore_Control *the_semaphore; CORE_semaphore_Attributes *the_sem_attr; char *name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) 1100e0: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1100e4: 74 0d je 1100f3 <_POSIX_Semaphore_Create_support+0x1b> rtems_set_errno_and_return_minus_one( ENOSYS ); 1100e6: e8 ad 27 00 00 call 112898 <__errno> 1100eb: c7 00 58 00 00 00 movl $0x58,(%eax) 1100f1: eb 36 jmp 110129 <_POSIX_Semaphore_Create_support+0x51> * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 1100f3: a1 b4 31 13 00 mov 0x1331b4,%eax 1100f8: 40 inc %eax 1100f9: a3 b4 31 13 00 mov %eax,0x1331b4 return _Thread_Dispatch_disable_level; 1100fe: a1 b4 31 13 00 mov 0x1331b4,%eax * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 110103: 83 ec 0c sub $0xc,%esp 110106: 68 78 34 13 00 push $0x133478 11010b: e8 a8 c5 ff ff call 10c6b8 <_Objects_Allocate> 110110: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 110112: 83 c4 10 add $0x10,%esp 110115: 85 c0 test %eax,%eax 110117: 75 18 jne 110131 <_POSIX_Semaphore_Create_support+0x59> _Thread_Enable_dispatch(); 110119: e8 9e d5 ff ff call 10d6bc <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 11011e: e8 75 27 00 00 call 112898 <__errno> 110123: c7 00 1c 00 00 00 movl $0x1c,(%eax) 110129: 83 c8 ff or $0xffffffff,%eax 11012c: e9 a4 00 00 00 jmp 1101d5 <_POSIX_Semaphore_Create_support+0xfd> /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ if ( name_arg != NULL ) { 110131: 85 f6 test %esi,%esi 110133: 74 36 je 11016b <_POSIX_Semaphore_Create_support+0x93> name = _Workspace_String_duplicate( name_arg, name_len ); 110135: 51 push %ecx 110136: 51 push %ecx 110137: ff 75 0c pushl 0xc(%ebp) 11013a: 56 push %esi 11013b: e8 d4 12 00 00 call 111414 <_Workspace_String_duplicate> 110140: 89 c6 mov %eax,%esi if ( !name ) { 110142: 83 c4 10 add $0x10,%esp 110145: 85 c0 test %eax,%eax 110147: 75 24 jne 11016d <_POSIX_Semaphore_Create_support+0x95><== ALWAYS TAKEN RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free ( POSIX_Semaphore_Control *the_semaphore ) { _Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object ); 110149: 52 push %edx <== NOT EXECUTED 11014a: 52 push %edx <== NOT EXECUTED 11014b: 53 push %ebx <== NOT EXECUTED 11014c: 68 78 34 13 00 push $0x133478 <== NOT EXECUTED 110151: e8 42 c8 ff ff call 10c998 <_Objects_Free> <== NOT EXECUTED _POSIX_Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 110156: e8 61 d5 ff ff call 10d6bc <_Thread_Enable_dispatch><== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 11015b: e8 38 27 00 00 call 112898 <__errno> <== NOT EXECUTED 110160: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 110166: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110169: eb be jmp 110129 <_POSIX_Semaphore_Create_support+0x51><== NOT EXECUTED } } else { name = NULL; 11016b: 31 f6 xor %esi,%esi } the_semaphore->process_shared = pshared; 11016d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( name ) { 110174: 85 f6 test %esi,%esi 110176: 74 11 je 110189 <_POSIX_Semaphore_Create_support+0xb1> the_semaphore->named = true; 110178: c6 43 14 01 movb $0x1,0x14(%ebx) the_semaphore->open_count = 1; 11017c: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx) the_semaphore->linked = true; 110183: c6 43 15 01 movb $0x1,0x15(%ebx) 110187: eb 0f jmp 110198 <_POSIX_Semaphore_Create_support+0xc0> } else { the_semaphore->named = false; 110189: c6 43 14 00 movb $0x0,0x14(%ebx) the_semaphore->open_count = 0; 11018d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_semaphore->linked = false; 110194: c6 43 15 00 movb $0x0,0x15(%ebx) * blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 110198: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 11019f: c7 43 5c ff ff ff ff movl $0xffffffff,0x5c(%ebx) _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1101a6: 50 push %eax 1101a7: ff 75 14 pushl 0x14(%ebp) the_semaphore->named = false; the_semaphore->open_count = 0; the_semaphore->linked = false; } the_sem_attr = &the_semaphore->Semaphore.Attributes; 1101aa: 8d 43 5c lea 0x5c(%ebx),%eax /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 1101ad: 50 push %eax 1101ae: 8d 43 1c lea 0x1c(%ebx),%eax 1101b1: 50 push %eax 1101b2: e8 e9 bf ff ff call 10c1a0 <_CORE_semaphore_Initialize> Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 1101b7: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1101bb: a1 94 34 13 00 mov 0x133494,%eax 1101c0: 89 1c 90 mov %ebx,(%eax,%edx,4) the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 1101c3: 89 73 0c mov %esi,0xc(%ebx) &_POSIX_Semaphore_Information, &the_semaphore->Object, name ); *the_sem = the_semaphore; 1101c6: 8b 45 18 mov 0x18(%ebp),%eax 1101c9: 89 18 mov %ebx,(%eax) _Thread_Enable_dispatch(); 1101cb: e8 ec d4 ff ff call 10d6bc <_Thread_Enable_dispatch> return 0; 1101d0: 83 c4 10 add $0x10,%esp 1101d3: 31 c0 xor %eax,%eax } 1101d5: 8d 65 f8 lea -0x8(%ebp),%esp 1101d8: 5b pop %ebx 1101d9: 5e pop %esi 1101da: 5d pop %ebp 1101db: c3 ret =============================================================================== 0010e1a8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e1a8: 55 push %ebp 10e1a9: 89 e5 mov %esp,%ebp 10e1ab: 83 ec 08 sub $0x8,%esp 10e1ae: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e1b1: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e1b7: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e1be: 75 31 jne 10e1f1 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x49><== NEVER TAKEN 10e1c0: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e1c7: 75 28 jne 10e1f1 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x49> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e1c9: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e1d0: 74 1f je 10e1f1 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x49> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10e1d2: a1 dc e3 12 00 mov 0x12e3dc,%eax 10e1d7: 48 dec %eax 10e1d8: a3 dc e3 12 00 mov %eax,0x12e3dc return _Thread_Dispatch_disable_level; 10e1dd: a1 dc e3 12 00 mov 0x12e3dc,%eax thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e1e2: 50 push %eax 10e1e3: 50 push %eax 10e1e4: 6a ff push $0xffffffff 10e1e6: 52 push %edx 10e1e7: e8 e4 05 00 00 call 10e7d0 <_POSIX_Thread_Exit> 10e1ec: 83 c4 10 add $0x10,%esp 10e1ef: eb 06 jmp 10e1f7 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x4f> } else _Thread_Enable_dispatch(); } 10e1f1: c9 leave thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); 10e1f2: e9 61 dd ff ff jmp 10bf58 <_Thread_Enable_dispatch> } 10e1f7: c9 leave 10e1f8: c3 ret =============================================================================== 0010f20c <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10f20c: 55 push %ebp 10f20d: 89 e5 mov %esp,%ebp 10f20f: 57 push %edi 10f210: 56 push %esi 10f211: 53 push %ebx 10f212: 83 ec 18 sub $0x18,%esp 10f215: 8b 75 08 mov 0x8(%ebp),%esi 10f218: 8b 7d 0c mov 0xc(%ebp),%edi 10f21b: 8b 5d 10 mov 0x10(%ebp),%ebx if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10f21e: ff 37 pushl (%edi) 10f220: e8 c7 ff ff ff call 10f1ec <_POSIX_Priority_Is_valid> 10f225: 83 c4 10 add $0x10,%esp 10f228: 84 c0 test %al,%al 10f22a: 75 0a jne 10f236 <_POSIX_Thread_Translate_sched_param+0x2a><== ALWAYS TAKEN return EINVAL; 10f22c: b8 16 00 00 00 mov $0x16,%eax 10f231: e9 91 00 00 00 jmp 10f2c7 <_POSIX_Thread_Translate_sched_param+0xbb> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10f236: c7 03 00 00 00 00 movl $0x0,(%ebx) *budget_callout = NULL; 10f23c: 8b 45 14 mov 0x14(%ebp),%eax 10f23f: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10f245: 85 f6 test %esi,%esi 10f247: 75 08 jne 10f251 <_POSIX_Thread_Translate_sched_param+0x45> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10f249: c7 03 01 00 00 00 movl $0x1,(%ebx) 10f24f: eb 74 jmp 10f2c5 <_POSIX_Thread_Translate_sched_param+0xb9> return 0; } if ( policy == SCHED_FIFO ) { 10f251: 83 fe 01 cmp $0x1,%esi 10f254: 74 6f je 10f2c5 <_POSIX_Thread_Translate_sched_param+0xb9> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10f256: 83 fe 02 cmp $0x2,%esi 10f259: 75 08 jne 10f263 <_POSIX_Thread_Translate_sched_param+0x57> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10f25b: c7 03 02 00 00 00 movl $0x2,(%ebx) 10f261: eb 62 jmp 10f2c5 <_POSIX_Thread_Translate_sched_param+0xb9> return 0; } if ( policy == SCHED_SPORADIC ) { 10f263: 83 fe 04 cmp $0x4,%esi 10f266: 75 c4 jne 10f22c <_POSIX_Thread_Translate_sched_param+0x20> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10f268: 83 7f 08 00 cmpl $0x0,0x8(%edi) 10f26c: 75 06 jne 10f274 <_POSIX_Thread_Translate_sched_param+0x68> 10f26e: 83 7f 0c 00 cmpl $0x0,0xc(%edi) 10f272: 74 b8 je 10f22c <_POSIX_Thread_Translate_sched_param+0x20> (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 10f274: 83 7f 10 00 cmpl $0x0,0x10(%edi) 10f278: 75 06 jne 10f280 <_POSIX_Thread_Translate_sched_param+0x74> 10f27a: 83 7f 14 00 cmpl $0x0,0x14(%edi) 10f27e: 74 ac je 10f22c <_POSIX_Thread_Translate_sched_param+0x20> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10f280: 83 ec 0c sub $0xc,%esp 10f283: 8d 47 08 lea 0x8(%edi),%eax 10f286: 50 push %eax 10f287: e8 74 e1 ff ff call 10d400 <_Timespec_To_ticks> 10f28c: 89 c6 mov %eax,%esi _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10f28e: 8d 47 10 lea 0x10(%edi),%eax 10f291: 89 04 24 mov %eax,(%esp) 10f294: e8 67 e1 ff ff call 10d400 <_Timespec_To_ticks> if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10f299: 83 c4 10 add $0x10,%esp 10f29c: 39 c6 cmp %eax,%esi 10f29e: 72 8c jb 10f22c <_POSIX_Thread_Translate_sched_param+0x20> _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 10f2a0: 83 ec 0c sub $0xc,%esp 10f2a3: ff 77 04 pushl 0x4(%edi) 10f2a6: e8 41 ff ff ff call 10f1ec <_POSIX_Priority_Is_valid> 10f2ab: 83 c4 10 add $0x10,%esp 10f2ae: 84 c0 test %al,%al 10f2b0: 0f 84 76 ff ff ff je 10f22c <_POSIX_Thread_Translate_sched_param+0x20> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10f2b6: c7 03 03 00 00 00 movl $0x3,(%ebx) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10f2bc: 8b 45 14 mov 0x14(%ebp),%eax 10f2bf: c7 00 fb a2 10 00 movl $0x10a2fb,(%eax) return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10f2c5: 31 c0 xor %eax,%eax *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 10f2c7: 8d 65 f4 lea -0xc(%ebp),%esp 10f2ca: 5b pop %ebx 10f2cb: 5e pop %esi 10f2cc: 5f pop %edi 10f2cd: 5d pop %ebp 10f2ce: c3 ret =============================================================================== 0010e3c1 <_POSIX_Threads_Delete_extension>: */ static void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) { 10e3c1: 55 push %ebp 10e3c2: 89 e5 mov %esp,%ebp 10e3c4: 57 push %edi 10e3c5: 56 push %esi 10e3c6: 53 push %ebx 10e3c7: 83 ec 28 sub $0x28,%esp 10e3ca: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 10e3cd: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 10e3d3: 53 push %ebx 10e3d4: e8 cb 22 00 00 call 1106a4 <_POSIX_Threads_cancel_run> /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 10e3d9: 89 1c 24 mov %ebx,(%esp) 10e3dc: e8 23 23 00 00 call 110704 <_POSIX_Keys_Run_destructors> /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 10e3e1: 8b 53 28 mov 0x28(%ebx),%edx while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10e3e4: 83 c4 10 add $0x10,%esp 10e3e7: 8d 7e 44 lea 0x44(%esi),%edi 10e3ea: eb 05 jmp 10e3f1 <_POSIX_Threads_Delete_extension+0x30> *(void **)the_thread->Wait.return_argument = value_ptr; 10e3ec: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10e3ef: 89 10 mov %edx,(%eax) <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10e3f1: 83 ec 0c sub $0xc,%esp 10e3f4: 57 push %edi 10e3f5: 89 55 e4 mov %edx,-0x1c(%ebp) 10e3f8: e8 77 dd ff ff call 10c174 <_Thread_queue_Dequeue> 10e3fd: 83 c4 10 add $0x10,%esp 10e400: 85 c0 test %eax,%eax 10e402: 8b 55 e4 mov -0x1c(%ebp),%edx 10e405: 75 e5 jne 10e3ec <_POSIX_Threads_Delete_extension+0x2b><== NEVER TAKEN *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 10e407: 83 be 84 00 00 00 04 cmpl $0x4,0x84(%esi) 10e40e: 75 12 jne 10e422 <_POSIX_Threads_Delete_extension+0x61> (void) _Watchdog_Remove( &api->Sporadic_timer ); 10e410: 83 ec 0c sub $0xc,%esp 10e413: 8d 86 a8 00 00 00 lea 0xa8(%esi),%eax 10e419: 50 push %eax 10e41a: e8 f9 e5 ff ff call 10ca18 <_Watchdog_Remove> 10e41f: 83 c4 10 add $0x10,%esp deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 10e422: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10e429: 00 00 00 _Workspace_Free( api ); 10e42c: 89 75 08 mov %esi,0x8(%ebp) } 10e42f: 8d 65 f4 lea -0xc(%ebp),%esp 10e432: 5b pop %ebx 10e433: 5e pop %esi 10e434: 5f pop %edi 10e435: 5d pop %ebp if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; _Workspace_Free( api ); 10e436: e9 22 e7 ff ff jmp 10cb5d <_Workspace_Free> =============================================================================== 0010a028 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a028: 55 push %ebp 10a029: 89 e5 mov %esp,%ebp 10a02b: 57 push %edi 10a02c: 56 push %esi 10a02d: 53 push %ebx 10a02e: 83 ec 6c sub $0x6c,%esp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = Configuration_POSIX_API.User_initialization_threads_table; 10a031: 8b 3d c4 b1 12 00 mov 0x12b1c4,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a037: 8b 15 c0 b1 12 00 mov 0x12b1c0,%edx if ( !user_threads || maximum == 0 ) 10a03d: 85 d2 test %edx,%edx 10a03f: 74 54 je 10a095 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a041: 85 ff test %edi,%edi 10a043: 74 50 je 10a095 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a045: 31 db xor %ebx,%ebx for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10a047: 8d 75 a8 lea -0x58(%ebp),%esi 10a04a: 83 ec 0c sub $0xc,%esp 10a04d: 56 push %esi 10a04e: 89 55 94 mov %edx,-0x6c(%ebp) 10a051: e8 7a 52 00 00 call 10f2d0 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a056: 59 pop %ecx 10a057: 58 pop %eax 10a058: 6a 02 push $0x2 10a05a: 56 push %esi 10a05b: e8 98 52 00 00 call 10f2f8 (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a060: 58 pop %eax 10a061: 5a pop %edx 10a062: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a066: 56 push %esi 10a067: e8 b8 52 00 00 call 10f324 status = pthread_create( 10a06c: 6a 00 push $0x0 10a06e: ff 34 df pushl (%edi,%ebx,8) 10a071: 56 push %esi 10a072: 8d 45 a4 lea -0x5c(%ebp),%eax 10a075: 50 push %eax 10a076: e8 75 fc ff ff call 109cf0 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a07b: 83 c4 20 add $0x20,%esp 10a07e: 85 c0 test %eax,%eax 10a080: 8b 55 94 mov -0x6c(%ebp),%edx 10a083: 74 0b je 10a090 <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a085: 52 push %edx 10a086: 50 push %eax 10a087: 6a 01 push $0x1 10a089: 6a 02 push $0x2 10a08b: e8 98 1a 00 00 call 10bb28 <_Internal_error_Occurred> * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10a090: 43 inc %ebx 10a091: 39 d3 cmp %edx,%ebx 10a093: 75 b5 jne 10a04a <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a095: 8d 65 f4 lea -0xc(%ebp),%esp 10a098: 5b pop %ebx 10a099: 5e pop %esi 10a09a: 5f pop %edi 10a09b: 5d pop %ebp 10a09c: c3 ret =============================================================================== 0010e56d <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10e56d: 55 push %ebp 10e56e: 89 e5 mov %esp,%ebp 10e570: 56 push %esi 10e571: 53 push %ebx 10e572: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e575: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 10e57b: 83 ec 0c sub $0xc,%esp 10e57e: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10e584: 50 push %eax 10e585: e8 a2 12 00 00 call 10f82c <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10e58a: 89 43 74 mov %eax,0x74(%ebx) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10e58d: 0f b6 05 88 a1 12 00 movzbl 0x12a188,%eax 10e594: 2b 86 88 00 00 00 sub 0x88(%esi),%eax new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); the_thread->real_priority = new_priority; 10e59a: 89 43 18 mov %eax,0x18(%ebx) */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10e59d: 83 c4 10 add $0x10,%esp 10e5a0: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10e5a4: 75 12 jne 10e5b8 <_POSIX_Threads_Sporadic_budget_TSR+0x4b><== NEVER TAKEN /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 10e5a6: 39 43 14 cmp %eax,0x14(%ebx) 10e5a9: 76 0d jbe 10e5b8 <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10e5ab: 52 push %edx 10e5ac: 6a 01 push $0x1 10e5ae: 50 push %eax 10e5af: 53 push %ebx 10e5b0: e8 67 d4 ff ff call 10ba1c <_Thread_Change_priority> 10e5b5: 83 c4 10 add $0x10,%esp #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 10e5b8: 83 ec 0c sub $0xc,%esp 10e5bb: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10e5c1: 50 push %eax 10e5c2: e8 65 12 00 00 call 10f82c <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10e5c7: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10e5cd: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10e5d0: 81 c6 a8 00 00 00 add $0xa8,%esi 10e5d6: 89 75 0c mov %esi,0xc(%ebp) 10e5d9: c7 45 08 88 e4 12 00 movl $0x12e488,0x8(%ebp) } 10e5e0: 8d 65 f8 lea -0x8(%ebp),%esp 10e5e3: 5b pop %ebx 10e5e4: 5e pop %esi 10e5e5: 5d pop %ebp 10e5e6: e9 19 e3 ff ff jmp 10c904 <_Watchdog_Insert> =============================================================================== 0010e5eb <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10e5eb: 55 push %ebp 10e5ec: 89 e5 mov %esp,%ebp 10e5ee: 83 ec 08 sub $0x8,%esp 10e5f1: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e5f4: 8b 88 e8 00 00 00 mov 0xe8(%eax),%ecx /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 10e5fa: c7 40 74 ff ff ff ff movl $0xffffffff,0x74(%eax) 10e601: 0f b6 15 88 a1 12 00 movzbl 0x12a188,%edx 10e608: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 10e60e: 89 50 18 mov %edx,0x18(%eax) */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10e611: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10e615: 75 12 jne 10e629 <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN /* * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { 10e617: 39 50 14 cmp %edx,0x14(%eax) 10e61a: 73 0d jae 10e629 <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10e61c: 51 push %ecx 10e61d: 6a 01 push $0x1 10e61f: 52 push %edx 10e620: 50 push %eax 10e621: e8 f6 d3 ff ff call 10ba1c <_Thread_Change_priority> 10e626: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10e629: c9 leave 10e62a: c3 ret =============================================================================== 00109bb8 <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 109bb8: 55 push %ebp 109bb9: 89 e5 mov %esp,%ebp 109bbb: 57 push %edi 109bbc: 56 push %esi 109bbd: 53 push %ebx 109bbe: 83 ec 1c sub $0x1c,%esp 109bc1: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 109bc4: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 109bc7: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 109bcb: 75 06 jne 109bd3 <_POSIX_Timer_TSR+0x1b> 109bcd: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 109bd1: 74 5f je 109c32 <_POSIX_Timer_TSR+0x7a> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 109bd3: 83 ec 0c sub $0xc,%esp 109bd6: 53 push %ebx 109bd7: 68 b8 9b 10 00 push $0x109bb8 109bdc: ff 73 08 pushl 0x8(%ebx) 109bdf: ff 73 64 pushl 0x64(%ebx) 109be2: 8d 43 10 lea 0x10(%ebx),%eax 109be5: 50 push %eax 109be6: e8 65 51 00 00 call 10ed50 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 109beb: 83 c4 20 add $0x20,%esp 109bee: 84 c0 test %al,%al 109bf0: 74 5b je 109c4d <_POSIX_Timer_TSR+0x95> <== NEVER TAKEN struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 109bf2: 83 ec 0c sub $0xc,%esp 109bf5: 8d 45 e0 lea -0x20(%ebp),%eax 109bf8: 50 push %eax 109bf9: e8 5e 13 00 00 call 10af5c <_TOD_Get_as_timestamp> _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 109bfe: 8b 75 e0 mov -0x20(%ebp),%esi 109c01: 8b 7d e4 mov -0x1c(%ebp),%edi static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 109c04: 6a 00 push $0x0 109c06: 68 00 ca 9a 3b push $0x3b9aca00 109c0b: 57 push %edi 109c0c: 56 push %esi 109c0d: e8 d2 3f 01 00 call 11dbe4 <__divdi3> 109c12: 83 c4 10 add $0x10,%esp 109c15: 89 43 6c mov %eax,0x6c(%ebx) _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 109c18: 6a 00 push $0x0 109c1a: 68 00 ca 9a 3b push $0x3b9aca00 109c1f: 57 push %edi 109c20: 56 push %esi 109c21: e8 12 41 01 00 call 11dd38 <__moddi3> 109c26: 89 43 70 mov %eax,0x70(%ebx) /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 109c29: c6 43 3c 03 movb $0x3,0x3c(%ebx) 109c2d: 83 c4 20 add $0x20,%esp 109c30: eb 04 jmp 109c36 <_POSIX_Timer_TSR+0x7e> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 109c32: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 109c36: 50 push %eax 109c37: 50 push %eax 109c38: ff 73 44 pushl 0x44(%ebx) 109c3b: ff 73 38 pushl 0x38(%ebx) 109c3e: e8 0d 4d 00 00 call 10e950 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 109c43: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 109c4a: 83 c4 10 add $0x10,%esp } 109c4d: 8d 65 f4 lea -0xc(%ebp),%esp 109c50: 5b pop %ebx 109c51: 5e pop %esi 109c52: 5f pop %edi 109c53: 5d pop %ebp 109c54: c3 ret =============================================================================== 00110780 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110780: 55 push %ebp 110781: 89 e5 mov %esp,%ebp 110783: 57 push %edi 110784: 56 push %esi 110785: 53 push %ebx 110786: 83 ec 68 sub $0x68,%esp siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 110789: 6a 01 push $0x1 11078b: 0f b6 45 10 movzbl 0x10(%ebp),%eax 11078f: 50 push %eax 110790: 8d 45 b4 lea -0x4c(%ebp),%eax 110793: 50 push %eax 110794: ff 75 0c pushl 0xc(%ebp) 110797: ff 75 08 pushl 0x8(%ebp) 11079a: e8 91 00 00 00 call 110830 <_POSIX_signals_Clear_signals> 11079f: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 1107a2: 31 c9 xor %ecx,%ecx { siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 1107a4: 84 c0 test %al,%al 1107a6: 74 7d je 110825 <_POSIX_signals_Check_signal+0xa5> #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 1107a8: 6b 55 0c 0c imul $0xc,0xc(%ebp),%edx 1107ac: 8b 9a 30 e9 12 00 mov 0x12e930(%edx),%ebx 1107b2: 83 fb 01 cmp $0x1,%ebx 1107b5: 74 6e je 110825 <_POSIX_signals_Check_signal+0xa5><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 1107b7: 8b 4d 08 mov 0x8(%ebp),%ecx 1107ba: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 1107c0: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 1107c3: 8b 82 2c e9 12 00 mov 0x12e92c(%edx),%eax 1107c9: 09 c8 or %ecx,%eax 1107cb: 8b 4d 08 mov 0x8(%ebp),%ecx 1107ce: 89 81 d0 00 00 00 mov %eax,0xd0(%ecx) /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 1107d4: 8d 7d c0 lea -0x40(%ebp),%edi 1107d7: 8b 35 ec e8 12 00 mov 0x12e8ec,%esi 1107dd: 83 c6 20 add $0x20,%esi 1107e0: b9 0a 00 00 00 mov $0xa,%ecx 1107e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 1107e7: 83 ba 28 e9 12 00 02 cmpl $0x2,0x12e928(%edx) 1107ee: 75 09 jne 1107f9 <_POSIX_signals_Check_signal+0x79> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 1107f0: 50 push %eax 1107f1: 6a 00 push $0x0 1107f3: 8d 45 b4 lea -0x4c(%ebp),%eax 1107f6: 50 push %eax 1107f7: eb 03 jmp 1107fc <_POSIX_signals_Check_signal+0x7c> &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 1107f9: 83 ec 0c sub $0xc,%esp 1107fc: ff 75 0c pushl 0xc(%ebp) 1107ff: ff d3 call *%ebx break; 110801: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110804: 8b 3d ec e8 12 00 mov 0x12e8ec,%edi 11080a: 83 c7 20 add $0x20,%edi 11080d: 8d 75 c0 lea -0x40(%ebp),%esi 110810: b9 0a 00 00 00 mov $0xa,%ecx 110815: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 110817: 8b 45 a4 mov -0x5c(%ebp),%eax 11081a: 8b 55 08 mov 0x8(%ebp),%edx 11081d: 89 82 d0 00 00 00 mov %eax,0xd0(%edx) return true; 110823: b1 01 mov $0x1,%cl } 110825: 88 c8 mov %cl,%al 110827: 8d 65 f4 lea -0xc(%ebp),%esp 11082a: 5b pop %ebx 11082b: 5e pop %esi 11082c: 5f pop %edi 11082d: 5d pop %ebp 11082e: c3 ret =============================================================================== 00110e54 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 110e54: 55 push %ebp 110e55: 89 e5 mov %esp,%ebp 110e57: 53 push %ebx 110e58: 8b 55 08 mov 0x8(%ebp),%edx 110e5b: 8d 4a ff lea -0x1(%edx),%ecx 110e5e: b8 01 00 00 00 mov $0x1,%eax 110e63: d3 e0 shl %cl,%eax clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 110e65: 9c pushf 110e66: fa cli 110e67: 59 pop %ecx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 110e68: 6b d2 0c imul $0xc,%edx,%edx 110e6b: 83 ba 28 e9 12 00 02 cmpl $0x2,0x12e928(%edx) 110e72: 75 12 jne 110e86 <_POSIX_signals_Clear_process_signals+0x32> RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 110e74: 8d 9a 24 eb 12 00 lea 0x12eb24(%edx),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 110e7a: 39 9a 20 eb 12 00 cmp %ebx,0x12eb20(%edx) 110e80: 74 04 je 110e86 <_POSIX_signals_Clear_process_signals+0x32><== ALWAYS TAKEN clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; } _ISR_Enable( level ); 110e82: 51 push %ecx 110e83: 9d popf 110e84: eb 0a jmp 110e90 <_POSIX_signals_Clear_process_signals+0x3c> if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 110e86: f7 d0 not %eax 110e88: 21 05 1c eb 12 00 and %eax,0x12eb1c 110e8e: eb f2 jmp 110e82 <_POSIX_signals_Clear_process_signals+0x2e> } _ISR_Enable( level ); } 110e90: 5b pop %ebx 110e91: 5d pop %ebp 110e92: c3 ret =============================================================================== 0010a6c4 <_POSIX_signals_Get_lowest>: #include static int _POSIX_signals_Get_lowest( sigset_t set ) { 10a6c4: 55 push %ebp 10a6c5: 89 e5 mov %esp,%ebp 10a6c7: 56 push %esi 10a6c8: 53 push %ebx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10a6c9: ba 1b 00 00 00 mov $0x1b,%edx 10a6ce: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include static int _POSIX_signals_Get_lowest( 10a6d3: 8d 4a ff lea -0x1(%edx),%ecx 10a6d6: 89 de mov %ebx,%esi 10a6d8: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10a6da: 85 c6 test %eax,%esi 10a6dc: 75 1e jne 10a6fc <_POSIX_signals_Get_lowest+0x38><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10a6de: 42 inc %edx 10a6df: 83 fa 20 cmp $0x20,%edx 10a6e2: 75 ef jne 10a6d3 <_POSIX_signals_Get_lowest+0xf> 10a6e4: b2 01 mov $0x1,%dl 10a6e6: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include static int _POSIX_signals_Get_lowest( 10a6eb: 8d 4a ff lea -0x1(%edx),%ecx 10a6ee: 89 de mov %ebx,%esi 10a6f0: d3 e6 shl %cl,%esi #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10a6f2: 85 c6 test %eax,%esi 10a6f4: 75 06 jne 10a6fc <_POSIX_signals_Get_lowest+0x38> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10a6f6: 42 inc %edx 10a6f7: 83 fa 1b cmp $0x1b,%edx 10a6fa: 75 ef jne 10a6eb <_POSIX_signals_Get_lowest+0x27><== ALWAYS TAKEN * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 10a6fc: 89 d0 mov %edx,%eax 10a6fe: 5b pop %ebx 10a6ff: 5e pop %esi 10a700: 5d pop %ebp 10a701: c3 ret =============================================================================== 0011dbf0 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 11dbf0: 55 push %ebp 11dbf1: 89 e5 mov %esp,%ebp 11dbf3: 57 push %edi 11dbf4: 56 push %esi 11dbf5: 53 push %ebx 11dbf6: 83 ec 0c sub $0xc,%esp 11dbf9: 8b 5d 08 mov 0x8(%ebp),%ebx 11dbfc: 8b 75 0c mov 0xc(%ebp),%esi POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11dbff: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi 11dc05: 8d 4e ff lea -0x1(%esi),%ecx 11dc08: b8 01 00 00 00 mov $0x1,%eax 11dc0d: d3 e0 shl %cl,%eax /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 11dc0f: 8b 53 10 mov 0x10(%ebx),%edx 11dc12: 89 d1 mov %edx,%ecx 11dc14: 81 e1 00 80 00 10 and $0x10008000,%ecx 11dc1a: 81 f9 00 80 00 10 cmp $0x10008000,%ecx 11dc20: 75 54 jne 11dc76 <_POSIX_signals_Unblock_thread+0x86> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 11dc22: 85 43 30 test %eax,0x30(%ebx) 11dc25: 75 11 jne 11dc38 <_POSIX_signals_Unblock_thread+0x48> 11dc27: 8b 97 d0 00 00 00 mov 0xd0(%edi),%edx 11dc2d: f7 d2 not %edx 11dc2f: 85 d0 test %edx,%eax 11dc31: 75 05 jne 11dc38 <_POSIX_signals_Unblock_thread+0x48> 11dc33: e9 ab 00 00 00 jmp 11dce3 <_POSIX_signals_Unblock_thread+0xf3> the_thread->Wait.return_code = EINTR; 11dc38: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 11dc3f: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 11dc42: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 11dc46: 75 12 jne 11dc5a <_POSIX_signals_Unblock_thread+0x6a> the_info->si_signo = signo; 11dc48: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 11dc4a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 11dc51: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 11dc58: eb 0c jmp 11dc66 <_POSIX_signals_Unblock_thread+0x76> } else { *the_info = *info; 11dc5a: b9 03 00 00 00 mov $0x3,%ecx 11dc5f: 89 c7 mov %eax,%edi 11dc61: 8b 75 10 mov 0x10(%ebp),%esi 11dc64: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 11dc66: 83 ec 0c sub $0xc,%esp 11dc69: 53 push %ebx 11dc6a: e8 c1 e7 fe ff call 10c430 <_Thread_queue_Extract_with_proxy> return true; 11dc6f: 83 c4 10 add $0x10,%esp 11dc72: b0 01 mov $0x1,%al 11dc74: eb 6f jmp 11dce5 <_POSIX_signals_Unblock_thread+0xf5> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 11dc76: 8b 8f d0 00 00 00 mov 0xd0(%edi),%ecx 11dc7c: f7 d1 not %ecx 11dc7e: 85 c8 test %ecx,%eax 11dc80: 74 61 je 11dce3 <_POSIX_signals_Unblock_thread+0xf3> * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) { 11dc82: f7 c2 00 00 00 10 test $0x10000000,%edx 11dc88: 74 3d je 11dcc7 <_POSIX_signals_Unblock_thread+0xd7> the_thread->Wait.return_code = EINTR; 11dc8a: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 11dc91: f7 c2 e0 be 03 00 test $0x3bee0,%edx 11dc97: 74 0b je 11dca4 <_POSIX_signals_Unblock_thread+0xb4> _Thread_queue_Extract_with_proxy( the_thread ); 11dc99: 83 ec 0c sub $0xc,%esp 11dc9c: 53 push %ebx 11dc9d: e8 8e e7 fe ff call 10c430 <_Thread_queue_Extract_with_proxy> 11dca2: eb 1e jmp 11dcc2 <_POSIX_signals_Unblock_thread+0xd2> else if ( _States_Is_delaying(the_thread->current_state) ) { 11dca4: 80 e2 08 and $0x8,%dl 11dca7: 74 3a je 11dce3 <_POSIX_signals_Unblock_thread+0xf3><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 11dca9: 83 ec 0c sub $0xc,%esp 11dcac: 8d 43 48 lea 0x48(%ebx),%eax 11dcaf: 50 push %eax 11dcb0: e8 63 ed fe ff call 10ca18 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 11dcb5: 58 pop %eax 11dcb6: 5a pop %edx 11dcb7: 68 f8 ff 03 10 push $0x1003fff8 11dcbc: 53 push %ebx 11dcbd: e8 1a de fe ff call 10badc <_Thread_Clear_state> 11dcc2: 83 c4 10 add $0x10,%esp 11dcc5: eb 1c jmp 11dce3 <_POSIX_signals_Unblock_thread+0xf3> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 11dcc7: 85 d2 test %edx,%edx 11dcc9: 75 18 jne 11dce3 <_POSIX_signals_Unblock_thread+0xf3><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11dccb: 83 3d e8 e8 12 00 00 cmpl $0x0,0x12e8e8 11dcd2: 74 0f je 11dce3 <_POSIX_signals_Unblock_thread+0xf3> 11dcd4: 3b 1d ec e8 12 00 cmp 0x12e8ec,%ebx 11dcda: 75 07 jne 11dce3 <_POSIX_signals_Unblock_thread+0xf3><== NEVER TAKEN _Thread_Dispatch_necessary = true; 11dcdc: c6 05 f8 e8 12 00 01 movb $0x1,0x12e8f8 } } return false; 11dce3: 31 c0 xor %eax,%eax } 11dce5: 8d 65 f4 lea -0xc(%ebp),%esp 11dce8: 5b pop %ebx 11dce9: 5e pop %esi 11dcea: 5f pop %edi 11dceb: 5d pop %ebp 11dcec: c3 ret =============================================================================== 0010c004 <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 10c004: 55 push %ebp 10c005: 89 e5 mov %esp,%ebp 10c007: 57 push %edi 10c008: 56 push %esi 10c009: 53 push %ebx 10c00a: 83 ec 1c sub $0x1c,%esp 10c00d: 8b 7d 08 mov 0x8(%ebp),%edi 10c010: 8b 5d 0c mov 0xc(%ebp),%ebx RBTree_Node *leaf, *target; RBTree_Color victim_color; RBTree_Direction dir; if (!the_node) return; 10c013: 85 db test %ebx,%ebx 10c015: 0f 84 0d 01 00 00 je 10c128 <_RBTree_Extract_unprotected+0x124> /* check if min needs to be updated */ if (the_node == the_rbtree->first[RBT_LEFT]) { 10c01b: 3b 5f 08 cmp 0x8(%edi),%ebx 10c01e: 75 10 jne 10c030 <_RBTree_Extract_unprotected+0x2c> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_RIGHT ); 10c020: 50 push %eax 10c021: 50 push %eax 10c022: 6a 01 push $0x1 10c024: 53 push %ebx 10c025: e8 5a 03 00 00 call 10c384 <_RBTree_Next_unprotected> RBTree_Node *next; next = _RBTree_Successor_unprotected(the_node); the_rbtree->first[RBT_LEFT] = next; 10c02a: 89 47 08 mov %eax,0x8(%edi) 10c02d: 83 c4 10 add $0x10,%esp } /* 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]) { 10c030: 3b 5f 0c cmp 0xc(%edi),%ebx 10c033: 75 10 jne 10c045 <_RBTree_Extract_unprotected+0x41> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_LEFT ); 10c035: 56 push %esi 10c036: 56 push %esi 10c037: 6a 00 push $0x0 10c039: 53 push %ebx 10c03a: e8 45 03 00 00 call 10c384 <_RBTree_Next_unprotected> RBTree_Node *previous; previous = _RBTree_Predecessor_unprotected(the_node); the_rbtree->first[RBT_RIGHT] = previous; 10c03f: 89 47 0c mov %eax,0xc(%edi) 10c042: 83 c4 10 add $0x10,%esp * 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]) { 10c045: 8b 73 04 mov 0x4(%ebx),%esi 10c048: 85 f6 test %esi,%esi 10c04a: 74 77 je 10c0c3 <_RBTree_Extract_unprotected+0xbf> 10c04c: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10c050: 75 04 jne 10c056 <_RBTree_Extract_unprotected+0x52> 10c052: eb 78 jmp 10c0cc <_RBTree_Extract_unprotected+0xc8> target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */ while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT]; 10c054: 89 c6 mov %eax,%esi 10c056: 8b 46 08 mov 0x8(%esi),%eax 10c059: 85 c0 test %eax,%eax 10c05b: 75 f7 jne 10c054 <_RBTree_Extract_unprotected+0x50> * 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]; 10c05d: 8b 56 04 mov 0x4(%esi),%edx if(leaf) { 10c060: 85 d2 test %edx,%edx 10c062: 74 06 je 10c06a <_RBTree_Extract_unprotected+0x66> leaf->parent = target->parent; 10c064: 8b 06 mov (%esi),%eax 10c066: 89 02 mov %eax,(%edx) 10c068: eb 0d jmp 10c077 <_RBTree_Extract_unprotected+0x73> } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); 10c06a: 89 f0 mov %esi,%eax 10c06c: 89 55 e0 mov %edx,-0x20(%ebp) 10c06f: e8 53 fe ff ff call 10bec7 <_RBTree_Extract_validate_unprotected> 10c074: 8b 55 e0 mov -0x20(%ebp),%edx } victim_color = target->color; 10c077: 8b 46 0c mov 0xc(%esi),%eax 10c07a: 89 45 e4 mov %eax,-0x1c(%ebp) dir = target != target->parent->child[0]; 10c07d: 8b 06 mov (%esi),%eax 10c07f: 31 c9 xor %ecx,%ecx 10c081: 3b 70 04 cmp 0x4(%eax),%esi 10c084: 0f 95 c1 setne %cl target->parent->child[dir] = leaf; 10c087: 89 54 88 04 mov %edx,0x4(%eax,%ecx,4) /* now replace the_node with target */ dir = the_node != the_node->parent->child[0]; 10c08b: 8b 03 mov (%ebx),%eax 10c08d: 31 c9 xor %ecx,%ecx 10c08f: 3b 58 04 cmp 0x4(%eax),%ebx 10c092: 0f 95 c1 setne %cl the_node->parent->child[dir] = target; 10c095: 89 74 88 04 mov %esi,0x4(%eax,%ecx,4) /* set target's new children to the original node's children */ target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT]; 10c099: 8b 43 08 mov 0x8(%ebx),%eax 10c09c: 89 46 08 mov %eax,0x8(%esi) if (the_node->child[RBT_RIGHT]) 10c09f: 8b 43 08 mov 0x8(%ebx),%eax 10c0a2: 85 c0 test %eax,%eax 10c0a4: 74 02 je 10c0a8 <_RBTree_Extract_unprotected+0xa4><== NEVER TAKEN the_node->child[RBT_RIGHT]->parent = target; 10c0a6: 89 30 mov %esi,(%eax) target->child[RBT_LEFT] = the_node->child[RBT_LEFT]; 10c0a8: 8b 43 04 mov 0x4(%ebx),%eax 10c0ab: 89 46 04 mov %eax,0x4(%esi) if (the_node->child[RBT_LEFT]) 10c0ae: 8b 43 04 mov 0x4(%ebx),%eax 10c0b1: 85 c0 test %eax,%eax 10c0b3: 74 02 je 10c0b7 <_RBTree_Extract_unprotected+0xb3> the_node->child[RBT_LEFT]->parent = target; 10c0b5: 89 30 mov %esi,(%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; 10c0b7: 8b 03 mov (%ebx),%eax 10c0b9: 89 06 mov %eax,(%esi) target->color = the_node->color; 10c0bb: 8b 43 0c mov 0xc(%ebx),%eax 10c0be: 89 46 0c mov %eax,0xc(%esi) 10c0c1: eb 32 jmp 10c0f5 <_RBTree_Extract_unprotected+0xf1> * 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]; 10c0c3: 8b 53 08 mov 0x8(%ebx),%edx if( leaf ) { 10c0c6: 85 d2 test %edx,%edx 10c0c8: 75 04 jne 10c0ce <_RBTree_Extract_unprotected+0xca> 10c0ca: eb 08 jmp 10c0d4 <_RBTree_Extract_unprotected+0xd0> * 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]) { 10c0cc: 89 f2 mov %esi,%edx * 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; 10c0ce: 8b 03 mov (%ebx),%eax 10c0d0: 89 02 mov %eax,(%edx) 10c0d2: eb 0d jmp 10c0e1 <_RBTree_Extract_unprotected+0xdd> } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(the_node); 10c0d4: 89 d8 mov %ebx,%eax 10c0d6: 89 55 e0 mov %edx,-0x20(%ebp) 10c0d9: e8 e9 fd ff ff call 10bec7 <_RBTree_Extract_validate_unprotected> 10c0de: 8b 55 e0 mov -0x20(%ebp),%edx } victim_color = the_node->color; 10c0e1: 8b 43 0c mov 0xc(%ebx),%eax 10c0e4: 89 45 e4 mov %eax,-0x1c(%ebp) /* remove the_node from the tree */ dir = the_node != the_node->parent->child[0]; 10c0e7: 8b 03 mov (%ebx),%eax 10c0e9: 31 c9 xor %ecx,%ecx 10c0eb: 3b 58 04 cmp 0x4(%eax),%ebx 10c0ee: 0f 95 c1 setne %cl the_node->parent->child[dir] = leaf; 10c0f1: 89 54 88 04 mov %edx,0x4(%eax,%ecx,4) /* 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 */ 10c0f5: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10c0f9: 75 0b jne 10c106 <_RBTree_Extract_unprotected+0x102> if (leaf) { 10c0fb: 85 d2 test %edx,%edx 10c0fd: 74 07 je 10c106 <_RBTree_Extract_unprotected+0x102> leaf->color = RBT_BLACK; /* case 2 */ 10c0ff: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) */ RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree( RBTree_Node *node ) { node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL; 10c106: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10c10d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 10c114: c7 03 00 00 00 00 movl $0x0,(%ebx) /* 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; 10c11a: 8b 47 04 mov 0x4(%edi),%eax 10c11d: 85 c0 test %eax,%eax 10c11f: 74 07 je 10c128 <_RBTree_Extract_unprotected+0x124> 10c121: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) } 10c128: 8d 65 f4 lea -0xc(%ebp),%esp 10c12b: 5b pop %ebx 10c12c: 5e pop %esi 10c12d: 5f pop %edi 10c12e: 5d pop %ebp 10c12f: c3 ret =============================================================================== 0010cb1c <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) { 10cb1c: 55 push %ebp 10cb1d: 89 e5 mov %esp,%ebp 10cb1f: 57 push %edi 10cb20: 56 push %esi 10cb21: 53 push %ebx 10cb22: 83 ec 0c sub $0xc,%esp 10cb25: 8b 5d 08 mov 0x8(%ebp),%ebx 10cb28: 8b 75 14 mov 0x14(%ebp),%esi 10cb2b: 8b 45 1c mov 0x1c(%ebp),%eax size_t count; RBTree_Node *next; /* TODO: Error message? */ if (!the_rbtree) return; 10cb2e: 85 db test %ebx,%ebx 10cb30: 74 3d je 10cb6f <_RBTree_Initialize+0x53><== NEVER TAKEN RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 10cb32: c7 03 00 00 00 00 movl $0x0,(%ebx) the_rbtree->root = NULL; 10cb38: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) the_rbtree->first[0] = NULL; 10cb3f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) the_rbtree->first[1] = NULL; 10cb46: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_rbtree->compare_function = compare_function; 10cb4d: 8b 55 0c mov 0xc(%ebp),%edx 10cb50: 89 53 10 mov %edx,0x10(%ebx) the_rbtree->is_unique = is_unique; 10cb53: 88 43 14 mov %al,0x14(%ebx) /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; 10cb56: 8b 7d 10 mov 0x10(%ebp),%edi while ( count-- ) { 10cb59: eb 10 jmp 10cb6b <_RBTree_Initialize+0x4f> _RBTree_Insert_unprotected(the_rbtree, next); 10cb5b: 50 push %eax 10cb5c: 50 push %eax 10cb5d: 57 push %edi 10cb5e: 53 push %ebx 10cb5f: e8 a8 fd ff ff call 10c90c <_RBTree_Insert_unprotected> * node_size - size of node in bytes * * Output parameters: NONE */ void _RBTree_Initialize( 10cb64: 03 7d 18 add 0x18(%ebp),%edi 10cb67: 4e dec %esi 10cb68: 83 c4 10 add $0x10,%esp /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; while ( count-- ) { 10cb6b: 85 f6 test %esi,%esi 10cb6d: 75 ec jne 10cb5b <_RBTree_Initialize+0x3f> _RBTree_Insert_unprotected(the_rbtree, next); next = (RBTree_Node *) _Addresses_Add_offset( (void *) next, node_size ); } } 10cb6f: 8d 65 f4 lea -0xc(%ebp),%esp 10cb72: 5b pop %ebx 10cb73: 5e pop %esi 10cb74: 5f pop %edi 10cb75: 5d pop %ebp 10cb76: c3 ret =============================================================================== 0010c194 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 10c194: 55 push %ebp 10c195: 89 e5 mov %esp,%ebp 10c197: 57 push %edi 10c198: 56 push %esi 10c199: 53 push %ebx 10c19a: 83 ec 1c sub $0x1c,%esp 10c19d: 8b 75 08 mov 0x8(%ebp),%esi 10c1a0: 8b 5d 0c mov 0xc(%ebp),%ebx if(!the_node) return (RBTree_Node*)-1; 10c1a3: 85 db test %ebx,%ebx 10c1a5: 0f 84 55 01 00 00 je 10c300 <_RBTree_Insert_unprotected+0x16c> RBTree_Node *iter_node = the_rbtree->root; 10c1ab: 8b 7e 04 mov 0x4(%esi),%edi int compare_result; if (!iter_node) { /* special case: first node inserted */ 10c1ae: 89 f9 mov %edi,%ecx 10c1b0: 85 ff test %edi,%edi 10c1b2: 75 27 jne 10c1db <_RBTree_Insert_unprotected+0x47> the_node->color = RBT_BLACK; 10c1b4: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_rbtree->root = the_node; 10c1bb: 89 5e 04 mov %ebx,0x4(%esi) the_rbtree->first[0] = the_rbtree->first[1] = the_node; 10c1be: 89 5e 0c mov %ebx,0xc(%esi) 10c1c1: 89 5e 08 mov %ebx,0x8(%esi) the_node->parent = (RBTree_Node *) the_rbtree; 10c1c4: 89 33 mov %esi,(%ebx) the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 10c1c6: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10c1cd: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 10c1d4: e9 37 01 00 00 jmp 10c310 <_RBTree_Insert_unprotected+0x17c> (dir && _RBTree_Is_greater(compare_result)) ) { the_rbtree->first[dir] = the_node; } break; } else { iter_node = iter_node->child[dir]; 10c1d9: 89 f9 mov %edi,%ecx 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); 10c1db: 52 push %edx 10c1dc: 52 push %edx 10c1dd: 57 push %edi 10c1de: 53 push %ebx 10c1df: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c1e2: ff 56 10 call *0x10(%esi) if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 10c1e5: 83 c4 10 add $0x10,%esp 10c1e8: 80 7e 14 00 cmpb $0x0,0x14(%esi) 10c1ec: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c1ef: 74 08 je 10c1f9 <_RBTree_Insert_unprotected+0x65> 10c1f1: 85 c0 test %eax,%eax 10c1f3: 0f 84 17 01 00 00 je 10c310 <_RBTree_Insert_unprotected+0x17c> return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); 10c1f9: 89 c2 mov %eax,%edx 10c1fb: f7 d2 not %edx 10c1fd: c1 ea 1f shr $0x1f,%edx if (!iter_node->child[dir]) { 10c200: 8b 7c 97 04 mov 0x4(%edi,%edx,4),%edi 10c204: 85 ff test %edi,%edi 10c206: 75 d1 jne 10c1d9 <_RBTree_Insert_unprotected+0x45> the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 10c208: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10c20f: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) the_node->color = RBT_RED; 10c216: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) iter_node->child[dir] = the_node; 10c21d: 89 5c 91 04 mov %ebx,0x4(%ecx,%edx,4) the_node->parent = iter_node; 10c221: 89 0b mov %ecx,(%ebx) /* update min/max */ compare_result = the_rbtree->compare_function( 10c223: 50 push %eax 10c224: 50 push %eax 10c225: ff 74 96 08 pushl 0x8(%esi,%edx,4) 10c229: 53 push %ebx 10c22a: 89 55 e4 mov %edx,-0x1c(%ebp) 10c22d: ff 56 10 call *0x10(%esi) the_node, _RBTree_First(the_rbtree, dir) ); if ( (!dir && _RBTree_Is_lesser(compare_result)) || 10c230: 83 c4 10 add $0x10,%esp 10c233: 8b 55 e4 mov -0x1c(%ebp),%edx 10c236: 85 d2 test %edx,%edx 10c238: 75 0a jne 10c244 <_RBTree_Insert_unprotected+0xb0> 10c23a: 85 c0 test %eax,%eax 10c23c: 0f 89 9f 00 00 00 jns 10c2e1 <_RBTree_Insert_unprotected+0x14d> 10c242: eb 08 jmp 10c24c <_RBTree_Insert_unprotected+0xb8> (dir && _RBTree_Is_greater(compare_result)) ) { 10c244: 85 c0 test %eax,%eax 10c246: 0f 8e 95 00 00 00 jle 10c2e1 <_RBTree_Insert_unprotected+0x14d> the_rbtree->first[dir] = the_node; 10c24c: 89 5c 96 08 mov %ebx,0x8(%esi,%edx,4) 10c250: e9 8c 00 00 00 jmp 10c2e1 <_RBTree_Insert_unprotected+0x14d> const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; 10c255: 85 f6 test %esi,%esi 10c257: 74 1b je 10c274 <_RBTree_Insert_unprotected+0xe0><== NEVER TAKEN if(!(the_node->parent->parent->parent)) return NULL; 10c259: 83 3e 00 cmpl $0x0,(%esi) 10c25c: 74 16 je 10c274 <_RBTree_Insert_unprotected+0xe0><== 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]) 10c25e: 8b 56 04 mov 0x4(%esi),%edx 10c261: 39 d0 cmp %edx,%eax 10c263: 75 03 jne 10c268 <_RBTree_Insert_unprotected+0xd4> return the_node->parent->child[RBT_RIGHT]; 10c265: 8b 56 08 mov 0x8(%esi),%edx */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10c268: 85 d2 test %edx,%edx 10c26a: 74 0a je 10c276 <_RBTree_Insert_unprotected+0xe2> 10c26c: 83 7a 0c 01 cmpl $0x1,0xc(%edx) 10c270: 75 04 jne 10c276 <_RBTree_Insert_unprotected+0xe2> 10c272: eb 06 jmp 10c27a <_RBTree_Insert_unprotected+0xe6> ) { 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; 10c274: 31 d2 xor %edx,%edx <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10c276: 31 c9 xor %ecx,%ecx 10c278: eb 05 jmp 10c27f <_RBTree_Insert_unprotected+0xeb> 10c27a: b9 01 00 00 00 mov $0x1,%ecx while (_RBTree_Is_red(_RBTree_Parent(the_node))) { 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)) { 10c27f: 85 c9 test %ecx,%ecx 10c281: 74 17 je 10c29a <_RBTree_Insert_unprotected+0x106> the_node->parent->color = RBT_BLACK; 10c283: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) u->color = RBT_BLACK; 10c28a: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) g->color = RBT_RED; 10c291: c7 46 0c 01 00 00 00 movl $0x1,0xc(%esi) 10c298: eb 45 jmp 10c2df <_RBTree_Insert_unprotected+0x14b> 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]; 10c29a: 31 c9 xor %ecx,%ecx 10c29c: 3b 46 04 cmp 0x4(%esi),%eax 10c29f: 0f 95 c1 setne %cl 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]; 10c2a2: 31 d2 xor %edx,%edx 10c2a4: 3b 58 04 cmp 0x4(%eax),%ebx 10c2a7: 0f 95 c2 setne %dl RBTree_Direction pdir = the_node->parent != g->child[0]; /* ensure node is on the same branch direction as parent */ if (dir != pdir) { 10c2aa: 39 ca cmp %ecx,%edx 10c2ac: 74 11 je 10c2bf <_RBTree_Insert_unprotected+0x12b> _RBTree_Rotate(the_node->parent, pdir); 10c2ae: 89 ca mov %ecx,%edx 10c2b0: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c2b3: e8 98 fe ff ff call 10c150 <_RBTree_Rotate> the_node = the_node->child[pdir]; 10c2b8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c2bb: 8b 5c 8b 04 mov 0x4(%ebx,%ecx,4),%ebx } the_node->parent->color = RBT_BLACK; 10c2bf: 8b 03 mov (%ebx),%eax 10c2c1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) g->color = RBT_RED; 10c2c8: c7 46 0c 01 00 00 00 movl $0x1,0xc(%esi) /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); 10c2cf: ba 01 00 00 00 mov $0x1,%edx 10c2d4: 29 ca sub %ecx,%edx 10c2d6: 89 f0 mov %esi,%eax 10c2d8: e8 73 fe ff ff call 10c150 <_RBTree_Rotate> 10c2dd: 89 de mov %ebx,%esi 10c2df: 89 f3 mov %esi,%ebx _ISR_Disable( level ); return_node = _RBTree_Insert_unprotected( tree, node ); _ISR_Enable( level ); return return_node; } 10c2e1: 8b 03 mov (%ebx),%eax */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent( const RBTree_Node *the_node ) { if (!the_node->parent->parent) return NULL; 10c2e3: 8b 30 mov (%eax),%esi 10c2e5: 85 f6 test %esi,%esi 10c2e7: 75 1c jne 10c305 <_RBTree_Insert_unprotected+0x171> */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10c2e9: 31 d2 xor %edx,%edx RBTree_Node *u,*g; /* note: the insert root case is handled already */ /* if the parent is black, nothing needs to be done * otherwise may need to loop a few times */ while (_RBTree_Is_red(_RBTree_Parent(the_node))) { 10c2eb: 85 d2 test %edx,%edx 10c2ed: 0f 85 62 ff ff ff jne 10c255 <_RBTree_Insert_unprotected+0xc1> /* 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; 10c2f3: 85 f6 test %esi,%esi 10c2f5: 75 19 jne 10c310 <_RBTree_Insert_unprotected+0x17c> 10c2f7: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) 10c2fe: eb 10 jmp 10c310 <_RBTree_Insert_unprotected+0x17c> RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { if(!the_node) return (RBTree_Node*)-1; 10c300: 83 cf ff or $0xffffffff,%edi 10c303: eb 0b jmp 10c310 <_RBTree_Insert_unprotected+0x17c> 10c305: 31 d2 xor %edx,%edx 10c307: 83 78 0c 01 cmpl $0x1,0xc(%eax) 10c30b: 0f 94 c2 sete %dl 10c30e: eb db jmp 10c2eb <_RBTree_Insert_unprotected+0x157> /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 10c310: 89 f8 mov %edi,%eax 10c312: 8d 65 f4 lea -0xc(%ebp),%esp 10c315: 5b pop %ebx 10c316: 5e pop %esi 10c317: 5f pop %edi 10c318: 5d pop %ebp 10c319: c3 ret =============================================================================== 0010c338 <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) { 10c338: 55 push %ebp 10c339: 89 e5 mov %esp,%ebp 10c33b: 57 push %edi 10c33c: 56 push %esi 10c33d: 53 push %ebx 10c33e: 83 ec 0c sub $0xc,%esp 10c341: 8b 5d 0c mov 0xc(%ebp),%ebx */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10c344: 31 d2 xor %edx,%edx 10c346: 85 db test %ebx,%ebx 10c348: 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]; 10c34b: 8b 45 08 mov 0x8(%ebp),%eax 10c34e: 8b 74 90 08 mov 0x8(%eax,%edx,4),%esi RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; 10c352: 31 ff xor %edi,%edi while ( !stop && current != NULL ) { 10c354: eb 1b jmp 10c371 <_RBTree_Iterate_unprotected+0x39> stop = (*visitor)( current, dir, visitor_arg ); 10c356: 50 push %eax 10c357: ff 75 14 pushl 0x14(%ebp) 10c35a: 53 push %ebx 10c35b: 56 push %esi 10c35c: 8b 55 10 mov 0x10(%ebp),%edx 10c35f: ff d2 call *%edx 10c361: 89 c7 mov %eax,%edi current = _RBTree_Next_unprotected( current, dir ); 10c363: 5a pop %edx 10c364: 59 pop %ecx 10c365: 53 push %ebx 10c366: 56 push %esi 10c367: e8 18 00 00 00 call 10c384 <_RBTree_Next_unprotected> 10c36c: 89 c6 mov %eax,%esi 10c36e: 83 c4 10 add $0x10,%esp { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 10c371: 85 f6 test %esi,%esi 10c373: 74 06 je 10c37b <_RBTree_Iterate_unprotected+0x43> 10c375: 89 f8 mov %edi,%eax 10c377: fe c8 dec %al 10c379: 75 db jne 10c356 <_RBTree_Iterate_unprotected+0x1e><== ALWAYS TAKEN stop = (*visitor)( current, dir, visitor_arg ); current = _RBTree_Next_unprotected( current, dir ); } } 10c37b: 8d 65 f4 lea -0xc(%ebp),%esp 10c37e: 5b pop %ebx 10c37f: 5e pop %esi 10c380: 5f pop %edi 10c381: 5d pop %ebp 10c382: c3 ret =============================================================================== 0010be83 <_RBTree_Rotate>: RBTree_Node *the_node, RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; 10be83: 85 c0 test %eax,%eax 10be85: 74 3f je 10bec6 <_RBTree_Rotate+0x43> <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _RBTree_Rotate( RBTree_Node *the_node, RBTree_Direction dir ) { 10be87: 55 push %ebp 10be88: 89 e5 mov %esp,%ebp 10be8a: 56 push %esi 10be8b: 53 push %ebx */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10be8c: 31 db xor %ebx,%ebx 10be8e: 85 d2 test %edx,%edx 10be90: 0f 94 c3 sete %bl RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10be93: 8b 4c 98 04 mov 0x4(%eax,%ebx,4),%ecx 10be97: 85 c9 test %ecx,%ecx 10be99: 74 28 je 10bec3 <_RBTree_Rotate+0x40> <== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10be9b: 8b 74 91 04 mov 0x4(%ecx,%edx,4),%esi 10be9f: 89 74 98 04 mov %esi,0x4(%eax,%ebx,4) if (c->child[dir]) 10bea3: 8b 5c 91 04 mov 0x4(%ecx,%edx,4),%ebx 10bea7: 85 db test %ebx,%ebx 10bea9: 74 02 je 10bead <_RBTree_Rotate+0x2a> c->child[dir]->parent = the_node; 10beab: 89 03 mov %eax,(%ebx) c->child[dir] = the_node; 10bead: 89 44 91 04 mov %eax,0x4(%ecx,%edx,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10beb1: 8b 10 mov (%eax),%edx 10beb3: 31 db xor %ebx,%ebx 10beb5: 3b 42 04 cmp 0x4(%edx),%eax 10beb8: 0f 95 c3 setne %bl 10bebb: 89 4c 9a 04 mov %ecx,0x4(%edx,%ebx,4) c->parent = the_node->parent; 10bebf: 89 11 mov %edx,(%ecx) the_node->parent = c; 10bec1: 89 08 mov %ecx,(%eax) } 10bec3: 5b pop %ebx 10bec4: 5e pop %esi 10bec5: 5d pop %ebp 10bec6: c3 ret =============================================================================== 0010be5f <_RBTree_Sibling>: * exists, and NULL if not. */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { 10be5f: 55 push %ebp 10be60: 89 e5 mov %esp,%ebp if(!the_node) return NULL; 10be62: 85 c0 test %eax,%eax 10be64: 74 17 je 10be7d <_RBTree_Sibling+0x1e> <== NEVER TAKEN if(!(the_node->parent)) return NULL; 10be66: 8b 08 mov (%eax),%ecx 10be68: 85 c9 test %ecx,%ecx 10be6a: 74 11 je 10be7d <_RBTree_Sibling+0x1e> <== NEVER TAKEN if(!(the_node->parent->parent)) return NULL; 10be6c: 83 39 00 cmpl $0x0,(%ecx) 10be6f: 74 0c je 10be7d <_RBTree_Sibling+0x1e> if(the_node == the_node->parent->child[RBT_LEFT]) 10be71: 8b 51 04 mov 0x4(%ecx),%edx 10be74: 39 d0 cmp %edx,%eax 10be76: 75 07 jne 10be7f <_RBTree_Sibling+0x20> return the_node->parent->child[RBT_RIGHT]; 10be78: 8b 51 08 mov 0x8(%ecx),%edx 10be7b: eb 02 jmp 10be7f <_RBTree_Sibling+0x20> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; 10be7d: 31 d2 xor %edx,%edx if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; else return the_node->parent->child[RBT_LEFT]; } 10be7f: 89 d0 mov %edx,%eax 10be81: 5d pop %ebp 10be82: c3 ret =============================================================================== 0012dbb8 <_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 ) { 12dbb8: 55 push %ebp 12dbb9: 89 e5 mov %esp,%ebp 12dbbb: 57 push %edi 12dbbc: 56 push %esi 12dbbd: 53 push %ebx 12dbbe: 83 ec 28 sub $0x28,%esp #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ Timestamp_Control uptime; #endif Thread_Control *owning_thread = the_period->owner; 12dbc1: 8b 45 08 mov 0x8(%ebp),%eax 12dbc4: 8b 78 40 mov 0x40(%eax),%edi /* * Determine elapsed wall time since period initiated. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _TOD_Get_uptime( &uptime ); 12dbc7: 8d 45 e0 lea -0x20(%ebp),%eax 12dbca: 50 push %eax 12dbcb: e8 e4 30 fe ff call 110cb4 <_TOD_Get_uptime> _Timestamp_Subtract( 12dbd0: 8b 45 e0 mov -0x20(%ebp),%eax 12dbd3: 8b 55 e4 mov -0x1c(%ebp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 12dbd6: 89 c1 mov %eax,%ecx 12dbd8: 89 d3 mov %edx,%ebx 12dbda: 8b 75 08 mov 0x8(%ebp),%esi 12dbdd: 2b 4e 4c sub 0x4c(%esi),%ecx 12dbe0: 1b 5e 50 sbb 0x50(%esi),%ebx 12dbe3: 8b 75 0c mov 0xc(%ebp),%esi 12dbe6: 89 0e mov %ecx,(%esi) 12dbe8: 89 5e 04 mov %ebx,0x4(%esi) #endif /* * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; 12dbeb: 8b 8f 80 00 00 00 mov 0x80(%edi),%ecx 12dbf1: 8b 9f 84 00 00 00 mov 0x84(%edi),%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 12dbf7: 83 c4 10 add $0x10,%esp if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 12dbfa: be 01 00 00 00 mov $0x1,%esi * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 12dbff: 3b 3d 04 e7 16 00 cmp 0x16e704,%edi 12dc05: 75 38 jne 12dc3f <_Rate_monotonic_Get_status+0x87> 12dc07: 2b 05 14 e7 16 00 sub 0x16e714,%eax 12dc0d: 1b 15 18 e7 16 00 sbb 0x16e718,%edx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 12dc13: 01 c8 add %ecx,%eax 12dc15: 11 da adc %ebx,%edx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12dc17: 8b 75 08 mov 0x8(%ebp),%esi 12dc1a: 8b 4e 44 mov 0x44(%esi),%ecx 12dc1d: 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)) 12dc20: 39 da cmp %ebx,%edx 12dc22: 7c 19 jl 12dc3d <_Rate_monotonic_Get_status+0x85><== NEVER TAKEN 12dc24: 7f 04 jg 12dc2a <_Rate_monotonic_Get_status+0x72> 12dc26: 39 c8 cmp %ecx,%eax 12dc28: 72 13 jb 12dc3d <_Rate_monotonic_Get_status+0x85> const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 12dc2a: 29 c8 sub %ecx,%eax 12dc2c: 19 da sbb %ebx,%edx 12dc2e: 8b 4d 10 mov 0x10(%ebp),%ecx 12dc31: 89 01 mov %eax,(%ecx) 12dc33: 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; 12dc36: be 01 00 00 00 mov $0x1,%esi 12dc3b: eb 02 jmp 12dc3f <_Rate_monotonic_Get_status+0x87> /* * The cpu usage info was reset while executing. Can't * determine a status. */ if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated)) return false; 12dc3d: 31 f6 xor %esi,%esi return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; } 12dc3f: 89 f0 mov %esi,%eax 12dc41: 8d 65 f4 lea -0xc(%ebp),%esp 12dc44: 5b pop %ebx 12dc45: 5e pop %esi 12dc46: 5f pop %edi 12dc47: 5d pop %ebp 12dc48: c3 ret =============================================================================== 0012dedc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 12dedc: 55 push %ebp 12dedd: 89 e5 mov %esp,%ebp 12dedf: 53 push %ebx 12dee0: 83 ec 18 sub $0x18,%esp /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); 12dee3: 8d 45 f4 lea -0xc(%ebp),%eax 12dee6: 50 push %eax 12dee7: ff 75 08 pushl 0x8(%ebp) 12deea: 68 a0 ec 16 00 push $0x16eca0 12deef: e8 4c d1 fd ff call 10b040 <_Objects_Get> switch ( location ) { 12def4: 83 c4 10 add $0x10,%esp 12def7: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 12defb: 75 6b jne 12df68 <_Rate_monotonic_Timeout+0x8c><== NEVER TAKEN 12defd: 89 c3 mov %eax,%ebx case OBJECTS_LOCAL: the_thread = the_period->owner; 12deff: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 12df02: f6 40 11 40 testb $0x40,0x11(%eax) 12df06: 74 18 je 12df20 <_Rate_monotonic_Timeout+0x44> 12df08: 8b 53 08 mov 0x8(%ebx),%edx 12df0b: 39 50 20 cmp %edx,0x20(%eax) 12df0e: 75 10 jne 12df20 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 12df10: 51 push %ecx 12df11: 51 push %ecx 12df12: 68 f8 ff 03 10 push $0x1003fff8 12df17: 50 push %eax 12df18: e8 27 d9 fd ff call 10b844 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 12df1d: 58 pop %eax 12df1e: eb 10 jmp 12df30 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 12df20: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 12df24: 75 2b jne 12df51 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 12df26: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 12df2d: 83 ec 0c sub $0xc,%esp 12df30: 53 push %ebx 12df31: e8 b2 fd ff ff call 12dce8 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 12df36: 8b 43 3c mov 0x3c(%ebx),%eax 12df39: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 12df3c: 58 pop %eax 12df3d: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 12df3e: 83 c3 10 add $0x10,%ebx 12df41: 53 push %ebx 12df42: 68 a0 e2 16 00 push $0x16e2a0 12df47: e8 20 e7 fd ff call 10c66c <_Watchdog_Insert> 12df4c: 83 c4 10 add $0x10,%esp 12df4f: eb 07 jmp 12df58 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 12df51: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 12df58: a1 fc e1 16 00 mov 0x16e1fc,%eax 12df5d: 48 dec %eax 12df5e: a3 fc e1 16 00 mov %eax,0x16e1fc return _Thread_Dispatch_disable_level; 12df63: a1 fc e1 16 00 mov 0x16e1fc,%eax case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 12df68: 8b 5d fc mov -0x4(%ebp),%ebx 12df6b: c9 leave 12df6c: c3 ret =============================================================================== 0012dc49 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 12dc49: 55 push %ebp 12dc4a: 89 e5 mov %esp,%ebp 12dc4c: 56 push %esi 12dc4d: 53 push %ebx 12dc4e: 83 ec 10 sub $0x10,%esp 12dc51: 89 c6 mov %eax,%esi /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 12dc53: ff 40 54 incl 0x54(%eax) if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 12dc56: 83 78 38 04 cmpl $0x4,0x38(%eax) 12dc5a: 75 03 jne 12dc5f <_Rate_monotonic_Update_statistics+0x16> stats->missed_count++; 12dc5c: ff 40 58 incl 0x58(%eax) /* * Grab status for time statistics. */ valid_status = 12dc5f: 50 push %eax _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 12dc60: 8d 45 e8 lea -0x18(%ebp),%eax stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 12dc63: 50 push %eax _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 12dc64: 8d 45 f0 lea -0x10(%ebp),%eax stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 12dc67: 50 push %eax 12dc68: 56 push %esi 12dc69: e8 4a ff ff ff call 12dbb8 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 12dc6e: 83 c4 10 add $0x10,%esp 12dc71: 84 c0 test %al,%al 12dc73: 74 6c je 12dce1 <_Rate_monotonic_Update_statistics+0x98> /* * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); 12dc75: 8b 4d e8 mov -0x18(%ebp),%ecx 12dc78: 8b 5d ec mov -0x14(%ebp),%ebx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 12dc7b: 01 4e 6c add %ecx,0x6c(%esi) 12dc7e: 11 5e 70 adc %ebx,0x70(%esi) if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 12dc81: 3b 5e 60 cmp 0x60(%esi),%ebx 12dc84: 7f 0d jg 12dc93 <_Rate_monotonic_Update_statistics+0x4a><== NEVER TAKEN 12dc86: 7c 05 jl 12dc8d <_Rate_monotonic_Update_statistics+0x44> 12dc88: 3b 4e 5c cmp 0x5c(%esi),%ecx 12dc8b: 73 06 jae 12dc93 <_Rate_monotonic_Update_statistics+0x4a> stats->min_cpu_time = executed; 12dc8d: 89 4e 5c mov %ecx,0x5c(%esi) 12dc90: 89 5e 60 mov %ebx,0x60(%esi) if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 12dc93: 39 5e 68 cmp %ebx,0x68(%esi) 12dc96: 7f 0d jg 12dca5 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN 12dc98: 7c 05 jl 12dc9f <_Rate_monotonic_Update_statistics+0x56><== NEVER TAKEN 12dc9a: 39 4e 64 cmp %ecx,0x64(%esi) 12dc9d: 73 06 jae 12dca5 <_Rate_monotonic_Update_statistics+0x5c> stats->max_cpu_time = executed; 12dc9f: 89 4e 64 mov %ecx,0x64(%esi) 12dca2: 89 5e 68 mov %ebx,0x68(%esi) /* * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 12dca5: 8b 4d f0 mov -0x10(%ebp),%ecx 12dca8: 8b 5d f4 mov -0xc(%ebp),%ebx 12dcab: 01 8e 84 00 00 00 add %ecx,0x84(%esi) 12dcb1: 11 9e 88 00 00 00 adc %ebx,0x88(%esi) if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 12dcb7: 3b 5e 78 cmp 0x78(%esi),%ebx 12dcba: 7f 0d jg 12dcc9 <_Rate_monotonic_Update_statistics+0x80><== NEVER TAKEN 12dcbc: 7c 05 jl 12dcc3 <_Rate_monotonic_Update_statistics+0x7a> 12dcbe: 3b 4e 74 cmp 0x74(%esi),%ecx 12dcc1: 73 06 jae 12dcc9 <_Rate_monotonic_Update_statistics+0x80> stats->min_wall_time = since_last_period; 12dcc3: 89 4e 74 mov %ecx,0x74(%esi) 12dcc6: 89 5e 78 mov %ebx,0x78(%esi) if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 12dcc9: 39 9e 80 00 00 00 cmp %ebx,0x80(%esi) 12dccf: 7f 10 jg 12dce1 <_Rate_monotonic_Update_statistics+0x98> 12dcd1: 7c 05 jl 12dcd8 <_Rate_monotonic_Update_statistics+0x8f><== NEVER TAKEN 12dcd3: 39 4e 7c cmp %ecx,0x7c(%esi) 12dcd6: 73 09 jae 12dce1 <_Rate_monotonic_Update_statistics+0x98> stats->max_wall_time = since_last_period; 12dcd8: 89 4e 7c mov %ecx,0x7c(%esi) 12dcdb: 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 } 12dce1: 8d 65 f8 lea -0x8(%ebp),%esp 12dce4: 5b pop %ebx 12dce5: 5e pop %esi 12dce6: 5d pop %ebp 12dce7: c3 ret =============================================================================== 0010bcd8 <_Scheduler_CBS_Allocate>: #include void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) { 10bcd8: 55 push %ebp 10bcd9: 89 e5 mov %esp,%ebp 10bcdb: 53 push %ebx 10bcdc: 83 ec 10 sub $0x10,%esp 10bcdf: 8b 5d 08 mov 0x8(%ebp),%ebx void *sched; Scheduler_CBS_Per_thread *schinfo; sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread)); 10bce2: 6a 1c push $0x1c 10bce4: e8 a7 15 00 00 call 10d290 <_Workspace_Allocate> if ( sched ) { 10bce9: 83 c4 10 add $0x10,%esp 10bcec: 85 c0 test %eax,%eax 10bcee: 74 16 je 10bd06 <_Scheduler_CBS_Allocate+0x2e><== NEVER TAKEN the_thread->scheduler_info = sched; 10bcf0: 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; 10bcf6: 89 18 mov %ebx,(%eax) schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 10bcf8: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax) schinfo->cbs_server = NULL; 10bcff: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) } return sched; } 10bd06: 8b 5d fc mov -0x4(%ebp),%ebx 10bd09: c9 leave 10bd0a: c3 ret =============================================================================== 0010d104 <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 10d104: 55 push %ebp 10d105: 89 e5 mov %esp,%ebp 10d107: 53 push %ebx 10d108: 83 ec 14 sub $0x14,%esp 10d10b: 8b 5d 08 mov 0x8(%ebp),%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; 10d10e: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax if ( the_thread->real_priority != new_priority ) 10d114: 39 43 18 cmp %eax,0x18(%ebx) 10d117: 74 03 je 10d11c <_Scheduler_CBS_Budget_callout+0x18><== NEVER TAKEN the_thread->real_priority = new_priority; 10d119: 89 43 18 mov %eax,0x18(%ebx) if ( the_thread->current_priority != new_priority ) 10d11c: 39 43 14 cmp %eax,0x14(%ebx) 10d11f: 74 0d je 10d12e <_Scheduler_CBS_Budget_callout+0x2a><== NEVER TAKEN _Thread_Change_priority(the_thread, new_priority, true); 10d121: 52 push %edx 10d122: 6a 01 push $0x1 10d124: 50 push %eax 10d125: 53 push %ebx 10d126: e8 b5 04 00 00 call 10d5e0 <_Thread_Change_priority> 10d12b: 83 c4 10 add $0x10,%esp /* Invoke callback function if any. */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; 10d12e: 8b 9b 88 00 00 00 mov 0x88(%ebx),%ebx if ( sched_info->cbs_server->cbs_budget_overrun ) { 10d134: 8b 43 18 mov 0x18(%ebx),%eax 10d137: 83 78 0c 00 cmpl $0x0,0xc(%eax) 10d13b: 74 1a je 10d157 <_Scheduler_CBS_Budget_callout+0x53> _Scheduler_CBS_Get_server_id( 10d13d: 52 push %edx 10d13e: 52 push %edx 10d13f: 8d 55 f4 lea -0xc(%ebp),%edx 10d142: 52 push %edx 10d143: ff 30 pushl (%eax) 10d145: e8 7e ff ff ff call 10d0c8 <_Scheduler_CBS_Get_server_id> sched_info->cbs_server->task_id, &server_id ); sched_info->cbs_server->cbs_budget_overrun( server_id ); 10d14a: 59 pop %ecx 10d14b: 8b 43 18 mov 0x18(%ebx),%eax 10d14e: ff 75 f4 pushl -0xc(%ebp) 10d151: ff 50 0c call *0xc(%eax) 10d154: 83 c4 10 add $0x10,%esp } } 10d157: 8b 5d fc mov -0x4(%ebp),%ebx 10d15a: c9 leave 10d15b: c3 ret =============================================================================== 0010cdcc <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 10cdcc: 55 push %ebp 10cdcd: 89 e5 mov %esp,%ebp 10cdcf: 57 push %edi 10cdd0: 56 push %esi 10cdd1: 53 push %ebx 10cdd2: 83 ec 0c sub $0xc,%esp 10cdd5: 8b 5d 08 mov 0x8(%ebp),%ebx 10cdd8: 8b 75 10 mov 0x10(%ebp),%esi unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 10cddb: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10cddf: 7e 42 jle 10ce23 <_Scheduler_CBS_Create_server+0x57> 10cde1: 83 3b 00 cmpl $0x0,(%ebx) 10cde4: 7e 3d jle 10ce23 <_Scheduler_CBS_Create_server+0x57> 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++ ) { 10cde6: 8b 15 6c d2 12 00 mov 0x12d26c,%edx if ( !_Scheduler_CBS_Server_list[i] ) 10cdec: 8b 0d ac 19 13 00 mov 0x1319ac,%ecx 10cdf2: 31 c0 xor %eax,%eax 10cdf4: eb 07 jmp 10cdfd <_Scheduler_CBS_Create_server+0x31> 10cdf6: 83 3c 81 00 cmpl $0x0,(%ecx,%eax,4) 10cdfa: 74 35 je 10ce31 <_Scheduler_CBS_Create_server+0x65> 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++ ) { 10cdfc: 40 inc %eax 10cdfd: 39 d0 cmp %edx,%eax 10cdff: 75 f5 jne 10cdf6 <_Scheduler_CBS_Create_server+0x2a> if ( !_Scheduler_CBS_Server_list[i] ) break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 10ce01: b8 e6 ff ff ff mov $0xffffffe6,%eax 10ce06: eb 53 jmp 10ce5b <_Scheduler_CBS_Create_server+0x8f> _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 10ce08: 8b 03 mov (%ebx),%eax 10ce0a: 8b 53 04 mov 0x4(%ebx),%edx 10ce0d: 89 41 04 mov %eax,0x4(%ecx) 10ce10: 89 51 08 mov %edx,0x8(%ecx) the_server->task_id = -1; 10ce13: c7 01 ff ff ff ff movl $0xffffffff,(%ecx) the_server->cbs_budget_overrun = budget_overrun_callback; 10ce19: 8b 45 0c mov 0xc(%ebp),%eax 10ce1c: 89 41 0c mov %eax,0xc(%ecx) return SCHEDULER_CBS_OK; 10ce1f: 31 c0 xor %eax,%eax 10ce21: eb 38 jmp 10ce5b <_Scheduler_CBS_Create_server+0x8f> 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; 10ce23: b8 ee ff ff ff mov $0xffffffee,%eax 10ce28: eb 31 jmp 10ce5b <_Scheduler_CBS_Create_server+0x8f> *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; 10ce2a: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED 10ce2f: eb 2a jmp 10ce5b <_Scheduler_CBS_Create_server+0x8f><== NOT EXECUTED } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; 10ce31: 89 06 mov %eax,(%esi) _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 10ce33: 8b 15 ac 19 13 00 mov 0x1319ac,%edx 10ce39: 8d 3c 82 lea (%edx,%eax,4),%edi _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 10ce3c: 83 ec 0c sub $0xc,%esp 10ce3f: 6a 10 push $0x10 10ce41: e8 c2 18 00 00 call 10e708 <_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 *) 10ce46: 89 07 mov %eax,(%edi) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; 10ce48: 8b 16 mov (%esi),%edx 10ce4a: a1 ac 19 13 00 mov 0x1319ac,%eax 10ce4f: 8b 0c 90 mov (%eax,%edx,4),%ecx if ( !the_server ) 10ce52: 83 c4 10 add $0x10,%esp 10ce55: 85 c9 test %ecx,%ecx 10ce57: 75 af jne 10ce08 <_Scheduler_CBS_Create_server+0x3c><== ALWAYS TAKEN 10ce59: eb cf jmp 10ce2a <_Scheduler_CBS_Create_server+0x5e><== NOT EXECUTED the_server->parameters = *params; the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK; } 10ce5b: 8d 65 f4 lea -0xc(%ebp),%esp 10ce5e: 5b pop %ebx 10ce5f: 5e pop %esi 10ce60: 5f pop %edi 10ce61: 5d pop %ebp 10ce62: c3 ret =============================================================================== 0010ced4 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 10ced4: 55 push %ebp 10ced5: 89 e5 mov %esp,%ebp 10ced7: 57 push %edi 10ced8: 56 push %esi 10ced9: 53 push %ebx 10ceda: 83 ec 24 sub $0x24,%esp 10cedd: 8b 7d 08 mov 0x8(%ebp),%edi 10cee0: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; the_thread = _Thread_Get(task_id, &location); 10cee3: 8d 45 e4 lea -0x1c(%ebp),%eax 10cee6: 50 push %eax 10cee7: 56 push %esi 10cee8: e8 03 0b 00 00 call 10d9f0 <_Thread_Get> 10ceed: 89 c3 mov %eax,%ebx /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10ceef: 83 c4 10 add $0x10,%esp 10cef2: 85 c0 test %eax,%eax 10cef4: 74 05 je 10cefb <_Scheduler_CBS_Detach_thread+0x27> _Thread_Enable_dispatch(); 10cef6: e8 d5 0a 00 00 call 10d9d0 <_Thread_Enable_dispatch> } if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10cefb: 3b 3d 6c d2 12 00 cmp 0x12d26c,%edi 10cf01: 73 4d jae 10cf50 <_Scheduler_CBS_Detach_thread+0x7c> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) 10cf03: 85 db test %ebx,%ebx 10cf05: 74 49 je 10cf50 <_Scheduler_CBS_Detach_thread+0x7c> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 10cf07: a1 ac 19 13 00 mov 0x1319ac,%eax 10cf0c: 8b 04 b8 mov (%eax,%edi,4),%eax 10cf0f: 85 c0 test %eax,%eax 10cf11: 74 36 je 10cf49 <_Scheduler_CBS_Detach_thread+0x75> return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) 10cf13: 39 30 cmp %esi,(%eax) 10cf15: 75 39 jne 10cf50 <_Scheduler_CBS_Detach_thread+0x7c><== NEVER TAKEN return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; 10cf17: c7 00 ff ff ff ff movl $0xffffffff,(%eax) sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; 10cf1d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10cf23: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10cf2a: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10cf30: 89 43 78 mov %eax,0x78(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 10cf33: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 10cf39: 89 43 7c mov %eax,0x7c(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 10cf3c: 8a 83 9c 00 00 00 mov 0x9c(%ebx),%al 10cf42: 88 43 70 mov %al,0x70(%ebx) return SCHEDULER_CBS_OK; 10cf45: 31 c0 xor %eax,%eax 10cf47: eb 0c jmp 10cf55 <_Scheduler_CBS_Detach_thread+0x81> 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; 10cf49: b8 e7 ff ff ff mov $0xffffffe7,%eax 10cf4e: eb 05 jmp 10cf55 <_Scheduler_CBS_Detach_thread+0x81> if ( the_thread ) { _Thread_Enable_dispatch(); } if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10cf50: 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; } 10cf55: 8d 65 f4 lea -0xc(%ebp),%esp 10cf58: 5b pop %ebx 10cf59: 5e pop %esi 10cf5a: 5f pop %edi 10cf5b: 5d pop %ebp 10cf5c: c3 ret =============================================================================== 0010cf98 <_Scheduler_CBS_Get_execution_time>: int _Scheduler_CBS_Get_execution_time ( Scheduler_CBS_Server_id server_id, time_t *exec_time, time_t *abs_time ) { 10cf98: 55 push %ebp 10cf99: 89 e5 mov %esp,%ebp 10cf9b: 57 push %edi 10cf9c: 56 push %esi 10cf9d: 53 push %ebx 10cf9e: 83 ec 1c sub $0x1c,%esp 10cfa1: 8b 5d 08 mov 0x8(%ebp),%ebx 10cfa4: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10cfa7: 3b 1d 6c d2 12 00 cmp 0x12d26c,%ebx 10cfad: 73 58 jae 10d007 <_Scheduler_CBS_Get_execution_time+0x6f> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 10cfaf: a1 ac 19 13 00 mov 0x1319ac,%eax 10cfb4: 8b 04 98 mov (%eax,%ebx,4),%eax 10cfb7: 85 c0 test %eax,%eax 10cfb9: 74 53 je 10d00e <_Scheduler_CBS_Get_execution_time+0x76> return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 10cfbb: 8b 00 mov (%eax),%eax 10cfbd: 83 f8 ff cmp $0xffffffff,%eax 10cfc0: 75 08 jne 10cfca <_Scheduler_CBS_Get_execution_time+0x32> *exec_time = 0; 10cfc2: c7 06 00 00 00 00 movl $0x0,(%esi) 10cfc8: eb 39 jmp 10d003 <_Scheduler_CBS_Get_execution_time+0x6b> return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( 10cfca: 52 push %edx 10cfcb: 52 push %edx 10cfcc: 8d 55 e4 lea -0x1c(%ebp),%edx 10cfcf: 52 push %edx 10cfd0: 50 push %eax 10cfd1: e8 1a 0a 00 00 call 10d9f0 <_Thread_Get> 10cfd6: 89 c7 mov %eax,%edi _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10cfd8: 83 c4 10 add $0x10,%esp 10cfdb: 85 c0 test %eax,%eax 10cfdd: 74 17 je 10cff6 <_Scheduler_CBS_Get_execution_time+0x5e><== NEVER TAKEN _Thread_Enable_dispatch(); 10cfdf: e8 ec 09 00 00 call 10d9d0 <_Thread_Enable_dispatch> *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget - 10cfe4: a1 ac 19 13 00 mov 0x1319ac,%eax 10cfe9: 8b 04 98 mov (%eax,%ebx,4),%eax 10cfec: 8b 50 08 mov 0x8(%eax),%edx 10cfef: 2b 57 74 sub 0x74(%edi),%edx 10cff2: 89 16 mov %edx,(%esi) 10cff4: eb 0d jmp 10d003 <_Scheduler_CBS_Get_execution_time+0x6b> the_thread->cpu_time_budget; } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 10cff6: a1 ac 19 13 00 mov 0x1319ac,%eax <== NOT EXECUTED 10cffb: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED 10cffe: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10d001: 89 06 mov %eax,(%esi) <== NOT EXECUTED } return SCHEDULER_CBS_OK; 10d003: 31 c0 xor %eax,%eax 10d005: eb 0c jmp 10d013 <_Scheduler_CBS_Get_execution_time+0x7b> { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10d007: b8 ee ff ff ff mov $0xffffffee,%eax 10d00c: eb 05 jmp 10d013 <_Scheduler_CBS_Get_execution_time+0x7b> if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 10d00e: b8 e7 ff ff ff mov $0xffffffe7,%eax } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; } return SCHEDULER_CBS_OK; } 10d013: 8d 65 f4 lea -0xc(%ebp),%esp 10d016: 5b pop %ebx 10d017: 5e pop %esi 10d018: 5f pop %edi 10d019: 5d pop %ebp 10d01a: c3 ret =============================================================================== 0010d058 <_Scheduler_CBS_Get_remaining_budget>: int _Scheduler_CBS_Get_remaining_budget ( Scheduler_CBS_Server_id server_id, time_t *remaining_budget ) { 10d058: 55 push %ebp 10d059: 89 e5 mov %esp,%ebp 10d05b: 56 push %esi 10d05c: 53 push %ebx 10d05d: 83 ec 10 sub $0x10,%esp 10d060: 8b 45 08 mov 0x8(%ebp),%eax 10d063: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10d066: 3b 05 6c d2 12 00 cmp 0x12d26c,%eax 10d06c: 73 44 jae 10d0b2 <_Scheduler_CBS_Get_remaining_budget+0x5a> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 10d06e: 8b 15 ac 19 13 00 mov 0x1319ac,%edx 10d074: 8b 04 82 mov (%edx,%eax,4),%eax 10d077: 85 c0 test %eax,%eax 10d079: 74 3e je 10d0b9 <_Scheduler_CBS_Get_remaining_budget+0x61> return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 10d07b: 8b 10 mov (%eax),%edx 10d07d: 83 fa ff cmp $0xffffffff,%edx 10d080: 75 05 jne 10d087 <_Scheduler_CBS_Get_remaining_budget+0x2f> *remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 10d082: 8b 40 08 mov 0x8(%eax),%eax 10d085: eb 1d jmp 10d0a4 <_Scheduler_CBS_Get_remaining_budget+0x4c> return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( 10d087: 50 push %eax 10d088: 50 push %eax 10d089: 8d 45 f4 lea -0xc(%ebp),%eax 10d08c: 50 push %eax 10d08d: 52 push %edx 10d08e: e8 5d 09 00 00 call 10d9f0 <_Thread_Get> 10d093: 89 c6 mov %eax,%esi _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10d095: 83 c4 10 add $0x10,%esp 10d098: 85 c0 test %eax,%eax 10d09a: 74 0c je 10d0a8 <_Scheduler_CBS_Get_remaining_budget+0x50><== NEVER TAKEN _Thread_Enable_dispatch(); 10d09c: e8 2f 09 00 00 call 10d9d0 <_Thread_Enable_dispatch> *remaining_budget = the_thread->cpu_time_budget; 10d0a1: 8b 46 74 mov 0x74(%esi),%eax 10d0a4: 89 03 mov %eax,(%ebx) 10d0a6: eb 06 jmp 10d0ae <_Scheduler_CBS_Get_remaining_budget+0x56> } else { *remaining_budget = 0; 10d0a8: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED } return SCHEDULER_CBS_OK; 10d0ae: 31 c0 xor %eax,%eax 10d0b0: eb 0c jmp 10d0be <_Scheduler_CBS_Get_remaining_budget+0x66> { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10d0b2: b8 ee ff ff ff mov $0xffffffee,%eax 10d0b7: eb 05 jmp 10d0be <_Scheduler_CBS_Get_remaining_budget+0x66> if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 10d0b9: b8 e7 ff ff ff mov $0xffffffe7,%eax else { *remaining_budget = 0; } return SCHEDULER_CBS_OK; } 10d0be: 8d 65 f8 lea -0x8(%ebp),%esp 10d0c1: 5b pop %ebx 10d0c2: 5e pop %esi 10d0c3: 5d pop %ebp 10d0c4: c3 ret =============================================================================== 0010d15c <_Scheduler_CBS_Initialize>: int _Scheduler_CBS_Initialize(void) { 10d15c: 55 push %ebp 10d15d: 89 e5 mov %esp,%ebp 10d15f: 83 ec 14 sub $0x14,%esp unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 10d162: a1 6c d2 12 00 mov 0x12d26c,%eax 10d167: c1 e0 02 shl $0x2,%eax 10d16a: 50 push %eax 10d16b: e8 98 15 00 00 call 10e708 <_Workspace_Allocate> 10d170: a3 ac 19 13 00 mov %eax,0x1319ac _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 10d175: 83 c4 10 add $0x10,%esp 10d178: 85 c0 test %eax,%eax 10d17a: 74 20 je 10d19c <_Scheduler_CBS_Initialize+0x40><== NEVER TAKEN return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 10d17c: 8b 15 6c d2 12 00 mov 0x12d26c,%edx 10d182: 31 c0 xor %eax,%eax 10d184: eb 0e jmp 10d194 <_Scheduler_CBS_Initialize+0x38> _Scheduler_CBS_Server_list[i] = NULL; 10d186: 8b 0d ac 19 13 00 mov 0x1319ac,%ecx 10d18c: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,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++) { 10d193: 40 inc %eax 10d194: 39 d0 cmp %edx,%eax 10d196: 75 ee jne 10d186 <_Scheduler_CBS_Initialize+0x2a> _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 10d198: 31 c0 xor %eax,%eax 10d19a: eb 05 jmp 10d1a1 <_Scheduler_CBS_Initialize+0x45> { 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; 10d19c: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; } 10d1a1: c9 leave 10d1a2: c3 ret =============================================================================== 0010bd0c <_Scheduler_CBS_Release_job>: void _Scheduler_CBS_Release_job( Thread_Control *the_thread, uint32_t deadline ) { 10bd0c: 55 push %ebp 10bd0d: 89 e5 mov %esp,%ebp 10bd0f: 83 ec 08 sub $0x8,%esp 10bd12: 8b 55 08 mov 0x8(%ebp),%edx 10bd15: 8b 45 0c mov 0xc(%ebp),%eax 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; 10bd18: 8b 8a 88 00 00 00 mov 0x88(%edx),%ecx ) { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = 10bd1e: 8b 49 18 mov 0x18(%ecx),%ecx (Scheduler_CBS_Server *) sched_info->cbs_server; if (deadline) { 10bd21: 85 c0 test %eax,%eax 10bd23: 74 22 je 10bd47 <_Scheduler_CBS_Release_job+0x3b> /* Initializing or shifting deadline. */ if (serv_info) 10bd25: 85 c9 test %ecx,%ecx 10bd27: 74 0f je 10bd38 <_Scheduler_CBS_Release_job+0x2c> new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) 10bd29: a1 40 f5 12 00 mov 0x12f540,%eax 10bd2e: 03 41 04 add 0x4(%ecx),%eax 10bd31: 25 ff ff ff 7f and $0x7fffffff,%eax 10bd36: eb 19 jmp 10bd51 <_Scheduler_CBS_Release_job+0x45> & ~SCHEDULER_EDF_PRIO_MSB; else new_priority = (_Watchdog_Ticks_since_boot + deadline) 10bd38: 8b 0d 40 f5 12 00 mov 0x12f540,%ecx 10bd3e: 01 c8 add %ecx,%eax 10bd40: 25 ff ff ff 7f and $0x7fffffff,%eax 10bd45: eb 10 jmp 10bd57 <_Scheduler_CBS_Release_job+0x4b> & ~SCHEDULER_EDF_PRIO_MSB; } else { /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; 10bd47: 8b 82 ac 00 00 00 mov 0xac(%edx),%eax } /* Budget replenishment for the next job. */ if (serv_info) 10bd4d: 85 c9 test %ecx,%ecx 10bd4f: 74 06 je 10bd57 <_Scheduler_CBS_Release_job+0x4b><== NEVER TAKEN the_thread->cpu_time_budget = serv_info->parameters.budget; 10bd51: 8b 49 08 mov 0x8(%ecx),%ecx 10bd54: 89 4a 74 mov %ecx,0x74(%edx) the_thread->real_priority = new_priority; 10bd57: 89 42 18 mov %eax,0x18(%edx) _Thread_Change_priority(the_thread, new_priority, true); 10bd5a: 51 push %ecx 10bd5b: 6a 01 push $0x1 10bd5d: 50 push %eax 10bd5e: 52 push %edx 10bd5f: e8 9c 03 00 00 call 10c100 <_Thread_Change_priority> 10bd64: 83 c4 10 add $0x10,%esp } 10bd67: c9 leave 10bd68: c3 ret =============================================================================== 0010bd6c <_Scheduler_CBS_Unblock>: #include void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) { 10bd6c: 55 push %ebp 10bd6d: 89 e5 mov %esp,%ebp 10bd6f: 56 push %esi 10bd70: 53 push %ebx 10bd71: 8b 5d 08 mov 0x8(%ebp),%ebx Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server *serv_info; Priority_Control new_priority; _Scheduler_EDF_Enqueue(the_thread); 10bd74: 83 ec 0c sub $0xc,%esp 10bd77: 53 push %ebx 10bd78: e8 cf 00 00 00 call 10be4c <_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; 10bd7d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10bd83: 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) { 10bd86: 83 c4 10 add $0x10,%esp 10bd89: 85 c0 test %eax,%eax 10bd8b: 74 3d je 10bdca <_Scheduler_CBS_Unblock+0x5e> 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 - 10bd8d: 8b 4b 18 mov 0x18(%ebx),%ecx 10bd90: 8b 15 40 f5 12 00 mov 0x12f540,%edx 10bd96: 89 ce mov %ecx,%esi 10bd98: 29 d6 sub %edx,%esi _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 10bd9a: 8b 50 04 mov 0x4(%eax),%edx 10bd9d: 0f af d6 imul %esi,%edx 10bda0: 8b 40 08 mov 0x8(%eax),%eax 10bda3: 0f af 43 74 imul 0x74(%ebx),%eax 10bda7: 39 c2 cmp %eax,%edx 10bda9: 7e 1f jle 10bdca <_Scheduler_CBS_Unblock+0x5e> /* Put late unblocked task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 10bdab: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax if ( the_thread->real_priority != new_priority ) 10bdb1: 39 c1 cmp %eax,%ecx 10bdb3: 74 03 je 10bdb8 <_Scheduler_CBS_Unblock+0x4c> the_thread->real_priority = new_priority; 10bdb5: 89 43 18 mov %eax,0x18(%ebx) if ( the_thread->current_priority != new_priority ) 10bdb8: 39 43 14 cmp %eax,0x14(%ebx) 10bdbb: 74 0d je 10bdca <_Scheduler_CBS_Unblock+0x5e> _Thread_Change_priority(the_thread, new_priority, true); 10bdbd: 52 push %edx 10bdbe: 6a 01 push $0x1 10bdc0: 50 push %eax 10bdc1: 53 push %ebx 10bdc2: e8 39 03 00 00 call 10c100 <_Thread_Change_priority> 10bdc7: 83 c4 10 add $0x10,%esp 10bdca: 50 push %eax 10bdcb: 50 push %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, 10bdcc: a1 58 f9 12 00 mov 0x12f958,%eax 10bdd1: ff 70 14 pushl 0x14(%eax) 10bdd4: ff 73 14 pushl 0x14(%ebx) 10bdd7: ff 15 60 b2 12 00 call *0x12b260 10bddd: 83 c4 10 add $0x10,%esp 10bde0: 85 c0 test %eax,%eax 10bde2: 7e 1e jle 10be02 <_Scheduler_CBS_Unblock+0x96> _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; 10bde4: 89 1d 58 f9 12 00 mov %ebx,0x12f958 if ( _Thread_Executing->is_preemptible || 10bdea: a1 54 f9 12 00 mov 0x12f954,%eax 10bdef: 80 78 70 00 cmpb $0x0,0x70(%eax) 10bdf3: 75 06 jne 10bdfb <_Scheduler_CBS_Unblock+0x8f> 10bdf5: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10bdf9: 75 07 jne 10be02 <_Scheduler_CBS_Unblock+0x96><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10bdfb: c6 05 60 f9 12 00 01 movb $0x1,0x12f960 } } 10be02: 8d 65 f8 lea -0x8(%ebp),%esp 10be05: 5b pop %ebx 10be06: 5e pop %esi 10be07: 5d pop %ebp 10be08: c3 ret =============================================================================== 0010bcd8 <_Scheduler_EDF_Allocate>: #include void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) { 10bcd8: 55 push %ebp 10bcd9: 89 e5 mov %esp,%ebp 10bcdb: 53 push %ebx 10bcdc: 83 ec 10 sub $0x10,%esp 10bcdf: 8b 5d 08 mov 0x8(%ebp),%ebx void *sched; Scheduler_EDF_Per_thread *schinfo; sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) ); 10bce2: 6a 18 push $0x18 10bce4: e8 27 15 00 00 call 10d210 <_Workspace_Allocate> if ( sched ) { 10bce9: 83 c4 10 add $0x10,%esp 10bcec: 85 c0 test %eax,%eax 10bcee: 74 0f je 10bcff <_Scheduler_EDF_Allocate+0x27><== NEVER TAKEN the_thread->scheduler_info = sched; 10bcf0: 89 83 88 00 00 00 mov %eax,0x88(%ebx) schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info); schinfo->thread = the_thread; 10bcf6: 89 18 mov %ebx,(%eax) schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 10bcf8: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax) } return sched; } 10bcff: 8b 5d fc mov -0x4(%ebp),%ebx 10bd02: c9 leave 10bd03: c3 ret =============================================================================== 0010bea0 <_Scheduler_EDF_Unblock>: #include void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) { 10bea0: 55 push %ebp 10bea1: 89 e5 mov %esp,%ebp 10bea3: 53 push %ebx 10bea4: 83 ec 10 sub $0x10,%esp 10bea7: 8b 5d 08 mov 0x8(%ebp),%ebx _Scheduler_EDF_Enqueue(the_thread); 10beaa: 53 push %ebx 10beab: e8 94 fe ff ff call 10bd44 <_Scheduler_EDF_Enqueue> 10beb0: 58 pop %eax 10beb1: 5a pop %edx 10beb2: ff 73 14 pushl 0x14(%ebx) * 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( 10beb5: a1 58 f9 12 00 mov 0x12f958,%eax 10beba: ff 70 14 pushl 0x14(%eax) 10bebd: ff 15 60 b2 12 00 call *0x12b260 10bec3: 83 c4 10 add $0x10,%esp 10bec6: 85 c0 test %eax,%eax 10bec8: 79 1e jns 10bee8 <_Scheduler_EDF_Unblock+0x48> _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; 10beca: 89 1d 58 f9 12 00 mov %ebx,0x12f958 if ( _Thread_Executing->is_preemptible || 10bed0: a1 54 f9 12 00 mov 0x12f954,%eax 10bed5: 80 78 70 00 cmpb $0x0,0x70(%eax) 10bed9: 75 06 jne 10bee1 <_Scheduler_EDF_Unblock+0x41> 10bedb: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10bedf: 75 07 jne 10bee8 <_Scheduler_EDF_Unblock+0x48><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10bee1: c6 05 60 f9 12 00 01 movb $0x1,0x12f960 } } 10bee8: 8b 5d fc mov -0x4(%ebp),%ebx 10beeb: c9 leave 10beec: c3 ret =============================================================================== 0010b854 <_Scheduler_priority_Tick>: #include #include void _Scheduler_priority_Tick( void ) { 10b854: 55 push %ebp 10b855: 89 e5 mov %esp,%ebp 10b857: 53 push %ebx 10b858: 50 push %eax Thread_Control *executing; executing = _Thread_Executing; 10b859: 8b 1d ec e8 12 00 mov 0x12e8ec,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10b85f: 80 7b 70 00 cmpb $0x0,0x70(%ebx) 10b863: 74 44 je 10b8a9 <_Scheduler_priority_Tick+0x55> return; if ( !_States_Is_ready( executing->current_state ) ) 10b865: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10b869: 75 3e jne 10b8a9 <_Scheduler_priority_Tick+0x55> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10b86b: 8b 43 78 mov 0x78(%ebx),%eax 10b86e: 83 f8 01 cmp $0x1,%eax 10b871: 72 36 jb 10b8a9 <_Scheduler_priority_Tick+0x55> 10b873: 83 f8 02 cmp $0x2,%eax 10b876: 76 07 jbe 10b87f <_Scheduler_priority_Tick+0x2b> 10b878: 83 f8 03 cmp $0x3,%eax 10b87b: 75 2c jne 10b8a9 <_Scheduler_priority_Tick+0x55><== NEVER TAKEN 10b87d: eb 1b jmp 10b89a <_Scheduler_priority_Tick+0x46> case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10b87f: 8b 43 74 mov 0x74(%ebx),%eax 10b882: 48 dec %eax 10b883: 89 43 74 mov %eax,0x74(%ebx) 10b886: 85 c0 test %eax,%eax 10b888: 7f 1f jg 10b8a9 <_Scheduler_priority_Tick+0x55> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 10b88a: ff 15 3c a2 12 00 call *0x12a23c * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield(); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b890: a1 b8 e3 12 00 mov 0x12e3b8,%eax 10b895: 89 43 74 mov %eax,0x74(%ebx) 10b898: eb 0f jmp 10b8a9 <_Scheduler_priority_Tick+0x55> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10b89a: ff 4b 74 decl 0x74(%ebx) 10b89d: 75 0a jne 10b8a9 <_Scheduler_priority_Tick+0x55> (*executing->budget_callout)( executing ); 10b89f: 83 ec 0c sub $0xc,%esp 10b8a2: 53 push %ebx 10b8a3: ff 53 7c call *0x7c(%ebx) 10b8a6: 83 c4 10 add $0x10,%esp break; #endif } } 10b8a9: 8b 5d fc mov -0x4(%ebp),%ebx 10b8ac: c9 leave 10b8ad: c3 ret =============================================================================== 0010a6b8 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10a6b8: 55 push %ebp 10a6b9: 89 e5 mov %esp,%ebp 10a6bb: 53 push %ebx 10a6bc: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10a6bf: b8 40 42 0f 00 mov $0xf4240,%eax 10a6c4: 31 d2 xor %edx,%edx 10a6c6: f7 35 0c c8 12 00 divl 0x12c80c (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; 10a6cc: 31 db xor %ebx,%ebx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10a6ce: 85 c9 test %ecx,%ecx 10a6d0: 74 4c je 10a71e <_TOD_Validate+0x66> <== NEVER TAKEN 10a6d2: 39 41 18 cmp %eax,0x18(%ecx) 10a6d5: 73 47 jae 10a71e <_TOD_Validate+0x66> (the_tod->ticks >= ticks_per_second) || 10a6d7: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10a6db: 77 41 ja 10a71e <_TOD_Validate+0x66> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10a6dd: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10a6e1: 77 3b ja 10a71e <_TOD_Validate+0x66> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10a6e3: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10a6e7: 77 35 ja 10a71e <_TOD_Validate+0x66> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10a6e9: 8b 51 04 mov 0x4(%ecx),%edx 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) || 10a6ec: 85 d2 test %edx,%edx 10a6ee: 74 2e je 10a71e <_TOD_Validate+0x66> <== NEVER TAKEN (the_tod->month == 0) || 10a6f0: 83 fa 0c cmp $0xc,%edx 10a6f3: 77 29 ja 10a71e <_TOD_Validate+0x66> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10a6f5: 8b 01 mov (%ecx),%eax (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) || 10a6f7: 3d c3 07 00 00 cmp $0x7c3,%eax 10a6fc: 76 20 jbe 10a71e <_TOD_Validate+0x66> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10a6fe: 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) || 10a701: 85 c9 test %ecx,%ecx 10a703: 74 19 je 10a71e <_TOD_Validate+0x66> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10a705: a8 03 test $0x3,%al 10a707: 75 09 jne 10a712 <_TOD_Validate+0x5a> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10a709: 8b 04 95 b8 18 12 00 mov 0x1218b8(,%edx,4),%eax 10a710: eb 07 jmp 10a719 <_TOD_Validate+0x61> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10a712: 8b 04 95 84 18 12 00 mov 0x121884(,%edx,4),%eax if ( the_tod->day > days_in_month ) 10a719: 39 c1 cmp %eax,%ecx 10a71b: 0f 96 c3 setbe %bl return false; return true; } 10a71e: 88 d8 mov %bl,%al 10a720: 5b pop %ebx 10a721: 5d pop %ebp 10a722: c3 ret =============================================================================== 0010ba1c <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10ba1c: 55 push %ebp 10ba1d: 89 e5 mov %esp,%ebp 10ba1f: 57 push %edi 10ba20: 56 push %esi 10ba21: 53 push %ebx 10ba22: 83 ec 28 sub $0x28,%esp 10ba25: 8b 7d 08 mov 0x8(%ebp),%edi 10ba28: 8b 5d 0c mov 0xc(%ebp),%ebx 10ba2b: 8a 45 10 mov 0x10(%ebp),%al 10ba2e: 88 45 e7 mov %al,-0x19(%ebp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10ba31: 8b 77 10 mov 0x10(%edi),%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 ); 10ba34: 57 push %edi 10ba35: e8 72 0b 00 00 call 10c5ac <_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 ) 10ba3a: 83 c4 10 add $0x10,%esp 10ba3d: 39 5f 14 cmp %ebx,0x14(%edi) 10ba40: 74 0c je 10ba4e <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10ba42: 50 push %eax 10ba43: 50 push %eax 10ba44: 53 push %ebx 10ba45: 57 push %edi 10ba46: e8 15 0b 00 00 call 10c560 <_Thread_Set_priority> 10ba4b: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10ba4e: 9c pushf 10ba4f: fa cli 10ba50: 5b pop %ebx /* * 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; 10ba51: 8b 47 10 mov 0x10(%edi),%eax if ( state != STATES_TRANSIENT ) { 10ba54: 83 f8 04 cmp $0x4,%eax 10ba57: 74 2b je 10ba84 <_Thread_Change_priority+0x68> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10ba59: 83 e6 04 and $0x4,%esi 10ba5c: 75 08 jne 10ba66 <_Thread_Change_priority+0x4a><== NEVER TAKEN RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10ba5e: 89 c2 mov %eax,%edx 10ba60: 83 e2 fb and $0xfffffffb,%edx 10ba63: 89 57 10 mov %edx,0x10(%edi) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10ba66: 53 push %ebx 10ba67: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10ba68: a9 e0 be 03 00 test $0x3bee0,%eax 10ba6d: 74 65 je 10bad4 <_Thread_Change_priority+0xb8> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10ba6f: 89 7d 0c mov %edi,0xc(%ebp) 10ba72: 8b 47 44 mov 0x44(%edi),%eax 10ba75: 89 45 08 mov %eax,0x8(%ebp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10ba78: 8d 65 f4 lea -0xc(%ebp),%esp 10ba7b: 5b pop %ebx 10ba7c: 5e pop %esi 10ba7d: 5f pop %edi 10ba7e: 5d pop %ebp /* 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 ); 10ba7f: e9 4c 0a 00 00 jmp 10c4d0 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10ba84: 83 e6 04 and $0x4,%esi 10ba87: 75 26 jne 10baaf <_Thread_Change_priority+0x93><== 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 ); 10ba89: c7 47 10 00 00 00 00 movl $0x0,0x10(%edi) if ( prepend_it ) 10ba90: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10ba94: 74 0c je 10baa2 <_Thread_Change_priority+0x86> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10ba96: 83 ec 0c sub $0xc,%esp 10ba99: 57 push %edi 10ba9a: ff 15 58 a2 12 00 call *0x12a258 10baa0: eb 0a jmp 10baac <_Thread_Change_priority+0x90> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10baa2: 83 ec 0c sub $0xc,%esp 10baa5: 57 push %edi 10baa6: ff 15 54 a2 12 00 call *0x12a254 10baac: 83 c4 10 add $0x10,%esp _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10baaf: 53 push %ebx 10bab0: 9d popf 10bab1: 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(); 10bab2: ff 15 38 a2 12 00 call *0x12a238 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bab8: a1 ec e8 12 00 mov 0x12e8ec,%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() && 10babd: 3b 05 f0 e8 12 00 cmp 0x12e8f0,%eax 10bac3: 74 0d je 10bad2 <_Thread_Change_priority+0xb6> 10bac5: 80 78 70 00 cmpb $0x0,0x70(%eax) 10bac9: 74 07 je 10bad2 <_Thread_Change_priority+0xb6> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bacb: c6 05 f8 e8 12 00 01 movb $0x1,0x12e8f8 _ISR_Enable( level ); 10bad2: 53 push %ebx 10bad3: 9d popf } 10bad4: 8d 65 f4 lea -0xc(%ebp),%esp 10bad7: 5b pop %ebx 10bad8: 5e pop %esi 10bad9: 5f pop %edi 10bada: 5d pop %ebp 10badb: c3 ret =============================================================================== 0010bc90 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bc90: 55 push %ebp 10bc91: 89 e5 mov %esp,%ebp 10bc93: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bc96: 8d 45 f4 lea -0xc(%ebp),%eax 10bc99: 50 push %eax 10bc9a: ff 75 08 pushl 0x8(%ebp) 10bc9d: e8 8a 01 00 00 call 10be2c <_Thread_Get> switch ( location ) { 10bca2: 83 c4 10 add $0x10,%esp 10bca5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bca9: 75 20 jne 10bccb <_Thread_Delay_ended+0x3b><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bcab: 52 push %edx 10bcac: 52 push %edx 10bcad: 68 18 00 00 10 push $0x10000018 10bcb2: 50 push %eax 10bcb3: e8 24 fe ff ff call 10badc <_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--; 10bcb8: a1 e4 e3 12 00 mov 0x12e3e4,%eax 10bcbd: 48 dec %eax 10bcbe: a3 e4 e3 12 00 mov %eax,0x12e3e4 return _Thread_Dispatch_disable_level; 10bcc3: a1 e4 e3 12 00 mov 0x12e3e4,%eax 10bcc8: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bccb: c9 leave 10bccc: c3 ret =============================================================================== 0010bcd0 <_Thread_Dispatch>: * INTERRUPT LATENCY: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bcd0: 55 push %ebp 10bcd1: 89 e5 mov %esp,%ebp 10bcd3: 57 push %edi 10bcd4: 56 push %esi 10bcd5: 53 push %ebx 10bcd6: 83 ec 1c sub $0x1c,%esp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10bcd9: a1 e4 e3 12 00 mov 0x12e3e4,%eax 10bcde: 40 inc %eax 10bcdf: a3 e4 e3 12 00 mov %eax,0x12e3e4 return _Thread_Dispatch_disable_level; 10bce4: a1 e4 e3 12 00 mov 0x12e3e4,%eax void _Thread_Disable_dispatch( void ); #else RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void ) { _Thread_Dispatch_increment_disable_level(); RTEMS_COMPILER_MEMORY_BARRIER(); 10bce9: e9 f9 00 00 00 jmp 10bde7 <_Thread_Dispatch+0x117> */ executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { heir = _Thread_Heir; 10bcee: 8b 35 f0 e8 12 00 mov 0x12e8f0,%esi _Thread_Dispatch_necessary = false; 10bcf4: c6 05 f8 e8 12 00 00 movb $0x0,0x12e8f8 _Thread_Executing = heir; 10bcfb: 89 35 ec e8 12 00 mov %esi,0x12e8ec /* * 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 ) 10bd01: 39 fe cmp %edi,%esi 10bd03: 75 1c jne 10bd21 <_Thread_Dispatch+0x51> _ISR_Disable( level ); } post_switch: _ISR_Enable( level ); 10bd05: 50 push %eax 10bd06: 9d popf * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10bd07: a1 e4 e3 12 00 mov 0x12e3e4,%eax 10bd0c: 48 dec %eax 10bd0d: a3 e4 e3 12 00 mov %eax,0x12e3e4 return _Thread_Dispatch_disable_level; 10bd12: a1 e4 e3 12 00 mov 0x12e3e4,%eax _Thread_Unnest_dispatch(); _API_extensions_Run_postswitch(); 10bd17: e8 39 e8 ff ff call 10a555 <_API_extensions_Run_postswitch> 10bd1c: e9 e2 00 00 00 jmp 10be03 <_Thread_Dispatch+0x133> */ #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 ) 10bd21: 83 7e 78 01 cmpl $0x1,0x78(%esi) 10bd25: 75 09 jne 10bd30 <_Thread_Dispatch+0x60> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bd27: 8b 15 b8 e3 12 00 mov 0x12e3b8,%edx 10bd2d: 89 56 74 mov %edx,0x74(%esi) _ISR_Enable( level ); 10bd30: 50 push %eax 10bd31: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bd32: 83 ec 0c sub $0xc,%esp 10bd35: 8d 45 e0 lea -0x20(%ebp),%eax 10bd38: 50 push %eax 10bd39: e8 06 34 00 00 call 10f144 <_TOD_Get_uptime> _Timestamp_Subtract( 10bd3e: 8b 45 e0 mov -0x20(%ebp),%eax 10bd41: 8b 55 e4 mov -0x1c(%ebp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 10bd44: 89 c1 mov %eax,%ecx 10bd46: 89 d3 mov %edx,%ebx 10bd48: 2b 0d fc e8 12 00 sub 0x12e8fc,%ecx 10bd4e: 1b 1d 00 e9 12 00 sbb 0x12e900,%ebx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 10bd54: 01 8f 80 00 00 00 add %ecx,0x80(%edi) 10bd5a: 11 9f 84 00 00 00 adc %ebx,0x84(%edi) &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); _Thread_Time_of_last_context_switch = uptime; 10bd60: a3 fc e8 12 00 mov %eax,0x12e8fc 10bd65: 89 15 00 e9 12 00 mov %edx,0x12e900 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10bd6b: a1 5c e4 12 00 mov 0x12e45c,%eax 10bd70: 83 c4 10 add $0x10,%esp 10bd73: 85 c0 test %eax,%eax 10bd75: 74 10 je 10bd87 <_Thread_Dispatch+0xb7> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10bd77: 8b 10 mov (%eax),%edx 10bd79: 89 97 e0 00 00 00 mov %edx,0xe0(%edi) *_Thread_libc_reent = heir->libc_reent; 10bd7f: 8b 96 e0 00 00 00 mov 0xe0(%esi),%edx 10bd85: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10bd87: 50 push %eax 10bd88: 50 push %eax 10bd89: 56 push %esi 10bd8a: 57 push %edi 10bd8b: e8 48 0b 00 00 call 10c8d8 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10bd90: 5a pop %edx 10bd91: 59 pop %ecx 10bd92: 8d 86 c4 00 00 00 lea 0xc4(%esi),%eax 10bd98: 50 push %eax 10bd99: 8d 87 c4 00 00 00 lea 0xc4(%edi),%eax 10bd9f: 50 push %eax 10bda0: e8 0b 0e 00 00 call 10cbb0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10bda5: 83 c4 10 add $0x10,%esp 10bda8: 83 bf dc 00 00 00 00 cmpl $0x0,0xdc(%edi) 10bdaf: 74 36 je 10bde7 <_Thread_Dispatch+0x117> #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 ); 10bdb1: a1 58 e4 12 00 mov 0x12e458,%eax 10bdb6: 39 c7 cmp %eax,%edi 10bdb8: 74 2d je 10bde7 <_Thread_Dispatch+0x117> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10bdba: 85 c0 test %eax,%eax 10bdbc: 74 11 je 10bdcf <_Thread_Dispatch+0xff> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10bdbe: 83 ec 0c sub $0xc,%esp 10bdc1: 05 dc 00 00 00 add $0xdc,%eax 10bdc6: 50 push %eax 10bdc7: e8 18 0e 00 00 call 10cbe4 <_CPU_Context_save_fp> 10bdcc: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10bdcf: 83 ec 0c sub $0xc,%esp 10bdd2: 8d 87 dc 00 00 00 lea 0xdc(%edi),%eax 10bdd8: 50 push %eax 10bdd9: e8 10 0e 00 00 call 10cbee <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10bdde: 89 3d 58 e4 12 00 mov %edi,0x12e458 10bde4: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10bde7: 8b 3d ec e8 12 00 mov 0x12e8ec,%edi _ISR_Disable( level ); 10bded: 9c pushf 10bdee: fa cli 10bdef: 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 ) { 10bdf0: 8a 15 f8 e8 12 00 mov 0x12e8f8,%dl 10bdf6: 84 d2 test %dl,%dl 10bdf8: 0f 85 f0 fe ff ff jne 10bcee <_Thread_Dispatch+0x1e> 10bdfe: e9 02 ff ff ff jmp 10bd05 <_Thread_Dispatch+0x35> _ISR_Enable( level ); _Thread_Unnest_dispatch(); _API_extensions_Run_postswitch(); } 10be03: 8d 65 f4 lea -0xc(%ebp),%esp 10be06: 5b pop %ebx 10be07: 5e pop %esi 10be08: 5f pop %edi 10be09: 5d pop %ebp 10be0a: c3 ret =============================================================================== 00110d08 <_Thread_Handler>: * Input parameters: NONE * * Output parameters: NONE */ void _Thread_Handler( void ) { 110d08: 55 push %ebp 110d09: 89 e5 mov %esp,%ebp 110d0b: 53 push %ebx 110d0c: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static bool doneConstructors; bool doCons; #endif executing = _Thread_Executing; 110d0f: 8b 1d ec e8 12 00 mov 0x12e8ec,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110d15: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax _ISR_Set_level(level); 110d1b: 85 c0 test %eax,%eax 110d1d: 74 03 je 110d22 <_Thread_Handler+0x1a> 110d1f: fa cli 110d20: eb 01 jmp 110d23 <_Thread_Handler+0x1b> 110d22: fb sti doCons = !doneConstructors && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API; if (doCons) doneConstructors = true; #else doCons = !doneConstructors; 110d23: a0 d4 e0 12 00 mov 0x12e0d4,%al 110d28: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = true; 110d2b: c6 05 d4 e0 12 00 01 movb $0x1,0x12e0d4 #endif #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110d32: 83 bb dc 00 00 00 00 cmpl $0x0,0xdc(%ebx) 110d39: 74 24 je 110d5f <_Thread_Handler+0x57> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 110d3b: a1 58 e4 12 00 mov 0x12e458,%eax 110d40: 39 c3 cmp %eax,%ebx 110d42: 74 1b je 110d5f <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110d44: 85 c0 test %eax,%eax 110d46: 74 11 je 110d59 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110d48: 83 ec 0c sub $0xc,%esp 110d4b: 05 dc 00 00 00 add $0xdc,%eax 110d50: 50 push %eax 110d51: e8 8e be ff ff call 10cbe4 <_CPU_Context_save_fp> 110d56: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110d59: 89 1d 58 e4 12 00 mov %ebx,0x12e458 /* * 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 ); 110d5f: 83 ec 0c sub $0xc,%esp 110d62: 53 push %ebx 110d63: e8 34 ba ff ff call 10c79c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110d68: e8 9f b0 ff ff call 10be0c <_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) */ { 110d6d: 83 c4 10 add $0x10,%esp 110d70: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 110d74: 75 05 jne 110d7b <_Thread_Handler+0x73> INIT_NAME (); 110d76: e8 b1 d0 00 00 call 11de2c <__start_set_sysctl_set> _Thread_Enable_dispatch(); #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 110d7b: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax 110d81: 85 c0 test %eax,%eax 110d83: 75 0b jne 110d90 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 110d85: 83 ec 0c sub $0xc,%esp 110d88: ff b3 98 00 00 00 pushl 0x98(%ebx) 110d8e: eb 0c jmp 110d9c <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 110d90: 48 dec %eax 110d91: 75 15 jne 110da8 <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 110d93: 83 ec 0c sub $0xc,%esp 110d96: ff b3 94 00 00 00 pushl 0x94(%ebx) 110d9c: ff 93 8c 00 00 00 call *0x8c(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 110da2: 89 43 28 mov %eax,0x28(%ebx) 110da5: 83 c4 10 add $0x10,%esp * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 110da8: 83 ec 0c sub $0xc,%esp 110dab: 53 push %ebx 110dac: e8 19 ba ff ff call 10c7ca <_User_extensions_Thread_exitted> _Internal_error_Occurred( 110db1: 83 c4 0c add $0xc,%esp 110db4: 6a 05 push $0x5 110db6: 6a 01 push $0x1 110db8: 6a 00 push $0x0 110dba: e8 0d a0 ff ff call 10adcc <_Internal_error_Occurred> =============================================================================== 0010c0d8 <_Thread_Handler_initialization>: * * Output parameters: NONE */ void _Thread_Handler_initialization(void) { 10c0d8: 55 push %ebp 10c0d9: 89 e5 mov %esp,%ebp 10c0db: 56 push %esi 10c0dc: 53 push %ebx uint32_t ticks_per_timeslice = 10c0dd: 8b 1d 54 a1 12 00 mov 0x12a154,%ebx rtems_configuration_get_ticks_per_timeslice(); uint32_t maximum_extensions = 10c0e3: 8b 35 48 a1 12 00 mov 0x12a148,%esi rtems_configuration_get_maximum_extensions(); rtems_stack_allocate_init_hook stack_allocate_init_hook = 10c0e9: a1 64 a1 12 00 mov 0x12a164,%eax #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 10c0ee: 83 3d 68 a1 12 00 00 cmpl $0x0,0x12a168 10c0f5: 74 09 je 10c100 <_Thread_Handler_initialization+0x28> 10c0f7: 83 3d 6c a1 12 00 00 cmpl $0x0,0x12a16c 10c0fe: 75 0c jne 10c10c <_Thread_Handler_initialization+0x34><== ALWAYS TAKEN rtems_configuration_get_stack_free_hook() == NULL) _Internal_error_Occurred( 10c100: 52 push %edx 10c101: 6a 0e push $0xe 10c103: 6a 01 push $0x1 10c105: 6a 00 push $0x0 10c107: e8 c0 ec ff ff call 10adcc <_Internal_error_Occurred> INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_BAD_STACK_HOOK ); if ( stack_allocate_init_hook != NULL ) 10c10c: 85 c0 test %eax,%eax 10c10e: 74 0e je 10c11e <_Thread_Handler_initialization+0x46> (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() ); 10c110: 83 ec 0c sub $0xc,%esp 10c113: ff 35 44 a1 12 00 pushl 0x12a144 10c119: ff d0 call *%eax 10c11b: 83 c4 10 add $0x10,%esp _Thread_Dispatch_necessary = false; 10c11e: c6 05 f8 e8 12 00 00 movb $0x0,0x12e8f8 _Thread_Executing = NULL; 10c125: c7 05 ec e8 12 00 00 movl $0x0,0x12e8ec 10c12c: 00 00 00 _Thread_Heir = NULL; 10c12f: c7 05 f0 e8 12 00 00 movl $0x0,0x12e8f0 10c136: 00 00 00 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10c139: c7 05 58 e4 12 00 00 movl $0x0,0x12e458 10c140: 00 00 00 #endif _Thread_Maximum_extensions = maximum_extensions; 10c143: 89 35 60 e4 12 00 mov %esi,0x12e460 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10c149: 89 1d b8 e3 12 00 mov %ebx,0x12e3b8 #if defined(RTEMS_MULTIPROCESSING) if ( _System_state_Is_multiprocessing ) maximum_internal_threads += 1; #endif _Objects_Initialize_information( 10c14f: 50 push %eax 10c150: 6a 08 push $0x8 10c152: 6a 00 push $0x0 10c154: 68 f4 00 00 00 push $0xf4 10c159: 6a 01 push $0x1 10c15b: 6a 01 push $0x1 10c15d: 6a 01 push $0x1 10c15f: 68 e0 e4 12 00 push $0x12e4e0 10c164: e8 5f f1 ff ff call 10b2c8 <_Objects_Initialize_information> 10c169: 83 c4 20 add $0x20,%esp false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10c16c: 8d 65 f8 lea -0x8(%ebp),%esp 10c16f: 5b pop %ebx 10c170: 5e pop %esi 10c171: 5d pop %ebp 10c172: c3 ret =============================================================================== 0010beac <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10beac: 55 push %ebp 10bead: 89 e5 mov %esp,%ebp 10beaf: 57 push %edi 10beb0: 56 push %esi 10beb1: 53 push %ebx 10beb2: 83 ec 1c sub $0x1c,%esp 10beb5: 8b 5d 0c mov 0xc(%ebp),%ebx 10beb8: 8b 4d 10 mov 0x10(%ebp),%ecx 10bebb: 8b 75 14 mov 0x14(%ebp),%esi 10bebe: 8a 55 18 mov 0x18(%ebp),%dl 10bec1: 8a 45 20 mov 0x20(%ebp),%al 10bec4: 88 45 e7 mov %al,-0x19(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10bec7: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10bece: 00 00 00 10bed1: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10bed8: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10bedb: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 10bee2: 00 00 00 if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { 10bee5: 85 c9 test %ecx,%ecx 10bee7: 75 31 jne 10bf1a <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10bee9: 57 push %edi 10beea: 57 push %edi 10beeb: 56 push %esi 10beec: 53 push %ebx 10beed: 88 55 e0 mov %dl,-0x20(%ebp) 10bef0: e8 e7 06 00 00 call 10c5dc <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10bef5: 83 c4 10 add $0x10,%esp 10bef8: 39 f0 cmp %esi,%eax 10befa: 8a 55 e0 mov -0x20(%ebp),%dl 10befd: 0f 82 c7 01 00 00 jb 10c0ca <_Thread_Initialize+0x21e> 10bf03: 85 c0 test %eax,%eax 10bf05: 0f 84 bf 01 00 00 je 10c0ca <_Thread_Initialize+0x21e><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10bf0b: 8b 8b c0 00 00 00 mov 0xc0(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10bf11: c6 83 b0 00 00 00 01 movb $0x1,0xb0(%ebx) 10bf18: eb 09 jmp 10bf23 <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10bf1a: c6 83 b0 00 00 00 00 movb $0x0,0xb0(%ebx) 10bf21: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10bf23: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx) the_stack->size = size; 10bf29: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10bf2f: 31 ff xor %edi,%edi /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10bf31: 84 d2 test %dl,%dl 10bf33: 74 17 je 10bf4c <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10bf35: 83 ec 0c sub $0xc,%esp 10bf38: 6a 6c push $0x6c 10bf3a: e8 05 0c 00 00 call 10cb44 <_Workspace_Allocate> 10bf3f: 89 c7 mov %eax,%edi if ( !fp_area ) 10bf41: 83 c4 10 add $0x10,%esp 10bf44: 85 c0 test %eax,%eax 10bf46: 0f 84 2b 01 00 00 je 10c077 <_Thread_Initialize+0x1cb><== NEVER TAKEN goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10bf4c: 89 bb dc 00 00 00 mov %edi,0xdc(%ebx) the_thread->Start.fp_context = fp_area; 10bf52: 89 bb bc 00 00 00 mov %edi,0xbc(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10bf58: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10bf5f: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10bf66: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10bf6d: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10bf74: a1 60 e4 12 00 mov 0x12e460,%eax * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10bf79: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10bf7b: 85 c0 test %eax,%eax 10bf7d: 74 1d je 10bf9c <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10bf7f: 83 ec 0c sub $0xc,%esp 10bf82: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10bf89: 50 push %eax 10bf8a: e8 b5 0b 00 00 call 10cb44 <_Workspace_Allocate> 10bf8f: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10bf91: 83 c4 10 add $0x10,%esp 10bf94: 85 c0 test %eax,%eax 10bf96: 0f 84 dd 00 00 00 je 10c079 <_Thread_Initialize+0x1cd><== NEVER TAKEN goto failed; } the_thread->extensions = (void **) extensions_area; 10bf9c: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx) * if they are linked to the thread. An extension user may * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 10bfa2: 85 f6 test %esi,%esi 10bfa4: 75 23 jne 10bfc9 <_Thread_Initialize+0x11d> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10bfa6: 8a 45 e7 mov -0x19(%ebp),%al 10bfa9: 88 83 9c 00 00 00 mov %al,0x9c(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10bfaf: 8b 45 24 mov 0x24(%ebp),%eax 10bfb2: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) the_thread->Start.budget_callout = budget_callout; 10bfb8: 8b 45 28 mov 0x28(%ebp),%eax 10bfbb: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) switch ( budget_algorithm ) { 10bfc1: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10bfc5: 75 28 jne 10bfef <_Thread_Initialize+0x143> 10bfc7: eb 1e jmp 10bfe7 <_Thread_Initialize+0x13b> * 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++ ) 10bfc9: 8b 15 60 e4 12 00 mov 0x12e460,%edx 10bfcf: 31 c0 xor %eax,%eax 10bfd1: eb 0e jmp 10bfe1 <_Thread_Initialize+0x135> the_thread->extensions[i] = NULL; 10bfd3: 8b 8b ec 00 00 00 mov 0xec(%ebx),%ecx 10bfd9: 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++ ) 10bfe0: 40 inc %eax 10bfe1: 39 d0 cmp %edx,%eax 10bfe3: 76 ee jbe 10bfd3 <_Thread_Initialize+0x127> 10bfe5: eb bf jmp 10bfa6 <_Thread_Initialize+0xfa> case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bfe7: a1 b8 e3 12 00 mov 0x12e3b8,%eax 10bfec: 89 43 74 mov %eax,0x74(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10bfef: 8b 45 2c mov 0x2c(%ebp),%eax 10bff2: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) the_thread->current_state = STATES_DORMANT; 10bff8: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10bfff: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c006: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c00d: 8b 45 1c mov 0x1c(%ebp),%eax 10c010: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c013: 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 ); 10c019: 83 ec 0c sub $0xc,%esp 10c01c: 53 push %ebx 10c01d: ff 15 48 a2 12 00 call *0x12a248 10c023: 89 c2 mov %eax,%edx sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10c025: 83 c4 10 add $0x10,%esp 10c028: 85 c0 test %eax,%eax 10c02a: 74 4f je 10c07b <_Thread_Initialize+0x1cf> goto failed; _Thread_Set_priority( the_thread, priority ); 10c02c: 51 push %ecx 10c02d: 51 push %ecx 10c02e: ff 75 1c pushl 0x1c(%ebp) 10c031: 53 push %ebx 10c032: 89 45 e0 mov %eax,-0x20(%ebp) 10c035: e8 26 05 00 00 call 10c560 <_Thread_Set_priority> static inline void _Timestamp64_implementation_Set_to_zero( Timestamp64_Control *_time ) { *_time = 0; 10c03a: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx) 10c041: 00 00 00 10c044: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c04b: 00 00 00 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c04e: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c052: 8b 45 08 mov 0x8(%ebp),%eax 10c055: 8b 40 1c mov 0x1c(%eax),%eax 10c058: 89 1c 88 mov %ebx,(%eax,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c05b: 8b 45 30 mov 0x30(%ebp),%eax 10c05e: 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 ); 10c061: 89 1c 24 mov %ebx,(%esp) 10c064: e8 c7 07 00 00 call 10c830 <_User_extensions_Thread_create> if ( extension_status ) 10c069: 83 c4 10 add $0x10,%esp return true; 10c06c: b1 01 mov $0x1,%cl * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) 10c06e: 84 c0 test %al,%al 10c070: 8b 55 e0 mov -0x20(%ebp),%edx 10c073: 74 06 je 10c07b <_Thread_Initialize+0x1cf> 10c075: eb 55 jmp 10c0cc <_Thread_Initialize+0x220> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c077: 31 f6 xor %esi,%esi size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10c079: 31 d2 xor %edx,%edx extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: _Workspace_Free( the_thread->libc_reent ); 10c07b: 83 ec 0c sub $0xc,%esp 10c07e: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 10c084: 89 55 e0 mov %edx,-0x20(%ebp) 10c087: e8 d1 0a 00 00 call 10cb5d <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10c08c: 58 pop %eax 10c08d: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10c093: e8 c5 0a 00 00 call 10cb5d <_Workspace_Free> 10c098: 5a pop %edx 10c099: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10c09f: e8 b9 0a 00 00 call 10cb5d <_Workspace_Free> _Workspace_Free( extensions_area ); 10c0a4: 89 34 24 mov %esi,(%esp) 10c0a7: e8 b1 0a 00 00 call 10cb5d <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10c0ac: 89 3c 24 mov %edi,(%esp) 10c0af: e8 a9 0a 00 00 call 10cb5d <_Workspace_Free> #endif _Workspace_Free( sched ); 10c0b4: 8b 55 e0 mov -0x20(%ebp),%edx 10c0b7: 89 14 24 mov %edx,(%esp) 10c0ba: e8 9e 0a 00 00 call 10cb5d <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10c0bf: 89 1c 24 mov %ebx,(%esp) 10c0c2: e8 51 05 00 00 call 10c618 <_Thread_Stack_Free> return false; 10c0c7: 83 c4 10 add $0x10,%esp stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10c0ca: 31 c9 xor %ecx,%ecx _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10c0cc: 88 c8 mov %cl,%al 10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10c0d1: 5b pop %ebx 10c0d2: 5e pop %esi 10c0d3: 5f pop %edi 10c0d4: 5d pop %ebp 10c0d5: c3 ret =============================================================================== 0010c618 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10c618: 55 push %ebp 10c619: 89 e5 mov %esp,%ebp 10c61b: 8b 45 08 mov 0x8(%ebp),%eax rtems_stack_free_hook stack_free_hook = 10c61e: 8b 15 6c a1 12 00 mov 0x12a16c,%edx #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10c624: 80 b8 b0 00 00 00 00 cmpb $0x0,0xb0(%eax) 10c62b: 74 0c je 10c639 <_Thread_Stack_Free+0x21><== NEVER TAKEN * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ (*stack_free_hook)( the_thread->Start.Initial_stack.area ); 10c62d: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax 10c633: 89 45 08 mov %eax,0x8(%ebp) } 10c636: 5d pop %ebp * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ (*stack_free_hook)( the_thread->Start.Initial_stack.area ); 10c637: ff e2 jmp *%edx } 10c639: 5d pop %ebp <== NOT EXECUTED 10c63a: c3 ret <== NOT EXECUTED =============================================================================== 0010c2f8 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10c2f8: 55 push %ebp 10c2f9: 89 e5 mov %esp,%ebp 10c2fb: 57 push %edi 10c2fc: 56 push %esi 10c2fd: 53 push %ebx 10c2fe: 83 ec 14 sub $0x14,%esp 10c301: 8b 4d 08 mov 0x8(%ebp),%ecx 10c304: 8b 45 0c mov 0xc(%ebp),%eax RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c307: 8d 50 38 lea 0x38(%eax),%edx 10c30a: 8d 58 3c lea 0x3c(%eax),%ebx 10c30d: 89 58 38 mov %ebx,0x38(%eax) head->next = tail; head->previous = NULL; 10c310: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10c317: 89 50 40 mov %edx,0x40(%eax) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c31a: 8b 50 14 mov 0x14(%eax),%edx 10c31d: 89 55 f0 mov %edx,-0x10(%ebp) RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 10c320: 89 d6 mov %edx,%esi 10c322: c1 ee 06 shr $0x6,%esi header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c325: 6b f6 0c imul $0xc,%esi,%esi 10c328: 01 ce add %ecx,%esi block_state = the_thread_queue->state; 10c32a: 8b 59 38 mov 0x38(%ecx),%ebx 10c32d: 89 5d e8 mov %ebx,-0x18(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) 10c330: 80 e2 20 and $0x20,%dl 10c333: 75 66 jne 10c39b <_Thread_queue_Enqueue_priority+0xa3> RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( const Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Immutable_tail( the_chain )); 10c335: 8d 56 04 lea 0x4(%esi),%edx 10c338: 89 55 e4 mov %edx,-0x1c(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c33b: 9c pushf 10c33c: fa cli 10c33d: 8f 45 e0 popl -0x20(%ebp) 10c340: 8b 5d e0 mov -0x20(%ebp),%ebx 10c343: 89 5d ec mov %ebx,-0x14(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10c346: 8b 16 mov (%esi),%edx if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 10c348: 83 cf ff or $0xffffffff,%edi _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c34b: eb 1d jmp 10c36a <_Thread_queue_Enqueue_priority+0x72> search_priority = search_thread->current_priority; 10c34d: 8b 7a 14 mov 0x14(%edx),%edi if ( priority <= search_priority ) 10c350: 39 7d f0 cmp %edi,-0x10(%ebp) 10c353: 76 1a jbe 10c36f <_Thread_queue_Enqueue_priority+0x77> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c355: ff 75 e0 pushl -0x20(%ebp) 10c358: 9d popf 10c359: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c35a: 8b 5d e8 mov -0x18(%ebp),%ebx 10c35d: 85 5a 10 test %ebx,0x10(%edx) 10c360: 75 06 jne 10c368 <_Thread_queue_Enqueue_priority+0x70> _ISR_Enable( level ); 10c362: ff 75 e0 pushl -0x20(%ebp) 10c365: 9d popf goto restart_forward_search; 10c366: eb d3 jmp 10c33b <_Thread_queue_Enqueue_priority+0x43> } search_thread = 10c368: 8b 12 mov (%edx),%edx restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c36a: 3b 55 e4 cmp -0x1c(%ebp),%edx 10c36d: 75 de jne 10c34d <_Thread_queue_Enqueue_priority+0x55> } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c36f: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c373: 0f 85 a1 00 00 00 jne 10c41a <_Thread_queue_Enqueue_priority+0x122> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c379: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c380: 39 7d f0 cmp %edi,-0x10(%ebp) 10c383: 74 7c je 10c401 <_Thread_queue_Enqueue_priority+0x109> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c385: 8b 72 04 mov 0x4(%edx),%esi the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c388: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c38a: 89 70 04 mov %esi,0x4(%eax) previous_node->next = the_node; 10c38d: 89 06 mov %eax,(%esi) search_node->previous = the_node; 10c38f: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c392: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c395: ff 75 e0 pushl -0x20(%ebp) 10c398: 9d popf 10c399: eb 5f jmp 10c3fa <_Thread_queue_Enqueue_priority+0x102> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c39b: 0f b6 3d 88 a1 12 00 movzbl 0x12a188,%edi 10c3a2: 47 inc %edi _ISR_Disable( level ); 10c3a3: 9c pushf 10c3a4: fa cli 10c3a5: 8f 45 e4 popl -0x1c(%ebp) 10c3a8: 8b 55 e4 mov -0x1c(%ebp),%edx 10c3ab: 89 55 ec mov %edx,-0x14(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 10c3ae: 8b 56 08 mov 0x8(%esi),%edx search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c3b1: eb 1e jmp 10c3d1 <_Thread_queue_Enqueue_priority+0xd9> search_priority = search_thread->current_priority; 10c3b3: 8b 7a 14 mov 0x14(%edx),%edi if ( priority >= search_priority ) 10c3b6: 39 7d f0 cmp %edi,-0x10(%ebp) 10c3b9: 73 1a jae 10c3d5 <_Thread_queue_Enqueue_priority+0xdd> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c3bb: ff 75 e4 pushl -0x1c(%ebp) 10c3be: 9d popf 10c3bf: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c3c0: 8b 5d e8 mov -0x18(%ebp),%ebx 10c3c3: 85 5a 10 test %ebx,0x10(%edx) 10c3c6: 75 06 jne 10c3ce <_Thread_queue_Enqueue_priority+0xd6><== ALWAYS TAKEN _ISR_Enable( level ); 10c3c8: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 10c3cb: 9d popf <== NOT EXECUTED goto restart_reverse_search; 10c3cc: eb cd jmp 10c39b <_Thread_queue_Enqueue_priority+0xa3><== NOT EXECUTED } search_thread = (Thread_Control *) 10c3ce: 8b 52 04 mov 0x4(%edx),%edx restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c3d1: 39 f2 cmp %esi,%edx 10c3d3: 75 de jne 10c3b3 <_Thread_queue_Enqueue_priority+0xbb> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c3d5: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c3d9: 75 3f jne 10c41a <_Thread_queue_Enqueue_priority+0x122> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c3db: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c3e2: 39 7d f0 cmp %edi,-0x10(%ebp) 10c3e5: 74 1a je 10c401 <_Thread_queue_Enqueue_priority+0x109> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c3e7: 8b 32 mov (%edx),%esi the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c3e9: 89 30 mov %esi,(%eax) the_node->previous = search_node; 10c3eb: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c3ee: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c3f0: 89 46 04 mov %eax,0x4(%esi) the_thread->Wait.queue = the_thread_queue; 10c3f3: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c3f6: ff 75 e4 pushl -0x1c(%ebp) 10c3f9: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c3fa: b8 01 00 00 00 mov $0x1,%eax 10c3ff: eb 24 jmp 10c425 <_Thread_queue_Enqueue_priority+0x12d> equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c401: 8b 5a 40 mov 0x40(%edx),%ebx the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); 10c404: 8d 72 3c lea 0x3c(%edx),%esi 10c407: 89 30 mov %esi,(%eax) previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; 10c409: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c40c: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c40e: 89 42 40 mov %eax,0x40(%edx) the_thread->Wait.queue = the_thread_queue; 10c411: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c414: ff 75 ec pushl -0x14(%ebp) 10c417: 9d popf 10c418: eb e0 jmp 10c3fa <_Thread_queue_Enqueue_priority+0x102> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10c41a: 8b 45 10 mov 0x10(%ebp),%eax 10c41d: 8b 55 ec mov -0x14(%ebp),%edx 10c420: 89 10 mov %edx,(%eax) return the_thread_queue->sync_state; 10c422: 8b 41 30 mov 0x30(%ecx),%eax } 10c425: 83 c4 14 add $0x14,%esp 10c428: 5b pop %ebx 10c429: 5e pop %esi 10c42a: 5f pop %edi 10c42b: 5d pop %ebp 10c42c: c3 ret =============================================================================== 0010c4d0 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c4d0: 55 push %ebp 10c4d1: 89 e5 mov %esp,%ebp 10c4d3: 57 push %edi 10c4d4: 56 push %esi 10c4d5: 53 push %ebx 10c4d6: 83 ec 1c sub $0x1c,%esp 10c4d9: 8b 5d 08 mov 0x8(%ebp),%ebx 10c4dc: 8b 75 0c mov 0xc(%ebp),%esi /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10c4df: 85 db test %ebx,%ebx 10c4e1: 74 36 je 10c519 <_Thread_queue_Requeue+0x49><== NEVER TAKEN /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10c4e3: 83 7b 34 01 cmpl $0x1,0x34(%ebx) 10c4e7: 75 30 jne 10c519 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c4e9: 9c pushf 10c4ea: fa cli 10c4eb: 5f pop %edi if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c4ec: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi) 10c4f3: 74 22 je 10c517 <_Thread_queue_Requeue+0x47><== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c4f5: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10c4fc: 50 push %eax 10c4fd: 6a 01 push $0x1 10c4ff: 56 push %esi 10c500: 53 push %ebx 10c501: e8 0a 32 00 00 call 10f710 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c506: 83 c4 0c add $0xc,%esp 10c509: 8d 45 e4 lea -0x1c(%ebp),%eax 10c50c: 50 push %eax 10c50d: 56 push %esi 10c50e: 53 push %ebx 10c50f: e8 e4 fd ff ff call 10c2f8 <_Thread_queue_Enqueue_priority> 10c514: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c517: 57 push %edi 10c518: 9d popf } } 10c519: 8d 65 f4 lea -0xc(%ebp),%esp 10c51c: 5b pop %ebx 10c51d: 5e pop %esi 10c51e: 5f pop %edi 10c51f: 5d pop %ebp 10c520: c3 ret =============================================================================== 0010c524 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c524: 55 push %ebp 10c525: 89 e5 mov %esp,%ebp 10c527: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c52a: 8d 45 f4 lea -0xc(%ebp),%eax 10c52d: 50 push %eax 10c52e: ff 75 08 pushl 0x8(%ebp) 10c531: e8 f6 f8 ff ff call 10be2c <_Thread_Get> switch ( location ) { 10c536: 83 c4 10 add $0x10,%esp 10c539: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c53d: 75 1c jne 10c55b <_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 ); 10c53f: 83 ec 0c sub $0xc,%esp 10c542: 50 push %eax 10c543: e8 78 32 00 00 call 10f7c0 <_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--; 10c548: a1 e4 e3 12 00 mov 0x12e3e4,%eax 10c54d: 48 dec %eax 10c54e: a3 e4 e3 12 00 mov %eax,0x12e3e4 return _Thread_Dispatch_disable_level; 10c553: a1 e4 e3 12 00 mov 0x12e3e4,%eax 10c558: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c55b: c9 leave 10c55c: c3 ret =============================================================================== 00116732 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116732: 55 push %ebp 116733: 89 e5 mov %esp,%ebp 116735: 57 push %edi 116736: 56 push %esi 116737: 53 push %ebx 116738: 83 ec 3c sub $0x3c,%esp 11673b: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11673e: 8d 45 d0 lea -0x30(%ebp),%eax 116741: 8d 55 d4 lea -0x2c(%ebp),%edx 116744: 89 55 d0 mov %edx,-0x30(%ebp) head->previous = NULL; 116747: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 11674e: 89 45 d8 mov %eax,-0x28(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116751: 8d 75 dc lea -0x24(%ebp),%esi 116754: 8d 55 e0 lea -0x20(%ebp),%edx 116757: 89 55 dc mov %edx,-0x24(%ebp) head->previous = NULL; 11675a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116761: 89 75 e4 mov %esi,-0x1c(%ebp) { /* * 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; 116764: 8d 45 d0 lea -0x30(%ebp),%eax 116767: 89 43 78 mov %eax,0x78(%ebx) */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11676a: 8d 7b 30 lea 0x30(%ebx),%edi static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 11676d: a1 48 7f 14 00 mov 0x147f48,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116772: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 116775: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116778: 51 push %ecx 116779: 56 push %esi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 11677a: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11677c: 50 push %eax 11677d: 57 push %edi 11677e: e8 25 38 00 00 call 119fa8 <_Watchdog_Adjust_to_chain> 116783: 6a 00 push $0x0 116785: 68 00 ca 9a 3b push $0x3b9aca00 11678a: ff 35 14 7e 14 00 pushl 0x147e14 116790: ff 35 10 7e 14 00 pushl 0x147e10 116796: e8 59 3e 01 00 call 12a5f4 <__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; 11679b: 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 ) { 11679e: 83 c4 20 add $0x20,%esp 1167a1: 39 d0 cmp %edx,%eax 1167a3: 76 15 jbe 1167ba <_Timer_server_Body+0x88> /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1167a5: 51 push %ecx 1167a6: 56 push %esi if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 1167a7: 89 c1 mov %eax,%ecx 1167a9: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1167ab: 51 push %ecx 1167ac: 8d 53 68 lea 0x68(%ebx),%edx 1167af: 52 push %edx 1167b0: 89 45 c0 mov %eax,-0x40(%ebp) 1167b3: e8 f0 37 00 00 call 119fa8 <_Watchdog_Adjust_to_chain> 1167b8: eb 14 jmp 1167ce <_Timer_server_Body+0x9c> } else if ( snapshot < last_snapshot ) { 1167ba: 73 18 jae 1167d4 <_Timer_server_Body+0xa2> /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1167bc: 51 push %ecx } else if ( snapshot < last_snapshot ) { /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; 1167bd: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1167bf: 52 push %edx 1167c0: 6a 01 push $0x1 1167c2: 8d 53 68 lea 0x68(%ebx),%edx 1167c5: 52 push %edx 1167c6: 89 45 c0 mov %eax,-0x40(%ebp) 1167c9: e8 72 37 00 00 call 119f40 <_Watchdog_Adjust> 1167ce: 83 c4 10 add $0x10,%esp 1167d1: 8b 45 c0 mov -0x40(%ebp),%eax } watchdogs->last_snapshot = snapshot; 1167d4: 89 43 74 mov %eax,0x74(%ebx) ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 1167d7: 8d 4b 68 lea 0x68(%ebx),%ecx 1167da: 89 4d c4 mov %ecx,-0x3c(%ebp) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 1167dd: 8b 43 78 mov 0x78(%ebx),%eax 1167e0: 83 ec 0c sub $0xc,%esp 1167e3: 50 push %eax 1167e4: e8 cf 07 00 00 call 116fb8 <_Chain_Get> if ( timer == NULL ) { 1167e9: 83 c4 10 add $0x10,%esp 1167ec: 85 c0 test %eax,%eax 1167ee: 74 29 je 116819 <_Timer_server_Body+0xe7><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 1167f0: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 1167f3: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1167f6: 75 09 jne 116801 <_Timer_server_Body+0xcf><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 1167f8: 52 push %edx <== NOT EXECUTED 1167f9: 52 push %edx <== NOT EXECUTED 1167fa: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1167fd: 50 push %eax <== NOT EXECUTED 1167fe: 57 push %edi <== NOT EXECUTED 1167ff: eb 0e jmp 11680f <_Timer_server_Body+0xdd><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116801: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116804: 75 d7 jne 1167dd <_Timer_server_Body+0xab><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116806: 51 push %ecx <== NOT EXECUTED 116807: 51 push %ecx <== NOT EXECUTED 116808: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11680b: 50 push %eax <== NOT EXECUTED 11680c: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 11680f: e8 18 38 00 00 call 11a02c <_Watchdog_Insert> <== NOT EXECUTED 116814: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116817: eb c4 jmp 1167dd <_Timer_server_Body+0xab><== 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 ); 116819: 9c pushf 11681a: fa cli 11681b: 58 pop %eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11681c: 8d 55 d4 lea -0x2c(%ebp),%edx if ( _Chain_Is_empty( insert_chain ) ) { 11681f: 39 55 d0 cmp %edx,-0x30(%ebp) 116822: 75 13 jne 116837 <_Timer_server_Body+0x105><== NEVER TAKEN ts->insert_chain = NULL; 116824: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) _ISR_Enable( level ); 11682b: 50 push %eax 11682c: 9d popf 11682d: 8d 7d e0 lea -0x20(%ebp),%edi _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 ) ) { 116830: 39 7d dc cmp %edi,-0x24(%ebp) 116833: 75 09 jne 11683e <_Timer_server_Body+0x10c> 116835: eb 39 jmp 116870 <_Timer_server_Body+0x13e> ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 116837: 50 push %eax <== NOT EXECUTED 116838: 9d popf <== NOT EXECUTED 116839: e9 2f ff ff ff jmp 11676d <_Timer_server_Body+0x3b><== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 11683e: 9c pushf 11683f: fa cli 116840: 5a pop %edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 116841: 8b 45 dc mov -0x24(%ebp),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 116844: 39 f8 cmp %edi,%eax 116846: 74 21 je 116869 <_Timer_server_Body+0x137> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 116848: 8b 08 mov (%eax),%ecx head->next = new_first; 11684a: 89 4d dc mov %ecx,-0x24(%ebp) new_first->previous = head; 11684d: 89 71 04 mov %esi,0x4(%ecx) watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 116850: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116857: 52 push %edx 116858: 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 ); 116859: 52 push %edx 11685a: 52 push %edx 11685b: ff 70 24 pushl 0x24(%eax) 11685e: ff 70 20 pushl 0x20(%eax) 116861: ff 50 1c call *0x1c(%eax) } 116864: 83 c4 10 add $0x10,%esp 116867: eb d5 jmp 11683e <_Timer_server_Body+0x10c> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 116869: 52 push %edx 11686a: 9d popf 11686b: e9 f4 fe ff ff jmp 116764 <_Timer_server_Body+0x32> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116870: c6 43 7c 00 movb $0x0,0x7c(%ebx) 116874: e8 ef fc ff ff call 116568 <_Thread_Dispatch_increment_disable_level> /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 116879: 57 push %edi 11687a: 57 push %edi 11687b: 6a 08 push $0x8 11687d: ff 33 pushl (%ebx) 11687f: e8 f8 32 00 00 call 119b7c <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116884: 89 d8 mov %ebx,%eax 116886: e8 f2 fc ff ff call 11657d <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 11688b: 89 d8 mov %ebx,%eax 11688d: e8 31 fd ff ff call 1165c3 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116892: e8 fd 2a 00 00 call 119394 <_Thread_Enable_dispatch> ts->active = true; 116897: 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 ); 11689b: 8d 43 08 lea 0x8(%ebx),%eax 11689e: 89 04 24 mov %eax,(%esp) 1168a1: e8 9a 38 00 00 call 11a140 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 1168a6: 8d 43 40 lea 0x40(%ebx),%eax 1168a9: 89 04 24 mov %eax,(%esp) 1168ac: e8 8f 38 00 00 call 11a140 <_Watchdog_Remove> 1168b1: 83 c4 10 add $0x10,%esp 1168b4: e9 ab fe ff ff jmp 116764 <_Timer_server_Body+0x32> =============================================================================== 00116609 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116609: 55 push %ebp 11660a: 89 e5 mov %esp,%ebp 11660c: 57 push %edi 11660d: 56 push %esi 11660e: 53 push %ebx 11660f: 83 ec 1c sub $0x1c,%esp 116612: 8b 5d 08 mov 0x8(%ebp),%ebx 116615: 8b 7d 0c mov 0xc(%ebp),%edi if ( ts->insert_chain == NULL ) { 116618: 8b 43 78 mov 0x78(%ebx),%eax 11661b: 85 c0 test %eax,%eax 11661d: 0f 85 fa 00 00 00 jne 11671d <_Timer_server_Schedule_operation_method+0x114><== NEVER TAKEN #if defined ( __THREAD_DO_NOT_INLINE_DISABLE_DISPATCH__ ) void _Thread_Disable_dispatch( void ); #else RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void ) { _Thread_Dispatch_increment_disable_level(); 116623: e8 40 ff ff ff call 116568 <_Thread_Dispatch_increment_disable_level> * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116628: 8b 47 38 mov 0x38(%edi),%eax 11662b: 83 f8 01 cmp $0x1,%eax 11662e: 75 61 jne 116691 <_Timer_server_Schedule_operation_method+0x88> /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116630: 9c pushf 116631: fa cli 116632: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116635: 8b 15 48 7f 14 00 mov 0x147f48,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 11663b: 8b 4b 3c mov 0x3c(%ebx),%ecx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 11663e: 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 ); 116641: 8d 73 34 lea 0x34(%ebx),%esi if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 116644: 39 f0 cmp %esi,%eax 116646: 74 19 je 116661 <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116648: 89 d6 mov %edx,%esi 11664a: 29 ce sub %ecx,%esi 11664c: 89 75 e4 mov %esi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 11664f: 8b 70 10 mov 0x10(%eax),%esi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116652: 31 c9 xor %ecx,%ecx * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { 116654: 3b 75 e4 cmp -0x1c(%ebp),%esi 116657: 76 05 jbe 11665e <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116659: 89 f1 mov %esi,%ecx 11665b: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 11665e: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116661: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116664: ff 75 e0 pushl -0x20(%ebp) 116667: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116668: 56 push %esi 116669: 56 push %esi 11666a: 8d 47 10 lea 0x10(%edi),%eax 11666d: 50 push %eax 11666e: 8d 43 30 lea 0x30(%ebx),%eax 116671: 50 push %eax 116672: e8 b5 39 00 00 call 11a02c <_Watchdog_Insert> if ( !ts->active ) { 116677: 8a 43 7c mov 0x7c(%ebx),%al 11667a: 83 c4 10 add $0x10,%esp 11667d: 84 c0 test %al,%al 11667f: 0f 85 8c 00 00 00 jne 116711 <_Timer_server_Schedule_operation_method+0x108> _Timer_server_Reset_interval_system_watchdog( ts ); 116685: 89 d8 mov %ebx,%eax 116687: e8 f1 fe ff ff call 11657d <_Timer_server_Reset_interval_system_watchdog> 11668c: e9 80 00 00 00 jmp 116711 <_Timer_server_Schedule_operation_method+0x108> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116691: 83 f8 03 cmp $0x3,%eax 116694: 75 7b jne 116711 <_Timer_server_Schedule_operation_method+0x108> /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116696: 9c pushf 116697: fa cli 116698: 8f 45 e0 popl -0x20(%ebp) 11669b: 6a 00 push $0x0 11669d: 68 00 ca 9a 3b push $0x3b9aca00 1166a2: ff 35 14 7e 14 00 pushl 0x147e14 1166a8: ff 35 10 7e 14 00 pushl 0x147e10 1166ae: e8 41 3f 01 00 call 12a5f4 <__divdi3> 1166b3: 83 c4 10 add $0x10,%esp snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; 1166b6: 8b 53 74 mov 0x74(%ebx),%edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 1166b9: 8b 4b 68 mov 0x68(%ebx),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 1166bc: 8d 73 6c lea 0x6c(%ebx),%esi if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 1166bf: 39 f1 cmp %esi,%ecx 1166c1: 74 27 je 1166ea <_Timer_server_Schedule_operation_method+0xe1> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 1166c3: 8b 71 10 mov 0x10(%ecx),%esi 1166c6: 89 75 dc mov %esi,-0x24(%ebp) if ( snapshot > last_snapshot ) { 1166c9: 39 d0 cmp %edx,%eax 1166cb: 76 15 jbe 1166e2 <_Timer_server_Schedule_operation_method+0xd9> /* * We advanced in time. */ delta = snapshot - last_snapshot; 1166cd: 89 c6 mov %eax,%esi 1166cf: 29 d6 sub %edx,%esi 1166d1: 89 75 e4 mov %esi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1166d4: 31 d2 xor %edx,%edx if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 1166d6: 39 75 dc cmp %esi,-0x24(%ebp) 1166d9: 76 0c jbe 1166e7 <_Timer_server_Schedule_operation_method+0xde><== NEVER TAKEN delta_interval -= delta; 1166db: 8b 55 dc mov -0x24(%ebp),%edx 1166de: 29 f2 sub %esi,%edx 1166e0: eb 05 jmp 1166e7 <_Timer_server_Schedule_operation_method+0xde> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 1166e2: 03 55 dc add -0x24(%ebp),%edx delta_interval += delta; 1166e5: 29 c2 sub %eax,%edx } first_watchdog->delta_interval = delta_interval; 1166e7: 89 51 10 mov %edx,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 1166ea: 89 43 74 mov %eax,0x74(%ebx) _ISR_Enable( level ); 1166ed: ff 75 e0 pushl -0x20(%ebp) 1166f0: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 1166f1: 51 push %ecx 1166f2: 51 push %ecx 1166f3: 8d 47 10 lea 0x10(%edi),%eax 1166f6: 50 push %eax 1166f7: 8d 43 68 lea 0x68(%ebx),%eax 1166fa: 50 push %eax 1166fb: e8 2c 39 00 00 call 11a02c <_Watchdog_Insert> if ( !ts->active ) { 116700: 8a 43 7c mov 0x7c(%ebx),%al 116703: 83 c4 10 add $0x10,%esp 116706: 84 c0 test %al,%al 116708: 75 07 jne 116711 <_Timer_server_Schedule_operation_method+0x108> _Timer_server_Reset_tod_system_watchdog( ts ); 11670a: 89 d8 mov %ebx,%eax 11670c: e8 b2 fe ff ff call 1165c3 <_Timer_server_Reset_tod_system_watchdog> * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); } } 116711: 8d 65 f4 lea -0xc(%ebp),%esp 116714: 5b pop %ebx 116715: 5e pop %esi 116716: 5f pop %edi 116717: 5d pop %ebp if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116718: e9 77 2c 00 00 jmp 119394 <_Thread_Enable_dispatch> * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11671d: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116720: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 116723: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116726: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116729: 5b pop %ebx <== NOT EXECUTED 11672a: 5e pop %esi <== NOT EXECUTED 11672b: 5f pop %edi <== NOT EXECUTED 11672c: 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 ); 11672d: e9 62 08 00 00 jmp 116f94 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010d974 <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) { 10d974: 55 push %ebp 10d975: 89 e5 mov %esp,%ebp 10d977: 57 push %edi 10d978: 56 push %esi 10d979: 53 push %ebx 10d97a: 83 ec 0c sub $0xc,%esp 10d97d: 8b 55 08 mov 0x8(%ebp),%edx Timestamp64_Control answer; if ( *_rhs == 0 ) { 10d980: 8b 45 0c mov 0xc(%ebp),%eax 10d983: 8b 08 mov (%eax),%ecx 10d985: 8b 58 04 mov 0x4(%eax),%ebx 10d988: 89 d8 mov %ebx,%eax 10d98a: 09 c8 or %ecx,%eax 10d98c: 75 14 jne 10d9a2 <_Timestamp64_Divide+0x2e><== ALWAYS TAKEN *_ival_percentage = 0; 10d98e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10d991: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *_fval_percentage = 0; 10d997: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10d99a: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED return; 10d9a0: eb 4c jmp 10d9ee <_Timestamp64_Divide+0x7a><== NOT EXECUTED * This looks odd but gives the results the proper precision. * * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; 10d9a2: 69 72 04 a0 86 01 00 imul $0x186a0,0x4(%edx),%esi 10d9a9: b8 a0 86 01 00 mov $0x186a0,%eax 10d9ae: f7 22 mull (%edx) 10d9b0: 01 f2 add %esi,%edx 10d9b2: 53 push %ebx 10d9b3: 51 push %ecx 10d9b4: 52 push %edx 10d9b5: 50 push %eax 10d9b6: e8 5d 10 01 00 call 11ea18 <__divdi3> 10d9bb: 83 c4 10 add $0x10,%esp 10d9be: 89 c6 mov %eax,%esi 10d9c0: 89 d7 mov %edx,%edi *_ival_percentage = answer / 1000; 10d9c2: 6a 00 push $0x0 10d9c4: 68 e8 03 00 00 push $0x3e8 10d9c9: 52 push %edx 10d9ca: 50 push %eax 10d9cb: e8 48 10 01 00 call 11ea18 <__divdi3> 10d9d0: 83 c4 10 add $0x10,%esp 10d9d3: 8b 55 10 mov 0x10(%ebp),%edx 10d9d6: 89 02 mov %eax,(%edx) *_fval_percentage = answer % 1000; 10d9d8: 6a 00 push $0x0 10d9da: 68 e8 03 00 00 push $0x3e8 10d9df: 57 push %edi 10d9e0: 56 push %esi 10d9e1: e8 86 11 01 00 call 11eb6c <__moddi3> 10d9e6: 83 c4 10 add $0x10,%esp 10d9e9: 8b 55 14 mov 0x14(%ebp),%edx 10d9ec: 89 02 mov %eax,(%edx) } 10d9ee: 8d 65 f4 lea -0xc(%ebp),%esp 10d9f1: 5b pop %ebx 10d9f2: 5e pop %esi 10d9f3: 5f pop %edi 10d9f4: 5d pop %ebp 10d9f5: c3 ret =============================================================================== 0010c6ec <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10c6ec: 55 push %ebp 10c6ed: 89 e5 mov %esp,%ebp 10c6ef: 57 push %edi 10c6f0: 56 push %esi 10c6f1: 53 push %ebx 10c6f2: 83 ec 1c sub $0x1c,%esp User_extensions_Control *extension; uint32_t i; uint32_t number_of_extensions; User_extensions_Table *initial_extensions; number_of_extensions = Configuration.number_of_initial_extensions; 10c6f5: a1 80 a1 12 00 mov 0x12a180,%eax 10c6fa: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10c6fd: 8b 1d 84 a1 12 00 mov 0x12a184,%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c703: c7 05 90 e5 12 00 94 movl $0x12e594,0x12e590 10c70a: e5 12 00 head->previous = NULL; 10c70d: c7 05 94 e5 12 00 00 movl $0x0,0x12e594 10c714: 00 00 00 tail->previous = head; 10c717: c7 05 98 e5 12 00 90 movl $0x12e590,0x12e598 10c71e: e5 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c721: c7 05 e8 e3 12 00 ec movl $0x12e3ec,0x12e3e8 10c728: e3 12 00 head->previous = NULL; 10c72b: c7 05 ec e3 12 00 00 movl $0x0,0x12e3ec 10c732: 00 00 00 tail->previous = head; 10c735: c7 05 f0 e3 12 00 e8 movl $0x12e3e8,0x12e3f0 10c73c: e3 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10c73f: 85 db test %ebx,%ebx 10c741: 74 4f je 10c792 <_User_extensions_Handler_initialization+0xa6><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10c743: 6b f0 34 imul $0x34,%eax,%esi _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { extension = (User_extensions_Control *) 10c746: 83 ec 0c sub $0xc,%esp 10c749: 56 push %esi 10c74a: e8 26 04 00 00 call 10cb75 <_Workspace_Allocate_or_fatal_error> 10c74f: 89 c2 mov %eax,%edx _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10c751: 31 c0 xor %eax,%eax 10c753: 89 d7 mov %edx,%edi 10c755: 89 f1 mov %esi,%ecx 10c757: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10c759: 83 c4 10 add $0x10,%esp 10c75c: 31 c0 xor %eax,%eax 10c75e: eb 2d jmp 10c78d <_User_extensions_Handler_initialization+0xa1> #include #include #include #include void _User_extensions_Handler_initialization(void) 10c760: 89 c6 mov %eax,%esi 10c762: c1 e6 05 shl $0x5,%esi RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10c765: 8d 7a 14 lea 0x14(%edx),%edi 10c768: 01 de add %ebx,%esi 10c76a: b9 08 00 00 00 mov $0x8,%ecx 10c76f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10c771: 83 ec 0c sub $0xc,%esp 10c774: 52 push %edx 10c775: 89 45 dc mov %eax,-0x24(%ebp) 10c778: 89 55 e0 mov %edx,-0x20(%ebp) 10c77b: e8 e4 30 00 00 call 10f864 <_User_extensions_Add_set> number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10c780: 8b 55 e0 mov -0x20(%ebp),%edx 10c783: 83 c2 34 add $0x34,%edx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10c786: 8b 45 dc mov -0x24(%ebp),%eax 10c789: 40 inc %eax 10c78a: 83 c4 10 add $0x10,%esp 10c78d: 3b 45 e4 cmp -0x1c(%ebp),%eax 10c790: 75 ce jne 10c760 <_User_extensions_Handler_initialization+0x74> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10c792: 8d 65 f4 lea -0xc(%ebp),%esp 10c795: 5b pop %ebx 10c796: 5e pop %esi 10c797: 5f pop %edi 10c798: 5d pop %ebp 10c799: c3 ret =============================================================================== 0010dc4c <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10dc4c: 55 push %ebp 10dc4d: 89 e5 mov %esp,%ebp 10dc4f: 57 push %edi 10dc50: 56 push %esi 10dc51: 53 push %ebx 10dc52: 83 ec 0c sub $0xc,%esp 10dc55: 8b 75 08 mov 0x8(%ebp),%esi 10dc58: 8b 4d 0c mov 0xc(%ebp),%ecx 10dc5b: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10dc5e: 9c pushf 10dc5f: fa cli 10dc60: 58 pop %eax */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10dc61: 8b 16 mov (%esi),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10dc63: 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 ) ) { 10dc66: 39 fa cmp %edi,%edx 10dc68: 74 3e je 10dca8 <_Watchdog_Adjust+0x5c> switch ( direction ) { 10dc6a: 85 c9 test %ecx,%ecx 10dc6c: 74 36 je 10dca4 <_Watchdog_Adjust+0x58> 10dc6e: 49 dec %ecx 10dc6f: 75 37 jne 10dca8 <_Watchdog_Adjust+0x5c> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10dc71: 01 5a 10 add %ebx,0x10(%edx) break; 10dc74: eb 32 jmp 10dca8 <_Watchdog_Adjust+0x5c> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10dc76: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10dc78: 8b 4a 10 mov 0x10(%edx),%ecx 10dc7b: 39 cb cmp %ecx,%ebx 10dc7d: 73 07 jae 10dc86 <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10dc7f: 29 d9 sub %ebx,%ecx 10dc81: 89 4a 10 mov %ecx,0x10(%edx) break; 10dc84: eb 22 jmp 10dca8 <_Watchdog_Adjust+0x5c> } else { units -= _Watchdog_First( header )->delta_interval; 10dc86: 29 cb sub %ecx,%ebx _Watchdog_First( header )->delta_interval = 1; 10dc88: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10dc8f: 50 push %eax 10dc90: 9d popf _Watchdog_Tickle( header ); 10dc91: 83 ec 0c sub $0xc,%esp 10dc94: 56 push %esi 10dc95: e8 96 01 00 00 call 10de30 <_Watchdog_Tickle> _ISR_Disable( level ); 10dc9a: 9c pushf 10dc9b: fa cli 10dc9c: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10dc9d: 83 c4 10 add $0x10,%esp 10dca0: 39 3e cmp %edi,(%esi) 10dca2: 74 04 je 10dca8 <_Watchdog_Adjust+0x5c> switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10dca4: 85 db test %ebx,%ebx 10dca6: 75 ce jne 10dc76 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10dca8: 50 push %eax 10dca9: 9d popf } 10dcaa: 8d 65 f4 lea -0xc(%ebp),%esp 10dcad: 5b pop %ebx 10dcae: 5e pop %esi 10dcaf: 5f pop %edi 10dcb0: 5d pop %ebp 10dcb1: c3 ret =============================================================================== 0010ca18 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10ca18: 55 push %ebp 10ca19: 89 e5 mov %esp,%ebp 10ca1b: 56 push %esi 10ca1c: 53 push %ebx 10ca1d: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10ca20: 9c pushf 10ca21: fa cli 10ca22: 5e pop %esi previous_state = the_watchdog->state; 10ca23: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10ca26: 83 f8 01 cmp $0x1,%eax 10ca29: 74 09 je 10ca34 <_Watchdog_Remove+0x1c> 10ca2b: 72 42 jb 10ca6f <_Watchdog_Remove+0x57> 10ca2d: 83 f8 03 cmp $0x3,%eax 10ca30: 77 3d ja 10ca6f <_Watchdog_Remove+0x57> <== NEVER TAKEN 10ca32: eb 09 jmp 10ca3d <_Watchdog_Remove+0x25> /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 10ca34: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10ca3b: eb 32 jmp 10ca6f <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10ca3d: 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 ); } 10ca44: 8b 0a mov (%edx),%ecx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10ca46: 83 39 00 cmpl $0x0,(%ecx) 10ca49: 74 06 je 10ca51 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10ca4b: 8b 5a 10 mov 0x10(%edx),%ebx 10ca4e: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10ca51: 8b 1d d4 e4 12 00 mov 0x12e4d4,%ebx 10ca57: 85 db test %ebx,%ebx 10ca59: 74 0c je 10ca67 <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10ca5b: 8b 1d e8 e8 12 00 mov 0x12e8e8,%ebx 10ca61: 89 1d 74 e4 12 00 mov %ebx,0x12e474 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10ca67: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10ca6a: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10ca6d: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10ca6f: 8b 0d d8 e4 12 00 mov 0x12e4d8,%ecx 10ca75: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10ca78: 56 push %esi 10ca79: 9d popf return( previous_state ); } 10ca7a: 5b pop %ebx 10ca7b: 5e pop %esi 10ca7c: 5d pop %ebp 10ca7d: c3 ret =============================================================================== 0010ca80 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10ca80: 55 push %ebp 10ca81: 89 e5 mov %esp,%ebp 10ca83: 57 push %edi 10ca84: 56 push %esi 10ca85: 53 push %ebx 10ca86: 83 ec 1c sub $0x1c,%esp 10ca89: 8b 75 08 mov 0x8(%ebp),%esi * 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 ); 10ca8c: 9c pushf 10ca8d: fa cli 10ca8e: 5a pop %edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10ca8f: 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 ); 10ca91: 8d 7e 04 lea 0x4(%esi),%edi if ( _Chain_Is_empty( header ) ) 10ca94: 39 fb cmp %edi,%ebx 10ca96: 74 45 je 10cadd <_Watchdog_Tickle+0x5d> * 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) { 10ca98: 8b 43 10 mov 0x10(%ebx),%eax 10ca9b: 85 c0 test %eax,%eax 10ca9d: 74 08 je 10caa7 <_Watchdog_Tickle+0x27> the_watchdog->delta_interval--; 10ca9f: 48 dec %eax 10caa0: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10caa3: 85 c0 test %eax,%eax 10caa5: 75 36 jne 10cadd <_Watchdog_Tickle+0x5d> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10caa7: 83 ec 0c sub $0xc,%esp 10caaa: 53 push %ebx 10caab: 89 55 e4 mov %edx,-0x1c(%ebp) 10caae: e8 65 ff ff ff call 10ca18 <_Watchdog_Remove> _ISR_Enable( level ); 10cab3: 8b 55 e4 mov -0x1c(%ebp),%edx 10cab6: 52 push %edx 10cab7: 9d popf switch( watchdog_state ) { 10cab8: 83 c4 10 add $0x10,%esp 10cabb: 83 f8 02 cmp $0x2,%eax 10cabe: 75 0e jne 10cace <_Watchdog_Tickle+0x4e> <== NEVER TAKEN case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10cac0: 50 push %eax 10cac1: 50 push %eax 10cac2: ff 73 24 pushl 0x24(%ebx) 10cac5: ff 73 20 pushl 0x20(%ebx) 10cac8: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10cacb: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10cace: 9c pushf 10cacf: fa cli 10cad0: 5a pop %edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10cad1: 8b 1e mov (%esi),%ebx the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10cad3: 39 fb cmp %edi,%ebx 10cad5: 74 06 je 10cadd <_Watchdog_Tickle+0x5d> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10cad7: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10cadb: eb c8 jmp 10caa5 <_Watchdog_Tickle+0x25> (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10cadd: 52 push %edx 10cade: 9d popf } 10cadf: 8d 65 f4 lea -0xc(%ebp),%esp 10cae2: 5b pop %ebx 10cae3: 5e pop %esi 10cae4: 5f pop %edi 10cae5: 5d pop %ebp 10cae6: c3 ret =============================================================================== 00104935 <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 104935: 55 push %ebp <== NOT EXECUTED 104936: 89 e5 mov %esp,%ebp <== NOT EXECUTED 104938: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 10493b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10493e: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 104941: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 104944: 5d pop %ebp <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 104945: e9 a6 ff ff ff jmp 1048f0 <== NOT EXECUTED =============================================================================== 0010757d <_stat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 10757d: 55 push %ebp <== NOT EXECUTED 10757e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107580: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 107583: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 107586: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 107589: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10758c: 5d pop %ebp <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 10758d: e9 a6 ff ff ff jmp 107538 <== NOT EXECUTED =============================================================================== 00109dc4 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 109dc4: 55 push %ebp 109dc5: 89 e5 mov %esp,%ebp 109dc7: 57 push %edi 109dc8: 56 push %esi 109dc9: 53 push %ebx 109dca: 83 ec 18 sub $0x18,%esp 109dcd: 8b 75 08 mov 0x8(%ebp),%esi 109dd0: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 109dd3: 68 08 03 13 00 push $0x130308 109dd8: e8 2b 10 00 00 call 10ae08 if (fcntl (fildes, F_GETFD) < 0) { 109ddd: 58 pop %eax 109dde: 5a pop %edx 109ddf: 6a 01 push $0x1 109de1: 56 push %esi 109de2: e8 a9 5b 00 00 call 10f990 109de7: 83 c4 10 add $0x10,%esp 109dea: 85 c0 test %eax,%eax 109dec: 79 1d jns 109e0b pthread_mutex_unlock(&aio_request_queue.mutex); 109dee: 83 ec 0c sub $0xc,%esp 109df1: 68 08 03 13 00 push $0x130308 109df6: e8 8d 10 00 00 call 10ae88 rtems_set_errno_and_return_minus_one (EBADF); 109dfb: e8 1c 8f 00 00 call 112d1c <__errno> 109e00: c7 00 09 00 00 00 movl $0x9,(%eax) 109e06: e9 20 01 00 00 jmp 109f2b } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 109e0b: 85 db test %ebx,%ebx 109e0d: 0f 85 bc 00 00 00 jne 109ecf AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 109e13: 50 push %eax 109e14: 6a 00 push $0x0 109e16: 56 push %esi 109e17: 68 50 03 13 00 push $0x130350 109e1c: e8 9e 05 00 00 call 10a3bf 109e21: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 109e23: 83 c4 10 add $0x10,%esp 109e26: 85 c0 test %eax,%eax 109e28: 75 6b jne 109e95 AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 109e2a: 81 3d 5c 03 13 00 60 cmpl $0x130360,0x13035c 109e31: 03 13 00 109e34: 74 17 je 109e4d <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 109e36: 50 push %eax 109e37: 6a 00 push $0x0 109e39: 56 push %esi 109e3a: 68 5c 03 13 00 push $0x13035c 109e3f: e8 7b 05 00 00 call 10a3bf 109e44: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 109e46: 83 c4 10 add $0x10,%esp 109e49: 85 c0 test %eax,%eax 109e4b: 75 1a jne 109e67 pthread_mutex_unlock(&aio_request_queue.mutex); 109e4d: 83 ec 0c sub $0xc,%esp 109e50: 68 08 03 13 00 push $0x130308 109e55: e8 2e 10 00 00 call 10ae88 return AIO_ALLDONE; 109e5a: 83 c4 10 add $0x10,%esp 109e5d: bb 02 00 00 00 mov $0x2,%ebx 109e62: e9 0d 01 00 00 jmp 109f74 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 109e67: 83 ec 0c sub $0xc,%esp 109e6a: 50 push %eax 109e6b: e8 94 26 00 00 call 10c504 <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 109e70: 89 1c 24 mov %ebx,(%esp) 109e73: e8 d5 05 00 00 call 10a44d pthread_mutex_destroy (&r_chain->mutex); 109e78: 8d 73 1c lea 0x1c(%ebx),%esi 109e7b: 89 34 24 mov %esi,(%esp) 109e7e: e8 59 0d 00 00 call 10abdc pthread_cond_destroy (&r_chain->mutex); 109e83: 89 34 24 mov %esi,(%esp) 109e86: e8 4d 0a 00 00 call 10a8d8 free (r_chain); 109e8b: 89 1c 24 mov %ebx,(%esp) 109e8e: e8 c5 cc ff ff call 106b58 109e93: eb 24 jmp 109eb9 return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 109e95: 8d 70 1c lea 0x1c(%eax),%esi 109e98: 83 ec 0c sub $0xc,%esp 109e9b: 56 push %esi 109e9c: e8 67 0f 00 00 call 10ae08 109ea1: 89 1c 24 mov %ebx,(%esp) 109ea4: e8 5b 26 00 00 call 10c504 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 109ea9: 89 1c 24 mov %ebx,(%esp) 109eac: e8 9c 05 00 00 call 10a44d pthread_mutex_unlock (&r_chain->mutex); 109eb1: 89 34 24 mov %esi,(%esp) 109eb4: e8 cf 0f 00 00 call 10ae88 pthread_mutex_unlock (&aio_request_queue.mutex); 109eb9: c7 04 24 08 03 13 00 movl $0x130308,(%esp) 109ec0: e8 c3 0f 00 00 call 10ae88 return AIO_CANCELED; 109ec5: 83 c4 10 add $0x10,%esp 109ec8: 31 db xor %ebx,%ebx 109eca: e9 a5 00 00 00 jmp 109f74 } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 109ecf: 8b 3b mov (%ebx),%edi 109ed1: 39 f7 cmp %esi,%edi 109ed3: 74 02 je 109ed7 109ed5: eb 3c jmp 109f13 pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 109ed7: 50 push %eax 109ed8: 6a 00 push $0x0 109eda: 57 push %edi 109edb: 68 50 03 13 00 push $0x130350 109ee0: e8 da 04 00 00 call 10a3bf 109ee5: 89 c6 mov %eax,%esi if (r_chain == NULL) { 109ee7: 83 c4 10 add $0x10,%esp 109eea: 85 c0 test %eax,%eax 109eec: 75 55 jne 109f43 if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 109eee: 81 3d 5c 03 13 00 60 cmpl $0x130360,0x13035c 109ef5: 03 13 00 109ef8: 0f 84 4f ff ff ff je 109e4d <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 109efe: 56 push %esi 109eff: 6a 00 push $0x0 109f01: 57 push %edi 109f02: 68 5c 03 13 00 push $0x13035c 109f07: e8 b3 04 00 00 call 10a3bf if (r_chain == NULL) { 109f0c: 83 c4 10 add $0x10,%esp 109f0f: 85 c0 test %eax,%eax 109f11: 75 20 jne 109f33 pthread_mutex_unlock (&aio_request_queue.mutex); 109f13: 83 ec 0c sub $0xc,%esp 109f16: 68 08 03 13 00 push $0x130308 109f1b: e8 68 0f 00 00 call 10ae88 rtems_set_errno_and_return_minus_one (EINVAL); 109f20: e8 f7 8d 00 00 call 112d1c <__errno> 109f25: c7 00 16 00 00 00 movl $0x16,(%eax) 109f2b: 83 c4 10 add $0x10,%esp 109f2e: 83 cb ff or $0xffffffff,%ebx 109f31: eb 41 jmp 109f74 } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 109f33: 51 push %ecx 109f34: 51 push %ecx 109f35: 53 push %ebx 109f36: 83 c0 08 add $0x8,%eax 109f39: 50 push %eax 109f3a: e8 57 05 00 00 call 10a496 109f3f: 89 c3 mov %eax,%ebx 109f41: eb 22 jmp 109f65 return AIO_ALLDONE; } } AIO_printf ("Request on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 109f43: 8d 78 1c lea 0x1c(%eax),%edi 109f46: 83 ec 0c sub $0xc,%esp 109f49: 57 push %edi 109f4a: e8 b9 0e 00 00 call 10ae08 result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 109f4f: 58 pop %eax 109f50: 5a pop %edx 109f51: 53 push %ebx 109f52: 83 c6 08 add $0x8,%esi 109f55: 56 push %esi 109f56: e8 3b 05 00 00 call 10a496 109f5b: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&r_chain->mutex); 109f5d: 89 3c 24 mov %edi,(%esp) 109f60: e8 23 0f 00 00 call 10ae88 pthread_mutex_unlock (&aio_request_queue.mutex); 109f65: c7 04 24 08 03 13 00 movl $0x130308,(%esp) 109f6c: e8 17 0f 00 00 call 10ae88 return result; 109f71: 83 c4 10 add $0x10,%esp } return AIO_ALLDONE; } 109f74: 89 d8 mov %ebx,%eax 109f76: 8d 65 f4 lea -0xc(%ebp),%esp 109f79: 5b pop %ebx 109f7a: 5e pop %esi 109f7b: 5f pop %edi 109f7c: 5d pop %ebp 109f7d: c3 ret =============================================================================== 00109f8c : int aio_fsync( int op, struct aiocb *aiocbp ) { 109f8c: 55 push %ebp 109f8d: 89 e5 mov %esp,%ebp 109f8f: 53 push %ebx 109f90: 52 push %edx 109f91: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 109f94: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 109f9b: 74 1b je 109fb8 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 109f9d: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 109fa4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 109fab: e8 6c 8d 00 00 call 112d1c <__errno> 109fb0: c7 00 16 00 00 00 movl $0x16,(%eax) 109fb6: eb 74 jmp 10a02c mode = fcntl (aiocbp->aio_fildes, F_GETFL); 109fb8: 50 push %eax 109fb9: 50 push %eax 109fba: 6a 03 push $0x3 109fbc: ff 33 pushl (%ebx) 109fbe: e8 cd 59 00 00 call 10f990 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 109fc3: 83 e0 03 and $0x3,%eax 109fc6: 48 dec %eax 109fc7: 83 c4 10 add $0x10,%esp 109fca: 83 f8 01 cmp $0x1,%eax 109fcd: 76 1b jbe 109fea rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 109fcf: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 109fd6: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 109fdd: e8 3a 8d 00 00 call 112d1c <__errno> 109fe2: c7 00 09 00 00 00 movl $0x9,(%eax) 109fe8: eb 42 jmp 10a02c req = malloc (sizeof (rtems_aio_request)); 109fea: 83 ec 0c sub $0xc,%esp 109fed: 6a 18 push $0x18 109fef: e8 3c cf ff ff call 106f30 if (req == NULL) 109ff4: 83 c4 10 add $0x10,%esp 109ff7: 85 c0 test %eax,%eax 109ff9: 75 1b jne 10a016 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 109ffb: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10a002: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10a009: e8 0e 8d 00 00 call 112d1c <__errno> <== NOT EXECUTED 10a00e: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10a014: eb 16 jmp 10a02c <== NOT EXECUTED req->aiocbp = aiocbp; 10a016: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10a019: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10a020: 89 45 08 mov %eax,0x8(%ebp) } 10a023: 8b 5d fc mov -0x4(%ebp),%ebx 10a026: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10a027: e9 ce 04 00 00 jmp 10a4fa } 10a02c: 83 c8 ff or $0xffffffff,%eax 10a02f: 8b 5d fc mov -0x4(%ebp),%ebx 10a032: c9 leave 10a033: c3 ret =============================================================================== 0010a6dc : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10a6dc: 55 push %ebp 10a6dd: 89 e5 mov %esp,%ebp 10a6df: 53 push %ebx 10a6e0: 83 ec 0c sub $0xc,%esp 10a6e3: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a6e6: 6a 03 push $0x3 10a6e8: ff 33 pushl (%ebx) 10a6ea: e8 a1 52 00 00 call 10f990 if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a6ef: 83 c4 10 add $0x10,%esp 10a6f2: a8 01 test $0x1,%al 10a6f4: 74 1b je 10a711 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a6f6: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a6fd: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a704: e8 13 86 00 00 call 112d1c <__errno> 10a709: c7 00 09 00 00 00 movl $0x9,(%eax) 10a70f: eb 6b jmp 10a77c if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10a711: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10a715: 74 02 je 10a719 10a717: eb 06 jmp 10a71f rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10a719: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10a71d: 79 1b jns 10a73a rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a71f: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a726: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a72d: e8 ea 85 00 00 call 112d1c <__errno> 10a732: c7 00 16 00 00 00 movl $0x16,(%eax) 10a738: eb 42 jmp 10a77c req = malloc (sizeof (rtems_aio_request)); 10a73a: 83 ec 0c sub $0xc,%esp 10a73d: 6a 18 push $0x18 10a73f: e8 ec c7 ff ff call 106f30 if (req == NULL) 10a744: 83 c4 10 add $0x10,%esp 10a747: 85 c0 test %eax,%eax 10a749: 75 1b jne 10a766 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10a74b: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10a752: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10a759: e8 be 85 00 00 call 112d1c <__errno> <== NOT EXECUTED 10a75e: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10a764: eb 16 jmp 10a77c <== NOT EXECUTED req->aiocbp = aiocbp; 10a766: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10a769: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10a770: 89 45 08 mov %eax,0x8(%ebp) } 10a773: 8b 5d fc mov -0x4(%ebp),%ebx 10a776: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); 10a777: e9 7e fd ff ff jmp 10a4fa } 10a77c: 83 c8 ff or $0xffffffff,%eax 10a77f: 8b 5d fc mov -0x4(%ebp),%ebx 10a782: c9 leave 10a783: c3 ret =============================================================================== 0010a790 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10a790: 55 push %ebp 10a791: 89 e5 mov %esp,%ebp 10a793: 53 push %ebx 10a794: 83 ec 0c sub $0xc,%esp 10a797: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a79a: 6a 03 push $0x3 10a79c: ff 33 pushl (%ebx) 10a79e: e8 ed 51 00 00 call 10f990 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a7a3: 83 e0 03 and $0x3,%eax 10a7a6: 48 dec %eax 10a7a7: 83 c4 10 add $0x10,%esp 10a7aa: 83 f8 01 cmp $0x1,%eax 10a7ad: 76 1b jbe 10a7ca rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a7af: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a7b6: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a7bd: e8 5a 85 00 00 call 112d1c <__errno> 10a7c2: c7 00 09 00 00 00 movl $0x9,(%eax) 10a7c8: eb 6b jmp 10a835 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10a7ca: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10a7ce: 74 02 je 10a7d2 10a7d0: eb 06 jmp 10a7d8 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10a7d2: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10a7d6: 79 1b jns 10a7f3 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a7d8: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a7df: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a7e6: e8 31 85 00 00 call 112d1c <__errno> 10a7eb: c7 00 16 00 00 00 movl $0x16,(%eax) 10a7f1: eb 42 jmp 10a835 req = malloc (sizeof (rtems_aio_request)); 10a7f3: 83 ec 0c sub $0xc,%esp 10a7f6: 6a 18 push $0x18 10a7f8: e8 33 c7 ff ff call 106f30 if (req == NULL) 10a7fd: 83 c4 10 add $0x10,%esp 10a800: 85 c0 test %eax,%eax 10a802: 75 1b jne 10a81f <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10a804: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10a80b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10a812: e8 05 85 00 00 call 112d1c <__errno> <== NOT EXECUTED 10a817: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10a81d: eb 16 jmp 10a835 <== NOT EXECUTED req->aiocbp = aiocbp; 10a81f: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10a822: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10a829: 89 45 08 mov %eax,0x8(%ebp) } 10a82c: 8b 5d fc mov -0x4(%ebp),%ebx 10a82f: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); 10a830: e9 c5 fc ff ff jmp 10a4fa } 10a835: 83 c8 ff or $0xffffffff,%eax 10a838: 8b 5d fc mov -0x4(%ebp),%ebx 10a83b: c9 leave 10a83c: c3 ret =============================================================================== 00104608 : #include #include int chroot( const char *path ) { 104608: 55 push %ebp 104609: 89 e5 mov %esp,%ebp 10460b: 53 push %ebx 10460c: 83 ec 70 sub $0x70,%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( 10460f: 68 60 7b 12 00 push $0x127b60 104614: 68 64 7b 12 00 push $0x127b64 104619: 6a 19 push $0x19 10461b: ff 75 08 pushl 0x8(%ebp) 10461e: 8d 45 c0 lea -0x40(%ebp),%eax 104621: 50 push %eax 104622: e8 45 11 00 00 call 10576c 104627: 83 c4 18 add $0x18,%esp 10462a: 8d 45 d8 lea -0x28(%ebp),%eax 10462d: 50 push %eax eval_flags, &rtems_global_user_env.root_directory, &rtems_global_user_env.current_directory ); rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc ); 10462e: 8d 5d a8 lea -0x58(%ebp),%ebx 104631: 53 push %ebx 104632: e8 00 15 00 00 call 105b37 new_current_loc = rtems_filesystem_location_transform_to_global( &loc ); 104637: 89 1c 24 mov %ebx,(%esp) 10463a: e8 6b 16 00 00 call 105caa 10463f: 89 45 a4 mov %eax,-0x5c(%ebp) if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) { 104642: 83 c4 10 add $0x10,%esp 104645: 81 78 10 24 d6 11 00 cmpl $0x11d624,0x10(%eax) 10464c: 74 7a je 1046c8 rtems_filesystem_global_location_t *new_root_loc = 10464e: 83 ec 0c sub $0xc,%esp rtems_filesystem_global_location_obtain( &new_current_loc ); 104651: 8d 45 a4 lea -0x5c(%ebp),%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 = 104654: 50 push %eax 104655: e8 c9 15 00 00 call 105c23 10465a: 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)( 10465c: 8b 40 14 mov 0x14(%eax),%eax 10465f: 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 = 104662: 89 1c 24 mov %ebx,(%esp) 104665: 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 ) { 104668: 83 c4 10 add $0x10,%esp 10466b: 85 c0 test %eax,%eax 10466d: 75 43 jne 1046b2 sc = rtems_libio_set_private_env(); 10466f: e8 93 0b 00 00 call 105207 if (sc == RTEMS_SUCCESSFUL) { 104674: 85 c0 test %eax,%eax 104676: 75 28 jne 1046a0 rtems_filesystem_global_location_assign( 104678: 50 push %eax 104679: 50 push %eax 10467a: 53 push %ebx 10467b: a1 5c 7b 12 00 mov 0x127b5c,%eax 104680: 83 c0 04 add $0x4,%eax 104683: 50 push %eax 104684: e8 7d 15 00 00 call 105c06 &rtems_filesystem_root, new_root_loc ); rtems_filesystem_global_location_assign( 104689: 5a pop %edx 10468a: 59 pop %ecx 10468b: ff 75 a4 pushl -0x5c(%ebp) 10468e: ff 35 5c 7b 12 00 pushl 0x127b5c 104694: e8 6d 15 00 00 call 105c06 104699: 83 c4 10 add $0x10,%esp 10469c: 31 db xor %ebx,%ebx 10469e: eb 2b jmp 1046cb &rtems_filesystem_current, new_current_loc ); } else { if (sc != RTEMS_UNSATISFIED) { 1046a0: 83 f8 0d cmp $0xd,%eax 1046a3: 74 49 je 1046ee <== NEVER TAKEN errno = ENOMEM; 1046a5: e8 6a 6c 00 00 call 10b314 <__errno> 1046aa: c7 00 0c 00 00 00 movl $0xc,(%eax) 1046b0: eb 3c jmp 1046ee static inline void rtems_filesystem_location_error( const rtems_filesystem_location_info_t *loc, int eno ) { if ( !rtems_filesystem_location_is_null( loc ) ) { 1046b2: 81 7b 10 24 d6 11 00 cmpl $0x11d624,0x10(%ebx) 1046b9: 74 33 je 1046ee <== NEVER TAKEN errno = eno; 1046bb: e8 54 6c 00 00 call 10b314 <__errno> 1046c0: c7 00 14 00 00 00 movl $0x14,(%eax) 1046c6: eb 26 jmp 1046ee if ( rv != 0 ) { rtems_filesystem_global_location_release( new_root_loc ); } } else { rv = -1; 1046c8: 83 cb ff or $0xffffffff,%ebx } rtems_filesystem_eval_path_cleanup( &ctx ); 1046cb: 83 ec 0c sub $0xc,%esp 1046ce: 8d 45 c0 lea -0x40(%ebp),%eax 1046d1: 50 push %eax 1046d2: e8 86 11 00 00 call 10585d if ( rv != 0 ) { 1046d7: 83 c4 10 add $0x10,%esp 1046da: 85 db test %ebx,%ebx 1046dc: 74 1e je 1046fc rtems_filesystem_global_location_release( new_current_loc ); 1046de: 83 ec 0c sub $0xc,%esp 1046e1: ff 75 a4 pushl -0x5c(%ebp) 1046e4: e8 d8 14 00 00 call 105bc1 1046e9: 83 c4 10 add $0x10,%esp 1046ec: eb 0e jmp 1046fc rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR ); rv = -1; } if ( rv != 0 ) { rtems_filesystem_global_location_release( new_root_loc ); 1046ee: 83 ec 0c sub $0xc,%esp 1046f1: 53 push %ebx 1046f2: e8 ca 14 00 00 call 105bc1 1046f7: 83 c4 10 add $0x10,%esp 1046fa: eb cc jmp 1046c8 if ( rv != 0 ) { rtems_filesystem_global_location_release( new_current_loc ); } return rv; } 1046fc: 89 d8 mov %ebx,%eax 1046fe: 8b 5d fc mov -0x4(%ebp),%ebx 104701: c9 leave 104702: c3 ret =============================================================================== 00109a54 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109a54: 55 push %ebp 109a55: 89 e5 mov %esp,%ebp 109a57: 57 push %edi 109a58: 56 push %esi 109a59: 53 push %ebx 109a5a: 83 ec 1c sub $0x1c,%esp 109a5d: 8b 45 08 mov 0x8(%ebp),%eax 109a60: 8b 5d 0c mov 0xc(%ebp),%ebx if ( !tp ) 109a63: 85 db test %ebx,%ebx 109a65: 75 02 jne 109a69 109a67: eb 6c jmp 109ad5 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109a69: 83 f8 01 cmp $0x1,%eax 109a6c: 75 3b jne 109aa9 struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 109a6e: 83 ec 0c sub $0xc,%esp 109a71: 8d 45 e0 lea -0x20(%ebp),%eax 109a74: 50 push %eax 109a75: e8 ba 1a 00 00 call 10b534 <_TOD_Get_as_timestamp> _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 109a7a: 8b 75 e0 mov -0x20(%ebp),%esi 109a7d: 8b 7d e4 mov -0x1c(%ebp),%edi static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 109a80: 6a 00 push $0x0 109a82: 68 00 ca 9a 3b push $0x3b9aca00 109a87: 57 push %edi 109a88: 56 push %esi 109a89: e8 86 52 01 00 call 11ed14 <__divdi3> 109a8e: 83 c4 10 add $0x10,%esp 109a91: 89 03 mov %eax,(%ebx) _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 109a93: 6a 00 push $0x0 109a95: 68 00 ca 9a 3b push $0x3b9aca00 109a9a: 57 push %edi 109a9b: 56 push %esi 109a9c: e8 c7 53 01 00 call 11ee68 <__moddi3> 109aa1: 83 c4 10 add $0x10,%esp 109aa4: 89 43 04 mov %eax,0x4(%ebx) 109aa7: eb 0e jmp 109ab7 _TOD_Get(tp); return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 109aa9: 83 f8 04 cmp $0x4,%eax 109aac: 75 10 jne 109abe <== ALWAYS TAKEN _TOD_Get_uptime_as_timespec( tp ); 109aae: 83 ec 0c sub $0xc,%esp 109ab1: 53 push %ebx 109ab2: e8 b5 1a 00 00 call 10b56c <_TOD_Get_uptime_as_timespec> return 0; 109ab7: 83 c4 10 add $0x10,%esp 109aba: 31 c0 xor %eax,%eax 109abc: eb 25 jmp 109ae3 } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) { 109abe: 83 f8 02 cmp $0x2,%eax 109ac1: 74 eb je 109aae return 0; } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) 109ac3: 83 f8 03 cmp $0x3,%eax 109ac6: 75 0d jne 109ad5 rtems_set_errno_and_return_minus_one( ENOSYS ); 109ac8: e8 cf 80 00 00 call 111b9c <__errno> 109acd: c7 00 58 00 00 00 movl $0x58,(%eax) 109ad3: eb 0b jmp 109ae0 #endif rtems_set_errno_and_return_minus_one( EINVAL ); 109ad5: e8 c2 80 00 00 call 111b9c <__errno> 109ada: c7 00 16 00 00 00 movl $0x16,(%eax) 109ae0: 83 c8 ff or $0xffffffff,%eax return 0; } 109ae3: 8d 65 f4 lea -0xc(%ebp),%esp 109ae6: 5b pop %ebx 109ae7: 5e pop %esi 109ae8: 5f pop %edi 109ae9: 5d pop %ebp 109aea: c3 ret =============================================================================== 001233a0 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 1233a0: 55 push %ebp 1233a1: 89 e5 mov %esp,%ebp 1233a3: 53 push %ebx 1233a4: 83 ec 14 sub $0x14,%esp 1233a7: 8b 45 08 mov 0x8(%ebp),%eax 1233aa: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !tp ) 1233ad: 85 c9 test %ecx,%ecx 1233af: 75 02 jne 1233b3 <== ALWAYS TAKEN 1233b1: eb 69 jmp 12341c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 1233b3: 83 f8 01 cmp $0x1,%eax 1233b6: 75 4b jne 123403 if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 1233b8: 81 39 ff e4 da 21 cmpl $0x21dae4ff,(%ecx) 1233be: 77 02 ja 1233c2 1233c0: eb 5a jmp 12341c * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 1233c2: a1 fc e1 16 00 mov 0x16e1fc,%eax 1233c7: 40 inc %eax 1233c8: a3 fc e1 16 00 mov %eax,0x16e1fc return _Thread_Dispatch_disable_level; 1233cd: a1 fc e1 16 00 mov 0x16e1fc,%eax Timestamp64_Control *_time, Timestamp64_Control _seconds, Timestamp64_Control _nanoseconds ) { *_time = _seconds * 1000000000L + _nanoseconds; 1233d2: b8 00 ca 9a 3b mov $0x3b9aca00,%eax 1233d7: f7 29 imull (%ecx) const struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _Timestamp_Set( 1233d9: 8b 49 04 mov 0x4(%ecx),%ecx 1233dc: 89 cb mov %ecx,%ebx 1233de: c1 fb 1f sar $0x1f,%ebx 1233e1: 01 c8 add %ecx,%eax 1233e3: 11 da adc %ebx,%edx 1233e5: 89 45 f0 mov %eax,-0x10(%ebp) 1233e8: 89 55 f4 mov %edx,-0xc(%ebp) &tod_as_timestamp, tod_as_timespec->tv_sec, tod_as_timespec->tv_nsec ); _TOD_Set_with_timestamp( &tod_as_timestamp ); 1233eb: 83 ec 0c sub $0xc,%esp 1233ee: 8d 45 f0 lea -0x10(%ebp),%eax 1233f1: 50 push %eax 1233f2: e8 0d 0e 00 00 call 124204 <_TOD_Set_with_timestamp> rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); 1233f7: e8 78 87 fe ff call 10bb74 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 1233fc: 83 c4 10 add $0x10,%esp 1233ff: 31 c0 xor %eax,%eax 123401: eb 27 jmp 12342a _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) 123403: 83 f8 02 cmp $0x2,%eax 123406: 75 02 jne 12340a 123408: eb 05 jmp 12340f rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) 12340a: 83 f8 03 cmp $0x3,%eax 12340d: 75 0d jne 12341c rtems_set_errno_and_return_minus_one( ENOSYS ); 12340f: e8 74 da 00 00 call 130e88 <__errno> 123414: c7 00 58 00 00 00 movl $0x58,(%eax) 12341a: eb 0b jmp 123427 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 12341c: e8 67 da 00 00 call 130e88 <__errno> 123421: c7 00 16 00 00 00 movl $0x16,(%eax) 123427: 83 c8 ff or $0xffffffff,%eax return 0; } 12342a: 8b 5d fc mov -0x4(%ebp),%ebx 12342d: c9 leave 12342e: c3 ret =============================================================================== 00107fa6 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) 107fa6: 55 push %ebp 107fa7: 89 e5 mov %esp,%ebp 107fa9: 53 push %ebx 107faa: 52 push %edx 107fab: 89 c3 mov %eax,%ebx 107fad: eb 2c jmp 107fdb 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; 107faf: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 107fb6: 00 00 00 rtems_interrupt_enable (level); 107fb9: 50 push %eax 107fba: 9d popf sc = rtems_semaphore_obtain( 107fbb: 50 push %eax 107fbc: 6a 00 push $0x0 107fbe: 6a 00 push $0x0 107fc0: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 107fc6: e8 c5 1d 00 00 call 109d90 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 107fcb: 83 c4 10 add $0x10,%esp 107fce: 85 c0 test %eax,%eax 107fd0: 74 09 je 107fdb <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 107fd2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107fd5: 50 push %eax <== NOT EXECUTED 107fd6: e8 d9 23 00 00 call 10a3b4 <== NOT EXECUTED rtems_interrupt_disable (level); 107fdb: 9c pushf 107fdc: fa cli 107fdd: 58 pop %eax rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { rtems_interrupt_disable (level); while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 107fde: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 107fe4: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 107fea: 39 d1 cmp %edx,%ecx 107fec: 75 c1 jne 107faf 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); 107fee: 50 push %eax 107fef: 9d popf } } 107ff0: 8b 5d fc mov -0x4(%ebp),%ebx 107ff3: c9 leave 107ff4: c3 ret =============================================================================== 00106bac : int dup2( int fildes, int fildes2 ) { 106bac: 55 push %ebp 106bad: 89 e5 mov %esp,%ebp 106baf: 57 push %edi 106bb0: 56 push %esi 106bb1: 53 push %ebx 106bb2: 83 ec 64 sub $0x64,%esp 106bb5: 8b 5d 08 mov 0x8(%ebp),%ebx 106bb8: 8b 75 0c mov 0xc(%ebp),%esi /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 106bbb: 8d 7d a0 lea -0x60(%ebp),%edi 106bbe: 57 push %edi 106bbf: 53 push %ebx 106bc0: e8 eb 04 00 00 call 1070b0 if ( status == -1 ) 106bc5: 83 c4 10 add $0x10,%esp 106bc8: 40 inc %eax 106bc9: 75 05 jne 106bd0 return -1; 106bcb: 83 c8 ff or $0xffffffff,%eax 106bce: eb 1c jmp 106bec /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 106bd0: 52 push %edx 106bd1: 52 push %edx 106bd2: 57 push %edi 106bd3: 56 push %esi 106bd4: e8 d7 04 00 00 call 1070b0 if ( status == -1 ) 106bd9: 83 c4 10 add $0x10,%esp 106bdc: 40 inc %eax 106bdd: 74 ec je 106bcb <== NEVER TAKEN /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 106bdf: 50 push %eax 106be0: 56 push %esi 106be1: 6a 00 push $0x0 106be3: 53 push %ebx 106be4: e8 eb 01 00 00 call 106dd4 106be9: 83 c4 10 add $0x10,%esp } 106bec: 8d 65 f4 lea -0xc(%ebp),%esp 106bef: 5b pop %ebx 106bf0: 5e pop %esi 106bf1: 5f pop %edi 106bf2: 5d pop %ebp 106bf3: c3 ret =============================================================================== 00108ae8 : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 108ae8: 55 push %ebp 108ae9: 89 e5 mov %esp,%ebp 108aeb: 53 push %ebx 108aec: 83 ec 24 sub $0x24,%esp if ((tty->termios.c_lflag & ECHOCTL) && 108aef: f6 42 3d 02 testb $0x2,0x3d(%edx) 108af3: 74 3e je 108b33 <== NEVER TAKEN iscntrl(c) && (c != '\t') && (c != '\n')) { 108af5: 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) && 108af8: 8b 1d 88 c2 12 00 mov 0x12c288,%ebx 108afe: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) 108b03: 74 2e je 108b33 iscntrl(c) && (c != '\t') && (c != '\n')) { 108b05: 8d 48 f7 lea -0x9(%eax),%ecx 108b08: 80 f9 01 cmp $0x1,%cl 108b0b: 76 26 jbe 108b33 char echobuf[2]; echobuf[0] = '^'; 108b0d: c6 45 f6 5e movb $0x5e,-0xa(%ebp) echobuf[1] = c ^ 0x40; 108b11: 83 f0 40 xor $0x40,%eax 108b14: 88 45 f7 mov %al,-0x9(%ebp) rtems_termios_puts (echobuf, 2, tty); 108b17: 53 push %ebx 108b18: 52 push %edx 108b19: 6a 02 push $0x2 108b1b: 8d 45 f6 lea -0xa(%ebp),%eax 108b1e: 50 push %eax 108b1f: 89 55 e4 mov %edx,-0x1c(%ebp) 108b22: e8 9e fd ff ff call 1088c5 tty->column += 2; 108b27: 8b 55 e4 mov -0x1c(%ebp),%edx 108b2a: 83 42 28 02 addl $0x2,0x28(%edx) 108b2e: 83 c4 10 add $0x10,%esp 108b31: eb 08 jmp 108b3b } else { oproc (c, tty); 108b33: 0f b6 c0 movzbl %al,%eax 108b36: e8 96 fe ff ff call 1089d1 } } 108b3b: 8b 5d fc mov -0x4(%ebp),%ebx 108b3e: c9 leave 108b3f: c3 ret =============================================================================== 00122635 : void endgrent(void) { if (group_fp != NULL) 122635: a1 20 dc 16 00 mov 0x16dc20,%eax 12263a: 85 c0 test %eax,%eax 12263c: 74 10 je 12264e <== NEVER TAKEN fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 12263e: 55 push %ebp 12263f: 89 e5 mov %esp,%ebp 122641: 83 ec 14 sub $0x14,%esp if (group_fp != NULL) fclose(group_fp); 122644: 50 push %eax 122645: e8 5a e9 00 00 call 130fa4 12264a: 83 c4 10 add $0x10,%esp } 12264d: c9 leave 12264e: c3 ret =============================================================================== 001224f7 : void endpwent(void) { if (passwd_fp != NULL) 1224f7: a1 44 db 16 00 mov 0x16db44,%eax 1224fc: 85 c0 test %eax,%eax 1224fe: 74 10 je 122510 <== NEVER TAKEN fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 122500: 55 push %ebp 122501: 89 e5 mov %esp,%ebp 122503: 83 ec 14 sub $0x14,%esp if (passwd_fp != NULL) fclose(passwd_fp); 122506: 50 push %eax 122507: e8 98 ea 00 00 call 130fa4 12250c: 83 c4 10 add $0x10,%esp } 12250f: c9 leave 122510: c3 ret =============================================================================== 00108b40 : * 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) 108b40: 55 push %ebp 108b41: 89 e5 mov %esp,%ebp 108b43: 57 push %edi 108b44: 56 push %esi 108b45: 53 push %ebx 108b46: 83 ec 2c sub $0x2c,%esp 108b49: 89 c3 mov %eax,%ebx 108b4b: 89 55 e4 mov %edx,-0x1c(%ebp) 108b4e: e9 09 01 00 00 jmp 108c5c return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 108b53: 8b 53 1c mov 0x1c(%ebx),%edx 108b56: 89 55 d4 mov %edx,-0x2c(%ebp) 108b59: 8d 50 ff lea -0x1(%eax),%edx 108b5c: 89 53 20 mov %edx,0x20(%ebx) 108b5f: 8b 75 d4 mov -0x2c(%ebp),%esi 108b62: 8a 4c 06 ff mov -0x1(%esi,%eax,1),%cl if (tty->termios.c_lflag & ECHO) { 108b66: 8b 53 3c mov 0x3c(%ebx),%edx 108b69: f6 c2 08 test $0x8,%dl 108b6c: 0f 84 e4 00 00 00 je 108c56 <== NEVER TAKEN if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 108b72: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 108b76: 75 17 jne 108b8f 108b78: f6 c2 10 test $0x10,%dl 108b7b: 75 12 jne 108b8f <== ALWAYS TAKEN echo (tty->termios.c_cc[VERASE], tty); 108b7d: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 108b81: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 108b83: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108b86: 5b pop %ebx <== NOT EXECUTED 108b87: 5e pop %esi <== NOT EXECUTED 108b88: 5f pop %edi <== NOT EXECUTED 108b89: 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); 108b8a: e9 59 ff ff ff jmp 108ae8 <== NOT EXECUTED } else if (c == '\t') { 108b8f: 80 f9 09 cmp $0x9,%cl 108b92: 8b 3d 88 c2 12 00 mov 0x12c288,%edi 108b98: 89 7d e0 mov %edi,-0x20(%ebp) 108b9b: 75 5d jne 108bfa int col = tty->read_start_column; 108b9d: 8b 73 2c mov 0x2c(%ebx),%esi * 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) 108ba0: b9 01 00 00 00 mov $0x1,%ecx 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) 108ba5: 81 e2 00 02 00 00 and $0x200,%edx 108bab: 89 55 dc mov %edx,-0x24(%ebp) 108bae: eb 29 jmp 108bd9 /* * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; 108bb0: 8b 7d d4 mov -0x2c(%ebp),%edi 108bb3: 0f b6 54 0f ff movzbl -0x1(%edi,%ecx,1),%edx if (c == '\t') { 108bb8: 80 fa 09 cmp $0x9,%dl 108bbb: 75 05 jne 108bc2 col = (col | 7) + 1; 108bbd: 83 ce 07 or $0x7,%esi 108bc0: eb 15 jmp 108bd7 } else if (iscntrl (c)) { 108bc2: 8b 7d e0 mov -0x20(%ebp),%edi 108bc5: f6 44 17 01 20 testb $0x20,0x1(%edi,%edx,1) 108bca: 74 0b je 108bd7 <== ALWAYS TAKEN if (tty->termios.c_lflag & ECHOCTL) 108bcc: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED 108bd0: 74 06 je 108bd8 <== NOT EXECUTED col += 2; 108bd2: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 108bd5: eb 01 jmp 108bd8 <== NOT EXECUTED } else { col++; 108bd7: 46 inc %esi 108bd8: 41 inc %ecx int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108bd9: 39 c1 cmp %eax,%ecx 108bdb: 75 d3 jne 108bb0 108bdd: eb 14 jmp 108bf3 /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 108bdf: 50 push %eax 108be0: 53 push %ebx 108be1: 6a 01 push $0x1 108be3: 68 18 fa 11 00 push $0x11fa18 108be8: e8 d8 fc ff ff call 1088c5 tty->column--; 108bed: ff 4b 28 decl 0x28(%ebx) 108bf0: 83 c4 10 add $0x10,%esp } /* * Back up over the tab */ while (tty->column > col) { 108bf3: 39 73 28 cmp %esi,0x28(%ebx) 108bf6: 7f e7 jg 108bdf 108bf8: eb 5c jmp 108c56 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 108bfa: 0f b6 f1 movzbl %cl,%esi 108bfd: 8b 45 e0 mov -0x20(%ebp),%eax 108c00: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) 108c05: 74 21 je 108c28 <== ALWAYS TAKEN 108c07: 80 e6 02 and $0x2,%dh <== NOT EXECUTED 108c0a: 74 1c je 108c28 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108c0c: 57 push %edi <== NOT EXECUTED 108c0d: 53 push %ebx <== NOT EXECUTED 108c0e: 6a 03 push $0x3 <== NOT EXECUTED 108c10: 68 16 fa 11 00 push $0x11fa16 <== NOT EXECUTED 108c15: e8 ab fc ff ff call 1088c5 <== NOT EXECUTED if (tty->column) 108c1a: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108c1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108c20: 85 c0 test %eax,%eax <== NOT EXECUTED 108c22: 74 04 je 108c28 <== NOT EXECUTED tty->column--; 108c24: 48 dec %eax <== NOT EXECUTED 108c25: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 108c28: a1 88 c2 12 00 mov 0x12c288,%eax 108c2d: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) 108c32: 74 06 je 108c3a <== ALWAYS TAKEN 108c34: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 108c38: 74 1c je 108c56 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108c3a: 56 push %esi 108c3b: 53 push %ebx 108c3c: 6a 03 push $0x3 108c3e: 68 16 fa 11 00 push $0x11fa16 108c43: e8 7d fc ff ff call 1088c5 if (tty->column) 108c48: 8b 43 28 mov 0x28(%ebx),%eax 108c4b: 83 c4 10 add $0x10,%esp 108c4e: 85 c0 test %eax,%eax 108c50: 74 04 je 108c56 <== NEVER TAKEN tty->column--; 108c52: 48 dec %eax 108c53: 89 43 28 mov %eax,0x28(%ebx) } } } if (!lineFlag) 108c56: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 108c5a: 74 0b je 108c67 echo ('\n', tty); return; } } while (tty->ccount) { 108c5c: 8b 43 20 mov 0x20(%ebx),%eax 108c5f: 85 c0 test %eax,%eax 108c61: 0f 85 ec fe ff ff jne 108b53 } } if (!lineFlag) break; } } 108c67: 8d 65 f4 lea -0xc(%ebp),%esp 108c6a: 5b pop %ebx 108c6b: 5e pop %esi 108c6c: 5f pop %edi 108c6d: 5d pop %ebp 108c6e: c3 ret =============================================================================== 001076e7 : size_t pathlen, int eval_flags, rtems_filesystem_global_location_t *const *global_root_ptr, rtems_filesystem_global_location_t *const *global_current_ptr ) { 1076e7: 55 push %ebp 1076e8: 89 e5 mov %esp,%ebp 1076ea: 57 push %edi 1076eb: 56 push %esi 1076ec: 53 push %ebx 1076ed: 83 ec 2c sub $0x2c,%esp 1076f0: 89 c3 mov %eax,%ebx 1076f2: 89 ce mov %ecx,%esi memset(ctx, 0, sizeof(*ctx)); 1076f4: b9 0e 00 00 00 mov $0xe,%ecx 1076f9: 31 c0 xor %eax,%eax 1076fb: 89 df mov %ebx,%edi 1076fd: f3 ab rep stos %eax,%es:(%edi) ctx->path = path; 1076ff: 89 13 mov %edx,(%ebx) ctx->pathlen = pathlen; 107701: 89 73 04 mov %esi,0x4(%ebx) ctx->flags = eval_flags; 107704: 8b 45 08 mov 0x8(%ebp),%eax 107707: 89 43 10 mov %eax,0x10(%ebx) 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) { 10770a: 85 f6 test %esi,%esi 10770c: 74 41 je 10774f char c = ctx->path [0]; 10770e: 8a 12 mov (%edx),%dl ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr); 107710: 83 ec 0c sub $0xc,%esp 107713: ff 75 0c pushl 0xc(%ebp) 107716: 88 55 d4 mov %dl,-0x2c(%ebp) 107719: e8 0d 05 00 00 call 107c2b 10771e: 89 43 30 mov %eax,0x30(%ebx) gid_t node_gid ); static inline bool rtems_filesystem_is_delimiter(char c) { return c == '/' || c == '\\'; 107721: 83 c4 10 add $0x10,%esp if (rtems_filesystem_is_delimiter(c)) { 107724: 8a 55 d4 mov -0x2c(%ebp),%dl 107727: 80 fa 5c cmp $0x5c,%dl 10772a: 74 05 je 107731 <== NEVER TAKEN 10772c: 80 fa 2f cmp $0x2f,%dl 10772f: 75 0e jne 10773f ++ctx->path; 107731: ff 03 incl (%ebx) --ctx->pathlen; 107733: ff 4b 04 decl 0x4(%ebx) ctx->startloc = rtems_filesystem_global_location_obtain( 107736: 83 ec 0c sub $0xc,%esp &ctx->rootloc 107739: 8d 43 30 lea 0x30(%ebx),%eax 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( 10773c: 50 push %eax 10773d: eb 06 jmp 107745 &ctx->rootloc ); } else { ctx->startloc = rtems_filesystem_global_location_obtain( 10773f: 83 ec 0c sub $0xc,%esp 107742: ff 75 10 pushl 0x10(%ebp) 107745: e8 e1 04 00 00 call 107c2b 10774a: 89 43 34 mov %eax,0x34(%ebx) 10774d: eb 33 jmp 107782 ); static inline rtems_filesystem_global_location_t * rtems_filesystem_global_location_obtain_null(void) { rtems_filesystem_global_location_t *global_loc = NULL; 10774f: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) return rtems_filesystem_global_location_obtain( &global_loc ); 107756: 83 ec 0c sub $0xc,%esp 107759: 8d 75 e4 lea -0x1c(%ebp),%esi 10775c: 56 push %esi 10775d: e8 c9 04 00 00 call 107c2b global_current_ptr ); } } else { ctx->rootloc = rtems_filesystem_global_location_obtain_null(); 107762: 89 43 30 mov %eax,0x30(%ebx) ); static inline rtems_filesystem_global_location_t * rtems_filesystem_global_location_obtain_null(void) { rtems_filesystem_global_location_t *global_loc = NULL; 107765: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) return rtems_filesystem_global_location_obtain( &global_loc ); 10776c: 89 34 24 mov %esi,(%esp) 10776f: e8 b7 04 00 00 call 107c2b ctx->startloc = rtems_filesystem_global_location_obtain_null(); 107774: 89 43 34 mov %eax,0x34(%ebx) errno = ENOENT; 107777: e8 60 97 00 00 call 110edc <__errno> 10777c: c7 00 02 00 00 00 movl $0x2,(%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); } 107782: 8b 43 34 mov 0x34(%ebx),%eax 107785: 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 ); 107788: 8b 50 0c mov 0xc(%eax),%edx 10778b: 89 04 24 mov %eax,(%esp) 10778e: ff 12 call *(%edx) set_startloc(ctx, global_root_ptr, global_current_ptr); rtems_filesystem_instance_lock(&ctx->startloc->location); rtems_filesystem_location_clone( 107790: 8d 73 18 lea 0x18(%ebx),%esi 107793: 5f pop %edi 107794: 58 pop %eax 107795: ff 73 34 pushl 0x34(%ebx) 107798: 56 push %esi 107799: e8 aa 61 00 00 call 10d948 &ctx->currentloc, &ctx->startloc->location ); rtems_filesystem_eval_path_continue(ctx); 10779e: 89 1c 24 mov %ebx,(%esp) 1077a1: e8 e5 fe ff ff call 10768b return &ctx->currentloc; } 1077a6: 89 f0 mov %esi,%eax 1077a8: 8d 65 f4 lea -0xc(%ebp),%esp 1077ab: 5b pop %ebx 1077ac: 5e pop %esi 1077ad: 5f pop %edi 1077ae: 5d pop %ebp 1077af: c3 ret =============================================================================== 0012d5e4 : #include #include int fchdir( int fd ) { 12d5e4: 55 push %ebp 12d5e5: 89 e5 mov %esp,%ebp 12d5e7: 57 push %edi 12d5e8: 56 push %esi 12d5e9: 53 push %ebx 12d5ea: 83 ec 6c sub $0x6c,%esp 12d5ed: 8b 5d 08 mov 0x8(%ebp),%ebx int rv = 0; rtems_libio_t *iop; struct stat st; rtems_filesystem_location_info_t loc; st.st_mode = 0; 12d5f0: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp) st.st_uid = 0; 12d5f7: 66 c7 45 b2 00 00 movw $0x0,-0x4e(%ebp) st.st_gid = 0; 12d5fd: 66 c7 45 b4 00 00 movw $0x0,-0x4c(%ebp) rtems_libio_check_fd( fd ); 12d603: 3b 1d 1c 69 16 00 cmp 0x16691c,%ebx 12d609: 72 02 jb 12d60d 12d60b: eb 0f jmp 12d61c iop = rtems_libio_iop( fd ); 12d60d: 6b db 30 imul $0x30,%ebx,%ebx 12d610: 03 1d e8 e0 16 00 add 0x16e0e8,%ebx rtems_libio_check_is_open( iop ); 12d616: f6 43 0d 01 testb $0x1,0xd(%ebx) 12d61a: 75 13 jne 12d62f 12d61c: e8 67 38 00 00 call 130e88 <__errno> 12d621: c7 00 09 00 00 00 movl $0x9,(%eax) 12d627: 83 ce ff or $0xffffffff,%esi 12d62a: e9 84 00 00 00 jmp 12d6b3 if ( rv == 0 ) { rv = rtems_filesystem_chdir( &loc ); } return rv; } 12d62f: 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 ); 12d632: 83 ec 0c sub $0xc,%esp 12d635: 8b 50 0c mov 0xc(%eax),%edx 12d638: 50 push %eax 12d639: 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 ); 12d63b: 8d 7b 10 lea 0x10(%ebx),%edi 12d63e: 5a pop %edx 12d63f: 59 pop %ecx 12d640: 8b 43 20 mov 0x20(%ebx),%eax 12d643: 8d 55 a0 lea -0x60(%ebp),%edx 12d646: 52 push %edx 12d647: 57 push %edi 12d648: ff 50 18 call *0x18(%eax) 12d64b: 89 c6 mov %eax,%esi if ( rv == 0 ) { 12d64d: 83 c4 10 add $0x10,%esp 12d650: 85 c0 test %eax,%eax 12d652: 75 3a jne 12d68e <== NEVER TAKEN bool access_ok = rtems_filesystem_check_access( 12d654: 0f b7 45 b4 movzwl -0x4c(%ebp),%eax 12d658: 50 push %eax 12d659: 0f b7 45 b2 movzwl -0x4e(%ebp),%eax 12d65d: 50 push %eax 12d65e: ff 75 ac pushl -0x54(%ebp) 12d661: 6a 01 push $0x1 12d663: e8 ec 22 fe ff call 10f954 st.st_mode, st.st_uid, st.st_gid ); if ( access_ok ) { 12d668: 83 c4 10 add $0x10,%esp 12d66b: 84 c0 test %al,%al 12d66d: 74 11 je 12d680 <== NEVER TAKEN rtems_filesystem_location_clone( &loc, &iop->pathinfo ); 12d66f: 50 push %eax 12d670: 50 push %eax 12d671: 57 push %edi 12d672: 8d 45 88 lea -0x78(%ebp),%eax 12d675: 50 push %eax 12d676: e8 31 1e fe ff call 10f4ac 12d67b: 83 c4 10 add $0x10,%esp 12d67e: eb 0e jmp 12d68e } else { errno = EACCES; 12d680: e8 03 38 00 00 call 130e88 <__errno> 12d685: c7 00 0d 00 00 00 movl $0xd,(%eax) rv = -1; 12d68b: 83 ce ff or $0xffffffff,%esi if ( rv == 0 ) { rv = rtems_filesystem_chdir( &loc ); } return rv; } 12d68e: 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 ); 12d691: 83 ec 0c sub $0xc,%esp 12d694: 8b 50 0c mov 0xc(%eax),%edx 12d697: 50 push %eax 12d698: ff 52 04 call *0x4(%edx) rv = -1; } } rtems_filesystem_instance_unlock( &iop->pathinfo ); if ( rv == 0 ) { 12d69b: 83 c4 10 add $0x10,%esp 12d69e: 85 f6 test %esi,%esi 12d6a0: 75 11 jne 12d6b3 rv = rtems_filesystem_chdir( &loc ); 12d6a2: 83 ec 0c sub $0xc,%esp 12d6a5: 8d 45 88 lea -0x78(%ebp),%eax 12d6a8: 50 push %eax 12d6a9: e8 7a 43 ff ff call 121a28 12d6ae: 89 c6 mov %eax,%esi 12d6b0: 83 c4 10 add $0x10,%esp } return rv; } 12d6b3: 89 f0 mov %esi,%eax 12d6b5: 8d 65 f4 lea -0xc(%ebp),%esp 12d6b8: 5b pop %ebx 12d6b9: 5e pop %esi 12d6ba: 5f pop %edi 12d6bb: 5d pop %ebp 12d6bc: c3 ret =============================================================================== 00121cc4 : #include #include int fchmod( int fd, mode_t mode ) { 121cc4: 55 push %ebp 121cc5: 89 e5 mov %esp,%ebp 121cc7: 53 push %ebx 121cc8: 83 ec 14 sub $0x14,%esp 121ccb: 8b 5d 08 mov 0x8(%ebp),%ebx int rv; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 121cce: 3b 1d 1c 69 16 00 cmp 0x16691c,%ebx 121cd4: 72 02 jb 121cd8 121cd6: eb 0f jmp 121ce7 iop = rtems_libio_iop( fd ); 121cd8: 6b db 30 imul $0x30,%ebx,%ebx 121cdb: 03 1d e8 e0 16 00 add 0x16e0e8,%ebx rtems_libio_check_is_open(iop); 121ce1: f6 43 0d 01 testb $0x1,0xd(%ebx) 121ce5: 75 0d jne 121cf4 121ce7: e8 9c f1 00 00 call 130e88 <__errno> 121cec: c7 00 09 00 00 00 movl $0x9,(%eax) 121cf2: eb 46 jmp 121d3a if (iop->pathinfo.mt_entry->writeable) { 121cf4: 8b 43 24 mov 0x24(%ebx),%eax 121cf7: 80 78 29 00 cmpb $0x0,0x29(%eax) 121cfb: 74 32 je 121d2f <== NEVER TAKEN 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 ); 121cfd: 83 ec 0c sub $0xc,%esp 121d00: 8b 50 0c mov 0xc(%eax),%edx 121d03: 50 push %eax 121d04: ff 12 call *(%edx) rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode ); 121d06: 58 pop %eax 121d07: 5a pop %edx 121d08: 8b 43 24 mov 0x24(%ebx),%eax 121d0b: 8b 40 0c mov 0xc(%eax),%eax 121d0e: ff 75 0c pushl 0xc(%ebp) 121d11: 8d 53 10 lea 0x10(%ebx),%edx 121d14: 52 push %edx 121d15: ff 50 20 call *0x20(%eax) errno = EROFS; rv = -1; } return rv; } 121d18: 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 ); 121d1b: 8b 4a 0c mov 0xc(%edx),%ecx 121d1e: 89 14 24 mov %edx,(%esp) 121d21: 89 45 f4 mov %eax,-0xc(%ebp) 121d24: ff 51 04 call *0x4(%ecx) 121d27: 83 c4 10 add $0x10,%esp 121d2a: 8b 45 f4 mov -0xc(%ebp),%eax 121d2d: eb 0e jmp 121d3d if (iop->pathinfo.mt_entry->writeable) { 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; 121d2f: e8 54 f1 00 00 call 130e88 <__errno> <== NOT EXECUTED 121d34: c7 00 1e 00 00 00 movl $0x1e,(%eax) <== NOT EXECUTED rv = -1; 121d3a: 83 c8 ff or $0xffffffff,%eax } return rv; } 121d3d: 8b 5d fc mov -0x4(%ebp),%ebx 121d40: c9 leave 121d41: c3 ret =============================================================================== 00121d44 : #include #include int fchown( int fd, uid_t owner, gid_t group ) { 121d44: 55 push %ebp 121d45: 89 e5 mov %esp,%ebp 121d47: 57 push %edi 121d48: 56 push %esi 121d49: 53 push %ebx 121d4a: 83 ec 1c sub $0x1c,%esp 121d4d: 8b 5d 08 mov 0x8(%ebp),%ebx 121d50: 0f b7 75 0c movzwl 0xc(%ebp),%esi 121d54: 0f b7 7d 10 movzwl 0x10(%ebp),%edi int rv = 0; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 121d58: 3b 1d 1c 69 16 00 cmp 0x16691c,%ebx 121d5e: 72 02 jb 121d62 121d60: eb 0f jmp 121d71 iop = rtems_libio_iop( fd ); 121d62: 6b db 30 imul $0x30,%ebx,%ebx 121d65: 03 1d e8 e0 16 00 add 0x16e0e8,%ebx rtems_libio_check_is_open(iop); 121d6b: f6 43 0d 01 testb $0x1,0xd(%ebx) 121d6f: 75 0d jne 121d7e 121d71: e8 12 f1 00 00 call 130e88 <__errno> 121d76: c7 00 09 00 00 00 movl $0x9,(%eax) 121d7c: eb 46 jmp 121dc4 if (iop->pathinfo.mt_entry->writeable) { 121d7e: 8b 43 24 mov 0x24(%ebx),%eax 121d81: 80 78 29 00 cmpb $0x0,0x29(%eax) 121d85: 74 32 je 121db9 <== NEVER TAKEN 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 ); 121d87: 83 ec 0c sub $0xc,%esp 121d8a: 8b 50 0c mov 0xc(%eax),%edx 121d8d: 50 push %eax 121d8e: ff 12 call *(%edx) rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.mt_entry->ops->chown_h)( 121d90: 83 c4 0c add $0xc,%esp 121d93: 8b 43 24 mov 0x24(%ebx),%eax 121d96: 8b 40 0c mov 0xc(%eax),%eax 121d99: 57 push %edi 121d9a: 56 push %esi &iop->pathinfo, 121d9b: 8d 53 10 lea 0x10(%ebx),%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)( 121d9e: 52 push %edx 121d9f: ff 50 24 call *0x24(%eax) errno = EROFS; rv = -1; } return rv; } 121da2: 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 ); 121da5: 8b 4a 0c mov 0xc(%edx),%ecx 121da8: 89 14 24 mov %edx,(%esp) 121dab: 89 45 e4 mov %eax,-0x1c(%ebp) 121dae: ff 51 04 call *0x4(%ecx) 121db1: 83 c4 10 add $0x10,%esp 121db4: 8b 45 e4 mov -0x1c(%ebp),%eax 121db7: eb 0e jmp 121dc7 owner, group ); rtems_filesystem_instance_unlock( &iop->pathinfo ); } else { errno = EROFS; 121db9: e8 ca f0 00 00 call 130e88 <__errno> <== NOT EXECUTED 121dbe: c7 00 1e 00 00 00 movl $0x1e,(%eax) <== NOT EXECUTED rv = -1; 121dc4: 83 c8 ff or $0xffffffff,%eax } return rv; } 121dc7: 8d 65 f4 lea -0xc(%ebp),%esp 121dca: 5b pop %ebx 121dcb: 5e pop %esi 121dcc: 5f pop %edi 121dcd: 5d pop %ebp 121dce: c3 ret =============================================================================== 0012c490 : int fcntl( int fd, int cmd, ... ) { 12c490: 55 push %ebp 12c491: 89 e5 mov %esp,%ebp 12c493: 57 push %edi 12c494: 56 push %esi 12c495: 53 push %ebx 12c496: 83 ec 1c sub $0x1c,%esp 12c499: 8b 55 08 mov 0x8(%ebp),%edx int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 12c49c: 3b 15 08 f7 13 00 cmp 0x13f708,%edx 12c4a2: 72 02 jb 12c4a6 12c4a4: eb 11 jmp 12c4b7 iop = rtems_libio_iop( fd ); 12c4a6: 6b fa 30 imul $0x30,%edx,%edi 12c4a9: 03 3d d8 38 15 00 add 0x1538d8,%edi rtems_libio_check_is_open(iop); 12c4af: 8b 5f 0c mov 0xc(%edi),%ebx 12c4b2: f6 c7 01 test $0x1,%bh 12c4b5: 75 10 jne 12c4c7 12c4b7: e8 10 2d ff ff call 11f1cc <__errno> 12c4bc: c7 00 09 00 00 00 movl $0x9,(%eax) 12c4c2: e9 29 01 00 00 jmp 12c5f0 /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 12c4c7: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 12c4cb: 0f 87 f2 00 00 00 ja 12c5c3 12c4d1: 8b 45 0c mov 0xc(%ebp),%eax 12c4d4: ff 24 85 64 36 13 00 jmp *0x133664(,%eax,4) /* * FIXME: We ignore the start value fd2 for the file descriptor search. This * is not POSIX conform. */ rtems_libio_t *diop = rtems_libio_allocate(); 12c4db: e8 d8 dc fd ff call 10a1b8 12c4e0: 89 c6 mov %eax,%esi if (diop != NULL) { 12c4e2: 85 c0 test %eax,%eax 12c4e4: 0f 84 06 01 00 00 je 12c5f0 int oflag = rtems_libio_to_fcntl_flags( iop->flags ); 12c4ea: 83 ec 0c sub $0xc,%esp 12c4ed: ff 77 0c pushl 0xc(%edi) 12c4f0: e8 83 dc fd ff call 10a178 12c4f5: 89 c1 mov %eax,%ecx oflag &= ~O_CREAT; 12c4f7: 80 e5 fd and $0xfd,%ch diop->flags |= rtems_libio_fcntl_flags( oflag ); 12c4fa: 8b 5e 0c mov 0xc(%esi),%ebx 12c4fd: 89 0c 24 mov %ecx,(%esp) 12c500: 89 4d e4 mov %ecx,-0x1c(%ebp) 12c503: e8 3c dc fd ff call 10a144 12c508: 09 d8 or %ebx,%eax 12c50a: 89 46 0c mov %eax,0xc(%esi) int cmd, int arg ) { return fcntl( fd, cmd, arg ); } 12c50d: 8b 47 24 mov 0x24(%edi),%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 ); 12c510: 8b 58 0c mov 0xc(%eax),%ebx 12c513: 89 04 24 mov %eax,(%esp) 12c516: ff 13 call *(%ebx) oflag &= ~O_CREAT; diop->flags |= rtems_libio_fcntl_flags( oflag ); rtems_filesystem_instance_lock( &iop->pathinfo ); rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo ); 12c518: 5a pop %edx 12c519: 59 pop %ecx 12c51a: 8d 47 10 lea 0x10(%edi),%eax 12c51d: 50 push %eax 12c51e: 8d 46 10 lea 0x10(%esi),%eax 12c521: 50 push %eax 12c522: e8 89 9e fe ff call 1163b0 int cmd, int arg ) { return fcntl( fd, cmd, arg ); } 12c527: 8b 47 24 mov 0x24(%edi),%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 ); 12c52a: 8b 58 0c mov 0xc(%eax),%ebx 12c52d: 89 04 24 mov %eax,(%esp) 12c530: ff 53 04 call *0x4(%ebx) /* * 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 ); 12c533: 8b 46 20 mov 0x20(%esi),%eax 12c536: 6a 00 push $0x0 12c538: 8b 4d e4 mov -0x1c(%ebp),%ecx 12c53b: 51 push %ecx 12c53c: 6a 00 push $0x0 12c53e: 56 push %esi 12c53f: ff 10 call *(%eax) 12c541: 89 c3 mov %eax,%ebx if ( rv == 0 ) { 12c543: 83 c4 20 add $0x20,%esp 12c546: 85 c0 test %eax,%eax 12c548: 75 11 jne 12c55b <== NEVER TAKEN rv = diop - rtems_libio_iops; 12c54a: 2b 35 d8 38 15 00 sub 0x1538d8,%esi 12c550: c1 fe 04 sar $0x4,%esi 12c553: 69 de ab aa aa aa imul $0xaaaaaaab,%esi,%ebx 12c559: eb 75 jmp 12c5d0 } else { rtems_libio_free( diop ); 12c55b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12c55e: 56 push %esi <== NOT EXECUTED 12c55f: e8 a7 dc fd ff call 10a20b <== NOT EXECUTED 12c564: eb 26 jmp 12c58c <== NOT EXECUTED 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); 12c566: c1 eb 0b shr $0xb,%ebx 12c569: 83 e3 01 and $0x1,%ebx 12c56c: eb 66 jmp 12c5d4 * 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 ) ) 12c56e: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 12c572: 74 05 je 12c579 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 12c574: 80 cf 08 or $0x8,%bh 12c577: eb 03 jmp 12c57c else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 12c579: 80 e7 f7 and $0xf7,%bh 12c57c: 89 5f 0c mov %ebx,0xc(%edi) 12c57f: eb 31 jmp 12c5b2 break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 12c581: 83 ec 0c sub $0xc,%esp 12c584: 53 push %ebx 12c585: e8 ee db fd ff call 10a178 12c58a: 89 c3 mov %eax,%ebx 12c58c: 83 c4 10 add $0x10,%esp 12c58f: eb 3f jmp 12c5d0 break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 12c591: 83 ec 0c sub $0xc,%esp 12c594: ff 75 10 pushl 0x10(%ebp) 12c597: e8 a8 db fd ff call 10a144 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 12c59c: 25 01 02 00 00 and $0x201,%eax 12c5a1: 8b 4f 0c mov 0xc(%edi),%ecx 12c5a4: 81 e1 fe fd ff ff and $0xfffffdfe,%ecx 12c5aa: 09 c8 or %ecx,%eax 12c5ac: 89 47 0c mov %eax,0xc(%edi) 12c5af: 83 c4 10 add $0x10,%esp { rtems_libio_t *iop; int fd2; int flags; int mask; int ret = 0; 12c5b2: 31 db xor %ebx,%ebx 12c5b4: eb 1e jmp 12c5d4 errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 12c5b6: e8 11 2c ff ff call 11f1cc <__errno> 12c5bb: c7 00 86 00 00 00 movl $0x86,(%eax) 12c5c1: eb 2d jmp 12c5f0 ret = -1; break; default: errno = EINVAL; 12c5c3: e8 04 2c ff ff call 11f1cc <__errno> 12c5c8: c7 00 16 00 00 00 movl $0x16,(%eax) 12c5ce: eb 20 jmp 12c5f0 /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 12c5d0: 85 db test %ebx,%ebx 12c5d2: 78 1f js 12c5f3 <== NEVER TAKEN int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd ); 12c5d4: 50 push %eax 12c5d5: 50 push %eax 12c5d6: 8b 47 20 mov 0x20(%edi),%eax 12c5d9: ff 75 0c pushl 0xc(%ebp) 12c5dc: 57 push %edi 12c5dd: ff 50 28 call *0x28(%eax) 12c5e0: 89 c6 mov %eax,%esi if (err) { 12c5e2: 83 c4 10 add $0x10,%esp 12c5e5: 85 c0 test %eax,%eax 12c5e7: 74 0a je 12c5f3 <== ALWAYS TAKEN errno = err; 12c5e9: e8 de 2b ff ff call 11f1cc <__errno> <== NOT EXECUTED 12c5ee: 89 30 mov %esi,(%eax) <== NOT EXECUTED int mask; int ret = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 12c5f0: 83 cb ff or $0xffffffff,%ebx va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 12c5f3: 89 d8 mov %ebx,%eax 12c5f5: 8d 65 f4 lea -0xc(%ebp),%esp 12c5f8: 5b pop %ebx 12c5f9: 5e pop %esi 12c5fa: 5f pop %edi 12c5fb: 5d pop %ebp 12c5fc: c3 ret =============================================================================== 0010948c : long fpathconf( int fd, int name ) { 10948c: 55 push %ebp 10948d: 89 e5 mov %esp,%ebp 10948f: 83 ec 08 sub $0x8,%esp 109492: 8b 45 08 mov 0x8(%ebp),%eax 109495: 8b 55 0c mov 0xc(%ebp),%edx long return_value; rtems_libio_t *iop; const rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); 109498: 3b 05 54 72 12 00 cmp 0x127254,%eax 10949e: 72 02 jb 1094a2 <== NEVER TAKEN 1094a0: eb 0f jmp 1094b1 iop = rtems_libio_iop(fd); 1094a2: 6b c0 30 imul $0x30,%eax,%eax <== NOT EXECUTED 1094a5: 03 05 34 b2 12 00 add 0x12b234,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 1094ab: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 1094af: 75 0d jne 1094be <== NOT EXECUTED 1094b1: e8 5e 1e 00 00 call 10b314 <__errno> 1094b6: c7 00 09 00 00 00 movl $0x9,(%eax) 1094bc: eb 58 jmp 109516 /* * Now process the information request. */ the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options; 1094be: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 1094c1: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED switch ( name ) { 1094c4: 83 fa 0b cmp $0xb,%edx <== NOT EXECUTED 1094c7: 77 42 ja 10950b <== NOT EXECUTED 1094c9: ff 24 95 58 d9 11 00 jmp *0x11d958(,%edx,4) <== NOT EXECUTED case _PC_LINK_MAX: return_value = the_limits->link_max; 1094d0: 8b 00 mov (%eax),%eax <== NOT EXECUTED break; 1094d2: eb 45 jmp 109519 <== NOT EXECUTED case _PC_MAX_CANON: return_value = the_limits->max_canon; 1094d4: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED break; 1094d7: eb 40 jmp 109519 <== NOT EXECUTED case _PC_MAX_INPUT: return_value = the_limits->max_input; 1094d9: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED break; 1094dc: eb 3b jmp 109519 <== NOT EXECUTED case _PC_NAME_MAX: return_value = the_limits->name_max; 1094de: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED break; 1094e1: eb 36 jmp 109519 <== NOT EXECUTED case _PC_PATH_MAX: return_value = the_limits->path_max; 1094e3: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED break; 1094e6: eb 31 jmp 109519 <== NOT EXECUTED case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 1094e8: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED break; 1094eb: eb 2c jmp 109519 <== NOT EXECUTED case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 1094ed: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED break; 1094f0: eb 27 jmp 109519 <== NOT EXECUTED case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 1094f2: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED break; 1094f5: eb 22 jmp 109519 <== NOT EXECUTED case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 1094f7: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED break; 1094fa: eb 1d jmp 109519 <== NOT EXECUTED case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 1094fc: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED break; 1094ff: eb 18 jmp 109519 <== NOT EXECUTED case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 109501: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED break; 109504: eb 13 jmp 109519 <== NOT EXECUTED case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 109506: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED break; 109509: eb 0e jmp 109519 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); 10950b: e8 04 1e 00 00 call 10b314 <__errno> <== NOT EXECUTED 109510: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109516: 83 c8 ff or $0xffffffff,%eax break; } return return_value; } 109519: c9 leave 10951a: c3 ret =============================================================================== 00106734 : #include void free( void *ptr ) { 106734: 55 push %ebp 106735: 89 e5 mov %esp,%ebp 106737: 53 push %ebx 106738: 52 push %edx 106739: 8b 5d 08 mov 0x8(%ebp),%ebx MSBUMP(free_calls, 1); 10673c: ff 05 f4 e2 12 00 incl 0x12e2f4 if ( !ptr ) 106742: 85 db test %ebx,%ebx 106744: 74 5f je 1067a5 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 106746: 83 3d 20 e5 12 00 03 cmpl $0x3,0x12e520 10674d: 75 15 jne 106764 <== NEVER TAKEN !malloc_is_system_state_OK() ) { 10674f: e8 78 01 00 00 call 1068cc return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 106754: 84 c0 test %al,%al 106756: 75 0c jne 106764 !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 106758: 89 5d 08 mov %ebx,0x8(%ebp) RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 10675b: 8b 5d fc mov -0x4(%ebp),%ebx 10675e: c9 leave /* * 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); 10675f: e9 d1 01 00 00 jmp 106935 } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 106764: a1 04 c8 12 00 mov 0x12c804,%eax 106769: 85 c0 test %eax,%eax 10676b: 74 0a je 106777 (*rtems_malloc_statistics_helpers->at_free)(ptr); 10676d: 83 ec 0c sub $0xc,%esp 106770: 53 push %ebx 106771: ff 50 08 call *0x8(%eax) 106774: 83 c4 10 add $0x10,%esp if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 106777: 50 push %eax 106778: 50 push %eax 106779: 53 push %ebx 10677a: ff 35 2c a2 12 00 pushl 0x12a22c 106780: e8 87 4d 00 00 call 10b50c <_Protected_heap_Free> 106785: 83 c4 10 add $0x10,%esp 106788: 84 c0 test %al,%al 10678a: 75 19 jne 1067a5 printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 10678c: a1 2c a2 12 00 mov 0x12a22c,%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", 106791: ff 70 1c pushl 0x1c(%eax) 106794: ff 70 18 pushl 0x18(%eax) 106797: 53 push %ebx 106798: 68 28 f8 11 00 push $0x11f828 10679d: e8 9a 0c 00 00 call 10743c 1067a2: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1067a5: 8b 5d fc mov -0x4(%ebp),%ebx 1067a8: c9 leave 1067a9: c3 ret =============================================================================== 0011d718 : int fstat( int fd, struct stat *sbuf ) { 11d718: 55 push %ebp 11d719: 89 e5 mov %esp,%ebp 11d71b: 57 push %edi 11d71c: 53 push %ebx 11d71d: 8b 55 08 mov 0x8(%ebp),%edx 11d720: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_libio_t *iop; /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11d723: 85 db test %ebx,%ebx 11d725: 75 0d jne 11d734 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EFAULT ); 11d727: e8 b0 37 ff ff call 110edc <__errno> <== NOT EXECUTED 11d72c: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 11d732: eb 43 jmp 11d777 <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11d734: 3b 15 70 a2 12 00 cmp 0x12a270,%edx 11d73a: 73 0f jae 11d74b 11d73c: 6b d2 30 imul $0x30,%edx,%edx 11d73f: 03 15 d0 e2 12 00 add 0x12e2d0,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11d745: f6 42 0d 01 testb $0x1,0xd(%edx) 11d749: 75 0d jne 11d758 11d74b: e8 8c 37 ff ff call 110edc <__errno> 11d750: c7 00 09 00 00 00 movl $0x9,(%eax) 11d756: eb 1f jmp 11d777 /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11d758: b9 12 00 00 00 mov $0x12,%ecx 11d75d: 31 c0 xor %eax,%eax 11d75f: 89 df mov %ebx,%edi 11d761: f3 ab rep stos %eax,%es:(%edi) return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11d763: 8b 42 20 mov 0x20(%edx),%eax 11d766: 89 5d 0c mov %ebx,0xc(%ebp) 11d769: 83 c2 10 add $0x10,%edx 11d76c: 89 55 08 mov %edx,0x8(%ebp) 11d76f: 8b 40 18 mov 0x18(%eax),%eax } 11d772: 5b pop %ebx 11d773: 5f pop %edi 11d774: 5d pop %ebp * 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 ); 11d775: ff e0 jmp *%eax } 11d777: 83 c8 ff or $0xffffffff,%eax 11d77a: 5b pop %ebx 11d77b: 5f pop %edi 11d77c: 5d pop %ebp 11d77d: c3 ret =============================================================================== 0012c628 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 12c628: 55 push %ebp 12c629: 89 e5 mov %esp,%ebp 12c62b: 57 push %edi 12c62c: 56 push %esi 12c62d: 53 push %ebx 12c62e: 83 ec 0c sub $0xc,%esp 12c631: 8b 45 08 mov 0x8(%ebp),%eax 12c634: 8b 75 0c mov 0xc(%ebp),%esi 12c637: 8b 7d 10 mov 0x10(%ebp),%edi rtems_filesystem_node_types_t type; /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 12c63a: 31 db xor %ebx,%ebx 12c63c: 3b 05 08 f7 13 00 cmp 0x13f708,%eax 12c642: 73 09 jae 12c64d <== NEVER TAKEN 12c644: 6b d8 30 imul $0x30,%eax,%ebx 12c647: 03 1d d8 38 15 00 add 0x1538d8,%ebx /* * Make sure we are working on a directory */ type = rtems_filesystem_node_type( &iop->pathinfo ); 12c64d: 83 ec 0c sub $0xc,%esp 12c650: 8d 43 10 lea 0x10(%ebx),%eax 12c653: 50 push %eax 12c654: e8 d3 f3 fd ff call 10ba2c if ( type != RTEMS_FILESYSTEM_DIRECTORY ) 12c659: 83 c4 10 add $0x10,%esp 12c65c: 85 c0 test %eax,%eax 12c65e: 75 18 jne 12c678 /* * 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 ); 12c660: 8b 43 20 mov 0x20(%ebx),%eax 12c663: 89 7d 10 mov %edi,0x10(%ebp) 12c666: 89 75 0c mov %esi,0xc(%ebp) 12c669: 89 5d 08 mov %ebx,0x8(%ebp) 12c66c: 8b 40 08 mov 0x8(%eax),%eax } 12c66f: 8d 65 f4 lea -0xc(%ebp),%esp 12c672: 5b pop %ebx 12c673: 5e pop %esi 12c674: 5f pop %edi 12c675: 5d pop %ebp /* * 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 ); 12c676: ff e0 jmp *%eax /* * 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 ); 12c678: e8 4f 2b ff ff call 11f1cc <__errno> 12c67d: 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 ); } 12c683: 83 c8 ff or $0xffffffff,%eax 12c686: 8d 65 f4 lea -0xc(%ebp),%esp 12c689: 5b pop %ebx 12c68a: 5e pop %esi 12c68b: 5f pop %edi 12c68c: 5d pop %ebp 12c68d: c3 ret =============================================================================== 001221a0 : void init_etc_passwd_group(void) { FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 1221a0: 80 3d 5c da 16 00 00 cmpb $0x0,0x16da5c 1221a7: 0f 85 c1 00 00 00 jne 12226e /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 1221ad: 55 push %ebp 1221ae: 89 e5 mov %esp,%ebp 1221b0: 53 push %ebx 1221b1: 83 ec 0c sub $0xc,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) return; etc_passwd_initted = 1; 1221b4: c6 05 5c da 16 00 01 movb $0x1,0x16da5c mkdir("/etc", 0777); 1221bb: 68 ff 01 00 00 push $0x1ff 1221c0: 68 41 03 15 00 push $0x150341 1221c5: e8 ea 46 fe ff call 1068b4 /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 1221ca: 58 pop %eax 1221cb: 5a pop %edx 1221cc: 68 7b c9 14 00 push $0x14c97b 1221d1: 68 46 03 15 00 push $0x150346 1221d6: e8 41 f6 00 00 call 13181c 1221db: 83 c4 10 add $0x10,%esp 1221de: 85 c0 test %eax,%eax 1221e0: 74 06 je 1221e8 fclose(fp); 1221e2: 83 ec 0c sub $0xc,%esp 1221e5: 50 push %eax 1221e6: eb 2a jmp 122212 } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 1221e8: 50 push %eax 1221e9: 50 push %eax 1221ea: 68 78 c9 14 00 push $0x14c978 1221ef: 68 46 03 15 00 push $0x150346 1221f4: e8 23 f6 00 00 call 13181c 1221f9: 89 c3 mov %eax,%ebx 1221fb: 83 c4 10 add $0x10,%esp 1221fe: 85 c0 test %eax,%eax 122200: 74 18 je 12221a <== NEVER TAKEN fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 122202: 50 push %eax 122203: 50 push %eax 122204: 53 push %ebx 122205: 68 52 03 15 00 push $0x150352 12220a: e8 7d f7 00 00 call 13198c "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 12220f: 89 1c 24 mov %ebx,(%esp) 122212: e8 8d ed 00 00 call 130fa4 122217: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 12221a: 53 push %ebx 12221b: 53 push %ebx 12221c: 68 7b c9 14 00 push $0x14c97b 122221: 68 b9 03 15 00 push $0x1503b9 122226: e8 f1 f5 00 00 call 13181c 12222b: 83 c4 10 add $0x10,%esp 12222e: 85 c0 test %eax,%eax 122230: 74 06 je 122238 fclose(fp); 122232: 83 ec 0c sub $0xc,%esp 122235: 50 push %eax 122236: eb 2a jmp 122262 } else if ((fp = fopen("/etc/group", "w")) != NULL) { 122238: 51 push %ecx 122239: 51 push %ecx 12223a: 68 78 c9 14 00 push $0x14c978 12223f: 68 b9 03 15 00 push $0x1503b9 122244: e8 d3 f5 00 00 call 13181c 122249: 89 c3 mov %eax,%ebx 12224b: 83 c4 10 add $0x10,%esp 12224e: 85 c0 test %eax,%eax 122250: 74 18 je 12226a <== NEVER TAKEN fprintf( fp, "root:x:0:root\n" 122252: 52 push %edx 122253: 52 push %edx 122254: 50 push %eax 122255: 68 c4 03 15 00 push $0x1503c4 12225a: e8 2d f7 00 00 call 13198c "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 12225f: 89 1c 24 mov %ebx,(%esp) 122262: e8 3d ed 00 00 call 130fa4 122267: 83 c4 10 add $0x10,%esp } } 12226a: 8b 5d fc mov -0x4(%ebp),%ebx 12226d: c9 leave 12226e: c3 ret =============================================================================== 00108c6f : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 108c6f: 55 push %ebp 108c70: 89 e5 mov %esp,%ebp 108c72: 53 push %ebx 108c73: 83 ec 14 sub $0x14,%esp 108c76: 89 d3 mov %edx,%ebx 108c78: 88 c1 mov %al,%cl if (tty->termios.c_iflag & ISTRIP) 108c7a: 8b 42 30 mov 0x30(%edx),%eax 108c7d: a8 20 test $0x20,%al 108c7f: 74 03 je 108c84 <== ALWAYS TAKEN c &= 0x7f; 108c81: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 108c84: f6 c4 02 test $0x2,%ah 108c87: 74 17 je 108ca0 c = tolower (c); 108c89: 0f b6 c9 movzbl %cl,%ecx 108c8c: 8b 15 88 c2 12 00 mov 0x12c288,%edx 108c92: 8a 54 0a 01 mov 0x1(%edx,%ecx,1),%dl 108c96: 83 e2 03 and $0x3,%edx 108c99: fe ca dec %dl 108c9b: 75 03 jne 108ca0 108c9d: 83 c1 20 add $0x20,%ecx if (c == '\r') { 108ca0: 80 f9 0d cmp $0xd,%cl 108ca3: 75 12 jne 108cb7 if (tty->termios.c_iflag & IGNCR) 108ca5: a8 80 test $0x80,%al 108ca7: 74 05 je 108cae <== ALWAYS TAKEN 108ca9: e9 20 01 00 00 jmp 108dce <== NOT EXECUTED return 0; if (tty->termios.c_iflag & ICRNL) 108cae: f6 c4 01 test $0x1,%ah 108cb1: 74 19 je 108ccc <== NEVER TAKEN c = '\n'; 108cb3: b1 0a mov $0xa,%cl 108cb5: eb 15 jmp 108ccc } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 108cb7: 80 f9 0a cmp $0xa,%cl 108cba: 75 08 jne 108cc4 108cbc: a8 40 test $0x40,%al 108cbe: 74 0c je 108ccc <== ALWAYS TAKEN c = '\r'; 108cc0: b1 0d mov $0xd,%cl <== NOT EXECUTED 108cc2: eb 08 jmp 108ccc <== NOT EXECUTED } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108cc4: 84 c9 test %cl,%cl 108cc6: 0f 84 d4 00 00 00 je 108da0 <== NEVER TAKEN 108ccc: 8b 43 3c mov 0x3c(%ebx),%eax 108ccf: a8 02 test $0x2,%al 108cd1: 0f 84 c9 00 00 00 je 108da0 if (c == tty->termios.c_cc[VERASE]) { 108cd7: 3a 4b 43 cmp 0x43(%ebx),%cl 108cda: 75 0d jne 108ce9 108cdc: 31 d2 xor %edx,%edx * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) 108cde: 83 7b 20 00 cmpl $0x0,0x20(%ebx) 108ce2: 75 59 jne 108d3d 108ce4: e9 e5 00 00 00 jmp 108dce if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { if (c == tty->termios.c_cc[VERASE]) { erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 108ce9: 3a 4b 44 cmp 0x44(%ebx),%cl 108cec: 75 5b jne 108d49 * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) 108cee: 83 7b 20 00 cmpl $0x0,0x20(%ebx) 108cf2: 0f 84 d6 00 00 00 je 108dce <== NEVER TAKEN return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { 108cf8: a8 08 test $0x8,%al 108cfa: 75 0c jne 108d08 <== ALWAYS TAKEN tty->ccount = 0; 108cfc: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 108d03: e9 c6 00 00 00 jmp 108dce <== NOT EXECUTED 108d08: ba 01 00 00 00 mov $0x1,%edx return; } if (!(tty->termios.c_lflag & ECHOE)) { 108d0d: a8 10 test $0x10,%al 108d0f: 75 2c jne 108d3d <== ALWAYS TAKEN tty->ccount = 0; 108d11: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 108d18: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108d1b: 89 da mov %ebx,%edx <== NOT EXECUTED 108d1d: e8 c6 fd ff ff call 108ae8 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 108d22: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 108d26: 0f 84 a2 00 00 00 je 108dce <== NOT EXECUTED echo ('\n', tty); 108d2c: 89 da mov %ebx,%edx <== NOT EXECUTED 108d2e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108d33: e8 b0 fd ff ff call 108ae8 <== NOT EXECUTED 108d38: e9 91 00 00 00 jmp 108dce <== NOT EXECUTED 108d3d: 89 d8 mov %ebx,%eax 108d3f: e8 fc fd ff ff call 108b40 108d44: e9 85 00 00 00 jmp 108dce } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 108d49: 3a 4b 45 cmp 0x45(%ebx),%cl 108d4c: 0f 84 80 00 00 00 je 108dd2 <== NEVER TAKEN return 1; } else if (c == '\n') { 108d52: 80 f9 0a cmp $0xa,%cl 108d55: 75 1c jne 108d73 if (tty->termios.c_lflag & (ECHO | ECHONL)) 108d57: a8 48 test $0x48,%al 108d59: 74 0c je 108d67 <== NEVER TAKEN echo (c, tty); 108d5b: 89 da mov %ebx,%edx 108d5d: b8 0a 00 00 00 mov $0xa,%eax 108d62: e8 81 fd ff ff call 108ae8 tty->cbuf[tty->ccount++] = c; 108d67: 8b 43 20 mov 0x20(%ebx),%eax 108d6a: 8b 53 1c mov 0x1c(%ebx),%edx 108d6d: c6 04 02 0a movb $0xa,(%edx,%eax,1) 108d71: eb 27 jmp 108d9a return 1; } else if ((c == tty->termios.c_cc[VEOL]) || 108d73: 3a 4b 4c cmp 0x4c(%ebx),%cl 108d76: 74 05 je 108d7d <== NEVER TAKEN 108d78: 3a 4b 51 cmp 0x51(%ebx),%cl 108d7b: 75 23 jne 108da0 <== ALWAYS TAKEN (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 108d7d: a8 08 test $0x8,%al <== NOT EXECUTED 108d7f: 74 10 je 108d91 <== NOT EXECUTED echo (c, tty); 108d81: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108d84: 89 da mov %ebx,%edx <== NOT EXECUTED 108d86: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED 108d89: e8 5a fd ff ff call 108ae8 <== NOT EXECUTED 108d8e: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108d91: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108d94: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 108d97: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED 108d9a: 40 inc %eax 108d9b: 89 43 20 mov %eax,0x20(%ebx) 108d9e: eb 32 jmp 108dd2 } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 108da0: a1 0c c1 12 00 mov 0x12c10c,%eax 108da5: 48 dec %eax 108da6: 39 43 20 cmp %eax,0x20(%ebx) 108da9: 73 23 jae 108dce <== NEVER TAKEN if (tty->termios.c_lflag & ECHO) 108dab: f6 43 3c 08 testb $0x8,0x3c(%ebx) 108daf: 74 10 je 108dc1 <== NEVER TAKEN echo (c, tty); 108db1: 0f b6 c1 movzbl %cl,%eax 108db4: 89 da mov %ebx,%edx 108db6: 88 4d f4 mov %cl,-0xc(%ebp) 108db9: e8 2a fd ff ff call 108ae8 108dbe: 8a 4d f4 mov -0xc(%ebp),%cl tty->cbuf[tty->ccount++] = c; 108dc1: 8b 43 20 mov 0x20(%ebx),%eax 108dc4: 8b 53 1c mov 0x1c(%ebx),%edx 108dc7: 88 0c 02 mov %cl,(%edx,%eax,1) 108dca: 40 inc %eax 108dcb: 89 43 20 mov %eax,0x20(%ebx) } return 0; 108dce: 31 c0 xor %eax,%eax 108dd0: eb 05 jmp 108dd7 else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { return 1; 108dd2: b8 01 00 00 00 mov $0x1,%eax if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; } return 0; } 108dd7: 83 c4 14 add $0x14,%esp 108dda: 5b pop %ebx 108ddb: 5d pop %ebp 108ddc: c3 ret =============================================================================== 0011d990 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 11d990: 55 push %ebp 11d991: 89 e5 mov %esp,%ebp 11d993: 57 push %edi 11d994: 56 push %esi 11d995: 53 push %ebx 11d996: 83 ec 3c sub $0x3c,%esp 11d999: 8b 5d 0c mov 0xc(%ebp),%ebx 11d99c: 8b 75 10 mov 0x10(%ebp),%esi POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 11d99f: e8 f0 fd ff ff call 11d794 11d9a4: 39 45 08 cmp %eax,0x8(%ebp) 11d9a7: 74 10 je 11d9b9 rtems_set_errno_and_return_minus_one( ESRCH ); 11d9a9: e8 2e 35 ff ff call 110edc <__errno> 11d9ae: c7 00 03 00 00 00 movl $0x3,(%eax) 11d9b4: e9 f1 01 00 00 jmp 11dbaa /* * Validate the signal passed. */ if ( !sig ) 11d9b9: 85 db test %ebx,%ebx 11d9bb: 75 02 jne 11d9bf 11d9bd: eb 08 jmp 11d9c7 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 11d9bf: 8d 4b ff lea -0x1(%ebx),%ecx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 11d9c2: 83 f9 1f cmp $0x1f,%ecx 11d9c5: 76 10 jbe 11d9d7 rtems_set_errno_and_return_minus_one( EINVAL ); 11d9c7: e8 10 35 ff ff call 110edc <__errno> 11d9cc: c7 00 16 00 00 00 movl $0x16,(%eax) 11d9d2: e9 d3 01 00 00 jmp 11dbaa /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 11d9d7: 6b c3 0c imul $0xc,%ebx,%eax 11d9da: 83 b8 30 e9 12 00 01 cmpl $0x1,0x12e930(%eax) 11d9e1: 0f 84 e9 01 00 00 je 11dbd0 /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 11d9e7: 83 fb 04 cmp $0x4,%ebx 11d9ea: 74 0a je 11d9f6 11d9ec: 83 fb 08 cmp $0x8,%ebx 11d9ef: 74 05 je 11d9f6 11d9f1: 83 fb 0b cmp $0xb,%ebx 11d9f4: 75 16 jne 11da0c return pthread_kill( pthread_self(), sig ); 11d9f6: e8 9d 03 00 00 call 11dd98 11d9fb: 56 push %esi 11d9fc: 56 push %esi 11d9fd: 53 push %ebx 11d9fe: 50 push %eax 11d9ff: e8 ec 02 00 00 call 11dcf0 11da04: 83 c4 10 add $0x10,%esp 11da07: e9 c6 01 00 00 jmp 11dbd2 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 11da0c: bf 01 00 00 00 mov $0x1,%edi 11da11: d3 e7 shl %cl,%edi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 11da13: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 11da16: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 11da1d: 85 f6 test %esi,%esi 11da1f: 75 09 jne 11da2a siginfo->si_value.sival_int = 0; 11da21: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 11da28: eb 05 jmp 11da2f } else { siginfo->si_value = *value; 11da2a: 8b 06 mov (%esi),%eax 11da2c: 89 45 e4 mov %eax,-0x1c(%ebp) * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 11da2f: a1 e4 e3 12 00 mov 0x12e3e4,%eax 11da34: 40 inc %eax 11da35: a3 e4 e3 12 00 mov %eax,0x12e3e4 return _Thread_Dispatch_disable_level; 11da3a: a1 e4 e3 12 00 mov 0x12e3e4,%eax /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 11da3f: a1 ec e8 12 00 mov 0x12e8ec,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 11da44: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx 11da4a: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 11da50: f7 d2 not %edx 11da52: 85 d7 test %edx,%edi 11da54: 0f 85 fa 00 00 00 jne 11db54 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 11da5a: a1 b4 ea 12 00 mov 0x12eab4,%eax /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 11da5f: eb 21 jmp 11da82 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11da61: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 11da67: 85 78 30 test %edi,0x30(%eax) 11da6a: 0f 85 e4 00 00 00 jne 11db54 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 11da70: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 11da76: f7 d2 not %edx 11da78: 85 d7 test %edx,%edi 11da7a: 0f 85 d4 00 00 00 jne 11db54 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 11da80: 8b 00 mov (%eax),%eax /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 11da82: 3d b8 ea 12 00 cmp $0x12eab8,%eax 11da87: 75 d8 jne 11da61 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 11da89: 0f b6 05 88 a1 12 00 movzbl 0x12a188,%eax 11da90: 40 inc %eax 11da91: 89 45 bc mov %eax,-0x44(%ebp) * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 11da94: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 11da96: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) /* * This can occur when no one is interested and an API is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 11da9d: 8b 4d cc mov -0x34(%ebp),%ecx 11daa0: 8b 14 8d bc e3 12 00 mov 0x12e3bc(,%ecx,4),%edx 11daa7: 85 d2 test %edx,%edx 11daa9: 0f 84 94 00 00 00 je 11db43 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 11daaf: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 11dab2: 0f b7 72 10 movzwl 0x10(%edx),%esi 11dab6: 89 75 c4 mov %esi,-0x3c(%ebp) object_table = the_info->local_table; 11dab9: 8b 52 1c mov 0x1c(%edx),%edx 11dabc: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 11dabf: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 11dac6: eb 73 jmp 11db3b the_thread = (Thread_Control *) object_table[ index ]; 11dac8: 8b 4d d0 mov -0x30(%ebp),%ecx 11dacb: 8b 75 c0 mov -0x40(%ebp),%esi 11dace: 8b 14 8e mov (%esi,%ecx,4),%edx if ( !the_thread ) 11dad1: 85 d2 test %edx,%edx 11dad3: 74 63 je 11db38 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 11dad5: 8b 4a 14 mov 0x14(%edx),%ecx 11dad8: 89 4d d4 mov %ecx,-0x2c(%ebp) 11dadb: 8b 75 bc mov -0x44(%ebp),%esi 11dade: 39 f1 cmp %esi,%ecx 11dae0: 77 56 ja 11db38 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 11dae2: 8b b2 e8 00 00 00 mov 0xe8(%edx),%esi 11dae8: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi 11daee: f7 d6 not %esi 11daf0: 85 f7 test %esi,%edi 11daf2: 74 44 je 11db38 * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 11daf4: 8b 75 bc mov -0x44(%ebp),%esi 11daf7: 39 f1 cmp %esi,%ecx 11daf9: 72 2d jb 11db28 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 11dafb: 85 c0 test %eax,%eax 11dafd: 74 39 je 11db38 <== NEVER TAKEN 11daff: 8b 48 10 mov 0x10(%eax),%ecx 11db02: 89 4d c8 mov %ecx,-0x38(%ebp) 11db05: 85 c9 test %ecx,%ecx 11db07: 74 2f je 11db38 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 11db09: 8b 72 10 mov 0x10(%edx),%esi 11db0c: 85 f6 test %esi,%esi 11db0e: 74 20 je 11db30 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 11db10: 81 e1 00 00 00 10 and $0x10000000,%ecx 11db16: 75 20 jne 11db38 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 11db18: 81 e6 00 00 00 10 and $0x10000000,%esi 11db1e: 74 18 je 11db38 11db20: 8b 75 d4 mov -0x2c(%ebp),%esi 11db23: 89 75 bc mov %esi,-0x44(%ebp) 11db26: eb 0e jmp 11db36 * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 11db28: 8b 45 d4 mov -0x2c(%ebp),%eax 11db2b: 89 45 bc mov %eax,-0x44(%ebp) 11db2e: eb 06 jmp 11db36 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 11db30: 8b 4d d4 mov -0x2c(%ebp),%ecx 11db33: 89 4d bc mov %ecx,-0x44(%ebp) 11db36: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 11db38: ff 45 d0 incl -0x30(%ebp) 11db3b: 8b 75 c4 mov -0x3c(%ebp),%esi 11db3e: 39 75 d0 cmp %esi,-0x30(%ebp) 11db41: 76 85 jbe 11dac8 * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 11db43: ff 45 cc incl -0x34(%ebp) 11db46: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 11db4a: 0f 85 4d ff ff ff jne 11da9d } } } } if ( interested ) { 11db50: 85 c0 test %eax,%eax 11db52: 74 1a je 11db6e /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 11db54: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 11db55: 8d 55 dc lea -0x24(%ebp),%edx /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 11db58: 52 push %edx 11db59: 53 push %ebx 11db5a: 50 push %eax 11db5b: e8 90 00 00 00 call 11dbf0 <_POSIX_signals_Unblock_thread> 11db60: 83 c4 10 add $0x10,%esp 11db63: 84 c0 test %al,%al 11db65: 74 07 je 11db6e _Thread_Enable_dispatch(); 11db67: e8 a0 e2 fe ff call 10be0c <_Thread_Enable_dispatch> 11db6c: eb 62 jmp 11dbd0 /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 11db6e: 83 ec 0c sub $0xc,%esp 11db71: 57 push %edi 11db72: e8 65 00 00 00 call 11dbdc <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 11db77: 6b db 0c imul $0xc,%ebx,%ebx 11db7a: 83 c4 10 add $0x10,%esp 11db7d: 83 bb 28 e9 12 00 02 cmpl $0x2,0x12e928(%ebx) 11db84: 75 e1 jne 11db67 psiginfo = (POSIX_signals_Siginfo_node *) 11db86: 83 ec 0c sub $0xc,%esp 11db89: 68 a8 ea 12 00 push $0x12eaa8 11db8e: e8 ed ca fe ff call 10a680 <_Chain_Get> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 11db93: 83 c4 10 add $0x10,%esp 11db96: 85 c0 test %eax,%eax 11db98: 75 15 jne 11dbaf _Thread_Enable_dispatch(); 11db9a: e8 6d e2 fe ff call 10be0c <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 11db9f: e8 38 33 ff ff call 110edc <__errno> 11dba4: c7 00 0b 00 00 00 movl $0xb,(%eax) 11dbaa: 83 c8 ff or $0xffffffff,%eax 11dbad: eb 23 jmp 11dbd2 } psiginfo->Info = *siginfo; 11dbaf: 8d 78 08 lea 0x8(%eax),%edi 11dbb2: 8d 75 dc lea -0x24(%ebp),%esi 11dbb5: b9 03 00 00 00 mov $0x3,%ecx 11dbba: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 11dbbc: 52 push %edx 11dbbd: 52 push %edx 11dbbe: 50 push %eax 11dbbf: 81 c3 20 eb 12 00 add $0x12eb20,%ebx 11dbc5: 53 push %ebx 11dbc6: e8 91 ca fe ff call 10a65c <_Chain_Append> 11dbcb: 83 c4 10 add $0x10,%esp 11dbce: eb 97 jmp 11db67 /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) return 0; 11dbd0: 31 c0 xor %eax,%eax } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 11dbd2: 8d 65 f4 lea -0xc(%ebp),%esp 11dbd5: 5b pop %ebx 11dbd6: 5e pop %esi 11dbd7: 5f pop %edi 11dbd8: 5d pop %ebp 11dbd9: c3 ret =============================================================================== 00106e64 : /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 106e64: 83 3d 20 e5 12 00 03 cmpl $0x3,0x12e520 106e6b: 75 58 jne 106ec5 <== NEVER TAKEN extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 106e6d: 55 push %ebp 106e6e: 89 e5 mov %esp,%ebp 106e70: 53 push %ebx 106e71: 51 push %ecx /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != _global_impure_ptr) { 106e72: 8b 1d 60 04 12 00 mov 0x120460,%ebx 106e78: 39 1d a0 c2 12 00 cmp %ebx,0x12c2a0 106e7e: 74 12 je 106e92 _wrapup_reent(_global_impure_ptr); 106e80: 83 ec 0c sub $0xc,%esp 106e83: 53 push %ebx 106e84: e8 a7 aa 00 00 call 111930 <_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; 106e89: 89 1d a0 c2 12 00 mov %ebx,0x12c2a0 106e8f: 83 c4 10 add $0x10,%esp * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 106e92: 83 ec 0c sub $0xc,%esp 106e95: a1 a0 c2 12 00 mov 0x12c2a0,%eax 106e9a: ff 70 04 pushl 0x4(%eax) 106e9d: e8 56 a1 00 00 call 110ff8 fclose (stdout); 106ea2: 58 pop %eax 106ea3: a1 a0 c2 12 00 mov 0x12c2a0,%eax 106ea8: ff 70 08 pushl 0x8(%eax) 106eab: e8 48 a1 00 00 call 110ff8 fclose (stderr); 106eb0: 5a pop %edx 106eb1: a1 a0 c2 12 00 mov 0x12c2a0,%eax 106eb6: ff 70 0c pushl 0xc(%eax) 106eb9: e8 3a a1 00 00 call 110ff8 106ebe: 83 c4 10 add $0x10,%esp } 106ec1: 8b 5d fc mov -0x4(%ebp),%ebx 106ec4: c9 leave 106ec5: c3 ret =============================================================================== 001069f4 : #include "malloc_p.h" void *malloc( size_t size ) { 1069f4: 55 push %ebp 1069f5: 89 e5 mov %esp,%ebp 1069f7: 56 push %esi 1069f8: 53 push %ebx 1069f9: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; MSBUMP(malloc_calls, 1); 1069fc: ff 05 ec e2 12 00 incl 0x12e2ec /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 106a02: e8 04 ff ff ff call 10690b /* * Validate the parameters */ if ( !size ) 106a07: 85 f6 test %esi,%esi 106a09: 75 02 jne 106a0d 106a0b: eb 43 jmp 106a50 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 106a0d: 83 3d 20 e5 12 00 03 cmpl $0x3,0x12e520 106a14: 74 1b je 106a31 RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 106a16: 6a 00 push $0x0 106a18: 6a 00 push $0x0 106a1a: 56 push %esi 106a1b: ff 35 2c a2 12 00 pushl 0x12a22c 106a21: e8 ae 4a 00 00 call 10b4d4 <_Protected_heap_Allocate_aligned_with_boundary> * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { 106a26: 83 c4 10 add $0x10,%esp 106a29: 85 c0 test %eax,%eax 106a2b: 74 0f je 106a3c 106a2d: 89 c3 mov %eax,%ebx 106a2f: eb 33 jmp 106a64 /* * 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() ) 106a31: e8 96 fe ff ff call 1068cc return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 106a36: 84 c0 test %al,%al 106a38: 75 dc jne 106a16 <== ALWAYS TAKEN 106a3a: eb 14 jmp 106a50 <== NOT EXECUTED */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) 106a3c: a1 00 c8 12 00 mov 0x12c800,%eax 106a41: 85 c0 test %eax,%eax 106a43: 75 0f jne 106a54 return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); if ( !return_this ) { errno = ENOMEM; 106a45: e8 92 a4 00 00 call 110edc <__errno> 106a4a: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 106a50: 31 db xor %ebx,%ebx 106a52: eb 35 jmp 106a89 return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 106a54: 83 ec 0c sub $0xc,%esp 106a57: 56 push %esi 106a58: ff 50 04 call *0x4(%eax) 106a5b: 89 c3 mov %eax,%ebx if ( !return_this ) { 106a5d: 83 c4 10 add $0x10,%esp 106a60: 85 c0 test %eax,%eax 106a62: 74 e1 je 106a45 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 106a64: a1 fc c7 12 00 mov 0x12c7fc,%eax 106a69: 85 c0 test %eax,%eax 106a6b: 74 09 je 106a76 (*rtems_malloc_dirty_helper)( return_this, size ); 106a6d: 52 push %edx 106a6e: 52 push %edx 106a6f: 56 push %esi 106a70: 53 push %ebx 106a71: ff d0 call *%eax 106a73: 83 c4 10 add $0x10,%esp /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 106a76: a1 04 c8 12 00 mov 0x12c804,%eax 106a7b: 85 c0 test %eax,%eax 106a7d: 74 0a je 106a89 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 106a7f: 83 ec 0c sub $0xc,%esp 106a82: 53 push %ebx 106a83: ff 50 04 call *0x4(%eax) 106a86: 83 c4 10 add $0x10,%esp return return_this; } 106a89: 89 d8 mov %ebx,%eax 106a8b: 8d 65 f8 lea -0x8(%ebp),%esp 106a8e: 5b pop %ebx 106a8f: 5e pop %esi 106a90: 5d pop %ebp 106a91: c3 ret =============================================================================== 00106a90 : } static void *malloc_sbrk_extend_and_allocate( size_t size ) { 106a90: 55 push %ebp 106a91: 89 e5 mov %esp,%ebp 106a93: 56 push %esi 106a94: 53 push %ebx 106a95: 8b 75 08 mov 0x8(%ebp),%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; 106a98: 8b 0d 9c ea 12 00 mov 0x12ea9c,%ecx if ( sbrk_amount == 0 ) 106a9e: 85 c9 test %ecx,%ecx 106aa0: 75 02 jne 106aa4 <== ALWAYS TAKEN 106aa2: eb 4b jmp 106aef <== NOT EXECUTED return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 106aa4: 8d 04 0e lea (%esi,%ecx,1),%eax 106aa7: 31 d2 xor %edx,%edx 106aa9: f7 f1 div %ecx 106aab: 89 c3 mov %eax,%ebx 106aad: 0f af d9 imul %ecx,%ebx starting_address = (void *) sbrk(the_size); 106ab0: 83 ec 0c sub $0xc,%esp 106ab3: 53 push %ebx 106ab4: e8 1c 99 ff ff call 1003d5 if ( starting_address == (void*) -1 ) 106ab9: 83 c4 10 add $0x10,%esp 106abc: 83 f8 ff cmp $0xffffffff,%eax 106abf: 74 2e je 106aef return (void *) 0; if ( !_Protected_heap_Extend( 106ac1: 52 push %edx 106ac2: 53 push %ebx 106ac3: 50 push %eax 106ac4: ff 35 6c a8 12 00 pushl 0x12a86c 106aca: e8 51 4a 00 00 call 10b520 <_Protected_heap_Extend> 106acf: 83 c4 10 add $0x10,%esp 106ad2: 84 c0 test %al,%al 106ad4: 75 1d jne 106af3 RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 106ad6: 83 ec 0c sub $0xc,%esp 106ad9: f7 db neg %ebx 106adb: 53 push %ebx 106adc: e8 f4 98 ff ff call 1003d5 errno = ENOMEM; 106ae1: e8 7a a6 00 00 call 111160 <__errno> 106ae6: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 106aec: 83 c4 10 add $0x10,%esp 106aef: 31 c0 xor %eax,%eax 106af1: eb 19 jmp 106b0c } MSBUMP(space_available, the_size); 106af3: 01 1d 70 ea 12 00 add %ebx,0x12ea70 106af9: 6a 00 push $0x0 106afb: 6a 00 push $0x0 106afd: 56 push %esi 106afe: ff 35 6c a8 12 00 pushl 0x12a86c 106b04: e8 df 49 00 00 call 10b4e8 <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; 106b09: 83 c4 10 add $0x10,%esp } 106b0c: 8d 65 f8 lea -0x8(%ebp),%esp 106b0f: 5b pop %ebx 106b10: 5e pop %esi 106b11: 5d pop %ebp 106b12: c3 ret =============================================================================== 00106b13 : static void *malloc_sbrk_initialize( void *starting_address, size_t length ) { 106b13: 55 push %ebp 106b14: 89 e5 mov %esp,%ebp 106b16: 83 ec 08 sub $0x8,%esp 106b19: 8b 45 08 mov 0x8(%ebp),%eax 106b1c: 8b 55 0c mov 0xc(%ebp),%edx uintptr_t old_address; uintptr_t uaddress; RTEMS_Malloc_Sbrk_amount = length; 106b1f: 89 15 9c ea 12 00 mov %edx,0x12ea9c * 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) { 106b25: 85 c0 test %eax,%eax 106b27: 75 25 jne 106b4e uaddress = (uintptr_t)sbrk(length); 106b29: 83 ec 0c sub $0xc,%esp 106b2c: 52 push %edx 106b2d: e8 a3 98 ff ff call 1003d5 if (uaddress == (uintptr_t) -1) { 106b32: 83 c4 10 add $0x10,%esp 106b35: 83 f8 ff cmp $0xffffffff,%eax 106b38: 75 0a jne 106b44 <== NEVER TAKEN rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 106b3a: 83 ec 0c sub $0xc,%esp 106b3d: 6a 1a push $0x1a 106b3f: e8 f4 38 00 00 call 10a438 /* DOES NOT RETURN!!! */ } if (uaddress & (CPU_HEAP_ALIGNMENT-1)) { 106b44: a8 03 test $0x3,%al <== NOT EXECUTED 106b46: 74 06 je 106b4e <== NOT EXECUTED old_address = uaddress; uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1); 106b48: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 106b4b: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } starting_address = (void *)uaddress; } return starting_address; } 106b4e: c9 leave 106b4f: c3 ret =============================================================================== 00106bac : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 106bac: 55 push %ebp 106bad: 89 e5 mov %esp,%ebp 106baf: 57 push %edi 106bb0: 56 push %esi 106bb1: 53 push %ebx 106bb2: 83 ec 7c sub $0x7c,%esp 106bb5: 8b 75 10 mov 0x10(%ebp),%esi int rv = 0; if ( 106bb8: 83 7d 14 01 cmpl $0x1,0x14(%ebp) 106bbc: 0f 87 6e 02 00 00 ja 106e30 options == RTEMS_FILESYSTEM_READ_ONLY || options == RTEMS_FILESYSTEM_READ_WRITE ) { rtems_filesystem_fsmount_me_t fsmount_me_h = 106bc2: 83 ec 0c sub $0xc,%esp 106bc5: 56 push %esi 106bc6: e8 c4 70 00 00 call 10dc8f 106bcb: 89 45 84 mov %eax,-0x7c(%ebp) rtems_filesystem_get_mount_handler( filesystemtype ); if ( fsmount_me_h != NULL ) { 106bce: 83 c4 10 add $0x10,%esp 106bd1: 85 c0 test %eax,%eax 106bd3: 0f 84 57 02 00 00 je 106e30 const char *target_or_null, const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; 106bd9: 8b 55 0c mov 0xc(%ebp),%edx 106bdc: 89 55 88 mov %edx,-0x78(%ebp) 106bdf: 85 d2 test %edx,%edx 106be1: 75 07 jne 106bea 106be3: c7 45 88 60 f8 11 00 movl $0x11f860,-0x78(%ebp) size_t filesystemtype_size = strlen( filesystemtype ) + 1; 106bea: 83 cb ff or $0xffffffff,%ebx 106bed: 31 c0 xor %eax,%eax 106bef: 89 d9 mov %ebx,%ecx 106bf1: 89 f7 mov %esi,%edi 106bf3: f2 ae repnz scas %es:(%edi),%al 106bf5: f7 d1 not %ecx 106bf7: 89 4d 94 mov %ecx,-0x6c(%ebp) 106bfa: 89 ca mov %ecx,%edx 106bfc: 4a dec %edx size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 106bfd: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 106c01: 74 0e je 106c11 106c03: 89 d9 mov %ebx,%ecx 106c05: 8b 7d 08 mov 0x8(%ebp),%edi 106c08: f2 ae repnz scas %es:(%edi),%al 106c0a: f7 d1 not %ecx 106c0c: 89 4d 90 mov %ecx,-0x70(%ebp) 106c0f: eb 07 jmp 106c18 106c11: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp) size_t target_size = strlen( target ) + 1; 106c18: 31 c0 xor %eax,%eax 106c1a: 83 c9 ff or $0xffffffff,%ecx 106c1d: 8b 7d 88 mov -0x78(%ebp),%edi 106c20: f2 ae repnz scas %es:(%edi),%al 106c22: f7 d1 not %ecx 106c24: 89 4d 8c mov %ecx,-0x74(%ebp) size_t size = sizeof( rtems_filesystem_mount_table_entry_t ) + filesystemtype_size + source_size + target_size + sizeof( rtems_filesystem_global_location_t ); rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 106c27: 51 push %ecx 106c28: 51 push %ecx 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 ) + filesystemtype_size + source_size + target_size 106c29: 8b 4d 90 mov -0x70(%ebp),%ecx 106c2c: 8d 44 0a 65 lea 0x65(%edx,%ecx,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 ) 106c30: 03 45 8c add -0x74(%ebp),%eax + filesystemtype_size + source_size + target_size + sizeof( rtems_filesystem_global_location_t ); rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 106c33: 50 push %eax 106c34: 6a 01 push $0x1 106c36: e8 f1 f8 ff ff call 10652c 106c3b: 89 c3 mov %eax,%ebx if ( mt_entry != NULL ) { 106c3d: 83 c4 10 add $0x10,%esp 106c40: 85 c0 test %eax,%eax 106c42: 0f 84 03 02 00 00 je 106e4b <== NEVER TAKEN rtems_filesystem_global_location_t *mt_fs_root = 106c48: 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 ); 106c4b: 8d 40 64 lea 0x64(%eax),%eax memcpy( str, filesystemtype, filesystemtype_size ); 106c4e: 89 c7 mov %eax,%edi 106c50: 8b 4d 94 mov -0x6c(%ebp),%ecx 106c53: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 106c55: 89 7d 94 mov %edi,-0x6c(%ebp) mt_entry->type = str; 106c58: 89 43 34 mov %eax,0x34(%ebx) str += filesystemtype_size; memcpy( str, source_or_null, source_size ); 106c5b: 8b 75 08 mov 0x8(%ebp),%esi 106c5e: 8b 4d 90 mov -0x70(%ebp),%ecx 106c61: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 106c63: 89 f8 mov %edi,%eax mt_entry->dev = str; 106c65: 8b 7d 94 mov -0x6c(%ebp),%edi 106c68: 89 7b 38 mov %edi,0x38(%ebx) str += source_size; memcpy( str, target, target_size ); 106c6b: 89 c7 mov %eax,%edi 106c6d: 8b 75 88 mov -0x78(%ebp),%esi 106c70: 8b 4d 8c mov -0x74(%ebp),%ecx 106c73: f3 a4 rep movsb %ds:(%esi),%es:(%edi) mt_entry->target = str; 106c75: 89 43 30 mov %eax,0x30(%ebx) str += target_size; mt_entry->mounted = true; 106c78: c6 43 28 01 movb $0x1,0x28(%ebx) mt_entry->mt_fs_root = mt_fs_root; 106c7c: 89 53 24 mov %edx,0x24(%ebx) mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf; 106c7f: c7 43 2c 64 f8 11 00 movl $0x11f864,0x2c(%ebx) mt_fs_root->location.mt_entry = mt_entry; 106c86: 89 5b 54 mov %ebx,0x54(%ebx) mt_fs_root->reference_count = 1; 106c89: 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 ); 106c90: 6a 24 push $0x24 106c92: 6a 01 push $0x1 106c94: 52 push %edx rtems_chain_initialize( 106c95: 8d 43 14 lea 0x14(%ebx),%eax 106c98: 50 push %eax 106c99: e8 06 3a 00 00 call 10a6a4 <_Chain_Initialize> filesystemtype, &target_length ); if ( mt_entry != NULL ) { mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 106c9e: 8a 45 14 mov 0x14(%ebp),%al 106ca1: 88 43 29 mov %al,0x29(%ebx) 106ca4: 80 63 29 01 andb $0x1,0x29(%ebx) rv = (*fsmount_me_h)( mt_entry, data ); 106ca8: 58 pop %eax 106ca9: 5a pop %edx 106caa: ff 75 18 pushl 0x18(%ebp) 106cad: 53 push %ebx 106cae: 8b 55 84 mov -0x7c(%ebp),%edx 106cb1: ff d2 call *%edx 106cb3: 89 c6 mov %eax,%esi if ( rv == 0 ) { 106cb5: 83 c4 10 add $0x10,%esp 106cb8: 85 c0 test %eax,%eax 106cba: 0f 85 7d 01 00 00 jne 106e3d if ( target != NULL ) { 106cc0: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 106cc4: 0f 84 c4 00 00 00 je 106d8e { 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 = 106cca: 50 push %eax 106ccb: 6a 1f push $0x1f 106ccd: ff 75 0c pushl 0xc(%ebp) rtems_filesystem_eval_path_start( &ctx, target, eval_flags ); 106cd0: 8d 75 b0 lea -0x50(%ebp),%esi { 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 = 106cd3: 56 push %esi 106cd4: e8 0c 0b 00 00 call 1077e5 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; 106cd9: 8b 50 14 mov 0x14(%eax),%edx return (*mt_entry->ops->are_nodes_equal_h)( 106cdc: 59 pop %ecx 106cdd: 5f pop %edi 106cde: 8b 4a 0c mov 0xc(%edx),%ecx 106ce1: ff 72 24 pushl 0x24(%edx) 106ce4: 50 push %eax 106ce5: ff 51 10 call *0x10(%ecx) rtems_filesystem_eval_path_start( &ctx, target, eval_flags ); if ( !rtems_filesystem_location_is_root( currentloc ) ) { 106ce8: 83 c4 10 add $0x10,%esp 106ceb: 84 c0 test %al,%al 106ced: 75 73 jne 106d62 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( 106cef: 50 push %eax 106cf0: 50 push %eax 106cf1: 8d 45 c8 lea -0x38(%ebp),%eax 106cf4: 50 push %eax rtems_filesystem_location_info_t targetloc; rtems_filesystem_global_location_t *mt_point_node; rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc ); 106cf5: 8d 75 98 lea -0x68(%ebp),%esi 106cf8: 56 push %esi 106cf9: e8 41 0e 00 00 call 107b3f mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc ); 106cfe: 89 34 24 mov %esi,(%esp) 106d01: e8 ac 0f 00 00 call 107cb2 106d06: 89 c7 mov %eax,%edi mt_entry->mt_point_node = mt_point_node; 106d08: 89 43 20 mov %eax,0x20(%ebx) rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry ); 106d0b: 8b 40 14 mov 0x14(%eax),%eax 106d0e: 8b 40 0c mov 0xc(%eax),%eax 106d11: 89 1c 24 mov %ebx,(%esp) 106d14: ff 50 30 call *0x30(%eax) 106d17: 89 c6 mov %eax,%esi if ( rv == 0 ) { 106d19: 83 c4 10 add $0x10,%esp 106d1c: 85 c0 test %eax,%eax 106d1e: 75 34 jne 106d54 */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 106d20: 50 push %eax 106d21: 6a 00 push $0x0 106d23: 6a 00 push $0x0 106d25: ff 35 d8 e2 12 00 pushl 0x12e2d8 106d2b: e8 60 30 00 00 call 109d90 Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 106d30: a1 fc c0 12 00 mov 0x12c0fc,%eax the_node->next = tail; 106d35: c7 03 f8 c0 12 00 movl $0x12c0f8,(%ebx) tail->previous = the_node; 106d3b: 89 1d fc c0 12 00 mov %ebx,0x12c0fc old_last->next = the_node; 106d41: 89 18 mov %ebx,(%eax) the_node->previous = old_last; 106d43: 89 43 04 mov %eax,0x4(%ebx) } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 106d46: 58 pop %eax 106d47: ff 35 d8 e2 12 00 pushl 0x12e2d8 106d4d: e8 2e 31 00 00 call 109e80 106d52: eb 09 jmp 106d5d &rtems_filesystem_mount_table, &mt_entry->mt_node ); rtems_filesystem_mt_unlock(); } else { rtems_filesystem_global_location_release( mt_point_node ); 106d54: 83 ec 0c sub $0xc,%esp 106d57: 57 push %edi 106d58: e8 6c 0e 00 00 call 107bc9 106d5d: 83 c4 10 add $0x10,%esp 106d60: eb 10 jmp 106d72 } } else { rtems_filesystem_eval_path_error( &ctx, EBUSY ); 106d62: 50 push %eax 106d63: 50 push %eax 106d64: 6a 10 push $0x10 106d66: 56 push %esi 106d67: e8 52 08 00 00 call 1075be 106d6c: 83 c4 10 add $0x10,%esp rv = -1; 106d6f: 83 ce ff or $0xffffffff,%esi } rtems_filesystem_eval_path_cleanup( &ctx ); 106d72: 83 ec 0c sub $0xc,%esp 106d75: 8d 45 b0 lea -0x50(%ebp),%eax 106d78: 50 push %eax 106d79: e8 23 0b 00 00 call 1078a1 106d7e: 83 c4 10 add $0x10,%esp rv = register_subordinate_file_system( mt_entry, target ); } else { rv = register_root_file_system( mt_entry ); } if ( rv != 0 ) { 106d81: 85 f6 test %esi,%esi 106d83: 0f 84 d0 00 00 00 je 106e59 106d89: e9 93 00 00 00 jmp 106e21 */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 106d8e: 50 push %eax 106d8f: 6a 00 push $0x0 106d91: 6a 00 push $0x0 106d93: ff 35 d8 e2 12 00 pushl 0x12e2d8 106d99: e8 f2 2f 00 00 call 109d90 ) { int rv = 0; rtems_filesystem_mt_lock(); if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) { 106d9e: 83 c4 10 add $0x10,%esp 106da1: 81 3d f4 c0 12 00 f8 cmpl $0x12c0f8,0x12c0f4 106da8: c0 12 00 106dab: 75 18 jne 106dc5 <== NEVER TAKEN Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 106dad: a1 fc c0 12 00 mov 0x12c0fc,%eax the_node->next = tail; 106db2: c7 03 f8 c0 12 00 movl $0x12c0f8,(%ebx) tail->previous = the_node; 106db8: 89 1d fc c0 12 00 mov %ebx,0x12c0fc old_last->next = the_node; 106dbe: 89 18 mov %ebx,(%eax) the_node->previous = old_last; 106dc0: 89 43 04 mov %eax,0x4(%ebx) 106dc3: eb 0e jmp 106dd3 rtems_chain_append_unprotected( &rtems_filesystem_mount_table, &mt_entry->mt_node ); } else { errno = EINVAL; 106dc5: e8 12 a1 00 00 call 110edc <__errno> <== NOT EXECUTED 106dca: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED rv = -1; 106dd0: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 106dd3: 83 ec 0c sub $0xc,%esp 106dd6: ff 35 d8 e2 12 00 pushl 0x12e2d8 106ddc: e8 9f 30 00 00 call 109e80 } rtems_filesystem_mt_unlock(); if ( rv == 0 ) { 106de1: 83 c4 10 add $0x10,%esp 106de4: 85 f6 test %esi,%esi 106de6: 75 39 jne 106e21 <== NEVER TAKEN rtems_filesystem_global_location_t *new_fs_root = rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root ); 106de8: 83 c3 24 add $0x24,%ebx rv = -1; } rtems_filesystem_mt_unlock(); if ( rv == 0 ) { rtems_filesystem_global_location_t *new_fs_root = 106deb: 83 ec 0c sub $0xc,%esp 106dee: 53 push %ebx 106def: e8 37 0e 00 00 call 107c2b 106df4: 89 c7 mov %eax,%edi rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root ); rtems_filesystem_global_location_t *new_fs_current = 106df6: 89 1c 24 mov %ebx,(%esp) 106df9: e8 2d 0e 00 00 call 107c2b 106dfe: 89 c3 mov %eax,%ebx rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root ); rtems_filesystem_global_location_assign( 106e00: 58 pop %eax 106e01: 5a pop %edx 106e02: 57 push %edi 106e03: a1 14 c1 12 00 mov 0x12c114,%eax 106e08: 83 c0 04 add $0x4,%eax 106e0b: 50 push %eax 106e0c: e8 fd 0d 00 00 call 107c0e &rtems_filesystem_root, new_fs_root ); rtems_filesystem_global_location_assign( 106e11: 59 pop %ecx 106e12: 5f pop %edi 106e13: 53 push %ebx 106e14: ff 35 14 c1 12 00 pushl 0x12c114 106e1a: e8 ef 0d 00 00 call 107c0e 106e1f: eb 25 jmp 106e46 } else { rv = register_root_file_system( mt_entry ); } if ( rv != 0 ) { (*mt_entry->ops->fsunmount_me_h)( mt_entry ); 106e21: 83 ec 0c sub $0xc,%esp 106e24: 8b 43 0c mov 0xc(%ebx),%eax 106e27: 53 push %ebx 106e28: ff 50 3c call *0x3c(%eax) 106e2b: 83 c4 10 add $0x10,%esp 106e2e: eb 0d jmp 106e3d } else { errno = EINVAL; rv = -1; } } else { errno = EINVAL; 106e30: e8 a7 a0 00 00 call 110edc <__errno> 106e35: c7 00 16 00 00 00 movl $0x16,(%eax) 106e3b: eb 19 jmp 106e56 (*mt_entry->ops->fsunmount_me_h)( mt_entry ); } } if ( rv != 0 ) { free( mt_entry ); 106e3d: 83 ec 0c sub $0xc,%esp 106e40: 53 push %ebx 106e41: e8 ee f8 ff ff call 106734 106e46: 83 c4 10 add $0x10,%esp 106e49: eb 0e jmp 106e59 } } else { errno = ENOMEM; 106e4b: e8 8c a0 00 00 call 110edc <__errno> <== NOT EXECUTED 106e50: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED rv = -1; 106e56: 83 ce ff or $0xffffffff,%esi errno = EINVAL; rv = -1; } return rv; } 106e59: 89 f0 mov %esi,%eax 106e5b: 8d 65 f4 lea -0xc(%ebp),%esp 106e5e: 5b pop %ebx 106e5f: 5e pop %esi 106e60: 5f pop %edi 106e61: 5d pop %ebp 106e62: c3 ret =============================================================================== 0010a5b8 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 10a5b8: 55 push %ebp 10a5b9: 89 e5 mov %esp,%ebp 10a5bb: 57 push %edi 10a5bc: 56 push %esi 10a5bd: 53 push %ebx 10a5be: 83 ec 1c sub $0x1c,%esp 10a5c1: 8b 75 08 mov 0x8(%ebp),%esi 10a5c4: 8b 5d 0c mov 0xc(%ebp),%ebx 10a5c7: 8b 7d 10 mov 0x10(%ebp),%edi 10a5ca: 8b 55 14 mov 0x14(%ebp),%edx 10a5cd: 8b 4d 18 mov 0x18(%ebp),%ecx int rv = -1; if (target != NULL) { 10a5d0: 85 db test %ebx,%ebx 10a5d2: 74 3b je 10a60f <== NEVER TAKEN rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); 10a5d4: 50 push %eax 10a5d5: 50 push %eax 10a5d6: 68 ff 01 00 00 push $0x1ff 10a5db: 53 push %ebx 10a5dc: 89 55 e4 mov %edx,-0x1c(%ebp) 10a5df: 89 4d e0 mov %ecx,-0x20(%ebp) 10a5e2: e8 d1 0a 00 00 call 10b0b8 if (rv == 0) { 10a5e7: 83 c4 10 add $0x10,%esp 10a5ea: 85 c0 test %eax,%eax 10a5ec: 8b 55 e4 mov -0x1c(%ebp),%edx 10a5ef: 8b 4d e0 mov -0x20(%ebp),%ecx 10a5f2: 75 29 jne 10a61d <== NEVER TAKEN rv = mount( 10a5f4: 89 4d 18 mov %ecx,0x18(%ebp) 10a5f7: 89 55 14 mov %edx,0x14(%ebp) 10a5fa: 89 7d 10 mov %edi,0x10(%ebp) 10a5fd: 89 5d 0c mov %ebx,0xc(%ebp) 10a600: 89 75 08 mov %esi,0x8(%ebp) } else { errno = EINVAL; } return rv; } 10a603: 8d 65 f4 lea -0xc(%ebp),%esp 10a606: 5b pop %ebx 10a607: 5e pop %esi 10a608: 5f pop %edi 10a609: 5d pop %ebp int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 10a60a: e9 19 00 00 00 jmp 10a628 options, data ); } } else { errno = EINVAL; 10a60f: e8 b8 4b 01 00 call 11f1cc <__errno> 10a614: c7 00 16 00 00 00 movl $0x16,(%eax) const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { int rv = -1; 10a61a: 83 c8 ff or $0xffffffff,%eax } else { errno = EINVAL; } return rv; } 10a61d: 8d 65 f4 lea -0xc(%ebp),%esp 10a620: 5b pop %ebx 10a621: 5e pop %esi 10a622: 5f pop %edi 10a623: 5d pop %ebp 10a624: c3 ret =============================================================================== 00106f3d : */ bool newlib_create_hook( rtems_tcb *current_task __attribute__((unused)), rtems_tcb *creating_task ) { 106f3d: 55 push %ebp 106f3e: 89 e5 mov %esp,%ebp 106f40: 57 push %edi 106f41: 56 push %esi 106f42: 53 push %ebx 106f43: 83 ec 1c sub $0x1c,%esp struct _reent *ptr; if (_Thread_libc_reent == 0) 106f46: 83 3d 5c e4 12 00 00 cmpl $0x0,0x12e45c 106f4d: 75 14 jne 106f63 { _REENT = _global_impure_ptr; 106f4f: a1 60 04 12 00 mov 0x120460,%eax 106f54: a3 a0 c2 12 00 mov %eax,0x12c2a0 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 106f59: c7 05 5c e4 12 00 a0 movl $0x12c2a0,0x12e45c 106f60: c2 12 00 ptr = (struct _reent *) calloc(1, sizeof(struct _reent)); #else /* It is OK to allocate from the workspace because these * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); 106f63: 83 ec 0c sub $0xc,%esp 106f66: 68 24 04 00 00 push $0x424 106f6b: e8 d4 5b 00 00 call 10cb44 <_Workspace_Allocate> 106f70: 89 c2 mov %eax,%edx #endif if (ptr) { 106f72: 83 c4 10 add $0x10,%esp 106f75: 85 c0 test %eax,%eax 106f77: 0f 84 28 02 00 00 je 1071a5 <== NEVER TAKEN _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 106f7d: c7 00 00 00 00 00 movl $0x0,(%eax) 106f83: 8d 98 ec 02 00 00 lea 0x2ec(%eax),%ebx 106f89: 89 58 04 mov %ebx,0x4(%eax) 106f8c: 8d 80 54 03 00 00 lea 0x354(%eax),%eax 106f92: 89 42 08 mov %eax,0x8(%edx) 106f95: 8d 82 bc 03 00 00 lea 0x3bc(%edx),%eax 106f9b: 89 42 0c mov %eax,0xc(%edx) 106f9e: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 106fa5: 8d 72 14 lea 0x14(%edx),%esi 106fa8: 31 c0 xor %eax,%eax 106faa: 89 f7 mov %esi,%edi 106fac: b9 19 00 00 00 mov $0x19,%ecx 106fb1: f3 aa rep stos %al,%es:(%edi) 106fb3: 89 4d e4 mov %ecx,-0x1c(%ebp) 106fb6: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 106fbd: c7 42 34 df ef 11 00 movl $0x11efdf,0x34(%edx) 106fc4: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) 106fcb: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) 106fd2: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx) 106fd9: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) 106fe0: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) 106fe7: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx) 106fee: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) 106ff5: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) 106ffc: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) 107003: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) 10700a: c6 42 60 00 movb $0x0,0x60(%edx) 10700e: 8d 72 7c lea 0x7c(%edx),%esi 107011: b1 09 mov $0x9,%cl 107013: 89 f7 mov %esi,%edi 107015: 31 c0 xor %eax,%eax 107017: f3 ab rep stos %eax,%es:(%edi) 107019: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx) 107020: 00 00 00 107023: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx) 10702a: 00 00 00 10702d: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx) 107034: 00 00 00 107037: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx) 10703e: 0e 33 107040: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx) 107047: cd ab 107049: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx) 107050: 34 12 107052: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx) 107059: 6d e6 10705b: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx) 107062: ec de 107064: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx) 10706b: 05 00 10706d: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx) 107074: 0b 00 107076: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx) 10707d: 00 00 00 107080: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx) 107087: 00 00 00 10708a: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx) 107091: 00 00 00 107094: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx) 10709b: 00 00 00 10709e: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx) 1070a5: 00 00 00 1070a8: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx) 1070af: 00 00 00 1070b2: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx) 1070b9: 00 00 00 1070bc: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx) 1070c3: 00 00 00 1070c6: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx) 1070cd: 00 00 00 1070d0: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx) 1070d7: 00 00 00 1070da: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx) 1070e1: 00 00 00 1070e4: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx) 1070eb: 00 00 00 1070ee: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx) 1070f5: 00 00 00 1070f8: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx) 1070ff: 00 00 00 107102: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx) 107109: 00 00 00 10710c: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx) 107113: 00 00 00 107116: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx) 10711d: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx) 107124: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx) 10712b: 00 00 00 10712e: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx) 107135: 00 00 00 107138: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx) 10713f: 00 00 00 107142: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx) 107149: 00 00 00 10714c: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx) 107153: 00 00 00 107156: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx) 10715d: 00 00 00 107160: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx) 107167: 00 00 00 10716a: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx) 107171: 00 00 00 107174: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx) 10717b: 00 00 00 10717e: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx) 107185: 00 00 00 107188: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx) 10718f: 00 00 00 107192: b1 4e mov $0x4e,%cl 107194: 89 df mov %ebx,%edi 107196: f3 ab rep stos %eax,%es:(%edi) creating_task->libc_reent = ptr; 107198: 8b 45 0c mov 0xc(%ebp),%eax 10719b: 89 90 e0 00 00 00 mov %edx,0xe0(%eax) return TRUE; 1071a1: b0 01 mov $0x1,%al 1071a3: eb 02 jmp 1071a7 } return FALSE; 1071a5: 31 c0 xor %eax,%eax } 1071a7: 8d 65 f4 lea -0xc(%ebp),%esp 1071aa: 5b pop %ebx 1071ab: 5e pop %esi 1071ac: 5f pop %edi 1071ad: 5d pop %ebp 1071ae: c3 ret =============================================================================== 001071af : void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 1071af: 55 push %ebp 1071b0: 89 e5 mov %esp,%ebp 1071b2: 56 push %esi 1071b3: 53 push %ebx 1071b4: 8b 75 0c mov 0xc(%ebp),%esi /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { ptr = _REENT; 1071b7: 8b 1d a0 c2 12 00 mov 0x12c2a0,%ebx /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 1071bd: 39 75 08 cmp %esi,0x8(%ebp) 1071c0: 74 06 je 1071c8 ptr = _REENT; } else { ptr = deleted_task->libc_reent; 1071c2: 8b 9e e0 00 00 00 mov 0xe0(%esi),%ebx } if (ptr && ptr != _global_impure_ptr) { 1071c8: 85 db test %ebx,%ebx 1071ca: 74 20 je 1071ec <== NEVER TAKEN 1071cc: 3b 1d 60 04 12 00 cmp 0x120460,%ebx 1071d2: 74 18 je 1071ec _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 1071d4: 50 push %eax 1071d5: 50 push %eax 1071d6: 68 ec 6e 10 00 push $0x106eec 1071db: 53 push %ebx 1071dc: e8 4f a4 00 00 call 111630 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 1071e1: 89 1c 24 mov %ebx,(%esp) 1071e4: e8 74 59 00 00 call 10cb5d <_Workspace_Free> 1071e9: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 1071ec: c7 86 e0 00 00 00 00 movl $0x0,0xe0(%esi) 1071f3: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 1071f6: 39 75 08 cmp %esi,0x8(%ebp) 1071f9: 75 0a jne 107205 _REENT = 0; 1071fb: c7 05 a0 c2 12 00 00 movl $0x0,0x12c2a0 107202: 00 00 00 } } 107205: 8d 65 f8 lea -0x8(%ebp),%esp 107208: 5b pop %ebx 107209: 5e pop %esi 10720a: 5d pop %ebp 10720b: c3 ret =============================================================================== 00106eec : */ int newlib_free_buffers( FILE *fp ) { 106eec: 55 push %ebp 106eed: 89 e5 mov %esp,%ebp 106eef: 53 push %ebx 106ef0: 83 ec 10 sub $0x10,%esp 106ef3: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 106ef6: 53 push %ebx 106ef7: e8 84 a3 00 00 call 111280 106efc: 83 c4 10 add $0x10,%esp 106eff: 83 f8 02 cmp $0x2,%eax 106f02: 77 26 ja 106f2a <== NEVER TAKEN case 0: case 1: case 2: if (fp->_flags & __SMBF) { 106f04: f6 43 0c 80 testb $0x80,0xc(%ebx) 106f08: 74 2c je 106f36 <== ALWAYS TAKEN free( fp->_bf._base ); 106f0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f0d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 106f10: e8 1f f8 ff ff call 106734 <== NOT EXECUTED fp->_flags &= ~__SMBF; 106f15: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 106f1b: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 106f21: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 106f28: eb 09 jmp 106f33 <== NOT EXECUTED } break; default: fclose(fp); 106f2a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f2d: 53 push %ebx <== NOT EXECUTED 106f2e: e8 c5 a0 00 00 call 110ff8 <== NOT EXECUTED 106f33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 106f36: 31 c0 xor %eax,%eax 106f38: 8b 5d fc mov -0x4(%ebp),%ebx 106f3b: c9 leave 106f3c: c3 ret =============================================================================== 00109579 : static int null_op_fsmount_me( rtems_filesystem_mount_table_entry_t *mt_entry, const void *data ) { 109579: 55 push %ebp <== NOT EXECUTED 10957a: 89 e5 mov %esp,%ebp <== NOT EXECUTED return -1; } 10957c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10957f: 5d pop %ebp <== NOT EXECUTED 109580: c3 ret <== NOT EXECUTED =============================================================================== 00109589 : static void null_op_fsunmount_me( rtems_filesystem_mount_table_entry_t *mt_entry ) { 109589: 55 push %ebp <== NOT EXECUTED 10958a: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* Do nothing */ } 10958c: 5d pop %ebp <== NOT EXECUTED 10958d: c3 ret <== NOT EXECUTED =============================================================================== 00109551 : const rtems_filesystem_location_info_t *parentloc, const rtems_filesystem_location_info_t *targetloc, const char *name, size_t namelen ) { 109551: 55 push %ebp <== NOT EXECUTED 109552: 89 e5 mov %esp,%ebp <== NOT EXECUTED return -1; } 109554: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109557: 5d pop %ebp <== NOT EXECUTED 109558: c3 ret <== NOT EXECUTED =============================================================================== 00109571 : static int null_op_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 109571: 55 push %ebp <== NOT EXECUTED 109572: 89 e5 mov %esp,%ebp <== NOT EXECUTED return -1; } 109574: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109577: 5d pop %ebp <== NOT EXECUTED 109578: c3 ret <== NOT EXECUTED =============================================================================== 0010959e : static ssize_t null_op_readlink( const rtems_filesystem_location_info_t *loc, char *buf, size_t bufsize ) { 10959e: 55 push %ebp <== NOT EXECUTED 10959f: 89 e5 mov %esp,%ebp <== NOT EXECUTED return -1; } 1095a1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1095a4: 5d pop %ebp <== NOT EXECUTED 1095a5: c3 ret <== NOT EXECUTED =============================================================================== 001095a6 : const rtems_filesystem_location_info_t *oldloc, const rtems_filesystem_location_info_t *newparentloc, const char *name, size_t namelen ) { 1095a6: 55 push %ebp <== NOT EXECUTED 1095a7: 89 e5 mov %esp,%ebp <== NOT EXECUTED return -1; } 1095a9: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1095ac: 5d pop %ebp <== NOT EXECUTED 1095ad: c3 ret <== NOT EXECUTED =============================================================================== 001089d1 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 1089d1: 55 push %ebp 1089d2: 89 e5 mov %esp,%ebp 1089d4: 56 push %esi 1089d5: 53 push %ebx 1089d6: 83 ec 10 sub $0x10,%esp 1089d9: 89 d3 mov %edx,%ebx 1089db: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 1089de: 8b 52 34 mov 0x34(%edx),%edx 1089e1: f6 c2 01 test $0x1,%dl 1089e4: 0f 84 e7 00 00 00 je 108ad1 <== NEVER TAKEN switch (c) { 1089ea: 3c 09 cmp $0x9,%al 1089ec: 74 75 je 108a63 1089ee: 77 0d ja 1089fd <== ALWAYS TAKEN 1089f0: 3c 08 cmp $0x8,%al <== NOT EXECUTED 1089f2: 0f 85 a5 00 00 00 jne 108a9d <== NOT EXECUTED 1089f8: e9 93 00 00 00 jmp 108a90 <== NOT EXECUTED 1089fd: 3c 0a cmp $0xa,%al 1089ff: 74 0a je 108a0b 108a01: 3c 0d cmp $0xd,%al 108a03: 0f 85 94 00 00 00 jne 108a9d <== ALWAYS TAKEN 108a09: eb 32 jmp 108a3d <== NOT EXECUTED case '\n': if (tty->termios.c_oflag & ONLRET) 108a0b: f6 c2 20 test $0x20,%dl 108a0e: 74 07 je 108a17 <== ALWAYS TAKEN tty->column = 0; 108a10: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 108a17: 80 e2 04 and $0x4,%dl 108a1a: 0f 84 b1 00 00 00 je 108ad1 <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 108a20: 51 push %ecx 108a21: 53 push %ebx 108a22: 6a 01 push $0x1 108a24: 68 14 fa 11 00 push $0x11fa14 108a29: e8 97 fe ff ff call 1088c5 tty->column = 0; 108a2e: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 108a35: 83 c4 10 add $0x10,%esp 108a38: e9 94 00 00 00 jmp 108ad1 } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 108a3d: f6 c2 10 test $0x10,%dl <== NOT EXECUTED 108a40: 74 0a je 108a4c <== NOT EXECUTED 108a42: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED 108a46: 0f 84 95 00 00 00 je 108ae1 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 108a4c: f6 c2 08 test $0x8,%dl <== NOT EXECUTED 108a4f: 74 09 je 108a5a <== NOT EXECUTED c = '\n'; 108a51: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 108a55: 80 e2 20 and $0x20,%dl <== NOT EXECUTED 108a58: 74 77 je 108ad1 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 108a5a: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED break; 108a61: eb 6e jmp 108ad1 <== NOT EXECUTED case '\t': i = 8 - (tty->column & 7); 108a63: 8b 4b 28 mov 0x28(%ebx),%ecx 108a66: 89 ce mov %ecx,%esi 108a68: 83 e6 07 and $0x7,%esi 108a6b: b8 08 00 00 00 mov $0x8,%eax 108a70: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 108a72: 81 e2 00 18 00 00 and $0x1800,%edx 108a78: 81 fa 00 18 00 00 cmp $0x1800,%edx 108a7e: 8d 14 01 lea (%ecx,%eax,1),%edx tty->column += i; 108a81: 89 53 28 mov %edx,0x28(%ebx) tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { 108a84: 75 4b jne 108ad1 <== NEVER TAKEN tty->column += i; rtems_termios_puts ( " ", i, tty); 108a86: 52 push %edx 108a87: 53 push %ebx 108a88: 50 push %eax 108a89: 68 74 ee 11 00 push $0x11ee74 108a8e: eb 49 jmp 108ad9 } tty->column += i; break; case '\b': if (tty->column > 0) 108a90: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108a93: 85 c0 test %eax,%eax <== NOT EXECUTED 108a95: 7e 3a jle 108ad1 <== NOT EXECUTED tty->column--; 108a97: 48 dec %eax <== NOT EXECUTED 108a98: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 108a9b: eb 34 jmp 108ad1 <== NOT EXECUTED break; default: if (tty->termios.c_oflag & OLCUC) 108a9d: 80 e2 02 and $0x2,%dl 108aa0: 74 1b je 108abd <== ALWAYS TAKEN c = toupper(c); 108aa2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108aa5: 8b 15 88 c2 12 00 mov 0x12c288,%edx <== NOT EXECUTED 108aab: 8a 54 02 01 mov 0x1(%edx,%eax,1),%dl <== NOT EXECUTED 108aaf: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 108ab2: 80 fa 02 cmp $0x2,%dl <== NOT EXECUTED 108ab5: 75 03 jne 108aba <== NOT EXECUTED 108ab7: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED 108aba: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED if (!iscntrl(c)) 108abd: 0f b6 45 f4 movzbl -0xc(%ebp),%eax 108ac1: 8b 15 88 c2 12 00 mov 0x12c288,%edx 108ac7: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1) 108acc: 75 03 jne 108ad1 <== NEVER TAKEN tty->column++; 108ace: ff 43 28 incl 0x28(%ebx) break; } } rtems_termios_puts (&c, 1, tty); 108ad1: 56 push %esi 108ad2: 53 push %ebx 108ad3: 6a 01 push $0x1 108ad5: 8d 45 f4 lea -0xc(%ebp),%eax 108ad8: 50 push %eax 108ad9: e8 e7 fd ff ff call 1088c5 108ade: 83 c4 10 add $0x10,%esp } 108ae1: 8d 65 f8 lea -0x8(%ebp),%esp 108ae4: 5b pop %ebx 108ae5: 5e pop %esi 108ae6: 5d pop %ebp 108ae7: c3 ret =============================================================================== 00105140 : long pathconf( const char *path, int name ) { 105140: 55 push %ebp 105141: 89 e5 mov %esp,%ebp 105143: 56 push %esi 105144: 53 push %ebx int status; int fd; fd = open( path, O_RDONLY ); 105145: 52 push %edx 105146: 52 push %edx 105147: 6a 00 push $0x0 105149: ff 75 08 pushl 0x8(%ebp) 10514c: e8 1f fe ff ff call 104f70 105151: 89 c3 mov %eax,%ebx if ( fd == -1 ) 105153: 83 c4 10 add $0x10,%esp 105156: 83 f8 ff cmp $0xffffffff,%eax 105159: 74 1a je 105175 <== ALWAYS TAKEN return -1; status = fpathconf( fd, name ); 10515b: 50 push %eax <== NOT EXECUTED 10515c: 50 push %eax <== NOT EXECUTED 10515d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 105160: 53 push %ebx <== NOT EXECUTED 105161: e8 26 43 00 00 call 10948c <== NOT EXECUTED 105166: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) close( fd ); 105168: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10516b: e8 b8 42 00 00 call 109428 <== NOT EXECUTED return status; 105170: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 105173: eb 03 jmp 105178 <== NOT EXECUTED int status; int fd; fd = open( path, O_RDONLY ); if ( fd == -1 ) return -1; 105175: 83 ce ff or $0xffffffff,%esi status = fpathconf( fd, name ); (void) close( fd ); return status; } 105178: 89 f0 mov %esi,%eax 10517a: 8d 65 f8 lea -0x8(%ebp),%esp 10517d: 5b pop %ebx 10517e: 5e pop %esi 10517f: 5d pop %ebp 105180: c3 ret =============================================================================== 0010997c : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10997c: 55 push %ebp 10997d: 89 e5 mov %esp,%ebp 10997f: 53 push %ebx 109980: 8b 45 0c mov 0xc(%ebp),%eax /* * Update call statistics */ MSBUMP(memalign_calls, 1); 109983: ff 05 c0 3b 13 00 incl 0x133bc0 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 109989: 8d 58 ff lea -0x1(%eax),%ebx 10998c: 85 c3 test %eax,%ebx 10998e: 75 0c jne 10999c <== NEVER TAKEN 109990: 83 f8 03 cmp $0x3,%eax 109993: 76 07 jbe 10999c /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 109995: 5b pop %ebx 109996: 5d pop %ebp /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 109997: e9 70 01 00 00 jmp 109b0c } 10999c: b8 16 00 00 00 mov $0x16,%eax 1099a1: 5b pop %ebx 1099a2: 5d pop %ebp 1099a3: c3 ret =============================================================================== 0010e4d4 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10e4d4: 55 push %ebp 10e4d5: 89 e5 mov %esp,%ebp 10e4d7: 8b 55 08 mov 0x8(%ebp),%edx 10e4da: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10e4dd: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10e4e2: 85 d2 test %edx,%edx 10e4e4: 74 1e je 10e504 10e4e6: 83 3a 00 cmpl $0x0,(%edx) 10e4e9: 74 19 je 10e504 return EINVAL; switch ( policy ) { 10e4eb: 83 f9 04 cmp $0x4,%ecx 10e4ee: 77 0f ja 10e4ff 10e4f0: b0 01 mov $0x1,%al 10e4f2: d3 e0 shl %cl,%eax 10e4f4: a8 17 test $0x17,%al 10e4f6: 74 07 je 10e4ff <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10e4f8: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10e4fb: 31 c0 xor %eax,%eax 10e4fd: eb 05 jmp 10e504 default: return ENOTSUP; 10e4ff: b8 86 00 00 00 mov $0x86,%eax } } 10e504: 5d pop %ebp 10e505: c3 ret =============================================================================== 00109fd8 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 109fd8: 55 push %ebp 109fd9: 89 e5 mov %esp,%ebp 109fdb: 57 push %edi 109fdc: 56 push %esi 109fdd: 53 push %ebx 109fde: 83 ec 1c sub $0x1c,%esp 109fe1: 8b 75 08 mov 0x8(%ebp),%esi 109fe4: 8b 5d 10 mov 0x10(%ebp),%ebx const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 109fe7: 85 f6 test %esi,%esi 109fe9: 75 05 jne 109ff0 109feb: e9 9a 00 00 00 jmp 10a08a return EINVAL; if ( count == 0 ) 109ff0: 85 db test %ebx,%ebx 109ff2: 0f 84 92 00 00 00 je 10a08a <== NEVER TAKEN return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 109ff8: 8b 45 0c mov 0xc(%ebp),%eax 109ffb: 85 c0 test %eax,%eax 109ffd: 75 11 jne 10a010 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 109fff: 83 ec 0c sub $0xc,%esp 10a002: 8d 7d e0 lea -0x20(%ebp),%edi 10a005: 57 push %edi 10a006: e8 19 ff ff ff call 109f24 10a00b: 83 c4 10 add $0x10,%esp the_attr = &my_attr; 10a00e: 89 f8 mov %edi,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a010: 83 38 00 cmpl $0x0,(%eax) 10a013: 74 75 je 10a08a return EINVAL; switch ( the_attr->process_shared ) { 10a015: 83 78 04 00 cmpl $0x0,0x4(%eax) 10a019: 75 6f jne 10a08a <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a01b: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) the_attributes.maximum_count = count; 10a022: 89 5d dc mov %ebx,-0x24(%ebp) * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10a025: a1 dc f3 12 00 mov 0x12f3dc,%eax 10a02a: 40 inc %eax 10a02b: a3 dc f3 12 00 mov %eax,0x12f3dc return _Thread_Dispatch_disable_level; 10a030: a1 dc f3 12 00 mov 0x12f3dc,%eax * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) 10a035: 83 ec 0c sub $0xc,%esp 10a038: 68 60 f7 12 00 push $0x12f760 10a03d: e8 ae 1c 00 00 call 10bcf0 <_Objects_Allocate> 10a042: 89 c3 mov %eax,%ebx */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a044: 83 c4 10 add $0x10,%esp 10a047: 85 c0 test %eax,%eax 10a049: 75 0c jne 10a057 _Thread_Enable_dispatch(); 10a04b: e8 e0 2b 00 00 call 10cc30 <_Thread_Enable_dispatch> return EAGAIN; 10a050: b8 0b 00 00 00 mov $0xb,%eax 10a055: eb 38 jmp 10a08f } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a057: 50 push %eax 10a058: 50 push %eax 10a059: 8d 45 d8 lea -0x28(%ebp),%eax 10a05c: 50 push %eax 10a05d: 8d 43 10 lea 0x10(%ebx),%eax 10a060: 50 push %eax 10a061: e8 56 14 00 00 call 10b4bc <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a066: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a069: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a06c: 8b 15 7c f7 12 00 mov 0x12f77c,%edx 10a072: 89 1c 8a mov %ebx,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a075: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10a07c: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10a07e: e8 ad 2b 00 00 call 10cc30 <_Thread_Enable_dispatch> 10a083: 83 c4 10 add $0x10,%esp return 0; 10a086: 31 c0 xor %eax,%eax 10a088: eb 05 jmp 10a08f switch ( the_attr->process_shared ) { case PTHREAD_PROCESS_PRIVATE: /* only supported values */ break; case PTHREAD_PROCESS_SHARED: default: return EINVAL; 10a08a: b8 16 00 00 00 mov $0x16,%eax * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; } 10a08f: 8d 65 f4 lea -0xc(%ebp),%esp 10a092: 5b pop %ebx 10a093: 5e pop %esi 10a094: 5f pop %edi 10a095: 5d pop %ebp 10a096: c3 ret =============================================================================== 001099a4 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 1099a4: 55 push %ebp 1099a5: 89 e5 mov %esp,%ebp 1099a7: 56 push %esi 1099a8: 53 push %ebx 1099a9: 8b 5d 08 mov 0x8(%ebp),%ebx 1099ac: 8b 75 0c mov 0xc(%ebp),%esi /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 1099af: 85 db test %ebx,%ebx 1099b1: 74 50 je 109a03 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 1099b3: a1 d4 f3 12 00 mov 0x12f3d4,%eax 1099b8: 40 inc %eax 1099b9: a3 d4 f3 12 00 mov %eax,0x12f3d4 return _Thread_Dispatch_disable_level; 1099be: a1 d4 f3 12 00 mov 0x12f3d4,%eax return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 1099c3: 83 ec 0c sub $0xc,%esp 1099c6: 6a 10 push $0x10 1099c8: e8 6b 3a 00 00 call 10d438 <_Workspace_Allocate> if ( handler ) { 1099cd: 83 c4 10 add $0x10,%esp 1099d0: 85 c0 test %eax,%eax 1099d2: 74 24 je 1099f8 <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 1099d4: 8b 15 dc f8 12 00 mov 0x12f8dc,%edx handler_stack = &thread_support->Cancellation_Handlers; 1099da: 8b 92 e8 00 00 00 mov 0xe8(%edx),%edx 1099e0: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 1099e6: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 1099e9: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 1099ec: 51 push %ecx 1099ed: 51 push %ecx 1099ee: 50 push %eax 1099ef: 52 push %edx 1099f0: e8 57 15 00 00 call 10af4c <_Chain_Append> 1099f5: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 1099f8: 8d 65 f8 lea -0x8(%ebp),%esp 1099fb: 5b pop %ebx 1099fc: 5e pop %esi 1099fd: 5d pop %ebp handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 1099fe: e9 89 2c 00 00 jmp 10c68c <_Thread_Enable_dispatch> } 109a03: 8d 65 f8 lea -0x8(%ebp),%esp 109a06: 5b pop %ebx 109a07: 5e pop %esi 109a08: 5d pop %ebp 109a09: c3 ret =============================================================================== 0010a7c4 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10a7c4: 55 push %ebp 10a7c5: 89 e5 mov %esp,%ebp 10a7c7: 56 push %esi 10a7c8: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10a7c9: 8b 75 0c mov 0xc(%ebp),%esi 10a7cc: 85 f6 test %esi,%esi 10a7ce: 75 05 jne 10a7d5 else the_attr = &_POSIX_Condition_variables_Default_attributes; 10a7d0: be f0 1d 12 00 mov $0x121df0,%esi /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10a7d5: b8 16 00 00 00 mov $0x16,%eax else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10a7da: 83 7e 04 01 cmpl $0x1,0x4(%esi) 10a7de: 74 7b je 10a85b <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10a7e0: 83 3e 00 cmpl $0x0,(%esi) 10a7e3: 74 76 je 10a85b * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10a7e5: a1 e4 03 13 00 mov 0x1303e4,%eax 10a7ea: 40 inc %eax 10a7eb: a3 e4 03 13 00 mov %eax,0x1303e4 return _Thread_Dispatch_disable_level; 10a7f0: a1 e4 03 13 00 mov 0x1303e4,%eax */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 10a7f5: 83 ec 0c sub $0xc,%esp 10a7f8: 68 00 08 13 00 push $0x130800 10a7fd: e8 6e 22 00 00 call 10ca70 <_Objects_Allocate> 10a802: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10a804: 83 c4 10 add $0x10,%esp 10a807: 85 c0 test %eax,%eax 10a809: 75 0c jne 10a817 _Thread_Enable_dispatch(); 10a80b: e8 a0 31 00 00 call 10d9b0 <_Thread_Enable_dispatch> return ENOMEM; 10a810: b8 0c 00 00 00 mov $0xc,%eax 10a815: eb 44 jmp 10a85b } the_cond->process_shared = the_attr->process_shared; 10a817: 8b 46 04 mov 0x4(%esi),%eax 10a81a: 89 43 10 mov %eax,0x10(%ebx) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10a81d: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) _Thread_queue_Initialize( 10a824: 6a 74 push $0x74 10a826: 68 00 08 00 10 push $0x10000800 10a82b: 6a 00 push $0x0 10a82d: 8d 43 18 lea 0x18(%ebx),%eax 10a830: 50 push %eax 10a831: e8 26 38 00 00 call 10e05c <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a836: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a839: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a83c: 8b 15 1c 08 13 00 mov 0x13081c,%edx 10a842: 89 1c 8a mov %ebx,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a845: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10a84c: 8b 55 08 mov 0x8(%ebp),%edx 10a84f: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10a851: e8 5a 31 00 00 call 10d9b0 <_Thread_Enable_dispatch> return 0; 10a856: 83 c4 10 add $0x10,%esp 10a859: 31 c0 xor %eax,%eax } 10a85b: 8d 65 f8 lea -0x8(%ebp),%esp 10a85e: 5b pop %ebx 10a85f: 5e pop %esi 10a860: 5d pop %ebp 10a861: c3 ret =============================================================================== 0010a66c : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10a66c: 55 push %ebp 10a66d: 89 e5 mov %esp,%ebp 10a66f: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10a672: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10a677: 85 d2 test %edx,%edx 10a679: 74 0d je 10a688 10a67b: 83 3a 00 cmpl $0x0,(%edx) 10a67e: 74 08 je 10a688 <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10a680: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10a686: 30 c0 xor %al,%al } 10a688: 5d pop %ebp 10a689: c3 ret =============================================================================== 00109cf0 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 109cf0: 55 push %ebp 109cf1: 89 e5 mov %esp,%ebp 109cf3: 57 push %edi 109cf4: 56 push %esi 109cf5: 53 push %ebx 109cf6: 83 ec 4c sub $0x4c,%esp int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 109cf9: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 109cfd: 0f 84 f8 01 00 00 je 109efb return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 109d03: 8b 55 0c mov 0xc(%ebp),%edx 109d06: 85 d2 test %edx,%edx 109d08: 75 05 jne 109d0f 109d0a: ba 60 09 12 00 mov $0x120960,%edx if ( !the_attr->is_initialized ) 109d0f: 83 3a 00 cmpl $0x0,(%edx) 109d12: 75 05 jne 109d19 109d14: e9 eb 01 00 00 jmp 109f04 * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 109d19: 83 7a 04 00 cmpl $0x0,0x4(%edx) 109d1d: 74 0e je 109d2d 109d1f: a1 8c b1 12 00 mov 0x12b18c,%eax 109d24: 39 42 08 cmp %eax,0x8(%edx) 109d27: 0f 82 d7 01 00 00 jb 109f04 * If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 109d2d: 8b 42 10 mov 0x10(%edx),%eax 109d30: 83 f8 01 cmp $0x1,%eax 109d33: 74 0b je 109d40 109d35: 83 f8 02 cmp $0x2,%eax 109d38: 0f 85 c6 01 00 00 jne 109f04 109d3e: eb 1f jmp 109d5f case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109d40: a1 dc f8 12 00 mov 0x12f8dc,%eax 109d45: 8b b0 e8 00 00 00 mov 0xe8(%eax),%esi schedpolicy = api->schedpolicy; 109d4b: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 109d51: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 109d54: 8d 7d cc lea -0x34(%ebp),%edi 109d57: 81 c6 88 00 00 00 add $0x88,%esi 109d5d: eb 0c jmp 109d6b break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 109d5f: 8b 42 14 mov 0x14(%edx),%eax 109d62: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 109d65: 8d 7d cc lea -0x34(%ebp),%edi 109d68: 8d 72 18 lea 0x18(%edx),%esi 109d6b: b9 07 00 00 00 mov $0x7,%ecx 109d70: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) return ENOTSUP; 109d72: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 109d79: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 109d7d: 0f 85 88 01 00 00 jne 109f0b return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 109d83: 83 ec 0c sub $0xc,%esp 109d86: ff 75 cc pushl -0x34(%ebp) 109d89: 89 55 a8 mov %edx,-0x58(%ebp) 109d8c: e8 5b 54 00 00 call 10f1ec <_POSIX_Priority_Is_valid> 109d91: 83 c4 10 add $0x10,%esp 109d94: 84 c0 test %al,%al 109d96: 0f 84 68 01 00 00 je 109f04 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 109d9c: 8b 5d cc mov -0x34(%ebp),%ebx RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 109d9f: 0f b6 35 88 b1 12 00 movzbl 0x12b188,%esi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 109da6: 8d 45 c8 lea -0x38(%ebp),%eax 109da9: 50 push %eax 109daa: 8d 45 c4 lea -0x3c(%ebp),%eax 109dad: 50 push %eax 109dae: 8d 45 cc lea -0x34(%ebp),%eax 109db1: 50 push %eax 109db2: ff 75 ac pushl -0x54(%ebp) 109db5: e8 52 54 00 00 call 10f20c <_POSIX_Thread_Translate_sched_param> 109dba: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 109dbd: 83 c4 10 add $0x10,%esp 109dc0: 85 c0 test %eax,%eax 109dc2: 0f 85 43 01 00 00 jne 109f0b #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 109dc8: 83 ec 0c sub $0xc,%esp 109dcb: ff 35 60 f4 12 00 pushl 0x12f460 109dd1: e8 66 15 00 00 call 10b33c <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 109dd6: c7 04 24 d8 f5 12 00 movl $0x12f5d8,(%esp) 109ddd: e8 d6 1d 00 00 call 10bbb8 <_Objects_Allocate> 109de2: 89 45 b0 mov %eax,-0x50(%ebp) * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 109de5: 83 c4 10 add $0x10,%esp 109de8: 85 c0 test %eax,%eax 109dea: 8b 55 a8 mov -0x58(%ebp),%edx 109ded: 75 05 jne 109df4 _RTEMS_Unlock_allocator(); 109def: 83 ec 0c sub $0xc,%esp 109df2: eb 56 jmp 109e4a /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 109df4: 8b 4a 08 mov 0x8(%edx),%ecx 109df7: 57 push %edi 109df8: 6a 00 push $0x0 109dfa: 6a 00 push $0x0 109dfc: ff 75 c8 pushl -0x38(%ebp) 109dff: ff 75 c4 pushl -0x3c(%ebp) 109e02: 6a 01 push $0x1 109e04: 81 e6 ff 00 00 00 and $0xff,%esi 109e0a: 29 de sub %ebx,%esi 109e0c: 56 push %esi 109e0d: 6a 01 push $0x1 109e0f: a1 8c b1 12 00 mov 0x12b18c,%eax 109e14: d1 e0 shl %eax 109e16: 39 c8 cmp %ecx,%eax 109e18: 73 02 jae 109e1c 109e1a: 89 c8 mov %ecx,%eax 109e1c: 50 push %eax 109e1d: ff 72 04 pushl 0x4(%edx) 109e20: ff 75 b0 pushl -0x50(%ebp) 109e23: 68 d8 f5 12 00 push $0x12f5d8 109e28: 89 55 a8 mov %edx,-0x58(%ebp) 109e2b: e8 68 2d 00 00 call 10cb98 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 109e30: 83 c4 30 add $0x30,%esp 109e33: 84 c0 test %al,%al 109e35: 8b 55 a8 mov -0x58(%ebp),%edx 109e38: 75 2a jne 109e64 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 109e3a: 51 push %ecx 109e3b: 51 push %ecx 109e3c: ff 75 b0 pushl -0x50(%ebp) 109e3f: 68 d8 f5 12 00 push $0x12f5d8 109e44: e8 4f 20 00 00 call 10be98 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 109e49: 5b pop %ebx 109e4a: ff 35 60 f4 12 00 pushl 0x12f460 109e50: e8 2f 15 00 00 call 10b384 <_API_Mutex_Unlock> 109e55: 83 c4 10 add $0x10,%esp return EAGAIN; 109e58: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 109e5f: e9 a7 00 00 00 jmp 109f0b } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109e64: 8b 45 b0 mov -0x50(%ebp),%eax 109e67: 8b 98 e8 00 00 00 mov 0xe8(%eax),%ebx api->Attributes = *the_attr; 109e6d: b9 10 00 00 00 mov $0x10,%ecx 109e72: 89 df mov %ebx,%edi 109e74: 89 d6 mov %edx,%esi 109e76: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 109e78: 8b 42 3c mov 0x3c(%edx),%eax 109e7b: 89 43 40 mov %eax,0x40(%ebx) api->schedpolicy = schedpolicy; 109e7e: 8b 45 ac mov -0x54(%ebp),%eax 109e81: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = schedparam; 109e87: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 109e8d: 8d 75 cc lea -0x34(%ebp),%esi 109e90: b1 07 mov $0x7,%cl 109e92: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 109e94: 83 ec 0c sub $0xc,%esp 109e97: 6a 00 push $0x0 109e99: ff 75 14 pushl 0x14(%ebp) 109e9c: ff 75 10 pushl 0x10(%ebp) 109e9f: 6a 01 push $0x1 109ea1: ff 75 b0 pushl -0x50(%ebp) 109ea4: e8 d7 34 00 00 call 10d380 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 109ea9: 83 c4 20 add $0x20,%esp 109eac: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 109eb0: 75 2b jne 109edd _Watchdog_Insert_ticks( 109eb2: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 109eb5: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 109ebb: 50 push %eax 109ebc: e8 3f 35 00 00 call 10d400 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 109ec1: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 109ec7: 58 pop %eax 109ec8: 5a pop %edx 109ec9: 81 c3 a8 00 00 00 add $0xa8,%ebx 109ecf: 53 push %ebx 109ed0: 68 78 f4 12 00 push $0x12f478 109ed5: e8 b2 37 00 00 call 10d68c <_Watchdog_Insert> 109eda: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 109edd: 8b 45 b0 mov -0x50(%ebp),%eax 109ee0: 8b 50 08 mov 0x8(%eax),%edx 109ee3: 8b 45 08 mov 0x8(%ebp),%eax 109ee6: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 109ee8: 83 ec 0c sub $0xc,%esp 109eeb: ff 35 60 f4 12 00 pushl 0x12f460 109ef1: e8 8e 14 00 00 call 10b384 <_API_Mutex_Unlock> 109ef6: 83 c4 10 add $0x10,%esp 109ef9: eb 10 jmp 109f0b struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 109efb: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp) 109f02: eb 07 jmp 109f0b schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 109f04: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 109f0b: 8b 45 b4 mov -0x4c(%ebp),%eax 109f0e: 8d 65 f4 lea -0xc(%ebp),%esp 109f11: 5b pop %ebx 109f12: 5e pop %esi 109f13: 5f pop %edi 109f14: 5d pop %ebp 109f15: c3 ret =============================================================================== 001109fe : } void pthread_exit( void *value_ptr ) { 1109fe: 55 push %ebp 1109ff: 89 e5 mov %esp,%ebp 110a01: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110a04: ff 75 08 pushl 0x8(%ebp) 110a07: ff 35 ec e8 12 00 pushl 0x12e8ec 110a0d: e8 0a ff ff ff call 11091c <_POSIX_Thread_Exit> 110a12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110a15: c9 leave <== NOT EXECUTED 110a16: c3 ret <== NOT EXECUTED =============================================================================== 0011dcf0 : int pthread_kill( pthread_t thread, int sig ) { 11dcf0: 55 push %ebp 11dcf1: 89 e5 mov %esp,%ebp 11dcf3: 57 push %edi 11dcf4: 56 push %esi 11dcf5: 53 push %ebx 11dcf6: 83 ec 1c sub $0x1c,%esp 11dcf9: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 11dcfc: 85 db test %ebx,%ebx 11dcfe: 75 02 jne 11dd02 11dd00: eb 08 jmp 11dd0a static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 11dd02: 8d 7b ff lea -0x1(%ebx),%edi rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 11dd05: 83 ff 1f cmp $0x1f,%edi 11dd08: 76 0d jbe 11dd17 rtems_set_errno_and_return_minus_one( EINVAL ); 11dd0a: e8 cd 31 ff ff call 110edc <__errno> 11dd0f: c7 00 16 00 00 00 movl $0x16,(%eax) 11dd15: eb 75 jmp 11dd8c the_thread = _Thread_Get( thread, &location ); 11dd17: 52 push %edx 11dd18: 52 push %edx 11dd19: 8d 45 e4 lea -0x1c(%ebp),%eax 11dd1c: 50 push %eax 11dd1d: ff 75 08 pushl 0x8(%ebp) 11dd20: e8 07 e1 fe ff call 10be2c <_Thread_Get> 11dd25: 89 c6 mov %eax,%esi switch ( location ) { 11dd27: 83 c4 10 add $0x10,%esp 11dd2a: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 11dd2e: 75 51 jne 11dd81 <== NEVER TAKEN case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11dd30: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 11dd36: 6b c3 0c imul $0xc,%ebx,%eax 11dd39: 83 b8 30 e9 12 00 01 cmpl $0x1,0x12e930(%eax) 11dd40: 75 09 jne 11dd4b _Thread_Enable_dispatch(); 11dd42: e8 c5 e0 fe ff call 10be0c <_Thread_Enable_dispatch> return 0; 11dd47: 31 c0 xor %eax,%eax 11dd49: eb 44 jmp 11dd8f static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 11dd4b: b8 01 00 00 00 mov $0x1,%eax 11dd50: 89 f9 mov %edi,%ecx 11dd52: d3 e0 shl %cl,%eax } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 11dd54: 09 82 d4 00 00 00 or %eax,0xd4(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 11dd5a: 50 push %eax 11dd5b: 6a 00 push $0x0 11dd5d: 53 push %ebx 11dd5e: 56 push %esi 11dd5f: e8 8c fe ff ff call 11dbf0 <_POSIX_signals_Unblock_thread> if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11dd64: 83 c4 10 add $0x10,%esp 11dd67: 83 3d e8 e8 12 00 00 cmpl $0x0,0x12e8e8 11dd6e: 74 d2 je 11dd42 11dd70: 3b 35 ec e8 12 00 cmp 0x12e8ec,%esi 11dd76: 75 ca jne 11dd42 _Thread_Dispatch_necessary = true; 11dd78: c6 05 f8 e8 12 00 01 movb $0x1,0x12e8f8 11dd7f: eb c1 jmp 11dd42 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 11dd81: e8 56 31 ff ff call 110edc <__errno> <== NOT EXECUTED 11dd86: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 11dd8c: 83 c8 ff or $0xffffffff,%eax } 11dd8f: 8d 65 f4 lea -0xc(%ebp),%esp 11dd92: 5b pop %ebx 11dd93: 5e pop %esi 11dd94: 5f pop %edi 11dd95: 5d pop %ebp 11dd96: c3 ret =============================================================================== 0010ba38 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10ba38: 55 push %ebp 10ba39: 89 e5 mov %esp,%ebp 10ba3b: 53 push %ebx 10ba3c: 83 ec 2c sub $0x2c,%esp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10ba3f: 8d 45 f4 lea -0xc(%ebp),%eax 10ba42: 50 push %eax 10ba43: ff 75 0c pushl 0xc(%ebp) 10ba46: e8 b5 00 00 00 call 10bb00 <_POSIX_Absolute_timeout_to_ticks> 10ba4b: 89 c3 mov %eax,%ebx if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10ba4d: 83 c4 0c add $0xc,%esp 10ba50: 83 f8 03 cmp $0x3,%eax 10ba53: 0f 94 c1 sete %cl do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10ba56: ff 75 f4 pushl -0xc(%ebp) 10ba59: 0f b6 c1 movzbl %cl,%eax 10ba5c: 50 push %eax 10ba5d: ff 75 08 pushl 0x8(%ebp) 10ba60: 88 4d e4 mov %cl,-0x1c(%ebp) 10ba63: e8 e8 fe ff ff call 10b950 <_POSIX_Mutex_Lock_support> * This service only gives us the option to block. We used a polling * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 10ba68: 83 c4 10 add $0x10,%esp 10ba6b: 8a 4d e4 mov -0x1c(%ebp),%cl 10ba6e: 84 c9 test %cl,%cl 10ba70: 75 17 jne 10ba89 10ba72: 83 f8 10 cmp $0x10,%eax 10ba75: 75 12 jne 10ba89 if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10ba77: b0 16 mov $0x16,%al * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10ba79: 85 db test %ebx,%ebx 10ba7b: 74 0c je 10ba89 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10ba7d: 4b dec %ebx status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10ba7e: 83 fb 02 cmp $0x2,%ebx 10ba81: 19 c0 sbb %eax,%eax 10ba83: 83 e0 64 and $0x64,%eax 10ba86: 83 c0 10 add $0x10,%eax } return lock_status; } 10ba89: 8b 5d fc mov -0x4(%ebp),%ebx 10ba8c: c9 leave 10ba8d: c3 ret =============================================================================== 0010b6a4 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10b6a4: 55 push %ebp 10b6a5: 89 e5 mov %esp,%ebp 10b6a7: 8b 55 08 mov 0x8(%ebp),%edx 10b6aa: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10b6ad: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10b6b2: 85 d2 test %edx,%edx 10b6b4: 74 0f je 10b6c5 10b6b6: 83 3a 00 cmpl $0x0,(%edx) 10b6b9: 74 0a je 10b6c5 return EINVAL; switch ( pshared ) { 10b6bb: 83 f9 01 cmp $0x1,%ecx 10b6be: 77 05 ja 10b6c5 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10b6c0: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10b6c3: 30 c0 xor %al,%al default: return EINVAL; } } 10b6c5: 5d pop %ebp 10b6c6: c3 ret =============================================================================== 00109870 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109870: 55 push %ebp 109871: 89 e5 mov %esp,%ebp 109873: 8b 55 08 mov 0x8(%ebp),%edx 109876: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109879: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 10987e: 85 d2 test %edx,%edx 109880: 74 0f je 109891 109882: 83 3a 00 cmpl $0x0,(%edx) 109885: 74 0a je 109891 <== NEVER TAKEN return EINVAL; switch ( type ) { 109887: 83 f9 03 cmp $0x3,%ecx 10988a: 77 05 ja 109891 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 10988c: 89 4a 10 mov %ecx,0x10(%edx) return 0; 10988f: 30 c0 xor %al,%al default: return EINVAL; } } 109891: 5d pop %ebp 109892: c3 ret =============================================================================== 0010a380 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a380: 55 push %ebp 10a381: 89 e5 mov %esp,%ebp 10a383: 56 push %esi 10a384: 53 push %ebx 10a385: 83 ec 10 sub $0x10,%esp 10a388: 8b 5d 08 mov 0x8(%ebp),%ebx 10a38b: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a38e: 85 f6 test %esi,%esi 10a390: 74 51 je 10a3e3 10a392: 85 db test %ebx,%ebx 10a394: 74 4d je 10a3e3 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a396: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a398: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a39c: 75 4a jne 10a3e8 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a39e: 52 push %edx 10a39f: 8d 45 f4 lea -0xc(%ebp),%eax 10a3a2: 50 push %eax 10a3a3: 68 00 01 00 00 push $0x100 10a3a8: 68 00 01 00 00 push $0x100 10a3ad: e8 16 0a 00 00 call 10adc8 if ( !once_control->init_executed ) { 10a3b2: 83 c4 10 add $0x10,%esp 10a3b5: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a3b9: 75 0f jne 10a3ca <== NEVER TAKEN once_control->is_initialized = true; 10a3bb: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a3c1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a3c8: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a3ca: 50 push %eax 10a3cb: 8d 45 f4 lea -0xc(%ebp),%eax 10a3ce: 50 push %eax 10a3cf: 68 00 01 00 00 push $0x100 10a3d4: ff 75 f4 pushl -0xc(%ebp) 10a3d7: e8 ec 09 00 00 call 10adc8 10a3dc: 83 c4 10 add $0x10,%esp } return 0; 10a3df: 31 c0 xor %eax,%eax 10a3e1: eb 05 jmp 10a3e8 pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a3e3: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a3e8: 8d 65 f8 lea -0x8(%ebp),%esp 10a3eb: 5b pop %ebx 10a3ec: 5e pop %esi 10a3ed: 5d pop %ebp 10a3ee: c3 ret =============================================================================== 0010a220 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10a220: 55 push %ebp 10a221: 89 e5 mov %esp,%ebp 10a223: 56 push %esi 10a224: 53 push %ebx 10a225: 83 ec 10 sub $0x10,%esp 10a228: 8b 75 08 mov 0x8(%ebp),%esi const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10a22b: 85 f6 test %esi,%esi 10a22d: 75 05 jne 10a234 10a22f: e9 8f 00 00 00 jmp 10a2c3 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a234: 8b 45 0c mov 0xc(%ebp),%eax 10a237: 85 c0 test %eax,%eax 10a239: 75 11 jne 10a24c the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10a23b: 83 ec 0c sub $0xc,%esp 10a23e: 8d 5d f0 lea -0x10(%ebp),%ebx 10a241: 53 push %ebx 10a242: e8 a1 06 00 00 call 10a8e8 10a247: 83 c4 10 add $0x10,%esp the_attr = &default_attr; 10a24a: 89 d8 mov %ebx,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a24c: 83 38 00 cmpl $0x0,(%eax) 10a24f: 74 72 je 10a2c3 <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10a251: 83 78 04 00 cmpl $0x0,0x4(%eax) 10a255: 75 6c jne 10a2c3 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10a257: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10a25e: a1 b4 31 13 00 mov 0x1331b4,%eax 10a263: 40 inc %eax 10a264: a3 b4 31 13 00 mov %eax,0x1331b4 return _Thread_Dispatch_disable_level; 10a269: a1 b4 31 13 00 mov 0x1331b4,%eax * This function allocates a RWLock control block from * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) 10a26e: 83 ec 0c sub $0xc,%esp 10a271: 68 b8 33 13 00 push $0x1333b8 10a276: e8 3d 24 00 00 call 10c6b8 <_Objects_Allocate> 10a27b: 89 c3 mov %eax,%ebx */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10a27d: 83 c4 10 add $0x10,%esp 10a280: 85 c0 test %eax,%eax 10a282: 75 0c jne 10a290 _Thread_Enable_dispatch(); 10a284: e8 33 34 00 00 call 10d6bc <_Thread_Enable_dispatch> return EAGAIN; 10a289: b8 0b 00 00 00 mov $0xb,%eax 10a28e: eb 38 jmp 10a2c8 } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10a290: 50 push %eax 10a291: 50 push %eax 10a292: 8d 45 ec lea -0x14(%ebp),%eax 10a295: 50 push %eax 10a296: 8d 43 10 lea 0x10(%ebx),%eax 10a299: 50 push %eax 10a29a: e8 c1 1e 00 00 call 10c160 <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a29f: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a2a2: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a2a5: 8b 15 d4 33 13 00 mov 0x1333d4,%edx 10a2ab: 89 1c 8a mov %ebx,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a2ae: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10a2b5: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10a2b7: e8 00 34 00 00 call 10d6bc <_Thread_Enable_dispatch> 10a2bc: 83 c4 10 add $0x10,%esp return 0; 10a2bf: 31 c0 xor %eax,%eax 10a2c1: eb 05 jmp 10a2c8 switch ( the_attr->process_shared ) { case PTHREAD_PROCESS_PRIVATE: /* only supported values */ break; case PTHREAD_PROCESS_SHARED: default: return EINVAL; 10a2c3: b8 16 00 00 00 mov $0x16,%eax *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; } 10a2c8: 8d 65 f8 lea -0x8(%ebp),%esp 10a2cb: 5b pop %ebx 10a2cc: 5e pop %esi 10a2cd: 5d pop %ebp 10a2ce: c3 ret =============================================================================== 0010ac10 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10ac10: 55 push %ebp 10ac11: 89 e5 mov %esp,%ebp 10ac13: 56 push %esi 10ac14: 53 push %ebx 10ac15: 83 ec 20 sub $0x20,%esp 10ac18: 8b 75 08 mov 0x8(%ebp),%esi Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10ac1b: 85 f6 test %esi,%esi 10ac1d: 75 05 jne 10ac24 10ac1f: e9 8a 00 00 00 jmp 10acae * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10ac24: 50 push %eax 10ac25: 50 push %eax 10ac26: 8d 45 f4 lea -0xc(%ebp),%eax 10ac29: 50 push %eax 10ac2a: ff 75 0c pushl 0xc(%ebp) 10ac2d: e8 ce 56 00 00 call 110300 <_POSIX_Absolute_timeout_to_ticks> 10ac32: 89 c3 mov %eax,%ebx 10ac34: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10ac37: 8d 45 f0 lea -0x10(%ebp),%eax 10ac3a: 50 push %eax 10ac3b: ff 36 pushl (%esi) 10ac3d: 68 a0 15 13 00 push $0x1315a0 10ac42: e8 59 25 00 00 call 10d1a0 <_Objects_Get> switch ( location ) { 10ac47: 83 c4 10 add $0x10,%esp 10ac4a: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10ac4e: 75 5e jne 10acae * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10ac50: 83 fb 03 cmp $0x3,%ebx 10ac53: 0f 94 c2 sete %dl the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10ac56: 83 ec 0c sub $0xc,%esp 10ac59: 6a 00 push $0x0 10ac5b: ff 75 f4 pushl -0xc(%ebp) 10ac5e: 0f b6 ca movzbl %dl,%ecx 10ac61: 51 push %ecx 10ac62: ff 36 pushl (%esi) 10ac64: 83 c0 10 add $0x10,%eax 10ac67: 50 push %eax 10ac68: 88 55 e4 mov %dl,-0x1c(%ebp) 10ac6b: e8 d0 19 00 00 call 10c640 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10ac70: 83 c4 20 add $0x20,%esp 10ac73: e8 5c 30 00 00 call 10dcd4 <_Thread_Enable_dispatch> if ( !do_wait ) { 10ac78: 8a 55 e4 mov -0x1c(%ebp),%dl 10ac7b: 84 d2 test %dl,%dl 10ac7d: 75 1a jne 10ac99 if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10ac7f: a1 e4 18 13 00 mov 0x1318e4,%eax 10ac84: 83 78 34 02 cmpl $0x2,0x34(%eax) 10ac88: 75 0f jne 10ac99 if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10ac8a: 85 db test %ebx,%ebx 10ac8c: 74 20 je 10acae <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10ac8e: 4b dec %ebx status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10ac8f: b8 74 00 00 00 mov $0x74,%eax _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10ac94: 83 fb 01 cmp $0x1,%ebx 10ac97: 76 1a jbe 10acb3 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ac99: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10ac9c: a1 e4 18 13 00 mov 0x1318e4,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10aca1: ff 70 34 pushl 0x34(%eax) 10aca4: e8 bf 00 00 00 call 10ad68 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10aca9: 83 c4 10 add $0x10,%esp 10acac: eb 05 jmp 10acb3 #endif case OBJECTS_ERROR: break; } return EINVAL; 10acae: b8 16 00 00 00 mov $0x16,%eax } 10acb3: 8d 65 f8 lea -0x8(%ebp),%esp 10acb6: 5b pop %ebx 10acb7: 5e pop %esi 10acb8: 5d pop %ebp 10acb9: c3 ret =============================================================================== 0010acbc : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10acbc: 55 push %ebp 10acbd: 89 e5 mov %esp,%ebp 10acbf: 56 push %esi 10acc0: 53 push %ebx 10acc1: 83 ec 20 sub $0x20,%esp 10acc4: 8b 75 08 mov 0x8(%ebp),%esi Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10acc7: 85 f6 test %esi,%esi 10acc9: 75 05 jne 10acd0 10accb: e9 8a 00 00 00 jmp 10ad5a * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10acd0: 50 push %eax 10acd1: 50 push %eax 10acd2: 8d 45 f4 lea -0xc(%ebp),%eax 10acd5: 50 push %eax 10acd6: ff 75 0c pushl 0xc(%ebp) 10acd9: e8 22 56 00 00 call 110300 <_POSIX_Absolute_timeout_to_ticks> 10acde: 89 c3 mov %eax,%ebx 10ace0: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10ace3: 8d 45 f0 lea -0x10(%ebp),%eax 10ace6: 50 push %eax 10ace7: ff 36 pushl (%esi) 10ace9: 68 a0 15 13 00 push $0x1315a0 10acee: e8 ad 24 00 00 call 10d1a0 <_Objects_Get> switch ( location ) { 10acf3: 83 c4 10 add $0x10,%esp 10acf6: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10acfa: 75 5e jne 10ad5a * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10acfc: 83 fb 03 cmp $0x3,%ebx 10acff: 0f 94 c2 sete %dl the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10ad02: 83 ec 0c sub $0xc,%esp 10ad05: 6a 00 push $0x0 10ad07: ff 75 f4 pushl -0xc(%ebp) 10ad0a: 0f b6 ca movzbl %dl,%ecx 10ad0d: 51 push %ecx 10ad0e: ff 36 pushl (%esi) 10ad10: 83 c0 10 add $0x10,%eax 10ad13: 50 push %eax 10ad14: 88 55 e4 mov %dl,-0x1c(%ebp) 10ad17: e8 d4 19 00 00 call 10c6f0 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10ad1c: 83 c4 20 add $0x20,%esp 10ad1f: e8 b0 2f 00 00 call 10dcd4 <_Thread_Enable_dispatch> if ( !do_wait && 10ad24: 8a 55 e4 mov -0x1c(%ebp),%dl 10ad27: 84 d2 test %dl,%dl 10ad29: 75 1a jne 10ad45 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10ad2b: a1 e4 18 13 00 mov 0x1318e4,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10ad30: 83 78 34 02 cmpl $0x2,0x34(%eax) 10ad34: 75 0f jne 10ad45 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10ad36: 85 db test %ebx,%ebx 10ad38: 74 20 je 10ad5a <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10ad3a: 4b dec %ebx status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10ad3b: b8 74 00 00 00 mov $0x74,%eax _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10ad40: 83 fb 01 cmp $0x1,%ebx 10ad43: 76 1a jbe 10ad5f <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ad45: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10ad48: a1 e4 18 13 00 mov 0x1318e4,%eax if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ad4d: ff 70 34 pushl 0x34(%eax) 10ad50: e8 13 00 00 00 call 10ad68 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10ad55: 83 c4 10 add $0x10,%esp 10ad58: eb 05 jmp 10ad5f #endif case OBJECTS_ERROR: break; } return EINVAL; 10ad5a: b8 16 00 00 00 mov $0x16,%eax } 10ad5f: 8d 65 f8 lea -0x8(%ebp),%esp 10ad62: 5b pop %ebx 10ad63: 5e pop %esi 10ad64: 5d pop %ebp 10ad65: c3 ret =============================================================================== 0010b4b8 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10b4b8: 55 push %ebp 10b4b9: 89 e5 mov %esp,%ebp 10b4bb: 8b 55 08 mov 0x8(%ebp),%edx 10b4be: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10b4c1: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10b4c6: 85 d2 test %edx,%edx 10b4c8: 74 0f je 10b4d9 return EINVAL; if ( !attr->is_initialized ) 10b4ca: 83 3a 00 cmpl $0x0,(%edx) 10b4cd: 74 0a je 10b4d9 return EINVAL; switch ( pshared ) { 10b4cf: 83 f9 01 cmp $0x1,%ecx 10b4d2: 77 05 ja 10b4d9 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10b4d4: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10b4d7: 30 c0 xor %al,%al default: return EINVAL; } } 10b4d9: 5d pop %ebp 10b4da: c3 ret =============================================================================== 0010c2c4 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c2c4: 55 push %ebp 10c2c5: 89 e5 mov %esp,%ebp 10c2c7: 57 push %edi 10c2c8: 56 push %esi 10c2c9: 53 push %ebx 10c2ca: 83 ec 2c sub $0x2c,%esp 10c2cd: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c2d0: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c2d7: 85 f6 test %esi,%esi 10c2d9: 0f 84 f9 00 00 00 je 10c3d8 return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c2df: 8d 45 e0 lea -0x20(%ebp),%eax 10c2e2: 50 push %eax 10c2e3: 8d 45 dc lea -0x24(%ebp),%eax 10c2e6: 50 push %eax 10c2e7: 56 push %esi 10c2e8: ff 75 0c pushl 0xc(%ebp) 10c2eb: e8 8c 4e 00 00 call 11117c <_POSIX_Thread_Translate_sched_param> 10c2f0: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c2f3: 83 c4 10 add $0x10,%esp 10c2f6: 85 c0 test %eax,%eax 10c2f8: 0f 85 da 00 00 00 jne 10c3d8 return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _Thread_Get( thread, &location ); 10c2fe: 53 push %ebx 10c2ff: 53 push %ebx 10c300: 8d 45 e4 lea -0x1c(%ebp),%eax 10c303: 50 push %eax 10c304: ff 75 08 pushl 0x8(%ebp) 10c307: e8 d4 26 00 00 call 10e9e0 <_Thread_Get> 10c30c: 89 c2 mov %eax,%edx switch ( location ) { 10c30e: 83 c4 10 add $0x10,%esp 10c311: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10c315: 0f 85 b6 00 00 00 jne 10c3d1 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c31b: 8b 98 e8 00 00 00 mov 0xe8(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c321: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c328: 75 18 jne 10c342 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c32a: 83 ec 0c sub $0xc,%esp 10c32d: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c333: 50 push %eax 10c334: 89 55 d0 mov %edx,-0x30(%ebp) 10c337: e8 ec 33 00 00 call 10f728 <_Watchdog_Remove> 10c33c: 83 c4 10 add $0x10,%esp 10c33f: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c342: 8b 45 0c mov 0xc(%ebp),%eax 10c345: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c34b: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c351: b9 07 00 00 00 mov $0x7,%ecx 10c356: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c358: 8b 45 dc mov -0x24(%ebp),%eax 10c35b: 89 42 78 mov %eax,0x78(%edx) the_thread->budget_callout = budget_callout; 10c35e: 8b 45 e0 mov -0x20(%ebp),%eax 10c361: 89 42 7c mov %eax,0x7c(%edx) switch ( api->schedpolicy ) { 10c364: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c368: 78 60 js 10c3ca <== NEVER TAKEN 10c36a: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c36e: 7e 08 jle 10c378 10c370: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c374: 75 54 jne 10c3ca <== NEVER TAKEN 10c376: eb 24 jmp 10c39c case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c378: a1 08 34 13 00 mov 0x133408,%eax 10c37d: 89 42 74 mov %eax,0x74(%edx) 10c380: 0f b6 05 88 f1 12 00 movzbl 0x12f188,%eax 10c387: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c38d: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c390: 51 push %ecx 10c391: 6a 01 push $0x1 10c393: 50 push %eax 10c394: 52 push %edx 10c395: e8 36 22 00 00 call 10e5d0 <_Thread_Change_priority> 10c39a: eb 2b jmp 10c3c7 true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c39c: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c3a2: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c3a8: 83 ec 0c sub $0xc,%esp 10c3ab: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c3b1: 53 push %ebx 10c3b2: 89 55 d0 mov %edx,-0x30(%ebp) 10c3b5: e8 6e 33 00 00 call 10f728 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c3ba: 58 pop %eax 10c3bb: 5a pop %edx 10c3bc: 8b 55 d0 mov -0x30(%ebp),%edx 10c3bf: 52 push %edx 10c3c0: 6a 00 push $0x0 10c3c2: e8 ea fd ff ff call 10c1b1 <_POSIX_Threads_Sporadic_budget_TSR> break; 10c3c7: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c3ca: e8 f1 25 00 00 call 10e9c0 <_Thread_Enable_dispatch> 10c3cf: eb 07 jmp 10c3d8 #endif case OBJECTS_ERROR: break; } return ESRCH; 10c3d1: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c3d8: 8b 45 d4 mov -0x2c(%ebp),%eax 10c3db: 8d 65 f4 lea -0xc(%ebp),%esp 10c3de: 5b pop %ebx 10c3df: 5e pop %esi 10c3e0: 5f pop %edi 10c3e1: 5d pop %ebp 10c3e2: c3 ret =============================================================================== 0010a130 : * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a130: 83 3d d8 f8 12 00 00 cmpl $0x0,0x12f8d8 10a137: 75 57 jne 10a190 <== NEVER TAKEN /* * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a139: 55 push %ebp 10a13a: 89 e5 mov %esp,%ebp 10a13c: 53 push %ebx 10a13d: 52 push %edx */ if ( _ISR_Is_in_progress() ) return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a13e: a1 dc f8 12 00 mov 0x12f8dc,%eax 10a143: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10a149: 8b 15 d4 f3 12 00 mov 0x12f3d4,%edx 10a14f: 42 inc %edx 10a150: 89 15 d4 f3 12 00 mov %edx,0x12f3d4 return _Thread_Dispatch_disable_level; 10a156: 8b 15 d4 f3 12 00 mov 0x12f3d4,%edx */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a15c: 31 db xor %ebx,%ebx return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a15e: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a165: 75 0a jne 10a171 <== NEVER TAKEN 10a167: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a16e: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a171: e8 16 25 00 00 call 10c68c <_Thread_Enable_dispatch> if ( cancel ) 10a176: 84 db test %bl,%bl 10a178: 74 12 je 10a18c _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a17a: 50 push %eax 10a17b: 50 push %eax 10a17c: 6a ff push $0xffffffff 10a17e: ff 35 dc f8 12 00 pushl 0x12f8dc 10a184: e8 8f 4d 00 00 call 10ef18 <_POSIX_Thread_Exit> 10a189: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a18c: 8b 5d fc mov -0x4(%ebp),%ebx 10a18f: c9 leave 10a190: c3 ret =============================================================================== 0011d844 : ssize_t read( int fd, void *buffer, size_t count ) { 11d844: 55 push %ebp 11d845: 89 e5 mov %esp,%ebp 11d847: 53 push %ebx 11d848: 53 push %ebx 11d849: 8b 45 08 mov 0x8(%ebp),%eax 11d84c: 8b 55 0c mov 0xc(%ebp),%edx 11d84f: 8b 4d 10 mov 0x10(%ebp),%ecx rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11d852: 3b 05 70 a2 12 00 cmp 0x12a270,%eax 11d858: 72 02 jb 11d85c 11d85a: eb 2d jmp 11d889 iop = rtems_libio_iop( fd ); 11d85c: 6b c0 30 imul $0x30,%eax,%eax 11d85f: 03 05 d0 e2 12 00 add 0x12e2d0,%eax rtems_libio_check_is_open( iop ); 11d865: 8b 58 0c mov 0xc(%eax),%ebx 11d868: f6 c7 01 test $0x1,%bh 11d86b: 75 02 jne 11d86f 11d86d: eb 1a jmp 11d889 rtems_libio_check_buffer( buffer ); 11d86f: 85 d2 test %edx,%edx 11d871: 75 0d jne 11d880 <== ALWAYS TAKEN 11d873: e8 64 36 ff ff call 110edc <__errno> <== NOT EXECUTED 11d878: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11d87e: eb 14 jmp 11d894 <== NOT EXECUTED rtems_libio_check_count( count ); 11d880: 85 c9 test %ecx,%ecx 11d882: 74 29 je 11d8ad rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 11d884: 80 e3 02 and $0x2,%bl 11d887: 75 10 jne 11d899 11d889: e8 4e 36 ff ff call 110edc <__errno> 11d88e: c7 00 09 00 00 00 movl $0x9,(%eax) 11d894: 83 c8 ff or $0xffffffff,%eax 11d897: eb 16 jmp 11d8af /* * Now process the read(). */ return (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11d899: 8b 58 20 mov 0x20(%eax),%ebx 11d89c: 89 4d 10 mov %ecx,0x10(%ebp) 11d89f: 89 55 0c mov %edx,0xc(%ebp) 11d8a2: 89 45 08 mov %eax,0x8(%ebp) 11d8a5: 8b 43 08 mov 0x8(%ebx),%eax } 11d8a8: 59 pop %ecx 11d8a9: 5b pop %ebx 11d8aa: 5d pop %ebp rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); /* * Now process the read(). */ return (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11d8ab: ff e0 jmp *%eax 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 ); 11d8ad: 31 c0 xor %eax,%eax /* * Now process the read(). */ return (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); } 11d8af: 5a pop %edx 11d8b0: 5b pop %ebx 11d8b1: 5d pop %ebp 11d8b2: c3 ret =============================================================================== 00107d9c : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 107d9c: 55 push %ebp 107d9d: 89 e5 mov %esp,%ebp 107d9f: 57 push %edi 107da0: 56 push %esi 107da1: 53 push %ebx 107da2: 83 ec 1c sub $0x1c,%esp 107da5: 8b 75 08 mov 0x8(%ebp),%esi 107da8: 8b 5d 0c mov 0xc(%ebp),%ebx 107dab: 8b 45 10 mov 0x10(%ebp),%eax int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 107dae: 3b 35 70 a2 12 00 cmp 0x12a270,%esi 107db4: 72 02 jb 107db8 107db6: eb 18 jmp 107dd0 iop = rtems_libio_iop( fd ); 107db8: 6b f6 30 imul $0x30,%esi,%esi 107dbb: 03 35 d0 e2 12 00 add 0x12e2d0,%esi rtems_libio_check_is_open( iop ); 107dc1: 8b 56 0c mov 0xc(%esi),%edx 107dc4: f6 c6 01 test $0x1,%dh 107dc7: 75 02 jne 107dcb 107dc9: eb 05 jmp 107dd0 rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 107dcb: 80 e2 02 and $0x2,%dl 107dce: 75 10 jne 107de0 <== ALWAYS TAKEN 107dd0: e8 ff 99 00 00 call 1117d4 <__errno> 107dd5: c7 00 09 00 00 00 movl $0x9,(%eax) 107ddb: e9 8b 00 00 00 jmp 107e6b /* * Argument validation on IO vector */ if ( !iov ) 107de0: 85 db test %ebx,%ebx 107de2: 75 02 jne 107de6 107de4: eb 36 jmp 107e1c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 107de6: 85 c0 test %eax,%eax 107de8: 7f 02 jg 107dec 107dea: eb 30 jmp 107e1c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 107dec: 3d 00 04 00 00 cmp $0x400,%eax 107df1: 7e 02 jle 107df5 <== ALWAYS TAKEN 107df3: eb 27 jmp 107e1c <== NOT EXECUTED #include #include #include ssize_t readv( 107df5: 8d 04 c3 lea (%ebx,%eax,8),%eax 107df8: 89 45 e0 mov %eax,-0x20(%ebp) 107dfb: 89 d8 mov %ebx,%eax 107dfd: c6 45 df 01 movb $0x1,-0x21(%ebp) 107e01: 31 d2 xor %edx,%edx 107e03: eb 03 jmp 107e08 if ( iov[v].iov_base == 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 107e05: 8b 55 e4 mov -0x1c(%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 ) 107e08: 83 38 00 cmpl $0x0,(%eax) 107e0b: 75 02 jne 107e0f 107e0d: eb 0d jmp 107e1c rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 107e0f: 8b 78 04 mov 0x4(%eax),%edi 107e12: 8d 0c 17 lea (%edi,%edx,1),%ecx 107e15: 89 4d e4 mov %ecx,-0x1c(%ebp) if ( total < old ) 107e18: 39 d1 cmp %edx,%ecx 107e1a: 7d 0d jge 107e29 rtems_set_errno_and_return_minus_one( EINVAL ); 107e1c: e8 b3 99 00 00 call 1117d4 <__errno> 107e21: c7 00 16 00 00 00 movl $0x16,(%eax) 107e27: eb 42 jmp 107e6b if ( iov[v].iov_len ) all_zeros = false; 107e29: 85 ff test %edi,%edi 107e2b: 0f 94 c2 sete %dl 107e2e: f7 da neg %edx 107e30: 20 55 df and %dl,-0x21(%ebp) 107e33: 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++ ) { 107e36: 3b 45 e0 cmp -0x20(%ebp),%eax 107e39: 75 ca jne 107e05 * 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; 107e3b: 31 ff xor %edi,%edi /* * 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 ) { 107e3d: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 107e41: 75 2b jne 107e6e /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { bytes = (*iop->pathinfo.handlers->read_h)( 107e43: 50 push %eax 107e44: 8b 46 20 mov 0x20(%esi),%eax 107e47: ff 73 04 pushl 0x4(%ebx) 107e4a: ff 33 pushl (%ebx) 107e4c: 56 push %esi 107e4d: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 107e50: 83 c4 10 add $0x10,%esp 107e53: 83 f8 00 cmp $0x0,%eax 107e56: 7c 13 jl 107e6b <== NEVER TAKEN return -1; if ( bytes > 0 ) { 107e58: 74 02 je 107e5c <== NEVER TAKEN total += bytes; 107e5a: 01 c7 add %eax,%edi } if (bytes != iov[ v ].iov_len) 107e5c: 3b 43 04 cmp 0x4(%ebx),%eax 107e5f: 75 0d jne 107e6e <== NEVER TAKEN 107e61: 83 c3 08 add $0x8,%ebx } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 107e64: 3b 5d e0 cmp -0x20(%ebp),%ebx 107e67: 75 da jne 107e43 107e69: eb 03 jmp 107e6e iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 107e6b: 83 cf ff or $0xffffffff,%edi if (bytes != iov[ v ].iov_len) break; } return total; } 107e6e: 89 f8 mov %edi,%eax 107e70: 8d 65 f4 lea -0xc(%ebp),%esp 107e73: 5b pop %ebx 107e74: 5e pop %esi 107e75: 5f pop %edi 107e76: 5d pop %ebp 107e77: c3 ret =============================================================================== 00107454 : void *realloc( void *ptr, size_t size ) { 107454: 55 push %ebp 107455: 89 e5 mov %esp,%ebp 107457: 57 push %edi 107458: 56 push %esi 107459: 53 push %ebx 10745a: 83 ec 2c sub $0x2c,%esp 10745d: 8b 5d 08 mov 0x8(%ebp),%ebx 107460: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 107463: ff 05 f8 e2 12 00 incl 0x12e2f8 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 107469: 83 3d 20 e5 12 00 03 cmpl $0x3,0x12e520 107470: 75 0f jne 107481 * 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 ) 107472: a1 e4 e3 12 00 mov 0x12e3e4,%eax 107477: 85 c0 test %eax,%eax 107479: 0f 84 a0 00 00 00 je 10751f <== ALWAYS TAKEN 10747f: eb 48 jmp 1074c9 <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 107481: 85 db test %ebx,%ebx 107483: 75 0f jne 107494 return malloc( size ); 107485: 89 75 08 mov %esi,0x8(%ebp) memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 107488: 8d 65 f4 lea -0xc(%ebp),%esp 10748b: 5b pop %ebx 10748c: 5e pop %esi 10748d: 5f pop %edi 10748e: 5d pop %ebp /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 10748f: e9 60 f5 ff ff jmp 1069f4 if ( !size ) { 107494: 85 f6 test %esi,%esi 107496: 75 0e jne 1074a6 <== ALWAYS TAKEN free( ptr ); 107498: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10749b: 53 push %ebx <== NOT EXECUTED 10749c: e8 93 f2 ff ff call 106734 <== NOT EXECUTED 1074a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1074a4: eb 23 jmp 1074c9 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 1074a6: 52 push %edx 1074a7: 8d 45 e4 lea -0x1c(%ebp),%eax 1074aa: 50 push %eax 1074ab: 53 push %ebx 1074ac: ff 35 2c a2 12 00 pushl 0x12a22c 1074b2: e8 89 40 00 00 call 10b540 <_Protected_heap_Get_block_size> 1074b7: 83 c4 10 add $0x10,%esp 1074ba: 84 c0 test %al,%al 1074bc: 75 0f jne 1074cd errno = EINVAL; 1074be: e8 19 9a 00 00 call 110edc <__errno> 1074c3: c7 00 16 00 00 00 movl $0x16,(%eax) return (void *) 0; 1074c9: 31 db xor %ebx,%ebx 1074cb: eb 61 jmp 10752e } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 1074cd: 50 push %eax 1074ce: 56 push %esi 1074cf: 53 push %ebx 1074d0: ff 35 2c a2 12 00 pushl 0x12a22c 1074d6: e8 a9 40 00 00 call 10b584 <_Protected_heap_Resize_block> 1074db: 83 c4 10 add $0x10,%esp 1074de: 84 c0 test %al,%al 1074e0: 75 4c jne 10752e * 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 ); 1074e2: 83 ec 0c sub $0xc,%esp 1074e5: 56 push %esi 1074e6: e8 09 f5 ff ff call 1069f4 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 1074eb: ff 0d ec e2 12 00 decl 0x12e2ec if ( !new_area ) { 1074f1: 83 c4 10 add $0x10,%esp 1074f4: 85 c0 test %eax,%eax 1074f6: 74 d1 je 1074c9 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 1074f8: 8b 55 e4 mov -0x1c(%ebp),%edx 1074fb: 89 f1 mov %esi,%ecx 1074fd: 39 d6 cmp %edx,%esi 1074ff: 76 02 jbe 107503 <== NEVER TAKEN 107501: 89 d1 mov %edx,%ecx 107503: 89 c7 mov %eax,%edi 107505: 89 de mov %ebx,%esi 107507: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 107509: 83 ec 0c sub $0xc,%esp 10750c: 53 push %ebx 10750d: 89 45 d4 mov %eax,-0x2c(%ebp) 107510: e8 1f f2 ff ff call 106734 107515: 83 c4 10 add $0x10,%esp 107518: 8b 45 d4 mov -0x2c(%ebp),%eax 10751b: 89 c3 mov %eax,%ebx 10751d: eb 0f jmp 10752e if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_in_critical_section()) return (void *) 0; if (_ISR_Nest_level > 0) 10751f: 83 3d e8 e8 12 00 00 cmpl $0x0,0x12e8e8 107526: 0f 84 55 ff ff ff je 107481 <== ALWAYS TAKEN 10752c: eb 9b jmp 1074c9 <== NOT EXECUTED memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 10752e: 89 d8 mov %ebx,%eax 107530: 8d 65 f4 lea -0xc(%ebp),%esp 107533: 5b pop %ebx 107534: 5e pop %esi 107535: 5f pop %edi 107536: 5d pop %ebp 107537: c3 ret =============================================================================== 0010a4fa : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10a4fa: 55 push %ebp 10a4fb: 89 e5 mov %esp,%ebp 10a4fd: 57 push %edi 10a4fe: 56 push %esi 10a4ff: 53 push %ebx 10a500: 83 ec 58 sub $0x58,%esp 10a503: 8b 5d 08 mov 0x8(%ebp),%ebx struct sched_param param; /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); 10a506: 68 08 03 13 00 push $0x130308 10a50b: e8 f8 08 00 00 call 10ae08 10a510: 89 c7 mov %eax,%edi if (result != 0) { 10a512: 83 c4 10 add $0x10,%esp 10a515: 85 c0 test %eax,%eax 10a517: 74 0e je 10a527 <== ALWAYS TAKEN free (req); 10a519: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a51c: 53 push %ebx <== NOT EXECUTED 10a51d: e8 36 c6 ff ff call 106b58 <== NOT EXECUTED 10a522: e9 a8 01 00 00 jmp 10a6cf <== NOT EXECUTED return result; } /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10a527: e8 cc 10 00 00 call 10b5f8 10a52c: 52 push %edx 10a52d: 8d 55 cc lea -0x34(%ebp),%edx 10a530: 52 push %edx 10a531: 8d 55 c8 lea -0x38(%ebp),%edx 10a534: 52 push %edx 10a535: 50 push %eax 10a536: e8 f1 0c 00 00 call 10b22c req->caller_thread = pthread_self (); 10a53b: e8 b8 10 00 00 call 10b5f8 10a540: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10a543: 8b 43 14 mov 0x14(%ebx),%eax 10a546: 8b 55 cc mov -0x34(%ebp),%edx 10a549: 2b 50 14 sub 0x14(%eax),%edx 10a54c: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10a54f: 8b 55 c8 mov -0x38(%ebp),%edx 10a552: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10a555: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10a55c: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10a563: 83 c4 10 add $0x10,%esp 10a566: 83 3d 70 03 13 00 00 cmpl $0x0,0x130370 10a56d: 0f 85 97 00 00 00 jne 10a60a <== NEVER TAKEN 10a573: 83 3d 6c 03 13 00 04 cmpl $0x4,0x13036c 10a57a: 0f 8f 8a 00 00 00 jg 10a60a aio_request_queue.active_threads < AIO_MAX_THREADS) /* we still have empty places on the active_threads chain */ { chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a580: 56 push %esi 10a581: 6a 01 push $0x1 10a583: ff 30 pushl (%eax) 10a585: 68 50 03 13 00 push $0x130350 10a58a: e8 30 fe ff ff call 10a3bf 10a58f: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10a591: 83 c4 10 add $0x10,%esp 10a594: 83 78 18 01 cmpl $0x1,0x18(%eax) 10a598: 0f 85 84 00 00 00 jne 10a622 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10a59e: 50 push %eax 10a59f: 50 push %eax 10a5a0: 53 push %ebx 10a5a1: 8d 46 08 lea 0x8(%esi),%eax 10a5a4: 50 push %eax 10a5a5: e8 96 1f 00 00 call 10c540 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10a5aa: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10a5b1: 58 pop %eax 10a5b2: 5a pop %edx 10a5b3: 6a 00 push $0x0 10a5b5: 8d 46 1c lea 0x1c(%esi),%eax 10a5b8: 50 push %eax 10a5b9: e8 22 07 00 00 call 10ace0 pthread_cond_init (&r_chain->cond, NULL); 10a5be: 59 pop %ecx 10a5bf: 5b pop %ebx 10a5c0: 6a 00 push $0x0 10a5c2: 8d 46 20 lea 0x20(%esi),%eax 10a5c5: 50 push %eax 10a5c6: e8 c9 03 00 00 call 10a994 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10a5cb: 56 push %esi 10a5cc: 68 34 a0 10 00 push $0x10a034 10a5d1: 68 10 03 13 00 push $0x130310 10a5d6: 8d 45 c4 lea -0x3c(%ebp),%eax 10a5d9: 50 push %eax 10a5da: e8 25 0a 00 00 call 10b004 10a5df: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10a5e1: 83 c4 20 add $0x20,%esp 10a5e4: 85 c0 test %eax,%eax 10a5e6: 74 17 je 10a5ff <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10a5e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a5eb: 68 08 03 13 00 push $0x130308 <== NOT EXECUTED 10a5f0: e8 93 08 00 00 call 10ae88 <== NOT EXECUTED 10a5f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5f8: 89 df mov %ebx,%edi <== NOT EXECUTED 10a5fa: e9 d3 00 00 00 jmp 10a6d2 <== NOT EXECUTED return result; } ++aio_request_queue.active_threads; 10a5ff: ff 05 6c 03 13 00 incl 0x13036c 10a605: e9 b8 00 00 00 jmp 10a6c2 else { /* the maximum number of threads has been already created even though some of them might be idle. The request belongs to one of the active fd chain */ r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a60a: 56 push %esi 10a60b: 6a 00 push $0x0 10a60d: ff 30 pushl (%eax) 10a60f: 68 50 03 13 00 push $0x130350 10a614: e8 a6 fd ff ff call 10a3bf 10a619: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10a61b: 83 c4 10 add $0x10,%esp 10a61e: 85 c0 test %eax,%eax 10a620: 74 31 je 10a653 { pthread_mutex_lock (&r_chain->mutex); 10a622: 8d 4e 1c lea 0x1c(%esi),%ecx 10a625: 83 ec 0c sub $0xc,%esp 10a628: 51 push %ecx 10a629: 89 4d b4 mov %ecx,-0x4c(%ebp) 10a62c: e8 d7 07 00 00 call 10ae08 rtems_aio_insert_prio (&r_chain->perfd, req); 10a631: 8d 46 08 lea 0x8(%esi),%eax 10a634: 89 da mov %ebx,%edx 10a636: e8 3d fc ff ff call 10a278 pthread_cond_signal (&r_chain->cond); 10a63b: 83 c6 20 add $0x20,%esi 10a63e: 89 34 24 mov %esi,(%esp) 10a641: e8 ee 03 00 00 call 10aa34 pthread_mutex_unlock (&r_chain->mutex); 10a646: 8b 4d b4 mov -0x4c(%ebp),%ecx 10a649: 89 0c 24 mov %ecx,(%esp) 10a64c: e8 37 08 00 00 call 10ae88 10a651: eb 6c jmp 10a6bf } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a653: 51 push %ecx 10a654: 6a 01 push $0x1 10a656: 8b 43 14 mov 0x14(%ebx),%eax 10a659: ff 30 pushl (%eax) 10a65b: 68 5c 03 13 00 push $0x13035c 10a660: e8 5a fd ff ff call 10a3bf 10a665: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10a667: 83 c4 10 add $0x10,%esp 10a66a: 83 78 18 01 cmpl $0x1,0x18(%eax) 10a66e: 8d 40 08 lea 0x8(%eax),%eax 10a671: 75 2f jne 10a6a2 10a673: 52 push %edx 10a674: 52 push %edx 10a675: 53 push %ebx 10a676: 50 push %eax 10a677: e8 c4 1e 00 00 call 10c540 <_Chain_Insert> /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10a67c: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10a683: 59 pop %ecx 10a684: 5b pop %ebx 10a685: 6a 00 push $0x0 10a687: 8d 46 1c lea 0x1c(%esi),%eax 10a68a: 50 push %eax 10a68b: e8 50 06 00 00 call 10ace0 pthread_cond_init (&r_chain->cond, NULL); 10a690: 58 pop %eax 10a691: 5a pop %edx 10a692: 6a 00 push $0x0 10a694: 83 c6 20 add $0x20,%esi 10a697: 56 push %esi 10a698: e8 f7 02 00 00 call 10a994 10a69d: 83 c4 10 add $0x10,%esp 10a6a0: eb 07 jmp 10a6a9 } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10a6a2: 89 da mov %ebx,%edx 10a6a4: e8 cf fb ff ff call 10a278 if (aio_request_queue.idle_threads > 0) 10a6a9: 83 3d 70 03 13 00 00 cmpl $0x0,0x130370 10a6b0: 7e 10 jle 10a6c2 <== ALWAYS TAKEN pthread_cond_signal (&aio_request_queue.new_req); 10a6b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a6b5: 68 0c 03 13 00 push $0x13030c <== NOT EXECUTED 10a6ba: e8 75 03 00 00 call 10aa34 <== NOT EXECUTED 10a6bf: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10a6c2: 83 ec 0c sub $0xc,%esp 10a6c5: 68 08 03 13 00 push $0x130308 10a6ca: e8 b9 07 00 00 call 10ae88 10a6cf: 83 c4 10 add $0x10,%esp return 0; } 10a6d2: 89 f8 mov %edi,%eax 10a6d4: 8d 65 f4 lea -0xc(%ebp),%esp 10a6d7: 5b pop %ebx 10a6d8: 5e pop %esi 10a6d9: 5f pop %edi 10a6da: 5d pop %ebp 10a6db: c3 ret =============================================================================== 0010a034 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10a034: 55 push %ebp 10a035: 89 e5 mov %esp,%ebp 10a037: 57 push %edi 10a038: 56 push %esi 10a039: 53 push %ebx 10a03a: 83 ec 4c sub $0x4c,%esp rtems_aio_request_chain *r_chain = arg; 10a03d: 8b 5d 08 mov 0x8(%ebp),%ebx /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10a040: 8d 7b 1c lea 0x1c(%ebx),%edi 10a043: 83 ec 0c sub $0xc,%esp 10a046: 57 push %edi 10a047: e8 bc 0d 00 00 call 10ae08 if (result != 0) 10a04c: 83 c4 10 add $0x10,%esp 10a04f: 85 c0 test %eax,%eax 10a051: 0f 85 17 02 00 00 jne 10a26e <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10a057: 8b 73 08 mov 0x8(%ebx),%esi RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10a05a: 8d 43 0c lea 0xc(%ebx),%eax /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10a05d: 39 c6 cmp %eax,%esi 10a05f: 0f 84 cc 00 00 00 je 10a131 node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10a065: e8 8e 15 00 00 call 10b5f8 10a06a: 52 push %edx 10a06b: 8d 55 cc lea -0x34(%ebp),%edx 10a06e: 52 push %edx 10a06f: 8d 55 c0 lea -0x40(%ebp),%edx 10a072: 52 push %edx 10a073: 50 push %eax 10a074: e8 b3 11 00 00 call 10b22c param.sched_priority = req->priority; 10a079: 8b 46 0c mov 0xc(%esi),%eax 10a07c: 89 45 cc mov %eax,-0x34(%ebp) pthread_setschedparam (pthread_self(), req->policy, ¶m); 10a07f: 8b 56 08 mov 0x8(%esi),%edx 10a082: 89 55 b4 mov %edx,-0x4c(%ebp) 10a085: e8 6e 15 00 00 call 10b5f8 10a08a: 83 c4 0c add $0xc,%esp 10a08d: 8d 4d cc lea -0x34(%ebp),%ecx 10a090: 51 push %ecx 10a091: 8b 55 b4 mov -0x4c(%ebp),%edx 10a094: 52 push %edx 10a095: 50 push %eax 10a096: e8 6d 15 00 00 call 10b608 10a09b: 89 34 24 mov %esi,(%esp) 10a09e: e8 61 24 00 00 call 10c504 <_Chain_Extract> rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10a0a3: 89 3c 24 mov %edi,(%esp) 10a0a6: e8 dd 0d 00 00 call 10ae88 switch (req->aiocbp->aio_lio_opcode) { 10a0ab: 8b 46 14 mov 0x14(%esi),%eax 10a0ae: 83 c4 10 add $0x10,%esp 10a0b1: 8b 50 2c mov 0x2c(%eax),%edx 10a0b4: 83 fa 02 cmp $0x2,%edx 10a0b7: 74 20 je 10a0d9 10a0b9: 83 fa 03 cmp $0x3,%edx 10a0bc: 74 36 je 10a0f4 <== NEVER TAKEN 10a0be: 4a dec %edx 10a0bf: 75 45 jne 10a106 <== NEVER TAKEN case LIO_READ: AIO_printf ("read\n"); result = pread (req->aiocbp->aio_fildes, 10a0c1: 83 ec 0c sub $0xc,%esp 10a0c4: ff 70 08 pushl 0x8(%eax) 10a0c7: ff 70 04 pushl 0x4(%eax) 10a0ca: ff 70 10 pushl 0x10(%eax) 10a0cd: ff 70 0c pushl 0xc(%eax) 10a0d0: ff 30 pushl (%eax) 10a0d2: e8 09 96 00 00 call 1136e0 10a0d7: eb 16 jmp 10a0ef req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: AIO_printf ("write\n"); result = pwrite (req->aiocbp->aio_fildes, 10a0d9: 83 ec 0c sub $0xc,%esp 10a0dc: ff 70 08 pushl 0x8(%eax) 10a0df: ff 70 04 pushl 0x4(%eax) 10a0e2: ff 70 10 pushl 0x10(%eax) 10a0e5: ff 70 0c pushl 0xc(%eax) 10a0e8: ff 30 pushl (%eax) 10a0ea: e8 f1 96 00 00 call 1137e0 (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10a0ef: 83 c4 20 add $0x20,%esp 10a0f2: eb 0d jmp 10a101 case LIO_SYNC: AIO_printf ("sync\n"); result = fsync (req->aiocbp->aio_fildes); 10a0f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0f7: ff 30 pushl (%eax) <== NOT EXECUTED 10a0f9: e8 56 5a 00 00 call 10fb54 <== NOT EXECUTED break; 10a0fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10a101: 83 f8 ff cmp $0xffffffff,%eax 10a104: 75 19 jne 10a11f <== ALWAYS TAKEN req->aiocbp->return_value = -1; 10a106: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10a109: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10a110: e8 07 8c 00 00 call 112d1c <__errno> <== NOT EXECUTED 10a115: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10a117: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10a11a: e9 21 ff ff ff jmp 10a040 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10a11f: 8b 56 14 mov 0x14(%esi),%edx 10a122: 89 42 34 mov %eax,0x34(%edx) req->aiocbp->error_code = 0; 10a125: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10a12c: e9 0f ff ff ff jmp 10a040 struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); 10a131: 83 ec 0c sub $0xc,%esp 10a134: 57 push %edi 10a135: e8 4e 0d 00 00 call 10ae88 pthread_mutex_lock (&aio_request_queue.mutex); 10a13a: c7 04 24 08 03 13 00 movl $0x130308,(%esp) 10a141: e8 c2 0c 00 00 call 10ae08 if (rtems_chain_is_empty (chain)) 10a146: 83 c4 10 add $0x10,%esp 10a149: 39 73 08 cmp %esi,0x8(%ebx) 10a14c: 0f 85 07 01 00 00 jne 10a259 <== NEVER TAKEN { clock_gettime (CLOCK_REALTIME, &timeout); 10a152: 56 push %esi 10a153: 56 push %esi 10a154: 8d 45 c4 lea -0x3c(%ebp),%eax 10a157: 50 push %eax 10a158: 6a 01 push $0x1 10a15a: e8 e1 06 00 00 call 10a840 timeout.tv_sec += 3; 10a15f: 83 45 c4 03 addl $0x3,-0x3c(%ebp) timeout.tv_nsec = 0; 10a163: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) result = pthread_cond_timedwait (&r_chain->cond, 10a16a: 8d 73 20 lea 0x20(%ebx),%esi 10a16d: 83 c4 0c add $0xc,%esp 10a170: 8d 55 c4 lea -0x3c(%ebp),%edx 10a173: 52 push %edx 10a174: 68 08 03 13 00 push $0x130308 10a179: 56 push %esi 10a17a: e8 29 09 00 00 call 10aaa8 &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10a17f: 83 c4 10 add $0x10,%esp 10a182: 83 f8 74 cmp $0x74,%eax 10a185: 0f 85 ce 00 00 00 jne 10a259 <== NEVER TAKEN 10a18b: 83 ec 0c sub $0xc,%esp 10a18e: 53 push %ebx 10a18f: e8 70 23 00 00 call 10c504 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10a194: 89 3c 24 mov %edi,(%esp) 10a197: e8 40 0a 00 00 call 10abdc pthread_cond_destroy (&r_chain->cond); 10a19c: 89 34 24 mov %esi,(%esp) 10a19f: e8 34 07 00 00 call 10a8d8 free (r_chain); 10a1a4: 89 1c 24 mov %ebx,(%esp) 10a1a7: e8 ac c9 ff ff call 106b58 /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a1ac: 83 c4 10 add $0x10,%esp 10a1af: 81 3d 5c 03 13 00 60 cmpl $0x130360,0x13035c 10a1b6: 03 13 00 10a1b9: 75 5a jne 10a215 AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 10a1bb: ff 05 70 03 13 00 incl 0x130370 --aio_request_queue.active_threads; 10a1c1: ff 0d 6c 03 13 00 decl 0x13036c clock_gettime (CLOCK_REALTIME, &timeout); 10a1c7: 51 push %ecx 10a1c8: 51 push %ecx 10a1c9: 8d 4d c4 lea -0x3c(%ebp),%ecx 10a1cc: 51 push %ecx 10a1cd: 6a 01 push $0x1 10a1cf: e8 6c 06 00 00 call 10a840 timeout.tv_sec += 3; 10a1d4: 83 45 c4 03 addl $0x3,-0x3c(%ebp) timeout.tv_nsec = 0; 10a1d8: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) result = pthread_cond_timedwait (&aio_request_queue.new_req, 10a1df: 83 c4 0c add $0xc,%esp 10a1e2: 8d 45 c4 lea -0x3c(%ebp),%eax 10a1e5: 50 push %eax 10a1e6: 68 08 03 13 00 push $0x130308 10a1eb: 68 0c 03 13 00 push $0x13030c 10a1f0: e8 b3 08 00 00 call 10aaa8 &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10a1f5: 83 c4 10 add $0x10,%esp 10a1f8: 83 f8 74 cmp $0x74,%eax 10a1fb: 75 18 jne 10a215 <== NEVER TAKEN AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; 10a1fd: ff 0d 70 03 13 00 decl 0x130370 pthread_mutex_unlock (&aio_request_queue.mutex); 10a203: 83 ec 0c sub $0xc,%esp 10a206: 68 08 03 13 00 push $0x130308 10a20b: e8 78 0c 00 00 call 10ae88 10a210: 83 c4 10 add $0x10,%esp 10a213: eb 59 jmp 10a26e } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 10a215: ff 0d 70 03 13 00 decl 0x130370 ++aio_request_queue.active_threads; 10a21b: ff 05 6c 03 13 00 incl 0x13036c */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10a221: 8b 1d 5c 03 13 00 mov 0x13035c,%ebx 10a227: 83 ec 0c sub $0xc,%esp 10a22a: 53 push %ebx 10a22b: e8 d4 22 00 00 call 10c504 <_Chain_Extract> 10a230: a1 50 03 13 00 mov 0x130350,%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10a235: 8b 53 14 mov 0x14(%ebx),%edx 10a238: 83 c4 10 add $0x10,%esp 10a23b: eb 02 jmp 10a23f } } AIO_printf ("Thread finished\n"); return NULL; } 10a23d: 8b 00 mov (%eax),%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10a23f: 39 50 14 cmp %edx,0x14(%eax) 10a242: 7d 07 jge 10a24b 10a244: 3d 54 03 13 00 cmp $0x130354,%eax 10a249: 75 f2 jne 10a23d <== ALWAYS TAKEN RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10a24b: 52 push %edx 10a24c: 52 push %edx 10a24d: 53 push %ebx 10a24e: ff 70 04 pushl 0x4(%eax) 10a251: e8 ea 22 00 00 call 10c540 <_Chain_Insert> 10a256: 83 c4 10 add $0x10,%esp } } /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10a259: 83 ec 0c sub $0xc,%esp 10a25c: 68 08 03 13 00 push $0x130308 10a261: e8 22 0c 00 00 call 10ae88 10a266: 83 c4 10 add $0x10,%esp 10a269: e9 d2 fd ff ff jmp 10a040 } } AIO_printf ("Thread finished\n"); return NULL; } 10a26e: 31 c0 xor %eax,%eax 10a270: 8d 65 f4 lea -0xc(%ebp),%esp 10a273: 5b pop %ebx 10a274: 5e pop %esi 10a275: 5f pop %edi 10a276: 5d pop %ebp 10a277: c3 ret =============================================================================== 0010a2c3 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10a2c3: 55 push %ebp 10a2c4: 89 e5 mov %esp,%ebp 10a2c6: 53 push %ebx 10a2c7: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10a2ca: 68 10 03 13 00 push $0x130310 10a2cf: e8 e4 0c 00 00 call 10afb8 10a2d4: 89 c3 mov %eax,%ebx if (result != 0) 10a2d6: 83 c4 10 add $0x10,%esp 10a2d9: 85 c0 test %eax,%eax 10a2db: 0f 85 d7 00 00 00 jne 10a3b8 <== NEVER TAKEN return result; result = 10a2e1: 50 push %eax 10a2e2: 50 push %eax 10a2e3: 6a 00 push $0x0 10a2e5: 68 10 03 13 00 push $0x130310 10a2ea: e8 f1 0c 00 00 call 10afe0 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10a2ef: 83 c4 10 add $0x10,%esp 10a2f2: 85 c0 test %eax,%eax 10a2f4: 74 10 je 10a306 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10a2f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a2f9: 68 10 03 13 00 push $0x130310 <== NOT EXECUTED 10a2fe: e8 95 0c 00 00 call 10af98 <== NOT EXECUTED 10a303: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10a306: 50 push %eax 10a307: 50 push %eax 10a308: 6a 00 push $0x0 10a30a: 68 08 03 13 00 push $0x130308 10a30f: e8 cc 09 00 00 call 10ace0 if (result != 0) 10a314: 83 c4 10 add $0x10,%esp 10a317: 85 c0 test %eax,%eax 10a319: 74 10 je 10a32b <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10a31b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a31e: 68 10 03 13 00 push $0x130310 <== NOT EXECUTED 10a323: e8 70 0c 00 00 call 10af98 <== NOT EXECUTED 10a328: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10a32b: 50 push %eax 10a32c: 50 push %eax 10a32d: 6a 00 push $0x0 10a32f: 68 0c 03 13 00 push $0x13030c 10a334: e8 5b 06 00 00 call 10a994 10a339: 89 c3 mov %eax,%ebx if (result != 0) { 10a33b: 83 c4 10 add $0x10,%esp 10a33e: 85 c0 test %eax,%eax 10a340: 74 1c je 10a35e <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10a342: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a345: 68 08 03 13 00 push $0x130308 <== NOT EXECUTED 10a34a: e8 8d 08 00 00 call 10abdc <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10a34f: c7 04 24 10 03 13 00 movl $0x130310,(%esp) <== NOT EXECUTED 10a356: e8 3d 0c 00 00 call 10af98 <== NOT EXECUTED 10a35b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10a35e: c7 05 50 03 13 00 54 movl $0x130354,0x130350 10a365: 03 13 00 head->previous = NULL; 10a368: c7 05 54 03 13 00 00 movl $0x0,0x130354 10a36f: 00 00 00 tail->previous = head; 10a372: c7 05 58 03 13 00 50 movl $0x130350,0x130358 10a379: 03 13 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10a37c: c7 05 5c 03 13 00 60 movl $0x130360,0x13035c 10a383: 03 13 00 head->previous = NULL; 10a386: c7 05 60 03 13 00 00 movl $0x0,0x130360 10a38d: 00 00 00 tail->previous = head; 10a390: c7 05 64 03 13 00 5c movl $0x13035c,0x130364 10a397: 03 13 00 } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 10a39a: c7 05 6c 03 13 00 00 movl $0x0,0x13036c 10a3a1: 00 00 00 aio_request_queue.idle_threads = 0; 10a3a4: c7 05 70 03 13 00 00 movl $0x0,0x130370 10a3ab: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10a3ae: c7 05 68 03 13 00 0b movl $0xb00b,0x130368 10a3b5: b0 00 00 return result; } 10a3b8: 89 d8 mov %ebx,%eax 10a3ba: 8b 5d fc mov -0x4(%ebp),%ebx 10a3bd: c9 leave 10a3be: c3 ret =============================================================================== 0010a278 : * NONE */ static void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10a278: 55 push %ebp 10a279: 89 e5 mov %esp,%ebp 10a27b: 56 push %esi 10a27c: 53 push %ebx 10a27d: 8b 08 mov (%eax),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10a27f: 8d 58 04 lea 0x4(%eax),%ebx rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 10a282: 39 d9 cmp %ebx,%ecx 10a284: 75 06 jne 10a28c <== ALWAYS TAKEN RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10a286: 56 push %esi <== NOT EXECUTED 10a287: 56 push %esi <== NOT EXECUTED 10a288: 52 push %edx <== NOT EXECUTED 10a289: 50 push %eax <== NOT EXECUTED 10a28a: eb 20 jmp 10a2ac <== NOT EXECUTED AIO_printf ("First in chain \n"); rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10a28c: 8b 41 14 mov 0x14(%ecx),%eax 10a28f: 8b 40 14 mov 0x14(%eax),%eax while (req->aiocbp->aio_reqprio > prio && 10a292: 8b 72 14 mov 0x14(%edx),%esi 10a295: 8b 76 14 mov 0x14(%esi),%esi 10a298: eb 08 jmp 10a2a2 } } AIO_printf ("Thread finished\n"); return NULL; } 10a29a: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10a29c: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10a29f: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 10a2a2: 39 c6 cmp %eax,%esi 10a2a4: 7f 10 jg 10a2b6 <== NEVER TAKEN 10a2a6: 53 push %ebx 10a2a7: 53 push %ebx 10a2a8: 52 push %edx 10a2a9: ff 71 04 pushl 0x4(%ecx) 10a2ac: e8 8f 22 00 00 call 10c540 <_Chain_Insert> 10a2b1: 83 c4 10 add $0x10,%esp 10a2b4: eb 06 jmp 10a2bc 10a2b6: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10a2b8: 75 e0 jne 10a29a <== NOT EXECUTED 10a2ba: eb ea jmp 10a2a6 <== NOT EXECUTED } rtems_chain_insert (node->previous, &req->next_prio); } } 10a2bc: 8d 65 f8 lea -0x8(%ebp),%esp 10a2bf: 5b pop %ebx 10a2c0: 5e pop %esi 10a2c1: 5d pop %ebp 10a2c2: c3 ret =============================================================================== 0010a496 : * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { 10a496: 55 push %ebp 10a497: 89 e5 mov %esp,%ebp 10a499: 53 push %ebx 10a49a: 50 push %eax 10a49b: 8b 55 08 mov 0x8(%ebp),%edx 10a49e: 8b 45 0c mov 0xc(%ebp),%eax */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10a4a1: 8b 1a mov (%edx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10a4a3: 83 c2 04 add $0x4,%edx if (rtems_chain_is_empty (chain)) 10a4a6: 39 d3 cmp %edx,%ebx 10a4a8: 75 0f jne 10a4b9 10a4aa: eb 44 jmp 10a4f0 } } AIO_printf ("Thread finished\n"); return NULL; } 10a4ac: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10a4ae: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10a4b0: 75 07 jne 10a4b9 <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10a4b2: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a4b7: eb 3c jmp 10a4f5 <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10a4b9: 39 43 14 cmp %eax,0x14(%ebx) 10a4bc: 75 ee jne 10a4ac <== NEVER TAKEN node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10a4be: b8 01 00 00 00 mov $0x1,%eax while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) 10a4c3: 39 d3 cmp %edx,%ebx 10a4c5: 74 2e je 10a4f5 <== NEVER TAKEN 10a4c7: 83 ec 0c sub $0xc,%esp 10a4ca: 53 push %ebx 10a4cb: e8 34 20 00 00 call 10c504 <_Chain_Extract> return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10a4d0: 8b 43 14 mov 0x14(%ebx),%eax 10a4d3: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10a4da: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10a4e1: 89 1c 24 mov %ebx,(%esp) 10a4e4: e8 6f c6 ff ff call 106b58 } return AIO_CANCELED; 10a4e9: 83 c4 10 add $0x10,%esp 10a4ec: 31 c0 xor %eax,%eax 10a4ee: eb 05 jmp 10a4f5 */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) return AIO_ALLDONE; 10a4f0: b8 02 00 00 00 mov $0x2,%eax current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10a4f5: 8b 5d fc mov -0x4(%ebp),%ebx 10a4f8: c9 leave 10a4f9: c3 ret =============================================================================== 0010a718 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10a718: 55 push %ebp 10a719: 89 e5 mov %esp,%ebp 10a71b: 56 push %esi 10a71c: 53 push %ebx 10a71d: 83 ec 10 sub $0x10,%esp while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10a720: 8d 5d f4 lea -0xc(%ebp),%ebx 10a723: eb 15 jmp 10a73a 10a725: 53 push %ebx 10a726: ff 75 10 pushl 0x10(%ebp) 10a729: 6a 00 push $0x0 10a72b: ff 75 0c pushl 0xc(%ebp) 10a72e: e8 99 f5 ff ff call 109ccc ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10a733: 83 c4 10 add $0x10,%esp 10a736: 85 c0 test %eax,%eax 10a738: 75 16 jne 10a750 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10a73a: 83 ec 0c sub $0xc,%esp 10a73d: ff 75 08 pushl 0x8(%ebp) 10a740: e8 cf 04 00 00 call 10ac14 <_Chain_Get> 10a745: 89 c6 mov %eax,%esi sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10a747: 83 c4 10 add $0x10,%esp 10a74a: 85 c0 test %eax,%eax 10a74c: 74 d7 je 10a725 10a74e: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10a750: 8b 55 14 mov 0x14(%ebp),%edx 10a753: 89 32 mov %esi,(%edx) return sc; } 10a755: 8d 65 f8 lea -0x8(%ebp),%esp 10a758: 5b pop %ebx 10a759: 5e pop %esi 10a75a: 5d pop %ebp 10a75b: c3 ret =============================================================================== 0010694c : */ void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 10694c: 55 push %ebp 10694d: 89 e5 mov %esp,%ebp 10694f: 57 push %edi 106950: 56 push %esi 106951: 53 push %ebx 106952: 83 ec 4c sub $0x4c,%esp uint32_t seconds, nanoseconds; #else uint32_t total_units = 0; #endif if ( !print ) 106955: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 106959: 0f 84 ca 01 00 00 je 106b29 <== NEVER TAKEN static inline void _Timestamp64_implementation_Set_to_zero( Timestamp64_Control *_time ) { *_time = 0; 10695f: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 106966: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) * 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; 10696d: a1 e8 13 13 00 mov 0x1313e8,%eax 106972: 8b 15 ec 13 13 00 mov 0x1313ec,%edx 106978: 89 45 a8 mov %eax,-0x58(%ebp) 10697b: 89 55 ac mov %edx,-0x54(%ebp) } } } #endif (*print)( 10697e: 53 push %ebx 10697f: 53 push %ebx 106980: 68 35 0e 12 00 push $0x120e35 106985: ff 75 08 pushl 0x8(%ebp) 106988: 8b 55 0c mov 0xc(%ebp),%edx 10698b: ff d2 call *%edx 10698d: 83 c4 10 add $0x10,%esp " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 106990: c7 45 b0 01 00 00 00 movl $0x1,-0x50(%ebp) #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 106997: 8b 55 b0 mov -0x50(%ebp),%edx 10699a: 8b 04 95 3c 0e 13 00 mov 0x130e3c(,%edx,4),%eax 1069a1: 8b 58 04 mov 0x4(%eax),%ebx if ( information ) { 1069a4: c7 45 b4 01 00 00 00 movl $0x1,-0x4c(%ebp) 1069ab: 85 db test %ebx,%ebx 1069ad: 0f 85 0b 01 00 00 jne 106abe <== ALWAYS TAKEN " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1069b3: ff 45 b0 incl -0x50(%ebp) 1069b6: 83 7d b0 04 cmpl $0x4,-0x50(%ebp) 1069ba: 75 db jne 106997 1069bc: e9 0f 01 00 00 jmp 106ad0 #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 1069c1: 8b 43 1c mov 0x1c(%ebx),%eax 1069c4: 8b 55 b4 mov -0x4c(%ebp),%edx 1069c7: 8b 34 90 mov (%eax,%edx,4),%esi if ( !the_thread ) 1069ca: 85 f6 test %esi,%esi 1069cc: 0f 84 e9 00 00 00 je 106abb <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 1069d2: 51 push %ecx 1069d3: 8d 45 db lea -0x25(%ebp),%eax 1069d6: 50 push %eax 1069d7: 6a 0d push $0xd 1069d9: ff 76 08 pushl 0x8(%esi) 1069dc: e8 47 40 00 00 call 10aa28 (*print)( 1069e1: 8d 55 db lea -0x25(%ebp),%edx 1069e4: 52 push %edx 1069e5: ff 76 08 pushl 0x8(%esi) 1069e8: 68 a7 0f 12 00 push $0x120fa7 1069ed: ff 75 08 pushl 0x8(%ebp) 1069f0: 8b 55 0c mov 0xc(%ebp),%edx 1069f3: ff d2 call *%edx /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 1069f5: 8b 86 80 00 00 00 mov 0x80(%esi),%eax 1069fb: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 106a01: 89 45 d0 mov %eax,-0x30(%ebp) 106a04: 89 55 d4 mov %edx,-0x2c(%ebp) Thread_Control *the_thread, Timestamp_Control *time_of_context_switch ) { #ifndef RTEMS_SMP if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 106a07: 83 c4 20 add $0x20,%esp 106a0a: a1 ac 13 13 00 mov 0x1313ac,%eax 106a0f: 8b 56 08 mov 0x8(%esi),%edx 106a12: 39 50 08 cmp %edx,0x8(%eax) 106a15: 0f 85 fd 00 00 00 jne 106b18 *time_of_context_switch = _Thread_Time_of_last_context_switch; 106a1b: 8b 35 bc 13 13 00 mov 0x1313bc,%esi 106a21: 8b 3d c0 13 13 00 mov 0x1313c0,%edi * 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 ); 106a27: 83 ec 0c sub $0xc,%esp 106a2a: 8d 45 c0 lea -0x40(%ebp),%eax 106a2d: 50 push %eax 106a2e: e8 bd 50 00 00 call 10baf0 <_TOD_Get_uptime> const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 106a33: 8b 45 c0 mov -0x40(%ebp),%eax 106a36: 8b 55 c4 mov -0x3c(%ebp),%edx 106a39: 29 f0 sub %esi,%eax 106a3b: 19 fa sbb %edi,%edx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 106a3d: 01 45 d0 add %eax,-0x30(%ebp) 106a40: 11 55 d4 adc %edx,-0x2c(%ebp) 106a43: 83 c4 10 add $0x10,%esp const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 106a46: 8b 45 c0 mov -0x40(%ebp),%eax 106a49: 8b 55 c4 mov -0x3c(%ebp),%edx 106a4c: 2b 45 a8 sub -0x58(%ebp),%eax 106a4f: 1b 55 ac sbb -0x54(%ebp),%edx 106a52: 89 45 c8 mov %eax,-0x38(%ebp) 106a55: 89 55 cc mov %edx,-0x34(%ebp) _Timestamp_Add_to( &ran, &used ); } else { _TOD_Get_uptime( &uptime ); } _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total ); _Timestamp_Divide( &ran, &total, &ival, &fval ); 106a58: 8d 45 bc lea -0x44(%ebp),%eax 106a5b: 50 push %eax 106a5c: 8d 45 b8 lea -0x48(%ebp),%eax 106a5f: 50 push %eax 106a60: 8d 45 c8 lea -0x38(%ebp),%eax 106a63: 50 push %eax 106a64: 8d 45 d0 lea -0x30(%ebp),%eax 106a67: 50 push %eax 106a68: e8 07 6f 00 00 call 10d974 <_Timestamp64_Divide> /* * Print the information */ seconds = _Timestamp_Get_seconds( &ran ); 106a6d: 8b 75 d0 mov -0x30(%ebp),%esi 106a70: 8b 7d d4 mov -0x2c(%ebp),%edi nanoseconds = _Timestamp_Get_nanoseconds( &ran ) / TOD_NANOSECONDS_PER_MICROSECOND; (*print)( context, 106a73: 58 pop %eax 106a74: 5a pop %edx 106a75: ff 75 bc pushl -0x44(%ebp) 106a78: ff 75 b8 pushl -0x48(%ebp) static inline uint32_t _Timestamp64_implementation_Get_nanoseconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time % 1000000000L); 106a7b: 6a 00 push $0x0 106a7d: 68 00 ca 9a 3b push $0x3b9aca00 106a82: 57 push %edi 106a83: 56 push %esi 106a84: e8 e3 80 01 00 call 11eb6c <__moddi3> 106a89: 83 c4 10 add $0x10,%esp /* * Print the information */ seconds = _Timestamp_Get_seconds( &ran ); nanoseconds = _Timestamp_Get_nanoseconds( &ran ) / 106a8c: b9 e8 03 00 00 mov $0x3e8,%ecx 106a91: 31 d2 xor %edx,%edx 106a93: f7 f1 div %ecx TOD_NANOSECONDS_PER_MICROSECOND; (*print)( context, 106a95: 50 push %eax static inline uint32_t _Timestamp64_implementation_Get_seconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time / 1000000000L); 106a96: 83 ec 0c sub $0xc,%esp 106a99: 6a 00 push $0x0 106a9b: 68 00 ca 9a 3b push $0x3b9aca00 106aa0: 57 push %edi 106aa1: 56 push %esi 106aa2: e8 71 7f 01 00 call 11ea18 <__divdi3> 106aa7: 83 c4 1c add $0x1c,%esp 106aaa: 50 push %eax 106aab: 68 ba 0f 12 00 push $0x120fba 106ab0: ff 75 08 pushl 0x8(%ebp) 106ab3: 8b 55 0c mov 0xc(%ebp),%edx 106ab6: ff d2 call *%edx 106ab8: 83 c4 20 add $0x20,%esp continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 106abb: ff 45 b4 incl -0x4c(%ebp) 106abe: 0f b7 43 10 movzwl 0x10(%ebx),%eax 106ac2: 39 45 b4 cmp %eax,-0x4c(%ebp) 106ac5: 0f 86 f6 fe ff ff jbe 1069c1 106acb: e9 e3 fe ff ff jmp 1069b3 } } } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ seconds = _Timestamp_Get_seconds( &total ); 106ad0: 8b 75 c8 mov -0x38(%ebp),%esi 106ad3: 8b 7d cc mov -0x34(%ebp),%edi static inline uint32_t _Timestamp64_implementation_Get_nanoseconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time % 1000000000L); 106ad6: 6a 00 push $0x0 106ad8: 68 00 ca 9a 3b push $0x3b9aca00 106add: 57 push %edi 106ade: 56 push %esi 106adf: e8 88 80 01 00 call 11eb6c <__moddi3> 106ae4: 83 c4 10 add $0x10,%esp nanoseconds = _Timestamp_Get_nanoseconds( &total ) / 106ae7: b9 e8 03 00 00 mov $0x3e8,%ecx 106aec: 31 d2 xor %edx,%edx 106aee: f7 f1 div %ecx TOD_NANOSECONDS_PER_MICROSECOND; (*print)( 106af0: 50 push %eax static inline uint32_t _Timestamp64_implementation_Get_seconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time / 1000000000L); 106af1: 83 ec 0c sub $0xc,%esp 106af4: 6a 00 push $0x0 106af6: 68 00 ca 9a 3b push $0x3b9aca00 106afb: 57 push %edi 106afc: 56 push %esi 106afd: e8 16 7f 01 00 call 11ea18 <__divdi3> 106b02: 83 c4 1c add $0x1c,%esp 106b05: 50 push %eax 106b06: 68 d2 0f 12 00 push $0x120fd2 106b0b: ff 75 08 pushl 0x8(%ebp) 106b0e: 8b 55 0c mov 0xc(%ebp),%edx 106b11: ff d2 call *%edx 106b13: 83 c4 10 add $0x10,%esp 106b16: eb 11 jmp 106b29 Timestamp_Control used; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( &last, &uptime, &used ); _Timestamp_Add_to( &ran, &used ); } else { _TOD_Get_uptime( &uptime ); 106b18: 83 ec 0c sub $0xc,%esp 106b1b: 8d 45 c0 lea -0x40(%ebp),%eax 106b1e: 50 push %eax 106b1f: e8 cc 4f 00 00 call 10baf0 <_TOD_Get_uptime> 106b24: e9 1a ff ff ff jmp 106a43 "-------------------------------------------------------------------------------\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset, total_units ); #endif } 106b29: 8d 65 f4 lea -0xc(%ebp),%esp 106b2c: 5b pop %ebx 106b2d: 5e pop %esi 106b2e: 5f pop %edi 106b2f: 5d pop %ebp 106b30: c3 ret =============================================================================== 00110e24 : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 110e24: 55 push %ebp 110e25: 89 e5 mov %esp,%ebp 110e27: 53 push %ebx 110e28: 51 push %ecx 110e29: 8b 55 08 mov 0x8(%ebp),%edx if (sc == RTEMS_SUCCESSFUL) { return 0; 110e2c: 31 c0 xor %eax,%eax [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { 110e2e: 85 d2 test %edx,%edx 110e30: 74 1b je 110e4d return 0; } else { int eno = EINVAL; 110e32: bb 16 00 00 00 mov $0x16,%ebx if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 110e37: 83 fa 1c cmp $0x1c,%edx 110e3a: 77 07 ja 110e43 <== NEVER TAKEN eno = status_code_to_errno [sc]; 110e3c: 8b 1c 95 4c 01 12 00 mov 0x12014c(,%edx,4),%ebx } errno = eno; 110e43: e8 94 00 00 00 call 110edc <__errno> 110e48: 89 18 mov %ebx,(%eax) return -1; 110e4a: 83 c8 ff or $0xffffffff,%eax } } 110e4d: 5a pop %edx 110e4e: 5b pop %ebx 110e4f: 5d pop %ebp 110e50: c3 ret =============================================================================== 0010ddf0 : int eval_flags, mode_t node_mode, uid_t node_uid, gid_t node_gid ) { 10ddf0: 55 push %ebp 10ddf1: 89 e5 mov %esp,%ebp 10ddf3: 57 push %edi 10ddf4: 56 push %esi 10ddf5: 53 push %ebx 10ddf6: 83 ec 0c sub $0xc,%esp 10ddf9: 8b 5d 08 mov 0x8(%ebp),%ebx 10ddfc: 8b 7d 10 mov 0x10(%ebp),%edi 10ddff: 8b 75 14 mov 0x14(%ebp),%esi mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX; 10de02: 83 e3 07 and $0x7,%ebx uid_t task_uid = geteuid(); 10de05: e8 3e fc ff ff call 10da48 if (task_uid == 0 || task_uid == node_uid) { 10de0a: 66 39 f8 cmp %di,%ax 10de0d: 74 05 je 10de14 10de0f: 66 85 c0 test %ax,%ax 10de12: 75 05 jne 10de19 perm_flags <<= RTEMS_FS_USR_SHIFT; 10de14: c1 e3 06 shl $0x6,%ebx 10de17: eb 12 jmp 10de2b } else { gid_t task_gid = getegid(); 10de19: e8 1a fc ff ff call 10da38 if (task_gid == 0 || task_gid == node_gid) { 10de1e: 66 39 f0 cmp %si,%ax 10de21: 74 05 je 10de28 10de23: 66 85 c0 test %ax,%ax 10de26: 75 03 jne 10de2b <== ALWAYS TAKEN perm_flags <<= RTEMS_FS_GRP_SHIFT; 10de28: c1 e3 03 shl $0x3,%ebx } else { perm_flags <<= RTEMS_FS_OTH_SHIFT; } } return (perm_flags & node_mode) == perm_flags; 10de2b: 8b 45 0c mov 0xc(%ebp),%eax 10de2e: 21 d8 and %ebx,%eax 10de30: 39 d8 cmp %ebx,%eax 10de32: 0f 94 c0 sete %al } 10de35: 83 c4 0c add $0xc,%esp 10de38: 5b pop %ebx 10de39: 5e pop %esi 10de3a: 5f pop %edi 10de3b: 5d pop %ebp 10de3c: c3 ret =============================================================================== 00107a95 : } void rtems_filesystem_do_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107a95: 55 push %ebp 107a96: 89 e5 mov %esp,%ebp 107a98: 53 push %ebx 107a99: 83 ec 08 sub $0x8,%esp 107a9c: 8b 5d 08 mov 0x8(%ebp),%ebx */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 107a9f: 6a 00 push $0x0 107aa1: 6a 00 push $0x0 107aa3: ff 35 d8 e2 12 00 pushl 0x12e2d8 107aa9: e8 e2 22 00 00 call 109d90 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 107aae: 8b 13 mov (%ebx),%edx previous = the_node->previous; 107ab0: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 107ab3: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 107ab6: 89 10 mov %edx,(%eax) } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 107ab8: 58 pop %eax 107ab9: ff 35 d8 e2 12 00 pushl 0x12e2d8 107abf: e8 bc 23 00 00 call 109e80 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); 107ac4: 58 pop %eax 107ac5: ff 73 20 pushl 0x20(%ebx) 107ac8: e8 fc 00 00 00 call 107bc9 (*mt_entry->ops->fsunmount_me_h)(mt_entry); 107acd: 8b 43 0c mov 0xc(%ebx),%eax 107ad0: 89 1c 24 mov %ebx,(%esp) 107ad3: ff 50 3c call *0x3c(%eax) if (mt_entry->unmount_task != 0) { 107ad6: 8b 43 3c mov 0x3c(%ebx),%eax 107ad9: 83 c4 10 add $0x10,%esp 107adc: 85 c0 test %eax,%eax 107ade: 74 1e je 107afe <== NEVER TAKEN rtems_status_code sc = 107ae0: 51 push %ecx 107ae1: 51 push %ecx 107ae2: 6a 02 push $0x2 107ae4: 50 push %eax 107ae5: e8 da 1e 00 00 call 1099c4 rtems_event_send(mt_entry->unmount_task, RTEMS_FILESYSTEM_UNMOUNT_EVENT); if (sc != RTEMS_SUCCESSFUL) { 107aea: 83 c4 10 add $0x10,%esp 107aed: 85 c0 test %eax,%eax 107aef: 74 0d je 107afe <== ALWAYS TAKEN rtems_fatal_error_occurred(0xdeadbeef); 107af1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107af4: 68 ef be ad de push $0xdeadbeef <== NOT EXECUTED 107af9: e8 b6 28 00 00 call 10a3b4 <== NOT EXECUTED } } free(mt_entry); 107afe: 89 5d 08 mov %ebx,0x8(%ebp) } 107b01: 8b 5d fc mov -0x4(%ebp),%ebx 107b04: c9 leave if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } } free(mt_entry); 107b05: e9 2a ec ff ff jmp 106734 =============================================================================== 0010de78 : void rtems_filesystem_eval_path_generic( rtems_filesystem_eval_path_context_t *ctx, void *arg, const rtems_filesystem_eval_path_generic_config *config ) { 10de78: 55 push %ebp 10de79: 89 e5 mov %esp,%ebp 10de7b: 57 push %edi 10de7c: 56 push %esi 10de7d: 53 push %ebx 10de7e: 83 ec 1c sub $0x1c,%esp 10de81: 8b 5d 08 mov 0x8(%ebp),%ebx 10de84: 8b 75 0c mov 0xc(%ebp),%esi 10de87: 8b 7d 10 mov 0x10(%ebp),%edi 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 = 10de8a: 8d 43 18 lea 0x18(%ebx),%eax 10de8d: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_filesystem_eval_path_context_t *ctx, const char **token, size_t *tokenlen ) { rtems_filesystem_eval_path_next_token(ctx); 10de90: 83 ec 0c sub $0xc,%esp 10de93: 53 push %ebx 10de94: e8 72 01 00 00 call 10e00b *token = ctx->token; 10de99: 8b 53 08 mov 0x8(%ebx),%edx *tokenlen = ctx->tokenlen; 10de9c: 8b 4b 0c mov 0xc(%ebx),%ecx const char *token; size_t tokenlen; rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen); if (tokenlen > 0) { 10de9f: 83 c4 10 add $0x10,%esp 10dea2: 85 c9 test %ecx,%ecx 10dea4: 0f 84 27 01 00 00 je 10dfd1 if ((*config->is_directory)(ctx, arg)) { 10deaa: 50 push %eax 10deab: 50 push %eax 10deac: 56 push %esi 10dead: 53 push %ebx 10deae: 89 55 e0 mov %edx,-0x20(%ebp) 10deb1: 89 4d dc mov %ecx,-0x24(%ebp) 10deb4: ff 17 call *(%edi) 10deb6: 83 c4 10 add $0x10,%esp 10deb9: 84 c0 test %al,%al 10debb: 8b 55 e0 mov -0x20(%ebp),%edx 10debe: 8b 4d dc mov -0x24(%ebp),%ecx 10dec1: 0f 84 f6 00 00 00 je 10dfbd static inline bool rtems_filesystem_is_current_directory( const char *token, size_t tokenlen ) { return tokenlen == 1 && token [0] == '.'; 10dec7: 31 c0 xor %eax,%eax 10dec9: 83 f9 01 cmp $0x1,%ecx 10decc: 75 08 jne 10ded6 10dece: 31 c0 xor %eax,%eax 10ded0: 80 3a 2e cmpb $0x2e,(%edx) 10ded3: 0f 94 c0 sete %al if (rtems_filesystem_is_current_directory(token, tokenlen)) { 10ded6: 85 c0 test %eax,%eax 10ded8: 74 1f je 10def9 if (rtems_filesystem_eval_path_has_path(ctx)) { 10deda: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10dede: 74 05 je 10dee5 10dee0: e9 93 00 00 00 jmp 10df78 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) { 10dee5: f6 43 11 01 testb $0x1,0x11(%ebx) 10dee9: 75 05 jne 10def0 10deeb: e9 88 00 00 00 jmp 10df78 status = (*config->eval_token)(ctx, arg, ".", 1); } else { rtems_filesystem_eval_path_error(ctx, EINVAL); 10def0: 50 push %eax 10def1: 50 push %eax 10def2: 6a 16 push $0x16 10def4: e9 c8 00 00 00 jmp 10dfc1 static inline bool rtems_filesystem_is_parent_directory( const char *token, size_t tokenlen ) { return tokenlen == 2 && token [0] == '.' && token [1] == '.'; 10def9: 31 c0 xor %eax,%eax 10defb: 83 f9 02 cmp $0x2,%ecx 10defe: 75 0e jne 10df0e 10df00: 80 3a 2e cmpb $0x2e,(%edx) 10df03: 75 09 jne 10df0e 10df05: 31 c0 xor %eax,%eax 10df07: 80 7a 01 2e cmpb $0x2e,0x1(%edx) 10df0b: 0f 94 c0 sete %al status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } else if (rtems_filesystem_is_parent_directory(token, tokenlen)) { 10df0e: 85 c0 test %eax,%eax 10df10: 74 78 je 10df8a } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 10df12: 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; 10df15: 8b 4b 2c mov 0x2c(%ebx),%ecx 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 ); 10df18: 31 c0 xor %eax,%eax 10df1a: 3b 4a 14 cmp 0x14(%edx),%ecx 10df1d: 75 12 jne 10df31 10df1f: 50 push %eax 10df20: 50 push %eax 10df21: 8b 41 0c mov 0xc(%ecx),%eax 10df24: 52 push %edx 10df25: ff 75 e4 pushl -0x1c(%ebp) 10df28: ff 50 10 call *0x10(%eax) 10df2b: 0f b6 c0 movzbl %al,%eax 10df2e: 83 c4 10 add $0x10,%esp } } else if (rtems_filesystem_is_parent_directory(token, tokenlen)) { rtems_filesystem_location_info_t *currentloc = rtems_filesystem_eval_path_get_currentloc( ctx ); if (is_eval_path_root(ctx, currentloc)) { 10df31: a8 01 test $0x1,%al 10df33: 74 02 je 10df37 10df35: eb 41 jmp 10df78 #include static bool is_fs_root( const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; 10df37: 8b 43 2c mov 0x2c(%ebx),%eax 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 ); 10df3a: 52 push %edx 10df3b: 52 push %edx 10df3c: 8b 50 0c mov 0xc(%eax),%edx 10df3f: ff 70 24 pushl 0x24(%eax) 10df42: ff 75 e4 pushl -0x1c(%ebp) 10df45: 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)) { 10df48: 83 c4 10 add $0x10,%esp 10df4b: 84 c0 test %al,%al 10df4d: 74 32 je 10df81 if (currentloc->mt_entry->mt_point_node != NULL) { 10df4f: 8b 43 2c mov 0x2c(%ebx),%eax 10df52: 83 78 20 00 cmpl $0x0,0x20(%eax) 10df56: 74 20 je 10df78 <== NEVER TAKEN static inline void rtems_filesystem_eval_path_put_back_token( rtems_filesystem_eval_path_context_t *ctx ) { size_t tokenlen = ctx->tokenlen; 10df58: 8b 53 0c mov 0xc(%ebx),%edx ctx->path -= tokenlen; 10df5b: 29 13 sub %edx,(%ebx) ctx->pathlen += tokenlen; 10df5d: 01 53 04 add %edx,0x4(%ebx) ctx->tokenlen = 0; 10df60: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) rtems_filesystem_eval_path_put_back_token(ctx); rtems_filesystem_eval_path_restart( 10df67: 51 push %ecx 10df68: 51 push %ecx 10df69: 83 c0 20 add $0x20,%eax 10df6c: 50 push %eax 10df6d: 53 push %ebx 10df6e: e8 84 99 ff ff call 1078f7 10df73: 83 c4 10 add $0x10,%esp 10df76: eb 59 jmp 10dfd1 ¤tloc->mt_entry->mt_point_node ); status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } else { /* This is the root file system */ status = (*config->eval_token)(ctx, arg, ".", 1); 10df78: 6a 01 push $0x1 10df7a: 68 71 ff 11 00 push $0x11ff71 10df7f: eb 0b jmp 10df8c } } else { status = (*config->eval_token)(ctx, arg, "..", 2); 10df81: 6a 02 push $0x2 10df83: 68 70 ff 11 00 push $0x11ff70 10df88: eb 02 jmp 10df8c } } else { status = (*config->eval_token)(ctx, arg, token, tokenlen); 10df8a: 51 push %ecx 10df8b: 52 push %edx 10df8c: 56 push %esi 10df8d: 53 push %ebx 10df8e: ff 57 04 call *0x4(%edi) 10df91: 83 c4 10 add $0x10,%esp } if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) { 10df94: 83 f8 02 cmp $0x2,%eax 10df97: 75 30 jne 10dfc9 if (rtems_filesystem_eval_path_has_path(ctx)) { 10df99: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10df9d: 74 32 je 10dfd1 int eval_flags; rtems_filesystem_eval_path_eat_delimiter(ctx); 10df9f: 83 ec 0c sub $0xc,%esp 10dfa2: 53 push %ebx 10dfa3: e8 34 00 00 00 call 10dfdc eval_flags = rtems_filesystem_eval_path_get_flags(ctx); if ( 10dfa8: 83 c4 10 add $0x10,%esp 10dfab: f6 43 10 80 testb $0x80,0x10(%ebx) 10dfaf: 74 06 je 10dfb7 (eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0 || rtems_filesystem_eval_path_has_path(ctx) 10dfb1: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10dfb5: 74 1a je 10dfd1 ) { rtems_filesystem_eval_path_error(ctx, ENOENT); 10dfb7: 52 push %edx 10dfb8: 52 push %edx 10dfb9: 6a 02 push $0x2 10dfbb: eb 04 jmp 10dfc1 } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 10dfbd: 50 push %eax 10dfbe: 50 push %eax 10dfbf: 6a 14 push $0x14 10dfc1: 53 push %ebx 10dfc2: e8 f7 95 ff ff call 1075be 10dfc7: eb aa jmp 10df73 ) { rtems_filesystem_eval_path_generic_status status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE; while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) { 10dfc9: 85 c0 test %eax,%eax 10dfcb: 0f 84 bf fe ff ff je 10de90 } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 10dfd1: 8d 65 f4 lea -0xc(%ebp),%esp 10dfd4: 5b pop %ebx 10dfd5: 5e pop %esi 10dfd6: 5f pop %edi 10dfd7: 5d pop %ebp 10dfd8: c3 ret =============================================================================== 0010e00b : } void rtems_filesystem_eval_path_next_token( rtems_filesystem_eval_path_context_t *ctx ) { 10e00b: 55 push %ebp 10e00c: 89 e5 mov %esp,%ebp 10e00e: 56 push %esi 10e00f: 53 push %ebx 10e010: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_filesystem_eval_path_eat_delimiter(ctx); 10e013: 53 push %ebx 10e014: e8 c3 ff ff ff call 10dfdc ctx->pathlen = (size_t) (end - current); } static void next_token(rtems_filesystem_eval_path_context_t *ctx) { const char *begin = ctx->path; 10e019: 8b 13 mov (%ebx),%edx const char *end = begin + ctx->pathlen; 10e01b: 8b 73 04 mov 0x4(%ebx),%esi 10e01e: 01 d6 add %edx,%esi 10e020: 58 pop %eax const char *current = begin; 10e021: 89 d0 mov %edx,%eax 10e023: eb 01 jmp 10e026 while (current != end && !rtems_filesystem_is_delimiter(*current)) { ++current; 10e025: 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)) { 10e026: 39 f0 cmp %esi,%eax 10e028: 75 11 jne 10e03b ++current; } ctx->path = current; 10e02a: 89 03 mov %eax,(%ebx) ctx->pathlen = (size_t) (end - current); 10e02c: 29 c6 sub %eax,%esi 10e02e: 89 73 04 mov %esi,0x4(%ebx) ctx->token = begin; 10e031: 89 53 08 mov %edx,0x8(%ebx) ctx->tokenlen = (size_t) (current - begin); 10e034: 29 d0 sub %edx,%eax 10e036: 89 43 0c mov %eax,0xc(%ebx) 10e039: eb 0e jmp 10e049 { const char *begin = ctx->path; const char *end = begin + ctx->pathlen; const char *current = begin; while (current != end && !rtems_filesystem_is_delimiter(*current)) { 10e03b: 8a 08 mov (%eax),%cl 10e03d: 80 f9 5c cmp $0x5c,%cl 10e040: 74 e8 je 10e02a <== NEVER TAKEN 10e042: 80 f9 2f cmp $0x2f,%cl 10e045: 75 de jne 10e025 10e047: eb e1 jmp 10e02a rtems_filesystem_eval_path_context_t *ctx ) { rtems_filesystem_eval_path_eat_delimiter(ctx); next_token(ctx); } 10e049: 8d 65 f8 lea -0x8(%ebp),%esp 10e04c: 5b pop %ebx 10e04d: 5e pop %esi 10e04e: 5d pop %ebp 10e04f: c3 ret =============================================================================== 0010795a : void rtems_filesystem_eval_path_recursive( rtems_filesystem_eval_path_context_t *ctx, const char *path, size_t pathlen ) { 10795a: 55 push %ebp 10795b: 89 e5 mov %esp,%ebp 10795d: 57 push %edi 10795e: 56 push %esi 10795f: 53 push %ebx 107960: 83 ec 1c sub $0x1c,%esp 107963: 8b 5d 08 mov 0x8(%ebp),%ebx 107966: 8b 4d 0c mov 0xc(%ebp),%ecx 107969: 8b 55 10 mov 0x10(%ebp),%edx if (pathlen > 0) { 10796c: 85 d2 test %edx,%edx 10796e: 74 63 je 1079d3 <== NEVER TAKEN if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) { 107970: 83 7b 14 1f cmpl $0x1f,0x14(%ebx) 107974: 7f 54 jg 1079ca const char *saved_path = ctx->path; 107976: 8b 3b mov (%ebx),%edi size_t saved_pathlen = ctx->pathlen; 107978: 8b 73 04 mov 0x4(%ebx),%esi if (rtems_filesystem_is_delimiter(path [0])) { 10797b: 8a 01 mov (%ecx),%al 10797d: 3c 5c cmp $0x5c,%al 10797f: 74 04 je 107985 <== NEVER TAKEN 107981: 3c 2f cmp $0x2f,%al 107983: 75 1b jne 1079a0 rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc); 107985: 50 push %eax 107986: 50 push %eax 107987: 8d 43 30 lea 0x30(%ebx),%eax 10798a: 50 push %eax 10798b: 53 push %ebx 10798c: 89 55 e0 mov %edx,-0x20(%ebp) 10798f: 89 4d e4 mov %ecx,-0x1c(%ebp) 107992: e8 60 ff ff ff call 1078f7 107997: 83 c4 10 add $0x10,%esp 10799a: 8b 4d e4 mov -0x1c(%ebp),%ecx 10799d: 8b 55 e0 mov -0x20(%ebp),%edx } ctx->path = path; 1079a0: 89 0b mov %ecx,(%ebx) ctx->pathlen = pathlen; 1079a2: 89 53 04 mov %edx,0x4(%ebx) ++ctx->recursionlevel; 1079a5: ff 43 14 incl 0x14(%ebx) while (ctx->pathlen > 0) { 1079a8: eb 10 jmp 1079ba (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx); 1079aa: 83 ec 0c sub $0xc,%esp 1079ad: 8b 43 2c mov 0x2c(%ebx),%eax 1079b0: 8b 40 0c mov 0xc(%eax),%eax 1079b3: 53 push %ebx 1079b4: ff 50 08 call *0x8(%eax) 1079b7: 83 c4 10 add $0x10,%esp ctx->path = path; ctx->pathlen = pathlen; ++ctx->recursionlevel; while (ctx->pathlen > 0) { 1079ba: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 1079be: 75 ea jne 1079aa (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx); } --ctx->recursionlevel; 1079c0: ff 4b 14 decl 0x14(%ebx) ctx->path = saved_path; 1079c3: 89 3b mov %edi,(%ebx) ctx->pathlen = saved_pathlen; 1079c5: 89 73 04 mov %esi,0x4(%ebx) 1079c8: eb 1f jmp 1079e9 } else { rtems_filesystem_eval_path_error(ctx, ELOOP); 1079ca: c7 45 0c 5c 00 00 00 movl $0x5c,0xc(%ebp) 1079d1: eb 07 jmp 1079da } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); 1079d3: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) <== NOT EXECUTED 1079da: 89 5d 08 mov %ebx,0x8(%ebp) } } 1079dd: 8d 65 f4 lea -0xc(%ebp),%esp 1079e0: 5b pop %ebx 1079e1: 5e pop %esi 1079e2: 5f pop %edi 1079e3: 5d pop %ebp ctx->pathlen = saved_pathlen; } else { rtems_filesystem_eval_path_error(ctx, ELOOP); } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); 1079e4: e9 d5 fb ff ff jmp 1075be } } 1079e9: 8d 65 f4 lea -0xc(%ebp),%esp 1079ec: 5b pop %ebx 1079ed: 5e pop %esi 1079ee: 5f pop %edi 1079ef: 5d pop %ebp 1079f0: c3 ret =============================================================================== 00107805 : const char *path, int eval_flags, rtems_filesystem_location_info_t *parentloc, int parent_eval_flags ) { 107805: 55 push %ebp 107806: 89 e5 mov %esp,%ebp 107808: 57 push %edi 107809: 56 push %esi 10780a: 53 push %ebx 10780b: 83 ec 0c sub $0xc,%esp 10780e: 8b 5d 08 mov 0x8(%ebp),%ebx 107811: 8b 55 0c mov 0xc(%ebp),%edx size_t pathlen = strlen(path); 107814: 31 c0 xor %eax,%eax 107816: 83 c9 ff or $0xffffffff,%ecx 107819: 89 d7 mov %edx,%edi 10781b: f2 ae repnz scas %es:(%edi),%al 10781d: f7 d1 not %ecx 10781f: 8d 79 ff lea -0x1(%ecx),%edi 107822: 89 f9 mov %edi,%ecx 107824: eb 11 jmp 107837 #include static size_t get_parentpathlen(const char *path, size_t pathlen) { while (pathlen > 0) { size_t i = pathlen - 1; 107826: 8d 71 ff lea -0x1(%ecx),%esi if (rtems_filesystem_is_delimiter(path [i])) { 107829: 8a 44 0a ff mov -0x1(%edx,%ecx,1),%al 10782d: 3c 5c cmp $0x5c,%al 10782f: 74 60 je 107891 <== NEVER TAKEN 107831: 3c 2f cmp $0x2f,%al 107833: 74 5c je 107891 return pathlen; } pathlen = i; 107835: 89 f1 mov %esi,%ecx #include static size_t get_parentpathlen(const char *path, size_t pathlen) { while (pathlen > 0) { 107837: 85 c9 test %ecx,%ecx 107839: 75 eb jne 107826 size_t parentpathlen = get_parentpathlen(path, pathlen); const char *name = NULL; size_t namelen = 0; const rtems_filesystem_location_info_t *currentloc = NULL; if (pathlen > 0) { 10783b: 85 ff test %edi,%edi 10783d: 74 12 je 107851 if (parentpathlen == 0) { parentpath = "."; parentpathlen = 1; name = path; 10783f: 89 d6 mov %edx,%esi const rtems_filesystem_location_info_t *currentloc = NULL; if (pathlen > 0) { if (parentpathlen == 0) { parentpath = "."; parentpathlen = 1; 107841: b1 01 mov $0x1,%cl size_t namelen = 0; const rtems_filesystem_location_info_t *currentloc = NULL; if (pathlen > 0) { if (parentpathlen == 0) { parentpath = "."; 107843: ba 71 ff 11 00 mov $0x11ff71,%edx 107848: eb 0d jmp 107857 parentpathlen = 1; name = path; namelen = pathlen; } else { name = path + parentpathlen; 10784a: 8d 34 0a lea (%edx,%ecx,1),%esi namelen = pathlen - parentpathlen; 10784d: 29 cf sub %ecx,%edi 10784f: eb 06 jmp 107857 { size_t pathlen = strlen(path); const char *parentpath = path; size_t parentpathlen = get_parentpathlen(path, pathlen); const char *name = NULL; size_t namelen = 0; 107851: 31 ff xor %edi,%edi ) { size_t pathlen = strlen(path); const char *parentpath = path; size_t parentpathlen = get_parentpathlen(path, pathlen); const char *name = NULL; 107853: 31 f6 xor %esi,%esi } pathlen = i; } return 0; 107855: 31 c9 xor %ecx,%ecx ctx, parentpath, parentpathlen, parent_eval_flags, &rtems_filesystem_root, &rtems_filesystem_current 107857: a1 14 c1 12 00 mov 0x12c114,%eax name = path + parentpathlen; namelen = pathlen - parentpathlen; } } currentloc = eval_path_start( 10785c: 83 ec 04 sub $0x4,%esp 10785f: 50 push %eax ctx, parentpath, parentpathlen, parent_eval_flags, &rtems_filesystem_root, 107860: 83 c0 04 add $0x4,%eax name = path + parentpathlen; namelen = pathlen - parentpathlen; } } currentloc = eval_path_start( 107863: 50 push %eax 107864: ff 75 18 pushl 0x18(%ebp) 107867: 89 d8 mov %ebx,%eax 107869: e8 79 fe ff ff call 1076e7 parent_eval_flags, &rtems_filesystem_root, &rtems_filesystem_current ); rtems_filesystem_location_clone(parentloc, currentloc); 10786e: 5a pop %edx 10786f: 59 pop %ecx 107870: 50 push %eax 107871: ff 75 14 pushl 0x14(%ebp) 107874: e8 cf 60 00 00 call 10d948 ctx->path = name; 107879: 89 33 mov %esi,(%ebx) ctx->pathlen = namelen; 10787b: 89 7b 04 mov %edi,0x4(%ebx) ctx->flags = eval_flags; 10787e: 8b 45 10 mov 0x10(%ebp),%eax 107881: 89 43 10 mov %eax,0x10(%ebx) rtems_filesystem_eval_path_continue(ctx); 107884: 89 1c 24 mov %ebx,(%esp) 107887: e8 ff fd ff ff call 10768b return &ctx->currentloc; 10788c: 8d 43 18 lea 0x18(%ebx),%eax 10788f: eb 08 jmp 107899 ) { size_t pathlen = strlen(path); const char *parentpath = path; size_t parentpathlen = get_parentpathlen(path, pathlen); const char *name = NULL; 107891: 31 f6 xor %esi,%esi size_t namelen = 0; const rtems_filesystem_location_info_t *currentloc = NULL; if (pathlen > 0) { 107893: 85 ff test %edi,%edi 107895: 74 c0 je 107857 <== NEVER TAKEN 107897: eb b1 jmp 10784a ctx->flags = eval_flags; rtems_filesystem_eval_path_continue(ctx); return &ctx->currentloc; } 107899: 8d 65 f4 lea -0xc(%ebp),%esp 10789c: 5b pop %ebx 10789d: 5e pop %esi 10789e: 5f pop %edi 10789f: 5d pop %ebp 1078a0: c3 ret =============================================================================== 0010dc8f : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 10dc8f: 55 push %ebp 10dc90: 89 e5 mov %esp,%ebp 10dc92: 83 ec 18 sub $0x18,%esp 10dc95: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 10dc98: 89 45 f0 mov %eax,-0x10(%ebp) 10dc9b: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 10dca2: 85 c0 test %eax,%eax 10dca4: 74 13 je 10dcb9 <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 10dca6: 50 push %eax 10dca7: 50 push %eax 10dca8: 8d 45 f0 lea -0x10(%ebp),%eax 10dcab: 50 push %eax 10dcac: 68 b8 db 10 00 push $0x10dbb8 10dcb1: e8 62 ff ff ff call 10dc18 10dcb6: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 10dcb9: 8b 45 f4 mov -0xc(%ebp),%eax 10dcbc: c9 leave 10dcbd: c3 ret =============================================================================== 001064c8 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 1064c8: 55 push %ebp 1064c9: 89 e5 mov %esp,%ebp 1064cb: 83 ec 14 sub $0x14,%esp int rv = 0; const rtems_filesystem_mount_configuration *root_config = &rtems_filesystem_root_configuration; rv = mount( 1064ce: ff 35 94 df 11 00 pushl 0x11df94 1064d4: ff 35 90 df 11 00 pushl 0x11df90 1064da: ff 35 8c df 11 00 pushl 0x11df8c 1064e0: ff 35 88 df 11 00 pushl 0x11df88 1064e6: ff 35 84 df 11 00 pushl 0x11df84 1064ec: e8 bb 06 00 00 call 106bac root_config->target, root_config->filesystemtype, root_config->options, root_config->data ); if ( rv != 0 ) 1064f1: 83 c4 20 add $0x20,%esp 1064f4: 85 c0 test %eax,%eax 1064f6: 74 0a je 106502 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); 1064f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1064fb: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 106500: eb 20 jmp 106522 <== NOT EXECUTED * * 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); 106502: 50 push %eax 106503: 50 push %eax 106504: 68 ff 01 00 00 push $0x1ff 106509: 68 ac f3 11 00 push $0x11f3ac 10650e: e8 81 05 00 00 call 106a94 if ( rv != 0 ) 106513: 83 c4 10 add $0x10,%esp 106516: 85 c0 test %eax,%eax 106518: 74 0d je 106527 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0003 ); 10651a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10651d: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 106522: e8 8d 3e 00 00 call 10a3b4 <== NOT EXECUTED * 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. */ } 106527: c9 leave 106528: c3 ret =============================================================================== 0010dc18 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10dc18: 55 push %ebp 10dc19: 89 e5 mov %esp,%ebp 10dc1b: 57 push %edi 10dc1c: 56 push %esi 10dc1d: 53 push %ebx 10dc1e: 83 ec 1c sub $0x1c,%esp 10dc21: 8b 5d 08 mov 0x8(%ebp),%ebx 10dc24: 8b 75 0c mov 0xc(%ebp),%esi const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; 10dc27: 31 c0 xor %eax,%eax bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; 10dc29: bf 98 df 11 00 mov $0x11df98,%edi rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10dc2e: eb 0c jmp 10dc3c stop = (*routine)( table_entry, routine_arg ); 10dc30: 51 push %ecx 10dc31: 51 push %ecx 10dc32: 56 push %esi 10dc33: 57 push %edi 10dc34: ff d3 call *%ebx ++table_entry; 10dc36: 83 c7 08 add $0x8,%edi 10dc39: 83 c4 10 add $0x10,%esp { const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10dc3c: 83 3f 00 cmpl $0x0,(%edi) 10dc3f: 74 06 je 10dc47 10dc41: 84 c0 test %al,%al 10dc43: 74 eb je 10dc30 10dc45: eb 40 jmp 10dc87 stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 10dc47: 84 c0 test %al,%al 10dc49: 75 3c jne 10dc87 rtems_libio_lock(); 10dc4b: 88 45 e4 mov %al,-0x1c(%ebp) 10dc4e: e8 95 ff ff ff call 10dbe8 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10dc53: 8b 3d b0 c1 12 00 mov 0x12c1b0,%edi for ( 10dc59: 8a 45 e4 mov -0x1c(%ebp),%al 10dc5c: eb 0e jmp 10dc6c !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); 10dc5e: 52 push %edx 10dc5f: 52 push %edx 10dc60: 56 push %esi 10dc61: 8d 47 08 lea 0x8(%edi),%eax 10dc64: 50 push %eax 10dc65: ff d3 call *%ebx } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10dc67: 8b 3f mov (%edi),%edi 10dc69: 83 c4 10 add $0x10,%esp ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10dc6c: 81 ff b4 c1 12 00 cmp $0x12c1b4,%edi 10dc72: 75 0d jne 10dc81 ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); } rtems_libio_unlock(); 10dc74: 88 45 e4 mov %al,-0x1c(%ebp) 10dc77: e8 86 ff ff ff call 10dc02 10dc7c: 8a 45 e4 mov -0x1c(%ebp),%al 10dc7f: eb 06 jmp 10dc87 if ( !stop ) { rtems_libio_lock(); for ( node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 10dc81: 84 c0 test %al,%al 10dc83: 74 d9 je 10dc5e <== ALWAYS TAKEN 10dc85: eb ed jmp 10dc74 <== NOT EXECUTED } rtems_libio_unlock(); } return stop; } 10dc87: 8d 65 f4 lea -0xc(%ebp),%esp 10dc8a: 5b pop %ebx 10dc8b: 5e pop %esi 10dc8c: 5f pop %edi 10dc8d: 5d pop %ebp 10dc8e: c3 ret =============================================================================== 00107b0a : } void rtems_filesystem_location_remove_from_mt_entry( rtems_filesystem_location_info_t *loc ) { 107b0a: 55 push %ebp 107b0b: 89 e5 mov %esp,%ebp 107b0d: 56 push %esi 107b0e: 53 push %ebx 107b0f: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_filesystem_mt_entry_declare_lock_context(lock_context); bool do_unmount; rtems_filesystem_mt_entry_lock(lock_context); 107b12: 9c pushf 107b13: fa cli 107b14: 5e pop %esi ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 107b15: 8b 13 mov (%ebx),%edx previous = the_node->previous; 107b17: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 107b1a: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 107b1d: 89 10 mov %edx,(%eax) rtems_chain_extract_unprotected(&loc->mt_entry_node); do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry); 107b1f: 8b 43 14 mov 0x14(%ebx),%eax 107b22: e8 cd fe ff ff call 1079f4 rtems_filesystem_mt_entry_unlock(lock_context); 107b27: 56 push %esi 107b28: 9d popf if (do_unmount) { 107b29: 84 c0 test %al,%al 107b2b: 74 0e je 107b3b <== ALWAYS TAKEN rtems_filesystem_do_unmount(loc->mt_entry); 107b2d: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 107b30: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 107b33: 5b pop %ebx <== NOT EXECUTED 107b34: 5e pop %esi <== NOT EXECUTED 107b35: 5d pop %ebp <== 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); 107b36: e9 5a ff ff ff jmp 107a95 <== NOT EXECUTED } } 107b3b: 5b pop %ebx 107b3c: 5e pop %esi 107b3d: 5d pop %ebp 107b3e: c3 ret =============================================================================== 00107cb2 : } rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global( rtems_filesystem_location_info_t *loc ) { 107cb2: 55 push %ebp 107cb3: 89 e5 mov %esp,%ebp 107cb5: 56 push %esi 107cb6: 53 push %ebx 107cb7: 83 ec 1c sub $0x1c,%esp 107cba: 8b 75 08 mov 0x8(%ebp),%esi rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc)); 107cbd: 6a 24 push $0x24 107cbf: e8 30 ed ff ff call 1069f4 107cc4: 89 c3 mov %eax,%ebx if (global_loc != NULL) { 107cc6: 83 c4 10 add $0x10,%esp 107cc9: 85 c0 test %eax,%eax 107ccb: 74 28 je 107cf5 <== NEVER TAKEN global_loc->reference_count = 1; 107ccd: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) global_loc->deferred_released_next = NULL; 107cd4: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) global_loc->deferred_released_count = 0; 107cdb: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) rtems_filesystem_location_copy(&global_loc->location, loc); 107ce2: 50 push %eax 107ce3: 50 push %eax 107ce4: 56 push %esi 107ce5: 53 push %ebx 107ce6: e8 46 fd ff ff call 107a31 rtems_filesystem_location_remove_from_mt_entry(loc); 107ceb: 89 34 24 mov %esi,(%esp) 107cee: e8 17 fe ff ff call 107b0a 107cf3: eb 28 jmp 107d1d } else { rtems_filesystem_location_free(loc); 107cf5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107cf8: 56 push %esi <== NOT EXECUTED 107cf9: e8 96 5c 00 00 call 10d994 <== NOT EXECUTED ); static inline rtems_filesystem_global_location_t * rtems_filesystem_global_location_obtain_null(void) { rtems_filesystem_global_location_t *global_loc = NULL; 107cfe: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED return rtems_filesystem_global_location_obtain( &global_loc ); 107d05: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 107d08: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 107d0b: e8 1b ff ff ff call 107c2b <== NOT EXECUTED 107d10: 89 c3 mov %eax,%ebx <== NOT EXECUTED global_loc = rtems_filesystem_global_location_obtain_null(); errno = ENOMEM; 107d12: e8 c5 91 00 00 call 110edc <__errno> <== NOT EXECUTED 107d17: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107d1d: 83 c4 10 add $0x10,%esp } return global_loc; } 107d20: 89 d8 mov %ebx,%eax 107d22: 8d 65 f8 lea -0x8(%ebp),%esp 107d25: 5b pop %ebx 107d26: 5e pop %esi 107d27: 5d pop %ebp 107d28: c3 ret =============================================================================== 00106db8 : int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) { 106db8: 55 push %ebp 106db9: 89 e5 mov %esp,%ebp 106dbb: 56 push %esi 106dbc: 53 push %ebx 106dbd: 8b 75 0c mov 0xc(%ebp),%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 ) ); 106dc0: 83 ec 0c sub $0xc,%esp 106dc3: 6a 08 push $0x8 106dc5: e8 82 03 00 00 call 10714c 106dca: 89 c3 mov %eax,%ebx *key = new_key; 106dcc: 8b 45 08 mov 0x8(%ebp),%eax 106dcf: 89 18 mov %ebx,(%eax) new_key->val = NULL; 106dd1: c7 03 00 00 00 00 movl $0x0,(%ebx) new_key->dtor = dtor; 106dd7: 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 ); 106dda: 83 c4 0c add $0xc,%esp 106ddd: 56 push %esi 106dde: 53 push %ebx 106ddf: 6a 00 push $0x0 106de1: e8 3a 3c 00 00 call 10aa20 if ( status == RTEMS_SUCCESSFUL ) 106de6: 83 c4 10 add $0x10,%esp return 0; 106de9: 31 d2 xor %edx,%edx ); #endif /* 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 ) 106deb: 85 c0 test %eax,%eax 106ded: 74 0f je 106dfe <== ALWAYS TAKEN return 0; free( new_key ); 106def: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106df2: 53 push %ebx <== NOT EXECUTED 106df3: e8 5c fe ff ff call 106c54 <== NOT EXECUTED return -1; 106df8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106dfb: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED } 106dfe: 89 d0 mov %edx,%eax 106e00: 8d 65 f8 lea -0x8(%ebp),%esp 106e03: 5b pop %ebx 106e04: 5e pop %esi 106e05: 5d pop %ebp 106e06: c3 ret =============================================================================== 00106e17 : int rtems_gxx_key_delete (__gthread_key_t key) { 106e17: 55 push %ebp 106e18: 89 e5 mov %esp,%ebp 106e1a: 53 push %ebx 106e1b: 83 ec 0c sub $0xc,%esp 106e1e: 8b 5d 08 mov 0x8(%ebp),%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 ); 106e21: 53 push %ebx 106e22: 6a 00 push $0x0 106e24: e8 8f 3c 00 00 call 10aab8 if ( status == RTEMS_SUCCESSFUL ) { 106e29: 83 c4 10 add $0x10,%esp 106e2c: 85 c0 test %eax,%eax 106e2e: 75 11 jne 106e41 <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 106e30: 85 db test %ebx,%ebx 106e32: 74 0d je 106e41 <== NEVER TAKEN 106e34: 83 ec 0c sub $0xc,%esp 106e37: ff 33 pushl (%ebx) 106e39: e8 16 fe ff ff call 106c54 106e3e: 83 c4 10 add $0x10,%esp return 0; } key = NULL; return 0; } 106e41: 31 c0 xor %eax,%eax 106e43: 8b 5d fc mov -0x4(%ebp),%ebx 106e46: c9 leave 106e47: c3 ret =============================================================================== 00106d60 : /* 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)) { 106d60: 55 push %ebp 106d61: 89 e5 mov %esp,%ebp 106d63: 57 push %edi 106d64: 56 push %esi 106d65: 53 push %ebx 106d66: 83 ec 1c sub $0x1c,%esp 106d69: 8b 5d 08 mov 0x8(%ebp),%ebx #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: once=%x, func=%x\n", *once, func ); #endif if ( *(volatile __gthread_once_t *)once == 0 ) { 106d6c: 8b 03 mov (%ebx),%eax 106d6e: 85 c0 test %eax,%eax 106d70: 75 3c jne 106dae rtems_mode saveMode; __gthread_once_t o; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 106d72: 52 push %edx 106d73: 8d 7d e4 lea -0x1c(%ebp),%edi 106d76: 57 push %edi 106d77: 68 00 01 00 00 push $0x100 106d7c: 68 00 01 00 00 push $0x100 106d81: e8 16 3b 00 00 call 10a89c if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 106d86: 8b 33 mov (%ebx),%esi 106d88: 83 c4 10 add $0x10,%esp 106d8b: 85 f6 test %esi,%esi 106d8d: 75 06 jne 106d95 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 106d8f: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 106d95: 50 push %eax 106d96: 57 push %edi 106d97: 68 00 01 00 00 push $0x100 106d9c: ff 75 e4 pushl -0x1c(%ebp) 106d9f: e8 f8 3a 00 00 call 10a89c if ( o == 0 ) 106da4: 83 c4 10 add $0x10,%esp 106da7: 85 f6 test %esi,%esi 106da9: 75 03 jne 106dae <== NEVER TAKEN (*func)(); 106dab: ff 55 0c call *0xc(%ebp) } return 0; } 106dae: 31 c0 xor %eax,%eax 106db0: 8d 65 f4 lea -0xc(%ebp),%esp 106db3: 5b pop %ebx 106db4: 5e pop %esi 106db5: 5f pop %edi 106db6: 5d pop %ebp 106db7: c3 ret =============================================================================== 00106ea0 : int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 106ea0: 55 push %ebp 106ea1: 89 e5 mov %esp,%ebp 106ea3: 53 push %ebx 106ea4: 83 ec 08 sub $0x8,%esp 106ea7: 8b 5d 08 mov 0x8(%ebp),%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 ); 106eaa: ff 73 04 pushl 0x4(%ebx) 106ead: 53 push %ebx 106eae: 6a 00 push $0x0 106eb0: e8 6b 3b 00 00 call 10aa20 if ( status == RTEMS_SUCCESSFUL ) { 106eb5: 83 c4 10 add $0x10,%esp 106eb8: 85 c0 test %eax,%eax 106eba: 75 09 jne 106ec5 <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 106ebc: 8b 45 0c mov 0xc(%ebp),%eax 106ebf: 89 03 mov %eax,(%ebx) return 0; 106ec1: 31 c0 xor %eax,%eax 106ec3: eb 03 jmp 106ec8 } return -1; 106ec5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 106ec8: 8b 5d fc mov -0x4(%ebp),%ebx 106ecb: c9 leave 106ecc: c3 ret =============================================================================== 00109ad0 : void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) { 109ad0: 55 push %ebp 109ad1: 89 e5 mov %esp,%ebp 109ad3: 83 ec 08 sub $0x8,%esp if ( 109ad6: 83 3d f0 3d 13 00 03 cmpl $0x3,0x133df0 109add: 74 1e je 109afd <== ALWAYS TAKEN && !malloc_is_system_state_OK() ) { return NULL; } malloc_deferred_frees_process(); 109adf: e8 97 f1 ff ff call 108c7b /* FIXME: Statistics, boundary checks */ return _Protected_heap_Allocate_aligned_with_boundary( 109ae4: ff 75 10 pushl 0x10(%ebp) 109ae7: ff 75 0c pushl 0xc(%ebp) 109aea: ff 75 08 pushl 0x8(%ebp) 109aed: ff 35 30 f2 12 00 pushl 0x12f230 109af3: e8 34 4a 00 00 call 10e52c <_Protected_heap_Allocate_aligned_with_boundary> 109af8: 83 c4 10 add $0x10,%esp 109afb: eb 0b jmp 109b08 uintptr_t boundary ) { if ( _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 109afd: e8 3a f1 ff ff call 108c3c 109b02: 84 c0 test %al,%al 109b04: 75 d9 jne 109adf ) { return NULL; 109b06: 31 c0 xor %eax,%eax RTEMS_Malloc_Heap, size, alignment, boundary ); } 109b08: c9 leave 109b09: c3 ret =============================================================================== 0010c020 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c020: 55 push %ebp 10c021: 89 e5 mov %esp,%ebp 10c023: 57 push %edi 10c024: 56 push %esi 10c025: 53 push %ebx 10c026: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c029: bb 01 00 00 00 mov $0x1,%ebx 10c02e: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10c032: 74 3a je 10c06e #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10c034: 8b 04 9d 3c 0e 13 00 mov 0x130e3c(,%ebx,4),%eax 10c03b: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c03e: be 01 00 00 00 mov $0x1,%esi 10c043: 85 ff test %edi,%edi 10c045: 75 1d jne 10c064 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c047: 43 inc %ebx 10c048: 83 fb 04 cmp $0x4,%ebx 10c04b: eb e5 jmp 10c032 information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c04d: 8b 57 1c mov 0x1c(%edi),%edx 10c050: 8b 14 b2 mov (%edx,%esi,4),%edx if ( !the_thread ) 10c053: 85 d2 test %edx,%edx 10c055: 74 0c je 10c063 <== NEVER TAKEN continue; (*routine)(the_thread); 10c057: 83 ec 0c sub $0xc,%esp 10c05a: 52 push %edx 10c05b: 8b 45 08 mov 0x8(%ebp),%eax 10c05e: ff d0 call *%eax 10c060: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c063: 46 inc %esi 10c064: 0f b7 57 10 movzwl 0x10(%edi),%edx 10c068: 39 d6 cmp %edx,%esi 10c06a: 76 e1 jbe 10c04d 10c06c: eb d9 jmp 10c047 (*routine)(the_thread); } } } 10c06e: 8d 65 f4 lea -0xc(%ebp),%esp 10c071: 5b pop %ebx 10c072: 5e pop %esi 10c073: 5f pop %edi 10c074: 5d pop %ebp 10c075: c3 ret =============================================================================== 00106840 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 106840: 55 push %ebp 106841: 89 e5 mov %esp,%ebp 106843: 53 push %ebx 106844: 52 push %edx rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 106845: 8b 1d 70 a2 12 00 mov 0x12a270,%ebx 10684b: 85 db test %ebx,%ebx 10684d: 74 3e je 10688d <== NEVER TAKEN { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 10684f: 50 push %eax 106850: 50 push %eax 106851: 6a 30 push $0x30 106853: 53 push %ebx 106854: e8 d3 fc ff ff call 10652c 106859: a3 d0 e2 12 00 mov %eax,0x12e2d0 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 10685e: 83 c4 10 add $0x10,%esp 106861: 85 c0 test %eax,%eax 106863: 75 07 jne 10686c rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 106865: 83 ec 0c sub $0xc,%esp 106868: 6a 1a push $0x1a 10686a: eb 44 jmp 1068b0 iop = rtems_libio_iop_freelist = rtems_libio_iops; 10686c: a3 d4 e2 12 00 mov %eax,0x12e2d4 for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 106871: 89 c1 mov %eax,%ecx 106873: 31 d2 xor %edx,%edx 106875: eb 06 jmp 10687d iop->data1 = iop + 1; 106877: 83 c1 30 add $0x30,%ecx 10687a: 89 49 fc mov %ecx,-0x4(%ecx) 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++) 10687d: 42 inc %edx 10687e: 39 da cmp %ebx,%edx 106880: 75 f5 jne 106877 iop->data1 = iop + 1; iop->data1 = NULL; 106882: 6b d2 30 imul $0x30,%edx,%edx 106885: c7 44 10 fc 00 00 00 movl $0x0,-0x4(%eax,%edx,1) 10688c: 00 /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 10688d: 83 ec 0c sub $0xc,%esp 106890: 68 d8 e2 12 00 push $0x12e2d8 106895: 6a 00 push $0x0 106897: 6a 54 push $0x54 106899: 6a 01 push $0x1 10689b: 68 4f 49 42 4c push $0x4c42494f 1068a0: e8 bb 32 00 00 call 109b60 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 1068a5: 83 c4 20 add $0x20,%esp 1068a8: 85 c0 test %eax,%eax 1068aa: 74 09 je 1068b5 <== ALWAYS TAKEN rtems_fatal_error_occurred( rc ); 1068ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1068af: 50 push %eax <== NOT EXECUTED 1068b0: e8 ff 3a 00 00 call 10a3b4 /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 1068b5: a1 74 a2 12 00 mov 0x12a274,%eax 1068ba: 85 c0 test %eax,%eax 1068bc: 74 06 je 1068c4 (* rtems_fs_init_helper)(); } 1068be: 8b 5d fc mov -0x4(%ebp),%ebx 1068c1: c9 leave /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 1068c2: ff e0 jmp *%eax } 1068c4: 8b 5d fc mov -0x4(%ebp),%ebx 1068c7: c9 leave 1068c8: c3 ret =============================================================================== 00105207 : } rtems_status_code rtems_libio_set_private_env(void) { 105207: 55 push %ebp 105208: 89 e5 mov %esp,%ebp 10520a: 57 push %edi 10520b: 56 push %esi 10520c: 53 push %ebx 10520d: 83 ec 1c sub $0x1c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id self_task_id = rtems_task_self(); 105210: e8 fb 14 00 00 call 106710 105215: 89 c2 mov %eax,%edx rtems_user_env_t *old_env = rtems_current_user_env; 105217: a1 5c 7b 12 00 mov 0x127b5c,%eax 10521c: 89 45 e4 mov %eax,-0x1c(%ebp) bool uses_global_env = old_env == &rtems_global_user_env; bool uses_shared_env = old_env->task_id != self_task_id; if (uses_global_env || uses_shared_env) { 10521f: 39 50 24 cmp %edx,0x24(%eax) 105222: 75 0d jne 105231 _Thread_Enable_dispatch(); } rtems_status_code rtems_libio_set_private_env(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; 105224: 31 f6 xor %esi,%esi rtems_id self_task_id = rtems_task_self(); rtems_user_env_t *old_env = rtems_current_user_env; bool uses_global_env = old_env == &rtems_global_user_env; bool uses_shared_env = old_env->task_id != self_task_id; if (uses_global_env || uses_shared_env) { 105226: 3d 60 7b 12 00 cmp $0x127b60,%eax 10522b: 0f 85 b1 00 00 00 jne 1052e2 <== ALWAYS TAKEN rtems_user_env_t *new_env = calloc(1, sizeof(*new_env)); 105231: 57 push %edi 105232: 57 push %edi 105233: 6a 2c push $0x2c 105235: 6a 01 push $0x1 105237: 89 55 e0 mov %edx,-0x20(%ebp) 10523a: e8 61 41 00 00 call 1093a0 10523f: 89 c3 mov %eax,%ebx if (new_env != NULL) { 105241: 83 c4 10 add $0x10,%esp if (sc != RTEMS_SUCCESSFUL) { free_user_env(new_env); } } else { sc = RTEMS_NO_MEMORY; 105244: be 1a 00 00 00 mov $0x1a,%esi bool uses_shared_env = old_env->task_id != self_task_id; if (uses_global_env || uses_shared_env) { rtems_user_env_t *new_env = calloc(1, sizeof(*new_env)); if (new_env != NULL) { 105249: 85 c0 test %eax,%eax 10524b: 8b 55 e0 mov -0x20(%ebp),%edx 10524e: 0f 84 8e 00 00 00 je 1052e2 *new_env = *old_env; 105254: b9 0b 00 00 00 mov $0xb,%ecx 105259: 89 c7 mov %eax,%edi 10525b: 8b 75 e4 mov -0x1c(%ebp),%esi 10525e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) new_env->reference_count = 1; 105260: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax) new_env->task_id = self_task_id; 105267: 89 50 24 mov %edx,0x24(%eax) new_env->root_directory = rtems_filesystem_global_location_obtain(&old_env->root_directory); 10526a: 83 ec 0c sub $0xc,%esp 10526d: 8b 45 e4 mov -0x1c(%ebp),%eax 105270: 83 c0 04 add $0x4,%eax 105273: 50 push %eax 105274: e8 aa 09 00 00 call 105c23 if (new_env != NULL) { *new_env = *old_env; new_env->reference_count = 1; new_env->task_id = self_task_id; new_env->root_directory = 105279: 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); 10527c: 5e pop %esi 10527d: ff 75 e4 pushl -0x1c(%ebp) 105280: e8 9e 09 00 00 call 105c23 *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 = 105285: 89 03 mov %eax,(%ebx) rtems_fatal_error_occurred(0xdeadbeef); } rtems_current_user_env = &rtems_global_user_env; } } 105287: 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 ( 10528a: 83 c4 10 add $0x10,%esp 10528d: 81 7a 10 24 d6 11 00 cmpl $0x11d624,0x10(%edx) 105294: 74 34 je 1052ca !rtems_filesystem_global_location_is_null(new_env->root_directory) && !rtems_filesystem_global_location_is_null(new_env->current_directory) 105296: 81 78 10 24 d6 11 00 cmpl $0x11d624,0x10(%eax) 10529d: 74 2b je 1052ca <== NEVER TAKEN ) { sc = rtems_task_variable_add( 10529f: 51 push %ecx 1052a0: 68 9c 51 10 00 push $0x10519c 1052a5: 68 5c 7b 12 00 push $0x127b5c 1052aa: 6a 00 push $0x0 1052ac: e8 d3 14 00 00 call 106784 1052b1: 89 c6 mov %eax,%esi RTEMS_SELF, (void **) &rtems_current_user_env, free_user_env ); if (sc == RTEMS_SUCCESSFUL) { 1052b3: 83 c4 10 add $0x10,%esp 1052b6: 85 c0 test %eax,%eax 1052b8: 75 17 jne 1052d1 free_user_env_protected(old_env); 1052ba: 8b 45 e4 mov -0x1c(%ebp),%eax 1052bd: e8 1d ff ff ff call 1051df rtems_current_user_env = new_env; 1052c2: 89 1d 5c 7b 12 00 mov %ebx,0x127b5c 1052c8: eb 18 jmp 1052e2 } else { sc = RTEMS_TOO_MANY; } } else { sc = RTEMS_UNSATISFIED; 1052ca: be 0d 00 00 00 mov $0xd,%esi 1052cf: eb 05 jmp 1052d6 ); if (sc == RTEMS_SUCCESSFUL) { free_user_env_protected(old_env); rtems_current_user_env = new_env; } else { sc = RTEMS_TOO_MANY; 1052d1: be 05 00 00 00 mov $0x5,%esi } else { sc = RTEMS_UNSATISFIED; } if (sc != RTEMS_SUCCESSFUL) { free_user_env(new_env); 1052d6: 83 ec 0c sub $0xc,%esp 1052d9: 53 push %ebx 1052da: e8 bd fe ff ff call 10519c 1052df: 83 c4 10 add $0x10,%esp sc = RTEMS_NO_MEMORY; } } return sc; } 1052e2: 89 f0 mov %esi,%eax 1052e4: 8d 65 f4 lea -0xc(%ebp),%esp 1052e7: 5b pop %ebx 1052e8: 5e pop %esi 1052e9: 5f pop %edi 1052ea: 5d pop %ebp 1052eb: c3 ret =============================================================================== 001052ec : rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { 1052ec: 55 push %ebp 1052ed: 89 e5 mov %esp,%ebp 1052ef: 53 push %ebx 1052f0: 83 ec 14 sub $0x14,%esp 1052f3: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id self_task_id = rtems_task_self(); 1052f6: e8 15 14 00 00 call 106710 if (task_id != RTEMS_SELF && self_task_id != task_id) { 1052fb: 39 d8 cmp %ebx,%eax 1052fd: 0f 84 81 00 00 00 je 105384 105303: 85 db test %ebx,%ebx 105305: 74 7d je 105384 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 105307: a1 fc b2 12 00 mov 0x12b2fc,%eax 10530c: 40 inc %eax 10530d: a3 fc b2 12 00 mov %eax,0x12b2fc return _Thread_Dispatch_disable_level; 105312: a1 fc b2 12 00 mov 0x12b2fc,%eax /* * We have to disable the thread dispatching to prevent deletion of the * environment in the meantime. */ _Thread_Disable_dispatch(); sc = rtems_task_variable_get( 105317: 50 push %eax task_id, (void *) &rtems_current_user_env, (void *) &env 105318: 8d 45 f4 lea -0xc(%ebp),%eax /* * We have to disable the thread dispatching to prevent deletion of the * environment in the meantime. */ _Thread_Disable_dispatch(); sc = rtems_task_variable_get( 10531b: 50 push %eax 10531c: 68 5c 7b 12 00 push $0x127b5c 105321: 53 push %ebx 105322: e8 71 15 00 00 call 106898 105327: 89 c3 mov %eax,%ebx task_id, (void *) &rtems_current_user_env, (void *) &env ); if (sc == RTEMS_SUCCESSFUL) { 105329: 83 c4 10 add $0x10,%esp 10532c: 85 c0 test %eax,%eax 10532e: 75 08 jne 105338 ++env->reference_count; 105330: 8b 45 f4 mov -0xc(%ebp),%eax 105333: ff 40 28 incl 0x28(%eax) 105336: eb 05 jmp 10533d } else { sc = RTEMS_UNSATISFIED; 105338: bb 0d 00 00 00 mov $0xd,%ebx } _Thread_Enable_dispatch(); 10533d: e8 8a 2e 00 00 call 1081cc <_Thread_Enable_dispatch> if (sc == RTEMS_SUCCESSFUL) { 105342: 85 db test %ebx,%ebx 105344: 75 40 jne 105386 sc = rtems_task_variable_add( 105346: 50 push %eax 105347: 68 9c 51 10 00 push $0x10519c 10534c: 68 5c 7b 12 00 push $0x127b5c 105351: 6a 00 push $0x0 105353: e8 2c 14 00 00 call 106784 105358: 89 c3 mov %eax,%ebx RTEMS_SELF, (void **) &rtems_current_user_env, free_user_env ); if (sc == RTEMS_SUCCESSFUL) { 10535a: 83 c4 10 add $0x10,%esp 10535d: 85 c0 test %eax,%eax 10535f: 75 14 jne 105375 <== NEVER TAKEN free_user_env_protected(rtems_current_user_env); 105361: a1 5c 7b 12 00 mov 0x127b5c,%eax 105366: e8 74 fe ff ff call 1051df rtems_current_user_env = env; 10536b: 8b 45 f4 mov -0xc(%ebp),%eax 10536e: a3 5c 7b 12 00 mov %eax,0x127b5c 105373: eb 11 jmp 105386 } else { free_user_env_protected(env); 105375: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 105378: e8 62 fe ff ff call 1051df <== NOT EXECUTED sc = RTEMS_TOO_MANY; 10537d: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED 105382: eb 02 jmp 105386 <== NOT EXECUTED return sc; } rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { rtems_status_code sc = RTEMS_SUCCESSFUL; 105384: 31 db xor %ebx,%ebx } } } return sc; } 105386: 89 d8 mov %ebx,%eax 105388: 8b 5d fc mov -0x4(%ebp),%ebx 10538b: c9 leave 10538c: c3 ret =============================================================================== 0010dad4 : * * Convert RTEMS internal flags to UNIX fnctl(2) flags */ int rtems_libio_to_fcntl_flags( uint32_t flags ) { 10dad4: 55 push %ebp 10dad5: 89 e5 mov %esp,%ebp 10dad7: 8b 55 08 mov 0x8(%ebp),%edx int fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10dada: 89 d0 mov %edx,%eax 10dadc: 83 e0 06 and $0x6,%eax 10dadf: 83 f8 06 cmp $0x6,%eax 10dae2: 74 11 je 10daf5 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { fcntl_flags |= O_RDONLY; 10dae4: 31 c0 xor %eax,%eax { 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) { 10dae6: f6 c2 02 test $0x2,%dl 10dae9: 75 0f jne 10dafa <== ALWAYS TAKEN fcntl_flags |= O_RDONLY; } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) { 10daeb: 89 d0 mov %edx,%eax <== NOT EXECUTED 10daed: 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; 10daf0: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10daf3: eb 05 jmp 10dafa <== NOT EXECUTED 10daf5: b8 02 00 00 00 mov $0x2,%eax 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 ) { 10dafa: f6 c2 01 test $0x1,%dl 10dafd: 74 03 je 10db02 fcntl_flags |= O_NONBLOCK; 10daff: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10db02: f6 c6 02 test $0x2,%dh 10db05: 74 03 je 10db0a fcntl_flags |= O_APPEND; 10db07: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10db0a: 80 e6 04 and $0x4,%dh 10db0d: 74 03 je 10db12 fcntl_flags |= O_CREAT; 10db0f: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10db12: 5d pop %ebp 10db13: c3 ret =============================================================================== 0010538d : { 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) { 10538d: 81 3d 5c 7b 12 00 60 cmpl $0x127b60,0x127b5c 105394: 7b 12 00 105397: 74 31 je 1053ca return sc; } void rtems_libio_use_global_env(void) { 105399: 55 push %ebp 10539a: 89 e5 mov %esp,%ebp 10539c: 83 ec 10 sub $0x10,%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( 10539f: 68 5c 7b 12 00 push $0x127b5c 1053a4: 6a 00 push $0x0 1053a6: e8 71 14 00 00 call 10681c RTEMS_SELF, (void **) &rtems_current_user_env ); if (sc != RTEMS_SUCCESSFUL) { 1053ab: 83 c4 10 add $0x10,%esp 1053ae: 85 c0 test %eax,%eax 1053b0: 74 0d je 1053bf <== ALWAYS TAKEN rtems_fatal_error_occurred(0xdeadbeef); 1053b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1053b5: 68 ef be ad de push $0xdeadbeef <== NOT EXECUTED 1053ba: e8 09 17 00 00 call 106ac8 <== NOT EXECUTED } rtems_current_user_env = &rtems_global_user_env; 1053bf: c7 05 5c 7b 12 00 60 movl $0x127b60,0x127b5c 1053c6: 7b 12 00 } } 1053c9: c9 leave 1053ca: c3 ret =============================================================================== 00108f14 : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 108f14: 55 push %ebp 108f15: 89 e5 mov %esp,%ebp 108f17: 83 ec 1c sub $0x1c,%esp uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 108f1a: 8d 45 f4 lea -0xc(%ebp),%eax 108f1d: 50 push %eax 108f1e: ff 75 08 pushl 0x8(%ebp) 108f21: ff 35 30 f2 12 00 pushl 0x12f230 108f27: e8 a8 56 00 00 call 10e5d4 <_Protected_heap_Get_block_size> 108f2c: 83 c4 10 add $0x10,%esp 108f2f: 84 c0 test %al,%al 108f31: 74 11 je 108f44 <== NEVER TAKEN MSBUMP(lifetime_freed, size); 108f33: 8b 45 f4 mov -0xc(%ebp),%eax 108f36: 31 d2 xor %edx,%edx 108f38: 01 05 dc 3b 13 00 add %eax,0x133bdc 108f3e: 11 15 e0 3b 13 00 adc %edx,0x133be0 } } 108f44: c9 leave 108f45: c3 ret =============================================================================== 00108f46 : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 108f46: 55 push %ebp 108f47: 89 e5 mov %esp,%ebp 108f49: 83 ec 18 sub $0x18,%esp 108f4c: 8b 45 08 mov 0x8(%ebp),%eax uintptr_t actual_size = 0; 108f4f: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) uint32_t current_depth; rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) 108f56: 85 c0 test %eax,%eax 108f58: 74 43 je 108f9d <== NEVER TAKEN return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 108f5a: 52 push %edx 108f5b: 8d 55 f4 lea -0xc(%ebp),%edx 108f5e: 52 push %edx 108f5f: 50 push %eax 108f60: ff 35 30 f2 12 00 pushl 0x12f230 108f66: e8 69 56 00 00 call 10e5d4 <_Protected_heap_Get_block_size> MSBUMP(lifetime_allocated, actual_size); 108f6b: 8b 45 f4 mov -0xc(%ebp),%eax 108f6e: 31 d2 xor %edx,%edx 108f70: 03 05 d4 3b 13 00 add 0x133bd4,%eax 108f76: 13 15 d8 3b 13 00 adc 0x133bd8,%edx 108f7c: a3 d4 3b 13 00 mov %eax,0x133bd4 108f81: 89 15 d8 3b 13 00 mov %edx,0x133bd8 current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 108f87: 2b 05 dc 3b 13 00 sub 0x133bdc,%eax if (current_depth > s->max_depth) 108f8d: 83 c4 10 add $0x10,%esp 108f90: 3b 05 d0 3b 13 00 cmp 0x133bd0,%eax 108f96: 76 05 jbe 108f9d s->max_depth = current_depth; 108f98: a3 d0 3b 13 00 mov %eax,0x133bd0 } 108f9d: c9 leave 108f9e: c3 ret =============================================================================== 0011117c : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 11117c: 55 push %ebp 11117d: 89 e5 mov %esp,%ebp 11117f: 56 push %esi 111180: 53 push %ebx 111181: 8b 5d 08 mov 0x8(%ebp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 111184: 85 db test %ebx,%ebx 111186: 75 07 jne 11118f return EINVAL; 111188: b8 16 00 00 00 mov $0x16,%eax 11118d: eb 5b jmp 1111ea *pointer = NULL; 11118f: 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()) && 111195: 83 3d a8 25 13 00 03 cmpl $0x3,0x1325a8 11119c: 74 23 je 1111c1 return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 11119e: e8 b8 66 ff ff call 10785b Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 1111a3: 6a 00 push $0x0 1111a5: ff 75 0c pushl 0xc(%ebp) 1111a8: ff 75 10 pushl 0x10(%ebp) 1111ab: ff 35 14 e2 12 00 pushl 0x12e214 1111b1: e8 72 b3 ff ff call 10c528 <_Protected_heap_Allocate_aligned_with_boundary> 1111b6: 89 c6 mov %eax,%esi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 1111b8: 83 c4 10 add $0x10,%esp 1111bb: 85 c0 test %eax,%eax 1111bd: 75 0d jne 1111cc 1111bf: eb 24 jmp 1111e5 /* * 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() ) 1111c1: e8 56 66 ff ff call 10781c *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1111c6: 84 c0 test %al,%al 1111c8: 74 be je 111188 <== NEVER TAKEN 1111ca: eb d2 jmp 11119e return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 1111cc: a1 e4 07 13 00 mov 0x1307e4,%eax 1111d1: 85 c0 test %eax,%eax 1111d3: 74 0a je 1111df (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 1111d5: 83 ec 0c sub $0xc,%esp 1111d8: 53 push %ebx 1111d9: ff 50 04 call *0x4(%eax) 1111dc: 83 c4 10 add $0x10,%esp *pointer = return_this; 1111df: 89 33 mov %esi,(%ebx) return 0; 1111e1: 31 c0 xor %eax,%eax 1111e3: eb 05 jmp 1111ea RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) return ENOMEM; 1111e5: 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; } 1111ea: 8d 65 f8 lea -0x8(%ebp),%esp 1111ed: 5b pop %ebx 1111ee: 5e pop %esi 1111ef: 5d pop %ebp 1111f0: c3 ret =============================================================================== 0010e848 : */ rtems_status_code rtems_message_queue_delete( rtems_id id ) { 10e848: 55 push %ebp 10e849: 89 e5 mov %esp,%ebp 10e84b: 53 push %ebx 10e84c: 83 ec 18 sub $0x18,%esp register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); 10e84f: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 10e852: 50 push %eax 10e853: ff 75 08 pushl 0x8(%ebp) 10e856: 68 94 ed 12 00 push $0x12ed94 10e85b: e8 08 ca ff ff call 10b268 <_Objects_Get> switch ( location ) { 10e860: 83 c4 10 add $0x10,%esp 10e863: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10e867: 75 38 jne 10e8a1 <== NEVER TAKEN 10e869: 89 c3 mov %eax,%ebx case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 10e86b: 50 push %eax 10e86c: 50 push %eax 10e86d: 53 push %ebx 10e86e: 68 94 ed 12 00 push $0x12ed94 10e873: e8 50 c6 ff ff call 10aec8 <_Objects_Close> &the_message_queue->Object ); _CORE_message_queue_Close( 10e878: 83 c4 0c add $0xc,%esp 10e87b: 6a 05 push $0x5 10e87d: 6a 00 push $0x0 10e87f: 8d 43 14 lea 0x14(%ebx),%eax 10e882: 50 push %eax 10e883: e8 a0 04 00 00 call 10ed28 <_CORE_message_queue_Close> */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 10e888: 5a pop %edx 10e889: 59 pop %ecx 10e88a: 53 push %ebx 10e88b: 68 94 ed 12 00 push $0x12ed94 10e890: e8 a7 c8 ff ff call 10b13c <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 10e895: e8 72 d5 ff ff call 10be0c <_Thread_Enable_dispatch> 10e89a: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; 10e89d: 31 c0 xor %eax,%eax 10e89f: eb 05 jmp 10e8a6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10e8a1: b8 04 00 00 00 mov $0x4,%eax } 10e8a6: 8b 5d fc mov -0x4(%ebp),%ebx 10e8a9: c9 leave 10e8aa: c3 ret =============================================================================== 0010b0b8 : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 10b0b8: 55 push %ebp 10b0b9: 89 e5 mov %esp,%ebp 10b0bb: 57 push %edi 10b0bc: 56 push %esi 10b0bd: 53 push %ebx 10b0be: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 10b0c1: ff 75 08 pushl 0x8(%ebp) 10b0c4: e8 87 5c 01 00 call 120d50 10b0c9: 89 c7 mov %eax,%edi if (dup_path != NULL) { 10b0cb: 83 c4 10 add $0x10,%esp 10b0ce: 85 c0 test %eax,%eax 10b0d0: 75 08 jne 10b0da success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 10b0d2: 83 c8 ff or $0xffffffff,%eax 10b0d5: e9 56 01 00 00 jmp 10b230 p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 10b0da: 31 c0 xor %eax,%eax 10b0dc: 80 3f 2f cmpb $0x2f,(%edi) 10b0df: 0f 94 c0 sete %al 10b0e2: 01 f8 add %edi,%eax 10b0e4: 89 45 94 mov %eax,-0x6c(%ebp) char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 10b0e7: be 01 00 00 00 mov $0x1,%esi 10b0ec: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp) 10b0f3: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 10b0f8: 8b 55 94 mov -0x6c(%ebp),%edx 10b0fb: 8a 0a mov (%edx),%cl 10b0fd: 84 c9 test %cl,%cl 10b0ff: 74 0d je 10b10e last = 1; else if (p[0] != '/') 10b101: 31 d2 xor %edx,%edx 10b103: 80 f9 2f cmp $0x2f,%cl 10b106: 0f 85 e6 00 00 00 jne 10b1f2 10b10c: eb 05 jmp 10b113 retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') last = 1; 10b10e: ba 01 00 00 00 mov $0x1,%edx else if (p[0] != '/') continue; *p = '\0'; 10b113: 8b 4d 94 mov -0x6c(%ebp),%ecx 10b116: c6 01 00 movb $0x0,(%ecx) if (!last && p[1] == '\0') 10b119: bb 01 00 00 00 mov $0x1,%ebx 10b11e: 85 d2 test %edx,%edx 10b120: 75 09 jne 10b12b 10b122: 31 db xor %ebx,%ebx 10b124: 80 79 01 00 cmpb $0x0,0x1(%ecx) 10b128: 0f 94 c3 sete %bl last = 1; if (first) { 10b12b: 85 c0 test %eax,%eax 10b12d: 74 1a je 10b149 * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 10b12f: 83 ec 0c sub $0xc,%esp 10b132: 6a 00 push $0x0 10b134: e8 2b 21 00 00 call 10d264 10b139: 89 45 90 mov %eax,-0x70(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 10b13c: 24 3f and $0x3f,%al (void)umask(numask); 10b13e: 89 04 24 mov %eax,(%esp) 10b141: e8 1e 21 00 00 call 10d264 10b146: 83 c4 10 add $0x10,%esp first = 0; } if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 10b149: b8 ff 01 00 00 mov $0x1ff,%eax oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 10b14e: 85 db test %ebx,%ebx 10b150: 74 11 je 10b163 (void)umask(oumask); 10b152: 83 ec 0c sub $0xc,%esp 10b155: ff 75 90 pushl -0x70(%ebp) 10b158: e8 07 21 00 00 call 10d264 10b15d: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 10b160: 8b 45 0c mov 0xc(%ebp),%eax 10b163: 52 push %edx 10b164: 52 push %edx 10b165: 50 push %eax 10b166: 57 push %edi 10b167: e8 34 f3 ff ff call 10a4a0 10b16c: 83 c4 10 add $0x10,%esp 10b16f: 85 c0 test %eax,%eax 10b171: 79 6d jns 10b1e0 if (errno == EEXIST || errno == EISDIR) { 10b173: e8 54 40 01 00 call 11f1cc <__errno> 10b178: 83 38 11 cmpl $0x11,(%eax) 10b17b: 75 15 jne 10b192 if (stat(path, &sb) < 0) { 10b17d: 50 push %eax 10b17e: 50 push %eax 10b17f: 8d 45 a0 lea -0x60(%ebp),%eax 10b182: 50 push %eax 10b183: 57 push %edi 10b184: e8 af 00 00 00 call 10b238 10b189: 83 c4 10 add $0x10,%esp 10b18c: 85 c0 test %eax,%eax 10b18e: 79 0e jns 10b19e <== ALWAYS TAKEN 10b190: eb 72 jmp 10b204 <== NOT EXECUTED first = 0; } if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { if (errno == EEXIST || errno == EISDIR) { 10b192: e8 35 40 01 00 call 11f1cc <__errno> 10b197: 83 38 15 cmpl $0x15,(%eax) 10b19a: 74 e1 je 10b17d <== NEVER TAKEN 10b19c: eb 66 jmp 10b204 if (stat(path, &sb) < 0) { retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 10b19e: 8b 45 ac mov -0x54(%ebp),%eax 10b1a1: 25 00 f0 00 00 and $0xf000,%eax 10b1a6: 3d 00 40 00 00 cmp $0x4000,%eax 10b1ab: 74 25 je 10b1d2 if (last) 10b1ad: 85 db test %ebx,%ebx 10b1af: 74 14 je 10b1c5 errno = EEXIST; 10b1b1: e8 16 40 01 00 call 11f1cc <__errno> 10b1b6: c7 00 11 00 00 00 movl $0x11,(%eax) else errno = ENOTDIR; retval = 0; 10b1bc: 31 f6 xor %esi,%esi if (stat(path, &sb) < 0) { retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; 10b1be: bb 01 00 00 00 mov $0x1,%ebx 10b1c3: eb 41 jmp 10b206 else errno = ENOTDIR; 10b1c5: e8 02 40 01 00 call 11f1cc <__errno> 10b1ca: c7 00 14 00 00 00 movl $0x14,(%eax) 10b1d0: eb 32 jmp 10b204 retval = 0; break; } if (last) 10b1d2: 85 db test %ebx,%ebx 10b1d4: 75 10 jne 10b1e6 retval = 0; break; } } if (!last) *p = '/'; 10b1d6: 8b 55 94 mov -0x6c(%ebp),%edx 10b1d9: c6 02 2f movb $0x2f,(%edx) 10b1dc: 31 d2 xor %edx,%edx 10b1de: eb 10 jmp 10b1f0 } else { retval = 0; break; } } if (!last) 10b1e0: 85 db test %ebx,%ebx 10b1e2: 74 f2 je 10b1d6 10b1e4: eb 05 jmp 10b1eb errno = ENOTDIR; retval = 0; break; } if (last) retval = 2; 10b1e6: be 02 00 00 00 mov $0x2,%esi else errno = ENOTDIR; retval = 0; break; } if (last) 10b1eb: ba 01 00 00 00 mov $0x1,%edx 10b1f0: 31 c0 xor %eax,%eax p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 10b1f2: ff 45 94 incl -0x6c(%ebp) 10b1f5: 85 d2 test %edx,%edx 10b1f7: 0f 84 fb fe ff ff je 10b0f8 10b1fd: bb 01 00 00 00 mov $0x1,%ebx 10b202: eb 04 jmp 10b208 if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { if (errno == EEXIST || errno == EISDIR) { if (stat(path, &sb) < 0) { retval = 0; 10b204: 31 f6 xor %esi,%esi } if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { if (errno == EEXIST || errno == EISDIR) { if (stat(path, &sb) < 0) { 10b206: 31 c0 xor %eax,%eax } } if (!last) *p = '/'; } if (!first && !last) 10b208: 09 c3 or %eax,%ebx 10b20a: 75 0e jne 10b21a (void)umask(oumask); 10b20c: 83 ec 0c sub $0xc,%esp 10b20f: ff 75 90 pushl -0x70(%ebp) 10b212: e8 4d 20 00 00 call 10d264 10b217: 83 c4 10 add $0x10,%esp int success = 0; char *dup_path = strdup(path); if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); 10b21a: 83 ec 0c sub $0xc,%esp 10b21d: 57 push %edi 10b21e: e8 c5 ec ff ff call 109ee8 } return success != 0 ? 0 : -1; 10b223: 83 c4 10 add $0x10,%esp 10b226: 85 f6 test %esi,%esi 10b228: 0f 84 a4 fe ff ff je 10b0d2 10b22e: 31 c0 xor %eax,%eax } 10b230: 8d 65 f4 lea -0xc(%ebp),%esp 10b233: 5b pop %ebx 10b234: 5e pop %esi 10b235: 5f pop %edi 10b236: 5d pop %ebp 10b237: c3 ret =============================================================================== 0010ae70 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 10ae70: 55 push %ebp 10ae71: 89 e5 mov %esp,%ebp 10ae73: 57 push %edi 10ae74: 56 push %esi 10ae75: 53 push %ebx 10ae76: 83 ec 0c sub $0xc,%esp 10ae79: 8b 7d 0c mov 0xc(%ebp),%edi 10ae7c: 8b 75 14 mov 0x14(%ebp),%esi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10ae7f: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 10ae84: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10ae88: 0f 84 d9 00 00 00 je 10af67 return RTEMS_INVALID_NAME; if ( !starting_address ) 10ae8e: 85 ff test %edi,%edi 10ae90: 0f 84 c5 00 00 00 je 10af5b return RTEMS_INVALID_ADDRESS; if ( !id ) 10ae96: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 10ae9a: 0f 84 bb 00 00 00 je 10af5b <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 10aea0: 85 f6 test %esi,%esi 10aea2: 0f 84 ba 00 00 00 je 10af62 10aea8: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10aeac: 0f 84 b0 00 00 00 je 10af62 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 10aeb2: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 10aeb4: 39 75 10 cmp %esi,0x10(%ebp) 10aeb7: 0f 82 aa 00 00 00 jb 10af67 10aebd: f7 c6 03 00 00 00 test $0x3,%esi 10aec3: 0f 85 9e 00 00 00 jne 10af67 if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 10aec9: b0 09 mov $0x9,%al if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 10aecb: f7 c7 03 00 00 00 test $0x3,%edi 10aed1: 0f 85 90 00 00 00 jne 10af67 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10aed7: a1 b4 31 13 00 mov 0x1331b4,%eax 10aedc: 40 inc %eax 10aedd: a3 b4 31 13 00 mov %eax,0x1331b4 return _Thread_Dispatch_disable_level; 10aee2: a1 b4 31 13 00 mov 0x1331b4,%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 ); 10aee7: 83 ec 0c sub $0xc,%esp 10aeea: 68 30 30 13 00 push $0x133030 10aeef: e8 c4 17 00 00 call 10c6b8 <_Objects_Allocate> 10aef4: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 10aef6: 83 c4 10 add $0x10,%esp 10aef9: 85 c0 test %eax,%eax 10aefb: 75 0c jne 10af09 _Thread_Enable_dispatch(); 10aefd: e8 ba 27 00 00 call 10d6bc <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10af02: b8 05 00 00 00 mov $0x5,%eax 10af07: eb 5e jmp 10af67 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 10af09: 89 78 10 mov %edi,0x10(%eax) the_partition->length = length; 10af0c: 8b 45 10 mov 0x10(%ebp),%eax 10af0f: 89 43 14 mov %eax,0x14(%ebx) the_partition->buffer_size = buffer_size; 10af12: 89 73 18 mov %esi,0x18(%ebx) the_partition->attribute_set = attribute_set; 10af15: 8b 45 18 mov 0x18(%ebp),%eax 10af18: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 10af1b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 10af22: 56 push %esi 10af23: 8b 45 10 mov 0x10(%ebp),%eax 10af26: 31 d2 xor %edx,%edx 10af28: f7 f6 div %esi 10af2a: 50 push %eax 10af2b: 57 push %edi 10af2c: 8d 43 24 lea 0x24(%ebx),%eax 10af2f: 50 push %eax 10af30: e8 3f 0f 00 00 call 10be74 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10af35: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10af38: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10af3b: 8b 15 4c 30 13 00 mov 0x13304c,%edx 10af41: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10af44: 8b 55 08 mov 0x8(%ebp),%edx 10af47: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 10af4a: 8b 55 1c mov 0x1c(%ebp),%edx 10af4d: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10af4f: e8 68 27 00 00 call 10d6bc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10af54: 83 c4 10 add $0x10,%esp 10af57: 31 c0 xor %eax,%eax 10af59: eb 0c jmp 10af67 if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 10af5b: b8 09 00 00 00 mov $0x9,%eax 10af60: eb 05 jmp 10af67 if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 10af62: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10af67: 8d 65 f4 lea -0xc(%ebp),%esp 10af6a: 5b pop %ebx 10af6b: 5e pop %esi 10af6c: 5f pop %edi 10af6d: 5d pop %ebp 10af6e: c3 ret =============================================================================== 0011445c : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 11445c: 55 push %ebp 11445d: 89 e5 mov %esp,%ebp 11445f: 56 push %esi 114460: 53 push %ebx 114461: 83 ec 14 sub $0x14,%esp 114464: 8b 75 0c mov 0xc(%ebp),%esi register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); 114467: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 11446a: 50 push %eax 11446b: ff 75 08 pushl 0x8(%ebp) 11446e: 68 d0 7c 14 00 push $0x147cd0 114473: e8 78 43 00 00 call 1187f0 <_Objects_Get> switch ( location ) { 114478: 83 c4 10 add $0x10,%esp 11447b: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 11447f: 75 53 jne 1144d4 114481: 89 c3 mov %eax,%ebx ) { void *starting; void *ending; starting = the_partition->starting_address; 114483: 8b 40 10 mov 0x10(%eax),%eax 114486: 8b 53 14 mov 0x14(%ebx),%edx 114489: 01 c2 add %eax,%edx ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 11448b: 39 d6 cmp %edx,%esi 11448d: 77 18 ja 1144a7 <== NEVER TAKEN 11448f: 39 c6 cmp %eax,%esi 114491: 72 14 jb 1144a7 RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 114493: 89 f2 mov %esi,%edx 114495: 29 c2 sub %eax,%edx 114497: 89 d0 mov %edx,%eax offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 114499: 31 d2 xor %edx,%edx 11449b: 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 ) && 11449e: 31 c0 xor %eax,%eax 1144a0: 85 d2 test %edx,%edx 1144a2: 0f 94 c0 sete %al 1144a5: eb 02 jmp 1144a9 1144a7: 31 c0 xor %eax,%eax case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { 1144a9: 85 c0 test %eax,%eax 1144ab: 74 1b je 1144c8 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 1144ad: 50 push %eax 1144ae: 50 push %eax 1144af: 56 push %esi 1144b0: 8d 43 24 lea 0x24(%ebx),%eax 1144b3: 50 push %eax 1144b4: e8 db 2a 00 00 call 116f94 <_Chain_Append> _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 1144b9: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 1144bc: e8 d3 4e 00 00 call 119394 <_Thread_Enable_dispatch> 1144c1: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; 1144c4: 31 c0 xor %eax,%eax 1144c6: eb 11 jmp 1144d9 } _Thread_Enable_dispatch(); 1144c8: e8 c7 4e 00 00 call 119394 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 1144cd: b8 09 00 00 00 mov $0x9,%eax 1144d2: eb 05 jmp 1144d9 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1144d4: b8 04 00 00 00 mov $0x4,%eax } 1144d9: 8d 65 f8 lea -0x8(%ebp),%esp 1144dc: 5b pop %ebx 1144dd: 5e pop %esi 1144de: 5d pop %ebp 1144df: c3 ret =============================================================================== 0012dd58 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 12dd58: 55 push %ebp 12dd59: 89 e5 mov %esp,%ebp 12dd5b: 57 push %edi 12dd5c: 56 push %esi 12dd5d: 53 push %ebx 12dd5e: 83 ec 30 sub $0x30,%esp 12dd61: 8b 7d 08 mov 0x8(%ebp),%edi 12dd64: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); 12dd67: 8d 45 e4 lea -0x1c(%ebp),%eax 12dd6a: 50 push %eax 12dd6b: 57 push %edi 12dd6c: 68 a0 ec 16 00 push $0x16eca0 12dd71: e8 ca d2 fd ff call 10b040 <_Objects_Get> switch ( location ) { 12dd76: 83 c4 10 add $0x10,%esp 12dd79: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 12dd7d: 0f 85 47 01 00 00 jne 12deca 12dd83: 89 c6 mov %eax,%esi case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 12dd85: a1 04 e7 16 00 mov 0x16e704,%eax 12dd8a: 39 46 40 cmp %eax,0x40(%esi) 12dd8d: 74 0f je 12dd9e _Thread_Enable_dispatch(); 12dd8f: e8 e0 dd fd ff call 10bb74 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 12dd94: bf 17 00 00 00 mov $0x17,%edi 12dd99: e9 31 01 00 00 jmp 12decf } if ( length == RTEMS_PERIOD_STATUS ) { 12dd9e: 85 db test %ebx,%ebx 12dda0: 75 1b jne 12ddbd switch ( the_period->state ) { 12dda2: 8b 46 38 mov 0x38(%esi),%eax 12dda5: 31 ff xor %edi,%edi 12dda7: 83 f8 04 cmp $0x4,%eax 12ddaa: 77 07 ja 12ddb3 <== NEVER TAKEN case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ddac: 0f b6 b8 08 31 15 00 movzbl 0x153108(%eax),%edi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 12ddb3: e8 bc dd fd ff call 10bb74 <_Thread_Enable_dispatch> 12ddb8: e9 12 01 00 00 jmp 12decf return( return_value ); } _ISR_Disable( level ); 12ddbd: 9c pushf 12ddbe: fa cli 12ddbf: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 12ddc2: 8b 46 38 mov 0x38(%esi),%eax 12ddc5: 85 c0 test %eax,%eax 12ddc7: 75 4c jne 12de15 _ISR_Enable( level ); 12ddc9: ff 75 d4 pushl -0x2c(%ebp) 12ddcc: 9d popf the_period->next_length = length; 12ddcd: 89 5e 3c mov %ebx,0x3c(%esi) /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 12ddd0: 83 ec 0c sub $0xc,%esp 12ddd3: 56 push %esi 12ddd4: e8 0f ff ff ff call 12dce8 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 12ddd9: 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; 12dde0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) the_watchdog->routine = routine; 12dde7: c7 46 2c dc de 12 00 movl $0x12dedc,0x2c(%esi) the_watchdog->id = id; 12ddee: 89 7e 30 mov %edi,0x30(%esi) the_watchdog->user_data = user_data; 12ddf1: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 12ddf8: 89 5e 1c mov %ebx,0x1c(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 12ddfb: 59 pop %ecx 12ddfc: 5b pop %ebx _Rate_monotonic_Timeout, id, NULL ); _Watchdog_Insert_ticks( &the_period->Timer, length ); 12ddfd: 8d 56 10 lea 0x10(%esi),%edx 12de00: 52 push %edx 12de01: 68 a0 e2 16 00 push $0x16e2a0 12de06: e8 61 e8 fd ff call 10c66c <_Watchdog_Insert> _Thread_Enable_dispatch(); 12de0b: e8 64 dd fd ff call 10bb74 <_Thread_Enable_dispatch> 12de10: 83 c4 10 add $0x10,%esp 12de13: eb 63 jmp 12de78 return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 12de15: 83 f8 02 cmp $0x2,%eax 12de18: 75 62 jne 12de7c /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 12de1a: 89 f0 mov %esi,%eax 12de1c: e8 28 fe ff ff call 12dc49 <_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; 12de21: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) the_period->next_length = length; 12de28: 89 5e 3c mov %ebx,0x3c(%esi) _ISR_Enable( level ); 12de2b: ff 75 d4 pushl -0x2c(%ebp) 12de2e: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 12de2f: a1 04 e7 16 00 mov 0x16e704,%eax 12de34: 8b 4e 08 mov 0x8(%esi),%ecx 12de37: 89 48 20 mov %ecx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 12de3a: 52 push %edx 12de3b: 52 push %edx 12de3c: 68 00 40 00 00 push $0x4000 12de41: 50 push %eax 12de42: e8 95 e4 fd ff call 10c2dc <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 12de47: 9c pushf 12de48: fa cli 12de49: 59 pop %ecx local_state = the_period->state; 12de4a: 8b 46 38 mov 0x38(%esi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 12de4d: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) _ISR_Enable( level ); 12de54: 51 push %ecx 12de55: 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 ) 12de56: 83 c4 10 add $0x10,%esp 12de59: 83 f8 03 cmp $0x3,%eax 12de5c: 75 15 jne 12de73 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 12de5e: 50 push %eax 12de5f: 50 push %eax 12de60: 68 00 40 00 00 push $0x4000 12de65: ff 35 04 e7 16 00 pushl 0x16e704 12de6b: e8 d4 d9 fd ff call 10b844 <_Thread_Clear_state> 12de70: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 12de73: e8 fc dc fd ff call 10bb74 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 12de78: 31 ff xor %edi,%edi 12de7a: eb 53 jmp 12decf #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 12de7c: bf 04 00 00 00 mov $0x4,%edi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 12de81: 83 f8 04 cmp $0x4,%eax 12de84: 75 49 jne 12decf <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 12de86: 89 f0 mov %esi,%eax 12de88: e8 bc fd ff ff call 12dc49 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 12de8d: ff 75 d4 pushl -0x2c(%ebp) 12de90: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 12de91: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) the_period->next_length = length; 12de98: 89 5e 3c mov %ebx,0x3c(%esi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 12de9b: 89 5e 1c mov %ebx,0x1c(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 12de9e: 51 push %ecx 12de9f: 51 push %ecx _Watchdog_Insert_ticks( &the_period->Timer, length ); 12dea0: 8d 46 10 lea 0x10(%esi),%eax 12dea3: 50 push %eax 12dea4: 68 a0 e2 16 00 push $0x16e2a0 12dea9: e8 be e7 fd ff call 10c66c <_Watchdog_Insert> 12deae: 5b pop %ebx 12deaf: 58 pop %eax 12deb0: ff 76 3c pushl 0x3c(%esi) 12deb3: ff 76 40 pushl 0x40(%esi) 12deb6: ff 15 10 69 16 00 call *0x166910 _Scheduler_Release_job(the_period->owner, the_period->next_length); _Thread_Enable_dispatch(); 12debc: e8 b3 dc fd ff call 10bb74 <_Thread_Enable_dispatch> 12dec1: 83 c4 10 add $0x10,%esp return RTEMS_TIMEOUT; 12dec4: 66 bf 06 00 mov $0x6,%di 12dec8: eb 05 jmp 12decf #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 12deca: bf 04 00 00 00 mov $0x4,%edi } 12decf: 89 f8 mov %edi,%eax 12ded1: 8d 65 f4 lea -0xc(%ebp),%esp 12ded4: 5b pop %ebx 12ded5: 5e pop %esi 12ded6: 5f pop %edi 12ded7: 5d pop %ebp 12ded8: c3 ret =============================================================================== 00123b14 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 123b14: 55 push %ebp 123b15: 89 e5 mov %esp,%ebp 123b17: 57 push %edi 123b18: 56 push %esi 123b19: 53 push %ebx 123b1a: 83 ec 7c sub $0x7c,%esp 123b1d: 8b 75 08 mov 0x8(%ebp),%esi 123b20: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 123b23: 85 db test %ebx,%ebx 123b25: 0f 84 2e 01 00 00 je 123c59 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 123b2b: 57 push %edi 123b2c: 57 push %edi 123b2d: 68 4c 05 15 00 push $0x15054c 123b32: 56 push %esi 123b33: ff d3 call *%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 123b35: 58 pop %eax 123b36: 5a pop %edx 123b37: 68 6a 05 15 00 push $0x15056a 123b3c: 56 push %esi 123b3d: ff d3 call *%ebx (*print)( context, "--- Wall times are in seconds ---\n" ); 123b3f: 59 pop %ecx 123b40: 5f pop %edi 123b41: 68 8c 05 15 00 push $0x15058c 123b46: 56 push %esi 123b47: ff d3 call *%ebx Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 123b49: 58 pop %eax 123b4a: 5a pop %edx 123b4b: 68 af 05 15 00 push $0x1505af 123b50: 56 push %esi 123b51: ff d3 call *%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 123b53: 59 pop %ecx 123b54: 5f pop %edi 123b55: 68 fa 05 15 00 push $0x1505fa 123b5a: 56 push %esi 123b5b: 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 ; 123b5d: 8b 3d a8 ec 16 00 mov 0x16eca8,%edi 123b63: 83 c4 10 add $0x10,%esp 123b66: e9 e2 00 00 00 jmp 123c4d id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 123b6b: 51 push %ecx 123b6c: 51 push %ecx 123b6d: 8d 45 b0 lea -0x50(%ebp),%eax 123b70: 50 push %eax 123b71: 57 push %edi 123b72: e8 b9 9d 00 00 call 12d930 if ( status != RTEMS_SUCCESSFUL ) 123b77: 83 c4 10 add $0x10,%esp 123b7a: 85 c0 test %eax,%eax 123b7c: 0f 85 ca 00 00 00 jne 123c4c #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 ); 123b82: 50 push %eax 123b83: 50 push %eax 123b84: 8d 55 98 lea -0x68(%ebp),%edx 123b87: 52 push %edx 123b88: 57 push %edi 123b89: e8 2e 9f 00 00 call 12dabc #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 123b8e: 83 c4 0c add $0xc,%esp 123b91: 8d 55 8b lea -0x75(%ebp),%edx 123b94: 52 push %edx 123b95: 6a 05 push $0x5 123b97: ff 75 98 pushl -0x68(%ebp) 123b9a: 89 55 84 mov %edx,-0x7c(%ebp) 123b9d: e8 e2 c9 fe ff call 110584 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 123ba2: 58 pop %eax 123ba3: 5a pop %edx 123ba4: ff 75 b4 pushl -0x4c(%ebp) 123ba7: ff 75 b0 pushl -0x50(%ebp) 123baa: 8b 55 84 mov -0x7c(%ebp),%edx 123bad: 52 push %edx 123bae: 57 push %edi 123baf: 68 46 06 15 00 push $0x150646 123bb4: 56 push %esi 123bb5: ff d3 call *%ebx ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 123bb7: 8b 45 b0 mov -0x50(%ebp),%eax 123bba: 83 c4 20 add $0x20,%esp 123bbd: 85 c0 test %eax,%eax 123bbf: 75 0f jne 123bd0 (*print)( context, "\n" ); 123bc1: 51 push %ecx 123bc2: 51 push %ecx 123bc3: 68 29 b1 14 00 push $0x14b129 123bc8: 56 push %esi 123bc9: ff d3 call *%ebx continue; 123bcb: 83 c4 10 add $0x10,%esp 123bce: eb 7c jmp 123c4c 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 ); 123bd0: 52 push %edx 123bd1: 8d 55 90 lea -0x70(%ebp),%edx 123bd4: 52 push %edx 123bd5: 50 push %eax { #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; 123bd6: 8d 45 c8 lea -0x38(%ebp),%eax _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 123bd9: 50 push %eax 123bda: e8 79 09 00 00 call 124558 <_Timespec_Divide_by_integer> (*print)( context, 123bdf: 8b 45 94 mov -0x6c(%ebp),%eax 123be2: b9 e8 03 00 00 mov $0x3e8,%ecx 123be7: 99 cltd 123be8: f7 f9 idiv %ecx 123bea: 50 push %eax 123beb: ff 75 90 pushl -0x70(%ebp) 123bee: 8b 45 c4 mov -0x3c(%ebp),%eax 123bf1: 99 cltd 123bf2: f7 f9 idiv %ecx 123bf4: 50 push %eax 123bf5: ff 75 c0 pushl -0x40(%ebp) 123bf8: 8b 45 bc mov -0x44(%ebp),%eax 123bfb: 99 cltd 123bfc: f7 f9 idiv %ecx 123bfe: 50 push %eax 123bff: ff 75 b8 pushl -0x48(%ebp) 123c02: 68 5d 06 15 00 push $0x15065d 123c07: 56 push %esi 123c08: 89 4d 84 mov %ecx,-0x7c(%ebp) 123c0b: 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); 123c0d: 83 c4 2c add $0x2c,%esp 123c10: 8d 45 90 lea -0x70(%ebp),%eax 123c13: 50 push %eax 123c14: ff 75 b0 pushl -0x50(%ebp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; 123c17: 8d 45 e0 lea -0x20(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 123c1a: 50 push %eax 123c1b: e8 38 09 00 00 call 124558 <_Timespec_Divide_by_integer> (*print)( context, 123c20: 8b 45 94 mov -0x6c(%ebp),%eax 123c23: 8b 4d 84 mov -0x7c(%ebp),%ecx 123c26: 99 cltd 123c27: f7 f9 idiv %ecx 123c29: 50 push %eax 123c2a: ff 75 90 pushl -0x70(%ebp) 123c2d: 8b 45 dc mov -0x24(%ebp),%eax 123c30: 99 cltd 123c31: f7 f9 idiv %ecx 123c33: 50 push %eax 123c34: ff 75 d8 pushl -0x28(%ebp) 123c37: 8b 45 d4 mov -0x2c(%ebp),%eax 123c3a: 99 cltd 123c3b: f7 f9 idiv %ecx 123c3d: 50 push %eax 123c3e: ff 75 d0 pushl -0x30(%ebp) 123c41: 68 7c 06 15 00 push $0x15067c 123c46: 56 push %esi 123c47: ff d3 call *%ebx 123c49: 83 c4 30 add $0x30,%esp * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 123c4c: 47 inc %edi /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 123c4d: 3b 3d ac ec 16 00 cmp 0x16ecac,%edi 123c53: 0f 86 12 ff ff ff jbe 123b6b the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 123c59: 8d 65 f4 lea -0xc(%ebp),%esp 123c5c: 5b pop %ebx 123c5d: 5e pop %esi 123c5e: 5f pop %edi 123c5f: 5d pop %ebp 123c60: c3 ret =============================================================================== 0010abb5 : return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 10abb5: 55 push %ebp 10abb6: 89 e5 mov %esp,%ebp 10abb8: 57 push %edi 10abb9: 56 push %esi 10abba: 53 push %ebx 10abbb: 83 ec 1c sub $0x1c,%esp 10abbe: 8b 4d 08 mov 0x8(%ebp),%ecx 10abc1: 8b 5d 0c mov 0xc(%ebp),%ebx 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; 10abc4: 8b 79 30 mov 0x30(%ecx),%edi #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 10abc7: 89 d8 mov %ebx,%eax 10abc9: 31 d2 xor %edx,%edx 10abcb: f7 f7 div %edi if (excess > 0) { 10abcd: 89 de mov %ebx,%esi 10abcf: 85 d2 test %edx,%edx 10abd1: 74 05 je 10abd8 <== ALWAYS TAKEN value += alignment - excess; 10abd3: 8d 34 3b lea (%ebx,%edi,1),%esi <== NOT EXECUTED 10abd6: 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) { 10abd8: 39 f3 cmp %esi,%ebx 10abda: 77 04 ja 10abe0 <== NEVER TAKEN 10abdc: 85 db test %ebx,%ebx 10abde: 75 07 jne 10abe7 return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 10abe0: 31 c0 xor %eax,%eax 10abe2: e9 8f 00 00 00 jmp 10ac76 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10abe7: 8b 01 mov (%ecx),%eax 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); 10abe9: 8d 51 04 lea 0x4(%ecx),%edx rtems_rbheap_chunk *big_enough = NULL; 10abec: 31 db xor %ebx,%ebx 10abee: eb 0e jmp 10abfe while (current != tail && big_enough == NULL) { rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current; if (free_chunk->size >= size) { 10abf0: 31 db xor %ebx,%ebx 10abf2: 39 70 1c cmp %esi,0x1c(%eax) 10abf5: 0f 93 c3 setae %bl 10abf8: f7 db neg %ebx 10abfa: 21 c3 and %eax,%ebx rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); if (chunk != NULL) { rtems_rbheap_add_to_spare_descriptor_chain(control, chunk); } } 10abfc: 8b 00 mov (%eax),%eax { 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) { 10abfe: 85 db test %ebx,%ebx 10ac00: 75 04 jne 10ac06 10ac02: 39 d0 cmp %edx,%eax 10ac04: 75 ea jne 10abf0 uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { 10ac06: 85 db test %ebx,%ebx 10ac08: 74 d6 je 10abe0 uintptr_t free_size = free_chunk->size; 10ac0a: 8b 53 1c mov 0x1c(%ebx),%edx if (free_size > aligned_size) { 10ac0d: 39 f2 cmp %esi,%edx 10ac0f: 76 4b jbe 10ac5c rtems_rbheap_chunk *new_chunk = get_chunk(control); 10ac11: 89 c8 mov %ecx,%eax 10ac13: 89 55 e4 mov %edx,-0x1c(%ebp) 10ac16: 89 4d e0 mov %ecx,-0x20(%ebp) 10ac19: e8 49 fe ff ff call 10aa67 10ac1e: 89 c7 mov %eax,%edi if (new_chunk != NULL) { 10ac20: 85 c0 test %eax,%eax 10ac22: 8b 55 e4 mov -0x1c(%ebp),%edx 10ac25: 8b 4d e0 mov -0x20(%ebp),%ecx 10ac28: 74 b6 je 10abe0 <== NEVER TAKEN uintptr_t new_free_size = free_size - aligned_size; 10ac2a: 29 f2 sub %esi,%edx free_chunk->size = new_free_size; 10ac2c: 89 53 1c mov %edx,0x1c(%ebx) new_chunk->begin = free_chunk->begin + new_free_size; 10ac2f: 03 53 18 add 0x18(%ebx),%edx 10ac32: 89 50 18 mov %edx,0x18(%eax) new_chunk->size = aligned_size; 10ac35: 89 70 1c mov %esi,0x1c(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 10ac38: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10ac3f: 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); 10ac45: 53 push %ebx 10ac46: 53 push %ebx 10ac47: 8d 40 08 lea 0x8(%eax),%eax 10ac4a: 50 push %eax 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; 10ac4b: 83 c1 18 add $0x18,%ecx static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10ac4e: 51 push %ecx 10ac4f: e8 40 15 00 00 call 10c194 <_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; 10ac54: 8b 47 18 mov 0x18(%edi),%eax 10ac57: 83 c4 10 add $0x10,%esp 10ac5a: eb 1a jmp 10ac76 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10ac5c: 8b 13 mov (%ebx),%edx previous = the_node->previous; 10ac5e: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 10ac61: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 10ac64: 89 10 mov %edx,(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 10ac66: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 10ac6d: c7 03 00 00 00 00 movl $0x0,(%ebx) } } else { rtems_chain_extract_unprotected(&free_chunk->chain_node); rtems_chain_set_off_chain(&free_chunk->chain_node); ptr = (void *) free_chunk->begin; 10ac73: 8b 43 18 mov 0x18(%ebx),%eax } } } return ptr; } 10ac76: 8d 65 f4 lea -0xc(%ebp),%esp 10ac79: 5b pop %ebx 10ac7a: 5e pop %esi 10ac7b: 5f pop %edi 10ac7c: 5d pop %ebp 10ac7d: c3 ret =============================================================================== 0010ad71 : void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) { 10ad71: 55 push %ebp <== NOT EXECUTED 10ad72: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad74: 53 push %ebx <== NOT EXECUTED 10ad75: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ad78: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); 10ad7b: 6a 20 push $0x20 <== NOT EXECUTED 10ad7d: e8 f2 c1 ff ff call 106f74 <== NOT EXECUTED if (chunk != NULL) { 10ad82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad85: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad87: 74 11 je 10ad9a <== 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); 10ad89: 8d 53 0c lea 0xc(%ebx),%edx <== NOT EXECUTED 10ad8c: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 10ad8f: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED after_node->next = the_node; 10ad92: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED the_node->next = before_node; 10ad95: 89 10 mov %edx,(%eax) <== NOT EXECUTED before_node->previous = the_node; 10ad97: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED rtems_rbheap_add_to_spare_descriptor_chain(control, chunk); } } 10ad9a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ad9d: c9 leave <== NOT EXECUTED 10ad9e: c3 ret <== NOT EXECUTED =============================================================================== 0010ac7e : _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 10ac7e: 55 push %ebp 10ac7f: 89 e5 mov %esp,%ebp 10ac81: 57 push %edi 10ac82: 56 push %esi 10ac83: 53 push %ebx 10ac84: 83 ec 3c sub $0x3c,%esp 10ac87: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac8a: 8b 55 0c mov 0xc(%ebp),%edx rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 10ac8d: 85 d2 test %edx,%edx 10ac8f: 0f 84 c6 00 00 00 je 10ad5b rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 10ac95: 8d 73 18 lea 0x18(%ebx),%esi #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 }; 10ac98: 8d 7d c8 lea -0x38(%ebp),%edi 10ac9b: b9 08 00 00 00 mov $0x8,%ecx 10aca0: 31 c0 xor %eax,%eax 10aca2: f3 ab rep stos %eax,%es:(%edi) 10aca4: 89 55 e0 mov %edx,-0x20(%ebp) RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 10aca7: 8b 53 1c mov 0x1c(%ebx),%edx RBTree_Node* found = NULL; 10acaa: 31 ff xor %edi,%edi return rtems_rbheap_chunk_of_node( 10acac: 8d 4d d0 lea -0x30(%ebp),%ecx 10acaf: eb 2e jmp 10acdf int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); 10acb1: 50 push %eax 10acb2: 50 push %eax 10acb3: 52 push %edx 10acb4: 51 push %ecx 10acb5: 89 55 c0 mov %edx,-0x40(%ebp) 10acb8: 89 4d bc mov %ecx,-0x44(%ebp) 10acbb: ff 56 10 call *0x10(%esi) if ( _RBTree_Is_equal( compare_result ) ) { 10acbe: 83 c4 10 add $0x10,%esp 10acc1: 85 c0 test %eax,%eax 10acc3: 8b 55 c0 mov -0x40(%ebp),%edx 10acc6: 8b 4d bc mov -0x44(%ebp),%ecx 10acc9: 75 08 jne 10acd3 found = iter_node; if ( the_rbtree->is_unique ) 10accb: 80 7e 14 00 cmpb $0x0,0x14(%esi) 10accf: 75 14 jne 10ace5 <== ALWAYS TAKEN 10acd1: 89 d7 mov %edx,%edi <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 10acd3: 85 c0 test %eax,%eax 10acd5: 0f 9f c0 setg %al 10acd8: 0f b6 c0 movzbl %al,%eax break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 10acdb: 8b 54 82 04 mov 0x4(%edx,%eax,4),%edx ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 10acdf: 85 d2 test %edx,%edx 10ace1: 75 ce jne 10acb1 10ace3: 89 fa mov %edi,%edx 10ace5: 8d 7a f8 lea -0x8(%edx),%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) { 10ace8: 83 ff f8 cmp $0xfffffff8,%edi 10aceb: 74 72 je 10ad5f */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 10aced: 31 c9 xor %ecx,%ecx 10acef: 83 7a f8 00 cmpl $0x0,-0x8(%edx) 10acf3: 75 09 jne 10acfe 10acf5: 31 c9 xor %ecx,%ecx 10acf7: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10acfb: 0f 94 c1 sete %cl 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; 10acfe: b8 0e 00 00 00 mov $0xe,%eax 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) { if (!rtems_rbheap_is_chunk_free(chunk)) { 10ad03: 85 c9 test %ecx,%ecx 10ad05: 74 5d je 10ad64 static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 10ad07: 8d 57 08 lea 0x8(%edi),%edx 10ad0a: 50 push %eax 10ad0b: 50 push %eax 10ad0c: 6a 00 push $0x0 10ad0e: 52 push %edx 10ad0f: 89 55 c0 mov %edx,-0x40(%ebp) 10ad12: e8 6d 16 00 00 call 10c384 <_RBTree_Next_unprotected> 10ad17: 89 45 c4 mov %eax,-0x3c(%ebp) 10ad1a: 58 pop %eax 10ad1b: 5a pop %edx 10ad1c: 6a 01 push $0x1 10ad1e: 8b 55 c0 mov -0x40(%ebp),%edx 10ad21: 52 push %edx 10ad22: e8 5d 16 00 00 call 10c384 <_RBTree_Next_unprotected> 10ad27: 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); 10ad2a: 89 04 24 mov %eax,(%esp) 10ad2d: 89 f9 mov %edi,%ecx 10ad2f: 89 f2 mov %esi,%edx 10ad31: 89 d8 mov %ebx,%eax 10ad33: e8 c5 fc ff ff call 10a9fd Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10ad38: 89 5f 04 mov %ebx,0x4(%edi) before_node = after_node->next; 10ad3b: 8b 03 mov (%ebx),%eax after_node->next = the_node; 10ad3d: 89 3b mov %edi,(%ebx) the_node->next = before_node; 10ad3f: 89 07 mov %eax,(%edi) before_node->previous = the_node; 10ad41: 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( 10ad44: 8b 45 c4 mov -0x3c(%ebp),%eax 10ad47: 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); 10ad4a: 89 04 24 mov %eax,(%esp) 10ad4d: 89 f9 mov %edi,%ecx 10ad4f: 89 f2 mov %esi,%edx 10ad51: 89 d8 mov %ebx,%eax 10ad53: e8 a5 fc ff ff call 10a9fd 10ad58: 83 c4 10 add $0x10,%esp } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10ad5b: 31 c0 xor %eax,%eax 10ad5d: eb 05 jmp 10ad64 check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; } } else { sc = RTEMS_INVALID_ID; 10ad5f: b8 04 00 00 00 mov $0x4,%eax } } return sc; } 10ad64: 8d 65 f4 lea -0xc(%ebp),%esp 10ad67: 5b pop %ebx 10ad68: 5e pop %esi 10ad69: 5f pop %edi 10ad6a: 5d pop %ebp 10ad6b: c3 ret =============================================================================== 00115724 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115724: 55 push %ebp 115725: 89 e5 mov %esp,%ebp 115727: 53 push %ebx 115728: 83 ec 14 sub $0x14,%esp 11572b: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 11572e: b8 0a 00 00 00 mov $0xa,%eax register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 115733: 85 db test %ebx,%ebx 115735: 74 6d je 1157a4 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115737: 50 push %eax 115738: 50 push %eax 115739: 8d 45 f4 lea -0xc(%ebp),%eax 11573c: 50 push %eax 11573d: ff 75 08 pushl 0x8(%ebp) 115740: e8 6f 3c 00 00 call 1193b4 <_Thread_Get> switch ( location ) { 115745: 83 c4 10 add $0x10,%esp 115748: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 11574c: 75 51 jne 11579f case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 11574e: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115754: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115758: 74 39 je 115793 if ( asr->is_enabled ) { 11575a: 80 7a 08 00 cmpb $0x0,0x8(%edx) 11575e: 74 22 je 115782 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115760: 9c pushf 115761: fa cli 115762: 59 pop %ecx *signal_set |= signals; 115763: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115766: 51 push %ecx 115767: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115768: 83 3d 60 83 14 00 00 cmpl $0x0,0x148360 11576f: 74 19 je 11578a 115771: 3b 05 64 83 14 00 cmp 0x148364,%eax 115777: 75 11 jne 11578a <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115779: c6 05 70 83 14 00 01 movb $0x1,0x148370 115780: eb 08 jmp 11578a rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115782: 9c pushf 115783: fa cli 115784: 58 pop %eax *signal_set |= signals; 115785: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115788: 50 push %eax 115789: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 11578a: e8 05 3c 00 00 call 119394 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11578f: 31 c0 xor %eax,%eax 115791: eb 11 jmp 1157a4 } _Thread_Enable_dispatch(); 115793: e8 fc 3b 00 00 call 119394 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115798: b8 0b 00 00 00 mov $0xb,%eax 11579d: eb 05 jmp 1157a4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11579f: b8 04 00 00 00 mov $0x4,%eax } 1157a4: 8b 5d fc mov -0x4(%ebp),%ebx 1157a7: c9 leave 1157a8: c3 ret =============================================================================== 00120a83 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 120a83: 55 push %ebp 120a84: 89 e5 mov %esp,%ebp 120a86: 57 push %edi 120a87: 56 push %esi 120a88: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 120a8b: 83 78 08 00 cmpl $0x0,0x8(%eax) 120a8f: 74 15 je 120aa6 <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 120a91: 8b b8 b8 00 00 00 mov 0xb8(%eax),%edi 120a97: 83 c7 08 add $0x8,%edi 120a9a: be 08 ec 16 00 mov $0x16ec08,%esi 120a9f: b9 04 00 00 00 mov $0x4,%ecx 120aa4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 120aa6: 5e pop %esi 120aa7: 5f pop %edi 120aa8: 5d pop %ebp 120aa9: c3 ret =============================================================================== 001209fc : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 1209fc: 55 push %ebp 1209fd: 89 e5 mov %esp,%ebp 1209ff: 57 push %edi 120a00: 53 push %ebx 120a01: 8b 5d 0c mov 0xc(%ebp),%ebx static uint32_t pattern[ 4 ] = { 0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */ 0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */ }; if ( Stack_check_Initialized ) 120a04: 83 3d 40 da 16 00 00 cmpl $0x0,0x16da40 120a0b: 75 5a jne 120a67 /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 120a0d: c7 05 08 ec 16 00 0d movl $0xfeedf00d,0x16ec08 120a14: f0 ed fe 120a17: c7 05 0c ec 16 00 06 movl $0xbad0d06,0x16ec0c 120a1e: 0d ad 0b 120a21: c7 05 10 ec 16 00 0d movl $0xdeadf00d,0x16ec10 120a28: f0 ad de 120a2b: c7 05 14 ec 16 00 06 movl $0x600d0d06,0x16ec14 120a32: 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) { 120a35: 8b 15 f8 e6 16 00 mov 0x16e6f8,%edx 120a3b: 85 d2 test %edx,%edx 120a3d: 74 1e je 120a5d <== NEVER TAKEN 120a3f: 8b 0d fc e6 16 00 mov 0x16e6fc,%ecx 120a45: 85 c9 test %ecx,%ecx 120a47: 74 14 je 120a5d <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 120a49: 89 15 1c ec 16 00 mov %edx,0x16ec1c Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 120a4f: 29 d1 sub %edx,%ecx 120a51: 89 0d 18 ec 16 00 mov %ecx,0x16ec18 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 120a57: b0 a5 mov $0xa5,%al 120a59: 89 d7 mov %edx,%edi 120a5b: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 120a5d: c7 05 40 da 16 00 01 movl $0x1,0x16da40 120a64: 00 00 00 Thread_Control *the_thread ) { Stack_check_Initialize(); if (the_thread) 120a67: 85 db test %ebx,%ebx 120a69: 74 12 je 120a7d <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 120a6b: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx 120a71: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx 120a77: b0 a5 mov $0xa5,%al 120a79: 89 d7 mov %edx,%edi 120a7b: f3 aa rep stos %al,%es:(%edi) return true; } 120a7d: b0 01 mov $0x1,%al 120a7f: 5b pop %ebx 120a80: 5f pop %edi 120a81: 5d pop %ebp 120a82: c3 ret =============================================================================== 00120bb5 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 120bb5: 55 push %ebp 120bb6: 89 e5 mov %esp,%ebp 120bb8: 53 push %ebx 120bb9: 83 ec 14 sub $0x14,%esp Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 120bbc: 8b 1d 04 e7 16 00 mov 0x16e704,%ebx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 120bc2: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx return false; 120bc8: 31 c9 xor %ecx,%ecx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 120bca: 39 d5 cmp %edx,%ebp 120bcc: 72 0d jb 120bdb <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 120bce: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax 120bd4: 01 d0 add %edx,%eax 120bd6: 39 c5 cmp %eax,%ebp 120bd8: 0f 96 c1 setbe %cl */ bool rtems_stack_checker_is_blown( void ) { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 120bdb: b0 01 mov $0x1,%al /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 120bdd: 83 3d 40 da 16 00 00 cmpl $0x0,0x16da40 120be4: 74 1f je 120c05 <== NEVER TAKEN pattern_ok = (!memcmp( 120be6: 50 push %eax 120be7: 6a 10 push $0x10 120be9: 68 08 ec 16 00 push $0x16ec08 120bee: 83 c2 08 add $0x8,%edx 120bf1: 52 push %edx 120bf2: 88 4d f4 mov %cl,-0xc(%ebp) 120bf5: e8 6e 34 01 00 call 134068 120bfa: 83 c4 10 add $0x10,%esp 120bfd: 85 c0 test %eax,%eax 120bff: 0f 94 c0 sete %al 120c02: 8a 4d f4 mov -0xc(%ebp),%cl /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 120c05: 84 c0 test %al,%al 120c07: 74 04 je 120c0d <== NEVER TAKEN 120c09: 84 c9 test %cl,%cl 120c0b: 75 0c jne 120c19 <== ALWAYS TAKEN Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 120c0d: 52 push %edx <== NOT EXECUTED 120c0e: 52 push %edx <== NOT EXECUTED 120c0f: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 120c12: 50 push %eax <== NOT EXECUTED 120c13: 53 push %ebx <== NOT EXECUTED 120c14: e8 91 fe ff ff call 120aaa <== NOT EXECUTED /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 120c19: 31 c0 xor %eax,%eax 120c1b: 8b 5d fc mov -0x4(%ebp),%ebx 120c1e: c9 leave 120c1f: c3 ret =============================================================================== 00120c85 : void rtems_stack_checker_report_usage( void ) { 120c85: 55 push %ebp <== NOT EXECUTED 120c86: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120c88: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 120c8b: 68 c0 28 12 00 push $0x1228c0 <== NOT EXECUTED 120c90: 6a 00 push $0x0 <== NOT EXECUTED 120c92: e8 89 ff ff ff call 120c20 <== NOT EXECUTED 120c97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 120c9a: c9 leave <== NOT EXECUTED 120c9b: c3 ret <== NOT EXECUTED =============================================================================== 00120c20 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 120c20: 55 push %ebp <== NOT EXECUTED 120c21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120c23: 56 push %esi <== NOT EXECUTED 120c24: 53 push %ebx <== NOT EXECUTED 120c25: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 120c28: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !print ) 120c2b: 85 db test %ebx,%ebx <== NOT EXECUTED 120c2d: 74 4f je 120c7e <== NOT EXECUTED return; print_context = context; 120c2f: 89 35 44 da 16 00 mov %esi,0x16da44 <== NOT EXECUTED print_handler = print; 120c35: 89 1d 48 da 16 00 mov %ebx,0x16da48 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 120c3b: 50 push %eax <== NOT EXECUTED 120c3c: 50 push %eax <== NOT EXECUTED 120c3d: 68 57 00 15 00 push $0x150057 <== NOT EXECUTED 120c42: 56 push %esi <== NOT EXECUTED 120c43: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 120c45: 58 pop %eax <== NOT EXECUTED 120c46: 5a pop %edx <== NOT EXECUTED 120c47: 68 6e 00 15 00 push $0x15006e <== NOT EXECUTED 120c4c: 56 push %esi <== NOT EXECUTED 120c4d: 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 ); 120c4f: c7 04 24 e4 08 12 00 movl $0x1208e4,(%esp) <== NOT EXECUTED 120c56: e8 6d 36 00 00 call 1242c8 <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 120c5b: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 120c62: e8 7d fc ff ff call 1208e4 <== NOT EXECUTED #endif print_context = NULL; 120c67: c7 05 44 da 16 00 00 movl $0x0,0x16da44 <== NOT EXECUTED 120c6e: 00 00 00 print_handler = NULL; 120c71: c7 05 48 da 16 00 00 movl $0x0,0x16da48 <== NOT EXECUTED 120c78: 00 00 00 120c7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 120c7e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 120c81: 5b pop %ebx <== NOT EXECUTED 120c82: 5e pop %esi <== NOT EXECUTED 120c83: 5d pop %ebp <== NOT EXECUTED 120c84: c3 ret <== NOT EXECUTED =============================================================================== 00120b5e : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 120b5e: 55 push %ebp 120b5f: 89 e5 mov %esp,%ebp 120b61: 53 push %ebx 120b62: 83 ec 14 sub $0x14,%esp 120b65: 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); 120b68: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 120b6e: 8d 48 08 lea 0x8(%eax),%ecx { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; 120b71: 31 d2 xor %edx,%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 120b73: 39 c5 cmp %eax,%ebp 120b75: 72 0b jb 120b82 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 120b77: 03 83 b4 00 00 00 add 0xb4(%ebx),%eax 120b7d: 39 c5 cmp %eax,%ebp 120b7f: 0f 96 c2 setbe %dl /* * 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, 120b82: 50 push %eax 120b83: 6a 10 push $0x10 120b85: 68 08 ec 16 00 push $0x16ec08 120b8a: 51 push %ecx 120b8b: 88 55 f4 mov %dl,-0xc(%ebp) 120b8e: e8 d5 34 01 00 call 134068 120b93: 83 c4 10 add $0x10,%esp 120b96: 85 c0 test %eax,%eax (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 120b98: 0f 94 c0 sete %al 120b9b: 8a 55 f4 mov -0xc(%ebp),%dl 120b9e: 75 04 jne 120ba4 <== NEVER TAKEN 120ba0: 84 d2 test %dl,%dl 120ba2: 75 0c jne 120bb0 <== ALWAYS TAKEN Stack_check_report_blown_task( running, pattern_ok ); 120ba4: 51 push %ecx <== NOT EXECUTED 120ba5: 51 push %ecx <== NOT EXECUTED 120ba6: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 120ba9: 50 push %eax <== NOT EXECUTED 120baa: 53 push %ebx <== NOT EXECUTED 120bab: e8 fa fe ff ff call 120aaa <== NOT EXECUTED } } 120bb0: 8b 5d fc mov -0x4(%ebp),%ebx 120bb3: c9 leave 120bb4: c3 ret =============================================================================== 0010e8cc : rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) { 10e8cc: 55 push %ebp 10e8cd: 89 e5 mov %esp,%ebp 10e8cf: 57 push %edi 10e8d0: 56 push %esi 10e8d1: 53 push %ebx 10e8d2: 83 ec 2c sub $0x2c,%esp 10e8d5: 8b 75 08 mov 0x8(%ebp),%esi 10e8d8: 8b 5d 0c mov 0xc(%ebp),%ebx 10e8db: 8b 7d 10 mov 0x10(%ebp),%edi double result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10e8de: ba 09 00 00 00 mov $0x9,%edx ) { double result; char *end; if ( !n ) 10e8e3: 85 db test %ebx,%ebx 10e8e5: 0f 84 95 00 00 00 je 10e980 return RTEMS_INVALID_ADDRESS; errno = 0; 10e8eb: e8 dc 30 00 00 call 1119cc <__errno> 10e8f0: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10e8f6: c7 03 00 00 00 00 movl $0x0,(%ebx) 10e8fc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtod( s, &end ); 10e903: 50 push %eax 10e904: 50 push %eax 10e905: 8d 45 e4 lea -0x1c(%ebp),%eax 10e908: 50 push %eax 10e909: 56 push %esi 10e90a: e8 61 5e 00 00 call 114770 if ( endptr ) 10e90f: 83 c4 10 add $0x10,%esp 10e912: 85 ff test %edi,%edi 10e914: 74 05 je 10e91b *endptr = end; 10e916: 8b 45 e4 mov -0x1c(%ebp),%eax 10e919: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10e91b: ba 0b 00 00 00 mov $0xb,%edx result = strtod( s, &end ); if ( endptr ) *endptr = end; if ( end == s ) 10e920: 39 75 e4 cmp %esi,-0x1c(%ebp) 10e923: 74 4d je 10e972 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10e925: dd 5d c8 fstpl -0x38(%ebp) 10e928: e8 9f 30 00 00 call 1119cc <__errno> 10e92d: 83 38 22 cmpl $0x22,(%eax) 10e930: dd 45 c8 fldl -0x38(%ebp) 10e933: 75 37 jne 10e96c 10e935: d9 ee fldz 10e937: d9 c9 fxch %st(1) 10e939: dd e1 fucom %st(1) 10e93b: df e0 fnstsw %ax 10e93d: dd d9 fstp %st(1) 10e93f: 9e sahf 10e940: 7a 07 jp 10e949 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; 10e942: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10e947: 74 2d je 10e976 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; 10e949: ba 0a 00 00 00 mov $0xa,%edx if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) 10e94e: dd 05 38 45 12 00 fldl 0x124538 10e954: d9 c9 fxch %st(1) 10e956: dd e1 fucom %st(1) 10e958: df e0 fnstsw %ax 10e95a: dd d9 fstp %st(1) 10e95c: 9e sahf 10e95d: 77 1b ja 10e97a 10e95f: dd 05 40 45 12 00 fldl 0x124540 10e965: dd e9 fucomp %st(1) 10e967: df e0 fnstsw %ax 10e969: 9e sahf 10e96a: 77 12 ja 10e97e <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; *n = result; 10e96c: dd 1b fstpl (%ebx) return RTEMS_SUCCESSFUL; 10e96e: 31 d2 xor %edx,%edx 10e970: eb 0e jmp 10e980 10e972: dd d8 fstp %st(0) 10e974: eb 0a jmp 10e980 10e976: dd d8 fstp %st(0) <== NOT EXECUTED 10e978: eb 06 jmp 10e980 <== NOT EXECUTED 10e97a: dd d8 fstp %st(0) 10e97c: eb 02 jmp 10e980 10e97e: dd d8 fstp %st(0) } 10e980: 89 d0 mov %edx,%eax 10e982: 8d 65 f4 lea -0xc(%ebp),%esp 10e985: 5b pop %ebx 10e986: 5e pop %esi 10e987: 5f pop %edi 10e988: 5d pop %ebp 10e989: c3 ret =============================================================================== 0010e98c : rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) { 10e98c: 55 push %ebp 10e98d: 89 e5 mov %esp,%ebp 10e98f: 57 push %edi 10e990: 56 push %esi 10e991: 53 push %ebx 10e992: 83 ec 2c sub $0x2c,%esp 10e995: 8b 75 08 mov 0x8(%ebp),%esi 10e998: 8b 5d 0c mov 0xc(%ebp),%ebx 10e99b: 8b 7d 10 mov 0x10(%ebp),%edi float result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10e99e: ba 09 00 00 00 mov $0x9,%edx ) { float result; char *end; if ( !n ) 10e9a3: 85 db test %ebx,%ebx 10e9a5: 0f 84 8e 00 00 00 je 10ea39 return RTEMS_INVALID_ADDRESS; errno = 0; 10e9ab: e8 1c 30 00 00 call 1119cc <__errno> 10e9b0: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10e9b6: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtof( s, &end ); 10e9bc: 50 push %eax 10e9bd: 50 push %eax 10e9be: 8d 45 e4 lea -0x1c(%ebp),%eax 10e9c1: 50 push %eax 10e9c2: 56 push %esi 10e9c3: e8 cc 5d 00 00 call 114794 if ( endptr ) 10e9c8: 83 c4 10 add $0x10,%esp 10e9cb: 85 ff test %edi,%edi 10e9cd: 74 05 je 10e9d4 *endptr = end; 10e9cf: 8b 45 e4 mov -0x1c(%ebp),%eax 10e9d2: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10e9d4: ba 0b 00 00 00 mov $0xb,%edx result = strtof( s, &end ); if ( endptr ) *endptr = end; if ( end == s ) 10e9d9: 39 75 e4 cmp %esi,-0x1c(%ebp) 10e9dc: 74 4d je 10ea2b return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10e9de: d9 5d c8 fstps -0x38(%ebp) 10e9e1: e8 e6 2f 00 00 call 1119cc <__errno> 10e9e6: 83 38 22 cmpl $0x22,(%eax) 10e9e9: d9 45 c8 flds -0x38(%ebp) 10e9ec: 75 37 jne 10ea25 10e9ee: d9 ee fldz 10e9f0: d9 c9 fxch %st(1) 10e9f2: dd e1 fucom %st(1) 10e9f4: df e0 fnstsw %ax 10e9f6: dd d9 fstp %st(1) 10e9f8: 9e sahf 10e9f9: 7a 07 jp 10ea02 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; 10e9fb: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ea00: 74 2d je 10ea2f <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; 10ea02: ba 0a 00 00 00 mov $0xa,%edx if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) 10ea07: d9 05 48 45 12 00 flds 0x124548 10ea0d: d9 c9 fxch %st(1) 10ea0f: dd e1 fucom %st(1) 10ea11: df e0 fnstsw %ax 10ea13: dd d9 fstp %st(1) 10ea15: 9e sahf 10ea16: 77 1b ja 10ea33 10ea18: d9 05 4c 45 12 00 flds 0x12454c 10ea1e: dd e9 fucomp %st(1) 10ea20: df e0 fnstsw %ax 10ea22: 9e sahf 10ea23: 77 12 ja 10ea37 <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; *n = result; 10ea25: d9 1b fstps (%ebx) return RTEMS_SUCCESSFUL; 10ea27: 31 d2 xor %edx,%edx 10ea29: eb 0e jmp 10ea39 10ea2b: dd d8 fstp %st(0) 10ea2d: eb 0a jmp 10ea39 10ea2f: dd d8 fstp %st(0) <== NOT EXECUTED 10ea31: eb 06 jmp 10ea39 <== NOT EXECUTED 10ea33: dd d8 fstp %st(0) 10ea35: eb 02 jmp 10ea39 10ea37: dd d8 fstp %st(0) } 10ea39: 89 d0 mov %edx,%eax 10ea3b: 8d 65 f4 lea -0xc(%ebp),%esp 10ea3e: 5b pop %ebx 10ea3f: 5e pop %esi 10ea40: 5f pop %edi 10ea41: 5d pop %ebp 10ea42: c3 ret =============================================================================== 0011c6f0 : const char *s, int *n, char **endptr, int base ) { 11c6f0: 55 push %ebp 11c6f1: 89 e5 mov %esp,%ebp 11c6f3: 57 push %edi 11c6f4: 56 push %esi 11c6f5: 53 push %ebx 11c6f6: 83 ec 1c sub $0x1c,%esp 11c6f9: 8b 5d 0c mov 0xc(%ebp),%ebx 11c6fc: 8b 7d 10 mov 0x10(%ebp),%edi long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11c6ff: b8 09 00 00 00 mov $0x9,%eax ) { long result; char *end; if ( !n ) 11c704: 85 db test %ebx,%ebx 11c706: 74 63 je 11c76b return RTEMS_INVALID_ADDRESS; errno = 0; 11c708: e8 7b 47 01 00 call 130e88 <__errno> 11c70d: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11c713: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 11c719: 50 push %eax 11c71a: ff 75 14 pushl 0x14(%ebp) 11c71d: 8d 45 e4 lea -0x1c(%ebp),%eax 11c720: 50 push %eax 11c721: ff 75 08 pushl 0x8(%ebp) 11c724: e8 03 bf 01 00 call 13862c 11c729: 89 c6 mov %eax,%esi if ( endptr ) 11c72b: 83 c4 10 add $0x10,%esp 11c72e: 85 ff test %edi,%edi 11c730: 74 05 je 11c737 *endptr = end; 11c732: 8b 45 e4 mov -0x1c(%ebp),%eax 11c735: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 11c737: b8 0b 00 00 00 mov $0xb,%eax result = strtol( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 11c73c: 8b 55 08 mov 0x8(%ebp),%edx 11c73f: 39 55 e4 cmp %edx,-0x1c(%ebp) 11c742: 74 27 je 11c76b return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11c744: e8 3f 47 01 00 call 130e88 <__errno> 11c749: 83 38 22 cmpl $0x22,(%eax) 11c74c: 75 19 jne 11c767 (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 11c74e: b8 0a 00 00 00 mov $0xa,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11c753: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi 11c759: 74 10 je 11c76b 11c75b: 85 f6 test %esi,%esi 11c75d: 74 0c je 11c76b <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 11c75f: 81 fe 00 00 00 80 cmp $0x80000000,%esi 11c765: 74 04 je 11c76b <== ALWAYS TAKEN errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 11c767: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 11c769: 31 c0 xor %eax,%eax } 11c76b: 8d 65 f4 lea -0xc(%ebp),%esp 11c76e: 5b pop %ebx 11c76f: 5e pop %esi 11c770: 5f pop %edi 11c771: 5d pop %ebp 11c772: c3 ret =============================================================================== 0010eb74 : const char *s, long *n, char **endptr, int base ) { 10eb74: 55 push %ebp 10eb75: 89 e5 mov %esp,%ebp 10eb77: 57 push %edi 10eb78: 56 push %esi 10eb79: 53 push %ebx 10eb7a: 83 ec 1c sub $0x1c,%esp 10eb7d: 8b 5d 0c mov 0xc(%ebp),%ebx 10eb80: 8b 7d 10 mov 0x10(%ebp),%edi long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10eb83: b8 09 00 00 00 mov $0x9,%eax ) { long result; char *end; if ( !n ) 10eb88: 85 db test %ebx,%ebx 10eb8a: 74 63 je 10ebef return RTEMS_INVALID_ADDRESS; errno = 0; 10eb8c: e8 3b 2e 00 00 call 1119cc <__errno> 10eb91: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10eb97: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 10eb9d: 50 push %eax 10eb9e: ff 75 14 pushl 0x14(%ebp) 10eba1: 8d 45 e4 lea -0x1c(%ebp),%eax 10eba4: 50 push %eax 10eba5: ff 75 08 pushl 0x8(%ebp) 10eba8: e8 fb 5d 00 00 call 1149a8 10ebad: 89 c6 mov %eax,%esi if ( endptr ) 10ebaf: 83 c4 10 add $0x10,%esp 10ebb2: 85 ff test %edi,%edi 10ebb4: 74 05 je 10ebbb *endptr = end; 10ebb6: 8b 45 e4 mov -0x1c(%ebp),%eax 10ebb9: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10ebbb: b8 0b 00 00 00 mov $0xb,%eax result = strtol( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10ebc0: 8b 55 08 mov 0x8(%ebp),%edx 10ebc3: 39 55 e4 cmp %edx,-0x1c(%ebp) 10ebc6: 74 27 je 10ebef return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ebc8: e8 ff 2d 00 00 call 1119cc <__errno> 10ebcd: 83 38 22 cmpl $0x22,(%eax) 10ebd0: 75 19 jne 10ebeb (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10ebd2: b8 0a 00 00 00 mov $0xa,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ebd7: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi 10ebdd: 74 10 je 10ebef 10ebdf: 85 f6 test %esi,%esi 10ebe1: 74 0c je 10ebef <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 10ebe3: 81 fe 00 00 00 80 cmp $0x80000000,%esi 10ebe9: 74 04 je 10ebef <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; *n = result; 10ebeb: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 10ebed: 31 c0 xor %eax,%eax } 10ebef: 8d 65 f4 lea -0xc(%ebp),%esp 10ebf2: 5b pop %ebx 10ebf3: 5e pop %esi 10ebf4: 5f pop %edi 10ebf5: 5d pop %ebp 10ebf6: c3 ret =============================================================================== 0010eac8 : const char *s, long long *n, char **endptr, int base ) { 10eac8: 55 push %ebp 10eac9: 89 e5 mov %esp,%ebp 10eacb: 57 push %edi 10eacc: 56 push %esi 10eacd: 53 push %ebx 10eace: 83 ec 2c sub $0x2c,%esp 10ead1: 8b 75 08 mov 0x8(%ebp),%esi 10ead4: 8b 5d 0c mov 0xc(%ebp),%ebx long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10ead7: b8 09 00 00 00 mov $0x9,%eax ) { long long result; char *end; if ( !n ) 10eadc: 85 db test %ebx,%ebx 10eade: 0f 84 85 00 00 00 je 10eb69 return RTEMS_INVALID_ADDRESS; errno = 0; 10eae4: e8 e3 2e 00 00 call 1119cc <__errno> 10eae9: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10eaef: c7 03 00 00 00 00 movl $0x0,(%ebx) 10eaf5: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoll( s, &end, base ); 10eafc: 50 push %eax 10eafd: ff 75 14 pushl 0x14(%ebp) 10eb00: 8d 45 e4 lea -0x1c(%ebp),%eax 10eb03: 50 push %eax 10eb04: 56 push %esi 10eb05: e8 ca 5e 00 00 call 1149d4 10eb0a: 89 c7 mov %eax,%edi if ( endptr ) 10eb0c: 83 c4 10 add $0x10,%esp 10eb0f: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10eb13: 74 08 je 10eb1d *endptr = end; 10eb15: 8b 45 e4 mov -0x1c(%ebp),%eax 10eb18: 8b 4d 10 mov 0x10(%ebp),%ecx 10eb1b: 89 01 mov %eax,(%ecx) if ( end == s ) return RTEMS_NOT_DEFINED; 10eb1d: b8 0b 00 00 00 mov $0xb,%eax result = strtoll( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10eb22: 39 75 e4 cmp %esi,-0x1c(%ebp) 10eb25: 74 42 je 10eb69 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10eb27: 89 55 d4 mov %edx,-0x2c(%ebp) 10eb2a: e8 9d 2e 00 00 call 1119cc <__errno> 10eb2f: 83 38 22 cmpl $0x22,(%eax) 10eb32: 8b 55 d4 mov -0x2c(%ebp),%edx 10eb35: 75 24 jne 10eb5b (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 10eb37: 89 fe mov %edi,%esi 10eb39: f7 d6 not %esi 10eb3b: 89 d0 mov %edx,%eax 10eb3d: 35 ff ff ff 7f xor $0x7fffffff,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10eb42: 09 c6 or %eax,%esi 10eb44: 74 1e je 10eb64 10eb46: 89 f8 mov %edi,%eax 10eb48: 09 d0 or %edx,%eax 10eb4a: 74 18 je 10eb64 <== NEVER TAKEN (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 10eb4c: 8d b2 00 00 00 80 lea -0x80000000(%edx),%esi return RTEMS_INVALID_NUMBER; 10eb52: b8 0a 00 00 00 mov $0xa,%eax if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 10eb57: 09 fe or %edi,%esi 10eb59: 74 0e je 10eb69 <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; *n = result; 10eb5b: 89 3b mov %edi,(%ebx) 10eb5d: 89 53 04 mov %edx,0x4(%ebx) return RTEMS_SUCCESSFUL; 10eb60: 31 c0 xor %eax,%eax 10eb62: eb 05 jmp 10eb69 if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10eb64: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 10eb69: 8d 65 f4 lea -0xc(%ebp),%esp 10eb6c: 5b pop %ebx 10eb6d: 5e pop %esi 10eb6e: 5f pop %edi 10eb6f: 5d pop %ebp 10eb70: c3 ret =============================================================================== 0011c78c : const char *s, unsigned char *n, char **endptr, int base ) { 11c78c: 55 push %ebp 11c78d: 89 e5 mov %esp,%ebp 11c78f: 57 push %edi 11c790: 56 push %esi 11c791: 53 push %ebx 11c792: 83 ec 2c sub $0x2c,%esp 11c795: 8b 75 08 mov 0x8(%ebp),%esi 11c798: 8b 5d 0c mov 0xc(%ebp),%ebx 11c79b: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11c79e: ba 09 00 00 00 mov $0x9,%edx ) { unsigned long result; char *end; if ( !n ) 11c7a3: 85 db test %ebx,%ebx 11c7a5: 74 6f je 11c816 return RTEMS_INVALID_ADDRESS; errno = 0; 11c7a7: e8 dc 46 01 00 call 130e88 <__errno> 11c7ac: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11c7b2: c6 03 00 movb $0x0,(%ebx) result = strtoul( s, &end, base ); 11c7b5: 50 push %eax 11c7b6: ff 75 14 pushl 0x14(%ebp) 11c7b9: 8d 45 e4 lea -0x1c(%ebp),%eax 11c7bc: 50 push %eax 11c7bd: 56 push %esi 11c7be: e8 e5 c3 01 00 call 138ba8 11c7c3: 89 c1 mov %eax,%ecx if ( endptr ) 11c7c5: 83 c4 10 add $0x10,%esp 11c7c8: 85 ff test %edi,%edi 11c7ca: 74 05 je 11c7d1 *endptr = end; 11c7cc: 8b 45 e4 mov -0x1c(%ebp),%eax 11c7cf: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 11c7d1: ba 0b 00 00 00 mov $0xb,%edx result = strtoul( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 11c7d6: 39 75 e4 cmp %esi,-0x1c(%ebp) 11c7d9: 74 3b je 11c816 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11c7db: 89 4d d4 mov %ecx,-0x2c(%ebp) 11c7de: e8 a5 46 01 00 call 130e88 <__errno> 11c7e3: 83 38 22 cmpl $0x22,(%eax) 11c7e6: 8b 4d d4 mov -0x2c(%ebp),%ecx 11c7e9: 75 0d jne 11c7f8 (( result == 0 ) || ( result == ULONG_MAX ))) 11c7eb: 8d 41 ff lea -0x1(%ecx),%eax return RTEMS_INVALID_NUMBER; 11c7ee: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11c7f3: 83 f8 fd cmp $0xfffffffd,%eax 11c7f6: 77 1e ja 11c816 <== ALWAYS TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { 11c7f8: 81 f9 ff 00 00 00 cmp $0xff,%ecx 11c7fe: 76 12 jbe 11c812 errno = ERANGE; 11c800: e8 83 46 01 00 call 130e88 <__errno> 11c805: c7 00 22 00 00 00 movl $0x22,(%eax) return RTEMS_INVALID_NUMBER; 11c80b: ba 0a 00 00 00 mov $0xa,%edx 11c810: eb 04 jmp 11c816 } #endif *n = result; 11c812: 88 0b mov %cl,(%ebx) return RTEMS_SUCCESSFUL; 11c814: 31 d2 xor %edx,%edx } 11c816: 89 d0 mov %edx,%eax 11c818: 8d 65 f4 lea -0xc(%ebp),%esp 11c81b: 5b pop %ebx 11c81c: 5e pop %esi 11c81d: 5f pop %edi 11c81e: 5d pop %ebp 11c81f: c3 ret =============================================================================== 0010eca4 : const char *s, unsigned int *n, char **endptr, int base ) { 10eca4: 55 push %ebp 10eca5: 89 e5 mov %esp,%ebp 10eca7: 57 push %edi 10eca8: 56 push %esi 10eca9: 53 push %ebx 10ecaa: 83 ec 1c sub $0x1c,%esp 10ecad: 8b 5d 0c mov 0xc(%ebp),%ebx 10ecb0: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10ecb3: ba 09 00 00 00 mov $0x9,%edx ) { unsigned long result; char *end; if ( !n ) 10ecb8: 85 db test %ebx,%ebx 10ecba: 74 57 je 10ed13 return RTEMS_INVALID_ADDRESS; errno = 0; 10ecbc: e8 0b 2d 00 00 call 1119cc <__errno> 10ecc1: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10ecc7: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 10eccd: 50 push %eax 10ecce: ff 75 14 pushl 0x14(%ebp) 10ecd1: 8d 45 e4 lea -0x1c(%ebp),%eax 10ecd4: 50 push %eax 10ecd5: ff 75 08 pushl 0x8(%ebp) 10ecd8: e8 47 62 00 00 call 114f24 10ecdd: 89 c6 mov %eax,%esi if ( endptr ) 10ecdf: 83 c4 10 add $0x10,%esp 10ece2: 85 ff test %edi,%edi 10ece4: 74 05 je 10eceb *endptr = end; 10ece6: 8b 45 e4 mov -0x1c(%ebp),%eax 10ece9: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10eceb: ba 0b 00 00 00 mov $0xb,%edx result = strtoul( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10ecf0: 8b 45 08 mov 0x8(%ebp),%eax 10ecf3: 39 45 e4 cmp %eax,-0x1c(%ebp) 10ecf6: 74 1b je 10ed13 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ecf8: e8 cf 2c 00 00 call 1119cc <__errno> 10ecfd: 83 38 22 cmpl $0x22,(%eax) 10ed00: 75 0d jne 10ed0f (( result == 0 ) || ( result == ULONG_MAX ))) 10ed02: 8d 46 ff lea -0x1(%esi),%eax return RTEMS_INVALID_NUMBER; 10ed05: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ed0a: 83 f8 fd cmp $0xfffffffd,%eax 10ed0d: 77 04 ja 10ed13 <== ALWAYS TAKEN errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 10ed0f: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 10ed11: 31 d2 xor %edx,%edx } 10ed13: 89 d0 mov %edx,%eax 10ed15: 8d 65 f4 lea -0xc(%ebp),%esp 10ed18: 5b pop %ebx 10ed19: 5e pop %esi 10ed1a: 5f pop %edi 10ed1b: 5d pop %ebp 10ed1c: c3 ret =============================================================================== 0010d460 : const char *s, unsigned long *n, char **endptr, int base ) { 10d460: 55 push %ebp 10d461: 89 e5 mov %esp,%ebp 10d463: 57 push %edi 10d464: 56 push %esi 10d465: 53 push %ebx 10d466: 83 ec 1c sub $0x1c,%esp 10d469: 8b 5d 0c mov 0xc(%ebp),%ebx 10d46c: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10d46f: ba 09 00 00 00 mov $0x9,%edx ) { unsigned long result; char *end; if ( !n ) 10d474: 85 db test %ebx,%ebx 10d476: 74 57 je 10d4cf return RTEMS_INVALID_ADDRESS; errno = 0; 10d478: e8 0b 3a 02 00 call 130e88 <__errno> 10d47d: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10d483: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 10d489: 50 push %eax 10d48a: ff 75 14 pushl 0x14(%ebp) 10d48d: 8d 45 e4 lea -0x1c(%ebp),%eax 10d490: 50 push %eax 10d491: ff 75 08 pushl 0x8(%ebp) 10d494: e8 0f b7 02 00 call 138ba8 10d499: 89 c6 mov %eax,%esi if ( endptr ) 10d49b: 83 c4 10 add $0x10,%esp 10d49e: 85 ff test %edi,%edi 10d4a0: 74 05 je 10d4a7 *endptr = end; 10d4a2: 8b 45 e4 mov -0x1c(%ebp),%eax 10d4a5: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10d4a7: ba 0b 00 00 00 mov $0xb,%edx result = strtoul( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10d4ac: 8b 45 08 mov 0x8(%ebp),%eax 10d4af: 39 45 e4 cmp %eax,-0x1c(%ebp) 10d4b2: 74 1b je 10d4cf return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10d4b4: e8 cf 39 02 00 call 130e88 <__errno> 10d4b9: 83 38 22 cmpl $0x22,(%eax) 10d4bc: 75 0d jne 10d4cb (( result == 0 ) || ( result == ULONG_MAX ))) 10d4be: 8d 46 ff lea -0x1(%esi),%eax return RTEMS_INVALID_NUMBER; 10d4c1: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10d4c6: 83 f8 fd cmp $0xfffffffd,%eax 10d4c9: 77 04 ja 10d4cf <== ALWAYS TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 10d4cb: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 10d4cd: 31 d2 xor %edx,%edx } 10d4cf: 89 d0 mov %edx,%eax 10d4d1: 8d 65 f4 lea -0xc(%ebp),%esp 10d4d4: 5b pop %ebx 10d4d5: 5e pop %esi 10d4d6: 5f pop %edi 10d4d7: 5d pop %ebp 10d4d8: c3 ret =============================================================================== 0010ed20 : const char *s, unsigned long long *n, char **endptr, int base ) { 10ed20: 55 push %ebp 10ed21: 89 e5 mov %esp,%ebp 10ed23: 57 push %edi 10ed24: 56 push %esi 10ed25: 53 push %ebx 10ed26: 83 ec 1c sub $0x1c,%esp 10ed29: 8b 5d 08 mov 0x8(%ebp),%ebx unsigned long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10ed2c: b8 09 00 00 00 mov $0x9,%eax ) { unsigned long long result; char *end; if ( !n ) 10ed31: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10ed35: 74 75 je 10edac return RTEMS_INVALID_ADDRESS; errno = 0; 10ed37: e8 90 2c 00 00 call 1119cc <__errno> 10ed3c: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10ed42: 8b 45 0c mov 0xc(%ebp),%eax 10ed45: c7 00 00 00 00 00 movl $0x0,(%eax) 10ed4b: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) result = strtoull( s, &end, base ); 10ed52: 50 push %eax 10ed53: ff 75 14 pushl 0x14(%ebp) 10ed56: 8d 45 e4 lea -0x1c(%ebp),%eax 10ed59: 50 push %eax 10ed5a: 53 push %ebx 10ed5b: e8 f0 61 00 00 call 114f50 10ed60: 89 c6 mov %eax,%esi 10ed62: 89 d7 mov %edx,%edi if ( endptr ) 10ed64: 83 c4 10 add $0x10,%esp 10ed67: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10ed6b: 74 08 je 10ed75 *endptr = end; 10ed6d: 8b 45 e4 mov -0x1c(%ebp),%eax 10ed70: 8b 55 10 mov 0x10(%ebp),%edx 10ed73: 89 02 mov %eax,(%edx) if ( end == s ) return RTEMS_NOT_DEFINED; 10ed75: b8 0b 00 00 00 mov $0xb,%eax result = strtoull( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10ed7a: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10ed7d: 74 2d je 10edac return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ed7f: e8 48 2c 00 00 call 1119cc <__errno> 10ed84: 83 38 22 cmpl $0x22,(%eax) 10ed87: 75 19 jne 10eda2 (( result == 0 ) || ( result == ULONG_LONG_MAX ))) 10ed89: 89 f1 mov %esi,%ecx 10ed8b: 89 fb mov %edi,%ebx 10ed8d: 83 c1 ff add $0xffffffff,%ecx 10ed90: 83 d3 ff adc $0xffffffff,%ebx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ed93: 83 fb ff cmp $0xffffffff,%ebx 10ed96: 72 0a jb 10eda2 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; 10ed98: b8 0a 00 00 00 mov $0xa,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ed9d: 83 f9 fd cmp $0xfffffffd,%ecx 10eda0: 77 0a ja 10edac <== ALWAYS TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 10eda2: 8b 45 0c mov 0xc(%ebp),%eax 10eda5: 89 30 mov %esi,(%eax) 10eda7: 89 78 04 mov %edi,0x4(%eax) return RTEMS_SUCCESSFUL; 10edaa: 31 c0 xor %eax,%eax } 10edac: 8d 65 f4 lea -0xc(%ebp),%esp 10edaf: 5b pop %ebx 10edb0: 5e pop %esi 10edb1: 5f pop %edi 10edb2: 5d pop %ebp 10edb3: c3 ret =============================================================================== 0010b68c : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10b68c: 55 push %ebp 10b68d: 89 e5 mov %esp,%ebp 10b68f: 56 push %esi 10b690: 53 push %ebx 10b691: 83 ec 10 sub $0x10,%esp 10b694: 8b 55 08 mov 0x8(%ebp),%edx 10b697: 8b 75 0c mov 0xc(%ebp),%esi 10b69a: 8b 5d 10 mov 0x10(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10b69d: b8 16 00 00 00 mov $0x16,%eax { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10b6a2: 80 3d 54 cf 12 00 00 cmpb $0x0,0x12cf54 10b6a9: 74 5d je 10b708 <== NEVER TAKEN return RTEMS_NOT_CONFIGURED; if ( !note ) 10b6ab: 85 db test %ebx,%ebx 10b6ad: 74 4d je 10b6fc * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) return RTEMS_INVALID_NUMBER; 10b6af: b0 0a mov $0xa,%al /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10b6b1: 83 fe 0f cmp $0xf,%esi 10b6b4: 77 52 ja 10b708 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10b6b6: 85 d2 test %edx,%edx 10b6b8: a1 3c 19 13 00 mov 0x13193c,%eax 10b6bd: 74 05 je 10b6c4 10b6bf: 3b 50 08 cmp 0x8(%eax),%edx 10b6c2: 75 0e jne 10b6d2 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10b6c4: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax 10b6ca: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10b6ce: 89 03 mov %eax,(%ebx) 10b6d0: eb 26 jmp 10b6f8 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10b6d2: 50 push %eax 10b6d3: 50 push %eax 10b6d4: 8d 45 f4 lea -0xc(%ebp),%eax 10b6d7: 50 push %eax 10b6d8: 52 push %edx 10b6d9: e8 fe 1f 00 00 call 10d6dc <_Thread_Get> switch ( location ) { 10b6de: 83 c4 10 add $0x10,%esp 10b6e1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b6e5: 75 1c jne 10b703 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10b6e7: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax 10b6ed: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10b6f1: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b6f3: e8 c4 1f 00 00 call 10d6bc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b6f8: 31 c0 xor %eax,%eax 10b6fa: eb 0c jmp 10b708 if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) return RTEMS_INVALID_ADDRESS; 10b6fc: b8 09 00 00 00 mov $0x9,%eax 10b701: eb 05 jmp 10b708 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b703: b8 04 00 00 00 mov $0x4,%eax } 10b708: 8d 65 f8 lea -0x8(%ebp),%esp 10b70b: 5b pop %ebx 10b70c: 5e pop %esi 10b70d: 5d pop %ebp 10b70e: c3 ret =============================================================================== 00110a2c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110a2c: 55 push %ebp 110a2d: 89 e5 mov %esp,%ebp 110a2f: 57 push %edi 110a30: 56 push %esi 110a31: 53 push %ebx 110a32: 83 ec 1c sub $0x1c,%esp ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 110a35: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 110a39: 0f 84 00 01 00 00 je 110b3f return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110a3f: 8b 35 ec e8 12 00 mov 0x12e8ec,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110a45: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110a4b: 80 7e 70 01 cmpb $0x1,0x70(%esi) 110a4f: 19 ff sbb %edi,%edi 110a51: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110a57: 83 7e 78 00 cmpl $0x0,0x78(%esi) 110a5b: 74 06 je 110a63 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110a5d: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110a63: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110a67: 19 c9 sbb %ecx,%ecx 110a69: 81 e1 00 04 00 00 and $0x400,%ecx old_mode |= _ISR_Get_level(); 110a6f: 89 4d e4 mov %ecx,-0x1c(%ebp) 110a72: e8 89 c4 ff ff call 10cf00 <_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; 110a77: 8b 4d e4 mov -0x1c(%ebp),%ecx 110a7a: 09 c8 or %ecx,%eax old_mode |= _ISR_Get_level(); 110a7c: 09 f8 or %edi,%eax 110a7e: 8b 55 10 mov 0x10(%ebp),%edx 110a81: 89 02 mov %eax,(%edx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110a83: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110a8a: 74 0f je 110a9b 110a8c: 8b 45 08 mov 0x8(%ebp),%eax 110a8f: c1 e8 08 shr $0x8,%eax 110a92: 83 f0 01 xor $0x1,%eax 110a95: 83 e0 01 and $0x1,%eax 110a98: 88 46 70 mov %al,0x70(%esi) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; if ( mask & RTEMS_TIMESLICE_MASK ) { 110a9b: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110aa2: 74 21 je 110ac5 if ( _Modes_Is_timeslice(mode_set) ) { 110aa4: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110aab: 74 11 je 110abe executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110aad: c7 46 78 01 00 00 00 movl $0x1,0x78(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110ab4: a1 b8 e3 12 00 mov 0x12e3b8,%eax 110ab9: 89 46 74 mov %eax,0x74(%esi) 110abc: eb 07 jmp 110ac5 } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110abe: c7 46 78 00 00 00 00 movl $0x0,0x78(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110ac5: f6 45 0c 01 testb $0x1,0xc(%ebp) 110ac9: 74 0a je 110ad5 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110acb: f6 45 08 01 testb $0x1,0x8(%ebp) 110acf: 74 03 je 110ad4 110ad1: fa cli 110ad2: eb 01 jmp 110ad5 110ad4: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110ad5: 31 d2 xor %edx,%edx if ( mask & RTEMS_ASR_MASK ) { 110ad7: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110ade: 74 2c je 110b0c is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; 110ae0: 8b 45 08 mov 0x8(%ebp),%eax 110ae3: c1 e8 0a shr $0xa,%eax 110ae6: 83 f0 01 xor $0x1,%eax 110ae9: 83 e0 01 and $0x1,%eax if ( is_asr_enabled != asr->is_enabled ) { 110aec: 3a 43 08 cmp 0x8(%ebx),%al 110aef: 74 1b je 110b0c asr->is_enabled = is_asr_enabled; 110af1: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110af4: 9c pushf 110af5: fa cli 110af6: 58 pop %eax _signals = information->signals_pending; 110af7: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110afa: 8b 4b 14 mov 0x14(%ebx),%ecx 110afd: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110b00: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110b03: 50 push %eax 110b04: 9d popf _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 110b05: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110b09: 0f 95 c2 setne %dl if ( _System_state_Is_up( _System_state_Get() ) ) { if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 110b0c: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110b0e: 83 3d 20 e5 12 00 03 cmpl $0x3,0x12e520 110b15: 75 2d jne 110b44 bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110b17: 8b 0d ec e8 12 00 mov 0x12e8ec,%ecx if ( are_signals_pending || 110b1d: 84 d2 test %dl,%dl 110b1f: 75 0e jne 110b2f 110b21: 3b 0d f0 e8 12 00 cmp 0x12e8f0,%ecx 110b27: 74 1b je 110b44 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110b29: 80 79 70 00 cmpb $0x0,0x70(%ecx) 110b2d: 74 15 je 110b44 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110b2f: c6 05 f8 e8 12 00 01 movb $0x1,0x12e8f8 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110b36: e8 95 b1 ff ff call 10bcd0 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110b3b: 31 c0 xor %eax,%eax 110b3d: eb 05 jmp 110b44 bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 110b3f: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 110b44: 83 c4 1c add $0x1c,%esp 110b47: 5b pop %ebx 110b48: 5e pop %esi 110b49: 5f pop %edi 110b4a: 5d pop %ebp 110b4b: c3 ret =============================================================================== 0010d48c : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10d48c: 55 push %ebp 10d48d: 89 e5 mov %esp,%ebp 10d48f: 56 push %esi 10d490: 53 push %ebx 10d491: 83 ec 10 sub $0x10,%esp 10d494: 8b 5d 0c mov 0xc(%ebp),%ebx 10d497: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10d49a: 85 db test %ebx,%ebx 10d49c: 74 10 je 10d4ae 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 ) ); 10d49e: 0f b6 15 88 e1 12 00 movzbl 0x12e188,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10d4a5: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10d4aa: 39 d3 cmp %edx,%ebx 10d4ac: 77 52 ja 10d500 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10d4ae: b8 09 00 00 00 mov $0x9,%eax if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10d4b3: 85 f6 test %esi,%esi 10d4b5: 74 49 je 10d500 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10d4b7: 51 push %ecx 10d4b8: 51 push %ecx 10d4b9: 8d 45 f4 lea -0xc(%ebp),%eax 10d4bc: 50 push %eax 10d4bd: ff 75 08 pushl 0x8(%ebp) 10d4c0: e8 d7 1d 00 00 call 10f29c <_Thread_Get> switch ( location ) { 10d4c5: 83 c4 10 add $0x10,%esp 10d4c8: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10d4cc: 75 2d jne 10d4fb case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10d4ce: 8b 50 14 mov 0x14(%eax),%edx 10d4d1: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10d4d3: 85 db test %ebx,%ebx 10d4d5: 74 1b je 10d4f2 the_thread->real_priority = new_priority; 10d4d7: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10d4da: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10d4de: 74 05 je 10d4e5 10d4e0: 39 58 14 cmp %ebx,0x14(%eax) 10d4e3: 76 0d jbe 10d4f2 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10d4e5: 52 push %edx 10d4e6: 6a 00 push $0x0 10d4e8: 53 push %ebx 10d4e9: 50 push %eax 10d4ea: e8 9d 19 00 00 call 10ee8c <_Thread_Change_priority> 10d4ef: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10d4f2: e8 85 1d 00 00 call 10f27c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d4f7: 31 c0 xor %eax,%eax 10d4f9: eb 05 jmp 10d500 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d4fb: b8 04 00 00 00 mov $0x4,%eax } 10d500: 8d 65 f8 lea -0x8(%ebp),%esp 10d503: 5b pop %ebx 10d504: 5e pop %esi 10d505: 5d pop %ebp 10d506: c3 ret =============================================================================== 00108cfc : #include int rtems_termios_baud_to_index( rtems_termios_baud_t termios_baud ) { 108cfc: 55 push %ebp 108cfd: 89 e5 mov %esp,%ebp 108cff: 8b 55 08 mov 0x8(%ebp),%edx int baud_index; switch (termios_baud) { 108d02: 83 fa 09 cmp $0x9,%edx 108d05: 0f 84 eb 00 00 00 je 108df6 108d0b: 77 61 ja 108d6e 108d0d: 83 fa 04 cmp $0x4,%edx 108d10: 0f 84 c4 00 00 00 je 108dda 108d16: 77 2b ja 108d43 108d18: 83 fa 01 cmp $0x1,%edx 108d1b: 0f 84 20 01 00 00 je 108e41 case B0: baud_index = 0; break; 108d21: b8 00 00 00 00 mov $0x0,%eax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108d26: 0f 82 1a 01 00 00 jb 108e46 108d2c: 83 fa 02 cmp $0x2,%edx 108d2f: 0f 84 97 00 00 00 je 108dcc 108d35: 83 fa 03 cmp $0x3,%edx 108d38: 0f 85 fe 00 00 00 jne 108e3c <== NEVER TAKEN 108d3e: e9 90 00 00 00 jmp 108dd3 108d43: 83 fa 06 cmp $0x6,%edx 108d46: 0f 84 95 00 00 00 je 108de1 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; 108d4c: b8 05 00 00 00 mov $0x5,%eax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108d51: 0f 82 ef 00 00 00 jb 108e46 108d57: 83 fa 07 cmp $0x7,%edx 108d5a: 0f 84 88 00 00 00 je 108de8 108d60: 83 fa 08 cmp $0x8,%edx 108d63: 0f 85 d3 00 00 00 jne 108e3c <== NEVER TAKEN 108d69: e9 81 00 00 00 jmp 108def 108d6e: 83 fa 0e cmp $0xe,%edx 108d71: 0f 84 9b 00 00 00 je 108e12 108d77: 77 20 ja 108d99 108d79: 83 fa 0b cmp $0xb,%edx 108d7c: 74 7f je 108dfd 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; 108d7e: b8 0a 00 00 00 mov $0xa,%eax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108d83: 0f 82 bd 00 00 00 jb 108e46 108d89: 83 fa 0c cmp $0xc,%edx 108d8c: 74 76 je 108e04 108d8e: 83 fa 0d cmp $0xd,%edx 108d91: 0f 85 a5 00 00 00 jne 108e3c <== NEVER TAKEN 108d97: eb 72 jmp 108e0b 108d99: 81 fa 02 10 00 00 cmp $0x1002,%edx 108d9f: 0f 84 82 00 00 00 je 108e27 108da5: 77 13 ja 108dba 108da7: 83 fa 0f cmp $0xf,%edx 108daa: 74 6d je 108e19 108dac: 81 fa 01 10 00 00 cmp $0x1001,%edx 108db2: 0f 85 84 00 00 00 jne 108e3c <== NEVER TAKEN 108db8: eb 66 jmp 108e20 108dba: 81 fa 03 10 00 00 cmp $0x1003,%edx 108dc0: 74 6c je 108e2e 108dc2: 81 fa 04 10 00 00 cmp $0x1004,%edx 108dc8: 75 72 jne 108e3c 108dca: eb 69 jmp 108e35 case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; 108dcc: b8 02 00 00 00 mov $0x2,%eax 108dd1: eb 73 jmp 108e46 case B110: baud_index = 3; break; 108dd3: b8 03 00 00 00 mov $0x3,%eax 108dd8: eb 6c jmp 108e46 case B134: baud_index = 4; break; 108dda: b8 04 00 00 00 mov $0x4,%eax 108ddf: eb 65 jmp 108e46 case B150: baud_index = 5; break; case B200: baud_index = 6; break; 108de1: b8 06 00 00 00 mov $0x6,%eax 108de6: eb 5e jmp 108e46 case B300: baud_index = 7; break; 108de8: b8 07 00 00 00 mov $0x7,%eax 108ded: eb 57 jmp 108e46 case B600: baud_index = 8; break; 108def: b8 08 00 00 00 mov $0x8,%eax 108df4: eb 50 jmp 108e46 case B1200: baud_index = 9; break; 108df6: b8 09 00 00 00 mov $0x9,%eax 108dfb: eb 49 jmp 108e46 case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; 108dfd: b8 0b 00 00 00 mov $0xb,%eax 108e02: eb 42 jmp 108e46 case B4800: baud_index = 12; break; 108e04: b8 0c 00 00 00 mov $0xc,%eax 108e09: eb 3b jmp 108e46 case B9600: baud_index = 13; break; 108e0b: b8 0d 00 00 00 mov $0xd,%eax 108e10: eb 34 jmp 108e46 case B19200: baud_index = 14; break; 108e12: b8 0e 00 00 00 mov $0xe,%eax 108e17: eb 2d jmp 108e46 case B38400: baud_index = 15; break; 108e19: b8 0f 00 00 00 mov $0xf,%eax 108e1e: eb 26 jmp 108e46 case B57600: baud_index = 16; break; 108e20: b8 10 00 00 00 mov $0x10,%eax 108e25: eb 1f jmp 108e46 case B115200: baud_index = 17; break; 108e27: b8 11 00 00 00 mov $0x11,%eax 108e2c: eb 18 jmp 108e46 case B230400: baud_index = 18; break; 108e2e: b8 12 00 00 00 mov $0x12,%eax 108e33: eb 11 jmp 108e46 case B460800: baud_index = 19; break; 108e35: b8 13 00 00 00 mov $0x13,%eax 108e3a: eb 0a jmp 108e46 default: baud_index = -1; break; 108e3c: 83 c8 ff or $0xffffffff,%eax 108e3f: eb 05 jmp 108e46 { int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; 108e41: b8 01 00 00 00 mov $0x1,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 108e46: 5d pop %ebp 108e47: c3 ret =============================================================================== 001083dd : } } rtems_status_code rtems_termios_close (void *arg) { 1083dd: 55 push %ebp 1083de: 89 e5 mov %esp,%ebp 1083e0: 56 push %esi 1083e1: 53 push %ebx 1083e2: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 1083e5: 8b 06 mov (%esi),%eax 1083e7: 8b 58 2c mov 0x2c(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain( 1083ea: 50 push %eax 1083eb: 6a 00 push $0x0 1083ed: 6a 00 push $0x0 1083ef: ff 35 14 e3 12 00 pushl 0x12e314 1083f5: e8 96 19 00 00 call 109d90 rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1083fa: 83 c4 10 add $0x10,%esp 1083fd: 85 c0 test %eax,%eax 1083ff: 74 05 je 108406 <== ALWAYS TAKEN 108401: e9 8f 00 00 00 jmp 108495 <== NOT EXECUTED rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 108406: ff 4b 08 decl 0x8(%ebx) 108409: 0f 85 4b 01 00 00 jne 10855a if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10840f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108415: c1 e0 05 shl $0x5,%eax 108418: 8b 80 c4 df 12 00 mov 0x12dfc4(%eax),%eax 10841e: 85 c0 test %eax,%eax 108420: 74 08 je 10842a /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108422: 83 ec 0c sub $0xc,%esp 108425: 53 push %ebx 108426: ff d0 call *%eax 108428: eb 31 jmp 10845b } else { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10842a: 50 push %eax 10842b: 6a 00 push $0x0 10842d: 6a 00 push $0x0 10842f: ff 73 18 pushl 0x18(%ebx) 108432: e8 59 19 00 00 call 109d90 if (sc != RTEMS_SUCCESSFUL) { 108437: 83 c4 10 add $0x10,%esp 10843a: 85 c0 test %eax,%eax 10843c: 74 02 je 108440 <== ALWAYS TAKEN 10843e: eb 55 jmp 108495 <== NOT EXECUTED drainOutput (struct rtems_termios_tty *tty) { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 108440: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 108447: 74 07 je 108450 108449: 89 d8 mov %ebx,%eax 10844b: e8 56 fb ff ff call 107fa6 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); 108450: 83 ec 0c sub $0xc,%esp 108453: ff 73 18 pushl 0x18(%ebx) 108456: e8 25 1a 00 00 call 109e80 10845b: 83 c4 10 add $0x10,%esp } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10845e: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108465: 75 37 jne 10849e /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); 108467: 50 push %eax 108468: 50 push %eax 108469: 6a 01 push $0x1 10846b: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 108471: e8 4e 15 00 00 call 1099c4 if (sc != RTEMS_SUCCESSFUL) 108476: 83 c4 10 add $0x10,%esp 108479: 85 c0 test %eax,%eax 10847b: 74 02 je 10847f <== ALWAYS TAKEN 10847d: eb 16 jmp 108495 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); 10847f: 51 push %ecx 108480: 51 push %ecx 108481: 6a 01 push $0x1 108483: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 108489: e8 36 15 00 00 call 1099c4 if (sc != RTEMS_SUCCESSFUL) 10848e: 83 c4 10 add $0x10,%esp 108491: 85 c0 test %eax,%eax 108493: 74 09 je 10849e <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108495: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108498: 50 push %eax <== NOT EXECUTED 108499: e8 16 1f 00 00 call 10a3b4 <== NOT EXECUTED } if (tty->device.lastClose) 10849e: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 1084a4: 85 c0 test %eax,%eax 1084a6: 74 0d je 1084b5 (*tty->device.lastClose)(tty->major, tty->minor, arg); 1084a8: 52 push %edx 1084a9: 56 push %esi 1084aa: ff 73 10 pushl 0x10(%ebx) 1084ad: ff 73 0c pushl 0xc(%ebx) 1084b0: ff d0 call *%eax 1084b2: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 1084b5: 8b 13 mov (%ebx),%edx 1084b7: 85 d2 test %edx,%edx 1084b9: 8b 43 04 mov 0x4(%ebx),%eax 1084bc: 75 11 jne 1084cf rtems_termios_ttyTail = tty->back; 1084be: a3 18 e3 12 00 mov %eax,0x12e318 if ( rtems_termios_ttyTail != NULL ) { 1084c3: 85 c0 test %eax,%eax 1084c5: 74 0b je 1084d2 <== ALWAYS TAKEN rtems_termios_ttyTail->forw = NULL; 1084c7: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 1084cd: eb 03 jmp 1084d2 <== NOT EXECUTED } } else { tty->forw->back = tty->back; 1084cf: 89 42 04 mov %eax,0x4(%edx) } if (tty->back == NULL) { 1084d2: 8b 53 04 mov 0x4(%ebx),%edx 1084d5: 85 d2 test %edx,%edx 1084d7: 8b 03 mov (%ebx),%eax 1084d9: 75 12 jne 1084ed <== NEVER TAKEN rtems_termios_ttyHead = tty->forw; 1084db: a3 1c e3 12 00 mov %eax,0x12e31c if ( rtems_termios_ttyHead != NULL ) { 1084e0: 85 c0 test %eax,%eax 1084e2: 74 0b je 1084ef rtems_termios_ttyHead->back = NULL; 1084e4: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 1084eb: eb 02 jmp 1084ef } } else { tty->back->forw = tty->forw; 1084ed: 89 02 mov %eax,(%edx) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 1084ef: 83 ec 0c sub $0xc,%esp 1084f2: ff 73 14 pushl 0x14(%ebx) 1084f5: e8 06 18 00 00 call 109d00 rtems_semaphore_delete (tty->osem); 1084fa: 58 pop %eax 1084fb: ff 73 18 pushl 0x18(%ebx) 1084fe: e8 fd 17 00 00 call 109d00 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 108503: 58 pop %eax 108504: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10850a: e8 f1 17 00 00 call 109d00 if ((tty->device.pollRead == NULL) || 10850f: 83 c4 10 add $0x10,%esp 108512: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 108519: 74 09 je 108524 10851b: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108522: 75 0e jne 108532 (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 108524: 83 ec 0c sub $0xc,%esp 108527: ff 73 68 pushl 0x68(%ebx) 10852a: e8 d1 17 00 00 call 109d00 10852f: 83 c4 10 add $0x10,%esp free (tty->rawInBuf.theBuf); 108532: 83 ec 0c sub $0xc,%esp 108535: ff 73 58 pushl 0x58(%ebx) 108538: e8 f7 e1 ff ff call 106734 free (tty->rawOutBuf.theBuf); 10853d: 58 pop %eax 10853e: ff 73 7c pushl 0x7c(%ebx) 108541: e8 ee e1 ff ff call 106734 free (tty->cbuf); 108546: 58 pop %eax 108547: ff 73 1c pushl 0x1c(%ebx) 10854a: e8 e5 e1 ff ff call 106734 free (tty); 10854f: 89 1c 24 mov %ebx,(%esp) 108552: e8 dd e1 ff ff call 106734 108557: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 10855a: 83 ec 0c sub $0xc,%esp 10855d: ff 35 14 e3 12 00 pushl 0x12e314 108563: e8 18 19 00 00 call 109e80 return RTEMS_SUCCESSFUL; } 108568: 31 c0 xor %eax,%eax 10856a: 8d 65 f8 lea -0x8(%ebp),%esp 10856d: 5b pop %ebx 10856e: 5e pop %esi 10856f: 5d pop %ebp 108570: c3 ret =============================================================================== 00109495 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 109495: 55 push %ebp 109496: 89 e5 mov %esp,%ebp 109498: 83 ec 08 sub $0x8,%esp 10949b: 8b 45 08 mov 0x8(%ebp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 10949e: 8b 55 0c mov 0xc(%ebp),%edx 1094a1: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1094a7: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 1094ae: 75 1f jne 1094cf /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT); 1094b0: 52 push %edx 1094b1: 52 push %edx 1094b2: 6a 02 push $0x2 1094b4: ff b0 c8 00 00 00 pushl 0xc8(%eax) 1094ba: e8 05 05 00 00 call 1099c4 if (sc != RTEMS_SUCCESSFUL) 1094bf: 83 c4 10 add $0x10,%esp 1094c2: 85 c0 test %eax,%eax 1094c4: 74 2d je 1094f3 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 1094c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094c9: 50 push %eax <== NOT EXECUTED 1094ca: e8 e5 0e 00 00 call 10a3b4 <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } if (tty->t_line == PPPDISC ) { 1094cf: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 1094d6: 75 15 jne 1094ed <== ALWAYS TAKEN /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 1094d8: 8b 15 74 e0 12 00 mov 0x12e074,%edx 1094de: 85 d2 test %edx,%edx 1094e0: 74 11 je 1094f3 <== NEVER TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 1094e2: 83 ec 0c sub $0xc,%esp 1094e5: 50 push %eax 1094e6: ff d2 call *%edx 1094e8: 83 c4 10 add $0x10,%esp 1094eb: eb 06 jmp 1094f3 } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); } 1094ed: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 1094ee: e9 8d e8 ff ff jmp 107d80 } 1094f3: 31 c0 xor %eax,%eax 1094f5: c9 leave 1094f6: c3 ret =============================================================================== 001091b7 : * 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) { 1091b7: 55 push %ebp 1091b8: 89 e5 mov %esp,%ebp 1091ba: 57 push %edi 1091bb: 56 push %esi 1091bc: 53 push %ebx 1091bd: 83 ec 2c sub $0x2c,%esp 1091c0: 8b 5d 08 mov 0x8(%ebp),%ebx 1091c3: 8b 75 0c mov 0xc(%ebp),%esi 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) { 1091c6: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 1091cc: c1 e0 05 shl $0x5,%eax 1091cf: 83 b8 d0 df 12 00 00 cmpl $0x0,0x12dfd0(%eax) 1091d6: 8b 45 10 mov 0x10(%ebp),%eax 1091d9: 8d 04 06 lea (%esi,%eax,1),%eax 1091dc: 89 45 dc mov %eax,-0x24(%ebp) 1091df: 75 31 jne 109212 * 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) 1091e1: c6 45 e3 00 movb $0x0,-0x1d(%ebp) 1091e5: 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); 1091e7: 8d 4b 30 lea 0x30(%ebx),%ecx 1091ea: 89 4d d4 mov %ecx,-0x2c(%ebp) (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); 1091ed: 8d 4b 4a lea 0x4a(%ebx),%ecx 1091f0: 89 4d d0 mov %ecx,-0x30(%ebp) 1091f3: e9 0a 02 00 00 jmp 109402 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--) { c = *buf++; 1091f8: 0f be 16 movsbl (%esi),%edx 1091fb: 46 inc %esi rtems_termios_linesw[tty->t_line].l_rint(c,tty); 1091fc: 57 push %edi 1091fd: 57 push %edi 1091fe: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109204: c1 e0 05 shl $0x5,%eax 109207: 53 push %ebx 109208: 52 push %edx 109209: ff 90 d0 df 12 00 call *0x12dfd0(%eax) 10920f: 83 c4 10 add $0x10,%esp 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--) { 109212: 3b 75 dc cmp -0x24(%ebp),%esi 109215: 75 e1 jne 1091f8 */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); tty->tty_rcvwakeup = 1; } return 0; 109217: 31 ff xor %edi,%edi } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 109219: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) 109220: 0f 85 01 02 00 00 jne 109427 <== NEVER TAKEN 109226: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10922c: 85 c0 test %eax,%eax 10922e: 0f 84 f3 01 00 00 je 109427 (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 109234: 51 push %ecx 109235: 51 push %ecx 109236: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 10923c: 8d 53 30 lea 0x30(%ebx),%edx 10923f: 52 push %edx 109240: ff d0 call *%eax tty->tty_rcvwakeup = 1; 109242: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) 109249: 00 00 00 10924c: e9 c8 01 00 00 jmp 109419 } return 0; } while (len--) { c = *buf++; 109251: 8a 0e mov (%esi),%cl 109253: 88 4d e2 mov %cl,-0x1e(%ebp) 109256: 46 inc %esi /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 109257: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10925d: f6 c4 02 test $0x2,%ah 109260: 74 3b je 10929d /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 109262: 0f be c1 movsbl %cl,%eax 109265: 0f b6 53 4a movzbl 0x4a(%ebx),%edx 109269: 39 d0 cmp %edx,%eax if (c == tty->termios.c_cc[VSTART]) { 10926b: 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]) { 10926f: 75 1d jne 10928e if (c == tty->termios.c_cc[VSTART]) { 109271: 39 d0 cmp %edx,%eax /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 109273: 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]) { 109279: 75 05 jne 109280 <== ALWAYS TAKEN /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 10927b: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 10927e: eb 03 jmp 109283 <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 109280: 83 c8 10 or $0x10,%eax 109283: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) 109289: e9 90 01 00 00 jmp 10941e } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 10928e: 39 d0 cmp %edx,%eax 109290: 75 0b jne 10929d <== ALWAYS TAKEN /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 109292: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109298: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 10929b: eb e6 jmp 109283 <== NOT EXECUTED flow_rcv = true; } } if (flow_rcv) { 10929d: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 1092a1: 74 51 je 1092f4 <== ALWAYS TAKEN /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 1092a3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1092a9: 83 e0 30 and $0x30,%eax 1092ac: 83 f8 20 cmp $0x20,%eax 1092af: 0f 85 4d 01 00 00 jne 109402 <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 1092b5: 9c pushf <== NOT EXECUTED 1092b6: fa cli <== NOT EXECUTED 1092b7: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 1092ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092c0: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 1092c3: 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) { 1092c9: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1092d0: 74 19 je 1092eb <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); 1092d2: 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)( 1092d8: 52 push %edx <== NOT EXECUTED 1092d9: 6a 01 push $0x1 <== NOT EXECUTED 1092db: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 1092de: 50 push %eax <== NOT EXECUTED 1092df: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1092e2: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1092e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 1092eb: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 1092ee: 9d popf <== NOT EXECUTED 1092ef: e9 0e 01 00 00 jmp 109402 <== NOT EXECUTED } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 1092f4: 8b 43 60 mov 0x60(%ebx),%eax 1092f7: 8b 4b 64 mov 0x64(%ebx),%ecx 1092fa: 40 inc %eax 1092fb: 31 d2 xor %edx,%edx 1092fd: f7 f1 div %ecx 1092ff: 89 55 e4 mov %edx,-0x1c(%ebp) /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 109302: 9c pushf 109303: fa cli 109304: 8f 45 d8 popl -0x28(%ebp) if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 109307: 8b 53 5c mov 0x5c(%ebx),%edx 10930a: 8b 43 64 mov 0x64(%ebx),%eax % tty->rawInBuf.Size) > tty->highwater) && 10930d: 8b 4b 64 mov 0x64(%ebx),%ecx } } 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) 109310: 29 d0 sub %edx,%eax 109312: 03 45 e4 add -0x1c(%ebp),%eax % tty->rawInBuf.Size) > tty->highwater) && 109315: 31 d2 xor %edx,%edx 109317: f7 f1 div %ecx } } 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) 109319: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx 10931f: 0f 86 92 00 00 00 jbe 1093b7 <== ALWAYS TAKEN % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { 109325: 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) && 10932b: a8 01 test $0x1,%al <== NOT EXECUTED 10932d: 0f 85 84 00 00 00 jne 1093b7 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 109333: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109339: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10933c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 109342: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109348: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 10934d: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 109352: 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)) 109358: 75 2d jne 109387 <== NOT EXECUTED == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 10935a: a8 20 test $0x20,%al <== NOT EXECUTED 10935c: 75 09 jne 109367 <== NOT EXECUTED 10935e: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 109365: 75 50 jne 1093b7 <== 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; 109367: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10936d: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 109370: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 109376: 51 push %ecx <== NOT EXECUTED 109377: 6a 01 push $0x1 <== NOT EXECUTED 109379: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10937c: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10937f: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 109385: eb 2d jmp 1093b4 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { 109387: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 10938c: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 109391: 75 24 jne 1093b7 <== NOT EXECUTED tty->flow_ctrl |= FL_IRTSOFF; 109393: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109399: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10939c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 1093a2: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 1093a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1093aa: 74 0b je 1093b7 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 1093ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1093af: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1093b2: ff d0 call *%eax <== NOT EXECUTED 1093b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 1093b7: ff 75 d8 pushl -0x28(%ebp) 1093ba: 9d popf if (newTail == tty->rawInBuf.Head) { 1093bb: 8b 43 5c mov 0x5c(%ebx),%eax 1093be: 39 45 e4 cmp %eax,-0x1c(%ebp) 1093c1: 75 03 jne 1093c6 <== ALWAYS TAKEN dropped++; 1093c3: 47 inc %edi <== NOT EXECUTED 1093c4: eb 3c jmp 109402 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 1093c6: 8b 43 58 mov 0x58(%ebx),%eax 1093c9: 8a 4d e2 mov -0x1e(%ebp),%cl 1093cc: 8b 55 e4 mov -0x1c(%ebp),%edx 1093cf: 88 0c 10 mov %cl,(%eax,%edx,1) tty->rawInBuf.Tail = newTail; 1093d2: 89 53 60 mov %edx,0x60(%ebx) /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1093d5: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) 1093dc: 75 24 jne 109402 <== NEVER TAKEN 1093de: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 1093e4: 85 c0 test %eax,%eax 1093e6: 74 1a je 109402 <== ALWAYS TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1093e8: 52 push %edx <== NOT EXECUTED 1093e9: 52 push %edx <== NOT EXECUTED 1093ea: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 1093f0: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1093f3: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 1093f5: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 1093fc: 00 00 00 1093ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 109402: 3b 75 dc cmp -0x24(%ebp),%esi 109405: 0f 85 46 fe ff ff jne 109251 } } } } tty->rawInBufDropped += dropped; 10940b: 01 7b 78 add %edi,0x78(%ebx) rtems_semaphore_release (tty->rawInBuf.Semaphore); 10940e: 83 ec 0c sub $0xc,%esp 109411: ff 73 68 pushl 0x68(%ebx) 109414: e8 67 0a 00 00 call 109e80 return dropped; 109419: 83 c4 10 add $0x10,%esp 10941c: eb 09 jmp 109427 * 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) { 10941e: c6 45 e3 01 movb $0x1,-0x1d(%ebp) 109422: e9 7c fe ff ff jmp 1092a3 } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 109427: 89 f8 mov %edi,%eax 109429: 8d 65 f4 lea -0xc(%ebp),%esp 10942c: 5b pop %ebx 10942d: 5e pop %esi 10942e: 5f pop %edi 10942f: 5d pop %ebp 109430: c3 ret =============================================================================== 00108590 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 108590: 55 push %ebp 108591: 89 e5 mov %esp,%ebp 108593: 57 push %edi 108594: 56 push %esi 108595: 53 push %ebx 108596: 83 ec 20 sub $0x20,%esp 108599: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10859c: 8b 06 mov (%esi),%eax 10859e: 8b 58 2c mov 0x2c(%eax),%ebx struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 1085a1: 8b 7e 08 mov 0x8(%esi),%edi rtems_status_code sc; args->ioctl_return = 0; 1085a4: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1085ab: 6a 00 push $0x0 1085ad: 6a 00 push $0x0 1085af: ff 73 18 pushl 0x18(%ebx) 1085b2: e8 d9 17 00 00 call 109d90 1085b7: 89 45 e4 mov %eax,-0x1c(%ebp) if (sc != RTEMS_SUCCESSFUL) { 1085ba: 83 c4 10 add $0x10,%esp 1085bd: 85 c0 test %eax,%eax 1085bf: 0f 85 f5 02 00 00 jne 1088ba <== NEVER TAKEN return sc; } switch (args->command) { 1085c5: 8b 46 04 mov 0x4(%esi),%eax 1085c8: 83 f8 04 cmp $0x4,%eax 1085cb: 0f 84 55 02 00 00 je 108826 1085d1: 77 10 ja 1085e3 1085d3: 83 f8 02 cmp $0x2,%eax 1085d6: 74 71 je 108649 1085d8: 0f 87 19 02 00 00 ja 1087f7 1085de: 48 dec %eax 1085df: 75 35 jne 108616 <== NEVER TAKEN 1085e1: eb 52 jmp 108635 1085e3: 3d 7f 66 04 40 cmp $0x4004667f,%eax 1085e8: 0f 84 9b 02 00 00 je 108889 <== NEVER TAKEN 1085ee: 77 0a ja 1085fa 1085f0: 83 f8 05 cmp $0x5,%eax 1085f3: 75 21 jne 108616 1085f5: e9 16 02 00 00 jmp 108810 1085fa: 3d 1a 74 04 40 cmp $0x4004741a,%eax 1085ff: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx 108605: 0f 84 77 02 00 00 je 108882 10860b: 3d 1b 74 04 80 cmp $0x8004741b,%eax 108610: 0f 84 23 02 00 00 je 108839 <== ALWAYS TAKEN default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 108616: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10861c: c1 e0 05 shl $0x5,%eax 10861f: 8b 80 d8 df 12 00 mov 0x12dfd8(%eax),%eax 108625: 85 c0 test %eax,%eax 108627: 0f 84 78 02 00 00 je 1088a5 <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 10862d: 57 push %edi 10862e: 57 push %edi 10862f: 56 push %esi 108630: e9 42 02 00 00 jmp 108877 sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 108635: 8b 46 08 mov 0x8(%esi),%eax 108638: 8d 73 30 lea 0x30(%ebx),%esi 10863b: b9 09 00 00 00 mov $0x9,%ecx 108640: 89 c7 mov %eax,%edi 108642: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 108644: e9 63 02 00 00 jmp 1088ac case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 108649: 8b 76 08 mov 0x8(%esi),%esi 10864c: 8d 7b 30 lea 0x30(%ebx),%edi 10864f: b9 09 00 00 00 mov $0x9,%ecx 108654: 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) && 108656: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10865c: f6 c4 02 test $0x2,%ah 10865f: 74 57 je 1086b8 108661: f6 43 31 04 testb $0x4,0x31(%ebx) 108665: 75 51 jne 1086b8 !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 108667: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10866d: 25 ef fd ff ff and $0xfffffdef,%eax 108672: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 108678: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10867e: a8 20 test $0x20,%al 108680: 74 36 je 1086b8 <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 108682: 9c pushf <== NOT EXECUTED 108683: fa cli <== NOT EXECUTED 108684: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 108685: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10868b: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 10868e: 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) { 108694: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 10869b: 74 19 je 1086b6 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 10869d: 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)( 1086a3: 51 push %ecx <== NOT EXECUTED 1086a4: 6a 01 push $0x1 <== NOT EXECUTED 1086a6: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 1086a9: 50 push %eax <== NOT EXECUTED 1086aa: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1086ad: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1086b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 1086b6: 56 push %esi <== NOT EXECUTED 1086b7: 9d popf <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) { 1086b8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1086be: f6 c4 04 test $0x4,%ah 1086c1: 74 24 je 1086e7 1086c3: f6 43 31 10 testb $0x10,0x31(%ebx) 1086c7: 75 1e jne 1086e7 <== NEVER TAKEN /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 1086c9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1086cf: 80 e4 fb and $0xfb,%ah 1086d2: 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); 1086d8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1086de: 83 e0 fd and $0xfffffffd,%eax 1086e1: 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)) { 1086e7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1086ed: f6 c4 01 test $0x1,%ah 1086f0: 74 43 je 108735 <== ALWAYS TAKEN 1086f2: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 1086f6: 78 3d js 108735 <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 1086f8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1086fe: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 108701: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) { 108707: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10870d: a8 04 test $0x4,%al <== NOT EXECUTED 10870f: 74 15 je 108726 <== NOT EXECUTED 108711: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 108717: 85 c0 test %eax,%eax <== NOT EXECUTED 108719: 74 0b je 108726 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 10871b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10871e: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108721: ff d0 call *%eax <== NOT EXECUTED 108723: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 108726: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10872c: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10872f: 89 83 b8 00 00 00 mov %eax,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) { 108735: 83 7b 38 00 cmpl $0x0,0x38(%ebx) 108739: 79 0f jns 10874a <== ALWAYS TAKEN tty->flow_ctrl |= FL_MDRTS; 10873b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108741: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 108744: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 10874a: 8b 53 30 mov 0x30(%ebx),%edx 10874d: f6 c6 10 test $0x10,%dh 108750: 74 0f je 108761 tty->flow_ctrl |= FL_MDXOF; 108752: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108758: 80 cc 04 or $0x4,%ah 10875b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) } /* check for outgoing XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXON) { 108761: 80 e6 04 and $0x4,%dh 108764: 74 0f je 108775 tty->flow_ctrl |= FL_MDXON; 108766: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10876c: 80 cc 02 or $0x2,%ah 10876f: 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) { 108775: f6 43 3c 02 testb $0x2,0x3c(%ebx) 108779: 74 02 je 10877d 10877b: eb 3b jmp 1087b8 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 10877d: 0f b6 73 46 movzbl 0x46(%ebx),%esi rtems_clock_get_ticks_per_second() / 10; 108781: e8 5e 10 00 00 call 1097e4 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] * 108786: 0f af c6 imul %esi,%eax rtems_clock_get_ticks_per_second() / 10; 108789: b9 0a 00 00 00 mov $0xa,%ecx 10878e: 31 d2 xor %edx,%edx 108790: f7 f1 div %ecx 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] * 108792: 89 43 54 mov %eax,0x54(%ebx) rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 108795: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 108799: 74 17 je 1087b2 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 10879b: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 1087a2: 89 43 70 mov %eax,0x70(%ebx) if (tty->termios.c_cc[VMIN]) 1087a5: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 1087a9: 74 02 je 1087ad 1087ab: eb 19 jmp 1087c6 tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 1087ad: 89 43 74 mov %eax,0x74(%ebx) 1087b0: eb 24 jmp 1087d6 } else { if (tty->termios.c_cc[VMIN]) { 1087b2: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 1087b6: 74 17 je 1087cf <== ALWAYS TAKEN tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1087b8: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 1087bf: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 1087c6: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) 1087cd: eb 07 jmp 1087d6 } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 1087cf: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) } } } if (tty->device.setAttributes) 1087d6: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 1087dc: 85 c0 test %eax,%eax 1087de: 0f 84 c8 00 00 00 je 1088ac <== NEVER TAKEN (*tty->device.setAttributes)(tty->minor, &tty->termios); 1087e4: 52 push %edx 1087e5: 52 push %edx 1087e6: 8d 53 30 lea 0x30(%ebx),%edx 1087e9: 52 push %edx 1087ea: ff 73 10 pushl 0x10(%ebx) 1087ed: ff d0 call *%eax 1087ef: 83 c4 10 add $0x10,%esp 1087f2: e9 b5 00 00 00 jmp 1088ac drainOutput (struct rtems_termios_tty *tty) { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 1087f7: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 1087fe: 0f 84 a8 00 00 00 je 1088ac 108804: 89 d8 mov %ebx,%eax 108806: e8 9b f7 ff ff call 107fa6 10880b: e9 9c 00 00 00 jmp 1088ac case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108810: 8b 07 mov (%edi),%eax 108812: 8b 57 04 mov 0x4(%edi),%edx 108815: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx) 10881b: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) break; 108821: e9 86 00 00 00 jmp 1088ac case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 108826: 8b 07 mov (%edi),%eax 108828: 8b 57 04 mov 0x4(%edi),%edx 10882b: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) 108831: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) break; 108837: eb 73 jmp 1088ac #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108839: c1 e2 05 shl $0x5,%edx 10883c: 8b 82 c4 df 12 00 mov 0x12dfc4(%edx),%eax 108842: 85 c0 test %eax,%eax 108844: 74 0c je 108852 sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108846: 83 ec 0c sub $0xc,%esp 108849: 53 push %ebx 10884a: ff d0 call *%eax 10884c: 89 45 e4 mov %eax,-0x1c(%ebp) 10884f: 83 c4 10 add $0x10,%esp } tty->t_line=*(int*)(args->buffer); 108852: 8b 46 08 mov 0x8(%esi),%eax 108855: 8b 00 mov (%eax),%eax 108857: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) tty->t_sc = NULL; /* ensure that no more valid data */ 10885d: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) 108864: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 108867: c1 e0 05 shl $0x5,%eax 10886a: 8b 80 c0 df 12 00 mov 0x12dfc0(%eax),%eax 108870: 85 c0 test %eax,%eax 108872: 74 38 je 1088ac sc = rtems_termios_linesw[tty->t_line].l_open(tty); 108874: 83 ec 0c sub $0xc,%esp 108877: 53 push %ebx 108878: ff d0 call *%eax 10887a: 89 45 e4 mov %eax,-0x1c(%ebp) 10887d: e9 6d ff ff ff jmp 1087ef } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 108882: 8b 46 08 mov 0x8(%esi),%eax 108885: 89 10 mov %edx,(%eax) break; 108887: eb 23 jmp 1088ac #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 108889: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 10888c: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 10888f: 29 d0 sub %edx,%eax <== NOT EXECUTED 108891: 79 05 jns 108898 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 108893: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 108896: 01 d0 add %edx,%eax <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 108898: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10889b: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED 10889e: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED 1088a1: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; 1088a3: eb 07 jmp 1088ac <== NOT EXECUTED 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; 1088a5: c7 45 e4 0a 00 00 00 movl $0xa,-0x1c(%ebp) <== NOT EXECUTED *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 1088ac: 83 ec 0c sub $0xc,%esp 1088af: ff 73 18 pushl 0x18(%ebx) 1088b2: e8 c9 15 00 00 call 109e80 return sc; 1088b7: 83 c4 10 add $0x10,%esp } 1088ba: 8b 45 e4 mov -0x1c(%ebp),%eax 1088bd: 8d 65 f4 lea -0xc(%ebp),%esp 1088c0: 5b pop %ebx 1088c1: 5e pop %esi 1088c2: 5f pop %edi 1088c3: 5d pop %ebp 1088c4: c3 ret =============================================================================== 00107ff5 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 107ff5: 55 push %ebp 107ff6: 89 e5 mov %esp,%ebp 107ff8: 57 push %edi 107ff9: 56 push %esi 107ffa: 53 push %ebx 107ffb: 83 ec 20 sub $0x20,%esp struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain( 107ffe: 6a 00 push $0x0 108000: 6a 00 push $0x0 108002: ff 35 14 e3 12 00 pushl 0x12e314 108008: e8 83 1d 00 00 call 109d90 10800d: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108010: 83 c4 10 add $0x10,%esp 108013: 85 c0 test %eax,%eax 108015: 0f 85 b7 03 00 00 jne 1083d2 <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 10801b: 8b 35 1c e3 12 00 mov 0x12e31c,%esi 108021: 89 f3 mov %esi,%ebx 108023: eb 16 jmp 10803b if ((tty->major == major) && (tty->minor == minor)) 108025: 8b 55 08 mov 0x8(%ebp),%edx 108028: 39 53 0c cmp %edx,0xc(%ebx) 10802b: 75 0c jne 108039 10802d: 8b 55 0c mov 0xc(%ebp),%edx 108030: 39 53 10 cmp %edx,0x10(%ebx) 108033: 0f 84 f2 02 00 00 je 10832b sc = rtems_semaphore_obtain( rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 108039: 8b 1b mov (%ebx),%ebx 10803b: 85 db test %ebx,%ebx 10803d: 75 e6 jne 108025 10803f: e9 6e 03 00 00 jmp 1083b2 /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 108044: 83 ec 0c sub $0xc,%esp 108047: e9 84 00 00 00 jmp 1080d0 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 10804c: a1 04 c1 12 00 mov 0x12c104,%eax 108051: 89 43 64 mov %eax,0x64(%ebx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 108054: 8b 43 64 mov 0x64(%ebx),%eax 108057: 83 ec 0c sub $0xc,%esp 10805a: 50 push %eax 10805b: e8 94 e9 ff ff call 1069f4 108060: 89 c7 mov %eax,%edi 108062: 89 43 58 mov %eax,0x58(%ebx) if (tty->rawInBuf.theBuf == NULL) { 108065: 83 c4 10 add $0x10,%esp 108068: 85 c0 test %eax,%eax 10806a: 75 05 jne 108071 free(tty); 10806c: 83 ec 0c sub $0xc,%esp 10806f: eb 58 jmp 1080c9 return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 108071: a1 08 c1 12 00 mov 0x12c108,%eax 108076: 89 83 88 00 00 00 mov %eax,0x88(%ebx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 10807c: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 108082: 83 ec 0c sub $0xc,%esp 108085: 50 push %eax 108086: e8 69 e9 ff ff call 1069f4 10808b: 89 43 7c mov %eax,0x7c(%ebx) if (tty->rawOutBuf.theBuf == NULL) { 10808e: 83 c4 10 add $0x10,%esp 108091: 85 c0 test %eax,%eax 108093: 75 05 jne 10809a free((void *)(tty->rawInBuf.theBuf)); 108095: 83 ec 0c sub $0xc,%esp 108098: eb 28 jmp 1080c2 return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 10809a: 83 ec 0c sub $0xc,%esp 10809d: ff 35 0c c1 12 00 pushl 0x12c10c 1080a3: 89 45 e0 mov %eax,-0x20(%ebp) 1080a6: e8 49 e9 ff ff call 1069f4 1080ab: 89 43 1c mov %eax,0x1c(%ebx) if (tty->cbuf == NULL) { 1080ae: 83 c4 10 add $0x10,%esp 1080b1: 85 c0 test %eax,%eax 1080b3: 8b 55 e0 mov -0x20(%ebp),%edx 1080b6: 75 32 jne 1080ea free((void *)(tty->rawOutBuf.theBuf)); 1080b8: 83 ec 0c sub $0xc,%esp 1080bb: 52 push %edx 1080bc: e8 73 e6 ff ff call 106734 free((void *)(tty->rawInBuf.theBuf)); 1080c1: 58 pop %eax 1080c2: 57 push %edi 1080c3: e8 6c e6 ff ff call 106734 free(tty); 1080c8: 58 pop %eax 1080c9: 53 push %ebx 1080ca: e8 65 e6 ff ff call 106734 rtems_semaphore_release (rtems_termios_ttyMutex); 1080cf: 5f pop %edi 1080d0: ff 35 14 e3 12 00 pushl 0x12e314 1080d6: e8 a5 1d 00 00 call 109e80 return RTEMS_NO_MEMORY; 1080db: 83 c4 10 add $0x10,%esp 1080de: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 1080e5: e9 e8 02 00 00 jmp 1083d2 } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1080ea: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) 1080f1: 00 00 00 tty->tty_snd.sw_arg = NULL; 1080f4: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx) 1080fb: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 1080fe: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 108105: 00 00 00 tty->tty_rcv.sw_arg = NULL; 108108: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 10810f: 00 00 00 tty->tty_rcvwakeup = 0; 108112: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 108119: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 10811c: 89 33 mov %esi,(%ebx) tty->back = NULL; 10811e: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) if (rtems_termios_ttyHead != NULL) 108125: 85 f6 test %esi,%esi 108127: 74 03 je 10812c rtems_termios_ttyHead->back = tty; 108129: 89 5e 04 mov %ebx,0x4(%esi) rtems_termios_ttyHead = tty; 10812c: 89 1d 1c e3 12 00 mov %ebx,0x12e31c if (rtems_termios_ttyTail == NULL) 108132: 83 3d 18 e3 12 00 00 cmpl $0x0,0x12e318 108139: 75 06 jne 108141 rtems_termios_ttyTail = tty; 10813b: 89 1d 18 e3 12 00 mov %ebx,0x12e318 tty->minor = minor; 108141: 8b 55 0c mov 0xc(%ebp),%edx 108144: 89 53 10 mov %edx,0x10(%ebx) tty->major = major; 108147: 8b 55 08 mov 0x8(%ebp),%edx 10814a: 89 53 0c mov %edx,0xc(%ebx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 10814d: 83 ec 0c sub $0xc,%esp 108150: 8d 43 14 lea 0x14(%ebx),%eax 108153: 50 push %eax 108154: 6a 00 push $0x0 108156: 6a 54 push $0x54 108158: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'i', c), 10815a: 0f be 05 10 c1 12 00 movsbl 0x12c110,%eax tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 108161: 0d 00 69 52 54 or $0x54526900,%eax 108166: 50 push %eax 108167: e8 f4 19 00 00 call 109b60 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) 10816c: 83 c4 20 add $0x20,%esp 10816f: 85 c0 test %eax,%eax 108171: 74 05 je 108178 108173: e9 1e 02 00 00 jmp 108396 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 108178: 83 ec 0c sub $0xc,%esp 10817b: 8d 43 18 lea 0x18(%ebx),%eax 10817e: 50 push %eax 10817f: 6a 00 push $0x0 108181: 6a 54 push $0x54 108183: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'o', c), 108185: 0f be 05 10 c1 12 00 movsbl 0x12c110,%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 ( 10818c: 0d 00 6f 52 54 or $0x54526f00,%eax 108191: 50 push %eax 108192: e8 c9 19 00 00 call 109b60 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) 108197: 83 c4 20 add $0x20,%esp 10819a: 85 c0 test %eax,%eax 10819c: 74 05 je 1081a3 10819e: e9 f3 01 00 00 jmp 108396 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 1081a3: 83 ec 0c sub $0xc,%esp 1081a6: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax 1081ac: 50 push %eax 1081ad: 6a 00 push $0x0 1081af: 6a 20 push $0x20 1081b1: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'x', c), 1081b3: 0f be 05 10 c1 12 00 movsbl 0x12c110,%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 ( 1081ba: 0d 00 78 52 54 or $0x54527800,%eax 1081bf: 50 push %eax 1081c0: e8 9b 19 00 00 call 109b60 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1081c5: 83 c4 20 add $0x20,%esp 1081c8: 85 c0 test %eax,%eax 1081ca: 74 05 je 1081d1 1081cc: e9 c5 01 00 00 jmp 108396 rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1081d1: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 1081d8: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 1081db: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi 1081e1: b9 08 00 00 00 mov $0x8,%ecx 1081e6: 8b 75 14 mov 0x14(%ebp),%esi 1081e9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1081eb: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1081f2: 75 6a jne 10825e sc = rtems_task_create ( 1081f4: 56 push %esi 1081f5: 56 push %esi 1081f6: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 1081fc: 50 push %eax 1081fd: 6a 00 push $0x0 1081ff: 68 00 05 00 00 push $0x500 108204: 68 00 04 00 00 push $0x400 108209: 6a 0a push $0xa rtems_build_name ('T', 'x', 'T', c), 10820b: 0f be 05 10 c1 12 00 movsbl 0x12c110,%eax /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 108212: 0d 00 54 78 54 or $0x54785400,%eax 108217: 50 push %eax 108218: e8 f3 1c 00 00 call 109f10 TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 10821d: 83 c4 20 add $0x20,%esp 108220: 85 c0 test %eax,%eax 108222: 74 05 je 108229 <== ALWAYS TAKEN 108224: e9 6d 01 00 00 jmp 108396 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 108229: 51 push %ecx 10822a: 51 push %ecx 10822b: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax 108231: 50 push %eax 108232: 6a 00 push $0x0 108234: 68 00 05 00 00 push $0x500 108239: 68 00 04 00 00 push $0x400 10823e: 6a 09 push $0x9 rtems_build_name ('R', 'x', 'T', c), 108240: 0f be 05 10 c1 12 00 movsbl 0x12c110,%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 ( 108247: 0d 00 54 78 52 or $0x52785400,%eax 10824c: 50 push %eax 10824d: e8 be 1c 00 00 call 109f10 TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 108252: 83 c4 20 add $0x20,%esp 108255: 85 c0 test %eax,%eax 108257: 74 05 je 10825e <== ALWAYS TAKEN 108259: e9 38 01 00 00 jmp 108396 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 10825e: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 108265: 74 09 je 108270 108267: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 10826e: 75 2b jne 10829b (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 108270: 83 ec 0c sub $0xc,%esp 108273: 8d 43 68 lea 0x68(%ebx),%eax 108276: 50 push %eax 108277: 6a 00 push $0x0 108279: 6a 24 push $0x24 10827b: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'r', c), 10827d: 0f be 05 10 c1 12 00 movsbl 0x12c110,%eax rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 108284: 0d 00 72 52 54 or $0x54527200,%eax 108289: 50 push %eax 10828a: e8 d1 18 00 00 call 109b60 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 10828f: 83 c4 20 add $0x20,%esp 108292: 85 c0 test %eax,%eax 108294: 74 05 je 10829b 108296: e9 fb 00 00 00 jmp 108396 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 10829b: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1082a2: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 1082a9: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) tty->termios.c_lflag = 1082b0: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 1082b7: c6 43 41 03 movb $0x3,0x41(%ebx) tty->termios.c_cc[VQUIT] = '\034'; 1082bb: c6 43 42 1c movb $0x1c,0x42(%ebx) tty->termios.c_cc[VERASE] = '\177'; 1082bf: c6 43 43 7f movb $0x7f,0x43(%ebx) tty->termios.c_cc[VKILL] = '\025'; 1082c3: c6 43 44 15 movb $0x15,0x44(%ebx) tty->termios.c_cc[VEOF] = '\004'; 1082c7: c6 43 45 04 movb $0x4,0x45(%ebx) tty->termios.c_cc[VEOL] = '\000'; 1082cb: c6 43 4c 00 movb $0x0,0x4c(%ebx) tty->termios.c_cc[VEOL2] = '\000'; 1082cf: c6 43 51 00 movb $0x0,0x51(%ebx) tty->termios.c_cc[VSTART] = '\021'; 1082d3: c6 43 49 11 movb $0x11,0x49(%ebx) tty->termios.c_cc[VSTOP] = '\023'; 1082d7: c6 43 4a 13 movb $0x13,0x4a(%ebx) tty->termios.c_cc[VSUSP] = '\032'; 1082db: c6 43 4b 1a movb $0x1a,0x4b(%ebx) tty->termios.c_cc[VREPRINT] = '\022'; 1082df: c6 43 4d 12 movb $0x12,0x4d(%ebx) tty->termios.c_cc[VDISCARD] = '\017'; 1082e3: c6 43 4e 0f movb $0xf,0x4e(%ebx) tty->termios.c_cc[VWERASE] = '\027'; 1082e7: c6 43 4f 17 movb $0x17,0x4f(%ebx) tty->termios.c_cc[VLNEXT] = '\026'; 1082eb: c6 43 50 16 movb $0x16,0x50(%ebx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 1082ef: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) 1082f6: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 1082f9: 8b 43 64 mov 0x64(%ebx),%eax 1082fc: d1 e8 shr %eax 1082fe: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) tty->highwater = tty->rawInBuf.Size * 3/4; 108304: 8b 43 64 mov 0x64(%ebx),%eax 108307: 8d 04 40 lea (%eax,%eax,2),%eax 10830a: c1 e8 02 shr $0x2,%eax 10830d: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) /* * Bump name characer */ if (c++ == 'z') 108313: a0 10 c1 12 00 mov 0x12c110,%al 108318: 3c 7a cmp $0x7a,%al 10831a: 74 08 je 108324 10831c: 40 inc %eax 10831d: a2 10 c1 12 00 mov %al,0x12c110 108322: eb 07 jmp 10832b c = 'a'; 108324: c6 05 10 c1 12 00 61 movb $0x61,0x12c110 } args->iop->data1 = tty; 10832b: 8b 55 10 mov 0x10(%ebp),%edx 10832e: 8b 02 mov (%edx),%eax 108330: 89 58 2c mov %ebx,0x2c(%eax) if (!tty->refcount++) { 108333: 8b 43 08 mov 0x8(%ebx),%eax 108336: 8d 50 01 lea 0x1(%eax),%edx 108339: 89 53 08 mov %edx,0x8(%ebx) 10833c: 85 c0 test %eax,%eax 10833e: 75 5f jne 10839f if (tty->device.firstOpen) 108340: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax 108346: 85 c0 test %eax,%eax 108348: 74 0f je 108359 (*tty->device.firstOpen)(major, minor, arg); 10834a: 52 push %edx 10834b: ff 75 10 pushl 0x10(%ebp) 10834e: ff 75 0c pushl 0xc(%ebp) 108351: ff 75 08 pushl 0x8(%ebp) 108354: ff d0 call *%eax 108356: 83 c4 10 add $0x10,%esp /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108359: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108360: 75 3d jne 10839f sc = rtems_task_start( 108362: 57 push %edi 108363: 53 push %ebx 108364: 68 31 94 10 00 push $0x109431 108369: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 10836f: e8 18 1e 00 00 call 10a18c tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 108374: 83 c4 10 add $0x10,%esp 108377: 85 c0 test %eax,%eax 108379: 74 02 je 10837d <== ALWAYS TAKEN 10837b: eb 19 jmp 108396 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_start( 10837d: 56 push %esi 10837e: 53 push %ebx 10837f: 68 47 7f 10 00 push $0x107f47 108384: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 10838a: e8 fd 1d 00 00 call 10a18c tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10838f: 83 c4 10 add $0x10,%esp 108392: 85 c0 test %eax,%eax 108394: 74 09 je 10839f <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108396: 83 ec 0c sub $0xc,%esp 108399: 50 push %eax 10839a: e8 15 20 00 00 call 10a3b4 } } rtems_semaphore_release (rtems_termios_ttyMutex); 10839f: 83 ec 0c sub $0xc,%esp 1083a2: ff 35 14 e3 12 00 pushl 0x12e314 1083a8: e8 d3 1a 00 00 call 109e80 return RTEMS_SUCCESSFUL; 1083ad: 83 c4 10 add $0x10,%esp 1083b0: eb 20 jmp 1083d2 static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 1083b2: 51 push %ecx 1083b3: 51 push %ecx 1083b4: 68 e8 00 00 00 push $0xe8 1083b9: 6a 01 push $0x1 1083bb: e8 6c e1 ff ff call 10652c 1083c0: 89 c3 mov %eax,%ebx if (tty == NULL) { 1083c2: 83 c4 10 add $0x10,%esp 1083c5: 85 c0 test %eax,%eax 1083c7: 0f 85 7f fc ff ff jne 10804c 1083cd: e9 72 fc ff ff jmp 108044 rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); return RTEMS_SUCCESSFUL; } 1083d2: 8b 45 e4 mov -0x1c(%ebp),%eax 1083d5: 8d 65 f4 lea -0xc(%ebp),%esp 1083d8: 5b pop %ebx 1083d9: 5e pop %esi 1083da: 5f pop %edi 1083db: 5d pop %ebp 1083dc: c3 ret =============================================================================== 001088c5 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, size_t len, struct rtems_termios_tty *tty) { 1088c5: 55 push %ebp 1088c6: 89 e5 mov %esp,%ebp 1088c8: 57 push %edi 1088c9: 56 push %esi 1088ca: 53 push %ebx 1088cb: 83 ec 1c sub $0x1c,%esp 1088ce: 8b 75 08 mov 0x8(%ebp),%esi 1088d1: 8b 45 0c mov 0xc(%ebp),%eax 1088d4: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 1088d7: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 1088de: 75 1b jne 1088fb (*tty->device.write)(tty->minor, buf, len); 1088e0: 89 45 10 mov %eax,0x10(%ebp) 1088e3: 89 75 0c mov %esi,0xc(%ebp) 1088e6: 8b 43 10 mov 0x10(%ebx),%eax 1088e9: 89 45 08 mov %eax,0x8(%ebp) 1088ec: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1088f2: 8d 65 f4 lea -0xc(%ebp),%esp 1088f5: 5b pop %ebx 1088f6: 5e pop %esi 1088f7: 5f pop %edi 1088f8: 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); 1088f9: ff e0 jmp *%eax return; } newHead = tty->rawOutBuf.Head; 1088fb: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi /* * Send characters to device-specific code */ void rtems_termios_puts ( 108901: 01 f0 add %esi,%eax 108903: 89 45 e0 mov %eax,-0x20(%ebp) if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 108906: e9 b5 00 00 00 jmp 1089c0 * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 10890b: 8d 47 01 lea 0x1(%edi),%eax 10890e: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 108914: 31 d2 xor %edx,%edx 108916: f7 f1 div %ecx 108918: 89 55 d8 mov %edx,-0x28(%ebp) 10891b: 89 d7 mov %edx,%edi 10891d: eb 2e jmp 10894d rtems_interrupt_disable (level); while (newHead == tty->rawOutBuf.Tail) { tty->rawOutBufState = rob_wait; 10891f: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 108926: 00 00 00 rtems_interrupt_enable (level); 108929: ff 75 e4 pushl -0x1c(%ebp) 10892c: 9d popf sc = rtems_semaphore_obtain( 10892d: 51 push %ecx 10892e: 6a 00 push $0x0 108930: 6a 00 push $0x0 108932: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108938: e8 53 14 00 00 call 109d90 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 10893d: 83 c4 10 add $0x10,%esp 108940: 85 c0 test %eax,%eax 108942: 74 09 je 10894d <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108944: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108947: 50 push %eax <== NOT EXECUTED 108948: e8 67 1a 00 00 call 10a3b4 <== NOT EXECUTED rtems_interrupt_disable (level); 10894d: 9c pushf 10894e: fa cli 10894f: 8f 45 e4 popl -0x1c(%ebp) * 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) { 108952: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 108958: 39 45 d8 cmp %eax,-0x28(%ebp) 10895b: 74 c2 je 10891f 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++; 10895d: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 108963: 8a 0e mov (%esi),%cl 108965: 8b 53 7c mov 0x7c(%ebx),%edx 108968: 88 0c 02 mov %cl,(%edx,%eax,1) 10896b: 46 inc %esi tty->rawOutBuf.Head = newHead; 10896c: 8b 55 d8 mov -0x28(%ebp),%edx 10896f: 89 93 80 00 00 00 mov %edx,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 108975: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) 10897c: 75 3e jne 1089bc /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 10897e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108984: a8 10 test $0x10,%al 108986: 75 1b jne 1089a3 <== NEVER TAKEN (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 108988: 8b 83 84 00 00 00 mov 0x84(%ebx),%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)( 10898e: 52 push %edx 10898f: 6a 01 push $0x1 108991: 03 43 7c add 0x7c(%ebx),%eax 108994: 50 push %eax 108995: ff 73 10 pushl 0x10(%ebx) 108998: ff 93 a4 00 00 00 call *0xa4(%ebx) 10899e: 83 c4 10 add $0x10,%esp 1089a1: eb 0f jmp 1089b2 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; 1089a3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1089a9: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 1089ac: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 1089b2: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 1089b9: 00 00 00 } rtems_interrupt_enable (level); 1089bc: ff 75 e4 pushl -0x1c(%ebp) 1089bf: 9d popf if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 1089c0: 3b 75 e0 cmp -0x20(%ebp),%esi 1089c3: 0f 85 42 ff ff ff jne 10890b tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1089c9: 8d 65 f4 lea -0xc(%ebp),%esp 1089cc: 5b pop %ebx 1089cd: 5e pop %esi 1089ce: 5f pop %edi 1089cf: 5d pop %ebp 1089d0: c3 ret =============================================================================== 00108ed2 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 108ed2: 55 push %ebp 108ed3: 89 e5 mov %esp,%ebp 108ed5: 57 push %edi 108ed6: 56 push %esi 108ed7: 53 push %ebx 108ed8: 83 ec 30 sub $0x30,%esp 108edb: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108ede: 8b 06 mov (%esi),%eax 108ee0: 8b 58 2c mov 0x2c(%eax),%ebx uint32_t count = args->count; 108ee3: 8b 4e 10 mov 0x10(%esi),%ecx 108ee6: 89 4d e4 mov %ecx,-0x1c(%ebp) char *buffer = args->buffer; 108ee9: 8b 4e 0c mov 0xc(%esi),%ecx 108eec: 89 4d dc mov %ecx,-0x24(%ebp) rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108eef: 6a 00 push $0x0 108ef1: 6a 00 push $0x0 108ef3: ff 73 14 pushl 0x14(%ebx) 108ef6: e8 95 0e 00 00 call 109d90 108efb: 89 45 d8 mov %eax,-0x28(%ebp) if (sc != RTEMS_SUCCESSFUL) 108efe: 83 c4 10 add $0x10,%esp 108f01: 85 c0 test %eax,%eax 108f03: 0f 85 88 02 00 00 jne 109191 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 108f09: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108f0f: c1 e0 05 shl $0x5,%eax 108f12: 8b 80 c8 df 12 00 mov 0x12dfc8(%eax),%eax 108f18: 85 c0 test %eax,%eax 108f1a: 74 19 je 108f35 sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 108f1c: 52 push %edx 108f1d: 52 push %edx 108f1e: 56 push %esi 108f1f: 53 push %ebx 108f20: ff d0 call *%eax 108f22: 89 45 d8 mov %eax,-0x28(%ebp) tty->tty_rcvwakeup = 0; 108f25: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 108f2c: 00 00 00 rtems_semaphore_release (tty->isem); 108f2f: 59 pop %ecx 108f30: e9 51 02 00 00 jmp 109186 return sc; } if (tty->cindex == tty->ccount) { 108f35: 8b 43 20 mov 0x20(%ebx),%eax 108f38: 39 43 24 cmp %eax,0x24(%ebx) 108f3b: 0f 85 21 02 00 00 jne 109162 <== NEVER TAKEN tty->cindex = tty->ccount = 0; 108f41: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 108f48: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) tty->read_start_column = tty->column; 108f4f: 8b 43 28 mov 0x28(%ebx),%eax 108f52: 89 43 2c mov %eax,0x2c(%ebx) if (tty->device.pollRead != NULL && 108f55: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 108f5c: 0f 84 c9 00 00 00 je 10902b 108f62: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 108f69: 0f 85 bc 00 00 00 jne 10902b static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 108f6f: f6 43 3c 02 testb $0x2,0x3c(%ebx) 108f73: 74 37 je 108fac for (;;) { n = (*tty->device.pollRead)(tty->minor); 108f75: 83 ec 0c sub $0xc,%esp 108f78: ff 73 10 pushl 0x10(%ebx) 108f7b: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 108f81: 83 c4 10 add $0x10,%esp 108f84: 85 c0 test %eax,%eax 108f86: 79 0f jns 108f97 rtems_task_wake_after (1); 108f88: 83 ec 0c sub $0xc,%esp 108f8b: 6a 01 push $0x1 108f8d: e8 5e 12 00 00 call 10a1f0 108f92: 83 c4 10 add $0x10,%esp 108f95: eb de jmp 108f75 } else { if (siproc (n, tty)) 108f97: 25 ff 00 00 00 and $0xff,%eax 108f9c: 89 da mov %ebx,%edx 108f9e: e8 3a fe ff ff call 108ddd 108fa3: 85 c0 test %eax,%eax 108fa5: 74 ce je 108f75 108fa7: e9 b6 01 00 00 jmp 109162 } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 108fac: e8 47 08 00 00 call 1097f8 108fb1: 89 c7 mov %eax,%edi for (;;) { n = (*tty->device.pollRead)(tty->minor); 108fb3: 83 ec 0c sub $0xc,%esp 108fb6: ff 73 10 pushl 0x10(%ebx) 108fb9: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 108fbf: 83 c4 10 add $0x10,%esp 108fc2: 85 c0 test %eax,%eax 108fc4: 79 3e jns 109004 if (tty->termios.c_cc[VMIN]) { 108fc6: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 108fca: 74 1d je 108fe9 <== NEVER TAKEN if (tty->termios.c_cc[VTIME] && tty->ccount) { 108fcc: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 108fd0: 75 0f jne 108fe1 <== ALWAYS TAKEN now = rtems_clock_get_ticks_since_boot(); if ((now - then) > tty->vtimeTicks) { break; } } rtems_task_wake_after (1); 108fd2: 83 ec 0c sub $0xc,%esp 108fd5: 6a 01 push $0x1 108fd7: e8 14 12 00 00 call 10a1f0 108fdc: 83 c4 10 add $0x10,%esp 108fdf: eb d2 jmp 108fb3 then = rtems_clock_get_ticks_since_boot(); for (;;) { n = (*tty->device.pollRead)(tty->minor); if (n < 0) { if (tty->termios.c_cc[VMIN]) { if (tty->termios.c_cc[VTIME] && tty->ccount) { 108fe1: 83 7b 20 00 cmpl $0x0,0x20(%ebx) 108fe5: 74 eb je 108fd2 108fe7: eb 0a jmp 108ff3 if ((now - then) > tty->vtimeTicks) { break; } } } else { if (!tty->termios.c_cc[VTIME]) 108fe9: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 108fed: 0f 84 6f 01 00 00 je 109162 <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 108ff3: e8 00 08 00 00 call 1097f8 if ((now - then) > tty->vtimeTicks) { 108ff8: 29 f8 sub %edi,%eax 108ffa: 3b 43 54 cmp 0x54(%ebx),%eax 108ffd: 76 d3 jbe 108fd2 108fff: e9 5e 01 00 00 jmp 109162 break; } } rtems_task_wake_after (1); } else { siproc (n, tty); 109004: 25 ff 00 00 00 and $0xff,%eax 109009: 89 da mov %ebx,%edx 10900b: e8 cd fd ff ff call 108ddd if (tty->ccount >= tty->termios.c_cc[VMIN]) 109010: 8a 43 47 mov 0x47(%ebx),%al 109013: 0f b6 d0 movzbl %al,%edx 109016: 39 53 20 cmp %edx,0x20(%ebx) 109019: 0f 8d 43 01 00 00 jge 109162 break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 10901f: 84 c0 test %al,%al 109021: 74 90 je 108fb3 <== NEVER TAKEN 109023: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109027: 74 8a je 108fb3 <== NEVER TAKEN 109029: eb 81 jmp 108fac * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 10902b: 8b 7b 74 mov 0x74(%ebx),%edi rtems_status_code sc; int wait = 1; 10902e: c7 45 d4 01 00 00 00 movl $0x1,-0x2c(%ebp) == (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); 109035: 8d 4b 49 lea 0x49(%ebx),%ecx 109038: 89 4d d0 mov %ecx,-0x30(%ebp) 10903b: e9 d3 00 00 00 jmp 109113 while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 109040: 8b 43 5c mov 0x5c(%ebx),%eax 109043: 8b 4b 64 mov 0x64(%ebx),%ecx 109046: 40 inc %eax 109047: 31 d2 xor %edx,%edx 109049: f7 f1 div %ecx c = tty->rawInBuf.theBuf[newHead]; 10904b: 8b 43 58 mov 0x58(%ebx),%eax 10904e: 8a 04 10 mov (%eax,%edx,1),%al 109051: 88 45 e3 mov %al,-0x1d(%ebp) tty->rawInBuf.Head = newHead; 109054: 89 53 5c mov %edx,0x5c(%ebx) if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 109057: 8b 43 60 mov 0x60(%ebx),%eax 10905a: 8b 7b 64 mov 0x64(%ebx),%edi % tty->rawInBuf.Size) 10905d: 8b 4b 64 mov 0x64(%ebx),%ecx 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) 109060: 01 f8 add %edi,%eax 109062: 29 d0 sub %edx,%eax % tty->rawInBuf.Size) 109064: 31 d2 xor %edx,%edx 109066: f7 f1 div %ecx 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) 109068: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx 10906e: 73 74 jae 1090e4 <== NEVER TAKEN % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 109070: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109076: 83 e0 fe and $0xfffffffe,%eax 109079: 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)) 10907f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109085: 25 02 02 00 00 and $0x202,%eax 10908a: 3d 02 02 00 00 cmp $0x202,%eax 10908f: 75 24 jne 1090b5 <== ALWAYS TAKEN == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) 109091: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 109098: 74 0a je 1090a4 <== NOT EXECUTED || (tty->flow_ctrl & FL_OSTOP))) { 10909a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1090a0: a8 20 test $0x20,%al <== NOT EXECUTED 1090a2: 74 11 je 1090b5 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)( 1090a4: 50 push %eax <== NOT EXECUTED 1090a5: 6a 01 push $0x1 <== NOT EXECUTED 1090a7: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 1090aa: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1090ad: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1090b3: eb 2c jmp 1090e1 <== NOT EXECUTED tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 1090b5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1090bb: f6 c4 01 test $0x1,%ah 1090be: 74 24 je 1090e4 <== ALWAYS TAKEN tty->flow_ctrl &= ~FL_IRTSOFF; 1090c0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1090c6: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 1090c9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 1090cf: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 1090d5: 85 c0 test %eax,%eax <== NOT EXECUTED 1090d7: 74 0b je 1090e4 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 1090d9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1090dc: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1090df: ff d0 call *%eax <== NOT EXECUTED 1090e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) 1090e4: 0f b6 45 e3 movzbl -0x1d(%ebp),%eax 1090e8: 89 da mov %ebx,%edx } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 1090ea: f6 43 3c 02 testb $0x2,0x3c(%ebx) 1090ee: 74 12 je 109102 <== NEVER TAKEN if (siproc (c, tty)) 1090f0: e8 e8 fc ff ff call 108ddd 1090f5: 85 c0 test %eax,%eax 1090f7: 74 17 je 109110 wait = 0; 1090f9: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 109100: eb 0e jmp 109110 } else { siproc (c, tty); 109102: e8 d6 fc ff ff call 108ddd <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 109107: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED 10910b: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 10910e: 7d e9 jge 1090f9 <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 109110: 8b 7b 70 mov 0x70(%ebx),%edi while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 109113: 8b 53 5c mov 0x5c(%ebx),%edx 109116: 8b 43 60 mov 0x60(%ebx),%eax 109119: 39 c2 cmp %eax,%edx 10911b: 75 08 jne 109125 } /* * Wait for characters */ if ( wait ) { 10911d: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 109121: 74 3f je 109162 109123: eb 11 jmp 109136 while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && (tty->ccount < (CBUFSIZE-1))) { 109125: a1 0c c1 12 00 mov 0x12c10c,%eax 10912a: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10912b: 39 43 20 cmp %eax,0x20(%ebx) 10912e: 0f 82 0c ff ff ff jb 109040 <== ALWAYS TAKEN 109134: eb e7 jmp 10911d <== NOT EXECUTED /* * Wait for characters */ if ( wait ) { sc = rtems_semaphore_obtain( 109136: 50 push %eax 109137: 57 push %edi 109138: ff 73 6c pushl 0x6c(%ebx) 10913b: ff 73 68 pushl 0x68(%ebx) 10913e: e8 4d 0c 00 00 call 109d90 tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 109143: 83 c4 10 add $0x10,%esp 109146: 85 c0 test %eax,%eax 109148: 74 c9 je 109113 10914a: eb 16 jmp 109162 if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 10914c: 8b 53 1c mov 0x1c(%ebx),%edx 10914f: 8a 14 02 mov (%edx,%eax,1),%dl 109152: 8b 4d dc mov -0x24(%ebp),%ecx 109155: 88 11 mov %dl,(%ecx) 109157: 41 inc %ecx 109158: 89 4d dc mov %ecx,-0x24(%ebp) 10915b: 40 inc %eax 10915c: 89 43 24 mov %eax,0x24(%ebx) count--; 10915f: ff 4d e4 decl -0x1c(%ebp) sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 109162: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 109166: 74 08 je 109170 109168: 8b 43 24 mov 0x24(%ebx),%eax 10916b: 3b 43 20 cmp 0x20(%ebx),%eax 10916e: 7c dc jl 10914c *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 109170: 8b 46 10 mov 0x10(%esi),%eax 109173: 2b 45 e4 sub -0x1c(%ebp),%eax 109176: 89 46 18 mov %eax,0x18(%esi) tty->tty_rcvwakeup = 0; 109179: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 109180: 00 00 00 rtems_semaphore_release (tty->isem); 109183: 83 ec 0c sub $0xc,%esp 109186: ff 73 14 pushl 0x14(%ebx) 109189: e8 f2 0c 00 00 call 109e80 return sc; 10918e: 83 c4 10 add $0x10,%esp } 109191: 8b 45 d8 mov -0x28(%ebp),%eax 109194: 8d 65 f4 lea -0xc(%ebp),%esp 109197: 5b pop %ebx 109198: 5e pop %esi 109199: 5f pop %edi 10919a: 5d pop %ebp 10919b: c3 ret =============================================================================== 00107d80 : * 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) { 107d80: 55 push %ebp 107d81: 89 e5 mov %esp,%ebp 107d83: 57 push %edi 107d84: 56 push %esi 107d85: 53 push %ebx 107d86: 83 ec 0c sub $0xc,%esp 107d89: 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)) 107d8b: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax 107d91: 25 03 04 00 00 and $0x403,%eax 107d96: 3d 01 04 00 00 cmp $0x401,%eax 107d9b: 75 24 jne 107dc1 <== ALWAYS TAKEN == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); 107d9d: 56 push %esi <== NOT EXECUTED 107d9e: 6a 01 push $0x1 <== NOT EXECUTED 107da0: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 107da3: 50 push %eax <== NOT EXECUTED 107da4: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107da7: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 107dad: 9c pushf <== NOT EXECUTED 107dae: fa cli <== NOT EXECUTED 107daf: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 107db0: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 107db6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107dbc: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 107dbf: eb 30 jmp 107df1 <== NOT EXECUTED rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) { 107dc1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 107dc7: 83 e0 03 and $0x3,%eax 107dca: 83 f8 02 cmp $0x2,%eax 107dcd: 75 37 jne 107e06 <== ALWAYS TAKEN * 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); 107dcf: 51 push %ecx <== NOT EXECUTED 107dd0: 6a 01 push $0x1 <== NOT EXECUTED 107dd2: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 107dd5: 50 push %eax <== NOT EXECUTED 107dd6: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107dd9: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 107ddf: 9c pushf <== NOT EXECUTED 107de0: fa cli <== NOT EXECUTED 107de1: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 107de2: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 107de8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107dee: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 107df1: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 107df7: 52 push %edx <== NOT EXECUTED 107df8: 9d popf <== NOT EXECUTED 107df9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 107dfc: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 107e01: e9 37 01 00 00 jmp 107f3d <== NOT EXECUTED } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 107e06: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 107e0c: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 107e12: 39 c2 cmp %eax,%edx 107e14: 75 25 jne 107e3b /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; 107e16: 31 f6 xor %esi,%esi } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 107e18: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 107e1f: 0f 85 18 01 00 00 jne 107f3d <== ALWAYS TAKEN /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 107e25: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107e28: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 107e2e: e8 4d 20 00 00 call 109e80 <== NOT EXECUTED 107e33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107e36: e9 02 01 00 00 jmp 107f3d <== NOT EXECUTED } return 0; } rtems_interrupt_disable(level); 107e3b: 9c pushf 107e3c: fa cli 107e3d: 58 pop %eax len = tty->t_dqlen; 107e3e: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi tty->t_dqlen = 0; 107e44: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 107e4b: 00 00 00 rtems_interrupt_enable(level); 107e4e: 50 push %eax 107e4f: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 107e50: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 107e56: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 107e5c: 01 f8 add %edi,%eax 107e5e: 31 d2 xor %edx,%edx 107e60: f7 f1 div %ecx 107e62: 89 d7 mov %edx,%edi tty->rawOutBuf.Tail = newTail; 107e64: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 107e6a: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 107e71: 75 11 jne 107e84 /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 107e73: 83 ec 0c sub $0xc,%esp 107e76: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 107e7c: e8 ff 1f 00 00 call 109e80 107e81: 83 c4 10 add $0x10,%esp } if (newTail == tty->rawOutBuf.Head) { 107e84: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 107e8a: 39 c7 cmp %eax,%edi 107e8c: 75 2b jne 107eb9 /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 107e8e: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 107e95: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 107e98: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax 107e9e: 85 c0 test %eax,%eax 107ea0: 0f 84 8f 00 00 00 je 107f35 <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 107ea6: 52 push %edx <== NOT EXECUTED 107ea7: 52 push %edx <== NOT EXECUTED 107ea8: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 107eae: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 107eb1: 52 push %edx <== NOT EXECUTED 107eb2: ff d0 call *%eax <== NOT EXECUTED 107eb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107eb7: eb 7c jmp 107f35 <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 107eb9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 107ebf: 25 10 02 00 00 and $0x210,%eax 107ec4: 3d 10 02 00 00 cmp $0x210,%eax 107ec9: 75 20 jne 107eeb <== ALWAYS TAKEN == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 107ecb: 9c pushf <== NOT EXECUTED 107ecc: fa cli <== NOT EXECUTED 107ecd: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 107ece: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107ed4: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 107ed7: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 107edd: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 107ee4: 00 00 00 rtems_interrupt_enable(level); 107ee7: 52 push %edx <== NOT EXECUTED 107ee8: 9d popf <== NOT EXECUTED 107ee9: eb 4a jmp 107f35 <== NOT EXECUTED nToSend = 0; } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 107eeb: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 107ef1: 39 c7 cmp %eax,%edi 107ef3: 76 08 jbe 107efd nToSend = tty->rawOutBuf.Size - newTail; 107ef5: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 107efb: eb 06 jmp 107f03 else nToSend = tty->rawOutBuf.Head - newTail; 107efd: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi 107f03: 29 fe sub %edi,%esi /* 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)) { 107f05: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 107f0b: f6 c4 06 test $0x6,%ah 107f0e: 74 05 je 107f15 nToSend = 1; 107f10: be 01 00 00 00 mov $0x1,%esi } tty->rawOutBufState = rob_busy; /*apm*/ 107f15: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 107f1c: 00 00 00 (*tty->device.write)( 107f1f: 50 push %eax 107f20: 56 push %esi 107f21: 8b 43 7c mov 0x7c(%ebx),%eax 107f24: 01 f8 add %edi,%eax 107f26: 50 push %eax 107f27: ff 73 10 pushl 0x10(%ebx) 107f2a: ff 93 a4 00 00 00 call *0xa4(%ebx) 107f30: 83 c4 10 add $0x10,%esp 107f33: eb 02 jmp 107f37 if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 107f35: 31 f6 xor %esi,%esi } tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 107f37: 89 bb 84 00 00 00 mov %edi,0x84(%ebx) } return nToSend; } 107f3d: 89 f0 mov %esi,%eax 107f3f: 8d 65 f4 lea -0xc(%ebp),%esp 107f42: 5b pop %ebx 107f43: 5e pop %esi 107f44: 5f pop %edi 107f45: 5d pop %ebp 107f46: c3 ret =============================================================================== 00109431 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 109431: 55 push %ebp 109432: 89 e5 mov %esp,%ebp 109434: 57 push %edi 109435: 56 push %esi 109436: 53 push %ebx 109437: 83 ec 1c sub $0x1c,%esp 10943a: 8b 5d 08 mov 0x8(%ebp),%ebx while (1) { /* * wait for rtems event */ rtems_event_receive( 10943d: 8d 7d e4 lea -0x1c(%ebp),%edi if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 109440: 8d 75 e3 lea -0x1d(%ebp),%esi while (1) { /* * wait for rtems event */ rtems_event_receive( 109443: 57 push %edi 109444: 6a 00 push $0x0 109446: 6a 02 push $0x2 109448: 6a 03 push $0x3 10944a: e8 0d 04 00 00 call 10985c (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) { 10944f: 83 c4 10 add $0x10,%esp 109452: f6 45 e4 01 testb $0x1,-0x1c(%ebp) 109456: 74 17 je 10946f <== ALWAYS TAKEN tty->rxTaskId = 0; 109458: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 10945f: 00 00 00 rtems_task_delete(RTEMS_SELF); 109462: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109465: 6a 00 push $0x0 <== NOT EXECUTED 109467: e8 dc 0b 00 00 call 10a048 <== NOT EXECUTED 10946c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * do something */ c = tty->device.pollRead(tty->minor); 10946f: 83 ec 0c sub $0xc,%esp 109472: ff 73 10 pushl 0x10(%ebx) 109475: ff 93 a0 00 00 00 call *0xa0(%ebx) if (c != EOF) { 10947b: 83 c4 10 add $0x10,%esp 10947e: 83 f8 ff cmp $0xffffffff,%eax 109481: 74 c0 je 109443 /* * pollRead did call enqueue on its own */ c_buf = c; 109483: 88 45 e3 mov %al,-0x1d(%ebp) rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 109486: 50 push %eax 109487: 6a 01 push $0x1 109489: 56 push %esi 10948a: 53 push %ebx 10948b: e8 27 fd ff ff call 1091b7 109490: 83 c4 10 add $0x10,%esp 109493: eb ae jmp 109443 =============================================================================== 00107f47 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 107f47: 55 push %ebp 107f48: 89 e5 mov %esp,%ebp 107f4a: 56 push %esi 107f4b: 53 push %ebx 107f4c: 83 ec 10 sub $0x10,%esp 107f4f: 8b 5d 08 mov 0x8(%ebp),%ebx while (1) { /* * wait for rtems event */ rtems_event_receive( 107f52: 8d 75 f4 lea -0xc(%ebp),%esi 107f55: 56 push %esi 107f56: 6a 00 push $0x0 107f58: 6a 02 push $0x2 107f5a: 6a 03 push $0x3 107f5c: e8 fb 18 00 00 call 10985c (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) { 107f61: 83 c4 10 add $0x10,%esp 107f64: f6 45 f4 01 testb $0x1,-0xc(%ebp) 107f68: 74 17 je 107f81 <== ALWAYS TAKEN tty->txTaskId = 0; 107f6a: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 107f71: 00 00 00 rtems_task_delete(RTEMS_SELF); 107f74: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f77: 6a 00 push $0x0 <== NOT EXECUTED 107f79: e8 ca 20 00 00 call 10a048 <== NOT EXECUTED 107f7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 107f81: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 107f87: c1 e0 05 shl $0x5,%eax 107f8a: 8b 80 d4 df 12 00 mov 0x12dfd4(%eax),%eax 107f90: 85 c0 test %eax,%eax 107f92: 74 09 je 107f9d <== ALWAYS TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 107f94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f97: 53 push %ebx <== NOT EXECUTED 107f98: ff d0 call *%eax <== NOT EXECUTED 107f9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 107f9d: 89 d8 mov %ebx,%eax 107f9f: e8 dc fd ff ff call 107d80 } 107fa4: eb af jmp 107f55 =============================================================================== 00108e2f : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 108e2f: 55 push %ebp 108e30: 89 e5 mov %esp,%ebp 108e32: 57 push %edi 108e33: 56 push %esi 108e34: 53 push %ebx 108e35: 83 ec 20 sub $0x20,%esp 108e38: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108e3b: 8b 03 mov (%ebx),%eax 108e3d: 8b 70 2c mov 0x2c(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108e40: 6a 00 push $0x0 108e42: 6a 00 push $0x0 108e44: ff 76 18 pushl 0x18(%esi) 108e47: e8 44 0f 00 00 call 109d90 108e4c: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) 108e4e: 83 c4 10 add $0x10,%esp 108e51: 85 c0 test %eax,%eax 108e53: 75 73 jne 108ec8 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 108e55: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 108e5b: c1 e0 05 shl $0x5,%eax 108e5e: 8b 80 cc df 12 00 mov 0x12dfcc(%eax),%eax 108e64: 85 c0 test %eax,%eax 108e66: 74 0b je 108e73 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 108e68: 52 push %edx 108e69: 52 push %edx 108e6a: 53 push %ebx 108e6b: 56 push %esi 108e6c: ff d0 call *%eax 108e6e: 89 c7 mov %eax,%edi rtems_semaphore_release (tty->osem); 108e70: 59 pop %ecx 108e71: eb 4a jmp 108ebd return sc; } if (tty->termios.c_oflag & OPOST) { 108e73: f6 46 34 01 testb $0x1,0x34(%esi) 108e77: 74 2b je 108ea4 <== NEVER TAKEN uint32_t count = args->count; char *buffer = args->buffer; 108e79: 8b 4b 0c mov 0xc(%ebx),%ecx } rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) 108e7c: 8b 43 10 mov 0x10(%ebx),%eax 108e7f: 01 c8 add %ecx,%eax 108e81: 89 45 e4 mov %eax,-0x1c(%ebp) return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 108e84: eb 11 jmp 108e97 oproc (*buffer++, tty); 108e86: 0f b6 01 movzbl (%ecx),%eax 108e89: 41 inc %ecx 108e8a: 89 f2 mov %esi,%edx 108e8c: 89 4d e0 mov %ecx,-0x20(%ebp) 108e8f: e8 3d fb ff ff call 1089d1 108e94: 8b 4d e0 mov -0x20(%ebp),%ecx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 108e97: 3b 4d e4 cmp -0x1c(%ebp),%ecx 108e9a: 75 ea jne 108e86 oproc (*buffer++, tty); args->bytes_moved = args->count; 108e9c: 8b 43 10 mov 0x10(%ebx),%eax 108e9f: 89 43 18 mov %eax,0x18(%ebx) 108ea2: eb 16 jmp 108eba } else { rtems_termios_puts (args->buffer, args->count, tty); 108ea4: 50 push %eax <== NOT EXECUTED 108ea5: 56 push %esi <== NOT EXECUTED 108ea6: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108ea9: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 108eac: e8 14 fa ff ff call 1088c5 <== NOT EXECUTED args->bytes_moved = args->count; 108eb1: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 108eb4: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 108eb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (tty->osem); 108eba: 83 ec 0c sub $0xc,%esp 108ebd: ff 76 18 pushl 0x18(%esi) 108ec0: e8 bb 0f 00 00 call 109e80 return sc; 108ec5: 83 c4 10 add $0x10,%esp } 108ec8: 89 f8 mov %edi,%eax 108eca: 8d 65 f4 lea -0xc(%ebp),%esp 108ecd: 5b pop %ebx 108ece: 5e pop %esi 108ecf: 5f pop %edi 108ed0: 5d pop %ebp 108ed1: c3 ret =============================================================================== 00115fac : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 115fac: 55 push %ebp 115fad: 89 e5 mov %esp,%ebp 115faf: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 115fb2: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 115fb5: 50 push %eax 115fb6: ff 75 08 pushl 0x8(%ebp) 115fb9: 68 84 87 14 00 push $0x148784 115fbe: e8 2d 28 00 00 call 1187f0 <_Objects_Get> switch ( location ) { 115fc3: 83 c4 10 add $0x10,%esp 115fc6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115fca: 75 1e jne 115fea case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 115fcc: 83 78 38 04 cmpl $0x4,0x38(%eax) 115fd0: 74 0f je 115fe1 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 115fd2: 83 ec 0c sub $0xc,%esp 115fd5: 83 c0 10 add $0x10,%eax 115fd8: 50 push %eax 115fd9: e8 62 41 00 00 call 11a140 <_Watchdog_Remove> 115fde: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 115fe1: e8 ae 33 00 00 call 119394 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115fe6: 31 c0 xor %eax,%eax 115fe8: eb 05 jmp 115fef #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115fea: b8 04 00 00 00 mov $0x4,%eax } 115fef: c9 leave 115ff0: c3 ret =============================================================================== 001168b9 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 1168b9: 55 push %ebp 1168ba: 89 e5 mov %esp,%ebp 1168bc: 53 push %ebx 1168bd: 83 ec 24 sub $0x24,%esp 1168c0: 8b 55 08 mov 0x8(%ebp),%edx */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1168c3: 31 c0 xor %eax,%eax 1168c5: 85 d2 test %edx,%edx 1168c7: 74 0f je 1168d8 ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 1168c9: 0f b6 05 48 f8 13 00 movzbl 0x13f848,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1168d0: 39 c2 cmp %eax,%edx 1168d2: 0f 96 c0 setbe %al 1168d5: 0f b6 c0 movzbl %al,%eax * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 1168d8: 85 c0 test %eax,%eax 1168da: 75 0d jne 1168e9 if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) return RTEMS_INVALID_PRIORITY; 1168dc: b0 13 mov $0x13,%al * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 1168de: 42 inc %edx 1168df: 0f 85 5c 01 00 00 jne 116a41 return RTEMS_INVALID_PRIORITY; _priority = 0; 1168e5: 31 db xor %ebx,%ebx 1168e7: eb 02 jmp 1168eb * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 1168e9: 89 d3 mov %edx,%ebx 1168eb: e8 78 fc ff ff call 116568 <_Thread_Dispatch_increment_disable_level> /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 1168f0: 8a 15 c0 37 14 00 mov 0x1437c0,%dl initialized = true; 1168f6: c6 05 c0 37 14 00 01 movb $0x1,0x1437c0 _Thread_Enable_dispatch(); 1168fd: 88 55 e4 mov %dl,-0x1c(%ebp) 116900: e8 8f 2a 00 00 call 119394 <_Thread_Enable_dispatch> if ( tmpInitialized ) return RTEMS_INCORRECT_STATE; 116905: b8 0e 00 00 00 mov $0xe,%eax _Thread_Disable_dispatch(); tmpInitialized = initialized; initialized = true; _Thread_Enable_dispatch(); if ( tmpInitialized ) 11690a: 8a 55 e4 mov -0x1c(%ebp),%dl 11690d: 84 d2 test %dl,%dl 11690f: 0f 85 2c 01 00 00 jne 116a41 <== NEVER TAKEN * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 116915: 50 push %eax 116916: 50 push %eax 116917: 8d 45 f4 lea -0xc(%ebp),%eax 11691a: 50 push %eax 11691b: 8b 45 10 mov 0x10(%ebp),%eax 11691e: 80 cc 80 or $0x80,%ah 116921: 50 push %eax 116922: 68 00 01 00 00 push $0x100 116927: ff 75 0c pushl 0xc(%ebp) 11692a: 53 push %ebx 11692b: 68 45 4d 49 54 push $0x54494d45 116930: e8 77 ee ff ff call 1157ac /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 116935: 83 c4 20 add $0x20,%esp 116938: 85 c0 test %eax,%eax 11693a: 74 0c je 116948 initialized = false; 11693c: c6 05 c0 37 14 00 00 movb $0x0,0x1437c0 116943: e9 f9 00 00 00 jmp 116a41 * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( &_RTEMS_tasks_Information, _Objects_Get_index(id) 116948: 8b 5d f4 mov -0xc(%ebp),%ebx */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 11694b: 0f b7 d3 movzwl %bx,%edx 11694e: a1 ec 7d 14 00 mov 0x147dec,%eax 116953: 8b 04 90 mov (%eax,%edx,4),%eax /* * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( 116956: a3 c4 37 14 00 mov %eax,0x1437c4 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11695b: c7 05 f4 37 14 00 f8 movl $0x1437f8,0x1437f4 116962: 37 14 00 head->previous = NULL; 116965: c7 05 f8 37 14 00 00 movl $0x0,0x1437f8 11696c: 00 00 00 tail->previous = head; 11696f: c7 05 fc 37 14 00 f4 movl $0x1437f4,0x1437fc 116976: 37 14 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116979: c7 05 2c 38 14 00 30 movl $0x143830,0x14382c 116980: 38 14 00 head->previous = NULL; 116983: c7 05 30 38 14 00 00 movl $0x0,0x143830 11698a: 00 00 00 tail->previous = head; 11698d: c7 05 34 38 14 00 2c movl $0x14382c,0x143834 116994: 38 14 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 116997: c7 05 d4 37 14 00 00 movl $0x0,0x1437d4 11699e: 00 00 00 the_watchdog->routine = routine; 1169a1: c7 05 e8 37 14 00 18 movl $0x119218,0x1437e8 1169a8: 92 11 00 the_watchdog->id = id; 1169ab: 89 1d ec 37 14 00 mov %ebx,0x1437ec the_watchdog->user_data = user_data; 1169b1: c7 05 f0 37 14 00 00 movl $0x0,0x1437f0 1169b8: 00 00 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1169bb: c7 05 0c 38 14 00 00 movl $0x0,0x14380c 1169c2: 00 00 00 the_watchdog->routine = routine; 1169c5: c7 05 20 38 14 00 18 movl $0x119218,0x143820 1169cc: 92 11 00 the_watchdog->id = id; 1169cf: 89 1d 24 38 14 00 mov %ebx,0x143824 the_watchdog->user_data = user_data; 1169d5: c7 05 28 38 14 00 00 movl $0x0,0x143828 1169dc: 00 00 00 /* * Initialize the pointer to the timer schedule method so applications that * do not use the Timer Server do not have to pull it in. */ ts->schedule_operation = _Timer_server_Schedule_operation_method; 1169df: c7 05 c8 37 14 00 09 movl $0x116609,0x1437c8 1169e6: 66 11 00 ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 1169e9: a1 48 7f 14 00 mov 0x147f48,%eax 1169ee: a3 00 38 14 00 mov %eax,0x143800 1169f3: 6a 00 push $0x0 1169f5: 68 00 ca 9a 3b push $0x3b9aca00 1169fa: ff 35 14 7e 14 00 pushl 0x147e14 116a00: ff 35 10 7e 14 00 pushl 0x147e10 116a06: e8 e9 3b 01 00 call 12a5f4 <__divdi3> 116a0b: 83 c4 0c add $0xc,%esp ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116a0e: a3 38 38 14 00 mov %eax,0x143838 ts->insert_chain = NULL; 116a13: c7 05 3c 38 14 00 00 movl $0x0,0x14383c 116a1a: 00 00 00 ts->active = false; 116a1d: c6 05 40 38 14 00 00 movb $0x0,0x143840 /* * The default timer server is now available. */ _Timer_server = ts; 116a24: c7 05 c4 87 14 00 c4 movl $0x1437c4,0x1487c4 116a2b: 37 14 00 /* * Start the timer server */ status = rtems_task_start( 116a2e: 68 c4 37 14 00 push $0x1437c4 116a33: 68 32 67 11 00 push $0x116732 116a38: 53 push %ebx 116a39: e8 56 f3 ff ff call 115d94 116a3e: 83 c4 10 add $0x10,%esp initialized = false; } #endif return status; } 116a41: 8b 5d fc mov -0x4(%ebp),%ebx 116a44: c9 leave 116a45: c3 ret =============================================================================== 0011645c : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 11645c: 55 push %ebp 11645d: 89 e5 mov %esp,%ebp 11645f: 57 push %edi 116460: 56 push %esi 116461: 53 push %ebx 116462: 83 ec 1c sub $0x1c,%esp 116465: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 116468: 8b 1d c4 87 14 00 mov 0x1487c4,%ebx if ( !timer_server ) 11646e: 85 db test %ebx,%ebx 116470: 0f 84 e1 00 00 00 je 116557 return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; 116476: b8 0b 00 00 00 mov $0xb,%eax Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) 11647b: 80 3d 24 7e 14 00 00 cmpb $0x0,0x147e24 116482: 0f 84 d6 00 00 00 je 11655e <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 116488: b0 09 mov $0x9,%al return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 11648a: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 11648e: 0f 84 ca 00 00 00 je 11655e return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116494: 83 ec 0c sub $0xc,%esp 116497: 56 push %esi 116498: e8 b3 d4 ff ff call 113950 <_TOD_Validate> 11649d: 83 c4 10 add $0x10,%esp 1164a0: 84 c0 test %al,%al 1164a2: 75 0a jne 1164ae return RTEMS_INVALID_CLOCK; 1164a4: b8 14 00 00 00 mov $0x14,%eax 1164a9: e9 b0 00 00 00 jmp 11655e seconds = _TOD_To_seconds( wall_time ); 1164ae: 83 ec 0c sub $0xc,%esp 1164b1: 56 push %esi 1164b2: e8 25 d4 ff ff call 1138dc <_TOD_To_seconds> 1164b7: 89 c6 mov %eax,%esi 1164b9: 6a 00 push $0x0 1164bb: 68 00 ca 9a 3b push $0x3b9aca00 1164c0: ff 35 14 7e 14 00 pushl 0x147e14 1164c6: ff 35 10 7e 14 00 pushl 0x147e10 1164cc: e8 23 41 01 00 call 12a5f4 <__divdi3> if ( seconds <= _TOD_Seconds_since_epoch() ) 1164d1: 83 c4 20 add $0x20,%esp 1164d4: 39 c6 cmp %eax,%esi 1164d6: 76 cc jbe 1164a4 1164d8: 50 push %eax return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 1164d9: 8d 45 e4 lea -0x1c(%ebp),%eax 1164dc: 50 push %eax 1164dd: ff 75 08 pushl 0x8(%ebp) 1164e0: 68 84 87 14 00 push $0x148784 1164e5: e8 06 23 00 00 call 1187f0 <_Objects_Get> 1164ea: 89 c7 mov %eax,%edi switch ( location ) { 1164ec: 83 c4 10 add $0x10,%esp #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1164ef: b8 04 00 00 00 mov $0x4,%eax seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1164f4: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 1164f8: 75 64 jne 11655e case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1164fa: 83 ec 0c sub $0xc,%esp 1164fd: 8d 47 10 lea 0x10(%edi),%eax 116500: 50 push %eax 116501: e8 3a 3c 00 00 call 11a140 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 116506: 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; 11650d: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 116514: 8b 45 10 mov 0x10(%ebp),%eax 116517: 89 47 2c mov %eax,0x2c(%edi) the_watchdog->id = id; 11651a: 8b 45 08 mov 0x8(%ebp),%eax 11651d: 89 47 30 mov %eax,0x30(%edi) the_watchdog->user_data = user_data; 116520: 8b 45 14 mov 0x14(%ebp),%eax 116523: 89 47 34 mov %eax,0x34(%edi) 116526: 6a 00 push $0x0 116528: 68 00 ca 9a 3b push $0x3b9aca00 11652d: ff 35 14 7e 14 00 pushl 0x147e14 116533: ff 35 10 7e 14 00 pushl 0x147e10 116539: e8 b6 40 01 00 call 12a5f4 <__divdi3> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 11653e: 29 c6 sub %eax,%esi 116540: 89 77 1c mov %esi,0x1c(%edi) (*timer_server->schedule_operation)( timer_server, the_timer ); 116543: 83 c4 18 add $0x18,%esp 116546: 57 push %edi 116547: 53 push %ebx 116548: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 11654b: e8 44 2e 00 00 call 119394 <_Thread_Enable_dispatch> 116550: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; 116553: 31 c0 xor %eax,%eax 116555: eb 07 jmp 11655e Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 116557: b8 0e 00 00 00 mov $0xe,%eax 11655c: eb 00 jmp 11655e case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11655e: 8d 65 f4 lea -0xc(%ebp),%esp 116561: 5b pop %ebx 116562: 5e pop %esi 116563: 5f pop %edi 116564: 5d pop %ebp 116565: c3 ret =============================================================================== 0010657d : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10657d: 55 push %ebp 10657e: 89 e5 mov %esp,%ebp 106580: 57 push %edi 106581: 56 push %esi 106582: 53 push %ebx 106583: 83 ec 1c sub $0x1c,%esp 106586: 89 c3 mov %eax,%ebx 106588: 89 55 e4 mov %edx,-0x1c(%ebp) 10658b: 89 cf mov %ecx,%edi int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) { 10658d: a9 00 00 00 20 test $0x20000000,%eax 106592: 75 27 jne 1065bb /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 106594: 83 ec 0c sub $0xc,%esp 106597: a1 a0 c2 12 00 mov 0x12c2a0,%eax 10659c: ff 70 08 pushl 0x8(%eax) 10659f: e8 a0 ac 00 00 call 111244 status = error_flag & ~RTEMS_ERROR_MASK; 1065a4: 89 de mov %ebx,%esi 1065a6: 81 e6 ff ff ff 8f and $0x8fffffff,%esi if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 1065ac: 83 c4 10 add $0x10,%esp 1065af: 81 e3 00 00 00 40 and $0x40000000,%ebx 1065b5: 75 36 jne 1065ed rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 1065b7: 31 db xor %ebx,%ebx 1065b9: eb 39 jmp 1065f4 int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) { if (rtems_panic_in_progress++) 1065bb: a1 cc e2 12 00 mov 0x12e2cc,%eax 1065c0: 8d 50 01 lea 0x1(%eax),%edx 1065c3: 89 15 cc e2 12 00 mov %edx,0x12e2cc 1065c9: 85 c0 test %eax,%eax 1065cb: 74 10 je 1065dd <== ALWAYS TAKEN * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 1065cd: a1 e4 e3 12 00 mov 0x12e3e4,%eax <== NOT EXECUTED 1065d2: 40 inc %eax <== NOT EXECUTED 1065d3: a3 e4 e3 12 00 mov %eax,0x12e3e4 <== NOT EXECUTED return _Thread_Dispatch_disable_level; 1065d8: a1 e4 e3 12 00 mov 0x12e3e4,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; 1065dd: 31 f6 xor %esi,%esi if (error_flag & RTEMS_ERROR_PANIC) { if (rtems_panic_in_progress++) _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 1065df: 83 3d cc e2 12 00 02 cmpl $0x2,0x12e2cc 1065e6: 7e ac jle 106594 <== ALWAYS TAKEN 1065e8: e9 b3 00 00 00 jmp 1066a0 <== NOT EXECUTED (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; 1065ed: e8 ea a8 00 00 call 110edc <__errno> 1065f2: 8b 18 mov (%eax),%ebx #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 1065f4: 50 push %eax 1065f5: 57 push %edi 1065f6: ff 75 e4 pushl -0x1c(%ebp) 1065f9: a1 a0 c2 12 00 mov 0x12c2a0,%eax 1065fe: ff 70 0c pushl 0xc(%eax) 106601: e8 ea 26 01 00 call 118cf0 106606: 89 c7 mov %eax,%edi if (status) 106608: 83 c4 10 add $0x10,%esp 10660b: 85 f6 test %esi,%esi 10660d: 74 24 je 106633 chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10660f: 83 ec 0c sub $0xc,%esp 106612: 56 push %esi 106613: e8 50 ff ff ff call 106568 106618: 83 c4 0c add $0xc,%esp 10661b: 50 push %eax 10661c: 68 b1 f3 11 00 push $0x11f3b1 106621: a1 a0 c2 12 00 mov 0x12c2a0,%eax 106626: ff 70 0c pushl 0xc(%eax) 106629: e8 d6 af 00 00 call 111604 #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 10662e: 01 c7 add %eax,%edi 106630: 83 c4 10 add $0x10,%esp fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 106633: 83 fb 00 cmp $0x0,%ebx 106636: 74 40 je 106678 if ((local_errno > 0) && *strerror(local_errno)) 106638: 7e 25 jle 10665f 10663a: 83 ec 0c sub $0xc,%esp 10663d: 53 push %ebx 10663e: e8 71 ba 00 00 call 1120b4 106643: 83 c4 10 add $0x10,%esp 106646: 80 38 00 cmpb $0x0,(%eax) 106649: 74 14 je 10665f <== NEVER TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10664b: 83 ec 0c sub $0xc,%esp 10664e: 53 push %ebx 10664f: e8 60 ba 00 00 call 1120b4 106654: 83 c4 0c add $0xc,%esp 106657: 50 push %eax 106658: 68 bf f3 11 00 push $0x11f3bf 10665d: eb 07 jmp 106666 else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10665f: 51 push %ecx 106660: 53 push %ebx 106661: 68 cc f3 11 00 push $0x11f3cc 106666: a1 a0 c2 12 00 mov 0x12c2a0,%eax 10666b: ff 70 0c pushl 0xc(%eax) 10666e: e8 91 af 00 00 call 111604 106673: 01 c7 add %eax,%edi 106675: 83 c4 10 add $0x10,%esp } chars_written += fprintf(stderr, "\n"); 106678: 50 push %eax 106679: 50 push %eax 10667a: 68 af fc 11 00 push $0x11fcaf 10667f: a1 a0 c2 12 00 mov 0x12c2a0,%eax 106684: ff 70 0c pushl 0xc(%eax) 106687: e8 78 af 00 00 call 111604 10668c: 8d 34 07 lea (%edi,%eax,1),%esi (void) fflush(stderr); 10668f: 5a pop %edx 106690: a1 a0 c2 12 00 mov 0x12c2a0,%eax 106695: ff 70 0c pushl 0xc(%eax) 106698: e8 a7 ab 00 00 call 111244 return chars_written; 10669d: 83 c4 10 add $0x10,%esp } 1066a0: 89 f0 mov %esi,%eax 1066a2: 8d 65 f4 lea -0xc(%ebp),%esp 1066a5: 5b pop %ebx 1066a6: 5e pop %esi 1066a7: 5f pop %edi 1066a8: 5d pop %ebp 1066a9: c3 ret =============================================================================== 00121e9c : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 121e9c: 55 push %ebp 121e9d: 89 e5 mov %esp,%ebp 121e9f: 57 push %edi 121ea0: 56 push %esi 121ea1: 53 push %ebx 121ea2: 83 ec 1c sub $0x1c,%esp 121ea5: 89 c6 mov %eax,%esi 121ea7: 89 55 dc mov %edx,-0x24(%ebp) int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0; 121eaa: 31 db xor %ebx,%ebx static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; unsigned int limit = INT_MAX; 121eac: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) */ static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; 121eb3: 31 ff xor %edi,%edi unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 121eb5: ff 4e 04 decl 0x4(%esi) 121eb8: 79 13 jns 121ecd <== ALWAYS TAKEN 121eba: 50 push %eax <== NOT EXECUTED 121ebb: 50 push %eax <== NOT EXECUTED 121ebc: 56 push %esi <== NOT EXECUTED 121ebd: ff 35 20 91 16 00 pushl 0x169120 <== NOT EXECUTED 121ec3: e8 78 40 01 00 call 135f40 <__srget_r> <== NOT EXECUTED 121ec8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121ecb: eb 08 jmp 121ed5 <== NOT EXECUTED 121ecd: 8b 16 mov (%esi),%edx 121ecf: 0f b6 02 movzbl (%edx),%eax 121ed2: 42 inc %edx 121ed3: 89 16 mov %edx,(%esi) if (c == ':') 121ed5: 83 f8 3a cmp $0x3a,%eax 121ed8: 74 45 je 121f1f break; if (sign == 0) { 121eda: 85 db test %ebx,%ebx 121edc: 75 0f jne 121eed if (c == '-') { sign = -1; limit++; continue; } sign = 1; 121ede: b3 01 mov $0x1,%bl for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 121ee0: 83 f8 2d cmp $0x2d,%eax 121ee3: 75 08 jne 121eed sign = -1; limit++; 121ee5: ff 45 e4 incl -0x1c(%ebp) c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; 121ee8: 83 cb ff or $0xffffffff,%ebx limit++; continue; 121eeb: eb c8 jmp 121eb5 } sign = 1; } if (!isdigit(c)) 121eed: 8b 15 00 91 16 00 mov 0x169100,%edx 121ef3: f6 44 02 01 04 testb $0x4,0x1(%edx,%eax,1) 121ef8: 74 3a je 121f34 return 0; d = c - '0'; 121efa: 83 e8 30 sub $0x30,%eax 121efd: 89 45 e0 mov %eax,-0x20(%ebp) if ((i > (limit / 10)) 121f00: b9 0a 00 00 00 mov $0xa,%ecx 121f05: 8b 45 e4 mov -0x1c(%ebp),%eax 121f08: 31 d2 xor %edx,%edx 121f0a: f7 f1 div %ecx 121f0c: 39 c7 cmp %eax,%edi 121f0e: 77 24 ja 121f34 || ((i == (limit / 10)) && (d > (limit % 10)))) 121f10: 75 05 jne 121f17 121f12: 39 55 e0 cmp %edx,-0x20(%ebp) 121f15: 77 1d ja 121f34 <== ALWAYS TAKEN return 0; i = i * 10 + d; 121f17: 6b ff 0a imul $0xa,%edi,%edi 121f1a: 03 7d e0 add -0x20(%ebp),%edi 121f1d: eb 96 jmp 121eb5 continue; } sign = 1; } if (!isdigit(c)) return 0; 121f1f: 31 c0 xor %eax,%eax if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 121f21: 85 db test %ebx,%ebx 121f23: 74 11 je 121f36 <== NEVER TAKEN return 0; *val = i * sign; 121f25: 0f af df imul %edi,%ebx 121f28: 8b 45 dc mov -0x24(%ebp),%eax 121f2b: 89 18 mov %ebx,(%eax) return 1; 121f2d: b8 01 00 00 00 mov $0x1,%eax 121f32: eb 02 jmp 121f36 continue; } sign = 1; } if (!isdigit(c)) return 0; 121f34: 31 c0 xor %eax,%eax } if (sign == 0) return 0; *val = i * sign; return 1; } 121f36: 8d 65 f4 lea -0xc(%ebp),%esp 121f39: 5b pop %ebx 121f3a: 5e pop %esi 121f3b: 5f pop %edi 121f3c: 5d pop %ebp 121f3d: c3 ret =============================================================================== 00121fbe : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 121fbe: 55 push %ebp 121fbf: 89 e5 mov %esp,%ebp 121fc1: 56 push %esi 121fc2: 53 push %ebx 121fc3: 83 ec 28 sub $0x28,%esp 121fc6: 89 c6 mov %eax,%esi 121fc8: 89 d3 mov %edx,%ebx 121fca: 89 4d e4 mov %ecx,-0x1c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 121fcd: 6a 00 push $0x0 121fcf: 8d 45 08 lea 0x8(%ebp),%eax 121fd2: 50 push %eax 121fd3: 8d 4d e4 lea -0x1c(%ebp),%ecx 121fd6: 89 f0 mov %esi,%eax 121fd8: e8 61 ff ff ff call 121f3e 121fdd: 83 c4 10 add $0x10,%esp 121fe0: 85 c0 test %eax,%eax 121fe2: 75 07 jne 121feb || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; 121fe4: 31 c0 xor %eax,%eax 121fe6: e9 b7 00 00 00 jmp 1220a2 int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 121feb: 50 push %eax 121fec: 50 push %eax 121fed: 8d 53 04 lea 0x4(%ebx),%edx 121ff0: 6a 00 push $0x0 121ff2: 8d 45 08 lea 0x8(%ebp),%eax 121ff5: 50 push %eax 121ff6: 8d 4d e4 lea -0x1c(%ebp),%ecx 121ff9: 89 f0 mov %esi,%eax 121ffb: e8 3e ff ff ff call 121f3e 122000: 83 c4 10 add $0x10,%esp 122003: 85 c0 test %eax,%eax 122005: 74 dd je 121fe4 <== NEVER TAKEN || !scanInt(fp, &grgid) 122007: 8d 55 f0 lea -0x10(%ebp),%edx 12200a: 89 f0 mov %esi,%eax 12200c: e8 8b fe ff ff call 121e9c 122011: 85 c0 test %eax,%eax 122013: 74 cf je 121fe4 <== NEVER TAKEN || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 122015: 51 push %ecx 122016: 51 push %ecx 122017: 6a 01 push $0x1 122019: 8d 45 08 lea 0x8(%ebp),%eax 12201c: 50 push %eax 12201d: 8d 4d e4 lea -0x1c(%ebp),%ecx 122020: 8d 55 f4 lea -0xc(%ebp),%edx 122023: 89 f0 mov %esi,%eax 122025: e8 14 ff ff ff call 121f3e 12202a: 83 c4 10 add $0x10,%esp 12202d: 85 c0 test %eax,%eax 12202f: 74 b3 je 121fe4 <== NEVER TAKEN return 0; grp->gr_gid = grgid; 122031: 8b 45 f0 mov -0x10(%ebp),%eax 122034: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 122038: 8b 75 f4 mov -0xc(%ebp),%esi 12203b: 89 f2 mov %esi,%edx 12203d: b8 01 00 00 00 mov $0x1,%eax 122042: eb 0c jmp 122050 if(*cp == ',') memcount++; 122044: 80 f9 2c cmp $0x2c,%cl 122047: 0f 94 c1 sete %cl 12204a: 0f b6 c9 movzbl %cl,%ecx 12204d: 01 c8 add %ecx,%eax grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 12204f: 42 inc %edx 122050: 8a 0a mov (%edx),%cl 122052: 84 c9 test %cl,%cl 122054: 75 ee jne 122044 } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 122056: 8d 04 85 13 00 00 00 lea 0x13(,%eax,4),%eax 12205d: 39 45 08 cmp %eax,0x8(%ebp) 122060: 72 82 jb 121fe4 <== NEVER TAKEN return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 122062: 8b 45 e4 mov -0x1c(%ebp),%eax 122065: 83 c0 0f add $0xf,%eax 122068: 83 e0 f0 and $0xfffffff0,%eax 12206b: 89 43 0c mov %eax,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 12206e: 89 30 mov %esi,(%eax) } /* * Extract a single group record from the database */ static int scangr( 122070: 8b 45 f4 mov -0xc(%ebp),%eax 122073: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 122074: ba 01 00 00 00 mov $0x1,%edx 122079: eb 11 jmp 12208c if(*cp == ',') { 12207b: 80 f9 2c cmp $0x2c,%cl 12207e: 75 0b jne 12208b *cp = '\0'; 122080: c6 40 ff 00 movb $0x0,-0x1(%eax) grp->gr_mem[memcount++] = cp + 1; 122084: 8b 4b 0c mov 0xc(%ebx),%ecx 122087: 89 04 91 mov %eax,(%ecx,%edx,4) 12208a: 42 inc %edx 12208b: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 12208c: 8a 48 ff mov -0x1(%eax),%cl 12208f: 84 c9 test %cl,%cl 122091: 75 e8 jne 12207b if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 122093: 8b 43 0c mov 0xc(%ebx),%eax 122096: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) return 1; 12209d: b8 01 00 00 00 mov $0x1,%eax } 1220a2: 8d 65 f8 lea -0x8(%ebp),%esp 1220a5: 5b pop %ebx 1220a6: 5e pop %esi 1220a7: 5d pop %ebp 1220a8: c3 ret =============================================================================== 001220a9 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 1220a9: 55 push %ebp 1220aa: 89 e5 mov %esp,%ebp 1220ac: 56 push %esi 1220ad: 53 push %ebx 1220ae: 83 ec 28 sub $0x28,%esp 1220b1: 89 c6 mov %eax,%esi 1220b3: 89 d3 mov %edx,%ebx 1220b5: 89 4d e4 mov %ecx,-0x1c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 1220b8: 6a 00 push $0x0 1220ba: 8d 45 08 lea 0x8(%ebp),%eax 1220bd: 50 push %eax 1220be: 8d 4d e4 lea -0x1c(%ebp),%ecx 1220c1: 89 f0 mov %esi,%eax 1220c3: e8 76 fe ff ff call 121f3e 1220c8: 83 c4 10 add $0x10,%esp 1220cb: 85 c0 test %eax,%eax 1220cd: 75 07 jne 1220d6 || !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; 1220cf: 31 c0 xor %eax,%eax 1220d1: e9 c3 00 00 00 jmp 122199 ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 1220d6: 50 push %eax 1220d7: 50 push %eax 1220d8: 8d 53 04 lea 0x4(%ebx),%edx 1220db: 6a 00 push $0x0 1220dd: 8d 45 08 lea 0x8(%ebp),%eax 1220e0: 50 push %eax 1220e1: 8d 4d e4 lea -0x1c(%ebp),%ecx 1220e4: 89 f0 mov %esi,%eax 1220e6: e8 53 fe ff ff call 121f3e 1220eb: 83 c4 10 add $0x10,%esp 1220ee: 85 c0 test %eax,%eax 1220f0: 74 dd je 1220cf <== NEVER TAKEN || !scanInt(fp, &pwuid) 1220f2: 8d 55 f0 lea -0x10(%ebp),%edx 1220f5: 89 f0 mov %esi,%eax 1220f7: e8 a0 fd ff ff call 121e9c 1220fc: 85 c0 test %eax,%eax 1220fe: 74 cf je 1220cf || !scanInt(fp, &pwgid) 122100: 8d 55 f4 lea -0xc(%ebp),%edx 122103: 89 f0 mov %esi,%eax 122105: e8 92 fd ff ff call 121e9c 12210a: 85 c0 test %eax,%eax 12210c: 74 c1 je 1220cf || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 12210e: 50 push %eax 12210f: 50 push %eax 122110: 8d 53 0c lea 0xc(%ebx),%edx 122113: 6a 00 push $0x0 122115: 8d 45 08 lea 0x8(%ebp),%eax 122118: 50 push %eax 122119: 8d 4d e4 lea -0x1c(%ebp),%ecx 12211c: 89 f0 mov %esi,%eax 12211e: e8 1b fe ff ff call 121f3e 122123: 83 c4 10 add $0x10,%esp 122126: 85 c0 test %eax,%eax 122128: 74 a5 je 1220cf <== NEVER TAKEN || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 12212a: 50 push %eax 12212b: 50 push %eax 12212c: 8d 53 10 lea 0x10(%ebx),%edx 12212f: 6a 00 push $0x0 122131: 8d 45 08 lea 0x8(%ebp),%eax 122134: 50 push %eax 122135: 8d 4d e4 lea -0x1c(%ebp),%ecx 122138: 89 f0 mov %esi,%eax 12213a: e8 ff fd ff ff call 121f3e 12213f: 83 c4 10 add $0x10,%esp 122142: 85 c0 test %eax,%eax 122144: 74 89 je 1220cf <== NEVER TAKEN || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 122146: 50 push %eax 122147: 50 push %eax 122148: 8d 53 14 lea 0x14(%ebx),%edx 12214b: 6a 00 push $0x0 12214d: 8d 45 08 lea 0x8(%ebp),%eax 122150: 50 push %eax 122151: 8d 4d e4 lea -0x1c(%ebp),%ecx 122154: 89 f0 mov %esi,%eax 122156: e8 e3 fd ff ff call 121f3e 12215b: 83 c4 10 add $0x10,%esp 12215e: 85 c0 test %eax,%eax 122160: 0f 84 69 ff ff ff je 1220cf <== NEVER TAKEN || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 122166: 50 push %eax 122167: 50 push %eax 122168: 8d 53 18 lea 0x18(%ebx),%edx 12216b: 6a 01 push $0x1 12216d: 8d 45 08 lea 0x8(%ebp),%eax 122170: 50 push %eax 122171: 8d 4d e4 lea -0x1c(%ebp),%ecx 122174: 89 f0 mov %esi,%eax 122176: e8 c3 fd ff ff call 121f3e 12217b: 83 c4 10 add $0x10,%esp 12217e: 85 c0 test %eax,%eax 122180: 0f 84 49 ff ff ff je 1220cf return 0; pwd->pw_uid = pwuid; 122186: 8b 45 f0 mov -0x10(%ebp),%eax 122189: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 12218d: 8b 45 f4 mov -0xc(%ebp),%eax 122190: 66 89 43 0a mov %ax,0xa(%ebx) return 1; 122194: b8 01 00 00 00 mov $0x1,%eax } 122199: 8d 65 f8 lea -0x8(%ebp),%esp 12219c: 5b pop %ebx 12219d: 5e pop %esi 12219e: 5d pop %ebp 12219f: c3 ret =============================================================================== 0010a400 : #include int sched_get_priority_max( int policy ) { 10a400: 55 push %ebp 10a401: 89 e5 mov %esp,%ebp 10a403: 83 ec 08 sub $0x8,%esp 10a406: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a409: 83 f9 04 cmp $0x4,%ecx 10a40c: 77 0b ja 10a419 10a40e: b8 01 00 00 00 mov $0x1,%eax 10a413: d3 e0 shl %cl,%eax 10a415: a8 17 test $0x17,%al 10a417: 75 10 jne 10a429 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a419: e8 36 74 00 00 call 111854 <__errno> 10a41e: c7 00 16 00 00 00 movl $0x16,(%eax) 10a424: 83 c8 ff or $0xffffffff,%eax 10a427: eb 08 jmp 10a431 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a429: 0f b6 05 88 b1 12 00 movzbl 0x12b188,%eax 10a430: 48 dec %eax } 10a431: c9 leave 10a432: c3 ret =============================================================================== 0010a434 : #include int sched_get_priority_min( int policy ) { 10a434: 55 push %ebp 10a435: 89 e5 mov %esp,%ebp 10a437: 83 ec 08 sub $0x8,%esp 10a43a: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a43d: 83 f9 04 cmp $0x4,%ecx 10a440: 77 11 ja 10a453 10a442: ba 01 00 00 00 mov $0x1,%edx 10a447: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a449: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a44e: 80 e2 17 and $0x17,%dl 10a451: 75 0e jne 10a461 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a453: e8 fc 73 00 00 call 111854 <__errno> 10a458: c7 00 16 00 00 00 movl $0x16,(%eax) 10a45e: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a461: c9 leave 10a462: c3 ret =============================================================================== 0010a464 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a464: 55 push %ebp 10a465: 89 e5 mov %esp,%ebp 10a467: 56 push %esi 10a468: 53 push %ebx 10a469: 8b 75 08 mov 0x8(%ebp),%esi 10a46c: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a46f: 85 f6 test %esi,%esi 10a471: 74 16 je 10a489 <== NEVER TAKEN 10a473: e8 a4 c7 ff ff call 106c1c 10a478: 39 c6 cmp %eax,%esi 10a47a: 74 0d je 10a489 rtems_set_errno_and_return_minus_one( ESRCH ); 10a47c: e8 d3 73 00 00 call 111854 <__errno> 10a481: c7 00 03 00 00 00 movl $0x3,(%eax) 10a487: eb 0f jmp 10a498 if ( !interval ) 10a489: 85 db test %ebx,%ebx 10a48b: 75 10 jne 10a49d rtems_set_errno_and_return_minus_one( EINVAL ); 10a48d: e8 c2 73 00 00 call 111854 <__errno> 10a492: c7 00 16 00 00 00 movl $0x16,(%eax) 10a498: 83 c8 ff or $0xffffffff,%eax 10a49b: eb 13 jmp 10a4b0 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a49d: 50 push %eax 10a49e: 50 push %eax 10a49f: 53 push %ebx 10a4a0: ff 35 a8 f3 12 00 pushl 0x12f3a8 10a4a6: e8 2d 2f 00 00 call 10d3d8 <_Timespec_From_ticks> return 0; 10a4ab: 83 c4 10 add $0x10,%esp 10a4ae: 31 c0 xor %eax,%eax } 10a4b0: 8d 65 f8 lea -0x8(%ebp),%esp 10a4b3: 5b pop %ebx 10a4b4: 5e pop %esi 10a4b5: 5d pop %ebp 10a4b6: c3 ret =============================================================================== 0010a90c : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10a90c: 55 push %ebp 10a90d: 89 e5 mov %esp,%ebp 10a90f: 57 push %edi 10a910: 56 push %esi 10a911: 53 push %ebx 10a912: 83 ec 1c sub $0x1c,%esp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10a915: a1 b4 31 13 00 mov 0x1331b4,%eax 10a91a: 40 inc %eax 10a91b: a3 b4 31 13 00 mov %eax,0x1331b4 return _Thread_Dispatch_disable_level; 10a920: a1 b4 31 13 00 mov 0x1331b4,%eax va_list arg; mode_t mode; unsigned int value = 0; 10a925: 31 db xor %ebx,%ebx Objects_Locations location; size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10a927: 8b 75 0c mov 0xc(%ebp),%esi 10a92a: 81 e6 00 02 00 00 and $0x200,%esi 10a930: 74 03 je 10a935 va_start(arg, oflag); mode = va_arg( arg, mode_t ); value = va_arg( arg, unsigned int ); 10a932: 8b 5d 14 mov 0x14(%ebp),%ebx va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id, &name_len ); 10a935: 8d 45 e4 lea -0x1c(%ebp),%eax const char *name, Objects_Id *id, size_t *len ) { return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len ); 10a938: 50 push %eax 10a939: 8d 45 d8 lea -0x28(%ebp),%eax 10a93c: 50 push %eax 10a93d: ff 75 08 pushl 0x8(%ebp) 10a940: 68 78 34 13 00 push $0x133478 10a945: e8 16 fa ff ff call 10a360 <_POSIX_Name_to_id> 10a94a: 89 c7 mov %eax,%edi * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10a94c: 83 c4 10 add $0x10,%esp 10a94f: 85 c0 test %eax,%eax 10a951: 74 17 je 10a96a /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10a953: 83 f8 02 cmp $0x2,%eax 10a956: 75 04 jne 10a95c 10a958: 85 f6 test %esi,%esi 10a95a: 75 56 jne 10a9b2 _Thread_Enable_dispatch(); 10a95c: e8 5b 2d 00 00 call 10d6bc <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10a961: e8 32 7f 00 00 call 112898 <__errno> 10a966: 89 38 mov %edi,(%eax) 10a968: eb 72 jmp 10a9dc /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10a96a: 8b 45 0c mov 0xc(%ebp),%eax 10a96d: 25 00 0a 00 00 and $0xa00,%eax 10a972: 3d 00 0a 00 00 cmp $0xa00,%eax 10a977: 75 12 jne 10a98b _Thread_Enable_dispatch(); 10a979: e8 3e 2d 00 00 call 10d6bc <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10a97e: e8 15 7f 00 00 call 112898 <__errno> 10a983: c7 00 11 00 00 00 movl $0x11,(%eax) 10a989: eb 51 jmp 10a9dc RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get ( sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) 10a98b: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location ); 10a98c: 8d 45 e0 lea -0x20(%ebp),%eax 10a98f: 50 push %eax 10a990: ff 75 d8 pushl -0x28(%ebp) 10a993: 68 78 34 13 00 push $0x133478 10a998: e8 27 21 00 00 call 10cac4 <_Objects_Get> 10a99d: 89 45 dc mov %eax,-0x24(%ebp) the_semaphore->open_count += 1; 10a9a0: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10a9a3: e8 14 2d 00 00 call 10d6bc <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10a9a8: e8 0f 2d 00 00 call 10d6bc <_Thread_Enable_dispatch> goto return_id; 10a9ad: 83 c4 10 add $0x10,%esp 10a9b0: eb 22 jmp 10a9d4 /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10a9b2: 83 ec 0c sub $0xc,%esp 10a9b5: 8d 45 dc lea -0x24(%ebp),%eax 10a9b8: 50 push %eax 10a9b9: 53 push %ebx 10a9ba: 6a 00 push $0x0 10a9bc: ff 75 e4 pushl -0x1c(%ebp) 10a9bf: ff 75 08 pushl 0x8(%ebp) 10a9c2: e8 11 57 00 00 call 1100d8 <_POSIX_Semaphore_Create_support> 10a9c7: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10a9c9: 83 c4 20 add $0x20,%esp 10a9cc: e8 eb 2c 00 00 call 10d6bc <_Thread_Enable_dispatch> if ( status == -1 ) 10a9d1: 43 inc %ebx 10a9d2: 74 08 je 10a9dc <== NEVER TAKEN return_id: #if defined(RTEMS_USE_16_BIT_OBJECT) the_semaphore->Semaphore_id = the_semaphore->Object.id; return &the_semaphore->Semaphore_id; #else return (sem_t *)&the_semaphore->Object.id; 10a9d4: 8b 45 dc mov -0x24(%ebp),%eax 10a9d7: 83 c0 08 add $0x8,%eax 10a9da: eb 03 jmp 10a9df */ _Thread_Enable_dispatch(); if ( status == -1 ) return SEM_FAILED; 10a9dc: 83 c8 ff or $0xffffffff,%eax the_semaphore->Semaphore_id = the_semaphore->Object.id; return &the_semaphore->Semaphore_id; #else return (sem_t *)&the_semaphore->Object.id; #endif } 10a9df: 8d 65 f4 lea -0xc(%ebp),%esp 10a9e2: 5b pop %ebx 10a9e3: 5e pop %esi 10a9e4: 5f pop %edi 10a9e5: 5d pop %ebp 10a9e6: c3 ret =============================================================================== 0010cc08 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 10cc08: 55 push %ebp 10cc09: 89 e5 mov %esp,%ebp 10cc0b: 53 push %ebx 10cc0c: 83 ec 1c sub $0x1c,%esp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10cc0f: 8d 45 f4 lea -0xc(%ebp),%eax 10cc12: 50 push %eax 10cc13: ff 75 0c pushl 0xc(%ebp) 10cc16: e8 49 49 00 00 call 111564 <_POSIX_Absolute_timeout_to_ticks> if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 10cc1b: 83 c4 0c add $0xc,%esp 10cc1e: 83 f8 03 cmp $0x3,%eax 10cc21: 0f 94 c3 sete %bl do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10cc24: ff 75 f4 pushl -0xc(%ebp) 10cc27: 0f b6 c3 movzbl %bl,%eax 10cc2a: 50 push %eax 10cc2b: ff 75 08 pushl 0x8(%ebp) 10cc2e: e8 59 53 00 00 call 111f8c <_POSIX_Semaphore_Wait_support> * This service only gives us the option to block. We used a polling * attempt to obtain if the abstime was not in the future. If we did * not obtain the semaphore, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 10cc33: 83 c4 10 add $0x10,%esp 10cc36: 84 db test %bl,%bl 10cc38: 75 00 jne 10cc3a <== ALWAYS TAKEN lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) rtems_set_errno_and_return_minus_one( ETIMEDOUT ); } return lock_status; } 10cc3a: 8b 5d fc mov -0x4(%ebp),%ebx 10cc3d: c9 leave 10cc3e: c3 ret =============================================================================== 0010a2a8 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a2a8: 55 push %ebp 10a2a9: 89 e5 mov %esp,%ebp 10a2ab: 57 push %edi 10a2ac: 56 push %esi 10a2ad: 53 push %ebx 10a2ae: 83 ec 1c sub $0x1c,%esp 10a2b1: 8b 5d 08 mov 0x8(%ebp),%ebx 10a2b4: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a2b7: 85 c0 test %eax,%eax 10a2b9: 74 12 je 10a2cd *oact = _POSIX_signals_Vectors[ sig ]; 10a2bb: 6b f3 0c imul $0xc,%ebx,%esi 10a2be: 81 c6 68 09 13 00 add $0x130968,%esi 10a2c4: b9 03 00 00 00 mov $0x3,%ecx 10a2c9: 89 c7 mov %eax,%edi 10a2cb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a2cd: 85 db test %ebx,%ebx 10a2cf: 75 02 jne 10a2d3 10a2d1: eb 0f jmp 10a2e2 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a2d3: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a2d6: 83 f8 1f cmp $0x1f,%eax 10a2d9: 76 02 jbe 10a2dd 10a2db: eb 05 jmp 10a2e2 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a2dd: 83 fb 09 cmp $0x9,%ebx 10a2e0: 75 10 jne 10a2f2 rtems_set_errno_and_return_minus_one( EINVAL ); 10a2e2: e8 b5 78 00 00 call 111b9c <__errno> 10a2e7: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2ed: 83 c8 ff or $0xffffffff,%eax 10a2f0: eb 55 jmp 10a347 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a2f2: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10a2f6: 74 4d je 10a345 <== NEVER TAKEN /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 10a2f8: 9c pushf 10a2f9: fa cli 10a2fa: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a2fd: 8b 45 0c mov 0xc(%ebp),%eax 10a300: 83 78 08 00 cmpl $0x0,0x8(%eax) 10a304: 75 1a jne 10a320 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a306: 6b f3 0c imul $0xc,%ebx,%esi 10a309: 8d 86 68 09 13 00 lea 0x130968(%esi),%eax 10a30f: 81 c6 a8 19 12 00 add $0x1219a8,%esi 10a315: b9 03 00 00 00 mov $0x3,%ecx 10a31a: 89 c7 mov %eax,%edi 10a31c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a31e: eb 21 jmp 10a341 } else { _POSIX_signals_Clear_process_signals( sig ); 10a320: 83 ec 0c sub $0xc,%esp 10a323: 53 push %ebx 10a324: e8 6f 4c 00 00 call 10ef98 <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a329: 6b db 0c imul $0xc,%ebx,%ebx 10a32c: 81 c3 68 09 13 00 add $0x130968,%ebx 10a332: b9 03 00 00 00 mov $0x3,%ecx 10a337: 89 df mov %ebx,%edi 10a339: 8b 75 0c mov 0xc(%ebp),%esi 10a33c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a33e: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a341: ff 75 e4 pushl -0x1c(%ebp) 10a344: 9d popf * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10a345: 31 c0 xor %eax,%eax } 10a347: 8d 65 f4 lea -0xc(%ebp),%esp 10a34a: 5b pop %ebx 10a34b: 5e pop %esi 10a34c: 5f pop %edi 10a34d: 5d pop %ebp 10a34e: c3 ret =============================================================================== 0010a702 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10a702: 55 push %ebp 10a703: 89 e5 mov %esp,%ebp 10a705: 57 push %edi 10a706: 56 push %esi 10a707: 53 push %ebx 10a708: 83 ec 2c sub $0x2c,%esp 10a70b: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10a70e: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10a712: 75 02 jne 10a716 10a714: eb 28 jmp 10a73e /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10a716: 85 db test %ebx,%ebx 10a718: 74 34 je 10a74e if ( !_Timespec_Is_valid( timeout ) ) 10a71a: 83 ec 0c sub $0xc,%esp 10a71d: 53 push %ebx 10a71e: e8 35 30 00 00 call 10d758 <_Timespec_Is_valid> 10a723: 83 c4 10 add $0x10,%esp 10a726: 84 c0 test %al,%al 10a728: 75 02 jne 10a72c 10a72a: eb 12 jmp 10a73e rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10a72c: 83 ec 0c sub $0xc,%esp 10a72f: 53 push %ebx 10a730: e8 47 30 00 00 call 10d77c <_Timespec_To_ticks> 10a735: 89 c1 mov %eax,%ecx if ( !interval ) 10a737: 83 c4 10 add $0x10,%esp 10a73a: 85 c0 test %eax,%eax 10a73c: 75 12 jne 10a750 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a73e: e8 1d 7a 00 00 call 112160 <__errno> 10a743: c7 00 16 00 00 00 movl $0x16,(%eax) 10a749: e9 29 01 00 00 jmp 10a877 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10a74e: 31 c9 xor %ecx,%ecx /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10a750: 8b 5d 0c mov 0xc(%ebp),%ebx 10a753: 85 db test %ebx,%ebx 10a755: 75 03 jne 10a75a 10a757: 8d 5d dc lea -0x24(%ebp),%ebx the_thread = _Thread_Executing; 10a75a: 8b 15 2c 09 13 00 mov 0x13092c,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a760: 8b b2 e8 00 00 00 mov 0xe8(%edx),%esi * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10a766: 9c pushf 10a767: fa cli 10a768: 8f 45 d4 popl -0x2c(%ebp) if ( *set & api->signals_pending ) { 10a76b: 8b 45 08 mov 0x8(%ebp),%eax 10a76e: 8b 38 mov (%eax),%edi 10a770: 8b 86 d4 00 00 00 mov 0xd4(%esi),%eax 10a776: 85 c7 test %eax,%edi 10a778: 74 2c je 10a7a6 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10a77a: e8 45 ff ff ff call 10a6c4 <_POSIX_signals_Get_lowest> 10a77f: 89 03 mov %eax,(%ebx) _POSIX_signals_Clear_signals( 10a781: 83 ec 0c sub $0xc,%esp 10a784: 6a 00 push $0x0 10a786: 6a 00 push $0x0 10a788: 53 push %ebx 10a789: 50 push %eax 10a78a: 56 push %esi 10a78b: e8 f4 4e 00 00 call 10f684 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10a790: ff 75 d4 pushl -0x2c(%ebp) 10a793: 9d popf the_info->si_code = SI_USER; 10a794: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) the_info->si_value.sival_int = 0; 10a79b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) return the_info->si_signo; 10a7a2: 8b 3b mov (%ebx),%edi 10a7a4: eb 33 jmp 10a7d9 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10a7a6: a1 5c 0b 13 00 mov 0x130b5c,%eax 10a7ab: 85 c7 test %eax,%edi 10a7ad: 74 32 je 10a7e1 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10a7af: e8 10 ff ff ff call 10a6c4 <_POSIX_signals_Get_lowest> 10a7b4: 89 c7 mov %eax,%edi _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10a7b6: 83 ec 0c sub $0xc,%esp 10a7b9: 6a 00 push $0x0 10a7bb: 6a 01 push $0x1 10a7bd: 53 push %ebx 10a7be: 50 push %eax 10a7bf: 56 push %esi 10a7c0: e8 bf 4e 00 00 call 10f684 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10a7c5: ff 75 d4 pushl -0x2c(%ebp) 10a7c8: 9d popf the_info->si_signo = signo; 10a7c9: 89 3b mov %edi,(%ebx) the_info->si_code = SI_USER; 10a7cb: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) the_info->si_value.sival_int = 0; 10a7d2: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10a7d9: 83 c4 20 add $0x20,%esp 10a7dc: e9 99 00 00 00 jmp 10a87a return signo; } the_info->si_signo = -1; 10a7e1: c7 03 ff ff ff ff movl $0xffffffff,(%ebx) * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10a7e7: a1 24 04 13 00 mov 0x130424,%eax 10a7ec: 40 inc %eax 10a7ed: a3 24 04 13 00 mov %eax,0x130424 return _Thread_Dispatch_disable_level; 10a7f2: a1 24 04 13 00 mov 0x130424,%eax _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10a7f7: c7 42 44 f4 0a 13 00 movl $0x130af4,0x44(%edx) the_thread->Wait.return_code = EINTR; 10a7fe: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10a805: 8b 7d 08 mov 0x8(%ebp),%edi 10a808: 8b 07 mov (%edi),%eax 10a80a: 89 42 30 mov %eax,0x30(%edx) the_thread->Wait.return_argument = the_info; 10a80d: 89 5a 28 mov %ebx,0x28(%edx) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10a810: c7 05 24 0b 13 00 01 movl $0x1,0x130b24 10a817: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10a81a: ff 75 d4 pushl -0x2c(%ebp) 10a81d: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10a81e: 50 push %eax 10a81f: 68 90 d5 10 00 push $0x10d590 10a824: 51 push %ecx 10a825: 68 f4 0a 13 00 push $0x130af4 10a82a: e8 a9 2a 00 00 call 10d2d8 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10a82f: e8 44 26 00 00 call 10ce78 <_Thread_Enable_dispatch> /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 10a834: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a83b: 6a 00 push $0x0 10a83d: 53 push %ebx 10a83e: ff 33 pushl (%ebx) 10a840: 56 push %esi 10a841: e8 3e 4e 00 00 call 10f684 <_POSIX_signals_Clear_signals> /* Set errno only if return code is not EINTR or * if EINTR was caused by a signal being caught, which * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) 10a846: 83 c4 20 add $0x20,%esp 10a849: a1 2c 09 13 00 mov 0x13092c,%eax 10a84e: 83 78 34 04 cmpl $0x4,0x34(%eax) 10a852: 75 13 jne 10a867 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10a854: 8b 3b mov (%ebx),%edi 10a856: 8d 4f ff lea -0x1(%edi),%ecx 10a859: b8 01 00 00 00 mov $0x1,%eax 10a85e: d3 e0 shl %cl,%eax 10a860: 8b 55 08 mov 0x8(%ebp),%edx 10a863: 85 02 test %eax,(%edx) 10a865: 75 13 jne 10a87a errno = _Thread_Executing->Wait.return_code; 10a867: e8 f4 78 00 00 call 112160 <__errno> 10a86c: 8b 15 2c 09 13 00 mov 0x13092c,%edx 10a872: 8b 52 34 mov 0x34(%edx),%edx 10a875: 89 10 mov %edx,(%eax) return -1; 10a877: 83 cf ff or $0xffffffff,%edi } return the_info->si_signo; } 10a87a: 89 f8 mov %edi,%eax 10a87c: 8d 65 f4 lea -0xc(%ebp),%esp 10a87f: 5b pop %ebx 10a880: 5e pop %esi 10a881: 5f pop %edi 10a882: 5d pop %ebp 10a883: c3 ret =============================================================================== 0010c244 : int sigwait( const sigset_t *set, int *sig ) { 10c244: 55 push %ebp 10c245: 89 e5 mov %esp,%ebp 10c247: 53 push %ebx 10c248: 83 ec 08 sub $0x8,%esp 10c24b: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10c24e: 6a 00 push $0x0 10c250: 6a 00 push $0x0 10c252: ff 75 08 pushl 0x8(%ebp) 10c255: e8 50 fe ff ff call 10c0aa if ( status != -1 ) { 10c25a: 83 c4 10 add $0x10,%esp 10c25d: 83 f8 ff cmp $0xffffffff,%eax 10c260: 74 08 je 10c26a if ( sig ) 10c262: 85 db test %ebx,%ebx 10c264: 74 0d je 10c273 <== NEVER TAKEN *sig = status; 10c266: 89 03 mov %eax,(%ebx) 10c268: eb 09 jmp 10c273 return 0; } return errno; 10c26a: e8 1d 76 00 00 call 11388c <__errno> 10c26f: 8b 00 mov (%eax),%eax 10c271: eb 02 jmp 10c275 status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) *sig = status; return 0; 10c273: 31 c0 xor %eax,%eax } return errno; } 10c275: 8b 5d fc mov -0x4(%ebp),%ebx 10c278: c9 leave 10c279: c3 ret =============================================================================== 00108ddd : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 108ddd: 55 push %ebp 108dde: 89 e5 mov %esp,%ebp 108de0: 56 push %esi 108de1: 53 push %ebx 108de2: 89 d3 mov %edx,%ebx 108de4: 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)) { 108de6: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) 108ded: 75 10 jne 108dff <== 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); 108def: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108df2: 89 da mov %ebx,%edx <== NOT EXECUTED } return i; } 108df4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108df7: 5b pop %ebx <== NOT EXECUTED 108df8: 5e pop %esi <== NOT EXECUTED 108df9: 5d pop %ebp <== 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); 108dfa: e9 70 fe ff ff jmp 108c6f <== 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); 108dff: 50 push %eax 108e00: 6a 00 push $0x0 108e02: 6a 00 push $0x0 108e04: ff 72 18 pushl 0x18(%edx) 108e07: e8 84 0f 00 00 call 109d90 i = iproc (c, tty); 108e0c: 89 f2 mov %esi,%edx 108e0e: 0f b6 c2 movzbl %dl,%eax 108e11: 89 da mov %ebx,%edx 108e13: e8 57 fe ff ff call 108c6f 108e18: 89 c6 mov %eax,%esi rtems_semaphore_release (tty->osem); 108e1a: 58 pop %eax 108e1b: ff 73 18 pushl 0x18(%ebx) 108e1e: e8 5d 10 00 00 call 109e80 108e23: 83 c4 10 add $0x10,%esp } else { i = iproc (c, tty); } return i; } 108e26: 89 f0 mov %esi,%eax 108e28: 8d 65 f8 lea -0x8(%ebp),%esp 108e2b: 5b pop %ebx 108e2c: 5e pop %esi 108e2d: 5d pop %ebp 108e2e: c3 ret =============================================================================== 001088c4 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 1088c4: 55 push %ebp 1088c5: 89 e5 mov %esp,%ebp 1088c7: 53 push %ebx 1088c8: 51 push %ecx 1088c9: 8b 45 08 mov 0x8(%ebp),%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; 1088cc: 8b 88 e0 00 00 00 mov 0xe0(%eax),%ecx if ( this_reent ) { 1088d2: 85 c9 test %ecx,%ecx 1088d4: 74 32 je 108908 <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 1088d6: 8b 15 2c 09 13 00 mov 0x13092c,%edx 1088dc: 8b 9a e0 00 00 00 mov 0xe0(%edx),%ebx _Thread_Executing->libc_reent = this_reent; 1088e2: 89 8a e0 00 00 00 mov %ecx,0xe0(%edx) _fwalk (t->libc_reent, sync_wrapper); 1088e8: 52 push %edx 1088e9: 52 push %edx 1088ea: 68 0d 89 10 00 push $0x10890d 1088ef: ff b0 e0 00 00 00 pushl 0xe0(%eax) 1088f5: e8 56 a0 00 00 call 112950 <_fwalk> _Thread_Executing->libc_reent = current_reent; 1088fa: a1 2c 09 13 00 mov 0x13092c,%eax 1088ff: 89 98 e0 00 00 00 mov %ebx,0xe0(%eax) 108905: 83 c4 10 add $0x10,%esp } } 108908: 8b 5d fc mov -0x4(%ebp),%ebx 10890b: c9 leave 10890c: c3 ret =============================================================================== 00109808 : */ long sysconf( int name ) { 109808: 55 push %ebp 109809: 89 e5 mov %esp,%ebp 10980b: 83 ec 08 sub $0x8,%esp 10980e: 8b 55 08 mov 0x8(%ebp),%edx if ( name == _SC_CLK_TCK ) 109811: 83 fa 02 cmp $0x2,%edx 109814: 75 0f jne 109825 return (TOD_MICROSECONDS_PER_SECOND / 109816: b8 40 42 0f 00 mov $0xf4240,%eax 10981b: 31 d2 xor %edx,%edx 10981d: f7 35 4c a1 12 00 divl 0x12a14c 109823: eb 34 jmp 109859 rtems_configuration_get_microseconds_per_tick()); if ( name == _SC_OPEN_MAX ) return rtems_libio_number_iops; 109825: a1 94 a2 12 00 mov 0x12a294,%eax { if ( name == _SC_CLK_TCK ) return (TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick()); if ( name == _SC_OPEN_MAX ) 10982a: 83 fa 04 cmp $0x4,%edx 10982d: 74 2a je 109859 return rtems_libio_number_iops; if ( name == _SC_GETPW_R_SIZE_MAX ) return 1024; 10982f: b8 00 04 00 00 mov $0x400,%eax rtems_configuration_get_microseconds_per_tick()); if ( name == _SC_OPEN_MAX ) return rtems_libio_number_iops; if ( name == _SC_GETPW_R_SIZE_MAX ) 109834: 83 fa 33 cmp $0x33,%edx 109837: 74 20 je 109859 return 1024; if ( name == _SC_PAGESIZE ) return PAGE_SIZE; 109839: 66 b8 00 10 mov $0x1000,%ax return rtems_libio_number_iops; if ( name == _SC_GETPW_R_SIZE_MAX ) return 1024; if ( name == _SC_PAGESIZE ) 10983d: 83 fa 08 cmp $0x8,%edx 109840: 74 17 je 109859 return PAGE_SIZE; if ( name == _SC_SYMLOOP_MAX ) return RTEMS_FILESYSTEM_SYMLOOP_MAX; 109842: 66 b8 20 00 mov $0x20,%ax return 1024; if ( name == _SC_PAGESIZE ) return PAGE_SIZE; if ( name == _SC_SYMLOOP_MAX ) 109846: 83 fa 4f cmp $0x4f,%edx 109849: 74 0e je 109859 <== NEVER TAKEN #if defined(__sparc__) if ( name == 515 ) /* Solaris _SC_STACK_PROT */ return 0; #endif rtems_set_errno_and_return_minus_one( EINVAL ); 10984b: e8 5c 79 00 00 call 1111ac <__errno> 109850: c7 00 16 00 00 00 movl $0x16,(%eax) 109856: 83 c8 ff or $0xffffffff,%eax } 109859: c9 leave 10985a: c3 ret =============================================================================== 00113240 : int tcsetattr( int fd, int opt, struct termios *tp ) { 113240: 55 push %ebp 113241: 89 e5 mov %esp,%ebp 113243: 56 push %esi 113244: 53 push %ebx 113245: 8b 5d 08 mov 0x8(%ebp),%ebx 113248: 8b 45 0c mov 0xc(%ebp),%eax 11324b: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 11324e: 85 c0 test %eax,%eax 113250: 74 22 je 113274 113252: 48 dec %eax 113253: 74 0d je 113262 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 113255: e8 3a 3a 00 00 call 116c94 <__errno> 11325a: c7 00 86 00 00 00 movl $0x86,(%eax) 113260: eb 2a jmp 11328c case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 113262: 50 push %eax 113263: 6a 00 push $0x0 113265: 6a 03 push $0x3 113267: 53 push %ebx 113268: e8 37 f9 ff ff call 112ba4 11326d: 83 c4 10 add $0x10,%esp 113270: 85 c0 test %eax,%eax 113272: 78 18 js 11328c <== NEVER TAKEN return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 113274: 89 75 10 mov %esi,0x10(%ebp) 113277: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 11327e: 89 5d 08 mov %ebx,0x8(%ebp) } } 113281: 8d 65 f8 lea -0x8(%ebp),%esp 113284: 5b pop %ebx 113285: 5e pop %esi 113286: 5d pop %ebp return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 113287: e9 18 f9 ff ff jmp 112ba4 } } 11328c: 83 c8 ff or $0xffffffff,%eax 11328f: 8d 65 f8 lea -0x8(%ebp),%esp 113292: 5b pop %ebx 113293: 5e pop %esi 113294: 5d pop %ebp 113295: c3 ret =============================================================================== 0010a9e8 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a9e8: 55 push %ebp 10a9e9: 89 e5 mov %esp,%ebp 10a9eb: 56 push %esi 10a9ec: 53 push %ebx 10a9ed: 8b 5d 0c mov 0xc(%ebp),%ebx 10a9f0: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a9f3: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a9f7: 74 02 je 10a9fb 10a9f9: eb 23 jmp 10aa1e rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a9fb: 85 f6 test %esi,%esi 10a9fd: 75 02 jne 10aa01 10a9ff: eb 1d jmp 10aa1e /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10aa01: 85 db test %ebx,%ebx 10aa03: 74 26 je 10aa2b /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10aa05: 8b 03 mov (%ebx),%eax 10aa07: 48 dec %eax 10aa08: 83 f8 01 cmp $0x1,%eax 10aa0b: 76 02 jbe 10aa0f <== ALWAYS TAKEN 10aa0d: eb 0f jmp 10aa1e <== NOT EXECUTED ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10aa0f: 8b 43 04 mov 0x4(%ebx),%eax 10aa12: 85 c0 test %eax,%eax 10aa14: 75 02 jne 10aa18 <== ALWAYS TAKEN 10aa16: eb 06 jmp 10aa1e <== NOT EXECUTED static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10aa18: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10aa19: 83 f8 1f cmp $0x1f,%eax 10aa1c: 76 0d jbe 10aa2b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10aa1e: e8 75 7e 00 00 call 112898 <__errno> 10aa23: c7 00 16 00 00 00 movl $0x16,(%eax) 10aa29: eb 34 jmp 10aa5f * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10aa2b: a1 b4 31 13 00 mov 0x1331b4,%eax 10aa30: 40 inc %eax 10aa31: a3 b4 31 13 00 mov %eax,0x1331b4 return _Thread_Dispatch_disable_level; 10aa36: a1 b4 31 13 00 mov 0x1331b4,%eax * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 10aa3b: 83 ec 0c sub $0xc,%esp 10aa3e: 68 b8 34 13 00 push $0x1334b8 10aa43: e8 70 1c 00 00 call 10c6b8 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10aa48: 83 c4 10 add $0x10,%esp 10aa4b: 85 c0 test %eax,%eax 10aa4d: 75 18 jne 10aa67 _Thread_Enable_dispatch(); 10aa4f: e8 68 2c 00 00 call 10d6bc <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10aa54: e8 3f 7e 00 00 call 112898 <__errno> 10aa59: c7 00 0b 00 00 00 movl $0xb,(%eax) 10aa5f: 83 c8 ff or $0xffffffff,%eax 10aa62: e9 83 00 00 00 jmp 10aaea } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10aa67: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10aa6b: 8b 15 fc 36 13 00 mov 0x1336fc,%edx 10aa71: 8b 52 08 mov 0x8(%edx),%edx 10aa74: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10aa77: 85 db test %ebx,%ebx 10aa79: 74 11 je 10aa8c ptimer->inf.sigev_notify = evp->sigev_notify; 10aa7b: 8b 13 mov (%ebx),%edx 10aa7d: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10aa80: 8b 53 04 mov 0x4(%ebx),%edx 10aa83: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10aa86: 8b 53 08 mov 0x8(%ebx),%edx 10aa89: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10aa8c: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10aa93: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10aa9a: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10aaa1: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10aaa8: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10aaaf: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10aab6: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10aabd: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10aac4: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10aacb: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10aace: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10aad1: 8b 0d d4 34 13 00 mov 0x1334d4,%ecx 10aad7: 89 04 99 mov %eax,(%ecx,%ebx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10aada: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10aae1: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10aae3: e8 d4 2b 00 00 call 10d6bc <_Thread_Enable_dispatch> return 0; 10aae8: 31 c0 xor %eax,%eax } 10aaea: 8d 65 f8 lea -0x8(%ebp),%esp 10aaed: 5b pop %ebx 10aaee: 5e pop %esi 10aaef: 5d pop %ebp 10aaf0: c3 ret =============================================================================== 001099d0 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 1099d0: 55 push %ebp 1099d1: 89 e5 mov %esp,%ebp 1099d3: 57 push %edi 1099d4: 56 push %esi 1099d5: 53 push %ebx 1099d6: 83 ec 3c sub $0x3c,%esp 1099d9: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 1099dc: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1099e0: 75 05 jne 1099e7 <== ALWAYS TAKEN 1099e2: e9 ba 01 00 00 jmp 109ba1 <== NOT EXECUTED /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 1099e7: 83 ec 0c sub $0xc,%esp 1099ea: 8b 45 10 mov 0x10(%ebp),%eax 1099ed: 83 c0 08 add $0x8,%eax 1099f0: 50 push %eax 1099f1: e8 06 32 00 00 call 10cbfc <_Timespec_Is_valid> 1099f6: 83 c4 10 add $0x10,%esp 1099f9: 84 c0 test %al,%al 1099fb: 75 05 jne 109a02 1099fd: e9 9f 01 00 00 jmp 109ba1 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 109a02: 83 ec 0c sub $0xc,%esp 109a05: ff 75 10 pushl 0x10(%ebp) 109a08: e8 ef 31 00 00 call 10cbfc <_Timespec_Is_valid> 109a0d: 83 c4 10 add $0x10,%esp 109a10: 84 c0 test %al,%al 109a12: 75 05 jne 109a19 <== ALWAYS TAKEN 109a14: e9 88 01 00 00 jmp 109ba1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 109a19: f7 c3 fb ff ff ff test $0xfffffffb,%ebx 109a1f: 74 05 je 109a26 109a21: e9 7b 01 00 00 jmp 109ba1 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 109a26: 8d 7d d8 lea -0x28(%ebp),%edi 109a29: b9 04 00 00 00 mov $0x4,%ecx 109a2e: 8b 75 10 mov 0x10(%ebp),%esi 109a31: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 109a33: 83 fb 04 cmp $0x4,%ebx 109a36: 75 5f jne 109a97 struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 109a38: 83 ec 0c sub $0xc,%esp 109a3b: 8d 45 c8 lea -0x38(%ebp),%eax 109a3e: 50 push %eax 109a3f: e8 18 15 00 00 call 10af5c <_TOD_Get_as_timestamp> _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 109a44: 8b 75 c8 mov -0x38(%ebp),%esi 109a47: 8b 7d cc mov -0x34(%ebp),%edi static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 109a4a: 6a 00 push $0x0 109a4c: 68 00 ca 9a 3b push $0x3b9aca00 109a51: 57 push %edi 109a52: 56 push %esi 109a53: e8 8c 41 01 00 call 11dbe4 <__divdi3> 109a58: 83 c4 10 add $0x10,%esp 109a5b: 89 45 d0 mov %eax,-0x30(%ebp) _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 109a5e: 6a 00 push $0x0 109a60: 68 00 ca 9a 3b push $0x3b9aca00 109a65: 57 push %edi 109a66: 56 push %esi 109a67: e8 cc 42 01 00 call 11dd38 <__moddi3> 109a6c: 89 45 d4 mov %eax,-0x2c(%ebp) struct timespec now; _TOD_Get( &now ); /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 109a6f: 83 c4 18 add $0x18,%esp 109a72: 8d 75 d0 lea -0x30(%ebp),%esi 109a75: 56 push %esi 109a76: 8d 5d e0 lea -0x20(%ebp),%ebx 109a79: 53 push %ebx 109a7a: e8 a1 31 00 00 call 10cc20 <_Timespec_Less_than> 109a7f: 83 c4 10 add $0x10,%esp 109a82: 84 c0 test %al,%al 109a84: 74 05 je 109a8b 109a86: e9 16 01 00 00 jmp 109ba1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 109a8b: 52 push %edx 109a8c: 53 push %ebx 109a8d: 53 push %ebx 109a8e: 56 push %esi 109a8f: e8 b0 31 00 00 call 10cc44 <_Timespec_Subtract> 109a94: 83 c4 10 add $0x10,%esp RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get ( timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) 109a97: 50 push %eax /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 109a98: 8d 45 c4 lea -0x3c(%ebp),%eax 109a9b: 50 push %eax 109a9c: ff 75 08 pushl 0x8(%ebp) 109a9f: 68 b8 e6 12 00 push $0x12e6b8 109aa4: e8 3f 1d 00 00 call 10b7e8 <_Objects_Get> 109aa9: 89 c3 mov %eax,%ebx switch ( location ) { 109aab: 83 c4 10 add $0x10,%esp 109aae: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 109ab2: 0f 85 e9 00 00 00 jne 109ba1 case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 109ab8: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 109abc: 75 3c jne 109afa 109abe: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 109ac2: 75 36 jne 109afa /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 109ac4: 83 ec 0c sub $0xc,%esp 109ac7: 8d 40 10 lea 0x10(%eax),%eax 109aca: 50 push %eax 109acb: e8 10 35 00 00 call 10cfe0 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 109ad0: 83 c4 10 add $0x10,%esp 109ad3: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 109ad7: 8d 43 54 lea 0x54(%ebx),%eax 109ada: 74 0c je 109ae8 *ovalue = ptimer->timer_data; 109adc: b9 04 00 00 00 mov $0x4,%ecx 109ae1: 8b 7d 14 mov 0x14(%ebp),%edi 109ae4: 89 c6 mov %eax,%esi 109ae6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 109ae8: 8d 75 d8 lea -0x28(%ebp),%esi 109aeb: b9 04 00 00 00 mov $0x4,%ecx 109af0: 89 c7 mov %eax,%edi 109af2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 109af4: c6 43 3c 04 movb $0x4,0x3c(%ebx) 109af8: eb 35 jmp 109b2f _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 109afa: 83 ec 0c sub $0xc,%esp 109afd: ff 75 10 pushl 0x10(%ebp) 109b00: e8 77 31 00 00 call 10cc7c <_Timespec_To_ticks> 109b05: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 109b08: 8d 45 e0 lea -0x20(%ebp),%eax 109b0b: 89 04 24 mov %eax,(%esp) 109b0e: e8 69 31 00 00 call 10cc7c <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 109b13: 89 1c 24 mov %ebx,(%esp) 109b16: 68 b8 9b 10 00 push $0x109bb8 109b1b: ff 73 08 pushl 0x8(%ebx) 109b1e: 50 push %eax 109b1f: 8d 43 10 lea 0x10(%ebx),%eax 109b22: 50 push %eax 109b23: e8 28 52 00 00 call 10ed50 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 109b28: 83 c4 20 add $0x20,%esp 109b2b: 84 c0 test %al,%al 109b2d: 75 07 jne 109b36 _Thread_Enable_dispatch(); 109b2f: e8 e8 27 00 00 call 10c31c <_Thread_Enable_dispatch> 109b34: eb 67 jmp 109b9d /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 109b36: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 109b3a: 8d 43 54 lea 0x54(%ebx),%eax 109b3d: 74 0c je 109b4b *ovalue = ptimer->timer_data; 109b3f: b9 04 00 00 00 mov $0x4,%ecx 109b44: 8b 7d 14 mov 0x14(%ebp),%edi 109b47: 89 c6 mov %eax,%esi 109b49: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 109b4b: 8d 75 d8 lea -0x28(%ebp),%esi 109b4e: b9 04 00 00 00 mov $0x4,%ecx 109b53: 89 c7 mov %eax,%edi 109b55: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 109b57: c6 43 3c 03 movb $0x3,0x3c(%ebx) struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 109b5b: 83 ec 0c sub $0xc,%esp 109b5e: 8d 45 c8 lea -0x38(%ebp),%eax 109b61: 50 push %eax 109b62: e8 f5 13 00 00 call 10af5c <_TOD_Get_as_timestamp> _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 109b67: 8b 75 c8 mov -0x38(%ebp),%esi 109b6a: 8b 7d cc mov -0x34(%ebp),%edi static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 109b6d: 6a 00 push $0x0 109b6f: 68 00 ca 9a 3b push $0x3b9aca00 109b74: 57 push %edi 109b75: 56 push %esi 109b76: e8 69 40 01 00 call 11dbe4 <__divdi3> 109b7b: 83 c4 10 add $0x10,%esp 109b7e: 89 43 6c mov %eax,0x6c(%ebx) _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 109b81: 6a 00 push $0x0 109b83: 68 00 ca 9a 3b push $0x3b9aca00 109b88: 57 push %edi 109b89: 56 push %esi 109b8a: e8 a9 41 01 00 call 11dd38 <__moddi3> 109b8f: 83 c4 10 add $0x10,%esp 109b92: 89 43 70 mov %eax,0x70(%ebx) _TOD_Get( &ptimer->time ); _Thread_Enable_dispatch(); 109b95: e8 82 27 00 00 call 10c31c <_Thread_Enable_dispatch> 109b9a: 83 c4 10 add $0x10,%esp return 0; 109b9d: 31 c0 xor %eax,%eax 109b9f: eb 0e jmp 109baf #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 109ba1: e8 c6 7a 00 00 call 11166c <__errno> 109ba6: c7 00 16 00 00 00 movl $0x16,(%eax) 109bac: 83 c8 ff or $0xffffffff,%eax } 109baf: 8d 65 f4 lea -0xc(%ebp),%esp 109bb2: 5b pop %ebx 109bb3: 5e pop %esi 109bb4: 5f pop %edi 109bb5: 5d pop %ebp 109bb6: c3 ret =============================================================================== 00109aa8 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109aa8: 55 push %ebp 109aa9: 89 e5 mov %esp,%ebp 109aab: 56 push %esi 109aac: 53 push %ebx 109aad: 83 ec 10 sub $0x10,%esp /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109ab0: 83 3d 0c fd 12 00 00 cmpl $0x0,0x12fd0c 109ab7: 75 2c jne 109ae5 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109ab9: c7 05 f8 fc 12 00 00 movl $0x0,0x12fcf8 109ac0: 00 00 00 the_watchdog->routine = routine; 109ac3: c7 05 0c fd 12 00 70 movl $0x109a70,0x12fd0c 109aca: 9a 10 00 the_watchdog->id = id; 109acd: c7 05 10 fd 12 00 00 movl $0x0,0x12fd10 109ad4: 00 00 00 the_watchdog->user_data = user_data; 109ad7: c7 05 14 fd 12 00 00 movl $0x0,0x12fd14 109ade: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109ae1: 31 db xor %ebx,%ebx 109ae3: eb 4f jmp 109b34 if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 109ae5: 83 ec 0c sub $0xc,%esp 109ae8: 68 f0 fc 12 00 push $0x12fcf0 109aed: e8 12 33 00 00 call 10ce04 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109af2: 83 e8 02 sub $0x2,%eax 109af5: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109af8: 31 db xor %ebx,%ebx _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109afa: 83 f8 01 cmp $0x1,%eax 109afd: 77 35 ja 109b34 <== NEVER TAKEN * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109aff: 8b 0d 04 fd 12 00 mov 0x12fd04,%ecx 109b05: 03 0d fc fc 12 00 add 0x12fcfc,%ecx /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109b0b: 50 push %eax 109b0c: 50 push %eax 109b0d: 8d 45 f0 lea -0x10(%ebp),%eax 109b10: 50 push %eax * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109b11: 2b 0d 08 fd 12 00 sub 0x12fd08,%ecx /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109b17: 51 push %ecx 109b18: e8 f3 2e 00 00 call 10ca10 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 109b1d: 69 5d f0 40 42 0f 00 imul $0xf4240,-0x10(%ebp),%ebx remaining += tp.tv_nsec / 1000; 109b24: 8b 45 f4 mov -0xc(%ebp),%eax 109b27: b9 e8 03 00 00 mov $0x3e8,%ecx 109b2c: 99 cltd 109b2d: f7 f9 idiv %ecx 109b2f: 01 c3 add %eax,%ebx 109b31: 83 c4 10 add $0x10,%esp /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 109b34: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 109b38: 74 45 je 109b7f Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 109b3a: b9 40 42 0f 00 mov $0xf4240,%ecx 109b3f: 8b 45 08 mov 0x8(%ebp),%eax 109b42: 31 d2 xor %edx,%edx 109b44: f7 f1 div %ecx 109b46: 89 45 f0 mov %eax,-0x10(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 109b49: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 109b4f: 89 55 f4 mov %edx,-0xc(%ebp) ticks = _Timespec_To_ticks( &tp ); 109b52: 83 ec 0c sub $0xc,%esp 109b55: 8d 75 f0 lea -0x10(%ebp),%esi 109b58: 56 push %esi 109b59: e8 da 2e 00 00 call 10ca38 <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 109b5e: 89 34 24 mov %esi,(%esp) 109b61: e8 d2 2e 00 00 call 10ca38 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 109b66: a3 fc fc 12 00 mov %eax,0x12fcfc _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 109b6b: 59 pop %ecx 109b6c: 5e pop %esi 109b6d: 68 f0 fc 12 00 push $0x12fcf0 109b72: 68 d8 f4 12 00 push $0x12f4d8 109b77: e8 74 31 00 00 call 10ccf0 <_Watchdog_Insert> 109b7c: 83 c4 10 add $0x10,%esp } return remaining; } 109b7f: 89 d8 mov %ebx,%eax 109b81: 8d 65 f8 lea -0x8(%ebp),%esp 109b84: 5b pop %ebx 109b85: 5e pop %esi 109b86: 5d pop %ebp 109b87: c3 ret =============================================================================== 0010981c : return mt_entry == root->mt_entry || mt_entry == current->mt_entry; } int unmount( const char *path ) { 10981c: 55 push %ebp 10981d: 89 e5 mov %esp,%ebp 10981f: 56 push %esi 109820: 53 push %ebx 109821: 83 ec 44 sub $0x44,%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 = 109824: 6a 18 push $0x18 109826: ff 75 08 pushl 0x8(%ebp) rtems_filesystem_eval_path_start( &ctx, path, eval_flags ); 109829: 8d 45 c0 lea -0x40(%ebp),%eax 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 = 10982c: 50 push %eax 10982d: e8 a3 e2 ff ff call 107ad5 rtems_filesystem_eval_path_start( &ctx, path, eval_flags ); rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry; 109832: 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)( 109835: 5a pop %edx 109836: 59 pop %ecx 109837: 8b 53 0c mov 0xc(%ebx),%edx 10983a: ff 73 24 pushl 0x24(%ebx) 10983d: 50 push %eax 10983e: ff 52 10 call *0x10(%edx) if ( rtems_filesystem_location_is_root( currentloc ) ) { 109841: 83 c4 10 add $0x10,%esp 109844: 84 c0 test %al,%al 109846: 74 5b je 1098a3 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; 109848: a1 14 c1 12 00 mov 0x12c114,%eax const rtems_filesystem_location_info_t *current = &rtems_filesystem_current->location; 10984d: 8b 10 mov (%eax),%edx return mt_entry == root->mt_entry || mt_entry == current->mt_entry; 10984f: 8b 40 04 mov 0x4(%eax),%eax 109852: 3b 58 14 cmp 0x14(%eax),%ebx 109855: 74 0a je 109861 109857: 31 c0 xor %eax,%eax 109859: 3b 5a 14 cmp 0x14(%edx),%ebx 10985c: 0f 94 c0 sete %al 10985f: eb 05 jmp 109866 109861: b8 01 00 00 00 mov $0x1,%eax const rtems_filesystem_location_info_t *currentloc = rtems_filesystem_eval_path_start( &ctx, path, eval_flags ); 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 ) ) { 109866: 85 c0 test %eax,%eax 109868: 75 2c jne 109896 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 ); 10986a: 83 ec 0c sub $0xc,%esp 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; 10986d: 8b 43 20 mov 0x20(%ebx),%eax 109870: 8b 40 14 mov 0x14(%eax),%eax rv = (*mt_point_ops->unmount_h)( mt_entry ); 109873: 8b 40 0c mov 0xc(%eax),%eax 109876: 53 push %ebx 109877: ff 50 38 call *0x38(%eax) 10987a: 89 c6 mov %eax,%esi if ( rv == 0 ) { 10987c: 83 c4 10 add $0x10,%esp 10987f: 85 c0 test %eax,%eax 109881: 75 2e jne 1098b1 rtems_id self_task_id = rtems_task_self(); 109883: e8 80 0c 00 00 call 10a508 rtems_filesystem_mt_entry_declare_lock_context( lock_context ); rtems_filesystem_mt_entry_lock( lock_context ); 109888: 9c pushf 109889: fa cli 10988a: 5a pop %edx mt_entry->unmount_task = self_task_id; 10988b: 89 43 3c mov %eax,0x3c(%ebx) mt_entry->mounted = false; 10988e: c6 43 28 00 movb $0x0,0x28(%ebx) rtems_filesystem_mt_entry_unlock( lock_context ); 109892: 52 push %edx 109893: 9d popf 109894: eb 1b jmp 1098b1 } } else { errno = EBUSY; 109896: e8 c9 79 00 00 call 111264 <__errno> 10989b: c7 00 10 00 00 00 movl $0x10,(%eax) 1098a1: eb 0b jmp 1098ae rv = -1; } } else { errno = EACCES; 1098a3: e8 bc 79 00 00 call 111264 <__errno> 1098a8: c7 00 0d 00 00 00 movl $0xd,(%eax) rv = -1; 1098ae: 83 ce ff or $0xffffffff,%esi } rtems_filesystem_eval_path_cleanup( &ctx ); 1098b1: 83 ec 0c sub $0xc,%esp 1098b4: 8d 45 c0 lea -0x40(%ebp),%eax 1098b7: 50 push %eax 1098b8: e8 d4 e2 ff ff call 107b91 if ( rv == 0 ) { 1098bd: 83 c4 10 add $0x10,%esp 1098c0: 85 f6 test %esi,%esi 1098c2: 75 23 jne 1098e7 rtems_event_set out; rtems_status_code sc = rtems_event_receive( 1098c4: 8d 45 bc lea -0x44(%ebp),%eax 1098c7: 50 push %eax 1098c8: 6a 00 push $0x0 1098ca: 6a 00 push $0x0 1098cc: 6a 02 push $0x2 1098ce: e8 4d 03 00 00 call 109c20 RTEMS_EVENT_ALL | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &out ); if ( sc != RTEMS_SUCCESSFUL ) { 1098d3: 83 c4 10 add $0x10,%esp 1098d6: 85 c0 test %eax,%eax 1098d8: 74 0d je 1098e7 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xdeadbeef ); 1098da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098dd: 68 ef be ad de push $0xdeadbeef <== NOT EXECUTED 1098e2: e8 59 0e 00 00 call 10a740 <== NOT EXECUTED } } return rv; } 1098e7: 89 f0 mov %esi,%eax 1098e9: 8d 65 f8 lea -0x8(%ebp),%esp 1098ec: 5b pop %ebx 1098ed: 5e pop %esi 1098ee: 5d pop %ebp 1098ef: c3 ret =============================================================================== 0011d920 : ssize_t write( int fd, const void *buffer, size_t count ) { 11d920: 55 push %ebp 11d921: 89 e5 mov %esp,%ebp 11d923: 53 push %ebx 11d924: 53 push %ebx 11d925: 8b 45 08 mov 0x8(%ebp),%eax 11d928: 8b 55 0c mov 0xc(%ebp),%edx 11d92b: 8b 4d 10 mov 0x10(%ebp),%ecx rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11d92e: 3b 05 70 a2 12 00 cmp 0x12a270,%eax 11d934: 72 02 jb 11d938 11d936: eb 2d jmp 11d965 iop = rtems_libio_iop( fd ); 11d938: 6b c0 30 imul $0x30,%eax,%eax 11d93b: 03 05 d0 e2 12 00 add 0x12e2d0,%eax rtems_libio_check_is_open( iop ); 11d941: 8b 58 0c mov 0xc(%eax),%ebx 11d944: f6 c7 01 test $0x1,%bh 11d947: 75 02 jne 11d94b 11d949: eb 1a jmp 11d965 rtems_libio_check_buffer( buffer ); 11d94b: 85 d2 test %edx,%edx 11d94d: 75 0d jne 11d95c <== ALWAYS TAKEN 11d94f: e8 88 35 ff ff call 110edc <__errno> <== NOT EXECUTED 11d954: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11d95a: eb 14 jmp 11d970 <== NOT EXECUTED rtems_libio_check_count( count ); 11d95c: 85 c9 test %ecx,%ecx 11d95e: 74 29 je 11d989 rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 11d960: 80 e3 04 and $0x4,%bl 11d963: 75 10 jne 11d975 11d965: e8 72 35 ff ff call 110edc <__errno> 11d96a: c7 00 09 00 00 00 movl $0x9,(%eax) 11d970: 83 c8 ff or $0xffffffff,%eax 11d973: eb 16 jmp 11d98b /* * Now process the write() request. */ return (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); 11d975: 8b 58 20 mov 0x20(%eax),%ebx 11d978: 89 4d 10 mov %ecx,0x10(%ebp) 11d97b: 89 55 0c mov %edx,0xc(%ebp) 11d97e: 89 45 08 mov %eax,0x8(%ebp) 11d981: 8b 43 0c mov 0xc(%ebx),%eax } 11d984: 59 pop %ecx 11d985: 5b pop %ebx 11d986: 5d pop %ebp 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 ); 11d987: ff e0 jmp *%eax 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 ); 11d989: 31 c0 xor %eax,%eax /* * Now process the write() request. */ return (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); } 11d98b: 5a pop %edx 11d98c: 5b pop %ebx 11d98d: 5d pop %ebp 11d98e: c3 ret =============================================================================== 0010a278 : ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) { 10a278: 55 push %ebp 10a279: 89 e5 mov %esp,%ebp 10a27b: 57 push %edi 10a27c: 56 push %esi 10a27d: 53 push %ebx 10a27e: 83 ec 1c sub $0x1c,%esp 10a281: 8b 75 08 mov 0x8(%ebp),%esi 10a284: 8b 5d 0c mov 0xc(%ebp),%ebx 10a287: 8b 45 10 mov 0x10(%ebp),%eax int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd ); 10a28a: 3b 35 70 a2 12 00 cmp 0x12a270,%esi 10a290: 72 02 jb 10a294 10a292: eb 18 jmp 10a2ac iop = rtems_libio_iop( fd ); 10a294: 6b f6 30 imul $0x30,%esi,%esi 10a297: 03 35 d0 e2 12 00 add 0x12e2d0,%esi rtems_libio_check_is_open( iop ); 10a29d: 8b 56 0c mov 0xc(%esi),%edx 10a2a0: f6 c6 01 test $0x1,%dh 10a2a3: 75 02 jne 10a2a7 10a2a5: eb 05 jmp 10a2ac rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 10a2a7: 80 e2 04 and $0x4,%dl 10a2aa: 75 10 jne 10a2bc <== ALWAYS TAKEN 10a2ac: e8 23 75 00 00 call 1117d4 <__errno> 10a2b1: c7 00 09 00 00 00 movl $0x9,(%eax) 10a2b7: e9 95 00 00 00 jmp 10a351 /* * Argument validation on IO vector */ if ( !iov ) 10a2bc: 85 db test %ebx,%ebx 10a2be: 75 02 jne 10a2c2 10a2c0: eb 3f jmp 10a301 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10a2c2: 85 c0 test %eax,%eax 10a2c4: 7f 02 jg 10a2c8 10a2c6: eb 39 jmp 10a301 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 10a2c8: 3d 00 04 00 00 cmp $0x400,%eax 10a2cd: 7e 02 jle 10a2d1 <== ALWAYS TAKEN 10a2cf: eb 30 jmp 10a301 <== NOT EXECUTED #include #include #include ssize_t writev( 10a2d1: 8d 04 c3 lea (%ebx,%eax,8),%eax 10a2d4: 89 45 e4 mov %eax,-0x1c(%ebp) 10a2d7: 89 d8 mov %ebx,%eax 10a2d9: bf 01 00 00 00 mov $0x1,%edi 10a2de: 31 c9 xor %ecx,%ecx 10a2e0: eb 02 jmp 10a2e4 if ( iov[v].iov_len ) all_zeros = false; /* check for wrap */ old = total; total += iov[v].iov_len; 10a2e2: 89 d1 mov %edx,%ecx /* * 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 ) 10a2e4: 83 38 00 cmpl $0x0,(%eax) 10a2e7: 75 02 jne 10a2eb 10a2e9: eb 16 jmp 10a301 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) all_zeros = false; 10a2eb: 83 78 04 00 cmpl $0x0,0x4(%eax) 10a2ef: 0f 94 c2 sete %dl 10a2f2: f7 da neg %edx 10a2f4: 21 d7 and %edx,%edi /* check for wrap */ old = total; total += iov[v].iov_len; if ( total < old || total > SSIZE_MAX ) 10a2f6: 8b 50 04 mov 0x4(%eax),%edx 10a2f9: 01 ca add %ecx,%edx 10a2fb: 78 04 js 10a301 10a2fd: 39 ca cmp %ecx,%edx 10a2ff: 7d 0d jge 10a30e rtems_set_errno_and_return_minus_one( EINVAL ); 10a301: e8 ce 74 00 00 call 1117d4 <__errno> 10a306: c7 00 16 00 00 00 movl $0x16,(%eax) 10a30c: eb 43 jmp 10a351 10a30e: 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++ ) { 10a311: 3b 45 e4 cmp -0x1c(%ebp),%eax 10a314: 75 cc jne 10a2e2 /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { return 0; 10a316: 31 d2 xor %edx,%edx } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10a318: 89 f8 mov %edi,%eax 10a31a: 84 c0 test %al,%al 10a31c: 75 36 jne 10a354 /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { /* all zero lengths has no effect */ if ( iov[v].iov_len == 0 ) 10a31e: 8b 43 04 mov 0x4(%ebx),%eax 10a321: 85 c0 test %eax,%eax 10a323: 74 22 je 10a347 <== NEVER TAKEN continue; bytes = (*iop->pathinfo.handlers->write_h)( 10a325: 51 push %ecx 10a326: 8b 4e 20 mov 0x20(%esi),%ecx 10a329: 50 push %eax 10a32a: ff 33 pushl (%ebx) 10a32c: 56 push %esi 10a32d: 89 55 e0 mov %edx,-0x20(%ebp) 10a330: ff 51 0c call *0xc(%ecx) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 10a333: 83 c4 10 add $0x10,%esp 10a336: 83 f8 00 cmp $0x0,%eax 10a339: 8b 55 e0 mov -0x20(%ebp),%edx 10a33c: 7c 13 jl 10a351 <== NEVER TAKEN return -1; if ( bytes > 0 ) { 10a33e: 74 02 je 10a342 <== NEVER TAKEN total += bytes; 10a340: 01 c2 add %eax,%edx } if (bytes != iov[ v ].iov_len) 10a342: 3b 43 04 cmp 0x4(%ebx),%eax 10a345: 75 0d jne 10a354 <== NEVER TAKEN 10a347: 83 c3 08 add $0x8,%ebx } /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10a34a: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10a34d: 75 cf jne 10a31e 10a34f: eb 03 jmp 10a354 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 10a351: 83 ca ff or $0xffffffff,%edx if (bytes != iov[ v ].iov_len) break; } return total; } 10a354: 89 d0 mov %edx,%eax 10a356: 8d 65 f4 lea -0xc(%ebp),%esp 10a359: 5b pop %ebx 10a35a: 5e pop %esi 10a35b: 5f pop %edi 10a35c: 5d pop %ebp 10a35d: c3 ret