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