2 #include <linux/atomic.h>
3 #include <linux/export.h>
4 #include <linux/generic-radix-tree.h>
7 #define GENRADIX_ARY (PAGE_SIZE / sizeof(struct genradix_node *))
8 #define GENRADIX_ARY_SHIFT ilog2(GENRADIX_ARY)
10 struct genradix_node {
13 struct genradix_node *children[GENRADIX_ARY];
20 static inline int genradix_depth_shift(unsigned depth)
22 return PAGE_SHIFT + GENRADIX_ARY_SHIFT * depth;
26 * Returns size (of data, in bytes) that a tree of a given depth holds:
28 static inline size_t genradix_depth_size(unsigned depth)
30 return 1UL << genradix_depth_shift(depth);
33 /* depth that's needed for a genradix that can address up to ULONG_MAX: */
34 #define GENRADIX_MAX_DEPTH \
35 DIV_ROUND_UP(BITS_PER_LONG - PAGE_SHIFT, GENRADIX_ARY_SHIFT)
37 #define GENRADIX_DEPTH_MASK \
38 ((unsigned long) (roundup_pow_of_two(GENRADIX_MAX_DEPTH + 1) - 1))
40 unsigned genradix_root_to_depth(struct genradix_root *r)
42 return (unsigned long) r & GENRADIX_DEPTH_MASK;
45 struct genradix_node *genradix_root_to_node(struct genradix_root *r)
47 return (void *) ((unsigned long) r & ~GENRADIX_DEPTH_MASK);
51 * Returns pointer to the specified byte @offset within @radix, or NULL if not
54 void *__genradix_ptr(struct __genradix *radix, size_t offset)
56 struct genradix_root *r = READ_ONCE(radix->root);
57 struct genradix_node *n = genradix_root_to_node(r);
58 unsigned level = genradix_root_to_depth(r);
60 if (ilog2(offset) >= genradix_depth_shift(level))
71 n = n->children[offset >> genradix_depth_shift(level)];
72 offset &= genradix_depth_size(level) - 1;
75 return &n->data[offset];
77 EXPORT_SYMBOL(__genradix_ptr);
80 * Returns pointer to the specified byte @offset within @radix, allocating it if
81 * necessary - newly allocated slots are always zeroed out:
83 void *__genradix_ptr_alloc(struct __genradix *radix, size_t offset,
86 struct genradix_root *v = READ_ONCE(radix->root);
87 struct genradix_node *n, *new_node = NULL;
90 /* Increase tree depth if necessary: */
92 struct genradix_root *r = v, *new_root;
94 n = genradix_root_to_node(r);
95 level = genradix_root_to_depth(r);
97 if (n && ilog2(offset) < genradix_depth_shift(level))
102 __get_free_page(gfp_mask|__GFP_ZERO);
107 new_node->children[0] = n;
108 new_root = ((struct genradix_root *)
109 ((unsigned long) new_node | (n ? level + 1 : 0)));
111 if ((v = cmpxchg_release(&radix->root, r, new_root)) == r) {
118 struct genradix_node **p =
119 &n->children[offset >> genradix_depth_shift(level)];
120 offset &= genradix_depth_size(level) - 1;
126 __get_free_page(gfp_mask|__GFP_ZERO);
131 if (!(n = cmpxchg_release(p, NULL, new_node)))
137 free_page((unsigned long) new_node);
139 return &n->data[offset];
141 EXPORT_SYMBOL(__genradix_ptr_alloc);
143 void *__genradix_iter_peek(struct genradix_iter *iter,
144 struct __genradix *radix,
145 size_t objs_per_page)
147 struct genradix_root *r;
148 struct genradix_node *n;
151 if (iter->offset == SIZE_MAX)
155 r = READ_ONCE(radix->root);
159 n = genradix_root_to_node(r);
160 level = genradix_root_to_depth(r);
162 if (ilog2(iter->offset) >= genradix_depth_shift(level))
168 i = (iter->offset >> genradix_depth_shift(level)) &
171 while (!n->children[i]) {
172 size_t objs_per_ptr = genradix_depth_size(level);
174 if (iter->offset + objs_per_ptr < iter->offset) {
175 iter->offset = SIZE_MAX;
176 iter->pos = SIZE_MAX;
181 iter->offset = round_down(iter->offset + objs_per_ptr,
183 iter->pos = (iter->offset >> PAGE_SHIFT) *
185 if (i == GENRADIX_ARY)
192 return &n->data[iter->offset & (PAGE_SIZE - 1)];
194 EXPORT_SYMBOL(__genradix_iter_peek);
196 static void genradix_free_recurse(struct genradix_node *n, unsigned level)
201 for (i = 0; i < GENRADIX_ARY; i++)
203 genradix_free_recurse(n->children[i], level - 1);
206 free_page((unsigned long) n);
209 int __genradix_prealloc(struct __genradix *radix, size_t size,
214 for (offset = 0; offset < size; offset += PAGE_SIZE)
215 if (!__genradix_ptr_alloc(radix, offset, gfp_mask))
220 EXPORT_SYMBOL(__genradix_prealloc);
222 void __genradix_free(struct __genradix *radix)
224 struct genradix_root *r = xchg(&radix->root, NULL);
226 genradix_free_recurse(genradix_root_to_node(r),
227 genradix_root_to_depth(r));
229 EXPORT_SYMBOL(__genradix_free);