Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-only */
2 : : /*
3 : : * Basic general purpose allocator for managing special purpose
4 : : * memory, for example, memory that is not managed by the regular
5 : : * kmalloc/kfree interface. Uses for this includes on-device special
6 : : * memory, uncached memory etc.
7 : : *
8 : : * It is safe to use the allocator in NMI handlers and other special
9 : : * unblockable contexts that could otherwise deadlock on locks. This
10 : : * is implemented by using atomic operations and retries on any
11 : : * conflicts. The disadvantage is that there may be livelocks in
12 : : * extreme cases. For better scalability, one allocator can be used
13 : : * for each CPU.
14 : : *
15 : : * The lockless operation only works if there is enough memory
16 : : * available. If new memory is added to the pool a lock has to be
17 : : * still taken. So any user relying on locklessness has to ensure
18 : : * that sufficient memory is preallocated.
19 : : *
20 : : * The basic atomic operation of this allocator is cmpxchg on long.
21 : : * On architectures that don't have NMI-safe cmpxchg implementation,
22 : : * the allocator can NOT be used in NMI handler. So code uses the
23 : : * allocator in NMI handler should depend on
24 : : * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
25 : : */
26 : :
27 : :
28 : : #ifndef __GENALLOC_H__
29 : : #define __GENALLOC_H__
30 : :
31 : : #include <linux/types.h>
32 : : #include <linux/spinlock_types.h>
33 : : #include <linux/atomic.h>
34 : :
35 : : struct device;
36 : : struct device_node;
37 : : struct gen_pool;
38 : :
39 : : /**
40 : : * typedef genpool_algo_t: Allocation callback function type definition
41 : : * @map: Pointer to bitmap
42 : : * @size: The bitmap size in bits
43 : : * @start: The bitnumber to start searching at
44 : : * @nr: The number of zeroed bits we're looking for
45 : : * @data: optional additional data used by the callback
46 : : * @pool: the pool being allocated from
47 : : */
48 : : typedef unsigned long (*genpool_algo_t)(unsigned long *map,
49 : : unsigned long size,
50 : : unsigned long start,
51 : : unsigned int nr,
52 : : void *data, struct gen_pool *pool,
53 : : unsigned long start_addr);
54 : :
55 : : /*
56 : : * General purpose special memory pool descriptor.
57 : : */
58 : : struct gen_pool {
59 : : spinlock_t lock;
60 : : struct list_head chunks; /* list of chunks in this pool */
61 : : int min_alloc_order; /* minimum allocation order */
62 : :
63 : : genpool_algo_t algo; /* allocation function */
64 : : void *data;
65 : :
66 : : const char *name;
67 : : };
68 : :
69 : : /*
70 : : * General purpose special memory pool chunk descriptor.
71 : : */
72 : : struct gen_pool_chunk {
73 : : struct list_head next_chunk; /* next chunk in pool */
74 : : atomic_long_t avail;
75 : : phys_addr_t phys_addr; /* physical starting address of memory chunk */
76 : : void *owner; /* private data to retrieve at alloc time */
77 : : unsigned long start_addr; /* start address of memory chunk */
78 : : unsigned long end_addr; /* end address of memory chunk (inclusive) */
79 : : unsigned long bits[0]; /* bitmap for allocating memory chunk */
80 : : };
81 : :
82 : : /*
83 : : * gen_pool data descriptor for gen_pool_first_fit_align.
84 : : */
85 : : struct genpool_data_align {
86 : : int align; /* alignment by bytes for starting address */
87 : : };
88 : :
89 : : /*
90 : : * gen_pool data descriptor for gen_pool_fixed_alloc.
91 : : */
92 : : struct genpool_data_fixed {
93 : : unsigned long offset; /* The offset of the specific region */
94 : : };
95 : :
96 : : extern struct gen_pool *gen_pool_create(int, int);
97 : : extern phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long);
98 : : extern int gen_pool_add_owner(struct gen_pool *, unsigned long, phys_addr_t,
99 : : size_t, int, void *);
100 : :
101 : : static inline int gen_pool_add_virt(struct gen_pool *pool, unsigned long addr,
102 : : phys_addr_t phys, size_t size, int nid)
103 : : {
104 : 3 : return gen_pool_add_owner(pool, addr, phys, size, nid, NULL);
105 : : }
106 : :
107 : : /**
108 : : * gen_pool_add - add a new chunk of special memory to the pool
109 : : * @pool: pool to add new memory chunk to
110 : : * @addr: starting address of memory chunk to add to pool
111 : : * @size: size in bytes of the memory chunk to add to pool
112 : : * @nid: node id of the node the chunk structure and bitmap should be
113 : : * allocated on, or -1
114 : : *
115 : : * Add a new chunk of special memory to the specified pool.
116 : : *
117 : : * Returns 0 on success or a -ve errno on failure.
118 : : */
119 : : static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
120 : : size_t size, int nid)
121 : : {
122 : : return gen_pool_add_virt(pool, addr, -1, size, nid);
123 : : }
124 : : extern void gen_pool_destroy(struct gen_pool *);
125 : : unsigned long gen_pool_alloc_algo_owner(struct gen_pool *pool, size_t size,
126 : : genpool_algo_t algo, void *data, void **owner);
127 : :
128 : : static inline unsigned long gen_pool_alloc_owner(struct gen_pool *pool,
129 : : size_t size, void **owner)
130 : : {
131 : : return gen_pool_alloc_algo_owner(pool, size, pool->algo, pool->data,
132 : : owner);
133 : : }
134 : :
135 : : static inline unsigned long gen_pool_alloc_algo(struct gen_pool *pool,
136 : : size_t size, genpool_algo_t algo, void *data)
137 : : {
138 : 3 : return gen_pool_alloc_algo_owner(pool, size, algo, data, NULL);
139 : : }
140 : :
141 : : /**
142 : : * gen_pool_alloc - allocate special memory from the pool
143 : : * @pool: pool to allocate from
144 : : * @size: number of bytes to allocate from the pool
145 : : *
146 : : * Allocate the requested number of bytes from the specified pool.
147 : : * Uses the pool allocation function (with first-fit algorithm by default).
148 : : * Can not be used in NMI handler on architectures without
149 : : * NMI-safe cmpxchg implementation.
150 : : */
151 : : static inline unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
152 : : {
153 : 3 : return gen_pool_alloc_algo(pool, size, pool->algo, pool->data);
154 : : }
155 : :
156 : : extern void *gen_pool_dma_alloc(struct gen_pool *pool, size_t size,
157 : : dma_addr_t *dma);
158 : : extern void *gen_pool_dma_alloc_algo(struct gen_pool *pool, size_t size,
159 : : dma_addr_t *dma, genpool_algo_t algo, void *data);
160 : : extern void *gen_pool_dma_alloc_align(struct gen_pool *pool, size_t size,
161 : : dma_addr_t *dma, int align);
162 : : extern void *gen_pool_dma_zalloc(struct gen_pool *pool, size_t size, dma_addr_t *dma);
163 : : extern void *gen_pool_dma_zalloc_algo(struct gen_pool *pool, size_t size,
164 : : dma_addr_t *dma, genpool_algo_t algo, void *data);
165 : : extern void *gen_pool_dma_zalloc_align(struct gen_pool *pool, size_t size,
166 : : dma_addr_t *dma, int align);
167 : : extern void gen_pool_free_owner(struct gen_pool *pool, unsigned long addr,
168 : : size_t size, void **owner);
169 : : static inline void gen_pool_free(struct gen_pool *pool, unsigned long addr,
170 : : size_t size)
171 : : {
172 : 3 : gen_pool_free_owner(pool, addr, size, NULL);
173 : : }
174 : :
175 : : extern void gen_pool_for_each_chunk(struct gen_pool *,
176 : : void (*)(struct gen_pool *, struct gen_pool_chunk *, void *), void *);
177 : : extern size_t gen_pool_avail(struct gen_pool *);
178 : : extern size_t gen_pool_size(struct gen_pool *);
179 : :
180 : : extern void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo,
181 : : void *data);
182 : :
183 : : extern unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size,
184 : : unsigned long start, unsigned int nr, void *data,
185 : : struct gen_pool *pool, unsigned long start_addr);
186 : :
187 : : extern unsigned long gen_pool_fixed_alloc(unsigned long *map,
188 : : unsigned long size, unsigned long start, unsigned int nr,
189 : : void *data, struct gen_pool *pool, unsigned long start_addr);
190 : :
191 : : extern unsigned long gen_pool_first_fit_align(unsigned long *map,
192 : : unsigned long size, unsigned long start, unsigned int nr,
193 : : void *data, struct gen_pool *pool, unsigned long start_addr);
194 : :
195 : :
196 : : extern unsigned long gen_pool_first_fit_order_align(unsigned long *map,
197 : : unsigned long size, unsigned long start, unsigned int nr,
198 : : void *data, struct gen_pool *pool, unsigned long start_addr);
199 : :
200 : : extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
201 : : unsigned long start, unsigned int nr, void *data,
202 : : struct gen_pool *pool, unsigned long start_addr);
203 : :
204 : :
205 : : extern struct gen_pool *devm_gen_pool_create(struct device *dev,
206 : : int min_alloc_order, int nid, const char *name);
207 : : extern struct gen_pool *gen_pool_get(struct device *dev, const char *name);
208 : :
209 : : bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start,
210 : : size_t size);
211 : :
212 : : #ifdef CONFIG_OF
213 : : extern struct gen_pool *of_gen_pool_get(struct device_node *np,
214 : : const char *propname, int index);
215 : : #else
216 : : static inline struct gen_pool *of_gen_pool_get(struct device_node *np,
217 : : const char *propname, int index)
218 : : {
219 : : return NULL;
220 : : }
221 : : #endif
222 : : #endif /* __GENALLOC_H__ */
|
