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) - orig_eax
  34  *      2C(%esp) - %eip
  35  *      30(%esp) - %cs
  36  *      34(%esp) - %eflags
  37  *      38(%esp) - %oldesp
  38  *      3C(%esp) - %oldss
  39  *
  40  * "current" is in register %ebx during any slow entries.
  41  */
  42
  43 #include <linux/linkage.h>
  44 #include <asm/thread_info.h>
  45 #include <asm/irqflags.h>
  46 #include <asm/errno.h>
  47 #include <asm/segment.h>
  48 #include <asm/smp.h>
  49 #include <asm/page.h>
  50 #include <asm/desc.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 /*
  58  * We use macros for low-level operations which need to be overridden
  59  * for paravirtualization.  The following will never clobber any registers:
  60  *   INTERRUPT_RETURN (aka. "iret")
  61  *   GET_CR0_INTO_EAX (aka. "movl %cr0, %eax")
  62  *   ENABLE_INTERRUPTS_SYSEXIT (aka "sti; sysexit").
  63  *
  64  * For DISABLE_INTERRUPTS/ENABLE_INTERRUPTS (aka "cli"/"sti"), you must
  65  * specify what registers can be overwritten (CLBR_NONE, CLBR_EAX/EDX/ECX/ANY).
  66  * Allowing a register to be clobbered can shrink the paravirt replacement
  67  * enough to patch inline, increasing performance.
  68  */
  69
  70 #define nr_syscalls ((syscall_table_size)/4)
  71
  72 #ifdef CONFIG_PREEMPT
  73 #define preempt_stop(clobbers)  DISABLE_INTERRUPTS(clobbers); TRACE_IRQS_OFF
  74 #else
  75 #define preempt_stop(clobbers)
  76 #define resume_kernel           restore_nocheck
  77 #endif
  78
  79 .macro TRACE_IRQS_IRET
  80 #ifdef CONFIG_TRACE_IRQFLAGS
  81         testl $X86_EFLAGS_IF,PT_EFLAGS(%esp)     # interrupts off?
  82         jz 1f
  83         TRACE_IRQS_ON
  84 1:
  85 #endif
  86 .endm
  87
  88 #ifdef CONFIG_VM86
  89 #define resume_userspace_sig    check_userspace
  90 #else
  91 #define resume_userspace_sig    resume_userspace
  92 #endif
  93
  94 #define SAVE_ALL \
  95         cld; \
  96         pushl %fs; \
  97         CFI_ADJUST_CFA_OFFSET 4;\
  98         /*CFI_REL_OFFSET fs, 0;*/\
  99         pushl %es; \
 100         CFI_ADJUST_CFA_OFFSET 4;\
 101         /*CFI_REL_OFFSET es, 0;*/\
 102         pushl %ds; \
 103         CFI_ADJUST_CFA_OFFSET 4;\
 104         /*CFI_REL_OFFSET ds, 0;*/\
 105         pushl %eax; \
 106         CFI_ADJUST_CFA_OFFSET 4;\
 107         CFI_REL_OFFSET eax, 0;\
 108         pushl %ebp; \
 109         CFI_ADJUST_CFA_OFFSET 4;\
 110         CFI_REL_OFFSET ebp, 0;\
 111         pushl %edi; \
 112         CFI_ADJUST_CFA_OFFSET 4;\
 113         CFI_REL_OFFSET edi, 0;\
 114         pushl %esi; \
 115         CFI_ADJUST_CFA_OFFSET 4;\
 116         CFI_REL_OFFSET esi, 0;\
 117         pushl %edx; \
 118         CFI_ADJUST_CFA_OFFSET 4;\
 119         CFI_REL_OFFSET edx, 0;\
 120         pushl %ecx; \
 121         CFI_ADJUST_CFA_OFFSET 4;\
 122         CFI_REL_OFFSET ecx, 0;\
 123         pushl %ebx; \
 124         CFI_ADJUST_CFA_OFFSET 4;\
 125         CFI_REL_OFFSET ebx, 0;\
 126         movl $(__USER_DS), %edx; \
 127         movl %edx, %ds; \
 128         movl %edx, %es; \
 129         movl $(__KERNEL_PERCPU), %edx; \
 130         movl %edx, %fs
 131
 132 #define RESTORE_INT_REGS \
 133         popl %ebx;      \
 134         CFI_ADJUST_CFA_OFFSET -4;\
 135         CFI_RESTORE ebx;\
 136         popl %ecx;      \
 137         CFI_ADJUST_CFA_OFFSET -4;\
 138         CFI_RESTORE ecx;\
 139         popl %edx;      \
 140         CFI_ADJUST_CFA_OFFSET -4;\
 141         CFI_RESTORE edx;\
 142         popl %esi;      \
 143         CFI_ADJUST_CFA_OFFSET -4;\
 144         CFI_RESTORE esi;\
 145         popl %edi;      \
 146         CFI_ADJUST_CFA_OFFSET -4;\
 147         CFI_RESTORE edi;\
 148         popl %ebp;      \
 149         CFI_ADJUST_CFA_OFFSET -4;\
 150         CFI_RESTORE ebp;\
 151         popl %eax;      \
 152         CFI_ADJUST_CFA_OFFSET -4;\
 153         CFI_RESTORE eax
 154
 155 #define RESTORE_REGS    \
 156         RESTORE_INT_REGS; \
 157 1:      popl %ds;       \
 158         CFI_ADJUST_CFA_OFFSET -4;\
 159         /*CFI_RESTORE ds;*/\
 160 2:      popl %es;       \
 161         CFI_ADJUST_CFA_OFFSET -4;\
 162         /*CFI_RESTORE es;*/\
 163 3:      popl %fs;       \
 164         CFI_ADJUST_CFA_OFFSET -4;\
 165         /*CFI_RESTORE fs;*/\
 166 .pushsection .fixup,"ax";       \
 167 4:      movl $0,(%esp); \
 168         jmp 1b;         \
 169 5:      movl $0,(%esp); \
 170         jmp 2b;         \
 171 6:      movl $0,(%esp); \
 172         jmp 3b;         \
 173 .section __ex_table,"a";\
 174         .align 4;       \
 175         .long 1b,4b;    \
 176         .long 2b,5b;    \
 177         .long 3b,6b;    \
 178 .popsection
 179
 180 #define RING0_INT_FRAME \
 181         CFI_STARTPROC simple;\
 182         CFI_SIGNAL_FRAME;\
 183         CFI_DEF_CFA esp, 3*4;\
 184         /*CFI_OFFSET cs, -2*4;*/\
 185         CFI_OFFSET eip, -3*4
 186
 187 #define RING0_EC_FRAME \
 188         CFI_STARTPROC simple;\
 189         CFI_SIGNAL_FRAME;\
 190         CFI_DEF_CFA esp, 4*4;\
 191         /*CFI_OFFSET cs, -2*4;*/\
 192         CFI_OFFSET eip, -3*4
 193
 194 #define RING0_PTREGS_FRAME \
 195         CFI_STARTPROC simple;\
 196         CFI_SIGNAL_FRAME;\
 197         CFI_DEF_CFA esp, PT_OLDESP-PT_EBX;\
 198         /*CFI_OFFSET cs, PT_CS-PT_OLDESP;*/\
 199         CFI_OFFSET eip, PT_EIP-PT_OLDESP;\
 200         /*CFI_OFFSET es, PT_ES-PT_OLDESP;*/\
 201         /*CFI_OFFSET ds, PT_DS-PT_OLDESP;*/\
 202         CFI_OFFSET eax, PT_EAX-PT_OLDESP;\
 203         CFI_OFFSET ebp, PT_EBP-PT_OLDESP;\
 204         CFI_OFFSET edi, PT_EDI-PT_OLDESP;\
 205         CFI_OFFSET esi, PT_ESI-PT_OLDESP;\
 206         CFI_OFFSET edx, PT_EDX-PT_OLDESP;\
 207         CFI_OFFSET ecx, PT_ECX-PT_OLDESP;\
 208         CFI_OFFSET ebx, PT_EBX-PT_OLDESP
 209
 210 ENTRY(ret_from_fork)
 211         CFI_STARTPROC
 212         pushl %eax
 213         CFI_ADJUST_CFA_OFFSET 4
 214         call schedule_tail
 215         GET_THREAD_INFO(%ebp)
 216         popl %eax
 217         CFI_ADJUST_CFA_OFFSET -4
 218         pushl $0x0202                   # Reset kernel eflags
 219         CFI_ADJUST_CFA_OFFSET 4
 220         popfl
 221         CFI_ADJUST_CFA_OFFSET -4
 222         jmp syscall_exit
 223         CFI_ENDPROC
 224 END(ret_from_fork)
 225
 226 /*
 227  * Return to user mode is not as complex as all this looks,
 228  * but we want the default path for a system call return to
 229  * go as quickly as possible which is why some of this is
 230  * less clear than it otherwise should be.
 231  */
 232
 233         # userspace resumption stub bypassing syscall exit tracing
 234         ALIGN
 235         RING0_PTREGS_FRAME
 236 ret_from_exception:
 237         preempt_stop(CLBR_ANY)
 238 ret_from_intr:
 239         GET_THREAD_INFO(%ebp)
 240 check_userspace:
 241         movl PT_EFLAGS(%esp), %eax      # mix EFLAGS and CS
 242         movb PT_CS(%esp), %al
 243         andl $(X86_EFLAGS_VM | SEGMENT_RPL_MASK), %eax
 244         cmpl $USER_RPL, %eax
 245         jb resume_kernel                # not returning to v8086 or userspace
 246
 247 ENTRY(resume_userspace)
 248         LOCKDEP_SYS_EXIT
 249         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
 250                                         # setting need_resched or sigpending
 251                                         # between sampling and the iret
 252         TRACE_IRQS_OFF
 253         movl TI_flags(%ebp), %ecx
 254         andl $_TIF_WORK_MASK, %ecx      # is there any work to be done on
 255                                         # int/exception return?
 256         jne work_pending
 257         jmp restore_all
 258 END(ret_from_exception)
 259
 260 #ifdef CONFIG_PREEMPT
 261 ENTRY(resume_kernel)
 262         DISABLE_INTERRUPTS(CLBR_ANY)
 263         cmpl $0,TI_preempt_count(%ebp)  # non-zero preempt_count ?
 264         jnz restore_nocheck
 265 need_resched:
 266         movl TI_flags(%ebp), %ecx       # need_resched set ?
 267         testb $_TIF_NEED_RESCHED, %cl
 268         jz restore_all
 269         testl $X86_EFLAGS_IF,PT_EFLAGS(%esp)    # interrupts off (exception path) ?
 270         jz restore_all
 271         call preempt_schedule_irq
 272         jmp need_resched
 273 END(resume_kernel)
 274 #endif
 275         CFI_ENDPROC
 276
 277 /* SYSENTER_RETURN points to after the "sysenter" instruction in
 278    the vsyscall page.  See vsyscall-sysentry.S, which defines the symbol.  */
 279
 280         # sysenter call handler stub
 281 ENTRY(ia32_sysenter_target)
 282         CFI_STARTPROC simple
 283         CFI_SIGNAL_FRAME
 284         CFI_DEF_CFA esp, 0
 285         CFI_REGISTER esp, ebp
 286         movl TSS_sysenter_sp0(%esp),%esp
 287 sysenter_past_esp:
 288         /*
 289          * Interrupts are disabled here, but we can't trace it until
 290          * enough kernel state to call TRACE_IRQS_OFF can be called - but
 291          * we immediately enable interrupts at that point anyway.
 292          */
 293         pushl $(__USER_DS)
 294         CFI_ADJUST_CFA_OFFSET 4
 295         /*CFI_REL_OFFSET ss, 0*/
 296         pushl %ebp
 297         CFI_ADJUST_CFA_OFFSET 4
 298         CFI_REL_OFFSET esp, 0
 299         pushfl
 300         orl $X86_EFLAGS_IF, (%esp)
 301         CFI_ADJUST_CFA_OFFSET 4
 302         pushl $(__USER_CS)
 303         CFI_ADJUST_CFA_OFFSET 4
 304         /*CFI_REL_OFFSET cs, 0*/
 305         /*
 306          * Push current_thread_info()->sysenter_return to the stack.
 307          * A tiny bit of offset fixup is necessary - 4*4 means the 4 words
 308          * pushed above; +8 corresponds to copy_thread's esp0 setting.
 309          */
 310         pushl (TI_sysenter_return-THREAD_SIZE+8+4*4)(%esp)
 311         CFI_ADJUST_CFA_OFFSET 4
 312         CFI_REL_OFFSET eip, 0
 313
 314         pushl %eax
 315         CFI_ADJUST_CFA_OFFSET 4
 316         SAVE_ALL
 317         ENABLE_INTERRUPTS(CLBR_NONE)
 318
 319 /*
 320  * Load the potential sixth argument from user stack.
 321  * Careful about security.
 322  */
 323         cmpl $__PAGE_OFFSET-3,%ebp
 324         jae syscall_fault
 325 1:      movl (%ebp),%ebp
 326         movl %ebp,PT_EBP(%esp)
 327 .section __ex_table,"a"
 328         .align 4
 329         .long 1b,syscall_fault
 330 .previous
 331
 332         GET_THREAD_INFO(%ebp)
 333
 334         /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */
 335         testw $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp)
 336         jnz syscall_trace_entry
 337         cmpl $(nr_syscalls), %eax
 338         jae syscall_badsys
 339         call *sys_call_table(,%eax,4)
 340         movl %eax,PT_EAX(%esp)
 341         LOCKDEP_SYS_EXIT
 342         DISABLE_INTERRUPTS(CLBR_ANY)
 343         TRACE_IRQS_OFF
 344         movl TI_flags(%ebp), %ecx
 345         testw $_TIF_ALLWORK_MASK, %cx
 346         jne syscall_exit_work
 347 /* if something modifies registers it must also disable sysexit */
 348         movl PT_EIP(%esp), %edx
 349         movl PT_OLDESP(%esp), %ecx
 350         xorl %ebp,%ebp
 351         TRACE_IRQS_ON
 352 1:      mov  PT_FS(%esp), %fs
 353         ENABLE_INTERRUPTS_SYSEXIT
 354         CFI_ENDPROC
 355 .pushsection .fixup,"ax"
 356 2:      movl $0,PT_FS(%esp)
 357         jmp 1b
 358 .section __ex_table,"a"
 359         .align 4
 360         .long 1b,2b
 361 .popsection
 362 ENDPROC(ia32_sysenter_target)
 363
 364         # system call handler stub
 365 ENTRY(system_call)
 366         RING0_INT_FRAME                 # can't unwind into user space anyway
 367         pushl %eax                      # save orig_eax
 368         CFI_ADJUST_CFA_OFFSET 4
 369         SAVE_ALL
 370         GET_THREAD_INFO(%ebp)
 371                                         # system call tracing in operation / emulation
 372         /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */
 373         testw $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp)
 374         jnz syscall_trace_entry
 375         cmpl $(nr_syscalls), %eax
 376         jae syscall_badsys
 377 syscall_call:
 378         call *sys_call_table(,%eax,4)
 379         movl %eax,PT_EAX(%esp)          # store the return value
 380 syscall_exit:
 381         LOCKDEP_SYS_EXIT
 382         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
 383                                         # setting need_resched or sigpending
 384                                         # between sampling and the iret
 385         TRACE_IRQS_OFF
 386         movl TI_flags(%ebp), %ecx
 387         testw $_TIF_ALLWORK_MASK, %cx   # current->work
 388         jne syscall_exit_work
 389
 390 restore_all:
 391         movl PT_EFLAGS(%esp), %eax      # mix EFLAGS, SS and CS
 392         # Warning: PT_OLDSS(%esp) contains the wrong/random values if we
 393         # are returning to the kernel.
 394         # See comments in process.c:copy_thread() for details.
 395         movb PT_OLDSS(%esp), %ah
 396         movb PT_CS(%esp), %al
 397         andl $(X86_EFLAGS_VM | (SEGMENT_TI_MASK << 8) | SEGMENT_RPL_MASK), %eax
 398         cmpl $((SEGMENT_LDT << 8) | USER_RPL), %eax
 399         CFI_REMEMBER_STATE
 400         je ldt_ss                       # returning to user-space with LDT SS
 401 restore_nocheck:
 402         TRACE_IRQS_IRET
 403 restore_nocheck_notrace:
 404         RESTORE_REGS
 405         addl $4, %esp                   # skip orig_eax/error_code
 406         CFI_ADJUST_CFA_OFFSET -4
 407 irq_return:
 408         INTERRUPT_RETURN
 409 .section .fixup,"ax"
 410 ENTRY(iret_exc)
 411         pushl $0                        # no error code
 412         pushl $do_iret_error
 413         jmp error_code
 414 .previous
 415 .section __ex_table,"a"
 416         .align 4
 417         .long irq_return,iret_exc
 418 .previous
 419
 420         CFI_RESTORE_STATE
 421 ldt_ss:
 422         larl PT_OLDSS(%esp), %eax
 423         jnz restore_nocheck
 424         testl $0x00400000, %eax         # returning to 32bit stack?
 425         jnz restore_nocheck             # allright, normal return
 426
 427 #ifdef CONFIG_PARAVIRT
 428         /*
 429          * The kernel can't run on a non-flat stack if paravirt mode
 430          * is active.  Rather than try to fixup the high bits of
 431          * ESP, bypass this code entirely.  This may break DOSemu
 432          * and/or Wine support in a paravirt VM, although the option
 433          * is still available to implement the setting of the high
 434          * 16-bits in the INTERRUPT_RETURN paravirt-op.
 435          */
 436         cmpl $0, pv_info+PARAVIRT_enabled
 437         jne restore_nocheck
 438 #endif
 439
 440         /* If returning to userspace with 16bit stack,
 441          * try to fix the higher word of ESP, as the CPU
 442          * won't restore it.
 443          * This is an "official" bug of all the x86-compatible
 444          * CPUs, which we can try to work around to make
 445          * dosemu and wine happy. */
 446         movl PT_OLDESP(%esp), %eax
 447         movl %esp, %edx
 448         call patch_espfix_desc
 449         pushl $__ESPFIX_SS
 450         CFI_ADJUST_CFA_OFFSET 4
 451         pushl %eax
 452         CFI_ADJUST_CFA_OFFSET 4
 453         DISABLE_INTERRUPTS(CLBR_EAX)
 454         TRACE_IRQS_OFF
 455         lss (%esp), %esp
 456         CFI_ADJUST_CFA_OFFSET -8
 457         jmp restore_nocheck
 458         CFI_ENDPROC
 459 ENDPROC(system_call)
 460
 461         # perform work that needs to be done immediately before resumption
 462         ALIGN
 463         RING0_PTREGS_FRAME              # can't unwind into user space anyway
 464 work_pending:
 465         testb $_TIF_NEED_RESCHED, %cl
 466         jz work_notifysig
 467 work_resched:
 468         call schedule
 469         LOCKDEP_SYS_EXIT
 470         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
 471                                         # setting need_resched or sigpending
 472                                         # between sampling and the iret
 473         TRACE_IRQS_OFF
 474         movl TI_flags(%ebp), %ecx
 475         andl $_TIF_WORK_MASK, %ecx      # is there any work to be done other
 476                                         # than syscall tracing?
 477         jz restore_all
 478         testb $_TIF_NEED_RESCHED, %cl
 479         jnz work_resched
 480
 481 work_notifysig:                         # deal with pending signals and
 482                                         # notify-resume requests
 483 #ifdef CONFIG_VM86
 484         testl $X86_EFLAGS_VM, PT_EFLAGS(%esp)
 485         movl %esp, %eax
 486         jne work_notifysig_v86          # returning to kernel-space or
 487                                         # vm86-space
 488         xorl %edx, %edx
 489         call do_notify_resume
 490         jmp resume_userspace_sig
 491
 492         ALIGN
 493 work_notifysig_v86:
 494         pushl %ecx                      # save ti_flags for do_notify_resume
 495         CFI_ADJUST_CFA_OFFSET 4
 496         call save_v86_state             # %eax contains pt_regs pointer
 497         popl %ecx
 498         CFI_ADJUST_CFA_OFFSET -4
 499         movl %eax, %esp
 500 #else
 501         movl %esp, %eax
 502 #endif
 503         xorl %edx, %edx
 504         call do_notify_resume
 505         jmp resume_userspace_sig
 506 END(work_pending)
 507
 508         # perform syscall exit tracing
 509         ALIGN
 510 syscall_trace_entry:
 511         movl $-ENOSYS,PT_EAX(%esp)
 512         movl %esp, %eax
 513         call syscall_trace_enter
 514         /* What it returned is what we'll actually use.  */
 515         cmpl $(nr_syscalls), %eax
 516         jnae syscall_call
 517         jmp syscall_exit
 518 END(syscall_trace_entry)
 519
 520         # perform syscall exit tracing
 521         ALIGN
 522 syscall_exit_work:
 523         testb $_TIF_WORK_SYSCALL_EXIT, %cl
 524         jz work_pending
 525         TRACE_IRQS_ON
 526         ENABLE_INTERRUPTS(CLBR_ANY)     # could let syscall_trace_leave() call
 527                                         # schedule() instead
 528         movl %esp, %eax
 529         call syscall_trace_leave
 530         jmp resume_userspace
 531 END(syscall_exit_work)
 532         CFI_ENDPROC
 533
 534         RING0_INT_FRAME                 # can't unwind into user space anyway
 535 syscall_fault:
 536         GET_THREAD_INFO(%ebp)
 537         movl $-EFAULT,PT_EAX(%esp)
 538         jmp resume_userspace
 539 END(syscall_fault)
 540
 541 syscall_badsys:
 542         movl $-ENOSYS,PT_EAX(%esp)
 543         jmp resume_userspace
 544 END(syscall_badsys)
 545         CFI_ENDPROC
 546
 547 #define FIXUP_ESPFIX_STACK \
 548         /* since we are on a wrong stack, we cant make it a C code :( */ \
 549         PER_CPU(gdt_page, %ebx); \
 550         GET_DESC_BASE(GDT_ENTRY_ESPFIX_SS, %ebx, %eax, %ax, %al, %ah); \
 551         addl %esp, %eax; \
 552         pushl $__KERNEL_DS; \
 553         CFI_ADJUST_CFA_OFFSET 4; \
 554         pushl %eax; \
 555         CFI_ADJUST_CFA_OFFSET 4; \
 556         lss (%esp), %esp; \
 557         CFI_ADJUST_CFA_OFFSET -8;
 558 #define UNWIND_ESPFIX_STACK \
 559         movl %ss, %eax; \
 560         /* see if on espfix stack */ \
 561         cmpw $__ESPFIX_SS, %ax; \
 562         jne 27f; \
 563         movl $__KERNEL_DS, %eax; \
 564         movl %eax, %ds; \
 565         movl %eax, %es; \
 566         /* switch to normal stack */ \
 567         FIXUP_ESPFIX_STACK; \
 568 27:;
 569
 570 /*
 571  * Build the entry stubs and pointer table with
 572  * some assembler magic.
 573  */
 574 .section .rodata,"a"
 575 ENTRY(interrupt)
 576 .text
 577
 578 ENTRY(irq_entries_start)
 579         RING0_INT_FRAME
 580 vector=0
 581 .rept NR_IRQS
 582         ALIGN
 583  .if vector
 584         CFI_ADJUST_CFA_OFFSET -4
 585  .endif
 586 1:      pushl $~(vector)
 587         CFI_ADJUST_CFA_OFFSET 4
 588         jmp common_interrupt
 589  .previous
 590         .long 1b
 591  .text
 592 vector=vector+1
 593 .endr
 594 END(irq_entries_start)
 595
 596 .previous
 597 END(interrupt)
 598 .previous
 599
 600 /*
 601  * the CPU automatically disables interrupts when executing an IRQ vector,
 602  * so IRQ-flags tracing has to follow that:
 603  */
 604         ALIGN
 605 common_interrupt:
 606         SAVE_ALL
 607         TRACE_IRQS_OFF
 608         movl %esp,%eax
 609         call do_IRQ
 610         jmp ret_from_intr
 611 ENDPROC(common_interrupt)
 612         CFI_ENDPROC
 613
 614 #define BUILD_INTERRUPT(name, nr)       \
 615 ENTRY(name)                             \
 616         RING0_INT_FRAME;                \
 617         pushl $~(nr);                   \
 618         CFI_ADJUST_CFA_OFFSET 4;        \
 619         SAVE_ALL;                       \
 620         TRACE_IRQS_OFF                  \
 621         movl %esp,%eax;                 \
 622         call smp_##name;                \
 623         jmp ret_from_intr;              \
 624         CFI_ENDPROC;                    \
 625 ENDPROC(name)
 626
 627 /* The include is where all of the SMP etc. interrupts come from */
 628 #include "entry_arch.h"
 629
 630 KPROBE_ENTRY(page_fault)
 631         RING0_EC_FRAME
 632         pushl $do_page_fault
 633         CFI_ADJUST_CFA_OFFSET 4
 634         ALIGN
 635 error_code:
 636         /* the function address is in %fs's slot on the stack */
 637         pushl %es
 638         CFI_ADJUST_CFA_OFFSET 4
 639         /*CFI_REL_OFFSET es, 0*/
 640         pushl %ds
 641         CFI_ADJUST_CFA_OFFSET 4
 642         /*CFI_REL_OFFSET ds, 0*/
 643         pushl %eax
 644         CFI_ADJUST_CFA_OFFSET 4
 645         CFI_REL_OFFSET eax, 0
 646         pushl %ebp
 647         CFI_ADJUST_CFA_OFFSET 4
 648         CFI_REL_OFFSET ebp, 0
 649         pushl %edi
 650         CFI_ADJUST_CFA_OFFSET 4
 651         CFI_REL_OFFSET edi, 0
 652         pushl %esi
 653         CFI_ADJUST_CFA_OFFSET 4
 654         CFI_REL_OFFSET esi, 0
 655         pushl %edx
 656         CFI_ADJUST_CFA_OFFSET 4
 657         CFI_REL_OFFSET edx, 0
 658         pushl %ecx
 659         CFI_ADJUST_CFA_OFFSET 4
 660         CFI_REL_OFFSET ecx, 0
 661         pushl %ebx
 662         CFI_ADJUST_CFA_OFFSET 4
 663         CFI_REL_OFFSET ebx, 0
 664         cld
 665         pushl %fs
 666         CFI_ADJUST_CFA_OFFSET 4
 667         /*CFI_REL_OFFSET fs, 0*/
 668         movl $(__KERNEL_PERCPU), %ecx
 669         movl %ecx, %fs
 670         UNWIND_ESPFIX_STACK
 671         popl %ecx
 672         CFI_ADJUST_CFA_OFFSET -4
 673         /*CFI_REGISTER es, ecx*/
 674         movl PT_FS(%esp), %edi          # get the function address
 675         movl PT_ORIG_EAX(%esp), %edx    # get the error code
 676         movl $-1, PT_ORIG_EAX(%esp)     # no syscall to restart
 677         mov  %ecx, PT_FS(%esp)
 678         /*CFI_REL_OFFSET fs, ES*/
 679         movl $(__USER_DS), %ecx
 680         movl %ecx, %ds
 681         movl %ecx, %es
 682         movl %esp,%eax                  # pt_regs pointer
 683         call *%edi
 684         jmp ret_from_exception
 685         CFI_ENDPROC
 686 KPROBE_END(page_fault)
 687
 688 ENTRY(coprocessor_error)
 689         RING0_INT_FRAME
 690         pushl $0
 691         CFI_ADJUST_CFA_OFFSET 4
 692         pushl $do_coprocessor_error
 693         CFI_ADJUST_CFA_OFFSET 4
 694         jmp error_code
 695         CFI_ENDPROC
 696 END(coprocessor_error)
 697
 698 ENTRY(simd_coprocessor_error)
 699         RING0_INT_FRAME
 700         pushl $0
 701         CFI_ADJUST_CFA_OFFSET 4
 702         pushl $do_simd_coprocessor_error
 703         CFI_ADJUST_CFA_OFFSET 4
 704         jmp error_code
 705         CFI_ENDPROC
 706 END(simd_coprocessor_error)
 707
 708 ENTRY(device_not_available)
 709         RING0_INT_FRAME
 710         pushl $-1                       # mark this as an int
 711         CFI_ADJUST_CFA_OFFSET 4
 712         SAVE_ALL
 713         GET_CR0_INTO_EAX
 714         testl $0x4, %eax                # EM (math emulation bit)
 715         jne device_not_available_emulate
 716         preempt_stop(CLBR_ANY)
 717         call math_state_restore
 718         jmp ret_from_exception
 719 device_not_available_emulate:
 720         pushl $0                        # temporary storage for ORIG_EIP
 721         CFI_ADJUST_CFA_OFFSET 4
 722         call math_emulate
 723         addl $4, %esp
 724         CFI_ADJUST_CFA_OFFSET -4
 725         jmp ret_from_exception
 726         CFI_ENDPROC
 727 END(device_not_available)
 728
 729 /*
 730  * Debug traps and NMI can happen at the one SYSENTER instruction
 731  * that sets up the real kernel stack. Check here, since we can't
 732  * allow the wrong stack to be used.
 733  *
 734  * "TSS_sysenter_sp0+12" is because the NMI/debug handler will have
 735  * already pushed 3 words if it hits on the sysenter instruction:
 736  * eflags, cs and eip.
 737  *
 738  * We just load the right stack, and push the three (known) values
 739  * by hand onto the new stack - while updating the return eip past
 740  * the instruction that would have done it for sysenter.
 741  */
 742 #define FIX_STACK(offset, ok, label)            \
 743         cmpw $__KERNEL_CS,4(%esp);              \
 744         jne ok;                                 \
 745 label:                                          \
 746         movl TSS_sysenter_sp0+offset(%esp),%esp;        \
 747         CFI_DEF_CFA esp, 0;                     \
 748         CFI_UNDEFINED eip;                      \
 749         pushfl;                                 \
 750         CFI_ADJUST_CFA_OFFSET 4;                \
 751         pushl $__KERNEL_CS;                     \
 752         CFI_ADJUST_CFA_OFFSET 4;                \
 753         pushl $sysenter_past_esp;               \
 754         CFI_ADJUST_CFA_OFFSET 4;                \
 755         CFI_REL_OFFSET eip, 0
 756
 757 KPROBE_ENTRY(debug)
 758         RING0_INT_FRAME
 759         cmpl $ia32_sysenter_target,(%esp)
 760         jne debug_stack_correct
 761         FIX_STACK(12, debug_stack_correct, debug_esp_fix_insn)
 762 debug_stack_correct:
 763         pushl $-1                       # mark this as an int
 764         CFI_ADJUST_CFA_OFFSET 4
 765         SAVE_ALL
 766         xorl %edx,%edx                  # error code 0
 767         movl %esp,%eax                  # pt_regs pointer
 768         call do_debug
 769         jmp ret_from_exception
 770         CFI_ENDPROC
 771 KPROBE_END(debug)
 772
 773 /*
 774  * NMI is doubly nasty. It can happen _while_ we're handling
 775  * a debug fault, and the debug fault hasn't yet been able to
 776  * clear up the stack. So we first check whether we got  an
 777  * NMI on the sysenter entry path, but after that we need to
 778  * check whether we got an NMI on the debug path where the debug
 779  * fault happened on the sysenter path.
 780  */
 781 KPROBE_ENTRY(nmi)
 782         RING0_INT_FRAME
 783         pushl %eax
 784         CFI_ADJUST_CFA_OFFSET 4
 785         movl %ss, %eax
 786         cmpw $__ESPFIX_SS, %ax
 787         popl %eax
 788         CFI_ADJUST_CFA_OFFSET -4
 789         je nmi_espfix_stack
 790         cmpl $ia32_sysenter_target,(%esp)
 791         je nmi_stack_fixup
 792         pushl %eax
 793         CFI_ADJUST_CFA_OFFSET 4
 794         movl %esp,%eax
 795         /* Do not access memory above the end of our stack page,
 796          * it might not exist.
 797          */
 798         andl $(THREAD_SIZE-1),%eax
 799         cmpl $(THREAD_SIZE-20),%eax
 800         popl %eax
 801         CFI_ADJUST_CFA_OFFSET -4
 802         jae nmi_stack_correct
 803         cmpl $ia32_sysenter_target,12(%esp)
 804         je nmi_debug_stack_check
 805 nmi_stack_correct:
 806         /* We have a RING0_INT_FRAME here */
 807         pushl %eax
 808         CFI_ADJUST_CFA_OFFSET 4
 809         SAVE_ALL
 810         xorl %edx,%edx          # zero error code
 811         movl %esp,%eax          # pt_regs pointer
 812         call do_nmi
 813         jmp restore_nocheck_notrace
 814         CFI_ENDPROC
 815
 816 nmi_stack_fixup:
 817         RING0_INT_FRAME
 818         FIX_STACK(12,nmi_stack_correct, 1)
 819         jmp nmi_stack_correct
 820
 821 nmi_debug_stack_check:
 822         /* We have a RING0_INT_FRAME here */
 823         cmpw $__KERNEL_CS,16(%esp)
 824         jne nmi_stack_correct
 825         cmpl $debug,(%esp)
 826         jb nmi_stack_correct
 827         cmpl $debug_esp_fix_insn,(%esp)
 828         ja nmi_stack_correct
 829         FIX_STACK(24,nmi_stack_correct, 1)
 830         jmp nmi_stack_correct
 831
 832 nmi_espfix_stack:
 833         /* We have a RING0_INT_FRAME here.
 834          *
 835          * create the pointer to lss back
 836          */
 837         pushl %ss
 838         CFI_ADJUST_CFA_OFFSET 4
 839         pushl %esp
 840         CFI_ADJUST_CFA_OFFSET 4
 841         addw $4, (%esp)
 842         /* copy the iret frame of 12 bytes */
 843         .rept 3
 844         pushl 16(%esp)
 845         CFI_ADJUST_CFA_OFFSET 4
 846         .endr
 847         pushl %eax
 848         CFI_ADJUST_CFA_OFFSET 4
 849         SAVE_ALL
 850         FIXUP_ESPFIX_STACK              # %eax == %esp
 851         xorl %edx,%edx                  # zero error code
 852         call do_nmi
 853         RESTORE_REGS
 854         lss 12+4(%esp), %esp            # back to espfix stack
 855         CFI_ADJUST_CFA_OFFSET -24
 856         jmp irq_return
 857         CFI_ENDPROC
 858 KPROBE_END(nmi)
 859
 860 #ifdef CONFIG_PARAVIRT
 861 ENTRY(native_iret)
 862         iret
 863 .section __ex_table,"a"
 864         .align 4
 865         .long native_iret, iret_exc
 866 .previous
 867 END(native_iret)
 868
 869 ENTRY(native_irq_enable_sysexit)
 870         sti
 871         sysexit
 872 END(native_irq_enable_sysexit)
 873 #endif
 874
 875 KPROBE_ENTRY(int3)
 876         RING0_INT_FRAME
 877         pushl $-1                       # mark this as an int
 878         CFI_ADJUST_CFA_OFFSET 4
 879         SAVE_ALL
 880         xorl %edx,%edx          # zero error code
 881         movl %esp,%eax          # pt_regs pointer
 882         call do_int3
 883         jmp ret_from_exception
 884         CFI_ENDPROC
 885 KPROBE_END(int3)
 886
 887 ENTRY(overflow)
 888         RING0_INT_FRAME
 889         pushl $0
 890         CFI_ADJUST_CFA_OFFSET 4
 891         pushl $do_overflow
 892         CFI_ADJUST_CFA_OFFSET 4
 893         jmp error_code
 894         CFI_ENDPROC
 895 END(overflow)
 896
 897 ENTRY(bounds)
 898         RING0_INT_FRAME
 899         pushl $0
 900         CFI_ADJUST_CFA_OFFSET 4
 901         pushl $do_bounds
 902         CFI_ADJUST_CFA_OFFSET 4
 903         jmp error_code
 904         CFI_ENDPROC
 905 END(bounds)
 906
 907 ENTRY(invalid_op)
 908         RING0_INT_FRAME
 909         pushl $0
 910         CFI_ADJUST_CFA_OFFSET 4
 911         pushl $do_invalid_op
 912         CFI_ADJUST_CFA_OFFSET 4
 913         jmp error_code
 914         CFI_ENDPROC
 915 END(invalid_op)
 916
 917 ENTRY(coprocessor_segment_overrun)
 918         RING0_INT_FRAME
 919         pushl $0
 920         CFI_ADJUST_CFA_OFFSET 4
 921         pushl $do_coprocessor_segment_overrun
 922         CFI_ADJUST_CFA_OFFSET 4
 923         jmp error_code
 924         CFI_ENDPROC
 925 END(coprocessor_segment_overrun)
 926
 927 ENTRY(invalid_TSS)
 928         RING0_EC_FRAME
 929         pushl $do_invalid_TSS
 930         CFI_ADJUST_CFA_OFFSET 4
 931         jmp error_code
 932         CFI_ENDPROC
 933 END(invalid_TSS)
 934
 935 ENTRY(segment_not_present)
 936         RING0_EC_FRAME
 937         pushl $do_segment_not_present
 938         CFI_ADJUST_CFA_OFFSET 4
 939         jmp error_code
 940         CFI_ENDPROC
 941 END(segment_not_present)
 942
 943 ENTRY(stack_segment)
 944         RING0_EC_FRAME
 945         pushl $do_stack_segment
 946         CFI_ADJUST_CFA_OFFSET 4
 947         jmp error_code
 948         CFI_ENDPROC
 949 END(stack_segment)
 950
 951 KPROBE_ENTRY(general_protection)
 952         RING0_EC_FRAME
 953         pushl $do_general_protection
 954         CFI_ADJUST_CFA_OFFSET 4
 955         jmp error_code
 956         CFI_ENDPROC
 957 KPROBE_END(general_protection)
 958
 959 ENTRY(alignment_check)
 960         RING0_EC_FRAME
 961         pushl $do_alignment_check
 962         CFI_ADJUST_CFA_OFFSET 4
 963         jmp error_code
 964         CFI_ENDPROC
 965 END(alignment_check)
 966
 967 ENTRY(divide_error)
 968         RING0_INT_FRAME
 969         pushl $0                        # no error code
 970         CFI_ADJUST_CFA_OFFSET 4
 971         pushl $do_divide_error
 972         CFI_ADJUST_CFA_OFFSET 4
 973         jmp error_code
 974         CFI_ENDPROC
 975 END(divide_error)
 976
 977 #ifdef CONFIG_X86_MCE
 978 ENTRY(machine_check)
 979         RING0_INT_FRAME
 980         pushl $0
 981         CFI_ADJUST_CFA_OFFSET 4
 982         pushl machine_check_vector
 983         CFI_ADJUST_CFA_OFFSET 4
 984         jmp error_code
 985         CFI_ENDPROC
 986 END(machine_check)
 987 #endif
 988
 989 ENTRY(spurious_interrupt_bug)
 990         RING0_INT_FRAME
 991         pushl $0
 992         CFI_ADJUST_CFA_OFFSET 4
 993         pushl $do_spurious_interrupt_bug
 994         CFI_ADJUST_CFA_OFFSET 4
 995         jmp error_code
 996         CFI_ENDPROC
 997 END(spurious_interrupt_bug)
 998
 999 ENTRY(kernel_thread_helper)
