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         TSRAW(&thread0, TS_ENTER, __func__, NULL);
1529
1530         /*
1531          * This may be done better later if it gets more high level
1532          * components in it. If so just link td->td_proc here.
1533          */
1534         proc_linkup0(&proc0, &thread0);
1535
1536         kmdp = init_ops.parse_preload_data(modulep);
1537
1538         identify_cpu();
1539         identify_hypervisor();
1540
1541         /* Init basic tunables, hz etc */
1542         init_param1();
1543
1544         thread0.td_kstack = physfree + KERNBASE;
1545         thread0.td_kstack_pages = kstack_pages;
1546         kstack0_sz = thread0.td_kstack_pages * PAGE_SIZE;
1547         bzero((void *)thread0.td_kstack, kstack0_sz);
1548         physfree += kstack0_sz;
1549
1550         /*
1551          * make gdt memory segments
1552          */
1553         for (x = 0; x < NGDT; x++) {
1554                 if (x != GPROC0_SEL && x != (GPROC0_SEL + 1) &&
1555                     x != GUSERLDT_SEL && x != (GUSERLDT_SEL) + 1)
1556                         ssdtosd(&gdt_segs[x], &gdt[x]);
1557         }
1558         gdt_segs[GPROC0_SEL].ssd_base = (uintptr_t)&common_tss[0];
1559         ssdtosyssd(&gdt_segs[GPROC0_SEL],
1560             (struct system_segment_descriptor *)&gdt[GPROC0_SEL]);
1561
1562         r_gdt.rd_limit = NGDT * sizeof(gdt[0]) - 1;
1563         r_gdt.rd_base =  (long) gdt;
1564         lgdt(&r_gdt);
1565         pc = &__pcpu[0];
1566
1567         wrmsr(MSR_FSBASE, 0);           /* User value */
1568         wrmsr(MSR_GSBASE, (u_int64_t)pc);
1569         wrmsr(MSR_KGSBASE, 0);          /* User value while in the kernel */
1570
1571         pcpu_init(pc, 0, sizeof(struct pcpu));
1572         dpcpu_init((void *)(physfree + KERNBASE), 0);
1573         physfree += DPCPU_SIZE;
1574         PCPU_SET(prvspace, pc);
1575         PCPU_SET(curthread, &thread0);
1576         /* Non-late cninit() and printf() can be moved up to here. */
1577         PCPU_SET(tssp, &common_tss[0]);
1578         PCPU_SET(commontssp, &common_tss[0]);
1579         PCPU_SET(tss, (struct system_segment_descriptor *)&gdt[GPROC0_SEL]);
1580         PCPU_SET(ldt, (struct system_segment_descriptor *)&gdt[GUSERLDT_SEL]);
1581         PCPU_SET(fs32p, &gdt[GUFS32_SEL]);
1582         PCPU_SET(gs32p, &gdt[GUGS32_SEL]);
1583
1584         /*
1585          * Initialize mutexes.
1586          *
1587          * icu_lock: in order to allow an interrupt to occur in a critical
1588          *           section, to set pcpu->ipending (etc...) properly, we
1589          *           must be able to get the icu lock, so it can't be
1590          *           under witness.
1591          */
1592         mutex_init();
1593         mtx_init(&icu_lock, "icu", NULL, MTX_SPIN | MTX_NOWITNESS);
1594         mtx_init(&dt_lock, "descriptor tables", NULL, MTX_DEF);
1595
1596         /* exceptions */
1597         for (x = 0; x < NIDT; x++)
1598                 setidt(x, &IDTVEC(rsvd), SDT_SYSIGT, SEL_KPL, 0);
1599         setidt(IDT_DE, &IDTVEC(div),  SDT_SYSIGT, SEL_KPL, 0);
1600         setidt(IDT_DB, &IDTVEC(dbg),  SDT_SYSIGT, SEL_KPL, 0);
1601         setidt(IDT_NMI, &IDTVEC(nmi),  SDT_SYSIGT, SEL_KPL, 2);
1602         setidt(IDT_BP, &IDTVEC(bpt),  SDT_SYSIGT, SEL_UPL, 0);
1603         setidt(IDT_OF, &IDTVEC(ofl),  SDT_SYSIGT, SEL_KPL, 0);
1604         setidt(IDT_BR, &IDTVEC(bnd),  SDT_SYSIGT, SEL_KPL, 0);
1605         setidt(IDT_UD, &IDTVEC(ill),  SDT_SYSIGT, SEL_KPL, 0);
1606         setidt(IDT_NM, &IDTVEC(dna),  SDT_SYSIGT, SEL_KPL, 0);
1607         setidt(IDT_DF, &IDTVEC(dblfault), SDT_SYSIGT, SEL_KPL, 1);
1608         setidt(IDT_FPUGP, &IDTVEC(fpusegm),  SDT_SYSIGT, SEL_KPL, 0);
1609         setidt(IDT_TS, &IDTVEC(tss),  SDT_SYSIGT, SEL_KPL, 0);
1610         setidt(IDT_NP, &IDTVEC(missing),  SDT_SYSIGT, SEL_KPL, 0);
1611         setidt(IDT_SS, &IDTVEC(stk),  SDT_SYSIGT, SEL_KPL, 0);
1612         setidt(IDT_GP, &IDTVEC(prot),  SDT_SYSIGT, SEL_KPL, 0);
1613         setidt(IDT_PF, &IDTVEC(page),  SDT_SYSIGT, SEL_KPL, 0);
1614         setidt(IDT_MF, &IDTVEC(fpu),  SDT_SYSIGT, SEL_KPL, 0);
1615         setidt(IDT_AC, &IDTVEC(align), SDT_SYSIGT, SEL_KPL, 0);
1616         setidt(IDT_MC, &IDTVEC(mchk),  SDT_SYSIGT, SEL_KPL, 0);
1617         setidt(IDT_XF, &IDTVEC(xmm), SDT_SYSIGT, SEL_KPL, 0);
1618 #ifdef KDTRACE_HOOKS
1619         setidt(IDT_DTRACE_RET, &IDTVEC(dtrace_ret), SDT_SYSIGT, SEL_UPL, 0);
1620 #endif
1621 #ifdef XENHVM
1622         setidt(IDT_EVTCHN, &IDTVEC(xen_intr_upcall), SDT_SYSIGT, SEL_UPL, 0);
1623 #endif
1624
1625         r_idt.rd_limit = sizeof(idt0) - 1;
1626         r_idt.rd_base = (long) idt;
1627         lidt(&r_idt);
1628
1629         /*
1630          * Initialize the clock before the console so that console
1631          * initialization can use DELAY().
1632          */
1633         clock_init();
1634
1635         /*
1636          * Use vt(4) by default for UEFI boot (during the sc(4)/vt(4)
1637          * transition).
1638          * Once bootblocks have updated, we can test directly for
1639          * efi_systbl != NULL here...
1640          */
1641         if (preload_search_info(kmdp, MODINFO_METADATA | MODINFOMD_EFI_MAP)
1642             != NULL)
1643                 vty_set_preferred(VTY_VT);
1644
1645         finishidentcpu();       /* Final stage of CPU initialization */
1646         initializecpu();        /* Initialize CPU registers */
1647         initializecpucache();
1648
1649         /* doublefault stack space, runs on ist1 */
1650         common_tss[0].tss_ist1 = (long)&dblfault_stack[sizeof(dblfault_stack)];
1651
1652         /*
1653          * NMI stack, runs on ist2.  The pcpu pointer is stored just
1654          * above the start of the ist2 stack.
1655          */
1656         np = ((struct nmi_pcpu *) &nmi0_stack[sizeof(nmi0_stack)]) - 1;
1657         np->np_pcpu = (register_t) pc;
1658         common_tss[0].tss_ist2 = (long) np;
1659
1660         /* Set the IO permission bitmap (empty due to tss seg limit) */
1661         common_tss[0].tss_iobase = sizeof(struct amd64tss) + IOPERM_BITMAP_SIZE;
1662
1663         gsel_tss = GSEL(GPROC0_SEL, SEL_KPL);
1664         ltr(gsel_tss);
1665
1666         /* Set up the fast syscall stuff */
1667         msr = rdmsr(MSR_EFER) | EFER_SCE;
1668         wrmsr(MSR_EFER, msr);
1669         wrmsr(MSR_LSTAR, (u_int64_t)IDTVEC(fast_syscall));
1670         wrmsr(MSR_CSTAR, (u_int64_t)IDTVEC(fast_syscall32));
1671         msr = ((u_int64_t)GSEL(GCODE_SEL, SEL_KPL) << 32) |
1672               ((u_int64_t)GSEL(GUCODE32_SEL, SEL_UPL) << 48);
1673         wrmsr(MSR_STAR, msr);
1674         wrmsr(MSR_SF_MASK, PSL_NT|PSL_T|PSL_I|PSL_C|PSL_D);
1675
1676         /*
1677          * Temporary forge some valid pointer to PCB, for exception
1678          * handlers.  It is reinitialized properly below after FPU is
1679          * set up.  Also set up td_critnest to short-cut the page
1680          * fault handler.
1681          */
1682         cpu_max_ext_state_size = sizeof(struct savefpu);
1683         thread0.td_pcb = get_pcb_td(&thread0);
1684         thread0.td_critnest = 1;
1685
1686         /*
1687          * The console and kdb should be initialized even earlier than here,
1688          * but some console drivers don't work until after getmemsize().
1689          * Default to late console initialization to support these drivers.
1690          * This loses mainly printf()s in getmemsize() and early debugging.
1691          */
1692         late_console = 1;
1693         TUNABLE_INT_FETCH("debug.late_console", &late_console);
1694         if (!late_console) {
1695                 cninit();
1696                 amd64_kdb_init();
1697         }
1698
1699         getmemsize(kmdp, physfree);
1700         init_param2(physmem);
1701
1702         /* now running on new page tables, configured,and u/iom is accessible */
1703
1704         if (late_console)
1705                 cninit();
1706
1707 #ifdef DEV_ISA
1708 #ifdef DEV_ATPIC
1709         elcr_probe();
1710         atpic_startup();
1711 #else
1712         /* Reset and mask the atpics and leave them shut down. */
1713         atpic_reset();
1714
1715         /*
1716          * Point the ICU spurious interrupt vectors at the APIC spurious
1717          * interrupt handler.
1718          */
1719         setidt(IDT_IO_INTS + 7, IDTVEC(spuriousint), SDT_SYSIGT, SEL_KPL, 0);
1720         setidt(IDT_IO_INTS + 15, IDTVEC(spuriousint), SDT_SYSIGT, SEL_KPL, 0);
1721 #endif
1722 #else
1723 #error "have you forgotten the isa device?";
1724 #endif
1725
1726         if (late_console)
1727                 amd64_kdb_init();
1728
1729         msgbufinit(msgbufp, msgbufsize);
1730         fpuinit();
1731
1732         /*
1733          * Set up thread0 pcb after fpuinit calculated pcb + fpu save
1734          * area size.  Zero out the extended state header in fpu save
1735          * area.
1736          */
1737         thread0.td_pcb = get_pcb_td(&thread0);
1738         thread0.td_pcb->pcb_save = get_pcb_user_save_td(&thread0);
1739         bzero(get_pcb_user_save_td(&thread0), cpu_max_ext_state_size);
1740         if (use_xsave) {
1741                 xhdr = (struct xstate_hdr *)(get_pcb_user_save_td(&thread0) +
1742                     1);
1743                 xhdr->xstate_bv = xsave_mask;
1744         }
1745         /* make an initial tss so cpu can get interrupt stack on syscall! */
1746         common_tss[0].tss_rsp0 = (vm_offset_t)thread0.td_pcb;
1747         /* Ensure the stack is aligned to 16 bytes */
1748         common_tss[0].tss_rsp0 &= ~0xFul;
1749         PCPU_SET(rsp0, common_tss[0].tss_rsp0);
1750         PCPU_SET(curpcb, thread0.td_pcb);
1751
1752         /* transfer to user mode */
1753
1754         _ucodesel = GSEL(GUCODE_SEL, SEL_UPL);
1755         _udatasel = GSEL(GUDATA_SEL, SEL_UPL);
1756         _ucode32sel = GSEL(GUCODE32_SEL, SEL_UPL);
1757         _ufssel = GSEL(GUFS32_SEL, SEL_UPL);
1758         _ugssel = GSEL(GUGS32_SEL, SEL_UPL);
1759
1760         load_ds(_udatasel);
1761         load_es(_udatasel);
1762         load_fs(_ufssel);
1763
1764         /* setup proc 0's pcb */
1765         thread0.td_pcb->pcb_flags = 0;
1766         thread0.td_frame = &proc0_tf;
1767
1768         env = kern_getenv("kernelname");
1769         if (env != NULL)
1770                 strlcpy(kernelname, env, sizeof(kernelname));
1771
1772         cpu_probe_amdc1e();
1773
1774 #ifdef FDT
1775         x86_init_fdt();
1776 #endif
1777         thread0.td_critnest = 0;
1778
1779         TSEXIT();
1780
1781         /* Location of kernel stack for locore */
1782         return ((u_int64_t)thread0.td_pcb);
1783 }
1784
1785 void
1786 cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t size)
1787 {
1788
1789         pcpu->pc_acpi_id = 0xffffffff;
1790 }
1791
1792 static int
1793 smap_sysctl_handler(SYSCTL_HANDLER_ARGS)
1794 {
1795         struct bios_smap *smapbase;
1796         struct bios_smap_xattr smap;
1797         caddr_t kmdp;
1798         uint32_t *smapattr;
1799         int count, error, i;
1800
1801         /* Retrieve the system memory map from the loader. */
1802         kmdp = preload_search_by_type("elf kernel");
1803         if (kmdp == NULL)
1804                 kmdp = preload_search_by_type("elf64 kernel");
1805         smapbase = (struct bios_smap *)preload_search_info(kmdp,
1806             MODINFO_METADATA | MODINFOMD_SMAP);
1807         if (smapbase == NULL)
1808                 return (0);
1809         smapattr = (uint32_t *)preload_search_info(kmdp,
1810             MODINFO_METADATA | MODINFOMD_SMAP_XATTR);
1811         count = *((uint32_t *)smapbase - 1) / sizeof(*smapbase);
1812         error = 0;
1813         for (i = 0; i < count; i++) {
1814                 smap.base = smapbase[i].base;
1815                 smap.length = smapbase[i].length;
1816                 smap.type = smapbase[i].type;
1817                 if (smapattr != NULL)
1818                         smap.xattr = smapattr[i];
1819                 else
1820                         smap.xattr = 0;
1821                 error = SYSCTL_OUT(req, &smap, sizeof(smap));
1822         }
1823         return (error);
1824 }
1825 SYSCTL_PROC(_machdep, OID_AUTO, smap, CTLTYPE_OPAQUE|CTLFLAG_RD, NULL, 0,
1826     smap_sysctl_handler, "S,bios_smap_xattr", "Raw BIOS SMAP data");
1827
1828 static int
1829 efi_map_sysctl_handler(SYSCTL_HANDLER_ARGS)
1830 {
1831         struct efi_map_header *efihdr;
1832         caddr_t kmdp;
1833         uint32_t efisize;
1834
1835         kmdp = preload_search_by_type("elf kernel");
1836         if (kmdp == NULL)
1837                 kmdp = preload_search_by_type("elf64 kernel");
1838         efihdr = (struct efi_map_header *)preload_search_info(kmdp,
1839             MODINFO_METADATA | MODINFOMD_EFI_MAP);
1840         if (efihdr == NULL)
1841                 return (0);
1842         efisize = *((uint32_t *)efihdr - 1);
1843         return (SYSCTL_OUT(req, efihdr, efisize));
1844 }
1845 SYSCTL_PROC(_machdep, OID_AUTO, efi_map, CTLTYPE_OPAQUE|CTLFLAG_RD, NULL, 0,
1846     efi_map_sysctl_handler, "S,efi_map_header", "Raw EFI Memory Map");
1847
1848 void
1849 spinlock_enter(void)
1850 {
1851         struct thread *td;
1852         register_t flags;
1853
1854         td = curthread;
1855         if (td->td_md.md_spinlock_count == 0) {
1856                 flags = intr_disable();
1857                 td->td_md.md_spinlock_count = 1;
1858                 td->td_md.md_saved_flags = flags;
1859                 critical_enter();
1860         } else
1861                 td->td_md.md_spinlock_count++;
1862 }
1863
1864 void
1865 spinlock_exit(void)
1866 {
1867         struct thread *td;
1868         register_t flags;
1869
1870         td = curthread;
1871         flags = td->td_md.md_saved_flags;
1872         td->td_md.md_spinlock_count--;
1873         if (td->td_md.md_spinlock_count == 0) {
1874                 critical_exit();
1875                 intr_restore(flags);
1876         }
1877 }
1878
1879 /*
1880  * Construct a PCB from a trapframe. This is called from kdb_trap() where
1881  * we want to start a backtrace from the function that caused us to enter
1882  * the debugger. We have the context in the trapframe, but base the trace
1883  * on the PCB. The PCB doesn't have to be perfect, as long as it contains
1884  * enough for a backtrace.
1885  */
1886 void
1887 makectx(struct trapframe *tf, struct pcb *pcb)
1888 {
1889
1890         pcb->pcb_r12 = tf->tf_r12;
1891         pcb->pcb_r13 = tf->tf_r13;
1892         pcb->pcb_r14 = tf->tf_r14;
1893         pcb->pcb_r15 = tf->tf_r15;
1894         pcb->pcb_rbp = tf->tf_rbp;
1895         pcb->pcb_rbx = tf->tf_rbx;
1896         pcb->pcb_rip = tf->tf_rip;
1897         pcb->pcb_rsp = tf->tf_rsp;
1898 }
1899
1900 int
1901 ptrace_set_pc(struct thread *td, unsigned long addr)
1902 {
1903
1904         td->td_frame->tf_rip = addr;
1905         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
1906         return (0);
1907 }
1908
1909 int
1910 ptrace_single_step(struct thread *td)
1911 {
1912         td->td_frame->tf_rflags |= PSL_T;
1913         return (0);
1914 }
1915
1916 int
1917 ptrace_clear_single_step(struct thread *td)
1918 {
1919         td->td_frame->tf_rflags &= ~PSL_T;
1920         return (0);
1921 }
1922
1923 int
1924 fill_regs(struct thread *td, struct reg *regs)
1925 {
1926         struct trapframe *tp;
1927
1928         tp = td->td_frame;
1929         return (fill_frame_regs(tp, regs));
1930 }
1931
1932 int
1933 fill_frame_regs(struct trapframe *tp, struct reg *regs)
1934 {
1935         regs->r_r15 = tp->tf_r15;
1936         regs->r_r14 = tp->tf_r14;
1937         regs->r_r13 = tp->tf_r13;
1938         regs->r_r12 = tp->tf_r12;
1939         regs->r_r11 = tp->tf_r11;
1940         regs->r_r10 = tp->tf_r10;
1941         regs->r_r9  = tp->tf_r9;
1942         regs->r_r8  = tp->tf_r8;
1943         regs->r_rdi = tp->tf_rdi;
1944         regs->r_rsi = tp->tf_rsi;
1945         regs->r_rbp = tp->tf_rbp;
1946         regs->r_rbx = tp->tf_rbx;
1947         regs->r_rdx = tp->tf_rdx;
1948         regs->r_rcx = tp->tf_rcx;
1949         regs->r_rax = tp->tf_rax;
1950         regs->r_rip = tp->tf_rip;
1951         regs->r_cs = tp->tf_cs;
1952         regs->r_rflags = tp->tf_rflags;
1953         regs->r_rsp = tp->tf_rsp;
1954         regs->r_ss = tp->tf_ss;
1955         if (tp->tf_flags & TF_HASSEGS) {
1956                 regs->r_ds = tp->tf_ds;
1957                 regs->r_es = tp->tf_es;
1958                 regs->r_fs = tp->tf_fs;
1959                 regs->r_gs = tp->tf_gs;
1960         } else {
1961                 regs->r_ds = 0;
1962                 regs->r_es = 0;
1963                 regs->r_fs = 0;
1964                 regs->r_gs = 0;
1965         }
1966         return (0);
1967 }
1968
1969 int
1970 set_regs(struct thread *td, struct reg *regs)
1971 {
1972         struct trapframe *tp;
1973         register_t rflags;
1974
1975         tp = td->td_frame;
1976         rflags = regs->r_rflags & 0xffffffff;
1977         if (!EFL_SECURE(rflags, tp->tf_rflags) || !CS_SECURE(regs->r_cs))
1978                 return (EINVAL);
1979         tp->tf_r15 = regs->r_r15;
1980         tp->tf_r14 = regs->r_r14;
1981         tp->tf_r13 = regs->r_r13;
1982         tp->tf_r12 = regs->r_r12;
1983         tp->tf_r11 = regs->r_r11;
1984         tp->tf_r10 = regs->r_r10;
1985         tp->tf_r9  = regs->r_r9;
1986         tp->tf_r8  = regs->r_r8;
1987         tp->tf_rdi = regs->r_rdi;
1988         tp->tf_rsi = regs->r_rsi;
1989         tp->tf_rbp = regs->r_rbp;
1990         tp->tf_rbx = regs->r_rbx;
1991         tp->tf_rdx = regs->r_rdx;
1992         tp->tf_rcx = regs->r_rcx;
1993         tp->tf_rax = regs->r_rax;
1994         tp->tf_rip = regs->r_rip;
1995         tp->tf_cs = regs->r_cs;
1996         tp->tf_rflags = rflags;
1997         tp->tf_rsp = regs->r_rsp;
1998         tp->tf_ss = regs->r_ss;
1999         if (0) {        /* XXXKIB */
2000                 tp->tf_ds = regs->r_ds;
2001                 tp->tf_es = regs->r_es;
2002                 tp->tf_fs = regs->r_fs;
2003                 tp->tf_gs = regs->r_gs;
2004                 tp->tf_flags = TF_HASSEGS;
2005         }
2006         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
2007         return (0);
2008 }
2009
2010 /* XXX check all this stuff! */
2011 /* externalize from sv_xmm */
2012 static void
2013 fill_fpregs_xmm(struct savefpu *sv_xmm, struct fpreg *fpregs)
2014 {
2015         struct envxmm *penv_fpreg = (struct envxmm *)&fpregs->fpr_env;
2016         struct envxmm *penv_xmm = &sv_xmm->sv_env;
2017         int i;
2018
2019         /* pcb -> fpregs */
2020         bzero(fpregs, sizeof(*fpregs));
2021
2022         /* FPU control/status */
2023         penv_fpreg->en_cw = penv_xmm->en_cw;
2024         penv_fpreg->en_sw = penv_xmm->en_sw;
2025         penv_fpreg->en_tw = penv_xmm->en_tw;
2026         penv_fpreg->en_opcode = penv_xmm->en_opcode;
2027         penv_fpreg->en_rip = penv_xmm->en_rip;
2028         penv_fpreg->en_rdp = penv_xmm->en_rdp;
2029         penv_fpreg->en_mxcsr = penv_xmm->en_mxcsr;
2030         penv_fpreg->en_mxcsr_mask = penv_xmm->en_mxcsr_mask;
2031
2032         /* FPU registers */
2033         for (i = 0; i < 8; ++i)
2034                 bcopy(sv_xmm->sv_fp[i].fp_acc.fp_bytes, fpregs->fpr_acc[i], 10);
2035
2036         /* SSE registers */
2037         for (i = 0; i < 16; ++i)
2038                 bcopy(sv_xmm->sv_xmm[i].xmm_bytes, fpregs->fpr_xacc[i], 16);
2039 }
2040
2041 /* internalize from fpregs into sv_xmm */
2042 static void
2043 set_fpregs_xmm(struct fpreg *fpregs, struct savefpu *sv_xmm)
2044 {
2045         struct envxmm *penv_xmm = &sv_xmm->sv_env;
2046         struct envxmm *penv_fpreg = (struct envxmm *)&fpregs->fpr_env;
2047         int i;
2048
2049         /* fpregs -> pcb */
2050         /* FPU control/status */
2051         penv_xmm->en_cw = penv_fpreg->en_cw;
2052         penv_xmm->en_sw = penv_fpreg->en_sw;
2053         penv_xmm->en_tw = penv_fpreg->en_tw;
2054         penv_xmm->en_opcode = penv_fpreg->en_opcode;
2055         penv_xmm->en_rip = penv_fpreg->en_rip;
2056         penv_xmm->en_rdp = penv_fpreg->en_rdp;
2057         penv_xmm->en_mxcsr = penv_fpreg->en_mxcsr;
2058         penv_xmm->en_mxcsr_mask = penv_fpreg->en_mxcsr_mask & cpu_mxcsr_mask;
2059
2060         /* FPU registers */
2061         for (i = 0; i < 8; ++i)
2062                 bcopy(fpregs->fpr_acc[i], sv_xmm->sv_fp[i].fp_acc.fp_bytes, 10);
2063
2064         /* SSE registers */
2065         for (i = 0; i < 16; ++i)
2066                 bcopy(fpregs->fpr_xacc[i], sv_xmm->sv_xmm[i].xmm_bytes, 16);
2067 }
2068
2069 /* externalize from td->pcb */
2070 int
2071 fill_fpregs(struct thread *td, struct fpreg *fpregs)
2072 {
2073
2074         KASSERT(td == curthread || TD_IS_SUSPENDED(td) ||
2075             P_SHOULDSTOP(td->td_proc),
2076             ("not suspended thread %p", td));
2077         fpugetregs(td);
2078         fill_fpregs_xmm(get_pcb_user_save_td(td), fpregs);
2079         return (0);
2080 }
2081
2082 /* internalize to td->pcb */
2083 int
2084 set_fpregs(struct thread *td, struct fpreg *fpregs)
2085 {
2086
2087         set_fpregs_xmm(fpregs, get_pcb_user_save_td(td));
2088         fpuuserinited(td);
2089         return (0);
2090 }
2091
2092 /*
2093  * Get machine context.
2094  */
2095 int
2096 get_mcontext(struct thread *td, mcontext_t *mcp, int flags)
2097 {
2098         struct pcb *pcb;
2099         struct trapframe *tp;
2100
2101         pcb = td->td_pcb;
2102         tp = td->td_frame;
2103         PROC_LOCK(curthread->td_proc);
2104         mcp->mc_onstack = sigonstack(tp->tf_rsp);
2105         PROC_UNLOCK(curthread->td_proc);
2106         mcp->mc_r15 = tp->tf_r15;
2107         mcp->mc_r14 = tp->tf_r14;
2108         mcp->mc_r13 = tp->tf_r13;
2109         mcp->mc_r12 = tp->tf_r12;
2110         mcp->mc_r11 = tp->tf_r11;
2111         mcp->mc_r10 = tp->tf_r10;
2112         mcp->mc_r9  = tp->tf_r9;
2113         mcp->mc_r8  = tp->tf_r8;
2114         mcp->mc_rdi = tp->tf_rdi;
2115         mcp->mc_rsi = tp->tf_rsi;
2116         mcp->mc_rbp = tp->tf_rbp;
2117         mcp->mc_rbx = tp->tf_rbx;
2118         mcp->mc_rcx = tp->tf_rcx;
2119         mcp->mc_rflags = tp->tf_rflags;
2120         if (flags & GET_MC_CLEAR_RET) {
2121                 mcp->mc_rax = 0;
2122                 mcp->mc_rdx = 0;
2123                 mcp->mc_rflags &= ~PSL_C;
2124         } else {
2125                 mcp->mc_rax = tp->tf_rax;
2126                 mcp->mc_rdx = tp->tf_rdx;
2127         }
2128         mcp->mc_rip = tp->tf_rip;
2129         mcp->mc_cs = tp->tf_cs;
2130         mcp->mc_rsp = tp->tf_rsp;
2131         mcp->mc_ss = tp->tf_ss;
2132         mcp->mc_ds = tp->tf_ds;
2133         mcp->mc_es = tp->tf_es;
2134         mcp->mc_fs = tp->tf_fs;
2135         mcp->mc_gs = tp->tf_gs;
2136         mcp->mc_flags = tp->tf_flags;
2137         mcp->mc_len = sizeof(*mcp);
2138         get_fpcontext(td, mcp, NULL, 0);
2139         update_pcb_bases(pcb);
2140         mcp->mc_fsbase = pcb->pcb_fsbase;
2141         mcp->mc_gsbase = pcb->pcb_gsbase;
2142         mcp->mc_xfpustate = 0;
2143         mcp->mc_xfpustate_len = 0;
2144         bzero(mcp->mc_spare, sizeof(mcp->mc_spare));
2145         return (0);
2146 }
2147
2148 /*
2149  * Set machine context.
2150  *
2151  * However, we don't set any but the user modifiable flags, and we won't
2152  * touch the cs selector.
2153  */
2154 int
2155 set_mcontext(struct thread *td, mcontext_t *mcp)
2156 {
2157         struct pcb *pcb;
2158         struct trapframe *tp;
2159         char *xfpustate;
2160         long rflags;
2161         int ret;
2162
2163         pcb = td->td_pcb;
2164         tp = td->td_frame;
2165         if (mcp->mc_len != sizeof(*mcp) ||
2166             (mcp->mc_flags & ~_MC_FLAG_MASK) != 0)
2167                 return (EINVAL);
2168         rflags = (mcp->mc_rflags & PSL_USERCHANGE) |
2169             (tp->tf_rflags & ~PSL_USERCHANGE);
2170         if (mcp->mc_flags & _MC_HASFPXSTATE) {
2171                 if (mcp->mc_xfpustate_len > cpu_max_ext_state_size -
2172                     sizeof(struct savefpu))
2173                         return (EINVAL);
2174                 xfpustate = __builtin_alloca(mcp->mc_xfpustate_len);
2175                 ret = copyin((void *)mcp->mc_xfpustate, xfpustate,
2176                     mcp->mc_xfpustate_len);
2177                 if (ret != 0)
2178                         return (ret);
2179         } else
2180                 xfpustate = NULL;
2181         ret = set_fpcontext(td, mcp, xfpustate, mcp->mc_xfpustate_len);
2182         if (ret != 0)
2183                 return (ret);
2184         tp->tf_r15 = mcp->mc_r15;
2185         tp->tf_r14 = mcp->mc_r14;
2186         tp->tf_r13 = mcp->mc_r13;
2187         tp->tf_r12 = mcp->mc_r12;
2188         tp->tf_r11 = mcp->mc_r11;
2189         tp->tf_r10 = mcp->mc_r10;
2190         tp->tf_r9  = mcp->mc_r9;
2191         tp->tf_r8  = mcp->mc_r8;
2192         tp->tf_rdi = mcp->mc_rdi;
2193         tp->tf_rsi = mcp->mc_rsi;
2194         tp->tf_rbp = mcp->mc_rbp;
2195         tp->tf_rbx = mcp->mc_rbx;
2196         tp->tf_rdx = mcp->mc_rdx;
2197         tp->tf_rcx = mcp->mc_rcx;
2198         tp->tf_rax = mcp->mc_rax;
2199         tp->tf_rip = mcp->mc_rip;
2200         tp->tf_rflags = rflags;
2201         tp->tf_rsp = mcp->mc_rsp;
2202         tp->tf_ss = mcp->mc_ss;
2203         tp->tf_flags = mcp->mc_flags;
2204         if (tp->tf_flags & TF_HASSEGS) {
2205                 tp->tf_ds = mcp->mc_ds;
2206                 tp->tf_es = mcp->mc_es;
2207                 tp->tf_fs = mcp->mc_fs;
2208                 tp->tf_gs = mcp->mc_gs;
2209         }
2210         set_pcb_flags(pcb, PCB_FULL_IRET);
2211         if (mcp->mc_flags & _MC_HASBASES) {
2212                 pcb->pcb_fsbase = mcp->mc_fsbase;
2213                 pcb->pcb_gsbase = mcp->mc_gsbase;
2214         }
2215         return (0);
2216 }
2217
2218 static void
2219 get_fpcontext(struct thread *td, mcontext_t *mcp, char *xfpusave,
2220     size_t xfpusave_len)
2221 {
2222         size_t max_len, len;
2223
2224         mcp->mc_ownedfp = fpugetregs(td);
2225         bcopy(get_pcb_user_save_td(td), &mcp->mc_fpstate[0],
2226             sizeof(mcp->mc_fpstate));
2227         mcp->mc_fpformat = fpuformat();
2228         if (!use_xsave || xfpusave_len == 0)
2229                 return;
2230         max_len = cpu_max_ext_state_size - sizeof(struct savefpu);
2231         len = xfpusave_len;
2232         if (len > max_len) {
2233                 len = max_len;
2234                 bzero(xfpusave + max_len, len - max_len);
2235         }
2236         mcp->mc_flags |= _MC_HASFPXSTATE;
2237         mcp->mc_xfpustate_len = len;
2238         bcopy(get_pcb_user_save_td(td) + 1, xfpusave, len);
2239 }
2240
2241 static int
2242 set_fpcontext(struct thread *td, mcontext_t *mcp, char *xfpustate,
2243     size_t xfpustate_len)
2244 {
2245         int error;
2246
2247         if (mcp->mc_fpformat == _MC_FPFMT_NODEV)
2248                 return (0);
2249         else if (mcp->mc_fpformat != _MC_FPFMT_XMM)
2250                 return (EINVAL);
2251         else if (mcp->mc_ownedfp == _MC_FPOWNED_NONE) {
2252                 /* We don't care what state is left in the FPU or PCB. */
2253                 fpstate_drop(td);
2254                 error = 0;
2255         } else if (mcp->mc_ownedfp == _MC_FPOWNED_FPU ||
2256             mcp->mc_ownedfp == _MC_FPOWNED_PCB) {
2257                 error = fpusetregs(td, (struct savefpu *)&mcp->mc_fpstate,
2258                     xfpustate, xfpustate_len);
2259         } else
2260                 return (EINVAL);
2261         return (error);
2262 }
2263
2264 void
2265 fpstate_drop(struct thread *td)
2266 {
2267
2268         KASSERT(PCB_USER_FPU(td->td_pcb), ("fpstate_drop: kernel-owned fpu"));
2269         critical_enter();
2270         if (PCPU_GET(fpcurthread) == td)
2271                 fpudrop();
2272         /*
2273          * XXX force a full drop of the fpu.  The above only drops it if we
2274          * owned it.
2275          *
2276          * XXX I don't much like fpugetuserregs()'s semantics of doing a full
2277          * drop.  Dropping only to the pcb matches fnsave's behaviour.
2278          * We only need to drop to !PCB_INITDONE in sendsig().  But
2279          * sendsig() is the only caller of fpugetuserregs()... perhaps we just
2280          * have too many layers.
2281          */
2282         clear_pcb_flags(curthread->td_pcb,
2283             PCB_FPUINITDONE | PCB_USERFPUINITDONE);
2284         critical_exit();
2285 }
2286
2287 int
2288 fill_dbregs(struct thread *td, struct dbreg *dbregs)
2289 {
2290         struct pcb *pcb;
2291
2292         if (td == NULL) {
2293                 dbregs->dr[0] = rdr0();
2294                 dbregs->dr[1] = rdr1();
2295                 dbregs->dr[2] = rdr2();
2296                 dbregs->dr[3] = rdr3();
2297                 dbregs->dr[6] = rdr6();
2298                 dbregs->dr[7] = rdr7();
2299         } else {
2300                 pcb = td->td_pcb;
2301                 dbregs->dr[0] = pcb->pcb_dr0;
2302                 dbregs->dr[1] = pcb->pcb_dr1;
2303                 dbregs->dr[2] = pcb->pcb_dr2;
2304                 dbregs->dr[3] = pcb->pcb_dr3;
2305                 dbregs->dr[6] = pcb->pcb_dr6;
2306                 dbregs->dr[7] = pcb->pcb_dr7;
2307         }
2308         dbregs->dr[4] = 0;
2309         dbregs->dr[5] = 0;
2310         dbregs->dr[8] = 0;
2311         dbregs->dr[9] = 0;
2312         dbregs->dr[10] = 0;
2313         dbregs->dr[11] = 0;
2314         dbregs->dr[12] = 0;
2315         dbregs->dr[13] = 0;
2316         dbregs->dr[14] = 0;
2317         dbregs->dr[15] = 0;
2318         return (0);
2319 }
2320
2321 int
2322 set_dbregs(struct thread *td, struct dbreg *dbregs)
2323 {
2324         struct pcb *pcb;
2325         int i;
2326
2327         if (td == NULL) {
2328                 load_dr0(dbregs->dr[0]);
2329                 load_dr1(dbregs->dr[1]);
2330                 load_dr2(dbregs->dr[2]);
2331                 load_dr3(dbregs->dr[3]);
2332                 load_dr6(dbregs->dr[6]);
2333                 load_dr7(dbregs->dr[7]);
2334         } else {
2335                 /*
2336                  * Don't let an illegal value for dr7 get set.  Specifically,
2337                  * check for undefined settings.  Setting these bit patterns
2338                  * result in undefined behaviour and can lead to an unexpected
2339                  * TRCTRAP or a general protection fault right here.
2340                  * Upper bits of dr6 and dr7 must not be set
2341                  */
2342                 for (i = 0; i < 4; i++) {
2343                         if (DBREG_DR7_ACCESS(dbregs->dr[7], i) == 0x02)
2344                                 return (EINVAL);
2345                         if (td->td_frame->tf_cs == _ucode32sel &&
2346                             DBREG_DR7_LEN(dbregs->dr[7], i) == DBREG_DR7_LEN_8)
2347                                 return (EINVAL);
2348                 }
2349                 if ((dbregs->dr[6] & 0xffffffff00000000ul) != 0 ||
2350                     (dbregs->dr[7] & 0xffffffff00000000ul) != 0)
2351                         return (EINVAL);
2352
2353                 pcb = td->td_pcb;
2354
2355                 /*
2356                  * Don't let a process set a breakpoint that is not within the
2357                  * process's address space.  If a process could do this, it
2358                  * could halt the system by setting a breakpoint in the kernel
2359                  * (if ddb was enabled).  Thus, we need to check to make sure
2360                  * that no breakpoints are being enabled for addresses outside
2361                  * process's address space.
2362                  *
2363                  * XXX - what about when the watched area of the user's
2364                  * address space is written into from within the kernel
2365                  * ... wouldn't that still cause a breakpoint to be generated
2366                  * from within kernel mode?
2367                  */
2368
2369                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 0)) {
2370                         /* dr0 is enabled */
2371                         if (dbregs->dr[0] >= VM_MAXUSER_ADDRESS)
2372                                 return (EINVAL);
2373                 }
2374                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 1)) {
2375                         /* dr1 is enabled */
2376                         if (dbregs->dr[1] >= VM_MAXUSER_ADDRESS)
2377                                 return (EINVAL);
2378                 }
2379                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 2)) {
2380                         /* dr2 is enabled */
2381                         if (dbregs->dr[2] >= VM_MAXUSER_ADDRESS)
2382                                 return (EINVAL);
2383                 }
2384                 if (DBREG_DR7_ENABLED(dbregs->dr[7], 3)) {
2385                         /* dr3 is enabled */
2386                         if (dbregs->dr[3] >= VM_MAXUSER_ADDRESS)
2387                                 return (EINVAL);
2388                 }
2389
2390                 pcb->pcb_dr0 = dbregs->dr[0];
2391                 pcb->pcb_dr1 = dbregs->dr[1];
2392                 pcb->pcb_dr2 = dbregs->dr[2];
2393                 pcb->pcb_dr3 = dbregs->dr[3];
2394                 pcb->pcb_dr6 = dbregs->dr[6];
2395                 pcb->pcb_dr7 = dbregs->dr[7];
2396
2397                 set_pcb_flags(pcb, PCB_DBREGS);
2398         }
2399
2400         return (0);
2401 }
2402
2403 void
2404 reset_dbregs(void)
2405 {
2406
2407         load_dr7(0);    /* Turn off the control bits first */
2408         load_dr0(0);
2409         load_dr1(0);
2410         load_dr2(0);
2411         load_dr3(0);
2412         load_dr6(0);
2413 }
2414
2415 /*
2416  * Return > 0 if a hardware breakpoint has been hit, and the
2417  * breakpoint was in user space.  Return 0, otherwise.
2418  */
2419 int
2420 user_dbreg_trap(void)
2421 {
2422         u_int64_t dr7, dr6; /* debug registers dr6 and dr7 */
2423         u_int64_t bp;       /* breakpoint bits extracted from dr6 */
2424         int nbp;            /* number of breakpoints that triggered */
2425         caddr_t addr[4];    /* breakpoint addresses */
2426         int i;
2427
2428         dr7 = rdr7();
2429         if ((dr7 & 0x000000ff) == 0) {
2430                 /*
2431                  * all GE and LE bits in the dr7 register are zero,
2432                  * thus the trap couldn't have been caused by the
2433                  * hardware debug registers
2434                  */
2435                 return 0;
2436         }
2437
2438         nbp = 0;
2439         dr6 = rdr6();
2440         bp = dr6 & 0x0000000f;
2441
2442         if (!bp) {
2443                 /*
2444                  * None of the breakpoint bits are set meaning this
2445                  * trap was not caused by any of the debug registers
2446                  */
2447                 return 0;
2448         }
2449
2450         /*
2451          * at least one of the breakpoints were hit, check to see
2452          * which ones and if any of them are user space addresses
2453          */
2454
2455         if (bp & 0x01) {
2456                 addr[nbp++] = (caddr_t)rdr0();
2457         }
2458         if (bp & 0x02) {
2459                 addr[nbp++] = (caddr_t)rdr1();
2460         }
2461         if (bp & 0x04) {
2462                 addr[nbp++] = (caddr_t)rdr2();
2463         }
2464         if (bp & 0x08) {
2465                 addr[nbp++] = (caddr_t)rdr3();
2466         }
2467
2468         for (i = 0; i < nbp; i++) {
2469                 if (addr[i] < (caddr_t)VM_MAXUSER_ADDRESS) {
2470                         /*
2471                          * addr[i] is in user space
2472                          */
2473                         return nbp;
2474                 }
2475         }
2476
2477         /*
2478          * None of the breakpoints are in user space.
2479          */
2480         return 0;
2481 }
2482
2483 /*
2484  * The pcb_flags is only modified by current thread, or by other threads
2485  * when current thread is stopped.  However, current thread may change it
2486  * from the interrupt context in cpu_switch(), or in the trap handler.
2487  * When we read-modify-write pcb_flags from C sources, compiler may generate
2488  * code that is not atomic regarding the interrupt handler.  If a trap or
2489  * interrupt happens and any flag is modified from the handler, it can be
2490  * clobbered with the cached value later.  Therefore, we implement setting
2491  * and clearing flags with single-instruction functions, which do not race
2492  * with possible modification of the flags from the trap or interrupt context,
2493  * because traps and interrupts are executed only on instruction boundary.
2494  */
2495 void
2496 set_pcb_flags_raw(struct pcb *pcb, const u_int flags)
2497 {
2498
2499         __asm __volatile("orl %1,%0"
2500             : "=m" (pcb->pcb_flags) : "ir" (flags), "m" (pcb->pcb_flags)
2501             : "cc", "memory");
2502
2503 }
2504
2505 /*
2506  * The support for RDFSBASE, WRFSBASE and similar instructions for %gs
2507  * base requires that kernel saves MSR_FSBASE and MSR_{K,}GSBASE into
2508  * pcb if user space modified the bases.  We must save on the context
2509  * switch or if the return to usermode happens through the doreti.
2510  *
2511  * Tracking of both events is performed by the pcb flag PCB_FULL_IRET,
2512  * which have a consequence that the base MSRs must be saved each time
2513  * the PCB_FULL_IRET flag is set.  We disable interrupts to sync with
2514  * context switches.
2515  */
2516 void
2517 set_pcb_flags(struct pcb *pcb, const u_int flags)
2518 {
2519         register_t r;
2520
2521         if (curpcb == pcb &&
2522             (flags & PCB_FULL_IRET) != 0 &&
2523             (pcb->pcb_flags & PCB_FULL_IRET) == 0 &&
2524             (cpu_stdext_feature & CPUID_STDEXT_FSGSBASE) != 0) {
2525                 r = intr_disable();
2526                 if ((pcb->pcb_flags & PCB_FULL_IRET) == 0) {
2527                         if (rfs() == _ufssel)
2528                                 pcb->pcb_fsbase = rdfsbase();
2529                         if (rgs() == _ugssel)
2530                                 pcb->pcb_gsbase = rdmsr(MSR_KGSBASE);
2531                 }
2532                 set_pcb_flags_raw(pcb, flags);
2533                 intr_restore(r);
2534         } else {
2535                 set_pcb_flags_raw(pcb, flags);
2536         }
2537 }
2538
2539 void
2540 clear_pcb_flags(struct pcb *pcb, const u_int flags)
2541 {
2542
2543         __asm __volatile("andl %1,%0"
2544             : "=m" (pcb->pcb_flags) : "ir" (~flags), "m" (pcb->pcb_flags)
2545             : "cc", "memory");
2546 }
2547
2548 #ifdef KDB
2549
2550 /*
2551  * Provide inb() and outb() as functions.  They are normally only available as
2552  * inline functions, thus cannot be called from the debugger.
2553  */
2554
2555 /* silence compiler warnings */
2556 u_char inb_(u_short);
2557 void outb_(u_short, u_char);
2558
2559 u_char
2560 inb_(u_short port)
2561 {
2562         return inb(port);
2563 }
2564
2565 void
2566 outb_(u_short port, u_char data)
2567 {
2568         outb(port, data);
2569 }
2570
2571 #endif /* KDB */