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 <uapi/linux/mount.h> 29 #include "base.h" 30 31 static struct task_struct *thread; 32 33 #if defined CONFIG_DEVTMPFS_MOUNT 34 static int mount_dev = 1; 35 #else 36 static int mount_dev; 37 #endif 38 39 static DEFINE_SPINLOCK(req_lock); 40 41 static struct req { 42 struct req *next; 43 struct completion done; 44 int err; 45 const char *name; 46 umode_t mode; /* 0 => delete */ 47 kuid_t uid; 48 kgid_t gid; 49 struct device *dev; 50 } *requests; 51 52 static int __init mount_param(char *str) 53 { 54 mount_dev = simple_strtoul(str, NULL, 0); 55 return 1; 56 } 57 __setup("devtmpfs.mount=", mount_param); 58 59 static struct dentry *dev_mount(struct file_system_type *fs_type, int flags, 60 const char *dev_name, void *data) 61 { 62 #ifdef CONFIG_TMPFS 63 return mount_single(fs_type, flags, data, shmem_fill_super); 64 #else 65 return mount_single(fs_type, flags, data, ramfs_fill_super); 66 #endif 67 } 68 69 static struct file_system_type dev_fs_type = { 70 .name = "devtmpfs", 71 .mount = dev_mount, 72 .kill_sb = kill_litter_super, 73 }; 74 75 #ifdef CONFIG_BLOCK 76 static inline int is_blockdev(struct device *dev) 77 { 78 return dev->class == &block_class; 79 } 80 #else 81 static inline int is_blockdev(struct device *dev) { return 0; } 82 #endif 83 84 int devtmpfs_create_node(struct device *dev) 85 { 86 const char *tmp = NULL; 87 struct req req; 88 89 if (!thread) 90 return 0; 91 92 req.mode = 0; 93 req.uid = GLOBAL_ROOT_UID; 94 req.gid = GLOBAL_ROOT_GID; 95 req.name = device_get_devnode(dev, &req.mode, &req.uid, &req.gid, &tmp); 96 if (!req.name) 97 return -ENOMEM; 98 99 if (req.mode == 0) 100 req.mode = 0600; 101 if (is_blockdev(dev)) 102 req.mode |= S_IFBLK; 103 else 104 req.mode |= S_IFCHR; 105 106 req.dev = dev; 107 108 init_completion(&req.done); 109 110 spin_lock(&req_lock); 111 req.next = requests; 112 requests = &req; 113 spin_unlock(&req_lock); 114 115 wake_up_process(thread); 116 wait_for_completion(&req.done); 117 118 kfree(tmp); 119 120 return req.err; 121 } 122 123 int devtmpfs_delete_node(struct device *dev) 124 { 125 const char *tmp = NULL; 126 struct req req; 127 128 if (!thread) 129 return 0; 130 131 req.name = device_get_devnode(dev, NULL, NULL, NULL, &tmp); 132 if (!req.name) 133 return -ENOMEM; 134 135 req.mode = 0; 136 req.dev = dev; 137 138 init_completion(&req.done); 139 140 spin_lock(&req_lock); 141 req.next = requests; 142 requests = &req; 143 spin_unlock(&req_lock); 144 145 wake_up_process(thread); 146 wait_for_completion(&req.done); 147 148 kfree(tmp); 149 return req.err; 150 } 151 152 static int dev_mkdir(const char *name, umode_t mode) 153 { 154 struct dentry *dentry; 155 struct path path; 156 int err; 157 158 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); 159 if (IS_ERR(dentry)) 160 return PTR_ERR(dentry); 161 162 err = vfs_mkdir(d_inode(path.dentry), dentry, mode); 163 if (!err) 164 /* mark as kernel-created inode */ 165 d_inode(dentry)->i_private = &thread; 166 done_path_create(&path, dentry); 167 return err; 168 } 169 170 static int create_path(const char *nodepath) 171 { 172 char *path; 173 char *s; 174 int err = 0; 175 176 /* parent directories do not exist, create them */ 177 path = kstrdup(nodepath, GFP_KERNEL); 178 if (!path) 179 return -ENOMEM; 180 181 s = path; 182 for (;;) { 183 s = strchr(s, '/'); 184 if (!s) 185 break; 186 s[0] = '\0'; 187 err = dev_mkdir(path, 0755); 188 if (err && err != -EEXIST) 189 break; 190 s[0] = '/'; 191 s++; 192 } 193 kfree(path); 194 return err; 195 } 196 197 static int handle_create(const char *nodename, umode_t mode, kuid_t uid, 198 kgid_t gid, struct device *dev) 199 { 200 struct dentry *dentry; 201 struct path path; 202 int err; 203 204 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); 205 if (dentry == ERR_PTR(-ENOENT)) { 206 create_path(nodename); 207 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); 208 } 209 if (IS_ERR(dentry)) 210 return PTR_ERR(dentry); 211 212 err = vfs_mknod(d_inode(path.dentry), dentry, mode, dev->devt); 213 if (!err) { 214 struct iattr newattrs; 215 216 newattrs.ia_mode = mode; 217 newattrs.ia_uid = uid; 218 newattrs.ia_gid = gid; 219 newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID; 220 inode_lock(d_inode(dentry)); 221 notify_change(dentry, &newattrs, NULL); 222 inode_unlock(d_inode(dentry)); 223 224 /* mark as kernel-created inode */ 225 d_inode(dentry)->i_private = &thread; 226 } 227 done_path_create(&path, dentry); 228 return err; 229 } 230 231 static int dev_rmdir(const char *name) 232 { 233 struct path parent; 234 struct dentry *dentry; 235 int err; 236 237 dentry = kern_path_locked(name, &parent); 238 if (IS_ERR(dentry)) 239 return PTR_ERR(dentry); 240 if (d_really_is_positive(dentry)) { 241 if (d_inode(dentry)->i_private == &thread) 242 err = vfs_rmdir(d_inode(parent.dentry), dentry); 243 else 244 err = -EPERM; 245 } else { 246 err = -ENOENT; 247 } 248 dput(dentry); 249 inode_unlock(d_inode(parent.dentry)); 250 path_put(&parent); 251 return err; 252 } 253 254 static int delete_path(const char *nodepath) 255 { 256 char *path; 257 int err = 0; 258 259 path = kstrdup(nodepath, GFP_KERNEL); 260 if (!path) 261 return -ENOMEM; 262 263 for (;;) { 264 char *base; 265 266 base = strrchr(path, '/'); 267 if (!base) 268 break; 269 base[0] = '\0'; 270 err = dev_rmdir(path); 271 if (err) 272 break; 273 } 274 275 kfree(path); 276 return err; 277 } 278 279 static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat) 280 { 281 /* did we create it */ 282 if (inode->i_private != &thread) 283 return 0; 284 285 /* does the dev_t match */ 286 if (is_blockdev(dev)) { 287 if (!S_ISBLK(stat->mode)) 288 return 0; 289 } else { 290 if (!S_ISCHR(stat->mode)) 291 return 0; 292 } 293 if (stat->rdev != dev->devt) 294 return 0; 295 296 /* ours */ 297 return 1; 298 } 299 300 static int handle_remove(const char *nodename, struct device *dev) 301 { 302 struct path parent; 303 struct dentry *dentry; 304 int deleted = 0; 305 int err; 306 307 dentry = kern_path_locked(nodename, &parent); 308 if (IS_ERR(dentry)) 309 return PTR_ERR(dentry); 310 311 if (d_really_is_positive(dentry)) { 312 struct kstat stat; 313 struct path p = {.mnt = parent.mnt, .dentry = dentry}; 314 err = vfs_getattr(&p, &stat, STATX_TYPE | STATX_MODE, 315 AT_STATX_SYNC_AS_STAT); 316 if (!err && dev_mynode(dev, d_inode(dentry), &stat)) { 317 struct iattr newattrs; 318 /* 319 * before unlinking this node, reset permissions 320 * of possible references like hardlinks 321 */ 322 newattrs.ia_uid = GLOBAL_ROOT_UID; 323 newattrs.ia_gid = GLOBAL_ROOT_GID; 324 newattrs.ia_mode = stat.mode & ~0777; 325 newattrs.ia_valid = 326 ATTR_UID|ATTR_GID|ATTR_MODE; 327 inode_lock(d_inode(dentry)); 328 notify_change(dentry, &newattrs, NULL); 329 inode_unlock(d_inode(dentry)); 330 err = vfs_unlink(d_inode(parent.dentry), dentry, NULL); 331 if (!err || err == -ENOENT) 332 deleted = 1; 333 } 334 } else { 335 err = -ENOENT; 336 } 337 dput(dentry); 338 inode_unlock(d_inode(parent.dentry)); 339 340 path_put(&parent); 341 if (deleted && strchr(nodename, '/')) 342 delete_path(nodename); 343 return err; 344 } 345 346 /* 347 * If configured, or requested by the commandline, devtmpfs will be 348 * auto-mounted after the kernel mounted the root filesystem. 349 */ 350 int devtmpfs_mount(const char *mntdir) 351 { 352 int err; 353 354 if (!mount_dev) 355 return 0; 356 357 if (!thread) 358 return 0; 359 360 err = ksys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, 361 NULL); 362 if (err) 363 printk(KERN_INFO "devtmpfs: error mounting %i\n", err); 364 else 365 printk(KERN_INFO "devtmpfs: mounted\n"); 366 return err; 367 } 368 369 static DECLARE_COMPLETION(setup_done); 370 371 static int handle(const char *name, umode_t mode, kuid_t uid, kgid_t gid, 372 struct device *dev) 373 { 374 if (mode) 375 return handle_create(name, mode, uid, gid, dev); 376 else 377 return handle_remove(name, dev); 378 } 379 380 static int devtmpfsd(void *p) 381 { 382 char options[] = "mode=0755"; 383 int *err = p; 384 *err = ksys_unshare(CLONE_NEWNS); 385 if (*err) 386 goto out; 387 *err = ksys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options); 388 if (*err) 389 goto out; 390 ksys_chdir("/.."); /* will traverse into overmounted root */ 391 ksys_chroot("."); 392 complete(&setup_done); 393 while (1) { 394 spin_lock(&req_lock); 395 while (requests) { 396 struct req *req = requests; 397 requests = NULL; 398 spin_unlock(&req_lock); 399 while (req) { 400 struct req *next = req->next; 401 req->err = handle(req->name, req->mode, 402 req->uid, req->gid, req->dev); 403 complete(&req->done); 404 req = next; 405 } 406 spin_lock(&req_lock); 407 } 408 __set_current_state(TASK_INTERRUPTIBLE); 409 spin_unlock(&req_lock); 410 schedule(); 411 } 412 return 0; 413 out: 414 complete(&setup_done); 415 return *err; 416 } 417 418 /* 419 * Create devtmpfs instance, driver-core devices will add their device 420 * nodes here. 421 */ 422 int __init devtmpfs_init(void) 423 { 424 int err = register_filesystem(&dev_fs_type); 425 if (err) { 426 printk(KERN_ERR "devtmpfs: unable to register devtmpfs " 427 "type %i\n", err); 428 return err; 429 } 430 431 thread = kthread_run(devtmpfsd, &err, "kdevtmpfs"); 432 if (!IS_ERR(thread)) { 433 wait_for_completion(&setup_done); 434 } else { 435 err = PTR_ERR(thread); 436 thread = NULL; 437 } 438 439 if (err) { 440 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); 441 unregister_filesystem(&dev_fs_type); 442 return err; 443 } 444 445 printk(KERN_INFO "devtmpfs: initialized\n"); 446 return 0; 447 } 448