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