1 /* $NetBSD: pmap.c,v 1.58 2023/09/09 18:27:59 ad Exp $ */
2
3 /*
4 * Copyright (c) 2002, 2003, 2020, 2023 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Brown.
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/cdefs.h>
33 #ifndef lint
34 __RCSID("$NetBSD: pmap.c,v 1.58 2023/09/09 18:27:59 ad Exp $");
35 #endif
36
37 #include <string.h>
38 #include <util.h>
39
40 #include "pmap.h"
41 #include "main.h"
42
43 static void dump_vm_anon(kvm_t *, struct vm_anon **, int);
44 static char *findname(kvm_t *, struct kbit *, struct kbit *, struct kbit *,
45 struct kbit *, struct kbit *);
46 static int search_cache(kvm_t *, struct vnode *, char **, char *, size_t);
47
48 /* when recursing or printing tree, output is indented */
49 #define indent(n) ((n) * ((recurse > 1 ? recurse - 1 : 0)) + depth)
50 #define rwx (VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
51 static int depth;
52
53 int heapfound;
54
55 void
process_map(kvm_t * kd,struct kinfo_proc2 * proc,struct kbit * vmspace,const char * thing)56 process_map(kvm_t *kd, struct kinfo_proc2 *proc,
57 struct kbit *vmspace, const char *thing)
58 {
59 struct kbit kbit, *vm_map = &kbit;
60
61 if (proc) {
62 heapfound = 0;
63 A(vmspace) = (u_long)proc->p_vmspace;
64 S(vmspace) = sizeof(struct vmspace);
65 thing = "proc->p_vmspace.vm_map";
66 } else if (S(vmspace) == (size_t)-1) {
67 heapfound = 0;
68 /* A(vmspace) set by caller */
69 S(vmspace) = sizeof(struct vmspace);
70 /* object identified by caller */
71 } else {
72 heapfound = 1; /* but really, do kernels have a heap? */
73 A(vmspace) = 0;
74 S(vmspace) = 0;
75 thing = "kernel_map";
76 }
77
78 S(vm_map) = sizeof(struct vm_map);
79
80 if (S(vmspace) != 0) {
81 KDEREF(kd, vmspace);
82 A(vm_map) = A(vmspace) + offsetof(struct vmspace, vm_map);
83 memcpy(D(vm_map, vm_map), &D(vmspace, vmspace)->vm_map,
84 S(vm_map));
85 } else {
86 memset(vmspace, 0, sizeof(*vmspace));
87 A(vm_map) = kernel_map_addr;
88 KDEREF(kd, vm_map);
89 }
90
91 dump_vm_map(kd, proc, vmspace, vm_map, thing);
92 }
93
94 void
dump_vm_map(kvm_t * kd,struct kinfo_proc2 * proc,struct kbit * vmspace,struct kbit * vm_map,const char * mname)95 dump_vm_map(kvm_t *kd, struct kinfo_proc2 *proc,
96 struct kbit *vmspace, struct kbit *vm_map, const char *mname)
97 {
98 struct kbit kbit[2], *header, *vm_map_entry;
99 size_t total;
100
101 if (S(vm_map) == (size_t)-1) {
102 heapfound = 1;
103 S(vm_map) = sizeof(struct vm_map);
104 KDEREF(kd, vm_map);
105 }
106
107 header = &kbit[0];
108 vm_map_entry = &kbit[1];
109 A(header) = 0;
110 A(vm_map_entry) = 0;
111
112 A(header) = A(vm_map) + offsetof(struct vm_map, header);
113 S(header) = sizeof(struct vm_map_entry);
114 memcpy(D(header, vm_map_entry), &D(vm_map, vm_map)->header, S(header));
115
116 if (S(vmspace) != 0 && (debug & PRINT_VMSPACE)) {
117 printf("proc->p_vmspace %p = {", P(vmspace));
118 printf(" vm_refcnt = %d,", D(vmspace, vmspace)->vm_refcnt);
119 printf(" vm_shm = %p,\n", D(vmspace, vmspace)->vm_shm);
120 printf(" vm_rssize = %d,", D(vmspace, vmspace)->vm_rssize);
121 printf(" vm_rssmax = %d,", D(vmspace, vmspace)->vm_rssmax);
122 printf(" vm_tsize = %d,", D(vmspace, vmspace)->vm_tsize);
123 printf(" vm_dsize = %d,\n", D(vmspace, vmspace)->vm_dsize);
124 printf(" vm_ssize = %d,", D(vmspace, vmspace)->vm_ssize);
125 printf(" vm_taddr = %p,", D(vmspace, vmspace)->vm_taddr);
126 printf(" vm_daddr = %p,\n", D(vmspace, vmspace)->vm_daddr);
127 printf(" vm_maxsaddr = %p,",
128 D(vmspace, vmspace)->vm_maxsaddr);
129 printf(" vm_minsaddr = %p,\n",
130 D(vmspace, vmspace)->vm_minsaddr);
131 printf(" vm_aslr_delta_mmap = %#zx }\n",
132 D(vmspace, vmspace)->vm_aslr_delta_mmap);
133 }
134
135 if (debug & PRINT_VM_MAP) {
136 printf("%*s%s %p = {", indent(2), "", mname, P(vm_map));
137 printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap);
138 printf("%*s lock = <struct lock>,", indent(2), "");
139 printf(" header = <struct vm_map_entry>,");
140 printf(" nentries = %d,\n", D(vm_map, vm_map)->nentries);
141 printf("%*s size = %#"PRIxVSIZE",", indent(2), "",
142 D(vm_map, vm_map)->size);
143 printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count);
144 printf("%*s hint = %p,", indent(2), "",
145 D(vm_map, vm_map)->hint);
146 printf("%*s first_free = %p,", indent(2), "",
147 D(vm_map, vm_map)->first_free);
148 printf(" flags = %#x <%s%s%s%s%s >,\n", D(vm_map, vm_map)->flags,
149 D(vm_map, vm_map)->flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "",
150 D(vm_map, vm_map)->flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "",
151 #ifdef VM_MAP_DYING
152 D(vm_map, vm_map)->flags & VM_MAP_DYING ? " DYING" :
153 #endif
154 "",
155 #ifdef VM_MAP_TOPDOWN
156 D(vm_map, vm_map)->flags & VM_MAP_TOPDOWN ? " TOPDOWN" :
157 #endif
158 "",
159 #ifdef VM_MAP_WANTVA
160 D(vm_map, vm_map)->flags & VM_MAP_WANTVA ? " WANTVA" :
161 #endif
162 "");
163 printf("%*s timestamp = %u }\n", indent(2), "",
164 D(vm_map, vm_map)->timestamp);
165 }
166 if (print_ddb) {
167 const char *name = mapname(P(vm_map));
168
169 printf("%*s%s %p: [%#"PRIxVADDR"->%#"PRIxVADDR"]\n", indent(2), "",
170 recurse < 2 ? "MAP" : "SUBMAP", P(vm_map),
171 vm_map_min(D(vm_map, vm_map)),
172 vm_map_max(D(vm_map, vm_map)));
173 printf("\t%*s#ent=%d, sz=%"PRIxVSIZE", ref=%d, version=%d, flags=%#x\n",
174 indent(2), "", D(vm_map, vm_map)->nentries,
175 D(vm_map, vm_map)->size, D(vm_map, vm_map)->ref_count,
176 D(vm_map, vm_map)->timestamp, D(vm_map, vm_map)->flags);
177 printf("\t%*spmap=%p(resident=<unknown>)\n", indent(2), "",
178 D(vm_map, vm_map)->pmap);
179 if (verbose && name != NULL)
180 printf("\t%*s([ %s ])\n", indent(2), "", name);
181 }
182
183 dump_vm_map_entry(kd, proc, vmspace, header, 1);
184
185 /*
186 * we're not recursing into a submap, so print headers
187 */
188 if (recurse < 2) {
189 /* headers */
190 #ifdef DISABLED_HEADERS
191 if (print_map)
192 printf("%-*s %-*s rwx RWX CPY NCP I W A\n",
193 (int)sizeof(long) * 2 + 2, "Start",
194 (int)sizeof(long) * 2 + 2, "End");
195 if (print_maps)
196 printf("%-*s %-*s rwxp %-*s Dev Inode File\n",
197 (int)sizeof(long) * 2 + 0, "Start",
198 (int)sizeof(long) * 2 + 0, "End",
199 (int)sizeof(long) * 2 + 0, "Offset");
200 if (print_solaris)
201 printf("%-*s %*s Protection File\n",
202 (int)sizeof(long) * 2 + 0, "Start",
203 (int)sizeof(int) * 2 - 1, "Size ");
204 #endif
205 if (print_all)
206 printf("%-*s %-*s %*s %-*s rwxpc RWX I/W/A Dev %*s"
207 " - File\n",
208 (int)sizeof(long) * 2, "Start",
209 (int)sizeof(long) * 2, "End",
210 (int)sizeof(int) * 2, "Size ",
211 (int)sizeof(long) * 2, "Offset",
212 (int)sizeof(int) * 2, "Inode");
213 }
214
215 /* these are the "sub entries" */
216 if (tree)
217 total = dump_vm_map_tree(kd, proc, vmspace,
218 vm_map, vm_map_entry);
219 else
220 total = dump_vm_map_list(kd, proc, vmspace,
221 header, vm_map_entry);
222
223 /*
224 * we're not recursing into a submap, so print totals
225 */
226 if (recurse < 2) {
227 if (print_solaris)
228 printf("%-*s %8luK\n",
229 (int)sizeof(void *) * 2 - 2, " total",
230 (unsigned long)total);
231 if (print_all)
232 printf("%-*s %9luk\n",
233 (int)sizeof(void *) * 4 - 1, " total",
234 (unsigned long)total);
235 }
236 }
237
238 size_t
dump_vm_map_node(kvm_t * kd,int lvl,struct kinfo_proc2 * proc,struct kbit * vmspace,struct kbit * vm_map_entry,struct vm_map_entry * node)239 dump_vm_map_node(kvm_t *kd, int lvl, struct kinfo_proc2 *proc,
240 struct kbit *vmspace, struct kbit *vm_map_entry,
241 struct vm_map_entry *node)
242 {
243 struct vm_map_entry *left, *right;
244 size_t total;
245 u_long addr;
246
247 if (node == NULL)
248 return 0;
249
250 total = 0;
251 addr = (u_long)node;
252 A(vm_map_entry) = addr;
253 S(vm_map_entry) = sizeof(struct vm_map_entry);
254 KDEREF(kd, vm_map_entry);
255
256 left = (struct vm_map_entry *)D(vm_map_entry, vm_map_entry)->rb_node.rb_left;
257 right = (struct vm_map_entry *)D(vm_map_entry, vm_map_entry)->rb_node.rb_right;
258
259 total += dump_vm_map_entry(kd, proc, vmspace, vm_map_entry, 0);
260
261 depth += 2;
262
263 total += dump_vm_map_node(kd, lvl+1, proc, vmspace, vm_map_entry, left);
264 total += dump_vm_map_node(kd, lvl+1, proc, vmspace, vm_map_entry, right);
265
266 depth -= 2;
267
268 return total;
269 }
270
271 size_t
dump_vm_map_tree(kvm_t * kd,struct kinfo_proc2 * proc,struct kbit * vmspace,struct kbit * vm_map,struct kbit * vm_map_entry)272 dump_vm_map_tree(kvm_t *kd, struct kinfo_proc2 *proc,
273 struct kbit *vmspace, struct kbit *vm_map, struct kbit *vm_map_entry)
274 {
275 struct vm_map_entry *root;
276 u_long addr;
277
278 /* these are the "sub entries" */
279 root = (struct vm_map_entry *)D(vm_map, vm_map)->rb_tree.rbt_root;
280
281 addr = (u_long)root;
282 A(vm_map_entry) = addr;
283 S(vm_map_entry) = sizeof(struct vm_map_entry);
284 KDEREF(kd, vm_map_entry);
285
286 depth = 0;
287
288 return dump_vm_map_node(kd, 0, proc, vmspace, vm_map_entry, root);
289 }
290
291 size_t
dump_vm_map_list(kvm_t * kd,struct kinfo_proc2 * proc,struct kbit * vmspace,struct kbit * header,struct kbit * vm_map_entry)292 dump_vm_map_list(kvm_t *kd, struct kinfo_proc2 *proc,
293 struct kbit *vmspace, struct kbit *header, struct kbit *vm_map_entry)
294 {
295 struct vm_map_entry *last, *next;
296 size_t total;
297 u_long addr, end;
298
299 total = 0;
300 next = D(header, vm_map_entry)->next;
301 last = P(header);
302 end = 0;
303
304 while (next != 0 && next != last) {
305 addr = (u_long)next;
306 A(vm_map_entry) = addr;
307 S(vm_map_entry) = sizeof(struct vm_map_entry);
308 KDEREF(kd, vm_map_entry);
309 next = D(vm_map_entry, vm_map_entry)->next;
310
311 if (end == 0)
312 end = D(vm_map_entry, vm_map_entry)->start;
313 else if (verbose > 1 &&
314 end != D(vm_map_entry, vm_map_entry)->start)
315 printf("%*s[%lu pages / %luK]\n", indent(2), "",
316 (D(vm_map_entry, vm_map_entry)->start - end) /
317 page_size,
318 (D(vm_map_entry, vm_map_entry)->start - end) /
319 1024);
320 total += dump_vm_map_entry(kd, proc, vmspace, vm_map_entry, 0);
321
322 end = D(vm_map_entry, vm_map_entry)->end;
323 }
324
325 return total;
326 }
327
328 size_t
dump_vm_map_entry(kvm_t * kd,struct kinfo_proc2 * proc,struct kbit * vmspace,struct kbit * vm_map_entry,int ishead)329 dump_vm_map_entry(kvm_t *kd, struct kinfo_proc2 *proc, struct kbit *vmspace,
330 struct kbit *vm_map_entry, int ishead)
331 {
332 struct kbit kbit[3];
333 struct kbit *uvm_obj, *vp, *vfs;
334 struct vm_map_entry *vme;
335 size_t sz;
336 char *name;
337 dev_t dev;
338 ino_t inode;
339
340 if (S(vm_map_entry) == (size_t)-1) {
341 heapfound = 1;
342 S(vm_map_entry) = sizeof(struct vm_map_entry);
343 KDEREF(kd, vm_map_entry);
344 }
345
346 uvm_obj = &kbit[0];
347 vp = &kbit[1];
348 vfs = &kbit[2];
349
350 A(uvm_obj) = 0;
351 A(vp) = 0;
352 A(vfs) = 0;
353
354 vme = D(vm_map_entry, vm_map_entry);
355
356 if ((ishead && (debug & PRINT_VM_MAP_HEADER)) ||
357 (!ishead && (debug & PRINT_VM_MAP_ENTRY))) {
358 printf("%*s%s %p = {", indent(2), "",
359 ishead ? "vm_map.header" : "vm_map_entry",
360 P(vm_map_entry));
361 printf(" prev = %p,", vme->prev);
362 printf(" next = %p,\n", vme->next);
363 printf("%*s start = %#"PRIxVADDR",", indent(2), "", vme->start);
364 printf(" end = %#"PRIxVADDR",", vme->end);
365 printf(" object.uvm_obj/sub_map = %p,\n", vme->object.uvm_obj);
366 printf("%*s gap = %#"PRIxVSIZE",", indent(2), "", vme->gap);
367 printf(" maxgap = %#"PRIxVSIZE",\n", vme->maxgap);
368 printf("%*s offset = %" PRIx64 ",", indent(2), "",
369 vme->offset);
370 printf(" etype = %#x <%s%s%s%s >,", vme->etype,
371 UVM_ET_ISOBJ(vme) ? " OBJ" : "",
372 UVM_ET_ISSUBMAP(vme) ? " SUBMAP" : "",
373 UVM_ET_ISCOPYONWRITE(vme) ? " COW" : "",
374 UVM_ET_ISNEEDSCOPY(vme) ? " NEEDSCOPY" : "");
375 printf(" protection = %#x,\n", vme->protection);
376 printf("%*s max_protection = %#x,", indent(2), "",
377 vme->max_protection);
378 printf(" inheritance = %d,", vme->inheritance);
379 printf(" wired_count = %d,\n", vme->wired_count);
380 printf("%*s aref = { ar_pageoff = %#x, ar_amap = %p },",
381 indent(2), "", vme->aref.ar_pageoff, vme->aref.ar_amap);
382 printf(" advice = %d,\n", vme->advice);
383 printf("%*s flags = %#x <%s%s%s > }\n", indent(2), "",
384 vme->flags,
385 vme->flags & UVM_MAP_KERNEL ? " KERNEL" : "",
386 vme->flags & UVM_MAP_STATIC ? " STATIC" : "",
387 vme->flags & UVM_MAP_NOMERGE ? " NOMERGE" : "");
388 }
389
390 if ((debug & PRINT_VM_AMAP) && (vme->aref.ar_amap != NULL)) {
391 struct kbit akbit, *amap;
392
393 amap = &akbit;
394 P(amap) = vme->aref.ar_amap;
395 S(amap) = sizeof(struct vm_amap);
396 KDEREF(kd, amap);
397 dump_amap(kd, amap);
398 }
399
400 if (ishead)
401 return (0);
402
403 A(vp) = 0;
404 A(uvm_obj) = 0;
405
406 if (vme->object.uvm_obj != NULL) {
407 P(uvm_obj) = vme->object.uvm_obj;
408 S(uvm_obj) = sizeof(struct uvm_object);
409 KDEREF(kd, uvm_obj);
410 if (UVM_ET_ISOBJ(vme) &&
411 UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) {
412 P(vp) = P(uvm_obj);
413 S(vp) = sizeof(struct vnode);
414 KDEREF(kd, vp);
415 }
416 }
417
418 A(vfs) = 0;
419
420 if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) {
421 P(vfs) = D(vp, vnode)->v_mount;
422 S(vfs) = sizeof(struct mount);
423 KDEREF(kd, vfs);
424 D(vp, vnode)->v_mount = D(vfs, mount);
425 }
426
427 /*
428 * dig out the device number and inode number from certain
429 * file system types.
430 */
431 #define V_DATA_IS(vp, type, d, i) do { \
432 struct kbit data; \
433 P(&data) = D(vp, vnode)->v_data; \
434 S(&data) = sizeof(*D(&data, type)); \
435 KDEREF(kd, &data); \
436 dev = D(&data, type)->d; \
437 inode = D(&data, type)->i; \
438 } while (0/*CONSTCOND*/)
439
440 dev = 0;
441 inode = 0;
442
443 if (A(vp) &&
444 D(vp, vnode)->v_type == VREG &&
445 D(vp, vnode)->v_data != NULL) {
446 switch (D(vp, vnode)->v_tag) {
447 case VT_UFS:
448 case VT_LFS:
449 case VT_EXT2FS:
450 V_DATA_IS(vp, inode, i_dev, i_number);
451 break;
452 case VT_ISOFS:
453 V_DATA_IS(vp, iso_node, i_dev, i_number);
454 break;
455 default:
456 break;
457 }
458 }
459
460 name = findname(kd, vmspace, vm_map_entry, vp, vfs, uvm_obj);
461
462 if (print_map) {
463 printf("%*s%#"PRIxVADDR" %#"PRIxVADDR" %c%c%c %c%c%c %s %s %d %d %d",
464 indent(2), "",
465 vme->start, vme->end,
466 (vme->protection & VM_PROT_READ) ? 'r' : '-',
467 (vme->protection & VM_PROT_WRITE) ? 'w' : '-',
468 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-',
469 (vme->max_protection & VM_PROT_READ) ? 'r' : '-',
470 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-',
471 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-',
472 UVM_ET_ISCOPYONWRITE(vme) ? "COW" : "NCOW",
473 UVM_ET_ISNEEDSCOPY(vme) ? "NC" : "NNC",
474 vme->inheritance, vme->wired_count,
475 vme->advice);
476 if (verbose) {
477 if (inode)
478 printf(" %llu,%llu %llu",
479 (unsigned long long)major(dev),
480 (unsigned long long)minor(dev),
481 (unsigned long long)inode);
482 if (name[0])
483 printf(" %s", name);
484 }
485 printf("\n");
486 }
487
488 if (print_maps) {
489 printf("%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %c%c%c%c %0*" PRIx64 " %02llx:%02llx %llu %s\n",
490 indent(2), "",
491 (int)sizeof(void *) * 2, vme->start,
492 (int)sizeof(void *) * 2, vme->end,
493 (vme->protection & VM_PROT_READ) ? 'r' : '-',
494 (vme->protection & VM_PROT_WRITE) ? 'w' : '-',
495 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-',
496 UVM_ET_ISCOPYONWRITE(vme) ? 'p' : 's',
497 (int)sizeof(void *) * 2,
498 vme->offset,
499 (unsigned long long)major(dev),
500 (unsigned long long)minor(dev),
501 (unsigned long long)inode,
502 (name[0] != ' ') || verbose ? name : "");
503 }
504
505 if (print_ddb) {
506 printf("%*s - %p: %#"PRIxVADDR"->%#"PRIxVADDR": obj=%p/%#" PRIx64 ", amap=%p/%d\n",
507 indent(2), "",
508 P(vm_map_entry), vme->start, vme->end,
509 vme->object.uvm_obj, vme->offset,
510 vme->aref.ar_amap, vme->aref.ar_pageoff);
511 printf("\t%*ssubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, "
512 "wc=%d, adv=%d\n",
513 indent(2), "",
514 UVM_ET_ISSUBMAP(vme) ? 'T' : 'F',
515 UVM_ET_ISCOPYONWRITE(vme) ? 'T' : 'F',
516 UVM_ET_ISNEEDSCOPY(vme) ? 'T' : 'F',
517 vme->protection, vme->max_protection,
518 vme->inheritance, vme->wired_count, vme->advice);
519 if (verbose) {
520 printf("\t%*s", indent(2), "");
521 if (inode)
522 printf("(dev=%llu,%llu ino=%llu [%s] [%p])\n",
523 (unsigned long long)major(dev),
524 (unsigned long long)minor(dev),
525 (unsigned long long)inode, name, P(vp));
526 else if (name[0] == ' ')
527 printf("(%s)\n", &name[2]);
528 else
529 printf("(%s)\n", name);
530 }
531 }
532
533 sz = 0;
534 if (print_solaris) {
535 char prot[30];
536
537 prot[0] = '\0';
538 prot[1] = '\0';
539 if (vme->protection & VM_PROT_READ)
540 strlcat(prot, "/read", sizeof(prot));
541 if (vme->protection & VM_PROT_WRITE)
542 strlcat(prot, "/write", sizeof(prot));
543 if (vme->protection & VM_PROT_EXECUTE)
544 strlcat(prot, "/exec", sizeof(prot));
545
546 sz = (size_t)((vme->end - vme->start) / 1024);
547 printf("%*s%0*lX %6luK %-15s %s\n",
548 indent(2), "",
549 (int)sizeof(void *) * 2,
550 (unsigned long)vme->start,
551 (unsigned long)sz,
552 &prot[1],
553 name);
554 }
555
556 if (print_all) {
557 sz = (size_t)((vme->end - vme->start) / 1024);
558 printf("%*s%0*"PRIxVADDR"-%0*"PRIxVADDR" %7luk %0*" PRIx64 " %c%c%c%c%c (%c%c%c) %d/%d/%d %02llu:%02llu %7llu - %s\n",
559 indent(2), "",
560 (int)sizeof(void *) * 2,
561 vme->start,
562 (int)sizeof(void *) * 2,
563 vme->end - (vme->start != vme->end ? 1 : 0),
564 (unsigned long)sz,
565 (int)sizeof(void *) * 2,
566 vme->offset,
567 (vme->protection & VM_PROT_READ) ? 'r' : '-',
568 (vme->protection & VM_PROT_WRITE) ? 'w' : '-',
569 (vme->protection & VM_PROT_EXECUTE) ? 'x' : '-',
570 UVM_ET_ISCOPYONWRITE(vme) ? 'p' : 's',
571 UVM_ET_ISNEEDSCOPY(vme) ? '+' : '-',
572 (vme->max_protection & VM_PROT_READ) ? 'r' : '-',
573 (vme->max_protection & VM_PROT_WRITE) ? 'w' : '-',
574 (vme->max_protection & VM_PROT_EXECUTE) ? 'x' : '-',
575 vme->inheritance,
576 vme->wired_count,
577 vme->advice,
578 (unsigned long long)major(dev),
579 (unsigned long long)minor(dev),
580 (unsigned long long)inode,
581 name);
582 }
583
584 /* no access allowed, don't count space */
585 if ((vme->protection & rwx) == 0)
586 sz = 0;
587
588 if (recurse && UVM_ET_ISSUBMAP(vme)) {
589 struct kbit mkbit, *submap;
590
591 recurse++;
592 submap = &mkbit;
593 P(submap) = vme->object.sub_map;
594 S(submap) = sizeof(*vme->object.sub_map);
595 KDEREF(kd, submap);
596 dump_vm_map(kd, proc, vmspace, submap, "submap");
597 recurse--;
598 }
599
600 return (sz);
601 }
602
603 void
dump_amap(kvm_t * kd,struct kbit * amap)604 dump_amap(kvm_t *kd, struct kbit *amap)
605 {
606 struct vm_anon **am_anon;
607 int *am_slots;
608 int *am_bckptr;
609 int *am_ppref;
610 size_t l;
611 int i, r, e;
612
613 if (S(amap) == (size_t)-1) {
614 heapfound = 1;
615 S(amap) = sizeof(struct vm_amap);
616 KDEREF(kd, amap);
617 }
618
619 printf("%*s amap %p = { am_ref = %d, "
620 "am_flags = %#x,\n"
621 "%*s am_maxslot = %d, am_nslot = %d, am_nused = %d, "
622 "am_slots = %p,\n"
623 "%*s am_bckptr = %p, am_anon = %p, am_ppref = %p }\n",
624 indent(2), "",
625 P(amap),
626 D(amap, amap)->am_ref,
627 D(amap, amap)->am_flags,
628 indent(2), "",
629 D(amap, amap)->am_maxslot,
630 D(amap, amap)->am_nslot,
631 D(amap, amap)->am_nused,
632 D(amap, amap)->am_slots,
633 indent(2), "",
634 D(amap, amap)->am_bckptr,
635 D(amap, amap)->am_anon,
636 D(amap, amap)->am_ppref);
637
638 if (!(debug & DUMP_VM_AMAP_DATA))
639 return;
640
641 /*
642 * Assume that sizeof(struct vm_anon *) >= sizeof(size_t) and
643 * allocate that amount of space.
644 */
645 am_anon = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_anon));
646 l = D(amap, amap)->am_maxslot * sizeof(*am_anon);
647 _KDEREF(kd, (u_long)D(amap, amap)->am_anon, am_anon, l);
648
649 l = D(amap, amap)->am_maxslot * sizeof(*am_bckptr);
650 am_bckptr = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_bckptr));
651 _KDEREF(kd, (u_long)D(amap, amap)->am_bckptr, am_bckptr, l);
652
653 l = D(amap, amap)->am_maxslot * sizeof(*am_slots);
654 am_slots = ecalloc(D(amap, amap)->am_maxslot, sizeof(*am_slots));
655 _KDEREF(kd, (u_long)D(amap, amap)->am_slots, am_slots, l);
656
657 if (D(amap, amap)->am_ppref != NULL &&
658 D(amap, amap)->am_ppref != PPREF_NONE) {
659 am_ppref = ecalloc(
660 D(amap, amap)->am_maxslot, sizeof(*am_ppref));
661 l = D(amap, amap)->am_maxslot * sizeof(*am_ppref);
662 _KDEREF(kd, (u_long)D(amap, amap)->am_ppref, am_ppref, l);
663 } else {
664 am_ppref = NULL;
665 }
666
667 printf(" page# %9s %8s", "am_bckptr", "am_slots");
668 if (am_ppref)
669 printf(" %8s ", "am_ppref");
670 printf(" %10s\n", "am_anon");
671
672 l = r = 0;
673 e = verbose > 1 ? D(amap, amap)->am_maxslot : D(amap, amap)->am_nslot;
674 for (i = 0; i < e; i++) {
675 printf(" %4lx", (unsigned long)i);
676
677 if (am_anon[i] || verbose > 1)
678 printf(" %8x", am_bckptr[i]);
679 else
680 printf(" %8s", "-");
681
682 if (i < D(amap, amap)->am_nused || verbose > 1)
683 printf(" %8x", am_slots[i]);
684 else
685 printf(" %8s", "-");
686
687 if (am_ppref) {
688 if (l == 0 || r || verbose > 1)
689 printf(" %8d", am_ppref[i]);
690 else
691 printf(" %8s", "-");
692 r = 0;
693 if (l == 0) {
694 if (am_ppref[i] > 0) {
695 r = am_ppref[i] - 1;
696 l = 1;
697 } else {
698 r = -am_ppref[i] - 1;
699 l = am_ppref[i + 1];
700 }
701 printf(" (%4ld @ %4ld)", (long)l, (long)r);
702 r = (l > 1) ? 1 : 0;
703 }
704 else
705 printf(" ");
706 l--;
707 }
708
709 dump_vm_anon(kd, am_anon, i);
710 }
711
712 free(am_anon);
713 free(am_bckptr);
714 free(am_slots);
715 if (am_ppref)
716 free(am_ppref);
717 }
718
719 static void
dump_vm_anon(kvm_t * kd,struct vm_anon ** alist,int i)720 dump_vm_anon(kvm_t *kd, struct vm_anon **alist, int i)
721 {
722
723 printf(" %10p", alist[i]);
724
725 if (debug & PRINT_VM_ANON) {
726 struct kbit kbit, *anon = &kbit;
727
728 A(anon) = (u_long)alist[i];
729 S(anon) = sizeof(struct vm_anon);
730 if (A(anon) == 0) {
731 printf(" = { }\n");
732 return;
733 }
734 else
735 KDEREF(kd, anon);
736
737 printf(" = { an_ref = %"PRIuPTR", an_page = %p, an_swslot = %d }",
738 D(anon, anon)->an_ref, D(anon, anon)->an_page,
739 D(anon, anon)->an_swslot);
740 }
741
742 printf("\n");
743 }
744
745 static char*
findname(kvm_t * kd,struct kbit * vmspace,struct kbit * vm_map_entry,struct kbit * vp,struct kbit * vfs,struct kbit * uvm_obj)746 findname(kvm_t *kd, struct kbit *vmspace,
747 struct kbit *vm_map_entry, struct kbit *vp,
748 struct kbit *vfs, struct kbit *uvm_obj)
749 {
750 static char buf[1024], *name;
751 struct vm_map_entry *vme;
752 size_t l;
753 int rv;
754
755 vme = D(vm_map_entry, vm_map_entry);
756
757 if (UVM_ET_ISOBJ(vme)) {
758 if (A(vfs)) {
759 l = (unsigned)strlen(D(vfs, mount)->mnt_stat.f_mntonname);
760 rv = search_cache(kd, P(vp), &name, buf, sizeof(buf));
761 switch (rv) {
762 case 0: /* found something */
763 name--;
764 *name = '/';
765 /*FALLTHROUGH*/
766 case 2: /* found nothing */
767 name -= 5;
768 memcpy(name, " -?- ", (size_t)5);
769 name -= l;
770 memcpy(name,
771 D(vfs, mount)->mnt_stat.f_mntonname, l);
772 break;
773 case 1: /* all is well */
774 name--;
775 *name = '/';
776 if (l != 1) {
777 name -= l;
778 memcpy(name,
779 D(vfs, mount)->mnt_stat.f_mntonname, l);
780 }
781 break;
782 }
783 }
784 else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) {
785 struct kbit kdev;
786 dev_t dev;
787
788 P(&kdev) = P(uvm_obj);
789 S(&kdev) = sizeof(struct uvm_device);
790 KDEREF(kd, &kdev);
791 dev = D(&kdev, uvm_device)->u_device;
792 name = devname(dev, S_IFCHR);
793 if (name != NULL)
794 snprintf(buf, sizeof(buf), "/dev/%s", name);
795 else
796 snprintf(buf, sizeof(buf), " [ device %llu,%llu ]",
797 (unsigned long long)major(dev),
798 (unsigned long long)minor(dev));
799 name = buf;
800 }
801 else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object))) {
802 snprintf(buf, sizeof(buf), " [ uvm_aobj ]");
803 name = buf;
804 }
805 else if (UVM_OBJ_IS_UBCPAGER(D(uvm_obj, uvm_object))) {
806 snprintf(buf, sizeof(buf), " [ ubc_pager ]");
807 name = buf;
808 }
809 else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) {
810 snprintf(buf, sizeof(buf), " [ ?VNODE? ]");
811 name = buf;
812 }
813 else {
814 snprintf(buf, sizeof(buf), " [ ?? %p ?? ]",
815 D(uvm_obj, uvm_object)->pgops);
816 name = buf;
817 }
818 }
819
820 else if ((char *)D(vmspace, vmspace)->vm_maxsaddr <=
821 (char *)vme->start &&
822 ((char *)D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >=
823 (char *)vme->end) {
824 snprintf(buf, sizeof(buf), " [ stack ]");
825 name = buf;
826 }
827
828 else if (!heapfound &&
829 (vme->protection & rwx) == rwx &&
830 vme->start >= (u_long)D(vmspace, vmspace)->vm_daddr) {
831 heapfound = 1;
832 snprintf(buf, sizeof(buf), " [ heap ]");
833 name = buf;
834 }
835
836 else if (UVM_ET_ISSUBMAP(vme)) {
837 const char *sub = mapname(vme->object.sub_map);
838 snprintf(buf, sizeof(buf), " [ %s ]", sub ? sub : "(submap)");
839 name = buf;
840 }
841
842 else {
843 snprintf(buf, sizeof(buf), " [ anon ]");
844 name = buf;
845 }
846
847 return (name);
848 }
849
850 static int
search_cache(kvm_t * kd,struct vnode * vp,char ** name,char * buf,size_t blen)851 search_cache(kvm_t *kd, struct vnode *vp, char **name, char *buf, size_t blen)
852 {
853 char *o, *e;
854 struct namecache nc;
855 struct vnode_impl vi;
856 u_long vip, ncp, ncp2;
857 size_t nlen;
858
859 vip = (u_long)vp;
860 e = &buf[blen - 1];
861 o = e;
862 ncp2 = 0;
863 do {
864 /* Pull down vnode_impl for vnode. */
865 _KDEREF(kd, vip, &vi, sizeof(vi));
866
867 /* From that, get first cached name for vnode. */
868 ncp = (u_long)vi.vi_nc_list.tqh_first;
869 if (ncp != 0 && ncp != ncp2) {
870 /* Pull down the cache entry. */
871 _KDEREF(kd, ncp, &nc, sizeof(nc));
872 /* Done if own parent or at the root. */
873 if ((u_long)nc.nc_dvp == vip ||
874 (vi.vi_vnode.v_vflag & VV_ROOT) != 0)
875 break;
876 /* Otherwise pull first NCHNAMLEN chars of name. */
877 nlen = MIN(NC_NLEN(&nc), NCHNAMLEN);
878 /* too small */
879 if ((size_t)(o - buf) < nlen + (o != e ? 1 : 0))
880 break;
881 if (o != e)
882 *(--o) = '/';
883 o -= nlen;
884 memcpy(o, nc.nc_name, nlen);
885 vip = (u_long)nc.nc_dvp;
886 ncp2 = ncp;
887 } else
888 break;
889 } while (1/*CONSTCOND*/);
890 *e = '\0';
891 *name = o;
892
893 if (e == o)
894 return (2);
895
896 return (vi.vi_vnode.v_vflag & VV_ROOT);
897 }
898