linux内核部件分析（三）——记录生命周期的kref

来源：互联网发布：怎么投诉淘宝卖家手机编辑：程序博客网时间：2024/05/29 10:38

分类： linux内核学习 2011-10-02 21:21895人阅读评论(1)收藏举报

linux内核structlist数据结构api制造

kref是一个引用计数器，它被嵌套进其它的结构中，记录所嵌套结构的引用计数，并在计数清零时调用相应的清理函数。kref的原理和实现都非常简单，但要想用好却不容易，或者说kref被创建就是为了跟踪复杂情况下地结构引用销毁情况。所以这里先介绍kref的实现，再介绍其使用规则。

kref的头文件在include/linux/kref.h，实现在lib/kref.c。闲话少说，上代码。

[cpp]view plaincopyprint?

1 struct kref {

2 atomic_t refcount;

3 };

可以看到，kref的结构中就包含一个atomic_t类型的计数值。atomic_t是原子类型，对其操作都要求是原子执行的，有专门的原子操作API执行，即使在多处理器间也保持原子性。使用atomic_t类型充当计数值，就省去了加锁去锁的过程。

[cpp]view plaincopyprint?

4 void kref_set(struct kref *kref, int num)

5 {

6 atomic_set(&kref->refcount, num);

7 smp_mb();

8 }

kref_set 设置kref的初始计数值。具体计数值设置由原子操作atomic_set完成。之后还有一个smp_mb()是为了增加内存屏障，保证这一写操作会在之后的读写操作完成之前完成。

[cpp]view plaincopyprint?

9 void kref_init(struct kref *kref)

10 {

11 kref_set(kref, 1);

12 }

kref_init 初始化kref的计数值为1。

[cpp]view plaincopyprint?

13 void kref_get(struct kref *kref)

14 {

15 WARN_ON(!atomic_read(&kref->refcount));

16 atomic_inc(&kref->refcount);

17 smp_mb__after_atomic_inc();

18 }

kref_get递增kref的计数值。

[cpp]view plaincopyprint?

19 int kref_put(struct kref *kref, void (*release)(struct kref *kref))

20 {

21 WARN_ON(release == NULL);

22 WARN_ON(release == (void (*)(struct kref *))kfree);

24 if (atomic_dec_and_test(&kref->refcount)) {

25 release(kref);

26 return 1;

27 }

28 return 0;

29 }

kref_put递减kref的计数值，如果计数值减为0，说明kref所指向的结构生命周期结束，会执行release释放函数。

所以说kref的API很简单，kref_init和kref_set基本都是初始时才会用到，平时常用的就是kref_get和kref_put。一旦在kref_put时计数值清零，立即调用结束函数。

kref设计得如此简单，是为了能灵活地用在各种结构的生命周期管理中。要用好它可不简单，好在Documentation/kref.txt中为我们总结了一些使用规则，下面简单翻译一下。

对于那些用在多种场合，被到处传递的结构，如果没有引用计数，bug几乎总是肯定的事。所以我们需要kref。kref允许我们在已有的结构中方便地添加引用计数。

你可以以如下方式添加kref到你的数据结构中：

[cpp]view plaincopyprint?

30 struct my_data {

31 ...

32 struct kref refcount;

33 ...

34 };

kref可以出现在你结构中的任意位置。

在分配kref后你必须初始化它，可以调用kref_init，把kref计数值初始为1。

[cpp]view plaincopyprint?

35 struct my_data *data;

37 data = kmalloc(sizeof(*data), GFP_KERNEL);

38 if(!data)

39 return -ENOMEM;

40 kref_init(&data->refcount);

初始化之后，kref的使用应该遵循以下三条规则：

1）如果你制造了一个结构指针的非暂时性副本，特别是当这个副本指针会被传递到其它执行线程时，你必须在传递副本指针之前执行kref_get：

[cpp]view plaincopyprint?

41 kref_put(&data->refcount);

2）当你使用完，不再需要结构的指针，必须执行kref_put。如果这是结构指针的最后一个引用，release函数会被调用。如果代码绝不会在没有拥有引用计数的请求下去调用kref_get，在kref_put时就不需要加锁。

[cpp]view plaincopyprint?

42 kref_put(&data->refcount, data_release);

3）如果代码试图在还没拥有引用计数的情况下就调用kref_get，就必须串行化kref_put和kref_get的执行。因为很可能在kref_get执行之前或者执行中，kref_put就被调用并把整个结构释放掉了。

例如，你分配了一些数据并把它传递到其它线程去处理：

[cpp]view plaincopyprint?

43 void data_release(struct kref *kref)

