[PATCH] x86-64: Annotate interrupt frame backlink in interrupt handlers
[pandora-kernel.git] / arch / x86_64 / kernel / entry.S
1 /*
2  *  linux/arch/x86_64/entry.S
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 2000, 2001, 2002  Andi Kleen SuSE Labs
6  *  Copyright (C) 2000  Pavel Machek <pavel@suse.cz>
7  */
8
9 /*
10  * entry.S contains the system-call and fault low-level handling routines.
11  *
12  * NOTE: This code handles signal-recognition, which happens every time
13  * after an interrupt and after each system call.
14  * 
15  * Normal syscalls and interrupts don't save a full stack frame, this is 
16  * only done for syscall tracing, signals or fork/exec et.al.
17  * 
18  * A note on terminology:        
19  * - top of stack: Architecture defined interrupt frame from SS to RIP 
20  * at the top of the kernel process stack.      
21  * - partial stack frame: partially saved registers upto R11.
22  * - full stack frame: Like partial stack frame, but all register saved. 
23  *
24  * Some macro usage:
25  * - CFI macros are used to generate dwarf2 unwind information for better
26  * backtraces. They don't change any code.
27  * - SAVE_ALL/RESTORE_ALL - Save/restore all registers
28  * - SAVE_ARGS/RESTORE_ARGS - Save/restore registers that C functions modify.
29  * There are unfortunately lots of special cases where some registers
30  * not touched. The macro is a big mess that should be cleaned up.
31  * - SAVE_REST/RESTORE_REST - Handle the registers not saved by SAVE_ARGS.
32  * Gives a full stack frame.
33  * - ENTRY/END Define functions in the symbol table.
34  * - FIXUP_TOP_OF_STACK/RESTORE_TOP_OF_STACK - Fix up the hardware stack
35  * frame that is otherwise undefined after a SYSCALL
36  * - TRACE_IRQ_* - Trace hard interrupt state for lock debugging.
37  * - errorentry/paranoidentry/zeroentry - Define exception entry points.
38  */
39
40 #include <linux/linkage.h>
41 #include <asm/segment.h>
42 #include <asm/cache.h>
43 #include <asm/errno.h>
44 #include <asm/dwarf2.h>
45 #include <asm/calling.h>
46 #include <asm/asm-offsets.h>
47 #include <asm/msr.h>
48 #include <asm/unistd.h>
49 #include <asm/thread_info.h>
50 #include <asm/hw_irq.h>
51 #include <asm/page.h>
52 #include <asm/irqflags.h>
53
54         .code64
55
56 #ifndef CONFIG_PREEMPT
57 #define retint_kernel retint_restore_args
58 #endif  
59
60
61 .macro TRACE_IRQS_IRETQ offset=ARGOFFSET
62 #ifdef CONFIG_TRACE_IRQFLAGS
63         bt   $9,EFLAGS-\offset(%rsp)    /* interrupts off? */
64         jnc  1f
65         TRACE_IRQS_ON
66 1:
67 #endif
68 .endm
69
70 /*
71  * C code is not supposed to know about undefined top of stack. Every time 
72  * a C function with an pt_regs argument is called from the SYSCALL based 
73  * fast path FIXUP_TOP_OF_STACK is needed.
74  * RESTORE_TOP_OF_STACK syncs the syscall state after any possible ptregs
75  * manipulation.
76  */             
77                 
78         /* %rsp:at FRAMEEND */ 
79         .macro FIXUP_TOP_OF_STACK tmp
80         movq    %gs:pda_oldrsp,\tmp
81         movq    \tmp,RSP(%rsp)
82         movq    $__USER_DS,SS(%rsp)
83         movq    $__USER_CS,CS(%rsp)
84         movq    $-1,RCX(%rsp)
85         movq    R11(%rsp),\tmp  /* get eflags */
86         movq    \tmp,EFLAGS(%rsp)
87         .endm
88
89         .macro RESTORE_TOP_OF_STACK tmp,offset=0
90         movq   RSP-\offset(%rsp),\tmp
91         movq   \tmp,%gs:pda_oldrsp
92         movq   EFLAGS-\offset(%rsp),\tmp
93         movq   \tmp,R11-\offset(%rsp)
94         .endm
95
96         .macro FAKE_STACK_FRAME child_rip
97         /* push in order ss, rsp, eflags, cs, rip */
98         xorl %eax, %eax
99         pushq %rax /* ss */
100         CFI_ADJUST_CFA_OFFSET   8
101         /*CFI_REL_OFFSET        ss,0*/
102         pushq %rax /* rsp */
103         CFI_ADJUST_CFA_OFFSET   8
104         CFI_REL_OFFSET  rsp,0
105         pushq $(1<<9) /* eflags - interrupts on */
106         CFI_ADJUST_CFA_OFFSET   8
107         /*CFI_REL_OFFSET        rflags,0*/
108         pushq $__KERNEL_CS /* cs */
109         CFI_ADJUST_CFA_OFFSET   8
110         /*CFI_REL_OFFSET        cs,0*/
111         pushq \child_rip /* rip */
112         CFI_ADJUST_CFA_OFFSET   8
113         CFI_REL_OFFSET  rip,0
114         pushq   %rax /* orig rax */
115         CFI_ADJUST_CFA_OFFSET   8
116         .endm
117
118         .macro UNFAKE_STACK_FRAME
119         addq $8*6, %rsp
120         CFI_ADJUST_CFA_OFFSET   -(6*8)
121         .endm
122
123         .macro  CFI_DEFAULT_STACK start=1
124         .if \start
125         CFI_STARTPROC   simple
126         CFI_SIGNAL_FRAME
127         CFI_DEF_CFA     rsp,SS+8
128         .else
129         CFI_DEF_CFA_OFFSET SS+8
130         .endif
131         CFI_REL_OFFSET  r15,R15
132         CFI_REL_OFFSET  r14,R14
133         CFI_REL_OFFSET  r13,R13
134         CFI_REL_OFFSET  r12,R12
135         CFI_REL_OFFSET  rbp,RBP
136         CFI_REL_OFFSET  rbx,RBX
137         CFI_REL_OFFSET  r11,R11
138         CFI_REL_OFFSET  r10,R10
139         CFI_REL_OFFSET  r9,R9
140         CFI_REL_OFFSET  r8,R8
141         CFI_REL_OFFSET  rax,RAX
142         CFI_REL_OFFSET  rcx,RCX
143         CFI_REL_OFFSET  rdx,RDX
144         CFI_REL_OFFSET  rsi,RSI
145         CFI_REL_OFFSET  rdi,RDI
146         CFI_REL_OFFSET  rip,RIP
147         /*CFI_REL_OFFSET        cs,CS*/
148         /*CFI_REL_OFFSET        rflags,EFLAGS*/
149         CFI_REL_OFFSET  rsp,RSP
150         /*CFI_REL_OFFSET        ss,SS*/
151         .endm
152 /*
153  * A newly forked process directly context switches into this.
154  */     
155 /* rdi: prev */ 
156 ENTRY(ret_from_fork)
157         CFI_DEFAULT_STACK
158         push kernel_eflags(%rip)
159         CFI_ADJUST_CFA_OFFSET 4
160         popf                            # reset kernel eflags
161         CFI_ADJUST_CFA_OFFSET -4
162         call schedule_tail
163         GET_THREAD_INFO(%rcx)
164         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT),threadinfo_flags(%rcx)
165         jnz rff_trace
166 rff_action:     
167         RESTORE_REST
168         testl $3,CS-ARGOFFSET(%rsp)     # from kernel_thread?
169         je   int_ret_from_sys_call
170         testl $_TIF_IA32,threadinfo_flags(%rcx)
171         jnz  int_ret_from_sys_call
172         RESTORE_TOP_OF_STACK %rdi,ARGOFFSET
173         jmp ret_from_sys_call
174 rff_trace:
175         movq %rsp,%rdi
176         call syscall_trace_leave
177         GET_THREAD_INFO(%rcx)   
178         jmp rff_action
179         CFI_ENDPROC
180 END(ret_from_fork)
181
182 /*
183  * System call entry. Upto 6 arguments in registers are supported.
184  *
185  * SYSCALL does not save anything on the stack and does not change the
186  * stack pointer.
187  */
188                 
189 /*
190  * Register setup:      
191  * rax  system call number
192  * rdi  arg0
193  * rcx  return address for syscall/sysret, C arg3 
194  * rsi  arg1
195  * rdx  arg2    
196  * r10  arg3    (--> moved to rcx for C)
197  * r8   arg4
198  * r9   arg5
199  * r11  eflags for syscall/sysret, temporary for C
200  * r12-r15,rbp,rbx saved by C code, not touched.                
201  * 
202  * Interrupts are off on entry.
203  * Only called from user space.
204  *
205  * XXX  if we had a free scratch register we could save the RSP into the stack frame
206  *      and report it properly in ps. Unfortunately we haven't.
207  *
208  * When user can change the frames always force IRET. That is because
209  * it deals with uncanonical addresses better. SYSRET has trouble
210  * with them due to bugs in both AMD and Intel CPUs.
211  */                                     
212
213 ENTRY(system_call)
214         CFI_STARTPROC   simple
215         CFI_SIGNAL_FRAME
216         CFI_DEF_CFA     rsp,PDA_STACKOFFSET
217         CFI_REGISTER    rip,rcx
218         /*CFI_REGISTER  rflags,r11*/
219         swapgs
220         movq    %rsp,%gs:pda_oldrsp 
221         movq    %gs:pda_kernelstack,%rsp
222         /*
223          * No need to follow this irqs off/on section - it's straight
224          * and short:
225          */
226         sti                                     
227         SAVE_ARGS 8,1
228         movq  %rax,ORIG_RAX-ARGOFFSET(%rsp) 
229         movq  %rcx,RIP-ARGOFFSET(%rsp)
230         CFI_REL_OFFSET rip,RIP-ARGOFFSET
231         GET_THREAD_INFO(%rcx)
232         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SECCOMP),threadinfo_flags(%rcx)
233         CFI_REMEMBER_STATE
234         jnz tracesys
235         cmpq $__NR_syscall_max,%rax
236         ja badsys
237         movq %r10,%rcx
238         call *sys_call_table(,%rax,8)  # XXX:    rip relative
239         movq %rax,RAX-ARGOFFSET(%rsp)
240 /*
241  * Syscall return path ending with SYSRET (fast path)
242  * Has incomplete stack frame and undefined top of stack. 
243  */             
244         .globl ret_from_sys_call
245 ret_from_sys_call:
246         movl $_TIF_ALLWORK_MASK,%edi
247         /* edi: flagmask */
248 sysret_check:           
249         GET_THREAD_INFO(%rcx)
250         cli
251         TRACE_IRQS_OFF
252         movl threadinfo_flags(%rcx),%edx
253         andl %edi,%edx
254         CFI_REMEMBER_STATE
255         jnz  sysret_careful 
256         /*
257          * sysretq will re-enable interrupts:
258          */
259         TRACE_IRQS_ON
260         movq RIP-ARGOFFSET(%rsp),%rcx
261         CFI_REGISTER    rip,rcx
262         RESTORE_ARGS 0,-ARG_SKIP,1
263         /*CFI_REGISTER  rflags,r11*/
264         movq    %gs:pda_oldrsp,%rsp
265         swapgs
266         sysretq
267
268         /* Handle reschedules */
269         /* edx: work, edi: workmask */  
270 sysret_careful:
271         CFI_RESTORE_STATE
272         bt $TIF_NEED_RESCHED,%edx
273         jnc sysret_signal
274         TRACE_IRQS_ON
275         sti
276         pushq %rdi
277         CFI_ADJUST_CFA_OFFSET 8
278         call schedule
279         popq  %rdi
280         CFI_ADJUST_CFA_OFFSET -8
281         jmp sysret_check
282
283         /* Handle a signal */ 
284 sysret_signal:
285         TRACE_IRQS_ON
286         sti
287         testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP),%edx
288         jz    1f
289
290         /* Really a signal */
291         /* edx: work flags (arg3) */
292         leaq do_notify_resume(%rip),%rax
293         leaq -ARGOFFSET(%rsp),%rdi # &pt_regs -> arg1
294         xorl %esi,%esi # oldset -> arg2
295         call ptregscall_common
296 1:      movl $_TIF_NEED_RESCHED,%edi
297         /* Use IRET because user could have changed frame. This
298            works because ptregscall_common has called FIXUP_TOP_OF_STACK. */
299         cli
300         TRACE_IRQS_OFF
301         jmp int_with_check
302         
303 badsys:
304         movq $-ENOSYS,RAX-ARGOFFSET(%rsp)
305         jmp ret_from_sys_call
306
307         /* Do syscall tracing */
308 tracesys:                        
309         CFI_RESTORE_STATE
310         SAVE_REST
311         movq $-ENOSYS,RAX(%rsp)
312         FIXUP_TOP_OF_STACK %rdi
313         movq %rsp,%rdi
314         call syscall_trace_enter
315         LOAD_ARGS ARGOFFSET  /* reload args from stack in case ptrace changed it */
316         RESTORE_REST
317         cmpq $__NR_syscall_max,%rax
318         ja  1f
319         movq %r10,%rcx  /* fixup for C */
320         call *sys_call_table(,%rax,8)
321 1:      movq %rax,RAX-ARGOFFSET(%rsp)
322         /* Use IRET because user could have changed frame */
323         jmp int_ret_from_sys_call
324         CFI_ENDPROC
325 END(system_call)
326                 
327 /* 
328  * Syscall return path ending with IRET.
329  * Has correct top of stack, but partial stack frame.
330  */     
331 ENTRY(int_ret_from_sys_call)
332         CFI_STARTPROC   simple
333         CFI_SIGNAL_FRAME
334         CFI_DEF_CFA     rsp,SS+8-ARGOFFSET
335         /*CFI_REL_OFFSET        ss,SS-ARGOFFSET*/
336         CFI_REL_OFFSET  rsp,RSP-ARGOFFSET
337         /*CFI_REL_OFFSET        rflags,EFLAGS-ARGOFFSET*/
338         /*CFI_REL_OFFSET        cs,CS-ARGOFFSET*/
339         CFI_REL_OFFSET  rip,RIP-ARGOFFSET
340         CFI_REL_OFFSET  rdx,RDX-ARGOFFSET
341         CFI_REL_OFFSET  rcx,RCX-ARGOFFSET
342         CFI_REL_OFFSET  rax,RAX-ARGOFFSET
343         CFI_REL_OFFSET  rdi,RDI-ARGOFFSET
344         CFI_REL_OFFSET  rsi,RSI-ARGOFFSET
345         CFI_REL_OFFSET  r8,R8-ARGOFFSET
346         CFI_REL_OFFSET  r9,R9-ARGOFFSET
347         CFI_REL_OFFSET  r10,R10-ARGOFFSET
348         CFI_REL_OFFSET  r11,R11-ARGOFFSET
349         cli
350         TRACE_IRQS_OFF
351         testl $3,CS-ARGOFFSET(%rsp)
352         je retint_restore_args
353         movl $_TIF_ALLWORK_MASK,%edi
354         /* edi: mask to check */
355 int_with_check:
356         GET_THREAD_INFO(%rcx)
357         movl threadinfo_flags(%rcx),%edx
358         andl %edi,%edx
359         jnz   int_careful
360         andl    $~TS_COMPAT,threadinfo_status(%rcx)
361         jmp   retint_swapgs
362
363         /* Either reschedule or signal or syscall exit tracking needed. */
364         /* First do a reschedule test. */
365         /* edx: work, edi: workmask */
366 int_careful:
367         bt $TIF_NEED_RESCHED,%edx
368         jnc  int_very_careful
369         TRACE_IRQS_ON
370         sti
371         pushq %rdi
372         CFI_ADJUST_CFA_OFFSET 8
373         call schedule
374         popq %rdi
375         CFI_ADJUST_CFA_OFFSET -8
376         cli
377         TRACE_IRQS_OFF
378         jmp int_with_check
379
380         /* handle signals and tracing -- both require a full stack frame */
381 int_very_careful:
382         TRACE_IRQS_ON
383         sti
384         SAVE_REST
385         /* Check for syscall exit trace */      
386         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP),%edx
387         jz int_signal
388         pushq %rdi
389         CFI_ADJUST_CFA_OFFSET 8
390         leaq 8(%rsp),%rdi       # &ptregs -> arg1       
391         call syscall_trace_leave
392         popq %rdi
393         CFI_ADJUST_CFA_OFFSET -8
394         andl $~(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP),%edi
395         cli
396         TRACE_IRQS_OFF
397         jmp int_restore_rest
398         
399 int_signal:
400         testl $(_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_SINGLESTEP),%edx
401         jz 1f
402         movq %rsp,%rdi          # &ptregs -> arg1
403         xorl %esi,%esi          # oldset -> arg2
404         call do_notify_resume
405 1:      movl $_TIF_NEED_RESCHED,%edi    
406 int_restore_rest:
407         RESTORE_REST
408         cli
409         TRACE_IRQS_OFF
410         jmp int_with_check
411         CFI_ENDPROC
412 END(int_ret_from_sys_call)
413                 
414 /* 
415  * Certain special system calls that need to save a complete full stack frame.
416  */                                                             
417         
418         .macro PTREGSCALL label,func,arg
419         .globl \label
420 \label:
421         leaq    \func(%rip),%rax
422         leaq    -ARGOFFSET+8(%rsp),\arg /* 8 for return address */
423         jmp     ptregscall_common
424 END(\label)
425         .endm
426
427         CFI_STARTPROC
428
429         PTREGSCALL stub_clone, sys_clone, %r8
430         PTREGSCALL stub_fork, sys_fork, %rdi
431         PTREGSCALL stub_vfork, sys_vfork, %rdi
432         PTREGSCALL stub_rt_sigsuspend, sys_rt_sigsuspend, %rdx
433         PTREGSCALL stub_sigaltstack, sys_sigaltstack, %rdx
434         PTREGSCALL stub_iopl, sys_iopl, %rsi
435
436 ENTRY(ptregscall_common)
437         popq %r11
438         CFI_ADJUST_CFA_OFFSET -8
439         CFI_REGISTER rip, r11
440         SAVE_REST
441         movq %r11, %r15
442         CFI_REGISTER rip, r15
443         FIXUP_TOP_OF_STACK %r11
444         call *%rax
445         RESTORE_TOP_OF_STACK %r11
446         movq %r15, %r11
447         CFI_REGISTER rip, r11
448         RESTORE_REST
449         pushq %r11
450         CFI_ADJUST_CFA_OFFSET 8
451         CFI_REL_OFFSET rip, 0
452         ret
453         CFI_ENDPROC
454 END(ptregscall_common)
455         
456 ENTRY(stub_execve)
457         CFI_STARTPROC
458         popq %r11
459         CFI_ADJUST_CFA_OFFSET -8
460         CFI_REGISTER rip, r11
461         SAVE_REST
462         FIXUP_TOP_OF_STACK %r11
463         call sys_execve
464         RESTORE_TOP_OF_STACK %r11
465         movq %rax,RAX(%rsp)
466         RESTORE_REST
467         jmp int_ret_from_sys_call
468         CFI_ENDPROC
469 END(stub_execve)
470         
471 /*
472  * sigreturn is special because it needs to restore all registers on return.
473  * This cannot be done with SYSRET, so use the IRET return path instead.
474  */                
475 ENTRY(stub_rt_sigreturn)
476         CFI_STARTPROC
477         addq $8, %rsp
478         CFI_ADJUST_CFA_OFFSET   -8
479         SAVE_REST
480         movq %rsp,%rdi
481         FIXUP_TOP_OF_STACK %r11
482         call sys_rt_sigreturn
483         movq %rax,RAX(%rsp) # fixme, this could be done at the higher layer
484         RESTORE_REST
485         jmp int_ret_from_sys_call
486         CFI_ENDPROC
487 END(stub_rt_sigreturn)
488
489 /*
490  * initial frame state for interrupts and exceptions
491  */
492         .macro _frame ref
493         CFI_STARTPROC simple
494         CFI_SIGNAL_FRAME
495         CFI_DEF_CFA rsp,SS+8-\ref
496         /*CFI_REL_OFFSET ss,SS-\ref*/
497         CFI_REL_OFFSET rsp,RSP-\ref
498         /*CFI_REL_OFFSET rflags,EFLAGS-\ref*/
499         /*CFI_REL_OFFSET cs,CS-\ref*/
500         CFI_REL_OFFSET rip,RIP-\ref
501         .endm
502
503 /* initial frame state for interrupts (and exceptions without error code) */
504 #define INTR_FRAME _frame RIP
505 /* initial frame state for exceptions with error code (and interrupts with
506    vector already pushed) */
507 #define XCPT_FRAME _frame ORIG_RAX
508
509 /* 
510  * Interrupt entry/exit.
511  *
512  * Interrupt entry points save only callee clobbered registers in fast path.
513  *      
514  * Entry runs with interrupts off.      
515  */ 
516
517 /* 0(%rsp): interrupt number */ 
518         .macro interrupt func
519         cld
520         SAVE_ARGS
521         leaq -ARGOFFSET(%rsp),%rdi      # arg1 for handler
522         pushq %rbp
523         CFI_ADJUST_CFA_OFFSET   8
524         CFI_REL_OFFSET          rbp, 0
525         movq %rsp,%rbp
526         CFI_DEF_CFA_REGISTER    rbp
527         testl $3,CS(%rdi)
528         je 1f
529         swapgs  
530         /* irqcount is used to check if a CPU is already on an interrupt
531            stack or not. While this is essentially redundant with preempt_count
532            it is a little cheaper to use a separate counter in the PDA
533            (short of moving irq_enter into assembly, which would be too
534             much work) */
535 1:      incl    %gs:pda_irqcount
536         cmoveq %gs:pda_irqstackptr,%rsp
537         push    %rbp                    # backlink for old unwinder
538         CFI_ADJUST_CFA_OFFSET 8
539         CFI_REL_OFFSET rbp,0
540         /*
541          * We entered an interrupt context - irqs are off:
542          */
543         TRACE_IRQS_OFF
544         call \func
545         .endm
546
547 ENTRY(common_interrupt)
548         XCPT_FRAME
549         interrupt do_IRQ
550         /* 0(%rsp): oldrsp-ARGOFFSET */
551 ret_from_intr:
552         cli     
553         TRACE_IRQS_OFF
554         decl %gs:pda_irqcount
555         leaveq
556         CFI_DEF_CFA_REGISTER    rsp
557         CFI_ADJUST_CFA_OFFSET   -8
558 exit_intr:
559         GET_THREAD_INFO(%rcx)
560         testl $3,CS-ARGOFFSET(%rsp)
561         je retint_kernel
562         
563         /* Interrupt came from user space */
564         /*
565          * Has a correct top of stack, but a partial stack frame
566          * %rcx: thread info. Interrupts off.
567          */             
568 retint_with_reschedule:
569         movl $_TIF_WORK_MASK,%edi
570 retint_check:
571         movl threadinfo_flags(%rcx),%edx
572         andl %edi,%edx
573         CFI_REMEMBER_STATE
574         jnz  retint_careful
575 retint_swapgs:          
576         /*
577          * The iretq could re-enable interrupts:
578          */
579         cli
580         TRACE_IRQS_IRETQ
581         swapgs 
582         jmp restore_args
583
584 retint_restore_args:                            
585         cli
586         /*
587          * The iretq could re-enable interrupts:
588          */
589         TRACE_IRQS_IRETQ
590 restore_args:
591         RESTORE_ARGS 0,8,0                                              
592 iret_label:     
593         iretq
594
595         .section __ex_table,"a"
596         .quad iret_label,bad_iret       
597         .previous
598         .section .fixup,"ax"
599         /* force a signal here? this matches i386 behaviour */
600         /* running with kernel gs */
601 bad_iret:
602         movq $11,%rdi   /* SIGSEGV */
603         TRACE_IRQS_ON
604         sti
605         jmp do_exit                     
606         .previous       
607         
608         /* edi: workmask, edx: work */
609 retint_careful:
610         CFI_RESTORE_STATE
611         bt    $TIF_NEED_RESCHED,%edx
612         jnc   retint_signal
613         TRACE_IRQS_ON
614         sti
615         pushq %rdi
616         CFI_ADJUST_CFA_OFFSET   8
617         call  schedule
618         popq %rdi               
619         CFI_ADJUST_CFA_OFFSET   -8
620         GET_THREAD_INFO(%rcx)
621         cli
622         TRACE_IRQS_OFF
623         jmp retint_check
624         
625 retint_signal:
626         testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP),%edx
627         jz    retint_swapgs
628         TRACE_IRQS_ON
629         sti
630         SAVE_REST
631         movq $-1,ORIG_RAX(%rsp)                         
632         xorl %esi,%esi          # oldset
633         movq %rsp,%rdi          # &pt_regs
634         call do_notify_resume
635         RESTORE_REST
636         cli
637         TRACE_IRQS_OFF
638         movl $_TIF_NEED_RESCHED,%edi
639         GET_THREAD_INFO(%rcx)
640         jmp retint_check
641
642 #ifdef CONFIG_PREEMPT
643         /* Returning to kernel space. Check if we need preemption */
644         /* rcx:  threadinfo. interrupts off. */
645 ENTRY(retint_kernel)
646         cmpl $0,threadinfo_preempt_count(%rcx)
647         jnz  retint_restore_args
648         bt  $TIF_NEED_RESCHED,threadinfo_flags(%rcx)
649         jnc  retint_restore_args
650         bt   $9,EFLAGS-ARGOFFSET(%rsp)  /* interrupts off? */
651         jnc  retint_restore_args
652         call preempt_schedule_irq
653         jmp exit_intr
654 #endif  
655
656         CFI_ENDPROC
657 END(common_interrupt)
658         
659 /*
660  * APIC interrupts.
661  */             
662         .macro apicinterrupt num,func
663         INTR_FRAME
664         pushq $~(\num)
665         CFI_ADJUST_CFA_OFFSET 8
666         interrupt \func
667         jmp ret_from_intr
668         CFI_ENDPROC
669         .endm
670
671 ENTRY(thermal_interrupt)
672         apicinterrupt THERMAL_APIC_VECTOR,smp_thermal_interrupt
673 END(thermal_interrupt)
674
675 ENTRY(threshold_interrupt)
676         apicinterrupt THRESHOLD_APIC_VECTOR,mce_threshold_interrupt
677 END(threshold_interrupt)
678
679 #ifdef CONFIG_SMP       
680 ENTRY(reschedule_interrupt)
681         apicinterrupt RESCHEDULE_VECTOR,smp_reschedule_interrupt
682 END(reschedule_interrupt)
683
684         .macro INVALIDATE_ENTRY num
685 ENTRY(invalidate_interrupt\num)
686         apicinterrupt INVALIDATE_TLB_VECTOR_START+\num,smp_invalidate_interrupt 
687 END(invalidate_interrupt\num)
688         .endm
689
690         INVALIDATE_ENTRY 0
691         INVALIDATE_ENTRY 1
692         INVALIDATE_ENTRY 2
693         INVALIDATE_ENTRY 3
694         INVALIDATE_ENTRY 4
695         INVALIDATE_ENTRY 5
696         INVALIDATE_ENTRY 6
697         INVALIDATE_ENTRY 7
698
699 ENTRY(call_function_interrupt)
700         apicinterrupt CALL_FUNCTION_VECTOR,smp_call_function_interrupt
701 END(call_function_interrupt)
702 #endif
703
704 ENTRY(apic_timer_interrupt)
705         apicinterrupt LOCAL_TIMER_VECTOR,smp_apic_timer_interrupt
706 END(apic_timer_interrupt)
707
708 ENTRY(error_interrupt)
709         apicinterrupt ERROR_APIC_VECTOR,smp_error_interrupt
710 END(error_interrupt)
711
712 ENTRY(spurious_interrupt)
713         apicinterrupt SPURIOUS_APIC_VECTOR,smp_spurious_interrupt
714 END(spurious_interrupt)
715                                 
716 /*
717  * Exception entry points.
718  */             
719         .macro zeroentry sym
720         INTR_FRAME
721         pushq $0        /* push error code/oldrax */ 
722         CFI_ADJUST_CFA_OFFSET 8
723         pushq %rax      /* push real oldrax to the rdi slot */ 
724         CFI_ADJUST_CFA_OFFSET 8
725         leaq  \sym(%rip),%rax
726         jmp error_entry
727         CFI_ENDPROC
728         .endm   
729
730         .macro errorentry sym
731         XCPT_FRAME
732         pushq %rax
733         CFI_ADJUST_CFA_OFFSET 8
734         leaq  \sym(%rip),%rax
735         jmp error_entry
736         CFI_ENDPROC
737         .endm
738
739         /* error code is on the stack already */
740         /* handle NMI like exceptions that can happen everywhere */
741         .macro paranoidentry sym, ist=0, irqtrace=1
742         SAVE_ALL
743         cld
744         movl $1,%ebx
745         movl  $MSR_GS_BASE,%ecx
746         rdmsr
747         testl %edx,%edx
748         js    1f
749         swapgs
750         xorl  %ebx,%ebx
751 1:
752         .if \ist
753         movq    %gs:pda_data_offset, %rbp
754         .endif
755         movq %rsp,%rdi
756         movq ORIG_RAX(%rsp),%rsi
757         movq $-1,ORIG_RAX(%rsp)
758         .if \ist
759         subq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
760         .endif
761         call \sym
762         .if \ist
763         addq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
764         .endif
765         cli
766         .if \irqtrace
767         TRACE_IRQS_OFF
768         .endif
769         .endm
770
771         /*
772          * "Paranoid" exit path from exception stack.
773          * Paranoid because this is used by NMIs and cannot take
774          * any kernel state for granted.
775          * We don't do kernel preemption checks here, because only
776          * NMI should be common and it does not enable IRQs and
777          * cannot get reschedule ticks.
778          *
779          * "trace" is 0 for the NMI handler only, because irq-tracing
780          * is fundamentally NMI-unsafe. (we cannot change the soft and
781          * hard flags at once, atomically)
782          */
783         .macro paranoidexit trace=1
784         /* ebx: no swapgs flag */
785 paranoid_exit\trace:
786         testl %ebx,%ebx                         /* swapgs needed? */
787         jnz paranoid_restore\trace
788         testl $3,CS(%rsp)
789         jnz   paranoid_userspace\trace
790 paranoid_swapgs\trace:
791         .if \trace
792         TRACE_IRQS_IRETQ 0
793         .endif
794         swapgs
795 paranoid_restore\trace:
796         RESTORE_ALL 8
797         iretq
798 paranoid_userspace\trace:
799         GET_THREAD_INFO(%rcx)
800         movl threadinfo_flags(%rcx),%ebx
801         andl $_TIF_WORK_MASK,%ebx
802         jz paranoid_swapgs\trace
803         movq %rsp,%rdi                  /* &pt_regs */
804         call sync_regs
805         movq %rax,%rsp                  /* switch stack for scheduling */
806         testl $_TIF_NEED_RESCHED,%ebx
807         jnz paranoid_schedule\trace
808         movl %ebx,%edx                  /* arg3: thread flags */
809         .if \trace
810         TRACE_IRQS_ON
811         .endif
812         sti
813         xorl %esi,%esi                  /* arg2: oldset */
814         movq %rsp,%rdi                  /* arg1: &pt_regs */
815         call do_notify_resume
816         cli
817         .if \trace
818         TRACE_IRQS_OFF
819         .endif
820         jmp paranoid_userspace\trace
821 paranoid_schedule\trace:
822         .if \trace
823         TRACE_IRQS_ON
824         .endif
825         sti
826         call schedule
827         cli
828         .if \trace
829         TRACE_IRQS_OFF
830         .endif
831         jmp paranoid_userspace\trace
832         CFI_ENDPROC
833         .endm
834
835 /*
836  * Exception entry point. This expects an error code/orig_rax on the stack
837  * and the exception handler in %rax.   
838  */                                             
839 KPROBE_ENTRY(error_entry)
840         _frame RDI
841         /* rdi slot contains rax, oldrax contains error code */
842         cld     
843         subq  $14*8,%rsp
844         CFI_ADJUST_CFA_OFFSET   (14*8)
845         movq %rsi,13*8(%rsp)
846         CFI_REL_OFFSET  rsi,RSI
847         movq 14*8(%rsp),%rsi    /* load rax from rdi slot */
848         movq %rdx,12*8(%rsp)
849         CFI_REL_OFFSET  rdx,RDX
850         movq %rcx,11*8(%rsp)
851         CFI_REL_OFFSET  rcx,RCX
852         movq %rsi,10*8(%rsp)    /* store rax */ 
853         CFI_REL_OFFSET  rax,RAX
854         movq %r8, 9*8(%rsp)
855         CFI_REL_OFFSET  r8,R8
856         movq %r9, 8*8(%rsp)
857         CFI_REL_OFFSET  r9,R9
858         movq %r10,7*8(%rsp)
859         CFI_REL_OFFSET  r10,R10
860         movq %r11,6*8(%rsp)
861         CFI_REL_OFFSET  r11,R11
862         movq %rbx,5*8(%rsp) 
863         CFI_REL_OFFSET  rbx,RBX
864         movq %rbp,4*8(%rsp) 
865         CFI_REL_OFFSET  rbp,RBP
866         movq %r12,3*8(%rsp) 
867         CFI_REL_OFFSET  r12,R12
868         movq %r13,2*8(%rsp) 
869         CFI_REL_OFFSET  r13,R13
870         movq %r14,1*8(%rsp) 
871         CFI_REL_OFFSET  r14,R14
872         movq %r15,(%rsp) 
873         CFI_REL_OFFSET  r15,R15
874         xorl %ebx,%ebx  
875         testl $3,CS(%rsp)
876         je  error_kernelspace
877 error_swapgs:   
878         swapgs
879 error_sti:      
880         movq %rdi,RDI(%rsp)     
881         movq %rsp,%rdi
882         movq ORIG_RAX(%rsp),%rsi        /* get error code */ 
883         movq $-1,ORIG_RAX(%rsp)
884         call *%rax
885         /* ebx: no swapgs flag (1: don't need swapgs, 0: need it) */     
886 error_exit:             
887         movl %ebx,%eax          
888         RESTORE_REST
889         cli
890         TRACE_IRQS_OFF
891         GET_THREAD_INFO(%rcx)   
892         testl %eax,%eax
893         jne  retint_kernel
894         movl  threadinfo_flags(%rcx),%edx
895         movl  $_TIF_WORK_MASK,%edi
896         andl  %edi,%edx
897         jnz  retint_careful
898         /*
899          * The iret might restore flags:
900          */
901         TRACE_IRQS_IRETQ
902         swapgs 
903         RESTORE_ARGS 0,8,0                                              
904         jmp iret_label
905         CFI_ENDPROC
906
907 error_kernelspace:
908         incl %ebx
909        /* There are two places in the kernel that can potentially fault with
910           usergs. Handle them here. The exception handlers after
911            iret run with kernel gs again, so don't set the user space flag.
912            B stepping K8s sometimes report an truncated RIP for IRET 
913            exceptions returning to compat mode. Check for these here too. */
914         leaq iret_label(%rip),%rbp
915         cmpq %rbp,RIP(%rsp) 
916         je   error_swapgs
917         movl %ebp,%ebp  /* zero extend */
918         cmpq %rbp,RIP(%rsp) 
919         je   error_swapgs
920         cmpq $gs_change,RIP(%rsp)
921         je   error_swapgs
922         jmp  error_sti
923 KPROBE_END(error_entry)
924         
925        /* Reload gs selector with exception handling */
926        /* edi:  new selector */ 
927 ENTRY(load_gs_index)
928         CFI_STARTPROC
929         pushf
930         CFI_ADJUST_CFA_OFFSET 8
931         cli
932         swapgs
933 gs_change:     
934         movl %edi,%gs   
935 2:      mfence          /* workaround */
936         swapgs
937         popf
938         CFI_ADJUST_CFA_OFFSET -8
939         ret
940         CFI_ENDPROC
941 ENDPROC(load_gs_index)
942        
943         .section __ex_table,"a"
944         .align 8
945         .quad gs_change,bad_gs
946         .previous
947         .section .fixup,"ax"
948         /* running with kernelgs */
949 bad_gs: 
950         swapgs                  /* switch back to user gs */
951         xorl %eax,%eax
952         movl %eax,%gs
953         jmp  2b
954         .previous       
955         
956 /*
957  * Create a kernel thread.
958  *
959  * C extern interface:
960  *      extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
961  *
962  * asm input arguments:
963  *      rdi: fn, rsi: arg, rdx: flags
964  */
965 ENTRY(kernel_thread)
966         CFI_STARTPROC
967         FAKE_STACK_FRAME $child_rip
968         SAVE_ALL
969
970         # rdi: flags, rsi: usp, rdx: will be &pt_regs
971         movq %rdx,%rdi
972         orq  kernel_thread_flags(%rip),%rdi
973         movq $-1, %rsi
974         movq %rsp, %rdx
975
976         xorl %r8d,%r8d
977         xorl %r9d,%r9d
978         
979         # clone now
980         call do_fork
981         movq %rax,RAX(%rsp)
982         xorl %edi,%edi
983         test %rax,%rax
984         jnz  1f
985         /* terminate stack in child */
986         movq %rdi,RIP(%rsp)
987 1:
988
989         /*
990          * It isn't worth to check for reschedule here,
991          * so internally to the x86_64 port you can rely on kernel_thread()
992          * not to reschedule the child before returning, this avoids the need
993          * of hacks for example to fork off the per-CPU idle tasks.
994          * [Hopefully no generic code relies on the reschedule -AK]     
995          */
996         RESTORE_ALL
997         UNFAKE_STACK_FRAME
998         ret
999         CFI_ENDPROC
1000 ENDPROC(kernel_thread)
1001         
1002 child_rip:
1003         pushq $0                # fake return address
1004         CFI_STARTPROC
1005         /*
1006          * Here we are in the child and the registers are set as they were
1007          * at kernel_thread() invocation in the parent.
1008          */
1009         movq %rdi, %rax
1010         movq %rsi, %rdi
1011         call *%rax
1012         # exit
1013         xorl %edi, %edi
1014         call do_exit
1015         CFI_ENDPROC
1016 ENDPROC(child_rip)
1017
1018 /*
1019  * execve(). This function needs to use IRET, not SYSRET, to set up all state properly.
1020  *
1021  * C extern interface:
1022  *       extern long execve(char *name, char **argv, char **envp)
1023  *
1024  * asm input arguments:
1025  *      rdi: name, rsi: argv, rdx: envp
1026  *
1027  * We want to fallback into:
1028  *      extern long sys_execve(char *name, char **argv,char **envp, struct pt_regs regs)
1029  *
1030  * do_sys_execve asm fallback arguments:
1031  *      rdi: name, rsi: argv, rdx: envp, fake frame on the stack
1032  */
1033 ENTRY(kernel_execve)
1034         CFI_STARTPROC
1035         FAKE_STACK_FRAME $0
1036         SAVE_ALL        
1037         call sys_execve
1038         movq %rax, RAX(%rsp)    
1039         RESTORE_REST
1040         testq %rax,%rax
1041         je int_ret_from_sys_call
1042         RESTORE_ARGS
1043         UNFAKE_STACK_FRAME
1044         ret
1045         CFI_ENDPROC
1046 ENDPROC(kernel_execve)
1047
1048 KPROBE_ENTRY(page_fault)
1049         errorentry do_page_fault
1050 KPROBE_END(page_fault)
1051
1052 ENTRY(coprocessor_error)
1053         zeroentry do_coprocessor_error
1054 END(coprocessor_error)
1055
1056 ENTRY(simd_coprocessor_error)
1057         zeroentry do_simd_coprocessor_error     
1058 END(simd_coprocessor_error)
1059
1060 ENTRY(device_not_available)
1061         zeroentry math_state_restore
1062 END(device_not_available)
1063
1064         /* runs on exception stack */
1065 KPROBE_ENTRY(debug)
1066         INTR_FRAME
1067         pushq $0
1068         CFI_ADJUST_CFA_OFFSET 8         
1069         paranoidentry do_debug, DEBUG_STACK
1070         paranoidexit
1071 KPROBE_END(debug)
1072
1073         /* runs on exception stack */   
1074 KPROBE_ENTRY(nmi)
1075         INTR_FRAME
1076         pushq $-1
1077         CFI_ADJUST_CFA_OFFSET 8
1078         paranoidentry do_nmi, 0, 0
1079 #ifdef CONFIG_TRACE_IRQFLAGS
1080         paranoidexit 0
1081 #else
1082         jmp paranoid_exit1
1083         CFI_ENDPROC
1084 #endif
1085 KPROBE_END(nmi)
1086
1087 KPROBE_ENTRY(int3)
1088         INTR_FRAME
1089         pushq $0
1090         CFI_ADJUST_CFA_OFFSET 8
1091         paranoidentry do_int3, DEBUG_STACK
1092         jmp paranoid_exit1
1093         CFI_ENDPROC
1094 KPROBE_END(int3)
1095
1096 ENTRY(overflow)
1097         zeroentry do_overflow
1098 END(overflow)
1099
1100 ENTRY(bounds)
1101         zeroentry do_bounds
1102 END(bounds)
1103
1104 ENTRY(invalid_op)
1105         zeroentry do_invalid_op 
1106 END(invalid_op)
1107
1108 ENTRY(coprocessor_segment_overrun)
1109         zeroentry do_coprocessor_segment_overrun
1110 END(coprocessor_segment_overrun)
1111
1112 ENTRY(reserved)
1113         zeroentry do_reserved
1114 END(reserved)
1115
1116         /* runs on exception stack */
1117 ENTRY(double_fault)
1118         XCPT_FRAME
1119         paranoidentry do_double_fault
1120         jmp paranoid_exit1
1121         CFI_ENDPROC
1122 END(double_fault)
1123
1124 ENTRY(invalid_TSS)
1125         errorentry do_invalid_TSS
1126 END(invalid_TSS)
1127
1128 ENTRY(segment_not_present)
1129         errorentry do_segment_not_present
1130 END(segment_not_present)
1131
1132         /* runs on exception stack */
1133 ENTRY(stack_segment)
1134         XCPT_FRAME
1135         paranoidentry do_stack_segment
1136         jmp paranoid_exit1
1137         CFI_ENDPROC
1138 END(stack_segment)
1139
1140 KPROBE_ENTRY(general_protection)
1141         errorentry do_general_protection
1142 KPROBE_END(general_protection)
1143
1144 ENTRY(alignment_check)
1145         errorentry do_alignment_check
1146 END(alignment_check)
1147
1148 ENTRY(divide_error)
1149         zeroentry do_divide_error
1150 END(divide_error)
1151
1152 ENTRY(spurious_interrupt_bug)
1153         zeroentry do_spurious_interrupt_bug
1154 END(spurious_interrupt_bug)
1155
1156 #ifdef CONFIG_X86_MCE
1157         /* runs on exception stack */
1158 ENTRY(machine_check)
1159         INTR_FRAME
1160         pushq $0
1161         CFI_ADJUST_CFA_OFFSET 8 
1162         paranoidentry do_machine_check
1163         jmp paranoid_exit1
1164         CFI_ENDPROC
1165 END(machine_check)
1166 #endif
1167
1168 /* Call softirq on interrupt stack. Interrupts are off. */
1169 ENTRY(call_softirq)
1170         CFI_STARTPROC
1171         push %rbp
1172         CFI_ADJUST_CFA_OFFSET   8
1173         CFI_REL_OFFSET rbp,0
1174         mov  %rsp,%rbp
1175         CFI_DEF_CFA_REGISTER rbp
1176         incl %gs:pda_irqcount
1177         cmove %gs:pda_irqstackptr,%rsp
1178         push  %rbp                      # backlink for old unwinder
1179         CFI_ADJUST_CFA_OFFSET    8
1180         call __do_softirq
1181         leaveq
1182         CFI_DEF_CFA_REGISTER    rsp
1183         CFI_ADJUST_CFA_OFFSET   -8
1184         decl %gs:pda_irqcount
1185         ret
1186         CFI_ENDPROC
1187 ENDPROC(call_softirq)
1188
1189 #ifdef CONFIG_STACK_UNWIND
1190 ENTRY(arch_unwind_init_running)
1191         CFI_STARTPROC
1192         movq    %r15, R15(%rdi)
1193         movq    %r14, R14(%rdi)
1194         xchgq   %rsi, %rdx
1195         movq    %r13, R13(%rdi)
1196         movq    %r12, R12(%rdi)
1197         xorl    %eax, %eax
1198         movq    %rbp, RBP(%rdi)
1199         movq    %rbx, RBX(%rdi)
1200         movq    (%rsp), %rcx
1201         movq    %rax, R11(%rdi)
1202         movq    %rax, R10(%rdi)
1203         movq    %rax, R9(%rdi)
1204         movq    %rax, R8(%rdi)
1205         movq    %rax, RAX(%rdi)
1206         movq    %rax, RCX(%rdi)
1207         movq    %rax, RDX(%rdi)
1208         movq    %rax, RSI(%rdi)
1209         movq    %rax, RDI(%rdi)
1210         movq    %rax, ORIG_RAX(%rdi)
1211         movq    %rcx, RIP(%rdi)
1212         leaq    8(%rsp), %rcx
1213         movq    $__KERNEL_CS, CS(%rdi)
1214         movq    %rax, EFLAGS(%rdi)
1215         movq    %rcx, RSP(%rdi)
1216         movq    $__KERNEL_DS, SS(%rdi)
1217         jmpq    *%rdx
1218         CFI_ENDPROC
1219 ENDPROC(arch_unwind_init_running)
1220 #endif