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