2 * fs/kernfs/mount.c - kernfs mount implementation
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>
8 * This file is released under the GPLv2.
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>
20 #include "kernfs-internal.h"
22 struct kmem_cache
*kernfs_node_cache
;
24 static int kernfs_sop_remount_fs(struct super_block
*sb
, int *flags
, char *data
)
26 struct kernfs_root
*root
= kernfs_info(sb
)->root
;
27 struct kernfs_syscall_ops
*scops
= root
->syscall_ops
;
29 if (scops
&& scops
->remount_fs
)
30 return scops
->remount_fs(root
, flags
, data
);
34 static int kernfs_sop_show_options(struct seq_file
*sf
, struct dentry
*dentry
)
36 struct kernfs_root
*root
= kernfs_root(dentry
->d_fsdata
);
37 struct kernfs_syscall_ops
*scops
= root
->syscall_ops
;
39 if (scops
&& scops
->show_options
)
40 return scops
->show_options(sf
, root
);
44 static int kernfs_sop_show_path(struct seq_file
*sf
, struct dentry
*dentry
)
46 struct kernfs_node
*node
= dentry
->d_fsdata
;
47 struct kernfs_root
*root
= kernfs_root(node
);
48 struct kernfs_syscall_ops
*scops
= root
->syscall_ops
;
50 if (scops
&& scops
->show_path
)
51 return scops
->show_path(sf
, node
, root
);
53 seq_dentry(sf
, dentry
, " \t\n\\");
57 const struct super_operations kernfs_sops
= {
58 .statfs
= simple_statfs
,
59 .drop_inode
= generic_delete_inode
,
60 .evict_inode
= kernfs_evict_inode
,
62 .remount_fs
= kernfs_sop_remount_fs
,
63 .show_options
= kernfs_sop_show_options
,
64 .show_path
= kernfs_sop_show_path
,
68 * kernfs_root_from_sb - determine kernfs_root associated with a super_block
69 * @sb: the super_block in question
71 * Return the kernfs_root associated with @sb. If @sb is not a kernfs one,
74 struct kernfs_root
*kernfs_root_from_sb(struct super_block
*sb
)
76 if (sb
->s_op
== &kernfs_sops
)
77 return kernfs_info(sb
)->root
;
82 * find the next ancestor in the path down to @child, where @parent was the
83 * ancestor whose descendant we want to find.
85 * Say the path is /a/b/c/d. @child is d, @parent is NULL. We return the root
86 * node. If @parent is b, then we return the node for c.
87 * Passing in d as @parent is not ok.
89 static struct kernfs_node
*find_next_ancestor(struct kernfs_node
*child
,
90 struct kernfs_node
*parent
)
92 if (child
== parent
) {
93 pr_crit_once("BUG in find_next_ancestor: called with parent == child");
97 while (child
->parent
!= parent
) {
100 child
= child
->parent
;
107 * kernfs_node_dentry - get a dentry for the given kernfs_node
108 * @kn: kernfs_node for which a dentry is needed
109 * @sb: the kernfs super_block
111 struct dentry
*kernfs_node_dentry(struct kernfs_node
*kn
,
112 struct super_block
*sb
)
114 struct dentry
*dentry
;
115 struct kernfs_node
*knparent
= NULL
;
117 BUG_ON(sb
->s_op
!= &kernfs_sops
);
119 dentry
= dget(sb
->s_root
);
121 /* Check if this is the root kernfs_node */
125 knparent
= find_next_ancestor(kn
, NULL
);
126 if (WARN_ON(!knparent
))
127 return ERR_PTR(-EINVAL
);
131 struct kernfs_node
*kntmp
;
135 kntmp
= find_next_ancestor(kn
, knparent
);
137 return ERR_PTR(-EINVAL
);
138 dtmp
= lookup_one_len_unlocked(kntmp
->name
, dentry
,
139 strlen(kntmp
->name
));
148 static int kernfs_fill_super(struct super_block
*sb
, unsigned long magic
)
150 struct kernfs_super_info
*info
= kernfs_info(sb
);
155 sb
->s_blocksize
= PAGE_SIZE
;
156 sb
->s_blocksize_bits
= PAGE_SHIFT
;
158 sb
->s_op
= &kernfs_sops
;
161 /* get root inode, initialize and unlock it */
162 mutex_lock(&kernfs_mutex
);
163 inode
= kernfs_get_inode(sb
, info
->root
->kn
);
164 mutex_unlock(&kernfs_mutex
);
166 pr_debug("kernfs: could not get root inode\n");
170 /* instantiate and link root dentry */
171 root
= d_make_root(inode
);
173 pr_debug("%s: could not get root dentry!\n", __func__
);
176 kernfs_get(info
->root
->kn
);
177 root
->d_fsdata
= info
->root
->kn
;
179 sb
->s_d_op
= &kernfs_dops
;
183 static int kernfs_test_super(struct super_block
*sb
, void *data
)
185 struct kernfs_super_info
*sb_info
= kernfs_info(sb
);
186 struct kernfs_super_info
*info
= data
;
188 return sb_info
->root
== info
->root
&& sb_info
->ns
== info
->ns
;
191 static int kernfs_set_super(struct super_block
*sb
, void *data
)
194 error
= set_anon_super(sb
, data
);
196 sb
->s_fs_info
= data
;
201 * kernfs_super_ns - determine the namespace tag of a kernfs super_block
202 * @sb: super_block of interest
204 * Return the namespace tag associated with kernfs super_block @sb.
206 const void *kernfs_super_ns(struct super_block
*sb
)
208 struct kernfs_super_info
*info
= kernfs_info(sb
);
214 * kernfs_mount_ns - kernfs mount helper
215 * @fs_type: file_system_type of the fs being mounted
216 * @flags: mount flags specified for the mount
217 * @root: kernfs_root of the hierarchy being mounted
218 * @magic: file system specific magic number
219 * @new_sb_created: tell the caller if we allocated a new superblock
220 * @ns: optional namespace tag of the mount
222 * This is to be called from each kernfs user's file_system_type->mount()
223 * implementation, which should pass through the specified @fs_type and
224 * @flags, and specify the hierarchy and namespace tag to mount via @root
225 * and @ns, respectively.
227 * The return value can be passed to the vfs layer verbatim.
229 struct dentry
*kernfs_mount_ns(struct file_system_type
*fs_type
, int flags
,
230 struct kernfs_root
*root
, unsigned long magic
,
231 bool *new_sb_created
, const void *ns
)
233 struct super_block
*sb
;
234 struct kernfs_super_info
*info
;
237 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
239 return ERR_PTR(-ENOMEM
);
244 sb
= sget(fs_type
, kernfs_test_super
, kernfs_set_super
, flags
, info
);
245 if (IS_ERR(sb
) || sb
->s_fs_info
!= info
)
251 *new_sb_created
= !sb
->s_root
;
254 struct kernfs_super_info
*info
= kernfs_info(sb
);
256 error
= kernfs_fill_super(sb
, magic
);
258 deactivate_locked_super(sb
);
259 return ERR_PTR(error
);
261 sb
->s_flags
|= MS_ACTIVE
;
263 mutex_lock(&kernfs_mutex
);
264 list_add(&info
->node
, &root
->supers
);
265 mutex_unlock(&kernfs_mutex
);
268 return dget(sb
->s_root
);
272 * kernfs_kill_sb - kill_sb for kernfs
273 * @sb: super_block being killed
275 * This can be used directly for file_system_type->kill_sb(). If a kernfs
276 * user needs extra cleanup, it can implement its own kill_sb() and call
277 * this function at the end.
279 void kernfs_kill_sb(struct super_block
*sb
)
281 struct kernfs_super_info
*info
= kernfs_info(sb
);
282 struct kernfs_node
*root_kn
= sb
->s_root
->d_fsdata
;
284 mutex_lock(&kernfs_mutex
);
285 list_del(&info
->node
);
286 mutex_unlock(&kernfs_mutex
);
289 * Remove the superblock from fs_supers/s_instances
290 * so we can't find it, before freeing kernfs_super_info.
298 * kernfs_pin_sb: try to pin the superblock associated with a kernfs_root
299 * @kernfs_root: the kernfs_root in question
300 * @ns: the namespace tag
302 * Pin the superblock so the superblock won't be destroyed in subsequent
303 * operations. This can be used to block ->kill_sb() which may be useful
304 * for kernfs users which dynamically manage superblocks.
306 * Returns NULL if there's no superblock associated to this kernfs_root, or
307 * -EINVAL if the superblock is being freed.
309 struct super_block
*kernfs_pin_sb(struct kernfs_root
*root
, const void *ns
)
311 struct kernfs_super_info
*info
;
312 struct super_block
*sb
= NULL
;
314 mutex_lock(&kernfs_mutex
);
315 list_for_each_entry(info
, &root
->supers
, node
) {
316 if (info
->ns
== ns
) {
318 if (!atomic_inc_not_zero(&info
->sb
->s_active
))
319 sb
= ERR_PTR(-EINVAL
);
323 mutex_unlock(&kernfs_mutex
);
327 void __init
kernfs_init(void)
329 kernfs_node_cache
= kmem_cache_create("kernfs_node_cache",
330 sizeof(struct kernfs_node
),
331 0, SLAB_PANIC
, NULL
);