Commit | Line | Data |
---|---|---|
0a835c4f | 1 | #include <linux/bitmap.h> |
8bc3bcc9 | 2 | #include <linux/export.h> |
1da177e4 | 3 | #include <linux/idr.h> |
0a835c4f | 4 | #include <linux/slab.h> |
88eca020 | 5 | #include <linux/spinlock.h> |
1da177e4 | 6 | |
7ad3d4d8 | 7 | DEFINE_PER_CPU(struct ida_bitmap *, ida_bitmap); |
88eca020 | 8 | static DEFINE_SPINLOCK(simple_ida_lock); |
1da177e4 | 9 | |
388f79fd CM |
10 | int idr_alloc_cmn(struct idr *idr, void *ptr, unsigned long *index, |
11 | unsigned long start, unsigned long end, gfp_t gfp, | |
12 | bool ext) | |
d5c7409f | 13 | { |
0a835c4f | 14 | struct radix_tree_iter iter; |
388f79fd | 15 | void __rcu **slot; |
d5c7409f | 16 | |
0a835c4f MW |
17 | if (WARN_ON_ONCE(radix_tree_is_internal_node(ptr))) |
18 | return -EINVAL; | |
d5c7409f | 19 | |
0a835c4f | 20 | radix_tree_iter_init(&iter, start); |
388f79fd CM |
21 | if (ext) |
22 | slot = idr_get_free_ext(&idr->idr_rt, &iter, gfp, end); | |
23 | else | |
24 | slot = idr_get_free(&idr->idr_rt, &iter, gfp, end); | |
0a835c4f MW |
25 | if (IS_ERR(slot)) |
26 | return PTR_ERR(slot); | |
d5c7409f | 27 | |
0a835c4f MW |
28 | radix_tree_iter_replace(&idr->idr_rt, &iter, slot, ptr); |
29 | radix_tree_iter_tag_clear(&idr->idr_rt, &iter, IDR_FREE); | |
388f79fd CM |
30 | |
31 | if (index) | |
32 | *index = iter.index; | |
33 | return 0; | |
d5c7409f | 34 | } |
388f79fd | 35 | EXPORT_SYMBOL_GPL(idr_alloc_cmn); |
d5c7409f | 36 | |
3e6628c4 JL |
37 | /** |
38 | * idr_alloc_cyclic - allocate new idr entry in a cyclical fashion | |
0a835c4f | 39 | * @idr: idr handle |
3e6628c4 JL |
40 | * @ptr: pointer to be associated with the new id |
41 | * @start: the minimum id (inclusive) | |
0a835c4f MW |
42 | * @end: the maximum id (exclusive) |
43 | * @gfp: memory allocation flags | |
9bb26bc1 | 44 | * |
0a835c4f MW |
45 | * Allocates an ID larger than the last ID allocated if one is available. |
46 | * If not, it will attempt to allocate the smallest ID that is larger or | |
47 | * equal to @start. | |
8d3b3591 | 48 | */ |
0a835c4f | 49 | int idr_alloc_cyclic(struct idr *idr, void *ptr, int start, int end, gfp_t gfp) |
1da177e4 | 50 | { |
0a835c4f | 51 | int id, curr = idr->idr_next; |
1da177e4 | 52 | |
0a835c4f MW |
53 | if (curr < start) |
54 | curr = start; | |
e8c8d1bc | 55 | |
0a835c4f MW |
56 | id = idr_alloc(idr, ptr, curr, end, gfp); |
57 | if ((id == -ENOSPC) && (curr > start)) | |
58 | id = idr_alloc(idr, ptr, start, curr, gfp); | |
1da177e4 | 59 | |
0a835c4f MW |
60 | if (id >= 0) |
61 | idr->idr_next = id + 1U; | |
1da177e4 | 62 | |
0a835c4f | 63 | return id; |
1da177e4 | 64 | } |
0a835c4f | 65 | EXPORT_SYMBOL(idr_alloc_cyclic); |
1da177e4 | 66 | |
96d7fa42 KH |
67 | /** |
68 | * idr_for_each - iterate through all stored pointers | |
0a835c4f | 69 | * @idr: idr handle |
96d7fa42 | 70 | * @fn: function to be called for each pointer |
0a835c4f | 71 | * @data: data passed to callback function |
96d7fa42 | 72 | * |
0a835c4f MW |
73 | * The callback function will be called for each entry in @idr, passing |
74 | * the id, the pointer and the data pointer passed to this function. | |
96d7fa42 | 75 | * |
0a835c4f MW |
76 | * If @fn returns anything other than %0, the iteration stops and that |
77 | * value is returned from this function. | |
96d7fa42 | 78 | * |
0a835c4f MW |
79 | * idr_for_each() can be called concurrently with idr_alloc() and |
80 | * idr_remove() if protected by RCU. Newly added entries may not be | |
81 | * seen and deleted entries may be seen, but adding and removing entries | |
82 | * will not cause other entries to be skipped, nor spurious ones to be seen. | |
96d7fa42 | 83 | */ |
0a835c4f MW |
84 | int idr_for_each(const struct idr *idr, |
85 | int (*fn)(int id, void *p, void *data), void *data) | |
96d7fa42 | 86 | { |
0a835c4f | 87 | struct radix_tree_iter iter; |
7e73eb0b | 88 | void __rcu **slot; |
96d7fa42 | 89 | |
0a835c4f MW |
90 | radix_tree_for_each_slot(slot, &idr->idr_rt, &iter, 0) { |
91 | int ret = fn(iter.index, rcu_dereference_raw(*slot), data); | |
92 | if (ret) | |
93 | return ret; | |
96d7fa42 KH |
94 | } |
95 | ||
0a835c4f | 96 | return 0; |
96d7fa42 KH |
97 | } |
98 | EXPORT_SYMBOL(idr_for_each); | |
99 | ||
38460b48 | 100 | /** |
0a835c4f MW |
101 | * idr_get_next - Find next populated entry |
102 | * @idr: idr handle | |
103 | * @nextid: Pointer to lowest possible ID to return | |
104 | * | |
105 | * Returns the next populated entry in the tree with an ID greater than | |
106 | * or equal to the value pointed to by @nextid. On exit, @nextid is updated | |
107 | * to the ID of the found value. To use in a loop, the value pointed to by | |
108 | * nextid must be incremented by the user. | |
38460b48 | 109 | */ |
0a835c4f | 110 | void *idr_get_next(struct idr *idr, int *nextid) |
38460b48 | 111 | { |
0a835c4f | 112 | struct radix_tree_iter iter; |
7e73eb0b | 113 | void __rcu **slot; |
38460b48 | 114 | |
0a835c4f MW |
115 | slot = radix_tree_iter_find(&idr->idr_rt, &iter, *nextid); |
116 | if (!slot) | |
38460b48 | 117 | return NULL; |
38460b48 | 118 | |
0a835c4f MW |
119 | *nextid = iter.index; |
120 | return rcu_dereference_raw(*slot); | |
38460b48 | 121 | } |
4d1ee80f | 122 | EXPORT_SYMBOL(idr_get_next); |
38460b48 | 123 | |
388f79fd CM |
124 | void *idr_get_next_ext(struct idr *idr, unsigned long *nextid) |
125 | { | |
126 | struct radix_tree_iter iter; | |
127 | void __rcu **slot; | |
128 | ||
129 | slot = radix_tree_iter_find(&idr->idr_rt, &iter, *nextid); | |
130 | if (!slot) | |
131 | return NULL; | |
132 | ||
133 | *nextid = iter.index; | |
134 | return rcu_dereference_raw(*slot); | |
135 | } | |
136 | EXPORT_SYMBOL(idr_get_next_ext); | |
137 | ||
5806f07c JM |
138 | /** |
139 | * idr_replace - replace pointer for given id | |
0a835c4f MW |
140 | * @idr: idr handle |
141 | * @ptr: New pointer to associate with the ID | |
142 | * @id: Lookup key | |
5806f07c | 143 | * |
0a835c4f MW |
144 | * Replace the pointer registered with an ID and return the old value. |
145 | * This function can be called under the RCU read lock concurrently with | |
146 | * idr_alloc() and idr_remove() (as long as the ID being removed is not | |
147 | * the one being replaced!). | |
5806f07c | 148 | * |
a70e43a5 | 149 | * Returns: the old value on success. %-ENOENT indicates that @id was not |
234a4624 | 150 | * found. %-EINVAL indicates that @ptr was not valid. |
5806f07c | 151 | */ |
234a4624 | 152 | void *idr_replace(struct idr *idr, void *ptr, unsigned long id) |
5806f07c | 153 | { |
0a835c4f | 154 | struct radix_tree_node *node; |
7e73eb0b | 155 | void __rcu **slot = NULL; |
0a835c4f | 156 | void *entry; |
5806f07c | 157 | |
0a835c4f | 158 | if (WARN_ON_ONCE(radix_tree_is_internal_node(ptr))) |
e8c8d1bc TH |
159 | return ERR_PTR(-EINVAL); |
160 | ||
0a835c4f MW |
161 | entry = __radix_tree_lookup(&idr->idr_rt, id, &node, &slot); |
162 | if (!slot || radix_tree_tag_get(&idr->idr_rt, id, IDR_FREE)) | |
5806f07c JM |
163 | return ERR_PTR(-ENOENT); |
164 | ||
c7df8ad2 | 165 | __radix_tree_replace(&idr->idr_rt, node, slot, ptr, NULL); |
5806f07c | 166 | |
0a835c4f | 167 | return entry; |
5806f07c | 168 | } |
234a4624 | 169 | EXPORT_SYMBOL(idr_replace); |
5806f07c | 170 | |
56083ab1 RD |
171 | /** |
172 | * DOC: IDA description | |
72dba584 | 173 | * |
0a835c4f MW |
174 | * The IDA is an ID allocator which does not provide the ability to |
175 | * associate an ID with a pointer. As such, it only needs to store one | |
176 | * bit per ID, and so is more space efficient than an IDR. To use an IDA, | |
177 | * define it using DEFINE_IDA() (or embed a &struct ida in a data structure, | |
178 | * then initialise it using ida_init()). To allocate a new ID, call | |
179 | * ida_simple_get(). To free an ID, call ida_simple_remove(). | |
180 | * | |
181 | * If you have more complex locking requirements, use a loop around | |
182 | * ida_pre_get() and ida_get_new() to allocate a new ID. Then use | |
183 | * ida_remove() to free an ID. You must make sure that ida_get_new() and | |
184 | * ida_remove() cannot be called at the same time as each other for the | |
185 | * same IDA. | |
186 | * | |
187 | * You can also use ida_get_new_above() if you need an ID to be allocated | |
188 | * above a particular number. ida_destroy() can be used to dispose of an | |
189 | * IDA without needing to free the individual IDs in it. You can use | |
190 | * ida_is_empty() to find out whether the IDA has any IDs currently allocated. | |
191 | * | |
192 | * IDs are currently limited to the range [0-INT_MAX]. If this is an awkward | |
193 | * limitation, it should be quite straightforward to raise the maximum. | |
72dba584 TH |
194 | */ |
195 | ||
d37cacc5 MW |
196 | /* |
197 | * Developer's notes: | |
198 | * | |
199 | * The IDA uses the functionality provided by the IDR & radix tree to store | |
200 | * bitmaps in each entry. The IDR_FREE tag means there is at least one bit | |
201 | * free, unlike the IDR where it means at least one entry is free. | |
202 | * | |
203 | * I considered telling the radix tree that each slot is an order-10 node | |
204 | * and storing the bit numbers in the radix tree, but the radix tree can't | |
205 | * allow a single multiorder entry at index 0, which would significantly | |
206 | * increase memory consumption for the IDA. So instead we divide the index | |
207 | * by the number of bits in the leaf bitmap before doing a radix tree lookup. | |
208 | * | |
209 | * As an optimisation, if there are only a few low bits set in any given | |
210 | * leaf, instead of allocating a 128-byte bitmap, we use the 'exceptional | |
211 | * entry' functionality of the radix tree to store BITS_PER_LONG - 2 bits | |
212 | * directly in the entry. By being really tricksy, we could store | |
213 | * BITS_PER_LONG - 1 bits, but there're diminishing returns after optimising | |
214 | * for 0-3 allocated IDs. | |
215 | * | |
216 | * We allow the radix tree 'exceptional' count to get out of date. Nothing | |
217 | * in the IDA nor the radix tree code checks it. If it becomes important | |
218 | * to maintain an accurate exceptional count, switch the rcu_assign_pointer() | |
219 | * calls to radix_tree_iter_replace() which will correct the exceptional | |
220 | * count. | |
221 | * | |
222 | * The IDA always requires a lock to alloc/free. If we add a 'test_bit' | |
223 | * equivalent, it will still need locking. Going to RCU lookup would require | |
224 | * using RCU to free bitmaps, and that's not trivial without embedding an | |
225 | * RCU head in the bitmap, which adds a 2-pointer overhead to each 128-byte | |
226 | * bitmap, which is excessive. | |
227 | */ | |
228 | ||
0a835c4f MW |
229 | #define IDA_MAX (0x80000000U / IDA_BITMAP_BITS) |
230 | ||
72dba584 TH |
231 | /** |
232 | * ida_get_new_above - allocate new ID above or equal to a start id | |
0a835c4f MW |
233 | * @ida: ida handle |
234 | * @start: id to start search at | |
235 | * @id: pointer to the allocated handle | |
72dba584 | 236 | * |
0a835c4f MW |
237 | * Allocate new ID above or equal to @start. It should be called |
238 | * with any required locks to ensure that concurrent calls to | |
239 | * ida_get_new_above() / ida_get_new() / ida_remove() are not allowed. | |
240 | * Consider using ida_simple_get() if you do not have complex locking | |
241 | * requirements. | |
72dba584 | 242 | * |
56083ab1 | 243 | * If memory is required, it will return %-EAGAIN, you should unlock |
72dba584 | 244 | * and go back to the ida_pre_get() call. If the ida is full, it will |
0a835c4f | 245 | * return %-ENOSPC. On success, it will return 0. |
a2ef9471 | 246 | * |
0a835c4f | 247 | * @id returns a value in the range @start ... %0x7fffffff. |
72dba584 | 248 | */ |
0a835c4f | 249 | int ida_get_new_above(struct ida *ida, int start, int *id) |
72dba584 | 250 | { |
0a835c4f | 251 | struct radix_tree_root *root = &ida->ida_rt; |
7e73eb0b | 252 | void __rcu **slot; |
0a835c4f | 253 | struct radix_tree_iter iter; |
72dba584 | 254 | struct ida_bitmap *bitmap; |
0a835c4f | 255 | unsigned long index; |
d37cacc5 | 256 | unsigned bit, ebit; |
0a835c4f MW |
257 | int new; |
258 | ||
259 | index = start / IDA_BITMAP_BITS; | |
260 | bit = start % IDA_BITMAP_BITS; | |
d37cacc5 | 261 | ebit = bit + RADIX_TREE_EXCEPTIONAL_SHIFT; |
0a835c4f MW |
262 | |
263 | slot = radix_tree_iter_init(&iter, index); | |
264 | for (;;) { | |
265 | if (slot) | |
266 | slot = radix_tree_next_slot(slot, &iter, | |
267 | RADIX_TREE_ITER_TAGGED); | |
268 | if (!slot) { | |
269 | slot = idr_get_free(root, &iter, GFP_NOWAIT, IDA_MAX); | |
270 | if (IS_ERR(slot)) { | |
271 | if (slot == ERR_PTR(-ENOMEM)) | |
272 | return -EAGAIN; | |
273 | return PTR_ERR(slot); | |
274 | } | |
275 | } | |
d37cacc5 | 276 | if (iter.index > index) { |
0a835c4f | 277 | bit = 0; |
d37cacc5 MW |
278 | ebit = RADIX_TREE_EXCEPTIONAL_SHIFT; |
279 | } | |
0a835c4f MW |
280 | new = iter.index * IDA_BITMAP_BITS; |
281 | bitmap = rcu_dereference_raw(*slot); | |
d37cacc5 MW |
282 | if (radix_tree_exception(bitmap)) { |
283 | unsigned long tmp = (unsigned long)bitmap; | |
284 | ebit = find_next_zero_bit(&tmp, BITS_PER_LONG, ebit); | |
285 | if (ebit < BITS_PER_LONG) { | |
286 | tmp |= 1UL << ebit; | |
287 | rcu_assign_pointer(*slot, (void *)tmp); | |
288 | *id = new + ebit - RADIX_TREE_EXCEPTIONAL_SHIFT; | |
289 | return 0; | |
290 | } | |
291 | bitmap = this_cpu_xchg(ida_bitmap, NULL); | |
292 | if (!bitmap) | |
293 | return -EAGAIN; | |
294 | memset(bitmap, 0, sizeof(*bitmap)); | |
295 | bitmap->bitmap[0] = tmp >> RADIX_TREE_EXCEPTIONAL_SHIFT; | |
296 | rcu_assign_pointer(*slot, bitmap); | |
297 | } | |
298 | ||
0a835c4f MW |
299 | if (bitmap) { |
300 | bit = find_next_zero_bit(bitmap->bitmap, | |
301 | IDA_BITMAP_BITS, bit); | |
302 | new += bit; | |
303 | if (new < 0) | |
304 | return -ENOSPC; | |
305 | if (bit == IDA_BITMAP_BITS) | |
306 | continue; | |
72dba584 | 307 | |
0a835c4f MW |
308 | __set_bit(bit, bitmap->bitmap); |
309 | if (bitmap_full(bitmap->bitmap, IDA_BITMAP_BITS)) | |
310 | radix_tree_iter_tag_clear(root, &iter, | |
311 | IDR_FREE); | |
312 | } else { | |
313 | new += bit; | |
314 | if (new < 0) | |
315 | return -ENOSPC; | |
d37cacc5 MW |
316 | if (ebit < BITS_PER_LONG) { |
317 | bitmap = (void *)((1UL << ebit) | | |
318 | RADIX_TREE_EXCEPTIONAL_ENTRY); | |
319 | radix_tree_iter_replace(root, &iter, slot, | |
320 | bitmap); | |
321 | *id = new; | |
322 | return 0; | |
323 | } | |
7ad3d4d8 | 324 | bitmap = this_cpu_xchg(ida_bitmap, NULL); |
0a835c4f MW |
325 | if (!bitmap) |
326 | return -EAGAIN; | |
0a835c4f MW |
327 | memset(bitmap, 0, sizeof(*bitmap)); |
328 | __set_bit(bit, bitmap->bitmap); | |
329 | radix_tree_iter_replace(root, &iter, slot, bitmap); | |
330 | } | |
72dba584 | 331 | |
0a835c4f MW |
332 | *id = new; |
333 | return 0; | |
72dba584 | 334 | } |
72dba584 TH |
335 | } |
336 | EXPORT_SYMBOL(ida_get_new_above); | |
337 | ||
72dba584 | 338 | /** |
0a835c4f MW |
339 | * ida_remove - Free the given ID |
340 | * @ida: ida handle | |
341 | * @id: ID to free | |
342 | * | |
343 | * This function should not be called at the same time as ida_get_new_above(). | |
72dba584 TH |
344 | */ |
345 | void ida_remove(struct ida *ida, int id) | |
346 | { | |
0a835c4f MW |
347 | unsigned long index = id / IDA_BITMAP_BITS; |
348 | unsigned offset = id % IDA_BITMAP_BITS; | |
72dba584 | 349 | struct ida_bitmap *bitmap; |
d37cacc5 | 350 | unsigned long *btmp; |
0a835c4f | 351 | struct radix_tree_iter iter; |
7e73eb0b | 352 | void __rcu **slot; |
72dba584 | 353 | |
0a835c4f MW |
354 | slot = radix_tree_iter_lookup(&ida->ida_rt, &iter, index); |
355 | if (!slot) | |
8f9f665a LJ |
356 | goto err; |
357 | ||
0a835c4f | 358 | bitmap = rcu_dereference_raw(*slot); |
d37cacc5 MW |
359 | if (radix_tree_exception(bitmap)) { |
360 | btmp = (unsigned long *)slot; | |
361 | offset += RADIX_TREE_EXCEPTIONAL_SHIFT; | |
362 | if (offset >= BITS_PER_LONG) | |
363 | goto err; | |
364 | } else { | |
365 | btmp = bitmap->bitmap; | |
366 | } | |
367 | if (!test_bit(offset, btmp)) | |
72dba584 TH |
368 | goto err; |
369 | ||
d37cacc5 | 370 | __clear_bit(offset, btmp); |
0a835c4f | 371 | radix_tree_iter_tag_set(&ida->ida_rt, &iter, IDR_FREE); |
d37cacc5 MW |
372 | if (radix_tree_exception(bitmap)) { |
373 | if (rcu_dereference_raw(*slot) == | |
374 | (void *)RADIX_TREE_EXCEPTIONAL_ENTRY) | |
375 | radix_tree_iter_delete(&ida->ida_rt, &iter, slot); | |
376 | } else if (bitmap_empty(btmp, IDA_BITMAP_BITS)) { | |
0a835c4f MW |
377 | kfree(bitmap); |
378 | radix_tree_iter_delete(&ida->ida_rt, &iter, slot); | |
72dba584 | 379 | } |
72dba584 | 380 | return; |
72dba584 | 381 | err: |
dd04b452 | 382 | WARN(1, "ida_remove called for id=%d which is not allocated.\n", id); |
72dba584 TH |
383 | } |
384 | EXPORT_SYMBOL(ida_remove); | |
385 | ||
386 | /** | |
0a835c4f MW |
387 | * ida_destroy - Free the contents of an ida |
388 | * @ida: ida handle | |
389 | * | |
390 | * Calling this function releases all resources associated with an IDA. When | |
391 | * this call returns, the IDA is empty and can be reused or freed. The caller | |
392 | * should not allow ida_remove() or ida_get_new_above() to be called at the | |
393 | * same time. | |
72dba584 TH |
394 | */ |
395 | void ida_destroy(struct ida *ida) | |
396 | { | |
0a835c4f | 397 | struct radix_tree_iter iter; |
7e73eb0b | 398 | void __rcu **slot; |
0a835c4f MW |
399 | |
400 | radix_tree_for_each_slot(slot, &ida->ida_rt, &iter, 0) { | |
401 | struct ida_bitmap *bitmap = rcu_dereference_raw(*slot); | |
d37cacc5 MW |
402 | if (!radix_tree_exception(bitmap)) |
403 | kfree(bitmap); | |
0a835c4f MW |
404 | radix_tree_iter_delete(&ida->ida_rt, &iter, slot); |
405 | } | |
72dba584 TH |
406 | } |
407 | EXPORT_SYMBOL(ida_destroy); | |
408 | ||
88eca020 RR |
409 | /** |
410 | * ida_simple_get - get a new id. | |
411 | * @ida: the (initialized) ida. | |
412 | * @start: the minimum id (inclusive, < 0x8000000) | |
413 | * @end: the maximum id (exclusive, < 0x8000000 or 0) | |
414 | * @gfp_mask: memory allocation flags | |
415 | * | |
416 | * Allocates an id in the range start <= id < end, or returns -ENOSPC. | |
417 | * On memory allocation failure, returns -ENOMEM. | |
418 | * | |
a2ef9471 DV |
419 | * Compared to ida_get_new_above() this function does its own locking, and |
420 | * should be used unless there are special requirements. | |
421 | * | |
88eca020 RR |
422 | * Use ida_simple_remove() to get rid of an id. |
423 | */ | |
424 | int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end, | |
425 | gfp_t gfp_mask) | |
426 | { | |
427 | int ret, id; | |
428 | unsigned int max; | |
46cbc1d3 | 429 | unsigned long flags; |
88eca020 RR |
430 | |
431 | BUG_ON((int)start < 0); | |
432 | BUG_ON((int)end < 0); | |
433 | ||
434 | if (end == 0) | |
435 | max = 0x80000000; | |
436 | else { | |
437 | BUG_ON(end < start); | |
438 | max = end - 1; | |
439 | } | |
440 | ||
441 | again: | |
442 | if (!ida_pre_get(ida, gfp_mask)) | |
443 | return -ENOMEM; | |
444 | ||
46cbc1d3 | 445 | spin_lock_irqsave(&simple_ida_lock, flags); |
88eca020 RR |
446 | ret = ida_get_new_above(ida, start, &id); |
447 | if (!ret) { | |
448 | if (id > max) { | |
449 | ida_remove(ida, id); | |
450 | ret = -ENOSPC; | |
451 | } else { | |
452 | ret = id; | |
453 | } | |
454 | } | |
46cbc1d3 | 455 | spin_unlock_irqrestore(&simple_ida_lock, flags); |
88eca020 RR |
456 | |
457 | if (unlikely(ret == -EAGAIN)) | |
458 | goto again; | |
459 | ||
460 | return ret; | |
461 | } | |
462 | EXPORT_SYMBOL(ida_simple_get); | |
463 | ||
464 | /** | |
465 | * ida_simple_remove - remove an allocated id. | |
466 | * @ida: the (initialized) ida. | |
467 | * @id: the id returned by ida_simple_get. | |
a2ef9471 DV |
468 | * |
469 | * Use to release an id allocated with ida_simple_get(). | |
470 | * | |
471 | * Compared to ida_remove() this function does its own locking, and should be | |
472 | * used unless there are special requirements. | |
88eca020 RR |
473 | */ |
474 | void ida_simple_remove(struct ida *ida, unsigned int id) | |
475 | { | |
46cbc1d3 TH |
476 | unsigned long flags; |
477 | ||
88eca020 | 478 | BUG_ON((int)id < 0); |
46cbc1d3 | 479 | spin_lock_irqsave(&simple_ida_lock, flags); |
88eca020 | 480 | ida_remove(ida, id); |
46cbc1d3 | 481 | spin_unlock_irqrestore(&simple_ida_lock, flags); |
88eca020 RR |
482 | } |
483 | EXPORT_SYMBOL(ida_simple_remove); |