Annotation of sys/kern/kern_malloc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: kern_malloc.c,v 1.70 2007/05/29 00:17:32 thib Exp $ */
2: /* $NetBSD: kern_malloc.c,v 1.15.4.2 1996/06/13 17:10:56 cgd Exp $ */
3:
4: /*
5: * Copyright (c) 1987, 1991, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)kern_malloc.c 8.3 (Berkeley) 1/4/94
33: */
34:
35: #include <sys/param.h>
36: #include <sys/proc.h>
37: #include <sys/kernel.h>
38: #include <sys/malloc.h>
39: #include <sys/systm.h>
40: #include <sys/sysctl.h>
41: #include <sys/time.h>
42: #include <sys/rwlock.h>
43:
44: #include <uvm/uvm_extern.h>
45:
46: static struct vm_map kmem_map_store;
47: struct vm_map *kmem_map = NULL;
48:
49: #ifdef NKMEMCLUSTERS
50: #error NKMEMCLUSTERS is obsolete; remove it from your kernel config file and use NKMEMPAGES instead or let the kernel auto-size
51: #endif
52:
53: /*
54: * Default number of pages in kmem_map. We attempt to calculate this
55: * at run-time, but allow it to be either patched or set in the kernel
56: * config file.
57: */
58: #ifndef NKMEMPAGES
59: #define NKMEMPAGES 0
60: #endif
61: u_int nkmempages = NKMEMPAGES;
62:
63: /*
64: * Defaults for lower- and upper-bounds for the kmem_map page count.
65: * Can be overridden by kernel config options.
66: */
67: #ifndef NKMEMPAGES_MIN
68: #define NKMEMPAGES_MIN NKMEMPAGES_MIN_DEFAULT
69: #endif
70: u_int nkmempages_min = 0;
71:
72: #ifndef NKMEMPAGES_MAX
73: #define NKMEMPAGES_MAX NKMEMPAGES_MAX_DEFAULT
74: #endif
75: u_int nkmempages_max = 0;
76:
77: struct kmembuckets bucket[MINBUCKET + 16];
78: struct kmemstats kmemstats[M_LAST];
79: struct kmemusage *kmemusage;
80: char *kmembase, *kmemlimit;
81: char buckstring[16 * sizeof("123456,")];
82: int buckstring_init = 0;
83: #if defined(KMEMSTATS) || defined(DIAGNOSTIC) || defined(FFS_SOFTUPDATES)
84: char *memname[] = INITKMEMNAMES;
85: char *memall = NULL;
86: struct rwlock sysctl_kmemlock = RWLOCK_INITIALIZER("sysctlklk");
87: #endif
88:
89: #ifdef DIAGNOSTIC
90: /*
91: * This structure provides a set of masks to catch unaligned frees.
92: */
93: const long addrmask[] = { 0,
94: 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
95: 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
96: 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
97: 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
98: };
99:
100: /*
101: * The WEIRD_ADDR is used as known text to copy into free objects so
102: * that modifications after frees can be detected.
103: */
104: #ifdef DEADBEEF0
105: #define WEIRD_ADDR ((unsigned) DEADBEEF0)
106: #else
107: #define WEIRD_ADDR ((unsigned) 0xdeadbeef)
108: #endif
109: #define MAX_COPY 32
110:
111: /*
112: * Normally the freelist structure is used only to hold the list pointer
113: * for free objects. However, when running with diagnostics, the first
114: * 8 bytes of the structure is unused except for diagnostic information,
115: * and the free list pointer is at offset 8 in the structure. Since the
116: * first 8 bytes is the portion of the structure most often modified, this
117: * helps to detect memory reuse problems and avoid free list corruption.
118: */
119: struct freelist {
120: int32_t spare0;
121: int16_t type;
122: int16_t spare1;
123: caddr_t next;
124: };
125: #else /* !DIAGNOSTIC */
126: struct freelist {
127: caddr_t next;
128: };
129: #endif /* DIAGNOSTIC */
130:
131: #ifndef SMALL_KERNEL
132: struct timeval malloc_errintvl = { 5, 0 };
133: struct timeval malloc_lasterr;
134: #endif
135:
136: /*
137: * Allocate a block of memory
138: */
139: void *
140: malloc(unsigned long size, int type, int flags)
141: {
142: struct kmembuckets *kbp;
143: struct kmemusage *kup;
144: struct freelist *freep;
145: long indx, npg, allocsize;
146: int s;
147: caddr_t va, cp, savedlist;
148: #ifdef DIAGNOSTIC
149: int32_t *end, *lp;
150: int copysize;
151: char *savedtype;
152: #endif
153: #ifdef KMEMSTATS
154: struct kmemstats *ksp = &kmemstats[type];
155:
156: if (((unsigned long)type) >= M_LAST)
157: panic("malloc - bogus type");
158: #endif
159:
160: #ifdef MALLOC_DEBUG
161: if (debug_malloc(size, type, flags, (void **)&va))
162: return (va);
163: #endif
164:
165: if (size > 65535 * PAGE_SIZE) {
166: if (flags & M_CANFAIL) {
167: #ifndef SMALL_KERNEL
168: if (ratecheck(&malloc_lasterr, &malloc_errintvl))
169: printf("malloc(): allocation too large, "
170: "type = %d, size = %lu\n", type, size);
171: #endif
172: return (NULL);
173: } else
174: panic("malloc: allocation too large");
175: }
176:
177: indx = BUCKETINDX(size);
178: kbp = &bucket[indx];
179: s = splvm();
180: #ifdef KMEMSTATS
181: while (ksp->ks_memuse >= ksp->ks_limit) {
182: if (flags & M_NOWAIT) {
183: splx(s);
184: return (NULL);
185: }
186: if (ksp->ks_limblocks < 65535)
187: ksp->ks_limblocks++;
188: tsleep(ksp, PSWP+2, memname[type], 0);
189: }
190: ksp->ks_size |= 1 << indx;
191: #endif
192: #ifdef DIAGNOSTIC
193: copysize = 1 << indx < MAX_COPY ? 1 << indx : MAX_COPY;
194: #endif
195: if (kbp->kb_next == NULL) {
196: kbp->kb_last = NULL;
197: if (size > MAXALLOCSAVE)
198: allocsize = round_page(size);
199: else
200: allocsize = 1 << indx;
201: npg = btoc(allocsize);
202: va = (caddr_t) uvm_km_kmemalloc(kmem_map, NULL,
203: (vsize_t)ctob(npg),
204: ((flags & M_NOWAIT) ? UVM_KMF_NOWAIT : 0) |
205: ((flags & M_CANFAIL) ? UVM_KMF_CANFAIL : 0));
206: if (va == NULL) {
207: /*
208: * Kmem_malloc() can return NULL, even if it can
209: * wait, if there is no map space available, because
210: * it can't fix that problem. Neither can we,
211: * right now. (We should release pages which
212: * are completely free and which are in buckets
213: * with too many free elements.)
214: */
215: if ((flags & (M_NOWAIT|M_CANFAIL)) == 0)
216: panic("malloc: out of space in kmem_map");
217: splx(s);
218: return (NULL);
219: }
220: #ifdef KMEMSTATS
221: kbp->kb_total += kbp->kb_elmpercl;
222: #endif
223: kup = btokup(va);
224: kup->ku_indx = indx;
225: if (allocsize > MAXALLOCSAVE) {
226: kup->ku_pagecnt = npg;
227: #ifdef KMEMSTATS
228: ksp->ks_memuse += allocsize;
229: #endif
230: goto out;
231: }
232: #ifdef KMEMSTATS
233: kup->ku_freecnt = kbp->kb_elmpercl;
234: kbp->kb_totalfree += kbp->kb_elmpercl;
235: #endif
236: /*
237: * Just in case we blocked while allocating memory,
238: * and someone else also allocated memory for this
239: * bucket, don't assume the list is still empty.
240: */
241: savedlist = kbp->kb_next;
242: kbp->kb_next = cp = va + (npg * PAGE_SIZE) - allocsize;
243: for (;;) {
244: freep = (struct freelist *)cp;
245: #ifdef DIAGNOSTIC
246: /*
247: * Copy in known text to detect modification
248: * after freeing.
249: */
250: end = (int32_t *)&cp[copysize];
251: for (lp = (int32_t *)cp; lp < end; lp++)
252: *lp = WEIRD_ADDR;
253: freep->type = M_FREE;
254: #endif /* DIAGNOSTIC */
255: if (cp <= va)
256: break;
257: cp -= allocsize;
258: freep->next = cp;
259: }
260: freep->next = savedlist;
261: if (kbp->kb_last == NULL)
262: kbp->kb_last = (caddr_t)freep;
263: }
264: va = kbp->kb_next;
265: kbp->kb_next = ((struct freelist *)va)->next;
266: #ifdef DIAGNOSTIC
267: freep = (struct freelist *)va;
268: savedtype = (unsigned)freep->type < M_LAST ?
269: memname[freep->type] : "???";
270: if (kbp->kb_next) {
271: int rv;
272: vaddr_t addr = (vaddr_t)kbp->kb_next;
273:
274: vm_map_lock(kmem_map);
275: rv = uvm_map_checkprot(kmem_map, addr,
276: addr + sizeof(struct freelist), VM_PROT_WRITE);
277: vm_map_unlock(kmem_map);
278:
279: if (!rv) {
280: printf("%s %d of object %p size 0x%lx %s %s (invalid addr %p)\n",
281: "Data modified on freelist: word",
282: (int32_t *)&kbp->kb_next - (int32_t *)kbp, va, size,
283: "previous type", savedtype, kbp->kb_next);
284: kbp->kb_next = NULL;
285: }
286: }
287:
288: /* Fill the fields that we've used with WEIRD_ADDR */
289: #if BYTE_ORDER == BIG_ENDIAN
290: freep->type = WEIRD_ADDR >> 16;
291: #endif
292: #if BYTE_ORDER == LITTLE_ENDIAN
293: freep->type = (short)WEIRD_ADDR;
294: #endif
295: end = (int32_t *)&freep->next +
296: (sizeof(freep->next) / sizeof(int32_t));
297: for (lp = (int32_t *)&freep->next; lp < end; lp++)
298: *lp = WEIRD_ADDR;
299:
300: /* and check that the data hasn't been modified. */
301: end = (int32_t *)&va[copysize];
302: for (lp = (int32_t *)va; lp < end; lp++) {
303: if (*lp == WEIRD_ADDR)
304: continue;
305: printf("%s %d of object %p size 0x%lx %s %s (0x%x != 0x%x)\n",
306: "Data modified on freelist: word", lp - (int32_t *)va,
307: va, size, "previous type", savedtype, *lp, WEIRD_ADDR);
308: break;
309: }
310:
311: freep->spare0 = 0;
312: #endif /* DIAGNOSTIC */
313: #ifdef KMEMSTATS
314: kup = btokup(va);
315: if (kup->ku_indx != indx)
316: panic("malloc: wrong bucket");
317: if (kup->ku_freecnt == 0)
318: panic("malloc: lost data");
319: kup->ku_freecnt--;
320: kbp->kb_totalfree--;
321: ksp->ks_memuse += 1 << indx;
322: out:
323: kbp->kb_calls++;
324: ksp->ks_inuse++;
325: ksp->ks_calls++;
326: if (ksp->ks_memuse > ksp->ks_maxused)
327: ksp->ks_maxused = ksp->ks_memuse;
328: #else
329: out:
330: #endif
331: splx(s);
332: return (va);
333: }
334:
335: /*
336: * Free a block of memory allocated by malloc.
337: */
338: void
339: free(void *addr, int type)
340: {
341: struct kmembuckets *kbp;
342: struct kmemusage *kup;
343: struct freelist *freep;
344: long size;
345: int s;
346: #ifdef DIAGNOSTIC
347: caddr_t cp;
348: int32_t *end, *lp;
349: long alloc, copysize;
350: #endif
351: #ifdef KMEMSTATS
352: struct kmemstats *ksp = &kmemstats[type];
353: #endif
354:
355: #ifdef MALLOC_DEBUG
356: if (debug_free(addr, type))
357: return;
358: #endif
359:
360: #ifdef DIAGNOSTIC
361: if (addr < (void *)kmembase || addr >= (void *)kmemlimit)
362: panic("free: non-malloced addr %p type %s", addr,
363: memname[type]);
364: #endif
365:
366: kup = btokup(addr);
367: size = 1 << kup->ku_indx;
368: kbp = &bucket[kup->ku_indx];
369: s = splvm();
370: #ifdef DIAGNOSTIC
371: /*
372: * Check for returns of data that do not point to the
373: * beginning of the allocation.
374: */
375: if (size > PAGE_SIZE)
376: alloc = addrmask[BUCKETINDX(PAGE_SIZE)];
377: else
378: alloc = addrmask[kup->ku_indx];
379: if (((u_long)addr & alloc) != 0)
380: panic("free: unaligned addr %p, size %ld, type %s, mask %ld",
381: addr, size, memname[type], alloc);
382: #endif /* DIAGNOSTIC */
383: if (size > MAXALLOCSAVE) {
384: uvm_km_free(kmem_map, (vaddr_t)addr, ctob(kup->ku_pagecnt));
385: #ifdef KMEMSTATS
386: size = kup->ku_pagecnt << PGSHIFT;
387: ksp->ks_memuse -= size;
388: kup->ku_indx = 0;
389: kup->ku_pagecnt = 0;
390: if (ksp->ks_memuse + size >= ksp->ks_limit &&
391: ksp->ks_memuse < ksp->ks_limit)
392: wakeup(ksp);
393: ksp->ks_inuse--;
394: kbp->kb_total -= 1;
395: #endif
396: splx(s);
397: return;
398: }
399: freep = (struct freelist *)addr;
400: #ifdef DIAGNOSTIC
401: /*
402: * Check for multiple frees. Use a quick check to see if
403: * it looks free before laboriously searching the freelist.
404: */
405: if (freep->spare0 == WEIRD_ADDR) {
406: for (cp = kbp->kb_next; cp;
407: cp = ((struct freelist *)cp)->next) {
408: if (addr != cp)
409: continue;
410: printf("multiply freed item %p\n", addr);
411: panic("free: duplicated free");
412: }
413: }
414: /*
415: * Copy in known text to detect modification after freeing
416: * and to make it look free. Also, save the type being freed
417: * so we can list likely culprit if modification is detected
418: * when the object is reallocated.
419: */
420: copysize = size < MAX_COPY ? size : MAX_COPY;
421: end = (int32_t *)&((caddr_t)addr)[copysize];
422: for (lp = (int32_t *)addr; lp < end; lp++)
423: *lp = WEIRD_ADDR;
424: freep->type = type;
425: #endif /* DIAGNOSTIC */
426: #ifdef KMEMSTATS
427: kup->ku_freecnt++;
428: if (kup->ku_freecnt >= kbp->kb_elmpercl) {
429: if (kup->ku_freecnt > kbp->kb_elmpercl)
430: panic("free: multiple frees");
431: else if (kbp->kb_totalfree > kbp->kb_highwat)
432: kbp->kb_couldfree++;
433: }
434: kbp->kb_totalfree++;
435: ksp->ks_memuse -= size;
436: if (ksp->ks_memuse + size >= ksp->ks_limit &&
437: ksp->ks_memuse < ksp->ks_limit)
438: wakeup(ksp);
439: ksp->ks_inuse--;
440: #endif
441: if (kbp->kb_next == NULL)
442: kbp->kb_next = addr;
443: else
444: ((struct freelist *)kbp->kb_last)->next = addr;
445: freep->next = NULL;
446: kbp->kb_last = addr;
447: splx(s);
448: }
449:
450: /*
451: * Compute the number of pages that kmem_map will map, that is,
452: * the size of the kernel malloc arena.
453: */
454: void
455: kmeminit_nkmempages(void)
456: {
457: u_int npages;
458:
459: if (nkmempages != 0) {
460: /*
461: * It's already been set (by us being here before, or
462: * by patching or kernel config options), bail out now.
463: */
464: return;
465: }
466:
467: /*
468: * We can't initialize these variables at compilation time, since
469: * the page size may not be known (on sparc GENERIC kernels, for
470: * example). But we still want the MD code to be able to provide
471: * better values.
472: */
473: if (nkmempages_min == 0)
474: nkmempages_min = NKMEMPAGES_MIN;
475: if (nkmempages_max == 0)
476: nkmempages_max = NKMEMPAGES_MAX;
477:
478: /*
479: * We use the following (simple) formula:
480: *
481: * - Starting point is physical memory / 4.
482: *
483: * - Clamp it down to nkmempages_max.
484: *
485: * - Round it up to nkmempages_min.
486: */
487: npages = physmem / 4;
488:
489: if (npages > nkmempages_max)
490: npages = nkmempages_max;
491:
492: if (npages < nkmempages_min)
493: npages = nkmempages_min;
494:
495: nkmempages = npages;
496: }
497:
498: /*
499: * Initialize the kernel memory allocator
500: */
501: void
502: kmeminit(void)
503: {
504: vaddr_t base, limit;
505: #ifdef KMEMSTATS
506: long indx;
507: #endif
508:
509: #ifdef DIAGNOSTIC
510: if (sizeof(struct freelist) > (1 << MINBUCKET))
511: panic("kmeminit: minbucket too small/struct freelist too big");
512: #endif
513:
514: /*
515: * Compute the number of kmem_map pages, if we have not
516: * done so already.
517: */
518: kmeminit_nkmempages();
519: base = vm_map_min(kernel_map);
520: kmem_map = uvm_km_suballoc(kernel_map, &base, &limit,
521: (vsize_t)(nkmempages * PAGE_SIZE), VM_MAP_INTRSAFE, FALSE,
522: &kmem_map_store);
523: kmembase = (char *)base;
524: kmemlimit = (char *)limit;
525: kmemusage = (struct kmemusage *) uvm_km_zalloc(kernel_map,
526: (vsize_t)(nkmempages * sizeof(struct kmemusage)));
527: #ifdef KMEMSTATS
528: for (indx = 0; indx < MINBUCKET + 16; indx++) {
529: if (1 << indx >= PAGE_SIZE)
530: bucket[indx].kb_elmpercl = 1;
531: else
532: bucket[indx].kb_elmpercl = PAGE_SIZE / (1 << indx);
533: bucket[indx].kb_highwat = 5 * bucket[indx].kb_elmpercl;
534: }
535: for (indx = 0; indx < M_LAST; indx++)
536: kmemstats[indx].ks_limit = nkmempages * PAGE_SIZE * 6 / 10;
537: #endif
538: #ifdef MALLOC_DEBUG
539: debug_malloc_init();
540: #endif
541: }
542:
543: /*
544: * Return kernel malloc statistics information.
545: */
546: int
547: sysctl_malloc(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
548: size_t newlen, struct proc *p)
549: {
550: struct kmembuckets kb;
551: int i, siz;
552:
553: if (namelen != 2 && name[0] != KERN_MALLOC_BUCKETS &&
554: name[0] != KERN_MALLOC_KMEMNAMES)
555: return (ENOTDIR); /* overloaded */
556:
557: switch (name[0]) {
558: case KERN_MALLOC_BUCKETS:
559: /* Initialize the first time */
560: if (buckstring_init == 0) {
561: buckstring_init = 1;
562: bzero(buckstring, sizeof(buckstring));
563: for (siz = 0, i = MINBUCKET; i < MINBUCKET + 16; i++) {
564: snprintf(buckstring + siz,
565: sizeof buckstring - siz,
566: "%d,", (u_int)(1<<i));
567: siz += strlen(buckstring + siz);
568: }
569: /* Remove trailing comma */
570: if (siz)
571: buckstring[siz - 1] = '\0';
572: }
573: return (sysctl_rdstring(oldp, oldlenp, newp, buckstring));
574:
575: case KERN_MALLOC_BUCKET:
576: bcopy(&bucket[BUCKETINDX(name[1])], &kb, sizeof(kb));
577: kb.kb_next = kb.kb_last = 0;
578: return (sysctl_rdstruct(oldp, oldlenp, newp, &kb, sizeof(kb)));
579: case KERN_MALLOC_KMEMSTATS:
580: #ifdef KMEMSTATS
581: if ((name[1] < 0) || (name[1] >= M_LAST))
582: return (EINVAL);
583: return (sysctl_rdstruct(oldp, oldlenp, newp,
584: &kmemstats[name[1]], sizeof(struct kmemstats)));
585: #else
586: return (EOPNOTSUPP);
587: #endif
588: case KERN_MALLOC_KMEMNAMES:
589: #if defined(KMEMSTATS) || defined(DIAGNOSTIC) || defined(FFS_SOFTUPDATES)
590: if (memall == NULL) {
591: int totlen;
592:
593: i = rw_enter(&sysctl_kmemlock, RW_WRITE|RW_INTR);
594: if (i)
595: return (i);
596:
597: /* Figure out how large a buffer we need */
598: for (totlen = 0, i = 0; i < M_LAST; i++) {
599: if (memname[i])
600: totlen += strlen(memname[i]);
601: totlen++;
602: }
603: memall = malloc(totlen + M_LAST, M_SYSCTL, M_WAITOK);
604: bzero(memall, totlen + M_LAST);
605: for (siz = 0, i = 0; i < M_LAST; i++) {
606: snprintf(memall + siz,
607: totlen + M_LAST - siz,
608: "%s,", memname[i] ? memname[i] : "");
609: siz += strlen(memall + siz);
610: }
611: /* Remove trailing comma */
612: if (siz)
613: memall[siz - 1] = '\0';
614:
615: /* Now, convert all spaces to underscores */
616: for (i = 0; i < totlen; i++)
617: if (memall[i] == ' ')
618: memall[i] = '_';
619: rw_exit_write(&sysctl_kmemlock);
620: }
621: return (sysctl_rdstring(oldp, oldlenp, newp, memall));
622: #else
623: return (EOPNOTSUPP);
624: #endif
625: default:
626: return (EOPNOTSUPP);
627: }
628: /* NOTREACHED */
629: }
630:
631: /*
632: * Round up a size to how much malloc would actually allocate.
633: */
634: size_t
635: malloc_roundup(size_t sz)
636: {
637: if (sz > MAXALLOCSAVE)
638: return round_page(sz);
639:
640: return (1 << BUCKETINDX(sz));
641: }
642:
643: #if defined(DDB)
644: #include <machine/db_machdep.h>
645: #include <ddb/db_interface.h>
646: #include <ddb/db_output.h>
647:
648: void
649: malloc_printit(int (*pr)(const char *, ...))
650: {
651: #ifdef KMEMSTATS
652: struct kmemstats *km;
653: int i;
654:
655: (*pr)("%15s %5s %6s %7s %6s %9s %8s %8s\n",
656: "Type", "InUse", "MemUse", "HighUse", "Limit", "Requests",
657: "Type Lim", "Kern Lim");
658: for (i = 0, km = kmemstats; i < M_LAST; i++, km++) {
659: if (!km->ks_calls || !memname[i])
660: continue;
661:
662: (*pr)("%15s %5ld %6ldK %7ldK %6ldK %9ld %8d %8d\n",
663: memname[i], km->ks_inuse, km->ks_memuse / 1024,
664: km->ks_maxused / 1024, km->ks_limit / 1024,
665: km->ks_calls, km->ks_limblocks, km->ks_mapblocks);
666: }
667: #else
668: (*pr)("No KMEMSTATS compiled in\n");
669: #endif
670: }
671: #endif /* DDB */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_malloc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern