genalloc.h 3.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081
  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. * This source code is licensed under the GNU General Public License,
  26. * Version 2. See the file COPYING for more details.
  27. */
  28. #ifndef __GENALLOC_H__
  29. #define __GENALLOC_H__
  30. /*
  31. * General purpose special memory pool descriptor.
  32. */
  33. struct gen_pool {
  34. spinlock_t lock;
  35. struct list_head chunks; /* list of chunks in this pool */
  36. int min_alloc_order; /* minimum allocation order */
  37. };
  38. /*
  39. * General purpose special memory pool chunk descriptor.
  40. */
  41. struct gen_pool_chunk {
  42. struct list_head next_chunk; /* next chunk in pool */
  43. atomic_t avail;
  44. phys_addr_t phys_addr; /* physical starting address of memory chunk */
  45. unsigned long start_addr; /* starting address of memory chunk */
  46. unsigned long end_addr; /* ending address of memory chunk */
  47. unsigned long bits[0]; /* bitmap for allocating memory chunk */
  48. };
  49. extern struct gen_pool *gen_pool_create(int, int);
  50. extern phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long);
  51. extern int gen_pool_add_virt(struct gen_pool *, unsigned long, phys_addr_t,
  52. size_t, int);
  53. /**
  54. * gen_pool_add - add a new chunk of special memory to the pool
  55. * @pool: pool to add new memory chunk to
  56. * @addr: starting address of memory chunk to add to pool
  57. * @size: size in bytes of the memory chunk to add to pool
  58. * @nid: node id of the node the chunk structure and bitmap should be
  59. * allocated on, or -1
  60. *
  61. * Add a new chunk of special memory to the specified pool.
  62. *
  63. * Returns 0 on success or a -ve errno on failure.
  64. */
  65. static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
  66. size_t size, int nid)
  67. {
  68. return gen_pool_add_virt(pool, addr, -1, size, nid);
  69. }
  70. extern void gen_pool_destroy(struct gen_pool *);
  71. extern unsigned long gen_pool_alloc(struct gen_pool *, size_t);
  72. extern void gen_pool_free(struct gen_pool *, unsigned long, size_t);
  73. extern void gen_pool_for_each_chunk(struct gen_pool *,
  74. void (*)(struct gen_pool *, struct gen_pool_chunk *, void *), void *);
  75. extern size_t gen_pool_avail(struct gen_pool *);
  76. extern size_t gen_pool_size(struct gen_pool *);
  77. #endif /* __GENALLOC_H__ */