RTEMS-6
Annotated Report
rtems
Sun Feb 28 23:00:05 2021
0010dee0 <_Signal_Action_handler>:
void _Signal_Action_handler(
Thread_Control *executing,
Thread_Action *action,
ISR_lock_Context *lock_context
)
{
10dee0: 55 push %ebp
10dee1: 89 e5 mov %esp,%ebp
10dee3: 83 ec 38 sub $0x38,%esp
10dee6: 89 5d f4 mov %ebx,-0xc(%ebp)
/*
* Signal Processing
*/
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10dee9: 8b 45 08 mov 0x8(%ebp),%eax
{
10deec: 89 75 f8 mov %esi,-0x8(%ebp)
10deef: 89 7d fc mov %edi,-0x4(%ebp)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10def2: 8b 98 08 01 00 00 mov 0x108(%eax),%ebx
ASR_Information *asr
)
{
rtems_signal_set signal_set;
signal_set = asr->signals_posted;
10def8: 8b 73 14 mov 0x14(%ebx),%esi
asr->signals_posted = 0;
10defb: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
_ISR_lock_ISR_enable( lock_context );
10df02: 8b 45 10 mov 0x10(%ebp),%eax
10df05: ff 30 push (%eax)
10df07: 9d popf
asr = &api->Signal;
signal_set = _ASR_Get_posted_signals( asr );
_Thread_State_release( executing, lock_context );
if ( signal_set == 0 ) {
10df08: 85 f6 test %esi,%esi
10df0a: 74 3f je 10df4b <_Signal_Action_handler+0x6b> <== NEVER TAKEN
return;
}
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10df0c: 8d 7d e4 lea -0x1c(%ebp),%edi
10df0f: b8 ff ff 00 00 mov $0xffff,%eax
asr->nest_level += 1;
10df14: ff 43 1c incl 0x1c(%ebx)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10df17: 89 7c 24 08 mov %edi,0x8(%esp)
10df1b: 89 44 24 04 mov %eax,0x4(%esp)
10df1f: 8b 43 10 mov 0x10(%ebx),%eax
10df22: 89 04 24 mov %eax,(%esp)
10df25: e8 c6 93 ff ff call 1072f0 <rtems_task_mode>
(*asr->handler)( signal_set );
10df2a: 89 34 24 mov %esi,(%esp)
10df2d: ff 53 0c call *0xc(%ebx)
asr->nest_level -= 1;
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10df30: 8b 45 e4 mov -0x1c(%ebp),%eax
10df33: ba ff ff 00 00 mov $0xffff,%edx
asr->nest_level -= 1;
10df38: ff 4b 1c decl 0x1c(%ebx)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10df3b: 89 7c 24 08 mov %edi,0x8(%esp)
10df3f: 89 54 24 04 mov %edx,0x4(%esp)
10df43: 89 04 24 mov %eax,(%esp)
10df46: e8 a5 93 ff ff call 1072f0 <rtems_task_mode>
}
10df4b: 8b 5d f4 mov -0xc(%ebp),%ebx
10df4e: 8b 75 f8 mov -0x8(%ebp),%esi
10df51: 8b 7d fc mov -0x4(%ebp),%edi
10df54: 89 ec mov %ebp,%esp
10df56: 5d pop %ebp
10df57: c3 ret
10df58: 90 nop
10df59: 90 nop
10df5a: 90 nop
10df5b: 90 nop
10df5c: 90 nop
10df5d: 90 nop
10df5e: 90 nop
10df5f: 90 nop
00104f20 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
104f20: 55 push %ebp
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
104f21: 31 d2 xor %edx,%edx
{
104f23: 89 e5 mov %esp,%ebp
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
104f25: b8 40 42 0f 00 mov $0xf4240,%eax
104f2a: f7 35 78 25 12 00 divl 0x122578
{
104f30: 8b 4d 08 mov 0x8(%ebp),%ecx
104f33: 53 push %ebx
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
104f34: 85 c9 test %ecx,%ecx
104f36: 74 58 je 104f90 <_TOD_Validate+0x70> <== NEVER TAKEN
104f38: 39 41 18 cmp %eax,0x18(%ecx)
104f3b: 73 53 jae 104f90 <_TOD_Validate+0x70>
(the_tod->ticks >= ticks_per_second) ||
104f3d: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
104f41: 77 4d ja 104f90 <_TOD_Validate+0x70>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
104f43: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
104f47: 77 47 ja 104f90 <_TOD_Validate+0x70>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
104f49: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
104f4d: 77 41 ja 104f90 <_TOD_Validate+0x70>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
104f4f: 8b 51 04 mov 0x4(%ecx),%edx
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
104f52: 31 c0 xor %eax,%eax
(the_tod->month == 0) ||
104f54: 8d 5a ff lea -0x1(%edx),%ebx
104f57: 83 fb 0b cmp $0xb,%ebx
104f5a: 77 36 ja 104f92 <_TOD_Validate+0x72>
(the_tod->year < TOD_BASE_YEAR) ||
104f5c: 8b 19 mov (%ecx),%ebx
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
104f5e: 81 fb c3 07 00 00 cmp $0x7c3,%ebx
104f64: 76 2c jbe 104f92 <_TOD_Validate+0x72>
(the_tod->day == 0) )
104f66: 8b 49 08 mov 0x8(%ecx),%ecx
(the_tod->year < TOD_BASE_YEAR) ||
104f69: 85 c9 test %ecx,%ecx
104f6b: 74 25 je 104f92 <_TOD_Validate+0x72> <== NEVER TAKEN
if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) ||
104f6d: f6 c3 03 test $0x3,%bl
104f70: 75 2e jne 104fa0 <_TOD_Validate+0x80>
104f72: 69 c3 29 5c 8f c2 imul $0xc28f5c29,%ebx,%eax
104f78: c1 c8 02 ror $0x2,%eax
104f7b: 3d 28 5c 8f 02 cmp $0x28f5c28,%eax
104f80: 76 1e jbe 104fa0 <_TOD_Validate+0x80>
(the_tod->year % 400 == 0))
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
104f82: 8b 04 95 f4 2d 12 00 mov 0x122df4(,%edx,4),%eax
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
if ( the_tod->day > days_in_month )
104f89: 39 c1 cmp %eax,%ecx
104f8b: 0f 96 c0 setbe %al
104f8e: eb 02 jmp 104f92 <_TOD_Validate+0x72>
return false;
104f90: 31 c0 xor %eax,%eax
return false;
return true;
}
104f92: 5b pop %ebx
104f93: 5d pop %ebp
104f94: c3 ret
104f95: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104f9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104fa0: 69 db 29 5c 8f c2 imul $0xc28f5c29,%ebx,%ebx
104fa6: c1 cb 04 ror $0x4,%ebx
if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) ||
104fa9: 81 fb 0a d7 a3 00 cmp $0xa3d70a,%ebx
104faf: 76 d1 jbe 104f82 <_TOD_Validate+0x62>
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
104fb1: 8b 04 95 c0 2d 12 00 mov 0x122dc0(,%edx,4),%eax
104fb8: eb cf jmp 104f89 <_TOD_Validate+0x69>
104fba: 90 nop
104fbb: 90 nop
104fbc: 90 nop
104fbd: 90 nop
104fbe: 90 nop
104fbf: 90 nop
00104b80 <rtems_clock_get_tod>:
}
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
104b80: 55 push %ebp
104b81: 89 e5 mov %esp,%ebp
104b83: 57 push %edi
104b84: 56 push %esi
104b85: 53 push %ebx
104b86: 83 ec 4c sub $0x4c,%esp
104b89: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t day_secs;
uint32_t year;
uint32_t year_days;
uint32_t leap_years;
if ( !time_buffer )
104b8c: 85 db test %ebx,%ebx
104b8e: 0f 84 5c 02 00 00 je 104df0 <rtems_clock_get_tod+0x270>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set() )
104b94: 80 3d f0 bc 12 00 00 cmpb $0x0,0x12bcf0
104b9b: 0f 84 ff 01 00 00 je 104da0 <rtems_clock_get_tod+0x220>
*/
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
104ba1: 8d 45 dc lea -0x24(%ebp),%eax
104ba4: 89 04 24 mov %eax,(%esp)
104ba7: e8 84 21 00 00 call 106d30 <_Timecounter_Microtime>
/* Obtain the current time */
_TOD_Get_timeval( &now );
/* How many days and how many seconds in the day ? */
days = now.tv_sec / RTEMS_SECS_PER_DAY;
104bac: 8b 75 dc mov -0x24(%ebp),%esi
104baf: 31 d2 xor %edx,%edx
104bb1: 89 54 24 0c mov %edx,0xc(%esp)
104bb5: 8b 7d e0 mov -0x20(%ebp),%edi
104bb8: b8 80 51 01 00 mov $0x15180,%eax
104bbd: 89 44 24 08 mov %eax,0x8(%esp)
104bc1: 89 34 24 mov %esi,(%esp)
104bc4: 89 7c 24 04 mov %edi,0x4(%esp)
104bc8: e8 f3 40 01 00 call 118cc0 <__divdi3>
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
104bcd: b9 80 51 01 00 mov $0x15180,%ecx
104bd2: 89 4c 24 08 mov %ecx,0x8(%esp)
104bd6: 89 34 24 mov %esi,(%esp)
104bd9: 89 7c 24 04 mov %edi,0x4(%esp)
days = now.tv_sec / RTEMS_SECS_PER_DAY;
104bdd: 89 45 d4 mov %eax,-0x2c(%ebp)
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
104be0: 31 c0 xor %eax,%eax
104be2: 89 44 24 0c mov %eax,0xc(%esp)
104be6: e8 45 42 01 00 call 118e30 <__moddi3>
/* How many non-leap year years ? */
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
104beb: 8b 7d d4 mov -0x2c(%ebp),%edi
104bee: 89 f9 mov %edi,%ecx
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
104bf0: 89 45 d0 mov %eax,-0x30(%ebp)
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
104bf3: b8 61 f3 19 67 mov $0x6719f361,%eax
104bf8: f7 e7 mul %edi
104bfa: 29 d1 sub %edx,%ecx
104bfc: d1 e9 shr %ecx
104bfe: 01 d1 add %edx,%ecx
return (year / 4) - (year / 100) + (year / 400);
104c00: ba 1f 85 eb 51 mov $0x51eb851f,%edx
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
104c05: c1 e9 08 shr $0x8,%ecx
year -= 1;
104c08: 8d b1 b1 07 00 00 lea 0x7b1(%ecx),%esi
return (year / 4) - (year / 100) + (year / 400);
104c0e: 89 f0 mov %esi,%eax
104c10: f7 e2 mul %edx
104c12: 89 d0 mov %edx,%eax
104c14: c1 e8 05 shr $0x5,%eax
104c17: 89 45 cc mov %eax,-0x34(%ebp)
104c1a: c1 ea 07 shr $0x7,%edx
104c1d: 89 f0 mov %esi,%eax
104c1f: c1 e8 02 shr $0x2,%eax
104c22: 8d 94 10 23 fe ff ff lea -0x1dd(%eax,%edx,1),%edx
/* Determine the number of leap years. */
leap_years = _Leap_years_between( RTEMS_YEAR_BASE, year );
/* Adjust the remaining number of days based on the leap years. */
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
104c29: 8b 45 cc mov -0x34(%ebp),%eax
104c2c: 89 55 c8 mov %edx,-0x38(%ebp)
104c2f: 01 f8 add %edi,%eax
104c31: 89 c7 mov %eax,%edi
104c33: b8 61 f3 19 67 mov $0x6719f361,%eax
104c38: 29 d7 sub %edx,%edi
104c3a: f7 e7 mul %edi
104c3c: 89 55 c4 mov %edx,-0x3c(%ebp)
104c3f: 89 fa mov %edi,%edx
104c41: 89 45 c0 mov %eax,-0x40(%ebp)
104c44: 8b 45 c4 mov -0x3c(%ebp),%eax
104c47: 29 c2 sub %eax,%edx
104c49: 89 d0 mov %edx,%eax
104c4b: 8b 55 c4 mov -0x3c(%ebp),%edx
104c4e: d1 e8 shr %eax
104c50: 01 c2 add %eax,%edx
104c52: c1 ea 08 shr $0x8,%edx
104c55: 8d 04 d2 lea (%edx,%edx,8),%eax
104c58: 8d 04 c2 lea (%edx,%eax,8),%eax
104c5b: 89 fa mov %edi,%edx
104c5d: 8d 04 80 lea (%eax,%eax,4),%eax
104c60: 29 c2 sub %eax,%edx
/* Adjust the year and days in the year if in the leap year overflow. */
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
104c62: 8d 04 c9 lea (%ecx,%ecx,8),%eax
104c65: 8d 04 c1 lea (%ecx,%eax,8),%eax
104c68: 8d 3c 80 lea (%eax,%eax,4),%edi
104c6b: 8b 45 d4 mov -0x2c(%ebp),%eax
104c6e: 29 f8 sub %edi,%eax
return _Leap_years_before( to ) - _Leap_years_before( from + 1 );
104c70: 8b 7d c8 mov -0x38(%ebp),%edi
104c73: 2b 7d cc sub -0x34(%ebp),%edi
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
104c76: 39 f8 cmp %edi,%eax
104c78: 0f 82 c2 00 00 00 jb 104d40 <rtems_clock_get_tod+0x1c0>
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
104c7e: 8d b1 b2 07 00 00 lea 0x7b2(%ecx),%esi
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104c84: 89 f0 mov %esi,%eax
104c86: 83 e0 03 and $0x3,%eax
if ( _Leap_year( year ) ) {
year_days += 1;
}
}
time_buffer->year = year;
104c89: 89 33 mov %esi,(%ebx)
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104c8b: 85 c0 test %eax,%eax
104c8d: 0f 85 dd 00 00 00 jne 104d70 <rtems_clock_get_tod+0x1f0>
104c93: 69 c6 29 5c 8f c2 imul $0xc28f5c29,%esi,%eax
days_to_date = _TOD_Days_to_date[1];
104c99: b9 9a 2d 12 00 mov $0x122d9a,%ecx
104c9e: c1 c8 02 ror $0x2,%eax
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104ca1: 3d 28 5c 8f 02 cmp $0x28f5c28,%eax
104ca6: 0f 86 c4 00 00 00 jbe 104d70 <rtems_clock_get_tod+0x1f0>
days_to_date += 2;
104cac: 83 c1 04 add $0x4,%ecx
uint32_t month = 0;
104caf: 31 c0 xor %eax,%eax
104cb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104cb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104cbf: 90 nop
if (*day < *days_to_date)
104cc0: 0f b7 31 movzwl (%ecx),%esi
++month;
104cc3: 40 inc %eax
if (*day < *days_to_date)
104cc4: 39 d6 cmp %edx,%esi
104cc6: 0f 87 e4 00 00 00 ja 104db0 <rtems_clock_get_tod+0x230>
++days_to_date;
104ccc: 83 c1 02 add $0x2,%ecx
while (month < 11) {
104ccf: 83 f8 0b cmp $0xb,%eax
104cd2: 75 ec jne 104cc0 <rtems_clock_get_tod+0x140>
104cd4: b8 0c 00 00 00 mov $0xc,%eax
time_buffer->month = _Year_day_as_month( year, &year_days ) + 1;
104cd9: 89 43 04 mov %eax,0x4(%ebx)
time_buffer->day = year_days + 1;
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
104cdc: 8b 45 d0 mov -0x30(%ebp),%eax
time_buffer->day = year_days + 1;
104cdf: 42 inc %edx
104ce0: 29 f2 sub %esi,%edx
104ce2: 89 53 08 mov %edx,0x8(%ebx)
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
104ce5: ba c5 b3 a2 91 mov $0x91a2b3c5,%edx
104cea: f7 e2 mul %edx
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
104cec: 8b 45 d0 mov -0x30(%ebp),%eax
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
104cef: c1 ea 0b shr $0xb,%edx
104cf2: 89 53 0c mov %edx,0xc(%ebx)
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
104cf5: 69 d2 10 0e 00 00 imul $0xe10,%edx,%edx
104cfb: 29 d0 sub %edx,%eax
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
104cfd: ba 89 88 88 88 mov $0x88888889,%edx
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
104d02: 89 c1 mov %eax,%ecx
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
104d04: f7 e2 mul %edx
time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE;
time_buffer->ticks = now.tv_usec /
104d06: 8b 45 e4 mov -0x1c(%ebp),%eax
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
104d09: c1 ea 05 shr $0x5,%edx
time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE;
104d0c: 89 53 10 mov %edx,0x10(%ebx)
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
104d0f: 89 d6 mov %edx,%esi
104d11: c1 e6 04 shl $0x4,%esi
104d14: 29 d6 sub %edx,%esi
time_buffer->ticks = now.tv_usec /
104d16: 31 d2 xor %edx,%edx
104d18: f7 35 78 25 12 00 divl 0x122578
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
104d1e: c1 e6 02 shl $0x2,%esi
104d21: 29 f1 sub %esi,%ecx
104d23: 89 4b 14 mov %ecx,0x14(%ebx)
time_buffer->ticks = now.tv_usec /
104d26: 89 43 18 mov %eax,0x18(%ebx)
rtems_configuration_get_microseconds_per_tick( );
return RTEMS_SUCCESSFUL;
}
104d29: 83 c4 4c add $0x4c,%esp
return RTEMS_SUCCESSFUL;
104d2c: 31 c0 xor %eax,%eax
}
104d2e: 5b pop %ebx
104d2f: 5e pop %esi
104d30: 5f pop %edi
104d31: 5d pop %ebp
104d32: c3 ret
104d33: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104d3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104d40: 69 ce 29 5c 8f c2 imul $0xc28f5c29,%esi,%ecx
104d46: 89 f0 mov %esi,%eax
104d48: 83 e0 03 and $0x3,%eax
104d4b: 75 73 jne 104dc0 <rtems_clock_get_tod+0x240>
104d4d: 89 cf mov %ecx,%edi
104d4f: c1 cf 02 ror $0x2,%edi
104d52: 81 ff 28 5c 8f 02 cmp $0x28f5c28,%edi
104d58: 77 71 ja 104dcb <rtems_clock_get_tod+0x24b>
104d5a: c1 c9 04 ror $0x4,%ecx
104d5d: 81 f9 0a d7 a3 00 cmp $0xa3d70a,%ecx
104d63: 76 66 jbe 104dcb <rtems_clock_get_tod+0x24b>
time_buffer->year = year;
104d65: 89 33 mov %esi,(%ebx)
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104d67: e9 27 ff ff ff jmp 104c93 <rtems_clock_get_tod+0x113>
104d6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104d70: 69 f6 29 5c 8f c2 imul $0xc28f5c29,%esi,%esi
days_to_date = _TOD_Days_to_date[1];
104d76: b9 9a 2d 12 00 mov $0x122d9a,%ecx
104d7b: c1 ce 04 ror $0x4,%esi
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104d7e: 81 fe 0a d7 a3 00 cmp $0xa3d70a,%esi
104d84: 0f 86 22 ff ff ff jbe 104cac <rtems_clock_get_tod+0x12c>
days_to_date = _TOD_Days_to_date[0];
104d8a: b9 80 2d 12 00 mov $0x122d80,%ecx
104d8f: e9 18 ff ff ff jmp 104cac <rtems_clock_get_tod+0x12c>
104d94: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104d9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104d9f: 90 nop
}
104da0: 83 c4 4c add $0x4c,%esp
return RTEMS_NOT_DEFINED;
104da3: b8 0b 00 00 00 mov $0xb,%eax
}
104da8: 5b pop %ebx
104da9: 5e pop %esi
104daa: 5f pop %edi
104dab: 5d pop %ebp
104dac: c3 ret
104dad: 8d 76 00 lea 0x0(%esi),%esi
*day -= *(days_to_date - 1);
104db0: 0f b7 71 fe movzwl -0x2(%ecx),%esi
104db4: e9 20 ff ff ff jmp 104cd9 <rtems_clock_get_tod+0x159>
104db9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
time_buffer->year = year;
104dc0: c1 c9 04 ror $0x4,%ecx
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
104dc3: 81 f9 0a d7 a3 00 cmp $0xa3d70a,%ecx
104dc9: 77 15 ja 104de0 <rtems_clock_get_tod+0x260> <== ALWAYS TAKEN
year_days += 1;
104dcb: 42 inc %edx
104dcc: e9 b8 fe ff ff jmp 104c89 <rtems_clock_get_tod+0x109>
104dd1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104dd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104ddf: 90 nop
time_buffer->year = year;
104de0: 89 33 mov %esi,(%ebx)
days_to_date = _TOD_Days_to_date[0];
104de2: b9 80 2d 12 00 mov $0x122d80,%ecx
104de7: e9 c0 fe ff ff jmp 104cac <rtems_clock_get_tod+0x12c>
104dec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
104df0: 83 c4 4c add $0x4c,%esp
return RTEMS_INVALID_ADDRESS;
104df3: b8 09 00 00 00 mov $0x9,%eax
}
104df8: 5b pop %ebx
104df9: 5e pop %esi
104dfa: 5f pop %edi
104dfb: 5d pop %ebp
104dfc: c3 ret
104dfd: 90 nop
104dfe: 90 nop
104dff: 90 nop
00104fb0 <rtems_clock_tick>:
#include <rtems/rtems/clock.h>
#include <rtems/score/timecounter.h>
#include <rtems/score/threadimpl.h>
rtems_status_code rtems_clock_tick( void )
{
104fb0: 55 push %ebp
104fb1: 89 e5 mov %esp,%ebp
104fb3: 83 ec 28 sub $0x28,%esp
ISR_lock_Context lock_context;
_Timecounter_Acquire( &lock_context );
104fb6: 9c pushf
104fb7: fa cli
104fb8: 58 pop %eax
104fb9: 89 45 f4 mov %eax,-0xc(%ebp)
_Timecounter_Tick_simple(
104fbc: 8d 45 f4 lea -0xc(%ebp),%eax
104fbf: 89 44 24 08 mov %eax,0x8(%esp)
104fc3: 31 c0 xor %eax,%eax
104fc5: 89 44 24 04 mov %eax,0x4(%esp)
104fc9: a1 d4 1f 12 00 mov 0x121fd4,%eax
104fce: 89 04 24 mov %eax,(%esp)
104fd1: e8 1a 25 00 00 call 1074f0 <_Timecounter_Tick_simple>
enabled = _Thread_Dispatch_disable_level == 0;
104fd6: a1 70 af 12 00 mov 0x12af70,%eax
rtems_configuration_get_microseconds_per_tick(),
0,
&lock_context
);
if ( _Thread_Dispatch_is_enabled() ) {
104fdb: 85 c0 test %eax,%eax
104fdd: 74 11 je 104ff0 <rtems_clock_tick+0x40> <== ALWAYS TAKEN
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
104fdf: 89 ec mov %ebp,%esp <== NOT EXECUTED
104fe1: 31 c0 xor %eax,%eax <== NOT EXECUTED
104fe3: 5d pop %ebp <== NOT EXECUTED
104fe4: c3 ret <== NOT EXECUTED
104fe5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104fec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
_Thread_Dispatch();
104ff0: e8 fb 32 00 00 call 1082f0 <_Thread_Dispatch>
}
104ff5: 89 ec mov %ebp,%esp
104ff7: 31 c0 xor %eax,%eax
104ff9: 5d pop %ebp
104ffa: c3 ret
104ffb: 90 nop
104ffc: 90 nop
104ffd: 90 nop
104ffe: 90 nop
104fff: 90 nop
00105550 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
105550: 55 push %ebp
105551: 89 e5 mov %esp,%ebp
105553: 83 ec 18 sub $0x18,%esp
105556: 89 5d fc mov %ebx,-0x4(%ebp)
105559: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10555c: 85 db test %ebx,%ebx
10555e: 74 70 je 1055d0 <rtems_object_get_class_information+0x80>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
105560: 0f b7 45 0c movzwl 0xc(%ebp),%eax
105564: 89 44 24 04 mov %eax,0x4(%esp)
105568: 8b 45 08 mov 0x8(%ebp),%eax
10556b: 89 04 24 mov %eax,(%esp)
10556e: e8 5d 1f 00 00 call 1074d0 <_Objects_Get_information>
if ( !obj_info )
105573: 85 c0 test %eax,%eax
105575: 74 69 je 1055e0 <rtems_object_get_class_information+0x90>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = _Objects_Get_minimum_id( obj_info->maximum_id );
105577: 8b 10 mov (%eax),%edx
info->maximum_id = obj_info->maximum_id;
105579: 89 53 04 mov %edx,0x4(%ebx)
*
* @return The corresponding ID with the minimum index.
*/
RTEMS_INLINE_ROUTINE Objects_Id _Objects_Get_minimum_id( Objects_Id id )
{
id &= ~OBJECTS_INDEX_MASK;
10557c: 89 d1 mov %edx,%ecx
10557e: 0f b7 d2 movzwl %dx,%edx
105581: 81 e1 00 00 ff ff and $0xffff0000,%ecx
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
105587: 41 inc %ecx
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend(
const Objects_Information *information
)
{
return information->objects_per_block != 0;
105588: 66 83 78 12 00 cmpw $0x0,0x12(%eax)
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
10558d: 89 0b mov %ecx,(%ebx)
info->auto_extend = _Objects_Is_auto_extend( obj_info );
info->maximum = _Objects_Get_maximum_index( obj_info );
10558f: 89 53 08 mov %edx,0x8(%ebx)
info->auto_extend = _Objects_Is_auto_extend( obj_info );
105592: 0f 95 43 0c setne 0xc(%ebx)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
105596: 85 d2 test %edx,%edx
105598: 74 23 je 1055bd <rtems_object_get_class_information+0x6d><== NEVER TAKEN
if ( !obj_info->local_table[i] )
10559a: 8b 48 04 mov 0x4(%eax),%ecx
10559d: 8d 41 04 lea 0x4(%ecx),%eax
1055a0: 8d 4c 91 04 lea 0x4(%ecx,%edx,4),%ecx
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
1055a4: 31 d2 xor %edx,%edx
1055a6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1055ad: 8d 76 00 lea 0x0(%esi),%esi
unallocated++;
1055b0: 83 38 01 cmpl $0x1,(%eax)
1055b3: 83 d2 00 adc $0x0,%edx
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
1055b6: 83 c0 04 add $0x4,%eax
1055b9: 39 c8 cmp %ecx,%eax
1055bb: 75 f3 jne 1055b0 <rtems_object_get_class_information+0x60>
info->unallocated = unallocated;
1055bd: 89 53 10 mov %edx,0x10(%ebx)
return RTEMS_SUCCESSFUL;
1055c0: 31 c0 xor %eax,%eax
}
1055c2: 8b 5d fc mov -0x4(%ebp),%ebx
1055c5: 89 ec mov %ebp,%esp
1055c7: 5d pop %ebp
1055c8: c3 ret
1055c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1055d0: 8b 5d fc mov -0x4(%ebp),%ebx
1055d3: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ADDRESS;
1055d5: b8 09 00 00 00 mov $0x9,%eax
}
1055da: 5d pop %ebp
1055db: c3 ret
1055dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return RTEMS_INVALID_NUMBER;
1055e0: b8 0a 00 00 00 mov $0xa,%eax
1055e5: eb db jmp 1055c2 <rtems_object_get_class_information+0x72>
1055e7: 90 nop
1055e8: 90 nop
1055e9: 90 nop
1055ea: 90 nop
1055eb: 90 nop
1055ec: 90 nop
1055ed: 90 nop
1055ee: 90 nop
1055ef: 90 nop
00103db0 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
103db0: 55 push %ebp
103db1: 89 e5 mov %esp,%ebp
103db3: 83 ec 28 sub $0x28,%esp
103db6: 89 7d fc mov %edi,-0x4(%ebp)
103db9: 8b 7d 0c mov 0xc(%ebp),%edi
103dbc: 89 75 f8 mov %esi,-0x8(%ebp)
103dbf: 8b 75 08 mov 0x8(%ebp),%esi
103dc2: 89 5d f4 mov %ebx,-0xc(%ebp)
Objects_Information *information;
Objects_Control *the_object;
Objects_Id tmpId;
Status_Control status;
if ( !name )
103dc5: 85 ff test %edi,%edi
103dc7: 0f 84 83 00 00 00 je 103e50 <rtems_object_set_name+0xa0>
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? rtems_task_self() : id;
103dcd: 85 f6 test %esi,%esi
103dcf: 74 4f je 103e20 <rtems_object_set_name+0x70>
information = _Objects_Get_information_id( tmpId );
103dd1: 89 34 24 mov %esi,(%esp)
103dd4: e8 27 17 00 00 call 105500 <_Objects_Get_information_id>
if ( !information )
103dd9: 85 c0 test %eax,%eax
information = _Objects_Get_information_id( tmpId );
103ddb: 89 c3 mov %eax,%ebx
if ( !information )
103ddd: 74 56 je 103e35 <rtems_object_set_name+0x85>
*
* @see _Objects_Allocator_unlock() and _Objects_Allocate().
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void )
{
_RTEMS_Lock_allocator();
103ddf: e8 fc 01 00 00 call 103fe0 <_RTEMS_Lock_allocator>
return RTEMS_INVALID_ID;
_Objects_Allocator_lock();
the_object = _Objects_Get_no_protection( tmpId, information );
103de4: 89 5c 24 04 mov %ebx,0x4(%esp)
103de8: 89 34 24 mov %esi,(%esp)
103deb: e8 80 18 00 00 call 105670 <_Objects_Get_no_protection>
if ( the_object == NULL ) {
103df0: 85 c0 test %eax,%eax
103df2: 74 7c je 103e70 <rtems_object_set_name+0xc0>
_Objects_Allocator_unlock();
return RTEMS_INVALID_ID;
}
status = _Objects_Set_name( information, the_object, name );
103df4: 89 1c 24 mov %ebx,(%esp)
103df7: 89 7c 24 08 mov %edi,0x8(%esp)
103dfb: 89 44 24 04 mov %eax,0x4(%esp)
103dff: e8 bc 18 00 00 call 1056c0 <_Objects_Set_name>
103e04: 89 c3 mov %eax,%ebx
* 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();
103e06: e8 f5 01 00 00 call 104000 <_RTEMS_Unlock_allocator>
_Objects_Allocator_unlock();
return STATUS_GET_CLASSIC( status );
103e0b: 0f b6 c3 movzbl %bl,%eax
}
103e0e: 8b 5d f4 mov -0xc(%ebp),%ebx
103e11: 8b 75 f8 mov -0x8(%ebp),%esi
103e14: 8b 7d fc mov -0x4(%ebp),%edi
103e17: 89 ec mov %ebp,%esp
103e19: 5d pop %ebp
103e1a: c3 ret
103e1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
103e1f: 90 nop
tmpId = (id == OBJECTS_ID_OF_SELF) ? rtems_task_self() : id;
103e20: e8 db 00 00 00 call 103f00 <rtems_task_self>
103e25: 89 c6 mov %eax,%esi
information = _Objects_Get_information_id( tmpId );
103e27: 89 34 24 mov %esi,(%esp)
103e2a: e8 d1 16 00 00 call 105500 <_Objects_Get_information_id>
if ( !information )
103e2f: 85 c0 test %eax,%eax
information = _Objects_Get_information_id( tmpId );
103e31: 89 c3 mov %eax,%ebx
if ( !information )
103e33: 75 aa jne 103ddf <rtems_object_set_name+0x2f> <== ALWAYS TAKEN
}
103e35: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ID;
103e38: b8 04 00 00 00 mov $0x4,%eax
}
103e3d: 8b 75 f8 mov -0x8(%ebp),%esi
103e40: 8b 7d fc mov -0x4(%ebp),%edi
103e43: 89 ec mov %ebp,%esp
103e45: 5d pop %ebp
103e46: c3 ret
103e47: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103e4e: 66 90 xchg %ax,%ax
103e50: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ADDRESS;
103e53: b8 09 00 00 00 mov $0x9,%eax
}
103e58: 8b 75 f8 mov -0x8(%ebp),%esi
103e5b: 8b 7d fc mov -0x4(%ebp),%edi
103e5e: 89 ec mov %ebp,%esp
103e60: 5d pop %ebp
103e61: c3 ret
103e62: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103e69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103e70: e8 8b 01 00 00 call 104000 <_RTEMS_Unlock_allocator>
return RTEMS_INVALID_ID;
103e75: b8 04 00 00 00 mov $0x4,%eax
103e7a: eb 92 jmp 103e0e <rtems_object_set_name+0x5e>
103e7c: 90 nop
103e7d: 90 nop
103e7e: 90 nop
103e7f: 90 nop
001143c0 <rtems_partition_create>:
{
1143c0: 55 push %ebp
1143c1: 89 e5 mov %esp,%ebp
1143c3: 83 ec 28 sub $0x28,%esp
1143c6: 89 75 f8 mov %esi,-0x8(%ebp)
if ( !rtems_is_name_valid( name ) ) {
1143c9: 8b 75 08 mov 0x8(%ebp),%esi
{
1143cc: 89 5d f4 mov %ebx,-0xc(%ebp)
1143cf: 8b 5d 14 mov 0x14(%ebp),%ebx
1143d2: 89 7d fc mov %edi,-0x4(%ebp)
if ( !rtems_is_name_valid( name ) ) {
1143d5: 85 f6 test %esi,%esi
1143d7: 0f 84 f3 00 00 00 je 1144d0 <rtems_partition_create+0x110>
if ( starting_address == NULL ) {
1143dd: 8b 4d 1c mov 0x1c(%ebp),%ecx
1143e0: 85 c9 test %ecx,%ecx
1143e2: 0f 84 c8 00 00 00 je 1144b0 <rtems_partition_create+0xf0> <== NEVER TAKEN
1143e8: 8b 55 0c mov 0xc(%ebp),%edx
1143eb: 85 d2 test %edx,%edx
1143ed: 0f 84 bd 00 00 00 je 1144b0 <rtems_partition_create+0xf0>
if ( length == 0 )
1143f3: 8b 45 10 mov 0x10(%ebp),%eax
return RTEMS_INVALID_SIZE;
1143f6: bf 08 00 00 00 mov $0x8,%edi
if ( length == 0 )
1143fb: 85 c0 test %eax,%eax
1143fd: 0f 94 c2 sete %dl
if ( buffer_size == 0 )
114400: 83 fb 07 cmp $0x7,%ebx
114403: 0f 96 c0 setbe %al
if ( length < buffer_size )
114406: 08 c2 or %al,%dl
114408: 0f 85 8d 00 00 00 jne 11449b <rtems_partition_create+0xdb>
11440e: 39 5d 10 cmp %ebx,0x10(%ebp)
114411: 0f 82 84 00 00 00 jb 11449b <rtems_partition_create+0xdb>
if ( buffer_size < sizeof( Chain_Node ) )
114417: f6 c3 03 test $0x3,%bl
11441a: 75 7f jne 11449b <rtems_partition_create+0xdb> <== NEVER TAKEN
if ( (uintptr_t) starting_address % CPU_SIZEOF_POINTER != 0 ) {
11441c: 8b 7d 0c mov 0xc(%ebp),%edi
11441f: 83 e7 03 and $0x3,%edi
114422: 0f 85 88 00 00 00 jne 1144b0 <rtems_partition_create+0xf0>
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
114428: c7 04 24 80 52 15 00 movl $0x155280,(%esp)
11442f: e8 ec 2b 00 00 call 117020 <_Objects_Allocate>
if ( !the_partition ) {
114434: 85 c0 test %eax,%eax
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
114436: 89 c6 mov %eax,%esi
if ( !the_partition ) {
114438: 0f 84 b2 00 00 00 je 1144f0 <rtems_partition_create+0x130>
the_partition->buffer_size = buffer_size;
11443e: 89 5e 18 mov %ebx,0x18(%esi)
the_partition->starting_address = starting_address;
114441: 8b 45 0c mov 0xc(%ebp),%eax
_Chain_Initialize(
114444: 31 d2 xor %edx,%edx
the_partition->number_of_used_blocks = 0;
114446: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi)
the_partition->starting_address = starting_address;
11444d: 89 46 10 mov %eax,0x10(%esi)
the_partition->length = length;
114450: 8b 45 10 mov 0x10(%ebp),%eax
114453: 89 46 14 mov %eax,0x14(%esi)
the_partition->attribute_set = attribute_set;
114456: 8b 45 18 mov 0x18(%ebp),%eax
114459: 89 46 1c mov %eax,0x1c(%esi)
_Chain_Initialize(
11445c: 8b 45 10 mov 0x10(%ebp),%eax
11445f: 89 5c 24 0c mov %ebx,0xc(%esp)
114463: f7 f3 div %ebx
114465: 89 44 24 08 mov %eax,0x8(%esp)
114469: 8b 45 0c mov 0xc(%ebp),%eax
11446c: 89 44 24 04 mov %eax,0x4(%esp)
114470: 8d 46 24 lea 0x24(%esi),%eax
114473: 89 04 24 mov %eax,(%esp)
114476: e8 b5 0f 00 00 call 115430 <_Chain_Initialize>
the_object->name = name;
11447b: 8b 45 08 mov 0x8(%ebp),%eax
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
11447e: 8b 15 84 52 15 00 mov 0x155284,%edx
*id = the_partition->Object.id;
114484: 8b 4d 1c mov 0x1c(%ebp),%ecx
the_object->name = name;
114487: 89 46 0c mov %eax,0xc(%esi)
_Objects_Get_index( the_object->id ),
11448a: 8b 46 08 mov 0x8(%esi),%eax
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
11448d: 0f b7 d8 movzwl %ax,%ebx
114490: 89 74 9a fc mov %esi,-0x4(%edx,%ebx,4)
114494: 89 01 mov %eax,(%ecx)
_RTEMS_Unlock_allocator();
114496: e8 e5 0e 00 00 call 115380 <_RTEMS_Unlock_allocator>
}
11449b: 8b 5d f4 mov -0xc(%ebp),%ebx
11449e: 89 f8 mov %edi,%eax
1144a0: 8b 75 f8 mov -0x8(%ebp),%esi
1144a3: 8b 7d fc mov -0x4(%ebp),%edi
1144a6: 89 ec mov %ebp,%esp
1144a8: 5d pop %ebp
1144a9: c3 ret
1144aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return RTEMS_INVALID_ADDRESS;
1144b0: bf 09 00 00 00 mov $0x9,%edi
}
1144b5: 8b 5d f4 mov -0xc(%ebp),%ebx
1144b8: 8b 75 f8 mov -0x8(%ebp),%esi
1144bb: 89 f8 mov %edi,%eax
1144bd: 8b 7d fc mov -0x4(%ebp),%edi
1144c0: 89 ec mov %ebp,%esp
1144c2: 5d pop %ebp
1144c3: c3 ret
1144c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1144cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1144cf: 90 nop
return RTEMS_INVALID_NAME;
1144d0: bf 03 00 00 00 mov $0x3,%edi
}
1144d5: 8b 5d f4 mov -0xc(%ebp),%ebx
1144d8: 8b 75 f8 mov -0x8(%ebp),%esi
1144db: 89 f8 mov %edi,%eax
1144dd: 8b 7d fc mov -0x4(%ebp),%edi
1144e0: 89 ec mov %ebp,%esp
1144e2: 5d pop %ebp
1144e3: c3 ret
1144e4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1144eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1144ef: 90 nop
1144f0: e8 8b 0e 00 00 call 115380 <_RTEMS_Unlock_allocator>
return RTEMS_TOO_MANY;
1144f5: bf 05 00 00 00 mov $0x5,%edi
1144fa: eb 9f jmp 11449b <rtems_partition_create+0xdb>
1144fc: 90 nop
1144fd: 90 nop
1144fe: 90 nop
1144ff: 90 nop
00104710 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
104710: 55 push %ebp
return (Partition_Control *) _Objects_Get(
104711: b8 40 51 12 00 mov $0x125140,%eax
104716: 89 e5 mov %esp,%ebp
104718: 56 push %esi
104719: 53 push %ebx
10471a: 83 ec 20 sub $0x20,%esp
10471d: 89 44 24 08 mov %eax,0x8(%esp)
104721: 8d 45 f4 lea -0xc(%ebp),%eax
104724: 8b 5d 0c mov 0xc(%ebp),%ebx
104727: 89 44 24 04 mov %eax,0x4(%esp)
10472b: 8b 45 08 mov 0x8(%ebp),%eax
10472e: 89 04 24 mov %eax,(%esp)
104731: e8 2a 19 00 00 call 106060 <_Objects_Get>
Partition_Control *the_partition;
ISR_lock_Context lock_context;
the_partition = _Partition_Get( id, &lock_context );
if ( the_partition == NULL ) {
104736: 85 c0 test %eax,%eax
104738: 74 56 je 104790 <rtems_partition_return_buffer+0x80>
starting = the_partition->starting_address;
10473a: 8b 50 10 mov 0x10(%eax),%edx
10473d: 89 c1 mov %eax,%ecx
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
10473f: 8b 40 14 mov 0x14(%eax),%eax
104742: 01 d0 add %edx,%eax
&& _Partition_Is_address_on_buffer_boundary( the_partition, the_buffer );
104744: 39 c3 cmp %eax,%ebx
104746: 77 11 ja 104759 <rtems_partition_return_buffer+0x49>
104748: 39 d3 cmp %edx,%ebx
10474a: 72 0d jb 104759 <rtems_partition_return_buffer+0x49> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE intptr_t _Addresses_Subtract(
const void *left,
const void *right
)
{
return (intptr_t) ( (const char *) left - (const char *) right );
10474c: 89 d8 mov %ebx,%eax
10474e: 29 d0 sub %edx,%eax
return ( offset % the_partition->buffer_size ) == 0;
104750: 31 d2 xor %edx,%edx
104752: f7 71 18 divl 0x18(%ecx)
&& _Partition_Is_address_on_buffer_boundary( the_partition, the_buffer );
104755: 85 d2 test %edx,%edx
104757: 74 17 je 104770 <rtems_partition_return_buffer+0x60>
_ISR_lock_Release_and_ISR_enable( &the_partition->Lock, lock_context );
104759: ff 75 f4 push -0xc(%ebp)
10475c: 9d popf
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Partition_Release( the_partition, &lock_context );
return RTEMS_SUCCESSFUL;
}
10475d: 83 c4 20 add $0x20,%esp
return RTEMS_INVALID_ADDRESS;
104760: ba 09 00 00 00 mov $0x9,%edx
}
104765: 5b pop %ebx
104766: 89 d0 mov %edx,%eax
104768: 5e pop %esi
104769: 5d pop %ebp
10476a: c3 ret
10476b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10476f: 90 nop
old_last = tail->previous;
104770: 8b 41 2c mov 0x2c(%ecx),%eax
return &the_chain->Tail.Node;
104773: 8d 71 28 lea 0x28(%ecx),%esi
104776: 89 33 mov %esi,(%ebx)
tail->previous = the_node;
104778: 89 59 2c mov %ebx,0x2c(%ecx)
old_last->next = the_node;
10477b: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
10477d: 89 43 04 mov %eax,0x4(%ebx)
the_partition->number_of_used_blocks -= 1;
104780: ff 49 20 decl 0x20(%ecx)
104783: ff 75 f4 push -0xc(%ebp)
104786: 9d popf
}
104787: 83 c4 20 add $0x20,%esp
10478a: 89 d0 mov %edx,%eax
10478c: 5b pop %ebx
10478d: 5e pop %esi
10478e: 5d pop %ebp
10478f: c3 ret
104790: 83 c4 20 add $0x20,%esp
return RTEMS_INVALID_ID;
104793: ba 04 00 00 00 mov $0x4,%edx
}
104798: 5b pop %ebx
104799: 89 d0 mov %edx,%eax
10479b: 5e pop %esi
10479c: 5d pop %ebp
10479d: c3 ret
10479e: 90 nop
10479f: 90 nop
00104780 <rtems_rate_monotonic_create>:
{
104780: 55 push %ebp
104781: 89 e5 mov %esp,%ebp
104783: 83 ec 28 sub $0x28,%esp
104786: 89 75 f8 mov %esi,-0x8(%ebp)
if ( !rtems_is_name_valid( name ) )
104789: 8b 75 08 mov 0x8(%ebp),%esi
{
10478c: 89 5d f4 mov %ebx,-0xc(%ebp)
10478f: 89 7d fc mov %edi,-0x4(%ebp)
if ( !rtems_is_name_valid( name ) )
104792: 85 f6 test %esi,%esi
104794: 0f 84 f6 00 00 00 je 104890 <rtems_rate_monotonic_create+0x110>
if ( !id )
10479a: 8b 5d 0c mov 0xc(%ebp),%ebx
10479d: 85 db test %ebx,%ebx
10479f: 0f 84 5b 01 00 00 je 104900 <rtems_rate_monotonic_create+0x180>
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
_Objects_Allocate( &_Rate_monotonic_Information );
1047a5: c7 04 24 c0 7c 12 00 movl $0x127cc0,(%esp)
1047ac: e8 af 25 00 00 call 106d60 <_Objects_Allocate>
if ( !the_period ) {
1047b1: 85 c0 test %eax,%eax
1047b3: 0f 84 67 01 00 00 je 104920 <rtems_rate_monotonic_create+0x1a0>
the_period->owner = _Thread_Get_executing();
1047b9: 8b 15 d8 d0 12 00 mov 0x12d0d8,%edx
)
{
Rate_monotonic_Statistics *statistics;
statistics = &the_period->Statistics;
memset( statistics, 0, sizeof( *statistics ) );
1047bf: 31 db xor %ebx,%ebx
1047c1: a8 01 test $0x1,%al
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
1047c3: c7 40 40 00 00 00 00 movl $0x0,0x40(%eax)
1047ca: 8d 48 60 lea 0x60(%eax),%ecx
1047cd: be 38 00 00 00 mov $0x38,%esi
1047d2: c7 40 44 00 00 00 00 movl $0x0,0x44(%eax)
*
* @see _RBTree_Is_node_off_tree().
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_tree( RBTree_Node *the_node )
{
RB_COLOR( the_node, Node ) = -1;
1047d9: c7 40 3c ff ff ff ff movl $0xffffffff,0x3c(%eax)
1047e0: 89 50 4c mov %edx,0x4c(%eax)
the_period->state = RATE_MONOTONIC_INACTIVE;
1047e3: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
RTEMS_INLINE_ROUTINE void _Watchdog_Set_state(
Watchdog_Control *the_watchdog,
Watchdog_State state
)
{
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
1047ea: c7 40 1c 02 00 00 00 movl $0x2,0x1c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Service_routine_entry routine
)
{
_Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE );
the_watchdog->routine = routine;
1047f1: c7 40 20 20 52 10 00 movl $0x105220,0x20(%eax)
1047f8: 0f 85 32 01 00 00 jne 104930 <rtems_rate_monotonic_create+0x1b0> <== NEVER TAKEN
1047fe: f6 c1 02 test $0x2,%cl
104801: 0f 85 49 01 00 00 jne 104950 <rtems_rate_monotonic_create+0x1d0> <== NEVER TAKEN
104807: 89 f7 mov %esi,%edi
104809: 31 d2 xor %edx,%edx
10480b: 83 e7 f8 and $0xfffffff8,%edi
10480e: 89 1c 11 mov %ebx,(%ecx,%edx,1)
104811: 89 5c 11 04 mov %ebx,0x4(%ecx,%edx,1)
104815: 83 c2 08 add $0x8,%edx
104818: 39 fa cmp %edi,%edx
10481a: 72 f2 jb 10480e <rtems_rate_monotonic_create+0x8e>
10481c: 01 d1 add %edx,%ecx
10481e: f7 c6 04 00 00 00 test $0x4,%esi
104824: 0f 85 b6 00 00 00 jne 1048e0 <rtems_rate_monotonic_create+0x160> <== NEVER TAKEN
10482a: f7 c6 02 00 00 00 test $0x2,%esi
104830: 0f 85 8a 00 00 00 jne 1048c0 <rtems_rate_monotonic_create+0x140> <== NEVER TAKEN
104836: 83 e6 01 and $0x1,%esi
104839: 75 75 jne 1048b0 <rtems_rate_monotonic_create+0x130> <== NEVER TAKEN
struct timespec _ts;
_ts.tv_sec = _seconds;
_ts.tv_nsec = _nanoseconds;
*_time = tstosbt(_ts);
10483b: ba 01 7d c1 25 mov $0x25c17d01,%edx
)
{
_Assert( information != NULL );
_Assert( the_object != NULL );
the_object->name = name;
104840: 8b 5d 08 mov 0x8(%ebp),%ebx
104843: b9 ff ff ff 7f mov $0x7fffffff,%ecx
104848: 89 90 80 00 00 00 mov %edx,0x80(%eax)
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10484e: 8b 50 08 mov 0x8(%eax),%edx
104851: 89 88 84 00 00 00 mov %ecx,0x84(%eax)
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
104857: 8b 0d c4 7c 12 00 mov 0x127cc4,%ecx
10485d: c7 40 68 01 7d c1 25 movl $0x25c17d01,0x68(%eax)
the_object->name = name;
104864: 89 58 0c mov %ebx,0xc(%eax)
104867: c7 40 6c ff ff ff 7f movl $0x7fffffff,0x6c(%eax)
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10486e: 0f b7 da movzwl %dx,%ebx
104871: 89 44 99 fc mov %eax,-0x4(%ecx,%ebx,4)
*id = the_period->Object.id;
104875: 8b 45 0c mov 0xc(%ebp),%eax
104878: 89 10 mov %edx,(%eax)
* 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();
10487a: e8 61 10 00 00 call 1058e0 <_RTEMS_Unlock_allocator>
return RTEMS_SUCCESSFUL;
10487f: 31 c0 xor %eax,%eax
}
104881: 8b 5d f4 mov -0xc(%ebp),%ebx
104884: 8b 75 f8 mov -0x8(%ebp),%esi
104887: 8b 7d fc mov -0x4(%ebp),%edi
10488a: 89 ec mov %ebp,%esp
10488c: 5d pop %ebp
10488d: c3 ret
10488e: 66 90 xchg %ax,%ax
104890: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_NAME;
104893: b8 03 00 00 00 mov $0x3,%eax
}
104898: 8b 75 f8 mov -0x8(%ebp),%esi
10489b: 8b 7d fc mov -0x4(%ebp),%edi
10489e: 89 ec mov %ebp,%esp
1048a0: 5d pop %ebp
1048a1: c3 ret
1048a2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1048a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1048b0: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED
1048b3: eb 86 jmp 10483b <rtems_rate_monotonic_create+0xbb> <== NOT EXECUTED
1048b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1048bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1048c0: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
1048c5: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
1048c8: 83 e6 01 and $0x1,%esi <== NOT EXECUTED
1048cb: 0f 84 6a ff ff ff je 10483b <rtems_rate_monotonic_create+0xbb> <== NOT EXECUTED
1048d1: eb dd jmp 1048b0 <rtems_rate_monotonic_create+0x130> <== NOT EXECUTED
1048d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1048da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
1048e0: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
1048e6: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED
1048e9: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED
1048ef: 0f 84 41 ff ff ff je 104836 <rtems_rate_monotonic_create+0xb6> <== NOT EXECUTED
1048f5: eb c9 jmp 1048c0 <rtems_rate_monotonic_create+0x140> <== NOT EXECUTED
1048f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1048fe: 66 90 xchg %ax,%ax <== NOT EXECUTED
104900: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ADDRESS;
104903: b8 09 00 00 00 mov $0x9,%eax
}
104908: 8b 75 f8 mov -0x8(%ebp),%esi
10490b: 8b 7d fc mov -0x4(%ebp),%edi
10490e: 89 ec mov %ebp,%esp
104910: 5d pop %ebp
104911: c3 ret
104912: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104919: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104920: e8 bb 0f 00 00 call 1058e0 <_RTEMS_Unlock_allocator>
return RTEMS_TOO_MANY;
104925: b8 05 00 00 00 mov $0x5,%eax
10492a: e9 52 ff ff ff jmp 104881 <rtems_rate_monotonic_create+0x101>
10492f: 90 nop
104930: c6 40 60 00 movb $0x0,0x60(%eax) <== NOT EXECUTED
104934: 8d 48 61 lea 0x61(%eax),%ecx <== NOT EXECUTED
104937: be 37 00 00 00 mov $0x37,%esi <== NOT EXECUTED
10493c: e9 bd fe ff ff jmp 1047fe <rtems_rate_monotonic_create+0x7e> <== NOT EXECUTED
104941: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104948: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10494f: 90 nop <== NOT EXECUTED
104950: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
104955: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
104958: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
10495b: e9 a7 fe ff ff jmp 104807 <rtems_rate_monotonic_create+0x87> <== NOT EXECUTED
00113670 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *dst
)
{
113670: 55 push %ebp
113671: 89 e5 mov %esp,%ebp
113673: 57 push %edi
113674: 56 push %esi
113675: 53 push %ebx
113676: 83 ec 2c sub $0x2c,%esp
113679: 8b 5d 0c mov 0xc(%ebp),%ebx
Rate_monotonic_Control *the_period;
ISR_lock_Context lock_context;
const Rate_monotonic_Statistics *src;
if ( dst == NULL ) {
11367c: 85 db test %ebx,%ebx
11367e: 0f 84 dc 00 00 00 je 113760 <rtems_rate_monotonic_get_statistics+0xf0><== NEVER TAKEN
Objects_Id id,
ISR_lock_Context *lock_context
)
{
return (Rate_monotonic_Control *)
_Objects_Get( id, lock_context, &_Rate_monotonic_Information );
113684: b8 80 18 1a 00 mov $0x1a1880,%eax
113689: 89 44 24 08 mov %eax,0x8(%esp)
11368d: 8d 45 e4 lea -0x1c(%ebp),%eax
113690: 89 44 24 04 mov %eax,0x4(%esp)
113694: 8b 45 08 mov 0x8(%ebp),%eax
113697: 89 04 24 mov %eax,(%esp)
11369a: e8 b1 4d 00 00 call 118450 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
}
the_period = _Rate_monotonic_Get( id, &lock_context );
if ( the_period == NULL ) {
11369f: 85 c0 test %eax,%eax
1136a1: 89 c1 mov %eax,%ecx
1136a3: 0f 84 c7 00 00 00 je 113770 <rtems_rate_monotonic_get_statistics+0x100>
}
_Rate_monotonic_Acquire_critical( the_period, &lock_context );
src = &the_period->Statistics;
dst->count = src->count;
1136a9: 8b 40 60 mov 0x60(%eax),%eax
RTEMS_INLINE_ROUTINE void _Timestamp_To_timespec(
const Timestamp_Control *_timestamp,
struct timespec *_timespec
)
{
*_timespec = sbttots( *_timestamp );
1136ac: 8b 51 6c mov 0x6c(%ecx),%edx
1136af: 89 03 mov %eax,(%ebx)
dst->missed_count = src->missed_count;
1136b1: 8b 41 64 mov 0x64(%ecx),%eax
_ts.tv_sec = _sbt >> 32;
1136b4: 89 d6 mov %edx,%esi
1136b6: c1 fe 1f sar $0x1f,%esi
1136b9: 89 43 04 mov %eax,0x4(%ebx)
1136bc: 8b 41 68 mov 0x68(%ecx),%eax
1136bf: 89 73 0c mov %esi,0xc(%ebx)
return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32));
1136c2: be 00 ca 9a 3b mov $0x3b9aca00,%esi
1136c7: 89 53 08 mov %edx,0x8(%ebx)
1136ca: f7 e6 mul %esi
1136cc: 8b 41 70 mov 0x70(%ecx),%eax
_ts.tv_nsec = sbttons((uint32_t)_sbt);
1136cf: 89 53 10 mov %edx,0x10(%ebx)
1136d2: 8b 51 74 mov 0x74(%ecx),%edx
1136d5: 89 53 14 mov %edx,0x14(%ebx)
_ts.tv_sec = _sbt >> 32;
1136d8: 89 d7 mov %edx,%edi
return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32));
1136da: f7 e6 mul %esi
_ts.tv_sec = _sbt >> 32;
1136dc: c1 ff 1f sar $0x1f,%edi
1136df: 89 7b 18 mov %edi,0x18(%ebx)
1136e2: 8b 41 78 mov 0x78(%ecx),%eax
_ts.tv_nsec = sbttons((uint32_t)_sbt);
1136e5: 89 53 1c mov %edx,0x1c(%ebx)
1136e8: 8b 51 7c mov 0x7c(%ecx),%edx
1136eb: 89 53 20 mov %edx,0x20(%ebx)
_ts.tv_sec = _sbt >> 32;
1136ee: 89 d7 mov %edx,%edi
return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32));
1136f0: f7 e6 mul %esi
_ts.tv_sec = _sbt >> 32;
1136f2: c1 ff 1f sar $0x1f,%edi
1136f5: 89 7b 24 mov %edi,0x24(%ebx)
1136f8: 8b 81 80 00 00 00 mov 0x80(%ecx),%eax
_ts.tv_nsec = sbttons((uint32_t)_sbt);
1136fe: 89 53 28 mov %edx,0x28(%ebx)
113701: 8b 91 84 00 00 00 mov 0x84(%ecx),%edx
113707: 89 53 2c mov %edx,0x2c(%ebx)
_ts.tv_sec = _sbt >> 32;
11370a: 89 d7 mov %edx,%edi
return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32));
11370c: f7 e6 mul %esi
_ts.tv_sec = _sbt >> 32;
11370e: c1 ff 1f sar $0x1f,%edi
113711: 89 7b 30 mov %edi,0x30(%ebx)
113714: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax
_ts.tv_nsec = sbttons((uint32_t)_sbt);
11371a: 89 53 34 mov %edx,0x34(%ebx)
11371d: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx
113723: 89 53 38 mov %edx,0x38(%ebx)
_ts.tv_sec = _sbt >> 32;
113726: 89 d7 mov %edx,%edi
return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32));
113728: f7 e6 mul %esi
_ts.tv_sec = _sbt >> 32;
11372a: c1 ff 1f sar $0x1f,%edi
11372d: 89 7b 3c mov %edi,0x3c(%ebx)
113730: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax
_ts.tv_nsec = sbttons((uint32_t)_sbt);
113736: 89 53 40 mov %edx,0x40(%ebx)
113739: 8b 91 94 00 00 00 mov 0x94(%ecx),%edx
11373f: 89 53 44 mov %edx,0x44(%ebx)
_ts.tv_sec = _sbt >> 32;
113742: 89 d1 mov %edx,%ecx
return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32));
113744: f7 e6 mul %esi
_ts.tv_sec = _sbt >> 32;
113746: c1 f9 1f sar $0x1f,%ecx
113749: 89 4b 48 mov %ecx,0x48(%ebx)
_ts.tv_nsec = sbttons((uint32_t)_sbt);
11374c: 89 53 4c mov %edx,0x4c(%ebx)
_ISR_lock_Release_and_ISR_enable( &the_period->Lock, lock_context );
11374f: ff 75 e4 push -0x1c(%ebp)
113752: 9d popf
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
_Rate_monotonic_Release( the_period, &lock_context );
return RTEMS_SUCCESSFUL;
113753: 31 c0 xor %eax,%eax
}
113755: 83 c4 2c add $0x2c,%esp
113758: 5b pop %ebx
113759: 5e pop %esi
11375a: 5f pop %edi
11375b: 5d pop %ebp
11375c: c3 ret
11375d: 8d 76 00 lea 0x0(%esi),%esi
113760: 83 c4 2c add $0x2c,%esp
return RTEMS_INVALID_ADDRESS;
113763: b8 09 00 00 00 mov $0x9,%eax
}
113768: 5b pop %ebx
113769: 5e pop %esi
11376a: 5f pop %edi
11376b: 5d pop %ebp
11376c: c3 ret
11376d: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_INVALID_ID;
113770: b8 04 00 00 00 mov $0x4,%eax
113775: eb de jmp 113755 <rtems_rate_monotonic_get_statistics+0xe5>
113777: 90 nop
113778: 90 nop
113779: 90 nop
11377a: 90 nop
11377b: 90 nop
11377c: 90 nop
11377d: 90 nop
11377e: 90 nop
11377f: 90 nop
001138f0 <rtems_rate_monotonic_report_statistics_with_plugin>:
#define NANOSECONDS_FMT "%06ld"
void rtems_rate_monotonic_report_statistics_with_plugin(
const rtems_printer *printer
)
{
1138f0: 55 push %ebp
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
rtems_printf( printer, "Period information by period\n" );
1138f1: b8 e8 08 19 00 mov $0x1908e8,%eax
{
1138f6: 89 e5 mov %esp,%ebp
1138f8: 57 push %edi
1138f9: 56 push %esi
1138fa: 53 push %ebx
1138fb: 81 ec dc 00 00 00 sub $0xdc,%esp
rtems_printf( printer, "Period information by period\n" );
113901: 89 44 24 04 mov %eax,0x4(%esp)
{
113905: 8b 7d 08 mov 0x8(%ebp),%edi
rtems_printf( printer, "Period information by period\n" );
113908: 89 3c 24 mov %edi,(%esp)
11390b: e8 e0 fd fe ff call 1036f0 <rtems_printf>
rtems_printf( printer, "--- CPU times are in seconds ---\n" );
113910: b8 1c 09 19 00 mov $0x19091c,%eax
113915: 89 44 24 04 mov %eax,0x4(%esp)
113919: 89 3c 24 mov %edi,(%esp)
11391c: e8 cf fd fe ff call 1036f0 <rtems_printf>
rtems_printf( printer, "--- Wall times are in seconds ---\n" );
113921: b8 40 09 19 00 mov $0x190940,%eax
113926: 89 44 24 04 mov %eax,0x4(%esp)
11392a: 89 3c 24 mov %edi,(%esp)
11392d: e8 be fd fe ff call 1036f0 <rtems_printf>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
rtems_printf( printer,
113932: b8 64 09 19 00 mov $0x190964,%eax
113937: 89 44 24 04 mov %eax,0x4(%esp)
11393b: 89 3c 24 mov %edi,(%esp)
11393e: e8 ad fd fe ff call 1036f0 <rtems_printf>
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
maximum_id = _Rate_monotonic_Information.maximum_id;
113943: a1 80 18 1a 00 mov 0x1a1880,%eax
113948: 89 85 54 ff ff ff mov %eax,-0xac(%ebp)
id &= ~OBJECTS_INDEX_MASK;
11394e: 89 c3 mov %eax,%ebx
113950: 81 e3 00 00 ff ff and $0xffff0000,%ebx
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
113956: 43 inc %ebx
for (
113957: 39 d8 cmp %ebx,%eax
113959: 0f 83 54 01 00 00 jae 113ab3 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c3><== ALWAYS TAKEN
11395f: e9 eb 01 00 00 jmp 113b4f <rtems_rate_monotonic_report_statistics_with_plugin+0x25f><== NOT EXECUTED
113964: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11396b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11396f: 90 nop <== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
113970: 89 44 24 04 mov %eax,0x4(%esp)
113974: 8d b5 68 ff ff ff lea -0x98(%ebp),%esi
11397a: 89 74 24 08 mov %esi,0x8(%esp)
11397e: 8d 45 b8 lea -0x48(%ebp),%eax
rtems_printf( printer,
113981: be d3 4d 62 10 mov $0x10624dd3,%esi
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
113986: 89 04 24 mov %eax,(%esp)
113989: e8 22 8e 00 00 call 11c7b0 <_Timespec_Divide_by_integer>
rtems_printf( printer,
11398e: 8b 8d 70 ff ff ff mov -0x90(%ebp),%ecx
113994: 89 3c 24 mov %edi,(%esp)
113997: 89 c8 mov %ecx,%eax
113999: f7 ee imul %esi
11399b: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
1139a1: c1 f9 1f sar $0x1f,%ecx
1139a4: 89 44 24 20 mov %eax,0x20(%esp)
1139a8: c1 fa 06 sar $0x6,%edx
1139ab: 29 ca sub %ecx,%edx
1139ad: 8b 4d b4 mov -0x4c(%ebp),%ecx
1139b0: 89 54 24 28 mov %edx,0x28(%esp)
1139b4: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx
1139ba: 89 c8 mov %ecx,%eax
1139bc: 89 54 24 24 mov %edx,0x24(%esp)
1139c0: f7 ee imul %esi
1139c2: 8b 45 ac mov -0x54(%ebp),%eax
1139c5: c1 f9 1f sar $0x1f,%ecx
1139c8: 89 44 24 14 mov %eax,0x14(%esp)
1139cc: c1 fa 06 sar $0x6,%edx
1139cf: 29 ca sub %ecx,%edx
1139d1: 8b 4d a8 mov -0x58(%ebp),%ecx
1139d4: 89 54 24 1c mov %edx,0x1c(%esp)
1139d8: 8b 55 b0 mov -0x50(%ebp),%edx
1139db: 89 c8 mov %ecx,%eax
1139dd: 89 54 24 18 mov %edx,0x18(%esp)
1139e1: f7 ee imul %esi
1139e3: 8b 45 a0 mov -0x60(%ebp),%eax
1139e6: c1 f9 1f sar $0x1f,%ecx
1139e9: 89 44 24 08 mov %eax,0x8(%esp)
1139ed: c1 fa 06 sar $0x6,%edx
1139f0: b8 fc 09 19 00 mov $0x1909fc,%eax
1139f5: 89 44 24 04 mov %eax,0x4(%esp)
1139f9: 29 ca sub %ecx,%edx
1139fb: 89 54 24 10 mov %edx,0x10(%esp)
1139ff: 8b 55 a4 mov -0x5c(%ebp),%edx
113a02: 89 54 24 0c mov %edx,0xc(%esp)
113a06: e8 e5 fc fe ff call 1036f0 <rtems_printf>
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
113a0b: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
113a11: 89 44 24 08 mov %eax,0x8(%esp)
113a15: 8b 45 98 mov -0x68(%ebp),%eax
113a18: 89 44 24 04 mov %eax,0x4(%esp)
113a1c: 8d 45 dc lea -0x24(%ebp),%eax
113a1f: 89 04 24 mov %eax,(%esp)
113a22: e8 89 8d 00 00 call 11c7b0 <_Timespec_Divide_by_integer>
rtems_printf( printer,
113a27: 8b 8d 70 ff ff ff mov -0x90(%ebp),%ecx
113a2d: 89 3c 24 mov %edi,(%esp)
113a30: 89 c8 mov %ecx,%eax
113a32: f7 ee imul %esi
113a34: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
113a3a: c1 f9 1f sar $0x1f,%ecx
113a3d: 89 44 24 20 mov %eax,0x20(%esp)
113a41: c1 fa 06 sar $0x6,%edx
113a44: 29 ca sub %ecx,%edx
113a46: 8b 4d d8 mov -0x28(%ebp),%ecx
113a49: 89 54 24 28 mov %edx,0x28(%esp)
113a4d: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx
113a53: 89 c8 mov %ecx,%eax
113a55: 89 54 24 24 mov %edx,0x24(%esp)
113a59: f7 ee imul %esi
113a5b: 8b 45 d0 mov -0x30(%ebp),%eax
113a5e: c1 f9 1f sar $0x1f,%ecx
113a61: 89 44 24 14 mov %eax,0x14(%esp)
113a65: c1 fa 06 sar $0x6,%edx
113a68: 29 ca sub %ecx,%edx
113a6a: 8b 4d cc mov -0x34(%ebp),%ecx
113a6d: 89 54 24 1c mov %edx,0x1c(%esp)
113a71: 8b 55 d4 mov -0x2c(%ebp),%edx
113a74: 89 c8 mov %ecx,%eax
113a76: 89 54 24 18 mov %edx,0x18(%esp)
113a7a: f7 ee imul %esi
113a7c: 8b 45 c4 mov -0x3c(%ebp),%eax
113a7f: c1 f9 1f sar $0x1f,%ecx
113a82: 89 44 24 08 mov %eax,0x8(%esp)
113a86: 89 d6 mov %edx,%esi
113a88: 8b 55 c8 mov -0x38(%ebp),%edx
113a8b: c1 fe 06 sar $0x6,%esi
113a8e: 29 ce sub %ecx,%esi
113a90: 89 74 24 10 mov %esi,0x10(%esp)
113a94: 89 54 24 0c mov %edx,0xc(%esp)
113a98: ba 20 0a 19 00 mov $0x190a20,%edx
113a9d: 89 54 24 04 mov %edx,0x4(%esp)
113aa1: e8 4a fc fe ff call 1036f0 <rtems_printf>
++id
113aa6: 43 inc %ebx
for (
113aa7: 39 9d 54 ff ff ff cmp %ebx,-0xac(%ebp)
113aad: 0f 82 9c 00 00 00 jb 113b4f <rtems_rate_monotonic_report_statistics_with_plugin+0x25f><== NEVER TAKEN
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
113ab3: 89 1c 24 mov %ebx,(%esp)
113ab6: 8d 45 98 lea -0x68(%ebp),%eax
113ab9: 89 44 24 04 mov %eax,0x4(%esp)
113abd: e8 ae fb ff ff call 113670 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
113ac2: 85 c0 test %eax,%eax
113ac4: 75 e0 jne 113aa6 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b6>
(void) rtems_rate_monotonic_get_status( id, &the_status );
113ac6: 89 1c 24 mov %ebx,(%esp)
113ac9: 8d 85 74 ff ff ff lea -0x8c(%ebp),%eax
rtems_object_get_name( the_status.owner, sizeof(name), name );
113acf: be 05 00 00 00 mov $0x5,%esi
(void) rtems_rate_monotonic_get_status( id, &the_status );
113ad4: 89 44 24 04 mov %eax,0x4(%esp)
113ad8: e8 a3 fc ff ff call 113780 <rtems_rate_monotonic_get_status>
rtems_object_get_name( the_status.owner, sizeof(name), name );
113add: 8d 85 63 ff ff ff lea -0x9d(%ebp),%eax
113ae3: 89 44 24 08 mov %eax,0x8(%esp)
113ae7: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
113aed: 89 74 24 04 mov %esi,0x4(%esp)
113af1: 89 04 24 mov %eax,(%esp)
113af4: e8 d7 01 00 00 call 113cd0 <rtems_object_get_name>
rtems_printf( printer,
113af9: 8b 45 9c mov -0x64(%ebp),%eax
113afc: 89 5c 24 08 mov %ebx,0x8(%esp)
113b00: 89 3c 24 mov %edi,(%esp)
113b03: 89 44 24 14 mov %eax,0x14(%esp)
113b07: 8b 45 98 mov -0x68(%ebp),%eax
113b0a: 89 44 24 10 mov %eax,0x10(%esp)
113b0e: 8d 85 63 ff ff ff lea -0x9d(%ebp),%eax
113b14: 89 44 24 0c mov %eax,0xc(%esp)
113b18: b8 06 09 19 00 mov $0x190906,%eax
113b1d: 89 44 24 04 mov %eax,0x4(%esp)
113b21: e8 ca fb fe ff call 1036f0 <rtems_printf>
if (the_stats.count == 0) {
113b26: 8b 45 98 mov -0x68(%ebp),%eax
113b29: 85 c0 test %eax,%eax
113b2b: 0f 85 3f fe ff ff jne 113970 <rtems_rate_monotonic_report_statistics_with_plugin+0x80><== NEVER TAKEN
rtems_printf( printer, "\n" );
113b31: 89 3c 24 mov %edi,(%esp)
113b34: b9 7c d4 19 00 mov $0x19d47c,%ecx
++id
113b39: 43 inc %ebx
rtems_printf( printer, "\n" );
113b3a: 89 4c 24 04 mov %ecx,0x4(%esp)
113b3e: e8 ad fb fe ff call 1036f0 <rtems_printf>
for (
113b43: 39 9d 54 ff ff ff cmp %ebx,-0xac(%ebp)
113b49: 0f 83 64 ff ff ff jae 113ab3 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c3>
_Timespec_Get_seconds( &wall_average ),
_Timespec_Get_nanoseconds( &wall_average ) / NANOSECONDS_DIVIDER
);
}
}
}
113b4f: 81 c4 dc 00 00 00 add $0xdc,%esp
113b55: 5b pop %ebx
113b56: 5e pop %esi
113b57: 5f pop %edi
113b58: 5d pop %ebp
113b59: c3 ret
113b5a: 90 nop
113b5b: 90 nop
113b5c: 90 nop
113b5d: 90 nop
113b5e: 90 nop
113b5f: 90 nop
00113b60 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
113b60: 55 push %ebp
113b61: 89 e5 mov %esp,%ebp
113b63: 56 push %esi
113b64: 53 push %ebx
113b65: 83 ec 10 sub $0x10,%esp
_RTEMS_Lock_allocator();
113b68: e8 53 0f 00 00 call 114ac0 <_RTEMS_Lock_allocator>
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
maximum_id = _Rate_monotonic_Information.maximum_id;
113b6d: 8b 35 80 18 1a 00 mov 0x1a1880,%esi
id &= ~OBJECTS_INDEX_MASK;
113b73: 89 f3 mov %esi,%ebx
113b75: 81 e3 00 00 ff ff and $0xffff0000,%ebx
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
113b7b: 43 inc %ebx
for (
113b7c: 39 de cmp %ebx,%esi
113b7e: 72 0d jb 113b8d <rtems_rate_monotonic_reset_all_statistics+0x2d><== NEVER TAKEN
id = _Objects_Get_minimum_id( maximum_id ) ;
id <= maximum_id ;
++id
) {
(void) rtems_rate_monotonic_reset_statistics( id );
113b80: 89 1c 24 mov %ebx,(%esp)
++id
113b83: 43 inc %ebx
(void) rtems_rate_monotonic_reset_statistics( id );
113b84: e8 17 00 00 00 call 113ba0 <rtems_rate_monotonic_reset_statistics>
for (
113b89: 39 de cmp %ebx,%esi
113b8b: 73 f3 jae 113b80 <rtems_rate_monotonic_reset_all_statistics+0x20>
}
_Objects_Allocator_unlock();
}
113b8d: 83 c4 10 add $0x10,%esp
113b90: 5b pop %ebx
113b91: 5e pop %esi
113b92: 5d pop %ebp
_RTEMS_Unlock_allocator();
113b93: e9 48 0f 00 00 jmp 114ae0 <_RTEMS_Unlock_allocator>
113b98: 90 nop
113b99: 90 nop
113b9a: 90 nop
113b9b: 90 nop
113b9c: 90 nop
113b9d: 90 nop
113b9e: 90 nop
113b9f: 90 nop
00113ba0 <rtems_rate_monotonic_reset_statistics>:
#include <rtems/rtems/ratemonimpl.h>
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
113ba0: 55 push %ebp
113ba1: 89 e5 mov %esp,%ebp
113ba3: 83 ec 38 sub $0x38,%esp
113ba6: 89 5d f4 mov %ebx,-0xc(%ebp)
_Objects_Get( id, lock_context, &_Rate_monotonic_Information );
113ba9: 8d 45 e4 lea -0x1c(%ebp),%eax
113bac: bb 80 18 1a 00 mov $0x1a1880,%ebx
113bb1: 89 44 24 04 mov %eax,0x4(%esp)
113bb5: 8b 45 08 mov 0x8(%ebp),%eax
113bb8: 89 5c 24 08 mov %ebx,0x8(%esp)
113bbc: 89 75 f8 mov %esi,-0x8(%ebp)
113bbf: 89 7d fc mov %edi,-0x4(%ebp)
113bc2: 89 04 24 mov %eax,(%esp)
113bc5: e8 86 48 00 00 call 118450 <_Objects_Get>
Rate_monotonic_Control *the_period;
ISR_lock_Context lock_context;
the_period = _Rate_monotonic_Get( id, &lock_context );
if ( the_period == NULL ) {
113bca: 85 c0 test %eax,%eax
113bcc: 0f 84 ae 00 00 00 je 113c80 <rtems_rate_monotonic_reset_statistics+0xe0>
)
{
Rate_monotonic_Statistics *statistics;
statistics = &the_period->Statistics;
memset( statistics, 0, sizeof( *statistics ) );
113bd2: 31 f6 xor %esi,%esi
113bd4: a8 01 test $0x1,%al
113bd6: 8d 48 60 lea 0x60(%eax),%ecx
113bd9: bb 38 00 00 00 mov $0x38,%ebx
113bde: 0f 85 bc 00 00 00 jne 113ca0 <rtems_rate_monotonic_reset_statistics+0x100><== NEVER TAKEN
113be4: f6 c1 02 test $0x2,%cl
113be7: 0f 85 d3 00 00 00 jne 113cc0 <rtems_rate_monotonic_reset_statistics+0x120><== NEVER TAKEN
113bed: 89 df mov %ebx,%edi
113bef: 31 d2 xor %edx,%edx
113bf1: 83 e7 f8 and $0xfffffff8,%edi
113bf4: 89 34 11 mov %esi,(%ecx,%edx,1)
113bf7: 89 74 11 04 mov %esi,0x4(%ecx,%edx,1)
113bfb: 83 c2 08 add $0x8,%edx
113bfe: 39 fa cmp %edi,%edx
113c00: 72 f2 jb 113bf4 <rtems_rate_monotonic_reset_statistics+0x54>
113c02: 01 d1 add %edx,%ecx
113c04: f6 c3 04 test $0x4,%bl
113c07: 75 67 jne 113c70 <rtems_rate_monotonic_reset_statistics+0xd0><== NEVER TAKEN
113c09: f6 c3 02 test $0x2,%bl
113c0c: 75 52 jne 113c60 <rtems_rate_monotonic_reset_statistics+0xc0><== NEVER TAKEN
113c0e: f6 c3 01 test $0x1,%bl
113c11: 75 3d jne 113c50 <rtems_rate_monotonic_reset_statistics+0xb0><== NEVER TAKEN
*_time = tstosbt(_ts);
113c13: c7 40 68 01 7d c1 25 movl $0x25c17d01,0x68(%eax)
113c1a: ba 01 7d c1 25 mov $0x25c17d01,%edx
113c1f: b9 ff ff ff 7f mov $0x7fffffff,%ecx
113c24: 89 90 80 00 00 00 mov %edx,0x80(%eax)
113c2a: 89 88 84 00 00 00 mov %ecx,0x84(%eax)
113c30: c7 40 6c ff ff ff 7f movl $0x7fffffff,0x6c(%eax)
_ISR_lock_Release_and_ISR_enable( &the_period->Lock, lock_context );
113c37: ff 75 e4 push -0x1c(%ebp)
113c3a: 9d popf
_Rate_monotonic_Acquire_critical( the_period, &lock_context );
_Rate_monotonic_Reset_statistics( the_period );
_Rate_monotonic_Release( the_period, &lock_context );
return RTEMS_SUCCESSFUL;
}
113c3b: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_SUCCESSFUL;
113c3e: 31 c0 xor %eax,%eax
}
113c40: 8b 75 f8 mov -0x8(%ebp),%esi
113c43: 8b 7d fc mov -0x4(%ebp),%edi
113c46: 89 ec mov %ebp,%esp
113c48: 5d pop %ebp
113c49: c3 ret
113c4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memset( statistics, 0, sizeof( *statistics ) );
113c50: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED
113c53: eb be jmp 113c13 <rtems_rate_monotonic_reset_statistics+0x73><== NOT EXECUTED
113c55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
113c5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
113c60: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
113c65: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
113c68: f6 c3 01 test $0x1,%bl <== NOT EXECUTED
113c6b: 74 a6 je 113c13 <rtems_rate_monotonic_reset_statistics+0x73><== NOT EXECUTED
113c6d: eb e1 jmp 113c50 <rtems_rate_monotonic_reset_statistics+0xb0><== NOT EXECUTED
113c6f: 90 nop <== NOT EXECUTED
113c70: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
113c76: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED
113c79: f6 c3 02 test $0x2,%bl <== NOT EXECUTED
113c7c: 74 90 je 113c0e <rtems_rate_monotonic_reset_statistics+0x6e><== NOT EXECUTED
113c7e: eb e0 jmp 113c60 <rtems_rate_monotonic_reset_statistics+0xc0><== NOT EXECUTED
113c80: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ID;
113c83: b8 04 00 00 00 mov $0x4,%eax
}
113c88: 8b 75 f8 mov -0x8(%ebp),%esi
113c8b: 8b 7d fc mov -0x4(%ebp),%edi
113c8e: 89 ec mov %ebp,%esp
113c90: 5d pop %ebp
113c91: c3 ret
113c92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
113c99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
113ca0: c6 40 60 00 movb $0x0,0x60(%eax) <== NOT EXECUTED
113ca4: 8d 48 61 lea 0x61(%eax),%ecx <== NOT EXECUTED
113ca7: bb 37 00 00 00 mov $0x37,%ebx <== NOT EXECUTED
113cac: e9 33 ff ff ff jmp 113be4 <rtems_rate_monotonic_reset_statistics+0x44><== NOT EXECUTED
113cb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
113cb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
113cbf: 90 nop <== NOT EXECUTED
113cc0: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED
113cc5: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
113cc8: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED
113ccb: e9 1d ff ff ff jmp 113bed <rtems_rate_monotonic_reset_statistics+0x4d><== NOT EXECUTED
00106e60 <rtems_scheduler_ident>:
rtems_status_code rtems_scheduler_ident(
rtems_name name,
rtems_id *id
)
{
106e60: 55 push %ebp
*id = _Scheduler_Build_id( i );
sc = RTEMS_SUCCESSFUL;
}
}
} else {
sc = RTEMS_INVALID_ADDRESS;
106e61: b8 09 00 00 00 mov $0x9,%eax
{
106e66: 89 e5 mov %esp,%ebp
106e68: 53 push %ebx
106e69: 8b 5d 0c mov 0xc(%ebp),%ebx
106e6c: 8b 4d 08 mov 0x8(%ebp),%ecx
if ( id != NULL ) {
106e6f: 85 db test %ebx,%ebx
106e71: 74 34 je 106ea7 <rtems_scheduler_ident+0x47>
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
106e73: 31 d2 xor %edx,%edx
sc = RTEMS_INVALID_NAME;
106e75: b8 03 00 00 00 mov $0x3,%eax
106e7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
106e80: 85 d2 test %edx,%edx
106e82: 75 23 jne 106ea7 <rtems_scheduler_ident+0x47>
106e84: 83 f8 03 cmp $0x3,%eax
106e87: 75 1e jne 106ea7 <rtems_scheduler_ident+0x47> <== NEVER TAKEN
if ( scheduler->name == name ) {
106e89: 39 0d 44 44 12 00 cmp %ecx,0x124444
106e8f: b8 03 00 00 00 mov $0x3,%eax
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
106e94: ba 01 00 00 00 mov $0x1,%edx
if ( scheduler->name == name ) {
106e99: 75 e5 jne 106e80 <rtems_scheduler_ident+0x20>
*id = _Scheduler_Build_id( i );
106e9b: c7 03 01 00 01 0f movl $0xf010001,(%ebx)
sc = RTEMS_SUCCESSFUL;
106ea1: 31 c0 xor %eax,%eax
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
106ea3: 85 d2 test %edx,%edx
106ea5: 74 dd je 106e84 <rtems_scheduler_ident+0x24> <== NEVER TAKEN
}
return sc;
}
106ea7: 5b pop %ebx
106ea8: 5d pop %ebp
106ea9: c3 ret
106eaa: 90 nop
106eab: 90 nop
106eac: 90 nop
106ead: 90 nop
106eae: 90 nop
106eaf: 90 nop
00106dd0 <rtems_scheduler_ident_by_processor_set>:
rtems_status_code rtems_scheduler_ident_by_processor_set(
size_t cpusetsize,
const cpu_set_t *cpuset,
rtems_id *id
)
{
106dd0: 55 push %ebp
106dd1: 89 e5 mov %esp,%ebp
106dd3: 83 ec 28 sub $0x28,%esp
106dd6: 89 5d fc mov %ebx,-0x4(%ebp)
106dd9: 8b 5d 10 mov 0x10(%ebp),%ebx
Processor_mask set;
Processor_mask_Copy_status status;
uint32_t cpu_index;
const Scheduler_Control *scheduler;
if ( id == NULL ) {
106ddc: 85 db test %ebx,%ebx
106dde: 74 60 je 106e40 <rtems_scheduler_ident_by_processor_set+0x70>
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
106de0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
106de3: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
106de7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
106dea: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
106dee: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
106df3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106df7: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED
106dfa: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106dfd: e8 9e 2f 00 00 call 109da0 <_Processor_mask_Copy> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
status = _Processor_mask_From_cpu_set_t( &set, cpusetsize, cpuset );
if ( status == PROCESSOR_MASK_COPY_INVALID_SIZE ) {
106e02: 83 f8 03 cmp $0x3,%eax
106e05: 74 49 je 106e50 <rtems_scheduler_ident_by_processor_set+0x80>
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
106e07: a1 48 4a 12 00 mov 0x124a48,%eax
return (uint32_t) BIT_FLS( CPU_MAXIMUM_PROCESSORS, a );
106e0c: 23 45 f4 and -0xc(%ebp),%eax
106e0f: 74 1f je 106e30 <rtems_scheduler_ident_by_processor_set+0x60>
106e11: 89 04 24 mov %eax,(%esp)
106e14: e8 37 66 01 00 call 11d450 <flsl>
return RTEMS_INVALID_SIZE;
}
_Processor_mask_And( &set, &set, _SMP_Get_online_processors() );
cpu_index = _Processor_mask_Find_last_set( &set );
if ( cpu_index == 0 ) {
106e19: 85 c0 test %eax,%eax
106e1b: 74 13 je 106e30 <rtems_scheduler_ident_by_processor_set+0x60><== NEVER TAKEN
}
#else
_Assert( scheduler != NULL );
#endif
*id = _Scheduler_Build_id( _Scheduler_Get_index( scheduler ) );
106e1d: c7 03 01 00 01 0f movl $0xf010001,(%ebx)
return RTEMS_SUCCESSFUL;
}
106e23: 8b 5d fc mov -0x4(%ebp),%ebx
106e26: 89 ec mov %ebp,%esp
106e28: 5d pop %ebp
return RTEMS_SUCCESSFUL;
106e29: 31 c0 xor %eax,%eax
}
106e2b: c3 ret
106e2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106e30: 8b 5d fc mov -0x4(%ebp),%ebx
106e33: 89 ec mov %ebp,%esp
return RTEMS_INVALID_NAME;
106e35: b8 03 00 00 00 mov $0x3,%eax
}
106e3a: 5d pop %ebp
106e3b: c3 ret
106e3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106e40: 8b 5d fc mov -0x4(%ebp),%ebx
106e43: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ADDRESS;
106e45: b8 09 00 00 00 mov $0x9,%eax
}
106e4a: 5d pop %ebp
106e4b: c3 ret
106e4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106e50: 8b 5d fc mov -0x4(%ebp),%ebx
106e53: 89 ec mov %ebp,%esp
return RTEMS_INVALID_SIZE;
106e55: b8 08 00 00 00 mov $0x8,%eax
}
106e5a: 5d pop %ebp
106e5b: c3 ret
106e5c: 90 nop
106e5d: 90 nop
106e5e: 90 nop
106e5f: 90 nop
00104140 <rtems_semaphore_flush>:
#endif
#include <rtems/rtems/semimpl.h>
rtems_status_code rtems_semaphore_flush( rtems_id id )
{
104140: 55 push %ebp
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (Semaphore_Control *) _Objects_Get(
104141: b9 c0 53 12 00 mov $0x1253c0,%ecx
104146: 89 e5 mov %esp,%ebp
104148: 83 ec 48 sub $0x48,%esp
10414b: 89 5d fc mov %ebx,-0x4(%ebp)
10414e: 8b 45 08 mov 0x8(%ebp),%eax
104151: 8d 5d d4 lea -0x2c(%ebp),%ebx
104154: 89 4c 24 08 mov %ecx,0x8(%esp)
104158: 89 5c 24 04 mov %ebx,0x4(%esp)
10415c: 89 04 24 mov %eax,(%esp)
10415f: e8 0c 1d 00 00 call 105e70 <_Objects_Get>
uintptr_t flags;
Semaphore_Variant variant;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
104164: 85 c0 test %eax,%eax
104166: 74 58 je 1041c0 <rtems_semaphore_flush+0x80>
return (uintptr_t) the_semaphore->Object.Node.previous;
104168: 8b 50 04 mov 0x4(%eax),%edx
if (
10416b: f6 c2 07 test $0x7,%dl
10416e: 74 40 je 1041b0 <rtems_semaphore_flush+0x70>
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
104170: f6 c2 08 test $0x8,%dl
return &_Thread_queue_Operations_FIFO;
104173: b9 b0 05 12 00 mov $0x1205b0,%ecx
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
104178: 74 26 je 1041a0 <rtems_semaphore_flush+0x60> <== NEVER TAKEN
|| variant == SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING
|| variant == SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL
|| variant == SEMAPHORE_VARIANT_SIMPLE_BINARY
|| variant == SEMAPHORE_VARIANT_COUNTING
);
_Thread_queue_Flush_critical(
10417a: 89 5c 24 0c mov %ebx,0xc(%esp)
10417e: ba 60 73 10 00 mov $0x107360,%edx
104183: 83 c0 10 add $0x10,%eax
104186: 89 54 24 08 mov %edx,0x8(%esp)
10418a: 89 4c 24 04 mov %ecx,0x4(%esp)
10418e: 89 04 24 mov %eax,(%esp)
104191: e8 da 31 00 00 call 107370 <_Thread_queue_Flush_critical>
);
break;
}
return RTEMS_SUCCESSFUL;
}
104196: 8b 5d fc mov -0x4(%ebp),%ebx
104199: 89 ec mov %ebp,%esp
10419b: 5d pop %ebp
return RTEMS_SUCCESSFUL;
10419c: 31 c0 xor %eax,%eax
}
10419e: c3 ret
10419f: 90 nop
return &_Thread_queue_Operations_priority;
1041a0: b9 9c 05 12 00 mov $0x12059c,%ecx <== NOT EXECUTED
1041a5: eb d3 jmp 10417a <rtems_semaphore_flush+0x3a> <== NOT EXECUTED
1041a7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1041ae: 66 90 xchg %ax,%ax <== NOT EXECUTED
return &_Thread_queue_Operations_priority_inherit;
1041b0: b9 88 05 12 00 mov $0x120588,%ecx
1041b5: eb c3 jmp 10417a <rtems_semaphore_flush+0x3a>
1041b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1041be: 66 90 xchg %ax,%ax
1041c0: 8b 5d fc mov -0x4(%ebp),%ebx
1041c3: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ID;
1041c5: b8 04 00 00 00 mov $0x4,%eax
}
1041ca: 5d pop %ebp
1041cb: c3 ret
1041cc: 90 nop
1041cd: 90 nop
1041ce: 90 nop
1041cf: 90 nop
0010a7b0 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10a7b0: 55 push %ebp
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (Semaphore_Control *) _Objects_Get(
10a7b1: b9 80 c4 12 00 mov $0x12c480,%ecx
10a7b6: 89 e5 mov %esp,%ebp
10a7b8: 57 push %edi
10a7b9: 56 push %esi
10a7ba: 53 push %ebx
10a7bb: 8d 5d c4 lea -0x3c(%ebp),%ebx
10a7be: 83 ec 6c sub $0x6c,%esp
10a7c1: 89 4c 24 08 mov %ecx,0x8(%esp)
10a7c5: 8b 45 08 mov 0x8(%ebp),%eax
10a7c8: 89 5c 24 04 mov %ebx,0x4(%esp)
10a7cc: 89 04 24 mov %eax,(%esp)
10a7cf: e8 9c 2a 00 00 call 10d270 <_Objects_Get>
Semaphore_Variant variant;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
10a7d4: 85 c0 test %eax,%eax
10a7d6: 0f 84 d4 01 00 00 je 10a9b0 <rtems_semaphore_obtain+0x200>
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
10a7dc: 0f b6 55 0c movzbl 0xc(%ebp),%edx
10a7e0: 8b 35 b8 0f 13 00 mov 0x130fb8,%esi
10a7e6: 80 e2 01 and $0x1,%dl
return RTEMS_INVALID_ID;
#endif
}
executing = _Thread_Executing;
wait = !_Options_Is_no_wait( option_set );
10a7e9: 80 f2 01 xor $0x1,%dl
10a7ec: 0f b6 fa movzbl %dl,%edi
10a7ef: 89 7d b0 mov %edi,-0x50(%ebp)
if ( wait ) {
10a7f2: 75 7c jne 10a870 <rtems_semaphore_obtain+0xc0>
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
10a7f4: c7 45 cc e0 e5 10 00 movl $0x10e5e0,-0x34(%ebp)
return (uintptr_t) the_semaphore->Object.Node.previous;
10a7fb: 8b 78 04 mov 0x4(%eax),%edi
10a7fe: 89 7d ac mov %edi,-0x54(%ebp)
return (Semaphore_Discipline) ( flags & 0x7 );
10a801: 89 f9 mov %edi,%ecx
flags = _Semaphore_Get_flags( the_semaphore );
variant = _Semaphore_Get_variant( flags );
switch ( variant ) {
case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
status = _CORE_recursive_mutex_Seize(
10a803: 8d 78 10 lea 0x10(%eax),%edi
10a806: 83 e1 07 and $0x7,%ecx
10a809: 89 7d b4 mov %edi,-0x4c(%ebp)
switch ( variant ) {
10a80c: 83 f9 01 cmp $0x1,%ecx
10a80f: 0f 84 cb 00 00 00 je 10a8e0 <rtems_semaphore_obtain+0x130>
10a815: 83 f9 02 cmp $0x2,%ecx
10a818: 0f 84 42 01 00 00 je 10a960 <rtems_semaphore_obtain+0x1b0>
10a81e: 85 c9 test %ecx,%ecx
10a820: 74 6e je 10a890 <rtems_semaphore_obtain+0xe0>
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10a822: f6 45 ac 08 testb $0x8,-0x54(%ebp)
return &_Thread_queue_Operations_FIFO;
10a826: b9 18 77 12 00 mov $0x127718,%ecx
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10a82b: 0f 84 1f 01 00 00 je 10a950 <rtems_semaphore_obtain+0x1a0>
)
{
_Assert( _ISR_Get_level() != 0 );
_CORE_semaphore_Acquire_critical( the_semaphore, queue_context );
if ( the_semaphore->count != 0 ) {
10a831: 8b 78 1c mov 0x1c(%eax),%edi
10a834: 85 ff test %edi,%edi
10a836: 0f 85 e4 00 00 00 jne 10a920 <rtems_semaphore_obtain+0x170>
the_semaphore->count -= 1;
_CORE_semaphore_Release( the_semaphore, queue_context );
return STATUS_SUCCESSFUL;
}
if ( !wait ) {
10a83c: 84 d2 test %dl,%dl
10a83e: 0f 84 8c 01 00 00 je 10a9d0 <rtems_semaphore_obtain+0x220>
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Enqueue(
10a844: 89 4c 24 04 mov %ecx,0x4(%esp)
10a848: 8b 45 b4 mov -0x4c(%ebp),%eax
10a84b: 89 5c 24 0c mov %ebx,0xc(%esp)
10a84f: 89 74 24 08 mov %esi,0x8(%esp)
queue_context->thread_state = thread_state;
10a853: c7 45 c8 02 00 00 00 movl $0x2,-0x38(%ebp)
10a85a: 89 04 24 mov %eax,(%esp)
10a85d: e8 be 3d 00 00 call 10e620 <_Thread_queue_Enqueue>
10a862: 0f b6 4e 4c movzbl 0x4c(%esi),%ecx
&queue_context
);
break;
}
return _Status_Get( status );
10a866: eb 61 jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10a868: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a86f: 90 nop
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
10a870: c7 45 cc e0 f4 10 00 movl $0x10f4e0,-0x34(%ebp)
queue_context->Timeout.ticks = ticks;
10a877: 8b 4d 10 mov 0x10(%ebp),%ecx
10a87a: 89 4d d0 mov %ecx,-0x30(%ebp)
}
10a87d: e9 79 ff ff ff jmp 10a7fb <rtems_semaphore_obtain+0x4b>
10a882: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a889: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return the_mutex->Wait_queue.Queue.owner;
10a890: 8b 50 14 mov 0x14(%eax),%edx
if ( owner == NULL ) {
10a893: 85 d2 test %edx,%edx
10a895: 0f 84 45 01 00 00 je 10a9e0 <rtems_semaphore_obtain+0x230>
if ( owner == executing ) {
10a89b: 39 d6 cmp %edx,%esi
10a89d: 0f 84 1d 01 00 00 je 10a9c0 <rtems_semaphore_obtain+0x210>
return _CORE_mutex_Seize_slow(
10a8a3: 89 5c 24 10 mov %ebx,0x10(%esp)
10a8a7: 8b 45 b0 mov -0x50(%ebp),%eax
10a8aa: ba f0 76 12 00 mov $0x1276f0,%edx
10a8af: 89 74 24 08 mov %esi,0x8(%esp)
10a8b3: 89 54 24 04 mov %edx,0x4(%esp)
10a8b7: 89 44 24 0c mov %eax,0xc(%esp)
10a8bb: 8b 45 b4 mov -0x4c(%ebp),%eax
10a8be: 89 04 24 mov %eax,(%esp)
10a8c1: e8 5a 0d 00 00 call 10b620 <_CORE_mutex_Seize_slow>
10a8c6: 0f b6 c8 movzbl %al,%ecx
}
10a8c9: 83 c4 6c add $0x6c,%esp
10a8cc: 89 c8 mov %ecx,%eax
10a8ce: 5b pop %ebx
10a8cf: 5e pop %esi
10a8d0: 5f pop %edi
10a8d1: 5d pop %ebp
10a8d2: c3 ret
10a8d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a8da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return the_mutex->Wait_queue.Queue.owner;
10a8e0: 8b 50 14 mov 0x14(%eax),%edx
_CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context );
owner = _CORE_mutex_Get_owner( &the_mutex->Recursive.Mutex );
if ( owner == NULL ) {
10a8e3: 85 d2 test %edx,%edx
10a8e5: 0f 84 15 01 00 00 je 10aa00 <rtems_semaphore_obtain+0x250>
executing,
queue_context
);
}
if ( owner == executing ) {
10a8eb: 39 d6 cmp %edx,%esi
10a8ed: 74 41 je 10a930 <rtems_semaphore_obtain+0x180> <== NEVER TAKEN
status = ( *nested )( &the_mutex->Recursive );
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
return status;
}
return _CORE_mutex_Seize_slow(
10a8ef: 89 5c 24 10 mov %ebx,0x10(%esp)
10a8f3: 8b 45 b0 mov -0x50(%ebp),%eax
10a8f6: 89 74 24 08 mov %esi,0x8(%esp)
10a8fa: 89 44 24 0c mov %eax,0xc(%esp)
10a8fe: b8 04 77 12 00 mov $0x127704,%eax
10a903: 89 44 24 04 mov %eax,0x4(%esp)
10a907: 8b 45 b4 mov -0x4c(%ebp),%eax
10a90a: 89 04 24 mov %eax,(%esp)
10a90d: e8 0e 0d 00 00 call 10b620 <_CORE_mutex_Seize_slow>
10a912: 83 c4 6c add $0x6c,%esp
10a915: 5b pop %ebx
10a916: 5e pop %esi
10a917: 0f b6 c8 movzbl %al,%ecx
10a91a: 5f pop %edi
10a91b: 89 c8 mov %ecx,%eax
10a91d: 5d pop %ebp
10a91e: c3 ret
10a91f: 90 nop
the_semaphore->count -= 1;
10a920: 4f dec %edi
10a921: 89 78 1c mov %edi,0x1c(%eax)
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10a924: ff 75 c4 push -0x3c(%ebp)
10a927: 9d popf
return STATUS_SUCCESSFUL;
10a928: 31 c9 xor %ecx,%ecx
10a92a: eb 9d jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10a92c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
++the_mutex->nest_level;
10a930: ff 40 1c incl 0x1c(%eax)
10a933: ff 75 c4 push -0x3c(%ebp)
10a936: 9d popf
10a937: 83 c4 6c add $0x6c,%esp
10a93a: 31 c9 xor %ecx,%ecx
10a93c: 5b pop %ebx
10a93d: 89 c8 mov %ecx,%eax
10a93f: 5e pop %esi
10a940: 5f pop %edi
10a941: 5d pop %ebp
10a942: c3 ret
10a943: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a94a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return &_Thread_queue_Operations_priority;
10a950: b9 04 77 12 00 mov $0x127704,%ecx
10a955: e9 d7 fe ff ff jmp 10a831 <rtems_semaphore_obtain+0x81>
10a95a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10a960: f6 45 ac 08 testb $0x8,-0x54(%ebp)
return &_Thread_queue_Operations_FIFO;
10a964: b9 18 77 12 00 mov $0x127718,%ecx
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10a969: 75 05 jne 10a970 <rtems_semaphore_obtain+0x1c0>
return &_Thread_queue_Operations_priority;
10a96b: b9 04 77 12 00 mov $0x127704,%ecx
return the_mutex->Wait_queue.Queue.owner;
10a970: 8b 50 14 mov 0x14(%eax),%edx
if ( owner == NULL ) {
10a973: 85 d2 test %edx,%edx
10a975: 74 79 je 10a9f0 <rtems_semaphore_obtain+0x240>
if ( owner == executing ) {
10a977: 39 d6 cmp %edx,%esi
10a979: 74 b5 je 10a930 <rtems_semaphore_obtain+0x180> <== NEVER TAKEN
return _CORE_mutex_Seize_slow(
10a97b: 89 5c 24 10 mov %ebx,0x10(%esp)
10a97f: 8b 45 b0 mov -0x50(%ebp),%eax
10a982: 89 74 24 08 mov %esi,0x8(%esp)
10a986: 89 4c 24 04 mov %ecx,0x4(%esp)
10a98a: 89 44 24 0c mov %eax,0xc(%esp)
10a98e: 8b 45 b4 mov -0x4c(%ebp),%eax
10a991: 89 04 24 mov %eax,(%esp)
10a994: e8 87 0c 00 00 call 10b620 <_CORE_mutex_Seize_slow>
10a999: 83 c4 6c add $0x6c,%esp
10a99c: 5b pop %ebx
10a99d: 5e pop %esi
10a99e: 0f b6 c8 movzbl %al,%ecx
10a9a1: 5f pop %edi
10a9a2: 89 c8 mov %ecx,%eax
10a9a4: 5d pop %ebp
10a9a5: c3 ret
10a9a6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a9ad: 8d 76 00 lea 0x0(%esi),%esi
10a9b0: 83 c4 6c add $0x6c,%esp
return RTEMS_INVALID_ID;
10a9b3: b9 04 00 00 00 mov $0x4,%ecx
}
10a9b8: 5b pop %ebx
10a9b9: 89 c8 mov %ecx,%eax
10a9bb: 5e pop %esi
10a9bc: 5f pop %edi
10a9bd: 5d pop %ebp
10a9be: c3 ret
10a9bf: 90 nop
++the_mutex->nest_level;
10a9c0: ff 40 1c incl 0x1c(%eax)
10a9c3: ff 75 c4 push -0x3c(%ebp)
10a9c6: 9d popf
return status;
10a9c7: e9 fd fe ff ff jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10a9cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10a9d0: ff 75 c4 push -0x3c(%ebp)
10a9d3: 9d popf
return STATUS_UNSATISFIED;
10a9d4: b9 0d 00 00 00 mov $0xd,%ecx
10a9d9: e9 eb fe ff ff jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10a9de: 66 90 xchg %ax,%ax
the_mutex->Wait_queue.Queue.owner = owner;
10a9e0: 89 70 14 mov %esi,0x14(%eax)
10a9e3: ff 75 c4 push -0x3c(%ebp)
10a9e6: 9d popf
return STATUS_SUCCESSFUL;
10a9e7: e9 dd fe ff ff jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10a9ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
the_mutex->Wait_queue.Queue.owner = owner;
10a9f0: 89 70 14 mov %esi,0x14(%eax)
10a9f3: ff 75 c4 push -0x3c(%ebp)
10a9f6: 9d popf
return STATUS_SUCCESSFUL;
10a9f7: 31 c9 xor %ecx,%ecx
10a9f9: e9 cb fe ff ff jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10a9fe: 66 90 xchg %ax,%ax
queue_context->Priority.update_count = 0;
10aa00: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
10aa07: 8b 56 38 mov 0x38(%esi),%edx
if (
10aa0a: 8b 78 30 mov 0x30(%eax),%edi
10aa0d: 39 7a 14 cmp %edi,0x14(%edx)
10aa10: 8b 4a 18 mov 0x18(%edx),%ecx
10aa13: 1b 48 34 sbb 0x34(%eax),%ecx
10aa16: 72 40 jb 10aa58 <rtems_semaphore_obtain+0x2a8>
the_mutex->Wait_queue.Queue.owner = owner;
10aa18: 89 70 14 mov %esi,0x14(%eax)
_Thread_Priority_add(
10aa1b: 83 c0 20 add $0x20,%eax
10aa1e: 89 44 24 04 mov %eax,0x4(%esp)
10aa22: 89 5c 24 08 mov %ebx,0x8(%esp)
10aa26: 89 34 24 mov %esi,(%esp)
10aa29: e8 72 35 00 00 call 10dfa0 <_Thread_Priority_add>
disable_level = cpu_self->thread_dispatch_disable_level;
10aa2e: a1 b0 0f 13 00 mov 0x130fb0,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10aa33: 40 inc %eax
10aa34: a3 b0 0f 13 00 mov %eax,0x130fb0
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10aa39: ff 75 c4 push -0x3c(%ebp)
10aa3c: 9d popf
_Thread_Priority_update( queue_context );
10aa3d: 89 1c 24 mov %ebx,(%esp)
10aa40: e8 db 36 00 00 call 10e120 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
10aa45: c7 04 24 a0 0f 13 00 movl $0x130fa0,(%esp)
10aa4c: e8 4f 39 00 00 call 10e3a0 <_Thread_Dispatch_enable>
return STATUS_SUCCESSFUL;
10aa51: 31 c9 xor %ecx,%ecx
10aa53: e9 71 fe ff ff jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10aa58: ff 75 c4 push -0x3c(%ebp)
10aa5b: 9d popf
return STATUS_MUTEX_CEILING_VIOLATED;
10aa5c: b9 13 00 00 00 mov $0x13,%ecx
10aa61: e9 63 fe ff ff jmp 10a8c9 <rtems_semaphore_obtain+0x119>
10aa66: 90 nop
10aa67: 90 nop
10aa68: 90 nop
10aa69: 90 nop
10aa6a: 90 nop
10aa6b: 90 nop
10aa6c: 90 nop
10aa6d: 90 nop
10aa6e: 90 nop
10aa6f: 90 nop
0010aa70 <rtems_semaphore_release>:
#include <rtems/rtems/semimpl.h>
#include <rtems/rtems/statusimpl.h>
rtems_status_code rtems_semaphore_release( rtems_id id )
{
10aa70: 55 push %ebp
10aa71: 89 e5 mov %esp,%ebp
10aa73: 83 ec 78 sub $0x78,%esp
10aa76: 89 5d f4 mov %ebx,-0xc(%ebp)
return (Semaphore_Control *) _Objects_Get(
10aa79: 8b 45 08 mov 0x8(%ebp),%eax
10aa7c: bb 80 c4 12 00 mov $0x12c480,%ebx
10aa81: 89 75 f8 mov %esi,-0x8(%ebp)
10aa84: 8d 75 c4 lea -0x3c(%ebp),%esi
10aa87: 89 5c 24 08 mov %ebx,0x8(%esp)
10aa8b: 89 74 24 04 mov %esi,0x4(%esp)
10aa8f: 89 04 24 mov %eax,(%esp)
10aa92: 89 7d fc mov %edi,-0x4(%ebp)
10aa95: e8 d6 27 00 00 call 10d270 <_Objects_Get>
Semaphore_Variant variant;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
10aa9a: 85 c0 test %eax,%eax
10aa9c: 0f 84 4e 02 00 00 je 10acf0 <rtems_semaphore_release+0x280>
10aaa2: 89 c3 mov %eax,%ebx
10aaa4: a1 b8 0f 13 00 mov 0x130fb8,%eax
return (uintptr_t) the_semaphore->Object.Node.previous;
10aaa9: 8b 53 04 mov 0x4(%ebx),%edx
flags = _Semaphore_Get_flags( the_semaphore );
variant = _Semaphore_Get_variant( flags );
switch ( variant ) {
case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
status = _CORE_recursive_mutex_Surrender(
10aaac: 8d 4b 10 lea 0x10(%ebx),%ecx
10aaaf: 89 4d b4 mov %ecx,-0x4c(%ebp)
return (Semaphore_Discipline) ( flags & 0x7 );
10aab2: 89 d7 mov %edx,%edi
10aab4: 83 e7 07 and $0x7,%edi
switch ( variant ) {
10aab7: 83 ff 02 cmp $0x2,%edi
10aaba: 0f 84 e0 01 00 00 je 10aca0 <rtems_semaphore_release+0x230>
10aac0: 0f 87 ba 00 00 00 ja 10ab80 <rtems_semaphore_release+0x110>
10aac6: 85 ff test %edi,%edi
10aac8: 0f 84 32 01 00 00 je 10ac00 <rtems_semaphore_release+0x190>
10aace: 4f dec %edi
10aacf: 90 nop
10aad0: 0f 85 5a 01 00 00 jne 10ac30 <rtems_semaphore_release+0x1c0> <== NEVER TAKEN
Per_CPU_Control *cpu_self;
Thread_Control *new_owner;
_CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context );
if ( !_CORE_mutex_Is_owner( &the_mutex->Recursive.Mutex, executing ) ) {
10aad6: 3b 43 14 cmp 0x14(%ebx),%eax
10aad9: 0f 85 01 01 00 00 jne 10abe0 <rtems_semaphore_release+0x170>
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
10aadf: 8b 7b 1c mov 0x1c(%ebx),%edi
if ( nest_level > 0 ) {
10aae2: 85 ff test %edi,%edi
10aae4: 0f 85 96 01 00 00 jne 10ac80 <rtems_semaphore_release+0x210> <== NEVER TAKEN
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
10aaea: 89 04 24 mov %eax,(%esp)
10aaed: 8d 4b 20 lea 0x20(%ebx),%ecx
10aaf0: 89 74 24 08 mov %esi,0x8(%esp)
10aaf4: 89 4c 24 04 mov %ecx,0x4(%esp)
queue_context->Priority.update_count = 0;
10aaf8: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
10aaff: 89 4d b0 mov %ecx,-0x50(%ebp)
10ab02: e8 19 35 00 00 call 10e020 <_Thread_Priority_remove>
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked(
Thread_queue_Control *the_thread_queue,
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
10ab07: 8b 43 10 mov 0x10(%ebx),%eax
if ( heads != NULL ) {
10ab0a: 85 c0 test %eax,%eax
10ab0c: 0f 84 38 02 00 00 je 10ad4a <rtems_semaphore_release+0x2da>
return ( *operations->first )( heads );
10ab12: 89 04 24 mov %eax,(%esp)
10ab15: ff 15 14 77 12 00 call *0x127714
the_mutex->Wait_queue.Queue.owner = owner;
10ab1b: 89 43 14 mov %eax,0x14(%ebx)
disable_level = cpu_self->thread_dispatch_disable_level;
10ab1e: 8b 1d b0 0f 13 00 mov 0x130fb0,%ebx
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10ab24: 43 inc %ebx
cpu_self = _Thread_Dispatch_disable_critical(
&queue_context->Lock_context.Lock_context
);
if ( new_owner != NULL ) {
10ab25: 85 c0 test %eax,%eax
10ab27: 89 1d b0 0f 13 00 mov %ebx,0x130fb0
10ab2d: 0f 84 29 02 00 00 je 10ad5c <rtems_semaphore_release+0x2ec> <== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
if ( _Objects_Is_local_id( new_owner->Object.id ) )
#endif
{
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
10ab33: 89 04 24 mov %eax,(%esp)
10ab36: 8b 4d b0 mov -0x50(%ebp),%ecx
10ab39: 89 74 24 08 mov %esi,0x8(%esp)
10ab3d: 89 45 b0 mov %eax,-0x50(%ebp)
10ab40: 89 4c 24 04 mov %ecx,0x4(%esp)
10ab44: e8 57 34 00 00 call 10dfa0 <_Thread_Priority_add>
&the_mutex->Priority_ceiling,
queue_context
);
}
_Thread_queue_Extract_critical(
10ab49: 8b 45 b0 mov -0x50(%ebp),%eax
10ab4c: ba 04 77 12 00 mov $0x127704,%edx
10ab51: 89 74 24 0c mov %esi,0xc(%esp)
10ab55: 89 54 24 04 mov %edx,0x4(%esp)
10ab59: 89 44 24 08 mov %eax,0x8(%esp)
10ab5d: 8b 45 b4 mov -0x4c(%ebp),%eax
10ab60: 89 04 24 mov %eax,(%esp)
10ab63: e8 38 3c 00 00 call 10e7a0 <_Thread_queue_Extract_critical>
);
} else {
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
}
_Thread_Priority_update( queue_context );
10ab68: 89 34 24 mov %esi,(%esp)
10ab6b: e8 b0 35 00 00 call 10e120 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
10ab70: c7 04 24 a0 0f 13 00 movl $0x130fa0,(%esp)
10ab77: e8 24 38 00 00 call 10e3a0 <_Thread_Dispatch_enable>
return STATUS_SUCCESSFUL;
10ab7c: eb 6b jmp 10abe9 <rtems_semaphore_release+0x179>
10ab7e: 66 90 xchg %ax,%ax
10ab80: 83 ff 03 cmp $0x3,%edi
10ab83: 0f 85 a7 00 00 00 jne 10ac30 <rtems_semaphore_release+0x1c0>
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10ab89: f6 c2 08 test $0x8,%dl
return &_Thread_queue_Operations_FIFO;
10ab8c: bf 18 77 12 00 mov $0x127718,%edi
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10ab91: 0f 84 a9 01 00 00 je 10ad40 <rtems_semaphore_release+0x2d0>
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
10ab97: 8b 43 10 mov 0x10(%ebx),%eax
if ( heads != NULL ) {
10ab9a: 85 c0 test %eax,%eax
10ab9c: 0f 84 6e 01 00 00 je 10ad10 <rtems_semaphore_release+0x2a0>
return ( *operations->first )( heads );
10aba2: 89 04 24 mov %eax,(%esp)
10aba5: ff 57 10 call *0x10(%edi)
if ( the_thread != NULL ) {
10aba8: 85 c0 test %eax,%eax
10abaa: 0f 84 60 01 00 00 je 10ad10 <rtems_semaphore_release+0x2a0> <== NEVER TAKEN
_Thread_queue_Extract_critical(
10abb0: 89 44 24 08 mov %eax,0x8(%esp)
10abb4: 8b 45 b4 mov -0x4c(%ebp),%eax
10abb7: 89 74 24 0c mov %esi,0xc(%esp)
10abbb: 89 7c 24 04 mov %edi,0x4(%esp)
10abbf: 31 ff xor %edi,%edi
10abc1: 89 04 24 mov %eax,(%esp)
10abc4: e8 d7 3b 00 00 call 10e7a0 <_Thread_queue_Extract_critical>
);
break;
}
return _Status_Get( status );
}
10abc9: 8b 5d f4 mov -0xc(%ebp),%ebx
10abcc: 89 f8 mov %edi,%eax
10abce: 8b 75 f8 mov -0x8(%ebp),%esi
10abd1: 8b 7d fc mov -0x4(%ebp),%edi
10abd4: 89 ec mov %ebp,%esp
10abd6: 5d pop %ebp
10abd7: c3 ret
10abd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10abdf: 90 nop
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10abe0: ff 75 c4 push -0x3c(%ebp)
10abe3: 9d popf
return STATUS_NOT_OWNER;
10abe4: bf 17 00 00 00 mov $0x17,%edi
10abe9: 8b 5d f4 mov -0xc(%ebp),%ebx
10abec: 89 f8 mov %edi,%eax
10abee: 8b 75 f8 mov -0x8(%ebp),%esi
10abf1: 8b 7d fc mov -0x4(%ebp),%edi
10abf4: 89 ec mov %ebp,%esp
10abf6: 5d pop %ebp
10abf7: c3 ret
10abf8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10abff: 90 nop
if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) {
10ac00: 3b 43 14 cmp 0x14(%ebx),%eax
10ac03: 75 db jne 10abe0 <rtems_semaphore_release+0x170>
nest_level = the_mutex->nest_level;
10ac05: 8b 7b 1c mov 0x1c(%ebx),%edi
if ( nest_level > 0 ) {
10ac08: 85 ff test %edi,%edi
10ac0a: 75 74 jne 10ac80 <rtems_semaphore_release+0x210>
the_mutex->Wait_queue.Queue.owner = owner;
10ac0c: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
heads = the_mutex->Mutex.Wait_queue.Queue.heads;
10ac13: 8b 5b 10 mov 0x10(%ebx),%ebx
if ( heads == NULL ) {
10ac16: 85 db test %ebx,%ebx
10ac18: 74 4b je 10ac65 <rtems_semaphore_release+0x1f5>
_Thread_queue_Surrender(
10ac1a: b9 f0 76 12 00 mov $0x1276f0,%ecx
10ac1f: 89 4c 24 10 mov %ecx,0x10(%esp)
10ac23: e9 a9 00 00 00 jmp 10acd1 <rtems_semaphore_release+0x261>
10ac28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ac2f: 90 nop
10ac30: f6 c2 08 test $0x8,%dl
return &_Thread_queue_Operations_FIFO;
10ac33: bf 18 77 12 00 mov $0x127718,%edi
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10ac38: 75 05 jne 10ac3f <rtems_semaphore_release+0x1cf>
return &_Thread_queue_Operations_priority;
10ac3a: bf 04 77 12 00 mov $0x127704,%edi
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
10ac3f: 8b 43 10 mov 0x10(%ebx),%eax
if ( heads != NULL ) {
10ac42: 85 c0 test %eax,%eax
10ac44: 74 0e je 10ac54 <rtems_semaphore_release+0x1e4>
return ( *operations->first )( heads );
10ac46: 89 04 24 mov %eax,(%esp)
10ac49: ff 57 10 call *0x10(%edi)
if ( the_thread != NULL ) {
10ac4c: 85 c0 test %eax,%eax
10ac4e: 0f 85 5c ff ff ff jne 10abb0 <rtems_semaphore_release+0x140> <== ALWAYS TAKEN
if ( the_semaphore->count < maximum_count )
10ac54: 8b 43 1c mov 0x1c(%ebx),%eax
10ac57: bf 0d 00 00 00 mov $0xd,%edi
10ac5c: 83 f8 ff cmp $0xffffffff,%eax
10ac5f: 0f 85 cb 00 00 00 jne 10ad30 <rtems_semaphore_release+0x2c0>
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10ac65: ff 75 c4 push -0x3c(%ebp)
10ac68: 9d popf
10ac69: 8b 5d f4 mov -0xc(%ebp),%ebx
10ac6c: 89 f8 mov %edi,%eax
10ac6e: 8b 75 f8 mov -0x8(%ebp),%esi
10ac71: 8b 7d fc mov -0x4(%ebp),%edi
10ac74: 89 ec mov %ebp,%esp
10ac76: 5d pop %ebp
10ac77: c3 ret
10ac78: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ac7f: 90 nop
the_mutex->nest_level = nest_level - 1;
10ac80: 8d 57 ff lea -0x1(%edi),%edx
10ac83: 89 53 1c mov %edx,0x1c(%ebx)
10ac86: ff 75 c4 push -0x3c(%ebp)
10ac89: 9d popf
return STATUS_SUCCESSFUL;
10ac8a: 31 ff xor %edi,%edi
10ac8c: 8b 5d f4 mov -0xc(%ebp),%ebx
10ac8f: 8b 75 f8 mov -0x8(%ebp),%esi
10ac92: 89 f8 mov %edi,%eax
10ac94: 8b 7d fc mov -0x4(%ebp),%edi
10ac97: 89 ec mov %ebp,%esp
10ac99: 5d pop %ebp
10ac9a: c3 ret
10ac9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10ac9f: 90 nop
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10aca0: f6 c2 08 test $0x8,%dl
return &_Thread_queue_Operations_FIFO;
10aca3: b9 18 77 12 00 mov $0x127718,%ecx
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
10aca8: 75 05 jne 10acaf <rtems_semaphore_release+0x23f>
return &_Thread_queue_Operations_priority;
10acaa: b9 04 77 12 00 mov $0x127704,%ecx
if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) {
10acaf: 3b 43 14 cmp 0x14(%ebx),%eax
10acb2: 0f 85 28 ff ff ff jne 10abe0 <rtems_semaphore_release+0x170> <== NEVER TAKEN
nest_level = the_mutex->nest_level;
10acb8: 8b 7b 1c mov 0x1c(%ebx),%edi
if ( nest_level > 0 ) {
10acbb: 85 ff test %edi,%edi
10acbd: 75 c1 jne 10ac80 <rtems_semaphore_release+0x210> <== NEVER TAKEN
the_mutex->Wait_queue.Queue.owner = owner;
10acbf: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
heads = the_mutex->Mutex.Wait_queue.Queue.heads;
10acc6: 8b 5b 10 mov 0x10(%ebx),%ebx
if ( heads == NULL ) {
10acc9: 85 db test %ebx,%ebx
10accb: 74 98 je 10ac65 <rtems_semaphore_release+0x1f5>
_Thread_queue_Surrender(
10accd: 89 4c 24 10 mov %ecx,0x10(%esp)
10acd1: 89 44 24 08 mov %eax,0x8(%esp)
10acd5: 8b 45 b4 mov -0x4c(%ebp),%eax
10acd8: 89 74 24 0c mov %esi,0xc(%esp)
10acdc: 89 5c 24 04 mov %ebx,0x4(%esp)
10ace0: 89 04 24 mov %eax,(%esp)
10ace3: e8 d8 3b 00 00 call 10e8c0 <_Thread_queue_Surrender>
return STATUS_SUCCESSFUL;
10ace8: e9 fc fe ff ff jmp 10abe9 <rtems_semaphore_release+0x179>
10aced: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_INVALID_ID;
10acf0: bf 04 00 00 00 mov $0x4,%edi
}
10acf5: 8b 5d f4 mov -0xc(%ebp),%ebx
10acf8: 8b 75 f8 mov -0x8(%ebp),%esi
10acfb: 89 f8 mov %edi,%eax
10acfd: 8b 7d fc mov -0x4(%ebp),%edi
10ad00: 89 ec mov %ebp,%esp
10ad02: 5d pop %ebp
10ad03: c3 ret
10ad04: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ad0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10ad0f: 90 nop
10ad10: 8b 43 1c mov 0x1c(%ebx),%eax
10ad13: 85 c0 test %eax,%eax
10ad15: 75 07 jne 10ad1e <rtems_semaphore_release+0x2ae>
the_semaphore->count += 1;
10ad17: c7 43 1c 01 00 00 00 movl $0x1,0x1c(%ebx)
10ad1e: ff 75 c4 push -0x3c(%ebp)
10ad21: 9d popf
10ad22: 31 ff xor %edi,%edi
10ad24: e9 c0 fe ff ff jmp 10abe9 <rtems_semaphore_release+0x179>
10ad29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ad30: 40 inc %eax
10ad31: 31 ff xor %edi,%edi
10ad33: 89 43 1c mov %eax,0x1c(%ebx)
10ad36: e9 2a ff ff ff jmp 10ac65 <rtems_semaphore_release+0x1f5>
10ad3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10ad3f: 90 nop
10ad40: bf 04 77 12 00 mov $0x127704,%edi
10ad45: e9 4d fe ff ff jmp 10ab97 <rtems_semaphore_release+0x127>
the_mutex->Wait_queue.Queue.owner = owner;
10ad4a: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
disable_level = cpu_self->thread_dispatch_disable_level;
10ad51: a1 b0 0f 13 00 mov 0x130fb0,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10ad56: 40 inc %eax
10ad57: a3 b0 0f 13 00 mov %eax,0x130fb0
10ad5c: ff 75 c4 push -0x3c(%ebp)
10ad5f: 9d popf
}
10ad60: e9 03 fe ff ff jmp 10ab68 <rtems_semaphore_release+0xf8>
10ad65: 90 nop
10ad66: 90 nop
10ad67: 90 nop
10ad68: 90 nop
10ad69: 90 nop
10ad6a: 90 nop
10ad6b: 90 nop
10ad6c: 90 nop
10ad6d: 90 nop
10ad6e: 90 nop
10ad6f: 90 nop
00105090 <rtems_semaphore_set_priority>:
rtems_id semaphore_id,
rtems_id scheduler_id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
105090: 55 push %ebp
105091: 89 e5 mov %esp,%ebp
105093: 83 ec 78 sub $0x78,%esp
105096: 89 5d f4 mov %ebx,-0xc(%ebp)
const Scheduler_Control *scheduler;
Semaphore_Control *the_semaphore;
Thread_queue_Context queue_context;
if ( old_priority == NULL ) {
105099: 8b 5d 14 mov 0x14(%ebp),%ebx
{
10509c: 89 75 f8 mov %esi,-0x8(%ebp)
10509f: 89 7d fc mov %edi,-0x4(%ebp)
if ( old_priority == NULL ) {
1050a2: 85 db test %ebx,%ebx
1050a4: 0f 84 86 01 00 00 je 105230 <rtems_semaphore_set_priority+0x1a0>
{
uint32_t index;
index = _Scheduler_Get_index_by_id( id );
if ( index >= _Scheduler_Count ) {
1050aa: 81 7d 0c 01 00 01 0f cmpl $0xf010001,0xc(%ebp)
1050b1: 0f 85 09 01 00 00 jne 1051c0 <rtems_semaphore_set_priority+0x130>
return (Semaphore_Control *) _Objects_Get(
1050b7: 8b 45 08 mov 0x8(%ebp),%eax
1050ba: 8d 5d c4 lea -0x3c(%ebp),%ebx
1050bd: b9 20 66 12 00 mov $0x126620,%ecx
1050c2: 89 4c 24 08 mov %ecx,0x8(%esp)
1050c6: 89 5c 24 04 mov %ebx,0x4(%esp)
1050ca: 89 04 24 mov %eax,(%esp)
1050cd: e8 fe 1e 00 00 call 106fd0 <_Objects_Get>
return RTEMS_INVALID_ID;
}
the_semaphore = _Semaphore_Get( semaphore_id, &queue_context );
if ( the_semaphore == NULL ) {
1050d2: 89 45 b4 mov %eax,-0x4c(%ebp)
1050d5: 85 c0 test %eax,%eax
1050d7: 0f 84 e3 00 00 00 je 1051c0 <rtems_semaphore_set_priority+0x130>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
1050dd: c7 04 24 a0 11 12 00 movl $0x1211a0,(%esp)
1050e4: 8b 45 10 mov 0x10(%ebp),%eax
1050e7: 31 d2 xor %edx,%edx
1050e9: 89 54 24 08 mov %edx,0x8(%esp)
1050ed: 89 55 ac mov %edx,-0x54(%ebp)
1050f0: 89 44 24 04 mov %eax,0x4(%esp)
1050f4: 89 45 a8 mov %eax,-0x58(%ebp)
1050f7: ff 15 bc 11 12 00 call *0x1211bc
if ( new_priority != RTEMS_CURRENT_PRIORITY && !valid ) {
1050fd: 8b 4d b4 mov -0x4c(%ebp),%ecx
105100: 89 55 a4 mov %edx,-0x5c(%ebp)
105103: 8b 55 10 mov 0x10(%ebp),%edx
105106: 89 45 a0 mov %eax,-0x60(%ebp)
105109: 85 d2 test %edx,%edx
10510b: 0f 84 8f 00 00 00 je 1051a0 <rtems_semaphore_set_priority+0x110>
105111: 8b 7d 10 mov 0x10(%ebp),%edi
105114: 39 3d dc 11 12 00 cmp %edi,0x1211dc
10511a: 8b 35 e0 11 12 00 mov 0x1211e0,%esi
105120: 1b 75 ac sbb -0x54(%ebp),%esi
105123: 0f 82 27 01 00 00 jb 105250 <rtems_semaphore_set_priority+0x1c0>
queue_context->Priority.update_count = 0;
105129: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
return (Semaphore_Discipline) ( flags & 0x7 );
105130: 8b 71 04 mov 0x4(%ecx),%esi
105133: 83 e6 07 and $0x7,%esi
switch ( variant ) {
105136: 4e dec %esi
105137: 0f 84 a3 00 00 00 je 1051e0 <rtems_semaphore_set_priority+0x150>
old_priority = 0;
10513d: 31 f6 xor %esi,%esi
10513f: 31 ff xor %edi,%edi
sc = RTEMS_NOT_DEFINED;
105141: b9 0b 00 00 00 mov $0xb,%ecx
105146: 89 4d b4 mov %ecx,-0x4c(%ebp)
disable_level = cpu_self->thread_dispatch_disable_level;
105149: a1 10 a4 12 00 mov 0x12a410,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10514e: 40 inc %eax
10514f: a3 10 a4 12 00 mov %eax,0x12a410
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
105154: ff 75 c4 push -0x3c(%ebp)
105157: 9d popf
_Thread_Priority_update( queue_context );
105158: 89 1c 24 mov %ebx,(%esp)
10515b: e8 10 2d 00 00 call 107e70 <_Thread_Priority_update>
_Thread_Dispatch_enable( cpu_self );
105160: c7 04 24 00 a4 12 00 movl $0x12a400,(%esp)
105167: e8 f4 2e 00 00 call 108060 <_Thread_Dispatch_enable>
return ( *scheduler->Operations.unmap_priority )( scheduler, priority );
10516c: 89 7c 24 08 mov %edi,0x8(%esp)
105170: 89 74 24 04 mov %esi,0x4(%esp)
105174: c7 04 24 a0 11 12 00 movl $0x1211a0,(%esp)
10517b: ff 15 c0 11 12 00 call *0x1211c0
RTEMS_INLINE_ROUTINE rtems_task_priority _RTEMS_Priority_From_core(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return (rtems_task_priority)
105181: 8b 7d 14 mov 0x14(%ebp),%edi
return sc;
105184: 8b 4d b4 mov -0x4c(%ebp),%ecx
105187: 89 07 mov %eax,(%edi)
scheduler,
new_priority,
old_priority,
&queue_context
);
}
105189: 8b 5d f4 mov -0xc(%ebp),%ebx
10518c: 89 c8 mov %ecx,%eax
10518e: 8b 75 f8 mov -0x8(%ebp),%esi
105191: 8b 7d fc mov -0x4(%ebp),%edi
105194: 89 ec mov %ebp,%esp
105196: 5d pop %ebp
105197: c3 ret
105198: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10519f: 90 nop
queue_context->Priority.update_count = 0;
1051a0: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
1051a7: 8b 41 04 mov 0x4(%ecx),%eax
1051aa: 83 e0 07 and $0x7,%eax
switch ( variant ) {
1051ad: 48 dec %eax
1051ae: 75 8d jne 10513d <rtems_semaphore_set_priority+0xad> <== NEVER TAKEN
return the_mutex->Priority_ceiling.priority;
1051b0: 8b 71 30 mov 0x30(%ecx),%esi
1051b3: 8b 79 34 mov 0x34(%ecx),%edi
sc = _Semaphore_Is_scheduler_valid(
1051b6: 31 c9 xor %ecx,%ecx
1051b8: eb 8c jmp 105146 <rtems_semaphore_set_priority+0xb6>
1051ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
1051c0: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ID;
1051c3: b9 04 00 00 00 mov $0x4,%ecx
}
1051c8: 8b 75 f8 mov -0x8(%ebp),%esi
1051cb: 89 c8 mov %ecx,%eax
1051cd: 8b 7d fc mov -0x4(%ebp),%edi
1051d0: 89 ec mov %ebp,%esp
1051d2: 5d pop %ebp
1051d3: c3 ret
1051d4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1051db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1051df: 90 nop
return the_mutex->Wait_queue.Queue.owner;
1051e0: 8b 41 14 mov 0x14(%ecx),%eax
return the_mutex->Priority_ceiling.priority;
1051e3: 8b 71 30 mov 0x30(%ecx),%esi
1051e6: 8b 79 34 mov 0x34(%ecx),%edi
return the_mutex->Wait_queue.Queue.owner;
1051e9: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( owner != NULL ) {
1051ec: 85 c0 test %eax,%eax
1051ee: 74 70 je 105260 <rtems_semaphore_set_priority+0x1d0> <== ALWAYS TAKEN
RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire(
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
1051f0: 9c pushf <== NOT EXECUTED
1051f1: fa cli <== NOT EXECUTED
1051f2: 8f 45 a8 pop -0x58(%ebp) <== NOT EXECUTED
1051f5: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED
1051f8: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED
node->priority = priority;
1051fb: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED
_Thread_Priority_change(
1051fe: 83 c1 20 add $0x20,%ecx <== NOT EXECUTED
105201: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED
105204: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED
_Thread_Priority_changed(
105207: 31 c0 xor %eax,%eax <== NOT EXECUTED
105209: 89 51 14 mov %edx,0x14(%ecx) <== NOT EXECUTED
10520c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
105210: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
105213: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
105217: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10521b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10521e: e8 cd 2b 00 00 call 107df0 <_Thread_Priority_changed> <== NOT EXECUTED
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
_Thread_Wait_release_critical( the_thread, queue_context );
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
105223: ff 75 c4 push -0x3c(%ebp) <== NOT EXECUTED
105226: 9d popf <== NOT EXECUTED
sc = _Semaphore_Is_scheduler_valid(
105227: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
}
105229: e9 18 ff ff ff jmp 105146 <rtems_semaphore_set_priority+0xb6> <== NOT EXECUTED
10522e: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
105230: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ADDRESS;
105233: b9 09 00 00 00 mov $0x9,%ecx
}
105238: 8b 75 f8 mov -0x8(%ebp),%esi
10523b: 89 c8 mov %ecx,%eax
10523d: 8b 7d fc mov -0x4(%ebp),%edi
105240: 89 ec mov %ebp,%esp
105242: 5d pop %ebp
105243: c3 ret
105244: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10524b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10524f: 90 nop
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
105250: ff 75 c4 push -0x3c(%ebp)
105253: 9d popf
return RTEMS_INVALID_PRIORITY;
105254: b9 13 00 00 00 mov $0x13,%ecx
105259: e9 2b ff ff ff jmp 105189 <rtems_semaphore_set_priority+0xf9>
10525e: 66 90 xchg %ax,%ax
the_mutex->Priority_ceiling.priority = priority_ceiling;
105260: 8b 45 a0 mov -0x60(%ebp),%eax
105263: 8b 55 a4 mov -0x5c(%ebp),%edx
105266: 89 41 30 mov %eax,0x30(%ecx)
105269: 89 51 34 mov %edx,0x34(%ecx)
sc = _Semaphore_Is_scheduler_valid(
10526c: 31 c9 xor %ecx,%ecx
10526e: e9 d3 fe ff ff jmp 105146 <rtems_semaphore_set_priority+0xb6>
105273: 90 nop
105274: 90 nop
105275: 90 nop
105276: 90 nop
105277: 90 nop
105278: 90 nop
105279: 90 nop
10527a: 90 nop
10527b: 90 nop
10527c: 90 nop
10527d: 90 nop
10527e: 90 nop
10527f: 90 nop
00104950 <rtems_signal_catch>:
rtems_status_code rtems_signal_catch(
rtems_asr_entry asr_handler,
rtems_mode mode_set
)
{
104950: 55 push %ebp
104951: 89 e5 mov %esp,%ebp
104953: 83 ec 0c sub $0xc,%esp
104956: 89 5d f4 mov %ebx,-0xc(%ebp)
104959: 8b 55 08 mov 0x8(%ebp),%edx
10495c: 89 75 f8 mov %esi,-0x8(%ebp)
10495f: 89 7d fc mov %edi,-0x4(%ebp)
_ISR_lock_ISR_disable( lock_context );
104962: 9c pushf
104963: fa cli
104964: 59 pop %ecx
RTEMS_API_Control *api;
ASR_Information *asr;
ISR_lock_Context lock_context;
executing = _Thread_State_acquire_for_executing( &lock_context );
api = executing->API_Extensions[ THREAD_API_RTEMS ];
104965: a1 58 93 12 00 mov 0x129358,%eax
asr = &api->Signal;
if ( asr_handler != NULL ) {
10496a: 85 d2 test %edx,%edx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10496c: 8b 80 08 01 00 00 mov 0x108(%eax),%eax
if ( asr_handler != NULL ) {
104972: 74 1c je 104990 <rtems_signal_catch+0x40>
asr->mode_set = mode_set;
asr->handler = asr_handler;
104974: 89 50 0c mov %edx,0xc(%eax)
asr->mode_set = mode_set;
104977: 8b 7d 0c mov 0xc(%ebp),%edi
10497a: 89 78 10 mov %edi,0x10(%eax)
_ISR_lock_ISR_enable( lock_context );
10497d: 51 push %ecx
10497e: 9d popf
_ASR_Initialize( asr );
}
_Thread_State_release( executing, &lock_context );
return RTEMS_SUCCESSFUL;
}
10497f: 8b 5d f4 mov -0xc(%ebp),%ebx
104982: 31 c0 xor %eax,%eax
104984: 8b 75 f8 mov -0x8(%ebp),%esi
104987: 8b 7d fc mov -0x4(%ebp),%edi
10498a: 89 ec mov %ebp,%esp
10498c: 5d pop %ebp
10498d: c3 ret
10498e: 66 90 xchg %ax,%ax
memset(asr, 0, sizeof(*asr));
104990: 31 db xor %ebx,%ebx
104992: a8 01 test $0x1,%al
104994: 8d 50 08 lea 0x8(%eax),%edx
104997: be 18 00 00 00 mov $0x18,%esi
10499c: 75 52 jne 1049f0 <rtems_signal_catch+0xa0> <== NEVER TAKEN
10499e: f6 c2 02 test $0x2,%dl
1049a1: 75 5d jne 104a00 <rtems_signal_catch+0xb0> <== NEVER TAKEN
1049a3: 89 f7 mov %esi,%edi
1049a5: 31 c0 xor %eax,%eax
1049a7: 83 e7 f8 and $0xfffffff8,%edi
1049aa: 89 1c 02 mov %ebx,(%edx,%eax,1)
1049ad: 89 5c 02 04 mov %ebx,0x4(%edx,%eax,1)
1049b1: 83 c0 08 add $0x8,%eax
1049b4: 39 f8 cmp %edi,%eax
1049b6: 72 f2 jb 1049aa <rtems_signal_catch+0x5a>
1049b8: 01 c2 add %eax,%edx
1049ba: f7 c6 04 00 00 00 test $0x4,%esi
1049c0: 74 09 je 1049cb <rtems_signal_catch+0x7b> <== ALWAYS TAKEN
1049c2: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
1049c8: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
1049cb: f7 c6 02 00 00 00 test $0x2,%esi
1049d1: 74 08 je 1049db <rtems_signal_catch+0x8b> <== ALWAYS TAKEN
1049d3: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
1049d8: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
1049db: 83 e6 01 and $0x1,%esi
1049de: 74 9d je 10497d <rtems_signal_catch+0x2d> <== ALWAYS TAKEN
1049e0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
}
1049e3: eb 98 jmp 10497d <rtems_signal_catch+0x2d> <== NOT EXECUTED
1049e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1049ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset(asr, 0, sizeof(*asr));
1049f0: c6 40 08 00 movb $0x0,0x8(%eax) <== NOT EXECUTED
1049f4: 8d 50 09 lea 0x9(%eax),%edx <== NOT EXECUTED
1049f7: be 17 00 00 00 mov $0x17,%esi <== NOT EXECUTED
1049fc: eb a0 jmp 10499e <rtems_signal_catch+0x4e> <== NOT EXECUTED
1049fe: 66 90 xchg %ax,%ax <== NOT EXECUTED
104a00: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
104a05: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
104a08: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
104a0b: eb 96 jmp 1049a3 <rtems_signal_catch+0x53> <== NOT EXECUTED
104a0d: 90 nop
104a0e: 90 nop
104a0f: 90 nop
0010c430 <rtems_status_code_to_errno>:
[RTEMS_INTERRUPTED] = EINTR,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_status_code_to_errno(rtems_status_code sc)
{
10c430: 55 push %ebp
10c431: 89 e5 mov %esp,%ebp
10c433: 83 ec 08 sub $0x8,%esp
10c436: 89 5d fc mov %ebx,-0x4(%ebp)
10c439: 8b 45 08 mov 0x8(%ebp),%eax
if (sc == RTEMS_SUCCESSFUL) {
10c43c: 85 c0 test %eax,%eax
10c43e: 75 10 jne 10c450 <rtems_status_code_to_errno+0x20>
return 0;
10c440: 31 c0 xor %eax,%eax
errno = eno;
return -1;
}
}
10c442: 8b 5d fc mov -0x4(%ebp),%ebx
10c445: 89 ec mov %ebp,%esp
10c447: 5d pop %ebp
10c448: c3 ret
10c449: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
10c450: 83 f8 1d cmp $0x1d,%eax
int eno = EINVAL;
10c453: bb 16 00 00 00 mov $0x16,%ebx
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
10c458: 77 07 ja 10c461 <rtems_status_code_to_errno+0x31> <== NEVER TAKEN
eno = status_code_to_errno [sc];
10c45a: 8b 1c 85 60 57 12 00 mov 0x125760(,%eax,4),%ebx
errno = eno;
10c461: e8 2a cc 00 00 call 119090 <__errno>
10c466: 89 18 mov %ebx,(%eax)
return -1;
10c468: b8 ff ff ff ff mov $0xffffffff,%eax
10c46d: eb d3 jmp 10c442 <rtems_status_code_to_errno+0x12>
10c46f: 90 nop
00111180 <rtems_task_delete>:
#include <rtems/score/threadimpl.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
111180: 55 push %ebp
111181: 89 e5 mov %esp,%ebp
111183: 83 ec 48 sub $0x48,%esp
111186: 89 5d fc mov %ebx,-0x4(%ebp)
Thread_Control *the_thread;
Thread_Close_context context;
Thread_Control *executing;
_Thread_queue_Context_initialize( &context.Base );
the_thread = _Thread_Get( id, &context.Base.Lock_context.Lock_context );
111189: 8b 45 08 mov 0x8(%ebp),%eax
11118c: 8d 5d d0 lea -0x30(%ebp),%ebx
11118f: 89 5c 24 04 mov %ebx,0x4(%esp)
111193: 89 04 24 mov %eax,(%esp)
111196: e8 65 9a ff ff call 10ac00 <_Thread_Get>
if ( the_thread == NULL ) {
11119b: 85 c0 test %eax,%eax
11119d: 74 71 je 111210 <rtems_task_delete+0x90>
11119f: 8b 15 58 48 13 00 mov 0x134858,%edx
return RTEMS_INVALID_ID;
}
executing = _Thread_Executing;
if ( the_thread == executing ) {
1111a5: 39 d0 cmp %edx,%eax
1111a7: 74 27 je 1111d0 <rtems_task_delete+0x50>
THREAD_LIFE_TERMINATING | THREAD_LIFE_DETACHED,
NULL
);
_Thread_Dispatch_enable( cpu_self );
} else {
_Thread_Close( the_thread, executing, &context );
1111a9: 89 5c 24 08 mov %ebx,0x8(%esp)
1111ad: 89 04 24 mov %eax,(%esp)
1111b0: 89 54 24 04 mov %edx,0x4(%esp)
1111b4: e8 f7 af ff ff call 10c1b0 <_Thread_Close>
}
return RTEMS_SUCCESSFUL;
}
1111b9: 8b 5d fc mov -0x4(%ebp),%ebx
1111bc: 89 ec mov %ebp,%esp
1111be: 5d pop %ebp
return RTEMS_SUCCESSFUL;
1111bf: 31 c0 xor %eax,%eax
}
1111c1: c3 ret
1111c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1111c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
disable_level = cpu_self->thread_dispatch_disable_level;
1111d0: 8b 15 50 48 13 00 mov 0x134850,%edx
cpu_self->thread_dispatch_disable_level = disable_level + 1;
1111d6: 42 inc %edx
1111d7: 89 15 50 48 13 00 mov %edx,0x134850
_ISR_lock_ISR_enable( &context.Base.Lock_context.Lock_context );
1111dd: ff 75 d0 push -0x30(%ebp)
1111e0: 9d popf
_Thread_Exit(
1111e1: 89 04 24 mov %eax,(%esp)
1111e4: 31 d2 xor %edx,%edx
1111e6: b9 14 00 00 00 mov $0x14,%ecx
1111eb: 89 54 24 08 mov %edx,0x8(%esp)
1111ef: 89 4c 24 04 mov %ecx,0x4(%esp)
1111f3: e8 08 b0 ff ff call 10c200 <_Thread_Exit>
_Thread_Dispatch_enable( cpu_self );
1111f8: c7 04 24 40 48 13 00 movl $0x134840,(%esp)
1111ff: e8 8c 99 ff ff call 10ab90 <_Thread_Dispatch_enable>
}
111204: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
111207: 89 ec mov %ebp,%esp <== NOT EXECUTED
111209: 5d pop %ebp <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
11120a: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
11120c: c3 ret <== NOT EXECUTED
11120d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
111210: 8b 5d fc mov -0x4(%ebp),%ebx
111213: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ID;
111215: b8 04 00 00 00 mov $0x4,%eax
}
11121a: 5d pop %ebp
11121b: c3 ret
11121c: 90 nop
11121d: 90 nop
11121e: 90 nop
11121f: 90 nop
00107b30 <rtems_task_get_affinity>:
rtems_status_code rtems_task_get_affinity(
rtems_id id,
size_t cpusetsize,
cpu_set_t *cpuset
)
{
107b30: 55 push %ebp
107b31: 89 e5 mov %esp,%ebp
107b33: 83 ec 28 sub $0x28,%esp
107b36: 89 5d fc mov %ebx,-0x4(%ebp)
107b39: 8b 5d 10 mov 0x10(%ebp),%ebx
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
bool ok;
if ( cpuset == NULL ) {
107b3c: 85 db test %ebx,%ebx
107b3e: 74 60 je 107ba0 <rtems_task_get_affinity+0x70>
return RTEMS_INVALID_ADDRESS;
}
the_thread = _Thread_Get( id, &lock_context );
107b40: 8d 45 f4 lea -0xc(%ebp),%eax
107b43: 89 44 24 04 mov %eax,0x4(%esp)
107b47: 8b 45 08 mov 0x8(%ebp),%eax
107b4a: 89 04 24 mov %eax,(%esp)
107b4d: e8 ae 39 00 00 call 10b500 <_Thread_Get>
if ( the_thread == NULL ) {
107b52: 85 c0 test %eax,%eax
107b54: 74 5a je 107bb0 <rtems_task_get_affinity+0x80>
}
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_acquire_critical( the_thread, &lock_context );
ok = _Scheduler_Get_affinity(
107b56: 89 5c 24 08 mov %ebx,0x8(%esp)
disable_level = cpu_self->thread_dispatch_disable_level;
107b5a: 8b 15 30 cf 12 00 mov 0x12cf30,%edx
107b60: 89 04 24 mov %eax,(%esp)
cpu_self->thread_dispatch_disable_level = disable_level + 1;
107b63: 42 inc %edx
107b64: 89 15 30 cf 12 00 mov %edx,0x12cf30
107b6a: 8b 55 0c mov 0xc(%ebp),%edx
107b6d: 89 54 24 04 mov %edx,0x4(%esp)
107b71: e8 aa 2a 00 00 call 10a620 <_Scheduler_Get_affinity>
107b76: 88 c3 mov %al,%bl
107b78: ff 75 f4 push -0xc(%ebp)
107b7b: 9d popf
cpusetsize,
cpuset
);
_Thread_State_release( the_thread, &lock_context );
_Thread_Dispatch_enable( cpu_self );
107b7c: c7 04 24 20 cf 12 00 movl $0x12cf20,(%esp)
107b83: e8 08 39 00 00 call 10b490 <_Thread_Dispatch_enable>
return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER;
107b88: 80 fb 01 cmp $0x1,%bl <== NOT EXECUTED
}
107b8b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER;
107b8e: 19 c0 sbb %eax,%eax <== NOT EXECUTED
}
107b90: 89 ec mov %ebp,%esp <== NOT EXECUTED
107b92: 5d pop %ebp <== NOT EXECUTED
return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER;
107b93: 83 e0 0a and $0xa,%eax <== NOT EXECUTED
}
107b96: c3 ret <== NOT EXECUTED
107b97: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107b9e: 66 90 xchg %ax,%ax <== NOT EXECUTED
107ba0: 8b 5d fc mov -0x4(%ebp),%ebx
107ba3: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ADDRESS;
107ba5: b8 09 00 00 00 mov $0x9,%eax
}
107baa: 5d pop %ebp
107bab: c3 ret
107bac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
107bb0: 8b 5d fc mov -0x4(%ebp),%ebx
107bb3: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ID;
107bb5: b8 04 00 00 00 mov $0x4,%eax
}
107bba: 5d pop %ebp
107bbb: c3 ret
107bbc: 90 nop
107bbd: 90 nop
107bbe: 90 nop
107bbf: 90 nop
001072f0 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
1072f0: 55 push %ebp
1072f1: 89 e5 mov %esp,%ebp
1072f3: 57 push %edi
1072f4: 56 push %esi
1072f5: 53 push %ebx
1072f6: 83 ec 2c sub $0x2c,%esp
bool needs_asr_dispatching;
rtems_mode old_mode;
executing = _Thread_Get_executing();
if ( !previous_mode_set )
1072f9: 8b 45 10 mov 0x10(%ebp),%eax
{
1072fc: 8b 7d 0c mov 0xc(%ebp),%edi
1072ff: 8b 1d 98 31 13 00 mov 0x133198,%ebx
if ( !previous_mode_set )
107305: 85 c0 test %eax,%eax
107307: 0f 84 93 01 00 00 je 1074a0 <rtems_task_mode+0x1b0>
*/
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
10730d: 80 bb 81 00 00 00 01 cmpb $0x1,0x81(%ebx)
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
107314: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10731a: 8b b3 08 01 00 00 mov 0x108(%ebx),%esi
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
107320: 19 c9 sbb %ecx,%ecx
107322: 81 e1 00 01 00 00 and $0x100,%ecx
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
107328: 85 c0 test %eax,%eax
10732a: 0f 85 30 01 00 00 jne 107460 <rtems_task_mode+0x170>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
107330: 80 7e 08 01 cmpb $0x1,0x8(%esi)
107334: 89 4d e0 mov %ecx,-0x20(%ebp)
107337: 19 d2 sbb %edx,%edx
107339: 81 e2 00 04 00 00 and $0x400,%edx
10733f: 89 55 e4 mov %edx,-0x1c(%ebp)
old_mode |= _ISR_Get_level();
107342: e8 29 57 00 00 call 10ca70 <_CPU_ISR_Get_level>
107347: 8b 55 e4 mov -0x1c(%ebp),%edx
10734a: 8b 4d e0 mov -0x20(%ebp),%ecx
10734d: 09 c2 or %eax,%edx
10734f: 8b 45 10 mov 0x10(%ebp),%eax
107352: 09 d1 or %edx,%ecx
107354: 89 08 mov %ecx,(%eax)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
preempt_enabled = false;
107356: 31 c0 xor %eax,%eax
if ( mask & RTEMS_PREEMPT_MASK ) {
107358: f7 c7 00 01 00 00 test $0x100,%edi
10735e: 74 1d je 10737d <rtems_task_mode+0x8d>
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (
rtems_mode mode_set
)
{
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
107360: 8b 55 08 mov 0x8(%ebp),%edx
bool is_preempt_enabled = _Modes_Is_preempt( mode_set );
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
107363: 0f b6 83 81 00 00 00 movzbl 0x81(%ebx),%eax
10736a: c1 ea 08 shr $0x8,%edx
10736d: 83 f2 01 xor $0x1,%edx
107370: 34 01 xor $0x1,%al
107372: 80 e2 01 and $0x1,%dl
executing->is_preemptible = is_preempt_enabled;
107375: 88 93 81 00 00 00 mov %dl,0x81(%ebx)
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
10737b: 20 d0 and %dl,%al
}
if ( mask & RTEMS_TIMESLICE_MASK ) {
10737d: f7 c7 00 02 00 00 test $0x200,%edi
107383: 74 24 je 1073a9 <rtems_task_mode+0xb9>
if ( _Modes_Is_timeslice(mode_set) ) {
107385: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
10738c: 0f 84 de 00 00 00 je 107470 <rtems_task_mode+0x180>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
107392: ba 01 00 00 00 mov $0x1,%edx
107397: 89 93 88 00 00 00 mov %edx,0x88(%ebx)
executing->cpu_time_budget =
10739d: 8b 15 e0 95 12 00 mov 0x1295e0,%edx
1073a3: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK ) {
1073a9: f7 c7 01 00 00 00 test $0x1,%edi
1073af: 74 0b je 1073bc <rtems_task_mode+0xcc>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
rtems_mode mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
1073b1: f6 45 08 01 testb $0x1,0x8(%ebp)
1073b5: 0f 84 d5 00 00 00 je 107490 <rtems_task_mode+0x1a0>
1073bb: fa cli
/*
* This is specific to the RTEMS API
*/
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
1073bc: 81 e7 00 04 00 00 and $0x400,%edi
1073c2: 74 7e je 107442 <rtems_task_mode+0x152>
bool is_asr_enabled = !_Modes_Is_asr_disabled( mode_set );
1073c4: 8b 55 08 mov 0x8(%ebp),%edx
1073c7: c1 ea 0a shr $0xa,%edx
1073ca: 83 f2 01 xor $0x1,%edx
1073cd: 80 e2 01 and $0x1,%dl
_ISR_lock_ISR_disable( lock_context );
1073d0: 9c pushf
1073d1: fa cli
1073d2: 59 pop %ecx
_Thread_State_acquire( executing, &lock_context );
if ( is_asr_enabled != asr->is_enabled ) {
1073d3: 3a 56 08 cmp 0x8(%esi),%dl
1073d6: 74 68 je 107440 <rtems_task_mode+0x150>
asr->is_enabled = is_asr_enabled;
1073d8: 88 56 08 mov %dl,0x8(%esi)
RTEMS_INLINE_ROUTINE rtems_signal_set _ASR_Swap_signals( ASR_Information *asr )
{
rtems_signal_set new_signals_posted;
new_signals_posted = asr->signals_pending;
1073db: 8b 56 18 mov 0x18(%esi),%edx
asr->signals_pending = asr->signals_posted;
1073de: 8b 7e 14 mov 0x14(%esi),%edi
asr->signals_posted = new_signals_posted;
1073e1: 89 56 14 mov %edx,0x14(%esi)
if ( _ASR_Swap_signals( asr ) != 0 ) {
1073e4: 85 d2 test %edx,%edx
asr->signals_pending = asr->signals_posted;
1073e6: 89 7e 18 mov %edi,0x18(%esi)
1073e9: 74 55 je 107440 <rtems_task_mode+0x150>
action->handler = handler;
1073eb: c7 46 28 e0 de 10 00 movl $0x10dee0,0x28(%esi)
RTEMS_INLINE_ROUTINE void _Chain_Append_if_is_off_chain_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
if ( _Chain_Is_node_off_chain( the_node ) ) {
1073f2: 8b 56 20 mov 0x20(%esi),%edx
} else {
_Atomic_Fetch_or_ulong( &cpu_target->message, 0, ATOMIC_ORDER_RELEASE );
_CPU_SMP_Send_interrupt( _Per_CPU_Get_index( cpu_target ) );
}
#else
cpu_self->dispatch_necessary = true;
1073f5: b0 01 mov $0x1,%al
1073f7: a2 94 31 13 00 mov %al,0x133194
1073fc: 85 d2 test %edx,%edx
1073fe: 0f 84 ac 00 00 00 je 1074b0 <rtems_task_mode+0x1c0> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
107404: 51 push %ecx <== NOT EXECUTED
107405: 9d popf <== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
107406: a1 90 31 13 00 mov 0x133190,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10740b: 40 inc %eax
10740c: a3 90 31 13 00 mov %eax,0x133190
_ISR_lock_ISR_disable( lock_context );
107411: 9c pushf
107412: fa cli
107413: 5e pop %esi
( *scheduler->Operations.schedule )( scheduler, the_thread );
107414: 89 5c 24 04 mov %ebx,0x4(%esp)
107418: c7 04 24 20 88 12 00 movl $0x128820,(%esp)
10741f: ff 15 28 88 12 00 call *0x128828
_ISR_lock_ISR_enable( lock_context );
107425: 56 push %esi
107426: 9d popf
cpu_self = _Thread_Dispatch_disable();
_Thread_State_acquire( executing, &lock_context );
_Scheduler_Schedule( executing );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_direct( cpu_self );
107427: c7 04 24 80 31 13 00 movl $0x133180,(%esp)
10742e: e8 ad 2e 00 00 call 10a2e0 <_Thread_Dispatch_direct>
}
return RTEMS_SUCCESSFUL;
}
107433: 83 c4 2c add $0x2c,%esp
return RTEMS_SUCCESSFUL;
107436: 31 d2 xor %edx,%edx
}
107438: 5b pop %ebx
107439: 89 d0 mov %edx,%eax
10743b: 5e pop %esi
10743c: 5f pop %edi
10743d: 5d pop %ebp
10743e: c3 ret
10743f: 90 nop
107440: 51 push %ecx
107441: 9d popf
return RTEMS_SUCCESSFUL;
107442: 31 d2 xor %edx,%edx
if ( preempt_enabled || needs_asr_dispatching ) {
107444: 84 c0 test %al,%al
107446: 75 be jne 107406 <rtems_task_mode+0x116>
}
107448: 83 c4 2c add $0x2c,%esp
10744b: 89 d0 mov %edx,%eax
10744d: 5b pop %ebx
10744e: 5e pop %esi
10744f: 5f pop %edi
107450: 5d pop %ebp
107451: c3 ret
107452: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107459: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
old_mode |= RTEMS_TIMESLICE;
107460: 81 c9 00 02 00 00 or $0x200,%ecx
107466: e9 c5 fe ff ff jmp 107330 <rtems_task_mode+0x40>
10746b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10746f: 90 nop
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
107470: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_INTERRUPT_MASK ) {
107472: f7 c7 01 00 00 00 test $0x1,%edi
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
107478: 89 8b 88 00 00 00 mov %ecx,0x88(%ebx)
if ( mask & RTEMS_INTERRUPT_MASK ) {
10747e: 0f 84 38 ff ff ff je 1073bc <rtems_task_mode+0xcc>
107484: e9 28 ff ff ff jmp 1073b1 <rtems_task_mode+0xc1>
107489: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107490: fb sti
107491: e9 26 ff ff ff jmp 1073bc <rtems_task_mode+0xcc>
107496: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10749d: 8d 76 00 lea 0x0(%esi),%esi
}
1074a0: 83 c4 2c add $0x2c,%esp
return RTEMS_INVALID_ADDRESS;
1074a3: ba 09 00 00 00 mov $0x9,%edx
}
1074a8: 5b pop %ebx
1074a9: 89 d0 mov %edx,%eax
1074ab: 5e pop %esi
1074ac: 5f pop %edi
1074ad: 5d pop %ebp
1074ae: c3 ret
1074af: 90 nop
old_last = tail->previous;
1074b0: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax
_Chain_Append_if_is_off_chain_unprotected(
1074b6: 8d 56 20 lea 0x20(%esi),%edx
return &the_chain->Tail.Node;
1074b9: 8d bb d4 00 00 00 lea 0xd4(%ebx),%edi
1074bf: 89 7e 20 mov %edi,0x20(%esi)
tail->previous = the_node;
1074c2: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx)
old_last->next = the_node;
1074c8: 89 10 mov %edx,(%eax)
the_node->previous = old_last;
1074ca: 89 46 24 mov %eax,0x24(%esi)
_ISR_lock_ISR_enable( lock_context );
1074cd: 51 push %ecx
1074ce: 9d popf
if ( preempt_enabled || needs_asr_dispatching ) {
1074cf: e9 32 ff ff ff jmp 107406 <rtems_task_mode+0x116>
1074d4: 90 nop
1074d5: 90 nop
1074d6: 90 nop
1074d7: 90 nop
1074d8: 90 nop
1074d9: 90 nop
1074da: 90 nop
1074db: 90 nop
1074dc: 90 nop
1074dd: 90 nop
1074de: 90 nop
1074df: 90 nop
00104100 <rtems_task_set_affinity>:
rtems_status_code rtems_task_set_affinity(
rtems_id id,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
104100: 55 push %ebp
104101: 89 e5 mov %esp,%ebp
104103: 83 ec 28 sub $0x28,%esp
104106: 89 5d fc mov %ebx,-0x4(%ebp)
104109: 8b 5d 10 mov 0x10(%ebp),%ebx
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
bool ok;
if ( cpuset == NULL ) {
10410c: 85 db test %ebx,%ebx
10410e: 74 60 je 104170 <rtems_task_set_affinity+0x70>
return RTEMS_INVALID_ADDRESS;
}
the_thread = _Thread_Get( id, &lock_context );
104110: 8d 45 f4 lea -0xc(%ebp),%eax
104113: 89 44 24 04 mov %eax,0x4(%esp)
104117: 8b 45 08 mov 0x8(%ebp),%eax
10411a: 89 04 24 mov %eax,(%esp)
10411d: e8 4e 21 00 00 call 106270 <_Thread_Get>
if ( the_thread == NULL ) {
104122: 85 c0 test %eax,%eax
104124: 74 5a je 104180 <rtems_task_set_affinity+0x80>
}
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_acquire_critical( the_thread, &lock_context );
ok = _Scheduler_Set_affinity(
104126: 89 5c 24 08 mov %ebx,0x8(%esp)
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
10412a: 8b 15 30 81 12 00 mov 0x128130,%edx
104130: 89 04 24 mov %eax,(%esp)
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
104133: 42 inc %edx
104134: 89 15 30 81 12 00 mov %edx,0x128130
10413a: 8b 55 0c mov 0xc(%ebp),%edx
10413d: 89 54 24 04 mov %edx,0x4(%esp)
104141: e8 2a 1d 00 00 call 105e70 <_Scheduler_Set_affinity>
104146: 88 c3 mov %al,%bl
Thread_Control *the_thread,
ISR_lock_Context *lock_context
)
{
_Thread_State_release_critical( the_thread, lock_context );
_ISR_lock_ISR_enable( lock_context );
104148: ff 75 f4 push -0xc(%ebp)
10414b: 9d popf
cpusetsize,
cpuset
);
_Thread_State_release( the_thread, &lock_context );
_Thread_Dispatch_enable( cpu_self );
10414c: c7 04 24 20 81 12 00 movl $0x128120,(%esp)
104153: e8 88 20 00 00 call 1061e0 <_Thread_Dispatch_enable>
return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER;
104158: 80 fb 01 cmp $0x1,%bl
}
10415b: 8b 5d fc mov -0x4(%ebp),%ebx
return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER;
10415e: 19 c0 sbb %eax,%eax
}
104160: 89 ec mov %ebp,%esp
104162: 5d pop %ebp
return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER;
104163: 83 e0 0a and $0xa,%eax
}
104166: c3 ret
104167: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10416e: 66 90 xchg %ax,%ax
104170: 8b 5d fc mov -0x4(%ebp),%ebx
104173: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ADDRESS;
104175: b8 09 00 00 00 mov $0x9,%eax
}
10417a: 5d pop %ebp
10417b: c3 ret
10417c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104180: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
104183: 89 ec mov %ebp,%esp <== NOT EXECUTED
return RTEMS_INVALID_ID;
104185: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
}
10418a: 5d pop %ebp <== NOT EXECUTED
10418b: c3 ret <== NOT EXECUTED
10418c: 90 nop
10418d: 90 nop
10418e: 90 nop
10418f: 90 nop
00108010 <rtems_task_set_scheduler>:
rtems_status_code rtems_task_set_scheduler(
rtems_id task_id,
rtems_id scheduler_id,
rtems_task_priority priority
)
{
108010: 55 push %ebp
108011: 89 e5 mov %esp,%ebp
108013: 83 ec 68 sub $0x68,%esp
if ( index >= _Scheduler_Count ) {
108016: 81 7d 0c 01 00 01 0f cmpl $0xf010001,0xc(%ebp)
10801d: 89 5d f4 mov %ebx,-0xc(%ebp)
108020: 8b 5d 10 mov 0x10(%ebp),%ebx
108023: 89 75 f8 mov %esi,-0x8(%ebp)
108026: 89 7d fc mov %edi,-0x4(%ebp)
108029: 0f 85 91 00 00 00 jne 1080c0 <rtems_task_set_scheduler+0xb0>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
10802f: 89 5c 24 04 mov %ebx,0x4(%esp)
*valid = ( priority <= scheduler->maximum_priority );
108033: 31 d2 xor %edx,%edx
108035: 89 54 24 08 mov %edx,0x8(%esp)
108039: c7 04 24 00 44 12 00 movl $0x124400,(%esp)
108040: 89 5d b0 mov %ebx,-0x50(%ebp)
108043: 89 55 b4 mov %edx,-0x4c(%ebp)
108046: ff 15 1c 44 12 00 call *0x12441c
if ( scheduler == NULL ) {
return RTEMS_INVALID_ID;
}
core_priority = _RTEMS_Priority_To_core( scheduler, priority, &valid );
if ( !valid ) {
10804c: 39 1d 3c 44 12 00 cmp %ebx,0x12443c
108052: 89 45 ac mov %eax,-0x54(%ebp)
108055: a1 40 44 12 00 mov 0x124440,%eax
10805a: 89 d6 mov %edx,%esi
10805c: 1b 45 b4 sbb -0x4c(%ebp),%eax
10805f: 72 7f jb 1080e0 <rtems_task_set_scheduler+0xd0>
return RTEMS_INVALID_PRIORITY;
}
_Thread_queue_Context_initialize( &queue_context );
the_thread = _Thread_Get( task_id, &queue_context.Lock_context.Lock_context );
108061: 8d 45 c4 lea -0x3c(%ebp),%eax
108064: 89 44 24 04 mov %eax,0x4(%esp)
108068: 8b 45 08 mov 0x8(%ebp),%eax
10806b: 89 04 24 mov %eax,(%esp)
10806e: e8 8d 34 00 00 call 10b500 <_Thread_Get>
if ( the_thread == NULL ) {
108073: 85 c0 test %eax,%eax
the_thread = _Thread_Get( task_id, &queue_context.Lock_context.Lock_context );
108075: 89 c3 mov %eax,%ebx
if ( the_thread == NULL ) {
108077: 74 47 je 1080c0 <rtems_task_set_scheduler+0xb0>
disable_level = cpu_self->thread_dispatch_disable_level;
108079: a1 30 cf 12 00 mov 0x12cf30,%eax
ISR_lock_Context lock_context;
const Scheduler_Control *old_scheduler;
#endif
if ( the_thread->Wait.queue != NULL ) {
10807e: 8b 53 54 mov 0x54(%ebx),%edx
cpu_self->thread_dispatch_disable_level = disable_level + 1;
108081: 40 inc %eax
108082: a3 30 cf 12 00 mov %eax,0x12cf30
108087: 85 d2 test %edx,%edx
108089: b8 0c 00 00 00 mov $0xc,%eax
10808e: 74 70 je 108100 <rtems_task_set_scheduler+0xf0>
108090: 89 45 b0 mov %eax,-0x50(%ebp)
108093: ff 75 c4 push -0x3c(%ebp)
108096: 9d popf
status = _Scheduler_Set( scheduler, the_thread, core_priority );
_Thread_State_release_critical( the_thread, &state_context );
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Dispatch_enable( cpu_self );
108097: c7 04 24 20 cf 12 00 movl $0x12cf20,(%esp)
10809e: e8 ed 33 00 00 call 10b490 <_Thread_Dispatch_enable>
return _Status_Get( status );
1080a3: 8b 45 b0 mov -0x50(%ebp),%eax
}
1080a6: 8b 5d f4 mov -0xc(%ebp),%ebx
1080a9: 8b 75 f8 mov -0x8(%ebp),%esi
1080ac: 8b 7d fc mov -0x4(%ebp),%edi
1080af: 89 ec mov %ebp,%esp
1080b1: 5d pop %ebp
1080b2: c3 ret
1080b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1080ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1080c0: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ID;
1080c3: b8 04 00 00 00 mov $0x4,%eax
}
1080c8: 8b 75 f8 mov -0x8(%ebp),%esi
1080cb: 8b 7d fc mov -0x4(%ebp),%edi
1080ce: 89 ec mov %ebp,%esp
1080d0: 5d pop %ebp
1080d1: c3 ret
1080d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1080d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1080e0: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_PRIORITY;
1080e3: b8 13 00 00 00 mov $0x13,%eax
}
1080e8: 8b 75 f8 mov -0x8(%ebp),%esi
1080eb: 8b 7d fc mov -0x4(%ebp),%edi
1080ee: 89 ec mov %ebp,%esp
1080f0: 5d pop %ebp
1080f1: c3 ret
1080f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1080f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return the_thread->Scheduler.nodes;
108100: 8b 7b 38 mov 0x38(%ebx),%edi
RTEMS_INLINE_ROUTINE void _Priority_Plain_extract(
Priority_Aggregation *aggregation,
Priority_Node *node
)
{
_RBTree_Extract( &aggregation->Contributors, &node->Node.RBTree );
108103: 8d 43 20 lea 0x20(%ebx),%eax
108106: 89 44 24 04 mov %eax,0x4(%esp)
10810a: 89 45 b0 mov %eax,-0x50(%ebp)
10810d: 8d 4f 1c lea 0x1c(%edi),%ecx
108110: 89 0c 24 mov %ecx,(%esp)
108113: 89 4d a8 mov %ecx,-0x58(%ebp)
108116: e8 45 1d 00 00 call 109e60 <_RBTree_Extract>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_empty(
const RBTree_Control *the_rbtree
)
{
return RB_EMPTY( the_rbtree );
10811b: 8b 47 1c mov 0x1c(%edi),%eax
_Priority_Plain_extract(
&old_scheduler_node->Wait.Priority,
&the_thread->Real_priority
);
if (
10811e: 85 c0 test %eax,%eax
108120: 75 6e jne 108190 <rtems_task_set_scheduler+0x180> <== NEVER TAKEN
_Thread_Scheduler_process_requests( the_thread );
#else
new_scheduler_node = old_scheduler_node;
#endif
the_thread->Start.initial_priority = priority;
108122: 89 b3 b8 00 00 00 mov %esi,0xb8(%ebx)
108128: 8b 45 ac mov -0x54(%ebp),%eax
node->priority = priority;
10812b: 89 73 34 mov %esi,0x34(%ebx)
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
_Assert( _RBTree_Is_node_off_tree( the_node ) );
RB_ROOT( the_rbtree ) = the_node;
10812e: 8b 4d b0 mov -0x50(%ebp),%ecx
108131: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
108137: 89 43 30 mov %eax,0x30(%ebx)
node->priority = priority;
10813a: 89 47 14 mov %eax,0x14(%edi)
unsigned int seq;
seq = _SMP_sequence_lock_Write_begin( &node->Priority.Lock );
#endif
new_priority |= ( prepend_it ? 0 : SCHEDULER_PRIORITY_APPEND_FLAG );
10813d: 83 c8 01 or $0x1,%eax
108140: 89 77 18 mov %esi,0x18(%edi)
108143: 89 4f 1c mov %ecx,0x1c(%edi)
RB_PARENT( the_node, Node ) = NULL;
108146: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
RB_LEFT( the_node, Node ) = NULL;
10814d: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
RB_RIGHT( the_node, Node ) = NULL;
108154: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
RB_COLOR( the_node, Node ) = RB_BLACK;
10815b: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx)
108162: 89 47 28 mov %eax,0x28(%edi)
( *scheduler->Operations.update_priority )(
108165: 8b 43 38 mov 0x38(%ebx),%eax
108168: 89 77 2c mov %esi,0x2c(%edi)
10816b: 89 5c 24 04 mov %ebx,0x4(%esp)
10816f: c7 04 24 00 44 12 00 movl $0x124400,(%esp)
108176: 89 44 24 08 mov %eax,0x8(%esp)
10817a: ff 15 18 44 12 00 call *0x124418
}
#endif
_Scheduler_Node_set_priority( new_scheduler_node, priority, false );
_Scheduler_Update_priority( the_thread );
return STATUS_SUCCESSFUL;
108180: 31 c0 xor %eax,%eax
108182: e9 09 ff ff ff jmp 108090 <rtems_task_set_scheduler+0x80>
108187: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10818e: 66 90 xchg %ax,%ax
_Priority_Plain_insert(
108190: 8b 7b 30 mov 0x30(%ebx),%edi <== NOT EXECUTED
108193: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED
link = _RBTree_Root_reference( the_rbtree );
parent = NULL;
is_new_minimum = true;
while ( *link != NULL ) {
108196: eb 0a jmp 1081a2 <rtems_task_set_scheduler+0x192> <== NOT EXECUTED
108198: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10819f: 90 nop <== NOT EXECUTED
1081a0: 89 d0 mov %edx,%eax <== NOT EXECUTED
parent = *link;
if ( ( *less )( key, parent ) ) {
1081a2: 3b 78 10 cmp 0x10(%eax),%edi <== NOT EXECUTED
1081a5: 89 f1 mov %esi,%ecx <== NOT EXECUTED
1081a7: 1b 48 14 sbb 0x14(%eax),%ecx <== NOT EXECUTED
return &RB_LEFT( the_node, Node );
1081aa: 89 c1 mov %eax,%ecx <== NOT EXECUTED
if ( ( *less )( key, parent ) ) {
1081ac: 72 03 jb 1081b1 <rtems_task_set_scheduler+0x1a1> <== NOT EXECUTED
return &RB_RIGHT( the_node, Node );
1081ae: 8d 48 04 lea 0x4(%eax),%ecx <== NOT EXECUTED
while ( *link != NULL ) {
1081b1: 8b 11 mov (%ecx),%edx <== NOT EXECUTED
1081b3: 85 d2 test %edx,%edx <== NOT EXECUTED
1081b5: 75 e9 jne 1081a0 <rtems_task_set_scheduler+0x190> <== NOT EXECUTED
RB_SET( child, parent, Node );
1081b7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
*link = child;
1081ba: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
RB_SET( child, parent, Node );
1081bd: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED
1081c4: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
1081cb: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) <== NOT EXECUTED
*link = child;
1081d2: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
is_new_minimum = false;
}
}
_RBTree_Add_child( the_node, parent, link );
_RBTree_Insert_color( the_rbtree, the_node );
1081d4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1081d8: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED
1081db: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1081de: e8 0d 21 00 00 call 10a2f0 <_RBTree_Insert_color> <== NOT EXECUTED
return STATUS_RESOURCE_IN_USE;
1081e3: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED
1081e8: e9 a3 fe ff ff jmp 108090 <rtems_task_set_scheduler+0x80> <== NOT EXECUTED
1081ed: 90 nop
1081ee: 90 nop
1081ef: 90 nop
00107cd0 <rtems_task_suspend>:
#include <rtems/score/threadimpl.h>
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
107cd0: 55 push %ebp
107cd1: 89 e5 mov %esp,%ebp
107cd3: 83 ec 28 sub $0x28,%esp
107cd6: 89 5d fc mov %ebx,-0x4(%ebp)
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
States_Control previous_state;
the_thread = _Thread_Get( id, &lock_context );
107cd9: 8d 45 f4 lea -0xc(%ebp),%eax
107cdc: 89 44 24 04 mov %eax,0x4(%esp)
107ce0: 8b 45 08 mov 0x8(%ebp),%eax
107ce3: 89 04 24 mov %eax,(%esp)
107ce6: e8 a5 2a 00 00 call 10a790 <_Thread_Get>
if ( the_thread == NULL ) {
107ceb: 85 c0 test %eax,%eax
107ced: 74 51 je 107d40 <rtems_task_suspend+0x70> <== NEVER TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
107cef: 8b 15 30 d3 12 00 mov 0x12d330,%edx
cpu_self->thread_dispatch_disable_level = disable_level + 1;
107cf5: 42 inc %edx
107cf6: 89 15 30 d3 12 00 mov %edx,0x12d330
return RTEMS_INVALID_ID;
#endif
}
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_ISR_lock_ISR_enable( &lock_context );
107cfc: ff 75 f4 push -0xc(%ebp)
107cff: 9d popf
previous_state = _Thread_Set_state( the_thread, STATES_SUSPENDED );
107d00: 89 04 24 mov %eax,(%esp)
107d03: ba 00 80 00 00 mov $0x8000,%edx
107d08: 89 54 24 04 mov %edx,0x4(%esp)
107d0c: e8 9f 43 00 00 call 10c0b0 <_Thread_Set_state>
_Thread_Dispatch_enable( cpu_self );
107d11: c7 04 24 20 d3 12 00 movl $0x12d320,(%esp)
previous_state = _Thread_Set_state( the_thread, STATES_SUSPENDED );
107d18: 89 c3 mov %eax,%ebx
_Thread_Dispatch_enable( cpu_self );
107d1a: e8 01 2a 00 00 call 10a720 <_Thread_Dispatch_enable>
return _States_Is_suspended( previous_state ) ?
RTEMS_ALREADY_SUSPENDED : RTEMS_SUCCESSFUL;
107d1f: 89 d8 mov %ebx,%eax
107d21: 25 00 80 00 00 and $0x8000,%eax
107d26: 74 05 je 107d2d <rtems_task_suspend+0x5d>
107d28: b8 0f 00 00 00 mov $0xf,%eax
}
107d2d: 8b 5d fc mov -0x4(%ebp),%ebx
107d30: 89 ec mov %ebp,%esp
107d32: 5d pop %ebp
107d33: c3 ret
107d34: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107d3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
107d3f: 90 nop
107d40: 8b 5d fc mov -0x4(%ebp),%ebx
107d43: 89 ec mov %ebp,%esp
return RTEMS_INVALID_ID;
107d45: b8 04 00 00 00 mov $0x4,%eax
}
107d4a: 5d pop %ebp
107d4b: c3 ret
107d4c: 90 nop
107d4d: 90 nop
107d4e: 90 nop
107d4f: 90 nop