map.c 添加注释

注释仅代表个人理解，难免有错误之处，仅供参考！

1 /*

2 * linux/drivers/base/map.c

3 *

4 * (C) Copyright Al Viro 2002,2003

5 * Released under GPL v2.

6 *

7 * NOTE: data structure needs to be changed. It works, but for large dev_t

8 * it will be too slow. It is isolated, though, so these changes will be

9 * local to that file.

10 */

11

12 #include <linux/module.h>

13 #include <linux/slab.h>

14 #include <linux/mutex.h>

15 #include <linux/kdev_t.h>

16 #include <linux/kobject.h>

17 #include <linux/kobj_map.h>

18

19 struct kobj_map {

20 struct probe {

21 struct probe *next;

22 dev_t dev;

23 unsigned long range;

24 struct module *owner;

25 kobj_probe_t *get;

26 int (*lock)(dev_t, void *);

27 void *data;

28 } *probes[255];

29 struct mutex *lock;

30 };

31

32 int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,

33 struct module *module, kobj_probe_t *probe,

34 int (*lock)(dev_t, void *), void *data)

35 {

36 /* [cgw]: 计算MAJOR(dev)到MAJOR(dev + range - 1)有几个

37 * 主设备，由于主设备号都一样，所以这里n = 1

38 */

39 unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;

40 /* [cgw]: 以主设备号为索引 */

41 unsigned index = MAJOR(dev);

42 unsigned i;

43 struct probe *p;

44

45 /* [cgw]: 主设备超出255个 */

46 if (n > 255)

47 n = 255;

48 /* [cgw]: 分配n个struct probe内存空间*/

49 p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);

50 /* [cgw]: 分配失败*/

51 if (p == NULL)

52 return -ENOMEM;

53 /* [cgw]: 填装n个struct probe，对应n个主设备号

54 *

55 */

56 for (i = 0; i < n; i++, p++) {

57 p->owner = module;

58 p->get = probe;

59 p->lock = lock;

60 p->dev = dev;

61 p->range = range;

62 p->data = data;

63 }

64 /* [cgw]: 进入临界区*/

65 mutex_lock(domain->lock);

66 /* [cgw]: 这里p -= n是因为，在以上for循环中，p++了n次 */

67 for (i = 0, p -= n; i < n; i++, p++, index++) {

68 /* [cgw]: 根据当前索引，从probes[]中

69 * 取出一个probe

70 */

71 struct probe **s = &domain->probes[index % 255];

72 /* [cgw]: probe是一个链表，每个新加入的节点，

73 * 按照其range的大小，从小到大排列，即头结点的

74 * range是最小的

75 */

76 while (*s && (*s)->range < range)

77 /* [cgw]: 继续查找下一个probe，直到其range大于

78 * 或等于新加入probe的range为止

79 */

80 s = &(*s)->next;

81 /* [cgw]: 找到了一个probe，其range大于或等于新加入

82 * probe的range，把这个新加入的probe下一节点指向

83 * 这个probe节点

84 */

85 p->next = *s;

86 /* [cgw]: 新加入的节点代替旧的位置 */

87 *s = p;

88 }

89 /* [cgw]: 退出临界区*/

90 mutex_unlock(domain->lock);

91 return 0;

92 }

93

94 void kobj_unmap(struct kobj_map *domain, dev_t dev, unsigned long range)

95 {

96 /* [cgw]: 计算MAJOR(dev)到MAJOR(dev + range - 1)有几个

97 * 主设备，由于主设备号都一样，所以这里n = 1

98 */

99 unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;

/* [cgw]: 以主设备号为索引 */

unsigned index = MAJOR(dev);

unsigned i;

struct probe *found = NULL;

/* [cgw]: 主设备超出255个 */

if (n > 255)

n = 255;

/* [cgw]: 进入临界区*/

mutex_lock(domain->lock);

for (i = 0; i < n; i++, index++) {

struct probe **s;

for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) {

struct probe *p = *s;

/* [cgw]: 找到这个设备，并且其对应的次设备号个数也匹配 */

if (p->dev == dev && p->range == range) {

/* [cgw]: 这个设备对应的节点，被下一节点取代，即移除

* 这个节点

*/

*s = p->next;

/* [cgw]: 记录这个节点 */

if (!found)

found = p;

break;

}

}

}

/* [cgw]: 退出临界区*/

mutex_unlock(domain->lock);

/* [cgw]: 释放这个节点对应的内存空间 */

kfree(found);

}

struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int *index)

{

struct kobject *kobj;

struct probe *p;

unsigned long best = ~0UL;

retry: /* [cgw]: 重试 */

/* [cgw]: 进入临界区 */

mutex_lock(domain->lock);

/* [cgw]: 以主设备号为索引，从probes数组取出一个probe */

for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) {

struct kobject *(*probe)(dev_t, int *, void *);

struct module *owner;

void *data;

/* [cgw]: 取出的这个probe对应的设备号大于要查找的设备号

* 或 这个probe对应的设备号的最大次设备号小于要查找的设备号

* 即不在查找范围内，那么返回，继续取出下一个probe

*/

if (p->dev > dev || p->dev + p->range - 1 < dev)

continue;

/* [cgw]: 连续的次设备号个数超过最大范围，出错

*/

if (p->range - 1 >= best)

break;

/* [cgw]: 模块引用失败???? */

if (!try_module_get(p->owner))

continue;

/* [cgw]: 到此，找到了我们想要的那个probe，接着提取它的值 */

owner = p->owner;

data = p->data;

probe = p->get;

best = p->range - 1;

/* [cgw]: 计算这个要找的设备的次设备号，相对于找到的probe对应

* 设备号的次设备号的偏移，因为找到的probe对应设备号的次设备号

* 是这个设备的次设备号基址

*/

*index = dev - p->dev;

/* [cgw]: 未搞明白这个判断的意思 */

if (p->lock && p->lock(dev, data) < 0) {

/* [cgw]: 放弃模块使用权???? */

module_put(owner);

continue;

}

/* [cgw]: 退出临界区 */

mutex_unlock(domain->lock);

/* [cgw]: 调用probe的实现函数，并返回对应的kobj */

kobj = probe(dev, index, data);

/* Currently ->owner protects _only_ ->probe() itself. */

/* [cgw]: 放弃模块使用权???? */

module_put(owner);

/* [cgw]: 获得kobj，退出 */

if (kobj)

return kobj;

goto retry;

}

/* [cgw]: 退出临界区 */

mutex_unlock(domain->lock);

return NULL;

}

struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)

{

/* [cgw]: 分配一个struct kobj_map内存空间 */

struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);

/* [cgw]: 分配一个struct probe指针内存空间 */

struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);

int i;

/* [cgw]: 分配失败 */

if ((p == NULL) || (base == NULL)) {

/* [cgw]: 释放内存空间 */

kfree(p);

kfree(base);

return NULL;

}

/* [cgw]: 设置默认设备号为1，连续range个次设备，设置probe的实现

* 函数(回调)

*/

base->dev = 1;

base->range = ~0;

base->get = base_probe;

/* [cgw]: 设置probes数组的初始值 */

for (i = 0; i < 255; i++)

p->probes[i] = base;

p->lock = lock;
219 return p;

220 }