cdev_类别函数,增添注释

2019-08-29 作者:www.bifa365365.com   |   浏览(198)

map.c 添加注释,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;
www.bifa365365.com, 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;
100     /* [cgw]: 以主设备号为索引 */
101     unsigned index = MAJOR(dev);
102     unsigned i;
103     struct probe *found = NULL;
104     /* [cgw]: 主设备超出255个 */
105     if (n > 255)
106         n = 255;
107     /* [cgw]: 进入临界区*/
108     mutex_lock(domain->lock);
109     
110     for (i = 0; i < n; i , index ) {
111         struct probe **s;
112         for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) {
113             struct probe *p = *s;
114             /* [cgw]: 找到这个设备,并且其对应的次设备号个数也匹配 */
115             if (p->dev == dev && p->range == range) {
116                 /* [cgw]: 这个设备对应的节点,被下一节点取代,即移除
117                       * 这个节点
118                       */
119                 *s = p->next;
120                 /* [cgw]: 记录这个节点 */
121                 if (!found)
122                     found = p;
123                 break;
124             }
125         }
126     }
127     /* [cgw]: 退出临界区*/
128     mutex_unlock(domain->lock);
129     /* [cgw]: 释放这个节点对应的内存空间 */
130     kfree(found);
131 }
132 
133 struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int *index)
134 {
135     struct kobject *kobj;
136     struct probe *p;
137     unsigned long best = ~0UL;
138 
139 retry:  /* [cgw]: 重试 */
140     /* [cgw]: 进入临界区 */
141     mutex_lock(domain->lock);
142     /* [cgw]: 以主设备号为索引,从probes数组取出一个probe */
143     for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) {
144         struct kobject *(*probe)(dev_t, int *, void *);
145         struct module *owner;
146         void *data;
147 
148         /* [cgw]: 取出的这个probe对应的设备号大于要查找的设备号
149                   * 或 这个probe对应的设备号的最大次设备号小于要查找的设备号
150                   * 即不在查找范围内,那么返回,继续取出下一个probe
151                   */
152         if (p->dev > dev || p->dev   p->range - 1 < dev)
153             continue;
154         /* [cgw]: 连续的次设备号个数超过最大范围,出错
155           */
156         if (p->range - 1 >= best)
157             break;
158         /* [cgw]: 模块引用失败???? */
159         if (!try_module_get(p->owner))
160             continue;
161         /* [cgw]: 到此,找到了我们想要的那个probe,接着提取它的值 */
162         owner = p->owner;
163         data = p->data;
164         probe = p->get;
165         best = p->range - 1;
166         /* [cgw]: 计算这个要找的设备的次设备号,相对于找到的probe对应
167           * 设备号的次设备号的偏移,因为找到的probe对应设备号的次设备号
168           * 是这个设备的次设备号基址
169           */
170         *index = dev - p->dev;
171         /* [cgw]: 未搞明白这个判断的意思 */
172         if (p->lock && p->lock(dev, data) < 0) {
173             /* [cgw]: 放弃模块使用权???? */
174             module_put(owner);
175             continue;
176         }
177         /* [cgw]: 退出临界区 */
178         mutex_unlock(domain->lock);
179         /* [cgw]: 调用probe的实现函数,并返回对应的kobj */
180         kobj = probe(dev, index, data);
181         /* Currently ->owner protects _only_ ->probe() itself. */
182         /* [cgw]: 放弃模块使用权???? */
183         module_put(owner);
184         /* [cgw]: 获得kobj,退出 */
185         if (kobj)
186             return kobj;
187         goto retry;
188     }
189     /* [cgw]: 退出临界区 */
190     mutex_unlock(domain->lock);
191     return NULL;
192 }
193 
194 struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)
195 {
196     /* [cgw]: 分配一个struct kobj_map内存空间 */
197     struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);
198     /* [cgw]: 分配一个struct probe指针内存空间 */
199     struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);
200     int i;
201 
202     /* [cgw]: 分配失败 */
203     if ((p == NULL) || (base == NULL)) {
204         /* [cgw]: 释放内存空间 */
205         kfree(p);
206         kfree(base);
207         return NULL;
208     }
209     /* [cgw]: 设置默认设备号为1,连续range个次设备,设置probe的实现
210           * 函数(回调)
211           */
212     base->dev = 1;
213     base->range = ~0;
214     base->get = base_probe;
215     /* [cgw]: 设置probes数组的初始值 */
216     for (i = 0; i < 255; i )
217         p->probes[i] = base;
218     p->lock = lock; 

