前面我们说到过list_head，这是Linux中通用的链表形式，双向循环链表，功能强大，实现简单优雅。可如果您认为list_head就是链表的极致，应该在linux链表界一统天下，那可就错了。据我所知，linux内核代码中至少还有两种链表能占有一席之地。一种就是hlist，一种就是本节要介绍的klist。虽然三者不同，但hlist和klist都可以看成是从list_head中发展出来的，用于特殊的链表使用情景。hlist是用于哈希表中。众所周知，哈希表主要就是一个哈希数组，为了解决映射冲突的问题，常常把哈希数组的每一项做成一个链表，这样有多少重复的都可以链进去。但哈希数组的项很多，list_head的话每个链表头都需要两个指针的空间，在稀疏的哈希表中实在是一种浪费，于是就发明了hlist。hlist有两大特点，一是它的链表头只需要一个指针，二是它的每一项都可以找到自己的前一节点，也就是说它不再循环，但仍是双向。令人不解的是，hlist的实现太绕了，比如它明明可以直接指向前一节点，却偏偏指向指针地址，还是前一节点中指向后一节点的指针地址。即使这种设计在实现时占便宜，但它理解上带来的不便已经远远超过实现上带来的小小便利。

同hlist一样，klist也是为了适应某类特殊情形的要求。考虑一个被简化的情形，假设一些设备被链接在设备链表中，一个线程命令卸载某设备，即将其从设备链表中删除，但这时该设备正在使用中，这时就出现了冲突。当前可以设置临界区并加锁，但因为使用一个设备而锁住整个设备链表显然是不对的；又或者可以从设备本身做文章，让线程阻塞，这当然也可以。但我们上节了解了kref，就该知道linux对待这种情况的风格，给它一个引用计数kref，等计数为零就删除。klist就是这么干的，它把kref直接保存在了链表节点上。之前说到有线程要求删除设备，之前的使用仍存在，所以不能实际删除，但不应该有新的应用访问到该设备。klist就提供了一种让节点在链表上隐身的方法。下面还是来看实际代码吧。

klist的头文件是include/linux/klist.h，实现在lib/klist.c。

[cpp] view plaincopy print?
  1. struct klist_node;
  2. struct klist {
  3. spinlock_t      k_lock;
  4. struct list_head    k_list;
  5. void            (*get)(struct klist_node *);
  6. void            (*put)(struct klist_node *);
  7. } __attribute__ ((aligned (4)));
  8. #define KLIST_INIT(_name, _get, _put)                   \
  9. { .k_lock   = __SPIN_LOCK_UNLOCKED(_name.k_lock),       \
  10. .k_list   = LIST_HEAD_INIT(_name.k_list),         \
  11. .get      = _get,                     \
  12. .put      = _put, }
  13. #define DEFINE_KLIST(_name, _get, _put)                 \
  14. struct klist _name = KLIST_INIT(_name, _get, _put)
  15. extern void klist_init(struct klist *k, void (*get)(struct klist_node *),
  16. void (*put)(struct klist_node *));
  17. struct klist_node {
  18. void            *n_klist;   /* never access directly */
  19. struct list_head    n_node;
  20. struct kref     n_ref;
  21. };

可以看到，klist的链表头是struct klist结构，链表节点是struct klist_node结构。先看struct klist，除了包含链表需要的k_list，还有用于加锁的k_lock。剩余的get()和put()函数是用于struct klist_node嵌入在更大的结构中，这样在节点初始时调用get()，在节点删除时调用put()，以表示链表中存在对结构的引用。再看struct klist_node，除了链表需要的n_node，还有一个引用计数n_ref。还有一个比较特殊的指针n_klist，n_klist是指向链表头struct klist的，但它的第0位用来表示是否该节点已被请求删除，如果已被请求删除则在链表循环时是看不到这一节点的，循环函数将其略过。现在你明白为什么非要在struct klist的定义后加上__attribute__((aligned(4)))。不过说实话这样在x86下仍然不太保险，但linux选择了相信gcc，毕竟是多年的战友和兄弟了，相互知根知底。

看过这两个结构，想必大家已经较为清楚了，下面就来看看它们的实现。

