mount.c 8.4 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * fs/kernfs/mount.c - kernfs mount implementation
 *
 * Copyright (c) 2001-3 Patrick Mochel
 * Copyright (c) 2007 SUSE Linux Products GmbH
 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
 *
 * This file is released under the GPLv2.
 */
10 11 12 13 14 15 16

#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/init.h>
#include <linux/magic.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
A
Aditya Kali 已提交
17
#include <linux/namei.h>
18
#include <linux/seq_file.h>
19 20 21

#include "kernfs-internal.h"

22
struct kmem_cache *kernfs_node_cache;
23

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
static int kernfs_sop_remount_fs(struct super_block *sb, int *flags, char *data)
{
	struct kernfs_root *root = kernfs_info(sb)->root;
	struct kernfs_syscall_ops *scops = root->syscall_ops;

	if (scops && scops->remount_fs)
		return scops->remount_fs(root, flags, data);
	return 0;
}

static int kernfs_sop_show_options(struct seq_file *sf, struct dentry *dentry)
{
	struct kernfs_root *root = kernfs_root(dentry->d_fsdata);
	struct kernfs_syscall_ops *scops = root->syscall_ops;

	if (scops && scops->show_options)
		return scops->show_options(sf, root);
	return 0;
}

44 45 46 47 48 49 50 51 52 53 54 55
static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry)
{
	struct kernfs_node *node = dentry->d_fsdata;
	struct kernfs_root *root = kernfs_root(node);
	struct kernfs_syscall_ops *scops = root->syscall_ops;

	if (scops && scops->show_path)
		return scops->show_path(sf, node, root);

	return seq_dentry(sf, dentry, " \t\n\\");
}

L
Li Zefan 已提交
56
const struct super_operations kernfs_sops = {
57 58
	.statfs		= simple_statfs,
	.drop_inode	= generic_delete_inode,
59
	.evict_inode	= kernfs_evict_inode,
60 61 62

	.remount_fs	= kernfs_sop_remount_fs,
	.show_options	= kernfs_sop_show_options,
63
	.show_path	= kernfs_sop_show_path,
64 65
};

66 67 68 69 70 71 72 73 74 75 76 77 78 79
/**
 * kernfs_root_from_sb - determine kernfs_root associated with a super_block
 * @sb: the super_block in question
 *
 * Return the kernfs_root associated with @sb.  If @sb is not a kernfs one,
 * %NULL is returned.
 */
struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
{
	if (sb->s_op == &kernfs_sops)
		return kernfs_info(sb)->root;
	return NULL;
}

A
Aditya Kali 已提交
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
/*
 * find the next ancestor in the path down to @child, where @parent was the
 * ancestor whose descendant we want to find.
 *
 * Say the path is /a/b/c/d.  @child is d, @parent is NULL.  We return the root
 * node.  If @parent is b, then we return the node for c.
 * Passing in d as @parent is not ok.
 */
static struct kernfs_node *find_next_ancestor(struct kernfs_node *child,
					      struct kernfs_node *parent)
{
	if (child == parent) {
		pr_crit_once("BUG in find_next_ancestor: called with parent == child");
		return NULL;
	}

	while (child->parent != parent) {
		if (!child->parent)
			return NULL;
		child = child->parent;
	}

	return child;
}

/**
 * kernfs_node_dentry - get a dentry for the given kernfs_node
 * @kn: kernfs_node for which a dentry is needed
 * @sb: the kernfs super_block
 */
struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
				  struct super_block *sb)
{
	struct dentry *dentry;
	struct kernfs_node *knparent = NULL;

	BUG_ON(sb->s_op != &kernfs_sops);

	dentry = dget(sb->s_root);

	/* Check if this is the root kernfs_node */
	if (!kn->parent)
		return dentry;

	knparent = find_next_ancestor(kn, NULL);
	if (WARN_ON(!knparent))
		return ERR_PTR(-EINVAL);

	do {
		struct dentry *dtmp;
		struct kernfs_node *kntmp;

		if (kn == knparent)
			return dentry;
		kntmp = find_next_ancestor(kn, knparent);
		if (WARN_ON(!kntmp))
			return ERR_PTR(-EINVAL);
		mutex_lock(&d_inode(dentry)->i_mutex);
		dtmp = lookup_one_len(kntmp->name, dentry, strlen(kntmp->name));
		mutex_unlock(&d_inode(dentry)->i_mutex);
		dput(dentry);
		if (IS_ERR(dtmp))
			return dtmp;
		knparent = kntmp;
		dentry = dtmp;
	} while (true);
}

148
static int kernfs_fill_super(struct super_block *sb, unsigned long magic)
149
{
150
	struct kernfs_super_info *info = kernfs_info(sb);
151 152 153
	struct inode *inode;
	struct dentry *root;

154
	info->sb = sb;
155 156
	sb->s_blocksize = PAGE_SIZE;
	sb->s_blocksize_bits = PAGE_SHIFT;
157
	sb->s_magic = magic;
158
	sb->s_op = &kernfs_sops;
159 160 161
	sb->s_time_gran = 1;

	/* 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);
165
	if (!inode) {
166
		pr_debug("kernfs: could not get root inode\n");
167 168 169 170 171 172 173 174 175
		return -ENOMEM;
	}

	/* instantiate and link root dentry */
	root = d_make_root(inode);
	if (!root) {
		pr_debug("%s: could not get root dentry!\n", __func__);
		return -ENOMEM;
	}
176 177
	kernfs_get(info->root->kn);
	root->d_fsdata = info->root->kn;
178
	sb->s_root = root;
179
	sb->s_d_op = &kernfs_dops;
180 181 182
	return 0;
}

