sys/amd64/amd64/machdep.c

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