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