regmap: name irq_chip based on regmap_irq_chip's name
[linux-2.6.git] / drivers / base / devtmpfs.c
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
9  * filesystem.
10  * By default, all devices are named after the the name of the
11  * device, owned by root and have a default mode of 0600. Subsystems
12  * can 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
28 static struct task_struct *thread;
29
30 #if defined CONFIG_DEVTMPFS_MOUNT
31 static int mount_dev = 1;
32 #else
33 static int mount_dev;
34 #endif
35
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;
43         umode_t mode;   /* 0 => delete */
44         struct device *dev;
45 } *requests;
46
47 static 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
54 static 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
64 static 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
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
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
145 static 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, 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);
162         return err;
163 }
164
165 static int create_path(const char *nodepath)
166 {
167         char *path;
168         char *s;
169         int err = 0;
170
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++;
187         }
188         kfree(path);
189         return err;
190 }
191
192 static int handle_create(const char *nodename, umode_t mode, struct device *dev)
193 {
194         struct dentry *dentry;
195         struct path path;
196         int err;
197
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);
202         }
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;
220         }
221         dput(dentry);
222
223         mutex_unlock(&path.dentry->d_inode->i_mutex);
224         path_put(&path);
225         return err;
226 }
227
228 static int dev_rmdir(const char *name)
229 {
230         struct nameidata nd;
231         struct dentry *dentry;
232         int err;
233
234         err = kern_path_parent(name, &nd);
235         if (err)
236                 return err;
237
238         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
239         dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
240         if (!IS_ERR(dentry)) {
241                 if (dentry->d_inode) {
242                         if (dentry->d_inode->i_private == &thread)
243                                 err = vfs_rmdir(nd.path.dentry->d_inode,
244                                                 dentry);
245                         else
246                                 err = -EPERM;
247                 } else {
248                         err = -ENOENT;
249                 }
250                 dput(dentry);
251         } else {
252                 err = PTR_ERR(dentry);
253         }
254
255         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
256         path_put(&nd.path);
257         return err;
258 }
259
260 static int delete_path(const char *nodepath)
261 {
262         const char *path;
263         int err = 0;
264
265         path = kstrdup(nodepath, GFP_KERNEL);
266         if (!path)
267                 return -ENOMEM;
268
269         for (;;) {
270                 char *base;
271
272                 base = strrchr(path, '/');
273                 if (!base)
274                         break;
275                 base[0] = '\0';
276                 err = dev_rmdir(path);
277                 if (err)
278                         break;
279         }
280
281         kfree(path);
282         return err;
283 }
284
285 static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat)
286 {
287         /* did we create it */
288         if (inode->i_private != &thread)
289                 return 0;
290
291         /* does the dev_t match */
292         if (is_blockdev(dev)) {
293                 if (!S_ISBLK(stat->mode))
294                         return 0;
295         } else {
296                 if (!S_ISCHR(stat->mode))
297                         return 0;
298         }
299         if (stat->rdev != dev->devt)
300                 return 0;
301
302         /* ours */
303         return 1;
304 }
305
306 static int handle_remove(const char *nodename, struct device *dev)
307 {
308         struct nameidata nd;
309         struct dentry *dentry;
310         struct kstat stat;
311         int deleted = 1;
312         int err;
313
314         err = kern_path_parent(nodename, &nd);
315         if (err)
316                 return err;
317
318         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
319         dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
320         if (!IS_ERR(dentry)) {
321                 if (dentry->d_inode) {
322                         err = vfs_getattr(nd.path.mnt, dentry, &stat);
323                         if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
324                                 struct iattr newattrs;
325                                 /*
326                                  * before unlinking this node, reset permissions
327                                  * of possible references like hardlinks
328                                  */
329                                 newattrs.ia_uid = 0;
330                                 newattrs.ia_gid = 0;
331                                 newattrs.ia_mode = stat.mode & ~0777;
332                                 newattrs.ia_valid =
333                                         ATTR_UID|ATTR_GID|ATTR_MODE;
334                                 mutex_lock(&dentry->d_inode->i_mutex);
335                                 notify_change(dentry, &newattrs);
336                                 mutex_unlock(&dentry->d_inode->i_mutex);
337                                 err = vfs_unlink(nd.path.dentry->d_inode,
338                                                  dentry);
339                                 if (!err || err == -ENOENT)
340                                         deleted = 1;
341                         }
342                 } else {
343                         err = -ENOENT;
344                 }
345                 dput(dentry);
346         } else {
347                 err = PTR_ERR(dentry);
348         }
349         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
350
351         path_put(&nd.path);
352         if (deleted && strchr(nodename, '/'))
353                 delete_path(nodename);
354         return err;
355 }
356
357 /*
358  * If configured, or requested by the commandline, devtmpfs will be
359  * auto-mounted after the kernel mounted the root filesystem.
360  */
361 int devtmpfs_mount(const char *mntdir)
362 {
363         int err;
364
365         if (!mount_dev)
366                 return 0;
367
368         if (!thread)
369                 return 0;
370
371         err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
372         if (err)
373                 printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
374         else
375                 printk(KERN_INFO "devtmpfs: mounted\n");
376         return err;
377 }
378
379 static DECLARE_COMPLETION(setup_done);
380
381 static int handle(const char *name, umode_t mode, struct device *dev)
382 {
383         if (mode)
384                 return handle_create(name, mode, dev);
385         else
386                 return handle_remove(name, dev);
387 }
388
389 static int devtmpfsd(void *p)
390 {
391         char options[] = "mode=0755";
392         int *err = p;
393         *err = sys_unshare(CLONE_NEWNS);
394         if (*err)
395                 goto out;
396         *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
397         if (*err)
398                 goto out;
399         sys_chdir("/.."); /* will traverse into overmounted root */
400         sys_chroot(".");
401         complete(&setup_done);
402         while (1) {
403                 spin_lock(&req_lock);
404                 while (requests) {
405                         struct req *req = requests;
406                         requests = NULL;
407                         spin_unlock(&req_lock);
408                         while (req) {
409                                 struct req *next = req->next;
410                                 req->err = handle(req->name, req->mode, req->dev);
411                                 complete(&req->done);
412                                 req = next;
413                         }
414                         spin_lock(&req_lock);
415                 }
416                 __set_current_state(TASK_INTERRUPTIBLE);
417                 spin_unlock(&req_lock);
418                 schedule();
419         }
420         return 0;
421 out:
422         complete(&setup_done);
423         return *err;
424 }
425
426 /*
427  * Create devtmpfs instance, driver-core devices will add their device
428  * nodes here.
429  */
430 int __init devtmpfs_init(void)
431 {
432         int err = register_filesystem(&dev_fs_type);
433         if (err) {
434                 printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
435                        "type %i\n", err);
436                 return err;
437         }
438
439         thread = kthread_run(devtmpfsd, &err, "kdevtmpfs");
440         if (!IS_ERR(thread)) {
441                 wait_for_completion(&setup_done);
442         } else {
443                 err = PTR_ERR(thread);
444                 thread = NULL;
445         }
446
447         if (err) {
448                 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
449                 unregister_filesystem(&dev_fs_type);
450                 return err;
451         }
452
453         printk(KERN_INFO "devtmpfs: initialized\n");
454         return 0;
455 }