projects/linux·blob v3.9 · refs

435 lines · 8.8 KiB

1/*
2 * devtmpfs - kernel-maintained tmpfs-based /dev
3 *
4 * Copyright (C) 2009, Kay Sievers <[email protected]>
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
9 * filesystem.
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.
13 */
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>
23#include <linux/ramfs.h>
24#include <linux/sched.h>
25#include <linux/slab.h>
26#include <linux/kthread.h>
27
28static struct task_struct *thread;
29
30#if defined CONFIG_DEVTMPFS_MOUNT
31static int mount_dev = 1;
32#else
33static int mount_dev;
34#endif
35
36static DEFINE_SPINLOCK(req_lock);
37
38static struct req {
39 struct req *next;
40 struct completion done;
41 int err;
42 const char *name;
43 umode_t mode; /* 0 => delete */
44 struct device *dev;
45} *requests;
46
47static int __init mount_param(char *str)
48{
49 mount_dev = simple_strtoul(str, NULL, 0);
50 return 1;
51}
52__setup("devtmpfs.mount=", mount_param);
53
54static struct dentry *dev_mount(struct file_system_type *fs_type, int flags,
55 const char *dev_name, void *data)
56{
57#ifdef CONFIG_TMPFS
58 return mount_single(fs_type, flags, data, shmem_fill_super);
59#else
60 return mount_single(fs_type, flags, data, ramfs_fill_super);
61#endif
62}
63
64static struct file_system_type dev_fs_type = {
65 .name = "devtmpfs",
66 .mount = dev_mount,
67 .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
79int 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
145static int dev_mkdir(const char *name, umode_t mode)
146{
147 struct dentry *dentry;
148 struct path path;
149 int err;
150
151 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY);
152 if (IS_ERR(dentry))
153 return PTR_ERR(dentry);
154
155 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;
159 done_path_create(&path, dentry);
160 return err;
161}
162
163static int create_path(const char *nodepath)
164{
165 char *path;
166 char *s;
167 int err = 0;
168
169 /* parent directories do not exist, create them */
170 path = kstrdup(nodepath, GFP_KERNEL);
171 if (!path)
172 return -ENOMEM;
173
174 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++;
185 }
186 kfree(path);
187 return err;
188}
189
190static int handle_create(const char *nodename, umode_t mode, struct device *dev)
191{
192 struct dentry *dentry;
193 struct path path;
194 int err;
195
196 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
197 if (dentry == ERR_PTR(-ENOENT)) {
198 create_path(nodename);
199 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
200 }
201 if (IS_ERR(dentry))
202 return PTR_ERR(dentry);
203
204 err = vfs_mknod(path.dentry->d_inode,
205 dentry, mode, dev->devt);
206 if (!err) {
207 struct iattr newattrs;
208
209 /* 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);
215
216 /* mark as kernel-created inode */
217 dentry->d_inode->i_private = &thread;
218 }
219 done_path_create(&path, dentry);
220 return err;
221}
222
223static int dev_rmdir(const char *name)
224{
225 struct path parent;
226 struct dentry *dentry;
227 int err;
228
229 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;
237 } else {
238 err = -ENOENT;
239 }
240 dput(dentry);
241 mutex_unlock(&parent.dentry->d_inode->i_mutex);
242 path_put(&parent);
243 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
255 for (;;) {
256 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 */
274 if (inode->i_private != &thread)
275 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
292static int handle_remove(const char *nodename, struct device *dev)
293{
294 struct path parent;
295 struct dentry *dentry;
296 int deleted = 1;
297 int err;
298
299 dentry = kern_path_locked(nodename, &parent);
300 if (IS_ERR(dentry))
301 return PTR_ERR(dentry);
302
303 if (dentry->d_inode) {
304 struct kstat stat;
305 struct path p = {.mnt = parent.mnt, .dentry = dentry};
306 err = vfs_getattr(&p, &stat);
307 if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
308 struct iattr newattrs;
309 /*
310 * before unlinking this node, reset permissions
311 * of possible references like hardlinks
312 */
313 newattrs.ia_uid = GLOBAL_ROOT_UID;
314 newattrs.ia_gid = GLOBAL_ROOT_GID;
315 newattrs.ia_mode = stat.mode & ~0777;
316 newattrs.ia_valid =
317 ATTR_UID|ATTR_GID|ATTR_MODE;
318 mutex_lock(&dentry->d_inode->i_mutex);
319 notify_change(dentry, &newattrs);
320 mutex_unlock(&dentry->d_inode->i_mutex);
321 err = vfs_unlink(parent.dentry->d_inode, dentry);
322 if (!err || err == -ENOENT)
323 deleted = 1;
324 }
325 } else {
326 err = -ENOENT;
327 }
328 dput(dentry);
329 mutex_unlock(&parent.dentry->d_inode->i_mutex);
330
331 path_put(&parent);
332 if (deleted && strchr(nodename, '/'))
333 delete_path(nodename);
334 return err;
335}
336
337/*
338 * If configured, or requested by the commandline, devtmpfs will be
339 * auto-mounted after the kernel mounted the root filesystem.
340 */
341int devtmpfs_mount(const char *mntdir)
342{
343 int err;
344
345 if (!mount_dev)
346 return 0;
347
348 if (!thread)
349 return 0;
350
351 err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
352 if (err)
353 printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
354 else
355 printk(KERN_INFO "devtmpfs: mounted\n");
356 return err;
357}
358
359static DECLARE_COMPLETION(setup_done);
360
361static int handle(const char *name, umode_t mode, struct device *dev)
362{
363 if (mode)
364 return handle_create(name, mode, dev);
365 else
366 return handle_remove(name, dev);
367}
368
369static int devtmpfsd(void *p)
370{
371 char options[] = "mode=0755";
372 int *err = p;
373 *err = sys_unshare(CLONE_NEWNS);
374 if (*err)
375 goto out;
376 *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
377 if (*err)
378 goto out;
379 sys_chdir("/.."); /* will traverse into overmounted root */
380 sys_chroot(".");
381 complete(&setup_done);
382 while (1) {
383 spin_lock(&req_lock);
384 while (requests) {
385 struct req *req = requests;
386 requests = NULL;
387 spin_unlock(&req_lock);
388 while (req) {
389 struct req *next = req->next;
390 req->err = handle(req->name, req->mode, req->dev);
391 complete(&req->done);
392 req = next;
393 }
394 spin_lock(&req_lock);
395 }
396 __set_current_state(TASK_INTERRUPTIBLE);
397 spin_unlock(&req_lock);
398 schedule();
399 }
400 return 0;
401out:
402 complete(&setup_done);
403 return *err;
404}
405
406/*
407 * Create devtmpfs instance, driver-core devices will add their device
408 * nodes here.
409 */
410int __init devtmpfs_init(void)
411{
412 int err = register_filesystem(&dev_fs_type);
413 if (err) {
414 printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
415 "type %i\n", err);
416 return err;
417 }
418
419 thread = kthread_run(devtmpfsd, &err, "kdevtmpfs");
420 if (!IS_ERR(thread)) {
421 wait_for_completion(&setup_done);
422 } else {
423 err = PTR_ERR(thread);
424 thread = NULL;
425 }
426
427 if (err) {
428 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
429 unregister_filesystem(&dev_fs_type);
430 return err;
431 }
432
433 printk(KERN_INFO "devtmpfs: initialized\n");
434 return 0;
435}