=============================================================================== 001052f0 <_POSIX_Condition_variables_Wait_support>: int _POSIX_Condition_variables_Wait_support( pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime ) { 1052f0: 55 push %ebp 1052f1: 89 e5 mov %esp,%ebp 1052f3: 83 ec 58 sub $0x58,%esp 1052f6: 89 5d f4 mov %ebx,-0xc(%ebp) 1052f9: 8b 5d 08 mov 0x8(%ebp),%ebx 1052fc: 89 75 f8 mov %esi,-0x8(%ebp) 1052ff: 8b 75 0c mov 0xc(%ebp),%esi 105302: 89 7d fc mov %edi,-0x4(%ebp) Thread_queue_Context queue_context; int error; Thread_Control *executing; the_cond = _POSIX_Condition_variables_Get( cond ); POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags ); 105305: 85 db test %ebx,%ebx 105307: 0f 84 b8 00 00 00 je 1053c5 <_POSIX_Condition_variables_Wait_support+0xd5> 10530d: 8b 3b mov (%ebx),%edi 10530f: 89 d8 mov %ebx,%eax 105311: 31 f8 xor %edi,%eax 105313: 35 fe b1 df 18 xor $0x18dfb1fe,%eax 105318: 83 e0 fe and $0xfffffffe,%eax 10531b: 0f 85 bf 00 00 00 jne 1053e0 <_POSIX_Condition_variables_Wait_support+0xf0> _Thread_queue_Context_initialize( &queue_context ); if ( abstime != NULL ) { 105321: 8b 55 10 mov 0x10(%ebp),%edx 105324: 85 d2 test %edx,%edx 105326: 0f 84 cb 00 00 00 je 1053f7 <_POSIX_Condition_variables_Wait_support+0x107> queue_context->Timeout.arg = arg; 10532c: 8b 45 10 mov 0x10(%ebp),%eax if ( ( flags & POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC ) != 0 ) { 10532f: 83 e7 01 and $0x1,%edi 105332: 89 45 d0 mov %eax,-0x30(%ebp) 105335: 0f 85 d5 00 00 00 jne 105410 <_POSIX_Condition_variables_Wait_support+0x120><== NEVER TAKEN queue_context->enqueue_callout = enqueue_callout; 10533b: c7 45 cc c0 51 10 00 movl $0x1051c0,-0x34(%ebp) _Thread_queue_Context_ISR_disable( queue_context, level ); 105342: 9c pushf 105343: fa cli 105344: 58 pop %eax 105345: 89 45 c4 mov %eax,-0x3c(%ebp) } executing = _POSIX_Condition_variables_Acquire( the_cond, &queue_context ); if ( the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX 105348: 8b 43 18 mov 0x18(%ebx),%eax && the_cond->mutex != mutex 10534b: 39 f0 cmp %esi,%eax 10534d: 74 21 je 105370 <_POSIX_Condition_variables_Wait_support+0x80> 10534f: 85 c0 test %eax,%eax 105351: 74 1d je 105370 <_POSIX_Condition_variables_Wait_support+0x80> _ISR_lock_ISR_enable( lock_context ); 105353: ff 75 c4 push -0x3c(%ebp) 105356: 9d popf ) { _POSIX_Condition_variables_Release( the_cond, &queue_context ); return EINVAL; 105357: bb 16 00 00 00 mov $0x16,%ebx error = EINVAL; } } return error; } 10535c: 8b 75 f8 mov -0x8(%ebp),%esi 10535f: 89 d8 mov %ebx,%eax 105361: 8b 5d f4 mov -0xc(%ebp),%ebx 105364: 8b 7d fc mov -0x4(%ebp),%edi 105367: 89 ec mov %ebp,%esp 105369: 5d pop %ebp 10536a: c3 ret 10536b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10536f: 90 nop static inline struct _Thread_Control *_Per_CPU_Get_executing( const Per_CPU_Control *cpu ) { return cpu->executing; 105370: 8b 3d b8 c1 12 00 mov 0x12c1b8,%edi _Thread_queue_Enqueue( 105376: 8d 45 c4 lea -0x3c(%ebp),%eax 105379: 83 c3 0c add $0xc,%ebx the_cond->mutex = mutex; 10537c: 89 73 0c mov %esi,0xc(%ebx) _Thread_queue_Enqueue( 10537f: 89 44 24 0c mov %eax,0xc(%esp) 105383: b8 90 2d 12 00 mov $0x122d90,%eax 105388: 89 44 24 04 mov %eax,0x4(%esp) 10538c: 89 1c 24 mov %ebx,(%esp) 10538f: 89 7c 24 08 mov %edi,0x8(%esp) queue_context->thread_state = thread_state; 105393: c7 45 c8 20 00 00 00 movl $0x20,-0x38(%ebp) 10539a: e8 81 3a 00 00 call 108e20 <_Thread_queue_Enqueue> return _POSIX_Get_by_name_error_table[ error ]; } RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status ) { return STATUS_GET_POSIX( status ); 10539f: 8b 57 4c mov 0x4c(%edi),%edx 1053a2: 89 d0 mov %edx,%eax 1053a4: c1 f8 1f sar $0x1f,%eax 1053a7: 0f b6 d8 movzbl %al,%ebx 1053aa: 01 d3 add %edx,%ebx 1053ac: c1 fb 08 sar $0x8,%ebx if ( error == EINTR ) { 1053af: 83 fb 04 cmp $0x4,%ebx 1053b2: 74 6c je 105420 <_POSIX_Condition_variables_Wait_support+0x130><== NEVER TAKEN if ( error != EPERM ) { 1053b4: 83 fb 01 cmp $0x1,%ebx 1053b7: 74 a3 je 10535c <_POSIX_Condition_variables_Wait_support+0x6c> mutex_error = pthread_mutex_lock( mutex ); 1053b9: 89 34 24 mov %esi,(%esp) 1053bc: e8 ff 01 00 00 call 1055c0 if ( mutex_error != 0 ) { 1053c1: 85 c0 test %eax,%eax 1053c3: 74 97 je 10535c <_POSIX_Condition_variables_Wait_support+0x6c> error = EINVAL; 1053c5: bb 16 00 00 00 mov $0x16,%ebx } 1053ca: 8b 75 f8 mov -0x8(%ebp),%esi 1053cd: 8b 7d fc mov -0x4(%ebp),%edi 1053d0: 89 d8 mov %ebx,%eax 1053d2: 8b 5d f4 mov -0xc(%ebp),%ebx 1053d5: 89 ec mov %ebp,%esp 1053d7: 5d pop %ebp 1053d8: c3 ret 1053d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags ); 1053e0: 89 1c 24 mov %ebx,(%esp) 1053e3: e8 38 fd ff ff call 105120 <_POSIX_Condition_variables_Auto_initialization> 1053e8: 84 c0 test %al,%al 1053ea: 74 d9 je 1053c5 <_POSIX_Condition_variables_Wait_support+0xd5> if ( abstime != NULL ) { 1053ec: 8b 55 10 mov 0x10(%ebp),%edx 1053ef: 85 d2 test %edx,%edx 1053f1: 0f 85 35 ff ff ff jne 10532c <_POSIX_Condition_variables_Wait_support+0x3c><== ALWAYS TAKEN queue_context->enqueue_callout = enqueue_callout; 1053f7: c7 45 cc 30 52 10 00 movl $0x105230,-0x34(%ebp) } 1053fe: e9 3f ff ff ff jmp 105342 <_POSIX_Condition_variables_Wait_support+0x52> 105403: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10540a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi queue_context->enqueue_callout = enqueue_callout; 105410: c7 45 cc 80 52 10 00 movl $0x105280,-0x34(%ebp) <== NOT EXECUTED } 105417: e9 26 ff ff ff jmp 105342 <_POSIX_Condition_variables_Wait_support+0x52><== NOT EXECUTED 10541c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED error = 0; 105420: 31 db xor %ebx,%ebx <== NOT EXECUTED 105422: eb 95 jmp 1053b9 <_POSIX_Condition_variables_Wait_support+0xc9><== NOT EXECUTED 105424: 90 nop 105425: 90 nop 105426: 90 nop 105427: 90 nop 105428: 90 nop 105429: 90 nop 10542a: 90 nop 10542b: 90 nop 10542c: 90 nop 10542d: 90 nop 10542e: 90 nop 10542f: 90 nop =============================================================================== 00105500 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime, Thread_queue_Enqueue_callout enqueue_callout ) { 105500: 55 push %ebp return (POSIX_Message_queue_Control *) _Objects_Get( 105501: ba 40 91 12 00 mov $0x129140,%edx 105506: 89 e5 mov %esp,%ebp 105508: 57 push %edi 105509: 56 push %esi 10550a: 53 push %ebx 10550b: 8d 5d c4 lea -0x3c(%ebp),%ebx 10550e: 83 ec 5c sub $0x5c,%esp 105511: 89 54 24 08 mov %edx,0x8(%esp) 105515: 8b 45 08 mov 0x8(%ebp),%eax 105518: 89 5c 24 04 mov %ebx,0x4(%esp) 10551c: 8b 75 14 mov 0x14(%ebp),%esi 10551f: 89 04 24 mov %eax,(%esp) 105522: e8 29 3c 00 00 call 109150 <_Objects_Get> Thread_Control *executing; Status_Control status; the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { 105527: 85 c0 test %eax,%eax 105529: 0f 84 95 00 00 00 je 1055c4 <_POSIX_Message_queue_Receive_support+0xc4> rtems_set_errno_and_return_minus_one( EBADF ); } if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) { 10552f: 8b 48 6c mov 0x6c(%eax),%ecx 105532: 89 ca mov %ecx,%edx 105534: 83 e2 03 and $0x3,%edx 105537: 4a dec %edx 105538: 0f 84 82 00 00 00 je 1055c0 <_POSIX_Message_queue_Receive_support+0xc0> _ISR_lock_ISR_enable( &queue_context.Lock_context.Lock_context ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10553e: 8b 7d 10 mov 0x10(%ebp),%edi 105541: 39 78 28 cmp %edi,0x28(%eax) 105544: 0f 87 8c 00 00 00 ja 1055d6 <_POSIX_Message_queue_Receive_support+0xd6> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10554a: c7 45 c0 ff ff ff ff movl $0xffffffff,-0x40(%ebp) queue_context->enqueue_callout = enqueue_callout; 105551: 8b 55 1c mov 0x1c(%ebp),%edx 105554: 89 55 cc mov %edx,-0x34(%ebp) queue_context->Timeout.arg = arg; 105557: 8b 55 18 mov 0x18(%ebp),%edx 10555a: 89 55 d0 mov %edx,-0x30(%ebp) _CORE_message_queue_Acquire_critical( 10555d: 8d 50 10 lea 0x10(%eax),%edx &the_mq->Message_queue, &queue_context ); if ( the_mq->open_count == 0 ) { 105560: 8b 40 54 mov 0x54(%eax),%eax 105563: 85 c0 test %eax,%eax 105565: 74 59 je 1055c0 <_POSIX_Message_queue_Receive_support+0xc0> /* * Now perform the actual message receive */ executing = _Thread_Executing; status = _CORE_message_queue_Seize( 105567: 89 5c 24 14 mov %ebx,0x14(%esp) 10556b: 31 c0 xor %eax,%eax 10556d: f6 c5 40 test $0x40,%ch 105570: 89 14 24 mov %edx,(%esp) 105573: 0f 94 c0 sete %al 105576: 8b 3d d8 d1 12 00 mov 0x12d1d8,%edi 10557c: 89 44 24 10 mov %eax,0x10(%esp) 105580: 8d 45 c0 lea -0x40(%ebp),%eax 105583: 89 44 24 0c mov %eax,0xc(%esp) 105587: 8b 45 0c mov 0xc(%ebp),%eax 10558a: 89 7c 24 04 mov %edi,0x4(%esp) 10558e: 89 44 24 08 mov %eax,0x8(%esp) 105592: e8 19 1f 00 00 call 1074b0 <_CORE_message_queue_Seize> &length_out, ( the_mq->oflag & O_NONBLOCK ) == 0, &queue_context ); if ( status != STATUS_SUCCESSFUL ) { 105597: 85 c0 test %eax,%eax status = _CORE_message_queue_Seize( 105599: 89 c3 mov %eax,%ebx if ( status != STATUS_SUCCESSFUL ) { 10559b: 75 4f jne 1055ec <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); } if ( msg_prio != NULL ) { 10559d: 85 f6 test %esi,%esi 10559f: 74 0f je 1055b0 <_POSIX_Message_queue_Receive_support+0xb0><== NEVER TAKEN return (unsigned int) ((priority >= 0) ? priority : -priority); 1055a1: 8b 47 3c mov 0x3c(%edi),%eax 1055a4: 8b 57 3c mov 0x3c(%edi),%edx 1055a7: c1 f8 1f sar $0x1f,%eax 1055aa: 31 c2 xor %eax,%edx 1055ac: 29 c2 sub %eax,%edx 1055ae: 89 16 mov %edx,(%esi) *msg_prio = _POSIX_Message_queue_Priority_from_core( executing->Wait.count ); } return length_out; 1055b0: 8b 45 c0 mov -0x40(%ebp),%eax } 1055b3: 83 c4 5c add $0x5c,%esp 1055b6: 5b pop %ebx 1055b7: 5e pop %esi 1055b8: 5f pop %edi 1055b9: 5d pop %ebp 1055ba: c3 ret 1055bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1055bf: 90 nop _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 1055c0: ff 75 c4 push -0x3c(%ebp) 1055c3: 9d popf rtems_set_errno_and_return_minus_one( EBADF ); 1055c4: e8 57 77 01 00 call 11cd20 <__errno> 1055c9: c7 00 09 00 00 00 movl $0x9,(%eax) 1055cf: b8 ff ff ff ff mov $0xffffffff,%eax 1055d4: eb dd jmp 1055b3 <_POSIX_Message_queue_Receive_support+0xb3> _ISR_lock_ISR_enable( &queue_context.Lock_context.Lock_context ); 1055d6: ff 75 c4 push -0x3c(%ebp) 1055d9: 9d popf rtems_set_errno_and_return_minus_one( EMSGSIZE ); 1055da: e8 41 77 01 00 call 11cd20 <__errno> 1055df: c7 00 7a 00 00 00 movl $0x7a,(%eax) 1055e5: b8 ff ff ff ff mov $0xffffffff,%eax 1055ea: eb c7 jmp 1055b3 <_POSIX_Message_queue_Receive_support+0xb3> rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); 1055ec: e8 2f 77 01 00 call 11cd20 <__errno> 1055f1: 89 c2 mov %eax,%edx 1055f3: 89 d8 mov %ebx,%eax 1055f5: c1 f8 1f sar $0x1f,%eax 1055f8: 0f b6 c0 movzbl %al,%eax 1055fb: 01 c3 add %eax,%ebx 1055fd: b8 ff ff ff ff mov $0xffffffff,%eax 105602: c1 fb 08 sar $0x8,%ebx 105605: 89 1a mov %ebx,(%edx) 105607: eb aa jmp 1055b3 <_POSIX_Message_queue_Receive_support+0xb3> 105609: 90 nop 10560a: 90 nop 10560b: 90 nop 10560c: 90 nop 10560d: 90 nop 10560e: 90 nop 10560f: 90 nop =============================================================================== 00105650 <_POSIX_Message_queue_Send_support>: size_t msg_len, unsigned int msg_prio, const struct timespec *abstime, Thread_queue_Enqueue_callout enqueue_callout ) { 105650: 55 push %ebp 105651: 89 e5 mov %esp,%ebp 105653: 56 push %esi 105654: 53 push %ebx 105655: 83 ec 50 sub $0x50,%esp 105658: 8b 5d 14 mov 0x14(%ebp),%ebx /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) { 10565b: 83 fb 20 cmp $0x20,%ebx 10565e: 0f 87 cc 00 00 00 ja 105730 <_POSIX_Message_queue_Send_support+0xe0> return (POSIX_Message_queue_Control *) _Objects_Get( 105664: 8b 45 08 mov 0x8(%ebp),%eax 105667: 8d 75 d4 lea -0x2c(%ebp),%esi 10566a: ba 40 91 12 00 mov $0x129140,%edx 10566f: 89 54 24 08 mov %edx,0x8(%esp) 105673: 89 74 24 04 mov %esi,0x4(%esp) 105677: 89 04 24 mov %eax,(%esp) 10567a: e8 d1 3a 00 00 call 109150 <_Objects_Get> rtems_set_errno_and_return_minus_one( EINVAL ); } the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { 10567f: 85 c0 test %eax,%eax 105681: 0f 84 8d 00 00 00 je 105714 <_POSIX_Message_queue_Send_support+0xc4><== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBADF ); } if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) { 105687: 8b 48 6c mov 0x6c(%eax),%ecx 10568a: f6 c1 03 test $0x3,%cl 10568d: 0f 84 7d 00 00 00 je 105710 <_POSIX_Message_queue_Send_support+0xc0> queue_context->enqueue_callout = enqueue_callout; 105693: 8b 55 1c mov 0x1c(%ebp),%edx 105696: 89 55 dc mov %edx,-0x24(%ebp) queue_context->Timeout.arg = arg; 105699: 8b 55 18 mov 0x18(%ebp),%edx 10569c: 89 55 e0 mov %edx,-0x20(%ebp) } _Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout ); _Thread_queue_Context_set_timeout_argument( &queue_context, abstime ); _CORE_message_queue_Acquire_critical( 10569f: 8d 50 10 lea 0x10(%eax),%edx &the_mq->Message_queue, &queue_context ); if ( the_mq->open_count == 0 ) { 1056a2: 8b 40 54 mov 0x54(%eax),%eax 1056a5: 85 c0 test %eax,%eax 1056a7: 74 67 je 105710 <_POSIX_Message_queue_Send_support+0xc0> /* * Now perform the actual message receive */ executing = _Thread_Executing; status = _CORE_message_queue_Submit( 1056a9: 89 74 24 18 mov %esi,0x18(%esp) 1056ad: 31 c0 xor %eax,%eax 1056af: f6 c5 40 test $0x40,%ch 1056b2: 89 14 24 mov %edx,(%esp) 1056b5: 0f 94 c0 sete %al return (CORE_message_queue_Submit_types) priority * -1; 1056b8: f7 db neg %ebx 1056ba: 89 44 24 14 mov %eax,0x14(%esp) 1056be: 8b 45 10 mov 0x10(%ebp),%eax 1056c1: 89 5c 24 10 mov %ebx,0x10(%esp) 1056c5: 89 44 24 0c mov %eax,0xc(%esp) 1056c9: 8b 45 0c mov 0xc(%ebp),%eax 1056cc: 89 44 24 08 mov %eax,0x8(%esp) 1056d0: a1 d8 d1 12 00 mov 0x12d1d8,%eax 1056d5: 89 44 24 04 mov %eax,0x4(%esp) 1056d9: e8 72 1f 00 00 call 107650 <_CORE_message_queue_Submit> RTEMS_INLINE_ROUTINE int _POSIX_Zero_or_minus_one_plus_errno( Status_Control status ) { if ( status == STATUS_SUCCESSFUL ) { 1056de: 85 c0 test %eax,%eax 1056e0: 89 c3 mov %eax,%ebx 1056e2: 75 0c jne 1056f0 <_POSIX_Message_queue_Send_support+0xa0> _POSIX_Message_queue_Priority_to_core( msg_prio ), ( the_mq->oflag & O_NONBLOCK ) == 0, &queue_context ); return _POSIX_Zero_or_minus_one_plus_errno( status ); } 1056e4: 83 c4 50 add $0x50,%esp 1056e7: 89 d8 mov %ebx,%eax 1056e9: 5b pop %ebx 1056ea: 5e pop %esi 1056eb: 5d pop %ebp 1056ec: c3 ret 1056ed: 8d 76 00 lea 0x0(%esi),%esi return 0; } rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); 1056f0: e8 2b 76 01 00 call 11cd20 <__errno> 1056f5: 89 c2 mov %eax,%edx return STATUS_GET_POSIX( status ); 1056f7: 89 d8 mov %ebx,%eax 1056f9: c1 f8 1f sar $0x1f,%eax 1056fc: 0f b6 c0 movzbl %al,%eax 1056ff: 01 c3 add %eax,%ebx 105701: c1 fb 08 sar $0x8,%ebx rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); 105704: 89 1a mov %ebx,(%edx) 105706: bb ff ff ff ff mov $0xffffffff,%ebx 10570b: eb d7 jmp 1056e4 <_POSIX_Message_queue_Send_support+0x94> 10570d: 8d 76 00 lea 0x0(%esi),%esi _ISR_lock_ISR_enable( &queue_context.Lock_context.Lock_context ); 105710: ff 75 d4 push -0x2c(%ebp) 105713: 9d popf rtems_set_errno_and_return_minus_one( EBADF ); 105714: e8 07 76 01 00 call 11cd20 <__errno> 105719: bb ff ff ff ff mov $0xffffffff,%ebx 10571e: c7 00 09 00 00 00 movl $0x9,(%eax) 105724: eb be jmp 1056e4 <_POSIX_Message_queue_Send_support+0x94> 105726: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10572d: 8d 76 00 lea 0x0(%esi),%esi rtems_set_errno_and_return_minus_one( EINVAL ); 105730: e8 eb 75 01 00 call 11cd20 <__errno> 105735: bb ff ff ff ff mov $0xffffffff,%ebx 10573a: c7 00 16 00 00 00 movl $0x16,(%eax) 105740: eb a2 jmp 1056e4 <_POSIX_Message_queue_Send_support+0x94> 105742: 90 nop 105743: 90 nop 105744: 90 nop 105745: 90 nop 105746: 90 nop 105747: 90 nop 105748: 90 nop 105749: 90 nop 10574a: 90 nop 10574b: 90 nop 10574c: 90 nop 10574d: 90 nop 10574e: 90 nop 10574f: 90 nop =============================================================================== 00107940 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, const struct timespec *abstime, Thread_queue_Enqueue_callout enqueue_callout ) { 107940: 55 push %ebp 107941: 89 e5 mov %esp,%ebp 107943: 83 ec 58 sub $0x58,%esp 107946: 89 5d f4 mov %ebx,-0xc(%ebp) 107949: 8b 5d 08 mov 0x8(%ebp),%ebx 10794c: 89 75 f8 mov %esi,-0x8(%ebp) 10794f: 89 7d fc mov %edi,-0x4(%ebp) Thread_queue_Context queue_context; Thread_Control *executing; Status_Control status; the_mutex = _POSIX_Mutex_Get( mutex ); POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 107952: 85 db test %ebx,%ebx 107954: 0f 84 36 01 00 00 je 107a90 <_POSIX_Mutex_Lock_support+0x150> 10795a: 8b 33 mov (%ebx),%esi 10795c: 89 d8 mov %ebx,%eax 10795e: 31 f0 xor %esi,%eax 107960: 35 b8 13 1c 96 xor $0x961c13b8,%eax 107965: 83 e0 f8 and $0xfffffff8,%eax 107968: 0f 85 12 01 00 00 jne 107a80 <_POSIX_Mutex_Lock_support+0x140> _Thread_queue_Context_ISR_disable( queue_context, level ); 10796e: 9c pushf 10796f: fa cli 107970: 58 pop %eax ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 107971: 89 45 c4 mov %eax,-0x3c(%ebp) queue_context->enqueue_callout = enqueue_callout; 107974: 8b 55 10 mov 0x10(%ebp),%edx queue_context->Timeout.arg = arg; 107977: 8b 45 0c mov 0xc(%ebp),%eax static inline struct _Thread_Control *_Per_CPU_Get_executing( const Per_CPU_Control *cpu ) { return cpu->executing; 10797a: 8b 3d 78 3c 13 00 mov 0x133c78,%edi queue_context->enqueue_callout = enqueue_callout; 107980: 89 55 cc mov %edx,-0x34(%ebp) executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context ); _Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout); _Thread_queue_Context_set_timeout_argument( &queue_context, abstime ); switch ( _POSIX_Mutex_Get_protocol( flags ) ) { 107983: 89 f2 mov %esi,%edx queue_context->Timeout.arg = arg; 107985: 89 45 d0 mov %eax,-0x30(%ebp) 107988: 83 e2 03 and $0x3,%edx 10798b: 0f 84 bf 00 00 00 je 107a50 <_POSIX_Mutex_Lock_support+0x110> 107991: 83 fa 02 cmp $0x2,%edx 107994: 74 4a je 1079e0 <_POSIX_Mutex_Lock_support+0xa0> RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Mutex_Get_owner( const POSIX_Mutex_Control *the_mutex ) { return the_mutex->Recursive.Mutex.Queue.Queue.owner; 107996: 8b 53 10 mov 0x10(%ebx),%edx { Thread_Control *owner; owner = _POSIX_Mutex_Get_owner( the_mutex ); if ( owner == NULL ) { 107999: 85 d2 test %edx,%edx 10799b: 0f 84 6f 01 00 00 je 107b10 <_POSIX_Mutex_Lock_support+0x1d0> _Thread_Resource_count_increment( executing ); _POSIX_Mutex_Release( the_mutex, queue_context ); return STATUS_SUCCESSFUL; } if ( owner == executing ) { 1079a1: 39 d7 cmp %edx,%edi 1079a3: 0f 84 b6 00 00 00 je 107a5f <_POSIX_Mutex_Lock_support+0x11f> if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) { 1079a9: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 1079ad: 0f 84 3d 01 00 00 je 107af0 <_POSIX_Mutex_Lock_support+0x1b0> queue_context->thread_state = thread_state; 1079b3: c7 45 c8 01 00 00 00 movl $0x1,-0x38(%ebp) _Thread_queue_Enqueue( 1079ba: 8d 55 c4 lea -0x3c(%ebp),%edx 1079bd: b8 28 a3 12 00 mov $0x12a328,%eax queue_context->deadlock_callout = deadlock_callout; 1079c2: c7 45 e4 50 bb 10 00 movl $0x10bb50,-0x1c(%ebp) 1079c9: 89 54 24 0c mov %edx,0xc(%esp) 1079cd: 89 7c 24 08 mov %edi,0x8(%esp) 1079d1: 89 44 24 04 mov %eax,0x4(%esp) 1079d5: eb 44 jmp 107a1b <_POSIX_Mutex_Lock_support+0xdb> 1079d7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1079de: 66 90 xchg %ax,%ax return the_mutex->Recursive.Mutex.Queue.Queue.owner; 1079e0: 8b 53 10 mov 0x10(%ebx),%edx { Thread_Control *owner; owner = _POSIX_Mutex_Get_owner( the_mutex ); if ( owner == NULL ) { 1079e3: 85 d2 test %edx,%edx 1079e5: 0f 84 45 01 00 00 je 107b30 <_POSIX_Mutex_Lock_support+0x1f0> executing, queue_context ); } if ( owner == executing ) { 1079eb: 39 d7 cmp %edx,%edi 1079ed: 74 70 je 107a5f <_POSIX_Mutex_Lock_support+0x11f> <== NEVER TAKEN if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) { 1079ef: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 1079f3: 0f 84 f7 00 00 00 je 107af0 <_POSIX_Mutex_Lock_support+0x1b0> <== NEVER TAKEN queue_context->thread_state = thread_state; 1079f9: c7 45 c8 01 00 00 00 movl $0x1,-0x38(%ebp) _Thread_queue_Enqueue( 107a00: 8d 55 c4 lea -0x3c(%ebp),%edx 107a03: b9 3c a3 12 00 mov $0x12a33c,%ecx queue_context->deadlock_callout = deadlock_callout; 107a08: c7 45 e4 50 bb 10 00 movl $0x10bb50,-0x1c(%ebp) 107a0f: 89 54 24 0c mov %edx,0xc(%esp) 107a13: 89 7c 24 08 mov %edi,0x8(%esp) 107a17: 89 4c 24 04 mov %ecx,0x4(%esp) 107a1b: 83 c3 0c add $0xc,%ebx 107a1e: 89 1c 24 mov %ebx,(%esp) 107a21: e8 5a 41 00 00 call 10bb80 <_Thread_queue_Enqueue> return _POSIX_Get_by_name_error_table[ error ]; } RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status ) { return STATUS_GET_POSIX( status ); 107a26: 8b 4f 4c mov 0x4c(%edi),%ecx 107a29: 89 ca mov %ecx,%edx 107a2b: c1 fa 1f sar $0x1f,%edx 107a2e: 0f b6 c2 movzbl %dl,%eax 107a31: 01 c8 add %ecx,%eax 107a33: c1 f8 08 sar $0x8,%eax ); break; } return _POSIX_Get_error( status ); } 107a36: 8b 5d f4 mov -0xc(%ebp),%ebx 107a39: 8b 75 f8 mov -0x8(%ebp),%esi 107a3c: 8b 7d fc mov -0x4(%ebp),%edi 107a3f: 89 ec mov %ebp,%esp 107a41: 5d pop %ebp 107a42: c3 ret 107a43: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107a4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return the_mutex->Recursive.Mutex.Queue.Queue.owner; 107a50: 8b 53 10 mov 0x10(%ebx),%edx if ( owner == NULL ) { 107a53: 85 d2 test %edx,%edx 107a55: 0f 84 b5 00 00 00 je 107b10 <_POSIX_Mutex_Lock_support+0x1d0> if ( owner == executing ) { 107a5b: 39 d7 cmp %edx,%edi 107a5d: 75 51 jne 107ab0 <_POSIX_Mutex_Lock_support+0x170> if ( _POSIX_Mutex_Is_recursive( flags ) ) { 107a5f: 83 e6 04 and $0x4,%esi 107a62: 74 7c je 107ae0 <_POSIX_Mutex_Lock_support+0x1a0> <== ALWAYS TAKEN ++the_mutex->Recursive.nest_level; 107a64: ff 43 18 incl 0x18(%ebx) <== NOT EXECUTED return STATUS_SUCCESSFUL; 107a67: 31 c0 xor %eax,%eax <== NOT EXECUTED _ISR_lock_ISR_enable( lock_context ); 107a69: ff 75 c4 push -0x3c(%ebp) 107a6c: 9d popf 107a6d: 8b 5d f4 mov -0xc(%ebp),%ebx 107a70: 8b 75 f8 mov -0x8(%ebp),%esi 107a73: 8b 7d fc mov -0x4(%ebp),%edi 107a76: 89 ec mov %ebp,%esp 107a78: 5d pop %ebp 107a79: c3 ret 107a7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 107a80: 89 1c 24 mov %ebx,(%esp) 107a83: e8 b8 02 00 00 call 107d40 <_POSIX_Mutex_Auto_initialization> 107a88: 84 c0 test %al,%al 107a8a: 0f 85 de fe ff ff jne 10796e <_POSIX_Mutex_Lock_support+0x2e> } 107a90: 8b 5d f4 mov -0xc(%ebp),%ebx return STATUS_MUTEX_CEILING_VIOLATED; 107a93: b8 16 00 00 00 mov $0x16,%eax 107a98: 8b 75 f8 mov -0x8(%ebp),%esi 107a9b: 8b 7d fc mov -0x4(%ebp),%edi 107a9e: 89 ec mov %ebp,%esp 107aa0: 5d pop %ebp 107aa1: c3 ret 107aa2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107aa9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) { 107ab0: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 107ab4: 74 3a je 107af0 <_POSIX_Mutex_Lock_support+0x1b0> <== NEVER TAKEN queue_context->thread_state = thread_state; 107ab6: c7 45 c8 01 00 00 00 movl $0x1,-0x38(%ebp) _Thread_queue_Enqueue( 107abd: 8d 55 c4 lea -0x3c(%ebp),%edx 107ac0: 89 54 24 0c mov %edx,0xc(%esp) 107ac4: ba 50 a3 12 00 mov $0x12a350,%edx queue_context->deadlock_callout = deadlock_callout; 107ac9: c7 45 e4 50 bb 10 00 movl $0x10bb50,-0x1c(%ebp) 107ad0: 89 7c 24 08 mov %edi,0x8(%esp) 107ad4: 89 54 24 04 mov %edx,0x4(%esp) 107ad8: e9 3e ff ff ff jmp 107a1b <_POSIX_Mutex_Lock_support+0xdb> 107add: 8d 76 00 lea 0x0(%esi),%esi 107ae0: b8 2d 00 00 00 mov $0x2d,%eax 107ae5: e9 7f ff ff ff jmp 107a69 <_POSIX_Mutex_Lock_support+0x129> 107aea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi _ISR_lock_ISR_enable( lock_context ); 107af0: ff 75 c4 push -0x3c(%ebp) 107af3: 9d popf } 107af4: 8b 5d f4 mov -0xc(%ebp),%ebx 107af7: b8 10 00 00 00 mov $0x10,%eax 107afc: 8b 75 f8 mov -0x8(%ebp),%esi 107aff: 8b 7d fc mov -0x4(%ebp),%edi 107b02: 89 ec mov %ebp,%esp 107b04: 5d pop %ebp 107b05: c3 ret 107b06: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107b0d: 8d 76 00 lea 0x0(%esi),%esi the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 107b10: 89 7b 10 mov %edi,0x10(%ebx) 107b13: ff 75 c4 push -0x3c(%ebp) 107b16: 9d popf 107b17: 8b 5d f4 mov -0xc(%ebp),%ebx return STATUS_SUCCESSFUL; 107b1a: 31 c0 xor %eax,%eax 107b1c: 8b 75 f8 mov -0x8(%ebp),%esi 107b1f: 8b 7d fc mov -0x4(%ebp),%edi 107b22: 89 ec mov %ebp,%esp 107b24: 5d pop %ebp 107b25: c3 ret 107b26: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107b2d: 8d 76 00 lea 0x0(%esi),%esi queue_context->Priority.update_count = 0; 107b30: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) */ RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority( const Priority_Aggregation *aggregation ) { return aggregation->Node.priority; 107b37: 8b 57 38 mov 0x38(%edi),%edx if ( 107b3a: 8b 43 2c mov 0x2c(%ebx),%eax 107b3d: 39 42 14 cmp %eax,0x14(%edx) 107b40: 8b 4a 18 mov 0x18(%edx),%ecx 107b43: 1b 4b 30 sbb 0x30(%ebx),%ecx 107b46: 72 43 jb 107b8b <_POSIX_Mutex_Lock_support+0x24b> the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 107b48: 89 7b 10 mov %edi,0x10(%ebx) _Thread_Priority_add( 107b4b: 8d 75 c4 lea -0x3c(%ebp),%esi 107b4e: 83 c3 1c add $0x1c,%ebx 107b51: 89 74 24 08 mov %esi,0x8(%esp) 107b55: 89 5c 24 04 mov %ebx,0x4(%esp) 107b59: 89 3c 24 mov %edi,(%esp) 107b5c: e8 ef 36 00 00 call 10b250 <_Thread_Priority_add> const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 107b61: a1 70 3c 13 00 mov 0x133c70,%eax _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 107b66: 40 inc %eax 107b67: a3 70 3c 13 00 mov %eax,0x133c70 _ISR_lock_ISR_enable( lock_context ); 107b6c: ff 75 c4 push -0x3c(%ebp) 107b6f: 9d popf _Thread_Priority_update( queue_context ); 107b70: 89 34 24 mov %esi,(%esp) 107b73: e8 58 38 00 00 call 10b3d0 <_Thread_Priority_update> _Thread_Dispatch_enable( cpu_self ); 107b78: c7 04 24 60 3c 13 00 movl $0x133c60,(%esp) 107b7f: e8 cc 3a 00 00 call 10b650 <_Thread_Dispatch_enable> return STATUS_SUCCESSFUL; 107b84: 31 c0 xor %eax,%eax 107b86: e9 ab fe ff ff jmp 107a36 <_POSIX_Mutex_Lock_support+0xf6> 107b8b: ff 75 c4 push -0x3c(%ebp) 107b8e: 9d popf 107b8f: e9 fc fe ff ff jmp 107a90 <_POSIX_Mutex_Lock_support+0x150> 107b94: 90 nop 107b95: 90 nop 107b96: 90 nop 107b97: 90 nop 107b98: 90 nop 107b99: 90 nop 107b9a: 90 nop 107b9b: 90 nop 107b9c: 90 nop 107b9d: 90 nop 107b9e: 90 nop 107b9f: 90 nop =============================================================================== 00106310 <_POSIX_RWLock_Auto_initialization>: #include #include bool _POSIX_RWLock_Auto_initialization( POSIX_RWLock_Control *the_rwlock ) { 106310: 55 push %ebp POSIX_RWLock_Control zero; memset( &zero, 0, sizeof( zero ) ); 106311: 31 d2 xor %edx,%edx { 106313: 89 e5 mov %esp,%ebp 106315: 83 ec 38 sub $0x38,%esp 106318: 89 5d fc mov %ebx,-0x4(%ebp) 10631b: 8b 5d 08 mov 0x8(%ebp),%ebx memset( &zero, 0, sizeof( zero ) ); 10631e: 31 c0 xor %eax,%eax 106320: 89 54 05 d8 mov %edx,-0x28(%ebp,%eax,1) 106324: 89 54 05 dc mov %edx,-0x24(%ebp,%eax,1) 106328: 83 c0 08 add $0x8,%eax 10632b: 83 f8 20 cmp $0x20,%eax 10632e: 72 f0 jb 106320 <_POSIX_RWLock_Auto_initialization+0x10> if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) { 106330: 89 1c 24 mov %ebx,(%esp) 106333: b8 20 00 00 00 mov $0x20,%eax 106338: 89 44 24 08 mov %eax,0x8(%esp) 10633c: 8d 45 d8 lea -0x28(%ebp),%eax 10633f: 89 44 24 04 mov %eax,0x4(%esp) 106343: e8 e7 69 01 00 call 11cd2f 106348: 85 c0 test %eax,%eax 10634a: 75 14 jne 106360 <_POSIX_RWLock_Auto_initialization+0x50> return false; } the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC; 10634c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10634e: 35 bd da 21 96 xor $0x9621dabd,%eax <== NOT EXECUTED 106353: 89 03 mov %eax,(%ebx) <== NOT EXECUTED return true; } 106355: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106358: 89 ec mov %ebp,%esp <== NOT EXECUTED 10635a: 5d pop %ebp <== NOT EXECUTED return true; 10635b: b0 01 mov $0x1,%al <== NOT EXECUTED } 10635d: c3 ret <== NOT EXECUTED 10635e: 66 90 xchg %ax,%ax <== NOT EXECUTED 106360: 8b 5d fc mov -0x4(%ebp),%ebx 106363: 89 ec mov %ebp,%esp return false; 106365: 31 c0 xor %eax,%eax } 106367: 5d pop %ebp 106368: c3 ret 106369: 90 nop 10636a: 90 nop 10636b: 90 nop 10636c: 90 nop 10636d: 90 nop 10636e: 90 nop 10636f: 90 nop =============================================================================== 001048e0 <_POSIX_Shm_Object_create_from_heap>: int _POSIX_Shm_Object_create_from_heap( POSIX_Shm_Object *shm_obj, size_t size ) { 1048e0: 55 push %ebp <== NOT EXECUTED 1048e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1048e3: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 1048e6: 89 5d f8 mov %ebx,-0x8(%ebp) <== NOT EXECUTED 1048e9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void *p = calloc( 1, size ); /* get zero'd memory */ 1048ec: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED { 1048f3: 89 75 fc mov %esi,-0x4(%ebp) <== NOT EXECUTED 1048f6: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED void *p = calloc( 1, size ); /* get zero'd memory */ 1048f9: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 1048fd: e8 fe 50 00 00 call 109a00 <== NOT EXECUTED if ( p != NULL ) { 104902: 85 c0 test %eax,%eax <== NOT EXECUTED 104904: 74 11 je 104917 <_POSIX_Shm_Object_create_from_heap+0x37><== NOT EXECUTED shm_obj->handle = p; 104906: 89 06 mov %eax,(%esi) <== NOT EXECUTED shm_obj->size = size; 104908: 89 5e 04 mov %ebx,0x4(%esi) <== NOT EXECUTED } else { errno = EIO; } return 0; } 10490b: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED 10490e: 31 c0 xor %eax,%eax <== NOT EXECUTED 104910: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED 104913: 89 ec mov %ebp,%esp <== NOT EXECUTED 104915: 5d pop %ebp <== NOT EXECUTED 104916: c3 ret <== NOT EXECUTED errno = EIO; 104917: e8 74 59 01 00 call 11a290 <__errno> <== NOT EXECUTED 10491c: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 104922: eb e7 jmp 10490b <_POSIX_Shm_Object_create_from_heap+0x2b><== NOT EXECUTED 104924: 90 nop 104925: 90 nop 104926: 90 nop 104927: 90 nop 104928: 90 nop 104929: 90 nop 10492a: 90 nop 10492b: 90 nop 10492c: 90 nop 10492d: 90 nop 10492e: 90 nop 10492f: 90 nop =============================================================================== 00105c60 <_POSIX_Shm_Object_create_from_workspace>: int _POSIX_Shm_Object_create_from_workspace( POSIX_Shm_Object *shm_obj, size_t size ) { 105c60: 55 push %ebp <== NOT EXECUTED 105c61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 105c63: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 105c66: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED 105c69: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 105c6c: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED 105c6f: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 105c72: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED shm_obj->handle = _Workspace_Allocate( size ); 105c75: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 105c78: e8 d3 43 00 00 call 10a050 <_Workspace_Allocate> <== NOT EXECUTED 105c7d: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( shm_obj->handle == NULL ) { 105c7f: 85 c0 test %eax,%eax <== NOT EXECUTED 105c81: 0f 84 99 00 00 00 je 105d20 <_POSIX_Shm_Object_create_from_workspace+0xc0><== NOT EXECUTED return ENOMEM; } memset( shm_obj->handle, 0, size ); 105c87: 83 fb 08 cmp $0x8,%ebx <== NOT EXECUTED 105c8a: 89 c7 mov %eax,%edi <== NOT EXECUTED 105c8c: 89 da mov %ebx,%edx <== NOT EXECUTED 105c8e: 73 60 jae 105cf0 <_POSIX_Shm_Object_create_from_workspace+0x90><== NOT EXECUTED 105c90: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 105c93: 75 4b jne 105ce0 <_POSIX_Shm_Object_create_from_workspace+0x80><== NOT EXECUTED 105c95: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 105c98: 75 36 jne 105cd0 <_POSIX_Shm_Object_create_from_workspace+0x70><== NOT EXECUTED 105c9a: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 105c9d: 75 21 jne 105cc0 <_POSIX_Shm_Object_create_from_workspace+0x60><== NOT EXECUTED shm_obj->size = size; 105c9f: 89 5e 04 mov %ebx,0x4(%esi) <== NOT EXECUTED return 0; } 105ca2: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED return 0; 105ca5: 31 c0 xor %eax,%eax <== NOT EXECUTED } 105ca7: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED 105caa: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 105cad: 89 ec mov %ebp,%esp <== NOT EXECUTED 105caf: 5d pop %ebp <== NOT EXECUTED 105cb0: c3 ret <== NOT EXECUTED 105cb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105cb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105cbf: 90 nop <== NOT EXECUTED memset( shm_obj->handle, 0, size ); 105cc0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 105cc3: eb da jmp 105c9f <_POSIX_Shm_Object_create_from_workspace+0x3f><== NOT EXECUTED 105cc5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105ccc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105cd0: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105cd5: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105cd8: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 105cdb: 74 c2 je 105c9f <_POSIX_Shm_Object_create_from_workspace+0x3f><== NOT EXECUTED 105cdd: eb e1 jmp 105cc0 <_POSIX_Shm_Object_create_from_workspace+0x60><== NOT EXECUTED 105cdf: 90 nop <== NOT EXECUTED 105ce0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 105ce6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 105ce9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 105cec: 74 ac je 105c9a <_POSIX_Shm_Object_create_from_workspace+0x3a><== NOT EXECUTED 105cee: eb e0 jmp 105cd0 <_POSIX_Shm_Object_create_from_workspace+0x70><== NOT EXECUTED 105cf0: a8 01 test $0x1,%al <== NOT EXECUTED 105cf2: 75 5c jne 105d50 <_POSIX_Shm_Object_create_from_workspace+0xf0><== NOT EXECUTED 105cf4: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 105cfa: 75 64 jne 105d60 <_POSIX_Shm_Object_create_from_workspace+0x100><== NOT EXECUTED 105cfc: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 105d02: 75 3c jne 105d40 <_POSIX_Shm_Object_create_from_workspace+0xe0><== NOT EXECUTED 105d04: 89 d1 mov %edx,%ecx <== NOT EXECUTED 105d06: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 105d09: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED 105d0c: 31 c0 xor %eax,%eax <== NOT EXECUTED 105d0e: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 105d10: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 105d13: 74 80 je 105c95 <_POSIX_Shm_Object_create_from_workspace+0x35><== NOT EXECUTED 105d15: eb c9 jmp 105ce0 <_POSIX_Shm_Object_create_from_workspace+0x80><== NOT EXECUTED 105d17: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105d1e: 66 90 xchg %ax,%ax <== NOT EXECUTED } 105d20: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED return ENOMEM; 105d23: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 105d28: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 105d2b: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 105d2e: 89 ec mov %ebp,%esp <== NOT EXECUTED 105d30: 5d pop %ebp <== NOT EXECUTED 105d31: c3 ret <== NOT EXECUTED 105d32: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105d39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memset( shm_obj->handle, 0, size ); 105d40: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 105d46: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED 105d49: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 105d4c: eb b6 jmp 105d04 <_POSIX_Shm_Object_create_from_workspace+0xa4><== NOT EXECUTED 105d4e: 66 90 xchg %ax,%ax <== NOT EXECUTED 105d50: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 105d53: 8d 53 ff lea -0x1(%ebx),%edx <== NOT EXECUTED 105d56: 47 inc %edi <== NOT EXECUTED 105d57: eb 9b jmp 105cf4 <_POSIX_Shm_Object_create_from_workspace+0x94><== NOT EXECUTED 105d59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105d60: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105d65: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 105d68: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105d6b: eb 8f jmp 105cfc <_POSIX_Shm_Object_create_from_workspace+0x9c><== NOT EXECUTED 105d6d: 90 nop 105d6e: 90 nop 105d6f: 90 nop =============================================================================== 00104930 <_POSIX_Shm_Object_delete_from_heap>: int _POSIX_Shm_Object_delete_from_heap( POSIX_Shm_Object *shm_obj ) { 104930: 55 push %ebp 104931: 89 e5 mov %esp,%ebp 104933: 57 push %edi 104934: 53 push %ebx 104935: 83 ec 10 sub $0x10,%esp 104938: 8b 5d 08 mov 0x8(%ebp),%ebx /* zero out memory before releasing it. */ memset( shm_obj->handle, 0, shm_obj->size ); 10493b: 8b 53 04 mov 0x4(%ebx),%edx 10493e: 8b 3b mov (%ebx),%edi 104940: 83 fa 08 cmp $0x8,%edx 104943: 73 4b jae 104990 <_POSIX_Shm_Object_delete_from_heap+0x60><== ALWAYS TAKEN 104945: f6 c2 04 test $0x4,%dl 104948: 74 09 je 104953 <_POSIX_Shm_Object_delete_from_heap+0x23><== ALWAYS TAKEN 10494a: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 104950: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 104953: f6 c2 02 test $0x2,%dl 104956: 74 08 je 104960 <_POSIX_Shm_Object_delete_from_heap+0x30><== ALWAYS TAKEN 104958: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 10495d: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 104960: f6 c2 01 test $0x1,%dl 104963: 74 03 je 104968 <_POSIX_Shm_Object_delete_from_heap+0x38><== ALWAYS TAKEN 104965: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED free( shm_obj->handle ); 104968: 8b 03 mov (%ebx),%eax 10496a: 89 04 24 mov %eax,(%esp) 10496d: e8 be 51 00 00 call 109b30 shm_obj->handle = NULL; shm_obj->size = 0; return 0; } 104972: 31 c0 xor %eax,%eax shm_obj->handle = NULL; 104974: c7 03 00 00 00 00 movl $0x0,(%ebx) shm_obj->size = 0; 10497a: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) } 104981: 83 c4 10 add $0x10,%esp 104984: 5b pop %ebx 104985: 5f pop %edi 104986: 5d pop %ebp 104987: c3 ret 104988: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10498f: 90 nop memset( shm_obj->handle, 0, shm_obj->size ); 104990: f7 c7 01 00 00 00 test $0x1,%edi 104996: 75 28 jne 1049c0 <_POSIX_Shm_Object_delete_from_heap+0x90><== NEVER TAKEN 104998: f7 c7 02 00 00 00 test $0x2,%edi 10499e: 75 30 jne 1049d0 <_POSIX_Shm_Object_delete_from_heap+0xa0><== NEVER TAKEN 1049a0: f7 c7 04 00 00 00 test $0x4,%edi 1049a6: 75 38 jne 1049e0 <_POSIX_Shm_Object_delete_from_heap+0xb0><== ALWAYS TAKEN 1049a8: 89 d1 mov %edx,%ecx 1049aa: 31 c0 xor %eax,%eax 1049ac: c1 e9 02 shr $0x2,%ecx 1049af: 83 e2 03 and $0x3,%edx 1049b2: f3 ab rep stos %eax,%es:(%edi) 1049b4: eb 8f jmp 104945 <_POSIX_Shm_Object_delete_from_heap+0x15> 1049b6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1049bd: 8d 76 00 lea 0x0(%esi),%esi 1049c0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 1049c3: 4a dec %edx <== NOT EXECUTED 1049c4: 47 inc %edi <== NOT EXECUTED 1049c5: eb d1 jmp 104998 <_POSIX_Shm_Object_delete_from_heap+0x68><== NOT EXECUTED 1049c7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1049ce: 66 90 xchg %ax,%ax <== NOT EXECUTED 1049d0: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 1049d5: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 1049d8: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 1049db: eb c3 jmp 1049a0 <_POSIX_Shm_Object_delete_from_heap+0x70><== NOT EXECUTED 1049dd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 1049e0: c7 07 00 00 00 00 movl $0x0,(%edi) 1049e6: 83 ea 04 sub $0x4,%edx 1049e9: 83 c7 04 add $0x4,%edi 1049ec: eb ba jmp 1049a8 <_POSIX_Shm_Object_delete_from_heap+0x78> 1049ee: 90 nop 1049ef: 90 nop =============================================================================== 00105d70 <_POSIX_Shm_Object_delete_from_workspace>: int _POSIX_Shm_Object_delete_from_workspace( POSIX_Shm_Object *shm_obj ) { 105d70: 55 push %ebp 105d71: 89 e5 mov %esp,%ebp 105d73: 57 push %edi 105d74: 53 push %ebx 105d75: 83 ec 10 sub $0x10,%esp 105d78: 8b 5d 08 mov 0x8(%ebp),%ebx /* zero out memory before releasing it. */ memset( shm_obj->handle, 0, shm_obj->size ); 105d7b: 8b 53 04 mov 0x4(%ebx),%edx 105d7e: 8b 3b mov (%ebx),%edi 105d80: 83 fa 08 cmp $0x8,%edx 105d83: 73 4b jae 105dd0 <_POSIX_Shm_Object_delete_from_workspace+0x60> 105d85: f6 c2 04 test $0x4,%dl 105d88: 74 09 je 105d93 <_POSIX_Shm_Object_delete_from_workspace+0x23><== ALWAYS TAKEN 105d8a: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 105d90: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 105d93: f6 c2 02 test $0x2,%dl 105d96: 74 08 je 105da0 <_POSIX_Shm_Object_delete_from_workspace+0x30><== ALWAYS TAKEN 105d98: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105d9d: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105da0: f6 c2 01 test $0x1,%dl 105da3: 74 03 je 105da8 <_POSIX_Shm_Object_delete_from_workspace+0x38><== ALWAYS TAKEN 105da5: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED _Workspace_Free( shm_obj->handle ); 105da8: 8b 03 mov (%ebx),%eax 105daa: 89 04 24 mov %eax,(%esp) 105dad: e8 ce 42 00 00 call 10a080 <_Workspace_Free> shm_obj->handle = NULL; shm_obj->size = 0; return 0; } 105db2: 31 c0 xor %eax,%eax shm_obj->handle = NULL; 105db4: c7 03 00 00 00 00 movl $0x0,(%ebx) shm_obj->size = 0; 105dba: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) } 105dc1: 83 c4 10 add $0x10,%esp 105dc4: 5b pop %ebx 105dc5: 5f pop %edi 105dc6: 5d pop %ebp 105dc7: c3 ret 105dc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105dcf: 90 nop memset( shm_obj->handle, 0, shm_obj->size ); 105dd0: f7 c7 01 00 00 00 test $0x1,%edi 105dd6: 75 28 jne 105e00 <_POSIX_Shm_Object_delete_from_workspace+0x90><== NEVER TAKEN 105dd8: f7 c7 02 00 00 00 test $0x2,%edi 105dde: 75 30 jne 105e10 <_POSIX_Shm_Object_delete_from_workspace+0xa0><== NEVER TAKEN 105de0: f7 c7 04 00 00 00 test $0x4,%edi 105de6: 75 38 jne 105e20 <_POSIX_Shm_Object_delete_from_workspace+0xb0><== ALWAYS TAKEN 105de8: 89 d1 mov %edx,%ecx 105dea: 31 c0 xor %eax,%eax 105dec: c1 e9 02 shr $0x2,%ecx 105def: 83 e2 03 and $0x3,%edx 105df2: f3 ab rep stos %eax,%es:(%edi) 105df4: eb 8f jmp 105d85 <_POSIX_Shm_Object_delete_from_workspace+0x15> 105df6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105dfd: 8d 76 00 lea 0x0(%esi),%esi 105e00: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 105e03: 4a dec %edx <== NOT EXECUTED 105e04: 47 inc %edi <== NOT EXECUTED 105e05: eb d1 jmp 105dd8 <_POSIX_Shm_Object_delete_from_workspace+0x68><== NOT EXECUTED 105e07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105e0e: 66 90 xchg %ax,%ax <== NOT EXECUTED 105e10: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105e15: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 105e18: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105e1b: eb c3 jmp 105de0 <_POSIX_Shm_Object_delete_from_workspace+0x70><== NOT EXECUTED 105e1d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 105e20: c7 07 00 00 00 00 movl $0x0,(%edi) 105e26: 83 ea 04 sub $0x4,%edx 105e29: 83 c7 04 add $0x4,%edi 105e2c: eb ba jmp 105de8 <_POSIX_Shm_Object_delete_from_workspace+0x78> 105e2e: 90 nop 105e2f: 90 nop =============================================================================== 00104c60 <_POSIX_Shm_Object_mmap_from_heap>: POSIX_Shm_Object *shm_obj, size_t len, int prot, off_t off ) { 104c60: 55 push %ebp 104c61: 89 e5 mov %esp,%ebp 104c63: 83 ec 18 sub $0x18,%esp 104c66: 89 75 f8 mov %esi,-0x8(%ebp) 104c69: 8b 45 08 mov 0x8(%ebp),%eax 104c6c: 89 7d fc mov %edi,-0x4(%ebp) 104c6f: 8b 75 14 mov 0x14(%ebp),%esi 104c72: 89 5d f4 mov %ebx,-0xc(%ebp) 104c75: 8b 7d 18 mov 0x18(%ebp),%edi if ( shm_obj == NULL || shm_obj->handle == NULL ) 104c78: 85 c0 test %eax,%eax 104c7a: 74 44 je 104cc0 <_POSIX_Shm_Object_mmap_from_heap+0x60> <== NEVER TAKEN 104c7c: 8b 10 mov (%eax),%edx 104c7e: 85 d2 test %edx,%edx 104c80: 74 20 je 104ca2 <_POSIX_Shm_Object_mmap_from_heap+0x42> <== NEVER TAKEN return 0; /* This is already checked by mmap. Maybe make it a debug assert? */ if ( shm_obj->size < len + off ) { 104c82: 8b 48 04 mov 0x4(%eax),%ecx 104c85: 31 db xor %ebx,%ebx 104c87: 89 5d ec mov %ebx,-0x14(%ebp) 104c8a: 31 db xor %ebx,%ebx 104c8c: 89 4d e8 mov %ecx,-0x18(%ebp) 104c8f: 8b 4d 0c mov 0xc(%ebp),%ecx 104c92: 01 f1 add %esi,%ecx 104c94: 11 fb adc %edi,%ebx 104c96: 39 48 04 cmp %ecx,0x4(%eax) 104c99: 8b 45 ec mov -0x14(%ebp),%eax 104c9c: 19 d8 sbb %ebx,%eax 104c9e: 7c 20 jl 104cc0 <_POSIX_Shm_Object_mmap_from_heap+0x60> <== NEVER TAKEN return NULL; } return (char*)shm_obj->handle + off; 104ca0: 01 f2 add %esi,%edx } 104ca2: 8b 5d f4 mov -0xc(%ebp),%ebx 104ca5: 89 d0 mov %edx,%eax 104ca7: 8b 75 f8 mov -0x8(%ebp),%esi 104caa: 8b 7d fc mov -0x4(%ebp),%edi 104cad: 89 ec mov %ebp,%esp 104caf: 5d pop %ebp 104cb0: c3 ret 104cb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104cb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104cbf: 90 nop 104cc0: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED return 0; 104cc3: 31 d2 xor %edx,%edx <== NOT EXECUTED } 104cc5: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 104cc8: 89 d0 mov %edx,%eax <== NOT EXECUTED 104cca: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 104ccd: 89 ec mov %ebp,%esp <== NOT EXECUTED 104ccf: 5d pop %ebp <== NOT EXECUTED 104cd0: c3 ret <== NOT EXECUTED 104cd1: 90 nop 104cd2: 90 nop 104cd3: 90 nop 104cd4: 90 nop 104cd5: 90 nop 104cd6: 90 nop 104cd7: 90 nop 104cd8: 90 nop 104cd9: 90 nop 104cda: 90 nop 104cdb: 90 nop 104cdc: 90 nop 104cdd: 90 nop 104cde: 90 nop 104cdf: 90 nop =============================================================================== 001060d0 <_POSIX_Shm_Object_mmap_from_workspace>: POSIX_Shm_Object *shm_obj, size_t len, int prot, off_t off ) { 1060d0: 55 push %ebp 1060d1: 89 e5 mov %esp,%ebp 1060d3: 83 ec 18 sub $0x18,%esp 1060d6: 89 75 f8 mov %esi,-0x8(%ebp) 1060d9: 8b 45 08 mov 0x8(%ebp),%eax 1060dc: 89 7d fc mov %edi,-0x4(%ebp) 1060df: 8b 75 14 mov 0x14(%ebp),%esi 1060e2: 89 5d f4 mov %ebx,-0xc(%ebp) 1060e5: 8b 7d 18 mov 0x18(%ebp),%edi if ( shm_obj == NULL || shm_obj->handle == NULL ) 1060e8: 85 c0 test %eax,%eax 1060ea: 74 44 je 106130 <_POSIX_Shm_Object_mmap_from_workspace+0x60><== NEVER TAKEN 1060ec: 8b 10 mov (%eax),%edx 1060ee: 85 d2 test %edx,%edx 1060f0: 74 20 je 106112 <_POSIX_Shm_Object_mmap_from_workspace+0x42><== NEVER TAKEN return 0; /* This is already checked by mmap. Maybe make it a debug assert? */ if ( shm_obj->size < len + off ) { 1060f2: 8b 48 04 mov 0x4(%eax),%ecx 1060f5: 31 db xor %ebx,%ebx 1060f7: 89 5d ec mov %ebx,-0x14(%ebp) 1060fa: 31 db xor %ebx,%ebx 1060fc: 89 4d e8 mov %ecx,-0x18(%ebp) 1060ff: 8b 4d 0c mov 0xc(%ebp),%ecx 106102: 01 f1 add %esi,%ecx 106104: 11 fb adc %edi,%ebx 106106: 39 48 04 cmp %ecx,0x4(%eax) 106109: 8b 45 ec mov -0x14(%ebp),%eax 10610c: 19 d8 sbb %ebx,%eax 10610e: 7c 20 jl 106130 <_POSIX_Shm_Object_mmap_from_workspace+0x60><== NEVER TAKEN return NULL; } return (char*)shm_obj->handle + off; 106110: 01 f2 add %esi,%edx } 106112: 8b 5d f4 mov -0xc(%ebp),%ebx 106115: 89 d0 mov %edx,%eax 106117: 8b 75 f8 mov -0x8(%ebp),%esi 10611a: 8b 7d fc mov -0x4(%ebp),%edi 10611d: 89 ec mov %ebp,%esp 10611f: 5d pop %ebp 106120: c3 ret 106121: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 106128: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10612f: 90 nop 106130: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED return 0; 106133: 31 d2 xor %edx,%edx <== NOT EXECUTED } 106135: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 106138: 89 d0 mov %edx,%eax <== NOT EXECUTED 10613a: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10613d: 89 ec mov %ebp,%esp <== NOT EXECUTED 10613f: 5d pop %ebp <== NOT EXECUTED 106140: c3 ret <== NOT EXECUTED 106141: 90 nop 106142: 90 nop 106143: 90 nop 106144: 90 nop 106145: 90 nop 106146: 90 nop 106147: 90 nop 106148: 90 nop 106149: 90 nop 10614a: 90 nop 10614b: 90 nop 10614c: 90 nop 10614d: 90 nop 10614e: 90 nop 10614f: 90 nop =============================================================================== 00104ba0 <_POSIX_Shm_Object_read_from_heap>: int _POSIX_Shm_Object_read_from_heap( POSIX_Shm_Object *shm_obj, void *buf, size_t count ) { 104ba0: 55 push %ebp <== NOT EXECUTED 104ba1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 104ba3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 104ba6: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED 104ba9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 104bac: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED if ( shm_obj == NULL || shm_obj->handle == NULL ) 104baf: 85 c0 test %eax,%eax <== NOT EXECUTED 104bb1: 74 6d je 104c20 <_POSIX_Shm_Object_read_from_heap+0x80> <== NOT EXECUTED 104bb3: 8b 30 mov (%eax),%esi <== NOT EXECUTED 104bb5: 85 f6 test %esi,%esi <== NOT EXECUTED 104bb7: 74 67 je 104c20 <_POSIX_Shm_Object_read_from_heap+0x80> <== NOT EXECUTED return 0; if ( shm_obj->size < count ) { 104bb9: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 104bbc: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 104bbf: 77 1f ja 104be0 <_POSIX_Shm_Object_read_from_heap+0x40> <== NOT EXECUTED count = shm_obj->size; } memcpy( buf, shm_obj->handle, count ); 104bc1: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED 104bc4: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 104bc7: 89 c1 mov %eax,%ecx <== NOT EXECUTED 104bc9: 73 22 jae 104bed <_POSIX_Shm_Object_read_from_heap+0x4d> <== NOT EXECUTED 104bcb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED return count; } 104bcd: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 104bd0: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 104bd3: 89 ec mov %ebp,%esp <== NOT EXECUTED 104bd5: 5d pop %ebp <== NOT EXECUTED 104bd6: c3 ret <== NOT EXECUTED 104bd7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104bde: 66 90 xchg %ax,%ax <== NOT EXECUTED 104be0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED memcpy( buf, shm_obj->handle, count ); 104be3: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 104be6: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED 104be9: 89 c1 mov %eax,%ecx <== NOT EXECUTED 104beb: 72 de jb 104bcb <_POSIX_Shm_Object_read_from_heap+0x2b> <== NOT EXECUTED 104bed: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 104bf3: 75 3b jne 104c30 <_POSIX_Shm_Object_read_from_heap+0x90> <== NOT EXECUTED 104bf5: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 104bfb: 75 43 jne 104c40 <_POSIX_Shm_Object_read_from_heap+0xa0> <== NOT EXECUTED 104bfd: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 104c03: 74 c6 je 104bcb <_POSIX_Shm_Object_read_from_heap+0x2b> <== NOT EXECUTED 104c05: 8b 16 mov (%esi),%edx <== NOT EXECUTED 104c07: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 104c0a: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 104c0d: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 104c10: 89 57 fc mov %edx,-0x4(%edi) <== NOT EXECUTED 104c13: eb b6 jmp 104bcb <_POSIX_Shm_Object_read_from_heap+0x2b> <== NOT EXECUTED 104c15: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104c1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED } 104c20: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED return 0; 104c23: 31 c0 xor %eax,%eax <== NOT EXECUTED } 104c25: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 104c28: 89 ec mov %ebp,%esp <== NOT EXECUTED 104c2a: 5d pop %ebp <== NOT EXECUTED 104c2b: c3 ret <== NOT EXECUTED 104c2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memcpy( buf, shm_obj->handle, count ); 104c30: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED 104c33: 47 inc %edi <== NOT EXECUTED 104c34: 46 inc %esi <== NOT EXECUTED 104c35: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 104c38: 88 57 ff mov %dl,-0x1(%edi) <== NOT EXECUTED 104c3b: eb b8 jmp 104bf5 <_POSIX_Shm_Object_read_from_heap+0x55> <== NOT EXECUTED 104c3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 104c40: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED 104c43: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 104c46: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 104c49: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED 104c4c: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED 104c50: eb ab jmp 104bfd <_POSIX_Shm_Object_read_from_heap+0x5d> <== NOT EXECUTED 104c52: 90 nop 104c53: 90 nop 104c54: 90 nop 104c55: 90 nop 104c56: 90 nop 104c57: 90 nop 104c58: 90 nop 104c59: 90 nop 104c5a: 90 nop 104c5b: 90 nop 104c5c: 90 nop 104c5d: 90 nop 104c5e: 90 nop 104c5f: 90 nop =============================================================================== 00106010 <_POSIX_Shm_Object_read_from_workspace>: int _POSIX_Shm_Object_read_from_workspace( POSIX_Shm_Object *shm_obj, void *buf, size_t count ) { 106010: 55 push %ebp 106011: 89 e5 mov %esp,%ebp 106013: 83 ec 08 sub $0x8,%esp 106016: 89 75 f8 mov %esi,-0x8(%ebp) 106019: 8b 45 08 mov 0x8(%ebp),%eax 10601c: 89 7d fc mov %edi,-0x4(%ebp) if ( shm_obj == NULL || shm_obj->handle == NULL ) 10601f: 85 c0 test %eax,%eax 106021: 74 6d je 106090 <_POSIX_Shm_Object_read_from_workspace+0x80><== NEVER TAKEN 106023: 8b 30 mov (%eax),%esi 106025: 85 f6 test %esi,%esi 106027: 74 67 je 106090 <_POSIX_Shm_Object_read_from_workspace+0x80><== NEVER TAKEN return 0; if ( shm_obj->size < count ) { 106029: 8b 40 04 mov 0x4(%eax),%eax 10602c: 3b 45 10 cmp 0x10(%ebp),%eax 10602f: 77 1f ja 106050 <_POSIX_Shm_Object_read_from_workspace+0x40><== NEVER TAKEN count = shm_obj->size; } memcpy( buf, shm_obj->handle, count ); 106031: 83 f8 08 cmp $0x8,%eax 106034: 8b 7d 0c mov 0xc(%ebp),%edi 106037: 89 c1 mov %eax,%ecx 106039: 73 22 jae 10605d <_POSIX_Shm_Object_read_from_workspace+0x4d><== ALWAYS TAKEN 10603b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) return count; } 10603d: 8b 75 f8 mov -0x8(%ebp),%esi 106040: 8b 7d fc mov -0x4(%ebp),%edi 106043: 89 ec mov %ebp,%esp 106045: 5d pop %ebp 106046: c3 ret 106047: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10604e: 66 90 xchg %ax,%ax 106050: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED memcpy( buf, shm_obj->handle, count ); 106053: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 106056: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED 106059: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10605b: 72 de jb 10603b <_POSIX_Shm_Object_read_from_workspace+0x2b><== NOT EXECUTED 10605d: f7 c7 01 00 00 00 test $0x1,%edi 106063: 75 3b jne 1060a0 <_POSIX_Shm_Object_read_from_workspace+0x90><== NEVER TAKEN 106065: f7 c7 02 00 00 00 test $0x2,%edi 10606b: 75 43 jne 1060b0 <_POSIX_Shm_Object_read_from_workspace+0xa0><== NEVER TAKEN 10606d: f7 c7 04 00 00 00 test $0x4,%edi 106073: 74 c6 je 10603b <_POSIX_Shm_Object_read_from_workspace+0x2b><== ALWAYS TAKEN 106075: 8b 16 mov (%esi),%edx <== NOT EXECUTED 106077: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 10607a: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 10607d: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 106080: 89 57 fc mov %edx,-0x4(%edi) <== NOT EXECUTED 106083: eb b6 jmp 10603b <_POSIX_Shm_Object_read_from_workspace+0x2b><== NOT EXECUTED 106085: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10608c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED } 106090: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED return 0; 106093: 31 c0 xor %eax,%eax <== NOT EXECUTED } 106095: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 106098: 89 ec mov %ebp,%esp <== NOT EXECUTED 10609a: 5d pop %ebp <== NOT EXECUTED 10609b: c3 ret <== NOT EXECUTED 10609c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memcpy( buf, shm_obj->handle, count ); 1060a0: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED 1060a3: 47 inc %edi <== NOT EXECUTED 1060a4: 46 inc %esi <== NOT EXECUTED 1060a5: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 1060a8: 88 57 ff mov %dl,-0x1(%edi) <== NOT EXECUTED 1060ab: eb b8 jmp 106065 <_POSIX_Shm_Object_read_from_workspace+0x55><== NOT EXECUTED 1060ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 1060b0: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED 1060b3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 1060b6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 1060b9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED 1060bc: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED 1060c0: eb ab jmp 10606d <_POSIX_Shm_Object_read_from_workspace+0x5d><== NOT EXECUTED 1060c2: 90 nop 1060c3: 90 nop 1060c4: 90 nop 1060c5: 90 nop 1060c6: 90 nop 1060c7: 90 nop 1060c8: 90 nop 1060c9: 90 nop 1060ca: 90 nop 1060cb: 90 nop 1060cc: 90 nop 1060cd: 90 nop 1060ce: 90 nop 1060cf: 90 nop =============================================================================== 001049f0 <_POSIX_Shm_Object_resize_from_heap>: int _POSIX_Shm_Object_resize_from_heap( POSIX_Shm_Object *shm_obj, size_t size ) { 1049f0: 55 push %ebp 1049f1: 89 e5 mov %esp,%ebp 1049f3: 83 ec 28 sub $0x28,%esp 1049f6: 89 5d f4 mov %ebx,-0xc(%ebp) 1049f9: 8b 5d 08 mov 0x8(%ebp),%ebx 1049fc: 89 75 f8 mov %esi,-0x8(%ebp) 1049ff: 8b 75 0c mov 0xc(%ebp),%esi 104a02: 89 7d fc mov %edi,-0x4(%ebp) void *p; int err = 0; if ( size < shm_obj->size ) { 104a05: 8b 53 04 mov 0x4(%ebx),%edx /* zero out if shrinking */ p = (void*)((uintptr_t)shm_obj->handle + (uintptr_t)size); 104a08: 8b 03 mov (%ebx),%eax if ( size < shm_obj->size ) { 104a0a: 39 f2 cmp %esi,%edx 104a0c: 77 32 ja 104a40 <_POSIX_Shm_Object_resize_from_heap+0x50><== NEVER TAKEN memset( p, 0, shm_obj->size - size ); } p = realloc( shm_obj->handle, size ); 104a0e: 89 74 24 04 mov %esi,0x4(%esp) 104a12: 89 04 24 mov %eax,(%esp) 104a15: e8 06 5b 00 00 call 10a520 if ( p != NULL ) { 104a1a: 85 c0 test %eax,%eax p = realloc( shm_obj->handle, size ); 104a1c: 89 c7 mov %eax,%edi if ( p != NULL ) { 104a1e: 0f 84 69 01 00 00 je 104b8d <_POSIX_Shm_Object_resize_from_heap+0x19d><== NEVER TAKEN shm_obj->handle = p; 104a24: 89 03 mov %eax,(%ebx) if ( size > shm_obj->size ) { 104a26: 8b 43 04 mov 0x4(%ebx),%eax 104a29: 39 f0 cmp %esi,%eax 104a2b: 72 43 jb 104a70 <_POSIX_Shm_Object_resize_from_heap+0x80><== ALWAYS TAKEN /* initialize added memory */ memset( p, 0, size - shm_obj->size ); } shm_obj->size = size; 104a2d: 89 73 04 mov %esi,0x4(%ebx) int err = 0; 104a30: 31 c0 xor %eax,%eax } else { err = EIO; } return err; } 104a32: 8b 5d f4 mov -0xc(%ebp),%ebx 104a35: 8b 75 f8 mov -0x8(%ebp),%esi 104a38: 8b 7d fc mov -0x4(%ebp),%edi 104a3b: 89 ec mov %ebp,%esp 104a3d: 5d pop %ebp 104a3e: c3 ret 104a3f: 90 nop memset( p, 0, shm_obj->size - size ); 104a40: 8d 3c 30 lea (%eax,%esi,1),%edi <== NOT EXECUTED 104a43: 29 f2 sub %esi,%edx <== NOT EXECUTED 104a45: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED 104a48: 0f 83 b2 00 00 00 jae 104b00 <_POSIX_Shm_Object_resize_from_heap+0x110><== NOT EXECUTED 104a4e: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 104a51: 75 6d jne 104ac0 <_POSIX_Shm_Object_resize_from_heap+0xd0><== NOT EXECUTED 104a53: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 104a56: 75 58 jne 104ab0 <_POSIX_Shm_Object_resize_from_heap+0xc0><== NOT EXECUTED 104a58: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 104a5b: 75 43 jne 104aa0 <_POSIX_Shm_Object_resize_from_heap+0xb0><== NOT EXECUTED p = realloc( shm_obj->handle, size ); 104a5d: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 104a5f: 90 nop <== NOT EXECUTED 104a60: eb ac jmp 104a0e <_POSIX_Shm_Object_resize_from_heap+0x1e><== NOT EXECUTED 104a62: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104a69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memset( p, 0, size - shm_obj->size ); 104a70: 89 f2 mov %esi,%edx 104a72: 29 c2 sub %eax,%edx 104a74: 83 fa 08 cmp $0x8,%edx 104a77: 0f 83 b3 00 00 00 jae 104b30 <_POSIX_Shm_Object_resize_from_heap+0x140><== ALWAYS TAKEN 104a7d: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 104a80: 75 6e jne 104af0 <_POSIX_Shm_Object_resize_from_heap+0x100><== NOT EXECUTED 104a82: f6 c2 02 test $0x2,%dl 104a85: 75 49 jne 104ad0 <_POSIX_Shm_Object_resize_from_heap+0xe0><== NEVER TAKEN 104a87: f6 c2 01 test $0x1,%dl 104a8a: 74 a1 je 104a2d <_POSIX_Shm_Object_resize_from_heap+0x3d><== ALWAYS TAKEN 104a8c: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 104a8f: 90 nop <== NOT EXECUTED 104a90: eb 9b jmp 104a2d <_POSIX_Shm_Object_resize_from_heap+0x3d><== NOT EXECUTED 104a92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104a99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memset( p, 0, shm_obj->size - size ); 104aa0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED p = realloc( shm_obj->handle, size ); 104aa3: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 104aa5: e9 64 ff ff ff jmp 104a0e <_POSIX_Shm_Object_resize_from_heap+0x1e><== NOT EXECUTED 104aaa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED memset( p, 0, shm_obj->size - size ); 104ab0: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 104ab5: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 104ab8: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 104abb: 74 a0 je 104a5d <_POSIX_Shm_Object_resize_from_heap+0x6d><== NOT EXECUTED 104abd: eb e1 jmp 104aa0 <_POSIX_Shm_Object_resize_from_heap+0xb0><== NOT EXECUTED 104abf: 90 nop <== NOT EXECUTED 104ac0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 104ac6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 104ac9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 104acc: 74 8a je 104a58 <_POSIX_Shm_Object_resize_from_heap+0x68><== NOT EXECUTED 104ace: eb e0 jmp 104ab0 <_POSIX_Shm_Object_resize_from_heap+0xc0><== NOT EXECUTED memset( p, 0, size - shm_obj->size ); 104ad0: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 104ad5: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 104ad8: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 104adb: 0f 84 4c ff ff ff je 104a2d <_POSIX_Shm_Object_resize_from_heap+0x3d><== NOT EXECUTED 104ae1: eb a9 jmp 104a8c <_POSIX_Shm_Object_resize_from_heap+0x9c><== NOT EXECUTED 104ae3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104aea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED 104af0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 104af6: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 104af9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 104afc: 74 89 je 104a87 <_POSIX_Shm_Object_resize_from_heap+0x97><== NOT EXECUTED 104afe: eb d0 jmp 104ad0 <_POSIX_Shm_Object_resize_from_heap+0xe0><== NOT EXECUTED memset( p, 0, shm_obj->size - size ); 104b00: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 104b06: 75 48 jne 104b50 <_POSIX_Shm_Object_resize_from_heap+0x160><== NOT EXECUTED 104b08: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 104b0e: 75 70 jne 104b80 <_POSIX_Shm_Object_resize_from_heap+0x190><== NOT EXECUTED 104b10: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 104b16: 75 58 jne 104b70 <_POSIX_Shm_Object_resize_from_heap+0x180><== NOT EXECUTED 104b18: 89 d1 mov %edx,%ecx <== NOT EXECUTED 104b1a: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 104b1d: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED 104b20: 31 c0 xor %eax,%eax <== NOT EXECUTED 104b22: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 104b24: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 104b27: 0f 84 26 ff ff ff je 104a53 <_POSIX_Shm_Object_resize_from_heap+0x63><== NOT EXECUTED 104b2d: eb 91 jmp 104ac0 <_POSIX_Shm_Object_resize_from_heap+0xd0><== NOT EXECUTED 104b2f: 90 nop <== NOT EXECUTED memset( p, 0, size - shm_obj->size ); 104b30: f7 c7 04 00 00 00 test $0x4,%edi 104b36: 75 28 jne 104b60 <_POSIX_Shm_Object_resize_from_heap+0x170><== ALWAYS TAKEN 104b38: 89 d1 mov %edx,%ecx 104b3a: 83 e2 03 and $0x3,%edx 104b3d: c1 e9 02 shr $0x2,%ecx 104b40: 31 c0 xor %eax,%eax 104b42: f3 ab rep stos %eax,%es:(%edi) 104b44: f6 c2 04 test $0x4,%dl 104b47: 0f 84 35 ff ff ff je 104a82 <_POSIX_Shm_Object_resize_from_heap+0x92><== ALWAYS TAKEN 104b4d: eb a1 jmp 104af0 <_POSIX_Shm_Object_resize_from_heap+0x100><== NOT EXECUTED 104b4f: 90 nop <== NOT EXECUTED memset( p, 0, shm_obj->size - size ); 104b50: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 104b53: 4a dec %edx <== NOT EXECUTED 104b54: 47 inc %edi <== NOT EXECUTED 104b55: eb b1 jmp 104b08 <_POSIX_Shm_Object_resize_from_heap+0x118><== NOT EXECUTED 104b57: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104b5e: 66 90 xchg %ax,%ax <== NOT EXECUTED memset( p, 0, size - shm_obj->size ); 104b60: c7 07 00 00 00 00 movl $0x0,(%edi) 104b66: 83 ea 04 sub $0x4,%edx 104b69: 83 c7 04 add $0x4,%edi 104b6c: eb ca jmp 104b38 <_POSIX_Shm_Object_resize_from_heap+0x148> 104b6e: 66 90 xchg %ax,%ax memset( p, 0, shm_obj->size - size ); 104b70: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 104b76: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED 104b79: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 104b7c: eb 9a jmp 104b18 <_POSIX_Shm_Object_resize_from_heap+0x128><== NOT EXECUTED 104b7e: 66 90 xchg %ax,%ax <== NOT EXECUTED 104b80: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 104b85: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 104b88: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 104b8b: eb 83 jmp 104b10 <_POSIX_Shm_Object_resize_from_heap+0x120><== NOT EXECUTED err = EIO; 104b8d: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED return err; 104b92: e9 9b fe ff ff jmp 104a32 <_POSIX_Shm_Object_resize_from_heap+0x42><== NOT EXECUTED 104b97: 90 nop 104b98: 90 nop 104b99: 90 nop 104b9a: 90 nop 104b9b: 90 nop 104b9c: 90 nop 104b9d: 90 nop 104b9e: 90 nop 104b9f: 90 nop =============================================================================== 00105e30 <_POSIX_Shm_Object_resize_from_workspace>: int _POSIX_Shm_Object_resize_from_workspace( POSIX_Shm_Object *shm_obj, size_t size ) { 105e30: 55 push %ebp 105e31: 89 e5 mov %esp,%ebp 105e33: 83 ec 28 sub $0x28,%esp 105e36: 89 75 f8 mov %esi,-0x8(%ebp) 105e39: 8b 75 0c mov 0xc(%ebp),%esi 105e3c: 89 5d f4 mov %ebx,-0xc(%ebp) 105e3f: 8b 5d 08 mov 0x8(%ebp),%ebx 105e42: 89 7d fc mov %edi,-0x4(%ebp) int err; if ( size == 0 ) { 105e45: 85 f6 test %esi,%esi memset( shm_obj->handle, 0, shm_obj->size ); 105e47: 8b 3b mov (%ebx),%edi if ( size == 0 ) { 105e49: 0f 84 81 00 00 00 je 105ed0 <_POSIX_Shm_Object_resize_from_workspace+0xa0><== NEVER TAKEN err = _POSIX_Shm_Object_delete_from_workspace( shm_obj ); } else if ( shm_obj->handle == NULL && shm_obj->size == 0 ) { 105e4f: 85 ff test %edi,%edi err = _POSIX_Shm_Object_create_from_workspace( shm_obj, size ); } else { /* Refuse to resize a workspace object. */ err = EIO; 105e51: b8 05 00 00 00 mov $0x5,%eax } else if ( shm_obj->handle == NULL && shm_obj->size == 0 ) { 105e56: 74 18 je 105e70 <_POSIX_Shm_Object_resize_from_workspace+0x40><== ALWAYS TAKEN } return err; } 105e58: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED 105e5b: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 105e5e: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 105e61: 89 ec mov %ebp,%esp <== NOT EXECUTED 105e63: 5d pop %ebp <== NOT EXECUTED 105e64: c3 ret <== NOT EXECUTED 105e65: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105e6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED } else if ( shm_obj->handle == NULL && shm_obj->size == 0 ) { 105e70: 8b 53 04 mov 0x4(%ebx),%edx 105e73: 85 d2 test %edx,%edx 105e75: 75 e1 jne 105e58 <_POSIX_Shm_Object_resize_from_workspace+0x28><== NEVER TAKEN shm_obj->handle = _Workspace_Allocate( size ); 105e77: 89 34 24 mov %esi,(%esp) 105e7a: e8 d1 41 00 00 call 10a050 <_Workspace_Allocate> 105e7f: 89 03 mov %eax,(%ebx) if ( shm_obj->handle == NULL ) { 105e81: 85 c0 test %eax,%eax shm_obj->handle = _Workspace_Allocate( size ); 105e83: 89 c7 mov %eax,%edi if ( shm_obj->handle == NULL ) { 105e85: 0f 84 15 01 00 00 je 105fa0 <_POSIX_Shm_Object_resize_from_workspace+0x170><== NEVER TAKEN memset( shm_obj->handle, 0, size ); 105e8b: 83 fe 08 cmp $0x8,%esi 105e8e: 89 f2 mov %esi,%edx 105e90: 0f 83 da 00 00 00 jae 105f70 <_POSIX_Shm_Object_resize_from_workspace+0x140><== ALWAYS TAKEN 105e96: f6 c2 04 test $0x4,%dl 105e99: 74 09 je 105ea4 <_POSIX_Shm_Object_resize_from_workspace+0x74><== ALWAYS TAKEN 105e9b: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 105ea1: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 105ea4: f6 c2 02 test $0x2,%dl 105ea7: 74 08 je 105eb1 <_POSIX_Shm_Object_resize_from_workspace+0x81><== ALWAYS TAKEN 105ea9: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105eae: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105eb1: f6 c2 01 test $0x1,%dl 105eb4: 74 03 je 105eb9 <_POSIX_Shm_Object_resize_from_workspace+0x89><== ALWAYS TAKEN 105eb6: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED shm_obj->size = size; 105eb9: 89 73 04 mov %esi,0x4(%ebx) } 105ebc: 8b 7d fc mov -0x4(%ebp),%edi return 0; 105ebf: 31 c0 xor %eax,%eax } 105ec1: 8b 5d f4 mov -0xc(%ebp),%ebx 105ec4: 8b 75 f8 mov -0x8(%ebp),%esi 105ec7: 89 ec mov %ebp,%esp 105ec9: 5d pop %ebp 105eca: c3 ret 105ecb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 105ecf: 90 nop memset( shm_obj->handle, 0, shm_obj->size ); 105ed0: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 105ed3: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED 105ed6: 73 68 jae 105f40 <_POSIX_Shm_Object_resize_from_workspace+0x110><== NOT EXECUTED 105ed8: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 105edb: 75 53 jne 105f30 <_POSIX_Shm_Object_resize_from_workspace+0x100><== NOT EXECUTED 105edd: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 105ee0: 75 3e jne 105f20 <_POSIX_Shm_Object_resize_from_workspace+0xf0><== NOT EXECUTED 105ee2: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 105ee5: 75 29 jne 105f10 <_POSIX_Shm_Object_resize_from_workspace+0xe0><== NOT EXECUTED _Workspace_Free( shm_obj->handle ); 105ee7: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 105ee9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105eec: e8 8f 41 00 00 call 10a080 <_Workspace_Free> <== NOT EXECUTED } 105ef1: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED err = _POSIX_Shm_Object_delete_from_workspace( shm_obj ); 105ef4: 31 c0 xor %eax,%eax <== NOT EXECUTED shm_obj->handle = NULL; 105ef6: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED } 105efc: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED shm_obj->size = 0; 105eff: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED } 105f06: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED 105f09: 89 ec mov %ebp,%esp <== NOT EXECUTED 105f0b: 5d pop %ebp <== NOT EXECUTED 105f0c: c3 ret <== NOT EXECUTED 105f0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED memset( shm_obj->handle, 0, shm_obj->size ); 105f10: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 105f13: eb d2 jmp 105ee7 <_POSIX_Shm_Object_resize_from_workspace+0xb7><== NOT EXECUTED 105f15: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105f1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105f20: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105f25: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105f28: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 105f2b: 74 ba je 105ee7 <_POSIX_Shm_Object_resize_from_workspace+0xb7><== NOT EXECUTED 105f2d: eb e1 jmp 105f10 <_POSIX_Shm_Object_resize_from_workspace+0xe0><== NOT EXECUTED 105f2f: 90 nop <== NOT EXECUTED 105f30: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 105f36: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 105f39: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 105f3c: 74 a4 je 105ee2 <_POSIX_Shm_Object_resize_from_workspace+0xb2><== NOT EXECUTED 105f3e: eb e0 jmp 105f20 <_POSIX_Shm_Object_resize_from_workspace+0xf0><== NOT EXECUTED 105f40: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 105f46: 75 78 jne 105fc0 <_POSIX_Shm_Object_resize_from_workspace+0x190><== NOT EXECUTED 105f48: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 105f4e: 75 60 jne 105fb0 <_POSIX_Shm_Object_resize_from_workspace+0x180><== NOT EXECUTED 105f50: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 105f56: 75 78 jne 105fd0 <_POSIX_Shm_Object_resize_from_workspace+0x1a0><== NOT EXECUTED 105f58: 89 d1 mov %edx,%ecx <== NOT EXECUTED 105f5a: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 105f5d: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED 105f60: 31 c0 xor %eax,%eax <== NOT EXECUTED 105f62: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 105f64: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 105f67: 0f 84 70 ff ff ff je 105edd <_POSIX_Shm_Object_resize_from_workspace+0xad><== NOT EXECUTED 105f6d: eb c1 jmp 105f30 <_POSIX_Shm_Object_resize_from_workspace+0x100><== NOT EXECUTED 105f6f: 90 nop <== NOT EXECUTED memset( shm_obj->handle, 0, size ); 105f70: a8 01 test $0x1,%al 105f72: 0f 85 84 00 00 00 jne 105ffc <_POSIX_Shm_Object_resize_from_workspace+0x1cc><== NEVER TAKEN 105f78: f7 c7 02 00 00 00 test $0x2,%edi 105f7e: 66 90 xchg %ax,%ax 105f80: 75 6d jne 105fef <_POSIX_Shm_Object_resize_from_workspace+0x1bf><== NEVER TAKEN 105f82: f7 c7 04 00 00 00 test $0x4,%edi 105f88: 75 57 jne 105fe1 <_POSIX_Shm_Object_resize_from_workspace+0x1b1><== ALWAYS TAKEN 105f8a: 89 d1 mov %edx,%ecx 105f8c: 31 c0 xor %eax,%eax 105f8e: c1 e9 02 shr $0x2,%ecx 105f91: 83 e2 03 and $0x3,%edx 105f94: f3 ab rep stos %eax,%es:(%edi) 105f96: e9 fb fe ff ff jmp 105e96 <_POSIX_Shm_Object_resize_from_workspace+0x66> 105f9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 105f9f: 90 nop return ENOMEM; 105fa0: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED return err; 105fa5: e9 ae fe ff ff jmp 105e58 <_POSIX_Shm_Object_resize_from_workspace+0x28><== NOT EXECUTED 105faa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED memset( shm_obj->handle, 0, shm_obj->size ); 105fb0: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105fb5: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 105fb8: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105fbb: eb 93 jmp 105f50 <_POSIX_Shm_Object_resize_from_workspace+0x120><== NOT EXECUTED 105fbd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 105fc0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 105fc3: 4a dec %edx <== NOT EXECUTED 105fc4: 47 inc %edi <== NOT EXECUTED 105fc5: eb 81 jmp 105f48 <_POSIX_Shm_Object_resize_from_workspace+0x118><== NOT EXECUTED 105fc7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105fce: 66 90 xchg %ax,%ax <== NOT EXECUTED 105fd0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 105fd6: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED 105fd9: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 105fdc: e9 77 ff ff ff jmp 105f58 <_POSIX_Shm_Object_resize_from_workspace+0x128><== NOT EXECUTED memset( shm_obj->handle, 0, size ); 105fe1: c7 07 00 00 00 00 movl $0x0,(%edi) 105fe7: 83 ea 04 sub $0x4,%edx 105fea: 83 c7 04 add $0x4,%edi 105fed: eb 9b jmp 105f8a <_POSIX_Shm_Object_resize_from_workspace+0x15a> 105fef: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105ff4: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 105ff7: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 105ffa: eb 86 jmp 105f82 <_POSIX_Shm_Object_resize_from_workspace+0x152><== NOT EXECUTED 105ffc: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 105fff: 8d 56 ff lea -0x1(%esi),%edx <== NOT EXECUTED 106002: 47 inc %edi <== NOT EXECUTED 106003: e9 70 ff ff ff jmp 105f78 <_POSIX_Shm_Object_resize_from_workspace+0x148><== NOT EXECUTED 106008: 90 nop 106009: 90 nop 10600a: 90 nop 10600b: 90 nop 10600c: 90 nop 10600d: 90 nop 10600e: 90 nop 10600f: 90 nop =============================================================================== 00106a70 <_POSIX_Threads_Sporadic_budget_callout>: { 106a70: 55 push %ebp 106a71: 89 e5 mov %esp,%ebp 106a73: 83 ec 48 sub $0x48,%esp 106a76: 89 5d f8 mov %ebx,-0x8(%ebp) 106a79: 8b 5d 08 mov 0x8(%ebp),%ebx 106a7c: 89 75 fc mov %esi,-0x4(%ebp) 106a7f: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 106a86: 8b 83 0c 01 00 00 mov 0x10c(%ebx),%eax _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 106a8c: 9c pushf 106a8d: fa cli 106a8e: 5a pop %edx 106a8f: 89 55 d4 mov %edx,-0x2c(%ebp) if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) { 106a92: 83 78 2c ff cmpl $0xffffffff,0x2c(%eax) the_thread->cpu_time_budget = UINT32_MAX; 106a96: ba ff ff ff ff mov $0xffffffff,%edx 106a9b: 89 93 84 00 00 00 mov %edx,0x84(%ebx) */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_node_off_tree( const RBTree_Node *the_node ) { return RB_COLOR( the_node, Node ) == -1; 106aa1: 8d 75 d4 lea -0x2c(%ebp),%esi if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) { 106aa4: 74 1a je 106ac0 <_POSIX_Threads_Sporadic_budget_callout+0x50><== ALWAYS TAKEN _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 106aa6: ff 75 d4 push -0x2c(%ebp) 106aa9: 9d popf _Thread_Priority_update( &queue_context ); 106aaa: 89 34 24 mov %esi,(%esp) 106aad: e8 0e 2c 00 00 call 1096c0 <_Thread_Priority_update> } 106ab2: 8b 5d f8 mov -0x8(%ebp),%ebx 106ab5: 8b 75 fc mov -0x4(%ebp),%esi 106ab8: 89 ec mov %ebp,%esp 106aba: 5d pop %ebp 106abb: c3 ret 106abc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi _Thread_Priority_add( 106ac0: 89 74 24 08 mov %esi,0x8(%esp) 106ac4: 83 c0 20 add $0x20,%eax 106ac7: 89 44 24 04 mov %eax,0x4(%esp) 106acb: 89 1c 24 mov %ebx,(%esp) 106ace: e8 ed 2a 00 00 call 1095c0 <_Thread_Priority_add> _Thread_Priority_remove( 106ad3: 8d 43 20 lea 0x20(%ebx),%eax 106ad6: 89 74 24 08 mov %esi,0x8(%esp) 106ada: 89 44 24 04 mov %eax,0x4(%esp) 106ade: 89 1c 24 mov %ebx,(%esp) 106ae1: e8 5a 2b 00 00 call 109640 <_Thread_Priority_remove> 106ae6: eb be jmp 106aa6 <_POSIX_Threads_Sporadic_budget_callout+0x36> 106ae8: 90 nop 106ae9: 90 nop 106aea: 90 nop 106aeb: 90 nop 106aec: 90 nop 106aed: 90 nop 106aee: 90 nop 106aef: 90 nop =============================================================================== 001065b0 <_POSIX_Threads_Sporadic_timer>: { 1065b0: 55 push %ebp 1065b1: 89 e5 mov %esp,%ebp 1065b3: 83 ec 58 sub $0x58,%esp 1065b6: 89 7d fc mov %edi,-0x4(%ebp) 1065b9: 8b 7d 08 mov 0x8(%ebp),%edi 1065bc: 89 5d f4 mov %ebx,-0xc(%ebp) 1065bf: 89 75 f8 mov %esi,-0x8(%ebp) queue_context->Priority.update_count = 0; 1065c2: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) the_thread = api->Sporadic.thread; 1065c9: 8b 77 fc mov -0x4(%edi),%esi api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer ); 1065cc: 8d 5f fc lea -0x4(%edi),%ebx RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire( Thread_Control *the_thread, Thread_queue_Context *queue_context ) { _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 1065cf: 9c pushf 1065d0: fa cli 1065d1: 58 pop %eax 1065d2: 89 45 c4 mov %eax,-0x3c(%ebp) if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) { 1065d5: 83 7b 2c ff cmpl $0xffffffff,0x2c(%ebx) 1065d9: 74 33 je 10660e <_POSIX_Threads_Sporadic_timer+0x5e> _Thread_Priority_add( 1065db: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 1065de: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED _Thread_Priority_remove( 1065e1: 83 c7 1c add $0x1c,%edi <== NOT EXECUTED _Thread_Priority_add( 1065e4: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1065e8: 8d 46 20 lea 0x20(%esi),%eax <== NOT EXECUTED 1065eb: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1065ef: e8 cc 2f 00 00 call 1095c0 <_Thread_Priority_add> <== NOT EXECUTED _Thread_Priority_remove( 1065f4: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 1065f7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1065fb: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 1065ff: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 106602: e8 39 30 00 00 call 109640 <_Thread_Priority_remove> <== NOT EXECUTED 106607: c7 43 2c ff ff ff ff movl $0xffffffff,0x2c(%ebx) 10660e: c7 04 24 90 92 1a 00 movl $0x1a9290,(%esp) _Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer ); 106615: 8d 7b 04 lea 0x4(%ebx),%edi 106618: 89 7c 24 04 mov %edi,0x4(%esp) 10661c: e8 0f 56 00 00 call 10bc30 <_Watchdog_Remove> Thread_Control *the_thread, POSIX_API_Control *api ) { the_thread->cpu_time_budget = _Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget ); 106621: 8d 43 44 lea 0x44(%ebx),%eax _Watchdog_Per_CPU_insert_ticks( &api->Sporadic.Timer, _Per_CPU_Get(), _Timespec_To_ticks( &api->Sporadic.sched_ss_repl_period ) 106624: 83 c3 38 add $0x38,%ebx _Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget ); 106627: 89 04 24 mov %eax,(%esp) 10662a: e8 01 51 00 00 call 10b730 <_Timespec_To_ticks> the_thread->cpu_time_budget = 10662f: 89 86 84 00 00 00 mov %eax,0x84(%esi) _Timespec_To_ticks( &api->Sporadic.sched_ss_repl_period ) 106635: 89 1c 24 mov %ebx,(%esp) _Watchdog_Per_CPU_insert_ticks( 106638: e8 f3 50 00 00 call 10b730 <_Timespec_To_ticks> expire = ticks + cpu->Watchdog.ticks; 10663d: 31 d2 xor %edx,%edx _Watchdog_Insert(header, the_watchdog, expire); 10663f: 89 7c 24 04 mov %edi,0x4(%esp) 106643: c7 04 24 90 92 1a 00 movl $0x1a9290,(%esp) expire = ticks + cpu->Watchdog.ticks; 10664a: 03 05 88 92 1a 00 add 0x1a9288,%eax 106650: 13 15 8c 92 1a 00 adc 0x1a928c,%edx _Watchdog_Insert(header, the_watchdog, expire); 106656: 89 44 24 08 mov %eax,0x8(%esp) 10665a: 89 54 24 0c mov %edx,0xc(%esp) 10665e: e8 2d 55 00 00 call 10bb90 <_Watchdog_Insert> Thread_Control *the_thread, Thread_queue_Context *queue_context ) { _Thread_Wait_release_critical( the_thread, queue_context ); _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 106663: ff 75 c4 push -0x3c(%ebp) 106666: 9d popf _Thread_Priority_update( &queue_context ); 106667: 8d 45 c4 lea -0x3c(%ebp),%eax 10666a: 89 04 24 mov %eax,(%esp) 10666d: e8 4e 30 00 00 call 1096c0 <_Thread_Priority_update> } 106672: 8b 5d f4 mov -0xc(%ebp),%ebx 106675: 8b 75 f8 mov -0x8(%ebp),%esi 106678: 8b 7d fc mov -0x4(%ebp),%edi 10667b: 89 ec mov %ebp,%esp 10667d: 5d pop %ebp 10667e: c3 ret 10667f: 90 nop =============================================================================== 0010d4e0 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Watchdog_Control *the_watchdog ) { 10d4e0: 55 push %ebp 10d4e1: 89 e5 mov %esp,%ebp 10d4e3: 83 ec 28 sub $0x28,%esp 10d4e6: 89 5d f4 mov %ebx,-0xc(%ebp) POSIX_Timer_Control *ptimer; ISR_lock_Context lock_context; Per_CPU_Control *cpu; ptimer = RTEMS_CONTAINER_OF( the_watchdog, POSIX_Timer_Control, Timer ); 10d4e9: 8b 45 08 mov 0x8(%ebp),%eax { 10d4ec: 89 75 f8 mov %esi,-0x8(%ebp) 10d4ef: 89 7d fc mov %edi,-0x4(%ebp) ptimer = RTEMS_CONTAINER_OF( the_watchdog, POSIX_Timer_Control, Timer ); 10d4f2: 8d 58 f0 lea -0x10(%eax),%ebx _ISR_lock_ISR_disable( &lock_context ); 10d4f5: 9c pushf 10d4f6: fa cli 10d4f7: 5e pop %esi /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10d4f8: 8b 43 4c mov 0x4c(%ebx),%eax ptimer->overrun = ptimer->overrun + 1; 10d4fb: ff 43 64 incl 0x64(%ebx) if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10d4fe: 0b 43 48 or 0x48(%ebx),%eax 10d501: 75 07 jne 10d50a <_POSIX_Timer_TSR+0x2a> 10d503: 8b 43 50 mov 0x50(%ebx),%eax 10d506: 85 c0 test %eax,%eax 10d508: 74 66 je 10d570 <_POSIX_Timer_TSR+0x90> <== NEVER TAKEN ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10d50a: c6 43 30 03 movb $0x3,0x30(%ebx) ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { _POSIX_Timer_Insert( ptimer, cpu, ptimer->ticks ); 10d50e: 8b 7b 60 mov 0x60(%ebx),%edi _TOD_Get( &ptimer->time ); 10d511: 8d 43 68 lea 0x68(%ebx),%eax 10d514: 89 04 24 mov %eax,(%esp) _Timecounter_Nanotime( tod ); 10d517: e8 34 b5 ff ff call 108a50 <_Timecounter_Nanotime> _Watchdog_Insert( 10d51c: 31 d2 xor %edx,%edx 10d51e: c7 04 24 50 bb 13 00 movl $0x13bb50,(%esp) 10d525: 89 f8 mov %edi,%eax 10d527: 03 05 48 bb 13 00 add 0x13bb48,%eax 10d52d: 13 15 4c bb 13 00 adc 0x13bb4c,%edx 10d533: 89 44 24 08 mov %eax,0x8(%esp) 10d537: 8d 43 10 lea 0x10(%ebx),%eax 10d53a: 89 44 24 04 mov %eax,0x4(%esp) 10d53e: 89 54 24 0c mov %edx,0xc(%esp) 10d542: e8 b9 f1 ff ff call 10c700 <_Watchdog_Insert> Per_CPU_Control *cpu, ISR_lock_Context *lock_context ) { _Watchdog_Per_CPU_release_critical( cpu, lock_context ); _ISR_lock_ISR_enable( lock_context ); 10d547: 56 push %esi 10d548: 9d popf /* * 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 ) ) { 10d549: 8b 43 38 mov 0x38(%ebx),%eax 10d54c: 89 44 24 04 mov %eax,0x4(%esp) 10d550: 8b 43 2c mov 0x2c(%ebx),%eax 10d553: 89 04 24 mov %eax,(%esp) 10d556: e8 85 25 00 00 call 10fae0 /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; } 10d55b: 8b 75 f8 mov -0x8(%ebp),%esi ptimer->overrun = 0; 10d55e: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) } 10d565: 8b 7d fc mov -0x4(%ebp),%edi 10d568: 8b 5d f4 mov -0xc(%ebp),%ebx 10d56b: 89 ec mov %ebp,%esp 10d56d: 5d pop %ebp 10d56e: c3 ret 10d56f: 90 nop ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10d570: c6 43 30 04 movb $0x4,0x30(%ebx) <== NOT EXECUTED 10d574: eb d1 jmp 10d547 <_POSIX_Timer_TSR+0x67> <== NOT EXECUTED 10d576: 90 nop 10d577: 90 nop 10d578: 90 nop 10d579: 90 nop 10d57a: 90 nop 10d57b: 90 nop 10d57c: 90 nop 10d57d: 90 nop 10d57e: 90 nop 10d57f: 90 nop =============================================================================== 0011b700 <_POSIX_signals_Clear_process_signals>: #include void _POSIX_signals_Clear_process_signals( int signo ) { 11b700: 55 push %ebp 11b701: b8 01 00 00 00 mov $0x1,%eax 11b706: 89 e5 mov %esp,%ebp 11b708: 8b 55 08 mov 0x8(%ebp),%edx 11b70b: 8d 4a ff lea -0x1(%edx),%ecx _Assert( _ISR_Get_level() != 0 ); clear_signal = true; mask = signo_to_mask( signo ); if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 11b70e: 8d 14 52 lea (%edx,%edx,2),%edx 11b711: d3 e0 shl %cl,%eax 11b713: 83 3c 95 80 50 14 00 cmpl $0x2,0x145080(,%edx,4) 11b71a: 02 11b71b: 74 13 je 11b730 <_POSIX_signals_Clear_process_signals+0x30> } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; } } 11b71d: 5d pop %ebp _POSIX_signals_Pending &= ~mask; 11b71e: f7 d0 not %eax 11b720: 21 05 00 52 14 00 and %eax,0x145200 } 11b726: c3 ret 11b727: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b72e: 66 90 xchg %ax,%ax 11b730: 8d 0c 95 00 00 00 00 lea 0x0(,%edx,4),%ecx return &the_chain->Tail.Node; 11b737: 8d 91 e4 4e 14 00 lea 0x144ee4(%ecx),%edx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 11b73d: 39 91 e0 4e 14 00 cmp %edx,0x144ee0(%ecx) 11b743: 74 d8 je 11b71d <_POSIX_signals_Clear_process_signals+0x1d><== ALWAYS TAKEN } 11b745: 5d pop %ebp <== NOT EXECUTED 11b746: c3 ret <== NOT EXECUTED 11b747: 90 nop 11b748: 90 nop 11b749: 90 nop 11b74a: 90 nop 11b74b: 90 nop 11b74c: 90 nop 11b74d: 90 nop 11b74e: 90 nop 11b74f: 90 nop =============================================================================== 0011b750 <_POSIX_signals_Clear_signals>: siginfo_t *info, bool is_global, bool check_blocked, bool do_signals_acquire_release ) { 11b750: 55 push %ebp 11b751: b8 01 00 00 00 mov $0x1,%eax 11b756: 89 e5 mov %esp,%ebp 11b758: 83 ec 38 sub $0x38,%esp 11b75b: 89 75 f8 mov %esi,-0x8(%ebp) 11b75e: 8b 75 0c mov 0xc(%ebp),%esi 11b761: 89 5d f4 mov %ebx,-0xc(%ebp) 11b764: 0f b6 55 14 movzbl 0x14(%ebp),%edx 11b768: 89 7d fc mov %edi,-0x4(%ebp) 11b76b: 0f b6 5d 1c movzbl 0x1c(%ebp),%ebx 11b76f: bf ff ff ff ff mov $0xffffffff,%edi 11b774: 8d 4e ff lea -0x1(%esi),%ecx 11b777: d3 e0 shl %cl,%eax /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 11b779: 80 7d 18 00 cmpb $0x0,0x18(%ebp) 11b77d: 89 c1 mov %eax,%ecx 11b77f: 74 06 je 11b787 <_POSIX_signals_Clear_signals+0x37> signals_unblocked = api->signals_unblocked; 11b781: 8b 45 08 mov 0x8(%ebp),%eax 11b784: 8b 78 54 mov 0x54(%eax),%edi signals_unblocked = SIGNAL_ALL_MASK; /* XXX is this right for siginfo type signals? */ /* XXX are we sure they can be cleared the same way? */ if ( do_signals_acquire_release ) { 11b787: 84 db test %bl,%bl 11b789: 74 06 je 11b791 <_POSIX_signals_Clear_signals+0x41> _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 11b78b: 9c pushf 11b78c: fa cli 11b78d: 58 pop %eax 11b78e: 89 45 e4 mov %eax,-0x1c(%ebp) _Thread_queue_Context_initialize( &queue_context ); _POSIX_signals_Acquire( &queue_context ); } if ( is_global ) { 11b791: 84 d2 test %dl,%dl 11b793: 74 2b je 11b7c0 <_POSIX_signals_Clear_signals+0x70> if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) { 11b795: a1 00 52 14 00 mov 0x145200,%eax 11b79a: 21 c1 and %eax,%ecx do_callout = false; 11b79c: 31 c0 xor %eax,%eax if ( mask & (_POSIX_signals_Pending & signals_unblocked) ) { 11b79e: 85 f9 test %edi,%ecx 11b7a0: 75 3e jne 11b7e0 <_POSIX_signals_Clear_signals+0x90> api->signals_pending &= ~mask; do_callout = true; } } if ( do_signals_acquire_release ) { 11b7a2: 84 db test %bl,%bl 11b7a4: 74 04 je 11b7aa <_POSIX_signals_Clear_signals+0x5a> _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 11b7a6: ff 75 e4 push -0x1c(%ebp) 11b7a9: 9d popf _POSIX_signals_Release( &queue_context ); } return do_callout; } 11b7aa: 8b 5d f4 mov -0xc(%ebp),%ebx 11b7ad: 8b 75 f8 mov -0x8(%ebp),%esi 11b7b0: 8b 7d fc mov -0x4(%ebp),%edi 11b7b3: 89 ec mov %ebp,%esp 11b7b5: 5d pop %ebp 11b7b6: c3 ret 11b7b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b7be: 66 90 xchg %ax,%ax if ( mask & (api->signals_pending & signals_unblocked) ) { 11b7c0: 8b 45 08 mov 0x8(%ebp),%eax 11b7c3: 8b 50 58 mov 0x58(%eax),%edx do_callout = false; 11b7c6: 31 c0 xor %eax,%eax if ( mask & (api->signals_pending & signals_unblocked) ) { 11b7c8: 89 d6 mov %edx,%esi 11b7ca: 21 ce and %ecx,%esi 11b7cc: 85 fe test %edi,%esi 11b7ce: 74 d2 je 11b7a2 <_POSIX_signals_Clear_signals+0x52> api->signals_pending &= ~mask; 11b7d0: 8b 45 08 mov 0x8(%ebp),%eax 11b7d3: f7 d1 not %ecx 11b7d5: 21 ca and %ecx,%edx 11b7d7: 89 50 58 mov %edx,0x58(%eax) do_callout = true; 11b7da: b0 01 mov $0x1,%al 11b7dc: eb c4 jmp 11b7a2 <_POSIX_signals_Clear_signals+0x52> 11b7de: 66 90 xchg %ax,%ax if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 11b7e0: 8d 0c 76 lea (%esi,%esi,2),%ecx 11b7e3: 83 3c 8d 80 50 14 00 cmpl $0x2,0x145080(,%ecx,4) 11b7ea: 02 11b7eb: 8d 04 8d 00 00 00 00 lea 0x0(,%ecx,4),%eax 11b7f2: 74 1c je 11b810 <_POSIX_signals_Clear_signals+0xc0> _POSIX_signals_Clear_process_signals( signo ); 11b7f4: 89 34 24 mov %esi,(%esp) 11b7f7: 88 55 e0 mov %dl,-0x20(%ebp) 11b7fa: e8 01 ff ff ff call 11b700 <_POSIX_signals_Clear_process_signals> do_callout = true; 11b7ff: 0f b6 55 e0 movzbl -0x20(%ebp),%edx 11b803: 88 d0 mov %dl,%al 11b805: eb 9b jmp 11b7a2 <_POSIX_signals_Clear_signals+0x52> 11b807: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b80e: 66 90 xchg %ax,%ax _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); 11b810: 8d b8 e0 4e 14 00 lea 0x144ee0(%eax),%edi 11b816: 89 7d e0 mov %edi,-0x20(%ebp) return _Chain_Immutable_head( the_chain )->next; 11b819: 8b b8 e0 4e 14 00 mov 0x144ee0(%eax),%edi return &the_chain->Tail.Node; 11b81f: 8d 88 e4 4e 14 00 lea 0x144ee4(%eax),%ecx if ( !_Chain_Is_empty(the_chain)) 11b825: 39 cf cmp %ecx,%edi 11b827: 74 57 je 11b880 <_POSIX_signals_Clear_signals+0x130> 11b829: 88 55 df mov %dl,-0x21(%ebp) new_first = old_first->next; 11b82c: 8b 0f mov (%edi),%ecx head->next = new_first; 11b82e: 89 88 e0 4e 14 00 mov %ecx,0x144ee0(%eax) new_first->previous = head; 11b834: 8b 45 e0 mov -0x20(%ebp),%eax 11b837: 89 41 04 mov %eax,0x4(%ecx) _POSIX_signals_Clear_process_signals( signo ); 11b83a: 89 34 24 mov %esi,(%esp) 11b83d: e8 be fe ff ff call 11b700 <_POSIX_signals_Clear_process_signals> *info = psiginfo->Info; 11b842: 8b 47 08 mov 0x8(%edi),%eax 11b845: 8b 55 10 mov 0x10(%ebp),%edx 11b848: 89 02 mov %eax,(%edx) 11b84a: 8b 47 0c mov 0xc(%edi),%eax 11b84d: 89 42 04 mov %eax,0x4(%edx) 11b850: 8b 47 10 mov 0x10(%edi),%eax 11b853: 89 42 08 mov %eax,0x8(%edx) old_last = tail->previous; 11b856: a1 68 50 14 00 mov 0x145068,%eax the_node->next = tail; 11b85b: c7 07 64 50 14 00 movl $0x145064,(%edi) the_node->previous = old_last; 11b861: 0f b6 55 df movzbl -0x21(%ebp),%edx tail->previous = the_node; 11b865: 89 3d 68 50 14 00 mov %edi,0x145068 old_last->next = the_node; 11b86b: 89 38 mov %edi,(%eax) the_node->previous = old_last; 11b86d: 89 47 04 mov %eax,0x4(%edi) } 11b870: eb 82 jmp 11b7f4 <_POSIX_signals_Clear_signals+0xa4> 11b872: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b879: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi _POSIX_signals_Clear_process_signals( signo ); 11b880: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 11b883: 88 55 e0 mov %dl,-0x20(%ebp) <== NOT EXECUTED 11b886: e8 75 fe ff ff call 11b700 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED if ( psiginfo ) { 11b88b: 0f b6 55 e0 movzbl -0x20(%ebp),%edx 11b88f: e9 60 ff ff ff jmp 11b7f4 <_POSIX_signals_Clear_signals+0xa4> 11b894: 90 nop 11b895: 90 nop 11b896: 90 nop 11b897: 90 nop 11b898: 90 nop 11b899: 90 nop 11b89a: 90 nop 11b89b: 90 nop 11b89c: 90 nop 11b89d: 90 nop 11b89e: 90 nop 11b89f: 90 nop =============================================================================== 0011b300 <_POSIX_signals_Send>: int _POSIX_signals_Send( pid_t pid, int sig, const union sigval *value ) { 11b300: 55 push %ebp 11b301: 89 e5 mov %esp,%ebp 11b303: 57 push %edi 11b304: 56 push %esi 11b305: 53 push %ebx 11b306: 83 ec 4c sub $0x4c,%esp 11b309: 8b 75 08 mov 0x8(%ebp),%esi 11b30c: 8b 7d 0c mov 0xc(%ebp),%edi 11b30f: 8b 5d 10 mov 0x10(%ebp),%ebx Per_CPU_Control *cpu_self; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 11b312: e8 09 5b fe ff call 100e20 11b317: 39 f0 cmp %esi,%eax 11b319: 0f 85 f9 02 00 00 jne 11b618 <_POSIX_signals_Send+0x318> rtems_set_errno_and_return_minus_one( ESRCH ); /* * Validate the signal passed. */ if ( !sig ) 11b31f: 85 ff test %edi,%edi 11b321: 0f 84 dc 02 00 00 je 11b603 <_POSIX_signals_Send+0x303> static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 11b327: 8d 4f ff lea -0x1(%edi),%ecx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 11b32a: 83 f9 1f cmp $0x1f,%ecx 11b32d: 0f 87 d0 02 00 00 ja 11b603 <_POSIX_signals_Send+0x303> rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 11b333: 8d 04 7f lea (%edi,%edi,2),%eax 11b336: 83 3c 85 88 50 14 00 cmpl $0x1,0x145088(,%eax,4) 11b33d: 01 11b33e: 0f 84 6c 01 00 00 je 11b4b0 <_POSIX_signals_Send+0x1b0> /* * 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 ) ) 11b344: 8d 47 fc lea -0x4(%edi),%eax 11b347: 83 e0 fb and $0xfffffffb,%eax 11b34a: 0f 84 30 01 00 00 je 11b480 <_POSIX_signals_Send+0x180> 11b350: 83 ff 0b cmp $0xb,%edi 11b353: 0f 84 27 01 00 00 je 11b480 <_POSIX_signals_Send+0x180> /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 11b359: 89 7d dc mov %edi,-0x24(%ebp) return 1u << (sig - 1); 11b35c: b8 01 00 00 00 mov $0x1,%eax siginfo->si_code = SI_USER; 11b361: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 11b368: d3 e0 shl %cl,%eax if ( !value ) { 11b36a: 85 db test %ebx,%ebx 11b36c: 89 c6 mov %eax,%esi 11b36e: 0f 84 2c 01 00 00 je 11b4a0 <_POSIX_signals_Send+0x1a0> siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 11b374: 8b 03 mov (%ebx),%eax 11b376: 89 45 e4 mov %eax,-0x1c(%ebp) disable_level = cpu_self->thread_dispatch_disable_level; 11b379: a1 30 4d 14 00 mov 0x144d30,%eax * get it an execute it as soon as the dispatcher executes. */ the_thread = _Per_CPU_Get_executing( cpu_self ); api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 11b37e: 89 f1 mov %esi,%ecx 11b380: 8b 1d 38 4d 14 00 mov 0x144d38,%ebx cpu_self->thread_dispatch_disable_level = disable_level + 1; 11b386: 40 inc %eax 11b387: a3 30 4d 14 00 mov %eax,0x144d30 11b38c: 8b 83 0c 01 00 00 mov 0x10c(%ebx),%eax 11b392: 23 48 54 and 0x54(%eax),%ecx 11b395: 75 4d jne 11b3e4 <_POSIX_signals_Send+0xe4> * There is no requirement on the order of threads pending on a sigwait(). */ /* XXX violation of visibility -- need to define thread queue support */ heads = _POSIX_signals_Wait_queue.Queue.heads; 11b397: 8b 1d 98 14 14 00 mov 0x141498,%ebx if ( heads != NULL ) { 11b39d: 85 db test %ebx,%ebx 11b39f: 0f 84 1b 01 00 00 je 11b4c0 <_POSIX_signals_Send+0x1c0> return _Chain_Immutable_head( the_chain )->next; 11b3a5: 8b 03 mov (%ebx),%eax return &the_chain->Tail.Node; 11b3a7: 83 c3 04 add $0x4,%ebx Chain_Control *the_chain = &heads->Heads.Fifo; for ( the_node = _Chain_First( the_chain ); 11b3aa: 39 d8 cmp %ebx,%eax 11b3ac: 0f 84 11 02 00 00 je 11b5c3 <_POSIX_signals_Send+0x2c3> <== NEVER TAKEN 11b3b2: 89 7d d4 mov %edi,-0x2c(%ebp) 11b3b5: 89 df mov %ebx,%edi 11b3b7: eb 18 jmp 11b3d1 <_POSIX_signals_Send+0xd1> 11b3b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (api->signals_unblocked & mask) 11b3c0: 89 f2 mov %esi,%edx 11b3c2: 23 51 54 and 0x54(%ecx),%edx 11b3c5: 75 1a jne 11b3e1 <_POSIX_signals_Send+0xe1> the_node = the_node->next ) { 11b3c7: 8b 00 mov (%eax),%eax for ( the_node = _Chain_First( the_chain ); 11b3c9: 39 f8 cmp %edi,%eax 11b3cb: 0f 84 ef 01 00 00 je 11b5c0 <_POSIX_signals_Send+0x2c0> <== ALWAYS TAKEN return node->owner; 11b3d1: 8b 58 fc mov -0x4(%eax),%ebx if (the_thread->Wait.option & mask) 11b3d4: 89 f2 mov %esi,%edx 11b3d6: 23 53 48 and 0x48(%ebx),%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11b3d9: 8b 8b 0c 01 00 00 mov 0x10c(%ebx),%ecx if (the_thread->Wait.option & mask) 11b3df: 74 df je 11b3c0 <_POSIX_signals_Send+0xc0> 11b3e1: 8b 7d d4 mov -0x2c(%ebp),%edi /* * 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 ) ) { 11b3e4: 89 7c 24 04 mov %edi,0x4(%esp) 11b3e8: 8d 45 dc lea -0x24(%ebp),%eax 11b3eb: 89 44 24 08 mov %eax,0x8(%esp) 11b3ef: 89 1c 24 mov %ebx,(%esp) 11b3f2: e8 39 06 00 00 call 11ba30 <_POSIX_signals_Unblock_thread> 11b3f7: 84 c0 test %al,%al 11b3f9: 75 6e jne 11b469 <_POSIX_signals_Send+0x169> /* * 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 ); 11b3fb: 89 34 24 mov %esi,(%esp) 11b3fe: e8 9d 04 00 00 call 11b8a0 <_POSIX_signals_Set_process_signals> _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 11b403: 9c pushf 11b404: fa cli 11b405: 59 pop %ecx _Thread_queue_Context_initialize( &queue_context ); _POSIX_signals_Acquire( &queue_context ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 11b406: 8d 04 7f lea (%edi,%edi,2),%eax 11b409: 83 3c 85 80 50 14 00 cmpl $0x2,0x145080(,%eax,4) 11b410: 02 11b411: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx 11b418: 75 4d jne 11b467 <_POSIX_signals_Send+0x167> return _Chain_Immutable_head( the_chain )->next; 11b41a: a1 60 50 14 00 mov 0x145060,%eax if ( !_Chain_Is_empty(the_chain)) 11b41f: 3d 64 50 14 00 cmp $0x145064,%eax 11b424: 0f 84 b6 01 00 00 je 11b5e0 <_POSIX_signals_Send+0x2e0> new_first = old_first->next; 11b42a: 8b 18 mov (%eax),%ebx rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; _Chain_Append_unprotected( 11b42c: 8d b2 e0 4e 14 00 lea 0x144ee0(%edx),%esi new_first->previous = head; 11b432: c7 43 04 60 50 14 00 movl $0x145060,0x4(%ebx) head->next = new_first; 11b439: 89 1d 60 50 14 00 mov %ebx,0x145060 psiginfo->Info = *siginfo; 11b43f: 8b 5d dc mov -0x24(%ebp),%ebx 11b442: 89 58 08 mov %ebx,0x8(%eax) 11b445: 8b 5d e0 mov -0x20(%ebp),%ebx 11b448: 89 58 0c mov %ebx,0xc(%eax) 11b44b: 8b 5d e4 mov -0x1c(%ebp),%ebx 11b44e: 89 58 10 mov %ebx,0x10(%eax) old_last = tail->previous; 11b451: 8b 9a e8 4e 14 00 mov 0x144ee8(%edx),%ebx return &the_chain->Tail.Node; 11b457: 81 c2 e4 4e 14 00 add $0x144ee4,%edx 11b45d: 89 10 mov %edx,(%eax) tail->previous = the_node; 11b45f: 89 46 08 mov %eax,0x8(%esi) old_last->next = the_node; 11b462: 89 03 mov %eax,(%ebx) the_node->previous = old_last; 11b464: 89 58 04 mov %ebx,0x4(%eax) Thread_queue_Context *queue_context ) { (void) the_thread_queue; _Assert( _Thread_queue_Is_lock_owner( the_thread_queue ) ); _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 11b467: 51 push %ecx 11b468: 9d popf ); } _POSIX_signals_Release( &queue_context ); DEBUG_STEP("\n"); _Thread_Dispatch_enable( cpu_self ); 11b469: c7 04 24 20 4d 14 00 movl $0x144d20,(%esp) 11b470: e8 9b 02 ff ff call 10b710 <_Thread_Dispatch_enable> return 0; 11b475: 31 c0 xor %eax,%eax } 11b477: 83 c4 4c add $0x4c,%esp 11b47a: 5b pop %ebx 11b47b: 5e pop %esi 11b47c: 5f pop %edi 11b47d: 5d pop %ebp 11b47e: c3 ret 11b47f: 90 nop return pthread_kill( pthread_self(), sig ); 11b480: e8 7b bc fe ff call 107100 11b485: 89 7d 0c mov %edi,0xc(%ebp) 11b488: 89 45 08 mov %eax,0x8(%ebp) } 11b48b: 83 c4 4c add $0x4c,%esp 11b48e: 5b pop %ebx 11b48f: 5e pop %esi 11b490: 5f pop %edi 11b491: 5d pop %ebp return pthread_kill( pthread_self(), sig ); 11b492: e9 f9 06 00 00 jmp 11bb90 11b497: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b49e: 66 90 xchg %ax,%ax siginfo->si_value.sival_int = 0; 11b4a0: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 11b4a7: e9 cd fe ff ff jmp 11b379 <_POSIX_signals_Send+0x79> 11b4ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi } 11b4b0: 83 c4 4c add $0x4c,%esp return 0; 11b4b3: 31 c0 xor %eax,%eax } 11b4b5: 5b pop %ebx 11b4b6: 5e pop %esi 11b4b7: 5f pop %edi 11b4b8: 5d pop %ebp 11b4b9: c3 ret 11b4ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 11b4c0: c7 45 d0 ff ff ff ff movl $0xffffffff,-0x30(%ebp) 11b4c7: b8 ff ff ff ff mov $0xffffffff,%eax 11b4cc: 89 7d bc mov %edi,-0x44(%ebp) 11b4cf: 89 c7 mov %eax,%edi for ( the_node = _Chain_First( the_chain ); 11b4d1: c7 45 c0 02 00 00 00 movl $0x2,-0x40(%ebp) 11b4d8: 89 5d c4 mov %ebx,-0x3c(%ebp) 11b4db: 89 75 c8 mov %esi,-0x38(%ebp) the_info = _Objects_Information_table[ the_api ][ 1 ]; 11b4de: 8b 45 c0 mov -0x40(%ebp),%eax 11b4e1: 8b 04 85 98 9b 13 00 mov 0x139b98(,%eax,4),%eax 11b4e8: 8b 40 04 mov 0x4(%eax),%eax if ( !the_info ) 11b4eb: 85 c0 test %eax,%eax 11b4ed: 0f 84 88 00 00 00 je 11b57b <_POSIX_signals_Send+0x27b> */ RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index( Objects_Id id ) { return 11b4f3: 0f b7 10 movzwl (%eax),%edx object_table = the_info->local_table; 11b4f6: 8b 40 04 mov 0x4(%eax),%eax for ( index = 0 ; index < maximum ; ++index ) { 11b4f9: 85 d2 test %edx,%edx 11b4fb: 74 7e je 11b57b <_POSIX_signals_Send+0x27b> 11b4fd: 89 7d d4 mov %edi,-0x2c(%ebp) 11b500: 8d 34 90 lea (%eax,%edx,4),%esi 11b503: 89 75 cc mov %esi,-0x34(%ebp) 11b506: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b50d: 8d 76 00 lea 0x0(%esi),%esi the_thread = (Thread_Control *) object_table[ index ]; 11b510: 8b 10 mov (%eax),%edx if ( !the_thread ) 11b512: 85 d2 test %edx,%edx 11b514: 74 5a je 11b570 <_POSIX_signals_Send+0x270> return aggregation->Node.priority; 11b516: 8b 4a 38 mov 0x38(%edx),%ecx if ( _Thread_Get_priority( the_thread ) > interested_priority ) 11b519: 8b 7d d4 mov -0x2c(%ebp),%edi 11b51c: 8b 59 14 mov 0x14(%ecx),%ebx 11b51f: 8b 49 18 mov 0x18(%ecx),%ecx 11b522: 39 5d d0 cmp %ebx,-0x30(%ebp) 11b525: 19 cf sbb %ecx,%edi 11b527: 72 47 jb 11b570 <_POSIX_signals_Send+0x270> if ( !_POSIX_signals_Is_interested( api, mask ) ) 11b529: 8b b2 0c 01 00 00 mov 0x10c(%edx),%esi 11b52f: 8b 7d c8 mov -0x38(%ebp),%edi 11b532: 23 7e 54 and 0x54(%esi),%edi 11b535: 74 39 je 11b570 <_POSIX_signals_Send+0x270> if ( _Thread_Get_priority( the_thread ) < interested_priority ) { 11b537: 3b 5d d0 cmp -0x30(%ebp),%ebx 11b53a: 89 cf mov %ecx,%edi 11b53c: 1b 7d d4 sbb -0x2c(%ebp),%edi 11b53f: 72 5f jb 11b5a0 <_POSIX_signals_Send+0x2a0> if ( interested && !_States_Is_ready( interested->current_state ) ) { 11b541: 8b 7d c4 mov -0x3c(%ebp),%edi 11b544: 85 ff test %edi,%edi 11b546: 74 28 je 11b570 <_POSIX_signals_Send+0x270> <== NEVER TAKEN 11b548: 8b 77 1c mov 0x1c(%edi),%esi 11b54b: 85 f6 test %esi,%esi 11b54d: 74 21 je 11b570 <_POSIX_signals_Send+0x270> if ( _States_Is_ready( the_thread->current_state ) ) { 11b54f: 8b 7a 1c mov 0x1c(%edx),%edi 11b552: 85 ff test %edi,%edi 11b554: 74 4a je 11b5a0 <_POSIX_signals_Send+0x2a0> if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 11b556: 81 e6 00 00 00 10 and $0x10000000,%esi 11b55c: 75 12 jne 11b570 <_POSIX_signals_Send+0x270> if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 11b55e: 81 e7 00 00 00 10 and $0x10000000,%edi 11b564: 75 3a jne 11b5a0 <_POSIX_signals_Send+0x2a0> 11b566: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b56d: 8d 76 00 lea 0x0(%esi),%esi for ( index = 0 ; index < maximum ; ++index ) { 11b570: 83 c0 04 add $0x4,%eax 11b573: 39 45 cc cmp %eax,-0x34(%ebp) 11b576: 75 98 jne 11b510 <_POSIX_signals_Send+0x210> 11b578: 8b 7d d4 mov -0x2c(%ebp),%edi for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 11b57b: 83 7d c0 03 cmpl $0x3,-0x40(%ebp) 11b57f: 75 2f jne 11b5b0 <_POSIX_signals_Send+0x2b0> if ( interested ) { 11b581: 8b 5d c4 mov -0x3c(%ebp),%ebx 11b584: 8b 75 c8 mov -0x38(%ebp),%esi 11b587: 8b 7d bc mov -0x44(%ebp),%edi 11b58a: 85 db test %ebx,%ebx 11b58c: 0f 85 52 fe ff ff jne 11b3e4 <_POSIX_signals_Send+0xe4> 11b592: e9 64 fe ff ff jmp 11b3fb <_POSIX_signals_Send+0xfb> 11b597: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b59e: 66 90 xchg %ax,%ax 11b5a0: 89 5d d0 mov %ebx,-0x30(%ebp) 11b5a3: 89 4d d4 mov %ecx,-0x2c(%ebp) 11b5a6: 89 55 c4 mov %edx,-0x3c(%ebp) 11b5a9: eb c5 jmp 11b570 <_POSIX_signals_Send+0x270> 11b5ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 11b5af: 90 nop 11b5b0: c7 45 c0 03 00 00 00 movl $0x3,-0x40(%ebp) 11b5b7: e9 22 ff ff ff jmp 11b4de <_POSIX_signals_Send+0x1de> 11b5bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 11b5c0: 8b 7d d4 mov -0x2c(%ebp),%edi for ( the_node = _Chain_First( the_chain ); 11b5c3: c7 45 d0 ff ff ff ff movl $0xffffffff,-0x30(%ebp) 11b5ca: b8 ff ff ff ff mov $0xffffffff,%eax 11b5cf: 31 db xor %ebx,%ebx 11b5d1: e9 f6 fe ff ff jmp 11b4cc <_POSIX_signals_Send+0x1cc> 11b5d6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11b5dd: 8d 76 00 lea 0x0(%esi),%esi 11b5e0: 51 push %ecx 11b5e1: 9d popf _Thread_Dispatch_enable( cpu_self ); 11b5e2: c7 04 24 20 4d 14 00 movl $0x144d20,(%esp) 11b5e9: e8 22 01 ff ff call 10b710 <_Thread_Dispatch_enable> rtems_set_errno_and_return_minus_one( EAGAIN ); 11b5ee: e8 ad ed 00 00 call 12a3a0 <__errno> 11b5f3: c7 00 0b 00 00 00 movl $0xb,(%eax) 11b5f9: b8 ff ff ff ff mov $0xffffffff,%eax 11b5fe: e9 74 fe ff ff jmp 11b477 <_POSIX_signals_Send+0x177> rtems_set_errno_and_return_minus_one( EINVAL ); 11b603: e8 98 ed 00 00 call 12a3a0 <__errno> 11b608: c7 00 16 00 00 00 movl $0x16,(%eax) 11b60e: b8 ff ff ff ff mov $0xffffffff,%eax 11b613: e9 5f fe ff ff jmp 11b477 <_POSIX_signals_Send+0x177> rtems_set_errno_and_return_minus_one( ESRCH ); 11b618: e8 83 ed 00 00 call 12a3a0 <__errno> 11b61d: c7 00 03 00 00 00 movl $0x3,(%eax) 11b623: b8 ff ff ff ff mov $0xffffffff,%eax 11b628: e9 4a fe ff ff jmp 11b477 <_POSIX_signals_Send+0x177> 11b62d: 90 nop 11b62e: 90 nop 11b62f: 90 nop =============================================================================== 0011ba30 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 11ba30: 55 push %ebp 11ba31: 89 e5 mov %esp,%ebp 11ba33: 83 ec 28 sub $0x28,%esp 11ba36: 89 75 f8 mov %esi,-0x8(%ebp) 11ba39: 8b 75 08 mov 0x8(%ebp),%esi 11ba3c: 89 5d f4 mov %ebx,-0xc(%ebp) 11ba3f: 8b 45 0c mov 0xc(%ebp),%eax 11ba42: 89 7d fc mov %edi,-0x4(%ebp) /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 11ba45: 8b 56 1c mov 0x1c(%esi),%edx 11ba48: 8d 48 ff lea -0x1(%eax),%ecx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11ba4b: 8b 9e 0c 01 00 00 mov 0x10c(%esi),%ebx 11ba51: b8 01 00 00 00 mov $0x1,%eax 11ba56: d3 e0 shl %cl,%eax if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 11ba58: 89 d1 mov %edx,%ecx _Chain_Append_if_is_off_chain_unprotected( 11ba5a: 8d 7b 5c lea 0x5c(%ebx),%edi 11ba5d: 81 e1 00 04 00 10 and $0x10000400,%ecx 11ba63: 81 f9 00 04 00 10 cmp $0x10000400,%ecx 11ba69: 74 55 je 11bac0 <_POSIX_signals_Unblock_thread+0x90> } /* * Thread is not waiting due to a sigwait. */ if ( api->signals_unblocked & mask ) { 11ba6b: 23 43 54 and 0x54(%ebx),%eax 11ba6e: 75 30 jne 11baa0 <_POSIX_signals_Unblock_thread+0x70> _ISR_lock_ISR_disable( lock_context ); 11ba70: 9c pushf 11ba71: fa cli 11ba72: 58 pop %eax action->handler = handler; 11ba73: c7 43 64 70 b9 11 00 movl $0x11b970,0x64(%ebx) if ( _Chain_Is_node_off_chain( the_node ) ) { 11ba7a: 8b 4b 5c mov 0x5c(%ebx),%ecx cpu_self->dispatch_necessary = true; 11ba7d: b2 01 mov $0x1,%dl 11ba7f: 88 15 34 4d 14 00 mov %dl,0x144d34 11ba85: 85 c9 test %ecx,%ecx 11ba87: 0f 84 a3 00 00 00 je 11bb30 <_POSIX_signals_Unblock_thread+0x100> _ISR_lock_ISR_enable( lock_context ); 11ba8d: 50 push %eax 11ba8e: 9d popf the_thread->Wait.return_code = STATUS_INTERRUPTED; _Thread_queue_Extract_with_proxy( the_thread ); } } return _POSIX_signals_Unblock_thread_done( the_thread, api, false ); } 11ba8f: 8b 5d f4 mov -0xc(%ebp),%ebx return _POSIX_signals_Unblock_thread_done( the_thread, api, false ); 11ba92: 31 c0 xor %eax,%eax } 11ba94: 8b 75 f8 mov -0x8(%ebp),%esi 11ba97: 8b 7d fc mov -0x4(%ebp),%edi 11ba9a: 89 ec mov %ebp,%esp 11ba9c: 5d pop %ebp 11ba9d: c3 ret 11ba9e: 66 90 xchg %ax,%ax if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) { 11baa0: 81 e2 00 00 00 10 and $0x10000000,%edx 11baa6: 74 c8 je 11ba70 <_POSIX_signals_Unblock_thread+0x40> the_thread->Wait.return_code = STATUS_INTERRUPTED; 11baa8: c7 46 4c 0d 04 00 00 movl $0x40d,0x4c(%esi) _Thread_queue_Extract_with_proxy( the_thread ); 11baaf: 89 34 24 mov %esi,(%esp) 11bab2: e8 79 06 ff ff call 10c130 <_Thread_queue_Extract_with_proxy> 11bab7: eb b7 jmp 11ba70 <_POSIX_signals_Unblock_thread+0x40> 11bab9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) { 11bac0: 89 c2 mov %eax,%edx 11bac2: 23 56 48 and 0x48(%esi),%edx 11bac5: 75 05 jne 11bacc <_POSIX_signals_Unblock_thread+0x9c> 11bac7: 23 43 54 and 0x54(%ebx),%eax 11baca: 74 a4 je 11ba70 <_POSIX_signals_Unblock_thread+0x40> the_thread->Wait.return_code = STATUS_INTERRUPTED; 11bacc: c7 46 4c 0d 04 00 00 movl $0x40d,0x4c(%esi) if ( !info ) { 11bad3: 8b 55 10 mov 0x10(%ebp),%edx the_info = (siginfo_t *) the_thread->Wait.return_argument; 11bad6: 8b 46 40 mov 0x40(%esi),%eax if ( !info ) { 11bad9: 85 d2 test %edx,%edx 11badb: 74 73 je 11bb50 <_POSIX_signals_Unblock_thread+0x120> *the_info = *info; 11badd: 8b 55 10 mov 0x10(%ebp),%edx 11bae0: 8b 12 mov (%edx),%edx 11bae2: 89 10 mov %edx,(%eax) 11bae4: 8b 55 10 mov 0x10(%ebp),%edx 11bae7: 8b 52 04 mov 0x4(%edx),%edx 11baea: 89 50 04 mov %edx,0x4(%eax) 11baed: 8b 55 10 mov 0x10(%ebp),%edx 11baf0: 8b 52 08 mov 0x8(%edx),%edx 11baf3: 89 50 08 mov %edx,0x8(%eax) _Thread_queue_Extract_with_proxy( the_thread ); 11baf6: 89 34 24 mov %esi,(%esp) 11baf9: e8 32 06 ff ff call 10c130 <_Thread_queue_Extract_with_proxy> _ISR_lock_ISR_disable( lock_context ); 11bafe: 9c pushf 11baff: fa cli 11bb00: 58 pop %eax action->handler = handler; 11bb01: c7 43 64 70 b9 11 00 movl $0x11b970,0x64(%ebx) 11bb08: 8b 4b 5c mov 0x5c(%ebx),%ecx 11bb0b: b2 01 mov $0x1,%dl 11bb0d: 88 15 34 4d 14 00 mov %dl,0x144d34 11bb13: 85 c9 test %ecx,%ecx 11bb15: 74 59 je 11bb70 <_POSIX_signals_Unblock_thread+0x140> <== ALWAYS TAKEN _ISR_lock_ISR_enable( lock_context ); 11bb17: 50 push %eax 11bb18: 9d popf } 11bb19: 8b 5d f4 mov -0xc(%ebp),%ebx return _POSIX_signals_Unblock_thread_done( the_thread, api, true ); 11bb1c: b0 01 mov $0x1,%al } 11bb1e: 8b 75 f8 mov -0x8(%ebp),%esi 11bb21: 8b 7d fc mov -0x4(%ebp),%edi 11bb24: 89 ec mov %ebp,%esp 11bb26: 5d pop %ebp 11bb27: c3 ret 11bb28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11bb2f: 90 nop old_last = tail->previous; 11bb30: 8b 96 d8 00 00 00 mov 0xd8(%esi),%edx return &the_chain->Tail.Node; 11bb36: 8d 8e d4 00 00 00 lea 0xd4(%esi),%ecx 11bb3c: 89 4b 5c mov %ecx,0x5c(%ebx) tail->previous = the_node; 11bb3f: 89 be d8 00 00 00 mov %edi,0xd8(%esi) old_last->next = the_node; 11bb45: 89 3a mov %edi,(%edx) the_node->previous = old_last; 11bb47: 89 53 60 mov %edx,0x60(%ebx) } 11bb4a: e9 3e ff ff ff jmp 11ba8d <_POSIX_signals_Unblock_thread+0x5d> 11bb4f: 90 nop the_info->si_code = SI_USER; 11bb50: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_signo = signo; 11bb57: 8b 55 0c mov 0xc(%ebp),%edx the_info->si_value.sival_int = 0; 11bb5a: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) the_info->si_signo = signo; 11bb61: 89 10 mov %edx,(%eax) the_info->si_value.sival_int = 0; 11bb63: eb 91 jmp 11baf6 <_POSIX_signals_Unblock_thread+0xc6> 11bb65: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 11bb6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi old_last = tail->previous; 11bb70: 8b 96 d8 00 00 00 mov 0xd8(%esi),%edx return &the_chain->Tail.Node; 11bb76: 8d 8e d4 00 00 00 lea 0xd4(%esi),%ecx 11bb7c: 89 4b 5c mov %ecx,0x5c(%ebx) tail->previous = the_node; 11bb7f: 89 be d8 00 00 00 mov %edi,0xd8(%esi) old_last->next = the_node; 11bb85: 89 3a mov %edi,(%edx) the_node->previous = old_last; 11bb87: 89 53 60 mov %edx,0x60(%ebx) } 11bb8a: eb 8b jmp 11bb17 <_POSIX_signals_Unblock_thread+0xe7> 11bb8c: 90 nop 11bb8d: 90 nop 11bb8e: 90 nop 11bb8f: 90 nop =============================================================================== 00109780 : #include #include #include int aio_cancel(int fildes, struct aiocb *aiocbp) { 109780: 55 push %ebp 109781: 89 e5 mov %esp,%ebp 109783: 83 ec 28 sub $0x28,%esp 109786: 89 75 f8 mov %esi,-0x8(%ebp) 109789: 8b 75 08 mov 0x8(%ebp),%esi rtems_chain_control *idle_req_chain = &aio_request_queue.idle_req; rtems_chain_control *work_req_chain = &aio_request_queue.work_req; rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10978c: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) { 109793: 89 7d fc mov %edi,-0x4(%ebp) 109796: 8b 7d 0c mov 0xc(%ebp),%edi 109799: 89 5d f4 mov %ebx,-0xc(%ebp) pthread_mutex_lock (&aio_request_queue.mutex); 10979c: e8 7f 25 00 00 call 10bd20 if (fcntl (fildes, F_GETFD) < 0) { 1097a1: b8 01 00 00 00 mov $0x1,%eax 1097a6: 89 44 24 04 mov %eax,0x4(%esp) 1097aa: 89 34 24 mov %esi,(%esp) 1097ad: e8 be 0f 00 00 call 10a770 1097b2: 85 c0 test %eax,%eax 1097b4: 0f 88 d7 01 00 00 js 109991 pthread_mutex_unlock(&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EBADF); } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 1097ba: 85 ff test %edi,%edi 1097bc: 0f 84 de 00 00 00 je 1098a0 pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 1097c2: 39 37 cmp %esi,(%edi) 1097c4: 0f 85 a6 01 00 00 jne 109970 pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0); 1097ca: 89 74 24 04 mov %esi,0x4(%esp) 1097ce: 31 d2 xor %edx,%edx 1097d0: 89 54 24 08 mov %edx,0x8(%esp) 1097d4: c7 04 24 a8 1c 13 00 movl $0x131ca8,(%esp) 1097db: e8 50 07 00 00 call 109f30 if (r_chain == NULL) { 1097e0: 85 c0 test %eax,%eax r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0); 1097e2: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 1097e4: 75 5a jne 109840 if (!rtems_chain_is_empty (idle_req_chain)) { 1097e6: 81 3d b4 1c 13 00 b8 cmpl $0x131cb8,0x131cb4 1097ed: 1c 13 00 1097f0: 0f 84 8a 00 00 00 je 109880 <== NEVER TAKEN r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0); 1097f6: 89 74 24 04 mov %esi,0x4(%esp) 1097fa: 31 c0 xor %eax,%eax 1097fc: 89 44 24 08 mov %eax,0x8(%esp) 109800: c7 04 24 b4 1c 13 00 movl $0x131cb4,(%esp) 109807: e8 24 07 00 00 call 109f30 if (r_chain == NULL) { 10980c: 85 c0 test %eax,%eax 10980e: 0f 84 5c 01 00 00 je 109970 rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 109814: 89 7c 24 04 mov %edi,0x4(%esp) 109818: 83 c0 08 add $0x8,%eax 10981b: 89 04 24 mov %eax,(%esp) 10981e: e8 cd 08 00 00 call 10a0f0 pthread_mutex_unlock (&aio_request_queue.mutex); 109823: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10982a: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); 10982c: e8 ef 27 00 00 call 10c020 pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } return AIO_ALLDONE; } 109831: 8b 75 f8 mov -0x8(%ebp),%esi 109834: 89 d8 mov %ebx,%eax 109836: 8b 5d f4 mov -0xc(%ebp),%ebx 109839: 8b 7d fc mov -0x4(%ebp),%edi 10983c: 89 ec mov %ebp,%esp 10983e: 5d pop %ebp 10983f: c3 ret pthread_mutex_lock (&r_chain->mutex); 109840: 8d 70 1c lea 0x1c(%eax),%esi result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 109843: 83 c3 08 add $0x8,%ebx pthread_mutex_lock (&r_chain->mutex); 109846: 89 34 24 mov %esi,(%esp) 109849: e8 d2 24 00 00 call 10bd20 result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10984e: 89 7c 24 04 mov %edi,0x4(%esp) 109852: 89 1c 24 mov %ebx,(%esp) 109855: e8 96 08 00 00 call 10a0f0 pthread_mutex_unlock (&r_chain->mutex); 10985a: 89 34 24 mov %esi,(%esp) result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10985d: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&r_chain->mutex); 10985f: e8 bc 27 00 00 call 10c020 pthread_mutex_unlock (&aio_request_queue.mutex); 109864: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) 10986b: e8 b0 27 00 00 call 10c020 } 109870: 8b 75 f8 mov -0x8(%ebp),%esi 109873: 89 d8 mov %ebx,%eax 109875: 8b 7d fc mov -0x4(%ebp),%edi 109878: 8b 5d f4 mov -0xc(%ebp),%ebx 10987b: 89 ec mov %ebp,%esp 10987d: 5d pop %ebp 10987e: c3 ret 10987f: 90 nop pthread_mutex_unlock(&aio_request_queue.mutex); 109880: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) return AIO_ALLDONE; 109887: bb 02 00 00 00 mov $0x2,%ebx pthread_mutex_unlock(&aio_request_queue.mutex); 10988c: e8 8f 27 00 00 call 10c020 return AIO_ALLDONE; 109891: eb 9e jmp 109831 109893: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10989a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0); 1098a0: 89 74 24 04 mov %esi,0x4(%esp) 1098a4: 31 db xor %ebx,%ebx 1098a6: 89 5c 24 08 mov %ebx,0x8(%esp) 1098aa: c7 04 24 a8 1c 13 00 movl $0x131ca8,(%esp) 1098b1: e8 7a 06 00 00 call 109f30 if (r_chain == NULL) { 1098b6: 85 c0 test %eax,%eax r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0); 1098b8: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 1098ba: 75 74 jne 109930 if (!rtems_chain_is_empty (idle_req_chain)) { 1098bc: 81 3d b4 1c 13 00 b8 cmpl $0x131cb8,0x131cb4 1098c3: 1c 13 00 1098c6: 74 b8 je 109880 <== NEVER TAKEN r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0); 1098c8: 89 74 24 04 mov %esi,0x4(%esp) 1098cc: 31 c9 xor %ecx,%ecx 1098ce: 89 4c 24 08 mov %ecx,0x8(%esp) 1098d2: c7 04 24 b4 1c 13 00 movl $0x131cb4,(%esp) 1098d9: e8 52 06 00 00 call 109f30 if (r_chain == NULL) { 1098de: 85 c0 test %eax,%eax r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0); 1098e0: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 1098e2: 74 9c je 109880 rtems_chain_extract (&r_chain->next_fd); 1098e4: 89 04 24 mov %eax,(%esp) 1098e7: e8 b4 35 00 00 call 10cea0 rtems_aio_remove_fd (r_chain); 1098ec: 89 1c 24 mov %ebx,(%esp) 1098ef: e8 9c 07 00 00 call 10a090 pthread_mutex_destroy (&r_chain->mutex); 1098f4: 8d 43 1c lea 0x1c(%ebx),%eax 1098f7: 89 04 24 mov %eax,(%esp) 1098fa: e8 91 22 00 00 call 10bb90 pthread_cond_destroy (&r_chain->cond); 1098ff: 8d 43 54 lea 0x54(%ebx),%eax 109902: 89 04 24 mov %eax,(%esp) 109905: e8 d6 1d 00 00 call 10b6e0 free (r_chain); 10990a: 89 1c 24 mov %ebx,(%esp) return AIO_CANCELED; 10990d: 31 db xor %ebx,%ebx free (r_chain); 10990f: e8 1c 71 ff ff call 100a30 pthread_mutex_unlock (&aio_request_queue.mutex); 109914: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) 10991b: e8 00 27 00 00 call 10c020 return AIO_CANCELED; 109920: e9 0c ff ff ff jmp 109831 109925: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10992c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi pthread_mutex_lock (&r_chain->mutex); 109930: 8d 70 1c lea 0x1c(%eax),%esi 109933: 89 34 24 mov %esi,(%esp) 109936: e8 e5 23 00 00 call 10bd20 rtems_chain_extract (&r_chain->next_fd); 10993b: 89 1c 24 mov %ebx,(%esp) 10993e: e8 5d 35 00 00 call 10cea0 rtems_aio_remove_fd (r_chain); 109943: 89 1c 24 mov %ebx,(%esp) return AIO_CANCELED; 109946: 31 db xor %ebx,%ebx rtems_aio_remove_fd (r_chain); 109948: e8 43 07 00 00 call 10a090 pthread_mutex_unlock (&r_chain->mutex); 10994d: 89 34 24 mov %esi,(%esp) 109950: e8 cb 26 00 00 call 10c020 pthread_mutex_unlock (&aio_request_queue.mutex); 109955: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) 10995c: e8 bf 26 00 00 call 10c020 return AIO_CANCELED; 109961: e9 cb fe ff ff jmp 109831 109966: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10996d: 8d 76 00 lea 0x0(%esi),%esi pthread_mutex_unlock (&aio_request_queue.mutex); 109970: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) rtems_set_errno_and_return_minus_one (EINVAL); 109977: bb ff ff ff ff mov $0xffffffff,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); 10997c: e8 9f 26 00 00 call 10c020 rtems_set_errno_and_return_minus_one (EINVAL); 109981: e8 7a 1b 01 00 call 11b500 <__errno> 109986: c7 00 16 00 00 00 movl $0x16,(%eax) 10998c: e9 a0 fe ff ff jmp 109831 pthread_mutex_unlock(&aio_request_queue.mutex); 109991: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) rtems_set_errno_and_return_minus_one (EBADF); 109998: bb ff ff ff ff mov $0xffffffff,%ebx pthread_mutex_unlock(&aio_request_queue.mutex); 10999d: e8 7e 26 00 00 call 10c020 rtems_set_errno_and_return_minus_one (EBADF); 1099a2: e8 59 1b 01 00 call 11b500 <__errno> 1099a7: c7 00 09 00 00 00 movl $0x9,(%eax) 1099ad: e9 7f fe ff ff jmp 109831 1099b2: 90 nop 1099b3: 90 nop 1099b4: 90 nop 1099b5: 90 nop 1099b6: 90 nop 1099b7: 90 nop 1099b8: 90 nop 1099b9: 90 nop 1099ba: 90 nop 1099bb: 90 nop 1099bc: 90 nop 1099bd: 90 nop 1099be: 90 nop 1099bf: 90 nop =============================================================================== 001099d0 : int aio_fsync( int op, struct aiocb *aiocbp ) { 1099d0: 55 push %ebp 1099d1: 89 e5 mov %esp,%ebp 1099d3: 83 ec 18 sub $0x18,%esp rtems_aio_request *req; int mode; if (op != O_SYNC) 1099d6: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) { 1099dd: 89 5d fc mov %ebx,-0x4(%ebp) 1099e0: 8b 5d 0c mov 0xc(%ebp),%ebx if (op != O_SYNC) 1099e3: 75 4b jne 109a30 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); 1099e5: b8 03 00 00 00 mov $0x3,%eax 1099ea: 89 44 24 04 mov %eax,0x4(%esp) 1099ee: 8b 03 mov (%ebx),%eax 1099f0: 89 04 24 mov %eax,(%esp) 1099f3: e8 78 0d 00 00 call 10a770 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 1099f8: 83 e0 03 and $0x3,%eax 1099fb: 48 dec %eax 1099fc: 83 f8 01 cmp $0x1,%eax 1099ff: 77 5f ja 109a60 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); req = malloc (sizeof (rtems_aio_request)); 109a01: c7 04 24 18 00 00 00 movl $0x18,(%esp) 109a08: e8 93 73 ff ff call 100da0 if (req == NULL) 109a0d: 85 c0 test %eax,%eax 109a0f: 74 6a je 109a7b <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 109a11: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 109a14: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); } 109a1b: 8b 5d fc mov -0x4(%ebp),%ebx return rtems_aio_enqueue (req); 109a1e: 89 45 08 mov %eax,0x8(%ebp) } 109a21: 89 ec mov %ebp,%esp 109a23: 5d pop %ebp return rtems_aio_enqueue (req); 109a24: e9 47 07 00 00 jmp 10a170 109a29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 109a30: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 109a37: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 109a3e: e8 bd 1a 01 00 call 11b500 <__errno> 109a43: c7 00 16 00 00 00 movl $0x16,(%eax) } 109a49: 8b 5d fc mov -0x4(%ebp),%ebx 109a4c: 89 ec mov %ebp,%esp 109a4e: b8 ff ff ff ff mov $0xffffffff,%eax 109a53: 5d pop %ebp 109a54: c3 ret 109a55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 109a5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 109a60: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 109a67: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 109a6e: e8 8d 1a 01 00 call 11b500 <__errno> 109a73: c7 00 09 00 00 00 movl $0x9,(%eax) 109a79: eb ce jmp 109a49 rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 109a7b: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 109a82: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 109a89: e8 72 1a 01 00 call 11b500 <__errno> <== NOT EXECUTED 109a8e: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 109a94: eb b3 jmp 109a49 <== NOT EXECUTED 109a96: 90 nop 109a97: 90 nop 109a98: 90 nop 109a99: 90 nop 109a9a: 90 nop 109a9b: 90 nop 109a9c: 90 nop 109a9d: 90 nop 109a9e: 90 nop 109a9f: 90 nop =============================================================================== 0010a3b0 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10a3b0: 55 push %ebp rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a3b1: b9 03 00 00 00 mov $0x3,%ecx { 10a3b6: 89 e5 mov %esp,%ebp 10a3b8: 83 ec 18 sub $0x18,%esp 10a3bb: 89 5d fc mov %ebx,-0x4(%ebp) 10a3be: 8b 5d 08 mov 0x8(%ebp),%ebx mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a3c1: 89 4c 24 04 mov %ecx,0x4(%esp) 10a3c5: 8b 03 mov (%ebx),%eax 10a3c7: 89 04 24 mov %eax,(%esp) 10a3ca: e8 a1 03 00 00 call 10a770 if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a3cf: a8 01 test $0x1,%al 10a3d1: 75 62 jne 10a435 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10a3d3: 8b 53 14 mov 0x14(%ebx),%edx 10a3d6: 85 d2 test %edx,%edx 10a3d8: 75 36 jne 10a410 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10a3da: 8b 43 08 mov 0x8(%ebx),%eax 10a3dd: 85 c0 test %eax,%eax 10a3df: 78 2f js 10a410 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10a3e1: c7 04 24 18 00 00 00 movl $0x18,(%esp) 10a3e8: e8 b3 69 ff ff call 100da0 if (req == NULL) 10a3ed: 85 c0 test %eax,%eax 10a3ef: 74 5f je 10a450 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10a3f1: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10a3f4: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); } 10a3fb: 8b 5d fc mov -0x4(%ebp),%ebx return rtems_aio_enqueue (req); 10a3fe: 89 45 08 mov %eax,0x8(%ebp) } 10a401: 89 ec mov %ebp,%esp 10a403: 5d pop %ebp return rtems_aio_enqueue (req); 10a404: e9 67 fd ff ff jmp 10a170 10a409: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a410: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a417: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a41e: e8 dd 10 01 00 call 11b500 <__errno> 10a423: c7 00 16 00 00 00 movl $0x16,(%eax) } 10a429: 8b 5d fc mov -0x4(%ebp),%ebx 10a42c: 89 ec mov %ebp,%esp 10a42e: b8 ff ff ff ff mov $0xffffffff,%eax 10a433: 5d pop %ebp 10a434: c3 ret rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a435: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a43c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a443: e8 b8 10 01 00 call 11b500 <__errno> 10a448: c7 00 09 00 00 00 movl $0x9,(%eax) 10a44e: eb d9 jmp 10a429 rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10a450: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10a457: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10a45e: e8 9d 10 01 00 call 11b500 <__errno> <== NOT EXECUTED 10a463: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10a469: eb be jmp 10a429 <== NOT EXECUTED 10a46b: 90 nop 10a46c: 90 nop 10a46d: 90 nop 10a46e: 90 nop 10a46f: 90 nop =============================================================================== 0010a480 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10a480: 55 push %ebp rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a481: b9 03 00 00 00 mov $0x3,%ecx { 10a486: 89 e5 mov %esp,%ebp 10a488: 83 ec 18 sub $0x18,%esp 10a48b: 89 5d fc mov %ebx,-0x4(%ebp) 10a48e: 8b 5d 08 mov 0x8(%ebp),%ebx mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a491: 89 4c 24 04 mov %ecx,0x4(%esp) 10a495: 8b 03 mov (%ebx),%eax 10a497: 89 04 24 mov %eax,(%esp) 10a49a: e8 d1 02 00 00 call 10a770 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a49f: 83 e0 03 and $0x3,%eax 10a4a2: 48 dec %eax 10a4a3: 83 f8 01 cmp $0x1,%eax 10a4a6: 77 5d ja 10a505 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10a4a8: 8b 53 14 mov 0x14(%ebx),%edx 10a4ab: 85 d2 test %edx,%edx 10a4ad: 75 31 jne 10a4e0 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10a4af: 8b 43 08 mov 0x8(%ebx),%eax 10a4b2: 85 c0 test %eax,%eax 10a4b4: 78 2a js 10a4e0 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 10a4b6: c7 04 24 18 00 00 00 movl $0x18,(%esp) 10a4bd: e8 de 68 ff ff call 100da0 if (req == NULL) 10a4c2: 85 c0 test %eax,%eax 10a4c4: 74 5a je 10a520 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 10a4c6: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10a4c9: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); } 10a4d0: 8b 5d fc mov -0x4(%ebp),%ebx return rtems_aio_enqueue (req); 10a4d3: 89 45 08 mov %eax,0x8(%ebp) } 10a4d6: 89 ec mov %ebp,%esp 10a4d8: 5d pop %ebp return rtems_aio_enqueue (req); 10a4d9: e9 92 fc ff ff jmp 10a170 10a4de: 66 90 xchg %ax,%ax rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a4e0: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a4e7: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a4ee: e8 0d 10 01 00 call 11b500 <__errno> 10a4f3: c7 00 16 00 00 00 movl $0x16,(%eax) } 10a4f9: 8b 5d fc mov -0x4(%ebp),%ebx 10a4fc: 89 ec mov %ebp,%esp 10a4fe: b8 ff ff ff ff mov $0xffffffff,%eax 10a503: 5d pop %ebp 10a504: c3 ret rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a505: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a50c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a513: e8 e8 0f 01 00 call 11b500 <__errno> 10a518: c7 00 09 00 00 00 movl $0x9,(%eax) 10a51e: eb d9 jmp 10a4f9 rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10a520: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10a527: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10a52e: e8 cd 0f 01 00 call 11b500 <__errno> <== NOT EXECUTED 10a533: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10a539: eb be jmp 10a4f9 <== NOT EXECUTED 10a53b: 90 nop 10a53c: 90 nop 10a53d: 90 nop 10a53e: 90 nop 10a53f: 90 nop =============================================================================== 001204c0 : clockid_t clock_id, int flags, const struct timespec *rqtp, struct timespec *rmtp ) { 1204c0: 55 push %ebp 1204c1: 89 e5 mov %esp,%ebp 1204c3: 57 push %edi 1204c4: 56 push %esi 1204c5: 53 push %ebx 1204c6: 83 ec 5c sub $0x5c,%esp 1204c9: 8b 45 08 mov 0x8(%ebp),%eax 1204cc: 8b 75 10 mov 0x10(%ebp),%esi struct timespec uptime; const struct timespec *end; Thread_Control *executing; int eno; if ( clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC ) { 1204cf: 83 f8 01 cmp $0x1,%eax 1204d2: 74 09 je 1204dd <== ALWAYS TAKEN 1204d4: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 1204d7: 0f 85 93 00 00 00 jne 120570 <== NOT EXECUTED queue_context->thread_state = thread_state; 1204dd: c7 45 c8 00 01 00 10 movl $0x10000100,-0x38(%ebp) _Thread_queue_Context_set_thread_state( &queue_context, STATES_WAITING_FOR_TIME | STATES_INTERRUPTIBLE_BY_SIGNAL ); if ( ( flags & TIMER_ABSTIME ) != 0 ) { 1204e4: 8b 5d 0c mov 0xc(%ebp),%ebx 1204e7: 83 e3 04 and $0x4,%ebx 1204ea: 0f 84 c0 00 00 00 je 1205b0 queue_context->Timeout.arg = abstime; 1204f0: 89 75 d0 mov %esi,-0x30(%ebp) end = rqtp; if ( clock_id == CLOCK_REALTIME ) { 1204f3: 48 dec %eax 1204f4: 0f 84 56 01 00 00 je 120650 <== ALWAYS TAKEN queue_context->enqueue_callout = 1204fa: c7 45 cc 70 96 10 00 movl $0x109670,-0x34(%ebp) _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 120501: 9c pushf 120502: fa cli 120503: 58 pop %eax 120504: 89 45 c4 mov %eax,-0x3c(%ebp) ); } _Thread_queue_Acquire( &_Nanosleep_Pseudo_queue, &queue_context ); executing = _Thread_Executing; _Thread_queue_Enqueue( 120507: c7 04 24 ac 75 12 00 movl $0x1275ac,(%esp) 12050e: 8b 3d 58 b3 12 00 mov 0x12b358,%edi 120514: 8d 45 c4 lea -0x3c(%ebp),%eax 120517: 89 44 24 0c mov %eax,0xc(%esp) 12051b: b8 d0 14 12 00 mov $0x1214d0,%eax 120520: 89 44 24 04 mov %eax,0x4(%esp) 120524: 89 7c 24 08 mov %edi,0x8(%esp) 120528: e8 c3 82 fe ff call 1087f0 <_Thread_queue_Enqueue> return _POSIX_Get_by_name_error_table[ error ]; } RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status ) { return STATUS_GET_POSIX( status ); 12052d: 8b 57 4c mov 0x4c(%edi),%edx 120530: 89 d0 mov %edx,%eax 120532: c1 f8 1f sar $0x1f,%eax 120535: 0f b6 f8 movzbl %al,%edi 120538: 01 d7 add %edx,%edi if ( eno == ETIMEDOUT ) { eno = 0; } if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) { 12053a: 8b 55 14 mov 0x14(%ebp),%edx 12053d: c1 ff 08 sar $0x8,%edi 120540: 85 db test %ebx,%ebx 120542: 0f 94 c0 sete %al 120545: 85 d2 test %edx,%edx 120547: 0f 95 c2 setne %dl 12054a: 20 d0 and %dl,%al if ( eno == ETIMEDOUT ) { 12054c: 83 ff 74 cmp $0x74,%edi 12054f: 74 2f je 120580 if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) { 120551: 84 c0 test %al,%al 120553: 0f 85 b7 00 00 00 jne 120610 _Timespec_Set_to_zero( rmtp ); } } return eno; } 120559: 83 c4 5c add $0x5c,%esp 12055c: 89 f8 mov %edi,%eax 12055e: 5b pop %ebx 12055f: 5e pop %esi 120560: 5f pop %edi 120561: 5d pop %ebp 120562: c3 ret 120563: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 12056a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 120570: 83 c4 5c add $0x5c,%esp <== NOT EXECUTED return ENOTSUP; 120573: bf 86 00 00 00 mov $0x86,%edi <== NOT EXECUTED } 120578: 5b pop %ebx <== NOT EXECUTED 120579: 89 f8 mov %edi,%eax <== NOT EXECUTED 12057b: 5e pop %esi <== NOT EXECUTED 12057c: 5f pop %edi <== NOT EXECUTED 12057d: 5d pop %ebp <== NOT EXECUTED 12057e: c3 ret <== NOT EXECUTED 12057f: 90 nop <== NOT EXECUTED eno = 0; 120580: 31 ff xor %edi,%edi if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) { 120582: 84 c0 test %al,%al 120584: 74 d3 je 120559 _Timespec_Set_to_zero( rmtp ); 120586: 8b 45 14 mov 0x14(%ebp),%eax 120589: c7 00 00 00 00 00 movl $0x0,(%eax) 12058f: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 120596: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) } 12059d: 83 c4 5c add $0x5c,%esp 1205a0: 89 f8 mov %edi,%eax 1205a2: 5b pop %ebx 1205a3: 5e pop %esi 1205a4: 5f pop %edi 1205a5: 5d pop %ebp 1205a6: c3 ret 1205a7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1205ae: 66 90 xchg %ax,%ax _Timecounter_Nanouptime( &uptime ); 1205b0: 8d 7d ac lea -0x54(%ebp),%edi 1205b3: 89 3c 24 mov %edi,(%esp) 1205b6: e8 25 72 fe ff call 1077e0 <_Timecounter_Nanouptime> && (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND; 1205bb: 85 f6 test %esi,%esi 1205bd: 74 46 je 120605 1205bf: 8b 4e 08 mov 0x8(%esi),%ecx 1205c2: 81 f9 ff c9 9a 3b cmp $0x3b9ac9ff,%ecx 1205c8: 0f 87 92 00 00 00 ja 120660 return _Watchdog_Is_valid_timespec( ts ) && ts->tv_sec >= 0; 1205ce: 8b 56 04 mov 0x4(%esi),%edx 1205d1: 8b 06 mov (%esi),%eax 1205d3: 85 d2 test %edx,%edx 1205d5: 0f 88 85 00 00 00 js 120660 now->tv_nsec += delta->tv_nsec; 1205db: 8b 75 b4 mov -0x4c(%ebp),%esi sec += (uint64_t) delta->tv_sec; 1205de: 03 45 ac add -0x54(%ebp),%eax 1205e1: 13 55 b0 adc -0x50(%ebp),%edx now->tv_nsec += delta->tv_nsec; 1205e4: 01 f1 add %esi,%ecx if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) { 1205e6: 81 f9 ff c9 9a 3b cmp $0x3b9ac9ff,%ecx 1205ec: 0f 8f 7e 00 00 00 jg 120670 now->tv_nsec += delta->tv_nsec; 1205f2: 89 4d b4 mov %ecx,-0x4c(%ebp) if ( sec <= INT64_MAX ) { 1205f5: 85 d2 test %edx,%edx 1205f7: 0f 88 93 00 00 00 js 120690 now->tv_sec = sec; 1205fd: 89 45 ac mov %eax,-0x54(%ebp) return now; 120600: 89 fe mov %edi,%esi now->tv_sec = sec; 120602: 89 55 b0 mov %edx,-0x50(%ebp) queue_context->Timeout.arg = abstime; 120605: 89 75 d0 mov %esi,-0x30(%ebp) 120608: e9 ed fe ff ff jmp 1204fa 12060d: 8d 76 00 lea 0x0(%esi),%esi if ( eno == EINTR ) { 120610: 83 ff 04 cmp $0x4,%edi 120613: 0f 85 6d ff ff ff jne 120586 _Timecounter_Nanouptime( &actual_end ); 120619: 8d 5d b8 lea -0x48(%ebp),%ebx 12061c: 89 1c 24 mov %ebx,(%esp) 12061f: e8 bc 71 fe ff call 1077e0 <_Timecounter_Nanouptime> if ( _Timespec_Less_than( &actual_end, end ) ) { 120624: 89 74 24 04 mov %esi,0x4(%esp) 120628: 89 1c 24 mov %ebx,(%esp) 12062b: e8 d0 00 00 00 call 120700 <_Timespec_Less_than> 120630: 84 c0 test %al,%al _Timespec_Subtract( &actual_end, end, rmtp ); 120632: 8b 45 14 mov 0x14(%ebp),%eax if ( _Timespec_Less_than( &actual_end, end ) ) { 120635: 0f 84 4e ff ff ff je 120589 <== NEVER TAKEN _Timespec_Subtract( &actual_end, end, rmtp ); 12063b: 89 44 24 08 mov %eax,0x8(%esp) 12063f: 89 74 24 04 mov %esi,0x4(%esp) 120643: 89 1c 24 mov %ebx,(%esp) 120646: e8 25 01 00 00 call 120770 <_Timespec_Subtract> 12064b: e9 09 ff ff ff jmp 120559 queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec; 120650: c7 45 cc b0 96 10 00 movl $0x1096b0,-0x34(%ebp) } 120657: e9 a5 fe ff ff jmp 120501 12065c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return NULL; 120660: 31 f6 xor %esi,%esi queue_context->Timeout.arg = abstime; 120662: 89 75 d0 mov %esi,-0x30(%ebp) 120665: e9 90 fe ff ff jmp 1204fa 12066a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND; 120670: 81 e9 00 ca 9a 3b sub $0x3b9aca00,%ecx ++sec; 120676: 83 c0 01 add $0x1,%eax now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND; 120679: 89 4d b4 mov %ecx,-0x4c(%ebp) ++sec; 12067c: 83 d2 00 adc $0x0,%edx 12067f: e9 71 ff ff ff jmp 1205f5 120684: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 12068b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 12068f: 90 nop now->tv_sec = INT64_MAX; 120690: c7 45 ac ff ff ff ff movl $0xffffffff,-0x54(%ebp) return now; 120697: 89 fe mov %edi,%esi now->tv_sec = INT64_MAX; 120699: c7 45 b0 ff ff ff 7f movl $0x7fffffff,-0x50(%ebp) 1206a0: e9 60 ff ff ff jmp 120605 1206a5: 90 nop 1206a6: 90 nop 1206a7: 90 nop 1206a8: 90 nop 1206a9: 90 nop 1206aa: 90 nop 1206ab: 90 nop 1206ac: 90 nop 1206ad: 90 nop 1206ae: 90 nop 1206af: 90 nop =============================================================================== 00112550 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 112550: 55 push %ebp 112551: 89 e5 mov %esp,%ebp 112553: 83 ec 28 sub $0x28,%esp 112556: 89 5d fc mov %ebx,-0x4(%ebp) 112559: 8b 5d 0c mov 0xc(%ebp),%ebx 11255c: 8b 45 08 mov 0x8(%ebp),%eax Status_Control status; if ( !tp ) 11255f: 85 db test %ebx,%ebx 112561: 74 0f je 112572 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 112563: 83 f8 01 cmp $0x1,%eax 112566: 74 48 je 1125b0 if ( status != STATUS_SUCCESSFUL ) { rtems_set_errno_and_return_minus_one( STATUS_GET_POSIX( status ) ); } } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) { 112568: 83 f8 02 cmp $0x2,%eax 11256b: 74 23 je 112590 rtems_set_errno_and_return_minus_one( ENOSYS ); } #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) { 11256d: 83 f8 03 cmp $0x3,%eax 112570: 74 1e je 112590 rtems_set_errno_and_return_minus_one( ENOSYS ); } #endif else { rtems_set_errno_and_return_minus_one( EINVAL ); 112572: e8 79 6c 04 00 call 1591f0 <__errno> 112577: bb ff ff ff ff mov $0xffffffff,%ebx 11257c: c7 00 16 00 00 00 movl $0x16,(%eax) } return 0; } 112582: 89 d8 mov %ebx,%eax 112584: 8b 5d fc mov -0x4(%ebp),%ebx 112587: 89 ec mov %ebp,%esp 112589: 5d pop %ebp 11258a: c3 ret 11258b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 11258f: 90 nop rtems_set_errno_and_return_minus_one( ENOSYS ); 112590: e8 5b 6c 04 00 call 1591f0 <__errno> 112595: bb ff ff ff ff mov $0xffffffff,%ebx 11259a: c7 00 58 00 00 00 movl $0x58,(%eax) } 1125a0: 89 d8 mov %ebx,%eax 1125a2: 8b 5d fc mov -0x4(%ebp),%ebx 1125a5: 89 ec mov %ebp,%esp 1125a7: 5d pop %ebp 1125a8: c3 ret 1125a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi _TOD_Lock(); 1125b0: e8 ab 2a 00 00 call 115060 <_TOD_Lock> _Timecounter_Acquire( lock_context ); 1125b5: 9c pushf 1125b6: fa cli 1125b7: 58 pop %eax 1125b8: 89 45 f4 mov %eax,-0xc(%ebp) status = _TOD_Set( tp, &lock_context ); 1125bb: 89 1c 24 mov %ebx,(%esp) 1125be: 8d 45 f4 lea -0xc(%ebp),%eax 1125c1: 89 44 24 04 mov %eax,0x4(%esp) 1125c5: e8 26 2b 00 00 call 1150f0 <_TOD_Set> 1125ca: 89 c3 mov %eax,%ebx _TOD_Unlock(); 1125cc: e8 af 2a 00 00 call 115080 <_TOD_Unlock> if ( status != STATUS_SUCCESSFUL ) { 1125d1: 85 db test %ebx,%ebx 1125d3: 74 ad je 112582 rtems_set_errno_and_return_minus_one( STATUS_GET_POSIX( status ) ); 1125d5: e8 16 6c 04 00 call 1591f0 <__errno> 1125da: 89 c2 mov %eax,%edx 1125dc: 89 d8 mov %ebx,%eax 1125de: c1 f8 1f sar $0x1f,%eax 1125e1: 0f b6 c0 movzbl %al,%eax 1125e4: 01 d8 add %ebx,%eax 1125e6: bb ff ff ff ff mov $0xffffffff,%ebx 1125eb: c1 f8 08 sar $0x8,%eax 1125ee: 89 02 mov %eax,(%edx) 1125f0: eb 90 jmp 112582 1125f2: 90 nop 1125f3: 90 nop 1125f4: 90 nop 1125f5: 90 nop 1125f6: 90 nop 1125f7: 90 nop 1125f8: 90 nop 1125f9: 90 nop 1125fa: 90 nop 1125fb: 90 nop 1125fc: 90 nop 1125fd: 90 nop 1125fe: 90 nop 1125ff: 90 nop =============================================================================== 00104e20 : CHAIN_DEFINE_EMPTY( mmap_mappings ); void *mmap( void *addr, size_t len, int prot, int flags, int fildes, off_t off ) { 104e20: 55 push %ebp 104e21: 89 e5 mov %esp,%ebp 104e23: 81 ec b8 00 00 00 sub $0xb8,%esp 104e29: 89 5d f4 mov %ebx,-0xc(%ebp) 104e2c: 8b 45 1c mov 0x1c(%ebp),%eax 104e2f: 89 7d fc mov %edi,-0x4(%ebp) 104e32: 8b 55 20 mov 0x20(%ebp),%edx 104e35: 89 75 f8 mov %esi,-0x8(%ebp) 104e38: 8b 7d 14 mov 0x14(%ebp),%edi 104e3b: 89 45 80 mov %eax,-0x80(%ebp) 104e3e: 89 55 84 mov %edx,-0x7c(%ebp) map_anonymous = (flags & MAP_ANON) == MAP_ANON; map_shared = (flags & MAP_SHARED) == MAP_SHARED; map_private = (flags & MAP_PRIVATE) == MAP_PRIVATE; /* Clear errno. */ errno = 0; 104e41: e8 6a 61 01 00 call 11afb0 <__errno> iop = NULL; if ( len == 0 ) { 104e46: 8b 5d 0c mov 0xc(%ebp),%ebx 104e49: 85 db test %ebx,%ebx errno = 0; 104e4b: c7 00 00 00 00 00 movl $0x0,(%eax) if ( len == 0 ) { 104e51: 0f 84 99 01 00 00 je 104ff0 <== NEVER TAKEN /* * We can provide read, write and execute because the memory in RTEMS does * not normally have protections but we cannot hide access to memory. */ if ( prot == PROT_NONE ) { 104e57: 8b 4d 10 mov 0x10(%ebp),%ecx 104e5a: 85 c9 test %ecx,%ecx 104e5c: 0f 84 de 02 00 00 je 105140 <== NEVER TAKEN /* * We can not normally provide restriction of write access. Reject any * attempt to map without write permission, since we are not able to * prevent a write from succeeding. */ if ( PROT_WRITE != (prot & PROT_WRITE) ) { 104e62: f6 45 10 02 testb $0x2,0x10(%ebp) 104e66: 0f 84 d4 02 00 00 je 105140 <== NEVER TAKEN map_fixed = (flags & MAP_FIXED) == MAP_FIXED; 104e6c: 89 f8 mov %edi,%eax map_shared = (flags & MAP_SHARED) == MAP_SHARED; 104e6e: 89 fb mov %edi,%ebx map_fixed = (flags & MAP_FIXED) == MAP_FIXED; 104e70: 83 e0 10 and $0x10,%eax map_private = (flags & MAP_PRIVATE) == MAP_PRIVATE; 104e73: 89 f9 mov %edi,%ecx map_fixed = (flags & MAP_FIXED) == MAP_FIXED; 104e75: 89 85 7c ff ff ff mov %eax,-0x84(%ebp) /* * Anonymous mappings must have file descriptor set to -1 and the offset * set to 0. Shared mappings are not supported with Anonymous mappings at * this time */ if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) { 104e7b: 89 f8 mov %edi,%eax map_shared = (flags & MAP_SHARED) == MAP_SHARED; 104e7d: 83 e3 01 and $0x1,%ebx 104e80: 89 9d 78 ff ff ff mov %ebx,-0x88(%ebp) map_private = (flags & MAP_PRIVATE) == MAP_PRIVATE; 104e86: 83 e1 02 and $0x2,%ecx if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) { 104e89: 25 00 10 00 00 and $0x1000,%eax 104e8e: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp) 104e94: 0f 85 36 01 00 00 jne 104fd0 flags |= MAP_PRIVATE; map_private = true; } /* Check for supported flags */ if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) { 104e9a: f7 c7 ec ef ff ff test $0xffffefec,%edi 104ea0: 0f 85 4a 01 00 00 jne 104ff0 <== NEVER TAKEN errno = EINVAL; return MAP_FAILED; } /* Either MAP_SHARED or MAP_PRIVATE must be defined, but not both */ if ( map_shared ) { 104ea6: 8b 95 78 ff ff ff mov -0x88(%ebp),%edx 104eac: 85 d2 test %edx,%edx 104eae: 0f 85 5c 01 00 00 jne 105010 if ( map_private ) { errno = EINVAL; return MAP_FAILED; } } else if ( !map_private ) { 104eb4: 85 c9 test %ecx,%ecx 104eb6: 0f 84 34 01 00 00 je 104ff0 errno = EINVAL; return MAP_FAILED; } /* Check for illegal addresses. Watch out for address wrap. */ if ( map_fixed ) { 104ebc: c6 85 73 ff ff ff 01 movb $0x1,-0x8d(%ebp) 104ec3: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax 104ec9: 85 c0 test %eax,%eax 104ecb: 74 23 je 104ef0 if ((uintptr_t)addr & PAGE_MASK) { 104ecd: f7 45 08 ff 0f 00 00 testl $0xfff,0x8(%ebp) 104ed4: 0f 85 16 01 00 00 jne 104ff0 errno = EINVAL; return MAP_FAILED; } if ( addr == NULL ) { 104eda: 8b 45 08 mov 0x8(%ebp),%eax 104edd: 85 c0 test %eax,%eax 104edf: 0f 84 0b 01 00 00 je 104ff0 errno = EINVAL; return MAP_FAILED; } if (addr + len < addr) { 104ee5: 8b 45 0c mov 0xc(%ebp),%eax 104ee8: 85 c0 test %eax,%eax 104eea: 0f 88 00 01 00 00 js 104ff0 <== NEVER TAKEN errno = EINVAL; return MAP_FAILED; } } if ( !map_anonymous ) { 104ef0: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 104ef6: 85 c0 test %eax,%eax 104ef8: 0f 84 2b 01 00 00 je 105029 <== NEVER TAKEN return MAP_FAILED; } } /* Create the mapping */ mapping = malloc( sizeof( mmap_mapping )); 104efe: c7 04 24 18 00 00 00 movl $0x18,(%esp) 104f05: b9 01 00 00 00 mov $0x1,%ecx 104f0a: 89 4c 24 04 mov %ecx,0x4(%esp) 104f0e: e8 0d 5a 00 00 call 10a920 if ( !mapping ) { 104f13: 85 c0 test %eax,%eax mapping = malloc( sizeof( mmap_mapping )); 104f15: 89 c3 mov %eax,%ebx if ( !mapping ) { 104f17: 0f 84 73 03 00 00 je 105290 <== NEVER TAKEN errno = ENOMEM; return MAP_FAILED; } memset( mapping, 0, sizeof( mmap_mapping )); mapping->len = len; mapping->flags = flags; 104f1d: 89 7b 10 mov %edi,0x10(%ebx) } } else { is_shared_shm = false; } if ( map_fixed ) { 104f20: 8b bd 7c ff ff ff mov -0x84(%ebp),%edi mapping->len = len; 104f26: 8b 45 0c mov 0xc(%ebp),%eax if ( map_fixed ) { 104f29: 85 ff test %edi,%edi mapping->len = len; 104f2b: 89 43 0c mov %eax,0xc(%ebx) if ( map_fixed ) { 104f2e: 0f 84 7c 03 00 00 je 1052b0 <== NEVER TAKEN mapping->addr = addr; 104f34: 8b 45 08 mov 0x8(%ebp),%eax iop = NULL; 104f37: 31 f6 xor %esi,%esi 104f39: 89 b5 6c ff ff ff mov %esi,-0x94(%ebp) mapping->addr = addr; 104f3f: 89 43 08 mov %eax,0x8(%ebx) extern rtems_chain_control mmap_mappings; static inline void mmap_mappings_lock_obtain( void ) { rtems_libio_lock(); 104f42: e8 a9 c1 ff ff call 1010f0 return _Chain_Immutable_head( the_chain )->next; 104f47: a1 a0 b3 12 00 mov 0x12b3a0,%eax mmap_mappings_lock_obtain(); if ( map_fixed ) { rtems_chain_node* node = rtems_chain_first (&mmap_mappings); while ( !rtems_chain_is_tail( &mmap_mappings, node )) { 104f4c: 3d a4 b3 12 00 cmp $0x12b3a4,%eax 104f51: 74 2c je 104f7f 104f53: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104f5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi * point in time if there is an overlap in the mappings we return an * error. POSIX allows us to also return successfully by unmapping * the overlapping prior mappings. */ current_mapping = (mmap_mapping*) node; if ( ( addr >= current_mapping->addr ) && 104f60: 8b 50 08 mov 0x8(%eax),%edx 104f63: 3b 55 08 cmp 0x8(%ebp),%edx 104f66: 77 0e ja 104f76 ( addr < ( current_mapping->addr + current_mapping->len )) ) { 104f68: 8b 48 0c mov 0xc(%eax),%ecx 104f6b: 01 ca add %ecx,%edx if ( ( addr >= current_mapping->addr ) && 104f6d: 39 55 08 cmp %edx,0x8(%ebp) 104f70: 0f 82 1a 04 00 00 jb 105390 <== NEVER TAKEN return the_node->next; 104f76: 8b 00 mov (%eax),%eax while ( !rtems_chain_is_tail( &mmap_mappings, node )) { 104f78: 3d a4 b3 12 00 cmp $0x12b3a4,%eax 104f7d: 75 e1 jne 104f60 node = rtems_chain_next( node ); } } /* Populate the data */ if ( map_private ) { 104f7f: 80 bd 73 ff ff ff 00 cmpb $0x0,-0x8d(%ebp) 104f86: 0f 84 16 05 00 00 je 1054a2 <== NEVER TAKEN if ( !map_anonymous ) { 104f8c: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 104f92: 85 c0 test %eax,%eax 104f94: 0f 84 26 04 00 00 je 1053c0 <== NEVER TAKEN } free( mapping ); errno = ENXIO; return MAP_FAILED; } } else if ( !map_fixed ) { 104f9a: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax 104fa0: 85 c0 test %eax,%eax 104fa2: 0f 84 8d 04 00 00 je 105435 <== NEVER TAKEN the_node->next = tail; 104fa8: c7 03 a4 b3 12 00 movl $0x12b3a4,(%ebx) old_last = tail->previous; 104fae: a1 a8 b3 12 00 mov 0x12b3a8,%eax tail->previous = the_node; 104fb3: 89 1d a8 b3 12 00 mov %ebx,0x12b3a8 old_last->next = the_node; 104fb9: 89 18 mov %ebx,(%eax) the_node->previous = old_last; 104fbb: 89 43 04 mov %eax,0x4(%ebx) } static inline void mmap_mappings_lock_release( void ) { rtems_libio_unlock(); 104fbe: e8 4d c1 ff ff call 101110 rtems_chain_append_unprotected( &mmap_mappings, &mapping->node ); mmap_mappings_lock_release( ); return mapping->addr; 104fc3: 8b 43 08 mov 0x8(%ebx),%eax 104fc6: eb 38 jmp 105000 104fc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104fcf: 90 nop if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) { 104fd0: 83 7d 18 ff cmpl $0xffffffff,0x18(%ebp) 104fd4: 8b 45 80 mov -0x80(%ebp),%eax 104fd7: 0f 95 c2 setne %dl 104fda: 0b 45 84 or -0x7c(%ebp),%eax 104fdd: 0f 95 c0 setne %al 104fe0: 08 c2 or %al,%dl 104fe2: 0f 84 78 01 00 00 je 105160 <== NEVER TAKEN 104fe8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104fef: 90 nop errno = EINVAL; 104ff0: e8 bb 5f 01 00 call 11afb0 <__errno> 104ff5: c7 00 16 00 00 00 movl $0x16,(%eax) return MAP_FAILED; 104ffb: b8 ff ff ff ff mov $0xffffffff,%eax } 105000: 8b 5d f4 mov -0xc(%ebp),%ebx 105003: 8b 75 f8 mov -0x8(%ebp),%esi 105006: 8b 7d fc mov -0x4(%ebp),%edi 105009: 89 ec mov %ebp,%esp 10500b: 5d pop %ebp 10500c: c3 ret 10500d: 8d 76 00 lea 0x0(%esi),%esi if ( map_private ) { 105010: 85 c9 test %ecx,%ecx 105012: 75 dc jne 104ff0 <== NEVER TAKEN if ( map_fixed ) { 105014: c6 85 73 ff ff ff 00 movb $0x0,-0x8d(%ebp) 10501b: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx 105021: 85 d2 test %edx,%edx 105023: 0f 85 a4 fe ff ff jne 104ecd <== NEVER TAKEN if ( fstat( fildes, &sb ) < 0 ) { 105029: 8d 45 90 lea -0x70(%ebp),%eax 10502c: 89 44 24 04 mov %eax,0x4(%esp) 105030: 8b 45 18 mov 0x18(%ebp),%eax 105033: 89 04 24 mov %eax,(%esp) 105036: e8 15 5b 00 00 call 10ab50 10503b: 85 c0 test %eax,%eax 10503d: 0f 88 2d 03 00 00 js 105370 <== NEVER TAKEN return &rtems_libio_iops[ fd ]; 105043: 8b 45 18 mov 0x18(%ebp),%eax 105046: 8b 75 18 mov 0x18(%ebp),%esi 105049: 8d 04 80 lea (%eax,%eax,4),%eax 10504c: 8d 04 46 lea (%esi,%eax,2),%eax if ( S_ISDIR( sb.st_mode ) || S_ISLNK( sb.st_mode )) { 10504f: 8b 75 a0 mov -0x60(%ebp),%esi 105052: 8d 04 85 e0 ea 12 00 lea 0x12eae0(,%eax,4),%eax 105059: 89 85 6c ff ff ff mov %eax,-0x94(%ebp) 10505f: 81 e6 00 f0 00 00 and $0xf000,%esi 105065: 81 fe 00 40 00 00 cmp $0x4000,%esi 10506b: 0f 84 df 02 00 00 je 105350 <== NEVER TAKEN 105071: 81 fe 00 a0 00 00 cmp $0xa000,%esi 105077: 0f 84 d3 02 00 00 je 105350 <== NEVER TAKEN if ( S_ISREG( sb.st_mode ) 10507d: 81 fe 00 80 00 00 cmp $0x8000,%esi 105083: 0f 84 77 01 00 00 je 105200 <== NEVER TAKEN if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) { 105089: 81 fe 00 20 00 00 cmp $0x2000,%esi 10508f: 0f 84 ca 01 00 00 je 10525f && (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) { 105095: 8b 45 0c mov 0xc(%ebp),%eax 105098: 31 d2 xor %edx,%edx 10509a: 03 45 80 add -0x80(%ebp),%eax 10509d: 13 55 84 adc -0x7c(%ebp),%edx if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) { 1050a0: 39 45 b4 cmp %eax,-0x4c(%ebp) 1050a3: 8b 45 b8 mov -0x48(%ebp),%eax 1050a6: 19 d0 sbb %edx,%eax 1050a8: 0f 8c 4f 03 00 00 jl 1053fd <== NEVER TAKEN if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ) { 1050ae: 8d 86 00 a0 ff ff lea -0x6000(%esi),%eax if ( S_ISCHR( sb.st_mode ) && map_private ) { 1050b4: 31 c9 xor %ecx,%ecx if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ) { 1050b6: a9 00 d0 ff ff test $0xffffd000,%eax 1050bb: 0f 84 6e 01 00 00 je 10522f <== NEVER TAKEN mapping = malloc( sizeof( mmap_mapping )); 1050c1: c7 04 24 18 00 00 00 movl $0x18,(%esp) 1050c8: b8 01 00 00 00 mov $0x1,%eax 1050cd: 89 44 24 04 mov %eax,0x4(%esp) 1050d1: 88 8d 72 ff ff ff mov %cl,-0x8e(%ebp) 1050d7: e8 44 58 00 00 call 10a920 if ( !mapping ) { 1050dc: 0f b6 8d 72 ff ff ff movzbl -0x8e(%ebp),%ecx 1050e3: 85 c0 test %eax,%eax mapping = malloc( sizeof( mmap_mapping )); 1050e5: 89 c3 mov %eax,%ebx if ( !mapping ) { 1050e7: 0f 84 a3 01 00 00 je 105290 <== NEVER TAKEN mapping->flags = flags; 1050ed: 89 7b 10 mov %edi,0x10(%ebx) mapping->len = len; 1050f0: 8b 45 0c mov 0xc(%ebp),%eax if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) || 1050f3: 81 fe 00 60 00 00 cmp $0x6000,%esi mapping->len = len; 1050f9: 89 43 0c mov %eax,0xc(%ebx) if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) || 1050fc: 0f 94 c0 sete %al S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) || 1050ff: 81 fe 00 10 00 00 cmp $0x1000,%esi 105105: 0f 94 c2 sete %dl if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) || 105108: 81 e6 ff bf ff ff and $0xffffbfff,%esi S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) || 10510e: 08 d0 or %dl,%al if ( map_fixed ) { 105110: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) || 105116: 08 c8 or %cl,%al if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) || 105118: 81 fe 00 80 00 00 cmp $0x8000,%esi 10511e: 0f 94 c1 sete %cl S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) || 105121: 08 c8 or %cl,%al 105123: 34 01 xor $0x1,%al if ( map_fixed ) { 105125: 85 d2 test %edx,%edx 105127: 0f 84 8d 01 00 00 je 1052ba <== ALWAYS TAKEN if ( map_fixed && is_shared_shm ) { 10512d: 84 c0 test %al,%al <== NOT EXECUTED 10512f: 0f 84 a2 03 00 00 je 1054d7 <== NOT EXECUTED free( mapping ); 105135: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 105138: e8 13 59 00 00 call 10aa50 <== NOT EXECUTED 10513d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED errno = ENOTSUP; 105140: e8 6b 5e 01 00 call 11afb0 <__errno> 105145: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED } 10514b: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED return MAP_FAILED; 10514e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 105153: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 105156: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 105159: 89 ec mov %ebp,%esp <== NOT EXECUTED 10515b: 5d pop %ebp <== NOT EXECUTED 10515c: c3 ret <== NOT EXECUTED 10515d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) { 105160: 84 db test %bl,%bl 105162: 0f 85 88 fe ff ff jne 104ff0 <== NEVER TAKEN if ( map_anonymous && !map_private && !map_shared ) { 105168: 89 f8 mov %edi,%eax 10516a: 25 ec ef ff ff and $0xffffefec,%eax 10516f: 85 c9 test %ecx,%ecx 105171: 0f 85 6b 03 00 00 jne 1054e2 flags |= MAP_PRIVATE; 105177: 83 cf 02 or $0x2,%edi if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) { 10517a: 85 c0 test %eax,%eax 10517c: 0f 85 6e fe ff ff jne 104ff0 <== NEVER TAKEN if ( map_fixed ) { 105182: 8b 9d 7c ff ff ff mov -0x84(%ebp),%ebx 105188: 85 db test %ebx,%ebx 10518a: 75 64 jne 1051f0 <== NEVER TAKEN mapping = malloc( sizeof( mmap_mapping )); 10518c: c7 04 24 18 00 00 00 movl $0x18,(%esp) 105193: b9 01 00 00 00 mov $0x1,%ecx 105198: 89 4c 24 04 mov %ecx,0x4(%esp) 10519c: e8 7f 57 00 00 call 10a920 if ( !mapping ) { 1051a1: 85 c0 test %eax,%eax mapping = malloc( sizeof( mmap_mapping )); 1051a3: 89 c3 mov %eax,%ebx if ( !mapping ) { 1051a5: 0f 84 e5 00 00 00 je 105290 <== NEVER TAKEN mapping->flags = flags; 1051ab: 89 7b 10 mov %edi,0x10(%ebx) mapping->len = len; 1051ae: 8b 45 0c mov 0xc(%ebp),%eax 1051b1: 89 43 0c mov %eax,0xc(%ebx) err = posix_memalign( &mapping->addr, PAGE_SIZE, len ); 1051b4: 8b 45 0c mov 0xc(%ebp),%eax 1051b7: be 00 10 00 00 mov $0x1000,%esi 1051bc: 89 74 24 04 mov %esi,0x4(%esp) 1051c0: 89 44 24 08 mov %eax,0x8(%esp) 1051c4: 8d 43 08 lea 0x8(%ebx),%eax 1051c7: 89 04 24 mov %eax,(%esp) 1051ca: e8 b1 5e 00 00 call 10b080 1051cf: 85 c0 test %eax,%eax 1051d1: 0f 84 39 02 00 00 je 105410 <== ALWAYS TAKEN free( mapping ); 1051d7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1051da: e8 71 58 00 00 call 10aa50 <== NOT EXECUTED errno = ENOMEM; 1051df: e8 cc 5d 01 00 call 11afb0 <__errno> <== NOT EXECUTED 1051e4: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED return MAP_FAILED; 1051ea: e9 5c ff ff ff jmp 10514b <== NOT EXECUTED 1051ef: 90 nop <== NOT EXECUTED map_private = true; 1051f0: c6 85 73 ff ff ff 01 movb $0x1,-0x8d(%ebp) <== NOT EXECUTED 1051f7: e9 d1 fc ff ff jmp 104ecd <== NOT EXECUTED 1051fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED && (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) { 105200: 8b 4d b4 mov -0x4c(%ebp),%ecx <== NOT EXECUTED 105203: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 105206: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 105209: 8b 5d b8 mov -0x48(%ebp),%ebx <== NOT EXECUTED 10520c: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10520e: 89 d6 mov %edx,%esi <== NOT EXECUTED 105210: 19 de sbb %ebx,%esi <== NOT EXECUTED 105212: 0f 8d 08 02 00 00 jge 105420 <== NOT EXECUTED 105218: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10521b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10521d: 03 45 80 add -0x80(%ebp),%eax <== NOT EXECUTED 105220: 13 55 84 adc -0x7c(%ebp),%edx <== NOT EXECUTED 105223: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 105225: 89 d0 mov %edx,%eax <== NOT EXECUTED 105227: 19 d8 sbb %ebx,%eax <== NOT EXECUTED 105229: 0f 8d f1 01 00 00 jge 105420 <== NOT EXECUTED if ( lseek( fildes, off, SEEK_SET ) < 0 ) { 10522f: 31 c0 xor %eax,%eax <== NOT EXECUTED 105231: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 105234: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 105238: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 10523b: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 10523f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 105243: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 105246: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105249: e8 82 5b 00 00 call 10add0 <== NOT EXECUTED 10524e: 85 d2 test %edx,%edx <== NOT EXECUTED 105250: 0f 88 f5 fe ff ff js 10514b <== NOT EXECUTED if ( S_ISCHR( sb.st_mode ) && map_private ) { 105256: 8b 75 a0 mov -0x60(%ebp),%esi <== NOT EXECUTED 105259: 81 e6 00 f0 00 00 and $0xf000,%esi <== NOT EXECUTED 10525f: 81 fe 00 20 00 00 cmp $0x2000,%esi 105265: 0f 94 c0 sete %al 105268: 80 bd 73 ff ff ff 00 cmpb $0x0,-0x8d(%ebp) 10526f: 88 c1 mov %al,%cl 105271: 0f 84 4a fe ff ff je 1050c1 105277: 84 c0 test %al,%al 105279: 0f 84 42 fe ff ff je 1050c1 <== NEVER TAKEN 10527f: e9 6c fd ff ff jmp 104ff0 105284: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10528b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10528f: 90 nop errno = ENOMEM; 105290: e8 1b 5d 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105295: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED return MAP_FAILED; 10529b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1052a0: e9 5b fd ff ff jmp 105000 <== NOT EXECUTED 1052a5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1052ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED iop = NULL; 1052b0: 31 f6 xor %esi,%esi is_shared_shm = false; 1052b2: 31 c0 xor %eax,%eax iop = NULL; 1052b4: 89 b5 6c ff ff ff mov %esi,-0x94(%ebp) } else if ( map_private ) { 1052ba: 80 bd 73 ff ff ff 00 cmpb $0x0,-0x8d(%ebp) 1052c1: 0f 85 ed fe ff ff jne 1051b4 1052c7: 88 85 7c ff ff ff mov %al,-0x84(%ebp) rtems_libio_lock(); 1052cd: e8 1e be ff ff call 1010f0 } else if ( map_shared ) { 1052d2: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax 1052d8: 85 c0 test %eax,%eax 1052da: 0f b6 85 7c ff ff ff movzbl -0x84(%ebp),%eax 1052e1: 0f 84 c1 fc ff ff je 104fa8 <== NEVER TAKEN if ( is_shared_shm ) { 1052e7: 84 c0 test %al,%al 1052e9: 74 0c je 1052f7 mapping->shm = iop_to_shm( iop ); 1052eb: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax 1052f1: 8b 40 28 mov 0x28(%eax),%eax 1052f4: 89 43 14 mov %eax,0x14(%ebx) err = (*iop->pathinfo.handlers->mmap_h)( 1052f7: 8b 8d 6c ff ff ff mov -0x94(%ebp),%ecx 1052fd: 8d 53 08 lea 0x8(%ebx),%edx 105300: 8b 75 80 mov -0x80(%ebp),%esi 105303: 8b 7d 84 mov -0x7c(%ebp),%edi 105306: 8b 41 1c mov 0x1c(%ecx),%eax 105309: 89 74 24 10 mov %esi,0x10(%esp) 10530d: 8b 75 10 mov 0x10(%ebp),%esi 105310: 89 7c 24 14 mov %edi,0x14(%esp) 105314: 89 54 24 04 mov %edx,0x4(%esp) 105318: 89 0c 24 mov %ecx,(%esp) 10531b: 89 74 24 0c mov %esi,0xc(%esp) 10531f: 8b 75 0c mov 0xc(%ebp),%esi 105322: 89 74 24 08 mov %esi,0x8(%esp) 105326: ff 50 3c call *0x3c(%eax) if ( err != 0 ) { 105329: 85 c0 test %eax,%eax 10532b: 0f 84 77 fc ff ff je 104fa8 rtems_libio_unlock(); 105331: e8 da bd ff ff call 101110 free( mapping ); 105336: 89 1c 24 mov %ebx,(%esp) 105339: e8 12 57 00 00 call 10aa50 return MAP_FAILED; 10533e: b8 ff ff ff ff mov $0xffffffff,%eax 105343: e9 b8 fc ff ff jmp 105000 105348: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10534f: 90 nop errno = ENODEV; 105350: e8 5b 5c 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105355: c7 00 13 00 00 00 movl $0x13,(%eax) <== NOT EXECUTED return MAP_FAILED; 10535b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 105360: e9 9b fc ff ff jmp 105000 <== NOT EXECUTED 105365: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10536c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED errno = EBADF; 105370: e8 3b 5c 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105375: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED return MAP_FAILED; 10537b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 105380: e9 7b fc ff ff jmp 105000 <== NOT EXECUTED 105385: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10538c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED free( mapping ); 105390: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 105393: e8 b8 56 00 00 call 10aa50 <== NOT EXECUTED 105398: e8 73 bd ff ff call 101110 <== NOT EXECUTED errno = ENXIO; 10539d: e8 0e 5c 01 00 call 11afb0 <__errno> <== NOT EXECUTED 1053a2: c7 00 06 00 00 00 movl $0x6,(%eax) <== NOT EXECUTED return MAP_FAILED; 1053a8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1053ad: e9 4e fc ff ff jmp 105000 <== NOT EXECUTED 1053b2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1053b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED r = read( fildes, mapping->addr, len ); 1053c0: 8b 45 0c mov 0xc(%ebp),%eax 1053c3: 89 44 24 08 mov %eax,0x8(%esp) 1053c7: 8b 43 08 mov 0x8(%ebx),%eax 1053ca: 89 44 24 04 mov %eax,0x4(%esp) 1053ce: 8b 45 18 mov 0x18(%ebp),%eax 1053d1: 89 04 24 mov %eax,(%esp) 1053d4: e8 67 5d 00 00 call 10b140 if ( r != len ) { 1053d9: 39 45 0c cmp %eax,0xc(%ebp) 1053dc: 0f 84 c6 fb ff ff je 104fa8 1053e2: e8 29 bd ff ff call 101110 <== NOT EXECUTED if ( !map_fixed ) { 1053e7: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 1053ed: 85 c0 test %eax,%eax <== NOT EXECUTED 1053ef: 0f 84 9d 00 00 00 je 105492 <== NOT EXECUTED free( mapping ); 1053f5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1053f8: e8 53 56 00 00 call 10aa50 <== NOT EXECUTED errno = ENXIO; 1053fd: e8 ae 5b 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105402: c7 00 06 00 00 00 movl $0x6,(%eax) <== NOT EXECUTED 105408: e9 3e fd ff ff jmp 10514b <== NOT EXECUTED 10540d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED rtems_libio_lock(); 105410: e8 db bc ff ff call 1010f0 if ( map_private ) { 105415: e9 72 fb ff ff jmp 104f8c 10541a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi errno = EOVERFLOW; 105420: e8 8b 5b 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105425: c7 00 8b 00 00 00 movl $0x8b,(%eax) <== NOT EXECUTED return MAP_FAILED; 10542b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 105430: e9 cb fb ff ff jmp 105000 <== NOT EXECUTED memset( mapping->addr, 0, len ); 105435: 8b 55 0c mov 0xc(%ebp),%edx 105438: 8b 7b 08 mov 0x8(%ebx),%edi 10543b: 83 fa 08 cmp $0x8,%edx 10543e: 73 2c jae 10546c <== ALWAYS TAKEN 105440: f6 c2 04 test $0x4,%dl 105443: 74 09 je 10544e <== ALWAYS TAKEN 105445: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 10544b: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 10544e: f6 c2 02 test $0x2,%dl 105451: 74 08 je 10545b <== ALWAYS TAKEN 105453: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 105458: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 10545b: f6 c2 01 test $0x1,%dl 10545e: 0f 84 44 fb ff ff je 104fa8 105464: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 105467: e9 3c fb ff ff jmp 104fa8 <== NOT EXECUTED 10546c: f7 c7 01 00 00 00 test $0x1,%edi 105472: 75 5c jne 1054d0 <== NEVER TAKEN 105474: f7 c7 02 00 00 00 test $0x2,%edi 10547a: 75 47 jne 1054c3 <== NEVER TAKEN 10547c: f7 c7 04 00 00 00 test $0x4,%edi 105482: 75 31 jne 1054b5 <== NEVER TAKEN 105484: 89 d1 mov %edx,%ecx 105486: 31 c0 xor %eax,%eax 105488: c1 e9 02 shr $0x2,%ecx 10548b: 83 e2 03 and $0x3,%edx 10548e: f3 ab rep stos %eax,%es:(%edi) 105490: eb ae jmp 105440 free( mapping->addr ); 105492: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 105495: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105498: e8 b3 55 00 00 call 10aa50 <== NOT EXECUTED 10549d: e9 53 ff ff ff jmp 1053f5 <== NOT EXECUTED } else if ( map_shared ) { 1054a2: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax <== NOT EXECUTED 1054a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1054aa: 0f 85 47 fe ff ff jne 1052f7 <== NOT EXECUTED 1054b0: e9 f3 fa ff ff jmp 104fa8 <== NOT EXECUTED memset( mapping->addr, 0, len ); 1054b5: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 1054bb: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED 1054be: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 1054c1: eb c1 jmp 105484 <== NOT EXECUTED 1054c3: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 1054c8: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 1054cb: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 1054ce: eb ac jmp 10547c <== NOT EXECUTED 1054d0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 1054d3: 4a dec %edx <== NOT EXECUTED 1054d4: 47 inc %edi <== NOT EXECUTED 1054d5: eb 9d jmp 105474 <== NOT EXECUTED mapping->addr = addr; 1054d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1054da: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 1054dd: e9 60 fa ff ff jmp 104f42 <== NOT EXECUTED if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) { 1054e2: 85 c0 test %eax,%eax 1054e4: 0f 84 d2 f9 ff ff je 104ebc 1054ea: e9 01 fb ff ff jmp 104ff0 <== NOT EXECUTED 1054ef: 90 nop =============================================================================== 00105180 : */ int mq_close( mqd_t mqdes ) { 105180: 55 push %ebp 105181: 89 e5 mov %esp,%ebp 105183: 83 ec 48 sub $0x48,%esp 105186: 89 5d fc mov %ebx,-0x4(%ebp) Objects_Id id, Thread_queue_Context *queue_context ) { _Thread_queue_Context_initialize( queue_context ); return (POSIX_Message_queue_Control *) _Objects_Get( 105189: 8d 5d d4 lea -0x2c(%ebp),%ebx * * @see _Objects_Allocator_unlock() and _Objects_Allocate(). */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void ) { _RTEMS_Lock_allocator(); 10518c: e8 7f 20 00 00 call 107210 <_RTEMS_Lock_allocator> 105191: b8 40 91 12 00 mov $0x129140,%eax 105196: 89 44 24 08 mov %eax,0x8(%esp) 10519a: 8b 45 08 mov 0x8(%ebp),%eax 10519d: 89 5c 24 04 mov %ebx,0x4(%esp) 1051a1: 89 04 24 mov %eax,(%esp) 1051a4: e8 a7 3f 00 00 call 109150 <_Objects_Get> Thread_queue_Context queue_context; _Objects_Allocator_lock(); the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { 1051a9: 85 c0 test %eax,%eax 1051ab: 74 37 je 1051e4 <== NEVER TAKEN _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, &queue_context ); if ( the_mq->open_count == 0 ) { 1051ad: 8b 50 54 mov 0x54(%eax),%edx 1051b0: 85 d2 test %edx,%edx 1051b2: 74 2c je 1051e0 _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); _Objects_Allocator_unlock(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq->open_count -= 1; 1051b4: 4a dec %edx 1051b5: 89 50 54 mov %edx,0x54(%eax) _POSIX_Message_queue_Delete( the_mq, &queue_context ); 1051b8: 89 04 24 mov %eax,(%esp) 1051bb: 89 5c 24 04 mov %ebx,0x4(%esp) 1051bf: e8 3c 00 00 00 call 105200 <_POSIX_Message_queue_Delete> * previous thread life protection state and thus may not return if the * executing thread was restarted or deleted in the mean-time. */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void ) { _RTEMS_Unlock_allocator(); 1051c4: e8 67 20 00 00 call 107230 <_RTEMS_Unlock_allocator> _Objects_Allocator_unlock(); return 0; 1051c9: 31 c0 xor %eax,%eax } 1051cb: 8b 5d fc mov -0x4(%ebp),%ebx 1051ce: 89 ec mov %ebp,%esp 1051d0: 5d pop %ebp 1051d1: c3 ret 1051d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1051d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi Thread_queue_Context *queue_context ) { (void) the_thread_queue; _Assert( _Thread_queue_Is_lock_owner( the_thread_queue ) ); _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 1051e0: ff 75 d4 push -0x2c(%ebp) 1051e3: 9d popf 1051e4: e8 47 20 00 00 call 107230 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_minus_one( EBADF ); 1051e9: e8 32 7b 01 00 call 11cd20 <__errno> 1051ee: c7 00 09 00 00 00 movl $0x9,(%eax) 1051f4: b8 ff ff ff ff mov $0xffffffff,%eax 1051f9: eb d0 jmp 1051cb 1051fb: 90 nop 1051fc: 90 nop 1051fd: 90 nop 1051fe: 90 nop 1051ff: 90 nop =============================================================================== 00109560 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 109560: 55 push %ebp 109561: 89 e5 mov %esp,%ebp 109563: 83 ec 48 sub $0x48,%esp 109566: 89 5d fc mov %ebx,-0x4(%ebp) 109569: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Message_queue_Control *the_mq; Thread_queue_Context queue_context; if ( mqstat == NULL ) { 10956c: 85 db test %ebx,%ebx 10956e: 74 60 je 1095d0 109570: 8d 45 d4 lea -0x2c(%ebp),%eax 109573: b9 e0 5a 13 00 mov $0x135ae0,%ecx 109578: 89 44 24 04 mov %eax,0x4(%esp) 10957c: 8b 45 08 mov 0x8(%ebp),%eax 10957f: 89 4c 24 08 mov %ecx,0x8(%esp) 109583: 89 04 24 mov %eax,(%esp) 109586: e8 e5 2e 00 00 call 10c470 <_Objects_Get> rtems_set_errno_and_return_minus_one( EINVAL ); } the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { 10958b: 85 c0 test %eax,%eax 10958d: 74 2f je 1095be <== NEVER TAKEN _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, &queue_context ); if ( the_mq->open_count == 0 ) { 10958f: 8b 50 54 mov 0x54(%eax),%edx 109592: 85 d2 test %edx,%edx 109594: 74 24 je 1095ba } /* * Return the old values. */ mqstat->mq_flags = the_mq->oflag; 109596: 8b 50 6c mov 0x6c(%eax),%edx 109599: 89 13 mov %edx,(%ebx) mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10959b: 8b 50 28 mov 0x28(%eax),%edx 10959e: 89 53 08 mov %edx,0x8(%ebx) mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 1095a1: 8b 50 20 mov 0x20(%eax),%edx mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 1095a4: 8b 40 24 mov 0x24(%eax),%eax mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 1095a7: 89 53 04 mov %edx,0x4(%ebx) mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 1095aa: 89 43 0c mov %eax,0xc(%ebx) 1095ad: ff 75 d4 push -0x2c(%ebp) 1095b0: 9d popf _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); return 0; 1095b1: 31 c0 xor %eax,%eax } 1095b3: 8b 5d fc mov -0x4(%ebp),%ebx 1095b6: 89 ec mov %ebp,%esp 1095b8: 5d pop %ebp 1095b9: c3 ret 1095ba: ff 75 d4 push -0x2c(%ebp) 1095bd: 9d popf rtems_set_errno_and_return_minus_one( EBADF ); 1095be: e8 ed 76 01 00 call 120cb0 <__errno> 1095c3: c7 00 09 00 00 00 movl $0x9,(%eax) 1095c9: b8 ff ff ff ff mov $0xffffffff,%eax 1095ce: eb e3 jmp 1095b3 rtems_set_errno_and_return_minus_one( EINVAL ); 1095d0: e8 db 76 01 00 call 120cb0 <__errno> 1095d5: c7 00 16 00 00 00 movl $0x16,(%eax) 1095db: b8 ff ff ff ff mov $0xffffffff,%eax 1095e0: eb d1 jmp 1095b3 1095e2: 90 nop 1095e3: 90 nop 1095e4: 90 nop 1095e5: 90 nop 1095e6: 90 nop 1095e7: 90 nop 1095e8: 90 nop 1095e9: 90 nop 1095ea: 90 nop 1095eb: 90 nop 1095ec: 90 nop 1095ed: 90 nop 1095ee: 90 nop 1095ef: 90 nop =============================================================================== 00110470 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 110470: 55 push %ebp return (POSIX_Message_queue_Control *) _Objects_Get( 110471: b8 e0 5a 13 00 mov $0x135ae0,%eax 110476: 89 e5 mov %esp,%ebp 110478: 83 ec 48 sub $0x48,%esp 11047b: 89 44 24 08 mov %eax,0x8(%esp) 11047f: 8d 45 d4 lea -0x2c(%ebp),%eax 110482: 89 44 24 04 mov %eax,0x4(%esp) 110486: 8b 45 08 mov 0x8(%ebp),%eax 110489: 89 5d fc mov %ebx,-0x4(%ebp) 11048c: 8b 5d 0c mov 0xc(%ebp),%ebx 11048f: 89 04 24 mov %eax,(%esp) 110492: e8 d9 bf ff ff call 10c470 <_Objects_Get> POSIX_Message_queue_Control *the_mq; Thread_queue_Context queue_context; the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { 110497: 85 c0 test %eax,%eax 110499: 74 68 je 110503 <== NEVER TAKEN _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, &queue_context ); if ( the_mq->open_count == 0 ) { 11049b: 8b 48 54 mov 0x54(%eax),%ecx 11049e: 85 c9 test %ecx,%ecx 1104a0: 74 5d je 1104ff _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( notification != NULL ) { 1104a2: 85 db test %ebx,%ebx 1104a4: 74 3a je 1104e0 if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 1104a6: 8b 50 40 mov 0x40(%eax),%edx 1104a9: 85 d2 test %edx,%edx 1104ab: 75 3c jne 1104e9 _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); rtems_set_errno_and_return_minus_one( EBUSY ); } the_mq->notification = *notification; 1104ad: 8b 13 mov (%ebx),%edx 1104af: 89 50 58 mov %edx,0x58(%eax) 1104b2: 8b 53 04 mov 0x4(%ebx),%edx 1104b5: 89 50 5c mov %edx,0x5c(%eax) 1104b8: 8b 53 08 mov 0x8(%ebx),%edx 1104bb: 89 50 60 mov %edx,0x60(%eax) 1104be: 8b 53 0c mov 0xc(%ebx),%edx 1104c1: 89 50 64 mov %edx,0x64(%eax) 1104c4: 8b 53 10 mov 0x10(%ebx),%edx 1104c7: c7 40 40 30 04 11 00 movl $0x110430,0x40(%eax) 1104ce: 89 50 68 mov %edx,0x68(%eax) 1104d1: ff 75 d4 push -0x2c(%ebp) 1104d4: 9d popf } else { _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL ); } _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); return 0; 1104d5: 31 c0 xor %eax,%eax } 1104d7: 8b 5d fc mov -0x4(%ebp),%ebx 1104da: 89 ec mov %ebp,%esp 1104dc: 5d pop %ebp 1104dd: c3 ret 1104de: 66 90 xchg %ax,%ax 1104e0: c7 40 40 00 00 00 00 movl $0x0,0x40(%eax) } 1104e7: eb e8 jmp 1104d1 1104e9: ff 75 d4 push -0x2c(%ebp) 1104ec: 9d popf rtems_set_errno_and_return_minus_one( EBUSY ); 1104ed: e8 be 07 01 00 call 120cb0 <__errno> 1104f2: c7 00 10 00 00 00 movl $0x10,(%eax) 1104f8: b8 ff ff ff ff mov $0xffffffff,%eax 1104fd: eb d8 jmp 1104d7 1104ff: ff 75 d4 push -0x2c(%ebp) 110502: 9d popf rtems_set_errno_and_return_minus_one( EBADF ); 110503: e8 a8 07 01 00 call 120cb0 <__errno> 110508: c7 00 09 00 00 00 movl $0x9,(%eax) 11050e: b8 ff ff ff ff mov $0xffffffff,%eax 110513: eb c2 jmp 1104d7 110515: 90 nop 110516: 90 nop 110517: 90 nop 110518: 90 nop 110519: 90 nop 11051a: 90 nop 11051b: 90 nop 11051c: 90 nop 11051d: 90 nop 11051e: 90 nop 11051f: 90 nop =============================================================================== 00105280 : { 105280: 55 push %ebp 105281: 89 e5 mov %esp,%ebp 105283: 83 ec 58 sub $0x58,%esp 105286: 89 5d f4 mov %ebx,-0xc(%ebp) 105289: 89 75 f8 mov %esi,-0x8(%ebp) 10528c: 89 7d fc mov %edi,-0x4(%ebp) _RTEMS_Lock_allocator(); 10528f: e8 7c 1f 00 00 call 107210 <_RTEMS_Lock_allocator> const char *name, size_t *name_length_p, Objects_Get_by_name_error *error ) { return (POSIX_Message_queue_Control *) _Objects_Get_by_name( 105294: 8d 45 e4 lea -0x1c(%ebp),%eax 105297: 89 44 24 0c mov %eax,0xc(%esp) 10529b: 8d 45 e0 lea -0x20(%ebp),%eax 10529e: 89 44 24 08 mov %eax,0x8(%esp) 1052a2: 8b 45 08 mov 0x8(%ebp),%eax 1052a5: c7 04 24 40 91 12 00 movl $0x129140,(%esp) 1052ac: 89 44 24 04 mov %eax,0x4(%esp) 1052b0: e8 db 3f 00 00 call 109290 <_Objects_Get_by_name> if ( the_mq == NULL ) { 1052b5: 85 c0 test %eax,%eax 1052b7: 74 37 je 1052f0 if ( ( oflag & ( O_CREAT | O_EXCL ) ) == ( O_CREAT | O_EXCL ) ) { 1052b9: 8b 55 0c mov 0xc(%ebp),%edx 1052bc: 81 e2 00 0a 00 00 and $0xa00,%edx 1052c2: 81 fa 00 0a 00 00 cmp $0xa00,%edx 1052c8: 0f 84 22 01 00 00 je 1053f0 the_mq->open_count += 1; 1052ce: ff 40 54 incl 0x54(%eax) status = the_mq->Object.id; 1052d1: 8b 40 08 mov 0x8(%eax),%eax 1052d4: 89 45 d4 mov %eax,-0x2c(%ebp) _RTEMS_Unlock_allocator(); 1052d7: e8 54 1f 00 00 call 107230 <_RTEMS_Unlock_allocator> return status; 1052dc: 8b 45 d4 mov -0x2c(%ebp),%eax } 1052df: 8b 5d f4 mov -0xc(%ebp),%ebx 1052e2: 8b 75 f8 mov -0x8(%ebp),%esi 1052e5: 8b 7d fc mov -0x4(%ebp),%edi 1052e8: 89 ec mov %ebp,%esp 1052ea: 5d pop %ebp 1052eb: c3 ret 1052ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if ( error != OBJECTS_GET_BY_NAME_NO_OBJECT || ( oflag & O_CREAT ) == 0 ) { 1052f0: 83 7d e4 02 cmpl $0x2,-0x1c(%ebp) 1052f4: 0f 85 c6 00 00 00 jne 1053c0 1052fa: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 105301: 0f 84 b9 00 00 00 je 1053c0 attr = va_arg( ap, const struct mq_attr * ); 105307: 8b 7d 14 mov 0x14(%ebp),%edi status = _POSIX_Message_queue_Create( name, name_len, oflag, attr ); 10530a: 8b 5d e0 mov -0x20(%ebp),%ebx if ( attr == NULL ) { 10530d: 85 ff test %edi,%edi 10530f: 0f 84 fb 00 00 00 je 105410 if ( attr->mq_maxmsg <= 0 ){ 105315: 8b 47 04 mov 0x4(%edi),%eax 105318: 85 c0 test %eax,%eax 10531a: 0f 8e 00 01 00 00 jle 105420 if ( attr->mq_msgsize <= 0 ){ 105320: 8b 77 08 mov 0x8(%edi),%esi 105323: 85 f6 test %esi,%esi 105325: 0f 8e f5 00 00 00 jle 105420 return ( *information->allocate )( information ); 10532b: c7 04 24 40 91 12 00 movl $0x129140,(%esp) 105332: ff 15 48 91 12 00 call *0x129148 if ( !the_mq ) { 105338: 85 c0 test %eax,%eax 10533a: 89 c6 mov %eax,%esi 10533c: 0f 84 5e 01 00 00 je 1054a0 name = _Workspace_String_duplicate( name_arg, name_len ); 105342: 89 5c 24 04 mov %ebx,0x4(%esp) 105346: 8b 45 08 mov 0x8(%ebp),%eax 105349: 89 04 24 mov %eax,(%esp) 10534c: e8 af 7a 00 00 call 10ce00 <_Workspace_String_duplicate> if ( !name ) { 105351: 85 c0 test %eax,%eax name = _Workspace_String_duplicate( name_arg, name_len ); 105353: 89 c3 mov %eax,%ebx if ( !name ) { 105355: 0f 84 e5 00 00 00 je 105440 the_mq->oflag = oflag; 10535b: 8b 45 0c mov 0xc(%ebp),%eax status = _CORE_message_queue_Initialize( 10535e: ba 60 78 10 00 mov $0x107860,%edx 105363: 31 c9 xor %ecx,%ecx the_mq->open_count = 1; 105365: c7 46 54 01 00 00 00 movl $0x1,0x54(%esi) the_mq->linked = true; 10536c: c6 46 50 01 movb $0x1,0x50(%esi) the_mq->oflag = oflag; 105370: 89 46 6c mov %eax,0x6c(%esi) status = _CORE_message_queue_Initialize( 105373: 31 c0 xor %eax,%eax 105375: 89 44 24 14 mov %eax,0x14(%esp) 105379: 89 54 24 10 mov %edx,0x10(%esp) 10537d: 8b 47 08 mov 0x8(%edi),%eax 105380: 89 44 24 0c mov %eax,0xc(%esp) 105384: 8b 47 04 mov 0x4(%edi),%eax 105387: 89 4c 24 04 mov %ecx,0x4(%esp) 10538b: 89 44 24 08 mov %eax,0x8(%esp) 10538f: 8d 46 10 lea 0x10(%esi),%eax 105392: 89 04 24 mov %eax,(%esp) 105395: e8 a6 1f 00 00 call 107340 <_CORE_message_queue_Initialize> if ( status != STATUS_SUCCESSFUL ) { 10539a: 85 c0 test %eax,%eax 10539c: 0f 85 ce 00 00 00 jne 105470 <== NEVER TAKEN the_object->name.name_p = name; 1053a2: 89 5e 0c mov %ebx,0xc(%esi) _Objects_Get_index( the_object->id ), 1053a5: 8b 46 08 mov 0x8(%esi),%eax information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 1053a8: 8b 15 44 91 12 00 mov 0x129144,%edx 1053ae: 0f b7 c8 movzwl %ax,%ecx 1053b1: 89 74 8a fc mov %esi,-0x4(%edx,%ecx,4) return the_mq->Object.id; 1053b5: e9 1a ff ff ff jmp 1052d4 1053ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi _RTEMS_Unlock_allocator(); 1053c0: e8 6b 1e 00 00 call 107230 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_value( 1053c5: 8b 5d e4 mov -0x1c(%ebp),%ebx 1053c8: e8 53 79 01 00 call 11cd20 <__errno> } 1053cd: 8b 75 f8 mov -0x8(%ebp),%esi 1053d0: 8b 7d fc mov -0x4(%ebp),%edi rtems_set_errno_and_return_value( 1053d3: 8b 14 9d 4c 44 12 00 mov 0x12444c(,%ebx,4),%edx } 1053da: 8b 5d f4 mov -0xc(%ebp),%ebx rtems_set_errno_and_return_value( 1053dd: 89 10 mov %edx,(%eax) } 1053df: 89 ec mov %ebp,%esp rtems_set_errno_and_return_value( 1053e1: b8 ff ff ff ff mov $0xffffffff,%eax } 1053e6: 5d pop %ebp 1053e7: c3 ret 1053e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1053ef: 90 nop 1053f0: e8 3b 1e 00 00 call 107230 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_value( EEXIST, MQ_OPEN_FAILED ); 1053f5: e8 26 79 01 00 call 11cd20 <__errno> 1053fa: c7 00 11 00 00 00 movl $0x11,(%eax) 105400: b8 ff ff ff ff mov $0xffffffff,%eax 105405: e9 d5 fe ff ff jmp 1052df 10540a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi attr = &_POSIX_Message_queue_Default_attributes; 105410: bf 30 44 12 00 mov $0x124430,%edi 105415: e9 11 ff ff ff jmp 10532b 10541a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi rtems_set_errno_and_return_value( EINVAL, MQ_OPEN_FAILED ); 105420: e8 fb 78 01 00 call 11cd20 <__errno> 105425: c7 00 16 00 00 00 movl $0x16,(%eax) 10542b: b8 ff ff ff ff mov $0xffffffff,%eax 105430: e9 9f fe ff ff jmp 1052d4 105435: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10543c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi ( *information->deallocate )( information, the_object ); 105440: 89 74 24 04 mov %esi,0x4(%esp) 105444: c7 04 24 40 91 12 00 movl $0x129140,(%esp) 10544b: ff 15 4c 91 12 00 call *0x12914c rtems_set_errno_and_return_value( ENOMEM, MQ_OPEN_FAILED ); 105451: e8 ca 78 01 00 call 11cd20 <__errno> 105456: c7 00 0c 00 00 00 movl $0xc,(%eax) 10545c: b8 ff ff ff ff mov $0xffffffff,%eax 105461: e9 6e fe ff ff jmp 1052d4 105466: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10546d: 8d 76 00 lea 0x0(%esi),%esi 105470: 89 74 24 04 mov %esi,0x4(%esp) 105474: c7 04 24 40 91 12 00 movl $0x129140,(%esp) 10547b: ff 15 4c 91 12 00 call *0x12914c _Workspace_Free( name ); 105481: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 105484: e8 57 79 00 00 call 10cde0 <_Workspace_Free> <== NOT EXECUTED rtems_set_errno_and_return_value( ENOSPC, MQ_OPEN_FAILED ); 105489: e8 92 78 01 00 call 11cd20 <__errno> 10548e: c7 00 1c 00 00 00 movl $0x1c,(%eax) 105494: b8 ff ff ff ff mov $0xffffffff,%eax 105499: e9 36 fe ff ff jmp 1052d4 10549e: 66 90 xchg %ax,%ax rtems_set_errno_and_return_value( ENFILE, MQ_OPEN_FAILED ); 1054a0: e8 7b 78 01 00 call 11cd20 <__errno> 1054a5: c7 00 17 00 00 00 movl $0x17,(%eax) 1054ab: b8 ff ff ff ff mov $0xffffffff,%eax 1054b0: e9 1f fe ff ff jmp 1052d4 1054b5: 90 nop 1054b6: 90 nop 1054b7: 90 nop 1054b8: 90 nop 1054b9: 90 nop 1054ba: 90 nop 1054bb: 90 nop 1054bc: 90 nop 1054bd: 90 nop 1054be: 90 nop 1054bf: 90 nop =============================================================================== 00109ae0 : int mq_setattr( mqd_t mqdes, const struct mq_attr *__restrict mqstat, struct mq_attr *__restrict omqstat ) { 109ae0: 55 push %ebp 109ae1: 89 e5 mov %esp,%ebp 109ae3: 56 push %esi 109ae4: 53 push %ebx 109ae5: 83 ec 40 sub $0x40,%esp 109ae8: 8b 75 0c mov 0xc(%ebp),%esi 109aeb: 8b 5d 10 mov 0x10(%ebp),%ebx POSIX_Message_queue_Control *the_mq; Thread_queue_Context queue_context; if ( mqstat == NULL ) { 109aee: 85 f6 test %esi,%esi 109af0: 74 69 je 109b5b return (POSIX_Message_queue_Control *) _Objects_Get( 109af2: 8d 45 d4 lea -0x2c(%ebp),%eax 109af5: b9 e0 5a 13 00 mov $0x135ae0,%ecx 109afa: 89 44 24 04 mov %eax,0x4(%esp) 109afe: 8b 45 08 mov 0x8(%ebp),%eax 109b01: 89 4c 24 08 mov %ecx,0x8(%esp) 109b05: 89 04 24 mov %eax,(%esp) 109b08: e8 63 29 00 00 call 10c470 <_Objects_Get> rtems_set_errno_and_return_minus_one( EINVAL ); } the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context ); if ( the_mq == NULL ) { 109b0d: 85 c0 test %eax,%eax 109b0f: 74 38 je 109b49 <== NEVER TAKEN _CORE_message_queue_Acquire_critical( &the_mq->Message_queue, &queue_context ); if ( the_mq->open_count == 0 ) { 109b11: 8b 50 54 mov 0x54(%eax),%edx 109b14: 85 d2 test %edx,%edx 109b16: 74 2d je 109b45 /* * Return the old values. */ if ( omqstat != NULL ) { 109b18: 85 db test %ebx,%ebx 109b1a: 74 17 je 109b33 omqstat->mq_flags = the_mq->oflag; 109b1c: 8b 50 6c mov 0x6c(%eax),%edx 109b1f: 89 13 mov %edx,(%ebx) omqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 109b21: 8b 50 28 mov 0x28(%eax),%edx 109b24: 89 53 08 mov %edx,0x8(%ebx) omqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 109b27: 8b 50 20 mov 0x20(%eax),%edx 109b2a: 89 53 04 mov %edx,0x4(%ebx) omqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 109b2d: 8b 50 24 mov 0x24(%eax),%edx 109b30: 89 53 0c mov %edx,0xc(%ebx) } the_mq->oflag = mqstat->mq_flags; 109b33: 8b 16 mov (%esi),%edx 109b35: 89 50 6c mov %edx,0x6c(%eax) _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 109b38: ff 75 d4 push -0x2c(%ebp) 109b3b: 9d popf _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context ); return 0; 109b3c: 31 c0 xor %eax,%eax } 109b3e: 83 c4 40 add $0x40,%esp 109b41: 5b pop %ebx 109b42: 5e pop %esi 109b43: 5d pop %ebp 109b44: c3 ret 109b45: ff 75 d4 push -0x2c(%ebp) 109b48: 9d popf rtems_set_errno_and_return_minus_one( EBADF ); 109b49: e8 62 71 01 00 call 120cb0 <__errno> 109b4e: c7 00 09 00 00 00 movl $0x9,(%eax) 109b54: b8 ff ff ff ff mov $0xffffffff,%eax 109b59: eb e3 jmp 109b3e rtems_set_errno_and_return_minus_one( EINVAL ); 109b5b: e8 50 71 01 00 call 120cb0 <__errno> 109b60: c7 00 16 00 00 00 movl $0x16,(%eax) 109b66: b8 ff ff ff ff mov $0xffffffff,%eax 109b6b: eb d1 jmp 109b3e 109b6d: 90 nop 109b6e: 90 nop 109b6f: 90 nop =============================================================================== 001057d0 : */ int mq_unlink( const char *name ) { 1057d0: 55 push %ebp 1057d1: 89 e5 mov %esp,%ebp 1057d3: 83 ec 48 sub $0x48,%esp 1057d6: 89 5d fc mov %ebx,-0x4(%ebp) _RTEMS_Lock_allocator(); 1057d9: e8 32 1a 00 00 call 107210 <_RTEMS_Lock_allocator> return (POSIX_Message_queue_Control *) _Objects_Get_by_name( 1057de: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 1057e1: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 1057e5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1057e7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1057eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1057ee: c7 04 24 40 91 12 00 movl $0x129140,(%esp) <== NOT EXECUTED 1057f5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1057f9: e8 92 3a 00 00 call 109290 <_Objects_Get_by_name> <== NOT EXECUTED Thread_queue_Context queue_context; _Objects_Allocator_lock(); the_mq = _POSIX_Message_queue_Get_by_name( name, NULL, &error ); if ( the_mq == NULL ) { 1057fe: 85 c0 test %eax,%eax 105800: 74 39 je 10583b _Objects_Namespace_remove_string( 105802: 89 44 24 04 mov %eax,0x4(%esp) 105806: 89 c3 mov %eax,%ebx 105808: c7 04 24 40 91 12 00 movl $0x129140,(%esp) 10580f: e8 5c 3a 00 00 call 109270 <_Objects_Namespace_remove_string> _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 105814: 9c pushf 105815: fa cli 105816: 58 pop %eax 105817: 89 45 d4 mov %eax,-0x2c(%ebp) _POSIX_Message_queue_Namespace_remove( the_mq ); _CORE_message_queue_Acquire( &the_mq->Message_queue, &queue_context ); the_mq->linked = false; 10581a: c6 43 50 00 movb $0x0,0x50(%ebx) _POSIX_Message_queue_Delete( the_mq, &queue_context ); 10581e: 8d 45 d4 lea -0x2c(%ebp),%eax 105821: 89 44 24 04 mov %eax,0x4(%esp) 105825: 89 1c 24 mov %ebx,(%esp) 105828: e8 d3 f9 ff ff call 105200 <_POSIX_Message_queue_Delete> _RTEMS_Unlock_allocator(); 10582d: e8 fe 19 00 00 call 107230 <_RTEMS_Unlock_allocator> _Objects_Allocator_unlock(); return 0; 105832: 31 c0 xor %eax,%eax } 105834: 8b 5d fc mov -0x4(%ebp),%ebx 105837: 89 ec mov %ebp,%esp 105839: 5d pop %ebp 10583a: c3 ret 10583b: e8 f0 19 00 00 call 107230 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_minus_one( _POSIX_Get_by_name_error( error ) ); 105840: 8b 5d d0 mov -0x30(%ebp),%ebx 105843: e8 d8 74 01 00 call 11cd20 <__errno> 105848: 8b 14 9d 4c 44 12 00 mov 0x12444c(,%ebx,4),%edx 10584f: 89 10 mov %edx,(%eax) 105851: b8 ff ff ff ff mov $0xffffffff,%eax 105856: eb dc jmp 105834 105858: 90 nop 105859: 90 nop 10585a: 90 nop 10585b: 90 nop 10585c: 90 nop 10585d: 90 nop 10585e: 90 nop 10585f: 90 nop =============================================================================== 001054f0 : #include #include int munmap(void *addr, size_t len) { 1054f0: 55 push %ebp 1054f1: 89 e5 mov %esp,%ebp 1054f3: 56 push %esi 1054f4: 53 push %ebx 1054f5: 83 ec 20 sub $0x20,%esp 1054f8: 8b 75 08 mov 0x8(%ebp),%esi rtems_chain_node *node; /* * Clear errno. */ errno = 0; 1054fb: e8 b0 5a 01 00 call 11afb0 <__errno> /* * Length cannot be 0. */ if ( len == 0 ) { 105500: 8b 4d 0c mov 0xc(%ebp),%ecx 105503: 85 c9 test %ecx,%ecx errno = 0; 105505: c7 00 00 00 00 00 movl $0x0,(%eax) if ( len == 0 ) { 10550b: 0f 84 ce 00 00 00 je 1055df <== NEVER TAKEN errno = EINVAL; return -1; } /* Check for illegal addresses. Watch out for address wrap. */ if (addr + len < addr) { 105511: 0f 88 c8 00 00 00 js 1055df <== NEVER TAKEN 105517: e8 d4 bb ff ff call 1010f0 return _Chain_Immutable_head( the_chain )->next; 10551c: 8b 1d a0 b3 12 00 mov 0x12b3a0,%ebx } mmap_mappings_lock_obtain(); node = rtems_chain_first (&mmap_mappings); while ( !rtems_chain_is_tail( &mmap_mappings, node )) { 105522: 81 fb a4 b3 12 00 cmp $0x12b3a4,%ebx 105528: 74 20 je 10554a <== NEVER TAKEN 10552a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi mapping = (mmap_mapping*) node; if ( ( addr >= mapping->addr ) && 105530: 8b 43 08 mov 0x8(%ebx),%eax 105533: 39 f0 cmp %esi,%eax 105535: 77 09 ja 105540 ( addr < ( mapping->addr + mapping->len )) ) { 105537: 8b 53 0c mov 0xc(%ebx),%edx 10553a: 01 d0 add %edx,%eax if ( ( addr >= mapping->addr ) && 10553c: 39 c6 cmp %eax,%esi 10553e: 72 20 jb 105560 return the_node->next; 105540: 8b 1b mov (%ebx),%ebx while ( !rtems_chain_is_tail( &mmap_mappings, node )) { 105542: 81 fb a4 b3 12 00 cmp $0x12b3a4,%ebx 105548: 75 e6 jne 105530 <== ALWAYS TAKEN rtems_libio_unlock(); 10554a: e8 c1 bb ff ff call 101110 } node = rtems_chain_next( node ); } mmap_mappings_lock_release( ); return 0; 10554f: 31 c0 xor %eax,%eax } 105551: 83 c4 20 add $0x20,%esp 105554: 5b pop %ebx 105555: 5e pop %esi 105556: 5d pop %ebp 105557: c3 ret 105558: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10555f: 90 nop if ( mapping->shm != NULL ) { 105560: 8b 73 14 mov 0x14(%ebx),%esi next = the_node->next; 105563: 8b 13 mov (%ebx),%edx previous = the_node->previous; 105565: 8b 43 04 mov 0x4(%ebx),%eax 105568: 85 f6 test %esi,%esi next->previous = previous; 10556a: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 10556d: 89 10 mov %edx,(%eax) 10556f: 74 3e je 1055af * * @see _Objects_Allocator_unlock() and _Objects_Allocate(). */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void ) { _RTEMS_Lock_allocator(); 105571: e8 9a 0d 00 00 call 106310 <_RTEMS_Lock_allocator> int err; err = 0; _Objects_Allocator_lock(); --shm->reference_count; 105576: ff 4e 1c decl 0x1c(%esi) if ( shm->reference_count == 0 ) { 105579: 75 0c jne 105587 <== ALWAYS TAKEN if ( (*shm->shm_object.ops->object_delete)( &shm->shm_object ) != 0 ) { 10557b: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED 10557e: 8d 56 20 lea 0x20(%esi),%edx <== NOT EXECUTED 105581: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 105584: ff 50 08 call *0x8(%eax) <== NOT EXECUTED err = EIO; } } /* check if the object has been unlinked yet. */ obj = _Objects_Get( shm->Object.id, &lock_ctx, &_POSIX_Shm_Information ); 105587: b8 40 b1 12 00 mov $0x12b140,%eax 10558c: 89 44 24 08 mov %eax,0x8(%esp) 105590: 8d 45 f4 lea -0xc(%ebp),%eax 105593: 89 44 24 04 mov %eax,0x4(%esp) 105597: 8b 46 08 mov 0x8(%esi),%eax 10559a: 89 04 24 mov %eax,(%esp) 10559d: e8 2e 22 00 00 call 1077d0 <_Objects_Get> if ( obj == NULL ) { 1055a2: 85 c0 test %eax,%eax 1055a4: 74 26 je 1055cc <== NEVER TAKEN /* if it was unlinked, then it can be freed. */ _POSIX_Shm_Free( shm ); } else { /* it will be freed when it is unlinked. */ _ISR_lock_ISR_enable( &lock_ctx ); 1055a6: ff 75 f4 push -0xc(%ebp) 1055a9: 9d popf * previous thread life protection state and thus may not return if the * executing thread was restarted or deleted in the mean-time. */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void ) { _RTEMS_Unlock_allocator(); 1055aa: e8 81 0d 00 00 call 106330 <_RTEMS_Unlock_allocator> if (( mapping->flags & MAP_SHARED ) != MAP_SHARED ) { 1055af: f6 43 10 11 testb $0x11,0x10(%ebx) 1055b3: 74 0a je 1055bf free( mapping ); 1055b5: 89 1c 24 mov %ebx,(%esp) 1055b8: e8 93 54 00 00 call 10aa50 break; 1055bd: eb 8b jmp 10554a free( mapping->addr ); 1055bf: 8b 43 08 mov 0x8(%ebx),%eax 1055c2: 89 04 24 mov %eax,(%esp) 1055c5: e8 86 54 00 00 call 10aa50 1055ca: eb e9 jmp 1055b5 Objects_Control *the_object ) { _Assert( _Objects_Allocator_is_owner() ); _Assert( information->deallocate != NULL ); ( *information->deallocate )( information, the_object ); 1055cc: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED 1055d0: c7 04 24 40 b1 12 00 movl $0x12b140,(%esp) <== NOT EXECUTED 1055d7: ff 15 4c b1 12 00 call *0x12b14c <== NOT EXECUTED } 1055dd: eb cb jmp 1055aa <== NOT EXECUTED errno = EINVAL; 1055df: e8 cc 59 01 00 call 11afb0 <__errno> <== NOT EXECUTED 1055e4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED return -1; 1055ea: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1055ef: e9 5d ff ff ff jmp 105551 <== NOT EXECUTED 1055f4: 90 nop 1055f5: 90 nop 1055f6: 90 nop 1055f7: 90 nop 1055f8: 90 nop 1055f9: 90 nop 1055fa: 90 nop 1055fb: 90 nop 1055fc: 90 nop 1055fd: 90 nop 1055fe: 90 nop 1055ff: 90 nop =============================================================================== 00104390 : int pthread_attr_getaffinity_np( const pthread_attr_t *attr, size_t cpusetsize, cpu_set_t *cpuset ) { 104390: 55 push %ebp 104391: 89 e5 mov %esp,%ebp 104393: 8b 45 08 mov 0x8(%ebp),%eax 104396: 8b 55 10 mov 0x10(%ebp),%edx if ( attr == NULL || !attr->is_initialized ) { 104399: 85 c0 test %eax,%eax 10439b: 74 23 je 1043c0 <== NEVER TAKEN return EINVAL; } if ( cpuset == NULL || cpusetsize != attr->affinitysetsize ) { 10439d: 8b 08 mov (%eax),%ecx 10439f: 85 c9 test %ecx,%ecx 1043a1: 74 1d je 1043c0 <== NEVER TAKEN 1043a3: 85 d2 test %edx,%edx 1043a5: 74 19 je 1043c0 <== NEVER TAKEN 1043a7: 8b 4d 0c mov 0xc(%ebp),%ecx 1043aa: 39 48 48 cmp %ecx,0x48(%eax) 1043ad: 75 11 jne 1043c0 <== NEVER TAKEN return CPU_ISSET_S(cpu, sizeof(*set), set); } static __inline void CPU_COPY(const cpu_set_t *src, cpu_set_t *dest) { BIT_COPY(_cpu_set_bits(setsize), src, dest); 1043af: 8b 40 4c mov 0x4c(%eax),%eax 1043b2: 8b 00 mov (%eax),%eax 1043b4: 89 02 mov %eax,(%edx) return EINVAL; } CPU_COPY( attr->affinityset, cpuset ); return 0; 1043b6: 31 c0 xor %eax,%eax } 1043b8: 5d pop %ebp 1043b9: c3 ret 1043ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 1043c0: 5d pop %ebp <== NOT EXECUTED return EINVAL; 1043c1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 1043c6: c3 ret <== NOT EXECUTED 1043c7: 90 nop 1043c8: 90 nop 1043c9: 90 nop 1043ca: 90 nop 1043cb: 90 nop 1043cc: 90 nop 1043cd: 90 nop 1043ce: 90 nop 1043cf: 90 nop =============================================================================== 00104540 : int pthread_attr_setaffinity_np( pthread_attr_t *attr, size_t cpusetsize, const cpu_set_t *cpuset ) { 104540: 55 push %ebp 104541: 89 e5 mov %esp,%ebp 104543: 8b 45 08 mov 0x8(%ebp),%eax 104546: 8b 55 10 mov 0x10(%ebp),%edx if ( attr == NULL || !attr->is_initialized ) { 104549: 85 c0 test %eax,%eax 10454b: 74 23 je 104570 <== NEVER TAKEN return EINVAL; } if ( cpuset == NULL || cpusetsize != attr->affinitysetsize ) { 10454d: 8b 08 mov (%eax),%ecx 10454f: 85 c9 test %ecx,%ecx 104551: 74 1d je 104570 <== NEVER TAKEN 104553: 85 d2 test %edx,%edx 104555: 74 19 je 104570 <== NEVER TAKEN 104557: 8b 4d 0c mov 0xc(%ebp),%ecx 10455a: 39 48 48 cmp %ecx,0x48(%eax) 10455d: 75 11 jne 104570 <== NEVER TAKEN 10455f: 8b 40 4c mov 0x4c(%eax),%eax 104562: 8b 12 mov (%edx),%edx 104564: 89 10 mov %edx,(%eax) return EINVAL; } CPU_COPY( cpuset, attr->affinityset ); return 0; 104566: 31 c0 xor %eax,%eax } 104568: 5d pop %ebp 104569: c3 ret 10456a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 104570: 5d pop %ebp <== NOT EXECUTED return EINVAL; 104571: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 104576: c3 ret <== NOT EXECUTED 104577: 90 nop 104578: 90 nop 104579: 90 nop 10457a: 90 nop 10457b: 90 nop 10457c: 90 nop 10457d: 90 nop 10457e: 90 nop 10457f: 90 nop =============================================================================== 00106480 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 106480: 55 push %ebp 106481: 89 e5 mov %esp,%ebp 106483: 8b 55 08 mov 0x8(%ebp),%edx 106486: 8b 45 0c mov 0xc(%ebp),%eax if ( !attr || !attr->is_initialized ) 106489: 85 d2 test %edx,%edx 10648b: 74 33 je 1064c0 10648d: 8b 0a mov (%edx),%ecx 10648f: 85 c9 test %ecx,%ecx 106491: 74 2d je 1064c0 return EINVAL; switch ( policy ) { 106493: 83 f8 02 cmp $0x2,%eax 106496: 7e 18 jle 1064b0 106498: 83 f8 04 cmp $0x4,%eax 10649b: 75 17 jne 1064b4 <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10649d: 89 42 14 mov %eax,0x14(%edx) return 0; 1064a0: 31 c0 xor %eax,%eax default: return ENOTSUP; } } 1064a2: 5d pop %ebp 1064a3: c3 ret 1064a4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1064ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1064af: 90 nop switch ( policy ) { 1064b0: 85 c0 test %eax,%eax 1064b2: 79 e9 jns 10649d } 1064b4: 5d pop %ebp switch ( policy ) { 1064b5: b8 86 00 00 00 mov $0x86,%eax } 1064ba: c3 ret 1064bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1064bf: 90 nop 1064c0: 5d pop %ebp return EINVAL; 1064c1: b8 16 00 00 00 mov $0x16,%eax } 1064c6: c3 ret 1064c7: 90 nop 1064c8: 90 nop 1064c9: 90 nop 1064ca: 90 nop 1064cb: 90 nop 1064cc: 90 nop 1064cd: 90 nop 1064ce: 90 nop 1064cf: 90 nop =============================================================================== 00104ee0 : /* * 18.2.1 Canceling Execution of a Thread, P1003.1c/Draft 10, p. 181 */ int pthread_cancel( pthread_t thread ) { 104ee0: 55 push %ebp 104ee1: 89 e5 mov %esp,%ebp 104ee3: 83 ec 28 sub $0x28,%esp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) { 104ee6: e8 15 1f 00 00 call 106e00 <_ISR_Is_in_progress> 104eeb: 84 c0 test %al,%al 104eed: 75 61 jne 104f50 return EPROTO; } the_thread = _Thread_Get( thread, &lock_context ); 104eef: 8d 45 f4 lea -0xc(%ebp),%eax 104ef2: 89 44 24 04 mov %eax,0x4(%esp) 104ef6: 8b 45 08 mov 0x8(%ebp),%eax 104ef9: 89 04 24 mov %eax,(%esp) 104efc: e8 8f 39 00 00 call 108890 <_Thread_Get> if ( the_thread == NULL ) { 104f01: 85 c0 test %eax,%eax 104f03: 74 7b je 104f80 const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 104f05: 8b 15 d0 d0 12 00 mov 0x12d0d0,%edx _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 104f0b: 42 inc %edx 104f0c: 89 15 d0 d0 12 00 mov %edx,0x12d0d0 return ESRCH; } cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _ISR_lock_ISR_enable( &lock_context ); 104f12: ff 75 f4 push -0xc(%ebp) 104f15: 9d popf static inline struct _Thread_Control *_Per_CPU_Get_executing( const Per_CPU_Control *cpu ) { return cpu->executing; 104f16: 8b 15 d8 d0 12 00 mov 0x12d0d8,%edx executing = _Per_CPU_Get_executing( cpu_self ); if ( the_thread == executing ) { _Thread_Exit( executing, THREAD_LIFE_TERMINATING, PTHREAD_CANCELED ); 104f1c: b9 ff ff ff ff mov $0xffffffff,%ecx 104f21: 89 4c 24 08 mov %ecx,0x8(%esp) if ( the_thread == executing ) { 104f25: 39 d0 cmp %edx,%eax 104f27: 74 37 je 104f60 <== NEVER TAKEN } else { _Thread_Cancel( the_thread, executing, PTHREAD_CANCELED ); 104f29: 89 54 24 04 mov %edx,0x4(%esp) 104f2d: 89 04 24 mov %eax,(%esp) 104f30: e8 6b 51 00 00 call 10a0a0 <_Thread_Cancel> } _Thread_Dispatch_enable( cpu_self ); 104f35: c7 04 24 c0 d0 12 00 movl $0x12d0c0,(%esp) 104f3c: e8 cf 38 00 00 call 108810 <_Thread_Dispatch_enable> return 0; 104f41: 31 c0 xor %eax,%eax } 104f43: 89 ec mov %ebp,%esp 104f45: 5d pop %ebp 104f46: c3 ret 104f47: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104f4e: 66 90 xchg %ax,%ax 104f50: 89 ec mov %ebp,%esp return EPROTO; 104f52: b8 47 00 00 00 mov $0x47,%eax } 104f57: 5d pop %ebp 104f58: c3 ret 104f59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi _Thread_Exit( executing, THREAD_LIFE_TERMINATING, PTHREAD_CANCELED ); 104f60: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104f63: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 104f68: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 104f6c: e8 2f 53 00 00 call 10a2a0 <_Thread_Exit> <== NOT EXECUTED 104f71: eb c2 jmp 104f35 <== NOT EXECUTED 104f73: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104f7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED return ESRCH; 104f80: b8 03 00 00 00 mov $0x3,%eax 104f85: eb bc jmp 104f43 104f87: 90 nop 104f88: 90 nop 104f89: 90 nop 104f8a: 90 nop 104f8b: 90 nop 104f8c: 90 nop 104f8d: 90 nop 104f8e: 90 nop 104f8f: 90 nop =============================================================================== 00104fc0 : */ int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 104fc0: 55 push %ebp 104fc1: 89 e5 mov %esp,%ebp 104fc3: 53 push %ebx 104fc4: 8b 45 08 mov 0x8(%ebp),%eax 104fc7: 8b 55 0c mov 0xc(%ebp),%edx POSIX_Condition_variables_Control *the_cond; the_cond = _POSIX_Condition_variables_Get( cond ); if ( the_cond == NULL ) { 104fca: 85 c0 test %eax,%eax 104fcc: 74 52 je 105020 <== NEVER TAKEN return EINVAL; } if ( attr == NULL ) { 104fce: 85 d2 test %edx,%edx 104fd0: 74 5e je 105030 attr = &_POSIX_Condition_variables_Default_attributes; } if ( !attr->is_initialized ) { 104fd2: 8b 0a mov (%edx),%ecx 104fd4: 85 c9 test %ecx,%ecx 104fd6: 74 48 je 105020 <== NEVER TAKEN return EINVAL; } if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) { 104fd8: 83 7a 0c 01 cmpl $0x1,0xc(%edx) 104fdc: 77 42 ja 105020 <== NEVER TAKEN queue->heads = NULL; 104fde: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) if ( the_attr->clock == CLOCK_MONOTONIC ) { 104fe5: 8b 5a 04 mov 0x4(%edx),%ebx flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC; 104fe8: 89 c1 mov %eax,%ecx queue->owner = NULL; 104fea: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) 104ff1: 81 f1 fe b1 df 18 xor $0x18dfb1fe,%ecx queue->name = name; 104ff7: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) flags &= ~POSIX_CONDITION_VARIABLES_FLAGS_MASK; 104ffe: 83 e1 fe and $0xfffffffe,%ecx the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 105001: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) if ( the_attr->clock == CLOCK_MONOTONIC ) { 105008: 83 f3 04 xor $0x4,%ebx 10500b: 0b 5a 08 or 0x8(%edx),%ebx 10500e: 75 03 jne 105013 <== ALWAYS TAKEN flags |= POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC; 105010: 83 c9 01 or $0x1,%ecx <== NOT EXECUTED the_cond->flags = flags; 105013: 89 08 mov %ecx,(%eax) return EINVAL; } _POSIX_Condition_variables_Initialize( the_cond, attr ); return 0; 105015: 31 c0 xor %eax,%eax } 105017: 5b pop %ebx 105018: 5d pop %ebp 105019: c3 ret 10501a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 105020: 5b pop %ebx return EINVAL; 105021: b8 16 00 00 00 mov $0x16,%eax } 105026: 5d pop %ebp 105027: c3 ret 105028: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10502f: 90 nop attr = &_POSIX_Condition_variables_Default_attributes; 105030: ba b0 2b 12 00 mov $0x122bb0,%edx 105035: eb 9b jmp 104fd2 105037: 90 nop 105038: 90 nop 105039: 90 nop 10503a: 90 nop 10503b: 90 nop 10503c: 90 nop 10503d: 90 nop 10503e: 90 nop 10503f: 90 nop =============================================================================== 00104e60 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 104e60: 55 push %ebp 104e61: 89 e5 mov %esp,%ebp 104e63: 8b 45 08 mov 0x8(%ebp),%eax if ( attr == NULL || !attr->is_initialized ) 104e66: 85 c0 test %eax,%eax 104e68: 74 16 je 104e80 104e6a: 8b 10 mov (%eax),%edx 104e6c: 85 d2 test %edx,%edx 104e6e: 74 10 je 104e80 <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 104e70: c7 00 00 00 00 00 movl $0x0,(%eax) return 0; 104e76: 31 c0 xor %eax,%eax } 104e78: 5d pop %ebp 104e79: c3 ret 104e7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 104e80: 5d pop %ebp return EINVAL; 104e81: b8 16 00 00 00 mov $0x16,%eax } 104e86: c3 ret 104e87: 90 nop 104e88: 90 nop 104e89: 90 nop 104e8a: 90 nop 104e8b: 90 nop 104e8c: 90 nop 104e8d: 90 nop 104e8e: 90 nop 104e8f: 90 nop =============================================================================== 00103fe0 : int pthread_condattr_getclock( const pthread_condattr_t *__restrict attr, clockid_t *__restrict clock ) { 103fe0: 55 push %ebp 103fe1: 89 e5 mov %esp,%ebp 103fe3: 8b 45 08 mov 0x8(%ebp),%eax 103fe6: 8b 55 0c mov 0xc(%ebp),%edx if ( attr == NULL ) { return EINVAL; } if ( clock == NULL ) { 103fe9: 85 c0 test %eax,%eax 103feb: 74 13 je 104000 <== NEVER TAKEN 103fed: 85 d2 test %edx,%edx 103fef: 74 0f je 104000 return EINVAL; } *clock = attr->clock; 103ff1: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 103ff4: 89 02 mov %eax,(%edx) <== NOT EXECUTED return 0; 103ff6: 31 c0 xor %eax,%eax <== NOT EXECUTED } 103ff8: 5d pop %ebp <== NOT EXECUTED 103ff9: c3 ret <== NOT EXECUTED 103ffa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED 104000: 5d pop %ebp return EINVAL; 104001: b8 16 00 00 00 mov $0x16,%eax } 104006: c3 ret 104007: 90 nop 104008: 90 nop 104009: 90 nop 10400a: 90 nop 10400b: 90 nop 10400c: 90 nop 10400d: 90 nop 10400e: 90 nop 10400f: 90 nop =============================================================================== 001066e0 : { 1066e0: 55 push %ebp 1066e1: 89 e5 mov %esp,%ebp 1066e3: 57 push %edi 1066e4: 56 push %esi 1066e5: 53 push %ebx 1066e6: 81 ec 9c 00 00 00 sub $0x9c,%esp 1066ec: 8b 45 10 mov 0x10(%ebp),%eax Thread_Entry_information entry = { 1066ef: c7 45 8c b0 99 10 00 movl $0x1099b0,-0x74(%ebp) 1066f6: 8b 55 14 mov 0x14(%ebp),%edx int schedpolicy = SCHED_RR; 1066f9: c7 45 84 02 00 00 00 movl $0x2,-0x7c(%ebp) { 106700: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Entry_information entry = { 106703: 89 45 90 mov %eax,-0x70(%ebp) if ( !start_routine ) 106706: 85 c0 test %eax,%eax Thread_Entry_information entry = { 106708: 89 55 94 mov %edx,-0x6c(%ebp) if ( !start_routine ) 10670b: 0f 84 ff 02 00 00 je 106a10 the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 106711: 85 db test %ebx,%ebx 106713: 0f 84 87 02 00 00 je 1069a0 if ( !the_attr->is_initialized ) 106719: 8b 33 mov (%ebx),%esi 10671b: 85 f6 test %esi,%esi 10671d: 0f 84 5d 02 00 00 je 106980 <== NEVER TAKEN memset( &config, 0, sizeof( config ) ); 106723: 31 d2 xor %edx,%edx 106725: 31 c0 xor %eax,%eax 106727: 89 54 05 bc mov %edx,-0x44(%ebp,%eax,1) 10672b: 89 54 05 c0 mov %edx,-0x40(%ebp,%eax,1) 10672f: 83 c0 08 add $0x8,%eax 106732: 83 f8 28 cmp $0x28,%eax 106735: 72 f0 jb 106727 if ( the_attr->stackaddr != NULL ) { 106737: 8b 4b 04 mov 0x4(%ebx),%ecx memset( &config, 0, sizeof( config ) ); 10673a: 31 d2 xor %edx,%edx 10673c: 89 54 05 bc mov %edx,-0x44(%ebp,%eax,1) if ( !_Stack_Is_enough( the_attr->stacksize, config.is_fp ) ) { 106740: 8b 73 08 mov 0x8(%ebx),%esi config.is_fp = true; 106743: 66 c7 45 e4 01 01 movw $0x101,-0x1c(%ebp) if ( the_attr->stackaddr != NULL ) { 106749: 85 c9 test %ecx,%ecx 10674b: 0f 84 5f 02 00 00 je 1069b0 bool is_fp ) { size_t minimum; minimum = _TLS_Get_allocation_size(); 106751: e8 3a 50 00 00 call 10b790 <_TLS_Get_allocation_size> minimum += _Stack_Minimum(); #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { minimum += CONTEXT_FP_SIZE; 106756: 8b 15 54 43 1a 00 mov 0x1a4354,%edx 10675c: 8d 44 02 6c lea 0x6c(%edx,%eax,1),%eax if ( !_Stack_Is_enough( the_attr->stacksize, config.is_fp ) ) { 106760: 39 c6 cmp %eax,%esi 106762: 0f 82 18 02 00 00 jb 106980 <== NEVER TAKEN config.stack_area = the_attr->stackaddr; 106768: 8b 43 04 mov 0x4(%ebx),%eax 10676b: 89 45 c0 mov %eax,-0x40(%ebp) config.stack_size = the_attr->stacksize; 10676e: 8b 43 08 mov 0x8(%ebx),%eax 106771: 89 45 c4 mov %eax,-0x3c(%ebp) switch ( the_attr->inheritsched ) { 106774: 8b 43 10 mov 0x10(%ebx),%eax 106777: 83 f8 01 cmp $0x1,%eax 10677a: 0f 84 57 02 00 00 je 1069d7 <== ALWAYS TAKEN 106780: 83 f8 02 cmp $0x2,%eax 106783: 0f 85 f7 01 00 00 jne 106980 <== NEVER TAKEN schedpolicy = the_attr->schedpolicy; 106789: 8b 43 14 mov 0x14(%ebx),%eax 10678c: 89 45 84 mov %eax,-0x7c(%ebp) schedparam = the_attr->schedparam; 10678f: 31 c0 xor %eax,%eax 106791: 8b 54 03 18 mov 0x18(%ebx,%eax,1),%edx 106795: 89 54 05 98 mov %edx,-0x68(%ebp,%eax,1) 106799: 83 c0 04 add $0x4,%eax 10679c: 83 f8 24 cmp $0x24,%eax 10679f: 72 f0 jb 106791 if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 1067a1: 8b 7b 0c mov 0xc(%ebx),%edi 1067a4: 85 ff test %edi,%edi 1067a6: 0f 85 51 02 00 00 jne 1069fd <== NEVER TAKEN error = _POSIX_Thread_Translate_sched_param( 1067ac: 8d 45 d8 lea -0x28(%ebp),%eax 1067af: 89 44 24 0c mov %eax,0xc(%esp) 1067b3: 8d 45 d4 lea -0x2c(%ebp),%eax 1067b6: 89 44 24 08 mov %eax,0x8(%esp) 1067ba: 8d 45 98 lea -0x68(%ebp),%eax 1067bd: 89 44 24 04 mov %eax,0x4(%esp) 1067c1: 8b 45 84 mov -0x7c(%ebp),%eax 1067c4: 89 04 24 mov %eax,(%esp) 1067c7: e8 34 6c 00 00 call 10d400 <_POSIX_Thread_Translate_sched_param> if ( error != 0 ) { 1067cc: 85 c0 test %eax,%eax error = _POSIX_Thread_Translate_sched_param( 1067ce: 89 c7 mov %eax,%edi if ( error != 0 ) { 1067d0: 0f 85 af 01 00 00 jne 106985 config.priority = _POSIX_Priority_To_core( 1067d6: c7 04 24 c0 6c 18 00 movl $0x186cc0,(%esp) normal_prio = schedparam.sched_priority; 1067dd: 8b 75 98 mov -0x68(%ebp),%esi config.priority = _POSIX_Priority_To_core( 1067e0: 8d 4d 83 lea -0x7d(%ebp),%ecx 1067e3: 89 4c 24 08 mov %ecx,0x8(%esp) config.scheduler = _Thread_Scheduler_get_home( executing ); 1067e7: c7 45 bc c0 6c 18 00 movl $0x186cc0,-0x44(%ebp) config.priority = _POSIX_Priority_To_core( 1067ee: 89 74 24 04 mov %esi,0x4(%esp) 1067f2: e8 29 5d 00 00 call 10c520 <_POSIX_Priority_To_core> if ( !valid ) { 1067f7: 80 7d 83 00 cmpb $0x0,-0x7d(%ebp) config.priority = _POSIX_Priority_To_core( 1067fb: 89 45 cc mov %eax,-0x34(%ebp) 1067fe: 89 55 d0 mov %edx,-0x30(%ebp) if ( !valid ) { 106801: 0f 84 79 01 00 00 je 106980 <== NEVER TAKEN if ( schedpolicy == SCHED_SPORADIC ) { 106807: 83 7d 84 04 cmpl $0x4,-0x7c(%ebp) 10680b: 8d 4d 83 lea -0x7d(%ebp),%ecx 10680e: 75 03 jne 106813 low_prio = schedparam.sched_ss_low_priority; 106810: 8b 75 9c mov -0x64(%ebp),%esi core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid ); 106813: 89 4c 24 08 mov %ecx,0x8(%esp) 106817: 8b 45 bc mov -0x44(%ebp),%eax 10681a: 89 74 24 04 mov %esi,0x4(%esp) 10681e: 89 04 24 mov %eax,(%esp) 106821: e8 fa 5c 00 00 call 10c520 <_POSIX_Priority_To_core> if ( !valid ) { 106826: 80 7d 83 00 cmpb $0x0,-0x7d(%ebp) core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid ); 10682a: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 106830: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) if ( !valid ) { 106836: 0f 84 44 01 00 00 je 106980 if ( the_attr->affinityset == NULL ) { 10683c: 8b 73 4c mov 0x4c(%ebx),%esi 10683f: 85 f6 test %esi,%esi 106841: 0f 84 39 01 00 00 je 106980 <== NEVER TAKEN * * @see _Objects_Allocator_unlock() and _Objects_Allocate(). */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void ) { _RTEMS_Lock_allocator(); 106847: e8 e4 0a 00 00 call 107330 <_RTEMS_Lock_allocator> RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void) { _Objects_Allocator_lock(); _Thread_Kill_zombies(); 10684c: e8 9f 48 00 00 call 10b0f0 <_Thread_Kill_zombies> _Assert( _Objects_Allocator_is_owner() || !_System_state_Is_up( _System_state_Get() ) ); return ( *information->allocate )( information ); 106851: c7 04 24 60 43 1a 00 movl $0x1a4360,(%esp) 106858: ff 15 68 43 1a 00 call *0x1a4368 if ( !the_thread ) { 10685e: 85 c0 test %eax,%eax 106860: 89 c6 mov %eax,%esi 106862: 0f 84 e8 01 00 00 je 106a50 if ( config.stack_area == NULL ) { 106868: 8b 4d c0 mov -0x40(%ebp),%ecx 10686b: 85 c9 test %ecx,%ecx 10686d: 0f 84 af 01 00 00 je 106a22 config.stack_free = _Stack_Free_nothing; 106873: c7 45 c8 70 92 10 00 movl $0x109270,-0x38(%ebp) status = _Thread_Initialize( 10687a: 89 74 24 04 mov %esi,0x4(%esp) 10687e: 8d 45 bc lea -0x44(%ebp),%eax 106881: 89 44 24 08 mov %eax,0x8(%esp) 106885: c7 04 24 60 43 1a 00 movl $0x1a4360,(%esp) 10688c: e8 9f 32 00 00 call 109b30 <_Thread_Initialize> if ( !status ) { 106891: 84 c0 test %al,%al 106893: 0f 84 a6 01 00 00 je 106a3f <== NEVER TAKEN if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) { 106899: 8b 53 44 mov 0x44(%ebx),%edx the_thread->Life.state |= THREAD_LIFE_DETACHED; 10689c: 8b 86 20 01 00 00 mov 0x120(%esi),%eax if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) { 1068a2: 85 d2 test %edx,%edx 1068a4: 75 03 jne 1068a9 the_thread->Life.state |= THREAD_LIFE_DETACHED; 1068a6: 83 c8 10 or $0x10,%eax the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED; 1068a9: 83 c8 08 or $0x8,%eax 1068ac: 89 86 20 01 00 00 mov %eax,0x120(%esi) _ISR_lock_ISR_disable( &lock_context ); 1068b2: 9c pushf 1068b3: fa cli 1068b4: 58 pop %eax 1068b5: 89 45 88 mov %eax,-0x78(%ebp) status = _Scheduler_Set_affinity( 1068b8: 8b 43 4c mov 0x4c(%ebx),%eax 1068bb: 89 44 24 08 mov %eax,0x8(%esp) 1068bf: 8b 43 48 mov 0x48(%ebx),%eax 1068c2: 89 34 24 mov %esi,(%esp) 1068c5: 89 44 24 04 mov %eax,0x4(%esp) 1068c9: e8 52 29 00 00 call 109220 <_Scheduler_Set_affinity> _ISR_lock_ISR_enable( &lock_context ); 1068ce: ff 75 88 push -0x78(%ebp) 1068d1: 9d popf if ( !status ) { 1068d2: 84 c0 test %al,%al 1068d4: 0f 84 82 00 00 00 je 10695c <== NEVER TAKEN api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1068da: 8b 86 0c 01 00 00 mov 0x10c(%esi),%eax RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 1068e0: 8b 95 70 ff ff ff mov -0x90(%ebp),%edx ( the_attr->inheritsched == PTHREAD_INHERIT_SCHED ); 1068e6: 83 7b 10 01 cmpl $0x1,0x10(%ebx) 1068ea: 8b 8d 74 ff ff ff mov -0x8c(%ebp),%ecx the_thread->was_created_with_inherited_scheduler = 1068f0: 0f 94 86 83 00 00 00 sete 0x83(%esi) if ( schedpolicy == SCHED_SPORADIC ) { 1068f7: 83 7d 84 04 cmpl $0x4,-0x7c(%ebp) 1068fb: 89 50 30 mov %edx,0x30(%eax) api->Sporadic.sched_ss_repl_period = 1068fe: 8b 53 20 mov 0x20(%ebx),%edx 106901: 89 48 34 mov %ecx,0x34(%eax) 106904: 89 50 38 mov %edx,0x38(%eax) 106907: 8b 53 24 mov 0x24(%ebx),%edx 10690a: 89 50 3c mov %edx,0x3c(%eax) 10690d: 8b 53 28 mov 0x28(%ebx),%edx 106910: 89 50 40 mov %edx,0x40(%eax) api->Sporadic.sched_ss_init_budget = 106913: 8b 53 2c mov 0x2c(%ebx),%edx 106916: 89 50 44 mov %edx,0x44(%eax) 106919: 8b 53 30 mov 0x30(%ebx),%edx 10691c: 89 50 48 mov %edx,0x48(%eax) 10691f: 8b 53 34 mov 0x34(%ebx),%edx api->Sporadic.sched_ss_max_repl = 106922: 8b 5b 38 mov 0x38(%ebx),%ebx api->Sporadic.sched_ss_init_budget = 106925: 89 50 4c mov %edx,0x4c(%eax) api->Sporadic.sched_ss_max_repl = 106928: 89 58 50 mov %ebx,0x50(%eax) if ( schedpolicy == SCHED_SPORADIC ) { 10692b: 0f 84 2e 01 00 00 je 106a5f _ISR_lock_ISR_disable( &lock_context ); 106931: 9c pushf 106932: fa cli 106933: 58 pop %eax 106934: 89 45 88 mov %eax,-0x78(%ebp) status = _Thread_Start( the_thread, &entry, &lock_context ); 106937: 89 34 24 mov %esi,(%esp) 10693a: 8d 45 88 lea -0x78(%ebp),%eax 10693d: 89 44 24 08 mov %eax,0x8(%esp) 106941: 8d 45 8c lea -0x74(%ebp),%eax 106944: 89 44 24 04 mov %eax,0x4(%esp) 106948: e8 13 4b 00 00 call 10b460 <_Thread_Start> *thread = the_thread->Object.id; 10694d: 8b 56 08 mov 0x8(%esi),%edx 106950: 8b 45 08 mov 0x8(%ebp),%eax 106953: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 106955: e8 f6 09 00 00 call 107350 <_RTEMS_Unlock_allocator> return 0; 10695a: eb 29 jmp 106985 Objects_Control *the_object ) { _Assert( _Objects_Allocator_is_owner() ); _Assert( information->deallocate != NULL ); ( *information->deallocate )( information, the_object ); 10695c: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED 106960: c7 04 24 60 43 1a 00 movl $0x1a4360,(%esp) <== NOT EXECUTED 106967: ff 15 6c 43 1a 00 call *0x1a436c <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10696d: e8 de 09 00 00 call 107350 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 106972: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 106979: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED return EINVAL; 106980: bf 16 00 00 00 mov $0x16,%edi } 106985: 81 c4 9c 00 00 00 add $0x9c,%esp 10698b: 89 f8 mov %edi,%eax 10698d: 5b pop %ebx 10698e: 5e pop %esi 10698f: 5f pop %edi 106990: 5d pop %ebp 106991: c3 ret 106992: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 106999: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 1069a0: bb 60 7d 18 00 mov $0x187d60,%ebx 1069a5: e9 6f fd ff ff jmp 106719 1069aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if ( size >= PTHREAD_MINIMUM_STACK_SIZE ) 1069b0: a1 6c 6c 18 00 mov 0x186c6c,%eax 1069b5: 39 f0 cmp %esi,%eax 1069b7: 73 02 jae 1069bb 1069b9: 89 f0 mov %esi,%eax config.stack_size = _POSIX_Threads_Ensure_minimum_stack( 1069bb: 89 45 c4 mov %eax,-0x3c(%ebp) bool is_fp ) { #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { stack_size += CONTEXT_FP_SIZE; 1069be: 8d 70 6c lea 0x6c(%eax),%esi } #else (void) is_fp; #endif stack_size += _TLS_Get_allocation_size(); 1069c1: e8 ca 4d 00 00 call 10b790 <_TLS_Get_allocation_size> 1069c6: 01 f0 add %esi,%eax 1069c8: 89 45 c4 mov %eax,-0x3c(%ebp) switch ( the_attr->inheritsched ) { 1069cb: 8b 43 10 mov 0x10(%ebx),%eax 1069ce: 83 f8 01 cmp $0x1,%eax 1069d1: 0f 85 a9 fd ff ff jne 106780 error = pthread_getschedparam( 1069d7: e8 24 06 00 00 call 107000 1069dc: 8d 55 98 lea -0x68(%ebp),%edx 1069df: 89 54 24 08 mov %edx,0x8(%esp) 1069e3: 8d 55 84 lea -0x7c(%ebp),%edx 1069e6: 89 54 24 04 mov %edx,0x4(%esp) 1069ea: 89 04 24 mov %eax,(%esp) 1069ed: e8 ee 03 00 00 call 106de0 if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 1069f2: 8b 7b 0c mov 0xc(%ebx),%edi 1069f5: 85 ff test %edi,%edi 1069f7: 0f 84 af fd ff ff je 1067ac } 1069fd: 81 c4 9c 00 00 00 add $0x9c,%esp return ENOTSUP; 106a03: bf 86 00 00 00 mov $0x86,%edi } 106a08: 5b pop %ebx 106a09: 89 f8 mov %edi,%eax 106a0b: 5e pop %esi 106a0c: 5f pop %edi 106a0d: 5d pop %ebp 106a0e: c3 ret 106a0f: 90 nop 106a10: 81 c4 9c 00 00 00 add $0x9c,%esp return EFAULT; 106a16: bf 0e 00 00 00 mov $0xe,%edi } 106a1b: 5b pop %ebx 106a1c: 89 f8 mov %edi,%eax 106a1e: 5e pop %esi 106a1f: 5f pop %edi 106a20: 5d pop %ebp 106a21: c3 ret config.stack_free = _Stack_Free; 106a22: c7 45 c8 50 b4 10 00 movl $0x10b450,-0x38(%ebp) config.stack_area = _Stack_Allocate( config.stack_size ); 106a29: 8b 45 c4 mov -0x3c(%ebp),%eax 106a2c: 89 04 24 mov %eax,(%esp) 106a2f: e8 0c 4a 00 00 call 10b440 <_Stack_Allocate> 106a34: 89 45 c0 mov %eax,-0x40(%ebp) if ( status ) { 106a37: 85 c0 test %eax,%eax 106a39: 0f 85 3b fe ff ff jne 10687a 106a3f: 89 74 24 04 mov %esi,0x4(%esp) 106a43: c7 04 24 60 43 1a 00 movl $0x1a4360,(%esp) 106a4a: ff 15 6c 43 1a 00 call *0x1a436c _RTEMS_Unlock_allocator(); 106a50: e8 fb 08 00 00 call 107350 <_RTEMS_Unlock_allocator> return EAGAIN; 106a55: bf 0b 00 00 00 mov $0xb,%edi 106a5a: e9 26 ff ff ff jmp 106985 _POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer ); 106a5f: 83 c0 04 add $0x4,%eax 106a62: 89 04 24 mov %eax,(%esp) 106a65: e8 46 fb ff ff call 1065b0 <_POSIX_Threads_Sporadic_timer> 106a6a: e9 c2 fe ff ff jmp 106931 106a6f: 90 nop =============================================================================== 00106ba0 : int pthread_getaffinity_np( pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset ) { 106ba0: 55 push %ebp 106ba1: 89 e5 mov %esp,%ebp 106ba3: 83 ec 28 sub $0x28,%esp 106ba6: 89 5d fc mov %ebx,-0x4(%ebp) 106ba9: 8b 5d 10 mov 0x10(%ebp),%ebx Thread_Control *the_thread; ISR_lock_Context lock_context; Per_CPU_Control *cpu_self; bool ok; if ( cpuset == NULL ) { 106bac: 85 db test %ebx,%ebx 106bae: 74 60 je 106c10 return EFAULT; } the_thread = _Thread_Get( thread, &lock_context ); 106bb0: 8d 45 f4 lea -0xc(%ebp),%eax 106bb3: 89 44 24 04 mov %eax,0x4(%esp) 106bb7: 8b 45 08 mov 0x8(%ebp),%eax 106bba: 89 04 24 mov %eax,(%esp) 106bbd: e8 3e 49 00 00 call 10b500 <_Thread_Get> if ( the_thread == NULL ) { 106bc2: 85 c0 test %eax,%eax 106bc4: 74 5a je 106c20 } cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _Thread_State_acquire_critical( the_thread, &lock_context ); ok = _Scheduler_Get_affinity( 106bc6: 89 5c 24 08 mov %ebx,0x8(%esp) const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 106bca: 8b 15 30 cf 12 00 mov 0x12cf30,%edx 106bd0: 89 04 24 mov %eax,(%esp) _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 106bd3: 42 inc %edx 106bd4: 89 15 30 cf 12 00 mov %edx,0x12cf30 106bda: 8b 55 0c mov 0xc(%ebp),%edx 106bdd: 89 54 24 04 mov %edx,0x4(%esp) 106be1: e8 3a 3a 00 00 call 10a620 <_Scheduler_Get_affinity> 106be6: 88 c3 mov %al,%bl Thread_Control *the_thread, ISR_lock_Context *lock_context ) { _Thread_State_release_critical( the_thread, lock_context ); _ISR_lock_ISR_enable( lock_context ); 106be8: ff 75 f4 push -0xc(%ebp) 106beb: 9d popf cpusetsize, cpuset ); _Thread_State_release( the_thread, &lock_context ); _Thread_Dispatch_enable( cpu_self ); 106bec: c7 04 24 20 cf 12 00 movl $0x12cf20,(%esp) 106bf3: e8 98 48 00 00 call 10b490 <_Thread_Dispatch_enable> return ok ? 0 : EINVAL; 106bf8: 80 fb 01 cmp $0x1,%bl } 106bfb: 8b 5d fc mov -0x4(%ebp),%ebx return ok ? 0 : EINVAL; 106bfe: 19 c0 sbb %eax,%eax } 106c00: 89 ec mov %ebp,%esp 106c02: 5d pop %ebp return ok ? 0 : EINVAL; 106c03: 83 e0 16 and $0x16,%eax } 106c06: c3 ret 106c07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 106c0e: 66 90 xchg %ax,%ax 106c10: 8b 5d fc mov -0x4(%ebp),%ebx 106c13: 89 ec mov %ebp,%esp return EFAULT; 106c15: b8 0e 00 00 00 mov $0xe,%eax } 106c1a: 5d pop %ebp 106c1b: c3 ret 106c1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 106c20: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106c23: 89 ec mov %ebp,%esp <== NOT EXECUTED return ESRCH; 106c25: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 106c2a: 5d pop %ebp <== NOT EXECUTED 106c2b: c3 ret <== NOT EXECUTED 106c2c: 90 nop 106c2d: 90 nop 106c2e: 90 nop 106c2f: 90 nop =============================================================================== 00106b30 : int pthread_getattr_np( pthread_t thread, pthread_attr_t *attr ) { 106b30: 55 push %ebp 106b31: 89 e5 mov %esp,%ebp 106b33: 57 push %edi 106b34: 56 push %esi 106b35: 53 push %ebx 106b36: 83 ec 3c sub $0x3c,%esp 106b39: 8b 7d 0c mov 0xc(%ebp),%edi Thread_CPU_budget_algorithms budget_algorithm; const Scheduler_Control *scheduler; Priority_Control priority; bool ok; if ( attr == NULL ) { 106b3c: 85 ff test %edi,%edi 106b3e: 0f 84 7c 01 00 00 je 106cc0 return EINVAL; } attr = memset( attr, 0, sizeof( *attr ) ); 106b44: 31 db xor %ebx,%ebx 106b46: f7 c7 01 00 00 00 test $0x1,%edi 106b4c: 89 f9 mov %edi,%ecx 106b4e: be 54 00 00 00 mov $0x54,%esi 106b53: 0f 85 d7 01 00 00 jne 106d30 <== NEVER TAKEN 106b59: f6 c1 02 test $0x2,%cl 106b5c: 0f 85 de 01 00 00 jne 106d40 <== NEVER TAKEN 106b62: 89 f2 mov %esi,%edx 106b64: 31 c0 xor %eax,%eax 106b66: 83 e2 f8 and $0xfffffff8,%edx 106b69: 89 1c 01 mov %ebx,(%ecx,%eax,1) 106b6c: 89 5c 01 04 mov %ebx,0x4(%ecx,%eax,1) 106b70: 83 c0 08 add $0x8,%eax 106b73: 39 d0 cmp %edx,%eax 106b75: 72 f2 jb 106b69 106b77: 01 c1 add %eax,%ecx 106b79: f7 c6 04 00 00 00 test $0x4,%esi 106b7f: 0f 85 7b 01 00 00 jne 106d00 <== ALWAYS TAKEN 106b85: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 106b8b: 0f 85 4f 01 00 00 jne 106ce0 <== NOT EXECUTED 106b91: 83 e6 01 and $0x1,%esi 106b94: 0f 85 36 01 00 00 jne 106cd0 <== NEVER TAKEN the_thread = _Thread_Get( thread, &lock_context ); 106b9a: 8d 45 e4 lea -0x1c(%ebp),%eax 106b9d: 89 44 24 04 mov %eax,0x4(%esp) 106ba1: 8b 45 08 mov 0x8(%ebp),%eax 106ba4: 89 04 24 mov %eax,(%esp) 106ba7: e8 34 2e 00 00 call 1099e0 <_Thread_Get> if ( the_thread == NULL ) { 106bac: 85 c0 test %eax,%eax the_thread = _Thread_Get( thread, &lock_context ); 106bae: 89 c6 mov %eax,%esi if ( the_thread == NULL ) { 106bb0: 0f 84 6a 01 00 00 je 106d20 return ESRCH; } _Thread_State_acquire_critical( the_thread, &lock_context ); attr->stackaddr = the_thread->Start.Initial_stack.area; 106bb6: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax ) { #if defined(RTEMS_POSIX_API) const POSIX_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 106bbc: 8b 9e 0c 01 00 00 mov 0x10c(%esi),%ebx attr->stacksize = the_thread->Start.Initial_stack.size; if ( the_thread->was_created_with_inherited_scheduler ) { attr->inheritsched = PTHREAD_INHERIT_SCHED; } else { attr->inheritsched = PTHREAD_EXPLICIT_SCHED; 106bc2: 80 be 83 00 00 00 01 cmpb $0x1,0x83(%esi) attr->stackaddr = the_thread->Start.Initial_stack.area; 106bc9: 89 47 04 mov %eax,0x4(%edi) attr->stacksize = the_thread->Start.Initial_stack.size; 106bcc: 8b 86 c0 00 00 00 mov 0xc0(%esi),%eax param->sched_ss_low_priority = _POSIX_Priority_From_core( 106bd2: 8b 53 34 mov 0x34(%ebx),%edx 106bd5: 89 47 08 mov %eax,0x8(%edi) attr->inheritsched = PTHREAD_EXPLICIT_SCHED; 106bd8: b8 02 00 00 00 mov $0x2,%eax 106bdd: 83 d0 ff adc $0xffffffff,%eax 106be0: 89 47 10 mov %eax,0x10(%edi) 106be3: 8b 43 30 mov 0x30(%ebx),%eax 106be6: 89 54 24 08 mov %edx,0x8(%esp) 106bea: c7 04 24 c0 6c 18 00 movl $0x186cc0,(%esp) 106bf1: 89 44 24 04 mov %eax,0x4(%esp) 106bf5: e8 86 59 00 00 call 10c580 <_POSIX_Priority_From_core> scheduler, &attr->schedparam ); priority = the_thread->Real_priority.priority; if ( _Thread_Is_joinable( the_thread ) ) { 106bfa: 8b 8e 20 01 00 00 mov 0x120(%esi),%ecx priority = the_thread->Real_priority.priority; 106c00: 8b 56 34 mov 0x34(%esi),%edx if ( _Thread_Is_joinable( the_thread ) ) { 106c03: c1 e9 04 shr $0x4,%ecx priority = the_thread->Real_priority.priority; 106c06: 89 55 d4 mov %edx,-0x2c(%ebp) 106c09: 89 47 1c mov %eax,0x1c(%edi) scheduler, api->Sporadic.Low_priority.priority ); param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period; 106c0c: 8b 43 38 mov 0x38(%ebx),%eax 106c0f: 89 47 20 mov %eax,0x20(%edi) 106c12: 8b 43 3c mov 0x3c(%ebx),%eax 106c15: 89 47 24 mov %eax,0x24(%edi) 106c18: 8b 43 40 mov 0x40(%ebx),%eax 106c1b: 89 47 28 mov %eax,0x28(%edi) param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget; 106c1e: 8b 43 44 mov 0x44(%ebx),%eax 106c21: 89 47 2c mov %eax,0x2c(%edi) 106c24: 8b 43 48 mov 0x48(%ebx),%eax 106c27: 89 47 30 mov %eax,0x30(%edi) 106c2a: 8b 43 4c mov 0x4c(%ebx),%eax 106c2d: 89 47 34 mov %eax,0x34(%edi) param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl; 106c30: 8b 43 50 mov 0x50(%ebx),%eax 106c33: 89 47 38 mov %eax,0x38(%edi) 106c36: 8b 46 30 mov 0x30(%esi),%eax } else { attr->detachstate = PTHREAD_CREATE_DETACHED; } attr->affinityset = &attr->affinitysetpreallocated; attr->affinitysetsize = sizeof( attr->affinitysetpreallocated ); 106c39: c7 47 48 04 00 00 00 movl $0x4,0x48(%edi) priority = the_thread->Real_priority.priority; 106c40: 89 45 d0 mov %eax,-0x30(%ebp) if ( _Thread_Is_joinable( the_thread ) ) { 106c43: 89 c8 mov %ecx,%eax 106c45: 83 f0 01 xor $0x1,%eax 106c48: 83 e0 01 and $0x1,%eax 106c4b: 89 47 44 mov %eax,0x44(%edi) attr->affinityset = &attr->affinitysetpreallocated; 106c4e: 8d 47 50 lea 0x50(%edi),%eax 106c51: 89 47 4c mov %eax,0x4c(%edi) ok = _Scheduler_Get_affinity( 106c54: 89 44 24 08 mov %eax,0x8(%esp) 106c58: b8 04 00 00 00 mov $0x4,%eax 106c5d: 89 34 24 mov %esi,(%esp) 106c60: 89 44 24 04 mov %eax,0x4(%esp) 106c64: e8 57 1e 00 00 call 108ac0 <_Scheduler_Get_affinity> the_thread, attr->affinitysetsize, attr->affinityset ); budget_algorithm = the_thread->budget_algorithm; 106c69: 8b b6 88 00 00 00 mov 0x88(%esi),%esi ok = _Scheduler_Get_affinity( 106c6f: 88 c3 mov %al,%bl _ISR_lock_ISR_enable( lock_context ); 106c71: ff 75 e4 push -0x1c(%ebp) 106c74: 9d popf _Thread_State_release( the_thread, &lock_context ); attr->is_initialized = true; 106c75: c7 07 01 00 00 00 movl $0x1,(%edi) attr->contentionscope = PTHREAD_SCOPE_PROCESS; attr->cputime_clock_allowed = 1; attr->schedparam.sched_priority = _POSIX_Priority_From_core( 106c7b: 8b 55 d4 mov -0x2c(%ebp),%edx attr->contentionscope = PTHREAD_SCOPE_PROCESS; 106c7e: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) attr->schedparam.sched_priority = _POSIX_Priority_From_core( 106c85: 8b 45 d0 mov -0x30(%ebp),%eax attr->cputime_clock_allowed = 1; 106c88: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi) attr->schedparam.sched_priority = _POSIX_Priority_From_core( 106c8f: c7 04 24 c0 6c 18 00 movl $0x186cc0,(%esp) 106c96: 89 54 24 08 mov %edx,0x8(%esp) 106c9a: 89 44 24 04 mov %eax,0x4(%esp) 106c9e: e8 dd 58 00 00 call 10c580 <_POSIX_Priority_From_core> 106ca3: 89 47 18 mov %eax,0x18(%edi) scheduler, priority ); attr->schedpolicy = _POSIX_Thread_Translate_to_sched_policy( budget_algorithm ); 106ca6: 89 34 24 mov %esi,(%esp) 106ca9: e8 32 67 00 00 call 10d3e0 <_POSIX_Thread_Translate_to_sched_policy> attr->schedpolicy = 106cae: 89 47 14 mov %eax,0x14(%edi) return ok ? 0 : EINVAL; 106cb1: 31 c0 xor %eax,%eax 106cb3: 84 db test %bl,%bl 106cb5: 74 09 je 106cc0 <== NEVER TAKEN } 106cb7: 83 c4 3c add $0x3c,%esp 106cba: 5b pop %ebx 106cbb: 5e pop %esi 106cbc: 5f pop %edi 106cbd: 5d pop %ebp 106cbe: c3 ret 106cbf: 90 nop 106cc0: 83 c4 3c add $0x3c,%esp return ok ? 0 : EINVAL; 106cc3: b8 16 00 00 00 mov $0x16,%eax } 106cc8: 5b pop %ebx 106cc9: 5e pop %esi 106cca: 5f pop %edi 106ccb: 5d pop %ebp 106ccc: c3 ret 106ccd: 8d 76 00 lea 0x0(%esi),%esi attr = memset( attr, 0, sizeof( *attr ) ); 106cd0: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED 106cd3: e9 c2 fe ff ff jmp 106b9a <== NOT EXECUTED 106cd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 106cdf: 90 nop <== NOT EXECUTED 106ce0: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED 106ce5: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 106ce8: 83 e6 01 and $0x1,%esi <== NOT EXECUTED 106ceb: 0f 84 a9 fe ff ff je 106b9a <== NOT EXECUTED 106cf1: eb dd jmp 106cd0 <== NOT EXECUTED 106cf3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 106cfa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED 106d00: c7 01 00 00 00 00 movl $0x0,(%ecx) 106d06: 83 c1 04 add $0x4,%ecx 106d09: f7 c6 02 00 00 00 test $0x2,%esi 106d0f: 0f 84 7c fe ff ff je 106b91 <== ALWAYS TAKEN 106d15: eb c9 jmp 106ce0 <== NOT EXECUTED 106d17: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 106d1e: 66 90 xchg %ax,%ax <== NOT EXECUTED return ESRCH; 106d20: b8 03 00 00 00 mov $0x3,%eax 106d25: eb 90 jmp 106cb7 106d27: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 106d2e: 66 90 xchg %ax,%ax attr = memset( attr, 0, sizeof( *attr ) ); 106d30: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 106d33: 8d 4f 01 lea 0x1(%edi),%ecx <== NOT EXECUTED 106d36: be 53 00 00 00 mov $0x53,%esi <== NOT EXECUTED 106d3b: e9 19 fe ff ff jmp 106b59 <== NOT EXECUTED 106d40: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED 106d45: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED 106d48: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 106d4b: e9 12 fe ff ff jmp 106b62 <== NOT EXECUTED =============================================================================== 00107650 : */ void *pthread_getspecific( pthread_key_t key ) { 107650: 55 push %ebp static inline struct _Thread_Control *_Per_CPU_Get_executing( const Per_CPU_Control *cpu ) { return cpu->executing; 107651: a1 98 de 15 00 mov 0x15de98,%eax 107656: 89 e5 mov %esp,%ebp 107658: 56 push %esi 107659: 53 push %ebx 10765a: 8b 5d 08 mov 0x8(%ebp),%ebx _ISR_lock_ISR_disable_and_acquire( &the_thread->Keys.Lock, lock_context ); 10765d: 9c pushf 10765e: fa cli 10765f: 5e pop %esi RBTree_Node *parent; link = _RBTree_Root_const_reference( the_rbtree ); parent = NULL; while ( *link != NULL ) { 107660: 8b 80 10 01 00 00 mov 0x110(%eax),%eax 107666: 85 c0 test %eax,%eax 107668: 75 13 jne 10767d 10766a: eb 1e jmp 10768a 10766c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return &RB_RIGHT( the_node, Node ); 107670: 8d 48 04 lea 0x4(%eax),%ecx parent = *link; if ( ( *equal )( key, parent ) ) { return ( *map )( parent ); } else if ( ( *less )( key, parent ) ) { 107673: 73 02 jae 107677 <== ALWAYS TAKEN return &RB_LEFT( the_node, Node ); 107675: 89 c1 mov %eax,%ecx <== NOT EXECUTED while ( *link != NULL ) { 107677: 8b 01 mov (%ecx),%eax 107679: 85 c0 test %eax,%eax 10767b: 74 0d je 10768a <== NEVER TAKEN const POSIX_Keys_Key_value_pair *the_right; the_left = left; the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right ); return *the_left == the_right->key; 10767d: 8b 50 10 mov 0x10(%eax),%edx the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right ); 107680: 8d 48 f8 lea -0x8(%eax),%ecx if ( ( *equal )( key, parent ) ) { 107683: 39 d3 cmp %edx,%ebx 107685: 75 e9 jne 107670 _POSIX_Keys_Key_value_acquire( executing, &lock_context ); key_value_pair = _POSIX_Keys_Key_value_find( key, executing ); if ( key_value_pair != NULL ) { value = key_value_pair->value; 107687: 8b 41 20 mov 0x20(%ecx),%eax _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 10768a: 56 push %esi 10768b: 9d popf } _POSIX_Keys_Key_value_release( executing, &lock_context ); return value; } 10768c: 5b pop %ebx 10768d: 5e pop %esi 10768e: 5d pop %ebp 10768f: c3 ret =============================================================================== 00107580 : * 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167 */ int pthread_key_delete( pthread_key_t key ) { 107580: 55 push %ebp 107581: 89 e5 mov %esp,%ebp 107583: 57 push %edi 107584: 56 push %esi 107585: 53 push %ebx 107586: 83 ec 2c sub $0x2c,%esp _RTEMS_Lock_allocator(); 107589: e8 82 0c 00 00 call 108210 <_RTEMS_Lock_allocator> _Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information ); 10758e: b8 40 a1 15 00 mov $0x15a140,%eax 107593: 89 44 24 04 mov %eax,0x4(%esp) 107597: 8b 45 08 mov 0x8(%ebp),%eax 10759a: 89 04 24 mov %eax,(%esp) 10759d: e8 8e 33 00 00 call 10a930 <_Objects_Get_no_protection> int eno; _Objects_Allocator_lock(); the_key = _POSIX_Keys_Get( key ); if ( the_key != NULL ) { 1075a2: 85 c0 test %eax,%eax 1075a4: 0f 84 86 00 00 00 je 107630 _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 1075aa: 89 44 24 04 mov %eax,0x4(%esp) 1075ae: 89 c7 mov %eax,%edi 1075b0: c7 04 24 40 a1 15 00 movl $0x15a140,(%esp) 1075b7: e8 a4 31 00 00 call 10a760 <_Objects_Close> return _Chain_Immutable_head( the_chain )->next; 1075bc: 8b 5f 14 mov 0x14(%edi),%ebx return &the_chain->Tail.Node; 1075bf: 8d 47 18 lea 0x18(%edi),%eax 1075c2: 89 45 e4 mov %eax,-0x1c(%ebp) while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) { 1075c5: 39 d8 cmp %ebx,%eax 1075c7: 74 45 je 10760e 1075c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi the_thread = key_value_pair->thread; 1075d0: 8b 43 1c mov 0x1c(%ebx),%eax _ISR_lock_ISR_disable_and_acquire( &the_thread->Keys.Lock, lock_context ); 1075d3: 9c pushf 1075d4: fa cli 1075d5: 5e pop %esi _RBTree_Extract( 1075d6: 8d 4b 08 lea 0x8(%ebx),%ecx 1075d9: 05 10 01 00 00 add $0x110,%eax 1075de: 89 4c 24 04 mov %ecx,0x4(%esp) 1075e2: 89 04 24 mov %eax,(%esp) 1075e5: e8 56 35 00 00 call 10ab40 <_RBTree_Extract> _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 1075ea: 56 push %esi 1075eb: 9d popf next = the_node->next; 1075ec: 8b 0b mov (%ebx),%ecx previous = the_node->previous; 1075ee: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 1075f1: 89 41 04 mov %eax,0x4(%ecx) previous->next = next; 1075f4: 89 08 mov %ecx,(%eax) _Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair ); 1075f6: 89 5c 24 04 mov %ebx,0x4(%esp) 1075fa: c7 04 24 04 de 15 00 movl $0x15de04,(%esp) 107601: e8 1a 0f 00 00 call 108520 <_Freechain_Put> return _Chain_Immutable_head( the_chain )->next; 107606: 8b 5f 14 mov 0x14(%edi),%ebx while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) { 107609: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10760c: 75 c2 jne 1075d0 <== NEVER TAKEN Objects_Control *the_object ) { _Assert( _Objects_Allocator_is_owner() ); _Assert( information->deallocate != NULL ); ( *information->deallocate )( information, the_object ); 10760e: 89 7c 24 04 mov %edi,0x4(%esp) _POSIX_Keys_Destroy( the_key ); eno = 0; 107612: 31 db xor %ebx,%ebx 107614: c7 04 24 40 a1 15 00 movl $0x15a140,(%esp) 10761b: ff 15 4c a1 15 00 call *0x15a14c _RTEMS_Unlock_allocator(); 107621: e8 0a 0c 00 00 call 108230 <_RTEMS_Unlock_allocator> } _Objects_Allocator_unlock(); return eno; } 107626: 83 c4 2c add $0x2c,%esp 107629: 89 d8 mov %ebx,%eax 10762b: 5b pop %ebx 10762c: 5e pop %esi 10762d: 5f pop %edi 10762e: 5d pop %ebp 10762f: c3 ret 107630: e8 fb 0b 00 00 call 108230 <_RTEMS_Unlock_allocator> eno = EINVAL; 107635: bb 16 00 00 00 mov $0x16,%ebx } 10763a: 83 c4 2c add $0x2c,%esp 10763d: 89 d8 mov %ebx,%eax 10763f: 5b pop %ebx 107640: 5e pop %esi 107641: 5f pop %edi 107642: 5d pop %ebp 107643: c3 ret 107644: 90 nop 107645: 90 nop 107646: 90 nop 107647: 90 nop 107648: 90 nop 107649: 90 nop 10764a: 90 nop 10764b: 90 nop 10764c: 90 nop 10764d: 90 nop 10764e: 90 nop 10764f: 90 nop =============================================================================== 00107750 : #else pthread_mutex_t *mutex, #endif int *prioceiling ) { 107750: 55 push %ebp 107751: 89 e5 mov %esp,%ebp 107753: 83 ec 38 sub $0x38,%esp 107756: 89 75 f8 mov %esi,-0x8(%ebp) 107759: 8b 75 0c mov 0xc(%ebp),%esi 10775c: 89 5d f4 mov %ebx,-0xc(%ebp) 10775f: 8b 5d 08 mov 0x8(%ebp),%ebx 107762: 89 7d fc mov %edi,-0x4(%ebp) if ( prioceiling == NULL ) { return EINVAL; } the_mutex = _POSIX_Mutex_Get( RTEMS_DECONST( pthread_mutex_t *, mutex ) ); POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 107765: 85 f6 test %esi,%esi 107767: 74 49 je 1077b2 107769: 85 db test %ebx,%ebx 10776b: 74 45 je 1077b2 10776d: 8b 13 mov (%ebx),%edx 10776f: 89 d8 mov %ebx,%eax 107771: 31 d0 xor %edx,%eax 107773: 35 b8 13 1c 96 xor $0x961c13b8,%eax 107778: 83 e0 f8 and $0xfffffff8,%eax 10777b: 75 23 jne 1077a0 10777d: 9c pushf 10777e: fa cli 10777f: 5f pop %edi RTEMS_INLINE_ROUTINE POSIX_Mutex_Protocol _POSIX_Mutex_Get_protocol( unsigned long flags ) { return flags & POSIX_MUTEX_PROTOCOL_MASK; 107780: 83 e2 03 and $0x3,%edx _POSIX_Mutex_Acquire( the_mutex, &queue_context ); if ( _POSIX_Mutex_Get_protocol( flags ) == POSIX_MUTEX_PRIORITY_CEILING ) { 107783: 83 fa 02 cmp $0x2,%edx 107786: 74 48 je 1077d0 *prioceiling = _POSIX_Priority_From_core( _POSIX_Mutex_Get_scheduler( the_mutex ), _POSIX_Mutex_Get_priority( the_mutex ) ); } else { *prioceiling = 0; 107788: c7 06 00 00 00 00 movl $0x0,(%esi) 10778e: 57 push %edi 10778f: 9d popf } _POSIX_Mutex_Release( the_mutex, &queue_context ); return 0; } 107790: 8b 5d f4 mov -0xc(%ebp),%ebx return 0; 107793: 31 c0 xor %eax,%eax } 107795: 8b 75 f8 mov -0x8(%ebp),%esi 107798: 8b 7d fc mov -0x4(%ebp),%edi 10779b: 89 ec mov %ebp,%esp 10779d: 5d pop %ebp 10779e: c3 ret 10779f: 90 nop POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 1077a0: 89 1c 24 mov %ebx,(%esp) 1077a3: 89 55 e4 mov %edx,-0x1c(%ebp) 1077a6: e8 95 05 00 00 call 107d40 <_POSIX_Mutex_Auto_initialization> 1077ab: 8b 55 e4 mov -0x1c(%ebp),%edx 1077ae: 84 c0 test %al,%al 1077b0: 75 cb jne 10777d <== ALWAYS TAKEN } 1077b2: 8b 5d f4 mov -0xc(%ebp),%ebx POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 1077b5: b8 16 00 00 00 mov $0x16,%eax } 1077ba: 8b 75 f8 mov -0x8(%ebp),%esi 1077bd: 8b 7d fc mov -0x4(%ebp),%edi 1077c0: 89 ec mov %ebp,%esp 1077c2: 5d pop %ebp 1077c3: c3 ret 1077c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1077cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1077cf: 90 nop *prioceiling = _POSIX_Priority_From_core( 1077d0: 8b 43 2c mov 0x2c(%ebx),%eax 1077d3: 8b 53 30 mov 0x30(%ebx),%edx 1077d6: c7 04 24 40 9a 12 00 movl $0x129a40,(%esp) 1077dd: 89 44 24 04 mov %eax,0x4(%esp) 1077e1: 89 54 24 08 mov %edx,0x8(%esp) 1077e5: e8 16 08 00 00 call 108000 <_POSIX_Priority_From_core> 1077ea: 89 06 mov %eax,(%esi) 1077ec: eb a0 jmp 10778e 1077ee: 90 nop 1077ef: 90 nop =============================================================================== 001077f0 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 1077f0: 55 push %ebp 1077f1: 89 e5 mov %esp,%ebp 1077f3: 83 ec 38 sub $0x38,%esp 1077f6: 89 5d f4 mov %ebx,-0xc(%ebp) 1077f9: 8b 55 0c mov 0xc(%ebp),%edx 1077fc: 89 75 f8 mov %esi,-0x8(%ebp) 1077ff: 8b 5d 08 mov 0x8(%ebp),%ebx 107802: 89 7d fc mov %edi,-0x4(%ebp) POSIX_Mutex_Protocol protocol; unsigned long flags; Priority_Control priority; const Scheduler_Control *scheduler; if ( attr ) the_attr = attr; 107805: 85 d2 test %edx,%edx 107807: 74 37 je 107840 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 107809: 85 db test %ebx,%ebx 10780b: 0f 84 da 00 00 00 je 1078eb * value in an uninitialized variable to make this fail. * * Thus, we do not look at *mutex. */ if ( !the_attr->is_initialized ) 107811: 8b 0a mov (%edx),%ecx return EINVAL; 107813: b8 16 00 00 00 mov $0x16,%eax if ( !the_attr->is_initialized ) 107818: 85 c9 test %ecx,%ecx 10781a: 74 0e je 10782a return EINVAL; if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) { 10781c: 83 7a 04 01 cmpl $0x1,0x4(%edx) 107820: 77 08 ja 10782a 107822: 8b 4a 0c mov 0xc(%edx),%ecx } /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 107825: 83 f9 02 cmp $0x2,%ecx 107828: 76 66 jbe 107890 ); the_mutex->Recursive.nest_level = 0; _Priority_Node_initialize( &the_mutex->Priority_ceiling, priority ); the_mutex->scheduler = scheduler; return 0; } 10782a: 8b 5d f4 mov -0xc(%ebp),%ebx 10782d: 8b 75 f8 mov -0x8(%ebp),%esi 107830: 8b 7d fc mov -0x4(%ebp),%edi 107833: 89 ec mov %ebp,%esp 107835: 5d pop %ebp 107836: c3 ret 107837: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10783e: 66 90 xchg %ax,%ax if ( !mutex ) 107840: 85 db test %ebx,%ebx 107842: 0f 84 a3 00 00 00 je 1078eb flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC; 107848: 89 d8 mov %ebx,%eax priority = 0; 10784a: 31 f6 xor %esi,%esi flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC; 10784c: 35 b8 13 1c 96 xor $0x961c13b8,%eax priority = 0; 107851: 31 ff xor %edi,%edi flags &= ~POSIX_MUTEX_FLAGS_MASK; 107853: 83 e0 f8 and $0xfffffff8,%eax 107856: 89 03 mov %eax,(%ebx) RTEMS_INLINE_ROUTINE void _Priority_Node_initialize( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 107858: 89 73 2c mov %esi,0x2c(%ebx) } 10785b: 8b 75 f8 mov -0x8(%ebp),%esi return 0; 10785e: 31 c0 xor %eax,%eax 107860: 89 7b 30 mov %edi,0x30(%ebx) } 107863: 8b 7d fc mov -0x4(%ebp),%edi queue->heads = NULL; 107866: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) queue->owner = NULL; 10786d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) queue->name = name; 107874: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) the_mutex->Recursive.nest_level = 0; 10787b: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_mutex->scheduler = scheduler; 107882: 89 53 34 mov %edx,0x34(%ebx) } 107885: 8b 5d f4 mov -0xc(%ebp),%ebx 107888: 89 ec mov %ebp,%esp 10788a: 5d pop %ebp 10788b: c3 ret 10788c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi switch ( the_attr->type ) { 107890: 8b 72 10 mov 0x10(%edx),%esi 107893: 83 fe 03 cmp $0x3,%esi 107896: 77 92 ja 10782a flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC; 107898: 89 d8 mov %ebx,%eax 10789a: 35 b8 13 1c 96 xor $0x961c13b8,%eax flags &= ~POSIX_MUTEX_FLAGS_MASK; 10789f: 83 e0 f8 and $0xfffffff8,%eax flags |= protocol; 1078a2: 09 c8 or %ecx,%eax if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) { 1078a4: 4e dec %esi 1078a5: 75 03 jne 1078aa <== ALWAYS TAKEN flags |= POSIX_MUTEX_RECURSIVE; 1078a7: 83 c8 04 or $0x4,%eax <== NOT EXECUTED the_mutex->flags = flags; 1078aa: 89 03 mov %eax,(%ebx) if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) { 1078ac: 83 f9 02 cmp $0x2,%ecx 1078af: 75 4c jne 1078fd prio_ceiling = the_attr->prio_ceiling; 1078b1: 8b 42 08 mov 0x8(%edx),%eax if ( prio_ceiling == INT_MAX ) { 1078b4: 3d ff ff ff 7f cmp $0x7fffffff,%eax 1078b9: 75 06 jne 1078c1 RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum( const Scheduler_Control *scheduler ) { _Assert( (int) scheduler->maximum_priority > 1 ); return (int) scheduler->maximum_priority - 1; 1078bb: a1 7c 9a 12 00 mov 0x129a7c,%eax 1078c0: 48 dec %eax priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid ); 1078c1: 89 44 24 04 mov %eax,0x4(%esp) 1078c5: 8d 55 e7 lea -0x19(%ebp),%edx 1078c8: 89 54 24 08 mov %edx,0x8(%esp) 1078cc: c7 04 24 40 9a 12 00 movl $0x129a40,(%esp) 1078d3: e8 c8 06 00 00 call 107fa0 <_POSIX_Priority_To_core> if ( !valid ) { 1078d8: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid ); 1078dc: 89 d7 mov %edx,%edi 1078de: 89 c6 mov %eax,%esi scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() ); 1078e0: ba 40 9a 12 00 mov $0x129a40,%edx if ( !valid ) { 1078e5: 0f 85 6d ff ff ff jne 107858 } 1078eb: 8b 5d f4 mov -0xc(%ebp),%ebx return EINVAL; 1078ee: b8 16 00 00 00 mov $0x16,%eax } 1078f3: 8b 75 f8 mov -0x8(%ebp),%esi 1078f6: 8b 7d fc mov -0x4(%ebp),%edi 1078f9: 89 ec mov %ebp,%esp 1078fb: 5d pop %ebp 1078fc: c3 ret scheduler = NULL; 1078fd: 31 d2 xor %edx,%edx priority = 0; 1078ff: 31 f6 xor %esi,%esi 107901: 31 ff xor %edi,%edi 107903: e9 50 ff ff ff jmp 107858 107908: 90 nop 107909: 90 nop 10790a: 90 nop 10790b: 90 nop 10790c: 90 nop 10790d: 90 nop 10790e: 90 nop 10790f: 90 nop =============================================================================== 00107ba0 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 107ba0: 55 push %ebp 107ba1: 89 e5 mov %esp,%ebp 107ba3: 83 ec 58 sub $0x58,%esp 107ba6: 89 7d fc mov %edi,-0x4(%ebp) 107ba9: 8b 7d 10 mov 0x10(%ebp),%edi 107bac: 89 75 f8 mov %esi,-0x8(%ebp) 107baf: 8b 75 08 mov 0x8(%ebp),%esi 107bb2: 89 5d f4 mov %ebx,-0xc(%ebp) POSIX_Mutex_Control *the_mutex; int error; int unlock_error; if ( old_ceiling == NULL ) { 107bb5: 85 ff test %edi,%edi 107bb7: 74 37 je 107bf0 /* * Must acquire the mutex before we can change it's ceiling. * POSIX says block until we acquire it. */ error = pthread_mutex_lock( mutex ); 107bb9: 89 34 24 mov %esi,(%esp) 107bbc: e8 4f fd ff ff call 107910 if ( error != 0 ) { 107bc1: 85 c0 test %eax,%eax error = pthread_mutex_lock( mutex ); 107bc3: 89 c3 mov %eax,%ebx if ( error != 0 ) { 107bc5: 75 29 jne 107bf0 return flags & POSIX_MUTEX_PROTOCOL_MASK; 107bc7: 8b 06 mov (%esi),%eax 107bc9: 83 e0 03 and $0x3,%eax return EINVAL; } the_mutex = _POSIX_Mutex_Get( mutex ); if ( 107bcc: 83 f8 02 cmp $0x2,%eax 107bcf: 74 3f je 107c10 error = 0; } else { error = EINVAL; } } else { *old_ceiling = 0; 107bd1: c7 07 00 00 00 00 movl $0x0,(%edi) error = 0; } unlock_error = pthread_mutex_unlock( mutex ); 107bd7: 89 34 24 mov %esi,(%esp) 107bda: e8 d1 01 00 00 call 107db0 _Assert( unlock_error == 0 ); (void) unlock_error; return error; } 107bdf: 8b 75 f8 mov -0x8(%ebp),%esi 107be2: 89 d8 mov %ebx,%eax 107be4: 8b 7d fc mov -0x4(%ebp),%edi 107be7: 8b 5d f4 mov -0xc(%ebp),%ebx 107bea: 89 ec mov %ebp,%esp 107bec: 5d pop %ebp 107bed: c3 ret 107bee: 66 90 xchg %ax,%ax return EINVAL; 107bf0: bb 16 00 00 00 mov $0x16,%ebx } 107bf5: 8b 75 f8 mov -0x8(%ebp),%esi 107bf8: 8b 7d fc mov -0x4(%ebp),%edi 107bfb: 89 d8 mov %ebx,%eax 107bfd: 8b 5d f4 mov -0xc(%ebp),%ebx 107c00: 89 ec mov %ebp,%esp 107c02: 5d pop %ebp 107c03: c3 ret 107c04: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107c0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 107c0f: 90 nop *old_ceiling = _POSIX_Priority_From_core( scheduler, old_priority ); 107c10: 8b 56 30 mov 0x30(%esi),%edx 107c13: 8b 46 2c mov 0x2c(%esi),%eax 107c16: c7 04 24 40 9a 12 00 movl $0x129a40,(%esp) 107c1d: 89 54 24 08 mov %edx,0x8(%esp) 107c21: 89 44 24 04 mov %eax,0x4(%esp) 107c25: e8 d6 03 00 00 call 108000 <_POSIX_Priority_From_core> 107c2a: 89 07 mov %eax,(%edi) new_priority = _POSIX_Priority_To_core( scheduler, prioceiling, &valid ); 107c2c: 8d 45 c3 lea -0x3d(%ebp),%eax 107c2f: 89 44 24 08 mov %eax,0x8(%esp) 107c33: 8b 45 0c mov 0xc(%ebp),%eax 107c36: c7 04 24 40 9a 12 00 movl $0x129a40,(%esp) 107c3d: 89 44 24 04 mov %eax,0x4(%esp) 107c41: e8 5a 03 00 00 call 107fa0 <_POSIX_Priority_To_core> if ( valid ) { 107c46: 80 7d c3 00 cmpb $0x0,-0x3d(%ebp) 107c4a: 75 14 jne 107c60 error = EINVAL; 107c4c: bb 16 00 00 00 mov $0x16,%ebx 107c51: eb 84 jmp 107bd7 107c53: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107c5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi queue_context->Priority.update_count = 0; 107c60: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) return the_mutex->Recursive.Mutex.Queue.Queue.owner; 107c67: 8b 4e 10 mov 0x10(%esi),%ecx if ( owner != NULL ) { 107c6a: 85 c9 test %ecx,%ecx 107c6c: 74 52 je 107cc0 <== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire( Thread_Control *the_thread, Thread_queue_Context *queue_context ) { _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 107c6e: 9c pushf <== NOT EXECUTED 107c6f: fa cli <== NOT EXECUTED 107c70: 5f pop %edi <== NOT EXECUTED 107c71: 89 7d c4 mov %edi,-0x3c(%ebp) <== NOT EXECUTED node->priority = priority; 107c74: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED _Thread_Priority_changed( 107c77: 8d 7d c4 lea -0x3c(%ebp),%edi <== NOT EXECUTED 107c7a: 31 c0 xor %eax,%eax <== NOT EXECUTED 107c7c: 89 56 30 mov %edx,0x30(%esi) <== NOT EXECUTED 107c7f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED _Thread_Priority_change( 107c83: 8d 46 1c lea 0x1c(%esi),%eax <== NOT EXECUTED 107c86: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED 107c8a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 107c8e: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED 107c91: e8 ba 36 00 00 call 10b350 <_Thread_Priority_changed> <== NOT EXECUTED Thread_Control *the_thread, Thread_queue_Context *queue_context ) { _Thread_Wait_release_critical( the_thread, queue_context ); _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 107c96: ff 75 c4 push -0x3c(%ebp) 107c99: 9d popf _Thread_Priority_update( &queue_context ); 107c9a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 107c9d: a1 70 3c 13 00 mov 0x133c70,%eax <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 107ca2: 40 inc %eax <== NOT EXECUTED 107ca3: a3 70 3c 13 00 mov %eax,0x133c70 <== NOT EXECUTED 107ca8: e8 23 37 00 00 call 10b3d0 <_Thread_Priority_update> <== NOT EXECUTED _Thread_Dispatch_enable( cpu_self ); 107cad: c7 04 24 60 3c 13 00 movl $0x133c60,(%esp) 107cb4: e8 97 39 00 00 call 10b650 <_Thread_Dispatch_enable> error = 0; 107cb9: e9 19 ff ff ff jmp 107bd7 107cbe: 66 90 xchg %ax,%ax the_mutex->Priority_ceiling.priority = priority_ceiling; 107cc0: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED 107cc3: 8d 7d c4 lea -0x3c(%ebp),%edi <== NOT EXECUTED 107cc6: 89 56 30 mov %edx,0x30(%esi) <== NOT EXECUTED 107cc9: eb cf jmp 107c9a <== NOT EXECUTED 107ccb: 90 nop 107ccc: 90 nop 107ccd: 90 nop 107cce: 90 nop 107ccf: 90 nop =============================================================================== 00107db0 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 107db0: 55 push %ebp 107db1: 89 e5 mov %esp,%ebp 107db3: 83 ec 78 sub $0x78,%esp 107db6: 89 5d f4 mov %ebx,-0xc(%ebp) 107db9: 8b 5d 08 mov 0x8(%ebp),%ebx 107dbc: 89 75 f8 mov %esi,-0x8(%ebp) 107dbf: 89 7d fc mov %edi,-0x4(%ebp) Thread_queue_Context queue_context; Thread_Control *executing; Status_Control status; the_mutex = _POSIX_Mutex_Get( mutex ); POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 107dc2: 85 db test %ebx,%ebx 107dc4: 0f 84 36 01 00 00 je 107f00 107dca: 8b 33 mov (%ebx),%esi 107dcc: 89 d8 mov %ebx,%eax 107dce: 31 f0 xor %esi,%eax 107dd0: 35 b8 13 1c 96 xor $0x961c13b8,%eax 107dd5: 83 e0 f8 and $0xfffffff8,%eax 107dd8: 0f 85 12 01 00 00 jne 107ef0 _Thread_queue_Context_ISR_disable( queue_context, level ); 107dde: 9c pushf 107ddf: fa cli 107de0: 58 pop %eax 107de1: 89 45 c4 mov %eax,-0x3c(%ebp) executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context ); switch ( _POSIX_Mutex_Get_protocol( flags ) ) { 107de4: 83 e6 03 and $0x3,%esi 107de7: a1 78 3c 13 00 mov 0x133c78,%eax 107dec: 0f 84 de 00 00 00 je 107ed0 107df2: 83 fe 02 cmp $0x2,%esi 107df5: 74 39 je 107e30 if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) { 107df7: 3b 43 10 cmp 0x10(%ebx),%eax 107dfa: 0f 85 d5 00 00 00 jne 107ed5 nest_level = the_mutex->Recursive.nest_level; 107e00: 8b 53 18 mov 0x18(%ebx),%edx if ( nest_level > 0 ) { 107e03: 85 d2 test %edx,%edx 107e05: 0f 85 65 01 00 00 jne 107f70 <== NEVER TAKEN the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 107e0b: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) heads = the_mutex->Recursive.Mutex.Queue.Queue.heads; 107e12: 8b 53 0c mov 0xc(%ebx),%edx if ( heads == NULL ) { 107e15: 85 d2 test %edx,%edx 107e17: 0f 84 57 01 00 00 je 107f74 _Thread_queue_Surrender( 107e1d: b9 28 a3 12 00 mov $0x12a328,%ecx 107e22: 89 4c 24 10 mov %ecx,0x10(%esp) 107e26: e9 13 01 00 00 jmp 107f3e 107e2b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 107e2f: 90 nop unsigned int nest_level; ISR_lock_Context lock_context; Per_CPU_Control *cpu_self; Thread_queue_Heads *heads; if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) { 107e30: 3b 43 10 cmp 0x10(%ebx),%eax 107e33: 0f 85 9c 00 00 00 jne 107ed5 <== NEVER TAKEN _POSIX_Mutex_Release( the_mutex, queue_context ); return STATUS_NOT_OWNER; } nest_level = the_mutex->Recursive.nest_level; 107e39: 8b 53 18 mov 0x18(%ebx),%edx if ( nest_level > 0 ) { 107e3c: 85 d2 test %edx,%edx 107e3e: 0f 85 2c 01 00 00 jne 107f70 <== NEVER TAKEN _Thread_Resource_count_decrement( executing ); _Thread_queue_Context_clear_priority_updates( queue_context ); _Thread_Wait_acquire_default_critical( executing, &lock_context ); _Thread_Priority_remove( 107e44: 89 04 24 mov %eax,(%esp) 107e47: 8d 7b 1c lea 0x1c(%ebx),%edi 107e4a: 89 7c 24 04 mov %edi,0x4(%esp) 107e4e: 8d 75 c4 lea -0x3c(%ebp),%esi 107e51: 89 74 24 08 mov %esi,0x8(%esp) 107e55: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) 107e5c: e8 6f 34 00 00 call 10b2d0 <_Thread_Priority_remove> disable_level = cpu_self->thread_dispatch_disable_level; 107e61: a1 70 3c 13 00 mov 0x133c70,%eax cpu_self->thread_dispatch_disable_level = disable_level + 1; 107e66: 40 inc %eax 107e67: a3 70 3c 13 00 mov %eax,0x133c70 ); _Thread_Wait_release_default_critical( executing, &lock_context ); cpu_self = _Thread_queue_Dispatch_disable( queue_context ); heads = the_mutex->Recursive.Mutex.Queue.Queue.heads; 107e6c: 8b 43 0c mov 0xc(%ebx),%eax if ( heads != NULL ) { 107e6f: 85 c0 test %eax,%eax 107e71: 0f 84 19 01 00 00 je 107f90 const Thread_queue_Operations *operations; Thread_Control *new_owner; operations = POSIX_MUTEX_PRIORITY_CEILING_TQ_OPERATIONS; new_owner = ( *operations->first )( heads ); 107e77: 89 04 24 mov %eax,(%esp) _Thread_Priority_add( new_owner, &the_mutex->Priority_ceiling, queue_context ); _Thread_queue_Extract_critical( 107e7a: 83 c3 0c add $0xc,%ebx new_owner = ( *operations->first )( heads ); 107e7d: ff 15 4c a3 12 00 call *0x12a34c the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 107e83: 89 43 04 mov %eax,0x4(%ebx) _Thread_Priority_add( 107e86: 89 7c 24 04 mov %edi,0x4(%esp) _Thread_queue_Extract_critical( 107e8a: bf 3c a3 12 00 mov $0x12a33c,%edi _Thread_Priority_add( 107e8f: 89 04 24 mov %eax,(%esp) 107e92: 89 74 24 08 mov %esi,0x8(%esp) 107e96: 89 45 b4 mov %eax,-0x4c(%ebp) 107e99: e8 b2 33 00 00 call 10b250 <_Thread_Priority_add> _Thread_queue_Extract_critical( 107e9e: 8b 45 b4 mov -0x4c(%ebp),%eax 107ea1: 89 74 24 0c mov %esi,0xc(%esp) 107ea5: 89 7c 24 04 mov %edi,0x4(%esp) 107ea9: 89 1c 24 mov %ebx,(%esp) 107eac: 89 44 24 08 mov %eax,0x8(%esp) 107eb0: e8 4b 3e 00 00 call 10bd00 <_Thread_queue_Extract_critical> } else { _POSIX_Mutex_Set_owner( the_mutex, NULL ); _POSIX_Mutex_Release( the_mutex, queue_context ); } _Thread_Priority_update( queue_context ); 107eb5: 89 34 24 mov %esi,(%esp) 107eb8: e8 13 35 00 00 call 10b3d0 <_Thread_Priority_update> _Thread_Dispatch_enable( cpu_self ); 107ebd: c7 04 24 60 3c 13 00 movl $0x133c60,(%esp) 107ec4: e8 87 37 00 00 call 10b650 <_Thread_Dispatch_enable> return STATUS_SUCCESSFUL; 107ec9: 31 c0 xor %eax,%eax 107ecb: eb 11 jmp 107ede 107ecd: 8d 76 00 lea 0x0(%esi),%esi if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) { 107ed0: 3b 43 10 cmp 0x10(%ebx),%eax 107ed3: 74 4b je 107f20 _ISR_lock_ISR_enable( lock_context ); 107ed5: ff 75 c4 push -0x3c(%ebp) 107ed8: 9d popf return STATUS_NOT_OWNER; 107ed9: b8 01 00 00 00 mov $0x1,%eax ); break; } return _POSIX_Get_error( status ); } 107ede: 8b 5d f4 mov -0xc(%ebp),%ebx 107ee1: 8b 75 f8 mov -0x8(%ebp),%esi 107ee4: 8b 7d fc mov -0x4(%ebp),%edi 107ee7: 89 ec mov %ebp,%esp 107ee9: 5d pop %ebp 107eea: c3 ret 107eeb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 107eef: 90 nop POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 107ef0: 89 1c 24 mov %ebx,(%esp) 107ef3: e8 48 fe ff ff call 107d40 <_POSIX_Mutex_Auto_initialization> 107ef8: 84 c0 test %al,%al 107efa: 0f 85 de fe ff ff jne 107dde } 107f00: 8b 5d f4 mov -0xc(%ebp),%ebx POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 107f03: b8 16 00 00 00 mov $0x16,%eax } 107f08: 8b 75 f8 mov -0x8(%ebp),%esi 107f0b: 8b 7d fc mov -0x4(%ebp),%edi 107f0e: 89 ec mov %ebp,%esp 107f10: 5d pop %ebp 107f11: c3 ret 107f12: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107f19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi nest_level = the_mutex->Recursive.nest_level; 107f20: 8b 53 18 mov 0x18(%ebx),%edx if ( nest_level > 0 ) { 107f23: 85 d2 test %edx,%edx 107f25: 75 49 jne 107f70 <== NEVER TAKEN the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 107f27: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) heads = the_mutex->Recursive.Mutex.Queue.Queue.heads; 107f2e: 8b 53 0c mov 0xc(%ebx),%edx if ( heads == NULL ) { 107f31: 85 d2 test %edx,%edx 107f33: 74 3f je 107f74 _Thread_queue_Surrender( 107f35: be 50 a3 12 00 mov $0x12a350,%esi 107f3a: 89 74 24 10 mov %esi,0x10(%esp) 107f3e: 89 44 24 08 mov %eax,0x8(%esp) 107f42: 8d 4d c4 lea -0x3c(%ebp),%ecx 107f45: 83 c3 0c add $0xc,%ebx 107f48: 89 1c 24 mov %ebx,(%esp) 107f4b: 89 4c 24 0c mov %ecx,0xc(%esp) 107f4f: 89 54 24 04 mov %edx,0x4(%esp) 107f53: e8 c8 3e 00 00 call 10be20 <_Thread_queue_Surrender> 107f58: 8b 5d f4 mov -0xc(%ebp),%ebx return STATUS_SUCCESSFUL; 107f5b: 31 c0 xor %eax,%eax 107f5d: 8b 75 f8 mov -0x8(%ebp),%esi 107f60: 8b 7d fc mov -0x4(%ebp),%edi 107f63: 89 ec mov %ebp,%esp 107f65: 5d pop %ebp 107f66: c3 ret 107f67: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107f6e: 66 90 xchg %ax,%ax the_mutex->Recursive.nest_level = nest_level - 1; 107f70: 4a dec %edx <== NOT EXECUTED 107f71: 89 53 18 mov %edx,0x18(%ebx) <== NOT EXECUTED 107f74: ff 75 c4 push -0x3c(%ebp) 107f77: 9d popf 107f78: 8b 5d f4 mov -0xc(%ebp),%ebx return STATUS_SUCCESSFUL; 107f7b: 31 c0 xor %eax,%eax 107f7d: 8b 75 f8 mov -0x8(%ebp),%esi 107f80: 8b 7d fc mov -0x4(%ebp),%edi 107f83: 89 ec mov %ebp,%esp 107f85: 5d pop %ebp 107f86: c3 ret 107f87: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107f8e: 66 90 xchg %ax,%ax the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 107f90: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 107f97: ff 75 c4 push -0x3c(%ebp) 107f9a: 9d popf } 107f9b: e9 15 ff ff ff jmp 107eb5 =============================================================================== 001076b0 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 1076b0: 55 push %ebp if ( !attr || !attr->is_initialized ) return EINVAL; 1076b1: ba 16 00 00 00 mov $0x16,%edx { 1076b6: 89 e5 mov %esp,%ebp 1076b8: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 1076bb: 85 c0 test %eax,%eax 1076bd: 74 14 je 1076d3 1076bf: 8b 08 mov (%eax),%ecx 1076c1: 85 c9 test %ecx,%ecx 1076c3: 74 0e je 1076d3 switch ( pshared ) { 1076c5: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 1076c9: 77 08 ja 1076d3 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 1076cb: 8b 4d 0c mov 0xc(%ebp),%ecx return 0; 1076ce: 31 d2 xor %edx,%edx attr->process_shared = pshared; 1076d0: 89 48 04 mov %ecx,0x4(%eax) default: return EINVAL; } } 1076d3: 5d pop %ebp 1076d4: 89 d0 mov %edx,%eax 1076d6: c3 ret 1076d7: 90 nop 1076d8: 90 nop 1076d9: 90 nop 1076da: 90 nop 1076db: 90 nop 1076dc: 90 nop 1076dd: 90 nop 1076de: 90 nop 1076df: 90 nop =============================================================================== 00103cf0 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 103cf0: 55 push %ebp 103cf1: 89 e5 mov %esp,%ebp 103cf3: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || !attr->is_initialized ) 103cf6: 85 c0 test %eax,%eax 103cf8: 74 16 je 103d10 103cfa: 8b 10 mov (%eax),%edx 103cfc: 85 d2 test %edx,%edx 103cfe: 74 10 je 103d10 <== NEVER TAKEN return EINVAL; switch ( type ) { 103d00: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) 103d04: 77 0a ja 103d10 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 103d06: 8b 55 0c mov 0xc(%ebp),%edx 103d09: 89 50 10 mov %edx,0x10(%eax) return 0; 103d0c: 31 c0 xor %eax,%eax default: return EINVAL; } } 103d0e: 5d pop %ebp 103d0f: c3 ret 103d10: 5d pop %ebp return EINVAL; 103d11: b8 16 00 00 00 mov $0x16,%eax } 103d16: c3 ret 103d17: 90 nop 103d18: 90 nop 103d19: 90 nop 103d1a: 90 nop 103d1b: 90 nop 103d1c: 90 nop 103d1d: 90 nop 103d1e: 90 nop 103d1f: 90 nop =============================================================================== 001061c0 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 1061c0: 55 push %ebp 1061c1: 89 e5 mov %esp,%ebp 1061c3: 83 ec 18 sub $0x18,%esp 1061c6: 8b 45 08 mov 0x8(%ebp),%eax 1061c9: 8b 55 0c mov 0xc(%ebp),%edx POSIX_RWLock_Control *the_rwlock; the_rwlock = _POSIX_RWLock_Get( rwlock ); if ( the_rwlock == NULL ) { 1061cc: 85 c0 test %eax,%eax 1061ce: 74 30 je 106200 return EINVAL; } if ( attr != NULL ) { 1061d0: 85 d2 test %edx,%edx 1061d2: 74 0c je 1061e0 if ( !attr->is_initialized ) { 1061d4: 8b 0a mov (%edx),%ecx 1061d6: 85 c9 test %ecx,%ecx 1061d8: 74 26 je 106200 <== NEVER TAKEN return EINVAL; } if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) { 1061da: 83 7a 04 01 cmpl $0x1,0x4(%edx) 1061de: 77 20 ja 106200 return EINVAL; } } the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC; 1061e0: 89 c2 mov %eax,%edx _CORE_RWLock_Initialize( &the_rwlock->RWLock ); 1061e2: 83 c0 04 add $0x4,%eax the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC; 1061e5: 81 f2 bd da 21 96 xor $0x9621dabd,%edx 1061eb: 89 50 fc mov %edx,-0x4(%eax) _CORE_RWLock_Initialize( &the_rwlock->RWLock ); 1061ee: 89 04 24 mov %eax,(%esp) 1061f1: e8 8a 16 00 00 call 107880 <_CORE_RWLock_Initialize> return 0; } 1061f6: 89 ec mov %ebp,%esp return 0; 1061f8: 31 c0 xor %eax,%eax } 1061fa: 5d pop %ebp 1061fb: c3 ret 1061fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 106200: 89 ec mov %ebp,%esp return EINVAL; 106202: b8 16 00 00 00 mov $0x16,%eax } 106207: 5d pop %ebp 106208: c3 ret 106209: 90 nop 10620a: 90 nop 10620b: 90 nop 10620c: 90 nop 10620d: 90 nop 10620e: 90 nop 10620f: 90 nop =============================================================================== 00106370 : int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 106370: 55 push %ebp 106371: 89 e5 mov %esp,%ebp 106373: 56 push %esi 106374: 53 push %ebx 106375: 83 ec 30 sub $0x30,%esp 106378: 8b 5d 08 mov 0x8(%ebp),%ebx POSIX_RWLock_Control *the_rwlock; Status_Control status; the_rwlock = _POSIX_RWLock_Get( rwlock ); POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock ); 10637b: 85 db test %ebx,%ebx 10637d: 74 61 je 1063e0 10637f: 89 de mov %ebx,%esi 106381: 81 f6 bd da 21 96 xor $0x9621dabd,%esi 106387: 3b 33 cmp (%ebx),%esi 106389: 74 32 je 1063bd memset( &zero, 0, sizeof( zero ) ); 10638b: 31 d2 xor %edx,%edx 10638d: 31 c0 xor %eax,%eax 10638f: 89 54 05 d8 mov %edx,-0x28(%ebp,%eax,1) 106393: 89 54 05 dc mov %edx,-0x24(%ebp,%eax,1) 106397: 83 c0 08 add $0x8,%eax 10639a: 83 f8 20 cmp $0x20,%eax 10639d: 72 f0 jb 10638f if ( memcmp( the_rwlock, &zero, sizeof( *the_rwlock ) ) != 0 ) { 10639f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1063a2: b8 20 00 00 00 mov $0x20,%eax <== NOT EXECUTED 1063a7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1063ab: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 1063ae: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1063b2: e8 78 69 01 00 call 11cd2f <== NOT EXECUTED 1063b7: 85 c0 test %eax,%eax 1063b9: 75 25 jne 1063e0 the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC; 1063bb: 89 33 mov %esi,(%ebx) <== NOT EXECUTED status = _CORE_RWLock_Surrender( &the_rwlock->RWLock ); 1063bd: 83 c3 04 add $0x4,%ebx 1063c0: 89 1c 24 mov %ebx,(%esp) 1063c3: e8 98 16 00 00 call 107a60 <_CORE_RWLock_Surrender> return _POSIX_Get_error( status ); } 1063c8: 83 c4 30 add $0x30,%esp 1063cb: 5b pop %ebx 1063cc: 5e pop %esi 1063cd: 89 c2 mov %eax,%edx status = _CORE_RWLock_Surrender( &the_rwlock->RWLock ); 1063cf: 89 c1 mov %eax,%ecx 1063d1: c1 fa 1f sar $0x1f,%edx } 1063d4: 5d pop %ebp 1063d5: 0f b6 c2 movzbl %dl,%eax 1063d8: 01 c8 add %ecx,%eax 1063da: c1 f8 08 sar $0x8,%eax 1063dd: c3 ret 1063de: 66 90 xchg %ax,%ax 1063e0: 83 c4 30 add $0x30,%esp POSIX_RWLOCK_VALIDATE_OBJECT( the_rwlock ); 1063e3: b8 16 00 00 00 mov $0x16,%eax } 1063e8: 5b pop %ebx 1063e9: 5e pop %esi 1063ea: 5d pop %ebp 1063eb: c3 ret 1063ec: 90 nop 1063ed: 90 nop 1063ee: 90 nop 1063ef: 90 nop =============================================================================== 00106ee0 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 106ee0: 55 push %ebp if ( !attr ) return EINVAL; 106ee1: ba 16 00 00 00 mov $0x16,%edx { 106ee6: 89 e5 mov %esp,%ebp 106ee8: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr ) 106eeb: 85 c0 test %eax,%eax 106eed: 74 14 je 106f03 if ( !attr->is_initialized ) 106eef: 8b 08 mov (%eax),%ecx 106ef1: 85 c9 test %ecx,%ecx 106ef3: 74 0e je 106f03 return EINVAL; switch ( pshared ) { 106ef5: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 106ef9: 77 08 ja 106f03 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 106efb: 8b 4d 0c mov 0xc(%ebp),%ecx return 0; 106efe: 31 d2 xor %edx,%edx attr->process_shared = pshared; 106f00: 89 48 04 mov %ecx,0x4(%eax) default: return EINVAL; } } 106f03: 5d pop %ebp 106f04: 89 d0 mov %edx,%eax 106f06: c3 ret 106f07: 90 nop 106f08: 90 nop 106f09: 90 nop 106f0a: 90 nop 106f0b: 90 nop 106f0c: 90 nop 106f0d: 90 nop 106f0e: 90 nop 106f0f: 90 nop =============================================================================== 00105b60 : int pthread_setcancelstate( int state, int *oldstate ) { 105b60: 55 push %ebp 105b61: 89 e5 mov %esp,%ebp 105b63: 83 ec 18 sub $0x18,%esp 105b66: 89 5d f8 mov %ebx,-0x8(%ebp) 105b69: 8b 5d 08 mov 0x8(%ebp),%ebx 105b6c: 89 75 fc mov %esi,-0x4(%ebp) 105b6f: 8b 75 0c mov 0xc(%ebp),%esi Thread_Life_state new_life_protection; Thread_Life_state previous_life_state; if ( _ISR_Is_in_progress() ) { 105b72: e8 89 12 00 00 call 106e00 <_ISR_Is_in_progress> 105b77: 84 c0 test %al,%al 105b79: 75 55 jne 105bd0 return EPROTO; } if ( state == PTHREAD_CANCEL_DISABLE ) { 105b7b: 83 fb 01 cmp $0x1,%ebx 105b7e: 0f 84 7c 00 00 00 je 105c00 <== NEVER TAKEN new_life_protection = THREAD_LIFE_PROTECTED; } else if ( state == PTHREAD_CANCEL_ENABLE ) { 105b84: 85 db test %ebx,%ebx 105b86: 75 58 jne 105be0 new_life_protection = 0; 105b88: 31 c0 xor %eax,%eax } else { return EINVAL; } previous_life_state = _Thread_Set_life_protection( new_life_protection ); 105b8a: 89 04 24 mov %eax,(%esp) 105b8d: e8 9e 48 00 00 call 10a430 <_Thread_Set_life_protection> if ( oldstate != NULL ) { 105b92: 85 f6 test %esi,%esi 105b94: 74 5a je 105bf0 if ( ( previous_life_state & THREAD_LIFE_PROTECTED ) != 0 ) { 105b96: a8 01 test $0x1,%al 105b98: 74 16 je 105bb0 <== ALWAYS TAKEN *oldstate = PTHREAD_CANCEL_DISABLE; 105b9a: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED *oldstate = PTHREAD_CANCEL_ENABLE; } } return 0; } 105ba0: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED return 0; 105ba3: 31 c0 xor %eax,%eax <== NOT EXECUTED } 105ba5: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED 105ba8: 89 ec mov %ebp,%esp <== NOT EXECUTED 105baa: 5d pop %ebp <== NOT EXECUTED 105bab: c3 ret <== NOT EXECUTED 105bac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED *oldstate = PTHREAD_CANCEL_ENABLE; 105bb0: c7 06 00 00 00 00 movl $0x0,(%esi) } 105bb6: 8b 5d f8 mov -0x8(%ebp),%ebx return 0; 105bb9: 31 c0 xor %eax,%eax } 105bbb: 8b 75 fc mov -0x4(%ebp),%esi 105bbe: 89 ec mov %ebp,%esp 105bc0: 5d pop %ebp 105bc1: c3 ret 105bc2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105bc9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105bd0: 8b 5d f8 mov -0x8(%ebp),%ebx return EPROTO; 105bd3: b8 47 00 00 00 mov $0x47,%eax } 105bd8: 8b 75 fc mov -0x4(%ebp),%esi 105bdb: 89 ec mov %ebp,%esp 105bdd: 5d pop %ebp 105bde: c3 ret 105bdf: 90 nop 105be0: 8b 5d f8 mov -0x8(%ebp),%ebx return EINVAL; 105be3: b8 16 00 00 00 mov $0x16,%eax } 105be8: 8b 75 fc mov -0x4(%ebp),%esi 105beb: 89 ec mov %ebp,%esp 105bed: 5d pop %ebp 105bee: c3 ret 105bef: 90 nop 105bf0: 8b 5d f8 mov -0x8(%ebp),%ebx return 0; 105bf3: 31 c0 xor %eax,%eax } 105bf5: 8b 75 fc mov -0x4(%ebp),%esi 105bf8: 89 ec mov %ebp,%esp 105bfa: 5d pop %ebp 105bfb: c3 ret 105bfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi new_life_protection = THREAD_LIFE_PROTECTED; 105c00: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 105c05: eb 83 jmp 105b8a <== NOT EXECUTED 105c07: 90 nop 105c08: 90 nop 105c09: 90 nop 105c0a: 90 nop 105c0b: 90 nop 105c0c: 90 nop 105c0d: 90 nop 105c0e: 90 nop 105c0f: 90 nop =============================================================================== 00105c10 : int pthread_setcanceltype( int type, int *oldtype ) { 105c10: 55 push %ebp 105c11: 89 e5 mov %esp,%ebp 105c13: 83 ec 18 sub $0x18,%esp 105c16: 89 5d f8 mov %ebx,-0x8(%ebp) 105c19: 8b 5d 08 mov 0x8(%ebp),%ebx 105c1c: 89 75 fc mov %esi,-0x4(%ebp) 105c1f: 8b 75 0c mov 0xc(%ebp),%esi Thread_Life_state set_life_state; Thread_Life_state previous_life_state; if ( _ISR_Is_in_progress() ) { 105c22: e8 d9 11 00 00 call 106e00 <_ISR_Is_in_progress> 105c27: 84 c0 test %al,%al 105c29: 75 55 jne 105c80 return EPROTO; } if ( type == PTHREAD_CANCEL_DEFERRED ) { 105c2b: 85 db test %ebx,%ebx 105c2d: 74 41 je 105c70 set_life_state = THREAD_LIFE_CHANGE_DEFERRED; } else if ( type == PTHREAD_CANCEL_ASYNCHRONOUS ) { 105c2f: 4b dec %ebx 105c30: 75 7e jne 105cb0 set_life_state = 0; 105c32: 31 c0 xor %eax,%eax } else { return EINVAL; } previous_life_state = _Thread_Change_life( 105c34: 89 44 24 04 mov %eax,0x4(%esp) 105c38: 31 d2 xor %edx,%edx 105c3a: 89 54 24 08 mov %edx,0x8(%esp) 105c3e: c7 04 24 08 00 00 00 movl $0x8,(%esp) 105c45: e8 06 47 00 00 call 10a350 <_Thread_Change_life> THREAD_LIFE_CHANGE_DEFERRED, set_life_state, 0 ); if ( oldtype != NULL ) { 105c4a: 85 f6 test %esi,%esi 105c4c: 74 72 je 105cc0 if ( ( previous_life_state & THREAD_LIFE_CHANGE_DEFERRED ) != 0 ) { 105c4e: a8 08 test $0x8,%al 105c50: 74 3e je 105c90 <== NEVER TAKEN *oldtype = PTHREAD_CANCEL_DEFERRED; 105c52: c7 06 00 00 00 00 movl $0x0,(%esi) *oldtype = PTHREAD_CANCEL_ASYNCHRONOUS; } } return 0; } 105c58: 8b 5d f8 mov -0x8(%ebp),%ebx return 0; 105c5b: 31 c0 xor %eax,%eax } 105c5d: 8b 75 fc mov -0x4(%ebp),%esi 105c60: 89 ec mov %ebp,%esp 105c62: 5d pop %ebp 105c63: c3 ret 105c64: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105c6b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 105c6f: 90 nop set_life_state = THREAD_LIFE_CHANGE_DEFERRED; 105c70: b8 08 00 00 00 mov $0x8,%eax 105c75: eb bd jmp 105c34 105c77: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105c7e: 66 90 xchg %ax,%ax } 105c80: 8b 5d f8 mov -0x8(%ebp),%ebx return EPROTO; 105c83: b8 47 00 00 00 mov $0x47,%eax } 105c88: 8b 75 fc mov -0x4(%ebp),%esi 105c8b: 89 ec mov %ebp,%esp 105c8d: 5d pop %ebp 105c8e: c3 ret 105c8f: 90 nop *oldtype = PTHREAD_CANCEL_ASYNCHRONOUS; 105c90: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED } 105c96: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED return 0; 105c99: 31 c0 xor %eax,%eax <== NOT EXECUTED } 105c9b: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED 105c9e: 89 ec mov %ebp,%esp <== NOT EXECUTED 105ca0: 5d pop %ebp <== NOT EXECUTED 105ca1: c3 ret <== NOT EXECUTED 105ca2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105ca9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 105cb0: 8b 5d f8 mov -0x8(%ebp),%ebx return EINVAL; 105cb3: b8 16 00 00 00 mov $0x16,%eax } 105cb8: 8b 75 fc mov -0x4(%ebp),%esi 105cbb: 89 ec mov %ebp,%esp 105cbd: 5d pop %ebp 105cbe: c3 ret 105cbf: 90 nop 105cc0: 8b 5d f8 mov -0x8(%ebp),%ebx return 0; 105cc3: 31 c0 xor %eax,%eax } 105cc5: 8b 75 fc mov -0x4(%ebp),%esi 105cc8: 89 ec mov %ebp,%esp 105cca: 5d pop %ebp 105ccb: c3 ret 105ccc: 90 nop 105ccd: 90 nop 105cce: 90 nop 105ccf: 90 nop =============================================================================== 00108910 : const struct sched_param *param #else struct sched_param *param #endif ) { 108910: 55 push %ebp 108911: 89 e5 mov %esp,%ebp 108913: 81 ec 88 00 00 00 sub $0x88,%esp 108919: 89 75 f8 mov %esi,-0x8(%ebp) 10891c: 8b 75 10 mov 0x10(%ebp),%esi 10891f: 89 5d f4 mov %ebx,-0xc(%ebp) 108922: 89 7d fc mov %edi,-0x4(%ebp) Thread_Control *the_thread; Per_CPU_Control *cpu_self; Thread_queue_Context queue_context; int error; if ( param == NULL ) { 108925: 85 f6 test %esi,%esi 108927: 0f 84 03 02 00 00 je 108b30 return EINVAL; } error = _POSIX_Thread_Translate_sched_param( 10892d: 89 74 24 04 mov %esi,0x4(%esp) 108931: 8d 45 c0 lea -0x40(%ebp),%eax 108934: 89 44 24 0c mov %eax,0xc(%esp) 108938: 8d 45 bc lea -0x44(%ebp),%eax 10893b: 89 44 24 08 mov %eax,0x8(%esp) 10893f: 8b 45 0c mov 0xc(%ebp),%eax 108942: 89 04 24 mov %eax,(%esp) 108945: e8 a6 65 00 00 call 10eef0 <_POSIX_Thread_Translate_sched_param> 10894a: 89 45 b4 mov %eax,-0x4c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( error != 0 ) { 10894d: 85 c0 test %eax,%eax 10894f: 74 1f je 108970 cpu_self = _Thread_queue_Dispatch_disable( &queue_context ); _Thread_Wait_release( the_thread, &queue_context ); _Thread_Priority_update( &queue_context ); _Thread_Dispatch_enable( cpu_self ); return error; } 108951: 8b 45 b4 mov -0x4c(%ebp),%eax 108954: 8b 5d f4 mov -0xc(%ebp),%ebx 108957: 8b 75 f8 mov -0x8(%ebp),%esi 10895a: 8b 7d fc mov -0x4(%ebp),%edi 10895d: 89 ec mov %ebp,%esp 10895f: 5d pop %ebp 108960: c3 ret 108961: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 108968: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10896f: 90 nop queue_context->Priority.update_count = 0; 108970: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context ); 108977: 8d 45 c4 lea -0x3c(%ebp),%eax 10897a: 89 44 24 04 mov %eax,0x4(%esp) 10897e: 8b 45 08 mov 0x8(%ebp),%eax 108981: 89 04 24 mov %eax,(%esp) 108984: e8 47 2d 00 00 call 10b6d0 <_Thread_Get> if ( the_thread == NULL ) { 108989: 85 c0 test %eax,%eax the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context ); 10898b: 89 c7 mov %eax,%edi if ( the_thread == NULL ) { 10898d: 0f 84 bd 01 00 00 je 108b50 error = _POSIX_Set_sched_param( 108993: 8b 45 c0 mov -0x40(%ebp),%eax normal_prio = param->sched_priority; 108996: 8b 0e mov (%esi),%ecx core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid ); 108998: c7 04 24 40 9a 12 00 movl $0x129a40,(%esp) error = _POSIX_Set_sched_param( 10899f: 89 45 b0 mov %eax,-0x50(%ebp) 1089a2: 8b 45 bc mov -0x44(%ebp),%eax core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid ); 1089a5: 89 4c 24 04 mov %ecx,0x4(%esp) 1089a9: 89 4d a8 mov %ecx,-0x58(%ebp) error = _POSIX_Set_sched_param( 1089ac: 89 45 a4 mov %eax,-0x5c(%ebp) core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid ); 1089af: 8d 45 bb lea -0x45(%ebp),%eax 1089b2: 89 44 24 08 mov %eax,0x8(%esp) 1089b6: e8 e5 f5 ff ff call 107fa0 <_POSIX_Priority_To_core> if ( !valid ) { 1089bb: 8b 4d a8 mov -0x58(%ebp),%ecx 1089be: 80 7d bb 00 cmpb $0x0,-0x45(%ebp) core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid ); 1089c2: 89 45 98 mov %eax,-0x68(%ebp) 1089c5: 89 55 9c mov %edx,-0x64(%ebp) if ( !valid ) { 1089c8: 0f 84 42 01 00 00 je 108b10 <== NEVER TAKEN if ( policy == SCHED_SPORADIC ) { 1089ce: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 1089d2: 0f 84 48 01 00 00 je 108b20 core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid ); 1089d8: 89 4c 24 04 mov %ecx,0x4(%esp) 1089dc: 8d 45 bb lea -0x45(%ebp),%eax 1089df: 89 44 24 08 mov %eax,0x8(%esp) 1089e3: c7 04 24 40 9a 12 00 movl $0x129a40,(%esp) 1089ea: e8 b1 f5 ff ff call 107fa0 <_POSIX_Priority_To_core> if ( !valid ) { 1089ef: 80 7d bb 00 cmpb $0x0,-0x45(%ebp) core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid ); 1089f3: 89 45 a8 mov %eax,-0x58(%ebp) 1089f6: 89 55 ac mov %edx,-0x54(%ebp) if ( !valid ) { 1089f9: 0f 84 11 01 00 00 je 108b10 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1089ff: 8b 97 0c 01 00 00 mov 0x10c(%edi),%edx _Thread_Priority_add( 108a05: 8d 5d c4 lea -0x3c(%ebp),%ebx _Watchdog_Remove( 108a08: c7 04 24 90 3c 13 00 movl $0x133c90,(%esp) _Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer ); 108a0f: 89 55 a0 mov %edx,-0x60(%ebp) 108a12: 8d 42 04 lea 0x4(%edx),%eax 108a15: 89 44 24 04 mov %eax,0x4(%esp) 108a19: 89 45 94 mov %eax,-0x6c(%ebp) 108a1c: e8 8f 4d 00 00 call 10d7b0 <_Watchdog_Remove> 108a21: 8b 55 9c mov -0x64(%ebp),%edx 108a24: 8b 45 98 mov -0x68(%ebp),%eax 108a27: 89 57 34 mov %edx,0x34(%edi) if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) { 108a2a: 8b 55 a0 mov -0x60(%ebp),%edx 108a2d: 89 47 30 mov %eax,0x30(%edi) _Thread_Priority_add( 108a30: 8d 47 20 lea 0x20(%edi),%eax if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) { 108a33: 83 7a 2c ff cmpl $0xffffffff,0x2c(%edx) 108a37: 89 55 98 mov %edx,-0x68(%ebp) 108a3a: 0f 84 20 01 00 00 je 108b60 _Thread_Priority_add( 108a40: 89 44 24 04 mov %eax,0x4(%esp) 108a44: 89 5c 24 08 mov %ebx,0x8(%esp) 108a48: 89 3c 24 mov %edi,(%esp) 108a4b: e8 00 28 00 00 call 10b250 <_Thread_Priority_add> _Thread_Priority_remove( 108a50: 8b 55 98 mov -0x68(%ebp),%edx 108a53: 89 5c 24 08 mov %ebx,0x8(%esp) 108a57: 89 3c 24 mov %edi,(%esp) 108a5a: 8d 42 20 lea 0x20(%edx),%eax 108a5d: 89 44 24 04 mov %eax,0x4(%esp) 108a61: e8 6a 28 00 00 call 10b2d0 <_Thread_Priority_remove> RB_COLOR( the_node, Node ) = -1; 108a66: 8b 55 98 mov -0x68(%ebp),%edx 108a69: c7 42 2c ff ff ff ff movl $0xffffffff,0x2c(%edx) the_thread->budget_algorithm = budget_algorithm; 108a70: 8b 45 a4 mov -0x5c(%ebp),%eax 108a73: 8b 4d a8 mov -0x58(%ebp),%ecx 108a76: 8b 5d ac mov -0x54(%ebp),%ebx if ( policy == SCHED_SPORADIC ) { 108a79: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) the_thread->budget_algorithm = budget_algorithm; 108a7d: 89 87 88 00 00 00 mov %eax,0x88(%edi) the_thread->budget_callout = budget_callout; 108a83: 8b 45 b0 mov -0x50(%ebp),%eax 108a86: 89 87 8c 00 00 00 mov %eax,0x8c(%edi) api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period; 108a8c: 8b 46 08 mov 0x8(%esi),%eax 108a8f: 89 4a 30 mov %ecx,0x30(%edx) 108a92: 89 5a 34 mov %ebx,0x34(%edx) 108a95: 89 42 38 mov %eax,0x38(%edx) 108a98: 8b 46 0c mov 0xc(%esi),%eax 108a9b: 89 42 3c mov %eax,0x3c(%edx) 108a9e: 8b 46 10 mov 0x10(%esi),%eax 108aa1: 89 42 40 mov %eax,0x40(%edx) api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget; 108aa4: 8b 46 14 mov 0x14(%esi),%eax 108aa7: 89 42 44 mov %eax,0x44(%edx) 108aaa: 8b 46 18 mov 0x18(%esi),%eax 108aad: 89 42 48 mov %eax,0x48(%edx) 108ab0: 8b 46 1c mov 0x1c(%esi),%eax 108ab3: 89 42 4c mov %eax,0x4c(%edx) api->Sporadic.sched_ss_max_repl = param->sched_ss_max_repl; 108ab6: 8b 46 20 mov 0x20(%esi),%eax 108ab9: 89 42 50 mov %eax,0x50(%edx) if ( policy == SCHED_SPORADIC ) { 108abc: 0f 84 be 00 00 00 je 108b80 the_thread->cpu_time_budget = 108ac2: a1 78 a3 12 00 mov 0x12a378,%eax 108ac7: 89 87 84 00 00 00 mov %eax,0x84(%edi) disable_level = cpu_self->thread_dispatch_disable_level; 108acd: a1 70 3c 13 00 mov 0x133c70,%eax cpu_self->thread_dispatch_disable_level = disable_level + 1; 108ad2: 40 inc %eax 108ad3: a3 70 3c 13 00 mov %eax,0x133c70 _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 108ad8: ff 75 c4 push -0x3c(%ebp) 108adb: 9d popf _Thread_Priority_update( &queue_context ); 108adc: 8d 45 c4 lea -0x3c(%ebp),%eax 108adf: 89 04 24 mov %eax,(%esp) 108ae2: e8 e9 28 00 00 call 10b3d0 <_Thread_Priority_update> _Thread_Dispatch_enable( cpu_self ); 108ae7: c7 04 24 60 3c 13 00 movl $0x133c60,(%esp) 108aee: e8 5d 2b 00 00 call 10b650 <_Thread_Dispatch_enable> } 108af3: 8b 45 b4 mov -0x4c(%ebp),%eax 108af6: 8b 5d f4 mov -0xc(%ebp),%ebx 108af9: 8b 75 f8 mov -0x8(%ebp),%esi 108afc: 8b 7d fc mov -0x4(%ebp),%edi 108aff: 89 ec mov %ebp,%esp 108b01: 5d pop %ebp 108b02: c3 ret 108b03: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 108b0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return EINVAL; 108b10: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) 108b17: eb b4 jmp 108acd 108b19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi low_prio = param->sched_ss_low_priority; 108b20: 8b 4e 04 mov 0x4(%esi),%ecx 108b23: e9 b0 fe ff ff jmp 1089d8 108b28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 108b2f: 90 nop return EINVAL; 108b30: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) } 108b37: 8b 5d f4 mov -0xc(%ebp),%ebx 108b3a: 8b 45 b4 mov -0x4c(%ebp),%eax 108b3d: 8b 75 f8 mov -0x8(%ebp),%esi 108b40: 8b 7d fc mov -0x4(%ebp),%edi 108b43: 89 ec mov %ebp,%esp 108b45: 5d pop %ebp 108b46: c3 ret 108b47: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 108b4e: 66 90 xchg %ax,%ax return ESRCH; 108b50: c7 45 b4 03 00 00 00 movl $0x3,-0x4c(%ebp) 108b57: e9 f5 fd ff ff jmp 108951 108b5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi _Thread_Priority_changed( 108b60: 89 5c 24 0c mov %ebx,0xc(%esp) 108b64: 31 d2 xor %edx,%edx 108b66: 89 54 24 08 mov %edx,0x8(%esp) 108b6a: 89 44 24 04 mov %eax,0x4(%esp) 108b6e: 89 3c 24 mov %edi,(%esp) 108b71: e8 da 27 00 00 call 10b350 <_Thread_Priority_changed> 108b76: 8b 55 98 mov -0x68(%ebp),%edx 108b79: e9 f2 fe ff ff jmp 108a70 108b7e: 66 90 xchg %ax,%ax _Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget ); 108b80: 89 55 a8 mov %edx,-0x58(%ebp) 108b83: 8d 42 44 lea 0x44(%edx),%eax 108b86: 89 04 24 mov %eax,(%esp) 108b89: e8 22 47 00 00 call 10d2b0 <_Timespec_To_ticks> _Timespec_To_ticks( &api->Sporadic.sched_ss_repl_period ) 108b8e: 8b 55 a8 mov -0x58(%ebp),%edx 108b91: 83 c2 38 add $0x38,%edx the_thread->cpu_time_budget = 108b94: 89 87 84 00 00 00 mov %eax,0x84(%edi) _Timespec_To_ticks( &api->Sporadic.sched_ss_repl_period ) 108b9a: 89 14 24 mov %edx,(%esp) _Watchdog_Per_CPU_insert_ticks( 108b9d: e8 0e 47 00 00 call 10d2b0 <_Timespec_To_ticks> expire = ticks + cpu->Watchdog.ticks; 108ba2: 31 d2 xor %edx,%edx _Watchdog_Insert(header, the_watchdog, expire); 108ba4: c7 04 24 90 3c 13 00 movl $0x133c90,(%esp) expire = ticks + cpu->Watchdog.ticks; 108bab: 03 05 88 3c 13 00 add 0x133c88,%eax 108bb1: 13 15 8c 3c 13 00 adc 0x133c8c,%edx _Watchdog_Insert(header, the_watchdog, expire); 108bb7: 89 44 24 08 mov %eax,0x8(%esp) 108bbb: 8b 45 94 mov -0x6c(%ebp),%eax 108bbe: 89 54 24 0c mov %edx,0xc(%esp) 108bc2: 89 44 24 04 mov %eax,0x4(%esp) 108bc6: e8 45 4b 00 00 call 10d710 <_Watchdog_Insert> } 108bcb: e9 fd fe ff ff jmp 108acd =============================================================================== 00107690 : int pthread_setspecific( pthread_key_t key, const void *value ) { 107690: 55 push %ebp 107691: 89 e5 mov %esp,%ebp 107693: 57 push %edi 107694: 56 push %esi 107695: 53 push %ebx 107696: 83 ec 2c sub $0x2c,%esp Thread_Control *executing; int eno; executing = _Thread_Get_executing(); if ( value != NULL ) { 107699: 8b 4d 0c mov 0xc(%ebp),%ecx { 10769c: 8b 5d 08 mov 0x8(%ebp),%ebx 10769f: 8b 35 98 de 15 00 mov 0x15de98,%esi if ( value != NULL ) { 1076a5: 85 c9 test %ecx,%ecx 1076a7: 74 47 je 1076f0 _ISR_lock_ISR_disable_and_acquire( &the_thread->Keys.Lock, lock_context ); 1076a9: 9c pushf 1076aa: fa cli 1076ab: 5f pop %edi while ( *link != NULL ) { 1076ac: 8b 86 10 01 00 00 mov 0x110(%esi),%eax 1076b2: 85 c0 test %eax,%eax 1076b4: 75 1b jne 1076d1 1076b6: e9 e5 00 00 00 jmp 1077a0 1076bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1076bf: 90 nop return &RB_RIGHT( the_node, Node ); 1076c0: 8d 48 04 lea 0x4(%eax),%ecx } else if ( ( *less )( key, parent ) ) { 1076c3: 73 02 jae 1076c7 <== ALWAYS TAKEN return &RB_LEFT( the_node, Node ); 1076c5: 89 c1 mov %eax,%ecx <== NOT EXECUTED while ( *link != NULL ) { 1076c7: 8b 01 mov (%ecx),%eax 1076c9: 85 c0 test %eax,%eax 1076cb: 0f 84 cf 00 00 00 je 1077a0 return *the_left == the_right->key; 1076d1: 8b 50 10 mov 0x10(%eax),%edx the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right ); 1076d4: 8d 48 f8 lea -0x8(%eax),%ecx if ( ( *equal )( key, parent ) ) { 1076d7: 39 d3 cmp %edx,%ebx 1076d9: 75 e5 jne 1076c0 key_value_pair->value = RTEMS_DECONST( void *, value ); 1076db: 8b 45 0c mov 0xc(%ebp),%eax 1076de: 89 41 20 mov %eax,0x20(%ecx) _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 1076e1: 57 push %edi 1076e2: 9d popf } else { eno = _POSIX_Keys_Delete_value( key, executing ); } return eno; } 1076e3: 83 c4 2c add $0x2c,%esp eno = _POSIX_Keys_Set_value( key_value_pair, value ); 1076e6: 31 c0 xor %eax,%eax } 1076e8: 5b pop %ebx 1076e9: 5e pop %esi 1076ea: 5f pop %edi 1076eb: 5d pop %ebp 1076ec: c3 ret 1076ed: 8d 76 00 lea 0x0(%esi),%esi _RTEMS_Lock_allocator(); 1076f0: e8 1b 0b 00 00 call 108210 <_RTEMS_Lock_allocator> _Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information ); 1076f5: ba 40 a1 15 00 mov $0x15a140,%edx 1076fa: 89 54 24 04 mov %edx,0x4(%esp) 1076fe: 89 1c 24 mov %ebx,(%esp) 107701: e8 2a 32 00 00 call 10a930 <_Objects_Get_no_protection> if ( the_key != NULL ) { 107706: 85 c0 test %eax,%eax 107708: 0f 84 82 00 00 00 je 107790 _ISR_lock_ISR_disable_and_acquire( &the_thread->Keys.Lock, lock_context ); 10770e: 9c pushf 10770f: fa cli 107710: 5f pop %edi while ( *link != NULL ) { 107711: 8b 86 10 01 00 00 mov 0x110(%esi),%eax 107717: 85 c0 test %eax,%eax 107719: 75 22 jne 10773d 10771b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10771f: 90 nop _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 107720: 57 push %edi 107721: 9d popf eno = 0; 107722: 31 c0 xor %eax,%eax } 107724: eb 57 jmp 10777d 107726: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10772d: 8d 76 00 lea 0x0(%esi),%esi return &RB_RIGHT( the_node, Node ); 107730: 8d 48 04 lea 0x4(%eax),%ecx <== NOT EXECUTED } else if ( ( *less )( key, parent ) ) { 107733: 73 02 jae 107737 <== NOT EXECUTED return &RB_LEFT( the_node, Node ); 107735: 89 c1 mov %eax,%ecx <== NOT EXECUTED while ( *link != NULL ) { 107737: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 107739: 85 c0 test %eax,%eax <== NOT EXECUTED 10773b: 74 e3 je 107720 <== NOT EXECUTED return *the_left == the_right->key; 10773d: 8b 50 10 mov 0x10(%eax),%edx the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right ); 107740: 8d 48 f8 lea -0x8(%eax),%ecx if ( ( *equal )( key, parent ) ) { 107743: 39 d3 cmp %edx,%ebx 107745: 75 e9 jne 107730 <== NEVER TAKEN _RBTree_Extract( 107747: 89 44 24 04 mov %eax,0x4(%esp) RTEMS_INLINE_ROUTINE POSIX_Keys_Key_value_pair *_POSIX_Keys_Key_value_find( pthread_key_t key, const Thread_Control *the_thread ) { return _RBTree_Find_inline( 10774b: 81 c6 10 01 00 00 add $0x110,%esi 107751: 89 34 24 mov %esi,(%esp) 107754: 89 4d e4 mov %ecx,-0x1c(%ebp) 107757: e8 e4 33 00 00 call 10ab40 <_RBTree_Extract> _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 10775c: 57 push %edi 10775d: 9d popf next = the_node->next; 10775e: 8b 4d e4 mov -0x1c(%ebp),%ecx previous = the_node->previous; 107761: 8b 41 04 mov 0x4(%ecx),%eax next = the_node->next; 107764: 8b 11 mov (%ecx),%edx next->previous = previous; 107766: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 107769: 89 10 mov %edx,(%eax) _Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair ); 10776b: 89 4c 24 04 mov %ecx,0x4(%esp) 10776f: c7 04 24 04 de 15 00 movl $0x15de04,(%esp) 107776: e8 a5 0d 00 00 call 108520 <_Freechain_Put> eno = 0; 10777b: 31 c0 xor %eax,%eax 10777d: 89 45 e4 mov %eax,-0x1c(%ebp) _RTEMS_Unlock_allocator(); 107780: e8 ab 0a 00 00 call 108230 <_RTEMS_Unlock_allocator> return eno; 107785: 8b 45 e4 mov -0x1c(%ebp),%eax } 107788: 83 c4 2c add $0x2c,%esp 10778b: 5b pop %ebx 10778c: 5e pop %esi 10778d: 5f pop %edi 10778e: 5d pop %ebp 10778f: c3 ret eno = EINVAL; 107790: b8 16 00 00 00 mov $0x16,%eax 107795: eb e6 jmp 10777d 107797: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10779e: 66 90 xchg %ax,%ax _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 1077a0: 57 push %edi 1077a1: 9d popf _RTEMS_Lock_allocator(); 1077a2: e8 69 0a 00 00 call 108210 <_RTEMS_Lock_allocator> _Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information ); 1077a7: b8 40 a1 15 00 mov $0x15a140,%eax 1077ac: 89 44 24 04 mov %eax,0x4(%esp) 1077b0: 89 1c 24 mov %ebx,(%esp) 1077b3: e8 78 31 00 00 call 10a930 <_Objects_Get_no_protection> if ( the_key != NULL ) { 1077b8: 85 c0 test %eax,%eax 1077ba: 89 c7 mov %eax,%edi 1077bc: 74 d2 je 107790 key_value_pair = _POSIX_Keys_Key_value_allocate(); 1077be: e8 7d fd ff ff call 107540 <_POSIX_Keys_Key_value_allocate> if ( key_value_pair != NULL ) { 1077c3: 85 c0 test %eax,%eax 1077c5: 0f 84 8c 00 00 00 je 107857 <== NEVER TAKEN key_value_pair->key = key; 1077cb: 89 58 18 mov %ebx,0x18(%eax) return &RB_ROOT( the_rbtree ); 1077ce: 8d 96 10 01 00 00 lea 0x110(%esi),%edx 1077d4: 89 55 e4 mov %edx,-0x1c(%ebp) key_value_pair->value = RTEMS_DECONST( void *, value ); 1077d7: 8b 55 0c mov 0xc(%ebp),%edx return &the_chain->Tail.Node; 1077da: 8d 4f 18 lea 0x18(%edi),%ecx key_value_pair->thread = executing; 1077dd: 89 70 1c mov %esi,0x1c(%eax) key_value_pair->value = RTEMS_DECONST( void *, value ); 1077e0: 89 50 20 mov %edx,0x20(%eax) _RBTree_Initialize_node( &key_value_pair->Lookup_node ); 1077e3: 8d 50 08 lea 0x8(%eax),%edx 1077e6: 89 55 e0 mov %edx,-0x20(%ebp) old_last = tail->previous; 1077e9: 8b 57 1c mov 0x1c(%edi),%edx return &the_chain->Tail.Node; 1077ec: 89 08 mov %ecx,(%eax) tail->previous = the_node; 1077ee: 89 47 1c mov %eax,0x1c(%edi) old_last->next = the_node; 1077f1: 89 02 mov %eax,(%edx) the_node->previous = old_last; 1077f3: 89 50 04 mov %edx,0x4(%eax) _ISR_lock_ISR_disable_and_acquire( &the_thread->Keys.Lock, lock_context ); 1077f6: 9c pushf 1077f7: fa cli 1077f8: 5f pop %edi while ( *link != NULL ) { 1077f9: 8b 96 10 01 00 00 mov 0x110(%esi),%edx 1077ff: 85 d2 test %edx,%edx 107801: 75 0f jne 107812 107803: eb 5c jmp 107861 107805: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10780c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 107810: 89 ca mov %ecx,%edx if ( ( *less )( key, parent ) ) { 107812: 3b 5a 10 cmp 0x10(%edx),%ebx return &RB_RIGHT( the_node, Node ); 107815: 8d 72 04 lea 0x4(%edx),%esi if ( ( *less )( key, parent ) ) { 107818: 73 02 jae 10781c <== ALWAYS TAKEN return &RB_LEFT( the_node, Node ); 10781a: 89 d6 mov %edx,%esi <== NOT EXECUTED while ( *link != NULL ) { 10781c: 8b 0e mov (%esi),%ecx 10781e: 85 c9 test %ecx,%ecx 107820: 75 ee jne 107810 RB_SET( child, parent, Node ); 107822: 89 50 10 mov %edx,0x10(%eax) 107825: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 10782c: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 107833: c7 40 14 01 00 00 00 movl $0x1,0x14(%eax) *link = child; 10783a: 8b 45 e0 mov -0x20(%ebp),%eax 10783d: 89 06 mov %eax,(%esi) _RBTree_Insert_color( the_rbtree, the_node ); 10783f: 89 44 24 04 mov %eax,0x4(%esp) 107843: 8b 45 e4 mov -0x1c(%ebp),%eax 107846: 89 04 24 mov %eax,(%esp) 107849: e8 82 37 00 00 call 10afd0 <_RBTree_Insert_color> _ISR_lock_Release_and_ISR_enable( &the_thread->Keys.Lock, lock_context ); 10784e: 57 push %edi 10784f: 9d popf eno = 0; 107850: 31 c0 xor %eax,%eax 107852: e9 26 ff ff ff jmp 10777d eno = ENOMEM; 107857: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10785c: e9 1c ff ff ff jmp 10777d <== NOT EXECUTED link = _RBTree_Root_reference( the_rbtree ); 107861: 8b 75 e4 mov -0x1c(%ebp),%esi 107864: eb bc jmp 107822 107866: 90 nop 107867: 90 nop 107868: 90 nop 107869: 90 nop 10786a: 90 nop 10786b: 90 nop 10786c: 90 nop 10786d: 90 nop 10786e: 90 nop 10786f: 90 nop =============================================================================== 00105cd0 : /* * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 105cd0: 55 push %ebp 105cd1: 89 e5 mov %esp,%ebp 105cd3: 83 ec 18 sub $0x18,%esp if ( _ISR_Is_in_progress() ) { 105cd6: e8 25 11 00 00 call 106e00 <_ISR_Is_in_progress> 105cdb: 84 c0 test %al,%al 105cdd: 75 1b jne 105cfa <== NEVER TAKEN return; } _Thread_Change_life( 0, 0, THREAD_LIFE_CHANGE_DEFERRED ); 105cdf: c7 04 24 00 00 00 00 movl $0x0,(%esp) 105ce6: b8 08 00 00 00 mov $0x8,%eax 105ceb: 31 d2 xor %edx,%edx 105ced: 89 44 24 08 mov %eax,0x8(%esp) 105cf1: 89 54 24 04 mov %edx,0x4(%esp) 105cf5: e8 56 46 00 00 call 10a350 <_Thread_Change_life> } 105cfa: 89 ec mov %ebp,%esp 105cfc: 5d pop %ebp 105cfd: c3 ret 105cfe: 90 nop 105cff: 90 nop =============================================================================== 0010a170 : { 10a170: 55 push %ebp 10a171: 89 e5 mov %esp,%ebp 10a173: 57 push %edi 10a174: 56 push %esi 10a175: 53 push %ebx 10a176: 83 ec 5c sub $0x5c,%esp result = pthread_mutex_lock (&aio_request_queue.mutex); 10a179: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) { 10a180: 8b 7d 08 mov 0x8(%ebp),%edi result = pthread_mutex_lock (&aio_request_queue.mutex); 10a183: e8 98 1b 00 00 call 10bd20 if (result != 0) { 10a188: 85 c0 test %eax,%eax result = pthread_mutex_lock (&aio_request_queue.mutex); 10a18a: 89 c6 mov %eax,%esi if (result != 0) { 10a18c: 0f 85 1e 01 00 00 jne 10a2b0 <== NEVER TAKEN pthread_getschedparam (pthread_self(), &policy, ¶m); 10a192: e8 59 29 00 00 call 10caf0 10a197: 8d 55 c4 lea -0x3c(%ebp),%edx 10a19a: 89 54 24 08 mov %edx,0x8(%esp) 10a19e: 8d 55 c0 lea -0x40(%ebp),%edx 10a1a1: 89 54 24 04 mov %edx,0x4(%esp) 10a1a5: 89 04 24 mov %eax,(%esp) 10a1a8: e8 33 28 00 00 call 10c9e0 req->caller_thread = pthread_self (); 10a1ad: e8 3e 29 00 00 call 10caf0 req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10a1b2: 8b 55 c4 mov -0x3c(%ebp),%edx if ((aio_request_queue.idle_threads == 0) && 10a1b5: 8b 1d c8 1c 13 00 mov 0x131cc8,%ebx req->caller_thread = pthread_self (); 10a1bb: 89 47 10 mov %eax,0x10(%edi) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10a1be: 8b 47 14 mov 0x14(%edi),%eax 10a1c1: 8b 48 14 mov 0x14(%eax),%ecx 10a1c4: 29 ca sub %ecx,%edx if ((aio_request_queue.idle_threads == 0) && 10a1c6: 85 db test %ebx,%ebx req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10a1c8: 89 57 0c mov %edx,0xc(%edi) req->policy = policy; 10a1cb: 8b 55 c0 mov -0x40(%ebp),%edx 10a1ce: 89 57 08 mov %edx,0x8(%edi) r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a1d1: 8b 10 mov (%eax),%edx req->aiocbp->error_code = EINPROGRESS; 10a1d3: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10a1da: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10a1e1: 75 0d jne 10a1f0 <== NEVER TAKEN 10a1e3: 83 3d c4 1c 13 00 04 cmpl $0x4,0x131cc4 10a1ea: 0f 8e e0 00 00 00 jle 10a2d0 return _Chain_Immutable_head( the_chain )->next; 10a1f0: 8b 1d a8 1c 13 00 mov 0x131ca8,%ebx while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10a1f6: 8b 43 14 mov 0x14(%ebx),%eax 10a1f9: 39 c2 cmp %eax,%edx 10a1fb: 7f 5c jg 10a259 10a1fd: 8d 76 00 lea 0x0(%esi),%esi if (r_chain->fildes == fildes) 10a200: 39 c2 cmp %eax,%edx 10a202: 75 5d jne 10a261 r_chain->new_fd = 0; 10a204: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) pthread_mutex_lock (&r_chain->mutex); 10a20b: 8d 4b 1c lea 0x1c(%ebx),%ecx 10a20e: 89 0c 24 mov %ecx,(%esp) 10a211: 89 4d b4 mov %ecx,-0x4c(%ebp) 10a214: e8 07 1b 00 00 call 10bd20 rtems_aio_insert_prio (&r_chain->perfd, req); 10a219: 8d 43 08 lea 0x8(%ebx),%eax 10a21c: 89 fa mov %edi,%edx 10a21e: e8 7d f8 ff ff call 109aa0 pthread_cond_signal (&r_chain->cond); 10a223: 83 c3 54 add $0x54,%ebx 10a226: 89 1c 24 mov %ebx,(%esp) 10a229: e8 a2 15 00 00 call 10b7d0 pthread_mutex_unlock (&r_chain->mutex); 10a22e: 8b 4d b4 mov -0x4c(%ebp),%ecx 10a231: 89 0c 24 mov %ecx,(%esp) 10a234: e8 e7 1d 00 00 call 10c020 pthread_mutex_unlock (&aio_request_queue.mutex); 10a239: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) 10a240: e8 db 1d 00 00 call 10c020 } 10a245: 83 c4 5c add $0x5c,%esp 10a248: 89 f0 mov %esi,%eax 10a24a: 5b pop %ebx 10a24b: 5e pop %esi 10a24c: 5f pop %edi 10a24d: 5d pop %ebp 10a24e: c3 ret 10a24f: 90 nop return the_node->next; 10a250: 8b 1b mov (%ebx),%ebx while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10a252: 8b 43 14 mov 0x14(%ebx),%eax 10a255: 39 d0 cmp %edx,%eax 10a257: 7d a7 jge 10a200 10a259: 81 fb ac 1c 13 00 cmp $0x131cac,%ebx 10a25f: 75 ef jne 10a250 <== ALWAYS TAKEN r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a261: 89 54 24 04 mov %edx,0x4(%esp) 10a265: bb 01 00 00 00 mov $0x1,%ebx 10a26a: 89 5c 24 08 mov %ebx,0x8(%esp) 10a26e: c7 04 24 b4 1c 13 00 movl $0x131cb4,(%esp) 10a275: e8 b6 fc ff ff call 109f30 if (r_chain->new_fd == 1) { 10a27a: 83 78 18 01 cmpl $0x1,0x18(%eax) r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a27e: 89 c3 mov %eax,%ebx if (r_chain->new_fd == 1) { 10a280: 0f 84 da 00 00 00 je 10a360 rtems_aio_insert_prio (&r_chain->perfd, req); 10a286: 8d 40 08 lea 0x8(%eax),%eax 10a289: 89 fa mov %edi,%edx 10a28b: e8 10 f8 ff ff call 109aa0 if (aio_request_queue.idle_threads > 0) 10a290: a1 c8 1c 13 00 mov 0x131cc8,%eax 10a295: 85 c0 test %eax,%eax 10a297: 7e a0 jle 10a239 <== ALWAYS TAKEN pthread_cond_signal (&aio_request_queue.new_req); 10a299: c7 04 24 38 1c 13 00 movl $0x131c38,(%esp) <== NOT EXECUTED 10a2a0: e8 2b 15 00 00 call 10b7d0 <== NOT EXECUTED 10a2a5: eb 92 jmp 10a239 <== NOT EXECUTED 10a2a7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a2ae: 66 90 xchg %ax,%ax <== NOT EXECUTED free (req); 10a2b0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a2b3: e8 78 67 ff ff call 100a30 <== NOT EXECUTED } 10a2b8: 83 c4 5c add $0x5c,%esp <== NOT EXECUTED 10a2bb: 89 f0 mov %esi,%eax <== NOT EXECUTED 10a2bd: 5b pop %ebx <== NOT EXECUTED 10a2be: 5e pop %esi <== NOT EXECUTED 10a2bf: 5f pop %edi <== NOT EXECUTED 10a2c0: 5d pop %ebp <== NOT EXECUTED 10a2c1: c3 ret <== NOT EXECUTED 10a2c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a2c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a2d0: 89 54 24 04 mov %edx,0x4(%esp) 10a2d4: b8 01 00 00 00 mov $0x1,%eax 10a2d9: 89 44 24 08 mov %eax,0x8(%esp) 10a2dd: c7 04 24 a8 1c 13 00 movl $0x131ca8,(%esp) 10a2e4: e8 47 fc ff ff call 109f30 if (r_chain->new_fd == 1) { 10a2e9: 83 78 18 01 cmpl $0x1,0x18(%eax) r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10a2ed: 89 c3 mov %eax,%ebx if (r_chain->new_fd == 1) { 10a2ef: 0f 85 16 ff ff ff jne 10a20b rtems_chain_prepend (&r_chain->perfd, &req->next_prio); 10a2f5: 89 7c 24 04 mov %edi,0x4(%esp) 10a2f9: 8d 40 08 lea 0x8(%eax),%eax pthread_mutex_init (&r_chain->mutex, NULL); 10a2fc: 31 ff xor %edi,%edi rtems_chain_prepend (&r_chain->perfd, &req->next_prio); 10a2fe: 89 04 24 mov %eax,(%esp) 10a301: e8 da 2b 00 00 call 10cee0 pthread_mutex_init (&r_chain->mutex, NULL); 10a306: 8d 43 1c lea 0x1c(%ebx),%eax r_chain->new_fd = 0; 10a309: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) pthread_mutex_init (&r_chain->mutex, NULL); 10a310: 89 7c 24 04 mov %edi,0x4(%esp) 10a314: 89 04 24 mov %eax,(%esp) 10a317: e8 e4 18 00 00 call 10bc00 pthread_cond_init (&r_chain->cond, NULL); 10a31c: 31 c0 xor %eax,%eax 10a31e: 89 44 24 04 mov %eax,0x4(%esp) 10a322: 8d 43 54 lea 0x54(%ebx),%eax 10a325: 89 04 24 mov %eax,(%esp) 10a328: e8 23 14 00 00 call 10b750 result = pthread_create (&thid, &aio_request_queue.attr, 10a32d: b8 20 9b 10 00 mov $0x109b20,%eax 10a332: 89 44 24 08 mov %eax,0x8(%esp) 10a336: b8 54 1c 13 00 mov $0x131c54,%eax 10a33b: 89 44 24 04 mov %eax,0x4(%esp) 10a33f: 8d 45 bc lea -0x44(%ebp),%eax 10a342: 89 5c 24 0c mov %ebx,0xc(%esp) 10a346: 89 04 24 mov %eax,(%esp) 10a349: e8 42 22 00 00 call 10c590 if (result != 0) { 10a34e: 85 c0 test %eax,%eax result = pthread_create (&thid, &aio_request_queue.attr, 10a350: 89 c3 mov %eax,%ebx if (result != 0) { 10a352: 75 49 jne 10a39d <== NEVER TAKEN ++aio_request_queue.active_threads; 10a354: ff 05 c4 1c 13 00 incl 0x131cc4 10a35a: e9 da fe ff ff jmp 10a239 10a35f: 90 nop rtems_chain_prepend (&r_chain->perfd, &req->next_prio); 10a360: 89 7c 24 04 mov %edi,0x4(%esp) 10a364: 8d 40 08 lea 0x8(%eax),%eax 10a367: 89 04 24 mov %eax,(%esp) 10a36a: e8 71 2b 00 00 call 10cee0 pthread_mutex_init (&r_chain->mutex, NULL); 10a36f: 8d 43 1c lea 0x1c(%ebx),%eax 10a372: 31 d2 xor %edx,%edx r_chain->new_fd = 0; 10a374: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) pthread_cond_init (&r_chain->cond, NULL); 10a37b: 83 c3 54 add $0x54,%ebx pthread_mutex_init (&r_chain->mutex, NULL); 10a37e: 89 54 24 04 mov %edx,0x4(%esp) 10a382: 89 04 24 mov %eax,(%esp) 10a385: e8 76 18 00 00 call 10bc00 pthread_cond_init (&r_chain->cond, NULL); 10a38a: 31 c9 xor %ecx,%ecx 10a38c: 89 4c 24 04 mov %ecx,0x4(%esp) 10a390: 89 1c 24 mov %ebx,(%esp) 10a393: e8 b8 13 00 00 call 10b750 10a398: e9 f3 fe ff ff jmp 10a290 pthread_mutex_unlock (&aio_request_queue.mutex); 10a39d: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) <== NOT EXECUTED return result; 10a3a4: 89 de mov %ebx,%esi <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a3a6: e8 75 1c 00 00 call 10c020 <== NOT EXECUTED return result; 10a3ab: e9 95 fe ff ff jmp 10a245 <== NOT EXECUTED =============================================================================== 00109df0 : { 109df0: 55 push %ebp 109df1: 89 e5 mov %esp,%ebp 109df3: 83 ec 18 sub $0x18,%esp result = pthread_attr_init (&aio_request_queue.attr); 109df6: c7 04 24 54 1c 13 00 movl $0x131c54,(%esp) { 109dfd: 89 5d fc mov %ebx,-0x4(%ebp) result = pthread_attr_init (&aio_request_queue.attr); 109e00: e8 cb 24 00 00 call 10c2d0 if (result != 0) 109e05: 85 c0 test %eax,%eax 109e07: 89 c3 mov %eax,%ebx 109e09: 74 15 je 109e20 <== ALWAYS TAKEN } 109e0b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109e0d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e10: 89 ec mov %ebp,%esp <== NOT EXECUTED 109e12: 5d pop %ebp <== NOT EXECUTED 109e13: c3 ret <== NOT EXECUTED 109e14: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109e1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109e1f: 90 nop <== NOT EXECUTED pthread_attr_setdetachstate (&aio_request_queue.attr, 109e20: c7 04 24 54 1c 13 00 movl $0x131c54,(%esp) 109e27: 31 c0 xor %eax,%eax 109e29: 89 44 24 04 mov %eax,0x4(%esp) 109e2d: e8 de 24 00 00 call 10c310 if (result != 0) 109e32: 85 c0 test %eax,%eax 109e34: 0f 85 96 00 00 00 jne 109ed0 <== NEVER TAKEN result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 109e3a: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) 109e41: 31 db xor %ebx,%ebx 109e43: 89 5c 24 04 mov %ebx,0x4(%esp) 109e47: e8 b4 1d 00 00 call 10bc00 if (result != 0) 109e4c: 85 c0 test %eax,%eax 109e4e: 0f 85 bc 00 00 00 jne 109f10 <== NEVER TAKEN result = pthread_cond_init (&aio_request_queue.new_req, NULL); 109e54: c7 04 24 38 1c 13 00 movl $0x131c38,(%esp) 109e5b: 31 c9 xor %ecx,%ecx 109e5d: 89 4c 24 04 mov %ecx,0x4(%esp) 109e61: e8 ea 18 00 00 call 10b750 if (result != 0) { 109e66: 85 c0 test %eax,%eax result = pthread_cond_init (&aio_request_queue.new_req, NULL); 109e68: 89 c3 mov %eax,%ebx if (result != 0) { 109e6a: 0f 85 80 00 00 00 jne 109ef0 <== NEVER TAKEN head->next = tail; 109e70: b8 ac 1c 13 00 mov $0x131cac,%eax head->previous = NULL; 109e75: 31 d2 xor %edx,%edx head->next = tail; 109e77: a3 a8 1c 13 00 mov %eax,0x131ca8 109e7c: b8 b8 1c 13 00 mov $0x131cb8,%eax tail->previous = head; 109e81: b9 a8 1c 13 00 mov $0x131ca8,%ecx head->next = tail; 109e86: a3 b4 1c 13 00 mov %eax,0x131cb4 head->previous = NULL; 109e8b: 31 c0 xor %eax,%eax 109e8d: a3 b8 1c 13 00 mov %eax,0x131cb8 tail->previous = head; 109e92: b8 b4 1c 13 00 mov $0x131cb4,%eax 109e97: a3 bc 1c 13 00 mov %eax,0x131cbc aio_request_queue.active_threads = 0; 109e9c: 31 c0 xor %eax,%eax head->previous = NULL; 109e9e: 89 15 ac 1c 13 00 mov %edx,0x131cac aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 109ea4: ba 0b b0 00 00 mov $0xb00b,%edx aio_request_queue.active_threads = 0; 109ea9: a3 c4 1c 13 00 mov %eax,0x131cc4 aio_request_queue.idle_threads = 0; 109eae: 31 c0 xor %eax,%eax 109eb0: a3 c8 1c 13 00 mov %eax,0x131cc8 } 109eb5: 89 d8 mov %ebx,%eax 109eb7: 8b 5d fc mov -0x4(%ebp),%ebx tail->previous = head; 109eba: 89 0d b0 1c 13 00 mov %ecx,0x131cb0 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 109ec0: 89 15 c0 1c 13 00 mov %edx,0x131cc0 } 109ec6: 89 ec mov %ebp,%esp 109ec8: 5d pop %ebp 109ec9: c3 ret 109eca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi pthread_attr_destroy (&aio_request_queue.attr); 109ed0: c7 04 24 54 1c 13 00 movl $0x131c54,(%esp) <== NOT EXECUTED 109ed7: e8 c4 23 00 00 call 10c2a0 <== NOT EXECUTED 109edc: e9 59 ff ff ff jmp 109e3a <== NOT EXECUTED 109ee1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109ee8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109eef: 90 nop <== NOT EXECUTED pthread_mutex_destroy (&aio_request_queue.mutex); 109ef0: c7 04 24 00 1c 13 00 movl $0x131c00,(%esp) <== NOT EXECUTED 109ef7: e8 94 1c 00 00 call 10bb90 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 109efc: c7 04 24 54 1c 13 00 movl $0x131c54,(%esp) <== NOT EXECUTED 109f03: e8 98 23 00 00 call 10c2a0 <== NOT EXECUTED 109f08: e9 63 ff ff ff jmp 109e70 <== NOT EXECUTED 109f0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 109f10: c7 04 24 54 1c 13 00 movl $0x131c54,(%esp) <== NOT EXECUTED 109f17: e8 84 23 00 00 call 10c2a0 <== NOT EXECUTED 109f1c: e9 33 ff ff ff jmp 109e54 <== NOT EXECUTED 109f21: 90 nop 109f22: 90 nop 109f23: 90 nop 109f24: 90 nop 109f25: 90 nop 109f26: 90 nop 109f27: 90 nop 109f28: 90 nop 109f29: 90 nop 109f2a: 90 nop 109f2b: 90 nop 109f2c: 90 nop 109f2d: 90 nop 109f2e: 90 nop 109f2f: 90 nop =============================================================================== 0010a090 : { 10a090: 55 push %ebp 10a091: 89 e5 mov %esp,%ebp 10a093: 57 push %edi 10a094: 56 push %esi 10a095: 53 push %ebx 10a096: 83 ec 1c sub $0x1c,%esp 10a099: 8b 7d 08 mov 0x8(%ebp),%edi return _Chain_Immutable_head( the_chain )->next; 10a09c: 8b 5f 08 mov 0x8(%edi),%ebx return &the_chain->Tail.Node; 10a09f: 83 c7 0c add $0xc,%edi while (!rtems_chain_is_tail (chain, node)) 10a0a2: 39 fb cmp %edi,%ebx 10a0a4: 74 33 je 10a0d9 <== NEVER TAKEN 10a0a6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a0ad: 8d 76 00 lea 0x0(%esi),%esi return the_node->next; 10a0b0: 89 de mov %ebx,%esi 10a0b2: 8b 1b mov (%ebx),%ebx rtems_chain_extract (&req->next_prio); 10a0b4: 89 34 24 mov %esi,(%esp) 10a0b7: e8 e4 2d 00 00 call 10cea0 req->aiocbp->error_code = ECANCELED; 10a0bc: 8b 46 14 mov 0x14(%esi),%eax 10a0bf: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) req->aiocbp->return_value = -1; 10a0c6: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (req); 10a0cd: 89 34 24 mov %esi,(%esp) 10a0d0: e8 5b 69 ff ff call 100a30 while (!rtems_chain_is_tail (chain, node)) 10a0d5: 39 fb cmp %edi,%ebx 10a0d7: 75 d7 jne 10a0b0 } 10a0d9: 83 c4 1c add $0x1c,%esp 10a0dc: 5b pop %ebx 10a0dd: 5e pop %esi 10a0de: 5f pop %edi 10a0df: 5d pop %ebp 10a0e0: c3 ret 10a0e1: 90 nop 10a0e2: 90 nop 10a0e3: 90 nop 10a0e4: 90 nop 10a0e5: 90 nop 10a0e6: 90 nop 10a0e7: 90 nop 10a0e8: 90 nop 10a0e9: 90 nop 10a0ea: 90 nop 10a0eb: 90 nop 10a0ec: 90 nop 10a0ed: 90 nop 10a0ee: 90 nop 10a0ef: 90 nop =============================================================================== 0010a0f0 : { 10a0f0: 55 push %ebp 10a0f1: 89 e5 mov %esp,%ebp 10a0f3: 83 ec 18 sub $0x18,%esp 10a0f6: 89 5d fc mov %ebx,-0x4(%ebp) 10a0f9: 8b 45 08 mov 0x8(%ebp),%eax 10a0fc: 8b 55 0c mov 0xc(%ebp),%edx return _Chain_Immutable_head( the_chain )->next; 10a0ff: 8b 18 mov (%eax),%ebx return &the_chain->Tail.Node; 10a101: 83 c0 04 add $0x4,%eax if (rtems_chain_is_empty (chain)) 10a104: 39 d8 cmp %ebx,%eax 10a106: 74 58 je 10a160 10a108: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a10f: 90 nop while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10a110: 39 53 14 cmp %edx,0x14(%ebx) 10a113: 74 1b je 10a130 <== ALWAYS TAKEN return the_node->next; 10a115: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10a117: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10a119: 75 f5 jne 10a110 <== NOT EXECUTED } 10a11b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a11e: 89 ec mov %ebp,%esp <== NOT EXECUTED return AIO_NOTCANCELED; 10a120: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } 10a125: 5d pop %ebp <== NOT EXECUTED 10a126: c3 ret <== NOT EXECUTED 10a127: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a12e: 66 90 xchg %ax,%ax <== NOT EXECUTED if (rtems_chain_is_tail (chain, node)) 10a130: 39 d8 cmp %ebx,%eax 10a132: 74 e7 je 10a11b <== NEVER TAKEN rtems_chain_extract (node); 10a134: 89 1c 24 mov %ebx,(%esp) 10a137: e8 64 2d 00 00 call 10cea0 current->aiocbp->error_code = ECANCELED; 10a13c: 8b 43 14 mov 0x14(%ebx),%eax 10a13f: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10a146: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10a14d: 89 1c 24 mov %ebx,(%esp) 10a150: e8 db 68 ff ff call 100a30 } 10a155: 8b 5d fc mov -0x4(%ebp),%ebx 10a158: 89 ec mov %ebp,%esp 10a15a: 5d pop %ebp return AIO_CANCELED; 10a15b: 31 c0 xor %eax,%eax } 10a15d: c3 ret 10a15e: 66 90 xchg %ax,%ax 10a160: 8b 5d fc mov -0x4(%ebp),%ebx 10a163: 89 ec mov %ebp,%esp return AIO_ALLDONE; 10a165: b8 02 00 00 00 mov $0x2,%eax } 10a16a: 5d pop %ebp 10a16b: c3 ret 10a16c: 90 nop 10a16d: 90 nop 10a16e: 90 nop 10a16f: 90 nop =============================================================================== 00109f30 : { 109f30: 55 push %ebp 109f31: 89 e5 mov %esp,%ebp 109f33: 57 push %edi 109f34: 56 push %esi 109f35: 53 push %ebx 109f36: 83 ec 2c sub $0x2c,%esp 109f39: 8b 4d 08 mov 0x8(%ebp),%ecx 109f3c: 8b 75 0c mov 0xc(%ebp),%esi return _Chain_Immutable_head( the_chain )->next; 109f3f: 8b 11 mov (%ecx),%edx while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 109f41: 8b 42 14 mov 0x14(%edx),%eax 109f44: 39 c6 cmp %eax,%esi 109f46: 0f 8e ec 00 00 00 jle 10a038 return &the_chain->Tail.Node; 109f4c: 8d 79 04 lea 0x4(%ecx),%edi 109f4f: 39 fa cmp %edi,%edx 109f51: 0f 84 ee 00 00 00 je 10a045 109f57: 89 d3 mov %edx,%ebx 109f59: eb 09 jmp 109f64 109f5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 109f5f: 90 nop 109f60: 39 fb cmp %edi,%ebx 109f62: 74 2c je 109f90 return the_node->next; 109f64: 8b 1b mov (%ebx),%ebx 109f66: 8b 43 14 mov 0x14(%ebx),%eax 109f69: 39 f0 cmp %esi,%eax 109f6b: 7c f3 jl 109f60 if (r_chain->fildes == fildes) 109f6d: 39 c6 cmp %eax,%esi 109f6f: 75 6f jne 109fe0 r_chain->new_fd = 0; 109f71: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED } 109f78: 83 c4 2c add $0x2c,%esp 109f7b: 89 d8 mov %ebx,%eax 109f7d: 5b pop %ebx 109f7e: 5e pop %esi 109f7f: 5f pop %edi 109f80: 5d pop %ebp 109f81: c3 ret 109f82: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 109f89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if (create == 0) 109f90: 8b 45 10 mov 0x10(%ebp),%eax r_chain = NULL; 109f93: 31 db xor %ebx,%ebx if (create == 0) 109f95: 85 c0 test %eax,%eax 109f97: 74 df je 109f78 r_chain = malloc (sizeof (rtems_aio_request_chain)); 109f99: c7 04 24 70 00 00 00 movl $0x70,(%esp) 109fa0: e8 fb 6d ff ff call 100da0 109fa5: 89 c3 mov %eax,%ebx head->previous = NULL; 109fa7: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) return &the_chain->Tail.Node; 109fae: 8d 40 08 lea 0x8(%eax),%eax return &the_chain->Head.Node; 109fb1: 89 43 10 mov %eax,0x10(%ebx) return &the_chain->Tail.Node; 109fb4: 8d 53 0c lea 0xc(%ebx),%edx rtems_chain_initialize_node (&r_chain->next_fd); 109fb7: 89 d8 mov %ebx,%eax 109fb9: 89 53 08 mov %edx,0x8(%ebx) rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd); 109fbc: 89 44 24 04 mov %eax,0x4(%esp) 109fc0: 8b 47 04 mov 0x4(%edi),%eax 109fc3: 89 04 24 mov %eax,(%esp) 109fc6: e8 f5 2e 00 00 call 10cec0 r_chain->new_fd = 1; 109fcb: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx) } 109fd2: 89 d8 mov %ebx,%eax r_chain->fildes = fildes; 109fd4: 89 73 14 mov %esi,0x14(%ebx) } 109fd7: 83 c4 2c add $0x2c,%esp 109fda: 5b pop %ebx 109fdb: 5e pop %esi 109fdc: 5f pop %edi 109fdd: 5d pop %ebp 109fde: c3 ret 109fdf: 90 nop 109fe0: 89 4d 08 mov %ecx,0x8(%ebp) if (create == 0) 109fe3: 8b 4d 10 mov 0x10(%ebp),%ecx 109fe6: 89 55 e4 mov %edx,-0x1c(%ebp) 109fe9: 85 c9 test %ecx,%ecx 109feb: 74 44 je 10a031 r_chain = malloc (sizeof (rtems_aio_request_chain)); 109fed: c7 04 24 70 00 00 00 movl $0x70,(%esp) 109ff4: e8 a7 6d ff ff call 100da0 return &the_chain->Tail.Node; 109ff9: 8b 4d 08 mov 0x8(%ebp),%ecx 109ffc: 8d 51 04 lea 0x4(%ecx),%edx if (rtems_chain_is_empty (chain)) 109fff: 89 55 e0 mov %edx,-0x20(%ebp) 10a002: 8b 55 e4 mov -0x1c(%ebp),%edx 10a005: 3b 55 e0 cmp -0x20(%ebp),%edx r_chain = malloc (sizeof (rtems_aio_request_chain)); 10a008: 89 c7 mov %eax,%edi head->previous = NULL; 10a00a: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) return &the_chain->Tail.Node; 10a011: 8d 40 08 lea 0x8(%eax),%eax 10a014: 89 47 10 mov %eax,0x10(%edi) 10a017: 8d 47 0c lea 0xc(%edi),%eax 10a01a: 89 47 08 mov %eax,0x8(%edi) rtems_chain_initialize_node (&r_chain->next_fd); 10a01d: 89 f8 mov %edi,%eax if (rtems_chain_is_empty (chain)) 10a01f: 75 5c jne 10a07d rtems_chain_prepend (chain, &r_chain->next_fd); 10a021: 89 44 24 04 mov %eax,0x4(%esp) 10a025: 89 fb mov %edi,%ebx 10a027: 89 0c 24 mov %ecx,(%esp) 10a02a: e8 b1 2e 00 00 call 10cee0 10a02f: eb 9a jmp 109fcb r_chain = NULL; 10a031: 31 db xor %ebx,%ebx 10a033: e9 40 ff ff ff jmp 109f78 while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) { 10a038: 89 d3 mov %edx,%ebx 10a03a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 10a040: e9 28 ff ff ff jmp 109f6d if (create == 0) 10a045: 8b 55 10 mov 0x10(%ebp),%edx r_chain = NULL; 10a048: 31 db xor %ebx,%ebx if (create == 0) 10a04a: 85 d2 test %edx,%edx 10a04c: 0f 84 26 ff ff ff je 109f78 <== NEVER TAKEN r_chain = malloc (sizeof (rtems_aio_request_chain)); 10a052: c7 04 24 70 00 00 00 movl $0x70,(%esp) 10a059: 89 4d 08 mov %ecx,0x8(%ebp) 10a05c: e8 3f 6d ff ff call 100da0 10a061: 8b 4d 08 mov 0x8(%ebp),%ecx 10a064: 89 c7 mov %eax,%edi head->previous = NULL; 10a066: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) return &the_chain->Tail.Node; 10a06d: 8d 40 08 lea 0x8(%eax),%eax return &the_chain->Head.Node; 10a070: 89 47 10 mov %eax,0x10(%edi) return &the_chain->Tail.Node; 10a073: 8d 57 0c lea 0xc(%edi),%edx rtems_chain_initialize_node (&r_chain->next_fd); 10a076: 89 f8 mov %edi,%eax 10a078: 89 57 08 mov %edx,0x8(%edi) return &the_chain->Tail.Node; 10a07b: eb a4 jmp 10a021 10a07d: 89 df mov %ebx,%edi 10a07f: 89 c3 mov %eax,%ebx 10a081: e9 36 ff ff ff jmp 109fbc 10a086: 90 nop 10a087: 90 nop 10a088: 90 nop 10a089: 90 nop 10a08a: 90 nop 10a08b: 90 nop 10a08c: 90 nop 10a08d: 90 nop 10a08e: 90 nop 10a08f: 90 nop =============================================================================== 00104830 : #include int sched_get_priority_max( int policy ) { 104830: 55 push %ebp 104831: 89 e5 mov %esp,%ebp 104833: 83 ec 08 sub $0x8,%esp 104836: 8b 45 08 mov 0x8(%ebp),%eax const Scheduler_Control *scheduler; switch ( policy ) { 104839: 83 f8 02 cmp $0x2,%eax 10483c: 7e 12 jle 104850 10483e: 83 f8 04 cmp $0x4,%eax 104841: 75 11 jne 104854 <== NEVER TAKEN RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum( const Scheduler_Control *scheduler ) { _Assert( (int) scheduler->maximum_priority > 1 ); return (int) scheduler->maximum_priority - 1; 104843: a1 1c 01 12 00 mov 0x12011c,%eax 104848: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); } scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() ); return _POSIX_Priority_Get_maximum( scheduler ); } 104849: 89 ec mov %ebp,%esp 10484b: 5d pop %ebp 10484c: c3 ret 10484d: 8d 76 00 lea 0x0(%esi),%esi switch ( policy ) { 104850: 85 c0 test %eax,%eax 104852: 79 ef jns 104843 rtems_set_errno_and_return_minus_one( EINVAL ); 104854: e8 a7 48 01 00 call 119100 <__errno> 104859: c7 00 16 00 00 00 movl $0x16,(%eax) 10485f: b8 ff ff ff ff mov $0xffffffff,%eax 104864: eb e3 jmp 104849 104866: 90 nop 104867: 90 nop 104868: 90 nop 104869: 90 nop 10486a: 90 nop 10486b: 90 nop 10486c: 90 nop 10486d: 90 nop 10486e: 90 nop 10486f: 90 nop =============================================================================== 00104870 : * 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258 */ int sched_get_priority_min( int policy ) { 104870: 55 push %ebp switch ( policy ) { 104871: ba 01 00 00 00 mov $0x1,%edx { 104876: 89 e5 mov %esp,%ebp 104878: 83 ec 08 sub $0x8,%esp 10487b: 8b 45 08 mov 0x8(%ebp),%eax switch ( policy ) { 10487e: 83 f8 02 cmp $0x2,%eax 104881: 7f 1d jg 1048a0 <== NEVER TAKEN 104883: 85 c0 test %eax,%eax 104885: 79 10 jns 104897 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 104887: e8 74 48 01 00 call 119100 <__errno> 10488c: ba ff ff ff ff mov $0xffffffff,%edx 104891: c7 00 16 00 00 00 movl $0x16,(%eax) } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 104897: 89 ec mov %ebp,%esp 104899: 89 d0 mov %edx,%eax 10489b: 5d pop %ebp 10489c: c3 ret 10489d: 8d 76 00 lea 0x0(%esi),%esi switch ( policy ) { 1048a0: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 1048a3: 75 e2 jne 104887 <== NOT EXECUTED } 1048a5: 89 ec mov %ebp,%esp <== NOT EXECUTED 1048a7: 89 d0 mov %edx,%eax <== NOT EXECUTED 1048a9: 5d pop %ebp <== NOT EXECUTED 1048aa: c3 ret <== NOT EXECUTED 1048ab: 90 nop 1048ac: 90 nop 1048ad: 90 nop 1048ae: 90 nop 1048af: 90 nop =============================================================================== 001048b0 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 1048b0: 55 push %ebp 1048b1: 89 e5 mov %esp,%ebp 1048b3: 83 ec 18 sub $0x18,%esp 1048b6: 89 75 fc mov %esi,-0x4(%ebp) 1048b9: 8b 75 08 mov 0x8(%ebp),%esi 1048bc: 89 5d f8 mov %ebx,-0x8(%ebp) 1048bf: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 1048c2: 85 f6 test %esi,%esi 1048c4: 75 2a jne 1048f0 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 1048c6: 85 db test %ebx,%ebx 1048c8: 74 41 je 10490b rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( 1048ca: 89 5c 24 04 mov %ebx,0x4(%esp) 1048ce: a1 e4 08 12 00 mov 0x1208e4,%eax 1048d3: 89 04 24 mov %eax,(%esp) 1048d6: e8 65 3e 00 00 call 108740 <_Timespec_From_ticks> rtems_configuration_get_ticks_per_timeslice(), interval ); return 0; 1048db: 31 c0 xor %eax,%eax } 1048dd: 8b 5d f8 mov -0x8(%ebp),%ebx 1048e0: 8b 75 fc mov -0x4(%ebp),%esi 1048e3: 89 ec mov %ebp,%esp 1048e5: 5d pop %ebp 1048e6: c3 ret 1048e7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1048ee: 66 90 xchg %ax,%ax if ( pid && pid != getpid() ) 1048f0: e8 fb bf ff ff call 1008f0 1048f5: 39 f0 cmp %esi,%eax 1048f7: 74 cd je 1048c6 rtems_set_errno_and_return_minus_one( ESRCH ); 1048f9: e8 02 48 01 00 call 119100 <__errno> 1048fe: c7 00 03 00 00 00 movl $0x3,(%eax) 104904: b8 ff ff ff ff mov $0xffffffff,%eax 104909: eb d2 jmp 1048dd rtems_set_errno_and_return_minus_one( EINVAL ); 10490b: e8 f0 47 01 00 call 119100 <__errno> 104910: c7 00 16 00 00 00 movl $0x16,(%eax) 104916: b8 ff ff ff ff mov $0xffffffff,%eax 10491b: eb c0 jmp 1048dd 10491d: 90 nop 10491e: 90 nop 10491f: 90 nop =============================================================================== 00109610 : #endif #include int sem_close( sem_t *sem ) { 109610: 55 push %ebp 109611: 89 e5 mov %esp,%ebp 109613: 56 push %esi 109614: 53 push %ebx 109615: 83 ec 10 sub $0x10,%esp 109618: 8b 5d 08 mov 0x8(%ebp),%ebx POSIX_Semaphore_Control *the_semaphore; uint32_t open_count; POSIX_SEMAPHORE_VALIDATE_OBJECT( sem ); 10961b: 85 db test %ebx,%ebx 10961d: 74 71 je 109690 10961f: 89 d8 mov %ebx,%eax 109621: 35 e7 7f 36 5d xor $0x5d367fe7,%eax 109626: 3b 03 cmp (%ebx),%eax 109628: 75 66 jne 109690 if ( !_POSIX_Semaphore_Is_named( sem ) ) { 10962a: 8b 4b 14 mov 0x14(%ebx),%ecx 10962d: 85 c9 test %ecx,%ecx 10962f: 74 5f je 109690 <== NEVER TAKEN _RTEMS_Lock_allocator(); 109631: e8 ba 07 00 00 call 109df0 <_RTEMS_Lock_allocator> the_semaphore = _POSIX_Semaphore_Get( sem ); _Objects_Allocator_lock(); open_count = the_semaphore->open_count; 109636: 8b 43 20 mov 0x20(%ebx),%eax RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get( sem_t *sem ) { return RTEMS_CONTAINER_OF( sem, POSIX_Semaphore_Control, Semaphore ); 109639: 8d 73 f0 lea -0x10(%ebx),%esi if ( open_count == 0 ) { 10963c: 85 c0 test %eax,%eax 10963e: 74 3d je 10967d <== NEVER TAKEN _Objects_Allocator_unlock(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( open_count == 1 && _POSIX_Semaphore_Is_busy( sem ) ) { 109640: 83 f8 01 cmp $0x1,%eax 109643: 75 07 jne 10964c 109645: 8b 53 0c mov 0xc(%ebx),%edx 109648: 85 d2 test %edx,%edx 10964a: 75 1a jne 109666 _Objects_Allocator_unlock(); rtems_set_errno_and_return_minus_one( EBUSY ); } the_semaphore->open_count = open_count - 1; 10964c: 48 dec %eax 10964d: 89 46 30 mov %eax,0x30(%esi) _POSIX_Semaphore_Delete( the_semaphore ); 109650: 89 34 24 mov %esi,(%esp) 109653: e8 f8 69 00 00 call 110050 <_POSIX_Semaphore_Delete> _RTEMS_Unlock_allocator(); 109658: e8 b3 07 00 00 call 109e10 <_RTEMS_Unlock_allocator> _Objects_Allocator_unlock(); return 0; 10965d: 31 c0 xor %eax,%eax } 10965f: 83 c4 10 add $0x10,%esp 109662: 5b pop %ebx 109663: 5e pop %esi 109664: 5d pop %ebp 109665: c3 ret 109666: e8 a5 07 00 00 call 109e10 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_minus_one( EBUSY ); 10966b: e8 d0 51 01 00 call 11e840 <__errno> 109670: c7 00 10 00 00 00 movl $0x10,(%eax) 109676: b8 ff ff ff ff mov $0xffffffff,%eax 10967b: eb e2 jmp 10965f 10967d: e8 8e 07 00 00 call 109e10 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 109682: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109689: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 109690: e8 ab 51 01 00 call 11e840 <__errno> 109695: c7 00 16 00 00 00 movl $0x16,(%eax) 10969b: b8 ff ff ff ff mov $0xffffffff,%eax 1096a0: eb bd jmp 10965f 1096a2: 90 nop 1096a3: 90 nop 1096a4: 90 nop 1096a5: 90 nop 1096a6: 90 nop 1096a7: 90 nop 1096a8: 90 nop 1096a9: 90 nop 1096aa: 90 nop 1096ab: 90 nop 1096ac: 90 nop 1096ad: 90 nop 1096ae: 90 nop 1096af: 90 nop =============================================================================== 00105e60 : { 105e60: 55 push %ebp 105e61: 89 e5 mov %esp,%ebp 105e63: 83 ec 38 sub $0x38,%esp 105e66: 89 5d f4 mov %ebx,-0xc(%ebp) 105e69: 8b 5d 0c mov 0xc(%ebp),%ebx 105e6c: 89 75 f8 mov %esi,-0x8(%ebp) 105e6f: 89 7d fc mov %edi,-0x4(%ebp) if ( oflag & O_CREAT ) { 105e72: f6 c7 02 test $0x2,%bh 105e75: 75 69 jne 105ee0 _RTEMS_Lock_allocator(); 105e77: e8 b4 10 00 00 call 106f30 <_RTEMS_Lock_allocator> const char *name, size_t *name_length_p, Objects_Get_by_name_error *error ) { return (POSIX_Semaphore_Control *) _Objects_Get_by_name( 105e7c: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 105e7f: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 105e83: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 105e86: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 105e8a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 105e8d: c7 04 24 40 97 12 00 movl $0x129740,(%esp) <== NOT EXECUTED 105e94: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 105e98: e8 93 31 00 00 call 109030 <_Objects_Get_by_name> <== NOT EXECUTED if ( the_semaphore == NULL ) { 105e9d: 85 c0 test %eax,%eax 105e9f: 89 c6 mov %eax,%esi 105ea1: 0f 84 19 01 00 00 je 105fc0 if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 105ea7: 81 e3 00 0a 00 00 and $0xa00,%ebx 105ead: 81 fb 00 0a 00 00 cmp $0xa00,%ebx 105eb3: 0f 84 37 01 00 00 je 105ff0 the_semaphore->open_count += 1; 105eb9: ff 46 30 incl 0x30(%esi) return &the_semaphore->Semaphore; 105ebc: 83 c6 10 add $0x10,%esi _RTEMS_Unlock_allocator(); 105ebf: e8 8c 10 00 00 call 106f50 <_RTEMS_Unlock_allocator> } 105ec4: 8b 5d f4 mov -0xc(%ebp),%ebx 105ec7: 89 f0 mov %esi,%eax 105ec9: 8b 7d fc mov -0x4(%ebp),%edi 105ecc: 8b 75 f8 mov -0x8(%ebp),%esi 105ecf: 89 ec mov %ebp,%esp 105ed1: 5d pop %ebp 105ed2: c3 ret 105ed3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105eda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi value = va_arg( arg, unsigned int ); 105ee0: 8b 7d 14 mov 0x14(%ebp),%edi _RTEMS_Lock_allocator(); 105ee3: e8 48 10 00 00 call 106f30 <_RTEMS_Lock_allocator> 105ee8: 8d 45 e4 lea -0x1c(%ebp),%eax 105eeb: 89 44 24 0c mov %eax,0xc(%esp) 105eef: 8d 45 e0 lea -0x20(%ebp),%eax 105ef2: 89 44 24 08 mov %eax,0x8(%esp) 105ef6: 8b 45 08 mov 0x8(%ebp),%eax 105ef9: c7 04 24 40 97 12 00 movl $0x129740,(%esp) 105f00: 89 44 24 04 mov %eax,0x4(%esp) 105f04: e8 27 31 00 00 call 109030 <_Objects_Get_by_name> if ( the_semaphore == NULL ) { 105f09: 85 c0 test %eax,%eax 105f0b: 89 c6 mov %eax,%esi 105f0d: 75 98 jne 105ea7 if ( !( error == OBJECTS_GET_BY_NAME_NO_OBJECT && (oflag & O_CREAT) ) ) { 105f0f: 83 7d e4 02 cmpl $0x2,-0x1c(%ebp) 105f13: 0f 85 a7 00 00 00 jne 105fc0 if ( value > SEM_VALUE_MAX ) { 105f19: 85 ff test %edi,%edi sem = _POSIX_Semaphore_Create_support( 105f1b: 8b 45 e0 mov -0x20(%ebp),%eax if ( value > SEM_VALUE_MAX ) { 105f1e: 0f 88 fc 00 00 00 js 106020 name = _Workspace_String_duplicate( name_arg, name_len ); 105f24: 89 44 24 04 mov %eax,0x4(%esp) 105f28: 8b 45 08 mov 0x8(%ebp),%eax 105f2b: 89 04 24 mov %eax,(%esp) 105f2e: e8 1d 6c 00 00 call 10cb50 <_Workspace_String_duplicate> if ( name == NULL ) { 105f33: 85 c0 test %eax,%eax name = _Workspace_String_duplicate( name_arg, name_len ); 105f35: 89 c3 mov %eax,%ebx if ( name == NULL ) { 105f37: 0f 84 f3 00 00 00 je 106030 <== NEVER TAKEN return ( *information->allocate )( information ); 105f3d: c7 04 24 40 97 12 00 movl $0x129740,(%esp) 105f44: ff 15 48 97 12 00 call *0x129748 if ( the_semaphore == NULL ) { 105f4a: 85 c0 test %eax,%eax 105f4c: 0f 84 ee 00 00 00 je 106040 <== NEVER TAKEN const char *_name, unsigned int _count) { struct _Semaphore_Control _init = _SEMAPHORE_NAMED_INITIALIZER(_name, _count); *_semaphore = _init; 105f52: 89 58 24 mov %ebx,0x24(%eax) _POSIX_Semaphore_Initialize( &the_semaphore->Semaphore, name, value ); 105f55: 8d 70 10 lea 0x10(%eax),%esi the_object->name.name_p = name; 105f58: 89 58 0c mov %ebx,0xc(%eax) sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC; 105f5b: 89 f1 mov %esi,%ecx information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 105f5d: 0f b7 58 08 movzwl 0x8(%eax),%ebx the_semaphore->open_count = 1; 105f61: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) 105f68: 81 f1 e7 7f 36 5d xor $0x5d367fe7,%ecx 105f6e: 89 48 10 mov %ecx,0x10(%eax) 105f71: 8b 0d 44 97 12 00 mov 0x129744,%ecx the_semaphore->linked = true; 105f77: c6 40 2c 01 movb $0x1,0x2c(%eax) 105f7b: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) 105f82: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) 105f89: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) 105f90: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 105f97: 89 78 28 mov %edi,0x28(%eax) 105f9a: 89 44 99 fc mov %eax,-0x4(%ecx,%ebx,4) _RTEMS_Unlock_allocator(); 105f9e: e8 ad 0f 00 00 call 106f50 <_RTEMS_Unlock_allocator> } 105fa3: 8b 5d f4 mov -0xc(%ebp),%ebx 105fa6: 89 f0 mov %esi,%eax 105fa8: 8b 7d fc mov -0x4(%ebp),%edi 105fab: 8b 75 f8 mov -0x8(%ebp),%esi 105fae: 89 ec mov %ebp,%esp 105fb0: 5d pop %ebp 105fb1: c3 ret 105fb2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105fb9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105fc0: e8 8b 0f 00 00 call 106f50 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_value( 105fc5: 8b 5d e4 mov -0x1c(%ebp),%ebx 105fc8: 31 f6 xor %esi,%esi 105fca: e8 f1 67 01 00 call 11c7c0 <__errno> } 105fcf: 8b 7d fc mov -0x4(%ebp),%edi rtems_set_errno_and_return_value( 105fd2: 8b 14 9d 20 42 12 00 mov 0x124220(,%ebx,4),%edx } 105fd9: 8b 5d f4 mov -0xc(%ebp),%ebx rtems_set_errno_and_return_value( 105fdc: 89 10 mov %edx,(%eax) } 105fde: 89 f0 mov %esi,%eax 105fe0: 8b 75 f8 mov -0x8(%ebp),%esi 105fe3: 89 ec mov %ebp,%esp 105fe5: 5d pop %ebp 105fe6: c3 ret 105fe7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105fee: 66 90 xchg %ax,%ax 105ff0: e8 5b 0f 00 00 call 106f50 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_value( EEXIST, SEM_FAILED ); 105ff5: 31 f6 xor %esi,%esi 105ff7: e8 c4 67 01 00 call 11c7c0 <__errno> } 105ffc: 8b 5d f4 mov -0xc(%ebp),%ebx 105fff: 8b 7d fc mov -0x4(%ebp),%edi rtems_set_errno_and_return_value( EEXIST, SEM_FAILED ); 106002: c7 00 11 00 00 00 movl $0x11,(%eax) } 106008: 89 f0 mov %esi,%eax 10600a: 8b 75 f8 mov -0x8(%ebp),%esi 10600d: 89 ec mov %ebp,%esp 10600f: 5d pop %ebp 106010: c3 ret 106011: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 106018: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10601f: 90 nop rtems_set_errno_and_return_value( EINVAL, SEM_FAILED ); 106020: e8 9b 67 01 00 call 11c7c0 <__errno> 106025: c7 00 16 00 00 00 movl $0x16,(%eax) 10602b: e9 6e ff ff ff jmp 105f9e rtems_set_errno_and_return_value( ENOMEM, SEM_FAILED ); 106030: e8 8b 67 01 00 call 11c7c0 <__errno> <== NOT EXECUTED 106035: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10603b: e9 5e ff ff ff jmp 105f9e <== NOT EXECUTED _Workspace_Free( name ); 106040: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 106043: e8 e8 6a 00 00 call 10cb30 <_Workspace_Free> <== NOT EXECUTED rtems_set_errno_and_return_value( ENOSPC, SEM_FAILED ); 106048: e8 73 67 01 00 call 11c7c0 <__errno> <== NOT EXECUTED 10604d: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 106053: e9 46 ff ff ff jmp 105f9e <== NOT EXECUTED 106058: 90 nop 106059: 90 nop 10605a: 90 nop 10605b: 90 nop 10605c: 90 nop 10605d: 90 nop 10605e: 90 nop 10605f: 90 nop =============================================================================== 00105a50 : #include #include int sem_post( sem_t *_sem ) { 105a50: 55 push %ebp 105a51: 89 e5 mov %esp,%ebp 105a53: 83 ec 48 sub $0x48,%esp 105a56: 89 5d fc mov %ebx,-0x4(%ebp) 105a59: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_queue_Context queue_context; Thread_queue_Heads *heads; unsigned int count; POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem ); 105a5c: 85 db test %ebx,%ebx 105a5e: 0f 84 8c 00 00 00 je 105af0 105a64: 89 d8 mov %ebx,%eax 105a66: 35 e7 7f 36 5d xor $0x5d367fe7,%eax 105a6b: 3b 03 cmp (%ebx),%eax 105a6d: 0f 85 7d 00 00 00 jne 105af0 sem = _Sem_Get( &_sem->_Semaphore ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); 105a73: 9c pushf 105a74: fa cli 105a75: 59 pop %ecx _Sem_Queue_acquire_critical( sem, &queue_context ); heads = sem->Queue.Queue.heads; 105a76: 8b 53 0c mov 0xc(%ebx),%edx count = sem->count; 105a79: 8b 43 18 mov 0x18(%ebx),%eax if ( RTEMS_PREDICT_TRUE( heads == NULL && count < SEM_VALUE_MAX ) ) { 105a7c: 85 d2 test %edx,%edx 105a7e: 75 20 jne 105aa0 105a80: 3d fe ff ff 7f cmp $0x7ffffffe,%eax 105a85: 77 49 ja 105ad0 sem->count = count + 1; 105a87: 40 inc %eax 105a88: 89 43 18 mov %eax,0x18(%ebx) { _Thread_queue_Queue_release_critical( &sem->Queue.Queue, &queue_context->Lock_context.Lock_context ); _ISR_Local_enable( level ); 105a8b: 51 push %ecx 105a8c: 9d popf _Sem_Queue_release( sem, level, &queue_context ); return 0; 105a8d: 31 c0 xor %eax,%eax return 0; } _Sem_Queue_release( sem, level, &queue_context ); rtems_set_errno_and_return_minus_one( EOVERFLOW ); } 105a8f: 8b 5d fc mov -0x4(%ebp),%ebx 105a92: 89 ec mov %ebp,%esp 105a94: 5d pop %ebp 105a95: c3 ret 105a96: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105a9d: 8d 76 00 lea 0x0(%esi),%esi ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 105aa0: 89 4d d4 mov %ecx,-0x2c(%ebp) _Thread_queue_Extract_critical( 105aa3: 83 c3 0c add $0xc,%ebx first = ( *operations->first )( heads ); 105aa6: 89 14 24 mov %edx,(%esp) 105aa9: ff 15 ec 3d 12 00 call *0x123dec _Thread_queue_Extract_critical( 105aaf: 8d 55 d4 lea -0x2c(%ebp),%edx 105ab2: 89 54 24 0c mov %edx,0xc(%esp) 105ab6: 89 1c 24 mov %ebx,(%esp) 105ab9: 89 44 24 08 mov %eax,0x8(%esp) 105abd: b8 dc 3d 12 00 mov $0x123ddc,%eax 105ac2: 89 44 24 04 mov %eax,0x4(%esp) 105ac6: e8 e5 33 00 00 call 108eb0 <_Thread_queue_Extract_critical> return 0; 105acb: 31 c0 xor %eax,%eax 105acd: eb c0 jmp 105a8f 105acf: 90 nop if ( RTEMS_PREDICT_TRUE( heads != NULL ) ) { 105ad0: 85 d2 test %edx,%edx 105ad2: 75 cc jne 105aa0 <== NEVER TAKEN 105ad4: 51 push %ecx 105ad5: 9d popf rtems_set_errno_and_return_minus_one( EOVERFLOW ); 105ad6: e8 f5 54 01 00 call 11afd0 <__errno> 105adb: c7 00 8b 00 00 00 movl $0x8b,(%eax) 105ae1: b8 ff ff ff ff mov $0xffffffff,%eax 105ae6: eb a7 jmp 105a8f 105ae8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105aef: 90 nop POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem ); 105af0: e8 db 54 01 00 call 11afd0 <__errno> 105af5: c7 00 16 00 00 00 movl $0x16,(%eax) 105afb: b8 ff ff ff ff mov $0xffffffff,%eax 105b00: eb 8d jmp 105a8f 105b02: 90 nop 105b03: 90 nop 105b04: 90 nop 105b05: 90 nop 105b06: 90 nop 105b07: 90 nop 105b08: 90 nop 105b09: 90 nop 105b0a: 90 nop 105b0b: 90 nop 105b0c: 90 nop 105b0d: 90 nop 105b0e: 90 nop 105b0f: 90 nop =============================================================================== 00106eb0 : int sem_timedwait( sem_t *__restrict _sem, const struct timespec *__restrict abstime ) { 106eb0: 55 push %ebp 106eb1: 89 e5 mov %esp,%ebp 106eb3: 83 ec 48 sub $0x48,%esp 106eb6: 89 5d fc mov %ebx,-0x4(%ebp) 106eb9: 8b 45 08 mov 0x8(%ebp),%eax Thread_queue_Context queue_context; ISR_Level level; Thread_Control *executing; unsigned int count; POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem ); 106ebc: 85 c0 test %eax,%eax 106ebe: 0f 84 8c 00 00 00 je 106f50 106ec4: 89 c2 mov %eax,%edx 106ec6: 81 f2 e7 7f 36 5d xor $0x5d367fe7,%edx 106ecc: 3b 10 cmp (%eax),%edx 106ece: 0f 85 7c 00 00 00 jne 106f50 sem = _Sem_Get( &_sem->_Semaphore ); _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_ISR_disable( &queue_context, level ); 106ed4: 9c pushf 106ed5: fa cli 106ed6: 59 pop %ecx executing = _Sem_Queue_acquire_critical( sem, &queue_context ); count = sem->count; 106ed7: 8b 50 18 mov 0x18(%eax),%edx if ( RTEMS_PREDICT_TRUE( count > 0 ) ) { 106eda: 85 d2 test %edx,%edx 106edc: 74 12 je 106ef0 sem->count = count - 1; 106ede: 4a dec %edx 106edf: 89 50 18 mov %edx,0x18(%eax) { _Thread_queue_Queue_release_critical( &sem->Queue.Queue, &queue_context->Lock_context.Lock_context ); _ISR_Local_enable( level ); 106ee2: 51 push %ecx 106ee3: 9d popf _Sem_Queue_release( sem, level, &queue_context ); return 0; 106ee4: 31 db xor %ebx,%ebx &queue_context ); status = _Thread_Wait_get_status( executing ); return _POSIX_Zero_or_minus_one_plus_errno( status ); } } 106ee6: 89 d8 mov %ebx,%eax 106ee8: 8b 5d fc mov -0x4(%ebp),%ebx 106eeb: 89 ec mov %ebp,%esp 106eed: 5d pop %ebp 106eee: c3 ret 106eef: 90 nop queue_context->Timeout.arg = abstime; 106ef0: 8b 55 0c mov 0xc(%ebp),%edx _Thread_queue_Enqueue( 106ef3: 83 c0 0c add $0xc,%eax 106ef6: 89 04 24 mov %eax,(%esp) 106ef9: 8b 1d d8 d1 12 00 mov 0x12d1d8,%ebx queue_context->thread_state = thread_state; 106eff: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp) queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec; 106f06: c7 45 dc b0 b8 10 00 movl $0x10b8b0,-0x24(%ebp) queue_context->Timeout.arg = abstime; 106f0d: 89 55 e0 mov %edx,-0x20(%ebp) 106f10: 8d 55 d4 lea -0x2c(%ebp),%edx 106f13: 89 54 24 0c mov %edx,0xc(%esp) 106f17: ba 1c 46 12 00 mov $0x12461c,%edx 106f1c: 89 5c 24 08 mov %ebx,0x8(%esp) 106f20: 89 54 24 04 mov %edx,0x4(%esp) 106f24: 89 4d d4 mov %ecx,-0x2c(%ebp) 106f27: e8 74 39 00 00 call 10a8a0 <_Thread_queue_Enqueue> */ RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status( const Thread_Control *the_thread ) { return (Status_Control) the_thread->Wait.return_code; 106f2c: 8b 5b 4c mov 0x4c(%ebx),%ebx if ( status == STATUS_SUCCESSFUL ) { 106f2f: 85 db test %ebx,%ebx 106f31: 74 b3 je 106ee6 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); 106f33: e8 e8 5d 01 00 call 11cd20 <__errno> 106f38: 89 c2 mov %eax,%edx return STATUS_GET_POSIX( status ); 106f3a: 89 d8 mov %ebx,%eax 106f3c: c1 f8 1f sar $0x1f,%eax 106f3f: 0f b6 c0 movzbl %al,%eax 106f42: 01 d8 add %ebx,%eax rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); 106f44: bb ff ff ff ff mov $0xffffffff,%ebx return STATUS_GET_POSIX( status ); 106f49: c1 f8 08 sar $0x8,%eax rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) ); 106f4c: 89 02 mov %eax,(%edx) 106f4e: eb 96 jmp 106ee6 POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem ); 106f50: e8 cb 5d 01 00 call 11cd20 <__errno> 106f55: bb ff ff ff ff mov $0xffffffff,%ebx 106f5a: c7 00 16 00 00 00 movl $0x16,(%eax) 106f60: eb 84 jmp 106ee6 106f62: 90 nop 106f63: 90 nop 106f64: 90 nop 106f65: 90 nop 106f66: 90 nop 106f67: 90 nop 106f68: 90 nop 106f69: 90 nop 106f6a: 90 nop 106f6b: 90 nop 106f6c: 90 nop 106f6d: 90 nop 106f6e: 90 nop 106f6f: 90 nop =============================================================================== 00105920 : { 105920: 55 push %ebp 105921: 89 e5 mov %esp,%ebp 105923: 57 push %edi 105924: 56 push %esi 105925: 53 push %ebx 105926: 83 ec 4c sub $0x4c,%esp 105929: 8b 75 0c mov 0xc(%ebp),%esi if ( ( oflag & O_ACCMODE ) != O_RDONLY && ( oflag & O_ACCMODE ) != O_RDWR ) { 10592c: 89 f7 mov %esi,%edi 10592e: 83 e7 03 and $0x3,%edi 105931: 89 7d c4 mov %edi,-0x3c(%ebp) 105934: 83 ff 02 cmp $0x2,%edi 105937: 0f 95 c0 setne %al 10593a: f7 c6 01 00 00 00 test $0x1,%esi 105940: 0f 85 ba 02 00 00 jne 105c00 <== NEVER TAKEN if ( ( oflag & ~( O_RDONLY | O_RDWR | O_CREAT | O_EXCL | O_TRUNC ) ) != 0 ) { 105946: f7 c6 fd f1 ff ff test $0xfffff1fd,%esi 10594c: 0f 85 ae 02 00 00 jne 105c00 <== NEVER TAKEN if ( ( oflag & O_TRUNC ) != 0 && ( oflag & O_ACCMODE ) != O_RDWR ) { 105952: 89 f7 mov %esi,%edi 105954: 81 e7 00 04 00 00 and $0x400,%edi 10595a: 89 7d c0 mov %edi,-0x40(%ebp) 10595d: 74 08 je 105967 <== ALWAYS TAKEN 10595f: 84 c0 test %al,%al <== NOT EXECUTED 105961: 0f 85 99 02 00 00 jne 105c00 <== NOT EXECUTED iop = rtems_libio_allocate(); 105967: e8 d4 b5 ff ff call 100f40 if ( iop == NULL ) { 10596c: 85 c0 test %eax,%eax iop = rtems_libio_allocate(); 10596e: 89 c3 mov %eax,%ebx if ( iop == NULL ) { 105970: 0f 84 9f 02 00 00 je 105c15 <== NEVER TAKEN _RTEMS_Lock_allocator(); 105976: e8 95 09 00 00 call 106310 <_RTEMS_Lock_allocator> return (POSIX_Shm_Control *) _Objects_Get_by_name( 10597b: 8d 45 d8 lea -0x28(%ebp),%eax 10597e: 89 44 24 0c mov %eax,0xc(%esp) 105982: 8d 45 d4 lea -0x2c(%ebp),%eax 105985: 89 44 24 08 mov %eax,0x8(%esp) 105989: 8b 45 08 mov 0x8(%ebp),%eax 10598c: c7 04 24 40 b1 12 00 movl $0x12b140,(%esp) 105993: 89 44 24 04 mov %eax,0x4(%esp) 105997: e8 54 1f 00 00 call 1078f0 <_Objects_Get_by_name> if ( shm == NULL ) { 10599c: 85 c0 test %eax,%eax 10599e: 89 c2 mov %eax,%edx 1059a0: 0f 84 fa 00 00 00 je 105aa0 <== ALWAYS TAKEN if ( ( oflag & ( O_EXCL | O_CREAT ) ) == ( O_EXCL | O_CREAT ) ) { 1059a6: 81 e6 00 0a 00 00 and $0xa00,%esi <== NOT EXECUTED 1059ac: 81 fe 00 0a 00 00 cmp $0xa00,%esi <== NOT EXECUTED 1059b2: 75 2c jne 1059e0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1059b4: e8 77 09 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED err = EEXIST; 1059b9: be 11 00 00 00 mov $0x11,%esi <== NOT EXECUTED rtems_libio_free( iop ); 1059be: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1059c1: e8 da b5 ff ff call 100fa0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( err ); 1059c6: e8 e5 55 01 00 call 11afb0 <__errno> <== NOT EXECUTED 1059cb: 89 30 mov %esi,(%eax) <== NOT EXECUTED 1059cd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 1059d2: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 1059d5: 5b pop %ebx <== NOT EXECUTED 1059d6: 5e pop %esi <== NOT EXECUTED 1059d7: 5f pop %edi <== NOT EXECUTED 1059d8: 5d pop %ebp <== NOT EXECUTED 1059d9: c3 ret <== NOT EXECUTED 1059da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else if ( !shm_access_ok( shm, oflag ) ) { 1059e0: 0f b7 48 2c movzwl 0x2c(%eax),%ecx <== NOT EXECUTED 1059e4: 89 55 bc mov %edx,-0x44(%ebp) <== NOT EXECUTED 1059e7: 0f b7 70 2e movzwl 0x2e(%eax),%esi <== NOT EXECUTED 1059eb: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED flags = RTEMS_FS_PERMS_WRITE; 1059ee: 83 7d c4 01 cmpl $0x1,-0x3c(%ebp) <== NOT EXECUTED return rtems_filesystem_check_access( flags, shm->mode, shm->uid, shm->gid ); 1059f2: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 1059f6: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED 1059fa: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED flags = RTEMS_FS_PERMS_WRITE; 1059fe: 19 c0 sbb %eax,%eax <== NOT EXECUTED 105a00: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 105a03: 83 c0 02 add $0x2,%eax <== NOT EXECUTED return rtems_filesystem_check_access( flags, shm->mode, shm->uid, shm->gid ); 105a06: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105a09: e8 72 58 00 00 call 10b280 <== NOT EXECUTED } else if ( !shm_access_ok( shm, oflag ) ) { 105a0e: 84 c0 test %al,%al <== NOT EXECUTED 105a10: 0f 84 8a 01 00 00 je 105ba0 <== NOT EXECUTED ++shm->reference_count; 105a16: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED 105a19: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 105a1c: e8 0f 09 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED if ( err != 0 ) { 105a21: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED if ( oflag & O_TRUNC ) { 105a24: 8b 4d c0 mov -0x40(%ebp),%ecx 105a27: 85 c9 test %ecx,%ecx 105a29: 0f 85 a1 01 00 00 jne 105bd0 <== NEVER TAKEN iop->data1 = shm; 105a2f: 89 53 28 mov %edx,0x28(%ebx) rtems_filesystem_location_add_to_mt_entry( &iop->pathinfo ); 105a32: 8d 73 0c lea 0xc(%ebx),%esi fd = rtems_libio_iop_to_descriptor( iop ); 105a35: 89 d8 mov %ebx,%eax iop->pathinfo.node_access = shm; 105a37: 89 53 14 mov %edx,0x14(%ebx) fd = rtems_libio_iop_to_descriptor( iop ); 105a3a: 2d e0 ea 12 00 sub $0x12eae0,%eax iop->pathinfo.handlers = &shm_handlers; 105a3f: c7 43 1c 80 6d 12 00 movl $0x126d80,0x1c(%ebx) fd = rtems_libio_iop_to_descriptor( iop ); 105a46: c1 f8 02 sar $0x2,%eax iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry; 105a49: c7 43 20 60 b3 12 00 movl $0x12b360,0x20(%ebx) fd = rtems_libio_iop_to_descriptor( iop ); 105a50: 69 c0 a3 8b 2e ba imul $0xba2e8ba3,%eax,%eax iop->data0 = fd; 105a56: 89 43 24 mov %eax,0x24(%ebx) rtems_filesystem_mt_entry_lock( lock_context ); 105a59: 9c pushf 105a5a: fa cli 105a5b: 8f 45 c0 pop -0x40(%ebp) &loc->mt_entry->location_chain, 105a5e: 8b 53 20 mov 0x20(%ebx),%edx old_last = tail->previous; 105a61: 8b 4a 1c mov 0x1c(%edx),%ecx return &the_chain->Tail.Node; 105a64: 8d 7a 18 lea 0x18(%edx),%edi 105a67: 89 7b 0c mov %edi,0xc(%ebx) tail->previous = the_node; 105a6a: 89 72 1c mov %esi,0x1c(%edx) old_last->next = the_node; 105a6d: 89 31 mov %esi,(%ecx) the_node->previous = old_last; 105a6f: 89 4b 10 mov %ecx,0x10(%ebx) rtems_filesystem_mt_entry_unlock( lock_context ); 105a72: ff 75 c0 push -0x40(%ebp) 105a75: 9d popf flags |= LIBIO_FLAGS_READ_WRITE; 105a76: 83 7d c4 01 cmpl $0x1,-0x3c(%ebp) 105a7a: 19 d2 sbb %edx,%edx 105a7c: 83 e2 fc and $0xfffffffc,%edx 105a7f: 81 c2 06 09 00 00 add $0x906,%edx _ISR_Local_disable( level ); 105a85: 9c pushf 105a86: fa cli 105a87: 59 pop %ecx *obj = val | arg; 105a88: 09 13 or %edx,(%ebx) _ISR_Local_enable( level ); 105a8a: 51 push %ecx 105a8b: 9d popf } 105a8c: 83 c4 4c add $0x4c,%esp 105a8f: 5b pop %ebx 105a90: 5e pop %esi 105a91: 5f pop %edi 105a92: 5d pop %ebp 105a93: c3 ret 105a94: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105a9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 105a9f: 90 nop switch ( obj_err ) { 105aa0: 8b 45 d8 mov -0x28(%ebp),%eax 105aa3: 85 c0 test %eax,%eax 105aa5: 0f 84 15 01 00 00 je 105bc0 <== NEVER TAKEN 105aab: 48 dec %eax 105aac: 0f 84 fe 00 00 00 je 105bb0 <== NEVER TAKEN if ( name_arg[0] != '/' ) { 105ab2: 8b 45 08 mov 0x8(%ebp),%eax 105ab5: 80 38 2f cmpb $0x2f,(%eax) 105ab8: 0f 85 02 01 00 00 jne 105bc0 <== NEVER TAKEN if ( ( oflag & O_CREAT ) != O_CREAT ) { 105abe: f7 c6 00 02 00 00 test $0x200,%esi 105ac4: 0f 84 26 01 00 00 je 105bf0 <== NEVER TAKEN name = _Workspace_String_duplicate( name_arg, name_len ); 105aca: 8b 45 d4 mov -0x2c(%ebp),%eax 105acd: 89 44 24 04 mov %eax,0x4(%esp) 105ad1: 8b 45 08 mov 0x8(%ebp),%eax 105ad4: 89 04 24 mov %eax,(%esp) 105ad7: e8 c4 45 00 00 call 10a0a0 <_Workspace_String_duplicate> 105adc: 89 45 bc mov %eax,-0x44(%ebp) if ( name == NULL ) { 105adf: 85 c0 test %eax,%eax 105ae1: 0f 84 43 01 00 00 je 105c2a <== NEVER TAKEN return ( *information->allocate )( information ); 105ae7: c7 04 24 40 b1 12 00 movl $0x12b140,(%esp) 105aee: ff 15 48 b1 12 00 call *0x12b148 if ( shm == NULL ) { 105af4: 85 c0 test %eax,%eax 105af6: 0f 84 3d 01 00 00 je 105c39 <== NEVER TAKEN 105afc: 89 45 b8 mov %eax,-0x48(%ebp) gettimeofday( &tv, 0 ); 105aff: 8d 45 dc lea -0x24(%ebp),%eax 105b02: 31 ff xor %edi,%edi 105b04: 89 7c 24 04 mov %edi,0x4(%esp) 105b08: 89 04 24 mov %eax,(%esp) 105b0b: e8 30 52 00 00 call 10ad40 shm->reference_count = 1; 105b10: 8b 55 b8 mov -0x48(%ebp),%edx 105b13: c7 42 1c 01 00 00 00 movl $0x1,0x1c(%edx) shm->shm_object.handle = NULL; 105b1a: c7 42 20 00 00 00 00 movl $0x0,0x20(%edx) shm->shm_object.size = 0; 105b21: c7 42 24 00 00 00 00 movl $0x0,0x24(%edx) shm->shm_object.ops = &_POSIX_Shm_Object_operations; 105b28: c7 42 28 c0 6d 12 00 movl $0x126dc0,0x28(%edx) shm->mode = mode & ~rtems_filesystem_umask; 105b2f: e8 dc ce ff ff call 102a10 105b34: 8b 55 10 mov 0x10(%ebp),%edx 105b37: 8b 40 08 mov 0x8(%eax),%eax 105b3a: f7 d0 not %eax 105b3c: 21 d0 and %edx,%eax 105b3e: 8b 55 b8 mov -0x48(%ebp),%edx shm->oflag = oflag; 105b41: 89 72 34 mov %esi,0x34(%edx) shm->mode = mode & ~rtems_filesystem_umask; 105b44: 89 42 30 mov %eax,0x30(%edx) shm->uid = geteuid(); 105b47: e8 d4 51 00 00 call 10ad20 105b4c: 8b 55 b8 mov -0x48(%ebp),%edx 105b4f: 66 89 42 2c mov %ax,0x2c(%edx) shm->gid = getegid(); 105b53: e8 a8 51 00 00 call 10ad00 105b58: 8b 55 b8 mov -0x48(%ebp),%edx shm->atime = (time_t) tv.tv_sec; 105b5b: 8b 75 dc mov -0x24(%ebp),%esi 105b5e: 8b 7d e0 mov -0x20(%ebp),%edi information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 105b61: 0f b7 4a 08 movzwl 0x8(%edx),%ecx 105b65: 89 72 38 mov %esi,0x38(%edx) shm->gid = getegid(); 105b68: 66 89 42 2e mov %ax,0x2e(%edx) the_object->name.name_p = name; 105b6c: 8b 45 bc mov -0x44(%ebp),%eax shm->atime = (time_t) tv.tv_sec; 105b6f: 89 7a 3c mov %edi,0x3c(%edx) shm->mtime = (time_t) tv.tv_sec; 105b72: 89 72 40 mov %esi,0x40(%edx) 105b75: 89 7a 44 mov %edi,0x44(%edx) 105b78: 89 42 0c mov %eax,0xc(%edx) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 105b7b: a1 44 b1 12 00 mov 0x12b144,%eax shm->ctime = (time_t) tv.tv_sec; 105b80: 89 72 48 mov %esi,0x48(%edx) 105b83: 89 7a 4c mov %edi,0x4c(%edx) 105b86: 89 55 bc mov %edx,-0x44(%ebp) 105b89: 89 54 88 fc mov %edx,-0x4(%eax,%ecx,4) _RTEMS_Unlock_allocator(); 105b8d: e8 9e 07 00 00 call 106330 <_RTEMS_Unlock_allocator> if ( err != 0 ) { 105b92: 8b 55 bc mov -0x44(%ebp),%edx 105b95: e9 8a fe ff ff jmp 105a24 105b9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 105ba0: e8 8b 07 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED err = EACCES; 105ba5: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED 105baa: e9 0f fe ff ff jmp 1059be <== NOT EXECUTED 105baf: 90 nop <== NOT EXECUTED 105bb0: e8 7b 07 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED err = ENAMETOOLONG; 105bb5: be 5b 00 00 00 mov $0x5b,%esi <== NOT EXECUTED 105bba: e9 ff fd ff ff jmp 1059be <== NOT EXECUTED 105bbf: 90 nop <== NOT EXECUTED 105bc0: e8 6b 07 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED *error = EINVAL; 105bc5: be 16 00 00 00 mov $0x16,%esi <== NOT EXECUTED 105bca: e9 ef fd ff ff jmp 1059be <== NOT EXECUTED 105bcf: 90 nop <== NOT EXECUTED 105bd0: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED err = shm_ftruncate( iop, 0 ); 105bd3: 31 c0 xor %eax,%eax <== NOT EXECUTED 105bd5: 31 d2 xor %edx,%edx <== NOT EXECUTED 105bd7: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 105bdb: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 105bdf: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 105be2: e8 b9 fb ff ff call 1057a0 <== NOT EXECUTED 105be7: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 105bea: e9 40 fe ff ff jmp 105a2f <== NOT EXECUTED 105bef: 90 nop <== NOT EXECUTED 105bf0: e8 3b 07 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED *error = ENOENT; 105bf5: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED 105bfa: e9 bf fd ff ff jmp 1059be <== NOT EXECUTED 105bff: 90 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 105c00: e8 ab 53 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105c05: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED return -1; 105c0b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 105c10: e9 bd fd ff ff jmp 1059d2 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EMFILE ); 105c15: e8 96 53 01 00 call 11afb0 <__errno> <== NOT EXECUTED 105c1a: c7 00 18 00 00 00 movl $0x18,(%eax) <== NOT EXECUTED 105c20: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 105c25: e9 a8 fd ff ff jmp 1059d2 <== NOT EXECUTED 105c2a: e8 01 07 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED *error = ENOSPC; 105c2f: be 1c 00 00 00 mov $0x1c,%esi <== NOT EXECUTED 105c34: e9 85 fd ff ff jmp 1059be <== NOT EXECUTED _Workspace_Free( name ); 105c39: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED *error = ENFILE; 105c3c: be 17 00 00 00 mov $0x17,%esi <== NOT EXECUTED _Workspace_Free( name ); 105c41: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105c44: e8 37 44 00 00 call 10a080 <_Workspace_Free> <== NOT EXECUTED 105c49: e8 e2 06 00 00 call 106330 <_RTEMS_Unlock_allocator> <== NOT EXECUTED if ( err != 0 ) { 105c4e: e9 6b fd ff ff jmp 1059be <== NOT EXECUTED 105c53: 90 nop 105c54: 90 nop 105c55: 90 nop 105c56: 90 nop 105c57: 90 nop 105c58: 90 nop 105c59: 90 nop 105c5a: 90 nop 105c5b: 90 nop 105c5c: 90 nop 105c5d: 90 nop 105c5e: 90 nop 105c5f: 90 nop =============================================================================== 001078e0 : #include #include int shm_unlink( const char *name ) { 1078e0: 55 push %ebp 1078e1: 89 e5 mov %esp,%ebp 1078e3: 83 ec 38 sub $0x38,%esp 1078e6: 89 5d fc mov %ebx,-0x4(%ebp) _RTEMS_Lock_allocator(); 1078e9: e8 62 2d 00 00 call 10a650 <_RTEMS_Lock_allocator> 1078ee: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1078f1: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 1078f5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1078f7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1078fb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1078fe: c7 04 24 80 e1 12 00 movl $0x12e180,(%esp) <== NOT EXECUTED 107905: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 107909: e8 92 4b 00 00 call 10c4a0 <_Objects_Get_by_name> <== NOT EXECUTED POSIX_Shm_Control *shm; _Objects_Allocator_lock(); shm = _POSIX_Shm_Get_by_name( name, 0, &obj_err ); if ( shm ) { 10790e: 85 c0 test %eax,%eax 107910: 74 4c je 10795e <== NEVER TAKEN _Objects_Namespace_remove_string( 107912: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 107916: 89 c3 mov %eax,%ebx <== NOT EXECUTED 107918: c7 04 24 80 e1 12 00 movl $0x12e180,(%esp) <== NOT EXECUTED 10791f: e8 5c 4b 00 00 call 10c480 <_Objects_Namespace_remove_string> <== NOT EXECUTED &_POSIX_Shm_Information, &shm->Object ); if ( shm->reference_count == 0 ) { 107924: 8b 43 1c mov 0x1c(%ebx),%eax 107927: 85 c0 test %eax,%eax 107929: 75 25 jne 107950 <== NEVER TAKEN ( *information->deallocate )( information, the_object ); 10792b: 89 5c 24 04 mov %ebx,0x4(%esp) 10792f: c7 04 24 80 e1 12 00 movl $0x12e180,(%esp) 107936: 89 45 e4 mov %eax,-0x1c(%ebp) 107939: ff 15 8c e1 12 00 call *0x12e18c _RTEMS_Unlock_allocator(); 10793f: e8 2c 2d 00 00 call 10a670 <_RTEMS_Unlock_allocator> } } _Objects_Allocator_unlock(); if ( err != 0 ) 107944: 8b 45 e4 mov -0x1c(%ebp),%eax rtems_set_errno_and_return_minus_one( err ); return 0; } 107947: 8b 5d fc mov -0x4(%ebp),%ebx 10794a: 89 ec mov %ebp,%esp 10794c: 5d pop %ebp 10794d: c3 ret 10794e: 66 90 xchg %ax,%ax 107950: e8 1b 2d 00 00 call 10a670 <_RTEMS_Unlock_allocator> <== NOT EXECUTED 107955: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107958: 89 ec mov %ebp,%esp <== NOT EXECUTED 10795a: 5d pop %ebp <== NOT EXECUTED return 0; 10795b: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10795d: c3 ret <== NOT EXECUTED switch ( obj_err ) { 10795e: 83 7d f4 01 cmpl $0x1,-0xc(%ebp) <== NOT EXECUTED 107962: 74 18 je 10797c <== NOT EXECUTED 107964: e8 07 2d 00 00 call 10a670 <_RTEMS_Unlock_allocator> <== NOT EXECUTED err = ENOENT; 107969: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( err ); 10796e: e8 9d 8d 01 00 call 120710 <__errno> <== NOT EXECUTED 107973: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 107975: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10797a: eb cb jmp 107947 <== NOT EXECUTED 10797c: e8 ef 2c 00 00 call 10a670 <_RTEMS_Unlock_allocator> <== NOT EXECUTED err = ENAMETOOLONG; 107981: bb 5b 00 00 00 mov $0x5b,%ebx <== NOT EXECUTED 107986: eb e6 jmp 10796e <== NOT EXECUTED 107988: 90 nop 107989: 90 nop 10798a: 90 nop 10798b: 90 nop 10798c: 90 nop 10798d: 90 nop 10798e: 90 nop 10798f: 90 nop =============================================================================== 0010fad0 : int sigaction( int sig, const struct sigaction *__restrict act, struct sigaction *__restrict oact ) { 10fad0: 55 push %ebp 10fad1: 89 e5 mov %esp,%ebp 10fad3: 83 ec 28 sub $0x28,%esp 10fad6: 89 5d f4 mov %ebx,-0xc(%ebp) 10fad9: 8b 5d 08 mov 0x8(%ebp),%ebx 10fadc: 89 75 f8 mov %esi,-0x8(%ebp) 10fadf: 8b 45 10 mov 0x10(%ebp),%eax 10fae2: 89 7d fc mov %edi,-0x4(%ebp) 10fae5: 8b 75 0c mov 0xc(%ebp),%esi Thread_queue_Context queue_context; if ( !sig ) 10fae8: 85 db test %ebx,%ebx 10faea: 0f 84 b0 00 00 00 je 10fba0 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10faf0: 8d 53 ff lea -0x1(%ebx),%edx rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10faf3: 83 fa 1f cmp $0x1f,%edx 10faf6: 0f 87 a4 00 00 00 ja 10fba0 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10fafc: 83 fb 09 cmp $0x9,%ebx 10faff: 0f 84 9b 00 00 00 je 10fba0 _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 10fb05: 9c pushf 10fb06: fa cli 10fb07: 5f pop %edi rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_queue_Context_initialize( &queue_context ); _POSIX_signals_Acquire( &queue_context ); if ( oact ) 10fb08: 85 c0 test %eax,%eax 10fb0a: 74 20 je 10fb2c *oact = _POSIX_signals_Vectors[ sig ]; 10fb0c: 8d 14 5b lea (%ebx,%ebx,2),%edx 10fb0f: c1 e2 02 shl $0x2,%edx 10fb12: 8d 8a c0 d4 12 00 lea 0x12d4c0(%edx),%ecx 10fb18: 8b 92 c0 d4 12 00 mov 0x12d4c0(%edx),%edx 10fb1e: 89 10 mov %edx,(%eax) 10fb20: 8b 51 04 mov 0x4(%ecx),%edx 10fb23: 89 50 04 mov %edx,0x4(%eax) 10fb26: 8b 51 08 mov 0x8(%ecx),%edx 10fb29: 89 50 08 mov %edx,0x8(%eax) /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10fb2c: 85 f6 test %esi,%esi 10fb2e: 74 2f je 10fb5f <== NEVER TAKEN /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ if ( act->sa_handler == SIG_DFL ) { 10fb30: 8b 46 08 mov 0x8(%esi),%eax 10fb33: 85 c0 test %eax,%eax 10fb35: 74 39 je 10fb70 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( sig ); 10fb37: 89 1c 24 mov %ebx,(%esp) 10fb3a: e8 81 0d 00 00 call 1108c0 <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10fb3f: 8b 0e mov (%esi),%ecx 10fb41: 8d 04 5b lea (%ebx,%ebx,2),%eax 10fb44: c1 e0 02 shl $0x2,%eax 10fb47: 8d 90 c0 d4 12 00 lea 0x12d4c0(%eax),%edx 10fb4d: 89 88 c0 d4 12 00 mov %ecx,0x12d4c0(%eax) 10fb53: 8b 46 04 mov 0x4(%esi),%eax 10fb56: 89 42 04 mov %eax,0x4(%edx) 10fb59: 8b 46 08 mov 0x8(%esi),%eax 10fb5c: 89 42 08 mov %eax,0x8(%edx) Thread_queue_Context *queue_context ) { (void) the_thread_queue; _Assert( _Thread_queue_Is_lock_owner( the_thread_queue ) ); _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 10fb5f: 57 push %edi 10fb60: 9d popf } } _POSIX_signals_Release( &queue_context ); return 0; 10fb61: 31 c0 xor %eax,%eax } 10fb63: 8b 5d f4 mov -0xc(%ebp),%ebx 10fb66: 8b 75 f8 mov -0x8(%ebp),%esi 10fb69: 8b 7d fc mov -0x4(%ebp),%edi 10fb6c: 89 ec mov %ebp,%esp 10fb6e: 5d pop %ebp 10fb6f: c3 ret _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10fb70: 8d 04 5b lea (%ebx,%ebx,2),%eax 10fb73: c1 e0 02 shl $0x2,%eax 10fb76: 8b 98 e0 48 12 00 mov 0x1248e0(%eax),%ebx 10fb7c: 8d 90 c0 d4 12 00 lea 0x12d4c0(%eax),%edx 10fb82: 8d 88 e0 48 12 00 lea 0x1248e0(%eax),%ecx 10fb88: 89 98 c0 d4 12 00 mov %ebx,0x12d4c0(%eax) 10fb8e: 8b 80 e4 48 12 00 mov 0x1248e4(%eax),%eax 10fb94: 89 42 04 mov %eax,0x4(%edx) 10fb97: 8b 41 08 mov 0x8(%ecx),%eax 10fb9a: 89 42 08 mov %eax,0x8(%edx) 10fb9d: eb c0 jmp 10fb5f 10fb9f: 90 nop rtems_set_errno_and_return_minus_one( EINVAL ); 10fba0: e8 9b c5 00 00 call 11c140 <__errno> 10fba5: c7 00 16 00 00 00 movl $0x16,(%eax) 10fbab: b8 ff ff ff ff mov $0xffffffff,%eax 10fbb0: eb b1 jmp 10fb63 10fbb2: 90 nop 10fbb3: 90 nop 10fbb4: 90 nop 10fbb5: 90 nop 10fbb6: 90 nop 10fbb7: 90 nop 10fbb8: 90 nop 10fbb9: 90 nop 10fbba: 90 nop 10fbbb: 90 nop 10fbbc: 90 nop 10fbbd: 90 nop 10fbbe: 90 nop 10fbbf: 90 nop =============================================================================== 0010a810 : int sigtimedwait( const sigset_t *__restrict set, siginfo_t *__restrict info, const struct timespec *__restrict timeout ) { 10a810: 55 push %ebp 10a811: 89 e5 mov %esp,%ebp 10a813: 57 push %edi 10a814: 56 push %esi 10a815: 53 push %ebx 10a816: 83 ec 7c sub $0x7c,%esp int error; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10a819: 8b 45 08 mov 0x8(%ebp),%eax { 10a81c: 8b 75 0c mov 0xc(%ebp),%esi 10a81f: 8b 7d 10 mov 0x10(%ebp),%edi if ( !set ) 10a822: 85 c0 test %eax,%eax 10a824: 0f 84 c7 02 00 00 je 10aaf1 <== NEVER TAKEN /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ if ( timeout != NULL ) { 10a82a: 85 ff test %edi,%edi 10a82c: 0f 84 3e 01 00 00 je 10a970 const struct timespec *end; _Timecounter_Nanouptime( &uptime ); 10a832: 8d 5d b8 lea -0x48(%ebp),%ebx 10a835: 89 1c 24 mov %ebx,(%esp) 10a838: e8 a3 b7 ff ff call 105fe0 <_Timecounter_Nanouptime> && (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND; 10a83d: 8b 4f 08 mov 0x8(%edi),%ecx 10a840: 81 f9 ff c9 9a 3b cmp $0x3b9ac9ff,%ecx 10a846: 0f 86 e4 00 00 00 jbe 10a930 return NULL; 10a84c: 31 db xor %ebx,%ebx queue_context->Timeout.arg = abstime; 10a84e: 89 5d d0 mov %ebx,-0x30(%ebp) /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10a851: 85 f6 test %esi,%esi queue_context->enqueue_callout = 10a853: c7 45 cc f0 87 10 00 movl $0x1087f0,-0x34(%ebp) 10a85a: 0f 84 1f 01 00 00 je 10a97f <== NEVER TAKEN 10a860: 8b 1d 98 03 13 00 mov 0x130398,%ebx executing = _Thread_Get_executing(); api = executing->API_Extensions[ THREAD_API_POSIX ]; 10a866: 8b bb 0c 01 00 00 mov 0x10c(%ebx),%edi 10a86c: 89 7d a4 mov %edi,-0x5c(%ebp) _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 10a86f: 9c pushf 10a870: fa cli 10a871: 58 pop %eax 10a872: 89 45 c4 mov %eax,-0x3c(%ebp) */ /* API signals pending? */ _POSIX_signals_Acquire( &queue_context ); if ( *set & api->signals_pending ) { 10a875: 8b 45 08 mov 0x8(%ebp),%eax 10a878: 8b 10 mov (%eax),%edx 10a87a: 8b 47 58 mov 0x58(%edi),%eax 10a87d: 85 c2 test %eax,%edx 10a87f: 0f 85 cb 01 00 00 jne 10aa50 return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10a885: a1 80 07 13 00 mov 0x130780,%eax 10a88a: 85 c2 test %eax,%edx 10a88c: 0f 85 fe 00 00 00 jne 10a990 the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 10a892: c7 06 ff ff ff ff movl $0xffffffff,(%esi) executing->Wait.return_argument = the_info; _Thread_queue_Context_set_thread_state( &queue_context, STATES_WAITING_FOR_SIGNAL | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_queue_Enqueue( 10a898: 8d 45 c4 lea -0x3c(%ebp),%eax executing->Wait.option = *set; 10a89b: 89 53 48 mov %edx,0x48(%ebx) executing->Wait.return_argument = the_info; 10a89e: 89 73 40 mov %esi,0x40(%ebx) _Thread_queue_Enqueue( 10a8a1: 89 44 24 0c mov %eax,0xc(%esp) 10a8a5: b8 50 78 12 00 mov $0x127850,%eax 10a8aa: 89 44 24 04 mov %eax,0x4(%esp) 10a8ae: 89 5c 24 08 mov %ebx,0x8(%esp) 10a8b2: c7 04 24 54 c4 12 00 movl $0x12c454,(%esp) queue_context->thread_state = thread_state; 10a8b9: c7 45 c8 00 04 00 10 movl $0x10000400,-0x38(%ebp) 10a8c0: e8 ab d0 ff ff call 107970 <_Thread_queue_Enqueue> /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( 10a8c5: b8 01 00 00 00 mov $0x1,%eax 10a8ca: 89 44 24 14 mov %eax,0x14(%esp) 10a8ce: 31 c0 xor %eax,%eax 10a8d0: 89 44 24 10 mov %eax,0x10(%esp) 10a8d4: 31 c0 xor %eax,%eax 10a8d6: 89 44 24 0c mov %eax,0xc(%esp) 10a8da: 89 74 24 08 mov %esi,0x8(%esp) 10a8de: 8b 06 mov (%esi),%eax 10a8e0: 89 44 24 04 mov %eax,0x4(%esp) 10a8e4: 8b 45 a4 mov -0x5c(%ebp),%eax 10a8e7: 89 04 24 mov %eax,(%esp) 10a8ea: e8 21 2b 00 00 call 10d410 <_POSIX_signals_Clear_signals> return _POSIX_Get_by_name_error_table[ error ]; } RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status ) { return STATUS_GET_POSIX( status ); 10a8ef: 8b 53 4c mov 0x4c(%ebx),%edx 10a8f2: 89 d0 mov %edx,%eax 10a8f4: c1 f8 1f sar $0x1f,%eax 10a8f7: 0f b6 f8 movzbl %al,%edi 10a8fa: 01 d7 add %edx,%edi 10a8fc: c1 ff 08 sar $0x8,%edi * was not in our set. */ error = _POSIX_Get_error_after_wait( executing ); if ( 10a8ff: 83 ff 04 cmp $0x4,%edi 10a902: 0f 85 ce 01 00 00 jne 10aad6 error != EINTR || ( *set & signo_to_mask( the_info->si_signo ) ) == 0 10a908: 8b 1e mov (%esi),%ebx return 1u << (sig - 1); 10a90a: b8 01 00 00 00 mov $0x1,%eax 10a90f: 8b 75 08 mov 0x8(%ebp),%esi 10a912: 8d 4b ff lea -0x1(%ebx),%ecx 10a915: d3 e0 shl %cl,%eax 10a917: 23 06 and (%esi),%eax 10a919: 0f 84 c1 01 00 00 je 10aae0 rtems_set_errno_and_return_minus_one( error ); } return the_info->si_signo; } 10a91f: 83 c4 7c add $0x7c,%esp 10a922: 89 d8 mov %ebx,%eax 10a924: 5b pop %ebx 10a925: 5e pop %esi 10a926: 5f pop %edi 10a927: 5d pop %ebp 10a928: c3 ret 10a929: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return _Watchdog_Is_valid_timespec( ts ) && ts->tv_sec >= 0; 10a930: 8b 57 04 mov 0x4(%edi),%edx 10a933: 8b 07 mov (%edi),%eax 10a935: 85 d2 test %edx,%edx 10a937: 0f 88 0f ff ff ff js 10a84c <== NEVER TAKEN now->tv_nsec += delta->tv_nsec; 10a93d: 8b 7d c0 mov -0x40(%ebp),%edi sec += (uint64_t) delta->tv_sec; 10a940: 03 45 b8 add -0x48(%ebp),%eax 10a943: 13 55 bc adc -0x44(%ebp),%edx now->tv_nsec += delta->tv_nsec; 10a946: 01 f9 add %edi,%ecx if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) { 10a948: 81 f9 ff c9 9a 3b cmp $0x3b9ac9ff,%ecx 10a94e: 0f 8f cc 00 00 00 jg 10aa20 <== NEVER TAKEN now->tv_nsec += delta->tv_nsec; 10a954: 89 4d c0 mov %ecx,-0x40(%ebp) if ( sec <= INT64_MAX ) { 10a957: 85 d2 test %edx,%edx 10a959: 0f 88 d8 00 00 00 js 10aa37 <== NEVER TAKEN now->tv_sec = sec; 10a95f: 89 45 b8 mov %eax,-0x48(%ebp) 10a962: 89 55 bc mov %edx,-0x44(%ebp) 10a965: e9 e4 fe ff ff jmp 10a84e 10a96a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 10a970: c7 45 cc 40 79 10 00 movl $0x107940,-0x34(%ebp) the_info = ( info ) ? info : &signal_information; 10a977: 85 f6 test %esi,%esi 10a979: 0f 85 e1 fe ff ff jne 10a860 10a97f: 8d 75 ac lea -0x54(%ebp),%esi 10a982: e9 d9 fe ff ff jmp 10a860 10a987: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a98e: 66 90 xchg %ax,%ax for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10a990: bb 1b 00 00 00 mov $0x1b,%ebx 10a995: ba 01 00 00 00 mov $0x1,%edx 10a99a: 8d 4b ff lea -0x1(%ebx),%ecx 10a99d: 89 d7 mov %edx,%edi 10a99f: d3 e7 shl %cl,%edi if ( set & signo_to_mask( signo ) ) { 10a9a1: 85 c7 test %eax,%edi 10a9a3: 75 2c jne 10a9d1 <== NEVER TAKEN for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10a9a5: 43 inc %ebx 10a9a6: 83 fb 20 cmp $0x20,%ebx 10a9a9: 75 ef jne 10a99a for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10a9ab: bb 01 00 00 00 mov $0x1,%ebx 10a9b0: ba 01 00 00 00 mov $0x1,%edx 10a9b5: eb 0f jmp 10a9c6 10a9b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a9be: 66 90 xchg %ax,%ax 10a9c0: 43 inc %ebx 10a9c1: 83 fb 1b cmp $0x1b,%ebx 10a9c4: 74 0b je 10a9d1 <== NEVER TAKEN 10a9c6: 8d 4b ff lea -0x1(%ebx),%ecx 10a9c9: 89 d7 mov %edx,%edi 10a9cb: d3 e7 shl %cl,%edi if ( set & signo_to_mask( signo ) ) { 10a9cd: 85 c7 test %eax,%edi 10a9cf: 74 ef je 10a9c0 _POSIX_signals_Clear_signals( api, signo, the_info, true, false, false ); 10a9d1: 31 c0 xor %eax,%eax 10a9d3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a9d5: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED 10a9d9: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10a9dc: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10a9e1: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED 10a9e5: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED 10a9e9: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED 10a9ed: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 10a9f1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a9f4: e8 17 2a 00 00 call 10d410 <_POSIX_signals_Clear_signals> <== NOT EXECUTED _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 10a9f9: ff 75 c4 push -0x3c(%ebp) 10a9fc: 9d popf the_info->si_signo = signo; 10a9fd: 89 1e mov %ebx,(%esi) <== NOT EXECUTED } 10a9ff: 89 d8 mov %ebx,%eax <== NOT EXECUTED the_info->si_code = SI_USER; 10aa01: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 10aa08: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED } 10aa0f: 83 c4 7c add $0x7c,%esp <== NOT EXECUTED 10aa12: 5b pop %ebx <== NOT EXECUTED 10aa13: 5e pop %esi <== NOT EXECUTED 10aa14: 5f pop %edi <== NOT EXECUTED 10aa15: 5d pop %ebp <== NOT EXECUTED 10aa16: c3 ret <== NOT EXECUTED 10aa17: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10aa1e: 66 90 xchg %ax,%ax <== NOT EXECUTED now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND; 10aa20: 81 e9 00 ca 9a 3b sub $0x3b9aca00,%ecx <== NOT EXECUTED ++sec; 10aa26: 83 c0 01 add $0x1,%eax <== NOT EXECUTED now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND; 10aa29: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED ++sec; 10aa2c: 83 d2 00 adc $0x0,%edx <== NOT EXECUTED if ( sec <= INT64_MAX ) { 10aa2f: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa31: 0f 89 28 ff ff ff jns 10a95f <== NOT EXECUTED now->tv_sec = INT64_MAX; 10aa37: c7 45 b8 ff ff ff ff movl $0xffffffff,-0x48(%ebp) <== NOT EXECUTED 10aa3e: c7 45 bc ff ff ff 7f movl $0x7fffffff,-0x44(%ebp) <== NOT EXECUTED 10aa45: e9 04 fe ff ff jmp 10a84e <== NOT EXECUTED 10aa4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10aa50: ba 1b 00 00 00 mov $0x1b,%edx 10aa55: bb 01 00 00 00 mov $0x1,%ebx 10aa5a: 8d 4a ff lea -0x1(%edx),%ecx 10aa5d: 89 df mov %ebx,%edi 10aa5f: d3 e7 shl %cl,%edi if ( set & signo_to_mask( signo ) ) { 10aa61: 85 c7 test %eax,%edi 10aa63: 75 2c jne 10aa91 <== NEVER TAKEN for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10aa65: 42 inc %edx 10aa66: 83 fa 20 cmp $0x20,%edx 10aa69: 75 ef jne 10aa5a for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10aa6b: ba 01 00 00 00 mov $0x1,%edx 10aa70: bb 01 00 00 00 mov $0x1,%ebx 10aa75: eb 0f jmp 10aa86 10aa77: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10aa7e: 66 90 xchg %ax,%ax 10aa80: 42 inc %edx 10aa81: 83 fa 1b cmp $0x1b,%edx 10aa84: 74 0b je 10aa91 <== NEVER TAKEN 10aa86: 8d 4a ff lea -0x1(%edx),%ecx 10aa89: 89 df mov %ebx,%edi 10aa8b: d3 e7 shl %cl,%edi if ( set & signo_to_mask( signo ) ) { 10aa8d: 85 c7 test %eax,%edi 10aa8f: 74 ef je 10aa80 the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10aa91: 89 16 mov %edx,(%esi) _POSIX_signals_Clear_signals( 10aa93: 31 c0 xor %eax,%eax 10aa95: 31 db xor %ebx,%ebx 10aa97: 89 44 24 0c mov %eax,0xc(%esp) 10aa9b: 8b 45 a4 mov -0x5c(%ebp),%eax 10aa9e: 31 ff xor %edi,%edi 10aaa0: 89 5c 24 14 mov %ebx,0x14(%esp) 10aaa4: 89 7c 24 10 mov %edi,0x10(%esp) 10aaa8: 89 74 24 08 mov %esi,0x8(%esp) 10aaac: 89 54 24 04 mov %edx,0x4(%esp) 10aab0: 89 04 24 mov %eax,(%esp) 10aab3: e8 58 29 00 00 call 10d410 <_POSIX_signals_Clear_signals> 10aab8: ff 75 c4 push -0x3c(%ebp) 10aabb: 9d popf the_info->si_code = SI_USER; 10aabc: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) return the_info->si_signo; 10aac3: 8b 1e mov (%esi),%ebx the_info->si_value.sival_int = 0; 10aac5: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) } 10aacc: 83 c4 7c add $0x7c,%esp 10aacf: 89 d8 mov %ebx,%eax 10aad1: 5b pop %ebx 10aad2: 5e pop %esi 10aad3: 5f pop %edi 10aad4: 5d pop %ebp 10aad5: c3 ret if ( error == ETIMEDOUT ) { 10aad6: 83 ff 74 cmp $0x74,%edi 10aad9: 75 05 jne 10aae0 error = EAGAIN; 10aadb: bf 0b 00 00 00 mov $0xb,%edi rtems_set_errno_and_return_minus_one( error ); 10aae0: e8 4b fd 00 00 call 11a830 <__errno> 10aae5: bb ff ff ff ff mov $0xffffffff,%ebx 10aaea: 89 38 mov %edi,(%eax) 10aaec: e9 2e fe ff ff jmp 10a91f rtems_set_errno_and_return_minus_one( EINVAL ); 10aaf1: e8 3a fd 00 00 call 11a830 <__errno> 10aaf6: bb ff ff ff ff mov $0xffffffff,%ebx 10aafb: c7 00 16 00 00 00 movl $0x16,(%eax) 10ab01: e9 19 fe ff ff jmp 10a91f 10ab06: 90 nop 10ab07: 90 nop 10ab08: 90 nop 10ab09: 90 nop 10ab0a: 90 nop 10ab0b: 90 nop 10ab0c: 90 nop 10ab0d: 90 nop 10ab0e: 90 nop 10ab0f: 90 nop =============================================================================== 0010c0b0 : int sigwait( const sigset_t *__restrict set, int *__restrict sig ) { 10c0b0: 55 push %ebp int status; status = sigtimedwait( set, NULL, NULL ); 10c0b1: 31 c0 xor %eax,%eax { 10c0b3: 89 e5 mov %esp,%ebp 10c0b5: 83 ec 18 sub $0x18,%esp status = sigtimedwait( set, NULL, NULL ); 10c0b8: 89 44 24 08 mov %eax,0x8(%esp) 10c0bc: 8b 45 08 mov 0x8(%ebp),%eax 10c0bf: 31 d2 xor %edx,%edx 10c0c1: 89 54 24 04 mov %edx,0x4(%esp) { 10c0c5: 89 5d fc mov %ebx,-0x4(%ebp) 10c0c8: 8b 5d 0c mov 0xc(%ebp),%ebx status = sigtimedwait( set, NULL, NULL ); 10c0cb: 89 04 24 mov %eax,(%esp) 10c0ce: e8 dd fc ff ff call 10bdb0 if ( status != -1 ) { 10c0d3: 83 f8 ff cmp $0xffffffff,%eax 10c0d6: 74 28 je 10c100 if ( sig ) 10c0d8: 85 db test %ebx,%ebx 10c0da: 74 14 je 10c0f0 <== NEVER TAKEN *sig = status; 10c0dc: 89 03 mov %eax,(%ebx) return 0; } return errno; } 10c0de: 8b 5d fc mov -0x4(%ebp),%ebx 10c0e1: 89 ec mov %ebp,%esp 10c0e3: 5d pop %ebp return 0; 10c0e4: 31 c0 xor %eax,%eax } 10c0e6: c3 ret 10c0e7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10c0ee: 66 90 xchg %ax,%ax 10c0f0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c0f3: 89 ec mov %ebp,%esp <== NOT EXECUTED return 0; 10c0f5: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10c0f7: 5d pop %ebp <== NOT EXECUTED 10c0f8: c3 ret <== NOT EXECUTED 10c0f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED return errno; 10c100: e8 2b fd 00 00 call 11be30 <__errno> } 10c105: 8b 5d fc mov -0x4(%ebp),%ebx return errno; 10c108: 8b 00 mov (%eax),%eax } 10c10a: 89 ec mov %ebp,%esp 10c10c: 5d pop %ebp 10c10d: c3 ret 10c10e: 90 nop 10c10f: 90 nop =============================================================================== 00103ce0 : */ long sysconf( int name ) { 103ce0: 55 push %ebp 103ce1: 89 e5 mov %esp,%ebp 103ce3: 83 ec 08 sub $0x8,%esp 103ce6: 8b 45 08 mov 0x8(%ebp),%eax switch ( name ) { 103ce9: 83 f8 0a cmp $0xa,%eax 103cec: 7f 22 jg 103d10 103cee: 83 f8 08 cmp $0x8,%eax 103cf1: 7f 5d jg 103d50 103cf3: 83 f8 04 cmp $0x4,%eax 103cf6: 74 68 je 103d60 103cf8: 83 f8 08 cmp $0x8,%eax 103cfb: 75 28 jne 103d25 103cfd: b8 00 10 00 00 mov $0x1000,%eax return 0; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); } } 103d02: 89 ec mov %ebp,%esp 103d04: 5d pop %ebp 103d05: c3 ret 103d06: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 103d0d: 8d 76 00 lea 0x0(%esi),%esi switch ( name ) { 103d10: 83 f8 4f cmp $0x4f,%eax 103d13: 74 2b je 103d40 <== NEVER TAKEN 103d15: 3d 8c 00 00 00 cmp $0x8c,%eax 103d1a: 75 15 jne 103d31 <== ALWAYS TAKEN } 103d1c: 89 ec mov %ebp,%esp <== NOT EXECUTED return (long) _POSIX_26_VERSION; 103d1e: b8 78 0e 03 00 mov $0x30e78,%eax <== NOT EXECUTED } 103d23: 5d pop %ebp <== NOT EXECUTED 103d24: c3 ret <== NOT EXECUTED switch ( name ) { 103d25: 83 f8 02 cmp $0x2,%eax 103d28: 75 3d jne 103d67 return (long) rtems_clock_get_ticks_per_second(); 103d2a: a1 ac ff 11 00 mov 0x11ffac,%eax 103d2f: eb d1 jmp 103d02 switch ( name ) { 103d31: 83 f8 33 cmp $0x33,%eax 103d34: 75 31 jne 103d67 return 1024; 103d36: b8 00 04 00 00 mov $0x400,%eax rtems_set_errno_and_return_minus_one( EINVAL ); 103d3b: eb c5 jmp 103d02 103d3d: 8d 76 00 lea 0x0(%esi),%esi return RTEMS_FILESYSTEM_SYMLOOP_MAX; 103d40: b8 20 00 00 00 mov $0x20,%eax <== NOT EXECUTED 103d45: eb bb jmp 103d02 <== NOT EXECUTED 103d47: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 103d4e: 66 90 xchg %ax,%ax <== NOT EXECUTED return (long) rtems_configuration_get_maximum_processors(); 103d50: b8 01 00 00 00 mov $0x1,%eax 103d55: eb ab jmp 103d02 103d57: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 103d5e: 66 90 xchg %ax,%ax return rtems_libio_number_iops; 103d60: a1 68 fe 11 00 mov 0x11fe68,%eax 103d65: eb 9b jmp 103d02 rtems_set_errno_and_return_minus_one( EINVAL ); 103d67: e8 14 4f 01 00 call 118c80 <__errno> 103d6c: c7 00 16 00 00 00 movl $0x16,(%eax) 103d72: b8 ff ff ff ff mov $0xffffffff,%eax 103d77: eb 89 jmp 103d02 103d79: 90 nop 103d7a: 90 nop 103d7b: 90 nop 103d7c: 90 nop 103d7d: 90 nop 103d7e: 90 nop 103d7f: 90 nop =============================================================================== 0010d380 : { 10d380: 55 push %ebp 10d381: 89 e5 mov %esp,%ebp 10d383: 56 push %esi 10d384: 53 push %ebx 10d385: 83 ec 10 sub $0x10,%esp if ( clock_id != CLOCK_REALTIME ) 10d388: 83 7d 08 01 cmpl $0x1,0x8(%ebp) { 10d38c: 8b 5d 0c mov 0xc(%ebp),%ebx 10d38f: 8b 75 10 mov 0x10(%ebp),%esi if ( clock_id != CLOCK_REALTIME ) 10d392: 0f 85 28 01 00 00 jne 10d4c0 if ( !timerid ) 10d398: 85 f6 test %esi,%esi 10d39a: 0f 84 20 01 00 00 je 10d4c0 if (evp != NULL) { 10d3a0: 85 db test %ebx,%ebx 10d3a2: 0f 84 c8 00 00 00 je 10d470 if ( ( evp->sigev_notify != SIGEV_NONE ) && 10d3a8: 8b 03 mov (%ebx),%eax 10d3aa: 48 dec %eax 10d3ab: 83 f8 01 cmp $0x1,%eax 10d3ae: 0f 87 0c 01 00 00 ja 10d4c0 <== NEVER TAKEN if ( !evp->sigev_signo ) 10d3b4: 8b 43 04 mov 0x4(%ebx),%eax 10d3b7: 85 c0 test %eax,%eax 10d3b9: 0f 84 01 01 00 00 je 10d4c0 <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10d3bf: 48 dec %eax if ( !is_valid_signo(evp->sigev_signo) ) 10d3c0: 83 f8 1f cmp $0x1f,%eax 10d3c3: 0f 87 f7 00 00 00 ja 10d4c0 <== NEVER TAKEN * This function allocates a timer control block from * 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 ); 10d3c9: c7 04 24 00 97 12 00 movl $0x129700,(%esp) 10d3d0: e8 6b b9 ff ff call 108d40 <_Objects_Allocate> if ( !ptimer ) { 10d3d5: 85 c0 test %eax,%eax 10d3d7: 0f 84 c3 00 00 00 je 10d4a0 <== NEVER TAKEN ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10d3dd: c6 40 30 02 movb $0x2,0x30(%eax) ptimer->thread_id = _Thread_Get_executing()->Object.id; 10d3e1: 8b 15 38 bb 13 00 mov 0x13bb38,%edx 10d3e7: 8b 52 08 mov 0x8(%edx),%edx 10d3ea: 89 50 2c mov %edx,0x2c(%eax) ptimer->inf.sigev_notify = evp->sigev_notify; 10d3ed: 8b 13 mov (%ebx),%edx 10d3ef: 89 50 34 mov %edx,0x34(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10d3f2: 8b 53 04 mov 0x4(%ebx),%edx 10d3f5: 89 50 38 mov %edx,0x38(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10d3f8: 8b 53 08 mov 0x8(%ebx),%edx 10d3fb: 89 50 3c mov %edx,0x3c(%eax) ptimer->overrun = 0; 10d3fe: c7 40 64 00 00 00 00 movl $0x0,0x64(%eax) _Objects_Get_index( the_object->id ), 10d405: 8b 50 08 mov 0x8(%eax),%edx ptimer->timer_data.it_value.tv_sec = 0; 10d408: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 10d40f: 8b 0d 04 97 12 00 mov 0x129704,%ecx 10d415: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10d41c: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10d423: c7 40 48 00 00 00 00 movl $0x0,0x48(%eax) 10d42a: 0f b7 da movzwl %dx,%ebx 10d42d: c7 40 4c 00 00 00 00 movl $0x0,0x4c(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10d434: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 10d43b: c7 40 1c 02 00 00 00 movl $0x2,0x1c(%eax) the_watchdog->routine = routine; 10d442: c7 40 20 e0 d4 10 00 movl $0x10d4e0,0x20(%eax) the_object->name.name_u32 = name; 10d449: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) *timerid = ptimer->Object.id; 10d450: 89 16 mov %edx,(%esi) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 10d452: 89 44 99 fc mov %eax,-0x4(%ecx,%ebx,4) _RTEMS_Unlock_allocator(); 10d456: e8 f5 9a ff ff call 106f50 <_RTEMS_Unlock_allocator> return 0; 10d45b: 31 c0 xor %eax,%eax } 10d45d: 83 c4 10 add $0x10,%esp 10d460: 5b pop %ebx 10d461: 5e pop %esi 10d462: 5d pop %ebp 10d463: c3 ret 10d464: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10d46b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10d46f: 90 nop 10d470: c7 04 24 00 97 12 00 movl $0x129700,(%esp) 10d477: e8 c4 b8 ff ff call 108d40 <_Objects_Allocate> if ( !ptimer ) { 10d47c: 85 c0 test %eax,%eax 10d47e: 74 20 je 10d4a0 ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10d480: c6 40 30 02 movb $0x2,0x30(%eax) ptimer->thread_id = _Thread_Get_executing()->Object.id; 10d484: 8b 15 38 bb 13 00 mov 0x13bb38,%edx 10d48a: 8b 52 08 mov 0x8(%edx),%edx 10d48d: 89 50 2c mov %edx,0x2c(%eax) if ( evp != NULL ) { 10d490: e9 69 ff ff ff jmp 10d3fe 10d495: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10d49c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10d4a0: e8 ab 9a ff ff call 106f50 <_RTEMS_Unlock_allocator> rtems_set_errno_and_return_minus_one( EAGAIN ); 10d4a5: e8 16 f3 00 00 call 11c7c0 <__errno> 10d4aa: c7 00 0b 00 00 00 movl $0xb,(%eax) } 10d4b0: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EAGAIN ); 10d4b3: b8 ff ff ff ff mov $0xffffffff,%eax } 10d4b8: 5b pop %ebx 10d4b9: 5e pop %esi 10d4ba: 5d pop %ebp 10d4bb: c3 ret 10d4bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi rtems_set_errno_and_return_minus_one( EINVAL ); 10d4c0: e8 fb f2 00 00 call 11c7c0 <__errno> 10d4c5: c7 00 16 00 00 00 movl $0x16,(%eax) 10d4cb: b8 ff ff ff ff mov $0xffffffff,%eax 10d4d0: eb 8b jmp 10d45d 10d4d2: 90 nop 10d4d3: 90 nop 10d4d4: 90 nop 10d4d5: 90 nop 10d4d6: 90 nop 10d4d7: 90 nop 10d4d8: 90 nop 10d4d9: 90 nop 10d4da: 90 nop 10d4db: 90 nop 10d4dc: 90 nop 10d4dd: 90 nop 10d4de: 90 nop 10d4df: 90 nop =============================================================================== 0010afe0 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 10afe0: 55 push %ebp 10afe1: 89 e5 mov %esp,%ebp 10afe3: 56 push %esi 10afe4: 53 push %ebx 10afe5: 83 ec 20 sub $0x20,%esp 10afe8: 8b 75 0c mov 0xc(%ebp),%esi POSIX_Timer_Control *ptimer; ISR_lock_Context lock_context; uint64_t now; uint32_t remaining; if ( !value ) 10afeb: 85 f6 test %esi,%esi 10afed: 0f 84 7d 00 00 00 je 10b070 return (POSIX_Timer_Control *) _Objects_Get( 10aff3: b8 40 31 13 00 mov $0x133140,%eax 10aff8: 89 44 24 08 mov %eax,0x8(%esp) 10affc: 8d 45 f4 lea -0xc(%ebp),%eax 10afff: 89 44 24 04 mov %eax,0x4(%esp) 10b003: 8b 45 08 mov 0x8(%ebp),%eax 10b006: 89 04 24 mov %eax,(%esp) 10b009: e8 d2 1b 00 00 call 10cbe0 <_Objects_Get> rtems_set_errno_and_return_minus_one( EINVAL ); ptimer = _POSIX_Timer_Get( timerid, &lock_context ); if ( ptimer != NULL ) { 10b00e: 85 c0 test %eax,%eax 10b010: 89 c3 mov %eax,%ebx 10b012: 74 5c je 10b070 Per_CPU_Control *cpu; cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context ); now = cpu->Watchdog.ticks; if ( now < ptimer->Timer.expire ) { 10b014: 8b 48 24 mov 0x24(%eax),%ecx now = cpu->Watchdog.ticks; 10b017: 8b 15 c8 7d 13 00 mov 0x137dc8,%edx if ( now < ptimer->Timer.expire ) { 10b01d: a1 cc 7d 13 00 mov 0x137dcc,%eax 10b022: 39 ca cmp %ecx,%edx 10b024: 1b 43 28 sbb 0x28(%ebx),%eax remaining = (uint32_t) ( ptimer->Timer.expire - now ); } else { remaining = 0; 10b027: b8 00 00 00 00 mov $0x0,%eax if ( now < ptimer->Timer.expire ) { 10b02c: 72 32 jb 10b060 <== ALWAYS TAKEN } _Timespec_From_ticks( remaining, &value->it_value ); 10b02e: 89 04 24 mov %eax,(%esp) 10b031: 8d 56 0c lea 0xc(%esi),%edx 10b034: 89 54 24 04 mov %edx,0x4(%esp) 10b038: e8 23 29 00 00 call 10d960 <_Timespec_From_ticks> value->it_interval = ptimer->timer_data.it_interval; 10b03d: 8b 43 48 mov 0x48(%ebx),%eax 10b040: 89 06 mov %eax,(%esi) 10b042: 8b 43 4c mov 0x4c(%ebx),%eax 10b045: 89 46 04 mov %eax,0x4(%esi) 10b048: 8b 43 50 mov 0x50(%ebx),%eax 10b04b: 89 46 08 mov %eax,0x8(%esi) _ISR_lock_ISR_enable( lock_context ); 10b04e: ff 75 f4 push -0xc(%ebp) 10b051: 9d popf _POSIX_Timer_Release( cpu, &lock_context ); return 0; 10b052: 31 c0 xor %eax,%eax } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b054: 83 c4 20 add $0x20,%esp 10b057: 5b pop %ebx 10b058: 5e pop %esi 10b059: 5d pop %ebp 10b05a: c3 ret 10b05b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10b05f: 90 nop remaining = (uint32_t) ( ptimer->Timer.expire - now ); 10b060: 89 c8 mov %ecx,%eax 10b062: 29 d0 sub %edx,%eax 10b064: eb c8 jmp 10b02e 10b066: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10b06d: 8d 76 00 lea 0x0(%esi),%esi rtems_set_errno_and_return_minus_one( EINVAL ); 10b070: e8 8b 07 01 00 call 11b800 <__errno> 10b075: c7 00 16 00 00 00 movl $0x16,(%eax) 10b07b: b8 ff ff ff ff mov $0xffffffff,%eax 10b080: eb d2 jmp 10b054 10b082: 90 nop 10b083: 90 nop 10b084: 90 nop 10b085: 90 nop 10b086: 90 nop 10b087: 90 nop 10b088: 90 nop 10b089: 90 nop 10b08a: 90 nop 10b08b: 90 nop 10b08c: 90 nop 10b08d: 90 nop 10b08e: 90 nop 10b08f: 90 nop =============================================================================== 00106e90 : timer_t timerid, int flags, const struct itimerspec *__restrict value, struct itimerspec *__restrict ovalue ) { 106e90: 55 push %ebp 106e91: 89 e5 mov %esp,%ebp 106e93: 57 push %edi 106e94: 56 push %esi 106e95: 53 push %ebx 106e96: 83 ec 5c sub $0x5c,%esp 106e99: 8b 5d 10 mov 0x10(%ebp),%ebx 106e9c: 8b 7d 0c mov 0xc(%ebp),%edi POSIX_Timer_Control *ptimer; ISR_lock_Context lock_context; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 106e9f: 85 db test %ebx,%ebx 106ea1: 0f 84 99 01 00 00 je 107040 <== NEVER TAKEN /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 106ea7: 8d 43 0c lea 0xc(%ebx),%eax 106eaa: 89 04 24 mov %eax,(%esp) 106ead: e8 ee 3e 00 00 call 10ada0 <_Timespec_Is_valid> 106eb2: 84 c0 test %al,%al 106eb4: 0f 84 86 01 00 00 je 107040 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 106eba: 89 1c 24 mov %ebx,(%esp) 106ebd: e8 de 3e 00 00 call 10ada0 <_Timespec_Is_valid> 106ec2: 84 c0 test %al,%al 106ec4: 0f 84 76 01 00 00 je 107040 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 106eca: 89 f8 mov %edi,%eax 106ecc: 83 e0 fb and $0xfffffffb,%eax 106ecf: 89 45 b4 mov %eax,-0x4c(%ebp) 106ed2: 0f 85 68 01 00 00 jne 107040 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 106ed8: 31 c0 xor %eax,%eax 106eda: 8b 14 03 mov (%ebx,%eax,1),%edx 106edd: 89 54 05 d0 mov %edx,-0x30(%ebp,%eax,1) 106ee1: 83 c0 04 add $0x4,%eax 106ee4: 83 f8 18 cmp $0x18,%eax 106ee7: 72 f1 jb 106eda /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 106ee9: 8d 75 c4 lea -0x3c(%ebp),%esi 106eec: 83 ff 04 cmp $0x4,%edi 106eef: 0f 84 1b 01 00 00 je 107010 return (POSIX_Timer_Control *) _Objects_Get( 106ef5: 89 74 24 04 mov %esi,0x4(%esp) 106ef9: 8b 45 08 mov 0x8(%ebp),%eax 106efc: bf 40 b1 12 00 mov $0x12b140,%edi 106f01: 89 7c 24 08 mov %edi,0x8(%esp) 106f05: 89 04 24 mov %eax,(%esp) 106f08: e8 13 1b 00 00 call 108a20 <_Objects_Get> * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &lock_context ); if ( ptimer != NULL ) { 106f0d: 85 c0 test %eax,%eax 106f0f: 89 c6 mov %eax,%esi 106f11: 0f 84 29 01 00 00 je 107040 Per_CPU_Control *cpu; cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context ); /* Stop the timer */ _Watchdog_Remove( 106f17: c7 04 24 90 ec 12 00 movl $0x12ec90,(%esp) 106f1e: 8d 78 10 lea 0x10(%eax),%edi 106f21: 89 7c 24 04 mov %edi,0x4(%esp) 106f25: e8 66 40 00 00 call 10af90 <_Watchdog_Remove> &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ], &ptimer->Timer ); /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 106f2a: 8b 45 e0 mov -0x20(%ebp),%eax 106f2d: 0b 45 dc or -0x24(%ebp),%eax 106f30: 75 4e jne 106f80 106f32: 8b 4d e4 mov -0x1c(%ebp),%ecx 106f35: 85 c9 test %ecx,%ecx 106f37: 75 47 jne 106f80 /* The old data of the timer are returned */ if ( ovalue ) 106f39: 8b 55 14 mov 0x14(%ebp),%edx 106f3c: 85 d2 test %edx,%edx 106f3e: 74 14 je 106f54 *ovalue = ptimer->timer_data; 106f40: 31 c0 xor %eax,%eax 106f42: 8b 4c 06 48 mov 0x48(%esi,%eax,1),%ecx 106f46: 8b 55 14 mov 0x14(%ebp),%edx 106f49: 89 0c 02 mov %ecx,(%edx,%eax,1) 106f4c: 83 c0 04 add $0x4,%eax 106f4f: 83 f8 18 cmp $0x18,%eax 106f52: 72 ee jb 106f42 /* The new data are set */ ptimer->timer_data = normalize; 106f54: 31 c0 xor %eax,%eax 106f56: 8b 4c 05 d0 mov -0x30(%ebp,%eax,1),%ecx 106f5a: 89 4c 06 48 mov %ecx,0x48(%esi,%eax,1) 106f5e: 83 c0 04 add $0x4,%eax 106f61: 83 f8 18 cmp $0x18,%eax 106f64: 72 f0 jb 106f56 /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 106f66: c6 46 30 04 movb $0x4,0x30(%esi) _ISR_lock_ISR_enable( lock_context ); 106f6a: ff 75 c4 push -0x3c(%ebp) 106f6d: 9d popf /* Returns with success */ _POSIX_Timer_Release( cpu, &lock_context ); return 0; 106f6e: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp) _POSIX_Timer_Release( cpu, &lock_context ); return 0; } rtems_set_errno_and_return_minus_one( EINVAL ); } 106f75: 8b 45 b4 mov -0x4c(%ebp),%eax 106f78: 83 c4 5c add $0x5c,%esp 106f7b: 5b pop %ebx 106f7c: 5e pop %esi 106f7d: 5f pop %edi 106f7e: 5d pop %ebp 106f7f: c3 ret ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 106f80: 89 1c 24 mov %ebx,(%esp) 106f83: e8 28 3f 00 00 call 10aeb0 <_Timespec_To_ticks> 106f88: 89 46 60 mov %eax,0x60(%esi) initial_period = _Timespec_To_ticks( &normalize.it_value ); 106f8b: 8d 45 dc lea -0x24(%ebp),%eax 106f8e: 89 04 24 mov %eax,(%esp) 106f91: e8 1a 3f 00 00 call 10aeb0 <_Timespec_To_ticks> ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 106f96: c6 46 30 03 movb $0x3,0x30(%esi) initial_period = _Timespec_To_ticks( &normalize.it_value ); 106f9a: 89 c3 mov %eax,%ebx _TOD_Get( &ptimer->time ); 106f9c: 8d 46 68 lea 0x68(%esi),%eax 106f9f: 89 04 24 mov %eax,(%esp) 106fa2: e8 a9 df ff ff call 104f50 <_Timecounter_Nanotime> _Watchdog_Insert( 106fa7: 89 d9 mov %ebx,%ecx 106fa9: 31 db xor %ebx,%ebx 106fab: 03 0d 88 ec 12 00 add 0x12ec88,%ecx 106fb1: 89 7c 24 04 mov %edi,0x4(%esp) 106fb5: 13 1d 8c ec 12 00 adc 0x12ec8c,%ebx 106fbb: 89 4c 24 08 mov %ecx,0x8(%esp) 106fbf: c7 04 24 90 ec 12 00 movl $0x12ec90,(%esp) 106fc6: 89 5c 24 0c mov %ebx,0xc(%esp) 106fca: e8 e1 f2 ff ff call 1062b0 <_Watchdog_Insert> if ( ovalue ) 106fcf: 8b 45 14 mov 0x14(%ebp),%eax 106fd2: 85 c0 test %eax,%eax 106fd4: 74 14 je 106fea *ovalue = ptimer->timer_data; 106fd6: 31 c0 xor %eax,%eax 106fd8: 8b 4c 06 48 mov 0x48(%esi,%eax,1),%ecx 106fdc: 8b 55 14 mov 0x14(%ebp),%edx 106fdf: 89 0c 02 mov %ecx,(%edx,%eax,1) 106fe2: 83 c0 04 add $0x4,%eax 106fe5: 83 f8 18 cmp $0x18,%eax 106fe8: 72 ee jb 106fd8 ptimer->timer_data = normalize; 106fea: 31 c0 xor %eax,%eax 106fec: 8b 4c 05 d0 mov -0x30(%ebp,%eax,1),%ecx 106ff0: 89 4c 06 48 mov %ecx,0x48(%esi,%eax,1) 106ff4: 83 c0 04 add $0x4,%eax 106ff7: 83 f8 18 cmp $0x18,%eax 106ffa: 72 f0 jb 106fec 106ffc: ff 75 c4 push -0x3c(%ebp) 106fff: 9d popf } 107000: 8b 45 b4 mov -0x4c(%ebp),%eax 107003: 83 c4 5c add $0x5c,%esp 107006: 5b pop %ebx 107007: 5e pop %esi 107008: 5f pop %edi 107009: 5d pop %ebp 10700a: c3 ret 10700b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10700f: 90 nop 107010: 89 34 24 mov %esi,(%esp) if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 107013: 8d 7d dc lea -0x24(%ebp),%edi 107016: e8 35 df ff ff call 104f50 <_Timecounter_Nanotime> 10701b: 89 74 24 04 mov %esi,0x4(%esp) 10701f: 89 3c 24 mov %edi,(%esp) 107022: e8 a9 3d 00 00 call 10add0 <_Timespec_Less_than> 107027: 84 c0 test %al,%al 107029: 75 15 jne 107040 _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10702b: 89 7c 24 08 mov %edi,0x8(%esp) 10702f: 89 7c 24 04 mov %edi,0x4(%esp) 107033: 89 34 24 mov %esi,(%esp) 107036: e8 05 3e 00 00 call 10ae40 <_Timespec_Subtract> 10703b: e9 b5 fe ff ff jmp 106ef5 rtems_set_errno_and_return_minus_one( EINVAL ); 107040: e8 eb 72 01 00 call 11e330 <__errno> 107045: c7 00 16 00 00 00 movl $0x16,(%eax) 10704b: c7 45 b4 ff ff ff ff movl $0xffffffff,-0x4c(%ebp) 107052: eb ac jmp 107000 107054: 90 nop 107055: 90 nop 107056: 90 nop 107057: 90 nop 107058: 90 nop 107059: 90 nop 10705a: 90 nop 10705b: 90 nop 10705c: 90 nop 10705d: 90 nop 10705e: 90 nop 10705f: 90 nop =============================================================================== 00100210 : static void wait(void) 100210: 55 push %ebp rtems_test_assert(sc == RTEMS_SUCCESSFUL); 100211: b8 20 2a 12 00 mov $0x122a20,%eax static void wait(void) 100216: 89 e5 mov %esp,%ebp rtems_test_assert(sc == RTEMS_SUCCESSFUL); 100218: ba 5c 00 00 00 mov $0x5c,%edx static void wait(void) 10021d: 83 ec 18 sub $0x18,%esp rtems_test_assert(sc == RTEMS_SUCCESSFUL); 100220: b9 44 2a 12 00 mov $0x122a44,%ecx 100225: 89 44 24 0c mov %eax,0xc(%esp) 100229: 89 54 24 08 mov %edx,0x8(%esp) 10022d: 89 4c 24 04 mov %ecx,0x4(%esp) 100231: c7 04 24 37 2a 12 00 movl $0x122a37,(%esp) 100238: e8 f3 0f 00 00 call 101230 <__wrap_printf> 10023d: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 100244: e8 b7 0f 00 00 call 101200 <== NOT EXECUTED 100249: 90 nop <== NOT EXECUTED 10024a: 90 nop <== NOT EXECUTED 10024b: 90 nop <== NOT EXECUTED 10024c: 90 nop 10024d: 90 nop 10024e: 90 nop 10024f: 90 nop