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