linux/fs/sysfs/mount.c
<<
>>
Prefs
   1/*
   2 * fs/sysfs/symlink.c - operations for initializing and mounting sysfs
   3 *
   4 * Copyright (c) 2001-3 Patrick Mochel
   5 * Copyright (c) 2007 SUSE Linux Products GmbH
   6 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
   7 *
   8 * This file is released under the GPLv2.
   9 *
  10 * Please see Documentation/filesystems/sysfs.txt for more information.
  11 */
  12
  13#define DEBUG
  14
  15#include <linux/fs.h>
  16#include <linux/mount.h>
  17#include <linux/pagemap.h>
  18#include <linux/init.h>
  19#include <linux/module.h>
  20#include <linux/magic.h>
  21#include <linux/slab.h>
  22#include <linux/user_namespace.h>
  23
  24#include "sysfs.h"
  25
  26
  27static struct vfsmount *sysfs_mnt;
  28struct kmem_cache *sysfs_dir_cachep;
  29
  30static const struct super_operations sysfs_ops = {
  31        .statfs         = simple_statfs,
  32        .drop_inode     = generic_delete_inode,
  33        .evict_inode    = sysfs_evict_inode,
  34};
  35
  36struct sysfs_dirent sysfs_root = {
  37        .s_name         = "",
  38        .s_count        = ATOMIC_INIT(1),
  39        .s_flags        = SYSFS_DIR | (KOBJ_NS_TYPE_NONE << SYSFS_NS_TYPE_SHIFT),
  40        .s_mode         = S_IFDIR | S_IRUGO | S_IXUGO,
  41        .s_ino          = 1,
  42};
  43
  44static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
  45{
  46        struct inode *inode;
  47        struct dentry *root;
  48
  49        sb->s_blocksize = PAGE_CACHE_SIZE;
  50        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
  51        sb->s_magic = SYSFS_MAGIC;
  52        sb->s_op = &sysfs_ops;
  53        sb->s_time_gran = 1;
  54
  55        /* get root inode, initialize and unlock it */
  56        mutex_lock(&sysfs_mutex);
  57        inode = sysfs_get_inode(sb, &sysfs_root);
  58        mutex_unlock(&sysfs_mutex);
  59        if (!inode) {
  60                pr_debug("sysfs: could not get root inode\n");
  61                return -ENOMEM;
  62        }
  63
  64        /* instantiate and link root dentry */
  65        root = d_make_root(inode);
  66        if (!root) {
  67                pr_debug("%s: could not get root dentry!\n",__func__);
  68                return -ENOMEM;
  69        }
  70        root->d_fsdata = &sysfs_root;
  71        sb->s_root = root;
  72        sb->s_d_op = &sysfs_dentry_ops;
  73        return 0;
  74}
  75
  76static int sysfs_test_super(struct super_block *sb, void *data)
  77{
  78        struct sysfs_super_info *sb_info = sysfs_info(sb);
  79        struct sysfs_super_info *info = data;
  80        enum kobj_ns_type type;
  81        int found = 1;
  82
  83        for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++) {
  84                if (sb_info->ns[type] != info->ns[type])
  85                        found = 0;
  86        }
  87        return found;
  88}
  89
  90static int sysfs_set_super(struct super_block *sb, void *data)
  91{
  92        int error;
  93        error = set_anon_super(sb, data);
  94        if (!error)
  95                sb->s_fs_info = data;
  96        return error;
  97}
  98
  99static void free_sysfs_super_info(struct sysfs_super_info *info)
 100{
 101        int type;
 102        for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
 103                kobj_ns_drop(type, info->ns[type]);
 104        kfree(info);
 105}
 106
 107static struct dentry *sysfs_mount(struct file_system_type *fs_type,
 108        int flags, const char *dev_name, void *data)
 109{
 110        struct sysfs_super_info *info;
 111        enum kobj_ns_type type;
 112        struct super_block *sb;
 113        int error;
 114
 115        if (!(flags & MS_KERNMOUNT) && !current_user_ns()->may_mount_sysfs)
 116                return ERR_PTR(-EPERM);
 117
 118        info = kzalloc(sizeof(*info), GFP_KERNEL);
 119        if (!info)
 120                return ERR_PTR(-ENOMEM);
 121
 122        for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
 123                info->ns[type] = kobj_ns_grab_current(type);
 124
 125        sb = sget(fs_type, sysfs_test_super, sysfs_set_super, flags, info);
 126        if (IS_ERR(sb) || sb->s_fs_info != info)
 127                free_sysfs_super_info(info);
 128        if (IS_ERR(sb))
 129                return ERR_CAST(sb);
 130        if (!sb->s_root) {
 131                error = sysfs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
 132                if (error) {
 133                        deactivate_locked_super(sb);
 134                        return ERR_PTR(error);
 135                }
 136                sb->s_flags |= MS_ACTIVE;
 137        }
 138
 139        return dget(sb->s_root);
 140}
 141
 142static void sysfs_kill_sb(struct super_block *sb)
 143{
 144        struct sysfs_super_info *info = sysfs_info(sb);
 145        /* Remove the superblock from fs_supers/s_instances
 146         * so we can't find it, before freeing sysfs_super_info.
 147         */
 148        kill_anon_super(sb);
 149        free_sysfs_super_info(info);
 150}
 151
 152static struct file_system_type sysfs_fs_type = {
 153        .name           = "sysfs",
 154        .mount          = sysfs_mount,
 155        .kill_sb        = sysfs_kill_sb,
 156        .fs_flags       = FS_USERNS_MOUNT,
 157};
 158
 159int __init sysfs_init(void)
 160{
 161        int err = -ENOMEM;
 162
 163        sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",
 164                                              sizeof(struct sysfs_dirent),
 165                                              0, 0, NULL);
 166        if (!sysfs_dir_cachep)
 167                goto out;
 168
 169        err = sysfs_inode_init();
 170        if (err)
 171                goto out_err;
 172
 173        err = register_filesystem(&sysfs_fs_type);
 174        if (!err) {
 175                sysfs_mnt = kern_mount(&sysfs_fs_type);
 176                if (IS_ERR(sysfs_mnt)) {
 177                        printk(KERN_ERR "sysfs: could not mount!\n");
 178                        err = PTR_ERR(sysfs_mnt);
 179                        sysfs_mnt = NULL;
 180                        unregister_filesystem(&sysfs_fs_type);
 181                        goto out_err;
 182                }
 183        } else
 184                goto out_err;
 185out:
 186        return err;
 187out_err:
 188        kmem_cache_destroy(sysfs_dir_cachep);
 189        sysfs_dir_cachep = NULL;
 190        goto out;
 191}
 192
 193#undef sysfs_get
 194struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd)
 195{
 196        return __sysfs_get(sd);
 197}
 198EXPORT_SYMBOL_GPL(sysfs_get);
 199
 200#undef sysfs_put
 201void sysfs_put(struct sysfs_dirent *sd)
 202{
 203        __sysfs_put(sd);
 204}
 205EXPORT_SYMBOL_GPL(sysfs_put);
 206
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.