RTEMS-6
Annotated Report
posix
Sun Feb 28 23:03:23 2021
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 <pthread_mutex_lock>
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 <rtems/posix/posixapi.h>
#include <string.h>
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 <memcmp>
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 <calloc> <== 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 <free>
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 <realloc>
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 <pthread_kill>
/* 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 <rtems/score/assert.h>
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 <getpid>
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 <pthread_self>
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 <pthread_kill>
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 <aio_cancel>:
#include <errno.h>
#include <stdlib.h>
#include <rtems/seterr.h>
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 <pthread_mutex_lock>
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 <fcntl>
1097b2: 85 c0 test %eax,%eax
1097b4: 0f 88 d7 01 00 00 js 109991 <aio_cancel+0x211>
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 <aio_cancel+0x120>
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 <aio_cancel+0x1f0>
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 <rtems_aio_search_fd>
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 <aio_cancel+0xc0>
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 <aio_cancel+0x100> <== 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 <rtems_aio_search_fd>
if (r_chain == NULL) {
10980c: 85 c0 test %eax,%eax
10980e: 0f 84 5c 01 00 00 je 109970 <aio_cancel+0x1f0>
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 <rtems_aio_remove_req>
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>
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 <pthread_mutex_lock>
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 <rtems_aio_remove_req>
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>
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 <pthread_mutex_unlock>
}
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 <pthread_mutex_unlock>
return AIO_ALLDONE;
109891: eb 9e jmp 109831 <aio_cancel+0xb1>
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 <rtems_aio_search_fd>
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 <aio_cancel+0x1b0>
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 <aio_cancel+0x100> <== 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 <rtems_aio_search_fd>
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 <aio_cancel+0x100>
rtems_chain_extract (&r_chain->next_fd);
1098e4: 89 04 24 mov %eax,(%esp)
1098e7: e8 b4 35 00 00 call 10cea0 <rtems_chain_extract>
rtems_aio_remove_fd (r_chain);
1098ec: 89 1c 24 mov %ebx,(%esp)
1098ef: e8 9c 07 00 00 call 10a090 <rtems_aio_remove_fd>
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_mutex_destroy>
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 <pthread_cond_destroy>
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 <free>
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 <pthread_mutex_unlock>
return AIO_CANCELED;
109920: e9 0c ff ff ff jmp 109831 <aio_cancel+0xb1>
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 <pthread_mutex_lock>
rtems_chain_extract (&r_chain->next_fd);
10993b: 89 1c 24 mov %ebx,(%esp)
10993e: e8 5d 35 00 00 call 10cea0 <rtems_chain_extract>
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 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10994d: 89 34 24 mov %esi,(%esp)
109950: e8 cb 26 00 00 call 10c020 <pthread_mutex_unlock>
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 <pthread_mutex_unlock>
return AIO_CANCELED;
109961: e9 cb fe ff ff jmp 109831 <aio_cancel+0xb1>
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 <pthread_mutex_unlock>
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 <aio_cancel+0xb1>
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 <pthread_mutex_unlock>
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 <aio_cancel+0xb1>
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 <aio_fsync>:
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 <aio_fsync+0x60>
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 <fcntl>
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 <aio_fsync+0x90>
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 <malloc>
if (req == NULL)
109a0d: 85 c0 test %eax,%eax
109a0f: 74 6a je 109a7b <aio_fsync+0xab> <== 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 <rtems_aio_enqueue>
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 <aio_fsync+0x79>
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 <aio_fsync+0x79> <== 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 <aio_read>:
* 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 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10a3cf: a8 01 test $0x1,%al
10a3d1: 75 62 jne 10a435 <aio_read+0x85>
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 <aio_read+0x60>
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 <aio_read+0x60>
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 <malloc>
if (req == NULL)
10a3ed: 85 c0 test %eax,%eax
10a3ef: 74 5f je 10a450 <aio_read+0xa0> <== 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 <rtems_aio_enqueue>
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 <aio_read+0x79>
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 <aio_read+0x79> <== NOT EXECUTED
10a46b: 90 nop
10a46c: 90 nop
10a46d: 90 nop
10a46e: 90 nop
10a46f: 90 nop
0010a480 <aio_write>:
* 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 <fcntl>
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 <aio_write+0x85>
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 <aio_write+0x60>
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 <aio_write+0x60>
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 <malloc>
if (req == NULL)
10a4c2: 85 c0 test %eax,%eax
10a4c4: 74 5a je 10a520 <aio_write+0xa0> <== 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 <rtems_aio_enqueue>
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 <aio_write+0x79>
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 <aio_write+0x79> <== NOT EXECUTED
10a53b: 90 nop
10a53c: 90 nop
10a53d: 90 nop
10a53e: 90 nop
10a53f: 90 nop
001204c0 <clock_nanosleep>:
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 <clock_nanosleep+0x1d> <== ALWAYS TAKEN
1204d4: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
1204d7: 0f 85 93 00 00 00 jne 120570 <clock_nanosleep+0xb0> <== 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 <clock_nanosleep+0xf0>
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 <clock_nanosleep+0x190> <== 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 <clock_nanosleep+0xc0>
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
120551: 84 c0 test %al,%al
120553: 0f 85 b7 00 00 00 jne 120610 <clock_nanosleep+0x150>
_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 <clock_nanosleep+0x99>
_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 <clock_nanosleep+0x145>
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 <clock_nanosleep+0x1a0>
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 <clock_nanosleep+0x1a0>
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 <clock_nanosleep+0x1b0>
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 <clock_nanosleep+0x1d0>
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 <clock_nanosleep+0x3a>
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 <clock_nanosleep+0xc6>
_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 <clock_nanosleep+0xc9> <== 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 <clock_nanosleep+0x99>
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 <clock_nanosleep+0x41>
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 <clock_nanosleep+0x3a>
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 <clock_nanosleep+0x135>
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 <clock_nanosleep+0x145>
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 <clock_settime>:
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 <clock_settime+0x22> <== 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 <clock_settime+0x60>
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 <clock_settime+0x40>
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 <clock_settime+0x40>
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 <clock_settime+0x32>
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 <clock_settime+0x32>
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 <mmap>:
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 <mmap+0x1d0> <== 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 <mmap+0x320> <== 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 <mmap+0x320> <== 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 <mmap+0x1b0>
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 <mmap+0x1d0> <== 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 <mmap+0x1f0>
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 <mmap+0x1d0>
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 <mmap+0xd0>
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 <mmap+0x1d0>
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 <mmap+0x1d0>
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 <mmap+0x1d0> <== 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 <mmap+0x209> <== 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 <calloc>
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 <mmap+0x470> <== 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 <mmap+0x490> <== 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 <rtems_libio_lock>
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 <mmap+0x15f>
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 <mmap+0x156>
( 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 <mmap+0x570> <== 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 <mmap+0x140>
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 <mmap+0x682> <== 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 <mmap+0x5a0> <== 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 <mmap+0x615> <== 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_libio_unlock>
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 <mmap+0x1e0>
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 <mmap+0x340> <== 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 <mmap+0x1d0> <== 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 <mmap+0xad> <== 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 <fstat>
10503b: 85 c0 test %eax,%eax
10503d: 0f 88 2d 03 00 00 js 105370 <mmap+0x550> <== 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 <mmap+0x530> <== NEVER TAKEN
105071: 81 fe 00 a0 00 00 cmp $0xa000,%esi
105077: 0f 84 d3 02 00 00 je 105350 <mmap+0x530> <== 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 <mmap+0x3e0> <== 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 <mmap+0x43f>
&& (( 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 <mmap+0x5dd> <== 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 <mmap+0x40f> <== 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 <calloc>
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 <mmap+0x470> <== 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 <mmap+0x49a> <== 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 <mmap+0x6b7> <== NOT EXECUTED
free( mapping );
105135: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105138: e8 13 59 00 00 call 10aa50 <free> <== 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 <mmap+0x1d0> <== 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 <mmap+0x6c2>
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 <mmap+0x1d0> <== 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 <mmap+0x3d0> <== 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 <calloc>
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 <mmap+0x470> <== 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 <posix_memalign>
1051cf: 85 c0 test %eax,%eax
1051d1: 0f 84 39 02 00 00 je 105410 <mmap+0x5f0> <== ALWAYS TAKEN
free( mapping );
1051d7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1051da: e8 71 58 00 00 call 10aa50 <free> <== 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 <mmap+0x32b> <== 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 <mmap+0xad> <== 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 <mmap+0x600> <== 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 <mmap+0x600> <== 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 <lseek> <== NOT EXECUTED
10524e: 85 d2 test %edx,%edx <== NOT EXECUTED
105250: 0f 88 f5 fe ff ff js 10514b <mmap+0x32b> <== 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 <mmap+0x2a1>
105277: 84 c0 test %al,%al
105279: 0f 84 42 fe ff ff je 1050c1 <mmap+0x2a1> <== NEVER TAKEN
10527f: e9 6c fd ff ff jmp 104ff0 <mmap+0x1d0>
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 <mmap+0x1e0> <== 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 <mmap+0x394>
1052c7: 88 85 7c ff ff ff mov %al,-0x84(%ebp)
rtems_libio_lock();
1052cd: e8 1e be ff ff call 1010f0 <rtems_libio_lock>
} 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 <mmap+0x188> <== NEVER TAKEN
if ( is_shared_shm ) {
1052e7: 84 c0 test %al,%al
1052e9: 74 0c je 1052f7 <mmap+0x4d7>
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 <mmap+0x188>
rtems_libio_unlock();
105331: e8 da bd ff ff call 101110 <rtems_libio_unlock>
free( mapping );
105336: 89 1c 24 mov %ebx,(%esp)
105339: e8 12 57 00 00 call 10aa50 <free>
return MAP_FAILED;
10533e: b8 ff ff ff ff mov $0xffffffff,%eax
105343: e9 b8 fc ff ff jmp 105000 <mmap+0x1e0>
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 <mmap+0x1e0> <== 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 <mmap+0x1e0> <== 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 <free> <== NOT EXECUTED
105398: e8 73 bd ff ff call 101110 <rtems_libio_unlock> <== 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 <mmap+0x1e0> <== 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 <read>
if ( r != len ) {
1053d9: 39 45 0c cmp %eax,0xc(%ebp)
1053dc: 0f 84 c6 fb ff ff je 104fa8 <mmap+0x188>
1053e2: e8 29 bd ff ff call 101110 <rtems_libio_unlock> <== 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 <mmap+0x672> <== NOT EXECUTED
free( mapping );
1053f5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1053f8: e8 53 56 00 00 call 10aa50 <free> <== 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 <mmap+0x32b> <== NOT EXECUTED
10540d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_libio_lock();
105410: e8 db bc ff ff call 1010f0 <rtems_libio_lock>
if ( map_private ) {
105415: e9 72 fb ff ff jmp 104f8c <mmap+0x16c>
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 <mmap+0x1e0> <== 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 <mmap+0x64c> <== ALWAYS TAKEN
105440: f6 c2 04 test $0x4,%dl
105443: 74 09 je 10544e <mmap+0x62e> <== 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 <mmap+0x63b> <== 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 <mmap+0x188>
105464: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
105467: e9 3c fb ff ff jmp 104fa8 <mmap+0x188> <== NOT EXECUTED
10546c: f7 c7 01 00 00 00 test $0x1,%edi
105472: 75 5c jne 1054d0 <mmap+0x6b0> <== NEVER TAKEN
105474: f7 c7 02 00 00 00 test $0x2,%edi
10547a: 75 47 jne 1054c3 <mmap+0x6a3> <== NEVER TAKEN
10547c: f7 c7 04 00 00 00 test $0x4,%edi
105482: 75 31 jne 1054b5 <mmap+0x695> <== 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 <mmap+0x620>
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 <free> <== NOT EXECUTED
10549d: e9 53 ff ff ff jmp 1053f5 <mmap+0x5d5> <== 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 <mmap+0x4d7> <== NOT EXECUTED
1054b0: e9 f3 fa ff ff jmp 104fa8 <mmap+0x188> <== 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 <mmap+0x664> <== 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 <mmap+0x65c> <== 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 <mmap+0x654> <== 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 <mmap+0x122> <== 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 <mmap+0x9c>
1054ea: e9 01 fb ff ff jmp 104ff0 <mmap+0x1d0> <== NOT EXECUTED
1054ef: 90 nop
00105180 <mq_close>:
*/
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 <mq_close+0x64> <== 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 <mq_close+0x60>
_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 <mq_close+0x4b>
1051fb: 90 nop
1051fc: 90 nop
1051fd: 90 nop
1051fe: 90 nop
1051ff: 90 nop
00109560 <mq_getattr>:
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 <mq_getattr+0x70>
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 <mq_getattr+0x5e> <== 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 <mq_getattr+0x5a>
}
/*
* 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 <mq_getattr+0x53>
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 <mq_getattr+0x53>
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 <mq_notify>:
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 <mq_notify+0x93> <== 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 <mq_notify+0x8f>
_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 <mq_notify+0x70>
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 <mq_notify+0x79>
_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 <mq_notify+0x61>
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 <mq_notify+0x67>
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 <mq_notify+0x67>
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 <mq_open>:
{
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 <mq_open+0x70>
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 <mq_open+0x170>
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 <mq_open+0x140>
1052fa: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
105301: 0f 84 b9 00 00 00 je 1053c0 <mq_open+0x140>
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 <mq_open+0x190>
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 <mq_open+0x1a0>
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 <mq_open+0x1a0>
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 <mq_open+0x220>
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 <mq_open+0x1c0>
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 <mq_open+0x1f0> <== 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 <mq_open+0x54>
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 <mq_open+0x5f>
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 <mq_open+0xab>
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 <mq_open+0x54>
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 <mq_open+0x54>
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 <mq_open+0x54>
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 <mq_open+0x54>
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 <mq_setattr>:
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 <mq_setattr+0x7b>
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 <mq_setattr+0x69> <== 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 <mq_setattr+0x65>
/*
* Return the old values.
*/
if ( omqstat != NULL ) {
109b18: 85 db test %ebx,%ebx
109b1a: 74 17 je 109b33 <mq_setattr+0x53>
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 <mq_setattr+0x5e>
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 <mq_setattr+0x5e>
109b6d: 90 nop
109b6e: 90 nop
109b6f: 90 nop
001057d0 <mq_unlink>:
*/
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 <mq_unlink+0x6b>
_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 <mq_unlink+0x64>
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 <munmap>:
#include <rtems/posix/mmanimpl.h>
#include <rtems/posix/shmimpl.h>
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 <munmap+0xef> <== 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 <munmap+0xef> <== NEVER TAKEN
105517: e8 d4 bb ff ff call 1010f0 <rtems_libio_lock>
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 <munmap+0x5a> <== 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 <munmap+0x50>
( 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 <munmap+0x70>
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 <munmap+0x40> <== ALWAYS TAKEN
rtems_libio_unlock();
10554a: e8 c1 bb ff ff call 101110 <rtems_libio_unlock>
}
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 <munmap+0xbf>
*
* @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 <munmap+0x97> <== 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 <munmap+0xdc> <== 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 <munmap+0xcf>
free( mapping );
1055b5: 89 1c 24 mov %ebx,(%esp)
1055b8: e8 93 54 00 00 call 10aa50 <free>
break;
1055bd: eb 8b jmp 10554a <munmap+0x5a>
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 <free>
1055ca: eb e9 jmp 1055b5 <munmap+0xc5>
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 <munmap+0xba> <== 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 <munmap+0x61> <== 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 <pthread_attr_getaffinity_np>:
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 <pthread_attr_getaffinity_np+0x30> <== 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 <pthread_attr_getaffinity_np+0x30> <== NEVER TAKEN
1043a3: 85 d2 test %edx,%edx
1043a5: 74 19 je 1043c0 <pthread_attr_getaffinity_np+0x30> <== NEVER TAKEN
1043a7: 8b 4d 0c mov 0xc(%ebp),%ecx
1043aa: 39 48 48 cmp %ecx,0x48(%eax)
1043ad: 75 11 jne 1043c0 <pthread_attr_getaffinity_np+0x30> <== 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 <pthread_attr_setaffinity_np>:
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 <pthread_attr_setaffinity_np+0x30> <== 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 <pthread_attr_setaffinity_np+0x30> <== NEVER TAKEN
104553: 85 d2 test %edx,%edx
104555: 74 19 je 104570 <pthread_attr_setaffinity_np+0x30> <== NEVER TAKEN
104557: 8b 4d 0c mov 0xc(%ebp),%ecx
10455a: 39 48 48 cmp %ecx,0x48(%eax)
10455d: 75 11 jne 104570 <pthread_attr_setaffinity_np+0x30> <== 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 <pthread_attr_setschedpolicy>:
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 <pthread_attr_setschedpolicy+0x40>
10648d: 8b 0a mov (%edx),%ecx
10648f: 85 c9 test %ecx,%ecx
106491: 74 2d je 1064c0 <pthread_attr_setschedpolicy+0x40>
return EINVAL;
switch ( policy ) {
106493: 83 f8 02 cmp $0x2,%eax
106496: 7e 18 jle 1064b0 <pthread_attr_setschedpolicy+0x30>
106498: 83 f8 04 cmp $0x4,%eax
10649b: 75 17 jne 1064b4 <pthread_attr_setschedpolicy+0x34> <== 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 <pthread_attr_setschedpolicy+0x1d>
}
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 <pthread_cancel>:
/*
* 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 <pthread_cancel+0x70>
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 <pthread_cancel+0xa0>
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 <pthread_cancel+0x80> <== 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 <pthread_cancel+0x55> <== 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 <pthread_cancel+0x63>
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 <pthread_cond_init>:
*/
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 <pthread_cond_init+0x60> <== NEVER TAKEN
return EINVAL;
}
if ( attr == NULL ) {
104fce: 85 d2 test %edx,%edx
104fd0: 74 5e je 105030 <pthread_cond_init+0x70>
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 <pthread_cond_init+0x60> <== 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 <pthread_cond_init+0x60> <== 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 <pthread_cond_init+0x53> <== 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 <pthread_cond_init+0x12>
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 <pthread_condattr_destroy>:
*/
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 <pthread_condattr_destroy+0x20>
104e6a: 8b 10 mov (%eax),%edx
104e6c: 85 d2 test %edx,%edx
104e6e: 74 10 je 104e80 <pthread_condattr_destroy+0x20> <== 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 <pthread_condattr_getclock>:
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 <pthread_condattr_getclock+0x20> <== NEVER TAKEN
103fed: 85 d2 test %edx,%edx
103fef: 74 0f je 104000 <pthread_condattr_getclock+0x20>
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 <pthread_create>:
{
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 <pthread_create+0x330>
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
106711: 85 db test %ebx,%ebx
106713: 0f 84 87 02 00 00 je 1069a0 <pthread_create+0x2c0>
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 <pthread_create+0x2a0> <== 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 <pthread_create+0x47>
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 <pthread_create+0x2d0>
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 <pthread_create+0x2a0> <== 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 <pthread_create+0x2f7> <== ALWAYS TAKEN
106780: 83 f8 02 cmp $0x2,%eax
106783: 0f 85 f7 01 00 00 jne 106980 <pthread_create+0x2a0> <== 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 <pthread_create+0xb1>
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 <pthread_create+0x31d> <== 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 <pthread_create+0x2a5>
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 <pthread_create+0x2a0> <== 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 <pthread_create+0x133>
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 <pthread_create+0x2a0>
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 <pthread_create+0x2a0> <== 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 <pthread_create+0x370>
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 <pthread_create+0x342>
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 <pthread_create+0x35f> <== 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 <pthread_create+0x1c9>
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 <pthread_create+0x27c> <== 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 <pthread_create+0x37f>
_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 <pthread_create+0x2a5>
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 <pthread_create+0x39>
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 <pthread_create+0x2db>
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 <pthread_create+0xa0>
error = pthread_getschedparam(
1069d7: e8 24 06 00 00 call 107000 <pthread_self>
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 <pthread_getschedparam>
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 <pthread_create+0xcc>
}
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 <pthread_create+0x19a>
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 <pthread_create+0x2a5>
_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 <pthread_create+0x251>
106a6f: 90 nop
00106ba0 <pthread_getaffinity_np>:
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 <pthread_getaffinity_np+0x70>
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 <pthread_getaffinity_np+0x80>
}
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 <pthread_getattr_np>:
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 <pthread_getattr_np+0x190>
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 <pthread_getattr_np+0x200> <== NEVER TAKEN
106b59: f6 c1 02 test $0x2,%cl
106b5c: 0f 85 de 01 00 00 jne 106d40 <pthread_getattr_np+0x210> <== 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 <pthread_getattr_np+0x39>
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 <pthread_getattr_np+0x1d0> <== ALWAYS TAKEN
106b85: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED
106b8b: 0f 85 4f 01 00 00 jne 106ce0 <pthread_getattr_np+0x1b0> <== NOT EXECUTED
106b91: 83 e6 01 and $0x1,%esi
106b94: 0f 85 36 01 00 00 jne 106cd0 <pthread_getattr_np+0x1a0> <== 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 <pthread_getattr_np+0x1f0>
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 <pthread_getattr_np+0x190> <== 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 <pthread_getattr_np+0x6a> <== 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 <pthread_getattr_np+0x6a> <== NOT EXECUTED
106cf1: eb dd jmp 106cd0 <pthread_getattr_np+0x1a0> <== 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 <pthread_getattr_np+0x61> <== ALWAYS TAKEN
106d15: eb c9 jmp 106ce0 <pthread_getattr_np+0x1b0> <== 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 <pthread_getattr_np+0x187>
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 <pthread_getattr_np+0x29> <== 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 <pthread_getattr_np+0x32> <== NOT EXECUTED
00107650 <pthread_getspecific>:
*/
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 <pthread_getspecific+0x2d>
10766a: eb 1e jmp 10768a <pthread_getspecific+0x3a>
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 <pthread_getspecific+0x27> <== 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 <pthread_getspecific+0x3a> <== 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 <pthread_getspecific+0x20>
_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 <pthread_key_delete>:
* 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 <pthread_key_delete+0xb0>
_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 <pthread_key_delete+0x8e>
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 <pthread_key_delete+0x50> <== 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 <pthread_mutex_getprioceiling>:
#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 <pthread_mutex_getprioceiling+0x62>
107769: 85 db test %ebx,%ebx
10776b: 74 45 je 1077b2 <pthread_mutex_getprioceiling+0x62>
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 <pthread_mutex_getprioceiling+0x50>
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 <pthread_mutex_getprioceiling+0x80>
*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 <pthread_mutex_getprioceiling+0x2d> <== 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 <pthread_mutex_getprioceiling+0x3e>
1077ee: 90 nop
1077ef: 90 nop
001077f0 <pthread_mutex_init>:
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 <pthread_mutex_init+0x50>
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 <pthread_mutex_init+0xfb>
* 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 <pthread_mutex_init+0x3a>
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 <pthread_mutex_init+0x3a>
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 <pthread_mutex_init+0xa0>
);
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 <pthread_mutex_init+0xfb>
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 <pthread_mutex_init+0x3a>
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 <pthread_mutex_init+0xba> <== 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 <pthread_mutex_init+0x10d>
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 <pthread_mutex_init+0xd1>
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 <pthread_mutex_init+0x68>
}
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 <pthread_mutex_init+0x68>
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 <pthread_mutex_setprioceiling>:
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 <pthread_mutex_setprioceiling+0x50>
/*
* 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 <pthread_mutex_lock>
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 <pthread_mutex_setprioceiling+0x50>
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 <pthread_mutex_setprioceiling+0x70>
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 <pthread_mutex_unlock>
_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 <pthread_mutex_setprioceiling+0xc0>
error = EINVAL;
107c4c: bb 16 00 00 00 mov $0x16,%ebx
107c51: eb 84 jmp 107bd7 <pthread_mutex_setprioceiling+0x37>
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 <pthread_mutex_setprioceiling+0x120> <== 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 <pthread_mutex_setprioceiling+0x37>
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 <pthread_mutex_setprioceiling+0xfa> <== NOT EXECUTED
107ccb: 90 nop
107ccc: 90 nop
107ccd: 90 nop
107cce: 90 nop
107ccf: 90 nop
00107db0 <pthread_mutex_unlock>:
*/
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 <pthread_mutex_unlock+0x150>
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 <pthread_mutex_unlock+0x140>
_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 <pthread_mutex_unlock+0x120>
107df2: 83 fe 02 cmp $0x2,%esi
107df5: 74 39 je 107e30 <pthread_mutex_unlock+0x80>
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 <pthread_mutex_unlock+0x125>
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 <pthread_mutex_unlock+0x1c0> <== 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 <pthread_mutex_unlock+0x1c4>
_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 <pthread_mutex_unlock+0x18e>
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 <pthread_mutex_unlock+0x125> <== 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 <pthread_mutex_unlock+0x1c0> <== 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 <pthread_mutex_unlock+0x1e0>
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 <pthread_mutex_unlock+0x12e>
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 <pthread_mutex_unlock+0x170>
_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 <pthread_mutex_unlock+0x2e>
}
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 <pthread_mutex_unlock+0x1c0> <== 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 <pthread_mutex_unlock+0x1c4>
_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 <pthread_mutex_unlock+0x105>
001076b0 <pthread_mutexattr_setpshared>:
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 <pthread_mutexattr_setpshared+0x23>
1076bf: 8b 08 mov (%eax),%ecx
1076c1: 85 c9 test %ecx,%ecx
1076c3: 74 0e je 1076d3 <pthread_mutexattr_setpshared+0x23>
switch ( pshared ) {
1076c5: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
1076c9: 77 08 ja 1076d3 <pthread_mutexattr_setpshared+0x23> <== 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 <pthread_mutexattr_settype>:
#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 <pthread_mutexattr_settype+0x20>
103cfa: 8b 10 mov (%eax),%edx
103cfc: 85 d2 test %edx,%edx
103cfe: 74 10 je 103d10 <pthread_mutexattr_settype+0x20> <== NEVER TAKEN
return EINVAL;
switch ( type ) {
103d00: 83 7d 0c 03 cmpl $0x3,0xc(%ebp)
103d04: 77 0a ja 103d10 <pthread_mutexattr_settype+0x20>
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 <pthread_rwlock_init>:
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 <pthread_rwlock_init+0x40>
return EINVAL;
}
if ( attr != NULL ) {
1061d0: 85 d2 test %edx,%edx
1061d2: 74 0c je 1061e0 <pthread_rwlock_init+0x20>
if ( !attr->is_initialized ) {
1061d4: 8b 0a mov (%edx),%ecx
1061d6: 85 c9 test %ecx,%ecx
1061d8: 74 26 je 106200 <pthread_rwlock_init+0x40> <== 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 <pthread_rwlock_init+0x40>
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 <pthread_rwlock_unlock>:
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 <pthread_rwlock_unlock+0x70>
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 <pthread_rwlock_unlock+0x4d>
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 <pthread_rwlock_unlock+0x1f>
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 <memcmp> <== NOT EXECUTED
1063b7: 85 c0 test %eax,%eax
1063b9: 75 25 jne 1063e0 <pthread_rwlock_unlock+0x70>
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 <pthread_rwlockattr_setpshared>:
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 <pthread_rwlockattr_setpshared+0x23>
if ( !attr->is_initialized )
106eef: 8b 08 mov (%eax),%ecx
106ef1: 85 c9 test %ecx,%ecx
106ef3: 74 0e je 106f03 <pthread_rwlockattr_setpshared+0x23>
return EINVAL;
switch ( pshared ) {
106ef5: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
106ef9: 77 08 ja 106f03 <pthread_rwlockattr_setpshared+0x23> <== 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 <pthread_setcancelstate>:
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 <pthread_setcancelstate+0x70>
return EPROTO;
}
if ( state == PTHREAD_CANCEL_DISABLE ) {
105b7b: 83 fb 01 cmp $0x1,%ebx
105b7e: 0f 84 7c 00 00 00 je 105c00 <pthread_setcancelstate+0xa0> <== 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 <pthread_setcancelstate+0x80>
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 <pthread_setcancelstate+0x90>
if ( ( previous_life_state & THREAD_LIFE_PROTECTED ) != 0 ) {
105b96: a8 01 test $0x1,%al
105b98: 74 16 je 105bb0 <pthread_setcancelstate+0x50> <== 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 <pthread_setcancelstate+0x2a> <== 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 <pthread_setcanceltype>:
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 <pthread_setcanceltype+0x70>
return EPROTO;
}
if ( type == PTHREAD_CANCEL_DEFERRED ) {
105c2b: 85 db test %ebx,%ebx
105c2d: 74 41 je 105c70 <pthread_setcanceltype+0x60>
set_life_state = THREAD_LIFE_CHANGE_DEFERRED;
} else if ( type == PTHREAD_CANCEL_ASYNCHRONOUS ) {
105c2f: 4b dec %ebx
105c30: 75 7e jne 105cb0 <pthread_setcanceltype+0xa0>
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 <pthread_setcanceltype+0xb0>
if ( ( previous_life_state & THREAD_LIFE_CHANGE_DEFERRED ) != 0 ) {
105c4e: a8 08 test $0x8,%al
105c50: 74 3e je 105c90 <pthread_setcanceltype+0x80> <== 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 <pthread_setcanceltype+0x24>
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 <pthread_setschedparam>:
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 <pthread_setschedparam+0x220>
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 <pthread_setschedparam+0x60>
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 <pthread_setschedparam+0x240>
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 <pthread_setschedparam+0x200> <== NEVER TAKEN
if ( policy == SCHED_SPORADIC ) {
1089ce: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
1089d2: 0f 84 48 01 00 00 je 108b20 <pthread_setschedparam+0x210>
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 <pthread_setschedparam+0x200>
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 <pthread_setschedparam+0x250>
_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 <pthread_setschedparam+0x270>
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 <pthread_setschedparam+0x1bd>
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 <pthread_setschedparam+0xc8>
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 <pthread_setschedparam+0x41>
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 <pthread_setschedparam+0x160>
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 <pthread_setschedparam+0x1bd>
00107690 <pthread_setspecific>:
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 <pthread_setspecific+0x60>
_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 <pthread_setspecific+0x41>
1076b6: e9 e5 00 00 00 jmp 1077a0 <pthread_setspecific+0x110>
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 <pthread_setspecific+0x37> <== 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 <pthread_setspecific+0x110>
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 <pthread_setspecific+0x30>
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 <pthread_setspecific+0x100>
_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 <pthread_setspecific+0xad>
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 <pthread_setspecific+0xed>
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 <pthread_setspecific+0xa7> <== 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 <pthread_setspecific+0x90> <== 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 <pthread_setspecific+0xa0> <== 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 <pthread_setspecific+0xed>
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 <pthread_setspecific+0x100>
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 <pthread_setspecific+0x1c7> <== 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 <pthread_setspecific+0x182>
107803: eb 5c jmp 107861 <pthread_setspecific+0x1d1>
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 <pthread_setspecific+0x18c> <== 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 <pthread_setspecific+0x180>
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 <pthread_setspecific+0xed>
eno = ENOMEM;
107857: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED
10785c: e9 1c ff ff ff jmp 10777d <pthread_setspecific+0xed> <== NOT EXECUTED
link = _RBTree_Root_reference( the_rbtree );
107861: 8b 75 e4 mov -0x1c(%ebp),%esi
107864: eb bc jmp 107822 <pthread_setspecific+0x192>
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 <pthread_testcancel>:
/*
* 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 <pthread_testcancel+0x2a> <== 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 <rtems_aio_enqueue>:
{
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 <pthread_mutex_lock>
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 <rtems_aio_enqueue+0x140> <== NEVER TAKEN
pthread_getschedparam (pthread_self(), &policy, ¶m);
10a192: e8 59 29 00 00 call 10caf0 <pthread_self>
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 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10a1ad: e8 3e 29 00 00 call 10caf0 <pthread_self>
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 <rtems_aio_enqueue+0x80> <== NEVER TAKEN
10a1e3: 83 3d c4 1c 13 00 04 cmpl $0x4,0x131cc4
10a1ea: 0f 8e e0 00 00 00 jle 10a2d0 <rtems_aio_enqueue+0x160>
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 <rtems_aio_enqueue+0xe9>
10a1fd: 8d 76 00 lea 0x0(%esi),%esi
if (r_chain->fildes == fildes)
10a200: 39 c2 cmp %eax,%edx
10a202: 75 5d jne 10a261 <rtems_aio_enqueue+0xf1>
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 <pthread_mutex_lock>
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 <rtems_aio_insert_prio>
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_cond_signal>
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>
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 <pthread_mutex_unlock>
}
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 <rtems_aio_enqueue+0x90>
10a259: 81 fb ac 1c 13 00 cmp $0x131cac,%ebx
10a25f: 75 ef jne 10a250 <rtems_aio_enqueue+0xe0> <== 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 <rtems_aio_search_fd>
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_enqueue+0x1f0>
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 <rtems_aio_insert_prio>
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 <rtems_aio_enqueue+0xc9> <== 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 <pthread_cond_signal> <== NOT EXECUTED
10a2a5: eb 92 jmp 10a239 <rtems_aio_enqueue+0xc9> <== 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 <free> <== 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 <rtems_aio_search_fd>
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_aio_enqueue+0x9b>
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 <rtems_chain_prepend>
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_mutex_init>
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 <pthread_cond_init>
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 <pthread_create>
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 <rtems_aio_enqueue+0x22d> <== NEVER TAKEN
++aio_request_queue.active_threads;
10a354: ff 05 c4 1c 13 00 incl 0x131cc4
10a35a: e9 da fe ff ff jmp 10a239 <rtems_aio_enqueue+0xc9>
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 <rtems_chain_prepend>
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_mutex_init>
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 <pthread_cond_init>
10a398: e9 f3 fe ff ff jmp 10a290 <rtems_aio_enqueue+0x120>
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 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10a3ab: e9 95 fe ff ff jmp 10a245 <rtems_aio_enqueue+0xd5> <== NOT EXECUTED
00109df0 <rtems_aio_init>:
{
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 <pthread_attr_init>
if (result != 0)
109e05: 85 c0 test %eax,%eax
109e07: 89 c3 mov %eax,%ebx
109e09: 74 15 je 109e20 <rtems_aio_init+0x30> <== 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 <pthread_attr_setdetachstate>
if (result != 0)
109e32: 85 c0 test %eax,%eax
109e34: 0f 85 96 00 00 00 jne 109ed0 <rtems_aio_init+0xe0> <== 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 <pthread_mutex_init>
if (result != 0)
109e4c: 85 c0 test %eax,%eax
109e4e: 0f 85 bc 00 00 00 jne 109f10 <rtems_aio_init+0x120> <== 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 <pthread_cond_init>
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 <rtems_aio_init+0x100> <== 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 <pthread_attr_destroy> <== NOT EXECUTED
109edc: e9 59 ff ff ff jmp 109e3a <rtems_aio_init+0x4a> <== 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 <pthread_mutex_destroy> <== 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 <pthread_attr_destroy> <== NOT EXECUTED
109f08: e9 63 ff ff ff jmp 109e70 <rtems_aio_init+0x80> <== 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 <pthread_attr_destroy> <== NOT EXECUTED
109f1c: e9 33 ff ff ff jmp 109e54 <rtems_aio_init+0x64> <== 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 <rtems_aio_remove_fd>:
{
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 <rtems_aio_remove_fd+0x49> <== 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 <rtems_chain_extract>
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 <free>
while (!rtems_chain_is_tail (chain, node))
10a0d5: 39 fb cmp %edi,%ebx
10a0d7: 75 d7 jne 10a0b0 <rtems_aio_remove_fd+0x20>
}
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 <rtems_aio_remove_req>:
{
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 <rtems_aio_remove_req+0x70>
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 <rtems_aio_remove_req+0x40> <== 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 <rtems_aio_remove_req+0x20> <== 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 <rtems_aio_remove_req+0x2b> <== NEVER TAKEN
rtems_chain_extract (node);
10a134: 89 1c 24 mov %ebx,(%esp)
10a137: e8 64 2d 00 00 call 10cea0 <rtems_chain_extract>
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 <free>
}
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 <rtems_aio_search_fd>:
{
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 <rtems_aio_search_fd+0x108>
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 <rtems_aio_search_fd+0x115>
109f57: 89 d3 mov %edx,%ebx
109f59: eb 09 jmp 109f64 <rtems_aio_search_fd+0x34>
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 <rtems_aio_search_fd+0x60>
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 <rtems_aio_search_fd+0x30>
if (r_chain->fildes == fildes)
109f6d: 39 c6 cmp %eax,%esi
109f6f: 75 6f jne 109fe0 <rtems_aio_search_fd+0xb0>
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 <rtems_aio_search_fd+0x48>
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 <malloc>
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 <rtems_chain_insert>
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 <rtems_aio_search_fd+0x101>
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 <malloc>
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_aio_search_fd+0x14d>
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 <rtems_chain_prepend>
10a02f: eb 9a jmp 109fcb <rtems_aio_search_fd+0x9b>
r_chain = NULL;
10a031: 31 db xor %ebx,%ebx
10a033: e9 40 ff ff ff jmp 109f78 <rtems_aio_search_fd+0x48>
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 <rtems_aio_search_fd+0x3d>
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 <rtems_aio_search_fd+0x48> <== 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 <malloc>
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 <rtems_aio_search_fd+0xf1>
10a07d: 89 df mov %ebx,%edi
10a07f: 89 c3 mov %eax,%ebx
10a081: e9 36 ff ff ff jmp 109fbc <rtems_aio_search_fd+0x8c>
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 <sched_get_priority_max>:
#include <rtems/score/schedulerimpl.h>
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 <sched_get_priority_max+0x20>
10483e: 83 f8 04 cmp $0x4,%eax
104841: 75 11 jne 104854 <sched_get_priority_max+0x24> <== 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 <sched_get_priority_max+0x13>
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 <sched_get_priority_max+0x19>
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 <sched_get_priority_min>:
* 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 <sched_get_priority_min+0x30> <== NEVER TAKEN
104883: 85 c0 test %eax,%eax
104885: 79 10 jns 104897 <sched_get_priority_min+0x27>
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 <sched_get_priority_min+0x17> <== 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 <sched_rr_get_interval>:
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 <sched_rr_get_interval+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
1048c6: 85 db test %ebx,%ebx
1048c8: 74 41 je 10490b <sched_rr_get_interval+0x5b>
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 <getpid>
1048f5: 39 f0 cmp %esi,%eax
1048f7: 74 cd je 1048c6 <sched_rr_get_interval+0x16>
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 <sched_rr_get_interval+0x2d>
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 <sched_rr_get_interval+0x2d>
10491d: 90 nop
10491e: 90 nop
10491f: 90 nop
00109610 <sem_close>:
#endif
#include <rtems/posix/semaphoreimpl.h>
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 <sem_close+0x80>
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 <sem_close+0x80>
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 <sem_close+0x80> <== 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 <sem_close+0x6d> <== 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 <sem_close+0x3c>
109645: 8b 53 0c mov 0xc(%ebx),%edx
109648: 85 d2 test %edx,%edx
10964a: 75 1a jne 109666 <sem_close+0x56>
_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 <sem_close+0x4f>
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 <sem_close+0x4f>
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 <sem_open>:
{
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 <sem_open+0x80>
_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 <sem_open+0x160>
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 <sem_open+0x190>
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 <sem_open+0x47>
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 <sem_open+0x160>
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 <sem_open+0x1c0>
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 <sem_open+0x1d0> <== 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 <sem_open+0x1e0> <== 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 <sem_open+0x13e>
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 <sem_open+0x13e> <== 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 <sem_open+0x13e> <== 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 <sem_post>:
#include <rtems/posix/semaphoreimpl.h>
#include <limits.h>
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 <sem_post+0xa0>
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_post+0xa0>
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 <sem_post+0x50>
105a80: 3d fe ff ff 7f cmp $0x7ffffffe,%eax
105a85: 77 49 ja 105ad0 <sem_post+0x80>
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 <sem_post+0x3f>
105acf: 90 nop
if ( RTEMS_PREDICT_TRUE( heads != NULL ) ) {
105ad0: 85 d2 test %edx,%edx
105ad2: 75 cc jne 105aa0 <sem_post+0x50> <== 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 <sem_post+0x3f>
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 <sem_post+0x3f>
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 <sem_timedwait>:
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 <sem_timedwait+0xa0>
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_timedwait+0xa0>
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_timedwait+0x40>
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 <sem_timedwait+0x36> <== 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 <sem_timedwait+0x36>
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 <sem_timedwait+0x36>
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 <shm_open>:
{
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 <shm_open+0x2e0> <== 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 <shm_open+0x2e0> <== 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 <shm_open+0x47> <== ALWAYS TAKEN
10595f: 84 c0 test %al,%al <== NOT EXECUTED
105961: 0f 85 99 02 00 00 jne 105c00 <shm_open+0x2e0> <== NOT EXECUTED
iop = rtems_libio_allocate();
105967: e8 d4 b5 ff ff call 100f40 <rtems_libio_allocate>
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 <shm_open+0x2f5> <== 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 <shm_open+0x180> <== 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 <shm_open+0xc0> <== 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 <rtems_libio_free> <== 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 <rtems_filesystem_check_access> <== 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 <shm_open+0x280> <== 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 <shm_open+0x2b0> <== 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 <shm_open+0x2a0> <== NEVER TAKEN
105aab: 48 dec %eax
105aac: 0f 84 fe 00 00 00 je 105bb0 <shm_open+0x290> <== 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 <shm_open+0x2a0> <== 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 <shm_open+0x2d0> <== 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 <shm_open+0x30a> <== 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 <shm_open+0x319> <== 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 <gettimeofday>
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 <rtems_current_user_env_get>
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 <geteuid>
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 <getegid>
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 <shm_open+0x104>
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 <shm_open+0x9e> <== 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 <shm_open+0x9e> <== 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 <shm_open+0x9e> <== 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 <shm_ftruncate> <== NOT EXECUTED
105be7: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED
105bea: e9 40 fe ff ff jmp 105a2f <shm_open+0x10f> <== 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 <shm_open+0x9e> <== 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 <shm_open+0xb2> <== 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 <shm_open+0xb2> <== 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 <shm_open+0x9e> <== 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 <shm_open+0x9e> <== 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 <shm_unlink>:
#include <rtems/seterr.h>
#include <rtems/posix/shmimpl.h>
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 <shm_unlink+0x7e> <== 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 <shm_unlink+0x70> <== 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 <shm_unlink+0x9c> <== 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 <shm_unlink+0x67> <== 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 <shm_unlink+0x8e> <== 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 <sigaction>:
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 <sigaction+0xd0>
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 <sigaction+0xd0>
*
* 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 <sigaction+0xd0>
_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 <sigaction+0x5c>
*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 <sigaction+0x8f> <== 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 <sigaction+0xa0>
_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 <sigaction+0x8f>
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 <sigaction+0x93>
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 <sigtimedwait>:
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 <sigtimedwait+0x2e1> <== 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 <sigtimedwait+0x160>
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 <sigtimedwait+0x120>
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 <sigtimedwait+0x16f> <== 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 <sigtimedwait+0x240>
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 <sigtimedwait+0x180>
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 <sigtimedwait+0x2c6>
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 <sigtimedwait+0x2d0>
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 <sigtimedwait+0x3c> <== 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 <sigtimedwait+0x210> <== 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 <sigtimedwait+0x227> <== 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 <sigtimedwait+0x3e>
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 <sigtimedwait+0x50>
10a97f: 8d 75 ac lea -0x54(%ebp),%esi
10a982: e9 d9 fe ff ff jmp 10a860 <sigtimedwait+0x50>
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 <sigtimedwait+0x1c1> <== NEVER TAKEN
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10a9a5: 43 inc %ebx
10a9a6: 83 fb 20 cmp $0x20,%ebx
10a9a9: 75 ef jne 10a99a <sigtimedwait+0x18a>
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 <sigtimedwait+0x1b6>
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 <sigtimedwait+0x1c1> <== 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 <sigtimedwait+0x1b0>
_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 <sigtimedwait+0x14f> <== 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 <sigtimedwait+0x3e> <== 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 <sigtimedwait+0x281> <== NEVER TAKEN
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10aa65: 42 inc %edx
10aa66: 83 fa 20 cmp $0x20,%edx
10aa69: 75 ef jne 10aa5a <sigtimedwait+0x24a>
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 <sigtimedwait+0x276>
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 <sigtimedwait+0x281> <== 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 <sigtimedwait+0x270>
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 <sigtimedwait+0x2d0>
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 <sigtimedwait+0x10f>
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 <sigtimedwait+0x10f>
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 <sigwait>:
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 <sigtimedwait>
if ( status != -1 ) {
10c0d3: 83 f8 ff cmp $0xffffffff,%eax
10c0d6: 74 28 je 10c100 <sigwait+0x50>
if ( sig )
10c0d8: 85 db test %ebx,%ebx
10c0da: 74 14 je 10c0f0 <sigwait+0x40> <== 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 <sysconf>:
*/
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 <sysconf+0x30>
103cee: 83 f8 08 cmp $0x8,%eax
103cf1: 7f 5d jg 103d50 <sysconf+0x70>
103cf3: 83 f8 04 cmp $0x4,%eax
103cf6: 74 68 je 103d60 <sysconf+0x80>
103cf8: 83 f8 08 cmp $0x8,%eax
103cfb: 75 28 jne 103d25 <sysconf+0x45>
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 <sysconf+0x60> <== NEVER TAKEN
103d15: 3d 8c 00 00 00 cmp $0x8c,%eax
103d1a: 75 15 jne 103d31 <sysconf+0x51> <== 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 <sysconf+0x87>
return (long) rtems_clock_get_ticks_per_second();
103d2a: a1 ac ff 11 00 mov 0x11ffac,%eax
103d2f: eb d1 jmp 103d02 <sysconf+0x22>
switch ( name ) {
103d31: 83 f8 33 cmp $0x33,%eax
103d34: 75 31 jne 103d67 <sysconf+0x87>
return 1024;
103d36: b8 00 04 00 00 mov $0x400,%eax
rtems_set_errno_and_return_minus_one( EINVAL );
103d3b: eb c5 jmp 103d02 <sysconf+0x22>
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 <sysconf+0x22> <== 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 <sysconf+0x22>
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 <sysconf+0x22>
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 <sysconf+0x22>
103d79: 90 nop
103d7a: 90 nop
103d7b: 90 nop
103d7c: 90 nop
103d7d: 90 nop
103d7e: 90 nop
103d7f: 90 nop
0010d380 <timer_create>:
{
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 <timer_create+0x140>
if ( !timerid )
10d398: 85 f6 test %esi,%esi
10d39a: 0f 84 20 01 00 00 je 10d4c0 <timer_create+0x140>
if (evp != NULL) {
10d3a0: 85 db test %ebx,%ebx
10d3a2: 0f 84 c8 00 00 00 je 10d470 <timer_create+0xf0>
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 <timer_create+0x140> <== 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 <timer_create+0x140> <== 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 <timer_create+0x140> <== 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 <timer_create+0x120> <== 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 <timer_create+0x120>
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 <timer_create+0x7e>
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 <timer_create+0xdd>
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 <timer_gettime>:
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 <timer_gettime+0x90>
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 <timer_gettime+0x90>
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 <timer_gettime+0x80> <== 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 <timer_gettime+0x4e>
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 <timer_gettime+0x74>
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_settime>:
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 <timer_settime+0x1b0> <== 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 <timer_settime+0x1b0>
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 <timer_settime+0x1b0> <== 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 <timer_settime+0x1b0>
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 <timer_settime+0x4a>
/* 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 <timer_settime+0x180>
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 <timer_settime+0x1b0>
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 <timer_settime+0xf0>
106f32: 8b 4d e4 mov -0x1c(%ebp),%ecx
106f35: 85 c9 test %ecx,%ecx
106f37: 75 47 jne 106f80 <timer_settime+0xf0>
/* 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 <timer_settime+0xc4>
*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 <timer_settime+0xb2>
/* 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 <timer_settime+0xc6>
/* 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 <timer_settime+0x15a>
*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 <timer_settime+0x148>
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 <timer_settime+0x15c>
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 <timer_settime+0x1b0>
_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 <timer_settime+0x65>
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 <timer_settime+0x170>
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 <wait.part.0>:
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 <rtems_test_exit> <== 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