1 /* 2 * Copyright (c) 1987, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)malloc.h 8.5 (Berkeley) 5/3/95 30 * $FreeBSD: src/sys/sys/malloc.h,v 1.48.2.2 2002/03/16 02:19:16 archie Exp $ 31 */ 32 33 #ifndef _SYS_MALLOC_H_ 34 #define _SYS_MALLOC_H_ 35 36 #ifndef _SYS_TYPES_H_ 37 #include <sys/types.h> 38 #endif 39 #ifndef _MACHINE_TYPES_H_ 40 #include <machine/types.h> /* vm_paddr_t and __* types */ 41 #endif 42 43 /* 44 * flags to malloc. 45 */ 46 #define M_RNOWAIT 0x0001 /* do not block */ 47 #define M_WAITOK 0x0002 /* wait for resources / alloc from cache */ 48 #define M_ZERO 0x0100 /* bzero() the allocation */ 49 #define M_USE_RESERVE 0x0200 /* can eat into free list reserve */ 50 #define M_NULLOK 0x0400 /* ok to return NULL */ 51 #define M_PASSIVE_ZERO 0x0800 /* (internal to the slab code only) */ 52 #define M_USE_INTERRUPT_RESERVE \ 53 0x1000 /* can exhaust free list entirely */ 54 #define M_POWEROF2 0x2000 /* roundup size to the nearest power of 2 */ 55 #define M_CACHEALIGN 0x4000 /* force CPU cache line alignment */ 56 57 /* 58 * M_NOWAIT has to be a set of flags for equivalence to prior use. 59 * 60 * M_SYSALLOC should be used for any critical infrastructure allocations 61 * made by the kernel proper. 62 * 63 * M_INTNOWAIT should be used for any critical infrastructure allocations 64 * made by interrupts. Such allocations can still fail but will not fail 65 * as often as M_NOWAIT. 66 * 67 * NOTE ON DRAGONFLY USE OF M_NOWAIT. In FreeBSD M_NOWAIT allocations 68 * almost always succeed. In DragonFly, however, there is a good chance 69 * that an allocation will fail. M_NOWAIT should only be used when 70 * allocations can fail without any serious detriment to the system. 71 * 72 * Note that allocations made from (preempted) interrupts will attempt to 73 * use pages from the VM PAGE CACHE (PQ_CACHE) (i.e. those associated with 74 * objects). This is automatic. 75 */ 76 77 #define M_INTNOWAIT (M_RNOWAIT | M_NULLOK | \ 78 M_USE_RESERVE | M_USE_INTERRUPT_RESERVE) 79 #define M_SYSNOWAIT (M_RNOWAIT | M_NULLOK | M_USE_RESERVE) 80 #define M_INTWAIT (M_WAITOK | M_USE_RESERVE | M_USE_INTERRUPT_RESERVE) 81 #define M_SYSWAIT (M_WAITOK | M_USE_RESERVE) 82 83 #define M_NOWAIT (M_RNOWAIT | M_NULLOK | M_USE_RESERVE) 84 #define M_SYSALLOC M_SYSWAIT 85 86 #define M_MAGIC 877983977 /* time when first defined :-) */ 87 88 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES) 89 #include <sys/_malloc.h> /* struct malloc_type */ 90 #endif 91 92 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES) 93 #define MALLOC_DEFINE(type, shortdesc, longdesc) \ 94 struct malloc_type type[1] = { \ 95 { NULL, 0, 0, { { 0, 0, 0, 0 } }, M_MAGIC, shortdesc, \ 96 { 0 } } \ 97 }; \ 98 SYSINIT(type##_init, SI_BOOT1_KMALLOC, SI_ORDER_ANY, \ 99 malloc_init, type); \ 100 SYSUNINIT(type##_uninit, SI_BOOT1_KMALLOC, SI_ORDER_ANY, \ 101 malloc_uninit, type) 102 #else 103 #define MALLOC_DEFINE(type, shortdesc, longdesc) \ 104 struct malloc_type type[1] = { \ 105 { NULL, 0, 0, { { 0, 0, 0, 0 } }, M_MAGIC, shortdesc, \ 106 { 0 } } \ 107 } 108 #endif 109 110 #ifdef _KERNEL 111 112 MALLOC_DECLARE(M_CACHE); 113 MALLOC_DECLARE(M_DEVBUF); 114 MALLOC_DECLARE(M_TEMP); 115 116 MALLOC_DECLARE(M_IP6OPT); /* for INET6 */ 117 MALLOC_DECLARE(M_IP6NDP); /* for INET6 */ 118 119 #endif /* _KERNEL */ 120 121 #ifdef _KERNEL 122 123 #define MINALLOCSIZE sizeof(void *) 124 125 /* XXX struct malloc_type is unused for contig*(). */ 126 size_t kmem_lim_size(void); 127 void contigfree(void *addr, unsigned long size, struct malloc_type *type) 128 __nonnull(1); 129 void *contigmalloc(unsigned long size, struct malloc_type *type, int flags, 130 vm_paddr_t low, vm_paddr_t high, unsigned long alignment, 131 unsigned long boundary) __malloclike __heedresult 132 __alloc_size(1) __alloc_align(6); 133 void malloc_init(void *); 134 void malloc_uninit(void *); 135 void kmalloc_raise_limit(struct malloc_type *type, size_t bytes); 136 void kmalloc_set_unlimited(struct malloc_type *type); 137 void kmalloc_create(struct malloc_type **typep, const char *descr); 138 void kmalloc_destroy(struct malloc_type **typep); 139 140 /* 141 * Debug and non-debug kmalloc() prototypes. 142 * 143 * The kmalloc() macro allows M_ZERO to be optimized external to 144 * the kmalloc() function. When combined with the use a builtin 145 * for bzero() this can get rid of a considerable amount of overhead 146 * for M_ZERO based kmalloc() calls. 147 */ 148 #ifdef SLAB_DEBUG 149 void *kmalloc_debug(unsigned long size, struct malloc_type *type, int flags, 150 const char *file, int line) __malloclike __heedresult 151 __alloc_size(1); 152 void *krealloc_debug(void *addr, unsigned long size, 153 struct malloc_type *type, int flags, 154 const char *file, int line) __heedresult __alloc_size(2); 155 char *kstrdup_debug(const char *, struct malloc_type *, 156 const char *file, int line) __malloclike __heedresult; 157 char *kstrndup_debug(const char *, size_t maxlen, struct malloc_type *, 158 const char *file, int line) __malloclike __heedresult; 159 #if 1 160 #define kmalloc(size, type, flags) ({ \ 161 void *_malloc_item; \ 162 size_t _size = (size); \ 163 \ 164 if (__builtin_constant_p(size) && \ 165 __builtin_constant_p(flags) && \ 166 ((flags) & M_ZERO)) { \ 167 _malloc_item = kmalloc_debug(_size, type, \ 168 (flags) & ~M_ZERO, \ 169 __FILE__, __LINE__); \ 170 if (((flags) & (M_WAITOK|M_NULLOK)) == M_WAITOK || \ 171 __predict_true(_malloc_item != NULL)) { \ 172 bzero(_malloc_item, _size); \ 173 } \ 174 } else { \ 175 _malloc_item = kmalloc_debug(_size, type, flags, \ 176 __FILE__, __LINE__); \ 177 } \ 178 _malloc_item; \ 179 }) 180 #endif 181 #define krealloc(addr, size, type, flags) \ 182 krealloc_debug(addr, size, type, flags, __FILE__, __LINE__) 183 #define kstrdup(str, type) \ 184 kstrdup_debug(str, type, __FILE__, __LINE__) 185 #define kstrndup(str, maxlen, type) \ 186 kstrndup_debug(str, maxlen, type, __FILE__, __LINE__) 187 188 #else /* !SLAB_DEBUG */ 189 190 void *kmalloc(unsigned long size, struct malloc_type *type, int flags) 191 __malloclike __heedresult __alloc_size(1); 192 #if 1 193 #define kmalloc(size, type, flags) ({ \ 194 void *_malloc_item; \ 195 size_t _size = (size); \ 196 \ 197 if (__builtin_constant_p(size) && \ 198 __builtin_constant_p(flags) && \ 199 ((flags) & M_ZERO)) { \ 200 _malloc_item = kmalloc(_size, type, (flags) & ~M_ZERO); \ 201 if (((flags) & (M_WAITOK|M_NULLOK)) == M_WAITOK || \ 202 __predict_true(_malloc_item != NULL)) { \ 203 bzero(_malloc_item, _size); \ 204 } \ 205 } else { \ 206 _malloc_item = kmalloc(_size, type, flags); \ 207 } \ 208 _malloc_item; \ 209 }) 210 #endif 211 void *krealloc(void *addr, unsigned long size, struct malloc_type *type, 212 int flags) __heedresult __alloc_size(2); 213 char *kstrdup(const char *, struct malloc_type *) 214 __malloclike __heedresult; 215 char *kstrndup(const char *, size_t maxlen, struct malloc_type *) 216 __malloclike __heedresult; 217 #define kmalloc_debug(size, type, flags, file, line) \ 218 kmalloc(size, type, flags) 219 #define krealloc_debug(addr, size, type, flags, file, line) \ 220 krealloc(addr, size, type, flags) 221 #define kstrdup_debug(str, type, file, line) \ 222 kstrdup(str, type) 223 #define kstrndup_debug(str, maxlen, type, file, line) \ 224 kstrndup(str, maxlen, type) 225 #endif 226 void kfree(void *addr, struct malloc_type *type) __nonnull(2); 227 long kmalloc_limit(struct malloc_type *type); 228 void slab_cleanup(void); 229 230 #endif /* _KERNEL */ 231 232 #endif /* !_SYS_MALLOC_H_ */ 233