1/*
2 * Copyright (c) 2002, Jeffrey Roberson <jroberson@chesapeake.net>
3 * 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 unmodified, this list of conditions, and the following
10 * disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
| 1/*
2 * Copyright (c) 2002, Jeffrey Roberson <jroberson@chesapeake.net>
3 * 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 unmodified, this list of conditions, and the following
10 * disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
|
26 * $FreeBSD: head/sys/vm/uma.h 94157 2002-04-07 22:56:48Z jeff $
| 26 * $FreeBSD: head/sys/vm/uma.h 94161 2002-04-08 04:48:58Z jeff $
|
27 *
28 */
29
30/*
31 * uma.h - External definitions for the Universal Memory Allocator
32 *
33 * Jeff Roberson <jroberson@chesapeake.net>
34*/
35
36#ifndef VM_UMA_H
37#define VM_UMA_H
38
39#include <sys/param.h> /* For NULL */
40#include <sys/malloc.h> /* For M_* */
41
42/* User visable parameters */
43#define UMA_SMALLEST_UNIT (PAGE_SIZE / 256) /* Smallest item allocated */
44
45/* Types and type defs */
46
47struct uma_zone;
48/* Opaque type used as a handle to the zone */
49typedef struct uma_zone * uma_zone_t;
50
51/*
52 * Item constructor
53 *
54 * Arguments:
55 * item A pointer to the memory which has been allocated.
56 * arg The arg field passed to uma_zalloc_arg
57 * size The size of the allocated item
58 *
59 * Returns:
60 * Nothing
61 *
62 * Discussion:
63 * The constructor is called just before the memory is returned
64 * to the user. It may block if neccisary.
65 */
66typedef void (*uma_ctor)(void *mem, int size, void *arg);
67
68/*
69 * Item destructor
70 *
71 * Arguments:
72 * item A pointer to the memory which has been allocated.
73 * size The size of the item being destructed.
74 * arg Argument passed through uma_zfree_arg
75 *
76 * Returns:
77 * Nothing
78 *
79 * Discussion:
80 * The destructor may perform operations that differ from those performed
81 * by the initializer, but it must leave the object in the same state.
82 * This IS type stable storage. This is called after EVERY zfree call.
83 */
84typedef void (*uma_dtor)(void *mem, int size, void *arg);
85
86/*
87 * Item initializer
88 *
89 * Arguments:
90 * item A pointer to the memory which has been allocated.
91 * size The size of the item being initialized.
92 *
93 * Returns:
94 * Nothing
95 *
96 * Discussion:
97 * The initializer is called when the memory is cached in the uma zone.
98 * this should be the same state that the destructor leaves the object in.
99 */
100typedef void (*uma_init)(void *mem, int size);
101
102/*
103 * Item discard function
104 *
105 * Arguments:
106 * item A pointer to memory which has been 'freed' but has not left the
107 * zone's cache.
108 * size The size of the item being discarded.
109 *
110 * Returns:
111 * Nothing
112 *
113 * Discussion:
114 * This routine is called when memory leaves a zone and is returned to the
115 * system for other uses. It is the counter part to the init function.
116 */
117typedef void (*uma_fini)(void *mem, int size);
118
119/*
120 * What's the difference between initializing and constructing?
121 *
122 * The item is initialized when it is cached, and this is the state that the
123 * object should be in when returned to the allocator. The purpose of this is
124 * to remove some code which would otherwise be called on each allocation by
125 * utilizing a known, stable state. This differs from the constructor which
126 * will be called on EVERY allocation.
127 *
128 * For example, in the initializer you may want to initialize embeded locks,
129 * NULL list pointers, set up initial states, magic numbers, etc. This way if
130 * the object is held in the allocator and re-used it won't be neccisary to
131 * re-initialize it.
132 *
133 * The constructor may be used to lock a data structure, link it on to lists,
134 * bump reference counts or total counts of outstanding structures, etc.
135 *
136 */
137
138
139/* Function proto types */
140
141/*
142 * Create a new uma zone
143 *
144 * Arguments:
145 * name The text name of the zone for debugging and stats, this memory
146 * should not be freed until the zone has been deallocated.
147 * size The size of the object that is being created.
148 * ctor The constructor that is called when the object is allocated
149 * dtor The destructor that is called when the object is freed.
150 * init An initializer that sets up the initial state of the memory.
151 * fini A discard function that undoes initialization done by init.
152 * ctor/dtor/init/fini may all be null, see notes above.
153 * align A bitmask that corisponds to the requested alignment
154 * eg 4 would be 0x3
155 * flags A set of parameters that control the behavior of the zone
156 *
157 * Returns:
158 * A pointer to a structure which is intended to be opaque to users of
159 * the interface. The value may be null if the wait flag is not set.
160 */
161
162uma_zone_t uma_zcreate(char *name, int size, uma_ctor ctor, uma_dtor dtor,
163 uma_init uminit, uma_fini fini, int align,
164 u_int16_t flags);
165
166/* Definitions for uma_zcreate flags */
167#define UMA_ZONE_PAGEABLE 0x0001 /* Return items not fully backed by
168 physical memory XXX Not yet */
169#define UMA_ZONE_ZINIT 0x0002 /* Initialize with zeros */
170#define UMA_ZONE_STATIC 0x0004 /* Staticly sized zone */
171#define UMA_ZONE_OFFPAGE 0x0008 /* Force the slab structure allocation
172 off of the real memory */
173#define UMA_ZONE_MALLOC 0x0010 /* For use by malloc(9) only! */
174#define UMA_ZONE_NOFREE 0x0020 /* Do not free slabs of this type! */
175
176/* Definitions for align */
177#define UMA_ALIGN_PTR (sizeof(void *) - 1) /* Alignment fit for ptr */
178#define UMA_ALIGN_LONG (sizeof(long) - 1) /* "" long */
179#define UMA_ALIGN_INT (sizeof(int) - 1) /* "" int */
180#define UMA_ALIGN_SHORT (sizeof(short) - 1) /* "" short */
181#define UMA_ALIGN_CHAR (sizeof(char) - 1) /* "" char */
182#define UMA_ALIGN_CACHE (16 - 1) /* Cache line size align */
183
184/*
| 27 *
28 */
29
30/*
31 * uma.h - External definitions for the Universal Memory Allocator
32 *
33 * Jeff Roberson <jroberson@chesapeake.net>
34*/
35
36#ifndef VM_UMA_H
37#define VM_UMA_H
38
39#include <sys/param.h> /* For NULL */
40#include <sys/malloc.h> /* For M_* */
41
42/* User visable parameters */
43#define UMA_SMALLEST_UNIT (PAGE_SIZE / 256) /* Smallest item allocated */
44
45/* Types and type defs */
46
47struct uma_zone;
48/* Opaque type used as a handle to the zone */
49typedef struct uma_zone * uma_zone_t;
50
51/*
52 * Item constructor
53 *
54 * Arguments:
55 * item A pointer to the memory which has been allocated.
56 * arg The arg field passed to uma_zalloc_arg
57 * size The size of the allocated item
58 *
59 * Returns:
60 * Nothing
61 *
62 * Discussion:
63 * The constructor is called just before the memory is returned
64 * to the user. It may block if neccisary.
65 */
66typedef void (*uma_ctor)(void *mem, int size, void *arg);
67
68/*
69 * Item destructor
70 *
71 * Arguments:
72 * item A pointer to the memory which has been allocated.
73 * size The size of the item being destructed.
74 * arg Argument passed through uma_zfree_arg
75 *
76 * Returns:
77 * Nothing
78 *
79 * Discussion:
80 * The destructor may perform operations that differ from those performed
81 * by the initializer, but it must leave the object in the same state.
82 * This IS type stable storage. This is called after EVERY zfree call.
83 */
84typedef void (*uma_dtor)(void *mem, int size, void *arg);
85
86/*
87 * Item initializer
88 *
89 * Arguments:
90 * item A pointer to the memory which has been allocated.
91 * size The size of the item being initialized.
92 *
93 * Returns:
94 * Nothing
95 *
96 * Discussion:
97 * The initializer is called when the memory is cached in the uma zone.
98 * this should be the same state that the destructor leaves the object in.
99 */
100typedef void (*uma_init)(void *mem, int size);
101
102/*
103 * Item discard function
104 *
105 * Arguments:
106 * item A pointer to memory which has been 'freed' but has not left the
107 * zone's cache.
108 * size The size of the item being discarded.
109 *
110 * Returns:
111 * Nothing
112 *
113 * Discussion:
114 * This routine is called when memory leaves a zone and is returned to the
115 * system for other uses. It is the counter part to the init function.
116 */
117typedef void (*uma_fini)(void *mem, int size);
118
119/*
120 * What's the difference between initializing and constructing?
121 *
122 * The item is initialized when it is cached, and this is the state that the
123 * object should be in when returned to the allocator. The purpose of this is
124 * to remove some code which would otherwise be called on each allocation by
125 * utilizing a known, stable state. This differs from the constructor which
126 * will be called on EVERY allocation.
127 *
128 * For example, in the initializer you may want to initialize embeded locks,
129 * NULL list pointers, set up initial states, magic numbers, etc. This way if
130 * the object is held in the allocator and re-used it won't be neccisary to
131 * re-initialize it.
132 *
133 * The constructor may be used to lock a data structure, link it on to lists,
134 * bump reference counts or total counts of outstanding structures, etc.
135 *
136 */
137
138
139/* Function proto types */
140
141/*
142 * Create a new uma zone
143 *
144 * Arguments:
145 * name The text name of the zone for debugging and stats, this memory
146 * should not be freed until the zone has been deallocated.
147 * size The size of the object that is being created.
148 * ctor The constructor that is called when the object is allocated
149 * dtor The destructor that is called when the object is freed.
150 * init An initializer that sets up the initial state of the memory.
151 * fini A discard function that undoes initialization done by init.
152 * ctor/dtor/init/fini may all be null, see notes above.
153 * align A bitmask that corisponds to the requested alignment
154 * eg 4 would be 0x3
155 * flags A set of parameters that control the behavior of the zone
156 *
157 * Returns:
158 * A pointer to a structure which is intended to be opaque to users of
159 * the interface. The value may be null if the wait flag is not set.
160 */
161
162uma_zone_t uma_zcreate(char *name, int size, uma_ctor ctor, uma_dtor dtor,
163 uma_init uminit, uma_fini fini, int align,
164 u_int16_t flags);
165
166/* Definitions for uma_zcreate flags */
167#define UMA_ZONE_PAGEABLE 0x0001 /* Return items not fully backed by
168 physical memory XXX Not yet */
169#define UMA_ZONE_ZINIT 0x0002 /* Initialize with zeros */
170#define UMA_ZONE_STATIC 0x0004 /* Staticly sized zone */
171#define UMA_ZONE_OFFPAGE 0x0008 /* Force the slab structure allocation
172 off of the real memory */
173#define UMA_ZONE_MALLOC 0x0010 /* For use by malloc(9) only! */
174#define UMA_ZONE_NOFREE 0x0020 /* Do not free slabs of this type! */
175
176/* Definitions for align */
177#define UMA_ALIGN_PTR (sizeof(void *) - 1) /* Alignment fit for ptr */
178#define UMA_ALIGN_LONG (sizeof(long) - 1) /* "" long */
179#define UMA_ALIGN_INT (sizeof(int) - 1) /* "" int */
180#define UMA_ALIGN_SHORT (sizeof(short) - 1) /* "" short */
181#define UMA_ALIGN_CHAR (sizeof(char) - 1) /* "" char */
182#define UMA_ALIGN_CACHE (16 - 1) /* Cache line size align */
183
184/*
|
185 * Destroys a uma zone
| 185 * Destroys an empty uma zone. If the zone is not empty uma complains loudly.
|
186 *
187 * Arguments:
188 * zone The zone we want to destroy.
| 186 *
187 * Arguments:
188 * zone The zone we want to destroy.
|
189 * wait This flag indicates whether or not we should wait for all
190 * allocations to free, or return an errno on outstanding memory.
| |
191 *
| 189 *
|
192 * Returns:
193 * 0 on successful completion, or EWOULDBLOCK if there are outstanding
194 * allocations and the wait flag is M_NOWAIT
| |
195 */
196
| 190 */
191
|
197int uma_zdestroy(uma_zone_t zone, int wait);
| 192void uma_zdestroy(uma_zone_t zone);
|
198
199/*
200 * Allocates an item out of a zone
201 *
202 * Arguments:
203 * zone The zone we are allocating from
204 * arg This data is passed to the ctor function
205 * wait This flag indicates whether or not we are allowed to block while
206 * allocating memory for this zone should we run out.
207 *
208 * Returns:
209 * A non null pointer to an initialized element from the zone is
210 * garanteed if the wait flag is M_WAITOK, otherwise a null pointer may be
211 * returned if the zone is empty or the ctor failed.
212 */
213
214void *uma_zalloc_arg(uma_zone_t zone, void *arg, int wait);
215
216/*
217 * Allocates an item out of a zone without supplying an argument
218 *
219 * This is just a wrapper for uma_zalloc_arg for convenience.
220 *
221 */
222static __inline void *uma_zalloc(uma_zone_t zone, int wait);
223
224static __inline void *
225uma_zalloc(uma_zone_t zone, int wait)
226{
227 return uma_zalloc_arg(zone, NULL, wait);
228}
229
230/*
231 * Frees an item back into the specified zone.
232 *
233 * Arguments:
234 * zone The zone the item was originally allocated out of.
235 * item The memory to be freed.
236 * arg Argument passed to the destructor
237 *
238 * Returns:
239 * Nothing.
240 */
241
242void uma_zfree_arg(uma_zone_t zone, void *item, void *arg);
243
244/*
245 * Frees an item back to a zone without supplying an argument
246 *
247 * This is just a wrapper for uma_zfree_arg for convenience.
248 *
249 */
250static __inline void uma_zfree(uma_zone_t zone, void *item);
251
252static __inline void
253uma_zfree(uma_zone_t zone, void *item)
254{
255 return uma_zfree_arg(zone, item, NULL);
256}
257
258/*
259 * XXX The rest of the prototypes in this header are h0h0 magic for the VM.
260 * If you think you need to use it for a normal zone you're probably incorrect.
261 */
262
263/*
264 * Backend page supplier routines
265 *
266 * Arguments:
267 * zone The zone that is requesting pages
268 * size The number of bytes being requested
269 * pflag Flags for these memory pages, see below.
270 * wait Indicates our willingness to block.
271 *
272 * Returns:
273 * A pointer to the alloced memory or NULL on failure.
274 */
275
276typedef void *(*uma_alloc)(uma_zone_t zone, int size, u_int8_t *pflag, int wait);
277
278/*
279 * Backend page free routines
280 *
281 * Arguments:
282 * item A pointer to the previously allocated pages
283 * size The original size of the allocation
284 * pflag The flags for the slab. See UMA_SLAB_* below
285 *
286 * Returns:
287 * None
288 */
289typedef void (*uma_free)(void *item, int size, u_int8_t pflag);
290
291
292
293/*
294 * Sets up the uma allocator. (Called by vm_mem_init)
295 *
296 * Arguments:
297 * bootmem A pointer to memory used to bootstrap the system.
298 *
299 * Returns:
300 * Nothing
301 *
302 * Discussion:
303 * This memory is used for zones which allocate things before the
304 * backend page supplier can give us pages. It should be
305 * UMA_SLAB_SIZE * UMA_BOOT_PAGES bytes. (see uma_int.h)
306 *
307 */
308
309void uma_startup(void *bootmem);
310
311/*
312 * Finishes starting up the allocator. This should
313 * be called when kva is ready for normal allocs.
314 *
315 * Arguments:
316 * hash An area of memory that will become the malloc hash
317 * elems The number of elements in this array
318 *
319 * Returns:
320 * Nothing
321 *
322 * Discussion:
323 * uma_startup2 is called by kmeminit() to prepare the malloc
324 * hash bucket, and enable use of uma for malloc ops.
325 */
326
327void uma_startup2(void *hash, u_long elems);
328
329/*
330 * Reclaims unused memory for all zones
331 *
332 * Arguments:
333 * None
334 * Returns:
335 * None
336 *
337 * This should only be called by the page out daemon.
338 */
339
340void uma_reclaim(void);
341
342/*
343 * Switches the backing object of a zone
344 *
345 * Arguments:
346 * zone The zone to update
347 * obj The obj to use for future allocations
348 * size The size of the object to allocate
349 *
350 * Returns:
351 * 0 if kva space can not be allocated
352 * 1 if successful
353 *
354 * Discussion:
355 * A NULL object can be used and uma will allocate one for you. Setting
356 * the size will limit the amount of memory allocated to this zone.
357 *
358 */
359struct vm_object;
360int uma_zone_set_obj(uma_zone_t zone, struct vm_object *obj, int size);
361
362/*
363 * Sets a high limit on the number of items allowed in a zone
364 *
365 * Arguments:
366 * zone The zone to limit
367 *
368 * Returns:
369 * Nothing
370 */
371void uma_zone_set_max(uma_zone_t zone, int nitems);
372
373/*
374 * Replaces the standard page_alloc or obj_alloc functions for this zone
375 *
376 * Arguments:
377 * zone The zone whos back end allocator is being changed.
378 * allocf A pointer to the allocation function
379 *
380 * Returns:
381 * Nothing
382 *
383 * Discussion:
384 * This could be used to implement pageable allocation, or perhaps
385 * even DMA allocators if used in conjunction with the OFFPAGE
386 * zone flag.
387 */
388
389void uma_zone_set_allocf(uma_zone_t zone, uma_alloc allocf);
390
391/*
392 * Used for freeing memory provided by the allocf above
393 *
394 * Arguments:
395 * zone The zone that intends to use this free routine.
396 * freef The page freeing routine.
397 *
398 * Returns:
399 * Nothing
400 */
401
402void uma_zone_set_freef(uma_zone_t zone, uma_free freef);
403
404/*
405 * These flags are setable in the allocf and visable in the freef.
406 */
407#define UMA_SLAB_BOOT 0x01 /* Slab alloced from boot pages */
408#define UMA_SLAB_KMEM 0x02 /* Slab alloced from kmem_map */
409#define UMA_SLAB_KMAP 0x04 /* Slab alloced from kernel_map */
410#define UMA_SLAB_PRIV 0x08 /* Slab alloced from priv allocator */
411#define UMA_SLAB_OFFP 0x10 /* Slab is managed separately */
412#define UMA_SLAB_MALLOC 0x20 /* Slab is a large malloc slab */
413/* 0x40 and 0x80 are available */
414
415/*
416 * Used to pre-fill a zone with some number of items
417 *
418 * Arguments:
419 * zone The zone to fill
420 * itemcnt The number of items to reserve
421 *
422 * Returns:
423 * Nothing
424 *
425 * NOTE: This is blocking and should only be done at startup
426 */
427void uma_prealloc(uma_zone_t zone, int itemcnt);
428
429
430#endif
| 193
194/*
195 * Allocates an item out of a zone
196 *
197 * Arguments:
198 * zone The zone we are allocating from
199 * arg This data is passed to the ctor function
200 * wait This flag indicates whether or not we are allowed to block while
201 * allocating memory for this zone should we run out.
202 *
203 * Returns:
204 * A non null pointer to an initialized element from the zone is
205 * garanteed if the wait flag is M_WAITOK, otherwise a null pointer may be
206 * returned if the zone is empty or the ctor failed.
207 */
208
209void *uma_zalloc_arg(uma_zone_t zone, void *arg, int wait);
210
211/*
212 * Allocates an item out of a zone without supplying an argument
213 *
214 * This is just a wrapper for uma_zalloc_arg for convenience.
215 *
216 */
217static __inline void *uma_zalloc(uma_zone_t zone, int wait);
218
219static __inline void *
220uma_zalloc(uma_zone_t zone, int wait)
221{
222 return uma_zalloc_arg(zone, NULL, wait);
223}
224
225/*
226 * Frees an item back into the specified zone.
227 *
228 * Arguments:
229 * zone The zone the item was originally allocated out of.
230 * item The memory to be freed.
231 * arg Argument passed to the destructor
232 *
233 * Returns:
234 * Nothing.
235 */
236
237void uma_zfree_arg(uma_zone_t zone, void *item, void *arg);
238
239/*
240 * Frees an item back to a zone without supplying an argument
241 *
242 * This is just a wrapper for uma_zfree_arg for convenience.
243 *
244 */
245static __inline void uma_zfree(uma_zone_t zone, void *item);
246
247static __inline void
248uma_zfree(uma_zone_t zone, void *item)
249{
250 return uma_zfree_arg(zone, item, NULL);
251}
252
253/*
254 * XXX The rest of the prototypes in this header are h0h0 magic for the VM.
255 * If you think you need to use it for a normal zone you're probably incorrect.
256 */
257
258/*
259 * Backend page supplier routines
260 *
261 * Arguments:
262 * zone The zone that is requesting pages
263 * size The number of bytes being requested
264 * pflag Flags for these memory pages, see below.
265 * wait Indicates our willingness to block.
266 *
267 * Returns:
268 * A pointer to the alloced memory or NULL on failure.
269 */
270
271typedef void *(*uma_alloc)(uma_zone_t zone, int size, u_int8_t *pflag, int wait);
272
273/*
274 * Backend page free routines
275 *
276 * Arguments:
277 * item A pointer to the previously allocated pages
278 * size The original size of the allocation
279 * pflag The flags for the slab. See UMA_SLAB_* below
280 *
281 * Returns:
282 * None
283 */
284typedef void (*uma_free)(void *item, int size, u_int8_t pflag);
285
286
287
288/*
289 * Sets up the uma allocator. (Called by vm_mem_init)
290 *
291 * Arguments:
292 * bootmem A pointer to memory used to bootstrap the system.
293 *
294 * Returns:
295 * Nothing
296 *
297 * Discussion:
298 * This memory is used for zones which allocate things before the
299 * backend page supplier can give us pages. It should be
300 * UMA_SLAB_SIZE * UMA_BOOT_PAGES bytes. (see uma_int.h)
301 *
302 */
303
304void uma_startup(void *bootmem);
305
306/*
307 * Finishes starting up the allocator. This should
308 * be called when kva is ready for normal allocs.
309 *
310 * Arguments:
311 * hash An area of memory that will become the malloc hash
312 * elems The number of elements in this array
313 *
314 * Returns:
315 * Nothing
316 *
317 * Discussion:
318 * uma_startup2 is called by kmeminit() to prepare the malloc
319 * hash bucket, and enable use of uma for malloc ops.
320 */
321
322void uma_startup2(void *hash, u_long elems);
323
324/*
325 * Reclaims unused memory for all zones
326 *
327 * Arguments:
328 * None
329 * Returns:
330 * None
331 *
332 * This should only be called by the page out daemon.
333 */
334
335void uma_reclaim(void);
336
337/*
338 * Switches the backing object of a zone
339 *
340 * Arguments:
341 * zone The zone to update
342 * obj The obj to use for future allocations
343 * size The size of the object to allocate
344 *
345 * Returns:
346 * 0 if kva space can not be allocated
347 * 1 if successful
348 *
349 * Discussion:
350 * A NULL object can be used and uma will allocate one for you. Setting
351 * the size will limit the amount of memory allocated to this zone.
352 *
353 */
354struct vm_object;
355int uma_zone_set_obj(uma_zone_t zone, struct vm_object *obj, int size);
356
357/*
358 * Sets a high limit on the number of items allowed in a zone
359 *
360 * Arguments:
361 * zone The zone to limit
362 *
363 * Returns:
364 * Nothing
365 */
366void uma_zone_set_max(uma_zone_t zone, int nitems);
367
368/*
369 * Replaces the standard page_alloc or obj_alloc functions for this zone
370 *
371 * Arguments:
372 * zone The zone whos back end allocator is being changed.
373 * allocf A pointer to the allocation function
374 *
375 * Returns:
376 * Nothing
377 *
378 * Discussion:
379 * This could be used to implement pageable allocation, or perhaps
380 * even DMA allocators if used in conjunction with the OFFPAGE
381 * zone flag.
382 */
383
384void uma_zone_set_allocf(uma_zone_t zone, uma_alloc allocf);
385
386/*
387 * Used for freeing memory provided by the allocf above
388 *
389 * Arguments:
390 * zone The zone that intends to use this free routine.
391 * freef The page freeing routine.
392 *
393 * Returns:
394 * Nothing
395 */
396
397void uma_zone_set_freef(uma_zone_t zone, uma_free freef);
398
399/*
400 * These flags are setable in the allocf and visable in the freef.
401 */
402#define UMA_SLAB_BOOT 0x01 /* Slab alloced from boot pages */
403#define UMA_SLAB_KMEM 0x02 /* Slab alloced from kmem_map */
404#define UMA_SLAB_KMAP 0x04 /* Slab alloced from kernel_map */
405#define UMA_SLAB_PRIV 0x08 /* Slab alloced from priv allocator */
406#define UMA_SLAB_OFFP 0x10 /* Slab is managed separately */
407#define UMA_SLAB_MALLOC 0x20 /* Slab is a large malloc slab */
408/* 0x40 and 0x80 are available */
409
410/*
411 * Used to pre-fill a zone with some number of items
412 *
413 * Arguments:
414 * zone The zone to fill
415 * itemcnt The number of items to reserve
416 *
417 * Returns:
418 * Nothing
419 *
420 * NOTE: This is blocking and should only be done at startup
421 */
422void uma_prealloc(uma_zone_t zone, int itemcnt);
423
424
425#endif
|