2016-12-20 22:27:56 +07:00
|
|
|
#include <linux/bitmap.h>
|
2011-11-17 09:29:17 +07:00
|
|
|
#include <linux/export.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/idr.h>
|
2016-12-20 22:27:56 +07:00
|
|
|
#include <linux/slab.h>
|
2011-08-04 06:21:06 +07:00
|
|
|
#include <linux/spinlock.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2016-12-16 23:55:56 +07:00
|
|
|
DEFINE_PER_CPU(struct ida_bitmap *, ida_bitmap);
|
2011-08-04 06:21:06 +07:00
|
|
|
static DEFINE_SPINLOCK(simple_ida_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
int idr_alloc_cmn(struct idr *idr, void *ptr, unsigned long *index,
|
|
|
|
unsigned long start, unsigned long end, gfp_t gfp,
|
|
|
|
bool ext)
|
idr: implement idr_preload[_end]() and idr_alloc()
The current idr interface is very cumbersome.
* For all allocations, two function calls - idr_pre_get() and
idr_get_new*() - should be made.
* idr_pre_get() doesn't guarantee that the following idr_get_new*()
will not fail from memory shortage. If idr_get_new*() returns
-EAGAIN, the caller is expected to retry pre_get and allocation.
* idr_get_new*() can't enforce upper limit. Upper limit can only be
enforced by allocating and then freeing if above limit.
* idr_layer buffer is unnecessarily per-idr. Each idr ends up keeping
around MAX_IDR_FREE idr_layers. The memory consumed per idr is
under two pages but it makes it difficult to make idr_layer larger.
This patch implements the following new set of allocation functions.
* idr_preload[_end]() - Similar to radix preload but doesn't fail.
The first idr_alloc() inside preload section can be treated as if it
were called with @gfp_mask used for idr_preload().
* idr_alloc() - Allocate an ID w/ lower and upper limits. Takes
@gfp_flags and can be used w/o preloading. When used inside
preloaded section, the allocation mask of preloading can be assumed.
If idr_alloc() can be called from a context which allows sufficiently
relaxed @gfp_mask, it can be used by itself. If, for example,
idr_alloc() is called inside spinlock protected region, preloading can
be used like the following.
idr_preload(GFP_KERNEL);
spin_lock(lock);
id = idr_alloc(idr, ptr, start, end, GFP_NOWAIT);
spin_unlock(lock);
idr_preload_end();
if (id < 0)
error;
which is much simpler and less error-prone than idr_pre_get and
idr_get_new*() loop.
The new interface uses per-pcu idr_layer buffer and thus the number of
idr's in the system doesn't affect the amount of memory used for
preloading.
idr_layer_alloc() is introduced to handle idr_layer allocations for
both old and new ID allocation paths. This is a bit hairy now but the
new interface is expected to replace the old and the internal
implementation eventually will become simpler.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:03:55 +07:00
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_iter iter;
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
void __rcu **slot;
|
idr: implement idr_preload[_end]() and idr_alloc()
The current idr interface is very cumbersome.
* For all allocations, two function calls - idr_pre_get() and
idr_get_new*() - should be made.
* idr_pre_get() doesn't guarantee that the following idr_get_new*()
will not fail from memory shortage. If idr_get_new*() returns
-EAGAIN, the caller is expected to retry pre_get and allocation.
* idr_get_new*() can't enforce upper limit. Upper limit can only be
enforced by allocating and then freeing if above limit.
* idr_layer buffer is unnecessarily per-idr. Each idr ends up keeping
around MAX_IDR_FREE idr_layers. The memory consumed per idr is
under two pages but it makes it difficult to make idr_layer larger.
This patch implements the following new set of allocation functions.
* idr_preload[_end]() - Similar to radix preload but doesn't fail.
The first idr_alloc() inside preload section can be treated as if it
were called with @gfp_mask used for idr_preload().
* idr_alloc() - Allocate an ID w/ lower and upper limits. Takes
@gfp_flags and can be used w/o preloading. When used inside
preloaded section, the allocation mask of preloading can be assumed.
If idr_alloc() can be called from a context which allows sufficiently
relaxed @gfp_mask, it can be used by itself. If, for example,
idr_alloc() is called inside spinlock protected region, preloading can
be used like the following.
idr_preload(GFP_KERNEL);
spin_lock(lock);
id = idr_alloc(idr, ptr, start, end, GFP_NOWAIT);
spin_unlock(lock);
idr_preload_end();
if (id < 0)
error;
which is much simpler and less error-prone than idr_pre_get and
idr_get_new*() loop.
The new interface uses per-pcu idr_layer buffer and thus the number of
idr's in the system doesn't affect the amount of memory used for
preloading.
idr_layer_alloc() is introduced to handle idr_layer allocations for
both old and new ID allocation paths. This is a bit hairy now but the
new interface is expected to replace the old and the internal
implementation eventually will become simpler.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:03:55 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
if (WARN_ON_ONCE(radix_tree_is_internal_node(ptr)))
|
|
|
|
return -EINVAL;
|
idr: implement idr_preload[_end]() and idr_alloc()
The current idr interface is very cumbersome.
* For all allocations, two function calls - idr_pre_get() and
idr_get_new*() - should be made.
* idr_pre_get() doesn't guarantee that the following idr_get_new*()
will not fail from memory shortage. If idr_get_new*() returns
-EAGAIN, the caller is expected to retry pre_get and allocation.
* idr_get_new*() can't enforce upper limit. Upper limit can only be
enforced by allocating and then freeing if above limit.
* idr_layer buffer is unnecessarily per-idr. Each idr ends up keeping
around MAX_IDR_FREE idr_layers. The memory consumed per idr is
under two pages but it makes it difficult to make idr_layer larger.
This patch implements the following new set of allocation functions.
* idr_preload[_end]() - Similar to radix preload but doesn't fail.
The first idr_alloc() inside preload section can be treated as if it
were called with @gfp_mask used for idr_preload().
* idr_alloc() - Allocate an ID w/ lower and upper limits. Takes
@gfp_flags and can be used w/o preloading. When used inside
preloaded section, the allocation mask of preloading can be assumed.
If idr_alloc() can be called from a context which allows sufficiently
relaxed @gfp_mask, it can be used by itself. If, for example,
idr_alloc() is called inside spinlock protected region, preloading can
be used like the following.
idr_preload(GFP_KERNEL);
spin_lock(lock);
id = idr_alloc(idr, ptr, start, end, GFP_NOWAIT);
spin_unlock(lock);
idr_preload_end();
if (id < 0)
error;
which is much simpler and less error-prone than idr_pre_get and
idr_get_new*() loop.
The new interface uses per-pcu idr_layer buffer and thus the number of
idr's in the system doesn't affect the amount of memory used for
preloading.
idr_layer_alloc() is introduced to handle idr_layer allocations for
both old and new ID allocation paths. This is a bit hairy now but the
new interface is expected to replace the old and the internal
implementation eventually will become simpler.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:03:55 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
radix_tree_iter_init(&iter, start);
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
if (ext)
|
|
|
|
slot = idr_get_free_ext(&idr->idr_rt, &iter, gfp, end);
|
|
|
|
else
|
|
|
|
slot = idr_get_free(&idr->idr_rt, &iter, gfp, end);
|
2016-12-20 22:27:56 +07:00
|
|
|
if (IS_ERR(slot))
|
|
|
|
return PTR_ERR(slot);
|
idr: implement idr_preload[_end]() and idr_alloc()
The current idr interface is very cumbersome.
* For all allocations, two function calls - idr_pre_get() and
idr_get_new*() - should be made.
* idr_pre_get() doesn't guarantee that the following idr_get_new*()
will not fail from memory shortage. If idr_get_new*() returns
-EAGAIN, the caller is expected to retry pre_get and allocation.
* idr_get_new*() can't enforce upper limit. Upper limit can only be
enforced by allocating and then freeing if above limit.
* idr_layer buffer is unnecessarily per-idr. Each idr ends up keeping
around MAX_IDR_FREE idr_layers. The memory consumed per idr is
under two pages but it makes it difficult to make idr_layer larger.
This patch implements the following new set of allocation functions.
* idr_preload[_end]() - Similar to radix preload but doesn't fail.
The first idr_alloc() inside preload section can be treated as if it
were called with @gfp_mask used for idr_preload().
* idr_alloc() - Allocate an ID w/ lower and upper limits. Takes
@gfp_flags and can be used w/o preloading. When used inside
preloaded section, the allocation mask of preloading can be assumed.
If idr_alloc() can be called from a context which allows sufficiently
relaxed @gfp_mask, it can be used by itself. If, for example,
idr_alloc() is called inside spinlock protected region, preloading can
be used like the following.
idr_preload(GFP_KERNEL);
spin_lock(lock);
id = idr_alloc(idr, ptr, start, end, GFP_NOWAIT);
spin_unlock(lock);
idr_preload_end();
if (id < 0)
error;
which is much simpler and less error-prone than idr_pre_get and
idr_get_new*() loop.
The new interface uses per-pcu idr_layer buffer and thus the number of
idr's in the system doesn't affect the amount of memory used for
preloading.
idr_layer_alloc() is introduced to handle idr_layer allocations for
both old and new ID allocation paths. This is a bit hairy now but the
new interface is expected to replace the old and the internal
implementation eventually will become simpler.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:03:55 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
radix_tree_iter_replace(&idr->idr_rt, &iter, slot, ptr);
|
|
|
|
radix_tree_iter_tag_clear(&idr->idr_rt, &iter, IDR_FREE);
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
|
|
|
|
if (index)
|
|
|
|
*index = iter.index;
|
|
|
|
return 0;
|
idr: implement idr_preload[_end]() and idr_alloc()
The current idr interface is very cumbersome.
* For all allocations, two function calls - idr_pre_get() and
idr_get_new*() - should be made.
* idr_pre_get() doesn't guarantee that the following idr_get_new*()
will not fail from memory shortage. If idr_get_new*() returns
-EAGAIN, the caller is expected to retry pre_get and allocation.
* idr_get_new*() can't enforce upper limit. Upper limit can only be
enforced by allocating and then freeing if above limit.
* idr_layer buffer is unnecessarily per-idr. Each idr ends up keeping
around MAX_IDR_FREE idr_layers. The memory consumed per idr is
under two pages but it makes it difficult to make idr_layer larger.
This patch implements the following new set of allocation functions.
* idr_preload[_end]() - Similar to radix preload but doesn't fail.
The first idr_alloc() inside preload section can be treated as if it
were called with @gfp_mask used for idr_preload().
* idr_alloc() - Allocate an ID w/ lower and upper limits. Takes
@gfp_flags and can be used w/o preloading. When used inside
preloaded section, the allocation mask of preloading can be assumed.
If idr_alloc() can be called from a context which allows sufficiently
relaxed @gfp_mask, it can be used by itself. If, for example,
idr_alloc() is called inside spinlock protected region, preloading can
be used like the following.
idr_preload(GFP_KERNEL);
spin_lock(lock);
id = idr_alloc(idr, ptr, start, end, GFP_NOWAIT);
spin_unlock(lock);
idr_preload_end();
if (id < 0)
error;
which is much simpler and less error-prone than idr_pre_get and
idr_get_new*() loop.
The new interface uses per-pcu idr_layer buffer and thus the number of
idr's in the system doesn't affect the amount of memory used for
preloading.
idr_layer_alloc() is introduced to handle idr_layer allocations for
both old and new ID allocation paths. This is a bit hairy now but the
new interface is expected to replace the old and the internal
implementation eventually will become simpler.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:03:55 +07:00
|
|
|
}
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
EXPORT_SYMBOL_GPL(idr_alloc_cmn);
|
idr: implement idr_preload[_end]() and idr_alloc()
The current idr interface is very cumbersome.
* For all allocations, two function calls - idr_pre_get() and
idr_get_new*() - should be made.
* idr_pre_get() doesn't guarantee that the following idr_get_new*()
will not fail from memory shortage. If idr_get_new*() returns
-EAGAIN, the caller is expected to retry pre_get and allocation.
* idr_get_new*() can't enforce upper limit. Upper limit can only be
enforced by allocating and then freeing if above limit.
* idr_layer buffer is unnecessarily per-idr. Each idr ends up keeping
around MAX_IDR_FREE idr_layers. The memory consumed per idr is
under two pages but it makes it difficult to make idr_layer larger.
This patch implements the following new set of allocation functions.
* idr_preload[_end]() - Similar to radix preload but doesn't fail.
The first idr_alloc() inside preload section can be treated as if it
were called with @gfp_mask used for idr_preload().
* idr_alloc() - Allocate an ID w/ lower and upper limits. Takes
@gfp_flags and can be used w/o preloading. When used inside
preloaded section, the allocation mask of preloading can be assumed.
If idr_alloc() can be called from a context which allows sufficiently
relaxed @gfp_mask, it can be used by itself. If, for example,
idr_alloc() is called inside spinlock protected region, preloading can
be used like the following.
idr_preload(GFP_KERNEL);
spin_lock(lock);
id = idr_alloc(idr, ptr, start, end, GFP_NOWAIT);
spin_unlock(lock);
idr_preload_end();
if (id < 0)
error;
which is much simpler and less error-prone than idr_pre_get and
idr_get_new*() loop.
The new interface uses per-pcu idr_layer buffer and thus the number of
idr's in the system doesn't affect the amount of memory used for
preloading.
idr_layer_alloc() is introduced to handle idr_layer allocations for
both old and new ID allocation paths. This is a bit hairy now but the
new interface is expected to replace the old and the internal
implementation eventually will become simpler.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:03:55 +07:00
|
|
|
|
2013-04-30 06:21:16 +07:00
|
|
|
/**
|
|
|
|
* idr_alloc_cyclic - allocate new idr entry in a cyclical fashion
|
2016-12-20 22:27:56 +07:00
|
|
|
* @idr: idr handle
|
2013-04-30 06:21:16 +07:00
|
|
|
* @ptr: pointer to be associated with the new id
|
|
|
|
* @start: the minimum id (inclusive)
|
2016-12-20 22:27:56 +07:00
|
|
|
* @end: the maximum id (exclusive)
|
|
|
|
* @gfp: memory allocation flags
|
2013-02-28 08:03:35 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* Allocates an ID larger than the last ID allocated if one is available.
|
|
|
|
* If not, it will attempt to allocate the smallest ID that is larger or
|
|
|
|
* equal to @start.
|
2005-10-24 02:57:18 +07:00
|
|
|
*/
|
2016-12-20 22:27:56 +07:00
|
|
|
int idr_alloc_cyclic(struct idr *idr, void *ptr, int start, int end, gfp_t gfp)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
int id, curr = idr->idr_next;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
if (curr < start)
|
|
|
|
curr = start;
|
idr: remove MAX_IDR_MASK and move left MAX_IDR_* into idr.c
MAX_IDR_MASK is another weirdness in the idr interface. As idr covers
whole positive integer range, it's defined as 0x7fffffff or INT_MAX.
Its usage in idr_find(), idr_replace() and idr_remove() is bizarre.
They basically mask off the sign bit and operate on the rest, so if
the caller, by accident, passes in a negative number, the sign bit
will be masked off and the remaining part will be used as if that was
the input, which is worse than crashing.
The constant is visible in idr.h and there are several users in the
kernel.
* drivers/i2c/i2c-core.c:i2c_add_numbered_adapter()
Basically used to test if adap->nr is a negative number which isn't
-1 and returns -EINVAL if so. idr_alloc() already has negative
@start checking (w/ WARN_ON_ONCE), so this can go away.
* drivers/infiniband/core/cm.c:cm_alloc_id()
drivers/infiniband/hw/mlx4/cm.c:id_map_alloc()
Used to wrap cyclic @start. Can be replaced with max(next, 0).
Note that this type of cyclic allocation using idr is buggy. These
are prone to spurious -ENOSPC failure after the first wraparound.
* fs/super.c:get_anon_bdev()
The ID allocated from ida is masked off before being tested whether
it's inside valid range. ida allocated ID can never be a negative
number and the masking is unnecessary.
Update idr_*() functions to fail with -EINVAL when negative @id is
specified and update other MAX_IDR_MASK users as described above.
This leaves MAX_IDR_MASK without any user, remove it and relocate
other MAX_IDR_* constants to lib/idr.c.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Jean Delvare <khali@linux-fr.org>
Cc: Roland Dreier <roland@kernel.org>
Cc: Sean Hefty <sean.hefty@intel.com>
Cc: Hal Rosenstock <hal.rosenstock@gmail.com>
Cc: "Marciniszyn, Mike" <mike.marciniszyn@intel.com>
Cc: Jack Morgenstein <jackm@dev.mellanox.co.il>
Cc: Or Gerlitz <ogerlitz@mellanox.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Acked-by: Wolfram Sang <wolfram@the-dreams.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:05:04 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
id = idr_alloc(idr, ptr, curr, end, gfp);
|
|
|
|
if ((id == -ENOSPC) && (curr > start))
|
|
|
|
id = idr_alloc(idr, ptr, start, curr, gfp);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
if (id >= 0)
|
|
|
|
idr->idr_next = id + 1U;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
return id;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2016-12-20 22:27:56 +07:00
|
|
|
EXPORT_SYMBOL(idr_alloc_cyclic);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-16 13:37:24 +07:00
|
|
|
/**
|
|
|
|
* idr_for_each - iterate through all stored pointers
|
2016-12-20 22:27:56 +07:00
|
|
|
* @idr: idr handle
|
2007-07-16 13:37:24 +07:00
|
|
|
* @fn: function to be called for each pointer
|
2016-12-20 22:27:56 +07:00
|
|
|
* @data: data passed to callback function
|
2007-07-16 13:37:24 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* The callback function will be called for each entry in @idr, passing
|
|
|
|
* the id, the pointer and the data pointer passed to this function.
|
2007-07-16 13:37:24 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* If @fn returns anything other than %0, the iteration stops and that
|
|
|
|
* value is returned from this function.
|
2007-07-16 13:37:24 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* 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.
|
2007-07-16 13:37:24 +07:00
|
|
|
*/
|
2016-12-20 22:27:56 +07:00
|
|
|
int idr_for_each(const struct idr *idr,
|
|
|
|
int (*fn)(int id, void *p, void *data), void *data)
|
2007-07-16 13:37:24 +07:00
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_iter iter;
|
2017-02-14 04:03:55 +07:00
|
|
|
void __rcu **slot;
|
2007-07-16 13:37:24 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
radix_tree_for_each_slot(slot, &idr->idr_rt, &iter, 0) {
|
|
|
|
int ret = fn(iter.index, rcu_dereference_raw(*slot), data);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2007-07-16 13:37:24 +07:00
|
|
|
}
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
return 0;
|
2007-07-16 13:37:24 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(idr_for_each);
|
|
|
|
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
/**
|
2016-12-20 22:27:56 +07:00
|
|
|
* idr_get_next - Find next populated entry
|
|
|
|
* @idr: idr handle
|
|
|
|
* @nextid: Pointer to lowest possible ID to return
|
|
|
|
*
|
|
|
|
* 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.
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
*/
|
2016-12-20 22:27:56 +07:00
|
|
|
void *idr_get_next(struct idr *idr, int *nextid)
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_iter iter;
|
2017-02-14 04:03:55 +07:00
|
|
|
void __rcu **slot;
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
slot = radix_tree_iter_find(&idr->idr_rt, &iter, *nextid);
|
|
|
|
if (!slot)
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
return NULL;
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
*nextid = iter.index;
|
|
|
|
return rcu_dereference_raw(*slot);
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
}
|
2010-01-30 03:59:17 +07:00
|
|
|
EXPORT_SYMBOL(idr_get_next);
|
cgroup: CSS ID support
Patch for Per-CSS(Cgroup Subsys State) ID and private hierarchy code.
This patch attaches unique ID to each css and provides following.
- css_lookup(subsys, id)
returns pointer to struct cgroup_subysys_state of id.
- css_get_next(subsys, id, rootid, depth, foundid)
returns the next css under "root" by scanning
When cgroup_subsys->use_id is set, an id for css is maintained.
The cgroup framework only parepares
- css_id of root css for subsys
- id is automatically attached at creation of css.
- id is *not* freed automatically. Because the cgroup framework
don't know lifetime of cgroup_subsys_state.
free_css_id() function is provided. This must be called by subsys.
There are several reasons to develop this.
- Saving space .... For example, memcg's swap_cgroup is array of
pointers to cgroup. But it is not necessary to be very fast.
By replacing pointers(8bytes per ent) to ID (2byes per ent), we can
reduce much amount of memory usage.
- Scanning without lock.
CSS_ID provides "scan id under this ROOT" function. By this, scanning
css under root can be written without locks.
ex)
do {
rcu_read_lock();
next = cgroup_get_next(subsys, id, root, &found);
/* check sanity of next here */
css_tryget();
rcu_read_unlock();
id = found + 1
} while(...)
Characteristics:
- Each css has unique ID under subsys.
- Lifetime of ID is controlled by subsys.
- css ID contains "ID" and "Depth in hierarchy" and stack of hierarchy
- Allowed ID is 1-65535, ID 0 is UNUSED ID.
Design Choices:
- scan-by-ID v.s. scan-by-tree-walk.
As /proc's pid scan does, scan-by-ID is robust when scanning is done
by following kind of routine.
scan -> rest a while(release a lock) -> conitunue from interrupted
memcg's hierarchical reclaim does this.
- When subsys->use_id is set, # of css in the system is limited to
65535.
[bharata@linux.vnet.ibm.com: remove rcu_read_lock() from css_get_next()]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Acked-by: Paul Menage <menage@google.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-03 06:57:25 +07:00
|
|
|
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid)
|
|
|
|
{
|
|
|
|
struct radix_tree_iter iter;
|
|
|
|
void __rcu **slot;
|
|
|
|
|
|
|
|
slot = radix_tree_iter_find(&idr->idr_rt, &iter, *nextid);
|
|
|
|
if (!slot)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*nextid = iter.index;
|
|
|
|
return rcu_dereference_raw(*slot);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(idr_get_next_ext);
|
|
|
|
|
2006-06-26 14:27:19 +07:00
|
|
|
/**
|
|
|
|
* idr_replace - replace pointer for given id
|
2016-12-20 22:27:56 +07:00
|
|
|
* @idr: idr handle
|
|
|
|
* @ptr: New pointer to associate with the ID
|
|
|
|
* @id: Lookup key
|
2006-06-26 14:27:19 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* 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!).
|
2006-06-26 14:27:19 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* Returns: 0 on success. %-ENOENT indicates that @id was not found.
|
|
|
|
* %-EINVAL indicates that @id or @ptr were not valid.
|
2006-06-26 14:27:19 +07:00
|
|
|
*/
|
2016-12-20 22:27:56 +07:00
|
|
|
void *idr_replace(struct idr *idr, void *ptr, int id)
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(id < 0))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
return idr_replace_ext(idr, ptr, id);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(idr_replace);
|
|
|
|
|
|
|
|
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id)
|
2006-06-26 14:27:19 +07:00
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_node *node;
|
2017-02-14 04:03:55 +07:00
|
|
|
void __rcu **slot = NULL;
|
2016-12-20 22:27:56 +07:00
|
|
|
void *entry;
|
2006-06-26 14:27:19 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
if (WARN_ON_ONCE(radix_tree_is_internal_node(ptr)))
|
idr: remove MAX_IDR_MASK and move left MAX_IDR_* into idr.c
MAX_IDR_MASK is another weirdness in the idr interface. As idr covers
whole positive integer range, it's defined as 0x7fffffff or INT_MAX.
Its usage in idr_find(), idr_replace() and idr_remove() is bizarre.
They basically mask off the sign bit and operate on the rest, so if
the caller, by accident, passes in a negative number, the sign bit
will be masked off and the remaining part will be used as if that was
the input, which is worse than crashing.
The constant is visible in idr.h and there are several users in the
kernel.
* drivers/i2c/i2c-core.c:i2c_add_numbered_adapter()
Basically used to test if adap->nr is a negative number which isn't
-1 and returns -EINVAL if so. idr_alloc() already has negative
@start checking (w/ WARN_ON_ONCE), so this can go away.
* drivers/infiniband/core/cm.c:cm_alloc_id()
drivers/infiniband/hw/mlx4/cm.c:id_map_alloc()
Used to wrap cyclic @start. Can be replaced with max(next, 0).
Note that this type of cyclic allocation using idr is buggy. These
are prone to spurious -ENOSPC failure after the first wraparound.
* fs/super.c:get_anon_bdev()
The ID allocated from ida is masked off before being tested whether
it's inside valid range. ida allocated ID can never be a negative
number and the masking is unnecessary.
Update idr_*() functions to fail with -EINVAL when negative @id is
specified and update other MAX_IDR_MASK users as described above.
This leaves MAX_IDR_MASK without any user, remove it and relocate
other MAX_IDR_* constants to lib/idr.c.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Jean Delvare <khali@linux-fr.org>
Cc: Roland Dreier <roland@kernel.org>
Cc: Sean Hefty <sean.hefty@intel.com>
Cc: Hal Rosenstock <hal.rosenstock@gmail.com>
Cc: "Marciniszyn, Mike" <mike.marciniszyn@intel.com>
Cc: Jack Morgenstein <jackm@dev.mellanox.co.il>
Cc: Or Gerlitz <ogerlitz@mellanox.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Acked-by: Wolfram Sang <wolfram@the-dreams.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 08:05:04 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
entry = __radix_tree_lookup(&idr->idr_rt, id, &node, &slot);
|
|
|
|
if (!slot || radix_tree_tag_get(&idr->idr_rt, id, IDR_FREE))
|
2006-06-26 14:27:19 +07:00
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
__radix_tree_replace(&idr->idr_rt, node, slot, ptr, NULL, NULL);
|
2006-06-26 14:27:19 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
return entry;
|
2006-06-26 14:27:19 +07:00
|
|
|
}
|
idr: Add new APIs to support unsigned long
The following new APIs are added:
int idr_alloc_ext(struct idr *idr, void *ptr, unsigned long *index,
unsigned long start, unsigned long end, gfp_t gfp);
void *idr_remove_ext(struct idr *idr, unsigned long id);
void *idr_find_ext(const struct idr *idr, unsigned long id);
void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
Signed-off-by: Chris Mi <chrism@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-30 13:31:57 +07:00
|
|
|
EXPORT_SYMBOL(idr_replace_ext);
|
2006-06-26 14:27:19 +07:00
|
|
|
|
2010-10-27 04:19:08 +07:00
|
|
|
/**
|
|
|
|
* DOC: IDA description
|
2007-06-14 01:45:13 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* 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.
|
2007-06-14 01:45:13 +07:00
|
|
|
*/
|
|
|
|
|
2016-12-17 20:18:17 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
#define IDA_MAX (0x80000000U / IDA_BITMAP_BITS)
|
|
|
|
|
2007-06-14 01:45:13 +07:00
|
|
|
/**
|
|
|
|
* ida_get_new_above - allocate new ID above or equal to a start id
|
2016-12-20 22:27:56 +07:00
|
|
|
* @ida: ida handle
|
|
|
|
* @start: id to start search at
|
|
|
|
* @id: pointer to the allocated handle
|
2007-06-14 01:45:13 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* 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.
|
2007-06-14 01:45:13 +07:00
|
|
|
*
|
2010-10-27 04:19:08 +07:00
|
|
|
* If memory is required, it will return %-EAGAIN, you should unlock
|
2007-06-14 01:45:13 +07:00
|
|
|
* and go back to the ida_pre_get() call. If the ida is full, it will
|
2016-12-20 22:27:56 +07:00
|
|
|
* return %-ENOSPC. On success, it will return 0.
|
2016-12-13 07:46:20 +07:00
|
|
|
*
|
2016-12-20 22:27:56 +07:00
|
|
|
* @id returns a value in the range @start ... %0x7fffffff.
|
2007-06-14 01:45:13 +07:00
|
|
|
*/
|
2016-12-20 22:27:56 +07:00
|
|
|
int ida_get_new_above(struct ida *ida, int start, int *id)
|
2007-06-14 01:45:13 +07:00
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_root *root = &ida->ida_rt;
|
2017-02-14 04:03:55 +07:00
|
|
|
void __rcu **slot;
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_iter iter;
|
2007-06-14 01:45:13 +07:00
|
|
|
struct ida_bitmap *bitmap;
|
2016-12-20 22:27:56 +07:00
|
|
|
unsigned long index;
|
2016-12-17 20:18:17 +07:00
|
|
|
unsigned bit, ebit;
|
2016-12-20 22:27:56 +07:00
|
|
|
int new;
|
|
|
|
|
|
|
|
index = start / IDA_BITMAP_BITS;
|
|
|
|
bit = start % IDA_BITMAP_BITS;
|
2016-12-17 20:18:17 +07:00
|
|
|
ebit = bit + RADIX_TREE_EXCEPTIONAL_SHIFT;
|
2016-12-20 22:27:56 +07:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2016-12-17 20:18:17 +07:00
|
|
|
if (iter.index > index) {
|
2016-12-20 22:27:56 +07:00
|
|
|
bit = 0;
|
2016-12-17 20:18:17 +07:00
|
|
|
ebit = RADIX_TREE_EXCEPTIONAL_SHIFT;
|
|
|
|
}
|
2016-12-20 22:27:56 +07:00
|
|
|
new = iter.index * IDA_BITMAP_BITS;
|
|
|
|
bitmap = rcu_dereference_raw(*slot);
|
2016-12-17 20:18:17 +07:00
|
|
|
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;
|
|
|
|
memset(bitmap, 0, sizeof(*bitmap));
|
|
|
|
bitmap->bitmap[0] = tmp >> RADIX_TREE_EXCEPTIONAL_SHIFT;
|
|
|
|
rcu_assign_pointer(*slot, bitmap);
|
|
|
|
}
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
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;
|
2007-06-14 01:45:13 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
__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;
|
2016-12-17 20:18:17 +07:00
|
|
|
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;
|
|
|
|
}
|
2016-12-16 23:55:56 +07:00
|
|
|
bitmap = this_cpu_xchg(ida_bitmap, NULL);
|
2016-12-20 22:27:56 +07:00
|
|
|
if (!bitmap)
|
|
|
|
return -EAGAIN;
|
|
|
|
memset(bitmap, 0, sizeof(*bitmap));
|
|
|
|
__set_bit(bit, bitmap->bitmap);
|
|
|
|
radix_tree_iter_replace(root, &iter, slot, bitmap);
|
|
|
|
}
|
2007-06-14 01:45:13 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
*id = new;
|
|
|
|
return 0;
|
2007-06-14 01:45:13 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ida_get_new_above);
|
|
|
|
|
|
|
|
/**
|
2016-12-20 22:27:56 +07:00
|
|
|
* 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().
|
2007-06-14 01:45:13 +07:00
|
|
|
*/
|
|
|
|
void ida_remove(struct ida *ida, int id)
|
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
unsigned long index = id / IDA_BITMAP_BITS;
|
|
|
|
unsigned offset = id % IDA_BITMAP_BITS;
|
2007-06-14 01:45:13 +07:00
|
|
|
struct ida_bitmap *bitmap;
|
2016-12-17 20:18:17 +07:00
|
|
|
unsigned long *btmp;
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_iter iter;
|
2017-02-14 04:03:55 +07:00
|
|
|
void __rcu **slot;
|
2007-06-14 01:45:13 +07:00
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
slot = radix_tree_iter_lookup(&ida->ida_rt, &iter, index);
|
|
|
|
if (!slot)
|
2014-06-07 04:37:11 +07:00
|
|
|
goto err;
|
|
|
|
|
2016-12-20 22:27:56 +07:00
|
|
|
bitmap = rcu_dereference_raw(*slot);
|
2016-12-17 20:18:17 +07:00
|
|
|
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))
|
2007-06-14 01:45:13 +07:00
|
|
|
goto err;
|
|
|
|
|
2016-12-17 20:18:17 +07:00
|
|
|
__clear_bit(offset, btmp);
|
2016-12-20 22:27:56 +07:00
|
|
|
radix_tree_iter_tag_set(&ida->ida_rt, &iter, IDR_FREE);
|
2016-12-17 20:18:17 +07:00
|
|
|
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)) {
|
2016-12-20 22:27:56 +07:00
|
|
|
kfree(bitmap);
|
|
|
|
radix_tree_iter_delete(&ida->ida_rt, &iter, slot);
|
2007-06-14 01:45:13 +07:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
err:
|
2013-07-04 05:08:47 +07:00
|
|
|
WARN(1, "ida_remove called for id=%d which is not allocated.\n", id);
|
2007-06-14 01:45:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ida_remove);
|
|
|
|
|
|
|
|
/**
|
2016-12-20 22:27:56 +07:00
|
|
|
* 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.
|
2007-06-14 01:45:13 +07:00
|
|
|
*/
|
|
|
|
void ida_destroy(struct ida *ida)
|
|
|
|
{
|
2016-12-20 22:27:56 +07:00
|
|
|
struct radix_tree_iter iter;
|
2017-02-14 04:03:55 +07:00
|
|
|
void __rcu **slot;
|
2016-12-20 22:27:56 +07:00
|
|
|
|
|
|
|
radix_tree_for_each_slot(slot, &ida->ida_rt, &iter, 0) {
|
|
|
|
struct ida_bitmap *bitmap = rcu_dereference_raw(*slot);
|
2016-12-17 20:18:17 +07:00
|
|
|
if (!radix_tree_exception(bitmap))
|
|
|
|
kfree(bitmap);
|
2016-12-20 22:27:56 +07:00
|
|
|
radix_tree_iter_delete(&ida->ida_rt, &iter, slot);
|
|
|
|
}
|
2007-06-14 01:45:13 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ida_destroy);
|
|
|
|
|
2011-08-04 06:21:06 +07:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2016-12-13 07:46:20 +07:00
|
|
|
* Compared to ida_get_new_above() this function does its own locking, and
|
|
|
|
* should be used unless there are special requirements.
|
|
|
|
*
|
2011-08-04 06:21:06 +07:00
|
|
|
* 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;
|
2011-11-03 03:38:46 +07:00
|
|
|
unsigned long flags;
|
2011-08-04 06:21:06 +07:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2011-11-03 03:38:46 +07:00
|
|
|
spin_lock_irqsave(&simple_ida_lock, flags);
|
2011-08-04 06:21:06 +07:00
|
|
|
ret = ida_get_new_above(ida, start, &id);
|
|
|
|
if (!ret) {
|
|
|
|
if (id > max) {
|
|
|
|
ida_remove(ida, id);
|
|
|
|
ret = -ENOSPC;
|
|
|
|
} else {
|
|
|
|
ret = id;
|
|
|
|
}
|
|
|
|
}
|
2011-11-03 03:38:46 +07:00
|
|
|
spin_unlock_irqrestore(&simple_ida_lock, flags);
|
2011-08-04 06:21:06 +07:00
|
|
|
|
|
|
|
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.
|
2016-12-13 07:46:20 +07:00
|
|
|
*
|
|
|
|
* 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.
|
2011-08-04 06:21:06 +07:00
|
|
|
*/
|
|
|
|
void ida_simple_remove(struct ida *ida, unsigned int id)
|
|
|
|
{
|
2011-11-03 03:38:46 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2011-08-04 06:21:06 +07:00
|
|
|
BUG_ON((int)id < 0);
|
2011-11-03 03:38:46 +07:00
|
|
|
spin_lock_irqsave(&simple_ida_lock, flags);
|
2011-08-04 06:21:06 +07:00
|
|
|
ida_remove(ida, id);
|
2011-11-03 03:38:46 +07:00
|
|
|
spin_unlock_irqrestore(&simple_ida_lock, flags);
|
2011-08-04 06:21:06 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ida_simple_remove);
|