idr.c 18.6 KB
Newer Older
1
#include <linux/bitmap.h>
2
#include <linux/bug.h>
3
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
4
#include <linux/idr.h>
5
#include <linux/slab.h>
6
#include <linux/spinlock.h>
Linus Torvalds's avatar
Linus Torvalds committed
7

8
DEFINE_PER_CPU(struct ida_bitmap *, ida_bitmap);
9
static DEFINE_SPINLOCK(simple_ida_lock);
Linus Torvalds's avatar
Linus Torvalds committed
10

11 12 13 14 15 16 17 18 19 20
/**
 * idr_alloc_u32() - Allocate an ID.
 * @idr: IDR handle.
 * @ptr: Pointer to be associated with the new ID.
 * @nextid: Pointer to an ID.
 * @max: The maximum ID to allocate (inclusive).
 * @gfp: Memory allocation flags.
 *
 * Allocates an unused ID in the range specified by @nextid and @max.
 * Note that @max is inclusive whereas the @end parameter to idr_alloc()
21 22 23
 * is exclusive.  The new ID is assigned to @nextid before the pointer
 * is inserted into the IDR, so if @nextid points into the object pointed
 * to by @ptr, a concurrent lookup will not find an uninitialised ID.
24 25 26 27 28 29 30 31 32 33 34 35
 *
 * The caller should provide their own locking to ensure that two
 * concurrent modifications to the IDR are not possible.  Read-only
 * accesses to the IDR may be done under the RCU read lock or may
 * exclude simultaneous writers.
 *
 * Return: 0 if an ID was allocated, -ENOMEM if memory allocation failed,
 * or -ENOSPC if no free IDs could be found.  If an error occurred,
 * @nextid is unchanged.
 */
int idr_alloc_u32(struct idr *idr, void *ptr, u32 *nextid,
			unsigned long max, gfp_t gfp)
36
{
37
	struct radix_tree_iter iter;
38
	void __rcu **slot;
39 40
	unsigned int base = idr->idr_base;
	unsigned int id = *nextid;
41

42 43
	if (WARN_ON_ONCE(radix_tree_is_internal_node(ptr)))
		return -EINVAL;
44 45
	if (WARN_ON_ONCE(!(idr->idr_rt.gfp_mask & ROOT_IS_IDR)))
		idr->idr_rt.gfp_mask |= IDR_RT_MARKER;
46

47 48 49
	id = (id < base) ? 0 : id - base;
	radix_tree_iter_init(&iter, id);
	slot = idr_get_free(&idr->idr_rt, &iter, gfp, max - base);
50 51
	if (IS_ERR(slot))
		return PTR_ERR(slot);
52

53
	*nextid = iter.index + base;
54
	/* there is a memory barrier inside radix_tree_iter_replace() */
55 56
	radix_tree_iter_replace(&idr->idr_rt, &iter, slot, ptr);
	radix_tree_iter_tag_clear(&idr->idr_rt, &iter, IDR_FREE);
57 58

	return 0;
59
}
60
EXPORT_SYMBOL_GPL(idr_alloc_u32);
61

62
/**
63 64 65 66 67 68
 * idr_alloc() - Allocate an ID.
 * @idr: IDR handle.
 * @ptr: Pointer to be associated with the new ID.
 * @start: The minimum ID (inclusive).
 * @end: The maximum ID (exclusive).
 * @gfp: Memory allocation flags.
69
 *
70 71 72 73 74 75 76 77 78 79 80
 * Allocates an unused ID in the range specified by @start and @end.  If
 * @end is <= 0, it is treated as one larger than %INT_MAX.  This allows
 * callers to use @start + N as @end as long as N is within integer range.
 *
 * The caller should provide their own locking to ensure that two
 * concurrent modifications to the IDR are not possible.  Read-only
 * accesses to the IDR may be done under the RCU read lock or may
 * exclude simultaneous writers.
 *
 * Return: The newly allocated ID, -ENOMEM if memory allocation failed,
 * or -ENOSPC if no free IDs could be found.
81
 */
