procmap.c revision 1.60 
1/*	$OpenBSD: procmap.c,v 1.60 2016/04/16 18:39:30 stefan Exp $ */
2/*	$NetBSD: pmap.c,v 1.1 2002/09/01 20:32:44 atatat Exp $ */
3
4/*
5 * Copyright (c) 2002 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Andrew Brown.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include <sys/param.h>	/* MAXCOMLEN */
34#include <sys/types.h>
35#include <sys/time.h>
36#include <sys/exec.h>
37#include <sys/proc.h>
38#include <sys/vnode.h>
39#include <sys/mount.h>
40#include <sys/uio.h>
41#include <sys/sysctl.h>
42
43/* XXX until uvm gets cleaned up */
44typedef int boolean_t;
45
46#include <uvm/uvm.h>
47#include <uvm/uvm_device.h>
48#include <uvm/uvm_amap.h>
49
50#include <ufs/ufs/quota.h>
51#include <ufs/ufs/inode.h>
52#undef doff_t
53#undef IN_ACCESS
54#undef i_size
55#undef i_devvp
56#include <isofs/cd9660/iso.h>
57#include <isofs/cd9660/cd9660_node.h>
58
59#include <kvm.h>
60#include <fcntl.h>
61#include <errno.h>
62#include <err.h>
63#include <stdlib.h>
64#include <stddef.h>
65#include <unistd.h>
66#include <stdio.h>
67#include <limits.h>
68#include <string.h>
69
70/*
71 * stolen (and munged) from #include <uvm/uvm_object.h>
72 */
73#define UVM_OBJ_IS_VNODE(uobj)	((uobj)->pgops == uvm_vnodeops)
74#define UVM_OBJ_IS_AOBJ(uobj)	((uobj)->pgops == aobj_pager)
75#define UVM_OBJ_IS_DEVICE(uobj)	((uobj)->pgops == uvm_deviceops)
76
77#define PRINT_VMSPACE		0x00000001
78#define PRINT_VM_MAP		0x00000002
79#define PRINT_VM_MAP_HEADER	0x00000004
80#define PRINT_VM_MAP_ENTRY	0x00000008
81
82struct cache_entry {
83	LIST_ENTRY(cache_entry) ce_next;
84	struct vnode *ce_vp, *ce_pvp;
85	u_long ce_cid, ce_pcid;
86	unsigned int ce_nlen;
87	char ce_name[256];
88};
89
90LIST_HEAD(cache_head, cache_entry) lcache;
91void *uvm_vnodeops, *uvm_deviceops, *aobj_pager;
92u_long kernel_map_addr;
93int debug, verbose;
94int print_all, print_map, print_maps, print_solaris, print_ddb, print_amap;
95int rwx = PROT_READ | PROT_WRITE | PROT_EXEC;
96rlim_t maxssiz;
97
98struct sum {
99	unsigned long s_am_nslots;
100	unsigned long s_am_nusedslots;
101};
102
103struct kbit {
104	/*
105	 * size of data chunk
106	 */
107	size_t k_size;
108
109	/*
110	 * something for printf() and something for kvm_read()
111	 */
112	union {
113		void *k_addr_p;
114		u_long k_addr_ul;
115	} k_addr;
116
117	/*
118	 * where we actually put the "stuff"
119	 */
120	union {
121		char data[1];
122		struct vmspace vmspace;
123		struct vm_map vm_map;
124		struct vm_map_entry vm_map_entry;
125		struct vnode vnode;
126		struct uvm_object uvm_object;
127		struct mount mount;
128		struct inode inode;
129		struct iso_node iso_node;
130		struct uvm_device uvm_device;
131		struct vm_amap vm_amap;
132	} k_data;
133};
134
135/* the size of the object in the kernel */
136#define S(x)	((x)->k_size)
137/* the address of the object in kernel, two forms */
138#define A(x)	((x)->k_addr.k_addr_ul)
139#define P(x)	((x)->k_addr.k_addr_p)
140/* the data from the kernel */
141#define D(x,d)	(&((x)->k_data.d))
142
143/* suck the data from the kernel */
144#define _KDEREF(kd, addr, dst, sz) do { \
145	ssize_t len; \
146	len = kvm_read((kd), (addr), (dst), (sz)); \
147	if (len != (sz)) \
148		errx(1, "%s == %ld vs. %lu @ %lx", \
149		    kvm_geterr(kd), (long)len, (unsigned long)(sz), (addr)); \
150} while (0/*CONSTCOND*/)
151
152/* suck the data using the structure */
153#define KDEREF(kd, item) _KDEREF((kd), A(item), D(item, data), S(item))
154
155struct nlist nl[] = {
156	{ "_maxsmap" },
157#define NL_MAXSSIZ		0
158	{ "_uvm_vnodeops" },
159#define NL_UVM_VNODEOPS		1
160	{ "_uvm_deviceops" },
161#define NL_UVM_DEVICEOPS	2
162	{ "_aobj_pager" },
163#define NL_AOBJ_PAGER		3
164	{ "_kernel_map" },
165#define NL_KERNEL_MAP		4
166	{ NULL }
167};
168
169void load_symbols(kvm_t *);
170void process_map(kvm_t *, pid_t, struct kinfo_proc *, struct sum *);
171struct vm_map_entry *load_vm_map_entries(kvm_t *, struct vm_map_entry *,
172    struct vm_map_entry *);
173void unload_vm_map_entries(struct vm_map_entry *);
174size_t dump_vm_map_entry(kvm_t *, struct kbit *, struct vm_map_entry *,
175    struct sum *);
176char *findname(kvm_t *, struct kbit *, struct vm_map_entry *, struct kbit *,
177    struct kbit *, struct kbit *);
178int search_cache(kvm_t *, struct kbit *, char **, char *, size_t);
179static void __dead usage(void);
180static pid_t strtopid(const char *);
181void print_sum(struct sum *, struct sum *);
182
183/*
184 * uvm_map address tree implementation.
185 */
186static int no_impl(void *, void *);
187static int
188no_impl(void *p, void *q)
189{
190	errx(1, "uvm_map address comparison not implemented");
191	return 0;
192}
193
194RB_GENERATE(uvm_map_addr, vm_map_entry, daddrs.addr_entry, no_impl);
195
196int
197main(int argc, char *argv[])
198{
199	const char *errstr;
200	char errbuf[_POSIX2_LINE_MAX], *kmem = NULL, *kernel = NULL;
201	struct kinfo_proc *kproc;
202	struct sum total_sum;
203	int many, ch, rc;
204	kvm_t *kd;
205	pid_t pid = -1;
206	gid_t gid;
207
208	while ((ch = getopt(argc, argv, "AaD:dlmM:N:p:Prsvx")) != -1) {
209		switch (ch) {
210		case 'A':
211			print_amap = 1;
212			break;
213		case 'a':
214			print_all = 1;
215			break;
216		case 'd':
217			print_ddb = 1;
218			break;
219		case 'D':
220			debug = strtonum(optarg, 0, 0xf, &errstr);
221			if (errstr)
222				errx(1, "invalid debug mask");
223			break;
224		case 'l':
225			print_maps = 1;
226			break;
227		case 'm':
228			print_map = 1;
229			break;
230		case 'M':
231			kmem = optarg;
232			break;
233		case 'N':
234			kernel = optarg;
235			break;
236		case 'p':
237			pid = strtopid(optarg);
238			break;
239		case 'P':
240			pid = getpid();
241			break;
242		case 's':
243			print_solaris = 1;
244			break;
245		case 'v':
246			verbose = 1;
247			break;
248		case 'r':
249		case 'x':
250			errx(1, "-%c option not implemented, sorry", ch);
251			/*NOTREACHED*/
252		default:
253			usage();
254		}
255	}
256
257	/*
258	 * Discard setgid privileges if not the running kernel so that bad
259	 * guys can't print interesting stuff from kernel memory.
260	 */
261	gid = getgid();
262	if (kernel != NULL || kmem != NULL)
263		if (setresgid(gid, gid, gid) == -1)
264			err(1, "setresgid");
265
266	argc -= optind;
267	argv += optind;
268
269	/* more than one "process" to dump? */
270	many = (argc > 1 - (pid == -1 ? 0 : 1)) ? 1 : 0;
271
272	/* apply default */
273	if (print_all + print_map + print_maps + print_solaris +
274	    print_ddb == 0)
275		print_solaris = 1;
276
277	/* start by opening libkvm */
278	kd = kvm_openfiles(kernel, kmem, NULL, O_RDONLY, errbuf);
279
280	if (kernel == NULL && kmem == NULL)
281		if (setresgid(gid, gid, gid) == -1)
282			err(1, "setresgid");
283
284	if (kd == NULL)
285		errx(1, "%s", errbuf);
286
287	/* get "bootstrap" addresses from kernel */
288	load_symbols(kd);
289
290	memset(&total_sum, 0, sizeof(total_sum));
291
292	do {
293		struct sum sum;
294
295		memset(&sum, 0, sizeof(sum));
296
297		if (pid == -1) {
298			if (argc == 0)
299				pid = getppid();
300			else {
301				pid = strtopid(argv[0]);
302				argv++;
303				argc--;
304			}
305		}
306
307		/* find the process id */
308		if (pid == 0)
309			kproc = NULL;
310		else {
311			kproc = kvm_getprocs(kd, KERN_PROC_PID, pid,
312			    sizeof(struct kinfo_proc), &rc);
313			if (kproc == NULL || rc == 0) {
314				warnc(ESRCH, "%d", pid);
315				pid = -1;
316				continue;
317			}
318		}
319
320		/* dump it */
321		if (many) {
322			if (kproc)
323				printf("process %d:\n", pid);
324			else
325				printf("kernel:\n");
326		}
327
328		process_map(kd, pid, kproc, &sum);
329		if (print_amap)
330			print_sum(&sum, &total_sum);
331		pid = -1;
332	} while (argc > 0);
333
334	if (print_amap)
335		print_sum(&total_sum, NULL);
336
337	/* done.  go away. */
338	rc = kvm_close(kd);
339	if (rc == -1)
340		err(1, "kvm_close");
341
342	return (0);
343}
344
345void
346print_sum(struct sum *sum, struct sum *total_sum)
347{
348	const char *t = total_sum == NULL ? "total " : "";
349	printf("%samap mapped slots: %lu\n", t, sum->s_am_nslots);
350	printf("%samap used slots: %lu\n", t, sum->s_am_nusedslots);
351
352	if (total_sum) {
353		total_sum->s_am_nslots += sum->s_am_nslots;
354		total_sum->s_am_nusedslots += sum->s_am_nusedslots;
355	}
356}
357
358void
359process_map(kvm_t *kd, pid_t pid, struct kinfo_proc *proc, struct sum *sum)
360{
361	struct kbit kbit[3], *vmspace, *vm_map;
362	struct vm_map_entry *vm_map_entry;
363	size_t total = 0;
364	char *thing;
365	uid_t uid;
366	int vmmap_flags;
367
368	if ((uid = getuid())) {
369		if (pid == 0) {
370			warnx("kernel map is restricted");
371			return;
372		}
373		if (uid != proc->p_uid) {
374			warnx("other users' process maps are restricted");
375			return;
376		}
377	}
378
379	vmspace = &kbit[0];
380	vm_map = &kbit[1];
381
382	A(vmspace) = 0;
383	A(vm_map) = 0;
384
385	if (pid > 0) {
386		A(vmspace) = (u_long)proc->p_vmspace;
387		S(vmspace) = sizeof(struct vmspace);
388		KDEREF(kd, vmspace);
389		thing = "proc->p_vmspace.vm_map";
390	} else {
391		A(vmspace) = 0;
392		S(vmspace) = 0;
393		thing = "kernel_map";
394	}
395
396	if (pid > 0 && (debug & PRINT_VMSPACE)) {
397		printf("proc->p_vmspace %p = {", P(vmspace));
398		printf(" vm_refcnt = %d,", D(vmspace, vmspace)->vm_refcnt);
399		printf(" vm_shm = %p,\n", D(vmspace, vmspace)->vm_shm);
400		printf("    vm_rssize = %d,", D(vmspace, vmspace)->vm_rssize);
401#if 0
402		printf(" vm_swrss = %d,", D(vmspace, vmspace)->vm_swrss);
403#endif
404		printf(" vm_tsize = %d,", D(vmspace, vmspace)->vm_tsize);
405		printf(" vm_dsize = %d,\n", D(vmspace, vmspace)->vm_dsize);
406		printf("    vm_ssize = %d,", D(vmspace, vmspace)->vm_ssize);
407		printf(" vm_taddr = %p,", D(vmspace, vmspace)->vm_taddr);
408		printf(" vm_daddr = %p,\n", D(vmspace, vmspace)->vm_daddr);
409		printf("    vm_maxsaddr = %p,",
410		    D(vmspace, vmspace)->vm_maxsaddr);
411		printf(" vm_minsaddr = %p }\n",
412		    D(vmspace, vmspace)->vm_minsaddr);
413	}
414
415	S(vm_map) = sizeof(struct vm_map);
416	if (pid > 0) {
417		A(vm_map) = A(vmspace);
418		memcpy(D(vm_map, vm_map), &D(vmspace, vmspace)->vm_map,
419		    S(vm_map));
420	} else {
421		A(vm_map) = kernel_map_addr;
422		KDEREF(kd, vm_map);
423	}
424	if (debug & PRINT_VM_MAP) {
425		printf("%s %p = {", thing, P(vm_map));
426
427		printf(" pmap = %p,\n", D(vm_map, vm_map)->pmap);
428		printf("    lock = <struct lock>\n");
429		printf("    size = %lx,", D(vm_map, vm_map)->size);
430		printf(" ref_count = %d,", D(vm_map, vm_map)->ref_count);
431		printf(" ref_lock = <struct simplelock>,\n");
432		printf("    min_offset-max_offset = 0x%lx-0x%lx\n",
433		    D(vm_map, vm_map)->min_offset,
434		    D(vm_map, vm_map)->max_offset);
435		printf("    b_start-b_end = 0x%lx-0x%lx\n",
436		    D(vm_map, vm_map)->b_start,
437		    D(vm_map, vm_map)->b_end);
438		printf("    s_start-s_end = 0x%lx-0x%lx\n",
439		    D(vm_map, vm_map)->s_start,
440		    D(vm_map, vm_map)->s_end);
441		vmmap_flags = D(vm_map, vm_map)->flags;
442		printf("    flags = %x <%s%s%s%s%s%s >,\n",
443		    vmmap_flags,
444		    vmmap_flags & VM_MAP_PAGEABLE ? " PAGEABLE" : "",
445		    vmmap_flags & VM_MAP_INTRSAFE ? " INTRSAFE" : "",
446		    vmmap_flags & VM_MAP_WIREFUTURE ? " WIREFUTURE" : "",
447		    vmmap_flags & VM_MAP_BUSY ? " BUSY" : "",
448		    vmmap_flags & VM_MAP_WANTLOCK ? " WANTLOCK" : "",
449#if VM_MAP_TOPDOWN > 0
450		    vmmap_flags & VM_MAP_TOPDOWN ? " TOPDOWN" :
451#endif
452		    "");
453		printf("    timestamp = %u }\n", D(vm_map, vm_map)->timestamp);
454	}
455	if (print_ddb) {
456		printf("MAP %p: [0x%lx->0x%lx]\n", P(vm_map),
457		    D(vm_map, vm_map)->min_offset,
458		    D(vm_map, vm_map)->max_offset);
459		printf("\tsz=%ld, ref=%d, version=%d, flags=0x%x\n",
460		    D(vm_map, vm_map)->size,
461		    D(vm_map, vm_map)->ref_count,
462		    D(vm_map, vm_map)->timestamp,
463		    D(vm_map, vm_map)->flags);
464		printf("\tpmap=%p(resident=<unknown>)\n",
465		    D(vm_map, vm_map)->pmap);
466	}
467
468	/* headers */
469#ifdef DISABLED_HEADERS
470	if (print_map)
471		printf("%-*s %-*s rwx RWX CPY NCP I W A\n",
472		    (int)sizeof(long) * 2 + 2, "Start",
473		    (int)sizeof(long) * 2 + 2, "End");
474	if (print_maps)
475		printf("%-*s %-*s rwxp %-*s Dev   Inode      File\n",
476		    (int)sizeof(long) * 2 + 0, "Start",
477		    (int)sizeof(long) * 2 + 0, "End",
478		    (int)sizeof(long) * 2 + 0, "Offset");
479	if (print_solaris)
480		printf("%-*s %*s Protection        File\n",
481		    (int)sizeof(long) * 2 + 0, "Start",
482		    (int)sizeof(int) * 2 - 1,  "Size ");
483#endif
484	if (print_all)
485		printf("%-*s %-*s %*s %-*s rwxpc  RWX  I/W/A Dev  %*s - File\n",
486		    (int)sizeof(long) * 2, "Start",
487		    (int)sizeof(long) * 2, "End",
488		    (int)sizeof(int)  * 2, "Size ",
489		    (int)sizeof(long) * 2, "Offset",
490		    (int)sizeof(int)  * 2, "Inode");
491
492	/* these are the "sub entries" */
493	RB_ROOT(&D(vm_map, vm_map)->addr) =
494	    load_vm_map_entries(kd, RB_ROOT(&D(vm_map, vm_map)->addr), NULL);
495	RB_FOREACH(vm_map_entry, uvm_map_addr, &D(vm_map, vm_map)->addr)
496		total += dump_vm_map_entry(kd, vmspace, vm_map_entry, sum);
497	unload_vm_map_entries(RB_ROOT(&D(vm_map, vm_map)->addr));
498
499	if (print_solaris)
500		printf("%-*s %8luK\n",
501		    (int)sizeof(void *) * 2 - 2, " total",
502		    (unsigned long)total);
503	if (print_all)
504		printf("%-*s %9luk\n",
505		    (int)sizeof(void *) * 4 - 1, " total",
506		    (unsigned long)total);
507}
508
509void
510load_symbols(kvm_t *kd)
511{
512	int rc, i;
513
514	rc = kvm_nlist(kd, &nl[0]);
515	if (rc == -1)
516		errx(1, "%s == %d", kvm_geterr(kd), rc);
517	for (i = 0; i < sizeof(nl)/sizeof(nl[0]); i++)
518		if (nl[i].n_value == 0 && nl[i].n_name)
519			printf("%s not found\n", nl[i].n_name);
520
521	uvm_vnodeops =	(void*)nl[NL_UVM_VNODEOPS].n_value;
522	uvm_deviceops =	(void*)nl[NL_UVM_DEVICEOPS].n_value;
523	aobj_pager =	(void*)nl[NL_AOBJ_PAGER].n_value;
524
525	_KDEREF(kd, nl[NL_MAXSSIZ].n_value, &maxssiz,
526	    sizeof(maxssiz));
527	_KDEREF(kd, nl[NL_KERNEL_MAP].n_value, &kernel_map_addr,
528	    sizeof(kernel_map_addr));
529}
530
531/*
532 * Recreate the addr tree of vm_map in local memory.
533 */
534struct vm_map_entry *
535load_vm_map_entries(kvm_t *kd, struct vm_map_entry *kptr,
536    struct vm_map_entry *parent)
537{
538	static struct kbit map_ent;
539	struct vm_map_entry *result;
540
541	if (kptr == NULL)
542		return NULL;
543
544	A(&map_ent) = (u_long)kptr;
545	S(&map_ent) = sizeof(struct vm_map_entry);
546	KDEREF(kd, &map_ent);
547
548	result = malloc(sizeof(*result));
549	if (result == NULL)
550		err(1, "malloc");
551	memcpy(result, D(&map_ent, vm_map_entry), sizeof(struct vm_map_entry));
552
553	/*
554	 * Recurse to download rest of the tree.
555	 */
556	RB_LEFT(result, daddrs.addr_entry) = load_vm_map_entries(kd,
557	    RB_LEFT(result, daddrs.addr_entry), result);
558	RB_RIGHT(result, daddrs.addr_entry) = load_vm_map_entries(kd,
559	    RB_RIGHT(result, daddrs.addr_entry), result);
560	RB_PARENT(result, daddrs.addr_entry) = parent;
561	return result;
562}
563
564/*
565 * Release the addr tree of vm_map.
566 */
567void
568unload_vm_map_entries(struct vm_map_entry *ent)
569{
570	if (ent == NULL)
571		return;
572
573	unload_vm_map_entries(RB_LEFT(ent, daddrs.addr_entry));
574	unload_vm_map_entries(RB_RIGHT(ent, daddrs.addr_entry));
575	free(ent);
576}
577
578size_t
579dump_vm_map_entry(kvm_t *kd, struct kbit *vmspace,
580    struct vm_map_entry *vme, struct sum *sum)
581{
582	struct kbit kbit[4], *uvm_obj, *vp, *vfs, *amap;
583	ino_t inode = 0;
584	dev_t dev = 0;
585	size_t sz = 0;
586	char *name;
587
588	uvm_obj = &kbit[0];
589	vp = &kbit[1];
590	vfs = &kbit[2];
591	amap = &kbit[3];
592
593	A(uvm_obj) = 0;
594	A(vp) = 0;
595	A(vfs) = 0;
596
597	if (debug & PRINT_VM_MAP_ENTRY) {
598		printf("%s = {", "vm_map_entry");
599		printf(" start = %lx,", vme->start);
600		printf(" end = %lx,", vme->end);
601		printf(" fspace = %lx,\n", vme->fspace);
602		printf("    object.uvm_obj/sub_map = %p,\n",
603		    vme->object.uvm_obj);
604		printf("    offset = %lx,", (unsigned long)vme->offset);
605		printf(" etype = %x <%s%s%s%s%s >,", vme->etype,
606		    vme->etype & UVM_ET_OBJ ? " OBJ" : "",
607		    vme->etype & UVM_ET_SUBMAP ? " SUBMAP" : "",
608		    vme->etype & UVM_ET_COPYONWRITE ? " COW" : "",
609		    vme->etype & UVM_ET_NEEDSCOPY ? " NEEDSCOPY" : "",
610		    vme->etype & UVM_ET_HOLE ? " HOLE" : "");
611		printf(" protection = %x,\n", vme->protection);
612		printf("    max_protection = %x,", vme->max_protection);
613		printf(" inheritance = %d,", vme->inheritance);
614		printf(" wired_count = %d,\n", vme->wired_count);
615		printf("    aref = <struct vm_aref>,");
616		printf(" advice = %d,", vme->advice);
617		printf(" flags = %x <%s%s > }\n", vme->flags,
618		    vme->flags & UVM_MAP_STATIC ? " STATIC" : "",
619		    vme->flags & UVM_MAP_KMEM ? " KMEM" : "");
620	}
621
622	A(vp) = 0;
623	A(uvm_obj) = 0;
624
625	if (vme->object.uvm_obj != NULL) {
626		P(uvm_obj) = vme->object.uvm_obj;
627		S(uvm_obj) = sizeof(struct uvm_object);
628		KDEREF(kd, uvm_obj);
629		if (UVM_ET_ISOBJ(vme) &&
630		    UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object))) {
631			P(vp) = P(uvm_obj);
632			S(vp) = sizeof(struct vnode);
633			KDEREF(kd, vp);
634		}
635	}
636
637	if (vme->aref.ar_amap != NULL) {
638		P(amap) = vme->aref.ar_amap;
639		S(amap) = sizeof(struct vm_amap);
640		KDEREF(kd, amap);
641	}
642
643	A(vfs) = 0;
644
645	if (P(vp) != NULL && D(vp, vnode)->v_mount != NULL) {
646		P(vfs) = D(vp, vnode)->v_mount;
647		S(vfs) = sizeof(struct mount);
648		KDEREF(kd, vfs);
649		D(vp, vnode)->v_mount = D(vfs, mount);
650	}
651
652	/*
653	 * dig out the device number and inode number from certain
654	 * file system types.
655	 */
656#define V_DATA_IS(vp, type, d, i) do { \
657	struct kbit data; \
658	P(&data) = D(vp, vnode)->v_data; \
659	S(&data) = sizeof(*D(&data, type)); \
660	KDEREF(kd, &data); \
661	dev = D(&data, type)->d; \
662	inode = D(&data, type)->i; \
663} while (0/*CONSTCOND*/)
664
665	if (A(vp) &&
666	    D(vp, vnode)->v_type == VREG &&
667	    D(vp, vnode)->v_data != NULL) {
668		switch (D(vp, vnode)->v_tag) {
669		case VT_UFS:
670		case VT_EXT2FS:
671			V_DATA_IS(vp, inode, i_dev, i_number);
672			break;
673		case VT_ISOFS:
674			V_DATA_IS(vp, iso_node, i_dev, i_number);
675			break;
676		case VT_NON:
677		case VT_NFS:
678		case VT_MFS:
679		case VT_MSDOSFS:
680		default:
681			break;
682		}
683	}
684
685	name = findname(kd, vmspace, vme, vp, vfs, uvm_obj);
686
687	if (print_map) {
688		printf("0x%lx 0x%lx %c%c%c %c%c%c %s %s %d %d %d",
689		    vme->start, vme->end,
690		    (vme->protection & PROT_READ) ? 'r' : '-',
691		    (vme->protection & PROT_WRITE) ? 'w' : '-',
692		    (vme->protection & PROT_EXEC) ? 'x' : '-',
693		    (vme->max_protection & PROT_READ) ? 'r' : '-',
694		    (vme->max_protection & PROT_WRITE) ? 'w' : '-',
695		    (vme->max_protection & PROT_EXEC) ? 'x' : '-',
696		    (vme->etype & UVM_ET_COPYONWRITE) ? "COW" : "NCOW",
697		    (vme->etype & UVM_ET_NEEDSCOPY) ? "NC" : "NNC",
698		    vme->inheritance, vme->wired_count,
699		    vme->advice);
700		if (verbose) {
701			if (inode)
702				printf(" %d,%d %llu",
703				    major(dev), minor(dev),
704				    (unsigned long long)inode);
705			if (name[0])
706				printf(" %s", name);
707		}
708		printf("\n");
709	}
710
711	if (print_maps)
712		printf("%0*lx-%0*lx %c%c%c%c %0*lx %02x:%02x %llu     %s\n",
713		    (int)sizeof(void *) * 2, vme->start,
714		    (int)sizeof(void *) * 2, vme->end,
715		    (vme->protection & PROT_READ) ? 'r' : '-',
716		    (vme->protection & PROT_WRITE) ? 'w' : '-',
717		    (vme->protection & PROT_EXEC) ? 'x' : '-',
718		    (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's',
719		    (int)sizeof(void *) * 2,
720		    (unsigned long)vme->offset,
721		    major(dev), minor(dev), (unsigned long long)inode,
722		    inode ? name : "");
723
724	if (print_ddb) {
725		printf(" - <lost address>: 0x%lx->0x%lx: "
726		    "obj=%p/0x%lx, amap=%p/%d\n",
727		    vme->start, vme->end,
728		    vme->object.uvm_obj, (unsigned long)vme->offset,
729		    vme->aref.ar_amap, vme->aref.ar_pageoff);
730		printf("\tsubmap=%c, cow=%c, nc=%c, prot(max)=%d/%d, inh=%d, "
731		    "wc=%d, adv=%d\n",
732		    (vme->etype & UVM_ET_SUBMAP) ? 'T' : 'F',
733		    (vme->etype & UVM_ET_COPYONWRITE) ? 'T' : 'F',
734		    (vme->etype & UVM_ET_NEEDSCOPY) ? 'T' : 'F',
735		    vme->protection, vme->max_protection,
736		    vme->inheritance, vme->wired_count, vme->advice);
737		if (inode && verbose)
738			printf("\t(dev=%d,%d ino=%llu [%s] [%p])\n",
739			    major(dev), minor(dev), (unsigned long long)inode,
740			    inode ? name : "", P(vp));
741		else if (name[0] == ' ' && verbose)
742			printf("\t(%s)\n", &name[2]);
743	}
744
745	if (print_solaris) {
746		char prot[30];
747
748		prot[0] = '\0';
749		prot[1] = '\0';
750		if (vme->protection & PROT_READ)
751			strlcat(prot, "/read", sizeof(prot));
752		if (vme->protection & PROT_WRITE)
753			strlcat(prot, "/write", sizeof(prot));
754		if (vme->protection & PROT_EXEC)
755			strlcat(prot, "/exec", sizeof(prot));
756
757		sz = (size_t)((vme->end - vme->start) / 1024);
758		printf("%0*lX %6luK %-15s   %s\n",
759		    (int)sizeof(void *) * 2, (unsigned long)vme->start,
760		    (unsigned long)sz, &prot[1], name);
761	}
762
763	if (print_all) {
764		sz = (size_t)((vme->end - vme->start) / 1024);
765		printf("%0*lx-%0*lx %7luk %0*lx %c%c%c%c%c (%c%c%c) %d/%d/%d %02d:%02d %7llu - %s",
766		    (int)sizeof(void *) * 2, vme->start, (int)sizeof(void *) * 2,
767		    vme->end - (vme->start != vme->end ? 1 : 0), (unsigned long)sz,
768		    (int)sizeof(void *) * 2, (unsigned long)vme->offset,
769		    (vme->protection & PROT_READ) ? 'r' : '-',
770		    (vme->protection & PROT_WRITE) ? 'w' : '-',
771		    (vme->protection & PROT_EXEC) ? 'x' : '-',
772		    (vme->etype & UVM_ET_COPYONWRITE) ? 'p' : 's',
773		    (vme->etype & UVM_ET_NEEDSCOPY) ? '+' : '-',
774		    (vme->max_protection & PROT_READ) ? 'r' : '-',
775		    (vme->max_protection & PROT_WRITE) ? 'w' : '-',
776		    (vme->max_protection & PROT_EXEC) ? 'x' : '-',
777		    vme->inheritance, vme->wired_count, vme->advice,
778		    major(dev), minor(dev), (unsigned long long)inode, name);
779		if (A(vp))
780			printf(" [%p]", P(vp));
781		printf("\n");
782	}
783
784	if (print_amap && vme->aref.ar_amap) {
785		printf(" amap - ref: %d fl: 0x%x nsl: %d nuse: %d\n",
786		    D(amap, vm_amap)->am_ref,
787		    D(amap, vm_amap)->am_flags,
788		    D(amap, vm_amap)->am_nslot,
789		    D(amap, vm_amap)->am_nused);
790		if (sum) {
791			sum->s_am_nslots += D(amap, vm_amap)->am_nslot;
792			sum->s_am_nusedslots += D(amap, vm_amap)->am_nused;
793		}
794	}
795
796	/* no access allowed, don't count space */
797	if ((vme->protection & rwx) == 0)
798		sz = 0;
799
800	return (sz);
801}
802
803char *
804findname(kvm_t *kd, struct kbit *vmspace,
805    struct vm_map_entry *vme, struct kbit *vp,
806    struct kbit *vfs, struct kbit *uvm_obj)
807{
808	static char buf[1024], *name;
809	size_t l;
810
811	if (UVM_ET_ISOBJ(vme)) {
812		if (A(vfs)) {
813			l = strlen(D(vfs, mount)->mnt_stat.f_mntonname);
814			switch (search_cache(kd, vp, &name, buf, sizeof(buf))) {
815			case 0: /* found something */
816				if (name - (1 + 11 + l) < buf)
817					break;
818				name--;
819				*name = '/';
820				/*FALLTHROUGH*/
821			case 2: /* found nothing */
822				name -= 11;
823				memcpy(name, " -unknown- ", (size_t)11);
824				name -= l;
825				memcpy(name,
826				    D(vfs, mount)->mnt_stat.f_mntonname, l);
827				break;
828			case 1: /* all is well */
829				if (name - (1 + l) < buf)
830					break;
831				name--;
832				*name = '/';
833				if (l != 1) {
834					name -= l;
835					memcpy(name,
836					    D(vfs, mount)->mnt_stat.f_mntonname, l);
837				}
838				break;
839			}
840		} else if (UVM_OBJ_IS_DEVICE(D(uvm_obj, uvm_object))) {
841			struct kbit kdev;
842			dev_t dev;
843
844			P(&kdev) = P(uvm_obj);
845			S(&kdev) = sizeof(struct uvm_device);
846			KDEREF(kd, &kdev);
847			dev = D(&kdev, uvm_device)->u_device;
848			name = devname(dev, S_IFCHR);
849			if (name != NULL)
850				snprintf(buf, sizeof(buf), "/dev/%s", name);
851			else
852				snprintf(buf, sizeof(buf), "  [ device %d,%d ]",
853				    major(dev), minor(dev));
854			name = buf;
855		} else if (UVM_OBJ_IS_AOBJ(D(uvm_obj, uvm_object)))
856			name = "  [ uvm_aobj ]";
857		else if (UVM_OBJ_IS_VNODE(D(uvm_obj, uvm_object)))
858			name = "  [ ?VNODE? ]";
859		else {
860			snprintf(buf, sizeof(buf), "  [ unknown (%p) ]",
861			    D(uvm_obj, uvm_object)->pgops);
862			name = buf;
863		}
864	} else if (D(vmspace, vmspace)->vm_maxsaddr <= (caddr_t)vme->start &&
865	    (D(vmspace, vmspace)->vm_maxsaddr + (size_t)maxssiz) >=
866	    (caddr_t)vme->end) {
867		name = "  [ stack ]";
868	} else if (UVM_ET_ISHOLE(vme))
869		name = "  [ hole ]";
870	else
871		name = "  [ anon ]";
872
873	return (name);
874}
875
876int
877search_cache(kvm_t *kd, struct kbit *vp, char **name, char *buf, size_t blen)
878{
879	struct cache_entry *ce;
880	struct kbit svp;
881	char *o, *e;
882	u_long cid;
883
884	P(&svp) = P(vp);
885	S(&svp) = sizeof(struct vnode);
886	cid = D(vp, vnode)->v_id;
887
888	e = &buf[blen - 1];
889	o = e;
890	do {
891		LIST_FOREACH(ce, &lcache, ce_next)
892			if (ce->ce_vp == P(&svp) && ce->ce_cid == cid)
893				break;
894		if (ce && ce->ce_vp == P(&svp) && ce->ce_cid == cid) {
895			if (o != e)
896				*(--o) = '/';
897			if (o - ce->ce_nlen <= buf)
898				break;
899			o -= ce->ce_nlen;
900			memcpy(o, ce->ce_name, ce->ce_nlen);
901			P(&svp) = ce->ce_pvp;
902			cid = ce->ce_pcid;
903		} else
904			break;
905	} while (1/*CONSTCOND*/);
906	*e = '\0';
907	*name = o;
908
909	if (e == o)
910		return (2);
911
912	KDEREF(kd, &svp);
913	return (D(&svp, vnode)->v_flag & VROOT);
914}
915
916static void __dead
917usage(void)
918{
919	extern char *__progname;
920	fprintf(stderr, "usage: %s [-AadlmPsv] [-D number] "
921	    "[-M core] [-N system] [-p pid] [pid ...]\n",
922	    __progname);
923	exit(1);
924}
925
926static pid_t
927strtopid(const char *str)
928{
929	pid_t pid;
930
931	errno = 0;
932	pid = (pid_t)strtonum(str, 0, INT_MAX, NULL);
933	if (errno != 0)
934		usage();
935	return (pid);
936}
937