6583 remove whole-process swapping
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <mdb/mdb_param.h>
28 #include <mdb/mdb_modapi.h>
29
30 #include <sys/fs/ufs_inode.h>
31 #include <sys/kmem_impl.h>
32 #include <sys/vmem_impl.h>
33 #include <sys/modctl.h>
34 #include <sys/kobj.h>
35 #include <sys/kobj_impl.h>
36 #include <vm/seg_vn.h>
37 #include <vm/as.h>
38 #include <vm/seg_map.h>
39 #include <mdb/mdb_ctf.h>
40
41 #include "kmem.h"
42 #include "leaky_impl.h"
43
44 /*
45 * This file defines the genunix target for leaky.c. There are three types
46 * of buffers in the kernel's heap: TYPE_VMEM, for kmem_oversize allocations,
47 * TYPE_KMEM, for kmem_cache_alloc() allocations bufctl_audit_ts, and
48 * TYPE_CACHE, for kmem_cache_alloc() allocation without bufctl_audit_ts.
49 *
50 * See "leaky_impl.h" for the target interface definition.
51 */
52
53 #define TYPE_VMEM 0 /* lkb_data is the vmem_seg's size */
54 #define TYPE_CACHE 1 /* lkb_cid is the bufctl's cache */
55 #define TYPE_KMEM 2 /* lkb_cid is the bufctl's cache */
56
57 #define LKM_CTL_BUFCTL 0 /* normal allocation, PTR is bufctl */
58 #define LKM_CTL_VMSEG 1 /* oversize allocation, PTR is vmem_seg_t */
59 #define LKM_CTL_CACHE 2 /* normal alloc, non-debug, PTR is cache */
60 #define LKM_CTL_MASK 3L
61
62 #define LKM_CTL(ptr, type) (LKM_CTLPTR(ptr) | (type))
63 #define LKM_CTLPTR(ctl) ((uintptr_t)(ctl) & ~(LKM_CTL_MASK))
64 #define LKM_CTLTYPE(ctl) ((uintptr_t)(ctl) & (LKM_CTL_MASK))
65
66 static int kmem_lite_count = 0; /* cache of the kernel's version */
67
68 /*ARGSUSED*/
69 static int
70 leaky_mtab(uintptr_t addr, const kmem_bufctl_audit_t *bcp, leak_mtab_t **lmp)
71 {
72 leak_mtab_t *lm = (*lmp)++;
73
74 lm->lkm_base = (uintptr_t)bcp->bc_addr;
75 lm->lkm_bufctl = LKM_CTL(addr, LKM_CTL_BUFCTL);
76
77 return (WALK_NEXT);
78 }
79
80 /*ARGSUSED*/
81 static int
82 leaky_mtab_addr(uintptr_t addr, void *ignored, leak_mtab_t **lmp)
83 {
84 leak_mtab_t *lm = (*lmp)++;
85
86 lm->lkm_base = addr;
87
88 return (WALK_NEXT);
89 }
90
91 static int
92 leaky_seg(uintptr_t addr, const vmem_seg_t *seg, leak_mtab_t **lmp)
93 {
94 leak_mtab_t *lm = (*lmp)++;
95
96 lm->lkm_base = seg->vs_start;
97 lm->lkm_limit = seg->vs_end;
98 lm->lkm_bufctl = LKM_CTL(addr, LKM_CTL_VMSEG);
99
100 return (WALK_NEXT);
101 }
102
103 static int
104 leaky_vmem_interested(const vmem_t *vmem)
105 {
106 if (strcmp(vmem->vm_name, "kmem_oversize") != 0 &&
107 strcmp(vmem->vm_name, "static_alloc") != 0)
108 return (0);
109 return (1);
110 }
111
112 static int
113 leaky_vmem(uintptr_t addr, const vmem_t *vmem, leak_mtab_t **lmp)
114 {
115 if (!leaky_vmem_interested(vmem))
116 return (WALK_NEXT);
117
118 if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)leaky_seg, lmp, addr) == -1)
119 mdb_warn("can't walk vmem_alloc for kmem_oversize (%p)", addr);
120
121 return (WALK_NEXT);
122 }
123
124 /*ARGSUSED*/
125 static int
126 leaky_estimate_vmem(uintptr_t addr, const vmem_t *vmem, size_t *est)
127 {
128 if (!leaky_vmem_interested(vmem))
129 return (WALK_NEXT);
130
131 *est += (int)(vmem->vm_kstat.vk_alloc.value.ui64 -
132 vmem->vm_kstat.vk_free.value.ui64);
133
134 return (WALK_NEXT);
135 }
136
137 static int
138 leaky_interested(const kmem_cache_t *c)
139 {
140 vmem_t vmem;
141
142 /*
143 * ignore HAT-related caches that happen to derive from kmem_default
144 */
145 if (strcmp(c->cache_name, "sfmmu1_cache") == 0 ||
146 strcmp(c->cache_name, "sf_hment_cache") == 0 ||
147 strcmp(c->cache_name, "pa_hment_cache") == 0)
148 return (0);
149
150 if (mdb_vread(&vmem, sizeof (vmem), (uintptr_t)c->cache_arena) == -1) {
151 mdb_warn("cannot read arena %p for cache '%s'",
152 (uintptr_t)c->cache_arena, c->cache_name);
153 return (0);
154 }
155
156 /*
157 * If this cache isn't allocating from the kmem_default,
158 * kmem_firewall, or static vmem arenas, we're not interested.
159 */
160 if (strcmp(vmem.vm_name, "kmem_default") != 0 &&
161 strcmp(vmem.vm_name, "kmem_firewall") != 0 &&
162 strcmp(vmem.vm_name, "static") != 0)
163 return (0);
164
165 return (1);
166 }
167
168 static int
169 leaky_estimate(uintptr_t addr, const kmem_cache_t *c, size_t *est)
170 {
171 if (!leaky_interested(c))
172 return (WALK_NEXT);
173
174 *est += kmem_estimate_allocated(addr, c);
175
176 return (WALK_NEXT);
177 }
178
179 /*ARGSUSED*/
180 static int
181 leaky_cache(uintptr_t addr, const kmem_cache_t *c, leak_mtab_t **lmp)
182 {
183 leak_mtab_t *lm = *lmp;
184 mdb_walk_cb_t cb;
185 const char *walk;
186 int audit = (c->cache_flags & KMF_AUDIT);
187
188 if (!leaky_interested(c))
189 return (WALK_NEXT);
190
191 if (audit) {
192 walk = "bufctl";
193 cb = (mdb_walk_cb_t)leaky_mtab;
194 } else {
195 walk = "kmem";
196 cb = (mdb_walk_cb_t)leaky_mtab_addr;
197 }
198 if (mdb_pwalk(walk, cb, lmp, addr) == -1) {
199 mdb_warn("can't walk kmem for cache %p (%s)", addr,
200 c->cache_name);
201 return (WALK_DONE);
202 }
203
204 for (; lm < *lmp; lm++) {
205 lm->lkm_limit = lm->lkm_base + c->cache_bufsize;
206 if (!audit)
207 lm->lkm_bufctl = LKM_CTL(addr, LKM_CTL_CACHE);
208 }
209
210 return (WALK_NEXT);
211 }
212
213 /*ARGSUSED*/
214 static int
215 leaky_scan_buffer(uintptr_t addr, const void *ignored, const kmem_cache_t *c)
216 {
217 leaky_grep(addr, c->cache_bufsize);
218
219 /*
220 * free, constructed KMF_LITE buffers keep their first uint64_t in
221 * their buftag's redzone.
222 */
223 if (c->cache_flags & KMF_LITE) {
224 /* LINTED alignment */
225 kmem_buftag_t *btp = KMEM_BUFTAG(c, addr);
226 leaky_grep((uintptr_t)&btp->bt_redzone,
227 sizeof (btp->bt_redzone));
228 }
229
230 return (WALK_NEXT);
231 }
232
233 /*ARGSUSED*/
234 static int
235 leaky_scan_cache(uintptr_t addr, const kmem_cache_t *c, void *ignored)
236 {
237 if (!leaky_interested(c))
238 return (WALK_NEXT);
239
240 /*
241 * Scan all of the free, constructed buffers, since they may have
242 * pointers to allocated objects.
243 */
244 if (mdb_pwalk("freemem_constructed",
245 (mdb_walk_cb_t)leaky_scan_buffer, (void *)c, addr) == -1) {
246 mdb_warn("can't walk freemem_constructed for cache %p (%s)",
247 addr, c->cache_name);
248 return (WALK_DONE);
249 }
250
251 return (WALK_NEXT);
252 }
253
254 /*ARGSUSED*/
255 static int
256 leaky_modctl(uintptr_t addr, const struct modctl *m, int *ignored)
257 {
258 struct module mod;
259 char name[MODMAXNAMELEN];
260
261 if (m->mod_mp == NULL)
262 return (WALK_NEXT);
263
264 if (mdb_vread(&mod, sizeof (mod), (uintptr_t)m->mod_mp) == -1) {
265 mdb_warn("couldn't read modctl %p's module", addr);
266 return (WALK_NEXT);
267 }
268
269 if (mdb_readstr(name, sizeof (name), (uintptr_t)m->mod_modname) == -1)
270 (void) mdb_snprintf(name, sizeof (name), "0x%p", addr);
271
272 leaky_grep((uintptr_t)m->mod_mp, sizeof (struct module));
273 leaky_grep((uintptr_t)mod.data, mod.data_size);
274 leaky_grep((uintptr_t)mod.bss, mod.bss_size);
275
276 return (WALK_NEXT);
277 }
278
279 /*ARGSUSED*/
280 static int
281 leaky_thread(uintptr_t addr, const kthread_t *t, unsigned long *pagesize)
282 {
283 uintptr_t size, base = (uintptr_t)t->t_stkbase;
284 uintptr_t stk = (uintptr_t)t->t_stk;
285
286 if (t->t_state != TS_FREE)
287 leaky_grep(base, stk - base);
288
289 /*
290 * There is always gunk hanging out between t_stk and the page
291 * boundary. If this thread structure wasn't kmem allocated,
292 * this will include the thread structure itself. If the thread
293 * _is_ kmem allocated, we'll be able to get to it via allthreads.
294 */
295 size = *pagesize - (stk & (*pagesize - 1));
296
297 leaky_grep(stk, size);
298
299 return (WALK_NEXT);
300 }
301
302 /*ARGSUSED*/
303 static int
304 leaky_kstat(uintptr_t addr, vmem_seg_t *seg, void *ignored)
305 {
306 leaky_grep(seg->vs_start, seg->vs_end - seg->vs_start);
307
308 return (WALK_NEXT);
309 }
310
311 static void
312 leaky_kludge(void)
313 {
314 GElf_Sym sym;
315 mdb_ctf_id_t id, rid;
316
317 int max_mem_nodes;
318 uintptr_t *counters;
319 size_t ncounters;
320 ssize_t hwpm_size;
321 int idx;
322
323 /*
324 * Because of DR, the page counters (which live in the kmem64 segment)
325 * can point into kmem_alloc()ed memory. The "page_counters" array
326 * is multi-dimensional, and each entry points to an array of
327 * "hw_page_map_t"s which is "max_mem_nodes" in length.
328 *
329 * To keep this from having too much grotty knowledge of internals,
330 * we use CTF data to get the size of the structure. For simplicity,
331 * we treat the page_counters array as a flat array of pointers, and
332 * use its size to determine how much to scan. Unused entries will
333 * be NULL.
334 */
335 if (mdb_lookup_by_name("page_counters", &sym) == -1) {
336 mdb_warn("unable to lookup page_counters");
337 return;
338 }
339
340 if (mdb_readvar(&max_mem_nodes, "max_mem_nodes") == -1) {
341 mdb_warn("unable to read max_mem_nodes");
342 return;
343 }
344
345 if (mdb_ctf_lookup_by_name("unix`hw_page_map_t", &id) == -1 ||
346 mdb_ctf_type_resolve(id, &rid) == -1 ||
347 (hwpm_size = mdb_ctf_type_size(rid)) < 0) {
348 mdb_warn("unable to lookup unix`hw_page_map_t");
349 return;
350 }
351
352 counters = mdb_alloc(sym.st_size, UM_SLEEP | UM_GC);
353
354 if (mdb_vread(counters, sym.st_size, (uintptr_t)sym.st_value) == -1) {
355 mdb_warn("unable to read page_counters");
356 return;
357 }
358
359 ncounters = sym.st_size / sizeof (counters);
360
361 for (idx = 0; idx < ncounters; idx++) {
362 uintptr_t addr = counters[idx];
363 if (addr != 0)
364 leaky_grep(addr, hwpm_size * max_mem_nodes);
365 }
366 }
367
368 int
369 leaky_subr_estimate(size_t *estp)
370 {
371 uintptr_t panicstr;
372 int state;
373
374 if ((state = mdb_get_state()) == MDB_STATE_RUNNING) {
375 mdb_warn("findleaks: can only be run on a system "
376 "dump or under kmdb; see dumpadm(1M)\n");
377 return (DCMD_ERR);
378 }
379
380 if (mdb_readvar(&panicstr, "panicstr") == -1) {
381 mdb_warn("can't read variable 'panicstr'");
382 return (DCMD_ERR);
383 }
384
385 if (state != MDB_STATE_STOPPED && panicstr == NULL) {
386 mdb_warn("findleaks: cannot be run on a live dump.\n");
387 return (DCMD_ERR);
388 }
389
390 if (mdb_walk("kmem_cache", (mdb_walk_cb_t)leaky_estimate, estp) == -1) {
391 mdb_warn("couldn't walk 'kmem_cache'");
392 return (DCMD_ERR);
393 }
394
395 if (*estp == 0) {
396 mdb_warn("findleaks: no buffers found\n");
397 return (DCMD_ERR);
398 }
399
400 if (mdb_walk("vmem", (mdb_walk_cb_t)leaky_estimate_vmem, estp) == -1) {
401 mdb_warn("couldn't walk 'vmem'");
402 return (DCMD_ERR);
403 }
404
405 return (DCMD_OK);
406 }
407
408 int
409 leaky_subr_fill(leak_mtab_t **lmpp)
410 {
411 if (mdb_walk("vmem", (mdb_walk_cb_t)leaky_vmem, lmpp) == -1) {
412 mdb_warn("couldn't walk 'vmem'");
413 return (DCMD_ERR);
414 }
415
416 if (mdb_walk("kmem_cache", (mdb_walk_cb_t)leaky_cache, lmpp) == -1) {
417 mdb_warn("couldn't walk 'kmem_cache'");
418 return (DCMD_ERR);
419 }
420
421 if (mdb_readvar(&kmem_lite_count, "kmem_lite_count") == -1) {
422 mdb_warn("couldn't read 'kmem_lite_count'");
423 kmem_lite_count = 0;
424 } else if (kmem_lite_count > 16) {
425 mdb_warn("kmem_lite_count nonsensical, ignored\n");
426 kmem_lite_count = 0;
427 }
428
429 return (DCMD_OK);
430 }
431
432 int
433 leaky_subr_run(void)
434 {
435 unsigned long ps = PAGESIZE;
436 uintptr_t kstat_arena;
437 uintptr_t dmods;
438
439 leaky_kludge();
440
441 if (mdb_walk("kmem_cache", (mdb_walk_cb_t)leaky_scan_cache,
442 NULL) == -1) {
443 mdb_warn("couldn't walk 'kmem_cache'");
444 return (DCMD_ERR);
445 }
446
447 if (mdb_walk("modctl", (mdb_walk_cb_t)leaky_modctl, NULL) == -1) {
448 mdb_warn("couldn't walk 'modctl'");
449 return (DCMD_ERR);
450 }
451
452 /*
453 * If kmdb is loaded, we need to walk it's module list, since kmdb
454 * modctl structures can reference kmem allocations.
455 */
456 if ((mdb_readvar(&dmods, "kdi_dmods") != -1) && (dmods != NULL))
457 (void) mdb_pwalk("modctl", (mdb_walk_cb_t)leaky_modctl,
458 NULL, dmods);
459
460 if (mdb_walk("thread", (mdb_walk_cb_t)leaky_thread, &ps) == -1) {
461 mdb_warn("couldn't walk 'thread'");
462 return (DCMD_ERR);
463 }
464
465 if (mdb_walk("deathrow", (mdb_walk_cb_t)leaky_thread, &ps) == -1) {
466 mdb_warn("couldn't walk 'deathrow'");
467 return (DCMD_ERR);
468 }
469
470 if (mdb_readvar(&kstat_arena, "kstat_arena") == -1) {
471 mdb_warn("couldn't read 'kstat_arena'");
472 return (DCMD_ERR);
473 }
474
475 if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)leaky_kstat,
476 NULL, kstat_arena) == -1) {
477 mdb_warn("couldn't walk kstat vmem arena");
478 return (DCMD_ERR);
479 }
480
481 return (DCMD_OK);
482 }
483
484 void
485 leaky_subr_add_leak(leak_mtab_t *lmp)
486 {
487 uintptr_t addr = LKM_CTLPTR(lmp->lkm_bufctl);
488 size_t depth;
489
490 switch (LKM_CTLTYPE(lmp->lkm_bufctl)) {
491 case LKM_CTL_VMSEG: {
492 vmem_seg_t vs;
493
494 if (mdb_vread(&vs, sizeof (vs), addr) == -1) {
495 mdb_warn("couldn't read leaked vmem_seg at addr %p",
496 addr);
497 return;
498 }
499 depth = MIN(vs.vs_depth, VMEM_STACK_DEPTH);
500
501 leaky_add_leak(TYPE_VMEM, addr, vs.vs_start, vs.vs_timestamp,
502 vs.vs_stack, depth, 0, (vs.vs_end - vs.vs_start));
503 break;
504 }
505 case LKM_CTL_BUFCTL: {
506 kmem_bufctl_audit_t bc;
507
508 if (mdb_vread(&bc, sizeof (bc), addr) == -1) {
509 mdb_warn("couldn't read leaked bufctl at addr %p",
510 addr);
511 return;
512 }
513
514 depth = MIN(bc.bc_depth, KMEM_STACK_DEPTH);
515
516 /*
517 * The top of the stack will be kmem_cache_alloc+offset.
518 * Since the offset in kmem_cache_alloc() isn't interesting
519 * we skip that frame for the purposes of uniquifying stacks.
520 *
521 * We also use the cache pointer as the leaks's cid, to
522 * prevent the coalescing of leaks from different caches.
523 */
524 if (depth > 0)
525 depth--;
526 leaky_add_leak(TYPE_KMEM, addr, (uintptr_t)bc.bc_addr,
527 bc.bc_timestamp, bc.bc_stack + 1, depth,
528 (uintptr_t)bc.bc_cache, 0);
529 break;
530 }
531 case LKM_CTL_CACHE: {
532 kmem_cache_t cache;
533 kmem_buftag_lite_t bt;
534 pc_t caller;
535 int depth = 0;
536
537 /*
538 * For KMF_LITE caches, we can get the allocation PC
539 * out of the buftag structure.
540 */
541 if (mdb_vread(&cache, sizeof (cache), addr) != -1 &&
542 (cache.cache_flags & KMF_LITE) &&
543 kmem_lite_count > 0 &&
544 mdb_vread(&bt, sizeof (bt),
545 /* LINTED alignment */
546 (uintptr_t)KMEM_BUFTAG(&cache, lmp->lkm_base)) != -1) {
547 caller = bt.bt_history[0];
548 depth = 1;
549 }
550 leaky_add_leak(TYPE_CACHE, lmp->lkm_base, lmp->lkm_base, 0,
551 &caller, depth, addr, addr);
552 break;
553 }
554 default:
555 mdb_warn("internal error: invalid leak_bufctl_t\n");
556 break;
557 }
558 }
559
560 static void
561 leaky_subr_caller(const pc_t *stack, uint_t depth, char *buf, uintptr_t *pcp)
562 {
563 int i;
564 GElf_Sym sym;
565 uintptr_t pc = 0;
566
567 buf[0] = 0;
568
569 for (i = 0; i < depth; i++) {
570 pc = stack[i];
571
572 if (mdb_lookup_by_addr(pc,
573 MDB_SYM_FUZZY, buf, MDB_SYM_NAMLEN, &sym) == -1)
574 continue;
575 if (strncmp(buf, "kmem_", 5) == 0)
576 continue;
577 if (strncmp(buf, "vmem_", 5) == 0)
578 continue;
579 *pcp = pc;
580
581 return;
582 }
583
584 /*
585 * We're only here if the entire call chain begins with "kmem_";
586 * this shouldn't happen, but we'll just use the last caller.
587 */
588 *pcp = pc;
589 }
590
591 int
592 leaky_subr_bufctl_cmp(const leak_bufctl_t *lhs, const leak_bufctl_t *rhs)
593 {
594 char lbuf[MDB_SYM_NAMLEN], rbuf[MDB_SYM_NAMLEN];
595 uintptr_t lcaller, rcaller;
596 int rval;
597
598 leaky_subr_caller(lhs->lkb_stack, lhs->lkb_depth, lbuf, &lcaller);
599 leaky_subr_caller(rhs->lkb_stack, lhs->lkb_depth, rbuf, &rcaller);
600
601 if (rval = strcmp(lbuf, rbuf))
602 return (rval);
603
604 if (lcaller < rcaller)
605 return (-1);
606
607 if (lcaller > rcaller)
608 return (1);
609
610 if (lhs->lkb_data < rhs->lkb_data)
611 return (-1);
612
613 if (lhs->lkb_data > rhs->lkb_data)
614 return (1);
615
616 return (0);
617 }
618
619 /*
620 * Global state variables used by the leaky_subr_dump_* routines. Note that
621 * they are carefully cleared before use.
622 */
623 static int lk_vmem_seen;
624 static int lk_cache_seen;
625 static int lk_kmem_seen;
626 static size_t lk_ttl;
627 static size_t lk_bytes;
628
629 void
630 leaky_subr_dump_start(int type)
631 {
632 switch (type) {
633 case TYPE_VMEM:
634 lk_vmem_seen = 0;
635 break;
636 case TYPE_CACHE:
637 lk_cache_seen = 0;
638 break;
639 case TYPE_KMEM:
640 lk_kmem_seen = 0;
641 break;
642 default:
643 break;
644 }
645
646 lk_ttl = 0;
647 lk_bytes = 0;
648 }
649
650 void
651 leaky_subr_dump(const leak_bufctl_t *lkb, int verbose)
652 {
653 const leak_bufctl_t *cur;
654 kmem_cache_t cache;
655 size_t min, max, size;
656 char sz[30];
657 char c[MDB_SYM_NAMLEN];
658 uintptr_t caller;
659
660 if (verbose) {
661 lk_ttl = 0;
662 lk_bytes = 0;
663 }
664
665 switch (lkb->lkb_type) {
666 case TYPE_VMEM:
667 if (!verbose && !lk_vmem_seen) {
668 lk_vmem_seen = 1;
669 mdb_printf("%-16s %7s %?s %s\n",
670 "BYTES", "LEAKED", "VMEM_SEG", "CALLER");
671 }
672
673 min = max = lkb->lkb_data;
674
675 for (cur = lkb; cur != NULL; cur = cur->lkb_next) {
676 size = cur->lkb_data;
677
678 if (size < min)
679 min = size;
680 if (size > max)
681 max = size;
682
683 lk_ttl++;
684 lk_bytes += size;
685 }
686
687 if (min == max)
688 (void) mdb_snprintf(sz, sizeof (sz), "%ld", min);
689 else
690 (void) mdb_snprintf(sz, sizeof (sz), "%ld-%ld",
691 min, max);
692
693 if (!verbose) {
694 leaky_subr_caller(lkb->lkb_stack, lkb->lkb_depth,
695 c, &caller);
696
697 if (caller != 0) {
698 (void) mdb_snprintf(c, sizeof (c),
699 "%a", caller);
700 } else {
701 (void) mdb_snprintf(c, sizeof (c),
702 "%s", "?");
703 }
704 mdb_printf("%-16s %7d %?p %s\n", sz, lkb->lkb_dups + 1,
705 lkb->lkb_addr, c);
706 } else {
707 mdb_arg_t v;
708
709 if (lk_ttl == 1)
710 mdb_printf("kmem_oversize leak: 1 vmem_seg, "
711 "%ld bytes\n", lk_bytes);
712 else
713 mdb_printf("kmem_oversize leak: %d vmem_segs, "
714 "%s bytes each, %ld bytes total\n",
715 lk_ttl, sz, lk_bytes);
716
717 v.a_type = MDB_TYPE_STRING;
718 v.a_un.a_str = "-v";
719
720 if (mdb_call_dcmd("vmem_seg", lkb->lkb_addr,
721 DCMD_ADDRSPEC, 1, &v) == -1) {
722 mdb_warn("'%p::vmem_seg -v' failed",
723 lkb->lkb_addr);
724 }
725 }
726 return;
727
728 case TYPE_CACHE:
729 if (!verbose && !lk_cache_seen) {
730 lk_cache_seen = 1;
731 if (lk_vmem_seen)
732 mdb_printf("\n");
733 mdb_printf("%-?s %7s %?s %s\n",
734 "CACHE", "LEAKED", "BUFFER", "CALLER");
735 }
736
737 if (mdb_vread(&cache, sizeof (cache), lkb->lkb_data) == -1) {
738 /*
739 * This _really_ shouldn't happen; we shouldn't
740 * have been able to get this far if this
741 * cache wasn't readable.
742 */
743 mdb_warn("can't read cache %p for leaked "
744 "buffer %p", lkb->lkb_data, lkb->lkb_addr);
745 return;
746 }
747
748 lk_ttl += lkb->lkb_dups + 1;
749 lk_bytes += (lkb->lkb_dups + 1) * cache.cache_bufsize;
750
751 caller = (lkb->lkb_depth == 0) ? 0 : lkb->lkb_stack[0];
752 if (caller != 0) {
753 (void) mdb_snprintf(c, sizeof (c), "%a", caller);
754 } else {
755 (void) mdb_snprintf(c, sizeof (c),
756 "%s", (verbose) ? "" : "?");
757 }
758
759 if (!verbose) {
760 mdb_printf("%0?p %7d %0?p %s\n", lkb->lkb_cid,
761 lkb->lkb_dups + 1, lkb->lkb_addr, c);
762 } else {
763 if (lk_ttl == 1)
764 mdb_printf("%s leak: 1 buffer, %ld bytes,\n",
765 cache.cache_name, lk_bytes);
766 else
767 mdb_printf("%s leak: %d buffers, "
768 "%ld bytes each, %ld bytes total,\n",
769 cache.cache_name, lk_ttl,
770 cache.cache_bufsize, lk_bytes);
771
772 mdb_printf(" sample addr %p%s%s\n",
773 lkb->lkb_addr, (caller == 0) ? "" : ", caller ", c);
774 }
775 return;
776
777 case TYPE_KMEM:
778 if (!verbose && !lk_kmem_seen) {
779 lk_kmem_seen = 1;
780 if (lk_vmem_seen || lk_cache_seen)
781 mdb_printf("\n");
782 mdb_printf("%-?s %7s %?s %s\n",
783 "CACHE", "LEAKED", "BUFCTL", "CALLER");
784 }
785
786 if (mdb_vread(&cache, sizeof (cache), lkb->lkb_cid) == -1) {
787 /*
788 * This _really_ shouldn't happen; we shouldn't
789 * have been able to get this far if this
790 * cache wasn't readable.
791 */
792 mdb_warn("can't read cache %p for leaked "
793 "bufctl %p", lkb->lkb_cid, lkb->lkb_addr);
794 return;
795 }
796
797 lk_ttl += lkb->lkb_dups + 1;
798 lk_bytes += (lkb->lkb_dups + 1) * cache.cache_bufsize;
799
800 if (!verbose) {
801 leaky_subr_caller(lkb->lkb_stack, lkb->lkb_depth,
802 c, &caller);
803
804 if (caller != 0) {
805 (void) mdb_snprintf(c, sizeof (c),
806 "%a", caller);
807 } else {
808 (void) mdb_snprintf(c, sizeof (c),
809 "%s", "?");
810 }
811 mdb_printf("%0?p %7d %0?p %s\n", lkb->lkb_cid,
812 lkb->lkb_dups + 1, lkb->lkb_addr, c);
813 } else {
814 mdb_arg_t v;
815
816 if (lk_ttl == 1)
817 mdb_printf("%s leak: 1 buffer, %ld bytes\n",
818 cache.cache_name, lk_bytes);
819 else
820 mdb_printf("%s leak: %d buffers, "
821 "%ld bytes each, %ld bytes total\n",
822 cache.cache_name, lk_ttl,
823 cache.cache_bufsize, lk_bytes);
824
825 v.a_type = MDB_TYPE_STRING;
826 v.a_un.a_str = "-v";
827
828 if (mdb_call_dcmd("bufctl", lkb->lkb_addr,
829 DCMD_ADDRSPEC, 1, &v) == -1) {
830 mdb_warn("'%p::bufctl -v' failed",
831 lkb->lkb_addr);
832 }
833 }
834 return;
835
836 default:
837 return;
838 }
839 }
840
841 void
842 leaky_subr_dump_end(int type)
843 {
844 int i;
845 int width;
846 const char *leaks;
847
848 switch (type) {
849 case TYPE_VMEM:
850 if (!lk_vmem_seen)
851 return;
852
853 width = 16;
854 leaks = "kmem_oversize leak";
855 break;
856
857 case TYPE_CACHE:
858 if (!lk_cache_seen)
859 return;
860
861 width = sizeof (uintptr_t) * 2;
862 leaks = "buffer";
863 break;
864
865 case TYPE_KMEM:
866 if (!lk_kmem_seen)
867 return;
868
869 width = sizeof (uintptr_t) * 2;
870 leaks = "buffer";
871 break;
872
873 default:
874 return;
875 }
876
877 for (i = 0; i < 72; i++)
878 mdb_printf("-");
879 mdb_printf("\n%*s %7ld %s%s, %ld byte%s\n",
880 width, "Total", lk_ttl, leaks, (lk_ttl == 1) ? "" : "s",
881 lk_bytes, (lk_bytes == 1) ? "" : "s");
882 }
883
884 int
885 leaky_subr_invoke_callback(const leak_bufctl_t *lkb, mdb_walk_cb_t cb,
886 void *cbdata)
887 {
888 kmem_bufctl_audit_t bc;
889 vmem_seg_t vs;
890
891 switch (lkb->lkb_type) {
892 case TYPE_VMEM:
893 if (mdb_vread(&vs, sizeof (vs), lkb->lkb_addr) == -1) {
894 mdb_warn("unable to read vmem_seg at %p",
895 lkb->lkb_addr);
896 return (WALK_NEXT);
897 }
898 return (cb(lkb->lkb_addr, &vs, cbdata));
899
900 case TYPE_CACHE:
901 return (cb(lkb->lkb_addr, NULL, cbdata));
902
903 case TYPE_KMEM:
904 if (mdb_vread(&bc, sizeof (bc), lkb->lkb_addr) == -1) {
905 mdb_warn("unable to read bufctl at %p",
906 lkb->lkb_addr);
907 return (WALK_NEXT);
908 }
909 return (cb(lkb->lkb_addr, &bc, cbdata));
910 default:
911 return (WALK_NEXT);
912 }
913 }
--- EOF ---