Blame view
mm/mempool.c
10.4 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 7 8 9 10 11 12 |
/* * linux/mm/mempool.c * * memory buffer pool support. Such pools are mostly used * for guaranteed, deadlock-free memory allocations during * extreme VM load. * * started by Ingo Molnar, Copyright (C) 2001 */ #include <linux/mm.h> #include <linux/slab.h> |
b95f1b31b mm: Map most file... |
13 |
#include <linux/export.h> |
1da177e4c Linux-2.6.12-rc2 |
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
#include <linux/mempool.h> #include <linux/blkdev.h> #include <linux/writeback.h> static void add_element(mempool_t *pool, void *element) { BUG_ON(pool->curr_nr >= pool->min_nr); pool->elements[pool->curr_nr++] = element; } static void *remove_element(mempool_t *pool) { BUG_ON(pool->curr_nr <= 0); return pool->elements[--pool->curr_nr]; } |
0565d3177 mempool: drop unn... |
29 30 31 32 33 34 35 36 37 |
/** * mempool_destroy - deallocate a memory pool * @pool: pointer to the memory pool which was allocated via * mempool_create(). * * Free all reserved elements in @pool and @pool itself. This function * only sleeps if the free_fn() function sleeps. */ void mempool_destroy(mempool_t *pool) |
1da177e4c Linux-2.6.12-rc2 |
38 39 40 41 42 43 44 45 |
{ while (pool->curr_nr) { void *element = remove_element(pool); pool->free(element, pool->pool_data); } kfree(pool->elements); kfree(pool); } |
0565d3177 mempool: drop unn... |
46 |
EXPORT_SYMBOL(mempool_destroy); |
1da177e4c Linux-2.6.12-rc2 |
47 48 49 50 51 52 53 54 55 56 |
/** * mempool_create - create a memory pool * @min_nr: the minimum number of elements guaranteed to be * allocated for this pool. * @alloc_fn: user-defined element-allocation function. * @free_fn: user-defined element-freeing function. * @pool_data: optional private data available to the user-defined functions. * * this function creates and allocates a guaranteed size, preallocated |
72fd4a35a [PATCH] Numerous ... |
57 |
* memory pool. The pool can be used from the mempool_alloc() and mempool_free() |
1da177e4c Linux-2.6.12-rc2 |
58 |
* functions. This function might sleep. Both the alloc_fn() and the free_fn() |
72fd4a35a [PATCH] Numerous ... |
59 |
* functions might sleep - as long as the mempool_alloc() function is not called |
1da177e4c Linux-2.6.12-rc2 |
60 61 |
* from IRQ contexts. */ |
1946089a1 [PATCH] NUMA awar... |
62 |
mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, |
1da177e4c Linux-2.6.12-rc2 |
63 64 |
mempool_free_t *free_fn, void *pool_data) { |
1946089a1 [PATCH] NUMA awar... |
65 66 67 |
return mempool_create_node(min_nr,alloc_fn,free_fn, pool_data,-1); } EXPORT_SYMBOL(mempool_create); |
1da177e4c Linux-2.6.12-rc2 |
68 |
|
1946089a1 [PATCH] NUMA awar... |
69 70 71 72 |
mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data, int node_id) { mempool_t *pool; |
94f6030ca Slab allocators: ... |
73 |
pool = kmalloc_node(sizeof(*pool), GFP_KERNEL | __GFP_ZERO, node_id); |
1da177e4c Linux-2.6.12-rc2 |
74 75 |
if (!pool) return NULL; |
1946089a1 [PATCH] NUMA awar... |
76 77 |
pool->elements = kmalloc_node(min_nr * sizeof(void *), GFP_KERNEL, node_id); |
1da177e4c Linux-2.6.12-rc2 |
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 |
if (!pool->elements) { kfree(pool); return NULL; } spin_lock_init(&pool->lock); pool->min_nr = min_nr; pool->pool_data = pool_data; init_waitqueue_head(&pool->wait); pool->alloc = alloc_fn; pool->free = free_fn; /* * First pre-allocate the guaranteed number of buffers. */ while (pool->curr_nr < pool->min_nr) { void *element; element = pool->alloc(GFP_KERNEL, pool->pool_data); if (unlikely(!element)) { |
0565d3177 mempool: drop unn... |
97 |
mempool_destroy(pool); |
1da177e4c Linux-2.6.12-rc2 |
98 99 100 101 102 103 |
return NULL; } add_element(pool, element); } return pool; } |
1946089a1 [PATCH] NUMA awar... |
104 |
EXPORT_SYMBOL(mempool_create_node); |
1da177e4c Linux-2.6.12-rc2 |
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
/** * mempool_resize - resize an existing memory pool * @pool: pointer to the memory pool which was allocated via * mempool_create(). * @new_min_nr: the new minimum number of elements guaranteed to be * allocated for this pool. * @gfp_mask: the usual allocation bitmask. * * This function shrinks/grows the pool. In the case of growing, * it cannot be guaranteed that the pool will be grown to the new * size immediately, but new mempool_free() calls will refill it. * * Note, the caller must guarantee that no mempool_destroy is called * while this function is running. mempool_alloc() & mempool_free() * might be called (eg. from IRQ contexts) while this function executes. */ |
dd0fc66fb [PATCH] gfp flags... |
122 |
int mempool_resize(mempool_t *pool, int new_min_nr, gfp_t gfp_mask) |
1da177e4c Linux-2.6.12-rc2 |
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 |
{ void *element; void **new_elements; unsigned long flags; BUG_ON(new_min_nr <= 0); spin_lock_irqsave(&pool->lock, flags); if (new_min_nr <= pool->min_nr) { while (new_min_nr < pool->curr_nr) { element = remove_element(pool); spin_unlock_irqrestore(&pool->lock, flags); pool->free(element, pool->pool_data); spin_lock_irqsave(&pool->lock, flags); } pool->min_nr = new_min_nr; goto out_unlock; } spin_unlock_irqrestore(&pool->lock, flags); /* Grow the pool */ new_elements = kmalloc(new_min_nr * sizeof(*new_elements), gfp_mask); if (!new_elements) return -ENOMEM; spin_lock_irqsave(&pool->lock, flags); if (unlikely(new_min_nr <= pool->min_nr)) { /* Raced, other resize will do our work */ spin_unlock_irqrestore(&pool->lock, flags); kfree(new_elements); goto out; } memcpy(new_elements, pool->elements, pool->curr_nr * sizeof(*new_elements)); kfree(pool->elements); pool->elements = new_elements; pool->min_nr = new_min_nr; while (pool->curr_nr < pool->min_nr) { spin_unlock_irqrestore(&pool->lock, flags); element = pool->alloc(gfp_mask, pool->pool_data); if (!element) goto out; spin_lock_irqsave(&pool->lock, flags); if (pool->curr_nr < pool->min_nr) { add_element(pool, element); } else { spin_unlock_irqrestore(&pool->lock, flags); pool->free(element, pool->pool_data); /* Raced */ goto out; } } out_unlock: spin_unlock_irqrestore(&pool->lock, flags); out: return 0; } EXPORT_SYMBOL(mempool_resize); /** |
1da177e4c Linux-2.6.12-rc2 |
183 184 185 186 187 |
* mempool_alloc - allocate an element from a specific memory pool * @pool: pointer to the memory pool which was allocated via * mempool_create(). * @gfp_mask: the usual allocation bitmask. * |
72fd4a35a [PATCH] Numerous ... |
188 |
* this function only sleeps if the alloc_fn() function sleeps or |
1da177e4c Linux-2.6.12-rc2 |
189 190 191 192 |
* returns NULL. Note that due to preallocation, this function * *never* fails when called from process contexts. (it might * fail if called from an IRQ context.) */ |
dd0fc66fb [PATCH] gfp flags... |
193 |
void * mempool_alloc(mempool_t *pool, gfp_t gfp_mask) |
1da177e4c Linux-2.6.12-rc2 |
194 195 196 |
{ void *element; unsigned long flags; |
01890a4c1 [PATCH] mempool -... |
197 |
wait_queue_t wait; |
6daa0e286 [PATCH] gfp_t: mm... |
198 |
gfp_t gfp_temp; |
20a77776c [PATCH] mempool: ... |
199 200 |
might_sleep_if(gfp_mask & __GFP_WAIT); |
b84a35be0 [PATCH] mempool: ... |
201 202 203 204 |
gfp_mask |= __GFP_NOMEMALLOC; /* don't allocate emergency reserves */ gfp_mask |= __GFP_NORETRY; /* don't loop in __alloc_pages */ gfp_mask |= __GFP_NOWARN; /* failures are OK */ |
1da177e4c Linux-2.6.12-rc2 |
205 |
|
20a77776c [PATCH] mempool: ... |
206 |
gfp_temp = gfp_mask & ~(__GFP_WAIT|__GFP_IO); |
1da177e4c Linux-2.6.12-rc2 |
207 |
repeat_alloc: |
20a77776c [PATCH] mempool: ... |
208 209 |
element = pool->alloc(gfp_temp, pool->pool_data); |
1da177e4c Linux-2.6.12-rc2 |
210 211 |
if (likely(element != NULL)) return element; |
1da177e4c Linux-2.6.12-rc2 |
212 213 214 215 |
spin_lock_irqsave(&pool->lock, flags); if (likely(pool->curr_nr)) { element = remove_element(pool); spin_unlock_irqrestore(&pool->lock, flags); |
5b990546e mempool: fix and ... |
216 217 |
/* paired with rmb in mempool_free(), read comment there */ smp_wmb(); |
1da177e4c Linux-2.6.12-rc2 |
218 219 |
return element; } |
1da177e4c Linux-2.6.12-rc2 |
220 |
|
1ebb7044c mempool: fix firs... |
221 222 223 224 225 226 227 228 229 230 231 |
/* * We use gfp mask w/o __GFP_WAIT or IO for the first round. If * alloc failed with that and @pool was empty, retry immediately. */ if (gfp_temp != gfp_mask) { spin_unlock_irqrestore(&pool->lock, flags); gfp_temp = gfp_mask; goto repeat_alloc; } /* We must not sleep if !__GFP_WAIT */ |
5b990546e mempool: fix and ... |
232 233 |
if (!(gfp_mask & __GFP_WAIT)) { spin_unlock_irqrestore(&pool->lock, flags); |
1da177e4c Linux-2.6.12-rc2 |
234 |
return NULL; |
5b990546e mempool: fix and ... |
235 |
} |
1da177e4c Linux-2.6.12-rc2 |
236 |
|
5b990546e mempool: fix and ... |
237 |
/* Let's wait for someone else to return an element to @pool */ |
01890a4c1 [PATCH] mempool -... |
238 |
init_wait(&wait); |
1da177e4c Linux-2.6.12-rc2 |
239 |
prepare_to_wait(&pool->wait, &wait, TASK_UNINTERRUPTIBLE); |
1da177e4c Linux-2.6.12-rc2 |
240 |
|
5b990546e mempool: fix and ... |
241 242 243 244 245 246 247 248 249 |
spin_unlock_irqrestore(&pool->lock, flags); /* * FIXME: this should be io_schedule(). The timeout is there as a * workaround for some DM problems in 2.6.18. */ io_schedule_timeout(5*HZ); finish_wait(&pool->wait, &wait); |
1da177e4c Linux-2.6.12-rc2 |
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
goto repeat_alloc; } EXPORT_SYMBOL(mempool_alloc); /** * mempool_free - return an element to the pool. * @element: pool element pointer. * @pool: pointer to the memory pool which was allocated via * mempool_create(). * * this function only sleeps if the free_fn() function sleeps. */ void mempool_free(void *element, mempool_t *pool) { unsigned long flags; |
c80e7a826 permit mempool_fr... |
265 266 |
if (unlikely(element == NULL)) return; |
5b990546e mempool: fix and ... |
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 |
/* * Paired with the wmb in mempool_alloc(). The preceding read is * for @element and the following @pool->curr_nr. This ensures * that the visible value of @pool->curr_nr is from after the * allocation of @element. This is necessary for fringe cases * where @element was passed to this task without going through * barriers. * * For example, assume @p is %NULL at the beginning and one task * performs "p = mempool_alloc(...);" while another task is doing * "while (!p) cpu_relax(); mempool_free(p, ...);". This function * may end up using curr_nr value which is from before allocation * of @p without the following rmb. */ smp_rmb(); /* * For correctness, we need a test which is guaranteed to trigger * if curr_nr + #allocated == min_nr. Testing curr_nr < min_nr * without locking achieves that and refilling as soon as possible * is desirable. * * Because curr_nr visible here is always a value after the * allocation of @element, any task which decremented curr_nr below * min_nr is guaranteed to see curr_nr < min_nr unless curr_nr gets * incremented to min_nr afterwards. If curr_nr gets incremented * to min_nr after the allocation of @element, the elements * allocated after that are subject to the same guarantee. * * Waiters happen iff curr_nr is 0 and the above guarantee also * ensures that there will be frees which return elements to the * pool waking up the waiters. */ |
1da177e4c Linux-2.6.12-rc2 |
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 |
if (pool->curr_nr < pool->min_nr) { spin_lock_irqsave(&pool->lock, flags); if (pool->curr_nr < pool->min_nr) { add_element(pool, element); spin_unlock_irqrestore(&pool->lock, flags); wake_up(&pool->wait); return; } spin_unlock_irqrestore(&pool->lock, flags); } pool->free(element, pool->pool_data); } EXPORT_SYMBOL(mempool_free); /* * A commonly used alloc and free fn. */ |
dd0fc66fb [PATCH] gfp flags... |
317 |
void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data) |
1da177e4c Linux-2.6.12-rc2 |
318 |
{ |
fcc234f88 [PATCH] mm: kill ... |
319 |
struct kmem_cache *mem = pool_data; |
1da177e4c Linux-2.6.12-rc2 |
320 321 322 323 324 325 |
return kmem_cache_alloc(mem, gfp_mask); } EXPORT_SYMBOL(mempool_alloc_slab); void mempool_free_slab(void *element, void *pool_data) { |
fcc234f88 [PATCH] mm: kill ... |
326 |
struct kmem_cache *mem = pool_data; |
1da177e4c Linux-2.6.12-rc2 |
327 328 329 |
kmem_cache_free(mem, element); } EXPORT_SYMBOL(mempool_free_slab); |
6e0678f39 [PATCH] mempool: ... |
330 331 |
/* |
53184082b [PATCH] mempool: ... |
332 |
* A commonly used alloc and free fn that kmalloc/kfrees the amount of memory |
183ff22bb spelling fixes: mm/ |
333 |
* specified by pool_data |
53184082b [PATCH] mempool: ... |
334 335 336 |
*/ void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data) { |
5e2f89b5d mempool.c: clean ... |
337 |
size_t size = (size_t)pool_data; |
53184082b [PATCH] mempool: ... |
338 339 340 341 342 343 344 345 346 347 348 |
return kmalloc(size, gfp_mask); } EXPORT_SYMBOL(mempool_kmalloc); void mempool_kfree(void *element, void *pool_data) { kfree(element); } EXPORT_SYMBOL(mempool_kfree); /* |
6e0678f39 [PATCH] mempool: ... |
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 |
* A simple mempool-backed page allocator that allocates pages * of the order specified by pool_data. */ void *mempool_alloc_pages(gfp_t gfp_mask, void *pool_data) { int order = (int)(long)pool_data; return alloc_pages(gfp_mask, order); } EXPORT_SYMBOL(mempool_alloc_pages); void mempool_free_pages(void *element, void *pool_data) { int order = (int)(long)pool_data; __free_pages(element, order); } EXPORT_SYMBOL(mempool_free_pages); |