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