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