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