sys/amd64/amd64/machdep.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 2003 Peter Wemm.
   5  * Copyright (c) 1992 Terrence R. Lambert.
   6  * Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to Berkeley by
  10  * William Jolitz.
  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  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *      This product includes software developed by the University of
  23  *      California, Berkeley and its contributors.
  24  * 4. Neither the name of the University nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  *
  40  *      from: @(#)machdep.c     7.4 (Berkeley) 6/3/91
  41  */
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include "opt_atpic.h"
  47 #include "opt_cpu.h"
  48 #include "opt_ddb.h"
  49 #include "opt_inet.h"
  50 #include "opt_isa.h"
  51 #include "opt_kstack_pages.h"
  52 #include "opt_maxmem.h"
  53 #include "opt_mp_watchdog.h"
  54 #include "opt_pci.h"
  55 #include "opt_platform.h"
  56 #include "opt_sched.h"
  57
  58 #include <sys/param.h>
  59 #include <sys/proc.h>
  60 #include <sys/systm.h>
  61 #include <sys/bio.h>
  62 #include <sys/buf.h>
  63 #include <sys/bus.h>
  64 #include <sys/callout.h>
  65 #include <sys/cons.h>
  66 #include <sys/cpu.h>
  67 #include <sys/csan.h>
  68 #include <sys/efi.h>
  69 #include <sys/eventhandler.h>
  70 #include <sys/exec.h>
  71 #include <sys/imgact.h>
  72 #include <sys/kdb.h>
  73 #include <sys/kernel.h>
  74 #include <sys/ktr.h>
  75 #include <sys/linker.h>
  76 #include <sys/lock.h>
  77 #include <sys/malloc.h>
  78 #include <sys/memrange.h>
  79 #include <sys/msgbuf.h>
  80 #include <sys/mutex.h>
  81 #include <sys/pcpu.h>
  82 #include <sys/ptrace.h>
  83 #include <sys/reboot.h>
  84 #include <sys/rwlock.h>
  85 #include <sys/sched.h>
  86 #include <sys/signalvar.h>
  87 #ifdef SMP
  88 #include <sys/smp.h>
  89 #endif
  90 #include <sys/syscallsubr.h>
  91 #include <sys/sysctl.h>
  92 #include <sys/sysent.h>
  93 #include <sys/sysproto.h>
  94 #include <sys/ucontext.h>
  95 #include <sys/vmmeter.h>
  96
  97 #include <vm/vm.h>
  98 #include <vm/vm_extern.h>
  99 #include <vm/vm_kern.h>
 100 #include <vm/vm_page.h>
 101 #include <vm/vm_map.h>
 102 #include <vm/vm_object.h>
 103 #include <vm/vm_pager.h>
 104 #include <vm/vm_param.h>
 105 #include <vm/vm_phys.h>
 106
 107 #ifdef DDB
 108 #ifndef KDB
 109 #error KDB must be enabled in order for DDB to work!
 110 #endif
 111 #include <ddb/ddb.h>
 112 #include <ddb/db_sym.h>
 113 #endif
 114
 115 #include <net/netisr.h>
 116
 117 #include <machine/clock.h>
 118 #include <machine/cpu.h>
 119 #include <machine/cputypes.h>
 120 #include <machine/frame.h>
 121 #include <machine/intr_machdep.h>
 122 #include <x86/mca.h>
 123 #include <machine/md_var.h>
 124 #include <machine/metadata.h>
 125 #include <machine/mp_watchdog.h>
 126 #include <machine/pc/bios.h>
 127 #include <machine/pcb.h>
 128 #include <machine/proc.h>
 129 #include <machine/reg.h>
 130 #include <machine/sigframe.h>
 131 #include <machine/specialreg.h>
 132 #include <machine/trap.h>
 133 #include <machine/tss.h>
 134 #include <x86/ucode.h>
 135 #include <x86/ifunc.h>
 136 #ifdef SMP
 137 #include <machine/smp.h>
 138 #endif
 139 #ifdef FDT
 140 #include <x86/fdt.h>
 141 #endif
 142
 143 #ifdef DEV_ATPIC
 144 #include <x86/isa/icu.h>
 145 #else
 146 #include <x86/apicvar.h>
 147 #endif
 148
 149 #include <isa/isareg.h>
 150 #include <isa/rtc.h>
 151 #include <x86/init.h>
 152
 153 /* Sanity check for __curthread() */
 154 CTASSERT(offsetof(struct pcpu, pc_curthread) == 0);
 155
 156 /*
 157  * The PTI trampoline stack needs enough space for a hardware trapframe and a
 158  * couple of scratch registers, as well as the trapframe left behind after an
 159  * iret fault.
 160  */
 161 CTASSERT(PC_PTI_STACK_SZ * sizeof(register_t) >= 2 * sizeof(struct pti_frame) -
 162     offsetof(struct pti_frame, pti_rip));
 163
 164 extern u_int64_t hammer_time(u_int64_t, u_int64_t);
 165
 166 #define CS_SECURE(cs)           (ISPL(cs) == SEL_UPL)
 167 #define EFL_SECURE(ef, oef)     ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 168
 169 static void cpu_startup(void *);
 170 static void get_fpcontext(struct thread *td, mcontext_t *mcp,
 171     char *xfpusave, size_t xfpusave_len);
 172 static int  set_fpcontext(struct thread *td, mcontext_t *mcp,
 173     char *xfpustate, size_t xfpustate_len);
 174 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL);
 175
 176 /* Preload data parse function */
 177 static caddr_t native_parse_preload_data(u_int64_t);
 178
 179 /* Native function to fetch and parse the e820 map */
 180 static void native_parse_memmap(caddr_t, vm_paddr_t *, int *);
 181
 182 /* Default init_ops implementation. */
 183 struct init_ops init_ops = {
 184         .parse_preload_data =   native_parse_preload_data,
 185         .early_clock_source_init =      i8254_init,
 186         .early_delay =                  i8254_delay,
 187         .parse_memmap =                 native_parse_memmap,
 188 #ifdef SMP
 189         .mp_bootaddress =               mp_bootaddress,
 190         .start_all_aps =                native_start_all_aps,
 191 #endif
 192 #ifdef DEV_PCI
 193         .msi_init =                     msi_init,
 194 #endif
 195 };
 196
 197 /*
 198  * Physical address of the EFI System Table. Stashed from the metadata hints
 199  * passed into the kernel and used by the EFI code to call runtime services.
 200  */
 201 vm_paddr_t efi_systbl_phys;
 202
 203 /* Intel ICH registers */
 204 #define ICH_PMBASE      0x400
 205 #define ICH_SMI_EN      ICH_PMBASE + 0x30
 206
 207 int     _udatasel, _ucodesel, _ucode32sel, _ufssel, _ugssel;
 208
 209 int cold = 1;
 210
 211 long Maxmem = 0;
 212 long realmem = 0;
 213
 214 struct kva_md_info kmi;
 215
 216 static struct trapframe proc0_tf;
 217 struct region_descriptor r_idt;
 218
 219 struct pcpu *__pcpu;
 220 struct pcpu temp_bsp_pcpu;
 221
 222 struct mtx icu_lock;
 223
 224 struct mem_range_softc mem_range_softc;
 225
 226 struct mtx dt_lock;     /* lock for GDT and LDT */
 227
 228 void (*vmm_resume_p)(void);
 229
 230 static void
 231 cpu_startup(dummy)
 232         void *dummy;
 233 {
 234         uintmax_t memsize;
 235         char *sysenv;
 236
 237         /*
 238          * On MacBooks, we need to disallow the legacy USB circuit to
 239          * generate an SMI# because this can cause several problems,
 240          * namely: incorrect CPU frequency detection and failure to
 241          * start the APs.
 242          * We do this by disabling a bit in the SMI_EN (SMI Control and
 243          * Enable register) of the Intel ICH LPC Interface Bridge.
 244          */
 245         sysenv = kern_getenv("smbios.system.product");
 246         if (sysenv != NULL) {
 247                 if (strncmp(sysenv, "MacBook1,1", 10) == 0 ||
 248                     strncmp(sysenv, "MacBook3,1", 10) == 0 ||
 249                     strncmp(sysenv, "MacBook4,1", 10) == 0 ||
 250                     strncmp(sysenv, "MacBookPro1,1", 13) == 0 ||
 251                     strncmp(sysenv, "MacBookPro1,2", 13) == 0 ||
 252                     strncmp(sysenv, "MacBookPro3,1", 13) == 0 ||
 253                     strncmp(sysenv, "MacBookPro4,1", 13) == 0 ||
 254                     strncmp(sysenv, "Macmini1,1", 10) == 0) {
 255                         if (bootverbose)
 256                                 printf("Disabling LEGACY_USB_EN bit on "
 257                                     "Intel ICH.\n");
 258                         outl(ICH_SMI_EN, inl(ICH_SMI_EN) & ~0x8);
 259                 }
 260                 freeenv(sysenv);
 261         }
 262
 263         /*
 264          * Good {morning,afternoon,evening,night}.
 265          */
 266         startrtclock();
 267         printcpuinfo();
 268
 269         /*
 270          * Display physical memory if SMBIOS reports reasonable amount.
 271          */
 272         memsize = 0;
 273         sysenv = kern_getenv("smbios.memory.enabled");
 274         if (sysenv != NULL) {
 275                 memsize = (uintmax_t)strtoul(sysenv, (char **)NULL, 10) << 10;
 276                 freeenv(sysenv);
 277         }
 278         if (memsize < ptoa((uintmax_t)vm_free_count()))
 279                 memsize = ptoa((uintmax_t)Maxmem);
 280         printf("real memory  = %ju (%ju MB)\n", memsize, memsize >> 20);
 281         realmem = atop(memsize);
 282
 283         /*
 284          * Display any holes after the first chunk of extended memory.
 285          */
 286         if (bootverbose) {
 287                 int indx;
 288
 289                 printf("Physical memory chunk(s):\n");
 290                 for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
 291                         vm_paddr_t size;
 292
 293                         size = phys_avail[indx + 1] - phys_avail[indx];
 294                         printf(
 295                             "0x%016jx - 0x%016jx, %ju bytes (%ju pages)\n",
 296                             (uintmax_t)phys_avail[indx],
 297                             (uintmax_t)phys_avail[indx + 1] - 1,
 298                             (uintmax_t)size, (uintmax_t)size / PAGE_SIZE);
 299                 }
 300         }
 301
 302         vm_ksubmap_init(&kmi);
 303
 304         printf("avail memory = %ju (%ju MB)\n",
 305             ptoa((uintmax_t)vm_free_count()),
 306             ptoa((uintmax_t)vm_free_count()) / 1048576);
 307 #ifdef DEV_PCI
 308         if (bootverbose && intel_graphics_stolen_base != 0)
 309                 printf("intel stolen mem: base %#jx size %ju MB\n",
 310                     (uintmax_t)intel_graphics_stolen_base,
 311                     (uintmax_t)intel_graphics_stolen_size / 1024 / 1024);
 312 #endif
 313
 314         /*
 315          * Set up buffers, so they can be used to read disk labels.
 316          */
 317         bufinit();
 318         vm_pager_bufferinit();
 319
 320         cpu_setregs();
 321 }
 322
 323 static void
 324 late_ifunc_resolve(void *dummy __unused)
 325 {
 326         link_elf_late_ireloc();
 327 }
 328 SYSINIT(late_ifunc_resolve, SI_SUB_CPU, SI_ORDER_ANY, late_ifunc_resolve, NULL);
 329
 330 /*
 331  * Send an interrupt to process.
 332  *
 333  * Stack is set up to allow sigcode stored
 334  * at top to call routine, followed by call
 335  * to sigreturn routine below.  After sigreturn
 336  * resets the signal mask, the stack, and the
 337  * frame pointer, it returns to the user
 338  * specified pc, psl.
 339  */
 340 void
 341 sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
 342 {
 343         struct sigframe sf, *sfp;
 344         struct pcb *pcb;
 345         struct proc *p;
 346         struct thread *td;
 347         struct sigacts *psp;
 348         char *sp;
 349         struct trapframe *regs;
 350         char *xfpusave;
 351         size_t xfpusave_len;
 352         int sig;
 353         int oonstack;
 354
 355         td = curthread;
 356         pcb = td->td_pcb;
 357         p = td->td_proc;
 358         PROC_LOCK_ASSERT(p, MA_OWNED);
 359         sig = ksi->ksi_signo;
 360         psp = p->p_sigacts;
 361         mtx_assert(&psp->ps_mtx, MA_OWNED);
 362         regs = td->td_frame;
 363         oonstack = sigonstack(regs->tf_rsp);
 364
 365         if (cpu_max_ext_state_size > sizeof(struct savefpu) && use_xsave) {
 366                 xfpusave_len = cpu_max_ext_state_size - sizeof(struct savefpu);
 367                 xfpusave = __builtin_alloca(xfpusave_len);
 368         } else {
 369                 xfpusave_len = 0;
 370                 xfpusave = NULL;
 371         }
 372
 373         /* Save user context. */
 374         bzero(&sf, sizeof(sf));
 375         sf.sf_uc.uc_sigmask = *mask;
 376         sf.sf_uc.uc_stack = td->td_sigstk;
 377         sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
 378             ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
 379         sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0;
 380         bcopy(regs, &sf.sf_uc.uc_mcontext.mc_rdi, sizeof(*regs));
 381         sf.sf_uc.uc_mcontext.mc_len = sizeof(sf.sf_uc.uc_mcontext); /* magic */
 382         get_fpcontext(td, &sf.sf_uc.uc_mcontext, xfpusave, xfpusave_len);
 383         fpstate_drop(td);
 384         update_pcb_bases(pcb);
 385         sf.sf_uc.uc_mcontext.mc_fsbase = pcb->pcb_fsbase;
 386         sf.sf_uc.uc_mcontext.mc_gsbase = pcb->pcb_gsbase;
 387         bzero(sf.sf_uc.uc_mcontext.mc_spare,
 388             sizeof(sf.sf_uc.uc_mcontext.mc_spare));
 389
 390         /* Allocate space for the signal handler context. */
 391         if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack &&
 392             SIGISMEMBER(psp->ps_sigonstack, sig)) {
 393                 sp = (char *)td->td_sigstk.ss_sp + td->td_sigstk.ss_size;
 394 #if defined(COMPAT_43)
 395                 td->td_sigstk.ss_flags |= SS_ONSTACK;
 396 #endif
 397         } else
 398                 sp = (char *)regs->tf_rsp - 128;
 399         if (xfpusave != NULL) {
 400                 sp -= xfpusave_len;
 401                 sp = (char *)((unsigned long)sp & ~0x3Ful);
 402                 sf.sf_uc.uc_mcontext.mc_xfpustate = (register_t)sp;
 403         }
 404         sp -= sizeof(struct sigframe);
 405         /* Align to 16 bytes. */
 406         sfp = (struct sigframe *)((unsigned long)sp & ~0xFul);
 407
 408         /* Build the argument list for the signal handler. */
 409         regs->tf_rdi = sig;                     /* arg 1 in %rdi */
 410         regs->tf_rdx = (register_t)&sfp->sf_uc; /* arg 3 in %rdx */
 411         bzero(&sf.sf_si, sizeof(sf.sf_si));
 412         if (SIGISMEMBER(psp->ps_siginfo, sig)) {
 413                 /* Signal handler installed with SA_SIGINFO. */
 414                 regs->tf_rsi = (register_t)&sfp->sf_si; /* arg 2 in %rsi */
 415                 sf.sf_ahu.sf_action = (__siginfohandler_t *)catcher;
 416
 417                 /* Fill in POSIX parts */
 418                 sf.sf_si = ksi->ksi_info;
 419                 sf.sf_si.si_signo = sig; /* maybe a translated signal */
 420                 regs->tf_rcx = (register_t)ksi->ksi_addr; /* arg 4 in %rcx */
 421         } else {
 422                 /* Old FreeBSD-style arguments. */
 423                 regs->tf_rsi = ksi->ksi_code;   /* arg 2 in %rsi */
 424                 regs->tf_rcx = (register_t)ksi->ksi_addr; /* arg 4 in %rcx */
 425                 sf.sf_ahu.sf_handler = catcher;
 426         }
 427         mtx_unlock(&psp->ps_mtx);
 428         PROC_UNLOCK(p);
 429
 430         /*
 431          * Copy the sigframe out to the user's stack.
 432          */
 433         if (copyout(&sf, sfp, sizeof(*sfp)) != 0 ||
 434             (xfpusave != NULL && copyout(xfpusave,
 435             (void *)sf.sf_uc.uc_mcontext.mc_xfpustate, xfpusave_len)
 436             != 0)) {
 437 #ifdef DEBUG
 438                 printf("process %ld has trashed its stack\n", (long)p->p_pid);
 439 #endif
 440                 PROC_LOCK(p);
 441                 sigexit(td, SIGILL);
 442         }
 443
 444         regs->tf_rsp = (long)sfp;
 445         regs->tf_rip = p->p_sysent->sv_sigcode_base;
 446         regs->tf_rflags &= ~(PSL_T | PSL_D);
 447         regs->tf_cs = _ucodesel;
 448         regs->tf_ds = _udatasel;
 449         regs->tf_ss = _udatasel;
 450         regs->tf_es = _udatasel;
 451         regs->tf_fs = _ufssel;
 452         regs->tf_gs = _ugssel;
 453         regs->tf_flags = TF_HASSEGS;
 454         PROC_LOCK(p);
 455         mtx_lock(&psp->ps_mtx);
 456 }
 457
 458 /*
 459  * System call to cleanup state after a signal
 460  * has been taken.  Reset signal mask and
 461  * stack state from context left by sendsig (above).
 462  * Return to previous pc and psl as specified by
 463  * context left by sendsig. Check carefully to
 464  * make sure that the user has not modified the
 465  * state to gain improper privileges.
 466  *
 467  * MPSAFE
 468  */
 469 int
 470 sys_sigreturn(td, uap)
 471         struct thread *td;
 472         struct sigreturn_args /* {
 473                 const struct __ucontext *sigcntxp;
 474         } */ *uap;
 475 {
 476         ucontext_t uc;
 477         struct pcb *pcb;
 478         struct proc *p;
 479         struct trapframe *regs;
 480         ucontext_t *ucp;
 481         char *xfpustate;
 482         size_t xfpustate_len;
 483         long rflags;
 484         int cs, error, ret;
 485         ksiginfo_t ksi;
 486
 487         pcb = td->td_pcb;
 488         p = td->td_proc;
 489
 490         error = copyin(uap->sigcntxp, &uc, sizeof(uc));
 491         if (error != 0) {
 492                 uprintf("pid %d (%s): sigreturn copyin failed\n",
 493                     p->p_pid, td->td_name);
 494                 return (error);
 495         }
 496         ucp = &uc;
 497         if ((ucp->uc_mcontext.mc_flags & ~_MC_FLAG_MASK) != 0) {
 498                 uprintf("pid %d (%s): sigreturn mc_flags %x\n", p->p_pid,
 499                     td->td_name, ucp->uc_mcontext.mc_flags);
 500                 return (EINVAL);
 501         }
 502         regs = td->td_frame;
 503         rflags = ucp->uc_mcontext.mc_rflags;
 504         /*
 505          * Don't allow users to change privileged or reserved flags.
 506          */
 507         if (!EFL_SECURE(rflags, regs->tf_rflags)) {
 508                 uprintf("pid %d (%s): sigreturn rflags = 0x%lx\n", p->p_pid,
 509                     td->td_name, rflags);
 510                 return (EINVAL);
 511         }
 512
 513         /*
 514          * Don't allow users to load a valid privileged %cs.  Let the
 515          * hardware check for invalid selectors, excess privilege in
 516          * other selectors, invalid %eip's and invalid %esp's.
 517          */
 518         cs = ucp->uc_mcontext.mc_cs;
 519         if (!CS_SECURE(cs)) {
 520                 uprintf("pid %d (%s): sigreturn cs = 0x%x\n", p->p_pid,
 521                     td->td_name, cs);
 522                 ksiginfo_init_trap(&ksi);
 523                 ksi.ksi_signo = SIGBUS;
 524                 ksi.ksi_code = BUS_OBJERR;
 525                 ksi.ksi_trapno = T_PROTFLT;
 526                 ksi.ksi_addr = (void *)regs->tf_rip;
 527                 trapsignal(td, &ksi);
 528                 return (EINVAL);
 529         }
 530
 531         if ((uc.uc_mcontext.mc_flags & _MC_HASFPXSTATE) != 0) {
 532                 xfpustate_len = uc.uc_mcontext.mc_xfpustate_len;
 533                 if (xfpustate_len > cpu_max_ext_state_size -
 534                     sizeof(struct savefpu)) {
 535                         uprintf("pid %d (%s): sigreturn xfpusave_len = 0x%zx\n",
 536                             p->p_pid, td->td_name, xfpustate_len);
 537                         return (EINVAL);
 538                 }
 539                 xfpustate = __builtin_alloca(xfpustate_len);
 540                 error = copyin((const void *)uc.uc_mcontext.mc_xfpustate,
 541                     xfpustate, xfpustate_len);
 542                 if (error != 0) {
 543                         uprintf(
 544         "pid %d (%s): sigreturn copying xfpustate failed\n",
 545                             p->p_pid, td->td_name);
 546                         return (error);
 547                 }
 548         } else {
 549                 xfpustate = NULL;
 550                 xfpustate_len = 0;
 551         }
 552         ret = set_fpcontext(td, &ucp->uc_mcontext, xfpustate, xfpustate_len);
 553         if (ret != 0) {
 554                 uprintf("pid %d (%s): sigreturn set_fpcontext err %d\n",
 555                     p->p_pid, td->td_name, ret);
 556                 return (ret);
 557         }
 558         bcopy(&ucp->uc_mcontext.mc_rdi, regs, sizeof(*regs));
 559         update_pcb_bases(pcb);
 560         pcb->pcb_fsbase = ucp->uc_mcontext.mc_fsbase;
 561         pcb->pcb_gsbase = ucp->uc_mcontext.mc_gsbase;
 562
 563 #if defined(COMPAT_43)
 564         if (ucp->uc_mcontext.mc_onstack & 1)
 565                 td->td_sigstk.ss_flags |= SS_ONSTACK;
 566         else
 567                 td->td_sigstk.ss_flags &= ~SS_ONSTACK;
 568 #endif
 569
 570         kern_sigprocmask(td, SIG_SETMASK, &ucp->uc_sigmask, NULL, 0);
 571         return (EJUSTRETURN);
 572 }
 573
 574 #ifdef COMPAT_FREEBSD4
 575 int
 576 freebsd4_sigreturn(struct thread *td, struct freebsd4_sigreturn_args *uap)
 577 {
 578
 579         return sys_sigreturn(td, (struct sigreturn_args *)uap);
 580 }
 581 #endif
 582
 583 /*
 584  * Reset registers to default values on exec.
 585  */
 586 void
 587 exec_setregs(struct thread *td, struct image_params *imgp, uintptr_t stack)
 588 {
 589         struct trapframe *regs;
 590         struct pcb *pcb;
 591         register_t saved_rflags;
 592
 593         regs = td->td_frame;
 594         pcb = td->td_pcb;
 595
 596         if (td->td_proc->p_md.md_ldt != NULL)
 597                 user_ldt_free(td);
 598
 599         update_pcb_bases(pcb);
 600         pcb->pcb_fsbase = 0;
 601         pcb->pcb_gsbase = 0;
 602         clear_pcb_flags(pcb, PCB_32BIT);
 603         pcb->pcb_initial_fpucw = __INITIAL_FPUCW__;
 604
 605         saved_rflags = regs->tf_rflags & PSL_T;
 606         bzero((char *)regs, sizeof(struct trapframe));
 607         regs->tf_rip = imgp->entry_addr;
 608         regs->tf_rsp = ((stack - 8) & ~0xFul) + 8;
 609         regs->tf_rdi = stack;           /* argv */
 610         regs->tf_rflags = PSL_USER | saved_rflags;
 611         regs->tf_ss = _udatasel;
 612         regs->tf_cs = _ucodesel;
 613         regs->tf_ds = _udatasel;
 614         regs->tf_es = _udatasel;
 615         regs->tf_fs = _ufssel;
 616         regs->tf_gs = _ugssel;
 617         regs->tf_flags = TF_HASSEGS;
 618
 619         /*
 620          * Reset the hardware debug registers if they were in use.
 621          * They won't have any meaning for the newly exec'd process.
 622          */
 623         if (pcb->pcb_flags & PCB_DBREGS) {
 624                 pcb->pcb_dr0 = 0;
 625                 pcb->pcb_dr1 = 0;
 626                 pcb->pcb_dr2 = 0;
 627                 pcb->pcb_dr3 = 0;
 628                 pcb->pcb_dr6 = 0;
 629                 pcb->pcb_dr7 = 0;
 630                 if (pcb == curpcb) {
 631                         /*
 632                          * Clear the debug registers on the running
 633                          * CPU, otherwise they will end up affecting
 634                          * the next process we switch to.
 635                          */
 636                         reset_dbregs();
 637                 }
 638                 clear_pcb_flags(pcb, PCB_DBREGS);
 639         }
 640
 641         /*
 642          * Drop the FP state if we hold it, so that the process gets a
 643          * clean FP state if it uses the FPU again.
 644          */
 645         fpstate_drop(td);
 646 }
 647
 648 void
 649 cpu_setregs(void)
 650 {
 651         register_t cr0;
 652
 653         cr0 = rcr0();
 654         /*
 655          * CR0_MP, CR0_NE and CR0_TS are also set by npx_probe() for the
 656          * BSP.  See the comments there about why we set them.
 657          */
 658         cr0 |= CR0_MP | CR0_NE | CR0_TS | CR0_WP | CR0_AM;
 659         load_cr0(cr0);
 660 }
 661
 662 /*
 663  * Initialize amd64 and configure to run kernel
 664  */
 665
 666 /*
 667  * Initialize segments & interrupt table
 668  */
 669 static struct gate_descriptor idt0[NIDT];
 670 struct gate_descriptor *idt = &idt0[0]; /* interrupt descriptor table */
 671
 672 static char dblfault_stack[PAGE_SIZE] __aligned(16);
 673 static char mce0_stack[PAGE_SIZE] __aligned(16);
 674 static char nmi0_stack[PAGE_SIZE] __aligned(16);
 675 static char dbg0_stack[PAGE_SIZE] __aligned(16);
 676 CTASSERT(sizeof(struct nmi_pcpu) == 16);
 677
 678 /*
 679  * Software prototypes -- in more palatable form.
 680  *
 681  * Keep GUFS32, GUGS32, GUCODE32 and GUDATA at the same
 682  * slots as corresponding segments for i386 kernel.
 683  */
 684 struct soft_segment_descriptor gdt_segs[] = {
 685 /* GNULL_SEL    0 Null Descriptor */
 686 {       .ssd_base = 0x0,
 687         .ssd_limit = 0x0,
 688         .ssd_type = 0,
 689         .ssd_dpl = 0,
 690         .ssd_p = 0,
 691         .ssd_long = 0,
 692         .ssd_def32 = 0,
 693         .ssd_gran = 0           },
 694 /* GNULL2_SEL   1 Null Descriptor */
 695 {       .ssd_base = 0x0,
 696         .ssd_limit = 0x0,
 697         .ssd_type = 0,
 698         .ssd_dpl = 0,
 699         .ssd_p = 0,
 700         .ssd_long = 0,
 701         .ssd_def32 = 0,
 702         .ssd_gran = 0           },
 703 /* GUFS32_SEL   2 32 bit %gs Descriptor for user */
 704 {       .ssd_base = 0x0,
 705         .ssd_limit = 0xfffff,
 706         .ssd_type = SDT_MEMRWA,
 707         .ssd_dpl = SEL_UPL,
 708         .ssd_p = 1,
 709         .ssd_long = 0,
 710         .ssd_def32 = 1,
 711         .ssd_gran = 1           },
 712 /* GUGS32_SEL   3 32 bit %fs Descriptor for user */
 713 {       .ssd_base = 0x0,
 714         .ssd_limit = 0xfffff,
 715         .ssd_type = SDT_MEMRWA,
 716         .ssd_dpl = SEL_UPL,
 717         .ssd_p = 1,
 718         .ssd_long = 0,
 719         .ssd_def32 = 1,
 720         .ssd_gran = 1           },
 721 /* GCODE_SEL    4 Code Descriptor for kernel */
 722 {       .ssd_base = 0x0,
 723         .ssd_limit = 0xfffff,
 724         .ssd_type = SDT_MEMERA,
 725         .ssd_dpl = SEL_KPL,
 726         .ssd_p = 1,
 727         .ssd_long = 1,
 728         .ssd_def32 = 0,
 729         .ssd_gran = 1           },
 730 /* GDATA_SEL    5 Data Descriptor for kernel */
 731 {       .ssd_base = 0x0,
 732         .ssd_limit = 0xfffff,
 733         .ssd_type = SDT_MEMRWA,
 734         .ssd_dpl = SEL_KPL,
 735         .ssd_p = 1,
 736         .ssd_long = 1,
 737         .ssd_def32 = 0,
 738         .ssd_gran = 1           },
 739 /* GUCODE32_SEL 6 32 bit Code Descriptor for user */
 740 {       .ssd_base = 0x0,
 741         .ssd_limit = 0xfffff,
 742         .ssd_type = SDT_MEMERA,
 743         .ssd_dpl = SEL_UPL,
 744         .ssd_p = 1,
 745         .ssd_long = 0,
 746         .ssd_def32 = 1,
 747         .ssd_gran = 1           },
 748 /* GUDATA_SEL   7 32/64 bit Data Descriptor for user */
 749 {       .ssd_base = 0x0,
 750         .ssd_limit = 0xfffff,
 751         .ssd_type = SDT_MEMRWA,
 752         .ssd_dpl = SEL_UPL,
 753         .ssd_p = 1,
 754         .ssd_long = 0,
 755         .ssd_def32 = 1,
 756         .ssd_gran = 1           },
 757 /* GUCODE_SEL   8 64 bit Code Descriptor for user */
 758 {       .ssd_base = 0x0,
 759         .ssd_limit = 0xfffff,
 760         .ssd_type = SDT_MEMERA,
 761         .ssd_dpl = SEL_UPL,
 762         .ssd_p = 1,
 763         .ssd_long = 1,
 764         .ssd_def32 = 0,
 765         .ssd_gran = 1           },
 766 /* GPROC0_SEL   9 Proc 0 Tss Descriptor */
 767 {       .ssd_base = 0x0,
 768         .ssd_limit = sizeof(struct amd64tss) + IOPERM_BITMAP_SIZE - 1,
 769         .ssd_type = SDT_SYSTSS,
 770         .ssd_dpl = SEL_KPL,
 771         .ssd_p = 1,
 772         .ssd_long = 0,
 773         .ssd_def32 = 0,
 774         .ssd_gran = 0           },
 775 /* Actually, the TSS is a system descriptor which is double size */
 776 {       .ssd_base = 0x0,
 777         .ssd_limit = 0x0,
 778         .ssd_type = 0,
 779         .ssd_dpl = 0,
 780         .ssd_p = 0,
 781         .ssd_long = 0,
 782         .ssd_def32 = 0,
 783         .ssd_gran = 0           },
 784 /* GUSERLDT_SEL 11 LDT Descriptor */
 785 {       .ssd_base = 0x0,
 786         .ssd_limit = 0x0,
 787         .ssd_type = 0,
 788         .ssd_dpl = 0,
 789         .ssd_p = 0,
 790         .ssd_long = 0,
 791         .ssd_def32 = 0,
 792         .ssd_gran = 0           },
 793 /* GUSERLDT_SEL 12 LDT Descriptor, double size */
 794 {       .ssd_base = 0x0,
 795         .ssd_limit = 0x0,
 796         .ssd_type = 0,
 797         .ssd_dpl = 0,
 798         .ssd_p = 0,
 799         .ssd_long = 0,
 800         .ssd_def32 = 0,
 801         .ssd_gran = 0           },
 802 };
 803 _Static_assert(nitems(gdt_segs) == NGDT, "Stale NGDT");
 804
 805 void
 806 setidt(int idx, inthand_t *func, int typ, int dpl, int ist)
 807 {
 808         struct gate_descriptor *ip;
 809
 810         ip = idt + idx;
 811         ip->gd_looffset = (uintptr_t)func;
 812         ip->gd_selector = GSEL(GCODE_SEL, SEL_KPL);
 813         ip->gd_ist = ist;
 814         ip->gd_xx = 0;
 815         ip->gd_type = typ;
 816         ip->gd_dpl = dpl;
 817         ip->gd_p = 1;
 818         ip->gd_hioffset = ((uintptr_t)func)>>16 ;
 819 }
 820
 821 extern inthand_t
 822         IDTVEC(div), IDTVEC(dbg), IDTVEC(nmi), IDTVEC(bpt), IDTVEC(ofl),
 823         IDTVEC(bnd), IDTVEC(ill), IDTVEC(dna), IDTVEC(fpusegm),
 824         IDTVEC(tss), IDTVEC(missing), IDTVEC(stk), IDTVEC(prot),
 825         IDTVEC(page), IDTVEC(mchk), IDTVEC(rsvd), IDTVEC(fpu), IDTVEC(align),
 826         IDTVEC(xmm), IDTVEC(dblfault),
 827         IDTVEC(div_pti), IDTVEC(bpt_pti),
 828         IDTVEC(ofl_pti), IDTVEC(bnd_pti), IDTVEC(ill_pti), IDTVEC(dna_pti),
 829         IDTVEC(fpusegm_pti), IDTVEC(tss_pti), IDTVEC(missing_pti),
 830         IDTVEC(stk_pti), IDTVEC(prot_pti), IDTVEC(page_pti),
 831         IDTVEC(rsvd_pti), IDTVEC(fpu_pti), IDTVEC(align_pti),
 832         IDTVEC(xmm_pti),
 833 #ifdef KDTRACE_HOOKS
 834         IDTVEC(dtrace_ret), IDTVEC(dtrace_ret_pti),
 835 #endif
 836 #ifdef XENHVM
 837         IDTVEC(xen_intr_upcall), IDTVEC(xen_intr_upcall_pti),
 838 #endif
 839         IDTVEC(fast_syscall), IDTVEC(fast_syscall32),
 840         IDTVEC(fast_syscall_pti);
 841
 842 #ifdef DDB
 843 /*
 844  * Display the index and function name of any IDT entries that don't use
 845  * the default 'rsvd' entry point.
 846  */
 847 DB_SHOW_COMMAND(idt, db_show_idt)
 848 {
 849         struct gate_descriptor *ip;
 850         int idx;
 851         uintptr_t func;
 852
 853         ip = idt;
 854         for (idx = 0; idx < NIDT && !db_pager_quit; idx++) {
 855                 func = ((long)ip->gd_hioffset << 16 | ip->gd_looffset);
 856                 if (func != (uintptr_t)&IDTVEC(rsvd)) {
 857                         db_printf("%3d\t", idx);
 858                         db_printsym(func, DB_STGY_PROC);
 859                         db_printf("\n");
 860                 }
 861                 ip++;
 862         }
 863 }
 864
 865 /* Show privileged registers. */
 866 DB_SHOW_COMMAND(sysregs, db_show_sysregs)
 867 {
 868         struct {
 869                 uint16_t limit;
 870                 uint64_t base;
 871         } __packed idtr, gdtr;
 872         uint16_t ldt, tr;
 873
 874         __asm __volatile("sidt %0" : "=m" (idtr));
 875         db_printf("idtr\t0x%016lx/%04x\n",
 876             (u_long)idtr.base, (u_int)idtr.limit);
 877         __asm __volatile("sgdt %0" : "=m" (gdtr));
 878         db_printf("gdtr\t0x%016lx/%04x\n",
 879             (u_long)gdtr.base, (u_int)gdtr.limit);
 880         __asm __volatile("sldt %0" : "=r" (ldt));
 881         db_printf("ldtr\t0x%04x\n", ldt);
 882         __asm __volatile("str %0" : "=r" (tr));
 883         db_printf("tr\t0x%04x\n", tr);
 884         db_printf("cr0\t0x%016lx\n", rcr0());
 885         db_printf("cr2\t0x%016lx\n", rcr2());
 886         db_printf("cr3\t0x%016lx\n", rcr3());
 887         db_printf("cr4\t0x%016lx\n", rcr4());
 888         if (rcr4() & CR4_XSAVE)
 889                 db_printf("xcr0\t0x%016lx\n", rxcr(0));
 890         db_printf("EFER\t0x%016lx\n", rdmsr(MSR_EFER));
 891         if (cpu_feature2 & (CPUID2_VMX | CPUID2_SMX))
 892                 db_printf("FEATURES_CTL\t%016lx\n",
 893                     rdmsr(MSR_IA32_FEATURE_CONTROL));
 894         db_printf("DEBUG_CTL\t0x%016lx\n", rdmsr(MSR_DEBUGCTLMSR));
 895         db_printf("PAT\t0x%016lx\n", rdmsr(MSR_PAT));
 896         db_printf("GSBASE\t0x%016lx\n", rdmsr(MSR_GSBASE));
 897 }
 898
 899 DB_SHOW_COMMAND(dbregs, db_show_dbregs)
 900 {
 901
 902         db_printf("dr0\t0x%016lx\n", rdr0());
 903         db_printf("dr1\t0x%016lx\n", rdr1());
 904         db_printf("dr2\t0x%016lx\n", rdr2());
 905         db_printf("dr3\t0x%016lx\n", rdr3());
 906         db_printf("dr6\t0x%016lx\n", rdr6());
 907         db_printf("dr7\t0x%016lx\n", rdr7());
 908 }
 909 #endif
 910
 911 void
 912 sdtossd(sd, ssd)
 913         struct user_segment_descriptor *sd;
 914         struct soft_segment_descriptor *ssd;
 915 {
 916
 917         ssd->ssd_base  = (sd->sd_hibase << 24) | sd->sd_lobase;
 918         ssd->ssd_limit = (sd->sd_hilimit << 16) | sd->sd_lolimit;
 919         ssd->ssd_type  = sd->sd_type;
 920         ssd->ssd_dpl   = sd->sd_dpl;
 921         ssd->ssd_p     = sd->sd_p;
 922         ssd->ssd_long  = sd->sd_long;
 923         ssd->ssd_def32 = sd->sd_def32;
 924         ssd->ssd_gran  = sd->sd_gran;
 925 }
 926
 927 void
 928 ssdtosd(ssd, sd)
 929         struct soft_segment_descriptor *ssd;
 930         struct user_segment_descriptor *sd;
 931 {
 932
 933         sd->sd_lobase = (ssd->ssd_base) & 0xffffff;
 934         sd->sd_hibase = (ssd->ssd_base >> 24) & 0xff;
 935         sd->sd_lolimit = (ssd->ssd_limit) & 0xffff;
 936         sd->sd_hilimit = (ssd->ssd_limit >> 16) & 0xf;
 937         sd->sd_type  = ssd->ssd_type;
 938         sd->sd_dpl   = ssd->ssd_dpl;
 939         sd->sd_p     = ssd->ssd_p;
 940         sd->sd_long  = ssd->ssd_long;
 941         sd->sd_def32 = ssd->ssd_def32;
 942         sd->sd_gran  = ssd->ssd_gran;
 943 }
 944
 945 void
 946 ssdtosyssd(ssd, sd)
 947         struct soft_segment_descriptor *ssd;
 948         struct system_segment_descriptor *sd;
 949 {
 950
 951         sd->sd_lobase = (ssd->ssd_base) & 0xffffff;
 952         sd->sd_hibase = (ssd->ssd_base >> 24) & 0xfffffffffful;
 953         sd->sd_lolimit = (ssd->ssd_limit) & 0xffff;
 954         sd->sd_hilimit = (ssd->ssd_limit >> 16) & 0xf;
 955         sd->sd_type  = ssd->ssd_type;
 956         sd->sd_dpl   = ssd->ssd_dpl;
 957         sd->sd_p     = ssd->ssd_p;
 958         sd->sd_gran  = ssd->ssd_gran;
 959 }
 960
 961 #if !defined(DEV_ATPIC) && defined(DEV_ISA)
 962 #include <isa/isavar.h>
 963 #include <isa/isareg.h>
 964 /*
 965  * Return a bitmap of the current interrupt requests.  This is 8259-specific
 966  * and is only suitable for use at probe time.
 967  * This is only here to pacify sio.  It is NOT FATAL if this doesn't work.
 968  * It shouldn't be here.  There should probably be an APIC centric
 969  * implementation in the apic driver code, if at all.
 970  */
 971 intrmask_t
 972 isa_irq_pending(void)
 973 {
 974         u_char irr1;
 975         u_char irr2;
 976
 977         irr1 = inb(IO_ICU1);
 978         irr2 = inb(IO_ICU2);
 979         return ((irr2 << 8) | irr1);
 980 }
 981 #endif
 982
 983 u_int basemem;
 984
 985 static int
 986 add_physmap_entry(uint64_t base, uint64_t length, vm_paddr_t *physmap,
 987     int *physmap_idxp)
 988 {
 989         int i, insert_idx, physmap_idx;
 990
 991         physmap_idx = *physmap_idxp;
 992
 993         if (length == 0)
 994                 return (1);
 995
 996         /*
 997          * Find insertion point while checking for overlap.  Start off by
 998          * assuming the new entry will be added to the end.
 999          *
1000          * NB: physmap_idx points to the next free slot.
1001          */
1002         insert_idx = physmap_idx;
1003         for (i = 0; i <= physmap_idx; i += 2) {
1004                 if (base < physmap[i + 1]) {
1005                         if (base + length <= physmap[i]) {
1006                                 insert_idx = i;
1007                                 break;
1008                         }
1009                         if (boothowto & RB_VERBOSE)
1010                                 printf(
1011                     "Overlapping memory regions, ignoring second region\n");
1012                         return (1);
1013                 }
1014         }
1015
1016         /* See if we can prepend to the next entry. */
1017         if (insert_idx <= physmap_idx && base + length == physmap[insert_idx]) {
1018                 physmap[insert_idx] = base;
1019                 return (1);
1020         }
1021
1022         /* See if we can append to the previous entry. */
1023         if (insert_idx > 0 && base == physmap[insert_idx - 1]) {
1024                 physmap[insert_idx - 1] += length;
1025                 return (1);
1026         }
1027
1028         physmap_idx += 2;
1029         *physmap_idxp = physmap_idx;
1030         if (physmap_idx == PHYS_AVAIL_ENTRIES) {
1031                 printf(
1032                 "Too many segments in the physical address map, giving up\n");
1033                 return (0);
1034         }
1035
1036         /*
1037          * Move the last 'N' entries down to make room for the new
1038          * entry if needed.
1039          */
1040         for (i = (physmap_idx - 2); i > insert_idx; i -= 2) {
1041                 physmap[i] = physmap[i - 2];
1042                 physmap[i + 1] = physmap[i - 1];
1043         }
1044
1045         /* Insert the new entry. */
1046         physmap[insert_idx] = base;
1047         physmap[insert_idx + 1] = base + length;
1048         return (1);
1049 }
1050
1051 void
1052 bios_add_smap_entries(struct bios_smap *smapbase, u_int32_t smapsize,
1053                       vm_paddr_t *physmap, int *physmap_idx)
1054 {
1055         struct bios_smap *smap, *smapend;
1056
1057         smapend = (struct bios_smap *)((uintptr_t)smapbase + smapsize);
1058
1059         for (smap = smapbase; smap < smapend; smap++) {
1060                 if (boothowto & RB_VERBOSE)
1061                         printf("SMAP type=%02x base=%016lx len=%016lx\n",
1062                             smap->type, smap->base, smap->length);
1063
1064                 if (smap->type != SMAP_TYPE_MEMORY)
1065                         continue;
1066
1067                 if (!add_physmap_entry(smap->base, smap->length, physmap,
1068                     physmap_idx))
1069                         break;
1070         }
1071 }
1072
1073 static void
1074 add_efi_map_entries(struct efi_map_header *efihdr, vm_paddr_t *physmap,
1075     int *physmap_idx)
1076 {
1077         struct efi_md *map, *p;
1078         const char *type;
1079         size_t efisz;
1080         int ndesc, i;
1081
1082         static const char *types[] = {
1083                 "Reserved",
1084                 "LoaderCode",
1085                 "LoaderData",
1086                 "BootServicesCode",
1087                 "BootServicesData",
1088                 "RuntimeServicesCode",
1089                 "RuntimeServicesData",
1090                 "ConventionalMemory",
1091                 "UnusableMemory",
1092                 "ACPIReclaimMemory",
1093                 "ACPIMemoryNVS",
1094                 "MemoryMappedIO",
1095                 "MemoryMappedIOPortSpace",
1096                 "PalCode",
1097                 "PersistentMemory"
1098         };
1099
1100         /*
1101          * Memory map data provided by UEFI via the GetMemoryMap
1102          * Boot Services API.
1103          */
1104         efisz = (sizeof(struct efi_map_header) + 0xf) & ~0xf;
1105         map = (struct efi_md *)((uint8_t *)efihdr + efisz);
1106
1107         if (efihdr->descriptor_size == 0)
1108                 return;
1109         ndesc = efihdr->memory_size / efihdr->descriptor_size;
1110
1111         if (boothowto & RB_VERBOSE)
1112                 printf("%23s %12s %12s %8s %4s\n",
1113                     "Type", "Physical", "Virtual", "#Pages", "Attr");
1114
1115         for (i = 0, p = map; i < ndesc; i++,
1116             p = efi_next_descriptor(p, efihdr->descriptor_size)) {
1117                 if (boothowto & RB_VERBOSE) {
1118                         if (p->md_type < nitems(types))
1119                                 type = types[p->md_type];
1120                         else
1121                                 type = "<INVALID>";
1122                         printf("%23s %012lx %12p %08lx ", type, p->md_phys,
1123                             p->md_virt, p->md_pages);
1124                         if (p->md_attr & EFI_MD_ATTR_UC)
1125                                 printf("UC ");
1126                         if (p->md_attr & EFI_MD_ATTR_WC)
1127                                 printf("WC ");
1128                         if (p->md_attr & EFI_MD_ATTR_WT)
1129                                 printf("WT ");
1130                         if (p->md_attr & EFI_MD_ATTR_WB)
1131                                 printf("WB ");
1132                         if (p->md_attr & EFI_MD_ATTR_UCE)
1133                                 printf("UCE ");
1134                         if (p->md_attr & EFI_MD_ATTR_WP)
1135                                 printf("WP ");
1136                         if (p->md_attr & EFI_MD_ATTR_RP)
1137                                 printf("RP ");
1138                         if (p->md_attr & EFI_MD_ATTR_XP)
1139                                 printf("XP ");
1140                         if (p->md_attr & EFI_MD_ATTR_NV)
1141                                 printf("NV ");
1142                         if (p->md_attr & EFI_MD_ATTR_MORE_RELIABLE)
1143                                 printf("MORE_RELIABLE ");
1144                         if (p->md_attr & EFI_MD_ATTR_RO)
1145                                 printf("RO ");
1146                         if (p->md_attr & EFI_MD_ATTR_RT)
1147                                 printf("RUNTIME");
1148                         printf("\n");
1149                 }
1150
1151                 switch (p->md_type) {
1152                 case EFI_MD_TYPE_CODE:
1153                 case EFI_MD_TYPE_DATA:
1154                 case EFI_MD_TYPE_BS_CODE:
1155                 case EFI_MD_TYPE_BS_DATA:
1156                 case EFI_MD_TYPE_FREE:
1157                         /*
1158                          * We're allowed to use any entry with these types.
1159                          */
1160                         break;
1161                 default:
1162                         continue;
1163                 }
1164
1165                 if (!add_physmap_entry(p->md_phys, (p->md_pages * PAGE_SIZE),
1166                     physmap, physmap_idx))
1167                         break;
1168         }
1169 }
1170
1171 static char bootmethod[16] = "";
1172 SYSCTL_STRING(_machdep, OID_AUTO, bootmethod, CTLFLAG_RD, bootmethod, 0,
1173     "System firmware boot method");
1174
1175 static void
1176 native_parse_memmap(caddr_t kmdp, vm_paddr_t *physmap, int *physmap_idx)
1177 {
1178         struct bios_smap *smap;
1179         struct efi_map_header *efihdr;
1180         u_int32_t size;
1181
1182         /*
1183          * Memory map from INT 15:E820.
1184          *
1185          * subr_module.c says:
1186          * "Consumer may safely assume that size value precedes data."
1187          * ie: an int32_t immediately precedes smap.
1188          */
1189
1190         efihdr = (struct efi_map_header *)preload_search_info(kmdp,
1191             MODINFO_METADATA | MODINFOMD_EFI_MAP);
1192         smap = (struct bios_smap *)preload_search_info(kmdp,
1193             MODINFO_METADATA | MODINFOMD_SMAP);
1194         if (efihdr == NULL && smap == NULL)
1195                 panic("No BIOS smap or EFI map info from loader!");
1196
1197         if (efihdr != NULL) {
1198                 add_efi_map_entries(efihdr, physmap, physmap_idx);
1199                 strlcpy(bootmethod, "UEFI", sizeof(bootmethod));
1200         } else {
1201                 size = *((u_int32_t *)smap - 1);
1202                 bios_add_smap_entries(smap, size, physmap, physmap_idx);
1203                 strlcpy(bootmethod, "BIOS", sizeof(bootmethod));
1204         }
1205 }
1206
1207 #define PAGES_PER_GB    (1024 * 1024 * 1024 / PAGE_SIZE)
1208
1209 /*
1210  * Populate the (physmap) array with base/bound pairs describing the
1211  * available physical memory in the system, then test this memory and
1212  * build the phys_avail array describing the actually-available memory.
1213  *
1214  * Total memory size may be set by the kernel environment variable
1215  * hw.physmem or the compile-time define MAXMEM.
1216  *
1217  * XXX first should be vm_paddr_t.
1218  */
1219 static void
1220 getmemsize(caddr_t kmdp, u_int64_t first)
1221 {
1222         int i, physmap_idx, pa_indx, da_indx;
1223         vm_paddr_t pa, physmap[PHYS_AVAIL_ENTRIES];
1224         u_long physmem_start, physmem_tunable, memtest;
1225         pt_entry_t *pte;
1226         quad_t dcons_addr, dcons_size;
1227         int page_counter;
1228
1229         /*
1230          * Tell the physical memory allocator about pages used to store
1231          * the kernel and preloaded data.  See kmem_bootstrap_free().
1232          */
1233         vm_phys_early_add_seg((vm_paddr_t)kernphys, trunc_page(first));
1234
1235         bzero(physmap, sizeof(physmap));
1236         physmap_idx = 0;
1237
1238         init_ops.parse_memmap(kmdp, physmap, &physmap_idx);
1239         physmap_idx -= 2;
1240
1241         /*
1242          * Find the 'base memory' segment for SMP
1243          */
1244         basemem = 0;
1245         for (i = 0; i <= physmap_idx; i += 2) {
1246                 if (physmap[i] <= 0xA0000) {
1247                         basemem = physmap[i + 1] / 1024;
1248                         break;
1249                 }
1250         }
1251         if (basemem == 0 || basemem > 640) {
1252                 if (bootverbose)
1253                         printf(
1254                 "Memory map doesn't contain a basemem segment, faking it");
1255                 basemem = 640;
1256         }
1257
1258         /*
1259          * Maxmem isn't the "maximum memory", it's one larger than the
1260          * highest page of the physical address space.  It should be
1261          * called something like "Maxphyspage".  We may adjust this
1262          * based on ``hw.physmem'' and the results of the memory test.
1263          */
1264         Maxmem = atop(physmap[physmap_idx + 1]);
1265
1266 #ifdef MAXMEM
1267         Maxmem = MAXMEM / 4;
1268 #endif
1269
1270         if (TUNABLE_ULONG_FETCH("hw.physmem", &physmem_tunable))
1271                 Maxmem = atop(physmem_tunable);
1272
1273         /*
1274          * The boot memory test is disabled by default, as it takes a
1275          * significant amount of time on large-memory systems, and is
1276          * unfriendly to virtual machines as it unnecessarily touches all
1277          * pages.
1278          *
1279          * A general name is used as the code may be extended to support
1280          * additional tests beyond the current "page present" test.
1281          */
1282         memtest = 0;
1283         TUNABLE_ULONG_FETCH("hw.memtest.tests", &memtest);
1284
1285         /*
1286          * Don't allow MAXMEM or hw.physmem to extend the amount of memory
1287          * in the system.
1288          */
1289         if (Maxmem > atop(physmap[physmap_idx + 1]))
1290                 Maxmem = atop(physmap[physmap_idx + 1]);
1291
1292         if (atop(physmap[physmap_idx + 1]) != Maxmem &&
1293             (boothowto & RB_VERBOSE))
1294                 printf("Physical memory use set to %ldK\n", Maxmem * 4);
1295
1296         /*
1297          * Make hole for "AP -> long mode" bootstrap code.  The
1298          * mp_bootaddress vector is only available when the kernel
1299          * is configured to support APs and APs for the system start
1300          * in real mode mode (e.g. SMP bare metal).
1301          */
1302         if (init_ops.mp_bootaddress)
1303                 init_ops.mp_bootaddress(physmap, &physmap_idx);
1304
1305         /* call pmap initialization to make new kernel address space */
1306         pmap_bootstrap(&first);
1307
1308         /*
1309          * Size up each available chunk of physical memory.
1310          *
1311          * XXX Some BIOSes corrupt low 64KB between suspend and resume.
1312          * By default, mask off the first 16 pages unless we appear to be
1313          * running in a VM.
1314          */
1315         physmem_start = (vm_guest > VM_GUEST_NO ? 1 : 16) << PAGE_SHIFT;
1316         TUNABLE_ULONG_FETCH("hw.physmem.start", &physmem_start);
1317         if (physmap[0] < physmem_start) {
1318                 if (physmem_start < PAGE_SIZE)
1319                         physmap[0] = PAGE_SIZE;
1320                 else if (physmem_start >= physmap[1])
1321                         physmap[0] = round_page(physmap[1] - PAGE_SIZE);
1322                 else
1323                         physmap[0] = round_page(physmem_start);
1324         }
1325         pa_indx = 0;
1326         da_indx = 1;
1327         phys_avail[pa_indx++] = physmap[0];
1328         phys_avail[pa_indx] = physmap[0];
1329         dump_avail[da_indx] = physmap[0];
1330         pte = CMAP1;
1331
1332         /*
1333          * Get dcons buffer address
1334          */
1335         if (getenv_quad("dcons.addr", &dcons_addr) == 0 ||
1336             getenv_quad("dcons.size", &dcons_size) == 0)
1337                 dcons_addr = 0;
1338
1339         /*
1340          * physmap is in bytes, so when converting to page boundaries,
1341          * round up the start address and round down the end address.
1342          */
1343         page_counter = 0;
1344         if (memtest != 0)
1345                 printf("Testing system memory");
1346         for (i = 0; i <= physmap_idx; i += 2) {
1347                 vm_paddr_t end;
1348
1349                 end = ptoa((vm_paddr_t)Maxmem);
1350                 if (physmap[i + 1] < end)
1351                         end = trunc_page(physmap[i + 1]);
1352                 for (pa = round_page(physmap[i]); pa < end; pa += PAGE_SIZE) {
1353                         int tmp, page_bad, full;
1354                         int *ptr = (int *)CADDR1;
1355
1356                         full = FALSE;
1357                         /*
1358                          * block out kernel memory as not available.
1359                          */
1360                         if (pa >= (vm_paddr_t)kernphys && pa < first)
1361                                 goto do_dump_avail;
1362
1363                         /*
1364                          * block out dcons buffer
1365                          */
1366                         if (dcons_addr > 0
1367                             && pa >= trunc_page(dcons_addr)
1368                             && pa < dcons_addr + dcons_size)
1369                                 goto do_dump_avail;
1370
1371                         page_bad = FALSE;
1372                         if (memtest == 0)
1373                                 goto skip_memtest;
1374
1375                         /*
1376                          * Print a "." every GB to show we're making
1377                          * progress.
1378                          */
1379                         page_counter++;
1380                         if ((page_counter % PAGES_PER_GB) == 0)
1381                                 printf(".");
1382
1383                         /*
1384                          * map page into kernel: valid, read/write,non-cacheable
1385                          */
1386                         *pte = pa | PG_V | PG_RW | PG_NC_PWT | PG_NC_PCD;
1387                         invltlb();
1388
1389                         tmp = *(int *)ptr;
1390                         /*
1391                          * Test for alternating 1's and 0's
1392                          */
1393                         *(volatile int *)ptr = 0xaaaaaaaa;
1394                         if (*(volatile int *)ptr != 0xaaaaaaaa)
1395                                 page_bad = TRUE;
1396                         /*
1397                          * Test for alternating 0's and 1's
1398                          */
1399                         *(volatile int *)ptr = 0x55555555;
1400                         if (*(volatile int *)ptr != 0x55555555)
1401                                 page_bad = TRUE;
1402                         /*
1403                          * Test for all 1's
1404                          */
1405                         *(volatile int *)ptr = 0xffffffff;
1406                         if (*(volatile int *)ptr != 0xffffffff)
1407                                 page_bad = TRUE;
1408                         /*
1409                          * Test for all 0's
1410                          */
1411                         *(volatile int *)ptr = 0x0;
1412                         if (*(volatile int *)ptr != 0x0)
1413                                 page_bad = TRUE;
1414                         /*
1415                          * Restore original value.
1416                          */
1417                         *(int *)ptr = tmp;
1418
1419 skip_memtest:
1420                         /*
1421                          * Adjust array of valid/good pages.
1422                          */
1423                         if (page_bad == TRUE)
1424                                 continue;
1425                         /*
1426                          * If this good page is a continuation of the
1427                          * previous set of good pages, then just increase
1428                          * the end pointer. Otherwise start a new chunk.
1429                          * Note that "end" points one higher than end,
1430                          * making the range >= start and < end.
1431                          * If we're also doing a speculative memory
1432                          * test and we at or past the end, bump up Maxmem
1433                          * so that we keep going. The first bad page
1434                          * will terminate the loop.
1435                          */
1436                         if (phys_avail[pa_indx] == pa) {
1437                                 phys_avail[pa_indx] += PAGE_SIZE;
1438                         } else {
1439                                 pa_indx++;
1440                                 if (pa_indx == PHYS_AVAIL_ENTRIES) {
1441                                         printf(
1442                 "Too many holes in the physical address space, giving up\n");
1443                                         pa_indx--;
1444                                         full = TRUE;
1445                                         goto do_dump_avail;
1446                                 }
1447                                 phys_avail[pa_indx++] = pa;     /* start */
1448                                 phys_avail[pa_indx] = pa + PAGE_SIZE; /* end */
1449                         }
1450                         physmem++;
1451 do_dump_avail:
1452                         if (dump_avail[da_indx] == pa) {
1453                                 dump_avail[da_indx] += PAGE_SIZE;
1454                         } else {
1455                                 da_indx++;
1456                                 if (da_indx == PHYS_AVAIL_ENTRIES) {
1457                                         da_indx--;
1458                                         goto do_next;
1459                                 }
1460                                 dump_avail[da_indx++] = pa; /* start */
1461                                 dump_avail[da_indx] = pa + PAGE_SIZE; /* end */
1462                         }
1463 do_next:
1464                         if (full)
1465                                 break;
1466                 }
1467         }
1468         *pte = 0;
1469         invltlb();
1470         if (memtest != 0)
1471                 printf("\n");
1472
1473         /*
1474          * XXX
1475          * The last chunk must contain at least one page plus the message
1476          * buffer to avoid complicating other code (message buffer address
1477          * calculation, etc.).
1478          */
1479         while (phys_avail[pa_indx - 1] + PAGE_SIZE +
1480             round_page(msgbufsize) >= phys_avail[pa_indx]) {
1481                 physmem -= atop(phys_avail[pa_indx] - phys_avail[pa_indx - 1]);
1482                 phys_avail[pa_indx--] = 0;
1483                 phys_avail[pa_indx--] = 0;
1484         }
1485
1486         Maxmem = atop(phys_avail[pa_indx]);
1487
1488         /* Trim off space for the message buffer. */
1489         phys_avail[pa_indx] -= round_page(msgbufsize);
1490
1491         /* Map the message buffer. */
1492         msgbufp = (struct msgbuf *)PHYS_TO_DMAP(phys_avail[pa_indx]);
1493 }
1494
1495 static caddr_t
1496 native_parse_preload_data(u_int64_t modulep)
1497 {
1498         caddr_t kmdp;
1499         char *envp;
1500 #ifdef DDB
1501         vm_offset_t ksym_start;
1502         vm_offset_t ksym_end;
1503 #endif
1504
1505         preload_metadata = (caddr_t)(uintptr_t)(modulep + KERNBASE);
1506         preload_bootstrap_relocate(KERNBASE);
1507         kmdp = preload_search_by_type("elf kernel");
1508         if (kmdp == NULL)
1509                 kmdp = preload_search_by_type("elf64 kernel");
1510         boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
1511         envp = MD_FETCH(kmdp, MODINFOMD_ENVP, char *);
1512         if (envp != NULL)
1513                 envp += KERNBASE;
1514         init_static_kenv(envp, 0);
1515 #ifdef DDB
1516         ksym_start = MD_FETCH(kmdp, MODINFOMD_SSYM, uintptr_t);
1517         ksym_end = MD_FETCH(kmdp, MODINFOMD_ESYM, uintptr_t);
1518         db_fetch_ksymtab(ksym_start, ksym_end, 0);
1519 #endif
1520         efi_systbl_phys = MD_FETCH(kmdp, MODINFOMD_FW_HANDLE, vm_paddr_t);
1521
1522         return (kmdp);
1523 }
1524
1525 static void
1526 amd64_kdb_init(void)
1527 {
1528         kdb_init();
1529 #ifdef KDB
1530         if (boothowto & RB_KDB)
1531                 kdb_enter(KDB_WHY_BOOTFLAGS, "Boot flags requested debugger");
1532 #endif
1533 }
1534
1535 /* Set up the fast syscall stuff */
1536 void
1537 amd64_conf_fast_syscall(void)
1538 {
1539         uint64_t msr;
1540
1541         msr = rdmsr(MSR_EFER) | EFER_SCE;
1542         wrmsr(MSR_EFER, msr);
1543         wrmsr(MSR_LSTAR, pti ? (u_int64_t)IDTVEC(fast_syscall_pti) :
1544             (u_int64_t)IDTVEC(fast_syscall));
1545         wrmsr(MSR_CSTAR, (u_int64_t)IDTVEC(fast_syscall32));
1546         msr = ((u_int64_t)GSEL(GCODE_SEL, SEL_KPL) << 32) |
1547             ((u_int64_t)GSEL(GUCODE32_SEL, SEL_UPL) << 48);
1548         wrmsr(MSR_STAR, msr);
1549         wrmsr(MSR_SF_MASK, PSL_NT | PSL_T | PSL_I | PSL_C | PSL_D | PSL_AC);
1550 }
1551
1552 void
1553 amd64_bsp_pcpu_init1(struct pcpu *pc)
1554 {
1555         struct user_segment_descriptor *gdt;
1556
1557         PCPU_SET(prvspace, pc);
1558         gdt = *PCPU_PTR(gdt);
1559         PCPU_SET(curthread, &thread0);
1560         PCPU_SET(tssp, PCPU_PTR(common_tss));
1561         PCPU_SET(tss, (struct system_segment_descriptor *)&gdt[GPROC0_SEL]);
1562         PCPU_SET(ldt, (struct system_segment_descriptor *)&gdt[GUSERLDT_SEL]);
1563         PCPU_SET(fs32p, &gdt[GUFS32_SEL]);
1564         PCPU_SET(gs32p, &gdt[GUGS32_SEL]);
1565         PCPU_SET(smp_tlb_gen, 1);
1566 }
1567
1568 void
1569 amd64_bsp_pcpu_init2(uint64_t rsp0)
1570 {
1571
1572         PCPU_SET(rsp0, rsp0);
1573         PCPU_SET(pti_rsp0, ((vm_offset_t)PCPU_PTR(pti_stack) +
1574             PC_PTI_STACK_SZ * sizeof(uint64_t)) & ~0xful);
1575         PCPU_SET(curpcb, thread0.td_pcb);
1576 }
1577
1578 void
1579 amd64_bsp_ist_init(struct pcpu *pc)
1580 {
1581         struct nmi_pcpu *np;
1582         struct amd64tss *tssp;
1583
1584         tssp = &pc->pc_common_tss;
1585
1586         /* doublefault stack space, runs on ist1 */
1587         np = ((struct nmi_pcpu *)&dblfault_stack[sizeof(dblfault_stack)]) - 1;
1588         np->np_pcpu = (register_t)pc;
1589         tssp->tss_ist1 = (long)np;
1590
1591         /*
1592          * NMI stack, runs on ist2.  The pcpu pointer is stored just
1593          * above the start of the ist2 stack.
1594          */
1595         np = ((struct nmi_pcpu *)&nmi0_stack[sizeof(nmi0_stack)]) - 1;
1596         np->np_pcpu = (register_t)pc;
1597         tssp->tss_ist2 = (long)np;
1598
1599         /*
1600          * MC# stack, runs on ist3.  The pcpu pointer is stored just
1601          * above the start of the ist3 stack.
1602          */
1603         np = ((struct nmi_pcpu *)&mce0_stack[sizeof(mce0_stack)]) - 1;
1604         np->np_pcpu = (register_t)pc;
1605         tssp->tss_ist3 = (long)np;
1606
1607         /*
1608          * DB# stack, runs on ist4.
1609          */
1610         np = ((struct nmi_pcpu *)&dbg0_stack[sizeof(dbg0_stack)]) - 1;
1611         np->np_pcpu = (register_t)pc;
1612         tssp->tss_ist4 = (long)np;
1613 }
1614
1615 u_int64_t
1616 hammer_time(u_int64_t modulep, u_int64_t physfree)
1617 {
1618         caddr_t kmdp;
1619         int gsel_tss, x;
1620         struct pcpu *pc;
1621         struct xstate_hdr *xhdr;
1622         u_int64_t rsp0;
1623         char *env;
1624         struct user_segment_descriptor *gdt;
1625         struct region_descriptor r_gdt;
1626         size_t kstack0_sz;
1627         int late_console;
1628
1629         TSRAW(&thread0, TS_ENTER, __func__, NULL);
1630
1631         kmdp = init_ops.parse_preload_data(modulep);
1632
1633         physfree += ucode_load_bsp(physfree + KERNBASE);
1634         physfree = roundup2(physfree, PAGE_SIZE);
1635
1636         identify_cpu1();
1637         identify_hypervisor();
1638         identify_cpu_fixup_bsp();
1639         identify_cpu2();
1640         initializecpucache();
1641
1642         /*
1643          * Check for pti, pcid, and invpcid before ifuncs are
1644          * resolved, to correctly select the implementation for
1645          * pmap_activate_sw_mode().
1646          */
1647         pti = pti_get_default();
1648         TUNABLE_INT_FETCH("vm.pmap.pti", &pti);
1649         TUNABLE_INT_FETCH("vm.pmap.pcid_enabled", &pmap_pcid_enabled);
1650         if ((cpu_feature2 & CPUID2_PCID) != 0 && pmap_pcid_enabled) {
1651                 invpcid_works = (cpu_stdext_feature &
1652                     CPUID_STDEXT_INVPCID) != 0;
1653         } else {
1654                 pmap_pcid_enabled = 0;
1655         }
1656
1657         link_elf_ireloc(kmdp);
1658
1659         /*
1660          * This may be done better later if it gets more high level
1661          * components in it. If so just link td->td_proc here.
1662          */
1663         proc_linkup0(&proc0, &thread0);
1664
1665         /* Init basic tunables, hz etc */
1666         init_param1();
1667
1668         thread0.td_kstack = physfree + KERNBASE;
1669         thread0.td_kstack_pages = kstack_pages;
1670         kstack0_sz = thread0.td_kstack_pages * PAGE_SIZE;
1671         bzero((void *)thread0.td_kstack, kstack0_sz);
1672         physfree += kstack0_sz;
1673
1674         /*
1675          * Initialize enough of thread0 for delayed invalidation to
1676          * work very early.  Rely on thread0.td_base_pri
1677          * zero-initialization, it is reset to PVM at proc0_init().
1678          */
1679         pmap_thread_init_invl_gen(&thread0);
1680
1681         pc = &temp_bsp_pcpu;
1682         pcpu_init(pc, 0, sizeof(struct pcpu));
1683         gdt = &temp_bsp_pcpu.pc_gdt[0];
1684
1685         /*
1686          * make gdt memory segments
1687          */
1688         for (x = 0; x < NGDT; x++) {
1689                 if (x != GPROC0_SEL && x != (GPROC0_SEL + 1) &&
1690                     x != GUSERLDT_SEL && x != (GUSERLDT_SEL) + 1)
1691                         ssdtosd(&gdt_segs[x], &gdt[x]);
1692         }
1693         gdt_segs[GPROC0_SEL].ssd_base = (uintptr_t)&pc->pc_common_tss;
1694         ssdtosyssd(&gdt_segs[GPROC0_SEL],
1695             (struct system_segment_descriptor *)&gdt[GPROC0_SEL]);
1696
1697         r_gdt.rd_limit = NGDT * sizeof(gdt[0]) - 1;
1698         r_gdt.rd_base = (long)gdt;
1699         lgdt(&r_gdt);
1700
1701         wrmsr(MSR_FSBASE, 0);           /* User value */
1702         wrmsr(MSR_GSBASE, (u_int64_t)pc);
1703         wrmsr(MSR_KGSBASE, 0);          /* User value while in the kernel */
1704
1705         dpcpu_init((void *)(physfree + KERNBASE), 0);
1706         physfree += DPCPU_SIZE;
1707         amd64_bsp_pcpu_init1(pc);
1708         /* Non-late cninit() and printf() can be moved up to here. */
1709
1710         /*
1711          * Initialize mutexes.
1712          *
1713          * icu_lock: in order to allow an interrupt to occur in a critical
1714          *           section, to set pcpu->ipending (etc...) properly, we
1715          *           must be able to get the icu lock, so it can't be
1716          *           under witness.
1717          */
1718         mutex_init();
1719         mtx_init(&icu_lock, "icu", NULL, MTX_SPIN | MTX_NOWITNESS);
1720         mtx_init(&dt_lock, "descriptor tables", NULL, MTX_DEF);
1721
1722         /* exceptions */
1723         for (x = 0; x < NIDT; x++)
1724                 setidt(x, pti ? &IDTVEC(rsvd_pti) : &IDTVEC(rsvd), SDT_SYSIGT,
1725                     SEL_KPL, 0);
1726         setidt(IDT_DE, pti ? &IDTVEC(div_pti) : &IDTVEC(div), SDT_SYSIGT,
1727             SEL_KPL, 0);
1728         setidt(IDT_DB, &IDTVEC(dbg), SDT_SYSIGT, SEL_KPL, 4);
1729         setidt(IDT_NMI, &IDTVEC(nmi),  SDT_SYSIGT, SEL_KPL, 2);
1730         setidt(IDT_BP, pti ? &IDTVEC(bpt_pti) : &IDTVEC(bpt), SDT_SYSIGT,
1731             SEL_UPL, 0);
1732         setidt(IDT_OF, pti ? &IDTVEC(ofl_pti) : &IDTVEC(ofl), SDT_SYSIGT,
1733             SEL_UPL, 0);
1734         setidt(IDT_BR, pti ? &IDTVEC(bnd_pti) : &IDTVEC(bnd), SDT_SYSIGT,
1735             SEL_KPL, 0);
1736         setidt(IDT_UD, pti ? &IDTVEC(ill_pti) : &IDTVEC(ill), SDT_SYSIGT,
1737             SEL_KPL, 0);
1738         setidt(IDT_NM, pti ? &IDTVEC(dna_pti) : &IDTVEC(dna), SDT_SYSIGT,
1739             SEL_KPL, 0);
1740         setidt(IDT_DF, &IDTVEC(dblfault), SDT_SYSIGT, SEL_KPL, 1);
1741         setidt(IDT_FPUGP, pti ? &IDTVEC(fpusegm_pti) : &IDTVEC(fpusegm),
1742             SDT_SYSIGT, SEL_KPL, 0);
1743         setidt(IDT_TS, pti ? &IDTVEC(tss_pti) : &IDTVEC(tss), SDT_SYSIGT,
1744             SEL_KPL, 0);
1745         setidt(IDT_NP, pti ? &IDTVEC(missing_pti) : &IDTVEC(missing),
1746             SDT_SYSIGT, SEL_KPL, 0);
1747         setidt(IDT_SS, pti ? &IDTVEC(stk_pti) : &IDTVEC(stk), SDT_SYSIGT,
1748             SEL_KPL, 0);
1749         setidt(IDT_GP, pti ? &IDTVEC(prot_pti) : &IDTVEC(prot), SDT_SYSIGT,
1750             SEL_KPL, 0);
1751         setidt(IDT_PF, pti ? &IDTVEC(page_pti) : &IDTVEC(page), SDT_SYSIGT,
1752             SEL_KPL, 0);
1753         setidt(IDT_MF, pti ? &IDTVEC(fpu_pti) : &IDTVEC(fpu), SDT_SYSIGT,
1754             SEL_KPL, 0);
1755         setidt(IDT_AC, pti ? &IDTVEC(align_pti) : &IDTVEC(align), SDT_SYSIGT,
1756             SEL_KPL, 0);
1757         setidt(IDT_MC, &IDTVEC(mchk), SDT_SYSIGT, SEL_KPL, 3);
1758         setidt(IDT_XF, pti ? &IDTVEC(xmm_pti) : &IDTVEC(xmm), SDT_SYSIGT,
1759             SEL_KPL, 0);
1760 #ifdef KDTRACE_HOOKS
1761         setidt(IDT_DTRACE_RET, pti ? &IDTVEC(dtrace_ret_pti) :
1762             &IDTVEC(dtrace_ret), SDT_SYSIGT, SEL_UPL, 0);
1763 #endif
1764 #ifdef XENHVM
1765         setidt(IDT_EVTCHN, pti ? &IDTVEC(xen_intr_upcall_pti) :
1766             &IDTVEC(xen_intr_upcall), SDT_SYSIGT, SEL_KPL, 0);
1767 #endif
1768         r_idt.rd_limit = sizeof(idt0) - 1;
1769         r_idt.rd_base = (long) idt;
1770         lidt(&r_idt);
1771
1772         /*
1773          * Initialize the clock before the console so that console
1774          * initialization can use DELAY().
1775          */
1776         clock_init();
1777
1778         /*
1779          * Use vt(4) by default for UEFI boot (during the sc(4)/vt(4)
1780          * transition).
1781          * Once bootblocks have updated, we can test directly for
1782          * efi_systbl != NULL here...
1783          */
1784         if (preload_search_info(kmdp, MODINFO_METADATA | MODINFOMD_EFI_MAP)
1785             != NULL)
1786                 vty_set_preferred(VTY_VT);
1787
1788         TUNABLE_INT_FETCH("hw.ibrs_disable", &hw_ibrs_disable);
1789         TUNABLE_INT_FETCH("machdep.mitigations.ibrs.disable", &hw_ibrs_disable);
1790
1791         TUNABLE_INT_FETCH("hw.spec_store_bypass_disable", &hw_ssb_disable);
1792         TUNABLE_INT_FETCH("machdep.mitigations.ssb.disable", &hw_ssb_disable);
1793
1794         TUNABLE_INT_FETCH("machdep.syscall_ret_l1d_flush",
1795             &syscall_ret_l1d_flush_mode);
1796
1797         TUNABLE_INT_FETCH("hw.mds_disable", &hw_mds_disable);
1798         TUNABLE_INT_FETCH("machdep.mitigations.mds.disable", &hw_mds_disable);
1799
1800         TUNABLE_INT_FETCH("machdep.mitigations.taa.enable", &x86_taa_enable);
1801
1802         TUNABLE_INT_FETCH("machdep.mitigations.rndgs.enable",
1803             &x86_rngds_mitg_enable);
1804
1805         finishidentcpu();       /* Final stage of CPU initialization */
1806         initializecpu();        /* Initialize CPU registers */
1807
1808         amd64_bsp_ist_init(pc);
1809
1810         /* Set the IO permission bitmap (empty due to tss seg limit) */
1811         pc->pc_common_tss.tss_iobase = sizeof(struct amd64tss) +
1812             IOPERM_BITMAP_SIZE;
1813
1814         gsel_tss = GSEL(GPROC0_SEL, SEL_KPL);
1815         ltr(gsel_tss);
1816
1817         amd64_conf_fast_syscall();
1818
1819         /*
1820          * We initialize the PCB pointer early so that exception
1821          * handlers will work.  Also set up td_critnest to short-cut
1822          * the page fault handler.
1823          */
1824         cpu_max_ext_state_size = sizeof(struct savefpu);
1825         set_top_of_stack_td(&thread0);
1826         thread0.td_pcb = get_pcb_td(&thread0);
1827         thread0.td_critnest = 1;
1828
1829         /*
1830          * The console and kdb should be initialized even earlier than here,
1831          * but some console drivers don't work until after getmemsize().
1832          * Default to late console initialization to support these drivers.
1833          * This loses mainly printf()s in getmemsize() and early debugging.
1834          */
1835         late_console = 1;
1836         TUNABLE_INT_FETCH("debug.late_console", &late_console);
1837         if (!late_console) {
1838                 cninit();
1839                 amd64_kdb_init();
1840         }
1841
1842         getmemsize(kmdp, physfree);
1843         init_param2(physmem);
1844
1845         /* now running on new page tables, configured,and u/iom is accessible */
1846
1847 #ifdef DEV_PCI
1848         /* This call might adjust phys_avail[]. */
1849         pci_early_quirks();
1850 #endif
1851
1852         if (late_console)
1853                 cninit();
1854
1855 #ifdef DEV_ISA
1856 #ifdef DEV_ATPIC
1857         elcr_probe();
1858         atpic_startup();
1859 #else
1860         /* Reset and mask the atpics and leave them shut down. */
1861         atpic_reset();
1862
1863         /*
1864          * Point the ICU spurious interrupt vectors at the APIC spurious
1865          * interrupt handler.
1866          */
1867         setidt(IDT_IO_INTS + 7, IDTVEC(spuriousint), SDT_SYSIGT, SEL_KPL, 0);
1868         setidt(IDT_IO_INTS + 15, IDTVEC(spuriousint), SDT_SYSIGT, SEL_KPL, 0);
1869 #endif
1870 #else
1871 #error "have you forgotten the isa device?"
1872 #endif
1873
1874         if (late_console)
1875                 amd64_kdb_init();
1876
1877         msgbufinit(msgbufp, msgbufsize);
1878         fpuinit();
1879
1880         /*
1881          * Reinitialize thread0's stack base now that the xsave area size is
1882          * known.  Set up thread0's pcb save area after fpuinit calculated fpu
1883          * save area size.  Zero out the extended state header in fpu save area.
1884          */
1885         set_top_of_stack_td(&thread0);
1886         thread0.td_pcb->pcb_save = get_pcb_user_save_td(&thread0);
1887         bzero(thread0.td_pcb->pcb_save, cpu_max_ext_state_size);
1888         if (use_xsave) {
1889                 xhdr = (struct xstate_hdr *)(get_pcb_user_save_td(&thread0) +
1890                     1);
1891                 xhdr->xstate_bv = xsave_mask;
1892         }
1893         /* make an initial tss so cpu can get interrupt stack on syscall! */
1894         rsp0 = thread0.td_md.md_stack_base;
1895         /* Ensure the stack is aligned to 16 bytes */
1896         rsp0 &= ~0xFul;
1897         PCPU_PTR(common_tss)->tss_rsp0 = rsp0;
1898         amd64_bsp_pcpu_init2(rsp0);
1899
1900         /* transfer to user mode */
1901
1902         _ucodesel = GSEL(GUCODE_SEL, SEL_UPL);
1903         _udatasel = GSEL(GUDATA_SEL, SEL_UPL);
1904         _ucode32sel = GSEL(GUCODE32_SEL, SEL_UPL);
1905         _ufssel = GSEL(GUFS32_SEL, SEL_UPL);
1906         _ugssel = GSEL(GUGS32_SEL, SEL_UPL);
1907
1908         load_ds(_udatasel);
1909         load_es(_udatasel);
1910         load_fs(_ufssel);
1911
1912         /* setup proc 0's pcb */
1913         thread0.td_pcb->pcb_flags = 0;
1914         thread0.td_frame = &proc0_tf;
1915
1916         env = kern_getenv("kernelname");
1917         if (env != NULL)
1918                 strlcpy(kernelname, env, sizeof(kernelname));
1919
1920         cpu_probe_amdc1e();
1921
1922         kcsan_cpu_init(0);
1923
1924 #ifdef FDT
1925         x86_init_fdt();
1926 #endif
1927         thread0.td_critnest = 0;
1928
1929         TSEXIT();
1930
1931         /* Location of kernel stack for locore */
1932         return (thread0.td_md.md_stack_base);
1933 }
1934
1935 void
1936 cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t size)
1937 {
1938
1939         pcpu->pc_acpi_id = 0xffffffff;
1940 }
1941
1942 static int
1943 smap_sysctl_handler(SYSCTL_HANDLER_ARGS)
1944 {
1945         struct bios_smap *smapbase;
1946         struct bios_smap_xattr smap;
1947         caddr_t kmdp;
1948         uint32_t *smapattr;
1949         int count, error, i;
1950
1951         /* Retrieve the system memory map from the loader. */
1952         kmdp = preload_search_by_type("elf kernel");
1953         if (kmdp == NULL)
1954                 kmdp = preload_search_by_type("elf64 kernel");
1955         smapbase = (struct bios_smap *)preload_search_info(kmdp,
1956             MODINFO_METADATA | MODINFOMD_SMAP);
1957         if (smapbase == NULL)
1958                 return (0);
1959         smapattr = (uint32_t *)preload_search_info(kmdp,
1960             MODINFO_METADATA | MODINFOMD_SMAP_XATTR);
1961         count = *((uint32_t *)smapbase - 1) / sizeof(*smapbase);
1962         error = 0;
1963         for (i = 0; i < count; i++) {
1964                 smap.base = smapbase[i].base;
1965                 smap.length = smapbase[i].length;
1966                 smap.type = smapbase[i].type;
1967                 if (smapattr != NULL)
1968                         smap.xattr = smapattr[i];
1969                 else
1970                         smap.xattr = 0;
1971                 error = SYSCTL_OUT(req, &smap, sizeof(smap));
1972         }
1973         return (error);
1974 }
1975 SYSCTL_PROC(_machdep, OID_AUTO, smap,
1976     CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
1977     smap_sysctl_handler, "S,bios_smap_xattr",
1978     "Raw BIOS SMAP data");
1979
1980 static int
1981 efi_map_sysctl_handler(SYSCTL_HANDLER_ARGS)
1982 {
1983         struct efi_map_header *efihdr;
1984         caddr_t kmdp;
1985         uint32_t efisize;
1986
1987         kmdp = preload_search_by_type("elf kernel");
1988         if (kmdp == NULL)
1989                 kmdp = preload_search_by_type("elf64 kernel");
1990         efihdr = (struct efi_map_header *)preload_search_info(kmdp,
1991             MODINFO_METADATA | MODINFOMD_EFI_MAP);
1992         if (efihdr == NULL)
1993                 return (0);
1994         efisize = *((uint32_t *)efihdr - 1);
1995         return (SYSCTL_OUT(req, efihdr, efisize));
1996 }
1997 SYSCTL_PROC(_machdep, OID_AUTO, efi_map,
1998     CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
1999     efi_map_sysctl_handler, "S,efi_map_header",
2000     "Raw EFI Memory Map");
2001
2002 void
2003 spinlock_enter(void)
2004 {
2005         struct thread *td;
2006         register_t flags;
2007
2008         td = curthread;
2009         if (td->td_md.md_spinlock_count == 0) {
2010                 flags = intr_disable();
2011                 td->td_md.md_spinlock_count = 1;
2012                 td->td_md.md_saved_flags = flags;
2013                 critical_enter();
2014         } else
2015                 td->td_md.md_spinlock_count++;
2016 }
2017
2018 void
2019 spinlock_exit(void)
2020 {
2021         struct thread *td;
2022         register_t flags;
2023
2024         td = curthread;
2025         flags = td->td_md.md_saved_flags;
2026         td->td_md.md_spinlock_count--;
2027         if (td->td_md.md_spinlock_count == 0) {
2028                 critical_exit();
2029                 intr_restore(flags);
2030         }
2031 }
2032
2033 /*
2034  * Construct a PCB from a trapframe. This is called from kdb_trap() where
2035  * we want to start a backtrace from the function that caused us to enter
2036  * the debugger. We have the context in the trapframe, but base the trace
2037  * on the PCB. The PCB doesn't have to be perfect, as long as it contains
2038  * enough for a backtrace.
2039  */
2040 void
2041 makectx(struct trapframe *tf, struct pcb *pcb)
2042 {
2043
2044         pcb->pcb_r12 = tf->tf_r12;
2045         pcb->pcb_r13 = tf->tf_r13;
2046         pcb->pcb_r14 = tf->tf_r14;
2047         pcb->pcb_r15 = tf->tf_r15;
2048         pcb->pcb_rbp = tf->tf_rbp;
2049         pcb->pcb_rbx = tf->tf_rbx;
2050         pcb->pcb_rip = tf->tf_rip;
2051         pcb->pcb_rsp = tf->tf_rsp;
2052 }
2053
2054 int
2055 ptrace_set_pc(struct thread *td, unsigned long addr)
2056 {
2057
2058         td->td_frame->tf_rip = addr;
2059         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
2060         return (0);
2061 }
2062
2063 int
2064 ptrace_single_step(struct thread *td)
2065 {
2066
2067         PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
2068         if ((td->td_frame->tf_rflags & PSL_T) == 0) {
2069                 td->td_frame->tf_rflags |= PSL_T;
2070                 td->td_dbgflags |= TDB_STEP;
2071         }
2072         return (0);
2073 }
2074
2075 int
2076 ptrace_clear_single_step(struct thread *td)
2077 {
2078
2079         PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
2080         td->td_frame->tf_rflags &= ~PSL_T;
2081         td->td_dbgflags &= ~TDB_STEP;
2082         return (0);
2083 }
2084
2085 int
2086 fill_regs(struct thread *td, struct reg *regs)
2087 {
2088         struct trapframe *tp;
2089
2090         tp = td->td_frame;
2091         return (fill_frame_regs(tp, regs));
2092 }
2093
2094 int
2095 fill_frame_regs(struct trapframe *tp, struct reg *regs)
2096 {
2097
2098         regs->r_r15 = tp->tf_r15;
2099         regs->r_r14 = tp->tf_r14;
2100         regs->r_r13 = tp->tf_r13;
2101         regs->r_r12 = tp->tf_r12;
2102         regs->r_r11 = tp->tf_r11;
2103         regs->r_r10 = tp->tf_r10;
2104         regs->r_r9  = tp->tf_r9;
2105         regs->r_r8  = tp->tf_r8;
2106         regs->r_rdi = tp->tf_rdi;
2107         regs->r_rsi = tp->tf_rsi;
2108         regs->r_rbp = tp->tf_rbp;
2109         regs->r_rbx = tp->tf_rbx;
2110         regs->r_rdx = tp->tf_rdx;
2111         regs->r_rcx = tp->tf_rcx;
2112         regs->r_rax = tp->tf_rax;
2113         regs->r_rip = tp->tf_rip;
2114         regs->r_cs = tp->tf_cs;
2115         regs->r_rflags = tp->tf_rflags;
2116         regs->r_rsp = tp->tf_rsp;
2117         regs->r_ss = tp->tf_ss;
2118         if (tp->tf_flags & TF_HASSEGS) {
2119                 regs->r_ds = tp->tf_ds;
2120                 regs->r_es = tp->tf_es;
2121                 regs->r_fs = tp->tf_fs;
2122                 regs->r_gs = tp->tf_gs;
2123         } else {
2124                 regs->r_ds = 0;
2125                 regs->r_es = 0;
2126                 regs->r_fs = 0;
2127                 regs->r_gs = 0;
2128         }
2129         regs->r_err = 0;
2130         regs->r_trapno = 0;
2131         return (0);
2132 }
2133
2134 int
2135 set_regs(struct thread *td, struct reg *regs)
2136 {
2137         struct trapframe *tp;
2138         register_t rflags;
2139
2140         tp = td->td_frame;
2141         rflags = regs->r_rflags & 0xffffffff;
2142         if (!EFL_SECURE(rflags, tp->tf_rflags) || !CS_SECURE(regs->r_cs))
2143                 return (EINVAL);
2144         tp->tf_r15 = regs->r_r15;
2145         tp->tf_r14 = regs->r_r14;
2146         tp->tf_r13 = regs->r_r13;
2147         tp->tf_r12 = regs->r_r12;
2148         tp->tf_r11 = regs->r_r11;
2149         tp->tf_r10 = regs->r_r10;
2150         tp->tf_r9  = regs->r_r9;
2151         tp->tf_r8  = regs->r_r8;
2152         tp->tf_rdi = regs->r_rdi;
2153         tp->tf_rsi = regs->r_rsi;
2154         tp->tf_rbp = regs->r_rbp;
2155         tp->tf_rbx = regs->r_rbx;
2156         tp->tf_rdx = regs->r_rdx;
2157         tp->tf_rcx = regs->r_rcx;
2158         tp->tf_rax = regs->r_rax;
2159         tp->tf_rip = regs->r_rip;
2160         tp->tf_cs = regs->r_cs;
2161         tp->tf_rflags = rflags;
2162         tp->tf_rsp = regs->r_rsp;
2163         tp->tf_ss = regs->r_ss;
2164         if (0) {        /* XXXKIB */
2165                 tp->tf_ds = regs->r_ds;
2166                 tp->tf_es = regs->r_es;
2167                 tp->tf_fs = regs->r_fs;
2168                 tp->tf_gs = regs->r_gs;
2169                 tp->tf_flags = TF_HASSEGS;
2170         }
2171         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
2172         return (0);
2173 }
2174
2175 /* XXX check all this stuff! */
2176 /* externalize from sv_xmm */
2177 static void
2178 fill_fpregs_xmm(struct savefpu *sv_xmm, struct fpreg *fpregs)
2179 {
2180         struct envxmm *penv_fpreg = (struct envxmm *)&fpregs->fpr_env;
2181         struct envxmm *penv_xmm = &sv_xmm->sv_env;
2182         int i;
2183
2184         /* pcb -> fpregs */
2185         bzero(fpregs, sizeof(*fpregs));
2186
2187         /* FPU control/status */
2188         penv_fpreg->en_cw = penv_xmm->en_cw;
2189         penv_fpreg->en_sw = penv_xmm->en_sw;
2190         penv_fpreg->en_tw = penv_xmm->en_tw;
2191         penv_fpreg->en_opcode = penv_xmm->en_opcode;
2192         penv_fpreg->en_rip = penv_xmm->en_rip;
2193         penv_fpreg->en_rdp = penv_xmm->en_rdp;
2194         penv_fpreg->en_mxcsr = penv_xmm->en_mxcsr;
2195         penv_fpreg->en_mxcsr_mask = penv_xmm->en_mxcsr_mask;
2196
2197         /* FPU registers */
2198         for (i = 0; i < 8; ++i)
2199                 bcopy(sv_xmm->sv_fp[i].fp_acc.fp_bytes, fpregs->fpr_acc[i], 10);
2200
2201         /* SSE registers */
2202         for (i = 0; i < 16; ++i)
2203                 bcopy(sv_xmm->sv_xmm[i].xmm_bytes, fpregs->fpr_xacc[i], 16);
2204 }
2205
2206 /* internalize from fpregs into sv_xmm */
2207 static void
2208 set_fpregs_xmm(struct fpreg *fpregs, struct savefpu *sv_xmm)
2209 {
2210         struct envxmm *penv_xmm = &sv_xmm->sv_env;
2211         struct envxmm *penv_fpreg = (struct envxmm *)&fpregs->fpr_env;
2212         int i;
2213
2214         /* fpregs -> pcb */
2215         /* FPU control/status */
2216         penv_xmm->en_cw = penv_fpreg->en_cw;
2217         penv_xmm->en_sw = penv_fpreg->en_sw;
2218         penv_xmm->en_tw = penv_fpreg->en_tw;
2219         penv_xmm->en_opcode = penv_fpreg->en_opcode;
2220         penv_xmm->en_rip = penv_fpreg->en_rip;
2221         penv_xmm->en_rdp = penv_fpreg->en_rdp;
2222         penv_xmm->en_mxcsr = penv_fpreg->en_mxcsr;
2223         penv_xmm->en_mxcsr_mask = penv_fpreg->en_mxcsr_mask & cpu_mxcsr_mask;
2224
2225         /* FPU registers */
2226         for (i = 0; i < 8; ++i)
2227                 bcopy(fpregs->fpr_acc[i], sv_xmm->sv_fp[i].fp_acc.fp_bytes, 10);
2228
2229         /* SSE registers */
2230         for (i = 0; i < 16; ++i)
2231                 bcopy(fpregs->fpr_xacc[i], sv_xmm->sv_xmm[i].xmm_bytes, 16);
2232 }
2233
2234 /* externalize from td->pcb */
2235 int
2236 fill_fpregs(struct thread *td, struct fpreg *fpregs)
2237 {
2238
2239         KASSERT(td == curthread || TD_IS_SUSPENDED(td) ||
2240             P_SHOULDSTOP(td->td_proc),
2241             ("not suspended thread %p", td));
2242         fpugetregs(td);
2243         fill_fpregs_xmm(get_pcb_user_save_td(td), fpregs);
2244         return (0);
2245 }
2246
2247 /* internalize to td->pcb */
2248 int
2249 set_fpregs(struct thread *td, struct fpreg *fpregs)
2250 {
2251
2252         critical_enter();
2253         set_fpregs_xmm(fpregs, get_pcb_user_save_td(td));
2254         fpuuserinited(td);
2255         critical_exit();
2256         return (0);
2257 }
2258
2259 /*
2260  * Get machine context.
2261  */
2262 int
2263 get_mcontext(struct thread *td, mcontext_t *mcp, int flags)
2264 {
2265         struct pcb *pcb;
2266         struct trapframe *tp;
2267
2268         pcb = td->td_pcb;
2269         tp = td->td_frame;
2270         PROC_LOCK(curthread->td_proc);
2271         mcp->mc_onstack = sigonstack(tp->tf_rsp);
2272         PROC_UNLOCK(curthread->td_proc);
2273         mcp->mc_r15 = tp->tf_r15;
2274         mcp->mc_r14 = tp->tf_r14;
2275         mcp->mc_r13 = tp->tf_r13;
2276         mcp->mc_r12 = tp->tf_r12;
2277         mcp->mc_r11 = tp->tf_r11;
2278         mcp->mc_r10 = tp->tf_r10;
2279         mcp->mc_r9  = tp->tf_r9;
2280         mcp->mc_r8  = tp->tf_r8;
2281         mcp->mc_rdi = tp->tf_rdi;
2282         mcp->mc_rsi = tp->tf_rsi;
2283         mcp->mc_rbp = tp->tf_rbp;
2284         mcp->mc_rbx = tp->tf_rbx;
2285         mcp->mc_rcx = tp->tf_rcx;
2286         mcp->mc_rflags = tp->tf_rflags;
2287         if (flags & GET_MC_CLEAR_RET) {
2288                 mcp->mc_rax = 0;
2289                 mcp->mc_rdx = 0;
2290                 mcp->mc_rflags &= ~PSL_C;
2291         } else {
2292                 mcp->mc_rax = tp->tf_rax;
2293                 mcp->mc_rdx = tp->tf_rdx;
2294         }
2295         mcp->mc_rip = tp->tf_rip;
2296         mcp->mc_cs = tp->tf_cs;
2297         mcp->mc_rsp = tp->tf_rsp;
2298         mcp->mc_ss = tp->tf_ss;
2299         mcp->mc_ds = tp->tf_ds;
2300         mcp->mc_es = tp->tf_es;
2301         mcp->mc_fs = tp->tf_fs;
2302         mcp->mc_gs = tp->tf_gs;
2303         mcp->mc_flags = tp->tf_flags;
2304         mcp->mc_len = sizeof(*mcp);
2305         get_fpcontext(td, mcp, NULL, 0);
2306         update_pcb_bases(pcb);
2307         mcp->mc_fsbase = pcb->pcb_fsbase;
2308         mcp->mc_gsbase = pcb->pcb_gsbase;
2309         mcp->mc_xfpustate = 0;
2310         mcp->mc_xfpustate_len = 0;
2311         bzero(mcp->mc_spare, sizeof(mcp->mc_spare));
2312         return (0);
2313 }
2314
2315 /*
2316  * Set machine context.
2317  *
2318  * However, we don't set any but the user modifiable flags, and we won't
2319  * touch the cs selector.
2320  */
2321 int
2322 set_mcontext(struct thread *td, mcontext_t *mcp)
2323 {
2324         struct pcb *pcb;
2325         struct trapframe *tp;
2326         char *xfpustate;
2327         long rflags;
2328         int ret;
2329
2330         pcb = td->td_pcb;
2331         tp = td->td_frame;
2332         if (mcp->mc_len != sizeof(*mcp) ||
2333             (mcp->mc_flags & ~_MC_FLAG_MASK) != 0)
2334                 return (EINVAL);
2335         rflags = (mcp->mc_rflags & PSL_USERCHANGE) |
2336             (tp->tf_rflags & ~PSL_USERCHANGE);
2337         if (mcp->mc_flags & _MC_HASFPXSTATE) {
2338                 if (mcp->mc_xfpustate_len > cpu_max_ext_state_size -
2339                     sizeof(struct savefpu))
2340                         return (EINVAL);
2341                 xfpustate = __builtin_alloca(mcp->mc_xfpustate_len);
2342                 ret = copyin((void *)mcp->mc_xfpustate, xfpustate,
2343                     mcp->mc_xfpustate_len);
2344                 if (ret != 0)
2345                         return (ret);
2346         } else
2347                 xfpustate = NULL;
2348         ret = set_fpcontext(td, mcp, xfpustate, mcp->mc_xfpustate_len);
2349         if (ret != 0)
2350                 return (ret);
2351         tp->tf_r15 = mcp->mc_r15;
2352         tp->tf_r14 = mcp->mc_r14;
2353         tp->tf_r13 = mcp->mc_r13;
2354         tp->tf_r12 = mcp->mc_r12;
2355         tp->tf_r11 = mcp->mc_r11;
2356         tp->tf_r10 = mcp->mc_r10;
2357         tp->tf_r9  = mcp->mc_r9;
2358         tp->tf_r8  = mcp->mc_r8;
2359         tp->tf_rdi = mcp->mc_rdi;
2360         tp->tf_rsi = mcp->mc_rsi;
2361         tp->tf_rbp = mcp->mc_rbp;
2362         tp->tf_rbx = mcp->mc_rbx;
2363         tp->tf_rdx = mcp->mc_rdx;
2364         tp->tf_rcx = mcp->mc_rcx;
2365         tp->tf_rax = mcp->mc_rax;
2366         tp->tf_rip = mcp->mc_rip;
2367         tp->tf_rflags = rflags;
2368         tp->tf_rsp = mcp->mc_rsp;
2369         tp->tf_ss = mcp->mc_ss;
2370         tp->tf_flags = mcp->mc_flags;
2371         if (tp->tf_flags & TF_HASSEGS) {
2372                 tp->tf_ds = mcp->mc_ds;
2373                 tp->tf_es = mcp->mc_es;
2374                 tp->tf_fs = mcp->mc_fs;
2375                 tp->tf_gs = mcp->mc_gs;
2376         }
2377         set_pcb_flags(pcb, PCB_FULL_IRET);
2378         if (mcp->mc_flags & _MC_HASBASES) {
2379                 pcb->pcb_fsbase = mcp->mc_fsbase;
2380                 pcb->pcb_gsbase = mcp->mc_gsbase;
2381         }
2382         return (0);
2383 }
2384
2385 static void
2386 get_fpcontext(struct thread *td, mcontext_t *mcp, char *xfpusave,
2387     size_t xfpusave_len)
2388 {
2389         size_t max_len, len;
2390
2391         mcp->mc_ownedfp = fpugetregs(td);
2392         bcopy(get_pcb_user_save_td(td), &mcp->mc_fpstate[0],
2393             sizeof(mcp->mc_fpstate));
2394         mcp->mc_fpformat = fpuformat();
2395         if (!use_xsave || xfpusave_len == 0)
2396                 return;
2397         max_len = cpu_max_ext_state_size - sizeof(struct savefpu);
2398         len = xfpusave_len;
2399         if (len > max_len) {
2400                 len = max_len;
2401                 bzero(xfpusave + max_len, len - max_len);
2402         }
2403         mcp->mc_flags |= _MC_HASFPXSTATE;
2404         mcp->mc_xfpustate_len = len;
2405         bcopy(get_pcb_user_save_td(td) + 1, xfpusave, len);
2406 }
2407
2408 static int
2409 set_fpcontext(struct thread *td, mcontext_t *mcp, char *xfpustate,
2410     size_t xfpustate_len)
2411 {
2412         int error;
2413
2414         if (mcp->mc_fpformat == _MC_FPFMT_NODEV)
2415                 return (0);
2416         else if (mcp->mc_fpformat != _MC_FPFMT_XMM)
2417                 return (EINVAL);
2418         else if (mcp->mc_ownedfp == _MC_FPOWNED_NONE) {
2419                 /* We don't care what state is left in the FPU or PCB. */
2420                 fpstate_drop(td);
2421                 error = 0;
2422         } else if (mcp->mc_ownedfp == _MC_FPOWNED_FPU ||
2423             mcp->mc_ownedfp == _MC_FPOWNED_PCB) {
2424                 error = fpusetregs(td, (struct savefpu *)&mcp->mc_fpstate,
2425                     xfpustate, xfpustate_len);
2426         } else
2427                 return (EINVAL);
2428         return (error);
2429 }
2430
2431 void
2432 fpstate_drop(struct thread *td)
2433 {
2434
2435         KASSERT(PCB_USER_FPU(td->td_pcb), ("fpstate_drop: kernel-owned fpu"));
2436         critical_enter();
2437         if (PCPU_GET(fpcurthread) == td)
2438                 fpudrop();
2439         /*
2440          * XXX force a full drop of the fpu.  The above only drops it if we
2441          * owned it.
2442          *
2443          * XXX I don't much like fpugetuserregs()'s semantics of doing a full
2444          * drop.  Dropping only to the pcb matches fnsave's behaviour.
2445          * We only need to drop to !PCB_INITDONE in sendsig().  But
2446          * sendsig() is the only caller of fpugetuserregs()... perhaps we just
2447          * have too many layers.
2448          */
2449         clear_pcb_flags(curthread->td_pcb,
2450             PCB_FPUINITDONE | PCB_USERFPUINITDONE);
2451         critical_exit();
2452 }
2453
2454 int
2455 fill_dbregs(struct thread *td, struct dbreg *dbregs)
2456 {
2457         struct pcb *pcb;
2458
2459         if (td == NULL) {
2460                 dbregs->dr[0] = rdr0();
2461                 dbregs->dr[1] = rdr1();
2462                 dbregs->dr[2] = rdr2();
2463                 dbregs->dr[3] = rdr3();
2464                 dbregs->dr[6] = rdr6();
2465                 dbregs->dr[7] = rdr7();
2466         } else {
2467                 pcb = td->td_pcb;
2468                 dbregs->dr[0] = pcb->pcb_dr0;
2469                 dbregs->dr[1] = pcb->pcb_dr1;
2470                 dbregs->dr[2] = pcb->pcb_dr2;
2471                 dbregs->dr[3] = pcb->pcb_dr3;
2472                 dbregs->dr[6] = pcb->pcb_dr6;
2473                 dbregs->dr[7] = pcb->pcb_dr7;
2474         }
2475         dbregs->dr[4] = 0;
2476         dbregs->dr[5] = 0;
2477         dbregs->dr[8] = 0;
2478         dbregs->dr[9] = 0;
2479         dbregs->dr[10] = 0;
2480         dbregs->dr[11] = 0;
2481         dbregs->dr[12] = 0;
2482         dbregs->dr[13] = 0;
2483         dbregs->dr[14] = 0;
2484         dbregs->dr[15] = 0;
2485         return (0);
2486 }
2487
2488 int
2489 set_dbregs(struct thread *td, struct dbreg *dbregs)
2490 {
2491         struct pcb *pcb;
2492         int i;
2493
2494         if (td == NULL) {
2495                 load_dr0(dbregs->dr[0]);
2496                 load_dr1(dbregs->dr[1]);
2497                 load_dr2(dbregs->dr[2]);
2498                 load_dr3(dbregs->dr[3]);
2499                 load_dr6(dbregs->dr[6]);
2500                 load_dr7(dbregs->dr[7]);
2501         } else {
2502                 /*
2503                  * Don't let an illegal value for dr7 get set.  Specifically,
2504                  * check for undefined settings.  Setting these bit patterns
2505                  * result in undefined behaviour and can lead to an unexpected
2506                  * TRCTRAP or a general protection fault right here.
2507                  * Upper bits of dr6 and dr7 must not be set
2508                  */
2509                 for (i = 0; i < 4; i++) {
2510                         if (DBREG_DR7_ACCESS(dbregs->dr[7], i) == 0x02)
2511                                 return (EINVAL);
2512                         if (td->td_frame->tf_cs == _ucode32sel &&
2513                             DBREG_DR7_LEN(dbregs->dr[7], i) == DBREG_DR7_LEN_8)
2514                                 return (EINVAL);
2515                 }
2516                 if ((dbregs->dr[6] & 0xffffffff00000000ul) != 0 ||
2517                     (dbregs->dr[7] & 0xffffffff00000000ul) != 0)
2518                         return (EINVAL);
2519
2520                 pcb = td->td_pcb;
2521
2522                 /*
2523                  * Don't let a process set a breakpoint that is not within the
2524                  * process's address space.  If a process could do this, it
2525                  * could halt the system by setting a breakpoint in the kernel
2526                  * (if ddb was enabled).  Thus, we need to check to make sure
2527                  * that no breakpoints are being enabled for addresses outside
2528                  * process's address space.
2529                  *
2530                  * XXX - what about when the watched area of the user's
2531                  * address space is written into from within the kernel
2532                  * ... wouldn't that still cause a breakpoint to be generated
2533                  * from within kernel mode?
2534                  */
2535
2536                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 0)) {
2537                         /* dr0 is enabled */
2538                         if (dbregs->dr[0] >= VM_MAXUSER_ADDRESS)
2539                                 return (EINVAL);
2540                 }
2541                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 1)) {
2542                         /* dr1 is enabled */
2543                         if (dbregs->dr[1] >= VM_MAXUSER_ADDRESS)
2544                                 return (EINVAL);
2545                 }
2546                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 2)) {
2547                         /* dr2 is enabled */
2548                         if (dbregs->dr[2] >= VM_MAXUSER_ADDRESS)
2549                                 return (EINVAL);
2550                 }
2551                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 3)) {
2552                         /* dr3 is enabled */
2553                         if (dbregs->dr[3] >= VM_MAXUSER_ADDRESS)
2554                                 return (EINVAL);
2555                 }
2556
2557                 pcb->pcb_dr0 = dbregs->dr[0];
2558                 pcb->pcb_dr1 = dbregs->dr[1];
2559                 pcb->pcb_dr2 = dbregs->dr[2];
2560                 pcb->pcb_dr3 = dbregs->dr[3];
2561                 pcb->pcb_dr6 = dbregs->dr[6];
2562                 pcb->pcb_dr7 = dbregs->dr[7];
2563
2564                 set_pcb_flags(pcb, PCB_DBREGS);
2565         }
2566
2567         return (0);
2568 }
2569
2570 void
2571 reset_dbregs(void)
2572 {
2573
2574         load_dr7(0);    /* Turn off the control bits first */
2575         load_dr0(0);
2576         load_dr1(0);
2577         load_dr2(0);
2578         load_dr3(0);
2579         load_dr6(0);
2580 }
2581
2582 /*
2583  * Return > 0 if a hardware breakpoint has been hit, and the
2584  * breakpoint was in user space.  Return 0, otherwise.
2585  */
2586 int
2587 user_dbreg_trap(register_t dr6)
2588 {
2589         u_int64_t dr7;
2590         u_int64_t bp;       /* breakpoint bits extracted from dr6 */
2591         int nbp;            /* number of breakpoints that triggered */
2592         caddr_t addr[4];    /* breakpoint addresses */
2593         int i;
2594
2595         bp = dr6 & DBREG_DR6_BMASK;
2596         if (bp == 0) {
2597                 /*
2598                  * None of the breakpoint bits are set meaning this
2599                  * trap was not caused by any of the debug registers
2600                  */
2601                 return 0;
2602         }
2603
2604         dr7 = rdr7();
2605         if ((dr7 & 0x000000ff) == 0) {
2606                 /*
2607                  * all GE and LE bits in the dr7 register are zero,
2608                  * thus the trap couldn't have been caused by the
2609                  * hardware debug registers
2610                  */
2611                 return 0;
2612         }
2613
2614         nbp = 0;
2615
2616         /*
2617          * at least one of the breakpoints were hit, check to see
2618          * which ones and if any of them are user space addresses
2619          */
2620
2621         if (bp & 0x01) {
2622                 addr[nbp++] = (caddr_t)rdr0();
2623         }
2624         if (bp & 0x02) {
2625                 addr[nbp++] = (caddr_t)rdr1();
2626         }
2627         if (bp & 0x04) {
2628                 addr[nbp++] = (caddr_t)rdr2();
2629         }
2630         if (bp & 0x08) {
2631                 addr[nbp++] = (caddr_t)rdr3();
2632         }
2633
2634         for (i = 0; i < nbp; i++) {
2635                 if (addr[i] < (caddr_t)VM_MAXUSER_ADDRESS) {
2636                         /*
2637                          * addr[i] is in user space
2638                          */
2639                         return nbp;
2640                 }
2641         }
2642
2643         /*
2644          * None of the breakpoints are in user space.
2645          */
2646         return 0;
2647 }
2648
2649 /*
2650  * The pcb_flags is only modified by current thread, or by other threads
2651  * when current thread is stopped.  However, current thread may change it
2652  * from the interrupt context in cpu_switch(), or in the trap handler.
2653  * When we read-modify-write pcb_flags from C sources, compiler may generate
2654  * code that is not atomic regarding the interrupt handler.  If a trap or
2655  * interrupt happens and any flag is modified from the handler, it can be
2656  * clobbered with the cached value later.  Therefore, we implement setting
2657  * and clearing flags with single-instruction functions, which do not race
2658  * with possible modification of the flags from the trap or interrupt context,
2659  * because traps and interrupts are executed only on instruction boundary.
2660  */
2661 void
2662 set_pcb_flags_raw(struct pcb *pcb, const u_int flags)
2663 {
2664
2665         __asm __volatile("orl %1,%0"
2666             : "=m" (pcb->pcb_flags) : "ir" (flags), "m" (pcb->pcb_flags)
2667             : "cc", "memory");
2668
2669 }
2670
2671 /*
2672  * The support for RDFSBASE, WRFSBASE and similar instructions for %gs
2673  * base requires that kernel saves MSR_FSBASE and MSR_{K,}GSBASE into
2674  * pcb if user space modified the bases.  We must save on the context
2675  * switch or if the return to usermode happens through the doreti.
2676  *
2677  * Tracking of both events is performed by the pcb flag PCB_FULL_IRET,
2678  * which have a consequence that the base MSRs must be saved each time
2679  * the PCB_FULL_IRET flag is set.  We disable interrupts to sync with
2680  * context switches.
2681  */
2682 static void
2683 set_pcb_flags_fsgsbase(struct pcb *pcb, const u_int flags)
2684 {
2685         register_t r;
2686
2687         if (curpcb == pcb &&
2688             (flags & PCB_FULL_IRET) != 0 &&
2689             (pcb->pcb_flags & PCB_FULL_IRET) == 0) {
2690                 r = intr_disable();
2691                 if ((pcb->pcb_flags & PCB_FULL_IRET) == 0) {
2692                         if (rfs() == _ufssel)
2693                                 pcb->pcb_fsbase = rdfsbase();
2694                         if (rgs() == _ugssel)
2695                                 pcb->pcb_gsbase = rdmsr(MSR_KGSBASE);
2696                 }
2697                 set_pcb_flags_raw(pcb, flags);
2698                 intr_restore(r);
2699         } else {
2700                 set_pcb_flags_raw(pcb, flags);
2701         }
2702 }
2703
2704 DEFINE_IFUNC(, void, set_pcb_flags, (struct pcb *, const u_int))
2705 {
2706
2707         return ((cpu_stdext_feature & CPUID_STDEXT_FSGSBASE) != 0 ?
2708             set_pcb_flags_fsgsbase : set_pcb_flags_raw);
2709 }
2710
2711 void
2712 clear_pcb_flags(struct pcb *pcb, const u_int flags)
2713 {
2714
2715         __asm __volatile("andl %1,%0"
2716             : "=m" (pcb->pcb_flags) : "ir" (~flags), "m" (pcb->pcb_flags)
2717             : "cc", "memory");
2718 }
2719
2720 #ifdef KDB
2721
2722 /*
2723  * Provide inb() and outb() as functions.  They are normally only available as
2724  * inline functions, thus cannot be called from the debugger.
2725  */
2726
2727 /* silence compiler warnings */
2728 u_char inb_(u_short);
2729 void outb_(u_short, u_char);
2730
2731 u_char
2732 inb_(u_short port)
2733 {
2734         return inb(port);
2735 }
2736
2737 void
2738 outb_(u_short port, u_char data)
2739 {
2740         outb(port, data);
2741 }
2742
2743 #endif /* KDB */
2744
2745 #undef memset
2746 #undef memmove
2747 #undef memcpy
2748
2749 void    *memset_std(void *buf, int c, size_t len);
2750 void    *memset_erms(void *buf, int c, size_t len);
2751 void    *memmove_std(void * _Nonnull dst, const void * _Nonnull src,
2752             size_t len);
2753 void    *memmove_erms(void * _Nonnull dst, const void * _Nonnull src,
2754             size_t len);
2755 void    *memcpy_std(void * _Nonnull dst, const void * _Nonnull src,
2756             size_t len);
2757 void    *memcpy_erms(void * _Nonnull dst, const void * _Nonnull src,
2758             size_t len);
2759
2760 #ifdef KCSAN
2761 /*
2762  * These fail to build as ifuncs when used with KCSAN.
2763  */
2764 void *
2765 memset(void *buf, int c, size_t len)
2766 {
2767
2768         return (memset_std(buf, c, len));
2769 }
2770
2771 void *
2772 memmove(void * _Nonnull dst, const void * _Nonnull src, size_t len)
2773 {
2774
2775         return (memmove_std(dst, src, len));
2776 }
2777
2778 void *
2779 memcpy(void * _Nonnull dst, const void * _Nonnull src, size_t len)
2780 {
2781
2782         return (memcpy_std(dst, src, len));
2783 }
2784 #else
2785 DEFINE_IFUNC(, void *, memset, (void *, int, size_t))
2786 {
2787
2788         return ((cpu_stdext_feature & CPUID_STDEXT_ERMS) != 0 ?
2789             memset_erms : memset_std);
2790 }
2791
2792 DEFINE_IFUNC(, void *, memmove, (void * _Nonnull, const void * _Nonnull,
2793     size_t))
2794 {
2795
2796         return ((cpu_stdext_feature & CPUID_STDEXT_ERMS) != 0 ?
2797             memmove_erms : memmove_std);
2798 }
2799
2800 DEFINE_IFUNC(, void *, memcpy, (void * _Nonnull, const void * _Nonnull,size_t))
2801 {
2802
2803         return ((cpu_stdext_feature & CPUID_STDEXT_ERMS) != 0 ?
2804             memcpy_erms : memcpy_std);
2805 }
2806 #endif
2807
2808 void    pagezero_std(void *addr);
2809 void    pagezero_erms(void *addr);
2810 DEFINE_IFUNC(, void , pagezero, (void *))
2811 {
2812
2813         return ((cpu_stdext_feature & CPUID_STDEXT_ERMS) != 0 ?
2814             pagezero_erms : pagezero_std);
2815 }