2 #include <linux/atomic.h>
3 #include <linux/export.h>
4 #include <linux/generic-radix-tree.h>
6 #include <linux/kmemleak.h>
8 #define GENRADIX_ARY (GENRADIX_NODE_SIZE / sizeof(struct genradix_node *))
9 #define GENRADIX_ARY_SHIFT ilog2(GENRADIX_ARY)
11 struct genradix_node {
14 struct genradix_node *children[GENRADIX_ARY];
17 u8 data[GENRADIX_NODE_SIZE];
21 static inline int genradix_depth_shift(unsigned depth)
23 return GENRADIX_NODE_SHIFT + GENRADIX_ARY_SHIFT * depth;
27 * Returns size (of data, in bytes) that a tree of a given depth holds:
29 static inline size_t genradix_depth_size(unsigned depth)
31 return 1UL << genradix_depth_shift(depth);
34 /* depth that's needed for a genradix that can address up to ULONG_MAX: */
35 #define GENRADIX_MAX_DEPTH \
36 DIV_ROUND_UP(BITS_PER_LONG - GENRADIX_NODE_SHIFT, GENRADIX_ARY_SHIFT)
38 #define GENRADIX_DEPTH_MASK \
39 ((unsigned long) (roundup_pow_of_two(GENRADIX_MAX_DEPTH + 1) - 1))
41 static inline unsigned genradix_root_to_depth(struct genradix_root *r)
43 return (unsigned long) r & GENRADIX_DEPTH_MASK;
46 static inline struct genradix_node *genradix_root_to_node(struct genradix_root *r)
48 return (void *) ((unsigned long) r & ~GENRADIX_DEPTH_MASK);
52 * Returns pointer to the specified byte @offset within @radix, or NULL if not
55 void *__genradix_ptr(struct __genradix *radix, size_t offset)
57 struct genradix_root *r = READ_ONCE(radix->root);
58 struct genradix_node *n = genradix_root_to_node(r);
59 unsigned level = genradix_root_to_depth(r);
61 if (ilog2(offset) >= genradix_depth_shift(level))
72 n = n->children[offset >> genradix_depth_shift(level)];
73 offset &= genradix_depth_size(level) - 1;
76 return &n->data[offset];
78 EXPORT_SYMBOL(__genradix_ptr);
80 static inline struct genradix_node *genradix_alloc_node(gfp_t gfp_mask)
82 return kzalloc(GENRADIX_NODE_SIZE, gfp_mask);
85 static inline void genradix_free_node(struct genradix_node *node)
91 * Returns pointer to the specified byte @offset within @radix, allocating it if
92 * necessary - newly allocated slots are always zeroed out:
94 void *__genradix_ptr_alloc(struct __genradix *radix, size_t offset,
97 struct genradix_root *v = READ_ONCE(radix->root);
98 struct genradix_node *n, *new_node = NULL;
101 /* Increase tree depth if necessary: */
103 struct genradix_root *r = v, *new_root;
105 n = genradix_root_to_node(r);
106 level = genradix_root_to_depth(r);
108 if (n && ilog2(offset) < genradix_depth_shift(level))
112 new_node = genradix_alloc_node(gfp_mask);
117 new_node->children[0] = n;
118 new_root = ((struct genradix_root *)
119 ((unsigned long) new_node | (n ? level + 1 : 0)));
121 if ((v = cmpxchg_release(&radix->root, r, new_root)) == r) {
128 struct genradix_node **p =
129 &n->children[offset >> genradix_depth_shift(level)];
130 offset &= genradix_depth_size(level) - 1;
135 new_node = genradix_alloc_node(gfp_mask);
140 if (!(n = cmpxchg_release(p, NULL, new_node)))
146 genradix_free_node(new_node);
148 return &n->data[offset];
150 EXPORT_SYMBOL(__genradix_ptr_alloc);
152 void *__genradix_iter_peek(struct genradix_iter *iter,
153 struct __genradix *radix,
154 size_t objs_per_page)
156 struct genradix_root *r;
157 struct genradix_node *n;
160 if (iter->offset == SIZE_MAX)
164 r = READ_ONCE(radix->root);
168 n = genradix_root_to_node(r);
169 level = genradix_root_to_depth(r);
171 if (ilog2(iter->offset) >= genradix_depth_shift(level))
177 i = (iter->offset >> genradix_depth_shift(level)) &
180 while (!n->children[i]) {
181 size_t objs_per_ptr = genradix_depth_size(level);
183 if (iter->offset + objs_per_ptr < iter->offset) {
184 iter->offset = SIZE_MAX;
185 iter->pos = SIZE_MAX;
190 iter->offset = round_down(iter->offset + objs_per_ptr,
192 iter->pos = (iter->offset >> GENRADIX_NODE_SHIFT) *
194 if (i == GENRADIX_ARY)
201 return &n->data[iter->offset & (GENRADIX_NODE_SIZE - 1)];
203 EXPORT_SYMBOL(__genradix_iter_peek);
205 void *__genradix_iter_peek_prev(struct genradix_iter *iter,
206 struct __genradix *radix,
207 size_t objs_per_page,
208 size_t obj_size_plus_page_remainder)
210 struct genradix_root *r;
211 struct genradix_node *n;
214 if (iter->offset == SIZE_MAX)
218 r = READ_ONCE(radix->root);
222 n = genradix_root_to_node(r);
223 level = genradix_root_to_depth(r);
225 if (ilog2(iter->offset) >= genradix_depth_shift(level)) {
226 iter->offset = genradix_depth_size(level);
227 iter->pos = (iter->offset >> GENRADIX_NODE_SHIFT) * objs_per_page;
229 iter->offset -= obj_size_plus_page_remainder;
236 i = (iter->offset >> genradix_depth_shift(level)) &
239 while (!n->children[i]) {
240 size_t objs_per_ptr = genradix_depth_size(level);
242 iter->offset = round_down(iter->offset, objs_per_ptr);
243 iter->pos = (iter->offset >> GENRADIX_NODE_SHIFT) * objs_per_page;
248 iter->offset -= obj_size_plus_page_remainder;
259 return &n->data[iter->offset & (GENRADIX_NODE_SIZE - 1)];
261 EXPORT_SYMBOL(__genradix_iter_peek_prev);
263 static void genradix_free_recurse(struct genradix_node *n, unsigned level)
268 for (i = 0; i < GENRADIX_ARY; i++)
270 genradix_free_recurse(n->children[i], level - 1);
273 genradix_free_node(n);
276 int __genradix_prealloc(struct __genradix *radix, size_t size,
281 for (offset = 0; offset < size; offset += GENRADIX_NODE_SIZE)
282 if (!__genradix_ptr_alloc(radix, offset, gfp_mask))
287 EXPORT_SYMBOL(__genradix_prealloc);
289 void __genradix_free(struct __genradix *radix)
291 struct genradix_root *r = xchg(&radix->root, NULL);
293 genradix_free_recurse(genradix_root_to_node(r),
294 genradix_root_to_depth(r));
296 EXPORT_SYMBOL(__genradix_free);