sys/amd64/amd64/machdep.c

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