GNU Linux-libre 4.19.211-gnu1
[releases.git] / fs / kernfs / mount.c
1 /*
2  * fs/kernfs/mount.c - kernfs mount implementation
3  *
4  * Copyright (c) 2001-3 Patrick Mochel
5  * Copyright (c) 2007 SUSE Linux Products GmbH
6  * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
7  *
8  * This file is released under the GPLv2.
9  */
10
11 #include <linux/fs.h>
12 #include <linux/mount.h>
13 #include <linux/init.h>
14 #include <linux/magic.h>
15 #include <linux/slab.h>
16 #include <linux/pagemap.h>
17 #include <linux/namei.h>
18 #include <linux/seq_file.h>
19 #include <linux/exportfs.h>
20
21 #include "kernfs-internal.h"
22
23 struct kmem_cache *kernfs_node_cache;
24
25 static int kernfs_sop_remount_fs(struct super_block *sb, int *flags, char *data)
26 {
27         struct kernfs_root *root = kernfs_info(sb)->root;
28         struct kernfs_syscall_ops *scops = root->syscall_ops;
29
30         if (scops && scops->remount_fs)
31                 return scops->remount_fs(root, flags, data);
32         return 0;
33 }
34
35 static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry)
36 {
37         struct kernfs_root *root = kernfs_root(kernfs_dentry_node(dentry));
38         struct kernfs_syscall_ops *scops = root->syscall_ops;
39
40         if (scops && scops->show_options)
41                 return scops->show_options(sf, root);
42         return 0;
43 }
44
45 static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry)
46 {
47         struct kernfs_node *node = kernfs_dentry_node(dentry);
48         struct kernfs_root *root = kernfs_root(node);
49         struct kernfs_syscall_ops *scops = root->syscall_ops;
50
51         if (scops && scops->show_path)
52                 return scops->show_path(sf, node, root);
53
54         seq_dentry(sf, dentry, " \t\n\\");
55         return 0;
56 }
57
58 const struct super_operations kernfs_sops = {
59         .statfs         = simple_statfs,
60         .drop_inode     = generic_delete_inode,
61         .evict_inode    = kernfs_evict_inode,
62
63         .remount_fs     = kernfs_sop_remount_fs,
64         .show_options   = kernfs_sop_show_options,
65         .show_path      = kernfs_sop_show_path,
66 };
67
68 /*
69  * Similar to kernfs_fh_get_inode, this one gets kernfs node from inode
70  * number and generation
71  */
72 struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root,
73         const union kernfs_node_id *id)
74 {
75         struct kernfs_node *kn;
76
77         kn = kernfs_find_and_get_node_by_ino(root, id->ino);
78         if (!kn)
79                 return NULL;
80         if (kn->id.generation != id->generation) {
81                 kernfs_put(kn);
82                 return NULL;
83         }
84         return kn;
85 }
86
87 static struct inode *kernfs_fh_get_inode(struct super_block *sb,
88                 u64 ino, u32 generation)
89 {
90         struct kernfs_super_info *info = kernfs_info(sb);
91         struct inode *inode;
92         struct kernfs_node *kn;
93
94         if (ino == 0)
95                 return ERR_PTR(-ESTALE);
96
97         kn = kernfs_find_and_get_node_by_ino(info->root, ino);
98         if (!kn)
99                 return ERR_PTR(-ESTALE);
100         inode = kernfs_get_inode(sb, kn);
101         kernfs_put(kn);
102         if (!inode)
103                 return ERR_PTR(-ESTALE);
104
105         if (generation && inode->i_generation != generation) {
106                 /* we didn't find the right inode.. */
107                 iput(inode);
108                 return ERR_PTR(-ESTALE);
109         }
110         return inode;
111 }
112
113 static struct dentry *kernfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
114                 int fh_len, int fh_type)
115 {
116         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
117                                     kernfs_fh_get_inode);
118 }
119
120 static struct dentry *kernfs_fh_to_parent(struct super_block *sb, struct fid *fid,
121                 int fh_len, int fh_type)
122 {
123         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
124                                     kernfs_fh_get_inode);
125 }
126
127 static struct dentry *kernfs_get_parent_dentry(struct dentry *child)
128 {
129         struct kernfs_node *kn = kernfs_dentry_node(child);
130
131         return d_obtain_alias(kernfs_get_inode(child->d_sb, kn->parent));
132 }
133
134 static const struct export_operations kernfs_export_ops = {
135         .fh_to_dentry   = kernfs_fh_to_dentry,
136         .fh_to_parent   = kernfs_fh_to_parent,
137         .get_parent     = kernfs_get_parent_dentry,
138 };
139
140 /**
141  * kernfs_root_from_sb - determine kernfs_root associated with a super_block
142  * @sb: the super_block in question
143  *
144  * Return the kernfs_root associated with @sb.  If @sb is not a kernfs one,
145  * %NULL is returned.
146  */
147 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
148 {
149         if (sb->s_op == &kernfs_sops)
150                 return kernfs_info(sb)->root;
151         return NULL;
152 }
153
154 /*
155  * find the next ancestor in the path down to @child, where @parent was the
156  * ancestor whose descendant we want to find.
157  *
158  * Say the path is /a/b/c/d.  @child is d, @parent is NULL.  We return the root
159  * node.  If @parent is b, then we return the node for c.
160  * Passing in d as @parent is not ok.
161  */
162 static struct kernfs_node *find_next_ancestor(struct kernfs_node *child,
163                                               struct kernfs_node *parent)
164 {
165         if (child == parent) {
166                 pr_crit_once("BUG in find_next_ancestor: called with parent == child");
167                 return NULL;
168         }
169
170         while (child->parent != parent) {
171                 if (!child->parent)
172                         return NULL;
173                 child = child->parent;
174         }
175
176         return child;
177 }
178
179 /**
180  * kernfs_node_dentry - get a dentry for the given kernfs_node
181  * @kn: kernfs_node for which a dentry is needed
182  * @sb: the kernfs super_block
183  */
184 struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
185                                   struct super_block *sb)
186 {
187         struct dentry *dentry;
188         struct kernfs_node *knparent = NULL;
189
190         BUG_ON(sb->s_op != &kernfs_sops);
191
192         dentry = dget(sb->s_root);
193
194         /* Check if this is the root kernfs_node */
195         if (!kn->parent)
196                 return dentry;
197
198         knparent = find_next_ancestor(kn, NULL);
199         if (WARN_ON(!knparent)) {
200                 dput(dentry);
201                 return ERR_PTR(-EINVAL);
202         }
203
204         do {
205                 struct dentry *dtmp;
206                 struct kernfs_node *kntmp;
207
208                 if (kn == knparent)
209                         return dentry;
210                 kntmp = find_next_ancestor(kn, knparent);
211                 if (WARN_ON(!kntmp)) {
212                         dput(dentry);
213                         return ERR_PTR(-EINVAL);
214                 }
215                 dtmp = lookup_one_len_unlocked(kntmp->name, dentry,
216                                                strlen(kntmp->name));
217                 dput(dentry);
218                 if (IS_ERR(dtmp))
219                         return dtmp;
220                 knparent = kntmp;
221                 dentry = dtmp;
222         } while (true);
223 }
224
225 static int kernfs_fill_super(struct super_block *sb, unsigned long magic)
226 {
227         struct kernfs_super_info *info = kernfs_info(sb);
228         struct inode *inode;
229         struct dentry *root;
230
231         info->sb = sb;
232         /* Userspace would break if executables or devices appear on sysfs */
233         sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV;
234         sb->s_blocksize = PAGE_SIZE;
235         sb->s_blocksize_bits = PAGE_SHIFT;
236         sb->s_magic = magic;
237         sb->s_op = &kernfs_sops;
238         sb->s_xattr = kernfs_xattr_handlers;
239         if (info->root->flags & KERNFS_ROOT_SUPPORT_EXPORTOP)
240                 sb->s_export_op = &kernfs_export_ops;
241         sb->s_time_gran = 1;
242
243         /* get root inode, initialize and unlock it */
244         mutex_lock(&kernfs_mutex);
245         inode = kernfs_get_inode(sb, info->root->kn);
246         mutex_unlock(&kernfs_mutex);
247         if (!inode) {
248                 pr_debug("kernfs: could not get root inode\n");
249                 return -ENOMEM;
250         }
251
252         /* instantiate and link root dentry */
253         root = d_make_root(inode);
254         if (!root) {
255                 pr_debug("%s: could not get root dentry!\n", __func__);
256                 return -ENOMEM;
257         }
258         sb->s_root = root;
259         sb->s_d_op = &kernfs_dops;
260         return 0;
261 }
262
263 static int kernfs_test_super(struct super_block *sb, void *data)
264 {
265         struct kernfs_super_info *sb_info = kernfs_info(sb);
266         struct kernfs_super_info *info = data;
267
268         return sb_info->root == info->root && sb_info->ns == info->ns;
269 }
270
271 static int kernfs_set_super(struct super_block *sb, void *data)
272 {
273         int error;
274         error = set_anon_super(sb, data);
275         if (!error)
276                 sb->s_fs_info = data;
277         return error;
278 }
279
280 /**
281  * kernfs_super_ns - determine the namespace tag of a kernfs super_block
282  * @sb: super_block of interest
283  *
284  * Return the namespace tag associated with kernfs super_block @sb.
285  */
286 const void *kernfs_super_ns(struct super_block *sb)
287 {
288         struct kernfs_super_info *info = kernfs_info(sb);
289
290         return info->ns;
291 }
292
293 /**
294  * kernfs_mount_ns - kernfs mount helper
295  * @fs_type: file_system_type of the fs being mounted
296  * @flags: mount flags specified for the mount
297  * @root: kernfs_root of the hierarchy being mounted
298  * @magic: file system specific magic number
299  * @new_sb_created: tell the caller if we allocated a new superblock
300  * @ns: optional namespace tag of the mount
301  *
302  * This is to be called from each kernfs user's file_system_type->mount()
303  * implementation, which should pass through the specified @fs_type and
304  * @flags, and specify the hierarchy and namespace tag to mount via @root
305  * and @ns, respectively.
306  *
307  * The return value can be passed to the vfs layer verbatim.
308  */
309 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
310                                 struct kernfs_root *root, unsigned long magic,
311                                 bool *new_sb_created, const void *ns)
312 {
313         struct super_block *sb;
314         struct kernfs_super_info *info;
315         int error;
316
317         info = kzalloc(sizeof(*info), GFP_KERNEL);
318         if (!info)
319                 return ERR_PTR(-ENOMEM);
320
321         info->root = root;
322         info->ns = ns;
323         INIT_LIST_HEAD(&info->node);
324
325         sb = sget_userns(fs_type, kernfs_test_super, kernfs_set_super, flags,
326                          &init_user_ns, info);
327         if (IS_ERR(sb) || sb->s_fs_info != info)
328                 kfree(info);
329         if (IS_ERR(sb))
330                 return ERR_CAST(sb);
331
332         if (new_sb_created)
333                 *new_sb_created = !sb->s_root;
334
335         if (!sb->s_root) {
336                 struct kernfs_super_info *info = kernfs_info(sb);
337
338                 error = kernfs_fill_super(sb, magic);
339                 if (error) {
340                         deactivate_locked_super(sb);
341                         return ERR_PTR(error);
342                 }
343                 sb->s_flags |= SB_ACTIVE;
344
345                 mutex_lock(&kernfs_mutex);
346                 list_add(&info->node, &root->supers);
347                 mutex_unlock(&kernfs_mutex);
348         }
349
350         return dget(sb->s_root);
351 }
352
353 /**
354  * kernfs_kill_sb - kill_sb for kernfs
355  * @sb: super_block being killed
356  *
357  * This can be used directly for file_system_type->kill_sb().  If a kernfs
358  * user needs extra cleanup, it can implement its own kill_sb() and call
359  * this function at the end.
360  */
361 void kernfs_kill_sb(struct super_block *sb)
362 {
363         struct kernfs_super_info *info = kernfs_info(sb);
364
365         mutex_lock(&kernfs_mutex);
366         list_del(&info->node);
367         mutex_unlock(&kernfs_mutex);
368
369         /*
370          * Remove the superblock from fs_supers/s_instances
371          * so we can't find it, before freeing kernfs_super_info.
372          */
373         kill_anon_super(sb);
374         kfree(info);
375 }
376
377 /**
378  * kernfs_pin_sb: try to pin the superblock associated with a kernfs_root
379  * @kernfs_root: the kernfs_root in question
380  * @ns: the namespace tag
381  *
382  * Pin the superblock so the superblock won't be destroyed in subsequent
383  * operations.  This can be used to block ->kill_sb() which may be useful
384  * for kernfs users which dynamically manage superblocks.
385  *
386  * Returns NULL if there's no superblock associated to this kernfs_root, or
387  * -EINVAL if the superblock is being freed.
388  */
389 struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns)
390 {
391         struct kernfs_super_info *info;
392         struct super_block *sb = NULL;
393
394         mutex_lock(&kernfs_mutex);
395         list_for_each_entry(info, &root->supers, node) {
396                 if (info->ns == ns) {
397                         sb = info->sb;
398                         if (!atomic_inc_not_zero(&info->sb->s_active))
399                                 sb = ERR_PTR(-EINVAL);
400                         break;
401                 }
402         }
403         mutex_unlock(&kernfs_mutex);
404         return sb;
405 }
406
407 void __init kernfs_init(void)
408 {
409
410         /*
411          * the slab is freed in RCU context, so kernfs_find_and_get_node_by_ino
412          * can access the slab lock free. This could introduce stale nodes,
413          * please see how kernfs_find_and_get_node_by_ino filters out stale
414          * nodes.
415          */
416         kernfs_node_cache = kmem_cache_create("kernfs_node_cache",
417                                               sizeof(struct kernfs_node),
418                                               0,
419                                               SLAB_PANIC | SLAB_TYPESAFE_BY_RCU,
420                                               NULL);
421 }