Blame view
lib/genalloc.c
26 KB
40b0b3f8f treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-only |
f14f75b81 [PATCH] ia64 unca... |
2 |
/* |
7f184275a lib, Make gen_poo... |
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
* Basic general purpose allocator for managing special purpose * memory, for example, memory that is not managed by the regular * kmalloc/kfree interface. Uses for this includes on-device special * memory, uncached memory etc. * * It is safe to use the allocator in NMI handlers and other special * unblockable contexts that could otherwise deadlock on locks. This * is implemented by using atomic operations and retries on any * conflicts. The disadvantage is that there may be livelocks in * extreme cases. For better scalability, one allocator can be used * for each CPU. * * The lockless operation only works if there is enough memory * available. If new memory is added to the pool a lock has to be * still taken. So any user relying on locklessness has to ensure * that sufficient memory is preallocated. * * The basic atomic operation of this allocator is cmpxchg on long. * On architectures that don't have NMI-safe cmpxchg implementation, * the allocator can NOT be used in NMI handler. So code uses the * allocator in NMI handler should depend on * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG. |
f14f75b81 [PATCH] ia64 unca... |
25 |
* |
f14f75b81 [PATCH] ia64 unca... |
26 |
* Copyright 2005 (C) Jes Sorensen <jes@trained-monkey.org> |
f14f75b81 [PATCH] ia64 unca... |
27 |
*/ |
5a0e3ad6a include cleanup: ... |
28 |
#include <linux/slab.h> |
8bc3bcc93 lib: reduce the u... |
29 |
#include <linux/export.h> |
243797f59 genalloc: use bit... |
30 |
#include <linux/bitmap.h> |
7f184275a lib, Make gen_poo... |
31 32 |
#include <linux/rculist.h> #include <linux/interrupt.h> |
f14f75b81 [PATCH] ia64 unca... |
33 |
#include <linux/genalloc.h> |
9375db07a genalloc: add dev... |
34 |
#include <linux/of_device.h> |
35004f2e5 lib/genalloc.c: i... |
35 |
#include <linux/vmalloc.h> |
f14f75b81 [PATCH] ia64 unca... |
36 |
|
674470d97 lib/genalloc.c: f... |
37 38 39 40 |
static inline size_t chunk_size(const struct gen_pool_chunk *chunk) { return chunk->end_addr - chunk->start_addr + 1; } |
7f184275a lib, Make gen_poo... |
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 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
static int set_bits_ll(unsigned long *addr, unsigned long mask_to_set) { unsigned long val, nval; nval = *addr; do { val = nval; if (val & mask_to_set) return -EBUSY; cpu_relax(); } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val); return 0; } static int clear_bits_ll(unsigned long *addr, unsigned long mask_to_clear) { unsigned long val, nval; nval = *addr; do { val = nval; if ((val & mask_to_clear) != mask_to_clear) return -EBUSY; cpu_relax(); } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val); return 0; } /* * bitmap_set_ll - set the specified number of bits at the specified position * @map: pointer to a bitmap * @start: a bit position in @map * @nr: number of bits to set * * Set @nr bits start from @start in @map lock-lessly. Several users * can set/clear the same bitmap simultaneously without lock. If two * users set the same bit, one user will return remain bits, otherwise * return 0. */ static int bitmap_set_ll(unsigned long *map, int start, int nr) { unsigned long *p = map + BIT_WORD(start); const int size = start + nr; int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG); unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start); while (nr - bits_to_set >= 0) { if (set_bits_ll(p, mask_to_set)) return nr; nr -= bits_to_set; bits_to_set = BITS_PER_LONG; mask_to_set = ~0UL; p++; } if (nr) { mask_to_set &= BITMAP_LAST_WORD_MASK(size); if (set_bits_ll(p, mask_to_set)) return nr; } return 0; } /* * bitmap_clear_ll - clear the specified number of bits at the specified position * @map: pointer to a bitmap * @start: a bit position in @map * @nr: number of bits to set * * Clear @nr bits start from @start in @map lock-lessly. Several users * can set/clear the same bitmap simultaneously without lock. If two * users clear the same bit, one user will return remain bits, * otherwise return 0. */ static int bitmap_clear_ll(unsigned long *map, int start, int nr) { unsigned long *p = map + BIT_WORD(start); const int size = start + nr; int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG); unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start); while (nr - bits_to_clear >= 0) { if (clear_bits_ll(p, mask_to_clear)) return nr; nr -= bits_to_clear; bits_to_clear = BITS_PER_LONG; mask_to_clear = ~0UL; p++; } if (nr) { mask_to_clear &= BITMAP_LAST_WORD_MASK(size); if (clear_bits_ll(p, mask_to_clear)) return nr; } return 0; } |
f14f75b81 [PATCH] ia64 unca... |
140 |
|
a58cbd7c2 [PATCH] make genp... |
141 142 |
/** * gen_pool_create - create a new special memory pool |
929f97276 [PATCH] change ge... |
143 144 |
* @min_alloc_order: log base 2 of number of bytes each bitmap bit represents * @nid: node id of the node the pool structure should be allocated on, or -1 |
a58cbd7c2 [PATCH] make genp... |
145 146 147 |
* * Create a new special memory pool that can be used to manage special purpose * memory not managed by the regular kmalloc/kfree interface. |
929f97276 [PATCH] change ge... |
148 149 |
*/ struct gen_pool *gen_pool_create(int min_alloc_order, int nid) |
f14f75b81 [PATCH] ia64 unca... |
150 |
{ |
929f97276 [PATCH] change ge... |
151 |
struct gen_pool *pool; |
f14f75b81 [PATCH] ia64 unca... |
152 |
|
929f97276 [PATCH] change ge... |
153 154 |
pool = kmalloc_node(sizeof(struct gen_pool), GFP_KERNEL, nid); if (pool != NULL) { |
7f184275a lib, Make gen_poo... |
155 |
spin_lock_init(&pool->lock); |
929f97276 [PATCH] change ge... |
156 157 |
INIT_LIST_HEAD(&pool->chunks); pool->min_alloc_order = min_alloc_order; |
ca279cf10 genalloc: make it... |
158 159 |
pool->algo = gen_pool_first_fit; pool->data = NULL; |
c98c36355 genalloc: add sup... |
160 |
pool->name = NULL; |
929f97276 [PATCH] change ge... |
161 162 |
} return pool; |
f14f75b81 [PATCH] ia64 unca... |
163 164 |
} EXPORT_SYMBOL(gen_pool_create); |
a58cbd7c2 [PATCH] make genp... |
165 |
/** |
795ee3064 lib/genalloc: int... |
166 |
* gen_pool_add_owner- add a new chunk of special memory to the pool |
929f97276 [PATCH] change ge... |
167 |
* @pool: pool to add new memory chunk to |
3c8f370de lib/genalloc.c: a... |
168 169 |
* @virt: virtual starting address of memory chunk to add to pool * @phys: physical starting address of memory chunk to add to pool |
929f97276 [PATCH] change ge... |
170 171 172 |
* @size: size in bytes of the memory chunk to add to pool * @nid: node id of the node the chunk structure and bitmap should be * allocated on, or -1 |
795ee3064 lib/genalloc: int... |
173 |
* @owner: private data the publisher would like to recall at alloc time |
a58cbd7c2 [PATCH] make genp... |
174 175 |
* * Add a new chunk of special memory to the specified pool. |
3c8f370de lib/genalloc.c: a... |
176 177 |
* * Returns 0 on success or a -ve errno on failure. |
f14f75b81 [PATCH] ia64 unca... |
178 |
*/ |
795ee3064 lib/genalloc: int... |
179 180 |
int gen_pool_add_owner(struct gen_pool *pool, unsigned long virt, phys_addr_t phys, size_t size, int nid, void *owner) |
f14f75b81 [PATCH] ia64 unca... |
181 |
{ |
929f97276 [PATCH] change ge... |
182 183 184 |
struct gen_pool_chunk *chunk; int nbits = size >> pool->min_alloc_order; int nbytes = sizeof(struct gen_pool_chunk) + |
eedce141c genalloc: stop cr... |
185 |
BITS_TO_LONGS(nbits) * sizeof(long); |
f14f75b81 [PATCH] ia64 unca... |
186 |
|
6862d2fc8 lib/genalloc.c: u... |
187 |
chunk = vzalloc_node(nbytes, nid); |
929f97276 [PATCH] change ge... |
188 |
if (unlikely(chunk == NULL)) |
3c8f370de lib/genalloc.c: a... |
189 |
return -ENOMEM; |
f14f75b81 [PATCH] ia64 unca... |
190 |
|
3c8f370de lib/genalloc.c: a... |
191 192 |
chunk->phys_addr = phys; chunk->start_addr = virt; |
674470d97 lib/genalloc.c: f... |
193 |
chunk->end_addr = virt + size - 1; |
795ee3064 lib/genalloc: int... |
194 |
chunk->owner = owner; |
36a3d1dd4 lib/genalloc.c: m... |
195 |
atomic_long_set(&chunk->avail, size); |
f14f75b81 [PATCH] ia64 unca... |
196 |
|
7f184275a lib, Make gen_poo... |
197 198 199 |
spin_lock(&pool->lock); list_add_rcu(&chunk->next_chunk, &pool->chunks); spin_unlock(&pool->lock); |
929f97276 [PATCH] change ge... |
200 201 |
return 0; |
f14f75b81 [PATCH] ia64 unca... |
202 |
} |
795ee3064 lib/genalloc: int... |
203 |
EXPORT_SYMBOL(gen_pool_add_owner); |
3c8f370de lib/genalloc.c: a... |
204 205 206 207 208 209 210 211 212 213 |
/** * gen_pool_virt_to_phys - return the physical address of memory * @pool: pool to allocate from * @addr: starting address of memory * * Returns the physical address on success, or -1 on error. */ phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long addr) { |
3c8f370de lib/genalloc.c: a... |
214 |
struct gen_pool_chunk *chunk; |
7f184275a lib, Make gen_poo... |
215 |
phys_addr_t paddr = -1; |
3c8f370de lib/genalloc.c: a... |
216 |
|
7f184275a lib, Make gen_poo... |
217 218 |
rcu_read_lock(); list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { |
674470d97 lib/genalloc.c: f... |
219 |
if (addr >= chunk->start_addr && addr <= chunk->end_addr) { |
7f184275a lib, Make gen_poo... |
220 221 222 |
paddr = chunk->phys_addr + (addr - chunk->start_addr); break; } |
3c8f370de lib/genalloc.c: a... |
223 |
} |
7f184275a lib, Make gen_poo... |
224 |
rcu_read_unlock(); |
3c8f370de lib/genalloc.c: a... |
225 |
|
7f184275a lib, Make gen_poo... |
226 |
return paddr; |
3c8f370de lib/genalloc.c: a... |
227 228 |
} EXPORT_SYMBOL(gen_pool_virt_to_phys); |
f14f75b81 [PATCH] ia64 unca... |
229 |
|
a58cbd7c2 [PATCH] make genp... |
230 231 |
/** * gen_pool_destroy - destroy a special memory pool |
322acc96d [PATCH] LIB: add ... |
232 |
* @pool: pool to destroy |
a58cbd7c2 [PATCH] make genp... |
233 234 235 |
* * Destroy the specified special memory pool. Verifies that there are no * outstanding allocations. |
322acc96d [PATCH] LIB: add ... |
236 237 238 239 240 241 242 |
*/ void gen_pool_destroy(struct gen_pool *pool) { struct list_head *_chunk, *_next_chunk; struct gen_pool_chunk *chunk; int order = pool->min_alloc_order; int bit, end_bit; |
322acc96d [PATCH] LIB: add ... |
243 244 245 |
list_for_each_safe(_chunk, _next_chunk, &pool->chunks) { chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk); list_del(&chunk->next_chunk); |
674470d97 lib/genalloc.c: f... |
246 |
end_bit = chunk_size(chunk) >> order; |
322acc96d [PATCH] LIB: add ... |
247 248 |
bit = find_next_bit(chunk->bits, end_bit, 0); BUG_ON(bit < end_bit); |
6862d2fc8 lib/genalloc.c: u... |
249 |
vfree(chunk); |
322acc96d [PATCH] LIB: add ... |
250 |
} |
c98c36355 genalloc: add sup... |
251 |
kfree_const(pool->name); |
322acc96d [PATCH] LIB: add ... |
252 |
kfree(pool); |
322acc96d [PATCH] LIB: add ... |
253 254 |
} EXPORT_SYMBOL(gen_pool_destroy); |
a58cbd7c2 [PATCH] make genp... |
255 |
/** |
795ee3064 lib/genalloc: int... |
256 |
* gen_pool_alloc_algo_owner - allocate special memory from the pool |
de2dd0eb3 genalloc:support ... |
257 258 259 260 |
* @pool: pool to allocate from * @size: number of bytes to allocate from the pool * @algo: algorithm passed from caller * @data: data passed to algorithm |
795ee3064 lib/genalloc: int... |
261 |
* @owner: optionally retrieve the chunk owner |
de2dd0eb3 genalloc:support ... |
262 263 264 265 266 267 |
* * Allocate the requested number of bytes from the specified pool. * Uses the pool allocation function (with first-fit algorithm by default). * Can not be used in NMI handler on architectures without * NMI-safe cmpxchg implementation. */ |
795ee3064 lib/genalloc: int... |
268 269 |
unsigned long gen_pool_alloc_algo_owner(struct gen_pool *pool, size_t size, genpool_algo_t algo, void *data, void **owner) |
de2dd0eb3 genalloc:support ... |
270 |
{ |
929f97276 [PATCH] change ge... |
271 |
struct gen_pool_chunk *chunk; |
7f184275a lib, Make gen_poo... |
272 |
unsigned long addr = 0; |
929f97276 [PATCH] change ge... |
273 |
int order = pool->min_alloc_order; |
62e931fac lib/genalloc.c: s... |
274 |
int nbits, start_bit, end_bit, remain; |
7f184275a lib, Make gen_poo... |
275 276 277 278 |
#ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG BUG_ON(in_nmi()); #endif |
f14f75b81 [PATCH] ia64 unca... |
279 |
|
795ee3064 lib/genalloc: int... |
280 281 |
if (owner) *owner = NULL; |
929f97276 [PATCH] change ge... |
282 283 |
if (size == 0) return 0; |
f14f75b81 [PATCH] ia64 unca... |
284 |
|
929f97276 [PATCH] change ge... |
285 |
nbits = (size + (1UL << order) - 1) >> order; |
7f184275a lib, Make gen_poo... |
286 287 |
rcu_read_lock(); list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { |
36a3d1dd4 lib/genalloc.c: m... |
288 |
if (size > atomic_long_read(&chunk->avail)) |
7f184275a lib, Make gen_poo... |
289 |
continue; |
929f97276 [PATCH] change ge... |
290 |
|
62e931fac lib/genalloc.c: s... |
291 |
start_bit = 0; |
674470d97 lib/genalloc.c: f... |
292 |
end_bit = chunk_size(chunk) >> order; |
7f184275a lib, Make gen_poo... |
293 |
retry: |
de2dd0eb3 genalloc:support ... |
294 |
start_bit = algo(chunk->bits, end_bit, start_bit, |
52fbf1134 lib/genalloc.c: f... |
295 |
nbits, data, pool, chunk->start_addr); |
7f184275a lib, Make gen_poo... |
296 |
if (start_bit >= end_bit) |
243797f59 genalloc: use bit... |
297 |
continue; |
7f184275a lib, Make gen_poo... |
298 299 300 301 302 303 |
remain = bitmap_set_ll(chunk->bits, start_bit, nbits); if (remain) { remain = bitmap_clear_ll(chunk->bits, start_bit, nbits - remain); BUG_ON(remain); goto retry; |
f14f75b81 [PATCH] ia64 unca... |
304 |
} |
243797f59 genalloc: use bit... |
305 306 |
addr = chunk->start_addr + ((unsigned long)start_bit << order); |
7f184275a lib, Make gen_poo... |
307 |
size = nbits << order; |
36a3d1dd4 lib/genalloc.c: m... |
308 |
atomic_long_sub(size, &chunk->avail); |
795ee3064 lib/genalloc: int... |
309 310 |
if (owner) *owner = chunk->owner; |
7f184275a lib, Make gen_poo... |
311 |
break; |
929f97276 [PATCH] change ge... |
312 |
} |
7f184275a lib, Make gen_poo... |
313 314 |
rcu_read_unlock(); return addr; |
929f97276 [PATCH] change ge... |
315 |
} |
795ee3064 lib/genalloc: int... |
316 |
EXPORT_SYMBOL(gen_pool_alloc_algo_owner); |
f14f75b81 [PATCH] ia64 unca... |
317 |
|
a58cbd7c2 [PATCH] make genp... |
318 |
/** |
684f0d3d1 lib/genalloc: add... |
319 320 321 |
* gen_pool_dma_alloc - allocate special memory from the pool for DMA usage * @pool: pool to allocate from * @size: number of bytes to allocate from the pool |
da83a7229 lib/genalloc: add... |
322 |
* @dma: dma-view physical address return value. Use %NULL if unneeded. |
684f0d3d1 lib/genalloc: add... |
323 324 325 326 327 |
* * Allocate the requested number of bytes from the specified pool. * Uses the pool allocation function (with first-fit algorithm by default). * Can not be used in NMI handler on architectures without * NMI-safe cmpxchg implementation. |
da83a7229 lib/genalloc: add... |
328 329 |
* * Return: virtual address of the allocated memory, or %NULL on failure |
684f0d3d1 lib/genalloc: add... |
330 331 332 |
*/ void *gen_pool_dma_alloc(struct gen_pool *pool, size_t size, dma_addr_t *dma) { |
cf394fc5f lib/genalloc.c: A... |
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 |
return gen_pool_dma_alloc_algo(pool, size, dma, pool->algo, pool->data); } EXPORT_SYMBOL(gen_pool_dma_alloc); /** * gen_pool_dma_alloc_algo - allocate special memory from the pool for DMA * usage with the given pool algorithm * @pool: pool to allocate from * @size: number of bytes to allocate from the pool * @dma: DMA-view physical address return value. Use %NULL if unneeded. * @algo: algorithm passed from caller * @data: data passed to algorithm * * Allocate the requested number of bytes from the specified pool. Uses the * given pool allocation function. Can not be used in NMI handler on * architectures without NMI-safe cmpxchg implementation. * * Return: virtual address of the allocated memory, or %NULL on failure */ void *gen_pool_dma_alloc_algo(struct gen_pool *pool, size_t size, dma_addr_t *dma, genpool_algo_t algo, void *data) { |
684f0d3d1 lib/genalloc: add... |
355 356 357 358 |
unsigned long vaddr; if (!pool) return NULL; |
cf394fc5f lib/genalloc.c: A... |
359 |
vaddr = gen_pool_alloc_algo(pool, size, algo, data); |
684f0d3d1 lib/genalloc: add... |
360 361 |
if (!vaddr) return NULL; |
0368dfd01 lib/genalloc.c: a... |
362 363 |
if (dma) *dma = gen_pool_virt_to_phys(pool, vaddr); |
684f0d3d1 lib/genalloc: add... |
364 365 366 |
return (void *)vaddr; } |
cf394fc5f lib/genalloc.c: A... |
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 |
EXPORT_SYMBOL(gen_pool_dma_alloc_algo); /** * gen_pool_dma_alloc_align - allocate special memory from the pool for DMA * usage with the given alignment * @pool: pool to allocate from * @size: number of bytes to allocate from the pool * @dma: DMA-view physical address return value. Use %NULL if unneeded. * @align: alignment in bytes for starting address * * Allocate the requested number bytes from the specified pool, with the given * alignment restriction. Can not be used in NMI handler on architectures * without NMI-safe cmpxchg implementation. * * Return: virtual address of the allocated memory, or %NULL on failure */ void *gen_pool_dma_alloc_align(struct gen_pool *pool, size_t size, dma_addr_t *dma, int align) { struct genpool_data_align data = { .align = align }; return gen_pool_dma_alloc_algo(pool, size, dma, gen_pool_first_fit_align, &data); } EXPORT_SYMBOL(gen_pool_dma_alloc_align); |
684f0d3d1 lib/genalloc: add... |
392 393 |
/** |
da83a7229 lib/genalloc: add... |
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 |
* gen_pool_dma_zalloc - allocate special zeroed memory from the pool for * DMA usage * @pool: pool to allocate from * @size: number of bytes to allocate from the pool * @dma: dma-view physical address return value. Use %NULL if unneeded. * * Allocate the requested number of zeroed bytes from the specified pool. * Uses the pool allocation function (with first-fit algorithm by default). * Can not be used in NMI handler on architectures without * NMI-safe cmpxchg implementation. * * Return: virtual address of the allocated zeroed memory, or %NULL on failure */ void *gen_pool_dma_zalloc(struct gen_pool *pool, size_t size, dma_addr_t *dma) { |
cf394fc5f lib/genalloc.c: A... |
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 |
return gen_pool_dma_zalloc_algo(pool, size, dma, pool->algo, pool->data); } EXPORT_SYMBOL(gen_pool_dma_zalloc); /** * gen_pool_dma_zalloc_algo - allocate special zeroed memory from the pool for * DMA usage with the given pool algorithm * @pool: pool to allocate from * @size: number of bytes to allocate from the pool * @dma: DMA-view physical address return value. Use %NULL if unneeded. * @algo: algorithm passed from caller * @data: data passed to algorithm * * Allocate the requested number of zeroed bytes from the specified pool. Uses * the given pool allocation function. Can not be used in NMI handler on * architectures without NMI-safe cmpxchg implementation. * * Return: virtual address of the allocated zeroed memory, or %NULL on failure */ void *gen_pool_dma_zalloc_algo(struct gen_pool *pool, size_t size, dma_addr_t *dma, genpool_algo_t algo, void *data) { void *vaddr = gen_pool_dma_alloc_algo(pool, size, dma, algo, data); |
da83a7229 lib/genalloc: add... |
432 433 434 435 436 437 |
if (vaddr) memset(vaddr, 0, size); return vaddr; } |
cf394fc5f lib/genalloc.c: A... |
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 |
EXPORT_SYMBOL(gen_pool_dma_zalloc_algo); /** * gen_pool_dma_zalloc_align - allocate special zeroed memory from the pool for * DMA usage with the given alignment * @pool: pool to allocate from * @size: number of bytes to allocate from the pool * @dma: DMA-view physical address return value. Use %NULL if unneeded. * @align: alignment in bytes for starting address * * Allocate the requested number of zeroed bytes from the specified pool, * with the given alignment restriction. Can not be used in NMI handler on * architectures without NMI-safe cmpxchg implementation. * * Return: virtual address of the allocated zeroed memory, or %NULL on failure */ void *gen_pool_dma_zalloc_align(struct gen_pool *pool, size_t size, dma_addr_t *dma, int align) { struct genpool_data_align data = { .align = align }; return gen_pool_dma_zalloc_algo(pool, size, dma, gen_pool_first_fit_align, &data); } EXPORT_SYMBOL(gen_pool_dma_zalloc_align); |
684f0d3d1 lib/genalloc: add... |
463 464 |
/** |
a58cbd7c2 [PATCH] make genp... |
465 |
* gen_pool_free - free allocated special memory back to the pool |
929f97276 [PATCH] change ge... |
466 467 468 |
* @pool: pool to free to * @addr: starting address of memory to free back to pool * @size: size in bytes of memory to free |
795ee3064 lib/genalloc: int... |
469 |
* @owner: private data stashed at gen_pool_add() time |
a58cbd7c2 [PATCH] make genp... |
470 |
* |
7f184275a lib, Make gen_poo... |
471 472 473 |
* Free previously allocated special memory back to the specified * pool. Can not be used in NMI handler on architectures without * NMI-safe cmpxchg implementation. |
929f97276 [PATCH] change ge... |
474 |
*/ |
795ee3064 lib/genalloc: int... |
475 476 |
void gen_pool_free_owner(struct gen_pool *pool, unsigned long addr, size_t size, void **owner) |
929f97276 [PATCH] change ge... |
477 |
{ |
929f97276 [PATCH] change ge... |
478 |
struct gen_pool_chunk *chunk; |
929f97276 [PATCH] change ge... |
479 |
int order = pool->min_alloc_order; |
7f184275a lib, Make gen_poo... |
480 |
int start_bit, nbits, remain; |
929f97276 [PATCH] change ge... |
481 |
|
7f184275a lib, Make gen_poo... |
482 483 484 |
#ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG BUG_ON(in_nmi()); #endif |
929f97276 [PATCH] change ge... |
485 |
|
795ee3064 lib/genalloc: int... |
486 487 |
if (owner) *owner = NULL; |
7f184275a lib, Make gen_poo... |
488 489 490 |
nbits = (size + (1UL << order) - 1) >> order; rcu_read_lock(); list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { |
674470d97 lib/genalloc.c: f... |
491 492 |
if (addr >= chunk->start_addr && addr <= chunk->end_addr) { BUG_ON(addr + size - 1 > chunk->end_addr); |
7f184275a lib, Make gen_poo... |
493 494 495 496 |
start_bit = (addr - chunk->start_addr) >> order; remain = bitmap_clear_ll(chunk->bits, start_bit, nbits); BUG_ON(remain); size = nbits << order; |
36a3d1dd4 lib/genalloc.c: m... |
497 |
atomic_long_add(size, &chunk->avail); |
795ee3064 lib/genalloc: int... |
498 499 |
if (owner) *owner = chunk->owner; |
7f184275a lib, Make gen_poo... |
500 501 |
rcu_read_unlock(); return; |
f14f75b81 [PATCH] ia64 unca... |
502 |
} |
f14f75b81 [PATCH] ia64 unca... |
503 |
} |
7f184275a lib, Make gen_poo... |
504 505 |
rcu_read_unlock(); BUG(); |
f14f75b81 [PATCH] ia64 unca... |
506 |
} |
795ee3064 lib/genalloc: int... |
507 |
EXPORT_SYMBOL(gen_pool_free_owner); |
7f184275a lib, Make gen_poo... |
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 |
/** * gen_pool_for_each_chunk - call func for every chunk of generic memory pool * @pool: the generic memory pool * @func: func to call * @data: additional data used by @func * * Call @func for every chunk of generic memory pool. The @func is * called with rcu_read_lock held. */ void gen_pool_for_each_chunk(struct gen_pool *pool, void (*func)(struct gen_pool *pool, struct gen_pool_chunk *chunk, void *data), void *data) { struct gen_pool_chunk *chunk; rcu_read_lock(); list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) func(pool, chunk, data); rcu_read_unlock(); } EXPORT_SYMBOL(gen_pool_for_each_chunk); /** |
9efb3a421 lib/genalloc.c: a... |
532 533 534 535 536 537 538 539 540 541 542 543 |
* addr_in_gen_pool - checks if an address falls within the range of a pool * @pool: the generic memory pool * @start: start address * @size: size of the region * * Check if the range of addresses falls within the specified pool. Returns * true if the entire range is contained in the pool and false otherwise. */ bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start, size_t size) { bool found = false; |
ad3d5d2f7 lib/genalloc.c: f... |
544 |
unsigned long end = start + size - 1; |
9efb3a421 lib/genalloc.c: a... |
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 |
struct gen_pool_chunk *chunk; rcu_read_lock(); list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) { if (start >= chunk->start_addr && start <= chunk->end_addr) { if (end <= chunk->end_addr) { found = true; break; } } } rcu_read_unlock(); return found; } /** |
7f184275a lib, Make gen_poo... |
561 562 563 564 565 566 567 568 569 570 571 572 |
* gen_pool_avail - get available free space of the pool * @pool: pool to get available free space * * Return available free space of the specified pool. */ size_t gen_pool_avail(struct gen_pool *pool) { struct gen_pool_chunk *chunk; size_t avail = 0; rcu_read_lock(); list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) |
36a3d1dd4 lib/genalloc.c: m... |
573 |
avail += atomic_long_read(&chunk->avail); |
7f184275a lib, Make gen_poo... |
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 |
rcu_read_unlock(); return avail; } EXPORT_SYMBOL_GPL(gen_pool_avail); /** * gen_pool_size - get size in bytes of memory managed by the pool * @pool: pool to get size * * Return size in bytes of memory managed by the pool. */ size_t gen_pool_size(struct gen_pool *pool) { struct gen_pool_chunk *chunk; size_t size = 0; rcu_read_lock(); list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) |
674470d97 lib/genalloc.c: f... |
592 |
size += chunk_size(chunk); |
7f184275a lib, Make gen_poo... |
593 594 595 596 |
rcu_read_unlock(); return size; } EXPORT_SYMBOL_GPL(gen_pool_size); |
ca279cf10 genalloc: make it... |
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 |
/** * gen_pool_set_algo - set the allocation algorithm * @pool: pool to change allocation algorithm * @algo: custom algorithm function * @data: additional data used by @algo * * Call @algo for each memory allocation in the pool. * If @algo is NULL use gen_pool_first_fit as default * memory allocation function. */ void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo, void *data) { rcu_read_lock(); pool->algo = algo; if (!pool->algo) pool->algo = gen_pool_first_fit; pool->data = data; rcu_read_unlock(); } EXPORT_SYMBOL(gen_pool_set_algo); /** * gen_pool_first_fit - find the first available region * of memory matching the size requirement (no alignment constraint) * @map: The address to base the search on * @size: The bitmap size in bits * @start: The bitnumber to start searching at * @nr: The number of zeroed bits we're looking for * @data: additional data - unused |
de2dd0eb3 genalloc:support ... |
630 |
* @pool: pool to find the fit region memory from |
ca279cf10 genalloc: make it... |
631 632 |
*/ unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size, |
de2dd0eb3 genalloc:support ... |
633 |
unsigned long start, unsigned int nr, void *data, |
52fbf1134 lib/genalloc.c: f... |
634 |
struct gen_pool *pool, unsigned long start_addr) |
ca279cf10 genalloc: make it... |
635 636 637 638 639 640 |
{ return bitmap_find_next_zero_area(map, size, start, nr, 0); } EXPORT_SYMBOL(gen_pool_first_fit); /** |
de2dd0eb3 genalloc:support ... |
641 642 643 644 645 646 647 648 649 650 651 |
* gen_pool_first_fit_align - find the first available region * of memory matching the size requirement (alignment constraint) * @map: The address to base the search on * @size: The bitmap size in bits * @start: The bitnumber to start searching at * @nr: The number of zeroed bits we're looking for * @data: data for alignment * @pool: pool to get order from */ unsigned long gen_pool_first_fit_align(unsigned long *map, unsigned long size, unsigned long start, unsigned int nr, void *data, |
52fbf1134 lib/genalloc.c: f... |
652 |
struct gen_pool *pool, unsigned long start_addr) |
de2dd0eb3 genalloc:support ... |
653 654 |
{ struct genpool_data_align *alignment; |
52fbf1134 lib/genalloc.c: f... |
655 |
unsigned long align_mask, align_off; |
de2dd0eb3 genalloc:support ... |
656 657 658 659 660 |
int order; alignment = data; order = pool->min_alloc_order; align_mask = ((alignment->align + (1UL << order) - 1) >> order) - 1; |
52fbf1134 lib/genalloc.c: f... |
661 662 663 664 |
align_off = (start_addr & (alignment->align - 1)) >> order; return bitmap_find_next_zero_area_off(map, size, start, nr, align_mask, align_off); |
de2dd0eb3 genalloc:support ... |
665 666 667 668 |
} EXPORT_SYMBOL(gen_pool_first_fit_align); /** |
b26981c8f genalloc:support ... |
669 670 671 672 673 674 675 676 677 678 |
* gen_pool_fixed_alloc - reserve a specific region * @map: The address to base the search on * @size: The bitmap size in bits * @start: The bitnumber to start searching at * @nr: The number of zeroed bits we're looking for * @data: data for alignment * @pool: pool to get order from */ unsigned long gen_pool_fixed_alloc(unsigned long *map, unsigned long size, unsigned long start, unsigned int nr, void *data, |
52fbf1134 lib/genalloc.c: f... |
679 |
struct gen_pool *pool, unsigned long start_addr) |
b26981c8f genalloc:support ... |
680 681 682 683 684 685 686 687 688 |
{ struct genpool_data_fixed *fixed_data; int order; unsigned long offset_bit; unsigned long start_bit; fixed_data = data; order = pool->min_alloc_order; offset_bit = fixed_data->offset >> order; |
0e6e01ff6 CPM/QE: use genal... |
689 |
if (WARN_ON(fixed_data->offset & ((1UL << order) - 1))) |
b26981c8f genalloc:support ... |
690 691 692 693 694 695 696 697 698 699 700 |
return size; start_bit = bitmap_find_next_zero_area(map, size, start + offset_bit, nr, 0); if (start_bit != offset_bit) start_bit = size; return start_bit; } EXPORT_SYMBOL(gen_pool_fixed_alloc); /** |
505e3be6c lib/genalloc.c: a... |
701 702 703 704 705 706 707 708 |
* gen_pool_first_fit_order_align - find the first available region * of memory matching the size requirement. The region will be aligned * to the order of the size specified. * @map: The address to base the search on * @size: The bitmap size in bits * @start: The bitnumber to start searching at * @nr: The number of zeroed bits we're looking for * @data: additional data - unused |
de2dd0eb3 genalloc:support ... |
709 |
* @pool: pool to find the fit region memory from |
505e3be6c lib/genalloc.c: a... |
710 711 712 |
*/ unsigned long gen_pool_first_fit_order_align(unsigned long *map, unsigned long size, unsigned long start, |
52fbf1134 lib/genalloc.c: f... |
713 714 |
unsigned int nr, void *data, struct gen_pool *pool, unsigned long start_addr) |
505e3be6c lib/genalloc.c: a... |
715 716 717 718 719 720 721 722 |
{ unsigned long align_mask = roundup_pow_of_two(nr) - 1; return bitmap_find_next_zero_area(map, size, start, nr, align_mask); } EXPORT_SYMBOL(gen_pool_first_fit_order_align); /** |
ca279cf10 genalloc: make it... |
723 724 725 726 727 728 729 |
* gen_pool_best_fit - find the best fitting region of memory * macthing the size requirement (no alignment constraint) * @map: The address to base the search on * @size: The bitmap size in bits * @start: The bitnumber to start searching at * @nr: The number of zeroed bits we're looking for * @data: additional data - unused |
de2dd0eb3 genalloc:support ... |
730 |
* @pool: pool to find the fit region memory from |
ca279cf10 genalloc: make it... |
731 732 733 734 735 |
* * Iterate over the bitmap to find the smallest free region * which we can allocate the memory. */ unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size, |
de2dd0eb3 genalloc:support ... |
736 |
unsigned long start, unsigned int nr, void *data, |
52fbf1134 lib/genalloc.c: f... |
737 |
struct gen_pool *pool, unsigned long start_addr) |
ca279cf10 genalloc: make it... |
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 |
{ unsigned long start_bit = size; unsigned long len = size + 1; unsigned long index; index = bitmap_find_next_zero_area(map, size, start, nr, 0); while (index < size) { int next_bit = find_next_bit(map, size, index + nr); if ((next_bit - index) < len) { len = next_bit - index; start_bit = index; if (len == nr) return start_bit; } index = bitmap_find_next_zero_area(map, size, next_bit + 1, nr, 0); } return start_bit; } EXPORT_SYMBOL(gen_pool_best_fit); |
9375db07a genalloc: add dev... |
760 761 762 763 764 |
static void devm_gen_pool_release(struct device *dev, void *res) { gen_pool_destroy(*(struct gen_pool **)res); } |
c98c36355 genalloc: add sup... |
765 766 767 768 769 770 771 772 773 774 775 776 777 |
static int devm_gen_pool_match(struct device *dev, void *res, void *data) { struct gen_pool **p = res; /* NULL data matches only a pool without an assigned name */ if (!data && !(*p)->name) return 1; if (!data || !(*p)->name) return 0; return !strcmp((*p)->name, data); } |
9375db07a genalloc: add dev... |
778 |
/** |
738581735 genalloc: add nam... |
779 780 781 782 783 784 785 786 787 |
* gen_pool_get - Obtain the gen_pool (if any) for a device * @dev: device to retrieve the gen_pool from * @name: name of a gen_pool or NULL, identifies a particular gen_pool on device * * Returns the gen_pool for the device if one is present, or NULL. */ struct gen_pool *gen_pool_get(struct device *dev, const char *name) { struct gen_pool **p; |
c98c36355 genalloc: add sup... |
788 789 |
p = devres_find(dev, devm_gen_pool_release, devm_gen_pool_match, (void *)name); |
738581735 genalloc: add nam... |
790 791 792 793 794 795 796 |
if (!p) return NULL; return *p; } EXPORT_SYMBOL_GPL(gen_pool_get); /** |
9375db07a genalloc: add dev... |
797 798 799 |
* devm_gen_pool_create - managed gen_pool_create * @dev: device that provides the gen_pool * @min_alloc_order: log base 2 of number of bytes each bitmap bit represents |
738581735 genalloc: add nam... |
800 801 |
* @nid: node selector for allocated gen_pool, %NUMA_NO_NODE for all nodes * @name: name of a gen_pool or NULL, identifies a particular gen_pool on device |
9375db07a genalloc: add dev... |
802 803 804 805 806 807 |
* * Create a new special memory pool that can be used to manage special purpose * memory not managed by the regular kmalloc/kfree interface. The pool will be * automatically destroyed by the device management code. */ struct gen_pool *devm_gen_pool_create(struct device *dev, int min_alloc_order, |
738581735 genalloc: add nam... |
808 |
int nid, const char *name) |
9375db07a genalloc: add dev... |
809 810 |
{ struct gen_pool **ptr, *pool; |
c98c36355 genalloc: add sup... |
811 |
const char *pool_name = NULL; |
9375db07a genalloc: add dev... |
812 |
|
738581735 genalloc: add nam... |
813 814 815 |
/* Check that genpool to be created is uniquely addressed on device */ if (gen_pool_get(dev, name)) return ERR_PTR(-EINVAL); |
c98c36355 genalloc: add sup... |
816 817 818 819 820 |
if (name) { pool_name = kstrdup_const(name, GFP_KERNEL); if (!pool_name) return ERR_PTR(-ENOMEM); } |
9375db07a genalloc: add dev... |
821 |
ptr = devres_alloc(devm_gen_pool_release, sizeof(*ptr), GFP_KERNEL); |
310ee9e8f lib/genalloc.c: c... |
822 |
if (!ptr) |
c98c36355 genalloc: add sup... |
823 |
goto free_pool_name; |
9375db07a genalloc: add dev... |
824 825 |
pool = gen_pool_create(min_alloc_order, nid); |
c98c36355 genalloc: add sup... |
826 827 828 829 830 831 |
if (!pool) goto free_devres; *ptr = pool; pool->name = pool_name; devres_add(dev, ptr); |
9375db07a genalloc: add dev... |
832 833 |
return pool; |
c98c36355 genalloc: add sup... |
834 835 836 837 838 839 840 |
free_devres: devres_free(ptr); free_pool_name: kfree_const(pool_name); return ERR_PTR(-ENOMEM); |
9375db07a genalloc: add dev... |
841 |
} |
b724aa213 lib/genalloc.c: e... |
842 |
EXPORT_SYMBOL(devm_gen_pool_create); |
9375db07a genalloc: add dev... |
843 |
|
9375db07a genalloc: add dev... |
844 845 |
#ifdef CONFIG_OF /** |
abdd4a702 genalloc: rename ... |
846 |
* of_gen_pool_get - find a pool by phandle property |
9375db07a genalloc: add dev... |
847 848 849 850 851 852 853 854 |
* @np: device node * @propname: property name containing phandle(s) * @index: index into the phandle array * * Returns the pool that contains the chunk starting at the physical * address of the device tree node pointed at by the phandle property, * or NULL if not found. */ |
abdd4a702 genalloc: rename ... |
855 |
struct gen_pool *of_gen_pool_get(struct device_node *np, |
9375db07a genalloc: add dev... |
856 857 858 |
const char *propname, int index) { struct platform_device *pdev; |
c98c36355 genalloc: add sup... |
859 860 861 |
struct device_node *np_pool, *parent; const char *name = NULL; struct gen_pool *pool = NULL; |
9375db07a genalloc: add dev... |
862 863 864 865 |
np_pool = of_parse_phandle(np, propname, index); if (!np_pool) return NULL; |
c98c36355 genalloc: add sup... |
866 |
|
9375db07a genalloc: add dev... |
867 |
pdev = of_find_device_by_node(np_pool); |
c98c36355 genalloc: add sup... |
868 869 870 871 872 873 874 875 876 877 878 879 |
if (!pdev) { /* Check if named gen_pool is created by parent node device */ parent = of_get_parent(np_pool); pdev = of_find_device_by_node(parent); of_node_put(parent); of_property_read_string(np_pool, "label", &name); if (!name) name = np_pool->name; } if (pdev) pool = gen_pool_get(&pdev->dev, name); |
6f3aabd18 genalloc: fix dev... |
880 |
of_node_put(np_pool); |
c98c36355 genalloc: add sup... |
881 882 |
return pool; |
9375db07a genalloc: add dev... |
883 |
} |
abdd4a702 genalloc: rename ... |
884 |
EXPORT_SYMBOL_GPL(of_gen_pool_get); |
9375db07a genalloc: add dev... |
885 |
#endif /* CONFIG_OF */ |