sys/platform/pc64/x86_64/exception.S

   1 /*-
   2  * Copyright (c) 1989, 1990 William F. Jolitz.
   3  * Copyright (c) 1990 The Regents of the University of California.
   4  * Copyright (c) 2007 The FreeBSD Foundation
   5  * Copyright (c) 2008 The DragonFly Project.
   6  * Copyright (c) 2008 Jordan Gordeev.
   7  * All rights reserved.
   8  *
   9  * Portions of this software were developed by A. Joseph Koshy under
  10  * sponsorship from the FreeBSD Foundation and Google, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #if JG
  38 #include "opt_atpic.h"
  39 #endif
  40 #include "opt_compat.h"
  41
  42 #include <machine/asmacros.h>
  43 #include <machine/psl.h>
  44 #include <machine/trap.h>
  45 #include <machine/segments.h>
  46
  47 #include "assym.s"
  48
  49         .text
  50
  51         .globl  lwkt_switch_return
  52
  53 /*****************************************************************************/
  54 /* Trap handling                                                             */
  55 /*****************************************************************************/
  56 /*
  57  * Trap and fault vector routines.
  58  *
  59  * All traps are 'interrupt gates', SDT_SYSIGT.  An interrupt gate pushes
  60  * state on the stack but also disables interrupts.  This is important for
  61  * us for the use of the swapgs instruction.  We cannot be interrupted
  62  * until the GS.base value is correct.  For most traps, we automatically
  63  * then enable interrupts if the interrupted context had them enabled.
  64  * This is equivalent to the i386 port's use of SDT_SYS386TGT.
  65  *
  66  * The cpu will push a certain amount of state onto the kernel stack for
  67  * the current process.  See x86_64/include/frame.h.
  68  * This includes the current RFLAGS (status register, which includes
  69  * the interrupt disable state prior to the trap), the code segment register,
  70  * and the return instruction pointer are pushed by the cpu.  The cpu
  71  * will also push an 'error' code for certain traps.  We push a dummy
  72  * error code for those traps where the cpu doesn't in order to maintain
  73  * a consistent frame.  We also push a contrived 'trap number'.
  74  *
  75  * The cpu does not push the general registers, we must do that, and we
  76  * must restore them prior to calling 'iret'.  The cpu adjusts the %cs and
  77  * %ss segment registers, but does not mess with %ds, %es, or %fs.  Thus we
  78  * must load them with appropriate values for supervisor mode operation.
  79  */
  80
  81 MCOUNT_LABEL(user)
  82 MCOUNT_LABEL(btrap)
  83
  84 /*
  85  * Interrupts are enabled for all traps, otherwise horrible livelocks
  86  * can occur with the smp_invltlb and cpusync ode.
  87  */
  88 #if 0
  89 #define TRAP_NOEN(a)    \
  90         subq $TF_RIP,%rsp; \
  91         movq $0,TF_XFLAGS(%rsp) ; \
  92         movq $(a),TF_TRAPNO(%rsp) ; \
  93         movq $0,TF_ADDR(%rsp) ; \
  94         movq $0,TF_ERR(%rsp) ; \
  95         jmp alltraps_noen
  96 #endif
  97
  98 /* Regular traps; The cpu does not supply tf_err for these. */
  99 #define TRAP(a)  \
 100         subq $TF_RIP,%rsp; \
 101         movq $0,TF_XFLAGS(%rsp) ; \
 102         movq $(a),TF_TRAPNO(%rsp) ; \
 103         movq $0,TF_ADDR(%rsp) ; \
 104         movq $0,TF_ERR(%rsp) ; \
 105         jmp alltraps
 106 IDTVEC(dbg)
 107         TRAP(T_TRCTRAP)
 108 IDTVEC(bpt)
 109         TRAP(T_BPTFLT)
 110 IDTVEC(div)
 111         TRAP(T_DIVIDE)
 112 IDTVEC(ofl)
 113         TRAP(T_OFLOW)
 114 IDTVEC(bnd)
 115         TRAP(T_BOUND)
 116 IDTVEC(ill)
 117         TRAP(T_PRIVINFLT)
 118 IDTVEC(dna)
 119         TRAP(T_DNA)
 120 IDTVEC(fpusegm)
 121         TRAP(T_FPOPFLT)
 122 IDTVEC(mchk)
 123         TRAP(T_MCHK)
 124 IDTVEC(rsvd)
 125         TRAP(T_RESERVED)
 126 IDTVEC(fpu)
 127         TRAP(T_ARITHTRAP)
 128 IDTVEC(xmm)
 129         TRAP(T_XMMFLT)
 130
 131 /* This group of traps have tf_err already pushed by the cpu */
 132 #define TRAP_ERR(a)     \
 133         subq $TF_ERR,%rsp; \
 134         movq $(a),TF_TRAPNO(%rsp) ; \
 135         movq $0,TF_ADDR(%rsp) ; \
 136         movq $0,TF_XFLAGS(%rsp) ; \
 137         jmp alltraps
 138 IDTVEC(tss)
 139         TRAP_ERR(T_TSSFLT)
 140 IDTVEC(missing)
 141         TRAP_ERR(T_SEGNPFLT)
 142 IDTVEC(stk)
 143         TRAP_ERR(T_STKFLT)
 144 IDTVEC(align)
 145         TRAP_ERR(T_ALIGNFLT)
 146
 147         /*
 148          * alltraps entry point.  Use swapgs if this is the first time in the
 149          * kernel from userland.  Reenable interrupts if they were enabled
 150          * before the trap.  This approximates SDT_SYS386TGT on the i386 port.
 151          */
 152
 153         SUPERALIGN_TEXT
 154         .globl  alltraps
 155         .type   alltraps,@function
 156 alltraps:
 157         /* Fixup %gs if coming from userland */
 158         testb   $SEL_RPL_MASK,TF_CS(%rsp)
 159         jz      alltraps_testi
 160         swapgs
 161 alltraps_testi:
 162         testq   $PSL_I,TF_RFLAGS(%rsp)
 163         jz      alltraps_pushregs
 164         sti
 165 alltraps_pushregs:
 166         movq    %rdi,TF_RDI(%rsp)
 167 alltraps_pushregs_no_rdi:
 168         movq    %rsi,TF_RSI(%rsp)
 169         movq    %rdx,TF_RDX(%rsp)
 170         movq    %rcx,TF_RCX(%rsp)
 171         movq    %r8,TF_R8(%rsp)
 172         movq    %r9,TF_R9(%rsp)
 173         movq    %rax,TF_RAX(%rsp)
 174         movq    %rbx,TF_RBX(%rsp)
 175         movq    %rbp,TF_RBP(%rsp)
 176         movq    %r10,TF_R10(%rsp)
 177         movq    %r11,TF_R11(%rsp)
 178         movq    %r12,TF_R12(%rsp)
 179         movq    %r13,TF_R13(%rsp)
 180         movq    %r14,TF_R14(%rsp)
 181         movq    %r15,TF_R15(%rsp)
 182         FAKE_MCOUNT(TF_RIP(%rsp))
 183         .globl  calltrap
 184         .type   calltrap,@function
 185 calltrap:
 186         movq    %rsp, %rdi
 187         call    trap
 188         MEXITCOUNT
 189         jmp     doreti                  /* Handle any pending ASTs */
 190
 191         /*
 192          * alltraps_noen entry point.  Unlike alltraps above, we want to
 193          * leave the interrupts disabled.  This corresponds to
 194          * SDT_SYS386IGT on the i386 port.
 195          */
 196         SUPERALIGN_TEXT
 197         .globl  alltraps_noen
 198         .type   alltraps_noen,@function
 199 alltraps_noen:
 200         /* Fixup %gs if coming from userland */
 201         testb   $SEL_RPL_MASK,TF_CS(%rsp)
 202         jz      alltraps_pushregs
 203         swapgs
 204         jmp     alltraps_pushregs
 205
 206 IDTVEC(dblfault)
 207         subq    $TF_ERR,%rsp
 208         movq    $T_DOUBLEFLT,TF_TRAPNO(%rsp)
 209         movq    $0,TF_ADDR(%rsp)
 210         movq    $0,TF_ERR(%rsp)
 211         movq    $0,TF_XFLAGS(%rsp)
 212         movq    %rdi,TF_RDI(%rsp)
 213         movq    %rsi,TF_RSI(%rsp)
 214         movq    %rdx,TF_RDX(%rsp)
 215         movq    %rcx,TF_RCX(%rsp)
 216         movq    %r8,TF_R8(%rsp)
 217         movq    %r9,TF_R9(%rsp)
 218         movq    %rax,TF_RAX(%rsp)
 219         movq    %rbx,TF_RBX(%rsp)
 220         movq    %rbp,TF_RBP(%rsp)
 221         movq    %r10,TF_R10(%rsp)
 222         movq    %r11,TF_R11(%rsp)
 223         movq    %r12,TF_R12(%rsp)
 224         movq    %r13,TF_R13(%rsp)
 225         movq    %r14,TF_R14(%rsp)
 226         movq    %r15,TF_R15(%rsp)
 227         testb   $SEL_RPL_MASK,TF_CS(%rsp)
 228         jz      1f
 229         swapgs
 230 1:      movq    %rsp, %rdi
 231         call    dblfault_handler
 232 2:      hlt
 233         jmp     2b
 234
 235 IDTVEC(page)
 236         subq    $TF_ERR,%rsp
 237         movq    $T_PAGEFLT,TF_TRAPNO(%rsp)
 238         /* Fixup %gs if coming from userland */
 239         testb   $SEL_RPL_MASK,TF_CS(%rsp)
 240         jz      1f
 241         swapgs
 242 1:
 243         movq    %rdi,TF_RDI(%rsp)       /* free up a GP register */
 244         movq    %cr2,%rdi               /* preserve %cr2 before ..  */
 245         movq    %rdi,TF_ADDR(%rsp)      /* enabling interrupts. */
 246         movq    $0,TF_XFLAGS(%rsp)
 247         testq   $PSL_I,TF_RFLAGS(%rsp)
 248         jz      alltraps_pushregs_no_rdi
 249         sti
 250         jmp     alltraps_pushregs_no_rdi
 251
 252         /*
 253          * We have to special-case this one.  If we get a trap in doreti() at
 254          * the iretq stage, we'll reenter with the wrong gs state.  We'll have
 255          * to do a special the swapgs in this case even coming from the kernel.
 256          * XXX linux has a trap handler for their equivalent of load_gs().
 257          */
 258 IDTVEC(prot)
 259         subq    $TF_ERR,%rsp
 260         movq    $T_PROTFLT,TF_TRAPNO(%rsp)
 261         movq    $0,TF_ADDR(%rsp)
 262         movq    $0,TF_XFLAGS(%rsp)
 263         movq    %rdi,TF_RDI(%rsp)       /* free up a GP register */
 264
 265         /*
 266          * Fixup %gs if coming from userland.  Handle the special case where
 267          * %fs faults in doreti at the iretq instruction itself.
 268          */
 269         leaq    doreti_iret(%rip),%rdi
 270         cmpq    %rdi,TF_RIP(%rsp)               /* special iretq fault case */
 271         je      2f
 272         testb   $SEL_RPL_MASK,TF_CS(%rsp)       /* check if from userland */
 273         jz      1f
 274 2:
 275         swapgs
 276 1:
 277         testq   $PSL_I,TF_RFLAGS(%rsp)
 278         jz      alltraps_pushregs_no_rdi
 279         sti
 280         jmp     alltraps_pushregs_no_rdi
 281
 282 /*
 283  * Fast syscall entry point.  We enter here with just our new %cs/%ss set,
 284  * and the new privilige level.  We are still running on the old user stack
 285  * pointer.  We have to juggle a few things around to find our stack etc.
 286  * swapgs gives us access to our PCPU space only.
 287  */
 288 IDTVEC(fast_syscall)
 289         swapgs
 290         movq    %rsp,PCPU(scratch_rsp)
 291         movq    PCPU(common_tss) + TSS_RSP0, %rsp
 292         /* Now emulate a trapframe. Make the 8 byte alignment odd for call. */
 293         subq    $TF_SIZE,%rsp
 294         /* defer TF_RSP till we have a spare register */
 295         movq    %r11,TF_RFLAGS(%rsp)
 296         movq    %rcx,TF_RIP(%rsp)       /* %rcx original value is in %r10 */
 297         movq    PCPU(scratch_rsp),%r11  /* %r11 already saved */
 298         movq    %r11,TF_RSP(%rsp)       /* user stack pointer */
 299         orl     $RQF_QUICKRET,PCPU(reqflags)
 300         sti
 301         movq    $KUDSEL,TF_SS(%rsp)
 302         movq    $KUCSEL,TF_CS(%rsp)
 303         movq    $2,TF_ERR(%rsp)
 304         movq    $T_FAST_SYSCALL,TF_TRAPNO(%rsp) /* for the vkernel */
 305         movq    $0,TF_XFLAGS(%rsp)      /* note: used in signal frame */
 306         movq    %rdi,TF_RDI(%rsp)       /* arg 1 */
 307         movq    %rsi,TF_RSI(%rsp)       /* arg 2 */
 308         movq    %rdx,TF_RDX(%rsp)       /* arg 3 */
 309         movq    %r10,TF_RCX(%rsp)       /* arg 4 */
 310         movq    %r8,TF_R8(%rsp)         /* arg 5 */
 311         movq    %r9,TF_R9(%rsp)         /* arg 6 */
 312         movq    %rax,TF_RAX(%rsp)       /* syscall number */
 313         movq    %rbx,TF_RBX(%rsp)       /* C preserved */
 314         movq    %rbp,TF_RBP(%rsp)       /* C preserved */
 315         movq    %r12,TF_R12(%rsp)       /* C preserved */
 316         movq    %r13,TF_R13(%rsp)       /* C preserved */
 317         movq    %r14,TF_R14(%rsp)       /* C preserved */
 318         movq    %r15,TF_R15(%rsp)       /* C preserved */
 319         FAKE_MCOUNT(TF_RIP(%rsp))
 320         movq    %rsp, %rdi
 321         call    syscall2
 322
 323         /*
 324          * Fast return from system call
 325          */
 326         cli
 327         testl   $RQF_IPIQ|RQF_TIMER|RQF_INTPEND|RQF_AST_MASK,PCPU(reqflags)
 328         jnz     1f
 329         testl   $RQF_QUICKRET,PCPU(reqflags)
 330         jz      1f
 331         MEXITCOUNT
 332         movq    TF_RDI(%rsp),%rdi
 333         movq    TF_RSI(%rsp),%rsi
 334         movq    TF_RDX(%rsp),%rdx
 335         movq    TF_RAX(%rsp),%rax
 336         movq    TF_RFLAGS(%rsp),%r11
 337         movq    TF_RIP(%rsp),%rcx
 338         movq    TF_RSP(%rsp),%rsp
 339         swapgs
 340         sysretq
 341         /*
 342          * Normal slow / full iret
 343          */
 344 1:
 345         MEXITCOUNT
 346         jmp     doreti
 347
 348 /*
 349  * Here for CYA insurance, in case a "syscall" instruction gets
 350  * issued from 32 bit compatability mode. MSR_CSTAR has to point
 351  * to *something* if EFER_SCE is enabled.
 352  */
 353 IDTVEC(fast_syscall32)
 354         sysret
 355
 356 /*
 357  * NMI handling is special.
 358  *
 359  * First, NMIs do not respect the state of the processor's RFLAGS.IF
 360  * bit and the NMI handler may be invoked at any time, including when
 361  * the processor is in a critical section with RFLAGS.IF == 0.  In
 362  * particular, this means that the processor's GS.base values could be
 363  * inconsistent on entry to the handler, and so we need to read
 364  * MSR_GSBASE to determine if a 'swapgs' is needed.  We use '%ebx', a
 365  * C-preserved register, to remember whether to swap GS back on the
 366  * exit path.
 367  *
 368  * Second, the processor treats NMIs specially, blocking further NMIs
 369  * until an 'iretq' instruction is executed.  We therefore need to
 370  * execute the NMI handler with interrupts disabled to prevent a
 371  * nested interrupt from executing an 'iretq' instruction and
 372  * inadvertently taking the processor out of NMI mode.
 373  *
 374  * Third, the NMI handler runs on its own stack (tss_ist1), shared
 375  * with the double fault handler.
 376  */
 377
 378 IDTVEC(nmi)
 379         subq    $TF_RIP,%rsp
 380         movq    $(T_NMI),TF_TRAPNO(%rsp)
 381         movq    $0,TF_ADDR(%rsp)
 382         movq    $0,TF_ERR(%rsp)
 383         movq    $0,TF_XFLAGS(%rsp)
 384         movq    %rdi,TF_RDI(%rsp)
 385         movq    %rsi,TF_RSI(%rsp)
 386         movq    %rdx,TF_RDX(%rsp)
 387         movq    %rcx,TF_RCX(%rsp)
 388         movq    %r8,TF_R8(%rsp)
 389         movq    %r9,TF_R9(%rsp)
 390         movq    %rax,TF_RAX(%rsp)
 391         movq    %rbx,TF_RBX(%rsp)
 392         movq    %rbp,TF_RBP(%rsp)
 393         movq    %r10,TF_R10(%rsp)
 394         movq    %r11,TF_R11(%rsp)
 395         movq    %r12,TF_R12(%rsp)
 396         movq    %r13,TF_R13(%rsp)
 397         movq    %r14,TF_R14(%rsp)
 398         movq    %r15,TF_R15(%rsp)
 399         xorl    %ebx,%ebx
 400         testb   $SEL_RPL_MASK,TF_CS(%rsp)
 401         jnz     nmi_needswapgs          /* we came from userland */
 402         movl    $MSR_GSBASE,%ecx
 403         rdmsr
 404         cmpl    $VM_MAX_USER_ADDRESS >> 32,%edx
 405         jae     nmi_calltrap            /* GS.base holds a kernel VA */
 406 nmi_needswapgs:
 407         incl    %ebx
 408         swapgs
 409 /* Note: this label is also used by ddb and gdb: */
 410 nmi_calltrap:
 411         FAKE_MCOUNT(TF_RIP(%rsp))
 412         movq    %rsp, %rdi
 413         call    trap
 414         MEXITCOUNT
 415         testl   %ebx,%ebx
 416         jz      nmi_restoreregs
 417         swapgs
 418 nmi_restoreregs:
 419         movq    TF_RDI(%rsp),%rdi
 420         movq    TF_RSI(%rsp),%rsi
 421         movq    TF_RDX(%rsp),%rdx
 422         movq    TF_RCX(%rsp),%rcx
 423         movq    TF_R8(%rsp),%r8
 424         movq    TF_R9(%rsp),%r9
 425         movq    TF_RAX(%rsp),%rax
 426         movq    TF_RBX(%rsp),%rbx
 427         movq    TF_RBP(%rsp),%rbp
 428         movq    TF_R10(%rsp),%r10
 429         movq    TF_R11(%rsp),%r11
 430         movq    TF_R12(%rsp),%r12
 431         movq    TF_R13(%rsp),%r13
 432         movq    TF_R14(%rsp),%r14
 433         movq    TF_R15(%rsp),%r15
 434         addq    $TF_RIP,%rsp
 435         iretq
 436
 437 /*
 438  * This function is what cpu_heavy_restore jumps to after a new process
 439  * is created.  The LWKT subsystem switches while holding a critical
 440  * section and we maintain that abstraction here (e.g. because
 441  * cpu_heavy_restore needs it due to PCB_*() manipulation), then get out of
 442  * it before calling the initial function (typically fork_return()) and/or
 443  * returning to user mode.
 444  *
 445  * The MP lock is not held at any point but the critcount is bumped
 446  * on entry to prevent interruption of the trampoline at a bad point.
 447  *
 448  * This is effectively what td->td_switch() returns to.  It 'returns' the
 449  * old thread in %rax and since this is not returning to a td->td_switch()
 450  * call from lwkt_switch() we must handle the cleanup for the old thread
 451  * by calling lwkt_switch_return().
 452  *
 453  * fork_trampoline(%rax:otd, %rbx:func, %r12:arg)
 454  */
 455 ENTRY(fork_trampoline)
 456         movq    %rax,%rdi
 457         call    lwkt_switch_return
 458         movq    PCPU(curthread),%rax
 459         decl    TD_CRITCOUNT(%rax)
 460
 461         /*
 462          * cpu_set_fork_handler intercepts this function call to
 463          * have this call a non-return function to stay in kernel mode.
 464          *
 465          * initproc has its own fork handler, start_init(), which DOES
 466          * return.
 467          *
 468          * %rbx - chaining function (typically fork_return)
 469          * %r12 -> %rdi (argument)
 470          * frame-> %rsi (trap frame)
 471          *
 472          *   void (func:rbx)(arg:rdi, trapframe:rsi)
 473          */
 474         movq    %rsp, %rsi              /* pass trapframe by reference */
 475         movq    %r12, %rdi              /* arg1 */
 476         call    *%rbx                   /* function */
 477
 478         /* cut from syscall */
 479
 480         sti
 481         call    splz
 482
 483         /*
 484          * Return via doreti to handle ASTs.
 485          *
 486          * trapframe is at the top of the stack.
 487          */
 488         MEXITCOUNT
 489         jmp     doreti
 490
 491 /*
 492  * To efficiently implement classification of trap and interrupt handlers
 493  * for profiling, there must be only trap handlers between the labels btrap
 494  * and bintr, and only interrupt handlers between the labels bintr and
 495  * eintr.  This is implemented (partly) by including files that contain
 496  * some of the handlers.  Before including the files, set up a normal asm
 497  * environment so that the included files doen't need to know that they are
 498  * included.
 499  */
 500
 501 #ifdef COMPAT_IA32
 502         .data
 503         .p2align 4
 504         .text
 505         SUPERALIGN_TEXT
 506
 507 #include <x86_64/ia32/ia32_exception.S>
 508 #endif
 509
 510         .data
 511         .p2align 4
 512         .text
 513         SUPERALIGN_TEXT
 514 MCOUNT_LABEL(bintr)
 515
 516 #if JG
 517 #include <x86_64/x86_64/apic_vector.S>
 518 #endif
 519
 520 #ifdef DEV_ATPIC
 521         .data
 522         .p2align 4
 523         .text
 524         SUPERALIGN_TEXT
 525
 526 #include <x86_64/isa/atpic_vector.S>
 527 #endif
 528
 529         .text
 530 MCOUNT_LABEL(eintr)
 531