1 /* $OpenBSD: kvm_sparc64.c,v 1.14 2024/04/11 18:58:44 miod Exp $ */
2 /* $NetBSD: kvm_sparc64.c,v 1.7 2001/08/05 03:33:15 matt Exp $ */
3
4 /*-
5 * Copyright (c) 1992, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * This code is derived from software developed by the Computer Systems
9 * Engineering group at Lawrence Berkeley Laboratory under DARPA contract
10 * BG 91-66 and contributed to Berkeley.
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. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37 /*
38 * Sparc machine dependent routines for kvm. Hopefully, the forthcoming
39 * vm code will one day obsolete this module.
40 */
41
42 #include <sys/types.h>
43 #include <sys/signal.h>
44 #include <sys/exec.h>
45 #include <sys/proc.h>
46 #include <sys/stat.h>
47 #include <sys/kcore.h>
48 #include <unistd.h>
49 #include <nlist.h>
50 #include <kvm.h>
51
52 #include <uvm/uvm_extern.h>
53
54 #include <machine/param.h>
55 #include <machine/vmparam.h>
56 #include <machine/pte.h>
57 #include <machine/kcore.h>
58
59 #include <limits.h>
60 #include <db.h>
61
62 #include "kvm_private.h"
63
64 /*
65 * UltraSPARC T1 & T2 implement only a 40-bit real address range, just
66 * like older UltraSPARC CPUs.
67 */
68 #define TLB_PA_MASK SUN4U_TLB_PA_MASK
69
70 int _kvm_kvatop(kvm_t *, u_long, u_long *);
71
72 void
_kvm_freevtop(kvm_t * kd)73 _kvm_freevtop(kvm_t *kd)
74 {
75 if (kd->vmst != NULL) {
76 _kvm_err(kd, kd->program, "_kvm_freevtop: internal error");
77 kd->vmst = NULL;
78 }
79 }
80
81 /*
82 * Prepare for translation of kernel virtual addresses into offsets
83 * into crash dump files. We use the MMU specific goop written at the
84 * front of the crash dump by pmap_dumpmmu().
85 *
86 * We should read in and cache the ksegs here to speed up operations...
87 */
88 int
_kvm_initvtop(kvm_t * kd)89 _kvm_initvtop(kvm_t *kd)
90 {
91 return (0);
92 }
93
94 /*
95 * Translate a kernel virtual address to a physical address using the
96 * mapping information in kd->vm. Returns the result in pa, and returns
97 * the number of bytes that are contiguously available from this
98 * physical address. This routine is used only for crashdumps.
99 */
100 int
_kvm_kvatop(kvm_t * kd,u_long va,paddr_t * pa)101 _kvm_kvatop(kvm_t *kd, u_long va, paddr_t *pa)
102 {
103 cpu_kcore_hdr_t *cpup = kd->cpu_data;
104 u_long kernbase = cpup->kernbase;
105 uint64_t *pseg, *pdir, *ptbl;
106 int64_t data;
107
108 if (va < kernbase)
109 goto lose;
110
111 /* Handle the wired 4MB TTEs */
112 if (va > cpup->ktextbase && va < (cpup->ktextbase + cpup->ktextsz)) {
113 u_long vaddr;
114
115 vaddr = va - cpup->ktextbase;
116 *pa = cpup->ktextp + vaddr;
117 return (cpup->ktextsz - vaddr);
118 }
119
120 if (va > cpup->kdatabase && va < (cpup->kdatabase + cpup->kdatasz)) {
121 u_long vaddr;
122
123 vaddr = va - cpup->kdatabase;
124 *pa = cpup->kdatap + vaddr;
125 return (cpup->kdatasz - vaddr);
126 }
127
128
129 /*
130 * Parse kernel page table.
131 */
132 pseg = (uint64_t *)(u_long)cpup->segmapoffset;
133 if (pread(kd->pmfd, &pdir, sizeof(pdir),
134 _kvm_pa2off(kd, (u_long)&pseg[va_to_seg(va)])) != sizeof(pdir)) {
135 _kvm_syserr(kd, 0, "could not read L1 PTE");
136 goto lose;
137 }
138
139 if (!pdir) {
140 _kvm_err(kd, 0, "invalid L1 PTE");
141 goto lose;
142 }
143
144 if (pread(kd->pmfd, &ptbl, sizeof(ptbl),
145 _kvm_pa2off(kd, (u_long)&pdir[va_to_dir(va)])) != sizeof(ptbl)) {
146 _kvm_syserr(kd, 0, "could not read L2 PTE");
147 goto lose;
148 }
149
150 if (!ptbl) {
151 _kvm_err(kd, 0, "invalid L2 PTE");
152 goto lose;
153 }
154
155 if (pread(kd->pmfd, &data, sizeof(data),
156 _kvm_pa2off(kd, (u_long)&ptbl[va_to_pte(va)])) != sizeof(data)) {
157 _kvm_syserr(kd, 0, "could not read TTE");
158 goto lose;
159 }
160
161 if (data >= 0) {
162 _kvm_err(kd, 0, "invalid L2 TTE");
163 goto lose;
164 }
165
166 /*
167 * Calculate page offsets and things.
168 *
169 * XXXX -- We could support multiple page sizes.
170 */
171 va = va & (kd->nbpg - 1);
172 data &= TLB_PA_MASK;
173 *pa = data + va;
174
175 /*
176 * Parse and translate our TTE.
177 */
178 return (kd->nbpg - va);
179
180 lose:
181 *pa = -1;
182 _kvm_err(kd, 0, "invalid address (%lx)", va);
183 return (0);
184 }
185
186
187 /*
188 * Translate a physical address to a file-offset in the crash-dump.
189 */
190 off_t
_kvm_pa2off(kvm_t * kd,paddr_t pa)191 _kvm_pa2off(kvm_t *kd, paddr_t pa)
192 {
193 cpu_kcore_hdr_t *cpup = kd->cpu_data;
194 phys_ram_seg_t *mp;
195 off_t off;
196 int nmem;
197
198 /*
199 * Layout of CPU segment:
200 * cpu_kcore_hdr_t;
201 * [alignment]
202 * phys_ram_seg_t[cpup->nmemseg];
203 */
204 mp = (phys_ram_seg_t *)((long)kd->cpu_data + cpup->memsegoffset);
205 off = 0;
206
207 /* Translate (sparse) pfnum to (packed) dump offset */
208 for (nmem = cpup->nmemseg; --nmem >= 0; mp++) {
209 if (mp->start <= pa && pa < mp->start + mp->size)
210 break;
211 off += mp->size;
212 }
213 if (nmem < 0) {
214 _kvm_err(kd, 0, "invalid address (%lx)", pa);
215 return (-1);
216 }
217
218 return (kd->dump_off + off + pa - mp->start);
219 }
220