1 /* $NetBSD: kvm_aarch64.c,v 1.3 2018/04/01 04:35:02 ryo Exp $ */ 2 3 /*- 4 * Copyright (c) 2014 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Matt Thomas of 3am Software Foundry. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/param.h> 33 #include <sys/proc.h> 34 #include <sys/stat.h> 35 #include <sys/kcore.h> 36 #include <sys/types.h> 37 #include <unistd.h> 38 #include <nlist.h> 39 #include <kvm.h> 40 41 #include <machine/kcore.h> 42 #include <machine/pte.h> 43 #include <machine/vmparam.h> 44 45 #include <limits.h> 46 #include <db.h> 47 #include <stdlib.h> 48 49 #include "kvm_private.h" 50 51 __RCSID("$NetBSD: kvm_aarch64.c,v 1.3 2018/04/01 04:35:02 ryo Exp $"); 52 53 /*ARGSUSED*/ 54 void 55 _kvm_freevtop(kvm_t *kd) 56 { 57 return; 58 } 59 60 /*ARGSUSED*/ 61 int 62 _kvm_initvtop(kvm_t *kd) 63 { 64 return (0); 65 } 66 67 int 68 _kvm_kvatop(kvm_t *kd, vaddr_t va, paddr_t *pa) 69 { 70 if (ISALIVE(kd)) { 71 _kvm_err(kd, 0, "vatop called in live kernel!"); 72 return(0); 73 } 74 75 if ((va & AARCH64_KSEG_MASK) != AARCH64_KSEG_START) { 76 /* 77 * Bogus address (not in KV space): punt. 78 */ 79 _kvm_err(kd, 0, "invalid kernel virtual address"); 80 lose: 81 *pa = -1; 82 return 0; 83 } 84 85 const cpu_kcore_hdr_t * const cpu_kh = kd->cpu_data; 86 const u_int tg1 =__SHIFTOUT(cpu_kh->kh_tcr1, TCR_TG1); 87 const u_int t1siz = __SHIFTOUT(cpu_kh->kh_tcr1, TCR_T1SZ); 88 89 /* 90 * Real kernel virtual address: do the translation. 91 */ 92 93 u_int va_bits; 94 u_int page_shift; 95 96 switch (tg1) { 97 case TCR_TG1_4KB: 98 va_bits = t1siz + 36; 99 page_shift = 12; 100 break; 101 case TCR_TG1_16KB: 102 va_bits = 48; 103 page_shift = 14; 104 break; 105 case TCR_TG1_64KB: 106 va_bits = t1siz + 38; 107 page_shift = 16; 108 break; 109 default: 110 goto lose; 111 } 112 113 const size_t page_size = 1 << page_shift; 114 const uint64_t page_mask = (page_size - 1); 115 const uint64_t page_addr = __BITS(47, 0) & ~page_mask; 116 const uint64_t pte_mask = page_mask >> 3; 117 const u_int pte_shift = page_shift - 3; 118 119 /* how many level of page tables do we have? */ 120 u_int level = (48 + page_shift - 1) / page_shift; 121 122 /* restrict va to the valid VA bits */ 123 va &= (1LL << va_bits) - 1; 124 125 u_int addr_shift = page_shift + (level - 1) * pte_shift; 126 127 /* clear out the unused low bits of the table address */ 128 paddr_t pte_addr = (cpu_kh->kh_ttbr1 & TTBR_BADDR); 129 pte_addr &= ~((8L << (va_bits - addr_shift)) - 1); 130 131 for (;;) { 132 pt_entry_t pte; 133 134 /* now index into the pte table */ 135 pte_addr += 8 * ((va >> addr_shift) & pte_mask); 136 137 /* Find and read the PTE. */ 138 if (_kvm_pread(kd, kd->pmfd, &pte, sizeof(pte), 139 _kvm_pa2off(kd, pte_addr)) != sizeof(pte)) { 140 _kvm_syserr(kd, 0, "could not read pte"); 141 goto lose; 142 } 143 144 /* Find and read the L2 PTE. */ 145 if ((pte & LX_VALID) == 0) { 146 _kvm_err(kd, 0, "invalid translation (invalid pte)"); 147 goto lose; 148 } 149 150 if ((pte & LX_TYPE) == LX_TYPE_BLK) { 151 const paddr_t blk_mask = ((1L << addr_shift) - 1); 152 153 *pa = (pte & page_addr & ~blk_mask) | (va & blk_mask); 154 return 0; 155 } 156 157 if (level == page_shift) { 158 *pa = (pte & page_addr) | (va & page_mask); 159 return 0; 160 } 161 162 /* 163 * Read next level of page table 164 */ 165 166 pte_addr = pte & page_addr; 167 addr_shift -= pte_shift; 168 } 169 } 170 171 /* 172 * Translate a physical address to a file-offset in the crash dump. 173 */ 174 off_t 175 _kvm_pa2off(kvm_t *kd, paddr_t pa) 176 { 177 const cpu_kcore_hdr_t * const cpu_kh = kd->cpu_data; 178 off_t off = 0; 179 180 for (const phys_ram_seg_t *ramsegs = cpu_kh->kh_ramsegs; 181 ramsegs->size != 0; ramsegs++) { 182 if (pa >= ramsegs->start 183 && pa < ramsegs->start + ramsegs->size) { 184 off += pa - ramsegs->start; 185 break; 186 } 187 off += ramsegs->size; 188 } 189 190 return kd->dump_off + off; 191 } 192 193 /* 194 * Machine-dependent initialization for ALL open kvm descriptors, 195 * not just those for a kernel crash dump. Some architectures 196 * have to deal with these NOT being constants! (i.e. m68k) 197 */ 198 int 199 _kvm_mdopen(kvm_t *kd) 200 { 201 202 kd->usrstack = USRSTACK; 203 kd->min_uva = VM_MIN_ADDRESS; 204 kd->max_uva = VM_MAXUSER_ADDRESS; 205 206 return (0); 207 } 208