btrfs-progs: send-stream: use proper type for read return value
[platform/upstream/btrfs-progs.git] / ulist.c
1 /*
2  * Copyright (C) 2011 STRATO AG
3  * written by Arne Jansen <sensille@gmx.net>
4  * Distributed under the GNU GPL license version 2.
5  */
6
7 //#include <linux/slab.h>
8 #include <stdlib.h>
9 #include "kerncompat.h"
10 #include "ulist.h"
11 #include "ctree.h"
12
13 /*
14  * ulist is a generic data structure to hold a collection of unique u64
15  * values. The only operations it supports is adding to the list and
16  * enumerating it.
17  * It is possible to store an auxiliary value along with the key.
18  *
19  * A sample usage for ulists is the enumeration of directed graphs without
20  * visiting a node twice. The pseudo-code could look like this:
21  *
22  * ulist = ulist_alloc();
23  * ulist_add(ulist, root);
24  * ULIST_ITER_INIT(&uiter);
25  *
26  * while ((elem = ulist_next(ulist, &uiter)) {
27  *      for (all child nodes n in elem)
28  *              ulist_add(ulist, n);
29  *      do something useful with the node;
30  * }
31  * ulist_free(ulist);
32  *
33  * This assumes the graph nodes are addressable by u64. This stems from the
34  * usage for tree enumeration in btrfs, where the logical addresses are
35  * 64 bit.
36  *
37  * It is also useful for tree enumeration which could be done elegantly
38  * recursively, but is not possible due to kernel stack limitations. The
39  * loop would be similar to the above.
40  */
41
42 /**
43  * ulist_init - freshly initialize a ulist
44  * @ulist:      the ulist to initialize
45  *
46  * Note: don't use this function to init an already used ulist, use
47  * ulist_reinit instead.
48  */
49 void ulist_init(struct ulist *ulist)
50 {
51         INIT_LIST_HEAD(&ulist->nodes);
52         ulist->root = RB_ROOT;
53         ulist->nnodes = 0;
54 }
55
56 /**
57  * ulist_fini - free up additionally allocated memory for the ulist
58  * @ulist:      the ulist from which to free the additional memory
59  *
60  * This is useful in cases where the base 'struct ulist' has been statically
61  * allocated.
62  */
63 static void ulist_fini(struct ulist *ulist)
64 {
65         struct ulist_node *node;
66         struct ulist_node *next;
67
68         list_for_each_entry_safe(node, next, &ulist->nodes, list) {
69                 kfree(node);
70         }
71         ulist->root = RB_ROOT;
72         INIT_LIST_HEAD(&ulist->nodes);
73 }
74
75 /**
76  * ulist_reinit - prepare a ulist for reuse
77  * @ulist:      ulist to be reused
78  *
79  * Free up all additional memory allocated for the list elements and reinit
80  * the ulist.
81  */
82 void ulist_reinit(struct ulist *ulist)
83 {
84         ulist_fini(ulist);
85         ulist_init(ulist);
86 }
87
88 /**
89  * ulist_alloc - dynamically allocate a ulist
90  * @gfp_mask:   allocation flags to for base allocation
91  *
92  * The allocated ulist will be returned in an initialized state.
93  */
94 struct ulist *ulist_alloc(gfp_t gfp_mask)
95 {
96         struct ulist *ulist = kmalloc(sizeof(*ulist), gfp_mask);
97
98         if (!ulist)
99                 return NULL;
100
101         ulist_init(ulist);
102
103         return ulist;
104 }
105
106 /**
107  * ulist_free - free dynamically allocated ulist
108  * @ulist:      ulist to free
109  *
110  * It is not necessary to call ulist_fini before.
111  */
112 void ulist_free(struct ulist *ulist)
113 {
114         if (!ulist)
115                 return;
116         ulist_fini(ulist);
117         kfree(ulist);
118 }
119
120 static struct ulist_node *ulist_rbtree_search(struct ulist *ulist, u64 val)
121 {
122         struct rb_node *n = ulist->root.rb_node;
123         struct ulist_node *u = NULL;
124
125         while (n) {
126                 u = rb_entry(n, struct ulist_node, rb_node);
127                 if (u->val < val)
128                         n = n->rb_right;
129                 else if (u->val > val)
130                         n = n->rb_left;
131                 else
132                         return u;
133         }
134         return NULL;
135 }
136
137 static int ulist_rbtree_insert(struct ulist *ulist, struct ulist_node *ins)
138 {
139         struct rb_node **p = &ulist->root.rb_node;
140         struct rb_node *parent = NULL;
141         struct ulist_node *cur = NULL;
142
143         while (*p) {
144                 parent = *p;
145                 cur = rb_entry(parent, struct ulist_node, rb_node);
146
147                 if (cur->val < ins->val)
148                         p = &(*p)->rb_right;
149                 else if (cur->val > ins->val)
150                         p = &(*p)->rb_left;
151                 else
152                         return -EEXIST;
153         }
154         rb_link_node(&ins->rb_node, parent, p);
155         rb_insert_color(&ins->rb_node, &ulist->root);
156         return 0;
157 }
158
159 /**
160  * ulist_add - add an element to the ulist
161  * @ulist:      ulist to add the element to
162  * @val:        value to add to ulist
163  * @aux:        auxiliary value to store along with val
164  * @gfp_mask:   flags to use for allocation
165  *
166  * Note: locking must be provided by the caller. In case of rwlocks write
167  *       locking is needed
168  *
169  * Add an element to a ulist. The @val will only be added if it doesn't
170  * already exist. If it is added, the auxiliary value @aux is stored along with
171  * it. In case @val already exists in the ulist, @aux is ignored, even if
172  * it differs from the already stored value.
173  *
174  * ulist_add returns 0 if @val already exists in ulist and 1 if @val has been
175  * inserted.
176  * In case of allocation failure -ENOMEM is returned and the ulist stays
177  * unaltered.
178  */
179 int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask)
180 {
181         return ulist_add_merge(ulist, val, aux, NULL, gfp_mask);
182 }
183
184 int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
185                     u64 *old_aux, gfp_t gfp_mask)
186 {
187         int ret;
188         struct ulist_node *node;
189
190         node = ulist_rbtree_search(ulist, val);
191         if (node) {
192                 if (old_aux)
193                         *old_aux = node->aux;
194                 return 0;
195         }
196         node = kmalloc(sizeof(*node), gfp_mask);
197         if (!node)
198                 return -ENOMEM;
199
200         node->val = val;
201         node->aux = aux;
202 #ifdef CONFIG_BTRFS_DEBUG
203         node->seqnum = ulist->nnodes;
204 #endif
205
206         ret = ulist_rbtree_insert(ulist, node);
207         ASSERT(!ret);
208         list_add_tail(&node->list, &ulist->nodes);
209         ulist->nnodes++;
210
211         return 1;
212 }
213
214 /**
215  * ulist_next - iterate ulist
216  * @ulist:      ulist to iterate
217  * @uiter:      iterator variable, initialized with ULIST_ITER_INIT(&iterator)
218  *
219  * Note: locking must be provided by the caller. In case of rwlocks only read
220  *       locking is needed
221  *
222  * This function is used to iterate an ulist.
223  * It returns the next element from the ulist or %NULL when the
224  * end is reached. No guarantee is made with respect to the order in which
225  * the elements are returned. They might neither be returned in order of
226  * addition nor in ascending order.
227  * It is allowed to call ulist_add during an enumeration. Newly added items
228  * are guaranteed to show up in the running enumeration.
229  */
230 struct ulist_node *ulist_next(struct ulist *ulist, struct ulist_iterator *uiter)
231 {
232         struct ulist_node *node;
233
234         if (list_empty(&ulist->nodes))
235                 return NULL;
236         if (uiter->cur_list && uiter->cur_list->next == &ulist->nodes)
237                 return NULL;
238         if (uiter->cur_list) {
239                 uiter->cur_list = uiter->cur_list->next;
240         } else {
241                 uiter->cur_list = ulist->nodes.next;
242 #ifdef CONFIG_BTRFS_DEBUG
243                 uiter->i = 0;
244 #endif
245         }
246         node = list_entry(uiter->cur_list, struct ulist_node, list);
247 #ifdef CONFIG_BTRFS_DEBUG
248         ASSERT(node->seqnum == uiter->i);
249         ASSERT(uiter->i >= 0 && uiter->i < ulist->nnodes);
250         uiter->i++;
251 #endif
252         return node;
253 }