[cpp] view plaincopy print?
  1. /*
  2. * Use the lowest bit of n_klist to mark deleted nodes and exclude
  3. * dead ones from iteration.
  4. */
  5. #define KNODE_DEAD      1LU
  6. #define KNODE_KLIST_MASK    ~KNODE_DEAD
  7. static struct klist *knode_klist(struct klist_node *knode)
  8. {
  9. return (struct klist *)
  10. ((unsigned long)knode->n_klist & KNODE_KLIST_MASK);
  11. }
  12. static bool knode_dead(struct klist_node *knode)
  13. {
  14. return (unsigned long)knode->n_klist & KNODE_DEAD;
  15. }
  16. static void knode_set_klist(struct klist_node *knode, struct klist *klist)
  17. {
  18. knode->n_klist = klist;
  19. /* no knode deserves to start its life dead */
  20. WARN_ON(knode_dead(knode));
  21. }
  22. static void knode_kill(struct klist_node *knode)
  23. {
  24. /* and no knode should die twice ever either, see we're very humane */
  25. WARN_ON(knode_dead(knode));
  26. *(unsigned long *)&knode->n_klist |= KNODE_DEAD;
  27. }

前面的四个函数都是内部静态函数，帮助API实现的。knode_klist()是从节点找到链表头。knode_dead()是检查该节点是否已被请求删除。

knode_set_klist设置节点的链表头。knode_kill将该节点请求删除。细心的话大家会发现这四个函数是对称的，而且都是操作节点的内部函数。

[cpp] view plaincopy print?
  1. void klist_init(struct klist *k, void (*get)(struct klist_node *),
  2. void (*put)(struct klist_node *))
  3. {
  4. INIT_LIST_HEAD(&k->k_list);
  5. spin_lock_init(&k->k_lock);
  6. k->get = get;
  7. k->put = put;
  8. }

klist_init，初始化klist。

[cpp] view plaincopy print?
  1. static void add_head(struct klist *k, struct klist_node *n)
  2. {
  3. spin_lock(&k->k_lock);
  4. list_add(&n->n_node, &k->k_list);
  5. spin_unlock(&k->k_lock);
  6. }
  7. static void add_tail(struct klist *k, struct klist_node *n)
  8. {
  9. spin_lock(&k->k_lock);
  10. list_add_tail(&n->n_node, &k->k_list);
  11. spin_unlock(&k->k_lock);
  12. }
  13. static void klist_node_init(struct klist *k, struct klist_node *n)
  14. {
  15. INIT_LIST_HEAD(&n->n_node);
  16. kref_init(&n->n_ref);
  17. knode_set_klist(n, k);
  18. if (k->get)
  19. k->get(n);
  20. }

又是三个内部函数，add_head()将节点加入链表头，add_tail()将节点加入链表尾，klist_node_init()是初始化节点。注意在节点的引用计数初始化时，因为引用计数变为1，所以也要调用相应的get()函数。

[cpp] view plaincopy print?
  1. void klist_add_head(struct klist_node *n, struct klist *k)
  2. {
  3. klist_node_init(k, n);
  4. add_head(k, n);
  5. }
  6. void klist_add_tail(struct klist_node *n, struct klist *k)
  7. {
  8. klist_node_init(k, n);
  9. add_tail(k, n);
  10. }

klist_add_head()将节点初始化，并加入链表头。

klist_add_tail()将节点初始化，并加入链表尾。

它们正是用上面的三个内部函数实现的，可见linux内核中对函数复用有很强的执念，其实这里add_tail和add_head是不用的，纵观整个文件，也只有klist_add_head()和klist_add_tail()对它们进行了调用。

[cpp] view plaincopy print?
  1. void klist_add_after(struct klist_node *n, struct klist_node *pos)
  2. {
  3. struct klist *k = knode_klist(pos);
  4. klist_node_init(k, n);
  5. spin_lock(&k->k_lock);
  6. list_add(&n->n_node, &pos->n_node);
  7. spin_unlock(&k->k_lock);
  8. }
  9. void klist_add_before(struct klist_node *n, struct klist_node *pos)
  10. {
  11. struct klist *k = knode_klist(pos);
  12. klist_node_init(k, n);
  13. spin_lock(&k->k_lock);
  14. list_add_tail(&n->n_node, &pos->n_node);
  15. spin_unlock(&k->k_lock);
  16. }

klist_add_after()将节点加到指定节点后面。

klist_add_before()将节点加到指定节点前面。

这两个函数都是对外提供的API。在list_head中都没有看到有这种API，所以说需求决定了接口。虽说只有一步之遥，klist也不愿让外界介入它的内部实现。

之前出现的API都太常见了，既没有使用引用计数，又没有跳过请求删除的节点。所以klist的亮点在下面，klist链表的遍历。

[cpp] view plaincopy print?
  1. struct klist_iter {
  2. struct klist    *i_klist;
  3. struct klist_node   *i_cur;
  4. };
  5. extern void klist_iter_init(struct klist *k, struct klist_iter *i);
  6. extern void klist_iter_init_node(struct klist *k, struct klist_iter *i,
  7. struct klist_node *n);
  8. extern void klist_iter_exit(struct klist_iter *i);
  9. extern struct klist_node *klist_next(struct klist_iter *i);

