arch/x86/kernel/entry_32.S

   1 /*
   2  *
   3  *  Copyright (C) 1991, 1992  Linus Torvalds
   4  */
   5
   6 /*
   7  * entry.S contains the system-call and fault low-level handling routines.
   8  * This also contains the timer-interrupt handler, as well as all interrupts
   9  * and faults that can result in a task-switch.
  10  *
  11  * NOTE: This code handles signal-recognition, which happens every time
  12  * after a timer-interrupt and after each system call.
  13  *
  14  * I changed all the .align's to 4 (16 byte alignment), as that's faster
  15  * on a 486.
  16  *
  17  * Stack layout in 'syscall_exit':
  18  *      ptrace needs to have all regs on the stack.
  19  *      if the order here is changed, it needs to be
  20  *      updated in fork.c:copy_process, signal.c:do_signal,
  21  *      ptrace.c and ptrace.h
  22  *
  23  *       0(%esp) - %ebx
  24  *       4(%esp) - %ecx
  25  *       8(%esp) - %edx
  26  *       C(%esp) - %esi
  27  *      10(%esp) - %edi
  28  *      14(%esp) - %ebp
  29  *      18(%esp) - %eax
  30  *      1C(%esp) - %ds
  31  *      20(%esp) - %es
  32  *      24(%esp) - %fs
  33  *      28(%esp) - %gs          saved iff !CONFIG_X86_32_LAZY_GS
  34  *      2C(%esp) - orig_eax
  35  *      30(%esp) - %eip
  36  *      34(%esp) - %cs
  37  *      38(%esp) - %eflags
  38  *      3C(%esp) - %oldesp
  39  *      40(%esp) - %oldss
  40  *
  41  * "current" is in register %ebx during any slow entries.
  42  */
  43
  44 #include <linux/linkage.h>
  45 #include <asm/thread_info.h>
  46 #include <asm/irqflags.h>
  47 #include <asm/errno.h>
  48 #include <asm/segment.h>
  49 #include <asm/smp.h>
  50 #include <asm/page_types.h>
  51 #include <asm/percpu.h>
  52 #include <asm/dwarf2.h>
  53 #include <asm/processor-flags.h>
  54 #include <asm/ftrace.h>
  55 #include <asm/irq_vectors.h>
  56
  57 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
  58 #include <linux/elf-em.h>
  59 #define AUDIT_ARCH_I386         (EM_386|__AUDIT_ARCH_LE)
  60 #define __AUDIT_ARCH_LE    0x40000000
  61
  62 #ifndef CONFIG_AUDITSYSCALL
  63 #define sysenter_audit  syscall_trace_entry
  64 #define sysexit_audit   syscall_exit_work
  65 #endif
  66
  67 /*
  68  * We use macros for low-level operations which need to be overridden
  69  * for paravirtualization.  The following will never clobber any registers:
  70  *   INTERRUPT_RETURN (aka. "iret")
  71  *   GET_CR0_INTO_EAX (aka. "movl %cr0, %eax")
  72  *   ENABLE_INTERRUPTS_SYSEXIT (aka "sti; sysexit").
  73  *
  74  * For DISABLE_INTERRUPTS/ENABLE_INTERRUPTS (aka "cli"/"sti"), you must
  75  * specify what registers can be overwritten (CLBR_NONE, CLBR_EAX/EDX/ECX/ANY).
  76  * Allowing a register to be clobbered can shrink the paravirt replacement
  77  * enough to patch inline, increasing performance.
  78  */
  79
  80 #define nr_syscalls ((syscall_table_size)/4)
  81
  82 #ifdef CONFIG_PREEMPT
  83 #define preempt_stop(clobbers)  DISABLE_INTERRUPTS(clobbers); TRACE_IRQS_OFF
  84 #else
  85 #define preempt_stop(clobbers)
  86 #define resume_kernel           restore_all
  87 #endif
  88
  89 .macro TRACE_IRQS_IRET
  90 #ifdef CONFIG_TRACE_IRQFLAGS
  91         testl $X86_EFLAGS_IF,PT_EFLAGS(%esp)     # interrupts off?
  92         jz 1f
  93         TRACE_IRQS_ON
  94 1:
  95 #endif
  96 .endm
  97
  98 #ifdef CONFIG_VM86
  99 #define resume_userspace_sig    check_userspace
 100 #else
 101 #define resume_userspace_sig    resume_userspace
 102 #endif
 103
 104 /*
 105  * User gs save/restore
 106  *
 107  * %gs is used for userland TLS and kernel only uses it for stack
 108  * canary which is required to be at %gs:20 by gcc.  Read the comment
 109  * at the top of stackprotector.h for more info.
 110  *
 111  * Local labels 98 and 99 are used.
 112  */
 113 #ifdef CONFIG_X86_32_LAZY_GS
 114
 115  /* unfortunately push/pop can't be no-op */
 116 .macro PUSH_GS
 117         pushl $0
 118         CFI_ADJUST_CFA_OFFSET 4
 119 .endm
 120 .macro POP_GS pop=0
 121         addl $(4 + \pop), %esp
 122         CFI_ADJUST_CFA_OFFSET -(4 + \pop)
 123 .endm
 124 .macro POP_GS_EX
 125 .endm
 126
 127  /* all the rest are no-op */
 128 .macro PTGS_TO_GS
 129 .endm
 130 .macro PTGS_TO_GS_EX
 131 .endm
 132 .macro GS_TO_REG reg
 133 .endm
 134 .macro REG_TO_PTGS reg
 135 .endm
 136 .macro SET_KERNEL_GS reg
 137 .endm
 138
 139 #else   /* CONFIG_X86_32_LAZY_GS */
 140
 141 .macro PUSH_GS
 142         pushl %gs
 143         CFI_ADJUST_CFA_OFFSET 4
 144         /*CFI_REL_OFFSET gs, 0*/
 145 .endm
 146
 147 .macro POP_GS pop=0
 148 98:     popl %gs
 149         CFI_ADJUST_CFA_OFFSET -4
 150         /*CFI_RESTORE gs*/
 151   .if \pop <> 0
 152         add $\pop, %esp
 153         CFI_ADJUST_CFA_OFFSET -\pop
 154   .endif
 155 .endm
 156 .macro POP_GS_EX
 157 .pushsection .fixup, "ax"
 158 99:     movl $0, (%esp)
 159         jmp 98b
 160 .section __ex_table, "a"
 161         .align 4
 162         .long 98b, 99b
 163 .popsection
 164 .endm
 165
 166 .macro PTGS_TO_GS
 167 98:     mov PT_GS(%esp), %gs
 168 .endm
 169 .macro PTGS_TO_GS_EX
 170 .pushsection .fixup, "ax"
 171 99:     movl $0, PT_GS(%esp)
 172         jmp 98b
 173 .section __ex_table, "a"
 174         .align 4
 175         .long 98b, 99b
 176 .popsection
 177 .endm
 178
 179 .macro GS_TO_REG reg
 180         movl %gs, \reg
 181         /*CFI_REGISTER gs, \reg*/
 182 .endm
 183 .macro REG_TO_PTGS reg
 184         movl \reg, PT_GS(%esp)
 185         /*CFI_REL_OFFSET gs, PT_GS*/
 186 .endm
 187 .macro SET_KERNEL_GS reg
 188         movl $(__KERNEL_STACK_CANARY), \reg
 189         movl \reg, %gs
 190 .endm
 191
 192 #endif  /* CONFIG_X86_32_LAZY_GS */
 193
 194 .macro SAVE_ALL
 195         cld
 196         PUSH_GS
 197         pushl %fs
 198         CFI_ADJUST_CFA_OFFSET 4
 199         /*CFI_REL_OFFSET fs, 0;*/
 200         pushl %es
 201         CFI_ADJUST_CFA_OFFSET 4
 202         /*CFI_REL_OFFSET es, 0;*/
 203         pushl %ds
 204         CFI_ADJUST_CFA_OFFSET 4
 205         /*CFI_REL_OFFSET ds, 0;*/
 206         pushl %eax
 207         CFI_ADJUST_CFA_OFFSET 4
 208         CFI_REL_OFFSET eax, 0
 209         pushl %ebp
 210         CFI_ADJUST_CFA_OFFSET 4
 211         CFI_REL_OFFSET ebp, 0
 212         pushl %edi
 213         CFI_ADJUST_CFA_OFFSET 4
 214         CFI_REL_OFFSET edi, 0
 215         pushl %esi
 216         CFI_ADJUST_CFA_OFFSET 4
 217         CFI_REL_OFFSET esi, 0
 218         pushl %edx
 219         CFI_ADJUST_CFA_OFFSET 4
 220         CFI_REL_OFFSET edx, 0
 221         pushl %ecx
 222         CFI_ADJUST_CFA_OFFSET 4
 223         CFI_REL_OFFSET ecx, 0
 224         pushl %ebx
 225         CFI_ADJUST_CFA_OFFSET 4
 226         CFI_REL_OFFSET ebx, 0
 227         movl $(__USER_DS), %edx
 228         movl %edx, %ds
 229         movl %edx, %es
 230         movl $(__KERNEL_PERCPU), %edx
 231         movl %edx, %fs
 232         SET_KERNEL_GS %edx
 233 .endm
 234
 235 .macro RESTORE_INT_REGS
 236         popl %ebx
 237         CFI_ADJUST_CFA_OFFSET -4
 238         CFI_RESTORE ebx
 239         popl %ecx
 240         CFI_ADJUST_CFA_OFFSET -4
 241         CFI_RESTORE ecx
 242         popl %edx
 243         CFI_ADJUST_CFA_OFFSET -4
 244         CFI_RESTORE edx
 245         popl %esi
 246         CFI_ADJUST_CFA_OFFSET -4
 247         CFI_RESTORE esi
 248         popl %edi
 249         CFI_ADJUST_CFA_OFFSET -4
 250         CFI_RESTORE edi
 251         popl %ebp
 252         CFI_ADJUST_CFA_OFFSET -4
 253         CFI_RESTORE ebp
 254         popl %eax
 255         CFI_ADJUST_CFA_OFFSET -4
 256         CFI_RESTORE eax
 257 .endm
 258
 259 .macro RESTORE_REGS pop=0
 260         RESTORE_INT_REGS
 261 1:      popl %ds
 262         CFI_ADJUST_CFA_OFFSET -4
 263         /*CFI_RESTORE ds;*/
 264 2:      popl %es
 265         CFI_ADJUST_CFA_OFFSET -4
 266         /*CFI_RESTORE es;*/
 267 3:      popl %fs
 268         CFI_ADJUST_CFA_OFFSET -4
 269         /*CFI_RESTORE fs;*/
 270         POP_GS \pop
 271 .pushsection .fixup, "ax"
 272 4:      movl $0, (%esp)
 273         jmp 1b
 274 5:      movl $0, (%esp)
 275         jmp 2b
 276 6:      movl $0, (%esp)
 277         jmp 3b
 278 .section __ex_table, "a"
 279         .align 4
 280         .long 1b, 4b
 281         .long 2b, 5b
 282         .long 3b, 6b
 283 .popsection
 284         POP_GS_EX
 285 .endm
 286
 287 .macro RING0_INT_FRAME
 288         CFI_STARTPROC simple
 289         CFI_SIGNAL_FRAME
 290         CFI_DEF_CFA esp, 3*4
 291         /*CFI_OFFSET cs, -2*4;*/
 292         CFI_OFFSET eip, -3*4
 293 .endm
 294
 295 .macro RING0_EC_FRAME
 296         CFI_STARTPROC simple
 297         CFI_SIGNAL_FRAME
 298         CFI_DEF_CFA esp, 4*4
 299         /*CFI_OFFSET cs, -2*4;*/
 300         CFI_OFFSET eip, -3*4
 301 .endm
 302
 303 .macro RING0_PTREGS_FRAME
 304         CFI_STARTPROC simple
 305         CFI_SIGNAL_FRAME
 306         CFI_DEF_CFA esp, PT_OLDESP-PT_EBX
 307         /*CFI_OFFSET cs, PT_CS-PT_OLDESP;*/
 308         CFI_OFFSET eip, PT_EIP-PT_OLDESP
 309         /*CFI_OFFSET es, PT_ES-PT_OLDESP;*/
 310         /*CFI_OFFSET ds, PT_DS-PT_OLDESP;*/
 311         CFI_OFFSET eax, PT_EAX-PT_OLDESP
 312         CFI_OFFSET ebp, PT_EBP-PT_OLDESP
 313         CFI_OFFSET edi, PT_EDI-PT_OLDESP
 314         CFI_OFFSET esi, PT_ESI-PT_OLDESP
 315         CFI_OFFSET edx, PT_EDX-PT_OLDESP
 316         CFI_OFFSET ecx, PT_ECX-PT_OLDESP
 317         CFI_OFFSET ebx, PT_EBX-PT_OLDESP
 318 .endm
 319
 320 ENTRY(ret_from_fork)
 321         CFI_STARTPROC
 322         pushl %eax
 323         CFI_ADJUST_CFA_OFFSET 4
 324         call schedule_tail
 325         GET_THREAD_INFO(%ebp)
 326         popl %eax
 327         CFI_ADJUST_CFA_OFFSET -4
 328         pushl $0x0202                   # Reset kernel eflags
 329         CFI_ADJUST_CFA_OFFSET 4
 330         popfl
 331         CFI_ADJUST_CFA_OFFSET -4
 332         jmp syscall_exit
 333         CFI_ENDPROC
 334 END(ret_from_fork)
 335
 336 /*
 337  * Return to user mode is not as complex as all this looks,
 338  * but we want the default path for a system call return to
 339  * go as quickly as possible which is why some of this is
 340  * less clear than it otherwise should be.
 341  */
 342
 343         # userspace resumption stub bypassing syscall exit tracing
 344         ALIGN
 345         RING0_PTREGS_FRAME
 346 ret_from_exception:
 347         preempt_stop(CLBR_ANY)
 348 ret_from_intr:
 349         GET_THREAD_INFO(%ebp)
 350 check_userspace:
 351         movl PT_EFLAGS(%esp), %eax      # mix EFLAGS and CS
 352         movb PT_CS(%esp), %al
 353         andl $(X86_EFLAGS_VM | SEGMENT_RPL_MASK), %eax
 354         cmpl $USER_RPL, %eax
 355         jb resume_kernel                # not returning to v8086 or userspace
 356
 357 ENTRY(resume_userspace)
 358         LOCKDEP_SYS_EXIT
 359         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
 360                                         # setting need_resched or sigpending
 361                                         # between sampling and the iret
 362         TRACE_IRQS_OFF
 363         movl TI_flags(%ebp), %ecx
 364         andl $_TIF_WORK_MASK, %ecx      # is there any work to be done on
 365                                         # int/exception return?
 366         jne work_pending
 367         jmp restore_all
 368 END(ret_from_exception)
 369
 370 #ifdef CONFIG_PREEMPT
 371 ENTRY(resume_kernel)
 372         DISABLE_INTERRUPTS(CLBR_ANY)
 373         cmpl $0,TI_preempt_count(%ebp)  # non-zero preempt_count ?
 374         jnz restore_all
 375 need_resched:
 376         movl TI_flags(%ebp), %ecx       # need_resched set ?
 377         testb $_TIF_NEED_RESCHED, %cl
 378         jz restore_all
 379         testl $X86_EFLAGS_IF,PT_EFLAGS(%esp)    # interrupts off (exception path) ?
 380         jz restore_all
 381         call preempt_schedule_irq
 382         jmp need_resched
 383 END(resume_kernel)
 384 #endif
 385         CFI_ENDPROC
 386
 387 /* SYSENTER_RETURN points to after the "sysenter" instruction in
 388    the vsyscall page.  See vsyscall-sysentry.S, which defines the symbol.  */
 389
 390         # sysenter call handler stub
 391 ENTRY(ia32_sysenter_target)
 392         CFI_STARTPROC simple
 393         CFI_SIGNAL_FRAME
 394         CFI_DEF_CFA esp, 0
 395         CFI_REGISTER esp, ebp
 396         movl TSS_sysenter_sp0(%esp),%esp
 397 sysenter_past_esp:
 398         /*
 399          * Interrupts are disabled here, but we can't trace it until
 400          * enough kernel state to call TRACE_IRQS_OFF can be called - but
 401          * we immediately enable interrupts at that point anyway.
 402          */
 403         pushl $(__USER_DS)
 404         CFI_ADJUST_CFA_OFFSET 4
 405         /*CFI_REL_OFFSET ss, 0*/
 406         pushl %ebp
 407         CFI_ADJUST_CFA_OFFSET 4
 408         CFI_REL_OFFSET esp, 0
 409         pushfl
 410         orl $X86_EFLAGS_IF, (%esp)
 411         CFI_ADJUST_CFA_OFFSET 4
 412         pushl $(__USER_CS)
 413         CFI_ADJUST_CFA_OFFSET 4
 414         /*CFI_REL_OFFSET cs, 0*/
 415         /*
 416          * Push current_thread_info()->sysenter_return to the stack.
 417          * A tiny bit of offset fixup is necessary - 4*4 means the 4 words
 418          * pushed above; +8 corresponds to copy_thread's esp0 setting.
 419          */
 420         pushl (TI_sysenter_return-THREAD_SIZE+8+4*4)(%esp)
 421         CFI_ADJUST_CFA_OFFSET 4
 422         CFI_REL_OFFSET eip, 0
 423
 424         pushl %eax
 425         CFI_ADJUST_CFA_OFFSET 4
 426         SAVE_ALL
 427         ENABLE_INTERRUPTS(CLBR_NONE)
 428
 429 /*
 430  * Load the potential sixth argument from user stack.
 431  * Careful about security.
 432  */
 433         cmpl $__PAGE_OFFSET-3,%ebp
 434         jae syscall_fault
 435 1:      movl (%ebp),%ebp
 436         movl %ebp,PT_EBP(%esp)
 437 .section __ex_table,"a"
 438         .align 4
 439         .long 1b,syscall_fault
 440 .previous
 441
 442         GET_THREAD_INFO(%ebp)
 443
 444         testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp)
 445         jnz sysenter_audit
 446 sysenter_do_call:
 447         cmpl $(nr_syscalls), %eax
 448         jae syscall_badsys
 449         call *sys_call_table(,%eax,4)
 450         movl %eax,PT_EAX(%esp)
 451         LOCKDEP_SYS_EXIT
 452         DISABLE_INTERRUPTS(CLBR_ANY)
 453         TRACE_IRQS_OFF
 454         movl TI_flags(%ebp), %ecx
 455         testl $_TIF_ALLWORK_MASK, %ecx
 456         jne sysexit_audit
 457 sysenter_exit:
 458 /* if something modifies registers it must also disable sysexit */
 459         movl PT_EIP(%esp), %edx
 460         movl PT_OLDESP(%esp), %ecx
 461         xorl %ebp,%ebp
 462         TRACE_IRQS_ON
 463 1:      mov  PT_FS(%esp), %fs
 464         PTGS_TO_GS
 465         ENABLE_INTERRUPTS_SYSEXIT
 466
 467 #ifdef CONFIG_AUDITSYSCALL
 468 sysenter_audit:
 469         testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags(%ebp)
 470         jnz syscall_trace_entry
 471         addl $4,%esp
 472         CFI_ADJUST_CFA_OFFSET -4
 473         /* %esi already in 8(%esp)         6th arg: 4th syscall arg */
 474         /* %edx already in 4(%esp)         5th arg: 3rd syscall arg */
 475         /* %ecx already in 0(%esp)         4th arg: 2nd syscall arg */
 476         movl %ebx,%ecx                  /* 3rd arg: 1st syscall arg */
 477         movl %eax,%edx                  /* 2nd arg: syscall number */
 478         movl $AUDIT_ARCH_I386,%eax      /* 1st arg: audit arch */
 479         call audit_syscall_entry
 480         pushl %ebx
 481         CFI_ADJUST_CFA_OFFSET 4
 482         movl PT_EAX(%esp),%eax          /* reload syscall number */
 483         jmp sysenter_do_call
 484
 485 sysexit_audit:
 486         testl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %ecx
 487         jne syscall_exit_work
 488         TRACE_IRQS_ON
 489         ENABLE_INTERRUPTS(CLBR_ANY)
 490         movl %eax,%edx          /* second arg, syscall return value */
 491         cmpl $0,%eax            /* is it < 0? */
 492         setl %al                /* 1 if so, 0 if not */
 493         movzbl %al,%eax         /* zero-extend that */
 494         inc %eax /* first arg, 0->1(AUDITSC_SUCCESS), 1->2(AUDITSC_FAILURE) */
 495         call audit_syscall_exit
 496         DISABLE_INTERRUPTS(CLBR_ANY)
 497         TRACE_IRQS_OFF
 498         movl TI_flags(%ebp), %ecx
 499         testl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %ecx
 500         jne syscall_exit_work
 501         movl PT_EAX(%esp),%eax  /* reload syscall return value */
 502         jmp sysenter_exit
 503 #endif
 504
 505         CFI_ENDPROC
 506 .pushsection .fixup,"ax"
 507 2:      movl $0,PT_FS(%esp)
 508         jmp 1b
 509 .section __ex_table,"a"
 510         .align 4
 511         .long 1b,2b
 512 .popsection
 513         PTGS_TO_GS_EX
 514 ENDPROC(ia32_sysenter_target)
 515
 516         # system call handler stub
 517 ENTRY(system_call)
 518         RING0_INT_FRAME                 # can't unwind into user space anyway
 519         pushl %eax                      # save orig_eax
 520         CFI_ADJUST_CFA_OFFSET 4
 521         SAVE_ALL
 522         GET_THREAD_INFO(%ebp)
 523                                         # system call tracing in operation / emulation
 524         testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp)
 525         jnz syscall_trace_entry
 526         cmpl $(nr_syscalls), %eax
 527         jae syscall_badsys
 528 syscall_call:
 529         call *sys_call_table(,%eax,4)
 530         movl %eax,PT_EAX(%esp)          # store the return value
 531 syscall_exit:
 532         LOCKDEP_SYS_EXIT
 533         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
 534                                         # setting need_resched or sigpending
 535                                         # between sampling and the iret
 536         TRACE_IRQS_OFF
 537         movl TI_flags(%ebp), %ecx
 538         testl $_TIF_ALLWORK_MASK, %ecx  # current->work
 539         jne syscall_exit_work
 540
 541 restore_all:
 542         TRACE_IRQS_IRET
 543 restore_all_notrace:
 544         movl PT_EFLAGS(%esp), %eax      # mix EFLAGS, SS and CS
 545         # Warning: PT_OLDSS(%esp) contains the wrong/random values if we
 546         # are returning to the kernel.
 547         # See comments in process.c:copy_thread() for details.
 548         movb PT_OLDSS(%esp), %ah
 549         movb PT_CS(%esp), %al
 550         andl $(X86_EFLAGS_VM | (SEGMENT_TI_MASK << 8) | SEGMENT_RPL_MASK), %eax
 551         cmpl $((SEGMENT_LDT << 8) | USER_RPL), %eax
 552         CFI_REMEMBER_STATE
 553         je ldt_ss                       # returning to user-space with LDT SS
 554 restore_nocheck:
 555         RESTORE_REGS 4                  # skip orig_eax/error_code
 556         CFI_ADJUST_CFA_OFFSET -4
 557 irq_return:
 558         INTERRUPT_RETURN
 559 .section .fixup,"ax"
 560 ENTRY(iret_exc)
 561         pushl $0                        # no error code
 562         pushl $do_iret_error
 563         jmp error_code
 564 .previous
 565 .section __ex_table,"a"
 566         .align 4
 567         .long irq_return,iret_exc
 568 .previous
 569
 570         CFI_RESTORE_STATE
 571 ldt_ss:
 572         larl PT_OLDSS(%esp), %eax
 573         jnz restore_nocheck
 574         testl $0x00400000, %eax         # returning to 32bit stack?
 575         jnz restore_nocheck             # allright, normal return
 576
 577 #ifdef CONFIG_PARAVIRT
 578         /*
 579          * The kernel can't run on a non-flat stack if paravirt mode
 580          * is active.  Rather than try to fixup the high bits of
 581          * ESP, bypass this code entirely.  This may break DOSemu
 582          * and/or Wine support in a paravirt VM, although the option
 583          * is still available to implement the setting of the high
 584          * 16-bits in the INTERRUPT_RETURN paravirt-op.
 585          */
 586         cmpl $0, pv_info+PARAVIRT_enabled
 587         jne restore_nocheck
 588 #endif
 589
 590 /*
 591  * Setup and switch to ESPFIX stack
 592  *
 593  * We're returning to userspace with a 16 bit stack. The CPU will not
 594  * restore the high word of ESP for us on executing iret... This is an
 595  * "official" bug of all the x86-compatible CPUs, which we can work
 596  * around to make dosemu and wine happy. We do this by preloading the
 597  * high word of ESP with the high word of the userspace ESP while
 598  * compensating for the offset by changing to the ESPFIX segment with
 599  * a base address that matches for the difference.
 600  */
 601         mov %esp, %edx                  /* load kernel esp */
 602         mov PT_OLDESP(%esp), %eax       /* load userspace esp */
 603         mov %dx, %ax                    /* eax: new kernel esp */
 604         sub %eax, %edx                  /* offset (low word is 0) */
 605         PER_CPU(gdt_page, %ebx)
 606         shr $16, %edx
 607         mov %dl, GDT_ENTRY_ESPFIX_SS * 8 + 4(%ebx) /* bits 16..23 */
 608         mov %dh, GDT_ENTRY_ESPFIX_SS * 8 + 7(%ebx) /* bits 24..31 */
 609         pushl $__ESPFIX_SS
 610         CFI_ADJUST_CFA_OFFSET 4
 611         push %eax                       /* new kernel esp */
 612         CFI_ADJUST_CFA_OFFSET 4
 613         /* Disable interrupts, but do not irqtrace this section: we
 614          * will soon execute iret and the tracer was already set to
 615          * the irqstate after the iret */
 616         DISABLE_INTERRUPTS(CLBR_EAX)
 617         lss (%esp), %esp                /* switch to espfix segment */
 618         CFI_ADJUST_CFA_OFFSET -8
 619         jmp restore_nocheck
 620         CFI_ENDPROC
 621 ENDPROC(system_call)
 622
 623         # perform work that needs to be done immediately before resumption
 624         ALIGN
 625         RING0_PTREGS_FRAME              # can't unwind into user space anyway
 626 work_pending:
 627         testb $_TIF_NEED_RESCHED, %cl
 628         jz work_notifysig
 629 work_resched:
 630         call schedule
 631         LOCKDEP_SYS_EXIT
 632         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
 633                                         # setting need_resched or sigpending
 634                                         # between sampling and the iret
 635         TRACE_IRQS_OFF
 636         movl TI_flags(%ebp), %ecx
 637         andl $_TIF_WORK_MASK, %ecx      # is there any work to be done other
 638                                         # than syscall tracing?
 639         jz restore_all
 640         testb $_TIF_NEED_RESCHED, %cl
 641         jnz work_resched
 642
 643 work_notifysig:                         # deal with pending signals and
 644                                         # notify-resume requests
 645 #ifdef CONFIG_VM86
 646         testl $X86_EFLAGS_VM, PT_EFLAGS(%esp)
 647         movl %esp, %eax
 648         jne work_notifysig_v86          # returning to kernel-space or
 649                                         # vm86-space
 650         xorl %edx, %edx
 651         call do_notify_resume
 652         jmp resume_userspace_sig
 653
 654         ALIGN
 655 work_notifysig_v86:
 656         pushl %ecx                      # save ti_flags for do_notify_resume
 657         CFI_ADJUST_CFA_OFFSET 4
 658         call save_v86_state             # %eax contains pt_regs pointer
 659         popl %ecx
 660         CFI_ADJUST_CFA_OFFSET -4
 661         movl %eax, %esp
 662 #else
 663         movl %esp, %eax
 664 #endif
 665         xorl %edx, %edx
 666         call do_notify_resume
 667         jmp resume_userspace_sig
 668 END(work_pending)
 669
 670         # perform syscall exit tracing
 671         ALIGN
 672 syscall_trace_entry:
 673         movl $-ENOSYS,PT_EAX(%esp)
 674         movl %esp, %eax
 675         call syscall_trace_enter
 676         /* What it returned is what we'll actually use.  */
 677         cmpl $(nr_syscalls), %eax
 678         jnae syscall_call
 679         jmp syscall_exit
 680 END(syscall_trace_entry)
 681
 682         # perform syscall exit tracing
 683         ALIGN
 684 syscall_exit_work:
 685         testl $_TIF_WORK_SYSCALL_EXIT, %ecx
 686         jz work_pending
 687         TRACE_IRQS_ON
 688         ENABLE_INTERRUPTS(CLBR_ANY)     # could let syscall_trace_leave() call
 689                                         # schedule() instead
 690         movl %esp, %eax
 691         call syscall_trace_leave
 692         jmp resume_userspace
 693 END(syscall_exit_work)
 694         CFI_ENDPROC
 695
 696         RING0_INT_FRAME                 # can't unwind into user space anyway
 697 syscall_fault:
 698         GET_THREAD_INFO(%ebp)
 699         movl $-EFAULT,PT_EAX(%esp)
 700         jmp resume_userspace
 701 END(syscall_fault)
 702
 703 syscall_badsys:
 704         movl $-ENOSYS,PT_EAX(%esp)
 705         jmp resume_userspace
 706 END(syscall_badsys)
 707         CFI_ENDPROC
 708
 709 /*
 710  * System calls that need a pt_regs pointer.
 711  */
 712 #define PTREGSCALL(name) \
 713         ALIGN; \
 714 ptregs_##name: \
 715         leal 4(%esp),%eax; \
 716         jmp sys_##name;
 717
 718 PTREGSCALL(iopl)
 719 PTREGSCALL(fork)
 720 PTREGSCALL(clone)
 721 PTREGSCALL(vfork)
 722 PTREGSCALL(execve)
 723 PTREGSCALL(sigaltstack)
 724 PTREGSCALL(sigreturn)
 725 PTREGSCALL(rt_sigreturn)
 726 PTREGSCALL(vm86)
 727 PTREGSCALL(vm86old)
 728
 729 .macro FIXUP_ESPFIX_STACK
 730 /*
 731  * Switch back for ESPFIX stack to the normal zerobased stack
 732  *
 733  * We can't call C functions using the ESPFIX stack. This code reads
 734  * the high word of the segment base from the GDT and swiches to the
 735  * normal stack and adjusts ESP with the matching offset.
 736  */
 737         /* fixup the stack */
 738         PER_CPU(gdt_page, %ebx)
 739         mov GDT_ENTRY_ESPFIX_SS * 8 + 4(%ebx), %al /* bits 16..23 */
 740         mov GDT_ENTRY_ESPFIX_SS * 8 + 7(%ebx), %ah /* bits 24..31 */
 741         shl $16, %eax
 742         addl %esp, %eax                 /* the adjusted stack pointer */
 743         pushl $__KERNEL_DS
 744         CFI_ADJUST_CFA_OFFSET 4
 745         pushl %eax
 746         CFI_ADJUST_CFA_OFFSET 4
 747         lss (%esp), %esp                /* switch to the normal stack segment */
 748         CFI_ADJUST_CFA_OFFSET -8
 749 .endm
 750 .macro UNWIND_ESPFIX_STACK
 751         movl %ss, %eax
 752         /* see if on espfix stack */
 753         cmpw $__ESPFIX_SS, %ax
 754         jne 27f
 755         movl $__KERNEL_DS, %eax
 756         movl %eax, %ds
 757         movl %eax, %es
 758         /* switch to normal stack */
 759         FIXUP_ESPFIX_STACK
 760 27:
 761 .endm
 762
 763 /*
 764  * Build the entry stubs and pointer table with some assembler magic.
 765  * We pack 7 stubs into a single 32-byte chunk, which will fit in a
 766  * single cache line on all modern x86 implementations.
 767  */
 768 .section .init.rodata,"a"
 769 ENTRY(interrupt)
 770 .text
 771         .p2align 5
 772         .p2align CONFIG_X86_L1_CACHE_SHIFT
 773 ENTRY(irq_entries_start)
 774         RING0_INT_FRAME
 775 vector=FIRST_EXTERNAL_VECTOR
 776 .rept (NR_VECTORS-FIRST_EXTERNAL_VECTOR+6)/7
 777         .balign 32
 778   .rept 7
 779     .if vector < NR_VECTORS
 780       .if vector <> FIRST_EXTERNAL_VECTOR
 781         CFI_ADJUST_CFA_OFFSET -4
 782       .endif
 783 1:      pushl $(~vector+0x80)   /* Note: always in signed byte range */
 784         CFI_ADJUST_CFA_OFFSET 4
 785       .if ((vector-FIRST_EXTERNAL_VECTOR)%7) <> 6
 786         jmp 2f
 787       .endif
 788       .previous
 789         .long 1b
 790       .text
 791 vector=vector+1
 792     .endif
 793   .endr
 794 2:      jmp common_interrupt
 795 .endr
 796 END(irq_entries_start)
 797
 798 .previous
 799 END(interrupt)
 800 .previous
 801
 802 /*
 803  * the CPU automatically disables interrupts when executing an IRQ vector,
 804  * so IRQ-flags tracing has to follow that:
 805  */
 806         .p2align CONFIG_X86_L1_CACHE_SHIFT
 807 common_interrupt:
 808         addl $-0x80,(%esp)      /* Adjust vector into the [-256,-1] range */
 809         SAVE_ALL
 810         TRACE_IRQS_OFF
 811         movl %esp,%eax
 812         call do_IRQ
 813         jmp ret_from_intr
 814 ENDPROC(common_interrupt)
 815         CFI_ENDPROC
 816
 817 #define BUILD_INTERRUPT3(name, nr, fn)  \
 818 ENTRY(name)                             \
 819         RING0_INT_FRAME;                \
 820         pushl $~(nr);                   \
 821         CFI_ADJUST_CFA_OFFSET 4;        \
 822         SAVE_ALL;                       \
 823         TRACE_IRQS_OFF                  \
 824         movl %esp,%eax;                 \
 825         call fn;                        \
 826         jmp ret_from_intr;              \
 827         CFI_ENDPROC;                    \
 828 ENDPROC(name)
 829
 830 #define BUILD_INTERRUPT(name, nr)       BUILD_INTERRUPT3(name, nr, smp_##name)
 831
 832 /* The include is where all of the SMP etc. interrupts come from */
 833 #include <asm/entry_arch.h>
 834
 835 ENTRY(coprocessor_error)
 836         RING0_INT_FRAME
 837         pushl $0
 838         CFI_ADJUST_CFA_OFFSET 4
 839         pushl $do_coprocessor_error
 840         CFI_ADJUST_CFA_OFFSET 4
 841         jmp error_code
 842         CFI_ENDPROC
 843 END(coprocessor_error)
 844
 845 ENTRY(simd_coprocessor_error)
 846         RING0_INT_FRAME
 847         pushl $0
 848         CFI_ADJUST_CFA_OFFSET 4
 849         pushl $do_simd_coprocessor_error
 850         CFI_ADJUST_CFA_OFFSET 4
 851         jmp error_code
 852         CFI_ENDPROC
 853 END(simd_coprocessor_error)
 854
 855 ENTRY(device_not_available)
 856         RING0_INT_FRAME
 857         pushl $-1                       # mark this as an int
 858         CFI_ADJUST_CFA_OFFSET 4
 859         pushl $do_device_not_available
 860         CFI_ADJUST_CFA_OFFSET 4
 861         jmp error_code
 862         CFI_ENDPROC
 863 END(device_not_available)
 864
 865 #ifdef CONFIG_PARAVIRT
 866 ENTRY(native_iret)
 867         iret
 868 .section __ex_table,"a"
 869         .align 4
 870         .long native_iret, iret_exc
 871 .previous
 872 END(native_iret)
 873
 874 ENTRY(native_irq_enable_sysexit)
 875         sti
 876         sysexit
 877 END(native_irq_enable_sysexit)
 878 #endif
 879
 880 ENTRY(overflow)
 881         RING0_INT_FRAME
 882         pushl $0
 883         CFI_ADJUST_CFA_OFFSET 4
 884         pushl $do_overflow
 885         CFI_ADJUST_CFA_OFFSET 4
 886         jmp error_code
 887         CFI_ENDPROC
 888 END(overflow)
 889
 890 ENTRY(bounds)
 891         RING0_INT_FRAME
 892         pushl $0
 893         CFI_ADJUST_CFA_OFFSET 4
 894         pushl $do_bounds
 895         CFI_ADJUST_CFA_OFFSET 4
 896         jmp error_code
 897         CFI_ENDPROC
 898 END(bounds)
 899
 900 ENTRY(invalid_op)
 901         RING0_INT_FRAME
 902         pushl $0
 903         CFI_ADJUST_CFA_OFFSET 4
 904         pushl $do_invalid_op
 905         CFI_ADJUST_CFA_OFFSET 4
 906         jmp error_code
 907         CFI_ENDPROC
 908 END(invalid_op)
 909
 910 ENTRY(coprocessor_segment_overrun)
 911         RING0_INT_FRAME
 912         pushl $0
 913         CFI_ADJUST_CFA_OFFSET 4
 914         pushl $do_coprocessor_segment_overrun
 915         CFI_ADJUST_CFA_OFFSET 4
 916         jmp error_code
 917         CFI_ENDPROC
 918 END(coprocessor_segment_overrun)
 919
 920 ENTRY(invalid_TSS)
 921         RING0_EC_FRAME
 922         pushl $do_invalid_TSS
 923         CFI_ADJUST_CFA_OFFSET 4
 924         jmp error_code
 925         CFI_ENDPROC
 926 END(invalid_TSS)
 927
 928 ENTRY(segment_not_present)
 929         RING0_EC_FRAME
 930         pushl $do_segment_not_present
 931         CFI_ADJUST_CFA_OFFSET 4
 932         jmp error_code
 933         CFI_ENDPROC
 934 END(segment_not_present)
 935
 936 ENTRY(stack_segment)
 937         RING0_EC_FRAME
 938         pushl $do_stack_segment
 939         CFI_ADJUST_CFA_OFFSET 4
 940         jmp error_code
 941         CFI_ENDPROC
 942 END(stack_segment)
 943
 944 ENTRY(alignment_check)
 945         RING0_EC_FRAME
 946         pushl $do_alignment_check
 947         CFI_ADJUST_CFA_OFFSET 4
 948         jmp error_code
 949         CFI_ENDPROC
 950 END(alignment_check)
 951
 952 ENTRY(divide_error)
 953         RING0_INT_FRAME
 954         pushl $0                        # no error code
 955         CFI_ADJUST_CFA_OFFSET 4
 956         pushl $do_divide_error
 957         CFI_ADJUST_CFA_OFFSET 4
 958         jmp error_code
 959         CFI_ENDPROC
 960 END(divide_error)
 961
 962 #ifdef CONFIG_X86_MCE
 963 ENTRY(machine_check)
 964         RING0_INT_FRAME
 965         pushl $0
 966         CFI_ADJUST_CFA_OFFSET 4
 967         pushl machine_check_vector
 968         CFI_ADJUST_CFA_OFFSET 4
 969         jmp error_code
 970         CFI_ENDPROC
 971 END(machine_check)
 972 #endif
 973
 974 ENTRY(spurious_interrupt_bug)
 975         RING0_INT_FRAME
 976         pushl $0
 977         CFI_ADJUST_CFA_OFFSET 4
 978         pushl $do_spurious_interrupt_bug
 979         CFI_ADJUST_CFA_OFFSET 4
 980         jmp error_code
 981         CFI_ENDPROC
 982 END(spurious_interrupt_bug)
 983
 984 ENTRY(kernel_thread_helper)
 985         pushl $0                # fake return address for unwinder
 986         CFI_STARTPROC
 987         movl %edx,%eax
 988         push %edx
 989         CFI_ADJUST_CFA_OFFSET 4
 990         call *%ebx
 991         push %eax
 992         CFI_ADJUST_CFA_OFFSET 4
 993         call do_exit
 994         ud2                     # padding for call trace
 995         CFI_ENDPROC
 996 ENDPROC(kernel_thread_helper)
 997
 998 #ifdef CONFIG_XEN
 999 /* Xen doesn't set %esp to be precisely what the normal sysenter
1000    entrypoint expects, so fix it up before using the normal path. */
1001 ENTRY(xen_sysenter_target)
1002         RING0_INT_FRAME
1003         addl $5*4, %esp         /* remove xen-provided frame */
1004         CFI_ADJUST_CFA_OFFSET -5*4
1005         jmp sysenter_past_esp
1006         CFI_ENDPROC
1007
1008 ENTRY(xen_hypervisor_callback)
1009         CFI_STARTPROC
1010         pushl $0
1011         CFI_ADJUST_CFA_OFFSET 4
1012         SAVE_ALL
1013         TRACE_IRQS_OFF
1014
1015         /* Check to see if we got the event in the critical
1016            region in xen_iret_direct, after we've reenabled
1017            events and checked for pending events.  This simulates
1018            iret instruction's behaviour where it delivers a
1019            pending interrupt when enabling interrupts. */
1020         movl PT_EIP(%esp),%eax
1021         cmpl $xen_iret_start_crit,%eax
1022         jb   1f
1023         cmpl $xen_iret_end_crit,%eax
1024         jae  1f
1025
1026         jmp  xen_iret_crit_fixup
1027
1028 ENTRY(xen_do_upcall)
1029 1:      mov %esp, %eax
1030         call xen_evtchn_do_upcall
1031         jmp  ret_from_intr
1032         CFI_ENDPROC
1033 ENDPROC(xen_hypervisor_callback)
1034
1035 # Hypervisor uses this for application faults while it executes.
1036 # We get here for two reasons:
1037 #  1. Fault while reloading DS, ES, FS or GS
1038 #  2. Fault while executing IRET
1039 # Category 1 we fix up by reattempting the load, and zeroing the segment
1040 # register if the load fails.
1041 # Category 2 we fix up by jumping to do_iret_error. We cannot use the
1042 # normal Linux return path in this case because if we use the IRET hypercall
1043 # to pop the stack frame we end up in an infinite loop of failsafe callbacks.
1044 # We distinguish between categories by maintaining a status value in EAX.
1045 ENTRY(xen_failsafe_callback)
1046         CFI_STARTPROC
1047         pushl %eax
1048         CFI_ADJUST_CFA_OFFSET 4
1049         movl $1,%eax
1050 1:      mov 4(%esp),%ds
1051 2:      mov 8(%esp),%es
1052 3:      mov 12(%esp),%fs
1053 4:      mov 16(%esp),%gs
1054         testl %eax,%eax
1055         popl %eax
1056         CFI_ADJUST_CFA_OFFSET -4
1057         lea 16(%esp),%esp
1058         CFI_ADJUST_CFA_OFFSET -16
1059         jz 5f
1060         addl $16,%esp
1061         jmp iret_exc            # EAX != 0 => Category 2 (Bad IRET)
1062 5:      pushl $0                # EAX == 0 => Category 1 (Bad segment)
1063         CFI_ADJUST_CFA_OFFSET 4
1064         SAVE_ALL
1065         jmp ret_from_exception
1066         CFI_ENDPROC
1067
1068 .section .fixup,"ax"
1069 6:      xorl %eax,%eax
1070         movl %eax,4(%esp)
1071         jmp 1b
1072 7:      xorl %eax,%eax
1073         movl %eax,8(%esp)
1074         jmp 2b
1075 8:      xorl %eax,%eax
1076         movl %eax,12(%esp)
1077         jmp 3b
1078 9:      xorl %eax,%eax
1079         movl %eax,16(%esp)
1080         jmp 4b
1081 .previous
1082 .section __ex_table,"a"
1083         .align 4
1084         .long 1b,6b
1085         .long 2b,7b
1086         .long 3b,8b
1087         .long 4b,9b
1088 .previous
1089 ENDPROC(xen_failsafe_callback)
1090
1091 #endif  /* CONFIG_XEN */
1092
1093 #ifdef CONFIG_FUNCTION_TRACER
1094 #ifdef CONFIG_DYNAMIC_FTRACE
1095
1096 ENTRY(mcount)
1097         ret
1098 END(mcount)
1099
1100 ENTRY(ftrace_caller)
1101         cmpl $0, function_trace_stop
1102         jne  ftrace_stub
1103
1104         pushl %eax
1105         pushl %ecx
1106         pushl %edx
1107         movl 0xc(%esp), %eax
1108         movl 0x4(%ebp), %edx
1109         subl $MCOUNT_INSN_SIZE, %eax
1110
1111 .globl ftrace_call
1112 ftrace_call:
1113         call ftrace_stub
1114
1115         popl %edx
1116         popl %ecx
1117         popl %eax
1118 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1119 .globl ftrace_graph_call
1120 ftrace_graph_call:
1121         jmp ftrace_stub
1122 #endif
1123
1124 .globl ftrace_stub
1125 ftrace_stub:
1126         ret
1127 END(ftrace_caller)
1128
1129 #else /* ! CONFIG_DYNAMIC_FTRACE */
1130
1131 ENTRY(mcount)
1132         cmpl $0, function_trace_stop
1133         jne  ftrace_stub
1134
1135         cmpl $ftrace_stub, ftrace_trace_function
1136         jnz trace
1137 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1138         cmpl $ftrace_stub, ftrace_graph_return
1139         jnz ftrace_graph_caller
1140
1141         cmpl $ftrace_graph_entry_stub, ftrace_graph_entry
1142         jnz ftrace_graph_caller
1143 #endif
1144 .globl ftrace_stub
1145 ftrace_stub:
1146         ret
1147
1148         /* taken from glibc */
1149 trace:
1150         pushl %eax
1151         pushl %ecx
1152         pushl %edx
1153         movl 0xc(%esp), %eax
1154         movl 0x4(%ebp), %edx
1155         subl $MCOUNT_INSN_SIZE, %eax
1156
1157         call *ftrace_trace_function
1158
1159         popl %edx
1160         popl %ecx
1161         popl %eax
1162         jmp ftrace_stub
1163 END(mcount)
1164 #endif /* CONFIG_DYNAMIC_FTRACE */
1165 #endif /* CONFIG_FUNCTION_TRACER */
1166
1167 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1168 ENTRY(ftrace_graph_caller)
1169         cmpl $0, function_trace_stop
1170         jne ftrace_stub
1171
1172         pushl %eax
1173         pushl %ecx
1174         pushl %edx
1175         movl 0xc(%esp), %edx
1176         lea 0x4(%ebp), %eax
1177         movl (%ebp), %ecx
1178         subl $MCOUNT_INSN_SIZE, %edx
1179         call prepare_ftrace_return
1180         popl %edx
1181         popl %ecx
1182         popl %eax
1183         ret
1184 END(ftrace_graph_caller)
1185
1186 .globl return_to_handler
1187 return_to_handler:
1188         pushl $0
1189         pushl %eax
1190         pushl %ecx
1191         pushl %edx
1192         movl %ebp, %eax
1193         call ftrace_return_to_handler
1194         movl %eax, 0xc(%esp)
1195         popl %edx
1196         popl %ecx
1197         popl %eax
1198         ret
1199 #endif
1200
1201 .section .rodata,"a"
1202 #include "syscall_table_32.S"
1203
1204 syscall_table_size=(.-sys_call_table)
1205
1206 /*
1207  * Some functions should be protected against kprobes
1208  */
1209         .pushsection .kprobes.text, "ax"
1210
1211 ENTRY(page_fault)
1212         RING0_EC_FRAME
1213         pushl $do_page_fault
1214         CFI_ADJUST_CFA_OFFSET 4
1215         ALIGN
1216 error_code:
1217         /* the function address is in %gs's slot on the stack */
1218         pushl %fs
1219         CFI_ADJUST_CFA_OFFSET 4
1220         /*CFI_REL_OFFSET fs, 0*/
1221         pushl %es
1222         CFI_ADJUST_CFA_OFFSET 4
1223         /*CFI_REL_OFFSET es, 0*/
1224         pushl %ds
1225         CFI_ADJUST_CFA_OFFSET 4
1226         /*CFI_REL_OFFSET ds, 0*/
1227         pushl %eax
1228         CFI_ADJUST_CFA_OFFSET 4
1229         CFI_REL_OFFSET eax, 0
1230         pushl %ebp
1231         CFI_ADJUST_CFA_OFFSET 4
1232         CFI_REL_OFFSET ebp, 0
1233         pushl %edi
1234         CFI_ADJUST_CFA_OFFSET 4
1235         CFI_REL_OFFSET edi, 0
1236         pushl %esi
1237         CFI_ADJUST_CFA_OFFSET 4
1238         CFI_REL_OFFSET esi, 0
1239         pushl %edx
1240         CFI_ADJUST_CFA_OFFSET 4
1241         CFI_REL_OFFSET edx, 0
1242         pushl %ecx
1243         CFI_ADJUST_CFA_OFFSET 4
1244         CFI_REL_OFFSET ecx, 0
1245         pushl %ebx
1246         CFI_ADJUST_CFA_OFFSET 4
1247         CFI_REL_OFFSET ebx, 0
1248         cld
1249         movl $(__KERNEL_PERCPU), %ecx
1250         movl %ecx, %fs
1251         UNWIND_ESPFIX_STACK
1252         GS_TO_REG %ecx
1253         movl PT_GS(%esp), %edi          # get the function address
1254         movl PT_ORIG_EAX(%esp), %edx    # get the error code
1255         movl $-1, PT_ORIG_EAX(%esp)     # no syscall to restart
1256         REG_TO_PTGS %ecx
1257         SET_KERNEL_GS %ecx
1258         movl $(__USER_DS), %ecx
1259         movl %ecx, %ds
1260         movl %ecx, %es
1261         TRACE_IRQS_OFF
1262         movl %esp,%eax                  # pt_regs pointer
1263         call *%edi
1264         jmp ret_from_exception
1265         CFI_ENDPROC
1266 END(page_fault)
1267
1268 /*
1269  * Debug traps and NMI can happen at the one SYSENTER instruction
1270  * that sets up the real kernel stack. Check here, since we can't
1271  * allow the wrong stack to be used.
1272  *
1273  * "TSS_sysenter_sp0+12" is because the NMI/debug handler will have
1274  * already pushed 3 words if it hits on the sysenter instruction:
1275  * eflags, cs and eip.
1276  *
1277  * We just load the right stack, and push the three (known) values
1278  * by hand onto the new stack - while updating the return eip past
1279  * the instruction that would have done it for sysenter.
1280  */
1281 .macro FIX_STACK offset ok label
1282         cmpw $__KERNEL_CS, 4(%esp)
1283         jne \ok
1284 \label:
1285         movl TSS_sysenter_sp0 + \offset(%esp), %esp
1286         CFI_DEF_CFA esp, 0
1287         CFI_UNDEFINED eip
1288         pushfl
1289         CFI_ADJUST_CFA_OFFSET 4
1290         pushl $__KERNEL_CS
1291         CFI_ADJUST_CFA_OFFSET 4
1292         pushl $sysenter_past_esp
1293         CFI_ADJUST_CFA_OFFSET 4
1294         CFI_REL_OFFSET eip, 0
1295 .endm
1296
1297 ENTRY(debug)
1298         RING0_INT_FRAME
1299         cmpl $ia32_sysenter_target,(%esp)
1300         jne debug_stack_correct
1301         FIX_STACK 12, debug_stack_correct, debug_esp_fix_insn
1302 debug_stack_correct:
1303         pushl $-1                       # mark this as an int
1304         CFI_ADJUST_CFA_OFFSET 4
1305         SAVE_ALL
1306         TRACE_IRQS_OFF
1307         xorl %edx,%edx                  # error code 0
1308         movl %esp,%eax                  # pt_regs pointer
1309         call do_debug
1310         jmp ret_from_exception
1311         CFI_ENDPROC
1312 END(debug)
1313
1314 /*
1315  * NMI is doubly nasty. It can happen _while_ we're handling
1316  * a debug fault, and the debug fault hasn't yet been able to
1317  * clear up the stack. So we first check whether we got  an
1318  * NMI on the sysenter entry path, but after that we need to
1319  * check whether we got an NMI on the debug path where the debug
1320  * fault happened on the sysenter path.
1321  */
1322 ENTRY(nmi)
1323         RING0_INT_FRAME
1324         pushl %eax
1325         CFI_ADJUST_CFA_OFFSET 4
1326         movl %ss, %eax
1327         cmpw $__ESPFIX_SS, %ax
1328         popl %eax
1329         CFI_ADJUST_CFA_OFFSET -4
1330         je nmi_espfix_stack
1331         cmpl $ia32_sysenter_target,(%esp)
1332         je nmi_stack_fixup
1333         pushl %eax
1334         CFI_ADJUST_CFA_OFFSET 4
1335         movl %esp,%eax
1336         /* Do not access memory above the end of our stack page,
1337          * it might not exist.
1338          */
1339         andl $(THREAD_SIZE-1),%eax
1340         cmpl $(THREAD_SIZE-20),%eax
1341         popl %eax
1342         CFI_ADJUST_CFA_OFFSET -4
1343         jae nmi_stack_correct
1344         cmpl $ia32_sysenter_target,12(%esp)
1345         je nmi_debug_stack_check
1346 nmi_stack_correct:
1347         /* We have a RING0_INT_FRAME here */
1348         pushl %eax
1349         CFI_ADJUST_CFA_OFFSET 4
1350         SAVE_ALL
1351         xorl %edx,%edx          # zero error code
1352         movl %esp,%eax          # pt_regs pointer
1353         call do_nmi
1354         jmp restore_all_notrace
1355         CFI_ENDPROC
1356
1357 nmi_stack_fixup:
1358         RING0_INT_FRAME
1359         FIX_STACK 12, nmi_stack_correct, 1
1360         jmp nmi_stack_correct
1361
1362 nmi_debug_stack_check:
1363         /* We have a RING0_INT_FRAME here */
1364         cmpw $__KERNEL_CS,16(%esp)
1365         jne nmi_stack_correct
1366         cmpl $debug,(%esp)
1367         jb nmi_stack_correct
1368         cmpl $debug_esp_fix_insn,(%esp)
1369         ja nmi_stack_correct
1370         FIX_STACK 24, nmi_stack_correct, 1
1371         jmp nmi_stack_correct
1372
1373 nmi_espfix_stack:
1374         /* We have a RING0_INT_FRAME here.
1375          *
1376          * create the pointer to lss back
1377          */
1378         pushl %ss
1379         CFI_ADJUST_CFA_OFFSET 4
1380         pushl %esp
1381         CFI_ADJUST_CFA_OFFSET 4
1382         addl $4, (%esp)
1383         /* copy the iret frame of 12 bytes */
1384         .rept 3
1385         pushl 16(%esp)
1386         CFI_ADJUST_CFA_OFFSET 4
1387         .endr
1388         pushl %eax
1389         CFI_ADJUST_CFA_OFFSET 4
1390         SAVE_ALL
1391         FIXUP_ESPFIX_STACK              # %eax == %esp
1392         xorl %edx,%edx                  # zero error code
1393         call do_nmi
1394         RESTORE_REGS
1395         lss 12+4(%esp), %esp            # back to espfix stack
1396         CFI_ADJUST_CFA_OFFSET -24
1397         jmp irq_return
1398         CFI_ENDPROC
1399 END(nmi)
1400
1401 ENTRY(int3)
1402         RING0_INT_FRAME
1403         pushl $-1                       # mark this as an int
1404         CFI_ADJUST_CFA_OFFSET 4
1405         SAVE_ALL
1406         TRACE_IRQS_OFF
1407         xorl %edx,%edx          # zero error code
1408         movl %esp,%eax          # pt_regs pointer
1409         call do_int3
1410         jmp ret_from_exception
1411         CFI_ENDPROC
1412 END(int3)
1413
1414 ENTRY(general_protection)
1415         RING0_EC_FRAME
1416         pushl $do_general_protection
1417         CFI_ADJUST_CFA_OFFSET 4
1418         jmp error_code
1419         CFI_ENDPROC
1420 END(general_protection)
1421
1422 /*
1423  * End of kprobes section
1424  */
1425         .popsection