FreeBSD/Linux Kernel Cross Reference
sys/sys/malloc.h
1 /* $NetBSD: malloc.h,v 1.89 2003/08/07 16:34:07 agc Exp $ */
2
3 /*
4 * Copyright (c) 1987, 1993
5 * The Regents of the University of California. 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 * 3. 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 * @(#)malloc.h 8.5 (Berkeley) 5/3/95
32 */
33
34 #ifndef _SYS_MALLOC_H_
35 #define _SYS_MALLOC_H_
36
37 #if defined(_KERNEL_OPT)
38 #include "opt_kmemstats.h"
39 #include "opt_malloclog.h"
40 #include "opt_malloc_debug.h"
41 #include "opt_lockdebug.h"
42 #endif
43
44
45 /*
46 * flags to malloc
47 */
48 #define M_WAITOK 0x0000 /* can wait for resources */
49 #define M_NOWAIT 0x0001 /* do not wait for resources */
50 #define M_ZERO 0x0002 /* zero the allocation */
51 #define M_CANFAIL 0x0004 /* can fail if requested memory can't ever
52 * be allocated */
53 #ifdef _KERNEL
54
55 #include <sys/lock.h>
56 #include <sys/mallocvar.h>
57 /*
58 * The following are standard, built-in malloc types that are
59 * not specific to any one subsystem.
60 */
61 MALLOC_DECLARE(M_DEVBUF);
62 MALLOC_DECLARE(M_DMAMAP);
63 MALLOC_DECLARE(M_FREE);
64 MALLOC_DECLARE(M_PCB);
65 MALLOC_DECLARE(M_SOFTINTR);
66 MALLOC_DECLARE(M_TEMP);
67
68 /* XXX These should all be declared elsewhere. */
69 MALLOC_DECLARE(M_RTABLE);
70 MALLOC_DECLARE(M_FTABLE);
71 MALLOC_DECLARE(M_UFSMNT);
72 MALLOC_DECLARE(M_NETADDR);
73 MALLOC_DECLARE(M_IPMOPTS);
74 MALLOC_DECLARE(M_IPMADDR);
75 MALLOC_DECLARE(M_MRTABLE);
76 MALLOC_DECLARE(M_1394DATA);
77 #endif /* _KERNEL */
78
79 /*
80 * Array of descriptors that describe the contents of each page
81 */
82 struct kmemusage {
83 short ku_indx; /* bucket index */
84 union {
85 u_short freecnt;/* for small allocations, free pieces in page */
86 u_short pagecnt;/* for large allocations, pages alloced */
87 } ku_un;
88 };
89 #define ku_freecnt ku_un.freecnt
90 #define ku_pagecnt ku_un.pagecnt
91
92 /*
93 * Set of buckets for each size of memory block that is retained
94 */
95 struct kmembuckets {
96 caddr_t kb_next; /* list of free blocks */
97 caddr_t kb_last; /* last free block */
98 long kb_calls; /* total calls to allocate this size */
99 long kb_total; /* total number of blocks allocated */
100 long kb_totalfree; /* # of free elements in this bucket */
101 long kb_elmpercl; /* # of elements in this sized allocation */
102 long kb_highwat; /* high water mark */
103 long kb_couldfree; /* over high water mark and could free */
104 };
105
106 #ifdef _KERNEL
107 #define MINALLOCSIZE (1 << MINBUCKET)
108 #define BUCKETINDX(size) \
109 ((size) <= (MINALLOCSIZE * 128) \
110 ? (size) <= (MINALLOCSIZE * 8) \
111 ? (size) <= (MINALLOCSIZE * 2) \
112 ? (size) <= (MINALLOCSIZE * 1) \
113 ? (MINBUCKET + 0) \
114 : (MINBUCKET + 1) \
115 : (size) <= (MINALLOCSIZE * 4) \
116 ? (MINBUCKET + 2) \
117 : (MINBUCKET + 3) \
118 : (size) <= (MINALLOCSIZE* 32) \
119 ? (size) <= (MINALLOCSIZE * 16) \
120 ? (MINBUCKET + 4) \
121 : (MINBUCKET + 5) \
122 : (size) <= (MINALLOCSIZE * 64) \
123 ? (MINBUCKET + 6) \
124 : (MINBUCKET + 7) \
125 : (size) <= (MINALLOCSIZE * 2048) \
126 ? (size) <= (MINALLOCSIZE * 512) \
127 ? (size) <= (MINALLOCSIZE * 256) \
128 ? (MINBUCKET + 8) \
129 : (MINBUCKET + 9) \
130 : (size) <= (MINALLOCSIZE * 1024) \
131 ? (MINBUCKET + 10) \
132 : (MINBUCKET + 11) \
133 : (size) <= (MINALLOCSIZE * 8192) \
134 ? (size) <= (MINALLOCSIZE * 4096) \
135 ? (MINBUCKET + 12) \
136 : (MINBUCKET + 13) \
137 : (size) <= (MINALLOCSIZE * 16384) \
138 ? (MINBUCKET + 14) \
139 : (MINBUCKET + 15))
140
141 /*
142 * Turn virtual addresses into kmem map indicies
143 */
144 #define kmemxtob(alloc) (kmembase + (alloc) * NBPG)
145 #define btokmemx(addr) (((caddr_t)(addr) - kmembase) / NBPG)
146 #define btokup(addr) (&kmemusage[((caddr_t)(addr) - kmembase) >> PGSHIFT])
147
148 extern struct simplelock malloc_slock;
149
150 /*
151 * Macro versions for the usual cases of malloc/free
152 */
153 #if defined(KMEMSTATS) || defined(DIAGNOSTIC) || defined(_LKM) || \
154 defined(MALLOCLOG) || defined(LOCKDEBUG) || defined(MALLOC_NOINLINE)
155 #define MALLOC(space, cast, size, type, flags) \
156 (space) = (cast)malloc((u_long)(size), (type), (flags))
157 #define FREE(addr, type) free((caddr_t)(addr), (type))
158
159 #else /* do not collect statistics */
160 #define MALLOC(space, cast, size, type, flags) \
161 do { \
162 register struct kmembuckets *__kbp = &bucket[BUCKETINDX((size))]; \
163 long __s = splvm(); \
164 simple_lock(&malloc_slock); \
165 if (__kbp->kb_next == NULL) { \
166 simple_unlock(&malloc_slock); \
167 (space) = (cast)malloc((u_long)(size), (type), (flags)); \
168 splx(__s); \
169 } else { \
170 (space) = (cast)__kbp->kb_next; \
171 __kbp->kb_next = *(caddr_t *)(space); \
172 simple_unlock(&malloc_slock); \
173 splx(__s); \
174 if ((flags) & M_ZERO) \
175 memset((space), 0, (size)); \
176 } \
177 } while (/* CONSTCOND */ 0)
178
179 #define FREE(addr, type) \
180 do { \
181 register struct kmembuckets *__kbp; \
182 register struct kmemusage *__kup = btokup((addr)); \
183 long __s = splvm(); \
184 if (1 << __kup->ku_indx > MAXALLOCSAVE) { \
185 free((caddr_t)(addr), (type)); \
186 } else { \
187 simple_lock(&malloc_slock); \
188 __kbp = &bucket[__kup->ku_indx]; \
189 if (__kbp->kb_next == NULL) \
190 __kbp->kb_next = (caddr_t)(addr); \
191 else \
192 *(caddr_t *)(__kbp->kb_last) = (caddr_t)(addr); \
193 *(caddr_t *)(addr) = NULL; \
194 __kbp->kb_last = (caddr_t)(addr); \
195 simple_unlock(&malloc_slock); \
196 } \
197 splx(__s); \
198 } while(/* CONSTCOND */ 0)
199 #endif /* do not collect statistics */
200
201 extern struct kmemusage *kmemusage;
202 extern char *kmembase;
203 extern struct kmembuckets bucket[];
204
205 #ifdef MALLOCLOG
206 void *_malloc(unsigned long, struct malloc_type *, int, const char *, long);
207 void _free(void *, struct malloc_type *, const char *, long);
208 #define malloc(size, type, flags) \
209 _malloc((size), (type), (flags), __FILE__, __LINE__)
210 #define free(addr, type) \
211 _free((addr), (type), __FILE__, __LINE__)
212 #else
213 void *malloc(unsigned long, struct malloc_type *, int);
214 void free(void *, struct malloc_type *);
215 #endif /* MALLOCLOG */
216
217 #ifdef MALLOC_DEBUG
218 int debug_malloc(unsigned long, struct malloc_type *, int, void **);
219 int debug_free(void *, struct malloc_type *);
220 void debug_malloc_init(void);
221
222 void debug_malloc_print(void);
223 void debug_malloc_printit(void (*)(const char *, ...), vaddr_t);
224 #endif /* MALLOC_DEBUG */
225
226 void *realloc(void *, unsigned long, struct malloc_type *, int);
227 unsigned long
228 malloc_roundup(unsigned long);
229 #endif /* _KERNEL */
230 #endif /* !_SYS_MALLOC_H_ */
Cache object: 7ca260b8cba9a8229210625701081fc6
|