Commit | Line | Data |
---|---|---|
55716d26 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b8441ed2 TH |
2 | /* |
3 | * fs/kernfs/mount.c - kernfs mount implementation | |
4 | * | |
5 | * Copyright (c) 2001-3 Patrick Mochel | |
6 | * Copyright (c) 2007 SUSE Linux Products GmbH | |
7 | * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org> | |
b8441ed2 | 8 | */ |
fa736a95 TH |
9 | |
10 | #include <linux/fs.h> | |
11 | #include <linux/mount.h> | |
12 | #include <linux/init.h> | |
13 | #include <linux/magic.h> | |
14 | #include <linux/slab.h> | |
15 | #include <linux/pagemap.h> | |
fb3c8315 | 16 | #include <linux/namei.h> |
4f41fc59 | 17 | #include <linux/seq_file.h> |
aa818825 | 18 | #include <linux/exportfs.h> |
fa736a95 TH |
19 | |
20 | #include "kernfs-internal.h" | |
21 | ||
26e28d68 | 22 | struct kmem_cache *kernfs_node_cache, *kernfs_iattrs_cache; |
fa736a95 | 23 | |
6a7fed4e TH |
24 | static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry) |
25 | { | |
319ba91d | 26 | struct kernfs_root *root = kernfs_root(kernfs_dentry_node(dentry)); |
6a7fed4e TH |
27 | struct kernfs_syscall_ops *scops = root->syscall_ops; |
28 | ||
29 | if (scops && scops->show_options) | |
30 | return scops->show_options(sf, root); | |
31 | return 0; | |
32 | } | |
33 | ||
4f41fc59 SH |
34 | static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry) |
35 | { | |
319ba91d | 36 | struct kernfs_node *node = kernfs_dentry_node(dentry); |
4f41fc59 SH |
37 | struct kernfs_root *root = kernfs_root(node); |
38 | struct kernfs_syscall_ops *scops = root->syscall_ops; | |
39 | ||
40 | if (scops && scops->show_path) | |
41 | return scops->show_path(sf, node, root); | |
42 | ||
3cc9b23c SH |
43 | seq_dentry(sf, dentry, " \t\n\\"); |
44 | return 0; | |
4f41fc59 SH |
45 | } |
46 | ||
f41c5934 | 47 | const struct super_operations kernfs_sops = { |
fa736a95 TH |
48 | .statfs = simple_statfs, |
49 | .drop_inode = generic_delete_inode, | |
c637b8ac | 50 | .evict_inode = kernfs_evict_inode, |
6a7fed4e | 51 | |
6a7fed4e | 52 | .show_options = kernfs_sop_show_options, |
4f41fc59 | 53 | .show_path = kernfs_sop_show_path, |
fa736a95 TH |
54 | }; |
55 | ||
69fd5c39 SL |
56 | /* |
57 | * Similar to kernfs_fh_get_inode, this one gets kernfs node from inode | |
58 | * number and generation | |
59 | */ | |
60 | struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root, | |
61 | const union kernfs_node_id *id) | |
62 | { | |
63 | struct kernfs_node *kn; | |
64 | ||
65 | kn = kernfs_find_and_get_node_by_ino(root, id->ino); | |
66 | if (!kn) | |
67 | return NULL; | |
68 | if (kn->id.generation != id->generation) { | |
69 | kernfs_put(kn); | |
70 | return NULL; | |
71 | } | |
72 | return kn; | |
73 | } | |
74 | ||
aa818825 SL |
75 | static struct inode *kernfs_fh_get_inode(struct super_block *sb, |
76 | u64 ino, u32 generation) | |
77 | { | |
78 | struct kernfs_super_info *info = kernfs_info(sb); | |
79 | struct inode *inode; | |
80 | struct kernfs_node *kn; | |
81 | ||
82 | if (ino == 0) | |
83 | return ERR_PTR(-ESTALE); | |
84 | ||
85 | kn = kernfs_find_and_get_node_by_ino(info->root, ino); | |
86 | if (!kn) | |
87 | return ERR_PTR(-ESTALE); | |
88 | inode = kernfs_get_inode(sb, kn); | |
89 | kernfs_put(kn); | |
ef13ecbc DC |
90 | if (!inode) |
91 | return ERR_PTR(-ESTALE); | |
aa818825 SL |
92 | |
93 | if (generation && inode->i_generation != generation) { | |
94 | /* we didn't find the right inode.. */ | |
95 | iput(inode); | |
96 | return ERR_PTR(-ESTALE); | |
97 | } | |
98 | return inode; | |
99 | } | |
100 | ||
101 | static struct dentry *kernfs_fh_to_dentry(struct super_block *sb, struct fid *fid, | |
102 | int fh_len, int fh_type) | |
103 | { | |
104 | return generic_fh_to_dentry(sb, fid, fh_len, fh_type, | |
105 | kernfs_fh_get_inode); | |
106 | } | |
107 | ||
108 | static struct dentry *kernfs_fh_to_parent(struct super_block *sb, struct fid *fid, | |
109 | int fh_len, int fh_type) | |
110 | { | |
111 | return generic_fh_to_parent(sb, fid, fh_len, fh_type, | |
112 | kernfs_fh_get_inode); | |
113 | } | |
114 | ||
115 | static struct dentry *kernfs_get_parent_dentry(struct dentry *child) | |
116 | { | |
117 | struct kernfs_node *kn = kernfs_dentry_node(child); | |
118 | ||
119 | return d_obtain_alias(kernfs_get_inode(child->d_sb, kn->parent)); | |
120 | } | |
121 | ||
122 | static const struct export_operations kernfs_export_ops = { | |
123 | .fh_to_dentry = kernfs_fh_to_dentry, | |
124 | .fh_to_parent = kernfs_fh_to_parent, | |
125 | .get_parent = kernfs_get_parent_dentry, | |
126 | }; | |
127 | ||
0c23b225 TH |
128 | /** |
129 | * kernfs_root_from_sb - determine kernfs_root associated with a super_block | |
130 | * @sb: the super_block in question | |
131 | * | |
132 | * Return the kernfs_root associated with @sb. If @sb is not a kernfs one, | |
133 | * %NULL is returned. | |
134 | */ | |
135 | struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) | |
136 | { | |
137 | if (sb->s_op == &kernfs_sops) | |
138 | return kernfs_info(sb)->root; | |
139 | return NULL; | |
140 | } | |
141 | ||
fb3c8315 AK |
142 | /* |
143 | * find the next ancestor in the path down to @child, where @parent was the | |
144 | * ancestor whose descendant we want to find. | |
145 | * | |
146 | * Say the path is /a/b/c/d. @child is d, @parent is NULL. We return the root | |
147 | * node. If @parent is b, then we return the node for c. | |
148 | * Passing in d as @parent is not ok. | |
149 | */ | |
150 | static struct kernfs_node *find_next_ancestor(struct kernfs_node *child, | |
151 | struct kernfs_node *parent) | |
152 | { | |
153 | if (child == parent) { | |
154 | pr_crit_once("BUG in find_next_ancestor: called with parent == child"); | |
155 | return NULL; | |
156 | } | |
157 | ||
158 | while (child->parent != parent) { | |
159 | if (!child->parent) | |
160 | return NULL; | |
161 | child = child->parent; | |
162 | } | |
163 | ||
164 | return child; | |
165 | } | |
166 | ||
167 | /** | |
168 | * kernfs_node_dentry - get a dentry for the given kernfs_node | |
169 | * @kn: kernfs_node for which a dentry is needed | |
170 | * @sb: the kernfs super_block | |
171 | */ | |
172 | struct dentry *kernfs_node_dentry(struct kernfs_node *kn, | |
173 | struct super_block *sb) | |
174 | { | |
175 | struct dentry *dentry; | |
176 | struct kernfs_node *knparent = NULL; | |
177 | ||
178 | BUG_ON(sb->s_op != &kernfs_sops); | |
179 | ||
180 | dentry = dget(sb->s_root); | |
181 | ||
182 | /* Check if this is the root kernfs_node */ | |
183 | if (!kn->parent) | |
184 | return dentry; | |
185 | ||
186 | knparent = find_next_ancestor(kn, NULL); | |
399504e2 AV |
187 | if (WARN_ON(!knparent)) { |
188 | dput(dentry); | |
fb3c8315 | 189 | return ERR_PTR(-EINVAL); |
399504e2 | 190 | } |
fb3c8315 AK |
191 | |
192 | do { | |
193 | struct dentry *dtmp; | |
194 | struct kernfs_node *kntmp; | |
195 | ||
196 | if (kn == knparent) | |
197 | return dentry; | |
198 | kntmp = find_next_ancestor(kn, knparent); | |
399504e2 AV |
199 | if (WARN_ON(!kntmp)) { |
200 | dput(dentry); | |
fb3c8315 | 201 | return ERR_PTR(-EINVAL); |
399504e2 | 202 | } |
779b8391 AV |
203 | dtmp = lookup_one_len_unlocked(kntmp->name, dentry, |
204 | strlen(kntmp->name)); | |
fb3c8315 AK |
205 | dput(dentry); |
206 | if (IS_ERR(dtmp)) | |
207 | return dtmp; | |
208 | knparent = kntmp; | |
209 | dentry = dtmp; | |
210 | } while (true); | |
211 | } | |
212 | ||
23bf1b6b | 213 | static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *kfc) |
fa736a95 | 214 | { |
c525aadd | 215 | struct kernfs_super_info *info = kernfs_info(sb); |
fa736a95 TH |
216 | struct inode *inode; |
217 | struct dentry *root; | |
218 | ||
7d568a83 | 219 | info->sb = sb; |
a2982cc9 EB |
220 | /* Userspace would break if executables or devices appear on sysfs */ |
221 | sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV; | |
09cbfeaf KS |
222 | sb->s_blocksize = PAGE_SIZE; |
223 | sb->s_blocksize_bits = PAGE_SHIFT; | |
23bf1b6b | 224 | sb->s_magic = kfc->magic; |
a797bfc3 | 225 | sb->s_op = &kernfs_sops; |
e72a1a8b | 226 | sb->s_xattr = kernfs_xattr_handlers; |
aa818825 SL |
227 | if (info->root->flags & KERNFS_ROOT_SUPPORT_EXPORTOP) |
228 | sb->s_export_op = &kernfs_export_ops; | |
fa736a95 TH |
229 | sb->s_time_gran = 1; |
230 | ||
4b85afbd JW |
231 | /* sysfs dentries and inodes don't require IO to create */ |
232 | sb->s_shrink.seeks = 0; | |
233 | ||
fa736a95 | 234 | /* get root inode, initialize and unlock it */ |
a797bfc3 | 235 | mutex_lock(&kernfs_mutex); |
c637b8ac | 236 | inode = kernfs_get_inode(sb, info->root->kn); |
a797bfc3 | 237 | mutex_unlock(&kernfs_mutex); |
fa736a95 | 238 | if (!inode) { |
c637b8ac | 239 | pr_debug("kernfs: could not get root inode\n"); |
fa736a95 TH |
240 | return -ENOMEM; |
241 | } | |
242 | ||
243 | /* instantiate and link root dentry */ | |
244 | root = d_make_root(inode); | |
245 | if (!root) { | |
246 | pr_debug("%s: could not get root dentry!\n", __func__); | |
247 | return -ENOMEM; | |
248 | } | |
fa736a95 | 249 | sb->s_root = root; |
a797bfc3 | 250 | sb->s_d_op = &kernfs_dops; |
fa736a95 TH |
251 | return 0; |
252 | } | |
253 | ||
23bf1b6b | 254 | static int kernfs_test_super(struct super_block *sb, struct fs_context *fc) |
fa736a95 | 255 | { |
c525aadd | 256 | struct kernfs_super_info *sb_info = kernfs_info(sb); |
23bf1b6b | 257 | struct kernfs_super_info *info = fc->s_fs_info; |
fa736a95 TH |
258 | |
259 | return sb_info->root == info->root && sb_info->ns == info->ns; | |
260 | } | |
261 | ||
23bf1b6b | 262 | static int kernfs_set_super(struct super_block *sb, struct fs_context *fc) |
fa736a95 | 263 | { |
23bf1b6b DH |
264 | struct kernfs_fs_context *kfc = fc->fs_private; |
265 | ||
266 | kfc->ns_tag = NULL; | |
267 | return set_anon_super_fc(sb, fc); | |
fa736a95 TH |
268 | } |
269 | ||
270 | /** | |
271 | * kernfs_super_ns - determine the namespace tag of a kernfs super_block | |
272 | * @sb: super_block of interest | |
273 | * | |
274 | * Return the namespace tag associated with kernfs super_block @sb. | |
275 | */ | |
276 | const void *kernfs_super_ns(struct super_block *sb) | |
277 | { | |
c525aadd | 278 | struct kernfs_super_info *info = kernfs_info(sb); |
fa736a95 TH |
279 | |
280 | return info->ns; | |
281 | } | |
282 | ||
283 | /** | |
23bf1b6b DH |
284 | * kernfs_get_tree - kernfs filesystem access/retrieval helper |
285 | * @fc: The filesystem context. | |
fa736a95 | 286 | * |
23bf1b6b DH |
287 | * This is to be called from each kernfs user's fs_context->ops->get_tree() |
288 | * implementation, which should set the specified ->@fs_type and ->@flags, and | |
289 | * specify the hierarchy and namespace tag to mount via ->@root and ->@ns, | |
290 | * respectively. | |
fa736a95 | 291 | */ |
23bf1b6b | 292 | int kernfs_get_tree(struct fs_context *fc) |
fa736a95 | 293 | { |
23bf1b6b | 294 | struct kernfs_fs_context *kfc = fc->fs_private; |
fa736a95 | 295 | struct super_block *sb; |
c525aadd | 296 | struct kernfs_super_info *info; |
fa736a95 TH |
297 | int error; |
298 | ||
299 | info = kzalloc(sizeof(*info), GFP_KERNEL); | |
300 | if (!info) | |
23bf1b6b | 301 | return -ENOMEM; |
fa736a95 | 302 | |
23bf1b6b DH |
303 | info->root = kfc->root; |
304 | info->ns = kfc->ns_tag; | |
82382ace | 305 | INIT_LIST_HEAD(&info->node); |
fa736a95 | 306 | |
23bf1b6b DH |
307 | fc->s_fs_info = info; |
308 | sb = sget_fc(fc, kernfs_test_super, kernfs_set_super); | |
fa736a95 | 309 | if (IS_ERR(sb)) |
23bf1b6b | 310 | return PTR_ERR(sb); |
fed95bab | 311 | |
fa736a95 | 312 | if (!sb->s_root) { |
7d568a83 TH |
313 | struct kernfs_super_info *info = kernfs_info(sb); |
314 | ||
23bf1b6b DH |
315 | kfc->new_sb_created = true; |
316 | ||
317 | error = kernfs_fill_super(sb, kfc); | |
fa736a95 TH |
318 | if (error) { |
319 | deactivate_locked_super(sb); | |
23bf1b6b | 320 | return error; |
fa736a95 | 321 | } |
1751e8a6 | 322 | sb->s_flags |= SB_ACTIVE; |
7d568a83 TH |
323 | |
324 | mutex_lock(&kernfs_mutex); | |
23bf1b6b | 325 | list_add(&info->node, &info->root->supers); |
7d568a83 | 326 | mutex_unlock(&kernfs_mutex); |
fa736a95 TH |
327 | } |
328 | ||
23bf1b6b DH |
329 | fc->root = dget(sb->s_root); |
330 | return 0; | |
331 | } | |
332 | ||
333 | void kernfs_free_fs_context(struct fs_context *fc) | |
334 | { | |
335 | /* Note that we don't deal with kfc->ns_tag here. */ | |
336 | kfree(fc->s_fs_info); | |
337 | fc->s_fs_info = NULL; | |
fa736a95 TH |
338 | } |
339 | ||
340 | /** | |
341 | * kernfs_kill_sb - kill_sb for kernfs | |
342 | * @sb: super_block being killed | |
343 | * | |
344 | * This can be used directly for file_system_type->kill_sb(). If a kernfs | |
345 | * user needs extra cleanup, it can implement its own kill_sb() and call | |
346 | * this function at the end. | |
347 | */ | |
348 | void kernfs_kill_sb(struct super_block *sb) | |
349 | { | |
c525aadd | 350 | struct kernfs_super_info *info = kernfs_info(sb); |
fa736a95 | 351 | |
7d568a83 TH |
352 | mutex_lock(&kernfs_mutex); |
353 | list_del(&info->node); | |
354 | mutex_unlock(&kernfs_mutex); | |
355 | ||
fa736a95 TH |
356 | /* |
357 | * Remove the superblock from fs_supers/s_instances | |
c525aadd | 358 | * so we can't find it, before freeing kernfs_super_info. |
fa736a95 TH |
359 | */ |
360 | kill_anon_super(sb); | |
361 | kfree(info); | |
fa736a95 TH |
362 | } |
363 | ||
364 | void __init kernfs_init(void) | |
365 | { | |
ba16b284 SL |
366 | |
367 | /* | |
368 | * the slab is freed in RCU context, so kernfs_find_and_get_node_by_ino | |
369 | * can access the slab lock free. This could introduce stale nodes, | |
370 | * please see how kernfs_find_and_get_node_by_ino filters out stale | |
371 | * nodes. | |
372 | */ | |
a797bfc3 | 373 | kernfs_node_cache = kmem_cache_create("kernfs_node_cache", |
324a56e1 | 374 | sizeof(struct kernfs_node), |
ba16b284 SL |
375 | 0, |
376 | SLAB_PANIC | SLAB_TYPESAFE_BY_RCU, | |
377 | NULL); | |
26e28d68 AM |
378 | |
379 | /* Creates slab cache for kernfs inode attributes */ | |
380 | kernfs_iattrs_cache = kmem_cache_create("kernfs_iattrs_cache", | |
381 | sizeof(struct kernfs_iattrs), | |
382 | 0, SLAB_PANIC, NULL); | |
fa736a95 | 383 | } |