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