内核ida和idr机制分析（盘符分配机制）
ida和idr的机制在我个人看来，是内核管理整数资源的一种方法。在内核中，许多地方都用到了该结构（例如class的id，disk的id），更直观的说，硬盘的sda到sdz的自动排序也是依靠该机制。使用该结构的好处是可以管理大量的整数资源并且检索的时候非常高效。但是，使用该机制的另一个弊端就是：同一个槽位的硬盘进行拔插的时候，如果之前申请的整数资源没有来得及释放，那么可能会产生盘符漂移现象。这给上层软件对盘符的管理带来了困难。在本篇博文中，对具体如何解决盘符漂移不做说明。
在根据代码说明之前，我想先介绍一下该机制对整型数的灵活应用。int数值一般来说，为4个字节。那么将一个int数分为4部分的结果就是每部分8bit。在idr的机制中，采用树来管理资源，int数值的一个字节，被抽象成了树中的一层。即：对某个int值从又向左数，分别是第一层、第二层、第三层、第四层。第一层必须要有，第一层一般是树叶层。该idr树的生长方式也是从树叶开始，随着不断的生长，最开始，树根就是树叶，到最后，树根处于第四层，树叶还是第一层。特别注意说明的是，idr还有一个第0层的概念。在第0层上，可以比喻成树叶上水珠。
之前的文字描述可能比较抽象，而且也可能不太准确。下面用一个图来表示这种关系。
假设我们现在有个a=0x0001，那么a在图中对应第一层中的１。如果有个b=0x0011，那么就必须从第二层的１上生长出一个和第一层一样的结构，再在这上面找到１.如图所示：
当然，如果该树管理的最大资源，还没有涉及到第三层，即最大的数第三个字节都是0，那么其实是没有必要维护第三层的。
此外，该图只是形象的说明了idr的思想，但与实际的代码并不完全一样，具体细节还需要接下来慢慢结合代码分析。在分析代码之前，再介绍一下常用运算符抑或。请观察下面的运算式：((m >> 8) & (0xF) ^ (m >> 8) ^ (0x5)) << 8 该运算的作用是将m的第二个字节置为5，第三个第四个字节不变，第一个字节清零。
下面开始结合代码分析，先分别给出ida和idr的结构说明：
168 struct ida {
169 struct idr idr;
170 struct ida_bitmap *free_bitmap;
171 };
163 struct ida_bitmap {
164 long nr_busy;
165 unsigned long bitmap[IDA_BITMAP_LONGS];
166 };
idr代表着上面介绍的那一棵树，因此可见，ida只是对这棵树的封装，在idr树的基础上，统一了管理办法。
42 struct idr {
43 struct idr_layer __rcu *hint; /* the last layer allocated from */
44 struct idr_layer __rcu *top;
45 int layers; /* only valid w/o concurrent changes */
46 int cur; /* current pos for cyclic allocation */
47 spinlock_t lock;
48 int id_free_cnt;
49 struct idr_layer *id_free;
50 };
30 struct idr_layer {
31 int prefix; /* the ID prefix of this idr_layer */
32 int layer; /* distance from leaf */
33 struct idr_layer __rcu *ary[1<<IDR_BITS];
34 int count; /* When zero, we can release it */
35 union {
36 /* A zero bit means "space here" */
37 DECLARE_BITMAP(bitmap, IDR_SIZE);
38 struct rcu_head rcu_head;
39 };
40 };
idr代表图中的那棵树，idr_layer代表着图上的每个圆球，而其中的ary数组代表着每个圆球下的箭头，bitmap位图用来记录该位置下的子layer是否还有空位，如果没有将置1.
获取idr资源主要由两个api来管理。ida_pre_get和ida_get_new_above。前者负责按照该树可承载的最多layer数量申请layer资源，并存放到资源池中。后者可以指定从某个id开始，寻找下一个未被使用的id。
896 int ida_pre_get(struct ida *ida, gfp_t gfp_mask)
897 {
898 /* allocate idr_layers */
899 if (!__idr_pre_get(&ida->idr, gfp_mask))
900 return 0;
901
902 /* allocate free_bitmap */
903 if (!ida->free_bitmap) {
904 struct ida_bitmap *bitmap;
905
906 bitmap = kmalloc(sizeof(struct ida_bitmap), gfp_mask);
907 if (!bitmap)
908 return 0;
909
910 free_bitmap(ida, bitmap);
911 }
912
913 return 1;
914 }
192 static int __idr_pre_get(struct idr *idp, gfp_t gfp_mask)
193 {
194 while (idp->id_free_cnt < MAX_IDR_FREE) {
195 struct idr_layer *new;
196 new = kmem_cache_zalloc(idr_layer_cache, gfp_mask);
197 if (new == NULL)
198 return (0);
199 move_to_free_list(idp, new);
200 }
201 return 1;
202 }
160 static void move_to_free_list(struct idr *idp, struct idr_layer *p)
161 {
162 unsigned long flags;
163
164 /*
165 * Depends on the return element being zeroed.
166 */
167 spin_lock_irqsave(&idp->lock, flags);
168 __move_to_free_list(idp, p);
169 spin_unlock_irqrestore(&idp->lock, flags);
170 }
153 static void __move_to_free_list(struct idr *idp, struct idr_layer *p)
154 {
155 p->ary[0] = idp->id_free;
156 idp->id_free = p;
157 idp->id_free_cnt++;
158 }
868 static void free_bitmap(struct ida *ida, struct ida_bitmap *bitmap)
869 {
870 unsigned long flags;
871
872 if (!ida->free_bitmap) {
873 spin_lock_irqsave(&ida->idr.lock, flags);
874 if (!ida->free_bitmap) {
875 ida->free_bitmap = bitmap;
876 bitmap = NULL;
877 }
878 spin_unlock_irqrestore(&ida->idr.lock, flags);
879 }
880
881 kfree(bitmap);
882 }
899行调用__idr_pre_get分配layer。在该函数内，分配MAX_IDR_FREE个layer，之后使用move_to_free_list函数进行保存。153行可以看出，所有的未使用layer都通过idr里的id_free连接起来，layer之间通过ary[0]连接。这样，创建的资源，在之后需要使用的时候，直接取就可以了，可以节省运行时间，提高性能。
ida内还有个free_bitmap域，由于该域的操作涉及到竞争，因此，放到自旋锁中处理。881行的free是因为，防止某个线程申请好了资源，但是有一个线程比他还快，已经进入了874行。那么等之后他获取到锁后，直接不需要进入if分支，释放之前申请的资源即可。
932 int ida_get_new_above(struct ida *ida, int starting_id, int *p_id)
933 {
934 struct idr_layer *pa[MAX_IDR_LEVEL + 1];
935 struct ida_bitmap *bitmap;
936 unsigned long flags;
937 int idr_id = starting_id / IDA_BITMAP_BITS;
938 int offset = starting_id % IDA_BITMAP_BITS;
939 int t, id;
940
941 restart:
942 /* get vacant slot */
943 t = idr_get_empty_slot(&ida->idr, idr_id, pa, 0, &ida->idr);
944 if (t < 0)
945 return t == -ENOMEM ? -EAGAIN : t;
946
947 if (t * IDA_BITMAP_BITS >= MAX_IDR_BIT)
948 return -ENOSPC;
949
950 if (t != idr_id)
951 offset = 0;
952 idr_id = t;
953
954 /* if bitmap isn't there, create a new one */
955 bitmap = (void *)pa[0]->ary[idr_id & IDR_MASK];
956 if (!bitmap) {
957 spin_lock_irqsave(&ida->idr.lock, flags);
958 bitmap = ida->free_bitmap;
959 ida->free_bitmap = NULL;
960 spin_unlock_irqrestore(&ida->idr.lock, flags);
961
962 if (!bitmap)
963 return -EAGAIN;
964
965 memset(bitmap, 0, sizeof(struct ida_bitmap));
966 rcu_assign_pointer(pa[0]->ary[idr_id & IDR_MASK],
967 (void *)bitmap);
968 pa[0]->count++;
969 }
970
971 /* lookup for empty slot */
972 t = find_next_zero_bit(bitmap->bitmap, IDA_BITMAP_BITS, offset);
973 if (t == IDA_BITMAP_BITS) {
974 /* no empty slot after offset, continue to the next chunk */
975 idr_id++;
976 offset = 0;
977 goto restart;
978 }
979
980 id = idr_id * IDA_BITMAP_BITS + t;
981 if (id >= MAX_IDR_BIT)
982 return -ENOSPC;
983
984 __set_bit(t, bitmap->bitmap);
985 if (++bitmap->nr_busy == IDA_BITMAP_BITS)
986 idr_mark_full(pa, idr_id);
987
988 *p_id = id;
989
990 /* Each leaf node can handle nearly a thousand slots and the
991 * whole idea of ida is to have small memory foot print.
992 * Throw away extra resources one by one after each successful
993 * allocation.
994 */
995 if (ida->idr.id_free_cnt || ida->free_bitmap) {
996 struct idr_layer *p = get_from_free_list(&ida->idr);
997 if (p)
998 kmem_cache_free(idr_layer_cache, p);
999 }
1000
1001 return 0;
1002 }
289 static int idr_get_empty_slot(struct idr *idp, int starting_id,
290 struct idr_layer **pa, gfp_t gfp_mask,
291 struct idr *layer_idr)
292 {
293 struct idr_layer *p, *new;
294 int layers, v, id;
295 unsigned long flags;
296
297 id = starting_id;
298 build_up:
299 p = idp->top;
300 layers = idp->layers;
301 if (unlikely(!p)) {
302 if (!(p = idr_layer_alloc(gfp_mask, layer_idr)))
303 return -ENOMEM;
304 p->layer = 0;
305 layers = 1;
306 }
307 /*
308 * Add a new layer to the top of the tree if the requested
309 * id is larger than the currently allocated space.
310 */
311 while (id > idr_max(layers)) {
312 layers++;
313 if (!p->count) {
314 /* special case: if the tree is currently empty,
315 * then we grow the tree by moving the top node
316 * upwards.
317 */
318 p->layer++;
319 WARN_ON_ONCE(p->prefix);
320 continue;
321 }
322 if (!(new = idr_layer_alloc(gfp_mask, layer_idr))) {
323 /*
324 * The allocation failed. If we built part of
325 * the structure tear it down.
326 */
327 spin_lock_irqsave(&idp->lock, flags);
328 for (new = p; p && p != idp->top; new = p) {
329 p = p->ary[0];
330 new->ary[0] = NULL;
331 new->count = 0;
332 bitmap_clear(new->bitmap, 0, IDR_SIZE);
333 __move_to_free_list(idp, new);
334 }
335 spin_unlock_irqrestore(&idp->lock, flags);
336 return -ENOMEM;
337 }
338 new->ary[0] = p;
339 new->count = 1;
340 new->layer = layers-1;
341 new->prefix = id & idr_layer_prefix_mask(new->layer);
342 if (bitmap_full(p->bitmap, IDR_SIZE))
343 __set_bit(0, new->bitmap);
344 p = new;
345 }
346 rcu_assign_pointer(idp->top, p);
347 idp->layers = layers;
348 v = sub_alloc(idp, &id, pa, gfp_mask, layer_idr);
349 if (v == -EAGAIN)
350 goto build_up;
351 return(v);
352 }
220 static int sub_alloc(struct idr *idp, int *starting_id, struct idr_layer **pa,
221 gfp_t gfp_mask, struct idr *layer_idr)
222 {
223 int n, m, sh;
224 struct idr_layer *p, *new;
225 int l, id, oid;
226
227 id = *starting_id;
228 restart:
229 p = idp->top;
230 l = idp->layers;
231 pa[l--] = NULL;
232 while (1) {
233 /*
234 * We run around this while until we reach the leaf node...
235 */
236 n = (id >> (IDR_BITS*l)) & IDR_MASK;
237 m = find_next_zero_bit(p->bitmap, IDR_SIZE, n);
238 if (m == IDR_SIZE) {
239 /* no space available go back to previous layer. */
240 l++;
241 oid = id;
242 id = (id | ((1 << (IDR_BITS * l)) - 1)) + 1;
243
244 /* if already at the top layer, we need to grow */
245 if (id > idr_max(idp->layers)) {
246 *starting_id = id;
247 return -EAGAIN;
248 }
249 p = pa[l];
250 BUG_ON(!p);
251
252 /* If we need to go up one layer, continue the
253 * loop; otherwise, restart from the top.
254 */
255 sh = IDR_BITS * (l + 1);
256 if (oid >> sh == id >> sh)
257 continue;
258 else
259 goto restart;
260 }
261 if (m != n) {
262 sh = IDR_BITS*l;
263 id = ((id >> sh) ^ n ^ m) << sh;
264 }
265 if ((id >= MAX_IDR_BIT) || (id < 0))
266 return -ENOSPC;
267 if (l == 0)
268 break;
269 /*
270 * Create the layer below if it is missing.
271 */
272 if (!p->ary[m]) {
273 new = idr_layer_alloc(gfp_mask, layer_idr);
274 if (!new)
275 return -ENOMEM;
276 new->layer = l-1;
277 new->prefix = id & idr_layer_prefix_mask(new->layer);
278 rcu_assign_pointer(p->ary[m], new);
279 p->count++;
280 }
281 pa[l--] = p;
282 p = p->ary[m];
283 }
284
285 pa[l] = p;
286 return id;
287 }
由于代码较长。为了方便叙述，假设当前idr树中没有被使用的id。现在调用ida_get_new_above从0开始找下一个可用的id。由于我们给出了假设，因此可以预期到得到的结果是0.我们带着这样的假设去分析代码。
943行进入idr_get_empty_slot。301行由于是第一次申请id，因此将进入该分支，分配一个top，即根节点。此时，304行看出根节点层数为第0层。305行layers表示总层数，为1层。由于是从0开始分配，因此311行循环不进入，直接跳过。346行通过rcu方式配置了top域。348行开始真正分配。
该函数工作开始，保存了几个量，如227~230所示。考虑到我们从0开始，则id=0，p为刚刚分配的根节点，l=1。232行的循环是为了使l>1时，能不断遍历到第0层。237行得到m=0.if分支显然不会进入，跳过。由于231行l--，所以267行的时候，跳出循环。285行保存了根节点，之后返回0.
回到943行，t取到0.pa[0]内保存的一定是叶子节点的地址。我们这里因为只有1层，根节点就是叶子节点。955行显然取到一个NULL，那么将ida中的free_bitmap转交给它，并在966行转交给根节点的ary[0]。972行检测当前层数是否还有剩余空位，这里需要说明的是，一般情况下，一个节点（layer）管理8*128个id，这种管理就是直接通过数组进行管理的。这个数组就是ida申请的数组，在该函数内通过强转保存到了ary[0]内。那么此时，肯定返回0. 980行id=0.984行配置相应位为1. 985~986行判断该节点是否已满,如果之后没有空闲了，将设置为该位置已满。这是通过根节点下的bitmap去设置的。988行将id值赋给p_id，之后返回。
在这里，将对之前的假设做出一个纠正。我们开始假设是从0开始寻找，是假设ida_get_new_above里的参数staring_id是从哪个数开始查找的意思。实际上，通过走读分析，我们可以看到，该starting_id其实代表某个layer。
通过这样的分析，相信对于整个流程已经有了简单的认知。代码其他部分主要涉及到stating_id指定的layer不存在，分配新的layer。或者starting_id超过了当前层数所能提供的最大id，则idr必须开始生长的过程。对于这些部分，相信经过前面的分析，这些都已经变的很简单，本文不再详细说明。留给读者自行分析。