x86: irq: fix apicinterrupts on 64 bits
[linux-3.10.git] / arch / x86 / kernel / entry_64.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 #include <asm/paravirt.h>
54 #include <asm/ftrace.h>
55
56 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
57 #include <linux/elf-em.h>
58 #define AUDIT_ARCH_X86_64       (EM_X86_64|__AUDIT_ARCH_64BIT|__AUDIT_ARCH_LE)
59 #define __AUDIT_ARCH_64BIT 0x80000000
60 #define __AUDIT_ARCH_LE    0x40000000
61
62         .code64
63
64 #ifdef CONFIG_FUNCTION_TRACER
65 #ifdef CONFIG_DYNAMIC_FTRACE
66 ENTRY(mcount)
67         retq
68 END(mcount)
69
70 ENTRY(ftrace_caller)
71
72         /* taken from glibc */
73         subq $0x38, %rsp
74         movq %rax, (%rsp)
75         movq %rcx, 8(%rsp)
76         movq %rdx, 16(%rsp)
77         movq %rsi, 24(%rsp)
78         movq %rdi, 32(%rsp)
79         movq %r8, 40(%rsp)
80         movq %r9, 48(%rsp)
81
82         movq 0x38(%rsp), %rdi
83         movq 8(%rbp), %rsi
84         subq $MCOUNT_INSN_SIZE, %rdi
85
86 .globl ftrace_call
87 ftrace_call:
88         call ftrace_stub
89
90         movq 48(%rsp), %r9
91         movq 40(%rsp), %r8
92         movq 32(%rsp), %rdi
93         movq 24(%rsp), %rsi
94         movq 16(%rsp), %rdx
95         movq 8(%rsp), %rcx
96         movq (%rsp), %rax
97         addq $0x38, %rsp
98
99 .globl ftrace_stub
100 ftrace_stub:
101         retq
102 END(ftrace_caller)
103
104 #else /* ! CONFIG_DYNAMIC_FTRACE */
105 ENTRY(mcount)
106         cmpq $ftrace_stub, ftrace_trace_function
107         jnz trace
108 .globl ftrace_stub
109 ftrace_stub:
110         retq
111
112 trace:
113         /* taken from glibc */
114         subq $0x38, %rsp
115         movq %rax, (%rsp)
116         movq %rcx, 8(%rsp)
117         movq %rdx, 16(%rsp)
118         movq %rsi, 24(%rsp)
119         movq %rdi, 32(%rsp)
120         movq %r8, 40(%rsp)
121         movq %r9, 48(%rsp)
122
123         movq 0x38(%rsp), %rdi
124         movq 8(%rbp), %rsi
125         subq $MCOUNT_INSN_SIZE, %rdi
126
127         call   *ftrace_trace_function
128
129         movq 48(%rsp), %r9
130         movq 40(%rsp), %r8
131         movq 32(%rsp), %rdi
132         movq 24(%rsp), %rsi
133         movq 16(%rsp), %rdx
134         movq 8(%rsp), %rcx
135         movq (%rsp), %rax
136         addq $0x38, %rsp
137
138         jmp ftrace_stub
139 END(mcount)
140 #endif /* CONFIG_DYNAMIC_FTRACE */
141 #endif /* CONFIG_FUNCTION_TRACER */
142
143 #ifndef CONFIG_PREEMPT
144 #define retint_kernel retint_restore_args
145 #endif  
146
147 #ifdef CONFIG_PARAVIRT
148 ENTRY(native_usergs_sysret64)
149         swapgs
150         sysretq
151 #endif /* CONFIG_PARAVIRT */
152
153
154 .macro TRACE_IRQS_IRETQ offset=ARGOFFSET
155 #ifdef CONFIG_TRACE_IRQFLAGS
156         bt   $9,EFLAGS-\offset(%rsp)    /* interrupts off? */
157         jnc  1f
158         TRACE_IRQS_ON
159 1:
160 #endif
161 .endm
162
163 /*
164  * C code is not supposed to know about undefined top of stack. Every time 
165  * a C function with an pt_regs argument is called from the SYSCALL based 
166  * fast path FIXUP_TOP_OF_STACK is needed.
167  * RESTORE_TOP_OF_STACK syncs the syscall state after any possible ptregs
168  * manipulation.
169  */             
170                 
171         /* %rsp:at FRAMEEND */ 
172         .macro FIXUP_TOP_OF_STACK tmp
173         movq    %gs:pda_oldrsp,\tmp
174         movq    \tmp,RSP(%rsp)
175         movq    $__USER_DS,SS(%rsp)
176         movq    $__USER_CS,CS(%rsp)
177         movq    $-1,RCX(%rsp)
178         movq    R11(%rsp),\tmp  /* get eflags */
179         movq    \tmp,EFLAGS(%rsp)
180         .endm
181
182         .macro RESTORE_TOP_OF_STACK tmp,offset=0
183         movq   RSP-\offset(%rsp),\tmp
184         movq   \tmp,%gs:pda_oldrsp
185         movq   EFLAGS-\offset(%rsp),\tmp
186         movq   \tmp,R11-\offset(%rsp)
187         .endm
188
189         .macro FAKE_STACK_FRAME child_rip
190         /* push in order ss, rsp, eflags, cs, rip */
191         xorl %eax, %eax
192         pushq $__KERNEL_DS /* ss */
193         CFI_ADJUST_CFA_OFFSET   8
194         /*CFI_REL_OFFSET        ss,0*/
195         pushq %rax /* rsp */
196         CFI_ADJUST_CFA_OFFSET   8
197         CFI_REL_OFFSET  rsp,0
198         pushq $(1<<9) /* eflags - interrupts on */
199         CFI_ADJUST_CFA_OFFSET   8
200         /*CFI_REL_OFFSET        rflags,0*/
201         pushq $__KERNEL_CS /* cs */
202         CFI_ADJUST_CFA_OFFSET   8
203         /*CFI_REL_OFFSET        cs,0*/
204         pushq \child_rip /* rip */
205         CFI_ADJUST_CFA_OFFSET   8
206         CFI_REL_OFFSET  rip,0
207         pushq   %rax /* orig rax */
208         CFI_ADJUST_CFA_OFFSET   8
209         .endm
210
211         .macro UNFAKE_STACK_FRAME
212         addq $8*6, %rsp
213         CFI_ADJUST_CFA_OFFSET   -(6*8)
214         .endm
215
216         .macro  CFI_DEFAULT_STACK start=1
217         .if \start
218         CFI_STARTPROC   simple
219         CFI_SIGNAL_FRAME
220         CFI_DEF_CFA     rsp,SS+8
221         .else
222         CFI_DEF_CFA_OFFSET SS+8
223         .endif
224         CFI_REL_OFFSET  r15,R15
225         CFI_REL_OFFSET  r14,R14
226         CFI_REL_OFFSET  r13,R13
227         CFI_REL_OFFSET  r12,R12
228         CFI_REL_OFFSET  rbp,RBP
229         CFI_REL_OFFSET  rbx,RBX
230         CFI_REL_OFFSET  r11,R11
231         CFI_REL_OFFSET  r10,R10
232         CFI_REL_OFFSET  r9,R9
233         CFI_REL_OFFSET  r8,R8
234         CFI_REL_OFFSET  rax,RAX
235         CFI_REL_OFFSET  rcx,RCX
236         CFI_REL_OFFSET  rdx,RDX
237         CFI_REL_OFFSET  rsi,RSI
238         CFI_REL_OFFSET  rdi,RDI
239         CFI_REL_OFFSET  rip,RIP
240         /*CFI_REL_OFFSET        cs,CS*/
241         /*CFI_REL_OFFSET        rflags,EFLAGS*/
242         CFI_REL_OFFSET  rsp,RSP
243         /*CFI_REL_OFFSET        ss,SS*/
244         .endm
245 /*
246  * A newly forked process directly context switches into this.
247  */     
248 /* rdi: prev */ 
249 ENTRY(ret_from_fork)
250         CFI_DEFAULT_STACK
251         push kernel_eflags(%rip)
252         CFI_ADJUST_CFA_OFFSET 8
253         popf                            # reset kernel eflags
254         CFI_ADJUST_CFA_OFFSET -8
255         call schedule_tail
256         GET_THREAD_INFO(%rcx)
257         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT),TI_flags(%rcx)
258         jnz rff_trace
259 rff_action:     
260         RESTORE_REST
261         testl $3,CS-ARGOFFSET(%rsp)     # from kernel_thread?
262         je   int_ret_from_sys_call
263         testl $_TIF_IA32,TI_flags(%rcx)
264         jnz  int_ret_from_sys_call
265         RESTORE_TOP_OF_STACK %rdi,ARGOFFSET
266         jmp ret_from_sys_call
267 rff_trace:
268         movq %rsp,%rdi
269         call syscall_trace_leave
270         GET_THREAD_INFO(%rcx)   
271         jmp rff_action
272         CFI_ENDPROC
273 END(ret_from_fork)
274
275 /*
276  * System call entry. Upto 6 arguments in registers are supported.
277  *
278  * SYSCALL does not save anything on the stack and does not change the
279  * stack pointer.
280  */
281                 
282 /*
283  * Register setup:      
284  * rax  system call number
285  * rdi  arg0
286  * rcx  return address for syscall/sysret, C arg3 
287  * rsi  arg1
288  * rdx  arg2    
289  * r10  arg3    (--> moved to rcx for C)
290  * r8   arg4
291  * r9   arg5
292  * r11  eflags for syscall/sysret, temporary for C
293  * r12-r15,rbp,rbx saved by C code, not touched.                
294  * 
295  * Interrupts are off on entry.
296  * Only called from user space.
297  *
298  * XXX  if we had a free scratch register we could save the RSP into the stack frame
299  *      and report it properly in ps. Unfortunately we haven't.
300  *
301  * When user can change the frames always force IRET. That is because
302  * it deals with uncanonical addresses better. SYSRET has trouble
303  * with them due to bugs in both AMD and Intel CPUs.
304  */                                     
305
306 ENTRY(system_call)
307         CFI_STARTPROC   simple
308         CFI_SIGNAL_FRAME
309         CFI_DEF_CFA     rsp,PDA_STACKOFFSET
310         CFI_REGISTER    rip,rcx
311         /*CFI_REGISTER  rflags,r11*/
312         SWAPGS_UNSAFE_STACK
313         /*
314          * A hypervisor implementation might want to use a label
315          * after the swapgs, so that it can do the swapgs
316          * for the guest and jump here on syscall.
317          */
318 ENTRY(system_call_after_swapgs)
319
320         movq    %rsp,%gs:pda_oldrsp 
321         movq    %gs:pda_kernelstack,%rsp
322         /*
323          * No need to follow this irqs off/on section - it's straight
324          * and short:
325          */
326         ENABLE_INTERRUPTS(CLBR_NONE)
327         SAVE_ARGS 8,1
328         movq  %rax,ORIG_RAX-ARGOFFSET(%rsp) 
329         movq  %rcx,RIP-ARGOFFSET(%rsp)
330         CFI_REL_OFFSET rip,RIP-ARGOFFSET
331         GET_THREAD_INFO(%rcx)
332         testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%rcx)
333         jnz tracesys
334 system_call_fastpath:
335         cmpq $__NR_syscall_max,%rax
336         ja badsys
337         movq %r10,%rcx
338         call *sys_call_table(,%rax,8)  # XXX:    rip relative
339         movq %rax,RAX-ARGOFFSET(%rsp)
340 /*
341  * Syscall return path ending with SYSRET (fast path)
342  * Has incomplete stack frame and undefined top of stack. 
343  */             
344 ret_from_sys_call:
345         movl $_TIF_ALLWORK_MASK,%edi
346         /* edi: flagmask */
347 sysret_check:           
348         LOCKDEP_SYS_EXIT
349         GET_THREAD_INFO(%rcx)
350         DISABLE_INTERRUPTS(CLBR_NONE)
351         TRACE_IRQS_OFF
352         movl TI_flags(%rcx),%edx
353         andl %edi,%edx
354         jnz  sysret_careful 
355         CFI_REMEMBER_STATE
356         /*
357          * sysretq will re-enable interrupts:
358          */
359         TRACE_IRQS_ON
360         movq RIP-ARGOFFSET(%rsp),%rcx
361         CFI_REGISTER    rip,rcx
362         RESTORE_ARGS 0,-ARG_SKIP,1
363         /*CFI_REGISTER  rflags,r11*/
364         movq    %gs:pda_oldrsp, %rsp
365         USERGS_SYSRET64
366
367         CFI_RESTORE_STATE
368         /* Handle reschedules */
369         /* edx: work, edi: workmask */  
370 sysret_careful:
371         bt $TIF_NEED_RESCHED,%edx
372         jnc sysret_signal
373         TRACE_IRQS_ON
374         ENABLE_INTERRUPTS(CLBR_NONE)
375         pushq %rdi
376         CFI_ADJUST_CFA_OFFSET 8
377         call schedule
378         popq  %rdi
379         CFI_ADJUST_CFA_OFFSET -8
380         jmp sysret_check
381
382         /* Handle a signal */ 
383 sysret_signal:
384         TRACE_IRQS_ON
385         ENABLE_INTERRUPTS(CLBR_NONE)
386 #ifdef CONFIG_AUDITSYSCALL
387         bt $TIF_SYSCALL_AUDIT,%edx
388         jc sysret_audit
389 #endif
390         /* edx: work flags (arg3) */
391         leaq do_notify_resume(%rip),%rax
392         leaq -ARGOFFSET(%rsp),%rdi # &pt_regs -> arg1
393         xorl %esi,%esi # oldset -> arg2
394         call ptregscall_common
395         movl $_TIF_WORK_MASK,%edi
396         /* Use IRET because user could have changed frame. This
397            works because ptregscall_common has called FIXUP_TOP_OF_STACK. */
398         DISABLE_INTERRUPTS(CLBR_NONE)
399         TRACE_IRQS_OFF
400         jmp int_with_check
401         
402 badsys:
403         movq $-ENOSYS,RAX-ARGOFFSET(%rsp)
404         jmp ret_from_sys_call
405
406 #ifdef CONFIG_AUDITSYSCALL
407         /*
408          * Fast path for syscall audit without full syscall trace.
409          * We just call audit_syscall_entry() directly, and then
410          * jump back to the normal fast path.
411          */
412 auditsys:
413         movq %r10,%r9                   /* 6th arg: 4th syscall arg */
414         movq %rdx,%r8                   /* 5th arg: 3rd syscall arg */
415         movq %rsi,%rcx                  /* 4th arg: 2nd syscall arg */
416         movq %rdi,%rdx                  /* 3rd arg: 1st syscall arg */
417         movq %rax,%rsi                  /* 2nd arg: syscall number */
418         movl $AUDIT_ARCH_X86_64,%edi    /* 1st arg: audit arch */
419         call audit_syscall_entry
420         LOAD_ARGS 0             /* reload call-clobbered registers */
421         jmp system_call_fastpath
422
423         /*
424          * Return fast path for syscall audit.  Call audit_syscall_exit()
425          * directly and then jump back to the fast path with TIF_SYSCALL_AUDIT
426          * masked off.
427          */
428 sysret_audit:
429         movq %rax,%rsi          /* second arg, syscall return value */
430         cmpq $0,%rax            /* is it < 0? */
431         setl %al                /* 1 if so, 0 if not */
432         movzbl %al,%edi         /* zero-extend that into %edi */
433         inc %edi /* first arg, 0->1(AUDITSC_SUCCESS), 1->2(AUDITSC_FAILURE) */
434         call audit_syscall_exit
435         movl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT),%edi
436         jmp sysret_check
437 #endif  /* CONFIG_AUDITSYSCALL */
438
439         /* Do syscall tracing */
440 tracesys:                        
441 #ifdef CONFIG_AUDITSYSCALL
442         testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags(%rcx)
443         jz auditsys
444 #endif
445         SAVE_REST
446         movq $-ENOSYS,RAX(%rsp) /* ptrace can change this for a bad syscall */
447         FIXUP_TOP_OF_STACK %rdi
448         movq %rsp,%rdi
449         call syscall_trace_enter
450         /*
451          * Reload arg registers from stack in case ptrace changed them.
452          * We don't reload %rax because syscall_trace_enter() returned
453          * the value it wants us to use in the table lookup.
454          */
455         LOAD_ARGS ARGOFFSET, 1
456         RESTORE_REST
457         cmpq $__NR_syscall_max,%rax
458         ja   int_ret_from_sys_call      /* RAX(%rsp) set to -ENOSYS above */
459         movq %r10,%rcx  /* fixup for C */
460         call *sys_call_table(,%rax,8)
461         movq %rax,RAX-ARGOFFSET(%rsp)
462         /* Use IRET because user could have changed frame */
463                 
464 /* 
465  * Syscall return path ending with IRET.
466  * Has correct top of stack, but partial stack frame.
467  */
468         .globl int_ret_from_sys_call
469         .globl int_with_check
470 int_ret_from_sys_call:
471         DISABLE_INTERRUPTS(CLBR_NONE)
472         TRACE_IRQS_OFF
473         testl $3,CS-ARGOFFSET(%rsp)
474         je retint_restore_args
475         movl $_TIF_ALLWORK_MASK,%edi
476         /* edi: mask to check */
477 int_with_check:
478         LOCKDEP_SYS_EXIT_IRQ
479         GET_THREAD_INFO(%rcx)
480         movl TI_flags(%rcx),%edx
481         andl %edi,%edx
482         jnz   int_careful
483         andl    $~TS_COMPAT,TI_status(%rcx)
484         jmp   retint_swapgs
485
486         /* Either reschedule or signal or syscall exit tracking needed. */
487         /* First do a reschedule test. */
488         /* edx: work, edi: workmask */
489 int_careful:
490         bt $TIF_NEED_RESCHED,%edx
491         jnc  int_very_careful
492         TRACE_IRQS_ON
493         ENABLE_INTERRUPTS(CLBR_NONE)
494         pushq %rdi
495         CFI_ADJUST_CFA_OFFSET 8
496         call schedule
497         popq %rdi
498         CFI_ADJUST_CFA_OFFSET -8
499         DISABLE_INTERRUPTS(CLBR_NONE)
500         TRACE_IRQS_OFF
501         jmp int_with_check
502
503         /* handle signals and tracing -- both require a full stack frame */
504 int_very_careful:
505         TRACE_IRQS_ON
506         ENABLE_INTERRUPTS(CLBR_NONE)
507         SAVE_REST
508         /* Check for syscall exit trace */      
509         testl $_TIF_WORK_SYSCALL_EXIT,%edx
510         jz int_signal
511         pushq %rdi
512         CFI_ADJUST_CFA_OFFSET 8
513         leaq 8(%rsp),%rdi       # &ptregs -> arg1       
514         call syscall_trace_leave
515         popq %rdi
516         CFI_ADJUST_CFA_OFFSET -8
517         andl $~(_TIF_WORK_SYSCALL_EXIT|_TIF_SYSCALL_EMU),%edi
518         jmp int_restore_rest
519         
520 int_signal:
521         testl $_TIF_DO_NOTIFY_MASK,%edx
522         jz 1f
523         movq %rsp,%rdi          # &ptregs -> arg1
524         xorl %esi,%esi          # oldset -> arg2
525         call do_notify_resume
526 1:      movl $_TIF_WORK_MASK,%edi
527 int_restore_rest:
528         RESTORE_REST
529         DISABLE_INTERRUPTS(CLBR_NONE)
530         TRACE_IRQS_OFF
531         jmp int_with_check
532         CFI_ENDPROC
533 END(system_call)
534                 
535 /* 
536  * Certain special system calls that need to save a complete full stack frame.
537  */                                                             
538         
539         .macro PTREGSCALL label,func,arg
540         .globl \label
541 \label:
542         leaq    \func(%rip),%rax
543         leaq    -ARGOFFSET+8(%rsp),\arg /* 8 for return address */
544         jmp     ptregscall_common
545 END(\label)
546         .endm
547
548         CFI_STARTPROC
549
550         PTREGSCALL stub_clone, sys_clone, %r8
551         PTREGSCALL stub_fork, sys_fork, %rdi
552         PTREGSCALL stub_vfork, sys_vfork, %rdi
553         PTREGSCALL stub_sigaltstack, sys_sigaltstack, %rdx
554         PTREGSCALL stub_iopl, sys_iopl, %rsi
555
556 ENTRY(ptregscall_common)
557         popq %r11
558         CFI_ADJUST_CFA_OFFSET -8
559         CFI_REGISTER rip, r11
560         SAVE_REST
561         movq %r11, %r15
562         CFI_REGISTER rip, r15
563         FIXUP_TOP_OF_STACK %r11
564         call *%rax
565         RESTORE_TOP_OF_STACK %r11
566         movq %r15, %r11
567         CFI_REGISTER rip, r11
568         RESTORE_REST
569         pushq %r11
570         CFI_ADJUST_CFA_OFFSET 8
571         CFI_REL_OFFSET rip, 0
572         ret
573         CFI_ENDPROC
574 END(ptregscall_common)
575         
576 ENTRY(stub_execve)
577         CFI_STARTPROC
578         popq %r11
579         CFI_ADJUST_CFA_OFFSET -8
580         CFI_REGISTER rip, r11
581         SAVE_REST
582         FIXUP_TOP_OF_STACK %r11
583         movq %rsp, %rcx
584         call sys_execve
585         RESTORE_TOP_OF_STACK %r11
586         movq %rax,RAX(%rsp)
587         RESTORE_REST
588         jmp int_ret_from_sys_call
589         CFI_ENDPROC
590 END(stub_execve)
591         
592 /*
593  * sigreturn is special because it needs to restore all registers on return.
594  * This cannot be done with SYSRET, so use the IRET return path instead.
595  */                
596 ENTRY(stub_rt_sigreturn)
597         CFI_STARTPROC
598         addq $8, %rsp
599         CFI_ADJUST_CFA_OFFSET   -8
600         SAVE_REST
601         movq %rsp,%rdi
602         FIXUP_TOP_OF_STACK %r11
603         call sys_rt_sigreturn
604         movq %rax,RAX(%rsp) # fixme, this could be done at the higher layer
605         RESTORE_REST
606         jmp int_ret_from_sys_call
607         CFI_ENDPROC
608 END(stub_rt_sigreturn)
609
610 /*
611  * initial frame state for interrupts and exceptions
612  */
613         .macro _frame ref
614         CFI_STARTPROC simple
615         CFI_SIGNAL_FRAME
616         CFI_DEF_CFA rsp,SS+8-\ref
617         /*CFI_REL_OFFSET ss,SS-\ref*/
618         CFI_REL_OFFSET rsp,RSP-\ref
619         /*CFI_REL_OFFSET rflags,EFLAGS-\ref*/
620         /*CFI_REL_OFFSET cs,CS-\ref*/
621         CFI_REL_OFFSET rip,RIP-\ref
622         .endm
623
624 /* initial frame state for interrupts (and exceptions without error code) */
625 #define INTR_FRAME _frame RIP
626 /* initial frame state for exceptions with error code (and interrupts with
627    vector already pushed) */
628 #define XCPT_FRAME _frame ORIG_RAX
629
630 /*
631  * Build the entry stubs and pointer table with some assembler magic.
632  * We pack 7 stubs into a single 32-byte chunk, which will fit in a
633  * single cache line on all modern x86 implementations.
634  */
635         .section .init.rodata,"a"
636 ENTRY(interrupt)
637         .text
638         .p2align 5
639         .p2align CONFIG_X86_L1_CACHE_SHIFT
640 ENTRY(irq_entries_start)
641         INTR_FRAME
642 vector=FIRST_EXTERNAL_VECTOR
643 .rept (NR_VECTORS-FIRST_EXTERNAL_VECTOR+6)/7
644         .balign 32
645   .rept 7
646     .if vector < NR_VECTORS
647       .if vector <> FIRST_EXTERNAL_VECTOR
648         CFI_ADJUST_CFA_OFFSET -8
649       .endif
650 1:      pushq $(~vector+0x80)   /* Note: always in signed byte range */
651         CFI_ADJUST_CFA_OFFSET 8
652       .if ((vector-FIRST_EXTERNAL_VECTOR)%7) <> 6
653         jmp 2f
654       .endif
655       .previous
656         .quad 1b
657       .text
658 vector=vector+1
659     .endif
660   .endr
661 2:      jmp common_interrupt
662 .endr
663         CFI_ENDPROC
664 END(irq_entries_start)
665
666 .previous
667 END(interrupt)
668 .previous
669
670 /* 
671  * Interrupt entry/exit.
672  *
673  * Interrupt entry points save only callee clobbered registers in fast path.
674  *      
675  * Entry runs with interrupts off.      
676  */ 
677
678 /* 0(%rsp): ~(interrupt number) */
679         .macro interrupt func
680         cld
681         SAVE_ARGS
682         leaq -ARGOFFSET(%rsp),%rdi      /* arg1 for handler */
683         pushq %rbp
684         /*
685          * Save rbp twice: One is for marking the stack frame, as usual, and the
686          * other, to fill pt_regs properly. This is because bx comes right
687          * before the last saved register in that structure, and not bp. If the
688          * base pointer were in the place bx is today, this would not be needed.
689          */
690         movq %rbp, -8(%rsp)
691         CFI_ADJUST_CFA_OFFSET   8
692         CFI_REL_OFFSET          rbp, 0
693         movq %rsp,%rbp
694         CFI_DEF_CFA_REGISTER    rbp
695         testl $3,CS(%rdi)
696         je 1f
697         SWAPGS
698         /* irqcount is used to check if a CPU is already on an interrupt
699            stack or not. While this is essentially redundant with preempt_count
700            it is a little cheaper to use a separate counter in the PDA
701            (short of moving irq_enter into assembly, which would be too
702             much work) */
703 1:      incl    %gs:pda_irqcount
704         cmoveq %gs:pda_irqstackptr,%rsp
705         push    %rbp                    # backlink for old unwinder
706         /*
707          * We entered an interrupt context - irqs are off:
708          */
709         TRACE_IRQS_OFF
710         call \func
711         .endm
712
713         /*
714          * The interrupt stubs push (~vector+0x80) onto the stack and
715          * then jump to common_interrupt.
716          */
717         .p2align CONFIG_X86_L1_CACHE_SHIFT
718 common_interrupt:
719         XCPT_FRAME
720         addq $-0x80,(%rsp)              /* Adjust vector to [-256,-1] range */
721         interrupt do_IRQ
722         /* 0(%rsp): oldrsp-ARGOFFSET */
723 ret_from_intr:
724         DISABLE_INTERRUPTS(CLBR_NONE)
725         TRACE_IRQS_OFF
726         decl %gs:pda_irqcount
727         leaveq
728         CFI_DEF_CFA_REGISTER    rsp
729         CFI_ADJUST_CFA_OFFSET   -8
730 exit_intr:
731         GET_THREAD_INFO(%rcx)
732         testl $3,CS-ARGOFFSET(%rsp)
733         je retint_kernel
734         
735         /* Interrupt came from user space */
736         /*
737          * Has a correct top of stack, but a partial stack frame
738          * %rcx: thread info. Interrupts off.
739          */             
740 retint_with_reschedule:
741         movl $_TIF_WORK_MASK,%edi
742 retint_check:
743         LOCKDEP_SYS_EXIT_IRQ
744         movl TI_flags(%rcx),%edx
745         andl %edi,%edx
746         CFI_REMEMBER_STATE
747         jnz  retint_careful
748
749 retint_swapgs:          /* return to user-space */
750         /*
751          * The iretq could re-enable interrupts:
752          */
753         DISABLE_INTERRUPTS(CLBR_ANY)
754         TRACE_IRQS_IRETQ
755         SWAPGS
756         jmp restore_args
757
758 retint_restore_args:    /* return to kernel space */
759         DISABLE_INTERRUPTS(CLBR_ANY)
760         /*
761          * The iretq could re-enable interrupts:
762          */
763         TRACE_IRQS_IRETQ
764 restore_args:
765         RESTORE_ARGS 0,8,0
766
767 irq_return:
768         INTERRUPT_RETURN
769
770         .section __ex_table, "a"
771         .quad irq_return, bad_iret
772         .previous
773
774 #ifdef CONFIG_PARAVIRT
775 ENTRY(native_iret)
776         iretq
777
778         .section __ex_table,"a"
779         .quad native_iret, bad_iret
780         .previous
781 #endif
782
783         .section .fixup,"ax"
784 bad_iret:
785         /*
786          * The iret traps when the %cs or %ss being restored is bogus.
787          * We've lost the original trap vector and error code.
788          * #GPF is the most likely one to get for an invalid selector.
789          * So pretend we completed the iret and took the #GPF in user mode.
790          *
791          * We are now running with the kernel GS after exception recovery.
792          * But error_entry expects us to have user GS to match the user %cs,
793          * so swap back.
794          */
795         pushq $0
796
797         SWAPGS
798         jmp general_protection
799
800         .previous
801
802         /* edi: workmask, edx: work */
803 retint_careful:
804         CFI_RESTORE_STATE
805         bt    $TIF_NEED_RESCHED,%edx
806         jnc   retint_signal
807         TRACE_IRQS_ON
808         ENABLE_INTERRUPTS(CLBR_NONE)
809         pushq %rdi
810         CFI_ADJUST_CFA_OFFSET   8
811         call  schedule
812         popq %rdi               
813         CFI_ADJUST_CFA_OFFSET   -8
814         GET_THREAD_INFO(%rcx)
815         DISABLE_INTERRUPTS(CLBR_NONE)
816         TRACE_IRQS_OFF
817         jmp retint_check
818         
819 retint_signal:
820         testl $_TIF_DO_NOTIFY_MASK,%edx
821         jz    retint_swapgs
822         TRACE_IRQS_ON
823         ENABLE_INTERRUPTS(CLBR_NONE)
824         SAVE_REST
825         movq $-1,ORIG_RAX(%rsp)                         
826         xorl %esi,%esi          # oldset
827         movq %rsp,%rdi          # &pt_regs
828         call do_notify_resume
829         RESTORE_REST
830         DISABLE_INTERRUPTS(CLBR_NONE)
831         TRACE_IRQS_OFF
832         GET_THREAD_INFO(%rcx)
833         jmp retint_with_reschedule
834
835 #ifdef CONFIG_PREEMPT
836         /* Returning to kernel space. Check if we need preemption */
837         /* rcx:  threadinfo. interrupts off. */
838 ENTRY(retint_kernel)
839         cmpl $0,TI_preempt_count(%rcx)
840         jnz  retint_restore_args
841         bt  $TIF_NEED_RESCHED,TI_flags(%rcx)
842         jnc  retint_restore_args
843         bt   $9,EFLAGS-ARGOFFSET(%rsp)  /* interrupts off? */
844         jnc  retint_restore_args
845         call preempt_schedule_irq
846         jmp exit_intr
847 #endif  
848
849         CFI_ENDPROC
850 END(common_interrupt)
851         
852 /*
853  * APIC interrupts.
854  */             
855         .macro apicinterrupt num,func
856         INTR_FRAME
857         pushq $~(\num)
858         CFI_ADJUST_CFA_OFFSET 8
859         interrupt \func
860         jmp ret_from_intr
861         CFI_ENDPROC
862         .endm
863
864 ENTRY(thermal_interrupt)
865         apicinterrupt THERMAL_APIC_VECTOR,smp_thermal_interrupt
866 END(thermal_interrupt)
867
868 ENTRY(threshold_interrupt)
869         apicinterrupt THRESHOLD_APIC_VECTOR,mce_threshold_interrupt
870 END(threshold_interrupt)
871
872 #ifdef CONFIG_SMP       
873 ENTRY(reschedule_interrupt)
874         apicinterrupt RESCHEDULE_VECTOR,smp_reschedule_interrupt
875 END(reschedule_interrupt)
876
877         .macro INVALIDATE_ENTRY num
878 ENTRY(invalidate_interrupt\num)
879         apicinterrupt INVALIDATE_TLB_VECTOR_START+\num,smp_invalidate_interrupt 
880 END(invalidate_interrupt\num)
881         .endm
882
883         INVALIDATE_ENTRY 0
884         INVALIDATE_ENTRY 1
885         INVALIDATE_ENTRY 2
886         INVALIDATE_ENTRY 3
887         INVALIDATE_ENTRY 4
888         INVALIDATE_ENTRY 5
889         INVALIDATE_ENTRY 6
890         INVALIDATE_ENTRY 7
891
892 ENTRY(call_function_interrupt)
893         apicinterrupt CALL_FUNCTION_VECTOR,smp_call_function_interrupt
894 END(call_function_interrupt)
895 ENTRY(call_function_single_interrupt)
896         apicinterrupt CALL_FUNCTION_SINGLE_VECTOR,smp_call_function_single_interrupt
897 END(call_function_single_interrupt)
898 ENTRY(irq_move_cleanup_interrupt)
899         apicinterrupt IRQ_MOVE_CLEANUP_VECTOR,smp_irq_move_cleanup_interrupt
900 END(irq_move_cleanup_interrupt)
901 #endif
902
903 ENTRY(apic_timer_interrupt)
904         apicinterrupt LOCAL_TIMER_VECTOR,smp_apic_timer_interrupt
905 END(apic_timer_interrupt)
906
907 ENTRY(uv_bau_message_intr1)
908         apicinterrupt 220,uv_bau_message_interrupt
909 END(uv_bau_message_intr1)
910
911 ENTRY(error_interrupt)
912         apicinterrupt ERROR_APIC_VECTOR,smp_error_interrupt
913 END(error_interrupt)
914
915 ENTRY(spurious_interrupt)
916         apicinterrupt SPURIOUS_APIC_VECTOR,smp_spurious_interrupt
917 END(spurious_interrupt)
918                                 
919 /*
920  * Exception entry points.
921  */             
922         .macro zeroentry sym
923         INTR_FRAME
924         PARAVIRT_ADJUST_EXCEPTION_FRAME
925         pushq $0        /* push error code/oldrax */ 
926         CFI_ADJUST_CFA_OFFSET 8
927         pushq %rax      /* push real oldrax to the rdi slot */ 
928         CFI_ADJUST_CFA_OFFSET 8
929         CFI_REL_OFFSET rax,0
930         leaq  \sym(%rip),%rax
931         jmp error_entry
932         CFI_ENDPROC
933         .endm   
934
935         .macro errorentry sym
936         XCPT_FRAME
937         PARAVIRT_ADJUST_EXCEPTION_FRAME
938         pushq %rax
939         CFI_ADJUST_CFA_OFFSET 8
940         CFI_REL_OFFSET rax,0
941         leaq  \sym(%rip),%rax
942         jmp error_entry
943         CFI_ENDPROC
944         .endm
945
946         /* error code is on the stack already */
947         /* handle NMI like exceptions that can happen everywhere */
948         .macro paranoidentry sym, ist=0, irqtrace=1
949         SAVE_ALL
950         cld
951         movl $1,%ebx
952         movl  $MSR_GS_BASE,%ecx
953         rdmsr
954         testl %edx,%edx
955         js    1f
956         SWAPGS
957         xorl  %ebx,%ebx
958 1:
959         .if \ist
960         movq    %gs:pda_data_offset, %rbp
961         .endif
962         .if \irqtrace
963         TRACE_IRQS_OFF
964         .endif
965         movq %rsp,%rdi
966         movq ORIG_RAX(%rsp),%rsi
967         movq $-1,ORIG_RAX(%rsp)
968         .if \ist
969         subq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
970         .endif
971         call \sym
972         .if \ist
973         addq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
974         .endif
975         DISABLE_INTERRUPTS(CLBR_NONE)
976         .if \irqtrace
977         TRACE_IRQS_OFF
978         .endif
979         .endm
980
981         /*
982          * "Paranoid" exit path from exception stack.
983          * Paranoid because this is used by NMIs and cannot take
984          * any kernel state for granted.
985          * We don't do kernel preemption checks here, because only
986          * NMI should be common and it does not enable IRQs and
987          * cannot get reschedule ticks.
988          *
989          * "trace" is 0 for the NMI handler only, because irq-tracing
990          * is fundamentally NMI-unsafe. (we cannot change the soft and
991          * hard flags at once, atomically)
992          */
993         .macro paranoidexit trace=1
994         /* ebx: no swapgs flag */
995 paranoid_exit\trace:
996         testl %ebx,%ebx                         /* swapgs needed? */
997         jnz paranoid_restore\trace
998         testl $3,CS(%rsp)
999         jnz   paranoid_userspace\trace
1000 paranoid_swapgs\trace:
1001         .if \trace
1002         TRACE_IRQS_IRETQ 0
1003         .endif
1004         SWAPGS_UNSAFE_STACK
1005 paranoid_restore\trace:
1006         RESTORE_ALL 8
1007         jmp irq_return
1008 paranoid_userspace\trace:
1009         GET_THREAD_INFO(%rcx)
1010         movl TI_flags(%rcx),%ebx
1011         andl $_TIF_WORK_MASK,%ebx
1012         jz paranoid_swapgs\trace
1013         movq %rsp,%rdi                  /* &pt_regs */
1014         call sync_regs
1015         movq %rax,%rsp                  /* switch stack for scheduling */
1016         testl $_TIF_NEED_RESCHED,%ebx
1017         jnz paranoid_schedule\trace
1018         movl %ebx,%edx                  /* arg3: thread flags */
1019         .if \trace
1020         TRACE_IRQS_ON
1021         .endif
1022         ENABLE_INTERRUPTS(CLBR_NONE)
1023         xorl %esi,%esi                  /* arg2: oldset */
1024         movq %rsp,%rdi                  /* arg1: &pt_regs */
1025         call do_notify_resume
1026         DISABLE_INTERRUPTS(CLBR_NONE)
1027         .if \trace
1028         TRACE_IRQS_OFF
1029         .endif
1030         jmp paranoid_userspace\trace
1031 paranoid_schedule\trace:
1032         .if \trace
1033         TRACE_IRQS_ON
1034         .endif
1035         ENABLE_INTERRUPTS(CLBR_ANY)
1036         call schedule
1037         DISABLE_INTERRUPTS(CLBR_ANY)
1038         .if \trace
1039         TRACE_IRQS_OFF
1040         .endif
1041         jmp paranoid_userspace\trace
1042         CFI_ENDPROC
1043         .endm
1044
1045 /*
1046  * Exception entry point. This expects an error code/orig_rax on the stack
1047  * and the exception handler in %rax.   
1048  */                                             
1049 KPROBE_ENTRY(error_entry)
1050         _frame RDI
1051         CFI_REL_OFFSET rax,0
1052         /* rdi slot contains rax, oldrax contains error code */
1053         cld     
1054         subq  $14*8,%rsp
1055         CFI_ADJUST_CFA_OFFSET   (14*8)
1056         movq %rsi,13*8(%rsp)
1057         CFI_REL_OFFSET  rsi,RSI
1058         movq 14*8(%rsp),%rsi    /* load rax from rdi slot */
1059         CFI_REGISTER    rax,rsi
1060         movq %rdx,12*8(%rsp)
1061         CFI_REL_OFFSET  rdx,RDX
1062         movq %rcx,11*8(%rsp)
1063         CFI_REL_OFFSET  rcx,RCX
1064         movq %rsi,10*8(%rsp)    /* store rax */ 
1065         CFI_REL_OFFSET  rax,RAX
1066         movq %r8, 9*8(%rsp)
1067         CFI_REL_OFFSET  r8,R8
1068         movq %r9, 8*8(%rsp)
1069         CFI_REL_OFFSET  r9,R9
1070         movq %r10,7*8(%rsp)
1071         CFI_REL_OFFSET  r10,R10
1072         movq %r11,6*8(%rsp)
1073         CFI_REL_OFFSET  r11,R11
1074         movq %rbx,5*8(%rsp) 
1075         CFI_REL_OFFSET  rbx,RBX
1076         movq %rbp,4*8(%rsp) 
1077         CFI_REL_OFFSET  rbp,RBP
1078         movq %r12,3*8(%rsp) 
1079         CFI_REL_OFFSET  r12,R12
1080         movq %r13,2*8(%rsp) 
1081         CFI_REL_OFFSET  r13,R13
1082         movq %r14,1*8(%rsp) 
1083         CFI_REL_OFFSET  r14,R14
1084         movq %r15,(%rsp) 
1085         CFI_REL_OFFSET  r15,R15
1086         xorl %ebx,%ebx  
1087         testl $3,CS(%rsp)
1088         je  error_kernelspace
1089 error_swapgs:   
1090         SWAPGS
1091 error_sti:
1092         TRACE_IRQS_OFF
1093         movq %rdi,RDI(%rsp)     
1094         CFI_REL_OFFSET  rdi,RDI
1095         movq %rsp,%rdi
1096         movq ORIG_RAX(%rsp),%rsi        /* get error code */ 
1097         movq $-1,ORIG_RAX(%rsp)
1098         call *%rax
1099         /* ebx: no swapgs flag (1: don't need swapgs, 0: need it) */
1100 error_exit:
1101         movl %ebx,%eax
1102         RESTORE_REST
1103         DISABLE_INTERRUPTS(CLBR_NONE)
1104         TRACE_IRQS_OFF
1105         GET_THREAD_INFO(%rcx)   
1106         testl %eax,%eax
1107         jne  retint_kernel
1108         LOCKDEP_SYS_EXIT_IRQ
1109         movl  TI_flags(%rcx),%edx
1110         movl  $_TIF_WORK_MASK,%edi
1111         andl  %edi,%edx
1112         jnz  retint_careful
1113         jmp retint_swapgs
1114         CFI_ENDPROC
1115
1116 error_kernelspace:
1117         incl %ebx
1118        /* There are two places in the kernel that can potentially fault with
1119           usergs. Handle them here. The exception handlers after
1120            iret run with kernel gs again, so don't set the user space flag.
1121            B stepping K8s sometimes report an truncated RIP for IRET 
1122            exceptions returning to compat mode. Check for these here too. */
1123         leaq irq_return(%rip),%rcx
1124         cmpq %rcx,RIP(%rsp)
1125         je   error_swapgs
1126         movl %ecx,%ecx  /* zero extend */
1127         cmpq %rcx,RIP(%rsp)
1128         je   error_swapgs
1129         cmpq $gs_change,RIP(%rsp)
1130         je   error_swapgs
1131         jmp  error_sti
1132 KPROBE_END(error_entry)
1133         
1134        /* Reload gs selector with exception handling */
1135        /* edi:  new selector */ 
1136 ENTRY(native_load_gs_index)
1137         CFI_STARTPROC
1138         pushf
1139         CFI_ADJUST_CFA_OFFSET 8
1140         DISABLE_INTERRUPTS(CLBR_ANY | ~(CLBR_RDI))
1141         SWAPGS
1142 gs_change:     
1143         movl %edi,%gs   
1144 2:      mfence          /* workaround */
1145         SWAPGS
1146         popf
1147         CFI_ADJUST_CFA_OFFSET -8
1148         ret
1149         CFI_ENDPROC
1150 ENDPROC(native_load_gs_index)
1151        
1152         .section __ex_table,"a"
1153         .align 8
1154         .quad gs_change,bad_gs
1155         .previous
1156         .section .fixup,"ax"
1157         /* running with kernelgs */
1158 bad_gs: 
1159         SWAPGS                  /* switch back to user gs */
1160         xorl %eax,%eax
1161         movl %eax,%gs
1162         jmp  2b
1163         .previous       
1164         
1165 /*
1166  * Create a kernel thread.
1167  *
1168  * C extern interface:
1169  *      extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
1170  *
1171  * asm input arguments:
1172  *      rdi: fn, rsi: arg, rdx: flags
1173  */
1174 ENTRY(kernel_thread)
1175         CFI_STARTPROC
1176         FAKE_STACK_FRAME $child_rip
1177         SAVE_ALL
1178
1179         # rdi: flags, rsi: usp, rdx: will be &pt_regs
1180         movq %rdx,%rdi
1181         orq  kernel_thread_flags(%rip),%rdi
1182         movq $-1, %rsi
1183         movq %rsp, %rdx
1184
1185         xorl %r8d,%r8d
1186         xorl %r9d,%r9d
1187         
1188         # clone now
1189         call do_fork
1190         movq %rax,RAX(%rsp)
1191         xorl %edi,%edi
1192
1193         /*
1194          * It isn't worth to check for reschedule here,
1195          * so internally to the x86_64 port you can rely on kernel_thread()
1196          * not to reschedule the child before returning, this avoids the need
1197          * of hacks for example to fork off the per-CPU idle tasks.
1198          * [Hopefully no generic code relies on the reschedule -AK]     
1199          */
1200         RESTORE_ALL
1201         UNFAKE_STACK_FRAME
1202         ret
1203         CFI_ENDPROC
1204 ENDPROC(kernel_thread)
1205         
1206 child_rip:
1207         pushq $0                # fake return address
1208         CFI_STARTPROC
1209         /*
1210          * Here we are in the child and the registers are set as they were
1211          * at kernel_thread() invocation in the parent.
1212          */
1213         movq %rdi, %rax
1214         movq %rsi, %rdi
1215         call *%rax
1216         # exit
1217         mov %eax, %edi
1218         call do_exit
1219         CFI_ENDPROC
1220 ENDPROC(child_rip)
1221
1222 /*
1223  * execve(). This function needs to use IRET, not SYSRET, to set up all state properly.
1224  *
1225  * C extern interface:
1226  *       extern long execve(char *name, char **argv, char **envp)
1227  *
1228  * asm input arguments:
1229  *      rdi: name, rsi: argv, rdx: envp
1230  *
1231  * We want to fallback into:
1232  *      extern long sys_execve(char *name, char **argv,char **envp, struct pt_regs *regs)
1233  *
1234  * do_sys_execve asm fallback arguments:
1235  *      rdi: name, rsi: argv, rdx: envp, rcx: fake frame on the stack
1236  */
1237 ENTRY(kernel_execve)
1238         CFI_STARTPROC
1239         FAKE_STACK_FRAME $0
1240         SAVE_ALL        
1241         movq %rsp,%rcx
1242         call sys_execve
1243         movq %rax, RAX(%rsp)    
1244         RESTORE_REST
1245         testq %rax,%rax
1246         je int_ret_from_sys_call
1247         RESTORE_ARGS
1248         UNFAKE_STACK_FRAME
1249         ret
1250         CFI_ENDPROC
1251 ENDPROC(kernel_execve)
1252
1253 KPROBE_ENTRY(page_fault)
1254         errorentry do_page_fault
1255 KPROBE_END(page_fault)
1256
1257 ENTRY(coprocessor_error)
1258         zeroentry do_coprocessor_error
1259 END(coprocessor_error)
1260
1261 ENTRY(simd_coprocessor_error)
1262         zeroentry do_simd_coprocessor_error     
1263 END(simd_coprocessor_error)
1264
1265 ENTRY(device_not_available)
1266         zeroentry do_device_not_available
1267 END(device_not_available)
1268
1269         /* runs on exception stack */
1270 KPROBE_ENTRY(debug)
1271         INTR_FRAME
1272         PARAVIRT_ADJUST_EXCEPTION_FRAME
1273         pushq $0
1274         CFI_ADJUST_CFA_OFFSET 8         
1275         paranoidentry do_debug, DEBUG_STACK
1276         paranoidexit
1277 KPROBE_END(debug)
1278
1279         /* runs on exception stack */   
1280 KPROBE_ENTRY(nmi)
1281         INTR_FRAME
1282         PARAVIRT_ADJUST_EXCEPTION_FRAME
1283         pushq $-1
1284         CFI_ADJUST_CFA_OFFSET 8
1285         paranoidentry do_nmi, 0, 0
1286 #ifdef CONFIG_TRACE_IRQFLAGS
1287         paranoidexit 0
1288 #else
1289         jmp paranoid_exit1
1290         CFI_ENDPROC
1291 #endif
1292 KPROBE_END(nmi)
1293
1294 KPROBE_ENTRY(int3)
1295         INTR_FRAME
1296         PARAVIRT_ADJUST_EXCEPTION_FRAME
1297         pushq $0
1298         CFI_ADJUST_CFA_OFFSET 8
1299         paranoidentry do_int3, DEBUG_STACK
1300         jmp paranoid_exit1
1301         CFI_ENDPROC
1302 KPROBE_END(int3)
1303
1304 ENTRY(overflow)
1305         zeroentry do_overflow
1306 END(overflow)
1307
1308 ENTRY(bounds)
1309         zeroentry do_bounds
1310 END(bounds)
1311
1312 ENTRY(invalid_op)
1313         zeroentry do_invalid_op 
1314 END(invalid_op)
1315
1316 ENTRY(coprocessor_segment_overrun)
1317         zeroentry do_coprocessor_segment_overrun
1318 END(coprocessor_segment_overrun)
1319
1320         /* runs on exception stack */
1321 ENTRY(double_fault)
1322         XCPT_FRAME
1323         PARAVIRT_ADJUST_EXCEPTION_FRAME
1324         paranoidentry do_double_fault
1325         jmp paranoid_exit1
1326         CFI_ENDPROC
1327 END(double_fault)
1328
1329 ENTRY(invalid_TSS)
1330         errorentry do_invalid_TSS
1331 END(invalid_TSS)
1332
1333 ENTRY(segment_not_present)
1334         errorentry do_segment_not_present
1335 END(segment_not_present)
1336
1337         /* runs on exception stack */
1338 ENTRY(stack_segment)
1339         XCPT_FRAME
1340         PARAVIRT_ADJUST_EXCEPTION_FRAME
1341         paranoidentry do_stack_segment
1342         jmp paranoid_exit1
1343         CFI_ENDPROC
1344 END(stack_segment)
1345
1346 KPROBE_ENTRY(general_protection)
1347         errorentry do_general_protection
1348 KPROBE_END(general_protection)
1349
1350 ENTRY(alignment_check)
1351         errorentry do_alignment_check
1352 END(alignment_check)
1353
1354 ENTRY(divide_error)
1355         zeroentry do_divide_error
1356 END(divide_error)
1357
1358 ENTRY(spurious_interrupt_bug)
1359         zeroentry do_spurious_interrupt_bug
1360 END(spurious_interrupt_bug)
1361
1362 #ifdef CONFIG_X86_MCE
1363         /* runs on exception stack */
1364 ENTRY(machine_check)
1365         INTR_FRAME
1366         PARAVIRT_ADJUST_EXCEPTION_FRAME
1367         pushq $0
1368         CFI_ADJUST_CFA_OFFSET 8 
1369         paranoidentry do_machine_check
1370         jmp paranoid_exit1
1371         CFI_ENDPROC
1372 END(machine_check)
1373 #endif
1374
1375 /* Call softirq on interrupt stack. Interrupts are off. */
1376 ENTRY(call_softirq)
1377         CFI_STARTPROC
1378         push %rbp
1379         CFI_ADJUST_CFA_OFFSET   8
1380         CFI_REL_OFFSET rbp,0
1381         mov  %rsp,%rbp
1382         CFI_DEF_CFA_REGISTER rbp
1383         incl %gs:pda_irqcount
1384         cmove %gs:pda_irqstackptr,%rsp
1385         push  %rbp                      # backlink for old unwinder
1386         call __do_softirq
1387         leaveq
1388         CFI_DEF_CFA_REGISTER    rsp
1389         CFI_ADJUST_CFA_OFFSET   -8
1390         decl %gs:pda_irqcount
1391         ret
1392         CFI_ENDPROC
1393 ENDPROC(call_softirq)
1394
1395 KPROBE_ENTRY(ignore_sysret)
1396         CFI_STARTPROC
1397         mov $-ENOSYS,%eax
1398         sysret
1399         CFI_ENDPROC
1400 ENDPROC(ignore_sysret)
1401
1402 #ifdef CONFIG_XEN
1403 ENTRY(xen_hypervisor_callback)
1404         zeroentry xen_do_hypervisor_callback
1405 END(xen_hypervisor_callback)
1406
1407 /*
1408 # A note on the "critical region" in our callback handler.
1409 # We want to avoid stacking callback handlers due to events occurring
1410 # during handling of the last event. To do this, we keep events disabled
1411 # until we've done all processing. HOWEVER, we must enable events before
1412 # popping the stack frame (can't be done atomically) and so it would still
1413 # be possible to get enough handler activations to overflow the stack.
1414 # Although unlikely, bugs of that kind are hard to track down, so we'd
1415 # like to avoid the possibility.
1416 # So, on entry to the handler we detect whether we interrupted an
1417 # existing activation in its critical region -- if so, we pop the current
1418 # activation and restart the handler using the previous one.
1419 */
1420 ENTRY(xen_do_hypervisor_callback)   # do_hypervisor_callback(struct *pt_regs)
1421         CFI_STARTPROC
1422 /* Since we don't modify %rdi, evtchn_do_upall(struct *pt_regs) will
1423    see the correct pointer to the pt_regs */
1424         movq %rdi, %rsp            # we don't return, adjust the stack frame
1425         CFI_ENDPROC
1426         CFI_DEFAULT_STACK
1427 11:     incl %gs:pda_irqcount
1428         movq %rsp,%rbp
1429         CFI_DEF_CFA_REGISTER rbp
1430         cmovzq %gs:pda_irqstackptr,%rsp
1431         pushq %rbp                      # backlink for old unwinder
1432         call xen_evtchn_do_upcall
1433         popq %rsp
1434         CFI_DEF_CFA_REGISTER rsp
1435         decl %gs:pda_irqcount
1436         jmp  error_exit
1437         CFI_ENDPROC
1438 END(do_hypervisor_callback)
1439
1440 /*
1441 # Hypervisor uses this for application faults while it executes.
1442 # We get here for two reasons:
1443 #  1. Fault while reloading DS, ES, FS or GS
1444 #  2. Fault while executing IRET
1445 # Category 1 we do not need to fix up as Xen has already reloaded all segment
1446 # registers that could be reloaded and zeroed the others.
1447 # Category 2 we fix up by killing the current process. We cannot use the
1448 # normal Linux return path in this case because if we use the IRET hypercall
1449 # to pop the stack frame we end up in an infinite loop of failsafe callbacks.
1450 # We distinguish between categories by comparing each saved segment register
1451 # with its current contents: any discrepancy means we in category 1.
1452 */
1453 ENTRY(xen_failsafe_callback)
1454         framesz = (RIP-0x30)    /* workaround buggy gas */
1455         _frame framesz
1456         CFI_REL_OFFSET rcx, 0
1457         CFI_REL_OFFSET r11, 8
1458         movw %ds,%cx
1459         cmpw %cx,0x10(%rsp)
1460         CFI_REMEMBER_STATE
1461         jne 1f
1462         movw %es,%cx
1463         cmpw %cx,0x18(%rsp)
1464         jne 1f
1465         movw %fs,%cx
1466         cmpw %cx,0x20(%rsp)
1467         jne 1f
1468         movw %gs,%cx
1469         cmpw %cx,0x28(%rsp)
1470         jne 1f
1471         /* All segments match their saved values => Category 2 (Bad IRET). */
1472         movq (%rsp),%rcx
1473         CFI_RESTORE rcx
1474         movq 8(%rsp),%r11
1475         CFI_RESTORE r11
1476         addq $0x30,%rsp
1477         CFI_ADJUST_CFA_OFFSET -0x30
1478         pushq $0
1479         CFI_ADJUST_CFA_OFFSET 8
1480         pushq %r11
1481         CFI_ADJUST_CFA_OFFSET 8
1482         pushq %rcx
1483         CFI_ADJUST_CFA_OFFSET 8
1484         jmp general_protection
1485         CFI_RESTORE_STATE
1486 1:      /* Segment mismatch => Category 1 (Bad segment). Retry the IRET. */
1487         movq (%rsp),%rcx
1488         CFI_RESTORE rcx
1489         movq 8(%rsp),%r11
1490         CFI_RESTORE r11
1491         addq $0x30,%rsp
1492         CFI_ADJUST_CFA_OFFSET -0x30
1493         pushq $0
1494         CFI_ADJUST_CFA_OFFSET 8
1495         SAVE_ALL
1496         jmp error_exit
1497         CFI_ENDPROC
1498 END(xen_failsafe_callback)
1499
1500 #endif /* CONFIG_XEN */