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