Commit | Line | Data |
---|---|---|
2b2af54a KS |
1 | /* |
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 | |
e454cea2 | 9 | * filesystem. |
02fbe5e6 PK |
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. | |
2b2af54a KS |
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> | |
da5e4ef7 | 23 | #include <linux/ramfs.h> |
e454cea2 | 24 | #include <linux/sched.h> |
5a0e3ad6 | 25 | #include <linux/slab.h> |
2780f1ff | 26 | #include <linux/kthread.h> |
2b2af54a | 27 | |
2780f1ff | 28 | static struct task_struct *thread; |
2b2af54a KS |
29 | |
30 | #if defined CONFIG_DEVTMPFS_MOUNT | |
fc14f2fe | 31 | static int mount_dev = 1; |
2b2af54a | 32 | #else |
fc14f2fe | 33 | static int mount_dev; |
2b2af54a KS |
34 | #endif |
35 | ||
2780f1ff AV |
36 | static DEFINE_SPINLOCK(req_lock); |
37 | ||
38 | static struct req { | |
39 | struct req *next; | |
40 | struct completion done; | |
41 | int err; | |
42 | const char *name; | |
2c9ede55 | 43 | umode_t mode; /* 0 => delete */ |
2780f1ff AV |
44 | struct device *dev; |
45 | } *requests; | |
ed413ae6 | 46 | |
2b2af54a KS |
47 | static int __init mount_param(char *str) |
48 | { | |
fc14f2fe | 49 | mount_dev = simple_strtoul(str, NULL, 0); |
2b2af54a KS |
50 | return 1; |
51 | } | |
52 | __setup("devtmpfs.mount=", mount_param); | |
53 | ||
fc14f2fe AV |
54 | static struct dentry *dev_mount(struct file_system_type *fs_type, int flags, |
55 | const char *dev_name, void *data) | |
2b2af54a | 56 | { |
da5e4ef7 | 57 | #ifdef CONFIG_TMPFS |
fc14f2fe | 58 | return mount_single(fs_type, flags, data, shmem_fill_super); |
da5e4ef7 | 59 | #else |
fc14f2fe | 60 | return mount_single(fs_type, flags, data, ramfs_fill_super); |
da5e4ef7 | 61 | #endif |
2b2af54a KS |
62 | } |
63 | ||
64 | static struct file_system_type dev_fs_type = { | |
65 | .name = "devtmpfs", | |
fc14f2fe | 66 | .mount = dev_mount, |
2b2af54a KS |
67 | .kill_sb = kill_litter_super, |
68 | }; | |
69 | ||
70 | #ifdef CONFIG_BLOCK | |
71 | static inline int is_blockdev(struct device *dev) | |
72 | { | |
73 | return dev->class == &block_class; | |
74 | } | |
75 | #else | |
76 | static inline int is_blockdev(struct device *dev) { return 0; } | |
77 | #endif | |
78 | ||
2780f1ff AV |
79 | int 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 | ||
116 | int 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 | ||
fbd48a69 | 145 | static int dev_mkdir(const char *name, umode_t mode) |
2b2af54a | 146 | { |
2b2af54a | 147 | struct dentry *dentry; |
69753a0f | 148 | struct path path; |
2b2af54a KS |
149 | int err; |
150 | ||
69753a0f AV |
151 | dentry = kern_path_create(AT_FDCWD, name, &path, 1); |
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 | dput(dentry); | |
160 | mutex_unlock(&path.dentry->d_inode->i_mutex); | |
161 | path_put(&path); | |
2b2af54a KS |
162 | return err; |
163 | } | |
164 | ||
165 | static int create_path(const char *nodepath) | |
166 | { | |
5da4e689 AV |
167 | char *path; |
168 | char *s; | |
9d108d25 | 169 | int err = 0; |
2b2af54a | 170 | |
5da4e689 AV |
171 | /* parent directories do not exist, create them */ |
172 | path = kstrdup(nodepath, GFP_KERNEL); | |
173 | if (!path) | |
174 | return -ENOMEM; | |
175 | ||
176 | s = path; | |
177 | for (;;) { | |
178 | s = strchr(s, '/'); | |
179 | if (!s) | |
180 | break; | |
181 | s[0] = '\0'; | |
182 | err = dev_mkdir(path, 0755); | |
183 | if (err && err != -EEXIST) | |
184 | break; | |
185 | s[0] = '/'; | |
186 | s++; | |
2b2af54a | 187 | } |
5da4e689 | 188 | kfree(path); |
2b2af54a KS |
189 | return err; |
190 | } | |
191 | ||
fbd48a69 | 192 | static int handle_create(const char *nodename, umode_t mode, struct device *dev) |
2b2af54a | 193 | { |
2b2af54a | 194 | struct dentry *dentry; |
69753a0f | 195 | struct path path; |
2b2af54a KS |
196 | int err; |
197 | ||
69753a0f AV |
198 | dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); |
199 | if (dentry == ERR_PTR(-ENOENT)) { | |
2b2af54a | 200 | create_path(nodename); |
69753a0f | 201 | dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); |
2b2af54a | 202 | } |
69753a0f AV |
203 | if (IS_ERR(dentry)) |
204 | return PTR_ERR(dentry); | |
205 | ||
206 | err = vfs_mknod(path.dentry->d_inode, | |
207 | dentry, mode, dev->devt); | |
208 | if (!err) { | |
209 | struct iattr newattrs; | |
210 | ||
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); | |
217 | ||
218 | /* mark as kernel-created inode */ | |
219 | dentry->d_inode->i_private = &thread; | |
2b2af54a | 220 | } |
69753a0f | 221 | dput(dentry); |
2b2af54a | 222 | |
69753a0f AV |
223 | mutex_unlock(&path.dentry->d_inode->i_mutex); |
224 | path_put(&path); | |
2b2af54a KS |
225 | return err; |
226 | } | |
227 | ||
228 | static int dev_rmdir(const char *name) | |
229 | { | |
79714f72 | 230 | struct path parent; |
2b2af54a KS |
231 | struct dentry *dentry; |
232 | int err; | |
233 | ||
79714f72 AV |
234 | dentry = kern_path_locked(name, &parent); |
235 | if (IS_ERR(dentry)) | |
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); | |
240 | else | |
241 | err = -EPERM; | |
2b2af54a | 242 | } else { |
79714f72 | 243 | err = -ENOENT; |
2b2af54a | 244 | } |
79714f72 AV |
245 | dput(dentry); |
246 | mutex_unlock(&parent.dentry->d_inode->i_mutex); | |
247 | path_put(&parent); | |
2b2af54a KS |
248 | return err; |
249 | } | |
250 | ||
251 | static int delete_path(const char *nodepath) | |
252 | { | |
253 | const char *path; | |
254 | int err = 0; | |
255 | ||
256 | path = kstrdup(nodepath, GFP_KERNEL); | |
257 | if (!path) | |
258 | return -ENOMEM; | |
259 | ||
ed413ae6 | 260 | for (;;) { |
2b2af54a KS |
261 | char *base; |
262 | ||
263 | base = strrchr(path, '/'); | |
264 | if (!base) | |
265 | break; | |
266 | base[0] = '\0'; | |
267 | err = dev_rmdir(path); | |
268 | if (err) | |
269 | break; | |
270 | } | |
271 | ||
272 | kfree(path); | |
273 | return err; | |
274 | } | |
275 | ||
276 | static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat) | |
277 | { | |
278 | /* did we create it */ | |
2780f1ff | 279 | if (inode->i_private != &thread) |
2b2af54a KS |
280 | return 0; |
281 | ||
282 | /* does the dev_t match */ | |
283 | if (is_blockdev(dev)) { | |
284 | if (!S_ISBLK(stat->mode)) | |
285 | return 0; | |
286 | } else { | |
287 | if (!S_ISCHR(stat->mode)) | |
288 | return 0; | |
289 | } | |
290 | if (stat->rdev != dev->devt) | |
291 | return 0; | |
292 | ||
293 | /* ours */ | |
294 | return 1; | |
295 | } | |
296 | ||
2780f1ff | 297 | static int handle_remove(const char *nodename, struct device *dev) |
2b2af54a | 298 | { |
79714f72 | 299 | struct path parent; |
2b2af54a | 300 | struct dentry *dentry; |
2b2af54a KS |
301 | int deleted = 1; |
302 | int err; | |
303 | ||
79714f72 AV |
304 | dentry = kern_path_locked(nodename, &parent); |
305 | if (IS_ERR(dentry)) | |
306 | return PTR_ERR(dentry); | |
307 | ||
308 | if (dentry->d_inode) { | |
309 | struct kstat stat; | |
310 | err = vfs_getattr(parent.mnt, dentry, &stat); | |
311 | if (!err && dev_mynode(dev, dentry->d_inode, &stat)) { | |
312 | struct iattr newattrs; | |
313 | /* | |
314 | * before unlinking this node, reset permissions | |
315 | * of possible references like hardlinks | |
316 | */ | |
317 | newattrs.ia_uid = 0; | |
318 | newattrs.ia_gid = 0; | |
319 | newattrs.ia_mode = stat.mode & ~0777; | |
320 | newattrs.ia_valid = | |
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) | |
327 | deleted = 1; | |
2b2af54a | 328 | } |
2b2af54a | 329 | } else { |
79714f72 | 330 | err = -ENOENT; |
2b2af54a | 331 | } |
79714f72 AV |
332 | dput(dentry); |
333 | mutex_unlock(&parent.dentry->d_inode->i_mutex); | |
2b2af54a | 334 | |
79714f72 | 335 | path_put(&parent); |
2b2af54a KS |
336 | if (deleted && strchr(nodename, '/')) |
337 | delete_path(nodename); | |
2b2af54a KS |
338 | return err; |
339 | } | |
340 | ||
341 | /* | |
342 | * If configured, or requested by the commandline, devtmpfs will be | |
343 | * auto-mounted after the kernel mounted the root filesystem. | |
344 | */ | |
073120cc | 345 | int devtmpfs_mount(const char *mntdir) |
2b2af54a | 346 | { |
2b2af54a KS |
347 | int err; |
348 | ||
fc14f2fe | 349 | if (!mount_dev) |
2b2af54a KS |
350 | return 0; |
351 | ||
2780f1ff | 352 | if (!thread) |
2b2af54a KS |
353 | return 0; |
354 | ||
073120cc | 355 | err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL); |
2b2af54a KS |
356 | if (err) |
357 | printk(KERN_INFO "devtmpfs: error mounting %i\n", err); | |
358 | else | |
359 | printk(KERN_INFO "devtmpfs: mounted\n"); | |
2b2af54a KS |
360 | return err; |
361 | } | |
362 | ||
f9e0b159 | 363 | static DECLARE_COMPLETION(setup_done); |
2780f1ff | 364 | |
fbd48a69 | 365 | static int handle(const char *name, umode_t mode, struct device *dev) |
2780f1ff AV |
366 | { |
367 | if (mode) | |
368 | return handle_create(name, mode, dev); | |
369 | else | |
370 | return handle_remove(name, dev); | |
371 | } | |
372 | ||
373 | static int devtmpfsd(void *p) | |
374 | { | |
375 | char options[] = "mode=0755"; | |
376 | int *err = p; | |
377 | *err = sys_unshare(CLONE_NEWNS); | |
378 | if (*err) | |
379 | goto out; | |
380 | *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options); | |
381 | if (*err) | |
382 | goto out; | |
383 | sys_chdir("/.."); /* will traverse into overmounted root */ | |
384 | sys_chroot("."); | |
385 | complete(&setup_done); | |
386 | while (1) { | |
387 | spin_lock(&req_lock); | |
388 | while (requests) { | |
389 | struct req *req = requests; | |
390 | requests = NULL; | |
391 | spin_unlock(&req_lock); | |
392 | while (req) { | |
e13889ba | 393 | struct req *next = req->next; |
2780f1ff AV |
394 | req->err = handle(req->name, req->mode, req->dev); |
395 | complete(&req->done); | |
e13889ba | 396 | req = next; |
2780f1ff AV |
397 | } |
398 | spin_lock(&req_lock); | |
399 | } | |
65e6757b | 400 | __set_current_state(TASK_INTERRUPTIBLE); |
2780f1ff AV |
401 | spin_unlock(&req_lock); |
402 | schedule(); | |
2780f1ff AV |
403 | } |
404 | return 0; | |
405 | out: | |
406 | complete(&setup_done); | |
407 | return *err; | |
408 | } | |
409 | ||
2b2af54a KS |
410 | /* |
411 | * Create devtmpfs instance, driver-core devices will add their device | |
412 | * nodes here. | |
413 | */ | |
414 | int __init devtmpfs_init(void) | |
415 | { | |
2780f1ff | 416 | int err = register_filesystem(&dev_fs_type); |
2b2af54a KS |
417 | if (err) { |
418 | printk(KERN_ERR "devtmpfs: unable to register devtmpfs " | |
419 | "type %i\n", err); | |
420 | return err; | |
421 | } | |
422 | ||
2780f1ff AV |
423 | thread = kthread_run(devtmpfsd, &err, "kdevtmpfs"); |
424 | if (!IS_ERR(thread)) { | |
425 | wait_for_completion(&setup_done); | |
426 | } else { | |
427 | err = PTR_ERR(thread); | |
428 | thread = NULL; | |
429 | } | |
430 | ||
431 | if (err) { | |
2b2af54a KS |
432 | printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); |
433 | unregister_filesystem(&dev_fs_type); | |
434 | return err; | |
435 | } | |
2b2af54a KS |
436 | |
437 | printk(KERN_INFO "devtmpfs: initialized\n"); | |
438 | return 0; | |
439 | } |