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