=============================================================================== 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 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 <== 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 <== 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 <== 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 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 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 <== 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 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 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 <== 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 } /* 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 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 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 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 : #include #include #include 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 if (fcntl (fildes, F_GETFD) < 0) { 1096a0: 2101 movs r1, #1 1096a2: 4630 mov r0, r6 1096a4: f000 fc1e bl 109ee4 1096a8: 2800 cmp r0, #0 1096aa: f2c0 8088 blt.w 1097be 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 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 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 if (r_chain == NULL) { 1096c4: 4606 mov r6, r0 1096c6: b9b8 cbnz r0, 1096f8 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 <== 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 if (r_chain == NULL) { 1096e0: 2800 cmp r0, #0 1096e2: d062 beq.n 1097aa 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 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 (&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 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 10970c: 4604 mov r4, r0 pthread_mutex_unlock (&r_chain->mutex); 10970e: 4638 mov r0, r7 109710: f001 fbb4 bl 10ae7c pthread_mutex_unlock (&aio_request_queue.mutex); 109714: 4628 mov r0, r5 109716: f001 fbb1 bl 10ae7c } 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 return AIO_ALLDONE; 10972c: e7e2 b.n 1096f4 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 if (r_chain == NULL) { 10973a: 4607 mov r7, r0 10973c: bb18 cbnz r0, 109786 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 <== 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 if (r_chain == NULL) { 109756: 4604 mov r4, r0 109758: 2800 cmp r0, #0 10975a: d0e0 beq.n 10971e rtems_chain_extract (&r_chain->next_fd); 10975c: f002 f820 bl 10b7a0 rtems_aio_remove_fd (r_chain); 109760: 4620 mov r0, r4 109762: f000 fa15 bl 109b90 pthread_mutex_destroy (&r_chain->mutex); 109766: f104 0020 add.w r0, r4, #32 10976a: f001 fa0b bl 10ab84 pthread_cond_destroy (&r_chain->cond); 10976e: f104 0060 add.w r0, r4, #96 ; 0x60 109772: f001 f8af bl 10a8d4 free (r_chain); 109776: 4620 mov r0, r4 return AIO_CANCELED; 109778: 463c mov r4, r7 free (r_chain); 10977a: f7fb faaf bl 104cdc pthread_mutex_unlock (&aio_request_queue.mutex); 10977e: 4628 mov r0, r5 109780: f001 fb7c bl 10ae7c return AIO_CANCELED; 109784: e7b6 b.n 1096f4 pthread_mutex_lock (&r_chain->mutex); 109786: f100 0620 add.w r6, r0, #32 10978a: 4630 mov r0, r6 10978c: f001 fa7e bl 10ac8c rtems_chain_extract (&r_chain->next_fd); 109790: 4638 mov r0, r7 109792: f002 f805 bl 10b7a0 rtems_aio_remove_fd (r_chain); 109796: 4638 mov r0, r7 109798: f000 f9fa bl 109b90 pthread_mutex_unlock (&r_chain->mutex); 10979c: 4630 mov r0, r6 10979e: f001 fb6d bl 10ae7c pthread_mutex_unlock (&aio_request_queue.mutex); 1097a2: 4628 mov r0, r5 1097a4: f001 fb6a bl 10ae7c return AIO_CANCELED; 1097a8: e7a4 b.n 1096f4 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 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 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 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 1097d2: bf00 nop =============================================================================== 001097d8 : ) { 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 mode = fcntl (aiocbp->aio_fildes, F_GETFL); 1097e6: 6808 ldr r0, [r1, #0] 1097e8: 2103 movs r1, #3 1097ea: f000 fb7b bl 109ee4 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 req = malloc (sizeof (rtems_aio_request)); 1097fc: 2018 movs r0, #24 1097fe: f7fb fb67 bl 104ed0 if (req == NULL) 109802: b130 cbz r0, 109812 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_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 : * 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 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 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 109d88: 69a3 ldr r3, [r4, #24] 109d8a: b96b cbnz r3, 109da8 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 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 if (req == NULL) 109d98: b188 cbz r0, 109dbe 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_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 <== NOT EXECUTED 109dc2: bf00 nop =============================================================================== 00109dc8 : * 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 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 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 109de2: 69a3 ldr r3, [r4, #24] 109de4: b96b cbnz r3, 109e02 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 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 if (req == NULL) 109df2: b188 cbz r0, 109e18 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_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 <== NOT EXECUTED =============================================================================== 0010aaa0 : ); 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 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 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 ) 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 __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 ) 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 10ab1a: bf00 nop 10ab1c: 00202ab0 .word 0x00202ab0 =============================================================================== 0010e1ac : 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 <== 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 end = rqtp; if ( clock_id == CLOCK_REALTIME ) { 10e1d0: 2801 cmp r0, #1 10e1d2: d073 beq.n 10e2bc <== 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 if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) { 10e232: 2900 cmp r1, #0 10e234: d137 bne.n 10e2a6 _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 eno = 0; 10e242: 2400 movs r4, #0 10e244: e031 b.n 10e2aa _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 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 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 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 ++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 if ( eno == EINTR ) { 10e2a6: 2c04 cmp r4, #4 10e2a8: d011 beq.n 10e2ce _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 return NULL; 10e2ca: 4625 mov r5, r4 10e2cc: e782 b.n 10e1d4 _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 _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 <== 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 10e2f6: bf00 nop =============================================================================== 0010ef38 : 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 <== 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 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 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 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 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 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 <== NOT EXECUTED 10efbe: bf00 nop =============================================================================== 00106f84 : 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 <== 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 <== 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 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 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 <== 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 if ( map_private ) { errno = EINVAL; return MAP_FAILED; } } else if ( !map_private ) { 106fda: 2a00 cmp r2, #0 106fdc: d061 beq.n 1070a2 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 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 errno = EINVAL; return MAP_FAILED; } if ( addr == NULL ) { 106ff2: 2f00 cmp r7, #0 106ff4: d055 beq.n 1070a2 errno = EINVAL; return MAP_FAILED; } if (addr + len < addr) { 106ff6: 2e00 cmp r6, #0 106ff8: db53 blt.n 1070a2 <== 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 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 if ( !mapping ) { 107008: 4682 mov sl, r0 10700a: 2800 cmp r0, #0 10700c: f000 80e6 beq.w 1071dc <== 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 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 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 * 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 ( 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 <== 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 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 <== ALWAYS TAKEN if ( !map_anonymous ) { 107058: 9b03 ldr r3, [sp, #12] 10705a: 2b00 cmp r3, #0 10705c: f000 8135 beq.w 1072ca } 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 107068: 49b1 ldr r1, [pc, #708] ; (107330 ) 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_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 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 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 if ( map_fixed ) { 1070ba: 9b02 ldr r3, [sp, #8] 1070bc: 2b00 cmp r3, #0 1070be: f040 8095 bne.w 1071ec <== 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 1070cc: 2800 cmp r0, #0 1070ce: f2c0 80f4 blt.w 1072ba <== 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 <== ALWAYS TAKEN if ( S_ISREG( sb.st_mode ) 107100: f5b3 4f00 cmp.w r3, #32768 ; 0x8000 107104: d078 beq.n 1071f8 <== 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 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 <== 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 <== 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 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 <== 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 <== NEVER TAKEN if ( map_fixed && is_shared_shm ) { 107174: 2c00 cmp r4, #0 <== NOT EXECUTED 107176: f000 80d8 beq.w 10732a <== NOT EXECUTED free( mapping ); 10717a: f002 fde3 bl 109d44 <== 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 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 if ( map_fixed ) { 1071aa: 9b02 ldr r3, [sp, #8] 1071ac: 2b00 cmp r3, #0 1071ae: f47f af1a bne.w 106fe6 <== ALWAYS TAKEN mapping = malloc( sizeof( mmap_mapping )); 1071b2: 2101 movs r1, #1 1071b4: 2018 movs r0, #24 1071b6: f002 fda1 bl 109cfc if ( !mapping ) { 1071ba: 4682 mov sl, r0 1071bc: b170 cbz r0, 1071dc 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 1071d0: 2800 cmp r0, #0 1071d2: f000 808b beq.w 1072ec <== NEVER TAKEN free( mapping ); 1071d6: 4650 mov r0, sl <== NOT EXECUTED 1071d8: f002 fdb4 bl 109d44 <== 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 <== 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 <== NOT EXECUTED 1071f2: 2301 movs r3, #1 1071f4: 9304 str r3, [sp, #16] 1071f6: e700 b.n 106ffa && (( 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 <== 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 <== 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 <== 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 <== 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 107246: e72c b.n 1070a2 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 rtems_libio_lock(); 107250: f7fd ff1a bl 105088 } else if ( map_shared ) { 107254: f1bb 0f00 cmp.w fp, #0 107258: f43f af06 beq.w 107068 <== ALWAYS TAKEN if ( is_shared_shm ) { 10725c: b11c cbz r4, 107266 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 rtems_libio_unlock(); 107280: f7fd ff08 bl 105094 free( mapping ); 107284: 4650 mov r0, sl 107286: f002 fd5d bl 109d44 return MAP_FAILED; 10728a: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff 10728e: e70f b.n 1070b0 free( mapping ); 107290: 4650 mov r0, sl <== NOT EXECUTED 107292: f002 fd57 bl 109d44 <== NOT EXECUTED 107296: f7fd fefd bl 105094 <== 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 <== 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 <== 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 <== 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 if ( r != len ) { 1072d6: 42b0 cmp r0, r6 1072d8: f43f aec6 beq.w 107068 <== NEVER TAKEN 1072dc: f7fd feda bl 105094 <== NOT EXECUTED if ( !map_fixed ) { 1072e0: 9b02 ldr r3, [sp, #8] <== NOT EXECUTED 1072e2: b1ab cbz r3, 107310 <== NOT EXECUTED free( mapping ); 1072e4: 4650 mov r0, sl <== NOT EXECUTED 1072e6: f002 fd2d bl 109d44 <== NOT EXECUTED 1072ea: e7d6 b.n 10729a <== NOT EXECUTED rtems_libio_lock(); 1072ec: f7fd fecc bl 105088 if ( map_private ) { 1072f0: e6b2 b.n 107058 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 <== 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 10730e: e6ab b.n 107068 free( mapping->addr ); 107310: f8da 0008 ldr.w r0, [sl, #8] <== NOT EXECUTED 107314: f002 fd16 bl 109d44 <== NOT EXECUTED 107318: e7e4 b.n 1072e4 <== NOT EXECUTED } else if ( map_shared ) { 10731a: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED 10731e: d1a2 bne.n 107266 <== NOT EXECUTED 107320: e6a4 b.n 10706c <== NOT EXECUTED if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) { 107322: 2b00 cmp r3, #0 107324: f43f ae5b beq.w 106fde <== NEVER TAKEN 107328: e6bb b.n 1070a2 <== NOT EXECUTED mapping->addr = addr; 10732a: f8ca 7008 str.w r7, [sl, #8] <== NOT EXECUTED 10732e: e679 b.n 107024 <== NOT EXECUTED 107330: 00200208 .word 0x00200208 <== NOT EXECUTED =============================================================================== 00107334 : #include #include 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 <== ALWAYS TAKEN errno = EINVAL; return -1; } /* Check for illegal addresses. Watch out for address wrap. */ if (addr + len < addr) { 107348: db49 blt.n 1073de <== ALWAYS TAKEN 10734a: f7fd fe9d bl 105088 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 <== 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 ( 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 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 <== NEVER TAKEN rtems_libio_unlock(); 107372: f7fd fe8f bl 105094 } 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 * * @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 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 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 free( mapping ); 1073c4: 4620 mov r0, r4 1073c6: f002 fcbd bl 109d44 break; 1073ca: e7d2 b.n 107372 free( mapping->addr ); 1073cc: 68a0 ldr r0, [r4, #8] 1073ce: f002 fcb9 bl 109d44 1073d2: e7f7 b.n 1073c4 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 <== 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 <== NOT EXECUTED 1073ee: bf00 nop =============================================================================== 00106998 : 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 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 <== ALWAYS TAKEN 1069ac: f8dc 3054 ldr.w r3, [ip, #84] ; 0x54 1069b0: 428b cmp r3, r1 1069b2: d104 bne.n 1069be <== 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_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 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 <== ALWAYS TAKEN 106b54: f8dc 3054 ldr.w r3, [ip, #84] ; 0x54 106b58: 428b cmp r3, r1 106b5a: d104 bne.n 106b66 <== 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 : 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 107b6c: 6802 ldr r2, [r0, #0] 107b6e: b152 cbz r2, 107b86 return EINVAL; switch ( policy ) { 107b70: 2902 cmp r1, #2 107b72: dd04 ble.n 107b7e 107b74: 2904 cmp r1, #4 107b76: d104 bne.n 107b82 <== 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 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 : /* * 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 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 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 <== 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 <== NOT EXECUTED return ESRCH; 107074: 2003 movs r0, #3 107076: e7f4 b.n 107062 =============================================================================== 00107ce4 : { 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 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 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 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 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 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 <== NEVER TAKEN 107d5e: 2b02 cmp r3, #2 107d60: f040 80b3 bne.w 107eca 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 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 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 <== 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 if ( the_attr->affinityset == NULL ) { 107de6: 6da3 ldr r3, [r4, #88] ; 0x58 107de8: 2b00 cmp r3, #0 107dea: d06e beq.n 107eca <== 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 if ( config.stack_area == NULL ) { 107e0c: 9b07 ldr r3, [sp, #28] 107e0e: 2b00 cmp r3, #0 107e10: d07e beq.n 107f10 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 <== 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 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 <== 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 __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 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 error = pthread_getschedparam( 107ef6: af12 add r7, sp, #72 ; 0x48 107ef8: f000 f9b8 bl 10826c 107efc: 463a mov r2, r7 107efe: a901 add r1, sp, #4 107f00: f000 f90e bl 108120 break; 107f04: e73e b.n 107d84 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 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 ( *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 <== 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 107f62: bf00 nop =============================================================================== 00107ff4 : * 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 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 _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 <== 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 : 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 { 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 __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 __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 <== 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 POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 10917e: 2016 movs r0, #22 } 109180: 4770 bx lr 109182: bf00 nop =============================================================================== 001093d4 : 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 /* * 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 if ( error != 0 ) { 1093e4: 4604 mov r4, r0 1093e6: b960 cbnz r0, 109402 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 error = 0; } unlock_error = pthread_mutex_unlock( mutex ); 1093f6: 4630 mov r0, r6 1093f8: f000 f886 bl 109508 _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 error = EINVAL; 109436: 2416 movs r4, #22 109438: e7dd b.n 1093f6 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 __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 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 <== NOT EXECUTED 10948a: bf00 nop =============================================================================== 00109508 : 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 { 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 __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 109548: 2d02 cmp r5, #2 10954a: d014 beq.n 109576 if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) { 10954c: 6923 ldr r3, [r4, #16] 10954e: 429a cmp r2, r3 109550: d122 bne.n 109598 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 <== 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 _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 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 <== 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 <== 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 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 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 <== 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 _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 _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 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 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 <== 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 <== 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 POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 10964c: 2016 movs r0, #22 } 10964e: 4770 bx lr =============================================================================== 001090b4 : 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 1090b8: 6802 ldr r2, [r0, #0] 1090ba: b122 cbz r2, 1090c6 return EINVAL; switch ( pshared ) { 1090bc: 2901 cmp r1, #1 1090be: d802 bhi.n 1090c6 <== 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 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 108a0c: 4603 mov r3, r0 108a0e: b130 cbz r0, 108a1e return EINVAL; if ( !attr->is_initialized ) 108a10: 6802 ldr r2, [r0, #0] 108a12: b122 cbz r2, 108a1e return EINVAL; switch ( pshared ) { 108a14: 2901 cmp r1, #1 108a16: d802 bhi.n 108a1e <== 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 : 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 return EPROTO; } if ( state == PTHREAD_CANCEL_DISABLE ) { 10783c: 2c01 cmp r4, #1 10783e: d001 beq.n 107844 <== 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 } 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 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 : 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 } 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 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 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 <== 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 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 ) _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 _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 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 return ESRCH; 109dcc: 2503 movs r5, #3 109dce: e765 b.n 109c9c _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 _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 109e0a: bf00 nop 109e0c: 00202af0 .word 0x00202af0 =============================================================================== 001080c4 : 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 __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 1080ea: e04c b.n 108186 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 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 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 __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 __asm__ volatile ( 108136: f387 8900 msr CPSR_fc, r7 eno = 0; 10813a: 2400 movs r4, #0 } 10813c: e01c b.n 108178 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 <== 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 <== 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 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 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 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 1081dc: e016 b.n 10820c 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 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 eno = ENOMEM; 108208: 240c movs r4, #12 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10820a: e7b5 b.n 108178 <== NOT EXECUTED link = _RBTree_Root_reference( the_rbtree ); 10820c: 4605 mov r5, r0 10820e: e7ef b.n 1081f0 =============================================================================== 001078b0 : /* * 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 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 : { 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 if (result != 0) { 109c18: 4607 mov r7, r0 109c1a: 2800 cmp r0, #0 109c1c: d142 bne.n 109ca4 <== ALWAYS TAKEN pthread_getschedparam (pthread_self(), &policy, ¶m); 109c1e: f001 fca1 bl 10b564 109c22: aa02 add r2, sp, #8 109c24: a901 add r1, sp, #4 109c26: f001 fc4f bl 10b4c8 req->caller_thread = pthread_self (); 109c2a: f001 fc9b bl 10b564 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 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 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 109c5e: 4a42 ldr r2, [pc, #264] ; (109d68 ) 109c60: e003 b.n 109c6a 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 109c6a: 4294 cmp r4, r2 109c6c: d1f9 bne.n 109c62 <== NEVER TAKEN r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 109c6e: 483f ldr r0, [pc, #252] ; (109d6c ) 109c70: 2201 movs r2, #1 109c72: f7ff ff2b bl 109acc 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_insert_prio (&r_chain->perfd, req); 109c82: f7ff fdd1 bl 109828 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 <== 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 } 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 <== NOT EXECUTED free (req); 109ca4: 4628 mov r0, r5 <== NOT EXECUTED 109ca6: f7fb f819 bl 104cdc <== 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 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 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 pthread_cond_signal (&r_chain->cond); 109ccc: f104 0060 add.w r0, r4, #96 ; 0x60 109cd0: f000 fe54 bl 10a97c pthread_mutex_unlock (&r_chain->mutex); 109cd4: 4630 mov r0, r6 109cd6: f001 f8d1 bl 10ae7c 109cda: e7d8 b.n 109c8e pthread_cond_signal (&aio_request_queue.new_req); 109cdc: 4824 ldr r0, [pc, #144] ; (109d70 ) <== NOT EXECUTED 109cde: f000 fe4d bl 10a97c <== NOT EXECUTED 109ce2: e7d4 b.n 109c8e <== 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 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_chain_prepend (&r_chain->perfd, &req->next_prio); 109cfc: 4629 mov r1, r5 109cfe: 3008 adds r0, #8 109d00: f001 fd6a bl 10b7d8 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_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 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 if (result != 0) { 109d2e: 4603 mov r3, r0 109d30: b9a0 cbnz r0, 109d5c ++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 r_chain->new_fd = 0; 109d3e: 2500 movs r5, #0 rtems_chain_prepend (&r_chain->perfd, &req->next_prio); 109d40: f001 fd4a bl 10b7d8 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_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 109d5a: e794 b.n 109c86 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 <== NOT EXECUTED return result; 109d64: e799 b.n 109c9a <== 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 : { 109a34: b538 push {r3, r4, r5, lr} result = pthread_attr_init (&aio_request_queue.attr); 109a36: 4822 ldr r0, [pc, #136] ; (109ac0 ) 109a38: f001 faf2 bl 10b020 if (result != 0) 109a3c: 4604 mov r4, r0 109a3e: b108 cbz r0, 109a44 } 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 ) 109a46: 4621 mov r1, r4 109a48: f001 fafc bl 10b044 if (result != 0) 109a4c: bb20 cbnz r0, 109a98 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 if (result != 0) 109a5e: bb48 cbnz r0, 109ab4 result = pthread_cond_init (&aio_request_queue.new_req, NULL); 109a60: 4818 ldr r0, [pc, #96] ; (109ac4 ) 109a62: 2100 movs r1, #0 109a64: f000 ff5e bl 10a924 if (result != 0) { 109a68: 4604 mov r4, r0 109a6a: b9c8 cbnz r0, 109aa0 head->next = tail; 109a6c: 4b16 ldr r3, [pc, #88] ; (109ac8 ) 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 ) <== NOT EXECUTED 109a9a: f001 fab7 bl 10b00c <== NOT EXECUTED 109a9e: e7d6 b.n 109a4e <== 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 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 109aac: 4804 ldr r0, [pc, #16] ; (109ac0 ) <== NOT EXECUTED 109aae: f001 faad bl 10b00c <== NOT EXECUTED 109ab2: e7db b.n 109a6c <== 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 <== NOT EXECUTED 109abc: e7d0 b.n 109a60 <== 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 : { 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 <== 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 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 while (!rtems_chain_is_tail (chain, node)) 109bbc: 42b4 cmp r4, r6 109bbe: d1f2 bne.n 109ba6 } 109bc0: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} =============================================================================== 00109bc4 : { 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 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 <== 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 <== 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 <== ALWAYS TAKEN rtems_chain_extract (node); 109be2: 4620 mov r0, r4 109be4: f001 fddc bl 10b7a0 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 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 : 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 106cf6: 2804 cmp r0, #4 106cf8: d108 bne.n 106d0c <== 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 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 : */ int sched_get_priority_min( int policy ) { switch ( policy ) { 106d1c: 2802 cmp r0, #2 106d1e: dc0a bgt.n 106d36 <== ALWAYS TAKEN 106d20: 2800 cmp r0, #0 106d22: da0a bge.n 106d3a { 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 <== NOT EXECUTED 106d3a: 2001 movs r0, #1 } 106d3c: 4770 bx lr 106d3e: bf00 nop =============================================================================== 0010a2e4 : #endif #include 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 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 if ( !_POSIX_Semaphore_Is_named( sem ) ) { 10a2fa: 6943 ldr r3, [r0, #20] 10a2fc: b1f3 cbz r3, 10a33c 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 _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 10a30e: 68e2 ldr r2, [r4, #12] 10a310: b942 cbnz r2, 10a324 _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 : { 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 _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 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 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 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 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 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 <== 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 <== 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 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 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 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 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 <== 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 <== NOT EXECUTED 107b32: bf00 nop =============================================================================== 001085ac : 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 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 __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->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 <== 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 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 =============================================================================== 001075c4 : { 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 <== 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 <== 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 <== ALWAYS TAKEN iop = rtems_libio_allocate(); 1075f8: 4680 mov r8, r0 1075fa: f7fd fcd9 bl 104fb0 if ( iop == NULL ) { 1075fe: 4604 mov r4, r0 107600: 2800 cmp r0, #0 107602: f000 80e8 beq.w 1077d6 <== 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 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 <== 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 <== 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 <== NOT EXECUTED } else if ( !shm_access_ok( shm, oflag ) ) { 10765a: 2800 cmp r0, #0 <== NOT EXECUTED 10765c: f040 8099 bne.w 107792 <== 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 <== NOT EXECUTED switch ( obj_err ) { 107668: 9b01 ldr r3, [sp, #4] 10766a: 2b00 cmp r3, #0 10766c: f000 80a3 beq.w 1077b6 <== ALWAYS TAKEN 107670: 2b01 cmp r3, #1 107672: f000 809c beq.w 1077ae <== 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 <== ALWAYS TAKEN if ( ( oflag & O_CREAT ) != O_CREAT ) { 107680: 05ab lsls r3, r5, #22 107682: f140 809c bpl.w 1077be <== 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 <== 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 <== ALWAYS TAKEN gettimeofday( &tv, 0 ); 1076ae: 2100 movs r1, #0 1076b0: a802 add r0, sp, #8 1076b2: f002 fc0f bl 109ed4 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 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 1076dc: 85b8 strh r0, [r7, #44] ; 0x2c shm->gid = getegid(); 1076de: f002 fbed bl 109ebc 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 <== 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 <== 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 <== NOT EXECUTED 1077ac: e7b1 b.n 107712 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED =============================================================================== 00108e9c : #include #include 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 _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 ( *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 <== NOT EXECUTED 108f02: bf00 nop =============================================================================== 0010a138 : 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 /* 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 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 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 <== 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 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 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 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 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 <== 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 <== 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 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 10a27a: ad03 add r5, sp, #12 10a27c: e77c b.n 10a178 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 <== ALWAYS TAKEN for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10a28c: 3401 adds r4, #1 10a28e: 2c20 cmp r4, #32 10a290: d1f7 bne.n 10a282 for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10a292: 2401 movs r4, #1 10a294: 4621 mov r1, r4 10a296: e002 b.n 10a29e 10a298: 3401 adds r4, #1 10a29a: 2c1b cmp r4, #27 10a29c: d004 beq.n 10a2a8 <== 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 _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 <== ALWAYS TAKEN for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10a2de: 3101 adds r1, #1 10a2e0: 2920 cmp r1, #32 10a2e2: d1f7 bne.n 10a2d4 for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10a2e4: 2101 movs r1, #1 10a2e6: 4608 mov r0, r1 10a2e8: e002 b.n 10a2f0 10a2ea: 3101 adds r1, #1 10a2ec: 291b cmp r1, #27 10a2ee: d004 beq.n 10a2fa <== 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 _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 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 10a342: bf00 nop =============================================================================== 0010b468 : 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 if ( status != -1 ) { 10b474: 1c43 adds r3, r0, #1 10b476: d006 beq.n 10b486 if ( sig ) 10b478: b11c cbz r4, 10b482 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 : long sysconf( int name ) { switch ( name ) { 1064dc: 280a cmp r0, #10 { 1064de: b508 push {r3, lr} switch ( name ) { 1064e0: dc0b bgt.n 1064fa 1064e2: 2801 cmp r0, #1 1064e4: dd1a ble.n 10651c 1064e6: 3802 subs r0, #2 1064e8: 2808 cmp r0, #8 1064ea: d817 bhi.n 10651c <== 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 <== 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 <== 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 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 : 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 if ( !timerid ) 10b73a: 4615 mov r5, r2 10b73c: 2a00 cmp r2, #0 10b73e: d063 beq.n 10b808 if (evp != NULL) { 10b740: 460c mov r4, r1 10b742: 2900 cmp r1, #0 10b744: d044 beq.n 10b7d0 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 <== ALWAYS TAKEN if ( !evp->sigev_signo ) 10b74e: 684b ldr r3, [r1, #4] 10b750: 2b00 cmp r3, #0 10b752: d059 beq.n 10b808 <== 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 <== 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 <== 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 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 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 : 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 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 ) 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 107af4: 00201cb0 .word 0x00201cb0 =============================================================================== 00107b68 : 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 <== 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 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 <== 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 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 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 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 ) 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 107be6: 9b0a ldr r3, [sp, #40] ; 0x28 107be8: b9e3 cbnz r3, 107c24 /* 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 *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 *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 _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 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 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 107cce: bf00 nop 107cd0: 00201cb0 .word 0x00201cb0 =============================================================================== 00107f90 : 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 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 ) 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 __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 ) 10802e: f2c0 0120 movt r1, #32 108032: f7ff fced bl 107a10 <_Watchdog_Insert> 108036: e7db b.n 107ff0 108038: 00202ab0 .word 0x00202ab0 =============================================================================== 00104678 : 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 <== NOT EXECUTED 10469e: bf00 nop <== NOT EXECUTED