219     return p;

220 }

添加注释,map.c注释 注释仅代表个人理解,难免有错误之处,仅供参考! 1 /* 2 *linux/drivers/base/map.c 3 * 4 *(C)CopyrightAlViro2002,2003 5 *Releas...

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

内核中每个字符设备都对应一个 cdev 结构的变量,下面是它的定义:

  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;
100     /* [cgw]: 以主设备号为索引 */
101     unsigned index = MAJOR(dev);
102     unsigned i;
103     struct probe *found = NULL;
104     /* [cgw]: 主设备超出255个 */
105     if (n > 255)
106         n = 255;
107     /* [cgw]: 进入临界区*/
108     mutex_lock(domain->lock);
109     
110     for (i = 0; i < n; i , index ) {
111         struct probe **s;
112         for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) {
113             struct probe *p = *s;
114             /* [cgw]: 找到这个设备,并且其对应的次设备号个数也匹配 */
115             if (p->dev == dev && p->range == range) {
116                 /* [cgw]: 这个设备对应的节点,被下一节点取代,即移除
117                       * 这个节点
118                       */
119                 *s = p->next;
120                 /* [cgw]: 记录这个节点 */
121                 if (!found)
122                     found = p;
123                 break;
124             }
125         }
126     }
127     /* [cgw]: 退出临界区*/
128     mutex_unlock(domain->lock);
129     /* [cgw]: 释放这个节点对应的内存空间 */
130     kfree(found);
131 }
132 
133 struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int *index)
134 {
135     struct kobject *kobj;
136     struct probe *p;
137     unsigned long best = ~0UL;
138 
139 retry:  /* [cgw]: 重试 */
140     /* [cgw]: 进入临界区 */
141     mutex_lock(domain->lock);
142     /* [cgw]: 以主设备号为索引,从probes数组取出一个probe */
143     for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) {
144         struct kobject *(*probe)(dev_t, int *, void *);
145         struct module *owner;
146         void *data;
147 
148         /* [cgw]: 取出的这个probe对应的设备号大于要查找的设备号
149                   * 或 这个probe对应的设备号的最大次设备号小于要查找的设备号
150                   * 即不在查找范围内,那么返回,继续取出下一个probe
151                   */
152         if (p->dev > dev || p->dev   p->range - 1 < dev)
153             continue;
154         /* [cgw]: 连续的次设备号个数超过最大范围,出错
155           */
156         if (p->range - 1 >= best)
157             break;
158         /* [cgw]: 模块引用失败???? */
159         if (!try_module_get(p->owner))
160             continue;
161         /* [cgw]: 到此,找到了我们想要的那个probe,接着提取它的值 */
162         owner = p->owner;
163         data = p->data;
164         probe = p->get;
165         best = p->range - 1;
166         /* [cgw]: 计算这个要找的设备的次设备号,相对于找到的probe对应
167           * 设备号的次设备号的偏移,因为找到的probe对应设备号的次设备号
168           * 是这个设备的次设备号基址
169           */
170         *index = dev - p->dev;
171         /* [cgw]: 未搞明白这个判断的意思 */
172         if (p->lock && p->lock(dev, data) < 0) {
173             /* [cgw]: 放弃模块使用权???? */
174             module_put(owner);
175             continue;
176         }
177         /* [cgw]: 退出临界区 */
178         mutex_unlock(domain->lock);
179         /* [cgw]: 调用probe的实现函数,并返回对应的kobj */
180         kobj = probe(dev, index, data);
181         /* Currently ->owner protects _only_ ->probe() itself. */
182         /* [cgw]: 放弃模块使用权???? */
183         module_put(owner);
184         /* [cgw]: 获得kobj,退出 */
185         if (kobj)
186             return kobj;
187         goto retry;
188     }
189     /* [cgw]: 退出临界区 */
190     mutex_unlock(domain->lock);
191     return NULL;
192 }
193 
194 struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)
195 {
196     /* [cgw]: 分配一个struct kobj_map内存空间 */
197     struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);
198     /* [cgw]: 分配一个struct probe指针内存空间 */
199     struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);
200     int i;
201 
202     /* [cgw]: 分配失败 */
203     if ((p == NULL) || (base == NULL)) {
204         /* [cgw]: 释放内存空间 */
205         kfree(p);
206         kfree(base);
207         return NULL;
208     }
209     /* [cgw]: 设置默认设备号为1,连续range个次设备,设置probe的实现
210           * 函数(回调)
211           */
212     base->dev = 1;
213     base->range = ~0;
214     base->get = base_probe;
215     /* [cgw]: 设置probes数组的初始值 */
216     for (i = 0; i < 255; i )
217         p->probes[i] = base;
218     p->lock = lock; 

