2 * devtmpfs - kernel-maintained tmpfs-based /dev
4 * Copyright (C) 2009, Kay Sievers <kay.sievers@vrfy.org>
6 * During bootup, before any driver core device is registered,
7 * devtmpfs, a tmpfs-based filesystem is created. Every driver-core
8 * device which requests a device node, will add a node in this
10 * By default, all devices are named after the the name of the
11 * device, owned by root and have a default mode of 0600. Subsystems
12 * can overwrite the default setting if needed.
15 #include <linux/kernel.h>
16 #include <linux/syscalls.h>
17 #include <linux/mount.h>
18 #include <linux/device.h>
19 #include <linux/genhd.h>
20 #include <linux/namei.h>
22 #include <linux/shmem_fs.h>
23 #include <linux/ramfs.h>
24 #include <linux/sched.h>
25 #include <linux/slab.h>
26 #include <linux/kthread.h>
28 static struct task_struct
*thread
;
30 #if defined CONFIG_DEVTMPFS_MOUNT
31 static int mount_dev
= 1;
36 static DEFINE_SPINLOCK(req_lock
);
40 struct completion done
;
43 mode_t mode
; /* 0 => delete */
47 static int __init
mount_param(char *str
)
49 mount_dev
= simple_strtoul(str
, NULL
, 0);
52 __setup("devtmpfs.mount=", mount_param
);
54 static struct dentry
*dev_mount(struct file_system_type
*fs_type
, int flags
,
55 const char *dev_name
, void *data
)
58 return mount_single(fs_type
, flags
, data
, shmem_fill_super
);
60 return mount_single(fs_type
, flags
, data
, ramfs_fill_super
);
64 static struct file_system_type dev_fs_type
= {
67 .kill_sb
= kill_litter_super
,
71 static inline int is_blockdev(struct device
*dev
)
73 return dev
->class == &block_class
;
76 static inline int is_blockdev(struct device
*dev
) { return 0; }
79 int devtmpfs_create_node(struct device
*dev
)
81 const char *tmp
= NULL
;
88 req
.name
= device_get_devnode(dev
, &req
.mode
, &tmp
);
101 init_completion(&req
.done
);
103 spin_lock(&req_lock
);
106 spin_unlock(&req_lock
);
108 wake_up_process(thread
);
109 wait_for_completion(&req
.done
);
116 int devtmpfs_delete_node(struct device
*dev
)
118 const char *tmp
= NULL
;
124 req
.name
= device_get_devnode(dev
, NULL
, &tmp
);
131 init_completion(&req
.done
);
133 spin_lock(&req_lock
);
136 spin_unlock(&req_lock
);
138 wake_up_process(thread
);
139 wait_for_completion(&req
.done
);
145 static int dev_mkdir(const char *name
, mode_t mode
)
147 struct dentry
*dentry
;
151 dentry
= kern_path_create(AT_FDCWD
, name
, &path
, 1);
153 return PTR_ERR(dentry
);
155 err
= vfs_mkdir(path
.dentry
->d_inode
, dentry
, mode
);
157 /* mark as kernel-created inode */
158 dentry
->d_inode
->i_private
= &thread
;
160 mutex_unlock(&path
.dentry
->d_inode
->i_mutex
);
165 static int create_path(const char *nodepath
)
169 err
= dev_mkdir(nodepath
, 0755);
170 if (err
== -ENOENT
) {
174 /* parent directories do not exist, create them */
175 path
= kstrdup(nodepath
, GFP_KERNEL
);
186 err
= dev_mkdir(path
, 0755);
187 if (err
&& err
!= -EEXIST
)
198 static int handle_create(const char *nodename
, mode_t mode
, struct device
*dev
)
200 struct dentry
*dentry
;
204 dentry
= kern_path_create(AT_FDCWD
, nodename
, &path
, 0);
205 if (dentry
== ERR_PTR(-ENOENT
)) {
206 create_path(nodename
);
207 dentry
= kern_path_create(AT_FDCWD
, nodename
, &path
, 0);
210 return PTR_ERR(dentry
);
212 err
= vfs_mknod(path
.dentry
->d_inode
,
213 dentry
, mode
, dev
->devt
);
215 struct iattr newattrs
;
217 /* fixup possibly umasked mode */
218 newattrs
.ia_mode
= mode
;
219 newattrs
.ia_valid
= ATTR_MODE
;
220 mutex_lock(&dentry
->d_inode
->i_mutex
);
221 notify_change(dentry
, &newattrs
);
222 mutex_unlock(&dentry
->d_inode
->i_mutex
);
224 /* mark as kernel-created inode */
225 dentry
->d_inode
->i_private
= &thread
;
229 mutex_unlock(&path
.dentry
->d_inode
->i_mutex
);
234 static int dev_rmdir(const char *name
)
237 struct dentry
*dentry
;
240 err
= kern_path_parent(name
, &nd
);
244 mutex_lock_nested(&nd
.path
.dentry
->d_inode
->i_mutex
, I_MUTEX_PARENT
);
245 dentry
= lookup_one_len(nd
.last
.name
, nd
.path
.dentry
, nd
.last
.len
);
246 if (!IS_ERR(dentry
)) {
247 if (dentry
->d_inode
) {
248 if (dentry
->d_inode
->i_private
== &thread
)
249 err
= vfs_rmdir(nd
.path
.dentry
->d_inode
,
258 err
= PTR_ERR(dentry
);
261 mutex_unlock(&nd
.path
.dentry
->d_inode
->i_mutex
);
266 static int delete_path(const char *nodepath
)
271 path
= kstrdup(nodepath
, GFP_KERNEL
);
278 base
= strrchr(path
, '/');
282 err
= dev_rmdir(path
);
291 static int dev_mynode(struct device
*dev
, struct inode
*inode
, struct kstat
*stat
)
293 /* did we create it */
294 if (inode
->i_private
!= &thread
)
297 /* does the dev_t match */
298 if (is_blockdev(dev
)) {
299 if (!S_ISBLK(stat
->mode
))
302 if (!S_ISCHR(stat
->mode
))
305 if (stat
->rdev
!= dev
->devt
)
312 static int handle_remove(const char *nodename
, struct device
*dev
)
315 struct dentry
*dentry
;
320 err
= kern_path_parent(nodename
, &nd
);
324 mutex_lock_nested(&nd
.path
.dentry
->d_inode
->i_mutex
, I_MUTEX_PARENT
);
325 dentry
= lookup_one_len(nd
.last
.name
, nd
.path
.dentry
, nd
.last
.len
);
326 if (!IS_ERR(dentry
)) {
327 if (dentry
->d_inode
) {
328 err
= vfs_getattr(nd
.path
.mnt
, dentry
, &stat
);
329 if (!err
&& dev_mynode(dev
, dentry
->d_inode
, &stat
)) {
330 struct iattr newattrs
;
332 * before unlinking this node, reset permissions
333 * of possible references like hardlinks
337 newattrs
.ia_mode
= stat
.mode
& ~0777;
339 ATTR_UID
|ATTR_GID
|ATTR_MODE
;
340 mutex_lock(&dentry
->d_inode
->i_mutex
);
341 notify_change(dentry
, &newattrs
);
342 mutex_unlock(&dentry
->d_inode
->i_mutex
);
343 err
= vfs_unlink(nd
.path
.dentry
->d_inode
,
345 if (!err
|| err
== -ENOENT
)
353 err
= PTR_ERR(dentry
);
355 mutex_unlock(&nd
.path
.dentry
->d_inode
->i_mutex
);
358 if (deleted
&& strchr(nodename
, '/'))
359 delete_path(nodename
);
364 * If configured, or requested by the commandline, devtmpfs will be
365 * auto-mounted after the kernel mounted the root filesystem.
367 int devtmpfs_mount(const char *mntdir
)
377 err
= sys_mount("devtmpfs", (char *)mntdir
, "devtmpfs", MS_SILENT
, NULL
);
379 printk(KERN_INFO
"devtmpfs: error mounting %i\n", err
);
381 printk(KERN_INFO
"devtmpfs: mounted\n");
385 static __initdata
DECLARE_COMPLETION(setup_done
);
387 static int handle(const char *name
, mode_t mode
, struct device
*dev
)
390 return handle_create(name
, mode
, dev
);
392 return handle_remove(name
, dev
);
395 static int devtmpfsd(void *p
)
397 char options
[] = "mode=0755";
399 *err
= sys_unshare(CLONE_NEWNS
);
402 *err
= sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT
, options
);
405 sys_chdir("/.."); /* will traverse into overmounted root */
407 complete(&setup_done
);
409 spin_lock(&req_lock
);
411 struct req
*req
= requests
;
413 spin_unlock(&req_lock
);
415 req
->err
= handle(req
->name
, req
->mode
, req
->dev
);
416 complete(&req
->done
);
419 spin_lock(&req_lock
);
421 set_current_state(TASK_INTERRUPTIBLE
);
422 spin_unlock(&req_lock
);
424 __set_current_state(TASK_RUNNING
);
428 complete(&setup_done
);
433 * Create devtmpfs instance, driver-core devices will add their device
436 int __init
devtmpfs_init(void)
438 int err
= register_filesystem(&dev_fs_type
);
440 printk(KERN_ERR
"devtmpfs: unable to register devtmpfs "
445 thread
= kthread_run(devtmpfsd
, &err
, "kdevtmpfs");
446 if (!IS_ERR(thread
)) {
447 wait_for_completion(&setup_done
);
449 err
= PTR_ERR(thread
);
454 printk(KERN_ERR
"devtmpfs: unable to create devtmpfs %i\n", err
);
455 unregister_filesystem(&dev_fs_type
);
459 printk(KERN_INFO
"devtmpfs: initialized\n");