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