KVM: s390: sie intercept handling
[linux-2.6.git] / lib / idr.c
1 /*
2  * 2002-10-18  written by Jim Houston jim.houston@ccur.com
3  *      Copyright (C) 2002 by Concurrent Computer Corporation
4  *      Distributed under the GNU GPL license version 2.
5  *
6  * Modified by George Anzinger to reuse immediately and to use
7  * find bit instructions.  Also removed _irq on spinlocks.
8  *
9  * Small id to pointer translation service.
10  *
11  * It uses a radix tree like structure as a sparse array indexed
12  * by the id to obtain the pointer.  The bitmap makes allocating
13  * a new id quick.
14  *
15  * You call it to allocate an id (an int) an associate with that id a
16  * pointer or what ever, we treat it as a (void *).  You can pass this
17  * id to a user for him to pass back at a later time.  You then pass
18  * that id to this code and it returns your pointer.
19
20  * You can release ids at any time. When all ids are released, most of
21  * the memory is returned (we keep IDR_FREE_MAX) in a local pool so we
22  * don't need to go to the memory "store" during an id allocate, just
23  * so you don't need to be too concerned about locking and conflicts
24  * with the slab allocator.
25  */
26
27 #ifndef TEST                        // to test in user space...
28 #include <linux/slab.h>
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #endif
32 #include <linux/err.h>
33 #include <linux/string.h>
34 #include <linux/idr.h>
35
36 static struct kmem_cache *idr_layer_cache;
37
38 static struct idr_layer *alloc_layer(struct idr *idp)
39 {
40         struct idr_layer *p;
41         unsigned long flags;
42
43         spin_lock_irqsave(&idp->lock, flags);
44         if ((p = idp->id_free)) {
45                 idp->id_free = p->ary[0];
46                 idp->id_free_cnt--;
47                 p->ary[0] = NULL;
48         }
49         spin_unlock_irqrestore(&idp->lock, flags);
50         return(p);
51 }
52
53 /* only called when idp->lock is held */
54 static void __free_layer(struct idr *idp, struct idr_layer *p)
55 {
56         p->ary[0] = idp->id_free;
57         idp->id_free = p;
58         idp->id_free_cnt++;
59 }
60
61 static void free_layer(struct idr *idp, struct idr_layer *p)
62 {
63         unsigned long flags;
64
65         /*
66          * Depends on the return element being zeroed.
67          */
68         spin_lock_irqsave(&idp->lock, flags);
69         __free_layer(idp, p);
70         spin_unlock_irqrestore(&idp->lock, flags);
71 }
72
73 static void idr_mark_full(struct idr_layer **pa, int id)
74 {
75         struct idr_layer *p = pa[0];
76         int l = 0;
77
78         __set_bit(id & IDR_MASK, &p->bitmap);
79         /*
80          * If this layer is full mark the bit in the layer above to
81          * show that this part of the radix tree is full.  This may
82          * complete the layer above and require walking up the radix
83          * tree.
84          */
85         while (p->bitmap == IDR_FULL) {
86                 if (!(p = pa[++l]))
87                         break;
88                 id = id >> IDR_BITS;
89                 __set_bit((id & IDR_MASK), &p->bitmap);
90         }
91 }
92
93 /**
94  * idr_pre_get - reserver resources for idr allocation
95  * @idp:        idr handle
96  * @gfp_mask:   memory allocation flags
97  *
98  * This function should be called prior to locking and calling the
99  * following function.  It preallocates enough memory to satisfy
100  * the worst possible allocation.
101  *
102  * If the system is REALLY out of memory this function returns 0,
103  * otherwise 1.
104  */
105 int idr_pre_get(struct idr *idp, gfp_t gfp_mask)
106 {
107         while (idp->id_free_cnt < IDR_FREE_MAX) {
108                 struct idr_layer *new;
109                 new = kmem_cache_alloc(idr_layer_cache, gfp_mask);
110                 if (new == NULL)
111                         return (0);
112                 free_layer(idp, new);
113         }
114         return 1;
115 }
116 EXPORT_SYMBOL(idr_pre_get);
117
118 static int sub_alloc(struct idr *idp, int *starting_id, struct idr_layer **pa)
119 {
120         int n, m, sh;
121         struct idr_layer *p, *new;
122         int l, id, oid;
123         unsigned long bm;
124
125         id = *starting_id;
126  restart:
127         p = idp->top;
128         l = idp->layers;
129         pa[l--] = NULL;
130         while (1) {
131                 /*
132                  * We run around this while until we reach the leaf node...
133                  */
134                 n = (id >> (IDR_BITS*l)) & IDR_MASK;
135                 bm = ~p->bitmap;
136                 m = find_next_bit(&bm, IDR_SIZE, n);
137                 if (m == IDR_SIZE) {
138                         /* no space available go back to previous layer. */
139                         l++;
140                         oid = id;
141                         id = (id | ((1 << (IDR_BITS * l)) - 1)) + 1;
142
143                         /* if already at the top layer, we need to grow */
144                         if (!(p = pa[l])) {
145                                 *starting_id = id;
146                                 return -2;
147                         }
148
149                         /* If we need to go up one layer, continue the
150                          * loop; otherwise, restart from the top.
151                          */
152                         sh = IDR_BITS * (l + 1);
153                         if (oid >> sh == id >> sh)
154                                 continue;
155                         else
156                                 goto restart;
157                 }
158                 if (m != n) {
159                         sh = IDR_BITS*l;
160                         id = ((id >> sh) ^ n ^ m) << sh;
161                 }
162                 if ((id >= MAX_ID_BIT) || (id < 0))
163                         return -3;
164                 if (l == 0)
165                         break;
166                 /*
167                  * Create the layer below if it is missing.
168                  */
169                 if (!p->ary[m]) {
170                         if (!(new = alloc_layer(idp)))
171                                 return -1;
172                         p->ary[m] = new;
173                         p->count++;
174                 }
175                 pa[l--] = p;
176                 p = p->ary[m];
177         }
178
179         pa[l] = p;
180         return id;
181 }
182
183 static int idr_get_empty_slot(struct idr *idp, int starting_id,
184                               struct idr_layer **pa)
185 {
186         struct idr_layer *p, *new;
187         int layers, v, id;
188         unsigned long flags;
189
190         id = starting_id;
191 build_up:
192         p = idp->top;
193         layers = idp->layers;
194         if (unlikely(!p)) {
195                 if (!(p = alloc_layer(idp)))
196                         return -1;
197                 layers = 1;
198         }
199         /*
200          * Add a new layer to the top of the tree if the requested
201          * id is larger than the currently allocated space.
202          */
203         while ((layers < (MAX_LEVEL - 1)) && (id >= (1 << (layers*IDR_BITS)))) {
204                 layers++;
205                 if (!p->count)
206                         continue;
207                 if (!(new = alloc_layer(idp))) {
208                         /*
209                          * The allocation failed.  If we built part of
210                          * the structure tear it down.
211                          */
212                         spin_lock_irqsave(&idp->lock, flags);
213                         for (new = p; p && p != idp->top; new = p) {
214                                 p = p->ary[0];
215                                 new->ary[0] = NULL;
216                                 new->bitmap = new->count = 0;
217                                 __free_layer(idp, new);
218                         }
219                         spin_unlock_irqrestore(&idp->lock, flags);
220                         return -1;
221                 }
222                 new->ary[0] = p;
223                 new->count = 1;
224                 if (p->bitmap == IDR_FULL)
225                         __set_bit(0, &new->bitmap);
226                 p = new;
227         }
228         idp->top = p;
229         idp->layers = layers;
230         v = sub_alloc(idp, &id, pa);
231         if (v == -2)
232                 goto build_up;
233         return(v);
234 }
235
236 static int idr_get_new_above_int(struct idr *idp, void *ptr, int starting_id)
237 {
238         struct idr_layer *pa[MAX_LEVEL];
239         int id;
240
241         id = idr_get_empty_slot(idp, starting_id, pa);
242         if (id >= 0) {
243                 /*
244                  * Successfully found an empty slot.  Install the user
245                  * pointer and mark the slot full.
246                  */
247                 pa[0]->ary[id & IDR_MASK] = (struct idr_layer *)ptr;
248                 pa[0]->count++;
249                 idr_mark_full(pa, id);
250         }
251
252         return id;
253 }
254
255 /**
256  * idr_get_new_above - allocate new idr entry above or equal to a start id
257  * @idp: idr handle
258  * @ptr: pointer you want associated with the ide
259  * @start_id: id to start search at
260  * @id: pointer to the allocated handle
261  *
262  * This is the allocate id function.  It should be called with any
263  * required locks.
264  *
265  * If memory is required, it will return -EAGAIN, you should unlock
266  * and go back to the idr_pre_get() call.  If the idr is full, it will
267  * return -ENOSPC.
268  *
269  * @id returns a value in the range 0 ... 0x7fffffff
270  */
271 int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id)
272 {
273         int rv;
274
275         rv = idr_get_new_above_int(idp, ptr, starting_id);
276         /*
277          * This is a cheap hack until the IDR code can be fixed to
278          * return proper error values.
279          */
280         if (rv < 0) {
281                 if (rv == -1)
282                         return -EAGAIN;
283                 else /* Will be -3 */
284                         return -ENOSPC;
285         }
286         *id = rv;
287         return 0;
288 }
289 EXPORT_SYMBOL(idr_get_new_above);
290
291 /**
292  * idr_get_new - allocate new idr entry
293  * @idp: idr handle
294  * @ptr: pointer you want associated with the ide
295  * @id: pointer to the allocated handle
296  *
297  * This is the allocate id function.  It should be called with any
298  * required locks.
299  *
300  * If memory is required, it will return -EAGAIN, you should unlock
301  * and go back to the idr_pre_get() call.  If the idr is full, it will
302  * return -ENOSPC.
303  *
304  * @id returns a value in the range 0 ... 0x7fffffff
305  */
306 int idr_get_new(struct idr *idp, void *ptr, int *id)
307 {
308         int rv;
309
310         rv = idr_get_new_above_int(idp, ptr, 0);
311         /*
312          * This is a cheap hack until the IDR code can be fixed to
313          * return proper error values.
314          */
315         if (rv < 0) {
316                 if (rv == -1)
317                         return -EAGAIN;
318                 else /* Will be -3 */
319                         return -ENOSPC;
320         }
321         *id = rv;
322         return 0;
323 }
324 EXPORT_SYMBOL(idr_get_new);
325
326 static void idr_remove_warning(int id)
327 {
328         printk("idr_remove called for id=%d which is not allocated.\n", id);
329         dump_stack();
330 }
331
332 static void sub_remove(struct idr *idp, int shift, int id)
333 {
334         struct idr_layer *p = idp->top;
335         struct idr_layer **pa[MAX_LEVEL];
336         struct idr_layer ***paa = &pa[0];
337         int n;
338
339         *paa = NULL;
340         *++paa = &idp->top;
341
342         while ((shift > 0) && p) {
343                 n = (id >> shift) & IDR_MASK;
344                 __clear_bit(n, &p->bitmap);
345                 *++paa = &p->ary[n];
346                 p = p->ary[n];
347                 shift -= IDR_BITS;
348         }
349         n = id & IDR_MASK;
350         if (likely(p != NULL && test_bit(n, &p->bitmap))){
351                 __clear_bit(n, &p->bitmap);
352                 p->ary[n] = NULL;
353                 while(*paa && ! --((**paa)->count)){
354                         free_layer(idp, **paa);
355                         **paa-- = NULL;
356                 }
357                 if (!*paa)
358                         idp->layers = 0;
359         } else
360                 idr_remove_warning(id);
361 }
362
363 /**
364  * idr_remove - remove the given id and free it's slot
365  * @idp: idr handle
366  * @id: unique key
367  */
368 void idr_remove(struct idr *idp, int id)
369 {
370         struct idr_layer *p;
371
372         /* Mask off upper bits we don't use for the search. */
373         id &= MAX_ID_MASK;
374
375         sub_remove(idp, (idp->layers - 1) * IDR_BITS, id);
376         if (idp->top && idp->top->count == 1 && (idp->layers > 1) &&
377             idp->top->ary[0]) {  // We can drop a layer
378
379                 p = idp->top->ary[0];
380                 idp->top->bitmap = idp->top->count = 0;
381                 free_layer(idp, idp->top);
382                 idp->top = p;
383                 --idp->layers;
384         }
385         while (idp->id_free_cnt >= IDR_FREE_MAX) {
386                 p = alloc_layer(idp);
387                 kmem_cache_free(idr_layer_cache, p);
388                 return;
389         }
390 }
391 EXPORT_SYMBOL(idr_remove);
392
393 /**
394  * idr_remove_all - remove all ids from the given idr tree
395  * @idp: idr handle
396  *
397  * idr_destroy() only frees up unused, cached idp_layers, but this
398  * function will remove all id mappings and leave all idp_layers
399  * unused.
400  *
401  * A typical clean-up sequence for objects stored in an idr tree, will
402  * use idr_for_each() to free all objects, if necessay, then
403  * idr_remove_all() to remove all ids, and idr_destroy() to free
404  * up the cached idr_layers.
405  */
406 void idr_remove_all(struct idr *idp)
407 {
408         int n, id, max;
409         struct idr_layer *p;
410         struct idr_layer *pa[MAX_LEVEL];
411         struct idr_layer **paa = &pa[0];
412
413         n = idp->layers * IDR_BITS;
414         p = idp->top;
415         max = 1 << n;
416
417         id = 0;
418         while (id < max) {
419                 while (n > IDR_BITS && p) {
420                         n -= IDR_BITS;
421                         *paa++ = p;
422                         p = p->ary[(id >> n) & IDR_MASK];
423                 }
424
425                 id += 1 << n;
426                 while (n < fls(id)) {
427                         if (p) {
428                                 memset(p, 0, sizeof *p);
429                                 free_layer(idp, p);
430                         }
431                         n += IDR_BITS;
432                         p = *--paa;
433                 }
434         }
435         idp->top = NULL;
436         idp->layers = 0;
437 }
438 EXPORT_SYMBOL(idr_remove_all);
439
440 /**
441  * idr_destroy - release all cached layers within an idr tree
442  * idp: idr handle
443  */
444 void idr_destroy(struct idr *idp)
445 {
446         while (idp->id_free_cnt) {
447                 struct idr_layer *p = alloc_layer(idp);
448                 kmem_cache_free(idr_layer_cache, p);
449         }
450 }
451 EXPORT_SYMBOL(idr_destroy);
452
453 /**
454  * idr_find - return pointer for given id
455  * @idp: idr handle
456  * @id: lookup key
457  *
458  * Return the pointer given the id it has been registered with.  A %NULL
459  * return indicates that @id is not valid or you passed %NULL in
460  * idr_get_new().
461  *
462  * The caller must serialize idr_find() vs idr_get_new() and idr_remove().
463  */
464 void *idr_find(struct idr *idp, int id)
465 {
466         int n;
467         struct idr_layer *p;
468
469         n = idp->layers * IDR_BITS;
470         p = idp->top;
471
472         /* Mask off upper bits we don't use for the search. */
473         id &= MAX_ID_MASK;
474
475         if (id >= (1 << n))
476                 return NULL;
477
478         while (n > 0 && p) {
479                 n -= IDR_BITS;
480                 p = p->ary[(id >> n) & IDR_MASK];
481         }
482         return((void *)p);
483 }
484 EXPORT_SYMBOL(idr_find);
485
486 /**
487  * idr_for_each - iterate through all stored pointers
488  * @idp: idr handle
489  * @fn: function to be called for each pointer
490  * @data: data passed back to callback function
491  *
492  * Iterate over the pointers registered with the given idr.  The
493  * callback function will be called for each pointer currently
494  * registered, passing the id, the pointer and the data pointer passed
495  * to this function.  It is not safe to modify the idr tree while in
496  * the callback, so functions such as idr_get_new and idr_remove are
497  * not allowed.
498  *
499  * We check the return of @fn each time. If it returns anything other
500  * than 0, we break out and return that value.
501  *
502  * The caller must serialize idr_for_each() vs idr_get_new() and idr_remove().
503  */
504 int idr_for_each(struct idr *idp,
505                  int (*fn)(int id, void *p, void *data), void *data)
506 {
507         int n, id, max, error = 0;
508         struct idr_layer *p;
509         struct idr_layer *pa[MAX_LEVEL];
510         struct idr_layer **paa = &pa[0];
511
512         n = idp->layers * IDR_BITS;
513         p = idp->top;
514         max = 1 << n;
515
516         id = 0;
517         while (id < max) {
518                 while (n > 0 && p) {
519                         n -= IDR_BITS;
520                         *paa++ = p;
521                         p = p->ary[(id >> n) & IDR_MASK];
522                 }
523
524                 if (p) {
525                         error = fn(id, (void *)p, data);
526                         if (error)
527                                 break;
528                 }
529
530                 id += 1 << n;
531                 while (n < fls(id)) {
532                         n += IDR_BITS;
533                         p = *--paa;
534                 }
535         }
536
537         return error;
538 }
539 EXPORT_SYMBOL(idr_for_each);
540
541 /**
542  * idr_replace - replace pointer for given id
543  * @idp: idr handle
544  * @ptr: pointer you want associated with the id
545  * @id: lookup key
546  *
547  * Replace the pointer registered with an id and return the old value.
548  * A -ENOENT return indicates that @id was not found.
549  * A -EINVAL return indicates that @id was not within valid constraints.
550  *
551  * The caller must serialize vs idr_find(), idr_get_new(), and idr_remove().
552  */
553 void *idr_replace(struct idr *idp, void *ptr, int id)
554 {
555         int n;
556         struct idr_layer *p, *old_p;
557
558         n = idp->layers * IDR_BITS;
559         p = idp->top;
560
561         id &= MAX_ID_MASK;
562
563         if (id >= (1 << n))
564                 return ERR_PTR(-EINVAL);
565
566         n -= IDR_BITS;
567         while ((n > 0) && p) {
568                 p = p->ary[(id >> n) & IDR_MASK];
569                 n -= IDR_BITS;
570         }
571
572         n = id & IDR_MASK;
573         if (unlikely(p == NULL || !test_bit(n, &p->bitmap)))
574                 return ERR_PTR(-ENOENT);
575
576         old_p = p->ary[n];
577         p->ary[n] = ptr;
578
579         return old_p;
580 }
581 EXPORT_SYMBOL(idr_replace);
582
583 static void idr_cache_ctor(struct kmem_cache *idr_layer_cache, void *idr_layer)
584 {
585         memset(idr_layer, 0, sizeof(struct idr_layer));
586 }
587
588 static  int init_id_cache(void)
589 {
590         if (!idr_layer_cache)
591                 idr_layer_cache = kmem_cache_create("idr_layer_cache",
592                         sizeof(struct idr_layer), 0, 0, idr_cache_ctor);
593         return 0;
594 }
595
596 /**
597  * idr_init - initialize idr handle
598  * @idp:        idr handle
599  *
600  * This function is use to set up the handle (@idp) that you will pass
601  * to the rest of the functions.
602  */
603 void idr_init(struct idr *idp)
604 {
605         init_id_cache();
606         memset(idp, 0, sizeof(struct idr));
607         spin_lock_init(&idp->lock);
608 }
609 EXPORT_SYMBOL(idr_init);
610
611
612 /*
613  * IDA - IDR based ID allocator
614  *
615  * this is id allocator without id -> pointer translation.  Memory
616  * usage is much lower than full blown idr because each id only
617  * occupies a bit.  ida uses a custom leaf node which contains
618  * IDA_BITMAP_BITS slots.
619  *
620  * 2007-04-25  written by Tejun Heo <htejun@gmail.com>
621  */
622
623 static void free_bitmap(struct ida *ida, struct ida_bitmap *bitmap)
624 {
625         unsigned long flags;
626
627         if (!ida->free_bitmap) {
628                 spin_lock_irqsave(&ida->idr.lock, flags);
629                 if (!ida->free_bitmap) {
630                         ida->free_bitmap = bitmap;
631                         bitmap = NULL;
632                 }
633                 spin_unlock_irqrestore(&ida->idr.lock, flags);
634         }
635
636         kfree(bitmap);
637 }
638
639 /**
640  * ida_pre_get - reserve resources for ida allocation
641  * @ida:        ida handle
642  * @gfp_mask:   memory allocation flag
643  *
644  * This function should be called prior to locking and calling the
645  * following function.  It preallocates enough memory to satisfy the
646  * worst possible allocation.
647  *
648  * If the system is REALLY out of memory this function returns 0,
649  * otherwise 1.
650  */
651 int ida_pre_get(struct ida *ida, gfp_t gfp_mask)
652 {
653         /* allocate idr_layers */
654         if (!idr_pre_get(&ida->idr, gfp_mask))
655                 return 0;
656
657         /* allocate free_bitmap */
658         if (!ida->free_bitmap) {
659                 struct ida_bitmap *bitmap;
660
661                 bitmap = kmalloc(sizeof(struct ida_bitmap), gfp_mask);
662                 if (!bitmap)
663                         return 0;
664
665                 free_bitmap(ida, bitmap);
666         }
667
668         return 1;
669 }
670 EXPORT_SYMBOL(ida_pre_get);
671
672 /**
673  * ida_get_new_above - allocate new ID above or equal to a start id
674  * @ida:        ida handle
675  * @staring_id: id to start search at
676  * @p_id:       pointer to the allocated handle
677  *
678  * Allocate new ID above or equal to @ida.  It should be called with
679  * any required locks.
680  *
681  * If memory is required, it will return -EAGAIN, you should unlock
682  * and go back to the ida_pre_get() call.  If the ida is full, it will
683  * return -ENOSPC.
684  *
685  * @p_id returns a value in the range 0 ... 0x7fffffff.
686  */
687 int ida_get_new_above(struct ida *ida, int starting_id, int *p_id)
688 {
689         struct idr_layer *pa[MAX_LEVEL];
690         struct ida_bitmap *bitmap;
691         unsigned long flags;
692         int idr_id = starting_id / IDA_BITMAP_BITS;
693         int offset = starting_id % IDA_BITMAP_BITS;
694         int t, id;
695
696  restart:
697         /* get vacant slot */
698         t = idr_get_empty_slot(&ida->idr, idr_id, pa);
699         if (t < 0) {
700                 if (t == -1)
701                         return -EAGAIN;
702                 else /* will be -3 */
703                         return -ENOSPC;
704         }
705
706         if (t * IDA_BITMAP_BITS >= MAX_ID_BIT)
707                 return -ENOSPC;
708
709         if (t != idr_id)
710                 offset = 0;
711         idr_id = t;
712
713         /* if bitmap isn't there, create a new one */
714         bitmap = (void *)pa[0]->ary[idr_id & IDR_MASK];
715         if (!bitmap) {
716                 spin_lock_irqsave(&ida->idr.lock, flags);
717                 bitmap = ida->free_bitmap;
718                 ida->free_bitmap = NULL;
719                 spin_unlock_irqrestore(&ida->idr.lock, flags);
720
721                 if (!bitmap)
722                         return -EAGAIN;
723
724                 memset(bitmap, 0, sizeof(struct ida_bitmap));
725                 pa[0]->ary[idr_id & IDR_MASK] = (void *)bitmap;
726                 pa[0]->count++;
727         }
728
729         /* lookup for empty slot */
730         t = find_next_zero_bit(bitmap->bitmap, IDA_BITMAP_BITS, offset);
731         if (t == IDA_BITMAP_BITS) {
732                 /* no empty slot after offset, continue to the next chunk */
733                 idr_id++;
734                 offset = 0;
735                 goto restart;
736         }
737
738         id = idr_id * IDA_BITMAP_BITS + t;
739         if (id >= MAX_ID_BIT)
740                 return -ENOSPC;
741
742         __set_bit(t, bitmap->bitmap);
743         if (++bitmap->nr_busy == IDA_BITMAP_BITS)
744                 idr_mark_full(pa, idr_id);
745
746         *p_id = id;
747
748         /* Each leaf node can handle nearly a thousand slots and the
749          * whole idea of ida is to have small memory foot print.
750          * Throw away extra resources one by one after each successful
751          * allocation.
752          */
753         if (ida->idr.id_free_cnt || ida->free_bitmap) {
754                 struct idr_layer *p = alloc_layer(&ida->idr);
755                 if (p)
756                         kmem_cache_free(idr_layer_cache, p);
757         }
758
759         return 0;
760 }
761 EXPORT_SYMBOL(ida_get_new_above);
762
763 /**
764  * ida_get_new - allocate new ID
765  * @ida:        idr handle
766  * @p_id:       pointer to the allocated handle
767  *
768  * Allocate new ID.  It should be called with any required locks.
769  *
770  * If memory is required, it will return -EAGAIN, you should unlock
771  * and go back to the idr_pre_get() call.  If the idr is full, it will
772  * return -ENOSPC.
773  *
774  * @id returns a value in the range 0 ... 0x7fffffff.
775  */
776 int ida_get_new(struct ida *ida, int *p_id)
777 {
778         return ida_get_new_above(ida, 0, p_id);
779 }
780 EXPORT_SYMBOL(ida_get_new);
781
782 /**
783  * ida_remove - remove the given ID
784  * @ida:        ida handle
785  * @id:         ID to free
786  */
787 void ida_remove(struct ida *ida, int id)
788 {
789         struct idr_layer *p = ida->idr.top;
790         int shift = (ida->idr.layers - 1) * IDR_BITS;
791         int idr_id = id / IDA_BITMAP_BITS;
792         int offset = id % IDA_BITMAP_BITS;
793         int n;
794         struct ida_bitmap *bitmap;
795
796         /* clear full bits while looking up the leaf idr_layer */
797         while ((shift > 0) && p) {
798                 n = (idr_id >> shift) & IDR_MASK;
799                 __clear_bit(n, &p->bitmap);
800                 p = p->ary[n];
801                 shift -= IDR_BITS;
802         }
803
804         if (p == NULL)
805                 goto err;
806
807         n = idr_id & IDR_MASK;
808         __clear_bit(n, &p->bitmap);
809
810         bitmap = (void *)p->ary[n];
811         if (!test_bit(offset, bitmap->bitmap))
812                 goto err;
813
814         /* update bitmap and remove it if empty */
815         __clear_bit(offset, bitmap->bitmap);
816         if (--bitmap->nr_busy == 0) {
817                 __set_bit(n, &p->bitmap);       /* to please idr_remove() */
818                 idr_remove(&ida->idr, idr_id);
819                 free_bitmap(ida, bitmap);
820         }
821
822         return;
823
824  err:
825         printk(KERN_WARNING
826                "ida_remove called for id=%d which is not allocated.\n", id);
827 }
828 EXPORT_SYMBOL(ida_remove);
829
830 /**
831  * ida_destroy - release all cached layers within an ida tree
832  * ida:         ida handle
833  */
834 void ida_destroy(struct ida *ida)
835 {
836         idr_destroy(&ida->idr);
837         kfree(ida->free_bitmap);
838 }
839 EXPORT_SYMBOL(ida_destroy);
840
841 /**
842  * ida_init - initialize ida handle
843  * @ida:        ida handle
844  *
845  * This function is use to set up the handle (@ida) that you will pass
846  * to the rest of the functions.
847  */
848 void ida_init(struct ida *ida)
849 {
850         memset(ida, 0, sizeof(struct ida));
851         idr_init(&ida->idr);
852
853 }
854 EXPORT_SYMBOL(ida_init);