82
int idr_alloc(struct idr *idr, void *ptr, int start, int end, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
83
{
84 85 86 87 88 89 90 91 92
	u32 id = start;
	int ret;

	if (WARN_ON_ONCE(start < 0))
		return -EINVAL;

	ret = idr_alloc_u32(idr, ptr, &id, end > 0 ? end - 1 : INT_MAX, gfp);
	if (ret)
		return ret;
Linus Torvalds's avatar
Linus Torvalds committed
93

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
	return id;
}
EXPORT_SYMBOL_GPL(idr_alloc);

/**
 * idr_alloc_cyclic() - Allocate an ID cyclically.
 * @idr: IDR handle.
 * @ptr: Pointer to be associated with the new ID.
 * @start: The minimum ID (inclusive).
 * @end: The maximum ID (exclusive).
 * @gfp: Memory allocation flags.
 *
 * Allocates an unused ID in the range specified by @nextid and @end.  If
 * @end is <= 0, it is treated as one larger than %INT_MAX.  This allows
 * callers to use @start + N as @end as long as N is within integer range.
 * The search for an unused ID will start at the last ID allocated and will
 * wrap around to @start if no free IDs are found before reaching @end.
 *
 * The caller should provide their own locking to ensure that two
 * concurrent modifications to the IDR are not possible.  Read-only
 * accesses to the IDR may be done under the RCU read lock or may
 * exclude simultaneous writers.
 *
 * Return: The newly allocated ID, -ENOMEM if memory allocation failed,
 * or -ENOSPC if no free IDs could be found.
 */
int idr_alloc_cyclic(struct idr *idr, void *ptr, int start, int end, gfp_t gfp)
{
	u32 id = idr->idr_next;
	int err, max = end > 0 ? end - 1 : INT_MAX;
124

125 126
	if ((int)id < start)
		id = start;
Linus Torvalds's avatar
Linus Torvalds committed
127

128 129 130 131 132 133 134
	err = idr_alloc_u32(idr, ptr, &id, max, gfp);
	if ((err == -ENOSPC) && (id > start)) {
		id = start;
		err = idr_alloc_u32(idr, ptr, &id, max, gfp);
	}
	if (err)
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
135

136
	idr->idr_next = id + 1;
137
	return id;
Linus Torvalds's avatar
Linus Torvalds committed
138
}
139
EXPORT_SYMBOL(idr_alloc_cyclic);
Linus Torvalds's avatar
Linus Torvalds committed
140

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
/**
 * idr_remove() - Remove an ID from the IDR.
 * @idr: IDR handle.
 * @id: Pointer ID.
 *
 * Removes this ID from the IDR.  If the ID was not previously in the IDR,
 * this function returns %NULL.
 *
 * Since this function modifies the IDR, the caller should provide their
 * own locking to ensure that concurrent modification of the same IDR is
 * not possible.
 *
 * Return: The pointer formerly associated with this ID.
 */
void *idr_remove(struct idr *idr, unsigned long id)
{
	return radix_tree_delete_item(&idr->idr_rt, id - idr->idr_base, NULL);
}
EXPORT_SYMBOL_GPL(idr_remove);

/**
 * idr_find() - Return pointer for given ID.
 * @idr: IDR handle.
 * @id: Pointer ID.
 *
 * Looks up the pointer associated with this ID.  A %NULL pointer may
 * indicate that @id is not allocated or that the %NULL pointer was
 * associated with this ID.
 *
 * This function can be called under rcu_read_lock(), given that the leaf
 * pointers lifetimes are correctly managed.
 *
 * Return: The pointer associated with this ID.
 */
void *idr_find(const struct idr *idr, unsigned long id)
{
	return radix_tree_lookup(&idr->idr_rt, id - idr->idr_base);
}
EXPORT_SYMBOL_GPL(idr_find);

181
/**
182 183 184 185
 * idr_for_each() - Iterate through all stored pointers.
 * @idr: IDR handle.
 * @fn: Function to be called for each pointer.
 * @data: Data passed to callback function.
186
 *
187
 * The callback function will be called for each entry in @idr, passing
188
 * the ID, the entry and @data.
189
 *
190 191
 * If @fn returns anything other than %0, the iteration stops and that
 * value is returned from this function.
192
 *
193 194 195 196
 * idr_for_each() can be called concurrently with idr_alloc() and
 * idr_remove() if protected by RCU.  Newly added entries may not be
 * seen and deleted entries may be seen, but adding and removing entries
 * will not cause other entries to be skipped, nor spurious ones to be seen.
197
 */
198 199
int idr_for_each(const struct idr *idr,
		int (*fn)(int id, void *p, void *data), void *data)
200
{
201
	struct radix_tree_iter iter;
202
	void __rcu **slot;
203
	int base = idr->idr_base;
204

205
	radix_tree_for_each_slot(slot, &idr->idr_rt, &iter, 0) {
206
		int ret;
207
		unsigned long id = iter.index + base;
208

209
		if (WARN_ON_ONCE(id > INT_MAX))
210
			break;
211
		ret = fn(id, rcu_dereference_raw(*slot), data);
212 213
		if (ret)
			return ret;
214 215
	}

216
	return 0;
217 218 219
}
EXPORT_SYMBOL(idr_for_each);

220
/**
221 222 223
 * idr_get_next() - Find next populated entry.
 * @idr: IDR handle.
 * @nextid: Pointer to an ID.
224 225 226 227 228
 *
 * Returns the next populated entry in the tree with an ID greater than
 * or equal to the value pointed to by @nextid.  On exit, @nextid is updated
 * to the ID of the found value.  To use in a loop, the value pointed to by
 * nextid must be incremented by the user.
229
 */
230
void *idr_get_next(struct idr *idr, int *nextid)
231
{
232
	struct radix_tree_iter iter;
233
	void __rcu **slot;
234 235
	unsigned long base = idr->idr_base;
	unsigned long id = *nextid;
236

237 238
	id = (id < base) ? 0 : id - base;
	slot = radix_tree_iter_find(&idr->idr_rt, &iter, id);
239
	if (!slot)
240
		return NULL;
241
	id = iter.index + base;
242

243
	if (WARN_ON_ONCE(id > INT_MAX))
244 245
		return NULL;

246
	*nextid = id;
247
	return rcu_dereference_raw(*slot);
248
}
249
EXPORT_SYMBOL(idr_get_next);
250

251 252 253 254 255 256 257 258 259 260 261
/**
 * idr_get_next_ul() - Find next populated entry.
 * @idr: IDR handle.
 * @nextid: Pointer to an ID.
 *
 * Returns the next populated entry in the tree with an ID greater than
 * or equal to the value pointed to by @nextid.  On exit, @nextid is updated
 * to the ID of the found value.  To use in a loop, the value pointed to by
 * nextid must be incremented by the user.
 */
void *idr_get_next_ul(struct idr *idr, unsigned long *nextid)
262 263 264
{
	struct radix_tree_iter iter;
	void __rcu **slot;
265 266
	unsigned long base = idr->idr_base;
	unsigned long id = *nextid;
267

268 269
	id = (id < base) ? 0 : id - base;
	slot = radix_tree_iter_find(&idr->idr_rt, &iter, id);
270 271 272
	if (!slot)
		return NULL;

273
	*nextid = iter.index + base;
274 275
	return rcu_dereference_raw(*slot);
}
276
EXPORT_SYMBOL(idr_get_next_ul);
277

278
/**
279 280 281 282
 * idr_replace() - replace pointer for given ID.
 * @idr: IDR handle.
 * @ptr: New pointer to associate with the ID.
 * @id: ID to change.
283
 *
284 285 286 287
 * Replace the pointer registered with an ID and return the old value.
 * This function can be called under the RCU read lock concurrently with
 * idr_alloc() and idr_remove() (as long as the ID being removed is not
 * the one being replaced!).
288
 *
289
 * Returns: the old value on success.  %-ENOENT indicates that @id was not
290
 * found.  %-EINVAL indicates that @ptr was not valid.
291
 */
292
void *idr_replace(struct idr *idr, void *ptr, unsigned long id)
293
{
294
	struct radix_tree_node *node;
295
	void __rcu **slot = NULL;
296
	void *entry;
297

298
	if (WARN_ON_ONCE(radix_tree_is_internal_node(ptr)))
299
		return ERR_PTR(-EINVAL);
300
	id -= idr->idr_base;
301

302 303
	entry = __radix_tree_lookup(&idr->idr_rt, id, &node, &slot);
	if (!slot || radix_tree_tag_get(&idr->idr_rt, id, IDR_FREE))
304 305
		return ERR_PTR(-ENOENT);

306
	__radix_tree_replace(&idr->idr_rt, node, slot, ptr, NULL);
307

308
	return entry;
309
}
310
EXPORT_SYMBOL(idr_replace);
311

312 313
/**
 * DOC: IDA description
314
 *
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
 * The IDA is an ID allocator which does not provide the ability to
 * associate an ID with a pointer.  As such, it only needs to store one
 * bit per ID, and so is more space efficient than an IDR.  To use an IDA,
 * define it using DEFINE_IDA() (or embed a &struct ida in a data structure,
 * then initialise it using ida_init()).  To allocate a new ID, call
 * ida_simple_get().  To free an ID, call ida_simple_remove().
 *
 * If you have more complex locking requirements, use a loop around
 * ida_pre_get() and ida_get_new() to allocate a new ID.  Then use
 * ida_remove() to free an ID.  You must make sure that ida_get_new() and
 * ida_remove() cannot be called at the same time as each other for the
 * same IDA.
 *
 * You can also use ida_get_new_above() if you need an ID to be allocated
 * above a particular number.  ida_destroy() can be used to dispose of an
 * IDA without needing to free the individual IDs in it.  You can use
 * ida_is_empty() to find out whether the IDA has any IDs currently allocated.
 *
 * IDs are currently limited to the range [0-INT_MAX].  If this is an awkward
 * limitation, it should be quite straightforward to raise the maximum.
335 336
 */

337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
/*
 * Developer's notes:
 *
 * The IDA uses the functionality provided by the IDR & radix tree to store
 * bitmaps in each entry.  The IDR_FREE tag means there is at least one bit
 * free, unlike the IDR where it means at least one entry is free.
 *
 * I considered telling the radix tree that each slot is an order-10 node
 * and storing the bit numbers in the radix tree, but the radix tree can't
 * allow a single multiorder entry at index 0, which would significantly
 * increase memory consumption for the IDA.  So instead we divide the index
 * by the number of bits in the leaf bitmap before doing a radix tree lookup.
 *
 * As an optimisation, if there are only a few low bits set in any given
 * leaf, instead of allocating a 128-byte bitmap, we use the 'exceptional
 * entry' functionality of the radix tree to store BITS_PER_LONG - 2 bits
 * directly in the entry.  By being really tricksy, we could store
 * BITS_PER_LONG - 1 bits, but there're diminishing returns after optimising
 * for 0-3 allocated IDs.
 *
 * We allow the radix tree 'exceptional' count to get out of date.  Nothing
 * in the IDA nor the radix tree code checks it.  If it becomes important
 * to maintain an accurate exceptional count, switch the rcu_assign_pointer()
 * calls to radix_tree_iter_replace() which will correct the exceptional
 * count.
 *
 * The IDA always requires a lock to alloc/free.  If we add a 'test_bit'
 * equivalent, it will still need locking.  Going to RCU lookup would require
 * using RCU to free bitmaps, and that's not trivial without embedding an
 * RCU head in the bitmap, which adds a 2-pointer overhead to each 128-byte
 * bitmap, which is excessive.
 */

370
#define IDA_MAX (0x80000000U / IDA_BITMAP_BITS - 1)
371

372 373
/**
 * ida_get_new_above - allocate new ID above or equal to a start id
374 375 376
 * @ida: ida handle
 * @start: id to start search at
 * @id: pointer to the allocated handle
377
 *
378 379 380 381 382
 * Allocate new ID above or equal to @start.  It should be called
 * with any required locks to ensure that concurrent calls to
 * ida_get_new_above() / ida_get_new() / ida_remove() are not allowed.
 * Consider using ida_simple_get() if you do not have complex locking
 * requirements.
383
 *
384
 * If memory is required, it will return %-EAGAIN, you should unlock
385
 * and go back to the ida_pre_get() call.  If the ida is full, it will
386
 * return %-ENOSPC.  On success, it will return 0.
387
 *
388
 * @id returns a value in the range @start ... %0x7fffffff.
389
 */
390
int ida_get_new_above(struct ida *ida, int start, int *id)
391
{
392
	struct radix_tree_root *root = &ida->ida_rt;
393
	void __rcu **slot;
394
	struct radix_tree_iter iter;
395
	struct ida_bitmap *bitmap;
396
	unsigned long index;
397
	unsigned bit, ebit;
398 399 400 401
	int new;

	index = start / IDA_BITMAP_BITS;
	bit = start % IDA_BITMAP_BITS;
402
	ebit = bit + RADIX_TREE_EXCEPTIONAL_SHIFT;
403 404 405 406 407 408 409 410 411 412 413 414 415 416

	slot = radix_tree_iter_init(&iter, index);
	for (;;) {
		if (slot)
			slot = radix_tree_next_slot(slot, &iter,
						RADIX_TREE_ITER_TAGGED);
		if (!slot) {
			slot = idr_get_free(root, &iter, GFP_NOWAIT, IDA_MAX);
			if (IS_ERR(slot)) {
				if (slot == ERR_PTR(-ENOMEM))
					return -EAGAIN;
				return PTR_ERR(slot);
			}
		}
417
		if (iter.index > index) {
418
			bit = 0;
419 420
			ebit = RADIX_TREE_EXCEPTIONAL_SHIFT;
		}
421 422
		new = iter.index * IDA_BITMAP_BITS;
		bitmap = rcu_dereference_raw(*slot);
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
		if (radix_tree_exception(bitmap)) {
			unsigned long tmp = (unsigned long)bitmap;
			ebit = find_next_zero_bit(&tmp, BITS_PER_LONG, ebit);
			if (ebit < BITS_PER_LONG) {
				tmp |= 1UL << ebit;
				rcu_assign_pointer(*slot, (void *)tmp);
				*id = new + ebit - RADIX_TREE_EXCEPTIONAL_SHIFT;
				return 0;
			}
			bitmap = this_cpu_xchg(ida_bitmap, NULL);
			if (!bitmap)
				return -EAGAIN;
			bitmap->bitmap[0] = tmp >> RADIX_TREE_EXCEPTIONAL_SHIFT;
			rcu_assign_pointer(*slot, bitmap);
		}

439 440 441 442 443 444 445 446
		if (bitmap) {
			bit = find_next_zero_bit(bitmap->bitmap,
							IDA_BITMAP_BITS, bit);
			new += bit;
			if (new < 0)
				return -ENOSPC;
			if (bit == IDA_BITMAP_BITS)
				continue;
447

448 449 450 451 452 453 454 455
			__set_bit(bit, bitmap->bitmap);
			if (bitmap_full(bitmap->bitmap, IDA_BITMAP_BITS))
				radix_tree_iter_tag_clear(root, &iter,
								IDR_FREE);
		} else {
			new += bit;
			if (new < 0)
				return -ENOSPC;
456 457 458 459 460 461 462 463
			if (ebit < BITS_PER_LONG) {
				bitmap = (void *)((1UL << ebit) |
						RADIX_TREE_EXCEPTIONAL_ENTRY);
				radix_tree_iter_replace(root, &iter, slot,
						bitmap);
				*id = new;
				return 0;
			}
464
			bitmap = this_cpu_xchg(ida_bitmap, NULL);
465 466 467 468 469
			if (!bitmap)
				return -EAGAIN;
			__set_bit(bit, bitmap->bitmap);
			radix_tree_iter_replace(root, &iter, slot, bitmap);
		}
470

471 472
		*id = new;
		return 0;
473 474 475 476 477
	}
}
EXPORT_SYMBOL(ida_get_new_above);

/**
478 479 480 481 482
 * ida_remove - Free the given ID
 * @ida: ida handle
 * @id: ID to free
 *
 * This function should not be called at the same time as ida_get_new_above().
483 484 485
 */
void ida_remove(struct ida *ida, int id)
{
486 487
	unsigned long index = id / IDA_BITMAP_BITS;
	unsigned offset = id % IDA_BITMAP_BITS;
488
	struct ida_bitmap *bitmap;
489
	unsigned long *btmp;
490
	struct radix_tree_iter iter;
491
	void __rcu **slot;
492

493 494
	slot = radix_tree_iter_lookup(&ida->ida_rt, &iter, index);
	if (!slot)
495 496
		goto err;

497
	bitmap = rcu_dereference_raw(*slot);
498 499 500 501 502 503 504 505 506
	if (radix_tree_exception(bitmap)) {
		btmp = (unsigned long *)slot;
		offset += RADIX_TREE_EXCEPTIONAL_SHIFT;
		if (offset >= BITS_PER_LONG)
			goto err;
	} else {
		btmp = bitmap->bitmap;
	}
	if (!test_bit(offset, btmp))
507 508
		goto err;

509
	__clear_bit(offset, btmp);
510
	radix_tree_iter_tag_set(&ida->ida_rt, &iter, IDR_FREE);
511 512 513 514 515
	if (radix_tree_exception(bitmap)) {
		if (rcu_dereference_raw(*slot) ==
					(void *)RADIX_TREE_EXCEPTIONAL_ENTRY)
			radix_tree_iter_delete(&ida->ida_rt, &iter, slot);
	} else if (bitmap_empty(btmp, IDA_BITMAP_BITS)) {
516 517
		kfree(bitmap);
		radix_tree_iter_delete(&ida->ida_rt, &iter, slot);
518 519 520
	}
	return;
 err:
521
	WARN(1, "ida_remove called for id=%d which is not allocated.\n", id);
522 523 524 525
}
EXPORT_SYMBOL(ida_remove);

/**
526 527 528 529 530 531 532
 * ida_destroy - Free the contents of an ida
 * @ida: ida handle
 *
 * Calling this function releases all resources associated with an IDA.  When
 * this call returns, the IDA is empty and can be reused or freed.  The caller
 * should not allow ida_remove() or ida_get_new_above() to be called at the
 * same time.
533 534 535
 */
void ida_destroy(struct ida *ida)
{
536
	struct radix_tree_iter iter;
537
	void __rcu **slot;
538 539 540

	radix_tree_for_each_slot(slot, &ida->ida_rt, &iter, 0) {
		struct ida_bitmap *bitmap = rcu_dereference_raw(*slot);
541 542
		if (!radix_tree_exception(bitmap))
			kfree(bitmap);
543 544
		radix_tree_iter_delete(&ida->ida_rt, &iter, slot);
	}
545 546 547
}
EXPORT_SYMBOL(ida_destroy);

548 549 550 551 552 553 554 555 556 557
/**
 * ida_simple_get - get a new id.
 * @ida: the (initialized) ida.
 * @start: the minimum id (inclusive, < 0x8000000)
 * @end: the maximum id (exclusive, < 0x8000000 or 0)
 * @gfp_mask: memory allocation flags
 *
 * Allocates an id in the range start <= id < end, or returns -ENOSPC.
 * On memory allocation failure, returns -ENOMEM.
 *
558 559 560
 * Compared to ida_get_new_above() this function does its own locking, and
 * should be used unless there are special requirements.
 *
561 562 563 564 565 566 567
 * Use ida_simple_remove() to get rid of an id.
 */
int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
		   gfp_t gfp_mask)
{
	int ret, id;
	unsigned int max;
568
	unsigned long flags;
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583

	BUG_ON((int)start < 0);
	BUG_ON((int)end < 0);

	if (end == 0)
		max = 0x80000000;
	else {
		BUG_ON(end < start);
		max = end - 1;
	}

again:
	if (!ida_pre_get(ida, gfp_mask))
		return -ENOMEM;

584
	spin_lock_irqsave(&simple_ida_lock, flags);
585 586 587 588 589 590 591 592 593
	ret = ida_get_new_above(ida, start, &id);
	if (!ret) {
		if (id > max) {
			ida_remove(ida, id);
			ret = -ENOSPC;
		} else {
			ret = id;
		}
	}
594
	spin_unlock_irqrestore(&simple_ida_lock, flags);
595 596 597 598 599 600 601 602 603 604 605 606

	if (unlikely(ret == -EAGAIN))
		goto again;

	return ret;
}
EXPORT_SYMBOL(ida_simple_get);

/**
 * ida_simple_remove - remove an allocated id.
 * @ida: the (initialized) ida.
 * @id: the id returned by ida_simple_get.
607 608 609 610 611
 *
 * Use to release an id allocated with ida_simple_get().
 *
 * Compared to ida_remove() this function does its own locking, and should be
 * used unless there are special requirements.
612 613 614
 */
void ida_simple_remove(struct ida *ida, unsigned int id)
{
615 616
	unsigned long flags;

617
	BUG_ON((int)id < 0);
618
	spin_lock_irqsave(&simple_ida_lock, flags);
619
	ida_remove(ida, id);
620
	spin_unlock_irqrestore(&simple_ida_lock, flags);
621 622
}
EXPORT_SYMBOL(ida_simple_remove);