devtmpfs文件系统创建设备节点

1. 一、devtmpfs概述
   
2. 1.devtmpfs 的功用是在 Linux 核心 启动早期建立一个初步的 /dev，令一般启动程序不用等待 udev，缩短 GNU/Linux 的开机时间。
   
3. 
   
4. 2.重要解释
   
5. Devtmpfs lets the kernel create a tmpfs very early at kernel initialization, before any driver core device is registered. Every device with a major/minor will have a device node created in this tmpfs instance. After the rootfs is mounted by the kernel, the populated tmpfs is mounted at /dev. In initramfs, it can be moved to the manually mounted root filesystem before /sbin/init is executed.
   
6. 
   
7. 3.menuconfig 中加入devtmpfs支持
   
8. make menuconfig-->Device Drivers-->Generic Driver Options
   
9. Maintain a devtmpfs filesystem to mount at /dev
   
10. Automount devtmpfs at /dev, after the kernel mounted the rootfs
    
11. 
    
12. 4.df -T显示devtmpfs
    
13. 文件系统 类型 1K-块 已用 可用 已用% 挂载点
    
14. /dev/sda1 ext4 31621016 14985712 15029008 50% /
    
15. none devtmpfs 399552 276 399276 1% /dev
    
16. none tmpfs 403804 24 403780 1% /dev/shm
    
17. none tmpfs 403804 108 403696 1% /var/run
    
18. none tmpfs 403804 0 403804 0% /var/lock
    
19. none tmpfs 403804 0 403804 0% /lib/init/rw
    
20. .host:/ vmhgfs 67151668 54038400 13113268 81% /mnt/hgfs
    
21. /dev/loop0 ext2 16119 8528 6772 56% /mnt/loop
    
22. 
    
23. 二、devtmpfs文件系统初始化
    
24. void __init driver_init(void)
    
25. {
    
26.     /* These are the core pieces */
    
27.     devtmpfs_init();//devtmpfs文件系统初始化
    
28.     devices_init();
    
29.     buses_init();
    
30.     classes_init();
    
31.     firmware_init();
    
32.     hypervisor_init();
    
33.     platform_bus_init();
    
34.     system_bus_init();
    
35.     cpu_dev_init();
    
36.     memory_dev_init();
    
37. }
    
38. 
    
39. static struct file_system_type dev_fs_type = {
    
40.     .name = "devtmpfs",
    
41.     .mount = dev_mount,
    
42.     .kill_sb = kill_litter_super,
    
43. };
    
44.    
    
45. int __init devtmpfs_init(void)
    
46. {
    
47.     int err = register_filesystem(&dev_fs_type);//注册dev_fs_type文件系统，即将dev_fs_type添加到内核全局总链表中file_systems
    
48.     if (err) {
    
49.         printk(KERN_ERR "devtmpfs: unable to register devtmpfs ""type %i\n", err);
    
50.         return err;
    
51.     }
    
52.     
    
53.     thread = kthread_run(devtmpfsd, &err, "kdevtmpfs");//创建并启动一个内核线程devtmpfsd
    
54.     if (!IS_ERR(thread)) {
    
55.         wait_for_completion(&setup_done);//进行一个不可打断的等待,允许一个线程告诉另一个线程工作已经完成
    
56.     } else {
    
57.         err = PTR_ERR(thread);
    
58.         thread = NULL;
    
59.     }
    
60.     
    
61.     if (err) {
    
62.         printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
    
63.         unregister_filesystem(&dev_fs_type);
    
64.         return err;
    
65.     }
    
66.     
    
67.     printk(KERN_INFO "devtmpfs: initialized\n");
    
68.     return 0;
    
69. }
    
70. 
    
71. //请求创建设备节点的请求队列req结构
    
72. static struct req {
    
73.     struct req *next;
    
74.     struct completion done;
    
75.     int err;
    
76.     const char *name;
    
77.     umode_t mode;//0代表删除
    
78.     struct device *dev;
    
79. } *requests;
    
80. 
    
81. //内核线程devtmpfsd
    
82. static int devtmpfsd(void *p)
    
