分析oops的機器碼
內核2.6.39.4多個USB插拔時出現oops，死在機器碼49 f2 8b 5d d4 89 f2 <8b> 33 89 75 d4 0f 18 06 90中。 使用文章oops調試的方法，製作了兩個文件：
- get_next_timer_interrupt.gdb
(gdb) disassemble get_next_timer_interrupt
Dump of assembler code for function get_next_timer_interrupt:
0xc103c738 <get_next_timer_interrupt+0>: push %ebp
0xc103c739 <get_next_timer_interrupt+1>: mov %esp,%ebp
0xc103c73b <get_next_timer_interrupt+3>: push %edi
0xc103c73c <get_next_timer_interrupt+4>: push %esi
0xc103c73d <get_next_timer_interrupt+5>: push %ebx
0xc103c73e <get_next_timer_interrupt+6>: sub $0x2c,%esp
0xc103c741 <get_next_timer_interrupt+9>: mov %eax,-0x20(%ebp)
0xc103c744 <get_next_timer_interrupt+12>: mov %fs:0xc1798d44,%ebx
0xc103c74b <get_next_timer_interrupt+19>: call 0xc11d4410 <debug_smp_processor_id>
0xc103c750 <get_next_timer_interrupt+24>: mov 0xc14d8cac,%edx
0xc103c756 <get_next_timer_interrupt+30>: bt %eax,(%edx)
0xc103c759 <get_next_timer_interrupt+33>: sbb %eax,%eax
0xc103c75b <get_next_timer_interrupt+35>: test %eax,%eax
0xc103c75d <get_next_timer_interrupt+37>: jne 0xc103c76b <get_next_timer_interrupt+51>
0xc103c75f <get_next_timer_interrupt+39>: addl $0x3fffffff,-0x20(%ebp)
0xc103c766 <get_next_timer_interrupt+46>: jmp 0xc103c8fc <get_next_timer_interrupt+452>
0xc103c76b <get_next_timer_interrupt+51>: mov %ebx,%eax
0xc103c76d <get_next_timer_interrupt+53>: call 0xc14ce789 <_raw_spin_lock>
0xc103c772 <get_next_timer_interrupt+58>: mov 0x8(%ebx),%eax
0xc103c775 <get_next_timer_interrupt+61>: cmp 0xc(%ebx),%eax
0xc103c778 <get_next_timer_interrupt+64>: js 0xc103c890 <get_next_timer_interrupt+344>
0xc103c77e <get_next_timer_interrupt+70>: movzbl %al,%ecx
0xc103c781 <get_next_timer_interrupt+73>: mov %ecx,%esi
0xc103c783 <get_next_timer_interrupt+75>: lea 0x10(%ebx,%esi,8),%edi
0xc103c787 <get_next_timer_interrupt+79>: mov 0x10(%ebx,%esi,8),%edx
0xc103c78b <get_next_timer_interrupt+83>: mov %edi,-0x24(%ebp)
0xc103c78e <get_next_timer_interrupt+86>: jmp 0xc103c7b0 <get_next_timer_interrupt+120>
0xc103c790 <get_next_timer_interrupt+88>: testb $0x1,0xc(%edx)
0xc103c794 <get_next_timer_interrupt+92>: je 0xc103c79a <get_next_timer_interrupt+98>
0xc103c796 <get_next_timer_interrupt+94>: mov %edi,%edx
0xc103c798 <get_next_timer_interrupt+96>: jmp 0xc103c7b0 <get_next_timer_interrupt+120>
0xc103c79a <get_next_timer_interrupt+98>: cmp %ecx,%esi
0xc103c79c <get_next_timer_interrupt+100>: mov 0x8(%edx),%edx
0xc103c79f <get_next_timer_interrupt+103>: jl 0xc103c7a9 <get_next_timer_interrupt+113>
0xc103c7a1 <get_next_timer_interrupt+105>: test %ecx,%ecx
0xc103c7a3 <get_next_timer_interrupt+107>: jne 0xc103c88d <get_next_timer_interrupt+341>
0xc103c7a9 <get_next_timer_interrupt+113>: mov $0x1,%edi
0xc103c7ae <get_next_timer_interrupt+118>: jmp 0xc103c7ce <get_next_timer_interrupt+150>
0xc103c7b0 <get_next_timer_interrupt+120>: mov (%edx),%edi
0xc103c7b2 <get_next_timer_interrupt+122>: lea 0x0(%esi,%eiz,1),%esi
0xc103c7b6 <get_next_timer_interrupt+126>: cmp -0x24(%ebp),%edx
0xc103c7b9 <get_next_timer_interrupt+129>: jne 0xc103c790 <get_next_timer_interrupt+88>
0xc103c7bb <get_next_timer_interrupt+131>: inc %esi
0xc103c7bc <get_next_timer_interrupt+132>: and $0xff,%esi
0xc103c7c2 <get_next_timer_interrupt+138>: cmp %ecx,%esi
0xc103c7c4 <get_next_timer_interrupt+140>: jne 0xc103c783 <get_next_timer_interrupt+75>
0xc103c7c6 <get_next_timer_interrupt+142>: lea 0x3fffffff(%eax),%edx
0xc103c7cc <get_next_timer_interrupt+148>: xor %edi,%edi
0xc103c7ce <get_next_timer_interrupt+150>: test %ecx,%ecx
0xc103c7d0 <get_next_timer_interrupt+152>: je 0xc103c7d9 <get_next_timer_interrupt+161>
0xc103c7d2 <get_next_timer_interrupt+154>: add $0x100,%eax
0xc103c7d7 <get_next_timer_interrupt+159>: sub %ecx,%eax
0xc103c7d9 <get_next_timer_interrupt+161>: shr $0x8,%eax
0xc103c7dc <get_next_timer_interrupt+164>: mov %eax,-0x24(%ebp)
0xc103c7df <get_next_timer_interrupt+167>: lea 0x810(%ebx),%eax
0xc103c7e5 <get_next_timer_interrupt+173>: mov %eax,-0x1c(%ebp)
0xc103c7e8 <get_next_timer_interrupt+176>: lea 0xa10(%ebx),%eax
0xc103c7ee <get_next_timer_interrupt+182>: mov %eax,-0x18(%ebp)
0xc103c7f1 <get_next_timer_interrupt+185>: lea 0xc10(%ebx),%eax
0xc103c7f7 <get_next_timer_interrupt+191>: mov %eax,-0x14(%ebp)
0xc103c7fa <get_next_timer_interrupt+194>: lea 0xe10(%ebx),%eax
0xc103c800 <get_next_timer_interrupt+200>: mov %eax,-0x10(%ebp)
0xc103c803 <get_next_timer_interrupt+203>: movl $0x0,-0x28(%ebp)
0xc103c80a <get_next_timer_interrupt+210>: mov %ebx,-0x34(%ebp)
0xc103c80d <get_next_timer_interrupt+213>: mov -0x28(%ebp),%eax
0xc103c810 <get_next_timer_interrupt+216>: mov -0x24(%ebp),%ecx
0xc103c813 <get_next_timer_interrupt+219>: mov -0x1c(%ebp,%eax,4),%eax
0xc103c817 <get_next_timer_interrupt+223>: and $0x3f,%ecx
0xc103c81a <get_next_timer_interrupt+226>: mov %eax,-0x30(%ebp)
0xc103c81d <get_next_timer_interrupt+229>: mov %ecx,%eax
0xc103c81f <get_next_timer_interrupt+231>: mov -0x30(%ebp),%esi
0xc103c822 <get_next_timer_interrupt+234>: mov (%esi,%eax,8),%ebx
0xc103c825 <get_next_timer_interrupt+237>: lea (%esi,%eax,8),%esi
0xc103c828 <get_next_timer_interrupt+240>: mov %esi,-0x38(%ebp)
0xc103c82b <get_next_timer_interrupt+243>: jmp 0xc103c847 <get_next_timer_interrupt+271>
0xc103c82d <get_next_timer_interrupt+245>: testb $0x1,0xc(%ebx)
0xc103c831 <get_next_timer_interrupt+249>: mov %edx,%esi
0xc103c833 <get_next_timer_interrupt+251>: jne 0xc103c842 <get_next_timer_interrupt+266>
0xc103c835 <get_next_timer_interrupt+253>: mov 0x8(%ebx),%esi
0xc103c838 <get_next_timer_interrupt+256>: mov $0x1,%edi
0xc103c83d <get_next_timer_interrupt+261>: cmp %edx,%esi
0xc103c83f <get_next_timer_interrupt+263>: cmovns %edx,%esi
0xc103c842 <get_next_timer_interrupt+266>: mov -0x2c(%ebp),%ebx
0xc103c845 <get_next_timer_interrupt+269>: mov %esi,%edx
0xc103c847 <get_next_timer_interrupt+271>: mov (%ebx),%esi
0xc103c849 <get_next_timer_interrupt+273>: mov %esi,-0x2c(%ebp)
0xc103c84c <get_next_timer_interrupt+276>: lea 0x0(%esi,%eiz,1),%esi
0xc103c850 <get_next_timer_interrupt+280>: cmp -0x38(%ebp),%ebx
0xc103c853 <get_next_timer_interrupt+283>: jne 0xc103c82d <get_next_timer_interrupt+245>
0xc103c855 <get_next_timer_interrupt+285>: test %edi,%edi
0xc103c857 <get_next_timer_interrupt+287>: je 0xc103c868 <get_next_timer_interrupt+304>
0xc103c859 <get_next_timer_interrupt+289>: cmp %ecx,%eax
0xc103c85b <get_next_timer_interrupt+291>: jl 0xc103c861 <get_next_timer_interrupt+297>
0xc103c85d <get_next_timer_interrupt+293>: test %ecx,%ecx
0xc103c85f <get_next_timer_interrupt+295>: jne 0xc103c88a <get_next_timer_interrupt+338>
0xc103c861 <get_next_timer_interrupt+297>: mov $0x1,%edi
0xc103c866 <get_next_timer_interrupt+302>: jmp 0xc103c870 <get_next_timer_interrupt+312>
0xc103c868 <get_next_timer_interrupt+304>: inc %eax
0xc103c869 <get_next_timer_interrupt+305>: and $0x3f,%eax
0xc103c86c <get_next_timer_interrupt+308>: cmp %ecx,%eax
0xc103c86e <get_next_timer_interrupt+310>: jne 0xc103c81f <get_next_timer_interrupt+231>
0xc103c870 <get_next_timer_interrupt+312>: test %ecx,%ecx
0xc103c872 <get_next_timer_interrupt+314>: je 0xc103c87b <get_next_timer_interrupt+323>
0xc103c874 <get_next_timer_interrupt+316>: addl $0x40,-0x24(%ebp)
0xc103c878 <get_next_timer_interrupt+320>: sub %ecx,-0x24(%ebp)
0xc103c87b <get_next_timer_interrupt+323>: incl -0x28(%ebp)
0xc103c87e <get_next_timer_interrupt+326>: cmpl $0x4,-0x28(%ebp)
0xc103c882 <get_next_timer_interrupt+330>: je 0xc103c88a <get_next_timer_interrupt+338>
0xc103c884 <get_next_timer_interrupt+332>: shrl $0x6,-0x24(%ebp)
0xc103c888 <get_next_timer_interrupt+336>: jmp 0xc103c80d <get_next_timer_interrupt+213>
0xc103c88a <get_next_timer_interrupt+338>: mov -0x34(%ebp),%ebx
0xc103c88d <get_next_timer_interrupt+341>: mov %edx,0xc(%ebx)
0xc103c890 <get_next_timer_interrupt+344>: mov 0xc(%ebx),%esi
0xc103c893 <get_next_timer_interrupt+347>: mov %ebx,%eax
0xc103c895 <get_next_timer_interrupt+349>: call 0xc14ce8e2 <_raw_spin_unlock>
0xc103c89a <get_next_timer_interrupt+354>: cmp %esi,-0x20(%ebp)
0xc103c89d <get_next_timer_interrupt+357>: jns 0xc103c8fc <get_next_timer_interrupt+452>
0xc103c89f <get_next_timer_interrupt+359>: call 0xc104b26f <hrtimer_get_next_event>
0xc103c8a4 <get_next_timer_interrupt+364>: cmp $0x7fffffff,%edx
0xc103c8aa <get_next_timer_interrupt+370>: jne 0xc103c8b3 <get_next_timer_interrupt+379>
0xc103c8ac <get_next_timer_interrupt+372>: cmp $0xffffffff,%eax
0xc103c8af <get_next_timer_interrupt+375>: jne 0xc103c8c4 <get_next_timer_interrupt+396>
0xc103c8b1 <get_next_timer_interrupt+377>: jmp 0xc103c8f9 <get_next_timer_interrupt+449>
0xc103c8b3 <get_next_timer_interrupt+379>: cmp $0x0,%edx
0xc103c8b6 <get_next_timer_interrupt+382>: jg 0xc103c8c4 <get_next_timer_interrupt+396>
0xc103c8b8 <get_next_timer_interrupt+384>: jl 0xc103c8bf <get_next_timer_interrupt+391>
0xc103c8ba <get_next_timer_interrupt+386>: cmp $0x0,%eax
0xc103c8bd <get_next_timer_interrupt+389>: ja 0xc103c8c4 <get_next_timer_interrupt+396>
0xc103c8bf <get_next_timer_interrupt+391>: incl -0x20(%ebp)
0xc103c8c2 <get_next_timer_interrupt+394>: jmp 0xc103c8fc <get_next_timer_interrupt+452>
0xc103c8c4 <get_next_timer_interrupt+396>: call 0xc10359c4 <ns_to_timespec>
0xc103c8c9 <get_next_timer_interrupt+401>: mov %eax,-0x1c(%ebp)
0xc103c8cc <get_next_timer_interrupt+404>: lea -0x1c(%ebp),%eax
0xc103c8cf <get_next_timer_interrupt+407>: mov %edx,-0x18(%ebp)
0xc103c8d2 <get_next_timer_interrupt+410>: call 0xc10357b9 <timespec_to_jiffies>
0xc103c8d7 <get_next_timer_interrupt+415>: cmp $0x3fffffff,%eax
0xc103c8dc <get_next_timer_interrupt+420>: jbe 0xc103c8e5 <get_next_timer_interrupt+429>
0xc103c8de <get_next_timer_interrupt+422>: mov $0x3fffffff,%eax
0xc103c8e3 <get_next_timer_interrupt+427>: jmp 0xc103c8ef <get_next_timer_interrupt+439>
0xc103c8e5 <get_next_timer_interrupt+429>: test %eax,%eax
0xc103c8e7 <get_next_timer_interrupt+431>: mov $0x1,%edx
0xc103c8ec <get_next_timer_interrupt+436>: cmove %edx,%eax
0xc103c8ef <get_next_timer_interrupt+439>: add -0x20(%ebp),%eax
0xc103c8f2 <get_next_timer_interrupt+442>: cmp %esi,%eax
0xc103c8f4 <get_next_timer_interrupt+444>: mov %eax,-0x20(%ebp)
0xc103c8f7 <get_next_timer_interrupt+447>: js 0xc103c8fc <get_next_timer_interrupt+452>
0xc103c8f9 <get_next_timer_interrupt+449>: mov %esi,-0x20(%ebp)
0xc103c8fc <get_next_timer_interrupt+452>: mov -0x20(%ebp),%eax
0xc103c8ff <get_next_timer_interrupt+455>: add $0x2c,%esp
0xc103c902 <get_next_timer_interrupt+458>: pop %ebx
0xc103c903 <get_next_timer_interrupt+459>: pop %esi
0xc103c904 <get_next_timer_interrupt+460>: pop %edi
0xc103c905 <get_next_timer_interrupt+461>: pop %ebp
0xc103c906 <get_next_timer_interrupt+462>: ret
End of assembler dump.
(gdb)
- get_next_timer_interrupt.objdump
kernel/timer.o: file format elf32-i386
Disassembly of section .text:
c103ab38 <round_jiffies_common>:
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab38: 55 push %ebp
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab39: 89 e5 mov %esp,%ebp
* It's not worth to care about 3dnow prefetches for the K6
* because they are microcoded there and very slow.
*/
static inline void prefetch(const void *x)
{
alternative_input(BASE_PREFETCH,
c103ab3b: 57 push %edi
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
rem = j % HZ;
c103ab3c: bf e8 03 00 00 mov $0x3e8,%edi
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab41: 56 push %esi
signed long __sched schedule_timeout(signed long timeout)
{
struct timer_list timer;
unsigned long expire;
switch (timeout)
c103ab42: 89 c6 mov %eax,%esi
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab44: 53 push %ebx
c103ab45: 89 d3 mov %edx,%ebx
c103ab47: 83 ec 04 sub $0x4,%esp
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab4a: 88 4d f3 mov %cl,-0xd(%ebp)
* 3 jiffies. This 3 jiffies came originally from the mm/ code which
* already did this.
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
c103ab4d: 8d 0c 52 lea (%edx,%edx,2),%ecx
rem = j % HZ;
c103ab50: 31 d2 xor %edx,%edx
* 3 jiffies. This 3 jiffies came originally from the mm/ code which
* already did this.
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
c103ab52: 01 c1 add %eax,%ecx
rem = j % HZ;
c103ab54: 89 c8 mov %ecx,%eax
c103ab56: f7 f7 div %edi
* due to delays of the timer irq, long irq off times etc etc) then
* we should round down to the whole second, not up. Use 1/4th second
* as cutoff for this rounding as an extreme upper bound for this.
* But never round down if @force_up is set.
*/
if (rem < HZ/4 && !force_up) /* round down */
c103ab58: 81 fa f9 00 00 00 cmp $0xf9,%edx
int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,
(void *)(long)smp_processor_id());
init_timer_stats();
BUG_ON(err != NOTIFY_OK);
c103ab5e: 7f 06 jg c103ab66 <round_jiffies_common+0x2e>
register_cpu_notifier(&timers_nb);
c103ab60: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
DECLARE_PER_CPU(struct task_struct *, current_task);
static __always_inline struct task_struct *get_current(void)
{
return percpu_read_stable(current_task);
c103ab64: 74 06 je c103ab6c <round_jiffies_common+0x34>
* But never round down if @force_up is set.
*/
if (rem < HZ/4 && !force_up) /* round down */
j = j - rem;
else /* round up */
j = j - rem + HZ;
c103ab66: 81 c1 e8 03 00 00 add $0x3e8,%ecx
/* now that we have rounded, subtract the extra skew again */
j -= cpu * 3;
c103ab6c: 6b db fd imul $0xfffffffd,%ebx,%ebx
if (j <= jiffies) /* rounding ate our timeout entirely; */
c103ab6f: a1 00 00 00 00 mov 0x0,%eax
* But never round down if @force_up is set.
*/
if (rem < HZ/4 && !force_up) /* round down */
j = j - rem;
else /* round up */
j = j - rem + HZ;
c103ab74: 29 d1 sub %edx,%ecx
j -= cpu * 3;
if (j <= jiffies) /* rounding ate our timeout entirely; */
return original;
return j;
}
c103ab76: 5a pop %edx
j = j - rem;
else /* round up */
j = j - rem + HZ;
/* now that we have rounded, subtract the extra skew again */
j -= cpu * 3;
c103ab77: 01 d9 add %ebx,%ecx
if (j <= jiffies) /* rounding ate our timeout entirely; */
c103ab79: 39 c1 cmp %eax,%ecx
c103ab7b: 89 c8 mov %ecx,%eax
c103ab7d: 0f 46 c6 cmovbe %esi,%eax
return original;
return j;
}
c103ab80: 5b pop %ebx
c103ab81: 5e pop %esi
c103ab82: 5f pop %edi
c103ab83: 5d pop %ebp
return kmalloc_large(size, flags);
if (!(flags & SLUB_DMA)) {
struct kmem_cache *s = kmalloc_slab(size);
if (!s)
c103ab84: c3 ret
c103ab85 <__round_jiffies>:
* to lock contention or spurious cache line bouncing.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies(unsigned long j, int cpu)
{
c103ab85: 55 push %ebp
return round_jiffies_common(j, cpu, false);
c103ab86: 31 c9 xor %ecx,%ecx
* to lock contention or spurious cache line bouncing.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies(unsigned long j, int cpu)
{
c103ab88: 89 e5 mov %esp,%ebp
return round_jiffies_common(j, cpu, false);
c103ab8a: e8 a9 ff ff ff call c103ab38 <round_jiffies_common>
}
c103ab8f: 5d pop %ebp
c103ab90: c3 ret
c103ab91 <__round_jiffies_relative>:
* to lock contention or spurious cache line bouncing.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
c103ab91: 55 push %ebp
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
c103ab92: 31 c9 xor %ecx,%ecx
* to lock contention or spurious cache line bouncing.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
c103ab94: 89 e5 mov %esp,%ebp
c103ab96: 53 push %ebx
unsigned long j0 = jiffies;
c103ab97: 8b 1d 00 00 00 00 mov 0x0,%ebx
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
c103ab9d: 01 d8 add %ebx,%eax
* The APs use this path later in boot
*/
base = kmalloc_node(sizeof(*base),
GFP_KERNEL | __GFP_ZERO,
cpu_to_node(cpu));
if (!base)
c103ab9f: e8 94 ff ff ff call c103ab38 <round_jiffies_common>
c103aba4: 29 d8 sub %ebx,%eax
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
}
c103aba6: 5b pop %ebx
c103aba7: 5d pop %ebp
c103aba8: c3 ret
c103aba9 <round_jiffies>:
* of this is to have the CPU wake up less, which saves power.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies(unsigned long j)
{
c103aba9: 55 push %ebp
return round_jiffies_common(j, raw_smp_processor_id(), false);
c103abaa: 31 c9 xor %ecx,%ecx
* of this is to have the CPU wake up less, which saves power.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies(unsigned long j)
{
c103abac: 89 e5 mov %esp,%ebp
return round_jiffies_common(j, raw_smp_processor_id(), false);
c103abae: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
if (!base)
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
WARN_ON(1);
c103abb5: e8 7e ff ff ff call c103ab38 <round_jiffies_common>
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies(unsigned long j)
{
return round_jiffies_common(j, raw_smp_processor_id(), false);
}
c103abba: 5d pop %ebp
c103abbb: c3 ret
c103abbc <round_jiffies_relative>:
* of this is to have the CPU wake up less, which saves power.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies_relative(unsigned long j)
{
c103abbc: 55 push %ebp
c103abbd: 89 e5 mov %esp,%ebp
return __round_jiffies_relative(j, raw_smp_processor_id());
c103abbf: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
WARN_ON(1);
kfree(base);
c103abc6: e8 fc ff ff ff call c103abc7 <round_jiffies_relative+0xb>
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies_relative(unsigned long j)
{
return __round_jiffies_relative(j, raw_smp_processor_id());
}
c103abcb: 5d pop %ebp
c103abcc: c3 ret
c103abcd <__round_jiffies_up>:
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up(unsigned long j, int cpu)
{
c103abcd: 55 push %ebp
return round_jiffies_common(j, cpu, true);
c103abce: b9 01 00 00 00 mov $0x1,%ecx
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up(unsigned long j, int cpu)
{
c103abd3: 89 e5 mov %esp,%ebp
return round_jiffies_common(j, cpu, true);
c103abd5: e8 5e ff ff ff call c103ab38 <round_jiffies_common>
}
c103abda: 5d pop %ebp
c103abdb: c3 ret
c103abdc <__round_jiffies_up_relative>:
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
c103abdc: 55 push %ebp
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, true) - j0;
c103abdd: b9 01 00 00 00 mov $0x1,%ecx
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
c103abe2: 89 e5 mov %esp,%ebp
c103abe4: 53 push %ebx
unsigned long j0 = jiffies;
c103abe5: 8b 1d 00 00 00 00 mov 0x0,%ebx
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, true) - j0;
c103abeb: 01 d8 add %ebx,%eax
c103abed: e8 46 ff ff ff call c103ab38 <round_jiffies_common>
* initialised either.
*/
boot_done = 1;
base = &boot_tvec_bases;
}
tvec_base_done[cpu] = 1;
c103abf2: 29 d8 sub %ebx,%eax
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, true) - j0;
}
c103abf4: 5b pop %ebx
c103abf5: 5d pop %ebp
/*
* We can use __set_current_state() here because schedule_timeout() calls
* schedule() unconditionally.
*/
signed long __sched schedule_timeout_interruptible(signed long timeout)
{
c103abf6: c3 ret
c103abf7 <round_jiffies_up>:
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long round_jiffies_up(unsigned long j)
{
c103abf7: 55 push %ebp
return round_jiffies_common(j, raw_smp_processor_id(), true);
c103abf8: b9 01 00 00 00 mov $0x1,%ecx
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long round_jiffies_up(unsigned long j)
{
c103abfd: 89 e5 mov %esp,%ebp
return round_jiffies_common(j, raw_smp_processor_id(), true);
c103abff: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
* schedule() unconditionally.
*/
signed long __sched schedule_timeout_interruptible(signed long timeout)
{
__set_current_state(TASK_INTERRUPTIBLE);
return schedule_timeout(timeout);
c103ac06: e8 2d ff ff ff call c103ab38 <round_jiffies_common>
* early.
*/
unsigned long round_jiffies_up(unsigned long j)
{
return round_jiffies_common(j, raw_smp_processor_id(), true);
}
c103ac0b: 5d pop %ebp
c103ac0c: c3 ret
c103ac0d <round_jiffies_up_relative>:
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long round_jiffies_up_relative(unsigned long j)
{
c103ac0d: 55 push %ebp
c103ac0e: 89 e5 mov %esp,%ebp
return __round_jiffies_up_relative(j, raw_smp_processor_id());
c103ac10: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
}
spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
INIT_LIST_HEAD(base->tv5.vec + j);
c103ac17: e8 fc ff ff ff call c103ac18 <round_jiffies_up_relative+0xb>
* early.
*/
unsigned long round_jiffies_up_relative(unsigned long j)
{
return __round_jiffies_up_relative(j, raw_smp_processor_id());
}
c103ac1c: 5d pop %ebp
c103ac1d: c3 ret
c103ac1e <set_timer_slack>:
*
* By setting the slack to -1, a percentage of the delay is used
* instead.
*/
void set_timer_slack(struct timer_list *timer, int slack_hz)
{
c103ac1e: 55 push %ebp
c103ac1f: 89 e5 mov %esp,%ebp
timer->slack = slack_hz;
c103ac21: 89 50 18 mov %edx,0x18(%eax)
}
c103ac24: 5d pop %ebp
c103ac25: c3 ret
c103ac26 <internal_add_timer>:
EXPORT_SYMBOL_GPL(set_timer_slack);
static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
{
c103ac26: 55 push %ebp
unsigned long expires = timer->expires;
c103ac27: 8b 4a 08 mov 0x8(%edx),%ecx
timer->slack = slack_hz;
}
EXPORT_SYMBOL_GPL(set_timer_slack);
static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
{
c103ac2a: 89 e5 mov %esp,%ebp
c103ac2c: 56 push %esi
c103ac2d: 53 push %ebx
unsigned long expires = timer->expires;
unsigned long idx = expires - base->timer_jiffies;
c103ac2e: 8b 70 08 mov 0x8(%eax),%esi
c103ac31: 89 cb mov %ecx,%ebx
c103ac33: 29 f3 sub %esi,%ebx
struct list_head *vec;
if (idx < TVR_SIZE) {
c103ac35: 81 fb ff 00 00 00 cmp $0xff,%ebx
c103ac3b: 77 0c ja c103ac49 <internal_add_timer+0x23>
int i = expires & TVR_MASK;
vec = base->tv1.vec + i;
c103ac3d: 81 e1 ff 00 00 00 and $0xff,%ecx
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ac43: 8d 44 c8 10 lea 0x10(%eax,%ecx,8),%eax
c103ac47: eb 5f jmp c103aca8 <internal_add_timer+0x82>
} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
c103ac49: 81 fb ff 3f 00 00 cmp $0x3fff,%ebx
list->prev = list;
c103ac4f: 77 0f ja c103ac60 <internal_add_timer+0x3a>
int i = (expires >> TVR_BITS) & TVN_MASK;
vec = base->tv2.vec + i;
c103ac51: c1 e9 08 shr $0x8,%ecx
c103ac54: 83 e1 3f and $0x3f,%ecx
c103ac57: 8d 84 c8 10 08 00 00 lea 0x810(%eax,%ecx,8),%eax
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ac5e: eb 48 jmp c103aca8 <internal_add_timer+0x82>
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
c103ac60: 81 fb ff ff 0f 00 cmp $0xfffff,%ebx
base = per_cpu(tvec_bases, cpu);
}
spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
c103ac66: 77 0f ja c103ac77 <internal_add_timer+0x51>
} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
int i = (expires >> TVR_BITS) & TVN_MASK;
vec = base->tv2.vec + i;
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
c103ac68: c1 e9 0e shr $0xe,%ecx
c103ac6b: 83 e1 3f and $0x3f,%ecx
INIT_LIST_HEAD(base->tv4.vec + j);
INIT_LIST_HEAD(base->tv3.vec + j);
INIT_LIST_HEAD(base->tv2.vec + j);
}
for (j = 0; j < TVR_SIZE; j++)
INIT_LIST_HEAD(base->tv1.vec + j);
c103ac6e: 8d 84 c8 10 0a 00 00 lea 0xa10(%eax,%ecx,8),%eax
c103ac75: eb 31 jmp c103aca8 <internal_add_timer+0x82>
int i = (expires >> TVR_BITS) & TVN_MASK;
vec = base->tv2.vec + i;
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
c103ac77: 81 fb ff ff ff 03 cmp $0x3ffffff,%ebx
INIT_LIST_HEAD(base->tv5.vec + j);
INIT_LIST_HEAD(base->tv4.vec + j);
INIT_LIST_HEAD(base->tv3.vec + j);
INIT_LIST_HEAD(base->tv2.vec + j);
}
for (j = 0; j < TVR_SIZE; j++)
c103ac7d: 77 0f ja c103ac8e <internal_add_timer+0x68>
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
vec = base->tv4.vec + i;
c103ac7f: c1 e9 14 shr $0x14,%ecx
INIT_LIST_HEAD(base->tv2.vec + j);
}
for (j = 0; j < TVR_SIZE; j++)
INIT_LIST_HEAD(base->tv1.vec + j);
base->timer_jiffies = jiffies;
c103ac82: 83 e1 3f and $0x3f,%ecx
c103ac85: 8d 84 c8 10 0c 00 00 lea 0xc10(%eax,%ecx,8),%eax
base->next_timer = base->timer_jiffies;
c103ac8c: eb 1a jmp c103aca8 <internal_add_timer+0x82>
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
vec = base->tv4.vec + i;
} else if ((signed long) idx < 0) {
c103ac8e: 85 db test %ebx,%ebx
c103ac90: 79 0c jns c103ac9e <internal_add_timer+0x78>
/*
* Can happen if you add a timer with expires == jiffies,
* or you set a timer to go off in the past
*/
vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
c103ac92: 81 e6 ff 00 00 00 and $0xff,%esi
c103ac98: 8d 44 f0 10 lea 0x10(%eax,%esi,8),%eax
{
struct tvec_base *old_base;
struct tvec_base *new_base;
int i;
BUG_ON(cpu_online(cpu));
c103ac9c: eb 0a jmp c103aca8 <internal_add_timer+0x82>
if (idx > 0xffffffffUL) {
idx = 0xffffffffUL;
expires = idx + base->timer_jiffies;
}
i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
vec = base->tv5.vec + i;
c103ac9e: c1 e9 1a shr $0x1a,%ecx
c103aca1: 8d 84 c8 10 0e 00 00 lea 0xe10(%eax,%ecx,8),%eax
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
c103aca8: 8b 48 04 mov 0x4(%eax),%ecx
#ifndef CONFIG_DEBUG_LIST
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
next->prev = new;
c103acab: 89 50 04 mov %edx,0x4(%eax)
new->next = next;
c103acae: 89 02 mov %eax,(%edx)
new->prev = prev;
c103acb0: 89 4a 04 mov %ecx,0x4(%edx)
prev->next = new;
c103acb3: 89 11 mov %edx,(%ecx)
}
/*
* Timers are FIFO:
*/
list_add_tail(&timer->entry, vec);
}
c103acb5: 5b pop %ebx
c103acb6: 5e pop %esi
c103acb7: 5d pop %ebp
c103acb8: c3 ret
c103acb9 <sys_getuid>:
return pid;
}
SYSCALL_DEFINE0(getuid)
{
c103acb9: 55 push %ebp
c103acba: 64 a1 00 00 00 00 mov %fs:0x0,%eax
c103acc0: 8b 80 d4 02 00 00 mov 0x2d4(%eax),%eax
c103acc6: 89 e5 mov %esp,%ebp
/* Only we change this so SMP safe */
return current_uid();
}
c103acc8: 5d pop %ebp
c103acc9: 8b 40 04 mov 0x4(%eax),%eax
c103accc: c3 ret
c103accd <sys_geteuid>:
SYSCALL_DEFINE0(geteuid)
{
c103accd: 55 push %ebp
c103acce: 64 a1 00 00 00 00 mov %fs:0x0,%eax
c103acd4: 8b 80 d4 02 00 00 mov 0x2d4(%eax),%eax
c103acda: 89 e5 mov %esp,%ebp
/* Only we change this so SMP safe */
return current_euid();
}
c103acdc: 5d pop %ebp
c103acdd: 8b 40 14 mov 0x14(%eax),%eax
c103ace0: c3 ret
c103ace1 <sys_getgid>:
SYSCALL_DEFINE0(getgid)
{
c103ace1: 55 push %ebp
c103ace2: 64 a1 00 00 00 00 mov %fs:0x0,%eax
spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
BUG_ON(old_base->running_timer);
for (i = 0; i < TVR_SIZE; i++)
migrate_timer_list(new_base, old_base->tv1.vec + i);
c103ace8: 8b 80 d4 02 00 00 mov 0x2d4(%eax),%eax
/* Only we change this so SMP safe */
return current_euid();
}
SYSCALL_DEFINE0(getgid)
{
c103acee: 89 e5 mov %esp,%ebp
/* Only we change this so SMP safe */
return current_gid();
}
c103acf0: 5d pop %ebp
c103acf1: 8b 40 08 mov 0x8(%eax),%eax
c103acf4: c3 ret
c103acf5 <sys_getegid>:
SYSCALL_DEFINE0(getegid)
{
c103acf5: 55 push %ebp
c103acf6: 64 a1 00 00 00 00 mov %fs:0x0,%eax
c103acfc: 8b 80 d4 02 00 00 mov 0x2d4(%eax),%eax
c103ad02: 89 e5 mov %esp,%ebp
/* Only we change this so SMP safe */
return current_egid();
}
c103ad04: 5d pop %ebp
c103ad05: 8b 40 18 mov 0x18(%eax),%eax
c103ad08: c3 ret
c103ad09 <cascade>:
}
EXPORT_SYMBOL(del_timer_sync);
#endif
static int cascade(struct tvec_base *base, struct tvec *tv, int index)
{
c103ad09: 55 push %ebp
c103ad0a: 89 e5 mov %esp,%ebp
for (i = 0; i < TVR_SIZE; i++)
migrate_timer_list(new_base, old_base->tv1.vec + i);
for (i = 0; i < TVN_SIZE; i++) {
migrate_timer_list(new_base, old_base->tv2.vec + i);
migrate_timer_list(new_base, old_base->tv3.vec + i);
c103ad0c: 57 push %edi
c103ad0d: 89 c7 mov %eax,%edi
c103ad0f: 56 push %esi
c103ad10: 53 push %ebx
c103ad11: 89 cb mov %ecx,%ebx
c103ad13: 83 ec 0c sub $0xc,%esp
* If @old was empty, it will be overwritten.
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
c103ad16: 8b 34 da mov (%edx,%ebx,8),%esi
new->next->prev = new;
c103ad19: 8d 45 ec lea -0x14(%ebp),%eax
{
/* cascade all the timers from tv up one level */
struct timer_list *timer, *tmp;
struct list_head tv_list;
list_replace_init(tv->vec + index, &tv_list);
c103ad1c: 8d 0c ca lea (%edx,%ecx,8),%ecx
* If @old was empty, it will be overwritten.
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
c103ad1f: 89 75 ec mov %esi,-0x14(%ebp)
new->next->prev = new;
c103ad22: 89 46 04 mov %eax,0x4(%esi)
new->prev = old->prev;
c103ad25: 8b 74 da 04 mov 0x4(%edx,%ebx,8),%esi
migrate_timer_list(new_base, old_base->tv1.vec + i);
for (i = 0; i < TVN_SIZE; i++) {
migrate_timer_list(new_base, old_base->tv2.vec + i);
migrate_timer_list(new_base, old_base->tv3.vec + i);
migrate_timer_list(new_base, old_base->tv4.vec + i);
migrate_timer_list(new_base, old_base->tv5.vec + i);
c103ad29: 89 75 f0 mov %esi,-0x10(%ebp)
new->prev->next = new;
c103ad2c: 89 06 mov %eax,(%esi)
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ad2e: 89 0c da mov %ecx,(%edx,%ebx,8)
list->prev = list;
c103ad31: 89 4c da 04 mov %ecx,0x4(%edx,%ebx,8)
/*
* We are removing _all_ timers from the list, so we
* don't have to detach them individually.
*/
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
c103ad35: 8b 55 ec mov -0x14(%ebp),%edx
BUG_ON(old_base->running_timer);
for (i = 0; i < TVR_SIZE; i++)
migrate_timer_list(new_base, old_base->tv1.vec + i);
for (i = 0; i < TVN_SIZE; i++) {
c103ad38: 8b 32 mov (%edx),%esi
c103ad3a: 89 45 e8 mov %eax,-0x18(%ebp)
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
c103ad3d: eb 19 jmp c103ad58 <cascade+0x4f>
/*
* We are removing _all_ timers from the list, so we
* don't have to detach them individually.
*/
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
BUG_ON(tbase_get_base(timer->base) != base);
c103ad3f: 8b 42 0c mov 0xc(%edx),%eax
raw_spin_unlock_bh(&lock->rlock);
}
static inline void spin_unlock_irq(spinlock_t *lock)
{
raw_spin_unlock_irq(&lock->rlock);
c103ad42: 83 e0 fe and $0xfffffffe,%eax
c103ad45: 39 c7 cmp %eax,%edi
c103ad47: 74 04 je c103ad4d <cascade+0x44>
migrate_timer_list(new_base, old_base->tv5.vec + i);
}
spin_unlock(&old_base->lock);
spin_unlock_irq(&new_base->lock);
put_cpu_var(tvec_bases);
c103ad49: 0f 0b ud2a
c103ad4b: eb fe jmp c103ad4b <cascade+0x42>
* We are removing _all_ timers from the list, so we
* don't have to detach them individually.
*/
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
BUG_ON(tbase_get_base(timer->base) != base);
internal_add_timer(base, timer);
c103ad4d: 89 f8 mov %edi,%eax
c103ad4f: e8 d2 fe ff ff call c103ac26 <internal_add_timer>
/*
* We are removing _all_ timers from the list, so we
* don't have to detach them individually.
*/
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
c103ad54: 89 f2 mov %esi,%edx
c103ad56: 8b 36 mov (%esi),%esi
c103ad58: 3b 55 e8 cmp -0x18(%ebp),%edx
}
static __always_inline int constant_test_bit(unsigned int nr, const volatile unsigned long *addr)
{
return ((1UL << (nr % BITS_PER_LONG)) &
(addr[nr / BITS_PER_LONG])) != 0;
c103ad5b: 75 e2 jne c103ad3f <cascade+0x36>
BUG_ON(tbase_get_base(timer->base) != base);
internal_add_timer(base, timer);
}
return index;
}
c103ad5d: 83 c4 0c add $0xc,%esp
c103ad60: 89 d8 mov %ebx,%eax
c103ad62: 5b pop %ebx
c103ad63: 5e pop %esi
c103ad64: 5f pop %edi
c103ad65: 5d pop %ebp
c103ad66: c3 ret
c103ad67 <ftrace_raw_output_timer_start>:
/**
* timer_start - called when the timer is started
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
TRACE_EVENT(timer_start,
c103ad67: 55 push %ebp
c103ad68: 83 e9 14 sub $0x14,%ecx
#endif
default:
break;
}
return NOTIFY_OK;
}
c103ad6b: 89 e5 mov %esp,%ebp
c103ad6d: 56 push %esi
c103ad6e: 53 push %ebx
c103ad6f: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103ad75: 0f b7 13 movzwl (%ebx),%edx
c103ad78: 3b 51 24 cmp 0x24(%ecx),%edx
c103ad7b: 74 2f je c103adac <ftrace_raw_output_timer_start+0x45>
c103ad7d: 80 3d 40 10 00 00 01 cmpb $0x1,0x1040
c103ad84: b8 02 00 00 00 mov $0x2,%eax
c103ad89: 0f 84 80 00 00 00 je c103ae0f <ftrace_raw_output_timer_start+0xa8>
c103ad8f: b8 0f 00 00 00 mov $0xf,%eax
c103ad94: ba 43 00 00 00 mov $0x43,%edx
c103ad99: e8 fc ff ff ff call c103ad9a <ftrace_raw_output_timer_start+0x33>
c103ad9e: b8 02 00 00 00 mov $0x2,%eax
c103ada3: c6 05 40 10 00 00 01 movb $0x1,0x1040
c103adaa: eb 63 jmp c103ae0f <ftrace_raw_output_timer_start+0xa8>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103adac: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103adb3: 00 00 00
c103adb6: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103adbc: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103adc3: 00 00 00
s->full = 0;
c103adc6: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103adcd: 00 00 00
c103add0: ff 71 0c pushl 0xc(%ecx)
c103add3: 68 2c 00 00 00 push $0x2c
c103add8: 56 push %esi
c103add9: e8 fc ff ff ff call c103adda <ftrace_raw_output_timer_start+0x73>
c103adde: 89 c2 mov %eax,%edx
c103ade0: 83 c4 0c add $0xc,%esp
c103ade3: 31 c0 xor %eax,%eax
c103ade5: 85 d2 test %edx,%edx
c103ade7: 74 26 je c103ae0f <ftrace_raw_output_timer_start+0xa8>
c103ade9: 8b 43 14 mov 0x14(%ebx),%eax
c103adec: 89 c2 mov %eax,%edx
c103adee: 2b 53 18 sub 0x18(%ebx),%edx
c103adf1: 52 push %edx
c103adf2: 50 push %eax
c103adf3: ff 73 10 pushl 0x10(%ebx)
c103adf6: ff 73 0c pushl 0xc(%ebx)
c103adf9: 68 31 00 00 00 push $0x31
c103adfe: 56 push %esi
c103adff: e8 fc ff ff ff call c103ae00 <ftrace_raw_output_timer_start+0x99>
c103ae04: 83 c4 18 add $0x18,%esp
c103ae07: 85 c0 test %eax,%eax
c103ae09: 0f 95 c0 setne %al
c103ae0c: 0f b6 c0 movzbl %al,%eax
c103ae0f: 8d 65 f8 lea -0x8(%ebp),%esp
c103ae12: 5b pop %ebx
c103ae13: 5e pop %esi
c103ae14: 5d pop %ebp
c103ae15: c3 ret
c103ae16 <ftrace_raw_output_timer_expire_entry>:
* timer_expire_entry - called immediately before the timer callback
* @timer: pointer to struct timer_list
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(timer_expire_entry,
c103ae16: 55 push %ebp
c103ae17: 83 e9 14 sub $0x14,%ecx
c103ae1a: 89 e5 mov %esp,%ebp
c103ae1c: 56 push %esi
c103ae1d: 53 push %ebx
c103ae1e: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103ae24: 0f b7 13 movzwl (%ebx),%edx
c103ae27: 3b 51 24 cmp 0x24(%ecx),%edx
c103ae2a: 74 2b je c103ae57 <ftrace_raw_output_timer_expire_entry+0x41>
c103ae2c: 80 3d 41 10 00 00 01 cmpb $0x1,0x1041
c103ae33: b8 02 00 00 00 mov $0x2,%eax
c103ae38: 74 79 je c103aeb3 <ftrace_raw_output_timer_expire_entry+0x9d>
c103ae3a: b8 0f 00 00 00 mov $0xf,%eax
c103ae3f: ba 5e 00 00 00 mov $0x5e,%edx
c103ae44: e8 fc ff ff ff call c103ae45 <ftrace_raw_output_timer_expire_entry+0x2f>
c103ae49: b8 02 00 00 00 mov $0x2,%eax
c103ae4e: c6 05 41 10 00 00 01 movb $0x1,0x1041
c103ae55: eb 5c jmp c103aeb3 <ftrace_raw_output_timer_expire_entry+0x9d>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103ae57: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103ae5e: 00 00 00
c103ae61: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103ae67: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103ae6e: 00 00 00
s->full = 0;
c103ae71: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103ae78: 00 00 00
c103ae7b: ff 71 0c pushl 0xc(%ecx)
c103ae7e: 68 2c 00 00 00 push $0x2c
c103ae83: 56 push %esi
c103ae84: e8 fc ff ff ff call c103ae85 <ftrace_raw_output_timer_expire_entry+0x6f>
c103ae89: 89 c2 mov %eax,%edx
c103ae8b: 83 c4 0c add $0xc,%esp
c103ae8e: 31 c0 xor %eax,%eax
c103ae90: 85 d2 test %edx,%edx
c103ae92: 74 1f je c103aeb3 <ftrace_raw_output_timer_expire_entry+0x9d>
c103ae94: ff 73 10 pushl 0x10(%ebx)
c103ae97: ff 73 14 pushl 0x14(%ebx)
c103ae9a: ff 73 0c pushl 0xc(%ebx)
c103ae9d: 68 62 00 00 00 push $0x62
c103aea2: 56 push %esi
c103aea3: e8 fc ff ff ff call c103aea4 <ftrace_raw_output_timer_expire_entry+0x8e>
c103aea8: 83 c4 14 add $0x14,%esp
c103aeab: 85 c0 test %eax,%eax
c103aead: 0f 95 c0 setne %al
c103aeb0: 0f b6 c0 movzbl %al,%eax
c103aeb3: 8d 65 f8 lea -0x8(%ebp),%esp
c103aeb6: 5b pop %ebx
c103aeb7: 5e pop %esi
c103aeb8: 5d pop %ebp
c103aeb9: c3 ret
c103aeba <ftrace_raw_output_timer_class>:
#include <linux/tracepoint.h>
#include <linux/hrtimer.h>
#include <linux/timer.h>
DECLARE_EVENT_CLASS(timer_class,
c103aeba: 55 push %ebp
c103aebb: 83 e9 14 sub $0x14,%ecx
c103aebe: 89 e5 mov %esp,%ebp
c103aec0: 56 push %esi
c103aec1: 53 push %ebx
c103aec2: 8b b0 60 20 00 00 mov 0x2060(%eax),%esi
c103aec8: 0f b7 16 movzwl (%esi),%edx
c103aecb: 3b 51 24 cmp 0x24(%ecx),%edx
c103aece: 74 2b je c103aefb <ftrace_raw_output_timer_class+0x41>
c103aed0: 80 3d 42 10 00 00 01 cmpb $0x1,0x1042
c103aed7: b8 02 00 00 00 mov $0x2,%eax
c103aedc: 74 73 je c103af51 <ftrace_raw_output_timer_class+0x97>
c103aede: b8 0f 00 00 00 mov $0xf,%eax
c103aee3: ba 1a 00 00 00 mov $0x1a,%edx
c103aee8: e8 fc ff ff ff call c103aee9 <ftrace_raw_output_timer_class+0x2f>
c103aeed: b8 02 00 00 00 mov $0x2,%eax
c103aef2: c6 05 42 10 00 00 01 movb $0x1,0x1042
c103aef9: eb 56 jmp c103af51 <ftrace_raw_output_timer_class+0x97>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103aefb: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103af02: 00 00 00
c103af05: 8d 98 54 10 00 00 lea 0x1054(%eax),%ebx
s->readpos = 0;
c103af0b: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103af12: 00 00 00
s->full = 0;
c103af15: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103af1c: 00 00 00
c103af1f: ff 71 0c pushl 0xc(%ecx)
c103af22: 68 2c 00 00 00 push $0x2c
c103af27: 53 push %ebx
c103af28: e8 fc ff ff ff call c103af29 <ftrace_raw_output_timer_class+0x6f>
c103af2d: 89 c2 mov %eax,%edx
c103af2f: 83 c4 0c add $0xc,%esp
c103af32: 31 c0 xor %eax,%eax
c103af34: 85 d2 test %edx,%edx
c103af36: 74 19 je c103af51 <ftrace_raw_output_timer_class+0x97>
c103af38: ff 76 0c pushl 0xc(%esi)
c103af3b: 68 81 00 00 00 push $0x81
c103af40: 53 push %ebx
c103af41: e8 fc ff ff ff call c103af42 <ftrace_raw_output_timer_class+0x88>
c103af46: 83 c4 0c add $0xc,%esp
c103af49: 85 c0 test %eax,%eax
c103af4b: 0f 95 c0 setne %al
c103af4e: 0f b6 c0 movzbl %al,%eax
c103af51: 8d 65 f8 lea -0x8(%ebp),%esp
c103af54: 5b pop %ebx
c103af55: 5e pop %esi
c103af56: 5d pop %ebp
c103af57: c3 ret
c103af58 <ftrace_raw_output_hrtimer_init>:
* hrtimer_init - called when the hrtimer is initialized
* @timer: pointer to struct hrtimer
* @clockid: the hrtimers clock
* @mode: the hrtimers mode
*/
TRACE_EVENT(hrtimer_init,
c103af58: 55 push %ebp
c103af59: 83 e9 14 sub $0x14,%ecx
c103af5c: 89 e5 mov %esp,%ebp
c103af5e: 56 push %esi
c103af5f: 53 push %ebx
c103af60: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103af66: 0f b7 13 movzwl (%ebx),%edx
c103af69: 3b 51 24 cmp 0x24(%ecx),%edx
c103af6c: 74 2f je c103af9d <ftrace_raw_output_hrtimer_init+0x45>
c103af6e: 80 3d 43 10 00 00 01 cmpb $0x1,0x1043
c103af75: b8 02 00 00 00 mov $0x2,%eax
c103af7a: 0f 84 97 00 00 00 je c103b017 <ftrace_raw_output_hrtimer_init+0xbf>
c103af80: b8 0f 00 00 00 mov $0xf,%eax
c103af85: ba 9a 00 00 00 mov $0x9a,%edx
c103af8a: e8 fc ff ff ff call c103af8b <ftrace_raw_output_hrtimer_init+0x33>
c103af8f: b8 02 00 00 00 mov $0x2,%eax
c103af94: c6 05 43 10 00 00 01 movb $0x1,0x1043
c103af9b: eb 7a jmp c103b017 <ftrace_raw_output_hrtimer_init+0xbf>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103af9d: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103afa4: 00 00 00
c103afa7: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103afad: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103afb4: 00 00 00
s->full = 0;
c103afb7: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103afbe: 00 00 00
c103afc1: ff 71 0c pushl 0xc(%ecx)
c103afc4: 68 2c 00 00 00 push $0x2c
c103afc9: 56 push %esi
c103afca: e8 fc ff ff ff call c103afcb <ftrace_raw_output_hrtimer_init+0x73>
c103afcf: 89 c2 mov %eax,%edx
c103afd1: 83 c4 0c add $0xc,%esp
c103afd4: 31 c0 xor %eax,%eax
c103afd6: 85 d2 test %edx,%edx
c103afd8: 74 3d je c103b017 <ftrace_raw_output_hrtimer_init+0xbf>
c103afda: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
c103afde: b8 9c 00 00 00 mov $0x9c,%eax
c103afe3: ba 8b 00 00 00 mov $0x8b,%edx
c103afe8: b9 bd 00 00 00 mov $0xbd,%ecx
c103afed: 0f 44 d0 cmove %eax,%edx
c103aff0: b8 ad 00 00 00 mov $0xad,%eax
c103aff5: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
c103aff9: 52 push %edx
c103affa: 0f 44 c1 cmove %ecx,%eax
c103affd: 50 push %eax
c103affe: ff 73 0c pushl 0xc(%ebx)
c103b001: 68 cc 00 00 00 push $0xcc
c103b006: 56 push %esi
c103b007: e8 fc ff ff ff call c103b008 <ftrace_raw_output_hrtimer_init+0xb0>
c103b00c: 83 c4 14 add $0x14,%esp
c103b00f: 85 c0 test %eax,%eax
c103b011: 0f 95 c0 setne %al
c103b014: 0f b6 c0 movzbl %al,%eax
c103b017: 8d 65 f8 lea -0x8(%ebp),%esp
c103b01a: 5b pop %ebx
c103b01b: 5e pop %esi
c103b01c: 5d pop %ebp
c103b01d: c3 ret
c103b01e <ftrace_raw_output_hrtimer_start>:
/**
* hrtimer_start - called when the hrtimer is started
* @timer: pointer to struct hrtimer
*/
TRACE_EVENT(hrtimer_start,
c103b01e: 55 push %ebp
c103b01f: 83 e9 14 sub $0x14,%ecx
c103b022: 89 e5 mov %esp,%ebp
c103b024: 56 push %esi
c103b025: 53 push %ebx
c103b026: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103b02c: 0f b7 13 movzwl (%ebx),%edx
c103b02f: 3b 51 24 cmp 0x24(%ecx),%edx
c103b032: 74 2f je c103b063 <ftrace_raw_output_hrtimer_start+0x45>
c103b034: 80 3d 44 10 00 00 01 cmpb $0x1,0x1044
c103b03b: b8 02 00 00 00 mov $0x2,%eax
c103b040: 0f 84 82 00 00 00 je c103b0c8 <ftrace_raw_output_hrtimer_start+0xaa>
c103b046: b8 0f 00 00 00 mov $0xf,%eax
c103b04b: ba ba 00 00 00 mov $0xba,%edx
c103b050: e8 fc ff ff ff call c103b051 <ftrace_raw_output_hrtimer_start+0x33>
c103b055: b8 02 00 00 00 mov $0x2,%eax
c103b05a: c6 05 44 10 00 00 01 movb $0x1,0x1044
c103b061: eb 65 jmp c103b0c8 <ftrace_raw_output_hrtimer_start+0xaa>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103b063: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103b06a: 00 00 00
c103b06d: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103b073: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103b07a: 00 00 00
s->full = 0;
c103b07d: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103b084: 00 00 00
c103b087: ff 71 0c pushl 0xc(%ecx)
c103b08a: 68 2c 00 00 00 push $0x2c
c103b08f: 56 push %esi
c103b090: e8 fc ff ff ff call c103b091 <ftrace_raw_output_hrtimer_start+0x73>
c103b095: 89 c2 mov %eax,%edx
c103b097: 83 c4 0c add $0xc,%esp
c103b09a: 31 c0 xor %eax,%eax
c103b09c: 85 d2 test %edx,%edx
c103b09e: 74 28 je c103b0c8 <ftrace_raw_output_hrtimer_start+0xaa>
c103b0a0: ff 73 20 pushl 0x20(%ebx)
c103b0a3: ff 73 1c pushl 0x1c(%ebx)
c103b0a6: ff 73 18 pushl 0x18(%ebx)
c103b0a9: ff 73 14 pushl 0x14(%ebx)
c103b0ac: ff 73 10 pushl 0x10(%ebx)
c103b0af: ff 73 0c pushl 0xc(%ebx)
c103b0b2: 68 eb 00 00 00 push $0xeb
c103b0b7: 56 push %esi
c103b0b8: e8 fc ff ff ff call c103b0b9 <ftrace_raw_output_hrtimer_start+0x9b>
c103b0bd: 83 c4 20 add $0x20,%esp
c103b0c0: 85 c0 test %eax,%eax
c103b0c2: 0f 95 c0 setne %al
c103b0c5: 0f b6 c0 movzbl %al,%eax
c103b0c8: 8d 65 f8 lea -0x8(%ebp),%esp
c103b0cb: 5b pop %ebx
c103b0cc: 5e pop %esi
c103b0cd: 5d pop %ebp
c103b0ce: c3 ret
c103b0cf <ftrace_raw_output_hrtimer_expire_entry>:
* @now: pointer to variable which contains current time of the
* timers base.
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(hrtimer_expire_entry,
c103b0cf: 55 push %ebp
c103b0d0: 83 e9 14 sub $0x14,%ecx
c103b0d3: 89 e5 mov %esp,%ebp
c103b0d5: 56 push %esi
c103b0d6: 53 push %ebx
c103b0d7: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103b0dd: 0f b7 13 movzwl (%ebx),%edx
c103b0e0: 3b 51 24 cmp 0x24(%ecx),%edx
c103b0e3: 74 2b je c103b110 <ftrace_raw_output_hrtimer_expire_entry+0x41>
c103b0e5: 80 3d 45 10 00 00 01 cmpb $0x1,0x1045
c103b0ec: b8 02 00 00 00 mov $0x2,%eax
c103b0f1: 74 7c je c103b16f <ftrace_raw_output_hrtimer_expire_entry+0xa0>
c103b0f3: b8 0f 00 00 00 mov $0xf,%eax
c103b0f8: ba d8 00 00 00 mov $0xd8,%edx
c103b0fd: e8 fc ff ff ff call c103b0fe <ftrace_raw_output_hrtimer_expire_entry+0x2f>
c103b102: b8 02 00 00 00 mov $0x2,%eax
c103b107: c6 05 45 10 00 00 01 movb $0x1,0x1045
c103b10e: eb 5f jmp c103b16f <ftrace_raw_output_hrtimer_expire_entry+0xa0>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103b110: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103b117: 00 00 00
c103b11a: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103b120: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103b127: 00 00 00
s->full = 0;
c103b12a: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103b131: 00 00 00
c103b134: ff 71 0c pushl 0xc(%ecx)
c103b137: 68 2c 00 00 00 push $0x2c
c103b13c: 56 push %esi
c103b13d: e8 fc ff ff ff call c103b13e <ftrace_raw_output_hrtimer_expire_entry+0x6f>
c103b142: 89 c2 mov %eax,%edx
c103b144: 83 c4 0c add $0xc,%esp
c103b147: 31 c0 xor %eax,%eax
c103b149: 85 d2 test %edx,%edx
c103b14b: 74 22 je c103b16f <ftrace_raw_output_hrtimer_expire_entry+0xa0>
c103b14d: ff 73 14 pushl 0x14(%ebx)
c103b150: ff 73 10 pushl 0x10(%ebx)
c103b153: ff 73 18 pushl 0x18(%ebx)
c103b156: ff 73 0c pushl 0xc(%ebx)
c103b159: 68 22 01 00 00 push $0x122
c103b15e: 56 push %esi
c103b15f: e8 fc ff ff ff call c103b160 <ftrace_raw_output_hrtimer_expire_entry+0x91>
c103b164: 83 c4 18 add $0x18,%esp
c103b167: 85 c0 test %eax,%eax
c103b169: 0f 95 c0 setne %al
c103b16c: 0f b6 c0 movzbl %al,%eax
c103b16f: 8d 65 f8 lea -0x8(%ebp),%esp
c103b172: 5b pop %ebx
c103b173: 5e pop %esi
c103b174: 5d pop %ebp
c103b175: c3 ret
c103b176 <ftrace_raw_output_hrtimer_class>:
TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
(unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
);
DECLARE_EVENT_CLASS(hrtimer_class,
c103b176: 55 push %ebp
c103b177: 83 e9 14 sub $0x14,%ecx
c103b17a: 89 e5 mov %esp,%ebp
c103b17c: 56 push %esi
c103b17d: 53 push %ebx
c103b17e: 8b b0 60 20 00 00 mov 0x2060(%eax),%esi
c103b184: 0f b7 16 movzwl (%esi),%edx
c103b187: 3b 51 24 cmp 0x24(%ecx),%edx
c103b18a: 74 2b je c103b1b7 <ftrace_raw_output_hrtimer_class+0x41>
c103b18c: 80 3d 46 10 00 00 01 cmpb $0x1,0x1046
c103b193: b8 02 00 00 00 mov $0x2,%eax
c103b198: 74 73 je c103b20d <ftrace_raw_output_hrtimer_class+0x97>
c103b19a: b8 0f 00 00 00 mov $0xf,%eax
c103b19f: ba e9 00 00 00 mov $0xe9,%edx
c103b1a4: e8 fc ff ff ff call c103b1a5 <ftrace_raw_output_hrtimer_class+0x2f>
c103b1a9: b8 02 00 00 00 mov $0x2,%eax
c103b1ae: c6 05 46 10 00 00 01 movb $0x1,0x1046
c103b1b5: eb 56 jmp c103b20d <ftrace_raw_output_hrtimer_class+0x97>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103b1b7: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103b1be: 00 00 00
c103b1c1: 8d 98 54 10 00 00 lea 0x1054(%eax),%ebx
s->readpos = 0;
c103b1c7: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103b1ce: 00 00 00
s->full = 0;
c103b1d1: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103b1d8: 00 00 00
c103b1db: ff 71 0c pushl 0xc(%ecx)
c103b1de: 68 2c 00 00 00 push $0x2c
c103b1e3: 53 push %ebx
c103b1e4: e8 fc ff ff ff call c103b1e5 <ftrace_raw_output_hrtimer_class+0x6f>
c103b1e9: 89 c2 mov %eax,%edx
c103b1eb: 83 c4 0c add $0xc,%esp
c103b1ee: 31 c0 xor %eax,%eax
c103b1f0: 85 d2 test %edx,%edx
c103b1f2: 74 19 je c103b20d <ftrace_raw_output_hrtimer_class+0x97>
c103b1f4: ff 76 0c pushl 0xc(%esi)
c103b1f7: 68 44 01 00 00 push $0x144
c103b1fc: 53 push %ebx
c103b1fd: e8 fc ff ff ff call c103b1fe <ftrace_raw_output_hrtimer_class+0x88>
c103b202: 83 c4 0c add $0xc,%esp
c103b205: 85 c0 test %eax,%eax
c103b207: 0f 95 c0 setne %al
c103b20a: 0f b6 c0 movzbl %al,%eax
c103b20d: 8d 65 f8 lea -0x8(%ebp),%esp
c103b210: 5b pop %ebx
c103b211: 5e pop %esi
c103b212: 5d pop %ebp
c103b213: c3 ret
c103b214 <ftrace_raw_output_itimer_state>:
* @which: name of the interval timer
* @value: the itimers value, itimer is canceled if value->it_value is
* zero, otherwise it is started
* @expires: the itimers expiry time
*/
TRACE_EVENT(itimer_state,
c103b214: 55 push %ebp
c103b215: 83 e9 14 sub $0x14,%ecx
c103b218: 89 e5 mov %esp,%ebp
c103b21a: 56 push %esi
c103b21b: 53 push %ebx
c103b21c: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103b222: 0f b7 13 movzwl (%ebx),%edx
c103b225: 3b 51 24 cmp 0x24(%ecx),%edx
c103b228: 74 2f je c103b259 <ftrace_raw_output_itimer_state+0x45>
c103b22a: 80 3d 47 10 00 00 01 cmpb $0x1,0x1047
c103b231: b8 02 00 00 00 mov $0x2,%eax
c103b236: 0f 84 86 00 00 00 je c103b2c2 <ftrace_raw_output_itimer_state+0xae>
c103b23c: b8 0f 00 00 00 mov $0xf,%eax
c103b241: ba 28 01 00 00 mov $0x128,%edx
c103b246: e8 fc ff ff ff call c103b247 <ftrace_raw_output_itimer_state+0x33>
c103b24b: b8 02 00 00 00 mov $0x2,%eax
c103b250: c6 05 47 10 00 00 01 movb $0x1,0x1047
c103b257: eb 69 jmp c103b2c2 <ftrace_raw_output_itimer_state+0xae>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103b259: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103b260: 00 00 00
c103b263: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103b269: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103b270: 00 00 00
s->full = 0;
c103b273: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103b27a: 00 00 00
c103b27d: ff 71 0c pushl 0xc(%ecx)
c103b280: 68 2c 00 00 00 push $0x2c
c103b285: 56 push %esi
c103b286: e8 fc ff ff ff call c103b287 <ftrace_raw_output_itimer_state+0x73>
c103b28b: 89 c2 mov %eax,%edx
c103b28d: 83 c4 0c add $0xc,%esp
c103b290: 31 c0 xor %eax,%eax
c103b292: 85 d2 test %edx,%edx
c103b294: 74 2c je c103b2c2 <ftrace_raw_output_itimer_state+0xae>
c103b296: ff 73 20 pushl 0x20(%ebx)
c103b299: 31 d2 xor %edx,%edx
c103b29b: ff 73 1c pushl 0x1c(%ebx)
c103b29e: ff 73 18 pushl 0x18(%ebx)
c103b2a1: ff 73 14 pushl 0x14(%ebx)
c103b2a4: 8b 43 10 mov 0x10(%ebx),%eax
c103b2a7: 52 push %edx
c103b2a8: 50 push %eax
c103b2a9: ff 73 0c pushl 0xc(%ebx)
c103b2ac: 68 50 01 00 00 push $0x150
c103b2b1: 56 push %esi
c103b2b2: e8 fc ff ff ff call c103b2b3 <ftrace_raw_output_itimer_state+0x9f>
c103b2b7: 83 c4 24 add $0x24,%esp
c103b2ba: 85 c0 test %eax,%eax
c103b2bc: 0f 95 c0 setne %al
c103b2bf: 0f b6 c0 movzbl %al,%eax
c103b2c2: 8d 65 f8 lea -0x8(%ebp),%esp
c103b2c5: 5b pop %ebx
c103b2c6: 5e pop %esi
c103b2c7: 5d pop %ebp
c103b2c8: c3 ret
c103b2c9 <ftrace_raw_output_itimer_expire>:
* itimer_expire - called when itimer expires
* @which: type of the interval timer
* @pid: pid of the process which owns the timer
* @now: current time, used to calculate the latency of itimer
*/
TRACE_EVENT(itimer_expire,
c103b2c9: 55 push %ebp
c103b2ca: 83 e9 14 sub $0x14,%ecx
c103b2cd: 89 e5 mov %esp,%ebp
c103b2cf: 56 push %esi
c103b2d0: 53 push %ebx
c103b2d1: 8b 98 60 20 00 00 mov 0x2060(%eax),%ebx
c103b2d7: 0f b7 13 movzwl (%ebx),%edx
c103b2da: 3b 51 24 cmp 0x24(%ecx),%edx
c103b2dd: 74 2b je c103b30a <ftrace_raw_output_itimer_expire+0x41>
c103b2df: 80 3d 48 10 00 00 01 cmpb $0x1,0x1048
c103b2e6: b8 02 00 00 00 mov $0x2,%eax
c103b2eb: 74 7d je c103b36a <ftrace_raw_output_itimer_expire+0xa1>
c103b2ed: b8 0f 00 00 00 mov $0xf,%eax
c103b2f2: ba 44 01 00 00 mov $0x144,%edx
c103b2f7: e8 fc ff ff ff call c103b2f8 <ftrace_raw_output_itimer_expire+0x2f>
c103b2fc: b8 02 00 00 00 mov $0x2,%eax
c103b301: c6 05 48 10 00 00 01 movb $0x1,0x1048
c103b308: eb 60 jmp c103b36a <ftrace_raw_output_itimer_expire+0xa1>
};
static inline void
trace_seq_init(struct trace_seq *s)
{
s->len = 0;
c103b30a: c7 80 48 10 00 00 00 movl $0x0,0x1048(%eax)
c103b311: 00 00 00
c103b314: 8d b0 54 10 00 00 lea 0x1054(%eax),%esi
s->readpos = 0;
c103b31a: c7 80 4c 10 00 00 00 movl $0x0,0x104c(%eax)
c103b321: 00 00 00
s->full = 0;
c103b324: c7 80 50 10 00 00 00 movl $0x0,0x1050(%eax)
c103b32b: 00 00 00
c103b32e: ff 71 0c pushl 0xc(%ecx)
c103b331: 68 2c 00 00 00 push $0x2c
c103b336: 56 push %esi
c103b337: e8 fc ff ff ff call c103b338 <ftrace_raw_output_itimer_expire+0x6f>
c103b33c: 89 c2 mov %eax,%edx
c103b33e: 83 c4 0c add $0xc,%esp
c103b341: 31 c0 xor %eax,%eax
c103b343: 85 d2 test %edx,%edx
c103b345: 74 23 je c103b36a <ftrace_raw_output_itimer_expire+0xa1>
c103b347: 8b 43 14 mov 0x14(%ebx),%eax
c103b34a: 31 d2 xor %edx,%edx
c103b34c: 52 push %edx
c103b34d: 50 push %eax
c103b34e: ff 73 10 pushl 0x10(%ebx)
c103b351: ff 73 0c pushl 0xc(%ebx)
c103b354: 68 8c 01 00 00 push $0x18c
c103b359: 56 push %esi
c103b35a: e8 fc ff ff ff call c103b35b <ftrace_raw_output_itimer_expire+0x92>
c103b35f: 83 c4 18 add $0x18,%esp
c103b362: 85 c0 test %eax,%eax
c103b364: 0f 95 c0 setne %al
c103b367: 0f b6 c0 movzbl %al,%eax
c103b36a: 8d 65 f8 lea -0x8(%ebp),%esp
c103b36d: 5b pop %ebx
c103b36e: 5e pop %esi
c103b36f: 5d pop %ebp
c103b370: c3 ret
c103b371 <ftrace_define_fields_timer_class>:
#include <linux/tracepoint.h>
#include <linux/hrtimer.h>
#include <linux/timer.h>
DECLARE_EVENT_CLASS(timer_class,
c103b371: 55 push %ebp
c103b372: b9 a6 01 00 00 mov $0x1a6,%ecx
c103b377: 89 e5 mov %esp,%ebp
c103b379: ba ac 01 00 00 mov $0x1ac,%edx
c103b37e: 6a 00 push $0x0
c103b380: 6a 00 push $0x0
c103b382: 6a 04 push $0x4
c103b384: 6a 0c push $0xc
c103b386: e8 fc ff ff ff call c103b387 <ftrace_define_fields_timer_class+0x16>
TP_fast_assign(
__entry->timer = timer;
),
TP_printk("timer=%p", __entry->timer)
);
c103b38b: c9 leave
c103b38c: c3 ret
c103b38d <ftrace_define_fields_timer_start>:
/**
* timer_start - called when the timer is started
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
TRACE_EVENT(timer_start,
c103b38d: 55 push %ebp
c103b38e: b9 a6 01 00 00 mov $0x1a6,%ecx
c103b393: 89 e5 mov %esp,%ebp
c103b395: ba ac 01 00 00 mov $0x1ac,%edx
c103b39a: 53 push %ebx
c103b39b: 89 c3 mov %eax,%ebx
c103b39d: 6a 00 push $0x0
c103b39f: 6a 00 push $0x0
c103b3a1: 6a 04 push $0x4
c103b3a3: 6a 0c push $0xc
c103b3a5: e8 fc ff ff ff call c103b3a6 <ftrace_define_fields_timer_start+0x19>
c103b3aa: 83 c4 10 add $0x10,%esp
c103b3ad: 85 c0 test %eax,%eax
c103b3af: 75 5c jne c103b40d <ftrace_define_fields_timer_start+0x80>
c103b3b1: 6a 00 push $0x0
c103b3b3: b9 b3 01 00 00 mov $0x1b3,%ecx
c103b3b8: 6a 00 push $0x0
c103b3ba: ba ac 01 00 00 mov $0x1ac,%edx
c103b3bf: 6a 04 push $0x4
c103b3c1: 89 d8 mov %ebx,%eax
c103b3c3: 6a 10 push $0x10
c103b3c5: e8 fc ff ff ff call c103b3c6 <ftrace_define_fields_timer_start+0x39>
c103b3ca: 83 c4 10 add $0x10,%esp
c103b3cd: 85 c0 test %eax,%eax
c103b3cf: 75 3c jne c103b40d <ftrace_define_fields_timer_start+0x80>
c103b3d1: 6a 00 push $0x0
c103b3d3: b9 bc 01 00 00 mov $0x1bc,%ecx
c103b3d8: 6a 00 push $0x0
c103b3da: ba c4 01 00 00 mov $0x1c4,%edx
c103b3df: 6a 04 push $0x4
c103b3e1: 89 d8 mov %ebx,%eax
c103b3e3: 6a 14 push $0x14
c103b3e5: e8 fc ff ff ff call c103b3e6 <ftrace_define_fields_timer_start+0x59>
c103b3ea: 83 c4 10 add $0x10,%esp
c103b3ed: 85 c0 test %eax,%eax
c103b3ef: 75 1c jne c103b40d <ftrace_define_fields_timer_start+0x80>
c103b3f1: 6a 00 push $0x0
c103b3f3: b9 d2 01 00 00 mov $0x1d2,%ecx
c103b3f8: 6a 00 push $0x0
c103b3fa: ba c4 01 00 00 mov $0x1c4,%edx
c103b3ff: 6a 04 push $0x4
c103b401: 89 d8 mov %ebx,%eax
c103b403: 6a 18 push $0x18
c103b405: e8 fc ff ff ff call c103b406 <ftrace_define_fields_timer_start+0x79>
c103b40a: 83 c4 10 add $0x10,%esp
),
TP_printk("timer=%p function=%pf expires=%lu [timeout=%ld]",
__entry->timer, __entry->function, __entry->expires,
(long)__entry->expires - __entry->now)
);
c103b40d: 8b 5d fc mov -0x4(%ebp),%ebx
c103b410: c9 leave
c103b411: c3 ret
c103b412 <ftrace_define_fields_timer_expire_entry>:
* timer_expire_entry - called immediately before the timer callback
* @timer: pointer to struct timer_list
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(timer_expire_entry,
c103b412: 55 push %ebp
c103b413: b9 a6 01 00 00 mov $0x1a6,%ecx
c103b418: 89 e5 mov %esp,%ebp
c103b41a: ba ac 01 00 00 mov $0x1ac,%edx
c103b41f: 53 push %ebx
c103b420: 89 c3 mov %eax,%ebx
c103b422: 6a 00 push $0x0
c103b424: 6a 00 push $0x0
c103b426: 6a 04 push $0x4
c103b428: 6a 0c push $0xc
c103b42a: e8 fc ff ff ff call c103b42b <ftrace_define_fields_timer_expire_entry+0x19>
c103b42f: 83 c4 10 add $0x10,%esp
c103b432: 85 c0 test %eax,%eax
c103b434: 75 3c jne c103b472 <ftrace_define_fields_timer_expire_entry+0x60>
c103b436: 6a 00 push $0x0
c103b438: b9 d2 01 00 00 mov $0x1d2,%ecx
c103b43d: 6a 00 push $0x0
c103b43f: ba c4 01 00 00 mov $0x1c4,%edx
c103b444: 6a 04 push $0x4
c103b446: 89 d8 mov %ebx,%eax
c103b448: 6a 10 push $0x10
c103b44a: e8 fc ff ff ff call c103b44b <ftrace_define_fields_timer_expire_entry+0x39>
c103b44f: 83 c4 10 add $0x10,%esp
c103b452: 85 c0 test %eax,%eax
c103b454: 75 1c jne c103b472 <ftrace_define_fields_timer_expire_entry+0x60>
c103b456: 6a 00 push $0x0
c103b458: b9 b3 01 00 00 mov $0x1b3,%ecx
c103b45d: 6a 00 push $0x0
c103b45f: ba ac 01 00 00 mov $0x1ac,%edx
c103b464: 6a 04 push $0x4
c103b466: 89 d8 mov %ebx,%eax
c103b468: 6a 14 push $0x14
c103b46a: e8 fc ff ff ff call c103b46b <ftrace_define_fields_timer_expire_entry+0x59>
c103b46f: 83 c4 10 add $0x10,%esp
__entry->now = jiffies;
__entry->function = timer->function;
),
TP_printk("timer=%p function=%pf now=%lu", __entry->timer, __entry->function,__entry->now)
);
c103b472: 8b 5d fc mov -0x4(%ebp),%ebx
c103b475: c9 leave
c103b476: c3 ret
c103b477 <ftrace_define_fields_hrtimer_init>:
* hrtimer_init - called when the hrtimer is initialized
* @timer: pointer to struct hrtimer
* @clockid: the hrtimers clock
* @mode: the hrtimers mode
*/
TRACE_EVENT(hrtimer_init,
c103b477: 55 push %ebp
c103b478: b9 d6 01 00 00 mov $0x1d6,%ecx
c103b47d: 89 e5 mov %esp,%ebp
c103b47f: ba ac 01 00 00 mov $0x1ac,%edx
c103b484: 53 push %ebx
c103b485: 89 c3 mov %eax,%ebx
c103b487: 6a 00 push $0x0
c103b489: 6a 00 push $0x0
c103b48b: 6a 04 push $0x4
c103b48d: 6a 0c push $0xc
c103b48f: e8 fc ff ff ff call c103b490 <ftrace_define_fields_hrtimer_init+0x19>
c103b494: 83 c4 10 add $0x10,%esp
c103b497: 85 c0 test %eax,%eax
c103b499: 75 3c jne c103b4d7 <ftrace_define_fields_hrtimer_init+0x60>
c103b49b: 6a 00 push $0x0
c103b49d: b9 de 01 00 00 mov $0x1de,%ecx
c103b4a2: 6a 01 push $0x1
c103b4a4: ba e6 01 00 00 mov $0x1e6,%edx
c103b4a9: 6a 04 push $0x4
c103b4ab: 89 d8 mov %ebx,%eax
c103b4ad: 6a 10 push $0x10
c103b4af: e8 fc ff ff ff call c103b4b0 <ftrace_define_fields_hrtimer_init+0x39>
c103b4b4: 83 c4 10 add $0x10,%esp
c103b4b7: 85 c0 test %eax,%eax
c103b4b9: 75 1c jne c103b4d7 <ftrace_define_fields_hrtimer_init+0x60>
c103b4bb: 6a 00 push $0x0
c103b4bd: b9 f0 01 00 00 mov $0x1f0,%ecx
c103b4c2: 6a 00 push $0x0
c103b4c4: ba f5 01 00 00 mov $0x1f5,%edx
c103b4c9: 6a 04 push $0x4
c103b4cb: 89 d8 mov %ebx,%eax
c103b4cd: 6a 14 push $0x14
c103b4cf: e8 fc ff ff ff call c103b4d0 <ftrace_define_fields_hrtimer_init+0x59>
c103b4d4: 83 c4 10 add $0x10,%esp
c103b4d7: 8b 5d fc mov -0x4(%ebp),%ebx
c103b4da: c9 leave
c103b4db: c3 ret
c103b4dc <ftrace_define_fields_hrtimer_start>:
/**
* hrtimer_start - called when the hrtimer is started
* @timer: pointer to struct hrtimer
*/
TRACE_EVENT(hrtimer_start,
c103b4dc: 55 push %ebp
c103b4dd: b9 d6 01 00 00 mov $0x1d6,%ecx
c103b4e2: 89 e5 mov %esp,%ebp
c103b4e4: ba ac 01 00 00 mov $0x1ac,%edx
c103b4e9: 53 push %ebx
c103b4ea: 89 c3 mov %eax,%ebx
c103b4ec: 6a 00 push $0x0
c103b4ee: 6a 00 push $0x0
c103b4f0: 6a 04 push $0x4
c103b4f2: 6a 0c push $0xc
c103b4f4: e8 fc ff ff ff call c103b4f5 <ftrace_define_fields_hrtimer_start+0x19>
c103b4f9: 83 c4 10 add $0x10,%esp
c103b4fc: 85 c0 test %eax,%eax
c103b4fe: 75 5c jne c103b55c <ftrace_define_fields_hrtimer_start+0x80>
c103b500: 6a 00 push $0x0
c103b502: b9 b3 01 00 00 mov $0x1b3,%ecx
c103b507: 6a 00 push $0x0
c103b509: ba ac 01 00 00 mov $0x1ac,%edx
c103b50e: 6a 04 push $0x4
c103b510: 89 d8 mov %ebx,%eax
c103b512: 6a 10 push $0x10
c103b514: e8 fc ff ff ff call c103b515 <ftrace_define_fields_hrtimer_start+0x39>
c103b519: 83 c4 10 add $0x10,%esp
c103b51c: 85 c0 test %eax,%eax
c103b51e: 75 3c jne c103b55c <ftrace_define_fields_hrtimer_start+0x80>
c103b520: 6a 00 push $0x0
c103b522: b9 bc 01 00 00 mov $0x1bc,%ecx
c103b527: 6a 01 push $0x1
c103b529: ba 07 02 00 00 mov $0x207,%edx
c103b52e: 6a 08 push $0x8
c103b530: 89 d8 mov %ebx,%eax
c103b532: 6a 14 push $0x14
c103b534: e8 fc ff ff ff call c103b535 <ftrace_define_fields_hrtimer_start+0x59>
c103b539: 83 c4 10 add $0x10,%esp
c103b53c: 85 c0 test %eax,%eax
c103b53e: 75 1c jne c103b55c <ftrace_define_fields_hrtimer_start+0x80>
c103b540: 6a 00 push $0x0
c103b542: b9 0b 02 00 00 mov $0x20b,%ecx
c103b547: 6a 01 push $0x1
c103b549: ba 07 02 00 00 mov $0x207,%edx
c103b54e: 6a 08 push $0x8
c103b550: 89 d8 mov %ebx,%eax
c103b552: 6a 1c push $0x1c
c103b554: e8 fc ff ff ff call c103b555 <ftrace_define_fields_hrtimer_start+0x79>
c103b559: 83 c4 10 add $0x10,%esp
__entry->hrtimer, __entry->function,
(unsigned long long)ktime_to_ns((ktime_t) {
.tv64 = __entry->expires }),
(unsigned long long)ktime_to_ns((ktime_t) {
.tv64 = __entry->softexpires }))
);
c103b55c: 8b 5d fc mov -0x4(%ebp),%ebx
c103b55f: c9 leave
c103b560: c3 ret
c103b561 <ftrace_define_fields_hrtimer_expire_entry>:
* @now: pointer to variable which contains current time of the
* timers base.
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(hrtimer_expire_entry,
c103b561: 55 push %ebp
c103b562: b9 d6 01 00 00 mov $0x1d6,%ecx
c103b567: 89 e5 mov %esp,%ebp
c103b569: ba ac 01 00 00 mov $0x1ac,%edx
c103b56e: 53 push %ebx
c103b56f: 89 c3 mov %eax,%ebx
c103b571: 6a 00 push $0x0
c103b573: 6a 00 push $0x0
c103b575: 6a 04 push $0x4
c103b577: 6a 0c push $0xc
c103b579: e8 fc ff ff ff call c103b57a <ftrace_define_fields_hrtimer_expire_entry+0x19>
c103b57e: 83 c4 10 add $0x10,%esp
c103b581: 85 c0 test %eax,%eax
c103b583: 75 3c jne c103b5c1 <ftrace_define_fields_hrtimer_expire_entry+0x60>
c103b585: 6a 00 push $0x0
c103b587: b9 d2 01 00 00 mov $0x1d2,%ecx
c103b58c: 6a 01 push $0x1
c103b58e: ba 07 02 00 00 mov $0x207,%edx
c103b593: 6a 08 push $0x8
c103b595: 89 d8 mov %ebx,%eax
c103b597: 6a 10 push $0x10
c103b599: e8 fc ff ff ff call c103b59a <ftrace_define_fields_hrtimer_expire_entry+0x39>
c103b59e: 83 c4 10 add $0x10,%esp
c103b5a1: 85 c0 test %eax,%eax
c103b5a3: 75 1c jne c103b5c1 <ftrace_define_fields_hrtimer_expire_entry+0x60>
c103b5a5: 6a 00 push $0x0
c103b5a7: b9 b3 01 00 00 mov $0x1b3,%ecx
c103b5ac: 6a 00 push $0x0
c103b5ae: ba ac 01 00 00 mov $0x1ac,%edx
c103b5b3: 6a 04 push $0x4
c103b5b5: 89 d8 mov %ebx,%eax
c103b5b7: 6a 18 push $0x18
c103b5b9: e8 fc ff ff ff call c103b5ba <ftrace_define_fields_hrtimer_expire_entry+0x59>
c103b5be: 83 c4 10 add $0x10,%esp
__entry->function = hrtimer->function;
),
TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
(unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
);
c103b5c1: 8b 5d fc mov -0x4(%ebp),%ebx
c103b5c4: c9 leave
c103b5c5: c3 ret
c103b5c6 <ftrace_define_fields_hrtimer_class>:
DECLARE_EVENT_CLASS(hrtimer_class,
c103b5c6: 55 push %ebp
c103b5c7: b9 d6 01 00 00 mov $0x1d6,%ecx
c103b5cc: 89 e5 mov %esp,%ebp
c103b5ce: ba ac 01 00 00 mov $0x1ac,%edx
c103b5d3: 6a 00 push $0x0
c103b5d5: 6a 00 push $0x0
c103b5d7: 6a 04 push $0x4
c103b5d9: 6a 0c push $0xc
c103b5db: e8 fc ff ff ff call c103b5dc <ftrace_define_fields_hrtimer_class+0x16>
TP_fast_assign(
__entry->hrtimer = hrtimer;
),
TP_printk("hrtimer=%p", __entry->hrtimer)
);
c103b5e0: c9 leave
c103b5e1: c3 ret
c103b5e2 <ftrace_define_fields_itimer_state>:
* @which: name of the interval timer
* @value: the itimers value, itimer is canceled if value->it_value is
* zero, otherwise it is started
* @expires: the itimers expiry time
*/
TRACE_EVENT(itimer_state,
c103b5e2: 55 push %ebp
c103b5e3: b9 17 02 00 00 mov $0x217,%ecx
c103b5e8: 89 e5 mov %esp,%ebp
c103b5ea: ba 1d 02 00 00 mov $0x21d,%edx
c103b5ef: 53 push %ebx
c103b5f0: 89 c3 mov %eax,%ebx
c103b5f2: 6a 00 push $0x0
c103b5f4: 6a 01 push $0x1
c103b5f6: 6a 04 push $0x4
c103b5f8: 6a 0c push $0xc
c103b5fa: e8 fc ff ff ff call c103b5fb <ftrace_define_fields_itimer_state+0x19>
c103b5ff: 83 c4 10 add $0x10,%esp
c103b602: 85 c0 test %eax,%eax
c103b604: 0f 85 9c 00 00 00 jne c103b6a6 <ftrace_define_fields_itimer_state+0xc4>
c103b60a: 6a 00 push $0x0
c103b60c: b9 bc 01 00 00 mov $0x1bc,%ecx
c103b611: 6a 00 push $0x0
c103b613: ba 21 02 00 00 mov $0x221,%edx
c103b618: 6a 04 push $0x4
c103b61a: 89 d8 mov %ebx,%eax
c103b61c: 6a 10 push $0x10
c103b61e: e8 fc ff ff ff call c103b61f <ftrace_define_fields_itimer_state+0x3d>
c103b623: 83 c4 10 add $0x10,%esp
c103b626: 85 c0 test %eax,%eax
c103b628: 75 7c jne c103b6a6 <ftrace_define_fields_itimer_state+0xc4>
c103b62a: 6a 00 push $0x0
c103b62c: b9 2b 02 00 00 mov $0x22b,%ecx
c103b631: 6a 01 push $0x1
c103b633: ba 35 02 00 00 mov $0x235,%edx
c103b638: 6a 04 push $0x4
c103b63a: 89 d8 mov %ebx,%eax
c103b63c: 6a 14 push $0x14
c103b63e: e8 fc ff ff ff call c103b63f <ftrace_define_fields_itimer_state+0x5d>
c103b643: 83 c4 10 add $0x10,%esp
c103b646: 85 c0 test %eax,%eax
c103b648: 75 5c jne c103b6a6 <ftrace_define_fields_itimer_state+0xc4>
c103b64a: 6a 00 push $0x0
c103b64c: b9 3a 02 00 00 mov $0x23a,%ecx
c103b651: 6a 01 push $0x1
c103b653: ba 35 02 00 00 mov $0x235,%edx
c103b658: 6a 04 push $0x4
c103b65a: 89 d8 mov %ebx,%eax
c103b65c: 6a 18 push $0x18
c103b65e: e8 fc ff ff ff call c103b65f <ftrace_define_fields_itimer_state+0x7d>
c103b663: 83 c4 10 add $0x10,%esp
c103b666: 85 c0 test %eax,%eax
c103b668: 75 3c jne c103b6a6 <ftrace_define_fields_itimer_state+0xc4>
c103b66a: 6a 00 push $0x0
c103b66c: b9 45 02 00 00 mov $0x245,%ecx
c103b671: 6a 01 push $0x1
c103b673: ba 35 02 00 00 mov $0x235,%edx
c103b678: 6a 04 push $0x4
c103b67a: 89 d8 mov %ebx,%eax
c103b67c: 6a 1c push $0x1c
c103b67e: e8 fc ff ff ff call c103b67f <ftrace_define_fields_itimer_state+0x9d>
c103b683: 83 c4 10 add $0x10,%esp
c103b686: 85 c0 test %eax,%eax
c103b688: 75 1c jne c103b6a6 <ftrace_define_fields_itimer_state+0xc4>
c103b68a: 6a 00 push $0x0
c103b68c: b9 52 02 00 00 mov $0x252,%ecx
c103b691: 6a 01 push $0x1
c103b693: ba 35 02 00 00 mov $0x235,%edx
c103b698: 6a 04 push $0x4
c103b69a: 89 d8 mov %ebx,%eax
c103b69c: 6a 20 push $0x20
c103b69e: e8 fc ff ff ff call c103b69f <ftrace_define_fields_itimer_state+0xbd>
c103b6a3: 83 c4 10 add $0x10,%esp
TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld",
__entry->which, (unsigned long long)__entry->expires,
__entry->value_sec, __entry->value_usec,
__entry->interval_sec, __entry->interval_usec)
);
c103b6a6: 8b 5d fc mov -0x4(%ebp),%ebx
c103b6a9: c9 leave
c103b6aa: c3 ret
c103b6ab <ftrace_define_fields_itimer_expire>:
* itimer_expire - called when itimer expires
* @which: type of the interval timer
* @pid: pid of the process which owns the timer
* @now: current time, used to calculate the latency of itimer
*/
TRACE_EVENT(itimer_expire,
c103b6ab: 55 push %ebp
c103b6ac: b9 17 02 00 00 mov $0x217,%ecx
c103b6b1: 89 e5 mov %esp,%ebp
c103b6b3: ba 1d 02 00 00 mov $0x21d,%edx
c103b6b8: 53 push %ebx
c103b6b9: 89 c3 mov %eax,%ebx
c103b6bb: 6a 00 push $0x0
c103b6bd: 6a 01 push $0x1
c103b6bf: 6a 04 push $0x4
c103b6c1: 6a 0c push $0xc
c103b6c3: e8 fc ff ff ff call c103b6c4 <ftrace_define_fields_itimer_expire+0x19>
c103b6c8: 83 c4 10 add $0x10,%esp
c103b6cb: 85 c0 test %eax,%eax
c103b6cd: 75 3c jne c103b70b <ftrace_define_fields_itimer_expire+0x60>
c103b6cf: 6a 00 push $0x0
c103b6d1: b9 60 02 00 00 mov $0x260,%ecx
c103b6d6: 6a 01 push $0x1
c103b6d8: ba 64 02 00 00 mov $0x264,%edx
c103b6dd: 6a 04 push $0x4
c103b6df: 89 d8 mov %ebx,%eax
c103b6e1: 6a 10 push $0x10
c103b6e3: e8 fc ff ff ff call c103b6e4 <ftrace_define_fields_itimer_expire+0x39>
c103b6e8: 83 c4 10 add $0x10,%esp
c103b6eb: 85 c0 test %eax,%eax
c103b6ed: 75 1c jne c103b70b <ftrace_define_fields_itimer_expire+0x60>
c103b6ef: 6a 00 push $0x0
c103b6f1: b9 d2 01 00 00 mov $0x1d2,%ecx
c103b6f6: 6a 00 push $0x0
c103b6f8: ba 21 02 00 00 mov $0x221,%edx
c103b6fd: 6a 04 push $0x4
c103b6ff: 89 d8 mov %ebx,%eax
c103b701: 6a 14 push $0x14
c103b703: e8 fc ff ff ff call c103b704 <ftrace_define_fields_itimer_expire+0x59>
c103b708: 83 c4 10 add $0x10,%esp
__entry->pid = pid_nr(pid);
),
TP_printk("which=%d pid=%d now=%llu", __entry->which,
(int) __entry->pid, (unsigned long long)__entry->now)
);
c103b70b: 8b 5d fc mov -0x4(%ebp),%ebx
c103b70e: c9 leave
c103b70f: c3 ret
c103b710 <perf_fetch_caller_regs>:
* - cs for user_mode() tests
* - bp for callchains
* - eflags, for future purposes, just in case
*/
static inline void perf_fetch_caller_regs(struct pt_regs *regs)
{
c103b710: 55 push %ebp
c103b711: 89 c2 mov %eax,%edx
c103b713: 89 e5 mov %esp,%ebp
memset(regs, 0, sizeof(*regs));
c103b715: 31 c0 xor %eax,%eax
* - cs for user_mode() tests
* - bp for callchains
* - eflags, for future purposes, just in case
*/
static inline void perf_fetch_caller_regs(struct pt_regs *regs)
{
c103b717: 57 push %edi
memset(regs, 0, sizeof(*regs));
c103b718: b9 11 00 00 00 mov $0x11,%ecx
c103b71d: 89 d7 mov %edx,%edi
c103b71f: f3 ab rep stos %eax,%es:(%edi)
perf_arch_fetch_caller_regs(regs, CALLER_ADDR0);
c103b721: 8b 45 04 mov 0x4(%ebp),%eax
c103b724: 89 42 30 mov %eax,0x30(%edx)
static inline unsigned long caller_frame_pointer(void)
{
struct stack_frame *frame;
get_bp(frame);
c103b727: 89 e8 mov %ebp,%eax
c103b729: 8b 00 mov (%eax),%eax
c103b72b: c7 42 34 60 00 00 00 movl $0x60,0x34(%edx)
c103b732: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
c103b739: 89 42 14 mov %eax,0x14(%edx)
}
c103b73c: 5f pop %edi
c103b73d: 5d pop %ebp
c103b73e: c3 ret
c103b73f <perf_trace_timer_class>:
#include <linux/tracepoint.h>
#include <linux/hrtimer.h>
#include <linux/timer.h>
DECLARE_EVENT_CLASS(timer_class,
c103b73f: 55 push %ebp
c103b740: 89 e5 mov %esp,%ebp
c103b742: 57 push %edi
c103b743: 89 d7 mov %edx,%edi
c103b745: 56 push %esi
c103b746: 53 push %ebx
c103b747: 89 c3 mov %eax,%ebx
c103b749: 8d 75 ac lea -0x54(%ebp),%esi
c103b74c: 83 ec 4c sub $0x4c,%esp
c103b74f: 89 f0 mov %esi,%eax
c103b751: e8 ba ff ff ff call c103b710 <perf_fetch_caller_regs>
c103b756: 0f b7 53 24 movzwl 0x24(%ebx),%edx
c103b75a: 8d 45 f0 lea -0x10(%ebp),%eax
c103b75d: 89 f1 mov %esi,%ecx
c103b75f: 50 push %eax
c103b760: b8 14 00 00 00 mov $0x14,%eax
c103b765: e8 fc ff ff ff call c103b766 <perf_trace_timer_class+0x27>
c103b76a: 59 pop %ecx
c103b76b: 85 c0 test %eax,%eax
c103b76d: 74 30 je c103b79f <perf_trace_timer_class+0x60>
c103b76f: 89 78 0c mov %edi,0xc(%eax)
c103b772: 8b 5b 44 mov 0x44(%ebx),%ebx
c103b775: 89 45 a8 mov %eax,-0x58(%ebp)
c103b778: e8 fc ff ff ff call c103b779 <perf_trace_timer_class+0x3a>
static inline void
perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
u64 count, struct pt_regs *regs, void *head)
{
perf_tp_event(addr, count, raw_data, size, regs, head, rctx);
c103b77d: 8b 55 a8 mov -0x58(%ebp),%edx
c103b780: ff 75 f0 pushl -0x10(%ebp)
c103b783: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103b78a: 31 c0 xor %eax,%eax
c103b78c: 53 push %ebx
c103b78d: 56 push %esi
c103b78e: 6a 14 push $0x14
c103b790: 52 push %edx
c103b791: 31 d2 xor %edx,%edx
c103b793: 6a 00 push $0x0
c103b795: 6a 01 push $0x1
c103b797: e8 fc ff ff ff call c103b798 <perf_trace_timer_class+0x59>
c103b79c: 83 c4 1c add $0x1c,%esp
TP_fast_assign(
__entry->timer = timer;
),
TP_printk("timer=%p", __entry->timer)
);
c103b79f: 8d 65 f4 lea -0xc(%ebp),%esp
c103b7a2: 5b pop %ebx
c103b7a3: 5e pop %esi
c103b7a4: 5f pop %edi
c103b7a5: 5d pop %ebp
c103b7a6: c3 ret
c103b7a7 <perf_trace_timer_start>:
/**
* timer_start - called when the timer is started
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
TRACE_EVENT(timer_start,
c103b7a7: 55 push %ebp
c103b7a8: 89 e5 mov %esp,%ebp
c103b7aa: 57 push %edi
c103b7ab: 56 push %esi
c103b7ac: 89 c6 mov %eax,%esi
c103b7ae: 53 push %ebx
c103b7af: 89 d3 mov %edx,%ebx
c103b7b1: 8d 7d ac lea -0x54(%ebp),%edi
c103b7b4: 83 ec 50 sub $0x50,%esp
c103b7b7: 89 f8 mov %edi,%eax
c103b7b9: 89 4d a8 mov %ecx,-0x58(%ebp)
c103b7bc: e8 4f ff ff ff call c103b710 <perf_fetch_caller_regs>
c103b7c1: 0f b7 56 24 movzwl 0x24(%esi),%edx
c103b7c5: 8d 45 f0 lea -0x10(%ebp),%eax
c103b7c8: 89 f9 mov %edi,%ecx
c103b7ca: 50 push %eax
c103b7cb: b8 1c 00 00 00 mov $0x1c,%eax
c103b7d0: e8 fc ff ff ff call c103b7d1 <perf_trace_timer_start+0x2a>
c103b7d5: 89 c2 mov %eax,%edx
c103b7d7: 85 d2 test %edx,%edx
c103b7d9: 58 pop %eax
c103b7da: 74 44 je c103b820 <perf_trace_timer_start+0x79>
c103b7dc: 89 5a 0c mov %ebx,0xc(%edx)
c103b7df: 8b 43 10 mov 0x10(%ebx),%eax
c103b7e2: 89 42 10 mov %eax,0x10(%edx)
c103b7e5: 8b 45 a8 mov -0x58(%ebp),%eax
c103b7e8: 89 42 14 mov %eax,0x14(%edx)
c103b7eb: a1 00 00 00 00 mov 0x0,%eax
c103b7f0: 89 42 18 mov %eax,0x18(%edx)
c103b7f3: 8b 5e 44 mov 0x44(%esi),%ebx
c103b7f6: 89 55 a4 mov %edx,-0x5c(%ebp)
c103b7f9: e8 fc ff ff ff call c103b7fa <perf_trace_timer_start+0x53>
c103b7fe: 8b 55 a4 mov -0x5c(%ebp),%edx
c103b801: ff 75 f0 pushl -0x10(%ebp)
c103b804: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103b80b: 31 c0 xor %eax,%eax
c103b80d: 53 push %ebx
c103b80e: 57 push %edi
c103b80f: 6a 1c push $0x1c
c103b811: 52 push %edx
c103b812: 31 d2 xor %edx,%edx
c103b814: 6a 00 push $0x0
c103b816: 6a 01 push $0x1
c103b818: e8 fc ff ff ff call c103b819 <perf_trace_timer_start+0x72>
c103b81d: 83 c4 1c add $0x1c,%esp
),
TP_printk("timer=%p function=%pf expires=%lu [timeout=%ld]",
__entry->timer, __entry->function, __entry->expires,
(long)__entry->expires - __entry->now)
);
c103b820: 8d 65 f4 lea -0xc(%ebp),%esp
c103b823: 5b pop %ebx
c103b824: 5e pop %esi
c103b825: 5f pop %edi
c103b826: 5d pop %ebp
c103b827: c3 ret
c103b828 <perf_trace_timer_expire_entry>:
* timer_expire_entry - called immediately before the timer callback
* @timer: pointer to struct timer_list
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(timer_expire_entry,
c103b828: 55 push %ebp
c103b829: 89 e5 mov %esp,%ebp
c103b82b: 57 push %edi
c103b82c: 56 push %esi
c103b82d: 89 c6 mov %eax,%esi
c103b82f: 53 push %ebx
c103b830: 89 d3 mov %edx,%ebx
c103b832: 8d 7d ac lea -0x54(%ebp),%edi
c103b835: 83 ec 4c sub $0x4c,%esp
c103b838: 89 f8 mov %edi,%eax
c103b83a: e8 d1 fe ff ff call c103b710 <perf_fetch_caller_regs>
c103b83f: 0f b7 56 24 movzwl 0x24(%esi),%edx
c103b843: 8d 45 f0 lea -0x10(%ebp),%eax
c103b846: 89 f9 mov %edi,%ecx
c103b848: 50 push %eax
c103b849: b8 1c 00 00 00 mov $0x1c,%eax
c103b84e: e8 fc ff ff ff call c103b84f <perf_trace_timer_expire_entry+0x27>
c103b853: 59 pop %ecx
c103b854: 85 c0 test %eax,%eax
c103b856: 89 c2 mov %eax,%edx
c103b858: 74 3e je c103b898 <perf_trace_timer_expire_entry+0x70>
c103b85a: 89 58 0c mov %ebx,0xc(%eax)
c103b85d: a1 00 00 00 00 mov 0x0,%eax
c103b862: 89 42 10 mov %eax,0x10(%edx)
c103b865: 8b 43 10 mov 0x10(%ebx),%eax
c103b868: 89 42 14 mov %eax,0x14(%edx)
c103b86b: 8b 5e 44 mov 0x44(%esi),%ebx
c103b86e: 89 55 a8 mov %edx,-0x58(%ebp)
c103b871: e8 fc ff ff ff call c103b872 <perf_trace_timer_expire_entry+0x4a>
c103b876: 8b 55 a8 mov -0x58(%ebp),%edx
c103b879: ff 75 f0 pushl -0x10(%ebp)
c103b87c: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103b883: 31 c0 xor %eax,%eax
c103b885: 53 push %ebx
c103b886: 57 push %edi
c103b887: 6a 1c push $0x1c
c103b889: 52 push %edx
c103b88a: 31 d2 xor %edx,%edx
c103b88c: 6a 00 push $0x0
c103b88e: 6a 01 push $0x1
c103b890: e8 fc ff ff ff call c103b891 <perf_trace_timer_expire_entry+0x69>
c103b895: 83 c4 1c add $0x1c,%esp
__entry->now = jiffies;
__entry->function = timer->function;
),
TP_printk("timer=%p function=%pf now=%lu", __entry->timer, __entry->function,__entry->now)
);
c103b898: 8d 65 f4 lea -0xc(%ebp),%esp
c103b89b: 5b pop %ebx
c103b89c: 5e pop %esi
c103b89d: 5f pop %edi
c103b89e: 5d pop %ebp
c103b89f: c3 ret
c103b8a0 <perf_trace_hrtimer_init>:
* hrtimer_init - called when the hrtimer is initialized
* @timer: pointer to struct hrtimer
* @clockid: the hrtimers clock
* @mode: the hrtimers mode
*/
TRACE_EVENT(hrtimer_init,
c103b8a0: 55 push %ebp
c103b8a1: 89 e5 mov %esp,%ebp
c103b8a3: 57 push %edi
c103b8a4: 89 d7 mov %edx,%edi
c103b8a6: 56 push %esi
c103b8a7: 53 push %ebx
c103b8a8: 89 c3 mov %eax,%ebx
c103b8aa: 8d 75 ac lea -0x54(%ebp),%esi
c103b8ad: 83 ec 50 sub $0x50,%esp
c103b8b0: 89 f0 mov %esi,%eax
c103b8b2: 89 4d a8 mov %ecx,-0x58(%ebp)
c103b8b5: e8 56 fe ff ff call c103b710 <perf_fetch_caller_regs>
c103b8ba: 0f b7 53 24 movzwl 0x24(%ebx),%edx
c103b8be: 8d 45 f0 lea -0x10(%ebp),%eax
c103b8c1: 89 f1 mov %esi,%ecx
c103b8c3: 50 push %eax
c103b8c4: b8 1c 00 00 00 mov $0x1c,%eax
c103b8c9: e8 fc ff ff ff call c103b8ca <perf_trace_hrtimer_init+0x2a>
c103b8ce: 89 c2 mov %eax,%edx
c103b8d0: 85 d2 test %edx,%edx
c103b8d2: 58 pop %eax
c103b8d3: 74 3c je c103b911 <perf_trace_hrtimer_init+0x71>
c103b8d5: 89 7a 0c mov %edi,0xc(%edx)
c103b8d8: 8b 45 a8 mov -0x58(%ebp),%eax
c103b8db: 89 42 10 mov %eax,0x10(%edx)
c103b8de: 8b 45 08 mov 0x8(%ebp),%eax
c103b8e1: 89 42 14 mov %eax,0x14(%edx)
c103b8e4: 8b 5b 44 mov 0x44(%ebx),%ebx
c103b8e7: 89 55 a4 mov %edx,-0x5c(%ebp)
c103b8ea: e8 fc ff ff ff call c103b8eb <perf_trace_hrtimer_init+0x4b>
c103b8ef: 8b 55 a4 mov -0x5c(%ebp),%edx
c103b8f2: ff 75 f0 pushl -0x10(%ebp)
c103b8f5: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103b8fc: 31 c0 xor %eax,%eax
c103b8fe: 53 push %ebx
c103b8ff: 56 push %esi
c103b900: 6a 1c push $0x1c
c103b902: 52 push %edx
c103b903: 31 d2 xor %edx,%edx
c103b905: 6a 00 push $0x0
c103b907: 6a 01 push $0x1
c103b909: e8 fc ff ff ff call c103b90a <perf_trace_hrtimer_init+0x6a>
c103b90e: 83 c4 1c add $0x1c,%esp
TP_printk("hrtimer=%p clockid=%s mode=%s", __entry->hrtimer,
__entry->clockid == CLOCK_REALTIME ?
"CLOCK_REALTIME" : "CLOCK_MONOTONIC",
__entry->mode == HRTIMER_MODE_ABS ?
"HRTIMER_MODE_ABS" : "HRTIMER_MODE_REL")
);
c103b911: 8d 65 f4 lea -0xc(%ebp),%esp
c103b914: 5b pop %ebx
c103b915: 5e pop %esi
c103b916: 5f pop %edi
c103b917: 5d pop %ebp
c103b918: c3 ret
c103b919 <perf_trace_hrtimer_start>:
/**
* hrtimer_start - called when the hrtimer is started
* @timer: pointer to struct hrtimer
*/
TRACE_EVENT(hrtimer_start,
c103b919: 55 push %ebp
c103b91a: 89 e5 mov %esp,%ebp
c103b91c: 57 push %edi
c103b91d: 56 push %esi
c103b91e: 53 push %ebx
c103b91f: 89 d3 mov %edx,%ebx
c103b921: 83 ec 50 sub $0x50,%esp
c103b924: 89 45 a4 mov %eax,-0x5c(%ebp)
c103b927: 8d 45 ac lea -0x54(%ebp),%eax
c103b92a: e8 e1 fd ff ff call c103b710 <perf_fetch_caller_regs>
c103b92f: 8b 45 a4 mov -0x5c(%ebp),%eax
c103b932: 8d 4d ac lea -0x54(%ebp),%ecx
c103b935: 0f b7 50 24 movzwl 0x24(%eax),%edx
c103b939: 8d 45 f0 lea -0x10(%ebp),%eax
c103b93c: 50 push %eax
c103b93d: b8 24 00 00 00 mov $0x24,%eax
c103b942: e8 fc ff ff ff call c103b943 <perf_trace_hrtimer_start+0x2a>
c103b947: 59 pop %ecx
c103b948: 85 c0 test %eax,%eax
c103b94a: 89 c2 mov %eax,%edx
c103b94c: 74 54 je c103b9a2 <perf_trace_hrtimer_start+0x89>
c103b94e: 89 58 0c mov %ebx,0xc(%eax)
c103b951: 8b 43 1c mov 0x1c(%ebx),%eax
c103b954: 89 42 10 mov %eax,0x10(%edx)
c103b957: 8b 7b 10 mov 0x10(%ebx),%edi
c103b95a: 8b 73 0c mov 0xc(%ebx),%esi
c103b95d: 89 7a 18 mov %edi,0x18(%edx)
c103b960: 89 72 14 mov %esi,0x14(%edx)
return timer->node.expires;
}
static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
{
return timer->_softexpires;
c103b963: 8b 4b 14 mov 0x14(%ebx),%ecx
c103b966: 8b 5b 18 mov 0x18(%ebx),%ebx
c103b969: 89 4a 1c mov %ecx,0x1c(%edx)
c103b96c: 89 5a 20 mov %ebx,0x20(%edx)
c103b96f: 8b 7d a4 mov -0x5c(%ebp),%edi
c103b972: 8b 5f 44 mov 0x44(%edi),%ebx
c103b975: 89 55 a8 mov %edx,-0x58(%ebp)
c103b978: e8 fc ff ff ff call c103b979 <perf_trace_hrtimer_start+0x60>
c103b97d: 8b 55 a8 mov -0x58(%ebp),%edx
c103b980: ff 75 f0 pushl -0x10(%ebp)
c103b983: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103b98a: 8d 45 ac lea -0x54(%ebp),%eax
c103b98d: 53 push %ebx
c103b98e: 50 push %eax
c103b98f: 31 c0 xor %eax,%eax
c103b991: 6a 24 push $0x24
c103b993: 52 push %edx
c103b994: 31 d2 xor %edx,%edx
c103b996: 6a 00 push $0x0
c103b998: 6a 01 push $0x1
c103b99a: e8 fc ff ff ff call c103b99b <perf_trace_hrtimer_start+0x82>
c103b99f: 83 c4 1c add $0x1c,%esp
__entry->hrtimer, __entry->function,
(unsigned long long)ktime_to_ns((ktime_t) {
.tv64 = __entry->expires }),
(unsigned long long)ktime_to_ns((ktime_t) {
.tv64 = __entry->softexpires }))
);
c103b9a2: 8d 65 f4 lea -0xc(%ebp),%esp
c103b9a5: 5b pop %ebx
c103b9a6: 5e pop %esi
c103b9a7: 5f pop %edi
c103b9a8: 5d pop %ebp
c103b9a9: c3 ret
c103b9aa <perf_trace_hrtimer_expire_entry>:
* @now: pointer to variable which contains current time of the
* timers base.
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(hrtimer_expire_entry,
c103b9aa: 55 push %ebp
c103b9ab: 89 e5 mov %esp,%ebp
c103b9ad: 57 push %edi
c103b9ae: 89 c7 mov %eax,%edi
c103b9b0: 56 push %esi
c103b9b1: 89 ce mov %ecx,%esi
c103b9b3: 53 push %ebx
c103b9b4: 83 ec 50 sub $0x50,%esp
c103b9b7: 8d 45 ac lea -0x54(%ebp),%eax
c103b9ba: 89 55 a4 mov %edx,-0x5c(%ebp)
c103b9bd: e8 4e fd ff ff call c103b710 <perf_fetch_caller_regs>
c103b9c2: 0f b7 57 24 movzwl 0x24(%edi),%edx
c103b9c6: 8d 45 f0 lea -0x10(%ebp),%eax
c103b9c9: 8d 4d ac lea -0x54(%ebp),%ecx
c103b9cc: 50 push %eax
c103b9cd: b8 1c 00 00 00 mov $0x1c,%eax
c103b9d2: e8 fc ff ff ff call c103b9d3 <perf_trace_hrtimer_expire_entry+0x29>
c103b9d7: 5b pop %ebx
c103b9d8: 85 c0 test %eax,%eax
c103b9da: 89 c2 mov %eax,%edx
c103b9dc: 74 4a je c103ba28 <perf_trace_hrtimer_expire_entry+0x7e>
c103b9de: 8b 45 a4 mov -0x5c(%ebp),%eax
c103b9e1: 89 42 0c mov %eax,0xc(%edx)
c103b9e4: 8b 0e mov (%esi),%ecx
c103b9e6: 8b 5e 04 mov 0x4(%esi),%ebx
c103b9e9: 89 4a 10 mov %ecx,0x10(%edx)
c103b9ec: 89 5a 14 mov %ebx,0x14(%edx)
c103b9ef: 8b 5d a4 mov -0x5c(%ebp),%ebx
c103b9f2: 8b 43 1c mov 0x1c(%ebx),%eax
c103b9f5: 89 42 18 mov %eax,0x18(%edx)
c103b9f8: 8b 5f 44 mov 0x44(%edi),%ebx
c103b9fb: 89 55 a8 mov %edx,-0x58(%ebp)
c103b9fe: e8 fc ff ff ff call c103b9ff <perf_trace_hrtimer_expire_entry+0x55>
c103ba03: 8b 55 a8 mov -0x58(%ebp),%edx
c103ba06: ff 75 f0 pushl -0x10(%ebp)
c103ba09: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103ba10: 8d 45 ac lea -0x54(%ebp),%eax
c103ba13: 53 push %ebx
c103ba14: 50 push %eax
c103ba15: 31 c0 xor %eax,%eax
c103ba17: 6a 1c push $0x1c
c103ba19: 52 push %edx
c103ba1a: 31 d2 xor %edx,%edx
c103ba1c: 6a 00 push $0x0
c103ba1e: 6a 01 push $0x1
c103ba20: e8 fc ff ff ff call c103ba21 <perf_trace_hrtimer_expire_entry+0x77>
c103ba25: 83 c4 1c add $0x1c,%esp
__entry->function = hrtimer->function;
),
TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
(unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
);
c103ba28: 8d 65 f4 lea -0xc(%ebp),%esp
c103ba2b: 5b pop %ebx
c103ba2c: 5e pop %esi
c103ba2d: 5f pop %edi
c103ba2e: 5d pop %ebp
c103ba2f: c3 ret
c103ba30 <perf_trace_hrtimer_class>:
DECLARE_EVENT_CLASS(hrtimer_class,
c103ba30: 55 push %ebp
c103ba31: 89 e5 mov %esp,%ebp
c103ba33: 57 push %edi
c103ba34: 89 d7 mov %edx,%edi
c103ba36: 56 push %esi
c103ba37: 53 push %ebx
c103ba38: 89 c3 mov %eax,%ebx
c103ba3a: 8d 75 ac lea -0x54(%ebp),%esi
c103ba3d: 83 ec 4c sub $0x4c,%esp
c103ba40: 89 f0 mov %esi,%eax
c103ba42: e8 c9 fc ff ff call c103b710 <perf_fetch_caller_regs>
c103ba47: 0f b7 53 24 movzwl 0x24(%ebx),%edx
c103ba4b: 8d 45 f0 lea -0x10(%ebp),%eax
c103ba4e: 89 f1 mov %esi,%ecx
c103ba50: 50 push %eax
c103ba51: b8 14 00 00 00 mov $0x14,%eax
c103ba56: e8 fc ff ff ff call c103ba57 <perf_trace_hrtimer_class+0x27>
c103ba5b: 89 c2 mov %eax,%edx
c103ba5d: 85 d2 test %edx,%edx
c103ba5f: 58 pop %eax
c103ba60: 74 30 je c103ba92 <perf_trace_hrtimer_class+0x62>
c103ba62: 89 7a 0c mov %edi,0xc(%edx)
c103ba65: 8b 5b 44 mov 0x44(%ebx),%ebx
c103ba68: 89 55 a8 mov %edx,-0x58(%ebp)
c103ba6b: e8 fc ff ff ff call c103ba6c <perf_trace_hrtimer_class+0x3c>
c103ba70: 8b 55 a8 mov -0x58(%ebp),%edx
c103ba73: ff 75 f0 pushl -0x10(%ebp)
c103ba76: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103ba7d: 31 c0 xor %eax,%eax
c103ba7f: 53 push %ebx
c103ba80: 56 push %esi
c103ba81: 6a 14 push $0x14
c103ba83: 52 push %edx
c103ba84: 31 d2 xor %edx,%edx
c103ba86: 6a 00 push $0x0
c103ba88: 6a 01 push $0x1
c103ba8a: e8 fc ff ff ff call c103ba8b <perf_trace_hrtimer_class+0x5b>
c103ba8f: 83 c4 1c add $0x1c,%esp
TP_fast_assign(
__entry->hrtimer = hrtimer;
),
TP_printk("hrtimer=%p", __entry->hrtimer)
);
c103ba92: 8d 65 f4 lea -0xc(%ebp),%esp
c103ba95: 5b pop %ebx
c103ba96: 5e pop %esi
c103ba97: 5f pop %edi
c103ba98: 5d pop %ebp
c103ba99: c3 ret
c103ba9a <perf_trace_itimer_state>:
* @which: name of the interval timer
* @value: the itimers value, itimer is canceled if value->it_value is
* zero, otherwise it is started
* @expires: the itimers expiry time
*/
TRACE_EVENT(itimer_state,
c103ba9a: 55 push %ebp
c103ba9b: 89 e5 mov %esp,%ebp
c103ba9d: 57 push %edi
c103ba9e: 56 push %esi
c103ba9f: 89 c6 mov %eax,%esi
c103baa1: 53 push %ebx
c103baa2: 89 cb mov %ecx,%ebx
c103baa4: 8d 7d ac lea -0x54(%ebp),%edi
c103baa7: 83 ec 50 sub $0x50,%esp
c103baaa: 89 f8 mov %edi,%eax
c103baac: 89 55 a8 mov %edx,-0x58(%ebp)
c103baaf: e8 5c fc ff ff call c103b710 <perf_fetch_caller_regs>
c103bab4: 0f b7 56 24 movzwl 0x24(%esi),%edx
c103bab8: 8d 45 f0 lea -0x10(%ebp),%eax
c103babb: 89 f9 mov %edi,%ecx
c103babd: 50 push %eax
c103babe: b8 24 00 00 00 mov $0x24,%eax
c103bac3: e8 fc ff ff ff call c103bac4 <perf_trace_itimer_state+0x2a>
c103bac8: 59 pop %ecx
c103bac9: 85 c0 test %eax,%eax
c103bacb: 89 c2 mov %eax,%edx
c103bacd: 74 50 je c103bb1f <perf_trace_itimer_state+0x85>
c103bacf: 8b 45 a8 mov -0x58(%ebp),%eax
c103bad2: 89 42 0c mov %eax,0xc(%edx)
c103bad5: 8b 45 08 mov 0x8(%ebp),%eax
c103bad8: 89 42 10 mov %eax,0x10(%edx)
c103badb: 8b 43 08 mov 0x8(%ebx),%eax
c103bade: 89 42 14 mov %eax,0x14(%edx)
c103bae1: 8b 43 0c mov 0xc(%ebx),%eax
c103bae4: 89 42 18 mov %eax,0x18(%edx)
c103bae7: 8b 03 mov (%ebx),%eax
c103bae9: 89 42 1c mov %eax,0x1c(%edx)
c103baec: 8b 43 04 mov 0x4(%ebx),%eax
c103baef: 89 42 20 mov %eax,0x20(%edx)
c103baf2: 8b 5e 44 mov 0x44(%esi),%ebx
c103baf5: 89 55 a4 mov %edx,-0x5c(%ebp)
c103baf8: e8 fc ff ff ff call c103baf9 <perf_trace_itimer_state+0x5f>
c103bafd: 8b 55 a4 mov -0x5c(%ebp),%edx
c103bb00: ff 75 f0 pushl -0x10(%ebp)
c103bb03: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103bb0a: 31 c0 xor %eax,%eax
c103bb0c: 53 push %ebx
c103bb0d: 57 push %edi
c103bb0e: 6a 24 push $0x24
c103bb10: 52 push %edx
c103bb11: 31 d2 xor %edx,%edx
c103bb13: 6a 00 push $0x0
c103bb15: 6a 01 push $0x1
c103bb17: e8 fc ff ff ff call c103bb18 <perf_trace_itimer_state+0x7e>
c103bb1c: 83 c4 1c add $0x1c,%esp
TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld",
__entry->which, (unsigned long long)__entry->expires,
__entry->value_sec, __entry->value_usec,
__entry->interval_sec, __entry->interval_usec)
);
c103bb1f: 8d 65 f4 lea -0xc(%ebp),%esp
c103bb22: 5b pop %ebx
c103bb23: 5e pop %esi
c103bb24: 5f pop %edi
c103bb25: 5d pop %ebp
c103bb26: c3 ret
c103bb27 <perf_trace_itimer_expire>:
* itimer_expire - called when itimer expires
* @which: type of the interval timer
* @pid: pid of the process which owns the timer
* @now: current time, used to calculate the latency of itimer
*/
TRACE_EVENT(itimer_expire,
c103bb27: 55 push %ebp
c103bb28: 89 e5 mov %esp,%ebp
c103bb2a: 57 push %edi
c103bb2b: 56 push %esi
c103bb2c: 89 c6 mov %eax,%esi
c103bb2e: 53 push %ebx
c103bb2f: 89 cb mov %ecx,%ebx
c103bb31: 8d 7d ac lea -0x54(%ebp),%edi
c103bb34: 83 ec 4c sub $0x4c,%esp
c103bb37: 89 f8 mov %edi,%eax
c103bb39: 89 55 a8 mov %edx,-0x58(%ebp)
c103bb3c: e8 cf fb ff ff call c103b710 <perf_fetch_caller_regs>
c103bb41: 0f b7 56 24 movzwl 0x24(%esi),%edx
c103bb45: 8d 45 f0 lea -0x10(%ebp),%eax
c103bb48: 89 f9 mov %edi,%ecx
c103bb4a: 50 push %eax
c103bb4b: b8 1c 00 00 00 mov $0x1c,%eax
c103bb50: e8 fc ff ff ff call c103bb51 <perf_trace_itimer_expire+0x2a>
c103bb55: 89 c7 mov %eax,%edi
c103bb57: 85 ff test %edi,%edi
c103bb59: 58 pop %eax
c103bb5a: 74 42 je c103bb9e <perf_trace_itimer_expire+0x77>
c103bb5c: 8b 45 a8 mov -0x58(%ebp),%eax
c103bb5f: 89 47 0c mov %eax,0xc(%edi)
c103bb62: 8b 45 08 mov 0x8(%ebp),%eax
c103bb65: 89 47 14 mov %eax,0x14(%edi)
*/
static inline pid_t pid_nr(struct pid *pid)
{
pid_t nr = 0;
if (pid)
c103bb68: 31 c0 xor %eax,%eax
c103bb6a: 85 db test %ebx,%ebx
c103bb6c: 74 03 je c103bb71 <perf_trace_itimer_expire+0x4a>
nr = pid->numbers[0].nr;
c103bb6e: 8b 43 1c mov 0x1c(%ebx),%eax
c103bb71: 89 47 10 mov %eax,0x10(%edi)
c103bb74: 8b 5e 44 mov 0x44(%esi),%ebx
c103bb77: e8 fc ff ff ff call c103bb78 <perf_trace_itimer_expire+0x51>
c103bb7c: 31 d2 xor %edx,%edx
c103bb7e: ff 75 f0 pushl -0x10(%ebp)
c103bb81: 03 1c 85 00 00 00 00 add 0x0(,%eax,4),%ebx
c103bb88: 8d 45 ac lea -0x54(%ebp),%eax
c103bb8b: 53 push %ebx
c103bb8c: 50 push %eax
c103bb8d: 31 c0 xor %eax,%eax
c103bb8f: 6a 1c push $0x1c
c103bb91: 57 push %edi
c103bb92: 6a 00 push $0x0
c103bb94: 6a 01 push $0x1
c103bb96: e8 fc ff ff ff call c103bb97 <perf_trace_itimer_expire+0x70>
c103bb9b: 83 c4 1c add $0x1c,%esp
__entry->pid = pid_nr(pid);
),
TP_printk("which=%d pid=%d now=%llu", __entry->which,
(int) __entry->pid, (unsigned long long)__entry->now)
);
c103bb9e: 8d 65 f4 lea -0xc(%ebp),%esp
c103bba1: 5b pop %ebx
c103bba2: 5e pop %esi
c103bba3: 5f pop %edi
c103bba4: 5d pop %ebp
c103bba5: c3 ret
c103bba6 <ftrace_raw_event_timer_class>:
#include <linux/tracepoint.h>
#include <linux/hrtimer.h>
#include <linux/timer.h>
DECLARE_EVENT_CLASS(timer_class,
c103bba6: 55 push %ebp
c103bba7: 89 e5 mov %esp,%ebp
c103bba9: 57 push %edi
c103bbaa: 56 push %esi
c103bbab: 89 c6 mov %eax,%esi
c103bbad: 53 push %ebx
c103bbae: 83 ec 0c sub $0xc,%esp
c103bbb1: 89 55 e8 mov %edx,-0x18(%ebp)
/*
* "=rm" is safe here, because "pop" adjusts the stack before
* it evaluates its effective address -- this is part of the
* documented behavior of the "pop" instruction.
*/
asm volatile("# __raw_save_flags\n\t"
c103bbb4: 9c pushf
c103bbb5: 8f 45 ec popl -0x14(%ebp)
c103bbb8: 89 e0 mov %esp,%eax
c103bbba: 8b 56 24 mov 0x24(%esi),%edx
c103bbbd: b9 10 00 00 00 mov $0x10,%ecx
c103bbc2: 25 00 e0 ff ff and $0xffffe000,%eax
c103bbc7: 8b 78 14 mov 0x14(%eax),%edi
c103bbca: 8d 45 f0 lea -0x10(%ebp),%eax
c103bbcd: 57 push %edi
c103bbce: ff 75 ec pushl -0x14(%ebp)
c103bbd1: e8 fc ff ff ff call c103bbd2 <ftrace_raw_event_timer_class+0x2c>
c103bbd6: 89 c3 mov %eax,%ebx
c103bbd8: 85 db test %ebx,%ebx
c103bbda: 58 pop %eax
c103bbdb: 5a pop %edx
c103bbdc: 74 2e je c103bc0c <ftrace_raw_event_timer_class+0x66>
c103bbde: 89 d8 mov %ebx,%eax
c103bbe0: e8 fc ff ff ff call c103bbe1 <ftrace_raw_event_timer_class+0x3b>
c103bbe5: 8b 55 e8 mov -0x18(%ebp),%edx
c103bbe8: 89 c1 mov %eax,%ecx
c103bbea: 89 50 0c mov %edx,0xc(%eax)
c103bbed: 8b 45 f0 mov -0x10(%ebp),%eax
c103bbf0: 89 f2 mov %esi,%edx
c103bbf2: 53 push %ebx
c103bbf3: e8 fc ff ff ff call c103bbf4 <ftrace_raw_event_timer_class+0x4e>
c103bbf8: 59 pop %ecx
c103bbf9: 85 c0 test %eax,%eax
c103bbfb: 75 0f jne c103bc0c <ftrace_raw_event_timer_class+0x66>
c103bbfd: 8b 4d ec mov -0x14(%ebp),%ecx
c103bc00: 89 da mov %ebx,%edx
c103bc02: 8b 45 f0 mov -0x10(%ebp),%eax
c103bc05: 57 push %edi
c103bc06: e8 fc ff ff ff call c103bc07 <ftrace_raw_event_timer_class+0x61>
c103bc0b: 5a pop %edx
c103bc0c: 8d 65 f4 lea -0xc(%ebp),%esp
c103bc0f: 5b pop %ebx
c103bc10: 5e pop %esi
c103bc11: 5f pop %edi
c103bc12: 5d pop %ebp
c103bc13: c3 ret
c103bc14 <ftrace_raw_event_timer_start>:
/**
* timer_start - called when the timer is started
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
TRACE_EVENT(timer_start,
c103bc14: 55 push %ebp
c103bc15: 89 e5 mov %esp,%ebp
c103bc17: 57 push %edi
c103bc18: 89 c7 mov %eax,%edi
c103bc1a: 56 push %esi
c103bc1b: 53 push %ebx
c103bc1c: 89 d3 mov %edx,%ebx
c103bc1e: 83 ec 10 sub $0x10,%esp
c103bc21: 89 4d e4 mov %ecx,-0x1c(%ebp)
c103bc24: 9c pushf
c103bc25: 8f 45 e8 popl -0x18(%ebp)
c103bc28: 89 e0 mov %esp,%eax
c103bc2a: 8b 57 24 mov 0x24(%edi),%edx
c103bc2d: b9 1c 00 00 00 mov $0x1c,%ecx
c103bc32: 25 00 e0 ff ff and $0xffffe000,%eax
c103bc37: 8b 40 14 mov 0x14(%eax),%eax
c103bc3a: 89 45 ec mov %eax,-0x14(%ebp)
c103bc3d: 8d 45 f0 lea -0x10(%ebp),%eax
c103bc40: ff 75 ec pushl -0x14(%ebp)
c103bc43: ff 75 e8 pushl -0x18(%ebp)
c103bc46: e8 fc ff ff ff call c103bc47 <ftrace_raw_event_timer_start+0x33>
c103bc4b: 89 c6 mov %eax,%esi
c103bc4d: 85 f6 test %esi,%esi
c103bc4f: 58 pop %eax
c103bc50: 5a pop %edx
c103bc51: 74 42 je c103bc95 <ftrace_raw_event_timer_start+0x81>
c103bc53: 89 f0 mov %esi,%eax
c103bc55: e8 fc ff ff ff call c103bc56 <ftrace_raw_event_timer_start+0x42>
c103bc5a: 89 58 0c mov %ebx,0xc(%eax)
c103bc5d: 8b 53 10 mov 0x10(%ebx),%edx
c103bc60: 89 c1 mov %eax,%ecx
c103bc62: 89 50 10 mov %edx,0x10(%eax)
c103bc65: 8b 55 e4 mov -0x1c(%ebp),%edx
c103bc68: 89 50 14 mov %edx,0x14(%eax)
c103bc6b: 8b 15 00 00 00 00 mov 0x0,%edx
c103bc71: 89 50 18 mov %edx,0x18(%eax)
c103bc74: 8b 45 f0 mov -0x10(%ebp),%eax
c103bc77: 89 fa mov %edi,%edx
c103bc79: 56 push %esi
c103bc7a: e8 fc ff ff ff call c103bc7b <ftrace_raw_event_timer_start+0x67>
c103bc7f: 5b pop %ebx
c103bc80: 85 c0 test %eax,%eax
c103bc82: 75 11 jne c103bc95 <ftrace_raw_event_timer_start+0x81>
c103bc84: 8b 4d e8 mov -0x18(%ebp),%ecx
c103bc87: 89 f2 mov %esi,%edx
c103bc89: ff 75 ec pushl -0x14(%ebp)
c103bc8c: 8b 45 f0 mov -0x10(%ebp),%eax
c103bc8f: e8 fc ff ff ff call c103bc90 <ftrace_raw_event_timer_start+0x7c>
c103bc94: 59 pop %ecx
c103bc95: 8d 65 f4 lea -0xc(%ebp),%esp
c103bc98: 5b pop %ebx
c103bc99: 5e pop %esi
c103bc9a: 5f pop %edi
c103bc9b: 5d pop %ebp
c103bc9c: c3 ret
c103bc9d <ftrace_raw_event_timer_expire_entry>:
* timer_expire_entry - called immediately before the timer callback
* @timer: pointer to struct timer_list
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(timer_expire_entry,
c103bc9d: 55 push %ebp
c103bc9e: 89 e5 mov %esp,%ebp
c103bca0: 57 push %edi
c103bca1: 89 c7 mov %eax,%edi
c103bca3: 56 push %esi
c103bca4: 53 push %ebx
c103bca5: 89 d3 mov %edx,%ebx
c103bca7: 83 ec 0c sub $0xc,%esp
c103bcaa: 9c pushf
c103bcab: 8f 45 e8 popl -0x18(%ebp)
c103bcae: 89 e0 mov %esp,%eax
c103bcb0: 8b 57 24 mov 0x24(%edi),%edx
c103bcb3: b9 18 00 00 00 mov $0x18,%ecx
c103bcb8: 25 00 e0 ff ff and $0xffffe000,%eax
c103bcbd: 8b 40 14 mov 0x14(%eax),%eax
c103bcc0: 89 45 ec mov %eax,-0x14(%ebp)
c103bcc3: 8d 45 f0 lea -0x10(%ebp),%eax
c103bcc6: ff 75 ec pushl -0x14(%ebp)
c103bcc9: ff 75 e8 pushl -0x18(%ebp)
c103bccc: e8 fc ff ff ff call c103bccd <ftrace_raw_event_timer_expire_entry+0x30>
c103bcd1: 89 c6 mov %eax,%esi
c103bcd3: 85 f6 test %esi,%esi
c103bcd5: 58 pop %eax
c103bcd6: 5a pop %edx
c103bcd7: 74 3c je c103bd15 <ftrace_raw_event_timer_expire_entry+0x78>
c103bcd9: 89 f0 mov %esi,%eax
c103bcdb: e8 fc ff ff ff call c103bcdc <ftrace_raw_event_timer_expire_entry+0x3f>
c103bce0: 89 58 0c mov %ebx,0xc(%eax)
c103bce3: 8b 15 00 00 00 00 mov 0x0,%edx
c103bce9: 89 c1 mov %eax,%ecx
c103bceb: 89 50 10 mov %edx,0x10(%eax)
c103bcee: 8b 53 10 mov 0x10(%ebx),%edx
c103bcf1: 89 50 14 mov %edx,0x14(%eax)
c103bcf4: 8b 45 f0 mov -0x10(%ebp),%eax
c103bcf7: 89 fa mov %edi,%edx
c103bcf9: 56 push %esi
c103bcfa: e8 fc ff ff ff call c103bcfb <ftrace_raw_event_timer_expire_entry+0x5e>
c103bcff: 5b pop %ebx
c103bd00: 85 c0 test %eax,%eax
c103bd02: 75 11 jne c103bd15 <ftrace_raw_event_timer_expire_entry+0x78>
c103bd04: 8b 4d e8 mov -0x18(%ebp),%ecx
c103bd07: 89 f2 mov %esi,%edx
c103bd09: ff 75 ec pushl -0x14(%ebp)
c103bd0c: 8b 45 f0 mov -0x10(%ebp),%eax
c103bd0f: e8 fc ff ff ff call c103bd10 <ftrace_raw_event_timer_expire_entry+0x73>
c103bd14: 59 pop %ecx
c103bd15: 8d 65 f4 lea -0xc(%ebp),%esp
c103bd18: 5b pop %ebx
c103bd19: 5e pop %esi
c103bd1a: 5f pop %edi
c103bd1b: 5d pop %ebp
c103bd1c: c3 ret
c103bd1d <ftrace_raw_event_hrtimer_init>:
* hrtimer_init - called when the hrtimer is initialized
* @timer: pointer to struct hrtimer
* @clockid: the hrtimers clock
* @mode: the hrtimers mode
*/
TRACE_EVENT(hrtimer_init,
c103bd1d: 55 push %ebp
c103bd1e: 89 e5 mov %esp,%ebp
c103bd20: 57 push %edi
c103bd21: 56 push %esi
c103bd22: 89 c6 mov %eax,%esi
c103bd24: 53 push %ebx
c103bd25: 83 ec 10 sub $0x10,%esp
c103bd28: 89 55 e8 mov %edx,-0x18(%ebp)
c103bd2b: 89 4d e4 mov %ecx,-0x1c(%ebp)
c103bd2e: 9c pushf
c103bd2f: 8f 45 ec popl -0x14(%ebp)
c103bd32: 89 e0 mov %esp,%eax
c103bd34: 8b 56 24 mov 0x24(%esi),%edx
c103bd37: b9 18 00 00 00 mov $0x18,%ecx
c103bd3c: 25 00 e0 ff ff and $0xffffe000,%eax
c103bd41: 8b 78 14 mov 0x14(%eax),%edi
c103bd44: 8d 45 f0 lea -0x10(%ebp),%eax
c103bd47: 57 push %edi
c103bd48: ff 75 ec pushl -0x14(%ebp)
c103bd4b: e8 fc ff ff ff call c103bd4c <ftrace_raw_event_hrtimer_init+0x2f>
c103bd50: 89 c3 mov %eax,%ebx
c103bd52: 85 db test %ebx,%ebx
c103bd54: 58 pop %eax
c103bd55: 5a pop %edx
c103bd56: 74 3a je c103bd92 <ftrace_raw_event_hrtimer_init+0x75>
c103bd58: 89 d8 mov %ebx,%eax
c103bd5a: e8 fc ff ff ff call c103bd5b <ftrace_raw_event_hrtimer_init+0x3e>
c103bd5f: 8b 55 e8 mov -0x18(%ebp),%edx
c103bd62: 89 50 0c mov %edx,0xc(%eax)
c103bd65: 8b 55 e4 mov -0x1c(%ebp),%edx
c103bd68: 89 c1 mov %eax,%ecx
c103bd6a: 89 50 10 mov %edx,0x10(%eax)
c103bd6d: 8b 55 08 mov 0x8(%ebp),%edx
c103bd70: 89 50 14 mov %edx,0x14(%eax)
c103bd73: 8b 45 f0 mov -0x10(%ebp),%eax
c103bd76: 89 f2 mov %esi,%edx
c103bd78: 53 push %ebx
c103bd79: e8 fc ff ff ff call c103bd7a <ftrace_raw_event_hrtimer_init+0x5d>
c103bd7e: 5e pop %esi
c103bd7f: 85 c0 test %eax,%eax
c103bd81: 75 0f jne c103bd92 <ftrace_raw_event_hrtimer_init+0x75>
c103bd83: 8b 4d ec mov -0x14(%ebp),%ecx
c103bd86: 89 da mov %ebx,%edx
c103bd88: 8b 45 f0 mov -0x10(%ebp),%eax
c103bd8b: 57 push %edi
c103bd8c: e8 fc ff ff ff call c103bd8d <ftrace_raw_event_hrtimer_init+0x70>
c103bd91: 59 pop %ecx
c103bd92: 8d 65 f4 lea -0xc(%ebp),%esp
c103bd95: 5b pop %ebx
c103bd96: 5e pop %esi
c103bd97: 5f pop %edi
c103bd98: 5d pop %ebp
c103bd99: c3 ret
c103bd9a <ftrace_raw_event_hrtimer_start>:
/**
* hrtimer_start - called when the hrtimer is started
* @timer: pointer to struct hrtimer
*/
TRACE_EVENT(hrtimer_start,
c103bd9a: 55 push %ebp
c103bd9b: 89 e5 mov %esp,%ebp
c103bd9d: 57 push %edi
c103bd9e: 89 c7 mov %eax,%edi
c103bda0: 56 push %esi
c103bda1: 53 push %ebx
c103bda2: 89 d3 mov %edx,%ebx
c103bda4: 83 ec 0c sub $0xc,%esp
c103bda7: 9c pushf
c103bda8: 8f 45 e8 popl -0x18(%ebp)
c103bdab: 89 e0 mov %esp,%eax
c103bdad: 8b 57 24 mov 0x24(%edi),%edx
c103bdb0: b9 24 00 00 00 mov $0x24,%ecx
c103bdb5: 25 00 e0 ff ff and $0xffffe000,%eax
c103bdba: 8b 40 14 mov 0x14(%eax),%eax
c103bdbd: 89 45 ec mov %eax,-0x14(%ebp)
c103bdc0: 8d 45 f0 lea -0x10(%ebp),%eax
c103bdc3: ff 75 ec pushl -0x14(%ebp)
c103bdc6: ff 75 e8 pushl -0x18(%ebp)
c103bdc9: e8 fc ff ff ff call c103bdca <ftrace_raw_event_hrtimer_start+0x30>
c103bdce: 89 c6 mov %eax,%esi
c103bdd0: 85 f6 test %esi,%esi
c103bdd2: 58 pop %eax
c103bdd3: 5a pop %edx
c103bdd4: 74 4b je c103be21 <ftrace_raw_event_hrtimer_start+0x87>
c103bdd6: 89 f0 mov %esi,%eax
c103bdd8: e8 fc ff ff ff call c103bdd9 <ftrace_raw_event_hrtimer_start+0x3f>
c103bddd: 89 58 0c mov %ebx,0xc(%eax)
c103bde0: 8b 53 1c mov 0x1c(%ebx),%edx
c103bde3: 89 50 10 mov %edx,0x10(%eax)
timer->_softexpires = ktime_add_ns(timer->_softexpires, ns);
}
static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer)
{
return timer->node.expires;
c103bde6: 8b 53 0c mov 0xc(%ebx),%edx
c103bde9: 8b 4b 10 mov 0x10(%ebx),%ecx
c103bdec: 89 50 14 mov %edx,0x14(%eax)
c103bdef: 89 48 18 mov %ecx,0x18(%eax)
}
static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
{
return timer->_softexpires;
c103bdf2: 8b 53 14 mov 0x14(%ebx),%edx
c103bdf5: 8b 4b 18 mov 0x18(%ebx),%ecx
c103bdf8: 89 50 1c mov %edx,0x1c(%eax)
c103bdfb: 89 fa mov %edi,%edx
c103bdfd: 89 48 20 mov %ecx,0x20(%eax)
c103be00: 89 c1 mov %eax,%ecx
c103be02: 8b 45 f0 mov -0x10(%ebp),%eax
c103be05: 56 push %esi
c103be06: e8 fc ff ff ff call c103be07 <ftrace_raw_event_hrtimer_start+0x6d>
c103be0b: 5b pop %ebx
c103be0c: 85 c0 test %eax,%eax
c103be0e: 75 11 jne c103be21 <ftrace_raw_event_hrtimer_start+0x87>
c103be10: 8b 4d e8 mov -0x18(%ebp),%ecx
c103be13: 89 f2 mov %esi,%edx
c103be15: ff 75 ec pushl -0x14(%ebp)
c103be18: 8b 45 f0 mov -0x10(%ebp),%eax
c103be1b: e8 fc ff ff ff call c103be1c <ftrace_raw_event_hrtimer_start+0x82>
c103be20: 59 pop %ecx
c103be21: 8d 65 f4 lea -0xc(%ebp),%esp
c103be24: 5b pop %ebx
c103be25: 5e pop %esi
c103be26: 5f pop %edi
c103be27: 5d pop %ebp
c103be28: c3 ret
c103be29 <ftrace_raw_event_hrtimer_expire_entry>:
* @now: pointer to variable which contains current time of the
* timers base.
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(hrtimer_expire_entry,
c103be29: 55 push %ebp
c103be2a: 89 e5 mov %esp,%ebp
c103be2c: 57 push %edi
c103be2d: 89 c7 mov %eax,%edi
c103be2f: 56 push %esi
c103be30: 53 push %ebx
c103be31: 89 d3 mov %edx,%ebx
c103be33: 83 ec 10 sub $0x10,%esp
c103be36: 89 4d e4 mov %ecx,-0x1c(%ebp)
c103be39: 9c pushf
c103be3a: 8f 45 e8 popl -0x18(%ebp)
c103be3d: 89 e0 mov %esp,%eax
c103be3f: 8b 57 24 mov 0x24(%edi),%edx
c103be42: b9 1c 00 00 00 mov $0x1c,%ecx
c103be47: 25 00 e0 ff ff and $0xffffe000,%eax
c103be4c: 8b 40 14 mov 0x14(%eax),%eax
c103be4f: 89 45 ec mov %eax,-0x14(%ebp)
c103be52: 8d 45 f0 lea -0x10(%ebp),%eax
c103be55: ff 75 ec pushl -0x14(%ebp)
c103be58: ff 75 e8 pushl -0x18(%ebp)
c103be5b: e8 fc ff ff ff call c103be5c <ftrace_raw_event_hrtimer_expire_entry+0x33>
c103be60: 89 c6 mov %eax,%esi
c103be62: 85 f6 test %esi,%esi
c103be64: 58 pop %eax
c103be65: 5a pop %edx
c103be66: 74 41 je c103bea9 <ftrace_raw_event_hrtimer_expire_entry+0x80>
c103be68: 89 f0 mov %esi,%eax
c103be6a: e8 fc ff ff ff call c103be6b <ftrace_raw_event_hrtimer_expire_entry+0x42>
c103be6f: 89 58 0c mov %ebx,0xc(%eax)
c103be72: 8b 4d e4 mov -0x1c(%ebp),%ecx
c103be75: 8b 11 mov (%ecx),%edx
c103be77: 8b 49 04 mov 0x4(%ecx),%ecx
c103be7a: 89 50 10 mov %edx,0x10(%eax)
c103be7d: 89 48 14 mov %ecx,0x14(%eax)
c103be80: 8b 53 1c mov 0x1c(%ebx),%edx
c103be83: 89 c1 mov %eax,%ecx
c103be85: 89 50 18 mov %edx,0x18(%eax)
c103be88: 8b 45 f0 mov -0x10(%ebp),%eax
c103be8b: 89 fa mov %edi,%edx
c103be8d: 56 push %esi
c103be8e: e8 fc ff ff ff call c103be8f <ftrace_raw_event_hrtimer_expire_entry+0x66>
c103be93: 5b pop %ebx
c103be94: 85 c0 test %eax,%eax
c103be96: 75 11 jne c103bea9 <ftrace_raw_event_hrtimer_expire_entry+0x80>
c103be98: 8b 4d e8 mov -0x18(%ebp),%ecx
c103be9b: 89 f2 mov %esi,%edx
c103be9d: ff 75 ec pushl -0x14(%ebp)
c103bea0: 8b 45 f0 mov -0x10(%ebp),%eax
c103bea3: e8 fc ff ff ff call c103bea4 <ftrace_raw_event_hrtimer_expire_entry+0x7b>
c103bea8: 59 pop %ecx
c103bea9: 8d 65 f4 lea -0xc(%ebp),%esp
c103beac: 5b pop %ebx
c103bead: 5e pop %esi
c103beae: 5f pop %edi
c103beaf: 5d pop %ebp
c103beb0: c3 ret
c103beb1 <ftrace_raw_event_hrtimer_class>:
TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
(unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
);
DECLARE_EVENT_CLASS(hrtimer_class,
c103beb1: 55 push %ebp
c103beb2: 89 e5 mov %esp,%ebp
c103beb4: 57 push %edi
c103beb5: 56 push %esi
c103beb6: 89 c6 mov %eax,%esi
c103beb8: 53 push %ebx
c103beb9: 83 ec 0c sub $0xc,%esp
c103bebc: 89 55 e8 mov %edx,-0x18(%ebp)
c103bebf: 9c pushf
c103bec0: 8f 45 ec popl -0x14(%ebp)
c103bec3: 89 e0 mov %esp,%eax
c103bec5: 8b 56 24 mov 0x24(%esi),%edx
c103bec8: b9 10 00 00 00 mov $0x10,%ecx
c103becd: 25 00 e0 ff ff and $0xffffe000,%eax
c103bed2: 8b 78 14 mov 0x14(%eax),%edi
c103bed5: 8d 45 f0 lea -0x10(%ebp),%eax
c103bed8: 57 push %edi
c103bed9: ff 75 ec pushl -0x14(%ebp)
c103bedc: e8 fc ff ff ff call c103bedd <ftrace_raw_event_hrtimer_class+0x2c>
c103bee1: 89 c3 mov %eax,%ebx
c103bee3: 85 db test %ebx,%ebx
c103bee5: 58 pop %eax
c103bee6: 5a pop %edx
c103bee7: 74 2e je c103bf17 <ftrace_raw_event_hrtimer_class+0x66>
c103bee9: 89 d8 mov %ebx,%eax
c103beeb: e8 fc ff ff ff call c103beec <ftrace_raw_event_hrtimer_class+0x3b>
c103bef0: 8b 55 e8 mov -0x18(%ebp),%edx
c103bef3: 89 c1 mov %eax,%ecx
c103bef5: 89 50 0c mov %edx,0xc(%eax)
c103bef8: 8b 45 f0 mov -0x10(%ebp),%eax
c103befb: 89 f2 mov %esi,%edx
c103befd: 53 push %ebx
c103befe: e8 fc ff ff ff call c103beff <ftrace_raw_event_hrtimer_class+0x4e>
c103bf03: 5e pop %esi
c103bf04: 85 c0 test %eax,%eax
c103bf06: 75 0f jne c103bf17 <ftrace_raw_event_hrtimer_class+0x66>
c103bf08: 8b 4d ec mov -0x14(%ebp),%ecx
c103bf0b: 89 da mov %ebx,%edx
c103bf0d: 8b 45 f0 mov -0x10(%ebp),%eax
c103bf10: 57 push %edi
c103bf11: e8 fc ff ff ff call c103bf12 <ftrace_raw_event_hrtimer_class+0x61>
c103bf16: 59 pop %ecx
c103bf17: 8d 65 f4 lea -0xc(%ebp),%esp
c103bf1a: 5b pop %ebx
c103bf1b: 5e pop %esi
c103bf1c: 5f pop %edi
c103bf1d: 5d pop %ebp
c103bf1e: c3 ret
c103bf1f <ftrace_raw_event_itimer_state>:
* @which: name of the interval timer
* @value: the itimers value, itimer is canceled if value->it_value is
* zero, otherwise it is started
* @expires: the itimers expiry time
*/
TRACE_EVENT(itimer_state,
c103bf1f: 55 push %ebp
c103bf20: 89 e5 mov %esp,%ebp
c103bf22: 57 push %edi
c103bf23: 89 c7 mov %eax,%edi
c103bf25: 56 push %esi
c103bf26: 53 push %ebx
c103bf27: 89 cb mov %ecx,%ebx
c103bf29: 83 ec 10 sub $0x10,%esp
c103bf2c: 89 55 e4 mov %edx,-0x1c(%ebp)
c103bf2f: 9c pushf
c103bf30: 8f 45 e8 popl -0x18(%ebp)
c103bf33: 89 e0 mov %esp,%eax
c103bf35: 8b 57 24 mov 0x24(%edi),%edx
c103bf38: b9 24 00 00 00 mov $0x24,%ecx
c103bf3d: 25 00 e0 ff ff and $0xffffe000,%eax
c103bf42: 8b 40 14 mov 0x14(%eax),%eax
c103bf45: 89 45 ec mov %eax,-0x14(%ebp)
c103bf48: 8d 45 f0 lea -0x10(%ebp),%eax
c103bf4b: ff 75 ec pushl -0x14(%ebp)
c103bf4e: ff 75 e8 pushl -0x18(%ebp)
c103bf51: e8 fc ff ff ff call c103bf52 <ftrace_raw_event_itimer_state+0x33>
c103bf56: 89 c6 mov %eax,%esi
c103bf58: 85 f6 test %esi,%esi
c103bf5a: 58 pop %eax
c103bf5b: 5a pop %edx
c103bf5c: 74 4d je c103bfab <ftrace_raw_event_itimer_state+0x8c>
c103bf5e: 89 f0 mov %esi,%eax
c103bf60: e8 fc ff ff ff call c103bf61 <ftrace_raw_event_itimer_state+0x42>
c103bf65: 8b 55 e4 mov -0x1c(%ebp),%edx
c103bf68: 89 50 0c mov %edx,0xc(%eax)
c103bf6b: 8b 55 08 mov 0x8(%ebp),%edx
c103bf6e: 89 c1 mov %eax,%ecx
c103bf70: 89 50 10 mov %edx,0x10(%eax)
c103bf73: 8b 53 08 mov 0x8(%ebx),%edx
c103bf76: 89 50 14 mov %edx,0x14(%eax)
c103bf79: 8b 53 0c mov 0xc(%ebx),%edx
c103bf7c: 89 50 18 mov %edx,0x18(%eax)
c103bf7f: 8b 13 mov (%ebx),%edx
c103bf81: 89 50 1c mov %edx,0x1c(%eax)
c103bf84: 8b 53 04 mov 0x4(%ebx),%edx
c103bf87: 89 50 20 mov %edx,0x20(%eax)
c103bf8a: 8b 45 f0 mov -0x10(%ebp),%eax
c103bf8d: 89 fa mov %edi,%edx
c103bf8f: 56 push %esi
c103bf90: e8 fc ff ff ff call c103bf91 <ftrace_raw_event_itimer_state+0x72>
c103bf95: 5b pop %ebx
c103bf96: 85 c0 test %eax,%eax
c103bf98: 75 11 jne c103bfab <ftrace_raw_event_itimer_state+0x8c>
c103bf9a: 8b 4d e8 mov -0x18(%ebp),%ecx
c103bf9d: 89 f2 mov %esi,%edx
c103bf9f: ff 75 ec pushl -0x14(%ebp)
c103bfa2: 8b 45 f0 mov -0x10(%ebp),%eax
c103bfa5: e8 fc ff ff ff call c103bfa6 <ftrace_raw_event_itimer_state+0x87>
c103bfaa: 59 pop %ecx
c103bfab: 8d 65 f4 lea -0xc(%ebp),%esp
c103bfae: 5b pop %ebx
c103bfaf: 5e pop %esi
c103bfb0: 5f pop %edi
c103bfb1: 5d pop %ebp
c103bfb2: c3 ret
c103bfb3 <ftrace_raw_event_itimer_expire>:
* itimer_expire - called when itimer expires
* @which: type of the interval timer
* @pid: pid of the process which owns the timer
* @now: current time, used to calculate the latency of itimer
*/
TRACE_EVENT(itimer_expire,
c103bfb3: 55 push %ebp
c103bfb4: 89 e5 mov %esp,%ebp
c103bfb6: 57 push %edi
c103bfb7: 89 cf mov %ecx,%edi
c103bfb9: 56 push %esi
c103bfba: 89 c6 mov %eax,%esi
c103bfbc: 53 push %ebx
c103bfbd: 83 ec 10 sub $0x10,%esp
c103bfc0: 89 55 e4 mov %edx,-0x1c(%ebp)
c103bfc3: 9c pushf
c103bfc4: 8f 45 e8 popl -0x18(%ebp)
c103bfc7: 89 e0 mov %esp,%eax
c103bfc9: b9 18 00 00 00 mov $0x18,%ecx
c103bfce: 25 00 e0 ff ff and $0xffffe000,%eax
c103bfd3: 8b 40 14 mov 0x14(%eax),%eax
c103bfd6: 89 45 ec mov %eax,-0x14(%ebp)
c103bfd9: 8b 56 24 mov 0x24(%esi),%edx
c103bfdc: 8d 45 f0 lea -0x10(%ebp),%eax
c103bfdf: ff 75 ec pushl -0x14(%ebp)
c103bfe2: ff 75 e8 pushl -0x18(%ebp)
c103bfe5: e8 fc ff ff ff call c103bfe6 <ftrace_raw_event_itimer_expire+0x33>
c103bfea: 89 c3 mov %eax,%ebx
c103bfec: 85 db test %ebx,%ebx
c103bfee: 58 pop %eax
c103bfef: 5a pop %edx
c103bff0: 74 42 je c103c034 <ftrace_raw_event_itimer_expire+0x81>
c103bff2: 89 d8 mov %ebx,%eax
c103bff4: e8 fc ff ff ff call c103bff5 <ftrace_raw_event_itimer_expire+0x42>
c103bff9: 8b 55 e4 mov -0x1c(%ebp),%edx
c103bffc: 89 50 0c mov %edx,0xc(%eax)
c103bfff: 8b 55 08 mov 0x8(%ebp),%edx
c103c002: 89 50 14 mov %edx,0x14(%eax)
*/
static inline pid_t pid_nr(struct pid *pid)
{
pid_t nr = 0;
if (pid)
c103c005: 31 d2 xor %edx,%edx
c103c007: 85 ff test %edi,%edi
c103c009: 74 03 je c103c00e <ftrace_raw_event_itimer_expire+0x5b>
nr = pid->numbers[0].nr;
c103c00b: 8b 57 1c mov 0x1c(%edi),%edx
c103c00e: 89 50 10 mov %edx,0x10(%eax)
c103c011: 89 c1 mov %eax,%ecx
c103c013: 8b 45 f0 mov -0x10(%ebp),%eax
c103c016: 89 f2 mov %esi,%edx
c103c018: 53 push %ebx
c103c019: e8 fc ff ff ff call c103c01a <ftrace_raw_event_itimer_expire+0x67>
c103c01e: 5e pop %esi
c103c01f: 85 c0 test %eax,%eax
c103c021: 75 11 jne c103c034 <ftrace_raw_event_itimer_expire+0x81>
c103c023: 8b 4d e8 mov -0x18(%ebp),%ecx
c103c026: 89 da mov %ebx,%edx
c103c028: ff 75 ec pushl -0x14(%ebp)
c103c02b: 8b 45 f0 mov -0x10(%ebp),%eax
c103c02e: e8 fc ff ff ff call c103c02f <ftrace_raw_event_itimer_expire+0x7c>
c103c033: 59 pop %ecx
c103c034: 8d 65 f4 lea -0xc(%ebp),%esp
c103c037: 5b pop %ebx
c103c038: 5e pop %esi
c103c039: 5f pop %edi
c103c03a: 5d pop %ebp
c103c03b: c3 ret
c103c03c <usleep_range>:
* usleep_range - Drop in replacement for udelay where wakeup is flexible
* @min: Minimum time in usecs to sleep
* @max: Maximum time in usecs to sleep
*/
void usleep_range(unsigned long min, unsigned long max)
{
c103c03c: 55 push %ebp
ktime_t kmin;
unsigned long delta;
kmin = ktime_set(0, min * NSEC_PER_USEC);
delta = (max - min) * NSEC_PER_USEC;
return schedule_hrtimeout_range(&kmin, delta, HRTIMER_MODE_REL);
c103c03d: 29 c2 sub %eax,%edx
* usleep_range - Drop in replacement for udelay where wakeup is flexible
* @min: Minimum time in usecs to sleep
* @max: Maximum time in usecs to sleep
*/
void usleep_range(unsigned long min, unsigned long max)
{
c103c03f: 89 e5 mov %esp,%ebp
ktime_t kmin;
unsigned long delta;
kmin = ktime_set(0, min * NSEC_PER_USEC);
delta = (max - min) * NSEC_PER_USEC;
return schedule_hrtimeout_range(&kmin, delta, HRTIMER_MODE_REL);
c103c041: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
* usleep_range - Drop in replacement for udelay where wakeup is flexible
* @min: Minimum time in usecs to sleep
* @max: Maximum time in usecs to sleep
*/
void usleep_range(unsigned long min, unsigned long max)
{
c103c047: 53 push %ebx
{
#if (BITS_PER_LONG == 64)
if (unlikely(secs >= KTIME_SEC_MAX))
return (ktime_t){ .tv64 = KTIME_MAX };
#endif
return (ktime_t) { .tv64 = (s64)secs * NSEC_PER_SEC + (s64)nsecs };
c103c048: 69 d8 e8 03 00 00 imul $0x3e8,%eax,%ebx
c103c04e: 83 ec 08 sub $0x8,%esp
c103c051: 64 8b 0d 00 00 00 00 mov %fs:0x0,%ecx
__set_current_state(TASK_UNINTERRUPTIBLE);
c103c058: c7 01 02 00 00 00 movl $0x2,(%ecx)
c103c05e: 31 c9 xor %ecx,%ecx
static int __sched do_usleep_range(unsigned long min, unsigned long max)
{
ktime_t kmin;
unsigned long delta;
kmin = ktime_set(0, min * NSEC_PER_USEC);
c103c060: 89 4d f8 mov %ecx,-0x8(%ebp)
delta = (max - min) * NSEC_PER_USEC;
return schedule_hrtimeout_range(&kmin, delta, HRTIMER_MODE_REL);
c103c063: 8d 45 f4 lea -0xc(%ebp),%eax
c103c066: b1 01 mov $0x1,%cl
static int __sched do_usleep_range(unsigned long min, unsigned long max)
{
ktime_t kmin;
unsigned long delta;
kmin = ktime_set(0, min * NSEC_PER_USEC);
c103c068: 89 5d f4 mov %ebx,-0xc(%ebp)
delta = (max - min) * NSEC_PER_USEC;
return schedule_hrtimeout_range(&kmin, delta, HRTIMER_MODE_REL);
c103c06b: e8 fc ff ff ff call c103c06c <usleep_range+0x30>
*/
void usleep_range(unsigned long min, unsigned long max)
{
__set_current_state(TASK_UNINTERRUPTIBLE);
do_usleep_range(min, max);
}
c103c070: 59 pop %ecx
c103c071: 5b pop %ebx
c103c072: 5b pop %ebx
c103c073: 5d pop %ebp
c103c074: c3 ret
c103c075 <rcu_read_unlock_sched_notrace>:
preempt_enable();
}
/* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
static inline notrace void rcu_read_unlock_sched_notrace(void)
{
c103c075: 55 push %ebp
c103c076: 89 e5 mov %esp,%ebp
register unsigned long current_stack_pointer asm("esp") __used;
/* how to get the thread information struct from C */
static inline struct thread_info *current_thread_info(void)
{
return (struct thread_info *)
c103c078: 89 e0 mov %esp,%eax
c103c07a: 25 00 e0 ff ff and $0xffffe000,%eax
__release(RCU_SCHED);
preempt_enable_notrace();
c103c07f: ff 48 14 decl 0x14(%eax)
c103c082: 8b 40 08 mov 0x8(%eax),%eax
c103c085: a8 08 test $0x8,%al
c103c087: 74 05 je c103c08e <rcu_read_unlock_sched_notrace+0x19>
c103c089: e8 fc ff ff ff call c103c08a <rcu_read_unlock_sched_notrace+0x15>
}
c103c08e: 5d pop %ebp
c103c08f: c3 ret
c103c090 <detach_timer>:
}
EXPORT_SYMBOL(init_timer_deferrable_key);
static inline void detach_timer(struct timer_list *timer,
int clear_pending)
{
c103c090: 55 push %ebp
/**
* timer_cancel - called when the timer is canceled
* @timer: pointer to struct timer_list
*/
DEFINE_EVENT(timer_class, timer_cancel,
c103c091: 83 3d 04 00 00 00 00 cmpl $0x0,0x4
c103c098: 89 e5 mov %esp,%ebp
c103c09a: 57 push %edi
c103c09b: 89 d7 mov %edx,%edi
c103c09d: 56 push %esi
c103c09e: 89 c6 mov %eax,%esi
c103c0a0: 53 push %ebx
c103c0a1: 74 28 je c103c0cb <detach_timer+0x3b>
c103c0a3: 89 e0 mov %esp,%eax
c103c0a5: 25 00 e0 ff ff and $0xffffe000,%eax
}
/* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
static inline notrace void rcu_read_lock_sched_notrace(void)
{
preempt_disable_notrace();
c103c0aa: ff 40 14 incl 0x14(%eax)
c103c0ad: 8b 1d 10 00 00 00 mov 0x10,%ebx
c103c0b3: 85 db test %ebx,%ebx
c103c0b5: 74 0f je c103c0c6 <detach_timer+0x36>
c103c0b7: 8b 43 04 mov 0x4(%ebx),%eax
c103c0ba: 89 f2 mov %esi,%edx
c103c0bc: ff 13 call *(%ebx)
c103c0be: 83 c3 08 add $0x8,%ebx
c103c0c1: 83 3b 00 cmpl $0x0,(%ebx)
c103c0c4: eb ef jmp c103c0b5 <detach_timer+0x25>
c103c0c6: e8 aa ff ff ff call c103c075 <rcu_read_unlock_sched_notrace>
struct list_head *entry = &timer->entry;
debug_deactivate(timer);
__list_del(entry->prev, entry->next);
c103c0cb: 8b 16 mov (%esi),%edx
if (clear_pending)
c103c0cd: 85 ff test %edi,%edi
{
struct list_head *entry = &timer->entry;
debug_deactivate(timer);
__list_del(entry->prev, entry->next);
c103c0cf: 8b 46 04 mov 0x4(%esi),%eax
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
c103c0d2: 89 42 04 mov %eax,0x4(%edx)
prev->next = next;
c103c0d5: 89 10 mov %edx,(%eax)
if (clear_pending)
c103c0d7: 74 06 je c103c0df <detach_timer+0x4f>
entry->next = NULL;
c103c0d9: c7 06 00 00 00 00 movl $0x0,(%esi)
entry->prev = LIST_POISON2;
c103c0df: c7 46 04 00 02 20 00 movl $0x200200,0x4(%esi)
}
c103c0e6: 5b pop %ebx
c103c0e7: 5e pop %esi
c103c0e8: 5f pop %edi
c103c0e9: 5d pop %ebp
c103c0ea: c3 ret
c103c0eb <migrate_timer_list>:
return 0;
}
#ifdef CONFIG_HOTPLUG_CPU
static void migrate_timer_list(struct tvec_base *new_base, struct list_head *head)
{
c103c0eb: 55 push %ebp
c103c0ec: 89 e5 mov %esp,%ebp
c103c0ee: 57 push %edi
c103c0ef: 89 d7 mov %edx,%edi
c103c0f1: 56 push %esi
c103c0f2: 89 c6 mov %eax,%esi
c103c0f4: 53 push %ebx
struct timer_list *timer;
while (!list_empty(head)) {
c103c0f5: eb 2c jmp c103c123 <migrate_timer_list+0x38>
timer = list_first_entry(head, struct timer_list, entry);
detach_timer(timer, 0);
c103c0f7: 31 d2 xor %edx,%edx
c103c0f9: 89 d8 mov %ebx,%eax
c103c0fb: e8 90 ff ff ff call c103c090 <detach_timer>
}
static inline void
timer_set_base(struct timer_list *timer, struct tvec_base *new_base)
{
timer->base = (struct tvec_base *)((unsigned long)(new_base) |
c103c100: 8b 43 0c mov 0xc(%ebx),%eax
while (!list_empty(head)) {
timer = list_first_entry(head, struct timer_list, entry);
detach_timer(timer, 0);
timer_set_base(timer, new_base);
if (time_before(timer->expires, new_base->next_timer) &&
c103c103: 8b 53 08 mov 0x8(%ebx),%edx
}
static inline void
timer_set_base(struct timer_list *timer, struct tvec_base *new_base)
{
timer->base = (struct tvec_base *)((unsigned long)(new_base) |
c103c106: 83 e0 01 and $0x1,%eax
c103c109: 09 f0 or %esi,%eax
c103c10b: 89 43 0c mov %eax,0xc(%ebx)
while (!list_empty(head)) {
timer = list_first_entry(head, struct timer_list, entry);
detach_timer(timer, 0);
timer_set_base(timer, new_base);
if (time_before(timer->expires, new_base->next_timer) &&
c103c10e: 3b 56 0c cmp 0xc(%esi),%edx
c103c111: 79 07 jns c103c11a <migrate_timer_list+0x2f>
c103c113: a8 01 test $0x1,%al
c103c115: 75 03 jne c103c11a <migrate_timer_list+0x2f>
!tbase_get_deferrable(timer->base))
new_base->next_timer = timer->expires;
c103c117: 89 56 0c mov %edx,0xc(%esi)
internal_add_timer(new_base, timer);
c103c11a: 89 da mov %ebx,%edx
c103c11c: 89 f0 mov %esi,%eax
c103c11e: e8 03 eb ff ff call c103ac26 <internal_add_timer>
* list_empty - tests whether a list is empty
* @head: the list to test.
*/
static inline int list_empty(const struct list_head *head)
{
return head->next == head;
c103c123: 8b 1f mov (%edi),%ebx
#ifdef CONFIG_HOTPLUG_CPU
static void migrate_timer_list(struct tvec_base *new_base, struct list_head *head)
{
struct timer_list *timer;
while (!list_empty(head)) {
c103c125: 39 fb cmp %edi,%ebx
c103c127: 75 ce jne c103c0f7 <migrate_timer_list+0xc>
if (time_before(timer->expires, new_base->next_timer) &&
!tbase_get_deferrable(timer->base))
new_base->next_timer = timer->expires;
internal_add_timer(new_base, timer);
}
}
c103c129: 5b pop %ebx
c103c12a: 5e pop %esi
c103c12b: 5f pop %edi
c103c12c: 5d pop %ebp
c103c12d: c3 ret
c103c12e <debug_activate>:
trace_timer_init(timer);
}
static inline void
debug_activate(struct timer_list *timer, unsigned long expires)
{
c103c12e: 55 push %ebp
/**
* timer_start - called when the timer is started
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
TRACE_EVENT(timer_start,
c103c12f: 83 3d 04 00 00 00 00 cmpl $0x0,0x4
c103c136: 89 e5 mov %esp,%ebp
c103c138: 57 push %edi
c103c139: 89 c7 mov %eax,%edi
c103c13b: 56 push %esi
c103c13c: 89 d6 mov %edx,%esi
c103c13e: 53 push %ebx
c103c13f: 74 2a je c103c16b <debug_activate+0x3d>
c103c141: 89 e0 mov %esp,%eax
c103c143: 25 00 e0 ff ff and $0xffffe000,%eax
c103c148: ff 40 14 incl 0x14(%eax)
c103c14b: 8b 1d 10 00 00 00 mov 0x10,%ebx
c103c151: 85 db test %ebx,%ebx
c103c153: 74 11 je c103c166 <debug_activate+0x38>
c103c155: 8b 43 04 mov 0x4(%ebx),%eax
c103c158: 89 f1 mov %esi,%ecx
c103c15a: 89 fa mov %edi,%edx
c103c15c: ff 13 call *(%ebx)
c103c15e: 83 c3 08 add $0x8,%ebx
c103c161: 83 3b 00 cmpl $0x0,(%ebx)
c103c164: eb ed jmp c103c153 <debug_activate+0x25>
c103c166: e8 0a ff ff ff call c103c075 <rcu_read_unlock_sched_notrace>
debug_timer_activate(timer);
trace_timer_start(timer, expires);
}
c103c16b: 5b pop %ebx
c103c16c: 5e pop %esi
c103c16d: 5f pop %edi
c103c16e: 5d pop %ebp
c103c16f: c3 ret
c103c170 <init_timer_key>:
* other timer functions.
*/
void init_timer_key(struct timer_list *timer,
const char *name,
struct lock_class_key *key)
{
c103c170: 55 push %ebp
/**
* timer_init - called when the timer is initialized
* @timer: pointer to struct timer_list
*/
DEFINE_EVENT(timer_class, timer_init,
c103c171: 83 3d 04 00 00 00 00 cmpl $0x0,0x4
c103c178: 89 e5 mov %esp,%ebp
c103c17a: 57 push %edi
c103c17b: 56 push %esi
c103c17c: 53 push %ebx
c103c17d: 89 c3 mov %eax,%ebx
c103c17f: 74 28 je c103c1a9 <init_timer_key+0x39>
c103c181: 89 e0 mov %esp,%eax
c103c183: 25 00 e0 ff ff and $0xffffe000,%eax
c103c188: ff 40 14 incl 0x14(%eax)
c103c18b: 8b 35 10 00 00 00 mov 0x10,%esi
c103c191: 85 f6 test %esi,%esi
c103c193: 74 0f je c103c1a4 <init_timer_key+0x34>
c103c195: 8b 46 04 mov 0x4(%esi),%eax
c103c198: 89 da mov %ebx,%edx
c103c19a: ff 16 call *(%esi)
c103c19c: 83 c6 08 add $0x8,%esi
c103c19f: 83 3e 00 cmpl $0x0,(%esi)
c103c1a2: eb ef jmp c103c193 <init_timer_key+0x23>
c103c1a4: e8 cc fe ff ff call c103c075 <rcu_read_unlock_sched_notrace>
static void __init_timer(struct timer_list *timer,
const char *name,
struct lock_class_key *key)
{
timer->entry.next = NULL;
c103c1a9: c7 03 00 00 00 00 movl $0x0,(%ebx)
timer->base = __raw_get_cpu_var(tvec_bases);
c103c1af: b8 00 00 00 00 mov $0x0,%eax
c103c1b4: 64 03 05 00 00 00 00 add %fs:0x0,%eax
c103c1bb: 8b 00 mov (%eax),%eax
timer->slack = -1;
#ifdef CONFIG_TIMER_STATS
timer->start_site = NULL;
timer->start_pid = -1;
memset(timer->start_comm, 0, TASK_COMM_LEN);
c103c1bd: 8d 53 24 lea 0x24(%ebx),%edx
c103c1c0: b9 04 00 00 00 mov $0x4,%ecx
c103c1c5: 89 d7 mov %edx,%edi
const char *name,
struct lock_class_key *key)
{
timer->entry.next = NULL;
timer->base = __raw_get_cpu_var(tvec_bases);
timer->slack = -1;
c103c1c7: c7 43 18 ff ff ff ff movl $0xffffffff,0x18(%ebx)
#ifdef CONFIG_TIMER_STATS
timer->start_site = NULL;
c103c1ce: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
static void __init_timer(struct timer_list *timer,
const char *name,
struct lock_class_key *key)
{
timer->entry.next = NULL;
timer->base = __raw_get_cpu_var(tvec_bases);
c103c1d5: 89 43 0c mov %eax,0xc(%ebx)
timer->slack = -1;
#ifdef CONFIG_TIMER_STATS
timer->start_site = NULL;
timer->start_pid = -1;
memset(timer->start_comm, 0, TASK_COMM_LEN);
c103c1d8: 31 c0 xor %eax,%eax
timer->entry.next = NULL;
timer->base = __raw_get_cpu_var(tvec_bases);
timer->slack = -1;
#ifdef CONFIG_TIMER_STATS
timer->start_site = NULL;
timer->start_pid = -1;
c103c1da: c7 43 1c ff ff ff ff movl $0xffffffff,0x1c(%ebx)
memset(timer->start_comm, 0, TASK_COMM_LEN);
c103c1e1: f3 ab rep stos %eax,%es:(%edi)
const char *name,
struct lock_class_key *key)
{
debug_init(timer);
__init_timer(timer, name, key);
}
c103c1e3: 5b pop %ebx
c103c1e4: 5e pop %esi
c103c1e5: 5f pop %edi
c103c1e6: 5d pop %ebp
c103c1e7: c3 ret
c103c1e8 <setup_deferrable_timer_on_stack_key>:
void setup_deferrable_timer_on_stack_key(struct timer_list *timer,
const char *name,
struct lock_class_key *key,
void (*function)(unsigned long),
unsigned long data)
{
c103c1e8: 55 push %ebp
c103c1e9: 89 e5 mov %esp,%ebp
c103c1eb: 53 push %ebx
c103c1ec: 89 c3 mov %eax,%ebx
timer->function = function;
c103c1ee: 8b 45 08 mov 0x8(%ebp),%eax
c103c1f1: 89 43 10 mov %eax,0x10(%ebx)
timer->data = data;
c103c1f4: 8b 45 0c mov 0xc(%ebp),%eax
c103c1f7: 89 43 14 mov %eax,0x14(%ebx)
static inline void destroy_timer_on_stack(struct timer_list *timer) { }
static inline void init_timer_on_stack_key(struct timer_list *timer,
const char *name,
struct lock_class_key *key)
{
init_timer_key(timer, name, key);
c103c1fa: 89 d8 mov %ebx,%eax
c103c1fc: e8 fc ff ff ff call c103c1fd <setup_deferrable_timer_on_stack_key+0x15>
return ((struct tvec_base *)((unsigned long)base & ~TBASE_DEFERRABLE_FLAG));
}
static inline void timer_set_deferrable(struct timer_list *timer)
{
timer->base = TBASE_MAKE_DEFERRED(timer->base);
c103c201: ff 43 0c incl 0xc(%ebx)
{
timer->function = function;
timer->data = data;
init_timer_on_stack_key(timer, name, key);
timer_set_deferrable(timer);
}
c103c204: 5b pop %ebx
c103c205: 5d pop %ebp
c103c206: c3 ret
c103c207 <init_timer_deferrable_key>:
EXPORT_SYMBOL(init_timer_key);
void init_timer_deferrable_key(struct timer_list *timer,
const char *name,
struct lock_class_key *key)
{
c103c207: 55 push %ebp
c103c208: 89 e5 mov %esp,%ebp
c103c20a: 53 push %ebx
c103c20b: 89 c3 mov %eax,%ebx
init_timer_key(timer, name, key);
c103c20d: e8 fc ff ff ff call c103c20e <init_timer_deferrable_key+0x7>
return ((struct tvec_base *)((unsigned long)base & ~TBASE_DEFERRABLE_FLAG));
}
static inline void timer_set_deferrable(struct timer_list *timer)
{
timer->base = TBASE_MAKE_DEFERRED(timer->base);
c103c212: ff 43 0c incl 0xc(%ebx)
const char *name,
struct lock_class_key *key)
{
init_timer_key(timer, name, key);
timer_set_deferrable(timer);
}
c103c215: 5b pop %ebx
c103c216: 5d pop %ebp
c103c217: c3 ret
c103c218 <run_timer_softirq>:
/*
* This function runs timers and the timer-tq in bottom half context.
*/
static void run_timer_softirq(struct softirq_action *h)
{
c103c218: 55 push %ebp
c103c219: 89 e5 mov %esp,%ebp
c103c21b: 57 push %edi
c103c21c: 56 push %esi
c103c21d: 53 push %ebx
c103c21e: 83 ec 28 sub $0x28,%esp
struct tvec_base *base = __this_cpu_read(tvec_bases);
c103c221: 64 8b 1d 00 00 00 00 mov %fs:0x0,%ebx
hrtimer_run_pending();
c103c228: e8 fc ff ff ff call c103c229 <run_timer_softirq+0x11>
if (time_after_eq(jiffies, base->timer_jiffies))
c103c22d: a1 00 00 00 00 mov 0x0,%eax
c103c232: 3b 43 08 cmp 0x8(%ebx),%eax
c103c235: 0f 88 f0 01 00 00 js c103c42b <run_timer_softirq+0x213>
raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
} while (0)
static inline void spin_lock_irq(spinlock_t *lock)
{
raw_spin_lock_irq(&lock->rlock);
c103c23b: 89 d8 mov %ebx,%eax
c103c23d: e8 fc ff ff ff call c103c23e <run_timer_softirq+0x26>
/*
* Cascade timers:
*/
if (!index &&
(!cascade(base, &base->tv2, INDEX(0))) &&
c103c242: 8d 83 10 08 00 00 lea 0x810(%ebx),%eax
(!cascade(base, &base->tv3, INDEX(1))) &&
c103c248: 8d 93 10 0a 00 00 lea 0xa10(%ebx),%edx
/*
* Cascade timers:
*/
if (!index &&
(!cascade(base, &base->tv2, INDEX(0))) &&
c103c24e: 89 45 e0 mov %eax,-0x20(%ebp)
(!cascade(base, &base->tv3, INDEX(1))) &&
!cascade(base, &base->tv4, INDEX(2)))
c103c251: 8d 8b 10 0c 00 00 lea 0xc10(%ebx),%ecx
/*
* Cascade timers:
*/
if (!index &&
(!cascade(base, &base->tv2, INDEX(0))) &&
(!cascade(base, &base->tv3, INDEX(1))) &&
c103c257: 89 55 dc mov %edx,-0x24(%ebp)
!cascade(base, &base->tv4, INDEX(2)))
cascade(base, &base->tv5, INDEX(3));
c103c25a: 8d 83 10 0e 00 00 lea 0xe10(%ebx),%eax
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
new->next->prev = new;
c103c260: 8d 55 ec lea -0x14(%ebp),%edx
* Cascade timers:
*/
if (!index &&
(!cascade(base, &base->tv2, INDEX(0))) &&
(!cascade(base, &base->tv3, INDEX(1))) &&
!cascade(base, &base->tv4, INDEX(2)))
c103c263: 89 4d d8 mov %ecx,-0x28(%ebp)
cascade(base, &base->tv5, INDEX(3));
c103c266: 89 45 d4 mov %eax,-0x2c(%ebp)
c103c269: 89 55 cc mov %edx,-0x34(%ebp)
c103c26c: e9 9c 01 00 00 jmp c103c40d <run_timer_softirq+0x1f5>
int index = base->timer_jiffies & TVR_MASK;
/*
* Cascade timers:
*/
if (!index &&
c103c271: 89 ce mov %ecx,%esi
c103c273: 81 e6 ff 00 00 00 and $0xff,%esi
c103c279: 75 52 jne c103c2cd <run_timer_softirq+0xb5>
(!cascade(base, &base->tv2, INDEX(0))) &&
c103c27b: 8b 55 e0 mov -0x20(%ebp),%edx
c103c27e: c1 e9 08 shr $0x8,%ecx
c103c281: 89 d8 mov %ebx,%eax
c103c283: 83 e1 3f and $0x3f,%ecx
c103c286: e8 7e ea ff ff call c103ad09 <cascade>
int index = base->timer_jiffies & TVR_MASK;
/*
* Cascade timers:
*/
if (!index &&
c103c28b: 85 c0 test %eax,%eax
c103c28d: 75 3e jne c103c2cd <run_timer_softirq+0xb5>
(!cascade(base, &base->tv2, INDEX(0))) &&
(!cascade(base, &base->tv3, INDEX(1))) &&
c103c28f: 8b 4b 08 mov 0x8(%ebx),%ecx
c103c292: 89 d8 mov %ebx,%eax
c103c294: 8b 55 dc mov -0x24(%ebp),%edx
c103c297: c1 e9 0e shr $0xe,%ecx
c103c29a: 83 e1 3f and $0x3f,%ecx
c103c29d: e8 67 ea ff ff call c103ad09 <cascade>
int index = base->timer_jiffies & TVR_MASK;
/*
* Cascade timers:
*/
if (!index &&
c103c2a2: 85 c0 test %eax,%eax
c103c2a4: 75 27 jne c103c2cd <run_timer_softirq+0xb5>
(!cascade(base, &base->tv2, INDEX(0))) &&
(!cascade(base, &base->tv3, INDEX(1))) &&
!cascade(base, &base->tv4, INDEX(2)))
c103c2a6: 8b 4b 08 mov 0x8(%ebx),%ecx
c103c2a9: 89 d8 mov %ebx,%eax
c103c2ab: 8b 55 d8 mov -0x28(%ebp),%edx
c103c2ae: c1 e9 14 shr $0x14,%ecx
c103c2b1: 83 e1 3f and $0x3f,%ecx
c103c2b4: e8 50 ea ff ff call c103ad09 <cascade>
int index = base->timer_jiffies & TVR_MASK;
/*
* Cascade timers:
*/
if (!index &&
c103c2b9: 85 c0 test %eax,%eax
c103c2bb: 75 10 jne c103c2cd <run_timer_softirq+0xb5>
(!cascade(base, &base->tv2, INDEX(0))) &&
(!cascade(base, &base->tv3, INDEX(1))) &&
!cascade(base, &base->tv4, INDEX(2)))
cascade(base, &base->tv5, INDEX(3));
c103c2bd: 8b 4b 08 mov 0x8(%ebx),%ecx
c103c2c0: 89 d8 mov %ebx,%eax
c103c2c2: 8b 55 d4 mov -0x2c(%ebp),%edx
c103c2c5: c1 e9 1a shr $0x1a,%ecx
c103c2c8: e8 3c ea ff ff call c103ad09 <cascade>
++base->timer_jiffies;
c103c2cd: ff 43 08 incl 0x8(%ebx)
c103c2d0: 89 df mov %ebx,%edi
* If @old was empty, it will be overwritten.
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
c103c2d2: 8b 54 f3 10 mov 0x10(%ebx,%esi,8),%edx
new->next->prev = new;
c103c2d6: 8d 4d ec lea -0x14(%ebp),%ecx
list_replace_init(base->tv1.vec + index, &work_list);
c103c2d9: 8d 44 f3 10 lea 0x10(%ebx,%esi,8),%eax
* If @old was empty, it will be overwritten.
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
c103c2dd: 89 55 ec mov %edx,-0x14(%ebp)
new->next->prev = new;
c103c2e0: 89 4a 04 mov %ecx,0x4(%edx)
new->prev = old->prev;
c103c2e3: 8b 54 f3 14 mov 0x14(%ebx,%esi,8),%edx
c103c2e7: 89 55 f0 mov %edx,-0x10(%ebp)
new->prev->next = new;
c103c2ea: 89 0a mov %ecx,(%edx)
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103c2ec: 89 44 f3 10 mov %eax,0x10(%ebx,%esi,8)
list->prev = list;
c103c2f0: 89 44 f3 14 mov %eax,0x14(%ebx,%esi,8)
c103c2f4: e9 06 01 00 00 jmp c103c3ff <run_timer_softirq+0x1e7>
while (!list_empty(head)) {
void (*fn)(unsigned long);
unsigned long data;
timer = list_first_entry(head, struct timer_list,entry);
fn = timer->function;
c103c2f9: 8b 43 10 mov 0x10(%ebx),%eax
c103c2fc: 89 45 e4 mov %eax,-0x1c(%ebp)
data = timer->data;
c103c2ff: 8b 53 14 mov 0x14(%ebx),%edx
c103c302: 89 55 d0 mov %edx,-0x30(%ebp)
static void timer_stats_account_timer(struct timer_list *timer)
{
unsigned int flag = 0;
if (likely(!timer->start_site))
c103c305: 8b 4b 20 mov 0x20(%ebx),%ecx
c103c308: 85 c9 test %ecx,%ecx
c103c30a: 74 1b je c103c327 <run_timer_softirq+0x10f>
return;
if (unlikely(tbase_get_deferrable(timer->base)))
flag |= TIMER_STATS_FLAG_DEFERRABLE;
timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
c103c30c: 8b 43 0c mov 0xc(%ebx),%eax
c103c30f: 8b 53 1c mov 0x1c(%ebx),%edx
c103c312: 83 e0 01 and $0x1,%eax
c103c315: 50 push %eax
c103c316: 8d 43 24 lea 0x24(%ebx),%eax
c103c319: 50 push %eax
c103c31a: 89 d8 mov %ebx,%eax
c103c31c: ff 75 e4 pushl -0x1c(%ebp)
c103c31f: e8 fc ff ff ff call c103c320 <run_timer_softirq+0x108>
c103c324: 83 c4 0c add $0xc,%esp
data = timer->data;
timer_stats_account_timer(timer);
base->running_timer = timer;
detach_timer(timer, 1);
c103c327: ba 01 00 00 00 mov $0x1,%edx
c103c32c: 89 d8 mov %ebx,%eax
fn = timer->function;
data = timer->data;
timer_stats_account_timer(timer);
base->running_timer = timer;
c103c32e: 89 5f 04 mov %ebx,0x4(%edi)
detach_timer(timer, 1);
c103c331: e8 5a fd ff ff call c103c090 <detach_timer>
raw_spin_unlock_bh(&lock->rlock);
}
static inline void spin_unlock_irq(spinlock_t *lock)
{
raw_spin_unlock_irq(&lock->rlock);
c103c336: 89 f8 mov %edi,%eax
c103c338: e8 fc ff ff ff call c103c339 <run_timer_softirq+0x121>
c103c33d: 89 e0 mov %esp,%eax
c103c33f: 25 00 e0 ff ff and $0xffffe000,%eax
}
static void call_timer_fn(struct timer_list *timer, void (*fn)(unsigned long),
unsigned long data)
{
int preempt_count = preempt_count();
c103c344: 8b 48 14 mov 0x14(%eax),%ecx
* timer_expire_entry - called immediately before the timer callback
* @timer: pointer to struct timer_list
*
* Allows to determine the timer latency.
*/
TRACE_EVENT(timer_expire_entry,
c103c347: 83 3d 04 00 00 00 00 cmpl $0x0,0x4
c103c34e: 89 4d e8 mov %ecx,-0x18(%ebp)
c103c351: 74 24 je c103c377 <run_timer_softirq+0x15f>
c103c353: 89 ca mov %ecx,%edx
c103c355: 42 inc %edx
c103c356: 89 50 14 mov %edx,0x14(%eax)
c103c359: 8b 35 10 00 00 00 mov 0x10,%esi
c103c35f: 85 f6 test %esi,%esi
c103c361: 74 0f je c103c372 <run_timer_softirq+0x15a>
c103c363: 8b 46 04 mov 0x4(%esi),%eax
c103c366: 89 da mov %ebx,%edx
c103c368: ff 16 call *(%esi)
c103c36a: 83 c6 08 add $0x8,%esi
c103c36d: 83 3e 00 cmpl $0x0,(%esi)
c103c370: eb ef jmp c103c361 <run_timer_softirq+0x149>
c103c372: e8 fe fc ff ff call c103c075 <rcu_read_unlock_sched_notrace>
* call here and in del_timer_sync().
*/
lock_map_acquire(&lockdep_map);
trace_timer_expire_entry(timer);
fn(data);
c103c377: 8b 45 d0 mov -0x30(%ebp),%eax
c103c37a: ff 55 e4 call *-0x1c(%ebp)
* determine the runtime of the timer callback function.
*
* NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
* be invalid. We solely track the pointer.
*/
DEFINE_EVENT(timer_class, timer_expire_exit,
c103c37d: 83 3d 04 00 00 00 00 cmpl $0x0,0x4
c103c384: 74 28 je c103c3ae <run_timer_softirq+0x196>
c103c386: 89 e0 mov %esp,%eax
c103c388: 25 00 e0 ff ff and $0xffffe000,%eax
c103c38d: ff 40 14 incl 0x14(%eax)
c103c390: 8b 35 10 00 00 00 mov 0x10,%esi
c103c396: 85 f6 test %esi,%esi
c103c398: 74 0f je c103c3a9 <run_timer_softirq+0x191>
c103c39a: 8b 46 04 mov 0x4(%esi),%eax
c103c39d: 89 da mov %ebx,%edx
c103c39f: ff 16 call *(%esi)
c103c3a1: 83 c6 08 add $0x8,%esi
c103c3a4: 83 3e 00 cmpl $0x0,(%esi)
c103c3a7: eb ef jmp c103c398 <run_timer_softirq+0x180>
c103c3a9: e8 c7 fc ff ff call c103c075 <rcu_read_unlock_sched_notrace>
trace_timer_expire_exit(timer);
lock_map_release(&lockdep_map);
if (preempt_count != preempt_count()) {
c103c3ae: 89 e0 mov %esp,%eax
c103c3b0: 25 00 e0 ff ff and $0xffffe000,%eax
c103c3b5: 8b 40 14 mov 0x14(%eax),%eax
c103c3b8: 39 45 e8 cmp %eax,-0x18(%ebp)
c103c3bb: 74 3b je c103c3f8 <run_timer_softirq+0x1e0>
WARN_ONCE(1, "timer: %pF preempt leak: %08x -> %08x\n",
c103c3bd: 80 3d 4a 10 00 00 01 cmpb $0x1,0x104a
c103c3c4: 74 25 je c103c3eb <run_timer_softirq+0x1d3>
c103c3c6: 50 push %eax
c103c3c7: ff 75 e8 pushl -0x18(%ebp)
c103c3ca: ff 75 e4 pushl -0x1c(%ebp)
c103c3cd: 68 6a 02 00 00 push $0x26a
c103c3d2: 68 31 04 00 00 push $0x431
c103c3d7: 68 00 00 00 00 push $0x0
c103c3dc: e8 fc ff ff ff call c103c3dd <run_timer_softirq+0x1c5>
c103c3e1: c6 05 4a 10 00 00 01 movb $0x1,0x104a
c103c3e8: 83 c4 18 add $0x18,%esp
* Restore the preempt count. That gives us a decent
* chance to survive and extract information. If the
* callback kept a lock held, bad luck, but not worse
* than the BUG() we had.
*/
preempt_count() = preempt_count;
c103c3eb: 8b 55 e8 mov -0x18(%ebp),%edx
c103c3ee: 89 e0 mov %esp,%eax
c103c3f0: 25 00 e0 ff ff and $0xffffe000,%eax
c103c3f5: 89 50 14 mov %edx,0x14(%eax)
raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
} while (0)
static inline void spin_lock_irq(spinlock_t *lock)
{
raw_spin_lock_irq(&lock->rlock);
c103c3f8: 89 f8 mov %edi,%eax
c103c3fa: e8 fc ff ff ff call c103c3fb <run_timer_softirq+0x1e3>
* list_empty - tests whether a list is empty
* @head: the list to test.
*/
static inline int list_empty(const struct list_head *head)
{
return head->next == head;
c103c3ff: 8b 5d ec mov -0x14(%ebp),%ebx
struct timer_list *timer;
spin_lock_irq(&base->lock);
while (time_after_eq(jiffies, base->timer_jiffies)) {
struct list_head work_list;
struct list_head *head = &work_list;
c103c402: 3b 5d cc cmp -0x34(%ebp),%ebx
c103c405: 0f 85 ee fe ff ff jne c103c2f9 <run_timer_softirq+0xe1>
c103c40b: 89 fb mov %edi,%ebx
static inline void __run_timers(struct tvec_base *base)
{
struct timer_list *timer;
spin_lock_irq(&base->lock);
while (time_after_eq(jiffies, base->timer_jiffies)) {
c103c40d: a1 00 00 00 00 mov 0x0,%eax
c103c412: 8b 4b 08 mov 0x8(%ebx),%ecx
c103c415: 39 c8 cmp %ecx,%eax
c103c417: 0f 89 54 fe ff ff jns c103c271 <run_timer_softirq+0x59>
spin_unlock_irq(&base->lock);
call_timer_fn(timer, fn, data);
spin_lock_irq(&base->lock);
}
}
base->running_timer = NULL;
c103c41d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
raw_spin_unlock_bh(&lock->rlock);
}
static inline void spin_unlock_irq(spinlock_t *lock)
{
raw_spin_unlock_irq(&lock->rlock);
c103c424: 89 d8 mov %ebx,%eax
c103c426: e8 fc ff ff ff call c103c427 <run_timer_softirq+0x20f>
hrtimer_run_pending();
if (time_after_eq(jiffies, base->timer_jiffies))
__run_timers(base);
}
c103c42b: 8d 65 f4 lea -0xc(%ebp),%esp
c103c42e: 5b pop %ebx
c103c42f: 5e pop %esi
c103c430: 5f pop %edi
c103c431: 5d pop %ebp
c103c432: c3 ret
c103c433 <do_sysinfo>:
/**
* do_sysinfo - fill in sysinfo struct
* @info: pointer to buffer to fill
*/
int do_sysinfo(struct sysinfo *info)
{
c103c433: 55 push %ebp
unsigned long mem_total, sav_total;
unsigned int mem_unit, bitcount;
struct timespec tp;
memset(info, 0, sizeof(struct sysinfo));
c103c434: b9 10 00 00 00 mov $0x10,%ecx
/**
* do_sysinfo - fill in sysinfo struct
* @info: pointer to buffer to fill
*/
int do_sysinfo(struct sysinfo *info)
{
c103c439: 89 e5 mov %esp,%ebp
c103c43b: 57 push %edi
c103c43c: 56 push %esi
c103c43d: 53 push %ebx
c103c43e: 89 c3 mov %eax,%ebx
unsigned long mem_total, sav_total;
unsigned int mem_unit, bitcount;
struct timespec tp;
memset(info, 0, sizeof(struct sysinfo));
c103c440: 89 df mov %ebx,%edi
c103c442: 31 c0 xor %eax,%eax
/**
* do_sysinfo - fill in sysinfo struct
* @info: pointer to buffer to fill
*/
int do_sysinfo(struct sysinfo *info)
{
c103c444: 83 ec 08 sub $0x8,%esp
unsigned long mem_total, sav_total;
unsigned int mem_unit, bitcount;
struct timespec tp;
memset(info, 0, sizeof(struct sysinfo));
c103c447: f3 ab rep stos %eax,%es:(%edi)
ktime_get_ts(&tp);
c103c449: 8d 75 ec lea -0x14(%ebp),%esi
c103c44c: 89 f0 mov %esi,%eax
c103c44e: e8 fc ff ff ff call c103c44f <do_sysinfo+0x1c>
monotonic_to_bootbased(&tp);
c103c453: 89 f0 mov %esi,%eax
c103c455: e8 fc ff ff ff call c103c456 <do_sysinfo+0x23>
info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
c103c45a: 31 c0 xor %eax,%eax
get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);
c103c45c: b9 05 00 00 00 mov $0x5,%ecx
memset(info, 0, sizeof(struct sysinfo));
ktime_get_ts(&tp);
monotonic_to_bootbased(&tp);
info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
c103c461: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
c103c465: 0f 95 c0 setne %al
get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);
c103c468: 31 d2 xor %edx,%edx
memset(info, 0, sizeof(struct sysinfo));
ktime_get_ts(&tp);
monotonic_to_bootbased(&tp);
info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
c103c46a: 03 45 ec add -0x14(%ebp),%eax
c103c46d: 89 03 mov %eax,(%ebx)
get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);
c103c46f: 8d 43 04 lea 0x4(%ebx),%eax
c103c472: e8 fc ff ff ff call c103c473 <do_sysinfo+0x40>
info->procs = nr_threads;
c103c477: a1 00 00 00 00 mov 0x0,%eax
c103c47c: 66 89 43 28 mov %ax,0x28(%ebx)
si_meminfo(info);
c103c480: 89 d8 mov %ebx,%eax
c103c482: e8 fc ff ff ff call c103c483 <do_sysinfo+0x50>
si_swapinfo(info);
c103c487: 89 d8 mov %ebx,%eax
c103c489: e8 fc ff ff ff call c103c48a <do_sysinfo+0x57>
* well, in that case 2.2.x was broken anyways...
*
* -Erik Andersen <andersee@debian.org>
*/
mem_total = info->totalram + info->totalswap;
c103c48e: 8b 53 20 mov 0x20(%ebx),%edx
if (mem_total < info->totalram || mem_total < info->totalswap)
c103c491: 89 d0 mov %edx,%eax
c103c493: 03 43 10 add 0x10(%ebx),%eax
c103c496: 72 3b jb c103c4d3 <do_sysinfo+0xa0>
c103c498: 39 d0 cmp %edx,%eax
c103c49a: 72 37 jb c103c4d3 <do_sysinfo+0xa0>
goto out;
bitcount = 0;
mem_unit = info->mem_unit;
c103c49c: 8b 53 34 mov 0x34(%ebx),%edx
c103c49f: 31 c9 xor %ecx,%ecx
while (mem_unit > 1) {
c103c4a1: eb 0c jmp c103c4af <do_sysinfo+0x7c>
bitcount++;
mem_unit >>= 1;
sav_total = mem_total;
mem_total <<= 1;
c103c4a3: 8d 34 00 lea (%eax,%eax,1),%esi
if (mem_total < sav_total)
c103c4a6: 39 c6 cmp %eax,%esi
c103c4a8: 72 29 jb c103c4d3 <do_sysinfo+0xa0>
if (mem_total < info->totalram || mem_total < info->totalswap)
goto out;
bitcount = 0;
mem_unit = info->mem_unit;
while (mem_unit > 1) {
bitcount++;
c103c4aa: 41 inc %ecx
mem_unit >>= 1;
c103c4ab: 89 f0 mov %esi,%eax
c103c4ad: d1 ea shr %edx
mem_total = info->totalram + info->totalswap;
if (mem_total < info->totalram || mem_total < info->totalswap)
goto out;
bitcount = 0;
mem_unit = info->mem_unit;
while (mem_unit > 1) {
c103c4af: 83 fa 01 cmp $0x1,%edx
c103c4b2: 77 ef ja c103c4a3 <do_sysinfo+0x70>
* with 2.2.x, and also retains compatibility with earlier 2.4.x
* kernels...
*/
info->mem_unit = 1;
info->totalram <<= bitcount;
c103c4b4: d3 63 10 shll %cl,0x10(%ebx)
info->freeram <<= bitcount;
c103c4b7: d3 63 14 shll %cl,0x14(%ebx)
info->sharedram <<= bitcount;
c103c4ba: d3 63 18 shll %cl,0x18(%ebx)
info->bufferram <<= bitcount;
c103c4bd: d3 63 1c shll %cl,0x1c(%ebx)
info->totalswap <<= bitcount;
c103c4c0: d3 63 20 shll %cl,0x20(%ebx)
info->freeswap <<= bitcount;
c103c4c3: d3 63 24 shll %cl,0x24(%ebx)
info->totalhigh <<= bitcount;
c103c4c6: d3 63 2c shll %cl,0x2c(%ebx)
info->freehigh <<= bitcount;
c103c4c9: d3 63 30 shll %cl,0x30(%ebx)
* info->mem_unit and set it to 1. This leaves things compatible
* with 2.2.x, and also retains compatibility with earlier 2.4.x
* kernels...
*/
info->mem_unit = 1;
c103c4cc: c7 43 34 01 00 00 00 movl $0x1,0x34(%ebx)
info->totalhigh <<= bitcount;
info->freehigh <<= bitcount;
out:
return 0;
}
c103c4d3: 5e pop %esi
c103c4d4: 31 c0 xor %eax,%eax
c103c4d6: 5f pop %edi
c103c4d7: 5b pop %ebx
c103c4d8: 5e pop %esi
c103c4d9: 5f pop %edi
c103c4da: 5d pop %ebp
c103c4db: c3 ret
c103c4dc <sys_sysinfo>:
SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info)
{
c103c4dc: 55 push %ebp
c103c4dd: 89 e5 mov %esp,%ebp
c103c4df: 53 push %ebx
struct sysinfo val;
do_sysinfo(&val);
c103c4e0: 8d 5d bc lea -0x44(%ebp),%ebx
out:
return 0;
}
SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info)
{
c103c4e3: 83 ec 40 sub $0x40,%esp
struct sysinfo val;
do_sysinfo(&val);
c103c4e6: 89 d8 mov %ebx,%eax
c103c4e8: e8 fc ff ff ff call c103c4e9 <sys_sysinfo+0xd>
if (copy_to_user(info, &val, sizeof(struct sysinfo)))
c103c4ed: 8b 45 08 mov 0x8(%ebp),%eax
c103c4f0: 89 da mov %ebx,%edx
c103c4f2: b9 40 00 00 00 mov $0x40,%ecx
c103c4f7: e8 fc ff ff ff call c103c4f8 <sys_sysinfo+0x1c>
c103c4fc: 83 f8 01 cmp $0x1,%eax
c103c4ff: 19 c0 sbb %eax,%eax
return -EFAULT;
return 0;
}
c103c501: 83 c4 40 add $0x40,%esp
{
struct sysinfo val;
do_sysinfo(&val);
if (copy_to_user(info, &val, sizeof(struct sysinfo)))
c103c504: f7 d0 not %eax
c103c506: 83 e0 f2 and $0xfffffff2,%eax
return -EFAULT;
return 0;
}
c103c509: 5b pop %ebx
c103c50a: 5d pop %ebp
c103c50b: c3 ret
c103c50c <sys_gettid>:
}
EXPORT_SYMBOL(schedule_timeout_uninterruptible);
/* Thread ID - the internal kernel "pid" */
SYSCALL_DEFINE0(gettid)
{
c103c50c: 55 push %ebp
return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
}
static inline pid_t task_pid_vnr(struct task_struct *tsk)
{
return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
c103c50d: 31 c9 xor %ecx,%ecx
c103c50f: 89 e5 mov %esp,%ebp
c103c511: 31 d2 xor %edx,%edx
c103c513: 64 a1 00 00 00 00 mov %fs:0x0,%eax
c103c519: e8 fc ff ff ff call c103c51a <sys_gettid+0xe>
return task_pid_vnr(current);
}
c103c51e: 5d pop %ebp
c103c51f: c3 ret
c103c520 <lock_timer_base>:
* locked.
*/
static struct tvec_base *lock_timer_base(struct timer_list *timer,
unsigned long *flags)
__acquires(timer->base->lock)
{
c103c520: 55 push %ebp
c103c521: 89 e5 mov %esp,%ebp
c103c523: 57 push %edi
c103c524: 89 d7 mov %edx,%edi
c103c526: 56 push %esi
c103c527: 89 c6 mov %eax,%esi
c103c529: 53 push %ebx
c103c52a: 83 ec 04 sub $0x4,%esp
struct tvec_base *base;
for (;;) {
struct tvec_base *prelock_base = timer->base;
c103c52d: 8b 4e 0c mov 0xc(%esi),%ecx
base = tbase_get_base(prelock_base);
if (likely(base != NULL)) {
c103c530: 89 cb mov %ecx,%ebx
c103c532: 83 e3 fe and $0xfffffffe,%ebx
c103c535: 74 25 je c103c55c <lock_timer_base+0x3c>
spin_lock_irqsave(&base->lock, *flags);
c103c537: 89 d8 mov %ebx,%eax
c103c539: 89 4d f0 mov %ecx,-0x10(%ebp)
c103c53c: e8 fc ff ff ff call c103c53d <lock_timer_base+0x1d>
if (likely(prelock_base == timer->base))
c103c541: 8b 4d f0 mov -0x10(%ebp),%ecx
for (;;) {
struct tvec_base *prelock_base = timer->base;
base = tbase_get_base(prelock_base);
if (likely(base != NULL)) {
spin_lock_irqsave(&base->lock, *flags);
c103c544: 89 07 mov %eax,(%edi)
if (likely(prelock_base == timer->base))
c103c546: 3b 4e 0c cmp 0xc(%esi),%ecx
c103c549: 75 08 jne c103c553 <lock_timer_base+0x33>
/* The timer has migrated to another CPU */
spin_unlock_irqrestore(&base->lock, *flags);
}
cpu_relax();
}
}
c103c54b: 5a pop %edx
c103c54c: 89 d8 mov %ebx,%eax
c103c54e: 5b pop %ebx
c103c54f: 5e pop %esi
c103c550: 5f pop %edi
c103c551: 5d pop %ebp
c103c552: c3 ret
}
static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
{
raw_spin_unlock_irqrestore(&lock->rlock, flags);
c103c553: 89 c2 mov %eax,%edx
c103c555: 89 d8 mov %ebx,%eax
c103c557: e8 fc ff ff ff call c103c558 <lock_timer_base+0x38>
}
/* REP NOP (PAUSE) is a good thing to insert into busy-wait loops. */
static inline void rep_nop(void)
{
asm volatile("rep; nop" ::: "memory");
c103c55c: f3 90 pause
return base;
/* The timer has migrated to another CPU */
spin_unlock_irqrestore(&base->lock, *flags);
}
cpu_relax();
}
c103c55e: eb cd jmp c103c52d <lock_timer_base+0xd>
c103c560 <try_to_del_timer_sync>:
*
* This function tries to deactivate a timer. Upon successful (ret >= 0)
* exit the timer is not queued and the handler is not running on any CPU.
*/
int try_to_del_timer_sync(struct timer_list *timer)
{
c103c560: 55 push %ebp
c103c561: 89 e5 mov %esp,%ebp
c103c563: 57 push %edi
unsigned long flags;
int ret = -1;
base = lock_timer_base(timer, &flags);
if (base->running_timer == timer)
c103c564: 83 cf ff or $0xffffffff,%edi
*
* This function tries to deactivate a timer. Upon successful (ret >= 0)
* exit the timer is not queued and the handler is not running on any CPU.
*/
int try_to_del_timer_sync(struct timer_list *timer)
{
c103c567: 56 push %esi
c103c568: 53 push %ebx
c103c569: 89 c3 mov %eax,%ebx
c103c56b: 83 ec 04 sub $0x4,%esp
struct tvec_base *base;
unsigned long flags;
int ret = -1;
base = lock_timer_base(timer, &flags);
c103c56e: 8d 55 f0 lea -0x10(%ebp),%edx
c103c571: e8 aa ff ff ff call c103c520 <lock_timer_base>
if (base->running_timer == timer)
c103c576: 39 58 04 cmp %ebx,0x4(%eax)
{
struct tvec_base *base;
unsigned long flags;
int ret = -1;
base = lock_timer_base(timer, &flags);
c103c579: 89 c6 mov %eax,%esi
if (base->running_timer == timer)
c103c57b: 74 39 je c103c5b6 <try_to_del_timer_sync+0x56>
goto out;
timer_stats_timer_clear_start_info(timer);
ret = 0;
if (timer_pending(timer)) {
c103c57d: 31 ff xor %edi,%edi
c103c57f: 83 3b 00 cmpl $0x0,(%ebx)
__timer_stats_timer_set_start_info(timer, __builtin_return_address(0));
}
static inline void timer_stats_timer_clear_start_info(struct timer_list *timer)
{
timer->start_site = NULL;
c103c582: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
c103c589: 74 2b je c103c5b6 <try_to_del_timer_sync+0x56>
detach_timer(timer, 1);
c103c58b: 89 d8 mov %ebx,%eax
c103c58d: ba 01 00 00 00 mov $0x1,%edx
c103c592: e8 f9 fa ff ff call c103c090 <detach_timer>
if (timer->expires == base->next_timer &&
c103c597: 8b 43 08 mov 0x8(%ebx),%eax
c103c59a: 3b 46 0c cmp 0xc(%esi),%eax
c103c59d: 75 12 jne c103c5b1 <try_to_del_timer_sync+0x51>
!tbase_get_deferrable(timer->base))
c103c59f: f6 43 0c 01 testb $0x1,0xc(%ebx)
c103c5a3: 75 0c jne c103c5b1 <try_to_del_timer_sync+0x51>
base->next_timer = base->timer_jiffies;
c103c5a5: 8b 46 08 mov 0x8(%esi),%eax
c103c5a8: 66 bf 01 00 mov $0x1,%di
c103c5ac: 89 46 0c mov %eax,0xc(%esi)
c103c5af: eb 05 jmp c103c5b6 <try_to_del_timer_sync+0x56>
c103c5b1: bf 01 00 00 00 mov $0x1,%edi
c103c5b6: 8b 55 f0 mov -0x10(%ebp),%edx
c103c5b9: 89 f0 mov %esi,%eax
c103c5bb: e8 fc ff ff ff call c103c5bc <try_to_del_timer_sync+0x5c>
}
out:
spin_unlock_irqrestore(&base->lock, flags);
return ret;
}
c103c5c0: 89 f8 mov %edi,%eax
c103c5c2: 59 pop %ecx
c103c5c3: 5b pop %ebx
c103c5c4: 5e pop %esi
c103c5c5: 5f pop %edi
c103c5c6: 5d pop %ebp
c103c5c7: c3 ret
c103c5c8 <del_timer_sync>:
* it has interrupted the softirq that CPU0 is waiting to finish.
*
* The function returns whether it has deactivated a pending timer or not.
*/
int del_timer_sync(struct timer_list *timer)
{
c103c5c8: 55 push %ebp
c103c5c9: 89 e5 mov %esp,%ebp
c103c5cb: 53 push %ebx
c103c5cc: 89 c3 mov %eax,%ebx
#endif
/*
* don't use it in hardirq context, because it
* could lead to deadlock.
*/
WARN_ON(in_irq());
c103c5ce: 89 e0 mov %esp,%eax
c103c5d0: 25 00 e0 ff ff and $0xffffe000,%eax
c103c5d5: f7 40 14 00 00 ff 03 testl $0x3ff0000,0x14(%eax)
c103c5dc: 74 0f je c103c5ed <del_timer_sync+0x25>
c103c5de: ba f4 03 00 00 mov $0x3f4,%edx
c103c5e3: b8 00 00 00 00 mov $0x0,%eax
c103c5e8: e8 fc ff ff ff call c103c5e9 <del_timer_sync+0x21>
for (;;) {
int ret = try_to_del_timer_sync(timer);
c103c5ed: 89 d8 mov %ebx,%eax
c103c5ef: e8 fc ff ff ff call c103c5f0 <del_timer_sync+0x28>
if (ret >= 0)
c103c5f4: 85 c0 test %eax,%eax
c103c5f6: 78 03 js c103c5fb <del_timer_sync+0x33>
return ret;
cpu_relax();
}
}
c103c5f8: 5b pop %ebx
c103c5f9: 5d pop %ebp
c103c5fa: c3 ret
c103c5fb: f3 90 pause
for (;;) {
int ret = try_to_del_timer_sync(timer);
if (ret >= 0)
return ret;
cpu_relax();
}
c103c5fd: eb ee jmp c103c5ed <del_timer_sync+0x25>
c103c5ff <del_timer>:
* The function returns whether it has deactivated a pending timer or not.
* (ie. del_timer() of an inactive timer returns 0, del_timer() of an
* active timer returns 1.)
*/
int del_timer(struct timer_list *timer)
{
c103c5ff: 55 push %ebp
c103c600: 89 e5 mov %esp,%ebp
c103c602: 57 push %edi
struct tvec_base *base;
unsigned long flags;
int ret = 0;
timer_stats_timer_clear_start_info(timer);
if (timer_pending(timer)) {
c103c603: 31 ff xor %edi,%edi
* The function returns whether it has deactivated a pending timer or not.
* (ie. del_timer() of an inactive timer returns 0, del_timer() of an
* active timer returns 1.)
*/
int del_timer(struct timer_list *timer)
{
c103c605: 56 push %esi
c103c606: 53 push %ebx
c103c607: 89 c3 mov %eax,%ebx
c103c609: 83 ec 04 sub $0x4,%esp
struct tvec_base *base;
unsigned long flags;
int ret = 0;
timer_stats_timer_clear_start_info(timer);
if (timer_pending(timer)) {
c103c60c: 83 38 00 cmpl $0x0,(%eax)
c103c60f: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
c103c616: 74 44 je c103c65c <del_timer+0x5d>
base = lock_timer_base(timer, &flags);
c103c618: 8d 55 f0 lea -0x10(%ebp),%edx
c103c61b: e8 00 ff ff ff call c103c520 <lock_timer_base>
if (timer_pending(timer)) {
c103c620: 83 3b 00 cmpl $0x0,(%ebx)
unsigned long flags;
int ret = 0;
timer_stats_timer_clear_start_info(timer);
if (timer_pending(timer)) {
base = lock_timer_base(timer, &flags);
c103c623: 89 c6 mov %eax,%esi
if (timer_pending(timer)) {
c103c625: 74 2b je c103c652 <del_timer+0x53>
detach_timer(timer, 1);
c103c627: 89 d8 mov %ebx,%eax
c103c629: ba 01 00 00 00 mov $0x1,%edx
c103c62e: e8 5d fa ff ff call c103c090 <detach_timer>
if (timer->expires == base->next_timer &&
c103c633: 8b 43 08 mov 0x8(%ebx),%eax
c103c636: 3b 46 0c cmp 0xc(%esi),%eax
c103c639: 75 12 jne c103c64d <del_timer+0x4e>
!tbase_get_deferrable(timer->base))
c103c63b: f6 43 0c 01 testb $0x1,0xc(%ebx)
c103c63f: 75 0c jne c103c64d <del_timer+0x4e>
base->next_timer = base->timer_jiffies;
c103c641: 8b 46 08 mov 0x8(%esi),%eax
c103c644: 66 bf 01 00 mov $0x1,%di
c103c648: 89 46 0c mov %eax,0xc(%esi)
c103c64b: eb 05 jmp c103c652 <del_timer+0x53>
c103c64d: bf 01 00 00 00 mov $0x1,%edi
c103c652: 8b 55 f0 mov -0x10(%ebp),%edx
c103c655: 89 f0 mov %esi,%eax
c103c657: e8 fc ff ff ff call c103c658 <del_timer+0x59>
}
spin_unlock_irqrestore(&base->lock, flags);
}
return ret;
}
c103c65c: 5b pop %ebx
c103c65d: 89 f8 mov %edi,%eax
c103c65f: 5b pop %ebx
c103c660: 5e pop %esi
c103c661: 5f pop %edi
c103c662: 5d pop %ebp
c103c663: c3 ret
c103c664 <process_timeout>:
}
#endif
static void process_timeout(unsigned long __data)
{
c103c664: 55 push %ebp
c103c665: 89 e5 mov %esp,%ebp
wake_up_process((struct task_struct *)__data);
c103c667: e8 fc ff ff ff call c103c668 <process_timeout+0x4>
}
c103c66c: 5d pop %ebp
c103c66d: c3 ret
c103c66e <sys_getpid>:
* which case the tgid is the same in all threads of the same group.
*
* This is SMP safe as current->tgid does not change.
*/
SYSCALL_DEFINE0(getpid)
{
c103c66e: 55 push %ebp
c103c66f: 64 a1 00 00 00 00 mov %fs:0x0,%eax
pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
static inline pid_t task_tgid_vnr(struct task_struct *tsk)
{
return pid_vnr(task_tgid(tsk));
c103c675: 8b 80 20 02 00 00 mov 0x220(%eax),%eax
c103c67b: 89 e5 mov %esp,%ebp
c103c67d: 8b 80 3c 02 00 00 mov 0x23c(%eax),%eax
c103c683: e8 fc ff ff ff call c103c684 <sys_getpid+0x16>
return task_tgid_vnr(current);
}
c103c688: 5d pop %ebp
c103c689: c3 ret
c103c68a <sys_getppid>:
* change from under us. However, we can use a stale
* value of ->real_parent under rcu_read_lock(), see
* release_task()->call_rcu(delayed_put_task_struct).
*/
SYSCALL_DEFINE0(getppid)
{
c103c68a: 55 push %ebp
c103c68b: 89 e5 mov %esp,%ebp
c103c68d: 83 ec 04 sub $0x4,%esp
* block, but only when acquiring spinlocks that are subject to priority
* inheritance.
*/
static inline void rcu_read_lock(void)
{
__rcu_read_lock();
c103c690: e8 fc ff ff ff call c103c691 <sys_getppid+0x7>
c103c695: 64 a1 00 00 00 00 mov %fs:0x0,%eax
c103c69b: 8b 80 08 02 00 00 mov 0x208(%eax),%eax
c103c6a1: 8b 80 20 02 00 00 mov 0x220(%eax),%eax
c103c6a7: 8b 80 3c 02 00 00 mov 0x23c(%eax),%eax
c103c6ad: e8 fc ff ff ff call c103c6ae <sys_getppid+0x24>
*/
static inline void rcu_read_unlock(void)
{
rcu_read_release();
__release(RCU);
__rcu_read_unlock();
c103c6b2: 89 45 fc mov %eax,-0x4(%ebp)
c103c6b5: e8 fc ff ff ff call c103c6b6 <sys_getppid+0x2c>
rcu_read_lock();
pid = task_tgid_vnr(current->real_parent);
rcu_read_unlock();
return pid;
}
c103c6ba: 8b 45 fc mov -0x4(%ebp),%eax
c103c6bd: c9 leave
c103c6be: c3 ret
c103c6bf <sys_alarm>:
/*
* For backwards compatibility? This can be done in libc so Alpha
* and all newer ports shouldn't need it.
*/
SYSCALL_DEFINE1(alarm, unsigned int, seconds)
{
c103c6bf: 55 push %ebp
c103c6c0: 89 e5 mov %esp,%ebp
return alarm_setitimer(seconds);
c103c6c2: 8b 45 08 mov 0x8(%ebp),%eax
c103c6c5: e8 fc ff ff ff call c103c6c6 <sys_alarm+0x7>
}
c103c6ca: 5d pop %ebp
c103c6cb: c3 ret
c103c6cc <run_local_timers>:
/*
* Called by the local, per-CPU timer interrupt on SMP.
*/
void run_local_timers(void)
{
c103c6cc: 55 push %ebp
c103c6cd: 89 e5 mov %esp,%ebp
hrtimer_run_queues();
c103c6cf: e8 fc ff ff ff call c103c6d0 <run_local_timers+0x4>
raise_softirq(TIMER_SOFTIRQ);
c103c6d4: b8 01 00 00 00 mov $0x1,%eax
c103c6d9: e8 fc ff ff ff call c103c6da <run_local_timers+0xe>
}
c103c6de: 5d pop %ebp
c103c6df: c3 ret
c103c6e0 <update_process_times>:
/*
* Called from the timer interrupt handler to charge one tick to the current
* process. user_tick is 1 if the tick is user time, 0 for system.
*/
void update_process_times(int user_tick)
{
c103c6e0: 55 push %ebp
c103c6e1: 89 e5 mov %esp,%ebp
c103c6e3: 57 push %edi
c103c6e4: 56 push %esi
c103c6e5: 53 push %ebx
c103c6e6: 89 c3 mov %eax,%ebx
struct task_struct *p = current;
int cpu = smp_processor_id();
c103c6e8: e8 fc ff ff ff call c103c6e9 <update_process_times+0x9>
/* Note: this timer irq context must be accounted for as well. */
account_process_tick(p, user_tick);
c103c6ed: 89 da mov %ebx,%edx
c103c6ef: 64 8b 3d 00 00 00 00 mov %fs:0x0,%edi
* process. user_tick is 1 if the tick is user time, 0 for system.
*/
void update_process_times(int user_tick)
{
struct task_struct *p = current;
int cpu = smp_processor_id();
c103c6f6: 89 c6 mov %eax,%esi
/* Note: this timer irq context must be accounted for as well. */
account_process_tick(p, user_tick);
c103c6f8: 89 f8 mov %edi,%eax
c103c6fa: e8 fc ff ff ff call c103c6fb <update_process_times+0x1b>
run_local_timers();
c103c6ff: e8 fc ff ff ff call c103c700 <update_process_times+0x20>
rcu_check_callbacks(cpu, user_tick);
c103c704: 89 f0 mov %esi,%eax
c103c706: 89 da mov %ebx,%edx
c103c708: e8 fc ff ff ff call c103c709 <update_process_times+0x29>
printk_tick();
c103c70d: e8 fc ff ff ff call c103c70e <update_process_times+0x2e>
#ifdef CONFIG_IRQ_WORK
if (in_irq())
c103c712: 89 e0 mov %esp,%eax
c103c714: 25 00 e0 ff ff and $0xffffe000,%eax
c103c719: f7 40 14 00 00 ff 03 testl $0x3ff0000,0x14(%eax)
c103c720: 74 05 je c103c727 <update_process_times+0x47>
irq_work_run();
c103c722: e8 fc ff ff ff call c103c723 <update_process_times+0x43>
#endif
scheduler_tick();
c103c727: e8 fc ff ff ff call c103c728 <update_process_times+0x48>
run_posix_cpu_timers(p);
c103c72c: 89 f8 mov %edi,%eax
c103c72e: e8 fc ff ff ff call c103c72f <update_process_times+0x4f>
}
c103c733: 5b pop %ebx
c103c734: 5e pop %esi
c103c735: 5f pop %edi
c103c736: 5d pop %ebp
c103c737: c3 ret
c103c738 <get_next_timer_interrupt>:
/**
* get_next_timer_interrupt - return the jiffy of the next pending timer
* @now: current time (in jiffies)
*/
unsigned long get_next_timer_interrupt(unsigned long now)
{
c103c738: 55 push %ebp
c103c739: 89 e5 mov %esp,%ebp
c103c73b: 57 push %edi
c103c73c: 56 push %esi
c103c73d: 53 push %ebx
c103c73e: 83 ec 2c sub $0x2c,%esp
c103c741: 89 45 e0 mov %eax,-0x20(%ebp)
struct tvec_base *base = __this_cpu_read(tvec_bases);
c103c744: 64 8b 1d 00 00 00 00 mov %fs:0x0,%ebx
/*
* Pretend that there is no timer pending if the cpu is offline.
* Possible pending timers will be migrated later to an active cpu.
*/
if (cpu_is_offline(smp_processor_id()))
c103c74b: e8 fc ff ff ff call c103c74c <get_next_timer_interrupt+0x14>
static inline int variable_test_bit(int nr, volatile const unsigned long *addr)
{
int oldbit;
asm volatile("bt %2,%1\n\t"
c103c750: 8b 15 00 00 00 00 mov 0x0,%edx
c103c756: 0f a3 02 bt %eax,(%edx)
c103c759: 19 c0 sbb %eax,%eax
c103c75b: 85 c0 test %eax,%eax
c103c75d: 75 0c jne c103c76b <get_next_timer_interrupt+0x33>
return now + NEXT_TIMER_MAX_DELTA;
c103c75f: 81 45 e0 ff ff ff 3f addl $0x3fffffff,-0x20(%ebp)
c103c766: e9 91 01 00 00 jmp c103c8fc <get_next_timer_interrupt+0x1c4>
raw_spin_lock_init(&(_lock)->rlock); \
} while (0)
static inline void spin_lock(spinlock_t *lock)
{
raw_spin_lock(&lock->rlock);
c103c76b: 89 d8 mov %ebx,%eax
c103c76d: e8 fc ff ff ff call c103c76e <get_next_timer_interrupt+0x36>
spin_lock(&base->lock);
if (time_before_eq(base->next_timer, base->timer_jiffies))
c103c772: 8b 43 08 mov 0x8(%ebx),%eax
c103c775: 3b 43 0c cmp 0xc(%ebx),%eax
c103c778: 0f 88 12 01 00 00 js c103c890 <get_next_timer_interrupt+0x158>
int index, slot, array, found = 0;
struct timer_list *nte;
struct tvec *varray[4];
/* Look for timer events in tv1. */
index = slot = timer_jiffies & TVR_MASK;
c103c77e: 0f b6 c8 movzbl %al,%ecx
c103c781: 89 ce mov %ecx,%esi
do {
list_for_each_entry(nte, base->tv1.vec + slot, entry) {
c103c783: 8d 7c f3 10 lea 0x10(%ebx,%esi,8),%edi
c103c787: 8b 54 f3 10 mov 0x10(%ebx,%esi,8),%edx
c103c78b: 89 7d dc mov %edi,-0x24(%ebp)
c103c78e: eb 20 jmp c103c7b0 <get_next_timer_interrupt+0x78>
if (tbase_get_deferrable(nte->base))
c103c790: f6 42 0c 01 testb $0x1,0xc(%edx)
c103c794: 74 04 je c103c79a <get_next_timer_interrupt+0x62>
struct tvec *varray[4];
/* Look for timer events in tv1. */
index = slot = timer_jiffies & TVR_MASK;
do {
list_for_each_entry(nte, base->tv1.vec + slot, entry) {
c103c796: 89 fa mov %edi,%edx
c103c798: eb 16 jmp c103c7b0 <get_next_timer_interrupt+0x78>
continue;
found = 1;
expires = nte->expires;
/* Look at the cascade bucket(s)? */
if (!index || slot < index)
c103c79a: 39 ce cmp %ecx,%esi
list_for_each_entry(nte, base->tv1.vec + slot, entry) {
if (tbase_get_deferrable(nte->base))
continue;
found = 1;
expires = nte->expires;
c103c79c: 8b 52 08 mov 0x8(%edx),%edx
/* Look at the cascade bucket(s)? */
if (!index || slot < index)
c103c79f: 7c 08 jl c103c7a9 <get_next_timer_interrupt+0x71>
c103c7a1: 85 c9 test %ecx,%ecx
c103c7a3: 0f 85 e4 00 00 00 jne c103c88d <get_next_timer_interrupt+0x155>
c103c7a9: bf 01 00 00 00 mov $0x1,%edi
c103c7ae: eb 1e jmp c103c7ce <get_next_timer_interrupt+0x96>
struct tvec *varray[4];
/* Look for timer events in tv1. */
index = slot = timer_jiffies & TVR_MASK;
do {
list_for_each_entry(nte, base->tv1.vec + slot, entry) {
c103c7b0: 8b 3a mov (%edx),%edi
c103c7b2: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c103c7b6: 3b 55 dc cmp -0x24(%ebp),%edx
c103c7b9: 75 d5 jne c103c790 <get_next_timer_interrupt+0x58>
/* Look at the cascade bucket(s)? */
if (!index || slot < index)
goto cascade;
return expires;
}
slot = (slot + 1) & TVR_MASK;
c103c7bb: 46 inc %esi
c103c7bc: 81 e6 ff 00 00 00 and $0xff,%esi
} while (slot != index);
c103c7c2: 39 ce cmp %ecx,%esi
c103c7c4: 75 bd jne c103c783 <get_next_timer_interrupt+0x4b>
* This function needs to be called with interrupts disabled.
*/
static unsigned long __next_timer_interrupt(struct tvec_base *base)
{
unsigned long timer_jiffies = base->timer_jiffies;
unsigned long expires = timer_jiffies + NEXT_TIMER_MAX_DELTA;
c103c7c6: 8d 90 ff ff ff 3f lea 0x3fffffff(%eax),%edx
c103c7cc: 31 ff xor %edi,%edi
slot = (slot + 1) & TVR_MASK;
} while (slot != index);
cascade:
/* Calculate the next cascade event */
if (index)
c103c7ce: 85 c9 test %ecx,%ecx
c103c7d0: 74 07 je c103c7d9 <get_next_timer_interrupt+0xa1>
timer_jiffies += TVR_SIZE - index;
c103c7d2: 05 00 01 00 00 add $0x100,%eax
c103c7d7: 29 c8 sub %ecx,%eax
timer_jiffies >>= TVR_BITS;
c103c7d9: c1 e8 08 shr $0x8,%eax
c103c7dc: 89 45 dc mov %eax,-0x24(%ebp)
/* Check tv2-tv5. */
varray[0] = &base->tv2;
c103c7df: 8d 83 10 08 00 00 lea 0x810(%ebx),%eax
c103c7e5: 89 45 e4 mov %eax,-0x1c(%ebp)
varray[1] = &base->tv3;
c103c7e8: 8d 83 10 0a 00 00 lea 0xa10(%ebx),%eax
c103c7ee: 89 45 e8 mov %eax,-0x18(%ebp)
varray[2] = &base->tv4;
c103c7f1: 8d 83 10 0c 00 00 lea 0xc10(%ebx),%eax
c103c7f7: 89 45 ec mov %eax,-0x14(%ebp)
varray[3] = &base->tv5;
c103c7fa: 8d 83 10 0e 00 00 lea 0xe10(%ebx),%eax
c103c800: 89 45 f0 mov %eax,-0x10(%ebp)
c103c803: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
for (array = 0; array < 4; array++) {
struct tvec *varp = varray[array];
c103c80a: 89 5d cc mov %ebx,-0x34(%ebp)
c103c80d: 8b 45 d8 mov -0x28(%ebp),%eax
index = slot = timer_jiffies & TVN_MASK;
c103c810: 8b 4d dc mov -0x24(%ebp),%ecx
varray[1] = &base->tv3;
varray[2] = &base->tv4;
varray[3] = &base->tv5;
for (array = 0; array < 4; array++) {
struct tvec *varp = varray[array];
c103c813: 8b 44 85 e4 mov -0x1c(%ebp,%eax,4),%eax
index = slot = timer_jiffies & TVN_MASK;
c103c817: 83 e1 3f and $0x3f,%ecx
varray[1] = &base->tv3;
varray[2] = &base->tv4;
varray[3] = &base->tv5;
for (array = 0; array < 4; array++) {
struct tvec *varp = varray[array];
c103c81a: 89 45 d0 mov %eax,-0x30(%ebp)
index = slot = timer_jiffies & TVN_MASK;
c103c81d: 89 c8 mov %ecx,%eax
do {
list_for_each_entry(nte, varp->vec + slot, entry) {
c103c81f: 8b 75 d0 mov -0x30(%ebp),%esi
c103c822: 8b 1c c6 mov (%esi,%eax,8),%ebx
c103c825: 8d 34 c6 lea (%esi,%eax,8),%esi
c103c828: 89 75 c8 mov %esi,-0x38(%ebp)
c103c82b: eb 1a jmp c103c847 <get_next_timer_interrupt+0x10f>
if (tbase_get_deferrable(nte->base))
c103c82d: f6 43 0c 01 testb $0x1,0xc(%ebx)
c103c831: 89 d6 mov %edx,%esi
c103c833: 75 0d jne c103c842 <get_next_timer_interrupt+0x10a>
continue;
found = 1;
if (time_before(nte->expires, expires))
c103c835: 8b 73 08 mov 0x8(%ebx),%esi
c103c838: bf 01 00 00 00 mov $0x1,%edi
c103c83d: 39 d6 cmp %edx,%esi
c103c83f: 0f 49 f2 cmovns %edx,%esi
for (array = 0; array < 4; array++) {
struct tvec *varp = varray[array];
index = slot = timer_jiffies & TVN_MASK;
do {
list_for_each_entry(nte, varp->vec + slot, entry) {
c103c842: 8b 5d d4 mov -0x2c(%ebp),%ebx
c103c845: 89 f2 mov %esi,%edx
c103c847: 8b 33 mov (%ebx),%esi
c103c849: 89 75 d4 mov %esi,-0x2c(%ebp)
c103c84c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c103c850: 3b 5d c8 cmp -0x38(%ebp),%ebx
c103c853: 75 d8 jne c103c82d <get_next_timer_interrupt+0xf5>
}
/*
* Do we still search for the first timer or are
* we looking up the cascade buckets ?
*/
if (found) {
c103c855: 85 ff test %edi,%edi
c103c857: 74 0f je c103c868 <get_next_timer_interrupt+0x130>
/* Look at the cascade bucket(s)? */
if (!index || slot < index)
c103c859: 39 c8 cmp %ecx,%eax
c103c85b: 7c 04 jl c103c861 <get_next_timer_interrupt+0x129>
c103c85d: 85 c9 test %ecx,%ecx
c103c85f: 75 29 jne c103c88a <get_next_timer_interrupt+0x152>
c103c861: bf 01 00 00 00 mov $0x1,%edi
c103c866: eb 08 jmp c103c870 <get_next_timer_interrupt+0x138>
break;
return expires;
}
slot = (slot + 1) & TVN_MASK;
c103c868: 40 inc %eax
c103c869: 83 e0 3f and $0x3f,%eax
} while (slot != index);
c103c86c: 39 c8 cmp %ecx,%eax
c103c86e: 75 af jne c103c81f <get_next_timer_interrupt+0xe7>
if (index)
c103c870: 85 c9 test %ecx,%ecx
c103c872: 74 07 je c103c87b <get_next_timer_interrupt+0x143>
timer_jiffies += TVN_SIZE - index;
c103c874: 83 45 dc 40 addl $0x40,-0x24(%ebp)
c103c878: 29 4d dc sub %ecx,-0x24(%ebp)
varray[0] = &base->tv2;
varray[1] = &base->tv3;
varray[2] = &base->tv4;
varray[3] = &base->tv5;
for (array = 0; array < 4; array++) {
c103c87b: ff 45 d8 incl -0x28(%ebp)
c103c87e: 83 7d d8 04 cmpl $0x4,-0x28(%ebp)
c103c882: 74 06 je c103c88a <get_next_timer_interrupt+0x152>
slot = (slot + 1) & TVN_MASK;
} while (slot != index);
if (index)
timer_jiffies += TVN_SIZE - index;
timer_jiffies >>= TVN_BITS;
c103c884: c1 6d dc 06 shrl $0x6,-0x24(%ebp)
c103c888: eb 83 jmp c103c80d <get_next_timer_interrupt+0xd5>
c103c88a: 8b 5d cc mov -0x34(%ebp),%ebx
*/
if (cpu_is_offline(smp_processor_id()))
return now + NEXT_TIMER_MAX_DELTA;
spin_lock(&base->lock);
if (time_before_eq(base->next_timer, base->timer_jiffies))
base->next_timer = __next_timer_interrupt(base);
c103c88d: 89 53 0c mov %edx,0xc(%ebx)
expires = base->next_timer;
c103c890: 8b 73 0c mov 0xc(%ebx),%esi
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
c103c893: 89 d8 mov %ebx,%eax
c103c895: e8 fc ff ff ff call c103c896 <get_next_timer_interrupt+0x15e>
spin_unlock(&base->lock);
if (time_before_eq(expires, now))
c103c89a: 39 75 e0 cmp %esi,-0x20(%ebp)
c103c89d: 79 5d jns c103c8fc <get_next_timer_interrupt+0x1c4>
* event:
*/
static unsigned long cmp_next_hrtimer_event(unsigned long now,
unsigned long expires)
{
ktime_t hr_delta = hrtimer_get_next_event();
c103c89f: e8 fc ff ff ff call c103c8a0 <get_next_timer_interrupt+0x168>
struct timespec tsdelta;
unsigned long delta;
if (hr_delta.tv64 == KTIME_MAX)
c103c8a4: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
c103c8aa: 75 07 jne c103c8b3 <get_next_timer_interrupt+0x17b>
c103c8ac: 83 f8 ff cmp $0xffffffff,%eax
c103c8af: 75 13 jne c103c8c4 <get_next_timer_interrupt+0x18c>
c103c8b1: eb 46 jmp c103c8f9 <get_next_timer_interrupt+0x1c1>
return expires;
/*
* Expired timer available, let it expire in the next tick
*/
if (hr_delta.tv64 <= 0)
c103c8b3: 83 fa 00 cmp $0x0,%edx
c103c8b6: 7f 0c jg c103c8c4 <get_next_timer_interrupt+0x18c>
c103c8b8: 7c 05 jl c103c8bf <get_next_timer_interrupt+0x187>
c103c8ba: 83 f8 00 cmp $0x0,%eax
c103c8bd: 77 05 ja c103c8c4 <get_next_timer_interrupt+0x18c>
return now + 1;
c103c8bf: ff 45 e0 incl -0x20(%ebp)
c103c8c2: eb 38 jmp c103c8fc <get_next_timer_interrupt+0x1c4>
tsdelta = ktime_to_timespec(hr_delta);
c103c8c4: e8 fc ff ff ff call c103c8c5 <get_next_timer_interrupt+0x18d>
c103c8c9: 89 45 e4 mov %eax,-0x1c(%ebp)
delta = timespec_to_jiffies(&tsdelta);
c103c8cc: 8d 45 e4 lea -0x1c(%ebp),%eax
* Expired timer available, let it expire in the next tick
*/
if (hr_delta.tv64 <= 0)
return now + 1;
tsdelta = ktime_to_timespec(hr_delta);
c103c8cf: 89 55 e8 mov %edx,-0x18(%ebp)
delta = timespec_to_jiffies(&tsdelta);
c103c8d2: e8 fc ff ff ff call c103c8d3 <get_next_timer_interrupt+0x19b>
/*
* Limit the delta to the max value, which is checked in
* tick_nohz_stop_sched_tick():
*/
if (delta > NEXT_TIMER_MAX_DELTA)
c103c8d7: 3d ff ff ff 3f cmp $0x3fffffff,%eax
c103c8dc: 76 07 jbe c103c8e5 <get_next_timer_interrupt+0x1ad>
c103c8de: b8 ff ff ff 3f mov $0x3fffffff,%eax
c103c8e3: eb 0a jmp c103c8ef <get_next_timer_interrupt+0x1b7>
* Take rounding errors in to account and make sure, that it
* expires in the next tick. Otherwise we go into an endless
* ping pong due to tick_nohz_stop_sched_tick() retriggering
* the timer softirq
*/
if (delta < 1)
c103c8e5: 85 c0 test %eax,%eax
c103c8e7: ba 01 00 00 00 mov $0x1,%edx
c103c8ec: 0f 44 c2 cmove %edx,%eax
delta = 1;
now += delta;
c103c8ef: 03 45 e0 add -0x20(%ebp),%eax
if (time_before(now, expires))
c103c8f2: 39 f0 cmp %esi,%eax
c103c8f4: 89 45 e0 mov %eax,-0x20(%ebp)
c103c8f7: 78 03 js c103c8fc <get_next_timer_interrupt+0x1c4>
c103c8f9: 89 75 e0 mov %esi,-0x20(%ebp)
if (time_before_eq(expires, now))
return now;
return cmp_next_hrtimer_event(now, expires);
}
c103c8fc: 8b 45 e0 mov -0x20(%ebp),%eax
c103c8ff: 83 c4 2c add $0x2c,%esp
c103c902: 5b pop %ebx
c103c903: 5e pop %esi
c103c904: 5f pop %edi
c103c905: 5d pop %ebp
c103c906: c3 ret
c103c907 <__timer_stats_timer_set_start_info>:
list_add_tail(&timer->entry, vec);
}
#ifdef CONFIG_TIMER_STATS
void __timer_stats_timer_set_start_info(struct timer_list *timer, void *addr)
{
c103c907: 55 push %ebp
if (timer->start_site)
c103c908: 83 78 20 00 cmpl $0x0,0x20(%eax)
list_add_tail(&timer->entry, vec);
}
#ifdef CONFIG_TIMER_STATS
void __timer_stats_timer_set_start_info(struct timer_list *timer, void *addr)
{
c103c90c: 89 e5 mov %esp,%ebp
c103c90e: 57 push %edi
c103c90f: 56 push %esi
c103c910: 53 push %ebx
if (timer->start_site)
c103c911: 75 25 jne c103c938 <__timer_stats_timer_set_start_info+0x31>
return;
timer->start_site = addr;
memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
c103c913: 8d 58 24 lea 0x24(%eax),%ebx
c103c916: b9 04 00 00 00 mov $0x4,%ecx
void __timer_stats_timer_set_start_info(struct timer_list *timer, void *addr)
{
if (timer->start_site)
return;
timer->start_site = addr;
c103c91b: 89 50 20 mov %edx,0x20(%eax)
memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
c103c91e: 89 df mov %ebx,%edi
c103c920: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
c103c927: 8d b2 dc 02 00 00 lea 0x2dc(%edx),%esi
c103c92d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
timer->start_pid = current->pid;
c103c92f: 8b 92 00 02 00 00 mov 0x200(%edx),%edx
c103c935: 89 50 1c mov %edx,0x1c(%eax)
}
c103c938: 5b pop %ebx
c103c939: 5e pop %esi
c103c93a: 5f pop %edi
c103c93b: 5d pop %ebp
c103c93c: c3 ret
c103c93d <timer_stats_timer_set_start_info>:
extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
void *addr);
static inline void timer_stats_timer_set_start_info(struct timer_list *timer)
{
if (likely(!timer_stats_active))
c103c93d: 83 3d 00 00 00 00 00 cmpl $0x0,0x0
extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
void *addr);
static inline void timer_stats_timer_set_start_info(struct timer_list *timer)
{
c103c944: 55 push %ebp
c103c945: 89 e5 mov %esp,%ebp
if (likely(!timer_stats_active))
c103c947: 74 08 je c103c951 <timer_stats_timer_set_start_info+0x14>
return;
__timer_stats_timer_set_start_info(timer, __builtin_return_address(0));
c103c949: 8b 55 04 mov 0x4(%ebp),%edx
c103c94c: e8 fc ff ff ff call c103c94d <timer_stats_timer_set_start_info+0x10>
}
c103c951: 5d pop %ebp
c103c952: c3 ret
c103c953 <__mod_timer>:
}
static inline int
__mod_timer(struct timer_list *timer, unsigned long expires,
bool pending_only, int pinned)
{
c103c953: 55 push %ebp
c103c954: 89 e5 mov %esp,%ebp
c103c956: 57 push %edi
c103c957: 89 d7 mov %edx,%edi
c103c959: 56 push %esi
c103c95a: 53 push %ebx
c103c95b: 89 c3 mov %eax,%ebx
c103c95d: 83 ec 10 sub $0x10,%esp
c103c960: 88 4d ec mov %cl,-0x14(%ebp)
struct tvec_base *base, *new_base;
unsigned long flags;
int ret = 0 , cpu;
timer_stats_timer_set_start_info(timer);
c103c963: e8 d5 ff ff ff call c103c93d <timer_stats_timer_set_start_info>
BUG_ON(!timer->function);
c103c968: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
c103c96c: 75 04 jne c103c972 <__mod_timer+0x1f>
c103c96e: 0f 0b ud2a
c103c970: eb fe jmp c103c970 <__mod_timer+0x1d>
base = lock_timer_base(timer, &flags);
c103c972: 8d 55 f0 lea -0x10(%ebp),%edx
c103c975: 89 d8 mov %ebx,%eax
c103c977: e8 a4 fb ff ff call c103c520 <lock_timer_base>
if (timer_pending(timer)) {
c103c97c: 83 3b 00 cmpl $0x0,(%ebx)
int ret = 0 , cpu;
timer_stats_timer_set_start_info(timer);
BUG_ON(!timer->function);
base = lock_timer_base(timer, &flags);
c103c97f: 89 c6 mov %eax,%esi
if (timer_pending(timer)) {
c103c981: 74 1f je c103c9a2 <__mod_timer+0x4f>
detach_timer(timer, 0);
c103c983: 31 d2 xor %edx,%edx
c103c985: 89 d8 mov %ebx,%eax
c103c987: e8 04 f7 ff ff call c103c090 <detach_timer>
if (timer->expires == base->next_timer &&
c103c98c: 8b 43 08 mov 0x8(%ebx),%eax
c103c98f: 3b 46 0c cmp 0xc(%esi),%eax
c103c992: 75 20 jne c103c9b4 <__mod_timer+0x61>
!tbase_get_deferrable(timer->base))
c103c994: f6 43 0c 01 testb $0x1,0xc(%ebx)
c103c998: 75 1a jne c103c9b4 <__mod_timer+0x61>
base->next_timer = base->timer_jiffies;
c103c99a: 8b 46 08 mov 0x8(%esi),%eax
c103c99d: 89 46 0c mov %eax,0xc(%esi)
c103c9a0: eb 12 jmp c103c9b4 <__mod_timer+0x61>
ret = 1;
} else {
if (pending_only)
c103c9a2: 80 7d ec 00 cmpb $0x0,-0x14(%ebp)
c103c9a6: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
c103c9ad: 74 0c je c103c9bb <__mod_timer+0x68>
c103c9af: e9 8a 00 00 00 jmp c103ca3e <__mod_timer+0xeb>
c103c9b4: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp)
goto out_unlock;
}
debug_activate(timer, expires);
c103c9bb: 89 fa mov %edi,%edx
c103c9bd: 89 d8 mov %ebx,%eax
c103c9bf: e8 6a f7 ff ff call c103c12e <debug_activate>
cpu = smp_processor_id();
c103c9c4: e8 fc ff ff ff call c103c9c5 <__mod_timer+0x72>
#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu))
c103c9c9: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
goto out_unlock;
}
debug_activate(timer, expires);
cpu = smp_processor_id();
c103c9cd: 89 c2 mov %eax,%edx
#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu))
c103c9cf: 75 16 jne c103c9e7 <__mod_timer+0x94>
c103c9d1: 89 55 e4 mov %edx,-0x1c(%ebp)
c103c9d4: e8 fc ff ff ff call c103c9d5 <__mod_timer+0x82>
c103c9d9: 8b 55 e4 mov -0x1c(%ebp),%edx
c103c9dc: 85 c0 test %eax,%eax
c103c9de: 74 07 je c103c9e7 <__mod_timer+0x94>
cpu = get_nohz_timer_target();
c103c9e0: e8 fc ff ff ff call c103c9e1 <__mod_timer+0x8e>
c103c9e5: 89 c2 mov %eax,%edx
#endif
new_base = per_cpu(tvec_bases, cpu);
c103c9e7: 8b 14 95 00 00 00 00 mov 0x0(,%edx,4),%edx
c103c9ee: b8 00 00 00 00 mov $0x0,%eax
c103c9f3: 8b 14 02 mov (%edx,%eax,1),%edx
if (base != new_base) {
c103c9f6: 39 d6 cmp %edx,%esi
#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu))
cpu = get_nohz_timer_target();
#endif
new_base = per_cpu(tvec_bases, cpu);
c103c9f8: 89 55 ec mov %edx,-0x14(%ebp)
if (base != new_base) {
c103c9fb: 74 27 je c103ca24 <__mod_timer+0xd1>
* However we can't change timer's base while it is running,
* otherwise del_timer_sync() can't detect that the timer's
* handler yet has not finished. This also guarantees that
* the timer is serialized wrt itself.
*/
if (likely(base->running_timer != timer)) {
c103c9fd: 39 5e 04 cmp %ebx,0x4(%esi)
c103ca00: 74 22 je c103ca24 <__mod_timer+0xd1>
}
static inline void
timer_set_base(struct timer_list *timer, struct tvec_base *new_base)
{
timer->base = (struct tvec_base *)((unsigned long)(new_base) |
c103ca02: 83 63 0c 01 andl $0x1,0xc(%ebx)
c103ca06: 89 f0 mov %esi,%eax
c103ca08: e8 fc ff ff ff call c103ca09 <__mod_timer+0xb6>
raw_spin_lock_init(&(_lock)->rlock); \
} while (0)
static inline void spin_lock(spinlock_t *lock)
{
raw_spin_lock(&lock->rlock);
c103ca0d: 8b 45 ec mov -0x14(%ebp),%eax
c103ca10: e8 fc ff ff ff call c103ca11 <__mod_timer+0xbe>
c103ca15: 8b 43 0c mov 0xc(%ebx),%eax
c103ca18: 8b 75 ec mov -0x14(%ebp),%esi
c103ca1b: 83 e0 01 and $0x1,%eax
c103ca1e: 0b 45 ec or -0x14(%ebp),%eax
c103ca21: 89 43 0c mov %eax,0xc(%ebx)
spin_lock(&base->lock);
timer_set_base(timer, base);
}
}
timer->expires = expires;
c103ca24: 89 7b 08 mov %edi,0x8(%ebx)
if (time_before(timer->expires, base->next_timer) &&
c103ca27: 3b 7e 0c cmp 0xc(%esi),%edi
c103ca2a: 79 09 jns c103ca35 <__mod_timer+0xe2>
!tbase_get_deferrable(timer->base))
c103ca2c: f6 43 0c 01 testb $0x1,0xc(%ebx)
c103ca30: 75 03 jne c103ca35 <__mod_timer+0xe2>
base->next_timer = timer->expires;
c103ca32: 89 7e 0c mov %edi,0xc(%esi)
internal_add_timer(base, timer);
c103ca35: 89 da mov %ebx,%edx
c103ca37: 89 f0 mov %esi,%eax
c103ca39: e8 e8 e1 ff ff call c103ac26 <internal_add_timer>
raw_spin_unlock_irq(&lock->rlock);
}
static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
{
raw_spin_unlock_irqrestore(&lock->rlock, flags);
c103ca3e: 8b 55 f0 mov -0x10(%ebp),%edx
c103ca41: 89 f0 mov %esi,%eax
c103ca43: e8 fc ff ff ff call c103ca44 <__mod_timer+0xf1>
out_unlock:
spin_unlock_irqrestore(&base->lock, flags);
return ret;
}
c103ca48: 8b 45 e8 mov -0x18(%ebp),%eax
c103ca4b: 83 c4 10 add $0x10,%esp
c103ca4e: 5b pop %ebx
c103ca4f: 5e pop %esi
c103ca50: 5f pop %edi
c103ca51: 5d pop %ebp
c103ca52: c3 ret
c103ca53 <msleep>:
/**
* msleep - sleep safely even with waitqueue interruptions
* @msecs: Time in milliseconds to sleep for
*/
void msleep(unsigned int msecs)
{
c103ca53: 55 push %ebp
c103ca54: 89 e5 mov %esp,%ebp
unsigned long timeout = msecs_to_jiffies(msecs) + 1;
c103ca56: e8 fc ff ff ff call c103ca57 <msleep+0x4>
c103ca5b: 40 inc %eax
while (timeout)
c103ca5c: eb 05 jmp c103ca63 <msleep+0x10>
timeout = schedule_timeout_uninterruptible(timeout);
c103ca5e: e8 fc ff ff ff call c103ca5f <msleep+0xc>
*/
void msleep(unsigned int msecs)
{
unsigned long timeout = msecs_to_jiffies(msecs) + 1;
while (timeout)
c103ca63: 85 c0 test %eax,%eax
c103ca65: 75 f7 jne c103ca5e <msleep+0xb>
timeout = schedule_timeout_uninterruptible(timeout);
}
c103ca67: 5d pop %ebp
c103ca68: c3 ret
c103ca69 <msleep_interruptible>:
/**
* msleep_interruptible - sleep waiting for signals
* @msecs: Time in milliseconds to sleep for
*/
unsigned long msleep_interruptible(unsigned int msecs)
{
c103ca69: 55 push %ebp
c103ca6a: 89 e5 mov %esp,%ebp
c103ca6c: 53 push %ebx
unsigned long timeout = msecs_to_jiffies(msecs) + 1;
c103ca6d: e8 fc ff ff ff call c103ca6e <msleep_interruptible+0x5>
c103ca72: 64 8b 1d 00 00 00 00 mov %fs:0x0,%ebx
c103ca79: 40 inc %eax
while (timeout && !signal_pending(current))
c103ca7a: eb 05 jmp c103ca81 <msleep_interruptible+0x18>
timeout = schedule_timeout_interruptible(timeout);
c103ca7c: e8 fc ff ff ff call c103ca7d <msleep_interruptible+0x14>
*/
unsigned long msleep_interruptible(unsigned int msecs)
{
unsigned long timeout = msecs_to_jiffies(msecs) + 1;
while (timeout && !signal_pending(current))
c103ca81: 85 c0 test %eax,%eax
c103ca83: 74 0b je c103ca90 <msleep_interruptible+0x27>
return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
}
static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
{
return test_bit(flag, (unsigned long *)&ti->flags);
c103ca85: 8b 53 04 mov 0x4(%ebx),%edx
}
static __always_inline int constant_test_bit(unsigned int nr, const volatile unsigned long *addr)
{
return ((1UL << (nr % BITS_PER_LONG)) &
(addr[nr / BITS_PER_LONG])) != 0;
c103ca88: 8b 52 08 mov 0x8(%edx),%edx
c103ca8b: 80 e2 04 and $0x4,%dl
c103ca8e: 74 ec je c103ca7c <msleep_interruptible+0x13>
timeout = schedule_timeout_interruptible(timeout);
return jiffies_to_msecs(timeout);
c103ca90: e8 fc ff ff ff call c103ca91 <msleep_interruptible+0x28>
}
c103ca95: 5b pop %ebx
c103ca96: 5d pop %ebp
c103ca97: c3 ret
c103ca98 <mod_timer_pinned>:
* mod_timer_pinned(timer, expires) is equivalent to:
*
* del_timer(timer); timer->expires = expires; add_timer(timer);
*/
int mod_timer_pinned(struct timer_list *timer, unsigned long expires)
{
c103ca98: 55 push %ebp
if (timer->expires == expires && timer_pending(timer))
c103ca99: 39 50 08 cmp %edx,0x8(%eax)
* mod_timer_pinned(timer, expires) is equivalent to:
*
* del_timer(timer); timer->expires = expires; add_timer(timer);
*/
int mod_timer_pinned(struct timer_list *timer, unsigned long expires)
{
c103ca9c: 89 e5 mov %esp,%ebp
if (timer->expires == expires && timer_pending(timer))
c103ca9e: 75 0a jne c103caaa <mod_timer_pinned+0x12>
c103caa0: 83 38 00 cmpl $0x0,(%eax)
c103caa3: b9 01 00 00 00 mov $0x1,%ecx
c103caa8: 75 0c jne c103cab6 <mod_timer_pinned+0x1e>
return 1;
return __mod_timer(timer, expires, false, TIMER_PINNED);
c103caaa: 31 c9 xor %ecx,%ecx
c103caac: 6a 01 push $0x1
c103caae: e8 a0 fe ff ff call c103c953 <__mod_timer>
c103cab3: 89 c1 mov %eax,%ecx
c103cab5: 58 pop %eax
}
c103cab6: 89 c8 mov %ecx,%eax
c103cab8: c9 leave
c103cab9: c3 ret
c103caba <mod_timer>:
* The function returns whether it has modified a pending timer or not.
* (ie. mod_timer() of an inactive timer returns 0, mod_timer() of an
* active timer returns 1.)
*/
int mod_timer(struct timer_list *timer, unsigned long expires)
{
c103caba: 55 push %ebp
c103cabb: 89 e5 mov %esp,%ebp
c103cabd: 56 push %esi
c103cabe: 53 push %ebx
c103cabf: 89 c3 mov %eax,%ebx
c103cac1: 83 ec 04 sub $0x4,%esp
/*
* This is a common optimization triggered by the
* networking code - if the timer is re-modified
* to be the same thing then just return:
*/
if (timer_pending(timer) && timer->expires == expires)
c103cac4: 83 38 00 cmpl $0x0,(%eax)
c103cac7: 74 0a je c103cad3 <mod_timer+0x19>
c103cac9: 39 53 08 cmp %edx,0x8(%ebx)
c103cacc: b8 01 00 00 00 mov $0x1,%eax
c103cad1: 74 53 je c103cb26 <mod_timer+0x6c>
unsigned long expires_limit, mask;
int bit;
expires_limit = expires;
if (timer->slack >= 0) {
c103cad3: 8b 73 18 mov 0x18(%ebx),%esi
c103cad6: 85 f6 test %esi,%esi
c103cad8: 78 05 js c103cadf <mod_timer+0x25>
expires_limit = expires + timer->slack;
c103cada: 8d 34 32 lea (%edx,%esi,1),%esi
c103cadd: eb 12 jmp c103caf1 <mod_timer+0x37>
} else {
unsigned long now = jiffies;
c103cadf: a1 00 00 00 00 mov 0x0,%eax
/* No slack, if already expired else auto slack 0.4% */
if (time_after(expires, now))
c103cae4: 89 d6 mov %edx,%esi
c103cae6: 39 d0 cmp %edx,%eax
c103cae8: 79 07 jns c103caf1 <mod_timer+0x37>
expires_limit = expires + (expires - now)/256;
c103caea: 29 c6 sub %eax,%esi
c103caec: c1 ee 08 shr $0x8,%esi
c103caef: 01 d6 add %edx,%esi
}
mask = expires ^ expires_limit;
c103caf1: 89 f0 mov %esi,%eax
c103caf3: 31 d0 xor %edx,%eax
if (mask == 0)
c103caf5: 85 c0 test %eax,%eax
/* No slack, if already expired else auto slack 0.4% */
if (time_after(expires, now))
expires_limit = expires + (expires - now)/256;
}
mask = expires ^ expires_limit;
c103caf7: 89 45 f4 mov %eax,-0xc(%ebp)
if (mask == 0)
c103cafa: 74 1e je c103cb1a <mod_timer+0x60>
return expires;
bit = find_last_bit(&mask, BITS_PER_LONG);
c103cafc: ba 20 00 00 00 mov $0x20,%edx
c103cb01: 8d 45 f4 lea -0xc(%ebp),%eax
c103cb04: e8 fc ff ff ff call c103cb05 <mod_timer+0x4b>
mask = (1 << bit) - 1;
c103cb09: ba 01 00 00 00 mov $0x1,%edx
c103cb0e: 88 c1 mov %al,%cl
c103cb10: d3 e2 shl %cl,%edx
c103cb12: 4a dec %edx
c103cb13: 89 55 f4 mov %edx,-0xc(%ebp)
expires_limit = expires_limit & ~(mask);
c103cb16: f7 d2 not %edx
c103cb18: 21 f2 and %esi,%edx
if (timer_pending(timer) && timer->expires == expires)
return 1;
expires = apply_slack(timer, expires);
return __mod_timer(timer, expires, false, TIMER_NOT_PINNED);
c103cb1a: 6a 00 push $0x0
c103cb1c: 31 c9 xor %ecx,%ecx
c103cb1e: 89 d8 mov %ebx,%eax
c103cb20: e8 2e fe ff ff call c103c953 <__mod_timer>
c103cb25: 5a pop %edx
}
c103cb26: 8d 65 f8 lea -0x8(%ebp),%esp
c103cb29: 5b pop %ebx
c103cb2a: 5e pop %esi
c103cb2b: 5d pop %ebp
c103cb2c: c3 ret
c103cb2d <add_timer>:
*
* Timers with an ->expires field in the past will be executed in the next
* timer tick.
*/
void add_timer(struct timer_list *timer)
{
c103cb2d: 55 push %ebp
BUG_ON(timer_pending(timer));
c103cb2e: 83 38 00 cmpl $0x0,(%eax)
*
* Timers with an ->expires field in the past will be executed in the next
* timer tick.
*/
void add_timer(struct timer_list *timer)
{
c103cb31: 89 e5 mov %esp,%ebp
BUG_ON(timer_pending(timer));
c103cb33: 74 04 je c103cb39 <add_timer+0xc>
c103cb35: 0f 0b ud2a
c103cb37: eb fe jmp c103cb37 <add_timer+0xa>
mod_timer(timer, timer->expires);
c103cb39: 8b 50 08 mov 0x8(%eax),%edx
c103cb3c: e8 fc ff ff ff call c103cb3d <add_timer+0x10>
}
c103cb41: 5d pop %ebp
c103cb42: c3 ret
c103cb43 <mod_timer_pending>:
* but will not re-activate and modify already deleted timers.
*
* It is useful for unserialized use of timers.
*/
int mod_timer_pending(struct timer_list *timer, unsigned long expires)
{
c103cb43: 55 push %ebp
return __mod_timer(timer, expires, true, TIMER_NOT_PINNED);
c103cb44: b9 01 00 00 00 mov $0x1,%ecx
* but will not re-activate and modify already deleted timers.
*
* It is useful for unserialized use of timers.
*/
int mod_timer_pending(struct timer_list *timer, unsigned long expires)
{
c103cb49: 89 e5 mov %esp,%ebp
return __mod_timer(timer, expires, true, TIMER_NOT_PINNED);
c103cb4b: 6a 00 push $0x0
c103cb4d: e8 01 fe ff ff call c103c953 <__mod_timer>
}
c103cb52: c9 leave
c103cb53: c3 ret
c103cb54 <add_timer_on>:
* @cpu: the CPU to start it on
*
* This is not very scalable on SMP. Double adds are not possible.
*/
void add_timer_on(struct timer_list *timer, int cpu)
{
c103cb54: 55 push %ebp
c103cb55: 89 e5 mov %esp,%ebp
c103cb57: 57 push %edi
c103cb58: 89 d7 mov %edx,%edi
c103cb5a: 56 push %esi
c103cb5b: 53 push %ebx
c103cb5c: 89 c3 mov %eax,%ebx
c103cb5e: 83 ec 04 sub $0x4,%esp
struct tvec_base *base = per_cpu(tvec_bases, cpu);
c103cb61: 8b 14 95 00 00 00 00 mov 0x0(,%edx,4),%edx
c103cb68: b8 00 00 00 00 mov $0x0,%eax
c103cb6d: 8b 34 10 mov (%eax,%edx,1),%esi
unsigned long flags;
timer_stats_timer_set_start_info(timer);
c103cb70: 89 d8 mov %ebx,%eax
c103cb72: e8 c6 fd ff ff call c103c93d <timer_stats_timer_set_start_info>
BUG_ON(timer_pending(timer) || !timer->function);
c103cb77: 83 3b 00 cmpl $0x0,(%ebx)
c103cb7a: 75 06 jne c103cb82 <add_timer_on+0x2e>
c103cb7c: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
c103cb80: 75 04 jne c103cb86 <add_timer_on+0x32>
c103cb82: 0f 0b ud2a
c103cb84: eb fe jmp c103cb84 <add_timer_on+0x30>
spin_lock_irqsave(&base->lock, flags);
c103cb86: 89 f0 mov %esi,%eax
c103cb88: e8 fc ff ff ff call c103cb89 <add_timer_on+0x35>
timer_set_base(timer, base);
debug_activate(timer, timer->expires);
c103cb8d: 8b 53 08 mov 0x8(%ebx),%edx
struct tvec_base *base = per_cpu(tvec_bases, cpu);
unsigned long flags;
timer_stats_timer_set_start_info(timer);
BUG_ON(timer_pending(timer) || !timer->function);
spin_lock_irqsave(&base->lock, flags);
c103cb90: 89 45 f0 mov %eax,-0x10(%ebp)
}
static inline void
timer_set_base(struct timer_list *timer, struct tvec_base *new_base)
{
timer->base = (struct tvec_base *)((unsigned long)(new_base) |
c103cb93: 8b 43 0c mov 0xc(%ebx),%eax
c103cb96: 83 e0 01 and $0x1,%eax
c103cb99: 09 f0 or %esi,%eax
c103cb9b: 89 43 0c mov %eax,0xc(%ebx)
timer_stats_timer_set_start_info(timer);
BUG_ON(timer_pending(timer) || !timer->function);
spin_lock_irqsave(&base->lock, flags);
timer_set_base(timer, base);
debug_activate(timer, timer->expires);
c103cb9e: 89 d8 mov %ebx,%eax
c103cba0: e8 89 f5 ff ff call c103c12e <debug_activate>
if (time_before(timer->expires, base->next_timer) &&
c103cba5: 8b 43 08 mov 0x8(%ebx),%eax
c103cba8: 3b 46 0c cmp 0xc(%esi),%eax
c103cbab: 79 09 jns c103cbb6 <add_timer_on+0x62>
!tbase_get_deferrable(timer->base))
c103cbad: f6 43 0c 01 testb $0x1,0xc(%ebx)
c103cbb1: 75 03 jne c103cbb6 <add_timer_on+0x62>
base->next_timer = timer->expires;
c103cbb3: 89 46 0c mov %eax,0xc(%esi)
internal_add_timer(base, timer);
c103cbb6: 89 da mov %ebx,%edx
c103cbb8: 89 f0 mov %esi,%eax
c103cbba: e8 67 e0 ff ff call c103ac26 <internal_add_timer>
* active. We are protected against the other CPU fiddling
* with the timer by holding the timer base lock. This also
* makes sure that a CPU on the way to idle can not evaluate
* the timer wheel.
*/
wake_up_idle_cpu(cpu);
c103cbbf: 89 f8 mov %edi,%eax
c103cbc1: e8 fc ff ff ff call c103cbc2 <add_timer_on+0x6e>
c103cbc6: 8b 55 f0 mov -0x10(%ebp),%edx
c103cbc9: 89 f0 mov %esi,%eax
c103cbcb: e8 fc ff ff ff call c103cbcc <add_timer_on+0x78>
spin_unlock_irqrestore(&base->lock, flags);
}
c103cbd0: 59 pop %ecx
c103cbd1: 5b pop %ebx
c103cbd2: 5e pop %esi
c103cbd3: 5f pop %edi
c103cbd4: 5d pop %ebp
c103cbd5: c3 ret
Disassembly of section .cpuinit.text:
c103ab38 <timer_cpu_notify>:
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab38: 55 push %ebp
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab39: 83 fa 07 cmp $0x7,%edx
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
rem = j % HZ;
c103ab3c: 89 e5 mov %esp,%ebp
c103ab3e: 57 push %edi
c103ab3f: 56 push %esi
c103ab40: 53 push %ebx
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab41: 89 cb mov %ecx,%ebx
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab43: 0f 84 49 01 00 00 je c103ac92 <timer_cpu_notify+0x15a>
* in the caller. Nothing more. We could take
* MAX_SCHEDULE_TIMEOUT from one of the negative value
* but I' d like to return a valid offset (>=0) to allow
* the caller to do everything it want with the retval.
*/
schedule();
c103ab49: 77 0b ja c103ab56 <timer_cpu_notify+0x1e>
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab4b: 83 fa 03 cmp $0x3,%edx
* MAX_SCHEDULE_TIMEOUT from one of the negative value
* but I' d like to return a valid offset (>=0) to allow
* the caller to do everything it want with the retval.
*/
schedule();
goto out;
c103ab4e: 0f 85 12 02 00 00 jne c103ad66 <timer_cpu_notify+0x22e>
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
rem = j % HZ;
c103ab54: eb 13 jmp c103ab69 <timer_cpu_notify+0x31>
c103ab56: 83 fa 13 cmp $0x13,%edx
int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,
(void *)(long)smp_processor_id());
init_timer_stats();
BUG_ON(err != NOTIFY_OK);
c103ab59: 74 0e je c103ab69 <timer_cpu_notify+0x31>
c103ab5b: 83 fa 17 cmp $0x17,%edx
c103ab5e: 0f 85 02 02 00 00 jne c103ad66 <timer_cpu_notify+0x22e>
c103ab64: e9 29 01 00 00 jmp c103ac92 <timer_cpu_notify+0x15a>
{
int j;
struct tvec_base *base;
static char __cpuinitdata tvec_base_done[NR_CPUS];
if (!tvec_base_done[cpu]) {
c103ab69: 80 bb 0c 00 00 00 00 cmpb $0x0,0xc(%ebx)
if (timeout < 0) {
printk(KERN_ERR "schedule_timeout: wrong timeout "
"value %lx\n", timeout);
dump_stack();
current->state = TASK_RUNNING;
goto out;
c103ab70: 0f 85 85 00 00 00 jne c103abfb <timer_cpu_notify+0xc3>
j -= cpu * 3;
if (j <= jiffies) /* rounding ate our timeout entirely; */
return original;
return j;
}
c103ab76: 80 3d 49 10 00 00 00 cmpb $0x0,0x1049
c103ab7d: 74 67 je c103abe6 <timer_cpu_notify+0xae>
int index = kmalloc_index(size);
if (index == 0)
return NULL;
return kmalloc_caches[index];
c103ab7f: a1 34 00 00 00 mov 0x34,%eax
return kmalloc_large(size, flags);
if (!(flags & SLUB_DMA)) {
struct kmem_cache *s = kmalloc_slab(size);
if (!s)
c103ab84: be 10 00 00 00 mov $0x10,%esi
c103ab89: 85 c0 test %eax,%eax
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies(unsigned long j, int cpu)
{
return round_jiffies_common(j, cpu, false);
c103ab8b: 74 11 je c103ab9e <timer_cpu_notify+0x66>
return ZERO_SIZE_PTR;
return kmem_cache_alloc_trace(s, flags, size);
c103ab8d: b9 40 10 00 00 mov $0x1040,%ecx
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
c103ab92: ba d0 80 00 00 mov $0x80d0,%edx
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
unsigned long j0 = jiffies;
c103ab97: e8 fc ff ff ff call c103ab98 <timer_cpu_notify+0x60>
}
expire = timeout + jiffies;
setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
c103ab9c: 89 c6 mov %eax,%esi
* The APs use this path later in boot
*/
base = kmalloc_node(sizeof(*base),
GFP_KERNEL | __GFP_ZERO,
cpu_to_node(cpu));
if (!base)
c103ab9e: 85 f6 test %esi,%esi
if (boot_done) {
/*
* The APs use this path later in boot
*/
base = kmalloc_node(sizeof(*base),
c103aba0: 89 f2 mov %esi,%edx
GFP_KERNEL | __GFP_ZERO,
cpu_to_node(cpu));
if (!base)
c103aba2: b8 0d 80 00 00 mov $0x800d,%eax
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
}
c103aba7: 0f 84 be 01 00 00 je c103ad6b <timer_cpu_notify+0x233>
cpu_to_node(cpu));
if (!base)
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
c103abad: f7 c6 01 00 00 00 test $0x1,%esi
del_singleshot_timer_sync(&timer);
/* Remove the timer from the object tracker */
destroy_timer_on_stack(&timer);
timeout = expire - jiffies;
c103abb3: 74 20 je c103abd5 <timer_cpu_notify+0x9d>
if (!base)
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
WARN_ON(1);
c103abb5: ba 51 06 00 00 mov $0x651,%edx
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies(unsigned long j)
{
return round_jiffies_common(j, raw_smp_processor_id(), false);
}
c103abba: b8 00 00 00 00 mov $0x0,%eax
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies_relative(unsigned long j)
{
return __round_jiffies_relative(j, raw_smp_processor_id());
c103abbf: e8 fc ff ff ff call c103abc0 <timer_cpu_notify+0x88>
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
WARN_ON(1);
kfree(base);
c103abc4: 89 f0 mov %esi,%eax
c103abc6: e8 fc ff ff ff call c103abc7 <timer_cpu_notify+0x8f>
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies_relative(unsigned long j)
{
return __round_jiffies_relative(j, raw_smp_processor_id());
}
c103abcb: b8 0d 80 00 00 mov $0x800d,%eax
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up(unsigned long j, int cpu)
{
return round_jiffies_common(j, cpu, true);
c103abd0: e9 96 01 00 00 jmp c103ad6b <timer_cpu_notify+0x233>
c103abd5: 8b 0c 9d 00 00 00 00 mov 0x0(,%ebx,4),%ecx
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
c103abdc: b8 00 00 00 00 mov $0x0,%eax
return schedule_timeout(timeout);
}
EXPORT_SYMBOL(schedule_timeout_interruptible);
signed long __sched schedule_timeout_killable(signed long timeout)
{
c103abe1: 89 34 08 mov %esi,(%eax,%ecx,1)
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
c103abe4: eb 0c jmp c103abf2 <timer_cpu_notify+0xba>
* This is for the boot CPU - we use compile-time
* static initialisation because per-cpu memory isn't
* ready yet and because the memory allocators are not
* initialised either.
*/
boot_done = 1;
c103abe6: c6 05 49 10 00 00 01 movb $0x1,0x1049
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, true) - j0;
c103abed: ba 00 00 00 00 mov $0x0,%edx
* initialised either.
*/
boot_done = 1;
base = &boot_tvec_bases;
}
tvec_base_done[cpu] = 1;
c103abf2: c6 83 0c 00 00 00 01 movb $0x1,0xc(%ebx)
c103abf9: eb 0f jmp c103ac0a <timer_cpu_notify+0xd2>
} else {
base = per_cpu(tvec_bases, cpu);
c103abfb: 8b 14 9d 00 00 00 00 mov 0x0(,%ebx,4),%edx
* We can use __set_current_state() here because schedule_timeout() calls
* schedule() unconditionally.
*/
signed long __sched schedule_timeout_interruptible(signed long timeout)
{
__set_current_state(TASK_INTERRUPTIBLE);
c103ac02: b8 00 00 00 00 mov $0x0,%eax
return schedule_timeout(timeout);
c103ac07: 8b 14 10 mov (%eax,%edx,1),%edx
tvec_base_done[cpu] = 1;
} else {
base = per_cpu(tvec_bases, cpu);
}
spin_lock_init(&base->lock);
c103ac0a: c7 02 00 00 00 00 movl $0x0,(%edx)
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long round_jiffies_up_relative(unsigned long j)
{
return __round_jiffies_up_relative(j, raw_smp_processor_id());
c103ac10: 31 c0 xor %eax,%eax
}
spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
INIT_LIST_HEAD(base->tv5.vec + j);
c103ac12: 8d 8c c2 10 0e 00 00 lea 0xe10(%edx,%eax,8),%ecx
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ac19: 89 8c c2 10 0e 00 00 mov %ecx,0xe10(%edx,%eax,8)
list->prev = list;
c103ac20: 89 8c c2 14 0e 00 00 mov %ecx,0xe14(%edx,%eax,8)
}
EXPORT_SYMBOL_GPL(set_timer_slack);
static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
{
unsigned long expires = timer->expires;
c103ac27: 8d 8c c2 10 0c 00 00 lea 0xc10(%edx,%eax,8),%ecx
unsigned long idx = expires - base->timer_jiffies;
c103ac2e: 89 8c c2 10 0c 00 00 mov %ecx,0xc10(%edx,%eax,8)
struct list_head *vec;
if (idx < TVR_SIZE) {
c103ac35: 89 8c c2 14 0c 00 00 mov %ecx,0xc14(%edx,%eax,8)
spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
INIT_LIST_HEAD(base->tv5.vec + j);
INIT_LIST_HEAD(base->tv4.vec + j);
INIT_LIST_HEAD(base->tv3.vec + j);
c103ac3c: 8d 8c c2 10 0a 00 00 lea 0xa10(%edx,%eax,8),%ecx
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ac43: 89 8c c2 10 0a 00 00 mov %ecx,0xa10(%edx,%eax,8)
list->prev = list;
c103ac4a: 89 8c c2 14 0a 00 00 mov %ecx,0xa14(%edx,%eax,8)
if (idx < TVR_SIZE) {
int i = expires & TVR_MASK;
vec = base->tv1.vec + i;
} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
int i = (expires >> TVR_BITS) & TVN_MASK;
vec = base->tv2.vec + i;
c103ac51: 8d 8c c2 10 08 00 00 lea 0x810(%edx,%eax,8),%ecx
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ac58: 89 8c c2 10 08 00 00 mov %ecx,0x810(%edx,%eax,8)
list->prev = list;
c103ac5f: 89 8c c2 14 08 00 00 mov %ecx,0x814(%edx,%eax,8)
base = per_cpu(tvec_bases, cpu);
}
spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
c103ac66: 40 inc %eax
c103ac67: 83 f8 40 cmp $0x40,%eax
} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
int i = (expires >> TVR_BITS) & TVN_MASK;
vec = base->tv2.vec + i;
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
c103ac6a: 75 a6 jne c103ac12 <timer_cpu_notify+0xda>
c103ac6c: 30 c0 xor %al,%al
INIT_LIST_HEAD(base->tv4.vec + j);
INIT_LIST_HEAD(base->tv3.vec + j);
INIT_LIST_HEAD(base->tv2.vec + j);
}
for (j = 0; j < TVR_SIZE; j++)
INIT_LIST_HEAD(base->tv1.vec + j);
c103ac6e: 8d 4c c2 10 lea 0x10(%edx,%eax,8),%ecx
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ac72: 89 4c c2 10 mov %ecx,0x10(%edx,%eax,8)
list->prev = list;
c103ac76: 89 4c c2 14 mov %ecx,0x14(%edx,%eax,8)
INIT_LIST_HEAD(base->tv5.vec + j);
INIT_LIST_HEAD(base->tv4.vec + j);
INIT_LIST_HEAD(base->tv3.vec + j);
INIT_LIST_HEAD(base->tv2.vec + j);
}
for (j = 0; j < TVR_SIZE; j++)
c103ac7a: 40 inc %eax
c103ac7b: 3d 00 01 00 00 cmp $0x100,%eax
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
vec = base->tv4.vec + i;
c103ac80: 75 ec jne c103ac6e <timer_cpu_notify+0x136>
INIT_LIST_HEAD(base->tv2.vec + j);
}
for (j = 0; j < TVR_SIZE; j++)
INIT_LIST_HEAD(base->tv1.vec + j);
base->timer_jiffies = jiffies;
c103ac82: a1 00 00 00 00 mov 0x0,%eax
c103ac87: 89 42 08 mov %eax,0x8(%edx)
base->next_timer = base->timer_jiffies;
c103ac8a: 89 42 0c mov %eax,0xc(%edx)
c103ac8d: e9 d4 00 00 00 jmp c103ad66 <timer_cpu_notify+0x22e>
} else if ((signed long) idx < 0) {
/*
* Can happen if you add a timer with expires == jiffies,
* or you set a timer to go off in the past
*/
vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
c103ac92: a1 00 00 00 00 mov 0x0,%eax
c103ac97: 0f a3 18 bt %ebx,(%eax)
c103ac9a: 19 c0 sbb %eax,%eax
{
struct tvec_base *old_base;
struct tvec_base *new_base;
int i;
BUG_ON(cpu_online(cpu));
c103ac9c: 85 c0 test %eax,%eax
if (idx > 0xffffffffUL) {
idx = 0xffffffffUL;
expires = idx + base->timer_jiffies;
}
i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
vec = base->tv5.vec + i;
c103ac9e: 74 04 je c103aca4 <timer_cpu_notify+0x16c>
c103aca0: 0f 0b ud2a
c103aca2: eb fe jmp c103aca2 <timer_cpu_notify+0x16a>
struct tvec_base *old_base;
struct tvec_base *new_base;
int i;
BUG_ON(cpu_online(cpu));
old_base = per_cpu(tvec_bases, cpu);
c103aca4: 8b 04 9d 00 00 00 00 mov 0x0(,%ebx,4),%eax
#ifndef CONFIG_DEBUG_LIST
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
next->prev = new;
c103acab: be 00 00 00 00 mov $0x0,%esi
new->next = next;
new->prev = prev;
c103acb0: 8b 1c 06 mov (%esi,%eax,1),%ebx
prev->next = new;
c103acb3: b8 01 00 00 00 mov $0x1,%eax
}
/*
* Timers are FIFO:
*/
list_add_tail(&timer->entry, vec);
}
c103acb8: e8 fc ff ff ff call c103acb9 <timer_cpu_notify+0x181>
c103acbd: e8 fc ff ff ff call c103acbe <timer_cpu_notify+0x186>
c103acc2: 8b 04 85 00 00 00 00 mov 0x0(,%eax,4),%eax
c103acc9: 8b 3c 30 mov (%eax,%esi,1),%edi
SYSCALL_DEFINE0(getuid)
{
/* Only we change this so SMP safe */
return current_uid();
}
c103accc: 31 f6 xor %esi,%esi
c103acce: 89 f8 mov %edi,%eax
c103acd0: e8 fc ff ff ff call c103acd1 <timer_cpu_notify+0x199>
/*
* The caller is globally serialized and nobody else
* takes two locks at once, deadlock is not possible.
*/
spin_lock_irq(&new_base->lock);
spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
c103acd5: 89 d8 mov %ebx,%eax
c103acd7: e8 fc ff ff ff call c103acd8 <timer_cpu_notify+0x1a0>
SYSCALL_DEFINE0(geteuid)
{
/* Only we change this so SMP safe */
return current_euid();
}
c103acdc: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
c103ace0: 74 04 je c103ace6 <timer_cpu_notify+0x1ae>
c103ace2: 0f 0b ud2a
c103ace4: eb fe jmp c103ace4 <timer_cpu_notify+0x1ac>
spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
BUG_ON(old_base->running_timer);
for (i = 0; i < TVR_SIZE; i++)
migrate_timer_list(new_base, old_base->tv1.vec + i);
c103ace6: 8d 54 f3 10 lea 0x10(%ebx,%esi,8),%edx
c103acea: 89 f8 mov %edi,%eax
spin_lock_irq(&new_base->lock);
spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
BUG_ON(old_base->running_timer);
for (i = 0; i < TVR_SIZE; i++)
c103acec: 46 inc %esi
migrate_timer_list(new_base, old_base->tv1.vec + i);
c103aced: e8 af 15 00 00 call c103c2a1 <run_timer_softirq+0x89>
spin_lock_irq(&new_base->lock);
spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
BUG_ON(old_base->running_timer);
for (i = 0; i < TVR_SIZE; i++)
c103acf2: 81 fe 00 01 00 00 cmp $0x100,%esi
c103acf8: 75 ec jne c103ace6 <timer_cpu_notify+0x1ae>
c103acfa: 66 31 f6 xor %si,%si
migrate_timer_list(new_base, old_base->tv1.vec + i);
for (i = 0; i < TVN_SIZE; i++) {
migrate_timer_list(new_base, old_base->tv2.vec + i);
c103acfd: 8d 94 f3 10 08 00 00 lea 0x810(%ebx,%esi,8),%edx
SYSCALL_DEFINE0(getegid)
{
/* Only we change this so SMP safe */
return current_egid();
}
c103ad04: 89 f8 mov %edi,%eax
c103ad06: e8 af 15 00 00 call c103c2ba <run_timer_softirq+0xa2>
for (i = 0; i < TVR_SIZE; i++)
migrate_timer_list(new_base, old_base->tv1.vec + i);
for (i = 0; i < TVN_SIZE; i++) {
migrate_timer_list(new_base, old_base->tv2.vec + i);
migrate_timer_list(new_base, old_base->tv3.vec + i);
c103ad0b: 8d 94 f3 10 0a 00 00 lea 0xa10(%ebx,%esi,8),%edx
c103ad12: 89 f8 mov %edi,%eax
c103ad14: e8 af 15 00 00 call c103c2c8 <run_timer_softirq+0xb0>
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
new->next->prev = new;
c103ad19: 8d 94 f3 10 0c 00 00 lea 0xc10(%ebx,%esi,8),%edx
* If @old was empty, it will be overwritten.
*/
static inline void list_replace(struct list_head *old,
struct list_head *new)
{
new->next = old->next;
c103ad20: 89 f8 mov %edi,%eax
new->next->prev = new;
c103ad22: e8 af 15 00 00 call c103c2d6 <run_timer_softirq+0xbe>
migrate_timer_list(new_base, old_base->tv4.vec + i);
migrate_timer_list(new_base, old_base->tv5.vec + i);
c103ad27: 8d 94 f3 10 0e 00 00 lea 0xe10(%ebx,%esi,8),%edx
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
c103ad2e: 89 f8 mov %edi,%eax
BUG_ON(old_base->running_timer);
for (i = 0; i < TVR_SIZE; i++)
migrate_timer_list(new_base, old_base->tv1.vec + i);
for (i = 0; i < TVN_SIZE; i++) {
c103ad30: 46 inc %esi
list->prev = list;
c103ad31: e8 af 15 00 00 call c103c2e5 <run_timer_softirq+0xcd>
c103ad36: 83 fe 40 cmp $0x40,%esi
c103ad39: 75 c2 jne c103acfd <timer_cpu_notify+0x1c5>
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
c103ad3b: 89 d8 mov %ebx,%eax
c103ad3d: e8 fc ff ff ff call c103ad3e <timer_cpu_notify+0x206>
raw_spin_unlock_bh(&lock->rlock);
}
static inline void spin_unlock_irq(spinlock_t *lock)
{
raw_spin_unlock_irq(&lock->rlock);
c103ad42: 89 f8 mov %edi,%eax
c103ad44: e8 fc ff ff ff call c103ad45 <timer_cpu_notify+0x20d>
migrate_timer_list(new_base, old_base->tv5.vec + i);
}
spin_unlock(&old_base->lock);
spin_unlock_irq(&new_base->lock);
put_cpu_var(tvec_bases);
c103ad49: b8 01 00 00 00 mov $0x1,%eax
* We are removing _all_ timers from the list, so we
* don't have to detach them individually.
*/
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
BUG_ON(tbase_get_base(timer->base) != base);
internal_add_timer(base, timer);
c103ad4e: e8 fc ff ff ff call c103ad4f <timer_cpu_notify+0x217>
c103ad53: 89 e0 mov %esp,%eax
/*
* We are removing _all_ timers from the list, so we
* don't have to detach them individually.
*/
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
c103ad55: 25 00 e0 ff ff and $0xffffe000,%eax
c103ad5a: 8b 40 08 mov 0x8(%eax),%eax
BUG_ON(tbase_get_base(timer->base) != base);
internal_add_timer(base, timer);
}
return index;
}
c103ad5d: a8 08 test $0x8,%al
c103ad5f: 74 05 je c103ad66 <timer_cpu_notify+0x22e>
c103ad61: e8 fc ff ff ff call c103ad62 <timer_cpu_notify+0x22a>
c103ad66: b8 01 00 00 00 mov $0x1,%eax
#endif
default:
break;
}
return NOTIFY_OK;
}
c103ad6b: 5b pop %ebx
c103ad6c: 5e pop %esi
c103ad6d: 5f pop %edi
c103ad6e: 5d pop %ebp
/**
* timer_start - called when the timer is started
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
TRACE_EVENT(timer_start,
c103ad6f: c3 ret
Disassembly of section .init.text:
c103ab38 <init_timers>:
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab38: 55 push %ebp
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab39: 89 e5 mov %esp,%ebp
* It's not worth to care about 3dnow prefetches for the K6
* because they are microcoded there and very slow.
*/
static inline void prefetch(const void *x)
{
alternative_input(BASE_PREFETCH,
c103ab3b: 53 push %ebx
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
rem = j % HZ;
c103ab3c: e8 fc ff ff ff call c103ab3d <init_timers+0x5>
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab41: ba 03 00 00 00 mov $0x3,%edx
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab46: 89 c1 mov %eax,%ecx
c103ab48: b8 00 00 00 00 mov $0x0,%eax
* 3 jiffies. This 3 jiffies came originally from the mm/ code which
* already did this.
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
c103ab4d: e8 fc ff ff ff call c103ab4e <init_timers+0x16>
c103ab52: 89 c3 mov %eax,%ebx
rem = j % HZ;
c103ab54: e8 fc ff ff ff call c103ab55 <init_timers+0x1d>
int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,
(void *)(long)smp_processor_id());
init_timer_stats();
BUG_ON(err != NOTIFY_OK);
c103ab59: 4b dec %ebx
c103ab5a: 74 04 je c103ab60 <init_timers+0x28>
c103ab5c: 0f 0b ud2a
c103ab5e: eb fe jmp c103ab5e <init_timers+0x26>
register_cpu_notifier(&timers_nb);
c103ab60: b8 00 00 00 00 mov $0x0,%eax
c103ab65: e8 fc ff ff ff call c103ab66 <init_timers+0x2e>
open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
c103ab6a: ba e0 16 00 00 mov $0x16e0,%edx
j = j - rem + HZ;
/* now that we have rounded, subtract the extra skew again */
j -= cpu * 3;
if (j <= jiffies) /* rounding ate our timeout entirely; */
c103ab6f: b8 01 00 00 00 mov $0x1,%eax
* But never round down if @force_up is set.
*/
if (rem < HZ/4 && !force_up) /* round down */
j = j - rem;
else /* round up */
j = j - rem + HZ;
c103ab74: e8 fc ff ff ff call c103ab75 <init_timers+0x3d>
/* now that we have rounded, subtract the extra skew again */
j -= cpu * 3;
if (j <= jiffies) /* rounding ate our timeout entirely; */
c103ab79: 5b pop %ebx
c103ab7a: 5d pop %ebp
c103ab7b: c3 ret
Disassembly of section .altinstr_replacement:
c103ab38 <.altinstr_replacement>:
tbase_get_deferrable(timer->base));
}
static unsigned long round_jiffies_common(unsigned long j, int cpu,
bool force_up)
{
c103ab38: 0f 18 07 prefetchnta (%edi)
c103ab3b: 0f 18 06 prefetchnta (%esi)
Disassembly of section .sched.text:
c103ab38 <schedule_timeout>:
c103ab38: 55 push %ebp
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab39: 89 e5 mov %esp,%ebp
c103ab3b: 56 push %esi
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
rem = j % HZ;
c103ab3c: 89 c6 mov %eax,%esi
c103ab3e: 53 push %ebx
c103ab3f: 83 ec 34 sub $0x34,%esp
signed long __sched schedule_timeout(signed long timeout)
{
struct timer_list timer;
unsigned long expire;
switch (timeout)
c103ab42: 3d ff ff ff 7f cmp $0x7fffffff,%eax
unsigned long action, void *hcpu)
{
long cpu = (long)hcpu;
int err;
switch(action) {
c103ab47: 75 07 jne c103ab50 <schedule_timeout+0x18>
* in the caller. Nothing more. We could take
* MAX_SCHEDULE_TIMEOUT from one of the negative value
* but I' d like to return a valid offset (>=0) to allow
* the caller to do everything it want with the retval.
*/
schedule();
c103ab49: e8 fc ff ff ff call c103ab4a <schedule_timeout+0x12>
goto out;
c103ab4e: eb 6a jmp c103abba <schedule_timeout+0x82>
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
rem = j % HZ;
c103ab50: 85 c0 test %eax,%eax
* 3 jiffies. This 3 jiffies came originally from the mm/ code which
* already did this.
* The skew is done by adding 3*cpunr, then round, then subtract this
* extra offset again.
*/
j += cpu * 3;
c103ab52: 79 20 jns c103ab74 <schedule_timeout+0x3c>
rem = j % HZ;
c103ab54: 50 push %eax
c103ab55: 68 91 02 00 00 push $0x291
int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,
(void *)(long)smp_processor_id());
init_timer_stats();
BUG_ON(err != NOTIFY_OK);
c103ab5a: e8 fc ff ff ff call c103ab5b <schedule_timeout+0x23>
* that will tell you if something is gone wrong and where.
*/
if (timeout < 0) {
printk(KERN_ERR "schedule_timeout: wrong timeout "
"value %lx\n", timeout);
dump_stack();
c103ab5f: e8 fc ff ff ff call c103ab60 <schedule_timeout+0x28>
c103ab64: 64 a1 00 00 00 00 mov %fs:0x0,%eax
init_timer_stats();
BUG_ON(err != NOTIFY_OK);
register_cpu_notifier(&timers_nb);
open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
c103ab6a: c7 00 00 00 00 00 movl $0x0,(%eax)
if (timeout < 0) {
printk(KERN_ERR "schedule_timeout: wrong timeout "
"value %lx\n", timeout);
dump_stack();
current->state = TASK_RUNNING;
goto out;
c103ab70: 5a pop %edx
c103ab71: 59 pop %ecx
c103ab72: eb 46 jmp c103abba <schedule_timeout+0x82>
* But never round down if @force_up is set.
*/
if (rem < HZ/4 && !force_up) /* round down */
j = j - rem;
else /* round up */
j = j - rem + HZ;
c103ab74: a1 00 00 00 00 mov 0x0,%eax
/* now that we have rounded, subtract the extra skew again */
j -= cpu * 3;
if (j <= jiffies) /* rounding ate our timeout entirely; */
c103ab79: 8d 5d c4 lea -0x3c(%ebp),%ebx
c103ab7c: 31 c9 xor %ecx,%ecx
c103ab7e: 31 d2 xor %edx,%edx
return original;
return j;
}
c103ab80: c7 45 d4 2c 1b 00 00 movl $0x1b2c,-0x2c(%ebp)
current->state = TASK_RUNNING;
goto out;
}
}
expire = timeout + jiffies;
c103ab87: 01 c6 add %eax,%esi
c103ab89: 64 a1 00 00 00 00 mov %fs:0x0,%eax
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies(unsigned long j, int cpu)
{
return round_jiffies_common(j, cpu, false);
}
c103ab8f: 89 45 d8 mov %eax,-0x28(%ebp)
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
c103ab92: 89 d8 mov %ebx,%eax
* to lock contention or spurious cache line bouncing.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
c103ab94: e8 fc ff ff ff call c103ab95 <schedule_timeout+0x5d>
}
expire = timeout + jiffies;
setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
c103ab99: 89 f2 mov %esi,%edx
c103ab9b: 31 c9 xor %ecx,%ecx
unsigned long __round_jiffies_relative(unsigned long j, int cpu)
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
c103ab9d: 89 d8 mov %ebx,%eax
* The APs use this path later in boot
*/
base = kmalloc_node(sizeof(*base),
GFP_KERNEL | __GFP_ZERO,
cpu_to_node(cpu));
if (!base)
c103ab9f: 6a 00 push $0x0
if (boot_done) {
/*
* The APs use this path later in boot
*/
base = kmalloc_node(sizeof(*base),
c103aba1: e8 17 1e 00 00 call c103c9bd <__mod_timer+0x6a>
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, false) - j0;
}
c103aba6: e8 fc ff ff ff call c103aba7 <schedule_timeout+0x6f>
expire = timeout + jiffies;
setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
schedule();
del_singleshot_timer_sync(&timer);
c103abab: 89 d8 mov %ebx,%eax
cpu_to_node(cpu));
if (!base)
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
c103abad: e8 fc ff ff ff call c103abae <schedule_timeout+0x76>
del_singleshot_timer_sync(&timer);
/* Remove the timer from the object tracker */
destroy_timer_on_stack(&timer);
timeout = expire - jiffies;
c103abb2: a1 00 00 00 00 mov 0x0,%eax
if (!base)
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
WARN_ON(1);
c103abb7: 29 c6 sub %eax,%esi
c103abb9: 58 pop %eax
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies(unsigned long j)
{
return round_jiffies_common(j, raw_smp_processor_id(), false);
}
c103abba: 31 c0 xor %eax,%eax
* of this is to have the CPU wake up less, which saves power.
*
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies_relative(unsigned long j)
{
c103abbc: 85 f6 test %esi,%esi
c103abbe: 0f 49 c6 cmovns %esi,%eax
timeout = expire - jiffies;
out:
return timeout < 0 ? 0 : timeout;
}
c103abc1: 8d 65 f8 lea -0x8(%ebp),%esp
return -ENOMEM;
/* Make sure that tvec_base is 2 byte aligned */
if (tbase_get_deferrable(base)) {
WARN_ON(1);
kfree(base);
c103abc4: 5b pop %ebx
c103abc5: 5e pop %esi
c103abc6: 5d pop %ebp
c103abc7: c3 ret
c103abc8 <schedule_timeout_uninterruptible>:
return schedule_timeout(timeout);
}
EXPORT_SYMBOL(schedule_timeout_killable);
signed long __sched schedule_timeout_uninterruptible(signed long timeout)
{
c103abc8: 55 push %ebp
c103abc9: 89 e5 mov %esp,%ebp
* The return value is the rounded version of the @j parameter.
*/
unsigned long round_jiffies_relative(unsigned long j)
{
return __round_jiffies_relative(j, raw_smp_processor_id());
}
c103abcb: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
}
EXPORT_SYMBOL(schedule_timeout_killable);
signed long __sched schedule_timeout_uninterruptible(signed long timeout)
{
__set_current_state(TASK_UNINTERRUPTIBLE);
c103abd2: c7 02 02 00 00 00 movl $0x2,(%edx)
return schedule_timeout(timeout);
c103abd8: e8 fc ff ff ff call c103abd9 <schedule_timeout_uninterruptible+0x11>
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, true) - j0;
c103abdd: 5d pop %ebp
c103abde: c3 ret
c103abdf <schedule_timeout_killable>:
return schedule_timeout(timeout);
}
EXPORT_SYMBOL(schedule_timeout_interruptible);
signed long __sched schedule_timeout_killable(signed long timeout)
{
c103abdf: 55 push %ebp
c103abe0: 89 e5 mov %esp,%ebp
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
{
c103abe2: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
}
EXPORT_SYMBOL(schedule_timeout_interruptible);
signed long __sched schedule_timeout_killable(signed long timeout)
{
__set_current_state(TASK_KILLABLE);
c103abe9: c7 02 82 00 00 00 movl $0x82,(%edx)
return schedule_timeout(timeout);
c103abef: e8 fc ff ff ff call c103abf0 <schedule_timeout_killable+0x11>
{
unsigned long j0 = jiffies;
/* Use j0 because jiffies might change while we run */
return round_jiffies_common(j + j0, cpu, true) - j0;
}
c103abf4: 5d pop %ebp
c103abf5: c3 ret
c103abf6 <schedule_timeout_interruptible>:
/*
* We can use __set_current_state() here because schedule_timeout() calls
* schedule() unconditionally.
*/
signed long __sched schedule_timeout_interruptible(signed long timeout)
{
c103abf6: 55 push %ebp
* round down. This is useful for timeouts for which the exact time
* of firing does not matter too much, as long as they don't fire too
* early.
*/
unsigned long round_jiffies_up(unsigned long j)
{
c103abf7: 89 e5 mov %esp,%ebp
c103abf9: 64 8b 15 00 00 00 00 mov %fs:0x0,%edx
* We can use __set_current_state() here because schedule_timeout() calls
* schedule() unconditionally.
*/
signed long __sched schedule_timeout_interruptible(signed long timeout)
{
__set_current_state(TASK_INTERRUPTIBLE);
c103ac00: c7 02 01 00 00 00 movl $0x1,(%edx)
return schedule_timeout(timeout);
c103ac06: e8 fc ff ff ff call c103ac07 <schedule_timeout_interruptible+0x11>
* early.
*/
unsigned long round_jiffies_up(unsigned long j)
{
return round_jiffies_common(j, raw_smp_processor_id(), true);
}
c103ac0b: 5d pop %ebp
c103ac0c: c3 ret
記錄分析oops所在static函數__next_timer_interrupt的彙編如下：
77e: movzbl %al, %ecx
781: mov %ecx, %esi
783: lea 0x10(%ebx, %esi, 8), %edi
787: mov 0x10(%ebx, %esi, 8), %edx
78b: %edi, -0x24(%ebp)
78e: jmp 0x7b0
= =b> %esi指timer_jiffies & 0xff; 0x10指tvec_base到tv1的偏移量;
lea後%edi為tv1.vec[%esi]的地址, struct *list_head類型;
mov後%edx為該地址所存儲數字的值, 對應list_head->next，下一鏈表的首地址;
790: testb $0x1, 0xc(%edx)
794: je 0x79a
= =b> %edx指nte，如果(nte->base & 1) == 0，跳到0x79a，表示got not deferrable
796: mov %edi, %edx
798: jmp 0x7b0
= =b> %edi為prefetch了的鏈表頭，為struct *list_head類型，下一遍歷經過的鏈表頭
79a: cmp %ecx, %esi
79c: mov 0x8(%edx), %edx
79f: jl 0x7a9
= =b> %ecx指index，%esi指slot，如果slot比index小則跳到0x7a9; 0x8(%edx)指nte->expires
7a1: test %ecx, %ecx
7a3: jne 0x88d
= =b> %ecx指index，如果(index & index) != 0即index != 0，則跳到0x88d
7a9: mov $0x1, %edi
7ae: jmp 0x7ce
= =b> 這裡是猜的，這裡%edi變成了found = 1?將要跳到cascade
7b0: mov (%edx), %edi
7b2: lea 0x0(%esi, %eiz, 1), %esi
7b6: cmp -0x24(%ebp), %edx
7b9: jne 0x790
= =b> 想了解lea eiz的朋友，讀這篇文章吧 http://www.technovelty.org/arch/the-quickest-way-to-do-nothing.html
-0x24(%ebp)為0x78b所存儲的首鏈表地址，如果鏈表沒遍歷完則跳到0x790
7bb: inc %esi
7bc: and $0xff, %esi
7c2: cmp %ecx %esi
7c4: jne 0x783
= =b> %esi指slot, %ecx指index，index與(slot+1) & 0xff比較，如果不同則跳到0x783
7ce: test %ecx, %ecx
7d0: je 0x7d9
= =b> 如果index為0，跳到0x7d9
7d2: add $0x100, %eax
7d7: sub %ecx, %eax
7d9: shr 0x08, %eax
7dc: mov %eax, -0x24(%ebp)
= =b> %ecx指index，%eax指timer_jiffies，timer_jiffies += 0x100 - index，然後將其右移8位
7df: lea 0x810(%ebx), %eax
7e5: mov %eax, -0x1c(%ebp)
7e8: lea 0xa10(%ebx), %eax
7ee: mov %eax, -0x18(%ebp)
7f1: lea 0xc10(%ebx), %eax
7f7: mov %eax, -0x14(%ebp)
7fa: lea 0xe10(%ebx), %eax
800: mov %eax, -0x10(%ebp)
= =b> -0x1c(%ebp)為varray[0]，-0x18(%ebp)為varray[1]，-0x14(%ebp)為varray[2]，
-0x10(%ebp)為varray[3]
803: movl $0x0, -0x28(%ebp)
80a: mov %ebx, -0x34(%ebp)
80d: mov -0x28(%ebp), %eax
810: mov -0x24(%ebp), %ecx
813: mov -0x1c(%ebp, %eax, 4), %eax
817: and $0x3f, %ecx
81a: mov %eax, -0x30(%ebp)
= =b> %eax是varray[x]的值, %ecx是timer_jiffies即index; -0x34(%ebp)保存base，
-0x30(%ebp)保存varray[x]，-0x28(%ebp)保存varray的下標，-0x24(%ebp)保存timer_jiffies
81d: mov %ecx, %eax
81f: mov -0x30(%ebp), %esi
822: mov (%esi, %eax, 8), %ebx
825: lea (%esi, %eax, 8), %esi
828: %esi, -0x38(%ebp)
82b: jmp 0x847
= =b> varray[x]保存struct tvec *類型，tvec裡第timer_jiffies個list_head的地址保存在%esi，
list_head->next的值保存在%ebx，-0x38(%ebp)保存list_head這個鏈表頭以進行遍歷
82d: testb $0x1, 0xc(%ebx)
831: mov %edx, %esi
833: jne 0x842
= =b> %ebx指nte，0xc(%ebx)指nte->base; 如果(nte->base & 1) == 1,跳到0x842,表示got deferrable;
%edx為expires
835: mov 0x8(%ebx), %esi
838: mov $0x1, %edi
83d: cmp %edx, %esi
83f: cmovns %edx, %esi
= =b> %ebx是list_head的地址，嵌套於sturct timer_list *類型中，所以%0x8(%ebx)指timer_list.expires;
%edx指expires, %edi是found, %esi是nte->expires; 如果nte->expires大於或等於expires，%esi代替為expires
842: mov -0x2c(%ebp), %ebx
845: mov %esi, %edx
= =b> 參考0x847的註釋，%ebx賦值為下一鏈表頭地址; %esi在這裡是expires
847: mov (%ebx), %esi
849: mov %esi, -0x2c(%ebp)
84c: lea 0x0(%esi, %eiz, 1)
850: cmp -0x38(%ebp), %ebx
853: jne 0x82d
= =b> 這裡的代碼跟0x7b0非常像; %ebx是下一鏈表頭的地址，%esi為下下一鏈表頭的地址，
-0x2c(%ebp)保存下下一鏈表頭地址; 比較是否遍歷到最早那個鏈表頭，否則跳到0x82d
855: test %edi, %edi
857: je 0x868
= =b> %edi指found，如果沒有找到則跳到0x868
859: cmp %ecx, %eax
85b: jl 0x861
= =b> %ecx指index，%eax指slot，如果slot比index小，跳到0x861
85d: test %ecx, %ecx
85f: jne 0x88a
= =b> 如果index不為0，跳到0x88a
861: mov $0x1, %edi
866: jmp 0x870
= =b> 這裡%edi指found?猜的
868: inc %eax
869: and $0x3f, %eax
86c: cmp %ecx, %eax
86e: jne 0x81f
= =b> %eax指slot，%ecx指index，如果不相等則跳到0x81f
870: test %ecx, %ecx
872: je 0x87b
= =b> 如果index等於0跳到0x87b
874: addl $0x40, -0x24(%ebp)
878: sub %ecx, -0x24(%ebp)
= =b> -0x24(%ebp)保存timer_jiffies，%ecx為index
87b: incl -0x28(%ebp)
87e: cmpl $0x4, -0x28(%ebp)
882: je 0x88a
= =b> -0x28(%ebp)為varray[x]的下標，如果下標達到4跳到0x88a
884: shrl $0x6, -0x24(%ebp)
888: jmp 0x80d
= =b> -0x24(%ebp)保存timer_jiffies
88a: mov -0x34(%ebp), %ebx
88d: mov %edx, 0xc(%ebx)
890: mov 0xc(%ebx), %esi
893: mov %ebx, %eax
895: call 0xc14ce8e2 <_raw_spin_unlock>
= =b> 0xc(%ebx)指base->next_timer，-0x34(%ebp)保存了base，%edx指expires
機器碼8b 33所在的地址為0xc103c847
书籍推荐