以上就是链表遍历需要的辅助结构struct klist_iter，和遍历用到的四个函数。

[cpp] view plaincopy print?
  1. struct klist_waiter {
  2. struct list_head list;
  3. struct klist_node *node;
  4. struct task_struct *process;
  5. int woken;
  6. };
  7. static DEFINE_SPINLOCK(klist_remove_lock);
  8. static LIST_HEAD(klist_remove_waiters);
  9. static void klist_release(struct kref *kref)
  10. {
  11. struct klist_waiter *waiter, *tmp;
  12. struct klist_node *n = container_of(kref, struct klist_node, n_ref);
  13. WARN_ON(!knode_dead(n));
  14. list_del(&n->n_node);
  15. spin_lock(&klist_remove_lock);
  16. list_for_each_entry_safe(waiter, tmp, &klist_remove_waiters, list) {
  17. if (waiter->node != n)
  18. continue;
  19. waiter->woken = 1;
  20. mb();
  21. wake_up_process(waiter->process);
  22. list_del(&waiter->list);
  23. }
  24. spin_unlock(&klist_remove_lock);
  25. knode_set_klist(n, NULL);
  26. }
  27. static int klist_dec_and_del(struct klist_node *n)
  28. {
  29. return kref_put(&n->n_ref, klist_release);
  30. }
  31. static void klist_put(struct klist_node *n, bool kill)
  32. {
  33. struct klist *k = knode_klist(n);
  34. void (*put)(struct klist_node *) = k->put;
  35. spin_lock(&k->k_lock);
  36. if (kill)
  37. knode_kill(n);
  38. if (!klist_dec_and_del(n))
  39. put = NULL;
  40. spin_unlock(&k->k_lock);
  41. if (put)
  42. put(n);
  43. }
  44. /**
  45. * klist_del - Decrement the reference count of node and try to remove.
  46. * @n: node we're deleting.
  47. */
  48. void klist_del(struct klist_node *n)
  49. {
  50. klist_put(n, true);
  51. }

以上的内容乍一看很难理解，其实都是klist实现必须的。因为使用kref动态删除，自然需要一个计数降为零时调用的函数klist_release。

klist_dec_and_del()就是对kref_put()的包装，起到减少节点引用计数的功能。

至于为什么会出现一个新的结构struct klist_waiter，也很简单。之前说有线程申请删除某节点，但节点的引用计数仍在，所以只能把请求删除的线程阻塞，就是用struct klist_waiter阻塞在klist_remove_waiters上。所以在klist_release()调用时还要将阻塞的线程唤醒。knode_kill()将节点设为已请求删除。而且还会调用put()函数。

释放引用计数是调用klist_del()，它通过内部函数klist_put()完成所需操作：用knode_kill()设置节点为已请求删除，用klist_dec_and_del()释放引用，调用可能的put()函数。

[cpp] view plaincopy print?
  1. /**
  2. * klist_remove - Decrement the refcount of node and wait for it to go away.
  3. * @n: node we're removing.
  4. */
  5. void klist_remove(struct klist_node *n)
  6. {
  7. struct klist_waiter waiter;
  8. waiter.node = n;
  9. waiter.process = current;
  10. waiter.woken = 0;
  11. spin_lock(&klist_remove_lock);
  12. list_add(&waiter.list, &klist_remove_waiters);
  13. spin_unlock(&klist_remove_lock);
  14. klist_del(n);
  15. for (;;) {
  16. set_current_state(TASK_UNINTERRUPTIBLE);
  17. if (waiter.woken)
  18. break;
  19. schedule();
  20. }
  21. __set_current_state(TASK_RUNNING);
  22. }

klist_remove()不但会调用klist_del()减少引用计数，还会一直阻塞到节点被删除。这个函数才是请求删除节点的线程应该调用的。

[cpp] view plaincopy print?
  1. int klist_node_attached(struct klist_node *n)
  2. {
  3. return (n->n_klist != NULL);
  4. }

klist_node_attached()检查节点是否被包含在某链表中。

以上是klist的链表初始化，节点加入，节点删除函数。下面是klist链表遍历函数。

[cpp] view plaincopy print?
  1. struct klist_iter {
  2. struct klist        *i_klist;
  3. struct klist_node   *i_cur;
  4. };
  5. extern void klist_iter_init(struct klist *k, struct klist_iter *i);
  6. extern void klist_iter_init_node(struct klist *k, struct klist_iter *i,
  7. struct klist_node *n);
  8. extern void klist_iter_exit(struct klist_iter *i);
  9. extern struct klist_node *klist_next(struct klist_iter *i);

