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