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