lib/genalloc.c

   1 /*
   2  * Basic general purpose allocator for managing special purpose
   3  * memory, for example, memory that is not managed by the regular
   4  * kmalloc/kfree interface.  Uses for this includes on-device special
   5  * memory, uncached memory etc.
   6  *
   7  * It is safe to use the allocator in NMI handlers and other special
   8  * unblockable contexts that could otherwise deadlock on locks.  This
   9  * is implemented by using atomic operations and retries on any
  10  * conflicts.  The disadvantage is that there may be livelocks in
  11  * extreme cases.  For better scalability, one allocator can be used
  12  * for each CPU.
  13  *
  14  * The lockless operation only works if there is enough memory
  15  * available.  If new memory is added to the pool a lock has to be
  16  * still taken.  So any user relying on locklessness has to ensure
  17  * that sufficient memory is preallocated.
  18  *
  19  * The basic atomic operation of this allocator is cmpxchg on long.
  20  * On architectures that don't have NMI-safe cmpxchg implementation,
  21  * the allocator can NOT be used in NMI handler.  So code uses the
  22  * allocator in NMI handler should depend on
  23  * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
  24  *
  25  * Copyright 2005 (C) Jes Sorensen <jes@trained-monkey.org>
  26  *
  27  * This source code is licensed under the GNU General Public License,
  28  * Version 2.  See the file COPYING for more details.
  29  */
  30
  31 #include <linux/slab.h>
  32 #include <linux/module.h>
  33 #include <linux/bitmap.h>
  34 #include <linux/rculist.h>
  35 #include <linux/interrupt.h>
  36 #include <linux/genalloc.h>
  37
  38 static int set_bits_ll(unsigned long *addr, unsigned long mask_to_set)
  39 {
  40         unsigned long val, nval;
  41
  42         nval = *addr;
  43         do {
  44                 val = nval;
  45                 if (val & mask_to_set)
  46                         return -EBUSY;
  47                 cpu_relax();
  48         } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val);
  49
  50         return 0;
  51 }
  52
  53 static int clear_bits_ll(unsigned long *addr, unsigned long mask_to_clear)
  54 {
  55         unsigned long val, nval;
  56
  57         nval = *addr;
  58         do {
  59                 val = nval;
  60                 if ((val & mask_to_clear) != mask_to_clear)
  61                         return -EBUSY;
  62                 cpu_relax();
  63         } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val);
  64
  65         return 0;
  66 }
  67
  68 /*
  69  * bitmap_set_ll - set the specified number of bits at the specified position
  70  * @map: pointer to a bitmap
  71  * @start: a bit position in @map
  72  * @nr: number of bits to set
  73  *
  74  * Set @nr bits start from @start in @map lock-lessly. Several users
  75  * can set/clear the same bitmap simultaneously without lock. If two
  76  * users set the same bit, one user will return remain bits, otherwise
  77  * return 0.
  78  */
  79 static int bitmap_set_ll(unsigned long *map, int start, int nr)
  80 {
  81         unsigned long *p = map + BIT_WORD(start);
  82         const int size = start + nr;
  83         int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
  84         unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
  85
  86         while (nr - bits_to_set >= 0) {
  87                 if (set_bits_ll(p, mask_to_set))
  88                         return nr;
  89                 nr -= bits_to_set;
  90                 bits_to_set = BITS_PER_LONG;
  91                 mask_to_set = ~0UL;
  92                 p++;
  93         }
  94         if (nr) {
  95                 mask_to_set &= BITMAP_LAST_WORD_MASK(size);
  96                 if (set_bits_ll(p, mask_to_set))
  97                         return nr;
  98         }
  99
 100         return 0;
 101 }
 102
 103 /*
 104  * bitmap_clear_ll - clear the specified number of bits at the specified position
 105  * @map: pointer to a bitmap
 106  * @start: a bit position in @map
 107  * @nr: number of bits to set
 108  *
 109  * Clear @nr bits start from @start in @map lock-lessly. Several users
 110  * can set/clear the same bitmap simultaneously without lock. If two
 111  * users clear the same bit, one user will return remain bits,
 112  * otherwise return 0.
 113  */
 114 static int bitmap_clear_ll(unsigned long *map, int start, int nr)
 115 {
 116         unsigned long *p = map + BIT_WORD(start);
 117         const int size = start + nr;
 118         int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
 119         unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
 120
 121         while (nr - bits_to_clear >= 0) {
 122                 if (clear_bits_ll(p, mask_to_clear))
 123                         return nr;
 124                 nr -= bits_to_clear;
 125                 bits_to_clear = BITS_PER_LONG;
 126                 mask_to_clear = ~0UL;
 127                 p++;
 128         }
 129         if (nr) {
 130                 mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
 131                 if (clear_bits_ll(p, mask_to_clear))
 132                         return nr;
 133         }
 134
 135         return 0;
 136 }
 137
 138 /**
 139  * gen_pool_create - create a new special memory pool
 140  * @min_alloc_order: log base 2 of number of bytes each bitmap bit represents
 141  * @nid: node id of the node the pool structure should be allocated on, or -1
 142  *
 143  * Create a new special memory pool that can be used to manage special purpose
 144  * memory not managed by the regular kmalloc/kfree interface.
 145  */
 146 struct gen_pool *gen_pool_create(int min_alloc_order, int nid)
 147 {
 148         struct gen_pool *pool;
 149
 150         pool = kmalloc_node(sizeof(struct gen_pool), GFP_KERNEL, nid);
 151         if (pool != NULL) {
 152                 spin_lock_init(&pool->lock);
 153                 INIT_LIST_HEAD(&pool->chunks);
 154                 pool->min_alloc_order = min_alloc_order;
 155         }
 156         return pool;
 157 }
 158 EXPORT_SYMBOL(gen_pool_create);
 159
 160 /**
 161  * gen_pool_add_virt - add a new chunk of special memory to the pool
 162  * @pool: pool to add new memory chunk to
 163  * @virt: virtual starting address of memory chunk to add to pool
 164  * @phys: physical starting address of memory chunk to add to pool
 165  * @size: size in bytes of the memory chunk to add to pool
 166  * @nid: node id of the node the chunk structure and bitmap should be
 167  *       allocated on, or -1
 168  *
 169  * Add a new chunk of special memory to the specified pool.
 170  *
 171  * Returns 0 on success or a -ve errno on failure.
 172  */
 173 int gen_pool_add_virt(struct gen_pool *pool, unsigned long virt, phys_addr_t phys,
 174                  size_t size, int nid)
 175 {
 176         struct gen_pool_chunk *chunk;
 177         int nbits = size >> pool->min_alloc_order;
 178         int nbytes = sizeof(struct gen_pool_chunk) +
 179                                 (nbits + BITS_PER_BYTE - 1) / BITS_PER_BYTE;
 180
 181         chunk = kmalloc_node(nbytes, GFP_KERNEL | __GFP_ZERO, nid);
 182         if (unlikely(chunk == NULL))
 183                 return -ENOMEM;
 184
 185         chunk->phys_addr = phys;
 186         chunk->start_addr = virt;
 187         chunk->end_addr = virt + size;
 188         atomic_set(&chunk->avail, size);
 189
 190         spin_lock(&pool->lock);
 191         list_add_rcu(&chunk->next_chunk, &pool->chunks);
 192         spin_unlock(&pool->lock);
 193
 194         return 0;
 195 }
 196 EXPORT_SYMBOL(gen_pool_add_virt);
 197
 198 /**
 199  * gen_pool_virt_to_phys - return the physical address of memory
 200  * @pool: pool to allocate from
 201  * @addr: starting address of memory
 202  *
 203  * Returns the physical address on success, or -1 on error.
 204  */
 205 phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long addr)
 206 {
 207         struct gen_pool_chunk *chunk;
 208         phys_addr_t paddr = -1;
 209
 210         rcu_read_lock();
 211         list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) {
 212                 if (addr >= chunk->start_addr && addr < chunk->end_addr) {
 213                         paddr = chunk->phys_addr + (addr - chunk->start_addr);
 214                         break;
 215                 }
 216         }
 217         rcu_read_unlock();
 218
 219         return paddr;
 220 }
 221 EXPORT_SYMBOL(gen_pool_virt_to_phys);
 222
 223 /**
 224  * gen_pool_destroy - destroy a special memory pool
 225  * @pool: pool to destroy
 226  *
 227  * Destroy the specified special memory pool. Verifies that there are no
 228  * outstanding allocations.
 229  */
 230 void gen_pool_destroy(struct gen_pool *pool)
 231 {
 232         struct list_head *_chunk, *_next_chunk;
 233         struct gen_pool_chunk *chunk;
 234         int order = pool->min_alloc_order;
 235         int bit, end_bit;
 236
 237         list_for_each_safe(_chunk, _next_chunk, &pool->chunks) {
 238                 chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk);
 239                 list_del(&chunk->next_chunk);
 240
 241                 end_bit = (chunk->end_addr - chunk->start_addr) >> order;
 242                 bit = find_next_bit(chunk->bits, end_bit, 0);
 243                 BUG_ON(bit < end_bit);
 244
 245                 kfree(chunk);
 246         }
 247         kfree(pool);
 248         return;
 249 }
 250 EXPORT_SYMBOL(gen_pool_destroy);
 251
 252 /**
 253  * gen_pool_alloc_addr - allocate special memory from the pool
 254  * @pool: pool to allocate from
 255  * @size: number of bytes to allocate from the pool
 256  * @alloc_addr: if non-zero, allocate starting at alloc_addr.
 257  *
 258  * Allocate the requested number of bytes from the specified pool.
 259  * Uses a first-fit algorithm. Can not be used in NMI handler on
 260  * architectures without NMI-safe cmpxchg implementation.
 261  */
 262 unsigned long gen_pool_alloc_addr(struct gen_pool *pool, size_t size,
 263                                     unsigned long alloc_addr)
 264 {
 265         struct gen_pool_chunk *chunk;
 266         unsigned long addr = 0;
 267         int order = pool->min_alloc_order;
 268         int nbits, start_bit = 0, end_bit, remain;
 269         int alloc_bit_needed = 0;
 270
 271 #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
 272         BUG_ON(in_nmi());
 273 #endif
 274
 275         if (size == 0)
 276                 return 0;
 277
 278         if (alloc_addr & (1 << order) - 1)
 279                 return 0;
 280
 281         nbits = (size + (1UL << order) - 1) >> order;
 282         rcu_read_lock();
 283         list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) {
 284                 if (size > atomic_read(&chunk->avail))
 285                         continue;
 286
 287                 end_bit = (chunk->end_addr - chunk->start_addr) >> order;
 288                 if (alloc_addr) {
 289                         if (alloc_addr < chunk->start_addr ||
 290                                 alloc_addr >= chunk->end_addr)
 291                                 continue;
 292                         if (alloc_addr + size > chunk->end_addr)
 293                                 return 0;
 294                         alloc_bit_needed = start_bit =
 295                                 (alloc_addr - chunk->start_addr) >> order;
 296                 }
 297 retry:
 298                 start_bit = bitmap_find_next_zero_area(chunk->bits, end_bit,
 299                                                        start_bit, nbits, 0);
 300                 if (alloc_addr && alloc_bit_needed != start_bit)
 301                         return 0;
 302                 if (start_bit >= end_bit)
 303                         continue;
 304                 remain = bitmap_set_ll(chunk->bits, start_bit, nbits);
 305                 if (remain) {
 306                         remain = bitmap_clear_ll(chunk->bits, start_bit,
 307                                                  nbits - remain);
 308                         BUG_ON(remain);
 309                         goto retry;
 310                 }
 311
 312                 addr = chunk->start_addr + ((unsigned long)start_bit << order);
 313                 size = nbits << order;
 314                 atomic_sub(size, &chunk->avail);
 315                 break;
 316         }
 317         rcu_read_unlock();
 318         return addr;
 319 }
 320 EXPORT_SYMBOL(gen_pool_alloc_addr);
 321
 322 /**
 323  * gen_pool_free - free allocated special memory back to the pool
 324  * @pool: pool to free to
 325  * @addr: starting address of memory to free back to pool
 326  * @size: size in bytes of memory to free
 327  *
 328  * Free previously allocated special memory back to the specified
 329  * pool.  Can not be used in NMI handler on architectures without
 330  * NMI-safe cmpxchg implementation.
 331  */
 332 void gen_pool_free(struct gen_pool *pool, unsigned long addr, size_t size)
 333 {
 334         struct gen_pool_chunk *chunk;
 335         int order = pool->min_alloc_order;
 336         int start_bit, nbits, remain;
 337
 338 #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
 339         BUG_ON(in_nmi());
 340 #endif
 341
 342         nbits = (size + (1UL << order) - 1) >> order;
 343         rcu_read_lock();
 344         list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) {
 345                 if (addr >= chunk->start_addr && addr < chunk->end_addr) {
 346                         BUG_ON(addr + size > chunk->end_addr);
 347                         start_bit = (addr - chunk->start_addr) >> order;
 348                         remain = bitmap_clear_ll(chunk->bits, start_bit, nbits);
 349                         BUG_ON(remain);
 350                         size = nbits << order;
 351                         atomic_add(size, &chunk->avail);
 352                         rcu_read_unlock();
 353                         return;
 354                 }
 355         }
 356         rcu_read_unlock();
 357         BUG();
 358 }
 359 EXPORT_SYMBOL(gen_pool_free);
 360
 361 /**
 362  * gen_pool_for_each_chunk - call func for every chunk of generic memory pool
 363  * @pool:       the generic memory pool
 364  * @func:       func to call
 365  * @data:       additional data used by @func
 366  *
 367  * Call @func for every chunk of generic memory pool.  The @func is
 368  * called with rcu_read_lock held.
 369  */
 370 void gen_pool_for_each_chunk(struct gen_pool *pool,
 371         void (*func)(struct gen_pool *pool, struct gen_pool_chunk *chunk, void *data),
 372         void *data)
 373 {
 374         struct gen_pool_chunk *chunk;
 375
 376         rcu_read_lock();
 377         list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk)
 378                 func(pool, chunk, data);
 379         rcu_read_unlock();
 380 }
 381 EXPORT_SYMBOL(gen_pool_for_each_chunk);
 382
 383 /**
 384  * gen_pool_avail - get available free space of the pool
 385  * @pool: pool to get available free space
 386  *
 387  * Return available free space of the specified pool.
 388  */
 389 size_t gen_pool_avail(struct gen_pool *pool)
 390 {
 391         struct gen_pool_chunk *chunk;
 392         size_t avail = 0;
 393
 394         rcu_read_lock();
 395         list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk)
 396                 avail += atomic_read(&chunk->avail);
 397         rcu_read_unlock();
 398         return avail;
 399 }
 400 EXPORT_SYMBOL_GPL(gen_pool_avail);
 401
 402 /**
 403  * gen_pool_size - get size in bytes of memory managed by the pool
 404  * @pool: pool to get size
 405  *
 406  * Return size in bytes of memory managed by the pool.
 407  */
 408 size_t gen_pool_size(struct gen_pool *pool)
 409 {
 410         struct gen_pool_chunk *chunk;
 411         size_t size = 0;
 412
 413         rcu_read_lock();
 414         list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk)
 415                 size += chunk->end_addr - chunk->start_addr;
 416         rcu_read_unlock();
 417         return size;
 418 }
 419 EXPORT_SYMBOL_GPL(gen_pool_size);