kern_malloc.c revision 193490
1/*-
2 * Copyright (c) 1987, 1991, 1993
3 *	The Regents of the University of California.
4 * Copyright (c) 2005-2009 Robert N. M. Watson
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 4. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 *	@(#)kern_malloc.c	8.3 (Berkeley) 1/4/94
32 */
33
34/*
35 * Kernel malloc(9) implementation -- general purpose kernel memory allocator
36 * based on memory types.  Back end is implemented using the UMA(9) zone
37 * allocator.  A set of fixed-size buckets are used for smaller allocations,
38 * and a special UMA allocation interface is used for larger allocations.
39 * Callers declare memory types, and statistics are maintained independently
40 * for each memory type.  Statistics are maintained per-CPU for performance
41 * reasons.  See malloc(9) and comments in malloc.h for a detailed
42 * description.
43 */
44
45#include <sys/cdefs.h>
46__FBSDID("$FreeBSD: head/sys/kern/kern_malloc.c 193490 2009-06-05 09:16:52Z brian $");
47
48#include "opt_ddb.h"
49#include "opt_kdtrace.h"
50#include "opt_vm.h"
51
52#include <sys/param.h>
53#include <sys/systm.h>
54#include <sys/kdb.h>
55#include <sys/kernel.h>
56#include <sys/lock.h>
57#include <sys/malloc.h>
58#include <sys/mbuf.h>
59#include <sys/mutex.h>
60#include <sys/vmmeter.h>
61#include <sys/proc.h>
62#include <sys/sbuf.h>
63#include <sys/sysctl.h>
64#include <sys/time.h>
65
66#include <vm/vm.h>
67#include <vm/pmap.h>
68#include <vm/vm_param.h>
69#include <vm/vm_kern.h>
70#include <vm/vm_extern.h>
71#include <vm/vm_map.h>
72#include <vm/vm_page.h>
73#include <vm/uma.h>
74#include <vm/uma_int.h>
75#include <vm/uma_dbg.h>
76
77#ifdef DEBUG_MEMGUARD
78#include <vm/memguard.h>
79#endif
80#ifdef DEBUG_REDZONE
81#include <vm/redzone.h>
82#endif
83
84#if defined(INVARIANTS) && defined(__i386__)
85#include <machine/cpu.h>
86#endif
87
88#include <ddb/ddb.h>
89
90#ifdef KDTRACE_HOOKS
91#include <sys/dtrace_bsd.h>
92
93dtrace_malloc_probe_func_t	dtrace_malloc_probe;
94#endif
95
96/*
97 * When realloc() is called, if the new size is sufficiently smaller than
98 * the old size, realloc() will allocate a new, smaller block to avoid
99 * wasting memory. 'Sufficiently smaller' is defined as: newsize <=
100 * oldsize / 2^n, where REALLOC_FRACTION defines the value of 'n'.
101 */
102#ifndef REALLOC_FRACTION
103#define	REALLOC_FRACTION	1	/* new block if <= half the size */
104#endif
105
106/*
107 * Centrally define some common malloc types.
108 */
109MALLOC_DEFINE(M_CACHE, "cache", "Various Dynamically allocated caches");
110MALLOC_DEFINE(M_DEVBUF, "devbuf", "device driver memory");
111MALLOC_DEFINE(M_TEMP, "temp", "misc temporary data buffers");
112
113MALLOC_DEFINE(M_IP6OPT, "ip6opt", "IPv6 options");
114MALLOC_DEFINE(M_IP6NDP, "ip6ndp", "IPv6 Neighbor Discovery");
115
116static void kmeminit(void *);
117SYSINIT(kmem, SI_SUB_KMEM, SI_ORDER_FIRST, kmeminit, NULL);
118
119static MALLOC_DEFINE(M_FREE, "free", "should be on free list");
120
121static struct malloc_type *kmemstatistics;
122static vm_offset_t kmembase;
123static vm_offset_t kmemlimit;
124static int kmemcount;
125
126#define KMEM_ZSHIFT	4
127#define KMEM_ZBASE	16
128#define KMEM_ZMASK	(KMEM_ZBASE - 1)
129
130#define KMEM_ZMAX	PAGE_SIZE
131#define KMEM_ZSIZE	(KMEM_ZMAX >> KMEM_ZSHIFT)
132static u_int8_t kmemsize[KMEM_ZSIZE + 1];
133
134/*
135 * Small malloc(9) memory allocations are allocated from a set of UMA buckets
136 * of various sizes.
137 *
138 * XXX: The comment here used to read "These won't be powers of two for
139 * long."  It's possible that a significant amount of wasted memory could be
140 * recovered by tuning the sizes of these buckets.
141 */
142struct {
143	int kz_size;
144	char *kz_name;
145	uma_zone_t kz_zone;
146} kmemzones[] = {
147	{16, "16", NULL},
148	{32, "32", NULL},
149	{64, "64", NULL},
150	{128, "128", NULL},
151	{256, "256", NULL},
152	{512, "512", NULL},
153	{1024, "1024", NULL},
154	{2048, "2048", NULL},
155	{4096, "4096", NULL},
156#if PAGE_SIZE > 4096
157	{8192, "8192", NULL},
158#if PAGE_SIZE > 8192
159	{16384, "16384", NULL},
160#if PAGE_SIZE > 16384
161	{32768, "32768", NULL},
162#if PAGE_SIZE > 32768
163	{65536, "65536", NULL},
164#if PAGE_SIZE > 65536
165#error	"Unsupported PAGE_SIZE"
166#endif	/* 65536 */
167#endif	/* 32768 */
168#endif	/* 16384 */
169#endif	/* 8192 */
170#endif	/* 4096 */
171	{0, NULL},
172};
173
174/*
175 * Zone to allocate malloc type descriptions from.  For ABI reasons, memory
176 * types are described by a data structure passed by the declaring code, but
177 * the malloc(9) implementation has its own data structure describing the
178 * type and statistics.  This permits the malloc(9)-internal data structures
179 * to be modified without breaking binary-compiled kernel modules that
180 * declare malloc types.
181 */
182static uma_zone_t mt_zone;
183
184u_long vm_kmem_size;
185SYSCTL_ULONG(_vm, OID_AUTO, kmem_size, CTLFLAG_RD, &vm_kmem_size, 0,
186    "Size of kernel memory");
187
188static u_long vm_kmem_size_min;
189SYSCTL_ULONG(_vm, OID_AUTO, kmem_size_min, CTLFLAG_RD, &vm_kmem_size_min, 0,
190    "Minimum size of kernel memory");
191
192static u_long vm_kmem_size_max;
193SYSCTL_ULONG(_vm, OID_AUTO, kmem_size_max, CTLFLAG_RD, &vm_kmem_size_max, 0,
194    "Maximum size of kernel memory");
195
196static u_int vm_kmem_size_scale;
197SYSCTL_UINT(_vm, OID_AUTO, kmem_size_scale, CTLFLAG_RD, &vm_kmem_size_scale, 0,
198    "Scale factor for kernel memory size");
199
200/*
201 * The malloc_mtx protects the kmemstatistics linked list.
202 */
203struct mtx malloc_mtx;
204
205#ifdef MALLOC_PROFILE
206uint64_t krequests[KMEM_ZSIZE + 1];
207
208static int sysctl_kern_mprof(SYSCTL_HANDLER_ARGS);
209#endif
210
211static int sysctl_kern_malloc_stats(SYSCTL_HANDLER_ARGS);
212
213/*
214 * time_uptime of the last malloc(9) failure (induced or real).
215 */
216static time_t t_malloc_fail;
217
218/*
219 * malloc(9) fault injection -- cause malloc failures every (n) mallocs when
220 * the caller specifies M_NOWAIT.  If set to 0, no failures are caused.
221 */
222#ifdef MALLOC_MAKE_FAILURES
223SYSCTL_NODE(_debug, OID_AUTO, malloc, CTLFLAG_RD, 0,
224    "Kernel malloc debugging options");
225
226static int malloc_failure_rate;
227static int malloc_nowait_count;
228static int malloc_failure_count;
229SYSCTL_INT(_debug_malloc, OID_AUTO, failure_rate, CTLFLAG_RW,
230    &malloc_failure_rate, 0, "Every (n) mallocs with M_NOWAIT will fail");
231TUNABLE_INT("debug.malloc.failure_rate", &malloc_failure_rate);
232SYSCTL_INT(_debug_malloc, OID_AUTO, failure_count, CTLFLAG_RD,
233    &malloc_failure_count, 0, "Number of imposed M_NOWAIT malloc failures");
234#endif
235
236int
237malloc_last_fail(void)
238{
239
240	return (time_uptime - t_malloc_fail);
241}
242
243/*
244 * An allocation has succeeded -- update malloc type statistics for the
245 * amount of bucket size.  Occurs within a critical section so that the
246 * thread isn't preempted and doesn't migrate while updating per-PCU
247 * statistics.
248 */
249static void
250malloc_type_zone_allocated(struct malloc_type *mtp, unsigned long size,
251    int zindx)
252{
253	struct malloc_type_internal *mtip;
254	struct malloc_type_stats *mtsp;
255
256	critical_enter();
257	mtip = mtp->ks_handle;
258	mtsp = &mtip->mti_stats[curcpu];
259	if (size > 0) {
260		mtsp->mts_memalloced += size;
261		mtsp->mts_numallocs++;
262	}
263	if (zindx != -1)
264		mtsp->mts_size |= 1 << zindx;
265
266#ifdef KDTRACE_HOOKS
267	if (dtrace_malloc_probe != NULL) {
268		uint32_t probe_id = mtip->mti_probes[DTMALLOC_PROBE_MALLOC];
269		if (probe_id != 0)
270			(dtrace_malloc_probe)(probe_id,
271			    (uintptr_t) mtp, (uintptr_t) mtip,
272			    (uintptr_t) mtsp, size, zindx);
273	}
274#endif
275
276	critical_exit();
277}
278
279void
280malloc_type_allocated(struct malloc_type *mtp, unsigned long size)
281{
282
283	if (size > 0)
284		malloc_type_zone_allocated(mtp, size, -1);
285}
286
287/*
288 * A free operation has occurred -- update malloc type statistics for the
289 * amount of the bucket size.  Occurs within a critical section so that the
290 * thread isn't preempted and doesn't migrate while updating per-CPU
291 * statistics.
292 */
293void
294malloc_type_freed(struct malloc_type *mtp, unsigned long size)
295{
296	struct malloc_type_internal *mtip;
297	struct malloc_type_stats *mtsp;
298
299	critical_enter();
300	mtip = mtp->ks_handle;
301	mtsp = &mtip->mti_stats[curcpu];
302	mtsp->mts_memfreed += size;
303	mtsp->mts_numfrees++;
304
305#ifdef KDTRACE_HOOKS
306	if (dtrace_malloc_probe != NULL) {
307		uint32_t probe_id = mtip->mti_probes[DTMALLOC_PROBE_FREE];
308		if (probe_id != 0)
309			(dtrace_malloc_probe)(probe_id,
310			    (uintptr_t) mtp, (uintptr_t) mtip,
311			    (uintptr_t) mtsp, size, 0);
312	}
313#endif
314
315	critical_exit();
316}
317
318/*
319 *	malloc:
320 *
321 *	Allocate a block of memory.
322 *
323 *	If M_NOWAIT is set, this routine will not block and return NULL if
324 *	the allocation fails.
325 */
326void *
327malloc(unsigned long size, struct malloc_type *mtp, int flags)
328{
329	int indx;
330	caddr_t va;
331	uma_zone_t zone;
332#if defined(DIAGNOSTIC) || defined(DEBUG_REDZONE)
333	unsigned long osize = size;
334#endif
335
336#ifdef INVARIANTS
337	KASSERT(mtp->ks_magic == M_MAGIC, ("malloc: bad malloc type magic"));
338	/*
339	 * Check that exactly one of M_WAITOK or M_NOWAIT is specified.
340	 */
341	indx = flags & (M_WAITOK | M_NOWAIT);
342	if (indx != M_NOWAIT && indx != M_WAITOK) {
343		static	struct timeval lasterr;
344		static	int curerr, once;
345		if (once == 0 && ppsratecheck(&lasterr, &curerr, 1)) {
346			printf("Bad malloc flags: %x\n", indx);
347			kdb_backtrace();
348			flags |= M_WAITOK;
349			once++;
350		}
351	}
352#endif
353#ifdef MALLOC_MAKE_FAILURES
354	if ((flags & M_NOWAIT) && (malloc_failure_rate != 0)) {
355		atomic_add_int(&malloc_nowait_count, 1);
356		if ((malloc_nowait_count % malloc_failure_rate) == 0) {
357			atomic_add_int(&malloc_failure_count, 1);
358			t_malloc_fail = time_uptime;
359			return (NULL);
360		}
361	}
362#endif
363	if (flags & M_WAITOK)
364		KASSERT(curthread->td_intr_nesting_level == 0,
365		   ("malloc(M_WAITOK) in interrupt context"));
366
367#ifdef DEBUG_MEMGUARD
368	if (memguard_cmp(mtp))
369		return memguard_alloc(size, flags);
370#endif
371
372#ifdef DEBUG_REDZONE
373	size = redzone_size_ntor(size);
374#endif
375
376	if (size <= KMEM_ZMAX) {
377		if (size & KMEM_ZMASK)
378			size = (size & ~KMEM_ZMASK) + KMEM_ZBASE;
379		indx = kmemsize[size >> KMEM_ZSHIFT];
380		zone = kmemzones[indx].kz_zone;
381#ifdef MALLOC_PROFILE
382		krequests[size >> KMEM_ZSHIFT]++;
383#endif
384		va = uma_zalloc(zone, flags);
385		if (va != NULL)
386			size = zone->uz_size;
387		malloc_type_zone_allocated(mtp, va == NULL ? 0 : size, indx);
388	} else {
389		size = roundup(size, PAGE_SIZE);
390		zone = NULL;
391		va = uma_large_malloc(size, flags);
392		malloc_type_allocated(mtp, va == NULL ? 0 : size);
393	}
394	if (flags & M_WAITOK)
395		KASSERT(va != NULL, ("malloc(M_WAITOK) returned NULL"));
396	else if (va == NULL)
397		t_malloc_fail = time_uptime;
398#ifdef DIAGNOSTIC
399	if (va != NULL && !(flags & M_ZERO)) {
400		memset(va, 0x70, osize);
401	}
402#endif
403#ifdef DEBUG_REDZONE
404	if (va != NULL)
405		va = redzone_setup(va, osize);
406#endif
407	return ((void *) va);
408}
409
410/*
411 *	free:
412 *
413 *	Free a block of memory allocated by malloc.
414 *
415 *	This routine may not block.
416 */
417void
418free(void *addr, struct malloc_type *mtp)
419{
420	uma_slab_t slab;
421	u_long size;
422
423	KASSERT(mtp->ks_magic == M_MAGIC, ("free: bad malloc type magic"));
424
425	/* free(NULL, ...) does nothing */
426	if (addr == NULL)
427		return;
428
429#ifdef DEBUG_MEMGUARD
430	if (memguard_cmp(mtp)) {
431		memguard_free(addr);
432		return;
433	}
434#endif
435
436#ifdef DEBUG_REDZONE
437	redzone_check(addr);
438	addr = redzone_addr_ntor(addr);
439#endif
440
441	slab = vtoslab((vm_offset_t)addr & (~UMA_SLAB_MASK));
442
443	if (slab == NULL)
444		panic("free: address %p(%p) has not been allocated.\n",
445		    addr, (void *)((u_long)addr & (~UMA_SLAB_MASK)));
446
447
448	if (!(slab->us_flags & UMA_SLAB_MALLOC)) {
449#ifdef INVARIANTS
450		struct malloc_type **mtpp = addr;
451#endif
452		size = slab->us_keg->uk_size;
453#ifdef INVARIANTS
454		/*
455		 * Cache a pointer to the malloc_type that most recently freed
456		 * this memory here.  This way we know who is most likely to
457		 * have stepped on it later.
458		 *
459		 * This code assumes that size is a multiple of 8 bytes for
460		 * 64 bit machines
461		 */
462		mtpp = (struct malloc_type **)
463		    ((unsigned long)mtpp & ~UMA_ALIGN_PTR);
464		mtpp += (size - sizeof(struct malloc_type *)) /
465		    sizeof(struct malloc_type *);
466		*mtpp = mtp;
467#endif
468		uma_zfree_arg(LIST_FIRST(&slab->us_keg->uk_zones), addr, slab);
469	} else {
470		size = slab->us_size;
471		uma_large_free(slab);
472	}
473	malloc_type_freed(mtp, size);
474}
475
476/*
477 *	realloc: change the size of a memory block
478 */
479void *
480realloc(void *addr, unsigned long size, struct malloc_type *mtp, int flags)
481{
482	uma_slab_t slab;
483	unsigned long alloc;
484	void *newaddr;
485
486	KASSERT(mtp->ks_magic == M_MAGIC,
487	    ("realloc: bad malloc type magic"));
488
489	/* realloc(NULL, ...) is equivalent to malloc(...) */
490	if (addr == NULL)
491		return (malloc(size, mtp, flags));
492
493	/*
494	 * XXX: Should report free of old memory and alloc of new memory to
495	 * per-CPU stats.
496	 */
497
498#ifdef DEBUG_MEMGUARD
499if (memguard_cmp(mtp)) {
500	slab = NULL;
501	alloc = size;
502} else {
503#endif
504
505#ifdef DEBUG_REDZONE
506	slab = NULL;
507	alloc = redzone_get_size(addr);
508#else
509	slab = vtoslab((vm_offset_t)addr & ~(UMA_SLAB_MASK));
510
511	/* Sanity check */
512	KASSERT(slab != NULL,
513	    ("realloc: address %p out of range", (void *)addr));
514
515	/* Get the size of the original block */
516	if (!(slab->us_flags & UMA_SLAB_MALLOC))
517		alloc = slab->us_keg->uk_size;
518	else
519		alloc = slab->us_size;
520
521	/* Reuse the original block if appropriate */
522	if (size <= alloc
523	    && (size > (alloc >> REALLOC_FRACTION) || alloc == MINALLOCSIZE))
524		return (addr);
525#endif /* !DEBUG_REDZONE */
526
527#ifdef DEBUG_MEMGUARD
528}
529#endif
530
531	/* Allocate a new, bigger (or smaller) block */
532	if ((newaddr = malloc(size, mtp, flags)) == NULL)
533		return (NULL);
534
535	/* Copy over original contents */
536	bcopy(addr, newaddr, min(size, alloc));
537	free(addr, mtp);
538	return (newaddr);
539}
540
541/*
542 *	reallocf: same as realloc() but free memory on failure.
543 */
544void *
545reallocf(void *addr, unsigned long size, struct malloc_type *mtp, int flags)
546{
547	void *mem;
548
549	if ((mem = realloc(addr, size, mtp, flags)) == NULL)
550		free(addr, mtp);
551	return (mem);
552}
553
554/*
555 * Initialize the kernel memory allocator
556 */
557/* ARGSUSED*/
558static void
559kmeminit(void *dummy)
560{
561	u_int8_t indx;
562	u_long mem_size;
563	int i;
564
565	mtx_init(&malloc_mtx, "malloc", NULL, MTX_DEF);
566
567	/*
568	 * Try to auto-tune the kernel memory size, so that it is
569	 * more applicable for a wider range of machine sizes.
570	 * On an X86, a VM_KMEM_SIZE_SCALE value of 4 is good, while
571	 * a VM_KMEM_SIZE of 12MB is a fair compromise.  The
572	 * VM_KMEM_SIZE_MAX is dependent on the maximum KVA space
573	 * available, and on an X86 with a total KVA space of 256MB,
574	 * try to keep VM_KMEM_SIZE_MAX at 80MB or below.
575	 *
576	 * Note that the kmem_map is also used by the zone allocator,
577	 * so make sure that there is enough space.
578	 */
579	vm_kmem_size = VM_KMEM_SIZE + nmbclusters * PAGE_SIZE;
580	mem_size = cnt.v_page_count;
581
582#if defined(VM_KMEM_SIZE_SCALE)
583	vm_kmem_size_scale = VM_KMEM_SIZE_SCALE;
584#endif
585	TUNABLE_INT_FETCH("vm.kmem_size_scale", &vm_kmem_size_scale);
586	if (vm_kmem_size_scale > 0 &&
587	    (mem_size / vm_kmem_size_scale) > (vm_kmem_size / PAGE_SIZE))
588		vm_kmem_size = (mem_size / vm_kmem_size_scale) * PAGE_SIZE;
589
590#if defined(VM_KMEM_SIZE_MIN)
591	vm_kmem_size_min = VM_KMEM_SIZE_MIN;
592#endif
593	TUNABLE_ULONG_FETCH("vm.kmem_size_min", &vm_kmem_size_min);
594	if (vm_kmem_size_min > 0 && vm_kmem_size < vm_kmem_size_min) {
595		vm_kmem_size = vm_kmem_size_min;
596	}
597
598#if defined(VM_KMEM_SIZE_MAX)
599	vm_kmem_size_max = VM_KMEM_SIZE_MAX;
600#endif
601	TUNABLE_ULONG_FETCH("vm.kmem_size_max", &vm_kmem_size_max);
602	if (vm_kmem_size_max > 0 && vm_kmem_size >= vm_kmem_size_max)
603		vm_kmem_size = vm_kmem_size_max;
604
605	/* Allow final override from the kernel environment */
606	TUNABLE_ULONG_FETCH("vm.kmem_size", &vm_kmem_size);
607
608	/*
609	 * Limit kmem virtual size to twice the physical memory.
610	 * This allows for kmem map sparseness, but limits the size
611	 * to something sane. Be careful to not overflow the 32bit
612	 * ints while doing the check.
613	 */
614	if (((vm_kmem_size / 2) / PAGE_SIZE) > cnt.v_page_count)
615		vm_kmem_size = 2 * cnt.v_page_count * PAGE_SIZE;
616
617	/*
618	 * Tune settings based on the kmem map's size at this time.
619	 */
620	init_param3(vm_kmem_size / PAGE_SIZE);
621
622	kmem_map = kmem_suballoc(kernel_map, &kmembase, &kmemlimit,
623	    vm_kmem_size, TRUE);
624	kmem_map->system_map = 1;
625
626#ifdef DEBUG_MEMGUARD
627	/*
628	 * Initialize MemGuard if support compiled in.  MemGuard is a
629	 * replacement allocator used for detecting tamper-after-free
630	 * scenarios as they occur.  It is only used for debugging.
631	 */
632	vm_memguard_divisor = 10;
633	TUNABLE_INT_FETCH("vm.memguard.divisor", &vm_memguard_divisor);
634
635	/* Pick a conservative value if provided value sucks. */
636	if ((vm_memguard_divisor <= 0) ||
637	    ((vm_kmem_size / vm_memguard_divisor) == 0))
638		vm_memguard_divisor = 10;
639	memguard_init(kmem_map, vm_kmem_size / vm_memguard_divisor);
640#endif
641
642	uma_startup2();
643
644	mt_zone = uma_zcreate("mt_zone", sizeof(struct malloc_type_internal),
645#ifdef INVARIANTS
646	    mtrash_ctor, mtrash_dtor, mtrash_init, mtrash_fini,
647#else
648	    NULL, NULL, NULL, NULL,
649#endif
650	    UMA_ALIGN_PTR, UMA_ZONE_MALLOC);
651	for (i = 0, indx = 0; kmemzones[indx].kz_size != 0; indx++) {
652		int size = kmemzones[indx].kz_size;
653		char *name = kmemzones[indx].kz_name;
654
655		kmemzones[indx].kz_zone = uma_zcreate(name, size,
656#ifdef INVARIANTS
657		    mtrash_ctor, mtrash_dtor, mtrash_init, mtrash_fini,
658#else
659		    NULL, NULL, NULL, NULL,
660#endif
661		    UMA_ALIGN_PTR, UMA_ZONE_MALLOC);
662
663		for (;i <= size; i+= KMEM_ZBASE)
664			kmemsize[i >> KMEM_ZSHIFT] = indx;
665
666	}
667}
668
669void
670malloc_init(void *data)
671{
672	struct malloc_type_internal *mtip;
673	struct malloc_type *mtp;
674
675	KASSERT(cnt.v_page_count != 0, ("malloc_register before vm_init"));
676
677	mtp = data;
678	if (mtp->ks_magic != M_MAGIC)
679		panic("malloc_init: bad malloc type magic");
680
681	mtip = uma_zalloc(mt_zone, M_WAITOK | M_ZERO);
682	mtp->ks_handle = mtip;
683
684	mtx_lock(&malloc_mtx);
685	mtp->ks_next = kmemstatistics;
686	kmemstatistics = mtp;
687	kmemcount++;
688	mtx_unlock(&malloc_mtx);
689}
690
691void
692malloc_uninit(void *data)
693{
694	struct malloc_type_internal *mtip;
695	struct malloc_type_stats *mtsp;
696	struct malloc_type *mtp, *temp;
697	uma_slab_t slab;
698	long temp_allocs, temp_bytes;
699	int i;
700
701	mtp = data;
702	KASSERT(mtp->ks_magic == M_MAGIC,
703	    ("malloc_uninit: bad malloc type magic"));
704	KASSERT(mtp->ks_handle != NULL, ("malloc_deregister: cookie NULL"));
705
706	mtx_lock(&malloc_mtx);
707	mtip = mtp->ks_handle;
708	mtp->ks_handle = NULL;
709	if (mtp != kmemstatistics) {
710		for (temp = kmemstatistics; temp != NULL;
711		    temp = temp->ks_next) {
712			if (temp->ks_next == mtp) {
713				temp->ks_next = mtp->ks_next;
714				break;
715			}
716		}
717		KASSERT(temp,
718		    ("malloc_uninit: type '%s' not found", mtp->ks_shortdesc));
719	} else
720		kmemstatistics = mtp->ks_next;
721	kmemcount--;
722	mtx_unlock(&malloc_mtx);
723
724	/*
725	 * Look for memory leaks.
726	 */
727	temp_allocs = temp_bytes = 0;
728	for (i = 0; i < MAXCPU; i++) {
729		mtsp = &mtip->mti_stats[i];
730		temp_allocs += mtsp->mts_numallocs;
731		temp_allocs -= mtsp->mts_numfrees;
732		temp_bytes += mtsp->mts_memalloced;
733		temp_bytes -= mtsp->mts_memfreed;
734	}
735	if (temp_allocs > 0 || temp_bytes > 0) {
736		printf("Warning: memory type %s leaked memory on destroy "
737		    "(%ld allocations, %ld bytes leaked).\n", mtp->ks_shortdesc,
738		    temp_allocs, temp_bytes);
739	}
740
741	slab = vtoslab((vm_offset_t) mtip & (~UMA_SLAB_MASK));
742	uma_zfree_arg(mt_zone, mtip, slab);
743}
744
745struct malloc_type *
746malloc_desc2type(const char *desc)
747{
748	struct malloc_type *mtp;
749
750	mtx_assert(&malloc_mtx, MA_OWNED);
751	for (mtp = kmemstatistics; mtp != NULL; mtp = mtp->ks_next) {
752		if (strcmp(mtp->ks_shortdesc, desc) == 0)
753			return (mtp);
754	}
755	return (NULL);
756}
757
758static int
759sysctl_kern_malloc_stats(SYSCTL_HANDLER_ARGS)
760{
761	struct malloc_type_stream_header mtsh;
762	struct malloc_type_internal *mtip;
763	struct malloc_type_header mth;
764	struct malloc_type *mtp;
765	int buflen, count, error, i;
766	struct sbuf sbuf;
767	char *buffer;
768
769	mtx_lock(&malloc_mtx);
770restart:
771	mtx_assert(&malloc_mtx, MA_OWNED);
772	count = kmemcount;
773	mtx_unlock(&malloc_mtx);
774	buflen = sizeof(mtsh) + count * (sizeof(mth) +
775	    sizeof(struct malloc_type_stats) * MAXCPU) + 1;
776	buffer = malloc(buflen, M_TEMP, M_WAITOK | M_ZERO);
777	mtx_lock(&malloc_mtx);
778	if (count < kmemcount) {
779		free(buffer, M_TEMP);
780		goto restart;
781	}
782
783	sbuf_new(&sbuf, buffer, buflen, SBUF_FIXEDLEN);
784
785	/*
786	 * Insert stream header.
787	 */
788	bzero(&mtsh, sizeof(mtsh));
789	mtsh.mtsh_version = MALLOC_TYPE_STREAM_VERSION;
790	mtsh.mtsh_maxcpus = MAXCPU;
791	mtsh.mtsh_count = kmemcount;
792	if (sbuf_bcat(&sbuf, &mtsh, sizeof(mtsh)) < 0) {
793		mtx_unlock(&malloc_mtx);
794		error = ENOMEM;
795		goto out;
796	}
797
798	/*
799	 * Insert alternating sequence of type headers and type statistics.
800	 */
801	for (mtp = kmemstatistics; mtp != NULL; mtp = mtp->ks_next) {
802		mtip = (struct malloc_type_internal *)mtp->ks_handle;
803
804		/*
805		 * Insert type header.
806		 */
807		bzero(&mth, sizeof(mth));
808		strlcpy(mth.mth_name, mtp->ks_shortdesc, MALLOC_MAX_NAME);
809		if (sbuf_bcat(&sbuf, &mth, sizeof(mth)) < 0) {
810			mtx_unlock(&malloc_mtx);
811			error = ENOMEM;
812			goto out;
813		}
814
815		/*
816		 * Insert type statistics for each CPU.
817		 */
818		for (i = 0; i < MAXCPU; i++) {
819			if (sbuf_bcat(&sbuf, &mtip->mti_stats[i],
820			    sizeof(mtip->mti_stats[i])) < 0) {
821				mtx_unlock(&malloc_mtx);
822				error = ENOMEM;
823				goto out;
824			}
825		}
826	}
827	mtx_unlock(&malloc_mtx);
828	sbuf_finish(&sbuf);
829	error = SYSCTL_OUT(req, sbuf_data(&sbuf), sbuf_len(&sbuf));
830out:
831	sbuf_delete(&sbuf);
832	free(buffer, M_TEMP);
833	return (error);
834}
835
836SYSCTL_PROC(_kern, OID_AUTO, malloc_stats, CTLFLAG_RD|CTLTYPE_STRUCT,
837    0, 0, sysctl_kern_malloc_stats, "s,malloc_type_ustats",
838    "Return malloc types");
839
840SYSCTL_INT(_kern, OID_AUTO, malloc_count, CTLFLAG_RD, &kmemcount, 0,
841    "Count of kernel malloc types");
842
843void
844malloc_type_list(malloc_type_list_func_t *func, void *arg)
845{
846	struct malloc_type *mtp, **bufmtp;
847	int count, i;
848	size_t buflen;
849
850	mtx_lock(&malloc_mtx);
851restart:
852	mtx_assert(&malloc_mtx, MA_OWNED);
853	count = kmemcount;
854	mtx_unlock(&malloc_mtx);
855
856	buflen = sizeof(struct malloc_type *) * count;
857	bufmtp = malloc(buflen, M_TEMP, M_WAITOK);
858
859	mtx_lock(&malloc_mtx);
860
861	if (count < kmemcount) {
862		free(bufmtp, M_TEMP);
863		goto restart;
864	}
865
866	for (mtp = kmemstatistics, i = 0; mtp != NULL; mtp = mtp->ks_next, i++)
867		bufmtp[i] = mtp;
868
869	mtx_unlock(&malloc_mtx);
870
871	for (i = 0; i < count; i++)
872		(func)(bufmtp[i], arg);
873
874	free(bufmtp, M_TEMP);
875}
876
877#ifdef DDB
878DB_SHOW_COMMAND(malloc, db_show_malloc)
879{
880	struct malloc_type_internal *mtip;
881	struct malloc_type *mtp;
882	u_int64_t allocs, frees;
883	u_int64_t alloced, freed;
884	int i;
885
886	db_printf("%18s %12s  %12s %12s\n", "Type", "InUse", "MemUse",
887	    "Requests");
888	for (mtp = kmemstatistics; mtp != NULL; mtp = mtp->ks_next) {
889		mtip = (struct malloc_type_internal *)mtp->ks_handle;
890		allocs = 0;
891		frees = 0;
892		alloced = 0;
893		freed = 0;
894		for (i = 0; i < MAXCPU; i++) {
895			allocs += mtip->mti_stats[i].mts_numallocs;
896			frees += mtip->mti_stats[i].mts_numfrees;
897			alloced += mtip->mti_stats[i].mts_memalloced;
898			freed += mtip->mti_stats[i].mts_memfreed;
899		}
900		db_printf("%18s %12ju %12juK %12ju\n",
901		    mtp->ks_shortdesc, allocs - frees,
902		    (alloced - freed + 1023) / 1024, allocs);
903	}
904}
905#endif
906
907#ifdef MALLOC_PROFILE
908
909static int
910sysctl_kern_mprof(SYSCTL_HANDLER_ARGS)
911{
912	int linesize = 64;
913	struct sbuf sbuf;
914	uint64_t count;
915	uint64_t waste;
916	uint64_t mem;
917	int bufsize;
918	int error;
919	char *buf;
920	int rsize;
921	int size;
922	int i;
923
924	bufsize = linesize * (KMEM_ZSIZE + 1);
925	bufsize += 128; 	/* For the stats line */
926	bufsize += 128; 	/* For the banner line */
927	waste = 0;
928	mem = 0;
929
930	buf = malloc(bufsize, M_TEMP, M_WAITOK|M_ZERO);
931	sbuf_new(&sbuf, buf, bufsize, SBUF_FIXEDLEN);
932	sbuf_printf(&sbuf,
933	    "\n  Size                    Requests  Real Size\n");
934	for (i = 0; i < KMEM_ZSIZE; i++) {
935		size = i << KMEM_ZSHIFT;
936		rsize = kmemzones[kmemsize[i]].kz_size;
937		count = (long long unsigned)krequests[i];
938
939		sbuf_printf(&sbuf, "%6d%28llu%11d\n", size,
940		    (unsigned long long)count, rsize);
941
942		if ((rsize * count) > (size * count))
943			waste += (rsize * count) - (size * count);
944		mem += (rsize * count);
945	}
946	sbuf_printf(&sbuf,
947	    "\nTotal memory used:\t%30llu\nTotal Memory wasted:\t%30llu\n",
948	    (unsigned long long)mem, (unsigned long long)waste);
949	sbuf_finish(&sbuf);
950
951	error = SYSCTL_OUT(req, sbuf_data(&sbuf), sbuf_len(&sbuf));
952
953	sbuf_delete(&sbuf);
954	free(buf, M_TEMP);
955	return (error);
956}
957
958SYSCTL_OID(_kern, OID_AUTO, mprof, CTLTYPE_STRING|CTLFLAG_RD,
959    NULL, 0, sysctl_kern_mprof, "A", "Malloc Profiling");
960#endif /* MALLOC_PROFILE */
961