mm/mempool.c

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