linux/drivers/base/devtmpfs.c
<<
>>
Prefs
   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
  32static struct task_struct *thread;
  33
  34static int __initdata mount_dev = IS_ENABLED(CONFIG_DEVTMPFS_MOUNT);
  35
  36static DEFINE_SPINLOCK(req_lock);
  37
  38static 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
  49static 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
  56static struct vfsmount *mnt;
  57
  58static 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
  67static 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
  79static struct file_system_type dev_fs_type = {
  80        .name = "devtmpfs",
  81        .mount = public_dev_mount,
  82};
  83
  84#ifdef CONFIG_BLOCK
  85static inline int is_blockdev(struct device *dev)
  86{
  87        return dev->class == &block_class;
  88}
  89#else
  90static inline int is_blockdev(struct device *dev) { return 0; }
  91#endif
  92
  93static 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
 110int 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
 137int 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
 155static 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
 173static 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
 200static 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
 234static 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
 257static 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
 282static 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
 303static 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 */
 353int __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
 371static DECLARE_COMPLETION(setup_done);
 372
 373static 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
 382static 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
 405static 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(".");
 417out:
 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 */
 428static 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 */
 442int __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