83. {
    
84.     char options[] = "mode=0755";
    
85.     int *err = p;
    
86.     
    
87.     *err = sys_unshare(CLONE_NEWNS);
    
88.     if (*err)
    
89.         goto out;
    
90.         
    
91.     //挂载devtmpfs文件系统
    
92.     //devtmpfs是待安装设备的路径名，“/”是安装点路径名，”devtmpfs“表示文件系统类型，MS_SILENT=32768，即0x8000
    
93.     *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
    
94.     if (*err)
    
95.         goto out;
    
96.     sys_chdir("/.."); //将进程的当前工作目录(pwd)设定为devtmpfs文件系统的根目录/* will traverse into overmounted root */
    
97.     sys_chroot(".");
    
98.     complete(&setup_done);//允许一个线程告诉另一个线程工作已经完成
    
99.     while (1) {
    
100.         spin_lock(&req_lock);
     
101.         while (requests) {//扫描请求链表，每当要创建一个设备节点时，都需要向requests链表中添加请求
     
102.             struct req *req = requests;//赋值给临时req
     
103.             requests = NULL;//清空
     
104.             spin_unlock(&req_lock);
     
105.             while (req) {//遍历刚才requests的请求链表
     
106.                 struct req *next = req->next;
     
107.                 req->err = handle(req->name, req->mode, req->dev);//对链表中的每一个请求调用handle函数
     
108.                 complete(&req->done);
     
109.                 req = next;
     
110.             }
     
111.             spin_lock(&req_lock);
     
112.         }
     
113.         __set_current_state(TASK_INTERRUPTIBLE);//设置为睡眠状态
     
114.         spin_unlock(&req_lock);
     
115.         schedule();//系统切换
     
116.     }
     
117.     return 0;
     
118. out:
     
119.     complete(&setup_done);
     
120.     return *err;
     
121. }
     
122. 
     
123. static int handle(const char *name, umode_t mode, struct device *dev)
     
124. {
     
125.     if (mode)
     
126.         return handle_create(name, mode, dev);
     
127.     else
     
128.         return handle_remove(name, dev);
     
129. }
     
130. 
     
131. static int handle_create(const char *nodename, umode_t mode, struct device *dev)
     
132. {
     
133.     struct dentry *dentry;
     
134.     struct path path;
     
135.     int err;
     
136.     
     
137.     //查找节点名称的路径以及返回节点对应的父目录dentry结构，即在此目录下创建一个设备节点，即是/dev目录对应的dentry结构
     
138.     dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
     
139.     if (dentry == ERR_PTR(-ENOENT)) {
     
140.         create_path(nodename);
     
141.         dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
     
142.     }
     
143.     if (IS_ERR(dentry))
     
144.         return PTR_ERR(dentry);
     
145.     
     
146.     //创建设备节点
     
147.     err = vfs_mknod(path.dentry->d_inode,dentry, mode, dev->devt);
     
148.     if (!err) {
     
149.         struct iattr newattrs;
     
150.         newattrs.ia_mode = mode;/* fixup possibly umasked mode */
     
151.         newattrs.ia_valid = ATTR_MODE;
     
152.         mutex_lock(&dentry->d_inode->i_mutex);
     
153.         notify_change(dentry, &newattrs);
     
154.         mutex_unlock(&dentry->d_inode->i_mutex);
     
155.         dentry->d_inode->i_private = &thread;/* mark as kernel-created inode */
     
156.     }
     
157.     done_path_create(&path, dentry);//与前边kern_path_create对应，减少path和dentry的计数等
     
158.     return err;
     
159. }
     
160. 
     
161. int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
     
