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