RTEMS-6
Annotated Report
posix
Sun Feb 28 23:41:07 2021
0010765c <_POSIX_Condition_variables_Wait_support>:
int _POSIX_Condition_variables_Wait_support(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10765c: b5f0 push {r4, r5, r6, r7, lr}
10765e: b08b sub sp, #44 ; 0x2c
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 );
107660: 2800 cmp r0, #0
107662: d053 beq.n 10770c <_POSIX_Condition_variables_Wait_support+0xb0>
107664: f24b 13fe movw r3, #45566 ; 0xb1fe
107668: 4616 mov r6, r2
10766a: 6807 ldr r7, [r0, #0]
10766c: f6c1 03df movt r3, #6367 ; 0x18df
107670: 460d mov r5, r1
107672: 4604 mov r4, r0
107674: ea80 0207 eor.w r2, r0, r7
107678: 4053 eors r3, r2
10767a: f033 0301 bics.w r3, r3, #1
10767e: d141 bne.n 107704 <_POSIX_Condition_variables_Wait_support+0xa8>
_Thread_queue_Context_initialize( &queue_context );
if ( abstime != NULL ) {
107680: 2e00 cmp r6, #0
107682: d04e beq.n 107722 <_POSIX_Condition_variables_Wait_support+0xc6>
RTEMS_INLINE_ROUTINE clockid_t _POSIX_Condition_variables_Get_clock(
unsigned long flags
)
{
if ( ( flags & POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC ) != 0 ) {
107684: 07fb lsls r3, r7, #31
queue_context->Timeout.arg = arg;
107686: 9604 str r6, [sp, #16]
queue_context->enqueue_callout = enqueue_callout;
107688: bf55 itete pl
10768a: f247 53f9 movwpl r3, #30201 ; 0x75f9
10768e: f247 6339 movwmi r3, #30265 ; 0x7639
107692: f2c0 0310 movtpl r3, #16
107696: f2c0 0310 movtmi r3, #16
10769a: 9303 str r3, [sp, #12]
__asm__ volatile (
10769c: f3ef 8200 mrs r2, CPSR
1076a0: f042 0380 orr.w r3, r2, #128 ; 0x80
1076a4: f383 8900 msr CPSR_fc, r3
}
executing = _POSIX_Condition_variables_Acquire( the_cond, &queue_context );
if (
the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
1076a8: 69a6 ldr r6, [r4, #24]
1076aa: 9201 str r2, [sp, #4]
&& the_cond->mutex != mutex
1076ac: 42ae cmp r6, r5
1076ae: bf18 it ne
1076b0: 2e00 cmpne r6, #0
1076b2: bf14 ite ne
1076b4: 2601 movne r6, #1
1076b6: 2600 moveq r6, #0
1076b8: d12c bne.n 107714 <_POSIX_Condition_variables_Wait_support+0xb8>
1076ba: f642 0340 movw r3, #10304 ; 0x2840
queue_context->thread_state = thread_state;
1076be: 2220 movs r2, #32
1076c0: f2c0 0320 movt r3, #32
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_CONDITION_VARIABLE
);
_Thread_queue_Enqueue(
1076c4: f240 2154 movw r1, #596 ; 0x254
1076c8: 699f ldr r7, [r3, #24]
1076ca: f104 000c add.w r0, r4, #12
1076ce: ab01 add r3, sp, #4
1076d0: 9202 str r2, [sp, #8]
the_cond->mutex = mutex;
1076d2: 61a5 str r5, [r4, #24]
_Thread_queue_Enqueue(
1076d4: f2c0 0111 movt r1, #17
1076d8: 463a mov r2, r7
1076da: f001 ff35 bl 109548 <_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 );
1076de: 6cfb ldr r3, [r7, #76] ; 0x4c
1076e0: f103 04ff add.w r4, r3, #255 ; 0xff
1076e4: ea14 0423 ands.w r4, r4, r3, asr #32
1076e8: bf38 it cc
1076ea: 461c movcc r4, r3
1076ec: 1224 asrs r4, r4, #8
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal() or a pthread_cond_broadcast().
*/
if ( error == EINTR ) {
1076ee: 2c04 cmp r4, #4
1076f0: d01d beq.n 10772e <_POSIX_Condition_variables_Wait_support+0xd2> <== ALWAYS TAKEN
/*
* When we get here the dispatch disable level is 0.
*/
if ( error != EPERM ) {
1076f2: 2c01 cmp r4, #1
1076f4: d003 beq.n 1076fe <_POSIX_Condition_variables_Wait_support+0xa2>
int mutex_error;
mutex_error = pthread_mutex_lock( mutex );
1076f6: 4628 mov r0, r5
1076f8: f000 f8a0 bl 10783c <pthread_mutex_lock>
if ( mutex_error != 0 ) {
1076fc: b930 cbnz r0, 10770c <_POSIX_Condition_variables_Wait_support+0xb0>
error = EINVAL;
}
}
return error;
}
1076fe: 4620 mov r0, r4
107700: b00b add sp, #44 ; 0x2c
107702: bdf0 pop {r4, r5, r6, r7, pc}
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
107704: f7ff ff56 bl 1075b4 <_POSIX_Condition_variables_Auto_initialization>
107708: 2800 cmp r0, #0
10770a: d1b9 bne.n 107680 <_POSIX_Condition_variables_Wait_support+0x24>
error = EINVAL;
10770c: 2416 movs r4, #22
}
10770e: 4620 mov r0, r4
107710: b00b add sp, #44 ; 0x2c
107712: bdf0 pop {r4, r5, r6, r7, pc}
__asm__ volatile (
107714: 9b01 ldr r3, [sp, #4]
107716: f383 8900 msr CPSR_fc, r3
return EINVAL;
10771a: 2416 movs r4, #22
}
10771c: 4620 mov r0, r4
10771e: b00b add sp, #44 ; 0x2c
107720: bdf0 pop {r4, r5, r6, r7, pc}
queue_context->enqueue_callout = enqueue_callout;
107722: f247 631d movw r3, #30237 ; 0x761d
107726: f2c0 0310 movt r3, #16
10772a: 9303 str r3, [sp, #12]
}
10772c: e7b6 b.n 10769c <_POSIX_Condition_variables_Wait_support+0x40>
error = 0;
10772e: 4634 mov r4, r6 <== NOT EXECUTED
107730: e7e1 b.n 1076f6 <_POSIX_Condition_variables_Wait_support+0x9a> <== NOT EXECUTED
107732: bf00 nop
001075fc <_POSIX_Message_queue_Send_support>:
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX ) {
1075fc: 2b20 cmp r3, #32
{
1075fe: b5f0 push {r4, r5, r6, r7, lr}
107600: b08f sub sp, #60 ; 0x3c
if ( msg_prio > MQ_PRIO_MAX ) {
107602: d843 bhi.n 10768c <_POSIX_Message_queue_Send_support+0x90>
return (POSIX_Message_queue_Control *) _Objects_Get(
107604: 4617 mov r7, r2
107606: f240 0200 movw r2, #0
10760a: 460e mov r6, r1
10760c: f2c0 0220 movt r2, #32
107610: a905 add r1, sp, #20
107612: 461c mov r4, r3
107614: f001 ff16 bl 109444 <_Objects_Get>
rtems_set_errno_and_return_minus_one( EINVAL );
}
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
107618: 2800 cmp r0, #0
10761a: d030 beq.n 10767e <_POSIX_Message_queue_Send_support+0x82> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) {
10761c: 6ec5 ldr r5, [r0, #108] ; 0x6c
10761e: 07ab lsls r3, r5, #30
107620: d02a beq.n 107678 <_POSIX_Message_queue_Send_support+0x7c>
queue_context->enqueue_callout = enqueue_callout;
107622: 9b15 ldr r3, [sp, #84] ; 0x54
}
_Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout );
_Thread_queue_Context_set_timeout_argument( &queue_context, abstime );
_CORE_message_queue_Acquire_critical(
107624: 3010 adds r0, #16
107626: 9307 str r3, [sp, #28]
queue_context->Timeout.arg = arg;
107628: 9b14 ldr r3, [sp, #80] ; 0x50
10762a: 9308 str r3, [sp, #32]
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
10762c: 6c43 ldr r3, [r0, #68] ; 0x44
10762e: b31b cbz r3, 107678 <_POSIX_Message_queue_Send_support+0x7c>
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
status = _CORE_message_queue_Submit(
107630: f485 4580 eor.w r5, r5, #16384 ; 0x4000
107634: f242 2100 movw r1, #8704 ; 0x2200
107638: ab05 add r3, sp, #20
return (CORE_message_queue_Submit_types) priority * -1;
10763a: 4264 negs r4, r4
10763c: f3c5 3580 ubfx r5, r5, #14, #1
107640: f2c0 0120 movt r1, #32
107644: 9302 str r3, [sp, #8]
107646: 4632 mov r2, r6
107648: e9cd 4500 strd r4, r5, [sp]
10764c: 463b mov r3, r7
10764e: 6989 ldr r1, [r1, #24]
107650: f001 f980 bl 108954 <_CORE_message_queue_Submit>
RTEMS_INLINE_ROUTINE int _POSIX_Zero_or_minus_one_plus_errno(
Status_Control status
)
{
if ( status == STATUS_SUCCESSFUL ) {
107654: 4604 mov r4, r0
107656: b910 cbnz r0, 10765e <_POSIX_Message_queue_Send_support+0x62>
_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 );
}
107658: 4620 mov r0, r4
10765a: b00f add sp, #60 ; 0x3c
10765c: bdf0 pop {r4, r5, r6, r7, pc}
return 0;
}
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
10765e: f007 fea1 bl 10f3a4 <__errno>
return STATUS_GET_POSIX( status );
107662: f104 03ff add.w r3, r4, #255 ; 0xff
107666: ea13 0324 ands.w r3, r3, r4, asr #32
10766a: bf38 it cc
10766c: 4623 movcc r3, r4
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
10766e: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
return STATUS_GET_POSIX( status );
107672: 121b asrs r3, r3, #8
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
107674: 6003 str r3, [r0, #0]
107676: e7ef b.n 107658 <_POSIX_Message_queue_Send_support+0x5c>
107678: 9b05 ldr r3, [sp, #20]
10767a: f383 8900 msr CPSR_fc, r3
rtems_set_errno_and_return_minus_one( EBADF );
10767e: f007 fe91 bl 10f3a4 <__errno>
107682: 2309 movs r3, #9
107684: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
107688: 6003 str r3, [r0, #0]
10768a: e7e5 b.n 107658 <_POSIX_Message_queue_Send_support+0x5c>
rtems_set_errno_and_return_minus_one( EINVAL );
10768c: f007 fe8a bl 10f3a4 <__errno>
107690: 2316 movs r3, #22
107692: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
107696: 6003 str r3, [r0, #0]
107698: e7de b.n 107658 <_POSIX_Message_queue_Send_support+0x5c>
10769a: bf00 nop
00109250 <_POSIX_Mutex_Lock_support>:
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
109250: 2800 cmp r0, #0
109252: f000 80b8 beq.w 1093c6 <_POSIX_Mutex_Lock_support+0x176>
{
109256: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10925a: f241 33b8 movw r3, #5048 ; 0x13b8
10925e: 6807 ldr r7, [r0, #0]
109260: 4615 mov r5, r2
109262: f2c9 631c movt r3, #38428 ; 0x961c
{
109266: b08b sub sp, #44 ; 0x2c
109268: 460e mov r6, r1
10926a: 4604 mov r4, r0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10926c: ea80 0207 eor.w r2, r0, r7
109270: 4053 eors r3, r2
109272: f033 0307 bics.w r3, r3, #7
109276: d148 bne.n 10930a <_POSIX_Mutex_Lock_support+0xba>
__asm__ volatile (
109278: f3ef 8300 mrs r3, CPSR
10927c: f043 0280 orr.w r2, r3, #128 ; 0x80
109280: f382 8900 msr CPSR_fc, r2
109284: f642 28c0 movw r8, #10944 ; 0x2ac0
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
109288: 9301 str r3, [sp, #4]
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 ) ) {
10928a: f017 0303 ands.w r3, r7, #3
10928e: f2c0 0820 movt r8, #32
109292: f8d8 9018 ldr.w r9, [r8, #24]
queue_context->enqueue_callout = enqueue_callout;
109296: 9503 str r5, [sp, #12]
queue_context->Timeout.arg = arg;
109298: 9604 str r6, [sp, #16]
10929a: d03e beq.n 10931a <_POSIX_Mutex_Lock_support+0xca>
10929c: 2b02 cmp r3, #2
10929e: d010 beq.n 1092c2 <_POSIX_Mutex_Lock_support+0x72>
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Mutex_Get_owner(
const POSIX_Mutex_Control *the_mutex
)
{
return the_mutex->Recursive.Mutex.Queue.Queue.owner;
1092a0: 6920 ldr r0, [r4, #16]
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
1092a2: 2800 cmp r0, #0
1092a4: d065 beq.n 109372 <_POSIX_Mutex_Lock_support+0x122>
_Thread_Resource_count_increment( executing );
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_SUCCESSFUL;
}
if ( owner == executing ) {
1092a6: 4581 cmp r9, r0
1092a8: d047 beq.n 10933a <_POSIX_Mutex_Lock_support+0xea>
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
1092aa: 2e01 cmp r6, #1
1092ac: d05a beq.n 109364 <_POSIX_Mutex_Lock_support+0x114>
queue_context->deadlock_callout = deadlock_callout;
1092ae: f24b 5275 movw r2, #46453 ; 0xb575
_Thread_queue_Enqueue(
1092b2: f645 41fc movw r1, #23804 ; 0x5cfc
1092b6: f2c0 0210 movt r2, #16
queue_context->thread_state = thread_state;
1092ba: 2301 movs r3, #1
1092bc: f2c0 0111 movt r1, #17
1092c0: e00f b.n 1092e2 <_POSIX_Mutex_Lock_support+0x92>
return the_mutex->Recursive.Mutex.Queue.Queue.owner;
1092c2: 6925 ldr r5, [r4, #16]
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
1092c4: 2d00 cmp r5, #0
1092c6: d05c beq.n 109382 <_POSIX_Mutex_Lock_support+0x132>
executing,
queue_context
);
}
if ( owner == executing ) {
1092c8: 45a9 cmp r9, r5
1092ca: d036 beq.n 10933a <_POSIX_Mutex_Lock_support+0xea> <== ALWAYS TAKEN
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
1092cc: 2e01 cmp r6, #1
1092ce: d049 beq.n 109364 <_POSIX_Mutex_Lock_support+0x114> <== ALWAYS TAKEN
queue_context->deadlock_callout = deadlock_callout;
1092d0: f24b 5275 movw r2, #46453 ; 0xb575
_Thread_queue_Enqueue(
1092d4: f645 41e8 movw r1, #23784 ; 0x5ce8
1092d8: f2c0 0210 movt r2, #16
queue_context->thread_state = thread_state;
1092dc: 2301 movs r3, #1
1092de: f2c0 0111 movt r1, #17
1092e2: f104 000c add.w r0, r4, #12
1092e6: 9302 str r3, [sp, #8]
queue_context->deadlock_callout = deadlock_callout;
1092e8: 9209 str r2, [sp, #36] ; 0x24
1092ea: ab01 add r3, sp, #4
1092ec: 464a mov r2, r9
1092ee: f002 f949 bl 10b584 <_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 );
1092f2: f8d9 304c ldr.w r3, [r9, #76] ; 0x4c
1092f6: f103 00ff add.w r0, r3, #255 ; 0xff
1092fa: ea10 0023 ands.w r0, r0, r3, asr #32
1092fe: bf38 it cc
109300: 4618 movcc r0, r3
109302: 1200 asrs r0, r0, #8
);
break;
}
return _POSIX_Get_error( status );
}
109304: b00b add sp, #44 ; 0x2c
109306: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10930a: f000 f8cf bl 1094ac <_POSIX_Mutex_Auto_initialization>
10930e: 2800 cmp r0, #0
109310: d1b2 bne.n 109278 <_POSIX_Mutex_Lock_support+0x28>
return STATUS_MUTEX_CEILING_VIOLATED;
109312: 2016 movs r0, #22
}
109314: b00b add sp, #44 ; 0x2c
109316: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
return the_mutex->Recursive.Mutex.Queue.Queue.owner;
10931a: 6920 ldr r0, [r4, #16]
if ( owner == NULL ) {
10931c: b348 cbz r0, 109372 <_POSIX_Mutex_Lock_support+0x122>
if ( owner == executing ) {
10931e: 4581 cmp r9, r0
109320: d017 beq.n 109352 <_POSIX_Mutex_Lock_support+0x102>
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
109322: 2e01 cmp r6, #1
109324: d01e beq.n 109364 <_POSIX_Mutex_Lock_support+0x114> <== ALWAYS TAKEN
109326: f24b 5275 movw r2, #46453 ; 0xb575
_Thread_queue_Enqueue(
10932a: f645 41c0 movw r1, #23744 ; 0x5cc0
10932e: f2c0 0210 movt r2, #16
queue_context->thread_state = thread_state;
109332: 2301 movs r3, #1
109334: f2c0 0111 movt r1, #17
109338: e7d3 b.n 1092e2 <_POSIX_Mutex_Lock_support+0x92>
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
10933a: 077b lsls r3, r7, #29
10933c: d510 bpl.n 109360 <_POSIX_Mutex_Lock_support+0x110> <== NEVER TAKEN
++the_mutex->Recursive.nest_level;
10933e: 69a3 ldr r3, [r4, #24] <== NOT EXECUTED
return STATUS_SUCCESSFUL;
109340: 2000 movs r0, #0 <== NOT EXECUTED
++the_mutex->Recursive.nest_level;
109342: 3301 adds r3, #1 <== NOT EXECUTED
109344: 61a3 str r3, [r4, #24] <== NOT EXECUTED
__asm__ volatile (
109346: 9b01 ldr r3, [sp, #4]
109348: f383 8900 msr CPSR_fc, r3
}
10934c: b00b add sp, #44 ; 0x2c
10934e: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
109352: 077a lsls r2, r7, #29
109354: d504 bpl.n 109360 <_POSIX_Mutex_Lock_support+0x110> <== NEVER TAKEN
++the_mutex->Recursive.nest_level;
109356: 69a2 ldr r2, [r4, #24] <== NOT EXECUTED
return STATUS_SUCCESSFUL;
109358: 4618 mov r0, r3 <== NOT EXECUTED
++the_mutex->Recursive.nest_level;
10935a: 3201 adds r2, #1 <== NOT EXECUTED
10935c: 61a2 str r2, [r4, #24] <== NOT EXECUTED
return STATUS_SUCCESSFUL;
10935e: e7f2 b.n 109346 <_POSIX_Mutex_Lock_support+0xf6> <== NOT EXECUTED
109360: 202d movs r0, #45 ; 0x2d
109362: e7f0 b.n 109346 <_POSIX_Mutex_Lock_support+0xf6>
109364: 9b01 ldr r3, [sp, #4]
109366: f383 8900 msr CPSR_fc, r3
10936a: 2010 movs r0, #16
10936c: b00b add sp, #44 ; 0x2c
10936e: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
109372: f8c4 9010 str.w r9, [r4, #16]
109376: 9b01 ldr r3, [sp, #4]
109378: f383 8900 msr CPSR_fc, r3
10937c: b00b add sp, #44 ; 0x2c
10937e: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
109382: f8d9 3038 ldr.w r3, [r9, #56] ; 0x38
if (
109386: e9d4 120c ldrd r1, r2, [r4, #48] ; 0x30
queue_context->Priority.update_count = 0;
10938a: 9506 str r5, [sp, #24]
10938c: e9d3 0306 ldrd r0, r3, [r3, #24]
109390: 4288 cmp r0, r1
109392: 4193 sbcs r3, r2
109394: d319 bcc.n 1093ca <_POSIX_Mutex_Lock_support+0x17a>
_Thread_Priority_add(
109396: f104 0120 add.w r1, r4, #32
10939a: 4648 mov r0, r9
10939c: aa01 add r2, sp, #4
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
10939e: f8c4 9010 str.w r9, [r4, #16]
_Thread_Priority_add(
1093a2: f001 fe27 bl 10aff4 <_Thread_Priority_add>
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
1093a6: f8d8 3010 ldr.w r3, [r8, #16]
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
1093aa: 3301 adds r3, #1
1093ac: f8c8 3010 str.w r3, [r8, #16]
1093b0: 9b01 ldr r3, [sp, #4]
1093b2: f383 8900 msr CPSR_fc, r3
_Thread_Priority_update( queue_context );
1093b6: a801 add r0, sp, #4
1093b8: f001 fe86 bl 10b0c8 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
1093bc: 4640 mov r0, r8
1093be: f001 ff57 bl 10b270 <_Thread_Dispatch_enable>
return STATUS_SUCCESSFUL;
1093c2: 4628 mov r0, r5
1093c4: e79e b.n 109304 <_POSIX_Mutex_Lock_support+0xb4>
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
1093c6: 2016 movs r0, #22
}
1093c8: 4770 bx lr
1093ca: 9b01 ldr r3, [sp, #4]
1093cc: f383 8900 msr CPSR_fc, r3
1093d0: e79f b.n 109312 <_POSIX_Mutex_Lock_support+0xc2>
1093d2: bf00 nop
00106bcc <_POSIX_Shm_Object_create_from_heap>:
int _POSIX_Shm_Object_create_from_heap(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
106bcc: b538 push {r3, r4, r5, lr} <== NOT EXECUTED
106bce: 4604 mov r4, r0 <== NOT EXECUTED
void *p = calloc( 1, size ); /* get zero'd memory */
106bd0: 2001 movs r0, #1 <== NOT EXECUTED
{
106bd2: 460d mov r5, r1 <== NOT EXECUTED
void *p = calloc( 1, size ); /* get zero'd memory */
106bd4: f002 fc1e bl 109414 <calloc> <== NOT EXECUTED
if ( p != NULL ) {
106bd8: b118 cbz r0, 106be2 <_POSIX_Shm_Object_create_from_heap+0x16> <== NOT EXECUTED
shm_obj->handle = p;
shm_obj->size = size;
106bda: e9c4 0500 strd r0, r5, [r4] <== NOT EXECUTED
} else {
errno = EIO;
}
return 0;
}
106bde: 2000 movs r0, #0 <== NOT EXECUTED
106be0: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
errno = EIO;
106be2: f006 fddb bl 10d79c <__errno> <== NOT EXECUTED
106be6: 2305 movs r3, #5 <== NOT EXECUTED
106be8: 6003 str r3, [r0, #0] <== NOT EXECUTED
106bea: e7f8 b.n 106bde <_POSIX_Shm_Object_create_from_heap+0x12> <== NOT EXECUTED
001077fc <_POSIX_Shm_Object_create_from_workspace>:
int _POSIX_Shm_Object_create_from_workspace(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
1077fc: b538 push {r3, r4, r5, lr} <== NOT EXECUTED
1077fe: 4605 mov r5, r0 <== NOT EXECUTED
shm_obj->handle = _Workspace_Allocate( size );
107800: 4608 mov r0, r1 <== NOT EXECUTED
{
107802: 460c mov r4, r1 <== NOT EXECUTED
shm_obj->handle = _Workspace_Allocate( size );
107804: f002 f8b8 bl 109978 <_Workspace_Allocate> <== NOT EXECUTED
107808: 6028 str r0, [r5, #0] <== NOT EXECUTED
if ( shm_obj->handle == NULL ) {
10780a: b130 cbz r0, 10781a <_POSIX_Shm_Object_create_from_workspace+0x1e> <== NOT EXECUTED
return ENOMEM;
}
memset( shm_obj->handle, 0, size );
10780c: 4622 mov r2, r4 <== NOT EXECUTED
10780e: 2100 movs r1, #0 <== NOT EXECUTED
107810: f006 fea6 bl 10e560 <memset> <== NOT EXECUTED
shm_obj->size = size;
return 0;
107814: 2000 movs r0, #0 <== NOT EXECUTED
shm_obj->size = size;
107816: 606c str r4, [r5, #4] <== NOT EXECUTED
}
107818: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
return ENOMEM;
10781a: 200c movs r0, #12 <== NOT EXECUTED
}
10781c: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
10781e: bf00 nop
00106c6c <_POSIX_Shm_Object_mmap_from_heap>:
POSIX_Shm_Object *shm_obj,
size_t len,
int prot,
off_t off
)
{
106c6c: b430 push {r4, r5}
if ( shm_obj == NULL || shm_obj->handle == NULL )
106c6e: 4603 mov r3, r0
{
106c70: e9dd 4202 ldrd r4, r2, [sp, #8]
if ( shm_obj == NULL || shm_obj->handle == NULL )
106c74: b170 cbz r0, 106c94 <_POSIX_Shm_Object_mmap_from_heap+0x28>
106c76: 6800 ldr r0, [r0, #0]
106c78: b150 cbz r0, 106c90 <_POSIX_Shm_Object_mmap_from_heap+0x24>
return 0;
/* This is already checked by mmap. Maybe make it a debug assert? */
if ( shm_obj->size < len + off ) {
106c7a: 685d ldr r5, [r3, #4]
106c7c: 1909 adds r1, r1, r4
106c7e: f142 0200 adc.w r2, r2, #0
106c82: 2300 movs r3, #0
106c84: 428d cmp r5, r1
106c86: eb73 0202 sbcs.w r2, r3, r2
return NULL;
}
return (char*)shm_obj->handle + off;
106c8a: bfa8 it ge
106c8c: 1900 addge r0, r0, r4
if ( shm_obj->size < len + off ) {
106c8e: db01 blt.n 106c94 <_POSIX_Shm_Object_mmap_from_heap+0x28> <== ALWAYS TAKEN
}
106c90: bc30 pop {r4, r5}
106c92: 4770 bx lr
return 0;
106c94: 4618 mov r0, r3 <== NOT EXECUTED
}
106c96: bc30 pop {r4, r5} <== NOT EXECUTED
106c98: 4770 bx lr <== NOT EXECUTED
106c9a: bf00 nop
001078a8 <_POSIX_Shm_Object_mmap_from_workspace>:
POSIX_Shm_Object *shm_obj,
size_t len,
int prot,
off_t off
)
{
1078a8: b430 push {r4, r5}
if ( shm_obj == NULL || shm_obj->handle == NULL )
1078aa: 4603 mov r3, r0
{
1078ac: e9dd 4202 ldrd r4, r2, [sp, #8]
if ( shm_obj == NULL || shm_obj->handle == NULL )
1078b0: b170 cbz r0, 1078d0 <_POSIX_Shm_Object_mmap_from_workspace+0x28>
1078b2: 6800 ldr r0, [r0, #0]
1078b4: b150 cbz r0, 1078cc <_POSIX_Shm_Object_mmap_from_workspace+0x24>
return 0;
/* This is already checked by mmap. Maybe make it a debug assert? */
if ( shm_obj->size < len + off ) {
1078b6: 685d ldr r5, [r3, #4]
1078b8: 1909 adds r1, r1, r4
1078ba: f142 0200 adc.w r2, r2, #0
1078be: 2300 movs r3, #0
1078c0: 428d cmp r5, r1
1078c2: eb73 0202 sbcs.w r2, r3, r2
return NULL;
}
return (char*)shm_obj->handle + off;
1078c6: bfa8 it ge
1078c8: 1900 addge r0, r0, r4
if ( shm_obj->size < len + off ) {
1078ca: db01 blt.n 1078d0 <_POSIX_Shm_Object_mmap_from_workspace+0x28> <== ALWAYS TAKEN
}
1078cc: bc30 pop {r4, r5}
1078ce: 4770 bx lr
return 0;
1078d0: 4618 mov r0, r3 <== NOT EXECUTED
}
1078d2: bc30 pop {r4, r5} <== NOT EXECUTED
1078d4: 4770 bx lr <== NOT EXECUTED
1078d6: bf00 nop
00106c48 <_POSIX_Shm_Object_read_from_heap>:
POSIX_Shm_Object *shm_obj,
void *buf,
size_t count
)
{
if ( shm_obj == NULL || shm_obj->handle == NULL )
106c48: b178 cbz r0, 106c6a <_POSIX_Shm_Object_read_from_heap+0x22> <== NOT EXECUTED
106c4a: 468c mov ip, r1 <== NOT EXECUTED
106c4c: 6801 ldr r1, [r0, #0] <== NOT EXECUTED
106c4e: b151 cbz r1, 106c66 <_POSIX_Shm_Object_read_from_heap+0x1e> <== NOT EXECUTED
{
106c50: b510 push {r4, lr} <== NOT EXECUTED
106c52: 6844 ldr r4, [r0, #4] <== NOT EXECUTED
if ( shm_obj->size < count ) {
count = shm_obj->size;
}
memcpy( buf, shm_obj->handle, count );
106c54: 4660 mov r0, ip <== NOT EXECUTED
106c56: 4294 cmp r4, r2 <== NOT EXECUTED
106c58: bf28 it cs <== NOT EXECUTED
106c5a: 4614 movcs r4, r2 <== NOT EXECUTED
106c5c: 4622 mov r2, r4 <== NOT EXECUTED
106c5e: f006 ee10 blx 10d880 <memcpy> <== NOT EXECUTED
return count;
106c62: 4620 mov r0, r4 <== NOT EXECUTED
}
106c64: bd10 pop {r4, pc} <== NOT EXECUTED
return 0;
106c66: 4608 mov r0, r1 <== NOT EXECUTED
}
106c68: 4770 bx lr <== NOT EXECUTED
106c6a: 4770 bx lr <== NOT EXECUTED
00107884 <_POSIX_Shm_Object_read_from_workspace>:
POSIX_Shm_Object *shm_obj,
void *buf,
size_t count
)
{
if ( shm_obj == NULL || shm_obj->handle == NULL )
107884: b178 cbz r0, 1078a6 <_POSIX_Shm_Object_read_from_workspace+0x22>
107886: 468c mov ip, r1
107888: 6801 ldr r1, [r0, #0]
10788a: b151 cbz r1, 1078a2 <_POSIX_Shm_Object_read_from_workspace+0x1e>
{
10788c: b510 push {r4, lr}
10788e: 6844 ldr r4, [r0, #4]
if ( shm_obj->size < count ) {
count = shm_obj->size;
}
memcpy( buf, shm_obj->handle, count );
107890: 4660 mov r0, ip
107892: 4294 cmp r4, r2
107894: bf28 it cs
107896: 4614 movcs r4, r2
107898: 4622 mov r2, r4
10789a: f006 ebf2 blx 10e080 <memcpy>
return count;
10789e: 4620 mov r0, r4
}
1078a0: bd10 pop {r4, pc}
return 0;
1078a2: 4608 mov r0, r1 <== NOT EXECUTED
}
1078a4: 4770 bx lr <== NOT EXECUTED
1078a6: 4770 bx lr <== NOT EXECUTED
00106c08 <_POSIX_Shm_Object_resize_from_heap>:
int _POSIX_Shm_Object_resize_from_heap(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
106c08: b538 push {r3, r4, r5, lr}
106c0a: 4604 mov r4, r0
void *p;
int err = 0;
if ( size < shm_obj->size ) {
/* zero out if shrinking */
p = (void*)((uintptr_t)shm_obj->handle + (uintptr_t)size);
106c0c: e9d0 0200 ldrd r0, r2, [r0]
{
106c10: 460d mov r5, r1
if ( size < shm_obj->size ) {
106c12: 428a cmp r2, r1
106c14: d80a bhi.n 106c2c <_POSIX_Shm_Object_resize_from_heap+0x24> <== ALWAYS TAKEN
memset( p, 0, shm_obj->size - size );
}
p = realloc( shm_obj->handle, size );
106c16: 4629 mov r1, r5
106c18: f002 ff30 bl 109a7c <realloc>
if ( p != NULL ) {
106c1c: b190 cbz r0, 106c44 <_POSIX_Shm_Object_resize_from_heap+0x3c>
shm_obj->handle = p;
if ( size > shm_obj->size ) {
106c1e: 6862 ldr r2, [r4, #4]
shm_obj->handle = p;
106c20: 6020 str r0, [r4, #0]
if ( size > shm_obj->size ) {
106c22: 42aa cmp r2, r5
106c24: d309 bcc.n 106c3a <_POSIX_Shm_Object_resize_from_heap+0x32> <== NEVER TAKEN
int err = 0;
106c26: 2000 movs r0, #0
/* initialize added memory */
memset( p, 0, size - shm_obj->size );
}
shm_obj->size = size;
106c28: 6065 str r5, [r4, #4]
} else {
err = EIO;
}
return err;
}
106c2a: bd38 pop {r3, r4, r5, pc}
memset( p, 0, shm_obj->size - size );
106c2c: 4408 add r0, r1 <== NOT EXECUTED
106c2e: 1a52 subs r2, r2, r1 <== NOT EXECUTED
106c30: 2100 movs r1, #0 <== NOT EXECUTED
106c32: f007 f895 bl 10dd60 <memset> <== NOT EXECUTED
p = realloc( shm_obj->handle, size );
106c36: 6820 ldr r0, [r4, #0] <== NOT EXECUTED
106c38: e7ed b.n 106c16 <_POSIX_Shm_Object_resize_from_heap+0xe> <== NOT EXECUTED
memset( p, 0, size - shm_obj->size );
106c3a: 1aaa subs r2, r5, r2
106c3c: 2100 movs r1, #0
106c3e: f007 f88f bl 10dd60 <memset>
106c42: e7f0 b.n 106c26 <_POSIX_Shm_Object_resize_from_heap+0x1e>
err = EIO;
106c44: 2005 movs r0, #5 <== NOT EXECUTED
}
106c46: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
0010783c <_POSIX_Shm_Object_resize_from_workspace>:
int _POSIX_Shm_Object_resize_from_workspace(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
10783c: b570 push {r4, r5, r6, lr}
10783e: 4604 mov r4, r0
int err;
if ( size == 0 ) {
107840: 460d mov r5, r1
memset( shm_obj->handle, 0, shm_obj->size );
107842: 6800 ldr r0, [r0, #0]
if ( size == 0 ) {
107844: b189 cbz r1, 10786a <_POSIX_Shm_Object_resize_from_workspace+0x2e>
err = _POSIX_Shm_Object_delete_from_workspace( shm_obj );
} else if ( shm_obj->handle == NULL && shm_obj->size == 0 ) {
107846: b108 cbz r0, 10784c <_POSIX_Shm_Object_resize_from_workspace+0x10>
err = _POSIX_Shm_Object_create_from_workspace( shm_obj, size );
} else {
/* Refuse to resize a workspace object. */
err = EIO;
107848: 2005 movs r0, #5 <== NOT EXECUTED
}
return err;
}
10784a: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
} else if ( shm_obj->handle == NULL && shm_obj->size == 0 ) {
10784c: 6866 ldr r6, [r4, #4]
10784e: 2e00 cmp r6, #0
107850: d1fa bne.n 107848 <_POSIX_Shm_Object_resize_from_workspace+0xc> <== ALWAYS TAKEN
shm_obj->handle = _Workspace_Allocate( size );
107852: 4608 mov r0, r1
107854: f002 f890 bl 109978 <_Workspace_Allocate>
107858: 6020 str r0, [r4, #0]
if ( shm_obj->handle == NULL ) {
10785a: b180 cbz r0, 10787e <_POSIX_Shm_Object_resize_from_workspace+0x42>
memset( shm_obj->handle, 0, size );
10785c: 462a mov r2, r5
10785e: 4631 mov r1, r6
107860: f006 fe7e bl 10e560 <memset>
return 0;
107864: 4630 mov r0, r6
shm_obj->size = size;
107866: 6065 str r5, [r4, #4]
}
107868: bd70 pop {r4, r5, r6, pc}
memset( shm_obj->handle, 0, shm_obj->size );
10786a: 6862 ldr r2, [r4, #4] <== NOT EXECUTED
10786c: f006 fe78 bl 10e560 <memset> <== NOT EXECUTED
_Workspace_Free( shm_obj->handle );
107870: 6820 ldr r0, [r4, #0] <== NOT EXECUTED
107872: f002 f88b bl 10998c <_Workspace_Free> <== NOT EXECUTED
err = _POSIX_Shm_Object_delete_from_workspace( shm_obj );
107876: 4628 mov r0, r5 <== NOT EXECUTED
shm_obj->size = 0;
107878: e9c4 5500 strd r5, r5, [r4] <== NOT EXECUTED
}
10787c: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
return ENOMEM;
10787e: 200c movs r0, #12 <== NOT EXECUTED
}
107880: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
107882: bf00 nop
00107f64 <_POSIX_Threads_Sporadic_budget_callout>:
{
107f64: b530 push {r4, r5, lr}
107f66: 2300 movs r3, #0
107f68: b08b sub sp, #44 ; 0x2c
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
107f6a: f8d0 1160 ldr.w r1, [r0, #352] ; 0x160
107f6e: 9306 str r3, [sp, #24]
107f70: f3ef 8300 mrs r3, CPSR
107f74: f043 0280 orr.w r2, r3, #128 ; 0x80
107f78: f382 8900 msr CPSR_fc, r2
107f7c: 9301 str r3, [sp, #4]
if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
107f7e: 6b4b ldr r3, [r1, #52] ; 0x34
the_thread->cpu_time_budget = UINT32_MAX;
107f80: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
107f84: f8c0 208c str.w r2, [r0, #140] ; 0x8c
if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
107f88: 4293 cmp r3, r2
107f8a: bf18 it ne
107f8c: ad01 addne r5, sp, #4
107f8e: d007 beq.n 107fa0 <_POSIX_Threads_Sporadic_budget_callout+0x3c> <== NEVER TAKEN
__asm__ volatile (
107f90: 9b01 ldr r3, [sp, #4]
107f92: f383 8900 msr CPSR_fc, r3
_Thread_Priority_update( &queue_context );
107f96: 4628 mov r0, r5
107f98: f001 fa3a bl 109410 <_Thread_Priority_update>
}
107f9c: b00b add sp, #44 ; 0x2c
107f9e: bd30 pop {r4, r5, pc}
_Thread_Priority_add(
107fa0: ad01 add r5, sp, #4
107fa2: 4604 mov r4, r0
107fa4: 462a mov r2, r5
107fa6: 3128 adds r1, #40 ; 0x28
107fa8: f001 f9ec bl 109384 <_Thread_Priority_add>
_Thread_Priority_remove(
107fac: 462a mov r2, r5
107fae: f104 0120 add.w r1, r4, #32
107fb2: 4620 mov r0, r4
107fb4: f001 fa08 bl 1093c8 <_Thread_Priority_remove>
107fb8: e7ea b.n 107f90 <_POSIX_Threads_Sporadic_budget_callout+0x2c>
107fba: bf00 nop
00107c10 <_POSIX_Threads_Sporadic_timer>:
{
107c10: b5f0 push {r4, r5, r6, r7, lr}
queue_context->Priority.update_count = 0;
107c12: 2300 movs r3, #0
107c14: b08b sub sp, #44 ; 0x2c
the_thread = api->Sporadic.thread;
107c16: f850 6c08 ldr.w r6, [r0, #-8]
api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic.Timer );
107c1a: f1a0 0408 sub.w r4, r0, #8
107c1e: 9306 str r3, [sp, #24]
__asm__ volatile (
107c20: f3ef 8300 mrs r3, CPSR
107c24: f043 0280 orr.w r2, r3, #128 ; 0x80
107c28: f382 8900 msr CPSR_fc, r2
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 );
107c2c: 9301 str r3, [sp, #4]
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
107c2e: 6b63 ldr r3, [r4, #52] ; 0x34
107c30: 3301 adds r3, #1
107c32: bf08 it eq
107c34: af01 addeq r7, sp, #4
107c36: d010 beq.n 107c5a <_POSIX_Threads_Sporadic_timer+0x4a>
_Thread_Priority_add(
107c38: af01 add r7, sp, #4
107c3a: 4605 mov r5, r0
107c3c: 463a mov r2, r7
107c3e: f106 0120 add.w r1, r6, #32
107c42: 4630 mov r0, r6
107c44: f001 fb9e bl 109384 <_Thread_Priority_add>
_Thread_Priority_remove(
107c48: 463a mov r2, r7
107c4a: f105 0120 add.w r1, r5, #32
107c4e: 4630 mov r0, r6
107c50: f001 fbba bl 1093c8 <_Thread_Priority_remove>
107c54: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
107c58: 6363 str r3, [r4, #52] ; 0x34
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
107c5a: f104 0508 add.w r5, r4, #8
107c5e: 4813 ldr r0, [pc, #76] ; (107cac <_POSIX_Threads_Sporadic_timer+0x9c>)
107c60: 4629 mov r1, r5
107c62: f002 ff27 bl 10aab4 <_Watchdog_Remove>
Thread_Control *the_thread,
POSIX_API_Control *api
)
{
the_thread->cpu_time_budget =
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
107c66: f104 0050 add.w r0, r4, #80 ; 0x50
107c6a: f002 fdab bl 10a7c4 <_Timespec_To_ticks>
the_thread->cpu_time_budget =
107c6e: f8c6 008c str.w r0, [r6, #140] ; 0x8c
_Watchdog_Per_CPU_insert_ticks(
107c72: f104 0040 add.w r0, r4, #64 ; 0x40
107c76: f002 fda5 bl 10a7c4 <_Timespec_To_ticks>
expire = ticks + cpu->Watchdog.ticks;
107c7a: f243 4c40 movw ip, #13376 ; 0x3440
_Watchdog_Insert(header, the_watchdog, expire);
107c7e: 4629 mov r1, r5
expire = ticks + cpu->Watchdog.ticks;
107c80: f2c0 0c20 movt ip, #32
107c84: f8dc 2028 ldr.w r2, [ip, #40] ; 0x28
107c88: f8dc 302c ldr.w r3, [ip, #44] ; 0x2c
107c8c: 1882 adds r2, r0, r2
_Watchdog_Insert(header, the_watchdog, expire);
107c8e: f10c 0030 add.w r0, ip, #48 ; 0x30
107c92: f143 0300 adc.w r3, r3, #0
107c96: f002 fee5 bl 10aa64 <_Watchdog_Insert>
__asm__ volatile (
107c9a: 9b01 ldr r3, [sp, #4]
107c9c: f383 8900 msr CPSR_fc, r3
_Thread_Priority_update( &queue_context );
107ca0: 4638 mov r0, r7
107ca2: f001 fbb5 bl 109410 <_Thread_Priority_update>
}
107ca6: b00b add sp, #44 ; 0x2c
107ca8: bdf0 pop {r4, r5, r6, r7, pc}
107caa: bf00 nop
107cac: 00203470 .word 0x00203470
0010b818 <_POSIX_Timer_TSR>:
/*
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR( Watchdog_Control *the_watchdog )
{
10b818: b570 push {r4, r5, r6, lr}
POSIX_Timer_Control *ptimer;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu;
ptimer = RTEMS_CONTAINER_OF( the_watchdog, POSIX_Timer_Control, Timer );
10b81a: f1a0 0410 sub.w r4, r0, #16
__asm__ volatile (
10b81e: f3ef 8600 mrs r6, CPSR
10b822: f046 0380 orr.w r3, r6, #128 ; 0x80
10b826: f383 8900 msr CPSR_fc, r3
_ISR_lock_ISR_disable( &lock_context );
cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10b82a: 6f63 ldr r3, [r4, #116] ; 0x74
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10b82c: e9d4 1214 ldrd r1, r2, [r4, #80] ; 0x50
ptimer->overrun = ptimer->overrun + 1;
10b830: 3301 adds r3, #1
10b832: 6763 str r3, [r4, #116] ; 0x74
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10b834: ea51 0302 orrs.w r3, r1, r2
10b838: d101 bne.n 10b83e <_POSIX_Timer_TSR+0x26>
10b83a: 6da3 ldr r3, [r4, #88] ; 0x58
10b83c: b1fb cbz r3, 10b87e <_POSIX_Timer_TSR+0x66>
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10b83e: 2303 movs r3, #3
_Timecounter_Nanotime( tod );
10b840: f104 0078 add.w r0, r4, #120 ; 0x78
10b844: f884 3034 strb.w r3, [r4, #52] ; 0x34
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
_POSIX_Timer_Insert( ptimer, cpu, ptimer->ticks );
10b848: 6f25 ldr r5, [r4, #112] ; 0x70
10b84a: f7fd f9db bl 108c04 <_Timecounter_Nanotime>
cpu->Watchdog.ticks + ticks
10b84e: f241 1000 movw r0, #4352 ; 0x1100
_Watchdog_Insert(
10b852: f104 0110 add.w r1, r4, #16
cpu->Watchdog.ticks + ticks
10b856: f2c0 0021 movt r0, #33 ; 0x21
_Watchdog_Insert(
10b85a: 6a82 ldr r2, [r0, #40] ; 0x28
10b85c: 3030 adds r0, #48 ; 0x30
10b85e: f850 3c04 ldr.w r3, [r0, #-4]
10b862: 18aa adds r2, r5, r2
10b864: f143 0300 adc.w r3, r3, #0
10b868: f7ff fc78 bl 10b15c <_Watchdog_Insert>
__asm__ volatile (
10b86c: f386 8900 msr CPSR_fc, r6
/*
* 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 ) ) {
10b870: 6be1 ldr r1, [r4, #60] ; 0x3c
10b872: 6b20 ldr r0, [r4, #48] ; 0x30
10b874: f001 fb00 bl 10ce78 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10b878: 2300 movs r3, #0
10b87a: 6763 str r3, [r4, #116] ; 0x74
}
10b87c: bd70 pop {r4, r5, r6, pc}
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10b87e: 2304 movs r3, #4 <== NOT EXECUTED
10b880: f884 3034 strb.w r3, [r4, #52] ; 0x34 <== NOT EXECUTED
10b884: e7f2 b.n 10b86c <_POSIX_Timer_TSR+0x54> <== NOT EXECUTED
10b886: bf00 nop
00113f98 <_POSIX_signals_Clear_process_signals>:
_Assert( _ISR_Get_level() != 0 );
clear_signal = true;
mask = signo_to_mask( signo );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
113f98: eb00 0340 add.w r3, r0, r0, lsl #1
113f9c: f242 12b0 movw r2, #8624 ; 0x21b0
113fa0: f2c0 0220 movt r2, #32
113fa4: 009b lsls r3, r3, #2
113fa6: 3801 subs r0, #1
113fa8: 2101 movs r1, #1
113faa: 58d2 ldr r2, [r2, r3]
113fac: fa01 f000 lsl.w r0, r1, r0
113fb0: 2a02 cmp r2, #2
113fb2: d008 beq.n 113fc6 <_POSIX_signals_Clear_process_signals+0x2e>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
113fb4: f242 032c movw r3, #8236 ; 0x202c
113fb8: f2c0 0320 movt r3, #32
113fbc: 6819 ldr r1, [r3, #0]
113fbe: ea21 0000 bic.w r0, r1, r0
113fc2: 6018 str r0, [r3, #0]
}
}
113fc4: 4770 bx lr
return _Chain_Immutable_head( the_chain )->next;
113fc6: f242 0230 movw r2, #8240 ; 0x2030
return &the_chain->Tail.Node;
113fca: 1d19 adds r1, r3, #4
return _Chain_Immutable_head( the_chain )->next;
113fcc: f2c0 0220 movt r2, #32
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
113fd0: 589b ldr r3, [r3, r2]
return &the_chain->Tail.Node;
113fd2: 440a add r2, r1
113fd4: 4293 cmp r3, r2
113fd6: d0ed beq.n 113fb4 <_POSIX_signals_Clear_process_signals+0x1c> <== NEVER TAKEN
}
113fd8: 4770 bx lr <== NOT EXECUTED
113fda: bf00 nop
00113cfc <_POSIX_signals_Send>:
int _POSIX_signals_Send(
pid_t pid,
int sig,
const union sigval *value
)
{
113cfc: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
113d00: 4605 mov r5, r0
113d02: b087 sub sp, #28
113d04: 460c mov r4, r1
113d06: 4690 mov r8, r2
Per_CPU_Control *cpu_self;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
113d08: f7f1 f8ac bl 104e64 <getpid>
113d0c: 42a8 cmp r0, r5
113d0e: f040 80f7 bne.w 113f00 <_POSIX_signals_Send+0x204>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
113d12: 2c00 cmp r4, #0
113d14: f000 80ec beq.w 113ef0 <_POSIX_signals_Send+0x1f4>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
113d18: 1e65 subs r5, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
113d1a: 2d1f cmp r5, #31
113d1c: f200 80e8 bhi.w 113ef0 <_POSIX_signals_Send+0x1f4>
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 )
113d20: 0066 lsls r6, r4, #1
113d22: f242 17b0 movw r7, #8624 ; 0x21b0
113d26: f2c0 0720 movt r7, #32
113d2a: 1933 adds r3, r6, r4
113d2c: eb07 0383 add.w r3, r7, r3, lsl #2
113d30: 689b ldr r3, [r3, #8]
113d32: 2b01 cmp r3, #1
113d34: f000 80c8 beq.w 113ec8 <_POSIX_signals_Send+0x1cc>
/*
* 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 ) )
113d38: 1f23 subs r3, r4, #4
113d3a: f023 0304 bic.w r3, r3, #4
113d3e: 2b00 cmp r3, #0
113d40: bf18 it ne
113d42: 2c0b cmpne r4, #11
113d44: d06f beq.n 113e26 <_POSIX_signals_Send+0x12a>
return 1u << (sig - 1);
113d46: 2301 movs r3, #1
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
113d48: 9403 str r4, [sp, #12]
113d4a: fa03 f505 lsl.w r5, r3, r5
siginfo->si_code = SI_USER;
113d4e: 9304 str r3, [sp, #16]
if ( !value ) {
113d50: f1b8 0f00 cmp.w r8, #0
113d54: d06f beq.n 113e36 <_POSIX_signals_Send+0x13a>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
113d56: f8d8 3000 ldr.w r3, [r8]
113d5a: 9305 str r3, [sp, #20]
disable_level = cpu_self->thread_dispatch_disable_level;
113d5c: f641 7300 movw r3, #7936 ; 0x1f00
113d60: f2c0 0320 movt r3, #32
113d64: 691a ldr r2, [r3, #16]
113d66: 6998 ldr r0, [r3, #24]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
113d68: 3201 adds r2, #1
113d6a: 611a str r2, [r3, #16]
* 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 ) ) {
113d6c: f8d0 3160 ldr.w r3, [r0, #352] ; 0x160
113d70: 6e9b ldr r3, [r3, #104] ; 0x68
113d72: 421d tst r5, r3
113d74: d119 bne.n 113daa <_POSIX_signals_Send+0xae>
* 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;
113d76: f240 3368 movw r3, #872 ; 0x368
113d7a: f2c0 0320 movt r3, #32
113d7e: 681b ldr r3, [r3, #0]
if ( heads != NULL ) {
113d80: 2b00 cmp r3, #0
113d82: d05b beq.n 113e3c <_POSIX_signals_Send+0x140>
113d84: 469c mov ip, r3
113d86: f85c 3b04 ldr.w r3, [ip], #4
Chain_Control *the_chain = &heads->Heads.Fifo;
for ( the_node = _Chain_First( the_chain );
113d8a: 4563 cmp r3, ip
113d8c: d106 bne.n 113d9c <_POSIX_signals_Send+0xa0> <== NEVER TAKEN
113d8e: e055 b.n 113e3c <_POSIX_signals_Send+0x140> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (api->signals_unblocked & mask)
113d90: 6e8a ldr r2, [r1, #104] ; 0x68
113d92: 4215 tst r5, r2
113d94: d109 bne.n 113daa <_POSIX_signals_Send+0xae>
the_node = the_node->next ) {
113d96: 681b ldr r3, [r3, #0]
for ( the_node = _Chain_First( the_chain );
113d98: 4563 cmp r3, ip
113d9a: d04f beq.n 113e3c <_POSIX_signals_Send+0x140> <== NEVER TAKEN
return node->owner;
113d9c: f853 0c08 ldr.w r0, [r3, #-8]
if (the_thread->Wait.option & mask)
113da0: 6c82 ldr r2, [r0, #72] ; 0x48
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
113da2: f8d0 1160 ldr.w r1, [r0, #352] ; 0x160
if (the_thread->Wait.option & mask)
113da6: 4215 tst r5, r2
113da8: d0f2 beq.n 113d90 <_POSIX_signals_Send+0x94>
/*
* 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 ) ) {
113daa: aa03 add r2, sp, #12
113dac: 4621 mov r1, r4
113dae: f000 fa11 bl 1141d4 <_POSIX_signals_Unblock_thread>
113db2: bb70 cbnz r0, 113e12 <_POSIX_signals_Send+0x116>
/*
* 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 );
113db4: 4628 mov r0, r5
113db6: f000 f983 bl 1140c0 <_POSIX_signals_Set_process_signals>
__asm__ volatile (
113dba: f3ef 8c00 mrs ip, CPSR
113dbe: f04c 0380 orr.w r3, ip, #128 ; 0x80
113dc2: f383 8900 msr CPSR_fc, r3
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
113dc6: 4434 add r4, r6
113dc8: 00a4 lsls r4, r4, #2
113dca: 593b ldr r3, [r7, r4]
113dcc: 2b02 cmp r3, #2
113dce: d11e bne.n 113e0e <_POSIX_signals_Send+0x112>
return _Chain_Immutable_head( the_chain )->next;
113dd0: f242 0220 movw r2, #8224 ; 0x2020
113dd4: f2c0 0220 movt r2, #32
113dd8: 4611 mov r1, r2
113dda: f851 3b04 ldr.w r3, [r1], #4
if ( !_Chain_Is_empty(the_chain))
113dde: 428b cmp r3, r1
113de0: d076 beq.n 113ed0 <_POSIX_signals_Send+0x1d4>
new_first = old_first->next;
113de2: 461d mov r5, r3
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
_Chain_Append_unprotected(
113de4: f242 0130 movw r1, #8240 ; 0x2030
113de8: f855 0b08 ldr.w r0, [r5], #8
113dec: f2c0 0120 movt r1, #32
113df0: 1867 adds r7, r4, r1
return &the_chain->Tail.Node;
113df2: 3404 adds r4, #4
113df4: 440c add r4, r1
new_first->previous = head;
113df6: 6042 str r2, [r0, #4]
head->next = new_first;
113df8: 6010 str r0, [r2, #0]
psiginfo->Info = *siginfo;
113dfa: aa06 add r2, sp, #24
113dfc: e912 0007 ldmdb r2, {r0, r1, r2}
old_last = tail->previous;
113e00: 68be ldr r6, [r7, #8]
113e02: e885 0007 stmia.w r5, {r0, r1, r2}
the_node->next = tail;
113e06: 601c str r4, [r3, #0]
tail->previous = the_node;
113e08: 60bb str r3, [r7, #8]
old_last->next = the_node;
113e0a: 6033 str r3, [r6, #0]
the_node->previous = old_last;
113e0c: 605e str r6, [r3, #4]
__asm__ volatile (
113e0e: f38c 8900 msr CPSR_fc, ip
);
}
_POSIX_signals_Release( &queue_context );
DEBUG_STEP("\n");
_Thread_Dispatch_enable( cpu_self );
113e12: f641 7000 movw r0, #7936 ; 0x1f00
113e16: f2c0 0020 movt r0, #32
113e1a: f7f7 f8b1 bl 10af80 <_Thread_Dispatch_enable>
return 0;
113e1e: 2000 movs r0, #0
}
113e20: b007 add sp, #28
113e22: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return pthread_kill( pthread_self(), sig );
113e26: f7f4 f9f3 bl 108210 <pthread_self>
113e2a: 4621 mov r1, r4
}
113e2c: b007 add sp, #28
113e2e: e8bd 4ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
return pthread_kill( pthread_self(), sig );
113e32: f000 ba5d b.w 1142f0 <pthread_kill>
siginfo->si_value.sival_int = 0;
113e36: f8cd 8014 str.w r8, [sp, #20]
113e3a: e78f b.n 113d5c <_POSIX_signals_Send+0x60>
113e3c: f8df b0d4 ldr.w fp, [pc, #212] ; 113f14 <_POSIX_signals_Send+0x218>
{
113e40: f04f 38ff mov.w r8, #4294967295 ; 0xffffffff
113e44: 46c1 mov r9, r8
113e46: 2000 movs r0, #0
113e48: 46a2 mov sl, r4
113e4a: 46b6 mov lr, r6
the_info = _Objects_Information_table[ the_api ][ 1 ];
113e4c: f85b 3b04 ldr.w r3, [fp], #4
113e50: 685b ldr r3, [r3, #4]
if ( !the_info )
113e52: b383 cbz r3, 113eb6 <_POSIX_signals_Send+0x1ba>
return
113e54: 8819 ldrh r1, [r3, #0]
object_table = the_info->local_table;
113e56: 685a ldr r2, [r3, #4]
for ( index = 0 ; index < maximum ; ++index ) {
113e58: b369 cbz r1, 113eb6 <_POSIX_signals_Send+0x1ba>
113e5a: eb02 0c81 add.w ip, r2, r1, lsl #2
113e5e: 9701 str r7, [sp, #4]
113e60: e00f b.n 113e82 <_POSIX_signals_Send+0x186>
if ( interested && !_States_Is_ready( interested->current_state ) ) {
113e62: b160 cbz r0, 113e7e <_POSIX_signals_Send+0x182>
113e64: 69c6 ldr r6, [r0, #28]
113e66: b156 cbz r6, 113e7e <_POSIX_signals_Send+0x182>
if ( _States_Is_ready( the_thread->current_state ) ) {
113e68: 69df ldr r7, [r3, #28]
113e6a: b1f7 cbz r7, 113eaa <_POSIX_signals_Send+0x1ae>
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
113e6c: 00f6 lsls r6, r6, #3
113e6e: d406 bmi.n 113e7e <_POSIX_signals_Send+0x182>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
113e70: f007 5680 and.w r6, r7, #268435456 ; 0x10000000
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
113e74: 2e00 cmp r6, #0
113e76: bf1e ittt ne
113e78: 46a0 movne r8, r4
113e7a: 4689 movne r9, r1
113e7c: 4618 movne r0, r3
for ( index = 0 ; index < maximum ; ++index ) {
113e7e: 4594 cmp ip, r2
113e80: d018 beq.n 113eb4 <_POSIX_signals_Send+0x1b8>
the_thread = (Thread_Control *) object_table[ index ];
113e82: f852 3b04 ldr.w r3, [r2], #4
if ( !the_thread )
113e86: 2b00 cmp r3, #0
113e88: d0f9 beq.n 113e7e <_POSIX_signals_Send+0x182>
return aggregation->Node.priority;
113e8a: 6b99 ldr r1, [r3, #56] ; 0x38
113e8c: e9d1 4106 ldrd r4, r1, [r1, #24]
if ( _Thread_Get_priority( the_thread ) > interested_priority )
113e90: 45a0 cmp r8, r4
113e92: eb79 0601 sbcs.w r6, r9, r1
113e96: d3f2 bcc.n 113e7e <_POSIX_signals_Send+0x182>
if ( !_POSIX_signals_Is_interested( api, mask ) )
113e98: f8d3 6160 ldr.w r6, [r3, #352] ; 0x160
113e9c: 6eb6 ldr r6, [r6, #104] ; 0x68
113e9e: 4235 tst r5, r6
113ea0: d0ed beq.n 113e7e <_POSIX_signals_Send+0x182>
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
113ea2: 4544 cmp r4, r8
113ea4: eb71 0609 sbcs.w r6, r1, r9
113ea8: d2db bcs.n 113e62 <_POSIX_signals_Send+0x166>
for ( index = 0 ; index < maximum ; ++index ) {
113eaa: 4594 cmp ip, r2
113eac: 46a0 mov r8, r4
113eae: 4689 mov r9, r1
113eb0: 4618 mov r0, r3
113eb2: d1e6 bne.n 113e82 <_POSIX_signals_Send+0x186>
113eb4: 9f01 ldr r7, [sp, #4]
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
113eb6: 4b16 ldr r3, [pc, #88] ; (113f10 <_POSIX_signals_Send+0x214>)
113eb8: 459b cmp fp, r3
113eba: d1c7 bne.n 113e4c <_POSIX_signals_Send+0x150>
if ( interested ) {
113ebc: 4654 mov r4, sl
113ebe: 4676 mov r6, lr
113ec0: 2800 cmp r0, #0
113ec2: f47f af72 bne.w 113daa <_POSIX_signals_Send+0xae>
113ec6: e775 b.n 113db4 <_POSIX_signals_Send+0xb8>
return 0;
113ec8: 2000 movs r0, #0
}
113eca: b007 add sp, #28
113ecc: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
113ed0: f38c 8900 msr CPSR_fc, ip
_Thread_Dispatch_enable( cpu_self );
113ed4: f641 7000 movw r0, #7936 ; 0x1f00
113ed8: f2c0 0020 movt r0, #32
113edc: f7f7 f850 bl 10af80 <_Thread_Dispatch_enable>
rtems_set_errno_and_return_minus_one( EAGAIN );
113ee0: f00a fe26 bl 11eb30 <__errno>
113ee4: 220b movs r2, #11
113ee6: 4603 mov r3, r0
113ee8: 601a str r2, [r3, #0]
113eea: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
113eee: e797 b.n 113e20 <_POSIX_signals_Send+0x124>
rtems_set_errno_and_return_minus_one( EINVAL );
113ef0: f00a fe1e bl 11eb30 <__errno>
113ef4: 2216 movs r2, #22
113ef6: 4603 mov r3, r0
113ef8: 601a str r2, [r3, #0]
113efa: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
113efe: e78f b.n 113e20 <_POSIX_signals_Send+0x124>
rtems_set_errno_and_return_minus_one( ESRCH );
113f00: f00a fe16 bl 11eb30 <__errno>
113f04: 2203 movs r2, #3
113f06: 4603 mov r3, r0
113f08: 601a str r2, [r3, #0]
113f0a: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
113f0e: e787 b.n 113e20 <_POSIX_signals_Send+0x124>
113f10: 00132750 .word 0x00132750
113f14: 00132748 .word 0x00132748
001141d4 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
1141d4: b5f8 push {r3, r4, r5, r6, r7, lr}
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
1141d6: f44f 6c80 mov.w ip, #1024 ; 0x400
1141da: 69c6 ldr r6, [r0, #28]
1141dc: f2c1 0c00 movt ip, #4096 ; 0x1000
1141e0: 1e4b subs r3, r1, #1
1141e2: f04f 0e01 mov.w lr, #1
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1141e6: f8d0 5160 ldr.w r5, [r0, #352] ; 0x160
1141ea: fa0e f303 lsl.w r3, lr, r3
{
1141ee: 4604 mov r4, r0
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
1141f0: ea3c 0c06 bics.w ip, ip, r6
_Chain_Append_if_is_off_chain_unprotected(
1141f4: f105 0770 add.w r7, r5, #112 ; 0x70
1141f8: d01b beq.n 114232 <_POSIX_signals_Unblock_thread+0x5e>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( api->signals_unblocked & mask ) {
1141fa: 6eaa ldr r2, [r5, #104] ; 0x68
1141fc: 4213 tst r3, r2
1141fe: d001 beq.n 114204 <_POSIX_signals_Unblock_thread+0x30>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
114200: 00f3 lsls r3, r6, #3
114202: d45f bmi.n 1142c4 <_POSIX_signals_Unblock_thread+0xf0>
__asm__ volatile (
114204: f3ef 8200 mrs r2, CPSR
114208: f042 0380 orr.w r3, r2, #128 ; 0x80
11420c: f383 8900 msr CPSR_fc, r3
action->handler = handler;
114210: f244 1335 movw r3, #16693 ; 0x4135
if ( _Chain_Is_node_off_chain( the_node ) ) {
114214: 6f29 ldr r1, [r5, #112] ; 0x70
114216: f2c0 0311 movt r3, #17
cpu_self->dispatch_necessary = true;
11421a: 2001 movs r0, #1
11421c: 67ab str r3, [r5, #120] ; 0x78
11421e: f641 7300 movw r3, #7936 ; 0x1f00
114222: f2c0 0320 movt r3, #32
114226: 7518 strb r0, [r3, #20]
114228: b1e9 cbz r1, 114266 <_POSIX_signals_Unblock_thread+0x92>
__asm__ volatile (
11422a: f382 8900 msr CPSR_fc, r2
the_thread->Wait.return_code = STATUS_INTERRUPTED;
_Thread_queue_Extract_with_proxy( the_thread );
}
}
return _POSIX_signals_Unblock_thread_done( the_thread, api, false );
11422e: 2000 movs r0, #0
}
114230: bdf8 pop {r3, r4, r5, r6, r7, pc}
if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {
114232: 6c80 ldr r0, [r0, #72] ; 0x48
114234: 4203 tst r3, r0
114236: d123 bne.n 114280 <_POSIX_signals_Unblock_thread+0xac>
114238: 6ea8 ldr r0, [r5, #104] ; 0x68
11423a: 4203 tst r3, r0
11423c: d120 bne.n 114280 <_POSIX_signals_Unblock_thread+0xac>
__asm__ volatile (
11423e: f3ef 8200 mrs r2, CPSR
114242: f042 0380 orr.w r3, r2, #128 ; 0x80
114246: f383 8900 msr CPSR_fc, r3
11424a: f244 1335 movw r3, #16693 ; 0x4135
11424e: 6f29 ldr r1, [r5, #112] ; 0x70
114250: f2c0 0311 movt r3, #17
114254: 67ab str r3, [r5, #120] ; 0x78
114256: f641 7300 movw r3, #7936 ; 0x1f00
11425a: f2c0 0320 movt r3, #32
11425e: f883 e014 strb.w lr, [r3, #20]
114262: 2900 cmp r1, #0
114264: d1e1 bne.n 11422a <_POSIX_signals_Unblock_thread+0x56> <== ALWAYS TAKEN
old_last = tail->previous;
114266: f8d4 30e0 ldr.w r3, [r4, #224] ; 0xe0
return &the_chain->Tail.Node;
11426a: f104 01dc add.w r1, r4, #220 ; 0xdc
the_node->next = tail;
11426e: 6729 str r1, [r5, #112] ; 0x70
tail->previous = the_node;
114270: f8c4 70e0 str.w r7, [r4, #224] ; 0xe0
old_last->next = the_node;
114274: 601f str r7, [r3, #0]
the_node->previous = old_last;
114276: 676b str r3, [r5, #116] ; 0x74
__asm__ volatile (
114278: f382 8900 msr CPSR_fc, r2
return _POSIX_signals_Unblock_thread_done( the_thread, api, false );
11427c: 2000 movs r0, #0
11427e: e7d7 b.n 114230 <_POSIX_signals_Unblock_thread+0x5c>
the_thread->Wait.return_code = STATUS_INTERRUPTED;
114280: f240 430d movw r3, #1037 ; 0x40d
114284: 64e3 str r3, [r4, #76] ; 0x4c
the_info = (siginfo_t *) the_thread->Wait.return_argument;
114286: 6c23 ldr r3, [r4, #64] ; 0x40
if ( !info ) {
114288: b312 cbz r2, 1142d0 <_POSIX_signals_Unblock_thread+0xfc>
*the_info = *info;
11428a: ca07 ldmia r2, {r0, r1, r2}
11428c: e883 0007 stmia.w r3, {r0, r1, r2}
_Thread_queue_Extract_with_proxy( the_thread );
114290: 4620 mov r0, r4
114292: f7f7 f93f bl 10b514 <_Thread_queue_Extract_with_proxy>
__asm__ volatile (
114296: f3ef 8200 mrs r2, CPSR
11429a: f042 0380 orr.w r3, r2, #128 ; 0x80
11429e: f383 8900 msr CPSR_fc, r3
1142a2: f244 1335 movw r3, #16693 ; 0x4135
if ( _Chain_Is_node_off_chain( the_node ) ) {
1142a6: 6f29 ldr r1, [r5, #112] ; 0x70
1142a8: f2c0 0311 movt r3, #17
1142ac: 2001 movs r0, #1
1142ae: 67ab str r3, [r5, #120] ; 0x78
1142b0: f641 7300 movw r3, #7936 ; 0x1f00
1142b4: f2c0 0320 movt r3, #32
1142b8: 7518 strb r0, [r3, #20]
1142ba: b171 cbz r1, 1142da <_POSIX_signals_Unblock_thread+0x106>
__asm__ volatile (
1142bc: f382 8900 msr CPSR_fc, r2
return _POSIX_signals_Unblock_thread_done( the_thread, api, true );
1142c0: 2001 movs r0, #1
}
1142c2: bdf8 pop {r3, r4, r5, r6, r7, pc}
the_thread->Wait.return_code = STATUS_INTERRUPTED;
1142c4: f240 430d movw r3, #1037 ; 0x40d
1142c8: 64c3 str r3, [r0, #76] ; 0x4c
_Thread_queue_Extract_with_proxy( the_thread );
1142ca: f7f7 f923 bl 10b514 <_Thread_queue_Extract_with_proxy>
1142ce: e799 b.n 114204 <_POSIX_signals_Unblock_thread+0x30>
the_info->si_value.sival_int = 0;
1142d0: 609a str r2, [r3, #8]
the_info->si_code = SI_USER;
1142d2: 2201 movs r2, #1
the_info->si_signo = signo;
1142d4: 6019 str r1, [r3, #0]
the_info->si_code = SI_USER;
1142d6: 605a str r2, [r3, #4]
the_info->si_value.sival_int = 0;
1142d8: e7da b.n 114290 <_POSIX_signals_Unblock_thread+0xbc>
old_last = tail->previous;
1142da: f8d4 30e0 ldr.w r3, [r4, #224] ; 0xe0
return &the_chain->Tail.Node;
1142de: f104 01dc add.w r1, r4, #220 ; 0xdc
the_node->next = tail;
1142e2: 6729 str r1, [r5, #112] ; 0x70
tail->previous = the_node;
1142e4: f8c4 70e0 str.w r7, [r4, #224] ; 0xe0
old_last->next = the_node;
1142e8: 601f str r7, [r3, #0]
the_node->previous = old_last;
1142ea: 676b str r3, [r5, #116] ; 0x74
}
1142ec: e7e6 b.n 1142bc <_POSIX_signals_Unblock_thread+0xe8>
1142ee: bf00 nop
0010968c <aio_cancel>:
#include <errno.h>
#include <stdlib.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10968c: b5f8 push {r3, r4, r5, r6, r7, lr}
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);
10968e: f244 5518 movw r5, #17688 ; 0x4518
109692: f2c0 0520 movt r5, #32
{
109696: 4606 mov r6, r0
pthread_mutex_lock (&aio_request_queue.mutex);
109698: 4628 mov r0, r5
{
10969a: 460c mov r4, r1
pthread_mutex_lock (&aio_request_queue.mutex);
10969c: f001 faf6 bl 10ac8c <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
1096a0: 2101 movs r1, #1
1096a2: 4630 mov r0, r6
1096a4: f000 fc1e bl 109ee4 <fcntl>
1096a8: 2800 cmp r0, #0
1096aa: f2c0 8088 blt.w 1097be <aio_cancel+0x132>
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) {
1096ae: 2c00 cmp r4, #0
1096b0: d03d beq.n 10972e <aio_cancel+0xa2>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
1096b2: 6827 ldr r7, [r4, #0]
1096b4: 42b7 cmp r7, r6
1096b6: d178 bne.n 1097aa <aio_cancel+0x11e>
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);
1096b8: 2200 movs r2, #0
1096ba: 4639 mov r1, r7
1096bc: f105 00c0 add.w r0, r5, #192 ; 0xc0
1096c0: f000 fa04 bl 109acc <rtems_aio_search_fd>
if (r_chain == NULL) {
1096c4: 4606 mov r6, r0
1096c6: b9b8 cbnz r0, 1096f8 <aio_cancel+0x6c>
if (!rtems_chain_is_empty (idle_req_chain)) {
1096c8: f8d5 20cc ldr.w r2, [r5, #204] ; 0xcc
1096cc: f105 03d0 add.w r3, r5, #208 ; 0xd0
1096d0: 429a cmp r2, r3
1096d2: d024 beq.n 10971e <aio_cancel+0x92> <== ALWAYS TAKEN
r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0);
1096d4: 4602 mov r2, r0
1096d6: 4639 mov r1, r7
1096d8: f105 00cc add.w r0, r5, #204 ; 0xcc
1096dc: f000 f9f6 bl 109acc <rtems_aio_search_fd>
if (r_chain == NULL) {
1096e0: 2800 cmp r0, #0
1096e2: d062 beq.n 1097aa <aio_cancel+0x11e>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
1096e4: 4621 mov r1, r4
1096e6: 3008 adds r0, #8
1096e8: f000 fa6c bl 109bc4 <rtems_aio_remove_req>
1096ec: 4604 mov r4, r0
pthread_mutex_unlock (&aio_request_queue.mutex);
1096ee: 4628 mov r0, r5
1096f0: f001 fbc4 bl 10ae7c <pthread_mutex_unlock>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
1096f4: 4620 mov r0, r4
1096f6: bdf8 pop {r3, r4, r5, r6, r7, pc}
pthread_mutex_lock (&r_chain->mutex);
1096f8: f100 0720 add.w r7, r0, #32
1096fc: 4638 mov r0, r7
1096fe: f001 fac5 bl 10ac8c <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
109702: 4621 mov r1, r4
109704: f106 0008 add.w r0, r6, #8
109708: f000 fa5c bl 109bc4 <rtems_aio_remove_req>
10970c: 4604 mov r4, r0
pthread_mutex_unlock (&r_chain->mutex);
10970e: 4638 mov r0, r7
109710: f001 fbb4 bl 10ae7c <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
109714: 4628 mov r0, r5
109716: f001 fbb1 bl 10ae7c <pthread_mutex_unlock>
}
10971a: 4620 mov r0, r4
10971c: bdf8 pop {r3, r4, r5, r6, r7, pc}
pthread_mutex_unlock(&aio_request_queue.mutex);
10971e: f244 5018 movw r0, #17688 ; 0x4518
return AIO_ALLDONE;
109722: 2402 movs r4, #2
pthread_mutex_unlock(&aio_request_queue.mutex);
109724: f2c0 0020 movt r0, #32
109728: f001 fba8 bl 10ae7c <pthread_mutex_unlock>
return AIO_ALLDONE;
10972c: e7e2 b.n 1096f4 <aio_cancel+0x68>
r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0);
10972e: 4622 mov r2, r4
109730: 4631 mov r1, r6
109732: f105 00c0 add.w r0, r5, #192 ; 0xc0
109736: f000 f9c9 bl 109acc <rtems_aio_search_fd>
if (r_chain == NULL) {
10973a: 4607 mov r7, r0
10973c: bb18 cbnz r0, 109786 <aio_cancel+0xfa>
if (!rtems_chain_is_empty (idle_req_chain)) {
10973e: f8d5 20cc ldr.w r2, [r5, #204] ; 0xcc
109742: f105 03d0 add.w r3, r5, #208 ; 0xd0
109746: 429a cmp r2, r3
109748: d0e9 beq.n 10971e <aio_cancel+0x92> <== ALWAYS TAKEN
r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0);
10974a: 4602 mov r2, r0
10974c: 4631 mov r1, r6
10974e: f105 00cc add.w r0, r5, #204 ; 0xcc
109752: f000 f9bb bl 109acc <rtems_aio_search_fd>
if (r_chain == NULL) {
109756: 4604 mov r4, r0
109758: 2800 cmp r0, #0
10975a: d0e0 beq.n 10971e <aio_cancel+0x92>
rtems_chain_extract (&r_chain->next_fd);
10975c: f002 f820 bl 10b7a0 <rtems_chain_extract>
rtems_aio_remove_fd (r_chain);
109760: 4620 mov r0, r4
109762: f000 fa15 bl 109b90 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
109766: f104 0020 add.w r0, r4, #32
10976a: f001 fa0b bl 10ab84 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10976e: f104 0060 add.w r0, r4, #96 ; 0x60
109772: f001 f8af bl 10a8d4 <pthread_cond_destroy>
free (r_chain);
109776: 4620 mov r0, r4
return AIO_CANCELED;
109778: 463c mov r4, r7
free (r_chain);
10977a: f7fb faaf bl 104cdc <free>
pthread_mutex_unlock (&aio_request_queue.mutex);
10977e: 4628 mov r0, r5
109780: f001 fb7c bl 10ae7c <pthread_mutex_unlock>
return AIO_CANCELED;
109784: e7b6 b.n 1096f4 <aio_cancel+0x68>
pthread_mutex_lock (&r_chain->mutex);
109786: f100 0620 add.w r6, r0, #32
10978a: 4630 mov r0, r6
10978c: f001 fa7e bl 10ac8c <pthread_mutex_lock>
rtems_chain_extract (&r_chain->next_fd);
109790: 4638 mov r0, r7
109792: f002 f805 bl 10b7a0 <rtems_chain_extract>
rtems_aio_remove_fd (r_chain);
109796: 4638 mov r0, r7
109798: f000 f9fa bl 109b90 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10979c: 4630 mov r0, r6
10979e: f001 fb6d bl 10ae7c <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
1097a2: 4628 mov r0, r5
1097a4: f001 fb6a bl 10ae7c <pthread_mutex_unlock>
return AIO_CANCELED;
1097a8: e7a4 b.n 1096f4 <aio_cancel+0x68>
pthread_mutex_unlock (&aio_request_queue.mutex);
1097aa: 4628 mov r0, r5
rtems_set_errno_and_return_minus_one (EINVAL);
1097ac: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
pthread_mutex_unlock (&aio_request_queue.mutex);
1097b0: f001 fb64 bl 10ae7c <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
1097b4: f004 feea bl 10e58c <__errno>
1097b8: 2316 movs r3, #22
1097ba: 6003 str r3, [r0, #0]
1097bc: e79a b.n 1096f4 <aio_cancel+0x68>
pthread_mutex_unlock(&aio_request_queue.mutex);
1097be: 4628 mov r0, r5
rtems_set_errno_and_return_minus_one (EBADF);
1097c0: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
pthread_mutex_unlock(&aio_request_queue.mutex);
1097c4: f001 fb5a bl 10ae7c <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
1097c8: f004 fee0 bl 10e58c <__errno>
1097cc: 2309 movs r3, #9
1097ce: 6003 str r3, [r0, #0]
1097d0: e790 b.n 1096f4 <aio_cancel+0x68>
1097d2: bf00 nop
001097d8 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
1097d8: f5b0 5f00 cmp.w r0, #8192 ; 0x2000
{
1097dc: b538 push {r3, r4, r5, lr}
1097de: 460c mov r4, r1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
1097e0: bf18 it ne
1097e2: 2516 movne r5, #22
if (op != O_SYNC)
1097e4: d116 bne.n 109814 <aio_fsync+0x3c>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
1097e6: 6808 ldr r0, [r1, #0]
1097e8: 2103 movs r1, #3
1097ea: f000 fb7b bl 109ee4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
1097ee: f000 0003 and.w r0, r0, #3
1097f2: 3801 subs r0, #1
1097f4: 2801 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
1097f6: bf88 it hi
1097f8: 2509 movhi r5, #9
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
1097fa: d80b bhi.n 109814 <aio_fsync+0x3c>
req = malloc (sizeof (rtems_aio_request));
1097fc: 2018 movs r0, #24
1097fe: f7fb fb67 bl 104ed0 <malloc>
if (req == NULL)
109802: b130 cbz r0, 109812 <aio_fsync+0x3a>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
109804: 2203 movs r2, #3
req->aiocbp = aiocbp;
109806: 6144 str r4, [r0, #20]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
109808: 6322 str r2, [r4, #48] ; 0x30
return rtems_aio_enqueue (req);
}
10980a: e8bd 4038 ldmia.w sp!, {r3, r4, r5, lr}
return rtems_aio_enqueue (req);
10980e: f000 b9f9 b.w 109c04 <rtems_aio_enqueue>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
109812: 250b movs r5, #11 <== NOT EXECUTED
109814: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
109818: e9c4 530d strd r5, r3, [r4, #52] ; 0x34
10981c: f004 feb6 bl 10e58c <__errno>
109820: 6005 str r5, [r0, #0]
}
109822: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
109826: bd38 pop {r3, r4, r5, pc}
00109d74 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
109d74: b538 push {r3, r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
109d76: 2103 movs r1, #3
{
109d78: 4604 mov r4, r0
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
109d7a: 6800 ldr r0, [r0, #0]
109d7c: f000 f8b2 bl 109ee4 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
109d80: 07c3 lsls r3, r0, #31
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
109d82: bf48 it mi
109d84: 2509 movmi r5, #9
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
109d86: d410 bmi.n 109daa <aio_read+0x36>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
109d88: 69a3 ldr r3, [r4, #24]
109d8a: b96b cbnz r3, 109da8 <aio_read+0x34>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
109d8c: 68e3 ldr r3, [r4, #12]
109d8e: 2b00 cmp r3, #0
109d90: db0a blt.n 109da8 <aio_read+0x34>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
109d92: 2018 movs r0, #24
109d94: f7fb f89c bl 104ed0 <malloc>
if (req == NULL)
109d98: b188 cbz r0, 109dbe <aio_read+0x4a>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
109d9a: 2201 movs r2, #1
req->aiocbp = aiocbp;
109d9c: 6144 str r4, [r0, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
109d9e: 6322 str r2, [r4, #48] ; 0x30
return rtems_aio_enqueue (req);
}
109da0: e8bd 4038 ldmia.w sp!, {r3, r4, r5, lr}
return rtems_aio_enqueue (req);
109da4: f7ff bf2e b.w 109c04 <rtems_aio_enqueue>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
109da8: 2516 movs r5, #22
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
109daa: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
109dae: e9c4 530d strd r5, r3, [r4, #52] ; 0x34
109db2: f004 fbeb bl 10e58c <__errno>
109db6: 6005 str r5, [r0, #0]
}
109db8: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
109dbc: bd38 pop {r3, r4, r5, pc}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
109dbe: 250b movs r5, #11 <== NOT EXECUTED
109dc0: e7f3 b.n 109daa <aio_read+0x36> <== NOT EXECUTED
109dc2: bf00 nop
00109dc8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
109dc8: b538 push {r3, r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
109dca: 2103 movs r1, #3
{
109dcc: 4604 mov r4, r0
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
109dce: 6800 ldr r0, [r0, #0]
109dd0: f000 f888 bl 109ee4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
109dd4: f000 0003 and.w r0, r0, #3
109dd8: 3801 subs r0, #1
109dda: 2801 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
109ddc: bf88 it hi
109dde: 2509 movhi r5, #9
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
109de0: d810 bhi.n 109e04 <aio_write+0x3c>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
109de2: 69a3 ldr r3, [r4, #24]
109de4: b96b cbnz r3, 109e02 <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
109de6: 68e3 ldr r3, [r4, #12]
109de8: 2b00 cmp r3, #0
109dea: db0a blt.n 109e02 <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
109dec: 2018 movs r0, #24
109dee: f7fb f86f bl 104ed0 <malloc>
if (req == NULL)
109df2: b188 cbz r0, 109e18 <aio_write+0x50>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
109df4: 2202 movs r2, #2
req->aiocbp = aiocbp;
109df6: 6144 str r4, [r0, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
109df8: 6322 str r2, [r4, #48] ; 0x30
return rtems_aio_enqueue (req);
}
109dfa: e8bd 4038 ldmia.w sp!, {r3, r4, r5, lr}
return rtems_aio_enqueue (req);
109dfe: f7ff bf01 b.w 109c04 <rtems_aio_enqueue>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
109e02: 2516 movs r5, #22
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
109e04: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
109e08: e9c4 530d strd r5, r3, [r4, #52] ; 0x34
109e0c: f004 fbbe bl 10e58c <__errno>
109e10: 6005 str r5, [r0, #0]
}
109e12: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
109e16: bd38 pop {r3, r4, r5, pc}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
109e18: 250b movs r5, #11 <== NOT EXECUTED
109e1a: e7f3 b.n 109e04 <aio_write+0x3c> <== NOT EXECUTED
0010aaa0 <alarm>:
);
unsigned int alarm(
unsigned int seconds
)
{
10aaa0: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
10aaa4: 4604 mov r4, r0
uint64_t now;
uint32_t ticks_per_second;
uint32_t ticks;
the_watchdog = &_POSIX_signals_Alarm_watchdog;
ticks_per_second = TOD_TICKS_PER_SECOND;
10aaa6: f001 f9b7 bl 10be18 <TOD_TICKS_PER_SECOND_method>
ticks = seconds * ticks_per_second;
10aaaa: fb00 f404 mul.w r4, r0, r4
ticks_per_second = TOD_TICKS_PER_SECOND;
10aaae: 4606 mov r6, r0
__asm__ volatile (
10aab0: f3ef 8800 mrs r8, CPSR
10aab4: f048 0380 orr.w r3, r8, #128 ; 0x80
10aab8: f383 8900 msr CPSR_fc, r3
&lock_context
);
cpu = _Watchdog_Get_CPU( the_watchdog );
_Watchdog_Per_CPU_acquire_critical( cpu, &lock_context2 );
now = cpu->Watchdog.ticks;
10aabc: f642 2380 movw r3, #10880 ; 0x2a80
expire = the_watchdog->expire;
10aac0: f240 2cd0 movw ip, #720 ; 0x2d0
10aac4: f2c0 0320 movt r3, #32
10aac8: f2c0 0c20 movt ip, #32
10aacc: e9d3 790a ldrd r7, r9, [r3, #40] ; 0x28
10aad0: e9dc 5306 ldrd r5, r3, [ip, #24]
if ( now < expire ) {
10aad4: 42af cmp r7, r5
10aad6: eb79 0303 sbcs.w r3, r9, r3
10aada: bf28 it cs
10aadc: 2500 movcs r5, #0
10aade: d200 bcs.n 10aae2 <alarm+0x42>
remaining = (unsigned long) _Watchdog_Cancel(
10aae0: 1bed subs r5, r5, r7
_Watchdog_Remove( header, the_watchdog );
10aae2: f240 21d0 movw r1, #720 ; 0x2d0
10aae6: 480d ldr r0, [pc, #52] ; (10ab1c <alarm+0x7c>)
10aae8: f2c0 0120 movt r1, #32
10aaec: f7ff fdce bl 10a68c <_Watchdog_Remove>
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ],
the_watchdog,
now
);
if ( ticks != 0 ) {
10aaf0: b944 cbnz r4, 10ab04 <alarm+0x64>
__asm__ volatile (
10aaf2: f388 8900 msr CPSR_fc, r8
_ISR_lock_Release_and_ISR_enable(
&_POSIX_signals_Alarm_lock,
&lock_context
);
return ( remaining + ticks_per_second - 1 ) / ticks_per_second;
10aaf6: 1e70 subs r0, r6, #1
10aaf8: 4631 mov r1, r6
10aafa: 4428 add r0, r5
10aafc: f003 fac0 bl 10e080 <__udivsi3>
}
10ab00: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
_Watchdog_Insert(
10ab04: 19e2 adds r2, r4, r7
10ab06: f240 21d0 movw r1, #720 ; 0x2d0
10ab0a: 4804 ldr r0, [pc, #16] ; (10ab1c <alarm+0x7c>)
10ab0c: f149 0300 adc.w r3, r9, #0
10ab10: f2c0 0120 movt r1, #32
10ab14: f7ff fd92 bl 10a63c <_Watchdog_Insert>
10ab18: e7eb b.n 10aaf2 <alarm+0x52>
10ab1a: bf00 nop
10ab1c: 00202ab0 .word 0x00202ab0
0010e1ac <clock_nanosleep>:
struct timespec uptime;
const struct timespec *end;
Thread_Control *executing;
int eno;
if ( clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC ) {
10e1ac: 2801 cmp r0, #1
10e1ae: bf18 it ne
10e1b0: 2804 cmpne r0, #4
{
10e1b2: b5f0 push {r4, r5, r6, r7, lr}
return ENOTSUP;
10e1b4: bf18 it ne
10e1b6: 2486 movne r4, #134 ; 0x86
{
10e1b8: b093 sub sp, #76 ; 0x4c
if ( clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC ) {
10e1ba: d13c bne.n 10e236 <clock_nanosleep+0x8a> <== ALWAYS TAKEN
queue_context->thread_state = thread_state;
10e1bc: 461e mov r6, r3
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_TIME | STATES_INTERRUPTIBLE_BY_SIGNAL
);
if ( ( flags & TIMER_ABSTIME ) != 0 ) {
10e1be: f011 0404 ands.w r4, r1, #4
10e1c2: f44f 7380 mov.w r3, #256 ; 0x100
10e1c6: 4615 mov r5, r2
10e1c8: f2c1 0300 movt r3, #4096 ; 0x1000
10e1cc: 930a str r3, [sp, #40] ; 0x28
10e1ce: d03a beq.n 10e246 <clock_nanosleep+0x9a>
end = rqtp;
if ( clock_id == CLOCK_REALTIME ) {
10e1d0: 2801 cmp r0, #1
10e1d2: d073 beq.n 10e2bc <clock_nanosleep+0x110> <== NEVER TAKEN
queue_context->enqueue_callout =
10e1d4: f649 6395 movw r3, #40597 ; 0x9e95
queue_context->Timeout.arg = abstime;
10e1d8: 950c str r5, [sp, #48] ; 0x30
queue_context->enqueue_callout =
10e1da: f2c0 0310 movt r3, #16
10e1de: 930b str r3, [sp, #44] ; 0x2c
__asm__ volatile (
10e1e0: f3ef 8300 mrs r3, CPSR
10e1e4: f043 0280 orr.w r2, r3, #128 ; 0x80
10e1e8: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
10e1ec: 9309 str r3, [sp, #36] ; 0x24
10e1ee: f644 02c0 movw r2, #18624 ; 0x48c0
);
}
_Thread_queue_Acquire( &_Nanosleep_Pseudo_queue, &queue_context );
executing = _Thread_Executing;
_Thread_queue_Enqueue(
10e1f2: f64e 51d8 movw r1, #60888 ; 0xedd8
10e1f6: f2c0 0220 movt r2, #32
10e1fa: f240 40e0 movw r0, #1248 ; 0x4e0
10e1fe: 6997 ldr r7, [r2, #24]
10e200: ab09 add r3, sp, #36 ; 0x24
10e202: f2c0 0110 movt r1, #16
10e206: f2c0 0020 movt r0, #32
10e20a: 463a mov r2, r7
10e20c: f7fb fa10 bl 109630 <_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 );
10e210: 6cfb ldr r3, [r7, #76] ; 0x4c
if ( eno == ETIMEDOUT ) {
eno = 0;
}
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
10e212: 2e00 cmp r6, #0
10e214: fab4 f184 clz r1, r4
10e218: ea4f 1151 mov.w r1, r1, lsr #5
10e21c: bf08 it eq
10e21e: 2100 moveq r1, #0
10e220: f103 04ff add.w r4, r3, #255 ; 0xff
10e224: ea14 0423 ands.w r4, r4, r3, asr #32
10e228: bf38 it cc
10e22a: 461c movcc r4, r3
10e22c: 1224 asrs r4, r4, #8
if ( eno == ETIMEDOUT ) {
10e22e: 2c74 cmp r4, #116 ; 0x74
10e230: d004 beq.n 10e23c <clock_nanosleep+0x90>
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
10e232: 2900 cmp r1, #0
10e234: d137 bne.n 10e2a6 <clock_nanosleep+0xfa>
_Timespec_Set_to_zero( rmtp );
}
}
return eno;
}
10e236: 4620 mov r0, r4
10e238: b013 add sp, #76 ; 0x4c
10e23a: bdf0 pop {r4, r5, r6, r7, pc}
eno = 0;
10e23c: 460c mov r4, r1
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
10e23e: 2900 cmp r1, #0
10e240: d0f9 beq.n 10e236 <clock_nanosleep+0x8a>
eno = 0;
10e242: 2400 movs r4, #0
10e244: e031 b.n 10e2aa <clock_nanosleep+0xfe>
_Timecounter_Nanouptime( &uptime );
10e246: 4668 mov r0, sp
10e248: f7fa fc56 bl 108af8 <_Timecounter_Nanouptime>
&& (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND;
10e24c: 2d00 cmp r5, #0
10e24e: d0c1 beq.n 10e1d4 <clock_nanosleep+0x28>
10e250: 68aa ldr r2, [r5, #8]
10e252: f64c 10ff movw r0, #51711 ; 0xc9ff
10e256: f6c3 309a movt r0, #15258 ; 0x3b9a
10e25a: 4282 cmp r2, r0
10e25c: d835 bhi.n 10e2ca <clock_nanosleep+0x11e>
return _Watchdog_Is_valid_timespec( ts ) && ts->tv_sec >= 0;
10e25e: e9d5 3700 ldrd r3, r7, [r5]
10e262: 2f00 cmp r7, #0
10e264: db31 blt.n 10e2ca <clock_nanosleep+0x11e>
now->tv_nsec += delta->tv_nsec;
10e266: 9902 ldr r1, [sp, #8]
sec = (uint64_t) now->tv_sec;
10e268: 9d00 ldr r5, [sp, #0]
now->tv_nsec += delta->tv_nsec;
10e26a: 440a add r2, r1
sec = (uint64_t) now->tv_sec;
10e26c: 9901 ldr r1, [sp, #4]
sec += (uint64_t) delta->tv_sec;
10e26e: 195b adds r3, r3, r5
10e270: eb41 0107 adc.w r1, r1, r7
if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) {
10e274: 4282 cmp r2, r0
now->tv_nsec += delta->tv_nsec;
10e276: bfd8 it le
10e278: 9202 strle r2, [sp, #8]
if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) {
10e27a: dd08 ble.n 10e28e <clock_nanosleep+0xe2>
++sec;
10e27c: 3301 adds r3, #1
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
10e27e: f44f 5058 mov.w r0, #13824 ; 0x3600
10e282: f2cc 4065 movt r0, #50277 ; 0xc465
++sec;
10e286: f141 0100 adc.w r1, r1, #0
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
10e28a: 4410 add r0, r2
10e28c: 9002 str r0, [sp, #8]
if ( sec <= INT64_MAX ) {
10e28e: 2900 cmp r1, #0
return now;
10e290: 466d mov r5, sp
now->tv_sec = INT64_MAX;
10e292: bfbb ittet lt
10e294: f04f 32ff movlt.w r2, #4294967295 ; 0xffffffff
10e298: f06f 4300 mvnlt.w r3, #2147483648 ; 0x80000000
now->tv_sec = sec;
10e29c: e9cd 3100 strdge r3, r1, [sp]
now->tv_sec = INT64_MAX;
10e2a0: e9cd 2300 strdlt r2, r3, [sp]
10e2a4: e796 b.n 10e1d4 <clock_nanosleep+0x28>
if ( eno == EINTR ) {
10e2a6: 2c04 cmp r4, #4
10e2a8: d011 beq.n 10e2ce <clock_nanosleep+0x122>
_Timespec_Set_to_zero( rmtp );
10e2aa: efc0 0010 vmov.i32 d16, #0 ; 0x00000000
10e2ae: 2300 movs r3, #0
}
10e2b0: 4620 mov r0, r4
_Timespec_Set_to_zero( rmtp );
10e2b2: 60b3 str r3, [r6, #8]
10e2b4: edc6 0b00 vstr d16, [r6]
}
10e2b8: b013 add sp, #76 ; 0x4c
10e2ba: bdf0 pop {r4, r5, r6, r7, pc}
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
10e2bc: f649 63b9 movw r3, #40633 ; 0x9eb9
queue_context->Timeout.arg = abstime;
10e2c0: 920c str r2, [sp, #48] ; 0x30
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
10e2c2: f2c0 0310 movt r3, #16
10e2c6: 930b str r3, [sp, #44] ; 0x2c
}
10e2c8: e78a b.n 10e1e0 <clock_nanosleep+0x34>
return NULL;
10e2ca: 4625 mov r5, r4
10e2cc: e782 b.n 10e1d4 <clock_nanosleep+0x28>
_Timecounter_Nanouptime( &actual_end );
10e2ce: a804 add r0, sp, #16
10e2d0: f7fa fc12 bl 108af8 <_Timecounter_Nanouptime>
if ( _Timespec_Less_than( &actual_end, end ) ) {
10e2d4: 4629 mov r1, r5
10e2d6: a804 add r0, sp, #16
10e2d8: f000 f820 bl 10e31c <_Timespec_Less_than>
10e2dc: b928 cbnz r0, 10e2ea <clock_nanosleep+0x13e>
_Timespec_Set_to_zero( rmtp );
10e2de: efc0 0010 vmov.i32 d16, #0 ; 0x00000000 <== NOT EXECUTED
10e2e2: 60b0 str r0, [r6, #8] <== NOT EXECUTED
10e2e4: edc6 0b00 vstr d16, [r6] <== NOT EXECUTED
10e2e8: e7a5 b.n 10e236 <clock_nanosleep+0x8a> <== NOT EXECUTED
_Timespec_Subtract( &actual_end, end, rmtp );
10e2ea: 4632 mov r2, r6
10e2ec: 4629 mov r1, r5
10e2ee: a804 add r0, sp, #16
10e2f0: f000 f82e bl 10e350 <_Timespec_Subtract>
10e2f4: e79f b.n 10e236 <clock_nanosleep+0x8a>
10e2f6: bf00 nop
0010ef38 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10ef38: b510 push {r4, lr}
10ef3a: b082 sub sp, #8
Status_Control status;
if ( !tp )
10ef3c: 2900 cmp r1, #0
10ef3e: d037 beq.n 10efb0 <clock_settime+0x78> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10ef40: 2801 cmp r0, #1
10ef42: d015 beq.n 10ef70 <clock_settime+0x38>
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 ) {
10ef44: 2802 cmp r0, #2
10ef46: d00a beq.n 10ef5e <clock_settime+0x26>
rtems_set_errno_and_return_minus_one( ENOSYS );
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) {
10ef48: 2803 cmp r0, #3
10ef4a: d008 beq.n 10ef5e <clock_settime+0x26>
rtems_set_errno_and_return_minus_one( ENOSYS );
}
#endif
else {
rtems_set_errno_and_return_minus_one( EINVAL );
10ef4c: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
10ef50: f023 fcaa bl 1328a8 <__errno>
10ef54: 2316 movs r3, #22
10ef56: 6003 str r3, [r0, #0]
}
return 0;
}
10ef58: 4620 mov r0, r4
10ef5a: b002 add sp, #8
10ef5c: bd10 pop {r4, pc}
rtems_set_errno_and_return_minus_one( ENOSYS );
10ef5e: f023 fca3 bl 1328a8 <__errno>
10ef62: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
10ef66: 2358 movs r3, #88 ; 0x58
10ef68: 6003 str r3, [r0, #0]
}
10ef6a: 4620 mov r0, r4
10ef6c: b002 add sp, #8
10ef6e: bd10 pop {r4, pc}
_TOD_Lock();
10ef70: 460c mov r4, r1
10ef72: f001 fc29 bl 1107c8 <_TOD_Lock>
__asm__ volatile (
10ef76: f3ef 8300 mrs r3, CPSR
10ef7a: f043 0280 orr.w r2, r3, #128 ; 0x80
10ef7e: f382 8900 msr CPSR_fc, r2
_Timecounter_Acquire( lock_context );
10ef82: 9301 str r3, [sp, #4]
status = _TOD_Set( tp, &lock_context );
10ef84: 4620 mov r0, r4
10ef86: a901 add r1, sp, #4
10ef88: f001 fc42 bl 110810 <_TOD_Set>
10ef8c: 4604 mov r4, r0
_TOD_Unlock();
10ef8e: f001 fc21 bl 1107d4 <_TOD_Unlock>
if ( status != STATUS_SUCCESSFUL ) {
10ef92: 2c00 cmp r4, #0
10ef94: d0e0 beq.n 10ef58 <clock_settime+0x20>
rtems_set_errno_and_return_minus_one( STATUS_GET_POSIX( status ) );
10ef96: f023 fc87 bl 1328a8 <__errno>
10ef9a: f104 03ff add.w r3, r4, #255 ; 0xff
10ef9e: ea13 0324 ands.w r3, r3, r4, asr #32
10efa2: bf38 it cc
10efa4: 4623 movcc r3, r4
10efa6: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
10efaa: 121b asrs r3, r3, #8
10efac: 6003 str r3, [r0, #0]
10efae: e7d3 b.n 10ef58 <clock_settime+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
10efb0: f023 fc7a bl 1328a8 <__errno> <== NOT EXECUTED
10efb4: 2316 movs r3, #22 <== NOT EXECUTED
10efb6: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff <== NOT EXECUTED
10efba: 6003 str r3, [r0, #0] <== NOT EXECUTED
10efbc: e7cc b.n 10ef58 <clock_settime+0x20> <== NOT EXECUTED
10efbe: bf00 nop
00106f84 <mmap>:
CHAIN_DEFINE_EMPTY( mmap_mappings );
void *mmap(
void *addr, size_t len, int prot, int flags, int fildes, off_t off
)
{
106f84: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
106f88: 460e mov r6, r1
106f8a: b0a3 sub sp, #140 ; 0x8c
106f8c: 461c mov r4, r3
106f8e: 4607 mov r7, r0
106f90: 4615 mov r5, r2
106f92: f8dd 80b8 ldr.w r8, [sp, #184] ; 0xb8
106f96: f8dd 90bc ldr.w r9, [sp, #188] ; 0xbc
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;
106f9a: f006 ff31 bl 10de00 <__errno>
106f9e: 2300 movs r3, #0
106fa0: 6003 str r3, [r0, #0]
iop = NULL;
if ( len == 0 ) {
106fa2: 2e00 cmp r6, #0
106fa4: d07d beq.n 1070a2 <mmap+0x11e> <== ALWAYS 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 ) {
106fa6: 2d00 cmp r5, #0
106fa8: f000 80e9 beq.w 10717e <mmap+0x1fa> <== ALWAYS 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) ) {
106fac: 07ab lsls r3, r5, #30
106fae: f140 80e6 bpl.w 10717e <mmap+0x1fa>
map_fixed = (flags & MAP_FIXED) == MAP_FIXED;
106fb2: f004 0310 and.w r3, r4, #16
map_shared = (flags & MAP_SHARED) == MAP_SHARED;
106fb6: f004 0b01 and.w fp, r4, #1
map_fixed = (flags & MAP_FIXED) == MAP_FIXED;
106fba: 9302 str r3, [sp, #8]
/*
* 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) ) {
106fbc: f414 5380 ands.w r3, r4, #4096 ; 0x1000
map_private = (flags & MAP_PRIVATE) == MAP_PRIVATE;
106fc0: f004 0202 and.w r2, r4, #2
if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) {
106fc4: 9303 str r3, [sp, #12]
106fc6: d15f bne.n 107088 <mmap+0x104>
flags |= MAP_PRIVATE;
map_private = true;
}
/* Check for supported flags */
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) {
106fc8: f424 5380 bic.w r3, r4, #4096 ; 0x1000
106fcc: f023 0313 bic.w r3, r3, #19
106fd0: 2b00 cmp r3, #0
106fd2: d166 bne.n 1070a2 <mmap+0x11e> <== ALWAYS TAKEN
errno = EINVAL;
return MAP_FAILED;
}
/* Either MAP_SHARED or MAP_PRIVATE must be defined, but not both */
if ( map_shared ) {
106fd4: f1bb 0f00 cmp.w fp, #0
106fd8: d16d bne.n 1070b6 <mmap+0x132>
if ( map_private ) {
errno = EINVAL;
return MAP_FAILED;
}
} else if ( !map_private ) {
106fda: 2a00 cmp r2, #0
106fdc: d061 beq.n 1070a2 <mmap+0x11e>
errno = EINVAL;
return MAP_FAILED;
}
/* Check for illegal addresses. Watch out for address wrap. */
if ( map_fixed ) {
106fde: 9b02 ldr r3, [sp, #8]
106fe0: 2b00 cmp r3, #0
106fe2: f000 8106 beq.w 1071f2 <mmap+0x26e>
map_private = true;
106fe6: 2301 movs r3, #1
106fe8: 9304 str r3, [sp, #16]
if ((uintptr_t)addr & PAGE_MASK) {
106fea: f3c7 030b ubfx r3, r7, #0, #12
106fee: 2b00 cmp r3, #0
106ff0: d157 bne.n 1070a2 <mmap+0x11e>
errno = EINVAL;
return MAP_FAILED;
}
if ( addr == NULL ) {
106ff2: 2f00 cmp r7, #0
106ff4: d055 beq.n 1070a2 <mmap+0x11e>
errno = EINVAL;
return MAP_FAILED;
}
if (addr + len < addr) {
106ff6: 2e00 cmp r6, #0
106ff8: db53 blt.n 1070a2 <mmap+0x11e> <== ALWAYS TAKEN
errno = EINVAL;
return MAP_FAILED;
}
}
if ( !map_anonymous ) {
106ffa: 9b03 ldr r3, [sp, #12]
106ffc: 2b00 cmp r3, #0
106ffe: d061 beq.n 1070c4 <mmap+0x140>
return MAP_FAILED;
}
}
/* Create the mapping */
mapping = malloc( sizeof( mmap_mapping ));
107000: 2101 movs r1, #1
107002: 2018 movs r0, #24
107004: f002 fe7a bl 109cfc <calloc>
if ( !mapping ) {
107008: 4682 mov sl, r0
10700a: 2800 cmp r0, #0
10700c: f000 80e6 beq.w 1071dc <mmap+0x258> <== ALWAYS TAKEN
errno = ENOMEM;
return MAP_FAILED;
}
memset( mapping, 0, sizeof( mmap_mapping ));
mapping->len = len;
107010: e9ca 6403 strd r6, r4, [sl, #12]
}
} else {
is_shared_shm = false;
}
if ( map_fixed ) {
107014: 9c02 ldr r4, [sp, #8]
107016: 2c00 cmp r4, #0
107018: f000 8116 beq.w 107248 <mmap+0x2c4>
iop = NULL;
10701c: 2300 movs r3, #0
mapping->addr = addr;
10701e: f8ca 7008 str.w r7, [sl, #8]
iop = NULL;
107022: 9305 str r3, [sp, #20]
return _Chain_Immutable_head( the_chain )->next;
107024: f240 2404 movw r4, #516 ; 0x204
107028: f2c0 0420 movt r4, #32
extern rtems_chain_control mmap_mappings;
static inline void mmap_mappings_lock_obtain( void )
{
rtems_libio_lock();
10702c: f7fe f82c bl 105088 <rtems_libio_lock>
107030: 4621 mov r1, r4
107032: f851 3b04 ldr.w r3, [r1], #4
mmap_mappings_lock_obtain();
if ( map_fixed ) {
rtems_chain_node* node = rtems_chain_first (&mmap_mappings);
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
107036: 428b cmp r3, r1
107038: d00a beq.n 107050 <mmap+0xcc>
* 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 ) &&
10703a: 689a ldr r2, [r3, #8]
10703c: 42ba cmp r2, r7
10703e: d804 bhi.n 10704a <mmap+0xc6>
( addr < ( current_mapping->addr + current_mapping->len )) ) {
107040: 68d8 ldr r0, [r3, #12]
107042: 4402 add r2, r0
if ( ( addr >= current_mapping->addr ) &&
107044: 4297 cmp r7, r2
107046: f0c0 8123 bcc.w 107290 <mmap+0x30c> <== ALWAYS TAKEN
return the_node->next;
10704a: 681b ldr r3, [r3, #0]
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
10704c: 428b cmp r3, r1
10704e: d1f4 bne.n 10703a <mmap+0xb6>
node = rtems_chain_next( node );
}
}
/* Populate the data */
if ( map_private ) {
107050: 9b04 ldr r3, [sp, #16]
107052: 2b00 cmp r3, #0
107054: f000 8161 beq.w 10731a <mmap+0x396> <== ALWAYS TAKEN
if ( !map_anonymous ) {
107058: 9b03 ldr r3, [sp, #12]
10705a: 2b00 cmp r3, #0
10705c: f000 8135 beq.w 1072ca <mmap+0x346>
}
free( mapping );
errno = ENXIO;
return MAP_FAILED;
}
} else if ( !map_fixed ) {
107060: 9b02 ldr r3, [sp, #8]
107062: 2b00 cmp r3, #0
107064: f000 814d beq.w 107302 <mmap+0x37e>
107068: 49b1 ldr r1, [pc, #708] ; (107330 <mmap+0x3ac>)
10706a: 1f0c subs r4, r1, #4
old_last = tail->previous;
10706c: 68a3 ldr r3, [r4, #8]
the_node->next = tail;
10706e: f8ca 1000 str.w r1, [sl]
tail->previous = the_node;
107072: f8c4 a008 str.w sl, [r4, #8]
old_last->next = the_node;
107076: f8c3 a000 str.w sl, [r3]
the_node->previous = old_last;
10707a: f8ca 3004 str.w r3, [sl, #4]
}
static inline void mmap_mappings_lock_release( void )
{
rtems_libio_unlock();
10707e: f7fe f809 bl 105094 <rtems_libio_unlock>
rtems_chain_append_unprotected( &mmap_mappings, &mapping->node );
mmap_mappings_lock_release( );
return mapping->addr;
107082: f8da 0008 ldr.w r0, [sl, #8]
107086: e013 b.n 1070b0 <mmap+0x12c>
if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) {
107088: 992c ldr r1, [sp, #176] ; 0xb0
10708a: ea48 0309 orr.w r3, r8, r9
10708e: 2b00 cmp r3, #0
107090: bf08 it eq
107092: f1b1 3fff cmpeq.w r1, #4294967295 ; 0xffffffff
107096: bf14 ite ne
107098: 2301 movne r3, #1
10709a: 2300 moveq r3, #0
10709c: ea53 030b orrs.w r3, r3, fp
1070a0: d077 beq.n 107192 <mmap+0x20e>
errno = EINVAL;
1070a2: f006 fead bl 10de00 <__errno>
1070a6: 4603 mov r3, r0
return MAP_FAILED;
1070a8: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
errno = EINVAL;
1070ac: 2216 movs r2, #22
1070ae: 601a str r2, [r3, #0]
}
1070b0: b023 add sp, #140 ; 0x8c
1070b2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( map_private ) {
1070b6: 2a00 cmp r2, #0
1070b8: d1f3 bne.n 1070a2 <mmap+0x11e>
if ( map_fixed ) {
1070ba: 9b02 ldr r3, [sp, #8]
1070bc: 2b00 cmp r3, #0
1070be: f040 8095 bne.w 1071ec <mmap+0x268> <== ALWAYS TAKEN
1070c2: 9304 str r3, [sp, #16]
if ( fstat( fildes, &sb ) < 0 ) {
1070c4: 982c ldr r0, [sp, #176] ; 0xb0
1070c6: a908 add r1, sp, #32
1070c8: f002 fe9c bl 109e04 <fstat>
1070cc: 2800 cmp r0, #0
1070ce: f2c0 80f4 blt.w 1072ba <mmap+0x336> <== ALWAYS TAKEN
return &rtems_libio_iops[ fd ];
1070d2: 9a2c ldr r2, [sp, #176] ; 0xb0
if ( S_ISDIR( sb.st_mode ) || S_ISLNK( sb.st_mode )) {
1070d4: 9b0c ldr r3, [sp, #48] ; 0x30
1070d6: eb02 0142 add.w r1, r2, r2, lsl #1
1070da: f641 4238 movw r2, #7224 ; 0x1c38
1070de: f403 4370 and.w r3, r3, #61440 ; 0xf000
1070e2: f2c0 0220 movt r2, #32
1070e6: f5b3 4f20 cmp.w r3, #40960 ; 0xa000
1070ea: bf18 it ne
1070ec: f5b3 4f80 cmpne.w r3, #16384 ; 0x4000
1070f0: eb02 1201 add.w r2, r2, r1, lsl #4
1070f4: 9205 str r2, [sp, #20]
1070f6: bf0c ite eq
1070f8: 2201 moveq r2, #1
1070fa: 2200 movne r2, #0
1070fc: f000 80d5 beq.w 1072aa <mmap+0x326> <== ALWAYS TAKEN
if ( S_ISREG( sb.st_mode )
107100: f5b3 4f00 cmp.w r3, #32768 ; 0x8000
107104: d078 beq.n 1071f8 <mmap+0x274> <== ALWAYS TAKEN
if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) {
107106: f5b3 5f00 cmp.w r3, #8192 ; 0x2000
10710a: f000 8093 beq.w 107234 <mmap+0x2b0>
10710e: e9dd 0112 ldrd r0, r1, [sp, #72] ; 0x48
&& (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) {
107112: eb16 0e08 adds.w lr, r6, r8
107116: f149 0c00 adc.w ip, r9, #0
if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) {
10711a: 4570 cmp r0, lr
10711c: eb71 010c sbcs.w r1, r1, ip
107120: f2c0 80bb blt.w 10729a <mmap+0x316> <== ALWAYS TAKEN
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ) {
107124: f5a3 41c0 sub.w r1, r3, #24576 ; 0x6000
107128: f421 5100 bic.w r1, r1, #8192 ; 0x2000
10712c: 2900 cmp r1, #0
10712e: d071 beq.n 107214 <mmap+0x290> <== ALWAYS TAKEN
mapping = malloc( sizeof( mmap_mapping ));
107130: 2101 movs r1, #1
107132: 2018 movs r0, #24
107134: e9cd 3206 strd r3, r2, [sp, #24]
107138: f002 fde0 bl 109cfc <calloc>
if ( !mapping ) {
10713c: e9dd 3206 ldrd r3, r2, [sp, #24]
107140: 4682 mov sl, r0
107142: 2800 cmp r0, #0
107144: d04a beq.n 1071dc <mmap+0x258> <== ALWAYS TAKEN
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
107146: f5b3 5f80 cmp.w r3, #4096 ; 0x1000
10714a: bf18 it ne
10714c: f5b3 4fc0 cmpne.w r3, #24576 ; 0x6000
mapping->len = len;
107150: e9ca 6403 strd r6, r4, [sl, #12]
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
107154: bf0c ite eq
107156: 2401 moveq r4, #1
107158: 2400 movne r4, #0
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
10715a: f423 4380 bic.w r3, r3, #16384 ; 0x4000
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
10715e: 4314 orrs r4, r2
107160: f5b3 4f00 cmp.w r3, #32768 ; 0x8000
107164: bf08 it eq
107166: f044 0401 orreq.w r4, r4, #1
if ( map_fixed ) {
10716a: 9b02 ldr r3, [sp, #8]
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
10716c: f084 0401 eor.w r4, r4, #1
if ( map_fixed ) {
107170: 2b00 cmp r3, #0
107172: d06a beq.n 10724a <mmap+0x2c6> <== NEVER TAKEN
if ( map_fixed && is_shared_shm ) {
107174: 2c00 cmp r4, #0 <== NOT EXECUTED
107176: f000 80d8 beq.w 10732a <mmap+0x3a6> <== NOT EXECUTED
free( mapping );
10717a: f002 fde3 bl 109d44 <free> <== NOT EXECUTED
errno = ENOTSUP;
10717e: f006 fe3f bl 10de00 <__errno>
107182: 2286 movs r2, #134 ; 0x86
107184: 4603 mov r3, r0
107186: 601a str r2, [r3, #0]
return MAP_FAILED;
107188: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10718c: b023 add sp, #140 ; 0x8c
10718e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( map_anonymous && !map_private && !map_shared ) {
107192: f424 5380 bic.w r3, r4, #4096 ; 0x1000
107196: f023 0313 bic.w r3, r3, #19
10719a: 2a00 cmp r2, #0
10719c: f040 80c1 bne.w 107322 <mmap+0x39e>
flags |= MAP_PRIVATE;
1071a0: f044 0402 orr.w r4, r4, #2
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) {
1071a4: 2b00 cmp r3, #0
1071a6: f47f af7c bne.w 1070a2 <mmap+0x11e>
if ( map_fixed ) {
1071aa: 9b02 ldr r3, [sp, #8]
1071ac: 2b00 cmp r3, #0
1071ae: f47f af1a bne.w 106fe6 <mmap+0x62> <== ALWAYS TAKEN
mapping = malloc( sizeof( mmap_mapping ));
1071b2: 2101 movs r1, #1
1071b4: 2018 movs r0, #24
1071b6: f002 fda1 bl 109cfc <calloc>
if ( !mapping ) {
1071ba: 4682 mov sl, r0
1071bc: b170 cbz r0, 1071dc <mmap+0x258>
mapping->flags = flags;
1071be: e9ca 6403 strd r6, r4, [sl, #12]
err = posix_memalign( &mapping->addr, PAGE_SIZE, len );
1071c2: 4632 mov r2, r6
1071c4: f44f 5180 mov.w r1, #4096 ; 0x1000
1071c8: f10a 0008 add.w r0, sl, #8
1071cc: f002 ff84 bl 10a0d8 <posix_memalign>
1071d0: 2800 cmp r0, #0
1071d2: f000 808b beq.w 1072ec <mmap+0x368> <== NEVER TAKEN
free( mapping );
1071d6: 4650 mov r0, sl <== NOT EXECUTED
1071d8: f002 fdb4 bl 109d44 <free> <== NOT EXECUTED
errno = ENOMEM;
1071dc: f006 fe10 bl 10de00 <__errno> <== NOT EXECUTED
1071e0: 220c movs r2, #12 <== NOT EXECUTED
1071e2: 4603 mov r3, r0 <== NOT EXECUTED
1071e4: 601a str r2, [r3, #0] <== NOT EXECUTED
return MAP_FAILED;
1071e6: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1071ea: e761 b.n 1070b0 <mmap+0x12c> <== NOT EXECUTED
if ( map_fixed ) {
1071ec: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
1071ee: 9304 str r3, [sp, #16] <== NOT EXECUTED
1071f0: e6fb b.n 106fea <mmap+0x66> <== NOT EXECUTED
1071f2: 2301 movs r3, #1
1071f4: 9304 str r3, [sp, #16]
1071f6: e700 b.n 106ffa <mmap+0x76>
&& (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) {
1071f8: e9dd 2312 ldrd r2, r3, [sp, #72] ; 0x48 <== NOT EXECUTED
1071fc: 4590 cmp r8, r2 <== NOT EXECUTED
1071fe: eb79 0103 sbcs.w r1, r9, r3 <== NOT EXECUTED
107202: da76 bge.n 1072f2 <mmap+0x36e> <== NOT EXECUTED
107204: eb16 0008 adds.w r0, r6, r8 <== NOT EXECUTED
107208: f149 0100 adc.w r1, r9, #0 <== NOT EXECUTED
10720c: 4290 cmp r0, r2 <== NOT EXECUTED
10720e: eb71 0303 sbcs.w r3, r1, r3 <== NOT EXECUTED
107212: da6e bge.n 1072f2 <mmap+0x36e> <== NOT EXECUTED
if ( lseek( fildes, off, SEEK_SET ) < 0 ) {
107214: 2300 movs r3, #0 <== NOT EXECUTED
107216: 982c ldr r0, [sp, #176] ; 0xb0 <== NOT EXECUTED
107218: 9300 str r3, [sp, #0] <== NOT EXECUTED
10721a: 4642 mov r2, r8 <== NOT EXECUTED
10721c: 464b mov r3, r9 <== NOT EXECUTED
10721e: f002 fe83 bl 109f28 <lseek> <== NOT EXECUTED
107222: 2900 cmp r1, #0 <== NOT EXECUTED
return MAP_FAILED;
107224: bfb8 it lt <== NOT EXECUTED
107226: f04f 30ff movlt.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
if ( lseek( fildes, off, SEEK_SET ) < 0 ) {
10722a: f6ff af41 blt.w 1070b0 <mmap+0x12c> <== NOT EXECUTED
if ( S_ISCHR( sb.st_mode ) && map_private ) {
10722e: 9b0c ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
107230: f403 4370 and.w r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
107234: f5a3 5200 sub.w r2, r3, #8192 ; 0x2000
107238: 9904 ldr r1, [sp, #16]
10723a: fab2 f282 clz r2, r2
10723e: 0952 lsrs r2, r2, #5
107240: 4211 tst r1, r2
107242: f43f af75 beq.w 107130 <mmap+0x1ac>
107246: e72c b.n 1070a2 <mmap+0x11e>
iop = NULL;
107248: 9405 str r4, [sp, #20]
} else if ( map_private ) {
10724a: 9b04 ldr r3, [sp, #16]
10724c: 2b00 cmp r3, #0
10724e: d1b8 bne.n 1071c2 <mmap+0x23e>
rtems_libio_lock();
107250: f7fd ff1a bl 105088 <rtems_libio_lock>
} else if ( map_shared ) {
107254: f1bb 0f00 cmp.w fp, #0
107258: f43f af06 beq.w 107068 <mmap+0xe4> <== ALWAYS TAKEN
if ( is_shared_shm ) {
10725c: b11c cbz r4, 107266 <mmap+0x2e2>
mapping->shm = iop_to_shm( iop );
10725e: 9b05 ldr r3, [sp, #20]
107260: 6adb ldr r3, [r3, #44] ; 0x2c
107262: f8ca 3014 str.w r3, [sl, #20]
err = (*iop->pathinfo.handlers->mmap_h)(
107266: 9805 ldr r0, [sp, #20]
107268: 462b mov r3, r5
10726a: 4632 mov r2, r6
10726c: 6a01 ldr r1, [r0, #32]
10726e: e9cd 8900 strd r8, r9, [sp]
107272: 6bcc ldr r4, [r1, #60] ; 0x3c
107274: f10a 0108 add.w r1, sl, #8
107278: 47a0 blx r4
if ( err != 0 ) {
10727a: 2800 cmp r0, #0
10727c: f43f aef4 beq.w 107068 <mmap+0xe4>
rtems_libio_unlock();
107280: f7fd ff08 bl 105094 <rtems_libio_unlock>
free( mapping );
107284: 4650 mov r0, sl
107286: f002 fd5d bl 109d44 <free>
return MAP_FAILED;
10728a: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
10728e: e70f b.n 1070b0 <mmap+0x12c>
free( mapping );
107290: 4650 mov r0, sl <== NOT EXECUTED
107292: f002 fd57 bl 109d44 <free> <== NOT EXECUTED
107296: f7fd fefd bl 105094 <rtems_libio_unlock> <== NOT EXECUTED
errno = ENXIO;
10729a: f006 fdb1 bl 10de00 <__errno> <== NOT EXECUTED
10729e: 2206 movs r2, #6 <== NOT EXECUTED
1072a0: 4603 mov r3, r0 <== NOT EXECUTED
1072a2: 601a str r2, [r3, #0] <== NOT EXECUTED
return MAP_FAILED;
1072a4: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1072a8: e702 b.n 1070b0 <mmap+0x12c> <== NOT EXECUTED
errno = ENODEV;
1072aa: f006 fda9 bl 10de00 <__errno> <== NOT EXECUTED
1072ae: 2213 movs r2, #19 <== NOT EXECUTED
1072b0: 4603 mov r3, r0 <== NOT EXECUTED
1072b2: 601a str r2, [r3, #0] <== NOT EXECUTED
return MAP_FAILED;
1072b4: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1072b8: e6fa b.n 1070b0 <mmap+0x12c> <== NOT EXECUTED
errno = EBADF;
1072ba: f006 fda1 bl 10de00 <__errno> <== NOT EXECUTED
1072be: 2209 movs r2, #9 <== NOT EXECUTED
1072c0: 4603 mov r3, r0 <== NOT EXECUTED
1072c2: 601a str r2, [r3, #0] <== NOT EXECUTED
return MAP_FAILED;
1072c4: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1072c8: e6f2 b.n 1070b0 <mmap+0x12c> <== NOT EXECUTED
r = read( fildes, mapping->addr, len );
1072ca: f8da 1008 ldr.w r1, [sl, #8]
1072ce: 4632 mov r2, r6
1072d0: 982c ldr r0, [sp, #176] ; 0xb0
1072d2: f002 ff53 bl 10a17c <read>
if ( r != len ) {
1072d6: 42b0 cmp r0, r6
1072d8: f43f aec6 beq.w 107068 <mmap+0xe4> <== NEVER TAKEN
1072dc: f7fd feda bl 105094 <rtems_libio_unlock> <== NOT EXECUTED
if ( !map_fixed ) {
1072e0: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED
1072e2: b1ab cbz r3, 107310 <mmap+0x38c> <== NOT EXECUTED
free( mapping );
1072e4: 4650 mov r0, sl <== NOT EXECUTED
1072e6: f002 fd2d bl 109d44 <free> <== NOT EXECUTED
1072ea: e7d6 b.n 10729a <mmap+0x316> <== NOT EXECUTED
rtems_libio_lock();
1072ec: f7fd fecc bl 105088 <rtems_libio_lock>
if ( map_private ) {
1072f0: e6b2 b.n 107058 <mmap+0xd4>
errno = EOVERFLOW;
1072f2: f006 fd85 bl 10de00 <__errno> <== NOT EXECUTED
1072f6: 228b movs r2, #139 ; 0x8b <== NOT EXECUTED
1072f8: 4603 mov r3, r0 <== NOT EXECUTED
1072fa: 601a str r2, [r3, #0] <== NOT EXECUTED
return MAP_FAILED;
1072fc: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
107300: e6d6 b.n 1070b0 <mmap+0x12c> <== NOT EXECUTED
memset( mapping->addr, 0, len );
107302: f8da 0008 ldr.w r0, [sl, #8]
107306: 4632 mov r2, r6
107308: 9902 ldr r1, [sp, #8]
10730a: f007 f929 bl 10e560 <memset>
10730e: e6ab b.n 107068 <mmap+0xe4>
free( mapping->addr );
107310: f8da 0008 ldr.w r0, [sl, #8] <== NOT EXECUTED
107314: f002 fd16 bl 109d44 <free> <== NOT EXECUTED
107318: e7e4 b.n 1072e4 <mmap+0x360> <== NOT EXECUTED
} else if ( map_shared ) {
10731a: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
10731e: d1a2 bne.n 107266 <mmap+0x2e2> <== NOT EXECUTED
107320: e6a4 b.n 10706c <mmap+0xe8> <== NOT EXECUTED
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) {
107322: 2b00 cmp r3, #0
107324: f43f ae5b beq.w 106fde <mmap+0x5a> <== NEVER TAKEN
107328: e6bb b.n 1070a2 <mmap+0x11e> <== NOT EXECUTED
mapping->addr = addr;
10732a: f8ca 7008 str.w r7, [sl, #8] <== NOT EXECUTED
10732e: e679 b.n 107024 <mmap+0xa0> <== NOT EXECUTED
107330: 00200208 .word 0x00200208 <== NOT EXECUTED
00107334 <munmap>:
#include <rtems/posix/mmanimpl.h>
#include <rtems/posix/shmimpl.h>
int munmap(void *addr, size_t len)
{
107334: b570 push {r4, r5, r6, lr}
107336: b082 sub sp, #8
107338: 460c mov r4, r1
10733a: 4605 mov r5, r0
rtems_chain_node *node;
/*
* Clear errno.
*/
errno = 0;
10733c: f006 fd60 bl 10de00 <__errno>
107340: 2300 movs r3, #0
/*
* Length cannot be 0.
*/
if ( len == 0 ) {
107342: 429c cmp r4, r3
errno = 0;
107344: 6003 str r3, [r0, #0]
if ( len == 0 ) {
107346: d04a beq.n 1073de <munmap+0xaa> <== ALWAYS TAKEN
errno = EINVAL;
return -1;
}
/* Check for illegal addresses. Watch out for address wrap. */
if (addr + len < addr) {
107348: db49 blt.n 1073de <munmap+0xaa> <== ALWAYS TAKEN
10734a: f7fd fe9d bl 105088 <rtems_libio_lock>
return _Chain_Immutable_head( the_chain )->next;
10734e: f240 2204 movw r2, #516 ; 0x204
107352: f2c0 0220 movt r2, #32
107356: f852 4b04 ldr.w r4, [r2], #4
}
mmap_mappings_lock_obtain();
node = rtems_chain_first (&mmap_mappings);
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
10735a: 4294 cmp r4, r2
10735c: d009 beq.n 107372 <munmap+0x3e> <== ALWAYS TAKEN
mapping = (mmap_mapping*) node;
if ( ( addr >= mapping->addr ) &&
10735e: 68a3 ldr r3, [r4, #8]
107360: 42ab cmp r3, r5
107362: d803 bhi.n 10736c <munmap+0x38>
( addr < ( mapping->addr + mapping->len )) ) {
107364: 68e1 ldr r1, [r4, #12]
107366: 440b add r3, r1
if ( ( addr >= mapping->addr ) &&
107368: 429d cmp r5, r3
10736a: d307 bcc.n 10737c <munmap+0x48>
return the_node->next;
10736c: 6824 ldr r4, [r4, #0]
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
10736e: 4294 cmp r4, r2
107370: d1f5 bne.n 10735e <munmap+0x2a> <== NEVER TAKEN
rtems_libio_unlock();
107372: f7fd fe8f bl 105094 <rtems_libio_unlock>
}
node = rtems_chain_next( node );
}
mmap_mappings_lock_release( );
return 0;
107376: 2000 movs r0, #0
}
107378: b002 add sp, #8
10737a: bd70 pop {r4, r5, r6, pc}
if ( mapping->shm != NULL ) {
10737c: 6965 ldr r5, [r4, #20]
previous = the_node->previous;
10737e: e9d4 2300 ldrd r2, r3, [r4]
next->previous = previous;
107382: 6053 str r3, [r2, #4]
previous->next = next;
107384: 601a str r2, [r3, #0]
107386: b1cd cbz r5, 1073bc <munmap+0x88>
*
* @see _Objects_Allocator_unlock() and _Objects_Allocate().
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void )
{
_RTEMS_Lock_allocator();
107388: f000 fb30 bl 1079ec <_RTEMS_Lock_allocator>
int err;
err = 0;
_Objects_Allocator_lock();
--shm->reference_count;
10738c: 69eb ldr r3, [r5, #28]
10738e: 3b01 subs r3, #1
107390: 61eb str r3, [r5, #28]
if ( shm->reference_count == 0 ) {
107392: b923 cbnz r3, 10739e <munmap+0x6a>
if ( (*shm->shm_object.ops->object_delete)( &shm->shm_object ) != 0 ) {
107394: 6aab ldr r3, [r5, #40] ; 0x28 <== NOT EXECUTED
107396: f105 0020 add.w r0, r5, #32 <== NOT EXECUTED
10739a: 689b ldr r3, [r3, #8] <== NOT EXECUTED
10739c: 4798 blx r3 <== NOT EXECUTED
err = EIO;
}
}
/* check if the object has been unlinked yet. */
obj = _Objects_Get( shm->Object.id, &lock_ctx, &_POSIX_Shm_Information );
10739e: f240 0630 movw r6, #48 ; 0x30
1073a2: 68a8 ldr r0, [r5, #8]
1073a4: f2c0 0620 movt r6, #32
1073a8: a901 add r1, sp, #4
1073aa: 4632 mov r2, r6
1073ac: f000 fe96 bl 1080dc <_Objects_Get>
if ( obj == NULL ) {
1073b0: b180 cbz r0, 1073d4 <munmap+0xa0>
1073b2: 9b01 ldr r3, [sp, #4]
1073b4: f383 8900 msr CPSR_fc, r3
* 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();
1073b8: f000 fb1e bl 1079f8 <_RTEMS_Unlock_allocator>
if (( mapping->flags & MAP_SHARED ) != MAP_SHARED ) {
1073bc: 6923 ldr r3, [r4, #16]
1073be: f013 0f11 tst.w r3, #17
1073c2: d003 beq.n 1073cc <munmap+0x98>
free( mapping );
1073c4: 4620 mov r0, r4
1073c6: f002 fcbd bl 109d44 <free>
break;
1073ca: e7d2 b.n 107372 <munmap+0x3e>
free( mapping->addr );
1073cc: 68a0 ldr r0, [r4, #8]
1073ce: f002 fcb9 bl 109d44 <free>
1073d2: e7f7 b.n 1073c4 <munmap+0x90>
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
1073d4: 68f3 ldr r3, [r6, #12] <== NOT EXECUTED
1073d6: 4629 mov r1, r5 <== NOT EXECUTED
1073d8: 4630 mov r0, r6 <== NOT EXECUTED
1073da: 4798 blx r3 <== NOT EXECUTED
}
1073dc: e7ec b.n 1073b8 <munmap+0x84> <== NOT EXECUTED
errno = EINVAL;
1073de: f006 fd0f bl 10de00 <__errno> <== NOT EXECUTED
1073e2: 2216 movs r2, #22 <== NOT EXECUTED
1073e4: 4603 mov r3, r0 <== NOT EXECUTED
1073e6: 601a str r2, [r3, #0] <== NOT EXECUTED
return -1;
1073e8: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1073ec: e7c4 b.n 107378 <munmap+0x44> <== NOT EXECUTED
1073ee: bf00 nop
00106998 <pthread_attr_getaffinity_np>:
const pthread_attr_t *attr,
size_t cpusetsize,
cpu_set_t *cpuset
)
{
if ( attr == NULL || !attr->is_initialized ) {
106998: 4684 mov ip, r0
10699a: b180 cbz r0, 1069be <pthread_attr_getaffinity_np+0x26>
10699c: 6803 ldr r3, [r0, #0]
return EINVAL;
}
if ( cpuset == NULL || cpusetsize != attr->affinitysetsize ) {
10699e: 2a00 cmp r2, #0
1069a0: bf18 it ne
1069a2: 2b00 cmpne r3, #0
1069a4: bf0c ite eq
1069a6: 2001 moveq r0, #1
1069a8: 2000 movne r0, #0
1069aa: d008 beq.n 1069be <pthread_attr_getaffinity_np+0x26> <== ALWAYS TAKEN
1069ac: f8dc 3054 ldr.w r3, [ip, #84] ; 0x54
1069b0: 428b cmp r3, r1
1069b2: d104 bne.n 1069be <pthread_attr_getaffinity_np+0x26> <== ALWAYS 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);
1069b4: f8dc 3058 ldr.w r3, [ip, #88] ; 0x58
1069b8: 681b ldr r3, [r3, #0]
1069ba: 6013 str r3, [r2, #0]
return EINVAL;
}
CPU_COPY( attr->affinityset, cpuset );
return 0;
1069bc: 4770 bx lr
return EINVAL;
1069be: 2016 movs r0, #22 <== NOT EXECUTED
}
1069c0: 4770 bx lr <== NOT EXECUTED
1069c2: bf00 nop
00106b40 <pthread_attr_setaffinity_np>:
pthread_attr_t *attr,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
if ( attr == NULL || !attr->is_initialized ) {
106b40: 4684 mov ip, r0
106b42: b180 cbz r0, 106b66 <pthread_attr_setaffinity_np+0x26>
106b44: 6803 ldr r3, [r0, #0]
return EINVAL;
}
if ( cpuset == NULL || cpusetsize != attr->affinitysetsize ) {
106b46: 2a00 cmp r2, #0
106b48: bf18 it ne
106b4a: 2b00 cmpne r3, #0
106b4c: bf0c ite eq
106b4e: 2001 moveq r0, #1
106b50: 2000 movne r0, #0
106b52: d008 beq.n 106b66 <pthread_attr_setaffinity_np+0x26> <== ALWAYS TAKEN
106b54: f8dc 3054 ldr.w r3, [ip, #84] ; 0x54
106b58: 428b cmp r3, r1
106b5a: d104 bne.n 106b66 <pthread_attr_setaffinity_np+0x26> <== ALWAYS TAKEN
106b5c: f8dc 3058 ldr.w r3, [ip, #88] ; 0x58
106b60: 6812 ldr r2, [r2, #0]
106b62: 601a str r2, [r3, #0]
return EINVAL;
}
CPU_COPY( cpuset, attr->affinityset );
return 0;
106b64: 4770 bx lr
return EINVAL;
106b66: 2016 movs r0, #22 <== NOT EXECUTED
}
106b68: 4770 bx lr <== NOT EXECUTED
106b6a: bf00 nop
00107b68 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
107b68: 4603 mov r3, r0
107b6a: b160 cbz r0, 107b86 <pthread_attr_setschedpolicy+0x1e>
107b6c: 6802 ldr r2, [r0, #0]
107b6e: b152 cbz r2, 107b86 <pthread_attr_setschedpolicy+0x1e>
return EINVAL;
switch ( policy ) {
107b70: 2902 cmp r1, #2
107b72: dd04 ble.n 107b7e <pthread_attr_setschedpolicy+0x16>
107b74: 2904 cmp r1, #4
107b76: d104 bne.n 107b82 <pthread_attr_setschedpolicy+0x1a> <== ALWAYS TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
107b78: 2000 movs r0, #0
attr->schedpolicy = policy;
107b7a: 6159 str r1, [r3, #20]
return 0;
107b7c: 4770 bx lr
switch ( policy ) {
107b7e: 2900 cmp r1, #0
107b80: dafa bge.n 107b78 <pthread_attr_setschedpolicy+0x10>
107b82: 2086 movs r0, #134 ; 0x86
default:
return ENOTSUP;
}
}
107b84: 4770 bx lr
return EINVAL;
107b86: 2016 movs r0, #22
107b88: 4770 bx lr
107b8a: bf00 nop
0010701c <pthread_cancel>:
/*
* 18.2.1 Canceling Execution of a Thread, P1003.1c/Draft 10, p. 181
*/
int pthread_cancel( pthread_t thread )
{
10701c: b510 push {r4, lr}
10701e: b082 sub sp, #8
107020: 4604 mov r4, r0
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() ) {
107022: f000 fd79 bl 107b18 <_ISR_Is_in_progress>
107026: b9f0 cbnz r0, 107066 <pthread_cancel+0x4a>
return EPROTO;
}
the_thread = _Thread_Get( thread, &lock_context );
107028: a901 add r1, sp, #4
10702a: 4620 mov r0, r4
10702c: f001 fe50 bl 108cd0 <_Thread_Get>
if ( the_thread == NULL ) {
107030: b300 cbz r0, 107074 <pthread_cancel+0x58>
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
107032: f242 1300 movw r3, #8448 ; 0x2100
107036: f2c0 0320 movt r3, #32
10703a: 6919 ldr r1, [r3, #16]
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10703c: 3101 adds r1, #1
10703e: 6119 str r1, [r3, #16]
107040: 9901 ldr r1, [sp, #4]
107042: f381 8900 msr CPSR_fc, r1
107046: 6999 ldr r1, [r3, #24]
_ISR_lock_ISR_enable( &lock_context );
executing = _Per_CPU_Get_executing( cpu_self );
if ( the_thread == executing ) {
_Thread_Exit( executing, THREAD_LIFE_TERMINATING, PTHREAD_CANCELED );
107048: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
if ( the_thread == executing ) {
10704c: 4288 cmp r0, r1
10704e: d00d beq.n 10706c <pthread_cancel+0x50> <== ALWAYS TAKEN
} else {
_Thread_Cancel( the_thread, executing, PTHREAD_CANCELED );
107050: f002 fdda bl 109c08 <_Thread_Cancel>
}
_Thread_Dispatch_enable( cpu_self );
107054: f242 1000 movw r0, #8448 ; 0x2100
107058: f2c0 0020 movt r0, #32
10705c: f001 fe18 bl 108c90 <_Thread_Dispatch_enable>
return 0;
107060: 2000 movs r0, #0
}
107062: b002 add sp, #8
107064: bd10 pop {r4, pc}
return EPROTO;
107066: 2047 movs r0, #71 ; 0x47
}
107068: b002 add sp, #8
10706a: bd10 pop {r4, pc}
_Thread_Exit( executing, THREAD_LIFE_TERMINATING, PTHREAD_CANCELED );
10706c: 2104 movs r1, #4 <== NOT EXECUTED
10706e: f002 fe81 bl 109d74 <_Thread_Exit> <== NOT EXECUTED
107072: e7ef b.n 107054 <pthread_cancel+0x38> <== NOT EXECUTED
return ESRCH;
107074: 2003 movs r0, #3
107076: e7f4 b.n 107062 <pthread_cancel+0x46>
00107ce4 <pthread_create>:
{
107ce4: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
Thread_Entry_information entry = {
107ce8: f249 55f1 movw r5, #38385 ; 0x95f1
{
107cec: b09e sub sp, #120 ; 0x78
Thread_Entry_information entry = {
107cee: f2c0 0510 movt r5, #16
{
107cf2: 460c mov r4, r1
int schedpolicy = SCHED_RR;
107cf4: 2102 movs r1, #2
Thread_Entry_information entry = {
107cf6: 9503 str r5, [sp, #12]
107cf8: e9cd 2304 strd r2, r3, [sp, #16]
int schedpolicy = SCHED_RR;
107cfc: 9101 str r1, [sp, #4]
if ( !start_routine )
107cfe: 2a00 cmp r2, #0
107d00: f000 8101 beq.w 107f06 <pthread_create+0x222>
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
107d04: f245 2348 movw r3, #21064 ; 0x5248
107d08: f2c0 0315 movt r3, #21
107d0c: 2c00 cmp r4, #0
107d0e: bf08 it eq
107d10: 461c moveq r4, r3
if ( !the_attr->is_initialized )
107d12: 6823 ldr r3, [r4, #0]
107d14: 2b00 cmp r3, #0
107d16: f000 80d8 beq.w 107eca <pthread_create+0x1e6>
memset( &config, 0, sizeof( config ) );
107d1a: 2230 movs r2, #48 ; 0x30
107d1c: 4606 mov r6, r0
107d1e: 2100 movs r1, #0
107d20: a806 add r0, sp, #24
107d22: f03d f9f9 bl 145118 <memset>
if ( the_attr->stackaddr != NULL ) {
107d26: 6863 ldr r3, [r4, #4]
config.is_fp = true;
107d28: f240 1201 movw r2, #257 ; 0x101
if ( !_Stack_Is_enough( the_attr->stacksize, config.is_fp ) ) {
107d2c: 68a5 ldr r5, [r4, #8]
config.is_fp = true;
107d2e: f8ad 2040 strh.w r2, [sp, #64] ; 0x40
if ( the_attr->stackaddr != NULL ) {
107d32: 2b00 cmp r3, #0
107d34: f000 80ce beq.w 107ed4 <pthread_create+0x1f0>
bool is_fp
)
{
size_t minimum;
minimum = _TLS_Get_allocation_size();
107d38: f002 fd5c bl 10a7f4 <_TLS_Get_allocation_size>
return rtems_minimum_stack_size;
107d3c: f240 03b8 movw r3, #184 ; 0xb8
107d40: f2c0 0320 movt r3, #32
minimum += _Stack_Minimum();
107d44: 681b ldr r3, [r3, #0]
107d46: 4418 add r0, r3
if ( !_Stack_Is_enough( the_attr->stacksize, config.is_fp ) ) {
107d48: 4285 cmp r5, r0
107d4a: f0c0 80be bcc.w 107eca <pthread_create+0x1e6>
config.stack_size = the_attr->stacksize;
107d4e: e9d4 2301 ldrd r2, r3, [r4, #4]
107d52: e9cd 2307 strd r2, r3, [sp, #28]
switch ( the_attr->inheritsched ) {
107d56: 6923 ldr r3, [r4, #16]
107d58: 2b01 cmp r3, #1
107d5a: f000 80cc beq.w 107ef6 <pthread_create+0x212> <== NEVER TAKEN
107d5e: 2b02 cmp r3, #2
107d60: f040 80b3 bne.w 107eca <pthread_create+0x1e6>
schedpolicy = the_attr->schedpolicy;
107d64: 6963 ldr r3, [r4, #20]
schedparam = the_attr->schedparam;
107d66: f104 0c18 add.w ip, r4, #24
107d6a: af12 add r7, sp, #72 ; 0x48
107d6c: 463d mov r5, r7
schedpolicy = the_attr->schedpolicy;
107d6e: 9301 str r3, [sp, #4]
schedparam = the_attr->schedparam;
107d70: e8bc 000f ldmia.w ip!, {r0, r1, r2, r3}
107d74: c50f stmia r5!, {r0, r1, r2, r3}
107d76: e8bc 000f ldmia.w ip!, {r0, r1, r2, r3}
107d7a: c50f stmia r5!, {r0, r1, r2, r3}
107d7c: e89c 000f ldmia.w ip, {r0, r1, r2, r3}
107d80: e885 000f stmia.w r5, {r0, r1, r2, r3}
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
107d84: 68e3 ldr r3, [r4, #12]
return ENOTSUP;
107d86: 2586 movs r5, #134 ; 0x86
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
107d88: 2b00 cmp r3, #0
107d8a: f040 809f bne.w 107ecc <pthread_create+0x1e8>
error = _POSIX_Thread_Translate_sched_param(
107d8e: 9801 ldr r0, [sp, #4]
107d90: ab0d add r3, sp, #52 ; 0x34
107d92: 4639 mov r1, r7
107d94: aa0c add r2, sp, #48 ; 0x30
107d96: f003 fc7b bl 10b690 <_POSIX_Thread_Translate_sched_param>
if ( error != 0 ) {
107d9a: 4605 mov r5, r0
107d9c: 2800 cmp r0, #0
107d9e: f040 8095 bne.w 107ecc <pthread_create+0x1e8>
normal_prio = schedparam.sched_priority;
107da2: 9f12 ldr r7, [sp, #72] ; 0x48
config.scheduler = _Thread_Scheduler_get_home( executing );
107da4: f244 50b0 movw r0, #17840 ; 0x45b0
107da8: f2c0 0015 movt r0, #21
config.priority = _POSIX_Priority_To_core(
107dac: f10d 0203 add.w r2, sp, #3
config.scheduler = _Thread_Scheduler_get_home( executing );
107db0: 9006 str r0, [sp, #24]
config.priority = _POSIX_Priority_To_core(
107db2: 4639 mov r1, r7
107db4: f003 f880 bl 10aeb8 <_POSIX_Priority_To_core>
if ( !valid ) {
107db8: f89d 3003 ldrb.w r3, [sp, #3]
config.priority = _POSIX_Priority_To_core(
107dbc: e9cd 010a strd r0, r1, [sp, #40] ; 0x28
if ( !valid ) {
107dc0: 2b00 cmp r3, #0
107dc2: f000 8082 beq.w 107eca <pthread_create+0x1e6> <== ALWAYS TAKEN
if ( schedpolicy == SCHED_SPORADIC ) {
107dc6: 9b01 ldr r3, [sp, #4]
core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid );
107dc8: f10d 0203 add.w r2, sp, #3
107dcc: 9806 ldr r0, [sp, #24]
if ( schedpolicy == SCHED_SPORADIC ) {
107dce: 2b04 cmp r3, #4
low_prio = schedparam.sched_ss_low_priority;
107dd0: bf08 it eq
107dd2: 9f13 ldreq r7, [sp, #76] ; 0x4c
core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid );
107dd4: 4639 mov r1, r7
107dd6: f003 f86f bl 10aeb8 <_POSIX_Priority_To_core>
if ( !valid ) {
107dda: f89d 3003 ldrb.w r3, [sp, #3]
core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid );
107dde: 4682 mov sl, r0
107de0: 4689 mov r9, r1
if ( !valid ) {
107de2: 2b00 cmp r3, #0
107de4: d071 beq.n 107eca <pthread_create+0x1e6>
if ( the_attr->affinityset == NULL ) {
107de6: 6da3 ldr r3, [r4, #88] ; 0x58
107de8: 2b00 cmp r3, #0
107dea: d06e beq.n 107eca <pthread_create+0x1e6> <== ALWAYS TAKEN
_Assert(
_Objects_Allocator_is_owner()
|| !_System_state_Is_up( _System_state_Get() )
);
return ( *information->allocate )( information );
107dec: f240 0804 movw r8, #4
107df0: f2c0 0820 movt r8, #32
_RTEMS_Lock_allocator();
107df4: f000 fb1a bl 10842c <_RTEMS_Lock_allocator>
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void)
{
_Objects_Allocator_lock();
_Thread_Kill_zombies();
107df8: f002 fae6 bl 10a3c8 <_Thread_Kill_zombies>
return ( *information->allocate )( information );
107dfc: f8d8 3008 ldr.w r3, [r8, #8]
107e00: 4640 mov r0, r8
107e02: 4798 blx r3
if ( !the_thread ) {
107e04: 4607 mov r7, r0
107e06: 2800 cmp r0, #0
107e08: f000 8096 beq.w 107f38 <pthread_create+0x254>
if ( config.stack_area == NULL ) {
107e0c: 9b07 ldr r3, [sp, #28]
107e0e: 2b00 cmp r3, #0
107e10: d07e beq.n 107f10 <pthread_create+0x22c>
config.stack_free = _Stack_Free_nothing;
107e12: f249 13c1 movw r3, #37313 ; 0x91c1
107e16: f2c0 0310 movt r3, #16
107e1a: 9309 str r3, [sp, #36] ; 0x24
status = _Thread_Initialize(
107e1c: f240 0004 movw r0, #4
107e20: aa06 add r2, sp, #24
107e22: f2c0 0020 movt r0, #32
107e26: 4639 mov r1, r7
107e28: f001 fc44 bl 1096b4 <_Thread_Initialize>
if ( !status ) {
107e2c: 2800 cmp r0, #0
107e2e: d07b beq.n 107f28 <pthread_create+0x244> <== ALWAYS TAKEN
if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
107e30: 6d22 ldr r2, [r4, #80] ; 0x50
the_thread->Life.state |= THREAD_LIFE_DETACHED;
107e32: f8d7 3174 ldr.w r3, [r7, #372] ; 0x174
if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
107e36: b90a cbnz r2, 107e3c <pthread_create+0x158>
the_thread->Life.state |= THREAD_LIFE_DETACHED;
107e38: f043 0310 orr.w r3, r3, #16
the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED;
107e3c: f043 0308 orr.w r3, r3, #8
107e40: f8c7 3174 str.w r3, [r7, #372] ; 0x174
__asm__ volatile (
107e44: f3ef 8300 mrs r3, CPSR
107e48: f043 0280 orr.w r2, r3, #128 ; 0x80
107e4c: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( &lock_context );
107e50: 9302 str r3, [sp, #8]
status = _Scheduler_Set_affinity(
107e52: e9d4 1215 ldrd r1, r2, [r4, #84] ; 0x54
107e56: 4638 mov r0, r7
107e58: f001 f99a bl 109190 <_Scheduler_Set_affinity>
__asm__ volatile (
107e5c: 9b02 ldr r3, [sp, #8]
107e5e: f383 8900 msr CPSR_fc, r3
if ( !status ) {
107e62: 2800 cmp r0, #0
107e64: d06c beq.n 107f40 <pthread_create+0x25c> <== ALWAYS TAKEN
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
107e66: 6922 ldr r2, [r4, #16]
api->Sporadic.sched_ss_repl_period =
107e68: f104 0320 add.w r3, r4, #32
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
107e6c: f8d7 c160 ldr.w ip, [r7, #352] ; 0x160
api->Sporadic.sched_ss_init_budget =
107e70: f104 0830 add.w r8, r4, #48 ; 0x30
api->Sporadic.sched_ss_max_repl =
107e74: 6c24 ldr r4, [r4, #64] ; 0x40
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
107e76: f1a2 0201 sub.w r2, r2, #1
107e7a: fab2 f282 clz r2, r2
api->Sporadic.sched_ss_init_budget =
107e7e: f10c 0e50 add.w lr, ip, #80 ; 0x50
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
107e82: 0952 lsrs r2, r2, #5
107e84: f887 208b strb.w r2, [r7, #139] ; 0x8b
api->Sporadic.sched_ss_repl_period =
107e88: cb0f ldmia r3, {r0, r1, r2, r3}
RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
107e8a: e9cc a90e strd sl, r9, [ip, #56] ; 0x38
107e8e: f10c 0940 add.w r9, ip, #64 ; 0x40
107e92: e889 000f stmia.w r9, {r0, r1, r2, r3}
api->Sporadic.sched_ss_init_budget =
107e96: e898 000f ldmia.w r8, {r0, r1, r2, r3}
107e9a: e88e 000f stmia.w lr, {r0, r1, r2, r3}
if ( schedpolicy == SCHED_SPORADIC ) {
107e9e: 9b01 ldr r3, [sp, #4]
api->Sporadic.sched_ss_max_repl =
107ea0: f8cc 4060 str.w r4, [ip, #96] ; 0x60
if ( schedpolicy == SCHED_SPORADIC ) {
107ea4: 2b04 cmp r3, #4
107ea6: d057 beq.n 107f58 <pthread_create+0x274>
__asm__ volatile (
107ea8: f3ef 8300 mrs r3, CPSR
107eac: f043 0280 orr.w r2, r3, #128 ; 0x80
107eb0: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( &lock_context );
107eb4: 9302 str r3, [sp, #8]
status = _Thread_Start( the_thread, &entry, &lock_context );
107eb6: aa02 add r2, sp, #8
107eb8: a903 add r1, sp, #12
107eba: 4638 mov r0, r7
107ebc: f002 fbbc bl 10a638 <_Thread_Start>
*thread = the_thread->Object.id;
107ec0: 68bb ldr r3, [r7, #8]
107ec2: 6033 str r3, [r6, #0]
_RTEMS_Unlock_allocator();
107ec4: f000 fab8 bl 108438 <_RTEMS_Unlock_allocator>
return 0;
107ec8: e000 b.n 107ecc <pthread_create+0x1e8>
switch ( the_attr->inheritsched ) {
107eca: 2516 movs r5, #22
}
107ecc: 4628 mov r0, r5
107ece: b01e add sp, #120 ; 0x78
107ed0: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
107ed4: f244 538c movw r3, #17804 ; 0x458c
107ed8: f2c0 0315 movt r3, #21
107edc: 681b ldr r3, [r3, #0]
107ede: 429d cmp r5, r3
107ee0: bf38 it cc
107ee2: 461d movcc r5, r3
config.stack_size = _POSIX_Threads_Ensure_minimum_stack(
107ee4: 9508 str r5, [sp, #32]
}
#else
(void) is_fp;
#endif
stack_size += _TLS_Get_allocation_size();
107ee6: f002 fc85 bl 10a7f4 <_TLS_Get_allocation_size>
switch ( the_attr->inheritsched ) {
107eea: 6923 ldr r3, [r4, #16]
107eec: 4405 add r5, r0
config.stack_size = _Stack_Extend_size( config.stack_size, config.is_fp );
107eee: 9508 str r5, [sp, #32]
switch ( the_attr->inheritsched ) {
107ef0: 2b01 cmp r3, #1
107ef2: f47f af34 bne.w 107d5e <pthread_create+0x7a>
error = pthread_getschedparam(
107ef6: af12 add r7, sp, #72 ; 0x48
107ef8: f000 f9b8 bl 10826c <pthread_self>
107efc: 463a mov r2, r7
107efe: a901 add r1, sp, #4
107f00: f000 f90e bl 108120 <pthread_getschedparam>
break;
107f04: e73e b.n 107d84 <pthread_create+0xa0>
return EFAULT;
107f06: 250e movs r5, #14
}
107f08: 4628 mov r0, r5
107f0a: b01e add sp, #120 ; 0x78
107f0c: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
config.stack_free = _Stack_Free;
107f10: f24a 632d movw r3, #42541 ; 0xa62d
config.stack_area = _Stack_Allocate( config.stack_size );
107f14: 9808 ldr r0, [sp, #32]
config.stack_free = _Stack_Free;
107f16: f2c0 0310 movt r3, #16
107f1a: 9309 str r3, [sp, #36] ; 0x24
config.stack_area = _Stack_Allocate( config.stack_size );
107f1c: f002 fb80 bl 10a620 <_Stack_Allocate>
107f20: 9007 str r0, [sp, #28]
if ( status ) {
107f22: 2800 cmp r0, #0
107f24: f47f af7a bne.w 107e1c <pthread_create+0x138>
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
107f28: f240 0004 movw r0, #4
107f2c: f8d8 300c ldr.w r3, [r8, #12]
107f30: 4639 mov r1, r7
107f32: f2c0 0020 movt r0, #32
107f36: 4798 blx r3
return EAGAIN;
107f38: 250b movs r5, #11
_RTEMS_Unlock_allocator();
107f3a: f000 fa7d bl 108438 <_RTEMS_Unlock_allocator>
107f3e: e7c5 b.n 107ecc <pthread_create+0x1e8>
( *information->deallocate )( information, the_object );
107f40: f240 0004 movw r0, #4 <== NOT EXECUTED
107f44: f8d8 300c ldr.w r3, [r8, #12] <== NOT EXECUTED
107f48: 4639 mov r1, r7 <== NOT EXECUTED
107f4a: f2c0 0020 movt r0, #32 <== NOT EXECUTED
return EINVAL;
107f4e: 2516 movs r5, #22 <== NOT EXECUTED
107f50: 4798 blx r3 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
107f52: f000 fa71 bl 108438 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
return EINVAL;
107f56: e7b9 b.n 107ecc <pthread_create+0x1e8> <== NOT EXECUTED
_POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer );
107f58: f10c 0008 add.w r0, ip, #8
107f5c: f7ff fe58 bl 107c10 <_POSIX_Threads_Sporadic_timer>
107f60: e7a2 b.n 107ea8 <pthread_create+0x1c4>
107f62: bf00 nop
00107ff4 <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
)
{
107ff4: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
_Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information );
107ff8: f240 0904 movw r9, #4
107ffc: 4604 mov r4, r0
107ffe: f2c0 0920 movt r9, #32
_RTEMS_Lock_allocator();
108002: f000 fbe3 bl 1087cc <_RTEMS_Lock_allocator>
108006: 4620 mov r0, r4
108008: 4649 mov r1, r9
the_key = _POSIX_Keys_Get( key );
if ( the_key != NULL ) {
_POSIX_Keys_Destroy( the_key );
eno = 0;
} else {
eno = EINVAL;
10800a: 2416 movs r4, #22
10800c: f002 f8e2 bl 10a1d4 <_Objects_Get_no_protection>
if ( the_key != NULL ) {
108010: b380 cbz r0, 108074 <pthread_key_delete+0x80>
108012: 4605 mov r5, r0
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
108014: 4601 mov r1, r0
108016: 4648 mov r0, r9
return &the_chain->Tail.Node;
108018: f105 0818 add.w r8, r5, #24
10801c: f002 f858 bl 10a0d0 <_Objects_Close>
return _Chain_Immutable_head( the_chain )->next;
108020: 696c ldr r4, [r5, #20]
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
108022: 45a0 cmp r8, r4
108024: d01d beq.n 108062 <pthread_key_delete+0x6e>
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
108026: f641 6768 movw r7, #7784 ; 0x1e68
10802a: f2c0 0720 movt r7, #32
the_thread = key_value_pair->thread;
10802e: 69e0 ldr r0, [r4, #28]
__asm__ volatile (
108030: f3ef 8600 mrs r6, CPSR
108034: f046 0380 orr.w r3, r6, #128 ; 0x80
108038: f383 8900 msr CPSR_fc, r3
_RBTree_Extract(
10803c: f104 0108 add.w r1, r4, #8
108040: f500 70b2 add.w r0, r0, #356 ; 0x164
108044: f002 f918 bl 10a278 <_RBTree_Extract>
__asm__ volatile (
108048: f386 8900 msr CPSR_fc, r6
previous = the_node->previous;
10804c: e9d4 2300 ldrd r2, r3, [r4]
108050: 4621 mov r1, r4
108052: 4638 mov r0, r7
next->previous = previous;
108054: 6053 str r3, [r2, #4]
previous->next = next;
108056: 601a str r2, [r3, #0]
108058: f000 fc3c bl 1088d4 <_Freechain_Put>
return _Chain_Immutable_head( the_chain )->next;
10805c: 696c ldr r4, [r5, #20]
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
10805e: 4544 cmp r4, r8
108060: d1e5 bne.n 10802e <pthread_key_delete+0x3a> <== ALWAYS TAKEN
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
108062: f240 0004 movw r0, #4
108066: f8d9 300c ldr.w r3, [r9, #12]
10806a: 4629 mov r1, r5
10806c: f2c0 0020 movt r0, #32
eno = 0;
108070: 2400 movs r4, #0
108072: 4798 blx r3
_RTEMS_Unlock_allocator();
108074: f000 fbb0 bl 1087d8 <_RTEMS_Unlock_allocator>
}
_Objects_Allocator_unlock();
return eno;
}
108078: 4620 mov r0, r4
10807a: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
10807e: bf00 nop
00109118 <pthread_mutex_getprioceiling>:
if ( prioceiling == NULL ) {
return EINVAL;
}
the_mutex = _POSIX_Mutex_Get( RTEMS_DECONST( pthread_mutex_t *, mutex ) );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
109118: 2800 cmp r0, #0
10911a: bf18 it ne
10911c: 2900 cmpne r1, #0
10911e: d02e beq.n 10917e <pthread_mutex_getprioceiling+0x66>
{
109120: b5f8 push {r3, r4, r5, r6, r7, lr}
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
109122: f241 33b8 movw r3, #5048 ; 0x13b8
109126: 6806 ldr r6, [r0, #0]
109128: f2c9 631c movt r3, #38428 ; 0x961c
10912c: 460d mov r5, r1
10912e: 4604 mov r4, r0
109130: ea80 0206 eor.w r2, r0, r6
109134: 4053 eors r3, r2
109136: f033 0307 bics.w r3, r3, #7
10913a: d110 bne.n 10915e <pthread_mutex_getprioceiling+0x46>
__asm__ volatile (
10913c: f3ef 8700 mrs r7, CPSR
109140: f047 0380 orr.w r3, r7, #128 ; 0x80
109144: f383 8900 msr CPSR_fc, r3
RTEMS_INLINE_ROUTINE POSIX_Mutex_Protocol _POSIX_Mutex_Get_protocol(
unsigned long flags
)
{
return flags & POSIX_MUTEX_PROTOCOL_MASK;
109148: f006 0603 and.w r6, r6, #3
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_protocol( flags ) == POSIX_MUTEX_PRIORITY_CEILING ) {
10914c: 2e02 cmp r6, #2
*prioceiling = _POSIX_Priority_From_core(
_POSIX_Mutex_Get_scheduler( the_mutex ),
_POSIX_Mutex_Get_priority( the_mutex )
);
} else {
*prioceiling = 0;
10914e: bf1c itt ne
109150: 2300 movne r3, #0
109152: 602b strne r3, [r5, #0]
if ( _POSIX_Mutex_Get_protocol( flags ) == POSIX_MUTEX_PRIORITY_CEILING ) {
109154: d009 beq.n 10916a <pthread_mutex_getprioceiling+0x52>
__asm__ volatile (
109156: f387 8900 msr CPSR_fc, r7
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return 0;
10915a: 2000 movs r0, #0
}
10915c: bdf8 pop {r3, r4, r5, r6, r7, pc}
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10915e: f000 f9a5 bl 1094ac <_POSIX_Mutex_Auto_initialization>
109162: 2800 cmp r0, #0
109164: d1ea bne.n 10913c <pthread_mutex_getprioceiling+0x24> <== NEVER TAKEN
109166: 2016 movs r0, #22 <== NOT EXECUTED
}
109168: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
*prioceiling = _POSIX_Priority_From_core(
10916a: f245 6038 movw r0, #22072 ; 0x5638
10916e: e9d4 230c ldrd r2, r3, [r4, #48] ; 0x30
109172: f2c0 0011 movt r0, #17
109176: f000 fa87 bl 109688 <_POSIX_Priority_From_core>
10917a: 6028 str r0, [r5, #0]
10917c: e7eb b.n 109156 <pthread_mutex_getprioceiling+0x3e>
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10917e: 2016 movs r0, #22
}
109180: 4770 bx lr
109182: bf00 nop
001093d4 <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
1093d4: b5f0 push {r4, r5, r6, r7, lr}
1093d6: b08b sub sp, #44 ; 0x2c
POSIX_Mutex_Control *the_mutex;
int error;
int unlock_error;
if ( old_ceiling == NULL ) {
1093d8: b19a cbz r2, 109402 <pthread_mutex_setprioceiling+0x2e>
/*
* Must acquire the mutex before we can change it's ceiling.
* POSIX says block until we acquire it.
*/
error = pthread_mutex_lock( mutex );
1093da: 4606 mov r6, r0
1093dc: 460f mov r7, r1
1093de: 4615 mov r5, r2
1093e0: f7ff ff2e bl 109240 <pthread_mutex_lock>
if ( error != 0 ) {
1093e4: 4604 mov r4, r0
1093e6: b960 cbnz r0, 109402 <pthread_mutex_setprioceiling+0x2e>
return flags & POSIX_MUTEX_PROTOCOL_MASK;
1093e8: 6833 ldr r3, [r6, #0]
1093ea: f003 0303 and.w r3, r3, #3
return EINVAL;
}
the_mutex = _POSIX_Mutex_Get( mutex );
if (
1093ee: 2b02 cmp r3, #2
error = 0;
} else {
error = EINVAL;
}
} else {
*old_ceiling = 0;
1093f0: bf18 it ne
1093f2: 6028 strne r0, [r5, #0]
if (
1093f4: d009 beq.n 10940a <pthread_mutex_setprioceiling+0x36>
error = 0;
}
unlock_error = pthread_mutex_unlock( mutex );
1093f6: 4630 mov r0, r6
1093f8: f000 f886 bl 109508 <pthread_mutex_unlock>
_Assert( unlock_error == 0 );
(void) unlock_error;
return error;
}
1093fc: 4620 mov r0, r4
1093fe: b00b add sp, #44 ; 0x2c
109400: bdf0 pop {r4, r5, r6, r7, pc}
return EINVAL;
109402: 2416 movs r4, #22
}
109404: 4620 mov r0, r4
109406: b00b add sp, #44 ; 0x2c
109408: bdf0 pop {r4, r5, r6, r7, pc}
*old_ceiling = _POSIX_Priority_From_core( scheduler, old_priority );
10940a: f245 6038 movw r0, #22072 ; 0x5638
10940e: e9d6 230c ldrd r2, r3, [r6, #48] ; 0x30
109412: f2c0 0011 movt r0, #17
109416: f000 f937 bl 109688 <_POSIX_Priority_From_core>
10941a: 6028 str r0, [r5, #0]
new_priority = _POSIX_Priority_To_core( scheduler, prioceiling, &valid );
10941c: f245 6038 movw r0, #22072 ; 0x5638
109420: f10d 0203 add.w r2, sp, #3
109424: 4639 mov r1, r7
109426: f2c0 0011 movt r0, #17
10942a: f000 f911 bl 109650 <_POSIX_Priority_To_core>
if ( valid ) {
10942e: f89d 3003 ldrb.w r3, [sp, #3]
new_priority = _POSIX_Priority_To_core( scheduler, prioceiling, &valid );
109432: 4602 mov r2, r0
if ( valid ) {
109434: b90b cbnz r3, 10943a <pthread_mutex_setprioceiling+0x66>
error = EINVAL;
109436: 2416 movs r4, #22
109438: e7dd b.n 1093f6 <pthread_mutex_setprioceiling+0x22>
return the_mutex->Recursive.Mutex.Queue.Queue.owner;
10943a: 6930 ldr r0, [r6, #16]
10943c: 9406 str r4, [sp, #24]
if ( owner != NULL ) {
10943e: b300 cbz r0, 109482 <pthread_mutex_setprioceiling+0xae>
__asm__ volatile (
109440: f3ef 8300 mrs r3, CPSR
109444: f043 0580 orr.w r5, r3, #128 ; 0x80
109448: f385 8900 msr CPSR_fc, r5
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 );
10944c: 9301 str r3, [sp, #4]
_Thread_Priority_changed(
10944e: af01 add r7, sp, #4
node->priority = priority;
109450: 6332 str r2, [r6, #48] ; 0x30
109452: 6371 str r1, [r6, #52] ; 0x34
109454: 463b mov r3, r7
109456: 4622 mov r2, r4
109458: f106 0120 add.w r1, r6, #32
10945c: f001 fe10 bl 10b080 <_Thread_Priority_changed>
__asm__ volatile (
109460: 9b01 ldr r3, [sp, #4]
109462: f383 8900 msr CPSR_fc, r3
disable_level = cpu_self->thread_dispatch_disable_level;
109466: f642 25c0 movw r5, #10944 ; 0x2ac0
_Thread_Priority_update( &queue_context );
10946a: 4638 mov r0, r7
10946c: f2c0 0520 movt r5, #32
109470: 692b ldr r3, [r5, #16]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
109472: 3301 adds r3, #1
109474: 612b str r3, [r5, #16]
109476: f001 fe27 bl 10b0c8 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
10947a: 4628 mov r0, r5
10947c: f001 fef8 bl 10b270 <_Thread_Dispatch_enable>
error = 0;
109480: e7b9 b.n 1093f6 <pthread_mutex_setprioceiling+0x22>
the_mutex->Priority_ceiling.priority = priority_ceiling;
109482: af01 add r7, sp, #4 <== NOT EXECUTED
109484: e9c6 210c strd r2, r1, [r6, #48] ; 0x30 <== NOT EXECUTED
109488: e7ed b.n 109466 <pthread_mutex_setprioceiling+0x92> <== NOT EXECUTED
10948a: bf00 nop
00109508 <pthread_mutex_unlock>:
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
109508: 2800 cmp r0, #0
10950a: f000 809f beq.w 10964c <pthread_mutex_unlock+0x144>
{
10950e: b5f0 push {r4, r5, r6, r7, lr}
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
109510: f241 33b8 movw r3, #5048 ; 0x13b8
109514: 6805 ldr r5, [r0, #0]
109516: f2c9 631c movt r3, #38428 ; 0x961c
{
10951a: b08d sub sp, #52 ; 0x34
10951c: 4604 mov r4, r0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10951e: ea80 0205 eor.w r2, r0, r5
109522: 4053 eors r3, r2
109524: f033 0307 bics.w r3, r3, #7
109528: d13c bne.n 1095a4 <pthread_mutex_unlock+0x9c>
__asm__ volatile (
10952a: f3ef 8300 mrs r3, CPSR
10952e: f043 0280 orr.w r2, r3, #128 ; 0x80
109532: f382 8900 msr CPSR_fc, r2
109536: f642 26c0 movw r6, #10944 ; 0x2ac0
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
10953a: f015 0503 ands.w r5, r5, #3
10953e: f2c0 0620 movt r6, #32
109542: 9303 str r3, [sp, #12]
109544: 69b2 ldr r2, [r6, #24]
109546: d024 beq.n 109592 <pthread_mutex_unlock+0x8a>
109548: 2d02 cmp r5, #2
10954a: d014 beq.n 109576 <pthread_mutex_unlock+0x6e>
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
10954c: 6923 ldr r3, [r4, #16]
10954e: 429a cmp r2, r3
109550: d122 bne.n 109598 <pthread_mutex_unlock+0x90>
nest_level = the_mutex->Recursive.nest_level;
109552: 69a5 ldr r5, [r4, #24]
if ( nest_level > 0 ) {
109554: 2d00 cmp r5, #0
109556: d171 bne.n 10963c <pthread_mutex_unlock+0x134> <== ALWAYS TAKEN
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
109558: 68e1 ldr r1, [r4, #12]
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
10955a: 6125 str r5, [r4, #16]
if ( heads == NULL ) {
10955c: b199 cbz r1, 109586 <pthread_mutex_unlock+0x7e>
_Thread_queue_Surrender(
10955e: f645 43fc movw r3, #23804 ; 0x5cfc
109562: f104 000c add.w r0, r4, #12
109566: f2c0 0311 movt r3, #17
10956a: 9300 str r3, [sp, #0]
10956c: ab03 add r3, sp, #12
10956e: f002 f915 bl 10b79c <_Thread_queue_Surrender>
return STATUS_SUCCESSFUL;
109572: 4628 mov r0, r5
&queue_context
);
break;
}
return _POSIX_Get_error( status );
109574: e014 b.n 1095a0 <pthread_mutex_unlock+0x98>
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 ) ) {
109576: 6923 ldr r3, [r4, #16]
109578: 429a cmp r2, r3
10957a: d10d bne.n 109598 <pthread_mutex_unlock+0x90> <== ALWAYS TAKEN
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
10957c: 69a3 ldr r3, [r4, #24]
if ( nest_level > 0 ) {
10957e: 2b00 cmp r3, #0
109580: d02a beq.n 1095d8 <pthread_mutex_unlock+0xd0> <== NEVER TAKEN
the_mutex->Recursive.nest_level = nest_level - 1;
109582: 3b01 subs r3, #1 <== NOT EXECUTED
109584: 61a3 str r3, [r4, #24] <== NOT EXECUTED
__asm__ volatile (
109586: 9b03 ldr r3, [sp, #12]
109588: f383 8900 msr CPSR_fc, r3
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_SUCCESSFUL;
10958c: 2000 movs r0, #0
}
10958e: b00d add sp, #52 ; 0x34
109590: bdf0 pop {r4, r5, r6, r7, pc}
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
109592: 6923 ldr r3, [r4, #16]
109594: 429a cmp r2, r3
109596: d00c beq.n 1095b2 <pthread_mutex_unlock+0xaa>
109598: 9b03 ldr r3, [sp, #12]
10959a: f383 8900 msr CPSR_fc, r3
return STATUS_NOT_OWNER;
10959e: 2001 movs r0, #1
1095a0: b00d add sp, #52 ; 0x34
1095a2: bdf0 pop {r4, r5, r6, r7, pc}
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
1095a4: f7ff ff82 bl 1094ac <_POSIX_Mutex_Auto_initialization>
1095a8: 2800 cmp r0, #0
1095aa: d1be bne.n 10952a <pthread_mutex_unlock+0x22>
1095ac: 2016 movs r0, #22
}
1095ae: b00d add sp, #52 ; 0x34
1095b0: bdf0 pop {r4, r5, r6, r7, pc}
nest_level = the_mutex->Recursive.nest_level;
1095b2: 69a6 ldr r6, [r4, #24]
if ( nest_level > 0 ) {
1095b4: 2e00 cmp r6, #0
1095b6: d13a bne.n 10962e <pthread_mutex_unlock+0x126> <== ALWAYS TAKEN
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
1095b8: 68e1 ldr r1, [r4, #12]
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
1095ba: 6126 str r6, [r4, #16]
if ( heads == NULL ) {
1095bc: 2900 cmp r1, #0
1095be: d0e2 beq.n 109586 <pthread_mutex_unlock+0x7e>
_Thread_queue_Surrender(
1095c0: f645 43c0 movw r3, #23744 ; 0x5cc0
1095c4: f104 000c add.w r0, r4, #12
1095c8: f2c0 0311 movt r3, #17
1095cc: 9300 str r3, [sp, #0]
1095ce: ab03 add r3, sp, #12
1095d0: f002 f8e4 bl 10b79c <_Thread_queue_Surrender>
return STATUS_SUCCESSFUL;
1095d4: 4630 mov r0, r6
1095d6: e7e3 b.n 1095a0 <pthread_mutex_unlock+0x98>
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
1095d8: f104 0720 add.w r7, r4, #32
1095dc: 4610 mov r0, r2
1095de: 4639 mov r1, r7
1095e0: aa03 add r2, sp, #12
1095e2: 9308 str r3, [sp, #32]
1095e4: f001 fd28 bl 10b038 <_Thread_Priority_remove>
disable_level = cpu_self->thread_dispatch_disable_level;
1095e8: 6933 ldr r3, [r6, #16]
);
_Thread_Wait_release_default_critical( executing, &lock_context );
cpu_self = _Thread_queue_Dispatch_disable( queue_context );
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
1095ea: 68e0 ldr r0, [r4, #12]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
1095ec: 3301 adds r3, #1
1095ee: 6133 str r3, [r6, #16]
if ( heads != NULL ) {
1095f0: b338 cbz r0, 109642 <pthread_mutex_unlock+0x13a>
const Thread_queue_Operations *operations;
Thread_Control *new_owner;
operations = POSIX_MUTEX_PRIORITY_CEILING_TQ_OPERATIONS;
new_owner = ( *operations->first )( heads );
1095f2: f645 45e8 movw r5, #23784 ; 0x5ce8
1095f6: f2c0 0511 movt r5, #17
1095fa: 692b ldr r3, [r5, #16]
1095fc: 4798 blx r3
_POSIX_Mutex_Set_owner( the_mutex, new_owner );
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
1095fe: 4639 mov r1, r7
new_owner = ( *operations->first )( heads );
109600: 4606 mov r6, r0
_Thread_Priority_add(
109602: aa03 add r2, sp, #12
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
109604: 6120 str r0, [r4, #16]
_Thread_Priority_add(
109606: f001 fcf5 bl 10aff4 <_Thread_Priority_add>
new_owner,
&the_mutex->Priority_ceiling,
queue_context
);
_Thread_queue_Extract_critical(
10960a: ab03 add r3, sp, #12
10960c: 4632 mov r2, r6
10960e: 4629 mov r1, r5
109610: f104 000c add.w r0, r4, #12
109614: f002 f846 bl 10b6a4 <_Thread_queue_Extract_critical>
} else {
_POSIX_Mutex_Set_owner( the_mutex, NULL );
_POSIX_Mutex_Release( the_mutex, queue_context );
}
_Thread_Priority_update( queue_context );
109618: a803 add r0, sp, #12
10961a: f001 fd55 bl 10b0c8 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
10961e: f642 20c0 movw r0, #10944 ; 0x2ac0
109622: f2c0 0020 movt r0, #32
109626: f001 fe23 bl 10b270 <_Thread_Dispatch_enable>
return STATUS_SUCCESSFUL;
10962a: 2000 movs r0, #0
10962c: e7b8 b.n 1095a0 <pthread_mutex_unlock+0x98>
the_mutex->Recursive.nest_level = nest_level - 1;
10962e: 3e01 subs r6, #1 <== NOT EXECUTED
109630: 61a6 str r6, [r4, #24] <== NOT EXECUTED
109632: 9b03 ldr r3, [sp, #12] <== NOT EXECUTED
109634: f383 8900 msr CPSR_fc, r3 <== NOT EXECUTED
return STATUS_SUCCESSFUL;
109638: 4628 mov r0, r5 <== NOT EXECUTED
10963a: e7b1 b.n 1095a0 <pthread_mutex_unlock+0x98> <== NOT EXECUTED
the_mutex->Recursive.nest_level = nest_level - 1;
10963c: 3d01 subs r5, #1 <== NOT EXECUTED
10963e: 61a5 str r5, [r4, #24] <== NOT EXECUTED
Thread_queue_Queue *queue,
ISR_lock_Context *lock_context
)
{
_Thread_queue_Queue_release_critical( queue, lock_context );
_ISR_lock_ISR_enable( lock_context );
109640: e7a1 b.n 109586 <pthread_mutex_unlock+0x7e> <== NOT EXECUTED
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
109642: 6120 str r0, [r4, #16]
109644: 9b03 ldr r3, [sp, #12]
109646: f383 8900 msr CPSR_fc, r3
}
10964a: e7e5 b.n 109618 <pthread_mutex_unlock+0x110>
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
10964c: 2016 movs r0, #22
}
10964e: 4770 bx lr
001090b4 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
1090b4: 4603 mov r3, r0
1090b6: b130 cbz r0, 1090c6 <pthread_mutexattr_setpshared+0x12>
1090b8: 6802 ldr r2, [r0, #0]
1090ba: b122 cbz r2, 1090c6 <pthread_mutexattr_setpshared+0x12>
return EINVAL;
switch ( pshared ) {
1090bc: 2901 cmp r1, #1
1090be: d802 bhi.n 1090c6 <pthread_mutexattr_setpshared+0x12> <== ALWAYS TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
1090c0: 2000 movs r0, #0
attr->process_shared = pshared;
1090c2: 6059 str r1, [r3, #4]
return 0;
1090c4: 4770 bx lr
return EINVAL;
1090c6: 2016 movs r0, #22
default:
return EINVAL;
}
}
1090c8: 4770 bx lr
1090ca: bf00 nop
00108a0c <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
108a0c: 4603 mov r3, r0
108a0e: b130 cbz r0, 108a1e <pthread_rwlockattr_setpshared+0x12>
return EINVAL;
if ( !attr->is_initialized )
108a10: 6802 ldr r2, [r0, #0]
108a12: b122 cbz r2, 108a1e <pthread_rwlockattr_setpshared+0x12>
return EINVAL;
switch ( pshared ) {
108a14: 2901 cmp r1, #1
108a16: d802 bhi.n 108a1e <pthread_rwlockattr_setpshared+0x12> <== ALWAYS TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
108a18: 2000 movs r0, #0
attr->process_shared = pshared;
108a1a: 6059 str r1, [r3, #4]
return 0;
108a1c: 4770 bx lr
return EINVAL;
108a1e: 2016 movs r0, #22
default:
return EINVAL;
}
}
108a20: 4770 bx lr
108a22: bf00 nop
00107830 <pthread_setcancelstate>:
int pthread_setcancelstate(
int state,
int *oldstate
)
{
107830: b538 push {r3, r4, r5, lr}
107832: 4604 mov r4, r0
107834: 460d mov r5, r1
Thread_Life_state new_life_protection;
Thread_Life_state previous_life_state;
if ( _ISR_Is_in_progress() ) {
107836: f000 f96f bl 107b18 <_ISR_Is_in_progress>
10783a: b978 cbnz r0, 10785c <pthread_setcancelstate+0x2c>
return EPROTO;
}
if ( state == PTHREAD_CANCEL_DISABLE ) {
10783c: 2c01 cmp r4, #1
10783e: d001 beq.n 107844 <pthread_setcancelstate+0x14> <== ALWAYS TAKEN
new_life_protection = THREAD_LIFE_PROTECTED;
} else if ( state == PTHREAD_CANCEL_ENABLE ) {
new_life_protection = 0;
} else {
return EINVAL;
107840: 2016 movs r0, #22
} else if ( state == PTHREAD_CANCEL_ENABLE ) {
107842: b954 cbnz r4, 10785a <pthread_setcancelstate+0x2a>
}
previous_life_state = _Thread_Set_life_protection( new_life_protection );
107844: 4620 mov r0, r4
107846: f002 fb27 bl 109e98 <_Thread_Set_life_protection>
if ( oldstate != NULL ) {
10784a: b14d cbz r5, 107860 <pthread_setcancelstate+0x30>
if ( ( previous_life_state & THREAD_LIFE_PROTECTED ) != 0 ) {
10784c: f010 0301 ands.w r3, r0, #1
} else {
*oldstate = PTHREAD_CANCEL_ENABLE;
}
}
return 0;
107850: f04f 0000 mov.w r0, #0
*oldstate = PTHREAD_CANCEL_DISABLE;
107854: bf18 it ne
107856: 2301 movne r3, #1
107858: 602b str r3, [r5, #0]
}
10785a: bd38 pop {r3, r4, r5, pc}
return EPROTO;
10785c: 2047 movs r0, #71 ; 0x47
}
10785e: bd38 pop {r3, r4, r5, pc}
return 0;
107860: 4628 mov r0, r5
}
107862: bd38 pop {r3, r4, r5, pc}
00109c7c <pthread_setschedparam>:
const struct sched_param *param
#else
struct sched_param *param
#endif
)
{
109c7c: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Per_CPU_Control *cpu_self;
Thread_queue_Context queue_context;
int error;
if ( param == NULL ) {
return EINVAL;
109c80: 2516 movs r5, #22
{
109c82: b091 sub sp, #68 ; 0x44
if ( param == NULL ) {
109c84: b152 cbz r2, 109c9c <pthread_setschedparam+0x20>
}
error = _POSIX_Thread_Translate_sched_param(
109c86: 460e mov r6, r1
109c88: 4614 mov r4, r2
109c8a: 4607 mov r7, r0
109c8c: ab06 add r3, sp, #24
109c8e: aa05 add r2, sp, #20
109c90: 4621 mov r1, r4
109c92: 4630 mov r0, r6
109c94: f003 fb1a bl 10d2cc <_POSIX_Thread_Translate_sched_param>
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( error != 0 ) {
109c98: 4605 mov r5, r0
109c9a: b118 cbz r0, 109ca4 <pthread_setschedparam+0x28>
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;
}
109c9c: 4628 mov r0, r5
109c9e: b011 add sp, #68 ; 0x44
109ca0: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );
109ca4: 4638 mov r0, r7
109ca6: a907 add r1, sp, #28
queue_context->Priority.update_count = 0;
109ca8: 950c str r5, [sp, #48] ; 0x30
109caa: f001 fb01 bl 10b2b0 <_Thread_Get>
if ( the_thread == NULL ) {
109cae: 4607 mov r7, r0
109cb0: 2800 cmp r0, #0
109cb2: f000 808b beq.w 109dcc <pthread_setschedparam+0x150>
error = _POSIX_Set_sched_param(
109cb6: 9b05 ldr r3, [sp, #20]
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
109cb8: f245 6038 movw r0, #22072 ; 0x5638
normal_prio = param->sched_priority;
109cbc: f8d4 8000 ldr.w r8, [r4]
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
109cc0: f2c0 0011 movt r0, #17
109cc4: f10d 0213 add.w r2, sp, #19
error = _POSIX_Set_sched_param(
109cc8: 9300 str r3, [sp, #0]
109cca: 9b06 ldr r3, [sp, #24]
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
109ccc: 4641 mov r1, r8
error = _POSIX_Set_sched_param(
109cce: 9301 str r3, [sp, #4]
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
109cd0: f7ff fcbe bl 109650 <_POSIX_Priority_To_core>
if ( !valid ) {
109cd4: f89d 3013 ldrb.w r3, [sp, #19]
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
109cd8: 4682 mov sl, r0
109cda: 4689 mov r9, r1
if ( !valid ) {
109cdc: 2b00 cmp r3, #0
109cde: d06f beq.n 109dc0 <pthread_setschedparam+0x144> <== ALWAYS TAKEN
if ( policy == SCHED_SPORADIC ) {
109ce0: 2e04 cmp r6, #4
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
109ce2: f245 6038 movw r0, #22072 ; 0x5638
low_prio = param->sched_ss_low_priority;
109ce6: bf08 it eq
109ce8: f8d4 8004 ldreq.w r8, [r4, #4]
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
109cec: f10d 0213 add.w r2, sp, #19
109cf0: f2c0 0011 movt r0, #17
109cf4: 4641 mov r1, r8
109cf6: f7ff fcab bl 109650 <_POSIX_Priority_To_core>
if ( !valid ) {
109cfa: f89d 3013 ldrb.w r3, [sp, #19]
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
109cfe: e9cd 0102 strd r0, r1, [sp, #8]
if ( !valid ) {
109d02: 2b00 cmp r3, #0
109d04: d05c beq.n 109dc0 <pthread_setschedparam+0x144>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
109d06: f8d7 8160 ldr.w r8, [r7, #352] ; 0x160
_Watchdog_Remove(
109d0a: 4840 ldr r0, [pc, #256] ; (109e0c <pthread_setschedparam+0x190>)
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
109d0c: f108 0b08 add.w fp, r8, #8
109d10: 4659 mov r1, fp
109d12: f002 fd11 bl 10c738 <_Watchdog_Remove>
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
109d16: f8d8 3034 ldr.w r3, [r8, #52] ; 0x34
_Thread_Priority_add(
109d1a: f107 0120 add.w r1, r7, #32
109d1e: e9c7 a90c strd sl, r9, [r7, #48] ; 0x30
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
109d22: 3301 adds r3, #1
109d24: d054 beq.n 109dd0 <pthread_setschedparam+0x154>
_Thread_Priority_add(
109d26: 4638 mov r0, r7
109d28: aa07 add r2, sp, #28
109d2a: f001 f963 bl 10aff4 <_Thread_Priority_add>
_Thread_Priority_remove(
109d2e: aa07 add r2, sp, #28
109d30: f108 0128 add.w r1, r8, #40 ; 0x28
109d34: 4638 mov r0, r7
109d36: f001 f97f bl 10b038 <_Thread_Priority_remove>
109d3a: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
109d3e: f8c8 3034 str.w r3, [r8, #52] ; 0x34
the_thread->budget_algorithm = budget_algorithm;
109d42: 9b00 ldr r3, [sp, #0]
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
109d44: f104 0c18 add.w ip, r4, #24
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
109d48: f108 0940 add.w r9, r8, #64 ; 0x40
api->Sporadic.sched_ss_max_repl = param->sched_ss_max_repl;
109d4c: f8d4 e028 ldr.w lr, [r4, #40] ; 0x28
if ( policy == SCHED_SPORADIC ) {
109d50: 2e04 cmp r6, #4
the_thread->budget_algorithm = budget_algorithm;
109d52: f8c7 3090 str.w r3, [r7, #144] ; 0x90
the_thread->budget_callout = budget_callout;
109d56: 9b01 ldr r3, [sp, #4]
109d58: f8c7 3094 str.w r3, [r7, #148] ; 0x94
109d5c: 9b02 ldr r3, [sp, #8]
109d5e: f8c8 3038 str.w r3, [r8, #56] ; 0x38
109d62: 9b03 ldr r3, [sp, #12]
109d64: f8c8 303c str.w r3, [r8, #60] ; 0x3c
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
109d68: f104 0308 add.w r3, r4, #8
109d6c: cb0f ldmia r3, {r0, r1, r2, r3}
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
109d6e: f108 0450 add.w r4, r8, #80 ; 0x50
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
109d72: e889 000f stmia.w r9, {r0, r1, r2, r3}
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
109d76: e89c 000f ldmia.w ip, {r0, r1, r2, r3}
109d7a: e884 000f stmia.w r4, {r0, r1, r2, r3}
api->Sporadic.sched_ss_max_repl = param->sched_ss_max_repl;
109d7e: f8c8 e060 str.w lr, [r8, #96] ; 0x60
if ( policy == SCHED_SPORADIC ) {
109d82: d02b beq.n 109ddc <pthread_setschedparam+0x160>
the_thread->cpu_time_budget =
109d84: f645 5310 movw r3, #23824 ; 0x5d10
109d88: f642 24c0 movw r4, #10944 ; 0x2ac0
109d8c: f2c0 0311 movt r3, #17
109d90: f2c0 0420 movt r4, #32
109d94: 681b ldr r3, [r3, #0]
109d96: f8c7 308c str.w r3, [r7, #140] ; 0x8c
disable_level = cpu_self->thread_dispatch_disable_level;
109d9a: 6923 ldr r3, [r4, #16]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
109d9c: 3301 adds r3, #1
109d9e: 6123 str r3, [r4, #16]
109da0: 9b07 ldr r3, [sp, #28]
109da2: f383 8900 msr CPSR_fc, r3
_Thread_Priority_update( &queue_context );
109da6: a807 add r0, sp, #28
109da8: f001 f98e bl 10b0c8 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
109dac: f642 20c0 movw r0, #10944 ; 0x2ac0
109db0: f2c0 0020 movt r0, #32
109db4: f001 fa5c bl 10b270 <_Thread_Dispatch_enable>
}
109db8: 4628 mov r0, r5
109dba: b011 add sp, #68 ; 0x44
109dbc: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
109dc0: f642 24c0 movw r4, #10944 ; 0x2ac0
return EINVAL;
109dc4: 2516 movs r5, #22
109dc6: f2c0 0420 movt r4, #32
109dca: e7e6 b.n 109d9a <pthread_setschedparam+0x11e>
return ESRCH;
109dcc: 2503 movs r5, #3
109dce: e765 b.n 109c9c <pthread_setschedparam+0x20>
_Thread_Priority_changed(
109dd0: ab07 add r3, sp, #28
109dd2: 2200 movs r2, #0
109dd4: 4638 mov r0, r7
109dd6: f001 f953 bl 10b080 <_Thread_Priority_changed>
109dda: e7b2 b.n 109d42 <pthread_setschedparam+0xc6>
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
109ddc: 4620 mov r0, r4
expire = ticks + cpu->Watchdog.ticks;
109dde: f642 24c0 movw r4, #10944 ; 0x2ac0
109de2: f002 fb31 bl 10c448 <_Timespec_To_ticks>
109de6: f2c0 0420 movt r4, #32
the_thread->cpu_time_budget =
109dea: f8c7 008c str.w r0, [r7, #140] ; 0x8c
_Watchdog_Per_CPU_insert_ticks(
109dee: 4648 mov r0, r9
109df0: f002 fb2a bl 10c448 <_Timespec_To_ticks>
109df4: 6aa2 ldr r2, [r4, #40] ; 0x28
_Watchdog_Insert(header, the_watchdog, expire);
109df6: 4659 mov r1, fp
expire = ticks + cpu->Watchdog.ticks;
109df8: 6ae3 ldr r3, [r4, #44] ; 0x2c
109dfa: 1882 adds r2, r0, r2
_Watchdog_Insert(header, the_watchdog, expire);
109dfc: f104 0030 add.w r0, r4, #48 ; 0x30
109e00: f143 0300 adc.w r3, r3, #0
109e04: f002 fc70 bl 10c6e8 <_Watchdog_Insert>
}
109e08: e7c7 b.n 109d9a <pthread_setschedparam+0x11e>
109e0a: bf00 nop
109e0c: 00202af0 .word 0x00202af0
001080c4 <pthread_setspecific>:
1080c4: f641 7300 movw r3, #7936 ; 0x1f00
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
1080c8: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
1080cc: f2c0 0320 movt r3, #32
1080d0: 4604 mov r4, r0
1080d2: 699e ldr r6, [r3, #24]
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
1080d4: b1e1 cbz r1, 108110 <pthread_setspecific+0x4c>
__asm__ volatile (
1080d6: 460d mov r5, r1
1080d8: f3ef 8100 mrs r1, CPSR
1080dc: f041 0380 orr.w r3, r1, #128 ; 0x80
1080e0: f383 8900 msr CPSR_fc, r3
while ( *link != NULL ) {
1080e4: f8d6 3164 ldr.w r3, [r6, #356] ; 0x164
1080e8: b92b cbnz r3, 1080f6 <pthread_setspecific+0x32>
1080ea: e04c b.n 108186 <pthread_setspecific+0xc2>
return &RB_LEFT( the_node, Node );
1080ec: bf38 it cc
1080ee: 461a movcc r2, r3
while ( *link != NULL ) {
1080f0: 6813 ldr r3, [r2, #0]
1080f2: 2b00 cmp r3, #0
1080f4: d047 beq.n 108186 <pthread_setspecific+0xc2>
if ( ( *equal )( key, parent ) ) {
1080f6: 691f ldr r7, [r3, #16]
1080f8: f1a3 0008 sub.w r0, r3, #8
return &RB_RIGHT( the_node, Node );
1080fc: 1d1a adds r2, r3, #4
if ( ( *equal )( key, parent ) ) {
1080fe: 42bc cmp r4, r7
108100: d1f4 bne.n 1080ec <pthread_setspecific+0x28>
key_value_pair->value = RTEMS_DECONST( void *, value );
108102: 6205 str r5, [r0, #32]
__asm__ volatile (
108104: f381 8900 msr CPSR_fc, r1
_POSIX_Keys_Key_value_acquire( executing, &lock_context );
key_value_pair = _POSIX_Keys_Key_value_find( key, executing );
if ( key_value_pair != NULL ) {
eno = _POSIX_Keys_Set_value( key_value_pair, value );
108108: 2400 movs r4, #0
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
10810a: 4620 mov r0, r4
10810c: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
_RTEMS_Lock_allocator();
108110: f000 fb5c bl 1087cc <_RTEMS_Lock_allocator>
_Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information );
108114: f240 0104 movw r1, #4
108118: 4620 mov r0, r4
10811a: f2c0 0120 movt r1, #32
10811e: f002 f859 bl 10a1d4 <_Objects_Get_no_protection>
if ( the_key != NULL ) {
108122: b370 cbz r0, 108182 <pthread_setspecific+0xbe>
__asm__ volatile (
108124: f3ef 8700 mrs r7, CPSR
108128: f047 0380 orr.w r3, r7, #128 ; 0x80
10812c: f383 8900 msr CPSR_fc, r3
while ( *link != NULL ) {
108130: f8d6 1164 ldr.w r1, [r6, #356] ; 0x164
108134: b941 cbnz r1, 108148 <pthread_setspecific+0x84>
__asm__ volatile (
108136: f387 8900 msr CPSR_fc, r7
eno = 0;
10813a: 2400 movs r4, #0
}
10813c: e01c b.n 108178 <pthread_setspecific+0xb4>
return &RB_LEFT( the_node, Node );
10813e: bf38 it cc <== NOT EXECUTED
108140: 460b movcc r3, r1 <== NOT EXECUTED
while ( *link != NULL ) {
108142: 6819 ldr r1, [r3, #0] <== NOT EXECUTED
108144: 2900 cmp r1, #0 <== NOT EXECUTED
108146: d0f6 beq.n 108136 <pthread_setspecific+0x72> <== NOT EXECUTED
return *the_left == the_right->key;
108148: 690a ldr r2, [r1, #16]
the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right );
10814a: f1a1 0508 sub.w r5, r1, #8
return &RB_RIGHT( the_node, Node );
10814e: 1d0b adds r3, r1, #4
if ( ( *equal )( key, parent ) ) {
108150: 4294 cmp r4, r2
108152: d1f4 bne.n 10813e <pthread_setspecific+0x7a> <== ALWAYS TAKEN
_RBTree_Extract(
108154: f506 70b2 add.w r0, r6, #356 ; 0x164
108158: f002 f88e bl 10a278 <_RBTree_Extract>
10815c: f387 8900 msr CPSR_fc, r7
previous = the_node->previous;
108160: e9d5 2300 ldrd r2, r3, [r5]
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
108164: f641 6068 movw r0, #7784 ; 0x1e68
108168: 4629 mov r1, r5
10816a: f2c0 0020 movt r0, #32
eno = 0;
10816e: 2400 movs r4, #0
next->previous = previous;
108170: 6053 str r3, [r2, #4]
previous->next = next;
108172: 601a str r2, [r3, #0]
108174: f000 fbae bl 1088d4 <_Freechain_Put>
_RTEMS_Unlock_allocator();
108178: f000 fb2e bl 1087d8 <_RTEMS_Unlock_allocator>
}
10817c: 4620 mov r0, r4
10817e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
eno = EINVAL;
108182: 2416 movs r4, #22
108184: e7f8 b.n 108178 <pthread_setspecific+0xb4>
108186: f381 8900 msr CPSR_fc, r1
_RTEMS_Lock_allocator();
10818a: f000 fb1f bl 1087cc <_RTEMS_Lock_allocator>
_Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information );
10818e: f240 0104 movw r1, #4
108192: 4620 mov r0, r4
108194: f2c0 0120 movt r1, #32
108198: f002 f81c bl 10a1d4 <_Objects_Get_no_protection>
if ( the_key != NULL ) {
10819c: 4680 mov r8, r0
10819e: 2800 cmp r0, #0
1081a0: d0ef beq.n 108182 <pthread_setspecific+0xbe>
key_value_pair = _POSIX_Keys_Key_value_allocate();
1081a2: f7ff ff13 bl 107fcc <_POSIX_Keys_Key_value_allocate>
if ( key_value_pair != NULL ) {
1081a6: 4607 mov r7, r0
1081a8: b370 cbz r0, 108208 <pthread_setspecific+0x144>
old_last = tail->previous;
1081aa: f8d8 301c ldr.w r3, [r8, #28]
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
1081ae: 4601 mov r1, r0
return &the_chain->Tail.Node;
1081b0: f108 0218 add.w r2, r8, #24
key_value_pair->value = RTEMS_DECONST( void *, value );
1081b4: 6205 str r5, [r0, #32]
key_value_pair->thread = executing;
1081b6: e9c0 4606 strd r4, r6, [r0, #24]
the_node->next = tail;
1081ba: f841 2b08 str.w r2, [r1], #8
tail->previous = the_node;
1081be: f8c8 001c str.w r0, [r8, #28]
old_last->next = the_node;
1081c2: 6018 str r0, [r3, #0]
the_node->previous = old_last;
1081c4: 6043 str r3, [r0, #4]
return &RB_ROOT( the_rbtree );
1081c6: f506 70b2 add.w r0, r6, #356 ; 0x164
__asm__ volatile (
1081ca: f3ef 8800 mrs r8, CPSR
1081ce: f048 0380 orr.w r3, r8, #128 ; 0x80
1081d2: f383 8900 msr CPSR_fc, r3
while ( *link != NULL ) {
1081d6: f8d6 3164 ldr.w r3, [r6, #356] ; 0x164
1081da: b90b cbnz r3, 1081e0 <pthread_setspecific+0x11c>
1081dc: e016 b.n 10820c <pthread_setspecific+0x148>
1081de: 4613 mov r3, r2
if ( ( *less )( key, parent ) ) {
1081e0: 691a ldr r2, [r3, #16]
return &RB_RIGHT( the_node, Node );
1081e2: 1d1d adds r5, r3, #4
if ( ( *less )( key, parent ) ) {
1081e4: 4294 cmp r4, r2
return &RB_LEFT( the_node, Node );
1081e6: bf38 it cc
1081e8: 461d movcc r5, r3
while ( *link != NULL ) {
1081ea: 682a ldr r2, [r5, #0]
1081ec: 2a00 cmp r2, #0
1081ee: d1f6 bne.n 1081de <pthread_setspecific+0x11a>
RB_SET( child, parent, Node );
1081f0: 613b str r3, [r7, #16]
1081f2: 2400 movs r4, #0
1081f4: 2301 movs r3, #1
1081f6: e9c7 4402 strd r4, r4, [r7, #8]
1081fa: 617b str r3, [r7, #20]
*link = child;
1081fc: 6029 str r1, [r5, #0]
_RBTree_Insert_color( the_rbtree, the_node );
1081fe: f002 f97d bl 10a4fc <_RBTree_Insert_color>
__asm__ volatile (
108202: f388 8900 msr CPSR_fc, r8
eno = 0;
108206: e7b7 b.n 108178 <pthread_setspecific+0xb4>
eno = ENOMEM;
108208: 240c movs r4, #12 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
10820a: e7b5 b.n 108178 <pthread_setspecific+0xb4> <== NOT EXECUTED
link = _RBTree_Root_reference( the_rbtree );
10820c: 4605 mov r5, r0
10820e: e7ef b.n 1081f0 <pthread_setspecific+0x12c>
001078b0 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
1078b0: b508 push {r3, lr}
if ( _ISR_Is_in_progress() ) {
1078b2: f000 f931 bl 107b18 <_ISR_Is_in_progress>
1078b6: b100 cbz r0, 1078ba <pthread_testcancel+0xa>
return;
}
_Thread_Change_life( 0, 0, THREAD_LIFE_CHANGE_DEFERRED );
}
1078b8: bd08 pop {r3, pc} <== NOT EXECUTED
1078ba: e8bd 4008 ldmia.w sp!, {r3, lr}
1078be: 4601 mov r1, r0
_Thread_Change_life( 0, 0, THREAD_LIFE_CHANGE_DEFERRED );
1078c0: 2208 movs r2, #8
1078c2: f002 ba9b b.w 109dfc <_Thread_Change_life>
1078c6: bf00 nop
00109c04 <rtems_aio_enqueue>:
{
109c04: b5f0 push {r4, r5, r6, r7, lr}
result = pthread_mutex_lock (&aio_request_queue.mutex);
109c06: f244 5618 movw r6, #17688 ; 0x4518
109c0a: f2c0 0620 movt r6, #32
{
109c0e: b08f sub sp, #60 ; 0x3c
109c10: 4605 mov r5, r0
result = pthread_mutex_lock (&aio_request_queue.mutex);
109c12: 4630 mov r0, r6
109c14: f001 f83a bl 10ac8c <pthread_mutex_lock>
if (result != 0) {
109c18: 4607 mov r7, r0
109c1a: 2800 cmp r0, #0
109c1c: d142 bne.n 109ca4 <rtems_aio_enqueue+0xa0> <== ALWAYS TAKEN
pthread_getschedparam (pthread_self(), &policy, ¶m);
109c1e: f001 fca1 bl 10b564 <pthread_self>
109c22: aa02 add r2, sp, #8
109c24: a901 add r1, sp, #4
109c26: f001 fc4f bl 10b4c8 <pthread_getschedparam>
req->caller_thread = pthread_self ();
109c2a: f001 fc9b bl 10b564 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
109c2e: 696b ldr r3, [r5, #20]
req->caller_thread = pthread_self ();
109c30: 6128 str r0, [r5, #16]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
109c32: 9a02 ldr r2, [sp, #8]
109c34: 6998 ldr r0, [r3, #24]
if ((aio_request_queue.idle_threads == 0) &&
109c36: f8d6 10e0 ldr.w r1, [r6, #224] ; 0xe0
req->policy = policy;
109c3a: 9c01 ldr r4, [sp, #4]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
109c3c: 1a12 subs r2, r2, r0
109c3e: 60ea str r2, [r5, #12]
req->aiocbp->error_code = EINPROGRESS;
109c40: 2277 movs r2, #119 ; 0x77
req->policy = policy;
109c42: 60ac str r4, [r5, #8]
req->aiocbp->return_value = 0;
109c44: 639f str r7, [r3, #56] ; 0x38
req->aiocbp->error_code = EINPROGRESS;
109c46: 635a str r2, [r3, #52] ; 0x34
if ((aio_request_queue.idle_threads == 0) &&
109c48: bb51 cbnz r1, 109ca0 <rtems_aio_enqueue+0x9c>
109c4a: f8d6 20dc ldr.w r2, [r6, #220] ; 0xdc
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
109c4e: 6819 ldr r1, [r3, #0]
if ((aio_request_queue.idle_threads == 0) &&
109c50: 2a04 cmp r2, #4
109c52: dd47 ble.n 109ce4 <rtems_aio_enqueue+0xe0>
return _Chain_Immutable_head( the_chain )->next;
109c54: f8d6 40c0 ldr.w r4, [r6, #192] ; 0xc0
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
109c58: 6963 ldr r3, [r4, #20]
109c5a: 4299 cmp r1, r3
109c5c: dd28 ble.n 109cb0 <rtems_aio_enqueue+0xac>
109c5e: 4a42 ldr r2, [pc, #264] ; (109d68 <rtems_aio_enqueue+0x164>)
109c60: e003 b.n 109c6a <rtems_aio_enqueue+0x66>
return the_node->next;
109c62: 6824 ldr r4, [r4, #0]
109c64: 6963 ldr r3, [r4, #20]
109c66: 428b cmp r3, r1
109c68: da22 bge.n 109cb0 <rtems_aio_enqueue+0xac>
109c6a: 4294 cmp r4, r2
109c6c: d1f9 bne.n 109c62 <rtems_aio_enqueue+0x5e> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
109c6e: 483f ldr r0, [pc, #252] ; (109d6c <rtems_aio_enqueue+0x168>)
109c70: 2201 movs r2, #1
109c72: f7ff ff2b bl 109acc <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
109c76: 6983 ldr r3, [r0, #24]
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
109c78: 4604 mov r4, r0
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
109c7a: 4629 mov r1, r5
109c7c: 3008 adds r0, #8
if (r_chain->new_fd == 1) {
109c7e: 2b01 cmp r3, #1
109c80: d05d beq.n 109d3e <rtems_aio_enqueue+0x13a>
rtems_aio_insert_prio (&r_chain->perfd, req);
109c82: f7ff fdd1 bl 109828 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
109c86: f8d6 30e0 ldr.w r3, [r6, #224] ; 0xe0
109c8a: 2b00 cmp r3, #0
109c8c: dc26 bgt.n 109cdc <rtems_aio_enqueue+0xd8> <== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
109c8e: f244 5018 movw r0, #17688 ; 0x4518
109c92: f2c0 0020 movt r0, #32
109c96: f001 f8f1 bl 10ae7c <pthread_mutex_unlock>
}
109c9a: 4638 mov r0, r7
109c9c: b00f add sp, #60 ; 0x3c
109c9e: bdf0 pop {r4, r5, r6, r7, pc}
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
109ca0: 6819 ldr r1, [r3, #0] <== NOT EXECUTED
109ca2: e7d7 b.n 109c54 <rtems_aio_enqueue+0x50> <== NOT EXECUTED
free (req);
109ca4: 4628 mov r0, r5 <== NOT EXECUTED
109ca6: f7fb f819 bl 104cdc <free> <== NOT EXECUTED
}
109caa: 4638 mov r0, r7 <== NOT EXECUTED
109cac: b00f add sp, #60 ; 0x3c <== NOT EXECUTED
109cae: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if (r_chain->fildes == fildes)
109cb0: 4299 cmp r1, r3
109cb2: d1dc bne.n 109c6e <rtems_aio_enqueue+0x6a>
pthread_mutex_lock (&r_chain->mutex);
109cb4: f104 0620 add.w r6, r4, #32
r_chain->new_fd = 0;
109cb8: 2300 movs r3, #0
109cba: 61a3 str r3, [r4, #24]
pthread_mutex_lock (&r_chain->mutex);
109cbc: 4630 mov r0, r6
109cbe: f000 ffe5 bl 10ac8c <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
109cc2: 4629 mov r1, r5
109cc4: f104 0008 add.w r0, r4, #8
109cc8: f7ff fdae bl 109828 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
109ccc: f104 0060 add.w r0, r4, #96 ; 0x60
109cd0: f000 fe54 bl 10a97c <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
109cd4: 4630 mov r0, r6
109cd6: f001 f8d1 bl 10ae7c <pthread_mutex_unlock>
109cda: e7d8 b.n 109c8e <rtems_aio_enqueue+0x8a>
pthread_cond_signal (&aio_request_queue.new_req);
109cdc: 4824 ldr r0, [pc, #144] ; (109d70 <rtems_aio_enqueue+0x16c>) <== NOT EXECUTED
109cde: f000 fe4d bl 10a97c <pthread_cond_signal> <== NOT EXECUTED
109ce2: e7d4 b.n 109c8e <rtems_aio_enqueue+0x8a> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
109ce4: f106 00c0 add.w r0, r6, #192 ; 0xc0
109ce8: 2201 movs r2, #1
109cea: f7ff feef bl 109acc <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
109cee: 6983 ldr r3, [r0, #24]
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
109cf0: 4604 mov r4, r0
if (r_chain->new_fd == 1) {
109cf2: 2b01 cmp r3, #1
pthread_mutex_lock (&r_chain->mutex);
109cf4: bf18 it ne
109cf6: f100 0620 addne.w r6, r0, #32
if (r_chain->new_fd == 1) {
109cfa: d1df bne.n 109cbc <rtems_aio_enqueue+0xb8>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
109cfc: 4629 mov r1, r5
109cfe: 3008 adds r0, #8
109d00: f001 fd6a bl 10b7d8 <rtems_chain_prepend>
pthread_mutex_init (&r_chain->mutex, NULL);
109d04: 4639 mov r1, r7
109d06: f104 0020 add.w r0, r4, #32
r_chain->new_fd = 0;
109d0a: 61a7 str r7, [r4, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
109d0c: f000 ff60 bl 10abd0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
109d10: 4639 mov r1, r7
109d12: f104 0060 add.w r0, r4, #96 ; 0x60
109d16: f000 fe05 bl 10a924 <pthread_cond_init>
result = pthread_create (&thid, &aio_request_queue.attr,
109d1a: f649 0261 movw r2, #39009 ; 0x9861
109d1e: 4623 mov r3, r4
109d20: f106 0160 add.w r1, r6, #96 ; 0x60
109d24: f2c0 0210 movt r2, #16
109d28: 4668 mov r0, sp
109d2a: f001 fa51 bl 10b1d0 <pthread_create>
if (result != 0) {
109d2e: 4603 mov r3, r0
109d30: b9a0 cbnz r0, 109d5c <rtems_aio_enqueue+0x158>
++aio_request_queue.active_threads;
109d32: f8d6 30dc ldr.w r3, [r6, #220] ; 0xdc
109d36: 3301 adds r3, #1
109d38: f8c6 30dc str.w r3, [r6, #220] ; 0xdc
109d3c: e7a7 b.n 109c8e <rtems_aio_enqueue+0x8a>
r_chain->new_fd = 0;
109d3e: 2500 movs r5, #0
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
109d40: f001 fd4a bl 10b7d8 <rtems_chain_prepend>
pthread_mutex_init (&r_chain->mutex, NULL);
109d44: 4629 mov r1, r5
109d46: f104 0020 add.w r0, r4, #32
r_chain->new_fd = 0;
109d4a: 61a5 str r5, [r4, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
109d4c: f000 ff40 bl 10abd0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
109d50: 4629 mov r1, r5
109d52: f104 0060 add.w r0, r4, #96 ; 0x60
109d56: f000 fde5 bl 10a924 <pthread_cond_init>
109d5a: e794 b.n 109c86 <rtems_aio_enqueue+0x82>
pthread_mutex_unlock (&aio_request_queue.mutex);
109d5c: 4630 mov r0, r6 <== NOT EXECUTED
return result;
109d5e: 461f mov r7, r3 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
109d60: f001 f88c bl 10ae7c <pthread_mutex_unlock> <== NOT EXECUTED
return result;
109d64: e799 b.n 109c9a <rtems_aio_enqueue+0x96> <== NOT EXECUTED
109d66: bf00 nop <== NOT EXECUTED
109d68: 002045dc .word 0x002045dc <== NOT EXECUTED
109d6c: 002045e4 .word 0x002045e4 <== NOT EXECUTED
109d70: 00204558 .word 0x00204558 <== NOT EXECUTED
00109a34 <rtems_aio_init>:
{
109a34: b538 push {r3, r4, r5, lr}
result = pthread_attr_init (&aio_request_queue.attr);
109a36: 4822 ldr r0, [pc, #136] ; (109ac0 <rtems_aio_init+0x8c>)
109a38: f001 faf2 bl 10b020 <pthread_attr_init>
if (result != 0)
109a3c: 4604 mov r4, r0
109a3e: b108 cbz r0, 109a44 <rtems_aio_init+0x10>
}
109a40: 4620 mov r0, r4 <== NOT EXECUTED
109a42: bd38 pop {r3, r4, r5, pc} <== NOT EXECUTED
pthread_attr_setdetachstate (&aio_request_queue.attr,
109a44: 481e ldr r0, [pc, #120] ; (109ac0 <rtems_aio_init+0x8c>)
109a46: 4621 mov r1, r4
109a48: f001 fafc bl 10b044 <pthread_attr_setdetachstate>
if (result != 0)
109a4c: bb20 cbnz r0, 109a98 <rtems_aio_init+0x64>
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
109a4e: f244 5518 movw r5, #17688 ; 0x4518
109a52: 2100 movs r1, #0
109a54: f2c0 0520 movt r5, #32
109a58: 4628 mov r0, r5
109a5a: f001 f8b9 bl 10abd0 <pthread_mutex_init>
if (result != 0)
109a5e: bb48 cbnz r0, 109ab4 <rtems_aio_init+0x80>
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
109a60: 4818 ldr r0, [pc, #96] ; (109ac4 <rtems_aio_init+0x90>)
109a62: 2100 movs r1, #0
109a64: f000 ff5e bl 10a924 <pthread_cond_init>
if (result != 0) {
109a68: 4604 mov r4, r0
109a6a: b9c8 cbnz r0, 109aa0 <rtems_aio_init+0x6c>
head->next = tail;
109a6c: 4b16 ldr r3, [pc, #88] ; (109ac8 <rtems_aio_init+0x94>)
head->previous = NULL;
109a6e: 2200 movs r2, #0
109a70: f8c5 20c4 str.w r2, [r5, #196] ; 0xc4
}
109a74: 4620 mov r0, r4
109a76: f8c5 20d0 str.w r2, [r5, #208] ; 0xd0
tail->previous = head;
109a7a: 1f19 subs r1, r3, #4
aio_request_queue.idle_threads = 0;
109a7c: e9c5 2237 strd r2, r2, [r5, #220] ; 0xdc
head->next = tail;
109a80: f103 020c add.w r2, r3, #12
109a84: f8c5 30c0 str.w r3, [r5, #192] ; 0xc0
109a88: e9c5 1232 strd r1, r2, [r5, #200] ; 0xc8
tail->previous = head;
109a8c: 3308 adds r3, #8
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
109a8e: f24b 020b movw r2, #45067 ; 0xb00b
109a92: e9c5 3235 strd r3, r2, [r5, #212] ; 0xd4
}
109a96: bd38 pop {r3, r4, r5, pc}
pthread_attr_destroy (&aio_request_queue.attr);
109a98: 4809 ldr r0, [pc, #36] ; (109ac0 <rtems_aio_init+0x8c>) <== NOT EXECUTED
109a9a: f001 fab7 bl 10b00c <pthread_attr_destroy> <== NOT EXECUTED
109a9e: e7d6 b.n 109a4e <rtems_aio_init+0x1a> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
109aa0: f244 5018 movw r0, #17688 ; 0x4518 <== NOT EXECUTED
109aa4: f2c0 0020 movt r0, #32 <== NOT EXECUTED
109aa8: f001 f86c bl 10ab84 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
109aac: 4804 ldr r0, [pc, #16] ; (109ac0 <rtems_aio_init+0x8c>) <== NOT EXECUTED
109aae: f001 faad bl 10b00c <pthread_attr_destroy> <== NOT EXECUTED
109ab2: e7db b.n 109a6c <rtems_aio_init+0x38> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
109ab4: f105 0060 add.w r0, r5, #96 ; 0x60 <== NOT EXECUTED
109ab8: f001 faa8 bl 10b00c <pthread_attr_destroy> <== NOT EXECUTED
109abc: e7d0 b.n 109a60 <rtems_aio_init+0x2c> <== NOT EXECUTED
109abe: bf00 nop <== NOT EXECUTED
109ac0: 00204578 .word 0x00204578 <== NOT EXECUTED
109ac4: 00204558 .word 0x00204558 <== NOT EXECUTED
109ac8: 002045dc .word 0x002045dc <== NOT EXECUTED
00109b90 <rtems_aio_remove_fd>:
{
109b90: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
109b94: f100 060c add.w r6, r0, #12
return _Chain_Immutable_head( the_chain )->next;
109b98: 6884 ldr r4, [r0, #8]
while (!rtems_chain_is_tail (chain, node))
109b9a: 42b4 cmp r4, r6
109b9c: d010 beq.n 109bc0 <rtems_aio_remove_fd+0x30> <== ALWAYS TAKEN
req->aiocbp->error_code = ECANCELED;
109b9e: f04f 088c mov.w r8, #140 ; 0x8c
req->aiocbp->return_value = -1;
109ba2: f04f 37ff mov.w r7, #4294967295 ; 0xffffffff
return the_node->next;
109ba6: 4625 mov r5, r4
109ba8: 6824 ldr r4, [r4, #0]
rtems_chain_extract (&req->next_prio);
109baa: 4628 mov r0, r5
109bac: f001 fdf8 bl 10b7a0 <rtems_chain_extract>
req->aiocbp->error_code = ECANCELED;
109bb0: 696b ldr r3, [r5, #20]
free (req);
109bb2: 4628 mov r0, r5
req->aiocbp->return_value = -1;
109bb4: e9c3 870d strd r8, r7, [r3, #52] ; 0x34
free (req);
109bb8: f7fb f890 bl 104cdc <free>
while (!rtems_chain_is_tail (chain, node))
109bbc: 42b4 cmp r4, r6
109bbe: d1f2 bne.n 109ba6 <rtems_aio_remove_fd+0x16>
}
109bc0: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
00109bc4 <rtems_aio_remove_req>:
{
109bc4: b510 push {r4, lr}
return _Chain_Immutable_head( the_chain )->next;
109bc6: f850 4b04 ldr.w r4, [r0], #4
if (rtems_chain_is_empty (chain))
109bca: 42a0 cmp r0, r4
109bcc: d017 beq.n 109bfe <rtems_aio_remove_req+0x3a>
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
109bce: 6963 ldr r3, [r4, #20]
109bd0: 428b cmp r3, r1
109bd2: d004 beq.n 109bde <rtems_aio_remove_req+0x1a> <== NEVER TAKEN
return the_node->next;
109bd4: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
109bd6: 4284 cmp r4, r0 <== NOT EXECUTED
109bd8: d1f9 bne.n 109bce <rtems_aio_remove_req+0xa> <== NOT EXECUTED
return AIO_NOTCANCELED;
109bda: 2001 movs r0, #1 <== NOT EXECUTED
}
109bdc: bd10 pop {r4, pc} <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
109bde: 42a0 cmp r0, r4
109be0: d0fb beq.n 109bda <rtems_aio_remove_req+0x16> <== ALWAYS TAKEN
rtems_chain_extract (node);
109be2: 4620 mov r0, r4
109be4: f001 fddc bl 10b7a0 <rtems_chain_extract>
current->aiocbp->error_code = ECANCELED;
109be8: 6963 ldr r3, [r4, #20]
109bea: 218c movs r1, #140 ; 0x8c
current->aiocbp->return_value = -1;
109bec: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
free (current);
109bf0: 4620 mov r0, r4
current->aiocbp->return_value = -1;
109bf2: e9c3 120d strd r1, r2, [r3, #52] ; 0x34
free (current);
109bf6: f7fb f871 bl 104cdc <free>
return AIO_CANCELED;
109bfa: 2000 movs r0, #0
}
109bfc: bd10 pop {r4, pc}
return AIO_ALLDONE;
109bfe: 2002 movs r0, #2
}
109c00: bd10 pop {r4, pc}
109c02: bf00 nop
00106cf0 <sched_get_priority_max>:
int policy
)
{
const Scheduler_Control *scheduler;
switch ( policy ) {
106cf0: 2802 cmp r0, #2
{
106cf2: b508 push {r3, lr}
switch ( policy ) {
106cf4: dd08 ble.n 106d08 <sched_get_priority_max+0x18>
106cf6: 2804 cmp r0, #4
106cf8: d108 bne.n 106d0c <sched_get_priority_max+0x1c> <== ALWAYS 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;
106cfa: f241 5350 movw r3, #5456 ; 0x1550
106cfe: f2c0 0311 movt r3, #17
106d02: 6c18 ldr r0, [r3, #64] ; 0x40
106d04: 3801 subs r0, #1
rtems_set_errno_and_return_minus_one( EINVAL );
}
scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() );
return _POSIX_Priority_Get_maximum( scheduler );
}
106d06: bd08 pop {r3, pc}
switch ( policy ) {
106d08: 2800 cmp r0, #0
106d0a: daf6 bge.n 106cfa <sched_get_priority_max+0xa>
rtems_set_errno_and_return_minus_one( EINVAL );
106d0c: f006 f8d8 bl 10cec0 <__errno>
106d10: 2216 movs r2, #22
106d12: 4603 mov r3, r0
106d14: 601a str r2, [r3, #0]
106d16: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
106d1a: bd08 pop {r3, pc}
00106d1c <sched_get_priority_min>:
*/
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
106d1c: 2802 cmp r0, #2
106d1e: dc0a bgt.n 106d36 <sched_get_priority_min+0x1a> <== ALWAYS TAKEN
106d20: 2800 cmp r0, #0
106d22: da0a bge.n 106d3a <sched_get_priority_min+0x1e>
{
106d24: b508 push {r3, lr}
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
106d26: f006 f8cb bl 10cec0 <__errno>
106d2a: 2216 movs r2, #22
106d2c: 4603 mov r3, r0
106d2e: 601a str r2, [r3, #0]
106d30: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
106d34: bd08 pop {r3, pc}
switch ( policy ) {
106d36: 2804 cmp r0, #4 <== NOT EXECUTED
106d38: d1f4 bne.n 106d24 <sched_get_priority_min+0x8> <== NOT EXECUTED
106d3a: 2001 movs r0, #1
}
106d3c: 4770 bx lr
106d3e: bf00 nop
0010a2e4 <sem_close>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_close( sem_t *sem )
{
10a2e4: b538 push {r3, r4, r5, lr}
POSIX_Semaphore_Control *the_semaphore;
uint32_t open_count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
10a2e6: b348 cbz r0, 10a33c <sem_close+0x58>
10a2e8: 6802 ldr r2, [r0, #0]
10a2ea: f647 73e7 movw r3, #32743 ; 0x7fe7
10a2ee: f6c5 5336 movt r3, #23862 ; 0x5d36
10a2f2: 4604 mov r4, r0
10a2f4: 4043 eors r3, r0
10a2f6: 4293 cmp r3, r2
10a2f8: d120 bne.n 10a33c <sem_close+0x58>
if ( !_POSIX_Semaphore_Is_named( sem ) ) {
10a2fa: 6943 ldr r3, [r0, #20]
10a2fc: b1f3 cbz r3, 10a33c <sem_close+0x58>
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get(
sem_t *sem
)
{
return RTEMS_CONTAINER_OF( sem, POSIX_Semaphore_Control, Semaphore );
10a2fe: f1a0 0510 sub.w r5, r0, #16
_RTEMS_Lock_allocator();
10a302: f000 fa73 bl 10a7ec <_RTEMS_Lock_allocator>
the_semaphore = _POSIX_Semaphore_Get( sem );
_Objects_Allocator_lock();
open_count = the_semaphore->open_count;
10a306: 6b2b ldr r3, [r5, #48] ; 0x30
if ( open_count == 0 ) {
10a308: b1b3 cbz r3, 10a338 <sem_close+0x54>
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( open_count == 1 && _POSIX_Semaphore_Is_busy( sem ) ) {
10a30a: 2b01 cmp r3, #1
10a30c: d101 bne.n 10a312 <sem_close+0x2e>
10a30e: 68e2 ldr r2, [r4, #12]
10a310: b942 cbnz r2, 10a324 <sem_close+0x40>
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EBUSY );
}
the_semaphore->open_count = open_count - 1;
10a312: 3b01 subs r3, #1
_POSIX_Semaphore_Delete( the_semaphore );
10a314: 4628 mov r0, r5
the_semaphore->open_count = open_count - 1;
10a316: 632b str r3, [r5, #48] ; 0x30
_POSIX_Semaphore_Delete( the_semaphore );
10a318: f003 fc06 bl 10db28 <_POSIX_Semaphore_Delete>
_RTEMS_Unlock_allocator();
10a31c: f000 fa6c bl 10a7f8 <_RTEMS_Unlock_allocator>
_Objects_Allocator_unlock();
return 0;
10a320: 2000 movs r0, #0
}
10a322: bd38 pop {r3, r4, r5, pc}
10a324: f000 fa68 bl 10a7f8 <_RTEMS_Unlock_allocator>
rtems_set_errno_and_return_minus_one( EBUSY );
10a328: f006 fbce bl 110ac8 <__errno>
10a32c: 2210 movs r2, #16
10a32e: 4603 mov r3, r0
10a330: 601a str r2, [r3, #0]
10a332: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10a336: bd38 pop {r3, r4, r5, pc}
10a338: f000 fa5e bl 10a7f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
10a33c: f006 fbc4 bl 110ac8 <__errno>
10a340: 2216 movs r2, #22
10a342: 4603 mov r3, r0
10a344: 601a str r2, [r3, #0]
10a346: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10a34a: bd38 pop {r3, r4, r5, pc}
00107a0c <sem_open>:
{
107a0c: b40e push {r1, r2, r3}
107a0e: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
107a12: b085 sub sp, #20
107a14: 4605 mov r5, r0
107a16: 9e0b ldr r6, [sp, #44] ; 0x2c
if ( oflag & O_CREAT ) {
107a18: 05b3 lsls r3, r6, #22
107a1a: d41e bmi.n 107a5a <sem_open+0x4e>
_RTEMS_Lock_allocator();
107a1c: f000 fc84 bl 108328 <_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(
107a20: f240 00f0 movw r0, #240 ; 0xf0
107a24: ab03 add r3, sp, #12
107a26: aa02 add r2, sp, #8
107a28: 4629 mov r1, r5
107a2a: f2c0 0020 movt r0, #32
107a2e: f001 fb45 bl 1090bc <_Objects_Get_by_name>
if ( the_semaphore == NULL ) {
107a32: 4604 mov r4, r0
107a34: 2800 cmp r0, #0
107a36: d054 beq.n 107ae2 <sem_open+0xd6>
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
107a38: f406 6620 and.w r6, r6, #2560 ; 0xa00
107a3c: f5b6 6f20 cmp.w r6, #2560 ; 0xa00
107a40: d05d beq.n 107afe <sem_open+0xf2>
the_semaphore->open_count += 1;
107a42: 6b23 ldr r3, [r4, #48] ; 0x30
return &the_semaphore->Semaphore;
107a44: 3410 adds r4, #16
the_semaphore->open_count += 1;
107a46: 3301 adds r3, #1
107a48: 6223 str r3, [r4, #32]
_RTEMS_Unlock_allocator();
107a4a: f000 fc73 bl 108334 <_RTEMS_Unlock_allocator>
}
107a4e: 4620 mov r0, r4
107a50: b005 add sp, #20
107a52: e8bd 41f0 ldmia.w sp!, {r4, r5, r6, r7, r8, lr}
107a56: b003 add sp, #12
107a58: 4770 bx lr
107a5a: f240 07f0 movw r7, #240 ; 0xf0
va_start(arg, oflag);
107a5e: ab0c add r3, sp, #48 ; 0x30
107a60: f2c0 0720 movt r7, #32
107a64: 9301 str r3, [sp, #4]
value = va_arg( arg, unsigned int );
107a66: f8dd 8034 ldr.w r8, [sp, #52] ; 0x34
_RTEMS_Lock_allocator();
107a6a: f000 fc5d bl 108328 <_RTEMS_Lock_allocator>
107a6e: ab03 add r3, sp, #12
107a70: aa02 add r2, sp, #8
107a72: 4629 mov r1, r5
107a74: 4638 mov r0, r7
107a76: f001 fb21 bl 1090bc <_Objects_Get_by_name>
if ( the_semaphore == NULL ) {
107a7a: 4604 mov r4, r0
107a7c: 2800 cmp r0, #0
107a7e: d1db bne.n 107a38 <sem_open+0x2c>
if ( !( error == OBJECTS_GET_BY_NAME_NO_OBJECT && (oflag & O_CREAT) ) ) {
107a80: 9b03 ldr r3, [sp, #12]
107a82: 2b02 cmp r3, #2
107a84: d12d bne.n 107ae2 <sem_open+0xd6>
if ( value > SEM_VALUE_MAX ) {
107a86: f1b8 0f00 cmp.w r8, #0
sem = _POSIX_Semaphore_Create_support(
107a8a: 9902 ldr r1, [sp, #8]
if ( value > SEM_VALUE_MAX ) {
107a8c: db3f blt.n 107b0e <sem_open+0x102>
name = _Workspace_String_duplicate( name_arg, name_len );
107a8e: 4628 mov r0, r5
107a90: f003 fcb6 bl 10b400 <_Workspace_String_duplicate>
if ( name == NULL ) {
107a94: 4605 mov r5, r0
107a96: 2800 cmp r0, #0
107a98: d03e beq.n 107b18 <sem_open+0x10c> <== ALWAYS TAKEN
return ( *information->allocate )( information );
107a9a: 68bb ldr r3, [r7, #8]
107a9c: 4638 mov r0, r7
107a9e: 4798 blx r3
if ( the_semaphore == NULL ) {
107aa0: 2800 cmp r0, #0
107aa2: d03e beq.n 107b22 <sem_open+0x116> <== ALWAYS TAKEN
the_semaphore->open_count = 1;
107aa4: 2201 movs r2, #1
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
107aa6: 8903 ldrh r3, [r0, #8]
107aa8: 6302 str r2, [r0, #48] ; 0x30
_POSIX_Semaphore_Initialize( &the_semaphore->Semaphore, name, value );
107aaa: f100 0410 add.w r4, r0, #16
the_semaphore->linked = true;
107aae: f880 202c strb.w r2, [r0, #44] ; 0x2c
sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC;
107ab2: f647 72e7 movw r2, #32743 ; 0x7fe7
107ab6: 6879 ldr r1, [r7, #4]
107ab8: f6c5 5236 movt r2, #23862 ; 0x5d36
107abc: 4062 eors r2, r4
107abe: f103 4380 add.w r3, r3, #1073741824 ; 0x40000000
107ac2: 6102 str r2, [r0, #16]
107ac4: 3b01 subs r3, #1
const char *_name, unsigned int _count)
{
struct _Semaphore_Control _init =
_SEMAPHORE_NAMED_INITIALIZER(_name, _count);
*_semaphore = _init;
107ac6: 2200 movs r2, #0
107ac8: f8c0 8028 str.w r8, [r0, #40] ; 0x28
107acc: 6245 str r5, [r0, #36] ; 0x24
the_object->name.name_p = name;
107ace: 60c5 str r5, [r0, #12]
107ad0: e9c0 2205 strd r2, r2, [r0, #20]
107ad4: e9c0 2207 strd r2, r2, [r0, #28]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
107ad8: f841 0023 str.w r0, [r1, r3, lsl #2]
_RTEMS_Unlock_allocator();
107adc: f000 fc2a bl 108334 <_RTEMS_Unlock_allocator>
return sem;
107ae0: e7b5 b.n 107a4e <sem_open+0x42>
107ae2: f000 fc27 bl 108334 <_RTEMS_Unlock_allocator>
rtems_set_errno_and_return_value(
107ae6: 9d03 ldr r5, [sp, #12]
107ae8: 2400 movs r4, #0
107aea: f007 f989 bl 10ee00 <__errno>
107aee: f640 233c movw r3, #2620 ; 0xa3c
107af2: f2c0 0311 movt r3, #17
107af6: f853 3025 ldr.w r3, [r3, r5, lsl #2]
107afa: 6003 str r3, [r0, #0]
107afc: e7a7 b.n 107a4e <sem_open+0x42>
107afe: f000 fc19 bl 108334 <_RTEMS_Unlock_allocator>
rtems_set_errno_and_return_value( EEXIST, SEM_FAILED );
107b02: f007 f97d bl 10ee00 <__errno>
107b06: 2311 movs r3, #17
107b08: 2400 movs r4, #0
107b0a: 6003 str r3, [r0, #0]
107b0c: e79f b.n 107a4e <sem_open+0x42>
rtems_set_errno_and_return_value( EINVAL, SEM_FAILED );
107b0e: f007 f977 bl 10ee00 <__errno>
107b12: 2316 movs r3, #22
107b14: 6003 str r3, [r0, #0]
107b16: e7e1 b.n 107adc <sem_open+0xd0>
rtems_set_errno_and_return_value( ENOMEM, SEM_FAILED );
107b18: f007 f972 bl 10ee00 <__errno> <== NOT EXECUTED
107b1c: 230c movs r3, #12 <== NOT EXECUTED
107b1e: 6003 str r3, [r0, #0] <== NOT EXECUTED
107b20: e7dc b.n 107adc <sem_open+0xd0> <== NOT EXECUTED
_Workspace_Free( name );
107b22: 4628 mov r0, r5 <== NOT EXECUTED
107b24: f003 fc64 bl 10b3f0 <_Workspace_Free> <== NOT EXECUTED
rtems_set_errno_and_return_value( ENOSPC, SEM_FAILED );
107b28: f007 f96a bl 10ee00 <__errno> <== NOT EXECUTED
107b2c: 231c movs r3, #28 <== NOT EXECUTED
107b2e: 6003 str r3, [r0, #0] <== NOT EXECUTED
107b30: e7d4 b.n 107adc <sem_open+0xd0> <== NOT EXECUTED
107b32: bf00 nop
001085ac <sem_timedwait>:
int sem_timedwait(
sem_t *__restrict _sem,
const struct timespec *__restrict abstime
)
{
1085ac: b570 push {r4, r5, r6, lr}
1085ae: b08a sub sp, #40 ; 0x28
Thread_queue_Context queue_context;
ISR_Level level;
Thread_Control *executing;
unsigned int count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
1085b0: 2800 cmp r0, #0
1085b2: d03e beq.n 108632 <sem_timedwait+0x86>
1085b4: f647 73e7 movw r3, #32743 ; 0x7fe7
1085b8: 6802 ldr r2, [r0, #0]
1085ba: f6c5 5336 movt r3, #23862 ; 0x5d36
1085be: 4043 eors r3, r0
1085c0: 4293 cmp r3, r2
1085c2: d136 bne.n 108632 <sem_timedwait+0x86>
__asm__ volatile (
1085c4: f3ef 8400 mrs r4, CPSR
1085c8: f044 0380 orr.w r3, r4, #128 ; 0x80
1085cc: f383 8900 msr CPSR_fc, r3
sem = _Sem_Get( &_sem->_Semaphore );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
1085d0: 6983 ldr r3, [r0, #24]
if ( RTEMS_PREDICT_TRUE( count > 0 ) ) {
1085d2: b13b cbz r3, 1085e4 <sem_timedwait+0x38>
sem->count = count - 1;
1085d4: 3b01 subs r3, #1
1085d6: 6183 str r3, [r0, #24]
__asm__ volatile (
1085d8: f384 8900 msr CPSR_fc, r4
_Sem_Queue_release( sem, level, &queue_context );
return 0;
1085dc: 2400 movs r4, #0
&queue_context
);
status = _Thread_Wait_get_status( executing );
return _POSIX_Zero_or_minus_one_plus_errno( status );
}
}
1085de: 4620 mov r0, r4
1085e0: b00a add sp, #40 ; 0x28
1085e2: bd70 pop {r4, r5, r6, pc}
1085e4: f242 2300 movw r3, #8704 ; 0x2200
queue_context->thread_state = thread_state;
1085e8: 2202 movs r2, #2
1085ea: f2c0 0320 movt r3, #32
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
1085ee: f64a 452d movw r5, #44077 ; 0xac2d
1085f2: 699e ldr r6, [r3, #24]
_Thread_queue_Enqueue(
1085f4: 300c adds r0, #12
queue_context->Timeout.arg = abstime;
1085f6: 9104 str r1, [sp, #16]
1085f8: f640 6110 movw r1, #3600 ; 0xe10
queue_context->thread_state = thread_state;
1085fc: 9202 str r2, [sp, #8]
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
1085fe: f2c0 0510 movt r5, #16
108602: ab01 add r3, sp, #4
108604: 4632 mov r2, r6
108606: f2c0 0111 movt r1, #17
10860a: 9401 str r4, [sp, #4]
10860c: 9503 str r5, [sp, #12]
10860e: f001 fe01 bl 10a214 <_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;
108612: 6cf4 ldr r4, [r6, #76] ; 0x4c
if ( status == STATUS_SUCCESSFUL ) {
108614: 2c00 cmp r4, #0
108616: d0e2 beq.n 1085de <sem_timedwait+0x32> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
108618: f006 fec4 bl 10f3a4 <__errno>
return STATUS_GET_POSIX( status );
10861c: f104 03ff add.w r3, r4, #255 ; 0xff
108620: ea13 0324 ands.w r3, r3, r4, asr #32
108624: bf38 it cc
108626: 4623 movcc r3, r4
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
108628: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
return STATUS_GET_POSIX( status );
10862c: 121b asrs r3, r3, #8
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
10862e: 6003 str r3, [r0, #0]
108630: e7d5 b.n 1085de <sem_timedwait+0x32>
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
108632: f006 feb7 bl 10f3a4 <__errno>
108636: 2316 movs r3, #22
108638: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
10863c: 6003 str r3, [r0, #0]
10863e: e7ce b.n 1085de <sem_timedwait+0x32>
001075c4 <shm_open>:
{
1075c4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
if ( ( oflag & O_ACCMODE ) != O_RDONLY && ( oflag & O_ACCMODE ) != O_RDWR ) {
1075c8: f001 0603 and.w r6, r1, #3
{
1075cc: 4691 mov r9, r2
if ( ( oflag & O_ACCMODE ) != O_RDONLY && ( oflag & O_ACCMODE ) != O_RDWR ) {
1075ce: 1eb2 subs r2, r6, #2
1075d0: bf18 it ne
1075d2: 2201 movne r2, #1
1075d4: 07cc lsls r4, r1, #31
{
1075d6: b087 sub sp, #28
if ( ( oflag & O_ACCMODE ) != O_RDONLY && ( oflag & O_ACCMODE ) != O_RDWR ) {
1075d8: f100 80f5 bmi.w 1077c6 <shm_open+0x202> <== ALWAYS TAKEN
if ( ( oflag & ~( O_RDONLY | O_RDWR | O_CREAT | O_EXCL | O_TRUNC ) ) != 0 ) {
1075dc: f421 6360 bic.w r3, r1, #3584 ; 0xe00
1075e0: 460d mov r5, r1
1075e2: f023 0302 bic.w r3, r3, #2
1075e6: 2b00 cmp r3, #0
1075e8: f040 80ed bne.w 1077c6 <shm_open+0x202> <== ALWAYS TAKEN
if ( ( oflag & O_TRUNC ) != 0 && ( oflag & O_ACCMODE ) != O_RDWR ) {
1075ec: ea12 2391 ands.w r3, r2, r1, lsr #10
1075f0: f401 6a80 and.w sl, r1, #1024 ; 0x400
1075f4: f040 80e7 bne.w 1077c6 <shm_open+0x202> <== ALWAYS TAKEN
iop = rtems_libio_allocate();
1075f8: 4680 mov r8, r0
1075fa: f7fd fcd9 bl 104fb0 <rtems_libio_allocate>
if ( iop == NULL ) {
1075fe: 4604 mov r4, r0
107600: 2800 cmp r0, #0
107602: f000 80e8 beq.w 1077d6 <shm_open+0x212> <== ALWAYS TAKEN
_RTEMS_Lock_allocator();
107606: f000 f9f1 bl 1079ec <_RTEMS_Lock_allocator>
return (POSIX_Shm_Control *) _Objects_Get_by_name(
10760a: f240 0030 movw r0, #48 ; 0x30
10760e: ab01 add r3, sp, #4
107610: f2c0 0020 movt r0, #32
107614: 466a mov r2, sp
107616: 4641 mov r1, r8
107618: f000 fdb2 bl 108180 <_Objects_Get_by_name>
if ( shm == NULL ) {
10761c: 4607 mov r7, r0
10761e: b318 cbz r0, 107668 <shm_open+0xa4>
if ( ( oflag & ( O_EXCL | O_CREAT ) ) == ( O_EXCL | O_CREAT ) ) {
107620: f405 6120 and.w r1, r5, #2560 ; 0xa00 <== NOT EXECUTED
107624: f5b1 6f20 cmp.w r1, #2560 ; 0xa00 <== NOT EXECUTED
107628: d10e bne.n 107648 <shm_open+0x84> <== NOT EXECUTED
err = EEXIST;
10762a: 2511 movs r5, #17 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
10762c: f000 f9e4 bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
rtems_libio_free( iop );
107630: 4620 mov r0, r4 <== NOT EXECUTED
107632: f7fd fcd7 bl 104fe4 <rtems_libio_free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( err );
107636: f006 fbe3 bl 10de00 <__errno> <== NOT EXECUTED
10763a: 4603 mov r3, r0 <== NOT EXECUTED
10763c: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
107640: 601d str r5, [r3, #0] <== NOT EXECUTED
}
107642: b007 add sp, #28 <== NOT EXECUTED
107644: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
flags = RTEMS_FS_PERMS_WRITE;
107648: 2e00 cmp r6, #0 <== NOT EXECUTED
return rtems_filesystem_check_access( flags, shm->mode, shm->uid, shm->gid );
10764a: 8dc3 ldrh r3, [r0, #46] ; 0x2e <== NOT EXECUTED
10764c: 8d82 ldrh r2, [r0, #44] ; 0x2c <== NOT EXECUTED
10764e: 6b01 ldr r1, [r0, #48] ; 0x30 <== NOT EXECUTED
107650: bf0c ite eq <== NOT EXECUTED
107652: 2004 moveq r0, #4 <== NOT EXECUTED
107654: 2002 movne r0, #2 <== NOT EXECUTED
107656: f002 fde9 bl 10a22c <rtems_filesystem_check_access> <== NOT EXECUTED
} else if ( !shm_access_ok( shm, oflag ) ) {
10765a: 2800 cmp r0, #0 <== NOT EXECUTED
10765c: f040 8099 bne.w 107792 <shm_open+0x1ce> <== NOT EXECUTED
err = EACCES;
107660: 250d movs r5, #13 <== NOT EXECUTED
107662: f000 f9c9 bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( err != 0 ) {
107666: e7e3 b.n 107630 <shm_open+0x6c> <== NOT EXECUTED
switch ( obj_err ) {
107668: 9b01 ldr r3, [sp, #4]
10766a: 2b00 cmp r3, #0
10766c: f000 80a3 beq.w 1077b6 <shm_open+0x1f2> <== ALWAYS TAKEN
107670: 2b01 cmp r3, #1
107672: f000 809c beq.w 1077ae <shm_open+0x1ea> <== ALWAYS TAKEN
if ( name_arg[0] != '/' ) {
107676: f898 3000 ldrb.w r3, [r8]
10767a: 2b2f cmp r3, #47 ; 0x2f
10767c: f040 809b bne.w 1077b6 <shm_open+0x1f2> <== ALWAYS TAKEN
if ( ( oflag & O_CREAT ) != O_CREAT ) {
107680: 05ab lsls r3, r5, #22
107682: f140 809c bpl.w 1077be <shm_open+0x1fa> <== ALWAYS TAKEN
name = _Workspace_String_duplicate( name_arg, name_len );
107686: 4640 mov r0, r8
107688: 9900 ldr r1, [sp, #0]
10768a: f002 f987 bl 10999c <_Workspace_String_duplicate>
if ( name == NULL ) {
10768e: 4680 mov r8, r0
107690: 2800 cmp r0, #0
107692: f000 80a8 beq.w 1077e6 <shm_open+0x222> <== ALWAYS TAKEN
return ( *information->allocate )( information );
107696: f240 0b30 movw fp, #48 ; 0x30
10769a: f2c0 0b20 movt fp, #32
10769e: f8db 3008 ldr.w r3, [fp, #8]
1076a2: 4658 mov r0, fp
1076a4: 4798 blx r3
if ( shm == NULL ) {
1076a6: 4607 mov r7, r0
1076a8: 2800 cmp r0, #0
1076aa: f000 80a0 beq.w 1077ee <shm_open+0x22a> <== ALWAYS TAKEN
gettimeofday( &tv, 0 );
1076ae: 2100 movs r1, #0
1076b0: a802 add r0, sp, #8
1076b2: f002 fc0f bl 109ed4 <gettimeofday>
shm->shm_object.ops = &_POSIX_Shm_Object_operations;
1076b6: f643 33f4 movw r3, #15348 ; 0x3bf4
1076ba: f2c0 0311 movt r3, #17
1076be: 62bb str r3, [r7, #40] ; 0x28
shm->shm_object.handle = NULL;
1076c0: 2300 movs r3, #0
shm->shm_object.size = 0;
1076c2: e9c7 3308 strd r3, r3, [r7, #32]
shm->reference_count = 1;
1076c6: 2301 movs r3, #1
1076c8: 61fb str r3, [r7, #28]
shm->mode = mode & ~rtems_filesystem_umask;
1076ca: f7fe fb9d bl 105e08 <rtems_current_user_env_get>
1076ce: 6882 ldr r2, [r0, #8]
shm->oflag = oflag;
1076d0: 637d str r5, [r7, #52] ; 0x34
shm->mode = mode & ~rtems_filesystem_umask;
1076d2: ea29 0202 bic.w r2, r9, r2
1076d6: 633a str r2, [r7, #48] ; 0x30
shm->uid = geteuid();
1076d8: f002 fbf6 bl 109ec8 <geteuid>
1076dc: 85b8 strh r0, [r7, #44] ; 0x2c
shm->gid = getegid();
1076de: f002 fbed bl 109ebc <getegid>
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
1076e2: 893b ldrh r3, [r7, #8]
1076e4: 85f8 strh r0, [r7, #46] ; 0x2e
1076e6: f8db 2004 ldr.w r2, [fp, #4]
shm->atime = (time_t) tv.tv_sec;
1076ea: e9dd 0102 ldrd r0, r1, [sp, #8]
1076ee: f103 4380 add.w r3, r3, #1073741824 ; 0x40000000
1076f2: 3b01 subs r3, #1
the_object->name.name_p = name;
1076f4: f8c7 800c str.w r8, [r7, #12]
1076f8: e9c7 010e strd r0, r1, [r7, #56] ; 0x38
shm->mtime = (time_t) tv.tv_sec;
1076fc: e9c7 0110 strd r0, r1, [r7, #64] ; 0x40
shm->ctime = (time_t) tv.tv_sec;
107700: e9c7 0112 strd r0, r1, [r7, #72] ; 0x48
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
107704: f842 7023 str.w r7, [r2, r3, lsl #2]
_RTEMS_Unlock_allocator();
107708: f000 f976 bl 1079f8 <_RTEMS_Unlock_allocator>
if ( oflag & O_TRUNC ) {
10770c: f1ba 0f00 cmp.w sl, #0
107710: d147 bne.n 1077a2 <shm_open+0x1de> <== ALWAYS TAKEN
fd = rtems_libio_iop_to_descriptor( iop );
107712: f641 4338 movw r3, #7224 ; 0x1c38
107716: f64a 20ab movw r0, #43691 ; 0xaaab
10771a: f2c0 0320 movt r3, #32
10771e: f6ca 20aa movt r0, #43690 ; 0xaaaa
107722: 1ae3 subs r3, r4, r3
iop->pathinfo.handlers = &shm_handlers;
107724: f643 32b4 movw r2, #15284 ; 0x3bb4
fd = rtems_libio_iop_to_descriptor( iop );
107728: 111b asrs r3, r3, #4
iop->pathinfo.handlers = &shm_handlers;
10772a: f2c0 0211 movt r2, #17
rtems_filesystem_location_add_to_mt_entry( &iop->pathinfo );
10772e: f104 0110 add.w r1, r4, #16
iop->data1 = shm;
107732: 62e7 str r7, [r4, #44] ; 0x2c
fd = rtems_libio_iop_to_descriptor( iop );
107734: fb03 f000 mul.w r0, r3, r0
iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry;
107738: f240 137c movw r3, #380 ; 0x17c
10773c: f2c0 0320 movt r3, #32
iop->pathinfo.node_access = shm;
107740: 61a7 str r7, [r4, #24]
iop->pathinfo.handlers = &shm_handlers;
107742: 6222 str r2, [r4, #32]
iop->data0 = fd;
107744: e9c4 3009 strd r3, r0, [r4, #36] ; 0x24
__asm__ volatile (
107748: f3ef 8500 mrs r5, CPSR
10774c: f045 0380 orr.w r3, r5, #128 ; 0x80
107750: f383 8900 msr CPSR_fc, r3
&loc->mt_entry->location_chain,
107754: 6a63 ldr r3, [r4, #36] ; 0x24
old_last = tail->previous;
107756: 69da ldr r2, [r3, #28]
return &the_chain->Tail.Node;
107758: f103 0718 add.w r7, r3, #24
the_node->next = tail;
10775c: 6127 str r7, [r4, #16]
tail->previous = the_node;
10775e: 61d9 str r1, [r3, #28]
old_last->next = the_node;
107760: 6011 str r1, [r2, #0]
the_node->previous = old_last;
107762: 6162 str r2, [r4, #20]
__asm__ volatile (
107764: f385 8900 msr CPSR_fc, r5
flags |= LIBIO_FLAGS_READ_WRITE;
107768: f640 1302 movw r3, #2306 ; 0x902
10776c: f640 1206 movw r2, #2310 ; 0x906
107770: 2e00 cmp r6, #0
107772: bf08 it eq
107774: 461a moveq r2, r3
__asm__ volatile (
107776: f3ef 8100 mrs r1, CPSR
10777a: f041 0380 orr.w r3, r1, #128 ; 0x80
10777e: f383 8900 msr CPSR_fc, r3
*obj = val | arg;
107782: 6823 ldr r3, [r4, #0]
107784: 4313 orrs r3, r2
107786: 6023 str r3, [r4, #0]
__asm__ volatile (
107788: f381 8900 msr CPSR_fc, r1
}
10778c: b007 add sp, #28
10778e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
++shm->reference_count;
107792: 69fb ldr r3, [r7, #28] <== NOT EXECUTED
107794: 3301 adds r3, #1 <== NOT EXECUTED
107796: 61fb str r3, [r7, #28] <== NOT EXECUTED
107798: f000 f92e bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( oflag & O_TRUNC ) {
10779c: f1ba 0f00 cmp.w sl, #0 <== NOT EXECUTED
1077a0: d0b7 beq.n 107712 <shm_open+0x14e> <== NOT EXECUTED
err = shm_ftruncate( iop, 0 );
1077a2: 2200 movs r2, #0 <== NOT EXECUTED
1077a4: 2300 movs r3, #0 <== NOT EXECUTED
1077a6: 4620 mov r0, r4 <== NOT EXECUTED
1077a8: f7ff fe9c bl 1074e4 <shm_ftruncate> <== NOT EXECUTED
1077ac: e7b1 b.n 107712 <shm_open+0x14e> <== NOT EXECUTED
err = ENAMETOOLONG;
1077ae: 255b movs r5, #91 ; 0x5b <== NOT EXECUTED
1077b0: f000 f922 bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( err != 0 ) {
1077b4: e73c b.n 107630 <shm_open+0x6c> <== NOT EXECUTED
*error = EINVAL;
1077b6: 2516 movs r5, #22 <== NOT EXECUTED
1077b8: f000 f91e bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( err != 0 ) {
1077bc: e738 b.n 107630 <shm_open+0x6c> <== NOT EXECUTED
*error = ENOENT;
1077be: 2502 movs r5, #2 <== NOT EXECUTED
1077c0: f000 f91a bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( err != 0 ) {
1077c4: e734 b.n 107630 <shm_open+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
1077c6: f006 fb1b bl 10de00 <__errno> <== NOT EXECUTED
1077ca: 220d movs r2, #13 <== NOT EXECUTED
1077cc: 4603 mov r3, r0 <== NOT EXECUTED
1077ce: 601a str r2, [r3, #0] <== NOT EXECUTED
return -1;
1077d0: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1077d4: e735 b.n 107642 <shm_open+0x7e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMFILE );
1077d6: f006 fb13 bl 10de00 <__errno> <== NOT EXECUTED
1077da: 2218 movs r2, #24 <== NOT EXECUTED
1077dc: 4603 mov r3, r0 <== NOT EXECUTED
1077de: 601a str r2, [r3, #0] <== NOT EXECUTED
1077e0: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff <== NOT EXECUTED
1077e4: e72d b.n 107642 <shm_open+0x7e> <== NOT EXECUTED
*error = ENOSPC;
1077e6: 251c movs r5, #28 <== NOT EXECUTED
1077e8: f000 f906 bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( err != 0 ) {
1077ec: e720 b.n 107630 <shm_open+0x6c> <== NOT EXECUTED
_Workspace_Free( name );
1077ee: 4640 mov r0, r8 <== NOT EXECUTED
*error = ENFILE;
1077f0: 2517 movs r5, #23 <== NOT EXECUTED
_Workspace_Free( name );
1077f2: f002 f8cb bl 10998c <_Workspace_Free> <== NOT EXECUTED
1077f6: f000 f8ff bl 1079f8 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
if ( err != 0 ) {
1077fa: e719 b.n 107630 <shm_open+0x6c> <== NOT EXECUTED
00108e9c <shm_unlink>:
#include <rtems/seterr.h>
#include <rtems/posix/shmimpl.h>
int shm_unlink( const char *name )
{
108e9c: b570 push {r4, r5, r6, lr}
108e9e: f240 1550 movw r5, #336 ; 0x150
108ea2: b082 sub sp, #8
108ea4: 4604 mov r4, r0
108ea6: f2c0 0520 movt r5, #32
_RTEMS_Lock_allocator();
108eaa: f001 fbb3 bl 10a614 <_RTEMS_Lock_allocator>
108eae: ab01 add r3, sp, #4
108eb0: 2200 movs r2, #0
108eb2: 4621 mov r1, r4
108eb4: 4628 mov r0, r5
108eb6: f002 fbbf bl 10b638 <_Objects_Get_by_name>
POSIX_Shm_Control *shm;
_Objects_Allocator_lock();
shm = _POSIX_Shm_Get_by_name( name, 0, &obj_err );
if ( shm ) {
108eba: b1a8 cbz r0, 108ee8 <shm_unlink+0x4c>
_Objects_Namespace_remove_string(
108ebc: 4604 mov r4, r0
108ebe: 4601 mov r1, r0
108ec0: 4628 mov r0, r5
108ec2: f002 fbb3 bl 10b62c <_Objects_Namespace_remove_string>
&_POSIX_Shm_Information,
&shm->Object
);
if ( shm->reference_count == 0 ) {
108ec6: 69e6 ldr r6, [r4, #28]
108ec8: b946 cbnz r6, 108edc <shm_unlink+0x40>
( *information->deallocate )( information, the_object );
108eca: 68eb ldr r3, [r5, #12]
108ecc: 4621 mov r1, r4
108ece: 4628 mov r0, r5
108ed0: 4798 blx r3
_RTEMS_Unlock_allocator();
108ed2: f001 fba5 bl 10a620 <_RTEMS_Unlock_allocator>
_Objects_Allocator_unlock();
if ( err != 0 )
rtems_set_errno_and_return_minus_one( err );
return 0;
}
108ed6: 4630 mov r0, r6
108ed8: b002 add sp, #8
108eda: bd70 pop {r4, r5, r6, pc}
return 0;
108edc: 2600 movs r6, #0 <== NOT EXECUTED
108ede: f001 fb9f bl 10a620 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
}
108ee2: 4630 mov r0, r6 <== NOT EXECUTED
108ee4: b002 add sp, #8 <== NOT EXECUTED
108ee6: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
switch ( obj_err ) {
108ee8: 9b01 ldr r3, [sp, #4] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( err );
108eea: f04f 36ff mov.w r6, #4294967295 ; 0xffffffff <== NOT EXECUTED
switch ( obj_err ) {
108eee: 2b01 cmp r3, #1 <== NOT EXECUTED
err = ENOENT;
108ef0: bf14 ite ne <== NOT EXECUTED
108ef2: 2402 movne r4, #2 <== NOT EXECUTED
err = ENAMETOOLONG;
108ef4: 245b moveq r4, #91 ; 0x5b <== NOT EXECUTED
108ef6: f001 fb93 bl 10a620 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( err );
108efa: f008 f839 bl 110f70 <__errno> <== NOT EXECUTED
108efe: 6004 str r4, [r0, #0] <== NOT EXECUTED
108f00: e7e9 b.n 108ed6 <shm_unlink+0x3a> <== NOT EXECUTED
108f02: bf00 nop
0010a138 <sigtimedwait>:
int sigtimedwait(
const sigset_t *__restrict set,
siginfo_t *__restrict info,
const struct timespec *__restrict timeout
)
{
10a138: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10a13c: b094 sub sp, #80 ; 0x50
int error;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10a13e: 2800 cmp r0, #0
10a140: f000 80f8 beq.w 10a334 <sigtimedwait+0x1fc>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
if ( timeout != NULL ) {
10a144: 460d mov r5, r1
10a146: 4614 mov r4, r2
10a148: 4607 mov r7, r0
10a14a: 2a00 cmp r2, #0
10a14c: f000 808d beq.w 10a26a <sigtimedwait+0x132>
const struct timespec *end;
_Timecounter_Nanouptime( &uptime );
10a150: a806 add r0, sp, #24
10a152: f7fd f9c1 bl 1074d8 <_Timecounter_Nanouptime>
&& (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND;
10a156: 68a2 ldr r2, [r4, #8]
10a158: f64c 10ff movw r0, #51711 ; 0xc9ff
10a15c: f6c3 309a movt r0, #15258 ; 0x3b9a
10a160: 4282 cmp r2, r0
10a162: d95e bls.n 10a222 <sigtimedwait+0xea>
return NULL;
10a164: 2200 movs r2, #0
queue_context->enqueue_callout =
10a166: f648 631d movw r3, #36381 ; 0x8e1d
queue_context->Timeout.arg = abstime;
10a16a: 920e str r2, [sp, #56] ; 0x38
queue_context->enqueue_callout =
10a16c: f2c0 0310 movt r3, #16
10a170: 930d str r3, [sp, #52] ; 0x34
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10a172: 2d00 cmp r5, #0
10a174: f000 8081 beq.w 10a27a <sigtimedwait+0x142> <== ALWAYS TAKEN
10a178: f242 5380 movw r3, #9600 ; 0x2580
10a17c: f2c0 0320 movt r3, #32
10a180: 699c ldr r4, [r3, #24]
executing = _Thread_Get_executing();
api = executing->API_Extensions[ THREAD_API_POSIX ];
10a182: f8d4 6160 ldr.w r6, [r4, #352] ; 0x160
__asm__ volatile (
10a186: f3ef 8300 mrs r3, CPSR
10a18a: f043 0280 orr.w r2, r3, #128 ; 0x80
10a18e: f382 8900 msr CPSR_fc, r2
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
10a192: 930b str r3, [sp, #44] ; 0x2c
*/
/* API signals pending? */
_POSIX_signals_Acquire( &queue_context );
if ( *set & api->signals_pending ) {
10a194: 683b ldr r3, [r7, #0]
10a196: 6ef2 ldr r2, [r6, #108] ; 0x6c
10a198: 4213 tst r3, r2
10a19a: f040 8099 bne.w 10a2d0 <sigtimedwait+0x198>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10a19e: f242 52e8 movw r2, #9704 ; 0x25e8
10a1a2: f2c0 0220 movt r2, #32
10a1a6: 6812 ldr r2, [r2, #0]
10a1a8: ea13 0802 ands.w r8, r3, r2
10a1ac: d167 bne.n 10a27e <sigtimedwait+0x146>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
10a1ae: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
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(
10a1b2: f643 015c movw r1, #14428 ; 0x385c
the_info->si_signo = -1;
10a1b6: 602a str r2, [r5, #0]
_Thread_queue_Enqueue(
10a1b8: f240 20cc movw r0, #716 ; 0x2cc
executing->Wait.option = *set;
10a1bc: 64a3 str r3, [r4, #72] ; 0x48
queue_context->thread_state = thread_state;
10a1be: f44f 6380 mov.w r3, #1024 ; 0x400
10a1c2: f2c1 0300 movt r3, #4096 ; 0x1000
_Thread_queue_Enqueue(
10a1c6: f2c0 0111 movt r1, #17
10a1ca: f2c0 0020 movt r0, #32
10a1ce: 4622 mov r2, r4
10a1d0: 930c str r3, [sp, #48] ; 0x30
10a1d2: ab0b add r3, sp, #44 ; 0x2c
executing->Wait.return_argument = the_info;
10a1d4: 6425 str r5, [r4, #64] ; 0x40
_Thread_queue_Enqueue(
10a1d6: f7fe f9ef bl 1085b8 <_Thread_queue_Enqueue>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals(
10a1da: 6829 ldr r1, [r5, #0]
10a1dc: 4643 mov r3, r8
10a1de: f8cd 8000 str.w r8, [sp]
10a1e2: f04f 0801 mov.w r8, #1
10a1e6: 4630 mov r0, r6
10a1e8: 462a mov r2, r5
10a1ea: f8cd 8004 str.w r8, [sp, #4]
10a1ee: f001 fc63 bl 10bab8 <_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 );
10a1f2: 6ce3 ldr r3, [r4, #76] ; 0x4c
10a1f4: f103 06ff add.w r6, r3, #255 ; 0xff
10a1f8: ea16 0623 ands.w r6, r6, r3, asr #32
10a1fc: bf38 it cc
10a1fe: 461e movcc r6, r3
10a200: 1236 asrs r6, r6, #8
* was not in our set.
*/
error = _POSIX_Get_error_after_wait( executing );
if (
10a202: 2e04 cmp r6, #4
10a204: f040 808d bne.w 10a322 <sigtimedwait+0x1ea>
error != EINTR
|| ( *set & signo_to_mask( the_info->si_signo ) ) == 0
10a208: 682c ldr r4, [r5, #0]
10a20a: 683b ldr r3, [r7, #0]
return 1u << (sig - 1);
10a20c: 1e62 subs r2, r4, #1
10a20e: fa08 f802 lsl.w r8, r8, r2
10a212: ea18 0f03 tst.w r8, r3
10a216: f000 8087 beq.w 10a328 <sigtimedwait+0x1f0>
rtems_set_errno_and_return_minus_one( error );
}
return the_info->si_signo;
}
10a21a: 4620 mov r0, r4
10a21c: b014 add sp, #80 ; 0x50
10a21e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
return _Watchdog_Is_valid_timespec( ts ) && ts->tv_sec >= 0;
10a222: e9d4 3600 ldrd r3, r6, [r4]
10a226: 2e00 cmp r6, #0
10a228: db9c blt.n 10a164 <sigtimedwait+0x2c> <== ALWAYS TAKEN
now->tv_nsec += delta->tv_nsec;
10a22a: 9908 ldr r1, [sp, #32]
sec = (uint64_t) now->tv_sec;
10a22c: 9c06 ldr r4, [sp, #24]
now->tv_nsec += delta->tv_nsec;
10a22e: 440a add r2, r1
sec = (uint64_t) now->tv_sec;
10a230: 9907 ldr r1, [sp, #28]
sec += (uint64_t) delta->tv_sec;
10a232: 191b adds r3, r3, r4
10a234: eb41 0106 adc.w r1, r1, r6
if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) {
10a238: 4282 cmp r2, r0
now->tv_nsec += delta->tv_nsec;
10a23a: bfd8 it le
10a23c: 9208 strle r2, [sp, #32]
if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) {
10a23e: dd08 ble.n 10a252 <sigtimedwait+0x11a> <== NEVER TAKEN
++sec;
10a240: 3301 adds r3, #1 <== NOT EXECUTED
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
10a242: f44f 5058 mov.w r0, #13824 ; 0x3600 <== NOT EXECUTED
10a246: f2cc 4065 movt r0, #50277 ; 0xc465 <== NOT EXECUTED
++sec;
10a24a: f141 0100 adc.w r1, r1, #0 <== NOT EXECUTED
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
10a24e: 4410 add r0, r2 <== NOT EXECUTED
10a250: 9008 str r0, [sp, #32] <== NOT EXECUTED
if ( sec <= INT64_MAX ) {
10a252: 2900 cmp r1, #0
return now;
10a254: aa06 add r2, sp, #24
now->tv_sec = INT64_MAX;
10a256: bfbb ittet lt
10a258: f04f 30ff movlt.w r0, #4294967295 ; 0xffffffff
10a25c: f06f 4100 mvnlt.w r1, #2147483648 ; 0x80000000
now->tv_sec = sec;
10a260: e9cd 3106 strdge r3, r1, [sp, #24]
now->tv_sec = INT64_MAX;
10a264: e9cd 0106 strdlt r0, r1, [sp, #24]
10a268: e77d b.n 10a166 <sigtimedwait+0x2e>
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
10a26a: f248 53ad movw r3, #34221 ; 0x85ad
10a26e: f2c0 0310 movt r3, #16
10a272: 930d str r3, [sp, #52] ; 0x34
the_info = ( info ) ? info : &signal_information;
10a274: 2d00 cmp r5, #0
10a276: f47f af7f bne.w 10a178 <sigtimedwait+0x40>
10a27a: ad03 add r5, sp, #12
10a27c: e77c b.n 10a178 <sigtimedwait+0x40>
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10a27e: 241b movs r4, #27
10a280: 2101 movs r1, #1
10a282: 1e63 subs r3, r4, #1
10a284: fa01 f303 lsl.w r3, r1, r3
if ( set & signo_to_mask( signo ) ) {
10a288: 4213 tst r3, r2
10a28a: d10d bne.n 10a2a8 <sigtimedwait+0x170> <== ALWAYS TAKEN
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10a28c: 3401 adds r4, #1
10a28e: 2c20 cmp r4, #32
10a290: d1f7 bne.n 10a282 <sigtimedwait+0x14a>
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10a292: 2401 movs r4, #1
10a294: 4621 mov r1, r4
10a296: e002 b.n 10a29e <sigtimedwait+0x166>
10a298: 3401 adds r4, #1
10a29a: 2c1b cmp r4, #27
10a29c: d004 beq.n 10a2a8 <sigtimedwait+0x170> <== ALWAYS TAKEN
10a29e: 1e63 subs r3, r4, #1
10a2a0: fa01 f303 lsl.w r3, r1, r3
if ( set & signo_to_mask( signo ) ) {
10a2a4: 4213 tst r3, r2
10a2a6: d0f7 beq.n 10a298 <sigtimedwait+0x160>
_POSIX_signals_Clear_signals( api, signo, the_info, true, false, false );
10a2a8: 2700 movs r7, #0
10a2aa: 2301 movs r3, #1
10a2ac: 4630 mov r0, r6
10a2ae: 462a mov r2, r5
10a2b0: 4621 mov r1, r4
10a2b2: e9cd 7700 strd r7, r7, [sp]
10a2b6: f001 fbff bl 10bab8 <_POSIX_signals_Clear_signals>
__asm__ volatile (
10a2ba: 9b0b ldr r3, [sp, #44] ; 0x2c
10a2bc: f383 8900 msr CPSR_fc, r3
the_info->si_code = SI_USER;
10a2c0: 2301 movs r3, #1
}
10a2c2: 4620 mov r0, r4
the_info->si_code = SI_USER;
10a2c4: e9c5 4300 strd r4, r3, [r5]
the_info->si_value.sival_int = 0;
10a2c8: 60af str r7, [r5, #8]
}
10a2ca: b014 add sp, #80 ; 0x50
10a2cc: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10a2d0: 211b movs r1, #27
10a2d2: 2001 movs r0, #1
10a2d4: 1e4b subs r3, r1, #1
10a2d6: fa00 f303 lsl.w r3, r0, r3
if ( set & signo_to_mask( signo ) ) {
10a2da: 4213 tst r3, r2
10a2dc: d10d bne.n 10a2fa <sigtimedwait+0x1c2> <== ALWAYS TAKEN
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10a2de: 3101 adds r1, #1
10a2e0: 2920 cmp r1, #32
10a2e2: d1f7 bne.n 10a2d4 <sigtimedwait+0x19c>
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10a2e4: 2101 movs r1, #1
10a2e6: 4608 mov r0, r1
10a2e8: e002 b.n 10a2f0 <sigtimedwait+0x1b8>
10a2ea: 3101 adds r1, #1
10a2ec: 291b cmp r1, #27
10a2ee: d004 beq.n 10a2fa <sigtimedwait+0x1c2> <== ALWAYS TAKEN
10a2f0: 1e4b subs r3, r1, #1
10a2f2: fa00 f303 lsl.w r3, r0, r3
if ( set & signo_to_mask( signo ) ) {
10a2f6: 4213 tst r3, r2
10a2f8: d0f7 beq.n 10a2ea <sigtimedwait+0x1b2>
_POSIX_signals_Clear_signals(
10a2fa: 2700 movs r7, #0
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10a2fc: 6029 str r1, [r5, #0]
_POSIX_signals_Clear_signals(
10a2fe: 463b mov r3, r7
10a300: 4630 mov r0, r6
10a302: 462a mov r2, r5
10a304: e9cd 7700 strd r7, r7, [sp]
10a308: f001 fbd6 bl 10bab8 <_POSIX_signals_Clear_signals>
10a30c: 9b0b ldr r3, [sp, #44] ; 0x2c
10a30e: f383 8900 msr CPSR_fc, r3
return the_info->si_signo;
10a312: 682c ldr r4, [r5, #0]
the_info->si_code = SI_USER;
10a314: 2301 movs r3, #1
the_info->si_value.sival_int = 0;
10a316: e9c5 3701 strd r3, r7, [r5, #4]
}
10a31a: 4620 mov r0, r4
10a31c: b014 add sp, #80 ; 0x50
10a31e: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
error = EAGAIN;
10a322: 2e74 cmp r6, #116 ; 0x74
10a324: bf08 it eq
10a326: 260b moveq r6, #11
rtems_set_errno_and_return_minus_one( error );
10a328: f003 fd78 bl 10de1c <__errno>
10a32c: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
10a330: 6006 str r6, [r0, #0]
10a332: e772 b.n 10a21a <sigtimedwait+0xe2>
rtems_set_errno_and_return_minus_one( EINVAL );
10a334: f003 fd72 bl 10de1c <__errno>
10a338: 2316 movs r3, #22
10a33a: f04f 34ff mov.w r4, #4294967295 ; 0xffffffff
10a33e: 6003 str r3, [r0, #0]
10a340: e76b b.n 10a21a <sigtimedwait+0xe2>
10a342: bf00 nop
0010b468 <sigwait>:
int *__restrict sig
)
{
int status;
status = sigtimedwait( set, NULL, NULL );
10b468: 2200 movs r2, #0
{
10b46a: b510 push {r4, lr}
10b46c: 460c mov r4, r1
status = sigtimedwait( set, NULL, NULL );
10b46e: 4611 mov r1, r2
10b470: f7ff fef4 bl 10b25c <sigtimedwait>
if ( status != -1 ) {
10b474: 1c43 adds r3, r0, #1
10b476: d006 beq.n 10b486 <sigwait+0x1e>
if ( sig )
10b478: b11c cbz r4, 10b482 <sigwait+0x1a>
10b47a: 4603 mov r3, r0
*sig = status;
return 0;
10b47c: 2000 movs r0, #0
*sig = status;
10b47e: 6023 str r3, [r4, #0]
}
return errno;
}
10b480: bd10 pop {r4, pc}
return 0;
10b482: 4620 mov r0, r4 <== NOT EXECUTED
}
10b484: bd10 pop {r4, pc} <== NOT EXECUTED
return errno;
10b486: f003 fd69 bl 10ef5c <__errno>
10b48a: 6800 ldr r0, [r0, #0]
}
10b48c: bd10 pop {r4, pc}
10b48e: bf00 nop
001064dc <sysconf>:
long sysconf(
int name
)
{
switch ( name ) {
1064dc: 280a cmp r0, #10
{
1064de: b508 push {r3, lr}
switch ( name ) {
1064e0: dc0b bgt.n 1064fa <sysconf+0x1e>
1064e2: 2801 cmp r0, #1
1064e4: dd1a ble.n 10651c <sysconf+0x40>
1064e6: 3802 subs r0, #2
1064e8: 2808 cmp r0, #8
1064ea: d817 bhi.n 10651c <sysconf+0x40> <== ALWAYS TAKEN
1064ec: e8df f000 tbb [pc, r0]
1064f0: 16201629 .word 0x16201629
1064f4: 1e261616 .word 0x1e261616
1064f8: 1e .byte 0x1e
1064f9: 00 .byte 0x00
1064fa: 284f cmp r0, #79 ; 0x4f
case _SC_GETPW_R_SIZE_MAX:
return 1024;
case _SC_PAGESIZE:
return PAGE_SIZE;
case _SC_SYMLOOP_MAX:
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
1064fc: bf08 it eq
1064fe: 2020 moveq r0, #32
switch ( name ) {
106500: d006 beq.n 106510 <sysconf+0x34> <== ALWAYS TAKEN
106502: 288c cmp r0, #140 ; 0x8c
case _SC_NPROCESSORS_CONF:
return (long) rtems_configuration_get_maximum_processors();
case _SC_NPROCESSORS_ONLN:
return (long) rtems_scheduler_get_processor_maximum();
case _SC_POSIX_26_VERSION:
return (long) _POSIX_26_VERSION;
106504: bf04 itt eq
106506: f640 6078 movweq r0, #3704 ; 0xe78
10650a: f2c0 0003 movteq r0, #3
switch ( name ) {
10650e: d100 bne.n 106512 <sysconf+0x36> <== NEVER TAKEN
return 0;
#endif
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
}
106510: bd08 pop {r3, pc}
switch ( name ) {
106512: 2833 cmp r0, #51 ; 0x33
return 1024;
106514: bf08 it eq
106516: f44f 6080 moveq.w r0, #1024 ; 0x400
switch ( name ) {
10651a: d0f9 beq.n 106510 <sysconf+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
10651c: f006 faea bl 10caf4 <__errno>
106520: 2216 movs r2, #22
106522: 4603 mov r3, r0
106524: 601a str r2, [r3, #0]
106526: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10652a: bd08 pop {r3, pc}
return (long) rtems_configuration_get_maximum_processors();
10652c: 2001 movs r0, #1
}
10652e: bd08 pop {r3, pc}
return rtems_libio_number_iops;
106530: f24e 132c movw r3, #57644 ; 0xe12c
106534: f2c0 0310 movt r3, #16
106538: 6818 ldr r0, [r3, #0]
}
10653a: bd08 pop {r3, pc}
switch ( name ) {
10653c: f44f 5080 mov.w r0, #4096 ; 0x1000
}
106540: bd08 pop {r3, pc}
return (long) rtems_clock_get_ticks_per_second();
106542: f24e 03fc movw r3, #57596 ; 0xe0fc
106546: f2c0 0310 movt r3, #16
10654a: 6818 ldr r0, [r3, #0]
}
10654c: bd08 pop {r3, pc}
10654e: bf00 nop
0010b734 <timer_create>:
if ( clock_id != CLOCK_REALTIME )
10b734: 2801 cmp r0, #1
{
10b736: b538 push {r3, r4, r5, lr}
if ( clock_id != CLOCK_REALTIME )
10b738: d166 bne.n 10b808 <timer_create+0xd4>
if ( !timerid )
10b73a: 4615 mov r5, r2
10b73c: 2a00 cmp r2, #0
10b73e: d063 beq.n 10b808 <timer_create+0xd4>
if (evp != NULL) {
10b740: 460c mov r4, r1
10b742: 2900 cmp r1, #0
10b744: d044 beq.n 10b7d0 <timer_create+0x9c>
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10b746: 680b ldr r3, [r1, #0]
10b748: 3b01 subs r3, #1
10b74a: 2b01 cmp r3, #1
10b74c: d85c bhi.n 10b808 <timer_create+0xd4> <== ALWAYS TAKEN
if ( !evp->sigev_signo )
10b74e: 684b ldr r3, [r1, #4]
10b750: 2b00 cmp r3, #0
10b752: d059 beq.n 10b808 <timer_create+0xd4> <== ALWAYS TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10b754: 3b01 subs r3, #1
if ( !is_valid_signo(evp->sigev_signo) )
10b756: 2b1f cmp r3, #31
10b758: d856 bhi.n 10b808 <timer_create+0xd4> <== ALWAYS 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 );
10b75a: f240 105c movw r0, #348 ; 0x15c
10b75e: f2c0 0020 movt r0, #32
10b762: f7fd fbe1 bl 108f28 <_Objects_Allocate>
if ( !ptimer ) {
10b766: 2800 cmp r0, #0
10b768: d044 beq.n 10b7f4 <timer_create+0xc0> <== ALWAYS TAKEN
10b76a: f241 1300 movw r3, #4352 ; 0x1100
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10b76e: 2202 movs r2, #2
10b770: f2c0 0321 movt r3, #33 ; 0x21
10b774: f880 2034 strb.w r2, [r0, #52] ; 0x34
ptimer->thread_id = _Thread_Get_executing()->Object.id;
10b778: 699a ldr r2, [r3, #24]
ptimer->inf.sigev_notify = evp->sigev_notify;
10b77a: 6823 ldr r3, [r4, #0]
ptimer->thread_id = _Thread_Get_executing()->Object.id;
10b77c: 6891 ldr r1, [r2, #8]
ptimer->inf.sigev_notify = evp->sigev_notify;
10b77e: 6383 str r3, [r0, #56] ; 0x38
ptimer->inf.sigev_value = evp->sigev_value;
10b780: e9d4 2301 ldrd r2, r3, [r4, #4]
ptimer->thread_id = _Thread_Get_executing()->Object.id;
10b784: 6301 str r1, [r0, #48] ; 0x30
ptimer->inf.sigev_value = evp->sigev_value;
10b786: e9c0 230f strd r2, r3, [r0, #60] ; 0x3c
_Objects_Get_index( the_object->id ),
10b78a: 6883 ldr r3, [r0, #8]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10b78c: f240 115c movw r1, #348 ; 0x15c
10b790: f2c0 0120 movt r1, #32
ptimer->timer_data.it_value.tv_sec = 0;
10b794: efc0 0010 vmov.i32 d16, #0 ; 0x00000000
10b798: 6849 ldr r1, [r1, #4]
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
10b79a: 2202 movs r2, #2
*timerid = ptimer->Object.id;
10b79c: 602b str r3, [r5, #0]
ptimer->overrun = 0;
10b79e: 2400 movs r4, #0
10b7a0: b29b uxth r3, r3
10b7a2: 61c2 str r2, [r0, #28]
the_watchdog->routine = routine;
10b7a4: f64b 0219 movw r2, #47129 ; 0xb819
10b7a8: 6744 str r4, [r0, #116] ; 0x74
10b7aa: f103 4380 add.w r3, r3, #1073741824 ; 0x40000000
10b7ae: f2c0 0210 movt r2, #16
10b7b2: 3b01 subs r3, #1
ptimer->timer_data.it_value.tv_sec = 0;
10b7b4: edc0 0b18 vstr d16, [r0, #96] ; 0x60
ptimer->timer_data.it_value.tv_nsec = 0;
10b7b8: 6684 str r4, [r0, #104] ; 0x68
ptimer->timer_data.it_interval.tv_sec = 0;
10b7ba: edc0 0b14 vstr d16, [r0, #80] ; 0x50
ptimer->timer_data.it_interval.tv_nsec = 0;
10b7be: 6584 str r4, [r0, #88] ; 0x58
the_object->name.name_u32 = name;
10b7c0: 60c4 str r4, [r0, #12]
10b7c2: 6202 str r2, [r0, #32]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10b7c4: f841 0023 str.w r0, [r1, r3, lsl #2]
_RTEMS_Unlock_allocator();
10b7c8: f7fc fdb4 bl 108334 <_RTEMS_Unlock_allocator>
return 0;
10b7cc: 4620 mov r0, r4
}
10b7ce: bd38 pop {r3, r4, r5, pc}
10b7d0: f240 105c movw r0, #348 ; 0x15c
10b7d4: f2c0 0020 movt r0, #32
10b7d8: f7fd fba6 bl 108f28 <_Objects_Allocate>
if ( !ptimer ) {
10b7dc: b150 cbz r0, 10b7f4 <timer_create+0xc0>
10b7de: f241 1300 movw r3, #4352 ; 0x1100
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10b7e2: 2202 movs r2, #2
10b7e4: f2c0 0321 movt r3, #33 ; 0x21
10b7e8: f880 2034 strb.w r2, [r0, #52] ; 0x34
ptimer->thread_id = _Thread_Get_executing()->Object.id;
10b7ec: 699b ldr r3, [r3, #24]
10b7ee: 689b ldr r3, [r3, #8]
10b7f0: 6303 str r3, [r0, #48] ; 0x30
if ( evp != NULL ) {
10b7f2: e7ca b.n 10b78a <timer_create+0x56>
10b7f4: f7fc fd9e bl 108334 <_RTEMS_Unlock_allocator>
rtems_set_errno_and_return_minus_one( EAGAIN );
10b7f8: f003 fb02 bl 10ee00 <__errno>
10b7fc: 220b movs r2, #11
10b7fe: 4603 mov r3, r0
10b800: 601a str r2, [r3, #0]
10b802: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10b806: bd38 pop {r3, r4, r5, pc}
rtems_set_errno_and_return_minus_one( EINVAL );
10b808: f003 fafa bl 10ee00 <__errno>
10b80c: 2216 movs r2, #22
10b80e: 4603 mov r3, r0
10b810: 601a str r2, [r3, #0]
10b812: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
}
10b816: bd38 pop {r3, r4, r5, pc}
00107a90 <timer_delete>:
int timer_delete(
timer_t timerid
)
{
107a90: b530 push {r4, r5, lr}
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
ISR_lock_Context *lock_context
)
{
return (POSIX_Timer_Control *) _Objects_Get(
107a92: f240 0510 movw r5, #16
107a96: b083 sub sp, #12
107a98: 4604 mov r4, r0
107a9a: f2c0 0520 movt r5, #32
_RTEMS_Lock_allocator();
107a9e: f000 fd83 bl 1085a8 <_RTEMS_Lock_allocator>
107aa2: 462a mov r2, r5
107aa4: a901 add r1, sp, #4
107aa6: 4620 mov r0, r4
107aa8: f001 f876 bl 108b98 <_Objects_Get>
ISR_lock_Context lock_context;
_Objects_Allocator_lock();
ptimer = _POSIX_Timer_Get( timerid, &lock_context );
if ( ptimer != NULL ) {
107aac: b1c0 cbz r0, 107ae0 <timer_delete+0x50>
Per_CPU_Control *cpu;
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
107aae: 4604 mov r4, r0
107ab0: 4601 mov r1, r0
107ab2: 4628 mov r0, r5
107ab4: f001 f866 bl 108b84 <_Objects_Close>
cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
ptimer->state = POSIX_TIMER_STATE_FREE;
107ab8: 2301 movs r3, #1
_Watchdog_Remove(
107aba: 480e ldr r0, [pc, #56] ; (107af4 <timer_delete+0x64>)
107abc: f104 0110 add.w r1, r4, #16
ptimer->state = POSIX_TIMER_STATE_FREE;
107ac0: f884 3034 strb.w r3, [r4, #52] ; 0x34
_Watchdog_Remove(
107ac4: f002 fb62 bl 10a18c <_Watchdog_Remove>
107ac8: 9b01 ldr r3, [sp, #4]
107aca: f383 8900 msr CPSR_fc, r3
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
107ace: 4628 mov r0, r5
107ad0: 68eb ldr r3, [r5, #12]
107ad2: 4621 mov r1, r4
107ad4: 4798 blx r3
_RTEMS_Unlock_allocator();
107ad6: f000 fd6d bl 1085b4 <_RTEMS_Unlock_allocator>
&ptimer->Timer
);
_POSIX_Timer_Release( cpu, &lock_context );
_POSIX_Timer_Free( ptimer );
_Objects_Allocator_unlock();
return 0;
107ada: 2000 movs r0, #0
}
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EINVAL );
}
107adc: b003 add sp, #12
107ade: bd30 pop {r4, r5, pc}
107ae0: f000 fd68 bl 1085b4 <_RTEMS_Unlock_allocator>
rtems_set_errno_and_return_minus_one( EINVAL );
107ae4: f008 f970 bl 10fdc8 <__errno>
107ae8: 2216 movs r2, #22
107aea: 4603 mov r3, r0
107aec: 601a str r2, [r3, #0]
107aee: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
107af2: e7f3 b.n 107adc <timer_delete+0x4c>
107af4: 00201cb0 .word 0x00201cb0
00107b68 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *__restrict value,
struct itimerspec *__restrict ovalue
)
{
107b68: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
107b6c: b08c sub sp, #48 ; 0x30
POSIX_Timer_Control *ptimer;
ISR_lock_Context lock_context;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
107b6e: 2a00 cmp r2, #0
107b70: f000 809f beq.w 107cb2 <timer_settime+0x14a> <== ALWAYS 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) ) ) {
107b74: f102 0910 add.w r9, r2, #16
107b78: 4682 mov sl, r0
107b7a: 4648 mov r0, r9
107b7c: 4688 mov r8, r1
107b7e: 461f mov r7, r3
107b80: 4615 mov r5, r2
107b82: f002 fa71 bl 10a068 <_Timespec_Is_valid>
107b86: 2800 cmp r0, #0
107b88: f000 8093 beq.w 107cb2 <timer_settime+0x14a>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
107b8c: 4628 mov r0, r5
107b8e: f002 fa6b bl 10a068 <_Timespec_Is_valid>
107b92: 2800 cmp r0, #0
107b94: f000 808d beq.w 107cb2 <timer_settime+0x14a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
107b98: f038 0604 bics.w r6, r8, #4
107b9c: f040 8089 bne.w 107cb2 <timer_settime+0x14a>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
107ba0: 462c mov r4, r5
107ba2: f10d 0c10 add.w ip, sp, #16
107ba6: cc0f ldmia r4!, {r0, r1, r2, r3}
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
107ba8: f1b8 0f04 cmp.w r8, #4
107bac: 466c mov r4, sp
normalize = *value;
107bae: e8ac 000f stmia.w ip!, {r0, r1, r2, r3}
107bb2: e899 000f ldmia.w r9, {r0, r1, r2, r3}
107bb6: e88c 000f stmia.w ip, {r0, r1, r2, r3}
if (flags == TIMER_ABSTIME) {
107bba: d06c beq.n 107c96 <timer_settime+0x12e>
107bbc: f240 0210 movw r2, #16
107bc0: 4621 mov r1, r4
107bc2: 4650 mov r0, sl
107bc4: f2c0 0220 movt r2, #32
107bc8: f000 ffe6 bl 108b98 <_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 ) {
107bcc: 4604 mov r4, r0
107bce: 2800 cmp r0, #0
107bd0: d076 beq.n 107cc0 <timer_settime+0x158>
Per_CPU_Control *cpu;
cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
/* Stop the timer */
_Watchdog_Remove(
107bd2: f100 0810 add.w r8, r0, #16
107bd6: 483e ldr r0, [pc, #248] ; (107cd0 <timer_settime+0x168>)
107bd8: 4641 mov r1, r8
107bda: f002 fad7 bl 10a18c <_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 ) {
107bde: e9dd 2308 ldrd r2, r3, [sp, #32]
107be2: 4313 orrs r3, r2
107be4: d11e bne.n 107c24 <timer_settime+0xbc>
107be6: 9b0a ldr r3, [sp, #40] ; 0x28
107be8: b9e3 cbnz r3, 107c24 <timer_settime+0xbc>
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
107bea: f104 0c50 add.w ip, r4, #80 ; 0x50
if ( ovalue )
107bee: b137 cbz r7, 107bfe <timer_settime+0x96>
*ovalue = ptimer->timer_data;
107bf0: 4665 mov r5, ip
107bf2: cd0f ldmia r5!, {r0, r1, r2, r3}
107bf4: c70f stmia r7!, {r0, r1, r2, r3}
107bf6: e895 000f ldmia.w r5, {r0, r1, r2, r3}
107bfa: e887 000f stmia.w r7, {r0, r1, r2, r3}
/* The new data are set */
ptimer->timer_data = normalize;
107bfe: ad04 add r5, sp, #16
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
107c00: 2604 movs r6, #4
ptimer->timer_data = normalize;
107c02: cd0f ldmia r5!, {r0, r1, r2, r3}
107c04: e8ac 000f stmia.w ip!, {r0, r1, r2, r3}
107c08: e895 000f ldmia.w r5, {r0, r1, r2, r3}
107c0c: e88c 000f stmia.w ip, {r0, r1, r2, r3}
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
107c10: f884 6034 strb.w r6, [r4, #52] ; 0x34
107c14: 9b00 ldr r3, [sp, #0]
107c16: f383 8900 msr CPSR_fc, r3
/* Returns with success */
_POSIX_Timer_Release( cpu, &lock_context );
return 0;
107c1a: 2600 movs r6, #0
_POSIX_Timer_Release( cpu, &lock_context );
return 0;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
107c1c: 4630 mov r0, r6
107c1e: b00c add sp, #48 ; 0x30
107c20: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
107c24: 4628 mov r0, r5
107c26: f002 fa6b bl 10a100 <_Timespec_To_ticks>
107c2a: 6720 str r0, [r4, #112] ; 0x70
initial_period = _Timespec_To_ticks( &normalize.it_value );
107c2c: a808 add r0, sp, #32
107c2e: f002 fa67 bl 10a100 <_Timespec_To_ticks>
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
107c32: 2303 movs r3, #3
initial_period = _Timespec_To_ticks( &normalize.it_value );
107c34: 4605 mov r5, r0
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
107c36: f884 3034 strb.w r3, [r4, #52] ; 0x34
107c3a: f104 0078 add.w r0, r4, #120 ; 0x78
107c3e: f7fe fe35 bl 1068ac <_Timecounter_Nanotime>
cpu->Watchdog.ticks + ticks
107c42: f641 4080 movw r0, #7296 ; 0x1c80
_Watchdog_Insert(
107c46: 4641 mov r1, r8
cpu->Watchdog.ticks + ticks
107c48: f2c0 0020 movt r0, #32
_Watchdog_Insert(
107c4c: 6a82 ldr r2, [r0, #40] ; 0x28
107c4e: 3030 adds r0, #48 ; 0x30
107c50: f850 3c04 ldr.w r3, [r0, #-4]
107c54: 18aa adds r2, r5, r2
107c56: f143 0300 adc.w r3, r3, #0
107c5a: f7ff fc89 bl 107570 <_Watchdog_Insert>
*ovalue = ptimer->timer_data;
107c5e: f104 0c50 add.w ip, r4, #80 ; 0x50
if ( ovalue )
107c62: b13f cbz r7, 107c74 <timer_settime+0x10c>
*ovalue = ptimer->timer_data;
107c64: 4665 mov r5, ip
107c66: 463c mov r4, r7
107c68: cd0f ldmia r5!, {r0, r1, r2, r3}
107c6a: c40f stmia r4!, {r0, r1, r2, r3}
107c6c: e895 000f ldmia.w r5, {r0, r1, r2, r3}
107c70: e884 000f stmia.w r4, {r0, r1, r2, r3}
ptimer->timer_data = normalize;
107c74: f10d 0e10 add.w lr, sp, #16
107c78: e8be 000f ldmia.w lr!, {r0, r1, r2, r3}
107c7c: e8ac 000f stmia.w ip!, {r0, r1, r2, r3}
107c80: e89e 000f ldmia.w lr, {r0, r1, r2, r3}
107c84: e88c 000f stmia.w ip, {r0, r1, r2, r3}
107c88: 9b00 ldr r3, [sp, #0]
107c8a: f383 8900 msr CPSR_fc, r3
}
107c8e: 4630 mov r0, r6
107c90: b00c add sp, #48 ; 0x30
107c92: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
107c96: 4620 mov r0, r4
107c98: f7fe fe08 bl 1068ac <_Timecounter_Nanotime>
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
107c9c: 4621 mov r1, r4
107c9e: a808 add r0, sp, #32
107ca0: f002 f9f2 bl 10a088 <_Timespec_Less_than>
107ca4: b928 cbnz r0, 107cb2 <timer_settime+0x14a>
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
107ca6: aa08 add r2, sp, #32
107ca8: 4620 mov r0, r4
107caa: 4611 mov r1, r2
107cac: f002 fa06 bl 10a0bc <_Timespec_Subtract>
107cb0: e784 b.n 107bbc <timer_settime+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
107cb2: f008 f889 bl 10fdc8 <__errno>
107cb6: 2316 movs r3, #22
107cb8: f04f 36ff mov.w r6, #4294967295 ; 0xffffffff
107cbc: 6003 str r3, [r0, #0]
107cbe: e7e6 b.n 107c8e <timer_settime+0x126>
rtems_set_errno_and_return_minus_one( EINVAL );
107cc0: f008 f882 bl 10fdc8 <__errno>
107cc4: 2316 movs r3, #22
107cc6: f04f 36ff mov.w r6, #4294967295 ; 0xffffffff
107cca: 6003 str r3, [r0, #0]
107ccc: e7df b.n 107c8e <timer_settime+0x126>
107cce: bf00 nop
107cd0: 00201cb0 .word 0x00201cb0
00107f90 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
107f90: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uint32_t us_per_tick = rtems_configuration_get_microseconds_per_tick();
107f94: f641 55ec movw r5, #7660 ; 0x1dec
107f98: f2c0 0511 movt r5, #17
{
107f9c: b083 sub sp, #12
uint32_t us_per_tick = rtems_configuration_get_microseconds_per_tick();
107f9e: 682f ldr r7, [r5, #0]
{
107fa0: 9101 str r1, [sp, #4]
107fa2: f107 38ff add.w r8, r7, #4294967295 ; 0xffffffff
return ( us + us_per_tick - 1 ) / us_per_tick;
107fa6: eb00 0608 add.w r6, r0, r8
__asm__ volatile (
107faa: f3ef 8a00 mrs sl, CPSR
107fae: f04a 0380 orr.w r3, sl, #128 ; 0x80
107fb2: f383 8900 msr CPSR_fc, r3
&lock_context
);
cpu = _Watchdog_Get_CPU( the_watchdog );
_Watchdog_Per_CPU_acquire_critical( cpu, &lock_context2 );
now = cpu->Watchdog.ticks;
107fb6: f642 2180 movw r1, #10880 ; 0x2a80
expire = the_watchdog->expire;
107fba: f240 2370 movw r3, #624 ; 0x270
107fbe: f2c0 0120 movt r1, #32
107fc2: f2c0 0320 movt r3, #32
107fc6: e9d3 4306 ldrd r4, r3, [r3, #24]
107fca: e9d1 b90a ldrd fp, r9, [r1, #40] ; 0x28
if ( now < expire ) {
107fce: 45a3 cmp fp, r4
107fd0: eb79 0303 sbcs.w r3, r9, r3
107fd4: bf28 it cs
107fd6: 2400 movcs r4, #0
107fd8: d201 bcs.n 107fde <ualarm+0x4e>
remaining = (useconds_t) _Watchdog_Cancel(
107fda: ebb4 040b subs.w r4, r4, fp
_Watchdog_Remove( header, the_watchdog );
107fde: f240 2170 movw r1, #624 ; 0x270
107fe2: 4815 ldr r0, [pc, #84] ; (108038 <ualarm+0xa8>)
107fe4: f2c0 0120 movt r1, #32
107fe8: f002 fe76 bl 10acd8 <_Watchdog_Remove>
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ],
the_watchdog,
now
);
if ( ticks_initial != 0 ) {
107fec: 42b7 cmp r7, r6
107fee: d907 bls.n 108000 <ualarm+0x70>
__asm__ volatile (
107ff0: f38a 8900 msr CPSR_fc, sl
_ISR_lock_Release_and_ISR_enable(
&_POSIX_signals_Ualarm_lock,
&lock_context
);
remaining *= rtems_configuration_get_microseconds_per_tick();
107ff4: 6828 ldr r0, [r5, #0]
return remaining;
}
107ff6: fb04 f000 mul.w r0, r4, r0
107ffa: b003 add sp, #12
107ffc: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return ( us + us_per_tick - 1 ) / us_per_tick;
108000: 9b01 ldr r3, [sp, #4]
108002: 4639 mov r1, r7
108004: 4443 add r3, r8
108006: 4618 mov r0, r3
108008: f004 fd8e bl 10cb28 <__udivsi3>
_POSIX_signals_Ualarm_interval = ticks_interval;
10800c: f642 23d8 movw r3, #10968 ; 0x2ad8
return ( us + us_per_tick - 1 ) / us_per_tick;
108010: 4602 mov r2, r0
_POSIX_signals_Ualarm_interval = ticks_interval;
108012: f2c0 0320 movt r3, #32
return ( us + us_per_tick - 1 ) / us_per_tick;
108016: 4639 mov r1, r7
_POSIX_signals_Ualarm_interval = ticks_interval;
108018: 601a str r2, [r3, #0]
return ( us + us_per_tick - 1 ) / us_per_tick;
10801a: 4630 mov r0, r6
10801c: f004 fd84 bl 10cb28 <__udivsi3>
_Watchdog_Insert(
108020: f240 2170 movw r1, #624 ; 0x270
108024: eb10 020b adds.w r2, r0, fp
108028: f149 0300 adc.w r3, r9, #0
10802c: 4802 ldr r0, [pc, #8] ; (108038 <ualarm+0xa8>)
10802e: f2c0 0120 movt r1, #32
108032: f7ff fced bl 107a10 <_Watchdog_Insert>
108036: e7db b.n 107ff0 <ualarm+0x60>
108038: 00202ab0 .word 0x00202ab0
00104678 <wait.part.0>:
static void wait(void)
104678: b508 push {r3, lr}
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
10467a: f642 6108 movw r1, #11784 ; 0x2e08
10467e: f642 53f0 movw r3, #11760 ; 0x2df0
104682: f642 6038 movw r0, #11832 ; 0x2e38
104686: f2c0 0311 movt r3, #17
10468a: 225c movs r2, #92 ; 0x5c
10468c: f2c0 0111 movt r1, #17
104690: f2c0 0011 movt r0, #17
104694: f000 fdd6 bl 105244 <__wrap_printf> <== NOT EXECUTED
104698: 2000 movs r0, #0 <== NOT EXECUTED
10469a: f000 fdcd bl 105238 <rtems_test_exit> <== NOT EXECUTED
10469e: bf00 nop <== NOT EXECUTED