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