162. {
     
163.     int error = may_create(dir, dentry);//检查是否可以创建设备文件节点
     
164.     
     
165.     if (error)
     
166.         return error;
     
167.     
     
168.     //必须是字符设备或者块设备，且具有创建节点的权限
     
169.     if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
     
170.         return -EPERM;
     
171.     
     
172.     if (!dir->i_op->mknod)
     
173.         return -EPERM;
     
174.     
     
175.     error = devcgroup_inode_mknod(mode, dev);
     
176.     if (error)
     
177.         return error;
     
178.     
     
179.     error = security_inode_mknod(dir, dentry, mode, dev);
     
180.     if (error)
     
181.         return error;
     
182.     
     
183.     //调用具体文件系统的mknod()函数
     
184.     //mount时调用shmem_fill_super()-->shmem_get_inode()分配inode节点时做出的初始化
     
185.     /*那么在shmem_get_inode中
     
186.         caseS_IFDIR:
     
187.         inc_nlink(inode);
     
188.         inode->i_size= 2 * BOGO_DIRENT_SIZE;
     
189.         inode->i_op= &shmem_dir_inode_operations;
     
190.         inode->i_fop= &simple_dir_operations;
     
191.         由于mountpoint是dev这个目录，所以dev对应的inode的i_op就是shmem_dir_inode_operations。
     
192.         staticconst struct inode_operations shmem_dir_inode_operations = {
     
193.             #ifdefCONFIG_TMPFS
     
194.             .create =shmem_create,
     
195.             .lookup =simple_lookup,
     
196.             .link =shmem_link,
     
197.             .unlink =shmem_unlink,
     
198.             .symlink =shmem_symlink,
     
199.             .mkdir =shmem_mkdir,
     
200.             .rmdir =shmem_rmdir,
     
201.             .mknod =shmem_mknod,
     
202.             .rename =shmem_rename,
     
203.             #endif
     
204.             #ifdefCONFIG_TMPFS_POSIX_ACL
     
205.             .setattr =shmem_notify_change,
     
206.             .setxattr =generic_setxattr,
     
207.             .getxattr =generic_getxattr,
     
208.             .listxattr =generic_listxattr,
     
209.             .removexattr =generic_removexattr,
     
210.             .check_acl =generic_check_acl,
     
211.             #endif
     
212.             };
     
213.         */
     
214.     error = dir->i_op->mknod(dir, dentry, mode, dev);//所以这里调用的就是shmem_mknod
     
215.     if (!error)
     
216.         fsnotify_create(dir, dentry);
     
217.     return error;
     
218. }
     
219. 
     
220. shmem_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
     
221. {
     
222.     struct inode *inode;
     
223.     int error = -ENOSPC;
     
224.     
     
225.     inode = shmem_get_inode(dir->i_sb, dir, mode, dev, VM_NORESERVE);//获得一个要创建的设备节点的inode，并初始化
     
226.     if (inode) {
     
227.         error = security_inode_init_security(inode, dir,&dentry->d_name,shmem_initxattrs, NULL);
     
228.         if (error) {
     
229.             if (error != -EOPNOTSUPP) {
     
230.                 iput(inode);
     
231.                 return error;
     
232.             }
     
233.         }
     
234. #ifdef CONFIG_TMPFS_POSIX_ACL
     
235.         error = generic_acl_init(inode, dir);
     
236.         if (error) {
     
237.             iput(inode);
     
238.             return error;
     
239.         }
     
240. #else
     
241.         error = 0;
     
242. #endif
     
243.         dir->i_size += BOGO_DIRENT_SIZE;
     
244.         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
     
245.         d_instantiate(dentry, inode);//与dentry建立关,此时就可以在/dev下看到这个字符设备节点了
     
246.         dget(dentry); //递减dentry的计数
     
247.     }
     
248.     return error;
     
249. }
     
250. 
     
251. 三、文件系统的mount
     
252. 内核主要是通过kernel_init调用prepare_namespace()函数执行安装实际根文件系统的操作：
     
253. void __init prepare_namespace(void)
     
254. {
     
255.     int is_floppy;
     
256.   
     
257.     if (root_delay) {
     
258.         printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
     
259.                root_delay);
     
260.         ssleep(root_delay);
     
261.     }
     
262.     wait_for_device_probe();
     
263.   
     
264.     md_run_setup();
     
265.     /* 把root_device_name变量置为从启动参数“root”中获取的设备文件名。
     
266.   * 同样，把ROOT_DEV变量置为同一设备文件的主设备号和次设备号。*/
     
267.     if (saved_root_name[0]) {
     
268.         root_device_name = saved_root_name;
     
269.         if (!strncmp(root_device_name, "mtd", 3) ||
     
270.             !strncmp(root_device_name, "ubi", 3)) {
     
271.             mount_block_root(root_device_name, root_mountflags);
     
272.             goto out;
     
273.         }
     
274.         ROOT_DEV = name_to_dev_t(root_device_name);//转换为设备号/dev/mtdblock2.
     
275.         if (strncmp(root_device_name, "/dev/", 5) == 0)
     
276.             root_device_name += 5;
     
277.     }
     