44 {

45 struct my_data *data = container_of(kref, struct my_data, refcount);

46 kree(data);

47 }

49 void more_data_handling(void *cb_data)

50 {

51 struct my_data *data = cb_data;

52 .

53 . do stuff with data here

54 .

55 kref_put(&data->refcount, data_release);

56 }

58 int my_data_handler(void)

59 {

60 int rv = 0;

61 struct my_data *data;

62 struct task_struct *task;

63 data = kmalloc(sizeof(*data), GFP_KERNEL);

64 if (!data)

65 return -ENOMEM;

66 kref_init(&data->refcount);

67 kref_get(&data->refcount);

68 task = kthread_run(more_data_handling, data, "more_data_handling");

69 if (task == ERR_PTR(-ENOMEM)){

70 rv = -ENOMEM;

71 goto out;

72 }

73 .

74 . do stuff with data here

75 .

76 out:

77 kref_put(&data->refcount, data_release);

78 return rv;

79 }

这样做，无论两个线程的执行顺序是怎样的都无所谓，kref_put知道何时数据不再有引用计数，可以被销毁。kref_get()调用不需要加锁，因为在my_data_handler中调用kref_get时已经拥有一个引用。同样地原因，kref_put也不需要加锁。

要注意规则一中的要求，必须在传递指针之前调用kref_get。决不能写下面的代码：

[cpp]view plaincopyprint?

80 task = kthread_run(more_data_handling, data, "more_data_handling");

81 if(task == ERR_PTR(-ENOMEM)) {

82 rv = -ENOMEM;

83 goto out;

84 }

85 else {

86 /* BAD BAD BAD - get is after the handoff */

87 kref_get(&data->refcount);

不要认为自己在使用上面的代码时知道自己在做什么。首先，你可能并不知道你在做什么。其次，你可能知道你在做什么（在部分加锁情况下上面的代码也是正确的），但一些修改或者复制你代码的人并不知道你在做什么。这是一种坏的使用方式。

当然在部分情况下也可以优化对get和put的使用。例如，你已经完成了对这个数据的处理，并要把它传递给其它线程，就不需要再做多余的get和put了。

[cpp]view plaincopyprint?

88 /* Silly extra get and put */

89 kref_get(&obj->ref);

90 enqueue(obj);

91 kref_put(&obj->ref, obj_cleanup);

只需要做enqueue操作即可，可以在其后加一条注释。

[cpp]view plaincopyprint?

92 enqueue(obj);

93 /* We are done with obj , so we pass our refcount off to the queue. DON'T TOUCH obj AFTER HERE! */

第三条规则是处理起来最麻烦的。例如，你有一列数据，每条数据都有kref计数，你希望获取第一条数据。但你不能简单地把第一条数据从链表中取出并调用kref_get。这违背了第三条，在调用kref_get前你并没有一个引用。你需要增加一个mutex（或者其它锁）。

[cpp]view plaincopyprint?

94 static DEFINE_MUTEX(mutex);

95 static LIST_HEAD(q);

96 struct my_data

97 {

98 struct kref refcount;

99 struct list_head link;

100 };

101

102 static struct my_data *get_entry()

103 {

104 struct my_data *entry = NULL;

105 mutex_lock(&mutex);

106 if(!list_empty(&q)){

107 entry = container_of(q.next, struct my_q_entry, link);

108 kref_get(&entry->refcount);

109 }

110 mutex_unlock(&mutex);

111 return entry;

112 }

113

114 static void release_entry(struct kref *ref)

115 {

116 struct my_data *entry = container_of(ref, struct my_data, refcount);

117

118 list_del(&entry->link);

119 kfree(entry);

120 }

121

122 static void put_entry(struct my_data *entry)

123 {

124 mutex_lock(&mutex);

125 kref_put(&entry->refcount, release_entry);

126 mutex_unlock(&mutex);

127 }

如果你不想在整个释放过程中都加锁，kref_put的返回值就有用了。例如你不想在加锁情况下调用kfree，你可以如下使用kref_put。

[cpp]view plaincopyprint?

128 static void release_entry(struct kref *ref)

129 {

130

131 }

132

133 static void put_entry(struct my_data *entry)

134 {

135 mutex_lock(&mutex);

136 if(kref_put(&entry->refcount, release_entry)){

137 list_del(&entry->link);

138 mutex_unlock(&mutex);

139 kfree(entry);

140 }

141 else

142 mutex_unlock(&mutex);

143 }

如果你在撤销结构的过程中需要调用其它的需要较长时间的函数，或者函数也可能要获取同样地互斥锁，这样做就很有用了。但要注意在release函数中做完撤销工作会使代码看起来更整洁。