Blame view
mm/mempool.c
15.8 KB
b24413180
|
1 |
// SPDX-License-Identifier: GPL-2.0 |
1da177e4c
|
2 3 4 5 6 7 8 9 |
/* * 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 |
bdfedb76f
|
10 |
* debugging by David Rientjes, Copyright (C) 2015 |
1da177e4c
|
11 12 13 14 |
*/ #include <linux/mm.h> #include <linux/slab.h> |
bdfedb76f
|
15 |
#include <linux/highmem.h> |
923936157
|
16 |
#include <linux/kasan.h> |
174119628
|
17 |
#include <linux/kmemleak.h> |
b95f1b31b
|
18 |
#include <linux/export.h> |
1da177e4c
|
19 20 21 |
#include <linux/mempool.h> #include <linux/blkdev.h> #include <linux/writeback.h> |
e244c9e66
|
22 |
#include "slab.h" |
1da177e4c
|
23 |
|
bdfedb76f
|
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB_DEBUG_ON) static void poison_error(mempool_t *pool, void *element, size_t size, size_t byte) { const int nr = pool->curr_nr; const int start = max_t(int, byte - (BITS_PER_LONG / 8), 0); const int end = min_t(int, byte + (BITS_PER_LONG / 8), size); int i; pr_err("BUG: mempool element poison mismatch "); pr_err("Mempool %p size %zu ", pool, size); pr_err(" nr=%d @ %p: %s0x", nr, element, start > 0 ? "... " : ""); for (i = start; i < end; i++) pr_cont("%x ", *(u8 *)(element + i)); pr_cont("%s ", end < size ? "..." : ""); dump_stack(); } static void __check_element(mempool_t *pool, void *element, size_t size) { u8 *obj = element; size_t i; for (i = 0; i < size; i++) { u8 exp = (i < size - 1) ? POISON_FREE : POISON_END; if (obj[i] != exp) { poison_error(pool, element, size, i); return; } } memset(obj, POISON_INUSE, size); } static void check_element(mempool_t *pool, void *element) { /* Mempools backed by slab allocator */ if (pool->free == mempool_free_slab || pool->free == mempool_kfree) __check_element(pool, element, ksize(element)); /* Mempools backed by page allocator */ if (pool->free == mempool_free_pages) { int order = (int)(long)pool->pool_data; void *addr = kmap_atomic((struct page *)element); __check_element(pool, addr, 1UL << (PAGE_SHIFT + order)); kunmap_atomic(addr); } } static void __poison_element(void *element, size_t size) { u8 *obj = element; memset(obj, POISON_FREE, size - 1); obj[size - 1] = POISON_END; } static void poison_element(mempool_t *pool, void *element) { /* Mempools backed by slab allocator */ if (pool->alloc == mempool_alloc_slab || pool->alloc == mempool_kmalloc) __poison_element(element, ksize(element)); /* Mempools backed by page allocator */ if (pool->alloc == mempool_alloc_pages) { int order = (int)(long)pool->pool_data; void *addr = kmap_atomic((struct page *)element); __poison_element(addr, 1UL << (PAGE_SHIFT + order)); kunmap_atomic(addr); } } #else /* CONFIG_DEBUG_SLAB || CONFIG_SLUB_DEBUG_ON */ static inline void check_element(mempool_t *pool, void *element) { } static inline void poison_element(mempool_t *pool, void *element) { } #endif /* CONFIG_DEBUG_SLAB || CONFIG_SLUB_DEBUG_ON */ |
6860f6340
|
108 |
static __always_inline void kasan_poison_element(mempool_t *pool, void *element) |
923936157
|
109 |
{ |
9b75a867c
|
110 |
if (pool->alloc == mempool_alloc_slab || pool->alloc == mempool_kmalloc) |
6860f6340
|
111 |
kasan_poison_kfree(element, _RET_IP_); |
923936157
|
112 113 114 |
if (pool->alloc == mempool_alloc_pages) kasan_free_pages(element, (unsigned long)pool->pool_data); } |
8cded8668
|
115 |
static void kasan_unpoison_element(mempool_t *pool, void *element) |
923936157
|
116 |
{ |
9b75a867c
|
117 118 |
if (pool->alloc == mempool_alloc_slab || pool->alloc == mempool_kmalloc) kasan_unpoison_slab(element); |
923936157
|
119 120 121 |
if (pool->alloc == mempool_alloc_pages) kasan_alloc_pages(element, (unsigned long)pool->pool_data); } |
6860f6340
|
122 |
static __always_inline void add_element(mempool_t *pool, void *element) |
1da177e4c
|
123 124 |
{ BUG_ON(pool->curr_nr >= pool->min_nr); |
bdfedb76f
|
125 |
poison_element(pool, element); |
923936157
|
126 |
kasan_poison_element(pool, element); |
1da177e4c
|
127 128 |
pool->elements[pool->curr_nr++] = element; } |
8cded8668
|
129 |
static void *remove_element(mempool_t *pool) |
1da177e4c
|
130 |
{ |
bdfedb76f
|
131 132 133 |
void *element = pool->elements[--pool->curr_nr]; BUG_ON(pool->curr_nr < 0); |
8cded8668
|
134 |
kasan_unpoison_element(pool, element); |
764013103
|
135 |
check_element(pool, element); |
bdfedb76f
|
136 |
return element; |
1da177e4c
|
137 |
} |
0565d3177
|
138 |
/** |
c1a67fefd
|
139 140 141 142 143 144 145 146 147 148 149 150 151 |
* mempool_exit - exit a mempool initialized with mempool_init() * @pool: pointer to the memory pool which was initialized with * mempool_init(). * * Free all reserved elements in @pool and @pool itself. This function * only sleeps if the free_fn() function sleeps. * * May be called on a zeroed but uninitialized mempool (i.e. allocated with * kzalloc()). */ void mempool_exit(mempool_t *pool) { while (pool->curr_nr) { |
8cded8668
|
152 |
void *element = remove_element(pool); |
c1a67fefd
|
153 154 155 156 157 158 159 160 |
pool->free(element, pool->pool_data); } kfree(pool->elements); pool->elements = NULL; } EXPORT_SYMBOL(mempool_exit); /** |
0565d3177
|
161 162 163 164 165 166 167 168 |
* 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
|
169 |
{ |
4e3ca3e03
|
170 171 |
if (unlikely(!pool)) return; |
c1a67fefd
|
172 |
mempool_exit(pool); |
1da177e4c
|
173 174 |
kfree(pool); } |
0565d3177
|
175 |
EXPORT_SYMBOL(mempool_destroy); |
1da177e4c
|
176 |
|
c1a67fefd
|
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 |
int mempool_init_node(mempool_t *pool, int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data, gfp_t gfp_mask, int node_id) { spin_lock_init(&pool->lock); pool->min_nr = min_nr; pool->pool_data = pool_data; pool->alloc = alloc_fn; pool->free = free_fn; init_waitqueue_head(&pool->wait); pool->elements = kmalloc_array_node(min_nr, sizeof(void *), gfp_mask, node_id); if (!pool->elements) return -ENOMEM; /* * First pre-allocate the guaranteed number of buffers. */ while (pool->curr_nr < pool->min_nr) { void *element; element = pool->alloc(gfp_mask, pool->pool_data); if (unlikely(!element)) { mempool_exit(pool); return -ENOMEM; } add_element(pool, element); } return 0; } EXPORT_SYMBOL(mempool_init_node); /** * mempool_init - initialize a memory pool |
a3bf6ce36
|
213 |
* @pool: pointer to the memory pool that should be initialized |
c1a67fefd
|
214 215 216 217 218 219 220 221 |
* @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. * * Like mempool_create(), but initializes the pool in (i.e. embedded in another * structure). |
a862f68a8
|
222 223 |
* * Return: %0 on success, negative error code otherwise. |
c1a67fefd
|
224 225 226 227 228 229 230 231 232 |
*/ int mempool_init(mempool_t *pool, int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data) { return mempool_init_node(pool, min_nr, alloc_fn, free_fn, pool_data, GFP_KERNEL, NUMA_NO_NODE); } EXPORT_SYMBOL(mempool_init); |
1da177e4c
|
233 234 235 236 237 238 239 240 241 |
/** * 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
|
242 |
* memory pool. The pool can be used from the mempool_alloc() and mempool_free() |
1da177e4c
|
243 |
* functions. This function might sleep. Both the alloc_fn() and the free_fn() |
72fd4a35a
|
244 |
* functions might sleep - as long as the mempool_alloc() function is not called |
1da177e4c
|
245 |
* from IRQ contexts. |
a862f68a8
|
246 247 |
* * Return: pointer to the created memory pool object or %NULL on error. |
1da177e4c
|
248 |
*/ |
1946089a1
|
249 |
mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, |
1da177e4c
|
250 251 |
mempool_free_t *free_fn, void *pool_data) { |
a91a5ac68
|
252 253 |
return mempool_create_node(min_nr,alloc_fn,free_fn, pool_data, GFP_KERNEL, NUMA_NO_NODE); |
1946089a1
|
254 255 |
} EXPORT_SYMBOL(mempool_create); |
1da177e4c
|
256 |
|
1946089a1
|
257 |
mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn, |
a91a5ac68
|
258 259 |
mempool_free_t *free_fn, void *pool_data, gfp_t gfp_mask, int node_id) |
1946089a1
|
260 261 |
{ mempool_t *pool; |
c1a67fefd
|
262 |
|
7b5219db0
|
263 |
pool = kzalloc_node(sizeof(*pool), gfp_mask, node_id); |
1da177e4c
|
264 265 |
if (!pool) return NULL; |
c1a67fefd
|
266 267 268 |
if (mempool_init_node(pool, min_nr, alloc_fn, free_fn, pool_data, gfp_mask, node_id)) { |
1da177e4c
|
269 270 271 |
kfree(pool); return NULL; } |
1da177e4c
|
272 |
|
1da177e4c
|
273 274 |
return pool; } |
1946089a1
|
275 |
EXPORT_SYMBOL(mempool_create_node); |
1da177e4c
|
276 277 278 279 280 281 282 |
/** * 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. |
1da177e4c
|
283 284 285 286 |
* * 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. |
11d833604
|
287 |
* This function may sleep. |
1da177e4c
|
288 289 290 291 |
* * 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. |
a862f68a8
|
292 293 |
* * Return: %0 on success, negative error code otherwise. |
1da177e4c
|
294 |
*/ |
11d833604
|
295 |
int mempool_resize(mempool_t *pool, int new_min_nr) |
1da177e4c
|
296 297 298 299 300 301 |
{ void *element; void **new_elements; unsigned long flags; BUG_ON(new_min_nr <= 0); |
11d833604
|
302 |
might_sleep(); |
1da177e4c
|
303 304 305 306 |
spin_lock_irqsave(&pool->lock, flags); if (new_min_nr <= pool->min_nr) { while (new_min_nr < pool->curr_nr) { |
8cded8668
|
307 |
element = remove_element(pool); |
1da177e4c
|
308 309 310 311 312 313 314 315 316 317 |
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 */ |
11d833604
|
318 319 |
new_elements = kmalloc_array(new_min_nr, sizeof(*new_elements), GFP_KERNEL); |
1da177e4c
|
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 |
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); |
11d833604
|
338 |
element = pool->alloc(GFP_KERNEL, pool->pool_data); |
1da177e4c
|
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 |
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
|
358 359 360 361 362 |
* 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
|
363 |
* this function only sleeps if the alloc_fn() function sleeps or |
1da177e4c
|
364 365 366 |
* 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.) |
4e390b2b2
|
367 |
* Note: using __GFP_ZERO is not supported. |
a862f68a8
|
368 369 |
* * Return: pointer to the allocated element or %NULL on error. |
1da177e4c
|
370 |
*/ |
f9054c70d
|
371 |
void *mempool_alloc(mempool_t *pool, gfp_t gfp_mask) |
1da177e4c
|
372 373 374 |
{ void *element; unsigned long flags; |
ac6424b98
|
375 |
wait_queue_entry_t wait; |
6daa0e286
|
376 |
gfp_t gfp_temp; |
20a77776c
|
377 |
|
8bf8fcb07
|
378 |
VM_WARN_ON_ONCE(gfp_mask & __GFP_ZERO); |
d0164adc8
|
379 |
might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM); |
b84a35be0
|
380 |
|
4e390b2b2
|
381 |
gfp_mask |= __GFP_NOMEMALLOC; /* don't allocate emergency reserves */ |
b84a35be0
|
382 383 |
gfp_mask |= __GFP_NORETRY; /* don't loop in __alloc_pages */ gfp_mask |= __GFP_NOWARN; /* failures are OK */ |
1da177e4c
|
384 |
|
d0164adc8
|
385 |
gfp_temp = gfp_mask & ~(__GFP_DIRECT_RECLAIM|__GFP_IO); |
20a77776c
|
386 |
|
1da177e4c
|
387 |
repeat_alloc: |
20a77776c
|
388 389 |
element = pool->alloc(gfp_temp, pool->pool_data); |
1da177e4c
|
390 391 |
if (likely(element != NULL)) return element; |
1da177e4c
|
392 393 |
spin_lock_irqsave(&pool->lock, flags); if (likely(pool->curr_nr)) { |
8cded8668
|
394 |
element = remove_element(pool); |
1da177e4c
|
395 |
spin_unlock_irqrestore(&pool->lock, flags); |
5b990546e
|
396 397 |
/* paired with rmb in mempool_free(), read comment there */ smp_wmb(); |
174119628
|
398 399 400 401 402 |
/* * Update the allocation stack trace as this is more useful * for debugging. */ kmemleak_update_trace(element); |
1da177e4c
|
403 404 |
return element; } |
1da177e4c
|
405 |
|
1ebb7044c
|
406 |
/* |
d0164adc8
|
407 |
* We use gfp mask w/o direct reclaim or IO for the first round. If |
1ebb7044c
|
408 409 |
* alloc failed with that and @pool was empty, retry immediately. */ |
4e390b2b2
|
410 |
if (gfp_temp != gfp_mask) { |
1ebb7044c
|
411 412 413 414 |
spin_unlock_irqrestore(&pool->lock, flags); gfp_temp = gfp_mask; goto repeat_alloc; } |
d0164adc8
|
415 416 |
/* We must not sleep if !__GFP_DIRECT_RECLAIM */ if (!(gfp_mask & __GFP_DIRECT_RECLAIM)) { |
5b990546e
|
417 |
spin_unlock_irqrestore(&pool->lock, flags); |
1da177e4c
|
418 |
return NULL; |
5b990546e
|
419 |
} |
1da177e4c
|
420 |
|
5b990546e
|
421 |
/* Let's wait for someone else to return an element to @pool */ |
01890a4c1
|
422 |
init_wait(&wait); |
1da177e4c
|
423 |
prepare_to_wait(&pool->wait, &wait, TASK_UNINTERRUPTIBLE); |
1da177e4c
|
424 |
|
5b990546e
|
425 426 427 428 429 430 431 432 433 |
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
|
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 |
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
|
449 450 |
if (unlikely(element == NULL)) return; |
5b990546e
|
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 |
/* * 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. */ |
eb9a3c62a
|
484 |
if (unlikely(pool->curr_nr < pool->min_nr)) { |
1da177e4c
|
485 |
spin_lock_irqsave(&pool->lock, flags); |
eb9a3c62a
|
486 |
if (likely(pool->curr_nr < pool->min_nr)) { |
1da177e4c
|
487 488 489 490 491 492 493 494 495 496 497 498 499 500 |
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
|
501 |
void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data) |
1da177e4c
|
502 |
{ |
fcc234f88
|
503 |
struct kmem_cache *mem = pool_data; |
e244c9e66
|
504 |
VM_BUG_ON(mem->ctor); |
1da177e4c
|
505 506 507 508 509 510 |
return kmem_cache_alloc(mem, gfp_mask); } EXPORT_SYMBOL(mempool_alloc_slab); void mempool_free_slab(void *element, void *pool_data) { |
fcc234f88
|
511 |
struct kmem_cache *mem = pool_data; |
1da177e4c
|
512 513 514 |
kmem_cache_free(mem, element); } EXPORT_SYMBOL(mempool_free_slab); |
6e0678f39
|
515 516 |
/* |
53184082b
|
517 |
* A commonly used alloc and free fn that kmalloc/kfrees the amount of memory |
183ff22bb
|
518 |
* specified by pool_data |
53184082b
|
519 520 521 |
*/ void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data) { |
5e2f89b5d
|
522 |
size_t size = (size_t)pool_data; |
53184082b
|
523 524 525 526 527 528 529 530 531 532 533 |
return kmalloc(size, gfp_mask); } EXPORT_SYMBOL(mempool_kmalloc); void mempool_kfree(void *element, void *pool_data) { kfree(element); } EXPORT_SYMBOL(mempool_kfree); /* |
6e0678f39
|
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 |
* 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); |