map.c 添加注釋，map.c注釋
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;
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 }
http://xxxxxx/Linuxjc/1144279.html TechArticle
