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> |
0ce7c12e IB |
19 | #include <linux/uuid.h> |
20 | #include <linux/statfs.h> | |
fa736a95 TH |
21 | |
22 | #include "kernfs-internal.h" | |
23 | ||
68279f9c AD |
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; | |
fa736a95 | 27 | |
6a7fed4e TH |
28 | static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry) |
29 | { | |
319ba91d | 30 | struct kernfs_root *root = kernfs_root(kernfs_dentry_node(dentry)); |
6a7fed4e TH |
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 | ||
4f41fc59 SH |
38 | static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry) |
39 | { | |
319ba91d | 40 | struct kernfs_node *node = kernfs_dentry_node(dentry); |
4f41fc59 SH |
41 | struct kernfs_root *root = kernfs_root(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 | ||
3cc9b23c SH |
47 | seq_dentry(sf, dentry, " \t\n\\"); |
48 | return 0; | |
4f41fc59 SH |
49 | } |
50 | ||
0ce7c12e IB |
51 | static int kernfs_statfs(struct dentry *dentry, struct kstatfs *buf) |
52 | { | |
53 | simple_statfs(dentry, buf); | |
54 | buf->f_fsid = uuid_to_fsid(dentry->d_sb->s_uuid.b); | |
55 | return 0; | |
56 | } | |
57 | ||
f41c5934 | 58 | const struct super_operations kernfs_sops = { |
0ce7c12e | 59 | .statfs = kernfs_statfs, |
fa736a95 | 60 | .drop_inode = generic_delete_inode, |
c637b8ac | 61 | .evict_inode = kernfs_evict_inode, |
6a7fed4e | 62 | |
6a7fed4e | 63 | .show_options = kernfs_sop_show_options, |
4f41fc59 | 64 | .show_path = kernfs_sop_show_path, |
fa736a95 TH |
65 | }; |
66 | ||
33c5ac91 TH |
67 | static int kernfs_encode_fh(struct inode *inode, __u32 *fh, int *max_len, |
68 | struct inode *parent) | |
aa818825 | 69 | { |
33c5ac91 | 70 | struct kernfs_node *kn = inode->i_private; |
aa818825 | 71 | |
33c5ac91 TH |
72 | if (*max_len < 2) { |
73 | *max_len = 2; | |
74 | return FILEID_INVALID; | |
75 | } | |
aa818825 | 76 | |
33c5ac91 TH |
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 | /* | |
40430452 TH |
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(). | |
33c5ac91 TH |
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(info->root, id); | |
aa818825 SL |
113 | if (!kn) |
114 | return ERR_PTR(-ESTALE); | |
33c5ac91 TH |
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(-ESTALE); | |
124 | } | |
125 | ||
aa818825 SL |
126 | inode = kernfs_get_inode(sb, kn); |
127 | kernfs_put(kn); | |
ef13ecbc DC |
128 | if (!inode) |
129 | return ERR_PTR(-ESTALE); | |
aa818825 | 130 | |
33c5ac91 | 131 | return d_obtain_alias(inode); |
aa818825 SL |
132 | } |
133 | ||
33c5ac91 TH |
134 | static struct dentry *kernfs_fh_to_dentry(struct super_block *sb, |
135 | struct fid *fid, int fh_len, | |
136 | int fh_type) | |
aa818825 | 137 | { |
33c5ac91 | 138 | return __kernfs_fh_to_dentry(sb, fid, fh_len, fh_type, false); |
aa818825 SL |
139 | } |
140 | ||
33c5ac91 TH |
141 | static struct dentry *kernfs_fh_to_parent(struct super_block *sb, |
142 | struct fid *fid, int fh_len, | |
143 | int fh_type) | |
aa818825 | 144 | { |
33c5ac91 | 145 | return __kernfs_fh_to_dentry(sb, fid, fh_len, fh_type, true); |
aa818825 SL |
146 | } |
147 | ||
148 | static struct dentry *kernfs_get_parent_dentry(struct dentry *child) | |
149 | { | |
150 | struct kernfs_node *kn = kernfs_dentry_node(child); | |
151 | ||
152 | return d_obtain_alias(kernfs_get_inode(child->d_sb, kn->parent)); | |
153 | } | |
154 | ||
155 | static const struct export_operations kernfs_export_ops = { | |
33c5ac91 | 156 | .encode_fh = kernfs_encode_fh, |
aa818825 SL |
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 | ||
0c23b225 TH |
162 | /** |
163 | * kernfs_root_from_sb - determine kernfs_root associated with a super_block | |
164 | * @sb: the super_block in question | |
165 | * | |
24b3e3dd | 166 | * Return: the kernfs_root associated with @sb. If @sb is not a kernfs one, |
0c23b225 TH |
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 | ||
fb3c8315 AK |
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 | * | |
24b3e3dd | 180 | * Say the path is /a/b/c/d. @child is d, @parent is %NULL. We return the root |
fb3c8315 AK |
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 | |
24b3e3dd RD |
205 | * |
206 | * Return: the dentry pointer | |
fb3c8315 AK |
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(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(kn, NULL); | |
399504e2 AV |
223 | if (WARN_ON(!knparent)) { |
224 | dput(dentry); | |
fb3c8315 | 225 | return ERR_PTR(-EINVAL); |
399504e2 | 226 | } |
fb3c8315 AK |
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(kn, knparent); | |
399504e2 AV |
235 | if (WARN_ON(!kntmp)) { |
236 | dput(dentry); | |
fb3c8315 | 237 | return ERR_PTR(-EINVAL); |
399504e2 | 238 | } |
6c2d4798 | 239 | dtmp = lookup_positive_unlocked(kntmp->name, dentry, |
779b8391 | 240 | strlen(kntmp->name)); |
fb3c8315 AK |
241 | dput(dentry); |
242 | if (IS_ERR(dtmp)) | |
243 | return dtmp; | |
244 | knparent = kntmp; | |
245 | dentry = dtmp; | |
246 | } while (true); | |
247 | } | |
248 | ||
23bf1b6b | 249 | static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *kfc) |
fa736a95 | 250 | { |
c525aadd | 251 | struct kernfs_super_info *info = kernfs_info(sb); |
393c3714 | 252 | struct kernfs_root *kf_root = kfc->root; |
fa736a95 TH |
253 | struct inode *inode; |
254 | struct dentry *root; | |
255 | ||
7d568a83 | 256 | info->sb = sb; |
a2982cc9 EB |
257 | /* Userspace would break if executables or devices appear on sysfs */ |
258 | sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV; | |
09cbfeaf KS |
259 | sb->s_blocksize = PAGE_SIZE; |
260 | sb->s_blocksize_bits = PAGE_SHIFT; | |
23bf1b6b | 261 | sb->s_magic = kfc->magic; |
a797bfc3 | 262 | sb->s_op = &kernfs_sops; |
e72a1a8b | 263 | sb->s_xattr = kernfs_xattr_handlers; |
aa818825 SL |
264 | if (info->root->flags & KERNFS_ROOT_SUPPORT_EXPORTOP) |
265 | sb->s_export_op = &kernfs_export_ops; | |
fa736a95 TH |
266 | sb->s_time_gran = 1; |
267 | ||
4b85afbd | 268 | /* sysfs dentries and inodes don't require IO to create */ |
1720f5dd | 269 | sb->s_shrink->seeks = 0; |
4b85afbd | 270 | |
fa736a95 | 271 | /* get root inode, initialize and unlock it */ |
393c3714 | 272 | down_read(&kf_root->kernfs_rwsem); |
c637b8ac | 273 | inode = kernfs_get_inode(sb, info->root->kn); |
393c3714 | 274 | up_read(&kf_root->kernfs_rwsem); |
fa736a95 | 275 | if (!inode) { |
c637b8ac | 276 | pr_debug("kernfs: could not get root inode\n"); |
fa736a95 TH |
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 | } | |
fa736a95 | 286 | sb->s_root = root; |
a797bfc3 | 287 | sb->s_d_op = &kernfs_dops; |
fa736a95 TH |
288 | return 0; |
289 | } | |
290 | ||
23bf1b6b | 291 | static int kernfs_test_super(struct super_block *sb, struct fs_context *fc) |
fa736a95 | 292 | { |
c525aadd | 293 | struct kernfs_super_info *sb_info = kernfs_info(sb); |
23bf1b6b | 294 | struct kernfs_super_info *info = fc->s_fs_info; |
fa736a95 TH |
295 | |
296 | return sb_info->root == info->root && sb_info->ns == info->ns; | |
297 | } | |
298 | ||
23bf1b6b | 299 | static int kernfs_set_super(struct super_block *sb, struct fs_context *fc) |
fa736a95 | 300 | { |
23bf1b6b DH |
301 | struct kernfs_fs_context *kfc = fc->fs_private; |
302 | ||
303 | kfc->ns_tag = NULL; | |
304 | return set_anon_super_fc(sb, fc); | |
fa736a95 TH |
305 | } |
306 | ||
307 | /** | |
308 | * kernfs_super_ns - determine the namespace tag of a kernfs super_block | |
309 | * @sb: super_block of interest | |
310 | * | |
24b3e3dd | 311 | * Return: the namespace tag associated with kernfs super_block @sb. |
fa736a95 TH |
312 | */ |
313 | const void *kernfs_super_ns(struct super_block *sb) | |
314 | { | |
c525aadd | 315 | struct kernfs_super_info *info = kernfs_info(sb); |
fa736a95 TH |
316 | |
317 | return info->ns; | |
318 | } | |
319 | ||
320 | /** | |
23bf1b6b DH |
321 | * kernfs_get_tree - kernfs filesystem access/retrieval helper |
322 | * @fc: The filesystem context. | |
fa736a95 | 323 | * |
23bf1b6b DH |
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. | |
24b3e3dd RD |
328 | * |
329 | * Return: %0 on success, -errno on failure. | |
fa736a95 | 330 | */ |
23bf1b6b | 331 | int kernfs_get_tree(struct fs_context *fc) |
fa736a95 | 332 | { |
23bf1b6b | 333 | struct kernfs_fs_context *kfc = fc->fs_private; |
fa736a95 | 334 | struct super_block *sb; |
c525aadd | 335 | struct kernfs_super_info *info; |
fa736a95 TH |
336 | int error; |
337 | ||
338 | info = kzalloc(sizeof(*info), GFP_KERNEL); | |
339 | if (!info) | |
23bf1b6b | 340 | return -ENOMEM; |
fa736a95 | 341 | |
23bf1b6b DH |
342 | info->root = kfc->root; |
343 | info->ns = kfc->ns_tag; | |
82382ace | 344 | INIT_LIST_HEAD(&info->node); |
fa736a95 | 345 | |
23bf1b6b DH |
346 | fc->s_fs_info = info; |
347 | sb = sget_fc(fc, kernfs_test_super, kernfs_set_super); | |
fa736a95 | 348 | if (IS_ERR(sb)) |
23bf1b6b | 349 | return PTR_ERR(sb); |
fed95bab | 350 | |
fa736a95 | 351 | if (!sb->s_root) { |
7d568a83 | 352 | struct kernfs_super_info *info = kernfs_info(sb); |
393c3714 | 353 | struct kernfs_root *root = kfc->root; |
7d568a83 | 354 | |
23bf1b6b DH |
355 | kfc->new_sb_created = true; |
356 | ||
357 | error = kernfs_fill_super(sb, kfc); | |
fa736a95 TH |
358 | if (error) { |
359 | deactivate_locked_super(sb); | |
23bf1b6b | 360 | return error; |
fa736a95 | 361 | } |
1751e8a6 | 362 | sb->s_flags |= SB_ACTIVE; |
7d568a83 | 363 | |
0ce7c12e IB |
364 | uuid_gen(&sb->s_uuid); |
365 | ||
c9f2dfb7 | 366 | down_write(&root->kernfs_supers_rwsem); |
23bf1b6b | 367 | list_add(&info->node, &info->root->supers); |
c9f2dfb7 | 368 | up_write(&root->kernfs_supers_rwsem); |
fa736a95 TH |
369 | } |
370 | ||
23bf1b6b DH |
371 | fc->root = dget(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(fc->s_fs_info); | |
379 | fc->s_fs_info = NULL; | |
fa736a95 TH |
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 | { | |
c525aadd | 392 | struct kernfs_super_info *info = kernfs_info(sb); |
393c3714 | 393 | struct kernfs_root *root = info->root; |
fa736a95 | 394 | |
c9f2dfb7 | 395 | down_write(&root->kernfs_supers_rwsem); |
7d568a83 | 396 | list_del(&info->node); |
c9f2dfb7 | 397 | up_write(&root->kernfs_supers_rwsem); |
7d568a83 | 398 | |
fa736a95 TH |
399 | /* |
400 | * Remove the superblock from fs_supers/s_instances | |
c525aadd | 401 | * so we can't find it, before freeing kernfs_super_info. |
fa736a95 TH |
402 | */ |
403 | kill_anon_super(sb); | |
404 | kfree(info); | |
fa736a95 TH |
405 | } |
406 | ||
1d25b84e IK |
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(sizeof(struct kernfs_global_locks), GFP_KERNEL); | |
418 | WARN_ON(!kernfs_locks); | |
419 | ||
420 | kernfs_mutex_init(); | |
421 | } | |
422 | ||
fa736a95 TH |
423 | void __init kernfs_init(void) |
424 | { | |
a797bfc3 | 425 | kernfs_node_cache = kmem_cache_create("kernfs_node_cache", |
324a56e1 | 426 | sizeof(struct kernfs_node), |
b680b081 | 427 | 0, SLAB_PANIC, NULL); |
26e28d68 AM |
428 | |
429 | /* Creates slab cache for kernfs inode attributes */ | |
430 | kernfs_iattrs_cache = kmem_cache_create("kernfs_iattrs_cache", | |
431 | sizeof(struct kernfs_iattrs), | |
432 | 0, SLAB_PANIC, NULL); | |
1d25b84e IK |
433 | |
434 | kernfs_lock_init(); | |
fa736a95 | 435 | } |