1 | // SPDX-License-Identifier: GPL-2.0-only |
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> |
8 | */ |
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> |
16 | #include <linux/namei.h> |
17 | #include <linux/seq_file.h> |
18 | #include <linux/exportfs.h> |
19 | #include <linux/uuid.h> |
20 | #include <linux/statfs.h> |
21 | |
22 | #include "kernfs-internal.h" |
23 | |
24 | struct kmem_cache *kernfs_node_cache __ro_after_init; |
25 | struct kmem_cache *kernfs_iattrs_cache __ro_after_init; |
26 | struct kernfs_global_locks *kernfs_locks __ro_after_init; |
27 | |
28 | static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry) |
29 | { |
30 | struct kernfs_root *root = kernfs_root(kn: kernfs_dentry_node(dentry)); |
31 | struct kernfs_syscall_ops *scops = root->syscall_ops; |
32 | |
33 | if (scops && scops->show_options) |
34 | return scops->show_options(sf, root); |
35 | return 0; |
36 | } |
37 | |
38 | static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry) |
39 | { |
40 | struct kernfs_node *node = kernfs_dentry_node(dentry); |
41 | struct kernfs_root *root = kernfs_root(kn: node); |
42 | struct kernfs_syscall_ops *scops = root->syscall_ops; |
43 | |
44 | if (scops && scops->show_path) |
45 | return scops->show_path(sf, node, root); |
46 | |
47 | seq_dentry(sf, dentry, " \t\n\\" ); |
48 | return 0; |
49 | } |
50 | |
51 | static int kernfs_statfs(struct dentry *dentry, struct kstatfs *buf) |
52 | { |
53 | simple_statfs(dentry, buf); |
54 | buf->f_fsid = uuid_to_fsid(uuid: dentry->d_sb->s_uuid.b); |
55 | return 0; |
56 | } |
57 | |
58 | const struct super_operations kernfs_sops = { |
59 | .statfs = kernfs_statfs, |
60 | .drop_inode = generic_delete_inode, |
61 | .evict_inode = kernfs_evict_inode, |
62 | |
63 | .show_options = kernfs_sop_show_options, |
64 | .show_path = kernfs_sop_show_path, |
65 | }; |
66 | |
67 | static int kernfs_encode_fh(struct inode *inode, __u32 *fh, int *max_len, |
68 | struct inode *parent) |
69 | { |
70 | struct kernfs_node *kn = inode->i_private; |
71 | |
72 | if (*max_len < 2) { |
73 | *max_len = 2; |
74 | return FILEID_INVALID; |
75 | } |
76 | |
77 | *max_len = 2; |
78 | *(u64 *)fh = kn->id; |
79 | return FILEID_KERNFS; |
80 | } |
81 | |
82 | static struct dentry *__kernfs_fh_to_dentry(struct super_block *sb, |
83 | struct fid *fid, int fh_len, |
84 | int fh_type, bool get_parent) |
85 | { |
86 | struct kernfs_super_info *info = kernfs_info(sb); |
87 | struct kernfs_node *kn; |
88 | struct inode *inode; |
89 | u64 id; |
90 | |
91 | if (fh_len < 2) |
92 | return NULL; |
93 | |
94 | switch (fh_type) { |
95 | case FILEID_KERNFS: |
96 | id = *(u64 *)fid; |
97 | break; |
98 | case FILEID_INO32_GEN: |
99 | case FILEID_INO32_GEN_PARENT: |
100 | /* |
101 | * blk_log_action() exposes "LOW32,HIGH32" pair without |
102 | * type and userland can call us with generic fid |
103 | * constructed from them. Combine it back to ID. See |
104 | * blk_log_action(). |
105 | */ |
106 | id = ((u64)fid->i32.gen << 32) | fid->i32.ino; |
107 | break; |
108 | default: |
109 | return NULL; |
110 | } |
111 | |
112 | kn = kernfs_find_and_get_node_by_id(root: info->root, id); |
113 | if (!kn) |
114 | return ERR_PTR(error: -ESTALE); |
115 | |
116 | if (get_parent) { |
117 | struct kernfs_node *parent; |
118 | |
119 | parent = kernfs_get_parent(kn); |
120 | kernfs_put(kn); |
121 | kn = parent; |
122 | if (!kn) |
123 | return ERR_PTR(error: -ESTALE); |
124 | } |
125 | |
126 | inode = kernfs_get_inode(sb, kn); |
127 | kernfs_put(kn); |
128 | if (!inode) |
129 | return ERR_PTR(error: -ESTALE); |
130 | |
131 | return d_obtain_alias(inode); |
132 | } |
133 | |
134 | static struct dentry *kernfs_fh_to_dentry(struct super_block *sb, |
135 | struct fid *fid, int fh_len, |
136 | int fh_type) |
137 | { |
138 | return __kernfs_fh_to_dentry(sb, fid, fh_len, fh_type, get_parent: false); |
139 | } |
140 | |
141 | static struct dentry *kernfs_fh_to_parent(struct super_block *sb, |
142 | struct fid *fid, int fh_len, |
143 | int fh_type) |
144 | { |
145 | return __kernfs_fh_to_dentry(sb, fid, fh_len, fh_type, get_parent: true); |
146 | } |
147 | |
148 | static struct dentry *kernfs_get_parent_dentry(struct dentry *child) |
149 | { |
150 | struct kernfs_node *kn = kernfs_dentry_node(dentry: child); |
151 | |
152 | return d_obtain_alias(kernfs_get_inode(sb: child->d_sb, kn: kn->parent)); |
153 | } |
154 | |
155 | static const struct export_operations kernfs_export_ops = { |
156 | .encode_fh = kernfs_encode_fh, |
157 | .fh_to_dentry = kernfs_fh_to_dentry, |
158 | .fh_to_parent = kernfs_fh_to_parent, |
159 | .get_parent = kernfs_get_parent_dentry, |
160 | }; |
161 | |
162 | /** |
163 | * kernfs_root_from_sb - determine kernfs_root associated with a super_block |
164 | * @sb: the super_block in question |
165 | * |
166 | * Return: the kernfs_root associated with @sb. If @sb is not a kernfs one, |
167 | * %NULL is returned. |
168 | */ |
169 | struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) |
170 | { |
171 | if (sb->s_op == &kernfs_sops) |
172 | return kernfs_info(sb)->root; |
173 | return NULL; |
174 | } |
175 | |
176 | /* |
177 | * find the next ancestor in the path down to @child, where @parent was the |
178 | * ancestor whose descendant we want to find. |
179 | * |
180 | * Say the path is /a/b/c/d. @child is d, @parent is %NULL. We return the root |
181 | * node. If @parent is b, then we return the node for c. |
182 | * Passing in d as @parent is not ok. |
183 | */ |
184 | static struct kernfs_node *find_next_ancestor(struct kernfs_node *child, |
185 | struct kernfs_node *parent) |
186 | { |
187 | if (child == parent) { |
188 | pr_crit_once("BUG in find_next_ancestor: called with parent == child" ); |
189 | return NULL; |
190 | } |
191 | |
192 | while (child->parent != parent) { |
193 | if (!child->parent) |
194 | return NULL; |
195 | child = child->parent; |
196 | } |
197 | |
198 | return child; |
199 | } |
200 | |
201 | /** |
202 | * kernfs_node_dentry - get a dentry for the given kernfs_node |
203 | * @kn: kernfs_node for which a dentry is needed |
204 | * @sb: the kernfs super_block |
205 | * |
206 | * Return: the dentry pointer |
207 | */ |
208 | struct dentry *kernfs_node_dentry(struct kernfs_node *kn, |
209 | struct super_block *sb) |
210 | { |
211 | struct dentry *dentry; |
212 | struct kernfs_node *knparent = NULL; |
213 | |
214 | BUG_ON(sb->s_op != &kernfs_sops); |
215 | |
216 | dentry = dget(dentry: sb->s_root); |
217 | |
218 | /* Check if this is the root kernfs_node */ |
219 | if (!kn->parent) |
220 | return dentry; |
221 | |
222 | knparent = find_next_ancestor(child: kn, NULL); |
223 | if (WARN_ON(!knparent)) { |
224 | dput(dentry); |
225 | return ERR_PTR(error: -EINVAL); |
226 | } |
227 | |
228 | do { |
229 | struct dentry *dtmp; |
230 | struct kernfs_node *kntmp; |
231 | |
232 | if (kn == knparent) |
233 | return dentry; |
234 | kntmp = find_next_ancestor(child: kn, parent: knparent); |
235 | if (WARN_ON(!kntmp)) { |
236 | dput(dentry); |
237 | return ERR_PTR(error: -EINVAL); |
238 | } |
239 | dtmp = lookup_positive_unlocked(kntmp->name, dentry, |
240 | strlen(kntmp->name)); |
241 | dput(dentry); |
242 | if (IS_ERR(ptr: dtmp)) |
243 | return dtmp; |
244 | knparent = kntmp; |
245 | dentry = dtmp; |
246 | } while (true); |
247 | } |
248 | |
249 | static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *kfc) |
250 | { |
251 | struct kernfs_super_info *info = kernfs_info(sb); |
252 | struct kernfs_root *kf_root = kfc->root; |
253 | struct inode *inode; |
254 | struct dentry *root; |
255 | |
256 | info->sb = sb; |
257 | /* Userspace would break if executables or devices appear on sysfs */ |
258 | sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV; |
259 | sb->s_blocksize = PAGE_SIZE; |
260 | sb->s_blocksize_bits = PAGE_SHIFT; |
261 | sb->s_magic = kfc->magic; |
262 | sb->s_op = &kernfs_sops; |
263 | sb->s_xattr = kernfs_xattr_handlers; |
264 | if (info->root->flags & KERNFS_ROOT_SUPPORT_EXPORTOP) |
265 | sb->s_export_op = &kernfs_export_ops; |
266 | sb->s_time_gran = 1; |
267 | |
268 | /* sysfs dentries and inodes don't require IO to create */ |
269 | sb->s_shrink->seeks = 0; |
270 | |
271 | /* get root inode, initialize and unlock it */ |
272 | down_read(sem: &kf_root->kernfs_rwsem); |
273 | inode = kernfs_get_inode(sb, kn: info->root->kn); |
274 | up_read(sem: &kf_root->kernfs_rwsem); |
275 | if (!inode) { |
276 | pr_debug("kernfs: could not get root inode\n" ); |
277 | return -ENOMEM; |
278 | } |
279 | |
280 | /* instantiate and link root dentry */ |
281 | root = d_make_root(inode); |
282 | if (!root) { |
283 | pr_debug("%s: could not get root dentry!\n" , __func__); |
284 | return -ENOMEM; |
285 | } |
286 | sb->s_root = root; |
287 | sb->s_d_op = &kernfs_dops; |
288 | return 0; |
289 | } |
290 | |
291 | static int kernfs_test_super(struct super_block *sb, struct fs_context *fc) |
292 | { |
293 | struct kernfs_super_info *sb_info = kernfs_info(sb); |
294 | struct kernfs_super_info *info = fc->s_fs_info; |
295 | |
296 | return sb_info->root == info->root && sb_info->ns == info->ns; |
297 | } |
298 | |
299 | static int kernfs_set_super(struct super_block *sb, struct fs_context *fc) |
300 | { |
301 | struct kernfs_fs_context *kfc = fc->fs_private; |
302 | |
303 | kfc->ns_tag = NULL; |
304 | return set_anon_super_fc(s: sb, fc); |
305 | } |
306 | |
307 | /** |
308 | * kernfs_super_ns - determine the namespace tag of a kernfs super_block |
309 | * @sb: super_block of interest |
310 | * |
311 | * Return: the namespace tag associated with kernfs super_block @sb. |
312 | */ |
313 | const void *kernfs_super_ns(struct super_block *sb) |
314 | { |
315 | struct kernfs_super_info *info = kernfs_info(sb); |
316 | |
317 | return info->ns; |
318 | } |
319 | |
320 | /** |
321 | * kernfs_get_tree - kernfs filesystem access/retrieval helper |
322 | * @fc: The filesystem context. |
323 | * |
324 | * This is to be called from each kernfs user's fs_context->ops->get_tree() |
325 | * implementation, which should set the specified ->@fs_type and ->@flags, and |
326 | * specify the hierarchy and namespace tag to mount via ->@root and ->@ns, |
327 | * respectively. |
328 | * |
329 | * Return: %0 on success, -errno on failure. |
330 | */ |
331 | int kernfs_get_tree(struct fs_context *fc) |
332 | { |
333 | struct kernfs_fs_context *kfc = fc->fs_private; |
334 | struct super_block *sb; |
335 | struct kernfs_super_info *info; |
336 | int error; |
337 | |
338 | info = kzalloc(size: sizeof(*info), GFP_KERNEL); |
339 | if (!info) |
340 | return -ENOMEM; |
341 | |
342 | info->root = kfc->root; |
343 | info->ns = kfc->ns_tag; |
344 | INIT_LIST_HEAD(list: &info->node); |
345 | |
346 | fc->s_fs_info = info; |
347 | sb = sget_fc(fc, test: kernfs_test_super, set: kernfs_set_super); |
348 | if (IS_ERR(ptr: sb)) |
349 | return PTR_ERR(ptr: sb); |
350 | |
351 | if (!sb->s_root) { |
352 | struct kernfs_super_info *info = kernfs_info(sb); |
353 | struct kernfs_root *root = kfc->root; |
354 | |
355 | kfc->new_sb_created = true; |
356 | |
357 | error = kernfs_fill_super(sb, kfc); |
358 | if (error) { |
359 | deactivate_locked_super(sb); |
360 | return error; |
361 | } |
362 | sb->s_flags |= SB_ACTIVE; |
363 | |
364 | uuid_gen(u: &sb->s_uuid); |
365 | |
366 | down_write(sem: &root->kernfs_supers_rwsem); |
367 | list_add(new: &info->node, head: &info->root->supers); |
368 | up_write(sem: &root->kernfs_supers_rwsem); |
369 | } |
370 | |
371 | fc->root = dget(dentry: sb->s_root); |
372 | return 0; |
373 | } |
374 | |
375 | void kernfs_free_fs_context(struct fs_context *fc) |
376 | { |
377 | /* Note that we don't deal with kfc->ns_tag here. */ |
378 | kfree(objp: fc->s_fs_info); |
379 | fc->s_fs_info = NULL; |
380 | } |
381 | |
382 | /** |
383 | * kernfs_kill_sb - kill_sb for kernfs |
384 | * @sb: super_block being killed |
385 | * |
386 | * This can be used directly for file_system_type->kill_sb(). If a kernfs |
387 | * user needs extra cleanup, it can implement its own kill_sb() and call |
388 | * this function at the end. |
389 | */ |
390 | void kernfs_kill_sb(struct super_block *sb) |
391 | { |
392 | struct kernfs_super_info *info = kernfs_info(sb); |
393 | struct kernfs_root *root = info->root; |
394 | |
395 | down_write(sem: &root->kernfs_supers_rwsem); |
396 | list_del(entry: &info->node); |
397 | up_write(sem: &root->kernfs_supers_rwsem); |
398 | |
399 | /* |
400 | * Remove the superblock from fs_supers/s_instances |
401 | * so we can't find it, before freeing kernfs_super_info. |
402 | */ |
403 | kill_anon_super(sb); |
404 | kfree(objp: info); |
405 | } |
406 | |
407 | static void __init kernfs_mutex_init(void) |
408 | { |
409 | int count; |
410 | |
411 | for (count = 0; count < NR_KERNFS_LOCKS; count++) |
412 | mutex_init(&kernfs_locks->open_file_mutex[count]); |
413 | } |
414 | |
415 | static void __init kernfs_lock_init(void) |
416 | { |
417 | kernfs_locks = kmalloc(size: sizeof(struct kernfs_global_locks), GFP_KERNEL); |
418 | WARN_ON(!kernfs_locks); |
419 | |
420 | kernfs_mutex_init(); |
421 | } |
422 | |
423 | void __init kernfs_init(void) |
424 | { |
425 | kernfs_node_cache = kmem_cache_create(name: "kernfs_node_cache" , |
426 | size: sizeof(struct kernfs_node), |
427 | align: 0, SLAB_PANIC, NULL); |
428 | |
429 | /* Creates slab cache for kernfs inode attributes */ |
430 | kernfs_iattrs_cache = kmem_cache_create(name: "kernfs_iattrs_cache" , |
431 | size: sizeof(struct kernfs_iattrs), |
432 | align: 0, SLAB_PANIC, NULL); |
433 | |
434 | kernfs_lock_init(); |
435 | } |
436 | |