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
 18#include "kernfs-internal.h"
 19
 20struct kmem_cache *kernfs_node_cache;
 21
 22static int kernfs_sop_remount_fs(struct super_block *sb, int *flags, char *data)
 23{
 24	struct kernfs_root *root = kernfs_info(sb)->root;
 25	struct kernfs_syscall_ops *scops = root->syscall_ops;
 26
 27	if (scops && scops->remount_fs)
 28		return scops->remount_fs(root, flags, data);
 29	return 0;
 30}
 31
 32static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry)
 33{
 34	struct kernfs_root *root = kernfs_root(dentry->d_fsdata);
 35	struct kernfs_syscall_ops *scops = root->syscall_ops;
 36
 37	if (scops && scops->show_options)
 38		return scops->show_options(sf, root);
 39	return 0;
 40}
 41
 42const struct super_operations kernfs_sops = {
 43	.statfs		= simple_statfs,
 44	.drop_inode	= generic_delete_inode,
 45	.evict_inode	= kernfs_evict_inode,
 46
 47	.remount_fs	= kernfs_sop_remount_fs,
 48	.show_options	= kernfs_sop_show_options,
 49};
 50
 51/**
 52 * kernfs_root_from_sb - determine kernfs_root associated with a super_block
 53 * @sb: the super_block in question
 54 *
 55 * Return the kernfs_root associated with @sb.  If @sb is not a kernfs one,
 56 * %NULL is returned.
 57 */
 58struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
 59{
 60	if (sb->s_op == &kernfs_sops)
 61		return kernfs_info(sb)->root;
 62	return NULL;
 63}
 64
 65static int kernfs_fill_super(struct super_block *sb, unsigned long magic)
 66{
 67	struct kernfs_super_info *info = kernfs_info(sb);
 68	struct inode *inode;
 69	struct dentry *root;
 70
 71	sb->s_blocksize = PAGE_CACHE_SIZE;
 72	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 73	sb->s_magic = magic;
 74	sb->s_op = &kernfs_sops;
 75	sb->s_time_gran = 1;
 76
 77	/* get root inode, initialize and unlock it */
 78	mutex_lock(&kernfs_mutex);
 79	inode = kernfs_get_inode(sb, info->root->kn);
 80	mutex_unlock(&kernfs_mutex);
 81	if (!inode) {
 82		pr_debug("kernfs: could not get root inode\n");
 83		return -ENOMEM;
 84	}
 85
 86	/* instantiate and link root dentry */
 87	root = d_make_root(inode);
 88	if (!root) {
 89		pr_debug("%s: could not get root dentry!\n", __func__);
 90		return -ENOMEM;
 91	}
 92	kernfs_get(info->root->kn);
 93	root->d_fsdata = info->root->kn;
 94	sb->s_root = root;
 95	sb->s_d_op = &kernfs_dops;
 96	return 0;
 97}
 98
 99static int kernfs_test_super(struct super_block *sb, void *data)
100{
101	struct kernfs_super_info *sb_info = kernfs_info(sb);
102	struct kernfs_super_info *info = data;
103
104	return sb_info->root == info->root && sb_info->ns == info->ns;
105}
106
107static int kernfs_set_super(struct super_block *sb, void *data)
108{
109	int error;
110	error = set_anon_super(sb, data);
111	if (!error)
112		sb->s_fs_info = data;
113	return error;
114}
115
116/**
117 * kernfs_super_ns - determine the namespace tag of a kernfs super_block
118 * @sb: super_block of interest
119 *
120 * Return the namespace tag associated with kernfs super_block @sb.
121 */
122const void *kernfs_super_ns(struct super_block *sb)
123{
124	struct kernfs_super_info *info = kernfs_info(sb);
125
126	return info->ns;
127}
128
129/**
130 * kernfs_mount_ns - kernfs mount helper
131 * @fs_type: file_system_type of the fs being mounted
132 * @flags: mount flags specified for the mount
133 * @root: kernfs_root of the hierarchy being mounted
134 * @magic: file system specific magic number
135 * @new_sb_created: tell the caller if we allocated a new superblock
136 * @ns: optional namespace tag of the mount
137 *
138 * This is to be called from each kernfs user's file_system_type->mount()
139 * implementation, which should pass through the specified @fs_type and
140 * @flags, and specify the hierarchy and namespace tag to mount via @root
141 * and @ns, respectively.
142 *
143 * The return value can be passed to the vfs layer verbatim.
144 */
145struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
146				struct kernfs_root *root, unsigned long magic,
147				bool *new_sb_created, const void *ns)
148{
149	struct super_block *sb;
150	struct kernfs_super_info *info;
151	int error;
152
153	info = kzalloc(sizeof(*info), GFP_KERNEL);
154	if (!info)
155		return ERR_PTR(-ENOMEM);
156
157	info->root = root;
158	info->ns = ns;
159
160	sb = sget(fs_type, kernfs_test_super, kernfs_set_super, flags, info);
161	if (IS_ERR(sb) || sb->s_fs_info != info)
162		kfree(info);
163	if (IS_ERR(sb))
164		return ERR_CAST(sb);
165
166	if (new_sb_created)
167		*new_sb_created = !sb->s_root;
168
169	if (!sb->s_root) {
170		error = kernfs_fill_super(sb, magic);
171		if (error) {
172			deactivate_locked_super(sb);
173			return ERR_PTR(error);
174		}
175		sb->s_flags |= MS_ACTIVE;
176	}
177
178	return dget(sb->s_root);
179}
180
181/**
182 * kernfs_kill_sb - kill_sb for kernfs
183 * @sb: super_block being killed
184 *
185 * This can be used directly for file_system_type->kill_sb().  If a kernfs
186 * user needs extra cleanup, it can implement its own kill_sb() and call
187 * this function at the end.
188 */
189void kernfs_kill_sb(struct super_block *sb)
190{
191	struct kernfs_super_info *info = kernfs_info(sb);
192	struct kernfs_node *root_kn = sb->s_root->d_fsdata;
193
194	/*
195	 * Remove the superblock from fs_supers/s_instances
196	 * so we can't find it, before freeing kernfs_super_info.
197	 */
198	kill_anon_super(sb);
199	kfree(info);
200	kernfs_put(root_kn);
201}
202
203void __init kernfs_init(void)
204{
205	kernfs_node_cache = kmem_cache_create("kernfs_node_cache",
206					      sizeof(struct kernfs_node),
207					      0, SLAB_PANIC, NULL);
208	kernfs_inode_init();
209}