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(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(d_inode(path.dentry), dentry, mode, dev->devt); 216 if (!err) { 217 struct iattr newattrs; 218 219 newattrs.ia_mode = mode; 220 newattrs.ia_uid = uid; 221 newattrs.ia_gid = gid; 222 newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID; 223 inode_lock(d_inode(dentry)); 224 notify_change(dentry, &newattrs, NULL); 225 inode_unlock(d_inode(dentry)); 226 227 /* mark as kernel-created inode */ 228 d_inode(dentry)->i_private = &thread; 229 } 230 done_path_create(&path, dentry); 231 return err; 232 } 233 234 static int dev_rmdir(const char *name) 235 { 236 struct path parent; 237 struct dentry *dentry; 238 int err; 239 240 dentry = kern_path_locked(name, &parent); 241 if (IS_ERR(dentry)) 242 return PTR_ERR(dentry); 243 if (d_really_is_positive(dentry)) { 244 if (d_inode(dentry)->i_private == &thread) 245 err = vfs_rmdir(d_inode(parent.dentry), dentry); 246 else 247 err = -EPERM; 248 } else { 249 err = -ENOENT; 250 } 251 dput(dentry); 252 inode_unlock(d_inode(parent.dentry)); 253 path_put(&parent); 254 return err; 255 } 256 257 static int delete_path(const char *nodepath) 258 { 259 char *path; 260 int err = 0; 261 262 path = kstrdup(nodepath, GFP_KERNEL); 263 if (!path) 264 return -ENOMEM; 265 266 for (;;) { 267 char *base; 268 269 base = strrchr(path, '/'); 270 if (!base) 271 break; 272 base[0] = '\0'; 273 err = dev_rmdir(path); 274 if (err) 275 break; 276 } 277 278 kfree(path); 279 return err; 280 } 281 282 static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat) 283 { 284 /* did we create it */ 285 if (inode->i_private != &thread) 286 return 0; 287 288 /* does the dev_t match */ 289 if (is_blockdev(dev)) { 290 if (!S_ISBLK(stat->mode)) 291 return 0; 292 } else { 293 if (!S_ISCHR(stat->mode)) 294 return 0; 295 } 296 if (stat->rdev != dev->devt) 297 return 0; 298 299 /* ours */ 300 return 1; 301 } 302 303 static int handle_remove(const char *nodename, struct device *dev) 304 { 305 struct path parent; 306 struct dentry *dentry; 307 int deleted = 0; 308 int err; 309 310 dentry = kern_path_locked(nodename, &parent); 311 if (IS_ERR(dentry)) 312 return PTR_ERR(dentry); 313 314 if (d_really_is_positive(dentry)) { 315 struct kstat stat; 316 struct path p = {.mnt = parent.mnt, .dentry = dentry}; 317 err = vfs_getattr(&p, &stat, STATX_TYPE | STATX_MODE, 318 AT_STATX_SYNC_AS_STAT); 319 if (!err && dev_mynode(dev, d_inode(dentry), &stat)) { 320 struct iattr newattrs; 321 /* 322 * before unlinking this node, reset permissions 323 * of possible references like hardlinks 324 */ 325 newattrs.ia_uid = GLOBAL_ROOT_UID; 326 newattrs.ia_gid = GLOBAL_ROOT_GID; 327 newattrs.ia_mode = stat.mode & ~0777; 328 newattrs.ia_valid = 329 ATTR_UID|ATTR_GID|ATTR_MODE; 330 inode_lock(d_inode(dentry)); 331 notify_change(dentry, &newattrs, NULL); 332 inode_unlock(d_inode(dentry)); 333 err = vfs_unlink(d_inode(parent.dentry), dentry, NULL); 334 if (!err || err == -ENOENT) 335 deleted = 1; 336 } 337 } else { 338 err = -ENOENT; 339 } 340 dput(dentry); 341 inode_unlock(d_inode(parent.dentry)); 342 343 path_put(&parent); 344 if (deleted && strchr(nodename, '/')) 345 delete_path(nodename); 346 return err; 347 } 348 349 /* 350 * If configured, or requested by the commandline, devtmpfs will be 351 * auto-mounted after the kernel mounted the root filesystem. 352 */ 353 int __init devtmpfs_mount(void) 354 { 355 int err; 356 357 if (!mount_dev) 358 return 0; 359 360 if (!thread) 361 return 0; 362 363 err = init_mount("devtmpfs", "dev", "devtmpfs", MS_SILENT, NULL); 364 if (err) 365 printk(KERN_INFO "devtmpfs: error mounting %i\n", err); 366 else 367 printk(KERN_INFO "devtmpfs: mounted\n"); 368 return err; 369 } 370 371 static DECLARE_COMPLETION(setup_done); 372 373 static int handle(const char *name, umode_t mode, kuid_t uid, kgid_t gid, 374 struct device *dev) 375 { 376 if (mode) 377 return handle_create(name, mode, uid, gid, dev); 378 else 379 return handle_remove(name, dev); 380 } 381 382 static void __noreturn devtmpfs_work_loop(void) 383 { 384 while (1) { 385 spin_lock(&req_lock); 386 while (requests) { 387 struct req *req = requests; 388 requests = NULL; 389 spin_unlock(&req_lock); 390 while (req) { 391 struct req *next = req->next; 392 req->err = handle(req->name, req->mode, 393 req->uid, req->gid, req->dev); 394 complete(&req->done); 395 req = next; 396 } 397 spin_lock(&req_lock); 398 } 399 __set_current_state(TASK_INTERRUPTIBLE); 400 spin_unlock(&req_lock); 401 schedule(); 402 } 403 } 404 405 static int __init devtmpfs_setup(void *p) 406 { 407 int err; 408 409 err = ksys_unshare(CLONE_NEWNS); 410 if (err) 411 goto out; 412 err = init_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, NULL); 413 if (err) 414 goto out; 415 init_chdir("/.."); /* will traverse into overmounted root */ 416 init_chroot("."); 417 out: 418 *(int *)p = err; 419 complete(&setup_done); 420 return err; 421 } 422 423 /* 424 * The __ref is because devtmpfs_setup needs to be __init for the routines it 425 * calls. That call is done while devtmpfs_init, which is marked __init, 426 * synchronously waits for it to complete. 427 */ 428 static int __ref devtmpfsd(void *p) 429 { 430 int err = devtmpfs_setup(p); 431 432 if (err) 433 return err; 434 devtmpfs_work_loop(); 435 return 0; 436 } 437 438 /* 439 * Create devtmpfs instance, driver-core devices will add their device 440 * nodes here. 441 */ 442 int __init devtmpfs_init(void) 443 { 444 char opts[] = "mode=0755"; 445 int err; 446 447 mnt = vfs_kern_mount(&internal_fs_type, 0, "devtmpfs", opts); 448 if (IS_ERR(mnt)) { 449 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %ld\n", 450 PTR_ERR(mnt)); 451 return PTR_ERR(mnt); 452 } 453 err = register_filesystem(&dev_fs_type); 454 if (err) { 455 printk(KERN_ERR "devtmpfs: unable to register devtmpfs " 456 "type %i\n", err); 457 return err; 458 } 459 460 thread = kthread_run(devtmpfsd, &err, "kdevtmpfs"); 461 if (!IS_ERR(thread)) { 462 wait_for_completion(&setup_done); 463 } else { 464 err = PTR_ERR(thread); 465 thread = NULL; 466 } 467 468 if (err) { 469 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); 470 unregister_filesystem(&dev_fs_type); 471 return err; 472 } 473 474 printk(KERN_INFO "devtmpfs: initialized\n"); 475 return 0; 476 } 477