| 117,7 → 117,6 |
|---|
| return(p); |
| } |
| |
| |
| static void idr_layer_rcu_free(struct rcu_head *head) |
| { |
| struct idr_layer *layer; |
| 126,14 → 125,11 |
|---|
| kfree(layer); |
| } |
| |
| |
| |
| static inline void free_layer(struct idr_layer *p) |
| { |
| kfree(p); |
| } |
| |
| |
| /* only called when idp->lock is held */ |
| static void __move_to_free_list(struct idr *idp, struct idr_layer *p) |
| { |
| 174,21 → 170,20 |
|---|
| } |
| } |
| |
| |
| |
| /** |
| * idr_pre_get - reserver resources for idr allocation |
| * idr_pre_get - reserve resources for idr allocation |
| * @idp: idr handle |
| * @gfp_mask: memory allocation flags |
| * |
| * This function should be called prior to locking and calling the |
| * idr_get_new* functions. It preallocates enough memory to satisfy |
| * the worst possible allocation. |
| * This function should be called prior to calling the idr_get_new* functions. |
| * It preallocates enough memory to satisfy the worst possible allocation. The |
| * caller should pass in GFP_KERNEL if possible. This of course requires that |
| * no spinning locks be held. |
| * |
| * If the system is REALLY out of memory this function returns 0, |
| * otherwise 1. |
| * If the system is REALLY out of memory this function returns %0, |
| * otherwise %1. |
| */ |
| int idr_pre_get(struct idr *idp, u32_t gfp_mask) |
| int idr_pre_get(struct idr *idp, gfp_t gfp_mask) |
| { |
| while (idp->id_free_cnt < IDR_FREE_MAX) { |
| struct idr_layer *new; |
| 267,7 → 262,6 |
|---|
| return id; |
| } |
| |
| |
| static int idr_get_empty_slot(struct idr *idp, int starting_id, |
| struct idr_layer **pa) |
| { |
| 352,22 → 346,25 |
|---|
| /** |
| * idr_get_new_above - allocate new idr entry above or equal to a start id |
| * @idp: idr handle |
| * @ptr: pointer you want associated with the ide |
| * @start_id: id to start search at |
| * @ptr: pointer you want associated with the id |
| * @starting_id: id to start search at |
| * @id: pointer to the allocated handle |
| * |
| * This is the allocate id function. It should be called with any |
| * required locks. |
| * |
| * If memory is required, it will return -EAGAIN, you should unlock |
| * and go back to the idr_pre_get() call. If the idr is full, it will |
| * return -ENOSPC. |
| * If allocation from IDR's private freelist fails, idr_get_new_above() will |
| * return %-EAGAIN. The caller should retry the idr_pre_get() call to refill |
| * IDR's preallocation and then retry the idr_get_new_above() call. |
| * |
| * @id returns a value in the range @starting_id ... 0x7fffffff |
| * If the idr is full idr_get_new_above() will return %-ENOSPC. |
| * |
| * @id returns a value in the range @starting_id ... %0x7fffffff |
| */ |
| int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id) |
| { |
| int rv; |
| |
| rv = idr_get_new_above_int(idp, ptr, starting_id); |
| /* |
| * This is a cheap hack until the IDR code can be fixed to |
| 385,17 → 382,16 |
|---|
| /** |
| * idr_get_new - allocate new idr entry |
| * @idp: idr handle |
| * @ptr: pointer you want associated with the ide |
| * @ptr: pointer you want associated with the id |
| * @id: pointer to the allocated handle |
| * |
| * This is the allocate id function. It should be called with any |
| * required locks. |
| * If allocation from IDR's private freelist fails, idr_get_new_above() will |
| * return %-EAGAIN. The caller should retry the idr_pre_get() call to refill |
| * IDR's preallocation and then retry the idr_get_new_above() call. |
| * |
| * If memory is required, it will return -EAGAIN, you should unlock |
| * and go back to the idr_pre_get() call. If the idr is full, it will |
| * return -ENOSPC. |
| * If the idr is full idr_get_new_above() will return %-ENOSPC. |
| * |
| * @id returns a value in the range 0 ... 0x7fffffff |
| * @id returns a value in the range %0 ... %0x7fffffff |
| */ |
| int idr_get_new(struct idr *idp, void *ptr, int *id) |
| { |
| 457,7 → 453,7 |
|---|
| } |
| |
| /** |
| * idr_remove - remove the given id and free it's slot |
| * idr_remove - remove the given id and free its slot |
| * @idp: idr handle |
| * @id: unique key |
| */ |
| 506,7 → 502,7 |
|---|
| * function will remove all id mappings and leave all idp_layers |
| * unused. |
| * |
| * A typical clean-up sequence for objects stored in an idr tree, will |
| * A typical clean-up sequence for objects stored in an idr tree will |
| * use idr_for_each() to free all objects, if necessay, then |
| * idr_remove_all() to remove all ids, and idr_destroy() to free |
| * up the cached idr_layers. |
| 514,6 → 510,7 |
|---|
| void idr_remove_all(struct idr *idp) |
| { |
| int n, id, max; |
| int bt_mask; |
| struct idr_layer *p; |
| struct idr_layer *pa[MAX_LEVEL]; |
| struct idr_layer **paa = &pa[0]; |
| 531,8 → 528,10 |
|---|
| p = p->ary[(id >> n) & IDR_MASK]; |
| } |
| |
| bt_mask = id; |
| id += 1 << n; |
| while (n < fls(id)) { |
| /* Get the highest bit that the above add changed from 0->1. */ |
| while (n < fls(id ^ bt_mask)) { |
| if (p) |
| free_layer(p); |
| n += IDR_BITS; |
| 544,7 → 543,7 |
|---|
| |
| /** |
| * idr_destroy - release all cached layers within an idr tree |
| * idp: idr handle |
| * @idp: idr handle |
| */ |
| void idr_destroy(struct idr *idp) |
| { |
| 607,7 → 606,7 |
|---|
| * not allowed. |
| * |
| * We check the return of @fn each time. If it returns anything other |
| * than 0, we break out and return that value. |
| * than %0, we break out and return that value. |
| * |
| * The caller must serialize idr_for_each() vs idr_get_new() and idr_remove(). |
| */ |
| 651,10 → 650,11 |
|---|
| /** |
| * idr_get_next - lookup next object of id to given id. |
| * @idp: idr handle |
| * @id: pointer to lookup key |
| * @nextidp: pointer to lookup key |
| * |
| * Returns pointer to registered object with id, which is next number to |
| * given id. |
| * given id. After being looked up, *@nextidp will be updated for the next |
| * iteration. |
| */ |
| |
| void *idr_get_next(struct idr *idp, int *nextidp) |
| 701,8 → 701,8 |
|---|
| * @id: lookup key |
| * |
| * Replace the pointer registered with an id and return the old value. |
| * A -ENOENT return indicates that @id was not found. |
| * A -EINVAL return indicates that @id was not within valid constraints. |
| * A %-ENOENT return indicates that @id was not found. |
| * A %-EINVAL return indicates that @id was not within valid constraints. |
| * |
| * The caller must serialize with writers. |
| */ |
| 767,7 → 767,7 |
|---|
| /* |
| * IDA - IDR based ID allocator |
| * |
| * this is id allocator without id -> pointer translation. Memory |
| * This is id allocator without id -> pointer translation. Memory |
| * usage is much lower than full blown idr because each id only |
| * occupies a bit. ida uses a custom leaf node which contains |
| * IDA_BITMAP_BITS slots. |
| 800,8 → 800,8 |
|---|
| * following function. It preallocates enough memory to satisfy the |
| * worst possible allocation. |
| * |
| * If the system is REALLY out of memory this function returns 0, |
| * otherwise 1. |
| * If the system is REALLY out of memory this function returns %0, |
| * otherwise %1. |
| */ |
| int ida_pre_get(struct ida *ida, gfp_t gfp_mask) |
| { |
| 827,17 → 827,17 |
|---|
| /** |
| * ida_get_new_above - allocate new ID above or equal to a start id |
| * @ida: ida handle |
| * @staring_id: id to start search at |
| * @starting_id: id to start search at |
| * @p_id: pointer to the allocated handle |
| * |
| * Allocate new ID above or equal to @ida. It should be called with |
| * any required locks. |
| * Allocate new ID above or equal to @starting_id. It should be called |
| * with any required locks. |
| * |
| * If memory is required, it will return -EAGAIN, you should unlock |
| * If memory is required, it will return %-EAGAIN, you should unlock |
| * and go back to the ida_pre_get() call. If the ida is full, it will |
| * return -ENOSPC. |
| * return %-ENOSPC. |
| * |
| * @p_id returns a value in the range @starting_id ... 0x7fffffff. |
| * @p_id returns a value in the range @starting_id ... %0x7fffffff. |
| */ |
| int ida_get_new_above(struct ida *ida, int starting_id, int *p_id) |
| { |
| 919,11 → 919,11 |
|---|
| * |
| * Allocate new ID. It should be called with any required locks. |
| * |
| * If memory is required, it will return -EAGAIN, you should unlock |
| * If memory is required, it will return %-EAGAIN, you should unlock |
| * and go back to the idr_pre_get() call. If the idr is full, it will |
| * return -ENOSPC. |
| * return %-ENOSPC. |
| * |
| * @id returns a value in the range 0 ... 0x7fffffff. |
| * @p_id returns a value in the range %0 ... %0x7fffffff. |
| */ |
| int ida_get_new(struct ida *ida, int *p_id) |
| { |
| 981,7 → 981,7 |
|---|
| |
| /** |
| * ida_destroy - release all cached layers within an ida tree |
| * ida: ida handle |
| * @ida: ida handle |
| */ |
| void ida_destroy(struct ida *ida) |
| { |