udev\mdev創建設備節點

1. 一、概述
2. （1）udev是構建在linux的sysfs之上的是一個一個用戶程序，它能夠根據系統中的硬件設備的狀態動態更新設備文件，包括設備文件的創建，刪除等，設備文件通常放在/dev目錄下。使用udev後，在/dev目錄下就只包含系統中真正存在的設備。udev的的工作過程大致是這樣的：
3.  
4. 1. 當內核檢測到在系統中出現了新設備後，內核會在sysfs文件系統中爲該新設備生成一項新的記錄，新記錄是以文件或目錄的方式來表示，每個文件都包含有特定的信息。
5.  
6. 2. udev在系統中是以守護進程的方式運行，它通過某種途徑檢測到新設備的出現，通過查找設備對應的sysfs中的記錄得到設備的信息。
7.  
8. 3. udev會根據/etc/udev/udev.conf文件中的udev_rules指定的目錄，逐個檢查該目錄下的文件，這個目錄下的文件都是針對某類或某個設備應該施行什麼措施的規則文件。udev讀取文件是按照文件名的ASCII字母順序來讀取的，如果udev一旦找到了與新加入的設備匹配的規則，udev就會根據規則定義的措施對新設備進行配置。同時不再讀後續的規則文件。
9.  
10. （2）udev的工作可以簡單的概括爲：監控系統中設備狀態的變化，當有設備的狀態發生變化時，根據用戶的配置對設備文件執行相應的操作。
11.  
12. （3）udev的配置規則
13. udev的全局的配置文件是/etc/udev/udev.conf，該文件一般缺省有這樣幾項：
14. udev_root="/dev" #udev產生的設備文件的根目錄是/dev
15. udev_rules="/etc/udev/rules.d" #用於指導udev工作的規則所在目錄。
16. udev_log="err" #當出現錯誤時，用syslog記錄錯誤信息。
17. 其中最關鍵的就是規則文件，即/etc/udev/rules.d/目錄下的文件，udev是按照文件名的ASCII字母順序來讀取的，一旦找到與設備匹配的規則，就運用該規則，並不再讀後續的規則文件了。下面簡單看下udev定義了那些規則，以及它是如何進行配置的，怎樣去編寫這種規則文件。
18.  
19. udev的規則文件以行爲單位，以"#"開頭的行代表註釋行。其餘的每一行代表一個規則。每個規則分成一個或多個“匹配”和“賦值”部分。“匹配”部分用“匹配“專用的關鍵字來表示，相應的“賦值”部分用“賦值”專用的關鍵字來表示。“匹配”關鍵字包括：ACTION，KERNEL，BUS， SYSFS等等，“賦值”關鍵字包括：NAME，SYMLINK，OWNER等等。具體詳細的描述可以閱讀udev的man文檔。下面通過一個具體的例子來說明，看如下的規則:
20.  
21. # PCI device 0x8086:0x1096 (e1000e)
22. SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:19:21:ff:cc:7c", ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"
23.  
24. 這個規則中的“匹配”部分有四項，分別是SUBSYSTEM，ACTION，DRIVERS，KERNEL。而"賦值"部分有一項，是NAME。這個規則就是說，當系統中出現的新硬件屬於net子系統範疇，系統對該硬件採取的動作是加入這個硬件，且這個硬件在DRIVERS信息中的address="00:19:21:ff:cc:7c"，dev_id="0x0"，內核的命名爲eth*時，udev會在建立新的網絡設備，並命名爲eth0。udev規則文件的編寫可以參考man手冊。
25.  
26. 二、udev自動生成設備節點
27. 生成設備文件節點的方法有三個：1.手動mknod 2.利用devfs 3.利用udev
28.  
29. udev是硬件平臺無關的，屬於user space的進程，它脫離驅動層的關聯而建立在操作系統之上，基於這種設計實現，我們可以隨時修改及刪除/dev下的設備文件名稱和指向，隨心所欲地按照我們的願望安排和管理設備文件系統，而完成如此靈活的功能只需要簡單地修改udev的配置文件即可，無需重新啓動操作系統。udev已經使得我們對設備的管理如探囊取物般輕鬆自如。
30.  
31. 內核中定義了struct class 結構體，顧名思義，一個struct class 結構體類型變量對應一個類，內核同時提供了class_create() 函數，可以用它來創建一個類，這個類存放於sysfs 下面，一旦創建好了這個類，再調用device_create() 函數來在/dev目錄下創建相應的設備節點。這樣，加載模塊的時候，用戶空間中的udev會自動響應device_create() 函數，去/sysfs 下尋找對應的類從而創建設備節點。
32.  
33. struct class {
34.     const char * name;
35.     struct module * owner;
36.     nbsp; struct kset subsys;
37.     struct list_head devices;
38.     struct list_head interfaces;
39.     struct kset class_dirs;
40.     struct semaphore sem; /* locks children, devices, interfaces */
41.     struct class_attribute * class_attrs;
42.     struct device_attribute * dev_attrs;
43.     int ( * dev_uevent) ( struct device * dev, struct kobj_uevent_env * env) ;
44.     void ( * class_release) ( struct class * class ) ;
45.     void ( * dev_release) ( struct device * dev) ;
46.     int ( * suspend) ( struct device * dev, pm_message_t state) ;
47.     int ( * resume) ( struct device * dev) ;
48. } ;
49.  
50. //第一個參數指定類的所有者是哪個模塊，第二個參數指定類名。
51. struct class * class_create( struct module * owner, const char * name)
52. {
53.     struct class * cls;
54.     int retval;
55.     cls = kzalloc( sizeof ( * cls) , GFP_KERNEL) ;//分配一個類結構
56.     if ( ! cls) {
57.     retval = - ENOMEM;
58.     goto error ;
59.     }
60.     cls- > name = name;
61.     cls- > owner = owner;
62.     cls- > class_release = class_create_release;
63.     retval = class_register( cls) ;//註冊這個類，即在/sys/class目錄下添加目錄
64.     if ( retval)
65.         goto error ;
66.     return cls;
67. error :
68.     kfree( cls) ;
69.     return ERR_PTR( retval) ;
70. }
71.  
72. //第一個參數指定所要創建的設備所從屬的類，第二個參數是這個設備的父設備，如果沒有就指定爲NULL，第三個參數是設備號，第四個參數是設備名稱，第五個參數是從設備號。
73. struct device * device_create( struct class * class , struct device * parent,dev_t devt, const char * fmt, . . . )
74. {
75.     va_list vargs;
76.     struct device * dev;
77.     va_start ( vargs, fmt);
78.     //device_create_vargs函數流程：
79.     //device_create-->device_create_vargs-->device_register-->device_add-->kobject_uevent(&dev->kobj, KOBJ_ADD);-->
80.     //kobject_uevent_env(kobj, action, NULL);-->call_usermodehelper(argv[0], argv,env->envp, UMH_WAIT_EXEC);}
81.     dev = device_create_vargs( class , parent, devt, NULL , fmt, vargs) ;
82.     va_end ( vargs) ;
83.     return dev;
84. }
85.  
86. 三、事件通知
87. 在device_add()例程，其用於將一個device註冊到device model，其中調用了kobject_uevent(&dev->kobj, KOBJ_ADD)例程向用戶空間發出KOBJ_ADD 事件並輸出環境變量，以表明一個device被添加了。在《Linux設備模型淺析之設備篇》中介紹過rtc_device_register()例程 ，其最終調用device_add()例程添加了一個rtc0的device，我們就以它爲例子來完成uevent的分析。讓我們看看kobject_uevent()這個例程的代碼，如下：
88. int kobject_uevent(struct kobject *kobj, enum kobject_action action)
89. {
90.     return kobject_uevent_env(kobj, action, NULL);
91. }
92. 它又調用了kobject_uevent_env()例程，部分代碼如下：
93. int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,char *envp_ext[])
94. {
95.     struct kobj_uevent_env *env;
96.     const char *action_string = kobject_actions[action]; // 本例是“add”命令
97.     const char *devpath = NULL;
98.     const char *subsystem;
99.     struct kobject *top_kobj;
100.     struct kset *kset;
101.     struct kset_uevent_ops *uevent_ops;
102.     u64 seq;
103.     int i = 0;
104.     int retval = 0;
105.     pr_debug("kobject: '%s' (%p): %s\n",kobject_name(kobj), kobj, __func__);
106.  
107.     top_kobj = kobj;
108.     /* 找到其所屬的 kset容器，如果沒找到就從其父kobj找，一直持續下去，直到父kobj不存在 */
109.     while (!top_kobj->kset && top_kobj->parent)
110.         top_kobj = top_kobj->parent;
111.       if (!top_kobj->kset) {
112.           pr_debug("kobject: '%s' (%p): %s: attempted to send uevent ""without kset!\n", kobject_name(kobj), kobj,__func__);
113.           return -EINVAL;
114.       }
115.     /* 在本例中是devices_kset容器 */
116.     kset = top_kobj->kset;
117.     uevent_ops = kset->uevent_ops; // 本例中uevent_ops = ＆device_uevent_ops
118.     /* 回調 uevent_ops->filter ()例程，本例中是dev_uevent_filter()例程，主要是檢查是否uevent suppress*/
119.     /* skip the event, if the filter returns zero. */
120.     if (uevent_ops && uevent_ops->filter)
121.         if (!uevent_ops->filter(kset, kobj)) { // 如果不成功，即uevent suppress，則直接返回
122.             pr_debug("kobject: '%s' (%p): %s: filter function ""caused the event to drop!\n",kobject_name(kobj), kobj, __func__);
123.             return 0;
124.         }
125.     /* 回調 uevent_ops-> name ()，本例中是dev_uevent_name()例程，獲取bus或class的名字，本例中rtc0不存在bus，所以是class的名字“rtc”，後面分析 */
126.     if (uevent_ops && uevent_ops->name)
127.         subsystem = uevent_ops->name(kset, kobj);
128.     else
129.         subsystem = kobject_name(&kset->kobj);
130.     if (!subsystem) {
131.         pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the ""event to drop!\n", kobject_name(kobj), kobj,__func__);
132.         return 0;
133.     }
134.     // 獲得用於存放環境變量的buffer
135.     env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
136.     if (!env)
137.         return -ENOMEM;
138.     /* 獲取該kobj在sysfs的路徑，通過遍歷其父kobj來獲得，本例是/sys/devices/platform/s3c2410-rtc/rtc/rtc0 */
139.     devpath = kobject_get_path(kobj, GFP_KERNEL);
140.     if (!devpath) {
141.         retval = -ENOENT;
142.         goto exit;
143.     }
144.     // 添加 ACTION環境變量，本例是“add”命令
145.     retval = add_uevent_var(env, "ACTION=%s", action_string);
146.     if (retval)
147.         goto exit;
148.     // 添加 DEVPATH環境變量，本例是/sys/devices/platform/s3c2410-rtc/rtc/rtc0
149.     retval = add_uevent_var(env, "DEVPATH=%s", devpath);
150.     if (retval)
151.         goto exit;
152.     // 添加 SUBSYSTEM 環境變量，本例中是“rtc”
153.     retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
154.     if (retval)
155.         goto exit;
156.     /* keys passed in from the caller */
157.     if (envp_ext) { // 爲NULL，不執行
158.      for (i = 0; envp_ext[i]; i++) {
159.          retval = add_uevent_var(env, "%s", envp_ext[i]);
160.          if (retval)
161.              goto exit;
162.      }
163.     }
164.     // 回調 uevent_ops->uevent()，本例中是dev_uevent()例程，輸出一些環境變量，後面分析
165.     if (uevent_ops && uevent_ops->uevent) {
166.         retval = uevent_ops->uevent(kset, kobj, env);
167.      if (retval) {
168.          pr_debug("kobject: '%s' (%p): %s: uevent() returned ""%d\n", kobject_name(kobj), kobj,__func__, retval);
169.          goto exit;
170.      }
171.     }
172.  
173.     if (action == KOBJ_ADD)
174.         kobj->state_add_uevent_sent = 1;
175.     else if (action == KOBJ_REMOVE)
176.         kobj->state_remove_uevent_sent = 1;
177.         
178.     /* 增加event序列號的值，並輸出到環境變量的buffer。該系列號可以從/sys/kernel/uevent_seqnum屬性文件讀取，至於uevent_seqnum屬性文件及/sys/kernel/目錄是怎樣產生的，後面會分析 */
179.     spin_lock(&sequence_lock);
180.     seq = ++uevent_seqnum;
181.     spin_unlock(&sequence_lock);
182.     retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)seq);
183.     if (retval)
184.         goto exit;
185.     /* 如果配置了網絡，那麼就會通過netlink socket 向用戶空間發送環境標量，而用戶空間則通過netlink socket 接收，然後採取一些列的動作。這種機制目前用在udev中，也就是pc機系統中，後面會分析*/
186. #if defined(CONFIG_NET)
187.     /* 如果配置了net，則會在kobject_uevent_init()例程中將全局比昂倆uevent_sock 初試化爲NETLINK_KOBJECT_UEVENT 類型的socket。*/
188.     if (uevent_sock) {
189.      struct sk_buff *skb;
190.      size_t len;
191.      /* allocate message with the maximum possible size */
192.      len = strlen(action_string) + strlen(devpath) + 2;
193.      skb = alloc_skb(len + env->buflen, GFP_KERNEL);
194.      if (skb) {
195.          char *scratch;
196.          /* add header */
197.          scratch = skb_put(skb, len);
198.          sprintf(scratch, "%s@%s", action_string, devpath);
199.          /* copy keys to our continuous event payload buffer */
200.          for (i = 0; i < env->envp_idx; i++) {
201.              len = strlen(env->envp[i]) + 1;
202.              scratch = skb_put(skb, len);
203.              strcpy(scratch, env->envp[i]);
204.          }
205.          NETLINK_CB(skb).dst_group = 1;
206.          retval = netlink_broadcast(uevent_sock, skb, 0, 1,GFP_KERNEL); // 廣播
207.      } else
208.      retval = -ENOMEM;
209.     }
210. #endif
211.     /* 對於嵌入式系統來說，busybox採用的是mdev，在系統啓動腳本rcS 中會使用echo /sbin/mdev > /proc/sys/kernel/hotplug命令，而這個 hotplug文件通過一定的方法映射到了uevent_helper[]數組，所以uevent_helper[] = “/sbin/mdev” 。所以對於採用busybox的嵌入式系統來說會執行裏面的代碼，而pc機不會。也就是說內核會call用戶空間的/sbin/mdev這個應用程序來做動作，後面分析 */
212.     if (uevent_helper[0]) {
213.      char *argv [3];
214.      // 加入到環境變量buffer
215.      argv [0] = uevent_helper;
216.      argv [1] = (char *)subsystem;
217.      argv [2] = NULL;
218.      //添加HOME目錄環境變量
219.      retval = add_uevent_var(env, "HOME=/");
220.      if (retval)
221.          goto exit;
222.      //添加PATH環境變量
223.      retval = add_uevent_var(env,"PATH=/sbin:/bin:/usr/sbin:/usr/bin");
224.      if (retval)
225.          goto exit;
226.      // 呼叫應用程序來處理， UMH_WAIT_EXEC表明等待應用程序處理完，dev會根據先前設置的環境變量進行處理
227.      retval = call_usermodehelper(argv[0], argv,env->envp, UMH_WAIT_EXEC);
228.     }
229. exit:
230.     kfree(devpath);
231.     kfree(env);
232.     return retval;
233. }
234.  
235.  
236. kobject_uevent_env函數最後調用了mdev，mdev的入口函數在busybox的mdev_main
237.  
238. mdev_main
239. {
240.     if (argv[1] && !strcmp(argv[1], "-s"))//先判斷參數1是否爲-s，如果爲-s則表明mdev爲開機執行的情況（mdev -s位於/etc/init.d/rcS中）
241.     
242.     else
243.     
244.         getenv //提取各個環境變量
245.         
246.         make_device //根據action創建設備
247.         
248.         /*對於設備，當我們創建其節點時，我們可以通過配置文件進行配置，該配置文件位於/etc/mdev.conf
249.         
250.         *設備名稱正則表達式用戶id 組id 節點屬性 創建的設備節點路徑 shell命令
251.         
252.         *配置方式爲<device regex> <uid>:<gid> <octal permissions> [=path] [@|$|*<command>]        
253.         */
254.         
255.         parser = config_open2("/etc/mdev.conf", fopen_for_read); //打開/etc/mdev.conf文件
256.         
257.         while (config_read(parser, tokens, 4, 3, "# \t", PARSE_NORMAL)) //分析mdev.conf文件內容，並執行相關操作command
258.         
259.         {...}
260.         
261.         mknod(device_name, mode | type, makedev(major, minor)) //調用mknod進行節點創建
262. }
263.  
264.  
265. 四、示例
266. Udev獲取和設置設備節點的信息是通過建立一個本地套接口來實現：socket(AF_LOCAL, SOCK_SEQPACKET|SOCK_NONBLOCK|SOCK_CLOEXEC, 0)。其中SOCK_SEQPACKET提供連續可信賴的數據包連接。然後通過sendmsg和recvmsg去發送和獲取相應的信息。當獲取到設備的相應信息後再根據用戶設置的規則調用mknod函數去創建相應的設備節點。
267. Udev創建的所有設備節點的設備號都可以在/sys/dev/{block,char}目錄中找到。如果驅動程序要讓udev自動創建設備節點，那麼你就必須保存在這個目錄下有這個設備號。下面例舉一個簡單的例子：
268. #include <linux/module.h>
269. #include <linux/fs.h>
270. #include <linux/init.h>
271. #include <linux/cdev.h>
272. #include <linux/device.h>
273. static int mem_major = 240;
274. static struct class *test_class;
275. struct cdev cdev;
276. /*文件操作結構體*/
277. static const struct file_operations mem_fops =
278. {
279.   .owner = THIS_MODULE,
280. };
281.  
282. /*設備驅動模塊加載函數*/
283. static int memdev_init(void)
284. {
285.   dev_t devno = MKDEV(mem_major, 0);
286.   int result = register_chrdev_region(devno, 2, "memdev");
287.   if (result < 0)
288.     return result;
289.   cdev_add(&cdev, MKDEV(mem_major, 0), 1);
290.   test_class = class_create(THIS_MODULE, "juvi_test_class");//創建一個類，用來表示該設備文件是哪一種類型，創建成功會在/sys/class中出現。
291.   device_create(test_class, NULL, devno, NULL, "test_udev");//創建設備文件，它會在/sys/dev/char中出現相應的設備接點號。然後dev目錄下面會自動創建設備文件。
292.   return result;
293. }
294. /*模塊卸載函數*/
295. static void memdev_exit(void)
296. {
297.   cdev_del(&cdev); /*註銷設備*/
298.   unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*釋放設備號*/
299.   class_destroy(test_class);//刪除這個類型的設備。
300. }
301. MODULE_LICENSE("GPL");
302. module_init(memdev_init);
303. module_exit(memdev_exit);
304.  
305.  
306.  
307. 五、分析mdev
308. a、執行mdev -s命令時，mdev掃描/sys/block(塊設備保存在/sys/block目錄下,內核2.6.25版本以後，塊設備也保存在/sys/class/block目錄下。mdev掃描/sys/block是爲了實現向後兼容)和/sys/class兩個目錄下的dev屬性文件，從該dev屬性文件中獲取到設備編號(dev屬性文件以"major:minor\n"形式保存設備編號)，並以包含該dev屬性文件的目錄名稱作爲設備名device_name(即包含dev屬性文件的目錄稱爲device_name，而/sys/class和device_name之間的那部分目錄稱爲subsystem。也就是每個dev屬性文件所在的路徑都可表示爲/sys/class/subsystem/device_name/dev)，在/dev目錄下創建相應的設備文件。例如，cat /sys/class/tty/tty0/dev會得到4:0，subsystem爲tty,device_name爲tty0。
309.  
310. b、當mdev因uevnet事件(以前叫hotplug事件)被調用時，mdev通過由uevent事件傳遞給它的環境變量獲取到：引起該uevent事件的設備action及該設備所在的路徑device path。然後判斷引起該uevent事件的action是什麼。若該action是add，即有新設備加入到系統中，不管該設備是虛擬設備還是實際物理設備，mdev都會通過device path路徑下的dev屬性文件獲取到設備編號，然後以device path路徑最後一個目錄(即包含該dev屬性文件的目錄)作爲設備名，在/dev目錄下創建相應的設備文件。若該action是remote，即設備已從系統中移除，則刪除/dev目錄下以device path路徑最後一個目錄名稱作爲文件名的設備文件。如果該action既不是add也不是remove，mdev則什麼都不做。
311.  
312. 由上面可知，如果我們想在設備加入到系統中或從系統中移除時，由mdev自動地創建和刪除設備文件，那麼就必須做到以下三點：1、在/sys/class的某一subsystem目錄下，2、創建一個以設備名device_name作爲名稱的目錄，3、並且在該device_name目錄下還必須包含一個dev屬性文件，該dev屬性文件以"major:minor\n"形式輸出設備編號。
313.  
314.  
315. int mdev_main(int argc UNUSED_PARAM, char **argv)
316. {
317.     //#define RESERVE_CONFIG_BUFFER(buffer,len) char buffer[len]
318.     //聲明一個數組
319.     RESERVE_CONFIG_BUFFER(temp, PATH_MAX + SCRATCH_SIZE);
320.     
321.     /*
322.     struct globals {
323.         int root_major, root_minor;
324.         char *subsystem;
325. #if ENABLE_FEATURE_MDEV_CONF
326.         const char *filename;
327.         parser_t *parser;
328.         struct rule **rule_vec;
329.         unsigned rule_idx;
330. #endif
331.         struct rule cur_rule;
332. } FIX_ALIASING;
333. #define G (*(struct globals*)&bb_common_bufsiz1)
334. enum { COMMON_BUFSIZE = (BUFSIZ >= 256*sizeof(void*) ? BUFSIZ+1 : 256*sizeof(void*)) };
335. extern char bb_common_bufsiz1[COMMON_BUFSIZE];
336. #define INIT_G() do { \
337.     IF_NOT_FEATURE_MDEV_CONF(G.cur_rule.maj = -1;) \
338.     IF_NOT_FEATURE_MDEV_CONF(G.cur_rule.mode = 0660;) \
339. } while (0)
340.     */
341.     //初始化結構體
342.     INIT_G();
343.  
344. #if ENABLE_FEATURE_MDEV_CONF
345.     G.filename = "/etc/mdev.conf";
346. #endif
347.  
348.     /* We can be called as hotplug helper */
349.     //閱讀這個函數的源代碼後，發現這裏其實就是判斷了/dev/null是否存在。如果打不開，那麼就進入die狀態。
350.     bb_sanitize_stdio();
351.  
352.     /* Force the configuration file settings exactly */
353.     umask(0);//配置屏蔽位
354.  
355.     xchdir("/dev");//切換到/dev目錄
356.  
357.     if (argv[1] && strcmp(argv[1], "-s") == 0) {//如果執行的是mdev -s，這是在shell裏調用的。在系統啓動時調用。創建所有設備驅動的節點。
358.         struct stat st;
359.  
360. #if ENABLE_FEATURE_MDEV_CONF
361.         /* Same as xrealloc_vector(NULL, 4, 0): */
362.         G.rule_vec = xzalloc((1 << 4) * sizeof(*G.rule_vec));//給rule結構體分配空間
363. #endif
364.         xstat("/", &st);//返回根目錄文件狀態信息
365.         G.root_major = major(st.st_dev);//保存文件的設備號
366.         G.root_minor = minor(st.st_dev);
367.  
368.         if (access("/sys/class/block", F_OK) != 0) {//判斷/sys/class/block這個文件或者目錄是否存在。存在返回0，否則返回-1
369.             //這個函數是遞歸函數，它會把/sys/block目錄下的所有文件文件夾都去查看一遍，如果發現dev文件，那麼將按照/etc/mdev.conf文件進行相應的配置。如果沒有配置文件，那麼直接創建設備節點。
370.             recursive_action("/sys/block",ACTION_RECURSE | ACTION_FOLLOWLINKS | ACTION_QUIET,fileAction, dirAction, temp, 0);
371.         }
372.         //這個函數是遞歸函數，它會把/sys/class目錄下的所有文件文件夾都去查看一遍，如果發現dev文件，那麼將按照/etc/mdev.conf文件進行相應的配置。如果沒有配置文件，那麼直接創建設備節點。
373.         recursive_action("/sys/class",ACTION_RECURSE | ACTION_FOLLOWLINKS,fileAction, dirAction, temp, 0);
374.     } else {//通過hotplug通知mdev創建設備節點
375.         char *fw;
376.         char *seq;
377.         char *action;
378.         char *env_path;
379.         static const char keywords[] ALIGN1 = "remove\0add\0";
380.         enum { OP_remove = 0, OP_add };
381.         smalluint op;
382.  
383.         /* Hotplug:
384.          * env ACTION=... DEVPATH=... SUBSYSTEM=... [SEQNUM=...] mdev
385.          * ACTION can be "add" or "remove"
386.          * DEVPATH is like "/block/sda" or "/class/input/mice"
387.          經過驅動層分析，所得的環境變量爲，這裏是以spidev，0.0設備爲例：
388.             ACTION=add: kobject_actions[KOBJ_ADD]
389.             DEVPATH=/class/spidev/spidev0.0/: kobject_get_path(kobj, GFP_KERNEL) /sys不存在，這裏只統計到/sys目錄下
390.             SUBSYSTEM=spidev: dev->bus->name，dev->class->name，如果dev->bus不存在的情況下，那麼才使用dev->class->name
391.             MAJOR=MAJOR(dev->devt)
392.             MINOR=MINOR(dev->devt)
393.             PHYSDEVPATH=/devices/platform/atmel_spi.0/spi0.0/: kobject_get_path(&dev->parent->kobj, GFP_KERNEL) /sys不存在，這裏只統計到/sys目錄下
394.             PHYSDEVBUS=/bus/spi/: dev->parent->bus->name /sys不存在，這裏只統計到/sys目錄下
395.             PHYSDEVDRIVER=spidev: dev->parent->driver->name
396.             SEQNUM=++uevent_seqnum
397.             HOME=/
398.             PATH=/sbin:/bin:/usr/sbin:/usr/bin
399.          */
400.         //獲得環境變量
401.         action = getenv("ACTION");
402.         env_path = getenv("DEVPATH");
403.         G.subsystem = getenv("SUBSYSTEM");
404.         if (!action || !env_path)
405.             bb_show_usage();
406.         fw = getenv("FIRMWARE");
407.         op = index_in_strings(keywords, action);//比較keywords數組中和action，若是remove則返回0，若是add則返回1
408.         seq = getenv("SEQNUM");
409.         /*
410.         內核不序列化熱插拔事件，而是爲每一個成功的熱插拔調用增加了 SEQNUM 這個環境變量。通常情況下，mdev不在乎這個。這樣也許可以重新對熱插拔事件進行重調用，典型的症狀就是有時某些設備節點不能像期待的那樣被創建出來。不管怎麼說，如果 /dev/mdev.seq 文件存在，mdev將比較它和SEQNUM的內容，它將重試直到有兩個第二，等待他們匹配。如果他們精確的匹配（甚至連"\n"都不被允許），或者兩個第二齣現，mdev依舊運行，然後它用SEQNUM+1重寫/dev/mdev.seq。
411.         */
412.         if (seq) {
413.             int timeout = 2000 / 32; /* 2000 msec */
414.             do {
415.                 int seqlen;
416.                 char seqbuf[sizeof(int)*3 + 2];
417.                 //從mdev.seq文件中讀出seq
418.                 seqlen = open_read_close("mdev.seq", seqbuf, sizeof(seqbuf) - 1);
419.                 if (seqlen < 0) {
420.                     seq = NULL;
421.                     break;
422.                 }
423.                 seqbuf[seqlen] = '\0';
424.                 if (seqbuf[0] == '\n' /* seed file? */|| strcmp(seq, seqbuf) == 0) { /* correct idx? */
425.                     break;
426.                 }
427.                 usleep(32*1000);
428.             } while (--timeout);
429.         }
430.         
431.         //創建的設備路徑名賦值給temp，例如/sys/class/spidev/spidev0.0/
432.         snprintf(temp, PATH_MAX, "/sys%s", env_path);
433.         if (op == OP_remove) {//刪除節點
434.             if (!fw)
435.                 make_device(temp, /*delete:*/ 1);
436.         }
437.         else if (op == OP_add) {//添加節點
438.             make_device(temp, /*delete:*/ 0);
439.             if (ENABLE_FEATURE_MDEV_LOAD_FIRMWARE) {
440.                 if (fw)
441.                     load_firmware(fw, temp);
442.             }
443.         }
444.  
445.         if (seq) {//重寫mdev.seq文件
446.             xopen_xwrite_close("mdev.seq", utoa(xatou(seq) + 1));
447.         }
448.     }
449.  
450.     if (ENABLE_FEATURE_CLEAN_UP)
451.         RELEASE_CONFIG_BUFFER(temp);
452.  
453.     return EXIT_SUCCESS;
454. }
455.  
456. //recursive_action("/sys/block",ACTION_RECURSE | ACTION_FOLLOWLINKS | ACTION_QUIET,fileAction, dirAction, temp, 0);
457. int FAST_FUNC recursive_action(const char *fileName,unsigned flags,int FAST_FUNC (*fileAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),
458.         int FAST_FUNC (*dirAction)(const char *fileName, struct stat *statbuf, void* userData, int depth),void* userData,unsigned depth)
459. {
460.     struct stat statbuf;
461.     unsigned follow;
462.     int status;
463.     DIR *dir;
464.     struct dirent *next;
465.  
466.     if (!fileAction)
467.         fileAction = true_action;
468.     if (!dirAction)
469.         dirAction = true_action;
470.  
471.     follow = ACTION_FOLLOWLINKS;
472.     if (depth == 0)//第一次調用時傳入depth參數爲0
473.         follow = ACTION_FOLLOWLINKS | ACTION_FOLLOWLINKS_L0;
474.         
475.     follow &= flags;//也設置了ACTION_FOLLOWLINKS標誌
476.     
477.     //stat和lstat的區別：當文件是一個符號鏈接時，lstat返回的是該符號鏈接本身的信息；而stat返回的是該鏈接指向的文件的信息。
478.     status = (follow ? stat : lstat)(fileName, &statbuf);//這裏用stat讀取目錄或文件屬性    
479.     if (status < 0) {
480.         if ((flags & ACTION_DANGLING_OK)&& errno == ENOENT&& lstat(fileName, &statbuf) == 0) {/* Dangling link */
481.             return fileAction(fileName, &statbuf, userData, depth);
482.         }
483.         goto done_nak_warn;
484.     }
485.  
486.     if (!S_ISDIR(statbuf.st_mode)) {//如果不是目錄，則調用下邊函數進行創建設備節點
487.         return fileAction(fileName, &statbuf, userData, depth);
488.     }
489.  
490.     //ACTION_RECURSE標誌設置過，不進行以下操作
491.     if (!(flags & ACTION_RECURSE)) {
492.         return dirAction(fileName, &statbuf, userData, depth);
493.     }
494.     
495.     //沒有設置過ACTION_DEPTHFIRST
496.     if (!(flags & ACTION_DEPTHFIRST)) {
497.         status = dirAction(fileName, &statbuf, userData, depth);//返回TRUE=1
498.         if (!status)
499.             goto done_nak_warn;
500.         if (status == SKIP)
501.             return TRUE;
502.     }
503.     
504.     //執行到這裏表明傳入的參數是目錄
505.     dir = opendir(fileName);//打開目錄
506.     if (!dir) {
507.         goto done_nak_warn;
508.     }
509.     status = TRUE;
510.     while ((next = readdir(dir)) != NULL) {//讀目錄
511.         char *nextFile;
512.  
513.         nextFile = concat_subpath_file(fileName, next->d_name);//讀目錄下的文件
514.         if (nextFile == NULL)
515.             continue;
516.         /* process every file (NB: ACTION_RECURSE is set in flags) */
517.         if (!recursive_action(nextFile, flags, fileAction, dirAction,userData, depth + 1))//遞歸調用
518.             status = FALSE;
519.         free(nextFile);
520.     }
521.     closedir(dir);
522.     
523.     //沒有設置過ACTION_DEPTHFIRST,不會進去執行
524.     if (flags & ACTION_DEPTHFIRST) {
525.         if (!dirAction(fileName, &statbuf, userData, depth))
526.             goto done_nak_warn;
527.     }
528.  
529.     return status;
530.  
531. done_nak_warn:
532.     if (!(flags & ACTION_QUIET))
533.         bb_simple_perror_msg(fileName);
534.     return FALSE;
535. }
536.  
537. static int FAST_FUNC fileAction(const char *fileName,struct stat *statbuf UNUSED_PARAM,void *userData,int depth UNUSED_PARAM)
538. {
539.     size_t len = strlen(fileName) - 4; /* can't underflow */
540.     char *scratch = userData;
541.  
542.     //檢查傳入進來的路徑名的最後4個字符是否爲“/dev”，即只有根據dev文件來創建設備節點
543.     if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX)
544.         return FALSE;
545.  
546.     strcpy(scratch, fileName);//複製文件名
547.     scratch[len] = '\0';//將最後的"/dev"去掉
548.     make_device(scratch, /*delete:*/ 0);//進行創建設備節點
549.  
550.     return TRUE;
551. }
552.  
553. static void make_device(char *path, int delete)
554. {
555.     char *device_name, *subsystem_slash_devname;
556.     int major, minor, type, len;
557.  
558.     dbg("%s('%s', delete:%d)", __func__, path, delete);
559.     major = -1;
560.     if (!delete) {
561.         char *dev_maj_min = path + strlen(path);//將dev_maj_min指針指向路徑名的最後
562.         
563.         //傳入的路徑名是最後dev文件的父目錄，例如/sys/block/mtdblock0
564.         strcpy(dev_maj_min, "/dev");//即將路徑名添加“/dev”，即/sys/block/mtdblock0/dev確保讀的文件時dev文件
565.         len = open_read_close(path, dev_maj_min + 1, 64);//從dev文件中讀出主設備號和次設備號存到dev_maj_min + 1地址處
566.         *dev_maj_min = '\0';
567.         if (len < 1) {
568.             if (!ENABLE_FEATURE_MDEV_EXEC)
569.                 return;
570.         } else if (sscanf(++dev_maj_min, "%u:%u", &major, &minor) != 2) {//主設備號和次設備號複製給major和minor
571.             major = -1;
572.         }
573.     }
574.     //調用strrchr() 函數查找字符在指定字符串中從後面開始的第一次出現的位置，即找到設備名
575.     //例如：/sys/block/mtdblock0,返回的設備名就是mtdblock0
576.     device_name = (char*) bb_basename(path);
577.     
578.     type = S_IFCHR;
579.     //判斷是否爲block設備
580.     if (strstr(path, "/block/") || (G.subsystem && strncmp(G.subsystem, "block", 5) == 0))
581.         type = S_IFBLK;
582.  
583.     /* Make path point to "subsystem/device_name" */
584.     subsystem_slash_devname = NULL;
585.     //path路徑名前移
586.     if (strncmp(path, "/sys/block/", 11) == 0) /* legacy case */
587.         path += sizeof("/sys/") - 1;
588.     else if (strncmp(path, "/sys/class/", 11) == 0)
589.         path += sizeof("/sys/class/") - 1;
590.     else {
591.         /* Example of a hotplug invocation:
592.          * SUBSYSTEM="block"
593.          * DEVPATH="/sys" + "/devices/virtual/mtd/mtd3/mtdblock3"
594.          * ("/sys" is added by mdev_main)
595.          * - path does not contain subsystem
596.          */
597.         subsystem_slash_devname = concat_path_file(G.subsystem, device_name);
598.         path = subsystem_slash_devname;
599.     }
600.  
601. #if ENABLE_FEATURE_MDEV_CONF
602.     G.rule_idx = 0; /* restart from the beginning (think mdev -s) */
603. #endif
604.     for (;;) {
605.         const char *str_to_match;
606.         regmatch_t off[1 + 9 * ENABLE_FEATURE_MDEV_RENAME_REGEXP];
607.         char *command;
608.         char *alias;
609.         char aliaslink = aliaslink; /* for compiler */
610.         const char *node_name;
611.         const struct rule *rule;
612.  
613.         str_to_match = "";
614.         //# define next_rule() (&G.cur_rule)
615.         rule = next_rule();
616.         //檢查rule
617. #if ENABLE_FEATURE_MDEV_CONF
618.         if (rule->maj >= 0) { /* @maj,min rule */
619.             if (major != rule->maj)
620.                 continue;
621.             if (minor < rule->min0 || minor > rule->min1)
622.                 continue;
623.             memset(off, 0, sizeof(off));
624.             goto rule_matches;
625.         }
626.         if (rule->envvar) { /* $envvar=regex rule */
627.             str_to_match = getenv(rule->envvar);
628.             dbg("getenv('%s'):'%s'", rule->envvar, str_to_match);
629.             if (!str_to_match)
630.                 continue;
631.         } else {
632.             /* regex to match [subsystem/]device_name */
633.             str_to_match = (rule->regex_has_slash ? path : device_name);
634.         }
635.  
636.         if (rule->regex_compiled) {
637.             int regex_match = regexec(&rule->match, str_to_match, ARRAY_SIZE(off), off, 0);
638.             dbg("regex_match for '%s':%d", str_to_match, regex_match);
639.  
640.             if (regex_match != 0
641.             /* regexec returns whole pattern as "range" 0 */
642.              || off[0].rm_so != 0
643.              || (int)off[0].rm_eo != (int)strlen(str_to_match)
644.             ) {
645.                 continue; /* this rule doesn't match */
646.             }
647.         }
648.         /* else: it's final implicit "match-all" rule */
649.  rule_matches:
650. #endif
651.         dbg("rule matched");
652.  
653.         /* Build alias name */
654.         alias = NULL;
655.         if (ENABLE_FEATURE_MDEV_RENAME && rule->ren_mov) {
656.             aliaslink = rule->ren_mov[0];
657.             if (aliaslink == '!') {
658.                 /* "!": suppress node creation/deletion */
659.                 major = -2;
660.             }
661.             else if (aliaslink == '>' || aliaslink == '=') {
662.                 if (ENABLE_FEATURE_MDEV_RENAME_REGEXP) {
663.                     char *s;
664.                     char *p;
665.                     unsigned n;
666.  
667.                     /* substitute %1..9 with off[1..9], if any */
668.                     n = 0;
669.                     s = rule->ren_mov;
670.                     while (*s)
671.                         if (*s++ == '%')
672.                             n++;
673.  
674.                     p = alias = xzalloc(strlen(rule->ren_mov) + n * strlen(str_to_match));
675.                     s = rule->ren_mov + 1;
676.                     while (*s) {
677.                         *p = *s;
678.                         if ('%' == *s) {
679.                             unsigned i = (s[1] - '0');
680.                             if (i <= 9 && off[i].rm_so >= 0) {
681.                                 n = off[i].rm_eo - off[i].rm_so;
682.                                 strncpy(p, str_to_match + off[i].rm_so, n);
683.                                 p += n - 1;
684.                                 s++;
685.                             }
686.                         }
687.                         p++;
688.                         s++;
689.                     }
690.                 } else {
691.                     alias = xstrdup(rule->ren_mov + 1);
692.                 }
693.             }
694.         }
695.         dbg("alias:'%s'", alias);
696.  
697.         command = NULL;
698.         IF_FEATURE_MDEV_EXEC(command = rule->r_cmd;)
699.         if (command) {
700.             const char *s = "$@*";
701.             const char *s2 = strchr(s, command[0]);
702.  
703.             /* Are we running this command now?
704.              * Run $cmd on delete, @cmd on create, *cmd on both
705.              */
706.             if (s2 - s != delete) {
707.                 /* We are here if: '*',
708.                  * or: '@' and delete = 0,
709.                  * or: '$' and delete = 1
710.                  */
711.                 command++;
712.             } else {
713.                 command = NULL;
714.             }
715.         }
716.         dbg("command:'%s'", command);
717.  
718.         /* "Execute" the line we found */
719.         node_name = device_name;
720.         if (ENABLE_FEATURE_MDEV_RENAME && alias) {
721.             node_name = alias = build_alias(alias, device_name);
722.             dbg("alias2:'%s'", alias);
723.         }
724.  
725.         if (!delete && major >= 0) {//創建設備節點
726.             dbg("mknod('%s',%o,(%d,%d))", node_name, rule->mode | type, major, minor);
727.             if (mknod(node_name, rule->mode | type, makedev(major, minor)) && errno != EEXIST)//創建設備節點
728.                 bb_perror_msg("can't create '%s'", node_name);
729.             if (major == G.root_major && minor == G.root_minor)
730.                 symlink(node_name, "root");
731.             if (ENABLE_FEATURE_MDEV_CONF) {
732.                 chmod(node_name, rule->mode);
733.                 chown(node_name, rule->ugid.uid, rule->ugid.gid);
734.             }
735.             if (ENABLE_FEATURE_MDEV_RENAME && alias) {
736.                 if (aliaslink == '>') {
737. //TODO: on devtmpfs, device_name already exists and symlink() fails.
738. //End result is that instead of symlink, we have two nodes.
739. //What should be done?
740.                     symlink(node_name, device_name);
741.                 }
742.             }
743.         }
744.  
745.         if (ENABLE_FEATURE_MDEV_EXEC && command) {
746.             /* setenv will leak memory, use putenv/unsetenv/free */
747.             char *s = xasprintf("%s=%s", "MDEV", node_name);
748.             char *s1 = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem);
749.             putenv(s);
750.             putenv(s1);
751.             if (system(command) == -1)
752.                 bb_perror_msg("can't run '%s'", command);
753.             bb_unsetenv_and_free(s1);
754.             bb_unsetenv_and_free(s);
755.         }
756.  
757.         if (delete && major >= -1) {//刪除節點
758.             if (ENABLE_FEATURE_MDEV_RENAME && alias) {
759.                 if (aliaslink == '>')
760.                     unlink(device_name);
761.             }
762.             unlink(node_name);
763.         }
764.  
765.         if (ENABLE_FEATURE_MDEV_RENAME)
766.             free(alias);
767.  
768.         /* We found matching line.
769.          * Stop unless it was prefixed with '-'
770.          */
771.         if (!ENABLE_FEATURE_MDEV_CONF || !rule->keep_matching)
772.             break;
773.     } /* for (;;) */
774.  
775.     free(subsystem_slash_devname);
776. }