1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * devtmpfs - kernel-maintained tmpfs-based /dev 4 * 5 * Copyright (C) 2009, Kay Sievers <kay.sievers@vrfy.org> 6 * 7 * During bootup, before any driver core device is registered, 8 * devtmpfs, a tmpfs-based filesystem is created. Every driver-core 9 * device which requests a device node, will add a node in this 10 * filesystem. 11 * By default, all devices are named after the name of the device, 12 * owned by root and have a default mode of 0600. Subsystems can 13 * overwrite the default setting if needed. 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/syscalls.h> 18 #include <linux/mount.h> 19 #include <linux/device.h> 20 #include <linux/genhd.h> 21 #include <linux/namei.h> 22 #include <linux/fs.h> 23 #include <linux/shmem_fs.h> 24 #include <linux/ramfs.h> 25 #include <linux/sched.h> 26 #include <linux/slab.h> 27 #include <linux/kthread.h> 28 #include <linux/init_syscalls.h> 29 #include <uapi/linux/mount.h> 30 #include "base.h" 31 32 static struct task_struct *thread; 33 34 static int __initdata mount_dev = IS_ENABLED(CONFIG_DEVTMPFS_MOUNT); 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 kuid_t uid; 45 kgid_t gid; 46 struct device *dev; 47 } *requests; 48 49 static int __init mount_param(char *str) 50 { 51 mount_dev = simple_strtoul(str, NULL, 0); 52 return 1; 53 } 54 __setup("devtmpfs.mount=", mount_param); 55 56 static struct vfsmount *mnt; 57 58 static struct dentry *public_dev_mount(struct file_system_type *fs_type, int flags, 59 const char *dev_name, void *data) 60 { 61 struct super_block *s = mnt->mnt_sb; 62 atomic_inc(&s->s_active); 63 down_write(&s->s_umount); 64 return dget(s->s_root); 65 } 66 67 static struct file_system_type internal_fs_type = { 68 .name = "devtmpfs", 69 #ifdef CONFIG_TMPFS 70 .init_fs_context = shmem_init_fs_context, 71 .parameters = shmem_fs_parameters, 72 #else 73 .init_fs_context = ramfs_init_fs_context, 74 .parameters = ramfs_fs_parameters, 75 #endif 76 .kill_sb = kill_litter_super, 77 }; 78 79 static struct file_system_type dev_fs_type = { 80 .name = "devtmpfs", 81 .mount = public_dev_mount, 82 }; 83 84 #ifdef CONFIG_BLOCK 85 static inline int is_blockdev(struct device *dev) 86 { 87 return dev->class == &block_class; 88 } 89 #else 90 static inline int is_blockdev(struct device *dev) { return 0; } 91 #endif 92 93 static int devtmpfs_submit_req(struct req *req, const char *tmp) 94 { 95 init_completion(&req->done); 96 97 spin_lock(&req_lock); 98 req->next = requests; 99 requests = req; 100 spin_unlock(&req_lock); 101 102 wake_up_process(thread); 103 wait_for_completion(&req->done); 104 105 kfree(tmp); 106 107 return req->err; 108 } 109 110 int devtmpfs_create_node(struct device *dev) 111 { 112 const char *tmp = NULL; 113 struct req req; 114 115 if (!thread) 116 return 0; 117 118 req.mode = 0; 119 req.uid = GLOBAL_ROOT_UID; 120 req.gid = GLOBAL_ROOT_GID; 121 req.name = device_get_devnode(dev, &req.mode, &req.uid, &req.gid, &tmp); 122 if (!req.name) 123 return -ENOMEM; 124 125 if (req.mode == 0) 126 req.mode = 0600; 127 if (is_blockdev(dev)) 128 req.mode |= S_IFBLK; 129 else 130 req.mode |= S_IFCHR; 131 132 req.dev = dev; 133 134 return devtmpfs_submit_req(&req, tmp); 135 } 136 137 int devtmpfs_delete_node(struct device *dev) 138 { 139 const char *tmp = NULL; 140 struct req req; 141 142 if (!thread) 143 return 0; 144 145 req.name = device_get_devnode(dev, NULL, NULL, NULL, &tmp); 146 if (!req.name) 147 return -ENOMEM; 148 149 req.mode = 0; 150 req.dev = dev; 151 152 return devtmpfs_submit_req(&req, tmp); 153 } 154 155 static int dev_mkdir(const char *name, umode_t mode) 156 { 157 struct dentry *dentry; 158 struct path path; 159 int err; 160 161 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); 162 if (IS_ERR(dentry)) 163 return PTR_ERR(dentry); 164 165 err = vfs_mkdir(&init_user_ns, d_inode(path.dentry), dentry, mode); 166 if (!err) 167 /* mark as kernel-created inode */ 168 d_inode(dentry)->i_private = &thread; 169 done_path_create(&path, dentry); 170 return err; 171 } 172 173 static int create_path(const char *nodepath) 174 { 175 char *path; 176 char *s; 177 int err = 0; 178 179 /* parent directories do not exist, create them */ 180 path = kstrdup(nodepath, GFP_KERNEL); 181 if (!path) 182 return -ENOMEM; 183 184 s = path; 185 for (;;) { 186 s = strchr(s, '/'); 187 if (!s) 188 break; 189 s[0] = '\0'; 190 err = dev_mkdir(path, 0755); 191 if (err && err != -EEXIST) 192 break; 193 s[0] = '/'; 194 s++; 195 } 196 kfree(path); 197 return err; 198 } 199 200 static int handle_create(const char *nodename, umode_t mode, kuid_t uid, 201 kgid_t gid, struct device *dev) 202 { 203 struct dentry *dentry; 204 struct path path; 205 int err; 206 207 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); 208 if (dentry == ERR_PTR(-ENOENT)) { 209 create_path(nodename); 210 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); 211 } 212 if (IS_ERR(dentry)) 213 return PTR_ERR(dentry); 214 215 err = vfs_mknod(&init_user_ns, d_inode(path.dentry), dentry, mode, 216 dev->devt); 217 if (!err) { 218 struct iattr newattrs; 219 220 newattrs.ia_mode = mode; 221 newattrs.ia_uid = uid; 222 newattrs.ia_gid = gid; 223 newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID; 224 inode_lock(d_inode(dentry)); 225 notify_change(&init_user_ns, dentry, &newattrs, NULL); 226 inode_unlock(d_inode(dentry)); 227 228 /* mark as kernel-created inode */ 229 d_inode(dentry)->i_private = &thread; 230 } 231 done_path_create(&path, dentry); 232 return err; 233 } 234 235 static int dev_rmdir(const char *name) 236 { 237 struct path parent; 238 struct dentry *dentry; 239 int err; 240 241 dentry = kern_path_locked(name, &parent); 242 if (IS_ERR(dentry)) 243 return PTR_ERR(dentry); 244 if (d_really_is_positive(dentry)) { 245 if (d_inode(dentry)->i_private == &thread) 246 err = vfs_rmdir(&init_user_ns, d_inode(parent.dentry), 247 dentry); 248 else 249 err = -EPERM; 250 } else { 251 err = -ENOENT; 252 } 253 dput(dentry); 254 inode_unlock(d_inode(parent.dentry)); 255 path_put(&parent); 256 return err; 257 } 258 259 static int delete_path(const char *nodepath) 260 { 261 char *path; 262 int err = 0; 263 264 path = kstrdup(nodepath, GFP_KERNEL); 265 if (!path) 266 return -ENOMEM; 267 268 for (;;) { 269 char *base; 270 271 base = strrchr(path, '/'); 272 if (!base) 273 break; 274 base[0] = '\0'; 275 err = dev_rmdir(path); 276 if (err) 277 break; 278 } 279 280 kfree(path); 281 return err; 282 } 283 284 static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat) 285 { 286 /* did we create it */ 287 if (inode->i_private != &thread) 288 return 0; 289 290 /* does the dev_t match */ 291 if (is_blockdev(dev)) { 292 if (!S_ISBLK(stat->mode)) 293 return 0; 294 } else { 295 if (!S_ISCHR(stat->mode)) 296 return 0; 297 } 298 if (stat->rdev != dev->devt) 299 return 0; 300 301 /* ours */ 302 return 1; 303 } 304 305 static int handle_remove(const char *nodename, struct device *dev) 306 { 307 struct path parent; 308 struct dentry *dentry; 309 int deleted = 0; 310 int err; 311 312 dentry = kern_path_locked(nodename, &parent); 313 if (IS_ERR(dentry)) 314 return PTR_ERR(dentry); 315 316 if (d_really_is_positive(dentry)) { 317 struct kstat stat; 318 struct path p = {.mnt = parent.mnt, .dentry = dentry}; 319 err = vfs_getattr(&p, &stat, STATX_TYPE | STATX_MODE, 320 AT_STATX_SYNC_AS_STAT); 321 if (!err && dev_mynode(dev, d_inode(dentry), &stat)) { 322 struct iattr newattrs; 323 /* 324 * before unlinking this node, reset permissions 325 * of possible references like hardlinks 326 */ 327 newattrs.ia_uid = GLOBAL_ROOT_UID; 328 newattrs.ia_gid = GLOBAL_ROOT_GID; 329 newattrs.ia_mode = stat.mode & ~0777; 330 newattrs.ia_valid = 331 ATTR_UID|ATTR_GID|ATTR_MODE; 332 inode_lock(d_inode(dentry)); 333 notify_change(&init_user_ns, dentry, &newattrs, NULL); 334 inode_unlock(d_inode(dentry)); 335 err = vfs_unlink(&init_user_ns, d_inode(parent.dentry), 336 dentry, NULL); 337 if (!err || err == -ENOENT) 338 deleted = 1; 339 } 340 } else { 341 err = -ENOENT; 342 } 343 dput(dentry); 344 inode_unlock(d_inode(parent.dentry)); 345 346 path_put(&parent); 347 if (deleted && strchr(nodename, '/')) 348 delete_path(nodename); 349 return err; 350 } 351 352 /* 353 * If configured, or requested by the commandline, devtmpfs will be 354 * auto-mounted after the kernel mounted the root filesystem. 355 */ 356 int __init devtmpfs_mount(void) 357 { 358 int err; 359 360 if (!mount_dev) 361 return 0; 362 363 if (!thread) 364 return 0; 365 366 err = init_mount("devtmpfs", "dev", "devtmpfs", MS_SILENT, NULL); 367 if (err) 368 printk(KERN_INFO "devtmpfs: error mounting %i\n", err); 369 else 370 printk(KERN_INFO "devtmpfs: mounted\n"); 371 return err; 372 } 373 374 static DECLARE_COMPLETION(setup_done); 375 376 static int handle(const char *name, umode_t mode, kuid_t uid, kgid_t gid, 377 struct device *dev) 378 { 379 if (mode) 380 return handle_create(name, mode, uid, gid, dev); 381 else 382 return handle_remove(name, dev); 383 } 384 385 static void __noreturn devtmpfs_work_loop(void) 386 { 387 while (1) { 388 spin_lock(&req_lock); 389 while (requests) { 390 struct req *req = requests; 391 requests = NULL; 392 spin_unlock(&req_lock); 393 while (req) { 394 struct req *next = req->next; 395 req->err = handle(req->name, req->mode, 396 req->uid, req->gid, req->dev); 397 complete(&req->done); 398 req = next; 399 } 400 spin_lock(&req_lock); 401 } 402 __set_current_state(TASK_INTERRUPTIBLE); 403 spin_unlock(&req_lock); 404 schedule(); 405 } 406 } 407 408 static int __init devtmpfs_setup(void *p) 409 { 410 int err; 411 412 err = ksys_unshare(CLONE_NEWNS); 413 if (err) 414 goto out; 415 err = init_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, NULL); 416 if (err) 417 goto out; 418 init_chdir("/.."); /* will traverse into overmounted root */ 419 init_chroot("."); 420 out: 421 *(int *)p = err; 422 complete(&setup_done); 423 return err; 424 } 425 426 /* 427 * The __ref is because devtmpfs_setup needs to be __init for the routines it 428 * calls. That call is done while devtmpfs_init, which is marked __init, 429 * synchronously waits for it to complete. 430 */ 431 static int __ref devtmpfsd(void *p) 432 { 433 int err = devtmpfs_setup(p); 434 435 if (err) 436 return err; 437 devtmpfs_work_loop(); 438 return 0; 439 } 440 441 /* 442 * Create devtmpfs instance, driver-core devices will add their device 443 * nodes here. 444 */ 445 int __init devtmpfs_init(void) 446 { 447 char opts[] = "mode=0755"; 448 int err; 449 450 mnt = vfs_kern_mount(&internal_fs_type, 0, "devtmpfs", opts); 451 if (IS_ERR(mnt)) { 452 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %ld\n", 453 PTR_ERR(mnt)); 454 return PTR_ERR(mnt); 455 } 456 err = register_filesystem(&dev_fs_type); 457 if (err) { 458 printk(KERN_ERR "devtmpfs: unable to register devtmpfs " 459 "type %i\n", err); 460 return err; 461 } 462 463 thread = kthread_run(devtmpfsd, &err, "kdevtmpfs"); 464 if (!IS_ERR(thread)) { 465 wait_for_completion(&setup_done); 466 } else { 467 err = PTR_ERR(thread); 468 thread = NULL; 469 } 470 471 if (err) { 472 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); 473 unregister_filesystem(&dev_fs_type); 474 return err; 475 } 476 477 printk(KERN_INFO "devtmpfs: initialized\n"); 478 return 0; 479 } 480