blob: 17cf7cad601e56840adefbd1b16a8d0cd5c8a5d8 [file] [log] [blame]
Kay Sievers2b2af542009-04-30 15:23:42 +02001/*
2 * devtmpfs - kernel-maintained tmpfs-based /dev
3 *
4 * Copyright (C) 2009, Kay Sievers <kay.sievers@vrfy.org>
5 *
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
Kay Sieverse454cea2009-09-18 23:01:12 +02009 * filesystem.
Peter Korsgaard02fbe5e2012-04-17 12:13:18 +020010 * 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.
Kay Sievers2b2af542009-04-30 15:23:42 +020013 */
14
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>
21#include <linux/fs.h>
22#include <linux/shmem_fs.h>
Peter Korsgaardda5e4ef2010-03-16 21:55:21 +010023#include <linux/ramfs.h>
Kay Sieverse454cea2009-09-18 23:01:12 +020024#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
Al Viro2780f1f2011-06-27 16:25:29 -040026#include <linux/kthread.h>
Kay Sievers2b2af542009-04-30 15:23:42 +020027
Al Viro2780f1f2011-06-27 16:25:29 -040028static struct task_struct *thread;
Kay Sievers2b2af542009-04-30 15:23:42 +020029
30#if defined CONFIG_DEVTMPFS_MOUNT
Al Virofc14f2f2010-07-25 01:48:30 +040031static int mount_dev = 1;
Kay Sievers2b2af542009-04-30 15:23:42 +020032#else
Al Virofc14f2f2010-07-25 01:48:30 +040033static int mount_dev;
Kay Sievers2b2af542009-04-30 15:23:42 +020034#endif
35
Al Viro2780f1f2011-06-27 16:25:29 -040036static DEFINE_SPINLOCK(req_lock);
37
38static struct req {
39 struct req *next;
40 struct completion done;
41 int err;
42 const char *name;
Al Viro2c9ede52011-07-23 20:24:48 -040043 umode_t mode; /* 0 => delete */
Al Viro2780f1f2011-06-27 16:25:29 -040044 struct device *dev;
45} *requests;
Kay Sieversed413ae2009-10-28 19:51:06 +010046
Kay Sievers2b2af542009-04-30 15:23:42 +020047static int __init mount_param(char *str)
48{
Al Virofc14f2f2010-07-25 01:48:30 +040049 mount_dev = simple_strtoul(str, NULL, 0);
Kay Sievers2b2af542009-04-30 15:23:42 +020050 return 1;
51}
52__setup("devtmpfs.mount=", mount_param);
53
Al Virofc14f2f2010-07-25 01:48:30 +040054static struct dentry *dev_mount(struct file_system_type *fs_type, int flags,
55 const char *dev_name, void *data)
Kay Sievers2b2af542009-04-30 15:23:42 +020056{
Peter Korsgaardda5e4ef2010-03-16 21:55:21 +010057#ifdef CONFIG_TMPFS
Al Virofc14f2f2010-07-25 01:48:30 +040058 return mount_single(fs_type, flags, data, shmem_fill_super);
Peter Korsgaardda5e4ef2010-03-16 21:55:21 +010059#else
Al Virofc14f2f2010-07-25 01:48:30 +040060 return mount_single(fs_type, flags, data, ramfs_fill_super);
Peter Korsgaardda5e4ef2010-03-16 21:55:21 +010061#endif
Kay Sievers2b2af542009-04-30 15:23:42 +020062}
63
64static struct file_system_type dev_fs_type = {
65 .name = "devtmpfs",
Al Virofc14f2f2010-07-25 01:48:30 +040066 .mount = dev_mount,
Kay Sievers2b2af542009-04-30 15:23:42 +020067 .kill_sb = kill_litter_super,
68};
69
70#ifdef CONFIG_BLOCK
71static inline int is_blockdev(struct device *dev)
72{
73 return dev->class == &block_class;
74}
75#else
76static inline int is_blockdev(struct device *dev) { return 0; }
77#endif
78
Al Viro2780f1f2011-06-27 16:25:29 -040079int devtmpfs_create_node(struct device *dev)
80{
81 const char *tmp = NULL;
82 struct req req;
83
84 if (!thread)
85 return 0;
86
87 req.mode = 0;
88 req.name = device_get_devnode(dev, &req.mode, &tmp);
89 if (!req.name)
90 return -ENOMEM;
91
92 if (req.mode == 0)
93 req.mode = 0600;
94 if (is_blockdev(dev))
95 req.mode |= S_IFBLK;
96 else
97 req.mode |= S_IFCHR;
98
99 req.dev = dev;
100
101 init_completion(&req.done);
102
103 spin_lock(&req_lock);
104 req.next = requests;
105 requests = &req;
106 spin_unlock(&req_lock);
107
108 wake_up_process(thread);
109 wait_for_completion(&req.done);
110
111 kfree(tmp);
112
113 return req.err;
114}
115
116int devtmpfs_delete_node(struct device *dev)
117{
118 const char *tmp = NULL;
119 struct req req;
120
121 if (!thread)
122 return 0;
123
124 req.name = device_get_devnode(dev, NULL, &tmp);
125 if (!req.name)
126 return -ENOMEM;
127
128 req.mode = 0;
129 req.dev = dev;
130
131 init_completion(&req.done);
132
133 spin_lock(&req_lock);
134 req.next = requests;
135 requests = &req;
136 spin_unlock(&req_lock);
137
138 wake_up_process(thread);
139 wait_for_completion(&req.done);
140
141 kfree(tmp);
142 return req.err;
143}
144
Al Virofbd48a62011-07-24 10:47:56 -0400145static int dev_mkdir(const char *name, umode_t mode)
Kay Sievers2b2af542009-04-30 15:23:42 +0200146{
Kay Sievers2b2af542009-04-30 15:23:42 +0200147 struct dentry *dentry;
Al Viro69753a02011-06-27 16:35:45 -0400148 struct path path;
Kay Sievers2b2af542009-04-30 15:23:42 +0200149 int err;
150
Jeff Layton1ac12b42012-12-11 12:10:06 -0500151 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY);
Al Viro69753a02011-06-27 16:35:45 -0400152 if (IS_ERR(dentry))
153 return PTR_ERR(dentry);
Kay Sievers2b2af542009-04-30 15:23:42 +0200154
Al Viro69753a02011-06-27 16:35:45 -0400155 err = vfs_mkdir(path.dentry->d_inode, dentry, mode);
156 if (!err)
157 /* mark as kernel-created inode */
158 dentry->d_inode->i_private = &thread;
Al Viro921a1652012-07-20 01:15:31 +0400159 done_path_create(&path, dentry);
Kay Sievers2b2af542009-04-30 15:23:42 +0200160 return err;
161}
162
163static int create_path(const char *nodepath)
164{
Al Viro5da4e682011-06-27 16:37:12 -0400165 char *path;
166 char *s;
Al Viro9d108d22011-07-27 22:27:33 -0400167 int err = 0;
Kay Sievers2b2af542009-04-30 15:23:42 +0200168
Al Viro5da4e682011-06-27 16:37:12 -0400169 /* parent directories do not exist, create them */
170 path = kstrdup(nodepath, GFP_KERNEL);
171 if (!path)
172 return -ENOMEM;
Kay Sievers2b2af542009-04-30 15:23:42 +0200173
Al Viro5da4e682011-06-27 16:37:12 -0400174 s = path;
175 for (;;) {
176 s = strchr(s, '/');
177 if (!s)
178 break;
179 s[0] = '\0';
180 err = dev_mkdir(path, 0755);
181 if (err && err != -EEXIST)
182 break;
183 s[0] = '/';
184 s++;
Kay Sievers2b2af542009-04-30 15:23:42 +0200185 }
Al Viro5da4e682011-06-27 16:37:12 -0400186 kfree(path);
Kay Sievers2b2af542009-04-30 15:23:42 +0200187 return err;
188}
189
Al Virofbd48a62011-07-24 10:47:56 -0400190static int handle_create(const char *nodename, umode_t mode, struct device *dev)
Kay Sievers2b2af542009-04-30 15:23:42 +0200191{
Kay Sievers2b2af542009-04-30 15:23:42 +0200192 struct dentry *dentry;
Al Viro69753a02011-06-27 16:35:45 -0400193 struct path path;
Kay Sievers2b2af542009-04-30 15:23:42 +0200194 int err;
195
Al Viro69753a02011-06-27 16:35:45 -0400196 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
197 if (dentry == ERR_PTR(-ENOENT)) {
Kay Sievers2b2af542009-04-30 15:23:42 +0200198 create_path(nodename);
Al Viro69753a02011-06-27 16:35:45 -0400199 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
Kay Sievers2b2af542009-04-30 15:23:42 +0200200 }
Al Viro69753a02011-06-27 16:35:45 -0400201 if (IS_ERR(dentry))
202 return PTR_ERR(dentry);
Kay Sievers2b2af542009-04-30 15:23:42 +0200203
Al Viro69753a02011-06-27 16:35:45 -0400204 err = vfs_mknod(path.dentry->d_inode,
205 dentry, mode, dev->devt);
206 if (!err) {
207 struct iattr newattrs;
Kay Sievers00926992009-10-28 19:50:57 +0100208
Al Viro69753a02011-06-27 16:35:45 -0400209 /* fixup possibly umasked mode */
210 newattrs.ia_mode = mode;
211 newattrs.ia_valid = ATTR_MODE;
212 mutex_lock(&dentry->d_inode->i_mutex);
213 notify_change(dentry, &newattrs);
214 mutex_unlock(&dentry->d_inode->i_mutex);
Kay Sievers00926992009-10-28 19:50:57 +0100215
Al Viro69753a02011-06-27 16:35:45 -0400216 /* mark as kernel-created inode */
217 dentry->d_inode->i_private = &thread;
Kay Sievers2b2af542009-04-30 15:23:42 +0200218 }
Al Viro921a1652012-07-20 01:15:31 +0400219 done_path_create(&path, dentry);
Kay Sievers2b2af542009-04-30 15:23:42 +0200220 return err;
221}
222
223static int dev_rmdir(const char *name)
224{
Al Viro79714f72012-06-15 03:01:42 +0400225 struct path parent;
Kay Sievers2b2af542009-04-30 15:23:42 +0200226 struct dentry *dentry;
227 int err;
228
Al Viro79714f72012-06-15 03:01:42 +0400229 dentry = kern_path_locked(name, &parent);
230 if (IS_ERR(dentry))
231 return PTR_ERR(dentry);
232 if (dentry->d_inode) {
233 if (dentry->d_inode->i_private == &thread)
234 err = vfs_rmdir(parent.dentry->d_inode, dentry);
235 else
236 err = -EPERM;
Kay Sievers2b2af542009-04-30 15:23:42 +0200237 } else {
Al Viro79714f72012-06-15 03:01:42 +0400238 err = -ENOENT;
Kay Sievers2b2af542009-04-30 15:23:42 +0200239 }
Al Viro79714f72012-06-15 03:01:42 +0400240 dput(dentry);
241 mutex_unlock(&parent.dentry->d_inode->i_mutex);
242 path_put(&parent);
Kay Sievers2b2af542009-04-30 15:23:42 +0200243 return err;
244}
245
246static int delete_path(const char *nodepath)
247{
248 const char *path;
249 int err = 0;
250
251 path = kstrdup(nodepath, GFP_KERNEL);
252 if (!path)
253 return -ENOMEM;
254
Kay Sieversed413ae2009-10-28 19:51:06 +0100255 for (;;) {
Kay Sievers2b2af542009-04-30 15:23:42 +0200256 char *base;
257
258 base = strrchr(path, '/');
259 if (!base)
260 break;
261 base[0] = '\0';
262 err = dev_rmdir(path);
263 if (err)
264 break;
265 }
266
267 kfree(path);
268 return err;
269}
270
271static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat)
272{
273 /* did we create it */
Al Viro2780f1f2011-06-27 16:25:29 -0400274 if (inode->i_private != &thread)
Kay Sievers2b2af542009-04-30 15:23:42 +0200275 return 0;
276
277 /* does the dev_t match */
278 if (is_blockdev(dev)) {
279 if (!S_ISBLK(stat->mode))
280 return 0;
281 } else {
282 if (!S_ISCHR(stat->mode))
283 return 0;
284 }
285 if (stat->rdev != dev->devt)
286 return 0;
287
288 /* ours */
289 return 1;
290}
291
Al Viro2780f1f2011-06-27 16:25:29 -0400292static int handle_remove(const char *nodename, struct device *dev)
Kay Sievers2b2af542009-04-30 15:23:42 +0200293{
Al Viro79714f72012-06-15 03:01:42 +0400294 struct path parent;
Kay Sievers2b2af542009-04-30 15:23:42 +0200295 struct dentry *dentry;
Kay Sievers2b2af542009-04-30 15:23:42 +0200296 int deleted = 1;
297 int err;
298
Al Viro79714f72012-06-15 03:01:42 +0400299 dentry = kern_path_locked(nodename, &parent);
300 if (IS_ERR(dentry))
301 return PTR_ERR(dentry);
Kay Sievers2b2af542009-04-30 15:23:42 +0200302
Al Viro79714f72012-06-15 03:01:42 +0400303 if (dentry->d_inode) {
304 struct kstat stat;
305 err = vfs_getattr(parent.mnt, dentry, &stat);
306 if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
307 struct iattr newattrs;
308 /*
309 * before unlinking this node, reset permissions
310 * of possible references like hardlinks
311 */
Eric W. Biederman91fa2cc2012-04-25 04:25:35 -0700312 newattrs.ia_uid = GLOBAL_ROOT_UID;
313 newattrs.ia_gid = GLOBAL_ROOT_GID;
Al Viro79714f72012-06-15 03:01:42 +0400314 newattrs.ia_mode = stat.mode & ~0777;
315 newattrs.ia_valid =
316 ATTR_UID|ATTR_GID|ATTR_MODE;
317 mutex_lock(&dentry->d_inode->i_mutex);
318 notify_change(dentry, &newattrs);
319 mutex_unlock(&dentry->d_inode->i_mutex);
320 err = vfs_unlink(parent.dentry->d_inode, dentry);
321 if (!err || err == -ENOENT)
322 deleted = 1;
Kay Sievers2b2af542009-04-30 15:23:42 +0200323 }
Kay Sievers2b2af542009-04-30 15:23:42 +0200324 } else {
Al Viro79714f72012-06-15 03:01:42 +0400325 err = -ENOENT;
Kay Sievers2b2af542009-04-30 15:23:42 +0200326 }
Al Viro79714f72012-06-15 03:01:42 +0400327 dput(dentry);
328 mutex_unlock(&parent.dentry->d_inode->i_mutex);
Kay Sievers2b2af542009-04-30 15:23:42 +0200329
Al Viro79714f72012-06-15 03:01:42 +0400330 path_put(&parent);
Kay Sievers2b2af542009-04-30 15:23:42 +0200331 if (deleted && strchr(nodename, '/'))
332 delete_path(nodename);
Kay Sievers2b2af542009-04-30 15:23:42 +0200333 return err;
334}
335
336/*
337 * If configured, or requested by the commandline, devtmpfs will be
338 * auto-mounted after the kernel mounted the root filesystem.
339 */
Kay Sievers073120c2009-10-28 19:51:17 +0100340int devtmpfs_mount(const char *mntdir)
Kay Sievers2b2af542009-04-30 15:23:42 +0200341{
Kay Sievers2b2af542009-04-30 15:23:42 +0200342 int err;
343
Al Virofc14f2f2010-07-25 01:48:30 +0400344 if (!mount_dev)
Kay Sievers2b2af542009-04-30 15:23:42 +0200345 return 0;
346
Al Viro2780f1f2011-06-27 16:25:29 -0400347 if (!thread)
Kay Sievers2b2af542009-04-30 15:23:42 +0200348 return 0;
349
Kay Sievers073120c2009-10-28 19:51:17 +0100350 err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
Kay Sievers2b2af542009-04-30 15:23:42 +0200351 if (err)
352 printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
353 else
354 printk(KERN_INFO "devtmpfs: mounted\n");
Kay Sievers2b2af542009-04-30 15:23:42 +0200355 return err;
356}
357
Arnaud Lacombef9e0b152011-07-21 13:16:19 -0400358static DECLARE_COMPLETION(setup_done);
Al Viro2780f1f2011-06-27 16:25:29 -0400359
Al Virofbd48a62011-07-24 10:47:56 -0400360static int handle(const char *name, umode_t mode, struct device *dev)
Al Viro2780f1f2011-06-27 16:25:29 -0400361{
362 if (mode)
363 return handle_create(name, mode, dev);
364 else
365 return handle_remove(name, dev);
366}
367
368static int devtmpfsd(void *p)
369{
370 char options[] = "mode=0755";
371 int *err = p;
372 *err = sys_unshare(CLONE_NEWNS);
373 if (*err)
374 goto out;
375 *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
376 if (*err)
377 goto out;
378 sys_chdir("/.."); /* will traverse into overmounted root */
379 sys_chroot(".");
380 complete(&setup_done);
381 while (1) {
382 spin_lock(&req_lock);
383 while (requests) {
384 struct req *req = requests;
385 requests = NULL;
386 spin_unlock(&req_lock);
387 while (req) {
Al Viroe13889b2011-07-25 14:15:50 -0400388 struct req *next = req->next;
Al Viro2780f1f2011-06-27 16:25:29 -0400389 req->err = handle(req->name, req->mode, req->dev);
390 complete(&req->done);
Al Viroe13889b2011-07-25 14:15:50 -0400391 req = next;
Al Viro2780f1f2011-06-27 16:25:29 -0400392 }
393 spin_lock(&req_lock);
394 }
Kautuk Consul65e67572011-11-15 14:52:34 -0800395 __set_current_state(TASK_INTERRUPTIBLE);
Al Viro2780f1f2011-06-27 16:25:29 -0400396 spin_unlock(&req_lock);
397 schedule();
Al Viro2780f1f2011-06-27 16:25:29 -0400398 }
399 return 0;
400out:
401 complete(&setup_done);
402 return *err;
403}
404
Kay Sievers2b2af542009-04-30 15:23:42 +0200405/*
406 * Create devtmpfs instance, driver-core devices will add their device
407 * nodes here.
408 */
409int __init devtmpfs_init(void)
410{
Al Viro2780f1f2011-06-27 16:25:29 -0400411 int err = register_filesystem(&dev_fs_type);
Kay Sievers2b2af542009-04-30 15:23:42 +0200412 if (err) {
413 printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
414 "type %i\n", err);
415 return err;
416 }
417
Al Viro2780f1f2011-06-27 16:25:29 -0400418 thread = kthread_run(devtmpfsd, &err, "kdevtmpfs");
419 if (!IS_ERR(thread)) {
420 wait_for_completion(&setup_done);
421 } else {
422 err = PTR_ERR(thread);
423 thread = NULL;
424 }
425
426 if (err) {
Kay Sievers2b2af542009-04-30 15:23:42 +0200427 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
428 unregister_filesystem(&dev_fs_type);
429 return err;
430 }
Kay Sievers2b2af542009-04-30 15:23:42 +0200431
432 printk(KERN_INFO "devtmpfs: initialized\n");
433 return 0;
434}