linux-2.6.22/include/linux/cdev.h
struct cdev {
   struct kobject kobj;          // 每个 cdev 都是一个 kobject
   struct module *owner;       // 指向实现驱动的模块
   const struct file_operations *ops;   // 操纵这个字符设备文件的方法
   struct list_head list;       // 与 cdev 对应的字符设备文件的 inode->i_devices 的链表头
   dev_t dev;                   // 起始设备编号
   unsigned int count;       // 设备范围号大小
};

219     return p;

一个 cdev 一般它有两种定义初始化方式:静态的和动态的。
静态内存定义初始化:
struct cdev my_cdev;
cdev_init(&my_cdev, &fops);
my_cdev.owner = THIS_MODULE;

220 }

动态内存定义初始化:
struct cdev *my_cdev = cdev_alloc();
my_cdev->ops = &fops;
my_cdev->owner = THIS_MODULE;

两种使用方式的功能是一样的,只是使用的内存区不一样,一般视实际的数据结构需求而定。

下面贴出了两个函数的代码,以具体看一下它们之间的差异。
struct cdev *cdev_alloc(void)
{
   struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
   if (p) {
       INIT_LIST_HEAD(&p->list);
       kobject_init(&p->kobj, &ktype_cdev_dynamic);
   }
   return p;
}

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
   memset(cdev, 0, sizeof *cdev);
   INIT_LIST_HEAD(&cdev->list);
   kobject_init(&cdev->kobj, &ktype_cdev_default);
   cdev->ops = fops;
}
由此可见,两个函数完成都功能基本一致,只是 cdev_init() 还多赋了一个 cdev->ops 的值。

初始化 cdev 后,需要把它添加到系统中去。为此可以调用 cdev_add() 函数。传入 cdev 结构的指针,起始设备编号,以及设备编号范围。
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
   p->dev = dev;
   p->count = count;
   return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}

内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。kobj_map() 函数就是用来把字符设备编号和 cdev 结构变量一起保存到 cdev_map 这个散列表里。当后续要打开一个字符设备文件时,通过调用 kobj_lookup() 函数,根据设备编号就可以找到 cdev 结构变量,从而取出其中的 ops 字段。

kobj_map函数中哈希表的实现原理和前面注册分配设备号中的几乎完全一样,通过 要加入系统的设备的主设备号major(major=MAJOR(dev))来获得probes数组的索引值i(i = major % 255),然后把一个类型为struct probe的节点对象加入到probes[i]所管理的链表中,如图2-6所示。其中struct probe所在的矩形块中的深色部分是我们重点关注的内容,记录了当前正在加入系统的字符设备对象的有关信息。其中,dev是它的设备号,range是从 次设备号开始连续的设备数量,data是一void *变量,指向当前正要加入系统的设备对象指针p。图2-6展示了两个满足主设备号major % 255 = 2的字符设备通过调用cdev_add之后,cdev_map所展现出来的数据结构状态。

 
图2-6  通过cdev_add向系统中加入设备

所以,简单地说,设备驱动程序通过调用cdev_add把它所管理的设备对象的指针嵌入到一个类型为struct probe的节点之中,然后再把该节点加入到cdev_map所实现的哈希链表中。

对系统而言,当设备驱动程序成功调用了cdev_add之后,就意味着一个字符设备对象已经加入到了系统,在需要的时候,系统就可以找到它。对用户态的程序而言,cdev_add调用之后,就已经可以通过文件系统的接口呼叫到我们的驱动程序。

当一个字符设备驱动不再需要的时候(比如模块卸载),就可以用 cdev_del() 函数来释放 cdev 占用的内存。
void cdev_del(struct cdev *p)
{
   cdev_unmap(p->dev, p->count);
   kobject_put(&p->kobj);
}
其中 cdev_unmap() 调用 kobj_unmap() 来释放 cdev_map 散列表中的对象。kobject_put() 释放 cdev 结构本身。

本文由www.bifa365365.com发布于www.bifa365365.com,转载请注明出处:cdev_类别函数,增添注释

关键词: www.bifa3653