183
static int kernfs_test_super(struct super_block *sb, void *data)
184
{
185 186
	struct kernfs_super_info *sb_info = kernfs_info(sb);
	struct kernfs_super_info *info = data;
187 188 189 190

	return sb_info->root == info->root && sb_info->ns == info->ns;
}

191
static int kernfs_set_super(struct super_block *sb, void *data)
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
{
	int error;
	error = set_anon_super(sb, data);
	if (!error)
		sb->s_fs_info = data;
	return error;
}

/**
 * kernfs_super_ns - determine the namespace tag of a kernfs super_block
 * @sb: super_block of interest
 *
 * Return the namespace tag associated with kernfs super_block @sb.
 */
const void *kernfs_super_ns(struct super_block *sb)
{
208
	struct kernfs_super_info *info = kernfs_info(sb);
209 210 211 212 213 214 215 216 217

	return info->ns;
}

/**
 * kernfs_mount_ns - kernfs mount helper
 * @fs_type: file_system_type of the fs being mounted
 * @flags: mount flags specified for the mount
 * @root: kernfs_root of the hierarchy being mounted
218
 * @magic: file system specific magic number
L
Li Zefan 已提交
219
 * @new_sb_created: tell the caller if we allocated a new superblock
220 221 222 223 224 225 226 227 228 229
 * @ns: optional namespace tag of the mount
 *
 * This is to be called from each kernfs user's file_system_type->mount()
 * implementation, which should pass through the specified @fs_type and
 * @flags, and specify the hierarchy and namespace tag to mount via @root
 * and @ns, respectively.
 *
 * The return value can be passed to the vfs layer verbatim.
 */
struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
230 231
				struct kernfs_root *root, unsigned long magic,
				bool *new_sb_created, const void *ns)
232 233
{
	struct super_block *sb;
234
	struct kernfs_super_info *info;
235 236 237 238 239 240 241 242 243
	int error;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		return ERR_PTR(-ENOMEM);

	info->root = root;
	info->ns = ns;

244
	sb = sget(fs_type, kernfs_test_super, kernfs_set_super, flags, info);
245 246 247 248
	if (IS_ERR(sb) || sb->s_fs_info != info)
		kfree(info);
	if (IS_ERR(sb))
		return ERR_CAST(sb);
L
Li Zefan 已提交
249 250 251 252

	if (new_sb_created)
		*new_sb_created = !sb->s_root;

253
	if (!sb->s_root) {
254 255
		struct kernfs_super_info *info = kernfs_info(sb);

256
		error = kernfs_fill_super(sb, magic);
257 258 259 260 261
		if (error) {
			deactivate_locked_super(sb);
			return ERR_PTR(error);
		}
		sb->s_flags |= MS_ACTIVE;
262 263 264 265

		mutex_lock(&kernfs_mutex);
		list_add(&info->node, &root->supers);
		mutex_unlock(&kernfs_mutex);
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
	}

	return dget(sb->s_root);
}

/**
 * kernfs_kill_sb - kill_sb for kernfs
 * @sb: super_block being killed
 *
 * This can be used directly for file_system_type->kill_sb().  If a kernfs
 * user needs extra cleanup, it can implement its own kill_sb() and call
 * this function at the end.
 */
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;
283

284 285 286 287
	mutex_lock(&kernfs_mutex);
	list_del(&info->node);
	mutex_unlock(&kernfs_mutex);

288 289
	/*
	 * Remove the superblock from fs_supers/s_instances
290
	 * so we can't find it, before freeing kernfs_super_info.
291 292 293
	 */
	kill_anon_super(sb);
	kfree(info);
294
	kernfs_put(root_kn);
295 296
}

L
Li Zefan 已提交
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
/**
 * kernfs_pin_sb: try to pin the superblock associated with a kernfs_root
 * @kernfs_root: the kernfs_root in question
 * @ns: the namespace tag
 *
 * Pin the superblock so the superblock won't be destroyed in subsequent
 * operations.  This can be used to block ->kill_sb() which may be useful
 * for kernfs users which dynamically manage superblocks.
 *
 * Returns NULL if there's no superblock associated to this kernfs_root, or
 * -EINVAL if the superblock is being freed.
 */
struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns)
{
	struct kernfs_super_info *info;
	struct super_block *sb = NULL;

	mutex_lock(&kernfs_mutex);
	list_for_each_entry(info, &root->supers, node) {
		if (info->ns == ns) {
			sb = info->sb;
			if (!atomic_inc_not_zero(&info->sb->s_active))
				sb = ERR_PTR(-EINVAL);
			break;
		}
	}
	mutex_unlock(&kernfs_mutex);
	return sb;
}

327 328
void __init kernfs_init(void)
{
329
	kernfs_node_cache = kmem_cache_create("kernfs_node_cache",
330
					      sizeof(struct kernfs_node),
331 332
					      0, SLAB_PANIC, NULL);
}