klist的遍历有些复杂，因为它考虑到了在遍历过程中节点删除的情况，而且还要忽略那些已被删除的节点。宏实现已经无法满足要求，迫不得已，只能用函数实现，并用struct klist_iter记录中间状态。

[cpp] view plaincopy print?
  1. void klist_iter_init_node(struct klist *k, struct klist_iter *i,
  2. struct klist_node *n)
  3. {
  4. i->i_klist = k;
  5. i->i_cur = n;
  6. if (n)
  7. kref_get(&n->n_ref);
  8. }
  9. void klist_iter_init(struct klist *k, struct klist_iter *i)
  10. {
  11. klist_iter_init_node(k, i, NULL);
  12. }

klist_iter_init_node()是从klist中的某个节点开始遍历，而klist_iter_init()是从链表头开始遍历的。

但你又要注意，klist_iter_init()和klist_iter_init_node()的用法又不同。klist_iter_init_node()可以在其后直接对当前节点进行访问，也可以调用klist_next()访问下一节点。而klist_iter_init()只能调用klist_next()访问下一节点。或许klist_iter_init_node()的本意不是从当前节点开始，而是从当前节点的下一节点开始。

[cpp] view plaincopy print?
  1. static struct klist_node *to_klist_node(struct list_head *n)
  2. {
  3. return container_of(n, struct klist_node, n_node);
  4. }
[cpp] view plaincopy print?
  1. struct klist_node *klist_next(struct klist_iter *i)
  2. {
  3. void (*put)(struct klist_node *) = i->i_klist->put;
  4. struct klist_node *last = i->i_cur;
  5. struct klist_node *next;
  6. spin_lock(&i->i_klist->k_lock);
  7. if (last) {
  8. next = to_klist_node(last->n_node.next);
  9. if (!klist_dec_and_del(last))
  10. put = NULL;
  11. } else
  12. next = to_klist_node(i->i_klist->k_list.next);
  13. i->i_cur = NULL;
  14. while (next != to_klist_node(&i->i_klist->k_list)) {
  15. if (likely(!knode_dead(next))) {
  16. kref_get(&next->n_ref);
  17. i->i_cur = next;
  18. break;
  19. }
  20. next = to_klist_node(next->n_node.next);
  21. }
  22. spin_unlock(&i->i_klist->k_lock);
  23. if (put && last)
  24. put(last);
  25. return i->i_cur;
  26. }

klist_next()是将循环进行到下一节点。实现中需要注意两点问题：1、加锁，根据经验，单纯对某个节点操作不需要加锁，但对影响整个链表的操作需要加自旋锁。比如之前klist_iter_init_node()中对节点增加引用计数，就不需要加锁，因为只有已经拥有节点引用计数的线程才会特别地从那个节点开始。而之后klist_next()中则需要加锁，因为当前线程很可能没有引用计数，所以需要加锁，让情况固定下来。这既是保护链表，也是保护节点有效。符合kref引用计数的使用原则。2、要注意，虽然在节点切换的过程中是加锁的，但切换完访问当前节点时是解锁的，中间可能有节点被删除（这个通过spin_lock就可以搞定），也可能有节点被请求删除，这就需要注意。首先要忽略链表中已被请求删除的节点，然后在减少前一个节点引用计数时，可能就把前一个节点删除了。这里之所以不调用klist_put()，是因为本身已处于加锁状态，但仍要有它的实现。这里的实现和klist_put()中类似，代码不介意在加锁状态下唤醒另一个线程，但却不希望在加锁状态下调用put()函数，那可能会涉及释放另一个更大的结构。

[cpp] view plaincopy print?
  1. void klist_iter_exit(struct klist_iter *i)
  2. {
  3. if (i->i_cur) {
  4. klist_put(i->i_cur, false);
  5. i->i_cur = NULL;
  6. }
  7. }

klist_iter_exit()，遍历结束函数。在遍历完成时调不调无所谓，但如果想中途结束，就一定要调用klist_iter_exit()。

klist主要用于设备驱动模型中，为了适应那些动态变化的设备和驱动，而专门设计的链表。klist并不通用，但它真的很新奇。 我看到它时，震惊于链表竟然可以专门异化成这种样子。如果你是松耦合的结构，如果你手下净是些桀骜不驯的家伙，那么不要只考虑kref，你可能还需要klist。

