projects/linux·blob v2.6.34 · refs

391 lines · 8.1 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 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/cred.h>
24#include <linux/sched.h>
25#include <linux/init_task.h>
26#include <linux/slab.h>
27
28static struct vfsmount *dev_mnt;
29
30#if defined CONFIG_DEVTMPFS_MOUNT
31static int dev_mount = 1;
32#else
33static int dev_mount;
34#endif
35
36static DEFINE_MUTEX(dirlock);
37
38static int __init mount_param(char *str)
39{
40 dev_mount = simple_strtoul(str, NULL, 0);
41 return 1;
42}
43__setup("devtmpfs.mount=", mount_param);
44
45static int dev_get_sb(struct file_system_type *fs_type, int flags,
46 const char *dev_name, void *data, struct vfsmount *mnt)
47{
48 return get_sb_single(fs_type, flags, data, shmem_fill_super, mnt);
49}
50
51static struct file_system_type dev_fs_type = {
52 .name = "devtmpfs",
53 .get_sb = dev_get_sb,
54 .kill_sb = kill_litter_super,
55};
56
57#ifdef CONFIG_BLOCK
58static inline int is_blockdev(struct device *dev)
59{
60 return dev->class == &block_class;
61}
62#else
63static inline int is_blockdev(struct device *dev) { return 0; }
64#endif
65
66static int dev_mkdir(const char *name, mode_t mode)
67{
68 struct nameidata nd;
69 struct dentry *dentry;
70 int err;
71
72 err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
73 name, LOOKUP_PARENT, &nd);
74 if (err)
75 return err;
76
77 dentry = lookup_create(&nd, 1);
78 if (!IS_ERR(dentry)) {
79 err = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
80 if (!err)
81 /* mark as kernel-created inode */
82 dentry->d_inode->i_private = &dev_mnt;
83 dput(dentry);
84 } else {
85 err = PTR_ERR(dentry);
86 }
87
88 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
89 path_put(&nd.path);
90 return err;
91}
92
93static int create_path(const char *nodepath)
94{
95 int err;
96
97 mutex_lock(&dirlock);
98 err = dev_mkdir(nodepath, 0755);
99 if (err == -ENOENT) {
100 char *path;
101 char *s;
102
103 /* parent directories do not exist, create them */
104 path = kstrdup(nodepath, GFP_KERNEL);
105 if (!path) {
106 err = -ENOMEM;
107 goto out;
108 }
109 s = path;
110 for (;;) {
111 s = strchr(s, '/');
112 if (!s)
113 break;
114 s[0] = '\0';
115 err = dev_mkdir(path, 0755);
116 if (err && err != -EEXIST)
117 break;
118 s[0] = '/';
119 s++;
120 }
121 kfree(path);
122 }
123out:
124 mutex_unlock(&dirlock);
125 return err;
126}
127
128int devtmpfs_create_node(struct device *dev)
129{
130 const char *tmp = NULL;
131 const char *nodename;
132 const struct cred *curr_cred;
133 mode_t mode = 0;
134 struct nameidata nd;
135 struct dentry *dentry;
136 int err;
137
138 if (!dev_mnt)
139 return 0;
140
141 nodename = device_get_devnode(dev, &mode, &tmp);
142 if (!nodename)
143 return -ENOMEM;
144
145 if (mode == 0)
146 mode = 0600;
147 if (is_blockdev(dev))
148 mode |= S_IFBLK;
149 else
150 mode |= S_IFCHR;
151
152 curr_cred = override_creds(&init_cred);
153
154 err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
155 nodename, LOOKUP_PARENT, &nd);
156 if (err == -ENOENT) {
157 create_path(nodename);
158 err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
159 nodename, LOOKUP_PARENT, &nd);
160 }
161 if (err)
162 goto out;
163
164 dentry = lookup_create(&nd, 0);
165 if (!IS_ERR(dentry)) {
166 err = vfs_mknod(nd.path.dentry->d_inode,
167 dentry, mode, dev->devt);
168 if (!err) {
169 struct iattr newattrs;
170
171 /* fixup possibly umasked mode */
172 newattrs.ia_mode = mode;
173 newattrs.ia_valid = ATTR_MODE;
174 mutex_lock(&dentry->d_inode->i_mutex);
175 notify_change(dentry, &newattrs);
176 mutex_unlock(&dentry->d_inode->i_mutex);
177
178 /* mark as kernel-created inode */
179 dentry->d_inode->i_private = &dev_mnt;
180 }
181 dput(dentry);
182 } else {
183 err = PTR_ERR(dentry);
184 }
185
186 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
187 path_put(&nd.path);
188out:
189 kfree(tmp);
190 revert_creds(curr_cred);
191 return err;
192}
193
194static int dev_rmdir(const char *name)
195{
196 struct nameidata nd;
197 struct dentry *dentry;
198 int err;
199
200 err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
201 name, LOOKUP_PARENT, &nd);
202 if (err)
203 return err;
204
205 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
206 dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
207 if (!IS_ERR(dentry)) {
208 if (dentry->d_inode) {
209 if (dentry->d_inode->i_private == &dev_mnt)
210 err = vfs_rmdir(nd.path.dentry->d_inode,
211 dentry);
212 else
213 err = -EPERM;
214 } else {
215 err = -ENOENT;
216 }
217 dput(dentry);
218 } else {
219 err = PTR_ERR(dentry);
220 }
221
222 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
223 path_put(&nd.path);
224 return err;
225}
226
227static int delete_path(const char *nodepath)
228{
229 const char *path;
230 int err = 0;
231
232 path = kstrdup(nodepath, GFP_KERNEL);
233 if (!path)
234 return -ENOMEM;
235
236 mutex_lock(&dirlock);
237 for (;;) {
238 char *base;
239
240 base = strrchr(path, '/');
241 if (!base)
242 break;
243 base[0] = '\0';
244 err = dev_rmdir(path);
245 if (err)
246 break;
247 }
248 mutex_unlock(&dirlock);
249
250 kfree(path);
251 return err;
252}
253
254static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat)
255{
256 /* did we create it */
257 if (inode->i_private != &dev_mnt)
258 return 0;
259
260 /* does the dev_t match */
261 if (is_blockdev(dev)) {
262 if (!S_ISBLK(stat->mode))
263 return 0;
264 } else {
265 if (!S_ISCHR(stat->mode))
266 return 0;
267 }
268 if (stat->rdev != dev->devt)
269 return 0;
270
271 /* ours */
272 return 1;
273}
274
275int devtmpfs_delete_node(struct device *dev)
276{
277 const char *tmp = NULL;
278 const char *nodename;
279 const struct cred *curr_cred;
280 struct nameidata nd;
281 struct dentry *dentry;
282 struct kstat stat;
283 int deleted = 1;
284 int err;
285
286 if (!dev_mnt)
287 return 0;
288
289 nodename = device_get_devnode(dev, NULL, &tmp);
290 if (!nodename)
291 return -ENOMEM;
292
293 curr_cred = override_creds(&init_cred);
294 err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
295 nodename, LOOKUP_PARENT, &nd);
296 if (err)
297 goto out;
298
299 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
300 dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
301 if (!IS_ERR(dentry)) {
302 if (dentry->d_inode) {
303 err = vfs_getattr(nd.path.mnt, dentry, &stat);
304 if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
305 struct iattr newattrs;
306 /*
307 * before unlinking this node, reset permissions
308 * of possible references like hardlinks
309 */
310 newattrs.ia_uid = 0;
311 newattrs.ia_gid = 0;
312 newattrs.ia_mode = stat.mode & ~0777;
313 newattrs.ia_valid =
314 ATTR_UID|ATTR_GID|ATTR_MODE;
315 mutex_lock(&dentry->d_inode->i_mutex);
316 notify_change(dentry, &newattrs);
317 mutex_unlock(&dentry->d_inode->i_mutex);
318 err = vfs_unlink(nd.path.dentry->d_inode,
319 dentry);
320 if (!err || err == -ENOENT)
321 deleted = 1;
322 }
323 } else {
324 err = -ENOENT;
325 }
326 dput(dentry);
327 } else {
328 err = PTR_ERR(dentry);
329 }
330 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
331
332 path_put(&nd.path);
333 if (deleted && strchr(nodename, '/'))
334 delete_path(nodename);
335out:
336 kfree(tmp);
337 revert_creds(curr_cred);
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 */
345int devtmpfs_mount(const char *mntdir)
346{
347 int err;
348
349 if (!dev_mount)
350 return 0;
351
352 if (!dev_mnt)
353 return 0;
354
355 err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
356 if (err)
357 printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
358 else
359 printk(KERN_INFO "devtmpfs: mounted\n");
360 return err;
361}
362
363/*
364 * Create devtmpfs instance, driver-core devices will add their device
365 * nodes here.
366 */
367int __init devtmpfs_init(void)
368{
369 int err;
370 struct vfsmount *mnt;
371 char options[] = "mode=0755";
372
373 err = register_filesystem(&dev_fs_type);
374 if (err) {
375 printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
376 "type %i\n", err);
377 return err;
378 }
379
380 mnt = kern_mount_data(&dev_fs_type, options);
381 if (IS_ERR(mnt)) {
382 err = PTR_ERR(mnt);
383 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
384 unregister_filesystem(&dev_fs_type);
385 return err;
386 }
387 dev_mnt = mnt;
388
389 printk(KERN_INFO "devtmpfs: initialized\n");
390 return 0;
391}