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 name of the device,
11 * owned by root and have a default mode of 0600. Subsystems can
12 * 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 umode_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
, umode_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
)
171 /* parent directories do not exist, create them */
172 path
= kstrdup(nodepath
, GFP_KERNEL
);
182 err
= dev_mkdir(path
, 0755);
183 if (err
&& err
!= -EEXIST
)
192 static int handle_create(const char *nodename
, umode_t mode
, struct device
*dev
)
194 struct dentry
*dentry
;
198 dentry
= kern_path_create(AT_FDCWD
, nodename
, &path
, 0);
199 if (dentry
== ERR_PTR(-ENOENT
)) {
200 create_path(nodename
);
201 dentry
= kern_path_create(AT_FDCWD
, nodename
, &path
, 0);
204 return PTR_ERR(dentry
);
206 err
= vfs_mknod(path
.dentry
->d_inode
,
207 dentry
, mode
, dev
->devt
);
209 struct iattr newattrs
;
211 /* fixup possibly umasked mode */
212 newattrs
.ia_mode
= mode
;
213 newattrs
.ia_valid
= ATTR_MODE
;
214 mutex_lock(&dentry
->d_inode
->i_mutex
);
215 notify_change(dentry
, &newattrs
);
216 mutex_unlock(&dentry
->d_inode
->i_mutex
);
218 /* mark as kernel-created inode */
219 dentry
->d_inode
->i_private
= &thread
;
223 mutex_unlock(&path
.dentry
->d_inode
->i_mutex
);
228 static int dev_rmdir(const char *name
)
231 struct dentry
*dentry
;
234 dentry
= kern_path_locked(name
, &parent
);
236 return PTR_ERR(dentry
);
237 if (dentry
->d_inode
) {
238 if (dentry
->d_inode
->i_private
== &thread
)
239 err
= vfs_rmdir(parent
.dentry
->d_inode
, dentry
);
246 mutex_unlock(&parent
.dentry
->d_inode
->i_mutex
);
251 static int delete_path(const char *nodepath
)
256 path
= kstrdup(nodepath
, GFP_KERNEL
);
263 base
= strrchr(path
, '/');
267 err
= dev_rmdir(path
);
276 static int dev_mynode(struct device
*dev
, struct inode
*inode
, struct kstat
*stat
)
278 /* did we create it */
279 if (inode
->i_private
!= &thread
)
282 /* does the dev_t match */
283 if (is_blockdev(dev
)) {
284 if (!S_ISBLK(stat
->mode
))
287 if (!S_ISCHR(stat
->mode
))
290 if (stat
->rdev
!= dev
->devt
)
297 static int handle_remove(const char *nodename
, struct device
*dev
)
300 struct dentry
*dentry
;
304 dentry
= kern_path_locked(nodename
, &parent
);
306 return PTR_ERR(dentry
);
308 if (dentry
->d_inode
) {
310 err
= vfs_getattr(parent
.mnt
, dentry
, &stat
);
311 if (!err
&& dev_mynode(dev
, dentry
->d_inode
, &stat
)) {
312 struct iattr newattrs
;
314 * before unlinking this node, reset permissions
315 * of possible references like hardlinks
319 newattrs
.ia_mode
= stat
.mode
& ~0777;
321 ATTR_UID
|ATTR_GID
|ATTR_MODE
;
322 mutex_lock(&dentry
->d_inode
->i_mutex
);
323 notify_change(dentry
, &newattrs
);
324 mutex_unlock(&dentry
->d_inode
->i_mutex
);
325 err
= vfs_unlink(parent
.dentry
->d_inode
, dentry
);
326 if (!err
|| err
== -ENOENT
)
333 mutex_unlock(&parent
.dentry
->d_inode
->i_mutex
);
336 if (deleted
&& strchr(nodename
, '/'))
337 delete_path(nodename
);
342 * If configured, or requested by the commandline, devtmpfs will be
343 * auto-mounted after the kernel mounted the root filesystem.
345 int devtmpfs_mount(const char *mntdir
)
355 err
= sys_mount("devtmpfs", (char *)mntdir
, "devtmpfs", MS_SILENT
, NULL
);
357 printk(KERN_INFO
"devtmpfs: error mounting %i\n", err
);
359 printk(KERN_INFO
"devtmpfs: mounted\n");
363 static DECLARE_COMPLETION(setup_done
);
365 static int handle(const char *name
, umode_t mode
, struct device
*dev
)
368 return handle_create(name
, mode
, dev
);
370 return handle_remove(name
, dev
);
373 static int devtmpfsd(void *p
)
375 char options
[] = "mode=0755";
377 *err
= sys_unshare(CLONE_NEWNS
);
380 *err
= sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT
, options
);
383 sys_chdir("/.."); /* will traverse into overmounted root */
385 complete(&setup_done
);
387 spin_lock(&req_lock
);
389 struct req
*req
= requests
;
391 spin_unlock(&req_lock
);
393 struct req
*next
= req
->next
;
394 req
->err
= handle(req
->name
, req
->mode
, req
->dev
);
395 complete(&req
->done
);
398 spin_lock(&req_lock
);
400 __set_current_state(TASK_INTERRUPTIBLE
);
401 spin_unlock(&req_lock
);
406 complete(&setup_done
);
411 * Create devtmpfs instance, driver-core devices will add their device
414 int __init
devtmpfs_init(void)
416 int err
= register_filesystem(&dev_fs_type
);
418 printk(KERN_ERR
"devtmpfs: unable to register devtmpfs "
423 thread
= kthread_run(devtmpfsd
, &err
, "kdevtmpfs");
424 if (!IS_ERR(thread
)) {
425 wait_for_completion(&setup_done
);
427 err
= PTR_ERR(thread
);
432 printk(KERN_ERR
"devtmpfs: unable to create devtmpfs %i\n", err
);
433 unregister_filesystem(&dev_fs_type
);
437 printk(KERN_INFO
"devtmpfs: initialized\n");