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