1000         pushl $0                # fake return address for unwinder
1001         CFI_STARTPROC
1002         movl %edx,%eax
1003         push %edx
1004         CFI_ADJUST_CFA_OFFSET 4
1005         call *%ebx
1006         push %eax
1007         CFI_ADJUST_CFA_OFFSET 4
1008         call do_exit
1009         CFI_ENDPROC
1010 ENDPROC(kernel_thread_helper)
1011
1012 #ifdef CONFIG_XEN
1013 /* Xen doesn't set %esp to be precisely what the normal sysenter
1014    entrypoint expects, so fix it up before using the normal path. */
1015 ENTRY(xen_sysenter_target)
1016         RING0_INT_FRAME
1017         addl $5*4, %esp         /* remove xen-provided frame */
1018         CFI_ADJUST_CFA_OFFSET -5*4
1019         jmp sysenter_past_esp
1020         CFI_ENDPROC
1021
1022 ENTRY(xen_hypervisor_callback)
1023         CFI_STARTPROC
1024         pushl $0
1025         CFI_ADJUST_CFA_OFFSET 4
1026         SAVE_ALL
1027         TRACE_IRQS_OFF
1028
1029         /* Check to see if we got the event in the critical
1030            region in xen_iret_direct, after we've reenabled
1031            events and checked for pending events.  This simulates
1032            iret instruction's behaviour where it delivers a
1033            pending interrupt when enabling interrupts. */
1034         movl PT_EIP(%esp),%eax
1035         cmpl $xen_iret_start_crit,%eax
1036         jb   1f
1037         cmpl $xen_iret_end_crit,%eax
1038         jae  1f
1039
1040         jmp  xen_iret_crit_fixup
1041
1042 ENTRY(xen_do_upcall)
1043 1:      mov %esp, %eax
1044         call xen_evtchn_do_upcall
1045         jmp  ret_from_intr
1046         CFI_ENDPROC
1047 ENDPROC(xen_hypervisor_callback)
1048
1049 # Hypervisor uses this for application faults while it executes.
1050 # We get here for two reasons:
1051 #  1. Fault while reloading DS, ES, FS or GS
1052 #  2. Fault while executing IRET
1053 # Category 1 we fix up by reattempting the load, and zeroing the segment
1054 # register if the load fails.
1055 # Category 2 we fix up by jumping to do_iret_error. We cannot use the
1056 # normal Linux return path in this case because if we use the IRET hypercall
1057 # to pop the stack frame we end up in an infinite loop of failsafe callbacks.
1058 # We distinguish between categories by maintaining a status value in EAX.
1059 ENTRY(xen_failsafe_callback)
1060         CFI_STARTPROC
1061         pushl %eax
1062         CFI_ADJUST_CFA_OFFSET 4
1063         movl $1,%eax
1064 1:      mov 4(%esp),%ds
1065 2:      mov 8(%esp),%es
1066 3:      mov 12(%esp),%fs
1067 4:      mov 16(%esp),%gs
1068         testl %eax,%eax
1069         popl %eax
1070         CFI_ADJUST_CFA_OFFSET -4
1071         lea 16(%esp),%esp
1072         CFI_ADJUST_CFA_OFFSET -16
1073         jz 5f
1074         addl $16,%esp
1075         jmp iret_exc            # EAX != 0 => Category 2 (Bad IRET)
1076 5:      pushl $0                # EAX == 0 => Category 1 (Bad segment)
1077         CFI_ADJUST_CFA_OFFSET 4
1078         SAVE_ALL
1079         jmp ret_from_exception
1080         CFI_ENDPROC
1081
1082 .section .fixup,"ax"
1083 6:      xorl %eax,%eax
1084         movl %eax,4(%esp)
1085         jmp 1b
1086 7:      xorl %eax,%eax
1087         movl %eax,8(%esp)
1088         jmp 2b
1089 8:      xorl %eax,%eax
1090         movl %eax,12(%esp)
1091         jmp 3b
1092 9:      xorl %eax,%eax
1093         movl %eax,16(%esp)
1094         jmp 4b
1095 .previous
1096 .section __ex_table,"a"
1097         .align 4
1098         .long 1b,6b
1099         .long 2b,7b
1100         .long 3b,8b
1101         .long 4b,9b
1102 .previous
1103 ENDPROC(xen_failsafe_callback)
1104
1105 #endif  /* CONFIG_XEN */
1106
1107 #ifdef CONFIG_FTRACE
1108 #ifdef CONFIG_DYNAMIC_FTRACE
1109
1110 ENTRY(mcount)
1111         pushl %eax
1112         pushl %ecx
1113         pushl %edx
1114         movl 0xc(%esp), %eax
1115         subl $MCOUNT_INSN_SIZE, %eax
1116
1117 .globl mcount_call
1118 mcount_call:
1119         call ftrace_stub
1120
1121         popl %edx
1122         popl %ecx
1123         popl %eax
1124
1125         ret
1126 END(mcount)
1127
1128 ENTRY(ftrace_caller)
1129         pushl %eax
1130         pushl %ecx
1131         pushl %edx
1132         movl 0xc(%esp), %eax
1133         movl 0x4(%ebp), %edx
1134         subl $MCOUNT_INSN_SIZE, %eax
1135
1136 .globl ftrace_call
1137 ftrace_call:
1138         call ftrace_stub
1139
1140         popl %edx
1141         popl %ecx
1142         popl %eax
1143
1144 .globl ftrace_stub
1145 ftrace_stub:
1146         ret
1147 END(ftrace_caller)
1148
1149 #else /* ! CONFIG_DYNAMIC_FTRACE */
1150
1151 ENTRY(mcount)
1152         cmpl $ftrace_stub, ftrace_trace_function
1153         jnz trace
1154 .globl ftrace_stub
1155 ftrace_stub:
1156         ret
1157
1158         /* taken from glibc */
1159 trace:
1160         pushl %eax
1161         pushl %ecx
1162         pushl %edx
1163         movl 0xc(%esp), %eax
1164         movl 0x4(%ebp), %edx
1165         subl $MCOUNT_INSN_SIZE, %eax
1166
1167         call *ftrace_trace_function
1168
1169         popl %edx
1170         popl %ecx
1171         popl %eax
1172
1173         jmp ftrace_stub
1174 END(mcount)
1175 #endif /* CONFIG_DYNAMIC_FTRACE */
1176 #endif /* CONFIG_FTRACE */
1177
1178 .section .rodata,"a"
1179 #include "syscall_table_32.S"
1180
1181 syscall_table_size=(.-sys_call_table)