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 mutex_lock(&d_inode(dentry
)->i_mutex
);
139 dtmp
= lookup_one_len(kntmp
->name
, dentry
, strlen(kntmp
->name
));
140 mutex_unlock(&d_inode(dentry
)->i_mutex
);
149 static int kernfs_fill_super(struct super_block
*sb
, unsigned long magic
)
151 struct kernfs_super_info
*info
= kernfs_info(sb
);
156 sb
->s_blocksize
= PAGE_SIZE
;
157 sb
->s_blocksize_bits
= PAGE_SHIFT
;
159 sb
->s_op
= &kernfs_sops
;
162 /* get root inode, initialize and unlock it */
163 mutex_lock(&kernfs_mutex
);
164 inode
= kernfs_get_inode(sb
, info
->root
->kn
);
165 mutex_unlock(&kernfs_mutex
);
167 pr_debug("kernfs: could not get root inode\n");
171 /* instantiate and link root dentry */
172 root
= d_make_root(inode
);
174 pr_debug("%s: could not get root dentry!\n", __func__
);
177 kernfs_get(info
->root
->kn
);
178 root
->d_fsdata
= info
->root
->kn
;
180 sb
->s_d_op
= &kernfs_dops
;
184 static int kernfs_test_super(struct super_block
*sb
, void *data
)
186 struct kernfs_super_info
*sb_info
= kernfs_info(sb
);
187 struct kernfs_super_info
*info
= data
;
189 return sb_info
->root
== info
->root
&& sb_info
->ns
== info
->ns
;
192 static int kernfs_set_super(struct super_block
*sb
, void *data
)
195 error
= set_anon_super(sb
, data
);
197 sb
->s_fs_info
= data
;
202 * kernfs_super_ns - determine the namespace tag of a kernfs super_block
203 * @sb: super_block of interest
205 * Return the namespace tag associated with kernfs super_block @sb.
207 const void *kernfs_super_ns(struct super_block
*sb
)
209 struct kernfs_super_info
*info
= kernfs_info(sb
);
215 * kernfs_mount_ns - kernfs mount helper
216 * @fs_type: file_system_type of the fs being mounted
217 * @flags: mount flags specified for the mount
218 * @root: kernfs_root of the hierarchy being mounted
219 * @magic: file system specific magic number
220 * @new_sb_created: tell the caller if we allocated a new superblock
221 * @ns: optional namespace tag of the mount
223 * This is to be called from each kernfs user's file_system_type->mount()
224 * implementation, which should pass through the specified @fs_type and
225 * @flags, and specify the hierarchy and namespace tag to mount via @root
226 * and @ns, respectively.
228 * The return value can be passed to the vfs layer verbatim.
230 struct dentry
*kernfs_mount_ns(struct file_system_type
*fs_type
, int flags
,
231 struct kernfs_root
*root
, unsigned long magic
,
232 bool *new_sb_created
, const void *ns
)
234 struct super_block
*sb
;
235 struct kernfs_super_info
*info
;
238 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
240 return ERR_PTR(-ENOMEM
);
245 sb
= sget(fs_type
, kernfs_test_super
, kernfs_set_super
, flags
, info
);
246 if (IS_ERR(sb
) || sb
->s_fs_info
!= info
)
252 *new_sb_created
= !sb
->s_root
;
255 struct kernfs_super_info
*info
= kernfs_info(sb
);
257 error
= kernfs_fill_super(sb
, magic
);
259 deactivate_locked_super(sb
);
260 return ERR_PTR(error
);
262 sb
->s_flags
|= MS_ACTIVE
;
264 mutex_lock(&kernfs_mutex
);
265 list_add(&info
->node
, &root
->supers
);
266 mutex_unlock(&kernfs_mutex
);
269 return dget(sb
->s_root
);
273 * kernfs_kill_sb - kill_sb for kernfs
274 * @sb: super_block being killed
276 * This can be used directly for file_system_type->kill_sb(). If a kernfs
277 * user needs extra cleanup, it can implement its own kill_sb() and call
278 * this function at the end.
280 void kernfs_kill_sb(struct super_block
*sb
)
282 struct kernfs_super_info
*info
= kernfs_info(sb
);
283 struct kernfs_node
*root_kn
= sb
->s_root
->d_fsdata
;
285 mutex_lock(&kernfs_mutex
);
286 list_del(&info
->node
);
287 mutex_unlock(&kernfs_mutex
);
290 * Remove the superblock from fs_supers/s_instances
291 * so we can't find it, before freeing kernfs_super_info.
299 * kernfs_pin_sb: try to pin the superblock associated with a kernfs_root
300 * @kernfs_root: the kernfs_root in question
301 * @ns: the namespace tag
303 * Pin the superblock so the superblock won't be destroyed in subsequent
304 * operations. This can be used to block ->kill_sb() which may be useful
305 * for kernfs users which dynamically manage superblocks.
307 * Returns NULL if there's no superblock associated to this kernfs_root, or
308 * -EINVAL if the superblock is being freed.
310 struct super_block
*kernfs_pin_sb(struct kernfs_root
*root
, const void *ns
)
312 struct kernfs_super_info
*info
;
313 struct super_block
*sb
= NULL
;
315 mutex_lock(&kernfs_mutex
);
316 list_for_each_entry(info
, &root
->supers
, node
) {
317 if (info
->ns
== ns
) {
319 if (!atomic_inc_not_zero(&info
->sb
->s_active
))
320 sb
= ERR_PTR(-EINVAL
);
324 mutex_unlock(&kernfs_mutex
);
328 void __init
kernfs_init(void)
330 kernfs_node_cache
= kmem_cache_create("kernfs_node_cache",
331 sizeof(struct kernfs_node
),
332 0, SLAB_PANIC
, NULL
);