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, 1);
 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                err = vfs_getattr(parent.mnt, dentry, &stat);
 306                if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
 307                        struct iattr newattrs;
 308                        /*
 309                         * before unlinking this node, reset permissions
 310                         * of possible references like hardlinks
 311                         */
 312                        newattrs.ia_uid = GLOBAL_ROOT_UID;
 313                        newattrs.ia_gid = GLOBAL_ROOT_GID;
 314                        newattrs.ia_mode = stat.mode & ~0777;
 315                        newattrs.ia_valid =
 316                                ATTR_UID|ATTR_GID|ATTR_MODE;
 317                        mutex_lock(&dentry->d_inode->i_mutex);
 318                        notify_change(dentry, &newattrs);
 319                        mutex_unlock(&dentry->d_inode->i_mutex);
 320                        err = vfs_unlink(parent.dentry->d_inode, dentry);
 321                        if (!err || err == -ENOENT)
 322                                deleted = 1;
 323                }
 324        } else {
 325                err = -ENOENT;
 326        }
 327        dput(dentry);
 328        mutex_unlock(&parent.dentry->d_inode->i_mutex);
 329
 330        path_put(&parent);
 331        if (deleted && strchr(nodename, '/'))
 332                delete_path(nodename);
 333        return err;
 334}
 335
 336/*
 337 * If configured, or requested by the commandline, devtmpfs will be
 338 * auto-mounted after the kernel mounted the root filesystem.
 339 */
 340int devtmpfs_mount(const char *mntdir)
 341{
 342        int err;
 343
 344        if (!mount_dev)
 345                return 0;
 346
 347        if (!thread)
 348                return 0;
 349
 350        err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
 351        if (err)
 352                printk(KERN_INFO "devtmpfs: error mounting %i\n", err);
 353        else
 354                printk(KERN_INFO "devtmpfs: mounted\n");
 355        return err;
 356}
 357
 358static DECLARE_COMPLETION(setup_done);
 359
 360static int handle(const char *name, umode_t mode, struct device *dev)
 361{
 362        if (mode)
 363                return handle_create(name, mode, dev);
 364        else
 365                return handle_remove(name, dev);
 366}
 367
 368static int devtmpfsd(void *p)
 369{
 370        char options[] = "mode=0755";
 371        int *err = p;
 372        *err = sys_unshare(CLONE_NEWNS);
 373        if (*err)
 374                goto out;
 375        *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
 376        if (*err)
 377                goto out;
 378        sys_chdir("/.."); /* will traverse into overmounted root */
 379        sys_chroot(".");
 380        complete(&setup_done);
 381        while (1) {
 382                spin_lock(&req_lock);
 383                while (requests) {
 384                        struct req *req = requests;
 385                        requests = NULL;
 386                        spin_unlock(&req_lock);
 387                        while (req) {
 388                                struct req *next = req->next;
 389                                req->err = handle(req->name, req->mode, req->dev);
 390                                complete(&req->done);
 391                                req = next;
 392                        }
 393                        spin_lock(&req_lock);
 394                }
 395                __set_current_state(TASK_INTERRUPTIBLE);
 396                spin_unlock(&req_lock);
 397                schedule();
 398        }
 399        return 0;
 400out:
 401        complete(&setup_done);
 402        return *err;
 403}
 404
 405/*
 406 * Create devtmpfs instance, driver-core devices will add their device
 407 * nodes here.
 408 */
 409int __init devtmpfs_init(void)
 410{
 411        int err = register_filesystem(&dev_fs_type);
 412        if (err) {
 413                printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
 414                       "type %i\n", err);
 415                return err;
 416        }
 417
 418        thread = kthread_run(devtmpfsd, &err, "kdevtmpfs");
 419        if (!IS_ERR(thread)) {
 420                wait_for_completion(&setup_done);
 421        } else {
 422                err = PTR_ERR(thread);
 423                thread = NULL;
 424        }
 425
 426        if (err) {
 427                printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
 428                unregister_filesystem(&dev_fs_type);
 429                return err;
 430        }
 431
 432        printk(KERN_INFO "devtmpfs: initialized\n");
 433        return 0;
 434}
 435
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.