三大链表之klist相关推荐

  1. 面试官:说说Innodb中LRU怎么做的？

    引言 某日,小编去面试(纯属瞎编),有了如下对话 面试官:"懂mysql吧,知道CPU在读硬盘上数据的时候,是怎么解决CPU和硬盘速度不一致问题么?"我:"懂啊,mysq ...

  2. linux设备驱动之总线、设备、驱动

    文章转载至多个地方,网上拼凑的一篇文章,说的好听一些的话那就叫自己总结的文章,只 是多次引用啊,哈哈,哎,不管了,反正这个有利用学习进步就好,这是重要的,文章转载过来要经过一篇大脑才能成为自己的,以后 ...

  3. Linux设备驱动程序学习-Linux设备模型（总线、设备、驱动程序和类）

    文章的例子和实验使用<LDD3>所配的lddbus模块(稍作修改). 总线 总线是处理器和一个或多个设备之间的通道,在设备模型中, 所有的设备都通过总线相连, 甚至是内部的虚拟" ...

  4. 介绍struct bus_type非常好的

    总线 总线是处理器和一个或多个设备之间的通道,在设备模型中, 所有的设备都通过总线相连, 甚至是内部的虚拟"platform"总线.总线可以相互插入.设备模型展示了总线和它们所控制 ...

  5. Linux设备驱动模型三 kset

    Linux设备驱动模型三 kset 1 kset数据结构 kset的定义在前文已有描述,我们再回顾一下: [cpp] view plain copy struct kset { /*与子kobject ...

  6. Linux设备驱动模型

    尽管LDD3中说对多数程序员掌握设备驱动模型不是必要的,但对于嵌入式Linux的底层程序员而言,对设备驱动模型的学习非常重要. Linux设备模型的目的:为内核建立一个统一的设备模型,从而又一个对系统 ...

  7. linux驱动工程面试必问知识点

    linux内核原理面试必问(由易到难) 简单型 1:linux中内核空间及用户空间的区别?用户空间与内核通信方式有哪些? 2:linux中内存划分及如何使用?虚拟地址及物理地址的概念及彼此之间的转化, ...

  8. 集合的交运算c语言函数,集合的并交运算(C语言

    <集合的并交运算(C语言>由会员分享,可在线阅读,更多相关<集合的并交运算(C语言(7页珍藏版)>请在人人文库网上搜索. 1.本文档如对你有帮助,请帮忙下载支持!题目一:集合的 ...

  9. Linux 设备驱动那些事

    目的 初步了解 linux 设备驱动框架模型 初步了解设备驱动模型有哪些元素 设备驱动模型元素的说明及解释 设备驱动模型元素的工作原理 设备驱动模型的小例子 对整体有个粗略的了解,设备驱动类型种类太多 ...

最新文章

  1. 【转载】程序员有哪些电脑技能让外行感到神奇？
  2. leetcode 146.缓存机制（中等）
  3. SVN迁移历史日志记录笔记
  4. db2关闭下一句sql的日志_DB2_数据库日志管理
  5. Cloud for Customer的contact主数据function字段下拉菜单的绘制原理
  6. python异常处理优点_python自测100题（下）
  7. mixin network_【译文】Mixin——以最高的安全性满足所有区块链资产的交易需求
  8. asp.net记录错误日志的方法
  9. 明明还有空间，硬盘却写不进去了！
  10. 布局管理器 4----- 相对布局
  11. 李宏毅机器学习——迁移学习
  12. 前端性能优化（十一）
  13. 微信小程序获取屏幕高度
  14. HDU -2191 悼念512汶川大地震遇难同胞——珍惜现在，感恩生活（DP，贪心）
  15. JS实现waterfall
  16. VRRP协议及实验配置
  17. 视频（mp4文件）批量转换成动图（gif文件）
  18. 算法竞赛入门经典 例题6-16
  19. 使用Python实现滚动的广告屏幕
  20. 前端工程化精讲第七课 低代码工具：如何用更少的代码实现更灵活的需求？

热门文章

  1. 软件开发工作流-GitFlow
  2. VPS虚拟服务器简介
  3. 每日一题:由卢卡斯队列引出java四舍五入
  4. java 中 if else 和else if区别
  5. WindowsMobile应该如何发展？-2(未完待续)
  6. Android之高仿墨迹天气桌面组件(AppWidgetProvider) .
  7. 第4周作业-项目技术指标（招标文件）
  8. 搜集的一些机器学习和数据挖掘的实践项目
  9. tp5分页遇到的问题
  10. Zookeeper+Hadoop+Hbase+Hive+Kylin+Nginx集群搭建三(zookeeper篇)