~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/kernfs/mount.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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                 return ERR_PTR(-EINVAL);
201 
202         do {
203                 struct dentry *dtmp;
204                 struct kernfs_node *kntmp;
205 
206                 if (kn == knparent)
207                         return dentry;
208                 kntmp = find_next_ancestor(kn, knparent);
209                 if (WARN_ON(!kntmp))
210                         return ERR_PTR(-EINVAL);
211                 dtmp = lookup_one_len_unlocked(kntmp->name, dentry,
212                                                strlen(kntmp->name));
213                 dput(dentry);
214                 if (IS_ERR(dtmp))
215                         return dtmp;
216                 knparent = kntmp;
217                 dentry = dtmp;
218         } while (true);
219 }
220 
221 static int kernfs_fill_super(struct super_block *sb, unsigned long magic)
222 {
223         struct kernfs_super_info *info = kernfs_info(sb);
224         struct inode *inode;
225         struct dentry *root;
226 
227         info->sb = sb;
228         /* Userspace would break if executables or devices appear on sysfs */
229         sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV;
230         sb->s_blocksize = PAGE_SIZE;
231         sb->s_blocksize_bits = PAGE_SHIFT;
232         sb->s_magic = magic;
233         sb->s_op = &kernfs_sops;
234         sb->s_xattr = kernfs_xattr_handlers;
235         if (info->root->flags & KERNFS_ROOT_SUPPORT_EXPORTOP)
236                 sb->s_export_op = &kernfs_export_ops;
237         sb->s_time_gran = 1;
238 
239         /* get root inode, initialize and unlock it */
240         mutex_lock(&kernfs_mutex);
241         inode = kernfs_get_inode(sb, info->root->kn);
242         mutex_unlock(&kernfs_mutex);
243         if (!inode) {
244                 pr_debug("kernfs: could not get root inode\n");
245                 return -ENOMEM;
246         }
247 
248         /* instantiate and link root dentry */
249         root = d_make_root(inode);
250         if (!root) {
251                 pr_debug("%s: could not get root dentry!\n", __func__);
252                 return -ENOMEM;
253         }
254         sb->s_root = root;
255         sb->s_d_op = &kernfs_dops;
256         return 0;
257 }
258 
259 static int kernfs_test_super(struct super_block *sb, void *data)
260 {
261         struct kernfs_super_info *sb_info = kernfs_info(sb);
262         struct kernfs_super_info *info = data;
263 
264         return sb_info->root == info->root && sb_info->ns == info->ns;
265 }
266 
267 static int kernfs_set_super(struct super_block *sb, void *data)
268 {
269         int error;
270         error = set_anon_super(sb, data);
271         if (!error)
272                 sb->s_fs_info = data;
273         return error;
274 }
275 
276 /**
277  * kernfs_super_ns - determine the namespace tag of a kernfs super_block
278  * @sb: super_block of interest
279  *
280  * Return the namespace tag associated with kernfs super_block @sb.
281  */
282 const void *kernfs_super_ns(struct super_block *sb)
283 {
284         struct kernfs_super_info *info = kernfs_info(sb);
285 
286         return info->ns;
287 }
288 
289 /**
290  * kernfs_mount_ns - kernfs mount helper
291  * @fs_type: file_system_type of the fs being mounted
292  * @flags: mount flags specified for the mount
293  * @root: kernfs_root of the hierarchy being mounted
294  * @magic: file system specific magic number
295  * @new_sb_created: tell the caller if we allocated a new superblock
296  * @ns: optional namespace tag of the mount
297  *
298  * This is to be called from each kernfs user's file_system_type->mount()
299  * implementation, which should pass through the specified @fs_type and
300  * @flags, and specify the hierarchy and namespace tag to mount via @root
301  * and @ns, respectively.
302  *
303  * The return value can be passed to the vfs layer verbatim.
304  */
305 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
306                                 struct kernfs_root *root, unsigned long magic,
307                                 bool *new_sb_created, const void *ns)
308 {
309         struct super_block *sb;
310         struct kernfs_super_info *info;
311         int error;
312 
313         info = kzalloc(sizeof(*info), GFP_KERNEL);
314         if (!info)
315                 return ERR_PTR(-ENOMEM);
316 
317         info->root = root;
318         info->ns = ns;
319 
320         sb = sget_userns(fs_type, kernfs_test_super, kernfs_set_super, flags,
321                          &init_user_ns, info);
322         if (IS_ERR(sb) || sb->s_fs_info != info)
323                 kfree(info);
324         if (IS_ERR(sb))
325                 return ERR_CAST(sb);
326 
327         if (new_sb_created)
328                 *new_sb_created = !sb->s_root;
329 
330         if (!sb->s_root) {
331                 struct kernfs_super_info *info = kernfs_info(sb);
332 
333                 error = kernfs_fill_super(sb, magic);
334                 if (error) {
335                         deactivate_locked_super(sb);
336                         return ERR_PTR(error);
337                 }
338                 sb->s_flags |= SB_ACTIVE;
339 
340                 mutex_lock(&kernfs_mutex);
341                 list_add(&info->node, &root->supers);
342                 mutex_unlock(&kernfs_mutex);
343         }
344 
345         return dget(sb->s_root);
346 }
347 
348 /**
349  * kernfs_kill_sb - kill_sb for kernfs
350  * @sb: super_block being killed
351  *
352  * This can be used directly for file_system_type->kill_sb().  If a kernfs
353  * user needs extra cleanup, it can implement its own kill_sb() and call
354  * this function at the end.
355  */
356 void kernfs_kill_sb(struct super_block *sb)
357 {
358         struct kernfs_super_info *info = kernfs_info(sb);
359 
360         mutex_lock(&kernfs_mutex);
361         list_del(&info->node);
362         mutex_unlock(&kernfs_mutex);
363 
364         /*
365          * Remove the superblock from fs_supers/s_instances
366          * so we can't find it, before freeing kernfs_super_info.
367          */
368         kill_anon_super(sb);
369         kfree(info);
370 }
371 
372 /**
373  * kernfs_pin_sb: try to pin the superblock associated with a kernfs_root
374  * @kernfs_root: the kernfs_root in question
375  * @ns: the namespace tag
376  *
377  * Pin the superblock so the superblock won't be destroyed in subsequent
378  * operations.  This can be used to block ->kill_sb() which may be useful
379  * for kernfs users which dynamically manage superblocks.
380  *
381  * Returns NULL if there's no superblock associated to this kernfs_root, or
382  * -EINVAL if the superblock is being freed.
383  */
384 struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns)
385 {
386         struct kernfs_super_info *info;
387         struct super_block *sb = NULL;
388 
389         mutex_lock(&kernfs_mutex);
390         list_for_each_entry(info, &root->supers, node) {
391                 if (info->ns == ns) {
392                         sb = info->sb;
393                         if (!atomic_inc_not_zero(&info->sb->s_active))
394                                 sb = ERR_PTR(-EINVAL);
395                         break;
396                 }
397         }
398         mutex_unlock(&kernfs_mutex);
399         return sb;
400 }
401 
402 void __init kernfs_init(void)
403 {
404 
405         /*
406          * the slab is freed in RCU context, so kernfs_find_and_get_node_by_ino
407          * can access the slab lock free. This could introduce stale nodes,
408          * please see how kernfs_find_and_get_node_by_ino filters out stale
409          * nodes.
410          */
411         kernfs_node_cache = kmem_cache_create("kernfs_node_cache",
412                                               sizeof(struct kernfs_node),
413                                               0,
414                                               SLAB_PANIC | SLAB_TYPESAFE_BY_RCU,
415                                               NULL);
416 }
417 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp