sys/arm64/arm64/machdep.c

   1 /*-
   2  * Copyright (c) 2014 Andrew Turner
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 #include "opt_acpi.h"
  29 #include "opt_platform.h"
  30 #include "opt_ddb.h"
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/buf.h>
  38 #include <sys/bus.h>
  39 #include <sys/cons.h>
  40 #include <sys/cpu.h>
  41 #include <sys/devmap.h>
  42 #include <sys/efi.h>
  43 #include <sys/exec.h>
  44 #include <sys/imgact.h>
  45 #include <sys/kdb.h>
  46 #include <sys/kernel.h>
  47 #include <sys/limits.h>
  48 #include <sys/linker.h>
  49 #include <sys/msgbuf.h>
  50 #include <sys/pcpu.h>
  51 #include <sys/proc.h>
  52 #include <sys/ptrace.h>
  53 #include <sys/reboot.h>
  54 #include <sys/rwlock.h>
  55 #include <sys/sched.h>
  56 #include <sys/signalvar.h>
  57 #include <sys/syscallsubr.h>
  58 #include <sys/sysent.h>
  59 #include <sys/sysproto.h>
  60 #include <sys/ucontext.h>
  61 #include <sys/vdso.h>
  62
  63 #include <vm/vm.h>
  64 #include <vm/vm_kern.h>
  65 #include <vm/vm_object.h>
  66 #include <vm/vm_page.h>
  67 #include <vm/pmap.h>
  68 #include <vm/vm_map.h>
  69 #include <vm/vm_pager.h>
  70
  71 #include <machine/armreg.h>
  72 #include <machine/cpu.h>
  73 #include <machine/debug_monitor.h>
  74 #include <machine/kdb.h>
  75 #include <machine/machdep.h>
  76 #include <machine/metadata.h>
  77 #include <machine/md_var.h>
  78 #include <machine/pcb.h>
  79 #include <machine/reg.h>
  80 #include <machine/undefined.h>
  81 #include <machine/vmparam.h>
  82
  83 #include <arm/include/physmem.h>
  84
  85 #ifdef VFP
  86 #include <machine/vfp.h>
  87 #endif
  88
  89 #ifdef DEV_ACPI
  90 #include <contrib/dev/acpica/include/acpi.h>
  91 #include <machine/acpica_machdep.h>
  92 #endif
  93
  94 #ifdef FDT
  95 #include <dev/fdt/fdt_common.h>
  96 #include <dev/ofw/openfirm.h>
  97 #endif
  98
  99
 100 enum arm64_bus arm64_bus_method = ARM64_BUS_NONE;
 101
 102 struct pcpu __pcpu[MAXCPU];
 103
 104 static struct trapframe proc0_tf;
 105
 106 int early_boot = 1;
 107 int cold = 1;
 108
 109 struct kva_md_info kmi;
 110
 111 int64_t dcache_line_size;       /* The minimum D cache line size */
 112 int64_t icache_line_size;       /* The minimum I cache line size */
 113 int64_t idcache_line_size;      /* The minimum cache line size */
 114 int64_t dczva_line_size;        /* The size of cache line the dc zva zeroes */
 115 int has_pan;
 116
 117 /*
 118  * Physical address of the EFI System Table. Stashed from the metadata hints
 119  * passed into the kernel and used by the EFI code to call runtime services.
 120  */
 121 vm_paddr_t efi_systbl_phys;
 122
 123 /* pagezero_* implementations are provided in support.S */
 124 void pagezero_simple(void *);
 125 void pagezero_cache(void *);
 126
 127 /* pagezero_simple is default pagezero */
 128 void (*pagezero)(void *p) = pagezero_simple;
 129
 130 static void
 131 pan_setup(void)
 132 {
 133         uint64_t id_aa64mfr1;
 134
 135         id_aa64mfr1 = READ_SPECIALREG(id_aa64mmfr1_el1);
 136         if (ID_AA64MMFR1_PAN(id_aa64mfr1) != ID_AA64MMFR1_PAN_NONE)
 137                 has_pan = 1;
 138 }
 139
 140 void
 141 pan_enable(void)
 142 {
 143
 144         /*
 145          * The LLVM integrated assembler doesn't understand the PAN
 146          * PSTATE field. Because of this we need to manually create
 147          * the instruction in an asm block. This is equivalent to:
 148          * msr pan, #1
 149          *
 150          * This sets the PAN bit, stopping the kernel from accessing
 151          * memory when userspace can also access it unless the kernel
 152          * uses the userspace load/store instructions.
 153          */
 154         if (has_pan) {
 155                 WRITE_SPECIALREG(sctlr_el1,
 156                     READ_SPECIALREG(sctlr_el1) & ~SCTLR_SPAN);
 157                 __asm __volatile(".inst 0xd500409f | (0x1 << 8)");
 158         }
 159 }
 160
 161 static void
 162 cpu_startup(void *dummy)
 163 {
 164
 165         undef_init();
 166         identify_cpu();
 167         install_cpu_errata();
 168
 169         vm_ksubmap_init(&kmi);
 170         bufinit();
 171         vm_pager_bufferinit();
 172 }
 173
 174 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL);
 175
 176 int
 177 cpu_idle_wakeup(int cpu)
 178 {
 179
 180         return (0);
 181 }
 182
 183 int
 184 fill_regs(struct thread *td, struct reg *regs)
 185 {
 186         struct trapframe *frame;
 187
 188         frame = td->td_frame;
 189         regs->sp = frame->tf_sp;
 190         regs->lr = frame->tf_lr;
 191         regs->elr = frame->tf_elr;
 192         regs->spsr = frame->tf_spsr;
 193
 194         memcpy(regs->x, frame->tf_x, sizeof(regs->x));
 195
 196         return (0);
 197 }
 198
 199 int
 200 set_regs(struct thread *td, struct reg *regs)
 201 {
 202         struct trapframe *frame;
 203
 204         frame = td->td_frame;
 205         frame->tf_sp = regs->sp;
 206         frame->tf_lr = regs->lr;
 207         frame->tf_elr = regs->elr;
 208         frame->tf_spsr &= ~PSR_FLAGS;
 209         frame->tf_spsr |= regs->spsr & PSR_FLAGS;
 210
 211         memcpy(frame->tf_x, regs->x, sizeof(frame->tf_x));
 212
 213         return (0);
 214 }
 215
 216 int
 217 fill_fpregs(struct thread *td, struct fpreg *regs)
 218 {
 219 #ifdef VFP
 220         struct pcb *pcb;
 221
 222         pcb = td->td_pcb;
 223         if ((pcb->pcb_fpflags & PCB_FP_STARTED) != 0) {
 224                 /*
 225                  * If we have just been running VFP instructions we will
 226                  * need to save the state to memcpy it below.
 227                  */
 228                 if (td == curthread)
 229                         vfp_save_state(td, pcb);
 230
 231                 KASSERT(pcb->pcb_fpusaved == &pcb->pcb_fpustate,
 232                     ("Called fill_fpregs while the kernel is using the VFP"));
 233                 memcpy(regs->fp_q, pcb->pcb_fpustate.vfp_regs,
 234                     sizeof(regs->fp_q));
 235                 regs->fp_cr = pcb->pcb_fpustate.vfp_fpcr;
 236                 regs->fp_sr = pcb->pcb_fpustate.vfp_fpsr;
 237         } else
 238 #endif
 239                 memset(regs, 0, sizeof(*regs));
 240         return (0);
 241 }
 242
 243 int
 244 set_fpregs(struct thread *td, struct fpreg *regs)
 245 {
 246 #ifdef VFP
 247         struct pcb *pcb;
 248
 249         pcb = td->td_pcb;
 250         KASSERT(pcb->pcb_fpusaved == &pcb->pcb_fpustate,
 251             ("Called set_fpregs while the kernel is using the VFP"));
 252         memcpy(pcb->pcb_fpustate.vfp_regs, regs->fp_q, sizeof(regs->fp_q));
 253         pcb->pcb_fpustate.vfp_fpcr = regs->fp_cr;
 254         pcb->pcb_fpustate.vfp_fpsr = regs->fp_sr;
 255 #endif
 256         return (0);
 257 }
 258
 259 int
 260 fill_dbregs(struct thread *td, struct dbreg *regs)
 261 {
 262
 263         printf("ARM64TODO: fill_dbregs");
 264         return (EDOOFUS);
 265 }
 266
 267 int
 268 set_dbregs(struct thread *td, struct dbreg *regs)
 269 {
 270
 271         printf("ARM64TODO: set_dbregs");
 272         return (EDOOFUS);
 273 }
 274
 275 #ifdef COMPAT_FREEBSD32
 276 int
 277 fill_regs32(struct thread *td, struct reg32 *regs)
 278 {
 279
 280         printf("ARM64TODO: fill_regs32");
 281         return (EDOOFUS);
 282 }
 283
 284 int
 285 set_regs32(struct thread *td, struct reg32 *regs)
 286 {
 287
 288         printf("ARM64TODO: set_regs32");
 289         return (EDOOFUS);
 290 }
 291
 292 int
 293 fill_fpregs32(struct thread *td, struct fpreg32 *regs)
 294 {
 295
 296         printf("ARM64TODO: fill_fpregs32");
 297         return (EDOOFUS);
 298 }
 299
 300 int
 301 set_fpregs32(struct thread *td, struct fpreg32 *regs)
 302 {
 303
 304         printf("ARM64TODO: set_fpregs32");
 305         return (EDOOFUS);
 306 }
 307
 308 int
 309 fill_dbregs32(struct thread *td, struct dbreg32 *regs)
 310 {
 311
 312         printf("ARM64TODO: fill_dbregs32");
 313         return (EDOOFUS);
 314 }
 315
 316 int
 317 set_dbregs32(struct thread *td, struct dbreg32 *regs)
 318 {
 319
 320         printf("ARM64TODO: set_dbregs32");
 321         return (EDOOFUS);
 322 }
 323 #endif
 324
 325 int
 326 ptrace_set_pc(struct thread *td, u_long addr)
 327 {
 328
 329         printf("ARM64TODO: ptrace_set_pc");
 330         return (EDOOFUS);
 331 }
 332
 333 int
 334 ptrace_single_step(struct thread *td)
 335 {
 336
 337         td->td_frame->tf_spsr |= PSR_SS;
 338         td->td_pcb->pcb_flags |= PCB_SINGLE_STEP;
 339         return (0);
 340 }
 341
 342 int
 343 ptrace_clear_single_step(struct thread *td)
 344 {
 345
 346         td->td_frame->tf_spsr &= ~PSR_SS;
 347         td->td_pcb->pcb_flags &= ~PCB_SINGLE_STEP;
 348         return (0);
 349 }
 350
 351 void
 352 exec_setregs(struct thread *td, struct image_params *imgp, u_long stack)
 353 {
 354         struct trapframe *tf = td->td_frame;
 355
 356         memset(tf, 0, sizeof(struct trapframe));
 357
 358         tf->tf_x[0] = stack;
 359         tf->tf_sp = STACKALIGN(stack);
 360         tf->tf_lr = imgp->entry_addr;
 361         tf->tf_elr = imgp->entry_addr;
 362 }
 363
 364 /* Sanity check these are the same size, they will be memcpy'd to and fro */
 365 CTASSERT(sizeof(((struct trapframe *)0)->tf_x) ==
 366     sizeof((struct gpregs *)0)->gp_x);
 367 CTASSERT(sizeof(((struct trapframe *)0)->tf_x) ==
 368     sizeof((struct reg *)0)->x);
 369
 370 int
 371 get_mcontext(struct thread *td, mcontext_t *mcp, int clear_ret)
 372 {
 373         struct trapframe *tf = td->td_frame;
 374
 375         if (clear_ret & GET_MC_CLEAR_RET) {
 376                 mcp->mc_gpregs.gp_x[0] = 0;
 377                 mcp->mc_gpregs.gp_spsr = tf->tf_spsr & ~PSR_C;
 378         } else {
 379                 mcp->mc_gpregs.gp_x[0] = tf->tf_x[0];
 380                 mcp->mc_gpregs.gp_spsr = tf->tf_spsr;
 381         }
 382
 383         memcpy(&mcp->mc_gpregs.gp_x[1], &tf->tf_x[1],
 384             sizeof(mcp->mc_gpregs.gp_x[1]) * (nitems(mcp->mc_gpregs.gp_x) - 1));
 385
 386         mcp->mc_gpregs.gp_sp = tf->tf_sp;
 387         mcp->mc_gpregs.gp_lr = tf->tf_lr;
 388         mcp->mc_gpregs.gp_elr = tf->tf_elr;
 389
 390         return (0);
 391 }
 392
 393 int
 394 set_mcontext(struct thread *td, mcontext_t *mcp)
 395 {
 396         struct trapframe *tf = td->td_frame;
 397         uint32_t spsr;
 398
 399         spsr = mcp->mc_gpregs.gp_spsr;
 400         if ((spsr & PSR_M_MASK) != PSR_M_EL0t ||
 401             (spsr & (PSR_AARCH32 | PSR_F | PSR_I | PSR_A | PSR_D)) != 0)
 402                 return (EINVAL);
 403
 404         memcpy(tf->tf_x, mcp->mc_gpregs.gp_x, sizeof(tf->tf_x));
 405
 406         tf->tf_sp = mcp->mc_gpregs.gp_sp;
 407         tf->tf_lr = mcp->mc_gpregs.gp_lr;
 408         tf->tf_elr = mcp->mc_gpregs.gp_elr;
 409         tf->tf_spsr = mcp->mc_gpregs.gp_spsr;
 410
 411         return (0);
 412 }
 413
 414 static void
 415 get_fpcontext(struct thread *td, mcontext_t *mcp)
 416 {
 417 #ifdef VFP
 418         struct pcb *curpcb;
 419
 420         critical_enter();
 421
 422         curpcb = curthread->td_pcb;
 423
 424         if ((curpcb->pcb_fpflags & PCB_FP_STARTED) != 0) {
 425                 /*
 426                  * If we have just been running VFP instructions we will
 427                  * need to save the state to memcpy it below.
 428                  */
 429                 vfp_save_state(td, curpcb);
 430
 431                 KASSERT(curpcb->pcb_fpusaved == &curpcb->pcb_fpustate,
 432                     ("Called get_fpcontext while the kernel is using the VFP"));
 433                 KASSERT((curpcb->pcb_fpflags & ~PCB_FP_USERMASK) == 0,
 434                     ("Non-userspace FPU flags set in get_fpcontext"));
 435                 memcpy(mcp->mc_fpregs.fp_q, curpcb->pcb_fpustate.vfp_regs,
 436                     sizeof(mcp->mc_fpregs));
 437                 mcp->mc_fpregs.fp_cr = curpcb->pcb_fpustate.vfp_fpcr;
 438                 mcp->mc_fpregs.fp_sr = curpcb->pcb_fpustate.vfp_fpsr;
 439                 mcp->mc_fpregs.fp_flags = curpcb->pcb_fpflags;
 440                 mcp->mc_flags |= _MC_FP_VALID;
 441         }
 442
 443         critical_exit();
 444 #endif
 445 }
 446
 447 static void
 448 set_fpcontext(struct thread *td, mcontext_t *mcp)
 449 {
 450 #ifdef VFP
 451         struct pcb *curpcb;
 452
 453         critical_enter();
 454
 455         if ((mcp->mc_flags & _MC_FP_VALID) != 0) {
 456                 curpcb = curthread->td_pcb;
 457
 458                 /*
 459                  * Discard any vfp state for the current thread, we
 460                  * are about to override it.
 461                  */
 462                 vfp_discard(td);
 463
 464                 KASSERT(curpcb->pcb_fpusaved == &curpcb->pcb_fpustate,
 465                     ("Called set_fpcontext while the kernel is using the VFP"));
 466                 memcpy(curpcb->pcb_fpustate.vfp_regs, mcp->mc_fpregs.fp_q,
 467                     sizeof(mcp->mc_fpregs));
 468                 curpcb->pcb_fpustate.vfp_fpcr = mcp->mc_fpregs.fp_cr;
 469                 curpcb->pcb_fpustate.vfp_fpsr = mcp->mc_fpregs.fp_sr;
 470                 curpcb->pcb_fpflags = mcp->mc_fpregs.fp_flags & PCB_FP_USERMASK;
 471         }
 472
 473         critical_exit();
 474 #endif
 475 }
 476
 477 void
 478 cpu_idle(int busy)
 479 {
 480
 481         spinlock_enter();
 482         if (!busy)
 483                 cpu_idleclock();
 484         if (!sched_runnable())
 485                 __asm __volatile(
 486                     "dsb sy \n"
 487                     "wfi    \n");
 488         if (!busy)
 489                 cpu_activeclock();
 490         spinlock_exit();
 491 }
 492
 493 void
 494 cpu_halt(void)
 495 {
 496
 497         /* We should have shutdown by now, if not enter a low power sleep */
 498         intr_disable();
 499         while (1) {
 500                 __asm __volatile("wfi");
 501         }
 502 }
 503
 504 /*
 505  * Flush the D-cache for non-DMA I/O so that the I-cache can
 506  * be made coherent later.
 507  */
 508 void
 509 cpu_flush_dcache(void *ptr, size_t len)
 510 {
 511
 512         /* ARM64TODO TBD */
 513 }
 514
 515 /* Get current clock frequency for the given CPU ID. */
 516 int
 517 cpu_est_clockrate(int cpu_id, uint64_t *rate)
 518 {
 519         struct pcpu *pc;
 520
 521         pc = pcpu_find(cpu_id);
 522         if (pc == NULL || rate == NULL)
 523                 return (EINVAL);
 524
 525         if (pc->pc_clock == 0)
 526                 return (EOPNOTSUPP);
 527
 528         *rate = pc->pc_clock;
 529         return (0);
 530 }
 531
 532 void
 533 cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t size)
 534 {
 535
 536         pcpu->pc_acpi_id = 0xffffffff;
 537 }
 538
 539 void
 540 spinlock_enter(void)
 541 {
 542         struct thread *td;
 543         register_t daif;
 544
 545         td = curthread;
 546         if (td->td_md.md_spinlock_count == 0) {
 547                 daif = intr_disable();
 548                 td->td_md.md_spinlock_count = 1;
 549                 td->td_md.md_saved_daif = daif;
 550         } else
 551                 td->td_md.md_spinlock_count++;
 552         critical_enter();
 553 }
 554
 555 void
 556 spinlock_exit(void)
 557 {
 558         struct thread *td;
 559         register_t daif;
 560
 561         td = curthread;
 562         critical_exit();
 563         daif = td->td_md.md_saved_daif;
 564         td->td_md.md_spinlock_count--;
 565         if (td->td_md.md_spinlock_count == 0)
 566                 intr_restore(daif);
 567 }
 568
 569 #ifndef _SYS_SYSPROTO_H_
 570 struct sigreturn_args {
 571         ucontext_t *ucp;
 572 };
 573 #endif
 574
 575 int
 576 sys_sigreturn(struct thread *td, struct sigreturn_args *uap)
 577 {
 578         ucontext_t uc;
 579         int error;
 580
 581         if (uap == NULL)
 582                 return (EFAULT);
 583         if (copyin(uap->sigcntxp, &uc, sizeof(uc)))
 584                 return (EFAULT);
 585
 586         error = set_mcontext(td, &uc.uc_mcontext);
 587         if (error != 0)
 588                 return (error);
 589         set_fpcontext(td, &uc.uc_mcontext);
 590
 591         /* Restore signal mask. */
 592         kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0);
 593
 594         return (EJUSTRETURN);
 595 }
 596
 597 /*
 598  * Construct a PCB from a trapframe. This is called from kdb_trap() where
 599  * we want to start a backtrace from the function that caused us to enter
 600  * the debugger. We have the context in the trapframe, but base the trace
 601  * on the PCB. The PCB doesn't have to be perfect, as long as it contains
 602  * enough for a backtrace.
 603  */
 604 void
 605 makectx(struct trapframe *tf, struct pcb *pcb)
 606 {
 607         int i;
 608
 609         for (i = 0; i < PCB_LR; i++)
 610                 pcb->pcb_x[i] = tf->tf_x[i];
 611
 612         pcb->pcb_x[PCB_LR] = tf->tf_lr;
 613         pcb->pcb_pc = tf->tf_elr;
 614         pcb->pcb_sp = tf->tf_sp;
 615 }
 616
 617 void
 618 sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
 619 {
 620         struct thread *td;
 621         struct proc *p;
 622         struct trapframe *tf;
 623         struct sigframe *fp, frame;
 624         struct sigacts *psp;
 625         struct sysentvec *sysent;
 626         int onstack, sig;
 627
 628         td = curthread;
 629         p = td->td_proc;
 630         PROC_LOCK_ASSERT(p, MA_OWNED);
 631
 632         sig = ksi->ksi_signo;
 633         psp = p->p_sigacts;
 634         mtx_assert(&psp->ps_mtx, MA_OWNED);
 635
 636         tf = td->td_frame;
 637         onstack = sigonstack(tf->tf_sp);
 638
 639         CTR4(KTR_SIG, "sendsig: td=%p (%s) catcher=%p sig=%d", td, p->p_comm,
 640             catcher, sig);
 641
 642         /* Allocate and validate space for the signal handler context. */
 643         if ((td->td_pflags & TDP_ALTSTACK) != 0 && !onstack &&
 644             SIGISMEMBER(psp->ps_sigonstack, sig)) {
 645                 fp = (struct sigframe *)((uintptr_t)td->td_sigstk.ss_sp +
 646                     td->td_sigstk.ss_size);
 647 #if defined(COMPAT_43)
 648                 td->td_sigstk.ss_flags |= SS_ONSTACK;
 649 #endif
 650         } else {
 651                 fp = (struct sigframe *)td->td_frame->tf_sp;
 652         }
 653
 654         /* Make room, keeping the stack aligned */
 655         fp--;
 656         fp = (struct sigframe *)STACKALIGN(fp);
 657
 658         /* Fill in the frame to copy out */
 659         bzero(&frame, sizeof(frame));
 660         get_mcontext(td, &frame.sf_uc.uc_mcontext, 0);
 661         get_fpcontext(td, &frame.sf_uc.uc_mcontext);
 662         frame.sf_si = ksi->ksi_info;
 663         frame.sf_uc.uc_sigmask = *mask;
 664         frame.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) ?
 665             ((onstack) ? SS_ONSTACK : 0) : SS_DISABLE;
 666         frame.sf_uc.uc_stack = td->td_sigstk;
 667         mtx_unlock(&psp->ps_mtx);
 668         PROC_UNLOCK(td->td_proc);
 669
 670         /* Copy the sigframe out to the user's stack. */
 671         if (copyout(&frame, fp, sizeof(*fp)) != 0) {
 672                 /* Process has trashed its stack. Kill it. */
 673                 CTR2(KTR_SIG, "sendsig: sigexit td=%p fp=%p", td, fp);
 674                 PROC_LOCK(p);
 675                 sigexit(td, SIGILL);
 676         }
 677
 678         tf->tf_x[0]= sig;
 679         tf->tf_x[1] = (register_t)&fp->sf_si;
 680         tf->tf_x[2] = (register_t)&fp->sf_uc;
 681
 682         tf->tf_elr = (register_t)catcher;
 683         tf->tf_sp = (register_t)fp;
 684         sysent = p->p_sysent;
 685         if (sysent->sv_sigcode_base != 0)
 686                 tf->tf_lr = (register_t)sysent->sv_sigcode_base;
 687         else
 688                 tf->tf_lr = (register_t)(sysent->sv_psstrings -
 689                     *(sysent->sv_szsigcode));
 690
 691         CTR3(KTR_SIG, "sendsig: return td=%p pc=%#x sp=%#x", td, tf->tf_elr,
 692             tf->tf_sp);
 693
 694         PROC_LOCK(p);
 695         mtx_lock(&psp->ps_mtx);
 696 }
 697
 698 static void
 699 init_proc0(vm_offset_t kstack)
 700 {
 701         struct pcpu *pcpup = &__pcpu[0];
 702
 703         proc_linkup0(&proc0, &thread0);
 704         thread0.td_kstack = kstack;
 705         thread0.td_pcb = (struct pcb *)(thread0.td_kstack) - 1;
 706         thread0.td_pcb->pcb_fpflags = 0;
 707         thread0.td_pcb->pcb_fpusaved = &thread0.td_pcb->pcb_fpustate;
 708         thread0.td_pcb->pcb_vfpcpu = UINT_MAX;
 709         thread0.td_frame = &proc0_tf;
 710         pcpup->pc_curpcb = thread0.td_pcb;
 711
 712         /* Set the base address of translation table 0. */
 713         thread0.td_proc->p_md.md_l0addr = READ_SPECIALREG(ttbr0_el1);
 714 }
 715
 716 typedef struct {
 717         uint32_t type;
 718         uint64_t phys_start;
 719         uint64_t virt_start;
 720         uint64_t num_pages;
 721         uint64_t attr;
 722 } EFI_MEMORY_DESCRIPTOR;
 723
 724 typedef void (*efi_map_entry_cb)(struct efi_md *);
 725
 726 static void
 727 foreach_efi_map_entry(struct efi_map_header *efihdr, efi_map_entry_cb cb)
 728 {
 729         struct efi_md *map, *p;
 730         size_t efisz;
 731         int ndesc, i;
 732
 733         /*
 734          * Memory map data provided by UEFI via the GetMemoryMap
 735          * Boot Services API.
 736          */
 737         efisz = (sizeof(struct efi_map_header) + 0xf) & ~0xf;
 738         map = (struct efi_md *)((uint8_t *)efihdr + efisz);
 739
 740         if (efihdr->descriptor_size == 0)
 741                 return;
 742         ndesc = efihdr->memory_size / efihdr->descriptor_size;
 743
 744         for (i = 0, p = map; i < ndesc; i++,
 745             p = efi_next_descriptor(p, efihdr->descriptor_size)) {
 746                 cb(p);
 747         }
 748 }
 749
 750 static void
 751 exclude_efi_map_entry(struct efi_md *p)
 752 {
 753
 754         switch (p->md_type) {
 755         case EFI_MD_TYPE_CODE:
 756         case EFI_MD_TYPE_DATA:
 757         case EFI_MD_TYPE_BS_CODE:
 758         case EFI_MD_TYPE_BS_DATA:
 759         case EFI_MD_TYPE_FREE:
 760                 /*
 761                  * We're allowed to use any entry with these types.
 762                  */
 763                 break;
 764         default:
 765                 arm_physmem_exclude_region(p->md_phys, p->md_pages * PAGE_SIZE,
 766                     EXFLAG_NOALLOC);
 767         }
 768 }
 769
 770 static void
 771 exclude_efi_map_entries(struct efi_map_header *efihdr)
 772 {
 773
 774         foreach_efi_map_entry(efihdr, exclude_efi_map_entry);
 775 }
 776
 777 static void
 778 add_efi_map_entry(struct efi_md *p)
 779 {
 780
 781         switch (p->md_type) {
 782         case EFI_MD_TYPE_RT_DATA:
 783                 /*
 784                  * Runtime data will be excluded after the DMAP
 785                  * region is created to stop it from being added
 786                  * to phys_avail.
 787                  */
 788         case EFI_MD_TYPE_CODE:
 789         case EFI_MD_TYPE_DATA:
 790         case EFI_MD_TYPE_BS_CODE:
 791         case EFI_MD_TYPE_BS_DATA:
 792         case EFI_MD_TYPE_FREE:
 793                 /*
 794                  * We're allowed to use any entry with these types.
 795                  */
 796                 arm_physmem_hardware_region(p->md_phys,
 797                     p->md_pages * PAGE_SIZE);
 798                 break;
 799         }
 800 }
 801
 802 static void
 803 add_efi_map_entries(struct efi_map_header *efihdr)
 804 {
 805
 806         foreach_efi_map_entry(efihdr, add_efi_map_entry);
 807 }
 808
 809 static void
 810 print_efi_map_entry(struct efi_md *p)
 811 {
 812         const char *type;
 813         static const char *types[] = {
 814                 "Reserved",
 815                 "LoaderCode",
 816                 "LoaderData",
 817                 "BootServicesCode",
 818                 "BootServicesData",
 819                 "RuntimeServicesCode",
 820                 "RuntimeServicesData",
 821                 "ConventionalMemory",
 822                 "UnusableMemory",
 823                 "ACPIReclaimMemory",
 824                 "ACPIMemoryNVS",
 825                 "MemoryMappedIO",
 826                 "MemoryMappedIOPortSpace",
 827                 "PalCode",
 828                 "PersistentMemory"
 829         };
 830
 831         if (p->md_type < nitems(types))
 832                 type = types[p->md_type];
 833         else
 834                 type = "<INVALID>";
 835         printf("%23s %012lx %12p %08lx ", type, p->md_phys,
 836             p->md_virt, p->md_pages);
 837         if (p->md_attr & EFI_MD_ATTR_UC)
 838                 printf("UC ");
 839         if (p->md_attr & EFI_MD_ATTR_WC)
 840                 printf("WC ");
 841         if (p->md_attr & EFI_MD_ATTR_WT)
 842                 printf("WT ");
 843         if (p->md_attr & EFI_MD_ATTR_WB)
 844                 printf("WB ");
 845         if (p->md_attr & EFI_MD_ATTR_UCE)
 846                 printf("UCE ");
 847         if (p->md_attr & EFI_MD_ATTR_WP)
 848                 printf("WP ");
 849         if (p->md_attr & EFI_MD_ATTR_RP)
 850                 printf("RP ");
 851         if (p->md_attr & EFI_MD_ATTR_XP)
 852                 printf("XP ");
 853         if (p->md_attr & EFI_MD_ATTR_NV)
 854                 printf("NV ");
 855         if (p->md_attr & EFI_MD_ATTR_MORE_RELIABLE)
 856                 printf("MORE_RELIABLE ");
 857         if (p->md_attr & EFI_MD_ATTR_RO)
 858                 printf("RO ");
 859         if (p->md_attr & EFI_MD_ATTR_RT)
 860                 printf("RUNTIME");
 861         printf("\n");
 862 }
 863
 864 static void
 865 print_efi_map_entries(struct efi_map_header *efihdr)
 866 {
 867
 868         printf("%23s %12s %12s %8s %4s\n",
 869             "Type", "Physical", "Virtual", "#Pages", "Attr");
 870         foreach_efi_map_entry(efihdr, print_efi_map_entry);
 871 }
 872
 873 #ifdef FDT
 874 static void
 875 try_load_dtb(caddr_t kmdp)
 876 {
 877         vm_offset_t dtbp;
 878
 879         dtbp = MD_FETCH(kmdp, MODINFOMD_DTBP, vm_offset_t);
 880         if (dtbp == (vm_offset_t)NULL) {
 881                 printf("ERROR loading DTB\n");
 882                 return;
 883         }
 884
 885         if (OF_install(OFW_FDT, 0) == FALSE)
 886                 panic("Cannot install FDT");
 887
 888         if (OF_init((void *)dtbp) != 0)
 889                 panic("OF_init failed with the found device tree");
 890 }
 891 #endif
 892
 893 static bool
 894 bus_probe(void)
 895 {
 896         bool has_acpi, has_fdt;
 897         char *order, *env;
 898
 899         has_acpi = has_fdt = false;
 900
 901 #ifdef FDT
 902         has_fdt = (OF_peer(0) != 0);
 903 #endif
 904 #ifdef DEV_ACPI
 905         has_acpi = (acpi_find_table(ACPI_SIG_SPCR) != 0);
 906 #endif
 907
 908         env = kern_getenv("kern.cfg.order");
 909         if (env != NULL) {
 910                 order = env;
 911                 while (order != NULL) {
 912                         if (has_acpi &&
 913                             strncmp(order, "acpi", 4) == 0 &&
 914                             (order[4] == ',' || order[4] == '\0')) {
 915                                 arm64_bus_method = ARM64_BUS_ACPI;
 916                                 break;
 917                         }
 918                         if (has_fdt &&
 919                             strncmp(order, "fdt", 3) == 0 &&
 920                             (order[3] == ',' || order[3] == '\0')) {
 921                                 arm64_bus_method = ARM64_BUS_FDT;
 922                                 break;
 923                         }
 924                         order = strchr(order, ',');
 925                 }
 926                 freeenv(env);
 927
 928                 /* If we set the bus method it is valid */
 929                 if (arm64_bus_method != ARM64_BUS_NONE)
 930                         return (true);
 931         }
 932         /* If no order or an invalid order was set use the default */
 933         if (arm64_bus_method == ARM64_BUS_NONE) {
 934                 if (has_fdt)
 935                         arm64_bus_method = ARM64_BUS_FDT;
 936                 else if (has_acpi)
 937                         arm64_bus_method = ARM64_BUS_ACPI;
 938         }
 939
 940         /*
 941          * If no option was set the default is valid, otherwise we are
 942          * setting one to get cninit() working, then calling panic to tell
 943          * the user about the invalid bus setup.
 944          */
 945         return (env == NULL);
 946 }
 947
 948 static void
 949 cache_setup(void)
 950 {
 951         int dcache_line_shift, icache_line_shift, dczva_line_shift;
 952         uint32_t ctr_el0;
 953         uint32_t dczid_el0;
 954
 955         ctr_el0 = READ_SPECIALREG(ctr_el0);
 956
 957         /* Read the log2 words in each D cache line */
 958         dcache_line_shift = CTR_DLINE_SIZE(ctr_el0);
 959         /* Get the D cache line size */
 960         dcache_line_size = sizeof(int) << dcache_line_shift;
 961
 962         /* And the same for the I cache */
 963         icache_line_shift = CTR_ILINE_SIZE(ctr_el0);
 964         icache_line_size = sizeof(int) << icache_line_shift;
 965
 966         idcache_line_size = MIN(dcache_line_size, icache_line_size);
 967
 968         dczid_el0 = READ_SPECIALREG(dczid_el0);
 969
 970         /* Check if dc zva is not prohibited */
 971         if (dczid_el0 & DCZID_DZP)
 972                 dczva_line_size = 0;
 973         else {
 974                 /* Same as with above calculations */
 975                 dczva_line_shift = DCZID_BS_SIZE(dczid_el0);
 976                 dczva_line_size = sizeof(int) << dczva_line_shift;
 977
 978                 /* Change pagezero function */
 979                 pagezero = pagezero_cache;
 980         }
 981 }
 982
 983 void
 984 initarm(struct arm64_bootparams *abp)
 985 {
 986         struct efi_fb *efifb;
 987         struct efi_map_header *efihdr;
 988         struct pcpu *pcpup;
 989         char *env;
 990 #ifdef FDT
 991         struct mem_region mem_regions[FDT_MEM_REGIONS];
 992         int mem_regions_sz;
 993 #endif
 994         vm_offset_t lastaddr;
 995         caddr_t kmdp;
 996         bool valid;
 997
 998         /* Set the module data location */
 999         preload_metadata = (caddr_t)(uintptr_t)(abp->modulep);
1000
1001         /* Find the kernel address */
1002         kmdp = preload_search_by_type("elf kernel");
1003         if (kmdp == NULL)
1004                 kmdp = preload_search_by_type("elf64 kernel");
1005
1006         boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
1007         init_static_kenv(MD_FETCH(kmdp, MODINFOMD_ENVP, char *), 0);
1008         link_elf_ireloc(kmdp);
1009
1010 #ifdef FDT
1011         try_load_dtb(kmdp);
1012 #endif
1013
1014         efi_systbl_phys = MD_FETCH(kmdp, MODINFOMD_FW_HANDLE, vm_paddr_t);
1015
1016         /* Find the address to start allocating from */
1017         lastaddr = MD_FETCH(kmdp, MODINFOMD_KERNEND, vm_offset_t);
1018
1019         /* Load the physical memory ranges */
1020         efihdr = (struct efi_map_header *)preload_search_info(kmdp,
1021             MODINFO_METADATA | MODINFOMD_EFI_MAP);
1022         if (efihdr != NULL)
1023                 add_efi_map_entries(efihdr);
1024 #ifdef FDT
1025         else {
1026                 /* Grab physical memory regions information from device tree. */
1027                 if (fdt_get_mem_regions(mem_regions, &mem_regions_sz,
1028                     NULL) != 0)
1029                         panic("Cannot get physical memory regions");
1030                 arm_physmem_hardware_regions(mem_regions, mem_regions_sz);
1031         }
1032         if (fdt_get_reserved_mem(mem_regions, &mem_regions_sz) == 0)
1033                 arm_physmem_exclude_regions(mem_regions, mem_regions_sz,
1034                     EXFLAG_NODUMP | EXFLAG_NOALLOC);
1035 #endif
1036
1037         /* Exclude the EFI framebuffer from our view of physical memory. */
1038         efifb = (struct efi_fb *)preload_search_info(kmdp,
1039             MODINFO_METADATA | MODINFOMD_EFI_FB);
1040         if (efifb != NULL)
1041                 arm_physmem_exclude_region(efifb->fb_addr, efifb->fb_size,
1042                     EXFLAG_NOALLOC);
1043
1044         /* Set the pcpu data, this is needed by pmap_bootstrap */
1045         pcpup = &__pcpu[0];
1046         pcpu_init(pcpup, 0, sizeof(struct pcpu));
1047
1048         /*
1049          * Set the pcpu pointer with a backup in tpidr_el1 to be
1050          * loaded when entering the kernel from userland.
1051          */
1052         __asm __volatile(
1053             "mov x18, %0 \n"
1054             "msr tpidr_el1, %0" :: "r"(pcpup));
1055
1056         PCPU_SET(curthread, &thread0);
1057
1058         /* Do basic tuning, hz etc */
1059         init_param1();
1060
1061         cache_setup();
1062         pan_setup();
1063
1064         /* Bootstrap enough of pmap  to enter the kernel proper */
1065         pmap_bootstrap(abp->kern_l0pt, abp->kern_l1pt,
1066             KERNBASE - abp->kern_delta, lastaddr - KERNBASE);
1067         /* Exclude entries neexed in teh DMAP region, but not phys_avail */
1068         if (efihdr != NULL)
1069                 exclude_efi_map_entries(efihdr);
1070         arm_physmem_init_kernel_globals();
1071
1072         devmap_bootstrap(0, NULL);
1073
1074         valid = bus_probe();
1075
1076         cninit();
1077
1078         if (!valid)
1079                 panic("Invalid bus configuration: %s",
1080                     kern_getenv("kern.cfg.order"));
1081
1082         init_proc0(abp->kern_stack);
1083         msgbufinit(msgbufp, msgbufsize);
1084         mutex_init();
1085         init_param2(physmem);
1086
1087         dbg_init();
1088         kdb_init();
1089         pan_enable();
1090
1091         env = kern_getenv("kernelname");
1092         if (env != NULL)
1093                 strlcpy(kernelname, env, sizeof(kernelname));
1094
1095         if (boothowto & RB_VERBOSE) {
1096                 print_efi_map_entries(efihdr);
1097                 arm_physmem_print_tables();
1098         }
1099
1100         early_boot = 0;
1101 }
1102
1103 void
1104 dbg_init(void)
1105 {
1106
1107         /* Clear OS lock */
1108         WRITE_SPECIALREG(OSLAR_EL1, 0);
1109
1110         /* This permits DDB to use debug registers for watchpoints. */
1111         dbg_monitor_init();
1112
1113         /* TODO: Eventually will need to initialize debug registers here. */
1114 }
1115
1116 #ifdef DDB
1117 #include <ddb/ddb.h>
1118
1119 DB_SHOW_COMMAND(specialregs, db_show_spregs)
1120 {
1121 #define PRINT_REG(reg)  \
1122     db_printf(__STRING(reg) " = %#016lx\n", READ_SPECIALREG(reg))
1123
1124         PRINT_REG(actlr_el1);
1125         PRINT_REG(afsr0_el1);
1126         PRINT_REG(afsr1_el1);
1127         PRINT_REG(aidr_el1);
1128         PRINT_REG(amair_el1);
1129         PRINT_REG(ccsidr_el1);
1130         PRINT_REG(clidr_el1);
1131         PRINT_REG(contextidr_el1);
1132         PRINT_REG(cpacr_el1);
1133         PRINT_REG(csselr_el1);
1134         PRINT_REG(ctr_el0);
1135         PRINT_REG(currentel);
1136         PRINT_REG(daif);
1137         PRINT_REG(dczid_el0);
1138         PRINT_REG(elr_el1);
1139         PRINT_REG(esr_el1);
1140         PRINT_REG(far_el1);
1141 #if 0
1142         /* ARM64TODO: Enable VFP before reading floating-point registers */
1143         PRINT_REG(fpcr);
1144         PRINT_REG(fpsr);
1145 #endif
1146         PRINT_REG(id_aa64afr0_el1);
1147         PRINT_REG(id_aa64afr1_el1);
1148         PRINT_REG(id_aa64dfr0_el1);
1149         PRINT_REG(id_aa64dfr1_el1);
1150         PRINT_REG(id_aa64isar0_el1);
1151         PRINT_REG(id_aa64isar1_el1);
1152         PRINT_REG(id_aa64pfr0_el1);
1153         PRINT_REG(id_aa64pfr1_el1);
1154         PRINT_REG(id_afr0_el1);
1155         PRINT_REG(id_dfr0_el1);
1156         PRINT_REG(id_isar0_el1);
1157         PRINT_REG(id_isar1_el1);
1158         PRINT_REG(id_isar2_el1);
1159         PRINT_REG(id_isar3_el1);
1160         PRINT_REG(id_isar4_el1);
1161         PRINT_REG(id_isar5_el1);
1162         PRINT_REG(id_mmfr0_el1);
1163         PRINT_REG(id_mmfr1_el1);
1164         PRINT_REG(id_mmfr2_el1);
1165         PRINT_REG(id_mmfr3_el1);
1166 #if 0
1167         /* Missing from llvm */
1168         PRINT_REG(id_mmfr4_el1);
1169 #endif
1170         PRINT_REG(id_pfr0_el1);
1171         PRINT_REG(id_pfr1_el1);
1172         PRINT_REG(isr_el1);
1173         PRINT_REG(mair_el1);
1174         PRINT_REG(midr_el1);
1175         PRINT_REG(mpidr_el1);
1176         PRINT_REG(mvfr0_el1);
1177         PRINT_REG(mvfr1_el1);
1178         PRINT_REG(mvfr2_el1);
1179         PRINT_REG(revidr_el1);
1180         PRINT_REG(sctlr_el1);
1181         PRINT_REG(sp_el0);
1182         PRINT_REG(spsel);
1183         PRINT_REG(spsr_el1);
1184         PRINT_REG(tcr_el1);
1185         PRINT_REG(tpidr_el0);
1186         PRINT_REG(tpidr_el1);
1187         PRINT_REG(tpidrro_el0);
1188         PRINT_REG(ttbr0_el1);
1189         PRINT_REG(ttbr1_el1);
1190         PRINT_REG(vbar_el1);
1191 #undef PRINT_REG
1192 }
1193
1194 DB_SHOW_COMMAND(vtop, db_show_vtop)
1195 {
1196         uint64_t phys;
1197
1198         if (have_addr) {
1199                 phys = arm64_address_translate_s1e1r(addr);
1200                 db_printf("EL1 physical address reg (read):  0x%016lx\n", phys);
1201                 phys = arm64_address_translate_s1e1w(addr);
1202                 db_printf("EL1 physical address reg (write): 0x%016lx\n", phys);
1203                 phys = arm64_address_translate_s1e0r(addr);
1204                 db_printf("EL0 physical address reg (read):  0x%016lx\n", phys);
1205                 phys = arm64_address_translate_s1e0w(addr);
1206                 db_printf("EL0 physical address reg (write): 0x%016lx\n", phys);
1207         } else
1208                 db_printf("show vtop <virt_addr>\n");
1209 }
1210 #endif