drivers/base/devtmpfs.c

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