linux idr机制
I.idr机制
i.idr介绍
系统许多资源都用整数ID来标识，如进程ID、文件描述符ID、IPC ID等；资源信息通常存放在对应的数据结构中（如进程信息存放在task_struct中、ipc信息存放在ipc_perm中），id与数据结构的关联机制有不同的实现，idr机制是其中的一种。
idr，id radix的缩写。idr主要用于建立id与指针（指向对应的数据结构）之间的对应关系。idr用类基数树结构来构造一个稀疏数组，以id为索引找到对应数组元素，进而找到对应的数据结构指针。
用到idr机制的主要有：IPC id（消息队列id、信号量id、共享内存id等），磁盘分区id(sda中数字部分）等
ii.idr实现
1.idr结构
idr是由基数树构成，叶结点存储id对应的指针，树干结点用于叶结点与根结点的串联而不存储数据。每个结点有radix个子结点，每个叶结点可存储radix个指针。
根结点、树干结点、叶结点均用idr_layer表示：
51 struct idr_layer {
52 unsigned long bitmap; /* A zero bit means "space here" */
53 struct idr_layer *ary[1<<IDR_BITS];
54 int count; /* When zero, we can release it */
55 int layer; /* distance from leaf */
56 struct rcu_head rcu_head;
57 };
bitmap：用于标识子结点是否还有空闲空间，如果子结点对应位是0，则表示子结点还有空闲空间，否则表示子结点已满
ary：根或树干结点时存储子结点指针，叶结点时存储指针数据
count：ary中有效数据个数
layer：层数，即距叶结点的距离，如果时叶结点layer=0
rcu_head：用于idr_layer的内存释放
2.idr基数树
idr树用结构idr表示
59 struct idr {
60 struct idr_layer *top;
61 struct idr_layer *id_free;
62 int layers; /* only valid without concurrent changes */
63 int id_free_cnt;
64 spinlock_t lock;
65 };
top：指向基数树根结点
id_free：指向idr_layer构成的缓存池链表
layers：基数树层数
id_free_cnt：缓存池大小
lock：idr锁，保护基数树
3.基数树结构图
3.宏定义
IDR_BITS：子结点索引位数，5或6；bitmap是long类型，表示子结点个数为sizeof(long)*8；long占32位时，可表示32个子结点，则需索引位数为5；long占64位时，则需索引位数为6
IDR_SIZE：子结点个数，(1 << IDR_BITS)
IDR_MASK：子结点索引掩码，((1 << IDR_BITS)-1)
MAX_ID_SHIFT：ID空间大小位数，(sizeof(int)*8 - 1)；ID空间为0~0x7fffffff，即正整数
MAX_LEVEL：表示ID空间所需的层数，(MAX_ID_SHIFT + IDR_BITS - 1) / IDR_BITS；n层基数树表示id空间的个数=IDR_SIZE^n=1<<(n*IDR_BITS)，则表示整个ID空间需要n=roundup(log2(1<<MAX_ID_SHIFT)/IDR_BITS)=(MAX_ID_SHIFT + IDR_BITS - 1) / IDR_BITS层
IDR_FREE_MAX：表示idr缓存在分配id过程中所需结点的最大值，MAX_LEVEL + MAX_LEVEL；分配id过程中，可能需要对树进行扩容，如果出现结点为空还要分配结点；比如空树情况，分配一个值为0x7fffffff的id，则首先要扩容MAX_LEVEL个结点，再添加MAX_LEVEL-1个结点后才能正确分配id
II.idr分配id
i.缓存预留
基数树是在分配id的过程中动态分配树结点的，如果结点不存在会从idr缓存中取出可用结点自动添加到树中；一次分配id过程中，最多会添加2*MAX_LEVEL-1个结点，所以缓存中必须保证存在2*MAX_LEVEL-1个结点，才能保证分配不出现无内存情况。
lib/idr.c：
108 /**
109 * idr_pre_get - reserver resources for idr allocation
110 * @idp: idr handle
111 * @gfp_mask: memory allocation flags
112 *
113 * This function should be called prior to locking and calling the
114 * idr_get_new* functions. It preallocates enough memory to satisfy
115 * the worst possible allocation.
116 *
117 * If the system is REALLY out of memory this function returns 0,
118 * otherwise 1.
119 */
120 int idr_pre_get(struct idr *idp, gfp_t gfp_mask)
121 {
122 while (idp->id_free_cnt < IDR_FREE_MAX) {
123 struct idr_layer *new;
124 new = kmem_cache_zalloc(idr_layer_cache, gfp_mask);
125 if (new == NULL)
126 return (0);
127 move_to_free_list(idp, new);
128 }
129 return 1;
130 }
ii.idr基数树扩容
当idr表示的id空间大小不满足要求时，会对idr树扩容，主要就是增加idr树的层数；树层数由n增加到n+1后，则n层树的根结点必属于n+1层的第一个结点的第个一元素。
idr基数是在分配id时自动扩容，实现代码是idr_get_empty_slot：
202 static int idr_get_empty_slot(struct idr *idp, int starting_id,
203 struct idr_layer **pa)
204 {
205 struct idr_layer *p, *new;
206 int layers, v, id;
207 unsigned long flags;
208
209 id = starting_id;
210 build_up:
211 p = idp->top;
212 layers = idp->layers;
213 if (unlikely(!p)) {
214 if (!(p = get_from_free_list(idp)))
215 return -1;
216 p->layer = 0;
217 layers = 1;
218 }
219 /*
220 * Add a new layer to the top of the tree if the requested
221 * id is larger than the currently allocated space.
222 */
223 while ((layers < (MAX_LEVEL - 1)) && (id >= (1 << (layers*IDR_BITS)))) {
224 layers++;
225 if (!p->count) {
226 /* special case: if the tree is currently empty,
227 * then we grow the tree by moving the top node
228 * upwards.
229 */
230 p->layer++;
231 continue;
232 }
233 if (!(new = get_from_free_list(idp))) {
234 /*
235 * The allocation failed. If we built part of
236 * the structure tear it down.
237 */
238 spin_lock_irqsave(&idp->lock, flags);
239 for (new = p; p && p != idp->top; new = p) {
240 p = p->ary[0];
241 new->ary[0] = NULL;
242 new->bitmap = new->count = 0;
243 __move_to_free_list(idp, new);
244 }
245 spin_unlock_irqrestore(&idp->lock, flags);
246 return -1;
247 }
248 new->ary[0] = p;
249 new->count = 1;
250 new->layer = layers-1;
251 if (p->bitmap == IDR_FULL)
252 __set_bit(0, &new->bitmap);
253 p = new;
254 }
255 rcu_assign_pointer(idp->top, p);
256 idp->layers = layers;
257 v = sub_alloc(idp, &id, pa);
258 if (v == IDR_NEED_TO_GROW)
259 goto build_up;
260 return(v);
261 }
分配步骤如下：
1.由于idr初始化后，基数树没有任何树结点；如果没有根结点，则创建根结点，且layer=0，表示根结点也是叶结点
2.如果查找起始id已经超过基数树的大小空间，则会对基数树进行扩容；
a.如果当前树是空树，则直接修改树的层数及根结点的层级
b.否则，将原树的根结点作为新树根结点的第一个元素，循环添加根结点直到满足扩容要求；在扩容过程中如果失败，则会删除前面添加的结点
3.修改树的根结点级层信息
4.从基数树中分配空闲id，如果树需要扩容，则根据id大小对树进行扩容。
基数树扩容过程如下图所示，其中绿色部分是扩容的结点：
iii.idr分配id
idr分配id，此过程可能会添加树的新结点，实现为sub_alloc
133 static int sub_alloc(struct idr *idp, int *starting_id, struct idr_layer **pa)
134 {
135 int n, m, sh;
136 struct idr_layer *p, *new;
137 int l, id, oid;
138 unsigned long bm;
139
140 id = *starting_id;
141 restart:
142 p = idp->top;
143 l = idp->layers;
144 pa[l--] = NULL;
145 while (1) {
146 /*
147 * We run around this while until we reach the leaf node...
148 */
149 n = (id >> (IDR_BITS*l)) & IDR_MASK;
150 bm = ~p->bitmap;
151 m = find_next_bit(&bm, IDR_SIZE, n);
152 if (m == IDR_SIZE) {
153 /* no space available go back to previous layer. */
154 l++;
155 oid = id;
156 id = (id | ((1 << (IDR_BITS * l)) - 1)) + 1;
158 /* if already at the top layer, we need to grow */
159 if (id >= 1 << (idp->layers * IDR_BITS)) {
160 *starting_id = id;
161 return IDR_NEED_TO_GROW;
162 }
163 p = pa[l];
164 BUG_ON(!p);
165
166 /* If we need to go up one layer, continue the
167 * loop; otherwise, restart from the top.
168 */
169 sh = IDR_BITS * (l + 1);
170 if (oid >> sh == id >> sh)
171 continue;
172 else
173 goto restart;
174 }
175 if (m != n) {
176 sh = IDR_BITS*l;
177 id = ((id >> sh) ^ n ^ m) << sh;
178 }
179 if ((id >= MAX_ID_BIT) || (id < 0))
180 return IDR_NOMORE_SPACE;
181 if (l == 0)
182 break;
183 /*
184 * Create the layer below if it is missing.
185 */
186 if (!p->ary[m]) {
187 new = get_from_free_list(idp);
188 if (!new)
189 return -1;
190 new->layer = l-1;
191 rcu_assign_pointer(p->ary[m], new);
192 p->count++;
193 }
194 pa[l--] = p;
195 p = p->ary[m];
196 }
197
198 pa[l] = p;
199 return id;
200 }
分配id过程如下：
1.查找starting_id开始的id空间，如果没有可用空间，则需要对基数树进行扩容
2.根据starting_id递归子结点，如果子结点无空间，则回退到上级或顶级并根据增大后的starting_id继续查找空闲id
注：递归过程中，需要父结点bitmap中标识子结点有空闲空间，但是子结点的空闲区间可能会出现在id之前，id之后无空闲空间，所以会出现回退上级或顶级的情况
注：一个结点有32或64个区间，分别对应ary的每个元素
如果该结点没有空闲id，则回退到上层，并向后偏移一个区间继续查找空闲ID；如果父区间是该结点的最后一个区间，则回退到根结点重新开始查找。
回退上层与根的两种情况如下：
layer = 6 5 4 3 2 1 0
id = 00 00000 00000 00000 11111 00001 00000时
a.在查找第0层第0(00000)区间时，由于该区间没有空闲id，则回退上级，并向后偏移一个区间即第2（00001+1）区间；由于上层两个区间属于同一节点，则可以继续查找
b.在查找第1层第1(00001)区间时，由于该区间没有空闲id，则回退上级，并向后偏移一个区间即第0（11111+1）区间；由于上层两个区间不属于同一节点，则回到根结点继续查找
3.递归子结点过程中，如果结点不存在，则添加结点
4.递归到叶结点，则循环结束，并返回叶结点的空闲id
注：
156行：id = (id | ((1 << (IDR_BITS * l)) - 1)) + 1;表示回退到上层，并偏移一个区间；
169行：sh = IDR_BITS * (l + 1);用来判断偏移后的区间与原区间是否在同一结点
176行：sh = IDR_BITS*l; id = ((id >> sh) ^ n ^ m) << sh;将id中代表l级的域值由n修改成m，可以看成id=id>>(sh+IDR_BITS)<<(sh+IDR_BITS)+n^n^m<<sh=id>>(sh+IDR_BITS)<<(sh+IDR_BITS)+m<<sh
回退到上层或顶层情况如下图：
A结点bitmap=0x0000FFFF，B结点bitmap=0x0000FFFF，D结点bitmap=0x00000000
当从977开始查找空闲id时，会查找到A结点，但A结点没有空闲id，会回退到上层C.ary[30]，并编移一个区间C.ary[31]，由于C.ary[30]与C.ary[31]在同一结点即E.ary[0]=E.ary[0];继续从C.ary[31]开始查找，会在B结点找到空闲id=992
当从1009开始查找空闲id时，会查找到B结点，但B结点没有空闲id，会回退到上层C.ary[31]，并统称一个区间D.ary[0]，由于C.ary[31]与D.ary[0]不在同一结点即E.ary[0]!=E.ary[1]；则回到顶层结点E，并从id=1024重新再查找空闲ID，则会在D结点找到空闲id=1024
III.idr释放id
i.删除id
idr释放id实现为：
353 static void sub_remove(struct idr *idp, int shift, int id)
354 {
355 struct idr_layer *p = idp->top;
356 struct idr_layer **pa[MAX_LEVEL];
357 struct idr_layer ***paa = &pa[0];
358 struct idr_layer *to_free;
359 int n;
360
361 *paa = NULL;
362 *++paa = &idp->top;
363
364 while ((shift > 0) && p) {
365 n = (id >> shift) & IDR_MASK;
366 __clear_bit(n, &p->bitmap);
367 *++paa = &p->ary[n];
368 p = p->ary[n];
369 shift -= IDR_BITS;
370 }
371 n = id & IDR_MASK;
372 if (likely(p != NULL && test_bit(n, &p->bitmap))){
373 __clear_bit(n, &p->bitmap);
374 rcu_assign_pointer(p->ary[n], NULL);
375 to_free = NULL;
376 while(*paa && ! --((**paa)->count)){
377 if (to_free)
378 free_layer(to_free);
379 to_free = **paa;
380 **paa-- = NULL;
381 }
382 if (!*paa)
383 idp->layers = 0;
384 if (to_free)
385 free_layer(to_free);
386 } else
387 idr_remove_warning(id);
388 }
1.将id所表示的基数树路径上结点对应的位图置0
2.如果路径上结点为空结点，同时删除结点
ii.基数树缩小
基数树shrink实现是idr_remove：
390 /**
391 * idr_remove - remove the given id and free it's slot
392 * @idp: idr handle
393 * @id: unique key
394 */
395 void idr_remove(struct idr *idp, int id)
396 {
397 struct idr_layer *p;
398 struct idr_layer *to_free;
399
400 /* Mask off upper bits we don't use for the search. */
401 id &= MAX_ID_MASK;
402
403 sub_remove(idp, (idp->layers - 1) * IDR_BITS, id);
404 if (idp->top && idp->top->count == 1 && (idp->layers > 1) &&
405 idp->top->ary[0]) {
406 /*
407 * Single child at leftmost slot: we can shrink the tree.
408 * This level is not needed anymore since when layers are
409 * inserted, they are inserted at the top of the existing
410 * tree.
411 */
412 to_free = idp->top;
413 p = idp->top->ary[0];
414 rcu_assign_pointer(idp->top, p);
415 --idp->layers;
416 to_free->bitmap = to_free->count = 0;
417 free_layer(to_free);
418 }
419 while (idp->id_free_cnt >= IDR_FREE_MAX) {
420 p = get_from_free_list(idp);
421 /*
422 * Note: we don't call the rcu callback here, since the only
423 * layers that fall into the freelist are those that have been
424 * preallocated.
425 */
426 kmem_cache_free(idr_layer_cache, p);
427 }
428 return;
429 }
1.如果根结点只使用了0区间，则删除根结点，将0区间表示的结点作为根结点
2.释放idr缓存中多余的结点
IV.idr查找id对应指针
id的查找即根据id值找到叶子结点中存储的指针值
查找过程由idr_find实现：
490 /**
491 * idr_find - return pointer for given id
492 * @idp: idr handle
493 * @id: lookup key
494 *
495 * Return the pointer given the id it has been registered with. A %NULL
496 * return indicates that @id is not valid or you passed %NULL in
497 * idr_get_new().
498 *
499 * This function can be called under rcu_read_lock(), given that the leaf
500 * pointers lifetimes are correctly managed.
501 */
502 void *idr_find(struct idr *idp, int id)
503 {
504 int n;
505 struct idr_layer *p;
506
507 p = rcu_dereference(idp->top);
508 if (!p)
509 return NULL;
510 n = (p->layer+1) * IDR_BITS;
511
512 /* Mask off upper bits we don't use for the search. */
513 id &= MAX_ID_MASK;
514
515 if (id >= (1 << n))
516 return NULL;
517 BUG_ON(n == 0);
518
519 while (n > 0 && p) {
520 n -= IDR_BITS;
521 BUG_ON(n != p->layer*IDR_BITS);
522 p = rcu_dereference(p->ary[(id >> n) & IDR_MASK]);
523 }
524 return((void *)p);
525 }
注：以id中对应的域值作为结点的区间索引，找到对应的子结点，直到叶结点为止；