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 | ||
1ac12b4b | 151 | dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); |
69753a0f AV |
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; | |
921a1650 | 159 | done_path_create(&path, dentry); |
2b2af54a KS |
160 | return err; |
161 | } | |
162 | ||
163 | static int create_path(const char *nodepath) | |
164 | { | |
5da4e689 AV |
165 | char *path; |
166 | char *s; | |
9d108d25 | 167 | int err = 0; |
2b2af54a | 168 | |
5da4e689 AV |
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++; | |
2b2af54a | 185 | } |
5da4e689 | 186 | kfree(path); |
2b2af54a KS |
187 | return err; |
188 | } | |
189 | ||
fbd48a69 | 190 | static int handle_create(const char *nodename, umode_t mode, struct device *dev) |
2b2af54a | 191 | { |
2b2af54a | 192 | struct dentry *dentry; |
69753a0f | 193 | struct path path; |
2b2af54a KS |
194 | int err; |
195 | ||
69753a0f AV |
196 | dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); |
197 | if (dentry == ERR_PTR(-ENOENT)) { | |
2b2af54a | 198 | create_path(nodename); |
69753a0f | 199 | dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); |
2b2af54a | 200 | } |
69753a0f AV |
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; | |
2b2af54a | 218 | } |
921a1650 | 219 | done_path_create(&path, dentry); |
2b2af54a KS |
220 | return err; |
221 | } | |
222 | ||
223 | static int dev_rmdir(const char *name) | |
224 | { | |
79714f72 | 225 | struct path parent; |
2b2af54a KS |
226 | struct dentry *dentry; |
227 | int err; | |
228 | ||
79714f72 AV |
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; | |
2b2af54a | 237 | } else { |
79714f72 | 238 | err = -ENOENT; |
2b2af54a | 239 | } |
79714f72 AV |
240 | dput(dentry); |
241 | mutex_unlock(&parent.dentry->d_inode->i_mutex); | |
242 | path_put(&parent); | |
2b2af54a KS |
243 | return err; |
244 | } | |
245 | ||
246 | static 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 | ||
ed413ae6 | 255 | for (;;) { |
2b2af54a KS |
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 | ||
271 | static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat) | |
272 | { | |
273 | /* did we create it */ | |
2780f1ff | 274 | if (inode->i_private != &thread) |
2b2af54a KS |
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 | ||
2780f1ff | 292 | static int handle_remove(const char *nodename, struct device *dev) |
2b2af54a | 293 | { |
79714f72 | 294 | struct path parent; |
2b2af54a | 295 | struct dentry *dentry; |
2b2af54a KS |
296 | int deleted = 1; |
297 | int err; | |
298 | ||
79714f72 AV |
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 | 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 | */ | |
91fa2cca EB |
312 | newattrs.ia_uid = GLOBAL_ROOT_UID; |
313 | newattrs.ia_gid = GLOBAL_ROOT_GID; | |
79714f72 AV |
314 | 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; | |
2b2af54a | 323 | } |
2b2af54a | 324 | } else { |
79714f72 | 325 | err = -ENOENT; |
2b2af54a | 326 | } |
79714f72 AV |
327 | dput(dentry); |
328 | mutex_unlock(&parent.dentry->d_inode->i_mutex); | |
2b2af54a | 329 | |
79714f72 | 330 | path_put(&parent); |
2b2af54a KS |
331 | if (deleted && strchr(nodename, '/')) |
332 | delete_path(nodename); | |
2b2af54a KS |
333 | 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 | */ | |
073120cc | 340 | int devtmpfs_mount(const char *mntdir) |
2b2af54a | 341 | { |
2b2af54a KS |
342 | int err; |
343 | ||
fc14f2fe | 344 | if (!mount_dev) |
2b2af54a KS |
345 | return 0; |
346 | ||
2780f1ff | 347 | if (!thread) |
2b2af54a KS |
348 | return 0; |
349 | ||
073120cc | 350 | err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL); |
2b2af54a KS |
351 | if (err) |
352 | printk(KERN_INFO "devtmpfs: error mounting %i\n", err); | |
353 | else | |
354 | printk(KERN_INFO "devtmpfs: mounted\n"); | |
2b2af54a KS |
355 | return err; |
356 | } | |
357 | ||
f9e0b159 | 358 | static DECLARE_COMPLETION(setup_done); |
2780f1ff | 359 | |
fbd48a69 | 360 | static int handle(const char *name, umode_t mode, struct device *dev) |
2780f1ff AV |
361 | { |
362 | if (mode) | |
363 | return handle_create(name, mode, dev); | |
364 | else | |
365 | return handle_remove(name, dev); | |
366 | } | |
367 | ||
368 | static 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) { | |
e13889ba | 388 | struct req *next = req->next; |
2780f1ff AV |
389 | req->err = handle(req->name, req->mode, req->dev); |
390 | complete(&req->done); | |
e13889ba | 391 | req = next; |
2780f1ff AV |
392 | } |
393 | spin_lock(&req_lock); | |
394 | } | |
65e6757b | 395 | __set_current_state(TASK_INTERRUPTIBLE); |
2780f1ff AV |
396 | spin_unlock(&req_lock); |
397 | schedule(); | |
2780f1ff AV |
398 | } |
399 | return 0; | |
400 | out: | |
401 | complete(&setup_done); | |
402 | return *err; | |
403 | } | |
404 | ||
2b2af54a KS |
405 | /* |
406 | * Create devtmpfs instance, driver-core devices will add their device | |
407 | * nodes here. | |
408 | */ | |
409 | int __init devtmpfs_init(void) | |
410 | { | |
2780f1ff | 411 | int err = register_filesystem(&dev_fs_type); |
2b2af54a KS |
412 | if (err) { |
413 | printk(KERN_ERR "devtmpfs: unable to register devtmpfs " | |
414 | "type %i\n", err); | |
415 | return err; | |
416 | } | |
417 | ||
2780f1ff AV |
418 | 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) { | |
2b2af54a KS |
427 | printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); |
428 | unregister_filesystem(&dev_fs_type); | |
429 | return err; | |
430 | } | |
2b2af54a KS |
431 | |
432 | printk(KERN_INFO "devtmpfs: initialized\n"); | |
433 | return 0; | |
434 | } |