sys/amd64/amd64/machdep.c

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