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