diff options
author | Tejun Heo <tj@kernel.org> | 2013-11-28 14:54:44 -0500 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2013-11-29 21:16:08 -0500 |
commit | fa736a951e456b996a76826ba78ff974414c3b55 (patch) | |
tree | 2ba6b9289163b684e41f5efb95c92144b12e2c86 /fs/sysfs/mount.c | |
parent | 4b93dc9b1c684d0587fe44d36bbfdf45bd3bea9d (diff) |
sysfs, kernfs: move mount core code to fs/kernfs/mount.c
Move core mount code to fs/kernfs/mount.c. The respective
declarations in fs/sysfs/sysfs.h are moved to
fs/kernfs/kernfs-internal.h.
This is pure relocation.
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat (limited to 'fs/sysfs/mount.c')
-rw-r--r-- | fs/sysfs/mount.c | 152 |
1 files changed, 0 insertions, 152 deletions
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c index 5384732700ba..e7e3aa8e7b78 100644 --- a/fs/sysfs/mount.c +++ b/fs/sysfs/mount.c | |||
@@ -14,91 +14,14 @@ | |||
14 | 14 | ||
15 | #include <linux/fs.h> | 15 | #include <linux/fs.h> |
16 | #include <linux/mount.h> | 16 | #include <linux/mount.h> |
17 | #include <linux/pagemap.h> | ||
18 | #include <linux/init.h> | 17 | #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> | 18 | #include <linux/user_namespace.h> |
23 | 19 | ||
24 | #include "sysfs.h" | 20 | #include "sysfs.h" |
25 | 21 | ||
26 | |||
27 | struct kmem_cache *sysfs_dir_cachep; | ||
28 | |||
29 | static const struct super_operations sysfs_ops = { | ||
30 | .statfs = simple_statfs, | ||
31 | .drop_inode = generic_delete_inode, | ||
32 | .evict_inode = sysfs_evict_inode, | ||
33 | }; | ||
34 | |||
35 | static struct kernfs_root *sysfs_root; | 22 | static struct kernfs_root *sysfs_root; |
36 | struct sysfs_dirent *sysfs_root_sd; | 23 | struct sysfs_dirent *sysfs_root_sd; |
37 | 24 | ||
38 | static int sysfs_fill_super(struct super_block *sb) | ||
39 | { | ||
40 | struct sysfs_super_info *info = sysfs_info(sb); | ||
41 | struct inode *inode; | ||
42 | struct dentry *root; | ||
43 | |||
44 | sb->s_blocksize = PAGE_CACHE_SIZE; | ||
45 | sb->s_blocksize_bits = PAGE_CACHE_SHIFT; | ||
46 | sb->s_magic = SYSFS_MAGIC; | ||
47 | sb->s_op = &sysfs_ops; | ||
48 | sb->s_time_gran = 1; | ||
49 | |||
50 | /* get root inode, initialize and unlock it */ | ||
51 | mutex_lock(&sysfs_mutex); | ||
52 | inode = sysfs_get_inode(sb, info->root->sd); | ||
53 | mutex_unlock(&sysfs_mutex); | ||
54 | if (!inode) { | ||
55 | pr_debug("sysfs: could not get root inode\n"); | ||
56 | return -ENOMEM; | ||
57 | } | ||
58 | |||
59 | /* instantiate and link root dentry */ | ||
60 | root = d_make_root(inode); | ||
61 | if (!root) { | ||
62 | pr_debug("%s: could not get root dentry!\n", __func__); | ||
63 | return -ENOMEM; | ||
64 | } | ||
65 | kernfs_get(info->root->sd); | ||
66 | root->d_fsdata = info->root->sd; | ||
67 | sb->s_root = root; | ||
68 | sb->s_d_op = &sysfs_dentry_ops; | ||
69 | return 0; | ||
70 | } | ||
71 | |||
72 | static int sysfs_test_super(struct super_block *sb, void *data) | ||
73 | { | ||
74 | struct sysfs_super_info *sb_info = sysfs_info(sb); | ||
75 | struct sysfs_super_info *info = data; | ||
76 | |||
77 | return sb_info->root == info->root && sb_info->ns == info->ns; | ||
78 | } | ||
79 | |||
80 | static int sysfs_set_super(struct super_block *sb, void *data) | ||
81 | { | ||
82 | int error; | ||
83 | error = set_anon_super(sb, data); | ||
84 | if (!error) | ||
85 | sb->s_fs_info = data; | ||
86 | return error; | ||
87 | } | ||
88 | |||
89 | /** | ||
90 | * kernfs_super_ns - determine the namespace tag of a kernfs super_block | ||
91 | * @sb: super_block of interest | ||
92 | * | ||
93 | * Return the namespace tag associated with kernfs super_block @sb. | ||
94 | */ | ||
95 | const void *kernfs_super_ns(struct super_block *sb) | ||
96 | { | ||
97 | struct sysfs_super_info *info = sysfs_info(sb); | ||
98 | |||
99 | return info->ns; | ||
100 | } | ||
101 | |||
102 | static struct dentry *sysfs_mount(struct file_system_type *fs_type, | 25 | static struct dentry *sysfs_mount(struct file_system_type *fs_type, |
103 | int flags, const char *dev_name, void *data) | 26 | int flags, const char *dev_name, void *data) |
104 | { | 27 | { |
@@ -120,79 +43,12 @@ static struct dentry *sysfs_mount(struct file_system_type *fs_type, | |||
120 | return root; | 43 | return root; |
121 | } | 44 | } |
122 | 45 | ||
123 | /** | ||
124 | * kernfs_mount_ns - kernfs mount helper | ||
125 | * @fs_type: file_system_type of the fs being mounted | ||
126 | * @flags: mount flags specified for the mount | ||
127 | * @root: kernfs_root of the hierarchy being mounted | ||
128 | * @ns: optional namespace tag of the mount | ||
129 | * | ||
130 | * This is to be called from each kernfs user's file_system_type->mount() | ||
131 | * implementation, which should pass through the specified @fs_type and | ||
132 | * @flags, and specify the hierarchy and namespace tag to mount via @root | ||
133 | * and @ns, respectively. | ||
134 | * | ||
135 | * The return value can be passed to the vfs layer verbatim. | ||
136 | */ | ||
137 | struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, | ||
138 | struct kernfs_root *root, const void *ns) | ||
139 | { | ||
140 | struct super_block *sb; | ||
141 | struct sysfs_super_info *info; | ||
142 | int error; | ||
143 | |||
144 | info = kzalloc(sizeof(*info), GFP_KERNEL); | ||
145 | if (!info) | ||
146 | return ERR_PTR(-ENOMEM); | ||
147 | |||
148 | info->root = root; | ||
149 | info->ns = ns; | ||
150 | |||
151 | sb = sget(fs_type, sysfs_test_super, sysfs_set_super, flags, info); | ||
152 | if (IS_ERR(sb) || sb->s_fs_info != info) | ||
153 | kfree(info); | ||
154 | if (IS_ERR(sb)) | ||
155 | return ERR_CAST(sb); | ||
156 | if (!sb->s_root) { | ||
157 | error = sysfs_fill_super(sb); | ||
158 | if (error) { | ||
159 | deactivate_locked_super(sb); | ||
160 | return ERR_PTR(error); | ||
161 | } | ||
162 | sb->s_flags |= MS_ACTIVE; | ||
163 | } | ||
164 | |||
165 | return dget(sb->s_root); | ||
166 | } | ||
167 | |||
168 | static void sysfs_kill_sb(struct super_block *sb) | 46 | static void sysfs_kill_sb(struct super_block *sb) |
169 | { | 47 | { |
170 | kernfs_kill_sb(sb); | 48 | kernfs_kill_sb(sb); |
171 | kobj_ns_drop(KOBJ_NS_TYPE_NET, (void *)kernfs_super_ns(sb)); | 49 | kobj_ns_drop(KOBJ_NS_TYPE_NET, (void *)kernfs_super_ns(sb)); |
172 | } | 50 | } |
173 | 51 | ||
174 | /** | ||
175 | * kernfs_kill_sb - kill_sb for kernfs | ||
176 | * @sb: super_block being killed | ||
177 | * | ||
178 | * This can be used directly for file_system_type->kill_sb(). If a kernfs | ||
179 | * user needs extra cleanup, it can implement its own kill_sb() and call | ||
180 | * this function at the end. | ||
181 | */ | ||
182 | void kernfs_kill_sb(struct super_block *sb) | ||
183 | { | ||
184 | struct sysfs_super_info *info = sysfs_info(sb); | ||
185 | struct sysfs_dirent *root_sd = sb->s_root->d_fsdata; | ||
186 | |||
187 | /* | ||
188 | * Remove the superblock from fs_supers/s_instances | ||
189 | * so we can't find it, before freeing sysfs_super_info. | ||
190 | */ | ||
191 | kill_anon_super(sb); | ||
192 | kfree(info); | ||
193 | kernfs_put(root_sd); | ||
194 | } | ||
195 | |||
196 | static struct file_system_type sysfs_fs_type = { | 52 | static struct file_system_type sysfs_fs_type = { |
197 | .name = "sysfs", | 53 | .name = "sysfs", |
198 | .mount = sysfs_mount, | 54 | .mount = sysfs_mount, |
@@ -200,14 +56,6 @@ static struct file_system_type sysfs_fs_type = { | |||
200 | .fs_flags = FS_USERNS_MOUNT, | 56 | .fs_flags = FS_USERNS_MOUNT, |
201 | }; | 57 | }; |
202 | 58 | ||
203 | void __init kernfs_init(void) | ||
204 | { | ||
205 | sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache", | ||
206 | sizeof(struct sysfs_dirent), | ||
207 | 0, SLAB_PANIC, NULL); | ||
208 | sysfs_inode_init(); | ||
209 | } | ||
210 | |||
211 | int __init sysfs_init(void) | 59 | int __init sysfs_init(void) |
212 | { | 60 | { |
213 | int err; | 61 | int err; |