Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/fs/configfs/mount.c

  1 /* -*- mode: c; c-basic-offset: 8; -*-
  2  * vim: noexpandtab sw=8 ts=8 sts=0:
  3  *
  4  * mount.c - operations for initializing and mounting configfs.
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public
  8  * License as published by the Free Software Foundation; either
  9  * version 2 of the License, or (at your option) any later version.
 10  *
 11  * This program is distributed in the hope that it will be useful,
 12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14  * General Public License for more details.
 15  *
 16  * You should have received a copy of the GNU General Public
 17  * License along with this program; if not, write to the
 18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 19  * Boston, MA 021110-1307, USA.
 20  *
 21  * Based on sysfs:
 22  *      sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
 23  *
 24  * configfs Copyright (C) 2005 Oracle.  All rights reserved.
 25  */
 26 
 27 #include <linux/fs.h>
 28 #include <linux/module.h>
 29 #include <linux/mount.h>
 30 #include <linux/pagemap.h>
 31 #include <linux/init.h>
 32 #include <linux/slab.h>
 33 
 34 #include <linux/configfs.h>
 35 #include "configfs_internal.h"
 36 
 37 /* Random magic number */
 38 #define CONFIGFS_MAGIC 0x62656570
 39 
 40 static struct vfsmount *configfs_mount = NULL;
 41 struct kmem_cache *configfs_dir_cachep;
 42 static int configfs_mnt_count = 0;
 43 
 44 static const struct super_operations configfs_ops = {
 45         .statfs         = simple_statfs,
 46         .drop_inode     = generic_delete_inode,
 47 };
 48 
 49 static struct config_group configfs_root_group = {
 50         .cg_item = {
 51                 .ci_namebuf     = "root",
 52                 .ci_name        = configfs_root_group.cg_item.ci_namebuf,
 53         },
 54 };
 55 
 56 int configfs_is_root(struct config_item *item)
 57 {
 58         return item == &configfs_root_group.cg_item;
 59 }
 60 
 61 static struct configfs_dirent configfs_root = {
 62         .s_sibling      = LIST_HEAD_INIT(configfs_root.s_sibling),
 63         .s_children     = LIST_HEAD_INIT(configfs_root.s_children),
 64         .s_element      = &configfs_root_group.cg_item,
 65         .s_type         = CONFIGFS_ROOT,
 66         .s_iattr        = NULL,
 67 };
 68 
 69 static int configfs_fill_super(struct super_block *sb, void *data, int silent)
 70 {
 71         struct inode *inode;
 72         struct dentry *root;
 73 
 74         sb->s_blocksize = PAGE_CACHE_SIZE;
 75         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 76         sb->s_magic = CONFIGFS_MAGIC;
 77         sb->s_op = &configfs_ops;
 78         sb->s_time_gran = 1;
 79 
 80         inode = configfs_new_inode(S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
 81                                    &configfs_root, sb);
 82         if (inode) {
 83                 inode->i_op = &configfs_root_inode_operations;
 84                 inode->i_fop = &configfs_dir_operations;
 85                 /* directory inodes start off with i_nlink == 2 (for "." entry) */
 86                 inc_nlink(inode);
 87         } else {
 88                 pr_debug("could not get root inode\n");
 89                 return -ENOMEM;
 90         }
 91 
 92         root = d_make_root(inode);
 93         if (!root) {
 94                 pr_debug("%s: could not get root dentry!\n",__func__);
 95                 return -ENOMEM;
 96         }
 97         config_group_init(&configfs_root_group);
 98         configfs_root_group.cg_item.ci_dentry = root;
 99         root->d_fsdata = &configfs_root;
100         sb->s_root = root;
101         sb->s_d_op = &configfs_dentry_ops; /* the rest get that */
102         return 0;
103 }
104 
105 static struct dentry *configfs_do_mount(struct file_system_type *fs_type,
106         int flags, const char *dev_name, void *data)
107 {
108         return mount_single(fs_type, flags, data, configfs_fill_super);
109 }
110 
111 static struct file_system_type configfs_fs_type = {
112         .owner          = THIS_MODULE,
113         .name           = "configfs",
114         .mount          = configfs_do_mount,
115         .kill_sb        = kill_litter_super,
116 };
117 MODULE_ALIAS_FS("configfs");
118 
119 struct dentry *configfs_pin_fs(void)
120 {
121         int err = simple_pin_fs(&configfs_fs_type, &configfs_mount,
122                              &configfs_mnt_count);
123         return err ? ERR_PTR(err) : configfs_mount->mnt_root;
124 }
125 
126 void configfs_release_fs(void)
127 {
128         simple_release_fs(&configfs_mount, &configfs_mnt_count);
129 }
130 
131 
132 static struct kobject *config_kobj;
133 
134 static int __init configfs_init(void)
135 {
136         int err = -ENOMEM;
137 
138         configfs_dir_cachep = kmem_cache_create("configfs_dir_cache",
139                                                 sizeof(struct configfs_dirent),
140                                                 0, 0, NULL);
141         if (!configfs_dir_cachep)
142                 goto out;
143 
144         config_kobj = kobject_create_and_add("config", kernel_kobj);
145         if (!config_kobj)
146                 goto out2;
147 
148         err = configfs_inode_init();
149         if (err)
150                 goto out3;
151 
152         err = register_filesystem(&configfs_fs_type);
153         if (err)
154                 goto out4;
155 
156         return 0;
157 out4:
158         pr_err("Unable to register filesystem!\n");
159         configfs_inode_exit();
160 out3:
161         kobject_put(config_kobj);
162 out2:
163         kmem_cache_destroy(configfs_dir_cachep);
164         configfs_dir_cachep = NULL;
165 out:
166         return err;
167 }
168 
169 static void __exit configfs_exit(void)
170 {
171         unregister_filesystem(&configfs_fs_type);
172         kobject_put(config_kobj);
173         kmem_cache_destroy(configfs_dir_cachep);
174         configfs_dir_cachep = NULL;
175         configfs_inode_exit();
176 }
177 
178 MODULE_AUTHOR("Oracle");
179 MODULE_LICENSE("GPL");
180 MODULE_VERSION("0.0.2");
181 MODULE_DESCRIPTION("Simple RAM filesystem for user driven kernel subsystem configuration.");
182 
183 module_init(configfs_init);
184 module_exit(configfs_exit);
185 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us