1/*- 2 * Copyright (c) 2014 Andrew Turner 3 * Copyright (c) 2015-2016 Ruslan Bukin <br@bsdpad.com> 4 * All rights reserved. 5 * 6 * Portions of this software were developed by SRI International and the 7 * University of Cambridge Computer Laboratory under DARPA/AFRL contract 8 * FA8750-10-C-0237 ("CTSRD"), as part of the DARPA CRASH research programme. 9 * 10 * Portions of this software were developed by the University of Cambridge 11 * Computer Laboratory as part of the CTSRD Project, with support from the 12 * UK Higher Education Innovation Fund (HEIF). 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36#include "opt_platform.h" 37 38#include <sys/cdefs.h> 39__FBSDID("$FreeBSD: stable/11/sys/riscv/riscv/machdep.c 341166 2018-11-28 21:20:51Z vangyzen $"); 40 41#include <sys/param.h> 42#include <sys/systm.h> 43#include <sys/buf.h> 44#include <sys/bus.h> 45#include <sys/cons.h> 46#include <sys/cpu.h> 47#include <sys/exec.h> 48#include <sys/imgact.h> 49#include <sys/kdb.h> 50#include <sys/kernel.h> 51#include <sys/limits.h> 52#include <sys/linker.h> 53#include <sys/msgbuf.h> 54#include <sys/pcpu.h> 55#include <sys/proc.h> 56#include <sys/ptrace.h> 57#include <sys/reboot.h> 58#include <sys/rwlock.h> 59#include <sys/sched.h> 60#include <sys/signalvar.h> 61#include <sys/syscallsubr.h> 62#include <sys/sysent.h> 63#include <sys/sysproto.h> 64#include <sys/ucontext.h> 65 66#include <vm/vm.h> 67#include <vm/vm_kern.h> 68#include <vm/vm_object.h> 69#include <vm/vm_page.h> 70#include <vm/pmap.h> 71#include <vm/vm_map.h> 72#include <vm/vm_pager.h> 73 74#include <machine/riscvreg.h> 75#include <machine/cpu.h> 76#include <machine/kdb.h> 77#include <machine/machdep.h> 78#include <machine/pcb.h> 79#include <machine/reg.h> 80#include <machine/trap.h> 81#include <machine/vmparam.h> 82#include <machine/intr.h> 83 84#include <machine/asm.h> 85 86#ifdef VFP 87#include <machine/vfp.h> 88#endif 89 90#ifdef FDT 91#include <dev/fdt/fdt_common.h> 92#include <dev/ofw/openfirm.h> 93#endif 94 95struct pcpu __pcpu[MAXCPU]; 96 97static struct trapframe proc0_tf; 98 99vm_paddr_t phys_avail[PHYS_AVAIL_SIZE + 2]; 100vm_paddr_t dump_avail[PHYS_AVAIL_SIZE + 2]; 101 102int early_boot = 1; 103int cold = 1; 104long realmem = 0; 105long Maxmem = 0; 106 107#define PHYSMAP_SIZE (2 * (VM_PHYSSEG_MAX - 1)) 108vm_paddr_t physmap[PHYSMAP_SIZE]; 109u_int physmap_idx; 110 111struct kva_md_info kmi; 112 113int64_t dcache_line_size; /* The minimum D cache line size */ 114int64_t icache_line_size; /* The minimum I cache line size */ 115int64_t idcache_line_size; /* The minimum cache line size */ 116 117extern int *end; 118extern int *initstack_end; 119 120struct pcpu *pcpup; 121 122uintptr_t mcall_trap(uintptr_t mcause, uintptr_t* regs); 123 124uintptr_t 125mcall_trap(uintptr_t mcause, uintptr_t* regs) 126{ 127 128 return (0); 129} 130 131static void 132cpu_startup(void *dummy) 133{ 134 135 identify_cpu(); 136 137 vm_ksubmap_init(&kmi); 138 bufinit(); 139 vm_pager_bufferinit(); 140} 141 142SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL); 143 144int 145cpu_idle_wakeup(int cpu) 146{ 147 148 return (0); 149} 150 151void 152bzero(void *buf, size_t len) 153{ 154 uint8_t *p; 155 156 p = buf; 157 while(len-- > 0) 158 *p++ = 0; 159} 160 161int 162fill_regs(struct thread *td, struct reg *regs) 163{ 164 struct trapframe *frame; 165 166 frame = td->td_frame; 167 regs->sepc = frame->tf_sepc; 168 regs->sstatus = frame->tf_sstatus; 169 regs->ra = frame->tf_ra; 170 regs->sp = frame->tf_sp; 171 regs->gp = frame->tf_gp; 172 regs->tp = frame->tf_tp; 173 174 memcpy(regs->t, frame->tf_t, sizeof(regs->t)); 175 memcpy(regs->s, frame->tf_s, sizeof(regs->s)); 176 memcpy(regs->a, frame->tf_a, sizeof(regs->a)); 177 178 return (0); 179} 180 181int 182set_regs(struct thread *td, struct reg *regs) 183{ 184 struct trapframe *frame; 185 186 frame = td->td_frame; 187 frame->tf_sepc = regs->sepc; 188 frame->tf_sstatus = regs->sstatus; 189 frame->tf_ra = regs->ra; 190 frame->tf_sp = regs->sp; 191 frame->tf_gp = regs->gp; 192 frame->tf_tp = regs->tp; 193 194 memcpy(frame->tf_t, regs->t, sizeof(frame->tf_t)); 195 memcpy(frame->tf_s, regs->s, sizeof(frame->tf_s)); 196 memcpy(frame->tf_a, regs->a, sizeof(frame->tf_a)); 197 198 return (0); 199} 200 201int 202fill_fpregs(struct thread *td, struct fpreg *regs) 203{ 204 205 /* TODO */ 206 bzero(regs, sizeof(*regs)); 207 return (0); 208} 209 210int 211set_fpregs(struct thread *td, struct fpreg *regs) 212{ 213 214 /* TODO */ 215 return (0); 216} 217 218int 219fill_dbregs(struct thread *td, struct dbreg *regs) 220{ 221 222 panic("fill_dbregs"); 223} 224 225int 226set_dbregs(struct thread *td, struct dbreg *regs) 227{ 228 229 panic("set_dbregs"); 230} 231 232int 233ptrace_set_pc(struct thread *td, u_long addr) 234{ 235 236 panic("ptrace_set_pc"); 237 return (0); 238} 239 240int 241ptrace_single_step(struct thread *td) 242{ 243 244 /* TODO; */ 245 return (0); 246} 247 248int 249ptrace_clear_single_step(struct thread *td) 250{ 251 252 /* TODO; */ 253 return (0); 254} 255 256void 257exec_setregs(struct thread *td, struct image_params *imgp, u_long stack) 258{ 259 struct trapframe *tf; 260 261 tf = td->td_frame; 262 263 memset(tf, 0, sizeof(struct trapframe)); 264 265 /* 266 * We need to set a0 for init as it doesn't call 267 * cpu_set_syscall_retval to copy the value. We also 268 * need to set td_retval for the cases where we do. 269 */ 270 tf->tf_a[0] = td->td_retval[0] = stack; 271 tf->tf_sp = STACKALIGN(stack); 272 tf->tf_ra = imgp->entry_addr; 273 tf->tf_sepc = imgp->entry_addr; 274} 275 276/* Sanity check these are the same size, they will be memcpy'd to and fro */ 277CTASSERT(sizeof(((struct trapframe *)0)->tf_a) == 278 sizeof((struct gpregs *)0)->gp_a); 279CTASSERT(sizeof(((struct trapframe *)0)->tf_s) == 280 sizeof((struct gpregs *)0)->gp_s); 281CTASSERT(sizeof(((struct trapframe *)0)->tf_t) == 282 sizeof((struct gpregs *)0)->gp_t); 283CTASSERT(sizeof(((struct trapframe *)0)->tf_a) == 284 sizeof((struct reg *)0)->a); 285CTASSERT(sizeof(((struct trapframe *)0)->tf_s) == 286 sizeof((struct reg *)0)->s); 287CTASSERT(sizeof(((struct trapframe *)0)->tf_t) == 288 sizeof((struct reg *)0)->t); 289 290int 291get_mcontext(struct thread *td, mcontext_t *mcp, int clear_ret) 292{ 293 struct trapframe *tf = td->td_frame; 294 295 memcpy(mcp->mc_gpregs.gp_t, tf->tf_t, sizeof(mcp->mc_gpregs.gp_t)); 296 memcpy(mcp->mc_gpregs.gp_s, tf->tf_s, sizeof(mcp->mc_gpregs.gp_s)); 297 memcpy(mcp->mc_gpregs.gp_a, tf->tf_a, sizeof(mcp->mc_gpregs.gp_a)); 298 299 if (clear_ret & GET_MC_CLEAR_RET) { 300 mcp->mc_gpregs.gp_a[0] = 0; 301 mcp->mc_gpregs.gp_t[0] = 0; /* clear syscall error */ 302 } 303 304 mcp->mc_gpregs.gp_ra = tf->tf_ra; 305 mcp->mc_gpregs.gp_sp = tf->tf_sp; 306 mcp->mc_gpregs.gp_gp = tf->tf_gp; 307 mcp->mc_gpregs.gp_tp = tf->tf_tp; 308 mcp->mc_gpregs.gp_sepc = tf->tf_sepc; 309 mcp->mc_gpregs.gp_sstatus = tf->tf_sstatus; 310 311 return (0); 312} 313 314int 315set_mcontext(struct thread *td, mcontext_t *mcp) 316{ 317 struct trapframe *tf; 318 319 tf = td->td_frame; 320 321 memcpy(tf->tf_t, mcp->mc_gpregs.gp_t, sizeof(tf->tf_t)); 322 memcpy(tf->tf_s, mcp->mc_gpregs.gp_s, sizeof(tf->tf_s)); 323 memcpy(tf->tf_a, mcp->mc_gpregs.gp_a, sizeof(tf->tf_a)); 324 325 tf->tf_ra = mcp->mc_gpregs.gp_ra; 326 tf->tf_sp = mcp->mc_gpregs.gp_sp; 327 tf->tf_gp = mcp->mc_gpregs.gp_gp; 328 tf->tf_tp = mcp->mc_gpregs.gp_tp; 329 tf->tf_sepc = mcp->mc_gpregs.gp_sepc; 330 tf->tf_sstatus = mcp->mc_gpregs.gp_sstatus; 331 332 return (0); 333} 334 335static void 336get_fpcontext(struct thread *td, mcontext_t *mcp) 337{ 338 /* TODO */ 339} 340 341static void 342set_fpcontext(struct thread *td, mcontext_t *mcp) 343{ 344 /* TODO */ 345} 346 347void 348cpu_idle(int busy) 349{ 350 351 spinlock_enter(); 352 if (!busy) 353 cpu_idleclock(); 354 if (!sched_runnable()) 355 __asm __volatile( 356 "fence \n" 357 "wfi \n"); 358 if (!busy) 359 cpu_activeclock(); 360 spinlock_exit(); 361} 362 363void 364cpu_halt(void) 365{ 366 367 panic("cpu_halt"); 368} 369 370/* 371 * Flush the D-cache for non-DMA I/O so that the I-cache can 372 * be made coherent later. 373 */ 374void 375cpu_flush_dcache(void *ptr, size_t len) 376{ 377 378 /* TBD */ 379} 380 381/* Get current clock frequency for the given CPU ID. */ 382int 383cpu_est_clockrate(int cpu_id, uint64_t *rate) 384{ 385 386 panic("cpu_est_clockrate"); 387} 388 389void 390cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t size) 391{ 392} 393 394void 395spinlock_enter(void) 396{ 397 struct thread *td; 398 399 td = curthread; 400 if (td->td_md.md_spinlock_count == 0) { 401 td->td_md.md_spinlock_count = 1; 402 td->td_md.md_saved_sstatus_ie = intr_disable(); 403 } else 404 td->td_md.md_spinlock_count++; 405 critical_enter(); 406} 407 408void 409spinlock_exit(void) 410{ 411 struct thread *td; 412 register_t sstatus_ie; 413 414 td = curthread; 415 critical_exit(); 416 sstatus_ie = td->td_md.md_saved_sstatus_ie; 417 td->td_md.md_spinlock_count--; 418 if (td->td_md.md_spinlock_count == 0) 419 intr_restore(sstatus_ie); 420} 421 422#ifndef _SYS_SYSPROTO_H_ 423struct sigreturn_args { 424 ucontext_t *ucp; 425}; 426#endif 427 428int 429sys_sigreturn(struct thread *td, struct sigreturn_args *uap) 430{ 431 uint64_t sstatus; 432 ucontext_t uc; 433 int error; 434 435 if (uap == NULL) 436 return (EFAULT); 437 if (copyin(uap->sigcntxp, &uc, sizeof(uc))) 438 return (EFAULT); 439 440 /* 441 * Make sure the processor mode has not been tampered with and 442 * interrupts have not been disabled. 443 */ 444 sstatus = uc.uc_mcontext.mc_gpregs.gp_sstatus; 445 if ((sstatus & SSTATUS_PS) != 0 || 446 (sstatus & SSTATUS_PIE) == 0) 447 return (EINVAL); 448 449 error = set_mcontext(td, &uc.uc_mcontext); 450 if (error != 0) 451 return (error); 452 453 set_fpcontext(td, &uc.uc_mcontext); 454 455 /* Restore signal mask. */ 456 kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0); 457 458 return (EJUSTRETURN); 459} 460 461/* 462 * Construct a PCB from a trapframe. This is called from kdb_trap() where 463 * we want to start a backtrace from the function that caused us to enter 464 * the debugger. We have the context in the trapframe, but base the trace 465 * on the PCB. The PCB doesn't have to be perfect, as long as it contains 466 * enough for a backtrace. 467 */ 468void 469makectx(struct trapframe *tf, struct pcb *pcb) 470{ 471 472 memcpy(pcb->pcb_t, tf->tf_t, sizeof(tf->tf_t)); 473 memcpy(pcb->pcb_s, tf->tf_s, sizeof(tf->tf_s)); 474 memcpy(pcb->pcb_a, tf->tf_a, sizeof(tf->tf_a)); 475 476 pcb->pcb_ra = tf->tf_ra; 477 pcb->pcb_sp = tf->tf_sp; 478 pcb->pcb_gp = tf->tf_gp; 479 pcb->pcb_tp = tf->tf_tp; 480 pcb->pcb_sepc = tf->tf_sepc; 481} 482 483void 484sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask) 485{ 486 struct sigframe *fp, frame; 487 struct sysentvec *sysent; 488 struct trapframe *tf; 489 struct sigacts *psp; 490 struct thread *td; 491 struct proc *p; 492 int onstack; 493 int code; 494 int sig; 495 496 td = curthread; 497 p = td->td_proc; 498 PROC_LOCK_ASSERT(p, MA_OWNED); 499 500 sig = ksi->ksi_signo; 501 code = ksi->ksi_code; 502 psp = p->p_sigacts; 503 mtx_assert(&psp->ps_mtx, MA_OWNED); 504 505 tf = td->td_frame; 506 onstack = sigonstack(tf->tf_sp); 507 508 CTR4(KTR_SIG, "sendsig: td=%p (%s) catcher=%p sig=%d", td, p->p_comm, 509 catcher, sig); 510 511 /* Allocate and validate space for the signal handler context. */ 512 if ((td->td_pflags & TDP_ALTSTACK) != 0 && !onstack && 513 SIGISMEMBER(psp->ps_sigonstack, sig)) { 514 fp = (struct sigframe *)((uintptr_t)td->td_sigstk.ss_sp + 515 td->td_sigstk.ss_size); 516 } else { 517 fp = (struct sigframe *)td->td_frame->tf_sp; 518 } 519 520 /* Make room, keeping the stack aligned */ 521 fp--; 522 fp = (struct sigframe *)STACKALIGN(fp); 523 524 /* Fill in the frame to copy out */ 525 bzero(&frame, sizeof(frame)); 526 get_mcontext(td, &frame.sf_uc.uc_mcontext, 0); 527 get_fpcontext(td, &frame.sf_uc.uc_mcontext); 528 frame.sf_si = ksi->ksi_info; 529 frame.sf_uc.uc_sigmask = *mask; 530 frame.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) ? 531 ((onstack) ? SS_ONSTACK : 0) : SS_DISABLE; 532 frame.sf_uc.uc_stack = td->td_sigstk; 533 mtx_unlock(&psp->ps_mtx); 534 PROC_UNLOCK(td->td_proc); 535 536 /* Copy the sigframe out to the user's stack. */ 537 if (copyout(&frame, fp, sizeof(*fp)) != 0) { 538 /* Process has trashed its stack. Kill it. */ 539 CTR2(KTR_SIG, "sendsig: sigexit td=%p fp=%p", td, fp); 540 PROC_LOCK(p); 541 sigexit(td, SIGILL); 542 } 543 544 tf->tf_a[0] = sig; 545 tf->tf_a[1] = (register_t)&fp->sf_si; 546 tf->tf_a[2] = (register_t)&fp->sf_uc; 547 548 tf->tf_sepc = (register_t)catcher; 549 tf->tf_sp = (register_t)fp; 550 551 sysent = p->p_sysent; 552 if (sysent->sv_sigcode_base != 0) 553 tf->tf_ra = (register_t)sysent->sv_sigcode_base; 554 else 555 tf->tf_ra = (register_t)(sysent->sv_psstrings - 556 *(sysent->sv_szsigcode)); 557 558 CTR3(KTR_SIG, "sendsig: return td=%p pc=%#x sp=%#x", td, tf->tf_sepc, 559 tf->tf_sp); 560 561 PROC_LOCK(p); 562 mtx_lock(&psp->ps_mtx); 563} 564 565static void 566init_proc0(vm_offset_t kstack) 567{ 568 569 pcpup = &__pcpu[0]; 570 571 proc_linkup0(&proc0, &thread0); 572 thread0.td_kstack = kstack; 573 thread0.td_pcb = (struct pcb *)(thread0.td_kstack) - 1; 574 thread0.td_frame = &proc0_tf; 575 pcpup->pc_curpcb = thread0.td_pcb; 576} 577 578static int 579add_physmap_entry(uint64_t base, uint64_t length, vm_paddr_t *physmap, 580 u_int *physmap_idxp) 581{ 582 u_int i, insert_idx, _physmap_idx; 583 584 _physmap_idx = *physmap_idxp; 585 586 if (length == 0) 587 return (1); 588 589 /* 590 * Find insertion point while checking for overlap. Start off by 591 * assuming the new entry will be added to the end. 592 */ 593 insert_idx = _physmap_idx; 594 for (i = 0; i <= _physmap_idx; i += 2) { 595 if (base < physmap[i + 1]) { 596 if (base + length <= physmap[i]) { 597 insert_idx = i; 598 break; 599 } 600 if (boothowto & RB_VERBOSE) 601 printf( 602 "Overlapping memory regions, ignoring second region\n"); 603 return (1); 604 } 605 } 606 607 /* See if we can prepend to the next entry. */ 608 if (insert_idx <= _physmap_idx && 609 base + length == physmap[insert_idx]) { 610 physmap[insert_idx] = base; 611 return (1); 612 } 613 614 /* See if we can append to the previous entry. */ 615 if (insert_idx > 0 && base == physmap[insert_idx - 1]) { 616 physmap[insert_idx - 1] += length; 617 return (1); 618 } 619 620 _physmap_idx += 2; 621 *physmap_idxp = _physmap_idx; 622 if (_physmap_idx == PHYSMAP_SIZE) { 623 printf( 624 "Too many segments in the physical address map, giving up\n"); 625 return (0); 626 } 627 628 /* 629 * Move the last 'N' entries down to make room for the new 630 * entry if needed. 631 */ 632 for (i = _physmap_idx; i > insert_idx; i -= 2) { 633 physmap[i] = physmap[i - 2]; 634 physmap[i + 1] = physmap[i - 1]; 635 } 636 637 /* Insert the new entry. */ 638 physmap[insert_idx] = base; 639 physmap[insert_idx + 1] = base + length; 640 641 printf("physmap[%d] = 0x%016lx\n", insert_idx, base); 642 printf("physmap[%d] = 0x%016lx\n", insert_idx + 1, base + length); 643 return (1); 644} 645 646#ifdef FDT 647static void 648try_load_dtb(caddr_t kmdp) 649{ 650 vm_offset_t dtbp; 651 652 dtbp = (vm_offset_t)&fdt_static_dtb; 653 if (dtbp == (vm_offset_t)NULL) { 654 printf("ERROR loading DTB\n"); 655 return; 656 } 657 658 if (OF_install(OFW_FDT, 0) == FALSE) 659 panic("Cannot install FDT"); 660 661 if (OF_init((void *)dtbp) != 0) 662 panic("OF_init failed with the found device tree"); 663} 664#endif 665 666static void 667cache_setup(void) 668{ 669 670 /* TODO */ 671} 672 673/* 674 * Fake up a boot descriptor table. 675 * RISCVTODO: This needs to be done via loader (when it's available). 676 */ 677vm_offset_t 678fake_preload_metadata(struct riscv_bootparams *rvbp __unused) 679{ 680#ifdef DDB 681 vm_offset_t zstart = 0, zend = 0; 682#endif 683 vm_offset_t lastaddr; 684 int i = 0; 685 static uint32_t fake_preload[35]; 686 687 fake_preload[i++] = MODINFO_NAME; 688 fake_preload[i++] = strlen("kernel") + 1; 689 strcpy((char*)&fake_preload[i++], "kernel"); 690 i += 1; 691 fake_preload[i++] = MODINFO_TYPE; 692 fake_preload[i++] = strlen("elf64 kernel") + 1; 693 strcpy((char*)&fake_preload[i++], "elf64 kernel"); 694 i += 3; 695 fake_preload[i++] = MODINFO_ADDR; 696 fake_preload[i++] = sizeof(vm_offset_t); 697 fake_preload[i++] = (uint64_t)(KERNBASE + KERNENTRY); 698 i += 1; 699 fake_preload[i++] = MODINFO_SIZE; 700 fake_preload[i++] = sizeof(uint64_t); 701 printf("end is 0x%016lx\n", (uint64_t)&end); 702 fake_preload[i++] = (uint64_t)&end - (uint64_t)(KERNBASE + KERNENTRY); 703 i += 1; 704#ifdef DDB 705#if 0 706 /* RISCVTODO */ 707 if (*(uint32_t *)KERNVIRTADDR == MAGIC_TRAMP_NUMBER) { 708 fake_preload[i++] = MODINFO_METADATA|MODINFOMD_SSYM; 709 fake_preload[i++] = sizeof(vm_offset_t); 710 fake_preload[i++] = *(uint32_t *)(KERNVIRTADDR + 4); 711 fake_preload[i++] = MODINFO_METADATA|MODINFOMD_ESYM; 712 fake_preload[i++] = sizeof(vm_offset_t); 713 fake_preload[i++] = *(uint32_t *)(KERNVIRTADDR + 8); 714 lastaddr = *(uint32_t *)(KERNVIRTADDR + 8); 715 zend = lastaddr; 716 zstart = *(uint32_t *)(KERNVIRTADDR + 4); 717 db_fetch_ksymtab(zstart, zend); 718 } else 719#endif 720#endif 721 lastaddr = (vm_offset_t)&end; 722 fake_preload[i++] = 0; 723 fake_preload[i] = 0; 724 preload_metadata = (void *)fake_preload; 725 726 return (lastaddr); 727} 728 729void 730initriscv(struct riscv_bootparams *rvbp) 731{ 732 struct mem_region mem_regions[FDT_MEM_REGIONS]; 733 vm_offset_t lastaddr; 734 int mem_regions_sz; 735 vm_size_t kernlen; 736 caddr_t kmdp; 737 int i; 738 739 /* Set the module data location */ 740 lastaddr = fake_preload_metadata(rvbp); 741 742 /* Find the kernel address */ 743 kmdp = preload_search_by_type("elf kernel"); 744 if (kmdp == NULL) 745 kmdp = preload_search_by_type("elf64 kernel"); 746 747 boothowto = 0; 748 749 kern_envp = NULL; 750 751#ifdef FDT 752 try_load_dtb(kmdp); 753#endif 754 755 /* Load the physical memory ranges */ 756 physmap_idx = 0; 757 758 /* Grab physical memory regions information from device tree. */ 759 if (fdt_get_mem_regions(mem_regions, &mem_regions_sz, NULL) != 0) 760 panic("Cannot get physical memory regions"); 761 for (i = 0; i < mem_regions_sz; i++) 762 add_physmap_entry(mem_regions[i].mr_start, 763 mem_regions[i].mr_size, physmap, &physmap_idx); 764 765 /* Set the pcpu data, this is needed by pmap_bootstrap */ 766 pcpup = &__pcpu[0]; 767 pcpu_init(pcpup, 0, sizeof(struct pcpu)); 768 769 /* Set the pcpu pointer */ 770 __asm __volatile("mv gp, %0" :: "r"(pcpup)); 771 772 PCPU_SET(curthread, &thread0); 773 774 /* Do basic tuning, hz etc */ 775 init_param1(); 776 777 cache_setup(); 778 779 /* Bootstrap enough of pmap to enter the kernel proper */ 780 kernlen = (lastaddr - KERNBASE); 781 pmap_bootstrap(rvbp->kern_l1pt, KERNENTRY, kernlen); 782 783 cninit(); 784 785 init_proc0(rvbp->kern_stack); 786 787 /* set page table base register for thread0 */ 788 thread0.td_pcb->pcb_l1addr = (rvbp->kern_l1pt - KERNBASE); 789 790 msgbufinit(msgbufp, msgbufsize); 791 mutex_init(); 792 init_param2(physmem); 793 kdb_init(); 794 795 riscv_init_interrupts(); 796 797 early_boot = 0; 798} 799