278.   
     
279.     if (initrd_load())
     
280.         goto out;
     
281.   
     
282.     /* wait for any asynchronous scanning to complete */
     
283.     if ((ROOT_DEV == 0) && root_wait) {
     
284.         printk(KERN_INFO "Waiting for root device %s...\n",
     
285.             saved_root_name);
     
286.         while (driver_probe_done() != 0 ||
     
287.             (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
     
288.             msleep(100);
     
289.         async_synchronize_full();
     
290.     }
     
291.   
     
292.     is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
     
293.   
     
294.     if (is_floppy && rd_doload && rd_load_disk(0))
     
295.         ROOT_DEV = Root_RAM0;
     
296.   
     
297.     mount_root();
     
298. out:
     
299.     devtmpfs_mount("dev");//挂载devtmpfs文件系统
     
300.     sys_mount(".", "/", NULL, MS_MOVE, NULL); /* 移动rootfs文件系统根目录上的已安装文件系统的安装点。 */
     
301.     sys_chroot(".");
     
302. }
     
303. 
     
304. int devtmpfs_mount(const char *mntdir)
     
305. {
     
306.     int err;
     
307.     
     
308.     if (!mount_dev)
     
309.         return 0;
     
310.     
     
311.     if (!thread)
     
312.         return 0;
     
313.     //将devtmpfs文件系统挂载到/dev目录下
     
314.     err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
     
315.     if (err)
     
316.         printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
     
317.     else
     
318.         printk(KERN_INFO "devtmpfs: mounted\n");
     
319.     return err;
     
320. }
     
321. 
     
322. 
     
323. 四、devtmpfs创建节点
     
324. 系统在启动过程中，扫描到的设备会通过devtmpfs_create_node()函数来添加设备节点。
     
325. int devtmpfs_create_node(struct device *dev)
     
326. {
     
327.     const char *tmp = NULL;
     
328.     struct req req;
     
329.     
     
330.     if (!thread)
     
331.     return 0;
     
332.     
     
333.     req.mode = 0;
     
334.     req.name = device_get_devnode(dev, &req.mode, &tmp);//获得设备名
     
335.     if (!req.name)
     
336.         return -ENOMEM;
     
337.     
     
338.     if (req.mode == 0)
     
339.         req.mode = 0600;
     
340.     if (is_blockdev(dev))
     
341.         req.mode |= S_IFBLK;//块设备
     
342.     else
     
343.         req.mode |= S_IFCHR;//字符设备
     
344.     
     
345.     req.dev = dev;
     
346.     
     
347.     init_completion(&req.done);
     
348.     
     
349.     spin_lock(&req_lock);
     
350.     req.next = requests;//请求添加到requests链表
     
351.     requests = &req;
     
352.     spin_unlock(&req_lock);
     
353.     
     
354.     wake_up_process(thread);//唤醒内核线程devtmpfsd添加设备节点
     
355.     wait_for_completion(&req.done);
     
356.     
     
357.     kfree(tmp);
     
358.     
     
359.     return req.err;
     
360. }
     
361. 
     
362. const char *device_get_devnode(struct device *dev,umode_t *mode, const char **tmp)
     
363. {
     
364.     char *s;
     
365.     
     
366.     *tmp = NULL;
     
367.     
     
368.     /* the device type may provide a specific name */
     
369.     if (dev->type && dev->type->devnode)
     
370.         *tmp = dev->type->devnode(dev, mode);
     
371.     if (*tmp)
     
372.         return *tmp;
     
373.     
     
374.     /* the class may provide a specific name */
     
375.     if (dev->class && dev->class->devnode)
     
376.         *tmp = dev->class->devnode(dev, mode);
     
377.     if (*tmp)
     
378.         return *tmp;
     
379.     
     
380.     /* return name without allocation, tmp == NULL */
     
381.     if (strchr(dev_name(dev), '!') == NULL)
     
382.         return dev_name(dev);
     
383.     
     
384.     /* replace '!' in the name with '/' */
     
385.     *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
     
386.     if (!*tmp)
     
387.         return NULL;
     
388.     while ((s = strchr(*tmp, '!')))
     
389.         s[0] = '/';
     
390.     return *tmp;
     
391. }