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