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 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 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 path parent; 231 struct dentry *dentry; 232 int err; 233 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; 242 } else { 243 err = -ENOENT; 244 } 245 dput(dentry); 246 mutex_unlock(&parent.dentry->d_inode->i_mutex); 247 path_put(&parent); 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 260 for (;;) { 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 */ 279 if (inode->i_private != &thread) 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 297 static int handle_remove(const char *nodename, struct device *dev) 298 { 299 struct path parent; 300 struct dentry *dentry; 301 int deleted = 1; 302 int err; 303 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; 328 } 329 } else { 330 err = -ENOENT; 331 } 332 dput(dentry); 333 mutex_unlock(&parent.dentry->d_inode->i_mutex); 334 335 path_put(&parent); 336 if (deleted && strchr(nodename, '/')) 337 delete_path(nodename); 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 */ 345 int devtmpfs_mount(const char *mntdir) 346 { 347 int err; 348 349 if (!mount_dev) 350 return 0; 351 352 if (!thread) 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 static DECLARE_COMPLETION(setup_done); 364 365 static int handle(const char *name, umode_t mode, struct device *dev) 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) { 393 struct req *next = req->next; 394 req->err = handle(req->name, req->mode, req->dev); 395 complete(&req->done); 396 req = next; 397 } 398 spin_lock(&req_lock); 399 } 400 __set_current_state(TASK_INTERRUPTIBLE); 401 spin_unlock(&req_lock); 402 schedule(); 403 } 404 return 0; 405 out: 406 complete(&setup_done); 407 return *err; 408 } 409 410 /* 411 * Create devtmpfs instance, driver-core devices will add their device 412 * nodes here. 413 */ 414 int __init devtmpfs_init(void) 415 { 416 int err = register_filesystem(&dev_fs_type); 417 if (err) { 418 printk(KERN_ERR "devtmpfs: unable to register devtmpfs " 419 "type %i\n", err); 420 return err; 421 } 422 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) { 432 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); 433 unregister_filesystem(&dev_fs_type); 434 return err; 435 } 436 437 printk(KERN_INFO "devtmpfs: initialized\n"); 438 return 0; 439 } 440